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.16 by jsr166, Sun Nov 22 18:57:17 2009 UTC vs.
Revision 1.44 by jsr166, Wed Jan 4 06:09:58 2017 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		*/
8
9	<	import junit.framework.*;
10	<	import java.util.*;
11	<	import java.util.concurrent.*;
9	>	import java.util.Arrays;
10	>	import java.util.Collection;
11	>	import java.util.Iterator;
12	>	import java.util.LinkedList;
13	>	import java.util.NoSuchElementException;
14	>
15	>	import junit.framework.Test;
16	>	import junit.framework.TestSuite;
17
18		public class LinkedListTest extends JSR166TestCase {
19		public static void main(String[] args) {
20	<	junit.textui.TestRunner.run (suite());
20	>	main(suite(), args);
21		}
22
23		public static Test suite() {
24	<	return new TestSuite(LinkedListTest.class);
24	>	class Implementation implements CollectionImplementation {
25	>	public Class<?> klazz() { return LinkedList.class; }
26	>	public Collection emptyCollection() { return new LinkedList(); }
27	>	public Object makeElement(int i) { return i; }
28	>	public boolean isConcurrent() { return false; }
29	>	public boolean permitsNulls() { return true; }
30	>	}
31	>	class SubListImplementation extends Implementation {
32	>	public Collection emptyCollection() {
33	>	return new LinkedList().subList(0, 0);
34	>	}
35	>	}
36	>	return newTestSuite(
37	>	LinkedListTest.class,
38	>	CollectionTest.testSuite(new Implementation()),
39	>	CollectionTest.testSuite(new SubListImplementation()));
40		}
41
42		/**
43	<	* Create a queue of given size containing consecutive
44	<	* Integers 0 ... n.
43	>	* Returns a new queue of given size containing consecutive
44	>	* Integers 0 ... n - 1.
45		*/
46	<	private LinkedList populatedQueue(int n) {
47	<	LinkedList q = new LinkedList();
46	>	private LinkedList<Integer> populatedQueue(int n) {
47	>	LinkedList<Integer> q = new LinkedList<>();
48		assertTrue(q.isEmpty());
49		for (int i = 0; i < n; ++i)
50		assertTrue(q.offer(new Integer(i)));
51		assertFalse(q.isEmpty());
52		assertEquals(n, q.size());
53	+	assertEquals((Integer) 0, q.peekFirst());
54	+	assertEquals((Integer) (n - 1), q.peekLast());
55		return q;
56		}
57
#	Line 45 | Line 67 | public class LinkedListTest extends JSR1
67		*/
68		public void testConstructor3() {
69		try {
70	<	LinkedList q = new LinkedList((Collection)null);
70	>	new LinkedList((Collection)null);
71		shouldThrow();
72		} catch (NullPointerException success) {}
73		}
#	Line 82 | Line 104 | public class LinkedListTest extends JSR1
104		public void testSize() {
105		LinkedList q = populatedQueue(SIZE);
106		for (int i = 0; i < SIZE; ++i) {
107	<	assertEquals(SIZE-i, q.size());
107	>	assertEquals(SIZE - i, q.size());
108		q.remove();
109		}
110		for (int i = 0; i < SIZE; ++i) {
#	Line 97 | Line 119 | public class LinkedListTest extends JSR1
119		public void testOfferNull() {
120		LinkedList q = new LinkedList();
121		q.offer(null);
122	+	assertNull(q.get(0));
123	+	assertTrue(q.contains(null));
124		}
125
126		/**
#	Line 123 | Line 147 | public class LinkedListTest extends JSR1
147		* addAll(null) throws NPE
148		*/
149		public void testAddAll1() {
150	+	LinkedList q = new LinkedList();
151		try {
127	–	LinkedList q = new LinkedList();
152		q.addAll(null);
153		shouldThrow();
154		} catch (NullPointerException success) {}
#	Line 174 | Line 198 | public class LinkedListTest extends JSR1
198		}
199
200		/**
201	<	*  poll succeeds unless empty
201	>	* poll succeeds unless empty
202		*/
203		public void testPoll() {
204		LinkedList q = populatedQueue(SIZE);
#	Line 185 | Line 209 | public class LinkedListTest extends JSR1
209		}
210
211		/**
212	<	*  peek returns next element, or null if empty
212	>	* peek returns next element, or null if empty
213		*/
214		public void testPeek() {
215		LinkedList q = populatedQueue(SIZE);
#	Line 214 | Line 238 | public class LinkedListTest extends JSR1
238		}
239
240		/**
241	<	*  remove removes next element, or throws NSEE if empty
241	>	* remove removes next element, or throws NSEE if empty
242		*/
243		public void testRemove() {
244		LinkedList q = populatedQueue(SIZE);
#	Line 232 | Line 256 | public class LinkedListTest extends JSR1
256		*/
257		public void testRemoveElement() {
258		LinkedList q = populatedQueue(SIZE);
259	<	for (int i = 1; i < SIZE; i+=2) {
260	<	assertTrue(q.remove(new Integer(i)));
261	<	}
262	<	for (int i = 0; i < SIZE; i+=2) {
263	<	assertTrue(q.remove(new Integer(i)));
264	<	assertFalse(q.remove(new Integer(i+1)));
259	>	for (int i = 1; i < SIZE; i += 2) {
260	>	assertTrue(q.contains(i));
261	>	assertTrue(q.remove((Integer)i));
262	>	assertFalse(q.contains(i));
263	>	assertTrue(q.contains(i - 1));
264	>	}
265	>	for (int i = 0; i < SIZE; i += 2) {
266	>	assertTrue(q.contains(i));
267	>	assertTrue(q.remove((Integer)i));
268	>	assertFalse(q.contains(i));
269	>	assertFalse(q.remove((Integer)(i + 1)));
270	>	assertFalse(q.contains(i + 1));
271		}
272		assertTrue(q.isEmpty());
273		}
#	Line 296 | Line 326 | public class LinkedListTest extends JSR1
326		assertTrue(changed);
327
328		assertTrue(q.containsAll(p));
329	<	assertEquals(SIZE-i, q.size());
329	>	assertEquals(SIZE - i, q.size());
330		p.remove();
331		}
332		}
#	Line 309 | Line 339 | public class LinkedListTest extends JSR1
339		LinkedList q = populatedQueue(SIZE);
340		LinkedList p = populatedQueue(i);
341		assertTrue(q.removeAll(p));
342	<	assertEquals(SIZE-i, q.size());
342	>	assertEquals(SIZE - i, q.size());
343		for (int j = 0; j < i; ++j) {
344	<	Integer I = (Integer)(p.remove());
345	<	assertFalse(q.contains(I));
344	>	Integer x = (Integer)(p.remove());
345	>	assertFalse(q.contains(x));
346		}
347		}
348		}
349
350		/**
351	<	*  toArray contains all elements
351	>	* toArray contains all elements in FIFO order
352		*/
353		public void testToArray() {
354		LinkedList q = populatedQueue(SIZE);
355		Object[] o = q.toArray();
326	–	Arrays.sort(o);
356		for (int i = 0; i < o.length; i++)
357	<	assertEquals(o[i], q.poll());
357	>	assertSame(o[i], q.poll());
358		}
359
360		/**
361	<	*  toArray(a) contains all elements
361	>	* toArray(a) contains all elements in FIFO order
362		*/
363		public void testToArray2() {
364	<	LinkedList q = populatedQueue(SIZE);
364	>	LinkedList<Integer> q = populatedQueue(SIZE);
365		Integer[] ints = new Integer[SIZE];
366	<	ints = (Integer[])q.toArray(ints);
367	<	Arrays.sort(ints);
366	>	Integer[] array = q.toArray(ints);
367	>	assertSame(ints, array);
368		for (int i = 0; i < ints.length; i++)
369	<	assertEquals(ints[i], q.poll());
369	>	assertSame(ints[i], q.poll());
370		}
371
372		/**
373	<	* toArray(null) throws NPE
373	>	* toArray(null) throws NullPointerException
374		*/
375	<	public void testToArray_BadArg() {
375	>	public void testToArray_NullArg() {
376		LinkedList l = new LinkedList();
377		l.add(new Object());
378		try {
379	<	Object o[] = l.toArray(null);
379	>	l.toArray(null);
380		shouldThrow();
381		} catch (NullPointerException success) {}
382		}
383
384		/**
385	<	* toArray with incompatable aray type throws CCE
385	>	* toArray(incompatible array type) throws ArrayStoreException
386		*/
387		public void testToArray1_BadArg() {
388		LinkedList l = new LinkedList();
389		l.add(new Integer(5));
390		try {
391	<	Object o[] = l.toArray(new String[10]);
391	>	l.toArray(new String[10]);
392		shouldThrow();
393		} catch (ArrayStoreException success) {}
394		}
395
396		/**
397	<	*  iterator iterates through all elements
397	>	* iterator iterates through all elements
398		*/
399		public void testIterator() {
400		LinkedList q = populatedQueue(SIZE);
372	–	int i = 0;
401		Iterator it = q.iterator();
402	<	while (it.hasNext()) {
402	>	int i;
403	>	for (i = 0; it.hasNext(); i++)
404		assertTrue(q.contains(it.next()));
376	–	++i;
377	–	}
405		assertEquals(i, SIZE);
406	+	assertIteratorExhausted(it);
407	+	}
408	+
409	+	/**
410	+	* iterator of empty collection has no elements
411	+	*/
412	+	public void testEmptyIterator() {
413	+	assertIteratorExhausted(new LinkedList().iterator());
414		}
415
416		/**
417	<	*  iterator ordering is FIFO
417	>	* iterator ordering is FIFO
418		*/
419		public void testIteratorOrdering() {
420		final LinkedList q = new LinkedList();
#	Line 397 | Line 432 | public class LinkedListTest extends JSR1
432		/**
433		* iterator.remove removes current element
434		*/
435	<	public void testIteratorRemove () {
435	>	public void testIteratorRemove() {
436		final LinkedList q = new LinkedList();
437		q.add(new Integer(1));
438		q.add(new Integer(2));
439		q.add(new Integer(3));
440		Iterator it = q.iterator();
441	<	assertEquals(it.next(), 1);
441	>	assertEquals(1, it.next());
442		it.remove();
443		it = q.iterator();
444	<	assertEquals(it.next(), 2);
445	<	assertEquals(it.next(), 3);
444	>	assertEquals(2, it.next());
445	>	assertEquals(3, it.next());
446		assertFalse(it.hasNext());
447		}
448
449		/**
450	<	*  Descending iterator iterates through all elements
450	>	* Descending iterator iterates through all elements
451		*/
452		public void testDescendingIterator() {
453		LinkedList q = populatedQueue(SIZE);
#	Line 431 | Line 466 | public class LinkedListTest extends JSR1
466		}
467
468		/**
469	<	*  Descending iterator ordering is reverse FIFO
469	>	* Descending iterator ordering is reverse FIFO
470		*/
471		public void testDescendingIteratorOrdering() {
472		final LinkedList q = new LinkedList();
#	Line 449 | Line 484 | public class LinkedListTest extends JSR1
484		/**
485		* descendingIterator.remove removes current element
486		*/
487	<	public void testDescendingIteratorRemove () {
487	>	public void testDescendingIteratorRemove() {
488		final LinkedList q = new LinkedList();
489	<	q.add(new Integer(3));
490	<	q.add(new Integer(2));
491	<	q.add(new Integer(1));
489	>	q.add(three);
490	>	q.add(two);
491	>	q.add(one);
492		Iterator it = q.descendingIterator();
493		it.next();
494		it.remove();
495		it = q.descendingIterator();
496	<	assertEquals(it.next(), 2);
497	<	assertEquals(it.next(), 3);
496	>	assertSame(it.next(), two);
497	>	assertSame(it.next(), three);
498		assertFalse(it.hasNext());
499		}
500
466	–
501		/**
502		* toString contains toStrings of elements
503		*/
#	Line 471 | Line 505 | public class LinkedListTest extends JSR1
505		LinkedList q = populatedQueue(SIZE);
506		String s = q.toString();
507		for (int i = 0; i < SIZE; ++i) {
508	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
508	>	assertTrue(s.contains(String.valueOf(i)));
509		}
510		}
511
#	Line 481 | Line 515 | public class LinkedListTest extends JSR1
515		public void testAddFirst() {
516		LinkedList q = populatedQueue(3);
517		q.addFirst(four);
518	<	assertEquals(four,q.peek());
518	>	assertSame(four, q.peek());
519		}
520
521		/**
#	Line 489 | Line 523 | public class LinkedListTest extends JSR1
523		*/
524		public void testPush() {
525		LinkedList q = populatedQueue(3);
492	–	q.pollLast();
526		q.push(four);
527	<	assertEquals(four,q.peekFirst());
527	>	assertSame(four, q.peekFirst());
528		}
529
530		/**
531	<	*  pop removes next element, or throws NSEE if empty
531	>	* pop removes next element, or throws NSEE if empty
532		*/
533		public void testPop() {
534		LinkedList q = populatedQueue(SIZE);
#	Line 527 | Line 560 | public class LinkedListTest extends JSR1
560		}
561
562		/**
563	<	*  pollLast succeeds unless empty
563	>	* pollLast succeeds unless empty
564		*/
565		public void testPollLast() {
566		LinkedList q = populatedQueue(SIZE);
567	<	for (int i = SIZE-1; i >= 0; --i) {
567	>	for (int i = SIZE - 1; i >= 0; --i) {
568		assertEquals(i, q.pollLast());
569		}
570		assertNull(q.pollLast());
571		}
572
573		/**
574	<	*  peekFirst returns next element, or null if empty
574	>	* peekFirst returns next element, or null if empty
575		*/
576		public void testPeekFirst() {
577		LinkedList q = populatedQueue(SIZE);
#	Line 551 | Line 584 | public class LinkedListTest extends JSR1
584		assertNull(q.peekFirst());
585		}
586
554	–
587		/**
588	<	*  peekLast returns next element, or null if empty
588	>	* peekLast returns next element, or null if empty
589		*/
590		public void testPeekLast() {
591		LinkedList q = populatedQueue(SIZE);
592	<	for (int i = SIZE-1; i >= 0; --i) {
592	>	for (int i = SIZE - 1; i >= 0; --i) {
593		assertEquals(i, q.peekLast());
594		assertEquals(i, q.pollLast());
595		assertTrue(q.peekLast() == null ||
#	Line 579 | Line 611 | public class LinkedListTest extends JSR1
611		}
612
613		/**
614	<	*  getLast returns next element, or throws NSEE if empty
614	>	* getLast returns next element, or throws NSEE if empty
615		*/
616		public void testLastElement() {
617		LinkedList q = populatedQueue(SIZE);
618	<	for (int i = SIZE-1; i >= 0; --i) {
618	>	for (int i = SIZE - 1; i >= 0; --i) {
619		assertEquals(i, q.getLast());
620		assertEquals(i, q.pollLast());
621		}
#	Line 599 | Line 631 | public class LinkedListTest extends JSR1
631		*/
632		public void testRemoveFirstOccurrence() {
633		LinkedList q = populatedQueue(SIZE);
634	<	for (int i = 1; i < SIZE; i+=2) {
634	>	for (int i = 1; i < SIZE; i += 2) {
635		assertTrue(q.removeFirstOccurrence(new Integer(i)));
636		}
637	<	for (int i = 0; i < SIZE; i+=2) {
637	>	for (int i = 0; i < SIZE; i += 2) {
638		assertTrue(q.removeFirstOccurrence(new Integer(i)));
639	<	assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
639	>	assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
640		}
641		assertTrue(q.isEmpty());
642		}
#	Line 614 | Line 646 | public class LinkedListTest extends JSR1
646		*/
647		public void testRemoveLastOccurrence() {
648		LinkedList q = populatedQueue(SIZE);
649	<	for (int i = 1; i < SIZE; i+=2) {
649	>	for (int i = 1; i < SIZE; i += 2) {
650		assertTrue(q.removeLastOccurrence(new Integer(i)));
651		}
652	<	for (int i = 0; i < SIZE; i+=2) {
652	>	for (int i = 0; i < SIZE; i += 2) {
653		assertTrue(q.removeLastOccurrence(new Integer(i)));
654	<	assertFalse(q.removeLastOccurrence(new Integer(i+1)));
654	>	assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
655		}
656		assertTrue(q.isEmpty());
657		}

Diff Legend

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