ViewVC Help

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

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

Comparing jsr166/src/test/tck/ArrayDequeTest.java (file contents):
Revision 1.26 by jsr166, Tue Feb 21 02:04:17 2012 UTC vs.
Revision 1.56 by jsr166, Fri Aug 4 03:30:21 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
2	>	* Written by Doug Lea and Martin Buchholz with assistance from
3	>	* members of JCP JSR-166 Expert Group and released to the public
4	>	* domain, as explained at
5		* http://creativecommons.org/publicdomain/zero/1.0/
6		*/
7
7	–	import junit.framework.*;
8	–	import java.util.Arrays;
8		import java.util.ArrayDeque;
9	+	import java.util.Arrays;
10		import java.util.Collection;
11		import java.util.Deque;
12		import java.util.Iterator;
13		import java.util.NoSuchElementException;
14		import java.util.Queue;
15		import java.util.Random;
16	+	import java.util.concurrent.ThreadLocalRandom;
17	+
18	+	import junit.framework.Test;
19
20		public class ArrayDequeTest extends JSR166TestCase {
21		public static void main(String[] args) {
22	<	junit.textui.TestRunner.run(suite());
22	>	main(suite(), args);
23		}
24
25		public static Test suite() {
26	<	return new TestSuite(ArrayDequeTest.class);
26	>	class Implementation implements CollectionImplementation {
27	>	public Class<?> klazz() { return ArrayDeque.class; }
28	>	public Collection emptyCollection() { return populatedDeque(0); }
29	>	public Object makeElement(int i) { return i; }
30	>	public boolean isConcurrent() { return false; }
31	>	public boolean permitsNulls() { return false; }
32	>	}
33	>	return newTestSuite(ArrayDequeTest.class,
34	>	CollectionTest.testSuite(new Implementation()));
35		}
36
37		/**
38		* Returns a new deque of given size containing consecutive
39	<	* Integers 0 ... n.
39	>	* Integers 0 ... n - 1.
40		*/
41	<	private ArrayDeque<Integer> populatedDeque(int n) {
42	<	ArrayDeque<Integer> q = new ArrayDeque<Integer>();
41	>	private static ArrayDeque<Integer> populatedDeque(int n) {
42	>	// Randomize various aspects of memory layout, including
43	>	// capacity slop and wraparound.
44	>	final ArrayDeque<Integer> q;
45	>	ThreadLocalRandom rnd = ThreadLocalRandom.current();
46	>	switch (rnd.nextInt(6)) {
47	>	case 0: q = new ArrayDeque<Integer>();      break;
48	>	case 1: q = new ArrayDeque<Integer>(0);     break;
49	>	case 2: q = new ArrayDeque<Integer>(1);     break;
50	>	case 3: q = new ArrayDeque<Integer>(Math.max(0, n - 1)); break;
51	>	case 4: q = new ArrayDeque<Integer>(n);     break;
52	>	case 5: q = new ArrayDeque<Integer>(n + 1); break;
53	>	default: throw new AssertionError();
54	>	}
55	>	switch (rnd.nextInt(3)) {
56	>	case 0:
57	>	q.addFirst(42);
58	>	assertEquals((Integer) 42, q.removeLast());
59	>	break;
60	>	case 1:
61	>	q.addLast(42);
62	>	assertEquals((Integer) 42, q.removeFirst());
63	>	break;
64	>	case 2: /* do nothing */ break;
65	>	default: throw new AssertionError();
66	>	}
67		assertTrue(q.isEmpty());
68	<	for (int i = 0; i < n; ++i)
69	<	assertTrue(q.offerLast(new Integer(i)));
70	<	assertFalse(q.isEmpty());
68	>	if (rnd.nextBoolean())
69	>	for (int i = 0; i < n; i++)
70	>	assertTrue(q.offerLast((Integer) i));
71	>	else
72	>	for (int i = n; --i >= 0; )
73	>	q.addFirst((Integer) i);
74		assertEquals(n, q.size());
75	+	if (n > 0) {
76	+	assertFalse(q.isEmpty());
77	+	assertEquals((Integer) 0, q.peekFirst());
78	+	assertEquals((Integer) (n - 1), q.peekLast());
79	+	}
80		return q;
81		}
82
#	Line 49 | Line 92 | public class ArrayDequeTest extends JSR1
92		*/
93		public void testConstructor3() {
94		try {
95	<	ArrayDeque q = new ArrayDeque((Collection)null);
95	>	new ArrayDeque((Collection)null);
96		shouldThrow();
97		} catch (NullPointerException success) {}
98		}
#	Line 59 | Line 102 | public class ArrayDequeTest extends JSR1
102		*/
103		public void testConstructor4() {
104		try {
105	<	Integer[] ints = new Integer[SIZE];
63	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
105	>	new ArrayDeque(Arrays.asList(new Integer[SIZE]));
106		shouldThrow();
107		} catch (NullPointerException success) {}
108		}
#	Line 69 | Line 111 | public class ArrayDequeTest extends JSR1
111		* Initializing from Collection with some null elements throws NPE
112		*/
113		public void testConstructor5() {
114	+	Integer[] ints = new Integer[SIZE];
115	+	for (int i = 0; i < SIZE - 1; ++i)
116	+	ints[i] = new Integer(i);
117		try {
118	<	Integer[] ints = new Integer[SIZE];
74	<	for (int i = 0; i < SIZE-1; ++i)
75	<	ints[i] = new Integer(i);
76	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
118	>	new ArrayDeque(Arrays.asList(ints));
119		shouldThrow();
120		} catch (NullPointerException success) {}
121		}
#	Line 110 | Line 152 | public class ArrayDequeTest extends JSR1
152		public void testSize() {
153		ArrayDeque q = populatedDeque(SIZE);
154		for (int i = 0; i < SIZE; ++i) {
155	<	assertEquals(SIZE-i, q.size());
155	>	assertEquals(SIZE - i, q.size());
156		q.removeFirst();
157		}
158		for (int i = 0; i < SIZE; ++i) {
#	Line 123 | Line 165 | public class ArrayDequeTest extends JSR1
165		* push(null) throws NPE
166		*/
167		public void testPushNull() {
168	+	ArrayDeque q = new ArrayDeque(1);
169		try {
127	–	ArrayDeque q = new ArrayDeque(1);
170		q.push(null);
171		shouldThrow();
172		} catch (NullPointerException success) {}
#	Line 158 | Line 200 | public class ArrayDequeTest extends JSR1
200		* offer(null) throws NPE
201		*/
202		public void testOfferNull() {
203	+	ArrayDeque q = new ArrayDeque();
204		try {
162	–	ArrayDeque q = new ArrayDeque();
205		q.offer(null);
206		shouldThrow();
207		} catch (NullPointerException success) {}
#	Line 169 | Line 211 | public class ArrayDequeTest extends JSR1
211		* offerFirst(null) throws NPE
212		*/
213		public void testOfferFirstNull() {
214	+	ArrayDeque q = new ArrayDeque();
215		try {
173	–	ArrayDeque q = new ArrayDeque();
216		q.offerFirst(null);
217		shouldThrow();
218		} catch (NullPointerException success) {}
#	Line 180 | Line 222 | public class ArrayDequeTest extends JSR1
222		* offerLast(null) throws NPE
223		*/
224		public void testOfferLastNull() {
225	+	ArrayDeque q = new ArrayDeque();
226		try {
184	–	ArrayDeque q = new ArrayDeque();
227		q.offerLast(null);
228		shouldThrow();
229		} catch (NullPointerException success) {}
#	Line 224 | Line 266 | public class ArrayDequeTest extends JSR1
266		* add(null) throws NPE
267		*/
268		public void testAddNull() {
269	+	ArrayDeque q = new ArrayDeque();
270		try {
228	–	ArrayDeque q = new ArrayDeque();
271		q.add(null);
272		shouldThrow();
273		} catch (NullPointerException success) {}
#	Line 235 | Line 277 | public class ArrayDequeTest extends JSR1
277		* addFirst(null) throws NPE
278		*/
279		public void testAddFirstNull() {
280	+	ArrayDeque q = new ArrayDeque();
281		try {
239	–	ArrayDeque q = new ArrayDeque();
282		q.addFirst(null);
283		shouldThrow();
284		} catch (NullPointerException success) {}
#	Line 246 | Line 288 | public class ArrayDequeTest extends JSR1
288		* addLast(null) throws NPE
289		*/
290		public void testAddLastNull() {
291	+	ArrayDeque q = new ArrayDeque();
292		try {
250	–	ArrayDeque q = new ArrayDeque();
293		q.addLast(null);
294		shouldThrow();
295		} catch (NullPointerException success) {}
#	Line 290 | Line 332 | public class ArrayDequeTest extends JSR1
332		* addAll(null) throws NPE
333		*/
334		public void testAddAll1() {
335	+	ArrayDeque q = new ArrayDeque();
336		try {
294	–	ArrayDeque q = new ArrayDeque();
337		q.addAll(null);
338		shouldThrow();
339		} catch (NullPointerException success) {}
#	Line 301 | Line 343 | public class ArrayDequeTest extends JSR1
343		* addAll of a collection with null elements throws NPE
344		*/
345		public void testAddAll2() {
346	+	ArrayDeque q = new ArrayDeque();
347		try {
348	<	ArrayDeque q = new ArrayDeque();
306	<	Integer[] ints = new Integer[SIZE];
307	<	q.addAll(Arrays.asList(ints));
348	>	q.addAll(Arrays.asList(new Integer[SIZE]));
349		shouldThrow();
350		} catch (NullPointerException success) {}
351		}
#	Line 314 | Line 355 | public class ArrayDequeTest extends JSR1
355		* possibly adding some elements
356		*/
357		public void testAddAll3() {
358	+	ArrayDeque q = new ArrayDeque();
359	+	Integer[] ints = new Integer[SIZE];
360	+	for (int i = 0; i < SIZE - 1; ++i)
361	+	ints[i] = new Integer(i);
362		try {
318	–	ArrayDeque q = new ArrayDeque();
319	–	Integer[] ints = new Integer[SIZE];
320	–	for (int i = 0; i < SIZE-1; ++i)
321	–	ints[i] = new Integer(i);
363		q.addAll(Arrays.asList(ints));
364		shouldThrow();
365		} catch (NullPointerException success) {}
#	Line 355 | Line 396 | public class ArrayDequeTest extends JSR1
396		*/
397		public void testPollLast() {
398		ArrayDeque q = populatedDeque(SIZE);
399	<	for (int i = SIZE-1; i >= 0; --i) {
399	>	for (int i = SIZE - 1; i >= 0; --i) {
400		assertEquals(i, q.pollLast());
401		}
402		assertNull(q.pollLast());
#	Line 391 | Line 432 | public class ArrayDequeTest extends JSR1
432		*/
433		public void testRemoveElement() {
434		ArrayDeque q = populatedDeque(SIZE);
435	<	for (int i = 1; i < SIZE; i+=2) {
435	>	for (int i = 1; i < SIZE; i += 2) {
436		assertTrue(q.contains(i));
437		assertTrue(q.remove(i));
438		assertFalse(q.contains(i));
439	<	assertTrue(q.contains(i-1));
439	>	assertTrue(q.contains(i - 1));
440		}
441	<	for (int i = 0; i < SIZE; i+=2) {
441	>	for (int i = 0; i < SIZE; i += 2) {
442		assertTrue(q.contains(i));
443		assertTrue(q.remove(i));
444		assertFalse(q.contains(i));
445	<	assertFalse(q.remove(i+1));
446	<	assertFalse(q.contains(i+1));
445	>	assertFalse(q.remove(i + 1));
446	>	assertFalse(q.contains(i + 1));
447		}
448		assertTrue(q.isEmpty());
449		}
#	Line 440 | Line 481 | public class ArrayDequeTest extends JSR1
481		*/
482		public void testPeekLast() {
483		ArrayDeque q = populatedDeque(SIZE);
484	<	for (int i = SIZE-1; i >= 0; --i) {
484	>	for (int i = SIZE - 1; i >= 0; --i) {
485		assertEquals(i, q.peekLast());
486		assertEquals(i, q.pollLast());
487		assertTrue(q.peekLast() == null ||
#	Line 484 | Line 525 | public class ArrayDequeTest extends JSR1
525		*/
526		public void testLastElement() {
527		ArrayDeque q = populatedDeque(SIZE);
528	<	for (int i = SIZE-1; i >= 0; --i) {
528	>	for (int i = SIZE - 1; i >= 0; --i) {
529		assertEquals(i, q.getLast());
530		assertEquals(i, q.pollLast());
531		}
#	Line 529 | Line 570 | public class ArrayDequeTest extends JSR1
570		* removeFirstOccurrence(x) removes x and returns true if present
571		*/
572		public void testRemoveFirstOccurrence() {
573	<	ArrayDeque q = populatedDeque(SIZE);
574	<	for (int i = 1; i < SIZE; i+=2) {
575	<	assertTrue(q.removeFirstOccurrence(new Integer(i)));
573	>	Deque<Integer> q = populatedDeque(SIZE);
574	>	assertFalse(q.removeFirstOccurrence(null));
575	>	for (int i = 1; i < SIZE; i += 2) {
576	>	assertTrue(q.removeFirstOccurrence(i));
577	>	assertFalse(q.contains(i));
578		}
579	<	for (int i = 0; i < SIZE; i+=2) {
580	<	assertTrue(q.removeFirstOccurrence(new Integer(i)));
581	<	assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
579	>	for (int i = 0; i < SIZE; i += 2) {
580	>	assertTrue(q.removeFirstOccurrence(i));
581	>	assertFalse(q.removeFirstOccurrence(i + 1));
582	>	assertFalse(q.contains(i));
583	>	assertFalse(q.contains(i + 1));
584		}
585		assertTrue(q.isEmpty());
586	+	assertFalse(q.removeFirstOccurrence(null));
587	+	assertFalse(q.removeFirstOccurrence(42));
588	+	q = new ArrayDeque();
589	+	assertFalse(q.removeFirstOccurrence(null));
590	+	assertFalse(q.removeFirstOccurrence(42));
591		}
592
593		/**
594		* removeLastOccurrence(x) removes x and returns true if present
595		*/
596		public void testRemoveLastOccurrence() {
597	<	ArrayDeque q = populatedDeque(SIZE);
598	<	for (int i = 1; i < SIZE; i+=2) {
599	<	assertTrue(q.removeLastOccurrence(new Integer(i)));
597	>	Deque<Integer> q = populatedDeque(SIZE);
598	>	assertFalse(q.removeLastOccurrence(null));
599	>	for (int i = 1; i < SIZE; i += 2) {
600	>	assertTrue(q.removeLastOccurrence(i));
601	>	assertFalse(q.contains(i));
602		}
603	<	for (int i = 0; i < SIZE; i+=2) {
604	<	assertTrue(q.removeLastOccurrence(new Integer(i)));
605	<	assertFalse(q.removeLastOccurrence(new Integer(i+1)));
603	>	for (int i = 0; i < SIZE; i += 2) {
604	>	assertTrue(q.removeLastOccurrence(i));
605	>	assertFalse(q.removeLastOccurrence(i + 1));
606	>	assertFalse(q.contains(i));
607	>	assertFalse(q.contains(i + 1));
608		}
609		assertTrue(q.isEmpty());
610	+	assertFalse(q.removeLastOccurrence(null));
611	+	assertFalse(q.removeLastOccurrence(42));
612	+	q = new ArrayDeque();
613	+	assertFalse(q.removeLastOccurrence(null));
614	+	assertFalse(q.removeLastOccurrence(42));
615		}
616
617		/**
#	Line 605 | Line 664 | public class ArrayDequeTest extends JSR1
664		boolean changed = q.retainAll(p);
665		assertEquals(changed, (i > 0));
666		assertTrue(q.containsAll(p));
667	<	assertEquals(SIZE-i, q.size());
667	>	assertEquals(SIZE - i, q.size());
668		p.removeFirst();
669		}
670		}
#	Line 618 | Line 677 | public class ArrayDequeTest extends JSR1
677		ArrayDeque q = populatedDeque(SIZE);
678		ArrayDeque p = populatedDeque(i);
679		assertTrue(q.removeAll(p));
680	<	assertEquals(SIZE-i, q.size());
680	>	assertEquals(SIZE - i, q.size());
681		for (int j = 0; j < i; ++j) {
682		assertFalse(q.contains(p.removeFirst()));
683		}
684		}
685		}
686
687	<	/**
688	<	* toArray() contains all elements in FIFO order
689	<	*/
690	<	public void testToArray() {
691	<	ArrayDeque q = populatedDeque(SIZE);
692	<	Object[] o = q.toArray();
693	<	for (int i = 0; i < o.length; i++)
694	<	assertSame(o[i], q.pollFirst());
687	>	void checkToArray(ArrayDeque<Integer> q) {
688	>	int size = q.size();
689	>	Object[] a1 = q.toArray();
690	>	assertEquals(size, a1.length);
691	>	Integer[] a2 = q.toArray(new Integer[0]);
692	>	assertEquals(size, a2.length);
693	>	Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
694	>	assertEquals(size, a3.length);
695	>	Integer[] a4 = new Integer[size];
696	>	assertSame(a4, q.toArray(a4));
697	>	Integer[] a5 = new Integer[size + 1];
698	>	Arrays.fill(a5, 42);
699	>	assertSame(a5, q.toArray(a5));
700	>	Integer[] a6 = new Integer[size + 2];
701	>	Arrays.fill(a6, 42);
702	>	assertSame(a6, q.toArray(a6));
703	>	Object[][] as = { a1, a2, a3, a4, a5, a6 };
704	>	for (Object[] a : as) {
705	>	if (a.length > size) assertNull(a[size]);
706	>	if (a.length > size + 1) assertEquals(42, a[size + 1]);
707	>	}
708	>	Iterator it = q.iterator();
709	>	Integer s = q.peekFirst();
710	>	for (int i = 0; i < size; i++) {
711	>	Integer x = (Integer) it.next();
712	>	assertEquals(s + i, (int) x);
713	>	for (Object[] a : as)
714	>	assertSame(a1[i], x);
715	>	}
716		}
717
718		/**
719	<	* toArray(a) contains all elements in FIFO order
719	>	* toArray() and toArray(a) contain all elements in FIFO order
720		*/
721	<	public void testToArray2() {
722	<	ArrayDeque<Integer> q = populatedDeque(SIZE);
723	<	Integer[] ints = new Integer[SIZE];
724	<	Integer[] array = q.toArray(ints);
725	<	assertSame(ints, array);
726	<	for (int i = 0; i < ints.length; i++)
727	<	assertSame(ints[i], q.remove());
721	>	public void testToArray() {
722	>	final int size = ThreadLocalRandom.current().nextInt(10);
723	>	ArrayDeque<Integer> q = new ArrayDeque<>(size);
724	>	for (int i = 0; i < size; i++) {
725	>	checkToArray(q);
726	>	q.addLast(i);
727	>	}
728	>	// Provoke wraparound
729	>	int added = size * 2;
730	>	for (int i = 0; i < added; i++) {
731	>	checkToArray(q);
732	>	assertEquals((Integer) i, q.poll());
733	>	q.addLast(size + i);
734	>	}
735	>	for (int i = 0; i < size; i++) {
736	>	checkToArray(q);
737	>	assertEquals((Integer) (added + i), q.poll());
738	>	}
739		}
740
741		/**
#	Line 662 | Line 753 | public class ArrayDequeTest extends JSR1
753		/**
754		* toArray(incompatible array type) throws ArrayStoreException
755		*/
756	<	public void testToArray1_BadArg() {
756	>	public void testToArray_incompatibleArrayType() {
757		ArrayDeque l = new ArrayDeque();
758		l.add(new Integer(5));
759		try {
760		l.toArray(new String[10]);
761		shouldThrow();
762		} catch (ArrayStoreException success) {}
763	+	try {
764	+	l.toArray(new String[0]);
765	+	shouldThrow();
766	+	} catch (ArrayStoreException success) {}
767		}
768
769		/**
#	Line 676 | Line 771 | public class ArrayDequeTest extends JSR1
771		*/
772		public void testIterator() {
773		ArrayDeque q = populatedDeque(SIZE);
679	–	int i = 0;
774		Iterator it = q.iterator();
775	<	while (it.hasNext()) {
775	>	int i;
776	>	for (i = 0; it.hasNext(); i++)
777		assertTrue(q.contains(it.next()));
683	–	++i;
684	–	}
778		assertEquals(i, SIZE);
779	+	assertIteratorExhausted(it);
780	+	}
781	+
782	+	/**
783	+	* iterator of empty collection has no elements
784	+	*/
785	+	public void testEmptyIterator() {
786	+	Deque c = new ArrayDeque();
787	+	assertIteratorExhausted(c.iterator());
788	+	assertIteratorExhausted(c.descendingIterator());
789		}
790
791		/**
#	Line 709 | Line 812 | public class ArrayDequeTest extends JSR1
812		final Random rng = new Random();
813		for (int iters = 0; iters < 100; ++iters) {
814		int max = rng.nextInt(5) + 2;
815	<	int split = rng.nextInt(max-1) + 1;
815	>	int split = rng.nextInt(max - 1) + 1;
816		for (int j = 1; j <= max; ++j)
817		q.add(new Integer(j));
818		Iterator it = q.iterator();
819		for (int j = 1; j <= split; ++j)
820		assertEquals(it.next(), new Integer(j));
821		it.remove();
822	<	assertEquals(it.next(), new Integer(split+1));
822	>	assertEquals(it.next(), new Integer(split + 1));
823		for (int j = 1; j <= split; ++j)
824		q.remove(new Integer(j));
825		it = q.iterator();
826	<	for (int j = split+1; j <= max; ++j) {
826	>	for (int j = split + 1; j <= max; ++j) {
827		assertEquals(it.next(), new Integer(j));
828		it.remove();
829		}
#	Line 777 | Line 880 | public class ArrayDequeTest extends JSR1
880		final Random rng = new Random();
881		for (int iters = 0; iters < 100; ++iters) {
882		int max = rng.nextInt(5) + 2;
883	<	int split = rng.nextInt(max-1) + 1;
883	>	int split = rng.nextInt(max - 1) + 1;
884		for (int j = max; j >= 1; --j)
885		q.add(new Integer(j));
886		Iterator it = q.descendingIterator();
887		for (int j = 1; j <= split; ++j)
888		assertEquals(it.next(), new Integer(j));
889		it.remove();
890	<	assertEquals(it.next(), new Integer(split+1));
890	>	assertEquals(it.next(), new Integer(split + 1));
891		for (int j = 1; j <= split; ++j)
892		q.remove(new Integer(j));
893		it = q.descendingIterator();
894	<	for (int j = split+1; j <= max; ++j) {
894	>	for (int j = split + 1; j <= max; ++j) {
895		assertEquals(it.next(), new Integer(j));
896		it.remove();
897		}
#	Line 809 | Line 912 | public class ArrayDequeTest extends JSR1
912		}
913
914		/**
915	<	* A deserialized serialized deque has same elements in same order
915	>	* A deserialized/reserialized deque has same elements in same order
916		*/
917		public void testSerialization() throws Exception {
918		Queue x = populatedDeque(SIZE);
919		Queue y = serialClone(x);
920
921	<	assertTrue(x != y);
921	>	assertNotSame(y, x);
922	>	assertEquals(x.size(), y.size());
923	>	assertEquals(x.toString(), y.toString());
924	>	assertEquals(Arrays.toString(x.toArray()), Arrays.toString(y.toArray()));
925	>	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
926	>	while (!x.isEmpty()) {
927	>	assertFalse(y.isEmpty());
928	>	assertEquals(x.remove(), y.remove());
929	>	}
930	>	assertTrue(y.isEmpty());
931	>	}
932	>
933	>	/**
934	>	* A cloned deque has same elements in same order
935	>	*/
936	>	public void testClone() throws Exception {
937	>	ArrayDeque<Integer> x = populatedDeque(SIZE);
938	>	ArrayDeque<Integer> y = x.clone();
939	>
940	>	assertNotSame(y, x);
941		assertEquals(x.size(), y.size());
942		assertEquals(x.toString(), y.toString());
943		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
#	Line 826 | Line 948 | public class ArrayDequeTest extends JSR1
948		assertTrue(y.isEmpty());
949		}
950
951	+	/**
952	+	* remove(null), contains(null) always return false
953	+	*/
954	+	public void testNeverContainsNull() {
955	+	Deque<?>[] qs = {
956	+	new ArrayDeque<Object>(),
957	+	populatedDeque(2),
958	+	};
959	+
960	+	for (Deque<?> q : qs) {
961	+	assertFalse(q.contains(null));
962	+	assertFalse(q.remove(null));
963	+	assertFalse(q.removeFirstOccurrence(null));
964	+	assertFalse(q.removeLastOccurrence(null));
965	+	}
966	+	}
967	+
968		}

Diff Legend

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