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.21 by jsr166, Mon Oct 11 05:40:41 2010 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 39 | Line 60 | public class ConcurrentSkipListMapTest e
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 119 | Line 140 | public class ConcurrentSkipListMapTest e
140		assertEquals(five, map.lastKey());
141		}
142
122	–
143		/**
144		* keySet.toArray returns contains all keys
145		*/
#	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		/**
#	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		/**
#	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		/**
#	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
427		*/
#	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 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 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 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