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.25 by jsr166, Tue Feb 21 01:54:03 2012 UTC vs.
Revision 1.39 by jsr166, Mon Oct 10 14:18:06 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() {
#	Line 24 | Line 26 | public class ArrayDequeTest extends JSR1
26		}
27
28		/**
29	<	* Creates 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<Integer> populatedDeque(int n) {
#	Line 49 | 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 59 | Line 61 | public class ArrayDequeTest extends JSR1
61		*/
62		public void testConstructor4() {
63		try {
64	<	Integer[] ints = new Integer[SIZE];
63	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
64	>	new ArrayDeque(Arrays.asList(new Integer[SIZE]));
65		shouldThrow();
66		} catch (NullPointerException success) {}
67		}
#	Line 69 | 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];
74	<	for (int i = 0; i < SIZE-1; ++i)
75	<	ints[i] = new Integer(i);
76	<	ArrayDeque q = new ArrayDeque(Arrays.asList(ints));
77	>	new ArrayDeque(Arrays.asList(ints));
78		shouldThrow();
79		} catch (NullPointerException success) {}
80		}
#	Line 110 | 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 123 | 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 {
127	–	ArrayDeque q = new ArrayDeque(1);
129		q.push(null);
130		shouldThrow();
131		} catch (NullPointerException success) {}
#	Line 158 | Line 159 | public class ArrayDequeTest extends JSR1
159		* offer(null) throws NPE
160		*/
161		public void testOfferNull() {
162	+	ArrayDeque q = new ArrayDeque();
163		try {
162	–	ArrayDeque q = new ArrayDeque();
164		q.offer(null);
165		shouldThrow();
166		} catch (NullPointerException success) {}
#	Line 169 | Line 170 | public class ArrayDequeTest extends JSR1
170		* offerFirst(null) throws NPE
171		*/
172		public void testOfferFirstNull() {
173	+	ArrayDeque q = new ArrayDeque();
174		try {
173	–	ArrayDeque q = new ArrayDeque();
175		q.offerFirst(null);
176		shouldThrow();
177		} catch (NullPointerException success) {}
#	Line 180 | Line 181 | public class ArrayDequeTest extends JSR1
181		* offerLast(null) throws NPE
182		*/
183		public void testOfferLastNull() {
184	+	ArrayDeque q = new ArrayDeque();
185		try {
184	–	ArrayDeque q = new ArrayDeque();
186		q.offerLast(null);
187		shouldThrow();
188		} catch (NullPointerException success) {}
#	Line 224 | Line 225 | public class ArrayDequeTest extends JSR1
225		* add(null) throws NPE
226		*/
227		public void testAddNull() {
228	+	ArrayDeque q = new ArrayDeque();
229		try {
228	–	ArrayDeque q = new ArrayDeque();
230		q.add(null);
231		shouldThrow();
232		} catch (NullPointerException success) {}
#	Line 235 | Line 236 | public class ArrayDequeTest extends JSR1
236		* addFirst(null) throws NPE
237		*/
238		public void testAddFirstNull() {
239	+	ArrayDeque q = new ArrayDeque();
240		try {
239	–	ArrayDeque q = new ArrayDeque();
241		q.addFirst(null);
242		shouldThrow();
243		} catch (NullPointerException success) {}
#	Line 246 | Line 247 | public class ArrayDequeTest extends JSR1
247		* addLast(null) throws NPE
248		*/
249		public void testAddLastNull() {
250	+	ArrayDeque q = new ArrayDeque();
251		try {
250	–	ArrayDeque q = new ArrayDeque();
252		q.addLast(null);
253		shouldThrow();
254		} catch (NullPointerException success) {}
#	Line 290 | Line 291 | public class ArrayDequeTest extends JSR1
291		* addAll(null) throws NPE
292		*/
293		public void testAddAll1() {
294	+	ArrayDeque q = new ArrayDeque();
295		try {
294	–	ArrayDeque q = new ArrayDeque();
296		q.addAll(null);
297		shouldThrow();
298		} catch (NullPointerException success) {}
#	Line 301 | 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();
306	<	Integer[] ints = new Integer[SIZE];
307	<	q.addAll(Arrays.asList(ints));
307	>	q.addAll(Arrays.asList(new Integer[SIZE]));
308		shouldThrow();
309		} catch (NullPointerException success) {}
310		}
#	Line 314 | 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 {
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);
322		q.addAll(Arrays.asList(ints));
323		shouldThrow();
324		} catch (NullPointerException success) {}
#	Line 355 | 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 391 | 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) {
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));
398	>	assertTrue(q.contains(i - 1));
399		}
400	<	for (int i = 0; i < SIZE; i+=2) {
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));
404	>	assertFalse(q.remove(i + 1));
405	>	assertFalse(q.contains(i + 1));
406		}
407		assertTrue(q.isEmpty());
408		}
#	Line 440 | 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 484 | 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 530 | 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 545 | 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 605 | 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 618 | 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<Integer> q = populatedDeque(SIZE);
710	<	Integer[] ints = new Integer[SIZE];
711	<	Integer[] array = q.toArray(ints);
712	<	assertSame(ints, array);
713	<	for (int i = 0; i < ints.length; i++)
714	<	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 676 | Line 752 | public class ArrayDequeTest extends JSR1
752		*/
753		public void testIterator() {
754		ArrayDeque q = populatedDeque(SIZE);
679	–	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()));
683	–	++i;
684	–	}
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 709 | 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 777 | 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 815 | Line 899 | public class ArrayDequeTest extends JSR1
899		Queue x = populatedDeque(SIZE);
900		Queue y = serialClone(x);
901
902	<	assertTrue(x != y);
902	>	assertNotSame(y, x);
903		assertEquals(x.size(), y.size());
904		assertEquals(x.toString(), y.toString());
905		assertTrue(Arrays.equals(x.toArray(), y.toArray()));
#	Line 826 | Line 910 | public class ArrayDequeTest extends JSR1
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