ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/LinkedListTest.java

Comparing jsr166/src/test/tck/LinkedListTest.java (file contents):
Revision 1.19 by jsr166, Wed Aug 25 00:07:03 2010 UTC vs.
Revision 1.27 by jsr166, Fri May 27 19:14:39 2011 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		* Other contributors include Andrew Wright, Jeffrey Hayes,
6		* Pat Fisher, Mike Judd.
7		*/
#	Line 23 | Line 23 | public class LinkedListTest extends JSR1
23		* Create a queue of given size containing consecutive
24		* Integers 0 ... n.
25		*/
26	<	private LinkedList populatedQueue(int n) {
27	<	LinkedList q = new LinkedList();
26	>	private LinkedList<Integer> populatedQueue(int n) {
27	>	LinkedList<Integer> q = new LinkedList<Integer>();
28		assertTrue(q.isEmpty());
29		for (int i = 0; i < n; ++i)
30		assertTrue(q.offer(new Integer(i)));
#	Line 174 | Line 174 | public class LinkedListTest extends JSR1
174		}
175
176		/**
177	<	*  poll succeeds unless empty
177	>	* poll succeeds unless empty
178		*/
179		public void testPoll() {
180		LinkedList q = populatedQueue(SIZE);
#	Line 185 | Line 185 | public class LinkedListTest extends JSR1
185		}
186
187		/**
188	<	*  peek returns next element, or null if empty
188	>	* peek returns next element, or null if empty
189		*/
190		public void testPeek() {
191		LinkedList q = populatedQueue(SIZE);
#	Line 214 | Line 214 | public class LinkedListTest extends JSR1
214		}
215
216		/**
217	<	*  remove removes next element, or throws NSEE if empty
217	>	* remove removes next element, or throws NSEE if empty
218		*/
219		public void testRemove() {
220		LinkedList q = populatedQueue(SIZE);
#	Line 233 | Line 233 | public class LinkedListTest extends JSR1
233		public void testRemoveElement() {
234		LinkedList q = populatedQueue(SIZE);
235		for (int i = 1; i < SIZE; i+=2) {
236	<	assertTrue(q.remove(new Integer(i)));
236	>	assertTrue(q.contains(i));
237	>	assertTrue(q.remove((Integer)i));
238	>	assertFalse(q.contains(i));
239	>	assertTrue(q.contains(i-1));
240		}
241		for (int i = 0; i < SIZE; i+=2) {
242	<	assertTrue(q.remove(new Integer(i)));
243	<	assertFalse(q.remove(new Integer(i+1)));
242	>	assertTrue(q.contains(i));
243	>	assertTrue(q.remove((Integer)i));
244	>	assertFalse(q.contains(i));
245	>	assertFalse(q.remove((Integer)(i+1)));
246	>	assertFalse(q.contains(i+1));
247		}
248		assertTrue(q.isEmpty());
249		}
#	Line 318 | Line 324 | public class LinkedListTest extends JSR1
324		}
325
326		/**
327	<	*  toArray contains all elements
327	>	* toArray contains all elements in FIFO order
328		*/
329		public void testToArray() {
330		LinkedList q = populatedQueue(SIZE);
331		Object[] o = q.toArray();
326	–	Arrays.sort(o);
332		for (int i = 0; i < o.length; i++)
333	<	assertEquals(o[i], q.poll());
333	>	assertSame(o[i], q.poll());
334		}
335
336		/**
337	<	*  toArray(a) contains all elements
337	>	* toArray(a) contains all elements in FIFO order
338		*/
339		public void testToArray2() {
340	<	LinkedList q = populatedQueue(SIZE);
340	>	LinkedList<Integer> q = populatedQueue(SIZE);
341		Integer[] ints = new Integer[SIZE];
342	<	ints = (Integer[])q.toArray(ints);
343	<	Arrays.sort(ints);
342	>	Integer[] array = q.toArray(ints);
343	>	assertSame(ints, array);
344		for (int i = 0; i < ints.length; i++)
345	<	assertEquals(ints[i], q.poll());
345	>	assertSame(ints[i], q.poll());
346		}
347
348		/**
349	<	* toArray(null) throws NPE
349	>	* toArray(null) throws NullPointerException
350		*/
351	<	public void testToArray_BadArg() {
351	>	public void testToArray_NullArg() {
352		LinkedList l = new LinkedList();
353		l.add(new Object());
354		try {
355	<	Object o[] = l.toArray(null);
355	>	l.toArray(null);
356		shouldThrow();
357		} catch (NullPointerException success) {}
358		}
359
360		/**
361	<	* toArray with incompatible array type throws CCE
361	>	* toArray(incompatible array type) throws ArrayStoreException
362		*/
363		public void testToArray1_BadArg() {
364		LinkedList l = new LinkedList();
365		l.add(new Integer(5));
366		try {
367	<	Object o[] = l.toArray(new String[10]);
367	>	l.toArray(new String[10]);
368		shouldThrow();
369		} catch (ArrayStoreException success) {}
370		}
371
372		/**
373	<	*  iterator iterates through all elements
373	>	* iterator iterates through all elements
374		*/
375		public void testIterator() {
376		LinkedList q = populatedQueue(SIZE);
#	Line 379 | Line 384 | public class LinkedListTest extends JSR1
384		}
385
386		/**
387	<	*  iterator ordering is FIFO
387	>	* iterator ordering is FIFO
388		*/
389		public void testIteratorOrdering() {
390		final LinkedList q = new LinkedList();
#	Line 412 | Line 417 | public class LinkedListTest extends JSR1
417		}
418
419		/**
420	<	*  Descending iterator iterates through all elements
420	>	* Descending iterator iterates through all elements
421		*/
422		public void testDescendingIterator() {
423		LinkedList q = populatedQueue(SIZE);
#	Line 431 | Line 436 | public class LinkedListTest extends JSR1
436		}
437
438		/**
439	<	*  Descending iterator ordering is reverse FIFO
439	>	* Descending iterator ordering is reverse FIFO
440		*/
441		public void testDescendingIteratorOrdering() {
442		final LinkedList q = new LinkedList();
#	Line 463 | Line 468 | public class LinkedListTest extends JSR1
468		assertFalse(it.hasNext());
469		}
470
466	–
471		/**
472		* toString contains toStrings of elements
473		*/
#	Line 471 | Line 475 | public class LinkedListTest extends JSR1
475		LinkedList q = populatedQueue(SIZE);
476		String s = q.toString();
477		for (int i = 0; i < SIZE; ++i) {
478	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
478	>	assertTrue(s.contains(String.valueOf(i)));
479		}
480		}
481
#	Line 494 | Line 498 | public class LinkedListTest extends JSR1
498		}
499
500		/**
501	<	*  pop removes next element, or throws NSEE if empty
501	>	* pop removes next element, or throws NSEE if empty
502		*/
503		public void testPop() {
504		LinkedList q = populatedQueue(SIZE);
#	Line 526 | Line 530 | public class LinkedListTest extends JSR1
530		}
531
532		/**
533	<	*  pollLast succeeds unless empty
533	>	* pollLast succeeds unless empty
534		*/
535		public void testPollLast() {
536		LinkedList q = populatedQueue(SIZE);
#	Line 537 | Line 541 | public class LinkedListTest extends JSR1
541		}
542
543		/**
544	<	*  peekFirst returns next element, or null if empty
544	>	* peekFirst returns next element, or null if empty
545		*/
546		public void testPeekFirst() {
547		LinkedList q = populatedQueue(SIZE);
#	Line 550 | Line 554 | public class LinkedListTest extends JSR1
554		assertNull(q.peekFirst());
555		}
556
553	–
557		/**
558	<	*  peekLast returns next element, or null if empty
558	>	* peekLast returns next element, or null if empty
559		*/
560		public void testPeekLast() {
561		LinkedList q = populatedQueue(SIZE);
#	Line 578 | Line 581 | public class LinkedListTest extends JSR1
581		}
582
583		/**
584	<	*  getLast returns next element, or throws NSEE if empty
584	>	* getLast returns next element, or throws NSEE if empty
585		*/
586		public void testLastElement() {
587		LinkedList q = populatedQueue(SIZE);

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines