ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/jsr166/jsr166/src/test/tck/ConcurrentSkipListSubMapTest.java
Revision: 1.18
Committed: Fri May 27 19:21:27 2011 UTC (12 years, 11 months ago) by jsr166
Branch: MAIN
Changes since 1.17: +2 -17 lines
Log Message: 
indexOf => contains

File Contents

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