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.20 by jsr166, Fri Nov 5 00:17:22 2010 UTC vs.
Revision 1.40 by jsr166, Sun Oct 16 20:16:36 2016 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		*/
6
7	<	import junit.framework.*;
8	<	import java.io.BufferedInputStream;
9	<	import java.io.BufferedOutputStream;
10	<	import java.io.ByteArrayInputStream;
11	<	import java.io.ByteArrayOutputStream;
12	<	import java.io.ObjectInputStream;
13	<	import java.io.ObjectOutputStream;
14	<	import java.util.*;
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;
12	>	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		/**
37	<	* Create a deque of given size containing consecutive
37	>	* Returns a new deque of given size containing consecutive
38		* Integers 0 ... n.
39		*/
40		private ArrayDeque<Integer> populatedDeque(int n) {
#	Line 48 | 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 58 | Line 69 | public class ArrayDequeTest extends JSR1
69		*/
70		public void testConstructor4() {
71		try {
72	<	Integer[] ints = new Integer[SIZE];
62	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
72	>	new ArrayDeque(Arrays.asList(new Integer[SIZE]));
73		shouldThrow();
74		} catch (NullPointerException success) {}
75		}
#	Line 68 | 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];
73	<	for (int i = 0; i < SIZE-1; ++i)
74	<	ints[i] = new Integer(i);
75	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
85	>	new ArrayDeque(Arrays.asList(ints));
86		shouldThrow();
87		} catch (NullPointerException success) {}
88		}
#	Line 109 | 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 122 | 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 {
126	–	ArrayDeque q = new ArrayDeque(1);
137		q.push(null);
138		shouldThrow();
139		} catch (NullPointerException success) {}
#	Line 157 | Line 167 | public class ArrayDequeTest extends JSR1
167		* offer(null) throws NPE
168		*/
169		public void testOfferNull() {
170	+	ArrayDeque q = new ArrayDeque();
171		try {
161	–	ArrayDeque q = new ArrayDeque();
172		q.offer(null);
173		shouldThrow();
174		} catch (NullPointerException success) {}
#	Line 168 | Line 178 | public class ArrayDequeTest extends JSR1
178		* offerFirst(null) throws NPE
179		*/
180		public void testOfferFirstNull() {
181	+	ArrayDeque q = new ArrayDeque();
182		try {
172	–	ArrayDeque q = new ArrayDeque();
183		q.offerFirst(null);
184		shouldThrow();
185		} catch (NullPointerException success) {}
#	Line 179 | Line 189 | public class ArrayDequeTest extends JSR1
189		* offerLast(null) throws NPE
190		*/
191		public void testOfferLastNull() {
192	+	ArrayDeque q = new ArrayDeque();
193		try {
183	–	ArrayDeque q = new ArrayDeque();
194		q.offerLast(null);
195		shouldThrow();
196		} catch (NullPointerException success) {}
#	Line 223 | Line 233 | public class ArrayDequeTest extends JSR1
233		* add(null) throws NPE
234		*/
235		public void testAddNull() {
236	+	ArrayDeque q = new ArrayDeque();
237		try {
227	–	ArrayDeque q = new ArrayDeque();
238		q.add(null);
239		shouldThrow();
240		} catch (NullPointerException success) {}
#	Line 234 | Line 244 | public class ArrayDequeTest extends JSR1
244		* addFirst(null) throws NPE
245		*/
246		public void testAddFirstNull() {
247	+	ArrayDeque q = new ArrayDeque();
248		try {
238	–	ArrayDeque q = new ArrayDeque();
249		q.addFirst(null);
250		shouldThrow();
251		} catch (NullPointerException success) {}
#	Line 245 | Line 255 | public class ArrayDequeTest extends JSR1
255		* addLast(null) throws NPE
256		*/
257		public void testAddLastNull() {
258	+	ArrayDeque q = new ArrayDeque();
259		try {
249	–	ArrayDeque q = new ArrayDeque();
260		q.addLast(null);
261		shouldThrow();
262		} catch (NullPointerException success) {}
#	Line 289 | Line 299 | public class ArrayDequeTest extends JSR1
299		* addAll(null) throws NPE
300		*/
301		public void testAddAll1() {
302	+	ArrayDeque q = new ArrayDeque();
303		try {
293	–	ArrayDeque q = new ArrayDeque();
304		q.addAll(null);
305		shouldThrow();
306		} catch (NullPointerException success) {}
#	Line 300 | 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();
305	<	Integer[] ints = new Integer[SIZE];
306	<	q.addAll(Arrays.asList(ints));
315	>	q.addAll(Arrays.asList(new Integer[SIZE]));
316		shouldThrow();
317		} catch (NullPointerException success) {}
318		}
#	Line 313 | 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 {
317	–	ArrayDeque q = new ArrayDeque();
318	–	Integer[] ints = new Integer[SIZE];
319	–	for (int i = 0; i < SIZE-1; ++i)
320	–	ints[i] = new Integer(i);
330		q.addAll(Arrays.asList(ints));
331		shouldThrow();
332		} catch (NullPointerException success) {}
#	Line 354 | 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 390 | 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) {
403	<	assertTrue(q.remove(new Integer(i)));
404	<	}
405	<	for (int i = 0; i < SIZE; i+=2) {
406	<	assertTrue(q.remove(new Integer(i)));
407	<	assertFalse(q.remove(new Integer(i+1)));
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));
407	>	}
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));
414		}
415		assertTrue(q.isEmpty());
416		}
#	Line 433 | 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 477 | 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 488 | Line 503 | public class ArrayDequeTest extends JSR1
503		assertNull(q.peekLast());
504		}
505
491	–
506		/**
507		* removeFirst() removes first element, or throws NSEE if empty
508		*/
#	Line 524 | 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 539 | 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 599 | 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 612 | 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 670 | Line 760 | public class ArrayDequeTest extends JSR1
760		*/
761		public void testIterator() {
762		ArrayDeque q = populatedDeque(SIZE);
673	–	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()));
677	–	++i;
678	–	}
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 703 | 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 771 | 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 791 | Line 889 | public class ArrayDequeTest extends JSR1
889		}
890		}
891
794	–
892		/**
893		* toString() contains toStrings of elements
894		*/
#	Line 799 | Line 896 | public class ArrayDequeTest extends JSR1
896		ArrayDeque q = populatedDeque(SIZE);
897		String s = q.toString();
898		for (int i = 0; i < SIZE; ++i) {
899	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
899	>	assertTrue(s.contains(String.valueOf(i)));
900		}
901		}
902
#	Line 807 | Line 904 | public class ArrayDequeTest extends JSR1
904		* A deserialized serialized deque has same elements in same order
905		*/
906		public void testSerialization() throws Exception {
907	<	ArrayDeque q = populatedDeque(SIZE);
908	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
909	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
910	<	out.writeObject(q);
911	<	out.close();
912	<
913	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
914	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
915	<	ArrayDeque r = (ArrayDeque)in.readObject();
916	<	assertEquals(q.size(), r.size());
917	<	while (!q.isEmpty())
918	<	assertEquals(q.remove(), r.remove());
907	>	Queue x = populatedDeque(SIZE);
908	>	Queue y = serialClone(x);
909	>
910	>	assertNotSame(y, x);
911	>	assertEquals(x.size(), y.size());
912	>	assertEquals(x.toString(), y.toString());
913	>	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
914	>	while (!x.isEmpty()) {
915	>	assertFalse(y.isEmpty());
916	>	assertEquals(x.remove(), y.remove());
917	>	}
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