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.50 by jsr166, Sat Oct 22 05:45:56 2016 UTC vs.
Revision 1.52 by jsr166, Sun Oct 30 21:07:27 2016 UTC

#	Line 14 | Line 14 | import java.util.Iterator;
14		import java.util.NoSuchElementException;
15		import java.util.Queue;
16		import java.util.Random;
17	–	import java.util.Spliterator;
17		import java.util.concurrent.ThreadLocalRandom;
18
19		import junit.framework.Test;
#	Line 681 | Line 680 | public class ArrayDequeTest extends JSR1
680		}
681		}
682
683	<	void checkToArray(ArrayDeque q) {
683	>	void checkToArray(ArrayDeque<Integer> q) {
684		int size = q.size();
685	<	Object[] o = q.toArray();
686	<	assertEquals(size, o.length);
685	>	Object[] a1 = q.toArray();
686	>	assertEquals(size, a1.length);
687	>	Integer[] a2 = q.toArray(new Integer[0]);
688	>	assertEquals(size, a2.length);
689	>	Integer[] a3 = q.toArray(new Integer[Math.max(0, size - 1)]);
690	>	assertEquals(size, a3.length);
691	>	Integer[] a4 = new Integer[size];
692	>	assertSame(a4, q.toArray(a4));
693	>	Integer[] a5 = new Integer[size + 1];
694	>	Arrays.fill(a5, 42);
695	>	assertSame(a5, q.toArray(a5));
696	>	Integer[] a6 = new Integer[size + 2];
697	>	Arrays.fill(a6, 42);
698	>	assertSame(a6, q.toArray(a6));
699	>	Object[][] as = { a1, a2, a3, a4, a5, a6 };
700	>	for (Object[] a : as) {
701	>	if (a.length > size) assertNull(a[size]);
702	>	if (a.length > size + 1) assertEquals(42, a[size + 1]);
703	>	}
704		Iterator it = q.iterator();
705	+	Integer s = q.peekFirst();
706		for (int i = 0; i < size; i++) {
707		Integer x = (Integer) it.next();
708	<	assertEquals((Integer)o[0] + i, (int) x);
709	<	assertSame(o[i], x);
708	>	assertEquals(s + i, (int) x);
709	>	for (Object[] a : as)
710	>	assertSame(a1[i], x);
711		}
712		}
713
714		/**
715	<	* toArray() contains all elements in FIFO order
715	>	* toArray() and toArray(a) contain all elements in FIFO order
716		*/
717		public void testToArray() {
718	<	ArrayDeque q = new ArrayDeque();
719	<	for (int i = 0; i < SIZE; i++) {
718	>	final int size = ThreadLocalRandom.current().nextInt(10);
719	>	ArrayDeque<Integer> q = new ArrayDeque<>(size);
720	>	for (int i = 0; i < size; i++) {
721		checkToArray(q);
722		q.addLast(i);
723		}
724		// Provoke wraparound
725	<	for (int i = 0; i < SIZE; i++) {
725	>	int added = size * 2;
726	>	for (int i = 0; i < added; i++) {
727		checkToArray(q);
728	<	assertEquals(i, q.poll());
729	<	q.addLast(SIZE + i);
728	>	assertEquals((Integer) i, q.poll());
729	>	q.addLast(size + i);
730		}
711	–	for (int i = 0; i < SIZE; i++) {
712	–	checkToArray(q);
713	–	assertEquals(SIZE + i, q.poll());
714	–	}
715	–	}
716	–
717	–	void checkToArray2(ArrayDeque q) {
718	–	int size = q.size();
719	–	Integer[] a1 = (size == 0) ? null : new Integer[size - 1];
720	–	Integer[] a2 = new Integer[size];
721	–	Integer[] a3 = new Integer[size + 2];
722	–	if (size > 0) Arrays.fill(a1, 42);
723	–	Arrays.fill(a2, 42);
724	–	Arrays.fill(a3, 42);
725	–	Integer[] b1 = (size == 0) ? null : (Integer[]) q.toArray(a1);
726	–	Integer[] b2 = (Integer[]) q.toArray(a2);
727	–	Integer[] b3 = (Integer[]) q.toArray(a3);
728	–	assertSame(a2, b2);
729	–	assertSame(a3, b3);
730	–	Iterator it = q.iterator();
731		for (int i = 0; i < size; i++) {
732	<	Integer x = (Integer) it.next();
733	<	assertSame(b1[i], x);
734	<	assertEquals(b1[0] + i, (int) x);
735	<	assertSame(b2[i], x);
736	<	assertSame(b3[i], x);
737	<	}
738	<	assertNull(a3[size]);
739	<	assertEquals(42, (int) a3[size + 1]);
740	<	if (size > 0) {
741	<	assertNotSame(a1, b1);
742	<	assertEquals(size, b1.length);
743	<	for (int i = 0; i < a1.length; i++) {
744	<	assertEquals(42, (int) a1[i]);
745	<	}
746	<	}
747	<	}
748	<
749	<	/**
750	<	* toArray(a) contains all elements in FIFO order
751	<	*/
752	<	public void testToArray2() {
753	<	ArrayDeque q = new ArrayDeque();
754	<	for (int i = 0; i < SIZE; i++) {
755	<	checkToArray2(q);
756	<	q.addLast(i);
757	<	}
758	<	// Provoke wraparound
759	<	for (int i = 0; i < SIZE; i++) {
760	<	checkToArray2(q);
761	<	assertEquals(i, q.poll());
762	<	q.addLast(SIZE + i);
763	<	}
764	<	for (int i = 0; i < SIZE; i++) {
765	<	checkToArray2(q);
766	<	assertEquals(SIZE + i, q.poll());
732	>	checkToArray(q);
733	>	assertEquals((Integer) (added + i), q.poll());
734		}
735		}
736
#	Line 782 | Line 749 | public class ArrayDequeTest extends JSR1
749		/**
750		* toArray(incompatible array type) throws ArrayStoreException
751		*/
752	<	public void testToArray1_BadArg() {
752	>	public void testToArray_incompatibleArrayType() {
753		ArrayDeque l = new ArrayDeque();
754		l.add(new Integer(5));
755		try {
756		l.toArray(new String[10]);
757		shouldThrow();
758		} catch (ArrayStoreException success) {}
759	+	try {
760	+	l.toArray(new String[0]);
761	+	shouldThrow();
762	+	} catch (ArrayStoreException success) {}
763		}
764
765		/**
#	Line 989 | Line 960 | public class ArrayDequeTest extends JSR1
960		}
961		}
962
992	–	/**
993	–	* Spliterator characteristics are as advertised
994	–	*/
995	–	public void testSpliterator_characteristics() {
996	–	ArrayDeque q = new ArrayDeque();
997	–	Spliterator s = q.spliterator();
998	–	int characteristics = s.characteristics();
999	–	int required = Spliterator.NONNULL
1000	–	| Spliterator.ORDERED
1001	–	| Spliterator.SIZED
1002	–	| Spliterator.SUBSIZED;
1003	–	assertEquals(required, characteristics & required);
1004	–	assertTrue(s.hasCharacteristics(required));
1005	–	assertEquals(0, characteristics
1006	–	& (Spliterator.CONCURRENT
1007	–	| Spliterator.DISTINCT
1008	–	| Spliterator.IMMUTABLE
1009	–	| Spliterator.SORTED));
1010	–	}
1011	–
1012	–	/**
1013	–	* Spliterator.getComparator always throws IllegalStateException
1014	–	*/
1015	–	public void testSpliterator_getComparator() {
1016	–	assertThrows(IllegalStateException.class,
1017	–	() -> new ArrayDeque().spliterator().getComparator());
1018	–	}
1019	–
1020	–	/**
1021	–	* Handle capacities near Integer.MAX_VALUE.
1022	–	* ant -Dvmoptions='-Xms28g -Xmx28g' -Djsr166.testImplementationDetails=true -Djsr166.expensiveTests=true -Djsr166.tckTestClass=ArrayDequeTest -Djsr166.methodFilter=testHuge tck
1023	–	*/
1024	–	public void testHuge() {
1025	–	if (! (testImplementationDetails
1026	–	&& expensiveTests
1027	–	&& Runtime.getRuntime().maxMemory() > 24L * (1 << 30)))
1028	–	return;
1029	–
1030	–	ArrayDeque q;
1031	–	Integer e = 42;
1032	–	final int maxSize = Integer.MAX_VALUE - 8;
1033	–
1034	–	assertThrows(OutOfMemoryError.class,
1035	–	() -> new ArrayDeque<>(Integer.MAX_VALUE));
1036	–
1037	–	{
1038	–	q = new ArrayDeque<>(maxSize);
1039	–	assertEquals(0, q.size());
1040	–	assertTrue(q.isEmpty());
1041	–	q = null;
1042	–	}
1043	–
1044	–	{
1045	–	q = new ArrayDeque();
1046	–	assertTrue(q.addAll(Collections.nCopies(maxSize - 2, e)));
1047	–	assertEquals(e, q.peekFirst());
1048	–	assertEquals(e, q.peekLast());
1049	–	assertEquals(maxSize - 2, q.size());
1050	–	q.addFirst((Integer) 0);
1051	–	q.addLast((Integer) 1);
1052	–	assertEquals((Integer) 0, q.peekFirst());
1053	–	assertEquals((Integer) 1, q.peekLast());
1054	–	assertEquals(maxSize, q.size());
1055	–
1056	–	ArrayDeque qq = q;
1057	–	ArrayDeque smallish = new ArrayDeque(
1058	–	Collections.nCopies(Integer.MAX_VALUE - maxSize + 1, e));
1059	–	assertThrows(
1060	–	IllegalStateException.class,
1061	–	() -> qq.addAll(qq),
1062	–	() -> qq.addAll(smallish),
1063	–	() -> smallish.addAll(qq));
1064	–	}
1065	–	}
1066	–
963		}

Diff Legend

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