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.40 by jsr166, Sun Oct 16 20:16:36 2016 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	–	import junit.framework.*;
8	–	import java.util.Arrays;
7		import java.util.ArrayDeque;
8	+	import java.util.Arrays;
9		import java.util.Collection;
10		import java.util.Deque;
11		import java.util.Iterator;
#	Line 14 | Line 13 | import java.util.NoSuchElementException;
13		import java.util.Queue;
14		import java.util.Random;
15
16	+	import junit.framework.Test;
17	+	import junit.framework.TestSuite;
18	+
19		public class ArrayDequeTest extends JSR166TestCase {
20		public static void main(String[] args) {
21	<	junit.textui.TestRunner.run(suite());
21	>	main(suite(), args);
22		}
23
24		public static Test suite() {
25	<	return new TestSuite(ArrayDequeTest.class);
25	>	class Implementation implements CollectionImplementation {
26	>	public Class<?> klazz() { return ArrayDeque.class; }
27	>	public Collection emptyCollection() { return new ArrayDeque(); }
28	>	public Object makeElement(int i) { return i; }
29	>	public boolean isConcurrent() { return false; }
30	>	public boolean permitsNulls() { return false; }
31	>	}
32	>	return newTestSuite(ArrayDequeTest.class,
33	>	CollectionTest.testSuite(new Implementation()));
34		}
35
36		/**
#	Line 49 | Line 59 | public class ArrayDequeTest extends JSR1
59		*/
60		public void testConstructor3() {
61		try {
62	<	ArrayDeque q = new ArrayDeque((Collection)null);
62	>	new ArrayDeque((Collection)null);
63		shouldThrow();
64		} catch (NullPointerException success) {}
65		}
#	Line 59 | Line 69 | public class ArrayDequeTest extends JSR1
69		*/
70		public void testConstructor4() {
71		try {
72	<	Integer[] ints = new Integer[SIZE];
63	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
72	>	new ArrayDeque(Arrays.asList(new Integer[SIZE]));
73		shouldThrow();
74		} catch (NullPointerException success) {}
75		}
#	Line 69 | Line 78 | public class ArrayDequeTest extends JSR1
78		* Initializing from Collection with some null elements throws NPE
79		*/
80		public void testConstructor5() {
81	+	Integer[] ints = new Integer[SIZE];
82	+	for (int i = 0; i < SIZE - 1; ++i)
83	+	ints[i] = new Integer(i);
84		try {
85	<	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));
85	>	new ArrayDeque(Arrays.asList(ints));
86		shouldThrow();
87		} catch (NullPointerException success) {}
88		}
#	Line 110 | Line 119 | public class ArrayDequeTest extends JSR1
119		public void testSize() {
120		ArrayDeque q = populatedDeque(SIZE);
121		for (int i = 0; i < SIZE; ++i) {
122	<	assertEquals(SIZE-i, q.size());
122	>	assertEquals(SIZE - i, q.size());
123		q.removeFirst();
124		}
125		for (int i = 0; i < SIZE; ++i) {
#	Line 123 | Line 132 | public class ArrayDequeTest extends JSR1
132		* push(null) throws NPE
133		*/
134		public void testPushNull() {
135	+	ArrayDeque q = new ArrayDeque(1);
136		try {
127	–	ArrayDeque q = new ArrayDeque(1);
137		q.push(null);
138		shouldThrow();
139		} catch (NullPointerException success) {}
#	Line 158 | Line 167 | public class ArrayDequeTest extends JSR1
167		* offer(null) throws NPE
168		*/
169		public void testOfferNull() {
170	+	ArrayDeque q = new ArrayDeque();
171		try {
162	–	ArrayDeque q = new ArrayDeque();
172		q.offer(null);
173		shouldThrow();
174		} catch (NullPointerException success) {}
#	Line 169 | Line 178 | public class ArrayDequeTest extends JSR1
178		* offerFirst(null) throws NPE
179		*/
180		public void testOfferFirstNull() {
181	+	ArrayDeque q = new ArrayDeque();
182		try {
173	–	ArrayDeque q = new ArrayDeque();
183		q.offerFirst(null);
184		shouldThrow();
185		} catch (NullPointerException success) {}
#	Line 180 | Line 189 | public class ArrayDequeTest extends JSR1
189		* offerLast(null) throws NPE
190		*/
191		public void testOfferLastNull() {
192	+	ArrayDeque q = new ArrayDeque();
193		try {
184	–	ArrayDeque q = new ArrayDeque();
194		q.offerLast(null);
195		shouldThrow();
196		} catch (NullPointerException success) {}
#	Line 224 | Line 233 | public class ArrayDequeTest extends JSR1
233		* add(null) throws NPE
234		*/
235		public void testAddNull() {
236	+	ArrayDeque q = new ArrayDeque();
237		try {
228	–	ArrayDeque q = new ArrayDeque();
238		q.add(null);
239		shouldThrow();
240		} catch (NullPointerException success) {}
#	Line 235 | Line 244 | public class ArrayDequeTest extends JSR1
244		* addFirst(null) throws NPE
245		*/
246		public void testAddFirstNull() {
247	+	ArrayDeque q = new ArrayDeque();
248		try {
239	–	ArrayDeque q = new ArrayDeque();
249		q.addFirst(null);
250		shouldThrow();
251		} catch (NullPointerException success) {}
#	Line 246 | Line 255 | public class ArrayDequeTest extends JSR1
255		* addLast(null) throws NPE
256		*/
257		public void testAddLastNull() {
258	+	ArrayDeque q = new ArrayDeque();
259		try {
250	–	ArrayDeque q = new ArrayDeque();
260		q.addLast(null);
261		shouldThrow();
262		} catch (NullPointerException success) {}
#	Line 290 | Line 299 | public class ArrayDequeTest extends JSR1
299		* addAll(null) throws NPE
300		*/
301		public void testAddAll1() {
302	+	ArrayDeque q = new ArrayDeque();
303		try {
294	–	ArrayDeque q = new ArrayDeque();
304		q.addAll(null);
305		shouldThrow();
306		} catch (NullPointerException success) {}
#	Line 301 | Line 310 | public class ArrayDequeTest extends JSR1
310		* addAll of a collection with null elements throws NPE
311		*/
312		public void testAddAll2() {
313	+	ArrayDeque q = new ArrayDeque();
314		try {
315	<	ArrayDeque q = new ArrayDeque();
306	<	Integer[] ints = new Integer[SIZE];
307	<	q.addAll(Arrays.asList(ints));
315	>	q.addAll(Arrays.asList(new Integer[SIZE]));
316		shouldThrow();
317		} catch (NullPointerException success) {}
318		}
#	Line 314 | Line 322 | public class ArrayDequeTest extends JSR1
322		* possibly adding some elements
323		*/
324		public void testAddAll3() {
325	+	ArrayDeque q = new ArrayDeque();
326	+	Integer[] ints = new Integer[SIZE];
327	+	for (int i = 0; i < SIZE - 1; ++i)
328	+	ints[i] = new Integer(i);
329		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);
330		q.addAll(Arrays.asList(ints));
331		shouldThrow();
332		} catch (NullPointerException success) {}
#	Line 355 | Line 363 | public class ArrayDequeTest extends JSR1
363		*/
364		public void testPollLast() {
365		ArrayDeque q = populatedDeque(SIZE);
366	<	for (int i = SIZE-1; i >= 0; --i) {
366	>	for (int i = SIZE - 1; i >= 0; --i) {
367		assertEquals(i, q.pollLast());
368		}
369		assertNull(q.pollLast());
#	Line 391 | Line 399 | public class ArrayDequeTest extends JSR1
399		*/
400		public void testRemoveElement() {
401		ArrayDeque q = populatedDeque(SIZE);
402	<	for (int i = 1; i < SIZE; i+=2) {
402	>	for (int i = 1; i < SIZE; i += 2) {
403		assertTrue(q.contains(i));
404		assertTrue(q.remove(i));
405		assertFalse(q.contains(i));
406	<	assertTrue(q.contains(i-1));
406	>	assertTrue(q.contains(i - 1));
407		}
408	<	for (int i = 0; i < SIZE; i+=2) {
408	>	for (int i = 0; i < SIZE; i += 2) {
409		assertTrue(q.contains(i));
410		assertTrue(q.remove(i));
411		assertFalse(q.contains(i));
412	<	assertFalse(q.remove(i+1));
413	<	assertFalse(q.contains(i+1));
412	>	assertFalse(q.remove(i + 1));
413	>	assertFalse(q.contains(i + 1));
414		}
415		assertTrue(q.isEmpty());
416		}
#	Line 440 | Line 448 | public class ArrayDequeTest extends JSR1
448		*/
449		public void testPeekLast() {
450		ArrayDeque q = populatedDeque(SIZE);
451	<	for (int i = SIZE-1; i >= 0; --i) {
451	>	for (int i = SIZE - 1; i >= 0; --i) {
452		assertEquals(i, q.peekLast());
453		assertEquals(i, q.pollLast());
454		assertTrue(q.peekLast() == null ||
#	Line 484 | Line 492 | public class ArrayDequeTest extends JSR1
492		*/
493		public void testLastElement() {
494		ArrayDeque q = populatedDeque(SIZE);
495	<	for (int i = SIZE-1; i >= 0; --i) {
495	>	for (int i = SIZE - 1; i >= 0; --i) {
496		assertEquals(i, q.getLast());
497		assertEquals(i, q.pollLast());
498		}
#	Line 530 | Line 538 | public class ArrayDequeTest extends JSR1
538		*/
539		public void testRemoveFirstOccurrence() {
540		ArrayDeque q = populatedDeque(SIZE);
541	<	for (int i = 1; i < SIZE; i+=2) {
541	>	assertFalse(q.removeFirstOccurrence(null));
542	>	for (int i = 1; i < SIZE; i += 2) {
543		assertTrue(q.removeFirstOccurrence(new Integer(i)));
544		}
545	<	for (int i = 0; i < SIZE; i+=2) {
545	>	for (int i = 0; i < SIZE; i += 2) {
546		assertTrue(q.removeFirstOccurrence(new Integer(i)));
547	<	assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
547	>	assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
548		}
549		assertTrue(q.isEmpty());
550	+	assertFalse(q.removeFirstOccurrence(null));
551	+	assertFalse(q.removeFirstOccurrence(42));
552	+	q = new ArrayDeque();
553	+	assertFalse(q.removeFirstOccurrence(null));
554	+	assertFalse(q.removeFirstOccurrence(42));
555		}
556
557		/**
#	Line 545 | Line 559 | public class ArrayDequeTest extends JSR1
559		*/
560		public void testRemoveLastOccurrence() {
561		ArrayDeque q = populatedDeque(SIZE);
562	<	for (int i = 1; i < SIZE; i+=2) {
562	>	assertFalse(q.removeLastOccurrence(null));
563	>	for (int i = 1; i < SIZE; i += 2) {
564		assertTrue(q.removeLastOccurrence(new Integer(i)));
565		}
566	<	for (int i = 0; i < SIZE; i+=2) {
566	>	for (int i = 0; i < SIZE; i += 2) {
567		assertTrue(q.removeLastOccurrence(new Integer(i)));
568	<	assertFalse(q.removeLastOccurrence(new Integer(i+1)));
568	>	assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
569		}
570		assertTrue(q.isEmpty());
571	+	assertFalse(q.removeLastOccurrence(null));
572	+	assertFalse(q.removeLastOccurrence(42));
573	+	q = new ArrayDeque();
574	+	assertFalse(q.removeLastOccurrence(null));
575	+	assertFalse(q.removeLastOccurrence(42));
576		}
577
578		/**
#	Line 605 | Line 625 | public class ArrayDequeTest extends JSR1
625		boolean changed = q.retainAll(p);
626		assertEquals(changed, (i > 0));
627		assertTrue(q.containsAll(p));
628	<	assertEquals(SIZE-i, q.size());
628	>	assertEquals(SIZE - i, q.size());
629		p.removeFirst();
630		}
631		}
#	Line 618 | Line 638 | public class ArrayDequeTest extends JSR1
638		ArrayDeque q = populatedDeque(SIZE);
639		ArrayDeque p = populatedDeque(i);
640		assertTrue(q.removeAll(p));
641	<	assertEquals(SIZE-i, q.size());
641	>	assertEquals(SIZE - i, q.size());
642		for (int j = 0; j < i; ++j) {
643		assertFalse(q.contains(p.removeFirst()));
644		}
645		}
646		}
647
648	+	void checkToArray(ArrayDeque q) {
649	+	int size = q.size();
650	+	Object[] o = q.toArray();
651	+	assertEquals(size, o.length);
652	+	Iterator it = q.iterator();
653	+	for (int i = 0; i < size; i++) {
654	+	Integer x = (Integer) it.next();
655	+	assertEquals((Integer)o[0] + i, (int) x);
656	+	assertSame(o[i], x);
657	+	}
658	+	}
659	+
660		/**
661		* toArray() contains all elements in FIFO order
662		*/
663		public void testToArray() {
664	<	ArrayDeque q = populatedDeque(SIZE);
665	<	Object[] o = q.toArray();
666	<	for (int i = 0; i < o.length; i++)
667	<	assertSame(o[i], q.pollFirst());
664	>	ArrayDeque q = new ArrayDeque();
665	>	for (int i = 0; i < SIZE; i++) {
666	>	checkToArray(q);
667	>	q.addLast(i);
668	>	}
669	>	// Provoke wraparound
670	>	for (int i = 0; i < SIZE; i++) {
671	>	checkToArray(q);
672	>	assertEquals(i, q.poll());
673	>	q.addLast(SIZE + i);
674	>	}
675	>	for (int i = 0; i < SIZE; i++) {
676	>	checkToArray(q);
677	>	assertEquals(SIZE + i, q.poll());
678	>	}
679	>	}
680	>
681	>	void checkToArray2(ArrayDeque q) {
682	>	int size = q.size();
683	>	Integer[] a1 = (size == 0) ? null : new Integer[size - 1];
684	>	Integer[] a2 = new Integer[size];
685	>	Integer[] a3 = new Integer[size + 2];
686	>	if (size > 0) Arrays.fill(a1, 42);
687	>	Arrays.fill(a2, 42);
688	>	Arrays.fill(a3, 42);
689	>	Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);
690	>	Integer[] b2 = (Integer[]) q.toArray(a2);
691	>	Integer[] b3 = (Integer[]) q.toArray(a3);
692	>	assertSame(a2, b2);
693	>	assertSame(a3, b3);
694	>	Iterator it = q.iterator();
695	>	for (int i = 0; i < size; i++) {
696	>	Integer x = (Integer) it.next();
697	>	assertSame(b1[i], x);
698	>	assertEquals(b1[0] + i, (int) x);
699	>	assertSame(b2[i], x);
700	>	assertSame(b3[i], x);
701	>	}
702	>	assertNull(a3[size]);
703	>	assertEquals(42, (int) a3[size + 1]);
704	>	if (size > 0) {
705	>	assertNotSame(a1, b1);
706	>	assertEquals(size, b1.length);
707	>	for (int i = 0; i < a1.length; i++) {
708	>	assertEquals(42, (int) a1[i]);
709	>	}
710	>	}
711		}
712
713		/**
714		* toArray(a) contains all elements in FIFO order
715		*/
716		public void testToArray2() {
717	<	ArrayDeque<Integer> q = populatedDeque(SIZE);
718	<	Integer[] ints = new Integer[SIZE];
719	<	Integer[] array = q.toArray(ints);
720	<	assertSame(ints, array);
721	<	for (int i = 0; i < ints.length; i++)
722	<	assertSame(ints[i], q.remove());
717	>	ArrayDeque q = new ArrayDeque();
718	>	for (int i = 0; i < SIZE; i++) {
719	>	checkToArray2(q);
720	>	q.addLast(i);
721	>	}
722	>	// Provoke wraparound
723	>	for (int i = 0; i < SIZE; i++) {
724	>	checkToArray2(q);
725	>	assertEquals(i, q.poll());
726	>	q.addLast(SIZE + i);
727	>	}
728	>	for (int i = 0; i < SIZE; i++) {
729	>	checkToArray2(q);
730	>	assertEquals(SIZE + i, q.poll());
731	>	}
732		}
733
734		/**
#	Line 676 | Line 760 | public class ArrayDequeTest extends JSR1
760		*/
761		public void testIterator() {
762		ArrayDeque q = populatedDeque(SIZE);
679	–	int i = 0;
763		Iterator it = q.iterator();
764	<	while (it.hasNext()) {
764	>	int i;
765	>	for (i = 0; it.hasNext(); i++)
766		assertTrue(q.contains(it.next()));
683	–	++i;
684	–	}
767		assertEquals(i, SIZE);
768	+	assertIteratorExhausted(it);
769	+	}
770	+
771	+	/**
772	+	* iterator of empty collection has no elements
773	+	*/
774	+	public void testEmptyIterator() {
775	+	Deque c = new ArrayDeque();
776	+	assertIteratorExhausted(c.iterator());
777	+	assertIteratorExhausted(c.descendingIterator());
778		}
779
780		/**
#	Line 709 | Line 801 | public class ArrayDequeTest extends JSR1
801		final Random rng = new Random();
802		for (int iters = 0; iters < 100; ++iters) {
803		int max = rng.nextInt(5) + 2;
804	<	int split = rng.nextInt(max-1) + 1;
804	>	int split = rng.nextInt(max - 1) + 1;
805		for (int j = 1; j <= max; ++j)
806		q.add(new Integer(j));
807		Iterator it = q.iterator();
808		for (int j = 1; j <= split; ++j)
809		assertEquals(it.next(), new Integer(j));
810		it.remove();
811	<	assertEquals(it.next(), new Integer(split+1));
811	>	assertEquals(it.next(), new Integer(split + 1));
812		for (int j = 1; j <= split; ++j)
813		q.remove(new Integer(j));
814		it = q.iterator();
815	<	for (int j = split+1; j <= max; ++j) {
815	>	for (int j = split + 1; j <= max; ++j) {
816		assertEquals(it.next(), new Integer(j));
817		it.remove();
818		}
#	Line 777 | Line 869 | public class ArrayDequeTest extends JSR1
869		final Random rng = new Random();
870		for (int iters = 0; iters < 100; ++iters) {
871		int max = rng.nextInt(5) + 2;
872	<	int split = rng.nextInt(max-1) + 1;
872	>	int split = rng.nextInt(max - 1) + 1;
873		for (int j = max; j >= 1; --j)
874		q.add(new Integer(j));
875		Iterator it = q.descendingIterator();
876		for (int j = 1; j <= split; ++j)
877		assertEquals(it.next(), new Integer(j));
878		it.remove();
879	<	assertEquals(it.next(), new Integer(split+1));
879	>	assertEquals(it.next(), new Integer(split + 1));
880		for (int j = 1; j <= split; ++j)
881		q.remove(new Integer(j));
882		it = q.descendingIterator();
883	<	for (int j = split+1; j <= max; ++j) {
883	>	for (int j = split + 1; j <= max; ++j) {
884		assertEquals(it.next(), new Integer(j));
885		it.remove();
886		}
#	Line 815 | Line 907 | public class ArrayDequeTest extends JSR1
907		Queue x = populatedDeque(SIZE);
908		Queue y = serialClone(x);
909
910	<	assertTrue(x != y);
910	>	assertNotSame(y, x);
911		assertEquals(x.size(), y.size());
912		assertEquals(x.toString(), y.toString());
913		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
#	Line 826 | Line 918 | public class ArrayDequeTest extends JSR1
918		assertTrue(y.isEmpty());
919		}
920
921	+	/**
922	+	* remove(null), contains(null) always return false
923	+	*/
924	+	public void testNeverContainsNull() {
925	+	Deque<?>[] qs = {
926	+	new ArrayDeque<Object>(),
927	+	populatedDeque(2),
928	+	};
929	+
930	+	for (Deque<?> q : qs) {
931	+	assertFalse(q.contains(null));
932	+	assertFalse(q.remove(null));
933	+	assertFalse(q.removeFirstOccurrence(null));
934	+	assertFalse(q.removeLastOccurrence(null));
935	+	}
936	+	}
937	+
938		}

Diff Legend

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