ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/tck/ConcurrentSkipListSubSetTest.java

Comparing jsr166/src/test/tck/ConcurrentSkipListSubSetTest.java (file contents):
Revision 1.32 by jsr166, Sat Apr 25 04:55:30 2015 UTC vs.
Revision 1.39 by jsr166, Mon May 28 21:19:50 2018 UTC

#	Line 30 | Line 30 | public class ConcurrentSkipListSubSetTes
30
31		/**
32		* Returns a new set of given size containing consecutive
33	<	* Integers 0 ... n.
33	>	* Integers 0 ... n - 1.
34		*/
35	<	private NavigableSet<Integer> populatedSet(int n) {
36	<	ConcurrentSkipListSet<Integer> q =
37	<	new ConcurrentSkipListSet<Integer>();
35	>	private static NavigableSet<Integer> populatedSet(int n) {
36	>	ConcurrentSkipListSet<Integer> q = new ConcurrentSkipListSet<>();
37		assertTrue(q.isEmpty());
38
39	<	for (int i = n-1; i >= 0; i -= 2)
39	>	for (int i = n - 1; i >= 0; i -= 2)
40		assertTrue(q.add(new Integer(i)));
41		for (int i = (n & 1); i < n; i += 2)
42		assertTrue(q.add(new Integer(i)));
#	Line 52 | Line 51 | public class ConcurrentSkipListSubSetTes
51		/**
52		* Returns a new set of first 5 ints.
53		*/
54	<	private NavigableSet set5() {
54	>	private static NavigableSet set5() {
55		ConcurrentSkipListSet q = new ConcurrentSkipListSet();
56		assertTrue(q.isEmpty());
57		q.add(one);
#	Line 70 | Line 69 | public class ConcurrentSkipListSubSetTes
69		/**
70		* Returns a new set of first 5 negative ints.
71		*/
72	<	private NavigableSet dset5() {
72	>	private static NavigableSet dset5() {
73		ConcurrentSkipListSet q = new ConcurrentSkipListSet();
74		assertTrue(q.isEmpty());
75		q.add(m1);
#	Line 122 | Line 121 | public class ConcurrentSkipListSubSetTes
121		public void testSize() {
122		NavigableSet q = populatedSet(SIZE);
123		for (int i = 0; i < SIZE; ++i) {
124	<	assertEquals(SIZE-i, q.size());
124	>	assertEquals(SIZE - i, q.size());
125		q.pollFirst();
126		}
127		for (int i = 0; i < SIZE; ++i) {
#	Line 201 | Line 200 | public class ConcurrentSkipListSubSetTes
200		public void testAddAll3() {
201		NavigableSet q = set0();
202		Integer[] ints = new Integer[SIZE];
203	<	for (int i = 0; i < SIZE-1; ++i)
204	<	ints[i] = new Integer(i+SIZE);
203	>	for (int i = 0; i < SIZE - 1; ++i)
204	>	ints[i] = new Integer(i + SIZE);
205		try {
206		q.addAll(Arrays.asList(ints));
207		shouldThrow();
#	Line 216 | Line 215 | public class ConcurrentSkipListSubSetTes
215		Integer[] empty = new Integer[0];
216		Integer[] ints = new Integer[SIZE];
217		for (int i = 0; i < SIZE; ++i)
218	<	ints[i] = new Integer(SIZE-1- i);
218	>	ints[i] = new Integer(SIZE - 1 - i);
219		NavigableSet q = set0();
220		assertFalse(q.addAll(Arrays.asList(empty)));
221		assertTrue(q.addAll(Arrays.asList(ints)));
#	Line 244 | Line 243 | public class ConcurrentSkipListSubSetTes
243		assertTrue(q.contains(i));
244		assertTrue(q.remove(i));
245		assertFalse(q.contains(i));
246	<	assertTrue(q.contains(i-1));
246	>	assertTrue(q.contains(i - 1));
247		}
248		for (int i = 0; i < SIZE; i += 2) {
249		assertTrue(q.contains(i));
250		assertTrue(q.remove(i));
251		assertFalse(q.contains(i));
252	<	assertFalse(q.remove(i+1));
253	<	assertFalse(q.contains(i+1));
252	>	assertFalse(q.remove(i + 1));
253	>	assertFalse(q.contains(i + 1));
254		}
255		assertTrue(q.isEmpty());
256		}
#	Line 310 | Line 309 | public class ConcurrentSkipListSubSetTes
309		assertTrue(changed);
310
311		assertTrue(q.containsAll(p));
312	<	assertEquals(SIZE-i, q.size());
312	>	assertEquals(SIZE - i, q.size());
313		p.pollFirst();
314		}
315		}
#	Line 323 | Line 322 | public class ConcurrentSkipListSubSetTes
322		NavigableSet q = populatedSet(SIZE);
323		NavigableSet p = populatedSet(i);
324		assertTrue(q.removeAll(p));
325	<	assertEquals(SIZE-i, q.size());
325	>	assertEquals(SIZE - i, q.size());
326		for (int j = 0; j < i; ++j) {
327		Integer x = (Integer)(p.pollFirst());
328		assertFalse(q.contains(x));
#	Line 408 | Line 407 | public class ConcurrentSkipListSubSetTes
407		*/
408		public void testToArray() {
409		NavigableSet q = populatedSet(SIZE);
410	<	Object[] o = q.toArray();
411	<	for (int i = 0; i < o.length; i++)
412	<	assertSame(o[i], q.pollFirst());
410	>	Object[] a = q.toArray();
411	>	assertSame(Object[].class, a.getClass());
412	>	for (Object o : a)
413	>	assertSame(o, q.pollFirst());
414	>	assertTrue(q.isEmpty());
415		}
416
417		/**
#	Line 421 | Line 422 | public class ConcurrentSkipListSubSetTes
422		Integer[] ints = new Integer[SIZE];
423		Integer[] array = q.toArray(ints);
424		assertSame(ints, array);
425	<	for (int i = 0; i < ints.length; i++)
426	<	assertSame(ints[i], q.pollFirst());
425	>	for (Integer o : ints)
426	>	assertSame(o, q.pollFirst());
427	>	assertTrue(q.isEmpty());
428		}
429
430		/**
#	Line 476 | Line 478 | public class ConcurrentSkipListSubSetTes
478		}
479
480		/**
481	<	* A deserialized serialized set has same elements
481	>	* A deserialized/reserialized set equals original
482		*/
483		public void testSerialization() throws Exception {
484		NavigableSet x = populatedSet(SIZE);
#	Line 618 | Line 620 | public class ConcurrentSkipListSubSetTes
620		public void testDescendingSize() {
621		NavigableSet q = populatedSet(SIZE);
622		for (int i = 0; i < SIZE; ++i) {
623	<	assertEquals(SIZE-i, q.size());
623	>	assertEquals(SIZE - i, q.size());
624		q.pollFirst();
625		}
626		for (int i = 0; i < SIZE; ++i) {
#	Line 697 | Line 699 | public class ConcurrentSkipListSubSetTes
699		public void testDescendingAddAll3() {
700		NavigableSet q = dset0();
701		Integer[] ints = new Integer[SIZE];
702	<	for (int i = 0; i < SIZE-1; ++i)
703	<	ints[i] = new Integer(i+SIZE);
702	>	for (int i = 0; i < SIZE - 1; ++i)
703	>	ints[i] = new Integer(i + SIZE);
704		try {
705		q.addAll(Arrays.asList(ints));
706		shouldThrow();
#	Line 712 | Line 714 | public class ConcurrentSkipListSubSetTes
714		Integer[] empty = new Integer[0];
715		Integer[] ints = new Integer[SIZE];
716		for (int i = 0; i < SIZE; ++i)
717	<	ints[i] = new Integer(SIZE-1- i);
717	>	ints[i] = new Integer(SIZE - 1 - i);
718		NavigableSet q = dset0();
719		assertFalse(q.addAll(Arrays.asList(empty)));
720		assertTrue(q.addAll(Arrays.asList(ints)));
#	Line 741 | Line 743 | public class ConcurrentSkipListSubSetTes
743		}
744		for (int i = 0; i < SIZE; i += 2 ) {
745		assertTrue(q.remove(new Integer(i)));
746	<	assertFalse(q.remove(new Integer(i+1)));
746	>	assertFalse(q.remove(new Integer(i + 1)));
747		}
748		assertTrue(q.isEmpty());
749		}
#	Line 800 | Line 802 | public class ConcurrentSkipListSubSetTes
802		assertTrue(changed);
803
804		assertTrue(q.containsAll(p));
805	<	assertEquals(SIZE-i, q.size());
805	>	assertEquals(SIZE - i, q.size());
806		p.pollFirst();
807		}
808		}
#	Line 813 | Line 815 | public class ConcurrentSkipListSubSetTes
815		NavigableSet q = populatedSet(SIZE);
816		NavigableSet p = populatedSet(i);
817		assertTrue(q.removeAll(p));
818	<	assertEquals(SIZE-i, q.size());
818	>	assertEquals(SIZE - i, q.size());
819		for (int j = 0; j < i; ++j) {
820		Integer x = (Integer)(p.pollFirst());
821		assertFalse(q.contains(x));
#	Line 975 | Line 977 | public class ConcurrentSkipListSubSetTes
977		}
978
979		/**
980	<	* A deserialized serialized set has same elements
980	>	* A deserialized/reserialized set equals original
981		*/
982		public void testDescendingSerialization() throws Exception {
983		NavigableSet x = dset5();

Diff Legend

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