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.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 56 | Line 78 | public class LinkedListTest extends JSR1
78		public void testConstructor6() {
79		Integer[] ints = new Integer[SIZE];
80		for (int i = 0; i < SIZE; ++i)
81	<	ints[i] = new Integer(i);
81	>	ints[i] = i;
82		LinkedList q = new LinkedList(Arrays.asList(ints));
83		for (int i = 0; i < SIZE; ++i)
84		assertEquals(ints[i], q.poll());
#	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 137 | Line 161 | public class LinkedListTest extends JSR1
161		Integer[] empty = new Integer[0];
162		Integer[] ints = new Integer[SIZE];
163		for (int i = 0; i < SIZE; ++i)
164	<	ints[i] = new Integer(i);
164	>	ints[i] = i;
165		LinkedList q = new LinkedList();
166		assertFalse(q.addAll(Arrays.asList(empty)));
167		assertTrue(q.addAll(Arrays.asList(ints)));
#	Line 156 | Line 180 | public class LinkedListTest extends JSR1
180		try {
181		l.addAll(4,m);
182		shouldThrow();
183	<	} catch (IndexOutOfBoundsException  success) {}
183	>	} catch (IndexOutOfBoundsException success) {}
184		}
185
186		/**
#	Line 170 | Line 194 | public class LinkedListTest extends JSR1
194		try {
195		l.addAll(-1,m);
196		shouldThrow();
197	<	} catch (IndexOutOfBoundsException  success) {}
197	>	} catch (IndexOutOfBoundsException success) {}
198		}
199
200		/**
201	<	*  poll succeeds unless empty
201	>	* poll succeeds unless empty
202		*/
203		public void testPoll() {
204		LinkedList q = populatedQueue(SIZE);
205		for (int i = 0; i < SIZE; ++i) {
206	<	assertEquals(i, ((Integer)q.poll()).intValue());
206	>	assertEquals(i, q.poll());
207		}
208		assertNull(q.poll());
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);
216		for (int i = 0; i < SIZE; ++i) {
217	<	assertEquals(i, ((Integer)q.peek()).intValue());
218	<	q.poll();
217	>	assertEquals(i, q.peek());
218	>	assertEquals(i, q.poll());
219		assertTrue(q.peek() == null ||
220	<	i != ((Integer)q.peek()).intValue());
220	>	!q.peek().equals(i));
221		}
222		assertNull(q.peek());
223		}
#	Line 204 | Line 228 | public class LinkedListTest extends JSR1
228		public void testElement() {
229		LinkedList q = populatedQueue(SIZE);
230		for (int i = 0; i < SIZE; ++i) {
231	<	assertEquals(i, ((Integer)q.element()).intValue());
232	<	q.poll();
231	>	assertEquals(i, q.element());
232	>	assertEquals(i, q.poll());
233		}
234		try {
235		q.element();
#	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);
245		for (int i = 0; i < SIZE; ++i) {
246	<	assertEquals(i, ((Integer)q.remove()).intValue());
246	>	assertEquals(i, q.remove());
247		}
248		try {
249		q.remove();
#	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 262 | Line 292 | public class LinkedListTest extends JSR1
292		q.clear();
293		assertTrue(q.isEmpty());
294		assertEquals(0, q.size());
295	<	q.add(new Integer(1));
295	>	assertTrue(q.add(new Integer(1)));
296		assertFalse(q.isEmpty());
297		q.clear();
298		assertTrue(q.isEmpty());
#	Line 277 | Line 307 | public class LinkedListTest extends JSR1
307		for (int i = 0; i < SIZE; ++i) {
308		assertTrue(q.containsAll(p));
309		assertFalse(p.containsAll(q));
310	<	p.add(new Integer(i));
310	>	assertTrue(p.add(new Integer(i)));
311		}
312		assertTrue(p.containsAll(q));
313		}
#	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	<	LinkedList l = new LinkedList();
349	<	l.add(new Object());
350	<	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	<	LinkedList l = new LinkedList();
361	<	l.add(new Integer(5));
362	<	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 388 | Line 423 | public class LinkedListTest extends JSR1
423		q.add(new Integer(3));
424		int k = 0;
425		for (Iterator it = q.iterator(); it.hasNext();) {
426	<	int i = ((Integer)(it.next())).intValue();
392	<	assertEquals(++k, i);
426	>	assertEquals(++k, it.next());
427		}
428
429		assertEquals(3, k);
#	Line 398 | 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	<	it.next();
441	>	assertEquals(1, it.next());
442		it.remove();
443		it = q.iterator();
444	<	assertEquals(it.next(), new Integer(2));
445	<	assertEquals(it.next(), new Integer(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 432 | 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 441 | Line 475 | public class LinkedListTest extends JSR1
475		q.add(new Integer(1));
476		int k = 0;
477		for (Iterator it = q.descendingIterator(); it.hasNext();) {
478	<	int i = ((Integer)(it.next())).intValue();
445	<	assertEquals(++k, i);
478	>	assertEquals(++k, it.next());
479		}
480
481		assertEquals(3, k);
#	Line 451 | 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(), new Integer(2));
497	<	assertEquals(it.next(), new Integer(3));
496	>	assertSame(it.next(), two);
497	>	assertSame(it.next(), three);
498		assertFalse(it.hasNext());
499		}
500
468	–
501		/**
502		* toString contains toStrings of elements
503		*/
#	Line 473 | 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 483 | 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 491 | Line 523 | public class LinkedListTest extends JSR1
523		*/
524		public void testPush() {
525		LinkedList q = populatedQueue(3);
494	–	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);
535		for (int i = 0; i < SIZE; ++i) {
536	<	assertEquals(i, ((Integer)q.pop()).intValue());
536	>	assertEquals(i, q.pop());
537		}
538		try {
539		q.pop();
#	Line 529 | 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) {
568	<	assertEquals(i, ((Integer)q.pollLast()).intValue());
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);
578		for (int i = 0; i < SIZE; ++i) {
579	<	assertEquals(i, ((Integer)q.peekFirst()).intValue());
580	<	q.pollFirst();
579	>	assertEquals(i, q.peekFirst());
580	>	assertEquals(i, q.pollFirst());
581		assertTrue(q.peekFirst() == null ||
582	<	i != ((Integer)q.peekFirst()).intValue());
582	>	!q.peekFirst().equals(i));
583		}
584		assertNull(q.peekFirst());
585		}
586
556	–
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) {
593	<	assertEquals(i, ((Integer)q.peekLast()).intValue());
594	<	q.pollLast();
592	>	for (int i = SIZE - 1; i >= 0; --i) {
593	>	assertEquals(i, q.peekLast());
594	>	assertEquals(i, q.pollLast());
595		assertTrue(q.peekLast() == null ||
596	<	i != ((Integer)q.peekLast()).intValue());
596	>	!q.peekLast().equals(i));
597		}
598		assertNull(q.peekLast());
599		}
#	Line 571 | Line 601 | public class LinkedListTest extends JSR1
601		public void testFirstElement() {
602		LinkedList q = populatedQueue(SIZE);
603		for (int i = 0; i < SIZE; ++i) {
604	<	assertEquals(i, ((Integer)q.getFirst()).intValue());
605	<	q.pollFirst();
604	>	assertEquals(i, q.getFirst());
605	>	assertEquals(i, q.pollFirst());
606		}
607		try {
608		q.getFirst();
#	Line 581 | 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) {
619	<	assertEquals(i, ((Integer)q.getLast()).intValue());
620	<	q.pollLast();
618	>	for (int i = SIZE - 1; i >= 0; --i) {
619	>	assertEquals(i, q.getLast());
620	>	assertEquals(i, q.pollLast());
621		}
622		try {
623		q.getLast();
#	Line 601 | 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 616 | 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