ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/TreeSubMapTest.java
Revision: 1.20
Committed: Thu May 30 03:28:55 2013 UTC (10 years, 11 months ago) by jsr166
Branch: MAIN
Changes since 1.19: +2 -2 lines
Log Message: 
prefer assertNotSame, assertNotNull to assertTrue

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