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.17 by jsr166, Thu Nov 18 20:21:53 2010 UTC vs.
Revision 1.25 by jsr166, Wed Dec 31 16:44:01 2014 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.*;
8	>	import java.util.Arrays;
9	>	import java.util.Comparator;
10	>	import java.util.Iterator;
11	>	import java.util.NavigableSet;
12	>	import java.util.SortedSet;
13	>	import java.util.concurrent.ConcurrentSkipListSet;
14
15		public class ConcurrentSkipListSubSetTest extends JSR166TestCase {
16		public static void main(String[] args) {
#	Line 24 | Line 27 | public class ConcurrentSkipListSubSetTes
27		}
28
29		/**
30	<	* Create a set of given size containing consecutive
30	>	* Returns a new set of given size containing consecutive
31		* Integers 0 ... n.
32		*/
33		private NavigableSet<Integer> populatedSet(int n) {
#	Line 45 | Line 48 | public class ConcurrentSkipListSubSetTes
48		}
49
50		/**
51	<	* Create set of first 5 ints
51	>	* Returns a new set of first 5 ints.
52		*/
53		private NavigableSet set5() {
54		ConcurrentSkipListSet q = new ConcurrentSkipListSet();
#	Line 63 | Line 66 | public class ConcurrentSkipListSubSetTes
66		}
67
68		/**
69	<	* Create set of first 5 negative ints
69	>	* Returns a new set of first 5 negative ints.
70		*/
71		private NavigableSet dset5() {
72		ConcurrentSkipListSet q = new ConcurrentSkipListSet();
#	Line 97 | Line 100 | public class ConcurrentSkipListSubSetTes
100		assertEquals(0, set0().size());
101		}
102
100	–
103		/**
104		* isEmpty is true before add, false after
105		*/
#	Line 168 | Line 170 | public class ConcurrentSkipListSubSetTes
170		} catch (ClassCastException success) {}
171		}
172
171	–
173		/**
174		* addAll(null) throws NPE
175		*/
#	Line 329 | Line 330 | public class ConcurrentSkipListSubSetTes
330		}
331		}
332
332	–
333	–
333		/**
334		* lower returns preceding element
335		*/
#	Line 450 | Line 449 | public class ConcurrentSkipListSubSetTes
449		assertTrue(q.contains(it.next()));
450		++i;
451		}
452	<	assertEquals(i, 0);
452	>	assertEquals(0, i);
453		}
454
455		/**
#	Line 472 | Line 471 | public class ConcurrentSkipListSubSetTes
471		assertFalse(it.hasNext());
472		}
473
475	–
474		/**
475		* toString contains toStrings of elements
476		*/
#	Line 480 | Line 478 | public class ConcurrentSkipListSubSetTes
478		NavigableSet q = populatedSet(SIZE);
479		String s = q.toString();
480		for (int i = 0; i < SIZE; ++i) {
481	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
481	>	assertTrue(s.contains(String.valueOf(i)));
482		}
483		}
484
#	Line 488 | Line 486 | public class ConcurrentSkipListSubSetTes
486		* A deserialized serialized set has same elements
487		*/
488		public void testSerialization() throws Exception {
489	<	NavigableSet q = populatedSet(SIZE);
490	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
491	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
492	<	out.writeObject(q);
493	<	out.close();
494	<
495	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
496	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
497	<	NavigableSet r = (NavigableSet)in.readObject();
498	<	assertEquals(q.size(), r.size());
499	<	while (!q.isEmpty())
500	<	assertEquals(q.pollFirst(), r.pollFirst());
489	>	NavigableSet x = populatedSet(SIZE);
490	>	NavigableSet y = serialClone(x);
491	>
492	>	assertNotSame(y, x);
493	>	assertEquals(x.size(), y.size());
494	>	assertEquals(x, y);
495	>	assertEquals(y, x);
496	>	while (!x.isEmpty()) {
497	>	assertFalse(y.isEmpty());
498	>	assertEquals(x.pollFirst(), y.pollFirst());
499	>	}
500	>	assertTrue(y.isEmpty());
501		}
502
503		/**
#	Line 677 | Line 675 | public class ConcurrentSkipListSubSetTes
675		} catch (ClassCastException success) {}
676		}
677
680	–
678		/**
679		* addAll(null) throws NPE
680		*/
#	Line 832 | Line 829 | public class ConcurrentSkipListSubSetTes
829		}
830		}
831
835	–
836	–
832		/**
833		* lower returns preceding element
834		*/
#	Line 954 | Line 949 | public class ConcurrentSkipListSubSetTes
949		assertTrue(q.contains(it.next()));
950		++i;
951		}
952	<	assertEquals(i, 0);
952	>	assertEquals(0, i);
953		}
954
955		/**
#	Line 976 | Line 971 | public class ConcurrentSkipListSubSetTes
971		assertFalse(it.hasNext());
972		}
973
979	–
974		/**
975		* toString contains toStrings of elements
976		*/
#	Line 984 | Line 978 | public class ConcurrentSkipListSubSetTes
978		NavigableSet q = populatedSet(SIZE);
979		String s = q.toString();
980		for (int i = 0; i < SIZE; ++i) {
981	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
981	>	assertTrue(s.contains(String.valueOf(i)));
982		}
983		}
984
#	Line 992 | Line 986 | public class ConcurrentSkipListSubSetTes
986		* A deserialized serialized set has same elements
987		*/
988		public void testDescendingSerialization() throws Exception {
989	<	NavigableSet q = populatedSet(SIZE);
990	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
991	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
992	<	out.writeObject(q);
993	<	out.close();
994	<
995	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
996	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
997	<	NavigableSet r = (NavigableSet)in.readObject();
998	<	assertEquals(q.size(), r.size());
999	<	while (!q.isEmpty())
1000	<	assertEquals(q.pollFirst(), r.pollFirst());
989	>	NavigableSet x = dset5();
990	>	NavigableSet y = serialClone(x);
991	>
992	>	assertNotSame(y, x);
993	>	assertEquals(x.size(), y.size());
994	>	assertEquals(x, y);
995	>	assertEquals(y, x);
996	>	while (!x.isEmpty()) {
997	>	assertFalse(y.isEmpty());
998	>	assertEquals(x.pollFirst(), y.pollFirst());
999	>	}
1000	>	assertTrue(y.isEmpty());
1001		}
1002
1003		/**

Diff Legend

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