ViewVC Help

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

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

Comparing jsr166/src/test/tck/ConcurrentSkipListSubMapTest.java (file contents):
Revision 1.14 by jsr166, Wed Dec 23 00:47:16 2009 UTC vs.
Revision 1.20 by jsr166, Sat Nov 26 05:19:17 2011 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.concurrent.ConcurrentNavigableMap;
9	+	import java.util.concurrent.ConcurrentSkipListMap;
10		import java.util.*;
9	–	import java.util.concurrent.*;
10	–	import java.io.*;
11
12		public class ConcurrentSkipListSubMapTest extends JSR166TestCase {
13		public static void main(String[] args) {
14	<	junit.textui.TestRunner.run (suite());
14	>	junit.textui.TestRunner.run(suite());
15		}
16		public static Test suite() {
17		return new TestSuite(ConcurrentSkipListSubMapTest.class);
#	Line 64 | Line 64 | public class ConcurrentSkipListSubMapTes
64		}
65
66		/**
67	<	*  clear removes all pairs
67	>	* clear removes all pairs
68		*/
69		public void testClear() {
70		ConcurrentNavigableMap map = map5();
71		map.clear();
72	<	assertEquals(map.size(), 0);
72	>	assertEquals(0, map.size());
73		}
74
75	–
75		/**
76	<	*  Maps with same contents are equal
76	>	* Maps with same contents are equal
77		*/
78		public void testEquals() {
79		ConcurrentNavigableMap map1 = map5();
#	Line 87 | Line 86 | public class ConcurrentSkipListSubMapTes
86		}
87
88		/**
89	<	*  containsKey returns true for contained key
89	>	* containsKey returns true for contained key
90		*/
91		public void testContainsKey() {
92		ConcurrentNavigableMap map = map5();
#	Line 96 | Line 95 | public class ConcurrentSkipListSubMapTes
95		}
96
97		/**
98	<	*  containsValue returns true for held values
98	>	* containsValue returns true for held values
99		*/
100		public void testContainsValue() {
101		ConcurrentNavigableMap map = map5();
#	Line 105 | Line 104 | public class ConcurrentSkipListSubMapTes
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		ConcurrentNavigableMap map = map5();
#	Line 116 | Line 115 | public class ConcurrentSkipListSubMapTes
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		ConcurrentNavigableMap empty = map0();
#	Line 126 | Line 125 | public class ConcurrentSkipListSubMapTes
125		}
126
127		/**
128	<	*   firstKey returns first key
128	>	* firstKey returns first key
129		*/
130		public void testFirstKey() {
131		ConcurrentNavigableMap map = map5();
#	Line 134 | Line 133 | public class ConcurrentSkipListSubMapTes
133		}
134
135		/**
136	<	*   lastKey returns last key
136	>	* lastKey returns last key
137		*/
138		public void testLastKey() {
139		ConcurrentNavigableMap map = map5();
140		assertEquals(five, map.lastKey());
141		}
142
144	–
143		/**
144	<	*   keySet returns a Set containing all the keys
144	>	* keySet returns a Set containing all the keys
145		*/
146		public void testKeySet() {
147		ConcurrentNavigableMap map = map5();
#	Line 157 | Line 155 | public class ConcurrentSkipListSubMapTes
155		}
156
157		/**
158	<	*   keySet is ordered
158	>	* keySet is ordered
159		*/
160		public void testKeySetOrder() {
161		ConcurrentNavigableMap map = map5();
#	Line 187 | Line 185 | public class ConcurrentSkipListSubMapTes
185		}
186
187		/**
188	<	*  keySet.toArray returns contains all keys
188	>	* keySet.toArray returns contains all keys
189		*/
190		public void testKeySetToArray() {
191		ConcurrentNavigableMap map = map5();
#	Line 200 | Line 198 | public class ConcurrentSkipListSubMapTes
198		}
199
200		/**
201	<	*  descendingkeySet.toArray returns contains all keys
201	>	* descendingkeySet.toArray returns contains all keys
202		*/
203		public void testDescendingKeySetToArray() {
204		ConcurrentNavigableMap map = map5();
#	Line 213 | Line 211 | public class ConcurrentSkipListSubMapTes
211		}
212
213		/**
214	<	*  Values.toArray contains all values
214	>	* Values.toArray contains all values
215		*/
216		public void testValuesToArray() {
217		ConcurrentNavigableMap map = map5();
#	Line 228 | Line 226 | public class ConcurrentSkipListSubMapTes
226		assertTrue(s.contains("E"));
227		}
228
231	–
229		/**
230		* entrySet contains all pairs
231		*/
#	Line 249 | Line 246 | public class ConcurrentSkipListSubMapTes
246		}
247
248		/**
249	<	*   putAll  adds all key-value pairs from the given map
249	>	* putAll adds all key-value pairs from the given map
250		*/
251		public void testPutAll() {
252		ConcurrentNavigableMap empty = map0();
#	Line 264 | Line 261 | public class ConcurrentSkipListSubMapTes
261		}
262
263		/**
264	<	*   putIfAbsent works when the given key is not present
264	>	* putIfAbsent works when the given key is not present
265		*/
266		public void testPutIfAbsent() {
267		ConcurrentNavigableMap map = map5();
#	Line 273 | Line 270 | public class ConcurrentSkipListSubMapTes
270		}
271
272		/**
273	<	*   putIfAbsent does not add the pair if the key is already present
273	>	* putIfAbsent does not add the pair if the key is already present
274		*/
275		public void testPutIfAbsent2() {
276		ConcurrentNavigableMap map = map5();
#	Line 281 | Line 278 | public class ConcurrentSkipListSubMapTes
278		}
279
280		/**
281	<	*   replace fails when the given key is not present
281	>	* replace fails when the given key is not present
282		*/
283		public void testReplace() {
284		ConcurrentNavigableMap map = map5();
#	Line 290 | Line 287 | public class ConcurrentSkipListSubMapTes
287		}
288
289		/**
290	<	*   replace succeeds if the key is already present
290	>	* replace succeeds if the key is already present
291		*/
292		public void testReplace2() {
293		ConcurrentNavigableMap map = map5();
#	Line 298 | Line 295 | public class ConcurrentSkipListSubMapTes
295		assertEquals("Z", map.get(one));
296		}
297
301	–
298		/**
299		* replace value fails when the given key not mapped to expected value
300		*/
#	Line 319 | Line 315 | public class ConcurrentSkipListSubMapTes
315		assertEquals("Z", map.get(one));
316		}
317
322	–
318		/**
319	<	*   remove removes the correct key-value pair from the map
319	>	* remove removes the correct key-value pair from the map
320		*/
321		public void testRemove() {
322		ConcurrentNavigableMap map = map5();
#	Line 472 | Line 467 | public class ConcurrentSkipListSubMapTes
467		}
468
469		/**
470	<	*   size returns the correct values
470	>	* size returns the correct values
471		*/
472		public void testSize() {
473		ConcurrentNavigableMap map = map5();
#	Line 488 | Line 483 | public class ConcurrentSkipListSubMapTes
483		ConcurrentNavigableMap map = map5();
484		String s = map.toString();
485		for (int i = 1; i <= 5; ++i) {
486	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
486	>	assertTrue(s.contains(String.valueOf(i)));
487		}
488		}
489
#	Line 527 | Line 522 | public class ConcurrentSkipListSubMapTes
522		} catch (NullPointerException success) {}
523		}
524
530	–
525		/**
526		* put(null,x) throws NPE
527		*/
#	Line 598 | Line 592 | public class ConcurrentSkipListSubMapTes
592		* A deserialized map equals original
593		*/
594		public void testSerialization() throws Exception {
595	<	ConcurrentNavigableMap q = map5();
595	>	NavigableMap x = map5();
596	>	NavigableMap y = serialClone(x);
597
598	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
599	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
600	<	out.writeObject(q);
601	<	out.close();
602	<
608	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
609	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
610	<	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
611	<	assertEquals(q.size(), r.size());
612	<	assertTrue(q.equals(r));
613	<	assertTrue(r.equals(q));
598	>	assertTrue(x != y);
599	>	assertEquals(x.size(), y.size());
600	>	assertEquals(x.toString(), y.toString());
601	>	assertEquals(x, y);
602	>	assertEquals(y, x);
603		}
604
616	–
617	–
605		/**
606		* subMap returns map with keys in requested range
607		*/
#	Line 751 | Line 738 | public class ConcurrentSkipListSubMapTes
738		}
739
740		/**
741	<	*  clear removes all pairs
741	>	* clear removes all pairs
742		*/
743		public void testDescendingClear() {
744		ConcurrentNavigableMap map = dmap5();
745		map.clear();
746	<	assertEquals(map.size(), 0);
746	>	assertEquals(0, map.size());
747		}
748
762	–
749		/**
750	<	*  Maps with same contents are equal
750	>	* Maps with same contents are equal
751		*/
752		public void testDescendingEquals() {
753		ConcurrentNavigableMap map1 = dmap5();
#	Line 774 | Line 760 | public class ConcurrentSkipListSubMapTes
760		}
761
762		/**
763	<	*  containsKey returns true for contained key
763	>	* containsKey returns true for contained key
764		*/
765		public void testDescendingContainsKey() {
766		ConcurrentNavigableMap map = dmap5();
#	Line 783 | Line 769 | public class ConcurrentSkipListSubMapTes
769		}
770
771		/**
772	<	*  containsValue returns true for held values
772	>	* containsValue returns true for held values
773		*/
774		public void testDescendingContainsValue() {
775		ConcurrentNavigableMap map = dmap5();
#	Line 792 | Line 778 | public class ConcurrentSkipListSubMapTes
778		}
779
780		/**
781	<	*  get returns the correct element at the given key,
782	<	*  or null if not present
781	>	* get returns the correct element at the given key,
782	>	* or null if not present
783		*/
784		public void testDescendingGet() {
785		ConcurrentNavigableMap map = dmap5();
#	Line 803 | Line 789 | public class ConcurrentSkipListSubMapTes
789		}
790
791		/**
792	<	*  isEmpty is true of empty map and false for non-empty
792	>	* isEmpty is true of empty map and false for non-empty
793		*/
794		public void testDescendingIsEmpty() {
795		ConcurrentNavigableMap empty = dmap0();
#	Line 813 | Line 799 | public class ConcurrentSkipListSubMapTes
799		}
800
801		/**
802	<	*   firstKey returns first key
802	>	* firstKey returns first key
803		*/
804		public void testDescendingFirstKey() {
805		ConcurrentNavigableMap map = dmap5();
#	Line 821 | Line 807 | public class ConcurrentSkipListSubMapTes
807		}
808
809		/**
810	<	*   lastKey returns last key
810	>	* lastKey returns last key
811		*/
812		public void testDescendingLastKey() {
813		ConcurrentNavigableMap map = dmap5();
814		assertEquals(m5, map.lastKey());
815		}
816
831	–
817		/**
818	<	*   keySet returns a Set containing all the keys
818	>	* keySet returns a Set containing all the keys
819		*/
820		public void testDescendingKeySet() {
821		ConcurrentNavigableMap map = dmap5();
#	Line 844 | Line 829 | public class ConcurrentSkipListSubMapTes
829		}
830
831		/**
832	<	*   keySet is ordered
832	>	* keySet is ordered
833		*/
834		public void testDescendingKeySetOrder() {
835		ConcurrentNavigableMap map = dmap5();
#	Line 874 | Line 859 | public class ConcurrentSkipListSubMapTes
859		}
860
861		/**
862	<	*  keySet.toArray returns contains all keys
862	>	* keySet.toArray returns contains all keys
863		*/
864		public void testDescendingAscendingKeySetToArray() {
865		ConcurrentNavigableMap map = dmap5();
#	Line 887 | Line 872 | public class ConcurrentSkipListSubMapTes
872		}
873
874		/**
875	<	*  descendingkeySet.toArray returns contains all keys
875	>	* descendingkeySet.toArray returns contains all keys
876		*/
877		public void testDescendingDescendingKeySetToArray() {
878		ConcurrentNavigableMap map = dmap5();
#	Line 900 | Line 885 | public class ConcurrentSkipListSubMapTes
885		}
886
887		/**
888	<	*  Values.toArray contains all values
888	>	* Values.toArray contains all values
889		*/
890		public void testDescendingValuesToArray() {
891		ConcurrentNavigableMap map = dmap5();
#	Line 915 | Line 900 | public class ConcurrentSkipListSubMapTes
900		assertTrue(s.contains("E"));
901		}
902
918	–
903		/**
904		* entrySet contains all pairs
905		*/
#	Line 936 | Line 920 | public class ConcurrentSkipListSubMapTes
920		}
921
922		/**
923	<	*   putAll  adds all key-value pairs from the given map
923	>	* putAll adds all key-value pairs from the given map
924		*/
925		public void testDescendingPutAll() {
926		ConcurrentNavigableMap empty = dmap0();
#	Line 951 | Line 935 | public class ConcurrentSkipListSubMapTes
935		}
936
937		/**
938	<	*   putIfAbsent works when the given key is not present
938	>	* putIfAbsent works when the given key is not present
939		*/
940		public void testDescendingPutIfAbsent() {
941		ConcurrentNavigableMap map = dmap5();
#	Line 960 | Line 944 | public class ConcurrentSkipListSubMapTes
944		}
945
946		/**
947	<	*   putIfAbsent does not add the pair if the key is already present
947	>	* putIfAbsent does not add the pair if the key is already present
948		*/
949		public void testDescendingPutIfAbsent2() {
950		ConcurrentNavigableMap map = dmap5();
#	Line 968 | Line 952 | public class ConcurrentSkipListSubMapTes
952		}
953
954		/**
955	<	*   replace fails when the given key is not present
955	>	* replace fails when the given key is not present
956		*/
957		public void testDescendingReplace() {
958		ConcurrentNavigableMap map = dmap5();
#	Line 977 | Line 961 | public class ConcurrentSkipListSubMapTes
961		}
962
963		/**
964	<	*   replace succeeds if the key is already present
964	>	* replace succeeds if the key is already present
965		*/
966		public void testDescendingReplace2() {
967		ConcurrentNavigableMap map = dmap5();
#	Line 985 | Line 969 | public class ConcurrentSkipListSubMapTes
969		assertEquals("Z", map.get(m1));
970		}
971
988	–
972		/**
973		* replace value fails when the given key not mapped to expected value
974		*/
#	Line 1006 | Line 989 | public class ConcurrentSkipListSubMapTes
989		assertEquals("Z", map.get(m1));
990		}
991
1009	–
992		/**
993	<	*   remove removes the correct key-value pair from the map
993	>	* remove removes the correct key-value pair from the map
994		*/
995		public void testDescendingRemove() {
996		ConcurrentNavigableMap map = dmap5();
#	Line 1159 | Line 1141 | public class ConcurrentSkipListSubMapTes
1141		}
1142
1143		/**
1144	<	*   size returns the correct values
1144	>	* size returns the correct values
1145		*/
1146		public void testDescendingSize() {
1147		ConcurrentNavigableMap map = dmap5();
#	Line 1175 | Line 1157 | public class ConcurrentSkipListSubMapTes
1157		ConcurrentNavigableMap map = dmap5();
1158		String s = map.toString();
1159		for (int i = 1; i <= 5; ++i) {
1160	<	assertTrue(s.indexOf(String.valueOf(i)) >= 0);
1160	>	assertTrue(s.contains(String.valueOf(i)));
1161		}
1162		}
1163
#	Line 1214 | Line 1196 | public class ConcurrentSkipListSubMapTes
1196		} catch (NullPointerException success) {}
1197		}
1198
1217	–
1199		/**
1200		* put(null,x) throws NPE
1201		*/
#	Line 1285 | Line 1266 | public class ConcurrentSkipListSubMapTes
1266		* A deserialized map equals original
1267		*/
1268		public void testDescendingSerialization() throws Exception {
1269	<	ConcurrentNavigableMap q = dmap5();
1269	>	NavigableMap x = dmap5();
1270	>	NavigableMap y = serialClone(x);
1271
1272	<	ByteArrayOutputStream bout = new ByteArrayOutputStream(10000);
1273	<	ObjectOutputStream out = new ObjectOutputStream(new BufferedOutputStream(bout));
1274	<	out.writeObject(q);
1275	<	out.close();
1276	<
1295	<	ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
1296	<	ObjectInputStream in = new ObjectInputStream(new BufferedInputStream(bin));
1297	<	ConcurrentNavigableMap r = (ConcurrentNavigableMap)in.readObject();
1298	<	assertEquals(q.size(), r.size());
1299	<	assertTrue(q.equals(r));
1300	<	assertTrue(r.equals(q));
1272	>	assertTrue(x != y);
1273	>	assertEquals(x.size(), y.size());
1274	>	assertEquals(x.toString(), y.toString());
1275	>	assertEquals(x, y);
1276	>	assertEquals(y, x);
1277		}
1278
1303	–
1279		/**
1280		* subMap returns map with keys in requested range
1281		*/

Diff Legend

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