17      * Returns a new map from Integers 1-5 to Strings "A"-"E".
20         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
21         assertTrue(map.isEmpty());
22         map.put(zero, "Z");
23         map.put(one, "A");
24         map.put(five, "E");
25         map.put(three, "C");
26         map.put(two, "B");
27         map.put(four, "D");
28         map.put(seven, "F");
29         assertFalse(map.isEmpty());
30         assertEquals(7, map.size());
31         return map.subMap(one, true, seven, false);
35      * Returns a new map from Integers -5 to -1 to Strings "A"-"E".
38         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
39         assertTrue(map.isEmpty());
40         map.put(m1, "A");
41         map.put(m5, "E");
42         map.put(m3, "C");
43         map.put(m2, "B");
44         map.put(m4, "D");
45         assertFalse(map.isEmpty());
46         assertEquals(5, map.size());
47         return map.descendingMap();
51         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
52         assertTrue(map.isEmpty());
53         return map.tailMap(one, true);
57         ConcurrentSkipListMap map = new ConcurrentSkipListMap();
58         assertTrue(map.isEmpty());
59         return map;
66         ConcurrentNavigableMap map = map5();
67         map.clear();
68         assertEquals(0, map.size());
88         ConcurrentNavigableMap map = map5();
89         assertTrue(map.containsKey(one));
90         assertFalse(map.containsKey(zero));
97         ConcurrentNavigableMap map = map5();
98         assertTrue(map.containsValue("A"));
99         assertFalse(map.containsValue("Z"));
107         ConcurrentNavigableMap map = map5();
108         assertEquals("A", (String)map.get(one));
114      * isEmpty is true of empty map and false for non-empty
118         ConcurrentNavigableMap map = map5();
120         assertFalse(map.isEmpty());
127         ConcurrentNavigableMap map = map5();
128         assertEquals(one, map.firstKey());
135         ConcurrentNavigableMap map = map5();
136         assertEquals(five, map.lastKey());
143         ConcurrentNavigableMap map = map5();
144         Set s = map.keySet();
157         ConcurrentNavigableMap map = map5();
158         Set s = map.keySet();
173         ConcurrentNavigableMap map = map5();
174         Collection s = map.values();
187         ConcurrentNavigableMap map = map5();
188         Set s = map.keySet();
200         ConcurrentNavigableMap map = map5();
201         Set s = map.descendingKeySet();
213         ConcurrentNavigableMap map = map5();
214         Collection v = map.values();
229         ConcurrentNavigableMap map = map5();
230         Set s = map.entrySet();
245      * putAll adds all key-value pairs from the given map
249         ConcurrentNavigableMap map = map5();
250         empty.putAll(map);
263         ConcurrentNavigableMap map = map5();
264         map.putIfAbsent(six, "Z");
265         assertTrue(map.containsKey(six));
272         ConcurrentNavigableMap map = map5();
273         assertEquals("A", map.putIfAbsent(one, "Z"));
280         ConcurrentNavigableMap map = map5();
281         assertNull(map.replace(six, "Z"));
282         assertFalse(map.containsKey(six));
289         ConcurrentNavigableMap map = map5();
290         assertNotNull(map.replace(one, "Z"));
291         assertEquals("Z", map.get(one));
298         ConcurrentNavigableMap map = map5();
299         assertEquals("A", map.get(one));
300         assertFalse(map.replace(one, "Z", "Z"));
301         assertEquals("A", map.get(one));
308         ConcurrentNavigableMap map = map5();
309         assertEquals("A", map.get(one));
310         assertTrue(map.replace(one, "A", "Z"));
311         assertEquals("Z", map.get(one));
315      * remove removes the correct key-value pair from the map
318         ConcurrentNavigableMap map = map5();
319         map.remove(five);
320         assertEquals(4, map.size());
321         assertFalse(map.containsKey(five));
328         ConcurrentNavigableMap map = map5();
329         assertTrue(map.containsKey(five));
330         assertEquals("E", map.get(five));
331         map.remove(five, "E");
332         assertEquals(4, map.size());
333         assertFalse(map.containsKey(five));
334         map.remove(four, "A");
335         assertEquals(4, map.size());
336         assertTrue(map.containsKey(four));
343         ConcurrentNavigableMap map = map5();
344         Map.Entry e1 = map.lowerEntry(three);
347         Map.Entry e2 = map.lowerEntry(six);
350         Map.Entry e3 = map.lowerEntry(one);
353         Map.Entry e4 = map.lowerEntry(zero);
361         ConcurrentNavigableMap map = map5();
362         Map.Entry e1 = map.higherEntry(three);
365         Map.Entry e2 = map.higherEntry(zero);
368         Map.Entry e3 = map.higherEntry(five);
371         Map.Entry e4 = map.higherEntry(six);
379         ConcurrentNavigableMap map = map5();
380         Map.Entry e1 = map.floorEntry(three);
383         Map.Entry e2 = map.floorEntry(six);
386         Map.Entry e3 = map.floorEntry(one);
389         Map.Entry e4 = map.floorEntry(zero);
397         ConcurrentNavigableMap map = map5();
398         Map.Entry e1 = map.ceilingEntry(three);
401         Map.Entry e2 = map.ceilingEntry(zero);
404         Map.Entry e3 = map.ceilingEntry(five);
407         Map.Entry e4 = map.ceilingEntry(six);
415         ConcurrentNavigableMap map = map5();
416         Map.Entry e = map.pollFirstEntry();
419         e = map.pollFirstEntry();
421         map.put(one, "A");
422         e = map.pollFirstEntry();
425         e = map.pollFirstEntry();
427         map.remove(four);
428         e = map.pollFirstEntry();
434         e = map.pollFirstEntry();
442         ConcurrentNavigableMap map = map5();
443         Map.Entry e = map.pollLastEntry();
446         e = map.pollLastEntry();
448         map.put(five, "E");
449         e = map.pollLastEntry();
452         e = map.pollLastEntry();
454         map.remove(two);
455         e = map.pollLastEntry();
461         e = map.pollLastEntry();
469         ConcurrentNavigableMap map = map5();
472         assertEquals(5, map.size());
479         ConcurrentNavigableMap map = map5();
480         String s = map.toString();
489      * get(null) of nonempty map throws NPE
500      * containsKey(null) of nonempty map throws NPE
588      * A deserialized map equals original
602      * subMap returns map with keys in requested range
605         ConcurrentNavigableMap map = map5();
606         SortedMap sm = map.subMap(two, four);
625         assertFalse(map.containsKey(two));
626         assertEquals(4, map.size());
632         assertEquals(3, map.size());
636         ConcurrentNavigableMap map = map5();
637         SortedMap sm = map.subMap(two, three);
654         assertFalse(map.containsKey(two));
655         assertEquals(4, map.size());
659         assertEquals(4, map.size());
663      * headMap returns map with keys in requested range
666         ConcurrentNavigableMap map = map5();
667         SortedMap sm = map.headMap(four);
684         assertEquals(2, map.size());
685         assertEquals(four, map.firstKey());
689      * headMap returns map with keys in requested range
692         ConcurrentNavigableMap map = map5();
693         SortedMap sm = map.tailMap(two);
733         assertEquals(4, map.size());
740         ConcurrentNavigableMap map = dmap5();
741         map.clear();
742         assertEquals(0, map.size());
762         ConcurrentNavigableMap map = dmap5();
763         assertTrue(map.containsKey(m1));
764         assertFalse(map.containsKey(zero));
771         ConcurrentNavigableMap map = dmap5();
772         assertTrue(map.containsValue("A"));
773         assertFalse(map.containsValue("Z"));
781         ConcurrentNavigableMap map = dmap5();
782         assertEquals("A", (String)map.get(m1));
788      * isEmpty is true of empty map and false for non-empty
792         ConcurrentNavigableMap map = dmap5();
794         assertFalse(map.isEmpty());
801         ConcurrentNavigableMap map = dmap5();
802         assertEquals(m1, map.firstKey());
809         ConcurrentNavigableMap map = dmap5();
810         assertEquals(m5, map.lastKey());
817         ConcurrentNavigableMap map = dmap5();
818         Set s = map.keySet();
831         ConcurrentNavigableMap map = dmap5();
832         Set s = map.keySet();
847         ConcurrentNavigableMap map = dmap5();
848         Collection s = map.values();
861         ConcurrentNavigableMap map = dmap5();
862         Set s = map.keySet();
874         ConcurrentNavigableMap map = dmap5();
875         Set s = map.descendingKeySet();
887         ConcurrentNavigableMap map = dmap5();
888         Collection v = map.values();
903         ConcurrentNavigableMap map = dmap5();
904         Set s = map.entrySet();
919      * putAll adds all key-value pairs from the given map
923         ConcurrentNavigableMap map = dmap5();
924         empty.putAll(map);
937         ConcurrentNavigableMap map = dmap5();
938         map.putIfAbsent(six, "Z");
939         assertTrue(map.containsKey(six));
946         ConcurrentNavigableMap map = dmap5();
947         assertEquals("A", map.putIfAbsent(m1, "Z"));
954         ConcurrentNavigableMap map = dmap5();
955         assertNull(map.replace(six, "Z"));
956         assertFalse(map.containsKey(six));
963         ConcurrentNavigableMap map = dmap5();
964         assertNotNull(map.replace(m1, "Z"));
965         assertEquals("Z", map.get(m1));
972         ConcurrentNavigableMap map = dmap5();
973         assertEquals("A", map.get(m1));
974         assertFalse(map.replace(m1, "Z", "Z"));
975         assertEquals("A", map.get(m1));
982         ConcurrentNavigableMap map = dmap5();
983         assertEquals("A", map.get(m1));
984         assertTrue(map.replace(m1, "A", "Z"));
985         assertEquals("Z", map.get(m1));
989      * remove removes the correct key-value pair from the map
992         ConcurrentNavigableMap map = dmap5();
993         map.remove(m5);
994         assertEquals(4, map.size());
995         assertFalse(map.containsKey(m5));
1002         ConcurrentNavigableMap map = dmap5();
1003         assertTrue(map.containsKey(m5));
1004         assertEquals("E", map.get(m5));
1005         map.remove(m5, "E");
1006         assertEquals(4, map.size());
1007         assertFalse(map.containsKey(m5));
1008         map.remove(m4, "A");
1009         assertEquals(4, map.size());
1010         assertTrue(map.containsKey(m4));
1017         ConcurrentNavigableMap map = dmap5();
1018         Map.Entry e1 = map.lowerEntry(m3);
1021         Map.Entry e2 = map.lowerEntry(m6);
1024         Map.Entry e3 = map.lowerEntry(m1);
1027         Map.Entry e4 = map.lowerEntry(zero);
1035         ConcurrentNavigableMap map = dmap5();
1036         Map.Entry e1 = map.higherEntry(m3);
1039         Map.Entry e2 = map.higherEntry(zero);
1042         Map.Entry e3 = map.higherEntry(m5);
1045         Map.Entry e4 = map.higherEntry(m6);
1053         ConcurrentNavigableMap map = dmap5();
1054         Map.Entry e1 = map.floorEntry(m3);
1057         Map.Entry e2 = map.floorEntry(m6);
1060         Map.Entry e3 = map.floorEntry(m1);
1063         Map.Entry e4 = map.floorEntry(zero);
1071         ConcurrentNavigableMap map = dmap5();
1072         Map.Entry e1 = map.ceilingEntry(m3);
1075         Map.Entry e2 = map.ceilingEntry(zero);
1078         Map.Entry e3 = map.ceilingEntry(m5);
1081         Map.Entry e4 = map.ceilingEntry(m6);
1089         ConcurrentNavigableMap map = dmap5();
1090         Map.Entry e = map.pollFirstEntry();
1093         e = map.pollFirstEntry();
1095         map.put(m1, "A");
1096         e = map.pollFirstEntry();
1099         e = map.pollFirstEntry();
1101         map.remove(m4);
1102         e = map.pollFirstEntry();
1108         e = map.pollFirstEntry();
1116         ConcurrentNavigableMap map = dmap5();
1117         Map.Entry e = map.pollLastEntry();
1120         e = map.pollLastEntry();
1122         map.put(m5, "E");
1123         e = map.pollLastEntry();
1126         e = map.pollLastEntry();
1128         map.remove(m2);
1129         e = map.pollLastEntry();
1135         e = map.pollLastEntry();
1143         ConcurrentNavigableMap map = dmap5();
1146         assertEquals(5, map.size());
1153         ConcurrentNavigableMap map = dmap5();
1154         String s = map.toString();
1163      * get(null) of empty map throws NPE
1174      * containsKey(null) of empty map throws NPE
1262      * A deserialized map equals original
1276      * subMap returns map with keys in requested range
1279         ConcurrentNavigableMap map = dmap5();
1280         SortedMap sm = map.subMap(m2, m4);
1299         assertFalse(map.containsKey(m2));
1300         assertEquals(4, map.size());
1306         assertEquals(3, map.size());
1310         ConcurrentNavigableMap map = dmap5();
1311         SortedMap sm = map.subMap(m2, m3);
1328         assertFalse(map.containsKey(m2));
1329         assertEquals(4, map.size());
1333         assertEquals(4, map.size());
1337      * headMap returns map with keys in requested range
1340         ConcurrentNavigableMap map = dmap5();
1341         SortedMap sm = map.headMap(m4);
1358         assertEquals(2, map.size());
1359         assertEquals(m4, map.firstKey());
1363      * headMap returns map with keys in requested range
1366         ConcurrentNavigableMap map = dmap5();
1367         SortedMap sm = map.tailMap(m2);
1407         assertEquals(4, map.size());

Indexes created Fri Mar 13 02:32:08 CET 2015