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.22 by jsr166, Tue Feb 21 01:54:04 2012 UTC vs.
Revision 1.39 by jsr166, Mon May 28 21:19:50 2018 UTC

#	Line 4 | Line 4
4		* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	–	import junit.framework.*;
7		import java.util.Arrays;
9	–	import java.util.BitSet;
10	–	import java.util.Collection;
8		import java.util.Comparator;
9		import java.util.Iterator;
10		import java.util.NavigableSet;
14	–	import java.util.NoSuchElementException;
15	–	import java.util.Random;
16	–	import java.util.Set;
11		import java.util.SortedSet;
12		import java.util.concurrent.ConcurrentSkipListSet;
13
14	+	import junit.framework.Test;
15	+	import junit.framework.TestSuite;
16	+
17		public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
18		public static void main(String[] args) {
19	<	junit.textui.TestRunner.run(suite());
19	>	main(suite(), args);
20		}
21		public static Test suite() {
22		return new TestSuite(ConcurrentSkipListSubSetTest.class);
#	Line 32 | Line 29 | public class ConcurrentSkipListSubSetTes
29		}
30
31		/**
32	<	* Creates a set of given size containing consecutive
33	<	* Integers 0 ... n.
32	>	* Returns a new set of given size containing consecutive
33	>	* Integers 0 ... n - 1.
34		*/
35	<	private NavigableSet<Integer> populatedSet(int n) {
36	<	ConcurrentSkipListSet<Integer> q =
40	<	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)
41	>	for (int i = (n & 1); i < n; i += 2)
42		assertTrue(q.add(new Integer(i)));
43		assertTrue(q.add(new Integer(-n)));
44		assertTrue(q.add(new Integer(n)));
#	Line 53 | Line 49 | public class ConcurrentSkipListSubSetTes
49		}
50
51		/**
52	<	* Creates set of first 5 ints.
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 71 | Line 67 | public class ConcurrentSkipListSubSetTes
67		}
68
69		/**
70	<	* Creates set of first 5 negative ints.
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 125 | 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 138 | Line 134 | public class ConcurrentSkipListSubSetTes
134		* add(null) throws NPE
135		*/
136		public void testAddNull() {
137	+	NavigableSet q = set0();
138		try {
142	–	NavigableSet q = set0();
139		q.add(null);
140		shouldThrow();
141		} catch (NullPointerException success) {}
#	Line 166 | Line 162 | public class ConcurrentSkipListSubSetTes
162		* Add of non-Comparable throws CCE
163		*/
164		public void testAddNonComparable() {
165	+	NavigableSet q = set0();
166		try {
170	–	NavigableSet q = set0();
171	–	q.add(new Object());
167		q.add(new Object());
168		q.add(new Object());
169		shouldThrow();
#	Line 179 | Line 174 | public class ConcurrentSkipListSubSetTes
174		* addAll(null) throws NPE
175		*/
176		public void testAddAll1() {
177	+	NavigableSet q = set0();
178		try {
183	–	NavigableSet q = set0();
179		q.addAll(null);
180		shouldThrow();
181		} catch (NullPointerException success) {}
#	Line 190 | Line 185 | public class ConcurrentSkipListSubSetTes
185		* addAll of a collection with null elements throws NPE
186		*/
187		public void testAddAll2() {
188	+	NavigableSet q = set0();
189	+	Integer[] ints = new Integer[SIZE];
190		try {
194	–	NavigableSet q = set0();
195	–	Integer[] ints = new Integer[SIZE];
191		q.addAll(Arrays.asList(ints));
192		shouldThrow();
193		} catch (NullPointerException success) {}
#	Line 203 | Line 198 | public class ConcurrentSkipListSubSetTes
198		* possibly adding some elements
199		*/
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);
205		try {
207	–	NavigableSet q = set0();
208	–	Integer[] ints = new Integer[SIZE];
209	–	for (int i = 0; i < SIZE-1; ++i)
210	–	ints[i] = new Integer(i+SIZE);
206		q.addAll(Arrays.asList(ints));
207		shouldThrow();
208		} catch (NullPointerException success) {}
#	Line 220 | 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 239 | public class ConcurrentSkipListSubSetTes
239		*/
240		public void testRemoveElement() {
241		NavigableSet q = populatedSet(SIZE);
242	<	for (int i = 1; i < SIZE; i+=2) {
242	>	for (int i = 1; i < SIZE; i += 2) {
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) {
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 314 | 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 327 | 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 I = (Integer)(p.pollFirst());
328	<	assertFalse(q.contains(I));
327	>	Integer x = (Integer)(p.pollFirst());
328	>	assertFalse(q.contains(x));
329		}
330		}
331		}
#	Line 412 | 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 425 | 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 434 | Line 432 | public class ConcurrentSkipListSubSetTes
432		*/
433		public void testIterator() {
434		NavigableSet q = populatedSet(SIZE);
437	–	int i = 0;
435		Iterator it = q.iterator();
436	<	while (it.hasNext()) {
436	>	int i;
437	>	for (i = 0; it.hasNext(); i++)
438		assertTrue(q.contains(it.next()));
441	–	++i;
442	–	}
439		assertEquals(i, SIZE);
440	+	assertIteratorExhausted(it);
441		}
442
443		/**
444		* iterator of empty set has no elements
445		*/
446		public void testEmptyIterator() {
447	<	NavigableSet q = set0();
451	<	int i = 0;
452	<	Iterator it = q.iterator();
453	<	while (it.hasNext()) {
454	<	assertTrue(q.contains(it.next()));
455	<	++i;
456	<	}
457	<	assertEquals(0, i);
447	>	assertIteratorExhausted(set0().iterator());
448		}
449
450		/**
#	Line 488 | 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);
485		NavigableSet y = serialClone(x);
486
487	<	assertTrue(x != y);
487	>	assertNotSame(y, x);
488		assertEquals(x.size(), y.size());
489		assertEquals(x, y);
490		assertEquals(y, x);
#	Line 630 | 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 643 | Line 633 | public class ConcurrentSkipListSubSetTes
633		* add(null) throws NPE
634		*/
635		public void testDescendingAddNull() {
636	+	NavigableSet q = dset0();
637		try {
647	–	NavigableSet q = dset0();
638		q.add(null);
639		shouldThrow();
640		} catch (NullPointerException success) {}
#	Line 671 | Line 661 | public class ConcurrentSkipListSubSetTes
661		* Add of non-Comparable throws CCE
662		*/
663		public void testDescendingAddNonComparable() {
664	+	NavigableSet q = dset0();
665		try {
675	–	NavigableSet q = dset0();
676	–	q.add(new Object());
666		q.add(new Object());
667		q.add(new Object());
668		shouldThrow();
#	Line 684 | Line 673 | public class ConcurrentSkipListSubSetTes
673		* addAll(null) throws NPE
674		*/
675		public void testDescendingAddAll1() {
676	+	NavigableSet q = dset0();
677		try {
688	–	NavigableSet q = dset0();
678		q.addAll(null);
679		shouldThrow();
680		} catch (NullPointerException success) {}
#	Line 695 | Line 684 | public class ConcurrentSkipListSubSetTes
684		* addAll of a collection with null elements throws NPE
685		*/
686		public void testDescendingAddAll2() {
687	+	NavigableSet q = dset0();
688	+	Integer[] ints = new Integer[SIZE];
689		try {
699	–	NavigableSet q = dset0();
700	–	Integer[] ints = new Integer[SIZE];
690		q.addAll(Arrays.asList(ints));
691		shouldThrow();
692		} catch (NullPointerException success) {}
#	Line 708 | Line 697 | public class ConcurrentSkipListSubSetTes
697		* possibly adding some elements
698		*/
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);
704		try {
712	–	NavigableSet q = dset0();
713	–	Integer[] ints = new Integer[SIZE];
714	–	for (int i = 0; i < SIZE-1; ++i)
715	–	ints[i] = new Integer(i+SIZE);
705		q.addAll(Arrays.asList(ints));
706		shouldThrow();
707		} catch (NullPointerException success) {}
#	Line 725 | 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 749 | Line 738 | public class ConcurrentSkipListSubSetTes
738		*/
739		public void testDescendingRemoveElement() {
740		NavigableSet q = populatedSet(SIZE);
741	<	for (int i = 1; i < SIZE; i+=2) {
741	>	for (int i = 1; i < SIZE; i += 2) {
742		assertTrue(q.remove(new Integer(i)));
743		}
744	<	for (int i = 0; i < SIZE; i+=2) {
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 813 | 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 826 | 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 I = (Integer)(p.pollFirst());
821	<	assertFalse(q.contains(I));
820	>	Integer x = (Integer)(p.pollFirst());
821	>	assertFalse(q.contains(x));
822		}
823		}
824		}
#	Line 988 | 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();
984		NavigableSet y = serialClone(x);
985
986	<	assertTrue(x != y);
986	>	assertNotSame(y, x);
987		assertEquals(x.size(), y.size());
988		assertEquals(x, y);
989		assertEquals(y, x);

Diff Legend

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