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.39 by jsr166, Mon Oct 10 14:18:06 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() {
#	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	>	assertFalse(q.removeFirstOccurrence(null));
534	>	for (int i = 1; i < SIZE; i += 2) {
535		assertTrue(q.removeFirstOccurrence(new Integer(i)));
536		}
537	<	for (int i = 0; i < SIZE; i+=2) {
537	>	for (int i = 0; i < SIZE; i += 2) {
538		assertTrue(q.removeFirstOccurrence(new Integer(i)));
539	<	assertFalse(q.removeFirstOccurrence(new Integer(i+1)));
539	>	assertFalse(q.removeFirstOccurrence(new Integer(i + 1)));
540		}
541		assertTrue(q.isEmpty());
542	+	assertFalse(q.removeFirstOccurrence(null));
543	+	assertFalse(q.removeFirstOccurrence(42));
544	+	q = new ArrayDeque();
545	+	assertFalse(q.removeFirstOccurrence(null));
546	+	assertFalse(q.removeFirstOccurrence(42));
547		}
548
549		/**
#	Line 539 | Line 551 | public class ArrayDequeTest extends JSR1
551		*/
552		public void testRemoveLastOccurrence() {
553		ArrayDeque q = populatedDeque(SIZE);
554	<	for (int i = 1; i < SIZE; i+=2) {
554	>	assertFalse(q.removeLastOccurrence(null));
555	>	for (int i = 1; i < SIZE; i += 2) {
556		assertTrue(q.removeLastOccurrence(new Integer(i)));
557		}
558	<	for (int i = 0; i < SIZE; i+=2) {
558	>	for (int i = 0; i < SIZE; i += 2) {
559		assertTrue(q.removeLastOccurrence(new Integer(i)));
560	<	assertFalse(q.removeLastOccurrence(new Integer(i+1)));
560	>	assertFalse(q.removeLastOccurrence(new Integer(i + 1)));
561		}
562		assertTrue(q.isEmpty());
563	+	assertFalse(q.removeLastOccurrence(null));
564	+	assertFalse(q.removeLastOccurrence(42));
565	+	q = new ArrayDeque();
566	+	assertFalse(q.removeLastOccurrence(null));
567	+	assertFalse(q.removeLastOccurrence(42));
568		}
569
570		/**
#	Line 599 | Line 617 | public class ArrayDequeTest extends JSR1
617		boolean changed = q.retainAll(p);
618		assertEquals(changed, (i > 0));
619		assertTrue(q.containsAll(p));
620	<	assertEquals(SIZE-i, q.size());
620	>	assertEquals(SIZE - i, q.size());
621		p.removeFirst();
622		}
623		}
#	Line 612 | Line 630 | public class ArrayDequeTest extends JSR1
630		ArrayDeque q = populatedDeque(SIZE);
631		ArrayDeque p = populatedDeque(i);
632		assertTrue(q.removeAll(p));
633	<	assertEquals(SIZE-i, q.size());
633	>	assertEquals(SIZE - i, q.size());
634		for (int j = 0; j < i; ++j) {
635		assertFalse(q.contains(p.removeFirst()));
636		}
637		}
638		}
639
640	+	void checkToArray(ArrayDeque q) {
641	+	int size = q.size();
642	+	Object[] o = q.toArray();
643	+	assertEquals(size, o.length);
644	+	Iterator it = q.iterator();
645	+	for (int i = 0; i < size; i++) {
646	+	Integer x = (Integer) it.next();
647	+	assertEquals((Integer)o[0] + i, (int) x);
648	+	assertSame(o[i], x);
649	+	}
650	+	}
651	+
652		/**
653		* toArray() contains all elements in FIFO order
654		*/
655		public void testToArray() {
656	<	ArrayDeque q = populatedDeque(SIZE);
657	<	Object[] o = q.toArray();
658	<	for (int i = 0; i < o.length; i++)
659	<	assertSame(o[i], q.pollFirst());
656	>	ArrayDeque q = new ArrayDeque();
657	>	for (int i = 0; i < SIZE; i++) {
658	>	checkToArray(q);
659	>	q.addLast(i);
660	>	}
661	>	// Provoke wraparound
662	>	for (int i = 0; i < SIZE; i++) {
663	>	checkToArray(q);
664	>	assertEquals(i, q.poll());
665	>	q.addLast(SIZE + i);
666	>	}
667	>	for (int i = 0; i < SIZE; i++) {
668	>	checkToArray(q);
669	>	assertEquals(SIZE + i, q.poll());
670	>	}
671	>	}
672	>
673	>	void checkToArray2(ArrayDeque q) {
674	>	int size = q.size();
675	>	Integer[] a1 = (size == 0) ? null : new Integer[size - 1];
676	>	Integer[] a2 = new Integer[size];
677	>	Integer[] a3 = new Integer[size + 2];
678	>	if (size > 0) Arrays.fill(a1, 42);
679	>	Arrays.fill(a2, 42);
680	>	Arrays.fill(a3, 42);
681	>	Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);
682	>	Integer[] b2 = (Integer[]) q.toArray(a2);
683	>	Integer[] b3 = (Integer[]) q.toArray(a3);
684	>	assertSame(a2, b2);
685	>	assertSame(a3, b3);
686	>	Iterator it = q.iterator();
687	>	for (int i = 0; i < size; i++) {
688	>	Integer x = (Integer) it.next();
689	>	assertSame(b1[i], x);
690	>	assertEquals(b1[0] + i, (int) x);
691	>	assertSame(b2[i], x);
692	>	assertSame(b3[i], x);
693	>	}
694	>	assertNull(a3[size]);
695	>	assertEquals(42, (int) a3[size + 1]);
696	>	if (size > 0) {
697	>	assertNotSame(a1, b1);
698	>	assertEquals(size, b1.length);
699	>	for (int i = 0; i < a1.length; i++) {
700	>	assertEquals(42, (int) a1[i]);
701	>	}
702	>	}
703		}
704
705		/**
706		* toArray(a) contains all elements in FIFO order
707		*/
708		public void testToArray2() {
709	<	ArrayDeque q = populatedDeque(SIZE);
710	<	Integer[] ints = new Integer[SIZE];
711	<	assertSame(ints, q.toArray(ints));
712	<	for (int i = 0; i < ints.length; i++)
713	<	assertSame(ints[i], q.remove());
709	>	ArrayDeque q = new ArrayDeque();
710	>	for (int i = 0; i < SIZE; i++) {
711	>	checkToArray2(q);
712	>	q.addLast(i);
713	>	}
714	>	// Provoke wraparound
715	>	for (int i = 0; i < SIZE; i++) {
716	>	checkToArray2(q);
717	>	assertEquals(i, q.poll());
718	>	q.addLast(SIZE + i);
719	>	}
720	>	for (int i = 0; i < SIZE; i++) {
721	>	checkToArray2(q);
722	>	assertEquals(SIZE + i, q.poll());
723	>	}
724		}
725
726		/**
#	Line 669 | Line 752 | public class ArrayDequeTest extends JSR1
752		*/
753		public void testIterator() {
754		ArrayDeque q = populatedDeque(SIZE);
672	–	int i = 0;
755		Iterator it = q.iterator();
756	<	while (it.hasNext()) {
756	>	int i;
757	>	for (i = 0; it.hasNext(); i++)
758		assertTrue(q.contains(it.next()));
676	–	++i;
677	–	}
759		assertEquals(i, SIZE);
760	+	assertIteratorExhausted(it);
761	+	}
762	+
763	+	/**
764	+	* iterator of empty collection has no elements
765	+	*/
766	+	public void testEmptyIterator() {
767	+	Deque c = new ArrayDeque();
768	+	assertIteratorExhausted(c.iterator());
769	+	assertIteratorExhausted(c.descendingIterator());
770		}
771
772		/**
#	Line 702 | Line 793 | public class ArrayDequeTest extends JSR1
793		final Random rng = new Random();
794		for (int iters = 0; iters < 100; ++iters) {
795		int max = rng.nextInt(5) + 2;
796	<	int split = rng.nextInt(max-1) + 1;
796	>	int split = rng.nextInt(max - 1) + 1;
797		for (int j = 1; j <= max; ++j)
798		q.add(new Integer(j));
799		Iterator it = q.iterator();
800		for (int j = 1; j <= split; ++j)
801		assertEquals(it.next(), new Integer(j));
802		it.remove();
803	<	assertEquals(it.next(), new Integer(split+1));
803	>	assertEquals(it.next(), new Integer(split + 1));
804		for (int j = 1; j <= split; ++j)
805		q.remove(new Integer(j));
806		it = q.iterator();
807	<	for (int j = split+1; j <= max; ++j) {
807	>	for (int j = split + 1; j <= max; ++j) {
808		assertEquals(it.next(), new Integer(j));
809		it.remove();
810		}
#	Line 770 | Line 861 | public class ArrayDequeTest extends JSR1
861		final Random rng = new Random();
862		for (int iters = 0; iters < 100; ++iters) {
863		int max = rng.nextInt(5) + 2;
864	<	int split = rng.nextInt(max-1) + 1;
864	>	int split = rng.nextInt(max - 1) + 1;
865		for (int j = max; j >= 1; --j)
866		q.add(new Integer(j));
867		Iterator it = q.descendingIterator();
868		for (int j = 1; j <= split; ++j)
869		assertEquals(it.next(), new Integer(j));
870		it.remove();
871	<	assertEquals(it.next(), new Integer(split+1));
871	>	assertEquals(it.next(), new Integer(split + 1));
872		for (int j = 1; j <= split; ++j)
873		q.remove(new Integer(j));
874		it = q.descendingIterator();
875	<	for (int j = split+1; j <= max; ++j) {
875	>	for (int j = split + 1; j <= max; ++j) {
876		assertEquals(it.next(), new Integer(j));
877		it.remove();
878		}
#	Line 790 | Line 881 | public class ArrayDequeTest extends JSR1
881		}
882		}
883
793	–
884		/**
885		* toString() contains toStrings of elements
886		*/
#	Line 798 | Line 888 | public class ArrayDequeTest extends JSR1
888		ArrayDeque q = populatedDeque(SIZE);
889		String s = q.toString();
890		for (int i = 0; i < SIZE; ++i) {
891	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
891	>	assertTrue(s.contains(String.valueOf(i)));
892		}
893		}
894
#	Line 806 | Line 896 | public class ArrayDequeTest extends JSR1
896		* A deserialized serialized deque has same elements in same order
897		*/
898		public void testSerialization() throws Exception {
899	<	ArrayDeque q = populatedDeque(SIZE);
900	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
901	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
902	<	out.writeObject(q);
903	<	out.close();
904	<
905	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
906	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
907	<	ArrayDeque r = (ArrayDeque)in.readObject();
908	<	assertEquals(q.size(), r.size());
909	<	while (!q.isEmpty())
910	<	assertEquals(q.remove(), r.remove());
899	>	Queue x = populatedDeque(SIZE);
900	>	Queue y = serialClone(x);
901	>
902	>	assertNotSame(y, x);
903	>	assertEquals(x.size(), y.size());
904	>	assertEquals(x.toString(), y.toString());
905	>	assertTrue(Arrays.equals(x.toArray(), y.toArray()));
906	>	while (!x.isEmpty()) {
907	>	assertFalse(y.isEmpty());
908	>	assertEquals(x.remove(), y.remove());
909	>	}
910	>	assertTrue(y.isEmpty());
911	>	}
912	>
913	>	/**
914	>	* remove(null), contains(null) always return false
915	>	*/
916	>	public void testNeverContainsNull() {
917	>	Deque<?>[] qs = {
918	>	new ArrayDeque<Object>(),
919	>	populatedDeque(2),
920	>	};
921	>
922	>	for (Deque<?> q : qs) {
923	>	assertFalse(q.contains(null));
924	>	assertFalse(q.remove(null));
925	>	assertFalse(q.removeFirstOccurrence(null));
926	>	assertFalse(q.removeLastOccurrence(null));
927	>	}
928		}
929
930		}

Diff Legend

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