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.17 by jsr166, Wed Dec 23 00:47:16 2009 UTC vs.
Revision 1.42 by jsr166, Sun Sep 29 20:40:48 2019 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.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
22		public class ConcurrentSkipListMapTest extends JSR166TestCase {
23		public static void main(String[] args) {
24	<	junit.textui.TestRunner.run (suite());
24	>	main(suite(), args);
25		}
26		public static Test suite() {
27	<	return new TestSuite(ConcurrentSkipListMapTest.class);
27	>	class Implementation implements MapImplementation {
28	>	public Class<?> klazz() { return ConcurrentSkipListMap.class; }
29	>	public Map emptyMap() { return new ConcurrentSkipListMap(); }
30	>	public boolean isConcurrent() { return true; }
31	>	public boolean remappingFunctionCalledAtMostOnce() { return false; };
32	>	public boolean permitsNullKeys() { return false; }
33	>	public boolean permitsNullValues() { return false; }
34	>	public boolean supportsSetValue() { return false; }
35	>	}
36	>	return newTestSuite(
37	>	ConcurrentSkipListMapTest.class,
38	>	MapTest.testSuite(new Implementation()));
39		}
40
41		/**
42	<	* Create a map from Integers 1-5 to Strings "A"-"E".
42	>	* Returns a new map from Integers 1-5 to Strings "A"-"E".
43		*/
44		private static ConcurrentSkipListMap map5() {
45		ConcurrentSkipListMap map = new ConcurrentSkipListMap();
#	Line 34 | Line 55 | public class ConcurrentSkipListMapTest e
55		}
56
57		/**
58	<	*  clear removes all pairs
58	>	* clear removes all pairs
59		*/
60		public void testClear() {
61		ConcurrentSkipListMap map = map5();
62		map.clear();
63	<	assertEquals(map.size(), 0);
63	>	assertEquals(0, map.size());
64		}
65
66		/**
67	<	*
67	>	* copy constructor creates map equal to source map
68		*/
69		public void testConstructFromSorted() {
70		ConcurrentSkipListMap map = map5();
#	Line 52 | Line 73 | public class ConcurrentSkipListMapTest e
73		}
74
75		/**
76	<	*  Maps with same contents are equal
76	>	* Maps with same contents are equal
77		*/
78		public void testEquals() {
79		ConcurrentSkipListMap map1 = map5();
#	Line 65 | Line 86 | public class ConcurrentSkipListMapTest e
86		}
87
88		/**
89	<	*  containsKey returns true for contained key
89	>	* containsKey returns true for contained key
90		*/
91		public void testContainsKey() {
92		ConcurrentSkipListMap map = map5();
#	Line 74 | Line 95 | public class ConcurrentSkipListMapTest e
95		}
96
97		/**
98	<	*  containsValue returns true for held values
98	>	* containsValue returns true for held values
99		*/
100		public void testContainsValue() {
101		ConcurrentSkipListMap map = map5();
#	Line 83 | Line 104 | public class ConcurrentSkipListMapTest e
104		}
105
106		/**
107	<	*  get returns the correct element at the given key,
108	<	*  or null if not present
107	>	* get returns the correct element at the given key,
108	>	* or null if not present
109		*/
110		public void testGet() {
111		ConcurrentSkipListMap map = map5();
#	Line 94 | Line 115 | public class ConcurrentSkipListMapTest e
115		}
116
117		/**
118	<	*  isEmpty is true of empty map and false for non-empty
118	>	* isEmpty is true of empty map and false for non-empty
119		*/
120		public void testIsEmpty() {
121		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
#	Line 104 | Line 125 | public class ConcurrentSkipListMapTest e
125		}
126
127		/**
128	<	*   firstKey returns first key
128	>	* firstKey returns first key
129		*/
130		public void testFirstKey() {
131		ConcurrentSkipListMap map = map5();
#	Line 112 | Line 133 | public class ConcurrentSkipListMapTest e
133		}
134
135		/**
136	<	*   lastKey returns last key
136	>	* lastKey returns last key
137		*/
138		public void testLastKey() {
139		ConcurrentSkipListMap map = map5();
140		assertEquals(five, map.lastKey());
141		}
142
122	–
143		/**
144	<	*  keySet.toArray returns contains all keys
144	>	* keySet.toArray returns contains all keys
145		*/
146		public void testKeySetToArray() {
147		ConcurrentSkipListMap map = map5();
#	Line 134 | Line 154 | public class ConcurrentSkipListMapTest e
154		}
155
156		/**
157	<	*  descendingkeySet.toArray returns contains all keys
157	>	* descendingkeySet.toArray returns contains all keys
158		*/
159		public void testDescendingKeySetToArray() {
160		ConcurrentSkipListMap map = map5();
#	Line 147 | Line 167 | public class ConcurrentSkipListMapTest e
167		}
168
169		/**
170	<	*   keySet returns a Set containing all the keys
170	>	* keySet returns a Set containing all the keys
171		*/
172		public void testKeySet() {
173		ConcurrentSkipListMap map = map5();
#	Line 161 | Line 181 | public class ConcurrentSkipListMapTest e
181		}
182
183		/**
184	<	*   keySet is ordered
184	>	* keySet is ordered
185		*/
186		public void testKeySetOrder() {
187		ConcurrentSkipListMap map = map5();
#	Line 176 | Line 196 | public class ConcurrentSkipListMapTest e
196		last = k;
197		++count;
198		}
199	<	assertEquals(count ,5);
199	>	assertEquals(5, count);
200		}
201
202		/**
#	Line 195 | Line 215 | public class ConcurrentSkipListMapTest e
215		last = k;
216		++count;
217		}
218	<	assertEquals(count ,5);
218	>	assertEquals(5, count);
219		}
220
221		/**
222	<	*   descendingKeySet is ordered
222	>	* descendingKeySet is ordered
223		*/
224		public void testDescendingKeySetOrder() {
225		ConcurrentSkipListMap map = map5();
#	Line 214 | Line 234 | public class ConcurrentSkipListMapTest e
234		last = k;
235		++count;
236		}
237	<	assertEquals(count, 5);
237	>	assertEquals(5, count);
238		}
239
240		/**
241	<	*  descending iterator of descendingKeySet is ordered
241	>	* descending iterator of descendingKeySet is ordered
242		*/
243		public void testDescendingKeySetDescendingIteratorOrder() {
244		ConcurrentSkipListMap map = map5();
#	Line 233 | Line 253 | public class ConcurrentSkipListMapTest e
253		last = k;
254		++count;
255		}
256	<	assertEquals(count, 5);
256	>	assertEquals(5, count);
257		}
258
259		/**
260	<	*  Values.toArray contains all values
260	>	* Values.toArray contains all values
261		*/
262		public void testValuesToArray() {
263		ConcurrentSkipListMap map = map5();
#	Line 305 | Line 325 | public class ConcurrentSkipListMapTest e
325		}
326
327		/**
328	<	*  entrySet.toArray contains all entries
328	>	* entrySet.toArray contains all entries
329		*/
330		public void testEntrySetToArray() {
331		ConcurrentSkipListMap map = map5();
#	Line 319 | Line 339 | public class ConcurrentSkipListMapTest e
339		}
340
341		/**
342	<	*  descendingEntrySet.toArray contains all entries
342	>	* descendingEntrySet.toArray contains all entries
343		*/
344		public void testDescendingEntrySetToArray() {
345		ConcurrentSkipListMap map = map5();
#	Line 333 | Line 353 | public class ConcurrentSkipListMapTest e
353		}
354
355		/**
356	<	*   putAll  adds all key-value pairs from the given map
356	>	* putAll adds all key-value pairs from the given map
357		*/
358		public void testPutAll() {
359		ConcurrentSkipListMap empty = new ConcurrentSkipListMap();
#	Line 348 | Line 368 | public class ConcurrentSkipListMapTest e
368		}
369
370		/**
371	<	*   putIfAbsent works when the given key is not present
371	>	* putIfAbsent works when the given key is not present
372		*/
373		public void testPutIfAbsent() {
374		ConcurrentSkipListMap map = map5();
#	Line 357 | Line 377 | public class ConcurrentSkipListMapTest e
377		}
378
379		/**
380	<	*   putIfAbsent does not add the pair if the key is already present
380	>	* putIfAbsent does not add the pair if the key is already present
381		*/
382		public void testPutIfAbsent2() {
383		ConcurrentSkipListMap map = map5();
#	Line 365 | Line 385 | public class ConcurrentSkipListMapTest e
385		}
386
387		/**
388	<	*   replace fails when the given key is not present
388	>	* replace fails when the given key is not present
389		*/
390		public void testReplace() {
391		ConcurrentSkipListMap map = map5();
#	Line 374 | Line 394 | public class ConcurrentSkipListMapTest e
394		}
395
396		/**
397	<	*   replace succeeds if the key is already present
397	>	* replace succeeds if the key is already present
398		*/
399		public void testReplace2() {
400		ConcurrentSkipListMap map = map5();
#	Line 382 | Line 402 | public class ConcurrentSkipListMapTest e
402		assertEquals("Z", map.get(one));
403		}
404
385	–
405		/**
406		* replace value fails when the given key not mapped to expected value
407		*/
#	Line 403 | Line 422 | public class ConcurrentSkipListMapTest e
422		assertEquals("Z", map.get(one));
423		}
424
406	–
425		/**
426	<	*   remove removes the correct key-value pair from the map
426	>	* remove removes the correct key-value pair from the map
427		*/
428		public void testRemove() {
429		ConcurrentSkipListMap map = map5();
#	Line 505 | Line 523 | public class ConcurrentSkipListMapTest e
523		* lowerEntry, higherEntry, ceilingEntry, and floorEntry return
524		* immutable entries
525		*/
526	<	public void testEntryImmutablity() {
526	>	public void testEntryImmutability() {
527		ConcurrentSkipListMap map = map5();
528		Map.Entry e = map.lowerEntry(three);
529		assertEquals(two, e.getKey());
#	Line 533 | Line 551 | public class ConcurrentSkipListMapTest e
551		} catch (UnsupportedOperationException success) {}
552		}
553
536	–
537	–
554		/**
555		* lowerKey returns preceding element
556		*/
#	Line 662 | Line 678 | public class ConcurrentSkipListMapTest e
678		}
679
680		/**
681	<	*   size returns the correct values
681	>	* size returns the correct values
682		*/
683		public void testSize() {
684		ConcurrentSkipListMap map = map5();
#	Line 678 | Line 694 | public class ConcurrentSkipListMapTest e
694		ConcurrentSkipListMap map = map5();
695		String s = map.toString();
696		for (int i = 1; i <= 5; ++i) {
697	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
697	>	assertTrue(s.contains(String.valueOf(i)));
698		}
699		}
700
#	Line 688 | Line 704 | public class ConcurrentSkipListMapTest e
704		* get(null) of nonempty map throws NPE
705		*/
706		public void testGet_NullPointerException() {
707	+	ConcurrentSkipListMap c = map5();
708		try {
692	–	ConcurrentSkipListMap c = map5();
709		c.get(null);
710		shouldThrow();
711		} catch (NullPointerException success) {}
#	Line 699 | Line 715 | public class ConcurrentSkipListMapTest e
715		* containsKey(null) of nonempty map throws NPE
716		*/
717		public void testContainsKey_NullPointerException() {
718	+	ConcurrentSkipListMap c = map5();
719		try {
703	–	ConcurrentSkipListMap c = map5();
720		c.containsKey(null);
721		shouldThrow();
722		} catch (NullPointerException success) {}
#	Line 710 | Line 726 | public class ConcurrentSkipListMapTest e
726		* containsValue(null) throws NPE
727		*/
728		public void testContainsValue_NullPointerException() {
729	+	ConcurrentSkipListMap c = new ConcurrentSkipListMap();
730		try {
714	–	ConcurrentSkipListMap c = new ConcurrentSkipListMap();
731		c.containsValue(null);
732		shouldThrow();
733		} catch (NullPointerException success) {}
734		}
735
720	–
736		/**
737		* put(null,x) throws NPE
738		*/
739		public void testPut1_NullPointerException() {
740	+	ConcurrentSkipListMap c = map5();
741		try {
726	–	ConcurrentSkipListMap c = map5();
742		c.put(null, "whatever");
743		shouldThrow();
744		} catch (NullPointerException success) {}
#	Line 733 | Line 748 | public class ConcurrentSkipListMapTest e
748		* putIfAbsent(null, x) throws NPE
749		*/
750		public void testPutIfAbsent1_NullPointerException() {
751	+	ConcurrentSkipListMap c = map5();
752		try {
737	–	ConcurrentSkipListMap c = map5();
753		c.putIfAbsent(null, "whatever");
754		shouldThrow();
755		} catch (NullPointerException success) {}
#	Line 744 | Line 759 | public class ConcurrentSkipListMapTest e
759		* replace(null, x) throws NPE
760		*/
761		public void testReplace_NullPointerException() {
762	+	ConcurrentSkipListMap c = map5();
763		try {
748	–	ConcurrentSkipListMap c = map5();
764		c.replace(null, "whatever");
765		shouldThrow();
766		} catch (NullPointerException success) {}
#	Line 755 | Line 770 | public class ConcurrentSkipListMapTest e
770		* replace(null, x, y) throws NPE
771		*/
772		public void testReplaceValue_NullPointerException() {
773	+	ConcurrentSkipListMap c = map5();
774		try {
759	–	ConcurrentSkipListMap c = map5();
775		c.replace(null, one, "whatever");
776		shouldThrow();
777		} catch (NullPointerException success) {}
#	Line 766 | Line 781 | public class ConcurrentSkipListMapTest e
781		* remove(null) throws NPE
782		*/
783		public void testRemove1_NullPointerException() {
784	+	ConcurrentSkipListMap c = new ConcurrentSkipListMap();
785	+	c.put("sadsdf", "asdads");
786		try {
770	–	ConcurrentSkipListMap c = new ConcurrentSkipListMap();
771	–	c.put("sadsdf", "asdads");
787		c.remove(null);
788		shouldThrow();
789		} catch (NullPointerException success) {}
#	Line 778 | Line 793 | public class ConcurrentSkipListMapTest e
793		* remove(null, x) throws NPE
794		*/
795		public void testRemove2_NullPointerException() {
796	+	ConcurrentSkipListMap c = new ConcurrentSkipListMap();
797	+	c.put("sadsdf", "asdads");
798		try {
782	–	ConcurrentSkipListMap c = new ConcurrentSkipListMap();
783	–	c.put("sadsdf", "asdads");
799		c.remove(null, "whatever");
800		shouldThrow();
801		} catch (NullPointerException success) {}
#	Line 796 | Line 811 | public class ConcurrentSkipListMapTest e
811		}
812
813		/**
814	<	* A deserialized map equals original
814	>	* A cloned map equals original
815		*/
816	<	public void testSerialization() throws Exception {
817	<	ConcurrentSkipListMap q = map5();
816	>	public void testClone() {
817	>	ConcurrentSkipListMap x = map5();
818	>	ConcurrentSkipListMap y = x.clone();
819
820	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
821	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
822	<	out.writeObject(q);
823	<	out.close();
824	<
825	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
826	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
827	<	ConcurrentSkipListMap r = (ConcurrentSkipListMap)in.readObject();
812	<	assertEquals(q.size(), r.size());
813	<	assertTrue(q.equals(r));
814	<	assertTrue(r.equals(q));
820	>	assertNotSame(x, y);
821	>	assertEquals(x.size(), y.size());
822	>	assertEquals(x.toString(), y.toString());
823	>	assertEquals(x, y);
824	>	assertEquals(y, x);
825	>	y.clear();
826	>	assertTrue(y.isEmpty());
827	>	assertFalse(x.equals(y));
828		}
829
830	+	/**
831	+	* A deserialized/reserialized map equals original
832	+	*/
833	+	public void testSerialization() throws Exception {
834	+	NavigableMap x = map5();
835	+	NavigableMap y = serialClone(x);
836
837	+	assertNotSame(x, y);
838	+	assertEquals(x.size(), y.size());
839	+	assertEquals(x.toString(), y.toString());
840	+	assertEquals(x, y);
841	+	assertEquals(y, x);
842	+	y.clear();
843	+	assertTrue(y.isEmpty());
844	+	assertFalse(x.equals(y));
845	+	}
846
847		/**
848		* subMap returns map with keys in requested range
#	Line 980 | Line 1008 | public class ConcurrentSkipListMapTest e
1008		* Submaps of submaps subdivide correctly
1009		*/
1010		public void testRecursiveSubMaps() throws Exception {
1011	<	int mapSize = 1000;
1011	>	int mapSize = expensiveTests ? 1000 : 100;
1012		Class cl = ConcurrentSkipListMap.class;
1013		NavigableMap<Integer, Integer> map = newMap(cl);
1014		bs = new BitSet(mapSize);
#	Line 999 | Line 1027 | public class ConcurrentSkipListMapTest e
1027
1028		static NavigableMap<Integer, Integer> newMap(Class cl) throws Exception {
1029		NavigableMap<Integer, Integer> result =
1030	<	(NavigableMap<Integer, Integer>) cl.newInstance();
1031	<	assertEquals(result.size(), 0);
1030	>	(NavigableMap<Integer, Integer>) cl.getConstructor().newInstance();
1031	>	assertEquals(0, result.size());
1032		assertFalse(result.keySet().iterator().hasNext());
1033		return result;
1034		}
#	Line 1032 | Line 1060 | public class ConcurrentSkipListMapTest e
1060		// Add entries till we're back to original size
1061		while (map.size() < size) {
1062		int key = min + rnd.nextInt(rangeSize);
1063	<	assertTrue(key >= min && key<= max);
1063	>	assertTrue(key >= min && key <= max);
1064		put(map, key);
1065		}
1066		}
#	Line 1057 | Line 1085 | public class ConcurrentSkipListMapTest e
1085		// Add entries till we're back to original size
1086		while (map.size() < size) {
1087		int key = min - 5 + rnd.nextInt(rangeSize + 10);
1088	<	if (key >= min && key<= max) {
1088	>	if (key >= min && key <= max) {
1089		put(map, key);
1090		} else {
1091		try {
#	Line 1161 | Line 1189 | public class ConcurrentSkipListMapTest e
1189		*/
1190		void check(NavigableMap<Integer, Integer> map,
1191		final int min, final int max, final boolean ascending) {
1192	<	class ReferenceSet {
1192	>	class ReferenceSet {
1193		int lower(int key) {
1194		return ascending ? lowerAscending(key) : higherAscending(key);
1195		}
#	Line 1192 | Line 1220 | public class ConcurrentSkipListMapTest e
1220		// BitSet should support this! Test would run much faster
1221		while (key >= min) {
1222		if (bs.get(key))
1223	<	return(key);
1223	>	return key;
1224		key--;
1225		}
1226		return -1;
#	Line 1227 | Line 1255 | public class ConcurrentSkipListMapTest e
1255		if (bsContainsI)
1256		size++;
1257		}
1258	<	assertEquals(map.size(), size);
1258	>	assertEquals(size, map.size());
1259
1260		// Test contents using contains keySet iterator
1261		int size2 = 0;
#	Line 1275 | Line 1303 | public class ConcurrentSkipListMapTest e
1303		}
1304
1305		static boolean eq(Integer i, int j) {
1306	<	return i == null ? j == -1 : i == j;
1306	>	return (i == null) ? j == -1 : i == j;
1307		}
1308
1309		}

Diff Legend

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