ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TreeSubMapTest.java
Revision: 1.22
Committed: Sat Feb 28 18:32:12 2015 UTC (9 years, 2 months ago) by jsr166
Branch: MAIN
Changes since 1.21: +6 -6 lines
Log Message: 
narrow scope of try-catch

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.12 junit.textui.TestRunner.run(suite());
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 jsr166 1.19 * Returns a new map from Integers 1-5 to Strings "A"-"E".
30 dl 1.1 */
31 jsr166 1.4 private static NavigableMap map5() {
32 jsr166 1.7 TreeMap 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     assertEquals(7, map.size());
43 dl 1.3 return map.subMap(one, true, seven, false);
44 dl 1.1 }
45    
46 jsr166 1.4 private static NavigableMap map0() {
47 jsr166 1.7 TreeMap map = new TreeMap();
48 dl 1.1 assertTrue(map.isEmpty());
49 dl 1.3 return map.tailMap(one, true);
50     }
51    
52     /**
53 jsr166 1.19 * Returns a new map from Integers -5 to -1 to Strings "A"-"E".
54 dl 1.3 */
55 jsr166 1.4 private static NavigableMap dmap5() {
56 jsr166 1.7 TreeMap map = new TreeMap();
57 dl 1.3 assertTrue(map.isEmpty());
58 jsr166 1.7 map.put(m1, "A");
59     map.put(m5, "E");
60     map.put(m3, "C");
61     map.put(m2, "B");
62     map.put(m4, "D");
63 dl 1.3 assertFalse(map.isEmpty());
64     assertEquals(5, map.size());
65 jsr166 1.7 return map.descendingMap();
66 dl 1.3 }
67    
68 jsr166 1.4 private static NavigableMap dmap0() {
69 jsr166 1.7 TreeMap 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     NavigableMap map = map5();
79 jsr166 1.7 map.clear();
80 jsr166 1.17 assertEquals(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     NavigableMap map1 = map5();
88     NavigableMap map2 = map5();
89     assertEquals(map1, map2);
90     assertEquals(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     NavigableMap 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     NavigableMap 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     NavigableMap map = map5();
120 jsr166 1.7 assertEquals("A", (String)map.get(one));
121 dl 1.1 NavigableMap empty = map0();
122     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     NavigableMap empty = map0();
130     NavigableMap 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     NavigableMap map = map5();
140 jsr166 1.7 assertEquals(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     NavigableMap map = map5();
148 jsr166 1.7 assertEquals(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     NavigableMap map = map5();
156 jsr166 1.7 Set s = map.keySet();
157     assertEquals(5, s.size());
158     assertTrue(s.contains(one));
159     assertTrue(s.contains(two));
160     assertTrue(s.contains(three));
161     assertTrue(s.contains(four));
162     assertTrue(s.contains(five));
163 dl 1.1 }
164    
165     /**
166 jsr166 1.13 * keySet is ordered
167 dl 1.1 */
168     public void testKeySetOrder() {
169     NavigableMap map = map5();
170 jsr166 1.7 Set s = map.keySet();
171 dl 1.1 Iterator i = s.iterator();
172     Integer last = (Integer)i.next();
173     assertEquals(last, one);
174     while (i.hasNext()) {
175     Integer k = (Integer)i.next();
176     assertTrue(last.compareTo(k) < 0);
177     last = k;
178     }
179     }
180    
181     /**
182     * values collection contains all values
183     */
184     public void testValues() {
185     NavigableMap map = map5();
186 jsr166 1.7 Collection s = map.values();
187     assertEquals(5, s.size());
188     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     NavigableMap map = map5();
200 jsr166 1.7 Set s = map.entrySet();
201     assertEquals(5, s.size());
202 dl 1.1 Iterator it = s.iterator();
203     while (it.hasNext()) {
204     Map.Entry e = (Map.Entry) 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     NavigableMap empty = map0();
219     NavigableMap map = map5();
220 jsr166 1.7 empty.putAll(map);
221     assertEquals(5, empty.size());
222     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     NavigableMap map = map5();
234 jsr166 1.7 map.remove(five);
235     assertEquals(4, map.size());
236     assertFalse(map.containsKey(five));
237 dl 1.1 }
238    
239     /**
240     * lowerEntry returns preceding entry.
241     */
242     public void testLowerEntry() {
243     NavigableMap map = map5();
244     Map.Entry e1 = map.lowerEntry(three);
245     assertEquals(two, e1.getKey());
246    
247     Map.Entry e2 = map.lowerEntry(six);
248     assertEquals(five, e2.getKey());
249    
250     Map.Entry e3 = map.lowerEntry(one);
251     assertNull(e3);
252    
253     Map.Entry e4 = map.lowerEntry(zero);
254     assertNull(e4);
255     }
256    
257     /**
258     * higherEntry returns next entry.
259     */
260     public void testHigherEntry() {
261     NavigableMap map = map5();
262     Map.Entry e1 = map.higherEntry(three);
263     assertEquals(four, e1.getKey());
264    
265     Map.Entry e2 = map.higherEntry(zero);
266     assertEquals(one, e2.getKey());
267    
268     Map.Entry e3 = map.higherEntry(five);
269     assertNull(e3);
270    
271     Map.Entry e4 = map.higherEntry(six);
272     assertNull(e4);
273     }
274    
275     /**
276     * floorEntry returns preceding entry.
277     */
278     public void testFloorEntry() {
279     NavigableMap map = map5();
280     Map.Entry e1 = map.floorEntry(three);
281     assertEquals(three, e1.getKey());
282    
283     Map.Entry e2 = map.floorEntry(six);
284     assertEquals(five, e2.getKey());
285    
286     Map.Entry e3 = map.floorEntry(one);
287     assertEquals(one, e3.getKey());
288    
289     Map.Entry e4 = map.floorEntry(zero);
290     assertNull(e4);
291     }
292    
293     /**
294     * ceilingEntry returns next entry.
295     */
296     public void testCeilingEntry() {
297     NavigableMap map = map5();
298     Map.Entry e1 = map.ceilingEntry(three);
299     assertEquals(three, e1.getKey());
300    
301     Map.Entry e2 = map.ceilingEntry(zero);
302     assertEquals(one, e2.getKey());
303    
304     Map.Entry e3 = map.ceilingEntry(five);
305     assertEquals(five, e3.getKey());
306    
307     Map.Entry e4 = map.ceilingEntry(six);
308     assertNull(e4);
309     }
310    
311     /**
312     * pollFirstEntry returns entries in order
313     */
314     public void testPollFirstEntry() {
315     NavigableMap map = map5();
316     Map.Entry e = map.pollFirstEntry();
317     assertEquals(one, e.getKey());
318     assertEquals("A", e.getValue());
319     e = map.pollFirstEntry();
320     assertEquals(two, e.getKey());
321     map.put(one, "A");
322     e = map.pollFirstEntry();
323     assertEquals(one, e.getKey());
324     assertEquals("A", e.getValue());
325     e = map.pollFirstEntry();
326     assertEquals(three, e.getKey());
327     map.remove(four);
328     e = map.pollFirstEntry();
329     assertEquals(five, e.getKey());
330     try {
331     e.setValue("A");
332     shouldThrow();
333 jsr166 1.9 } catch (UnsupportedOperationException success) {}
334 dl 1.1 assertTrue(map.isEmpty());
335     Map.Entry f = map.firstEntry();
336     assertNull(f);
337     e = map.pollFirstEntry();
338     assertNull(e);
339     }
340    
341     /**
342     * pollLastEntry returns entries in order
343     */
344     public void testPollLastEntry() {
345     NavigableMap map = map5();
346     Map.Entry e = map.pollLastEntry();
347     assertEquals(five, e.getKey());
348     assertEquals("E", e.getValue());
349     e = map.pollLastEntry();
350     assertEquals(four, e.getKey());
351     map.put(five, "E");
352     e = map.pollLastEntry();
353     assertEquals(five, e.getKey());
354     assertEquals("E", e.getValue());
355     e = map.pollLastEntry();
356     assertEquals(three, e.getKey());
357     map.remove(two);
358     e = map.pollLastEntry();
359     assertEquals(one, e.getKey());
360     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     NavigableMap map = map5();
373     NavigableMap empty = map0();
374 jsr166 1.7 assertEquals(0, empty.size());
375     assertEquals(5, map.size());
376 dl 1.1 }
377    
378     /**
379     * toString contains toString of elements
380     */
381     public void testToString() {
382     NavigableMap map = map5();
383     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 jsr166 1.22 NavigableMap 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 jsr166 1.22 NavigableMap 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 jsr166 1.22 NavigableMap 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 jsr166 1.22 NavigableMap 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     * A deserialized map equals original
437     */
438 jsr166 1.8 public void testSerialization() throws Exception {
439 jsr166 1.16 NavigableMap x = map5();
440     NavigableMap y = serialClone(x);
441 dl 1.1
442 jsr166 1.20 assertNotSame(x, y);
443 jsr166 1.16 assertEquals(x.size(), y.size());
444     assertEquals(x.toString(), y.toString());
445     assertEquals(x, y);
446     assertEquals(y, x);
447 dl 1.1 }
448    
449     /**
450     * subMap returns map with keys in requested range
451     */
452     public void testSubMapContents() {
453     NavigableMap map = map5();
454     SortedMap sm = map.subMap(two, four);
455     assertEquals(two, sm.firstKey());
456     assertEquals(three, sm.lastKey());
457     assertEquals(2, sm.size());
458     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     Iterator i = sm.keySet().iterator();
464     Object k;
465     k = (Integer)(i.next());
466     assertEquals(two, k);
467     k = (Integer)(i.next());
468     assertEquals(three, k);
469     assertFalse(i.hasNext());
470     Iterator j = sm.keySet().iterator();
471     j.next();
472     j.remove();
473     assertFalse(map.containsKey(two));
474     assertEquals(4, map.size());
475     assertEquals(1, sm.size());
476     assertEquals(three, sm.firstKey());
477     assertEquals(three, sm.lastKey());
478 jsr166 1.10 assertEquals("C", sm.remove(three));
479 dl 1.1 assertTrue(sm.isEmpty());
480     assertEquals(3, map.size());
481     }
482    
483     public void testSubMapContents2() {
484     NavigableMap map = map5();
485     SortedMap sm = map.subMap(two, three);
486     assertEquals(1, sm.size());
487     assertEquals(two, sm.firstKey());
488     assertEquals(two, sm.lastKey());
489     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     Iterator i = sm.keySet().iterator();
495     Object k;
496     k = (Integer)(i.next());
497     assertEquals(two, k);
498     assertFalse(i.hasNext());
499     Iterator j = sm.keySet().iterator();
500     j.next();
501     j.remove();
502     assertFalse(map.containsKey(two));
503     assertEquals(4, map.size());
504     assertEquals(0, sm.size());
505     assertTrue(sm.isEmpty());
506 jsr166 1.10 assertSame(sm.remove(three), null);
507 dl 1.1 assertEquals(4, map.size());
508     }
509    
510     /**
511     * headMap returns map with keys in requested range
512     */
513     public void testHeadMapContents() {
514     NavigableMap map = map5();
515     SortedMap sm = map.headMap(four);
516     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     Iterator i = sm.keySet().iterator();
522     Object k;
523     k = (Integer)(i.next());
524     assertEquals(one, k);
525     k = (Integer)(i.next());
526     assertEquals(two, k);
527     k = (Integer)(i.next());
528     assertEquals(three, k);
529     assertFalse(i.hasNext());
530     sm.clear();
531     assertTrue(sm.isEmpty());
532     assertEquals(2, map.size());
533     assertEquals(four, map.firstKey());
534     }
535    
536     /**
537     * headMap returns map with keys in requested range
538     */
539     public void testTailMapContents() {
540     NavigableMap map = map5();
541     SortedMap sm = map.tailMap(two);
542     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     Iterator i = sm.keySet().iterator();
548     Object k;
549     k = (Integer)(i.next());
550     assertEquals(two, k);
551     k = (Integer)(i.next());
552     assertEquals(three, k);
553     k = (Integer)(i.next());
554     assertEquals(four, k);
555     k = (Integer)(i.next());
556     assertEquals(five, k);
557     assertFalse(i.hasNext());
558    
559     Iterator ei = sm.entrySet().iterator();
560     Map.Entry e;
561     e = (Map.Entry)(ei.next());
562     assertEquals(two, e.getKey());
563     assertEquals("B", e.getValue());
564     e = (Map.Entry)(ei.next());
565     assertEquals(three, e.getKey());
566     assertEquals("C", e.getValue());
567     e = (Map.Entry)(ei.next());
568     assertEquals(four, e.getKey());
569     assertEquals("D", e.getValue());
570     e = (Map.Entry)(ei.next());
571     assertEquals(five, e.getKey());
572     assertEquals("E", e.getValue());
573     assertFalse(i.hasNext());
574    
575     SortedMap ssm = sm.tailMap(four);
576     assertEquals(four, ssm.firstKey());
577     assertEquals(five, ssm.lastKey());
578 jsr166 1.10 assertEquals("D", ssm.remove(four));
579 dl 1.1 assertEquals(1, ssm.size());
580     assertEquals(3, sm.size());
581     assertEquals(4, map.size());
582     }
583 dl 1.3
584     /**
585 jsr166 1.13 * clear removes all pairs
586 dl 1.3 */
587     public void testDescendingClear() {
588     NavigableMap map = dmap5();
589 jsr166 1.7 map.clear();
590 jsr166 1.17 assertEquals(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     NavigableMap map1 = dmap5();
598     NavigableMap map2 = dmap5();
599     assertEquals(map1, map2);
600     assertEquals(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     NavigableMap map = dmap5();
611 jsr166 1.7 assertTrue(map.containsKey(m1));
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     NavigableMap 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     NavigableMap map = dmap5();
630 jsr166 1.7 assertEquals("A", (String)map.get(m1));
631 dl 1.3 NavigableMap empty = dmap0();
632     assertNull(empty.get(m1));
633     }
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     NavigableMap empty = dmap0();
640     NavigableMap 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     NavigableMap map = dmap5();
650 jsr166 1.7 assertEquals(m1, 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     NavigableMap map = dmap5();
658 jsr166 1.7 assertEquals(m5, 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     NavigableMap map = dmap5();
666 jsr166 1.7 Set s = map.keySet();
667     assertEquals(5, s.size());
668     assertTrue(s.contains(m1));
669     assertTrue(s.contains(m2));
670     assertTrue(s.contains(m3));
671     assertTrue(s.contains(m4));
672     assertTrue(s.contains(m5));
673 dl 1.3 }
674    
675     /**
676 jsr166 1.13 * keySet is ordered
677 dl 1.3 */
678     public void testDescendingKeySetOrder() {
679     NavigableMap map = dmap5();
680 jsr166 1.7 Set s = map.keySet();
681 dl 1.3 Iterator i = s.iterator();
682     Integer last = (Integer)i.next();
683     assertEquals(last, m1);
684     while (i.hasNext()) {
685     Integer k = (Integer)i.next();
686     assertTrue(last.compareTo(k) > 0);
687     last = k;
688     }
689     }
690    
691     /**
692     * values collection contains all values
693     */
694     public void testDescendingValues() {
695     NavigableMap map = dmap5();
696 jsr166 1.7 Collection s = map.values();
697     assertEquals(5, s.size());
698     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     NavigableMap map = dmap5();
710 jsr166 1.7 Set s = map.keySet();
711 dl 1.3 Object[] ar = s.toArray();
712     assertTrue(s.containsAll(Arrays.asList(ar)));
713 jsr166 1.7 assertEquals(5, ar.length);
714 dl 1.3 ar[0] = m10;
715     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     NavigableMap map = dmap5();
723 jsr166 1.7 Set s = map.descendingKeySet();
724 dl 1.3 Object[] ar = s.toArray();
725 jsr166 1.7 assertEquals(5, ar.length);
726 dl 1.3 assertTrue(s.containsAll(Arrays.asList(ar)));
727     ar[0] = m10;
728     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     NavigableMap map = dmap5();
736 jsr166 1.7 Collection v = map.values();
737 dl 1.3 Object[] ar = v.toArray();
738     ArrayList s = new ArrayList(Arrays.asList(ar));
739 jsr166 1.7 assertEquals(5, ar.length);
740     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     NavigableMap map = dmap5();
752 jsr166 1.7 Set s = map.entrySet();
753     assertEquals(5, s.size());
754 dl 1.3 Iterator it = s.iterator();
755     while (it.hasNext()) {
756     Map.Entry e = (Map.Entry) it.next();
757 jsr166 1.4 assertTrue(
758 dl 1.3 (e.getKey().equals(m1) && e.getValue().equals("A")) ||
759     (e.getKey().equals(m2) && e.getValue().equals("B")) ||
760     (e.getKey().equals(m3) && e.getValue().equals("C")) ||
761     (e.getKey().equals(m4) && e.getValue().equals("D")) ||
762     (e.getKey().equals(m5) && e.getValue().equals("E")));
763     }
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     NavigableMap empty = dmap0();
771     NavigableMap map = dmap5();
772 jsr166 1.7 empty.putAll(map);
773     assertEquals(5, empty.size());
774     assertTrue(empty.containsKey(m1));
775     assertTrue(empty.containsKey(m2));
776     assertTrue(empty.containsKey(m3));
777     assertTrue(empty.containsKey(m4));
778     assertTrue(empty.containsKey(m5));
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     NavigableMap map = dmap5();
786 jsr166 1.7 map.remove(m5);
787     assertEquals(4, map.size());
788     assertFalse(map.containsKey(m5));
789 dl 1.3 }
790    
791     /**
792     * lowerEntry returns preceding entry.
793     */
794     public void testDescendingLowerEntry() {
795     NavigableMap map = dmap5();
796     Map.Entry e1 = map.lowerEntry(m3);
797     assertEquals(m2, e1.getKey());
798    
799     Map.Entry e2 = map.lowerEntry(m6);
800     assertEquals(m5, e2.getKey());
801    
802     Map.Entry e3 = map.lowerEntry(m1);
803     assertNull(e3);
804    
805     Map.Entry e4 = map.lowerEntry(zero);
806     assertNull(e4);
807     }
808    
809     /**
810     * higherEntry returns next entry.
811     */
812     public void testDescendingHigherEntry() {
813     NavigableMap map = dmap5();
814     Map.Entry e1 = map.higherEntry(m3);
815     assertEquals(m4, e1.getKey());
816    
817     Map.Entry e2 = map.higherEntry(zero);
818     assertEquals(m1, e2.getKey());
819    
820     Map.Entry e3 = map.higherEntry(m5);
821     assertNull(e3);
822    
823     Map.Entry e4 = map.higherEntry(m6);
824     assertNull(e4);
825     }
826    
827     /**
828     * floorEntry returns preceding entry.
829     */
830     public void testDescendingFloorEntry() {
831     NavigableMap map = dmap5();
832     Map.Entry e1 = map.floorEntry(m3);
833     assertEquals(m3, e1.getKey());
834    
835     Map.Entry e2 = map.floorEntry(m6);
836     assertEquals(m5, e2.getKey());
837    
838     Map.Entry e3 = map.floorEntry(m1);
839     assertEquals(m1, e3.getKey());
840    
841     Map.Entry e4 = map.floorEntry(zero);
842     assertNull(e4);
843     }
844    
845     /**
846     * ceilingEntry returns next entry.
847     */
848     public void testDescendingCeilingEntry() {
849     NavigableMap map = dmap5();
850     Map.Entry e1 = map.ceilingEntry(m3);
851     assertEquals(m3, e1.getKey());
852    
853     Map.Entry e2 = map.ceilingEntry(zero);
854     assertEquals(m1, e2.getKey());
855    
856     Map.Entry e3 = map.ceilingEntry(m5);
857     assertEquals(m5, e3.getKey());
858    
859     Map.Entry e4 = map.ceilingEntry(m6);
860     assertNull(e4);
861     }
862    
863     /**
864     * pollFirstEntry returns entries in order
865     */
866     public void testDescendingPollFirstEntry() {
867     NavigableMap map = dmap5();
868     Map.Entry e = map.pollFirstEntry();
869     assertEquals(m1, e.getKey());
870     assertEquals("A", e.getValue());
871     e = map.pollFirstEntry();
872     assertEquals(m2, e.getKey());
873     map.put(m1, "A");
874     e = map.pollFirstEntry();
875     assertEquals(m1, e.getKey());
876     assertEquals("A", e.getValue());
877     e = map.pollFirstEntry();
878     assertEquals(m3, e.getKey());
879     map.remove(m4);
880     e = map.pollFirstEntry();
881     assertEquals(m5, e.getKey());
882     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     NavigableMap map = dmap5();
895     Map.Entry e = map.pollLastEntry();
896     assertEquals(m5, e.getKey());
897     assertEquals("E", e.getValue());
898     e = map.pollLastEntry();
899     assertEquals(m4, e.getKey());
900     map.put(m5, "E");
901     e = map.pollLastEntry();
902     assertEquals(m5, e.getKey());
903     assertEquals("E", e.getValue());
904     e = map.pollLastEntry();
905     assertEquals(m3, e.getKey());
906     map.remove(m2);
907     e = map.pollLastEntry();
908     assertEquals(m1, e.getKey());
909     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     NavigableMap map = dmap5();
922     NavigableMap empty = dmap0();
923 jsr166 1.7 assertEquals(0, empty.size());
924     assertEquals(5, map.size());
925 dl 1.3 }
926    
927     /**
928     * toString contains toString of elements
929     */
930     public void testDescendingToString() {
931     NavigableMap map = dmap5();
932     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 jsr166 1.22 NavigableMap 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 jsr166 1.22 NavigableMap 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     * A deserialized map equals original
964     */
965 jsr166 1.8 public void testDescendingSerialization() throws Exception {
966 jsr166 1.16 NavigableMap x = dmap5();
967     NavigableMap y = serialClone(x);
968 jsr166 1.4
969 jsr166 1.20 assertNotSame(x, y);
970 jsr166 1.16 assertEquals(x.size(), y.size());
971     assertEquals(x.toString(), y.toString());
972     assertEquals(x, y);
973     assertEquals(y, x);
974 dl 1.3 }
975    
976     /**
977     * subMap returns map with keys in requested range
978     */
979     public void testDescendingSubMapContents() {
980     NavigableMap map = dmap5();
981     SortedMap sm = map.subMap(m2, m4);
982     assertEquals(m2, sm.firstKey());
983     assertEquals(m3, sm.lastKey());
984     assertEquals(2, sm.size());
985     assertFalse(sm.containsKey(m1));
986     assertTrue(sm.containsKey(m2));
987     assertTrue(sm.containsKey(m3));
988     assertFalse(sm.containsKey(m4));
989     assertFalse(sm.containsKey(m5));
990     Iterator i = sm.keySet().iterator();
991     Object k;
992     k = (Integer)(i.next());
993     assertEquals(m2, k);
994     k = (Integer)(i.next());
995     assertEquals(m3, k);
996     assertFalse(i.hasNext());
997     Iterator j = sm.keySet().iterator();
998     j.next();
999     j.remove();
1000     assertFalse(map.containsKey(m2));
1001     assertEquals(4, map.size());
1002     assertEquals(1, sm.size());
1003     assertEquals(m3, sm.firstKey());
1004     assertEquals(m3, sm.lastKey());
1005 jsr166 1.10 assertEquals("C", sm.remove(m3));
1006 dl 1.3 assertTrue(sm.isEmpty());
1007     assertEquals(3, map.size());
1008     }
1009    
1010     public void testDescendingSubMapContents2() {
1011     NavigableMap map = dmap5();
1012     SortedMap sm = map.subMap(m2, m3);
1013     assertEquals(1, sm.size());
1014     assertEquals(m2, sm.firstKey());
1015     assertEquals(m2, sm.lastKey());
1016     assertFalse(sm.containsKey(m1));
1017     assertTrue(sm.containsKey(m2));
1018     assertFalse(sm.containsKey(m3));
1019     assertFalse(sm.containsKey(m4));
1020     assertFalse(sm.containsKey(m5));
1021     Iterator i = sm.keySet().iterator();
1022     Object k;
1023     k = (Integer)(i.next());
1024     assertEquals(m2, k);
1025     assertFalse(i.hasNext());
1026     Iterator j = sm.keySet().iterator();
1027     j.next();
1028     j.remove();
1029     assertFalse(map.containsKey(m2));
1030     assertEquals(4, map.size());
1031     assertEquals(0, sm.size());
1032     assertTrue(sm.isEmpty());
1033 jsr166 1.10 assertSame(sm.remove(m3), null);
1034 dl 1.3 assertEquals(4, map.size());
1035     }
1036    
1037     /**
1038     * headMap returns map with keys in requested range
1039     */
1040     public void testDescendingHeadMapContents() {
1041     NavigableMap map = dmap5();
1042     SortedMap sm = map.headMap(m4);
1043     assertTrue(sm.containsKey(m1));
1044     assertTrue(sm.containsKey(m2));
1045     assertTrue(sm.containsKey(m3));
1046     assertFalse(sm.containsKey(m4));
1047     assertFalse(sm.containsKey(m5));
1048     Iterator i = sm.keySet().iterator();
1049     Object k;
1050     k = (Integer)(i.next());
1051     assertEquals(m1, k);
1052     k = (Integer)(i.next());
1053     assertEquals(m2, k);
1054     k = (Integer)(i.next());
1055     assertEquals(m3, k);
1056     assertFalse(i.hasNext());
1057     sm.clear();
1058     assertTrue(sm.isEmpty());
1059     assertEquals(2, map.size());
1060     assertEquals(m4, map.firstKey());
1061     }
1062    
1063     /**
1064     * headMap returns map with keys in requested range
1065     */
1066     public void testDescendingTailMapContents() {
1067     NavigableMap map = dmap5();
1068     SortedMap sm = map.tailMap(m2);
1069     assertFalse(sm.containsKey(m1));
1070     assertTrue(sm.containsKey(m2));
1071     assertTrue(sm.containsKey(m3));
1072     assertTrue(sm.containsKey(m4));
1073     assertTrue(sm.containsKey(m5));
1074     Iterator i = sm.keySet().iterator();
1075     Object k;
1076     k = (Integer)(i.next());
1077     assertEquals(m2, k);
1078     k = (Integer)(i.next());
1079     assertEquals(m3, k);
1080     k = (Integer)(i.next());
1081     assertEquals(m4, k);
1082     k = (Integer)(i.next());
1083     assertEquals(m5, k);
1084     assertFalse(i.hasNext());
1085    
1086     Iterator ei = sm.entrySet().iterator();
1087     Map.Entry e;
1088     e = (Map.Entry)(ei.next());
1089     assertEquals(m2, e.getKey());
1090     assertEquals("B", e.getValue());
1091     e = (Map.Entry)(ei.next());
1092     assertEquals(m3, e.getKey());
1093     assertEquals("C", e.getValue());
1094     e = (Map.Entry)(ei.next());
1095     assertEquals(m4, e.getKey());
1096     assertEquals("D", e.getValue());
1097     e = (Map.Entry)(ei.next());
1098     assertEquals(m5, e.getKey());
1099     assertEquals("E", e.getValue());
1100     assertFalse(i.hasNext());
1101    
1102     SortedMap ssm = sm.tailMap(m4);
1103     assertEquals(m4, ssm.firstKey());
1104     assertEquals(m5, ssm.lastKey());
1105 jsr166 1.10 assertEquals("D", ssm.remove(m4));
1106 dl 1.3 assertEquals(1, ssm.size());
1107     assertEquals(3, sm.size());
1108     assertEquals(4, map.size());
1109     }
1110 jsr166 1.4
1111 dl 1.1 }