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.16 by jsr166, Fri Nov 5 00:17:22 2010 UTC vs.
Revision 1.38 by jsr166, Sun Jan 7 22:59:18 2018 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.util.*;
9	<	import java.util.concurrent.*;
10	<	import java.io.*;
7	>	import java.util.Arrays;
8	>	import java.util.Comparator;
9	>	import java.util.Iterator;
10	>	import java.util.NavigableSet;
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 24 | Line 29 | public class ConcurrentSkipListSubSetTes
29		}
30
31		/**
32	<	* Create 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 =
32	<	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 45 | Line 49 | public class ConcurrentSkipListSubSetTes
49		}
50
51		/**
52	<	* Create 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 63 | Line 67 | public class ConcurrentSkipListSubSetTes
67		}
68
69		/**
70	<	* Create 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 97 | Line 101 | public class ConcurrentSkipListSubSetTes
101		assertEquals(0, set0().size());
102		}
103
100	–
104		/**
105		* isEmpty is true before add, false after
106		*/
#	Line 118 | 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 131 | Line 134 | public class ConcurrentSkipListSubSetTes
134		* add(null) throws NPE
135		*/
136		public void testAddNull() {
137	+	NavigableSet q = set0();
138		try {
135	–	NavigableSet q = set0();
139		q.add(null);
140		shouldThrow();
141		} catch (NullPointerException success) {}
#	Line 159 | Line 162 | public class ConcurrentSkipListSubSetTes
162		* Add of non-Comparable throws CCE
163		*/
164		public void testAddNonComparable() {
165	+	NavigableSet q = set0();
166		try {
163	–	NavigableSet q = set0();
164	–	q.add(new Object());
167		q.add(new Object());
168		q.add(new Object());
169		shouldThrow();
170		} catch (ClassCastException success) {}
171		}
172
171	–
173		/**
174		* addAll(null) throws NPE
175		*/
176		public void testAddAll1() {
177	+	NavigableSet q = set0();
178		try {
177	–	NavigableSet q = set0();
179		q.addAll(null);
180		shouldThrow();
181		} catch (NullPointerException success) {}
#	Line 184 | 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 {
188	–	NavigableSet q = set0();
189	–	Integer[] ints = new Integer[SIZE];
191		q.addAll(Arrays.asList(ints));
192		shouldThrow();
193		} catch (NullPointerException success) {}
#	Line 197 | 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 {
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);
206		q.addAll(Arrays.asList(ints));
207		shouldThrow();
208		} catch (NullPointerException success) {}
#	Line 214 | 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 238 | Line 239 | public class ConcurrentSkipListSubSetTes
239		*/
240		public void testRemoveElement() {
241		NavigableSet q = populatedSet(SIZE);
242	<	for (int i = 1; i < SIZE; i+=2) {
243	<	assertTrue(q.remove(new Integer(i)));
244	<	}
245	<	for (int i = 0; i < SIZE; i+=2) {
246	<	assertTrue(q.remove(new Integer(i)));
247	<	assertFalse(q.remove(new Integer(i+1)));
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));
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));
254		}
255		assertTrue(q.isEmpty());
256		}
#	Line 302 | 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 315 | 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		}
332
326	–
327	–
333		/**
334		* lower returns preceding element
335		*/
#	Line 424 | Line 429 | public class ConcurrentSkipListSubSetTes
429		*/
430		public void testIterator() {
431		NavigableSet q = populatedSet(SIZE);
427	–	int i = 0;
432		Iterator it = q.iterator();
433	<	while (it.hasNext()) {
433	>	int i;
434	>	for (i = 0; it.hasNext(); i++)
435		assertTrue(q.contains(it.next()));
431	–	++i;
432	–	}
436		assertEquals(i, SIZE);
437	+	assertIteratorExhausted(it);
438		}
439
440		/**
441		* iterator of empty set has no elements
442		*/
443		public void testEmptyIterator() {
444	<	NavigableSet q = set0();
441	<	int i = 0;
442	<	Iterator it = q.iterator();
443	<	while (it.hasNext()) {
444	<	assertTrue(q.contains(it.next()));
445	<	++i;
446	<	}
447	<	assertEquals(i, 0);
444	>	assertIteratorExhausted(set0().iterator());
445		}
446
447		/**
#	Line 466 | Line 463 | public class ConcurrentSkipListSubSetTes
463		assertFalse(it.hasNext());
464		}
465
469	–
466		/**
467		* toString contains toStrings of elements
468		*/
#	Line 474 | Line 470 | public class ConcurrentSkipListSubSetTes
470		NavigableSet q = populatedSet(SIZE);
471		String s = q.toString();
472		for (int i = 0; i < SIZE; ++i) {
473	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
473	>	assertTrue(s.contains(String.valueOf(i)));
474		}
475		}
476
477		/**
478	<	* A deserialized serialized set has same elements
478	>	* A deserialized/reserialized set equals original
479		*/
480		public void testSerialization() throws Exception {
481	<	NavigableSet q = populatedSet(SIZE);
482	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
483	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
484	<	out.writeObject(q);
485	<	out.close();
486	<
487	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
488	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
489	<	NavigableSet r = (NavigableSet)in.readObject();
490	<	assertEquals(q.size(), r.size());
491	<	while (!q.isEmpty())
492	<	assertEquals(q.pollFirst(), r.pollFirst());
481	>	NavigableSet x = populatedSet(SIZE);
482	>	NavigableSet y = serialClone(x);
483	>
484	>	assertNotSame(y, x);
485	>	assertEquals(x.size(), y.size());
486	>	assertEquals(x, y);
487	>	assertEquals(y, x);
488	>	while (!x.isEmpty()) {
489	>	assertFalse(y.isEmpty());
490	>	assertEquals(x.pollFirst(), y.pollFirst());
491	>	}
492	>	assertTrue(y.isEmpty());
493		}
494
495		/**
#	Line 621 | Line 617 | public class ConcurrentSkipListSubSetTes
617		public void testDescendingSize() {
618		NavigableSet q = populatedSet(SIZE);
619		for (int i = 0; i < SIZE; ++i) {
620	<	assertEquals(SIZE-i, q.size());
620	>	assertEquals(SIZE - i, q.size());
621		q.pollFirst();
622		}
623		for (int i = 0; i < SIZE; ++i) {
#	Line 634 | Line 630 | public class ConcurrentSkipListSubSetTes
630		* add(null) throws NPE
631		*/
632		public void testDescendingAddNull() {
633	+	NavigableSet q = dset0();
634		try {
638	–	NavigableSet q = dset0();
635		q.add(null);
636		shouldThrow();
637		} catch (NullPointerException success) {}
#	Line 662 | Line 658 | public class ConcurrentSkipListSubSetTes
658		* Add of non-Comparable throws CCE
659		*/
660		public void testDescendingAddNonComparable() {
661	+	NavigableSet q = dset0();
662		try {
666	–	NavigableSet q = dset0();
667	–	q.add(new Object());
663		q.add(new Object());
664		q.add(new Object());
665		shouldThrow();
666		} catch (ClassCastException success) {}
667		}
668
674	–
669		/**
670		* addAll(null) throws NPE
671		*/
672		public void testDescendingAddAll1() {
673	+	NavigableSet q = dset0();
674		try {
680	–	NavigableSet q = dset0();
675		q.addAll(null);
676		shouldThrow();
677		} catch (NullPointerException success) {}
#	Line 687 | Line 681 | public class ConcurrentSkipListSubSetTes
681		* addAll of a collection with null elements throws NPE
682		*/
683		public void testDescendingAddAll2() {
684	+	NavigableSet q = dset0();
685	+	Integer[] ints = new Integer[SIZE];
686		try {
691	–	NavigableSet q = dset0();
692	–	Integer[] ints = new Integer[SIZE];
687		q.addAll(Arrays.asList(ints));
688		shouldThrow();
689		} catch (NullPointerException success) {}
#	Line 700 | Line 694 | public class ConcurrentSkipListSubSetTes
694		* possibly adding some elements
695		*/
696		public void testDescendingAddAll3() {
697	+	NavigableSet q = dset0();
698	+	Integer[] ints = new Integer[SIZE];
699	+	for (int i = 0; i < SIZE - 1; ++i)
700	+	ints[i] = new Integer(i + SIZE);
701		try {
704	–	NavigableSet q = dset0();
705	–	Integer[] ints = new Integer[SIZE];
706	–	for (int i = 0; i < SIZE-1; ++i)
707	–	ints[i] = new Integer(i+SIZE);
702		q.addAll(Arrays.asList(ints));
703		shouldThrow();
704		} catch (NullPointerException success) {}
#	Line 717 | Line 711 | public class ConcurrentSkipListSubSetTes
711		Integer[] empty = new Integer[0];
712		Integer[] ints = new Integer[SIZE];
713		for (int i = 0; i < SIZE; ++i)
714	<	ints[i] = new Integer(SIZE-1- i);
714	>	ints[i] = new Integer(SIZE - 1 - i);
715		NavigableSet q = dset0();
716		assertFalse(q.addAll(Arrays.asList(empty)));
717		assertTrue(q.addAll(Arrays.asList(ints)));
#	Line 741 | Line 735 | public class ConcurrentSkipListSubSetTes
735		*/
736		public void testDescendingRemoveElement() {
737		NavigableSet q = populatedSet(SIZE);
738	<	for (int i = 1; i < SIZE; i+=2) {
738	>	for (int i = 1; i < SIZE; i += 2) {
739		assertTrue(q.remove(new Integer(i)));
740		}
741	<	for (int i = 0; i < SIZE; i+=2) {
741	>	for (int i = 0; i < SIZE; i += 2 ) {
742		assertTrue(q.remove(new Integer(i)));
743	<	assertFalse(q.remove(new Integer(i+1)));
743	>	assertFalse(q.remove(new Integer(i + 1)));
744		}
745		assertTrue(q.isEmpty());
746		}
#	Line 805 | Line 799 | public class ConcurrentSkipListSubSetTes
799		assertTrue(changed);
800
801		assertTrue(q.containsAll(p));
802	<	assertEquals(SIZE-i, q.size());
802	>	assertEquals(SIZE - i, q.size());
803		p.pollFirst();
804		}
805		}
#	Line 818 | Line 812 | public class ConcurrentSkipListSubSetTes
812		NavigableSet q = populatedSet(SIZE);
813		NavigableSet p = populatedSet(i);
814		assertTrue(q.removeAll(p));
815	<	assertEquals(SIZE-i, q.size());
815	>	assertEquals(SIZE - i, q.size());
816		for (int j = 0; j < i; ++j) {
817	<	Integer I = (Integer)(p.pollFirst());
818	<	assertFalse(q.contains(I));
817	>	Integer x = (Integer)(p.pollFirst());
818	>	assertFalse(q.contains(x));
819		}
820		}
821		}
822
829	–
830	–
823		/**
824		* lower returns preceding element
825		*/
#	Line 948 | Line 940 | public class ConcurrentSkipListSubSetTes
940		assertTrue(q.contains(it.next()));
941		++i;
942		}
943	<	assertEquals(i, 0);
943	>	assertEquals(0, i);
944		}
945
946		/**
#	Line 970 | Line 962 | public class ConcurrentSkipListSubSetTes
962		assertFalse(it.hasNext());
963		}
964
973	–
965		/**
966		* toString contains toStrings of elements
967		*/
#	Line 978 | Line 969 | public class ConcurrentSkipListSubSetTes
969		NavigableSet q = populatedSet(SIZE);
970		String s = q.toString();
971		for (int i = 0; i < SIZE; ++i) {
972	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
972	>	assertTrue(s.contains(String.valueOf(i)));
973		}
974		}
975
976		/**
977	<	* A deserialized serialized set has same elements
977	>	* A deserialized/reserialized set equals original
978		*/
979		public void testDescendingSerialization() throws Exception {
980	<	NavigableSet q = populatedSet(SIZE);
981	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
982	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
983	<	out.writeObject(q);
984	<	out.close();
985	<
986	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
987	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
988	<	NavigableSet r = (NavigableSet)in.readObject();
989	<	assertEquals(q.size(), r.size());
990	<	while (!q.isEmpty())
991	<	assertEquals(q.pollFirst(), r.pollFirst());
980	>	NavigableSet x = dset5();
981	>	NavigableSet y = serialClone(x);
982	>
983	>	assertNotSame(y, x);
984	>	assertEquals(x.size(), y.size());
985	>	assertEquals(x, y);
986	>	assertEquals(y, x);
987	>	while (!x.isEmpty()) {
988	>	assertFalse(y.isEmpty());
989	>	assertEquals(x.pollFirst(), y.pollFirst());
990	>	}
991	>	assertTrue(y.isEmpty());
992		}
993
994		/**

Diff Legend

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