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.14 by jsr166, Sat Nov 21 02:39:41 2009 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 12 | Line 12 | import java.util.concurrent.*;
12
13		public class LinkedListTest extends JSR166TestCase {
14		public static void main(String[] args) {
15	<	junit.textui.TestRunner.run (suite());
15	>	junit.textui.TestRunner.run(suite());
16		}
17
18		public static Test suite() {
#	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 56 | Line 56 | public class LinkedListTest extends JSR1
56		public void testConstructor6() {
57		Integer[] ints = new Integer[SIZE];
58		for (int i = 0; i < SIZE; ++i)
59	<	ints[i] = new Integer(i);
59	>	ints[i] = i;
60		LinkedList q = new LinkedList(Arrays.asList(ints));
61		for (int i = 0; i < SIZE; ++i)
62		assertEquals(ints[i], q.poll());
#	Line 137 | Line 137 | public class LinkedListTest extends JSR1
137		Integer[] empty = new Integer[0];
138		Integer[] ints = new Integer[SIZE];
139		for (int i = 0; i < SIZE; ++i)
140	<	ints[i] = new Integer(i);
140	>	ints[i] = i;
141		LinkedList q = new LinkedList();
142		assertFalse(q.addAll(Arrays.asList(empty)));
143		assertTrue(q.addAll(Arrays.asList(ints)));
#	Line 156 | Line 156 | public class LinkedListTest extends JSR1
156		try {
157		l.addAll(4,m);
158		shouldThrow();
159	<	} catch (IndexOutOfBoundsException  success) {}
159	>	} catch (IndexOutOfBoundsException success) {}
160		}
161
162		/**
#	Line 170 | Line 170 | public class LinkedListTest extends JSR1
170		try {
171		l.addAll(-1,m);
172		shouldThrow();
173	<	} catch (IndexOutOfBoundsException  success) {}
173	>	} catch (IndexOutOfBoundsException success) {}
174		}
175
176		/**
177	<	*  poll succeeds unless empty
177	>	* poll succeeds unless empty
178		*/
179		public void testPoll() {
180		LinkedList q = populatedQueue(SIZE);
181		for (int i = 0; i < SIZE; ++i) {
182	<	assertEquals(i, ((Integer)q.poll()).intValue());
182	>	assertEquals(i, q.poll());
183		}
184		assertNull(q.poll());
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);
192		for (int i = 0; i < SIZE; ++i) {
193	<	assertEquals(i, ((Integer)q.peek()).intValue());
194	<	q.poll();
193	>	assertEquals(i, q.peek());
194	>	assertEquals(i, q.poll());
195		assertTrue(q.peek() == null ||
196	<	i != ((Integer)q.peek()).intValue());
196	>	!q.peek().equals(i));
197		}
198		assertNull(q.peek());
199		}
#	Line 204 | Line 204 | public class LinkedListTest extends JSR1
204		public void testElement() {
205		LinkedList q = populatedQueue(SIZE);
206		for (int i = 0; i < SIZE; ++i) {
207	<	assertEquals(i, ((Integer)q.element()).intValue());
208	<	q.poll();
207	>	assertEquals(i, q.element());
208	>	assertEquals(i, q.poll());
209		}
210		try {
211		q.element();
#	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);
221		for (int i = 0; i < SIZE; ++i) {
222	<	assertEquals(i, ((Integer)q.remove()).intValue());
222	>	assertEquals(i, q.remove());
223		}
224		try {
225		q.remove();
#	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 262 | Line 268 | public class LinkedListTest extends JSR1
268		q.clear();
269		assertTrue(q.isEmpty());
270		assertEquals(0, q.size());
271	<	q.add(new Integer(1));
271	>	assertTrue(q.add(new Integer(1)));
272		assertFalse(q.isEmpty());
273		q.clear();
274		assertTrue(q.isEmpty());
#	Line 277 | Line 283 | public class LinkedListTest extends JSR1
283		for (int i = 0; i < SIZE; ++i) {
284		assertTrue(q.containsAll(p));
285		assertFalse(p.containsAll(q));
286	<	p.add(new Integer(i));
286	>	assertTrue(p.add(new Integer(i)));
287		}
288		assertTrue(p.containsAll(q));
289		}
#	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	<	LinkedList l = new LinkedList();
349	<	l.add(new Object());
350	<	Object o[] = l.toArray(null);
355	>	l.toArray(null);
356		shouldThrow();
357		} catch (NullPointerException success) {}
358		}
359
360		/**
361	<	* toArray with incompatable aray 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	<	LinkedList l = new LinkedList();
361	<	l.add(new Integer(5));
362	<	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 388 | Line 393 | public class LinkedListTest extends JSR1
393		q.add(new Integer(3));
394		int k = 0;
395		for (Iterator it = q.iterator(); it.hasNext();) {
396	<	int i = ((Integer)(it.next())).intValue();
392	<	assertEquals(++k, i);
396	>	assertEquals(++k, it.next());
397		}
398
399		assertEquals(3, k);
#	Line 398 | Line 402 | public class LinkedListTest extends JSR1
402		/**
403		* iterator.remove removes current element
404		*/
405	<	public void testIteratorRemove () {
405	>	public void testIteratorRemove() {
406		final LinkedList q = new LinkedList();
407		q.add(new Integer(1));
408		q.add(new Integer(2));
409		q.add(new Integer(3));
410		Iterator it = q.iterator();
411	<	it.next();
411	>	assertEquals(it.next(), 1);
412		it.remove();
413		it = q.iterator();
414	<	assertEquals(it.next(), new Integer(2));
415	<	assertEquals(it.next(), new Integer(3));
414	>	assertEquals(it.next(), 2);
415	>	assertEquals(it.next(), 3);
416		assertFalse(it.hasNext());
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 432 | 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 441 | Line 445 | public class LinkedListTest extends JSR1
445		q.add(new Integer(1));
446		int k = 0;
447		for (Iterator it = q.descendingIterator(); it.hasNext();) {
448	<	int i = ((Integer)(it.next())).intValue();
445	<	assertEquals(++k, i);
448	>	assertEquals(++k, it.next());
449		}
450
451		assertEquals(3, k);
#	Line 451 | Line 454 | public class LinkedListTest extends JSR1
454		/**
455		* descendingIterator.remove removes current element
456		*/
457	<	public void testDescendingIteratorRemove () {
457	>	public void testDescendingIteratorRemove() {
458		final LinkedList q = new LinkedList();
459	<	q.add(new Integer(3));
460	<	q.add(new Integer(2));
461	<	q.add(new Integer(1));
459	>	q.add(three);
460	>	q.add(two);
461	>	q.add(one);
462		Iterator it = q.descendingIterator();
463		it.next();
464		it.remove();
465		it = q.descendingIterator();
466	<	assertEquals(it.next(), new Integer(2));
467	<	assertEquals(it.next(), new Integer(3));
466	>	assertSame(it.next(), two);
467	>	assertSame(it.next(), three);
468		assertFalse(it.hasNext());
469		}
470
468	–
471		/**
472		* toString contains toStrings of elements
473		*/
#	Line 473 | 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 483 | Line 485 | public class LinkedListTest extends JSR1
485		public void testAddFirst() {
486		LinkedList q = populatedQueue(3);
487		q.addFirst(four);
488	<	assertEquals(four,q.peek());
488	>	assertSame(four, q.peek());
489		}
490
491		/**
#	Line 491 | Line 493 | public class LinkedListTest extends JSR1
493		*/
494		public void testPush() {
495		LinkedList q = populatedQueue(3);
494	–	q.pollLast();
496		q.push(four);
497	<	assertEquals(four,q.peekFirst());
497	>	assertSame(four, q.peekFirst());
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);
505		for (int i = 0; i < SIZE; ++i) {
506	<	assertEquals(i, ((Integer)q.pop()).intValue());
506	>	assertEquals(i, q.pop());
507		}
508		try {
509		q.pop();
#	Line 529 | 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);
537		for (int i = SIZE-1; i >= 0; --i) {
538	<	assertEquals(i, ((Integer)q.pollLast()).intValue());
538	>	assertEquals(i, q.pollLast());
539		}
540		assertNull(q.pollLast());
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);
548		for (int i = 0; i < SIZE; ++i) {
549	<	assertEquals(i, ((Integer)q.peekFirst()).intValue());
550	<	q.pollFirst();
549	>	assertEquals(i, q.peekFirst());
550	>	assertEquals(i, q.pollFirst());
551		assertTrue(q.peekFirst() == null ||
552	<	i != ((Integer)q.peekFirst()).intValue());
552	>	!q.peekFirst().equals(i));
553		}
554		assertNull(q.peekFirst());
555		}
556
556	–
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);
562		for (int i = SIZE-1; i >= 0; --i) {
563	<	assertEquals(i, ((Integer)q.peekLast()).intValue());
564	<	q.pollLast();
563	>	assertEquals(i, q.peekLast());
564	>	assertEquals(i, q.pollLast());
565		assertTrue(q.peekLast() == null ||
566	<	i != ((Integer)q.peekLast()).intValue());
566	>	!q.peekLast().equals(i));
567		}
568		assertNull(q.peekLast());
569		}
#	Line 571 | Line 571 | public class LinkedListTest extends JSR1
571		public void testFirstElement() {
572		LinkedList q = populatedQueue(SIZE);
573		for (int i = 0; i < SIZE; ++i) {
574	<	assertEquals(i, ((Integer)q.getFirst()).intValue());
575	<	q.pollFirst();
574	>	assertEquals(i, q.getFirst());
575	>	assertEquals(i, q.pollFirst());
576		}
577		try {
578		q.getFirst();
#	Line 581 | 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);
588		for (int i = SIZE-1; i >= 0; --i) {
589	<	assertEquals(i, ((Integer)q.getLast()).intValue());
590	<	q.pollLast();
589	>	assertEquals(i, q.getLast());
590	>	assertEquals(i, q.pollLast());
591		}
592		try {
593		q.getLast();

Diff Legend

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