ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TreeSubMapTest.java
Revision: 1.26
Committed: Wed Jan 27 01:57:25 2021 UTC (3 years, 3 months ago) by jsr166
Branch: MAIN
CVS Tags: HEAD
Changes since 1.25: +5 -5 lines
Log Message: 
use diamond <> pervasively

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.14 * http://creativecommons.org/publicdomain/zero/1.0/
5 dl 1.1 */
6    
7 jsr166 1.21 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     import java.util.TreeMap;
16    
17     import junit.framework.Test;
18     import junit.framework.TestSuite;
19 dl 1.1
20     public class TreeSubMapTest extends JSR166TestCase {
21     public static void main(String[] args) {
22 jsr166 1.23 main(suite(), args);
23 dl 1.1 }
24     public static Test suite() {
25 jsr166 1.7 return new TestSuite(TreeSubMapTest.class);
26 dl 1.1 }
27    
28     /**
29 dl 1.25 * Returns a new map from Items 1-5 to Strings "A"-"E".
30 dl 1.1 */
31 dl 1.25 private static NavigableMap<Item,String> map5() {
32 jsr166 1.26 TreeMap<Item,String> map = new TreeMap<>();
33 dl 1.1 assertTrue(map.isEmpty());
34 jsr166 1.7 map.put(zero, "Z");
35     map.put(one, "A");
36     map.put(five, "E");
37     map.put(three, "C");
38     map.put(two, "B");
39     map.put(four, "D");
40     map.put(seven, "F");
41 dl 1.1 assertFalse(map.isEmpty());
42 dl 1.25 mustEqual(7, map.size());
43 dl 1.3 return map.subMap(one, true, seven, false);
44 dl 1.1 }
45    
46 dl 1.25 private static NavigableMap<Item,String> map0() {
47 jsr166 1.26 TreeMap<Item,String> map = new TreeMap<>();
48 dl 1.1 assertTrue(map.isEmpty());
49 dl 1.3 return map.tailMap(one, true);
50     }
51    
52     /**
53 dl 1.25 * Returns a new map from Items -5 to -1 to Strings "A"-"E".
54 dl 1.3 */
55 dl 1.25 private static NavigableMap<Item,String> dmap5() {
56 jsr166 1.26 TreeMap<Item,String> map = new TreeMap<>();
57 dl 1.3 assertTrue(map.isEmpty());
58 dl 1.25 map.put(minusOne, "A");
59     map.put(minusFive, "E");
60     map.put(minusThree, "C");
61     map.put(minusTwo, "B");
62     map.put(minusFour, "D");
63 dl 1.3 assertFalse(map.isEmpty());
64 dl 1.25 mustEqual(5, map.size());
65 jsr166 1.7 return map.descendingMap();
66 dl 1.3 }
67    
68 dl 1.25 private static NavigableMap<Item,String> dmap0() {
69 jsr166 1.26 TreeMap<Item,String> map = new TreeMap<>();
70 dl 1.3 assertTrue(map.isEmpty());
71     return map;
72 dl 1.1 }
73    
74     /**
75 jsr166 1.13 * clear removes all pairs
76 dl 1.1 */
77     public void testClear() {
78 dl 1.25 NavigableMap<Item,String> map = map5();
79 jsr166 1.7 map.clear();
80 dl 1.25 mustEqual(0, map.size());
81 dl 1.1 }
82    
83     /**
84 jsr166 1.13 * Maps with same contents are equal
85 dl 1.1 */
86     public void testEquals() {
87 dl 1.25 NavigableMap<Item,String> map1 = map5();
88     NavigableMap<Item,String> map2 = map5();
89     mustEqual(map1, map2);
90     mustEqual(map2, map1);
91 jsr166 1.7 map1.clear();
92 dl 1.1 assertFalse(map1.equals(map2));
93     assertFalse(map2.equals(map1));
94     }
95    
96     /**
97 jsr166 1.13 * containsKey returns true for contained key
98 dl 1.1 */
99     public void testContainsKey() {
100 dl 1.25 NavigableMap<Item,String> map = map5();
101 jsr166 1.7 assertTrue(map.containsKey(one));
102 dl 1.1 assertFalse(map.containsKey(zero));
103     }
104    
105     /**
106 jsr166 1.13 * containsValue returns true for held values
107 dl 1.1 */
108     public void testContainsValue() {
109 dl 1.25 NavigableMap<Item,String> map = map5();
110 jsr166 1.7 assertTrue(map.containsValue("A"));
111 dl 1.1 assertFalse(map.containsValue("Z"));
112     }
113    
114     /**
115 jsr166 1.13 * get returns the correct element at the given key,
116     * or null if not present
117 dl 1.1 */
118     public void testGet() {
119 dl 1.25 NavigableMap<Item,String> map = map5();
120     mustEqual("A", map.get(one));
121     NavigableMap<Item,String> empty = map0();
122 dl 1.1 assertNull(empty.get(one));
123     }
124    
125     /**
126 jsr166 1.13 * isEmpty is true of empty map and false for non-empty
127 dl 1.1 */
128     public void testIsEmpty() {
129 dl 1.25 NavigableMap<Item,String> empty = map0();
130     NavigableMap<Item,String> map = map5();
131 jsr166 1.7 assertTrue(empty.isEmpty());
132 dl 1.1 assertFalse(map.isEmpty());
133     }
134    
135     /**
136 jsr166 1.13 * firstKey returns first key
137 dl 1.1 */
138     public void testFirstKey() {
139 dl 1.25 NavigableMap<Item,String> map = map5();
140     mustEqual(one, map.firstKey());
141 dl 1.1 }
142    
143     /**
144 jsr166 1.13 * lastKey returns last key
145 dl 1.1 */
146     public void testLastKey() {
147 dl 1.25 NavigableMap<Item,String> map = map5();
148     mustEqual(five, map.lastKey());
149 dl 1.1 }
150    
151     /**
152 jsr166 1.13 * keySet returns a Set containing all the keys
153 dl 1.1 */
154     public void testKeySet() {
155 dl 1.25 NavigableMap<Item,String> map = map5();
156     Set<Item> s = map.keySet();
157     mustEqual(5, s.size());
158     mustContain(s, one);
159     mustContain(s, two);
160     mustContain(s, three);
161     mustContain(s, four);
162     mustContain(s, five);
163 dl 1.1 }
164    
165     /**
166 jsr166 1.13 * keySet is ordered
167 dl 1.1 */
168     public void testKeySetOrder() {
169 dl 1.25 NavigableMap<Item,String> map = map5();
170     Set<Item> s = map.keySet();
171     Iterator<? extends Item> i = s.iterator();
172     Item last = i.next();
173     mustEqual(last, one);
174 dl 1.1 while (i.hasNext()) {
175 dl 1.25 Item k = i.next();
176 dl 1.1 assertTrue(last.compareTo(k) < 0);
177     last = k;
178     }
179     }
180    
181     /**
182     * values collection contains all values
183     */
184     public void testValues() {
185 dl 1.25 NavigableMap<Item,String> map = map5();
186     Collection<String> s = map.values();
187     mustEqual(5, s.size());
188 jsr166 1.7 assertTrue(s.contains("A"));
189     assertTrue(s.contains("B"));
190     assertTrue(s.contains("C"));
191     assertTrue(s.contains("D"));
192     assertTrue(s.contains("E"));
193 dl 1.1 }
194    
195     /**
196     * entrySet contains all pairs
197     */
198     public void testEntrySet() {
199 dl 1.25 NavigableMap<Item,String> map = map5();
200     Set<Map.Entry<Item,String>> s = map.entrySet();
201     mustEqual(5, s.size());
202     Iterator<? extends Map.Entry<Item,String>> it = s.iterator();
203 dl 1.1 while (it.hasNext()) {
204 dl 1.25 Map.Entry<Item,String> e = it.next();
205 jsr166 1.4 assertTrue(
206 dl 1.1 (e.getKey().equals(one) && e.getValue().equals("A")) ||
207     (e.getKey().equals(two) && e.getValue().equals("B")) ||
208     (e.getKey().equals(three) && e.getValue().equals("C")) ||
209     (e.getKey().equals(four) && e.getValue().equals("D")) ||
210     (e.getKey().equals(five) && e.getValue().equals("E")));
211     }
212     }
213    
214     /**
215 jsr166 1.13 * putAll adds all key-value pairs from the given map
216 dl 1.1 */
217     public void testPutAll() {
218 dl 1.25 NavigableMap<Item,String> empty = map0();
219     NavigableMap<Item,String> map = map5();
220 jsr166 1.7 empty.putAll(map);
221 dl 1.25 mustEqual(5, empty.size());
222 jsr166 1.7 assertTrue(empty.containsKey(one));
223     assertTrue(empty.containsKey(two));
224     assertTrue(empty.containsKey(three));
225     assertTrue(empty.containsKey(four));
226     assertTrue(empty.containsKey(five));
227 dl 1.1 }
228    
229     /**
230 jsr166 1.13 * remove removes the correct key-value pair from the map
231 dl 1.1 */
232     public void testRemove() {
233 dl 1.25 NavigableMap<Item,String> map = map5();
234 jsr166 1.7 map.remove(five);
235 dl 1.25 mustEqual(4, map.size());
236 jsr166 1.7 assertFalse(map.containsKey(five));
237 dl 1.1 }
238    
239     /**
240     * lowerEntry returns preceding entry.
241     */
242     public void testLowerEntry() {
243 dl 1.25 NavigableMap<Item,String> map = map5();
244     Map.Entry<Item,String> e1 = map.lowerEntry(three);
245     mustEqual(two, e1.getKey());
246 dl 1.1
247 dl 1.25 Map.Entry<Item,String> e2 = map.lowerEntry(six);
248     mustEqual(five, e2.getKey());
249 dl 1.1
250 dl 1.25 Map.Entry<Item,String> e3 = map.lowerEntry(one);
251 dl 1.1 assertNull(e3);
252    
253 dl 1.25 Map.Entry<Item,String> e4 = map.lowerEntry(zero);
254 dl 1.1 assertNull(e4);
255     }
256    
257     /**
258     * higherEntry returns next entry.
259     */
260     public void testHigherEntry() {
261 dl 1.25 NavigableMap<Item,String> map = map5();
262     Map.Entry<Item,String> e1 = map.higherEntry(three);
263     mustEqual(four, e1.getKey());
264 dl 1.1
265 dl 1.25 Map.Entry<Item,String> e2 = map.higherEntry(zero);
266     mustEqual(one, e2.getKey());
267 dl 1.1
268 dl 1.25 Map.Entry<Item,String> e3 = map.higherEntry(five);
269 dl 1.1 assertNull(e3);
270    
271 dl 1.25 Map.Entry<Item,String> e4 = map.higherEntry(six);
272 dl 1.1 assertNull(e4);
273     }
274    
275     /**
276     * floorEntry returns preceding entry.
277     */
278     public void testFloorEntry() {
279 dl 1.25 NavigableMap<Item,String> map = map5();
280     Map.Entry<Item,String> e1 = map.floorEntry(three);
281     mustEqual(three, e1.getKey());
282 dl 1.1
283 dl 1.25 Map.Entry<Item,String> e2 = map.floorEntry(six);
284     mustEqual(five, e2.getKey());
285 dl 1.1
286 dl 1.25 Map.Entry<Item,String> e3 = map.floorEntry(one);
287     mustEqual(one, e3.getKey());
288 dl 1.1
289 dl 1.25 Map.Entry<Item,String> e4 = map.floorEntry(zero);
290 dl 1.1 assertNull(e4);
291     }
292    
293     /**
294     * ceilingEntry returns next entry.
295     */
296     public void testCeilingEntry() {
297 dl 1.25 NavigableMap<Item,String> map = map5();
298     Map.Entry<Item,String> e1 = map.ceilingEntry(three);
299     mustEqual(three, e1.getKey());
300 dl 1.1
301 dl 1.25 Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
302     mustEqual(one, e2.getKey());
303 dl 1.1
304 dl 1.25 Map.Entry<Item,String> e3 = map.ceilingEntry(five);
305     mustEqual(five, e3.getKey());
306 dl 1.1
307 dl 1.25 Map.Entry<Item,String> e4 = map.ceilingEntry(six);
308 dl 1.1 assertNull(e4);
309     }
310    
311     /**
312     * pollFirstEntry returns entries in order
313     */
314     public void testPollFirstEntry() {
315 dl 1.25 NavigableMap<Item,String> map = map5();
316     Map.Entry<Item,String> e = map.pollFirstEntry();
317     mustEqual(one, e.getKey());
318     mustEqual("A", e.getValue());
319 dl 1.1 e = map.pollFirstEntry();
320 dl 1.25 mustEqual(two, e.getKey());
321 dl 1.1 map.put(one, "A");
322     e = map.pollFirstEntry();
323 dl 1.25 mustEqual(one, e.getKey());
324     mustEqual("A", e.getValue());
325 dl 1.1 e = map.pollFirstEntry();
326 dl 1.25 mustEqual(three, e.getKey());
327 dl 1.1 map.remove(four);
328     e = map.pollFirstEntry();
329 dl 1.25 mustEqual(five, e.getKey());
330 dl 1.1 try {
331     e.setValue("A");
332     shouldThrow();
333 jsr166 1.9 } catch (UnsupportedOperationException success) {}
334 dl 1.1 assertTrue(map.isEmpty());
335 dl 1.25 Map.Entry<Item,String> f = map.firstEntry();
336 dl 1.1 assertNull(f);
337     e = map.pollFirstEntry();
338     assertNull(e);
339     }
340    
341     /**
342     * pollLastEntry returns entries in order
343     */
344     public void testPollLastEntry() {
345 dl 1.25 NavigableMap<Item,String> map = map5();
346     Map.Entry<Item,String> e = map.pollLastEntry();
347     mustEqual(five, e.getKey());
348     mustEqual("E", e.getValue());
349 dl 1.1 e = map.pollLastEntry();
350 dl 1.25 mustEqual(four, e.getKey());
351 dl 1.1 map.put(five, "E");
352     e = map.pollLastEntry();
353 dl 1.25 mustEqual(five, e.getKey());
354     mustEqual("E", e.getValue());
355 dl 1.1 e = map.pollLastEntry();
356 dl 1.25 mustEqual(three, e.getKey());
357 dl 1.1 map.remove(two);
358     e = map.pollLastEntry();
359 dl 1.25 mustEqual(one, e.getKey());
360 dl 1.1 try {
361     e.setValue("E");
362     shouldThrow();
363 jsr166 1.9 } catch (UnsupportedOperationException success) {}
364 dl 1.1 e = map.pollLastEntry();
365     assertNull(e);
366     }
367    
368     /**
369 jsr166 1.13 * size returns the correct values
370 dl 1.1 */
371     public void testSize() {
372 dl 1.25 NavigableMap<Item,String> map = map5();
373     NavigableMap<Item,String> empty = map0();
374     mustEqual(0, empty.size());
375     mustEqual(5, map.size());
376 dl 1.1 }
377    
378     /**
379     * toString contains toString of elements
380     */
381     public void testToString() {
382 dl 1.25 NavigableMap<Item,String> map = map5();
383 dl 1.1 String s = map.toString();
384     for (int i = 1; i <= 5; ++i) {
385 jsr166 1.15 assertTrue(s.contains(String.valueOf(i)));
386 dl 1.1 }
387 jsr166 1.4 }
388 dl 1.1
389     // Exception tests
390    
391     /**
392     * get(null) of nonempty map throws NPE
393     */
394     public void testGet_NullPointerException() {
395 dl 1.25 NavigableMap<Item,String> c = map5();
396 dl 1.1 try {
397     c.get(null);
398     shouldThrow();
399 jsr166 1.9 } catch (NullPointerException success) {}
400 dl 1.1 }
401    
402     /**
403     * containsKey(null) of nonempty map throws NPE
404     */
405     public void testContainsKey_NullPointerException() {
406 dl 1.25 NavigableMap<Item,String> c = map5();
407 dl 1.1 try {
408     c.containsKey(null);
409     shouldThrow();
410 jsr166 1.9 } catch (NullPointerException success) {}
411 dl 1.1 }
412    
413     /**
414     * put(null,x) throws NPE
415     */
416     public void testPut1_NullPointerException() {
417 dl 1.25 NavigableMap<Item,String> c = map5();
418 dl 1.1 try {
419     c.put(null, "whatever");
420     shouldThrow();
421 jsr166 1.9 } catch (NullPointerException success) {}
422 dl 1.1 }
423    
424     /**
425     * remove(null) throws NPE
426     */
427     public void testRemove1_NullPointerException() {
428 dl 1.25 NavigableMap<Item,String> c = map5();
429 dl 1.1 try {
430     c.remove(null);
431     shouldThrow();
432 jsr166 1.9 } catch (NullPointerException success) {}
433 dl 1.1 }
434    
435     /**
436 jsr166 1.24 * A deserialized/reserialized map equals original
437 dl 1.1 */
438 jsr166 1.8 public void testSerialization() throws Exception {
439 dl 1.25 NavigableMap<Item,String> x = map5();
440     NavigableMap<Item,String> y = serialClone(x);
441 dl 1.1
442 jsr166 1.20 assertNotSame(x, y);
443 dl 1.25 mustEqual(x.size(), y.size());
444     mustEqual(x.toString(), y.toString());
445     mustEqual(x, y);
446     mustEqual(y, x);
447 dl 1.1 }
448    
449     /**
450     * subMap returns map with keys in requested range
451     */
452     public void testSubMapContents() {
453 dl 1.25 NavigableMap<Item,String> map = map5();
454     SortedMap<Item,String> sm = map.subMap(two, four);
455     mustEqual(two, sm.firstKey());
456     mustEqual(three, sm.lastKey());
457     mustEqual(2, sm.size());
458 dl 1.1 assertFalse(sm.containsKey(one));
459     assertTrue(sm.containsKey(two));
460     assertTrue(sm.containsKey(three));
461     assertFalse(sm.containsKey(four));
462     assertFalse(sm.containsKey(five));
463 dl 1.25 Iterator<? extends Item> i = sm.keySet().iterator();
464     Item k;
465     k = (Item)(i.next());
466     mustEqual(two, k);
467     k = (Item)(i.next());
468     mustEqual(three, k);
469 dl 1.1 assertFalse(i.hasNext());
470 dl 1.25 Iterator<? extends Item> j = sm.keySet().iterator();
471 dl 1.1 j.next();
472     j.remove();
473     assertFalse(map.containsKey(two));
474 dl 1.25 mustEqual(4, map.size());
475     mustEqual(1, sm.size());
476     mustEqual(three, sm.firstKey());
477     mustEqual(three, sm.lastKey());
478     mustEqual("C", sm.remove(three));
479 dl 1.1 assertTrue(sm.isEmpty());
480 dl 1.25 mustEqual(3, map.size());
481 dl 1.1 }
482    
483     public void testSubMapContents2() {
484 dl 1.25 NavigableMap<Item,String> map = map5();
485     SortedMap<Item,String> sm = map.subMap(two, three);
486     mustEqual(1, sm.size());
487     mustEqual(two, sm.firstKey());
488     mustEqual(two, sm.lastKey());
489 dl 1.1 assertFalse(sm.containsKey(one));
490     assertTrue(sm.containsKey(two));
491     assertFalse(sm.containsKey(three));
492     assertFalse(sm.containsKey(four));
493     assertFalse(sm.containsKey(five));
494 dl 1.25 Iterator<? extends Item> i = sm.keySet().iterator();
495 dl 1.1 Object k;
496 dl 1.25 k = (Item)(i.next());
497     mustEqual(two, k);
498 dl 1.1 assertFalse(i.hasNext());
499 dl 1.25 Iterator<? extends Item> j = sm.keySet().iterator();
500 dl 1.1 j.next();
501     j.remove();
502     assertFalse(map.containsKey(two));
503 dl 1.25 mustEqual(4, map.size());
504     mustEqual(0, sm.size());
505 dl 1.1 assertTrue(sm.isEmpty());
506 dl 1.25 assertNull(sm.remove(three));
507     mustEqual(4, map.size());
508 dl 1.1 }
509    
510     /**
511     * headMap returns map with keys in requested range
512     */
513     public void testHeadMapContents() {
514 dl 1.25 NavigableMap<Item,String> map = map5();
515     SortedMap<Item,String> sm = map.headMap(four);
516 dl 1.1 assertTrue(sm.containsKey(one));
517     assertTrue(sm.containsKey(two));
518     assertTrue(sm.containsKey(three));
519     assertFalse(sm.containsKey(four));
520     assertFalse(sm.containsKey(five));
521 dl 1.25 Iterator<? extends Item> i = sm.keySet().iterator();
522     Item k;
523     k = (Item)(i.next());
524     mustEqual(one, k);
525     k = (Item)(i.next());
526     mustEqual(two, k);
527     k = (Item)(i.next());
528     mustEqual(three, k);
529 dl 1.1 assertFalse(i.hasNext());
530     sm.clear();
531     assertTrue(sm.isEmpty());
532 dl 1.25 mustEqual(2, map.size());
533     mustEqual(four, map.firstKey());
534 dl 1.1 }
535    
536     /**
537     * headMap returns map with keys in requested range
538     */
539     public void testTailMapContents() {
540 dl 1.25 NavigableMap<Item,String> map = map5();
541     SortedMap<Item,String> sm = map.tailMap(two);
542 dl 1.1 assertFalse(sm.containsKey(one));
543     assertTrue(sm.containsKey(two));
544     assertTrue(sm.containsKey(three));
545     assertTrue(sm.containsKey(four));
546     assertTrue(sm.containsKey(five));
547 dl 1.25 Iterator<? extends Item> i = sm.keySet().iterator();
548 dl 1.1 Object k;
549 dl 1.25 k = (Item)(i.next());
550     mustEqual(two, k);
551     k = (Item)(i.next());
552     mustEqual(three, k);
553     k = (Item)(i.next());
554     mustEqual(four, k);
555     k = (Item)(i.next());
556     mustEqual(five, k);
557 dl 1.1 assertFalse(i.hasNext());
558    
559 dl 1.25 Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
560     Map.Entry<Item,String> e;
561     e = ei.next();
562     mustEqual(two, e.getKey());
563     mustEqual("B", e.getValue());
564     e = (ei.next());
565     mustEqual(three, e.getKey());
566     mustEqual("C", e.getValue());
567     e = (ei.next());
568     mustEqual(four, e.getKey());
569     mustEqual("D", e.getValue());
570     e = (ei.next());
571     mustEqual(five, e.getKey());
572     mustEqual("E", e.getValue());
573 dl 1.1 assertFalse(i.hasNext());
574    
575 dl 1.25 SortedMap<Item,String> ssm = sm.tailMap(four);
576     mustEqual(four, ssm.firstKey());
577     mustEqual(five, ssm.lastKey());
578     mustEqual("D", ssm.remove(four));
579     mustEqual(1, ssm.size());
580     mustEqual(3, sm.size());
581     mustEqual(4, map.size());
582 dl 1.1 }
583 dl 1.3
584     /**
585 jsr166 1.13 * clear removes all pairs
586 dl 1.3 */
587     public void testDescendingClear() {
588 dl 1.25 NavigableMap<Item,String> map = dmap5();
589 jsr166 1.7 map.clear();
590 dl 1.25 mustEqual(0, map.size());
591 dl 1.3 }
592    
593     /**
594 jsr166 1.13 * Maps with same contents are equal
595 dl 1.3 */
596     public void testDescendingEquals() {
597 dl 1.25 NavigableMap<Item,String> map1 = dmap5();
598     NavigableMap<Item,String> map2 = dmap5();
599     mustEqual(map1, map2);
600     mustEqual(map2, map1);
601 jsr166 1.7 map1.clear();
602 dl 1.3 assertFalse(map1.equals(map2));
603     assertFalse(map2.equals(map1));
604     }
605    
606     /**
607 jsr166 1.13 * containsKey returns true for contained key
608 dl 1.3 */
609     public void testDescendingContainsKey() {
610 dl 1.25 NavigableMap<Item,String> map = dmap5();
611     assertTrue(map.containsKey(minusOne));
612 dl 1.3 assertFalse(map.containsKey(zero));
613     }
614    
615     /**
616 jsr166 1.13 * containsValue returns true for held values
617 dl 1.3 */
618     public void testDescendingContainsValue() {
619 dl 1.25 NavigableMap<Item,String> map = dmap5();
620 jsr166 1.7 assertTrue(map.containsValue("A"));
621 dl 1.3 assertFalse(map.containsValue("Z"));
622     }
623    
624     /**
625 jsr166 1.13 * get returns the correct element at the given key,
626     * or null if not present
627 dl 1.3 */
628     public void testDescendingGet() {
629 dl 1.25 NavigableMap<Item,String> map = dmap5();
630     mustEqual("A", map.get(minusOne));
631     NavigableMap<Item,String> empty = dmap0();
632     assertNull(empty.get(minusOne));
633 dl 1.3 }
634    
635     /**
636 jsr166 1.13 * isEmpty is true of empty map and false for non-empty
637 dl 1.3 */
638     public void testDescendingIsEmpty() {
639 dl 1.25 NavigableMap<Item,String> empty = dmap0();
640     NavigableMap<Item,String> map = dmap5();
641 jsr166 1.7 assertTrue(empty.isEmpty());
642 dl 1.3 assertFalse(map.isEmpty());
643     }
644    
645     /**
646 jsr166 1.13 * firstKey returns first key
647 dl 1.3 */
648     public void testDescendingFirstKey() {
649 dl 1.25 NavigableMap<Item,String> map = dmap5();
650     mustEqual(minusOne, map.firstKey());
651 dl 1.3 }
652    
653     /**
654 jsr166 1.13 * lastKey returns last key
655 dl 1.3 */
656     public void testDescendingLastKey() {
657 dl 1.25 NavigableMap<Item,String> map = dmap5();
658     mustEqual(minusFive, map.lastKey());
659 dl 1.3 }
660    
661     /**
662 jsr166 1.13 * keySet returns a Set containing all the keys
663 dl 1.3 */
664     public void testDescendingKeySet() {
665 dl 1.25 NavigableMap<Item,String> map = dmap5();
666     Set<Item> s = map.keySet();
667     mustEqual(5, s.size());
668     mustContain(s, minusOne);
669     mustContain(s, minusTwo);
670     mustContain(s, minusThree);
671     mustContain(s, minusFour);
672     mustContain(s, minusFive);
673 dl 1.3 }
674    
675     /**
676 jsr166 1.13 * keySet is ordered
677 dl 1.3 */
678     public void testDescendingKeySetOrder() {
679 dl 1.25 NavigableMap<Item,String> map = dmap5();
680     Set<Item> s = map.keySet();
681     Iterator<? extends Item> i = s.iterator();
682     Item last = (Item)i.next();
683     mustEqual(last, minusOne);
684 dl 1.3 while (i.hasNext()) {
685 dl 1.25 Item k = (Item)i.next();
686 dl 1.3 assertTrue(last.compareTo(k) > 0);
687     last = k;
688     }
689     }
690    
691     /**
692     * values collection contains all values
693     */
694     public void testDescendingValues() {
695 dl 1.25 NavigableMap<Item,String> map = dmap5();
696     Collection<String> s = map.values();
697     mustEqual(5, s.size());
698 jsr166 1.7 assertTrue(s.contains("A"));
699     assertTrue(s.contains("B"));
700     assertTrue(s.contains("C"));
701     assertTrue(s.contains("D"));
702     assertTrue(s.contains("E"));
703 dl 1.3 }
704    
705     /**
706 jsr166 1.13 * keySet.toArray returns contains all keys
707 dl 1.3 */
708     public void testDescendingAscendingKeySetToArray() {
709 dl 1.25 NavigableMap<Item,String> map = dmap5();
710     Set<Item> s = map.keySet();
711     Item[] ar = s.toArray(new Item[0]);
712 dl 1.3 assertTrue(s.containsAll(Arrays.asList(ar)));
713 dl 1.25 mustEqual(5, ar.length);
714     ar[0] = minusTen;
715 dl 1.3 assertFalse(s.containsAll(Arrays.asList(ar)));
716     }
717    
718     /**
719 jsr166 1.13 * descendingkeySet.toArray returns contains all keys
720 dl 1.3 */
721     public void testDescendingDescendingKeySetToArray() {
722 dl 1.25 NavigableMap<Item,String> map = dmap5();
723     Set<Item> s = map.descendingKeySet();
724     Item[] ar = s.toArray(new Item[0]);
725     mustEqual(5, ar.length);
726 dl 1.3 assertTrue(s.containsAll(Arrays.asList(ar)));
727 dl 1.25 ar[0] = minusTen;
728 dl 1.3 assertFalse(s.containsAll(Arrays.asList(ar)));
729     }
730    
731     /**
732 jsr166 1.13 * Values.toArray contains all values
733 dl 1.3 */
734     public void testDescendingValuesToArray() {
735 dl 1.25 NavigableMap<Item,String> map = dmap5();
736     Collection<String> v = map.values();
737     String[] ar = v.toArray(new String[0]);
738 jsr166 1.26 ArrayList<String> s = new ArrayList<>(Arrays.asList(ar));
739 dl 1.25 mustEqual(5, ar.length);
740 jsr166 1.7 assertTrue(s.contains("A"));
741     assertTrue(s.contains("B"));
742     assertTrue(s.contains("C"));
743     assertTrue(s.contains("D"));
744     assertTrue(s.contains("E"));
745 dl 1.3 }
746    
747     /**
748     * entrySet contains all pairs
749     */
750     public void testDescendingEntrySet() {
751 dl 1.25 NavigableMap<Item,String> map = dmap5();
752     Set<Map.Entry<Item,String>> s = map.entrySet();
753     mustEqual(5, s.size());
754     Iterator<Map.Entry<Item,String>> it = s.iterator();
755 dl 1.3 while (it.hasNext()) {
756 dl 1.25 Map.Entry<Item,String> e = it.next();
757 jsr166 1.4 assertTrue(
758 dl 1.25 (e.getKey().equals(minusOne) && e.getValue().equals("A")) ||
759     (e.getKey().equals(minusTwo) && e.getValue().equals("B")) ||
760     (e.getKey().equals(minusThree) && e.getValue().equals("C")) ||
761     (e.getKey().equals(minusFour) && e.getValue().equals("D")) ||
762     (e.getKey().equals(minusFive) && e.getValue().equals("E")));
763 dl 1.3 }
764     }
765    
766     /**
767 jsr166 1.13 * putAll adds all key-value pairs from the given map
768 dl 1.3 */
769     public void testDescendingPutAll() {
770 dl 1.25 NavigableMap<Item,String> empty = dmap0();
771     NavigableMap<Item,String> map = dmap5();
772 jsr166 1.7 empty.putAll(map);
773 dl 1.25 mustEqual(5, empty.size());
774     assertTrue(empty.containsKey(minusOne));
775     assertTrue(empty.containsKey(minusTwo));
776     assertTrue(empty.containsKey(minusThree));
777     assertTrue(empty.containsKey(minusFour));
778     assertTrue(empty.containsKey(minusFive));
779 dl 1.3 }
780    
781     /**
782 jsr166 1.13 * remove removes the correct key-value pair from the map
783 dl 1.3 */
784     public void testDescendingRemove() {
785 dl 1.25 NavigableMap<Item,String> map = dmap5();
786     map.remove(minusFive);
787     mustEqual(4, map.size());
788     assertFalse(map.containsKey(minusFive));
789 dl 1.3 }
790    
791     /**
792     * lowerEntry returns preceding entry.
793     */
794     public void testDescendingLowerEntry() {
795 dl 1.25 NavigableMap<Item,String> map = dmap5();
796     Map.Entry<Item,String> e1 = map.lowerEntry(minusThree);
797     mustEqual(minusTwo, e1.getKey());
798 dl 1.3
799 dl 1.25 Map.Entry<Item,String> e2 = map.lowerEntry(minusSix);
800     mustEqual(minusFive, e2.getKey());
801 dl 1.3
802 dl 1.25 Map.Entry<Item,String> e3 = map.lowerEntry(minusOne);
803 dl 1.3 assertNull(e3);
804    
805 dl 1.25 Map.Entry<Item,String> e4 = map.lowerEntry(zero);
806 dl 1.3 assertNull(e4);
807     }
808    
809     /**
810     * higherEntry returns next entry.
811     */
812     public void testDescendingHigherEntry() {
813 dl 1.25 NavigableMap<Item,String> map = dmap5();
814     Map.Entry<Item,String> e1 = map.higherEntry(minusThree);
815     mustEqual(minusFour, e1.getKey());
816 dl 1.3
817 dl 1.25 Map.Entry<Item,String> e2 = map.higherEntry(zero);
818     mustEqual(minusOne, e2.getKey());
819 dl 1.3
820 dl 1.25 Map.Entry<Item,String> e3 = map.higherEntry(minusFive);
821 dl 1.3 assertNull(e3);
822    
823 dl 1.25 Map.Entry<Item,String> e4 = map.higherEntry(minusSix);
824 dl 1.3 assertNull(e4);
825     }
826    
827     /**
828     * floorEntry returns preceding entry.
829     */
830     public void testDescendingFloorEntry() {
831 dl 1.25 NavigableMap<Item,String> map = dmap5();
832     Map.Entry<Item,String> e1 = map.floorEntry(minusThree);
833     mustEqual(minusThree, e1.getKey());
834 dl 1.3
835 dl 1.25 Map.Entry<Item,String> e2 = map.floorEntry(minusSix);
836     mustEqual(minusFive, e2.getKey());
837 dl 1.3
838 dl 1.25 Map.Entry<Item,String> e3 = map.floorEntry(minusOne);
839     mustEqual(minusOne, e3.getKey());
840 dl 1.3
841 dl 1.25 Map.Entry<Item,String> e4 = map.floorEntry(zero);
842 dl 1.3 assertNull(e4);
843     }
844    
845     /**
846     * ceilingEntry returns next entry.
847     */
848     public void testDescendingCeilingEntry() {
849 dl 1.25 NavigableMap<Item,String> map = dmap5();
850     Map.Entry<Item,String> e1 = map.ceilingEntry(minusThree);
851     mustEqual(minusThree, e1.getKey());
852 dl 1.3
853 dl 1.25 Map.Entry<Item,String> e2 = map.ceilingEntry(zero);
854     mustEqual(minusOne, e2.getKey());
855 dl 1.3
856 dl 1.25 Map.Entry<Item,String> e3 = map.ceilingEntry(minusFive);
857     mustEqual(minusFive, e3.getKey());
858 dl 1.3
859 dl 1.25 Map.Entry<Item,String> e4 = map.ceilingEntry(minusSix);
860 dl 1.3 assertNull(e4);
861     }
862    
863     /**
864     * pollFirstEntry returns entries in order
865     */
866     public void testDescendingPollFirstEntry() {
867 dl 1.25 NavigableMap<Item,String> map = dmap5();
868     Map.Entry<Item,String> e = map.pollFirstEntry();
869     mustEqual(minusOne, e.getKey());
870     mustEqual("A", e.getValue());
871 dl 1.3 e = map.pollFirstEntry();
872 dl 1.25 mustEqual(minusTwo, e.getKey());
873     map.put(minusOne, "A");
874 dl 1.3 e = map.pollFirstEntry();
875 dl 1.25 mustEqual(minusOne, e.getKey());
876     mustEqual("A", e.getValue());
877 dl 1.3 e = map.pollFirstEntry();
878 dl 1.25 mustEqual(minusThree, e.getKey());
879     map.remove(minusFour);
880 dl 1.3 e = map.pollFirstEntry();
881 dl 1.25 mustEqual(minusFive, e.getKey());
882 dl 1.3 try {
883     e.setValue("A");
884     shouldThrow();
885 jsr166 1.9 } catch (UnsupportedOperationException success) {}
886 dl 1.3 e = map.pollFirstEntry();
887     assertNull(e);
888     }
889    
890     /**
891     * pollLastEntry returns entries in order
892     */
893     public void testDescendingPollLastEntry() {
894 dl 1.25 NavigableMap<Item,String> map = dmap5();
895     Map.Entry<Item,String> e = map.pollLastEntry();
896     mustEqual(minusFive, e.getKey());
897     mustEqual("E", e.getValue());
898 dl 1.3 e = map.pollLastEntry();
899 dl 1.25 mustEqual(minusFour, e.getKey());
900     map.put(minusFive, "E");
901 dl 1.3 e = map.pollLastEntry();
902 dl 1.25 mustEqual(minusFive, e.getKey());
903     mustEqual("E", e.getValue());
904 dl 1.3 e = map.pollLastEntry();
905 dl 1.25 mustEqual(minusThree, e.getKey());
906     map.remove(minusTwo);
907 dl 1.3 e = map.pollLastEntry();
908 dl 1.25 mustEqual(minusOne, e.getKey());
909 dl 1.3 try {
910     e.setValue("E");
911     shouldThrow();
912 jsr166 1.9 } catch (UnsupportedOperationException success) {}
913 dl 1.3 e = map.pollLastEntry();
914     assertNull(e);
915     }
916    
917     /**
918 jsr166 1.13 * size returns the correct values
919 dl 1.3 */
920     public void testDescendingSize() {
921 dl 1.25 NavigableMap<Item,String> map = dmap5();
922     NavigableMap<Item,String> empty = dmap0();
923     mustEqual(0, empty.size());
924     mustEqual(5, map.size());
925 dl 1.3 }
926    
927     /**
928     * toString contains toString of elements
929     */
930     public void testDescendingToString() {
931 dl 1.25 NavigableMap<Item,String> map = dmap5();
932 dl 1.3 String s = map.toString();
933     for (int i = 1; i <= 5; ++i) {
934 jsr166 1.15 assertTrue(s.contains(String.valueOf(i)));
935 dl 1.3 }
936 jsr166 1.4 }
937 dl 1.3
938     // Exception testDescendings
939    
940     /**
941     * get(null) of nonempty map throws NPE
942     */
943     public void testDescendingGet_NullPointerException() {
944 dl 1.25 NavigableMap<Item,String> c = dmap5();
945 dl 1.3 try {
946     c.get(null);
947     shouldThrow();
948 jsr166 1.9 } catch (NullPointerException success) {}
949 dl 1.3 }
950    
951     /**
952     * put(null,x) throws NPE
953     */
954     public void testDescendingPut1_NullPointerException() {
955 dl 1.25 NavigableMap<Item,String> c = dmap5();
956 dl 1.3 try {
957     c.put(null, "whatever");
958     shouldThrow();
959 jsr166 1.9 } catch (NullPointerException success) {}
960 dl 1.3 }
961    
962     /**
963 jsr166 1.24 * A deserialized/reserialized map equals original
964 dl 1.3 */
965 jsr166 1.8 public void testDescendingSerialization() throws Exception {
966 dl 1.25 NavigableMap<Item,String> x = dmap5();
967     NavigableMap<Item,String> y = serialClone(x);
968 jsr166 1.4
969 jsr166 1.20 assertNotSame(x, y);
970 dl 1.25 mustEqual(x.size(), y.size());
971     mustEqual(x.toString(), y.toString());
972     mustEqual(x, y);
973     mustEqual(y, x);
974 dl 1.3 }
975    
976     /**
977     * subMap returns map with keys in requested range
978     */
979     public void testDescendingSubMapContents() {
980 dl 1.25 NavigableMap<Item,String> map = dmap5();
981     SortedMap<Item,String> sm = map.subMap(minusTwo, minusFour);
982     mustEqual(minusTwo, sm.firstKey());
983     mustEqual(minusThree, sm.lastKey());
984     mustEqual(2, sm.size());
985     assertFalse(sm.containsKey(minusOne));
986     assertTrue(sm.containsKey(minusTwo));
987     assertTrue(sm.containsKey(minusThree));
988     assertFalse(sm.containsKey(minusFour));
989     assertFalse(sm.containsKey(minusFive));
990     Iterator<? extends Item> i = sm.keySet().iterator();
991     Item k;
992     k = (Item)(i.next());
993     mustEqual(minusTwo, k);
994     k = (Item)(i.next());
995     mustEqual(minusThree, k);
996 dl 1.3 assertFalse(i.hasNext());
997 dl 1.25 Iterator<? extends Item> j = sm.keySet().iterator();
998 dl 1.3 j.next();
999     j.remove();
1000 dl 1.25 assertFalse(map.containsKey(minusTwo));
1001     mustEqual(4, map.size());
1002     mustEqual(1, sm.size());
1003     mustEqual(minusThree, sm.firstKey());
1004     mustEqual(minusThree, sm.lastKey());
1005     mustEqual("C", sm.remove(minusThree));
1006 dl 1.3 assertTrue(sm.isEmpty());
1007 dl 1.25 mustEqual(3, map.size());
1008 dl 1.3 }
1009    
1010     public void testDescendingSubMapContents2() {
1011 dl 1.25 NavigableMap<Item,String> map = dmap5();
1012     SortedMap<Item,String> sm = map.subMap(minusTwo, minusThree);
1013     mustEqual(1, sm.size());
1014     mustEqual(minusTwo, sm.firstKey());
1015     mustEqual(minusTwo, sm.lastKey());
1016     assertFalse(sm.containsKey(minusOne));
1017     assertTrue(sm.containsKey(minusTwo));
1018     assertFalse(sm.containsKey(minusThree));
1019     assertFalse(sm.containsKey(minusFour));
1020     assertFalse(sm.containsKey(minusFive));
1021     Iterator<? extends Item> i = sm.keySet().iterator();
1022     Item k;
1023     k = (Item)(i.next());
1024     mustEqual(minusTwo, k);
1025 dl 1.3 assertFalse(i.hasNext());
1026 dl 1.25 Iterator<? extends Item> j = sm.keySet().iterator();
1027 dl 1.3 j.next();
1028     j.remove();
1029 dl 1.25 assertFalse(map.containsKey(minusTwo));
1030     mustEqual(4, map.size());
1031     mustEqual(0, sm.size());
1032 dl 1.3 assertTrue(sm.isEmpty());
1033 dl 1.25 assertNull(sm.remove(minusThree));
1034     mustEqual(4, map.size());
1035 dl 1.3 }
1036    
1037     /**
1038     * headMap returns map with keys in requested range
1039     */
1040     public void testDescendingHeadMapContents() {
1041 dl 1.25 NavigableMap<Item,String> map = dmap5();
1042     SortedMap<Item,String> sm = map.headMap(minusFour);
1043     assertTrue(sm.containsKey(minusOne));
1044     assertTrue(sm.containsKey(minusTwo));
1045     assertTrue(sm.containsKey(minusThree));
1046     assertFalse(sm.containsKey(minusFour));
1047     assertFalse(sm.containsKey(minusFive));
1048     Iterator<? extends Item> i = sm.keySet().iterator();
1049     Item k;
1050     k = (Item)(i.next());
1051     mustEqual(minusOne, k);
1052     k = (Item)(i.next());
1053     mustEqual(minusTwo, k);
1054     k = (Item)(i.next());
1055     mustEqual(minusThree, k);
1056 dl 1.3 assertFalse(i.hasNext());
1057     sm.clear();
1058     assertTrue(sm.isEmpty());
1059 dl 1.25 mustEqual(2, map.size());
1060     mustEqual(minusFour, map.firstKey());
1061 dl 1.3 }
1062    
1063     /**
1064     * headMap returns map with keys in requested range
1065     */
1066     public void testDescendingTailMapContents() {
1067 dl 1.25 NavigableMap<Item,String> map = dmap5();
1068     SortedMap<Item,String> sm = map.tailMap(minusTwo);
1069     assertFalse(sm.containsKey(minusOne));
1070     assertTrue(sm.containsKey(minusTwo));
1071     assertTrue(sm.containsKey(minusThree));
1072     assertTrue(sm.containsKey(minusFour));
1073     assertTrue(sm.containsKey(minusFive));
1074     Iterator<? extends Item> i = sm.keySet().iterator();
1075     Item k;
1076     k = (Item)(i.next());
1077     mustEqual(minusTwo, k);
1078     k = (Item)(i.next());
1079     mustEqual(minusThree, k);
1080     k = (Item)(i.next());
1081     mustEqual(minusFour, k);
1082     k = (Item)(i.next());
1083     mustEqual(minusFive, k);
1084 dl 1.3 assertFalse(i.hasNext());
1085    
1086 dl 1.25 Iterator<Map.Entry<Item,String>> ei = sm.entrySet().iterator();
1087     Map.Entry<Item,String> e;
1088     e = (ei.next());
1089     mustEqual(minusTwo, e.getKey());
1090     mustEqual("B", e.getValue());
1091     e = (ei.next());
1092     mustEqual(minusThree, e.getKey());
1093     mustEqual("C", e.getValue());
1094     e = (ei.next());
1095     mustEqual(minusFour, e.getKey());
1096     mustEqual("D", e.getValue());
1097     e = (ei.next());
1098     mustEqual(minusFive, e.getKey());
1099     mustEqual("E", e.getValue());
1100 dl 1.3 assertFalse(i.hasNext());
1101    
1102 dl 1.25 SortedMap<Item,String> ssm = sm.tailMap(minusFour);
1103     mustEqual(minusFour, ssm.firstKey());
1104     mustEqual(minusFive, ssm.lastKey());
1105     mustEqual("D", ssm.remove(minusFour));
1106     mustEqual(1, ssm.size());
1107     mustEqual(3, sm.size());
1108     mustEqual(4, map.size());
1109 dl 1.3 }
1110 jsr166 1.4
1111 dl 1.1 }