1package org.apache.harmony.tests.java.util;
2
3/*
4 *  Licensed to the Apache Software Foundation (ASF) under one or more
5 *  contributor license agreements.  See the NOTICE file distributed with
6 *  this work for additional information regarding copyright ownership.
7 *  The ASF licenses this file to You under the Apache License, Version 2.0
8 *  (the "License"); you may not use this file except in compliance with
9 *  the License.  You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 *  Unless required by applicable law or agreed to in writing, software
14 *  distributed under the License is distributed on an "AS IS" BASIS,
15 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 *  See the License for the specific language governing permissions and
17 *  limitations under the License.
18 */
19
20import junit.framework.TestCase;
21import org.apache.harmony.tests.java.util.TreeMapTest.MockComparator;
22import java.util.Collection;
23import java.util.Collections;
24import java.util.Comparator;
25import java.util.Iterator;
26import java.util.Map;
27import java.util.Map.Entry;
28import java.util.NavigableMap;
29import java.util.NavigableSet;
30import java.util.NoSuchElementException;
31import java.util.Set;
32import java.util.SortedMap;
33import java.util.SortedSet;
34import java.util.TreeMap;
35
36//
37public class TreeMapExtendTest extends TestCase {
38
39    TreeMap tm;
40
41    TreeMap tm_comparator;
42
43    SortedMap subMap_default;
44
45    SortedMap subMap_startExcluded_endExcluded;
46
47    SortedMap subMap_startExcluded_endIncluded;
48
49    SortedMap subMap_startIncluded_endExcluded;
50
51    SortedMap subMap_startIncluded_endIncluded;
52
53    SortedMap subMap_default_beforeStart_100;
54
55    SortedMap subMap_default_afterEnd_109;
56
57    NavigableMap navigableMap_startExcluded_endExcluded;
58
59    NavigableMap navigableMap_startExcluded_endIncluded;
60
61    NavigableMap navigableMap_startIncluded_endExcluded;
62
63    NavigableMap navigableMap_startIncluded_endIncluded;
64
65    SortedMap subMap_default_comparator;
66
67    SortedMap subMap_startExcluded_endExcluded_comparator;
68
69    SortedMap subMap_startExcluded_endIncluded_comparator;
70
71    SortedMap subMap_startIncluded_endExcluded_comparator;
72
73    SortedMap subMap_startIncluded_endIncluded_comparator;
74
75    Object objArray[] = new Object[1000];
76
77    public void test_TreeMap_Constructor_Default() {
78        TreeMap treeMap = new TreeMap();
79        assertTrue(treeMap.isEmpty());
80        assertNull(treeMap.comparator());
81        assertEquals(0, treeMap.size());
82
83        try {
84            treeMap.firstKey();
85            fail("should throw NoSuchElementException");
86        } catch (NoSuchElementException e) {
87            // Expected
88        }
89        assertNull(treeMap.firstEntry());
90
91        try {
92            treeMap.lastKey();
93            fail("should throw NoSuchElementException");
94        } catch (NoSuchElementException e) {
95            // Expected
96        }
97        assertNull(treeMap.lastEntry());
98
99        try {
100            treeMap.ceilingKey(1);
101        } catch (NoSuchElementException e) {
102            // Expected
103        }
104        assertNull(treeMap.ceilingEntry(1));
105
106        try {
107            treeMap.floorKey(1);
108        } catch (NoSuchElementException e) {
109            // Expected
110        }
111        assertNull(treeMap.floorEntry(1));
112        assertNull(treeMap.lowerKey(1));
113        assertNull(treeMap.lowerEntry(1));
114        assertNull(treeMap.higherKey(1));
115        assertNull(treeMap.higherEntry(1));
116        assertFalse(treeMap.containsKey(1));
117        assertFalse(treeMap.containsValue(1));
118        assertNull(treeMap.get(1));
119
120        assertNull(treeMap.pollFirstEntry());
121        assertNull(treeMap.pollLastEntry());
122        assertEquals(0, treeMap.values().size());
123    }
124
125    public void test_TreeMap_Constructor_Comparator() {
126        MockComparator mockComparator = new MockComparator();
127        TreeMap treeMap = new TreeMap(mockComparator);
128
129        assertEquals(mockComparator, treeMap.comparator());
130    }
131
132    public void test_TreeMap_Constructor_Map() {
133        TreeMap treeMap = new TreeMap(tm);
134        assertEquals(tm.size(), treeMap.size());
135        assertEquals(tm.firstKey(), treeMap.firstKey());
136        assertEquals(tm.firstEntry(), treeMap.firstEntry());
137        assertEquals(tm.lastKey(), treeMap.lastKey());
138        assertEquals(tm.lastEntry(), treeMap.lastEntry());
139        assertEquals(tm.keySet(), treeMap.keySet());
140
141        String key = new Integer(100).toString();
142        assertEquals(tm.ceilingKey(key), treeMap.ceilingKey(key));
143        assertEquals(tm.ceilingEntry(key), treeMap.ceilingEntry(key));
144        assertEquals(tm.floorKey(key), treeMap.floorKey(key));
145        assertEquals(tm.floorEntry(key), treeMap.floorEntry(key));
146        assertEquals(tm.lowerKey(key), treeMap.lowerKey(key));
147        assertEquals(tm.lowerEntry(key), treeMap.lowerEntry(key));
148        assertEquals(tm.higherKey(key), treeMap.higherKey(key));
149        assertEquals(tm.higherEntry(key), treeMap.higherEntry(key));
150        assertEquals(tm.entrySet(), treeMap.entrySet());
151    }
152
153    public void test_TreeMap_Constructor_SortedMap() {
154        TreeMap treeMap = new TreeMap(subMap_default);
155        assertEquals(subMap_default.size(), treeMap.size());
156        assertEquals(subMap_default.firstKey(), treeMap.firstKey());
157        assertEquals(subMap_default.lastKey(), treeMap.lastKey());
158        assertEquals(subMap_default.keySet(), treeMap.keySet());
159        assertEquals(subMap_default.entrySet(), treeMap.entrySet());
160    }
161
162    public void test_TreeMap_clear() {
163        tm.clear();
164        assertEquals(0, tm.size());
165    }
166
167    public void test_TreeMap_clone() {
168        TreeMap cloneTreeMap = (TreeMap) tm.clone();
169        assertEquals(tm, cloneTreeMap);
170    }
171
172    public void test_SubMap_Constructor() {
173    }
174
175    public void test_SubMap_clear() {
176        subMap_default.clear();
177        assertEquals(0, subMap_default.size());
178    }
179
180    public void test_SubMap_comparator() {
181        assertEquals(tm.comparator(), subMap_default.comparator());
182    }
183
184    public void test_SubMap_containsKey() {
185        String key = null;
186        for (int counter = 101; counter < 109; counter++) {
187            key = objArray[counter].toString();
188            assertTrue("SubMap contains incorrect elements", subMap_default
189                    .containsKey(key));
190            assertTrue("SubMap contains incorrect elements",
191                    subMap_startExcluded_endExcluded.containsKey(key));
192            assertTrue("SubMap contains incorrect elements",
193                    subMap_startExcluded_endIncluded.containsKey(key));
194            assertTrue("SubMap contains incorrect elements",
195                    subMap_startIncluded_endExcluded.containsKey(key));
196            assertTrue("SubMap contains incorrect elements",
197                    subMap_startIncluded_endIncluded.containsKey(key));
198        }
199
200        // Check boundary
201        key = objArray[100].toString();
202        assertTrue("SubMap contains incorrect elements", subMap_default
203                .containsKey(key));
204        assertFalse("SubMap contains incorrect elements",
205                subMap_startExcluded_endExcluded.containsKey(key));
206        assertFalse("SubMap contains incorrect elements",
207                subMap_startExcluded_endIncluded.containsKey(key));
208        assertTrue("SubMap contains incorrect elements",
209                subMap_startIncluded_endExcluded.containsKey(key));
210        assertTrue("SubMap contains incorrect elements",
211                subMap_startIncluded_endIncluded.containsKey(key));
212
213        key = objArray[109].toString();
214        assertFalse("SubMap contains incorrect elements", subMap_default
215                .containsKey(key));
216        assertFalse("SubMap contains incorrect elements",
217                subMap_startExcluded_endExcluded.containsKey(key));
218        assertTrue("SubMap contains incorrect elements",
219                subMap_startExcluded_endIncluded.containsKey(key));
220        assertFalse("SubMap contains incorrect elements",
221                subMap_startIncluded_endExcluded.containsKey(key));
222        assertTrue("SubMap contains incorrect elements",
223                subMap_startIncluded_endIncluded.containsKey(key));
224
225        // With Comparator
226        for (int counter = 101; counter < 109; counter++) {
227            key = objArray[counter].toString();
228            assertTrue("SubMap contains incorrect elements",
229                    subMap_default_comparator.containsKey(key));
230            assertTrue("SubMap contains incorrect elements",
231                    subMap_startExcluded_endExcluded_comparator
232                            .containsKey(key));
233            assertTrue("SubMap contains incorrect elements",
234                    subMap_startExcluded_endIncluded_comparator
235                            .containsKey(key));
236            assertTrue("SubMap contains incorrect elements",
237                    subMap_startIncluded_endExcluded_comparator
238                            .containsKey(key));
239            assertTrue("SubMap contains incorrect elements",
240                    subMap_startIncluded_endIncluded_comparator
241                            .containsKey(key));
242        }
243
244        // Check boundary
245        key = objArray[100].toString();
246        assertTrue("SubMap contains incorrect elements",
247                subMap_default_comparator.containsKey(key));
248        assertFalse("SubMap contains incorrect elements",
249                subMap_startExcluded_endExcluded_comparator.containsKey(key));
250        assertFalse("SubMap contains incorrect elements",
251                subMap_startExcluded_endIncluded_comparator.containsKey(key));
252        assertTrue("SubMap contains incorrect elements",
253                subMap_startIncluded_endExcluded_comparator.containsKey(key));
254        assertTrue("SubMap contains incorrect elements",
255                subMap_startIncluded_endIncluded_comparator.containsKey(key));
256
257        key = objArray[109].toString();
258        assertFalse("SubMap contains incorrect elements",
259                subMap_default_comparator.containsKey(key));
260        assertFalse("SubMap contains incorrect elements",
261                subMap_startExcluded_endExcluded_comparator.containsKey(key));
262        assertTrue("SubMap contains incorrect elements",
263                subMap_startExcluded_endIncluded_comparator.containsKey(key));
264        assertFalse("SubMap contains incorrect elements",
265                subMap_startIncluded_endExcluded_comparator.containsKey(key));
266        assertTrue("SubMap contains incorrect elements",
267                subMap_startIncluded_endIncluded_comparator.containsKey(key));
268    }
269
270    public void test_SubMap_containsValue() {
271        Object value = null;
272        for (int counter = 101; counter < 109; counter++) {
273            value = objArray[counter];
274            assertTrue("SubMap contains incorrect elements", subMap_default
275                    .containsValue(value));
276            assertTrue("SubMap contains incorrect elements",
277                    subMap_startExcluded_endExcluded.containsValue(value));
278            assertTrue("SubMap contains incorrect elements",
279                    subMap_startExcluded_endIncluded.containsValue(value));
280            assertTrue("SubMap contains incorrect elements",
281                    subMap_startIncluded_endExcluded.containsValue(value));
282            assertTrue("SubMap contains incorrect elements",
283                    subMap_startIncluded_endIncluded.containsValue(value));
284        }
285
286        // Check boundary
287        value = objArray[100];
288        assertTrue("SubMap contains incorrect elements", subMap_default
289                .containsValue(value));
290        assertFalse("SubMap contains incorrect elements",
291                subMap_startExcluded_endExcluded.containsValue(value));
292        assertFalse("SubMap contains incorrect elements",
293                subMap_startExcluded_endIncluded.containsValue(value));
294        assertTrue("SubMap contains incorrect elements",
295                subMap_startIncluded_endExcluded.containsValue(value));
296        assertTrue("SubMap contains incorrect elements",
297                subMap_startIncluded_endIncluded.containsValue(value));
298
299        value = objArray[109];
300        assertFalse("SubMap contains incorrect elements", subMap_default
301                .containsValue(value));
302        assertFalse("SubMap contains incorrect elements",
303                subMap_startExcluded_endExcluded.containsValue(value));
304        assertTrue("SubMap contains incorrect elements",
305                subMap_startExcluded_endIncluded.containsValue(value));
306        assertFalse("SubMap contains incorrect elements",
307                subMap_startIncluded_endExcluded.containsValue(value));
308        assertTrue("SubMap contains incorrect elements",
309                subMap_startIncluded_endIncluded.containsValue(value));
310
311        assertFalse(subMap_default.containsValue(null));
312
313        TreeMap tm_null = new TreeMap();
314        tm_null.put("0", 1);
315        tm_null.put("1", null);
316        tm_null.put("2", 2);
317        SortedMap subMap = tm_null.subMap("0", "2");
318        assertTrue(subMap.containsValue(null));
319
320        subMap.remove("1");
321        assertFalse(subMap.containsValue(null));
322    }
323
324    public void test_SubMap_entrySet() {
325        Set entrySet = subMap_default.entrySet();
326        assertFalse(entrySet.isEmpty());
327        assertEquals(9, entrySet.size());
328
329        entrySet = subMap_startExcluded_endExcluded.entrySet();
330        assertFalse(entrySet.isEmpty());
331        assertEquals(8, entrySet.size());
332
333        entrySet = subMap_startExcluded_endIncluded.entrySet();
334        assertFalse(entrySet.isEmpty());
335        assertEquals(9, entrySet.size());
336
337        entrySet = subMap_startIncluded_endExcluded.entrySet();
338        assertFalse(entrySet.isEmpty());
339        assertEquals(9, entrySet.size());
340
341        entrySet = subMap_startIncluded_endIncluded.entrySet();
342        assertFalse(entrySet.isEmpty());
343        assertEquals(10, entrySet.size());
344    }
345
346    public void test_SubMap_firstKey() {
347        String firstKey1 = new Integer(100).toString();
348        String firstKey2 = new Integer(101).toString();
349        assertEquals(firstKey1, subMap_default.firstKey());
350        assertEquals(firstKey2, subMap_startExcluded_endExcluded.firstKey());
351        assertEquals(firstKey2, subMap_startExcluded_endIncluded.firstKey());
352        assertEquals(firstKey1, subMap_startIncluded_endExcluded.firstKey());
353        assertEquals(firstKey1, subMap_startIncluded_endIncluded.firstKey());
354
355        try {
356            subMap_default.subMap(firstKey1, firstKey1).firstKey();
357            fail("should throw NoSuchElementException");
358        } catch (NoSuchElementException e) {
359            // Expected
360        }
361
362        try {
363            subMap_startExcluded_endExcluded.subMap(firstKey2, firstKey2)
364                    .firstKey();
365            fail("should throw NoSuchElementException");
366        } catch (NoSuchElementException e) {
367            // Expected
368        }
369
370        try {
371            subMap_startExcluded_endIncluded.subMap(firstKey2, firstKey2)
372                    .firstKey();
373            fail("should throw NoSuchElementException");
374        } catch (NoSuchElementException e) {
375            // Expected
376        }
377
378        try {
379            subMap_startIncluded_endExcluded.subMap(firstKey1, firstKey1)
380                    .firstKey();
381            fail("should throw NoSuchElementException");
382        } catch (NoSuchElementException e) {
383            // Expected
384        }
385
386        try {
387            subMap_startIncluded_endIncluded.subMap(firstKey1, firstKey1)
388                    .firstKey();
389            fail("should throw NoSuchElementException");
390        } catch (NoSuchElementException e) {
391            // Expected
392        }
393
394        // With Comparator
395        assertEquals(firstKey1, subMap_default_comparator.firstKey());
396        assertEquals(firstKey2, subMap_startExcluded_endExcluded_comparator
397                .firstKey());
398        assertEquals(firstKey2, subMap_startExcluded_endIncluded_comparator
399                .firstKey());
400        assertEquals(firstKey1, subMap_startIncluded_endExcluded_comparator
401                .firstKey());
402        assertEquals(firstKey1, subMap_startIncluded_endIncluded_comparator
403                .firstKey());
404
405        try {
406            subMap_default_comparator.subMap(firstKey1, firstKey1).firstKey();
407            fail("should throw NoSuchElementException");
408        } catch (NoSuchElementException e) {
409            // Expected
410        }
411
412        try {
413            subMap_startExcluded_endExcluded_comparator.subMap(firstKey2,
414                    firstKey2).firstKey();
415            fail("should throw NoSuchElementException");
416        } catch (NoSuchElementException e) {
417            // Expected
418        }
419
420        try {
421            subMap_startExcluded_endIncluded_comparator.subMap(firstKey2,
422                    firstKey2).firstKey();
423            fail("should throw NoSuchElementException");
424        } catch (NoSuchElementException e) {
425            // Expected
426        }
427
428        try {
429            subMap_startIncluded_endExcluded_comparator.subMap(firstKey1,
430                    firstKey1).firstKey();
431            fail("should throw NoSuchElementException");
432        } catch (NoSuchElementException e) {
433            // Expected
434        }
435
436        try {
437            subMap_startIncluded_endIncluded_comparator.subMap(firstKey1,
438                    firstKey1).firstKey();
439            fail("should throw NoSuchElementException");
440        } catch (NoSuchElementException e) {
441            // Expected
442        }
443
444    }
445
446    public void test_SubMap_lastKey() {
447        String lastKey1 = new Integer(108).toString();
448        String lastKey2 = new Integer(109).toString();
449        assertEquals(lastKey1, subMap_default.lastKey());
450        assertEquals(lastKey1, subMap_startExcluded_endExcluded.lastKey());
451        assertEquals(lastKey2, subMap_startExcluded_endIncluded.lastKey());
452        assertEquals(lastKey1, subMap_startIncluded_endExcluded.lastKey());
453        assertEquals(lastKey2, subMap_startIncluded_endIncluded.lastKey());
454
455        try {
456            subMap_default.subMap(lastKey1, lastKey1).lastKey();
457            fail("should throw NoSuchElementException");
458        } catch (NoSuchElementException e) {
459            // Expected
460        }
461
462        try {
463            subMap_startExcluded_endExcluded.subMap(lastKey1, lastKey1)
464                    .lastKey();
465            fail("should throw NoSuchElementException");
466        } catch (NoSuchElementException e) {
467            // Expected
468        }
469
470        try {
471            subMap_startExcluded_endIncluded.subMap(lastKey2, lastKey2)
472                    .lastKey();
473            fail("should throw NoSuchElementException");
474        } catch (NoSuchElementException e) {
475            // Expected
476        }
477
478        try {
479            subMap_startIncluded_endExcluded.subMap(lastKey1, lastKey1)
480                    .lastKey();
481            fail("should throw NoSuchElementException");
482        } catch (NoSuchElementException e) {
483            // Expected
484        }
485
486        try {
487            subMap_startIncluded_endIncluded.subMap(lastKey2, lastKey2)
488                    .lastKey();
489            fail("should throw NoSuchElementException");
490        } catch (NoSuchElementException e) {
491            // Expected
492        }
493
494        // With Comparator
495        assertEquals(lastKey1, subMap_default_comparator.lastKey());
496        assertEquals(lastKey1, subMap_startExcluded_endExcluded_comparator
497                .lastKey());
498        assertEquals(lastKey2, subMap_startExcluded_endIncluded_comparator
499                .lastKey());
500        assertEquals(lastKey1, subMap_startIncluded_endExcluded_comparator
501                .lastKey());
502        assertEquals(lastKey2, subMap_startIncluded_endIncluded_comparator
503                .lastKey());
504
505        try {
506            subMap_default_comparator.subMap(lastKey1, lastKey1).lastKey();
507            fail("should throw NoSuchElementException");
508        } catch (NoSuchElementException e) {
509            // Expected
510        }
511
512        try {
513            subMap_startExcluded_endExcluded_comparator.subMap(lastKey1,
514                    lastKey1).lastKey();
515            fail("should throw NoSuchElementException");
516        } catch (NoSuchElementException e) {
517            // Expected
518        }
519
520        try {
521            subMap_startExcluded_endIncluded_comparator.subMap(lastKey2,
522                    lastKey2).lastKey();
523            fail("should throw NoSuchElementException");
524        } catch (NoSuchElementException e) {
525            // Expected
526        }
527
528        try {
529            subMap_startIncluded_endExcluded_comparator.subMap(lastKey1,
530                    lastKey1).lastKey();
531            fail("should throw NoSuchElementException");
532        } catch (NoSuchElementException e) {
533            // Expected
534        }
535
536        try {
537            subMap_startIncluded_endIncluded_comparator.subMap(lastKey2,
538                    lastKey2).lastKey();
539            fail("should throw NoSuchElementException");
540        } catch (NoSuchElementException e) {
541            // Expected
542        }
543    }
544
545    public void test_SubMap_get() {
546        // left boundary
547        Integer value = new Integer(100);
548        assertEquals(value, subMap_default.get(value.toString()));
549        assertEquals(null, subMap_startExcluded_endExcluded.get(value
550                .toString()));
551        assertEquals(null, subMap_startExcluded_endIncluded.get(value
552                .toString()));
553        assertEquals(value, subMap_startIncluded_endExcluded.get(value
554                .toString()));
555        assertEquals(value, subMap_startIncluded_endIncluded.get(value
556                .toString()));
557
558        // normal value
559        value = new Integer(105);
560        assertEquals(value, subMap_default.get(value.toString()));
561        assertEquals(value, subMap_startExcluded_endExcluded.get(value
562                .toString()));
563        assertEquals(value, subMap_startExcluded_endIncluded.get(value
564                .toString()));
565        assertEquals(value, subMap_startIncluded_endExcluded.get(value
566                .toString()));
567        assertEquals(value, subMap_startIncluded_endIncluded.get(value
568                .toString()));
569
570        // right boundary
571        value = new Integer(109);
572        assertEquals(null, subMap_default.get(value.toString()));
573        assertEquals(null, subMap_startExcluded_endExcluded.get(value
574                .toString()));
575        assertEquals(value, subMap_startExcluded_endIncluded.get(value
576                .toString()));
577        assertEquals(null, subMap_startIncluded_endExcluded.get(value
578                .toString()));
579        assertEquals(value, subMap_startIncluded_endIncluded.get(value
580                .toString()));
581
582        // With Comparator to test inInRange
583        // left boundary
584        value = new Integer(100);
585        assertEquals(value, subMap_default_comparator.get(value.toString()));
586
587        // normal value
588        value = new Integer(105);
589        assertEquals(value, subMap_default_comparator.get(value.toString()));
590
591        // right boundary
592        value = new Integer(109);
593        assertEquals(null, subMap_default_comparator.get(value.toString()));
594    }
595
596    public void test_SubMap_headMap() {
597        String endKey = new Integer(99).toString();
598        try {
599            subMap_default.headMap(endKey);
600            fail("should throw IllegalArgumentException");
601        } catch (IllegalArgumentException e) {
602            // Expected
603        }
604
605        try {
606            subMap_startExcluded_endExcluded.headMap(endKey);
607            fail("should throw IllegalArgumentException");
608        } catch (IllegalArgumentException e) {
609            // Expected
610        }
611
612        try {
613            subMap_startExcluded_endIncluded.headMap(endKey);
614            fail("should throw IllegalArgumentException");
615        } catch (IllegalArgumentException e) {
616            // Expected
617        }
618
619        try {
620            subMap_startIncluded_endExcluded.headMap(endKey);
621            fail("should throw IllegalArgumentException");
622        } catch (IllegalArgumentException e) {
623            // Expected
624        }
625
626        try {
627            subMap_startIncluded_endIncluded.headMap(endKey);
628            fail("should throw IllegalArgumentException");
629        } catch (IllegalArgumentException e) {
630            // Expected
631        }
632
633        SortedMap headMap = null;
634        endKey = new Integer(100).toString();
635        headMap = subMap_default.headMap(endKey);
636        assertEquals(0, headMap.size());
637
638        try {
639            headMap = subMap_startExcluded_endExcluded.headMap(endKey);
640            fail("should throw IllegalArgumentException");
641        } catch (IllegalArgumentException e) {
642            // Expected
643        }
644
645        try {
646            headMap = subMap_startExcluded_endIncluded.headMap(endKey);
647            fail("should throw IllegalArgumentException");
648        } catch (IllegalArgumentException e) {
649            // Expected
650        }
651
652        headMap = subMap_startIncluded_endExcluded.headMap(endKey);
653        assertEquals(0, headMap.size());
654
655        headMap = subMap_startIncluded_endIncluded.headMap(endKey);
656        assertEquals(0, headMap.size());
657
658        for (int i = 0, j = 101; i < 8; i++) {
659            endKey = new Integer(i + j).toString();
660            headMap = subMap_default.headMap(endKey);
661            assertEquals(i + 1, headMap.size());
662
663            headMap = subMap_startExcluded_endExcluded.headMap(endKey);
664            assertEquals(i, headMap.size());
665
666            headMap = subMap_startExcluded_endIncluded.headMap(endKey);
667            assertEquals(i, headMap.size());
668
669            headMap = subMap_startIncluded_endExcluded.headMap(endKey);
670            assertEquals(i + 1, headMap.size());
671
672            headMap = subMap_startIncluded_endIncluded.headMap(endKey);
673            assertEquals(i + 1, headMap.size());
674        }
675
676        endKey = new Integer(109).toString();
677        headMap = subMap_default.headMap(endKey);
678        assertEquals(9, headMap.size());
679
680        headMap = subMap_startExcluded_endExcluded.headMap(endKey);
681        assertEquals(8, headMap.size());
682
683        headMap = subMap_startExcluded_endIncluded.headMap(endKey);
684        assertEquals(8, headMap.size());
685
686        headMap = subMap_startIncluded_endExcluded.headMap(endKey);
687        assertEquals(9, headMap.size());
688
689        headMap = subMap_startIncluded_endIncluded.headMap(endKey);
690        assertEquals(9, headMap.size());
691
692        endKey = new Integer(110).toString();
693        try {
694            subMap_default.headMap(endKey);
695            fail("should throw IllegalArgumentException");
696        } catch (IllegalArgumentException e) {
697            // Expected
698        }
699
700        try {
701            subMap_startExcluded_endExcluded.headMap(endKey);
702            fail("should throw IllegalArgumentException");
703        } catch (IllegalArgumentException e) {
704            // Expected
705        }
706
707        try {
708            subMap_startExcluded_endIncluded.headMap(endKey);
709            fail("should throw IllegalArgumentException");
710        } catch (IllegalArgumentException e) {
711            // Expected
712        }
713
714        try {
715            subMap_startIncluded_endExcluded.headMap(endKey);
716            fail("should throw IllegalArgumentException");
717        } catch (IllegalArgumentException e) {
718            // Expected
719        }
720
721        try {
722            subMap_startIncluded_endIncluded.headMap(endKey);
723            fail("should throw IllegalArgumentException");
724        } catch (IllegalArgumentException e) {
725            // Expected
726        }
727
728        // With Comparator
729        endKey = new Integer(99).toString();
730        try {
731            subMap_default_comparator.headMap(endKey);
732            fail("should throw IllegalArgumentException");
733        } catch (IllegalArgumentException e) {
734            // Expected
735        }
736
737        try {
738            subMap_startExcluded_endExcluded_comparator.headMap(endKey);
739            fail("should throw IllegalArgumentException");
740        } catch (IllegalArgumentException e) {
741            // Expected
742        }
743
744        try {
745            subMap_startExcluded_endIncluded_comparator.headMap(endKey);
746            fail("should throw IllegalArgumentException");
747        } catch (IllegalArgumentException e) {
748            // Expected
749        }
750
751        try {
752            subMap_startIncluded_endExcluded_comparator.headMap(endKey);
753            fail("should throw IllegalArgumentException");
754        } catch (IllegalArgumentException e) {
755            // Expected
756        }
757
758        try {
759            subMap_startIncluded_endIncluded_comparator.headMap(endKey);
760            fail("should throw IllegalArgumentException");
761        } catch (IllegalArgumentException e) {
762            // Expected
763        }
764
765        headMap = null;
766        endKey = new Integer(100).toString();
767        headMap = subMap_default_comparator.headMap(endKey);
768        assertEquals(0, headMap.size());
769
770        try {
771            headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey);
772            fail("should throw IllegalArgumentException");
773        } catch (IllegalArgumentException e) {
774            // Expected
775        }
776
777        try {
778            headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey);
779            fail("should throw IllegalArgumentException");
780        } catch (IllegalArgumentException e) {
781            // Expected
782        }
783
784        headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey);
785        assertEquals(0, headMap.size());
786
787        headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey);
788        assertEquals(0, headMap.size());
789
790        for (int i = 0, j = 101; i < 8; i++) {
791            endKey = new Integer(i + j).toString();
792            headMap = subMap_default_comparator.headMap(endKey);
793            assertEquals(i + 1, headMap.size());
794
795            headMap = subMap_startExcluded_endExcluded_comparator
796                    .headMap(endKey);
797            assertEquals(i, headMap.size());
798
799            headMap = subMap_startExcluded_endIncluded_comparator
800                    .headMap(endKey);
801            assertEquals(i, headMap.size());
802
803            headMap = subMap_startIncluded_endExcluded_comparator
804                    .headMap(endKey);
805            assertEquals(i + 1, headMap.size());
806
807            headMap = subMap_startIncluded_endIncluded_comparator
808                    .headMap(endKey);
809            assertEquals(i + 1, headMap.size());
810        }
811
812        endKey = new Integer(108).toString();
813        headMap = subMap_default_comparator.headMap(endKey);
814        assertEquals(8, headMap.size());
815
816        headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey);
817        assertEquals(7, headMap.size());
818
819        headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey);
820        assertEquals(7, headMap.size());
821
822        headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey);
823        assertEquals(8, headMap.size());
824
825        headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey);
826        assertEquals(8, headMap.size());
827
828        endKey = new Integer(110).toString();
829        try {
830            subMap_default_comparator.headMap(endKey);
831            fail("should throw IllegalArgumentException");
832        } catch (IllegalArgumentException e) {
833            // Expected
834        }
835
836        try {
837            subMap_startExcluded_endExcluded_comparator.headMap(endKey);
838            fail("should throw IllegalArgumentException");
839        } catch (IllegalArgumentException e) {
840            // Expected
841        }
842
843        try {
844            subMap_startExcluded_endIncluded_comparator.headMap(endKey);
845            fail("should throw IllegalArgumentException");
846        } catch (IllegalArgumentException e) {
847            // Expected
848        }
849
850        try {
851            subMap_startIncluded_endExcluded_comparator.headMap(endKey);
852            fail("should throw IllegalArgumentException");
853        } catch (IllegalArgumentException e) {
854            // Expected
855        }
856
857        try {
858            subMap_startIncluded_endIncluded_comparator.headMap(endKey);
859            fail("should throw IllegalArgumentException");
860        } catch (IllegalArgumentException e) {
861            // Expected
862        }
863    }
864
865    public void test_SubMap_isEmpty() {
866        assertFalse(subMap_default.isEmpty());
867        assertFalse(subMap_startExcluded_endExcluded.isEmpty());
868        assertFalse(subMap_startExcluded_endIncluded.isEmpty());
869        assertFalse(subMap_startIncluded_endExcluded.isEmpty());
870        assertFalse(subMap_startIncluded_endIncluded.isEmpty());
871
872        Object startKey = new Integer(100);
873        Object endKey = startKey;
874        SortedMap subMap = tm.subMap(startKey.toString(), endKey.toString());
875        assertTrue(subMap.isEmpty());
876        subMap = subMap_default.subMap(startKey.toString(), endKey.toString());
877        assertTrue(subMap.isEmpty());
878        subMap = subMap_startIncluded_endExcluded.subMap(startKey.toString(),
879                endKey.toString());
880        assertTrue(subMap.isEmpty());
881        subMap = subMap_startIncluded_endIncluded.subMap(startKey.toString(),
882                endKey.toString());
883        assertTrue(subMap.isEmpty());
884
885        for (int i = 0, j = 101; i < 8; i++) {
886            startKey = i + j;
887            endKey = startKey;
888
889            subMap = subMap_default.subMap(startKey.toString(), endKey
890                    .toString());
891            assertTrue(subMap.isEmpty());
892
893            subMap = subMap_startExcluded_endExcluded.subMap(startKey
894                    .toString(), endKey.toString());
895            assertTrue(subMap.isEmpty());
896
897            subMap = subMap_startExcluded_endIncluded.subMap(startKey
898                    .toString(), endKey.toString());
899            assertTrue(subMap.isEmpty());
900
901            subMap = subMap_startIncluded_endExcluded.subMap(startKey
902                    .toString(), endKey.toString());
903            assertTrue(subMap.isEmpty());
904
905            subMap = subMap_startIncluded_endIncluded.subMap(startKey
906                    .toString(), endKey.toString());
907            assertTrue(subMap.isEmpty());
908        }
909
910        for (int i = 0, j = 101; i < 5; i++) {
911            startKey = i + j;
912            endKey = i + j + 4;
913
914            subMap = subMap_default.subMap(startKey.toString(), endKey
915                    .toString());
916            assertFalse(subMap.isEmpty());
917
918            subMap = subMap_startExcluded_endExcluded.subMap(startKey
919                    .toString(), endKey.toString());
920            assertFalse(subMap.isEmpty());
921
922            subMap = subMap_startExcluded_endIncluded.subMap(startKey
923                    .toString(), endKey.toString());
924            assertFalse(subMap.isEmpty());
925
926            subMap = subMap_startIncluded_endExcluded.subMap(startKey
927                    .toString(), endKey.toString());
928            assertFalse(subMap.isEmpty());
929
930            subMap = subMap_startIncluded_endIncluded.subMap(startKey
931                    .toString(), endKey.toString());
932            assertFalse(subMap.isEmpty());
933        }
934
935        startKey = new Integer(109).toString();
936        endKey = startKey;
937        subMap = tm.subMap(startKey.toString(), endKey.toString());
938        assertTrue(subMap.isEmpty());
939        subMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey);
940        assertTrue(subMap.isEmpty());
941        subMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey);
942        assertTrue(subMap.isEmpty());
943
944    }
945
946    public void test_SubMap_keySet() {
947        Set keySet = subMap_default.keySet();
948        assertFalse(keySet.isEmpty());
949        assertEquals(9, keySet.size());
950
951        keySet = subMap_startExcluded_endExcluded.entrySet();
952        assertFalse(keySet.isEmpty());
953        assertEquals(8, keySet.size());
954
955        keySet = subMap_startExcluded_endIncluded.entrySet();
956        assertFalse(keySet.isEmpty());
957        assertEquals(9, keySet.size());
958
959        keySet = subMap_startIncluded_endExcluded.entrySet();
960        assertFalse(keySet.isEmpty());
961        assertEquals(9, keySet.size());
962
963        keySet = subMap_startIncluded_endIncluded.entrySet();
964        assertFalse(keySet.isEmpty());
965        assertEquals(10, keySet.size());
966    }
967
968    public void test_SubMap_put() {
969        Integer value = new Integer(100);
970        int addValue = 5;
971
972        subMap_default.put(value.toString(), value + addValue);
973        assertEquals(value + addValue, subMap_default.get(value.toString()));
974
975        try {
976            subMap_startExcluded_endExcluded.put(value.toString(), value
977                    + addValue);
978            fail("should throw IllegalArgumentException");
979        } catch (IllegalArgumentException e) {
980            // Expected
981        }
982
983        try {
984            subMap_startExcluded_endIncluded.put(value.toString(), value
985                    + addValue);
986            fail("should throw IllegalArgumentException");
987        } catch (IllegalArgumentException e) {
988            // Expected
989        }
990
991        subMap_startIncluded_endExcluded
992                .put(value.toString(), value + addValue);
993        assertEquals(value + addValue, subMap_startIncluded_endExcluded
994                .get(value.toString()));
995
996        subMap_startIncluded_endIncluded
997                .put(value.toString(), value + addValue);
998        assertEquals(value + addValue, subMap_startIncluded_endIncluded
999                .get(value.toString()));
1000
1001        value = new Integer(109);
1002        try {
1003            subMap_default.put(value.toString(), value + addValue);
1004            fail("should throw IllegalArgumentException");
1005        } catch (IllegalArgumentException e) {
1006            // Expected
1007        }
1008
1009        try {
1010            subMap_startExcluded_endExcluded.put(value.toString(), value
1011                    + addValue);
1012            fail("should throw IllegalArgumentException");
1013        } catch (IllegalArgumentException e) {
1014            // Expected
1015        }
1016
1017        subMap_startExcluded_endIncluded
1018                .put(value.toString(), value + addValue);
1019        assertEquals(value + addValue, subMap_startExcluded_endIncluded
1020                .get(value.toString()));
1021
1022        try {
1023            subMap_startIncluded_endExcluded.put(value.toString(), value
1024                    + addValue);
1025            fail("should throw IllegalArgumentException");
1026        } catch (IllegalArgumentException e) {
1027            // Expected
1028        }
1029
1030        subMap_startIncluded_endIncluded
1031                .put(value.toString(), value + addValue);
1032        assertEquals(value + addValue, subMap_startIncluded_endIncluded
1033                .get(value.toString()));
1034    }
1035
1036    public void test_SubMap_remove() {
1037        Integer value = new Integer(100);
1038
1039        subMap_default.remove(value.toString());
1040        assertNull(subMap_default.get(value.toString()));
1041
1042        subMap_startExcluded_endExcluded.remove(value.toString());
1043        assertNull(subMap_startExcluded_endExcluded.get(value.toString()));
1044
1045        subMap_startExcluded_endIncluded.remove(value.toString());
1046        assertNull(subMap_startExcluded_endIncluded.get(value.toString()));
1047
1048        subMap_startIncluded_endExcluded.remove(value.toString());
1049        assertNull(subMap_startIncluded_endExcluded.get(value.toString()));
1050
1051        subMap_startIncluded_endIncluded.remove(value.toString());
1052        assertNull(subMap_startIncluded_endIncluded.get(value.toString()));
1053
1054        value = new Integer(109);
1055        subMap_default.remove(value.toString());
1056        assertNull(subMap_default.get(value.toString()));
1057
1058        subMap_startExcluded_endExcluded.remove(value.toString());
1059        assertNull(subMap_startExcluded_endExcluded.get(value.toString()));
1060
1061        subMap_startExcluded_endIncluded.remove(value.toString());
1062        assertNull(subMap_startExcluded_endIncluded.get(value.toString()));
1063
1064        subMap_startIncluded_endExcluded.remove(value.toString());
1065        assertNull(subMap_startIncluded_endExcluded.get(value.toString()));
1066
1067        subMap_startIncluded_endIncluded.remove(value.toString());
1068        assertNull(subMap_startIncluded_endIncluded.get(value.toString()));
1069    }
1070
1071    public void test_SubMap_subMap_NoComparator() {
1072        String startKey = new Integer[100].toString();
1073        String endKey = new Integer[100].toString();
1074        try {
1075            subMap_default.subMap(startKey, endKey);
1076            fail("should throw IllegalArgumentException");
1077        } catch (IllegalArgumentException e) {
1078            // Expected
1079        }
1080
1081        try {
1082            subMap_startExcluded_endExcluded.subMap(startKey, endKey);
1083            fail("should throw IllegalArgumentException");
1084        } catch (IllegalArgumentException e) {
1085            // Expected
1086        }
1087
1088        try {
1089            subMap_startExcluded_endIncluded.subMap(startKey, endKey);
1090            fail("should throw IllegalArgumentException");
1091        } catch (IllegalArgumentException e) {
1092            // Expected
1093        }
1094
1095        try {
1096            subMap_startIncluded_endExcluded.subMap(startKey, endKey);
1097            fail("should throw IllegalArgumentException");
1098        } catch (IllegalArgumentException e) {
1099            // Expected
1100        }
1101
1102        try {
1103            subMap_startIncluded_endIncluded.subMap(startKey, endKey);
1104            fail("should throw IllegalArgumentException");
1105        } catch (IllegalArgumentException e) {
1106            // Expected
1107        }
1108
1109        SortedMap subSubMap = null;
1110        for (int i = 101; i < 109; i++) {
1111            startKey = new Integer(i).toString();
1112            endKey = startKey;
1113
1114            subSubMap = subMap_default.subMap(startKey, endKey);
1115            assertEquals(0, subSubMap.size());
1116
1117            subSubMap = subMap_startExcluded_endExcluded.subMap(startKey,
1118                    endKey);
1119            assertEquals(0, subSubMap.size());
1120
1121            subSubMap = subMap_startExcluded_endIncluded.subMap(startKey,
1122                    endKey);
1123            assertEquals(0, subSubMap.size());
1124
1125            subSubMap = subMap_startIncluded_endExcluded.subMap(startKey,
1126                    endKey);
1127            assertEquals(0, subSubMap.size());
1128
1129            subSubMap = subMap_startIncluded_endIncluded.subMap(startKey,
1130                    endKey);
1131            assertEquals(0, subSubMap.size());
1132        }
1133
1134        for (int i = 101, j = 5; i < 105; i++) {
1135            startKey = new Integer(i).toString();
1136            endKey = new Integer(i + j).toString();
1137
1138            subSubMap = subMap_default.subMap(startKey, endKey);
1139            assertEquals(j, subSubMap.size());
1140
1141            subSubMap = subMap_startExcluded_endExcluded.subMap(startKey,
1142                    endKey);
1143            assertEquals(j, subSubMap.size());
1144
1145            subSubMap = subMap_startExcluded_endIncluded.subMap(startKey,
1146                    endKey);
1147            assertEquals(j, subSubMap.size());
1148
1149            subSubMap = subMap_startIncluded_endExcluded.subMap(startKey,
1150                    endKey);
1151            assertEquals(j, subSubMap.size());
1152
1153            subSubMap = subMap_startIncluded_endIncluded.subMap(startKey,
1154                    endKey);
1155            assertEquals(j, subSubMap.size());
1156        }
1157
1158        startKey = new Integer(108).toString();
1159        endKey = new Integer(109).toString();
1160
1161        subSubMap = subMap_default.subMap(startKey, endKey);
1162        assertEquals(1, subSubMap.size());
1163
1164        subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, endKey);
1165        assertEquals(1, subSubMap.size());
1166
1167        subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey);
1168        assertEquals(1, subSubMap.size());
1169
1170        subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, endKey);
1171        assertEquals(1, subSubMap.size());
1172
1173        subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey);
1174        assertEquals(1, subSubMap.size());
1175
1176        startKey = new Integer(109).toString();
1177        endKey = new Integer(109).toString();
1178
1179        try {
1180            subMap_default.subMap(startKey, endKey);
1181            fail("should throw IllegalArgumentException");
1182        } catch (IllegalArgumentException e) {
1183            // Expected
1184        }
1185
1186        try {
1187            subMap_startExcluded_endExcluded.subMap(startKey, endKey);
1188            fail("should throw IllegalArgumentException");
1189        } catch (IllegalArgumentException e) {
1190            // Expected
1191        }
1192
1193        subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey);
1194        assertEquals(0, subSubMap.size());
1195
1196        try {
1197            subMap_startIncluded_endExcluded.subMap(startKey, endKey);
1198            fail("should throw IllegalArgumentException");
1199        } catch (IllegalArgumentException e) {
1200            // Expected
1201        }
1202
1203        subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey);
1204        assertEquals(0, subSubMap.size());
1205    }
1206
1207    public void test_SubMap_subMap_Comparator() {
1208        String startKey = new Integer[100].toString();
1209        String endKey = new Integer[100].toString();
1210        try {
1211            subMap_default_comparator.subMap(startKey, endKey);
1212            fail("should throw IllegalArgumentException");
1213        } catch (IllegalArgumentException e) {
1214            // Expected
1215        }
1216
1217        try {
1218            subMap_startExcluded_endExcluded_comparator
1219                    .subMap(startKey, endKey);
1220            fail("should throw IllegalArgumentException");
1221        } catch (IllegalArgumentException e) {
1222            // Expected
1223        }
1224
1225        try {
1226            subMap_startExcluded_endIncluded_comparator
1227                    .subMap(startKey, endKey);
1228            fail("should throw IllegalArgumentException");
1229        } catch (IllegalArgumentException e) {
1230            // Expected
1231        }
1232
1233        try {
1234            subMap_startIncluded_endExcluded_comparator
1235                    .subMap(startKey, endKey);
1236            fail("should throw IllegalArgumentException");
1237        } catch (IllegalArgumentException e) {
1238            // Expected
1239        }
1240
1241        try {
1242            subMap_startIncluded_endIncluded_comparator
1243                    .subMap(startKey, endKey);
1244            fail("should throw IllegalArgumentException");
1245        } catch (IllegalArgumentException e) {
1246            // Expected
1247        }
1248
1249        SortedMap subSubMap = null;
1250        for (int i = 101; i < 109; i++) {
1251            startKey = new Integer(i).toString();
1252            endKey = startKey;
1253
1254            subSubMap = subMap_default_comparator.subMap(startKey, endKey);
1255            assertEquals(0, subSubMap.size());
1256
1257            subSubMap = subMap_startExcluded_endExcluded_comparator.subMap(
1258                    startKey, endKey);
1259            assertEquals(0, subSubMap.size());
1260
1261            subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1262                    startKey, endKey);
1263            assertEquals(0, subSubMap.size());
1264
1265            subSubMap = subMap_startIncluded_endExcluded_comparator.subMap(
1266                    startKey, endKey);
1267            assertEquals(0, subSubMap.size());
1268
1269            subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1270                    startKey, endKey);
1271            assertEquals(0, subSubMap.size());
1272        }
1273
1274        for (int i = 101, j = 5; i < 105; i++) {
1275            startKey = new Integer(i).toString();
1276            endKey = new Integer(i + j).toString();
1277
1278            subSubMap = subMap_default_comparator.subMap(startKey, endKey);
1279            assertEquals(j, subSubMap.size());
1280
1281            subSubMap = subMap_startExcluded_endExcluded_comparator.subMap(
1282                    startKey, endKey);
1283            assertEquals(j, subSubMap.size());
1284
1285            subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1286                    startKey, endKey);
1287            assertEquals(j, subSubMap.size());
1288
1289            subSubMap = subMap_startIncluded_endExcluded_comparator.subMap(
1290                    startKey, endKey);
1291            assertEquals(j, subSubMap.size());
1292
1293            subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1294                    startKey, endKey);
1295            assertEquals(j, subSubMap.size());
1296        }
1297
1298        startKey = new Integer(108).toString();
1299        endKey = new Integer(109).toString();
1300
1301        subSubMap = subMap_default_comparator.subMap(startKey, endKey);
1302        assertEquals(1, subSubMap.size());
1303
1304        subSubMap = subMap_startExcluded_endExcluded_comparator.subMap(
1305                startKey, endKey);
1306        assertEquals(1, subSubMap.size());
1307
1308        subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1309                startKey, endKey);
1310        assertEquals(1, subSubMap.size());
1311
1312        subSubMap = subMap_startIncluded_endExcluded_comparator.subMap(
1313                startKey, endKey);
1314        assertEquals(1, subSubMap.size());
1315
1316        subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1317                startKey, endKey);
1318        assertEquals(1, subSubMap.size());
1319
1320        startKey = new Integer(109).toString();
1321        endKey = new Integer(109).toString();
1322
1323        try {
1324            subMap_default_comparator.subMap(startKey, endKey);
1325            fail("should throw IllegalArgumentException");
1326        } catch (IllegalArgumentException e) {
1327            // Expected
1328        }
1329
1330        try {
1331            subMap_startExcluded_endExcluded_comparator
1332                    .subMap(startKey, endKey);
1333            fail("should throw IllegalArgumentException");
1334        } catch (IllegalArgumentException e) {
1335            // Expected
1336        }
1337
1338        subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1339                startKey, endKey);
1340        assertEquals(0, subSubMap.size());
1341
1342        try {
1343            subMap_startIncluded_endExcluded_comparator
1344                    .subMap(startKey, endKey);
1345            fail("should throw IllegalArgumentException");
1346        } catch (IllegalArgumentException e) {
1347            // Expected
1348        }
1349
1350        subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1351                startKey, endKey);
1352        assertEquals(0, subSubMap.size());
1353    }
1354
1355    public void test_SubMap_tailMap() {
1356        String startKey = new Integer(99).toString();
1357        try {
1358            subMap_default.tailMap(startKey);
1359            fail("should throw IllegalArgumentException");
1360        } catch (IllegalArgumentException e) {
1361            // Expected
1362        }
1363
1364        try {
1365            subMap_startExcluded_endExcluded.tailMap(startKey);
1366            fail("should throw IllegalArgumentException");
1367        } catch (IllegalArgumentException e) {
1368            // Expected
1369        }
1370
1371        try {
1372            subMap_startExcluded_endIncluded.tailMap(startKey);
1373            fail("should throw IllegalArgumentException");
1374        } catch (IllegalArgumentException e) {
1375            // Expected
1376        }
1377
1378        try {
1379            subMap_startIncluded_endExcluded.tailMap(startKey);
1380            fail("should throw IllegalArgumentException");
1381        } catch (IllegalArgumentException e) {
1382            // Expected
1383        }
1384
1385        try {
1386            subMap_startIncluded_endIncluded.tailMap(startKey);
1387            fail("should throw IllegalArgumentException");
1388        } catch (IllegalArgumentException e) {
1389            // Expected
1390        }
1391        SortedMap tailMap = null;
1392
1393        startKey = new Integer(100).toString();
1394        tailMap = subMap_default.tailMap(startKey);
1395        assertEquals(9, tailMap.size());
1396
1397        try {
1398            subMap_startExcluded_endExcluded.tailMap(startKey);
1399            fail("should throw IllegalArgumentException");
1400        } catch (IllegalArgumentException e) {
1401            // Expected
1402        }
1403
1404        try {
1405            subMap_startExcluded_endIncluded.tailMap(startKey);
1406            fail("should throw IllegalArgumentException");
1407        } catch (IllegalArgumentException e) {
1408            // Expected
1409        }
1410
1411        tailMap = subMap_startIncluded_endExcluded.tailMap(startKey);
1412        assertEquals(9, tailMap.size());
1413
1414        tailMap = subMap_startIncluded_endIncluded.tailMap(startKey);
1415        assertEquals(10, tailMap.size());
1416
1417        for (int i = 0, j = 101, end = 8; i < end; i++) {
1418            startKey = new Integer(i + j).toString();
1419            tailMap = subMap_default.tailMap(startKey);
1420            assertEquals(end - i, tailMap.size());
1421
1422            tailMap = subMap_startExcluded_endExcluded.tailMap(startKey);
1423            assertEquals(end - i, tailMap.size());
1424
1425            tailMap = subMap_startExcluded_endIncluded.tailMap(startKey);
1426            assertEquals(end - i + 1, tailMap.size());
1427
1428            tailMap = subMap_startIncluded_endExcluded.tailMap(startKey);
1429            assertEquals(end - i, tailMap.size());
1430
1431            tailMap = subMap_startIncluded_endIncluded.tailMap(startKey);
1432            assertEquals(end - i + 1, tailMap.size());
1433        }
1434
1435        startKey = new Integer(109).toString();
1436        try {
1437            subMap_default.tailMap(startKey);
1438            fail("should throw IllegalArgumentException");
1439        } catch (IllegalArgumentException e) {
1440            // Expected
1441        }
1442        try {
1443            subMap_startExcluded_endExcluded.tailMap(startKey);
1444            fail("should throw IllegalArgumentException");
1445        } catch (IllegalArgumentException e) {
1446            // Expected
1447        }
1448
1449        tailMap = subMap_startExcluded_endIncluded.tailMap(startKey);
1450        assertEquals(1, tailMap.size());
1451
1452        try {
1453            subMap_startIncluded_endExcluded.tailMap(startKey);
1454            fail("should throw IllegalArgumentException");
1455        } catch (IllegalArgumentException e) {
1456            // Expected
1457        }
1458
1459        tailMap = subMap_startIncluded_endIncluded.tailMap(startKey);
1460        assertEquals(1, tailMap.size());
1461
1462        startKey = new Integer(110).toString();
1463        try {
1464            subMap_default.tailMap(startKey);
1465            fail("should throw IllegalArgumentException");
1466        } catch (IllegalArgumentException e) {
1467            // Expected
1468        }
1469
1470        try {
1471            subMap_startExcluded_endExcluded.tailMap(startKey);
1472            fail("should throw IllegalArgumentException");
1473        } catch (IllegalArgumentException e) {
1474            // Expected
1475        }
1476        try {
1477            subMap_startExcluded_endIncluded.tailMap(startKey);
1478            fail("should throw IllegalArgumentException");
1479        } catch (IllegalArgumentException e) {
1480            // Expected
1481        }
1482        try {
1483            subMap_startIncluded_endExcluded.tailMap(startKey);
1484            fail("should throw IllegalArgumentException");
1485        } catch (IllegalArgumentException e) {
1486            // Expected
1487        }
1488        try {
1489            subMap_startIncluded_endIncluded.tailMap(startKey);
1490            fail("should throw IllegalArgumentException");
1491        } catch (IllegalArgumentException e) {
1492            // Expected
1493        }
1494    }
1495
1496    public void test_SubMap_values() {
1497        Collection values = subMap_default.values();
1498
1499        assertFalse(values.isEmpty());
1500        assertTrue(values.contains(100));
1501        for (int i = 101; i < 109; i++) {
1502            assertTrue(values.contains(i));
1503        }
1504        assertFalse(values.contains(109));
1505
1506        values = subMap_startExcluded_endExcluded.values();
1507        assertFalse(values.isEmpty());
1508        assertFalse(values.contains(100));
1509        for (int i = 101; i < 109; i++) {
1510            assertTrue(values.contains(i));
1511        }
1512        assertFalse(values.contains(109));
1513
1514        values = subMap_startExcluded_endIncluded.values();
1515        assertFalse(values.isEmpty());
1516        assertFalse(values.contains(100));
1517        for (int i = 101; i < 109; i++) {
1518            assertTrue(values.contains(i));
1519        }
1520        assertTrue(values.contains(109));
1521
1522        values = subMap_startIncluded_endExcluded.values();
1523        assertFalse(values.isEmpty());
1524        assertTrue(values.contains(100));
1525        for (int i = 101; i < 109; i++) {
1526            assertTrue(values.contains(i));
1527        }
1528        assertFalse(values.contains(109));
1529
1530        values = subMap_startIncluded_endIncluded.values();
1531        assertFalse(values.isEmpty());
1532        assertTrue(values.contains(100));
1533        for (int i = 100; i < 109; i++) {
1534            assertTrue(values.contains(i));
1535        }
1536        assertTrue(values.contains(109));
1537    }
1538
1539    public void test_SubMap_size() {
1540        assertEquals(9, subMap_default.size());
1541        assertEquals(8, subMap_startExcluded_endExcluded.size());
1542        assertEquals(9, subMap_startExcluded_endIncluded.size());
1543        assertEquals(9, subMap_startIncluded_endExcluded.size());
1544        assertEquals(10, subMap_startIncluded_endIncluded.size());
1545
1546        assertEquals(9, subMap_default_comparator.size());
1547        assertEquals(8, subMap_startExcluded_endExcluded_comparator.size());
1548        assertEquals(9, subMap_startExcluded_endIncluded_comparator.size());
1549        assertEquals(9, subMap_startIncluded_endExcluded_comparator.size());
1550        assertEquals(10, subMap_startIncluded_endIncluded_comparator.size());
1551    }
1552
1553    public void test_SubMap_readObject() throws Exception {
1554        // SerializationTest.verifySelf(subMap_default);
1555        // SerializationTest.verifySelf(subMap_startExcluded_endExcluded);
1556        // SerializationTest.verifySelf(subMap_startExcluded_endIncluded);
1557        // SerializationTest.verifySelf(subMap_startIncluded_endExcluded);
1558        // SerializationTest.verifySelf(subMap_startIncluded_endIncluded);
1559    }
1560
1561    public void test_AscendingSubMap_ceilingEntry() {
1562        String key = new Integer(99).toString();
1563        assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key));
1564        assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key));
1565        assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key));
1566        assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key));
1567
1568        key = new Integer(100).toString();
1569        assertEquals(101, navigableMap_startExcluded_endExcluded.ceilingEntry(
1570                key).getValue());
1571        assertEquals(101, navigableMap_startExcluded_endIncluded.ceilingEntry(
1572                key).getValue());
1573        assertEquals(100, navigableMap_startIncluded_endExcluded.ceilingEntry(
1574                key).getValue());
1575        assertEquals(100, navigableMap_startIncluded_endIncluded.ceilingEntry(
1576                key).getValue());
1577
1578        for (int i = 101; i < 109; i++) {
1579            key = new Integer(i).toString();
1580            assertEquals(i, navigableMap_startExcluded_endExcluded
1581                    .ceilingEntry(key).getValue());
1582            assertEquals(i, navigableMap_startExcluded_endIncluded
1583                    .ceilingEntry(key).getValue());
1584            assertEquals(i, navigableMap_startIncluded_endExcluded
1585                    .ceilingEntry(key).getValue());
1586            assertEquals(i, navigableMap_startIncluded_endIncluded
1587                    .ceilingEntry(key).getValue());
1588
1589        }
1590
1591        key = new Integer(109).toString();
1592        assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key));
1593        assertEquals(109, navigableMap_startExcluded_endIncluded.ceilingEntry(
1594                key).getValue());
1595        assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key));
1596        assertEquals(109, navigableMap_startIncluded_endIncluded.ceilingEntry(
1597                key).getValue());
1598
1599        key = new Integer(110).toString();
1600        assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key));
1601        assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key));
1602        assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key));
1603        assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key));
1604    }
1605
1606    public void test_AscendingSubMap_descendingMap() {
1607        NavigableMap descendingMap = navigableMap_startExcluded_endExcluded
1608                .descendingMap();
1609        assertEquals(navigableMap_startExcluded_endExcluded.size(),
1610                descendingMap.size());
1611        assertNotNull(descendingMap.comparator());
1612
1613        assertEquals(navigableMap_startExcluded_endExcluded.firstKey(),
1614                descendingMap.lastKey());
1615        assertEquals(navigableMap_startExcluded_endExcluded.firstEntry(),
1616                descendingMap.lastEntry());
1617
1618        assertEquals(navigableMap_startExcluded_endExcluded.lastKey(),
1619                descendingMap.firstKey());
1620        assertEquals(navigableMap_startExcluded_endExcluded.lastEntry(),
1621                descendingMap.firstEntry());
1622
1623        descendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
1624        assertEquals(navigableMap_startExcluded_endIncluded.size(),
1625                descendingMap.size());
1626        assertNotNull(descendingMap.comparator());
1627
1628        assertEquals(navigableMap_startExcluded_endIncluded.firstKey(),
1629                descendingMap.lastKey());
1630        assertEquals(navigableMap_startExcluded_endIncluded.firstEntry(),
1631                descendingMap.lastEntry());
1632
1633        assertEquals(navigableMap_startExcluded_endIncluded.lastKey(),
1634                descendingMap.firstKey());
1635        assertEquals(navigableMap_startExcluded_endIncluded.lastEntry(),
1636                descendingMap.firstEntry());
1637
1638        descendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
1639        assertEquals(navigableMap_startIncluded_endExcluded.size(),
1640                descendingMap.size());
1641        assertNotNull(descendingMap.comparator());
1642
1643        assertEquals(navigableMap_startIncluded_endExcluded.firstKey(),
1644                descendingMap.lastKey());
1645        assertEquals(navigableMap_startIncluded_endExcluded.firstEntry(),
1646                descendingMap.lastEntry());
1647
1648        assertEquals(navigableMap_startIncluded_endExcluded.lastKey(),
1649                descendingMap.firstKey());
1650        assertEquals(navigableMap_startIncluded_endExcluded.lastEntry(),
1651                descendingMap.firstEntry());
1652
1653        descendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
1654        assertEquals(navigableMap_startIncluded_endIncluded.size(),
1655                descendingMap.size());
1656        assertNotNull(descendingMap.comparator());
1657
1658        assertEquals(navigableMap_startIncluded_endIncluded.firstKey(),
1659                descendingMap.lastKey());
1660        assertEquals(navigableMap_startIncluded_endIncluded.firstEntry(),
1661                descendingMap.lastEntry());
1662
1663        assertEquals(navigableMap_startIncluded_endIncluded.lastKey(),
1664                descendingMap.firstKey());
1665        assertEquals(navigableMap_startIncluded_endIncluded.lastEntry(),
1666                descendingMap.firstEntry());
1667    }
1668
1669    public void test_AscendingSubMap_floorEntry() {
1670        String key = new Integer(99).toString();
1671        assertEquals(108, navigableMap_startExcluded_endExcluded
1672                .floorEntry(key).getValue());
1673        assertEquals(109, navigableMap_startExcluded_endIncluded
1674                .floorEntry(key).getValue());
1675        assertEquals(108, navigableMap_startIncluded_endExcluded
1676                .floorEntry(key).getValue());
1677        assertEquals(109, navigableMap_startIncluded_endIncluded
1678                .floorEntry(key).getValue());
1679
1680        key = new Integer(100).toString();
1681        assertNull(navigableMap_startExcluded_endExcluded.floorEntry(key));
1682        assertNull(navigableMap_startExcluded_endIncluded.floorEntry(key));
1683        assertEquals(100, navigableMap_startIncluded_endExcluded
1684                .floorEntry(key).getValue());
1685        assertEquals(100, navigableMap_startIncluded_endIncluded
1686                .floorEntry(key).getValue());
1687
1688        for (int i = 101; i < 109; i++) {
1689            key = new Integer(i).toString();
1690            assertEquals(i, navigableMap_startExcluded_endExcluded.floorEntry(
1691                    key).getValue());
1692            assertEquals(i, navigableMap_startExcluded_endIncluded.floorEntry(
1693                    key).getValue());
1694            assertEquals(i, navigableMap_startIncluded_endExcluded.floorEntry(
1695                    key).getValue());
1696            assertEquals(i, navigableMap_startIncluded_endIncluded.floorEntry(
1697                    key).getValue());
1698
1699        }
1700
1701        key = new Integer(109).toString();
1702        assertEquals(108, navigableMap_startExcluded_endExcluded
1703                .floorEntry(key).getValue());
1704        assertEquals(109, navigableMap_startExcluded_endIncluded
1705                .floorEntry(key).getValue());
1706        assertEquals(108, navigableMap_startIncluded_endExcluded
1707                .floorEntry(key).getValue());
1708        assertEquals(109, navigableMap_startIncluded_endIncluded
1709                .floorEntry(key).getValue());
1710
1711        key = new Integer(110).toString();
1712        assertEquals(108, navigableMap_startExcluded_endExcluded
1713                .floorEntry(key).getValue());
1714        assertEquals(109, navigableMap_startExcluded_endIncluded
1715                .floorEntry(key).getValue());
1716        assertEquals(108, navigableMap_startIncluded_endExcluded
1717                .floorEntry(key).getValue());
1718        assertEquals(109, navigableMap_startIncluded_endIncluded
1719                .floorEntry(key).getValue());
1720    }
1721
1722    public void test_AscendingSubMap_pollFirstEntry() {
1723        assertEquals(101, navigableMap_startExcluded_endExcluded
1724                .pollFirstEntry().getValue());
1725        assertEquals(102, navigableMap_startExcluded_endIncluded
1726                .pollFirstEntry().getValue());
1727        assertEquals(100, navigableMap_startIncluded_endExcluded
1728                .pollFirstEntry().getValue());
1729        assertEquals(103, navigableMap_startIncluded_endIncluded
1730                .pollFirstEntry().getValue());
1731    }
1732
1733    public void test_AscendingSubMap_pollLastEntry() {
1734        assertEquals(108, navigableMap_startExcluded_endExcluded
1735                .pollLastEntry().getValue());
1736        assertEquals(109, navigableMap_startExcluded_endIncluded
1737                .pollLastEntry().getValue());
1738        assertEquals(107, navigableMap_startIncluded_endExcluded
1739                .pollLastEntry().getValue());
1740        assertEquals(106, navigableMap_startIncluded_endIncluded
1741                .pollLastEntry().getValue());
1742    }
1743
1744    public void test_AscendingSubMap_entrySet() {
1745        assertEquals(8, navigableMap_startExcluded_endExcluded.entrySet()
1746                .size());
1747        assertEquals(9, navigableMap_startExcluded_endIncluded.entrySet()
1748                .size());
1749        assertEquals(9, navigableMap_startIncluded_endExcluded.entrySet()
1750                .size());
1751        assertEquals(10, navigableMap_startIncluded_endIncluded.entrySet()
1752                .size());
1753    }
1754
1755    public void test_AscendingSubMap_subMap() {
1756        Set entrySet;
1757        Entry startEntry, endEntry;
1758        int startIndex, endIndex;
1759        SortedMap subMap;
1760        Iterator subMapSetIterator;
1761
1762        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
1763        Iterator startIterator = entrySet.iterator();
1764        while (startIterator.hasNext()) {
1765            startEntry = (Entry) startIterator.next();
1766            startIndex = (Integer) startEntry.getValue();
1767            Iterator endIterator = entrySet.iterator();
1768            while (endIterator.hasNext()) {
1769                endEntry = (Entry) endIterator.next();
1770                endIndex = (Integer) endEntry.getValue();
1771
1772                if (startIndex > endIndex) {
1773                    try {
1774                        navigableMap_startExcluded_endExcluded.subMap(
1775                                startEntry.getKey(), endEntry.getKey());
1776                        fail("should throw IllegalArgumentException");
1777                    } catch (IllegalArgumentException e) {
1778                        // Expected
1779                    }
1780                    try {
1781                        navigableMap_startExcluded_endExcluded.subMap(
1782                                startEntry.getKey(), false, endEntry.getKey(),
1783                                false);
1784                        fail("should throw IllegalArgumentException");
1785                    } catch (IllegalArgumentException e) {
1786                        // Expected
1787                    }
1788                    try {
1789                        navigableMap_startExcluded_endExcluded.subMap(
1790                                startEntry.getKey(), false, endEntry.getKey(),
1791                                true);
1792                        fail("should throw IllegalArgumentException");
1793                    } catch (IllegalArgumentException e) {
1794                        // Expected
1795                    }
1796                    try {
1797                        navigableMap_startExcluded_endExcluded.subMap(
1798                                startEntry.getKey(), true, endEntry.getKey(),
1799                                false);
1800                        fail("should throw IllegalArgumentException");
1801                    } catch (IllegalArgumentException e) {
1802                        // Expected
1803                    }
1804                    try {
1805                        navigableMap_startExcluded_endExcluded.subMap(
1806                                startEntry.getKey(), true, endEntry.getKey(),
1807                                true);
1808                        fail("should throw IllegalArgumentException");
1809                    } catch (IllegalArgumentException e) {
1810                        // Expected
1811                    }
1812                } else {
1813                    subMap = navigableMap_startExcluded_endExcluded.subMap(
1814                            startEntry.getKey(), endEntry.getKey());
1815                    subMapSetIterator = subMap.entrySet().iterator();
1816                    for (int index = startIndex; index < endIndex; index++) {
1817                        assertEquals(index, ((Entry) subMapSetIterator.next())
1818                                .getValue());
1819                    }
1820
1821                    subMap = navigableMap_startExcluded_endExcluded.subMap(
1822                            startEntry.getKey(), false, endEntry.getKey(),
1823                            false);
1824                    subMapSetIterator = subMap.entrySet().iterator();
1825                    for (int index = startIndex + 1; index < endIndex; index++) {
1826                        assertEquals(index, ((Entry) subMapSetIterator.next())
1827                                .getValue());
1828                    }
1829
1830                    subMap = navigableMap_startExcluded_endExcluded
1831                            .subMap(startEntry.getKey(), false, endEntry
1832                                    .getKey(), true);
1833                    subMapSetIterator = subMap.entrySet().iterator();
1834                    for (int index = startIndex + 1; index < endIndex; index++) {
1835                        assertEquals(index, ((Entry) subMapSetIterator.next())
1836                                .getValue());
1837                    }
1838
1839                    subMap = navigableMap_startExcluded_endExcluded
1840                            .subMap(startEntry.getKey(), true, endEntry
1841                                    .getKey(), false);
1842                    subMapSetIterator = subMap.entrySet().iterator();
1843                    for (int index = startIndex; index < endIndex; index++) {
1844                        assertEquals(index, ((Entry) subMapSetIterator.next())
1845                                .getValue());
1846                    }
1847
1848                    subMap = navigableMap_startExcluded_endExcluded.subMap(
1849                            startEntry.getKey(), true, endEntry.getKey(), true);
1850                    subMapSetIterator = subMap.entrySet().iterator();
1851                    for (int index = startIndex; index <= endIndex; index++) {
1852                        assertEquals(index, ((Entry) subMapSetIterator.next())
1853                                .getValue());
1854                    }
1855                }
1856            }
1857        }
1858    }
1859
1860    public void test_DescendingSubMap_ceilingEntry() {
1861        NavigableMap decendingMap = tm.descendingMap();
1862        String key = new Integer(-1).toString();
1863        assertNull(decendingMap.ceilingEntry(key));
1864        for (int i = 0; i < objArray.length; i++) {
1865            key = objArray[i].toString();
1866            assertEquals(objArray[i], decendingMap.ceilingEntry(key).getValue());
1867        }
1868        key = new Integer(1000).toString();
1869        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1870        key = new Integer(1001).toString();
1871        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1872
1873        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
1874        key = new Integer(100).toString();
1875        assertNull(decendingMap.ceilingEntry(key));
1876        for (int i = 101; i < 109; i++) {
1877            key = new Integer(i).toString();
1878            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1879        }
1880        key = new Integer(109).toString();
1881        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1882
1883        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
1884        key = new Integer(100).toString();
1885        assertNull(decendingMap.ceilingEntry(key));
1886        for (int i = 101; i < 109; i++) {
1887            key = new Integer(i).toString();
1888            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1889        }
1890        key = new Integer(109).toString();
1891        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1892
1893        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
1894        key = new Integer(100).toString();
1895        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1896        for (int i = 101; i < 109; i++) {
1897            key = new Integer(i).toString();
1898            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1899        }
1900        key = new Integer(109).toString();
1901        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1902
1903        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
1904        key = new Integer(100).toString();
1905        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1906        for (int i = 101; i < 109; i++) {
1907            key = new Integer(i).toString();
1908            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1909        }
1910        key = new Integer(109).toString();
1911        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1912
1913        // With Comparator
1914        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
1915                .descendingMap();
1916        key = new Integer(100).toString();
1917        assertNull(decendingMap.ceilingEntry(key));
1918        for (int i = 101; i < 109; i++) {
1919            key = new Integer(i).toString();
1920            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1921        }
1922        key = new Integer(109).toString();
1923        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1924
1925        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
1926                .descendingMap();
1927        key = new Integer(100).toString();
1928        assertNull(decendingMap.ceilingEntry(key));
1929        for (int i = 101; i < 109; i++) {
1930            key = new Integer(i).toString();
1931            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1932        }
1933        key = new Integer(109).toString();
1934        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1935
1936        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
1937                .descendingMap();
1938        key = new Integer(100).toString();
1939        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1940        for (int i = 101; i < 109; i++) {
1941            key = new Integer(i).toString();
1942            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1943        }
1944        key = new Integer(109).toString();
1945        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1946
1947        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
1948                .descendingMap();
1949        key = new Integer(100).toString();
1950        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1951        for (int i = 101; i < 109; i++) {
1952            key = new Integer(i).toString();
1953            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1954        }
1955        key = new Integer(109).toString();
1956        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1957    }
1958
1959    public void test_DescendingSubMap_descendingMap() {
1960        NavigableMap decendingMap = tm.descendingMap();
1961        NavigableMap decendingDecendingMap = decendingMap.descendingMap();
1962        assertEquals(decendingMap, decendingDecendingMap);
1963
1964        NavigableMap decendingMapHeadMap = decendingMap.headMap(
1965                new Integer(990).toString(), false);
1966        NavigableMap decendingDecendingHeadMap = decendingMapHeadMap
1967                .descendingMap();
1968        assertNotNull(decendingMapHeadMap);
1969        assertNotNull(decendingDecendingHeadMap);
1970        assertEquals(decendingMapHeadMap, decendingDecendingHeadMap);
1971
1972        NavigableMap decendingMapTailMap = decendingMap.tailMap(
1973                new Integer(990).toString(), false);
1974        NavigableMap decendingDecendingTailMap = decendingMapTailMap
1975                .descendingMap();
1976        assertNotNull(decendingMapTailMap);
1977        assertNotNull(decendingDecendingTailMap);
1978        // assertEquals(decendingMapTailMap,decendingDecendingTailMap);
1979
1980        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
1981        decendingDecendingMap = decendingMap.descendingMap();
1982        assertEquals(decendingMap, decendingDecendingMap);
1983
1984        decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(),
1985                false);
1986        decendingDecendingHeadMap = decendingMapHeadMap.descendingMap();
1987        assertEquals(decendingMapHeadMap, decendingDecendingHeadMap);
1988
1989        decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(),
1990                false);
1991        decendingDecendingTailMap = decendingMapTailMap.descendingMap();
1992        assertEquals(decendingMapTailMap, decendingDecendingTailMap);
1993
1994        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
1995        decendingDecendingMap = decendingMap.descendingMap();
1996        assertEquals(decendingMap, decendingDecendingMap);
1997
1998        decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(),
1999                false);
2000        decendingDecendingHeadMap = decendingMapHeadMap.descendingMap();
2001        assertEquals(decendingMapHeadMap, decendingDecendingHeadMap);
2002
2003        decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(),
2004                false);
2005        decendingDecendingTailMap = decendingMapTailMap.descendingMap();
2006        assertEquals(decendingMapTailMap, decendingDecendingTailMap);
2007
2008        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2009        decendingDecendingMap = decendingMap.descendingMap();
2010        assertEquals(decendingMap, decendingDecendingMap);
2011
2012        decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(),
2013                false);
2014        decendingDecendingHeadMap = decendingMapHeadMap.descendingMap();
2015        assertEquals(decendingMapHeadMap, decendingDecendingHeadMap);
2016
2017        decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(),
2018                false);
2019        decendingDecendingTailMap = decendingMapTailMap.descendingMap();
2020        assertEquals(decendingMapTailMap, decendingDecendingTailMap);
2021
2022        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2023        decendingDecendingMap = decendingMap.descendingMap();
2024        assertEquals(decendingMap, decendingDecendingMap);
2025
2026        decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(),
2027                false);
2028        decendingDecendingHeadMap = decendingMapHeadMap.descendingMap();
2029        assertEquals(decendingMapHeadMap, decendingDecendingHeadMap);
2030
2031        decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(),
2032                false);
2033        decendingDecendingTailMap = decendingMapTailMap.descendingMap();
2034        assertEquals(decendingMapTailMap, decendingDecendingTailMap);
2035    }
2036
2037    public void test_DescendingSubMap_firstEntry() {
2038        NavigableMap decendingMap = tm.descendingMap();
2039        assertEquals(999, decendingMap.firstEntry().getValue());
2040
2041        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2042        assertEquals(108, decendingMap.firstEntry().getValue());
2043
2044        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2045        assertEquals(109, decendingMap.firstEntry().getValue());
2046
2047        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2048        assertEquals(108, decendingMap.firstEntry().getValue());
2049
2050        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2051        assertEquals(109, decendingMap.firstEntry().getValue());
2052    }
2053
2054    public void test_DescendingSubMap_floorEntry() {
2055        NavigableMap decendingMap = tm.descendingMap();
2056        String key = new Integer(-1).toString();
2057        assertEquals(0, decendingMap.floorEntry(key).getValue());
2058        for (int i = 0; i < objArray.length; i++) {
2059            key = objArray[i].toString();
2060            assertEquals(objArray[i], decendingMap.floorEntry(key).getValue());
2061        }
2062        key = new Integer(1000).toString();
2063        assertEquals(101, decendingMap.floorEntry(key).getValue());
2064        key = new Integer(1001).toString();
2065        assertEquals(101, decendingMap.floorEntry(key).getValue());
2066
2067        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2068        key = new Integer(100).toString();
2069        assertEquals(101, decendingMap.floorEntry(key).getValue());
2070        for (int i = 101; i < 109; i++) {
2071            key = new Integer(i).toString();
2072            assertEquals(i, decendingMap.floorEntry(key).getValue());
2073        }
2074        key = new Integer(109).toString();
2075        assertNull(decendingMap.floorEntry(key));
2076
2077        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2078        key = new Integer(100).toString();
2079        assertEquals(101, decendingMap.floorEntry(key).getValue());
2080        for (int i = 101; i < 109; i++) {
2081            key = new Integer(i).toString();
2082            assertEquals(i, decendingMap.floorEntry(key).getValue());
2083        }
2084        key = new Integer(109).toString();
2085        assertEquals(109, decendingMap.floorEntry(key).getValue());
2086
2087        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2088        key = new Integer(100).toString();
2089        assertEquals(100, decendingMap.floorEntry(key).getValue());
2090        for (int i = 101; i < 109; i++) {
2091            key = new Integer(i).toString();
2092            assertEquals(i, decendingMap.floorEntry(key).getValue());
2093        }
2094        key = new Integer(109).toString();
2095        assertNull(decendingMap.floorEntry(key));
2096
2097        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2098        key = new Integer(100).toString();
2099        assertEquals(100, decendingMap.floorEntry(key).getValue());
2100        for (int i = 101; i < 109; i++) {
2101            key = new Integer(i).toString();
2102            assertEquals(i, decendingMap.floorEntry(key).getValue());
2103        }
2104        key = new Integer(109).toString();
2105        assertEquals(109, decendingMap.floorEntry(key).getValue());
2106
2107        // With Comparator
2108        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
2109                .descendingMap();
2110        key = new Integer(100).toString();
2111        assertEquals(101, decendingMap.floorEntry(key).getValue());
2112        for (int i = 101; i < 109; i++) {
2113            key = new Integer(i).toString();
2114            assertEquals(i, decendingMap.floorEntry(key).getValue());
2115        }
2116        key = new Integer(109).toString();
2117        assertNull(decendingMap.floorEntry(key));
2118
2119        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
2120                .descendingMap();
2121        key = new Integer(100).toString();
2122        assertEquals(101, decendingMap.floorEntry(key).getValue());
2123        for (int i = 101; i < 109; i++) {
2124            key = new Integer(i).toString();
2125            assertEquals(i, decendingMap.floorEntry(key).getValue());
2126        }
2127        key = new Integer(109).toString();
2128        assertEquals(109, decendingMap.floorEntry(key).getValue());
2129
2130        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
2131                .descendingMap();
2132        key = new Integer(100).toString();
2133        assertEquals(100, decendingMap.floorEntry(key).getValue());
2134        for (int i = 101; i < 109; i++) {
2135            key = new Integer(i).toString();
2136            assertEquals(i, decendingMap.floorEntry(key).getValue());
2137        }
2138        key = new Integer(109).toString();
2139        assertNull(decendingMap.floorEntry(key));
2140
2141        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
2142                .descendingMap();
2143        key = new Integer(100).toString();
2144        assertEquals(100, decendingMap.floorEntry(key).getValue());
2145        for (int i = 101; i < 109; i++) {
2146            key = new Integer(i).toString();
2147            assertEquals(i, decendingMap.floorEntry(key).getValue());
2148        }
2149        key = new Integer(109).toString();
2150        assertEquals(109, decendingMap.floorEntry(key).getValue());
2151    }
2152
2153    public void test_DescendingSubMap_lastEntry() {
2154        NavigableMap decendingMap = tm.descendingMap();
2155        assertEquals(0, decendingMap.lastEntry().getValue());
2156
2157        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2158        assertEquals(101, decendingMap.lastEntry().getValue());
2159
2160        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2161        assertEquals(101, decendingMap.lastEntry().getValue());
2162
2163        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2164        assertEquals(100, decendingMap.lastEntry().getValue());
2165
2166        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2167        assertEquals(100, decendingMap.lastEntry().getValue());
2168    }
2169
2170    public void test_DescendingSubMap_higherEntry() {
2171        NavigableMap decendingMap;
2172        NavigableMap decendingTailMap;
2173        Integer value;
2174        Entry entry;
2175        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2176        value = new Integer(101);
2177        assertNull(decendingMap.higherEntry(value.toString()));
2178
2179        for (int i = 108; i > 101; i--) {
2180            value = new Integer(i);
2181            entry = decendingMap.higherEntry(value.toString());
2182            assertEquals(value - 1, entry.getValue());
2183        }
2184
2185        value = new Integer(109);
2186        entry = decendingMap.higherEntry(value.toString());
2187        assertEquals(108, entry.getValue());
2188
2189        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2190                false);
2191        value = new Integer(109);
2192        entry = decendingTailMap.higherEntry(value.toString());
2193        assertEquals(103, entry.getValue());
2194
2195        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2196        value = new Integer(100);
2197        assertNull(decendingMap.higherEntry(value.toString()));
2198
2199        for (int i = 108; i > 100; i--) {
2200            value = new Integer(i);
2201            entry = decendingMap.higherEntry(value.toString());
2202            assertEquals(value - 1, entry.getValue());
2203        }
2204
2205        value = new Integer(109);
2206        entry = decendingMap.higherEntry(value.toString());
2207        assertEquals(108, entry.getValue());
2208
2209        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2210                false);
2211        value = new Integer(109);
2212        entry = decendingTailMap.higherEntry(value.toString());
2213        assertEquals(103, entry.getValue());
2214
2215        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2216        value = new Integer(101);
2217        assertNull(decendingMap.higherEntry(value.toString()));
2218
2219        for (int i = 109; i > 101; i--) {
2220            value = new Integer(i);
2221            entry = decendingMap.higherEntry(value.toString());
2222            assertEquals(value - 1, entry.getValue());
2223        }
2224
2225        value = new Integer(2);
2226        entry = decendingMap.higherEntry(value.toString());
2227        assertEquals(109, entry.getValue());
2228
2229        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2230                false);
2231        value = new Integer(109);
2232        entry = decendingTailMap.higherEntry(value.toString());
2233        assertEquals(103, entry.getValue());
2234
2235        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2236        value = new Integer(100);
2237        assertNull(decendingMap.higherEntry(value.toString()));
2238
2239        for (int i = 109; i > 100; i--) {
2240            value = new Integer(i);
2241            entry = decendingMap.higherEntry(value.toString());
2242            assertEquals(value - 1, entry.getValue());
2243        }
2244
2245        value = new Integer(2);
2246        entry = decendingMap.higherEntry(value.toString());
2247        assertEquals(109, entry.getValue());
2248
2249        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2250                false);
2251        value = new Integer(109);
2252        entry = decendingTailMap.higherEntry(value.toString());
2253        assertEquals(103, entry.getValue());
2254    }
2255
2256    public void test_DescendingSubMap_lowerEntry() {
2257        NavigableMap decendingMap;
2258        NavigableMap decendingHeadMap;
2259        Integer value;
2260        Entry entry;
2261        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2262        value = new Integer(99);
2263        assertNull(decendingMap.lowerEntry(value.toString()));
2264        for (int i = 100; i < 108; i++) {
2265            value = new Integer(i);
2266            entry = decendingMap.lowerEntry(value.toString());
2267            assertEquals(value + 1, entry.getValue());
2268        }
2269        value = new Integer(109);
2270        assertNull(decendingMap.lowerEntry(value.toString()));
2271
2272        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2273                false);
2274        for (int i = 104; i < 106; i++) {
2275            value = new Integer(i);
2276            entry = decendingHeadMap.lowerEntry(value.toString());
2277            assertEquals(value + 1, entry.getValue());
2278        }
2279        value = new Integer(102);
2280        entry = decendingHeadMap.lowerEntry(value.toString());
2281        assertEquals(104, entry.getValue());
2282
2283        value = new Integer(109);
2284        entry = decendingHeadMap.lowerEntry(value.toString());
2285        assertNull(entry);
2286
2287        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2288        value = new Integer(99);
2289        assertNull(decendingMap.lowerEntry(value.toString()));
2290        for (int i = 100; i < 109; i++) {
2291            value = new Integer(i);
2292            entry = decendingMap.lowerEntry(value.toString());
2293            assertEquals(value + 1, entry.getValue());
2294        }
2295        value = new Integer(110);
2296        assertNull(decendingMap.lowerEntry(value.toString()));
2297
2298        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2299                false);
2300        for (int i = 104; i < 109; i++) {
2301            value = new Integer(i);
2302            entry = decendingHeadMap.lowerEntry(value.toString());
2303            assertEquals(value + 1, entry.getValue());
2304        }
2305        value = new Integer(102);
2306        entry = decendingHeadMap.lowerEntry(value.toString());
2307        assertEquals(104, entry.getValue());
2308
2309        value = new Integer(2);
2310        entry = decendingHeadMap.lowerEntry(value.toString());
2311        assertNull(entry);
2312
2313        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2314        value = new Integer(99);
2315        assertNull(decendingMap.lowerEntry(value.toString()));
2316        for (int i = 100; i < 108; i++) {
2317            value = new Integer(i);
2318            entry = decendingMap.lowerEntry(value.toString());
2319            assertEquals(value + 1, entry.getValue());
2320        }
2321        value = new Integer(109);
2322        assertNull(decendingMap.lowerEntry(value.toString()));
2323
2324        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2325                false);
2326        for (int i = 104; i < 107; i++) {
2327            value = new Integer(i);
2328            entry = decendingHeadMap.lowerEntry(value.toString());
2329            assertEquals(value + 1, entry.getValue());
2330        }
2331        value = new Integer(102);
2332        entry = decendingHeadMap.lowerEntry(value.toString());
2333        assertEquals(104, entry.getValue());
2334
2335        value = new Integer(2);
2336        entry = decendingHeadMap.lowerEntry(value.toString());
2337        assertNull(entry);
2338
2339        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2340        value = new Integer(99);
2341        assertNull(decendingMap.lowerEntry(value.toString()));
2342        for (int i = 100; i < 109; i++) {
2343            value = new Integer(i);
2344            entry = decendingMap.lowerEntry(value.toString());
2345            assertEquals(value + 1, entry.getValue());
2346        }
2347        value = new Integer(110);
2348        assertNull(decendingMap.lowerEntry(value.toString()));
2349
2350        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2351                false);
2352        for (int i = 104; i < 109; i++) {
2353            value = new Integer(i);
2354            entry = decendingHeadMap.lowerEntry(value.toString());
2355            assertEquals(value + 1, entry.getValue());
2356        }
2357        value = new Integer(102);
2358        entry = decendingHeadMap.lowerEntry(value.toString());
2359        assertEquals(104, entry.getValue());
2360
2361        value = new Integer(2);
2362        entry = decendingHeadMap.lowerEntry(value.toString());
2363        assertNull(entry);
2364    }
2365
2366    public void test_DescendingSubMap_pollFirstEntry() {
2367        NavigableMap decendingMap = tm.descendingMap();
2368        assertEquals(999, decendingMap.pollFirstEntry().getValue());
2369
2370        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2371        assertEquals(108, decendingMap.pollFirstEntry().getValue());
2372
2373        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2374        assertEquals(109, decendingMap.pollFirstEntry().getValue());
2375
2376        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2377        assertEquals(107, decendingMap.pollFirstEntry().getValue());
2378
2379        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2380        assertEquals(106, decendingMap.pollFirstEntry().getValue());
2381    }
2382
2383    public void test_DescendingSubMap_pollLastEntry() {
2384        NavigableMap decendingMap = tm.descendingMap();
2385        assertEquals(0, decendingMap.pollLastEntry().getValue());
2386
2387        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2388        assertEquals(101, decendingMap.pollLastEntry().getValue());
2389
2390        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2391        assertEquals(102, decendingMap.pollLastEntry().getValue());
2392
2393        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2394        assertEquals(100, decendingMap.pollLastEntry().getValue());
2395
2396        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2397        assertEquals(103, decendingMap.pollLastEntry().getValue());
2398    }
2399
2400    public void test_DescendingSubMap_values() {
2401        NavigableMap decendingMap = tm.descendingMap();
2402        Collection values = decendingMap.values();
2403        assertFalse(values.isEmpty());
2404        assertFalse(values.contains(1000));
2405        for (int i = 999; i > 0; i--) {
2406            assertTrue(values.contains(i));
2407        }
2408        assertTrue(values.contains(0));
2409
2410        String endKey = new Integer(99).toString();
2411        NavigableMap headMap = decendingMap.headMap(endKey, false);
2412        values = headMap.values();
2413        Iterator it = values.iterator();
2414        for (int i = 999; i > 990; i--) {
2415            assertTrue(values.contains(i));
2416            assertEquals(i, it.next());
2417        }
2418
2419        String startKey = new Integer(11).toString();
2420        NavigableMap tailMap = decendingMap.tailMap(startKey, false);
2421        values = tailMap.values();
2422        it = values.iterator();
2423        for (int i = 109; i > 100; i--) {
2424            assertTrue(values.contains(i));
2425            assertEquals(i, it.next());
2426        }
2427
2428        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2429        values = decendingMap.values();
2430        assertFalse(values.isEmpty());
2431        assertFalse(values.contains(109));
2432        for (int i = 108; i > 100; i--) {
2433            assertTrue(values.contains(i));
2434        }
2435        assertFalse(values.contains(100));
2436
2437        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2438        values = decendingMap.values();
2439        assertFalse(values.isEmpty());
2440        assertFalse(values.contains(100));
2441        for (int i = 108; i > 100; i--) {
2442            assertTrue(values.contains(i));
2443        }
2444        assertTrue(values.contains(109));
2445
2446        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2447        values = decendingMap.values();
2448        assertFalse(values.isEmpty());
2449        assertTrue(values.contains(100));
2450        for (int i = 108; i > 100; i--) {
2451            assertTrue(values.contains(i));
2452        }
2453        assertFalse(values.contains(109));
2454
2455        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2456        values = decendingMap.values();
2457        assertFalse(values.isEmpty());
2458        assertTrue(values.contains(100));
2459        for (int i = 108; i > 100; i--) {
2460            assertTrue(values.contains(i));
2461        }
2462        assertTrue(values.contains(109));
2463    }
2464
2465    public void test_DescendingSubMap_headMap() {
2466        NavigableMap decendingMap = tm.descendingMap();
2467        String endKey = new Integer(0).toString(), key;
2468        SortedMap subDecendingMap_Included = decendingMap.headMap(endKey, true);
2469        SortedMap subDecendingMap_Excluded = decendingMap
2470                .headMap(endKey, false);
2471        key = endKey;
2472        assertTrue(subDecendingMap_Included.containsKey(key));
2473        assertFalse(subDecendingMap_Excluded.containsKey(key));
2474        for (int i = 1; i < 1000; i++) {
2475            key = new Integer(i).toString();
2476            assertTrue(subDecendingMap_Included.containsKey(key));
2477            assertTrue(subDecendingMap_Excluded.containsKey(key));
2478        }
2479        key = new Integer(1000).toString();
2480        assertFalse(subDecendingMap_Included.containsKey(key));
2481        assertFalse(subDecendingMap_Excluded.containsKey(key));
2482
2483        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2484        endKey = new Integer(100).toString();
2485        try {
2486            decendingMap.headMap(endKey, true);
2487            fail("should throw IllegalArgumentException");
2488        } catch (IllegalArgumentException e) {
2489            // Expected
2490        }
2491        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2492        key = endKey;
2493        assertFalse(subDecendingMap_Excluded.containsKey(key));
2494
2495        endKey = new Integer(101).toString();
2496        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2497        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2498
2499        key = endKey;
2500        assertTrue(subDecendingMap_Included.containsKey(key));
2501        assertFalse(subDecendingMap_Excluded.containsKey(key));
2502
2503        for (int i = 102; i < 109; i++) {
2504            key = new Integer(i).toString();
2505            assertTrue(subDecendingMap_Included.containsKey(key));
2506            assertTrue(subDecendingMap_Excluded.containsKey(key));
2507        }
2508        key = new Integer(109).toString();
2509        assertFalse(subDecendingMap_Included.containsKey(key));
2510        assertFalse(subDecendingMap_Excluded.containsKey(key));
2511
2512        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2513        endKey = new Integer(100).toString();
2514        try {
2515            decendingMap.headMap(endKey, true);
2516            fail("should throw IllegalArgumentException");
2517        } catch (IllegalArgumentException e) {
2518            // Expected
2519        }
2520        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2521        key = endKey;
2522        assertFalse(subDecendingMap_Excluded.containsKey(key));
2523
2524        endKey = new Integer(101).toString();
2525        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2526        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2527
2528        key = endKey;
2529        assertTrue(subDecendingMap_Included.containsKey(key));
2530        assertFalse(subDecendingMap_Excluded.containsKey(key));
2531
2532        for (int i = 102; i < 109; i++) {
2533            key = new Integer(i).toString();
2534            assertTrue(subDecendingMap_Included.containsKey(key));
2535            assertTrue(subDecendingMap_Excluded.containsKey(key));
2536        }
2537        key = new Integer(109).toString();
2538        assertTrue(subDecendingMap_Included.containsKey(key));
2539        assertTrue(subDecendingMap_Excluded.containsKey(key));
2540
2541        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2542        endKey = new Integer(100).toString();
2543        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2544        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2545        key = endKey;
2546        assertTrue(subDecendingMap_Included.containsKey(key));
2547        assertFalse(subDecendingMap_Excluded.containsKey(key));
2548
2549        endKey = new Integer(101).toString();
2550        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2551        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2552
2553        key = endKey;
2554        assertTrue(subDecendingMap_Included.containsKey(key));
2555        assertFalse(subDecendingMap_Excluded.containsKey(key));
2556
2557        for (int i = 102; i < 109; i++) {
2558            key = new Integer(i).toString();
2559            assertTrue(subDecendingMap_Included.containsKey(key));
2560            assertTrue(subDecendingMap_Excluded.containsKey(key));
2561        }
2562        key = new Integer(109).toString();
2563        assertFalse(subDecendingMap_Included.containsKey(key));
2564        assertFalse(subDecendingMap_Excluded.containsKey(key));
2565
2566        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2567        endKey = new Integer(100).toString();
2568        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2569        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2570        key = endKey;
2571        assertTrue(subDecendingMap_Included.containsKey(key));
2572        assertFalse(subDecendingMap_Excluded.containsKey(key));
2573
2574        endKey = new Integer(101).toString();
2575        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2576        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2577
2578        key = endKey;
2579        assertTrue(subDecendingMap_Included.containsKey(key));
2580        assertFalse(subDecendingMap_Excluded.containsKey(key));
2581
2582        for (int i = 102; i < 109; i++) {
2583            key = new Integer(i).toString();
2584            assertTrue(subDecendingMap_Included.containsKey(key));
2585            assertTrue(subDecendingMap_Excluded.containsKey(key));
2586        }
2587        key = new Integer(109).toString();
2588        assertTrue(subDecendingMap_Included.containsKey(key));
2589        assertTrue(subDecendingMap_Excluded.containsKey(key));
2590
2591        // With Comparator
2592
2593        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
2594                .descendingMap();
2595        endKey = new Integer(100).toString();
2596        try {
2597            decendingMap.headMap(endKey, true);
2598            fail("should throw IllegalArgumentException");
2599        } catch (IllegalArgumentException e) {
2600            // Expected
2601        }
2602        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2603        key = endKey;
2604        assertFalse(subDecendingMap_Excluded.containsKey(key));
2605
2606        endKey = new Integer(101).toString();
2607        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2608        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2609
2610        key = endKey;
2611        assertTrue(subDecendingMap_Included.containsKey(key));
2612        assertFalse(subDecendingMap_Excluded.containsKey(key));
2613
2614        for (int i = 102; i < 109; i++) {
2615            key = new Integer(i).toString();
2616            assertTrue(subDecendingMap_Included.containsKey(key));
2617            assertTrue(subDecendingMap_Excluded.containsKey(key));
2618        }
2619        key = new Integer(109).toString();
2620        assertFalse(subDecendingMap_Included.containsKey(key));
2621        assertFalse(subDecendingMap_Excluded.containsKey(key));
2622
2623        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
2624                .descendingMap();
2625        endKey = new Integer(100).toString();
2626        try {
2627            decendingMap.headMap(endKey, true);
2628            fail("should throw IllegalArgumentException");
2629        } catch (IllegalArgumentException e) {
2630            // Expected
2631        }
2632        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2633        key = endKey;
2634        assertFalse(subDecendingMap_Excluded.containsKey(key));
2635
2636        endKey = new Integer(101).toString();
2637        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2638        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2639
2640        key = endKey;
2641        assertTrue(subDecendingMap_Included.containsKey(key));
2642        assertFalse(subDecendingMap_Excluded.containsKey(key));
2643
2644        for (int i = 102; i < 109; i++) {
2645            key = new Integer(i).toString();
2646            assertTrue(subDecendingMap_Included.containsKey(key));
2647            assertTrue(subDecendingMap_Excluded.containsKey(key));
2648        }
2649        key = new Integer(109).toString();
2650        assertTrue(subDecendingMap_Included.containsKey(key));
2651        assertTrue(subDecendingMap_Excluded.containsKey(key));
2652
2653        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
2654                .descendingMap();
2655        endKey = new Integer(100).toString();
2656        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2657        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2658        key = endKey;
2659        assertTrue(subDecendingMap_Included.containsKey(key));
2660        assertFalse(subDecendingMap_Excluded.containsKey(key));
2661
2662        endKey = new Integer(101).toString();
2663        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2664        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2665
2666        key = endKey;
2667        assertTrue(subDecendingMap_Included.containsKey(key));
2668        assertFalse(subDecendingMap_Excluded.containsKey(key));
2669
2670        for (int i = 102; i < 109; i++) {
2671            key = new Integer(i).toString();
2672            assertTrue(subDecendingMap_Included.containsKey(key));
2673            assertTrue(subDecendingMap_Excluded.containsKey(key));
2674        }
2675        key = new Integer(109).toString();
2676        assertFalse(subDecendingMap_Included.containsKey(key));
2677        assertFalse(subDecendingMap_Excluded.containsKey(key));
2678
2679        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
2680                .descendingMap();
2681        endKey = new Integer(100).toString();
2682        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2683        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2684        key = endKey;
2685        assertTrue(subDecendingMap_Included.containsKey(key));
2686        assertFalse(subDecendingMap_Excluded.containsKey(key));
2687
2688        endKey = new Integer(101).toString();
2689        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2690        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2691
2692        key = endKey;
2693        assertTrue(subDecendingMap_Included.containsKey(key));
2694        assertFalse(subDecendingMap_Excluded.containsKey(key));
2695
2696        for (int i = 102; i < 109; i++) {
2697            key = new Integer(i).toString();
2698            assertTrue(subDecendingMap_Included.containsKey(key));
2699            assertTrue(subDecendingMap_Excluded.containsKey(key));
2700        }
2701        key = new Integer(109).toString();
2702        assertTrue(subDecendingMap_Included.containsKey(key));
2703        assertTrue(subDecendingMap_Excluded.containsKey(key));
2704    }
2705
2706    public void test_DescendingSubMap_subMap() {
2707        NavigableMap descendingMap = tm.descendingMap();
2708        String startKey = new Integer(109).toString();
2709        String endKey = new Integer(100).toString();
2710        try {
2711            descendingMap.subMap(endKey, false, startKey, false);
2712        } catch (IllegalArgumentException e) {
2713            // Expected
2714        }
2715
2716        SortedMap subDescendingMap = descendingMap.subMap(startKey, false,
2717                endKey, false);
2718        String key = new Integer(100).toString();
2719        assertFalse(subDescendingMap.containsKey(key));
2720        for (int i = 101; i < 109; i++) {
2721            key = new Integer(i).toString();
2722            assertTrue(subDescendingMap.containsKey(key));
2723        }
2724        key = new Integer(109).toString();
2725        assertFalse(subDescendingMap.containsKey(key));
2726
2727        subDescendingMap = descendingMap.subMap(startKey, false, endKey, true);
2728        key = new Integer(100).toString();
2729        assertTrue(subDescendingMap.containsKey(key));
2730        for (int i = 101; i < 109; i++) {
2731            key = new Integer(i).toString();
2732            assertTrue(subDescendingMap.containsKey(key));
2733        }
2734        key = new Integer(109).toString();
2735        assertFalse(subDescendingMap.containsKey(key));
2736
2737        subDescendingMap = descendingMap.subMap(startKey, true, endKey, false);
2738        key = new Integer(100).toString();
2739        assertFalse(subDescendingMap.containsKey(key));
2740        for (int i = 101; i < 109; i++) {
2741            key = new Integer(i).toString();
2742            assertTrue(subDescendingMap.containsKey(key));
2743        }
2744        key = new Integer(109).toString();
2745        assertTrue(subDescendingMap.containsKey(key));
2746
2747        subDescendingMap = descendingMap.subMap(startKey, true, endKey, true);
2748        key = new Integer(100).toString();
2749        assertTrue(subDescendingMap.containsKey(key));
2750        for (int i = 101; i < 109; i++) {
2751            key = new Integer(i).toString();
2752            assertTrue(subDescendingMap.containsKey(key));
2753        }
2754        key = new Integer(109).toString();
2755        assertTrue(subDescendingMap.containsKey(key));
2756
2757        TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();
2758        for (int i = -10; i < 10; i++) {
2759            treeMap.put(i, String.valueOf(i));
2760        }
2761        descendingMap = treeMap.descendingMap();
2762        subDescendingMap = descendingMap.subMap(5, 0);
2763        assertEquals(5, subDescendingMap.size());
2764    }
2765
2766    public void test_DescendingSubMap_tailMap() {
2767        // tm
2768        NavigableMap decendingMap = tm.descendingMap();
2769        String endKey = new Integer(1000).toString(), key;
2770        SortedMap subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2771        SortedMap subDecendingMap_Excluded = decendingMap
2772                .tailMap(endKey, false);
2773
2774        key = endKey;
2775        assertFalse(subDecendingMap_Included.containsKey(key));
2776        assertFalse(subDecendingMap_Excluded.containsKey(key));
2777        key = new Integer(100).toString();
2778        assertTrue(subDecendingMap_Included.containsKey(key));
2779        assertTrue(subDecendingMap_Excluded.containsKey(key));
2780
2781        key = new Integer(10).toString();
2782        assertTrue(subDecendingMap_Included.containsKey(key));
2783        assertTrue(subDecendingMap_Excluded.containsKey(key));
2784
2785        key = new Integer(1).toString();
2786        assertTrue(subDecendingMap_Included.containsKey(key));
2787        assertTrue(subDecendingMap_Excluded.containsKey(key));
2788
2789        key = new Integer(0).toString();
2790        assertTrue(subDecendingMap_Included.containsKey(key));
2791        assertTrue(subDecendingMap_Excluded.containsKey(key));
2792
2793        endKey = new Integer(999).toString();
2794        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2795        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2796        key = endKey;
2797        assertTrue(subDecendingMap_Included.containsKey(key));
2798        assertFalse(subDecendingMap_Excluded.containsKey(key));
2799        for (int i = 998; i > 0; i--) {
2800            key = new Integer(i).toString();
2801            assertTrue(subDecendingMap_Included.containsKey(key));
2802            assertTrue(subDecendingMap_Excluded.containsKey(key));
2803        }
2804        key = new Integer(0).toString();
2805        assertTrue(subDecendingMap_Included.containsKey(key));
2806        assertTrue(subDecendingMap_Excluded.containsKey(key));
2807
2808        endKey = new Integer(0).toString();
2809        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2810        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2811        assertEquals(1, subDecendingMap_Included.size());
2812        key = endKey;
2813        assertTrue(subDecendingMap_Included.containsKey(key));
2814        assertTrue(subDecendingMap_Excluded.isEmpty());
2815
2816        // navigableMap_startExcluded_endExcluded
2817        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2818        endKey = new Integer(110).toString();
2819        try {
2820            decendingMap.tailMap(endKey, true);
2821            fail("should throw IllegalArgumentException");
2822        } catch (IllegalArgumentException e) {
2823            // Expected
2824        }
2825
2826        try {
2827            decendingMap.tailMap(endKey, false);
2828            fail("should throw IllegalArgumentException");
2829        } catch (IllegalArgumentException e) {
2830            // Expected
2831        }
2832
2833        endKey = new Integer(109).toString();
2834        try {
2835            decendingMap.tailMap(endKey, true);
2836            fail("should throw IllegalArgumentException");
2837        } catch (IllegalArgumentException e) {
2838            // Expected
2839        }
2840        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2841        key = endKey;
2842        assertFalse(subDecendingMap_Excluded.containsKey(key));
2843
2844        endKey = new Integer(108).toString();
2845        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2846        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2847        key = endKey;
2848        assertTrue(subDecendingMap_Included.containsKey(key));
2849        assertFalse(subDecendingMap_Excluded.containsKey(key));
2850        for (int i = 107; i > 100; i--) {
2851            key = new Integer(i).toString();
2852            assertTrue(subDecendingMap_Included.containsKey(key));
2853            assertTrue(subDecendingMap_Excluded.containsKey(key));
2854        }
2855        key = new Integer(100).toString();
2856        assertFalse(subDecendingMap_Included.containsKey(key));
2857        assertFalse(subDecendingMap_Included.containsKey(key));
2858
2859        endKey = new Integer(101).toString();
2860        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2861        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2862        key = endKey;
2863        assertEquals(1, subDecendingMap_Included.size());
2864        assertTrue(subDecendingMap_Included.containsKey(key));
2865        assertTrue(subDecendingMap_Excluded.isEmpty());
2866
2867        endKey = new Integer(100).toString();
2868        try {
2869            decendingMap.tailMap(endKey, true);
2870            fail("should throw IllegalArgumentException");
2871        } catch (IllegalArgumentException e) {
2872            // Expected
2873        }
2874        try {
2875            decendingMap.tailMap(endKey, false);
2876            fail("should throw IllegalArgumentException");
2877        } catch (IllegalArgumentException e) {
2878            // Expected
2879        }
2880
2881        endKey = new Integer(99).toString();
2882        try {
2883            decendingMap.tailMap(endKey, true);
2884            fail("should throw IllegalArgumentException");
2885        } catch (IllegalArgumentException e) {
2886            // Expected
2887        }
2888
2889        try {
2890            decendingMap.tailMap(endKey, false);
2891            fail("should throw IllegalArgumentException");
2892        } catch (IllegalArgumentException e) {
2893            // Expected
2894        }
2895
2896        // navigableMap_startExcluded_endIncluded
2897        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2898        endKey = new Integer(110).toString();
2899        try {
2900            decendingMap.tailMap(endKey, true);
2901            fail("should throw IllegalArgumentException");
2902        } catch (IllegalArgumentException e) {
2903            // Expected
2904        }
2905
2906        try {
2907            decendingMap.tailMap(endKey, false);
2908            fail("should throw IllegalArgumentException");
2909        } catch (IllegalArgumentException e) {
2910            // Expected
2911        }
2912
2913        endKey = new Integer(109).toString();
2914        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2915        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2916        key = endKey;
2917        assertTrue(subDecendingMap_Included.containsKey(key));
2918        assertFalse(subDecendingMap_Excluded.containsKey(key));
2919
2920        endKey = new Integer(108).toString();
2921        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2922        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2923        key = endKey;
2924        assertTrue(subDecendingMap_Included.containsKey(key));
2925        assertFalse(subDecendingMap_Excluded.containsKey(key));
2926        for (int i = 107; i > 100; i--) {
2927            key = new Integer(i).toString();
2928            assertTrue(subDecendingMap_Included.containsKey(key));
2929            assertTrue(subDecendingMap_Excluded.containsKey(key));
2930        }
2931        key = new Integer(100).toString();
2932        assertFalse(subDecendingMap_Included.containsKey(key));
2933        assertFalse(subDecendingMap_Included.containsKey(key));
2934
2935        endKey = new Integer(101).toString();
2936        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2937        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2938        key = endKey;
2939        assertEquals(1, subDecendingMap_Included.size());
2940        assertTrue(subDecendingMap_Included.containsKey(key));
2941        assertTrue(subDecendingMap_Excluded.isEmpty());
2942
2943        endKey = new Integer(100).toString();
2944        try {
2945            decendingMap.tailMap(endKey, true);
2946            fail("should throw IllegalArgumentException");
2947        } catch (IllegalArgumentException e) {
2948            // Expected
2949        }
2950        try {
2951            decendingMap.tailMap(endKey, false);
2952            fail("should throw IllegalArgumentException");
2953        } catch (IllegalArgumentException e) {
2954            // Expected
2955        }
2956
2957        endKey = new Integer(99).toString();
2958        try {
2959            decendingMap.tailMap(endKey, true);
2960            fail("should throw IllegalArgumentException");
2961        } catch (IllegalArgumentException e) {
2962            // Expected
2963        }
2964        try {
2965            decendingMap.tailMap(endKey, false);
2966            fail("should throw IllegalArgumentException");
2967        } catch (IllegalArgumentException e) {
2968            // Expected
2969        }
2970
2971        // navigableMap_startIncluded_endExcluded
2972        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2973        endKey = new Integer(110).toString();
2974        try {
2975            decendingMap.tailMap(endKey, true);
2976            fail("should throw IllegalArgumentException");
2977        } catch (IllegalArgumentException e) {
2978            // Expected
2979        }
2980
2981        try {
2982            decendingMap.tailMap(endKey, false);
2983            fail("should throw IllegalArgumentException");
2984        } catch (IllegalArgumentException e) {
2985            // Expected
2986        }
2987
2988        endKey = new Integer(109).toString();
2989        try {
2990            decendingMap.tailMap(endKey, true);
2991
2992        } catch (IllegalArgumentException e) {
2993            // Expected
2994        }
2995        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2996        key = endKey;
2997        assertFalse(subDecendingMap_Excluded.containsKey(key));
2998
2999        endKey = new Integer(108).toString();
3000        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3001        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3002        key = endKey;
3003        assertTrue(subDecendingMap_Included.containsKey(key));
3004        assertFalse(subDecendingMap_Excluded.containsKey(key));
3005        for (int i = 107; i > 100; i--) {
3006            key = new Integer(i).toString();
3007            assertTrue(subDecendingMap_Included.containsKey(key));
3008            assertTrue(subDecendingMap_Excluded.containsKey(key));
3009        }
3010        key = new Integer(100).toString();
3011        assertTrue(subDecendingMap_Included.containsKey(key));
3012        assertTrue(subDecendingMap_Included.containsKey(key));
3013
3014        endKey = new Integer(101).toString();
3015        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3016        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3017        key = endKey;
3018        assertEquals(2, subDecendingMap_Included.size());
3019        assertTrue(subDecendingMap_Included.containsKey(key));
3020        assertFalse(subDecendingMap_Excluded.containsKey(key));
3021
3022        endKey = new Integer(100).toString();
3023        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3024        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3025        key = endKey;
3026        assertTrue(subDecendingMap_Included.containsKey(key));
3027        assertFalse(subDecendingMap_Excluded.containsKey(key));
3028
3029        endKey = new Integer(99).toString();
3030        try {
3031            decendingMap.tailMap(endKey, true);
3032            fail("should throw IllegalArgumentException");
3033        } catch (IllegalArgumentException e) {
3034            // Expected
3035        }
3036        try {
3037            decendingMap.tailMap(endKey, false);
3038            fail("should throw IllegalArgumentException");
3039        } catch (IllegalArgumentException e) {
3040            // Expected
3041        }
3042
3043        // navigableMap_startIncluded_endIncluded
3044        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
3045        endKey = new Integer(110).toString();
3046        try {
3047            decendingMap.tailMap(endKey, true);
3048            fail("should throw IllegalArgumentException");
3049        } catch (IllegalArgumentException e) {
3050            // Expected
3051        }
3052        try {
3053            decendingMap.tailMap(endKey, false);
3054            fail("should throw IllegalArgumentException");
3055        } catch (IllegalArgumentException e) {
3056            // Expected
3057        }
3058
3059        endKey = new Integer(109).toString();
3060        try {
3061            decendingMap.tailMap(endKey, true);
3062
3063        } catch (IllegalArgumentException e) {
3064            // Expected
3065        }
3066        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3067        key = endKey;
3068        assertFalse(subDecendingMap_Excluded.containsKey(key));
3069
3070        endKey = new Integer(108).toString();
3071        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3072        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3073        key = endKey;
3074        assertTrue(subDecendingMap_Included.containsKey(key));
3075        assertFalse(subDecendingMap_Excluded.containsKey(key));
3076        for (int i = 107; i > 100; i--) {
3077            key = new Integer(i).toString();
3078            assertTrue(subDecendingMap_Included.containsKey(key));
3079            assertTrue(subDecendingMap_Excluded.containsKey(key));
3080        }
3081        key = new Integer(100).toString();
3082        assertTrue(subDecendingMap_Included.containsKey(key));
3083        assertTrue(subDecendingMap_Included.containsKey(key));
3084
3085        endKey = new Integer(101).toString();
3086        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3087        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3088        key = endKey;
3089        assertEquals(2, subDecendingMap_Included.size());
3090        assertTrue(subDecendingMap_Included.containsKey(key));
3091        assertFalse(subDecendingMap_Excluded.containsKey(key));
3092
3093        endKey = new Integer(100).toString();
3094        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3095        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3096        key = endKey;
3097        assertTrue(subDecendingMap_Included.containsKey(key));
3098        assertFalse(subDecendingMap_Excluded.containsKey(key));
3099
3100        endKey = new Integer(99).toString();
3101        try {
3102            decendingMap.tailMap(endKey, true);
3103            fail("should throw IllegalArgumentException");
3104        } catch (IllegalArgumentException e) {
3105            // Expected
3106        }
3107        try {
3108            decendingMap.tailMap(endKey, false);
3109            fail("should throw IllegalArgumentException");
3110        } catch (IllegalArgumentException e) {
3111            // Expected
3112        }
3113
3114        // With Comparator
3115        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
3116                .descendingMap();
3117        endKey = new Integer(110).toString();
3118        try {
3119            decendingMap.tailMap(endKey, true);
3120            fail("should throw IllegalArgumentException");
3121        } catch (IllegalArgumentException e) {
3122            // Expected
3123        }
3124
3125        try {
3126            decendingMap.tailMap(endKey, false);
3127            fail("should throw IllegalArgumentException");
3128        } catch (IllegalArgumentException e) {
3129            // Expected
3130        }
3131
3132        endKey = new Integer(109).toString();
3133        try {
3134            decendingMap.tailMap(endKey, true);
3135            fail("should throw IllegalArgumentException");
3136        } catch (IllegalArgumentException e) {
3137            // Expected
3138        }
3139        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3140        key = endKey;
3141        assertFalse(subDecendingMap_Excluded.containsKey(key));
3142
3143        endKey = new Integer(108).toString();
3144        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3145        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3146        key = endKey;
3147        assertTrue(subDecendingMap_Included.containsKey(key));
3148        assertFalse(subDecendingMap_Excluded.containsKey(key));
3149        for (int i = 107; i > 100; i--) {
3150            key = new Integer(i).toString();
3151            assertTrue(subDecendingMap_Included.containsKey(key));
3152            assertTrue(subDecendingMap_Excluded.containsKey(key));
3153        }
3154        key = new Integer(100).toString();
3155        assertFalse(subDecendingMap_Included.containsKey(key));
3156        assertFalse(subDecendingMap_Included.containsKey(key));
3157
3158        endKey = new Integer(101).toString();
3159        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3160        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3161        key = endKey;
3162        assertEquals(1, subDecendingMap_Included.size());
3163        assertTrue(subDecendingMap_Included.containsKey(key));
3164        assertTrue(subDecendingMap_Excluded.isEmpty());
3165
3166        endKey = new Integer(100).toString();
3167        try {
3168            decendingMap.tailMap(endKey, true);
3169            fail("should throw IllegalArgumentException");
3170        } catch (IllegalArgumentException e) {
3171            // Expected
3172        }
3173        try {
3174            decendingMap.tailMap(endKey, false);
3175            fail("should throw IllegalArgumentException");
3176        } catch (IllegalArgumentException e) {
3177            // Expected
3178        }
3179
3180        endKey = new Integer(99).toString();
3181        try {
3182            decendingMap.tailMap(endKey, true);
3183            fail("should throw IllegalArgumentException");
3184        } catch (IllegalArgumentException e) {
3185            // Expected
3186        }
3187
3188        try {
3189            decendingMap.tailMap(endKey, false);
3190            fail("should throw IllegalArgumentException");
3191        } catch (IllegalArgumentException e) {
3192            // Expected
3193        }
3194
3195        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
3196                .descendingMap();
3197        endKey = new Integer(110).toString();
3198        try {
3199            decendingMap.tailMap(endKey, true);
3200            fail("should throw IllegalArgumentException");
3201        } catch (IllegalArgumentException e) {
3202            // Expected
3203        }
3204
3205        try {
3206            decendingMap.tailMap(endKey, false);
3207            fail("should throw IllegalArgumentException");
3208        } catch (IllegalArgumentException e) {
3209            // Expected
3210        }
3211
3212        endKey = new Integer(109).toString();
3213        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3214        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3215        key = endKey;
3216        assertTrue(subDecendingMap_Included.containsKey(key));
3217        assertFalse(subDecendingMap_Excluded.containsKey(key));
3218
3219        endKey = new Integer(108).toString();
3220        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3221        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3222        key = endKey;
3223        assertTrue(subDecendingMap_Included.containsKey(key));
3224        assertFalse(subDecendingMap_Excluded.containsKey(key));
3225        for (int i = 107; i > 100; i--) {
3226            key = new Integer(i).toString();
3227            assertTrue(subDecendingMap_Included.containsKey(key));
3228            assertTrue(subDecendingMap_Excluded.containsKey(key));
3229        }
3230        key = new Integer(100).toString();
3231        assertFalse(subDecendingMap_Included.containsKey(key));
3232        assertFalse(subDecendingMap_Included.containsKey(key));
3233
3234        endKey = new Integer(101).toString();
3235        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3236        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3237        key = endKey;
3238        assertEquals(1, subDecendingMap_Included.size());
3239        assertTrue(subDecendingMap_Included.containsKey(key));
3240        assertTrue(subDecendingMap_Excluded.isEmpty());
3241
3242        endKey = new Integer(100).toString();
3243        try {
3244            decendingMap.tailMap(endKey, true);
3245            fail("should throw IllegalArgumentException");
3246        } catch (IllegalArgumentException e) {
3247            // Expected
3248        }
3249        try {
3250            decendingMap.tailMap(endKey, false);
3251            fail("should throw IllegalArgumentException");
3252        } catch (IllegalArgumentException e) {
3253            // Expected
3254        }
3255
3256        endKey = new Integer(99).toString();
3257        try {
3258            decendingMap.tailMap(endKey, true);
3259            fail("should throw IllegalArgumentException");
3260        } catch (IllegalArgumentException e) {
3261            // Expected
3262        }
3263        try {
3264            decendingMap.tailMap(endKey, false);
3265            fail("should throw IllegalArgumentException");
3266        } catch (IllegalArgumentException e) {
3267            // Expected
3268        }
3269
3270        // navigableMap_startIncluded_endExcluded
3271        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded)
3272                .descendingMap();
3273        endKey = new Integer(110).toString();
3274        try {
3275            decendingMap.tailMap(endKey, true);
3276            fail("should throw IllegalArgumentException");
3277        } catch (IllegalArgumentException e) {
3278            // Expected
3279        }
3280
3281        try {
3282            decendingMap.tailMap(endKey, false);
3283            fail("should throw IllegalArgumentException");
3284        } catch (IllegalArgumentException e) {
3285            // Expected
3286        }
3287
3288        endKey = new Integer(109).toString();
3289        try {
3290            decendingMap.tailMap(endKey, true);
3291
3292        } catch (IllegalArgumentException e) {
3293            // Expected
3294        }
3295        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3296        key = endKey;
3297        assertFalse(subDecendingMap_Excluded.containsKey(key));
3298
3299        endKey = new Integer(108).toString();
3300        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3301        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3302        key = endKey;
3303        assertTrue(subDecendingMap_Included.containsKey(key));
3304        assertFalse(subDecendingMap_Excluded.containsKey(key));
3305        for (int i = 107; i > 100; i--) {
3306            key = new Integer(i).toString();
3307            assertTrue(subDecendingMap_Included.containsKey(key));
3308            assertTrue(subDecendingMap_Excluded.containsKey(key));
3309        }
3310        key = new Integer(100).toString();
3311        assertTrue(subDecendingMap_Included.containsKey(key));
3312        assertTrue(subDecendingMap_Included.containsKey(key));
3313
3314        endKey = new Integer(101).toString();
3315        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3316        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3317        key = endKey;
3318        assertEquals(2, subDecendingMap_Included.size());
3319        assertTrue(subDecendingMap_Included.containsKey(key));
3320        assertFalse(subDecendingMap_Excluded.containsKey(key));
3321
3322        endKey = new Integer(100).toString();
3323        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3324        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3325        key = endKey;
3326        assertTrue(subDecendingMap_Included.containsKey(key));
3327        assertFalse(subDecendingMap_Excluded.containsKey(key));
3328
3329        endKey = new Integer(99).toString();
3330        try {
3331            decendingMap.tailMap(endKey, true);
3332            fail("should throw IllegalArgumentException");
3333        } catch (IllegalArgumentException e) {
3334            // Expected
3335        }
3336        try {
3337            decendingMap.tailMap(endKey, false);
3338            fail("should throw IllegalArgumentException");
3339        } catch (IllegalArgumentException e) {
3340            // Expected
3341        }
3342
3343        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded)
3344                .descendingMap();
3345        endKey = new Integer(110).toString();
3346        try {
3347            decendingMap.tailMap(endKey, true);
3348            fail("should throw IllegalArgumentException");
3349        } catch (IllegalArgumentException e) {
3350            // Expected
3351        }
3352        try {
3353            decendingMap.tailMap(endKey, false);
3354            fail("should throw IllegalArgumentException");
3355        } catch (IllegalArgumentException e) {
3356            // Expected
3357        }
3358
3359        endKey = new Integer(109).toString();
3360        try {
3361            decendingMap.tailMap(endKey, true);
3362
3363        } catch (IllegalArgumentException e) {
3364            // Expected
3365        }
3366        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3367        key = endKey;
3368        assertFalse(subDecendingMap_Excluded.containsKey(key));
3369
3370        endKey = new Integer(108).toString();
3371        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3372        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3373        key = endKey;
3374        assertTrue(subDecendingMap_Included.containsKey(key));
3375        assertFalse(subDecendingMap_Excluded.containsKey(key));
3376        for (int i = 107; i > 100; i--) {
3377            key = new Integer(i).toString();
3378            assertTrue(subDecendingMap_Included.containsKey(key));
3379            assertTrue(subDecendingMap_Excluded.containsKey(key));
3380        }
3381        key = new Integer(100).toString();
3382        assertTrue(subDecendingMap_Included.containsKey(key));
3383        assertTrue(subDecendingMap_Included.containsKey(key));
3384
3385        endKey = new Integer(101).toString();
3386        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3387        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3388        key = endKey;
3389        assertEquals(2, subDecendingMap_Included.size());
3390        assertTrue(subDecendingMap_Included.containsKey(key));
3391        assertFalse(subDecendingMap_Excluded.containsKey(key));
3392
3393        endKey = new Integer(100).toString();
3394        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3395        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3396        key = endKey;
3397        assertTrue(subDecendingMap_Included.containsKey(key));
3398        assertFalse(subDecendingMap_Excluded.containsKey(key));
3399
3400        endKey = new Integer(99).toString();
3401        try {
3402            decendingMap.tailMap(endKey, true);
3403            fail("should throw IllegalArgumentException");
3404        } catch (IllegalArgumentException e) {
3405            // Expected
3406        }
3407        try {
3408            decendingMap.tailMap(endKey, false);
3409            fail("should throw IllegalArgumentException");
3410        } catch (IllegalArgumentException e) {
3411            // Expected
3412        }
3413    }
3414
3415    public void test_Entry_setValue() {
3416        TreeMap treeMap = new TreeMap();
3417        Integer value = null;
3418        for (int i = 0; i < 50; i++) {
3419            value = new Integer(i);
3420            treeMap.put(value, value);
3421        }
3422        Map checkedMap = Collections.checkedMap(treeMap, Integer.class,
3423                Integer.class);
3424        Set entrySet = checkedMap.entrySet();
3425        Iterator iterator = entrySet.iterator();
3426        Entry entry;
3427        value = new Integer(0);
3428        for (; iterator.hasNext(); value++) {
3429            entry = (Entry) iterator.next();
3430            assertEquals(value, entry.setValue(value + 1));
3431            assertEquals(value + 1, entry.getValue());
3432        }
3433    }
3434
3435    public void test_DescendingSubMapEntrySet_comparator() {
3436        Set entrySet;
3437        NavigableSet descendingSet;
3438        Comparator comparator;
3439        Entry[] entryArray;
3440        Integer value1, value2;
3441
3442        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3443        if (entrySet instanceof NavigableSet) {
3444            descendingSet = ((NavigableSet) entrySet).descendingSet();
3445            assertNull(((NavigableSet) entrySet).comparator());
3446            comparator = descendingSet.comparator();
3447            assertNotNull(comparator);
3448
3449            entryArray = (Entry[]) descendingSet
3450                    .toArray(new Entry[descendingSet.size()]);
3451            for (int i = 1; i < entryArray.length; i++) {
3452                value1 = (Integer) entryArray[i - 1].getValue();
3453                value2 = (Integer) entryArray[i].getValue();
3454                assertTrue(value1 > value2);
3455                assertTrue(comparator.compare(value1, value2) < 0);
3456            }
3457        }
3458
3459        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3460        if (entrySet instanceof NavigableSet) {
3461            descendingSet = ((NavigableSet) entrySet).descendingSet();
3462            assertNull(((NavigableSet) entrySet).comparator());
3463            comparator = descendingSet.comparator();
3464            assertNotNull(comparator);
3465
3466            entryArray = (Entry[]) descendingSet
3467                    .toArray(new Entry[descendingSet.size()]);
3468            for (int i = 1; i < entryArray.length; i++) {
3469                value1 = (Integer) entryArray[i - 1].getValue();
3470                value2 = (Integer) entryArray[i].getValue();
3471                assertTrue(value1 > value2);
3472                assertTrue(comparator.compare(value1, value2) < 0);
3473            }
3474        }
3475
3476        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3477        if (entrySet instanceof NavigableSet) {
3478            descendingSet = ((NavigableSet) entrySet).descendingSet();
3479            assertNull(((NavigableSet) entrySet).comparator());
3480            comparator = descendingSet.comparator();
3481            assertNotNull(comparator);
3482
3483            entryArray = (Entry[]) descendingSet
3484                    .toArray(new Entry[descendingSet.size()]);
3485            for (int i = 1; i < entryArray.length; i++) {
3486                value1 = (Integer) entryArray[i - 1].getValue();
3487                value2 = (Integer) entryArray[i].getValue();
3488                assertTrue(value1 > value2);
3489                assertTrue(comparator.compare(value1, value2) < 0);
3490            }
3491        }
3492
3493        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3494        if (entrySet instanceof NavigableSet) {
3495            descendingSet = ((NavigableSet) entrySet).descendingSet();
3496            assertNull(((NavigableSet) entrySet).comparator());
3497            comparator = descendingSet.comparator();
3498            assertNotNull(comparator);
3499
3500            entryArray = (Entry[]) descendingSet
3501                    .toArray(new Entry[descendingSet.size()]);
3502            for (int i = 1; i < entryArray.length; i++) {
3503                value1 = (Integer) entryArray[i - 1].getValue();
3504                value2 = (Integer) entryArray[i].getValue();
3505                assertTrue(value1 > value2);
3506                assertTrue(comparator.compare(value1, value2) < 0);
3507            }
3508        }
3509
3510        String endKey = new Integer(2).toString();
3511        entrySet = tm.headMap(endKey, true).entrySet();
3512        if (entrySet instanceof NavigableSet) {
3513            descendingSet = ((NavigableSet) entrySet).descendingSet();
3514            assertNotNull(descendingSet.comparator());
3515        }
3516    }
3517
3518    public void test_DescendingSubMapEntrySet_descendingSet() {
3519        Set entrySet;
3520        NavigableSet ascendingSubMapEntrySet, descendingSet, descendingDescedingSet;
3521        Entry[] ascendingEntryArray, descendingDescendingArray;
3522
3523        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3524        if (entrySet instanceof NavigableSet) {
3525            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3526            descendingSet = ascendingSubMapEntrySet.descendingSet();
3527            descendingDescedingSet = descendingSet.descendingSet();
3528            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3529                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3530
3531            descendingDescendingArray = (Entry[]) descendingDescedingSet
3532                    .toArray(new Entry[descendingDescedingSet.size()]);
3533
3534            assertEquals(ascendingEntryArray.length,
3535                    descendingDescendingArray.length);
3536            for (int i = 0; i < ascendingEntryArray.length; i++) {
3537                assertEquals(ascendingEntryArray[i],
3538                        descendingDescendingArray[i]);
3539            }
3540        }
3541
3542        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3543        if (entrySet instanceof NavigableSet) {
3544            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3545            descendingSet = ascendingSubMapEntrySet.descendingSet();
3546            descendingDescedingSet = descendingSet.descendingSet();
3547            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3548                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3549
3550            descendingDescendingArray = (Entry[]) descendingDescedingSet
3551                    .toArray(new Entry[descendingDescedingSet.size()]);
3552
3553            assertEquals(ascendingEntryArray.length,
3554                    descendingDescendingArray.length);
3555            for (int i = 0; i < ascendingEntryArray.length; i++) {
3556                assertEquals(ascendingEntryArray[i],
3557                        descendingDescendingArray[i]);
3558            }
3559        }
3560
3561        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3562        if (entrySet instanceof NavigableSet) {
3563            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3564            descendingSet = ascendingSubMapEntrySet.descendingSet();
3565            descendingDescedingSet = descendingSet.descendingSet();
3566            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3567                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3568
3569            descendingDescendingArray = (Entry[]) descendingDescedingSet
3570                    .toArray(new Entry[descendingDescedingSet.size()]);
3571
3572            assertEquals(ascendingEntryArray.length,
3573                    descendingDescendingArray.length);
3574            for (int i = 0; i < ascendingEntryArray.length; i++) {
3575                assertEquals(ascendingEntryArray[i],
3576                        descendingDescendingArray[i]);
3577            }
3578        }
3579
3580        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3581        if (entrySet instanceof NavigableSet) {
3582            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3583            descendingSet = ascendingSubMapEntrySet.descendingSet();
3584            descendingDescedingSet = descendingSet.descendingSet();
3585            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3586                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3587
3588            descendingDescendingArray = (Entry[]) descendingDescedingSet
3589                    .toArray(new Entry[descendingDescedingSet.size()]);
3590
3591            assertEquals(ascendingEntryArray.length,
3592                    descendingDescendingArray.length);
3593            for (int i = 0; i < ascendingEntryArray.length; i++) {
3594                assertEquals(ascendingEntryArray[i],
3595                        descendingDescendingArray[i]);
3596            }
3597        }
3598
3599        String endKey = new Integer(2).toString();
3600        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
3601        if (entrySet instanceof NavigableSet) {
3602            // [2...0]
3603            descendingSet = ((NavigableSet) entrySet).descendingSet();
3604            // [0...2]
3605            descendingDescedingSet = descendingSet.descendingSet();
3606            Iterator iterator = descendingDescedingSet.iterator();
3607            assertEquals(0, ((Entry) iterator.next()).getValue());
3608        }
3609
3610        String startKey = new Integer(2).toString();
3611        entrySet = tm.tailMap(startKey, true).entrySet();// 2...
3612        if (entrySet instanceof NavigableSet) {
3613            // [2...0]
3614            descendingSet = ((NavigableSet) entrySet).descendingSet();
3615            // [0...2]
3616            descendingDescedingSet = descendingSet.descendingSet();
3617            Iterator iterator = descendingDescedingSet.iterator();
3618            assertEquals(2, ((Entry) iterator.next()).getValue());
3619        }
3620
3621    }
3622
3623    public void test_DescendingSubMapEntrySet_first() {
3624        Set entrySet;
3625        NavigableSet ascendingSubMapEntrySet, descendingSet;
3626        Entry entry;
3627
3628        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3629        if (entrySet instanceof NavigableSet) {
3630            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3631            descendingSet = ascendingSubMapEntrySet.descendingSet();
3632            entry = (Entry) descendingSet.first();
3633            assertEquals(101, entry.getValue());
3634        }
3635
3636        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3637        if (entrySet instanceof NavigableSet) {
3638            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3639            descendingSet = ascendingSubMapEntrySet.descendingSet();
3640            entry = (Entry) descendingSet.first();
3641            assertEquals(101, entry.getValue());
3642        }
3643
3644        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3645        if (entrySet instanceof NavigableSet) {
3646            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3647            descendingSet = ascendingSubMapEntrySet.descendingSet();
3648            entry = (Entry) descendingSet.first();
3649            assertEquals(100, entry.getValue());
3650        }
3651
3652        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3653        if (entrySet instanceof NavigableSet) {
3654            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3655            descendingSet = ascendingSubMapEntrySet.descendingSet();
3656            entry = (Entry) descendingSet.first();
3657            assertEquals(100, entry.getValue());
3658        }
3659    }
3660
3661    public void test_DescendingSubMapEntrySet_last() {
3662        Set entrySet;
3663        NavigableSet ascendingSubMapEntrySet, descendingSet;
3664        Entry entry;
3665
3666        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3667        if (entrySet instanceof NavigableSet) {
3668            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3669            descendingSet = ascendingSubMapEntrySet.descendingSet();
3670            entry = (Entry) descendingSet.last();
3671            assertEquals(108, entry.getValue());
3672        }
3673
3674        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3675        if (entrySet instanceof NavigableSet) {
3676            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3677            descendingSet = ascendingSubMapEntrySet.descendingSet();
3678            entry = (Entry) descendingSet.last();
3679            assertEquals(109, entry.getValue());
3680        }
3681
3682        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3683        if (entrySet instanceof NavigableSet) {
3684            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3685            descendingSet = ascendingSubMapEntrySet.descendingSet();
3686            entry = (Entry) descendingSet.last();
3687            assertEquals(108, entry.getValue());
3688        }
3689
3690        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3691        if (entrySet instanceof NavigableSet) {
3692            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3693            descendingSet = ascendingSubMapEntrySet.descendingSet();
3694            entry = (Entry) descendingSet.last();
3695            assertEquals(109, entry.getValue());
3696        }
3697    }
3698
3699    public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() {
3700        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3701        Entry entry;
3702        if (entrySet instanceof NavigableSet) {
3703            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3704                    .descendingSet();
3705            assertEquals(8, descendingSubMapEntrySet.size());
3706            for (int i = 101; i < 109; i++) {
3707                entry = (Entry) descendingSubMapEntrySet.pollFirst();
3708                assertEquals(i, entry.getValue());
3709            }
3710            assertNull(descendingSubMapEntrySet.pollFirst());
3711        }
3712    }
3713
3714    public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() {
3715        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3716        Entry entry;
3717        if (entrySet instanceof NavigableSet) {
3718            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3719                    .descendingSet();
3720            assertEquals(9, descendingSubMapEntrySet.size());
3721            for (int i = 101; i < 110; i++) {
3722                entry = (Entry) descendingSubMapEntrySet.pollFirst();
3723                assertEquals(i, entry.getValue());
3724            }
3725            assertNull(descendingSubMapEntrySet.pollFirst());
3726        }
3727    }
3728
3729    public void test_DescendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() {
3730        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3731        Entry entry;
3732        if (entrySet instanceof NavigableSet) {
3733            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3734                    .descendingSet();
3735            assertEquals(9, descendingSubMapEntrySet.size());
3736            for (int i = 100; i < 109; i++) {
3737                entry = (Entry) descendingSubMapEntrySet.pollFirst();
3738                assertEquals(i, entry.getValue());
3739            }
3740            assertNull(descendingSubMapEntrySet.pollFirst());
3741        }
3742    }
3743
3744    public void test_DescendingSubMapEntrySet_pollFirst_startIncluded_endIncluded() {
3745        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3746        Entry entry;
3747        if (entrySet instanceof NavigableSet) {
3748            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3749                    .descendingSet();
3750            assertEquals(10, descendingSubMapEntrySet.size());
3751            for (int i = 100; i < 110; i++) {
3752                entry = (Entry) descendingSubMapEntrySet.pollFirst();
3753                assertEquals(i, entry.getValue());
3754            }
3755            assertNull(descendingSubMapEntrySet.pollFirst());
3756        }
3757    }
3758
3759    public void test_DescendingSubMapEntrySet_pollFirst() {
3760        String key = new Integer(2).toString();
3761        Set entrySet = tm.headMap(key, true).entrySet();// [0...2]
3762        NavigableSet descendingEntrySet;
3763        Entry entry;
3764
3765        if (entrySet instanceof NavigableSet) {
3766            // [2...0]
3767            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3768            entry = (Entry) descendingEntrySet.pollFirst();
3769            assertEquals(0, entry.getValue());
3770        }
3771
3772        entrySet = tm.tailMap(key, true).entrySet();
3773        if (entrySet instanceof NavigableSet) {
3774            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3775            entry = (Entry) descendingEntrySet.pollFirst();
3776            assertEquals(2, entry.getValue());
3777        }
3778    }
3779
3780    public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endExclued() {
3781        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3782        Entry entry;
3783        if (entrySet instanceof NavigableSet) {
3784            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3785                    .descendingSet();
3786            assertEquals(8, descendingSubMapEntrySet.size());
3787            for (int i = 108; i > 100; i--) {
3788                entry = (Entry) descendingSubMapEntrySet.pollLast();
3789                assertEquals(i, entry.getValue());
3790            }
3791            assertNull(descendingSubMapEntrySet.pollFirst());
3792        }
3793    }
3794
3795    public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endInclued() {
3796        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3797        Entry entry;
3798        if (entrySet instanceof NavigableSet) {
3799            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3800                    .descendingSet();
3801            assertEquals(9, descendingSubMapEntrySet.size());
3802            for (int i = 109; i > 100; i--) {
3803                entry = (Entry) descendingSubMapEntrySet.pollLast();
3804                assertEquals(i, entry.getValue());
3805            }
3806            assertNull(descendingSubMapEntrySet.pollFirst());
3807        }
3808    }
3809
3810    public void test_DescendingSubMapEntrySet_pollLast_startIncluded_endExclued() {
3811        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3812        Entry entry;
3813        if (entrySet instanceof NavigableSet) {
3814            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3815                    .descendingSet();
3816            assertEquals(9, descendingSubMapEntrySet.size());
3817            for (int i = 108; i > 99; i--) {
3818                entry = (Entry) descendingSubMapEntrySet.pollLast();
3819                assertEquals(i, entry.getValue());
3820            }
3821            assertNull(descendingSubMapEntrySet.pollFirst());
3822        }
3823    }
3824
3825    public void test_DescendingSubMapEntrySet_pollLast_startIncluded_endInclued() {
3826        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3827        Entry entry;
3828        if (entrySet instanceof NavigableSet) {
3829            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3830                    .descendingSet();
3831            assertEquals(10, descendingSubMapEntrySet.size());
3832            for (int i = 109; i > 99; i--) {
3833                entry = (Entry) descendingSubMapEntrySet.pollLast();
3834                assertEquals(i, entry.getValue());
3835            }
3836            assertNull(descendingSubMapEntrySet.pollFirst());
3837        }
3838    }
3839
3840    public void test_DescendingSubMapEntrySet_pollLast() {
3841        String key = new Integer(2).toString();
3842        Set entrySet = tm.headMap(key, true).entrySet();// [0...2]
3843        NavigableSet descendingEntrySet;
3844        Entry entry;
3845
3846        if (entrySet instanceof NavigableSet) {
3847            // [2...0]
3848            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3849            entry = (Entry) descendingEntrySet.pollLast();
3850            assertEquals(2, entry.getValue());
3851        }
3852
3853        entrySet = tm.tailMap(key, true).entrySet();
3854        if (entrySet instanceof NavigableSet) {
3855            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3856            entry = (Entry) descendingEntrySet.pollLast();
3857            assertEquals(999, entry.getValue());
3858        }
3859    }
3860
3861    public void test_DescendingSubMapEntrySet_descendingIterator() {
3862        Set entrySet;
3863        NavigableSet descendingSet;
3864        Iterator iterator;
3865
3866        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3867        if (entrySet instanceof NavigableSet) {
3868            descendingSet = ((NavigableSet) entrySet).descendingSet();
3869            iterator = descendingSet.iterator();
3870            for (int value = 108; value > 100; value--) {
3871                assertTrue(iterator.hasNext());
3872                assertEquals(value, ((Entry) iterator.next()).getValue());
3873            }
3874            assertFalse(iterator.hasNext());
3875            try {
3876                iterator.next();
3877                fail("should throw NoSuchElementException");
3878            } catch (NoSuchElementException e) {
3879                // Expected
3880            }
3881        }
3882
3883        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3884        if (entrySet instanceof NavigableSet) {
3885            descendingSet = ((NavigableSet) entrySet).descendingSet();
3886            iterator = descendingSet.iterator();
3887            for (int value = 109; value > 100; value--) {
3888                assertTrue(iterator.hasNext());
3889                assertEquals(value, ((Entry) iterator.next()).getValue());
3890            }
3891            assertFalse(iterator.hasNext());
3892            try {
3893                iterator.next();
3894                fail("should throw NoSuchElementException");
3895            } catch (NoSuchElementException e) {
3896                // Expected
3897            }
3898        }
3899
3900        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3901        if (entrySet instanceof NavigableSet) {
3902            descendingSet = ((NavigableSet) entrySet).descendingSet();
3903            iterator = descendingSet.iterator();
3904            for (int value = 108; value > 99; value--) {
3905                assertTrue(iterator.hasNext());
3906                assertEquals(value, ((Entry) iterator.next()).getValue());
3907            }
3908            assertFalse(iterator.hasNext());
3909            try {
3910                iterator.next();
3911                fail("should throw NoSuchElementException");
3912            } catch (NoSuchElementException e) {
3913                // Expected
3914            }
3915        }
3916
3917        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3918        if (entrySet instanceof NavigableSet) {
3919            descendingSet = ((NavigableSet) entrySet).descendingSet();
3920            iterator = descendingSet.iterator();
3921            for (int value = 109; value > 99; value--) {
3922                assertTrue(iterator.hasNext());
3923                assertEquals(value, ((Entry) iterator.next()).getValue());
3924            }
3925            assertFalse(iterator.hasNext());
3926            try {
3927                iterator.next();
3928                fail("should throw NoSuchElementException");
3929            } catch (NoSuchElementException e) {
3930                // Expected
3931            }
3932        }
3933
3934        String endKey = new Integer(2).toString();
3935        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
3936        if (entrySet instanceof NavigableSet) {
3937            // [2...0]
3938            descendingSet = ((NavigableSet) entrySet).descendingSet();
3939            iterator = descendingSet.descendingIterator();
3940            assertEquals(0, ((Entry) iterator.next()).getValue());// 0...2
3941        }
3942    }
3943
3944    public void test_DescendingSubMapEntrySet_headSet() {
3945        Set entrySet, headSet;
3946        NavigableSet descendingSubMapEntrySet;
3947        Iterator iterator, headSetIterator;
3948        Entry entry;
3949        int value;
3950
3951        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3952        if (entrySet instanceof NavigableSet) {
3953            descendingSubMapEntrySet = ((NavigableSet) entrySet)
3954                    .descendingSet();
3955            iterator = descendingSubMapEntrySet.iterator();
3956            while (iterator.hasNext()) {
3957                entry = (Entry) iterator.next();
3958                headSet = descendingSubMapEntrySet.headSet(entry);
3959                headSetIterator = headSet.iterator();
3960                for (value = 108; headSetIterator.hasNext(); value--) {
3961                    assertEquals(value, ((Entry) headSetIterator.next())
3962                            .getValue());
3963                }
3964                try {
3965                    headSetIterator.next();
3966                    fail("should throw NoSuchElementException");
3967                } catch (NoSuchElementException e) {
3968                    // Expected
3969                }
3970
3971                headSet = descendingSubMapEntrySet.headSet(entry, false);
3972                headSetIterator = headSet.iterator();
3973                for (value = 108; headSetIterator.hasNext(); value--) {
3974                    assertEquals(value, ((Entry) headSetIterator.next())
3975                            .getValue());
3976                }
3977                try {
3978                    headSetIterator.next();
3979                    fail("should throw NoSuchElementException");
3980                } catch (NoSuchElementException e) {
3981                    // Expected
3982                }
3983
3984                headSet = descendingSubMapEntrySet.headSet(entry, true);
3985                headSetIterator = headSet.iterator();
3986                for (value = 108; headSetIterator.hasNext(); value--) {
3987                    assertEquals(value, ((Entry) headSetIterator.next())
3988                            .getValue());
3989                }
3990                try {
3991                    headSetIterator.next();
3992                    fail("should throw NoSuchElementException");
3993                } catch (NoSuchElementException e) {
3994                    // Expected
3995                }
3996            }
3997        }
3998
3999        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4000        if (entrySet instanceof NavigableSet) {
4001            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4002                    .descendingSet();
4003            iterator = descendingSubMapEntrySet.iterator();
4004            while (iterator.hasNext()) {
4005                entry = (Entry) iterator.next();
4006                headSet = descendingSubMapEntrySet.headSet(entry);
4007                headSetIterator = headSet.iterator();
4008                for (value = 109; headSetIterator.hasNext(); value--) {
4009                    assertEquals(value, ((Entry) headSetIterator.next())
4010                            .getValue());
4011                }
4012                try {
4013                    headSetIterator.next();
4014                    fail("should throw NoSuchElementException");
4015                } catch (NoSuchElementException e) {
4016                    // Expected
4017                }
4018
4019                headSet = descendingSubMapEntrySet.headSet(entry, false);
4020                headSetIterator = headSet.iterator();
4021                for (value = 109; headSetIterator.hasNext(); value--) {
4022                    assertEquals(value, ((Entry) headSetIterator.next())
4023                            .getValue());
4024                }
4025                try {
4026                    headSetIterator.next();
4027                    fail("should throw NoSuchElementException");
4028                } catch (NoSuchElementException e) {
4029                    // Expected
4030                }
4031
4032                headSet = descendingSubMapEntrySet.headSet(entry, true);
4033                headSetIterator = headSet.iterator();
4034                for (value = 109; headSetIterator.hasNext(); value--) {
4035                    assertEquals(value, ((Entry) headSetIterator.next())
4036                            .getValue());
4037                }
4038                try {
4039                    headSetIterator.next();
4040                    fail("should throw NoSuchElementException");
4041                } catch (NoSuchElementException e) {
4042                    // Expected
4043                }
4044            }
4045        }
4046
4047        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4048        if (entrySet instanceof NavigableSet) {
4049            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4050                    .descendingSet();
4051            iterator = descendingSubMapEntrySet.iterator();
4052            while (iterator.hasNext()) {
4053                entry = (Entry) iterator.next();
4054                headSet = descendingSubMapEntrySet.headSet(entry);
4055                headSetIterator = headSet.iterator();
4056                for (value = 108; headSetIterator.hasNext(); value--) {
4057                    assertEquals(value, ((Entry) headSetIterator.next())
4058                            .getValue());
4059                }
4060                try {
4061                    headSetIterator.next();
4062                    fail("should throw NoSuchElementException");
4063                } catch (NoSuchElementException e) {
4064                    // Expected
4065                }
4066
4067                headSet = descendingSubMapEntrySet.headSet(entry, false);
4068                headSetIterator = headSet.iterator();
4069                for (value = 108; headSetIterator.hasNext(); value--) {
4070                    assertEquals(value, ((Entry) headSetIterator.next())
4071                            .getValue());
4072                }
4073                try {
4074                    headSetIterator.next();
4075                    fail("should throw NoSuchElementException");
4076                } catch (NoSuchElementException e) {
4077                    // Expected
4078                }
4079
4080                headSet = descendingSubMapEntrySet.headSet(entry, true);
4081                headSetIterator = headSet.iterator();
4082                for (value = 108; headSetIterator.hasNext(); value--) {
4083                    assertEquals(value, ((Entry) headSetIterator.next())
4084                            .getValue());
4085                }
4086                try {
4087                    headSetIterator.next();
4088                    fail("should throw NoSuchElementException");
4089                } catch (NoSuchElementException e) {
4090                    // Expected
4091                }
4092            }
4093        }
4094
4095        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4096        if (entrySet instanceof NavigableSet) {
4097            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4098                    .descendingSet();
4099            iterator = descendingSubMapEntrySet.iterator();
4100            while (iterator.hasNext()) {
4101                entry = (Entry) iterator.next();
4102                headSet = descendingSubMapEntrySet.headSet(entry);
4103                headSetIterator = headSet.iterator();
4104                for (value = 109; headSetIterator.hasNext(); value--) {
4105                    assertEquals(value, ((Entry) headSetIterator.next())
4106                            .getValue());
4107                }
4108                try {
4109                    headSetIterator.next();
4110                    fail("should throw NoSuchElementException");
4111                } catch (NoSuchElementException e) {
4112                    // Expected
4113                }
4114
4115                headSet = descendingSubMapEntrySet.headSet(entry, false);
4116                headSetIterator = headSet.iterator();
4117                for (value = 109; headSetIterator.hasNext(); value--) {
4118                    assertEquals(value, ((Entry) headSetIterator.next())
4119                            .getValue());
4120                }
4121                try {
4122                    headSetIterator.next();
4123                    fail("should throw NoSuchElementException");
4124                } catch (NoSuchElementException e) {
4125                    // Expected
4126                }
4127
4128                headSet = descendingSubMapEntrySet.headSet(entry, true);
4129                headSetIterator = headSet.iterator();
4130                for (value = 109; headSetIterator.hasNext(); value--) {
4131                    assertEquals(value, ((Entry) headSetIterator.next())
4132                            .getValue());
4133                }
4134                try {
4135                    headSetIterator.next();
4136                    fail("should throw NoSuchElementException");
4137                } catch (NoSuchElementException e) {
4138                    // Expected
4139                }
4140            }
4141        }
4142
4143        String endKey = new Integer(2).toString();
4144        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
4145        if (entrySet instanceof NavigableSet) {
4146            // [2...0]
4147            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4148                    .descendingSet();
4149            iterator = descendingSubMapEntrySet.iterator();
4150            iterator.next();// 2
4151            iterator.next();// 199
4152            entry = (Entry) iterator.next();// 198
4153            headSet = descendingSubMapEntrySet.headSet(entry);
4154            assertEquals(2, headSet.size());// 2 199
4155            headSetIterator = headSet.iterator();
4156            assertEquals(2, ((Entry) headSetIterator.next()).getValue());
4157            assertEquals(199, ((Entry) headSetIterator.next()).getValue());
4158
4159            headSet = descendingSubMapEntrySet.headSet(entry, true);
4160            assertEquals(3, headSet.size());// 2 199
4161            headSetIterator = headSet.iterator();
4162            assertEquals(2, ((Entry) headSetIterator.next()).getValue());
4163            assertEquals(199, ((Entry) headSetIterator.next()).getValue());
4164            assertEquals(198, ((Entry) headSetIterator.next()).getValue());
4165        }
4166    }
4167
4168    public void test_DescendingSubMapEntrySet_tailSet() {
4169        Set entrySet, tailSet;
4170        NavigableSet descendingSubMapEntrySet;
4171        Iterator iterator, tailSetIterator;
4172        Entry entry;
4173        int value;
4174
4175        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4176        if (entrySet instanceof NavigableSet) {
4177            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4178                    .descendingSet();
4179            iterator = descendingSubMapEntrySet.iterator();
4180            while (iterator.hasNext()) {
4181                entry = (Entry) iterator.next();
4182                tailSet = descendingSubMapEntrySet.tailSet(entry);
4183                tailSetIterator = tailSet.iterator();
4184                for (value = (Integer) entry.getValue(); tailSetIterator
4185                        .hasNext(); value--) {
4186                    assertEquals(value, ((Entry) tailSetIterator.next())
4187                            .getValue());
4188                }
4189                try {
4190                    tailSetIterator.next();
4191                    fail("should throw NoSuchElementException");
4192                } catch (NoSuchElementException e) {
4193                    // Expected
4194                }
4195
4196                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4197                tailSetIterator = tailSet.iterator();
4198                for (value = (Integer) entry.getValue(); tailSetIterator
4199                        .hasNext(); value--) {
4200                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4201                            .getValue());
4202                }
4203                try {
4204                    tailSetIterator.next();
4205                    fail("should throw NoSuchElementException");
4206                } catch (NoSuchElementException e) {
4207                    // Expected
4208                }
4209
4210                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4211                tailSetIterator = tailSet.iterator();
4212                for (value = (Integer) entry.getValue(); tailSetIterator
4213                        .hasNext(); value--) {
4214                    assertEquals(value, ((Entry) tailSetIterator.next())
4215                            .getValue());
4216                }
4217                try {
4218                    tailSetIterator.next();
4219                    fail("should throw NoSuchElementException");
4220                } catch (NoSuchElementException e) {
4221                    // Expected
4222                }
4223            }
4224        }
4225
4226        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4227        if (entrySet instanceof NavigableSet) {
4228            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4229                    .descendingSet();
4230            iterator = descendingSubMapEntrySet.iterator();
4231            while (iterator.hasNext()) {
4232                entry = (Entry) iterator.next();
4233                tailSet = descendingSubMapEntrySet.tailSet(entry);
4234                tailSetIterator = tailSet.iterator();
4235                for (value = (Integer) entry.getValue(); tailSetIterator
4236                        .hasNext(); value--) {
4237                    assertEquals(value, ((Entry) tailSetIterator.next())
4238                            .getValue());
4239                }
4240                try {
4241                    tailSetIterator.next();
4242                    fail("should throw NoSuchElementException");
4243                } catch (NoSuchElementException e) {
4244                    // Expected
4245                }
4246
4247                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4248                tailSetIterator = tailSet.iterator();
4249                for (value = (Integer) entry.getValue(); tailSetIterator
4250                        .hasNext(); value--) {
4251                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4252                            .getValue());
4253                }
4254                try {
4255                    tailSetIterator.next();
4256                    fail("should throw NoSuchElementException");
4257                } catch (NoSuchElementException e) {
4258                    // Expected
4259                }
4260
4261                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4262                tailSetIterator = tailSet.iterator();
4263                for (value = (Integer) entry.getValue(); tailSetIterator
4264                        .hasNext(); value--) {
4265                    assertEquals(value, ((Entry) tailSetIterator.next())
4266                            .getValue());
4267                }
4268                try {
4269                    tailSetIterator.next();
4270                    fail("should throw NoSuchElementException");
4271                } catch (NoSuchElementException e) {
4272                    // Expected
4273                }
4274            }
4275        }
4276
4277        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4278        if (entrySet instanceof NavigableSet) {
4279            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4280                    .descendingSet();
4281            iterator = descendingSubMapEntrySet.iterator();
4282            while (iterator.hasNext()) {
4283                entry = (Entry) iterator.next();
4284                tailSet = descendingSubMapEntrySet.tailSet(entry);
4285                tailSetIterator = tailSet.iterator();
4286                for (value = (Integer) entry.getValue(); tailSetIterator
4287                        .hasNext(); value--) {
4288                    assertEquals(value, ((Entry) tailSetIterator.next())
4289                            .getValue());
4290                }
4291                try {
4292                    tailSetIterator.next();
4293                    fail("should throw NoSuchElementException");
4294                } catch (NoSuchElementException e) {
4295                    // Expected
4296                }
4297
4298                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4299                tailSetIterator = tailSet.iterator();
4300                for (value = (Integer) entry.getValue(); tailSetIterator
4301                        .hasNext(); value--) {
4302                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4303                            .getValue());
4304                }
4305                try {
4306                    tailSetIterator.next();
4307                    fail("should throw NoSuchElementException");
4308                } catch (NoSuchElementException e) {
4309                    // Expected
4310                }
4311
4312                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4313                tailSetIterator = tailSet.iterator();
4314                for (value = (Integer) entry.getValue(); tailSetIterator
4315                        .hasNext(); value--) {
4316                    assertEquals(value, ((Entry) tailSetIterator.next())
4317                            .getValue());
4318                }
4319                try {
4320                    tailSetIterator.next();
4321                    fail("should throw NoSuchElementException");
4322                } catch (NoSuchElementException e) {
4323                    // Expected
4324                }
4325            }
4326        }
4327
4328        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4329        if (entrySet instanceof NavigableSet) {
4330            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4331                    .descendingSet();
4332            iterator = descendingSubMapEntrySet.iterator();
4333            while (iterator.hasNext()) {
4334                entry = (Entry) iterator.next();
4335                tailSet = descendingSubMapEntrySet.tailSet(entry);
4336                tailSetIterator = tailSet.iterator();
4337                for (value = (Integer) entry.getValue(); tailSetIterator
4338                        .hasNext(); value--) {
4339                    assertEquals(value, ((Entry) tailSetIterator.next())
4340                            .getValue());
4341                }
4342                try {
4343                    tailSetIterator.next();
4344                    fail("should throw NoSuchElementException");
4345                } catch (NoSuchElementException e) {
4346                    // Expected
4347                }
4348
4349                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4350                tailSetIterator = tailSet.iterator();
4351                for (value = (Integer) entry.getValue(); tailSetIterator
4352                        .hasNext(); value--) {
4353                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4354                            .getValue());
4355                }
4356                try {
4357                    tailSetIterator.next();
4358                    fail("should throw NoSuchElementException");
4359                } catch (NoSuchElementException e) {
4360                    // Expected
4361                }
4362
4363                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4364                tailSetIterator = tailSet.iterator();
4365                for (value = (Integer) entry.getValue(); tailSetIterator
4366                        .hasNext(); value--) {
4367                    assertEquals(value, ((Entry) tailSetIterator.next())
4368                            .getValue());
4369                }
4370                try {
4371                    tailSetIterator.next();
4372                    fail("should throw NoSuchElementException");
4373                } catch (NoSuchElementException e) {
4374                    // Expected
4375                }
4376            }
4377        }
4378
4379        String endKey = new Integer(2).toString();
4380        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
4381        if (entrySet instanceof NavigableSet) {
4382            // [2...0]
4383            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4384                    .descendingSet();
4385            iterator = descendingSubMapEntrySet.iterator();
4386            iterator.next();// 2
4387            entry = (Entry) iterator.next();// 199
4388            tailSet = descendingSubMapEntrySet.tailSet(entry);
4389            tailSetIterator = tailSet.iterator();
4390            assertEquals(199, ((Entry) tailSetIterator.next()).getValue());
4391
4392            tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4393            tailSetIterator = tailSet.iterator();
4394            assertEquals(198, ((Entry) tailSetIterator.next()).getValue());
4395
4396            tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4397            tailSetIterator = tailSet.iterator();
4398            assertEquals(199, ((Entry) tailSetIterator.next()).getValue());
4399        }
4400    }
4401
4402    public void test_DescendingSubMapEntrySet_subSet() {
4403        Set entrySet, subSet;
4404        NavigableSet descendingSubMapEntrySet;
4405        Entry startEntry, endEntry;
4406        Iterator subSetIterator;
4407
4408        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4409        if (entrySet instanceof NavigableSet) {
4410            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4411                    .descendingSet();
4412            Iterator iteratorStart = descendingSubMapEntrySet.iterator();
4413            while (iteratorStart.hasNext()) {
4414                startEntry = (Entry) iteratorStart.next();
4415                Iterator iteratorEnd = descendingSubMapEntrySet.iterator();
4416                while (iteratorEnd.hasNext()) {
4417                    endEntry = (Entry) iteratorEnd.next();
4418                    int startIndex = (Integer) startEntry.getValue();
4419                    int endIndex = (Integer) endEntry.getValue();
4420                    if (startIndex < endIndex) {
4421                        try {
4422                            descendingSubMapEntrySet.subSet(startEntry,
4423                                    endEntry);
4424                            fail("should throw IllegalArgumentException");
4425                        } catch (IllegalArgumentException e) {
4426                            // Expected
4427                        }
4428
4429                        try {
4430                            descendingSubMapEntrySet.subSet(startEntry, false,
4431                                    endEntry, false);
4432                            fail("should throw IllegalArgumentException");
4433                        } catch (IllegalArgumentException e) {
4434                            // Expected
4435                        }
4436
4437                        try {
4438                            descendingSubMapEntrySet.subSet(startEntry, false,
4439                                    endEntry, true);
4440                            fail("should throw IllegalArgumentException");
4441                        } catch (IllegalArgumentException e) {
4442                            // Expected
4443                        }
4444
4445                        try {
4446                            descendingSubMapEntrySet.subSet(startEntry, true,
4447                                    endEntry, false);
4448                            fail("should throw IllegalArgumentException");
4449                        } catch (IllegalArgumentException e) {
4450                            // Expected
4451                        }
4452
4453                        try {
4454                            descendingSubMapEntrySet.subSet(startEntry, true,
4455                                    endEntry, true);
4456                            fail("should throw IllegalArgumentException");
4457                        } catch (IllegalArgumentException e) {
4458                            // Expected
4459                        }
4460                    } else {
4461                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4462                                endEntry);
4463                        subSetIterator = subSet.iterator();
4464                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4465                            assertEquals(index, ((Entry) subSetIterator.next())
4466                                    .getValue());
4467                        }
4468
4469                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4470                                false, endEntry, false);
4471                        subSetIterator = subSet.iterator();
4472                        for (int index = startIndex - 1; subSetIterator
4473                                .hasNext(); index--) {
4474                            assertEquals(index, ((Entry) subSetIterator.next())
4475                                    .getValue());
4476                        }
4477
4478                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4479                                false, endEntry, true);
4480                        subSetIterator = subSet.iterator();
4481                        for (int index = startIndex - 1; subSetIterator
4482                                .hasNext(); index--) {
4483                            assertEquals(index, ((Entry) subSetIterator.next())
4484                                    .getValue());
4485                        }
4486
4487                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4488                                true, endEntry, false);
4489                        subSetIterator = subSet.iterator();
4490                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4491                            assertEquals(index, ((Entry) subSetIterator.next())
4492                                    .getValue());
4493                        }
4494
4495                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4496                                true, endEntry, true);
4497                        subSetIterator = subSet.iterator();
4498                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4499                            assertEquals(index, ((Entry) subSetIterator.next())
4500                                    .getValue());
4501                        }
4502                    }
4503                }
4504            }
4505        }
4506
4507        String endKey = new Integer(2).toString();
4508        entrySet = tm.headMap(endKey, true).entrySet();
4509        if (entrySet instanceof NavigableSet) {
4510            // [2...0]
4511            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4512                    .descendingSet();
4513            Iterator iterator = descendingSubMapEntrySet.iterator();
4514            startEntry = (Entry) iterator.next();
4515            iterator.next();
4516            endEntry = (Entry) iterator.next();
4517            subSet = descendingSubMapEntrySet.subSet(startEntry, endEntry);
4518            assertEquals(2, subSet.size());
4519
4520            subSet = descendingSubMapEntrySet.subSet(startEntry, false,
4521                    endEntry, false);
4522            assertEquals(1, subSet.size());
4523            subSetIterator = subSet.iterator();
4524            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4525
4526            subSet = descendingSubMapEntrySet.subSet(startEntry, false,
4527                    endEntry, true);
4528            assertEquals(2, subSet.size());
4529            subSetIterator = subSet.iterator();
4530            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4531            assertEquals(198, ((Entry) subSetIterator.next()).getValue());
4532
4533            subSet = descendingSubMapEntrySet.subSet(startEntry, true,
4534                    endEntry, false);
4535            assertEquals(2, subSet.size());
4536            subSetIterator = subSet.iterator();
4537            assertEquals(2, ((Entry) subSetIterator.next()).getValue());
4538            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4539
4540            subSet = descendingSubMapEntrySet.subSet(startEntry, true,
4541                    endEntry, true);
4542            assertEquals(3, subSet.size());
4543            subSetIterator = subSet.iterator();
4544            assertEquals(2, ((Entry) subSetIterator.next()).getValue());
4545            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4546            assertEquals(198, ((Entry) subSetIterator.next()).getValue());
4547        }
4548
4549        // With Comnparator
4550        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
4551        if (entrySet instanceof NavigableSet) {
4552            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4553                    .descendingSet();
4554            Iterator iteratorStart = descendingSubMapEntrySet.iterator();
4555            while (iteratorStart.hasNext()) {
4556                startEntry = (Entry) iteratorStart.next();
4557                Iterator iteratorEnd = descendingSubMapEntrySet.iterator();
4558                while (iteratorEnd.hasNext()) {
4559                    endEntry = (Entry) iteratorEnd.next();
4560                    int startIndex = (Integer) startEntry.getValue();
4561                    int endIndex = (Integer) endEntry.getValue();
4562                    if (startIndex < endIndex) {
4563                        try {
4564                            descendingSubMapEntrySet.subSet(startEntry,
4565                                    endEntry);
4566                            fail("should throw IllegalArgumentException");
4567                        } catch (IllegalArgumentException e) {
4568                            // Expected
4569                        }
4570
4571                        try {
4572                            descendingSubMapEntrySet.subSet(startEntry, false,
4573                                    endEntry, false);
4574                            fail("should throw IllegalArgumentException");
4575                        } catch (IllegalArgumentException e) {
4576                            // Expected
4577                        }
4578
4579                        try {
4580                            descendingSubMapEntrySet.subSet(startEntry, false,
4581                                    endEntry, true);
4582                            fail("should throw IllegalArgumentException");
4583                        } catch (IllegalArgumentException e) {
4584                            // Expected
4585                        }
4586
4587                        try {
4588                            descendingSubMapEntrySet.subSet(startEntry, true,
4589                                    endEntry, false);
4590                            fail("should throw IllegalArgumentException");
4591                        } catch (IllegalArgumentException e) {
4592                            // Expected
4593                        }
4594
4595                        try {
4596                            descendingSubMapEntrySet.subSet(startEntry, true,
4597                                    endEntry, true);
4598                            fail("should throw IllegalArgumentException");
4599                        } catch (IllegalArgumentException e) {
4600                            // Expected
4601                        }
4602                    } else {
4603                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4604                                endEntry);
4605                        subSetIterator = subSet.iterator();
4606                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4607                            assertEquals(index, ((Entry) subSetIterator.next())
4608                                    .getValue());
4609                        }
4610
4611                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4612                                false, endEntry, false);
4613                        subSetIterator = subSet.iterator();
4614                        for (int index = startIndex - 1; subSetIterator
4615                                .hasNext(); index--) {
4616                            assertEquals(index, ((Entry) subSetIterator.next())
4617                                    .getValue());
4618                        }
4619
4620                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4621                                false, endEntry, true);
4622                        subSetIterator = subSet.iterator();
4623                        for (int index = startIndex - 1; subSetIterator
4624                                .hasNext(); index--) {
4625                            assertEquals(index, ((Entry) subSetIterator.next())
4626                                    .getValue());
4627                        }
4628
4629                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4630                                true, endEntry, false);
4631                        subSetIterator = subSet.iterator();
4632                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4633                            assertEquals(index, ((Entry) subSetIterator.next())
4634                                    .getValue());
4635                        }
4636
4637                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4638                                true, endEntry, true);
4639                        subSetIterator = subSet.iterator();
4640                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4641                            assertEquals(index, ((Entry) subSetIterator.next())
4642                                    .getValue());
4643                        }
4644                    }
4645                }
4646            }
4647        }
4648    }
4649
4650    public void test_DescendingSubMapEntrySet_lower() {
4651        Set entrySet, subSet;
4652        NavigableSet descendingSubMapEntrySet;
4653        Iterator iterator;
4654        Entry entry, lowerEntry;
4655        int value;
4656
4657        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4658        if (entrySet instanceof NavigableSet) {
4659            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4660                    .descendingSet();
4661            iterator = descendingSubMapEntrySet.iterator();
4662            while (iterator.hasNext()) {
4663                entry = (Entry) iterator.next();
4664                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4665                value = (Integer) entry.getValue();
4666                if (value < 108) {
4667                    assertEquals(value + 1, lowerEntry.getValue());
4668                } else {
4669                    assertNull(lowerEntry);
4670                }
4671            }
4672
4673            // System.out.println(descendingSubMapEntrySet);
4674            // System.out.println(tm);
4675            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4676                    .iterator().next();
4677            // System.out.println("o:" + afterEnd);
4678            Object x = descendingSubMapEntrySet.lower(afterEnd);
4679            // System.out.println("x:" + x);
4680            assertNull(x);
4681            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4682                    .iterator().next();
4683            // System.out.println("before: " + beforeStart);
4684            Object y = descendingSubMapEntrySet.lower(beforeStart);
4685            // System.out.println("y: " + y);
4686            assertNotNull(y);
4687            assertEquals(101, (((Entry) y).getValue()));
4688        }
4689
4690        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4691        if (entrySet instanceof NavigableSet) {
4692            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4693                    .descendingSet();
4694            iterator = descendingSubMapEntrySet.iterator();
4695            while (iterator.hasNext()) {
4696                entry = (Entry) iterator.next();
4697                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4698                value = (Integer) entry.getValue();
4699                if (value < 109) {
4700                    assertEquals(value + 1, lowerEntry.getValue());
4701                } else {
4702                    assertNull(lowerEntry);
4703                }
4704            }
4705        }
4706
4707        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4708        if (entrySet instanceof NavigableSet) {
4709            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4710                    .descendingSet();
4711            iterator = descendingSubMapEntrySet.iterator();
4712            while (iterator.hasNext()) {
4713                entry = (Entry) iterator.next();
4714                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4715                value = (Integer) entry.getValue();
4716                if (value < 108) {
4717                    assertEquals(value + 1, lowerEntry.getValue());
4718                } else {
4719                    assertNull(lowerEntry);
4720                }
4721            }
4722        }
4723
4724        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4725        if (entrySet instanceof NavigableSet) {
4726            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4727                    .descendingSet();
4728            iterator = descendingSubMapEntrySet.iterator();
4729            while (iterator.hasNext()) {
4730                entry = (Entry) iterator.next();
4731                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4732                value = (Integer) entry.getValue();
4733                if (value < 109) {
4734                    assertEquals(value + 1, lowerEntry.getValue());
4735                } else {
4736                    assertNull(lowerEntry);
4737                }
4738            }
4739        }
4740
4741        String endKey = new Integer(2).toString();
4742        entrySet = tm.headMap(endKey, true).entrySet();
4743        if (entrySet instanceof NavigableSet) {
4744            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4745                    .descendingSet();
4746            iterator = descendingSubMapEntrySet.iterator();
4747            iterator.next();// 2
4748            iterator.next();// 199
4749            entry = (Entry) iterator.next();// 198
4750            lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4751            assertEquals(199, lowerEntry.getValue());
4752        }
4753    }
4754
4755    public void test_DescendingSubMapEntrySet_higher() {
4756        Set entrySet, subSet;
4757        NavigableSet descendingSubMapEntrySet;
4758        Iterator iterator;
4759        Entry entry, higherEntry;
4760        int value;
4761
4762        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4763        if (entrySet instanceof NavigableSet) {
4764            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4765                    .descendingSet();
4766            iterator = descendingSubMapEntrySet.iterator();
4767            while (iterator.hasNext()) {
4768                entry = (Entry) iterator.next();
4769                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4770                value = (Integer) entry.getValue();
4771                if (value > 101) {
4772                    assertEquals(value - 1, higherEntry.getValue());
4773                } else {
4774                    assertNull(higherEntry);
4775                }
4776            }
4777
4778            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4779                    .iterator().next();
4780            Object x = descendingSubMapEntrySet.higher(afterEnd);
4781            assertNotNull(x);
4782            assertEquals(108, ((Entry) x).getValue());
4783            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4784                    .iterator().next();
4785            Object y = descendingSubMapEntrySet.higher(beforeStart);
4786            assertNull(y);
4787        }
4788
4789        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4790        if (entrySet instanceof NavigableSet) {
4791            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4792                    .descendingSet();
4793            iterator = descendingSubMapEntrySet.iterator();
4794            while (iterator.hasNext()) {
4795                entry = (Entry) iterator.next();
4796                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4797                value = (Integer) entry.getValue();
4798                if (value > 101) {
4799                    assertEquals(value - 1, higherEntry.getValue());
4800                } else {
4801                    assertNull(higherEntry);
4802                }
4803            }
4804        }
4805
4806        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4807        if (entrySet instanceof NavigableSet) {
4808            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4809                    .descendingSet();
4810            iterator = descendingSubMapEntrySet.iterator();
4811            while (iterator.hasNext()) {
4812                entry = (Entry) iterator.next();
4813                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4814                value = (Integer) entry.getValue();
4815                if (value > 100) {
4816                    assertEquals(value - 1, higherEntry.getValue());
4817                } else {
4818                    assertNull(higherEntry);
4819                }
4820            }
4821        }
4822
4823        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4824        if (entrySet instanceof NavigableSet) {
4825            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4826                    .descendingSet();
4827            iterator = descendingSubMapEntrySet.iterator();
4828            while (iterator.hasNext()) {
4829                entry = (Entry) iterator.next();
4830                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4831                value = (Integer) entry.getValue();
4832                if (value > 100) {
4833                    assertEquals(value - 1, higherEntry.getValue());
4834                } else {
4835                    assertNull(higherEntry);
4836                }
4837            }
4838        }
4839
4840        String endKey = new Integer(2).toString();
4841        entrySet = tm.headMap(endKey, true).entrySet();
4842        if (entrySet instanceof NavigableSet) {
4843            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4844                    .descendingSet();
4845            iterator = descendingSubMapEntrySet.iterator();
4846            iterator.next();// 2
4847            iterator.next();// 199
4848            entry = (Entry) iterator.next();// 198
4849            higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4850            assertEquals(197, higherEntry.getValue());
4851        }
4852
4853        // With Comparator
4854        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
4855        if (entrySet instanceof NavigableSet) {
4856            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4857                    .descendingSet();
4858            iterator = descendingSubMapEntrySet.iterator();
4859            while (iterator.hasNext()) {
4860                entry = (Entry) iterator.next();
4861                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4862                value = (Integer) entry.getValue();
4863                if (value > 101) {
4864                    assertEquals(value - 1, higherEntry.getValue());
4865                } else {
4866                    assertNull(higherEntry);
4867                }
4868            }
4869
4870            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4871                    .iterator().next();
4872            Object x = descendingSubMapEntrySet.higher(afterEnd);
4873            assertNotNull(x);
4874            assertEquals(108, ((Entry) x).getValue());
4875            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4876                    .iterator().next();
4877            Object y = descendingSubMapEntrySet.higher(beforeStart);
4878            assertNull(y);
4879        }
4880    }
4881
4882    public void test_DescendingSubMapEntrySet_ceiling() {
4883        Set entrySet;
4884        NavigableSet ascendingSubMapEntrySet, descendingSet;
4885        Entry entry;
4886        Entry[] entryArray;
4887
4888        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4889        if (entrySet instanceof NavigableSet) {
4890            ascendingSubMapEntrySet = (NavigableSet) entrySet;
4891            descendingSet = ascendingSubMapEntrySet.descendingSet();
4892            try {
4893                descendingSet.ceiling(null);
4894                fail("should throw NPE");
4895            } catch (NullPointerException e) {
4896                // Expected
4897            }
4898
4899            entryArray = (Entry[]) descendingSet
4900                    .toArray(new Entry[descendingSet.size()]);
4901            for (int i = 0, j = 108; i < entryArray.length; i++) {
4902                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4903                assertEquals(j - i, entry.getValue());
4904            }
4905
4906            // System.out.println(descendingSet);
4907            // System.out.println(tm);
4908            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4909                    .iterator().next();
4910            // System.out.println("o:" + afterEnd);//110
4911            Object x = descendingSet.ceiling(afterEnd);
4912            assertNotNull(x);
4913            // System.out.println("x:" + x);
4914            assertEquals(108, ((Entry) x).getValue());
4915            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4916                    .iterator().next();
4917            // System.out.println("before: " + beforeStart);//0
4918            Object y = descendingSet.ceiling(beforeStart);
4919            assertNull(y);
4920        }
4921
4922        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4923        if (entrySet instanceof NavigableSet) {
4924            ascendingSubMapEntrySet = (NavigableSet) entrySet;
4925            descendingSet = ascendingSubMapEntrySet.descendingSet();
4926            try {
4927                descendingSet.ceiling(null);
4928                fail("should throw NPE");
4929            } catch (NullPointerException e) {
4930                // Expected
4931            }
4932
4933            entryArray = (Entry[]) descendingSet
4934                    .toArray(new Entry[descendingSet.size()]);
4935            for (int i = 0, j = 109; i < entryArray.length; i++) {
4936                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4937                assertEquals(j - i, entry.getValue());
4938            }
4939        }
4940
4941        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4942        if (entrySet instanceof NavigableSet) {
4943            ascendingSubMapEntrySet = (NavigableSet) entrySet;
4944            descendingSet = ascendingSubMapEntrySet.descendingSet();
4945            try {
4946                descendingSet.ceiling(null);
4947                fail("should throw NPE");
4948            } catch (NullPointerException e) {
4949                // Expected
4950            }
4951
4952            entryArray = (Entry[]) descendingSet
4953                    .toArray(new Entry[descendingSet.size()]);
4954            for (int i = 0, j = 108; i < entryArray.length; i++) {
4955                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4956                assertEquals(j - i, entry.getValue());
4957            }
4958        }
4959
4960        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4961        if (entrySet instanceof NavigableSet) {
4962            descendingSet = ((NavigableSet) entrySet).descendingSet();
4963            try {
4964                descendingSet.ceiling(null);
4965                fail("should throw NPE");
4966            } catch (NullPointerException e) {
4967                // Expected
4968            }
4969
4970            entryArray = (Entry[]) descendingSet
4971                    .toArray(new Entry[descendingSet.size()]);
4972            for (int i = 0, j = 109; i < entryArray.length; i++) {
4973                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4974                assertEquals(j - i, entry.getValue());
4975            }
4976        }
4977
4978        String endKey = new Integer(2).toString();
4979        entrySet = tm.headMap(endKey, true).entrySet();
4980        if (entrySet instanceof NavigableSet) {
4981            descendingSet = ((NavigableSet) entrySet).descendingSet();
4982            try {
4983                descendingSet.ceiling(null);
4984                fail("should throw NPE");
4985            } catch (NullPointerException e) {
4986                // Expected
4987            }
4988
4989            Iterator iterator = descendingSet.iterator();
4990            Entry ceilingEntry;
4991            while (iterator.hasNext()) {
4992                entry = (Entry) iterator.next();
4993                ceilingEntry = (Entry) descendingSet.ceiling(entry);
4994                assertEquals(entry, ceilingEntry);
4995            }
4996        }
4997
4998    }
4999
5000    public void test_DescendingSubMapEntrySet_floor() {
5001        Set entrySet;
5002        NavigableSet ascendingSubMapEntrySet, descendingSet;
5003        Entry entry;
5004        Entry[] entryArray;
5005
5006        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
5007        if (entrySet instanceof NavigableSet) {
5008            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5009            descendingSet = ascendingSubMapEntrySet.descendingSet();
5010            try {
5011                descendingSet.floor(null);
5012                fail("should throw NPE");
5013            } catch (NullPointerException e) {
5014                // Expected
5015            }
5016
5017            entryArray = (Entry[]) descendingSet
5018                    .toArray(new Entry[descendingSet.size()]);
5019            for (int i = 0, j = 108; i < entryArray.length; i++) {
5020                entry = (Entry) descendingSet.floor(entryArray[i]);
5021                assertEquals(j - i, entry.getValue());
5022            }
5023
5024            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
5025                    .iterator().next();
5026            Object x = descendingSet.floor(afterEnd);
5027            assertNull(x);
5028
5029            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
5030                    .iterator().next();
5031            Object y = descendingSet.floor(beforeStart);
5032            assertNotNull(y);
5033            assertEquals(101, (((Entry) y).getValue()));
5034        }
5035
5036        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
5037        if (entrySet instanceof NavigableSet) {
5038            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5039            descendingSet = ascendingSubMapEntrySet.descendingSet();
5040            try {
5041                descendingSet.floor(null);
5042                fail("should throw NPE");
5043            } catch (NullPointerException e) {
5044                // Expected
5045            }
5046
5047            entryArray = (Entry[]) descendingSet
5048                    .toArray(new Entry[descendingSet.size()]);
5049            for (int i = 0, j = 109; i < entryArray.length; i++) {
5050                entry = (Entry) descendingSet.floor(entryArray[i]);
5051                assertEquals(j - i, entry.getValue());
5052            }
5053        }
5054
5055        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
5056        if (entrySet instanceof NavigableSet) {
5057            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5058            descendingSet = ascendingSubMapEntrySet.descendingSet();
5059            try {
5060                descendingSet.floor(null);
5061                fail("should throw NPE");
5062            } catch (NullPointerException e) {
5063                // Expected
5064            }
5065
5066            entryArray = (Entry[]) descendingSet
5067                    .toArray(new Entry[descendingSet.size()]);
5068            for (int i = 0, j = 108; i < entryArray.length; i++) {
5069                entry = (Entry) descendingSet.floor(entryArray[i]);
5070                assertEquals(j - i, entry.getValue());
5071            }
5072        }
5073
5074        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
5075        if (entrySet instanceof NavigableSet) {
5076            descendingSet = ((NavigableSet) entrySet).descendingSet();
5077            try {
5078                descendingSet.floor(null);
5079                fail("should throw NPE");
5080            } catch (NullPointerException e) {
5081                // Expected
5082            }
5083
5084            entryArray = (Entry[]) descendingSet
5085                    .toArray(new Entry[descendingSet.size()]);
5086            for (int i = 0, j = 109; i < entryArray.length; i++) {
5087                entry = (Entry) descendingSet.floor(entryArray[i]);
5088                assertEquals(j - i, entry.getValue());
5089            }
5090        }
5091
5092        String endKey = new Integer(2).toString();
5093        entrySet = tm.headMap(endKey, true).entrySet();
5094        if (entrySet instanceof NavigableSet) {
5095            descendingSet = ((NavigableSet) entrySet).descendingSet();
5096
5097            Iterator iterator = descendingSet.iterator();
5098            Entry floorEntry;
5099            while (iterator.hasNext()) {
5100                entry = (Entry) iterator.next();
5101                floorEntry = (Entry) descendingSet.floor(entry);
5102                assertEquals(entry, floorEntry);
5103            }
5104        }
5105
5106        // With Comparator
5107        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
5108        if (entrySet instanceof NavigableSet) {
5109            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5110            descendingSet = ascendingSubMapEntrySet.descendingSet();
5111            try {
5112                descendingSet.floor(null);
5113                fail("should throw NPE");
5114            } catch (NullPointerException e) {
5115                // Expected
5116            }
5117
5118            entryArray = (Entry[]) descendingSet
5119                    .toArray(new Entry[descendingSet.size()]);
5120            for (int i = 0, j = 108; i < entryArray.length; i++) {
5121                entry = (Entry) descendingSet.floor(entryArray[i]);
5122                assertEquals(j - i, entry.getValue());
5123            }
5124        }
5125
5126        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
5127        if (entrySet instanceof NavigableSet) {
5128            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5129            descendingSet = ascendingSubMapEntrySet.descendingSet();
5130            try {
5131                descendingSet.floor(null);
5132                fail("should throw NPE");
5133            } catch (NullPointerException e) {
5134                // Expected
5135            }
5136
5137            entryArray = (Entry[]) descendingSet
5138                    .toArray(new Entry[descendingSet.size()]);
5139            for (int i = 0, j = 109; i < entryArray.length; i++) {
5140                entry = (Entry) descendingSet.floor(entryArray[i]);
5141                assertEquals(j - i, entry.getValue());
5142            }
5143        }
5144
5145        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
5146        if (entrySet instanceof NavigableSet) {
5147            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5148            descendingSet = ascendingSubMapEntrySet.descendingSet();
5149            try {
5150                descendingSet.floor(null);
5151                fail("should throw NPE");
5152            } catch (NullPointerException e) {
5153                // Expected
5154            }
5155
5156            entryArray = (Entry[]) descendingSet
5157                    .toArray(new Entry[descendingSet.size()]);
5158            for (int i = 0, j = 108; i < entryArray.length; i++) {
5159                entry = (Entry) descendingSet.floor(entryArray[i]);
5160                assertEquals(j - i, entry.getValue());
5161            }
5162        }
5163
5164        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
5165        if (entrySet instanceof NavigableSet) {
5166            descendingSet = ((NavigableSet) entrySet).descendingSet();
5167            try {
5168                descendingSet.floor(null);
5169                fail("should throw NPE");
5170            } catch (NullPointerException e) {
5171                // Expected
5172            }
5173
5174            entryArray = (Entry[]) descendingSet
5175                    .toArray(new Entry[descendingSet.size()]);
5176            for (int i = 0, j = 109; i < entryArray.length; i++) {
5177                entry = (Entry) descendingSet.floor(entryArray[i]);
5178                assertEquals(j - i, entry.getValue());
5179            }
5180        }
5181    }
5182
5183    public void test_DescendingSubMapKeySet_comparator() {
5184        NavigableSet keySet, descendingKeySet;
5185        Comparator comparator;
5186        String[] keyArray;
5187        Integer value1, value2;
5188
5189        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
5190        assertNull(keySet.comparator());
5191        descendingKeySet = keySet.descendingSet();
5192        comparator = descendingKeySet.comparator();
5193        assertNotNull(comparator);
5194        keyArray = (String[]) descendingKeySet
5195                .toArray(new String[descendingKeySet.size()]);
5196        for (int i = 1; i < keyArray.length; i++) {
5197            value1 = Integer.valueOf(keyArray[i - 1]);
5198            value2 = Integer.valueOf(keyArray[i]);
5199            assertTrue(value1 > value2);
5200            assertTrue(comparator.compare(value1, value2) < 0);
5201        }
5202
5203        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
5204        assertNull(keySet.comparator());
5205        descendingKeySet = keySet.descendingSet();
5206        comparator = descendingKeySet.comparator();
5207        assertNotNull(comparator);
5208        keyArray = (String[]) descendingKeySet
5209                .toArray(new String[descendingKeySet.size()]);
5210        for (int i = 1; i < keyArray.length; i++) {
5211            value1 = Integer.valueOf(keyArray[i - 1]);
5212            value2 = Integer.valueOf(keyArray[i]);
5213            assertTrue(value1 > value2);
5214            assertTrue(comparator.compare(value1, value2) < 0);
5215        }
5216
5217        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
5218        assertNull(keySet.comparator());
5219        descendingKeySet = keySet.descendingSet();
5220        comparator = descendingKeySet.comparator();
5221        assertNotNull(comparator);
5222        keyArray = (String[]) descendingKeySet
5223                .toArray(new String[descendingKeySet.size()]);
5224        for (int i = 1; i < keyArray.length; i++) {
5225            value1 = Integer.valueOf(keyArray[i - 1]);
5226            value2 = Integer.valueOf(keyArray[i]);
5227            assertTrue(value1 > value2);
5228            assertTrue(comparator.compare(value1, value2) < 0);
5229        }
5230
5231        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
5232        assertNull(keySet.comparator());
5233        descendingKeySet = keySet.descendingSet();
5234        comparator = descendingKeySet.comparator();
5235        assertNotNull(comparator);
5236        keyArray = (String[]) descendingKeySet
5237                .toArray(new String[descendingKeySet.size()]);
5238        for (int i = 1; i < keyArray.length; i++) {
5239            value1 = Integer.valueOf(keyArray[i - 1]);
5240            value2 = Integer.valueOf(keyArray[i]);
5241            assertTrue(value1 > value2);
5242            assertTrue(comparator.compare(value1, value2) < 0);
5243        }
5244
5245        String endKey = new Integer(2).toString();
5246        keySet = tm.headMap(endKey, true).navigableKeySet();
5247        assertNull(keySet.comparator());
5248        descendingKeySet = keySet.descendingSet();
5249        assertNotNull(descendingKeySet.comparator());
5250    }
5251
5252    public void test_AscendingSubMapKeySet_first() {
5253        NavigableSet keySet;
5254        String firstKey1 = new Integer(100).toString();
5255        String firstKey2 = new Integer(101).toString();
5256
5257        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
5258        assertEquals(firstKey2, keySet.first());
5259
5260        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
5261        assertEquals(firstKey2, keySet.first());
5262
5263        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
5264        assertEquals(firstKey1, keySet.first());
5265
5266        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
5267        assertEquals(firstKey1, keySet.first());
5268    }
5269
5270    public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endExcluded() {
5271        NavigableSet keySet = navigableMap_startExcluded_endExcluded
5272                .navigableKeySet();
5273        NavigableSet descendingKeySet = keySet.descendingSet();
5274        Iterator iterator = descendingKeySet.iterator();
5275        assertEquals(8, keySet.size());
5276        for (int value = 101; value < 109; value++) {
5277            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5278        }
5279        assertEquals(0, keySet.size());
5280        assertNull(keySet.pollLast());
5281    }
5282
5283    public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endIncluded() {
5284        NavigableSet keySet = navigableMap_startExcluded_endIncluded
5285                .navigableKeySet();
5286        NavigableSet descendingKeySet = keySet.descendingSet();
5287        Iterator iterator = descendingKeySet.iterator();
5288        assertEquals(9, keySet.size());
5289        for (int value = 101; value < 110; value++) {
5290            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5291        }
5292        assertEquals(0, keySet.size());
5293        assertNull(keySet.pollLast());
5294    }
5295
5296    public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endExcluded() {
5297        NavigableSet keySet = navigableMap_startIncluded_endExcluded
5298                .navigableKeySet();
5299        NavigableSet descendingKeySet = keySet.descendingSet();
5300        Iterator iterator = descendingKeySet.iterator();
5301        assertEquals(9, keySet.size());
5302        for (int value = 100; value < 109; value++) {
5303            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5304        }
5305        assertEquals(0, keySet.size());
5306        assertNull(keySet.pollLast());
5307    }
5308
5309    public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endIncluded() {
5310        NavigableSet keySet = navigableMap_startIncluded_endIncluded
5311                .navigableKeySet();
5312        NavigableSet descendingKeySet = keySet.descendingSet();
5313        Iterator iterator = descendingKeySet.iterator();
5314        assertEquals(10, keySet.size());
5315        for (int value = 100; value < 110; value++) {
5316            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5317        }
5318        assertEquals(0, keySet.size());
5319        assertNull(keySet.pollLast());
5320    }
5321
5322    public void test_DescendingSubMapKeySet_pollFirst() {
5323        String endKey = new Integer(2).toString();
5324        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
5325        NavigableSet descendingKeySet = keySet.descendingSet();
5326        assertEquals(endKey, descendingKeySet.pollFirst());
5327    }
5328
5329    public void test_DescendingSubMapKeySet_pollLast_startExcluded_endExcluded() {
5330        NavigableSet keySet = navigableMap_startExcluded_endExcluded
5331                .navigableKeySet();
5332        NavigableSet descendingKeySet = keySet.descendingSet();
5333        Iterator iterator = descendingKeySet.iterator();
5334        assertEquals(8, keySet.size());
5335        for (int value = 108; value > 100; value--) {
5336            assertEquals(new Integer(value).toString(), keySet.pollLast());
5337        }
5338        assertEquals(0, keySet.size());
5339        assertNull(keySet.pollLast());
5340    }
5341
5342    public void test_DescendingSubMapKeySet_pollLast_startExcluded_endIncluded() {
5343        NavigableSet keySet = navigableMap_startExcluded_endIncluded
5344                .navigableKeySet();
5345        NavigableSet descendingKeySet = keySet.descendingSet();
5346        Iterator iterator = descendingKeySet.iterator();
5347        assertEquals(9, keySet.size());
5348        for (int value = 109; value > 100; value--) {
5349            assertEquals(new Integer(value).toString(), keySet.pollLast());
5350        }
5351        assertEquals(0, keySet.size());
5352        assertNull(keySet.pollLast());
5353    }
5354
5355    public void test_DescendingSubMapKeySet_pollLast_startIncluded_endExcluded() {
5356        NavigableSet keySet = navigableMap_startIncluded_endExcluded
5357                .navigableKeySet();
5358        NavigableSet descendingKeySet = keySet.descendingSet();
5359        Iterator iterator = descendingKeySet.iterator();
5360        assertEquals(9, keySet.size());
5361        for (int value = 108; value > 99; value--) {
5362            assertEquals(new Integer(value).toString(), keySet.pollLast());
5363        }
5364        assertEquals(0, keySet.size());
5365        assertNull(keySet.pollLast());
5366    }
5367
5368    public void test_DescendingSubMapKeySet_pollLast_startIncluded_endIncluded() {
5369        NavigableSet keySet = navigableMap_startIncluded_endIncluded
5370                .navigableKeySet();
5371        NavigableSet descendingKeySet = keySet.descendingSet();
5372        Iterator iterator = descendingKeySet.iterator();
5373        assertEquals(10, keySet.size());
5374        for (int value = 109; value > 99; value--) {
5375            assertEquals(new Integer(value).toString(), keySet.pollLast());
5376        }
5377        assertEquals(0, keySet.size());
5378        assertNull(keySet.pollLast());
5379    }
5380
5381    public void test_DescendingSubMapKeySet_pollLast() {
5382        String endKey = new Integer(2).toString();
5383        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
5384        NavigableSet descendingKeySet = keySet.descendingSet();
5385        assertEquals(new Integer(0).toString(), descendingKeySet.pollLast());
5386    }
5387
5388    public void test_DescendingSubMapKeySet_headSet() {
5389        NavigableSet keySet, descendingKeySet;
5390        SortedSet headSet;
5391        String endKey, key;
5392        Iterator iterator;
5393        int index;
5394
5395        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
5396        descendingKeySet = keySet.descendingSet();
5397        endKey = new Integer(99).toString();
5398        try {
5399            descendingKeySet.headSet(endKey);
5400            fail("should throw IllegalArgumentException");
5401        } catch (IllegalArgumentException e) {
5402            // Expected
5403        }
5404        try {
5405            descendingKeySet.headSet(endKey, false);
5406            fail("should throw IllegalArgumentException");
5407        } catch (IllegalArgumentException e) {
5408            // Expected
5409        }
5410        try {
5411            descendingKeySet.headSet(endKey, true);
5412            fail("should throw IllegalArgumentException");
5413        } catch (IllegalArgumentException e) {
5414            // Expected
5415        }
5416
5417        endKey = new Integer(100).toString();
5418        headSet = descendingKeySet.headSet(endKey);
5419        iterator = headSet.iterator();
5420        for (index = 108; iterator.hasNext(); index--) {
5421            key = (String) iterator.next();
5422            assertEquals(new Integer(index).toString(), key);
5423        }
5424        assertEquals(100, index);
5425
5426        headSet = descendingKeySet.headSet(endKey, false);
5427        iterator = headSet.iterator();
5428        for (index = 108; iterator.hasNext(); index--) {
5429            key = (String) iterator.next();
5430            assertEquals(new Integer(index).toString(), key);
5431        }
5432        assertEquals(100, index);
5433
5434        try {
5435            descendingKeySet.headSet(endKey, true);
5436            fail("should throw IllegalArgumentException");
5437        } catch (IllegalArgumentException e) {
5438            // Expected
5439        }
5440
5441        endKey = new Integer(101).toString();
5442        headSet = descendingKeySet.headSet(endKey);
5443        iterator = headSet.iterator();
5444        for (index = 108; iterator.hasNext(); index--) {
5445            key = (String) iterator.next();
5446            assertEquals(new Integer(index).toString(), key);
5447        }
5448        assertEquals(101, index);
5449
5450        headSet = descendingKeySet.headSet(endKey, false);
5451        iterator = headSet.iterator();
5452        for (index = 108; iterator.hasNext(); index--) {
5453            key = (String) iterator.next();
5454            assertEquals(new Integer(index).toString(), key);
5455        }
5456        assertEquals(101, index);
5457
5458        headSet = descendingKeySet.headSet(endKey, true);
5459        iterator = headSet.iterator();
5460        for (index = 108; iterator.hasNext(); index--) {
5461            key = (String) iterator.next();
5462            assertEquals(new Integer(index).toString(), key);
5463        }
5464        assertEquals(100, index);
5465
5466        for (int i = 102; i < 109; i++) {
5467            endKey = new Integer(i).toString();
5468            headSet = descendingKeySet.headSet(endKey);
5469            iterator = headSet.iterator();
5470            int j;
5471            for (j = 108; iterator.hasNext(); j--) {
5472                key = (String) iterator.next();
5473                assertEquals(new Integer(j).toString(), key);
5474            }
5475            assertEquals(i, j);
5476
5477            headSet = descendingKeySet.headSet(endKey, false);
5478            iterator = headSet.iterator();
5479            for (j = 108; iterator.hasNext(); j--) {
5480                key = (String) iterator.next();
5481                assertEquals(new Integer(j).toString(), key);
5482            }
5483            assertEquals(i, j);
5484
5485            headSet = descendingKeySet.headSet(endKey, true);
5486            iterator = headSet.iterator();
5487            for (j = 108; iterator.hasNext(); j--) {
5488                key = (String) iterator.next();
5489                assertEquals(new Integer(j).toString(), key);
5490            }
5491            assertEquals(i - 1, j);
5492        }
5493
5494        endKey = new Integer(109).toString();
5495        try {
5496            headSet = descendingKeySet.headSet(endKey);
5497            fail("should throw IllegalArgumentException");
5498        } catch (IllegalArgumentException expected) {
5499            // Expected
5500        }
5501
5502        try {
5503            descendingKeySet.headSet(endKey, false);
5504            fail("should throw IllegalArgumentException");
5505        } catch (IllegalArgumentException e) {
5506            // Expected
5507        }
5508
5509        try {
5510            descendingKeySet.headSet(endKey, true);
5511            fail("should throw IllegalArgumentException");
5512        } catch (IllegalArgumentException e) {
5513            // Expected
5514        }
5515
5516        endKey = new Integer(110).toString();
5517        try {
5518            descendingKeySet.headSet(endKey);
5519            fail("should throw IllegalArgumentException");
5520        } catch (IllegalArgumentException e) {
5521            // Expected
5522        }
5523        try {
5524            descendingKeySet.headSet(endKey, true);
5525            fail("should throw IllegalArgumentException");
5526        } catch (IllegalArgumentException e) {
5527            // Expected
5528        }
5529        try {
5530            descendingKeySet.headSet(endKey, false);
5531            fail("should throw IllegalArgumentException");
5532        } catch (IllegalArgumentException e) {
5533            // Expected
5534        }
5535
5536        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
5537        descendingKeySet = keySet.descendingSet();
5538        endKey = new Integer(99).toString();
5539        try {
5540            descendingKeySet.headSet(endKey);
5541            fail("should throw IllegalArgumentException");
5542        } catch (IllegalArgumentException e) {
5543            // Expected
5544        }
5545        try {
5546            descendingKeySet.headSet(endKey, false);
5547            fail("should throw IllegalArgumentException");
5548        } catch (IllegalArgumentException e) {
5549            // Expected
5550        }
5551        try {
5552            descendingKeySet.headSet(endKey, true);
5553            fail("should throw IllegalArgumentException");
5554        } catch (IllegalArgumentException e) {
5555            // Expected
5556        }
5557
5558        endKey = new Integer(100).toString();
5559        headSet = descendingKeySet.headSet(endKey);
5560        iterator = headSet.iterator();
5561        for (index = 109; iterator.hasNext(); index--) {
5562            key = (String) iterator.next();
5563            assertEquals(new Integer(index).toString(), key);
5564        }
5565        assertEquals(100, index);
5566
5567        headSet = descendingKeySet.headSet(endKey, false);
5568        iterator = headSet.iterator();
5569        for (index = 109; iterator.hasNext(); index--) {
5570            key = (String) iterator.next();
5571            assertEquals(new Integer(index).toString(), key);
5572        }
5573        assertEquals(100, index);
5574
5575        try {
5576            descendingKeySet.headSet(endKey, true);
5577            fail("should throw IllegalArgumentException");
5578        } catch (IllegalArgumentException e) {
5579            // Expected
5580        }
5581
5582        endKey = new Integer(101).toString();
5583        headSet = descendingKeySet.headSet(endKey);
5584        iterator = headSet.iterator();
5585        for (index = 109; iterator.hasNext(); index--) {
5586            key = (String) iterator.next();
5587            assertEquals(new Integer(index).toString(), key);
5588        }
5589        assertEquals(101, index);
5590
5591        headSet = descendingKeySet.headSet(endKey, false);
5592        iterator = headSet.iterator();
5593        for (index = 109; iterator.hasNext(); index--) {
5594            key = (String) iterator.next();
5595            assertEquals(new Integer(index).toString(), key);
5596        }
5597        assertEquals(101, index);
5598
5599        headSet = descendingKeySet.headSet(endKey, true);
5600        iterator = headSet.iterator();
5601        for (index = 109; iterator.hasNext(); index--) {
5602            key = (String) iterator.next();
5603            assertEquals(new Integer(index).toString(), key);
5604        }
5605        assertEquals(100, index);
5606
5607        for (int i = 102; i < 109; i++) {
5608            endKey = new Integer(i).toString();
5609            headSet = descendingKeySet.headSet(endKey);
5610            iterator = headSet.iterator();
5611            int j;
5612            for (j = 109; iterator.hasNext(); j--) {
5613                key = (String) iterator.next();
5614                assertEquals(new Integer(j).toString(), key);
5615            }
5616            assertEquals(i, j);
5617
5618            headSet = descendingKeySet.headSet(endKey, false);
5619            iterator = headSet.iterator();
5620            for (j = 109; iterator.hasNext(); j--) {
5621                key = (String) iterator.next();
5622                assertEquals(new Integer(j).toString(), key);
5623            }
5624            assertEquals(i, j);
5625
5626            headSet = descendingKeySet.headSet(endKey, true);
5627            iterator = headSet.iterator();
5628            for (j = 109; iterator.hasNext(); j--) {
5629                key = (String) iterator.next();
5630                assertEquals(new Integer(j).toString(), key);
5631            }
5632            assertEquals(i - 1, j);
5633        }
5634
5635        endKey = new Integer(109).toString();
5636        headSet = descendingKeySet.headSet(endKey);
5637        iterator = headSet.iterator();
5638        for (index = 109; iterator.hasNext(); index--) {
5639            key = (String) iterator.next();
5640            assertEquals(new Integer(index).toString(), key);
5641        }
5642        assertEquals(109, index);
5643
5644        headSet = descendingKeySet.headSet(endKey, false);
5645        iterator = headSet.iterator();
5646        for (index = 109; iterator.hasNext(); index--) {
5647            key = (String) iterator.next();
5648            assertEquals(new Integer(index).toString(), key);
5649        }
5650        assertEquals(109, index);
5651
5652        headSet = descendingKeySet.headSet(endKey, true);
5653        iterator = headSet.iterator();
5654        for (index = 109; iterator.hasNext(); index--) {
5655            key = (String) iterator.next();
5656            assertEquals(new Integer(index).toString(), key);
5657        }
5658        assertEquals(108, index);
5659
5660        endKey = new Integer(110).toString();
5661        try {
5662            descendingKeySet.headSet(endKey);
5663            fail("should throw IllegalArgumentException");
5664        } catch (IllegalArgumentException e) {
5665            // Expected
5666        }
5667        try {
5668            descendingKeySet.headSet(endKey, true);
5669            fail("should throw IllegalArgumentException");
5670        } catch (IllegalArgumentException e) {
5671            // Expected
5672        }
5673        try {
5674            descendingKeySet.headSet(endKey, false);
5675            fail("should throw IllegalArgumentException");
5676        } catch (IllegalArgumentException e) {
5677            // Expected
5678        }
5679
5680        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
5681        descendingKeySet = keySet.descendingSet();
5682        endKey = new Integer(99).toString();
5683        try {
5684            descendingKeySet.headSet(endKey);
5685            fail("should throw IllegalArgumentException");
5686        } catch (IllegalArgumentException e) {
5687            // Expected
5688        }
5689        try {
5690            descendingKeySet.headSet(endKey, false);
5691            fail("should throw IllegalArgumentException");
5692        } catch (IllegalArgumentException e) {
5693            // Expected
5694        }
5695        try {
5696            descendingKeySet.headSet(endKey, true);
5697            fail("should throw IllegalArgumentException");
5698        } catch (IllegalArgumentException e) {
5699            // Expected
5700        }
5701
5702        endKey = new Integer(100).toString();
5703        headSet = descendingKeySet.headSet(endKey);
5704        iterator = headSet.iterator();
5705        for (index = 108; iterator.hasNext(); index--) {
5706            key = (String) iterator.next();
5707            assertEquals(new Integer(index).toString(), key);
5708        }
5709        assertEquals(100, index);
5710
5711        headSet = descendingKeySet.headSet(endKey, false);
5712        iterator = headSet.iterator();
5713        for (index = 108; iterator.hasNext(); index--) {
5714            key = (String) iterator.next();
5715            assertEquals(new Integer(index).toString(), key);
5716        }
5717        assertEquals(100, index);
5718
5719        headSet = descendingKeySet.headSet(endKey, true);
5720        iterator = headSet.iterator();
5721        for (index = 108; iterator.hasNext(); index--) {
5722            key = (String) iterator.next();
5723            assertEquals(new Integer(index).toString(), key);
5724        }
5725        assertEquals(99, index);
5726
5727        endKey = new Integer(101).toString();
5728        headSet = descendingKeySet.headSet(endKey);
5729        iterator = headSet.iterator();
5730        for (index = 108; iterator.hasNext(); index--) {
5731            key = (String) iterator.next();
5732            assertEquals(new Integer(index).toString(), key);
5733        }
5734        assertEquals(101, index);
5735
5736        headSet = descendingKeySet.headSet(endKey, false);
5737        iterator = headSet.iterator();
5738        for (index = 108; iterator.hasNext(); index--) {
5739            key = (String) iterator.next();
5740            assertEquals(new Integer(index).toString(), key);
5741        }
5742        assertEquals(101, index);
5743
5744        headSet = descendingKeySet.headSet(endKey, true);
5745        iterator = headSet.iterator();
5746        for (index = 108; iterator.hasNext(); index--) {
5747            key = (String) iterator.next();
5748            assertEquals(new Integer(index).toString(), key);
5749        }
5750        assertEquals(100, index);
5751
5752        for (int i = 102; i < 109; i++) {
5753            endKey = new Integer(i).toString();
5754            headSet = descendingKeySet.headSet(endKey);
5755            iterator = headSet.iterator();
5756            int j;
5757            for (j = 108; iterator.hasNext(); j--) {
5758                key = (String) iterator.next();
5759                assertEquals(new Integer(j).toString(), key);
5760            }
5761            assertEquals(i, j);
5762
5763            headSet = descendingKeySet.headSet(endKey, false);
5764            iterator = headSet.iterator();
5765            for (j = 108; iterator.hasNext(); j--) {
5766                key = (String) iterator.next();
5767                assertEquals(new Integer(j).toString(), key);
5768            }
5769            assertEquals(i, j);
5770
5771            headSet = descendingKeySet.headSet(endKey, true);
5772            iterator = headSet.iterator();
5773            for (j = 108; iterator.hasNext(); j--) {
5774                key = (String) iterator.next();
5775                assertEquals(new Integer(j).toString(), key);
5776            }
5777            assertEquals(i - 1, j);
5778        }
5779
5780        endKey = new Integer(109).toString();
5781
5782        try {
5783            descendingKeySet.headSet(endKey);
5784            fail("should throw IllegalArgumentException");
5785        } catch (IllegalArgumentException e) {
5786            // Expected
5787        }
5788
5789        try {
5790            descendingKeySet.headSet(endKey, false);
5791            fail("should throw IllegalArgumentException");
5792        } catch (IllegalArgumentException e) {
5793            // Expected
5794        }
5795
5796        try {
5797            descendingKeySet.headSet(endKey, true);
5798            fail("should throw IllegalArgumentException");
5799        } catch (IllegalArgumentException e) {
5800            // Expected
5801        }
5802
5803        endKey = new Integer(110).toString();
5804        try {
5805            descendingKeySet.headSet(endKey);
5806            fail("should throw IllegalArgumentException");
5807        } catch (IllegalArgumentException e) {
5808            // Expected
5809        }
5810        try {
5811            descendingKeySet.headSet(endKey, true);
5812            fail("should throw IllegalArgumentException");
5813        } catch (IllegalArgumentException e) {
5814            // Expected
5815        }
5816        try {
5817            descendingKeySet.headSet(endKey, false);
5818            fail("should throw IllegalArgumentException");
5819        } catch (IllegalArgumentException e) {
5820            // Expected
5821        }
5822
5823        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
5824        descendingKeySet = keySet.descendingSet();
5825        endKey = new Integer(99).toString();
5826        try {
5827            descendingKeySet.headSet(endKey);
5828            fail("should throw IllegalArgumentException");
5829        } catch (IllegalArgumentException e) {
5830            // Expected
5831        }
5832        try {
5833            descendingKeySet.headSet(endKey, false);
5834            fail("should throw IllegalArgumentException");
5835        } catch (IllegalArgumentException e) {
5836            // Expected
5837        }
5838        try {
5839            descendingKeySet.headSet(endKey, true);
5840            fail("should throw IllegalArgumentException");
5841        } catch (IllegalArgumentException e) {
5842            // Expected
5843        }
5844
5845        endKey = new Integer(100).toString();
5846        headSet = descendingKeySet.headSet(endKey);
5847        iterator = headSet.iterator();
5848        for (index = 109; iterator.hasNext(); index--) {
5849            key = (String) iterator.next();
5850            assertEquals(new Integer(index).toString(), key);
5851        }
5852        assertEquals(100, index);
5853
5854        headSet = descendingKeySet.headSet(endKey, false);
5855        iterator = headSet.iterator();
5856        for (index = 109; iterator.hasNext(); index--) {
5857            key = (String) iterator.next();
5858            assertEquals(new Integer(index).toString(), key);
5859        }
5860        assertEquals(100, index);
5861
5862        headSet = descendingKeySet.headSet(endKey, true);
5863        iterator = headSet.iterator();
5864        for (index = 109; iterator.hasNext(); index--) {
5865            key = (String) iterator.next();
5866            assertEquals(new Integer(index).toString(), key);
5867        }
5868        assertEquals(99, index);
5869
5870        endKey = new Integer(101).toString();
5871        headSet = descendingKeySet.headSet(endKey);
5872        iterator = headSet.iterator();
5873        for (index = 109; iterator.hasNext(); index--) {
5874            key = (String) iterator.next();
5875            assertEquals(new Integer(index).toString(), key);
5876        }
5877        assertEquals(101, index);
5878
5879        headSet = descendingKeySet.headSet(endKey, false);
5880        iterator = headSet.iterator();
5881        for (index = 109; iterator.hasNext(); index--) {
5882            key = (String) iterator.next();
5883            assertEquals(new Integer(index).toString(), key);
5884        }
5885        assertEquals(101, index);
5886
5887        headSet = descendingKeySet.headSet(endKey, true);
5888        iterator = headSet.iterator();
5889        for (index = 109; iterator.hasNext(); index--) {
5890            key = (String) iterator.next();
5891            assertEquals(new Integer(index).toString(), key);
5892        }
5893        assertEquals(100, index);
5894
5895        for (int i = 102; i < 109; i++) {
5896            endKey = new Integer(i).toString();
5897            headSet = descendingKeySet.headSet(endKey);
5898            iterator = headSet.iterator();
5899            int j;
5900            for (j = 109; iterator.hasNext(); j--) {
5901                key = (String) iterator.next();
5902                assertEquals(new Integer(j).toString(), key);
5903            }
5904            assertEquals(i, j);
5905
5906            headSet = descendingKeySet.headSet(endKey, false);
5907            iterator = headSet.iterator();
5908            for (j = 109; iterator.hasNext(); j--) {
5909                key = (String) iterator.next();
5910                assertEquals(new Integer(j).toString(), key);
5911            }
5912            assertEquals(i, j);
5913
5914            headSet = descendingKeySet.headSet(endKey, true);
5915            iterator = headSet.iterator();
5916            for (j = 109; iterator.hasNext(); j--) {
5917                key = (String) iterator.next();
5918                assertEquals(new Integer(j).toString(), key);
5919            }
5920            assertEquals(i - 1, j);
5921        }
5922
5923        endKey = new Integer(109).toString();
5924        headSet = descendingKeySet.headSet(endKey);
5925        iterator = headSet.iterator();
5926        for (index = 109; iterator.hasNext(); index--) {
5927            key = (String) iterator.next();
5928            assertEquals(new Integer(index).toString(), key);
5929        }
5930        assertEquals(109, index);
5931
5932        headSet = descendingKeySet.headSet(endKey, false);
5933        iterator = headSet.iterator();
5934        for (index = 109; iterator.hasNext(); index--) {
5935            key = (String) iterator.next();
5936            assertEquals(new Integer(index).toString(), key);
5937        }
5938        assertEquals(109, index);
5939
5940        headSet = descendingKeySet.headSet(endKey, true);
5941        iterator = headSet.iterator();
5942        for (index = 109; iterator.hasNext(); index--) {
5943            key = (String) iterator.next();
5944            assertEquals(new Integer(index).toString(), key);
5945        }
5946        assertEquals(108, index);
5947
5948        endKey = new Integer(110).toString();
5949        try {
5950            descendingKeySet.headSet(endKey);
5951            fail("should throw IllegalArgumentException");
5952        } catch (IllegalArgumentException e) {
5953            // Expected
5954        }
5955        try {
5956            descendingKeySet.headSet(endKey, true);
5957            fail("should throw IllegalArgumentException");
5958        } catch (IllegalArgumentException e) {
5959            // Expected
5960        }
5961        try {
5962            descendingKeySet.headSet(endKey, false);
5963            fail("should throw IllegalArgumentException");
5964        } catch (IllegalArgumentException e) {
5965            // Expected
5966        }
5967
5968        key = new Integer(2).toString();
5969        keySet = tm.headMap(key, true).navigableKeySet();
5970        descendingKeySet = keySet.descendingSet();
5971        iterator = descendingKeySet.iterator();
5972        iterator.next();
5973        endKey = (String) iterator.next();
5974
5975        headSet = descendingKeySet.headSet(endKey);
5976        assertEquals(1, headSet.size());
5977
5978        headSet = descendingKeySet.headSet(endKey, false);
5979        assertEquals(1, headSet.size());
5980
5981        headSet = descendingKeySet.headSet(endKey, true);
5982        assertEquals(2, headSet.size());
5983
5984        key = new Integer(2).toString();
5985        keySet = tm.tailMap(key, true).navigableKeySet();
5986        descendingKeySet = keySet.descendingSet();
5987        iterator = descendingKeySet.iterator();
5988        iterator.next();
5989        endKey = (String) iterator.next();
5990        headSet = descendingKeySet.headSet(endKey);
5991        assertEquals(1, headSet.size());
5992        iterator = headSet.iterator();
5993        assertEquals(999, Integer.parseInt((String) iterator.next()));
5994    }
5995
5996    public void test_DescendingSubMapKeySet_tailSet() {
5997        NavigableSet keySet, descendingKeySet;
5998        SortedSet tailSet;
5999        String startKey, key;
6000        Iterator iterator;
6001        int index;
6002
6003        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
6004        descendingKeySet = keySet.descendingSet();
6005        startKey = new Integer(99).toString();
6006        try {
6007            descendingKeySet.tailSet(startKey);
6008            fail("should throw IllegalArgumentException");
6009        } catch (IllegalArgumentException e) {
6010            // Expected
6011        }
6012
6013        try {
6014            descendingKeySet.tailSet(startKey, true);
6015            fail("should throw IllegalArgumentException");
6016        } catch (IllegalArgumentException e) {
6017            // Expected
6018        }
6019
6020        try {
6021            descendingKeySet.tailSet(startKey, false);
6022            fail("should throw IllegalArgumentException");
6023        } catch (IllegalArgumentException e) {
6024            // Expected
6025        }
6026
6027        startKey = new Integer(100).toString();
6028        try {
6029            descendingKeySet.tailSet(startKey);
6030            fail("should throw IllegalArgumentException");
6031        } catch (IllegalArgumentException e) {
6032            // Expected
6033        }
6034        try {
6035            descendingKeySet.tailSet(startKey, true);
6036            fail("should throw IllegalArgumentException");
6037        } catch (IllegalArgumentException e) {
6038            // Expected
6039        }
6040
6041        try {
6042            descendingKeySet.tailSet(startKey, false);
6043            fail("should throw IllegalArgumentException");
6044        } catch (IllegalArgumentException e) {
6045            // Expected
6046        }
6047
6048        startKey = new Integer(101).toString();
6049        tailSet = descendingKeySet.tailSet(startKey);
6050        iterator = tailSet.iterator();
6051        for (index = 101; iterator.hasNext(); index--) {
6052            key = (String) iterator.next();
6053            assertEquals(new Integer(index).toString(), key);
6054        }
6055        assertEquals(100, index);
6056
6057        tailSet = descendingKeySet.tailSet(startKey, true);
6058        iterator = tailSet.iterator();
6059        for (index = 101; iterator.hasNext(); index--) {
6060            key = (String) iterator.next();
6061            assertEquals(new Integer(index).toString(), key);
6062        }
6063        assertEquals(100, index);
6064
6065        tailSet = descendingKeySet.tailSet(startKey, false);
6066        iterator = tailSet.iterator();
6067        for (index = 101; iterator.hasNext(); index--) {
6068            key = (String) iterator.next();
6069            assertEquals(new Integer(index).toString(), key);
6070        }
6071        assertEquals(101, index);
6072
6073        for (int i = 102; i < 109; i++) {
6074            startKey = new Integer(i).toString();
6075
6076            tailSet = descendingKeySet.tailSet(startKey);
6077            iterator = tailSet.iterator();
6078            int j;
6079            for (j = i; iterator.hasNext(); j--) {
6080                key = (String) iterator.next();
6081                assertEquals(new Integer(j).toString(), key);
6082            }
6083            assertEquals(100, j);
6084
6085            tailSet = descendingKeySet.tailSet(startKey, true);
6086            iterator = tailSet.iterator();
6087            for (j = i; iterator.hasNext(); j--) {
6088                key = (String) iterator.next();
6089                assertEquals(new Integer(j).toString(), key);
6090            }
6091            assertEquals(100, j);
6092
6093            tailSet = descendingKeySet.tailSet(startKey, false);
6094            iterator = tailSet.iterator();
6095            for (j = i; iterator.hasNext(); j--) {
6096                key = (String) iterator.next();
6097                assertEquals(new Integer(j - 1).toString(), key);
6098            }
6099            assertEquals(101, j);
6100        }
6101
6102        startKey = new Integer(109).toString();
6103        try {
6104            descendingKeySet.tailSet(startKey);
6105            fail("should throw IllegalArgumentException");
6106        } catch (IllegalArgumentException e) {
6107            // Expected
6108        }
6109        try {
6110            descendingKeySet.tailSet(startKey, true);
6111            fail("should throw IllegalArgumentException");
6112        } catch (IllegalArgumentException e) {
6113            // Expected
6114        }
6115        tailSet = descendingKeySet.tailSet(startKey, false);
6116        iterator = tailSet.iterator();
6117        for (index = 109; iterator.hasNext(); index--) {
6118            key = (String) iterator.next();
6119            assertEquals(new Integer(index - 1).toString(), key);
6120        }
6121        assertEquals(101, index);
6122
6123        startKey = new Integer(110).toString();
6124        try {
6125            descendingKeySet.tailSet(startKey);
6126            fail("should throw IllegalArgumentException");
6127        } catch (IllegalArgumentException e) {
6128            // Expected
6129        }
6130        try {
6131            descendingKeySet.tailSet(startKey, true);
6132            fail("should throw IllegalArgumentException");
6133        } catch (IllegalArgumentException e) {
6134            // Expected
6135        }
6136        try {
6137            descendingKeySet.tailSet(startKey, false);
6138            fail("should throw IllegalArgumentException");
6139        } catch (IllegalArgumentException e) {
6140            // Expected
6141        }
6142
6143        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
6144        descendingKeySet = keySet.descendingSet();
6145        startKey = new Integer(99).toString();
6146        try {
6147            descendingKeySet.tailSet(startKey);
6148            fail("should throw IllegalArgumentException");
6149        } catch (IllegalArgumentException e) {
6150            // Expected
6151        }
6152
6153        try {
6154            descendingKeySet.tailSet(startKey, true);
6155            fail("should throw IllegalArgumentException");
6156        } catch (IllegalArgumentException e) {
6157            // Expected
6158        }
6159
6160        try {
6161            descendingKeySet.tailSet(startKey, false);
6162            fail("should throw IllegalArgumentException");
6163        } catch (IllegalArgumentException e) {
6164            // Expected
6165        }
6166
6167        startKey = new Integer(100).toString();
6168        try {
6169            descendingKeySet.tailSet(startKey);
6170            fail("should throw IllegalArgumentException");
6171        } catch (IllegalArgumentException e) {
6172            // Expected
6173        }
6174        try {
6175            descendingKeySet.tailSet(startKey, true);
6176            fail("should throw IllegalArgumentException");
6177        } catch (IllegalArgumentException e) {
6178            // Expected
6179        }
6180        try {
6181            descendingKeySet.tailSet(startKey, false);
6182            fail("should throw IllegalArgumentException");
6183        } catch (IllegalArgumentException e) {
6184            // Expected
6185        }
6186
6187        startKey = new Integer(101).toString();
6188        tailSet = descendingKeySet.tailSet(startKey);
6189        iterator = tailSet.iterator();
6190        for (index = 101; iterator.hasNext(); index--) {
6191            key = (String) iterator.next();
6192            assertEquals(new Integer(index).toString(), key);
6193        }
6194        assertEquals(100, index);
6195
6196        tailSet = descendingKeySet.tailSet(startKey, true);
6197        iterator = tailSet.iterator();
6198        for (index = 101; iterator.hasNext(); index--) {
6199            key = (String) iterator.next();
6200            assertEquals(new Integer(index).toString(), key);
6201        }
6202        assertEquals(100, index);
6203
6204        tailSet = descendingKeySet.tailSet(startKey, false);
6205        iterator = tailSet.iterator();
6206        for (index = 101; iterator.hasNext(); index--) {
6207            key = (String) iterator.next();
6208            assertEquals(new Integer(index).toString(), key);
6209        }
6210        assertEquals(101, index);
6211
6212        for (int i = 102; i < 109; i++) {
6213            startKey = new Integer(i).toString();
6214
6215            tailSet = descendingKeySet.tailSet(startKey);
6216            iterator = tailSet.iterator();
6217            int j;
6218            for (j = i; iterator.hasNext(); j--) {
6219                key = (String) iterator.next();
6220                assertEquals(new Integer(j).toString(), key);
6221            }
6222            assertEquals(100, j);
6223
6224            tailSet = descendingKeySet.tailSet(startKey, true);
6225            iterator = tailSet.iterator();
6226            for (j = i; iterator.hasNext(); j--) {
6227                key = (String) iterator.next();
6228                assertEquals(new Integer(j).toString(), key);
6229            }
6230            assertEquals(100, j);
6231
6232            tailSet = descendingKeySet.tailSet(startKey, false);
6233            iterator = tailSet.iterator();
6234            for (j = i; iterator.hasNext(); j--) {
6235                key = (String) iterator.next();
6236                assertEquals(new Integer(j - 1).toString(), key);
6237            }
6238            assertEquals(101, j);
6239        }
6240
6241        startKey = new Integer(109).toString();
6242        tailSet = descendingKeySet.tailSet(startKey);
6243        iterator = tailSet.iterator();
6244        for (index = 109; iterator.hasNext(); index--) {
6245            key = (String) iterator.next();
6246            assertEquals(new Integer(index).toString(), key);
6247        }
6248        assertEquals(100, index);
6249
6250        tailSet = descendingKeySet.tailSet(startKey, true);
6251        iterator = tailSet.iterator();
6252        for (index = 109; iterator.hasNext(); index--) {
6253            key = (String) iterator.next();
6254            assertEquals(new Integer(index).toString(), key);
6255        }
6256        assertEquals(100, index);
6257
6258        tailSet = descendingKeySet.tailSet(startKey, false);
6259        iterator = tailSet.iterator();
6260        for (index = 109; iterator.hasNext(); index--) {
6261            key = (String) iterator.next();
6262            assertEquals(new Integer(index - 1).toString(), key);
6263        }
6264        assertEquals(101, index);
6265
6266        startKey = new Integer(110).toString();
6267        try {
6268            descendingKeySet.tailSet(startKey);
6269            fail("should throw IllegalArgumentException");
6270        } catch (IllegalArgumentException e) {
6271            // Expected
6272        }
6273        try {
6274            descendingKeySet.tailSet(startKey, true);
6275            fail("should throw IllegalArgumentException");
6276        } catch (IllegalArgumentException e) {
6277            // Expected
6278        }
6279        try {
6280            descendingKeySet.tailSet(startKey, false);
6281            fail("should throw IllegalArgumentException");
6282        } catch (IllegalArgumentException e) {
6283            // Expected
6284        }
6285
6286        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
6287        descendingKeySet = keySet.descendingSet();
6288        startKey = new Integer(99).toString();
6289        try {
6290            descendingKeySet.tailSet(startKey);
6291            fail("should throw IllegalArgumentException");
6292        } catch (IllegalArgumentException e) {
6293            // Expected
6294        }
6295        try {
6296            descendingKeySet.tailSet(startKey, true);
6297            fail("should throw IllegalArgumentException");
6298        } catch (IllegalArgumentException e) {
6299            // Expected
6300        }
6301        try {
6302            descendingKeySet.tailSet(startKey, false);
6303            fail("should throw IllegalArgumentException");
6304        } catch (IllegalArgumentException e) {
6305            // Expected
6306        }
6307
6308        startKey = new Integer(100).toString();
6309        tailSet = descendingKeySet.tailSet(startKey);
6310        assertEquals(1, tailSet.size());
6311        iterator = tailSet.iterator();
6312        assertEquals(startKey, iterator.next());
6313
6314        tailSet = descendingKeySet.tailSet(startKey, true);
6315        assertEquals(1, tailSet.size());
6316        iterator = tailSet.iterator();
6317        assertEquals(startKey, iterator.next());
6318
6319        tailSet = descendingKeySet.tailSet(startKey, false);
6320        assertEquals(0, tailSet.size());
6321
6322        startKey = new Integer(101).toString();
6323        tailSet = descendingKeySet.tailSet(startKey);
6324        iterator = tailSet.iterator();
6325        for (index = 101; iterator.hasNext(); index--) {
6326            key = (String) iterator.next();
6327            assertEquals(new Integer(index).toString(), key);
6328        }
6329        assertEquals(99, index);
6330
6331        tailSet = descendingKeySet.tailSet(startKey, true);
6332        iterator = tailSet.iterator();
6333        for (index = 101; iterator.hasNext(); index--) {
6334            key = (String) iterator.next();
6335            assertEquals(new Integer(index).toString(), key);
6336        }
6337        assertEquals(99, index);
6338
6339        tailSet = descendingKeySet.tailSet(startKey, false);
6340        iterator = tailSet.iterator();
6341        for (index = 101; iterator.hasNext(); index--) {
6342            key = (String) iterator.next();
6343            assertEquals(new Integer(index - 1).toString(), key);
6344        }
6345        assertEquals(100, index);
6346
6347        for (int i = 102; i < 109; i++) {
6348            startKey = new Integer(i).toString();
6349
6350            tailSet = descendingKeySet.tailSet(startKey);
6351            iterator = tailSet.iterator();
6352            int j;
6353            for (j = i; iterator.hasNext(); j--) {
6354                key = (String) iterator.next();
6355                assertEquals(new Integer(j).toString(), key);
6356            }
6357            assertEquals(99, j);
6358
6359            tailSet = descendingKeySet.tailSet(startKey, true);
6360            iterator = tailSet.iterator();
6361            for (j = i; iterator.hasNext(); j--) {
6362                key = (String) iterator.next();
6363                assertEquals(new Integer(j).toString(), key);
6364            }
6365            assertEquals(99, j);
6366
6367            tailSet = descendingKeySet.tailSet(startKey, false);
6368            iterator = tailSet.iterator();
6369            for (j = i; iterator.hasNext(); j--) {
6370                key = (String) iterator.next();
6371                assertEquals(new Integer(j - 1).toString(), key);
6372            }
6373            assertEquals(100, j);
6374        }
6375
6376        startKey = new Integer(109).toString();
6377        try {
6378            descendingKeySet.tailSet(startKey);
6379            fail("should throw IllegalArgumentException");
6380        } catch (IllegalArgumentException e) {
6381            // Expected
6382        }
6383        try {
6384            descendingKeySet.tailSet(startKey, true);
6385            fail("should throw IllegalArgumentException");
6386        } catch (IllegalArgumentException e) {
6387            // Expected
6388        }
6389        tailSet = descendingKeySet.tailSet(startKey, false);
6390        iterator = tailSet.iterator();
6391        for (index = 109; iterator.hasNext(); index--) {
6392            key = (String) iterator.next();
6393            assertEquals(new Integer(index - 1).toString(), key);
6394        }
6395        assertEquals(100, index);
6396
6397        startKey = new Integer(110).toString();
6398        try {
6399            descendingKeySet.tailSet(startKey);
6400            fail("should throw IllegalArgumentException");
6401        } catch (IllegalArgumentException e) {
6402            // Expected
6403        }
6404        try {
6405            descendingKeySet.tailSet(startKey, true);
6406            fail("should throw IllegalArgumentException");
6407        } catch (IllegalArgumentException e) {
6408            // Expected
6409        }
6410        try {
6411            descendingKeySet.tailSet(startKey, false);
6412            fail("should throw IllegalArgumentException");
6413        } catch (IllegalArgumentException e) {
6414            // Expected
6415        }
6416
6417        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
6418        descendingKeySet = keySet.descendingSet();
6419        startKey = new Integer(99).toString();
6420        try {
6421            descendingKeySet.tailSet(startKey);
6422            fail("should throw IllegalArgumentException");
6423        } catch (IllegalArgumentException e) {
6424            // Expected
6425        }
6426        try {
6427            descendingKeySet.tailSet(startKey, true);
6428            fail("should throw IllegalArgumentException");
6429        } catch (IllegalArgumentException e) {
6430            // Expected
6431        }
6432        try {
6433            descendingKeySet.tailSet(startKey, false);
6434            fail("should throw IllegalArgumentException");
6435        } catch (IllegalArgumentException e) {
6436            // Expected
6437        }
6438
6439        startKey = new Integer(100).toString();
6440        tailSet = descendingKeySet.tailSet(startKey);
6441        assertEquals(1, tailSet.size());
6442        iterator = tailSet.iterator();
6443        assertEquals(startKey, iterator.next());
6444
6445        tailSet = descendingKeySet.tailSet(startKey, true);
6446        assertEquals(1, tailSet.size());
6447        iterator = tailSet.iterator();
6448        assertEquals(startKey, iterator.next());
6449
6450        tailSet = descendingKeySet.tailSet(startKey, false);
6451        assertEquals(0, tailSet.size());
6452
6453        startKey = new Integer(101).toString();
6454        tailSet = descendingKeySet.tailSet(startKey);
6455        iterator = tailSet.iterator();
6456        for (index = 101; iterator.hasNext(); index--) {
6457            key = (String) iterator.next();
6458            assertEquals(new Integer(index).toString(), key);
6459        }
6460        assertEquals(99, index);
6461
6462        tailSet = descendingKeySet.tailSet(startKey, true);
6463        iterator = tailSet.iterator();
6464        for (index = 101; iterator.hasNext(); index--) {
6465            key = (String) iterator.next();
6466            assertEquals(new Integer(index).toString(), key);
6467        }
6468        assertEquals(99, index);
6469
6470        tailSet = descendingKeySet.tailSet(startKey, false);
6471        iterator = tailSet.iterator();
6472        for (index = 101; iterator.hasNext(); index--) {
6473            key = (String) iterator.next();
6474            assertEquals(new Integer(index - 1).toString(), key);
6475        }
6476        assertEquals(100, index);
6477
6478        for (int i = 102; i < 109; i++) {
6479            startKey = new Integer(i).toString();
6480
6481            tailSet = descendingKeySet.tailSet(startKey);
6482            iterator = tailSet.iterator();
6483            int j;
6484            for (j = i; iterator.hasNext(); j--) {
6485                key = (String) iterator.next();
6486                assertEquals(new Integer(j).toString(), key);
6487            }
6488            assertEquals(99, j);
6489
6490            tailSet = descendingKeySet.tailSet(startKey, true);
6491            iterator = tailSet.iterator();
6492            for (j = i; iterator.hasNext(); j--) {
6493                key = (String) iterator.next();
6494                assertEquals(new Integer(j).toString(), key);
6495            }
6496            assertEquals(99, j);
6497
6498            tailSet = descendingKeySet.tailSet(startKey, false);
6499            iterator = tailSet.iterator();
6500            for (j = i; iterator.hasNext(); j--) {
6501                key = (String) iterator.next();
6502                assertEquals(new Integer(j - 1).toString(), key);
6503            }
6504            assertEquals(100, j);
6505        }
6506
6507        startKey = new Integer(109).toString();
6508        tailSet = descendingKeySet.tailSet(startKey);
6509        iterator = tailSet.iterator();
6510        for (index = 109; iterator.hasNext(); index--) {
6511            key = (String) iterator.next();
6512            assertEquals(new Integer(index).toString(), key);
6513        }
6514        assertEquals(99, index);
6515
6516        tailSet = descendingKeySet.tailSet(startKey, true);
6517        iterator = tailSet.iterator();
6518        for (index = 109; iterator.hasNext(); index--) {
6519            key = (String) iterator.next();
6520            assertEquals(new Integer(index).toString(), key);
6521        }
6522        assertEquals(99, index);
6523
6524        tailSet = descendingKeySet.tailSet(startKey, false);
6525        iterator = tailSet.iterator();
6526        for (index = 109; iterator.hasNext(); index--) {
6527            key = (String) iterator.next();
6528            assertEquals(new Integer(index - 1).toString(), key);
6529        }
6530        assertEquals(100, index);
6531
6532        startKey = new Integer(110).toString();
6533        try {
6534            descendingKeySet.tailSet(startKey);
6535            fail("should throw IllegalArgumentException");
6536        } catch (IllegalArgumentException e) {
6537            // Expected
6538        }
6539        try {
6540            descendingKeySet.tailSet(startKey, true);
6541            fail("should throw IllegalArgumentException");
6542        } catch (IllegalArgumentException e) {
6543            // Expected
6544        }
6545        try {
6546            descendingKeySet.tailSet(startKey, false);
6547            fail("should throw IllegalArgumentException");
6548        } catch (IllegalArgumentException e) {
6549            // Expected
6550        }
6551
6552        key = new Integer(2).toString();
6553        keySet = tm.headMap(key, true).navigableKeySet();
6554        descendingKeySet = keySet.descendingSet();
6555        iterator = descendingKeySet.iterator();
6556        iterator.next();
6557        startKey = (String) iterator.next();
6558
6559        tailSet = descendingKeySet.tailSet(startKey);
6560        assertEquals(112, tailSet.size());
6561        Iterator tailIterator = tailSet.iterator();
6562        assertEquals(new Integer(199).toString(), tailIterator.next());
6563
6564        tailSet = descendingKeySet.tailSet(startKey, true);
6565        assertEquals(112, tailSet.size());
6566        tailIterator = tailSet.iterator();
6567        assertEquals(new Integer(199).toString(), tailIterator.next());
6568
6569        tailSet = descendingKeySet.tailSet(startKey, false);
6570        assertEquals(111, tailSet.size());
6571        tailIterator = tailSet.iterator();
6572        assertEquals(new Integer(198).toString(), tailIterator.next());
6573    }
6574
6575    public void test_DescendingSubMapKeySet_subSet() {
6576        NavigableSet keySet, descendingKeySet;
6577        SortedSet subSet;
6578        String startKey, endKey, key;
6579        Iterator startIterator, endIterator, subSetIterator;
6580
6581        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
6582        descendingKeySet = keySet.descendingSet();
6583        startIterator = descendingKeySet.iterator();
6584        while (startIterator.hasNext()) {
6585            startKey = (String) startIterator.next();
6586            endIterator = descendingKeySet.iterator();
6587            while (endIterator.hasNext()) {
6588                endKey = (String) endIterator.next();
6589                int startIndex = Integer.valueOf(startKey);
6590                int endIndex = Integer.valueOf(endKey);
6591                if (startIndex < endIndex) {
6592                    try {
6593                        descendingKeySet.subSet(startKey, endKey);
6594                        fail("should throw IllegalArgumentException");
6595                    } catch (IllegalArgumentException e) {
6596                        // Expected
6597                    }
6598
6599                    try {
6600                        descendingKeySet.subSet(startKey, false, endKey, false);
6601                        fail("shoudl throw IllegalArgumentException");
6602                    } catch (IllegalArgumentException e) {
6603                        // Expected
6604                    }
6605
6606                    try {
6607                        descendingKeySet.subSet(startKey, false, endKey, true);
6608                        fail("shoudl throw IllegalArgumentException");
6609                    } catch (IllegalArgumentException e) {
6610                        // Expected
6611                    }
6612
6613                    try {
6614                        descendingKeySet.subSet(startKey, true, endKey, false);
6615                        fail("shoudl throw IllegalArgumentException");
6616                    } catch (IllegalArgumentException e) {
6617                        // Expected
6618                    }
6619
6620                    try {
6621                        descendingKeySet.subSet(startKey, true, endKey, true);
6622                        fail("shoudl throw IllegalArgumentException");
6623                    } catch (IllegalArgumentException e) {
6624                        // Expected
6625                    }
6626                } else {
6627                    subSet = descendingKeySet.subSet(startKey, endKey);
6628                    subSetIterator = subSet.iterator();
6629                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6630                        assertEquals(new Integer(index).toString(),
6631                                subSetIterator.next());
6632                    }
6633
6634                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6635                            false);
6636                    subSetIterator = subSet.iterator();
6637                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6638                        assertEquals(new Integer(index).toString(),
6639                                subSetIterator.next());
6640                    }
6641
6642                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6643                            true);
6644                    subSetIterator = subSet.iterator();
6645                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6646                        assertEquals(new Integer(index).toString(),
6647                                subSetIterator.next());
6648                    }
6649
6650                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6651                            false);
6652                    subSetIterator = subSet.iterator();
6653                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6654                        assertEquals(new Integer(index).toString(),
6655                                subSetIterator.next());
6656                    }
6657
6658                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6659                            true);
6660                    subSetIterator = subSet.iterator();
6661                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6662                        assertEquals(new Integer(index).toString(),
6663                                subSetIterator.next());
6664                    }
6665                }
6666            }
6667        }
6668
6669        endKey = new Integer(2).toString();
6670        keySet = tm.headMap(endKey, true).navigableKeySet();
6671        descendingKeySet = keySet.descendingSet();
6672        Iterator iterator = descendingKeySet.iterator();
6673
6674        startKey = (String) iterator.next();
6675        iterator.next();
6676        endKey = (String) iterator.next();
6677
6678        subSet = descendingKeySet.subSet(startKey, endKey);
6679        assertEquals(2, subSet.size());
6680        subSetIterator = subSet.iterator();
6681        assertEquals(startKey, subSetIterator.next());
6682        subSetIterator.next();
6683        try {
6684            subSetIterator.next();
6685            fail("should throw NoSuchElementException");
6686        } catch (NoSuchElementException e) {
6687            // Expected
6688        }
6689
6690        subSet = descendingKeySet.subSet(startKey, false, endKey, false);
6691        assertEquals(1, subSet.size());
6692        subSetIterator = subSet.iterator();
6693        subSetIterator.next();
6694        try {
6695            subSetIterator.next();
6696            fail("should throw NoSuchElementException");
6697        } catch (NoSuchElementException e) {
6698            // Expected
6699        }
6700
6701        subSet = descendingKeySet.subSet(startKey, false, endKey, true);
6702        assertEquals(2, subSet.size());
6703        subSetIterator = subSet.iterator();
6704        subSetIterator.next();
6705        assertEquals(endKey, subSetIterator.next());
6706        try {
6707            subSetIterator.next();
6708            fail("should throw NoSuchElementException");
6709        } catch (NoSuchElementException e) {
6710            // Expected
6711        }
6712
6713        subSet = descendingKeySet.subSet(startKey, true, endKey, false);
6714        assertEquals(2, subSet.size());
6715        subSetIterator = subSet.iterator();
6716        assertEquals(startKey, subSetIterator.next());
6717        subSetIterator.next();
6718        try {
6719            subSetIterator.next();
6720            fail("should throw NoSuchElementException");
6721        } catch (NoSuchElementException e) {
6722            // Expected
6723        }
6724
6725        subSet = descendingKeySet.subSet(startKey, true, endKey, true);
6726        assertEquals(3, subSet.size());
6727        subSetIterator = subSet.iterator();
6728        assertEquals(startKey, subSetIterator.next());
6729        subSetIterator.next();
6730        assertEquals(endKey, subSetIterator.next());
6731        try {
6732            subSetIterator.next();
6733            fail("should throw NoSuchElementException");
6734        } catch (NoSuchElementException e) {
6735            // Expected
6736        }
6737
6738        // With Comparator
6739        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
6740                .navigableKeySet();
6741        descendingKeySet = keySet.descendingSet();
6742        startIterator = descendingKeySet.iterator();
6743        while (startIterator.hasNext()) {
6744            startKey = (String) startIterator.next();
6745            endIterator = descendingKeySet.iterator();
6746            while (endIterator.hasNext()) {
6747                endKey = (String) endIterator.next();
6748                int startIndex = Integer.valueOf(startKey);
6749                int endIndex = Integer.valueOf(endKey);
6750                if (startIndex < endIndex) {
6751                    try {
6752                        descendingKeySet.subSet(startKey, endKey);
6753                        fail("should throw IllegalArgumentException");
6754                    } catch (IllegalArgumentException e) {
6755                        // Expected
6756                    }
6757
6758                    try {
6759                        descendingKeySet.subSet(startKey, false, endKey, false);
6760                        fail("shoudl throw IllegalArgumentException");
6761                    } catch (IllegalArgumentException e) {
6762                        // Expected
6763                    }
6764
6765                    try {
6766                        descendingKeySet.subSet(startKey, false, endKey, true);
6767                        fail("shoudl throw IllegalArgumentException");
6768                    } catch (IllegalArgumentException e) {
6769                        // Expected
6770                    }
6771
6772                    try {
6773                        descendingKeySet.subSet(startKey, true, endKey, false);
6774                        fail("shoudl throw IllegalArgumentException");
6775                    } catch (IllegalArgumentException e) {
6776                        // Expected
6777                    }
6778
6779                    try {
6780                        descendingKeySet.subSet(startKey, true, endKey, true);
6781                        fail("shoudl throw IllegalArgumentException");
6782                    } catch (IllegalArgumentException e) {
6783                        // Expected
6784                    }
6785                } else {
6786                    subSet = descendingKeySet.subSet(startKey, endKey);
6787                    subSetIterator = subSet.iterator();
6788                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6789                        assertEquals(new Integer(index).toString(),
6790                                subSetIterator.next());
6791                    }
6792
6793                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6794                            false);
6795                    subSetIterator = subSet.iterator();
6796                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6797                        assertEquals(new Integer(index).toString(),
6798                                subSetIterator.next());
6799                    }
6800
6801                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6802                            true);
6803                    subSetIterator = subSet.iterator();
6804                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6805                        assertEquals(new Integer(index).toString(),
6806                                subSetIterator.next());
6807                    }
6808
6809                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6810                            false);
6811                    subSetIterator = subSet.iterator();
6812                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6813                        assertEquals(new Integer(index).toString(),
6814                                subSetIterator.next());
6815                    }
6816
6817                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6818                            true);
6819                    subSetIterator = subSet.iterator();
6820                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6821                        assertEquals(new Integer(index).toString(),
6822                                subSetIterator.next());
6823                    }
6824                }
6825            }
6826        }
6827    }
6828
6829    public void test_DescendingSubMapKeySet_descendingSet() {
6830        NavigableSet keySet, descendingSet, descendingDescendingSet;
6831        int value;
6832        Iterator iterator;
6833
6834        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
6835        descendingSet = keySet.descendingSet();
6836        descendingDescendingSet = descendingSet.descendingSet();
6837        iterator = descendingDescendingSet.iterator();
6838        assertTrue(iterator.hasNext());
6839        for (value = 101; iterator.hasNext(); value++) {
6840            assertEquals(new Integer(value).toString(), iterator.next());
6841        }
6842        assertEquals(109, value);
6843        try {
6844            iterator.next();
6845            fail("should throw NoSuchElementException");
6846        } catch (NoSuchElementException e) {
6847            // Expected
6848        }
6849
6850        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
6851        descendingSet = keySet.descendingSet();
6852        descendingDescendingSet = descendingSet.descendingSet();
6853        iterator = descendingDescendingSet.iterator();
6854        assertTrue(iterator.hasNext());
6855        for (value = 101; iterator.hasNext(); value++) {
6856            assertEquals(new Integer(value).toString(), iterator.next());
6857        }
6858        assertEquals(110, value);
6859        try {
6860            iterator.next();
6861            fail("should throw NoSuchElementException");
6862        } catch (NoSuchElementException e) {
6863            // Expected
6864        }
6865
6866        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
6867        descendingSet = keySet.descendingSet();
6868        descendingDescendingSet = descendingSet.descendingSet();
6869        iterator = descendingDescendingSet.iterator();
6870        assertTrue(iterator.hasNext());
6871        for (value = 100; iterator.hasNext(); value++) {
6872            assertEquals(new Integer(value).toString(), iterator.next());
6873        }
6874        assertEquals(109, value);
6875        try {
6876            iterator.next();
6877            fail("should throw NoSuchElementException");
6878        } catch (NoSuchElementException e) {
6879            // Expected
6880        }
6881
6882        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
6883        descendingSet = keySet.descendingSet();
6884        descendingDescendingSet = descendingSet.descendingSet();
6885        iterator = descendingDescendingSet.iterator();
6886        assertTrue(iterator.hasNext());
6887        for (value = 100; iterator.hasNext(); value++) {
6888            assertEquals(new Integer(value).toString(), iterator.next());
6889        }
6890        assertEquals(110, value);
6891        try {
6892            iterator.next();
6893            fail("should throw NoSuchElementException");
6894        } catch (NoSuchElementException e) {
6895            // Expected
6896        }
6897
6898        String endKey = new Integer(2).toString();
6899        keySet = tm.headMap(endKey, true).navigableKeySet();
6900        descendingSet = keySet.descendingSet();
6901        descendingDescendingSet = descendingSet.descendingSet();
6902        assertEquals(keySet, descendingDescendingSet);
6903
6904        String startKey = new Integer(2).toString();
6905        keySet = tm.tailMap(startKey, true).navigableKeySet();
6906        descendingSet = keySet.descendingSet();
6907        descendingDescendingSet = descendingSet.descendingSet();
6908        assertEquals(keySet, descendingDescendingSet);
6909    }
6910
6911    public void test_DescendingSubMapKeySet_descendingIterator() {
6912        NavigableSet keySet, descendingSet;
6913        int value;
6914        Iterator iterator, descendingIterator;
6915
6916        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
6917        descendingSet = keySet.descendingSet();
6918        descendingIterator = descendingSet.descendingIterator();
6919        assertTrue(descendingIterator.hasNext());
6920        for (value = 101; descendingIterator.hasNext(); value++) {
6921            assertEquals(new Integer(value).toString(), descendingIterator
6922                    .next());
6923        }
6924        assertEquals(109, value);
6925        try {
6926            descendingIterator.next();
6927            fail("should throw NoSuchElementException");
6928        } catch (NoSuchElementException e) {
6929            // Expected
6930        }
6931
6932        descendingSet = descendingSet
6933                .headSet(new Integer(105).toString(), true);
6934        descendingIterator = descendingSet.descendingIterator();
6935        for (value = 105; descendingIterator.hasNext(); value++) {
6936            assertEquals(new Integer(value).toString(), descendingIterator
6937                    .next());
6938        }
6939
6940        descendingSet = keySet.descendingSet();
6941        descendingSet = descendingSet
6942                .tailSet(new Integer(105).toString(), true);
6943        descendingIterator = descendingSet.descendingIterator();
6944        for (value = 101; descendingIterator.hasNext(); value++) {
6945            assertEquals(new Integer(value).toString(), descendingIterator
6946                    .next());
6947        }
6948
6949        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
6950        descendingSet = keySet.descendingSet();
6951        descendingIterator = descendingSet.descendingIterator();
6952        assertTrue(descendingIterator.hasNext());
6953        for (value = 101; descendingIterator.hasNext(); value++) {
6954            assertEquals(new Integer(value).toString(), descendingIterator
6955                    .next());
6956        }
6957        assertEquals(110, value);
6958        try {
6959            descendingIterator.next();
6960            fail("should throw NoSuchElementException");
6961        } catch (NoSuchElementException e) {
6962            // Expected
6963        }
6964
6965        descendingSet = descendingSet
6966                .headSet(new Integer(105).toString(), true);
6967        descendingIterator = descendingSet.descendingIterator();
6968        for (value = 105; descendingIterator.hasNext(); value++) {
6969            assertEquals(new Integer(value).toString(), descendingIterator
6970                    .next());
6971        }
6972
6973        descendingSet = keySet.descendingSet();
6974        descendingSet = descendingSet
6975                .tailSet(new Integer(105).toString(), true);
6976        descendingIterator = descendingSet.descendingIterator();
6977        for (value = 101; descendingIterator.hasNext(); value++) {
6978            assertEquals(new Integer(value).toString(), descendingIterator
6979                    .next());
6980        }
6981
6982        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
6983        descendingSet = keySet.descendingSet();
6984        descendingIterator = descendingSet.descendingIterator();
6985        assertTrue(descendingIterator.hasNext());
6986        for (value = 100; descendingIterator.hasNext(); value++) {
6987            assertEquals(new Integer(value).toString(), descendingIterator
6988                    .next());
6989        }
6990        assertEquals(109, value);
6991        try {
6992            descendingIterator.next();
6993            fail("should throw NoSuchElementException");
6994        } catch (NoSuchElementException e) {
6995            // Expected
6996        }
6997
6998        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
6999        descendingSet = keySet.descendingSet();
7000        descendingIterator = descendingSet.descendingIterator();
7001        assertTrue(descendingIterator.hasNext());
7002        for (value = 100; descendingIterator.hasNext(); value++) {
7003            assertEquals(new Integer(value).toString(), descendingIterator
7004                    .next());
7005        }
7006        assertEquals(110, value);
7007        try {
7008            descendingIterator.next();
7009            fail("should throw NoSuchElementException");
7010        } catch (NoSuchElementException e) {
7011            // Expected
7012        }
7013
7014        String endKey = new Integer(2).toString();
7015        keySet = tm.headMap(endKey, true).navigableKeySet();
7016        iterator = keySet.iterator();
7017
7018        descendingSet = keySet.descendingSet();
7019        descendingIterator = descendingSet.descendingIterator();
7020
7021        while (iterator.hasNext()) {
7022            assertEquals(iterator.next(), descendingIterator.next());
7023        }
7024
7025        String startKey = new Integer(2).toString();
7026        keySet = tm.tailMap(startKey, true).navigableKeySet();
7027        iterator = keySet.iterator();
7028        descendingSet = keySet.descendingSet();
7029        descendingIterator = descendingSet.descendingIterator();
7030
7031        while (iterator.hasNext()) {
7032            assertEquals(iterator.next(), descendingIterator.next());
7033        }
7034    }
7035
7036    public void test_DescendingSubMapKeySet_lower() {
7037        NavigableSet keySet, descendingKeySet;
7038        Iterator iterator;
7039        String key, lowerKey;
7040        int value, lowerValue;
7041
7042        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7043        descendingKeySet = keySet.descendingSet();
7044        iterator = descendingKeySet.iterator();
7045        while (iterator.hasNext()) {
7046            key = (String) iterator.next();
7047            value = Integer.valueOf(key);
7048            lowerKey = (String) descendingKeySet.lower(key);
7049            if (value < 108) {
7050                lowerValue = Integer.valueOf(lowerKey);
7051                assertEquals(value + 1, lowerValue);
7052            } else {
7053                assertNull(lowerKey);
7054            }
7055        }
7056
7057        key = new Integer(0).toString();
7058        lowerKey = (String) descendingKeySet.lower(key);
7059        assertEquals(101, Integer.parseInt(lowerKey));
7060
7061        key = new Integer(2).toString();
7062        lowerKey = (String) descendingKeySet.lower(key);
7063        assertNull(lowerKey);
7064
7065        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7066        descendingKeySet = keySet.descendingSet();
7067        iterator = descendingKeySet.iterator();
7068        while (iterator.hasNext()) {
7069            key = (String) iterator.next();
7070            value = Integer.valueOf(key);
7071            lowerKey = (String) descendingKeySet.lower(key);
7072            if (value < 109) {
7073                lowerValue = Integer.valueOf(lowerKey);
7074                assertEquals(value + 1, lowerValue);
7075            } else {
7076                assertNull(lowerKey);
7077            }
7078        }
7079
7080        key = new Integer(0).toString();
7081        lowerKey = (String) descendingKeySet.lower(key);
7082        assertEquals(101, Integer.parseInt(lowerKey));
7083
7084        key = new Integer(2).toString();
7085        lowerKey = (String) descendingKeySet.lower(key);
7086        assertNull(lowerKey);
7087
7088        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7089        descendingKeySet = keySet.descendingSet();
7090        iterator = descendingKeySet.iterator();
7091        while (iterator.hasNext()) {
7092            key = (String) iterator.next();
7093            value = Integer.valueOf(key);
7094            lowerKey = (String) descendingKeySet.lower(key);
7095            if (value < 108) {
7096                lowerValue = Integer.valueOf(lowerKey);
7097                assertEquals(value + 1, lowerValue);
7098            } else {
7099                assertNull(lowerKey);
7100            }
7101        }
7102
7103        key = new Integer(0).toString();
7104        lowerKey = (String) descendingKeySet.lower(key);
7105        assertEquals(100, Integer.parseInt(lowerKey));
7106
7107        key = new Integer(2).toString();
7108        lowerKey = (String) descendingKeySet.lower(key);
7109        assertNull(lowerKey);
7110
7111        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7112        descendingKeySet = keySet.descendingSet();
7113        iterator = descendingKeySet.iterator();
7114        while (iterator.hasNext()) {
7115            key = (String) iterator.next();
7116            value = Integer.valueOf(key);
7117            lowerKey = (String) descendingKeySet.lower(key);
7118            if (value < 109) {
7119                lowerValue = Integer.valueOf(lowerKey);
7120                assertEquals(value + 1, lowerValue);
7121            } else {
7122                assertNull(lowerKey);
7123            }
7124        }
7125
7126        key = new Integer(0).toString();
7127        lowerKey = (String) descendingKeySet.lower(key);
7128        assertEquals(100, Integer.parseInt(lowerKey));
7129
7130        key = new Integer(2).toString();
7131        lowerKey = (String) descendingKeySet.lower(key);
7132        assertNull(lowerKey);
7133
7134        key = new Integer(2).toString();
7135        keySet = tm.headMap(key, true).navigableKeySet();
7136        descendingKeySet = keySet.descendingSet();
7137        iterator = descendingKeySet.iterator();
7138        iterator.next();
7139        iterator.next();
7140        key = (String) iterator.next();
7141        lowerKey = (String) descendingKeySet.lower(key);
7142        assertEquals(new Integer(199).toString(), lowerKey);
7143        try {
7144            descendingKeySet.lower(null);
7145            fail("should throw NPE");
7146        } catch (NullPointerException e) {
7147            // Expected
7148        }
7149
7150        key = new Integer(0).toString();
7151        String endKey = key;
7152
7153        keySet = tm.headMap(endKey, true).navigableKeySet();
7154        descendingKeySet = keySet.descendingSet();
7155        assertNull(descendingKeySet.lower(endKey));
7156
7157        key = new Integer(0).toString();
7158        keySet = tm.headMap(endKey, false).navigableKeySet();
7159        descendingKeySet = keySet.descendingSet();
7160        assertNull(descendingKeySet.lower(endKey));
7161
7162        endKey = new Integer(999).toString();
7163        keySet = tm.headMap(endKey, true).navigableKeySet();
7164        descendingKeySet = keySet.descendingSet();
7165        assertNull(descendingKeySet.lower(endKey));
7166        assertEquals(new Integer(1).toString(), descendingKeySet.lower(key));
7167
7168        endKey = new Integer(999).toString();
7169        keySet = tm.headMap(endKey, false).navigableKeySet();
7170        descendingKeySet = keySet.descendingSet();
7171        assertNull(descendingKeySet.lower(endKey));
7172        assertEquals(new Integer(1).toString(), descendingKeySet.lower(key));
7173
7174        // With Comparator
7175        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7176                .navigableKeySet();
7177        descendingKeySet = keySet.descendingSet();
7178        iterator = descendingKeySet.iterator();
7179        while (iterator.hasNext()) {
7180            key = (String) iterator.next();
7181            value = Integer.valueOf(key);
7182            lowerKey = (String) descendingKeySet.lower(key);
7183            if (value < 108) {
7184                lowerValue = Integer.valueOf(lowerKey);
7185                assertEquals(value + 1, lowerValue);
7186            } else {
7187                assertNull(lowerKey);
7188            }
7189        }
7190
7191        key = new Integer(0).toString();
7192        lowerKey = (String) descendingKeySet.lower(key);
7193        assertEquals(101, Integer.parseInt(lowerKey));
7194
7195        key = new Integer(2).toString();
7196        lowerKey = (String) descendingKeySet.lower(key);
7197        assertNull(lowerKey);
7198
7199        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
7200                .navigableKeySet();
7201        descendingKeySet = keySet.descendingSet();
7202        iterator = descendingKeySet.iterator();
7203        while (iterator.hasNext()) {
7204            key = (String) iterator.next();
7205            value = Integer.valueOf(key);
7206            lowerKey = (String) descendingKeySet.lower(key);
7207            if (value < 109) {
7208                lowerValue = Integer.valueOf(lowerKey);
7209                assertEquals(value + 1, lowerValue);
7210            } else {
7211                assertNull(lowerKey);
7212            }
7213        }
7214
7215        key = new Integer(0).toString();
7216        lowerKey = (String) descendingKeySet.lower(key);
7217        assertEquals(101, Integer.parseInt(lowerKey));
7218
7219        key = new Integer(2).toString();
7220        lowerKey = (String) descendingKeySet.lower(key);
7221        assertNull(lowerKey);
7222
7223        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
7224                .navigableKeySet();
7225        descendingKeySet = keySet.descendingSet();
7226        iterator = descendingKeySet.iterator();
7227        while (iterator.hasNext()) {
7228            key = (String) iterator.next();
7229            value = Integer.valueOf(key);
7230            lowerKey = (String) descendingKeySet.lower(key);
7231            if (value < 108) {
7232                lowerValue = Integer.valueOf(lowerKey);
7233                assertEquals(value + 1, lowerValue);
7234            } else {
7235                assertNull(lowerKey);
7236            }
7237        }
7238
7239        key = new Integer(0).toString();
7240        lowerKey = (String) descendingKeySet.lower(key);
7241        assertEquals(100, Integer.parseInt(lowerKey));
7242
7243        key = new Integer(2).toString();
7244        lowerKey = (String) descendingKeySet.lower(key);
7245        assertNull(lowerKey);
7246
7247        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
7248                .navigableKeySet();
7249        descendingKeySet = keySet.descendingSet();
7250        iterator = descendingKeySet.iterator();
7251        while (iterator.hasNext()) {
7252            key = (String) iterator.next();
7253            value = Integer.valueOf(key);
7254            lowerKey = (String) descendingKeySet.lower(key);
7255            if (value < 109) {
7256                lowerValue = Integer.valueOf(lowerKey);
7257                assertEquals(value + 1, lowerValue);
7258            } else {
7259                assertNull(lowerKey);
7260            }
7261        }
7262    }
7263
7264    public void test_DescendingSubMapKeySet_higher() {
7265        NavigableSet keySet, descendingKeySet;
7266        Iterator iterator;
7267        String key, higherKey;
7268        int value, higherValue;
7269
7270        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7271        descendingKeySet = keySet.descendingSet();
7272        iterator = descendingKeySet.iterator();
7273        while (iterator.hasNext()) {
7274            key = (String) iterator.next();
7275            value = Integer.valueOf(key);
7276            higherKey = (String) descendingKeySet.higher(key);
7277            if (value > 101) {
7278                higherValue = Integer.valueOf(higherKey);
7279                assertEquals(value - 1, higherValue);
7280            } else {
7281                assertNull(higherKey);
7282            }
7283        }
7284
7285        key = new Integer(99999).toString();
7286        higherKey = (String) descendingKeySet.higher(key);
7287        assertEquals("108", higherKey);
7288
7289        key = new Integer(-1).toString();
7290        higherKey = (String) descendingKeySet.higher(key);
7291        assertNull(higherKey);
7292
7293        key = new Integer(100).toString();
7294        higherKey = (String) descendingKeySet.higher(key);
7295        assertNull(higherKey);
7296
7297        key = new Integer(0).toString();
7298        higherKey = (String) descendingKeySet.higher(key);
7299        assertNull(higherKey);
7300
7301        key = new Integer(2).toString();
7302        higherKey = (String) descendingKeySet.higher(key);
7303        assertEquals(108, Integer.parseInt(higherKey));
7304
7305        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7306        descendingKeySet = keySet.descendingSet();
7307        iterator = descendingKeySet.iterator();
7308        while (iterator.hasNext()) {
7309            key = (String) iterator.next();
7310            value = Integer.valueOf(key);
7311            higherKey = (String) descendingKeySet.higher(key);
7312            if (value > 101) {
7313                higherValue = Integer.valueOf(higherKey);
7314                assertEquals(value - 1, higherValue);
7315            } else {
7316                assertNull(higherKey);
7317            }
7318        }
7319
7320        key = new Integer(99999).toString();
7321        higherKey = (String) descendingKeySet.higher(key);
7322        assertEquals("109", higherKey);
7323
7324        key = new Integer(-1).toString();
7325        higherKey = (String) descendingKeySet.higher(key);
7326        assertNull(higherKey);
7327
7328        key = new Integer(100).toString();
7329        higherKey = (String) descendingKeySet.higher(key);
7330        assertNull(higherKey);
7331
7332        key = new Integer(2).toString();
7333        higherKey = (String) descendingKeySet.higher(key);
7334        assertEquals(109, Integer.parseInt(higherKey));
7335
7336        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7337        descendingKeySet = keySet.descendingSet();
7338        iterator = descendingKeySet.iterator();
7339        while (iterator.hasNext()) {
7340            key = (String) iterator.next();
7341            value = Integer.valueOf(key);
7342            higherKey = (String) descendingKeySet.higher(key);
7343            if (value > 100) {
7344                higherValue = Integer.valueOf(higherKey);
7345                assertEquals(value - 1, higherValue);
7346            } else {
7347                assertNull(higherKey);
7348            }
7349        }
7350
7351        key = new Integer(99999).toString();
7352        higherKey = (String) descendingKeySet.higher(key);
7353        assertEquals("108", higherKey);
7354
7355        key = new Integer(-1).toString();
7356        higherKey = (String) descendingKeySet.higher(key);
7357        assertNull(higherKey);
7358
7359        key = new Integer(100).toString();
7360        higherKey = (String) descendingKeySet.higher(key);
7361        assertNull(higherKey);
7362
7363        key = new Integer(2).toString();
7364        higherKey = (String) descendingKeySet.higher(key);
7365        assertEquals(108, Integer.parseInt(higherKey));
7366
7367        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7368        descendingKeySet = keySet.descendingSet();
7369        iterator = descendingKeySet.iterator();
7370        while (iterator.hasNext()) {
7371            key = (String) iterator.next();
7372            value = Integer.valueOf(key);
7373            higherKey = (String) descendingKeySet.higher(key);
7374            if (value > 100) {
7375                higherValue = Integer.valueOf(higherKey);
7376                assertEquals(value - 1, higherValue);
7377            } else {
7378                assertNull(higherKey);
7379            }
7380        }
7381
7382        key = new Integer(99999).toString();
7383        higherKey = (String) descendingKeySet.higher(key);
7384        assertEquals("109", higherKey);
7385
7386        key = new Integer(-1).toString();
7387        higherKey = (String) descendingKeySet.higher(key);
7388        assertNull(higherKey);
7389
7390        key = new Integer(100).toString();
7391        higherKey = (String) descendingKeySet.higher(key);
7392        assertNull(higherKey);
7393
7394        key = new Integer(2).toString();
7395        higherKey = (String) descendingKeySet.higher(key);
7396        assertEquals(109, Integer.parseInt(higherKey));
7397
7398        key = new Integer(2).toString();
7399        keySet = tm.headMap(key, true).navigableKeySet();
7400        descendingKeySet = keySet.descendingSet();
7401        iterator = descendingKeySet.iterator();
7402        key = (String) iterator.next();
7403        higherKey = (String) descendingKeySet.higher(key);
7404        assertEquals(new Integer(199).toString(), higherKey);
7405        try {
7406            descendingKeySet.higher(null);
7407            fail("should throw NPE");
7408        } catch (NullPointerException e) {
7409            // Expected
7410        }
7411
7412        key = new Integer(0).toString();
7413        String endKey = key;
7414
7415        keySet = tm.headMap(endKey, true).navigableKeySet();
7416        descendingKeySet = keySet.descendingSet();
7417        assertNull(descendingKeySet.higher(endKey));
7418
7419        key = new Integer(0).toString();
7420        keySet = tm.headMap(endKey, false).navigableKeySet();
7421        descendingKeySet = keySet.descendingSet();
7422        assertNull(descendingKeySet.higher(endKey));
7423
7424        endKey = new Integer(999).toString();
7425        keySet = tm.headMap(endKey, true).navigableKeySet();
7426        descendingKeySet = keySet.descendingSet();
7427        assertEquals(new Integer(998).toString(), descendingKeySet
7428                .higher(endKey));
7429        assertNull(descendingKeySet.higher(key));
7430
7431        endKey = new Integer(999).toString();
7432        keySet = tm.headMap(endKey, false).navigableKeySet();
7433        descendingKeySet = keySet.descendingSet();
7434        assertEquals(new Integer(998).toString(), descendingKeySet
7435                .higher(endKey));
7436        assertNull(descendingKeySet.higher(key));
7437
7438        // With Comparator
7439        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7440                .navigableKeySet();
7441        descendingKeySet = keySet.descendingSet();
7442        iterator = descendingKeySet.iterator();
7443        while (iterator.hasNext()) {
7444            key = (String) iterator.next();
7445            value = Integer.valueOf(key);
7446            higherKey = (String) descendingKeySet.higher(key);
7447            if (value > 101) {
7448                higherValue = Integer.valueOf(higherKey);
7449                assertEquals(value - 1, higherValue);
7450            } else {
7451                assertNull(higherKey);
7452            }
7453        }
7454
7455        key = new Integer(99999).toString();
7456        higherKey = (String) descendingKeySet.higher(key);
7457        assertEquals("108", higherKey);
7458
7459        key = new Integer(-1).toString();
7460        higherKey = (String) descendingKeySet.higher(key);
7461        assertNull(higherKey);
7462
7463        key = new Integer(100).toString();
7464        higherKey = (String) descendingKeySet.higher(key);
7465        assertNull(higherKey);
7466
7467        key = new Integer(0).toString();
7468        higherKey = (String) descendingKeySet.higher(key);
7469        assertNull(higherKey);
7470
7471        key = new Integer(2).toString();
7472        higherKey = (String) descendingKeySet.higher(key);
7473        assertEquals(108, Integer.parseInt(higherKey));
7474
7475        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
7476                .navigableKeySet();
7477        descendingKeySet = keySet.descendingSet();
7478        iterator = descendingKeySet.iterator();
7479        while (iterator.hasNext()) {
7480            key = (String) iterator.next();
7481            value = Integer.valueOf(key);
7482            higherKey = (String) descendingKeySet.higher(key);
7483            if (value > 101) {
7484                higherValue = Integer.valueOf(higherKey);
7485                assertEquals(value - 1, higherValue);
7486            } else {
7487                assertNull(higherKey);
7488            }
7489        }
7490
7491        key = new Integer(99999).toString();
7492        higherKey = (String) descendingKeySet.higher(key);
7493        assertEquals("109", higherKey);
7494
7495        key = new Integer(-1).toString();
7496        higherKey = (String) descendingKeySet.higher(key);
7497        assertNull(higherKey);
7498
7499        key = new Integer(100).toString();
7500        higherKey = (String) descendingKeySet.higher(key);
7501        assertNull(higherKey);
7502
7503        key = new Integer(2).toString();
7504        higherKey = (String) descendingKeySet.higher(key);
7505        assertEquals(109, Integer.parseInt(higherKey));
7506
7507        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
7508                .navigableKeySet();
7509        descendingKeySet = keySet.descendingSet();
7510        iterator = descendingKeySet.iterator();
7511        while (iterator.hasNext()) {
7512            key = (String) iterator.next();
7513            value = Integer.valueOf(key);
7514            higherKey = (String) descendingKeySet.higher(key);
7515            if (value > 100) {
7516                higherValue = Integer.valueOf(higherKey);
7517                assertEquals(value - 1, higherValue);
7518            } else {
7519                assertNull(higherKey);
7520            }
7521        }
7522
7523        key = new Integer(99999).toString();
7524        higherKey = (String) descendingKeySet.higher(key);
7525        assertEquals("108", higherKey);
7526
7527        key = new Integer(-1).toString();
7528        higherKey = (String) descendingKeySet.higher(key);
7529        assertNull(higherKey);
7530
7531        key = new Integer(100).toString();
7532        higherKey = (String) descendingKeySet.higher(key);
7533        assertNull(higherKey);
7534
7535        key = new Integer(2).toString();
7536        higherKey = (String) descendingKeySet.higher(key);
7537        assertEquals(108, Integer.parseInt(higherKey));
7538
7539        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
7540                .navigableKeySet();
7541        descendingKeySet = keySet.descendingSet();
7542        iterator = descendingKeySet.iterator();
7543        while (iterator.hasNext()) {
7544            key = (String) iterator.next();
7545            value = Integer.valueOf(key);
7546            higherKey = (String) descendingKeySet.higher(key);
7547            if (value > 100) {
7548                higherValue = Integer.valueOf(higherKey);
7549                assertEquals(value - 1, higherValue);
7550            } else {
7551                assertNull(higherKey);
7552            }
7553        }
7554
7555        key = new Integer(99999).toString();
7556        higherKey = (String) descendingKeySet.higher(key);
7557        assertEquals("109", higherKey);
7558
7559        key = new Integer(-1).toString();
7560        higherKey = (String) descendingKeySet.higher(key);
7561        assertNull(higherKey);
7562
7563        key = new Integer(100).toString();
7564        higherKey = (String) descendingKeySet.higher(key);
7565        assertNull(higherKey);
7566
7567        key = new Integer(2).toString();
7568        higherKey = (String) descendingKeySet.higher(key);
7569        assertEquals(109, Integer.parseInt(higherKey));
7570
7571        key = new Integer(2).toString();
7572        keySet = tm.headMap(key, true).navigableKeySet();
7573        descendingKeySet = keySet.descendingSet();
7574        iterator = descendingKeySet.iterator();
7575        key = (String) iterator.next();
7576        higherKey = (String) descendingKeySet.higher(key);
7577        assertEquals(new Integer(199).toString(), higherKey);
7578        try {
7579            descendingKeySet.higher(null);
7580            fail("should throw NPE");
7581        } catch (NullPointerException e) {
7582            // Expected
7583        }
7584
7585        key = new Integer(0).toString();
7586        endKey = key;
7587
7588        keySet = tm.headMap(endKey, true).navigableKeySet();
7589        descendingKeySet = keySet.descendingSet();
7590        assertNull(descendingKeySet.higher(endKey));
7591
7592        key = new Integer(0).toString();
7593        keySet = tm.headMap(endKey, false).navigableKeySet();
7594        descendingKeySet = keySet.descendingSet();
7595        assertNull(descendingKeySet.higher(endKey));
7596
7597        endKey = new Integer(999).toString();
7598        keySet = tm.headMap(endKey, true).navigableKeySet();
7599        descendingKeySet = keySet.descendingSet();
7600        assertEquals(new Integer(998).toString(), descendingKeySet
7601                .higher(endKey));
7602        assertNull(descendingKeySet.higher(key));
7603
7604        endKey = new Integer(999).toString();
7605        keySet = tm.headMap(endKey, false).navigableKeySet();
7606        descendingKeySet = keySet.descendingSet();
7607        assertEquals(new Integer(998).toString(), descendingKeySet
7608                .higher(endKey));
7609        assertNull(descendingKeySet.higher(key));
7610    }
7611
7612    public void test_DescendingSubMapKeySet_ceiling() {
7613        NavigableSet keySet, descendingKeySet;
7614        String[] keyArray;
7615        String key, ceilingKey;
7616
7617        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7618        descendingKeySet = keySet.descendingSet();
7619        keyArray = (String[]) descendingKeySet
7620                .toArray(new String[descendingKeySet.size()]);
7621        for (int i = 0, j = 108; i < keyArray.length; i++) {
7622            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7623            assertEquals(new Integer(j - i).toString(), ceilingKey);
7624        }
7625
7626        key = new Integer(2).toString();
7627        ceilingKey = (String) descendingKeySet.ceiling(key);
7628        assertEquals(108, Integer.parseInt(ceilingKey));
7629
7630        key = new Integer(0).toString();
7631        ceilingKey = (String) descendingKeySet.ceiling(key);
7632        assertNull(ceilingKey);
7633
7634        key = new Integer(-1).toString();
7635        ceilingKey = (String) descendingKeySet.ceiling(key);
7636        assertNull(ceilingKey);
7637
7638        key = new Integer(99999).toString();
7639        ceilingKey = (String) descendingKeySet.ceiling(key);
7640        assertEquals(108, Integer.parseInt(ceilingKey));
7641
7642        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7643        descendingKeySet = keySet.descendingSet();
7644        keyArray = (String[]) descendingKeySet
7645                .toArray(new String[descendingKeySet.size()]);
7646        for (int i = 0, j = 109; i < keyArray.length; i++) {
7647            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7648            assertEquals(new Integer(j - i).toString(), ceilingKey);
7649        }
7650
7651        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7652        descendingKeySet = keySet.descendingSet();
7653        keyArray = (String[]) descendingKeySet
7654                .toArray(new String[descendingKeySet.size()]);
7655        for (int i = 0, j = 108; i < keyArray.length; i++) {
7656            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7657            assertEquals(new Integer(j - i).toString(), ceilingKey);
7658        }
7659
7660        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7661        descendingKeySet = keySet.descendingSet();
7662        keyArray = (String[]) descendingKeySet
7663                .toArray(new String[descendingKeySet.size()]);
7664        for (int i = 0, j = 109; i < keyArray.length; i++) {
7665            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7666            assertEquals(new Integer(j - i).toString(), ceilingKey);
7667        }
7668
7669        key = new Integer(2).toString();
7670        keySet = tm.headMap(key, true).navigableKeySet();
7671        descendingKeySet = keySet.descendingSet();
7672        Iterator iterator = descendingKeySet.iterator();
7673        assertEquals(key, descendingKeySet.ceiling(iterator.next()));
7674        try {
7675            descendingKeySet.ceiling(null);
7676            fail("should throw NPE");
7677        } catch (NullPointerException e) {
7678            // Expected
7679        }
7680
7681        key = new Integer(0).toString();
7682        String endKey = key;
7683
7684        keySet = tm.headMap(endKey, true).navigableKeySet();
7685        descendingKeySet = keySet.descendingSet();
7686        assertEquals(key, descendingKeySet.ceiling(endKey));
7687
7688        key = new Integer(0).toString();
7689        keySet = tm.headMap(endKey, false).navigableKeySet();
7690        descendingKeySet = keySet.descendingSet();
7691        assertNull(descendingKeySet.ceiling(endKey));
7692
7693        endKey = new Integer(999).toString();
7694        keySet = tm.headMap(endKey, true).navigableKeySet();
7695        descendingKeySet = keySet.descendingSet();
7696        assertEquals(new Integer(999).toString(), descendingKeySet
7697                .ceiling(endKey));
7698        assertEquals(key, descendingKeySet.ceiling(key));
7699
7700        endKey = new Integer(999).toString();
7701        keySet = tm.headMap(endKey, false).navigableKeySet();
7702        descendingKeySet = keySet.descendingSet();
7703        assertEquals(new Integer(998).toString(), descendingKeySet
7704                .ceiling(endKey));
7705        assertEquals(key, descendingKeySet.ceiling(key));
7706
7707        // With Comparator
7708        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7709                .navigableKeySet();
7710        descendingKeySet = keySet.descendingSet();
7711        keyArray = (String[]) descendingKeySet
7712                .toArray(new String[descendingKeySet.size()]);
7713        for (int i = 0, j = 108; i < keyArray.length; i++) {
7714            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7715            assertEquals(new Integer(j - i).toString(), ceilingKey);
7716        }
7717
7718        key = new Integer(2).toString();
7719        ceilingKey = (String) descendingKeySet.ceiling(key);
7720        assertEquals(108, Integer.parseInt(ceilingKey));
7721
7722        key = new Integer(0).toString();
7723        ceilingKey = (String) descendingKeySet.ceiling(key);
7724        assertNull(ceilingKey);
7725
7726        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
7727                .navigableKeySet();
7728        descendingKeySet = keySet.descendingSet();
7729        keyArray = (String[]) descendingKeySet
7730                .toArray(new String[descendingKeySet.size()]);
7731        for (int i = 0, j = 109; i < keyArray.length; i++) {
7732            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7733            assertEquals(new Integer(j - i).toString(), ceilingKey);
7734        }
7735
7736        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
7737                .navigableKeySet();
7738        descendingKeySet = keySet.descendingSet();
7739        keyArray = (String[]) descendingKeySet
7740                .toArray(new String[descendingKeySet.size()]);
7741        for (int i = 0, j = 108; i < keyArray.length; i++) {
7742            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7743            assertEquals(new Integer(j - i).toString(), ceilingKey);
7744        }
7745
7746        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
7747                .navigableKeySet();
7748        descendingKeySet = keySet.descendingSet();
7749        keyArray = (String[]) descendingKeySet
7750                .toArray(new String[descendingKeySet.size()]);
7751        for (int i = 0, j = 109; i < keyArray.length; i++) {
7752            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7753            assertEquals(new Integer(j - i).toString(), ceilingKey);
7754        }
7755    }
7756
7757    public void test_DescendingSubMapKeySet_floor() {
7758        NavigableSet keySet, descendingKeySet;
7759        String[] keyArray;
7760        String floorKey;
7761
7762        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7763        descendingKeySet = keySet.descendingSet();
7764        keyArray = (String[]) descendingKeySet
7765                .toArray(new String[descendingKeySet.size()]);
7766        for (int i = 0, j = 108; i < keyArray.length; i++) {
7767            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7768            assertEquals(new Integer(j - i).toString(), floorKey);
7769        }
7770
7771        String key = new Integer(0).toString();
7772        floorKey = (String) descendingKeySet.floor(key);
7773        assertEquals(101, Integer.parseInt(floorKey));
7774
7775        key = new Integer(2).toString();
7776        floorKey = (String) descendingKeySet.floor(key);
7777        assertNull(floorKey);
7778
7779        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7780        descendingKeySet = keySet.descendingSet();
7781        keyArray = (String[]) descendingKeySet
7782                .toArray(new String[descendingKeySet.size()]);
7783        for (int i = 0, j = 109; i < keyArray.length; i++) {
7784            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7785            assertEquals(new Integer(j - i).toString(), floorKey);
7786        }
7787
7788        key = new Integer(0).toString();
7789        floorKey = (String) descendingKeySet.floor(key);
7790        assertEquals(101, Integer.parseInt(floorKey));
7791
7792        key = new Integer(2).toString();
7793        floorKey = (String) descendingKeySet.floor(key);
7794        assertNull(floorKey);
7795
7796        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7797        descendingKeySet = keySet.descendingSet();
7798        keyArray = (String[]) descendingKeySet
7799                .toArray(new String[descendingKeySet.size()]);
7800        for (int i = 0, j = 108; i < keyArray.length; i++) {
7801            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7802            assertEquals(new Integer(j - i).toString(), floorKey);
7803        }
7804
7805        key = new Integer(0).toString();
7806        floorKey = (String) descendingKeySet.floor(key);
7807        assertEquals(100, Integer.parseInt(floorKey));
7808
7809        key = new Integer(2).toString();
7810        floorKey = (String) descendingKeySet.floor(key);
7811        assertNull(floorKey);
7812
7813        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7814        descendingKeySet = keySet.descendingSet();
7815        keyArray = (String[]) descendingKeySet
7816                .toArray(new String[descendingKeySet.size()]);
7817        for (int i = 0, j = 109; i < keyArray.length; i++) {
7818            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7819            assertEquals(new Integer(j - i).toString(), floorKey);
7820        }
7821
7822        key = new Integer(0).toString();
7823        floorKey = (String) descendingKeySet.floor(key);
7824        assertEquals(100, Integer.parseInt(floorKey));
7825
7826        key = new Integer(2).toString();
7827        floorKey = (String) descendingKeySet.floor(key);
7828        assertNull(floorKey);
7829
7830        key = new Integer(2).toString();
7831        keySet = tm.headMap(key, true).navigableKeySet();
7832        descendingKeySet = keySet.descendingSet();
7833        Iterator iterator = descendingKeySet.iterator();
7834        assertEquals(key, descendingKeySet.floor(iterator.next()));
7835        try {
7836            descendingKeySet.floor(null);
7837            fail("should throw NPE");
7838        } catch (NullPointerException e) {
7839            // Expected
7840        }
7841
7842        key = new Integer(0).toString();
7843        String endKey = key;
7844
7845        keySet = tm.headMap(endKey, true).navigableKeySet();
7846        descendingKeySet = keySet.descendingSet();
7847        assertEquals(key, descendingKeySet.floor(endKey));
7848
7849        key = new Integer(0).toString();
7850        keySet = tm.headMap(endKey, false).navigableKeySet();
7851        descendingKeySet = keySet.descendingSet();
7852        assertNull(descendingKeySet.floor(endKey));
7853
7854        endKey = new Integer(999).toString();
7855        keySet = tm.headMap(endKey, true).navigableKeySet();
7856        descendingKeySet = keySet.descendingSet();
7857        assertEquals(new Integer(999).toString(), descendingKeySet
7858                .floor(endKey));
7859        assertEquals(key, descendingKeySet.floor(key));
7860
7861        endKey = new Integer(999).toString();
7862        keySet = tm.headMap(endKey, false).navigableKeySet();
7863        descendingKeySet = keySet.descendingSet();
7864        assertNull(descendingKeySet.floor(endKey));
7865        assertEquals(key, descendingKeySet.floor(key));
7866
7867        // With Comparator
7868        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7869                .navigableKeySet();
7870        descendingKeySet = keySet.descendingSet();
7871        keyArray = (String[]) descendingKeySet
7872                .toArray(new String[descendingKeySet.size()]);
7873        for (int i = 0, j = 108; i < keyArray.length; i++) {
7874            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7875            assertEquals(new Integer(j - i).toString(), floorKey);
7876        }
7877
7878        key = new Integer(0).toString();
7879        floorKey = (String) descendingKeySet.floor(key);
7880        assertEquals(101, Integer.parseInt(floorKey));
7881
7882        key = new Integer(2).toString();
7883        floorKey = (String) descendingKeySet.floor(key);
7884        assertNull(floorKey);
7885
7886        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
7887                .navigableKeySet();
7888        descendingKeySet = keySet.descendingSet();
7889        keyArray = (String[]) descendingKeySet
7890                .toArray(new String[descendingKeySet.size()]);
7891        for (int i = 0, j = 109; i < keyArray.length; i++) {
7892            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7893            assertEquals(new Integer(j - i).toString(), floorKey);
7894        }
7895
7896        key = new Integer(0).toString();
7897        floorKey = (String) descendingKeySet.floor(key);
7898        assertEquals(101, Integer.parseInt(floorKey));
7899
7900        key = new Integer(2).toString();
7901        floorKey = (String) descendingKeySet.floor(key);
7902        assertNull(floorKey);
7903
7904        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
7905                .navigableKeySet();
7906        descendingKeySet = keySet.descendingSet();
7907        keyArray = (String[]) descendingKeySet
7908                .toArray(new String[descendingKeySet.size()]);
7909        for (int i = 0, j = 108; i < keyArray.length; i++) {
7910            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7911            assertEquals(new Integer(j - i).toString(), floorKey);
7912        }
7913
7914        key = new Integer(0).toString();
7915        floorKey = (String) descendingKeySet.floor(key);
7916        assertEquals(100, Integer.parseInt(floorKey));
7917
7918        key = new Integer(2).toString();
7919        floorKey = (String) descendingKeySet.floor(key);
7920        assertNull(floorKey);
7921
7922        keySet = ((NavigableMap) subMap_startIncluded_endIncluded)
7923                .navigableKeySet();
7924        descendingKeySet = keySet.descendingSet();
7925        keyArray = (String[]) descendingKeySet
7926                .toArray(new String[descendingKeySet.size()]);
7927        for (int i = 0, j = 109; i < keyArray.length; i++) {
7928            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7929            assertEquals(new Integer(j - i).toString(), floorKey);
7930        }
7931
7932        key = new Integer(0).toString();
7933        floorKey = (String) descendingKeySet.floor(key);
7934        assertEquals(100, Integer.parseInt(floorKey));
7935
7936        key = new Integer(2).toString();
7937        floorKey = (String) descendingKeySet.floor(key);
7938        assertNull(floorKey);
7939    }
7940
7941    public void test_AscendingSubMapKeySet_last() {
7942        NavigableSet keySet;
7943        String firstKey1 = new Integer(108).toString();
7944        String firstKey2 = new Integer(109).toString();
7945
7946        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7947        assertEquals(firstKey1, keySet.last());
7948
7949        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7950        assertEquals(firstKey2, keySet.last());
7951
7952        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7953        assertEquals(firstKey1, keySet.last());
7954
7955        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7956        assertEquals(firstKey2, keySet.last());
7957    }
7958
7959    public void test_AscendingSubMapKeySet_comparator() {
7960        NavigableSet keySet;
7961        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7962        assertNull(keySet.comparator());
7963
7964        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7965        assertNull(keySet.comparator());
7966
7967        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7968        assertNull(keySet.comparator());
7969
7970        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7971        assertNull(keySet.comparator());
7972
7973        String endKey = new Integer(2).toString();
7974        keySet = tm.headMap(endKey, true).navigableKeySet();
7975        assertNull(keySet.comparator());
7976    }
7977
7978    public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endExcluded() {
7979        NavigableSet keySet = navigableMap_startExcluded_endExcluded
7980                .navigableKeySet();
7981        Iterator iterator = keySet.iterator();
7982        assertEquals(8, keySet.size());
7983        for (int value = 101; value < 109; value++) {
7984            assertEquals(new Integer(value).toString(), keySet.pollFirst());
7985        }
7986        assertEquals(0, keySet.size());
7987        assertNull(keySet.pollFirst());
7988    }
7989
7990    public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endIncluded() {
7991        NavigableSet keySet = navigableMap_startExcluded_endIncluded
7992                .navigableKeySet();
7993        Iterator iterator = keySet.iterator();
7994        assertEquals(9, keySet.size());
7995        for (int value = 101; value < 110; value++) {
7996            assertEquals(new Integer(value).toString(), keySet.pollFirst());
7997        }
7998        assertEquals(0, keySet.size());
7999        assertNull(keySet.pollFirst());
8000    }
8001
8002    public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endExcluded() {
8003        NavigableSet keySet = navigableMap_startIncluded_endExcluded
8004                .navigableKeySet();
8005        Iterator iterator = keySet.iterator();
8006        assertEquals(9, keySet.size());
8007        for (int value = 100; value < 109; value++) {
8008            assertEquals(new Integer(value).toString(), keySet.pollFirst());
8009        }
8010        assertEquals(0, keySet.size());
8011        assertNull(keySet.pollFirst());
8012    }
8013
8014    public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endIncluded() {
8015        NavigableSet keySet = navigableMap_startIncluded_endIncluded
8016                .navigableKeySet();
8017        Iterator iterator = keySet.iterator();
8018        assertEquals(10, keySet.size());
8019        for (int value = 100; value < 110; value++) {
8020            assertEquals(new Integer(value).toString(), keySet.pollFirst());
8021        }
8022        assertEquals(0, keySet.size());
8023        assertNull(keySet.pollFirst());
8024    }
8025
8026    public void test_AscendingSubMapKeySet_pollFirst() {
8027        String endKey = new Integer(2).toString();
8028        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
8029        assertEquals(new Integer(0).toString(), keySet.pollFirst());
8030
8031        keySet = tm.tailMap(endKey, true).navigableKeySet();
8032        assertEquals(new Integer(2).toString(), keySet.pollFirst());
8033    }
8034
8035    public void test_AscendingSubMapKeySet_pollLast_startExcluded_endExcluded() {
8036        NavigableSet keySet = navigableMap_startExcluded_endExcluded
8037                .navigableKeySet();
8038        Iterator iterator = keySet.iterator();
8039        assertEquals(8, keySet.size());
8040        for (int value = 108; value > 100; value--) {
8041            assertEquals(new Integer(value).toString(), keySet.pollLast());
8042        }
8043        assertEquals(0, keySet.size());
8044        assertNull(keySet.pollLast());
8045    }
8046
8047    public void test_AscendingSubMapKeySet_pollLast_startExcluded_endIncluded() {
8048        NavigableSet keySet = navigableMap_startExcluded_endIncluded
8049                .navigableKeySet();
8050        Iterator iterator = keySet.iterator();
8051        assertEquals(9, keySet.size());
8052        for (int value = 109; value > 100; value--) {
8053            assertEquals(new Integer(value).toString(), keySet.pollLast());
8054        }
8055        assertEquals(0, keySet.size());
8056        assertNull(keySet.pollLast());
8057    }
8058
8059    public void test_AscendingSubMapKeySet_pollLast_startIncluded_endExcluded() {
8060        NavigableSet keySet = navigableMap_startIncluded_endExcluded
8061                .navigableKeySet();
8062        Iterator iterator = keySet.iterator();
8063        assertEquals(9, keySet.size());
8064        for (int value = 108; value > 99; value--) {
8065            assertEquals(new Integer(value).toString(), keySet.pollLast());
8066        }
8067        assertEquals(0, keySet.size());
8068        assertNull(keySet.pollLast());
8069    }
8070
8071    public void test_AscendingSubMapKeySet_pollLast_startIncluded_endIncluded() {
8072        NavigableSet keySet = navigableMap_startIncluded_endIncluded
8073                .navigableKeySet();
8074        Iterator iterator = keySet.iterator();
8075        assertEquals(10, keySet.size());
8076        for (int value = 109; value > 99; value--) {
8077            assertEquals(new Integer(value).toString(), keySet.pollLast());
8078        }
8079        assertEquals(0, keySet.size());
8080        assertNull(keySet.pollLast());
8081    }
8082
8083    public void test_AscendingSubMapKeySet_pollLast() {
8084        String endKey = new Integer(2).toString();
8085        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
8086        assertEquals(new Integer(2).toString(), keySet.pollLast());
8087
8088        keySet = tm.tailMap(endKey, true).navigableKeySet();
8089        assertEquals(new Integer(999).toString(), keySet.pollLast());
8090    }
8091
8092    public void test_AscendingSubMapKeySet_descendingIterator() {
8093        NavigableSet keySet;
8094        Iterator iterator;
8095
8096        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
8097        iterator = keySet.descendingIterator();
8098        for (int value = 108; value > 100; value--) {
8099            assertTrue(iterator.hasNext());
8100            assertEquals(new Integer(value).toString(), iterator.next());
8101        }
8102        assertFalse(iterator.hasNext());
8103        try {
8104            iterator.next();
8105            fail("should throw NoSuchElementException");
8106        } catch (NoSuchElementException e) {
8107            // Expected
8108        }
8109
8110        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
8111        iterator = keySet.descendingIterator();
8112        for (int value = 109; value > 100; value--) {
8113            assertTrue(iterator.hasNext());
8114            assertEquals(new Integer(value).toString(), iterator.next());
8115        }
8116        assertFalse(iterator.hasNext());
8117        try {
8118            iterator.next();
8119            fail("should throw NoSuchElementException");
8120        } catch (NoSuchElementException e) {
8121            // Expected
8122        }
8123
8124        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
8125        iterator = keySet.descendingIterator();
8126        for (int value = 108; value > 99; value--) {
8127            assertTrue(iterator.hasNext());
8128            assertEquals(new Integer(value).toString(), iterator.next());
8129        }
8130        assertFalse(iterator.hasNext());
8131        try {
8132            iterator.next();
8133            fail("should throw NoSuchElementException");
8134        } catch (NoSuchElementException e) {
8135            // Expected
8136        }
8137
8138        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
8139        iterator = keySet.descendingIterator();
8140        for (int value = 109; value > 99; value--) {
8141            assertTrue(iterator.hasNext());
8142            assertEquals(new Integer(value).toString(), iterator.next());
8143        }
8144        assertFalse(iterator.hasNext());
8145        try {
8146            iterator.next();
8147            fail("should throw NoSuchElementException");
8148        } catch (NoSuchElementException e) {
8149            // Expected
8150        }
8151
8152        String endKey = new Integer(2).toString();
8153        keySet = tm.headMap(endKey, true).navigableKeySet();
8154        iterator = keySet.descendingIterator();
8155        assertEquals(new Integer(2).toString(), iterator.next());
8156        assertEquals(new Integer(199).toString(), iterator.next());
8157    }
8158
8159    public void test_AscendingSubMapKeySet_descendingSet() {
8160        NavigableSet keySet, descendingSet;
8161        Iterator iterator;
8162
8163        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet()
8164                .descendingSet();
8165        descendingSet = keySet.descendingSet();
8166        iterator = descendingSet.iterator();
8167        for (int value = 101; value < 109; value++) {
8168            assertTrue(iterator.hasNext());
8169            assertEquals(new Integer(value).toString(), iterator.next());
8170        }
8171        assertFalse(iterator.hasNext());
8172        try {
8173            iterator.next();
8174            fail("should throw NoSuchElementException");
8175        } catch (NoSuchElementException e) {
8176            // Expected
8177        }
8178
8179        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet()
8180                .descendingSet();
8181        descendingSet = keySet.descendingSet();
8182        iterator = descendingSet.iterator();
8183        for (int value = 101; value < 110; value++) {
8184            assertTrue(iterator.hasNext());
8185            assertEquals(new Integer(value).toString(), iterator.next());
8186        }
8187        assertFalse(iterator.hasNext());
8188        try {
8189            iterator.next();
8190            fail("should throw NoSuchElementException");
8191        } catch (NoSuchElementException e) {
8192            // Expected
8193        }
8194
8195        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet()
8196                .descendingSet();
8197        descendingSet = keySet.descendingSet();
8198        iterator = descendingSet.iterator();
8199        for (int value = 100; value < 109; value++) {
8200            assertTrue(iterator.hasNext());
8201            assertEquals(new Integer(value).toString(), iterator.next());
8202        }
8203        assertFalse(iterator.hasNext());
8204        try {
8205            iterator.next();
8206            fail("should throw NoSuchElementException");
8207        } catch (NoSuchElementException e) {
8208            // Expected
8209        }
8210
8211        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet()
8212                .descendingSet();
8213        descendingSet = keySet.descendingSet();
8214        iterator = descendingSet.iterator();
8215        for (int value = 100; value < 110; value++) {
8216            assertTrue(iterator.hasNext());
8217            assertEquals(new Integer(value).toString(), iterator.next());
8218        }
8219        assertFalse(iterator.hasNext());
8220        try {
8221            iterator.next();
8222            fail("should throw NoSuchElementException");
8223        } catch (NoSuchElementException e) {
8224            // Expected
8225        }
8226
8227        String endKey = new Integer(1).toString();
8228        keySet = tm.headMap(endKey, true).navigableKeySet();
8229        descendingSet = keySet.descendingSet();
8230        iterator = descendingSet.iterator();
8231        assertEquals(new Integer(1).toString(), iterator.next());
8232        assertEquals(new Integer(0).toString(), iterator.next());
8233    }
8234
8235    public void test_AscendingSubMapKeySet_headSet() {
8236        NavigableSet keySet;
8237        SortedSet headSet;
8238        String endKey, key;
8239        Iterator iterator;
8240
8241        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
8242        endKey = new Integer(99).toString();
8243        try {
8244            keySet.headSet(endKey);
8245            fail("should throw IllegalArgumentException");
8246        } catch (IllegalArgumentException e) {
8247            // Expected
8248        }
8249        try {
8250            keySet.headSet(endKey, false);
8251            fail("should throw IllegalArgumentException");
8252        } catch (IllegalArgumentException e) {
8253            // Expected
8254        }
8255        try {
8256            keySet.headSet(endKey, true);
8257            fail("should throw IllegalArgumentException");
8258        } catch (IllegalArgumentException e) {
8259            // Expected
8260        }
8261
8262        endKey = new Integer(100).toString();
8263        try {
8264            keySet.headSet(endKey, false);
8265            fail("should throw IllegalArgumentException");
8266        } catch (IllegalArgumentException e) {
8267            // Expected
8268        }
8269
8270        try {
8271            keySet.headSet(endKey);
8272            fail("should throw IllegalArgumentException");
8273        } catch (IllegalArgumentException e) {
8274            // Expected
8275        }
8276
8277        try {
8278            keySet.headSet(endKey, true);
8279            fail("should throw IllegalArgumentException");
8280        } catch (IllegalArgumentException e) {
8281            // Expected
8282        }
8283
8284        endKey = new Integer(101).toString();
8285        assertEquals(0, keySet.headSet(endKey).size());
8286        assertEquals(0, keySet.headSet(endKey, false).size());
8287        assertEquals(1, keySet.headSet(endKey, true).size());
8288
8289        for (int i = 102; i < 109; i++) {
8290            endKey = new Integer(i).toString();
8291            headSet = keySet.headSet(endKey);
8292            iterator = headSet.iterator();
8293            int j;
8294            for (j = 101; iterator.hasNext(); j++) {
8295                key = (String) iterator.next();
8296                assertEquals(new Integer(j).toString(), key);
8297            }
8298            assertEquals(i, j);
8299
8300            headSet = keySet.headSet(endKey, false);
8301            iterator = headSet.iterator();
8302            for (j = 101; iterator.hasNext(); j++) {
8303                key = (String) iterator.next();
8304                assertEquals(new Integer(j).toString(), key);
8305            }
8306            assertEquals(i, j);
8307
8308            headSet = keySet.headSet(endKey, true);
8309            iterator = headSet.iterator();
8310            for (j = 101; iterator.hasNext(); j++) {
8311                key = (String) iterator.next();
8312                assertEquals(new Integer(j).toString(), key);
8313            }
8314            assertEquals(i + 1, j);
8315        }
8316
8317        endKey = new Integer(109).toString();
8318        headSet = keySet.headSet(endKey);
8319        iterator = headSet.iterator();
8320        int index;
8321        for (index = 101; iterator.hasNext(); index++) {
8322            key = (String) iterator.next();
8323            assertEquals(new Integer(index).toString(), key);
8324        }
8325        assertEquals(109, index);
8326
8327        headSet = keySet.headSet(endKey, false);
8328        iterator = headSet.iterator();
8329        for (index = 101; iterator.hasNext(); index++) {
8330            key = (String) iterator.next();
8331            assertEquals(new Integer(index).toString(), key);
8332        }
8333        assertEquals(109, index);
8334
8335        try {
8336            keySet.headSet(endKey, true);
8337            fail("should throw IllegalArgumentException");
8338        } catch (IllegalArgumentException e) {
8339            // Expected
8340        }
8341
8342        endKey = new Integer(110).toString();
8343        try {
8344            keySet.headSet(endKey);
8345            fail("should throw IllegalArgumentException");
8346        } catch (IllegalArgumentException e) {
8347            // Expected
8348        }
8349        try {
8350            keySet.headSet(endKey, true);
8351            fail("should throw IllegalArgumentException");
8352        } catch (IllegalArgumentException e) {
8353            // Expected
8354        }
8355        try {
8356            keySet.headSet(endKey, false);
8357            fail("should throw IllegalArgumentException");
8358        } catch (IllegalArgumentException e) {
8359            // Expected
8360        }
8361
8362        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
8363        endKey = new Integer(99).toString();
8364        try {
8365            keySet.headSet(endKey);
8366            fail("should throw IllegalArgumentException");
8367        } catch (IllegalArgumentException e) {
8368            // Expected
8369        }
8370        try {
8371            keySet.headSet(endKey, true);
8372            fail("should throw IllegalArgumentException");
8373        } catch (IllegalArgumentException e) {
8374            // Expected
8375        }
8376        try {
8377            keySet.headSet(endKey, false);
8378            fail("should throw IllegalArgumentException");
8379        } catch (IllegalArgumentException e) {
8380            // Expected
8381        }
8382
8383        endKey = new Integer(100).toString();
8384        try {
8385            keySet.headSet(endKey);
8386            fail("should throw IllegalArgumentException");
8387        } catch (IllegalArgumentException e) {
8388            // Expected
8389        }
8390
8391        try {
8392            keySet.headSet(endKey, false);
8393            fail("should throw IllegalArgumentException");
8394        } catch (IllegalArgumentException e) {
8395            // Expected
8396        }
8397
8398        try {
8399            keySet.headSet(endKey, true);
8400            fail("should throw IllegalArgumentException");
8401        } catch (IllegalArgumentException e) {
8402            // Expected
8403        }
8404
8405        endKey = new Integer(101).toString();
8406        assertEquals(0, keySet.headSet(endKey).size());
8407        assertEquals(0, keySet.headSet(endKey).size());
8408        assertEquals(1, keySet.headSet(endKey, true).size());
8409
8410        for (int i = 102; i < 109; i++) {
8411            endKey = new Integer(i).toString();
8412
8413            headSet = keySet.headSet(endKey);
8414            iterator = headSet.iterator();
8415            int j;
8416            for (j = 101; iterator.hasNext(); j++) {
8417                key = (String) iterator.next();
8418                assertEquals(new Integer(j).toString(), key);
8419            }
8420            assertEquals(i, j);
8421
8422            headSet = keySet.headSet(endKey, false);
8423            iterator = headSet.iterator();
8424            for (j = 101; iterator.hasNext(); j++) {
8425                key = (String) iterator.next();
8426                assertEquals(new Integer(j).toString(), key);
8427            }
8428            assertEquals(i, j);
8429
8430            headSet = keySet.headSet(endKey, true);
8431            iterator = headSet.iterator();
8432            for (j = 101; iterator.hasNext(); j++) {
8433                key = (String) iterator.next();
8434                assertEquals(new Integer(j).toString(), key);
8435            }
8436            assertEquals(i + 1, j);
8437        }
8438
8439        endKey = new Integer(109).toString();
8440        headSet = keySet.headSet(endKey);
8441        iterator = headSet.iterator();
8442        for (index = 101; iterator.hasNext(); index++) {
8443            key = (String) iterator.next();
8444            assertEquals(new Integer(index).toString(), key);
8445        }
8446        assertEquals(109, index);
8447
8448        headSet = keySet.headSet(endKey, false);
8449        iterator = headSet.iterator();
8450        for (index = 101; iterator.hasNext(); index++) {
8451            key = (String) iterator.next();
8452            assertEquals(new Integer(index).toString(), key);
8453        }
8454        assertEquals(109, index);
8455
8456        headSet = keySet.headSet(endKey, true);
8457        iterator = headSet.iterator();
8458        for (index = 101; iterator.hasNext(); index++) {
8459            key = (String) iterator.next();
8460            assertEquals(new Integer(index).toString(), key);
8461        }
8462        assertEquals(110, index);
8463
8464        endKey = new Integer(110).toString();
8465        try {
8466            keySet.headSet(endKey);
8467            fail("should throw IllegalArgumentException");
8468        } catch (IllegalArgumentException e) {
8469            // Expected
8470        }
8471        try {
8472            keySet.headSet(endKey, false);
8473            fail("should throw IllegalArgumentException");
8474        } catch (IllegalArgumentException e) {
8475            // Expected
8476        }
8477        try {
8478            keySet.headSet(endKey, true);
8479            fail("should throw IllegalArgumentException");
8480        } catch (IllegalArgumentException e) {
8481            // Expected
8482        }
8483
8484        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
8485        endKey = new Integer(99).toString();
8486        try {
8487            keySet.headSet(endKey);
8488            fail("should throw IllegalArgumentException");
8489        } catch (IllegalArgumentException e) {
8490            // Expected
8491        }
8492        try {
8493            keySet.headSet(endKey, false);
8494            fail("should throw IllegalArgumentException");
8495        } catch (IllegalArgumentException e) {
8496            // Expected
8497        }
8498        try {
8499            keySet.headSet(endKey, true);
8500            fail("should throw IllegalArgumentException");
8501        } catch (IllegalArgumentException e) {
8502            // Expected
8503        }
8504
8505        endKey = new Integer(100).toString();
8506        assertEquals(0, keySet.headSet(endKey).size());
8507        assertEquals(0, keySet.headSet(endKey, false).size());
8508        assertEquals(1, keySet.headSet(endKey, true).size());
8509
8510        endKey = new Integer(101).toString();
8511        headSet = keySet.headSet(endKey);
8512        iterator = headSet.iterator();
8513        for (index = 100; iterator.hasNext(); index++) {
8514            key = (String) iterator.next();
8515            assertEquals(new Integer(index).toString(), key);
8516        }
8517        assertEquals(101, index);
8518
8519        headSet = keySet.headSet(endKey, false);
8520        iterator = headSet.iterator();
8521        for (index = 100; iterator.hasNext(); index++) {
8522            key = (String) iterator.next();
8523            assertEquals(new Integer(index).toString(), key);
8524        }
8525        assertEquals(101, index);
8526
8527        headSet = keySet.headSet(endKey, true);
8528        iterator = headSet.iterator();
8529        for (index = 100; iterator.hasNext(); index++) {
8530            key = (String) iterator.next();
8531            assertEquals(new Integer(index).toString(), key);
8532        }
8533        assertEquals(102, index);
8534
8535        for (int i = 102; i < 109; i++) {
8536            endKey = new Integer(i).toString();
8537
8538            headSet = keySet.headSet(endKey);
8539            iterator = headSet.iterator();
8540            int j;
8541            for (j = 100; iterator.hasNext(); j++) {
8542                key = (String) iterator.next();
8543                assertEquals(new Integer(j).toString(), key);
8544            }
8545            assertEquals(i, j);
8546
8547            headSet = keySet.headSet(endKey, false);
8548            iterator = headSet.iterator();
8549            for (j = 100; iterator.hasNext(); j++) {
8550                key = (String) iterator.next();
8551                assertEquals(new Integer(j).toString(), key);
8552            }
8553            assertEquals(i, j);
8554
8555            headSet = keySet.headSet(endKey, true);
8556            iterator = headSet.iterator();
8557            for (j = 100; iterator.hasNext(); j++) {
8558                key = (String) iterator.next();
8559                assertEquals(new Integer(j).toString(), key);
8560            }
8561            assertEquals(i + 1, j);
8562        }
8563
8564        endKey = new Integer(109).toString();
8565        headSet = keySet.headSet(endKey);
8566        iterator = headSet.iterator();
8567        for (index = 100; iterator.hasNext(); index++) {
8568            key = (String) iterator.next();
8569            assertEquals(new Integer(index).toString(), key);
8570        }
8571        assertEquals(109, index);
8572
8573        headSet = keySet.headSet(endKey, false);
8574        iterator = headSet.iterator();
8575        for (index = 100; iterator.hasNext(); index++) {
8576            key = (String) iterator.next();
8577            assertEquals(new Integer(index).toString(), key);
8578        }
8579        assertEquals(109, index);
8580
8581        try {
8582            keySet.headSet(endKey, true);
8583            fail("should throw IllegalArgumentException");
8584        } catch (IllegalArgumentException e) {
8585            // Expected
8586        }
8587
8588        endKey = new Integer(110).toString();
8589        try {
8590            keySet.headSet(endKey);
8591            fail("should throw IllegalArgumentException");
8592        } catch (IllegalArgumentException e) {
8593            // Expected
8594        }
8595
8596        try {
8597            keySet.headSet(endKey, false);
8598            fail("should throw IllegalArgumentException");
8599        } catch (IllegalArgumentException e) {
8600            // Expected
8601        }
8602
8603        try {
8604            keySet.headSet(endKey, true);
8605            fail("should throw IllegalArgumentException");
8606        } catch (IllegalArgumentException e) {
8607            // Expected
8608        }
8609
8610        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
8611        endKey = new Integer(99).toString();
8612        try {
8613            keySet.headSet(endKey);
8614            fail("should throw IllegalArgumentException");
8615        } catch (IllegalArgumentException e) {
8616            // Expected
8617        }
8618        try {
8619            keySet.headSet(endKey, false);
8620            fail("should throw IllegalArgumentException");
8621        } catch (IllegalArgumentException e) {
8622            // Expected
8623        }
8624        try {
8625            keySet.headSet(endKey, true);
8626            fail("should throw IllegalArgumentException");
8627        } catch (IllegalArgumentException e) {
8628            // Expected
8629        }
8630
8631        endKey = new Integer(100).toString();
8632        assertEquals(0, keySet.headSet(endKey).size());
8633        assertEquals(0, keySet.headSet(endKey, false).size());
8634        assertEquals(1, keySet.headSet(endKey, true).size());
8635
8636        endKey = new Integer(101).toString();
8637        headSet = keySet.headSet(endKey);
8638        iterator = headSet.iterator();
8639        for (index = 100; iterator.hasNext(); index++) {
8640            key = (String) iterator.next();
8641            assertEquals(new Integer(index).toString(), key);
8642        }
8643        assertEquals(101, index);
8644
8645        headSet = keySet.headSet(endKey, false);
8646        iterator = headSet.iterator();
8647        for (index = 100; iterator.hasNext(); index++) {
8648            key = (String) iterator.next();
8649            assertEquals(new Integer(index).toString(), key);
8650        }
8651        assertEquals(101, index);
8652
8653        headSet = keySet.headSet(endKey, true);
8654        iterator = headSet.iterator();
8655        for (index = 100; iterator.hasNext(); index++) {
8656            key = (String) iterator.next();
8657            assertEquals(new Integer(index).toString(), key);
8658        }
8659        assertEquals(102, index);
8660
8661        for (int i = 102; i < 109; i++) {
8662            endKey = new Integer(i).toString();
8663
8664            headSet = keySet.headSet(endKey);
8665            iterator = headSet.iterator();
8666            int j;
8667            for (j = 100; iterator.hasNext(); j++) {
8668                key = (String) iterator.next();
8669                assertEquals(new Integer(j).toString(), key);
8670            }
8671            assertEquals(i, j);
8672
8673            headSet = keySet.headSet(endKey, false);
8674            iterator = headSet.iterator();
8675            for (j = 100; iterator.hasNext(); j++) {
8676                key = (String) iterator.next();
8677                assertEquals(new Integer(j).toString(), key);
8678            }
8679            assertEquals(i, j);
8680
8681            headSet = keySet.headSet(endKey, true);
8682            iterator = headSet.iterator();
8683            for (j = 100; iterator.hasNext(); j++) {
8684                key = (String) iterator.next();
8685                assertEquals(new Integer(j).toString(), key);
8686            }
8687            assertEquals(i + 1, j);
8688        }
8689
8690        endKey = new Integer(109).toString();
8691        headSet = keySet.headSet(endKey);
8692        iterator = headSet.iterator();
8693        for (index = 100; iterator.hasNext(); index++) {
8694            key = (String) iterator.next();
8695            assertEquals(new Integer(index).toString(), key);
8696        }
8697        assertEquals(109, index);
8698
8699        headSet = keySet.headSet(endKey, false);
8700        iterator = headSet.iterator();
8701        for (index = 100; iterator.hasNext(); index++) {
8702            key = (String) iterator.next();
8703            assertEquals(new Integer(index).toString(), key);
8704        }
8705        assertEquals(109, index);
8706
8707        headSet = keySet.headSet(endKey, true);
8708        iterator = headSet.iterator();
8709        for (index = 100; iterator.hasNext(); index++) {
8710            key = (String) iterator.next();
8711            assertEquals(new Integer(index).toString(), key);
8712        }
8713        assertEquals(110, index);
8714
8715        endKey = new Integer(110).toString();
8716        try {
8717            keySet.headSet(endKey);
8718            fail("should throw IllegalArgumentException");
8719        } catch (IllegalArgumentException e) {
8720            // Expected
8721        }
8722        try {
8723            keySet.headSet(endKey, false);
8724            fail("should throw IllegalArgumentException");
8725        } catch (IllegalArgumentException e) {
8726            // Expected
8727        }
8728        try {
8729            keySet.headSet(endKey, true);
8730            fail("should throw IllegalArgumentException");
8731        } catch (IllegalArgumentException e) {
8732            // Expected
8733        }
8734
8735        key = new Integer(1).toString();
8736        keySet = tm.headMap(key, true).navigableKeySet();
8737        iterator = keySet.iterator();
8738        iterator.next();
8739        endKey = (String) iterator.next();
8740        headSet = keySet.headSet(endKey, false);
8741        assertEquals(1, headSet.size());
8742        Iterator headSetIterator = headSet.iterator();
8743        assertEquals(new Integer(0).toString(), headSetIterator.next());
8744        assertFalse(headSetIterator.hasNext());
8745        try {
8746            headSetIterator.next();
8747            fail("should throw NoSuchElementException");
8748        } catch (NoSuchElementException e) {
8749            // Expected
8750        }
8751        try {
8752            keySet.headSet(null, false);
8753            fail("should throw NPE");
8754        } catch (NullPointerException e) {
8755            // Expected
8756        }
8757
8758        headSet = keySet.headSet(endKey, true);
8759        assertEquals(2, headSet.size());
8760        headSetIterator = headSet.iterator();
8761        assertEquals(new Integer(0).toString(), headSetIterator.next());
8762        assertEquals(new Integer(1).toString(), headSetIterator.next());
8763        assertFalse(headSetIterator.hasNext());
8764        try {
8765            headSetIterator.next();
8766            fail("should throw NoSuchElementException");
8767        } catch (NoSuchElementException e) {
8768            // Expected
8769        }
8770        try {
8771            keySet.headSet(null, false);
8772            fail("should throw NPE");
8773        } catch (NullPointerException e) {
8774            // Expected
8775        }
8776
8777        // With Comparator
8778        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
8779                .navigableKeySet();
8780        endKey = new Integer(99).toString();
8781        try {
8782            keySet.headSet(endKey);
8783            fail("should throw IllegalArgumentException");
8784        } catch (IllegalArgumentException e) {
8785            // Expected
8786        }
8787        try {
8788            keySet.headSet(endKey, false);
8789            fail("should throw IllegalArgumentException");
8790        } catch (IllegalArgumentException e) {
8791            // Expected
8792        }
8793        try {
8794            keySet.headSet(endKey, true);
8795            fail("should throw IllegalArgumentException");
8796        } catch (IllegalArgumentException e) {
8797            // Expected
8798        }
8799
8800        endKey = new Integer(100).toString();
8801        try {
8802            keySet.headSet(endKey).size();
8803            fail("should throw IllegalArgumentException");
8804        } catch (IllegalArgumentException e) {
8805            // Expected
8806        }
8807
8808        try {
8809            keySet.headSet(endKey, false).size();
8810            fail("should throw IllegalArgumentException");
8811        } catch (IllegalArgumentException e) {
8812            // Expected
8813        }
8814
8815        try {
8816            keySet.headSet(endKey, true).size();
8817            fail("should throw IllegalArgumentException");
8818        } catch (IllegalArgumentException e) {
8819            // Expected
8820        }
8821
8822        endKey = new Integer(101).toString();
8823        assertEquals(0, keySet.headSet(endKey).size());
8824        assertEquals(0, keySet.headSet(endKey, false).size());
8825        assertEquals(1, keySet.headSet(endKey, true).size());
8826
8827        for (int i = 102; i < 109; i++) {
8828            endKey = new Integer(i).toString();
8829            headSet = keySet.headSet(endKey);
8830            iterator = headSet.iterator();
8831            int j;
8832            for (j = 101; iterator.hasNext(); j++) {
8833                key = (String) iterator.next();
8834                assertEquals(new Integer(j).toString(), key);
8835            }
8836            assertEquals(i, j);
8837
8838            headSet = keySet.headSet(endKey, false);
8839            iterator = headSet.iterator();
8840            for (j = 101; iterator.hasNext(); j++) {
8841                key = (String) iterator.next();
8842                assertEquals(new Integer(j).toString(), key);
8843            }
8844            assertEquals(i, j);
8845
8846            headSet = keySet.headSet(endKey, true);
8847            iterator = headSet.iterator();
8848            for (j = 101; iterator.hasNext(); j++) {
8849                key = (String) iterator.next();
8850                assertEquals(new Integer(j).toString(), key);
8851            }
8852            assertEquals(i + 1, j);
8853        }
8854
8855        endKey = new Integer(109).toString();
8856        headSet = keySet.headSet(endKey);
8857        iterator = headSet.iterator();
8858        for (index = 101; iterator.hasNext(); index++) {
8859            key = (String) iterator.next();
8860            assertEquals(new Integer(index).toString(), key);
8861        }
8862        assertEquals(109, index);
8863
8864        headSet = keySet.headSet(endKey, false);
8865        iterator = headSet.iterator();
8866        for (index = 101; iterator.hasNext(); index++) {
8867            key = (String) iterator.next();
8868            assertEquals(new Integer(index).toString(), key);
8869        }
8870        assertEquals(109, index);
8871
8872        try {
8873            keySet.headSet(endKey, true);
8874            fail("should throw IllegalArgumentException");
8875        } catch (IllegalArgumentException e) {
8876            // Expected
8877        }
8878
8879        endKey = new Integer(110).toString();
8880        try {
8881            keySet.headSet(endKey);
8882            fail("should throw IllegalArgumentException");
8883        } catch (IllegalArgumentException e) {
8884            // Expected
8885        }
8886        try {
8887            keySet.headSet(endKey, true);
8888            fail("should throw IllegalArgumentException");
8889        } catch (IllegalArgumentException e) {
8890            // Expected
8891        }
8892        try {
8893            keySet.headSet(endKey, false);
8894            fail("should throw IllegalArgumentException");
8895        } catch (IllegalArgumentException e) {
8896            // Expected
8897        }
8898
8899        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
8900                .navigableKeySet();
8901        endKey = new Integer(99).toString();
8902        try {
8903            keySet.headSet(endKey);
8904            fail("should throw IllegalArgumentException");
8905        } catch (IllegalArgumentException e) {
8906            // Expected
8907        }
8908        try {
8909            keySet.headSet(endKey, true);
8910            fail("should throw IllegalArgumentException");
8911        } catch (IllegalArgumentException e) {
8912            // Expected
8913        }
8914        try {
8915            keySet.headSet(endKey, false);
8916            fail("should throw IllegalArgumentException");
8917        } catch (IllegalArgumentException e) {
8918            // Expected
8919        }
8920
8921        endKey = new Integer(100).toString();
8922        try {
8923            keySet.headSet(endKey);
8924            fail("should throw IllegalArgumentException");
8925        } catch (IllegalArgumentException e) {
8926            // Expected
8927        }
8928
8929        try {
8930            keySet.headSet(endKey, false);
8931            fail("should throw IllegalArgumentException");
8932        } catch (IllegalArgumentException e) {
8933            // Expected
8934        }
8935
8936        try {
8937            keySet.headSet(endKey, true);
8938            fail("should throw IllegalArgumentException");
8939        } catch (IllegalArgumentException e) {
8940            // Expected
8941        }
8942
8943        endKey = new Integer(101).toString();
8944        assertEquals(0, keySet.headSet(endKey).size());
8945        assertEquals(0, keySet.headSet(endKey).size());
8946        assertEquals(1, keySet.headSet(endKey, true).size());
8947
8948        for (int i = 102; i < 109; i++) {
8949            endKey = new Integer(i).toString();
8950
8951            headSet = keySet.headSet(endKey);
8952            iterator = headSet.iterator();
8953            int j;
8954            for (j = 101; iterator.hasNext(); j++) {
8955                key = (String) iterator.next();
8956                assertEquals(new Integer(j).toString(), key);
8957            }
8958            assertEquals(i, j);
8959
8960            headSet = keySet.headSet(endKey, false);
8961            iterator = headSet.iterator();
8962            for (j = 101; iterator.hasNext(); j++) {
8963                key = (String) iterator.next();
8964                assertEquals(new Integer(j).toString(), key);
8965            }
8966            assertEquals(i, j);
8967
8968            headSet = keySet.headSet(endKey, true);
8969            iterator = headSet.iterator();
8970            for (j = 101; iterator.hasNext(); j++) {
8971                key = (String) iterator.next();
8972                assertEquals(new Integer(j).toString(), key);
8973            }
8974            assertEquals(i + 1, j);
8975        }
8976
8977        endKey = new Integer(109).toString();
8978        headSet = keySet.headSet(endKey);
8979        iterator = headSet.iterator();
8980        for (index = 101; iterator.hasNext(); index++) {
8981            key = (String) iterator.next();
8982            assertEquals(new Integer(index).toString(), key);
8983        }
8984        assertEquals(109, index);
8985
8986        headSet = keySet.headSet(endKey, false);
8987        iterator = headSet.iterator();
8988        for (index = 101; iterator.hasNext(); index++) {
8989            key = (String) iterator.next();
8990            assertEquals(new Integer(index).toString(), key);
8991        }
8992        assertEquals(109, index);
8993
8994        headSet = keySet.headSet(endKey, true);
8995        iterator = headSet.iterator();
8996        for (index = 101; iterator.hasNext(); index++) {
8997            key = (String) iterator.next();
8998            assertEquals(new Integer(index).toString(), key);
8999        }
9000        assertEquals(110, index);
9001
9002        endKey = new Integer(110).toString();
9003        try {
9004            keySet.headSet(endKey);
9005            fail("should throw IllegalArgumentException");
9006        } catch (IllegalArgumentException e) {
9007            // Expected
9008        }
9009        try {
9010            keySet.headSet(endKey, false);
9011            fail("should throw IllegalArgumentException");
9012        } catch (IllegalArgumentException e) {
9013            // Expected
9014        }
9015        try {
9016            keySet.headSet(endKey, true);
9017            fail("should throw IllegalArgumentException");
9018        } catch (IllegalArgumentException e) {
9019            // Expected
9020        }
9021
9022        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
9023                .navigableKeySet();
9024        endKey = new Integer(99).toString();
9025        try {
9026            keySet.headSet(endKey);
9027            fail("should throw IllegalArgumentException");
9028        } catch (IllegalArgumentException e) {
9029            // Expected
9030        }
9031        try {
9032            keySet.headSet(endKey, false);
9033            fail("should throw IllegalArgumentException");
9034        } catch (IllegalArgumentException e) {
9035            // Expected
9036        }
9037        try {
9038            keySet.headSet(endKey, true);
9039            fail("should throw IllegalArgumentException");
9040        } catch (IllegalArgumentException e) {
9041            // Expected
9042        }
9043
9044        endKey = new Integer(100).toString();
9045        assertEquals(0, keySet.headSet(endKey).size());
9046        assertEquals(0, keySet.headSet(endKey, false).size());
9047        assertEquals(1, keySet.headSet(endKey, true).size());
9048
9049        endKey = new Integer(101).toString();
9050        headSet = keySet.headSet(endKey);
9051        iterator = headSet.iterator();
9052        for (index = 100; iterator.hasNext(); index++) {
9053            key = (String) iterator.next();
9054            assertEquals(new Integer(index).toString(), key);
9055        }
9056        assertEquals(101, index);
9057
9058        headSet = keySet.headSet(endKey, false);
9059        iterator = headSet.iterator();
9060        for (index = 100; iterator.hasNext(); index++) {
9061            key = (String) iterator.next();
9062            assertEquals(new Integer(index).toString(), key);
9063        }
9064        assertEquals(101, index);
9065
9066        headSet = keySet.headSet(endKey, true);
9067        iterator = headSet.iterator();
9068        for (index = 100; iterator.hasNext(); index++) {
9069            key = (String) iterator.next();
9070            assertEquals(new Integer(index).toString(), key);
9071        }
9072        assertEquals(102, index);
9073
9074        for (int i = 102; i < 109; i++) {
9075            endKey = new Integer(i).toString();
9076
9077            headSet = keySet.headSet(endKey);
9078            iterator = headSet.iterator();
9079            int j;
9080            for (j = 100; iterator.hasNext(); j++) {
9081                key = (String) iterator.next();
9082                assertEquals(new Integer(j).toString(), key);
9083            }
9084            assertEquals(i, j);
9085
9086            headSet = keySet.headSet(endKey, false);
9087            iterator = headSet.iterator();
9088            for (j = 100; iterator.hasNext(); j++) {
9089                key = (String) iterator.next();
9090                assertEquals(new Integer(j).toString(), key);
9091            }
9092            assertEquals(i, j);
9093
9094            headSet = keySet.headSet(endKey, true);
9095            iterator = headSet.iterator();
9096            for (j = 100; iterator.hasNext(); j++) {
9097                key = (String) iterator.next();
9098                assertEquals(new Integer(j).toString(), key);
9099            }
9100            assertEquals(i + 1, j);
9101        }
9102
9103        endKey = new Integer(109).toString();
9104        headSet = keySet.headSet(endKey);
9105        iterator = headSet.iterator();
9106        for (index = 100; iterator.hasNext(); index++) {
9107            key = (String) iterator.next();
9108            assertEquals(new Integer(index).toString(), key);
9109        }
9110        assertEquals(109, index);
9111
9112        headSet = keySet.headSet(endKey, false);
9113        iterator = headSet.iterator();
9114        for (index = 100; iterator.hasNext(); index++) {
9115            key = (String) iterator.next();
9116            assertEquals(new Integer(index).toString(), key);
9117        }
9118        assertEquals(109, index);
9119
9120        try {
9121            keySet.headSet(endKey, true);
9122            fail("should throw IllegalArgumentException");
9123        } catch (IllegalArgumentException e) {
9124            // Expected
9125        }
9126
9127        endKey = new Integer(110).toString();
9128        try {
9129            keySet.headSet(endKey);
9130            fail("should throw IllegalArgumentException");
9131        } catch (IllegalArgumentException e) {
9132            // Expected
9133        }
9134
9135        try {
9136            keySet.headSet(endKey, false);
9137            fail("should throw IllegalArgumentException");
9138        } catch (IllegalArgumentException e) {
9139            // Expected
9140        }
9141
9142        try {
9143            keySet.headSet(endKey, true);
9144            fail("should throw IllegalArgumentException");
9145        } catch (IllegalArgumentException e) {
9146            // Expected
9147        }
9148
9149        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
9150                .navigableKeySet();
9151        endKey = new Integer(99).toString();
9152        try {
9153            keySet.headSet(endKey);
9154            fail("should throw IllegalArgumentException");
9155        } catch (IllegalArgumentException e) {
9156            // Expected
9157        }
9158        try {
9159            keySet.headSet(endKey, false);
9160            fail("should throw IllegalArgumentException");
9161        } catch (IllegalArgumentException e) {
9162            // Expected
9163        }
9164        try {
9165            keySet.headSet(endKey, true);
9166            fail("should throw IllegalArgumentException");
9167        } catch (IllegalArgumentException e) {
9168            // Expected
9169        }
9170
9171        endKey = new Integer(100).toString();
9172        assertEquals(0, keySet.headSet(endKey).size());
9173        assertEquals(0, keySet.headSet(endKey, false).size());
9174        assertEquals(1, keySet.headSet(endKey, true).size());
9175
9176        endKey = new Integer(101).toString();
9177        headSet = keySet.headSet(endKey);
9178        iterator = headSet.iterator();
9179        for (index = 100; iterator.hasNext(); index++) {
9180            key = (String) iterator.next();
9181            assertEquals(new Integer(index).toString(), key);
9182        }
9183        assertEquals(101, index);
9184
9185        headSet = keySet.headSet(endKey, false);
9186        iterator = headSet.iterator();
9187        for (index = 100; iterator.hasNext(); index++) {
9188            key = (String) iterator.next();
9189            assertEquals(new Integer(index).toString(), key);
9190        }
9191        assertEquals(101, index);
9192
9193        headSet = keySet.headSet(endKey, true);
9194        iterator = headSet.iterator();
9195        for (index = 100; iterator.hasNext(); index++) {
9196            key = (String) iterator.next();
9197            assertEquals(new Integer(index).toString(), key);
9198        }
9199        assertEquals(102, index);
9200
9201        for (int i = 102; i < 109; i++) {
9202            endKey = new Integer(i).toString();
9203
9204            headSet = keySet.headSet(endKey);
9205            iterator = headSet.iterator();
9206            int j;
9207            for (j = 100; iterator.hasNext(); j++) {
9208                key = (String) iterator.next();
9209                assertEquals(new Integer(j).toString(), key);
9210            }
9211            assertEquals(i, j);
9212
9213            headSet = keySet.headSet(endKey, false);
9214            iterator = headSet.iterator();
9215            for (j = 100; iterator.hasNext(); j++) {
9216                key = (String) iterator.next();
9217                assertEquals(new Integer(j).toString(), key);
9218            }
9219            assertEquals(i, j);
9220
9221            headSet = keySet.headSet(endKey, true);
9222            iterator = headSet.iterator();
9223            for (j = 100; iterator.hasNext(); j++) {
9224                key = (String) iterator.next();
9225                assertEquals(new Integer(j).toString(), key);
9226            }
9227            assertEquals(i + 1, j);
9228        }
9229
9230        endKey = new Integer(109).toString();
9231        headSet = keySet.headSet(endKey);
9232        iterator = headSet.iterator();
9233        for (index = 100; iterator.hasNext(); index++) {
9234            key = (String) iterator.next();
9235            assertEquals(new Integer(index).toString(), key);
9236        }
9237        assertEquals(109, index);
9238
9239        headSet = keySet.headSet(endKey, false);
9240        iterator = headSet.iterator();
9241        for (index = 100; iterator.hasNext(); index++) {
9242            key = (String) iterator.next();
9243            assertEquals(new Integer(index).toString(), key);
9244        }
9245        assertEquals(109, index);
9246
9247        headSet = keySet.headSet(endKey, true);
9248        iterator = headSet.iterator();
9249        for (index = 100; iterator.hasNext(); index++) {
9250            key = (String) iterator.next();
9251            assertEquals(new Integer(index).toString(), key);
9252        }
9253        assertEquals(110, index);
9254
9255        endKey = new Integer(110).toString();
9256        try {
9257            keySet.headSet(endKey);
9258            fail("should throw IllegalArgumentException");
9259        } catch (IllegalArgumentException e) {
9260            // Expected
9261        }
9262        try {
9263            keySet.headSet(endKey, false);
9264            fail("should throw IllegalArgumentException");
9265        } catch (IllegalArgumentException e) {
9266            // Expected
9267        }
9268        try {
9269            keySet.headSet(endKey, true);
9270            fail("should throw IllegalArgumentException");
9271        } catch (IllegalArgumentException e) {
9272            // Expected
9273        }
9274
9275        key = new Integer(1).toString();
9276        keySet = tm.headMap(key, true).navigableKeySet();
9277        iterator = keySet.iterator();
9278        iterator.next();
9279        endKey = (String) iterator.next();
9280        headSet = keySet.headSet(endKey, false);
9281        assertEquals(1, headSet.size());
9282        headSetIterator = headSet.iterator();
9283        assertEquals(new Integer(0).toString(), headSetIterator.next());
9284        assertFalse(headSetIterator.hasNext());
9285        try {
9286            headSetIterator.next();
9287            fail("should throw NoSuchElementException");
9288        } catch (NoSuchElementException e) {
9289            // Expected
9290        }
9291        try {
9292            keySet.headSet(null, false);
9293            fail("should throw NPE");
9294        } catch (NullPointerException e) {
9295            // Expected
9296        }
9297
9298        headSet = keySet.headSet(endKey, true);
9299        assertEquals(2, headSet.size());
9300        headSetIterator = headSet.iterator();
9301        assertEquals(new Integer(0).toString(), headSetIterator.next());
9302        assertEquals(new Integer(1).toString(), headSetIterator.next());
9303        assertFalse(headSetIterator.hasNext());
9304        try {
9305            headSetIterator.next();
9306            fail("should throw NoSuchElementException");
9307        } catch (NoSuchElementException e) {
9308            // Expected
9309        }
9310        try {
9311            keySet.headSet(null, false);
9312            fail("should throw NPE");
9313        } catch (NullPointerException e) {
9314            // Expected
9315        }
9316
9317    }
9318
9319    public void test_AscendingSubMapKeySet_remove() {
9320        TreeMap tm_rm = new TreeMap(tm);
9321        SortedMap subMap_startExcluded_endExcluded_rm = tm_rm.subMap(
9322                objArray[100].toString(), false, objArray[109].toString(),
9323                false);
9324        assertNull(subMap_startExcluded_endExcluded_rm.remove("0"));
9325        try {
9326            subMap_startExcluded_endExcluded_rm.remove(null);
9327            fail("should throw NPE");
9328        } catch (Exception e) {
9329            // Expected
9330        }
9331        for (int i = 101; i < 108; i++) {
9332            assertNotNull(subMap_startExcluded_endExcluded_rm
9333                    .remove(new Integer(i).toString()));
9334        }
9335    }
9336
9337    public void test_AscendingSubMapKeySet_tailSet() {
9338        NavigableSet keySet;
9339        SortedSet tailSet;
9340        String startKey, key;
9341        Iterator iterator;
9342
9343        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
9344        startKey = new Integer(99).toString();
9345        try {
9346            keySet.tailSet(startKey);
9347            fail("should throw IllegalArgumentException");
9348        } catch (IllegalArgumentException e) {
9349            // Expected
9350        }
9351
9352        try {
9353            keySet.tailSet(startKey, true);
9354            fail("should throw IllegalArgumentException");
9355        } catch (IllegalArgumentException e) {
9356            // Expected
9357        }
9358
9359        try {
9360            keySet.tailSet(startKey, false);
9361            fail("should throw IllegalArgumentException");
9362        } catch (IllegalArgumentException e) {
9363            // Expected
9364        }
9365
9366        startKey = new Integer(100).toString();
9367        try {
9368            keySet.tailSet(startKey);
9369            fail("should throw IllegalArgumentException");
9370        } catch (IllegalArgumentException e) {
9371            // Expected
9372        }
9373        try {
9374            keySet.tailSet(startKey, true);
9375            fail("should throw IllegalArgumentException");
9376        } catch (IllegalArgumentException e) {
9377            // Expected
9378        }
9379        int index;
9380        tailSet = keySet.tailSet(startKey, false);
9381        iterator = tailSet.iterator();
9382        for (index = 101; index < 109; index++) {
9383            key = (String) iterator.next();
9384            assertEquals(new Integer(index).toString(), key);
9385        }
9386
9387        startKey = new Integer(101).toString();
9388        tailSet = keySet.tailSet(startKey);
9389        iterator = tailSet.iterator();
9390        for (index = 101; iterator.hasNext(); index++) {
9391            key = (String) iterator.next();
9392            assertEquals(new Integer(index).toString(), key);
9393        }
9394        assertEquals(109, index);
9395
9396        tailSet = keySet.tailSet(startKey, true);
9397        iterator = tailSet.iterator();
9398        for (index = 101; iterator.hasNext(); index++) {
9399            key = (String) iterator.next();
9400            assertEquals(new Integer(index).toString(), key);
9401        }
9402        assertEquals(109, index);
9403
9404        tailSet = keySet.tailSet(startKey, false);
9405        iterator = tailSet.iterator();
9406        for (index = 101; iterator.hasNext(); index++) {
9407            key = (String) iterator.next();
9408            assertEquals(new Integer(index + 1).toString(), key);
9409        }
9410        assertEquals(108, index);
9411
9412        for (int i = 102; i < 109; i++) {
9413            startKey = new Integer(i).toString();
9414
9415            tailSet = keySet.tailSet(startKey);
9416            iterator = tailSet.iterator();
9417            int j;
9418            for (j = i; iterator.hasNext(); j++) {
9419                key = (String) iterator.next();
9420                assertEquals(new Integer(j).toString(), key);
9421            }
9422            assertEquals(109, j);
9423
9424            tailSet = keySet.tailSet(startKey, true);
9425            iterator = tailSet.iterator();
9426            for (j = i; iterator.hasNext(); j++) {
9427                key = (String) iterator.next();
9428                assertEquals(new Integer(j).toString(), key);
9429            }
9430            assertEquals(109, j);
9431
9432            tailSet = keySet.tailSet(startKey, false);
9433            iterator = tailSet.iterator();
9434            for (j = i; iterator.hasNext(); j++) {
9435                key = (String) iterator.next();
9436                assertEquals(new Integer(j + 1).toString(), key);
9437            }
9438            assertEquals(108, j);
9439        }
9440
9441        startKey = new Integer(109).toString();
9442        try {
9443            keySet.tailSet(startKey);
9444            fail("should throw IllegalArgumentException");
9445        } catch (IllegalArgumentException e) {
9446            // Expected
9447        }
9448        try {
9449            keySet.tailSet(startKey, true);
9450            fail("should throw IllegalArgumentException");
9451        } catch (IllegalArgumentException e) {
9452            // Expected
9453        }
9454        try {
9455            keySet.tailSet(startKey, false);
9456            fail("should throw IllegalArgumentException");
9457        } catch (IllegalArgumentException e) {
9458            // Expected
9459        }
9460
9461        startKey = new Integer(110).toString();
9462        try {
9463            keySet.tailSet(startKey);
9464            fail("should throw IllegalArgumentException");
9465        } catch (IllegalArgumentException e) {
9466            // Expected
9467        }
9468        try {
9469            keySet.tailSet(startKey, true);
9470            fail("should throw IllegalArgumentException");
9471        } catch (IllegalArgumentException e) {
9472            // Expected
9473        }
9474        try {
9475            keySet.tailSet(startKey, false);
9476            fail("should throw IllegalArgumentException");
9477        } catch (IllegalArgumentException e) {
9478            // Expected
9479        }
9480
9481        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
9482        startKey = new Integer(99).toString();
9483        try {
9484            keySet.tailSet(startKey);
9485            fail("should throw IllegalArgumentException");
9486        } catch (IllegalArgumentException e) {
9487            // Expected
9488        }
9489        try {
9490            keySet.tailSet(startKey, true);
9491            fail("should throw IllegalArgumentException");
9492        } catch (IllegalArgumentException e) {
9493            // Expected
9494        }
9495        try {
9496            keySet.tailSet(startKey, false);
9497            fail("should throw IllegalArgumentException");
9498        } catch (IllegalArgumentException e) {
9499            // Expected
9500        }
9501
9502        startKey = new Integer(100).toString();
9503        try {
9504            keySet.tailSet(startKey);
9505            fail("should throw IllegalArgumentException");
9506        } catch (IllegalArgumentException e) {
9507            // Expected
9508        }
9509        try {
9510            keySet.tailSet(startKey, true);
9511            fail("should throw IllegalArgumentException");
9512        } catch (IllegalArgumentException e) {
9513            // Expected
9514        }
9515
9516        tailSet = keySet.tailSet(startKey, false);
9517        iterator = tailSet.iterator();
9518        for (index = 100; iterator.hasNext(); index++) {
9519            key = (String) iterator.next();
9520            assertEquals(new Integer(index + 1).toString(), key);
9521        }
9522        assertEquals(109, index);
9523
9524        for (int i = 102; i < 109; i++) {
9525            startKey = new Integer(i).toString();
9526
9527            tailSet = keySet.tailSet(startKey);
9528            iterator = tailSet.iterator();
9529            int j;
9530            for (j = i; iterator.hasNext(); j++) {
9531                key = (String) iterator.next();
9532                assertEquals(new Integer(j).toString(), key);
9533            }
9534            assertEquals(110, j);
9535
9536            tailSet = keySet.tailSet(startKey, true);
9537            iterator = tailSet.iterator();
9538            for (j = i; iterator.hasNext(); j++) {
9539                key = (String) iterator.next();
9540                assertEquals(new Integer(j).toString(), key);
9541            }
9542            assertEquals(110, j);
9543
9544            tailSet = keySet.tailSet(startKey, false);
9545            iterator = tailSet.iterator();
9546            for (j = i; iterator.hasNext(); j++) {
9547                key = (String) iterator.next();
9548                assertEquals(new Integer(j + 1).toString(), key);
9549            }
9550            assertEquals(109, j);
9551        }
9552
9553        startKey = new Integer(109).toString();
9554        tailSet = keySet.tailSet(startKey);
9555        iterator = tailSet.iterator();
9556        for (index = 109; iterator.hasNext(); index++) {
9557            key = (String) iterator.next();
9558            assertEquals(new Integer(index).toString(), key);
9559        }
9560        assertEquals(110, index);
9561
9562        tailSet = keySet.tailSet(startKey, true);
9563        iterator = tailSet.iterator();
9564        for (index = 109; iterator.hasNext(); index++) {
9565            key = (String) iterator.next();
9566            assertEquals(new Integer(index).toString(), key);
9567        }
9568        assertEquals(110, index);
9569
9570        tailSet = keySet.tailSet(startKey, false);
9571        iterator = tailSet.iterator();
9572        for (index = 109; iterator.hasNext(); index++) {
9573            key = (String) iterator.next();
9574            assertEquals(new Integer(index + 1).toString(), key);
9575        }
9576        assertEquals(109, index);
9577
9578        startKey = new Integer(110).toString();
9579        try {
9580            keySet.tailSet(startKey);
9581            fail("should throw IllegalArgumentException");
9582        } catch (IllegalArgumentException e) {
9583            // Expected
9584        }
9585        try {
9586            keySet.tailSet(startKey, true);
9587            fail("should throw IllegalArgumentException");
9588        } catch (IllegalArgumentException e) {
9589            // Expected
9590        }
9591        try {
9592            keySet.tailSet(startKey, false);
9593            fail("should throw IllegalArgumentException");
9594        } catch (IllegalArgumentException e) {
9595            // Expected
9596        }
9597
9598        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
9599        startKey = new Integer(99).toString();
9600        try {
9601            keySet.tailSet(startKey);
9602            fail("should throw IllegalArgumentException");
9603        } catch (IllegalArgumentException e) {
9604            // Expected
9605        }
9606        try {
9607            keySet.tailSet(startKey, true);
9608            fail("should throw IllegalArgumentException");
9609        } catch (IllegalArgumentException e) {
9610            // Expected
9611        }
9612        try {
9613            keySet.tailSet(startKey, false);
9614            fail("should throw IllegalArgumentException");
9615        } catch (IllegalArgumentException e) {
9616            // Expected
9617        }
9618
9619        startKey = new Integer(100).toString();
9620        tailSet = keySet.tailSet(startKey);
9621        iterator = tailSet.iterator();
9622        for (index = 100; iterator.hasNext(); index++) {
9623            key = (String) iterator.next();
9624            assertEquals(new Integer(index).toString(), key);
9625        }
9626        assertEquals(109, index);
9627
9628        tailSet = keySet.tailSet(startKey, true);
9629        iterator = tailSet.iterator();
9630        for (index = 100; iterator.hasNext(); index++) {
9631            key = (String) iterator.next();
9632            assertEquals(new Integer(index).toString(), key);
9633        }
9634        assertEquals(109, index);
9635
9636        tailSet = keySet.tailSet(startKey, false);
9637        iterator = tailSet.iterator();
9638        for (index = 100; iterator.hasNext(); index++) {
9639            key = (String) iterator.next();
9640            assertEquals(new Integer(index + 1).toString(), key);
9641        }
9642        assertEquals(108, index);
9643
9644        startKey = new Integer(101).toString();
9645        tailSet = keySet.tailSet(startKey);
9646        iterator = tailSet.iterator();
9647        for (index = 101; iterator.hasNext(); index++) {
9648            key = (String) iterator.next();
9649            assertEquals(new Integer(index).toString(), key);
9650        }
9651        assertEquals(109, index);
9652
9653        tailSet = keySet.tailSet(startKey, true);
9654        iterator = tailSet.iterator();
9655        for (index = 101; iterator.hasNext(); index++) {
9656            key = (String) iterator.next();
9657            assertEquals(new Integer(index).toString(), key);
9658        }
9659        assertEquals(109, index);
9660
9661        tailSet = keySet.tailSet(startKey, false);
9662        iterator = tailSet.iterator();
9663        for (index = 101; iterator.hasNext(); index++) {
9664            key = (String) iterator.next();
9665            assertEquals(new Integer(index + 1).toString(), key);
9666        }
9667        assertEquals(108, index);
9668
9669        for (int i = 102; i < 109; i++) {
9670            startKey = new Integer(i).toString();
9671
9672            tailSet = keySet.tailSet(startKey);
9673            iterator = tailSet.iterator();
9674            int j;
9675            for (j = i; iterator.hasNext(); j++) {
9676                key = (String) iterator.next();
9677                assertEquals(new Integer(j).toString(), key);
9678            }
9679            assertEquals(109, j);
9680
9681            tailSet = keySet.tailSet(startKey, true);
9682            iterator = tailSet.iterator();
9683            for (j = i; iterator.hasNext(); j++) {
9684                key = (String) iterator.next();
9685                assertEquals(new Integer(j).toString(), key);
9686            }
9687            assertEquals(109, j);
9688
9689            tailSet = keySet.tailSet(startKey, false);
9690            iterator = tailSet.iterator();
9691            for (j = i; iterator.hasNext(); j++) {
9692                key = (String) iterator.next();
9693                assertEquals(new Integer(j + 1).toString(), key);
9694            }
9695            assertEquals(108, j);
9696        }
9697
9698        startKey = new Integer(109).toString();
9699        try {
9700            keySet.tailSet(startKey);
9701            fail("should throw IllegalArgumentException");
9702        } catch (IllegalArgumentException e) {
9703            // Expected
9704        }
9705        try {
9706            keySet.tailSet(startKey, true);
9707            fail("should throw IllegalArgumentException");
9708        } catch (IllegalArgumentException e) {
9709            // Expected
9710        }
9711        try {
9712            keySet.tailSet(startKey, false);
9713            fail("should throw IllegalArgumentException");
9714        } catch (IllegalArgumentException e) {
9715            // Expected
9716        }
9717
9718        startKey = new Integer(110).toString();
9719        try {
9720            keySet.tailSet(startKey);
9721            fail("should throw IllegalArgumentException");
9722        } catch (IllegalArgumentException e) {
9723            // Expected
9724        }
9725        try {
9726            keySet.tailSet(startKey, true);
9727            fail("should throw IllegalArgumentException");
9728        } catch (IllegalArgumentException e) {
9729            // Expected
9730        }
9731        try {
9732            keySet.tailSet(startKey, false);
9733            fail("should throw IllegalArgumentException");
9734        } catch (IllegalArgumentException e) {
9735            // Expected
9736        }
9737
9738        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
9739        startKey = new Integer(99).toString();
9740        try {
9741            keySet.tailSet(startKey);
9742            fail("should throw IllegalArgumentException");
9743        } catch (IllegalArgumentException e) {
9744            // Expected
9745        }
9746        try {
9747            keySet.tailSet(startKey, true);
9748            fail("should throw IllegalArgumentException");
9749        } catch (IllegalArgumentException e) {
9750            // Expected
9751        }
9752        try {
9753            keySet.tailSet(startKey, false);
9754            fail("should throw IllegalArgumentException");
9755        } catch (IllegalArgumentException e) {
9756            // Expected
9757        }
9758        startKey = new Integer(100).toString();
9759        tailSet = keySet.tailSet(startKey);
9760        iterator = tailSet.iterator();
9761        for (index = 100; iterator.hasNext(); index++) {
9762            key = (String) iterator.next();
9763            assertEquals(new Integer(index).toString(), key);
9764        }
9765        assertEquals(110, index);
9766
9767        tailSet = keySet.tailSet(startKey, true);
9768        iterator = tailSet.iterator();
9769        for (index = 100; iterator.hasNext(); index++) {
9770            key = (String) iterator.next();
9771            assertEquals(new Integer(index).toString(), key);
9772        }
9773        assertEquals(110, index);
9774
9775        tailSet = keySet.tailSet(startKey, false);
9776        iterator = tailSet.iterator();
9777        for (index = 100; iterator.hasNext(); index++) {
9778            key = (String) iterator.next();
9779            assertEquals(new Integer(index + 1).toString(), key);
9780        }
9781        assertEquals(109, index);
9782
9783        startKey = new Integer(101).toString();
9784        tailSet = keySet.tailSet(startKey);
9785        iterator = tailSet.iterator();
9786        for (index = 101; iterator.hasNext(); index++) {
9787            key = (String) iterator.next();
9788            assertEquals(new Integer(index).toString(), key);
9789        }
9790        assertEquals(110, index);
9791
9792        tailSet = keySet.tailSet(startKey, true);
9793        iterator = tailSet.iterator();
9794        for (index = 101; iterator.hasNext(); index++) {
9795            key = (String) iterator.next();
9796            assertEquals(new Integer(index).toString(), key);
9797        }
9798        assertEquals(110, index);
9799
9800        tailSet = keySet.tailSet(startKey, false);
9801        iterator = tailSet.iterator();
9802        for (index = 101; iterator.hasNext(); index++) {
9803            key = (String) iterator.next();
9804            assertEquals(new Integer(index + 1).toString(), key);
9805        }
9806        assertEquals(109, index);
9807
9808        for (int i = 102; i < 109; i++) {
9809            startKey = new Integer(i).toString();
9810
9811            tailSet = keySet.tailSet(startKey);
9812            iterator = tailSet.iterator();
9813            int j;
9814            for (j = i; iterator.hasNext(); j++) {
9815                key = (String) iterator.next();
9816                assertEquals(new Integer(j).toString(), key);
9817            }
9818            assertEquals(110, j);
9819
9820            tailSet = keySet.tailSet(startKey, true);
9821            iterator = tailSet.iterator();
9822            for (j = i; iterator.hasNext(); j++) {
9823                key = (String) iterator.next();
9824                assertEquals(new Integer(j).toString(), key);
9825            }
9826            assertEquals(110, j);
9827
9828            tailSet = keySet.tailSet(startKey, false);
9829            iterator = tailSet.iterator();
9830            for (j = i; iterator.hasNext(); j++) {
9831                key = (String) iterator.next();
9832                assertEquals(new Integer(j + 1).toString(), key);
9833            }
9834            assertEquals(109, j);
9835        }
9836
9837        startKey = new Integer(109).toString();
9838        tailSet = keySet.tailSet(startKey);
9839        iterator = tailSet.iterator();
9840        for (index = 109; iterator.hasNext(); index++) {
9841            key = (String) iterator.next();
9842            assertEquals(new Integer(index).toString(), key);
9843        }
9844        assertEquals(110, index);
9845
9846        tailSet = keySet.tailSet(startKey, true);
9847        iterator = tailSet.iterator();
9848        for (index = 109; iterator.hasNext(); index++) {
9849            key = (String) iterator.next();
9850            assertEquals(new Integer(index).toString(), key);
9851        }
9852        assertEquals(110, index);
9853
9854        tailSet = keySet.tailSet(startKey, false);
9855        iterator = tailSet.iterator();
9856        for (index = 109; iterator.hasNext(); index++) {
9857            key = (String) iterator.next();
9858            assertEquals(new Integer(index + 1).toString(), key);
9859        }
9860        assertEquals(109, index);
9861
9862        startKey = new Integer(110).toString();
9863        try {
9864            keySet.tailSet(startKey);
9865            fail("should throw IllegalArgumentException");
9866        } catch (IllegalArgumentException e) {
9867            // Expected
9868        }
9869        try {
9870            keySet.tailSet(startKey, true);
9871            fail("should throw IllegalArgumentException");
9872        } catch (IllegalArgumentException e) {
9873            // Expected
9874        }
9875        try {
9876            keySet.tailSet(startKey, false);
9877            fail("should throw IllegalArgumentException");
9878        } catch (IllegalArgumentException e) {
9879            // Expected
9880        }
9881
9882        String endKey = new Integer(1).toString();
9883        keySet = tm.headMap(endKey, true).navigableKeySet();
9884        iterator = keySet.iterator();
9885        iterator.next();
9886        startKey = (String) iterator.next();
9887        tailSet = keySet.tailSet(startKey);
9888        assertEquals(1, tailSet.size());
9889        Iterator tailSetIterator = tailSet.iterator();
9890        assertEquals(endKey, tailSetIterator.next());
9891        try {
9892            tailSetIterator.next();
9893            fail("should throw NoSuchElementException");
9894        } catch (NoSuchElementException e) {
9895            // Expected
9896        }
9897        try {
9898            keySet.tailSet(null);
9899            fail("should throw NPE");
9900        } catch (NullPointerException e) {
9901            // Expected
9902        }
9903
9904        tailSet = keySet.tailSet(startKey, true);
9905        assertEquals(1, tailSet.size());
9906        tailSetIterator = tailSet.iterator();
9907        assertEquals(endKey, tailSetIterator.next());
9908
9909        tailSet = keySet.tailSet(startKey, false);
9910        assertEquals(0, tailSet.size());
9911        tailSetIterator = tailSet.iterator();
9912        try {
9913            tailSetIterator.next();
9914            fail("should throw NoSuchElementException");
9915        } catch (NoSuchElementException e) {
9916            // Expected
9917        }
9918        try {
9919            keySet.tailSet(null, false);
9920            fail("should throw NPE");
9921        } catch (NullPointerException e) {
9922            // Expected
9923        }
9924        try {
9925            keySet.tailSet(null, true);
9926            fail("should throw NPE");
9927        } catch (NullPointerException e) {
9928            // Expected
9929        }
9930
9931        // With Comparator
9932        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
9933                .navigableKeySet();
9934        startKey = new Integer(99).toString();
9935        try {
9936            keySet.tailSet(startKey);
9937            fail("should throw IllegalArgumentException");
9938        } catch (IllegalArgumentException e) {
9939            // Expected
9940        }
9941
9942        try {
9943            keySet.tailSet(startKey, true);
9944            fail("should throw IllegalArgumentException");
9945        } catch (IllegalArgumentException e) {
9946            // Expected
9947        }
9948
9949        try {
9950            keySet.tailSet(startKey, false);
9951            fail("should throw IllegalArgumentException");
9952        } catch (IllegalArgumentException e) {
9953            // Expected
9954        }
9955
9956        startKey = new Integer(100).toString();
9957        try {
9958            keySet.tailSet(startKey);
9959            fail("should throw IllegalArgumentException");
9960        } catch (IllegalArgumentException e) {
9961            // Expected
9962        }
9963        try {
9964            keySet.tailSet(startKey, true);
9965            fail("should throw IllegalArgumentException");
9966        } catch (IllegalArgumentException e) {
9967            // Expected
9968        }
9969        tailSet = keySet.tailSet(startKey, false);
9970        iterator = tailSet.iterator();
9971        for (index = 101; index < 109; index++) {
9972            key = (String) iterator.next();
9973            assertEquals(new Integer(index).toString(), key);
9974        }
9975
9976        startKey = new Integer(101).toString();
9977        tailSet = keySet.tailSet(startKey);
9978        iterator = tailSet.iterator();
9979        for (index = 101; iterator.hasNext(); index++) {
9980            key = (String) iterator.next();
9981            assertEquals(new Integer(index).toString(), key);
9982        }
9983        assertEquals(109, index);
9984
9985        tailSet = keySet.tailSet(startKey, true);
9986        iterator = tailSet.iterator();
9987        for (index = 101; iterator.hasNext(); index++) {
9988            key = (String) iterator.next();
9989            assertEquals(new Integer(index).toString(), key);
9990        }
9991        assertEquals(109, index);
9992
9993        tailSet = keySet.tailSet(startKey, false);
9994        iterator = tailSet.iterator();
9995        for (index = 101; iterator.hasNext(); index++) {
9996            key = (String) iterator.next();
9997            assertEquals(new Integer(index + 1).toString(), key);
9998        }
9999        assertEquals(108, index);
10000
10001        for (int i = 102; i < 109; i++) {
10002            startKey = new Integer(i).toString();
10003
10004            tailSet = keySet.tailSet(startKey);
10005            iterator = tailSet.iterator();
10006            int j;
10007            for (j = i; iterator.hasNext(); j++) {
10008                key = (String) iterator.next();
10009                assertEquals(new Integer(j).toString(), key);
10010            }
10011            assertEquals(109, j);
10012
10013            tailSet = keySet.tailSet(startKey, true);
10014            iterator = tailSet.iterator();
10015            for (j = i; iterator.hasNext(); j++) {
10016                key = (String) iterator.next();
10017                assertEquals(new Integer(j).toString(), key);
10018            }
10019            assertEquals(109, j);
10020
10021            tailSet = keySet.tailSet(startKey, false);
10022            iterator = tailSet.iterator();
10023            for (j = i; iterator.hasNext(); j++) {
10024                key = (String) iterator.next();
10025                assertEquals(new Integer(j + 1).toString(), key);
10026            }
10027            assertEquals(108, j);
10028        }
10029
10030        startKey = new Integer(109).toString();
10031        try {
10032            keySet.tailSet(startKey);
10033            fail("should throw IllegalArgumentException");
10034        } catch (IllegalArgumentException e) {
10035            // Expected
10036        }
10037        try {
10038            keySet.tailSet(startKey, true);
10039            fail("should throw IllegalArgumentException");
10040        } catch (IllegalArgumentException e) {
10041            // Expected
10042        }
10043        try {
10044            keySet.tailSet(startKey, false);
10045            fail("should throw IllegalArgumentException");
10046        } catch (IllegalArgumentException e) {
10047            // Expected
10048        }
10049
10050        startKey = new Integer(110).toString();
10051        try {
10052            keySet.tailSet(startKey);
10053            fail("should throw IllegalArgumentException");
10054        } catch (IllegalArgumentException e) {
10055            // Expected
10056        }
10057        try {
10058            keySet.tailSet(startKey, true);
10059            fail("should throw IllegalArgumentException");
10060        } catch (IllegalArgumentException e) {
10061            // Expected
10062        }
10063        try {
10064            keySet.tailSet(startKey, false);
10065            fail("should throw IllegalArgumentException");
10066        } catch (IllegalArgumentException e) {
10067            // Expected
10068        }
10069
10070        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10071        startKey = new Integer(99).toString();
10072        try {
10073            keySet.tailSet(startKey);
10074            fail("should throw IllegalArgumentException");
10075        } catch (IllegalArgumentException e) {
10076            // Expected
10077        }
10078        try {
10079            keySet.tailSet(startKey, true);
10080            fail("should throw IllegalArgumentException");
10081        } catch (IllegalArgumentException e) {
10082            // Expected
10083        }
10084        try {
10085            keySet.tailSet(startKey, false);
10086            fail("should throw IllegalArgumentException");
10087        } catch (IllegalArgumentException e) {
10088            // Expected
10089        }
10090
10091        startKey = new Integer(100).toString();
10092        try {
10093            keySet.tailSet(startKey);
10094            fail("should throw IllegalArgumentException");
10095        } catch (IllegalArgumentException e) {
10096            // Expected
10097        }
10098        try {
10099            keySet.tailSet(startKey, true);
10100            fail("should throw IllegalArgumentException");
10101        } catch (IllegalArgumentException e) {
10102            // Expected
10103        }
10104
10105        tailSet = keySet.tailSet(startKey, false);
10106        iterator = tailSet.iterator();
10107        for (index = 100; iterator.hasNext(); index++) {
10108            key = (String) iterator.next();
10109            assertEquals(new Integer(index + 1).toString(), key);
10110        }
10111        assertEquals(109, index);
10112
10113        for (int i = 102; i < 109; i++) {
10114            startKey = new Integer(i).toString();
10115
10116            tailSet = keySet.tailSet(startKey);
10117            iterator = tailSet.iterator();
10118            int j;
10119            for (j = i; iterator.hasNext(); j++) {
10120                key = (String) iterator.next();
10121                assertEquals(new Integer(j).toString(), key);
10122            }
10123            assertEquals(110, j);
10124
10125            tailSet = keySet.tailSet(startKey, true);
10126            iterator = tailSet.iterator();
10127            for (j = i; iterator.hasNext(); j++) {
10128                key = (String) iterator.next();
10129                assertEquals(new Integer(j).toString(), key);
10130            }
10131            assertEquals(110, j);
10132
10133            tailSet = keySet.tailSet(startKey, false);
10134            iterator = tailSet.iterator();
10135            for (j = i; iterator.hasNext(); j++) {
10136                key = (String) iterator.next();
10137                assertEquals(new Integer(j + 1).toString(), key);
10138            }
10139            assertEquals(109, j);
10140        }
10141
10142        startKey = new Integer(109).toString();
10143        tailSet = keySet.tailSet(startKey);
10144        iterator = tailSet.iterator();
10145        for (index = 109; iterator.hasNext(); index++) {
10146            key = (String) iterator.next();
10147            assertEquals(new Integer(index).toString(), key);
10148        }
10149        assertEquals(110, index);
10150
10151        tailSet = keySet.tailSet(startKey, true);
10152        iterator = tailSet.iterator();
10153        for (index = 109; iterator.hasNext(); index++) {
10154            key = (String) iterator.next();
10155            assertEquals(new Integer(index).toString(), key);
10156        }
10157        assertEquals(110, index);
10158
10159        tailSet = keySet.tailSet(startKey, false);
10160        iterator = tailSet.iterator();
10161        for (index = 109; iterator.hasNext(); index++) {
10162            key = (String) iterator.next();
10163            assertEquals(new Integer(index + 1).toString(), key);
10164        }
10165        assertEquals(109, index);
10166
10167        startKey = new Integer(110).toString();
10168        try {
10169            keySet.tailSet(startKey);
10170            fail("should throw IllegalArgumentException");
10171        } catch (IllegalArgumentException e) {
10172            // Expected
10173        }
10174        try {
10175            keySet.tailSet(startKey, true);
10176            fail("should throw IllegalArgumentException");
10177        } catch (IllegalArgumentException e) {
10178            // Expected
10179        }
10180        try {
10181            keySet.tailSet(startKey, false);
10182            fail("should throw IllegalArgumentException");
10183        } catch (IllegalArgumentException e) {
10184            // Expected
10185        }
10186    }
10187
10188    public void test_AscendingSubMapKeySet_subSet() {
10189        NavigableSet keySet;
10190        SortedSet subSet;
10191        String startKey, endKey, key;
10192        Iterator startIterator, endIterator, subSetIterator;
10193
10194        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10195        startIterator = keySet.iterator();
10196        while (startIterator.hasNext()) {
10197            startKey = (String) startIterator.next();
10198            endIterator = keySet.iterator();
10199            while (endIterator.hasNext()) {
10200                endKey = (String) endIterator.next();
10201                int startIndex = Integer.valueOf(startKey);
10202                int endIndex = Integer.valueOf(endKey);
10203                if (startIndex > endIndex) {
10204                    try {
10205                        keySet.subSet(startKey, endKey);
10206                        fail("should throw IllegalArgumentException");
10207                    } catch (IllegalArgumentException e) {
10208                        // Expected
10209                    }
10210
10211                    try {
10212                        keySet.subSet(startKey, false, endKey, false);
10213                        fail("shoudl throw IllegalArgumentException");
10214                    } catch (IllegalArgumentException e) {
10215                        // Expected
10216                    }
10217
10218                    try {
10219                        keySet.subSet(startKey, false, endKey, true);
10220                        fail("shoudl throw IllegalArgumentException");
10221                    } catch (IllegalArgumentException e) {
10222                        // Expected
10223                    }
10224
10225                    try {
10226                        keySet.subSet(startKey, true, endKey, false);
10227                        fail("shoudl throw IllegalArgumentException");
10228                    } catch (IllegalArgumentException e) {
10229                        // Expected
10230                    }
10231
10232                    try {
10233                        keySet.subSet(startKey, true, endKey, true);
10234                        fail("shoudl throw IllegalArgumentException");
10235                    } catch (IllegalArgumentException e) {
10236                        // Expected
10237                    }
10238                } else {
10239                    subSet = keySet.subSet(startKey, endKey);
10240                    subSetIterator = subSet.iterator();
10241                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10242                        assertEquals(new Integer(index).toString(),
10243                                subSetIterator.next());
10244                    }
10245
10246                    subSet = keySet.subSet(startKey, false, endKey, false);
10247                    subSetIterator = subSet.iterator();
10248                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10249                        assertEquals(new Integer(index).toString(),
10250                                subSetIterator.next());
10251                    }
10252
10253                    subSet = keySet.subSet(startKey, false, endKey, true);
10254                    subSetIterator = subSet.iterator();
10255                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10256                        assertEquals(new Integer(index).toString(),
10257                                subSetIterator.next());
10258                    }
10259
10260                    subSet = keySet.subSet(startKey, true, endKey, false);
10261                    subSetIterator = subSet.iterator();
10262                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10263                        assertEquals(new Integer(index).toString(),
10264                                subSetIterator.next());
10265                    }
10266
10267                    subSet = keySet.subSet(startKey, true, endKey, true);
10268                    subSetIterator = subSet.iterator();
10269                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10270                        assertEquals(new Integer(index).toString(),
10271                                subSetIterator.next());
10272                    }
10273                }
10274            }
10275        }
10276
10277        key = new Integer(1).toString();
10278        keySet = tm.headMap(key, true).navigableKeySet();
10279        Iterator iterator = keySet.iterator();
10280        startKey = (String) iterator.next();
10281        endKey = (String) iterator.next();
10282
10283        subSet = keySet.subSet(startKey, endKey);
10284        assertEquals(1, subSet.size());
10285        subSetIterator = subSet.iterator();
10286        assertEquals(new Integer(0).toString(), subSetIterator.next());
10287        try {
10288            subSetIterator.next();
10289            fail("should throw NoSuchElementException");
10290        } catch (NoSuchElementException e) {
10291            // Expected
10292        }
10293
10294        subSet = keySet.subSet(startKey, false, endKey, false);
10295        assertEquals(0, subSet.size());
10296
10297        subSet = keySet.subSet(startKey, false, endKey, true);
10298        assertEquals(1, subSet.size());
10299        subSetIterator = subSet.iterator();
10300        assertEquals(new Integer(1).toString(), subSetIterator.next());
10301        try {
10302            subSetIterator.next();
10303            fail("should throw NoSuchElementException");
10304        } catch (NoSuchElementException e) {
10305            // Expected
10306        }
10307
10308        subSet = keySet.subSet(startKey, true, endKey, false);
10309        assertEquals(1, subSet.size());
10310        subSetIterator = subSet.iterator();
10311        assertEquals(new Integer(0).toString(), subSetIterator.next());
10312        try {
10313            subSetIterator.next();
10314            fail("should throw NoSuchElementException");
10315        } catch (NoSuchElementException e) {
10316            // Expected
10317        }
10318
10319        subSet = keySet.subSet(startKey, true, endKey, true);
10320        assertEquals(2, subSet.size());
10321        subSetIterator = subSet.iterator();
10322        assertEquals(new Integer(0).toString(), subSetIterator.next());
10323        assertEquals(new Integer(1).toString(), subSetIterator.next());
10324        try {
10325            subSetIterator.next();
10326            fail("should throw NoSuchElementException");
10327        } catch (NoSuchElementException e) {
10328            // Expected
10329        }
10330
10331        try {
10332            keySet.subSet(null, null);
10333            fail("should throw NPE");
10334        } catch (NullPointerException e) {
10335            // Expected
10336        }
10337
10338        try {
10339            keySet.subSet(null, false, null, false);
10340            fail("should throw NPE");
10341        } catch (NullPointerException e) {
10342            // Expected
10343        }
10344
10345        try {
10346            keySet.subSet(null, false, null, true);
10347            fail("should throw NPE");
10348        } catch (NullPointerException e) {
10349            // Expected
10350        }
10351
10352        try {
10353            keySet.subSet(null, true, null, false);
10354            fail("should throw NPE");
10355        } catch (NullPointerException e) {
10356            // Expected
10357        }
10358
10359        try {
10360            keySet.subSet(null, true, null, true);
10361            fail("should throw NPE");
10362        } catch (NullPointerException e) {
10363            // Expected
10364        }
10365
10366        try {
10367            keySet.subSet(null, endKey);
10368            fail("should throw NPE");
10369        } catch (NullPointerException e) {
10370            // Expected
10371        }
10372
10373        try {
10374            keySet.subSet(null, false, endKey, false);
10375            fail("should throw NPE");
10376        } catch (NullPointerException e) {
10377            // Expected
10378        }
10379
10380        try {
10381            keySet.subSet(null, false, endKey, true);
10382            fail("should throw NPE");
10383        } catch (NullPointerException e) {
10384            // Expected
10385        }
10386
10387        try {
10388            keySet.subSet(null, true, endKey, false);
10389            fail("should throw NPE");
10390        } catch (NullPointerException e) {
10391            // Expected
10392        }
10393
10394        try {
10395            keySet.subSet(null, true, endKey, true);
10396            fail("should throw NPE");
10397        } catch (NullPointerException e) {
10398            // Expected
10399        }
10400
10401        try {
10402            keySet.subSet(startKey, null);
10403            fail("should throw NPE");
10404        } catch (NullPointerException e) {
10405            // Expected
10406        }
10407
10408        try {
10409            keySet.subSet(startKey, false, null, false);
10410            fail("should throw NPE");
10411        } catch (NullPointerException e) {
10412            // Expected
10413        }
10414
10415        try {
10416            keySet.subSet(startKey, false, null, true);
10417            fail("should throw NPE");
10418        } catch (NullPointerException e) {
10419            // Expected
10420        }
10421
10422        try {
10423            keySet.subSet(startKey, true, null, false);
10424            fail("should throw NPE");
10425        } catch (NullPointerException e) {
10426            // Expected
10427        }
10428
10429        try {
10430            keySet.subSet(startKey, true, null, true);
10431            fail("should throw NPE");
10432        } catch (NullPointerException e) {
10433            // Expected
10434        }
10435
10436        // With Comparator
10437        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
10438                .navigableKeySet();
10439        startIterator = keySet.iterator();
10440        while (startIterator.hasNext()) {
10441            startKey = (String) startIterator.next();
10442            endIterator = keySet.iterator();
10443            while (endIterator.hasNext()) {
10444                endKey = (String) endIterator.next();
10445                int startIndex = Integer.valueOf(startKey);
10446                int endIndex = Integer.valueOf(endKey);
10447                if (startIndex > endIndex) {
10448                    try {
10449                        keySet.subSet(startKey, endKey);
10450                        fail("should throw IllegalArgumentException");
10451                    } catch (IllegalArgumentException e) {
10452                        // Expected
10453                    }
10454
10455                    try {
10456                        keySet.subSet(startKey, false, endKey, false);
10457                        fail("shoudl throw IllegalArgumentException");
10458                    } catch (IllegalArgumentException e) {
10459                        // Expected
10460                    }
10461
10462                    try {
10463                        keySet.subSet(startKey, false, endKey, true);
10464                        fail("shoudl throw IllegalArgumentException");
10465                    } catch (IllegalArgumentException e) {
10466                        // Expected
10467                    }
10468
10469                    try {
10470                        keySet.subSet(startKey, true, endKey, false);
10471                        fail("shoudl throw IllegalArgumentException");
10472                    } catch (IllegalArgumentException e) {
10473                        // Expected
10474                    }
10475
10476                    try {
10477                        keySet.subSet(startKey, true, endKey, true);
10478                        fail("shoudl throw IllegalArgumentException");
10479                    } catch (IllegalArgumentException e) {
10480                        // Expected
10481                    }
10482                } else {
10483                    subSet = keySet.subSet(startKey, endKey);
10484                    subSetIterator = subSet.iterator();
10485                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10486                        assertEquals(new Integer(index).toString(),
10487                                subSetIterator.next());
10488                    }
10489
10490                    subSet = keySet.subSet(startKey, false, endKey, false);
10491                    subSetIterator = subSet.iterator();
10492                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10493                        assertEquals(new Integer(index).toString(),
10494                                subSetIterator.next());
10495                    }
10496
10497                    subSet = keySet.subSet(startKey, false, endKey, true);
10498                    subSetIterator = subSet.iterator();
10499                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10500                        assertEquals(new Integer(index).toString(),
10501                                subSetIterator.next());
10502                    }
10503
10504                    subSet = keySet.subSet(startKey, true, endKey, false);
10505                    subSetIterator = subSet.iterator();
10506                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10507                        assertEquals(new Integer(index).toString(),
10508                                subSetIterator.next());
10509                    }
10510
10511                    subSet = keySet.subSet(startKey, true, endKey, true);
10512                    subSetIterator = subSet.iterator();
10513                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10514                        assertEquals(new Integer(index).toString(),
10515                                subSetIterator.next());
10516                    }
10517                }
10518            }
10519        }
10520
10521        key = new Integer(1).toString();
10522        keySet = tm.headMap(key, true).navigableKeySet();
10523        iterator = keySet.iterator();
10524        startKey = (String) iterator.next();
10525        endKey = (String) iterator.next();
10526
10527        subSet = keySet.subSet(startKey, endKey);
10528        assertEquals(1, subSet.size());
10529        subSetIterator = subSet.iterator();
10530        assertEquals(new Integer(0).toString(), subSetIterator.next());
10531        try {
10532            subSetIterator.next();
10533            fail("should throw NoSuchElementException");
10534        } catch (NoSuchElementException e) {
10535            // Expected
10536        }
10537
10538        subSet = keySet.subSet(startKey, false, endKey, false);
10539        assertEquals(0, subSet.size());
10540
10541        subSet = keySet.subSet(startKey, false, endKey, true);
10542        assertEquals(1, subSet.size());
10543        subSetIterator = subSet.iterator();
10544        assertEquals(new Integer(1).toString(), subSetIterator.next());
10545        try {
10546            subSetIterator.next();
10547            fail("should throw NoSuchElementException");
10548        } catch (NoSuchElementException e) {
10549            // Expected
10550        }
10551
10552        subSet = keySet.subSet(startKey, true, endKey, false);
10553        assertEquals(1, subSet.size());
10554        subSetIterator = subSet.iterator();
10555        assertEquals(new Integer(0).toString(), subSetIterator.next());
10556        try {
10557            subSetIterator.next();
10558            fail("should throw NoSuchElementException");
10559        } catch (NoSuchElementException e) {
10560            // Expected
10561        }
10562
10563        subSet = keySet.subSet(startKey, true, endKey, true);
10564        assertEquals(2, subSet.size());
10565        subSetIterator = subSet.iterator();
10566        assertEquals(new Integer(0).toString(), subSetIterator.next());
10567        assertEquals(new Integer(1).toString(), subSetIterator.next());
10568        try {
10569            subSetIterator.next();
10570            fail("should throw NoSuchElementException");
10571        } catch (NoSuchElementException e) {
10572            // Expected
10573        }
10574
10575        try {
10576            keySet.subSet(null, null);
10577            fail("should throw NPE");
10578        } catch (NullPointerException e) {
10579            // Expected
10580        }
10581
10582        try {
10583            keySet.subSet(null, false, null, false);
10584            fail("should throw NPE");
10585        } catch (NullPointerException e) {
10586            // Expected
10587        }
10588
10589        try {
10590            keySet.subSet(null, false, null, true);
10591            fail("should throw NPE");
10592        } catch (NullPointerException e) {
10593            // Expected
10594        }
10595
10596        try {
10597            keySet.subSet(null, true, null, false);
10598            fail("should throw NPE");
10599        } catch (NullPointerException e) {
10600            // Expected
10601        }
10602
10603        try {
10604            keySet.subSet(null, true, null, true);
10605            fail("should throw NPE");
10606        } catch (NullPointerException e) {
10607            // Expected
10608        }
10609
10610        try {
10611            keySet.subSet(null, endKey);
10612            fail("should throw NPE");
10613        } catch (NullPointerException e) {
10614            // Expected
10615        }
10616
10617        try {
10618            keySet.subSet(null, false, endKey, false);
10619            fail("should throw NPE");
10620        } catch (NullPointerException e) {
10621            // Expected
10622        }
10623
10624        try {
10625            keySet.subSet(null, false, endKey, true);
10626            fail("should throw NPE");
10627        } catch (NullPointerException e) {
10628            // Expected
10629        }
10630
10631        try {
10632            keySet.subSet(null, true, endKey, false);
10633            fail("should throw NPE");
10634        } catch (NullPointerException e) {
10635            // Expected
10636        }
10637
10638        try {
10639            keySet.subSet(null, true, endKey, true);
10640            fail("should throw NPE");
10641        } catch (NullPointerException e) {
10642            // Expected
10643        }
10644
10645        try {
10646            keySet.subSet(startKey, null);
10647            fail("should throw NPE");
10648        } catch (NullPointerException e) {
10649            // Expected
10650        }
10651
10652        try {
10653            keySet.subSet(startKey, false, null, false);
10654            fail("should throw NPE");
10655        } catch (NullPointerException e) {
10656            // Expected
10657        }
10658
10659        try {
10660            keySet.subSet(startKey, false, null, true);
10661            fail("should throw NPE");
10662        } catch (NullPointerException e) {
10663            // Expected
10664        }
10665
10666        try {
10667            keySet.subSet(startKey, true, null, false);
10668            fail("should throw NPE");
10669        } catch (NullPointerException e) {
10670            // Expected
10671        }
10672
10673        try {
10674            keySet.subSet(startKey, true, null, true);
10675            fail("should throw NPE");
10676        } catch (NullPointerException e) {
10677            // Expected
10678        }
10679
10680    }
10681
10682    public void test_AscendingSubMapKeySet_lower() {
10683        NavigableSet keySet;
10684        Iterator iterator;
10685        String key, lowerKey;
10686        int value, lowerValue;
10687
10688        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10689        iterator = keySet.iterator();
10690        while (iterator.hasNext()) {
10691            key = (String) iterator.next();
10692            value = Integer.valueOf(key);
10693            lowerKey = (String) keySet.lower(key);
10694            if (value > 101) {
10695                lowerValue = Integer.valueOf(lowerKey);
10696                assertEquals(value - 1, lowerValue);
10697            } else {
10698                assertNull(lowerKey);
10699            }
10700        }
10701
10702        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10703        iterator = keySet.iterator();
10704        while (iterator.hasNext()) {
10705            key = (String) iterator.next();
10706            value = Integer.valueOf(key);
10707            lowerKey = (String) keySet.lower(key);
10708            if (value > 101) {
10709                lowerValue = Integer.valueOf(lowerKey);
10710                assertEquals(value - 1, lowerValue);
10711            } else {
10712                assertNull(lowerKey);
10713            }
10714        }
10715
10716        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10717        iterator = keySet.iterator();
10718        while (iterator.hasNext()) {
10719            key = (String) iterator.next();
10720            value = Integer.valueOf(key);
10721            lowerKey = (String) keySet.lower(key);
10722            if (value > 100) {
10723                lowerValue = Integer.valueOf(lowerKey);
10724                assertEquals(value - 1, lowerValue);
10725            } else {
10726                assertNull(lowerKey);
10727            }
10728        }
10729
10730        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10731        iterator = keySet.iterator();
10732        while (iterator.hasNext()) {
10733            key = (String) iterator.next();
10734            value = Integer.valueOf(key);
10735            lowerKey = (String) keySet.lower(key);
10736            if (value > 100) {
10737                lowerValue = Integer.valueOf(lowerKey);
10738                assertEquals(value - 1, lowerValue);
10739            } else {
10740                assertNull(lowerKey);
10741            }
10742        }
10743
10744        key = new Integer(2).toString();
10745        keySet = tm.headMap(key, true).navigableKeySet();
10746        iterator = keySet.iterator();
10747        iterator.next();// 0
10748        String expectedLowerKey = (String) iterator.next();// 1
10749        assertEquals(expectedLowerKey, keySet.lower(iterator.next()));
10750
10751        try {
10752            keySet.lower(null);
10753            fail("should throw NPE");
10754        } catch (NullPointerException e) {
10755            // Expected
10756        }
10757
10758        key = new Integer(0).toString();
10759        keySet = tm.headMap(key, true).navigableKeySet();
10760        assertNull(keySet.lower(key));
10761
10762        key = new Integer(0).toString();
10763        keySet = tm.headMap(key, false).navigableKeySet();
10764        assertNull(keySet.lower(key));
10765
10766        key = new Integer(999).toString();
10767        keySet = tm.headMap(key, true).navigableKeySet();
10768        assertNotNull(keySet.lower(key));
10769
10770        key = new Integer(999).toString();
10771        keySet = tm.headMap(key, false).navigableKeySet();
10772        assertNotNull(keySet.lower(key));
10773    }
10774
10775    public void test_AscendingSubMapKeySet_higher() {
10776        NavigableSet keySet;
10777        Iterator iterator;
10778        String key, lowerKey;
10779        int value, lowerValue;
10780
10781        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10782        iterator = keySet.iterator();
10783        while (iterator.hasNext()) {
10784            key = (String) iterator.next();
10785            value = Integer.valueOf(key);
10786            lowerKey = (String) keySet.higher(key);
10787            if (value < 108) {
10788                lowerValue = Integer.valueOf(lowerKey);
10789                assertEquals(value + 1, lowerValue);
10790            } else {
10791                assertNull(lowerKey);
10792            }
10793        }
10794
10795        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10796        iterator = keySet.iterator();
10797        while (iterator.hasNext()) {
10798            key = (String) iterator.next();
10799            value = Integer.valueOf(key);
10800            lowerKey = (String) keySet.higher(key);
10801            if (value < 109) {
10802                lowerValue = Integer.valueOf(lowerKey);
10803                assertEquals(value + 1, lowerValue);
10804            } else {
10805                assertNull(lowerKey);
10806            }
10807        }
10808
10809        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10810        iterator = keySet.iterator();
10811        while (iterator.hasNext()) {
10812            key = (String) iterator.next();
10813            value = Integer.valueOf(key);
10814            lowerKey = (String) keySet.higher(key);
10815            if (value < 108) {
10816                lowerValue = Integer.valueOf(lowerKey);
10817                assertEquals(value + 1, lowerValue);
10818            } else {
10819                assertNull(lowerKey);
10820            }
10821        }
10822
10823        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10824        iterator = keySet.iterator();
10825        while (iterator.hasNext()) {
10826            key = (String) iterator.next();
10827            value = Integer.valueOf(key);
10828            lowerKey = (String) keySet.higher(key);
10829            if (value < 109) {
10830                lowerValue = Integer.valueOf(lowerKey);
10831                assertEquals(value + 1, lowerValue);
10832            } else {
10833                assertNull(lowerKey);
10834            }
10835        }
10836
10837        key = new Integer(2).toString();
10838        keySet = tm.headMap(key, true).navigableKeySet();
10839        iterator = keySet.iterator();
10840        iterator.next();// 0
10841        iterator.next();// 1
10842        lowerKey = (String) keySet.higher(iterator.next());
10843        String expectedLowerKey = (String) iterator.next();
10844        assertEquals(expectedLowerKey, lowerKey);
10845
10846        try {
10847            keySet.higher(null);
10848            fail("should throw NPE");
10849        } catch (NullPointerException e) {
10850            // Expected
10851        }
10852
10853        key = new Integer(0).toString();
10854        keySet = tm.headMap(key, true).navigableKeySet();
10855        assertNull(keySet.higher(key));
10856
10857        key = new Integer(0).toString();
10858        keySet = tm.headMap(key, false).navigableKeySet();
10859        assertNull(keySet.higher(key));
10860
10861        key = new Integer(999).toString();
10862        keySet = tm.headMap(key, true).navigableKeySet();
10863        assertNull(keySet.higher(key));
10864
10865        key = new Integer(999).toString();
10866        keySet = tm.headMap(key, false).navigableKeySet();
10867        assertNull(keySet.higher(key));
10868    }
10869
10870    public void test_AscendingSubMapKeySet_ceiling() {
10871        NavigableSet keySet;
10872        String key;
10873        String[] keyArray;
10874
10875        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10876        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10877        for (int i = 0, j = 101; i < keyArray.length; i++) {
10878            key = (String) keySet.ceiling(keyArray[i]);
10879            assertEquals(new Integer(i + j).toString(), key);
10880        }
10881
10882        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10883        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10884        for (int i = 0, j = 101; i < keyArray.length; i++) {
10885            key = (String) keySet.ceiling(keyArray[i]);
10886            assertEquals(new Integer(i + j).toString(), key);
10887        }
10888
10889        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10890        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10891        for (int i = 0, j = 100; i < keyArray.length; i++) {
10892            key = (String) keySet.ceiling(keyArray[i]);
10893            assertEquals(new Integer(i + j).toString(), key);
10894        }
10895
10896        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10897        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10898        for (int i = 0, j = 100; i < keyArray.length; i++) {
10899            key = (String) keySet.ceiling(keyArray[i]);
10900            assertEquals(new Integer(i + j).toString(), key);
10901        }
10902
10903        key = new Integer(2).toString();
10904        keySet = tm.headMap(key, true).navigableKeySet();
10905        Iterator iterator = keySet.iterator();
10906        iterator.next();
10907        assertEquals(new Integer(1).toString(), keySet.ceiling(iterator.next()));
10908
10909        try {
10910            keySet.ceiling(null);
10911            fail("should throw NPE");
10912        } catch (NullPointerException e) {
10913            // Expected
10914        }
10915
10916        key = new Integer(0).toString();
10917        keySet = tm.headMap(key, true).navigableKeySet();
10918        assertEquals(key, keySet.ceiling(key));
10919
10920        key = new Integer(0).toString();
10921        keySet = tm.headMap(key, false).navigableKeySet();
10922        assertNull(keySet.higher(key));
10923
10924        key = new Integer(999).toString();
10925        keySet = tm.headMap(key, true).navigableKeySet();
10926        assertNull(keySet.higher(key));
10927
10928        key = new Integer(999).toString();
10929        keySet = tm.headMap(key, false).navigableKeySet();
10930        assertNull(keySet.higher(key));
10931    }
10932
10933    public void test_AscendingSubMapKeySet_floor() {
10934        NavigableSet keySet;
10935        String key;
10936        String[] keyArray;
10937
10938        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10939        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10940        for (int i = 0, j = 101; i < keyArray.length; i++) {
10941            key = (String) keySet.floor(keyArray[i]);
10942            assertEquals(new Integer(i + j).toString(), key);
10943        }
10944
10945        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10946        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10947        for (int i = 0, j = 101; i < keyArray.length; i++) {
10948            key = (String) keySet.floor(keyArray[i]);
10949            assertEquals(new Integer(i + j).toString(), key);
10950        }
10951
10952        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10953        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10954        for (int i = 0, j = 100; i < keyArray.length; i++) {
10955            key = (String) keySet.floor(keyArray[i]);
10956            assertEquals(new Integer(i + j).toString(), key);
10957        }
10958
10959        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10960        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10961        for (int i = 0, j = 100; i < keyArray.length; i++) {
10962            key = (String) keySet.floor(keyArray[i]);
10963            assertEquals(new Integer(i + j).toString(), key);
10964        }
10965
10966        key = new Integer(2).toString();
10967        keySet = tm.headMap(key, true).navigableKeySet();
10968        Iterator iterator = keySet.iterator();
10969        iterator.next();
10970        assertEquals(new Integer(1).toString(), keySet.floor(iterator.next()));
10971
10972        try {
10973            keySet.floor(null);
10974            fail("should throw NPE");
10975        } catch (NullPointerException e) {
10976            // Expected
10977        }
10978
10979        key = new Integer(0).toString();
10980        keySet = tm.headMap(key, true).navigableKeySet();
10981        assertEquals(key, keySet.floor(key));
10982
10983        key = new Integer(0).toString();
10984        keySet = tm.headMap(key, false).navigableKeySet();
10985        assertNull(keySet.floor(key));
10986
10987        key = new Integer(999).toString();
10988        keySet = tm.headMap(key, true).navigableKeySet();
10989        assertEquals(key, keySet.floor(key));
10990
10991        key = new Integer(999).toString();
10992        keySet = tm.headMap(key, false).navigableKeySet();
10993        assertEquals(new Integer(998).toString(), keySet.floor(key));
10994    }
10995
10996    public void test_BoundedEntryIterator_next() {
10997        Iterator iterator = subMap_default.entrySet().iterator();
10998        assertTrue(iterator.hasNext());
10999        for (int i = 100; iterator.hasNext(); i++) {
11000            assertEquals(i, ((Entry) iterator.next()).getValue());
11001        }
11002
11003        try {
11004            iterator.next();
11005            fail("should throw java.util.NoSuchElementException");
11006        } catch (NoSuchElementException e) {
11007            // Expected
11008        }
11009
11010    }
11011
11012    public void test_BoundedKeyIterator_next() {
11013        Iterator iterator = subMap_default.keySet().iterator();
11014        assertTrue(iterator.hasNext());
11015        for (int i = 100; iterator.hasNext(); i++) {
11016            assertEquals(new Integer(i).toString(), iterator.next());
11017        }
11018
11019        try {
11020            iterator.next();
11021            fail("should throw java.util.NoSuchElementException");
11022        } catch (NoSuchElementException e) {
11023            // Expected
11024        }
11025    }
11026
11027    public void test_BoundedValueIterator_next() {
11028        String startKey = new Integer(101).toString();
11029        String endKey = new Integer(108).toString();
11030
11031        Collection values = tm.subMap(startKey, endKey).values();
11032        Iterator iter = values.iterator();
11033        for (int i = 101; i < 108; i++) {
11034            assertEquals(i, iter.next());
11035        }
11036        try {
11037            iter.next();
11038            fail("should throw java.util.NoSuchElementException");
11039        } catch (Exception e) {
11040            // Expected
11041        }
11042    }
11043
11044    /*
11045     * SubMapEntrySet
11046     */
11047    public void test_SubMapEntrySet_Constructor() {
11048    }
11049
11050    public void test_SubMapEntrySet_contains() {
11051        // covered in test_SubMapEntrySet_remove
11052    }
11053
11054    public void test_SubMapEntrySet_iterator() {
11055        Set entrySet = subMap_default.entrySet();
11056        Iterator iterator;
11057        Entry entry;
11058        Integer value = new Integer(100);
11059        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11060            entry = (Entry) iterator.next();
11061            assertEquals(value.toString(), entry.getKey());
11062            assertEquals(value, entry.getValue());
11063        }
11064        assertEquals(109, value.intValue());
11065        try {
11066            iterator.next();
11067            fail("should throw NoSuchElementException");
11068        } catch (NoSuchElementException e) {
11069            // Expected
11070        }
11071
11072        entrySet = subMap_startExcluded_endExcluded.entrySet();
11073        value = new Integer(101);
11074        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11075            entry = (Entry) iterator.next();
11076            assertEquals(value.toString(), entry.getKey());
11077            assertEquals(value, entry.getValue());
11078        }
11079        assertEquals(109, value.intValue());
11080        try {
11081            iterator.next();
11082            fail("should throw NoSuchElementException");
11083        } catch (NoSuchElementException e) {
11084            // Expected
11085        }
11086
11087        entrySet = subMap_startExcluded_endIncluded.entrySet();
11088        value = new Integer(101);
11089        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11090            entry = (Entry) iterator.next();
11091            assertEquals(value.toString(), entry.getKey());
11092            assertEquals(value, entry.getValue());
11093        }
11094        assertEquals(110, value.intValue());
11095        try {
11096            iterator.next();
11097            fail("should throw NoSuchElementException");
11098        } catch (NoSuchElementException e) {
11099            // Expected
11100        }
11101
11102        entrySet = subMap_startIncluded_endExcluded.entrySet();
11103        value = new Integer(100);
11104        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11105            entry = (Entry) iterator.next();
11106            assertEquals(value.toString(), entry.getKey());
11107            assertEquals(value, entry.getValue());
11108        }
11109        assertEquals(109, value.intValue());
11110        try {
11111            iterator.next();
11112            fail("should throw NoSuchElementException");
11113        } catch (NoSuchElementException e) {
11114            // Expected
11115        }
11116
11117        entrySet = subMap_startIncluded_endIncluded.entrySet();
11118        value = new Integer(100);
11119        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11120            entry = (Entry) iterator.next();
11121            assertEquals(value.toString(), entry.getKey());
11122            assertEquals(value, entry.getValue());
11123        }
11124        assertEquals(110, value.intValue());
11125        try {
11126            iterator.next();
11127            fail("should throw NoSuchElementException");
11128        } catch (NoSuchElementException e) {
11129            // Expected
11130        }
11131
11132        String startKey = new Integer(-1).toString();
11133        String endKey = new Integer(0).toString();
11134        SortedMap subMap = tm.subMap(startKey, endKey);
11135        entrySet = subMap.entrySet();
11136        iterator = entrySet.iterator();
11137        try {
11138            iterator.next();
11139            fail("should throw NoSuchElementException");
11140        } catch (NoSuchElementException e) {
11141            // Expected
11142        }
11143
11144        endKey = new Integer(1).toString();
11145        subMap = tm.subMap(startKey, endKey);
11146        entrySet = subMap.entrySet();
11147        iterator = entrySet.iterator();
11148        assertEquals(0, ((Entry) iterator.next()).getValue());
11149        try {
11150            iterator.next();
11151            fail("should throw NoSuchElementException");
11152        } catch (NoSuchElementException e) {
11153            // Expected
11154        }
11155
11156        endKey = new Integer(2000).toString();
11157        subMap = tm.subMap(startKey, endKey);
11158        entrySet = subMap.entrySet();
11159        iterator = entrySet.iterator();
11160        for (int i = 0; i < subMap.size(); i++) {
11161            iterator.next();
11162        }
11163        try {
11164            iterator.next();
11165            fail("should throw NoSuchElementException");
11166        } catch (NoSuchElementException e) {
11167            // Expected
11168        }
11169
11170        startKey = new Integer(9).toString();
11171        endKey = new Integer(100).toString();
11172        try {
11173            tm.subMap(startKey, endKey);
11174            fail("should throw IllegalArgumentException");
11175        } catch (IllegalArgumentException e) {
11176            // Expected
11177        }
11178
11179        // With Comparator
11180        entrySet = subMap_default_comparator.entrySet();
11181        value = new Integer(100);
11182        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11183            entry = (Entry) iterator.next();
11184            assertEquals(value.toString(), entry.getKey());
11185            assertEquals(value, entry.getValue());
11186        }
11187        assertEquals(109, value.intValue());
11188        try {
11189            iterator.next();
11190            fail("should throw NoSuchElementException");
11191        } catch (NoSuchElementException e) {
11192            // Expected
11193        }
11194
11195        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
11196        value = new Integer(101);
11197        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11198            entry = (Entry) iterator.next();
11199            assertEquals(value.toString(), entry.getKey());
11200            assertEquals(value, entry.getValue());
11201        }
11202        assertEquals(109, value.intValue());
11203        try {
11204            iterator.next();
11205            fail("should throw NoSuchElementException");
11206        } catch (NoSuchElementException e) {
11207            // Expected
11208        }
11209
11210        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
11211        value = new Integer(101);
11212        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11213            entry = (Entry) iterator.next();
11214            assertEquals(value.toString(), entry.getKey());
11215            assertEquals(value, entry.getValue());
11216        }
11217        assertEquals(110, value.intValue());
11218        try {
11219            iterator.next();
11220            fail("should throw NoSuchElementException");
11221        } catch (NoSuchElementException e) {
11222            // Expected
11223        }
11224
11225        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
11226        value = new Integer(100);
11227        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11228            entry = (Entry) iterator.next();
11229            assertEquals(value.toString(), entry.getKey());
11230            assertEquals(value, entry.getValue());
11231        }
11232        assertEquals(109, value.intValue());
11233        try {
11234            iterator.next();
11235            fail("should throw NoSuchElementException");
11236        } catch (NoSuchElementException e) {
11237            // Expected
11238        }
11239
11240        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
11241        value = new Integer(100);
11242        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11243            entry = (Entry) iterator.next();
11244            assertEquals(value.toString(), entry.getKey());
11245            assertEquals(value, entry.getValue());
11246        }
11247        assertEquals(110, value.intValue());
11248        try {
11249            iterator.next();
11250            fail("should throw NoSuchElementException");
11251        } catch (NoSuchElementException e) {
11252            // Expected
11253        }
11254    }
11255
11256    public void test_SubMapEntrySet_remove() {
11257        Set entrySet = subMap_default.entrySet();
11258        assertFalse(entrySet.remove(null));
11259        int size = entrySet.size();
11260        for (int i = 0; i < size; i++) {
11261            Iterator iterator = entrySet.iterator();
11262            assertTrue(entrySet.remove(iterator.next()));
11263        }
11264
11265        entrySet = subMap_startExcluded_endExcluded.entrySet();
11266        assertFalse(entrySet.remove(null));
11267        size = entrySet.size();
11268        for (int i = 0; i < size; i++) {
11269            Iterator iterator = entrySet.iterator();
11270            assertTrue(entrySet.remove(iterator.next()));
11271        }
11272
11273        entrySet = subMap_startExcluded_endIncluded.entrySet();
11274        assertFalse(entrySet.remove(null));
11275        size = entrySet.size();
11276        for (int i = 0; i < size; i++) {
11277            Iterator iterator = entrySet.iterator();
11278            assertTrue(entrySet.remove(iterator.next()));
11279        }
11280
11281        entrySet = subMap_startIncluded_endExcluded.entrySet();
11282        assertFalse(entrySet.remove(null));
11283        size = entrySet.size();
11284        for (int i = 0; i < size; i++) {
11285            Iterator iterator = entrySet.iterator();
11286            assertTrue(entrySet.remove(iterator.next()));
11287        }
11288
11289        entrySet = subMap_startIncluded_endIncluded.entrySet();
11290        assertFalse(entrySet.remove(null));
11291        size = entrySet.size();
11292        for (int i = 0; i < size; i++) {
11293            Iterator iterator = entrySet.iterator();
11294            assertTrue(entrySet.remove(iterator.next()));
11295        }
11296    }
11297
11298    public void test_SubMapEntrySet_isEmpty() {
11299        assertFalse(subMap_default.entrySet().isEmpty());
11300        assertFalse(subMap_startExcluded_endExcluded.entrySet().isEmpty());
11301        assertFalse(subMap_startExcluded_endIncluded.entrySet().isEmpty());
11302        assertFalse(subMap_startIncluded_endExcluded.entrySet().isEmpty());
11303        assertFalse(subMap_startIncluded_endIncluded.entrySet().isEmpty());
11304
11305        String startKey = new Integer(0).toString();
11306        String endKey = startKey;
11307        SortedMap subMap = tm.subMap(startKey, endKey);
11308        assertTrue(subMap.entrySet().isEmpty());
11309
11310        startKey = new Integer(-1).toString();
11311        subMap = tm.subMap(startKey, endKey);
11312        assertTrue(subMap.entrySet().isEmpty());
11313
11314        endKey = new Integer(1).toString();
11315        subMap = tm.subMap(startKey, endKey);
11316        assertFalse(subMap.entrySet().isEmpty());
11317    }
11318
11319    public void test_SubMapEntrySet_size() {
11320        assertEquals(9, subMap_default.entrySet().size());
11321        assertEquals(8, subMap_startExcluded_endExcluded.entrySet().size());
11322        assertEquals(9, subMap_startExcluded_endIncluded.entrySet().size());
11323        assertEquals(9, subMap_startIncluded_endExcluded.entrySet().size());
11324        assertEquals(10, subMap_startIncluded_endIncluded.entrySet().size());
11325
11326        String startKey = new Integer(0).toString();
11327        String endKey = new Integer(2).toString();
11328        SortedMap subMap = tm.subMap(startKey, endKey);
11329        assertEquals(112, subMap.entrySet().size());
11330
11331        startKey = new Integer(0).toString();
11332        endKey = startKey;
11333        subMap = tm.subMap(startKey, endKey);
11334        assertEquals(0, subMap.entrySet().size());
11335
11336        startKey = new Integer(-1).toString();
11337        endKey = startKey;
11338        subMap = tm.subMap(startKey, endKey);
11339        assertEquals(0, subMap.entrySet().size());
11340
11341        endKey = new Integer(1).toString();
11342        subMap = tm.subMap(startKey, endKey);
11343        assertEquals(1, subMap.entrySet().size());
11344
11345        startKey = new Integer(999).toString();
11346        endKey = startKey;
11347        subMap = tm.subMap(startKey, endKey);
11348        assertEquals(0, subMap.entrySet().size());
11349    }
11350
11351    /*
11352     * SubMapKeySet
11353     */
11354    public void test_SubMapKeySet_Constructor() {
11355        // covered in other test
11356    }
11357
11358    public void test_SubMapKeySet_iterator() {
11359        Set keySet = subMap_default.keySet();
11360        Iterator iterator = keySet.iterator();
11361        for (int i = 0; i < keySet.size(); i++) {
11362            assertEquals(new Integer(100 + i).toString(), iterator.next());
11363        }
11364        assertFalse(iterator.hasNext());
11365        try {
11366            iterator.next();
11367            fail("should throw NoSuchElementException");
11368        } catch (NoSuchElementException e) {
11369            // Expected
11370        }
11371
11372        keySet = subMap_startExcluded_endExcluded.keySet();
11373        iterator = keySet.iterator();
11374        for (int i = 0; i < keySet.size(); i++) {
11375            assertEquals(new Integer(101 + i).toString(), iterator.next());
11376        }
11377        assertFalse(iterator.hasNext());
11378        try {
11379            iterator.next();
11380            fail("should throw NoSuchElementException");
11381        } catch (NoSuchElementException e) {
11382            // Expected
11383        }
11384
11385        keySet = subMap_startExcluded_endIncluded.keySet();
11386        iterator = keySet.iterator();
11387        for (int i = 0; i < keySet.size(); i++) {
11388            assertEquals(new Integer(101 + i).toString(), iterator.next());
11389        }
11390        assertFalse(iterator.hasNext());
11391        try {
11392            iterator.next();
11393            fail("should throw NoSuchElementException");
11394        } catch (NoSuchElementException e) {
11395            // Expected
11396        }
11397
11398        keySet = subMap_startIncluded_endExcluded.keySet();
11399        iterator = keySet.iterator();
11400        for (int i = 0; i < keySet.size(); i++) {
11401            assertEquals(new Integer(100 + i).toString(), iterator.next());
11402        }
11403        assertFalse(iterator.hasNext());
11404        try {
11405            iterator.next();
11406            fail("should throw NoSuchElementException");
11407        } catch (NoSuchElementException e) {
11408            // Expected
11409        }
11410
11411        keySet = subMap_startIncluded_endIncluded.keySet();
11412        iterator = keySet.iterator();
11413        for (int i = 0; i < keySet.size(); i++) {
11414            assertEquals(new Integer(100 + i).toString(), iterator.next());
11415        }
11416        assertFalse(iterator.hasNext());
11417        try {
11418            iterator.next();
11419            fail("should throw NoSuchElementException");
11420        } catch (NoSuchElementException e) {
11421            // Expected
11422        }
11423
11424        // With Comparator
11425        keySet = subMap_default_comparator.keySet();
11426        iterator = keySet.iterator();
11427        for (int i = 0; i < keySet.size(); i++) {
11428            assertEquals(new Integer(100 + i).toString(), iterator.next());
11429        }
11430        assertFalse(iterator.hasNext());
11431        try {
11432            iterator.next();
11433            fail("should throw NoSuchElementException");
11434        } catch (NoSuchElementException e) {
11435            // Expected
11436        }
11437
11438        keySet = subMap_startExcluded_endExcluded_comparator.keySet();
11439        iterator = keySet.iterator();
11440        for (int i = 0; i < keySet.size(); i++) {
11441            assertEquals(new Integer(101 + i).toString(), iterator.next());
11442        }
11443        assertFalse(iterator.hasNext());
11444        try {
11445            iterator.next();
11446            fail("should throw NoSuchElementException");
11447        } catch (NoSuchElementException e) {
11448            // Expected
11449        }
11450
11451        keySet = subMap_startExcluded_endIncluded_comparator.keySet();
11452        iterator = keySet.iterator();
11453        for (int i = 0; i < keySet.size(); i++) {
11454            assertEquals(new Integer(101 + i).toString(), iterator.next());
11455        }
11456        assertFalse(iterator.hasNext());
11457        try {
11458            iterator.next();
11459            fail("should throw NoSuchElementException");
11460        } catch (NoSuchElementException e) {
11461            // Expected
11462        }
11463
11464        keySet = subMap_startIncluded_endExcluded_comparator.keySet();
11465        iterator = keySet.iterator();
11466        for (int i = 0; i < keySet.size(); i++) {
11467            assertEquals(new Integer(100 + i).toString(), iterator.next());
11468        }
11469        assertFalse(iterator.hasNext());
11470        try {
11471            iterator.next();
11472            fail("should throw NoSuchElementException");
11473        } catch (NoSuchElementException e) {
11474            // Expected
11475        }
11476
11477        keySet = subMap_startIncluded_endIncluded_comparator.keySet();
11478        iterator = keySet.iterator();
11479        for (int i = 0; i < keySet.size(); i++) {
11480            assertEquals(new Integer(100 + i).toString(), iterator.next());
11481        }
11482        assertFalse(iterator.hasNext());
11483        try {
11484            iterator.next();
11485            fail("should throw NoSuchElementException");
11486        } catch (NoSuchElementException e) {
11487            // Expected
11488        }
11489    }
11490
11491    public void test_SubMapKeySet_isEmpty() {
11492        assertFalse(subMap_default.keySet().isEmpty());
11493        assertFalse(subMap_startExcluded_endExcluded.keySet().isEmpty());
11494        assertFalse(subMap_startExcluded_endIncluded.keySet().isEmpty());
11495        assertFalse(subMap_startIncluded_endExcluded.keySet().isEmpty());
11496        assertFalse(subMap_startIncluded_endIncluded.keySet().isEmpty());
11497
11498        String startKey = new Integer(0).toString();
11499        String endKey = startKey;
11500        SortedMap subMap = tm.subMap(startKey, endKey);
11501        assertTrue(subMap.keySet().isEmpty());
11502
11503        startKey = new Integer(999).toString();
11504        endKey = startKey;
11505        subMap = tm.subMap(startKey, endKey);
11506        assertTrue(subMap.keySet().isEmpty());
11507
11508        startKey = new Integer(-1).toString();
11509        endKey = new Integer(1).toString();
11510        subMap = tm.subMap(startKey, endKey);
11511        assertFalse(subMap.keySet().isEmpty());
11512
11513        endKey = new Integer(0).toString();
11514        subMap = tm.subMap(startKey, endKey);
11515        assertTrue(subMap.keySet().isEmpty());
11516    }
11517
11518    public void test_SubMapKeySet_contains() {
11519        Set keySet = subMap_default.keySet();
11520        try {
11521            keySet.contains(null);
11522            fail("should throw NullPointerException");
11523        } catch (NullPointerException e) {
11524            // Expected
11525        }
11526        String key = new Integer(-1).toString();
11527        assertFalse(keySet.contains(key));
11528        key = new Integer(99).toString();
11529        assertFalse(keySet.contains(key));
11530        key = new Integer(100).toString();
11531        assertTrue(keySet.contains(key));
11532        for (int i = 101; i < 109; i++) {
11533            key = new Integer(i).toString();
11534            assertTrue(keySet.contains(key));
11535        }
11536        key = new Integer(109).toString();
11537        assertFalse(keySet.contains(key));
11538        key = new Integer(110).toString();
11539        assertFalse(keySet.contains(key));
11540        key = new Integer(1001).toString();
11541        assertFalse(keySet.contains(key));
11542
11543        keySet = subMap_startExcluded_endExcluded.keySet();
11544        try {
11545            keySet.contains(null);
11546            fail("should throw NullPointerException");
11547        } catch (NullPointerException e) {
11548            // Expected
11549        }
11550        key = new Integer(-1).toString();
11551        assertFalse(keySet.contains(key));
11552        key = new Integer(99).toString();
11553        assertFalse(keySet.contains(key));
11554        key = new Integer(100).toString();
11555        assertFalse(keySet.contains(key));
11556        for (int i = 101; i < 109; i++) {
11557            key = new Integer(i).toString();
11558            assertTrue(keySet.contains(key));
11559        }
11560        key = new Integer(109).toString();
11561        assertFalse(keySet.contains(key));
11562        key = new Integer(110).toString();
11563        assertFalse(keySet.contains(key));
11564        key = new Integer(1001).toString();
11565        assertFalse(keySet.contains(key));
11566
11567        keySet = subMap_startExcluded_endIncluded.keySet();
11568        try {
11569            keySet.contains(null);
11570            fail("should throw NullPointerException");
11571        } catch (NullPointerException e) {
11572            // Expected
11573        }
11574        key = new Integer(-1).toString();
11575        assertFalse(keySet.contains(key));
11576        key = new Integer(99).toString();
11577        assertFalse(keySet.contains(key));
11578        key = new Integer(100).toString();
11579        assertFalse(keySet.contains(key));
11580        for (int i = 101; i < 109; i++) {
11581            key = new Integer(i).toString();
11582            assertTrue(keySet.contains(key));
11583        }
11584        key = new Integer(109).toString();
11585        assertTrue(keySet.contains(key));
11586        key = new Integer(110).toString();
11587        assertFalse(keySet.contains(key));
11588        key = new Integer(1001).toString();
11589        assertFalse(keySet.contains(key));
11590
11591        keySet = subMap_startIncluded_endExcluded.keySet();
11592        try {
11593            keySet.contains(null);
11594            fail("should throw NullPointerException");
11595        } catch (NullPointerException e) {
11596            // Expected
11597        }
11598        key = new Integer(-1).toString();
11599        assertFalse(keySet.contains(key));
11600        key = new Integer(99).toString();
11601        assertFalse(keySet.contains(key));
11602        key = new Integer(100).toString();
11603        assertTrue(keySet.contains(key));
11604        for (int i = 101; i < 109; i++) {
11605            key = new Integer(i).toString();
11606            assertTrue(keySet.contains(key));
11607        }
11608        key = new Integer(109).toString();
11609        assertFalse(keySet.contains(key));
11610        key = new Integer(110).toString();
11611        assertFalse(keySet.contains(key));
11612        key = new Integer(1001).toString();
11613        assertFalse(keySet.contains(key));
11614
11615        keySet = subMap_startIncluded_endIncluded.keySet();
11616        try {
11617            keySet.contains(null);
11618            fail("should throw NullPointerException");
11619        } catch (NullPointerException e) {
11620            // Expected
11621        }
11622        key = new Integer(-1).toString();
11623        assertFalse(keySet.contains(key));
11624        key = new Integer(99).toString();
11625        assertFalse(keySet.contains(key));
11626        key = new Integer(100).toString();
11627        assertTrue(keySet.contains(key));
11628        for (int i = 101; i < 109; i++) {
11629            key = new Integer(i).toString();
11630            assertTrue(keySet.contains(key));
11631        }
11632        key = new Integer(109).toString();
11633        assertTrue(keySet.contains(key));
11634        key = new Integer(110).toString();
11635        assertFalse(keySet.contains(key));
11636        key = new Integer(1001).toString();
11637        assertFalse(keySet.contains(key));
11638    }
11639
11640    public void test_SubMapKeySet_size() {
11641        assertEquals(9, subMap_default.keySet().size());
11642        assertEquals(8, subMap_startExcluded_endExcluded.keySet().size());
11643        assertEquals(9, subMap_startExcluded_endIncluded.keySet().size());
11644        assertEquals(9, subMap_startIncluded_endExcluded.keySet().size());
11645        assertEquals(10, subMap_startIncluded_endIncluded.keySet().size());
11646
11647        String startKey = new Integer(0).toString();
11648        String endKey = new Integer(2).toString();
11649        SortedMap subMap = tm.subMap(startKey, endKey);
11650        assertEquals(112, subMap.keySet().size());
11651
11652        startKey = new Integer(0).toString();
11653        endKey = startKey;
11654        subMap = tm.subMap(startKey, endKey);
11655        assertEquals(0, subMap.keySet().size());
11656
11657        startKey = new Integer(-1).toString();
11658        endKey = startKey;
11659        subMap = tm.subMap(startKey, endKey);
11660        assertEquals(0, subMap.keySet().size());
11661
11662        endKey = new Integer(1).toString();
11663        subMap = tm.subMap(startKey, endKey);
11664        assertEquals(1, subMap.keySet().size());
11665
11666        startKey = new Integer(999).toString();
11667        endKey = startKey;
11668        subMap = tm.subMap(startKey, endKey);
11669        assertEquals(0, subMap.keySet().size());
11670    }
11671
11672    public void test_SubMapKeySet_remove() {
11673        Set keySet = subMap_default.keySet();
11674        try {
11675            keySet.remove(null);
11676            fail("should throw NullPointerException");
11677        } catch (NullPointerException e) {
11678            // Expected
11679        }
11680        int size = keySet.size();
11681        for (int i = 0; i < size; i++) {
11682            Iterator iterator = keySet.iterator();
11683            assertTrue(keySet.remove(iterator.next()));
11684        }
11685
11686        keySet = subMap_startExcluded_endExcluded.keySet();
11687        try {
11688            keySet.remove(null);
11689            fail("should throw NullPointerException");
11690        } catch (NullPointerException e) {
11691            // Expected
11692        }
11693        size = keySet.size();
11694        for (int i = 0; i < size; i++) {
11695            Iterator iterator = keySet.iterator();
11696            assertTrue(keySet.remove(iterator.next()));
11697        }
11698
11699        keySet = subMap_startExcluded_endIncluded.keySet();
11700        try {
11701            keySet.remove(null);
11702            fail("should throw NullPointerException");
11703        } catch (NullPointerException e) {
11704            // Expected
11705        }
11706        size = keySet.size();
11707        for (int i = 0; i < size; i++) {
11708            Iterator iterator = keySet.iterator();
11709            assertTrue(keySet.remove(iterator.next()));
11710        }
11711
11712        keySet = subMap_startIncluded_endExcluded.keySet();
11713        try {
11714            keySet.remove(null);
11715            fail("should throw NullPointerException");
11716        } catch (NullPointerException e) {
11717            // Expected
11718        }
11719        size = keySet.size();
11720        for (int i = 0; i < size; i++) {
11721            Iterator iterator = keySet.iterator();
11722            assertTrue(keySet.remove(iterator.next()));
11723        }
11724
11725        keySet = subMap_startIncluded_endIncluded.keySet();
11726        try {
11727            keySet.remove(null);
11728            fail("should throw NullPointerException");
11729        } catch (NullPointerException e) {
11730            // Expected
11731        }
11732        size = keySet.size();
11733        for (int i = 0; i < size; i++) {
11734            Iterator iterator = keySet.iterator();
11735            assertTrue(keySet.remove(iterator.next()));
11736        }
11737    }
11738
11739    /*
11740     * AscendingSubMapEntrySet
11741     */
11742
11743    public void test_AscendingSubMapEntrySet_comparator() {
11744        Set entrySet;
11745        NavigableSet ascendingSubMapEntrySet;
11746
11747        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11748        if (entrySet instanceof NavigableSet) {
11749            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11750            assertNull(ascendingSubMapEntrySet.comparator());
11751        }
11752
11753        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11754        if (entrySet instanceof NavigableSet) {
11755            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11756            assertNull(ascendingSubMapEntrySet.comparator());
11757        }
11758
11759        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11760        if (entrySet instanceof NavigableSet) {
11761            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11762            assertNull(ascendingSubMapEntrySet.comparator());
11763        }
11764
11765        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11766        if (entrySet instanceof NavigableSet) {
11767            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11768            assertNull(ascendingSubMapEntrySet.comparator());
11769        }
11770    }
11771
11772    public void test_AscendingSubMapEntrySet_descendingSet() {
11773        Set entrySet;
11774        NavigableSet ascendingSubMapEntrySet, descendingSet;
11775        Entry entry;
11776        int value;
11777        Iterator iterator;
11778
11779        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11780        if (entrySet instanceof NavigableSet) {
11781            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11782            descendingSet = ascendingSubMapEntrySet.descendingSet();
11783            iterator = descendingSet.iterator();
11784            assertTrue(iterator.hasNext());
11785            for (value = 108; iterator.hasNext(); value--) {
11786                entry = (Entry) iterator.next();
11787                assertEquals(value, entry.getValue());
11788            }
11789            assertEquals(100, value);
11790        }
11791
11792        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11793        if (entrySet instanceof NavigableSet) {
11794            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11795            descendingSet = ascendingSubMapEntrySet.descendingSet();
11796            iterator = descendingSet.iterator();
11797            assertTrue(iterator.hasNext());
11798            for (value = 109; iterator.hasNext(); value--) {
11799                entry = (Entry) iterator.next();
11800                assertEquals(value, entry.getValue());
11801            }
11802            assertEquals(100, value);
11803        }
11804
11805        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11806        if (entrySet instanceof NavigableSet) {
11807            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11808            descendingSet = ascendingSubMapEntrySet.descendingSet();
11809            iterator = descendingSet.iterator();
11810            assertTrue(iterator.hasNext());
11811            for (value = 108; iterator.hasNext(); value--) {
11812                entry = (Entry) iterator.next();
11813                assertEquals(value, entry.getValue());
11814            }
11815            assertEquals(99, value);
11816        }
11817
11818        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11819        if (entrySet instanceof NavigableSet) {
11820            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11821            descendingSet = ascendingSubMapEntrySet.descendingSet();
11822            iterator = descendingSet.iterator();
11823            assertTrue(iterator.hasNext());
11824            for (value = 109; iterator.hasNext(); value--) {
11825                entry = (Entry) iterator.next();
11826                assertEquals(value, entry.getValue());
11827            }
11828            assertEquals(99, value);
11829        }
11830    }
11831
11832    public void test_AscendingSubMapEntrySet_descendingIterator() {
11833        Set entrySet;
11834        NavigableSet ascendingSubMapEntrySet;
11835        Iterator iterator;
11836        Entry entry;
11837        int value;
11838
11839        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11840        if (entrySet instanceof NavigableSet) {
11841            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11842            iterator = ascendingSubMapEntrySet.descendingIterator();
11843            assertTrue(iterator.hasNext());
11844            for (value = 108; iterator.hasNext(); value--) {
11845                entry = (Entry) iterator.next();
11846                assertEquals(value, entry.getValue());
11847            }
11848            assertEquals(100, value);
11849        }
11850
11851        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11852        if (entrySet instanceof NavigableSet) {
11853            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11854            iterator = ascendingSubMapEntrySet.descendingIterator();
11855            assertTrue(iterator.hasNext());
11856            for (value = 109; iterator.hasNext(); value--) {
11857                entry = (Entry) iterator.next();
11858                assertEquals(value, entry.getValue());
11859            }
11860            assertEquals(100, value);
11861        }
11862
11863        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11864        if (entrySet instanceof NavigableSet) {
11865            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11866            iterator = ascendingSubMapEntrySet.descendingIterator();
11867            assertTrue(iterator.hasNext());
11868            for (value = 108; iterator.hasNext(); value--) {
11869                entry = (Entry) iterator.next();
11870                assertEquals(value, entry.getValue());
11871            }
11872            assertEquals(99, value);
11873        }
11874
11875        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11876        if (entrySet instanceof NavigableSet) {
11877            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11878            iterator = ascendingSubMapEntrySet.descendingIterator();
11879            assertTrue(iterator.hasNext());
11880            for (value = 109; iterator.hasNext(); value--) {
11881                entry = (Entry) iterator.next();
11882                assertEquals(value, entry.getValue());
11883            }
11884            assertEquals(99, value);
11885        }
11886
11887        String startKey = new Integer(2).toString();
11888        entrySet = tm.headMap(startKey, true).entrySet();
11889        if (entrySet instanceof NavigableSet) {
11890            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11891            iterator = ascendingSubMapEntrySet.descendingIterator();
11892            assertTrue(iterator.hasNext());
11893            assertEquals(2, ((Entry) iterator.next()).getValue());
11894        }
11895    }
11896
11897    public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() {
11898        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11899        if (entrySet instanceof NavigableSet) {
11900            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11901            for (int value = 101; value < 109; value++) {
11902                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11903                assertEquals(value, entry.getValue());
11904            }
11905            assertTrue(ascendingSubMapEntrySet.isEmpty());
11906            // should return null if the set is empty.
11907            assertNull(ascendingSubMapEntrySet.pollFirst());
11908        }
11909    }
11910
11911    public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() {
11912        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11913        if (entrySet instanceof NavigableSet) {
11914            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11915            for (int value = 101; value < 110; value++) {
11916                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11917                assertEquals(value, entry.getValue());
11918            }
11919            assertTrue(ascendingSubMapEntrySet.isEmpty());
11920            // should return null if the set is empty.
11921            assertNull(ascendingSubMapEntrySet.pollFirst());
11922        }
11923    }
11924
11925    public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() {
11926        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11927        if (entrySet instanceof NavigableSet) {
11928            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11929            for (int value = 100; value < 109; value++) {
11930                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11931                assertEquals(value, entry.getValue());
11932            }
11933            assertTrue(ascendingSubMapEntrySet.isEmpty());
11934            // should return null if the set is empty.
11935            assertNull(ascendingSubMapEntrySet.pollFirst());
11936        }
11937    }
11938
11939    public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endIncluded() {
11940        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11941        if (entrySet instanceof NavigableSet) {
11942            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11943            for (int value = 100; value < 110; value++) {
11944                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11945                assertEquals(value, entry.getValue());
11946            }
11947            assertTrue(ascendingSubMapEntrySet.isEmpty());
11948            // should return null if the set is empty.
11949            assertNull(ascendingSubMapEntrySet.pollFirst());
11950        }
11951    }
11952
11953    public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endExcluded() {
11954        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11955        if (entrySet instanceof NavigableSet) {
11956            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11957            for (int value = 108; value > 100; value--) {
11958                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
11959                assertEquals(value, entry.getValue());
11960            }
11961            assertTrue(ascendingSubMapEntrySet.isEmpty());
11962            // should return null if the set is empty
11963            assertNull(ascendingSubMapEntrySet.pollLast());
11964        }
11965
11966        // NavigableMap ascendingSubMap = tm.headMap("2", true);
11967        // Set entrySet = ascendingSubMap.entrySet();
11968        // Object last;
11969        // if (entrySet instanceof NavigableSet) {
11970        // last = ((NavigableSet) entrySet).pollLast();
11971        // assertEquals("2=2", last.toString());
11972        // }
11973        //
11974        // ascendingSubMap = tm.tailMap("2", true);
11975        // entrySet = ascendingSubMap.entrySet();
11976        // if (entrySet instanceof NavigableSet) {
11977        // last = ((NavigableSet) entrySet).pollLast();
11978        // assertEquals("999=999", last.toString());
11979        // }
11980    }
11981
11982    public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endIncluded() {
11983        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11984        if (entrySet instanceof NavigableSet) {
11985            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11986            for (int value = 109; value > 100; value--) {
11987                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
11988                assertEquals(value, entry.getValue());
11989            }
11990            assertTrue(ascendingSubMapEntrySet.isEmpty());
11991            // should return null if the set is empty
11992            assertNull(ascendingSubMapEntrySet.pollLast());
11993        }
11994    }
11995
11996    public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endExcluded() {
11997        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11998        if (entrySet instanceof NavigableSet) {
11999            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
12000            for (int value = 108; value > 99; value--) {
12001                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
12002                assertEquals(value, entry.getValue());
12003            }
12004            assertTrue(ascendingSubMapEntrySet.isEmpty());
12005            // should return null if the set is empty
12006            assertNull(ascendingSubMapEntrySet.pollLast());
12007        }
12008    }
12009
12010    public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endIncluded() {
12011        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12012        if (entrySet instanceof NavigableSet) {
12013            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
12014            for (int value = 109; value > 99; value--) {
12015                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
12016                assertEquals(value, entry.getValue());
12017            }
12018            assertTrue(ascendingSubMapEntrySet.isEmpty());
12019            // should return null if the set is empty
12020            assertNull(ascendingSubMapEntrySet.pollLast());
12021        }
12022    }
12023
12024    public void test_AscendingSubMapEntrySet_headSet() {
12025        Set entrySet, headSet;
12026        NavigableSet ascendingSubMapEntrySet;
12027        Iterator iterator, headSetIterator;
12028        Entry entry;
12029        int value;
12030
12031        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12032        if (entrySet instanceof NavigableSet) {
12033            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12034            iterator = ascendingSubMapEntrySet.iterator();
12035            while (iterator.hasNext()) {
12036                entry = (Entry) iterator.next();
12037                headSet = ascendingSubMapEntrySet.headSet(entry);
12038                headSetIterator = headSet.iterator();
12039                for (value = 101; headSetIterator.hasNext(); value++) {
12040                    assertEquals(value, ((Entry) headSetIterator.next())
12041                            .getValue());
12042                }
12043                assertEquals(entry.getValue(), value);
12044                try {
12045                    headSetIterator.next();
12046                    fail("should throw NoSuchElementException");
12047                } catch (NoSuchElementException e) {
12048                    // Expected
12049                }
12050
12051                headSet = ascendingSubMapEntrySet.headSet(entry, false);
12052                headSetIterator = headSet.iterator();
12053                for (value = 101; headSetIterator.hasNext(); value++) {
12054                    assertEquals(value, ((Entry) headSetIterator.next())
12055                            .getValue());
12056                }
12057                assertEquals(entry.getValue(), value);
12058                try {
12059                    headSetIterator.next();
12060                    fail("should throw NoSuchElementException");
12061                } catch (NoSuchElementException e) {
12062                    // Expected
12063                }
12064
12065                headSet = ascendingSubMapEntrySet.headSet(entry, true);
12066                headSetIterator = headSet.iterator();
12067                for (value = 101; headSetIterator.hasNext(); value++) {
12068                    assertEquals(value, ((Entry) headSetIterator.next())
12069                            .getValue());
12070                }
12071                assertEquals(entry.getValue(), value - 1);
12072                try {
12073                    headSetIterator.next();
12074                    fail("should throw NoSuchElementException");
12075                } catch (NoSuchElementException e) {
12076                    // Expected
12077                }
12078            }
12079        }
12080
12081        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12082        if (entrySet instanceof NavigableSet) {
12083            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12084            iterator = ascendingSubMapEntrySet.iterator();
12085            while (iterator.hasNext()) {
12086                entry = (Entry) iterator.next();
12087                headSet = ascendingSubMapEntrySet.headSet(entry);
12088                headSetIterator = headSet.iterator();
12089                for (value = 101; headSetIterator.hasNext(); value++) {
12090                    assertEquals(value, ((Entry) headSetIterator.next())
12091                            .getValue());
12092                }
12093                assertEquals(entry.getValue(), value);
12094                try {
12095                    headSetIterator.next();
12096                    fail("should throw NoSuchElementException");
12097                } catch (NoSuchElementException e) {
12098                    // Expected
12099                }
12100
12101                headSet = ascendingSubMapEntrySet.headSet(entry, false);
12102                headSetIterator = headSet.iterator();
12103                for (value = 101; headSetIterator.hasNext(); value++) {
12104                    assertEquals(value, ((Entry) headSetIterator.next())
12105                            .getValue());
12106                }
12107                assertEquals(entry.getValue(), value);
12108                try {
12109                    headSetIterator.next();
12110                    fail("should throw NoSuchElementException");
12111                } catch (NoSuchElementException e) {
12112                    // Expected
12113                }
12114
12115                headSet = ascendingSubMapEntrySet.headSet(entry, true);
12116                headSetIterator = headSet.iterator();
12117                for (value = 101; headSetIterator.hasNext(); value++) {
12118                    assertEquals(value, ((Entry) headSetIterator.next())
12119                            .getValue());
12120                }
12121                assertEquals(entry.getValue(), value - 1);
12122                try {
12123                    headSetIterator.next();
12124                    fail("should throw NoSuchElementException");
12125                } catch (NoSuchElementException e) {
12126                    // Expected
12127                }
12128            }
12129        }
12130
12131        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12132        if (entrySet instanceof NavigableSet) {
12133            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12134            iterator = ascendingSubMapEntrySet.iterator();
12135            while (iterator.hasNext()) {
12136                entry = (Entry) iterator.next();
12137                headSet = ascendingSubMapEntrySet.headSet(entry);
12138                headSetIterator = headSet.iterator();
12139                for (value = 100; headSetIterator.hasNext(); value++) {
12140                    assertEquals(value, ((Entry) headSetIterator.next())
12141                            .getValue());
12142                }
12143                assertEquals(entry.getValue(), value);
12144                try {
12145                    headSetIterator.next();
12146                    fail("should throw NoSuchElementException");
12147                } catch (NoSuchElementException e) {
12148                    // Expected
12149                }
12150
12151                headSet = ascendingSubMapEntrySet.headSet(entry, false);
12152                headSetIterator = headSet.iterator();
12153                for (value = 100; headSetIterator.hasNext(); value++) {
12154                    assertEquals(value, ((Entry) headSetIterator.next())
12155                            .getValue());
12156                }
12157                assertEquals(entry.getValue(), value);
12158                try {
12159                    headSetIterator.next();
12160                    fail("should throw NoSuchElementException");
12161                } catch (NoSuchElementException e) {
12162                    // Expected
12163                }
12164
12165                headSet = ascendingSubMapEntrySet.headSet(entry, true);
12166                headSetIterator = headSet.iterator();
12167                for (value = 100; headSetIterator.hasNext(); value++) {
12168                    assertEquals(value, ((Entry) headSetIterator.next())
12169                            .getValue());
12170                }
12171                assertEquals(entry.getValue(), value - 1);
12172                try {
12173                    headSetIterator.next();
12174                    fail("should throw NoSuchElementException");
12175                } catch (NoSuchElementException e) {
12176                    // Expected
12177                }
12178            }
12179        }
12180
12181        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12182        if (entrySet instanceof NavigableSet) {
12183            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12184            iterator = ascendingSubMapEntrySet.iterator();
12185            while (iterator.hasNext()) {
12186                entry = (Entry) iterator.next();
12187                headSet = ascendingSubMapEntrySet.headSet(entry);
12188                headSetIterator = headSet.iterator();
12189                for (value = 100; headSetIterator.hasNext(); value++) {
12190                    assertEquals(value, ((Entry) headSetIterator.next())
12191                            .getValue());
12192                }
12193                assertEquals(entry.getValue(), value);
12194                try {
12195                    headSetIterator.next();
12196                    fail("should throw NoSuchElementException");
12197                } catch (NoSuchElementException e) {
12198                    // Expected
12199                }
12200
12201                headSet = ascendingSubMapEntrySet.headSet(entry, false);
12202                headSetIterator = headSet.iterator();
12203                for (value = 100; headSetIterator.hasNext(); value++) {
12204                    assertEquals(value, ((Entry) headSetIterator.next())
12205                            .getValue());
12206                }
12207                assertEquals(entry.getValue(), value);
12208                try {
12209                    headSetIterator.next();
12210                    fail("should throw NoSuchElementException");
12211                } catch (NoSuchElementException e) {
12212                    // Expected
12213                }
12214
12215                headSet = ascendingSubMapEntrySet.headSet(entry, true);
12216                headSetIterator = headSet.iterator();
12217                for (value = 100; headSetIterator.hasNext(); value++) {
12218                    assertEquals(value, ((Entry) headSetIterator.next())
12219                            .getValue());
12220                }
12221                assertEquals(entry.getValue(), value - 1);
12222                try {
12223                    headSetIterator.next();
12224                    fail("should throw NoSuchElementException");
12225                } catch (NoSuchElementException e) {
12226                    // Expected
12227                }
12228            }
12229        }
12230
12231        // NavigableMap ascendingSubMap = tm.headMap("1", true);
12232        // entrySet = ascendingSubMap.entrySet();
12233        // if (entrySet instanceof SortedSet) {
12234        // Iterator it = entrySet.iterator();
12235        // it.next();
12236        // Object end = it.next();// 1=1
12237        // Set headSet = ((NavigableSet) entrySet).headSet(end);// inclusive
12238        // // false
12239        // assertEquals(1, headSet.size());
12240        // }
12241    }
12242
12243    public void test_AscendingSubMapEntrySet_tailSet() {
12244        Set entrySet, tailSet;
12245        NavigableSet ascendingSubMapEntrySet;
12246        Iterator iterator, tailSetIterator;
12247        Entry entry;
12248        int value;
12249
12250        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12251        if (entrySet instanceof NavigableSet) {
12252            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12253            iterator = entrySet.iterator();
12254            while (iterator.hasNext()) {
12255                entry = (Entry) iterator.next();
12256                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12257                tailSetIterator = tailSet.iterator();
12258                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12259                        .hasNext(); value++) {
12260                    assertEquals(value, ((Entry) tailSetIterator.next())
12261                            .getValue());
12262                }
12263                assertEquals(109, value);
12264                try {
12265                    tailSetIterator.next();
12266                    fail("should throw NoSuchElementException");
12267                } catch (NoSuchElementException e) {
12268                    // Expected
12269                }
12270
12271                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12272                tailSetIterator = tailSet.iterator();
12273                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12274                        .hasNext(); value++) {
12275                    assertEquals(value, ((Entry) tailSetIterator.next())
12276                            .getValue());
12277                }
12278                assertEquals(109, value);
12279                try {
12280                    tailSetIterator.next();
12281                    fail("should throw NoSuchElementException");
12282                } catch (NoSuchElementException e) {
12283                    // Expected
12284                }
12285
12286                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12287                tailSetIterator = tailSet.iterator();
12288                for (value = (Integer) entry.getValue(); tailSetIterator
12289                        .hasNext(); value++) {
12290                    assertEquals(value, ((Entry) tailSetIterator.next())
12291                            .getValue());
12292                }
12293                assertEquals(109, value);
12294                try {
12295                    tailSetIterator.next();
12296                    fail("should throw NoSuchElementException");
12297                } catch (NoSuchElementException e) {
12298                    // Expected
12299                }
12300            }
12301        }
12302
12303        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12304        if (entrySet instanceof NavigableSet) {
12305            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12306            iterator = entrySet.iterator();
12307            while (iterator.hasNext()) {
12308                entry = (Entry) iterator.next();
12309                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12310                tailSetIterator = tailSet.iterator();
12311                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12312                        .hasNext(); value++) {
12313                    assertEquals(value, ((Entry) tailSetIterator.next())
12314                            .getValue());
12315                }
12316                assertEquals(110, value);
12317                try {
12318                    tailSetIterator.next();
12319                    fail("should throw NoSuchElementException");
12320                } catch (NoSuchElementException e) {
12321                    // Expected
12322                }
12323
12324                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12325                tailSetIterator = tailSet.iterator();
12326                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12327                        .hasNext(); value++) {
12328                    assertEquals(value, ((Entry) tailSetIterator.next())
12329                            .getValue());
12330                }
12331                assertEquals(110, value);
12332                try {
12333                    tailSetIterator.next();
12334                    fail("should throw NoSuchElementException");
12335                } catch (NoSuchElementException e) {
12336                    // Expected
12337                }
12338
12339                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12340                tailSetIterator = tailSet.iterator();
12341                for (value = (Integer) entry.getValue(); tailSetIterator
12342                        .hasNext(); value++) {
12343                    assertEquals(value, ((Entry) tailSetIterator.next())
12344                            .getValue());
12345                }
12346                assertEquals(110, value);
12347                try {
12348                    tailSetIterator.next();
12349                    fail("should throw NoSuchElementException");
12350                } catch (NoSuchElementException e) {
12351                    // Expected
12352                }
12353            }
12354        }
12355
12356        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12357        if (entrySet instanceof NavigableSet) {
12358            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12359            iterator = entrySet.iterator();
12360            while (iterator.hasNext()) {
12361                entry = (Entry) iterator.next();
12362                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12363                tailSetIterator = tailSet.iterator();
12364                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12365                        .hasNext(); value++) {
12366                    assertEquals(value, ((Entry) tailSetIterator.next())
12367                            .getValue());
12368                }
12369                assertEquals(109, value);
12370                try {
12371                    tailSetIterator.next();
12372                    fail("should throw NoSuchElementException");
12373                } catch (NoSuchElementException e) {
12374                    // Expected
12375                }
12376
12377                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12378                tailSetIterator = tailSet.iterator();
12379                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12380                        .hasNext(); value++) {
12381                    assertEquals(value, ((Entry) tailSetIterator.next())
12382                            .getValue());
12383                }
12384                assertEquals(109, value);
12385                try {
12386                    tailSetIterator.next();
12387                    fail("should throw NoSuchElementException");
12388                } catch (NoSuchElementException e) {
12389                    // Expected
12390                }
12391
12392                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12393                tailSetIterator = tailSet.iterator();
12394                for (value = (Integer) entry.getValue(); tailSetIterator
12395                        .hasNext(); value++) {
12396                    assertEquals(value, ((Entry) tailSetIterator.next())
12397                            .getValue());
12398                }
12399                assertEquals(109, value);
12400                try {
12401                    tailSetIterator.next();
12402                    fail("should throw NoSuchElementException");
12403                } catch (NoSuchElementException e) {
12404                    // Expected
12405                }
12406            }
12407        }
12408
12409        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12410        if (entrySet instanceof NavigableSet) {
12411            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12412            iterator = entrySet.iterator();
12413            while (iterator.hasNext()) {
12414                entry = (Entry) iterator.next();
12415                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12416                tailSetIterator = tailSet.iterator();
12417                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12418                        .hasNext(); value++) {
12419                    assertEquals(value, ((Entry) tailSetIterator.next())
12420                            .getValue());
12421                }
12422                assertEquals(110, value);
12423                try {
12424                    tailSetIterator.next();
12425                    fail("should throw NoSuchElementException");
12426                } catch (NoSuchElementException e) {
12427                    // Expected
12428                }
12429
12430                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12431                tailSetIterator = tailSet.iterator();
12432                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12433                        .hasNext(); value++) {
12434                    assertEquals(value, ((Entry) tailSetIterator.next())
12435                            .getValue());
12436                }
12437                assertEquals(110, value);
12438                try {
12439                    tailSetIterator.next();
12440                    fail("should throw NoSuchElementException");
12441                } catch (NoSuchElementException e) {
12442                    // Expected
12443                }
12444
12445                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12446                tailSetIterator = tailSet.iterator();
12447                for (value = (Integer) entry.getValue(); tailSetIterator
12448                        .hasNext(); value++) {
12449                    assertEquals(value, ((Entry) tailSetIterator.next())
12450                            .getValue());
12451                }
12452                assertEquals(110, value);
12453                try {
12454                    tailSetIterator.next();
12455                    fail("should throw NoSuchElementException");
12456                } catch (NoSuchElementException e) {
12457                    // Expected
12458                }
12459            }
12460        }
12461
12462        // NavigableMap ascendingSubMap = tm.headMap("1", true);
12463        // Set entrySet = ascendingSubMap.entrySet();
12464        // if (entrySet instanceof NavigableSet) {
12465        // Iterator it = entrySet.iterator();
12466        // Object start = it.next();// 0=0
12467        // Set tailSet = ((NavigableSet) entrySet).tailSet(start);// default
12468        // // inclusive
12469        // // false
12470        // assertEquals(1, tailSet.size());
12471        // }
12472    }
12473
12474    public void test_AscendingSubMapEntrySet_subSet() {
12475        Set entrySet, subSet;
12476        NavigableSet ascendingSubMapEntrySet;
12477
12478        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12479        if (entrySet instanceof NavigableSet) {
12480            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12481            Iterator iteratorStart = ascendingSubMapEntrySet.iterator();
12482            while (iteratorStart.hasNext()) {
12483                Entry startEntry = (Entry) iteratorStart.next();
12484                Iterator iteratorEnd = ascendingSubMapEntrySet.iterator();
12485                while (iteratorEnd.hasNext()) {
12486                    Entry endEntry = (Entry) iteratorEnd.next();
12487                    int startIndex = (Integer) startEntry.getValue();
12488                    int endIndex = (Integer) endEntry.getValue();
12489                    if (startIndex > endIndex) {
12490                        try {
12491                            ascendingSubMapEntrySet
12492                                    .subSet(startEntry, endEntry);
12493                            fail("should throw IllegalArgumentException");
12494                        } catch (IllegalArgumentException e) {
12495                            // Expected
12496                        }
12497
12498                        try {
12499                            ascendingSubMapEntrySet.subSet(startEntry, false,
12500                                    endEntry, false);
12501                            fail("should throw IllegalArgumentException");
12502                        } catch (IllegalArgumentException e) {
12503                            // Expected
12504                        }
12505
12506                        try {
12507                            ascendingSubMapEntrySet.subSet(startEntry, false,
12508                                    endEntry, true);
12509                            fail("should throw IllegalArgumentException");
12510                        } catch (IllegalArgumentException e) {
12511                            // Expected
12512                        }
12513
12514                        try {
12515                            ascendingSubMapEntrySet.subSet(startEntry, true,
12516                                    endEntry, false);
12517                            fail("should throw IllegalArgumentException");
12518                        } catch (IllegalArgumentException e) {
12519                            // Expected
12520                        }
12521
12522                        try {
12523                            ascendingSubMapEntrySet.subSet(startEntry, true,
12524                                    endEntry, true);
12525                            fail("should throw IllegalArgumentException");
12526                        } catch (IllegalArgumentException e) {
12527                            // Expected
12528                        }
12529                    } else {
12530                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12531                                endEntry);
12532                        Iterator subSetIterator = subSet.iterator();
12533                        for (int index = startIndex + 1; subSetIterator
12534                                .hasNext(); index++) {
12535                            assertEquals(index, ((Entry) subSetIterator.next())
12536                                    .getValue());
12537                        }
12538
12539                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12540                                false, endEntry, false);
12541                        subSetIterator = subSet.iterator();
12542                        for (int index = startIndex + 1; subSetIterator
12543                                .hasNext(); index++) {
12544                            assertEquals(index, ((Entry) subSetIterator.next())
12545                                    .getValue());
12546                        }
12547
12548                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12549                                false, endEntry, true);
12550                        subSetIterator = subSet.iterator();
12551                        for (int index = startIndex + 1; subSetIterator
12552                                .hasNext(); index++) {
12553                            assertEquals(index, ((Entry) subSetIterator.next())
12554                                    .getValue());
12555                        }
12556
12557                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12558                                true, endEntry, false);
12559                        subSetIterator = subSet.iterator();
12560                        for (int index = startIndex; subSetIterator.hasNext(); index++) {
12561                            assertEquals(index, ((Entry) subSetIterator.next())
12562                                    .getValue());
12563                        }
12564
12565                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12566                                true, endEntry, true);
12567                        subSetIterator = subSet.iterator();
12568                        for (int index = startIndex; subSetIterator.hasNext(); index++) {
12569                            assertEquals(index, ((Entry) subSetIterator.next())
12570                                    .getValue());
12571                        }
12572                    }
12573                }
12574            }
12575        }
12576
12577        String endKey = new Integer(2).toString();
12578        entrySet = tm.headMap(endKey, true).entrySet();
12579        if (entrySet instanceof NavigableSet) {
12580            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12581            Iterator iterator = entrySet.iterator();
12582            Object startEntry = iterator.next();
12583            iterator.next();
12584            Object endEntry = iterator.next();
12585            subSet = ascendingSubMapEntrySet.subSet(startEntry, endEntry);
12586            assertEquals(1, subSet.size());
12587
12588            subSet = ascendingSubMapEntrySet.subSet(startEntry, false,
12589                    endEntry, false);
12590            assertEquals(1, subSet.size());
12591
12592            subSet = ascendingSubMapEntrySet.subSet(startEntry, false,
12593                    endEntry, true);
12594            assertEquals(2, subSet.size());
12595
12596            subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry,
12597                    false);
12598            assertEquals(2, subSet.size());
12599
12600            subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry,
12601                    true);
12602            assertEquals(3, subSet.size());
12603        }
12604    }
12605
12606    public void test_AscendingSubMapEntrySet_lower() {
12607        Set entrySet;
12608        NavigableSet ascendingSubMapEntrySet;
12609        Iterator iterator;
12610        Entry entry, lowerEntry;
12611        int value;
12612
12613        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12614        if (entrySet instanceof NavigableSet) {
12615            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12616            iterator = ascendingSubMapEntrySet.iterator();
12617            while (iterator.hasNext()) {
12618                entry = (Entry) iterator.next();
12619                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12620                value = (Integer) entry.getValue();
12621                if (value > 101) {
12622                    assertEquals(value - 1, lowerEntry.getValue());
12623                } else {
12624                    assertNull(lowerEntry);
12625                }
12626            }
12627        }
12628
12629        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12630        if (entrySet instanceof NavigableSet) {
12631            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12632            iterator = ascendingSubMapEntrySet.iterator();
12633            while (iterator.hasNext()) {
12634                entry = (Entry) iterator.next();
12635                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12636                value = (Integer) entry.getValue();
12637                if (value > 101) {
12638                    assertEquals(value - 1, lowerEntry.getValue());
12639                } else {
12640                    assertNull(lowerEntry);
12641                }
12642            }
12643        }
12644
12645        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12646        if (entrySet instanceof NavigableSet) {
12647            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12648            iterator = ascendingSubMapEntrySet.iterator();
12649            while (iterator.hasNext()) {
12650                entry = (Entry) iterator.next();
12651                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12652                value = (Integer) entry.getValue();
12653                if (value > 100) {
12654                    assertEquals(value - 1, lowerEntry.getValue());
12655                } else {
12656                    assertNull(lowerEntry);
12657                }
12658            }
12659        }
12660
12661        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12662        if (entrySet instanceof NavigableSet) {
12663            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12664            iterator = ascendingSubMapEntrySet.iterator();
12665            while (iterator.hasNext()) {
12666                entry = (Entry) iterator.next();
12667                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12668                value = (Integer) entry.getValue();
12669                if (value > 100) {
12670                    assertEquals(value - 1, lowerEntry.getValue());
12671                } else {
12672                    assertNull(lowerEntry);
12673                }
12674            }
12675        }
12676
12677        String endKey = new Integer(2).toString();
12678        entrySet = tm.headMap(endKey, true).entrySet();
12679        if (entrySet instanceof NavigableSet) {
12680            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12681            iterator = entrySet.iterator();
12682            Entry expectedEntry = (Entry) iterator.next();
12683            entry = (Entry) iterator.next();
12684            assertEquals(expectedEntry, ascendingSubMapEntrySet.lower(entry));
12685        }
12686
12687        // With Comparator
12688
12689        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
12690        if (entrySet instanceof NavigableSet) {
12691            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12692            iterator = ascendingSubMapEntrySet.iterator();
12693            while (iterator.hasNext()) {
12694                entry = (Entry) iterator.next();
12695                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12696                value = (Integer) entry.getValue();
12697                if (value > 101) {
12698                    assertEquals(value - 1, lowerEntry.getValue());
12699                } else {
12700                    assertNull(lowerEntry);
12701                }
12702            }
12703        }
12704
12705        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
12706        if (entrySet instanceof NavigableSet) {
12707            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12708            iterator = ascendingSubMapEntrySet.iterator();
12709            while (iterator.hasNext()) {
12710                entry = (Entry) iterator.next();
12711                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12712                value = (Integer) entry.getValue();
12713                if (value > 101) {
12714                    assertEquals(value - 1, lowerEntry.getValue());
12715                } else {
12716                    assertNull(lowerEntry);
12717                }
12718            }
12719        }
12720
12721        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
12722        if (entrySet instanceof NavigableSet) {
12723            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12724            iterator = ascendingSubMapEntrySet.iterator();
12725            while (iterator.hasNext()) {
12726                entry = (Entry) iterator.next();
12727                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12728                value = (Integer) entry.getValue();
12729                if (value > 100) {
12730                    assertEquals(value - 1, lowerEntry.getValue());
12731                } else {
12732                    assertNull(lowerEntry);
12733                }
12734            }
12735        }
12736
12737        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
12738        if (entrySet instanceof NavigableSet) {
12739            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12740            iterator = ascendingSubMapEntrySet.iterator();
12741            while (iterator.hasNext()) {
12742                entry = (Entry) iterator.next();
12743                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12744                value = (Integer) entry.getValue();
12745                if (value > 100) {
12746                    assertEquals(value - 1, lowerEntry.getValue());
12747                } else {
12748                    assertNull(lowerEntry);
12749                }
12750            }
12751        }
12752    }
12753
12754    public void test_AscendingSubMapEntrySet_higher() {
12755        Set entrySet;
12756        NavigableSet ascendingSubMapEntrySet;
12757        Iterator iterator;
12758        Entry entry, lowerEntry;
12759        int value;
12760
12761        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12762        if (entrySet instanceof NavigableSet) {
12763            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12764            iterator = ascendingSubMapEntrySet.iterator();
12765            while (iterator.hasNext()) {
12766                entry = (Entry) iterator.next();
12767                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12768                value = (Integer) entry.getValue();
12769                if (value < 108) {
12770                    assertEquals(value + 1, lowerEntry.getValue());
12771                } else {
12772                    assertNull(lowerEntry);
12773                }
12774            }
12775        }
12776
12777        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12778        if (entrySet instanceof NavigableSet) {
12779            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12780            iterator = ascendingSubMapEntrySet.iterator();
12781            while (iterator.hasNext()) {
12782                entry = (Entry) iterator.next();
12783                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12784                value = (Integer) entry.getValue();
12785                if (value < 109) {
12786                    assertEquals(value + 1, lowerEntry.getValue());
12787                } else {
12788                    assertNull(lowerEntry);
12789                }
12790            }
12791        }
12792
12793        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12794        if (entrySet instanceof NavigableSet) {
12795            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12796            iterator = ascendingSubMapEntrySet.iterator();
12797            while (iterator.hasNext()) {
12798                entry = (Entry) iterator.next();
12799                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12800                value = (Integer) entry.getValue();
12801                if (value < 108) {
12802                    assertEquals(value + 1, lowerEntry.getValue());
12803                } else {
12804                    assertNull(lowerEntry);
12805                }
12806            }
12807        }
12808
12809        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12810        if (entrySet instanceof NavigableSet) {
12811            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12812            iterator = ascendingSubMapEntrySet.iterator();
12813            while (iterator.hasNext()) {
12814                entry = (Entry) iterator.next();
12815                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12816                value = (Integer) entry.getValue();
12817                if (value < 109) {
12818                    assertEquals(value + 1, lowerEntry.getValue());
12819                } else {
12820                    assertNull(lowerEntry);
12821                }
12822            }
12823        }
12824
12825        String endKey = new Integer(2).toString();
12826        entrySet = tm.headMap(endKey, true).entrySet();
12827        if (entrySet instanceof NavigableSet) {
12828            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12829            iterator = entrySet.iterator();
12830            entry = (Entry) iterator.next();
12831            Entry expectedEntry = (Entry) iterator.next();
12832            assertEquals(expectedEntry, ascendingSubMapEntrySet.higher(entry));
12833        }
12834
12835        // With Comparator
12836        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
12837        if (entrySet instanceof NavigableSet) {
12838            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12839            iterator = ascendingSubMapEntrySet.iterator();
12840            while (iterator.hasNext()) {
12841                entry = (Entry) iterator.next();
12842                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12843                value = (Integer) entry.getValue();
12844                if (value < 108) {
12845                    assertEquals(value + 1, lowerEntry.getValue());
12846                } else {
12847                    assertNull(lowerEntry);
12848                }
12849            }
12850        }
12851
12852        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
12853        if (entrySet instanceof NavigableSet) {
12854            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12855            iterator = ascendingSubMapEntrySet.iterator();
12856            while (iterator.hasNext()) {
12857                entry = (Entry) iterator.next();
12858                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12859                value = (Integer) entry.getValue();
12860                if (value < 109) {
12861                    assertEquals(value + 1, lowerEntry.getValue());
12862                } else {
12863                    assertNull(lowerEntry);
12864                }
12865            }
12866        }
12867
12868        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
12869        if (entrySet instanceof NavigableSet) {
12870            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12871            iterator = ascendingSubMapEntrySet.iterator();
12872            while (iterator.hasNext()) {
12873                entry = (Entry) iterator.next();
12874                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12875                value = (Integer) entry.getValue();
12876                if (value < 108) {
12877                    assertEquals(value + 1, lowerEntry.getValue());
12878                } else {
12879                    assertNull(lowerEntry);
12880                }
12881            }
12882        }
12883
12884        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
12885        if (entrySet instanceof NavigableSet) {
12886            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12887            iterator = ascendingSubMapEntrySet.iterator();
12888            while (iterator.hasNext()) {
12889                entry = (Entry) iterator.next();
12890                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12891                value = (Integer) entry.getValue();
12892                if (value < 109) {
12893                    assertEquals(value + 1, lowerEntry.getValue());
12894                } else {
12895                    assertNull(lowerEntry);
12896                }
12897            }
12898        }
12899    }
12900
12901    public void test_AscendingSubMapEntrySet_ceiling() {
12902        Set entrySet;
12903        NavigableSet ascendingSubMapEntrySet;
12904        Iterator iterator;
12905
12906        Set entrySet_beyondBound;
12907        Iterator iterator_beyondBound;
12908        Entry beyondBoundEntry;
12909
12910        Entry entry, lowerEntry;
12911        int value = 0;
12912
12913        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12914        if (entrySet instanceof NavigableSet) {
12915            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12916            try {
12917                ascendingSubMapEntrySet.ceiling(null);
12918                fail("should throw NullPointerException");
12919            } catch (NullPointerException e) {
12920                // Expected
12921            }
12922
12923            iterator = ascendingSubMapEntrySet.iterator();
12924            while (iterator.hasNext()) {
12925                entry = (Entry) iterator.next();
12926                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12927                value = (Integer) entry.getValue();
12928                assertEquals(value, lowerEntry.getValue());
12929            }
12930            assertEquals(108, value);
12931
12932        }
12933
12934        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12935        if (entrySet instanceof NavigableSet) {
12936            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12937            try {
12938                ascendingSubMapEntrySet.ceiling(null);
12939                fail("should throw NullPointerException");
12940            } catch (NullPointerException e) {
12941                // Expected
12942            }
12943
12944            iterator = ascendingSubMapEntrySet.iterator();
12945            while (iterator.hasNext()) {
12946                entry = (Entry) iterator.next();
12947                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12948                value = (Integer) entry.getValue();
12949                assertEquals(value, lowerEntry.getValue());
12950            }
12951            assertEquals(109, value);
12952        }
12953
12954        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12955        if (entrySet instanceof NavigableSet) {
12956            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12957            try {
12958                ascendingSubMapEntrySet.ceiling(null);
12959                fail("should throw NullPointerException");
12960            } catch (NullPointerException e) {
12961                // Expected
12962            }
12963
12964            iterator = ascendingSubMapEntrySet.iterator();
12965            while (iterator.hasNext()) {
12966                entry = (Entry) iterator.next();
12967                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12968                value = (Integer) entry.getValue();
12969                assertEquals(value, lowerEntry.getValue());
12970            }
12971            assertEquals(108, value);
12972        }
12973
12974        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12975        if (entrySet instanceof NavigableSet) {
12976            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12977            try {
12978                ascendingSubMapEntrySet.ceiling(null);
12979                fail("should throw NullPointerException");
12980            } catch (NullPointerException e) {
12981                // Expected
12982            }
12983
12984            iterator = ascendingSubMapEntrySet.iterator();
12985            while (iterator.hasNext()) {
12986                entry = (Entry) iterator.next();
12987                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12988                value = (Integer) entry.getValue();
12989                assertEquals(value, lowerEntry.getValue());
12990            }
12991            assertEquals(109, value);
12992        }
12993
12994        // With Comparator
12995        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
12996        if (entrySet instanceof NavigableSet) {
12997            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12998            try {
12999                ascendingSubMapEntrySet.ceiling(null);
13000                fail("should throw NullPointerException");
13001            } catch (NullPointerException e) {
13002                // Expected
13003            }
13004
13005            iterator = ascendingSubMapEntrySet.iterator();
13006            while (iterator.hasNext()) {
13007                entry = (Entry) iterator.next();
13008                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
13009                value = (Integer) entry.getValue();
13010                assertEquals(value, lowerEntry.getValue());
13011            }
13012            assertEquals(109, value);
13013        }
13014
13015        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
13016        if (entrySet instanceof NavigableSet) {
13017            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13018            try {
13019                ascendingSubMapEntrySet.ceiling(null);
13020                fail("should throw NullPointerException");
13021            } catch (NullPointerException e) {
13022                // Expected
13023            }
13024
13025            iterator = ascendingSubMapEntrySet.iterator();
13026            while (iterator.hasNext()) {
13027                entry = (Entry) iterator.next();
13028                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
13029                value = (Integer) entry.getValue();
13030                assertEquals(value, lowerEntry.getValue());
13031            }
13032            assertEquals(108, value);
13033        }
13034
13035        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
13036        if (entrySet instanceof NavigableSet) {
13037            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13038            try {
13039                ascendingSubMapEntrySet.ceiling(null);
13040                fail("should throw NullPointerException");
13041            } catch (NullPointerException e) {
13042                // Expected
13043            }
13044
13045            iterator = ascendingSubMapEntrySet.iterator();
13046            while (iterator.hasNext()) {
13047                entry = (Entry) iterator.next();
13048                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
13049                value = (Integer) entry.getValue();
13050                assertEquals(value, lowerEntry.getValue());
13051            }
13052            assertEquals(109, value);
13053        }
13054
13055        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
13056        if (entrySet instanceof NavigableSet) {
13057            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13058            try {
13059                ascendingSubMapEntrySet.ceiling(null);
13060                fail("should throw NullPointerException");
13061            } catch (NullPointerException e) {
13062                // Expected
13063            }
13064
13065            iterator = ascendingSubMapEntrySet.iterator();
13066            while (iterator.hasNext()) {
13067                entry = (Entry) iterator.next();
13068                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
13069                value = (Integer) entry.getValue();
13070                assertEquals(value, lowerEntry.getValue());
13071            }
13072            assertEquals(108, value);
13073        }
13074    }
13075
13076    public void test_AscendingSubMapEntrySet_floor() {
13077        Set entrySet;
13078        NavigableSet ascendingSubMapEntrySet;
13079        Iterator iterator;
13080        Entry entry, floorEntry;
13081        int value;
13082
13083        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
13084        if (entrySet instanceof NavigableSet) {
13085            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13086            try {
13087                ascendingSubMapEntrySet.floor(null);
13088                fail("should throw NullPointerException");
13089            } catch (NullPointerException e) {
13090                // Expected
13091            }
13092
13093            iterator = ascendingSubMapEntrySet.iterator();
13094            for (int i = 101; i < 109; i++) {
13095                entry = (Entry) iterator.next();
13096                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13097                assertEquals(entry.getValue(), floorEntry.getValue());
13098            }
13099            assertFalse(iterator.hasNext());
13100        }
13101
13102        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
13103        if (entrySet instanceof NavigableSet) {
13104            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13105            try {
13106                ascendingSubMapEntrySet.floor(null);
13107                fail("should throw NullPointerException");
13108            } catch (NullPointerException e) {
13109                // Expected
13110            }
13111
13112            iterator = ascendingSubMapEntrySet.iterator();
13113            for (int i = 101; i < 110; i++) {
13114                entry = (Entry) iterator.next();
13115                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13116                assertEquals(entry.getValue(), floorEntry.getValue());
13117            }
13118            assertFalse(iterator.hasNext());
13119        }
13120
13121        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
13122        if (entrySet instanceof NavigableSet) {
13123            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13124            try {
13125                ascendingSubMapEntrySet.floor(null);
13126                fail("should throw NullPointerException");
13127            } catch (NullPointerException e) {
13128                // Expected
13129            }
13130
13131            iterator = ascendingSubMapEntrySet.iterator();
13132            for (int i = 100; i < 109; i++) {
13133                entry = (Entry) iterator.next();
13134                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13135                assertEquals(entry.getValue(), floorEntry.getValue());
13136            }
13137            assertFalse(iterator.hasNext());
13138        }
13139
13140        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
13141        if (entrySet instanceof NavigableSet) {
13142            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13143            try {
13144                ascendingSubMapEntrySet.floor(null);
13145                fail("should throw NullPointerException");
13146            } catch (NullPointerException e) {
13147                // Expected
13148            }
13149
13150            iterator = ascendingSubMapEntrySet.iterator();
13151            for (int i = 100; i < 110; i++) {
13152                entry = (Entry) iterator.next();
13153                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13154                assertEquals(entry.getValue(), floorEntry.getValue());
13155            }
13156            assertFalse(iterator.hasNext());
13157        }
13158
13159        // With Comparator
13160        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
13161        if (entrySet instanceof NavigableSet) {
13162            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13163            try {
13164                ascendingSubMapEntrySet.floor(null);
13165                fail("should throw NullPointerException");
13166            } catch (NullPointerException e) {
13167                // Expected
13168            }
13169
13170            iterator = ascendingSubMapEntrySet.iterator();
13171            for (int i = 101; i < 109; i++) {
13172                entry = (Entry) iterator.next();
13173                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13174                assertEquals(entry.getValue(), floorEntry.getValue());
13175            }
13176            assertFalse(iterator.hasNext());
13177        }
13178
13179        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
13180        if (entrySet instanceof NavigableSet) {
13181            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13182            try {
13183                ascendingSubMapEntrySet.floor(null);
13184                fail("should throw NullPointerException");
13185            } catch (NullPointerException e) {
13186                // Expected
13187            }
13188
13189            iterator = ascendingSubMapEntrySet.iterator();
13190            for (int i = 101; i < 110; i++) {
13191                entry = (Entry) iterator.next();
13192                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13193                assertEquals(entry.getValue(), floorEntry.getValue());
13194            }
13195            assertFalse(iterator.hasNext());
13196        }
13197
13198        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
13199        if (entrySet instanceof NavigableSet) {
13200            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13201            try {
13202                ascendingSubMapEntrySet.floor(null);
13203                fail("should throw NullPointerException");
13204            } catch (NullPointerException e) {
13205                // Expected
13206            }
13207
13208            iterator = ascendingSubMapEntrySet.iterator();
13209            for (int i = 100; i < 109; i++) {
13210                entry = (Entry) iterator.next();
13211                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13212                assertEquals(entry.getValue(), floorEntry.getValue());
13213            }
13214            assertFalse(iterator.hasNext());
13215        }
13216
13217        entrySet = subMap_startIncluded_endIncluded.entrySet();
13218        if (entrySet instanceof NavigableSet) {
13219            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13220            try {
13221                ascendingSubMapEntrySet.floor(null);
13222                fail("should throw NullPointerException");
13223            } catch (NullPointerException e) {
13224                // Expected
13225            }
13226
13227            iterator = ascendingSubMapEntrySet.iterator();
13228            for (int i = 100; i < 110; i++) {
13229                entry = (Entry) iterator.next();
13230                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13231                assertEquals(entry.getValue(), floorEntry.getValue());
13232            }
13233            assertFalse(iterator.hasNext());
13234        }
13235    }
13236
13237    @Override
13238    protected void setUp() {
13239        tm = new TreeMap();
13240        tm_comparator = new TreeMap(new MockComparator());
13241        for (int i = 0; i < objArray.length; i++) {
13242            Object x = objArray[i] = new Integer(i);
13243            tm.put(x.toString(), x);
13244            tm_comparator.put(x.toString(), x);
13245        }
13246
13247        subMap_default = tm.subMap(objArray[100].toString(), objArray[109]
13248                .toString());
13249        subMap_startExcluded_endExcluded = tm.subMap(objArray[100].toString(),
13250                false, objArray[109].toString(), false);
13251        subMap_startExcluded_endIncluded = tm.subMap(objArray[100].toString(),
13252                false, objArray[109].toString(), true);
13253        subMap_startIncluded_endExcluded = tm.subMap(objArray[100].toString(),
13254                true, objArray[109].toString(), false);
13255        subMap_startIncluded_endIncluded = tm.subMap(objArray[100].toString(),
13256                true, objArray[109].toString(), true);
13257
13258        subMap_default_beforeStart_100 = tm.subMap(objArray[0].toString(),
13259                objArray[1].toString());
13260
13261        subMap_default_afterEnd_109 = tm.subMap(objArray[110].toString(),
13262                objArray[119].toString());
13263
13264        assertTrue(subMap_startExcluded_endExcluded instanceof NavigableMap);
13265        assertTrue(subMap_startExcluded_endIncluded instanceof NavigableMap);
13266        assertTrue(subMap_startIncluded_endExcluded instanceof NavigableMap);
13267        assertTrue(subMap_startIncluded_endIncluded instanceof NavigableMap);
13268
13269        navigableMap_startExcluded_endExcluded = (NavigableMap) subMap_startExcluded_endExcluded;
13270        navigableMap_startExcluded_endIncluded = (NavigableMap) subMap_startExcluded_endIncluded;
13271        navigableMap_startIncluded_endExcluded = (NavigableMap) subMap_startIncluded_endExcluded;
13272        navigableMap_startIncluded_endIncluded = (NavigableMap) subMap_startIncluded_endIncluded;
13273
13274        subMap_default_comparator = tm_comparator.subMap(objArray[100]
13275                .toString(), objArray[109].toString());
13276        subMap_startExcluded_endExcluded_comparator = tm_comparator.subMap(
13277                objArray[100].toString(), false, objArray[109].toString(),
13278                false);
13279
13280        subMap_startExcluded_endIncluded_comparator = tm_comparator
13281                .subMap(objArray[100].toString(), false, objArray[109]
13282                        .toString(), true);
13283        subMap_startIncluded_endExcluded_comparator = tm_comparator
13284                .subMap(objArray[100].toString(), true, objArray[109]
13285                        .toString(), false);
13286        subMap_startIncluded_endIncluded_comparator = tm_comparator.subMap(
13287                objArray[100].toString(), true, objArray[109].toString(), true);
13288    }
13289
13290    @Override
13291    protected void tearDown() {
13292        tm = null;
13293        tm_comparator = null;
13294
13295        subMap_default = null;
13296        subMap_startExcluded_endExcluded = null;
13297        subMap_startExcluded_endIncluded = null;
13298        subMap_startIncluded_endExcluded = null;
13299        subMap_startIncluded_endIncluded = null;
13300
13301        subMap_default_beforeStart_100 = null;
13302        subMap_default_afterEnd_109 = null;
13303
13304        subMap_default_comparator = null;
13305        subMap_startExcluded_endExcluded_comparator = null;
13306        subMap_startExcluded_endIncluded_comparator = null;
13307        subMap_startIncluded_endExcluded_comparator = null;
13308        subMap_startIncluded_endIncluded_comparator = null;
13309    }
13310
13311    public void test_lower_null() throws Exception {
13312        NavigableMap map = tm.subMap(objArray[100].toString(), true,
13313                objArray[100].toString(), false);
13314        assertNull(map.ceilingKey(objArray[100].toString()));
13315        assertNull(map.floorKey(objArray[100].toString()));
13316        assertNull(map.lowerKey(objArray[100].toString()));
13317        assertNull(map.higherKey(objArray[100].toString()));
13318        assertNull(map.ceilingKey(objArray[111].toString()));
13319        assertNull(map.floorKey(objArray[111].toString()));
13320        assertNull(map.lowerKey(objArray[111].toString()));
13321        assertNull(map.higherKey(objArray[111].toString()));
13322        assertNull(map.ceilingKey(objArray[1].toString()));
13323        assertNull(map.floorKey(objArray[1].toString()));
13324        assertNull(map.lowerKey(objArray[1].toString()));
13325        assertNull(map.higherKey(objArray[1].toString()));
13326        map = map.descendingMap();
13327        assertNull(map.ceilingKey(objArray[100].toString()));
13328        assertNull(map.floorKey(objArray[100].toString()));
13329        assertNull(map.lowerKey(objArray[100].toString()));
13330        assertNull(map.higherKey(objArray[100].toString()));
13331        assertNull(map.ceilingKey(objArray[111].toString()));
13332        assertNull(map.floorKey(objArray[111].toString()));
13333        assertNull(map.lowerKey(objArray[111].toString()));
13334        assertNull(map.higherKey(objArray[111].toString()));
13335        assertNull(map.ceilingKey(objArray[1].toString()));
13336        assertNull(map.floorKey(objArray[1].toString()));
13337        assertNull(map.lowerKey(objArray[1].toString()));
13338        assertNull(map.higherKey(objArray[1].toString()));
13339    }
13340
13341    public void test_lower_tail() throws Exception {
13342        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13343                objArray[103].toString(), false);
13344        assertTrue(map.containsKey(objArray[102].toString()));
13345        assertFalse(map.containsKey(objArray[101].toString()));
13346        assertFalse(map.containsKey(objArray[103].toString()));
13347        assertFalse(map.containsKey(objArray[104].toString()));
13348        map = map.descendingMap();
13349        assertTrue(map.containsKey(objArray[102].toString()));
13350        assertFalse(map.containsKey(objArray[101].toString()));
13351        assertFalse(map.containsKey(objArray[103].toString()));
13352        assertFalse(map.containsKey(objArray[104].toString()));
13353        map = tm.subMap(objArray[102].toString(), true, objArray[102]
13354                .toString(), false);
13355        assertFalse(map.containsKey(objArray[102].toString()));
13356        assertFalse(map.containsKey(objArray[101].toString()));
13357        assertFalse(map.containsKey(objArray[103].toString()));
13358        assertFalse(map.containsKey(objArray[104].toString()));
13359        map = map.descendingMap();
13360        assertFalse(map.containsKey(objArray[102].toString()));
13361        assertFalse(map.containsKey(objArray[101].toString()));
13362        assertFalse(map.containsKey(objArray[103].toString()));
13363        assertFalse(map.containsKey(objArray[104].toString()));
13364    }
13365
13366    public void test_contains_null() throws Exception {
13367        NavigableMap map = tm.subMap(objArray[100].toString(), true,
13368                objArray[100].toString(), false);
13369        assertFalse(map.containsKey(objArray[100].toString()));
13370        assertFalse(map.containsKey(objArray[10].toString()));
13371        assertFalse(map.containsKey(objArray[101].toString()));
13372        assertFalse(map.containsKey(objArray[102].toString()));
13373        assertFalse(map.containsKey(objArray[1].toString()));
13374        map = map.descendingMap();
13375        assertFalse(map.containsKey(objArray[100].toString()));
13376        assertFalse(map.containsKey(objArray[10].toString()));
13377        assertFalse(map.containsKey(objArray[101].toString()));
13378        assertFalse(map.containsKey(objArray[102].toString()));
13379        assertFalse(map.containsKey(objArray[1].toString()));
13380    }
13381
13382    public void test_contains() throws Exception {
13383        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13384                objArray[103].toString(), false);
13385        assertFalse(map.containsKey(objArray[100].toString()));
13386        assertFalse(map.containsKey(objArray[104].toString()));
13387        assertFalse(map.containsKey(objArray[101].toString()));
13388        assertTrue(map.containsKey(objArray[102].toString()));
13389        map = map.descendingMap();
13390        assertFalse(map.containsKey(objArray[100].toString()));
13391        assertFalse(map.containsKey(objArray[104].toString()));
13392        assertFalse(map.containsKey(objArray[101].toString()));
13393        assertTrue(map.containsKey(objArray[102].toString()));
13394    }
13395
13396    public void test_size() throws Exception {
13397        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13398                objArray[103].toString(), false);
13399        assertEquals(0, map.headMap(objArray[102].toString(), false).size());
13400        assertEquals(1, map.headMap(objArray[102].toString(), true).size());
13401        try {
13402            assertEquals(1, map.headMap(objArray[103].toString(), true).size());
13403            fail("should throw IAE");
13404        } catch (IllegalArgumentException e) {
13405        }
13406        assertEquals(1, map.headMap(objArray[103].toString(), false).size());
13407        assertEquals(1, map.tailMap(objArray[102].toString(), true).size());
13408        assertEquals(0, map.tailMap(objArray[102].toString(), false).size());
13409        assertTrue(map.headMap(objArray[103].toString(), false).containsKey(
13410                objArray[102].toString()));
13411        try {
13412            assertTrue(map.headMap(objArray[103].toString(), true).containsKey(
13413                    objArray[102].toString()));
13414            fail("should throw IAE");
13415        } catch (IllegalArgumentException e) {
13416        }
13417        assertFalse(map.headMap(objArray[102].toString(), false).containsKey(
13418                objArray[102].toString()));
13419        assertTrue(map.headMap(objArray[102].toString(), true).containsKey(
13420                objArray[102].toString()));
13421        assertTrue(map.tailMap(objArray[102].toString(), true).containsKey(
13422                objArray[102].toString()));
13423        assertFalse(map.tailMap(objArray[102].toString(), true).containsKey(
13424                objArray[103].toString()));
13425        try {
13426            assertEquals(0, map.tailMap(objArray[101].toString()).size());
13427            fail("should throw IAE");
13428        } catch (IllegalArgumentException e) {
13429        }
13430        map = map.descendingMap();
13431        try {
13432            map = map.subMap(objArray[103].toString(), true, objArray[102]
13433                    .toString(), true);
13434            fail("should throw IAE");
13435        } catch (IllegalArgumentException e) {
13436        }
13437        map = map.subMap(objArray[102].toString(), true, objArray[102]
13438                .toString(), true);
13439        assertEquals(1, map.headMap(objArray[102].toString(), true).size());
13440        assertEquals(0, map.headMap(objArray[102].toString(), false).size());
13441        try {
13442            assertEquals(0, map.headMap(objArray[103].toString(), true).size());
13443            fail("should throw IAE");
13444        } catch (IllegalArgumentException e) {
13445        }
13446
13447        assertEquals(1, map.tailMap(objArray[102].toString(), true).size());
13448        try {
13449            assertFalse(map.headMap(objArray[103].toString(), true)
13450                    .containsKey(objArray[102].toString()));
13451            fail("should throw IAE");
13452        } catch (IllegalArgumentException e) {
13453        }
13454        assertTrue(map.headMap(objArray[102].toString(), true).containsKey(
13455                objArray[102].toString()));
13456        assertFalse(map.headMap(objArray[102].toString(), false).containsKey(
13457                objArray[102].toString()));
13458        assertTrue(map.tailMap(objArray[102].toString(), true).containsKey(
13459                objArray[102].toString()));
13460        assertFalse(map.tailMap(objArray[102].toString(), true).containsKey(
13461                objArray[103].toString()));
13462        try {
13463            assertEquals(0, map.tailMap(objArray[101].toString()).size());
13464            fail("should throw IAE");
13465        } catch (IllegalArgumentException e) {
13466        }
13467    }
13468
13469    public void test_lower() throws Exception {
13470        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13471                objArray[103].toString(), false);
13472        assertEquals(objArray[102].toString(), map.higherKey(objArray[101]
13473                .toString()));
13474        assertEquals(null, map.higherKey(objArray[102].toString()));
13475        assertEquals(null, map.higherKey(objArray[103].toString()));
13476        assertEquals(null, map.higherKey(objArray[104].toString()));
13477        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[101]
13478                .toString()));
13479        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102]
13480                .toString()));
13481        assertEquals(null, map.ceilingKey(objArray[103].toString()));
13482        assertEquals(null, map.ceilingKey(objArray[104].toString()));
13483        assertEquals(null, map.lowerKey(objArray[101].toString()));
13484        assertEquals(null, map.lowerKey(objArray[102].toString()));
13485        assertEquals(objArray[102].toString(), map.lowerKey(objArray[103]
13486                .toString()));
13487        assertEquals(objArray[102].toString(), map.lowerKey(objArray[104]
13488                .toString()));
13489        assertEquals(null, map.floorKey(objArray[101].toString()));
13490        assertEquals(objArray[102].toString(), map.floorKey(objArray[102]
13491                .toString()));
13492        assertEquals(objArray[102].toString(), map.floorKey(objArray[103]
13493                .toString()));
13494        assertEquals(objArray[102].toString(), map.floorKey(objArray[104]
13495                .toString()));
13496        map = map.descendingMap();
13497        assertEquals(null, map.higherKey(objArray[101].toString()));
13498        assertEquals(null, map.higherKey(objArray[102].toString()));
13499        assertEquals(objArray[102].toString(), map.higherKey(objArray[103]
13500                .toString()));
13501        assertEquals(objArray[102].toString(), map.higherKey(objArray[104]
13502                .toString()));
13503        assertEquals(null, map.ceilingKey(objArray[101].toString()));
13504        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102]
13505                .toString()));
13506        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[103]
13507                .toString()));
13508        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[104]
13509                .toString()));
13510        assertEquals(objArray[102].toString(), map.lowerKey(objArray[101]
13511                .toString()));
13512        assertEquals(null, map.lowerKey(objArray[102].toString()));
13513        assertEquals(null, map.lowerKey(objArray[103].toString()));
13514        assertEquals(null, map.lowerKey(objArray[104].toString()));
13515        assertEquals(objArray[102].toString(), map.floorKey(objArray[101]
13516                .toString()));
13517        assertEquals(objArray[102].toString(), map.floorKey(objArray[102]
13518                .toString()));
13519        assertEquals(null, map.floorKey(objArray[103].toString()));
13520        assertEquals(null, map.floorKey(objArray[104].toString()));
13521    }
13522
13523    public void test_lowerkey() throws Exception {
13524        try {
13525            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13526                    false).descendingMap().firstKey();
13527            fail("should throw NoSuchElementException");
13528        } catch (Exception e) {
13529            // expected
13530        }
13531        try {
13532            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13533                    false).descendingMap().lastKey();
13534            fail("should throw NoSuchElementException");
13535        } catch (Exception e) {
13536            // expected
13537        }
13538        try {
13539            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13540                    false).firstKey();
13541            fail("should throw NoSuchElementException");
13542        } catch (Exception e) {
13543            // expected
13544        }
13545        try {
13546            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13547                    false).lastKey();
13548            fail("should throw NoSuchElementException");
13549        } catch (Exception e) {
13550            // expected
13551        }
13552
13553    }
13554
13555    public void test_headMap() throws Exception {
13556        TreeMap tree = new TreeMap();
13557        tree.put(new Integer(0), null);
13558        tree.put(new Integer(1), null);
13559        Map submap = tree.subMap(tree.firstKey(), tree.lastKey());
13560        tree.remove(tree.lastKey());
13561        assertEquals(submap, tree);
13562    }
13563
13564    public void testname() throws Exception {
13565        TreeMap nullTree = new TreeMap(new Comparator() {
13566            public int compare(Object o1, Object o2) {
13567                if (o1 == null) {
13568                    return o2 == null ? 0 : -1;
13569                }
13570                return ((String) o1).compareTo((String) o2);
13571            }
13572        });
13573        nullTree.put(new String("One"), 1);
13574        nullTree.put(new String("Two"), 2);
13575        nullTree.put(new String("Three"), 3);
13576        nullTree.put(new String("Four"), 4);
13577        nullTree.put(null, 0);
13578        nullTree.subMap(null, "two").size();
13579    }
13580
13581}
13582