ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ConcurrentSkipListSubMapTest.java
Revision: 1.27
Committed: Tue Jan 26 13:33:05 2021 UTC (3 years, 3 months ago) by dl
Branch: MAIN
Changes since 1.26: +503 -505 lines
Log Message: 
Replace Integer with Item class

File Contents

# User Rev Content
1 dl 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 jsr166 1.17 * http://creativecommons.org/publicdomain/zero/1.0/
5 dl 1.1 */
6    
7 jsr166 1.24 import java.util.ArrayList;
8     import java.util.Arrays;
9     import java.util.Collection;
10     import java.util.Iterator;
11     import java.util.Map;
12     import java.util.NavigableMap;
13     import java.util.Set;
14     import java.util.SortedMap;
15 jsr166 1.19 import java.util.concurrent.ConcurrentNavigableMap;
16     import java.util.concurrent.ConcurrentSkipListMap;
17 jsr166 1.24
18     import junit.framework.Test;
19     import junit.framework.TestSuite;
20 dl 1.1
21     public class ConcurrentSkipListSubMapTest extends JSR166TestCase {
22     public static void main(String[] args) {
23 jsr166 1.25 main(suite(), args);
24 dl 1.1 }
25     public static Test suite() {
26 jsr166 1.9 return new TestSuite(ConcurrentSkipListSubMapTest.class);
27 dl 1.1 }
28    
29     /**
30 dl 1.27 * Returns a new map from Items 1-5 to Strings "A"-"E".
31 dl 1.1 */
32 dl 1.27 private static ConcurrentNavigableMap<Item,String> map5() {
33     ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
34 dl 1.1 assertTrue(map.isEmpty());
35 jsr166 1.9 map.put(zero, "Z");
36     map.put(one, "A");
37     map.put(five, "E");
38     map.put(three, "C");
39     map.put(two, "B");
40     map.put(four, "D");
41     map.put(seven, "F");
42 dl 1.1 assertFalse(map.isEmpty());
43 dl 1.27 mustEqual(7, map.size());
44 dl 1.5 return map.subMap(one, true, seven, false);
45     }
46    
47     /**
48 dl 1.27 * Returns a new map from Items -5 to -1 to Strings "A"-"E".
49 dl 1.5 */
50 dl 1.27 private static ConcurrentNavigableMap<Item,String> dmap5() {
51     ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
52 dl 1.5 assertTrue(map.isEmpty());
53 dl 1.27 map.put(minusOne, "A");
54     map.put(minusFive, "E");
55     map.put(minusThree, "C");
56     map.put(minusTwo, "B");
57     map.put(minusFour, "D");
58 dl 1.5 assertFalse(map.isEmpty());
59 dl 1.27 mustEqual(5, map.size());
60 jsr166 1.9 return map.descendingMap();
61 dl 1.1 }
62    
63 dl 1.27 private static ConcurrentNavigableMap<Item,String> map0() {
64     ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
65 dl 1.1 assertTrue(map.isEmpty());
66 dl 1.5 return map.tailMap(one, true);
67     }
68    
69 dl 1.27 private static ConcurrentNavigableMap<Item,String> dmap0() {
70     ConcurrentSkipListMap<Item,String>map = new ConcurrentSkipListMap<Item,String>();
71 dl 1.5 assertTrue(map.isEmpty());
72     return map;
73 dl 1.1 }
74    
75     /**
76 jsr166 1.16 * clear removes all pairs
77 dl 1.1 */
78     public void testClear() {
79 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
80 jsr166 1.9 map.clear();
81 dl 1.27 mustEqual(0, map.size());
82 dl 1.1 }
83    
84     /**
85 jsr166 1.16 * Maps with same contents are equal
86 dl 1.1 */
87     public void testEquals() {
88 dl 1.27 ConcurrentNavigableMap<Item,String> map1 = map5();
89     ConcurrentNavigableMap<Item,String> map2 = map5();
90     mustEqual(map1, map2);
91     mustEqual(map2, map1);
92 jsr166 1.9 map1.clear();
93 dl 1.1 assertFalse(map1.equals(map2));
94     assertFalse(map2.equals(map1));
95     }
96    
97     /**
98 jsr166 1.16 * containsKey returns true for contained key
99 dl 1.1 */
100     public void testContainsKey() {
101 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
102 jsr166 1.9 assertTrue(map.containsKey(one));
103 dl 1.1 assertFalse(map.containsKey(zero));
104     }
105    
106     /**
107 jsr166 1.16 * containsValue returns true for held values
108 dl 1.1 */
109     public void testContainsValue() {
110 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
111 jsr166 1.9 assertTrue(map.containsValue("A"));
112 dl 1.1 assertFalse(map.containsValue("Z"));
113     }
114    
115     /**
116 jsr166 1.16 * get returns the correct element at the given key,
117     * or null if not present
118 dl 1.1 */
119     public void testGet() {
120 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
121     mustEqual("A", map.get(one));
122     ConcurrentNavigableMap<Item,String> empty = map0();
123 dl 1.1 assertNull(empty.get(one));
124     }
125    
126     /**
127 jsr166 1.16 * isEmpty is true of empty map and false for non-empty
128 dl 1.1 */
129     public void testIsEmpty() {
130 dl 1.27 ConcurrentNavigableMap<Item,String> empty = map0();
131     ConcurrentNavigableMap<Item,String> map = map5();
132 jsr166 1.9 assertTrue(empty.isEmpty());
133 dl 1.1 assertFalse(map.isEmpty());
134     }
135    
136     /**
137 jsr166 1.16 * firstKey returns first key
138 dl 1.1 */
139     public void testFirstKey() {
140 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
141     mustEqual(one, map.firstKey());
142 dl 1.1 }
143    
144     /**
145 jsr166 1.16 * lastKey returns last key
146 dl 1.1 */
147     public void testLastKey() {
148 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
149     mustEqual(five, map.lastKey());
150 dl 1.1 }
151    
152     /**
153 jsr166 1.16 * keySet returns a Set containing all the keys
154 dl 1.1 */
155     public void testKeySet() {
156 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
157     Set<Item> s = map.keySet();
158     mustEqual(5, s.size());
159     mustContain(s, one);
160     mustContain(s, two);
161     mustContain(s, three);
162     mustContain(s, four);
163     mustContain(s, five);
164 dl 1.1 }
165    
166     /**
167 jsr166 1.16 * keySet is ordered
168 dl 1.1 */
169     public void testKeySetOrder() {
170 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
171     Set<Item> s = map.keySet();
172     Iterator<? extends Item> i = s.iterator();
173     Item last = i.next();
174     mustEqual(last, one);
175 dl 1.1 while (i.hasNext()) {
176 dl 1.27 Item k = i.next();
177 dl 1.1 assertTrue(last.compareTo(k) < 0);
178     last = k;
179     }
180     }
181    
182     /**
183     * values collection contains all values
184     */
185     public void testValues() {
186 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
187     Collection<String> s = map.values();
188     mustEqual(5, s.size());
189 jsr166 1.9 assertTrue(s.contains("A"));
190     assertTrue(s.contains("B"));
191     assertTrue(s.contains("C"));
192     assertTrue(s.contains("D"));
193     assertTrue(s.contains("E"));
194 dl 1.1 }
195    
196     /**
197 jsr166 1.16 * keySet.toArray returns contains all keys
198 dl 1.3 */
199     public void testKeySetToArray() {
200 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
201     Set<Item> s = map.keySet();
202 dl 1.3 Object[] ar = s.toArray();
203     assertTrue(s.containsAll(Arrays.asList(ar)));
204 dl 1.27 mustEqual(5, ar.length);
205     ar[0] = minusTen;
206 dl 1.3 assertFalse(s.containsAll(Arrays.asList(ar)));
207     }
208    
209     /**
210 jsr166 1.16 * descendingkeySet.toArray returns contains all keys
211 dl 1.3 */
212     public void testDescendingKeySetToArray() {
213 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
214     Set<Item> s = map.descendingKeySet();
215     Item[] ar = s.toArray(new Item[0]);
216     mustEqual(5, ar.length);
217 dl 1.3 assertTrue(s.containsAll(Arrays.asList(ar)));
218 dl 1.27 ar[0] = minusTen;
219 dl 1.3 assertFalse(s.containsAll(Arrays.asList(ar)));
220     }
221    
222     /**
223 jsr166 1.16 * Values.toArray contains all values
224 dl 1.3 */
225     public void testValuesToArray() {
226 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
227     Collection<String> v = map.values();
228     String[] ar = v.toArray(new String[0]);
229     ArrayList<String> s = new ArrayList<String>(Arrays.asList(ar));
230     mustEqual(5, ar.length);
231 jsr166 1.9 assertTrue(s.contains("A"));
232     assertTrue(s.contains("B"));
233     assertTrue(s.contains("C"));
234     assertTrue(s.contains("D"));
235     assertTrue(s.contains("E"));
236 dl 1.3 }
237    
238     /**
239 dl 1.1 * entrySet contains all pairs
240     */
241     public void testEntrySet() {
242 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
243     Set<Map.Entry<Item,String>> s = map.entrySet();
244     mustEqual(5, s.size());
245     Iterator<Map.Entry<Item,String>> it = s.iterator();
246 dl 1.1 while (it.hasNext()) {
247 dl 1.27 Map.Entry<Item,String> e = it.next();
248 jsr166 1.6 assertTrue(
249 dl 1.1 (e.getKey().equals(one) && e.getValue().equals("A")) ||
250     (e.getKey().equals(two) && e.getValue().equals("B")) ||
251     (e.getKey().equals(three) && e.getValue().equals("C")) ||
252     (e.getKey().equals(four) && e.getValue().equals("D")) ||
253     (e.getKey().equals(five) && e.getValue().equals("E")));
254     }
255     }
256    
257     /**
258 jsr166 1.16 * putAll adds all key-value pairs from the given map
259 dl 1.1 */
260     public void testPutAll() {
261 dl 1.27 ConcurrentNavigableMap<Item,String> empty = map0();
262     ConcurrentNavigableMap<Item,String> map = map5();
263 jsr166 1.9 empty.putAll(map);
264 dl 1.27 mustEqual(5, empty.size());
265 jsr166 1.9 assertTrue(empty.containsKey(one));
266     assertTrue(empty.containsKey(two));
267     assertTrue(empty.containsKey(three));
268     assertTrue(empty.containsKey(four));
269     assertTrue(empty.containsKey(five));
270 dl 1.1 }
271    
272     /**
273 jsr166 1.16 * putIfAbsent works when the given key is not present
274 dl 1.1 */
275     public void testPutIfAbsent() {
276 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
277 jsr166 1.9 map.putIfAbsent(six, "Z");
278 dl 1.1 assertTrue(map.containsKey(six));
279     }
280    
281     /**
282 jsr166 1.16 * putIfAbsent does not add the pair if the key is already present
283 dl 1.1 */
284     public void testPutIfAbsent2() {
285 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
286     mustEqual("A", map.putIfAbsent(one, "Z"));
287 dl 1.1 }
288    
289     /**
290 jsr166 1.16 * replace fails when the given key is not present
291 dl 1.1 */
292     public void testReplace() {
293 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
294 jsr166 1.9 assertNull(map.replace(six, "Z"));
295 dl 1.1 assertFalse(map.containsKey(six));
296     }
297    
298     /**
299 jsr166 1.16 * replace succeeds if the key is already present
300 dl 1.1 */
301     public void testReplace2() {
302 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
303 dl 1.1 assertNotNull(map.replace(one, "Z"));
304 dl 1.27 mustEqual("Z", map.get(one));
305 dl 1.1 }
306    
307     /**
308     * replace value fails when the given key not mapped to expected value
309     */
310     public void testReplaceValue() {
311 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
312     mustEqual("A", map.get(one));
313 jsr166 1.9 assertFalse(map.replace(one, "Z", "Z"));
314 dl 1.27 mustEqual("A", map.get(one));
315 dl 1.1 }
316    
317     /**
318     * replace value succeeds when the given key mapped to expected value
319     */
320     public void testReplaceValue2() {
321 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
322     mustEqual("A", map.get(one));
323 jsr166 1.9 assertTrue(map.replace(one, "A", "Z"));
324 dl 1.27 mustEqual("Z", map.get(one));
325 dl 1.1 }
326    
327     /**
328 jsr166 1.16 * remove removes the correct key-value pair from the map
329 dl 1.1 */
330     public void testRemove() {
331 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
332 jsr166 1.9 map.remove(five);
333 dl 1.27 mustEqual(4, map.size());
334 jsr166 1.9 assertFalse(map.containsKey(five));
335 dl 1.1 }
336    
337     /**
338     * remove(key,value) removes only if pair present
339     */
340     public void testRemove2() {
341 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
342 jsr166 1.9 assertTrue(map.containsKey(five));
343 dl 1.27 mustEqual("E", map.get(five));
344 jsr166 1.9 map.remove(five, "E");
345 dl 1.27 mustEqual(4, map.size());
346 jsr166 1.9 assertFalse(map.containsKey(five));
347     map.remove(four, "A");
348 dl 1.27 mustEqual(4, map.size());
349 jsr166 1.9 assertTrue(map.containsKey(four));
350 dl 1.1 }
351    
352     /**
353     * lowerEntry returns preceding entry.
354     */
355     public void testLowerEntry() {
356 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
357     Map.Entry<Item,String> e1 = map.lowerEntry(three);
358     mustEqual(two, e1.getKey());
359 dl 1.1
360 dl 1.27 Map.Entry<Item,String> e2 = map.lowerEntry(six);
361     mustEqual(five, e2.getKey());
362 dl 1.1
363 dl 1.27 Map.Entry<Item,String> e3 = map.lowerEntry(one);
364 dl 1.1 assertNull(e3);
365    
366 dl 1.27 Map.Entry<Item,String> e4 = map.lowerEntry(zero);
367 dl 1.1 assertNull(e4);
368     }
369    
370     /**
371     * higherEntry returns next entry.
372     */
373     public void testHigherEntry() {
374 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
375     Map.Entry<Item,String> e1 = map.higherEntry(three);
376     mustEqual(four, e1.getKey());
377 dl 1.1
378 dl 1.27 Map.Entry<Item,String> e2 = map.higherEntry(zero);
379     mustEqual(one, e2.getKey());
380 dl 1.1
381 dl 1.27 Map.Entry<Item,String> e3 = map.higherEntry(five);
382 dl 1.1 assertNull(e3);
383    
384 dl 1.27 Map.Entry<Item,String> e4 = map.higherEntry(six);
385 dl 1.1 assertNull(e4);
386     }
387    
388     /**
389     * floorEntry returns preceding entry.
390     */
391     public void testFloorEntry() {
392 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
393     Map.Entry<Item,String> e1 = map.floorEntry(three);
394     mustEqual(three, e1.getKey());
395 dl 1.1
396 dl 1.27 Map.Entry<Item,String> e2 = map.floorEntry(six);
397     mustEqual(five, e2.getKey());
398 dl 1.1
399 dl 1.27 Map.Entry<Item,String> e3 = map.floorEntry(one);
400     mustEqual(one, e3.getKey());
401 dl 1.1
402 dl 1.27 Map.Entry<Item,String> e4 = map.floorEntry(zero);
403 dl 1.1 assertNull(e4);
404     }
405    
406     /**
407     * ceilingEntry returns next entry.
408     */
409     public void testCeilingEntry() {
410 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
411     Map.Entry<Item,String> e1 = map.ceilingEntry(three);
412     mustEqual(three, e1.getKey());
413 dl 1.1
414 dl 1.27 Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
415     mustEqual(one, e2.getKey());
416 dl 1.1
417 dl 1.27 Map.Entry<Item,String> e3 = map.ceilingEntry(five);
418     mustEqual(five, e3.getKey());
419 dl 1.1
420 dl 1.27 Map.Entry<Item,String> e4 = map.ceilingEntry(six);
421 dl 1.1 assertNull(e4);
422     }
423    
424     /**
425     * pollFirstEntry returns entries in order
426     */
427     public void testPollFirstEntry() {
428 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
429     Map.Entry<Item,String> e = map.pollFirstEntry();
430     mustEqual(one, e.getKey());
431     mustEqual("A", e.getValue());
432 dl 1.1 e = map.pollFirstEntry();
433 dl 1.27 mustEqual(two, e.getKey());
434 dl 1.1 map.put(one, "A");
435     e = map.pollFirstEntry();
436 dl 1.27 mustEqual(one, e.getKey());
437     mustEqual("A", e.getValue());
438 dl 1.1 e = map.pollFirstEntry();
439 dl 1.27 mustEqual(three, e.getKey());
440 dl 1.1 map.remove(four);
441     e = map.pollFirstEntry();
442 dl 1.27 mustEqual(five, e.getKey());
443 dl 1.1 try {
444     e.setValue("A");
445     shouldThrow();
446 jsr166 1.11 } catch (UnsupportedOperationException success) {}
447 dl 1.1 e = map.pollFirstEntry();
448     assertNull(e);
449     }
450    
451     /**
452     * pollLastEntry returns entries in order
453     */
454     public void testPollLastEntry() {
455 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
456     Map.Entry<Item,String> e = map.pollLastEntry();
457     mustEqual(five, e.getKey());
458     mustEqual("E", e.getValue());
459 dl 1.1 e = map.pollLastEntry();
460 dl 1.27 mustEqual(four, e.getKey());
461 dl 1.1 map.put(five, "E");
462     e = map.pollLastEntry();
463 dl 1.27 mustEqual(five, e.getKey());
464     mustEqual("E", e.getValue());
465 dl 1.1 e = map.pollLastEntry();
466 dl 1.27 mustEqual(three, e.getKey());
467 dl 1.1 map.remove(two);
468     e = map.pollLastEntry();
469 dl 1.27 mustEqual(one, e.getKey());
470 dl 1.1 try {
471     e.setValue("E");
472     shouldThrow();
473 jsr166 1.11 } catch (UnsupportedOperationException success) {}
474 dl 1.1 e = map.pollLastEntry();
475     assertNull(e);
476     }
477    
478     /**
479 jsr166 1.16 * size returns the correct values
480 dl 1.1 */
481     public void testSize() {
482 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
483     ConcurrentNavigableMap<Item,String> empty = map0();
484     mustEqual(0, empty.size());
485     mustEqual(5, map.size());
486 dl 1.1 }
487    
488     /**
489     * toString contains toString of elements
490     */
491     public void testToString() {
492 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
493 dl 1.1 String s = map.toString();
494     for (int i = 1; i <= 5; ++i) {
495 jsr166 1.18 assertTrue(s.contains(String.valueOf(i)));
496 dl 1.1 }
497 jsr166 1.6 }
498 dl 1.1
499     // Exception tests
500    
501     /**
502     * get(null) of nonempty map throws NPE
503     */
504     public void testGet_NullPointerException() {
505     try {
506 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
507 dl 1.1 c.get(null);
508     shouldThrow();
509 jsr166 1.11 } catch (NullPointerException success) {}
510 dl 1.1 }
511    
512     /**
513     * containsKey(null) of nonempty map throws NPE
514     */
515     public void testContainsKey_NullPointerException() {
516     try {
517 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
518 dl 1.1 c.containsKey(null);
519     shouldThrow();
520 jsr166 1.11 } catch (NullPointerException success) {}
521 dl 1.1 }
522    
523     /**
524     * containsValue(null) throws NPE
525     */
526     public void testContainsValue_NullPointerException() {
527     try {
528 dl 1.27 ConcurrentNavigableMap<Item,String> c = map0();
529 dl 1.1 c.containsValue(null);
530     shouldThrow();
531 jsr166 1.11 } catch (NullPointerException success) {}
532 dl 1.1 }
533    
534     /**
535     * put(null,x) throws NPE
536     */
537     public void testPut1_NullPointerException() {
538     try {
539 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
540 dl 1.1 c.put(null, "whatever");
541     shouldThrow();
542 jsr166 1.11 } catch (NullPointerException success) {}
543 dl 1.1 }
544    
545     /**
546     * putIfAbsent(null, x) throws NPE
547     */
548     public void testPutIfAbsent1_NullPointerException() {
549     try {
550 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
551 dl 1.1 c.putIfAbsent(null, "whatever");
552     shouldThrow();
553 jsr166 1.11 } catch (NullPointerException success) {}
554 dl 1.1 }
555    
556     /**
557     * replace(null, x) throws NPE
558     */
559     public void testReplace_NullPointerException() {
560     try {
561 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
562     c.replace(null, "A");
563 dl 1.1 shouldThrow();
564 jsr166 1.11 } catch (NullPointerException success) {}
565 dl 1.1 }
566    
567     /**
568     * replace(null, x, y) throws NPE
569     */
570     public void testReplaceValue_NullPointerException() {
571     try {
572 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
573     c.replace(null, "A", "B");
574 dl 1.1 shouldThrow();
575 jsr166 1.11 } catch (NullPointerException success) {}
576 dl 1.1 }
577    
578     /**
579     * remove(null) throws NPE
580     */
581     public void testRemove1_NullPointerException() {
582     try {
583 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
584 dl 1.1 c.remove(null);
585     shouldThrow();
586 jsr166 1.11 } catch (NullPointerException success) {}
587 dl 1.1 }
588    
589     /**
590     * remove(null, x) throws NPE
591     */
592     public void testRemove2_NullPointerException() {
593     try {
594 dl 1.27 ConcurrentNavigableMap<Item,String> c = map5();
595 dl 1.1 c.remove(null, "whatever");
596     shouldThrow();
597 jsr166 1.11 } catch (NullPointerException success) {}
598 dl 1.1 }
599    
600     /**
601 jsr166 1.26 * A deserialized/reserialized map equals original
602 dl 1.1 */
603 jsr166 1.10 public void testSerialization() throws Exception {
604 dl 1.27 NavigableMap<Item,String> x = map5();
605     NavigableMap<Item,String> y = serialClone(x);
606 dl 1.1
607 jsr166 1.23 assertNotSame(x, y);
608 dl 1.27 mustEqual(x.size(), y.size());
609     mustEqual(x.toString(), y.toString());
610     mustEqual(x, y);
611     mustEqual(y, x);
612 dl 1.1 }
613    
614     /**
615     * subMap returns map with keys in requested range
616     */
617     public void testSubMapContents() {
618 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
619     SortedMap<Item,String> sm = map.subMap(two, four);
620     mustEqual(two, sm.firstKey());
621     mustEqual(three, sm.lastKey());
622     mustEqual(2, sm.size());
623 dl 1.1 assertFalse(sm.containsKey(one));
624     assertTrue(sm.containsKey(two));
625     assertTrue(sm.containsKey(three));
626     assertFalse(sm.containsKey(four));
627     assertFalse(sm.containsKey(five));
628 dl 1.27 Iterator<? extends Item> i = sm.keySet().iterator();
629     Item k;
630     k = (Item)(i.next());
631     mustEqual(two, k);
632     k = (Item)(i.next());
633     mustEqual(three, k);
634 dl 1.1 assertFalse(i.hasNext());
635 dl 1.27 Iterator<? extends Item> j = sm.keySet().iterator();
636 dl 1.1 j.next();
637     j.remove();
638     assertFalse(map.containsKey(two));
639 dl 1.27 mustEqual(4, map.size());
640     mustEqual(1, sm.size());
641     mustEqual(three, sm.firstKey());
642     mustEqual(three, sm.lastKey());
643     mustEqual("C", sm.remove(three));
644 dl 1.1 assertTrue(sm.isEmpty());
645 dl 1.27 mustEqual(3, map.size());
646 dl 1.1 }
647    
648     public void testSubMapContents2() {
649 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
650     SortedMap<Item,String> sm = map.subMap(two, three);
651     mustEqual(1, sm.size());
652     mustEqual(two, sm.firstKey());
653     mustEqual(two, sm.lastKey());
654 dl 1.1 assertFalse(sm.containsKey(one));
655     assertTrue(sm.containsKey(two));
656     assertFalse(sm.containsKey(three));
657     assertFalse(sm.containsKey(four));
658     assertFalse(sm.containsKey(five));
659 dl 1.27 Iterator<? extends Item> i = sm.keySet().iterator();
660     Item k;
661     k = (Item)(i.next());
662     mustEqual(two, k);
663 dl 1.1 assertFalse(i.hasNext());
664 dl 1.27 Iterator<? extends Item> j = sm.keySet().iterator();
665 dl 1.1 j.next();
666     j.remove();
667     assertFalse(map.containsKey(two));
668 dl 1.27 mustEqual(4, map.size());
669     mustEqual(0, sm.size());
670 dl 1.1 assertTrue(sm.isEmpty());
671 jsr166 1.12 assertSame(sm.remove(three), null);
672 dl 1.27 mustEqual(4, map.size());
673 dl 1.1 }
674    
675     /**
676     * headMap returns map with keys in requested range
677     */
678     public void testHeadMapContents() {
679 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
680     SortedMap<Item,String> sm = map.headMap(four);
681 dl 1.1 assertTrue(sm.containsKey(one));
682     assertTrue(sm.containsKey(two));
683     assertTrue(sm.containsKey(three));
684     assertFalse(sm.containsKey(four));
685     assertFalse(sm.containsKey(five));
686 dl 1.27 Iterator<? extends Item> i = sm.keySet().iterator();
687 dl 1.1 Object k;
688 dl 1.27 k = (Item)(i.next());
689     mustEqual(one, k);
690     k = (Item)(i.next());
691     mustEqual(two, k);
692     k = (Item)(i.next());
693     mustEqual(three, k);
694 dl 1.1 assertFalse(i.hasNext());
695     sm.clear();
696     assertTrue(sm.isEmpty());
697 dl 1.27 mustEqual(2, map.size());
698     mustEqual(four, map.firstKey());
699 dl 1.1 }
700    
701     /**
702     * headMap returns map with keys in requested range
703     */
704     public void testTailMapContents() {
705 dl 1.27 ConcurrentNavigableMap<Item,String> map = map5();
706     SortedMap<Item,String> sm = map.tailMap(two);
707 dl 1.1 assertFalse(sm.containsKey(one));
708     assertTrue(sm.containsKey(two));
709     assertTrue(sm.containsKey(three));
710     assertTrue(sm.containsKey(four));
711     assertTrue(sm.containsKey(five));
712 dl 1.27 Iterator<Item> i = sm.keySet().iterator();
713     Item k = i.next();
714     mustEqual(two, k);
715     k = i.next();
716     mustEqual(three, k);
717     k = i.next();
718     mustEqual(four, k);
719     k = i.next();
720     mustEqual(five, k);
721 dl 1.1 assertFalse(i.hasNext());
722    
723 dl 1.27 Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
724     Map.Entry<Item,String> e;
725     e = (ei.next());
726     mustEqual(two, e.getKey());
727     mustEqual("B", e.getValue());
728     e = (ei.next());
729     mustEqual(three, e.getKey());
730     mustEqual("C", e.getValue());
731     e = (ei.next());
732     mustEqual(four, e.getKey());
733     mustEqual("D", e.getValue());
734     e = (ei.next());
735     mustEqual(five, e.getKey());
736     mustEqual("E", e.getValue());
737 dl 1.1 assertFalse(i.hasNext());
738    
739 dl 1.27 SortedMap<Item,String> ssm = sm.tailMap(four);
740     mustEqual(four, ssm.firstKey());
741     mustEqual(five, ssm.lastKey());
742     mustEqual("D", ssm.remove(four));
743     mustEqual(1, ssm.size());
744     mustEqual(3, sm.size());
745     mustEqual(4, map.size());
746 dl 1.1 }
747 dl 1.5
748     /**
749 jsr166 1.16 * clear removes all pairs
750 dl 1.5 */
751     public void testDescendingClear() {
752 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
753 jsr166 1.9 map.clear();
754 dl 1.27 mustEqual(0, map.size());
755 dl 1.5 }
756    
757     /**
758 jsr166 1.16 * Maps with same contents are equal
759 dl 1.5 */
760     public void testDescendingEquals() {
761 dl 1.27 ConcurrentNavigableMap<Item,String> map1 = dmap5();
762     ConcurrentNavigableMap<Item,String> map2 = dmap5();
763     mustEqual(map1, map2);
764     mustEqual(map2, map1);
765 jsr166 1.9 map1.clear();
766 dl 1.5 assertFalse(map1.equals(map2));
767     assertFalse(map2.equals(map1));
768     }
769    
770     /**
771 jsr166 1.16 * containsKey returns true for contained key
772 dl 1.5 */
773     public void testDescendingContainsKey() {
774 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
775     assertTrue(map.containsKey(minusOne));
776 dl 1.5 assertFalse(map.containsKey(zero));
777     }
778    
779     /**
780 jsr166 1.16 * containsValue returns true for held values
781 dl 1.5 */
782     public void testDescendingContainsValue() {
783 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
784 jsr166 1.9 assertTrue(map.containsValue("A"));
785 dl 1.5 assertFalse(map.containsValue("Z"));
786     }
787    
788     /**
789 jsr166 1.16 * get returns the correct element at the given key,
790     * or null if not present
791 dl 1.5 */
792     public void testDescendingGet() {
793 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
794     mustEqual("A", map.get(minusOne));
795     ConcurrentNavigableMap<Item,String> empty = dmap0();
796     assertNull(empty.get(minusOne));
797 dl 1.5 }
798    
799     /**
800 jsr166 1.16 * isEmpty is true of empty map and false for non-empty
801 dl 1.5 */
802     public void testDescendingIsEmpty() {
803 dl 1.27 ConcurrentNavigableMap<Item,String> empty = dmap0();
804     ConcurrentNavigableMap<Item,String> map = dmap5();
805 jsr166 1.9 assertTrue(empty.isEmpty());
806 dl 1.5 assertFalse(map.isEmpty());
807     }
808    
809     /**
810 jsr166 1.16 * firstKey returns first key
811 dl 1.5 */
812     public void testDescendingFirstKey() {
813 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
814     mustEqual(minusOne, map.firstKey());
815 dl 1.5 }
816    
817     /**
818 jsr166 1.16 * lastKey returns last key
819 dl 1.5 */
820     public void testDescendingLastKey() {
821 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
822     mustEqual(minusFive, map.lastKey());
823 dl 1.5 }
824    
825     /**
826 jsr166 1.16 * keySet returns a Set containing all the keys
827 dl 1.5 */
828     public void testDescendingKeySet() {
829 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
830     Set<Item> s = map.keySet();
831     mustEqual(5, s.size());
832     mustContain(s, minusOne);
833     mustContain(s, minusTwo);
834     mustContain(s, minusThree);
835     mustContain(s, minusFour);
836     mustContain(s, minusFive);
837 dl 1.5 }
838    
839     /**
840 jsr166 1.16 * keySet is ordered
841 dl 1.5 */
842     public void testDescendingKeySetOrder() {
843 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
844     Set<Item> s = map.keySet();
845     Iterator<? extends Item> i = s.iterator();
846     Item last = i.next();
847     mustEqual(last, minusOne);
848 dl 1.5 while (i.hasNext()) {
849 dl 1.27 Item k = i.next();
850 dl 1.5 assertTrue(last.compareTo(k) > 0);
851     last = k;
852     }
853     }
854    
855     /**
856     * values collection contains all values
857     */
858     public void testDescendingValues() {
859 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
860     Collection<String> s = map.values();
861     mustEqual(5, s.size());
862 jsr166 1.9 assertTrue(s.contains("A"));
863     assertTrue(s.contains("B"));
864     assertTrue(s.contains("C"));
865     assertTrue(s.contains("D"));
866     assertTrue(s.contains("E"));
867 dl 1.5 }
868    
869     /**
870 jsr166 1.16 * keySet.toArray returns contains all keys
871 dl 1.5 */
872     public void testDescendingAscendingKeySetToArray() {
873 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
874     Set<Item> s = map.keySet();
875     Item[] ar = s.toArray(new Item[0]);
876 dl 1.5 assertTrue(s.containsAll(Arrays.asList(ar)));
877 dl 1.27 mustEqual(5, ar.length);
878     ar[0] = minusTen;
879 dl 1.5 assertFalse(s.containsAll(Arrays.asList(ar)));
880     }
881    
882     /**
883 jsr166 1.16 * descendingkeySet.toArray returns contains all keys
884 dl 1.5 */
885     public void testDescendingDescendingKeySetToArray() {
886 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
887     Set<Item> s = map.descendingKeySet();
888     Item[] ar = s.toArray(new Item[0]);
889     mustEqual(5, ar.length);
890 dl 1.5 assertTrue(s.containsAll(Arrays.asList(ar)));
891 dl 1.27 ar[0] = minusTen;
892 dl 1.5 assertFalse(s.containsAll(Arrays.asList(ar)));
893     }
894    
895     /**
896 jsr166 1.16 * Values.toArray contains all values
897 dl 1.5 */
898     public void testDescendingValuesToArray() {
899 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
900     Collection<String> v = map.values();
901     String[] ar = v.toArray(new String[0]);
902     ArrayList<String> s = new ArrayList<String>(Arrays.asList(ar));
903     mustEqual(5, ar.length);
904 jsr166 1.9 assertTrue(s.contains("A"));
905     assertTrue(s.contains("B"));
906     assertTrue(s.contains("C"));
907     assertTrue(s.contains("D"));
908     assertTrue(s.contains("E"));
909 dl 1.5 }
910    
911     /**
912     * entrySet contains all pairs
913     */
914     public void testDescendingEntrySet() {
915 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
916     Set<Map.Entry<Item,String>> s = map.entrySet();
917     mustEqual(5, s.size());
918     Iterator<Map.Entry<Item,String>> it = s.iterator();
919 dl 1.5 while (it.hasNext()) {
920 dl 1.27 Map.Entry<Item,String> e = it.next();
921 jsr166 1.6 assertTrue(
922 dl 1.27 (e.getKey().equals(minusOne) && e.getValue().equals("A")) ||
923     (e.getKey().equals(minusTwo) && e.getValue().equals("B")) ||
924     (e.getKey().equals(minusThree) && e.getValue().equals("C")) ||
925     (e.getKey().equals(minusFour) && e.getValue().equals("D")) ||
926     (e.getKey().equals(minusFive) && e.getValue().equals("E")));
927 dl 1.5 }
928     }
929    
930     /**
931 jsr166 1.16 * putAll adds all key-value pairs from the given map
932 dl 1.5 */
933     public void testDescendingPutAll() {
934 dl 1.27 ConcurrentNavigableMap<Item,String> empty = dmap0();
935     ConcurrentNavigableMap<Item,String> map = dmap5();
936 jsr166 1.9 empty.putAll(map);
937 dl 1.27 mustEqual(5, empty.size());
938     assertTrue(empty.containsKey(minusOne));
939     assertTrue(empty.containsKey(minusTwo));
940     assertTrue(empty.containsKey(minusThree));
941     assertTrue(empty.containsKey(minusFour));
942     assertTrue(empty.containsKey(minusFive));
943 dl 1.5 }
944    
945     /**
946 jsr166 1.16 * putIfAbsent works when the given key is not present
947 dl 1.5 */
948     public void testDescendingPutIfAbsent() {
949 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
950 jsr166 1.9 map.putIfAbsent(six, "Z");
951 dl 1.5 assertTrue(map.containsKey(six));
952     }
953    
954     /**
955 jsr166 1.16 * putIfAbsent does not add the pair if the key is already present
956 dl 1.5 */
957     public void testDescendingPutIfAbsent2() {
958 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
959     mustEqual("A", map.putIfAbsent(minusOne, "Z"));
960 dl 1.5 }
961    
962     /**
963 jsr166 1.16 * replace fails when the given key is not present
964 dl 1.5 */
965     public void testDescendingReplace() {
966 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
967 jsr166 1.9 assertNull(map.replace(six, "Z"));
968 dl 1.5 assertFalse(map.containsKey(six));
969     }
970    
971     /**
972 jsr166 1.16 * replace succeeds if the key is already present
973 dl 1.5 */
974     public void testDescendingReplace2() {
975 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
976     assertNotNull(map.replace(minusOne, "Z"));
977     mustEqual("Z", map.get(minusOne));
978 dl 1.5 }
979    
980     /**
981     * replace value fails when the given key not mapped to expected value
982     */
983     public void testDescendingReplaceValue() {
984 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
985     mustEqual("A", map.get(minusOne));
986     assertFalse(map.replace(minusOne, "Z", "Z"));
987     mustEqual("A", map.get(minusOne));
988 dl 1.5 }
989    
990     /**
991     * replace value succeeds when the given key mapped to expected value
992     */
993     public void testDescendingReplaceValue2() {
994 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
995     mustEqual("A", map.get(minusOne));
996     assertTrue(map.replace(minusOne, "A", "Z"));
997     mustEqual("Z", map.get(minusOne));
998 dl 1.5 }
999    
1000     /**
1001 jsr166 1.16 * remove removes the correct key-value pair from the map
1002 dl 1.5 */
1003     public void testDescendingRemove() {
1004 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1005     map.remove(minusFive);
1006     mustEqual(4, map.size());
1007     assertFalse(map.containsKey(minusFive));
1008 dl 1.5 }
1009    
1010     /**
1011     * remove(key,value) removes only if pair present
1012     */
1013     public void testDescendingRemove2() {
1014 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1015     assertTrue(map.containsKey(minusFive));
1016     mustEqual("E", map.get(minusFive));
1017     map.remove(minusFive, "E");
1018     mustEqual(4, map.size());
1019     assertFalse(map.containsKey(minusFive));
1020     map.remove(minusFour, "A");
1021     mustEqual(4, map.size());
1022     assertTrue(map.containsKey(minusFour));
1023 dl 1.5 }
1024    
1025     /**
1026     * lowerEntry returns preceding entry.
1027     */
1028     public void testDescendingLowerEntry() {
1029 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1030     Map.Entry<Item,String> e1 = map.lowerEntry(minusThree);
1031     mustEqual(minusTwo, e1.getKey());
1032 dl 1.5
1033 dl 1.27 Map.Entry<Item,String> e2 = map.lowerEntry(minusSix);
1034     mustEqual(minusFive, e2.getKey());
1035 dl 1.5
1036 dl 1.27 Map.Entry<Item,String> e3 = map.lowerEntry(minusOne);
1037 dl 1.5 assertNull(e3);
1038    
1039 dl 1.27 Map.Entry<Item,String> e4 = map.lowerEntry(zero);
1040 dl 1.5 assertNull(e4);
1041     }
1042    
1043     /**
1044     * higherEntry returns next entry.
1045     */
1046     public void testDescendingHigherEntry() {
1047 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1048     Map.Entry<Item,String> e1 = map.higherEntry(minusThree);
1049     mustEqual(minusFour, e1.getKey());
1050 dl 1.5
1051 dl 1.27 Map.Entry<Item,String> e2 = map.higherEntry(zero);
1052     mustEqual(minusOne, e2.getKey());
1053 dl 1.5
1054 dl 1.27 Map.Entry<Item,String> e3 = map.higherEntry(minusFive);
1055 dl 1.5 assertNull(e3);
1056    
1057 dl 1.27 Map.Entry<Item,String> e4 = map.higherEntry(minusSix);
1058 dl 1.5 assertNull(e4);
1059     }
1060    
1061     /**
1062     * floorEntry returns preceding entry.
1063     */
1064     public void testDescendingFloorEntry() {
1065 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1066     Map.Entry<Item,String> e1 = map.floorEntry(minusThree);
1067     mustEqual(minusThree, e1.getKey());
1068 dl 1.5
1069 dl 1.27 Map.Entry<Item,String> e2 = map.floorEntry(minusSix);
1070     mustEqual(minusFive, e2.getKey());
1071 dl 1.5
1072 dl 1.27 Map.Entry<Item,String> e3 = map.floorEntry(minusOne);
1073     mustEqual(minusOne, e3.getKey());
1074 dl 1.5
1075 dl 1.27 Map.Entry<Item,String> e4 = map.floorEntry(zero);
1076 dl 1.5 assertNull(e4);
1077     }
1078    
1079     /**
1080     * ceilingEntry returns next entry.
1081     */
1082     public void testDescendingCeilingEntry() {
1083 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1084     Map.Entry<Item,String> e1 = map.ceilingEntry(minusThree);
1085     mustEqual(minusThree, e1.getKey());
1086 dl 1.5
1087 dl 1.27 Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
1088     mustEqual(minusOne, e2.getKey());
1089 dl 1.5
1090 dl 1.27 Map.Entry<Item,String> e3 = map.ceilingEntry(minusFive);
1091     mustEqual(minusFive, e3.getKey());
1092 dl 1.5
1093 dl 1.27 Map.Entry<Item,String> e4 = map.ceilingEntry(minusSix);
1094 dl 1.5 assertNull(e4);
1095     }
1096    
1097     /**
1098     * pollFirstEntry returns entries in order
1099     */
1100     public void testDescendingPollFirstEntry() {
1101 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1102     Map.Entry<Item,String> e = map.pollFirstEntry();
1103     mustEqual(minusOne, e.getKey());
1104     mustEqual("A", e.getValue());
1105 dl 1.5 e = map.pollFirstEntry();
1106 dl 1.27 mustEqual(minusTwo, e.getKey());
1107     map.put(minusOne, "A");
1108 dl 1.5 e = map.pollFirstEntry();
1109 dl 1.27 mustEqual(minusOne, e.getKey());
1110     mustEqual("A", e.getValue());
1111 dl 1.5 e = map.pollFirstEntry();
1112 dl 1.27 mustEqual(minusThree, e.getKey());
1113     map.remove(minusFour);
1114 dl 1.5 e = map.pollFirstEntry();
1115 dl 1.27 mustEqual(minusFive, e.getKey());
1116 dl 1.5 try {
1117     e.setValue("A");
1118     shouldThrow();
1119 jsr166 1.11 } catch (UnsupportedOperationException success) {}
1120 dl 1.5 e = map.pollFirstEntry();
1121     assertNull(e);
1122     }
1123    
1124     /**
1125     * pollLastEntry returns entries in order
1126     */
1127     public void testDescendingPollLastEntry() {
1128 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1129     Map.Entry<Item,String> e = map.pollLastEntry();
1130     mustEqual(minusFive, e.getKey());
1131     mustEqual("E", e.getValue());
1132 dl 1.5 e = map.pollLastEntry();
1133 dl 1.27 mustEqual(minusFour, e.getKey());
1134     map.put(minusFive, "E");
1135 dl 1.5 e = map.pollLastEntry();
1136 dl 1.27 mustEqual(minusFive, e.getKey());
1137     mustEqual("E", e.getValue());
1138 dl 1.5 e = map.pollLastEntry();
1139 dl 1.27 mustEqual(minusThree, e.getKey());
1140     map.remove(minusTwo);
1141 dl 1.5 e = map.pollLastEntry();
1142 dl 1.27 mustEqual(minusOne, e.getKey());
1143 dl 1.5 try {
1144     e.setValue("E");
1145     shouldThrow();
1146 jsr166 1.11 } catch (UnsupportedOperationException success) {}
1147 dl 1.5 e = map.pollLastEntry();
1148     assertNull(e);
1149     }
1150    
1151     /**
1152 jsr166 1.16 * size returns the correct values
1153 dl 1.5 */
1154     public void testDescendingSize() {
1155 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1156     ConcurrentNavigableMap<Item,String> empty = dmap0();
1157     mustEqual(0, empty.size());
1158     mustEqual(5, map.size());
1159 dl 1.5 }
1160    
1161     /**
1162     * toString contains toString of elements
1163     */
1164     public void testDescendingToString() {
1165 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1166 dl 1.5 String s = map.toString();
1167     for (int i = 1; i <= 5; ++i) {
1168 jsr166 1.18 assertTrue(s.contains(String.valueOf(i)));
1169 dl 1.5 }
1170 jsr166 1.6 }
1171 dl 1.5
1172     // Exception testDescendings
1173    
1174     /**
1175 jsr166 1.14 * get(null) of empty map throws NPE
1176 dl 1.5 */
1177     public void testDescendingGet_NullPointerException() {
1178     try {
1179 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1180 dl 1.5 c.get(null);
1181     shouldThrow();
1182 jsr166 1.11 } catch (NullPointerException success) {}
1183 dl 1.5 }
1184    
1185     /**
1186 jsr166 1.14 * containsKey(null) of empty map throws NPE
1187 dl 1.5 */
1188     public void testDescendingContainsKey_NullPointerException() {
1189     try {
1190 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1191 dl 1.5 c.containsKey(null);
1192     shouldThrow();
1193 jsr166 1.11 } catch (NullPointerException success) {}
1194 dl 1.5 }
1195    
1196     /**
1197     * containsValue(null) throws NPE
1198     */
1199     public void testDescendingContainsValue_NullPointerException() {
1200     try {
1201 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap0();
1202 dl 1.5 c.containsValue(null);
1203     shouldThrow();
1204 jsr166 1.11 } catch (NullPointerException success) {}
1205 dl 1.5 }
1206    
1207     /**
1208     * put(null,x) throws NPE
1209     */
1210     public void testDescendingPut1_NullPointerException() {
1211     try {
1212 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1213 dl 1.5 c.put(null, "whatever");
1214     shouldThrow();
1215 jsr166 1.11 } catch (NullPointerException success) {}
1216 dl 1.5 }
1217    
1218     /**
1219     * putIfAbsent(null, x) throws NPE
1220     */
1221     public void testDescendingPutIfAbsent1_NullPointerException() {
1222     try {
1223 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1224 dl 1.5 c.putIfAbsent(null, "whatever");
1225     shouldThrow();
1226 jsr166 1.11 } catch (NullPointerException success) {}
1227 dl 1.5 }
1228    
1229     /**
1230     * replace(null, x) throws NPE
1231     */
1232     public void testDescendingReplace_NullPointerException() {
1233     try {
1234 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1235 dl 1.5 c.replace(null, "whatever");
1236     shouldThrow();
1237 jsr166 1.11 } catch (NullPointerException success) {}
1238 dl 1.5 }
1239    
1240     /**
1241     * replace(null, x, y) throws NPE
1242     */
1243     public void testDescendingReplaceValue_NullPointerException() {
1244     try {
1245 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1246     c.replace(null, "A", "B");
1247 dl 1.5 shouldThrow();
1248 jsr166 1.11 } catch (NullPointerException success) {}
1249 dl 1.5 }
1250    
1251     /**
1252     * remove(null) throws NPE
1253     */
1254     public void testDescendingRemove1_NullPointerException() {
1255     try {
1256 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1257 dl 1.5 c.remove(null);
1258     shouldThrow();
1259 jsr166 1.11 } catch (NullPointerException success) {}
1260 dl 1.5 }
1261    
1262     /**
1263     * remove(null, x) throws NPE
1264     */
1265     public void testDescendingRemove2_NullPointerException() {
1266     try {
1267 dl 1.27 ConcurrentNavigableMap<Item,String> c = dmap5();
1268 dl 1.5 c.remove(null, "whatever");
1269     shouldThrow();
1270 jsr166 1.11 } catch (NullPointerException success) {}
1271 dl 1.5 }
1272    
1273     /**
1274 jsr166 1.26 * A deserialized/reserialized map equals original
1275 dl 1.5 */
1276 jsr166 1.10 public void testDescendingSerialization() throws Exception {
1277 dl 1.27 NavigableMap<Item,String> x = dmap5();
1278     NavigableMap<Item,String> y = serialClone(x);
1279 dl 1.5
1280 jsr166 1.23 assertNotSame(x, y);
1281 dl 1.27 mustEqual(x.size(), y.size());
1282     mustEqual(x.toString(), y.toString());
1283     mustEqual(x, y);
1284     mustEqual(y, x);
1285 dl 1.5 }
1286    
1287     /**
1288     * subMap returns map with keys in requested range
1289     */
1290     public void testDescendingSubMapContents() {
1291 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1292     SortedMap<Item,String> sm = map.subMap(minusTwo, minusFour);
1293     mustEqual(minusTwo, sm.firstKey());
1294     mustEqual(minusThree, sm.lastKey());
1295     mustEqual(2, sm.size());
1296     assertFalse(sm.containsKey(minusOne));
1297     assertTrue(sm.containsKey(minusTwo));
1298     assertTrue(sm.containsKey(minusThree));
1299     assertFalse(sm.containsKey(minusFour));
1300     assertFalse(sm.containsKey(minusFive));
1301     Iterator<? extends Item> i = sm.keySet().iterator();
1302     Item k;
1303     k = (Item)(i.next());
1304     mustEqual(minusTwo, k);
1305     k = (Item)(i.next());
1306     mustEqual(minusThree, k);
1307 dl 1.5 assertFalse(i.hasNext());
1308 dl 1.27 Iterator<? extends Item> j = sm.keySet().iterator();
1309 dl 1.5 j.next();
1310     j.remove();
1311 dl 1.27 assertFalse(map.containsKey(minusTwo));
1312     mustEqual(4, map.size());
1313     mustEqual(1, sm.size());
1314     mustEqual(minusThree, sm.firstKey());
1315     mustEqual(minusThree, sm.lastKey());
1316     mustEqual("C", sm.remove(minusThree));
1317 dl 1.5 assertTrue(sm.isEmpty());
1318 dl 1.27 mustEqual(3, map.size());
1319 dl 1.5 }
1320    
1321     public void testDescendingSubMapContents2() {
1322 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1323     SortedMap<Item,String> sm = map.subMap(minusTwo, minusThree);
1324     mustEqual(1, sm.size());
1325     mustEqual(minusTwo, sm.firstKey());
1326     mustEqual(minusTwo, sm.lastKey());
1327     assertFalse(sm.containsKey(minusOne));
1328     assertTrue(sm.containsKey(minusTwo));
1329     assertFalse(sm.containsKey(minusThree));
1330     assertFalse(sm.containsKey(minusFour));
1331     assertFalse(sm.containsKey(minusFive));
1332     Iterator<? extends Item> i = sm.keySet().iterator();
1333     Item k;
1334     k = (Item)(i.next());
1335     mustEqual(minusTwo, k);
1336 dl 1.5 assertFalse(i.hasNext());
1337 dl 1.27 Iterator<? extends Item> j = sm.keySet().iterator();
1338 dl 1.5 j.next();
1339     j.remove();
1340 dl 1.27 assertFalse(map.containsKey(minusTwo));
1341     mustEqual(4, map.size());
1342     mustEqual(0, sm.size());
1343 dl 1.5 assertTrue(sm.isEmpty());
1344 dl 1.27 assertSame(sm.remove(minusThree), null);
1345     mustEqual(4, map.size());
1346 dl 1.5 }
1347    
1348     /**
1349     * headMap returns map with keys in requested range
1350     */
1351     public void testDescendingHeadMapContents() {
1352 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1353     SortedMap<Item,String> sm = map.headMap(minusFour);
1354     assertTrue(sm.containsKey(minusOne));
1355     assertTrue(sm.containsKey(minusTwo));
1356     assertTrue(sm.containsKey(minusThree));
1357     assertFalse(sm.containsKey(minusFour));
1358     assertFalse(sm.containsKey(minusFive));
1359     Iterator<? extends Item> i = sm.keySet().iterator();
1360     Item k;
1361     k = (Item)(i.next());
1362     mustEqual(minusOne, k);
1363     k = (Item)(i.next());
1364     mustEqual(minusTwo, k);
1365     k = (Item)(i.next());
1366     mustEqual(minusThree, k);
1367 dl 1.5 assertFalse(i.hasNext());
1368     sm.clear();
1369     assertTrue(sm.isEmpty());
1370 dl 1.27 mustEqual(2, map.size());
1371     mustEqual(minusFour, map.firstKey());
1372 dl 1.5 }
1373    
1374     /**
1375     * headMap returns map with keys in requested range
1376     */
1377     public void testDescendingTailMapContents() {
1378 dl 1.27 ConcurrentNavigableMap<Item,String> map = dmap5();
1379     SortedMap<Item,String> sm = map.tailMap(minusTwo);
1380     assertFalse(sm.containsKey(minusOne));
1381     assertTrue(sm.containsKey(minusTwo));
1382     assertTrue(sm.containsKey(minusThree));
1383     assertTrue(sm.containsKey(minusFour));
1384     assertTrue(sm.containsKey(minusFive));
1385     Iterator<? extends Item> i = sm.keySet().iterator();
1386     Item k = i.next();
1387     mustEqual(minusTwo, k);
1388     k = (i.next());
1389     mustEqual(minusThree, k);
1390     k = (i.next());
1391     mustEqual(minusFour, k);
1392     k = (i.next());
1393     mustEqual(minusFive, k);
1394 dl 1.5 assertFalse(i.hasNext());
1395    
1396 dl 1.27 Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
1397     Map.Entry<Item,String> e;
1398     e = (ei.next());
1399     mustEqual(minusTwo, e.getKey());
1400     mustEqual("B", e.getValue());
1401     e = (ei.next());
1402     mustEqual(minusThree, e.getKey());
1403     mustEqual("C", e.getValue());
1404     e = (ei.next());
1405     mustEqual(minusFour, e.getKey());
1406     mustEqual("D", e.getValue());
1407     e = (ei.next());
1408     mustEqual(minusFive, e.getKey());
1409     mustEqual("E", e.getValue());
1410 dl 1.5 assertFalse(i.hasNext());
1411    
1412 dl 1.27 SortedMap<Item,String> ssm = sm.tailMap(minusFour);
1413     mustEqual(minusFour, ssm.firstKey());
1414     mustEqual(minusFive, ssm.lastKey());
1415     mustEqual("D", ssm.remove(minusFour));
1416     mustEqual(1, ssm.size());
1417     mustEqual(3, sm.size());
1418     mustEqual(4, map.size());
1419 dl 1.5 }
1420 jsr166 1.6
1421 dl 1.1 }