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.19 by jsr166, Thu Nov 4 01:04:54 2010 UTC vs.
Revision 1.36 by jsr166, Sat May 23 00:53:08 2015 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() {
#	Line 23 | Line 26 | public class ArrayDequeTest extends JSR1
26		}
27
28		/**
29	<	* Create a deque of given size containing consecutive
29	>	* Returns a new deque of given size containing consecutive
30		* Integers 0 ... n.
31		*/
32	<	private ArrayDeque populatedDeque(int n) {
33	<	ArrayDeque q = new ArrayDeque();
32	>	private ArrayDeque<Integer> populatedDeque(int n) {
33	>	ArrayDeque<Integer> q = new ArrayDeque<Integer>();
34		assertTrue(q.isEmpty());
35		for (int i = 0; i < n; ++i)
36		assertTrue(q.offerLast(new Integer(i)));
#	Line 48 | Line 51 | public class ArrayDequeTest extends JSR1
51		*/
52		public void testConstructor3() {
53		try {
54	<	ArrayDeque q = new ArrayDeque((Collection)null);
54	>	new ArrayDeque((Collection)null);
55		shouldThrow();
56		} catch (NullPointerException success) {}
57		}
#	Line 58 | Line 61 | public class ArrayDequeTest extends JSR1
61		*/
62		public void testConstructor4() {
63		try {
64	<	Integer[] ints = new Integer[SIZE];
62	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
64	>	new ArrayDeque(Arrays.asList(new Integer[SIZE]));
65		shouldThrow();
66		} catch (NullPointerException success) {}
67		}
#	Line 68 | Line 70 | public class ArrayDequeTest extends JSR1
70		* Initializing from Collection with some null elements throws NPE
71		*/
72		public void testConstructor5() {
73	+	Integer[] ints = new Integer[SIZE];
74	+	for (int i = 0; i < SIZE - 1; ++i)
75	+	ints[i] = new Integer(i);
76		try {
77	<	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));
77	>	new ArrayDeque(Arrays.asList(ints));
78		shouldThrow();
79		} catch (NullPointerException success) {}
80		}
#	Line 109 | Line 111 | public class ArrayDequeTest extends JSR1
111		public void testSize() {
112		ArrayDeque q = populatedDeque(SIZE);
113		for (int i = 0; i < SIZE; ++i) {
114	<	assertEquals(SIZE-i, q.size());
114	>	assertEquals(SIZE - i, q.size());
115		q.removeFirst();
116		}
117		for (int i = 0; i < SIZE; ++i) {
#	Line 122 | Line 124 | public class ArrayDequeTest extends JSR1
124		* push(null) throws NPE
125		*/
126		public void testPushNull() {
127	+	ArrayDeque q = new ArrayDeque(1);
128		try {
126	–	ArrayDeque q = new ArrayDeque(1);
129		q.push(null);
130		shouldThrow();
131		} catch (NullPointerException success) {}
#	Line 157 | Line 159 | public class ArrayDequeTest extends JSR1
159		* offer(null) throws NPE
160		*/
161		public void testOfferNull() {
162	+	ArrayDeque q = new ArrayDeque();
163		try {
161	–	ArrayDeque q = new ArrayDeque();
164		q.offer(null);
165		shouldThrow();
166		} catch (NullPointerException success) {}
#	Line 168 | Line 170 | public class ArrayDequeTest extends JSR1
170		* offerFirst(null) throws NPE
171		*/
172		public void testOfferFirstNull() {
173	+	ArrayDeque q = new ArrayDeque();
174		try {
172	–	ArrayDeque q = new ArrayDeque();
175		q.offerFirst(null);
176		shouldThrow();
177		} catch (NullPointerException success) {}
#	Line 179 | Line 181 | public class ArrayDequeTest extends JSR1
181		* offerLast(null) throws NPE
182		*/
183		public void testOfferLastNull() {
184	+	ArrayDeque q = new ArrayDeque();
185		try {
183	–	ArrayDeque q = new ArrayDeque();
186		q.offerLast(null);
187		shouldThrow();
188		} catch (NullPointerException success) {}
#	Line 223 | Line 225 | public class ArrayDequeTest extends JSR1
225		* add(null) throws NPE
226		*/
227		public void testAddNull() {
228	+	ArrayDeque q = new ArrayDeque();
229		try {
227	–	ArrayDeque q = new ArrayDeque();
230		q.add(null);
231		shouldThrow();
232		} catch (NullPointerException success) {}
#	Line 234 | Line 236 | public class ArrayDequeTest extends JSR1
236		* addFirst(null) throws NPE
237		*/
238		public void testAddFirstNull() {
239	+	ArrayDeque q = new ArrayDeque();
240		try {
238	–	ArrayDeque q = new ArrayDeque();
241		q.addFirst(null);
242		shouldThrow();
243		} catch (NullPointerException success) {}
#	Line 245 | Line 247 | public class ArrayDequeTest extends JSR1
247		* addLast(null) throws NPE
248		*/
249		public void testAddLastNull() {
250	+	ArrayDeque q = new ArrayDeque();
251		try {
249	–	ArrayDeque q = new ArrayDeque();
252		q.addLast(null);
253		shouldThrow();
254		} catch (NullPointerException success) {}
#	Line 289 | Line 291 | public class ArrayDequeTest extends JSR1
291		* addAll(null) throws NPE
292		*/
293		public void testAddAll1() {
294	+	ArrayDeque q = new ArrayDeque();
295		try {
293	–	ArrayDeque q = new ArrayDeque();
296		q.addAll(null);
297		shouldThrow();
298		} catch (NullPointerException success) {}
#	Line 300 | Line 302 | public class ArrayDequeTest extends JSR1
302		* addAll of a collection with null elements throws NPE
303		*/
304		public void testAddAll2() {
305	+	ArrayDeque q = new ArrayDeque();
306		try {
307	<	ArrayDeque q = new ArrayDeque();
305	<	Integer[] ints = new Integer[SIZE];
306	<	q.addAll(Arrays.asList(ints));
307	>	q.addAll(Arrays.asList(new Integer[SIZE]));
308		shouldThrow();
309		} catch (NullPointerException success) {}
310		}
#	Line 313 | Line 314 | public class ArrayDequeTest extends JSR1
314		* possibly adding some elements
315		*/
316		public void testAddAll3() {
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);
321		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);
322		q.addAll(Arrays.asList(ints));
323		shouldThrow();
324		} catch (NullPointerException success) {}
#	Line 354 | Line 355 | public class ArrayDequeTest extends JSR1
355		*/
356		public void testPollLast() {
357		ArrayDeque q = populatedDeque(SIZE);
358	<	for (int i = SIZE-1; i >= 0; --i) {
358	>	for (int i = SIZE - 1; i >= 0; --i) {
359		assertEquals(i, q.pollLast());
360		}
361		assertNull(q.pollLast());
#	Line 390 | Line 391 | public class ArrayDequeTest extends JSR1
391		*/
392		public void testRemoveElement() {
393		ArrayDeque q = populatedDeque(SIZE);
394	<	for (int i = 1; i < SIZE; i+=2) {
395	<	assertTrue(q.remove(new Integer(i)));
396	<	}
397	<	for (int i = 0; i < SIZE; i+=2) {
398	<	assertTrue(q.remove(new Integer(i)));
399	<	assertFalse(q.remove(new Integer(i+1)));
394	>	for (int i = 1; i < SIZE; i += 2) {
395	>	assertTrue(q.contains(i));
396	>	assertTrue(q.remove(i));
397	>	assertFalse(q.contains(i));
398	>	assertTrue(q.contains(i-1));
399	>	}
400	>	for (int i = 0; i < SIZE; i += 2) {
401	>	assertTrue(q.contains(i));
402	>	assertTrue(q.remove(i));
403	>	assertFalse(q.contains(i));
404	>	assertFalse(q.remove(i+1));
405	>	assertFalse(q.contains(i+1));
406		}
407		assertTrue(q.isEmpty());
408		}
#	Line 433 | Line 440 | public class ArrayDequeTest extends JSR1
440		*/
441		public void testPeekLast() {
442		ArrayDeque q = populatedDeque(SIZE);
443	<	for (int i = SIZE-1; i >= 0; --i) {
443	>	for (int i = SIZE - 1; i >= 0; --i) {
444		assertEquals(i, q.peekLast());
445		assertEquals(i, q.pollLast());
446		assertTrue(q.peekLast() == null ||
#	Line 477 | Line 484 | public class ArrayDequeTest extends JSR1
484		*/
485		public void testLastElement() {
486		ArrayDeque q = populatedDeque(SIZE);
487	<	for (int i = SIZE-1; i >= 0; --i) {
487	>	for (int i = SIZE - 1; i >= 0; --i) {
488		assertEquals(i, q.getLast());
489		assertEquals(i, q.pollLast());
490		}
#	Line 488 | Line 495 | public class ArrayDequeTest extends JSR1
495		assertNull(q.peekLast());
496		}
497
491	–
498		/**
499		* removeFirst() removes first element, or throws NSEE if empty
500		*/
#	Line 524 | Line 530 | public class ArrayDequeTest extends JSR1
530		*/
531		public void testRemoveFirstOccurrence() {
532		ArrayDeque q = populatedDeque(SIZE);
533	<	for (int i = 1; i < SIZE; i+=2) {
533	>	for (int i = 1; i < SIZE; i += 2) {
534		assertTrue(q.removeFirstOccurrence(new Integer(i)));
535		}
536	<	for (int i = 0; i < SIZE; i+=2) {
536	>	for (int i = 0; i < SIZE; i += 2) {
537		assertTrue(q.removeFirstOccurrence(new Integer(i)));
538		assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
539		}
#	Line 539 | Line 545 | public class ArrayDequeTest extends JSR1
545		*/
546		public void testRemoveLastOccurrence() {
547		ArrayDeque q = populatedDeque(SIZE);
548	<	for (int i = 1; i < SIZE; i+=2) {
548	>	for (int i = 1; i < SIZE; i += 2) {
549		assertTrue(q.removeLastOccurrence(new Integer(i)));
550		}
551	<	for (int i = 0; i < SIZE; i+=2) {
551	>	for (int i = 0; i < SIZE; i += 2) {
552		assertTrue(q.removeLastOccurrence(new Integer(i)));
553		assertFalse(q.removeLastOccurrence(new Integer(i+1)));
554		}
#	Line 599 | Line 605 | public class ArrayDequeTest extends JSR1
605		boolean changed = q.retainAll(p);
606		assertEquals(changed, (i > 0));
607		assertTrue(q.containsAll(p));
608	<	assertEquals(SIZE-i, q.size());
608	>	assertEquals(SIZE - i, q.size());
609		p.removeFirst();
610		}
611		}
#	Line 612 | Line 618 | public class ArrayDequeTest extends JSR1
618		ArrayDeque q = populatedDeque(SIZE);
619		ArrayDeque p = populatedDeque(i);
620		assertTrue(q.removeAll(p));
621	<	assertEquals(SIZE-i, q.size());
621	>	assertEquals(SIZE - i, q.size());
622		for (int j = 0; j < i; ++j) {
623		assertFalse(q.contains(p.removeFirst()));
624		}
625		}
626		}
627
628	+	void checkToArray(ArrayDeque q) {
629	+	int size = q.size();
630	+	Object[] o = q.toArray();
631	+	assertEquals(size, o.length);
632	+	Iterator it = q.iterator();
633	+	for (int i = 0; i < size; i++) {
634	+	Integer x = (Integer) it.next();
635	+	assertEquals((Integer)o[0] + i, (int) x);
636	+	assertSame(o[i], x);
637	+	}
638	+	}
639	+
640		/**
641		* toArray() contains all elements in FIFO order
642		*/
643		public void testToArray() {
644	<	ArrayDeque q = populatedDeque(SIZE);
645	<	Object[] o = q.toArray();
646	<	for (int i = 0; i < o.length; i++)
647	<	assertSame(o[i], q.pollFirst());
644	>	ArrayDeque q = new ArrayDeque();
645	>	for (int i = 0; i < SIZE; i++) {
646	>	checkToArray(q);
647	>	q.addLast(i);
648	>	}
649	>	// Provoke wraparound
650	>	for (int i = 0; i < SIZE; i++) {
651	>	checkToArray(q);
652	>	assertEquals(i, q.poll());
653	>	q.addLast(SIZE + i);
654	>	}
655	>	for (int i = 0; i < SIZE; i++) {
656	>	checkToArray(q);
657	>	assertEquals(SIZE + i, q.poll());
658	>	}
659	>	}
660	>
661	>	void checkToArray2(ArrayDeque q) {
662	>	int size = q.size();
663	>	Integer[] a1 = size == 0 ? null : new Integer[size-1];
664	>	Integer[] a2 = new Integer[size];
665	>	Integer[] a3 = new Integer[size+2];
666	>	if (size > 0) Arrays.fill(a1, 42);
667	>	Arrays.fill(a2, 42);
668	>	Arrays.fill(a3, 42);
669	>	Integer[] b1 = size == 0 ? null : (Integer[]) q.toArray(a1);
670	>	Integer[] b2 = (Integer[]) q.toArray(a2);
671	>	Integer[] b3 = (Integer[]) q.toArray(a3);
672	>	assertSame(a2, b2);
673	>	assertSame(a3, b3);
674	>	Iterator it = q.iterator();
675	>	for (int i = 0; i < size; i++) {
676	>	Integer x = (Integer) it.next();
677	>	assertSame(b1[i], x);
678	>	assertEquals(b1[0] + i, (int) x);
679	>	assertSame(b2[i], x);
680	>	assertSame(b3[i], x);
681	>	}
682	>	assertNull(a3[size]);
683	>	assertEquals(42, (int) a3[size+1]);
684	>	if (size > 0) {
685	>	assertNotSame(a1, b1);
686	>	assertEquals(size, b1.length);
687	>	for (int i = 0; i < a1.length; i++) {
688	>	assertEquals(42, (int) a1[i]);
689	>	}
690	>	}
691		}
692
693		/**
694		* toArray(a) contains all elements in FIFO order
695		*/
696		public void testToArray2() {
697	<	ArrayDeque q = populatedDeque(SIZE);
698	<	Integer[] ints = new Integer[SIZE];
699	<	assertSame(ints, q.toArray(ints));
700	<	for (int i = 0; i < ints.length; i++)
701	<	assertSame(ints[i], q.remove());
697	>	ArrayDeque q = new ArrayDeque();
698	>	for (int i = 0; i < SIZE; i++) {
699	>	checkToArray2(q);
700	>	q.addLast(i);
701	>	}
702	>	// Provoke wraparound
703	>	for (int i = 0; i < SIZE; i++) {
704	>	checkToArray2(q);
705	>	assertEquals(i, q.poll());
706	>	q.addLast(SIZE + i);
707	>	}
708	>	for (int i = 0; i < SIZE; i++) {
709	>	checkToArray2(q);
710	>	assertEquals(SIZE + i, q.poll());
711	>	}
712		}
713
714		/**
#	Line 669 | Line 740 | public class ArrayDequeTest extends JSR1
740		*/
741		public void testIterator() {
742		ArrayDeque q = populatedDeque(SIZE);
672	–	int i = 0;
743		Iterator it = q.iterator();
744	<	while (it.hasNext()) {
744	>	int i;
745	>	for (i = 0; it.hasNext(); i++)
746		assertTrue(q.contains(it.next()));
676	–	++i;
677	–	}
747		assertEquals(i, SIZE);
748	+	assertIteratorExhausted(it);
749	+	}
750	+
751	+	/**
752	+	* iterator of empty collection has no elements
753	+	*/
754	+	public void testEmptyIterator() {
755	+	Deque c = new ArrayDeque();
756	+	assertIteratorExhausted(c.iterator());
757	+	assertIteratorExhausted(c.descendingIterator());
758		}
759
760		/**
#	Line 790 | Line 869 | public class ArrayDequeTest extends JSR1
869		}
870		}
871
793	–
872		/**
873		* toString() contains toStrings of elements
874		*/
#	Line 798 | Line 876 | public class ArrayDequeTest extends JSR1
876		ArrayDeque q = populatedDeque(SIZE);
877		String s = q.toString();
878		for (int i = 0; i < SIZE; ++i) {
879	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
879	>	assertTrue(s.contains(String.valueOf(i)));
880		}
881		}
882
#	Line 806 | Line 884 | public class ArrayDequeTest extends JSR1
884		* A deserialized serialized deque has same elements in same order
885		*/
886		public void testSerialization() throws Exception {
887	<	ArrayDeque q = populatedDeque(SIZE);
888	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
889	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
890	<	out.writeObject(q);
891	<	out.close();
892	<
893	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
894	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
895	<	ArrayDeque r = (ArrayDeque)in.readObject();
896	<	assertEquals(q.size(), r.size());
897	<	while (!q.isEmpty())
898	<	assertEquals(q.remove(), r.remove());
887	>	Queue x = populatedDeque(SIZE);
888	>	Queue y = serialClone(x);
889	>
890	>	assertNotSame(y, x);
891	>	assertEquals(x.size(), y.size());
892	>	assertEquals(x.toString(), y.toString());
893	>	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
894	>	while (!x.isEmpty()) {
895	>	assertFalse(y.isEmpty());
896	>	assertEquals(x.remove(), y.remove());
897	>	}
898	>	assertTrue(y.isEmpty());
899	>	}
900	>
901	>	/**
902	>	* remove(null), contains(null) always return false
903	>	*/
904	>	public void testNeverContainsNull() {
905	>	Deque<?>[] qs = {
906	>	new ArrayDeque<Object>(),
907	>	populatedDeque(2),
908	>	};
909	>
910	>	for (Deque<?> q : qs) {
911	>	assertFalse(q.contains(null));
912	>	assertFalse(q.remove(null));
913	>	assertFalse(q.removeFirstOccurrence(null));
914	>	assertFalse(q.removeLastOccurrence(null));
915	>	}
916		}
917
918		}

Diff Legend

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