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); |
18 |
|
} |
19 |
|
|
20 |
|
/** |
21 |
< |
* Create a map from Integers 1-5 to Strings "A"-"E". |
21 |
> |
* Creates a map from Integers 1-5 to Strings "A"-"E". |
22 |
|
*/ |
23 |
|
private static ConcurrentNavigableMap map5() { |
24 |
|
ConcurrentSkipListMap map = new ConcurrentSkipListMap(); |
36 |
|
} |
37 |
|
|
38 |
|
/** |
39 |
< |
* Create a map from Integers -5 to -1 to Strings "A"-"E". |
39 |
> |
* Creates a map from Integers -5 to -1 to Strings "A"-"E". |
40 |
|
*/ |
41 |
|
private static ConcurrentNavigableMap dmap5() { |
42 |
|
ConcurrentSkipListMap map = new ConcurrentSkipListMap(); |
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(); |
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(); |
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(); |
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(); |
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(); |
125 |
|
} |
126 |
|
|
127 |
|
/** |
128 |
< |
* firstKey returns first key |
128 |
> |
* firstKey returns first key |
129 |
|
*/ |
130 |
|
public void testFirstKey() { |
131 |
|
ConcurrentNavigableMap map = map5(); |
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(); |
155 |
|
} |
156 |
|
|
157 |
|
/** |
158 |
< |
* keySet is ordered |
158 |
> |
* keySet is ordered |
159 |
|
*/ |
160 |
|
public void testKeySetOrder() { |
161 |
|
ConcurrentNavigableMap map = map5(); |
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(); |
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(); |
211 |
|
} |
212 |
|
|
213 |
|
/** |
214 |
< |
* Values.toArray contains all values |
214 |
> |
* Values.toArray contains all values |
215 |
|
*/ |
216 |
|
public void testValuesToArray() { |
217 |
|
ConcurrentNavigableMap map = map5(); |
226 |
|
assertTrue(s.contains("E")); |
227 |
|
} |
228 |
|
|
231 |
– |
|
229 |
|
/** |
230 |
|
* entrySet contains all pairs |
231 |
|
*/ |
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(); |
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(); |
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(); |
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(); |
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(); |
295 |
|
assertEquals("Z", map.get(one)); |
296 |
|
} |
297 |
|
|
301 |
– |
|
298 |
|
/** |
299 |
|
* replace value fails when the given key not mapped to expected value |
300 |
|
*/ |
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(); |
467 |
|
} |
468 |
|
|
469 |
|
/** |
470 |
< |
* size returns the correct values |
470 |
> |
* size returns the correct values |
471 |
|
*/ |
472 |
|
public void testSize() { |
473 |
|
ConcurrentNavigableMap map = map5(); |
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 |
|
|
522 |
|
} catch (NullPointerException success) {} |
523 |
|
} |
524 |
|
|
530 |
– |
|
525 |
|
/** |
526 |
|
* put(null,x) throws NPE |
527 |
|
*/ |
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 |
|
*/ |
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(); |
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(); |
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(); |
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(); |
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(); |
799 |
|
} |
800 |
|
|
801 |
|
/** |
802 |
< |
* firstKey returns first key |
802 |
> |
* firstKey returns first key |
803 |
|
*/ |
804 |
|
public void testDescendingFirstKey() { |
805 |
|
ConcurrentNavigableMap map = dmap5(); |
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(); |
829 |
|
} |
830 |
|
|
831 |
|
/** |
832 |
< |
* keySet is ordered |
832 |
> |
* keySet is ordered |
833 |
|
*/ |
834 |
|
public void testDescendingKeySetOrder() { |
835 |
|
ConcurrentNavigableMap map = dmap5(); |
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(); |
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(); |
885 |
|
} |
886 |
|
|
887 |
|
/** |
888 |
< |
* Values.toArray contains all values |
888 |
> |
* Values.toArray contains all values |
889 |
|
*/ |
890 |
|
public void testDescendingValuesToArray() { |
891 |
|
ConcurrentNavigableMap map = dmap5(); |
900 |
|
assertTrue(s.contains("E")); |
901 |
|
} |
902 |
|
|
918 |
– |
|
903 |
|
/** |
904 |
|
* entrySet contains all pairs |
905 |
|
*/ |
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(); |
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(); |
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(); |
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(); |
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(); |
969 |
|
assertEquals("Z", map.get(m1)); |
970 |
|
} |
971 |
|
|
988 |
– |
|
972 |
|
/** |
973 |
|
* replace value fails when the given key not mapped to expected value |
974 |
|
*/ |
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(); |
1141 |
|
} |
1142 |
|
|
1143 |
|
/** |
1144 |
< |
* size returns the correct values |
1144 |
> |
* size returns the correct values |
1145 |
|
*/ |
1146 |
|
public void testDescendingSize() { |
1147 |
|
ConcurrentNavigableMap map = dmap5(); |
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 |
|
|
1164 |
|
// Exception testDescendings |
1165 |
|
|
1166 |
|
/** |
1167 |
< |
* get(null) of nm1mpty map throws NPE |
1167 |
> |
* get(null) of empty map throws NPE |
1168 |
|
*/ |
1169 |
|
public void testDescendingGet_NullPointerException() { |
1170 |
|
try { |
1175 |
|
} |
1176 |
|
|
1177 |
|
/** |
1178 |
< |
* containsKey(null) of nm1mpty map throws NPE |
1178 |
> |
* containsKey(null) of empty map throws NPE |
1179 |
|
*/ |
1180 |
|
public void testDescendingContainsKey_NullPointerException() { |
1181 |
|
try { |
1196 |
|
} catch (NullPointerException success) {} |
1197 |
|
} |
1198 |
|
|
1217 |
– |
|
1199 |
|
/** |
1200 |
|
* put(null,x) throws NPE |
1201 |
|
*/ |
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 |
|
*/ |