35      * Returns a new map from Integers 1-5 to Strings "A"-"E".
38         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
39         assertTrue(map.isEmpty());
40         map.put(zero, "Z");
41         map.put(one, "A");
42         map.put(five, "E");
43         map.put(three, "C");
44         map.put(two, "B");
45         map.put(four, "D");
46         map.put(seven, "F");
47         assertFalse(map.isEmpty());
48         assertEquals(7, map.size());
49         return map.subMap(one, true, seven, false);
53      * Returns a new map from Integers -5 to -1 to Strings "A"-"E".
56         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
57         assertTrue(map.isEmpty());
58         map.put(m1, "A");
59         map.put(m5, "E");
60         map.put(m3, "C");
61         map.put(m2, "B");
62         map.put(m4, "D");
63         assertFalse(map.isEmpty());
64         assertEquals(5, map.size());
65         return map.descendingMap();
69         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
70         assertTrue(map.isEmpty());
71         return map.tailMap(one, true);
75         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
76         assertTrue(map.isEmpty());
77         return map;
84         ConcurrentNavigableMap map = map5();
85         map.clear();
86         assertEquals(0, map.size());
106         ConcurrentNavigableMap map = map5();
107         assertTrue(map.containsKey(one));
108         assertFalse(map.containsKey(zero));
115         ConcurrentNavigableMap map = map5();
116         assertTrue(map.containsValue("A"));
117         assertFalse(map.containsValue("Z"));
125         ConcurrentNavigableMap map = map5();
126         assertEquals("A", (String)map.get(one));
132      * isEmpty is true of empty map and false for non-empty
136         ConcurrentNavigableMap map = map5();
138         assertFalse(map.isEmpty());
145         ConcurrentNavigableMap map = map5();
146         assertEquals(one, map.firstKey());
153         ConcurrentNavigableMap map = map5();
154         assertEquals(five, map.lastKey());
161         ConcurrentNavigableMap map = map5();
162         Set s = map.keySet();
175         ConcurrentNavigableMap map = map5();
176         Set s = map.keySet();
191         ConcurrentNavigableMap map = map5();
192         Collection s = map.values();
205         ConcurrentNavigableMap map = map5();
206         Set s = map.keySet();
218         ConcurrentNavigableMap map = map5();
219         Set s = map.descendingKeySet();
231         ConcurrentNavigableMap map = map5();
232         Collection v = map.values();
247         ConcurrentNavigableMap map = map5();
248         Set s = map.entrySet();
263      * putAll adds all key-value pairs from the given map
267         ConcurrentNavigableMap map = map5();
268         empty.putAll(map);
281         ConcurrentNavigableMap map = map5();
282         map.putIfAbsent(six, "Z");
283         assertTrue(map.containsKey(six));
290         ConcurrentNavigableMap map = map5();
291         assertEquals("A", map.putIfAbsent(one, "Z"));
298         ConcurrentNavigableMap map = map5();
299         assertNull(map.replace(six, "Z"));
300         assertFalse(map.containsKey(six));
307         ConcurrentNavigableMap map = map5();
308         assertNotNull(map.replace(one, "Z"));
309         assertEquals("Z", map.get(one));
316         ConcurrentNavigableMap map = map5();
317         assertEquals("A", map.get(one));
318         assertFalse(map.replace(one, "Z", "Z"));
319         assertEquals("A", map.get(one));
326         ConcurrentNavigableMap map = map5();
327         assertEquals("A", map.get(one));
328         assertTrue(map.replace(one, "A", "Z"));
329         assertEquals("Z", map.get(one));
333      * remove removes the correct key-value pair from the map
336         ConcurrentNavigableMap map = map5();
337         map.remove(five);
338         assertEquals(4, map.size());
339         assertFalse(map.containsKey(five));
346         ConcurrentNavigableMap map = map5();
347         assertTrue(map.containsKey(five));
348         assertEquals("E", map.get(five));
349         map.remove(five, "E");
350         assertEquals(4, map.size());
351         assertFalse(map.containsKey(five));
352         map.remove(four, "A");
353         assertEquals(4, map.size());
354         assertTrue(map.containsKey(four));
361         ConcurrentNavigableMap map = map5();
362         Map.Entry e1 = map.lowerEntry(three);
365         Map.Entry e2 = map.lowerEntry(six);
368         Map.Entry e3 = map.lowerEntry(one);
371         Map.Entry e4 = map.lowerEntry(zero);
379         ConcurrentNavigableMap map = map5();
380         Map.Entry e1 = map.higherEntry(three);
383         Map.Entry e2 = map.higherEntry(zero);
386         Map.Entry e3 = map.higherEntry(five);
389         Map.Entry e4 = map.higherEntry(six);
397         ConcurrentNavigableMap map = map5();
398         Map.Entry e1 = map.floorEntry(three);
401         Map.Entry e2 = map.floorEntry(six);
404         Map.Entry e3 = map.floorEntry(one);
407         Map.Entry e4 = map.floorEntry(zero);
415         ConcurrentNavigableMap map = map5();
416         Map.Entry e1 = map.ceilingEntry(three);
419         Map.Entry e2 = map.ceilingEntry(zero);
422         Map.Entry e3 = map.ceilingEntry(five);
425         Map.Entry e4 = map.ceilingEntry(six);
433         ConcurrentNavigableMap map = map5();
434         Map.Entry e = map.pollFirstEntry();
437         e = map.pollFirstEntry();
439         map.put(one, "A");
440         e = map.pollFirstEntry();
443         e = map.pollFirstEntry();
445         map.remove(four);
446         e = map.pollFirstEntry();
452         e = map.pollFirstEntry();
460         ConcurrentNavigableMap map = map5();
461         Map.Entry e = map.pollLastEntry();
464         e = map.pollLastEntry();
466         map.put(five, "E");
467         e = map.pollLastEntry();
470         e = map.pollLastEntry();
472         map.remove(two);
473         e = map.pollLastEntry();
479         e = map.pollLastEntry();
487         ConcurrentNavigableMap map = map5();
490         assertEquals(5, map.size());
497         ConcurrentNavigableMap map = map5();
498         String s = map.toString();
507      * get(null) of nonempty map throws NPE
518      * containsKey(null) of nonempty map throws NPE
606      * A deserialized map equals original
620      * subMap returns map with keys in requested range
623         ConcurrentNavigableMap map = map5();
624         SortedMap sm = map.subMap(two, four);
643         assertFalse(map.containsKey(two));
644         assertEquals(4, map.size());
650         assertEquals(3, map.size());
654         ConcurrentNavigableMap map = map5();
655         SortedMap sm = map.subMap(two, three);
672         assertFalse(map.containsKey(two));
673         assertEquals(4, map.size());
677         assertEquals(4, map.size());
681      * headMap returns map with keys in requested range
684         ConcurrentNavigableMap map = map5();
685         SortedMap sm = map.headMap(four);
702         assertEquals(2, map.size());
703         assertEquals(four, map.firstKey());
707      * headMap returns map with keys in requested range
710         ConcurrentNavigableMap map = map5();
711         SortedMap sm = map.tailMap(two);
751         assertEquals(4, map.size());
758         ConcurrentNavigableMap map = dmap5();
759         map.clear();
760         assertEquals(0, map.size());
780         ConcurrentNavigableMap map = dmap5();
781         assertTrue(map.containsKey(m1));
782         assertFalse(map.containsKey(zero));
789         ConcurrentNavigableMap map = dmap5();
790         assertTrue(map.containsValue("A"));
791         assertFalse(map.containsValue("Z"));
799         ConcurrentNavigableMap map = dmap5();
800         assertEquals("A", (String)map.get(m1));
806      * isEmpty is true of empty map and false for non-empty
810         ConcurrentNavigableMap map = dmap5();
812         assertFalse(map.isEmpty());
819         ConcurrentNavigableMap map = dmap5();
820         assertEquals(m1, map.firstKey());
827         ConcurrentNavigableMap map = dmap5();
828         assertEquals(m5, map.lastKey());
835         ConcurrentNavigableMap map = dmap5();
836         Set s = map.keySet();
849         ConcurrentNavigableMap map = dmap5();
850         Set s = map.keySet();
865         ConcurrentNavigableMap map = dmap5();
866         Collection s = map.values();
879         ConcurrentNavigableMap map = dmap5();
880         Set s = map.keySet();
892         ConcurrentNavigableMap map = dmap5();
893         Set s = map.descendingKeySet();
905         ConcurrentNavigableMap map = dmap5();
906         Collection v = map.values();
921         ConcurrentNavigableMap map = dmap5();
922         Set s = map.entrySet();
937      * putAll adds all key-value pairs from the given map
941         ConcurrentNavigableMap map = dmap5();
942         empty.putAll(map);
955         ConcurrentNavigableMap map = dmap5();
956         map.putIfAbsent(six, "Z");
957         assertTrue(map.containsKey(six));
964         ConcurrentNavigableMap map = dmap5();
965         assertEquals("A", map.putIfAbsent(m1, "Z"));
972         ConcurrentNavigableMap map = dmap5();
973         assertNull(map.replace(six, "Z"));
974         assertFalse(map.containsKey(six));
981         ConcurrentNavigableMap map = dmap5();
982         assertNotNull(map.replace(m1, "Z"));
983         assertEquals("Z", map.get(m1));
990         ConcurrentNavigableMap map = dmap5();
991         assertEquals("A", map.get(m1));
992         assertFalse(map.replace(m1, "Z", "Z"));
993         assertEquals("A", map.get(m1));
1000         ConcurrentNavigableMap map = dmap5();
1001         assertEquals("A", map.get(m1));
1002         assertTrue(map.replace(m1, "A", "Z"));
1003         assertEquals("Z", map.get(m1));
1007      * remove removes the correct key-value pair from the map
1010         ConcurrentNavigableMap map = dmap5();
1011         map.remove(m5);
1012         assertEquals(4, map.size());
1013         assertFalse(map.containsKey(m5));
1020         ConcurrentNavigableMap map = dmap5();
1021         assertTrue(map.containsKey(m5));
1022         assertEquals("E", map.get(m5));
1023         map.remove(m5, "E");
1024         assertEquals(4, map.size());
1025         assertFalse(map.containsKey(m5));
1026         map.remove(m4, "A");
1027         assertEquals(4, map.size());
1028         assertTrue(map.containsKey(m4));
1035         ConcurrentNavigableMap map = dmap5();
1036         Map.Entry e1 = map.lowerEntry(m3);
1039         Map.Entry e2 = map.lowerEntry(m6);
1042         Map.Entry e3 = map.lowerEntry(m1);
1045         Map.Entry e4 = map.lowerEntry(zero);
1053         ConcurrentNavigableMap map = dmap5();
1054         Map.Entry e1 = map.higherEntry(m3);
1057         Map.Entry e2 = map.higherEntry(zero);
1060         Map.Entry e3 = map.higherEntry(m5);
1063         Map.Entry e4 = map.higherEntry(m6);
1071         ConcurrentNavigableMap map = dmap5();
1072         Map.Entry e1 = map.floorEntry(m3);
1075         Map.Entry e2 = map.floorEntry(m6);
1078         Map.Entry e3 = map.floorEntry(m1);
1081         Map.Entry e4 = map.floorEntry(zero);
1089         ConcurrentNavigableMap map = dmap5();
1090         Map.Entry e1 = map.ceilingEntry(m3);
1093         Map.Entry e2 = map.ceilingEntry(zero);
1096         Map.Entry e3 = map.ceilingEntry(m5);
1099         Map.Entry e4 = map.ceilingEntry(m6);
1107         ConcurrentNavigableMap map = dmap5();
1108         Map.Entry e = map.pollFirstEntry();
1111         e = map.pollFirstEntry();
1113         map.put(m1, "A");
1114         e = map.pollFirstEntry();
1117         e = map.pollFirstEntry();
1119         map.remove(m4);
1120         e = map.pollFirstEntry();
1126         e = map.pollFirstEntry();
1134         ConcurrentNavigableMap map = dmap5();
1135         Map.Entry e = map.pollLastEntry();
1138         e = map.pollLastEntry();
1140         map.put(m5, "E");
1141         e = map.pollLastEntry();
1144         e = map.pollLastEntry();
1146         map.remove(m2);
1147         e = map.pollLastEntry();
1153         e = map.pollLastEntry();
1161         ConcurrentNavigableMap map = dmap5();
1164         assertEquals(5, map.size());
1171         ConcurrentNavigableMap map = dmap5();
1172         String s = map.toString();
1181      * get(null) of empty map throws NPE
1192      * containsKey(null) of empty map throws NPE
1280      * A deserialized map equals original
1294      * subMap returns map with keys in requested range
1297         ConcurrentNavigableMap map = dmap5();
1298         SortedMap sm = map.subMap(m2, m4);
1317         assertFalse(map.containsKey(m2));
1318         assertEquals(4, map.size());
1324         assertEquals(3, map.size());
1328         ConcurrentNavigableMap map = dmap5();
1329         SortedMap sm = map.subMap(m2, m3);
1346         assertFalse(map.containsKey(m2));
1347         assertEquals(4, map.size());
1351         assertEquals(4, map.size());
1355      * headMap returns map with keys in requested range
1358         ConcurrentNavigableMap map = dmap5();
1359         SortedMap sm = map.headMap(m4);
1376         assertEquals(2, map.size());
1377         assertEquals(m4, map.firstKey());
1381      * headMap returns map with keys in requested range
1384         ConcurrentNavigableMap map = dmap5();
1385         SortedMap sm = map.tailMap(m2);
1425         assertEquals(4, map.size());

Indexes created Sun Aug 12 02:23:12 CEST 2018