ViewVC Help

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

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

Comparing jsr166/src/test/tck/ConcurrentSkipListMapTest.java (file contents):
Revision 1.24 by jsr166, Fri May 27 19:21:27 2011 UTC vs.
Revision 1.34 by jsr166, Wed Dec 31 21:45:16 2014 UTC

#	Line 4 | Line 4
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.ArrayList;
8	>	import java.util.Arrays;
9	>	import java.util.BitSet;
10	>	import java.util.Collection;
11	>	import java.util.Iterator;
12	>	import java.util.Map;
13	>	import java.util.NavigableMap;
14	>	import java.util.NavigableSet;
15	>	import java.util.NoSuchElementException;
16	>	import java.util.Random;
17	>	import java.util.Set;
18	>	import java.util.concurrent.ConcurrentSkipListMap;
19	>
20	>	import junit.framework.Test;
21	>	import junit.framework.TestSuite;
22
23		public class ConcurrentSkipListMapTest extends JSR166TestCase {
24		public static void main(String[] args) {
#	Line 18 | Line 29 | public class ConcurrentSkipListMapTest e
29		}
30
31		/**
32	<	* Create a map from Integers 1-5 to Strings "A"-"E".
32	>	* Returns a new map from Integers 1-5 to Strings "A"-"E".
33		*/
34		private static ConcurrentSkipListMap map5() {
35		ConcurrentSkipListMap map = new ConcurrentSkipListMap();
#	Line 39 | Line 50 | public class ConcurrentSkipListMapTest e
50		public void testClear() {
51		ConcurrentSkipListMap map = map5();
52		map.clear();
53	<	assertEquals(map.size(), 0);
53	>	assertEquals(0, map.size());
54		}
55
56		/**
57	<	*
57	>	* copy constructor creates map equal to source map
58		*/
59		public void testConstructFromSorted() {
60		ConcurrentSkipListMap map = map5();
#	Line 175 | Line 186 | public class ConcurrentSkipListMapTest e
186		last = k;
187		++count;
188		}
189	<	assertEquals(count ,5);
189	>	assertEquals(5, count);
190		}
191
192		/**
#	Line 194 | Line 205 | public class ConcurrentSkipListMapTest e
205		last = k;
206		++count;
207		}
208	<	assertEquals(count ,5);
208	>	assertEquals(5, count);
209		}
210
211		/**
#	Line 213 | Line 224 | public class ConcurrentSkipListMapTest e
224		last = k;
225		++count;
226		}
227	<	assertEquals(count, 5);
227	>	assertEquals(5, count);
228		}
229
230		/**
#	Line 232 | Line 243 | public class ConcurrentSkipListMapTest e
243		last = k;
244		++count;
245		}
246	<	assertEquals(count, 5);
246	>	assertEquals(5, count);
247		}
248
249		/**
#	Line 502 | Line 513 | public class ConcurrentSkipListMapTest e
513		* lowerEntry, higherEntry, ceilingEntry, and floorEntry return
514		* immutable entries
515		*/
516	<	public void testEntryImmutablity() {
516	>	public void testEntryImmutability() {
517		ConcurrentSkipListMap map = map5();
518		Map.Entry e = map.lowerEntry(three);
519		assertEquals(two, e.getKey());
#	Line 530 | Line 541 | public class ConcurrentSkipListMapTest e
541		} catch (UnsupportedOperationException success) {}
542		}
543
533	–
544		/**
545		* lowerKey returns preceding element
546		*/
#	Line 794 | Line 804 | public class ConcurrentSkipListMapTest e
804		* A deserialized map equals original
805		*/
806		public void testSerialization() throws Exception {
807	<	ConcurrentSkipListMap q = map5();
807	>	NavigableMap x = map5();
808	>	NavigableMap y = serialClone(x);
809
810	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
811	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
812	<	out.writeObject(q);
813	<	out.close();
814	<
804	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
805	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
806	<	ConcurrentSkipListMap r = (ConcurrentSkipListMap)in.readObject();
807	<	assertEquals(q.size(), r.size());
808	<	assertTrue(q.equals(r));
809	<	assertTrue(r.equals(q));
810	>	assertNotSame(x, y);
811	>	assertEquals(x.size(), y.size());
812	>	assertEquals(x.toString(), y.toString());
813	>	assertEquals(x, y);
814	>	assertEquals(y, x);
815		}
816
817		/**
#	Line 993 | Line 998 | public class ConcurrentSkipListMapTest e
998		static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception {
999		NavigableMap<Integer, Integer> result =
1000		(NavigableMap<Integer, Integer>) cl.newInstance();
1001	<	assertEquals(result.size(), 0);
1001	>	assertEquals(0, result.size());
1002		assertFalse(result.keySet().iterator().hasNext());
1003		return result;
1004		}
#	Line 1025 | Line 1030 | public class ConcurrentSkipListMapTest e
1030		// Add entries till we're back to original size
1031		while (map.size() < size) {
1032		int key = min + rnd.nextInt(rangeSize);
1033	<	assertTrue(key >= min && key<= max);
1033	>	assertTrue(key >= min && key <= max);
1034		put(map, key);
1035		}
1036		}
#	Line 1050 | Line 1055 | public class ConcurrentSkipListMapTest e
1055		// Add entries till we're back to original size
1056		while (map.size() < size) {
1057		int key = min - 5 + rnd.nextInt(rangeSize + 10);
1058	<	if (key >= min && key<= max) {
1058	>	if (key >= min && key <= max) {
1059		put(map, key);
1060		} else {
1061		try {
#	Line 1220 | Line 1225 | public class ConcurrentSkipListMapTest e
1225		if (bsContainsI)
1226		size++;
1227		}
1228	<	assertEquals(map.size(), size);
1228	>	assertEquals(size, map.size());
1229
1230		// Test contents using contains keySet iterator
1231		int size2 = 0;

Diff Legend

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