1package org.apache.harmony.luni.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 java.util.Collection;
21import java.util.Collections;
22import java.util.Comparator;
23import java.util.Iterator;
24import java.util.Map;
25import java.util.NavigableMap;
26import java.util.NavigableSet;
27import java.util.NoSuchElementException;
28import java.util.Set;
29import java.util.SortedMap;
30import java.util.SortedSet;
31import java.util.TreeMap;
32import java.util.Map.Entry;
33
34import junit.framework.TestCase;
35
36import org.apache.harmony.luni.tests.java.util.TreeMapTest.MockComparator;
37
38//
39public class TreeMapExtendTest extends TestCase {
40
41    TreeMap tm;
42
43    TreeMap tm_comparator;
44
45    SortedMap subMap_default;
46
47    SortedMap subMap_startExcluded_endExcluded;
48
49    SortedMap subMap_startExcluded_endIncluded;
50
51    SortedMap subMap_startIncluded_endExcluded;
52
53    SortedMap subMap_startIncluded_endIncluded;
54
55    SortedMap subMap_default_beforeStart_100;
56
57    SortedMap subMap_default_afterEnd_109;
58
59    NavigableMap navigableMap_startExcluded_endExcluded;
60
61    NavigableMap navigableMap_startExcluded_endIncluded;
62
63    NavigableMap navigableMap_startIncluded_endExcluded;
64
65    NavigableMap navigableMap_startIncluded_endIncluded;
66
67    SortedMap subMap_default_comparator;
68
69    SortedMap subMap_startExcluded_endExcluded_comparator;
70
71    SortedMap subMap_startExcluded_endIncluded_comparator;
72
73    SortedMap subMap_startIncluded_endExcluded_comparator;
74
75    SortedMap subMap_startIncluded_endIncluded_comparator;
76
77    Object objArray[] = new Object[1000];
78
79    public void test_TreeMap_Constructor_Default() {
80        TreeMap treeMap = new TreeMap();
81        assertTrue(treeMap.isEmpty());
82        assertNull(treeMap.comparator());
83        assertEquals(0, treeMap.size());
84
85        try {
86            treeMap.firstKey();
87            fail("should throw NoSuchElementException");
88        } catch (NoSuchElementException e) {
89            // Expected
90        }
91        assertNull(treeMap.firstEntry());
92
93        try {
94            treeMap.lastKey();
95            fail("should throw NoSuchElementException");
96        } catch (NoSuchElementException e) {
97            // Expected
98        }
99        assertNull(treeMap.lastEntry());
100
101        try {
102            treeMap.ceilingKey(1);
103        } catch (NoSuchElementException e) {
104            // Expected
105        }
106        assertNull(treeMap.ceilingEntry(1));
107
108        try {
109            treeMap.floorKey(1);
110        } catch (NoSuchElementException e) {
111            // Expected
112        }
113        assertNull(treeMap.floorEntry(1));
114        assertNull(treeMap.lowerKey(1));
115        assertNull(treeMap.lowerEntry(1));
116        assertNull(treeMap.higherKey(1));
117        assertNull(treeMap.higherEntry(1));
118        assertFalse(treeMap.containsKey(1));
119        assertFalse(treeMap.containsValue(1));
120        assertNull(treeMap.get(1));
121
122        assertNull(treeMap.pollFirstEntry());
123        assertNull(treeMap.pollLastEntry());
124        assertEquals(0, treeMap.values().size());
125    }
126
127    public void test_TreeMap_Constructor_Comparator() {
128        MockComparator mockComparator = new MockComparator();
129        TreeMap treeMap = new TreeMap(mockComparator);
130
131        assertEquals(mockComparator, treeMap.comparator());
132    }
133
134    public void test_TreeMap_Constructor_Map() {
135        TreeMap treeMap = new TreeMap(tm);
136        assertEquals(tm.size(), treeMap.size());
137        assertEquals(tm.firstKey(), treeMap.firstKey());
138        assertEquals(tm.firstEntry(), treeMap.firstEntry());
139        assertEquals(tm.lastKey(), treeMap.lastKey());
140        assertEquals(tm.lastEntry(), treeMap.lastEntry());
141        assertEquals(tm.keySet(), treeMap.keySet());
142
143        String key = new Integer(100).toString();
144        assertEquals(tm.ceilingKey(key), treeMap.ceilingKey(key));
145        assertEquals(tm.ceilingEntry(key), treeMap.ceilingEntry(key));
146        assertEquals(tm.floorKey(key), treeMap.floorKey(key));
147        assertEquals(tm.floorEntry(key), treeMap.floorEntry(key));
148        assertEquals(tm.lowerKey(key), treeMap.lowerKey(key));
149        assertEquals(tm.lowerEntry(key), treeMap.lowerEntry(key));
150        assertEquals(tm.higherKey(key), treeMap.higherKey(key));
151        assertEquals(tm.higherEntry(key), treeMap.higherEntry(key));
152        assertEquals(tm.entrySet(), treeMap.entrySet());
153    }
154
155    public void test_TreeMap_Constructor_SortedMap() {
156        TreeMap treeMap = new TreeMap(subMap_default);
157        assertEquals(subMap_default.size(), treeMap.size());
158        assertEquals(subMap_default.firstKey(), treeMap.firstKey());
159        assertEquals(subMap_default.lastKey(), treeMap.lastKey());
160        assertEquals(subMap_default.keySet(), treeMap.keySet());
161        assertEquals(subMap_default.entrySet(), treeMap.entrySet());
162    }
163
164    public void test_TreeMap_clear() {
165        tm.clear();
166        assertEquals(0, tm.size());
167    }
168
169    public void test_TreeMap_clone() {
170        TreeMap cloneTreeMap = (TreeMap) tm.clone();
171        assertEquals(tm, cloneTreeMap);
172    }
173
174    public void test_SubMap_Constructor() {
175    }
176
177    public void test_SubMap_clear() {
178        subMap_default.clear();
179        assertEquals(0, subMap_default.size());
180    }
181
182    public void test_SubMap_comparator() {
183        assertEquals(tm.comparator(), subMap_default.comparator());
184    }
185
186    public void test_SubMap_containsKey() {
187        String key = null;
188        for (int counter = 101; counter < 109; counter++) {
189            key = objArray[counter].toString();
190            assertTrue("SubMap contains incorrect elements", subMap_default
191                    .containsKey(key));
192            assertTrue("SubMap contains incorrect elements",
193                    subMap_startExcluded_endExcluded.containsKey(key));
194            assertTrue("SubMap contains incorrect elements",
195                    subMap_startExcluded_endIncluded.containsKey(key));
196            assertTrue("SubMap contains incorrect elements",
197                    subMap_startIncluded_endExcluded.containsKey(key));
198            assertTrue("SubMap contains incorrect elements",
199                    subMap_startIncluded_endIncluded.containsKey(key));
200        }
201
202        // Check boundary
203        key = objArray[100].toString();
204        assertTrue("SubMap contains incorrect elements", subMap_default
205                .containsKey(key));
206        assertFalse("SubMap contains incorrect elements",
207                subMap_startExcluded_endExcluded.containsKey(key));
208        assertFalse("SubMap contains incorrect elements",
209                subMap_startExcluded_endIncluded.containsKey(key));
210        assertTrue("SubMap contains incorrect elements",
211                subMap_startIncluded_endExcluded.containsKey(key));
212        assertTrue("SubMap contains incorrect elements",
213                subMap_startIncluded_endIncluded.containsKey(key));
214
215        key = objArray[109].toString();
216        assertFalse("SubMap contains incorrect elements", subMap_default
217                .containsKey(key));
218        assertFalse("SubMap contains incorrect elements",
219                subMap_startExcluded_endExcluded.containsKey(key));
220        assertTrue("SubMap contains incorrect elements",
221                subMap_startExcluded_endIncluded.containsKey(key));
222        assertFalse("SubMap contains incorrect elements",
223                subMap_startIncluded_endExcluded.containsKey(key));
224        assertTrue("SubMap contains incorrect elements",
225                subMap_startIncluded_endIncluded.containsKey(key));
226
227        // With Comparator
228        for (int counter = 101; counter < 109; counter++) {
229            key = objArray[counter].toString();
230            assertTrue("SubMap contains incorrect elements",
231                    subMap_default_comparator.containsKey(key));
232            assertTrue("SubMap contains incorrect elements",
233                    subMap_startExcluded_endExcluded_comparator
234                            .containsKey(key));
235            assertTrue("SubMap contains incorrect elements",
236                    subMap_startExcluded_endIncluded_comparator
237                            .containsKey(key));
238            assertTrue("SubMap contains incorrect elements",
239                    subMap_startIncluded_endExcluded_comparator
240                            .containsKey(key));
241            assertTrue("SubMap contains incorrect elements",
242                    subMap_startIncluded_endIncluded_comparator
243                            .containsKey(key));
244        }
245
246        // Check boundary
247        key = objArray[100].toString();
248        assertTrue("SubMap contains incorrect elements",
249                subMap_default_comparator.containsKey(key));
250        assertFalse("SubMap contains incorrect elements",
251                subMap_startExcluded_endExcluded_comparator.containsKey(key));
252        assertFalse("SubMap contains incorrect elements",
253                subMap_startExcluded_endIncluded_comparator.containsKey(key));
254        assertTrue("SubMap contains incorrect elements",
255                subMap_startIncluded_endExcluded_comparator.containsKey(key));
256        assertTrue("SubMap contains incorrect elements",
257                subMap_startIncluded_endIncluded_comparator.containsKey(key));
258
259        key = objArray[109].toString();
260        assertFalse("SubMap contains incorrect elements",
261                subMap_default_comparator.containsKey(key));
262        assertFalse("SubMap contains incorrect elements",
263                subMap_startExcluded_endExcluded_comparator.containsKey(key));
264        assertTrue("SubMap contains incorrect elements",
265                subMap_startExcluded_endIncluded_comparator.containsKey(key));
266        assertFalse("SubMap contains incorrect elements",
267                subMap_startIncluded_endExcluded_comparator.containsKey(key));
268        assertTrue("SubMap contains incorrect elements",
269                subMap_startIncluded_endIncluded_comparator.containsKey(key));
270    }
271
272    public void test_SubMap_containsValue() {
273        Object value = null;
274        for (int counter = 101; counter < 109; counter++) {
275            value = objArray[counter];
276            assertTrue("SubMap contains incorrect elements", subMap_default
277                    .containsValue(value));
278            assertTrue("SubMap contains incorrect elements",
279                    subMap_startExcluded_endExcluded.containsValue(value));
280            assertTrue("SubMap contains incorrect elements",
281                    subMap_startExcluded_endIncluded.containsValue(value));
282            assertTrue("SubMap contains incorrect elements",
283                    subMap_startIncluded_endExcluded.containsValue(value));
284            assertTrue("SubMap contains incorrect elements",
285                    subMap_startIncluded_endIncluded.containsValue(value));
286        }
287
288        // Check boundary
289        value = objArray[100];
290        assertTrue("SubMap contains incorrect elements", subMap_default
291                .containsValue(value));
292        assertFalse("SubMap contains incorrect elements",
293                subMap_startExcluded_endExcluded.containsValue(value));
294        assertFalse("SubMap contains incorrect elements",
295                subMap_startExcluded_endIncluded.containsValue(value));
296        assertTrue("SubMap contains incorrect elements",
297                subMap_startIncluded_endExcluded.containsValue(value));
298        assertTrue("SubMap contains incorrect elements",
299                subMap_startIncluded_endIncluded.containsValue(value));
300
301        value = objArray[109];
302        assertFalse("SubMap contains incorrect elements", subMap_default
303                .containsValue(value));
304        assertFalse("SubMap contains incorrect elements",
305                subMap_startExcluded_endExcluded.containsValue(value));
306        assertTrue("SubMap contains incorrect elements",
307                subMap_startExcluded_endIncluded.containsValue(value));
308        assertFalse("SubMap contains incorrect elements",
309                subMap_startIncluded_endExcluded.containsValue(value));
310        assertTrue("SubMap contains incorrect elements",
311                subMap_startIncluded_endIncluded.containsValue(value));
312
313        assertFalse(subMap_default.containsValue(null));
314
315        TreeMap tm_null = new TreeMap();
316        tm_null.put("0", 1);
317        tm_null.put("1", null);
318        tm_null.put("2", 2);
319        SortedMap subMap = tm_null.subMap("0", "2");
320        assertTrue(subMap.containsValue(null));
321
322        subMap.remove("1");
323        assertFalse(subMap.containsValue(null));
324    }
325
326    public void test_SubMap_entrySet() {
327        Set entrySet = subMap_default.entrySet();
328        assertFalse(entrySet.isEmpty());
329        assertEquals(9, entrySet.size());
330
331        entrySet = subMap_startExcluded_endExcluded.entrySet();
332        assertFalse(entrySet.isEmpty());
333        assertEquals(8, entrySet.size());
334
335        entrySet = subMap_startExcluded_endIncluded.entrySet();
336        assertFalse(entrySet.isEmpty());
337        assertEquals(9, entrySet.size());
338
339        entrySet = subMap_startIncluded_endExcluded.entrySet();
340        assertFalse(entrySet.isEmpty());
341        assertEquals(9, entrySet.size());
342
343        entrySet = subMap_startIncluded_endIncluded.entrySet();
344        assertFalse(entrySet.isEmpty());
345        assertEquals(10, entrySet.size());
346    }
347
348    public void test_SubMap_firstKey() {
349        String firstKey1 = new Integer(100).toString();
350        String firstKey2 = new Integer(101).toString();
351        assertEquals(firstKey1, subMap_default.firstKey());
352        assertEquals(firstKey2, subMap_startExcluded_endExcluded.firstKey());
353        assertEquals(firstKey2, subMap_startExcluded_endIncluded.firstKey());
354        assertEquals(firstKey1, subMap_startIncluded_endExcluded.firstKey());
355        assertEquals(firstKey1, subMap_startIncluded_endIncluded.firstKey());
356
357        try {
358            subMap_default.subMap(firstKey1, firstKey1).firstKey();
359            fail("should throw NoSuchElementException");
360        } catch (NoSuchElementException e) {
361            // Expected
362        }
363
364        try {
365            subMap_startExcluded_endExcluded.subMap(firstKey2, firstKey2)
366                    .firstKey();
367            fail("should throw NoSuchElementException");
368        } catch (NoSuchElementException e) {
369            // Expected
370        }
371
372        try {
373            subMap_startExcluded_endIncluded.subMap(firstKey2, firstKey2)
374                    .firstKey();
375            fail("should throw NoSuchElementException");
376        } catch (NoSuchElementException e) {
377            // Expected
378        }
379
380        try {
381            subMap_startIncluded_endExcluded.subMap(firstKey1, firstKey1)
382                    .firstKey();
383            fail("should throw NoSuchElementException");
384        } catch (NoSuchElementException e) {
385            // Expected
386        }
387
388        try {
389            subMap_startIncluded_endIncluded.subMap(firstKey1, firstKey1)
390                    .firstKey();
391            fail("should throw NoSuchElementException");
392        } catch (NoSuchElementException e) {
393            // Expected
394        }
395
396        // With Comparator
397        assertEquals(firstKey1, subMap_default_comparator.firstKey());
398        assertEquals(firstKey2, subMap_startExcluded_endExcluded_comparator
399                .firstKey());
400        assertEquals(firstKey2, subMap_startExcluded_endIncluded_comparator
401                .firstKey());
402        assertEquals(firstKey1, subMap_startIncluded_endExcluded_comparator
403                .firstKey());
404        assertEquals(firstKey1, subMap_startIncluded_endIncluded_comparator
405                .firstKey());
406
407        try {
408            subMap_default_comparator.subMap(firstKey1, firstKey1).firstKey();
409            fail("should throw NoSuchElementException");
410        } catch (NoSuchElementException e) {
411            // Expected
412        }
413
414        try {
415            subMap_startExcluded_endExcluded_comparator.subMap(firstKey2,
416                    firstKey2).firstKey();
417            fail("should throw NoSuchElementException");
418        } catch (NoSuchElementException e) {
419            // Expected
420        }
421
422        try {
423            subMap_startExcluded_endIncluded_comparator.subMap(firstKey2,
424                    firstKey2).firstKey();
425            fail("should throw NoSuchElementException");
426        } catch (NoSuchElementException e) {
427            // Expected
428        }
429
430        try {
431            subMap_startIncluded_endExcluded_comparator.subMap(firstKey1,
432                    firstKey1).firstKey();
433            fail("should throw NoSuchElementException");
434        } catch (NoSuchElementException e) {
435            // Expected
436        }
437
438        try {
439            subMap_startIncluded_endIncluded_comparator.subMap(firstKey1,
440                    firstKey1).firstKey();
441            fail("should throw NoSuchElementException");
442        } catch (NoSuchElementException e) {
443            // Expected
444        }
445
446    }
447
448    public void test_SubMap_lastKey() {
449        String lastKey1 = new Integer(108).toString();
450        String lastKey2 = new Integer(109).toString();
451        assertEquals(lastKey1, subMap_default.lastKey());
452        assertEquals(lastKey1, subMap_startExcluded_endExcluded.lastKey());
453        assertEquals(lastKey2, subMap_startExcluded_endIncluded.lastKey());
454        assertEquals(lastKey1, subMap_startIncluded_endExcluded.lastKey());
455        assertEquals(lastKey2, subMap_startIncluded_endIncluded.lastKey());
456
457        try {
458            subMap_default.subMap(lastKey1, lastKey1).lastKey();
459            fail("should throw NoSuchElementException");
460        } catch (NoSuchElementException e) {
461            // Expected
462        }
463
464        try {
465            subMap_startExcluded_endExcluded.subMap(lastKey1, lastKey1)
466                    .lastKey();
467            fail("should throw NoSuchElementException");
468        } catch (NoSuchElementException e) {
469            // Expected
470        }
471
472        try {
473            subMap_startExcluded_endIncluded.subMap(lastKey2, lastKey2)
474                    .lastKey();
475            fail("should throw NoSuchElementException");
476        } catch (NoSuchElementException e) {
477            // Expected
478        }
479
480        try {
481            subMap_startIncluded_endExcluded.subMap(lastKey1, lastKey1)
482                    .lastKey();
483            fail("should throw NoSuchElementException");
484        } catch (NoSuchElementException e) {
485            // Expected
486        }
487
488        try {
489            subMap_startIncluded_endIncluded.subMap(lastKey2, lastKey2)
490                    .lastKey();
491            fail("should throw NoSuchElementException");
492        } catch (NoSuchElementException e) {
493            // Expected
494        }
495
496        // With Comparator
497        assertEquals(lastKey1, subMap_default_comparator.lastKey());
498        assertEquals(lastKey1, subMap_startExcluded_endExcluded_comparator
499                .lastKey());
500        assertEquals(lastKey2, subMap_startExcluded_endIncluded_comparator
501                .lastKey());
502        assertEquals(lastKey1, subMap_startIncluded_endExcluded_comparator
503                .lastKey());
504        assertEquals(lastKey2, subMap_startIncluded_endIncluded_comparator
505                .lastKey());
506
507        try {
508            subMap_default_comparator.subMap(lastKey1, lastKey1).lastKey();
509            fail("should throw NoSuchElementException");
510        } catch (NoSuchElementException e) {
511            // Expected
512        }
513
514        try {
515            subMap_startExcluded_endExcluded_comparator.subMap(lastKey1,
516                    lastKey1).lastKey();
517            fail("should throw NoSuchElementException");
518        } catch (NoSuchElementException e) {
519            // Expected
520        }
521
522        try {
523            subMap_startExcluded_endIncluded_comparator.subMap(lastKey2,
524                    lastKey2).lastKey();
525            fail("should throw NoSuchElementException");
526        } catch (NoSuchElementException e) {
527            // Expected
528        }
529
530        try {
531            subMap_startIncluded_endExcluded_comparator.subMap(lastKey1,
532                    lastKey1).lastKey();
533            fail("should throw NoSuchElementException");
534        } catch (NoSuchElementException e) {
535            // Expected
536        }
537
538        try {
539            subMap_startIncluded_endIncluded_comparator.subMap(lastKey2,
540                    lastKey2).lastKey();
541            fail("should throw NoSuchElementException");
542        } catch (NoSuchElementException e) {
543            // Expected
544        }
545    }
546
547    public void test_SubMap_get() {
548        // left boundary
549        Integer value = new Integer(100);
550        assertEquals(value, subMap_default.get(value.toString()));
551        assertEquals(null, subMap_startExcluded_endExcluded.get(value
552                .toString()));
553        assertEquals(null, subMap_startExcluded_endIncluded.get(value
554                .toString()));
555        assertEquals(value, subMap_startIncluded_endExcluded.get(value
556                .toString()));
557        assertEquals(value, subMap_startIncluded_endIncluded.get(value
558                .toString()));
559
560        // normal value
561        value = new Integer(105);
562        assertEquals(value, subMap_default.get(value.toString()));
563        assertEquals(value, subMap_startExcluded_endExcluded.get(value
564                .toString()));
565        assertEquals(value, subMap_startExcluded_endIncluded.get(value
566                .toString()));
567        assertEquals(value, subMap_startIncluded_endExcluded.get(value
568                .toString()));
569        assertEquals(value, subMap_startIncluded_endIncluded.get(value
570                .toString()));
571
572        // right boundary
573        value = new Integer(109);
574        assertEquals(null, subMap_default.get(value.toString()));
575        assertEquals(null, subMap_startExcluded_endExcluded.get(value
576                .toString()));
577        assertEquals(value, subMap_startExcluded_endIncluded.get(value
578                .toString()));
579        assertEquals(null, subMap_startIncluded_endExcluded.get(value
580                .toString()));
581        assertEquals(value, subMap_startIncluded_endIncluded.get(value
582                .toString()));
583
584        // With Comparator to test inInRange
585        // left boundary
586        value = new Integer(100);
587        assertEquals(value, subMap_default_comparator.get(value.toString()));
588
589        // normal value
590        value = new Integer(105);
591        assertEquals(value, subMap_default_comparator.get(value.toString()));
592
593        // right boundary
594        value = new Integer(109);
595        assertEquals(null, subMap_default_comparator.get(value.toString()));
596    }
597
598    public void test_SubMap_headMap() {
599        String endKey = new Integer(99).toString();
600        try {
601            subMap_default.headMap(endKey);
602            fail("should throw IllegalArgumentException");
603        } catch (IllegalArgumentException e) {
604            // Expected
605        }
606
607        try {
608            subMap_startExcluded_endExcluded.headMap(endKey);
609            fail("should throw IllegalArgumentException");
610        } catch (IllegalArgumentException e) {
611            // Expected
612        }
613
614        try {
615            subMap_startExcluded_endIncluded.headMap(endKey);
616            fail("should throw IllegalArgumentException");
617        } catch (IllegalArgumentException e) {
618            // Expected
619        }
620
621        try {
622            subMap_startIncluded_endExcluded.headMap(endKey);
623            fail("should throw IllegalArgumentException");
624        } catch (IllegalArgumentException e) {
625            // Expected
626        }
627
628        try {
629            subMap_startIncluded_endIncluded.headMap(endKey);
630            fail("should throw IllegalArgumentException");
631        } catch (IllegalArgumentException e) {
632            // Expected
633        }
634
635        SortedMap headMap = null;
636        endKey = new Integer(100).toString();
637        headMap = subMap_default.headMap(endKey);
638        assertEquals(0, headMap.size());
639
640        headMap = subMap_startExcluded_endExcluded.headMap(endKey);
641        assertEquals(0, headMap.size());
642
643        headMap = subMap_startExcluded_endIncluded.headMap(endKey);
644        assertEquals(0, headMap.size());
645
646        headMap = subMap_startIncluded_endExcluded.headMap(endKey);
647        assertEquals(0, headMap.size());
648
649        headMap = subMap_startIncluded_endIncluded.headMap(endKey);
650        assertEquals(0, headMap.size());
651
652        for (int i = 0, j = 101; i < 8; i++) {
653            endKey = new Integer(i + j).toString();
654            headMap = subMap_default.headMap(endKey);
655            assertEquals(i + 1, headMap.size());
656
657            headMap = subMap_startExcluded_endExcluded.headMap(endKey);
658            assertEquals(i, headMap.size());
659
660            headMap = subMap_startExcluded_endIncluded.headMap(endKey);
661            assertEquals(i, headMap.size());
662
663            headMap = subMap_startIncluded_endExcluded.headMap(endKey);
664            assertEquals(i + 1, headMap.size());
665
666            headMap = subMap_startIncluded_endIncluded.headMap(endKey);
667            assertEquals(i + 1, headMap.size());
668        }
669
670        endKey = new Integer(109).toString();
671        headMap = subMap_default.headMap(endKey);
672        assertEquals(9, headMap.size());
673
674        headMap = subMap_startExcluded_endExcluded.headMap(endKey);
675        assertEquals(8, headMap.size());
676
677        headMap = subMap_startExcluded_endIncluded.headMap(endKey);
678        assertEquals(8, headMap.size());
679
680        headMap = subMap_startIncluded_endExcluded.headMap(endKey);
681        assertEquals(9, headMap.size());
682
683        headMap = subMap_startIncluded_endIncluded.headMap(endKey);
684        assertEquals(9, headMap.size());
685
686        endKey = new Integer(110).toString();
687        try {
688            subMap_default.headMap(endKey);
689            fail("should throw IllegalArgumentException");
690        } catch (IllegalArgumentException e) {
691            // Expected
692        }
693
694        try {
695            subMap_startExcluded_endExcluded.headMap(endKey);
696            fail("should throw IllegalArgumentException");
697        } catch (IllegalArgumentException e) {
698            // Expected
699        }
700
701        try {
702            subMap_startExcluded_endIncluded.headMap(endKey);
703            fail("should throw IllegalArgumentException");
704        } catch (IllegalArgumentException e) {
705            // Expected
706        }
707
708        try {
709            subMap_startIncluded_endExcluded.headMap(endKey);
710            fail("should throw IllegalArgumentException");
711        } catch (IllegalArgumentException e) {
712            // Expected
713        }
714
715        try {
716            subMap_startIncluded_endIncluded.headMap(endKey);
717            fail("should throw IllegalArgumentException");
718        } catch (IllegalArgumentException e) {
719            // Expected
720        }
721
722        // With Comparator
723        endKey = new Integer(99).toString();
724        try {
725            subMap_default_comparator.headMap(endKey);
726            fail("should throw IllegalArgumentException");
727        } catch (IllegalArgumentException e) {
728            // Expected
729        }
730
731        try {
732            subMap_startExcluded_endExcluded_comparator.headMap(endKey);
733            fail("should throw IllegalArgumentException");
734        } catch (IllegalArgumentException e) {
735            // Expected
736        }
737
738        try {
739            subMap_startExcluded_endIncluded_comparator.headMap(endKey);
740            fail("should throw IllegalArgumentException");
741        } catch (IllegalArgumentException e) {
742            // Expected
743        }
744
745        try {
746            subMap_startIncluded_endExcluded_comparator.headMap(endKey);
747            fail("should throw IllegalArgumentException");
748        } catch (IllegalArgumentException e) {
749            // Expected
750        }
751
752        try {
753            subMap_startIncluded_endIncluded_comparator.headMap(endKey);
754            fail("should throw IllegalArgumentException");
755        } catch (IllegalArgumentException e) {
756            // Expected
757        }
758
759        headMap = null;
760        endKey = new Integer(100).toString();
761        headMap = subMap_default_comparator.headMap(endKey);
762        assertEquals(0, headMap.size());
763
764        headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey);
765        assertEquals(0, headMap.size());
766
767        headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey);
768        assertEquals(0, headMap.size());
769
770        headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey);
771        assertEquals(0, headMap.size());
772
773        headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey);
774        assertEquals(0, headMap.size());
775
776        for (int i = 0, j = 101; i < 8; i++) {
777            endKey = new Integer(i + j).toString();
778            headMap = subMap_default_comparator.headMap(endKey);
779            assertEquals(i + 1, headMap.size());
780
781            headMap = subMap_startExcluded_endExcluded_comparator
782                    .headMap(endKey);
783            assertEquals(i, headMap.size());
784
785            headMap = subMap_startExcluded_endIncluded_comparator
786                    .headMap(endKey);
787            assertEquals(i, headMap.size());
788
789            headMap = subMap_startIncluded_endExcluded_comparator
790                    .headMap(endKey);
791            assertEquals(i + 1, headMap.size());
792
793            headMap = subMap_startIncluded_endIncluded_comparator
794                    .headMap(endKey);
795            assertEquals(i + 1, headMap.size());
796        }
797
798        endKey = new Integer(108).toString();
799        headMap = subMap_default_comparator.headMap(endKey);
800        assertEquals(8, headMap.size());
801
802        headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey);
803        assertEquals(7, headMap.size());
804
805        headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey);
806        assertEquals(7, headMap.size());
807
808        headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey);
809        assertEquals(8, headMap.size());
810
811        headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey);
812        assertEquals(8, headMap.size());
813
814        endKey = new Integer(110).toString();
815        try {
816            subMap_default_comparator.headMap(endKey);
817            fail("should throw IllegalArgumentException");
818        } catch (IllegalArgumentException e) {
819            // Expected
820        }
821
822        try {
823            subMap_startExcluded_endExcluded_comparator.headMap(endKey);
824            fail("should throw IllegalArgumentException");
825        } catch (IllegalArgumentException e) {
826            // Expected
827        }
828
829        try {
830            subMap_startExcluded_endIncluded_comparator.headMap(endKey);
831            fail("should throw IllegalArgumentException");
832        } catch (IllegalArgumentException e) {
833            // Expected
834        }
835
836        try {
837            subMap_startIncluded_endExcluded_comparator.headMap(endKey);
838            fail("should throw IllegalArgumentException");
839        } catch (IllegalArgumentException e) {
840            // Expected
841        }
842
843        try {
844            subMap_startIncluded_endIncluded_comparator.headMap(endKey);
845            fail("should throw IllegalArgumentException");
846        } catch (IllegalArgumentException e) {
847            // Expected
848        }
849    }
850
851    public void test_SubMap_isEmpty() {
852        assertFalse(subMap_default.isEmpty());
853        assertFalse(subMap_startExcluded_endExcluded.isEmpty());
854        assertFalse(subMap_startExcluded_endIncluded.isEmpty());
855        assertFalse(subMap_startIncluded_endExcluded.isEmpty());
856        assertFalse(subMap_startIncluded_endIncluded.isEmpty());
857
858        Object startKey = new Integer(100);
859        Object endKey = startKey;
860        SortedMap subMap = tm.subMap(startKey.toString(), endKey.toString());
861        assertTrue(subMap.isEmpty());
862        subMap = subMap_default.subMap(startKey.toString(), endKey.toString());
863        assertTrue(subMap.isEmpty());
864        subMap = subMap_startIncluded_endExcluded.subMap(startKey.toString(),
865                endKey.toString());
866        assertTrue(subMap.isEmpty());
867        subMap = subMap_startIncluded_endIncluded.subMap(startKey.toString(),
868                endKey.toString());
869        assertTrue(subMap.isEmpty());
870
871        for (int i = 0, j = 101; i < 8; i++) {
872            startKey = i + j;
873            endKey = startKey;
874
875            subMap = subMap_default.subMap(startKey.toString(), endKey
876                    .toString());
877            assertTrue(subMap.isEmpty());
878
879            subMap = subMap_startExcluded_endExcluded.subMap(startKey
880                    .toString(), endKey.toString());
881            assertTrue(subMap.isEmpty());
882
883            subMap = subMap_startExcluded_endIncluded.subMap(startKey
884                    .toString(), endKey.toString());
885            assertTrue(subMap.isEmpty());
886
887            subMap = subMap_startIncluded_endExcluded.subMap(startKey
888                    .toString(), endKey.toString());
889            assertTrue(subMap.isEmpty());
890
891            subMap = subMap_startIncluded_endIncluded.subMap(startKey
892                    .toString(), endKey.toString());
893            assertTrue(subMap.isEmpty());
894        }
895
896        for (int i = 0, j = 101; i < 5; i++) {
897            startKey = i + j;
898            endKey = i + j + 4;
899
900            subMap = subMap_default.subMap(startKey.toString(), endKey
901                    .toString());
902            assertFalse(subMap.isEmpty());
903
904            subMap = subMap_startExcluded_endExcluded.subMap(startKey
905                    .toString(), endKey.toString());
906            assertFalse(subMap.isEmpty());
907
908            subMap = subMap_startExcluded_endIncluded.subMap(startKey
909                    .toString(), endKey.toString());
910            assertFalse(subMap.isEmpty());
911
912            subMap = subMap_startIncluded_endExcluded.subMap(startKey
913                    .toString(), endKey.toString());
914            assertFalse(subMap.isEmpty());
915
916            subMap = subMap_startIncluded_endIncluded.subMap(startKey
917                    .toString(), endKey.toString());
918            assertFalse(subMap.isEmpty());
919        }
920
921        startKey = new Integer(109).toString();
922        endKey = startKey;
923        subMap = tm.subMap(startKey.toString(), endKey.toString());
924        assertTrue(subMap.isEmpty());
925        subMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey);
926        assertTrue(subMap.isEmpty());
927        subMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey);
928        assertTrue(subMap.isEmpty());
929
930    }
931
932    public void test_SubMap_keySet() {
933        Set keySet = subMap_default.keySet();
934        assertFalse(keySet.isEmpty());
935        assertEquals(9, keySet.size());
936
937        keySet = subMap_startExcluded_endExcluded.entrySet();
938        assertFalse(keySet.isEmpty());
939        assertEquals(8, keySet.size());
940
941        keySet = subMap_startExcluded_endIncluded.entrySet();
942        assertFalse(keySet.isEmpty());
943        assertEquals(9, keySet.size());
944
945        keySet = subMap_startIncluded_endExcluded.entrySet();
946        assertFalse(keySet.isEmpty());
947        assertEquals(9, keySet.size());
948
949        keySet = subMap_startIncluded_endIncluded.entrySet();
950        assertFalse(keySet.isEmpty());
951        assertEquals(10, keySet.size());
952    }
953
954    public void test_SubMap_put() {
955        Integer value = new Integer(100);
956        int addValue = 5;
957
958        subMap_default.put(value.toString(), value + addValue);
959        assertEquals(value + addValue, subMap_default.get(value.toString()));
960
961        try {
962            subMap_startExcluded_endExcluded.put(value.toString(), value
963                    + addValue);
964            fail("should throw IllegalArgumentException");
965        } catch (IllegalArgumentException e) {
966            // Expected
967        }
968
969        try {
970            subMap_startExcluded_endIncluded.put(value.toString(), value
971                    + addValue);
972            fail("should throw IllegalArgumentException");
973        } catch (IllegalArgumentException e) {
974            // Expected
975        }
976
977        subMap_startIncluded_endExcluded
978                .put(value.toString(), value + addValue);
979        assertEquals(value + addValue, subMap_startIncluded_endExcluded
980                .get(value.toString()));
981
982        subMap_startIncluded_endIncluded
983                .put(value.toString(), value + addValue);
984        assertEquals(value + addValue, subMap_startIncluded_endIncluded
985                .get(value.toString()));
986
987        value = new Integer(109);
988        try {
989            subMap_default.put(value.toString(), value + addValue);
990            fail("should throw IllegalArgumentException");
991        } catch (IllegalArgumentException e) {
992            // Expected
993        }
994
995        try {
996            subMap_startExcluded_endExcluded.put(value.toString(), value
997                    + addValue);
998            fail("should throw IllegalArgumentException");
999        } catch (IllegalArgumentException e) {
1000            // Expected
1001        }
1002
1003        subMap_startExcluded_endIncluded
1004                .put(value.toString(), value + addValue);
1005        assertEquals(value + addValue, subMap_startExcluded_endIncluded
1006                .get(value.toString()));
1007
1008        try {
1009            subMap_startIncluded_endExcluded.put(value.toString(), value
1010                    + addValue);
1011            fail("should throw IllegalArgumentException");
1012        } catch (IllegalArgumentException e) {
1013            // Expected
1014        }
1015
1016        subMap_startIncluded_endIncluded
1017                .put(value.toString(), value + addValue);
1018        assertEquals(value + addValue, subMap_startIncluded_endIncluded
1019                .get(value.toString()));
1020    }
1021
1022    public void test_SubMap_remove() {
1023        Integer value = new Integer(100);
1024
1025        subMap_default.remove(value.toString());
1026        assertNull(subMap_default.get(value.toString()));
1027
1028        subMap_startExcluded_endExcluded.remove(value.toString());
1029        assertNull(subMap_startExcluded_endExcluded.get(value.toString()));
1030
1031        subMap_startExcluded_endIncluded.remove(value.toString());
1032        assertNull(subMap_startExcluded_endIncluded.get(value.toString()));
1033
1034        subMap_startIncluded_endExcluded.remove(value.toString());
1035        assertNull(subMap_startIncluded_endExcluded.get(value.toString()));
1036
1037        subMap_startIncluded_endIncluded.remove(value.toString());
1038        assertNull(subMap_startIncluded_endIncluded.get(value.toString()));
1039
1040        value = new Integer(109);
1041        subMap_default.remove(value.toString());
1042        assertNull(subMap_default.get(value.toString()));
1043
1044        subMap_startExcluded_endExcluded.remove(value.toString());
1045        assertNull(subMap_startExcluded_endExcluded.get(value.toString()));
1046
1047        subMap_startExcluded_endIncluded.remove(value.toString());
1048        assertNull(subMap_startExcluded_endIncluded.get(value.toString()));
1049
1050        subMap_startIncluded_endExcluded.remove(value.toString());
1051        assertNull(subMap_startIncluded_endExcluded.get(value.toString()));
1052
1053        subMap_startIncluded_endIncluded.remove(value.toString());
1054        assertNull(subMap_startIncluded_endIncluded.get(value.toString()));
1055    }
1056
1057    public void test_SubMap_subMap_NoComparator() {
1058        String startKey = new Integer[100].toString();
1059        String endKey = new Integer[100].toString();
1060        try {
1061            subMap_default.subMap(startKey, endKey);
1062            fail("should throw IllegalArgumentException");
1063        } catch (IllegalArgumentException e) {
1064            // Expected
1065        }
1066
1067        try {
1068            subMap_startExcluded_endExcluded.subMap(startKey, endKey);
1069            fail("should throw IllegalArgumentException");
1070        } catch (IllegalArgumentException e) {
1071            // Expected
1072        }
1073
1074        try {
1075            subMap_startExcluded_endIncluded.subMap(startKey, endKey);
1076            fail("should throw IllegalArgumentException");
1077        } catch (IllegalArgumentException e) {
1078            // Expected
1079        }
1080
1081        try {
1082            subMap_startIncluded_endExcluded.subMap(startKey, endKey);
1083            fail("should throw IllegalArgumentException");
1084        } catch (IllegalArgumentException e) {
1085            // Expected
1086        }
1087
1088        try {
1089            subMap_startIncluded_endIncluded.subMap(startKey, endKey);
1090            fail("should throw IllegalArgumentException");
1091        } catch (IllegalArgumentException e) {
1092            // Expected
1093        }
1094
1095        SortedMap subSubMap = null;
1096        for (int i = 101; i < 109; i++) {
1097            startKey = new Integer(i).toString();
1098            endKey = startKey;
1099
1100            subSubMap = subMap_default.subMap(startKey, endKey);
1101            assertEquals(0, subSubMap.size());
1102
1103            subSubMap = subMap_startExcluded_endExcluded.subMap(startKey,
1104                    endKey);
1105            assertEquals(0, subSubMap.size());
1106
1107            subSubMap = subMap_startExcluded_endIncluded.subMap(startKey,
1108                    endKey);
1109            assertEquals(0, subSubMap.size());
1110
1111            subSubMap = subMap_startIncluded_endExcluded.subMap(startKey,
1112                    endKey);
1113            assertEquals(0, subSubMap.size());
1114
1115            subSubMap = subMap_startIncluded_endIncluded.subMap(startKey,
1116                    endKey);
1117            assertEquals(0, subSubMap.size());
1118        }
1119
1120        for (int i = 101, j = 5; i < 105; i++) {
1121            startKey = new Integer(i).toString();
1122            endKey = new Integer(i + j).toString();
1123
1124            subSubMap = subMap_default.subMap(startKey, endKey);
1125            assertEquals(j, subSubMap.size());
1126
1127            subSubMap = subMap_startExcluded_endExcluded.subMap(startKey,
1128                    endKey);
1129            assertEquals(j, subSubMap.size());
1130
1131            subSubMap = subMap_startExcluded_endIncluded.subMap(startKey,
1132                    endKey);
1133            assertEquals(j, subSubMap.size());
1134
1135            subSubMap = subMap_startIncluded_endExcluded.subMap(startKey,
1136                    endKey);
1137            assertEquals(j, subSubMap.size());
1138
1139            subSubMap = subMap_startIncluded_endIncluded.subMap(startKey,
1140                    endKey);
1141            assertEquals(j, subSubMap.size());
1142        }
1143
1144        startKey = new Integer(108).toString();
1145        endKey = new Integer(109).toString();
1146
1147        subSubMap = subMap_default.subMap(startKey, endKey);
1148        assertEquals(1, subSubMap.size());
1149
1150        subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, endKey);
1151        assertEquals(1, subSubMap.size());
1152
1153        subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey);
1154        assertEquals(1, subSubMap.size());
1155
1156        subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, endKey);
1157        assertEquals(1, subSubMap.size());
1158
1159        subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey);
1160        assertEquals(1, subSubMap.size());
1161
1162        startKey = new Integer(109).toString();
1163        endKey = new Integer(109).toString();
1164
1165        try {
1166            subMap_default.subMap(startKey, endKey);
1167            fail("should throw IllegalArgumentException");
1168        } catch (IllegalArgumentException e) {
1169            // Expected
1170        }
1171
1172        try {
1173            subMap_startExcluded_endExcluded.subMap(startKey, endKey);
1174            fail("should throw IllegalArgumentException");
1175        } catch (IllegalArgumentException e) {
1176            // Expected
1177        }
1178
1179        subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey);
1180        assertEquals(0, subSubMap.size());
1181
1182        try {
1183            subMap_startIncluded_endExcluded.subMap(startKey, endKey);
1184            fail("should throw IllegalArgumentException");
1185        } catch (IllegalArgumentException e) {
1186            // Expected
1187        }
1188
1189        subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey);
1190        assertEquals(0, subSubMap.size());
1191    }
1192
1193    public void test_SubMap_subMap_Comparator() {
1194        String startKey = new Integer[100].toString();
1195        String endKey = new Integer[100].toString();
1196        try {
1197            subMap_default_comparator.subMap(startKey, endKey);
1198            fail("should throw IllegalArgumentException");
1199        } catch (IllegalArgumentException e) {
1200            // Expected
1201        }
1202
1203        try {
1204            subMap_startExcluded_endExcluded_comparator
1205                    .subMap(startKey, endKey);
1206            fail("should throw IllegalArgumentException");
1207        } catch (IllegalArgumentException e) {
1208            // Expected
1209        }
1210
1211        try {
1212            subMap_startExcluded_endIncluded_comparator
1213                    .subMap(startKey, endKey);
1214            fail("should throw IllegalArgumentException");
1215        } catch (IllegalArgumentException e) {
1216            // Expected
1217        }
1218
1219        try {
1220            subMap_startIncluded_endExcluded_comparator
1221                    .subMap(startKey, endKey);
1222            fail("should throw IllegalArgumentException");
1223        } catch (IllegalArgumentException e) {
1224            // Expected
1225        }
1226
1227        try {
1228            subMap_startIncluded_endIncluded_comparator
1229                    .subMap(startKey, endKey);
1230            fail("should throw IllegalArgumentException");
1231        } catch (IllegalArgumentException e) {
1232            // Expected
1233        }
1234
1235        SortedMap subSubMap = null;
1236        for (int i = 101; i < 109; i++) {
1237            startKey = new Integer(i).toString();
1238            endKey = startKey;
1239
1240            subSubMap = subMap_default_comparator.subMap(startKey, endKey);
1241            assertEquals(0, subSubMap.size());
1242
1243            subSubMap = subMap_startExcluded_endExcluded_comparator.subMap(
1244                    startKey, endKey);
1245            assertEquals(0, subSubMap.size());
1246
1247            subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1248                    startKey, endKey);
1249            assertEquals(0, subSubMap.size());
1250
1251            subSubMap = subMap_startIncluded_endExcluded_comparator.subMap(
1252                    startKey, endKey);
1253            assertEquals(0, subSubMap.size());
1254
1255            subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1256                    startKey, endKey);
1257            assertEquals(0, subSubMap.size());
1258        }
1259
1260        for (int i = 101, j = 5; i < 105; i++) {
1261            startKey = new Integer(i).toString();
1262            endKey = new Integer(i + j).toString();
1263
1264            subSubMap = subMap_default_comparator.subMap(startKey, endKey);
1265            assertEquals(j, subSubMap.size());
1266
1267            subSubMap = subMap_startExcluded_endExcluded_comparator.subMap(
1268                    startKey, endKey);
1269            assertEquals(j, subSubMap.size());
1270
1271            subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1272                    startKey, endKey);
1273            assertEquals(j, subSubMap.size());
1274
1275            subSubMap = subMap_startIncluded_endExcluded_comparator.subMap(
1276                    startKey, endKey);
1277            assertEquals(j, subSubMap.size());
1278
1279            subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1280                    startKey, endKey);
1281            assertEquals(j, subSubMap.size());
1282        }
1283
1284        startKey = new Integer(108).toString();
1285        endKey = new Integer(109).toString();
1286
1287        subSubMap = subMap_default_comparator.subMap(startKey, endKey);
1288        assertEquals(1, subSubMap.size());
1289
1290        subSubMap = subMap_startExcluded_endExcluded_comparator.subMap(
1291                startKey, endKey);
1292        assertEquals(1, subSubMap.size());
1293
1294        subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1295                startKey, endKey);
1296        assertEquals(1, subSubMap.size());
1297
1298        subSubMap = subMap_startIncluded_endExcluded_comparator.subMap(
1299                startKey, endKey);
1300        assertEquals(1, subSubMap.size());
1301
1302        subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1303                startKey, endKey);
1304        assertEquals(1, subSubMap.size());
1305
1306        startKey = new Integer(109).toString();
1307        endKey = new Integer(109).toString();
1308
1309        try {
1310            subMap_default_comparator.subMap(startKey, endKey);
1311            fail("should throw IllegalArgumentException");
1312        } catch (IllegalArgumentException e) {
1313            // Expected
1314        }
1315
1316        try {
1317            subMap_startExcluded_endExcluded_comparator
1318                    .subMap(startKey, endKey);
1319            fail("should throw IllegalArgumentException");
1320        } catch (IllegalArgumentException e) {
1321            // Expected
1322        }
1323
1324        subSubMap = subMap_startExcluded_endIncluded_comparator.subMap(
1325                startKey, endKey);
1326        assertEquals(0, subSubMap.size());
1327
1328        try {
1329            subMap_startIncluded_endExcluded_comparator
1330                    .subMap(startKey, endKey);
1331            fail("should throw IllegalArgumentException");
1332        } catch (IllegalArgumentException e) {
1333            // Expected
1334        }
1335
1336        subSubMap = subMap_startIncluded_endIncluded_comparator.subMap(
1337                startKey, endKey);
1338        assertEquals(0, subSubMap.size());
1339    }
1340
1341    public void test_SubMap_tailMap() {
1342        String startKey = new Integer(99).toString();
1343        try {
1344            subMap_default.tailMap(startKey);
1345            fail("should throw IllegalArgumentException");
1346        } catch (IllegalArgumentException e) {
1347            // Expected
1348        }
1349
1350        try {
1351            subMap_startExcluded_endExcluded.tailMap(startKey);
1352            fail("should throw IllegalArgumentException");
1353        } catch (IllegalArgumentException e) {
1354            // Expected
1355        }
1356
1357        try {
1358            subMap_startExcluded_endIncluded.tailMap(startKey);
1359            fail("should throw IllegalArgumentException");
1360        } catch (IllegalArgumentException e) {
1361            // Expected
1362        }
1363
1364        try {
1365            subMap_startIncluded_endExcluded.tailMap(startKey);
1366            fail("should throw IllegalArgumentException");
1367        } catch (IllegalArgumentException e) {
1368            // Expected
1369        }
1370
1371        try {
1372            subMap_startIncluded_endIncluded.tailMap(startKey);
1373            fail("should throw IllegalArgumentException");
1374        } catch (IllegalArgumentException e) {
1375            // Expected
1376        }
1377        SortedMap tailMap = null;
1378
1379        startKey = new Integer(100).toString();
1380        tailMap = subMap_default.tailMap(startKey);
1381        assertEquals(9, tailMap.size());
1382
1383        try {
1384            subMap_startExcluded_endExcluded.tailMap(startKey);
1385            fail("should throw IllegalArgumentException");
1386        } catch (IllegalArgumentException e) {
1387            // Expected
1388        }
1389
1390        try {
1391            subMap_startExcluded_endIncluded.tailMap(startKey);
1392            fail("should throw IllegalArgumentException");
1393        } catch (IllegalArgumentException e) {
1394            // Expected
1395        }
1396
1397        tailMap = subMap_startIncluded_endExcluded.tailMap(startKey);
1398        assertEquals(9, tailMap.size());
1399
1400        tailMap = subMap_startIncluded_endIncluded.tailMap(startKey);
1401        assertEquals(10, tailMap.size());
1402
1403        for (int i = 0, j = 101, end = 8; i < end; i++) {
1404            startKey = new Integer(i + j).toString();
1405            tailMap = subMap_default.tailMap(startKey);
1406            assertEquals(end - i, tailMap.size());
1407
1408            tailMap = subMap_startExcluded_endExcluded.tailMap(startKey);
1409            assertEquals(end - i, tailMap.size());
1410
1411            tailMap = subMap_startExcluded_endIncluded.tailMap(startKey);
1412            assertEquals(end - i + 1, tailMap.size());
1413
1414            tailMap = subMap_startIncluded_endExcluded.tailMap(startKey);
1415            assertEquals(end - i, tailMap.size());
1416
1417            tailMap = subMap_startIncluded_endIncluded.tailMap(startKey);
1418            assertEquals(end - i + 1, tailMap.size());
1419        }
1420
1421        startKey = new Integer(109).toString();
1422        try {
1423            subMap_default.tailMap(startKey);
1424            fail("should throw IllegalArgumentException");
1425        } catch (IllegalArgumentException e) {
1426            // Expected
1427        }
1428        try {
1429            subMap_startExcluded_endExcluded.tailMap(startKey);
1430            fail("should throw IllegalArgumentException");
1431        } catch (IllegalArgumentException e) {
1432            // Expected
1433        }
1434
1435        tailMap = subMap_startExcluded_endIncluded.tailMap(startKey);
1436        assertEquals(1, tailMap.size());
1437
1438        try {
1439            subMap_startIncluded_endExcluded.tailMap(startKey);
1440            fail("should throw IllegalArgumentException");
1441        } catch (IllegalArgumentException e) {
1442            // Expected
1443        }
1444
1445        tailMap = subMap_startIncluded_endIncluded.tailMap(startKey);
1446        assertEquals(1, tailMap.size());
1447
1448        startKey = new Integer(110).toString();
1449        try {
1450            subMap_default.tailMap(startKey);
1451            fail("should throw IllegalArgumentException");
1452        } catch (IllegalArgumentException e) {
1453            // Expected
1454        }
1455
1456        try {
1457            subMap_startExcluded_endExcluded.tailMap(startKey);
1458            fail("should throw IllegalArgumentException");
1459        } catch (IllegalArgumentException e) {
1460            // Expected
1461        }
1462        try {
1463            subMap_startExcluded_endIncluded.tailMap(startKey);
1464            fail("should throw IllegalArgumentException");
1465        } catch (IllegalArgumentException e) {
1466            // Expected
1467        }
1468        try {
1469            subMap_startIncluded_endExcluded.tailMap(startKey);
1470            fail("should throw IllegalArgumentException");
1471        } catch (IllegalArgumentException e) {
1472            // Expected
1473        }
1474        try {
1475            subMap_startIncluded_endIncluded.tailMap(startKey);
1476            fail("should throw IllegalArgumentException");
1477        } catch (IllegalArgumentException e) {
1478            // Expected
1479        }
1480    }
1481
1482    public void test_SubMap_values() {
1483        Collection values = subMap_default.values();
1484
1485        assertFalse(values.isEmpty());
1486        assertTrue(values.contains(100));
1487        for (int i = 101; i < 109; i++) {
1488            assertTrue(values.contains(i));
1489        }
1490        assertFalse(values.contains(109));
1491
1492        values = subMap_startExcluded_endExcluded.values();
1493        assertFalse(values.isEmpty());
1494        assertFalse(values.contains(100));
1495        for (int i = 101; i < 109; i++) {
1496            assertTrue(values.contains(i));
1497        }
1498        assertFalse(values.contains(109));
1499
1500        values = subMap_startExcluded_endIncluded.values();
1501        assertFalse(values.isEmpty());
1502        assertFalse(values.contains(100));
1503        for (int i = 101; i < 109; i++) {
1504            assertTrue(values.contains(i));
1505        }
1506        assertTrue(values.contains(109));
1507
1508        values = subMap_startIncluded_endExcluded.values();
1509        assertFalse(values.isEmpty());
1510        assertTrue(values.contains(100));
1511        for (int i = 101; i < 109; i++) {
1512            assertTrue(values.contains(i));
1513        }
1514        assertFalse(values.contains(109));
1515
1516        values = subMap_startIncluded_endIncluded.values();
1517        assertFalse(values.isEmpty());
1518        assertTrue(values.contains(100));
1519        for (int i = 100; i < 109; i++) {
1520            assertTrue(values.contains(i));
1521        }
1522        assertTrue(values.contains(109));
1523    }
1524
1525    public void test_SubMap_size() {
1526        assertEquals(9, subMap_default.size());
1527        assertEquals(8, subMap_startExcluded_endExcluded.size());
1528        assertEquals(9, subMap_startExcluded_endIncluded.size());
1529        assertEquals(9, subMap_startIncluded_endExcluded.size());
1530        assertEquals(10, subMap_startIncluded_endIncluded.size());
1531
1532        assertEquals(9, subMap_default_comparator.size());
1533        assertEquals(8, subMap_startExcluded_endExcluded_comparator.size());
1534        assertEquals(9, subMap_startExcluded_endIncluded_comparator.size());
1535        assertEquals(9, subMap_startIncluded_endExcluded_comparator.size());
1536        assertEquals(10, subMap_startIncluded_endIncluded_comparator.size());
1537    }
1538
1539    public void test_SubMap_readObject() throws Exception {
1540        // SerializationTest.verifySelf(subMap_default);
1541        // SerializationTest.verifySelf(subMap_startExcluded_endExcluded);
1542        // SerializationTest.verifySelf(subMap_startExcluded_endIncluded);
1543        // SerializationTest.verifySelf(subMap_startIncluded_endExcluded);
1544        // SerializationTest.verifySelf(subMap_startIncluded_endIncluded);
1545    }
1546
1547    public void test_AscendingSubMap_ceilingEntry() {
1548        String key = new Integer(99).toString();
1549        assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key));
1550        assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key));
1551        assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key));
1552        assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key));
1553
1554        key = new Integer(100).toString();
1555        assertEquals(101, navigableMap_startExcluded_endExcluded.ceilingEntry(
1556                key).getValue());
1557        assertEquals(101, navigableMap_startExcluded_endIncluded.ceilingEntry(
1558                key).getValue());
1559        assertEquals(100, navigableMap_startIncluded_endExcluded.ceilingEntry(
1560                key).getValue());
1561        assertEquals(100, navigableMap_startIncluded_endIncluded.ceilingEntry(
1562                key).getValue());
1563
1564        for (int i = 101; i < 109; i++) {
1565            key = new Integer(i).toString();
1566            assertEquals(i, navigableMap_startExcluded_endExcluded
1567                    .ceilingEntry(key).getValue());
1568            assertEquals(i, navigableMap_startExcluded_endIncluded
1569                    .ceilingEntry(key).getValue());
1570            assertEquals(i, navigableMap_startIncluded_endExcluded
1571                    .ceilingEntry(key).getValue());
1572            assertEquals(i, navigableMap_startIncluded_endIncluded
1573                    .ceilingEntry(key).getValue());
1574
1575        }
1576
1577        key = new Integer(109).toString();
1578        assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key));
1579        assertEquals(109, navigableMap_startExcluded_endIncluded.ceilingEntry(
1580                key).getValue());
1581        assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key));
1582        assertEquals(109, navigableMap_startIncluded_endIncluded.ceilingEntry(
1583                key).getValue());
1584
1585        key = new Integer(110).toString();
1586        assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key));
1587        assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key));
1588        assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key));
1589        assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key));
1590    }
1591
1592    public void test_AscendingSubMap_descendingMap() {
1593        NavigableMap descendingMap = navigableMap_startExcluded_endExcluded
1594                .descendingMap();
1595        assertEquals(navigableMap_startExcluded_endExcluded.size(),
1596                descendingMap.size());
1597        assertNotNull(descendingMap.comparator());
1598
1599        assertEquals(navigableMap_startExcluded_endExcluded.firstKey(),
1600                descendingMap.lastKey());
1601        assertEquals(navigableMap_startExcluded_endExcluded.firstEntry(),
1602                descendingMap.lastEntry());
1603
1604        assertEquals(navigableMap_startExcluded_endExcluded.lastKey(),
1605                descendingMap.firstKey());
1606        assertEquals(navigableMap_startExcluded_endExcluded.lastEntry(),
1607                descendingMap.firstEntry());
1608
1609        descendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
1610        assertEquals(navigableMap_startExcluded_endIncluded.size(),
1611                descendingMap.size());
1612        assertNotNull(descendingMap.comparator());
1613
1614        assertEquals(navigableMap_startExcluded_endIncluded.firstKey(),
1615                descendingMap.lastKey());
1616        assertEquals(navigableMap_startExcluded_endIncluded.firstEntry(),
1617                descendingMap.lastEntry());
1618
1619        assertEquals(navigableMap_startExcluded_endIncluded.lastKey(),
1620                descendingMap.firstKey());
1621        assertEquals(navigableMap_startExcluded_endIncluded.lastEntry(),
1622                descendingMap.firstEntry());
1623
1624        descendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
1625        assertEquals(navigableMap_startIncluded_endExcluded.size(),
1626                descendingMap.size());
1627        assertNotNull(descendingMap.comparator());
1628
1629        assertEquals(navigableMap_startIncluded_endExcluded.firstKey(),
1630                descendingMap.lastKey());
1631        assertEquals(navigableMap_startIncluded_endExcluded.firstEntry(),
1632                descendingMap.lastEntry());
1633
1634        assertEquals(navigableMap_startIncluded_endExcluded.lastKey(),
1635                descendingMap.firstKey());
1636        assertEquals(navigableMap_startIncluded_endExcluded.lastEntry(),
1637                descendingMap.firstEntry());
1638
1639        descendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
1640        assertEquals(navigableMap_startIncluded_endIncluded.size(),
1641                descendingMap.size());
1642        assertNotNull(descendingMap.comparator());
1643
1644        assertEquals(navigableMap_startIncluded_endIncluded.firstKey(),
1645                descendingMap.lastKey());
1646        assertEquals(navigableMap_startIncluded_endIncluded.firstEntry(),
1647                descendingMap.lastEntry());
1648
1649        assertEquals(navigableMap_startIncluded_endIncluded.lastKey(),
1650                descendingMap.firstKey());
1651        assertEquals(navigableMap_startIncluded_endIncluded.lastEntry(),
1652                descendingMap.firstEntry());
1653    }
1654
1655    public void test_AscendingSubMap_floorEntry() {
1656        String key = new Integer(99).toString();
1657        assertEquals(108, navigableMap_startExcluded_endExcluded
1658                .floorEntry(key).getValue());
1659        assertEquals(109, navigableMap_startExcluded_endIncluded
1660                .floorEntry(key).getValue());
1661        assertEquals(108, navigableMap_startIncluded_endExcluded
1662                .floorEntry(key).getValue());
1663        assertEquals(109, navigableMap_startIncluded_endIncluded
1664                .floorEntry(key).getValue());
1665
1666        key = new Integer(100).toString();
1667        assertNull(navigableMap_startExcluded_endExcluded.floorEntry(key));
1668        assertNull(navigableMap_startExcluded_endIncluded.floorEntry(key));
1669        assertEquals(100, navigableMap_startIncluded_endExcluded
1670                .floorEntry(key).getValue());
1671        assertEquals(100, navigableMap_startIncluded_endIncluded
1672                .floorEntry(key).getValue());
1673
1674        for (int i = 101; i < 109; i++) {
1675            key = new Integer(i).toString();
1676            assertEquals(i, navigableMap_startExcluded_endExcluded.floorEntry(
1677                    key).getValue());
1678            assertEquals(i, navigableMap_startExcluded_endIncluded.floorEntry(
1679                    key).getValue());
1680            assertEquals(i, navigableMap_startIncluded_endExcluded.floorEntry(
1681                    key).getValue());
1682            assertEquals(i, navigableMap_startIncluded_endIncluded.floorEntry(
1683                    key).getValue());
1684
1685        }
1686
1687        key = new Integer(109).toString();
1688        assertEquals(108, navigableMap_startExcluded_endExcluded
1689                .floorEntry(key).getValue());
1690        assertEquals(109, navigableMap_startExcluded_endIncluded
1691                .floorEntry(key).getValue());
1692        assertEquals(108, navigableMap_startIncluded_endExcluded
1693                .floorEntry(key).getValue());
1694        assertEquals(109, navigableMap_startIncluded_endIncluded
1695                .floorEntry(key).getValue());
1696
1697        key = new Integer(110).toString();
1698        assertEquals(108, navigableMap_startExcluded_endExcluded
1699                .floorEntry(key).getValue());
1700        assertEquals(109, navigableMap_startExcluded_endIncluded
1701                .floorEntry(key).getValue());
1702        assertEquals(108, navigableMap_startIncluded_endExcluded
1703                .floorEntry(key).getValue());
1704        assertEquals(109, navigableMap_startIncluded_endIncluded
1705                .floorEntry(key).getValue());
1706    }
1707
1708    public void test_AscendingSubMap_pollFirstEntry() {
1709        assertEquals(101, navigableMap_startExcluded_endExcluded
1710                .pollFirstEntry().getValue());
1711        assertEquals(102, navigableMap_startExcluded_endIncluded
1712                .pollFirstEntry().getValue());
1713        assertEquals(100, navigableMap_startIncluded_endExcluded
1714                .pollFirstEntry().getValue());
1715        assertEquals(103, navigableMap_startIncluded_endIncluded
1716                .pollFirstEntry().getValue());
1717    }
1718
1719    public void test_AscendingSubMap_pollLastEntry() {
1720        assertEquals(108, navigableMap_startExcluded_endExcluded
1721                .pollLastEntry().getValue());
1722        assertEquals(109, navigableMap_startExcluded_endIncluded
1723                .pollLastEntry().getValue());
1724        assertEquals(107, navigableMap_startIncluded_endExcluded
1725                .pollLastEntry().getValue());
1726        assertEquals(106, navigableMap_startIncluded_endIncluded
1727                .pollLastEntry().getValue());
1728    }
1729
1730    public void test_AscendingSubMap_entrySet() {
1731        assertEquals(8, navigableMap_startExcluded_endExcluded.entrySet()
1732                .size());
1733        assertEquals(9, navigableMap_startExcluded_endIncluded.entrySet()
1734                .size());
1735        assertEquals(9, navigableMap_startIncluded_endExcluded.entrySet()
1736                .size());
1737        assertEquals(10, navigableMap_startIncluded_endIncluded.entrySet()
1738                .size());
1739    }
1740
1741    public void test_AscendingSubMap_subMap() {
1742        Set entrySet;
1743        Entry startEntry, endEntry;
1744        int startIndex, endIndex;
1745        SortedMap subMap;
1746        Iterator subMapSetIterator;
1747
1748        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
1749        Iterator startIterator = entrySet.iterator();
1750        while (startIterator.hasNext()) {
1751            startEntry = (Entry) startIterator.next();
1752            startIndex = (Integer) startEntry.getValue();
1753            Iterator endIterator = entrySet.iterator();
1754            while (endIterator.hasNext()) {
1755                endEntry = (Entry) endIterator.next();
1756                endIndex = (Integer) endEntry.getValue();
1757
1758                if (startIndex > endIndex) {
1759                    try {
1760                        navigableMap_startExcluded_endExcluded.subMap(
1761                                startEntry.getKey(), endEntry.getKey());
1762                        fail("should throw IllegalArgumentException");
1763                    } catch (IllegalArgumentException e) {
1764                        // Expected
1765                    }
1766                    try {
1767                        navigableMap_startExcluded_endExcluded.subMap(
1768                                startEntry.getKey(), false, endEntry.getKey(),
1769                                false);
1770                        fail("should throw IllegalArgumentException");
1771                    } catch (IllegalArgumentException e) {
1772                        // Expected
1773                    }
1774                    try {
1775                        navigableMap_startExcluded_endExcluded.subMap(
1776                                startEntry.getKey(), false, endEntry.getKey(),
1777                                true);
1778                        fail("should throw IllegalArgumentException");
1779                    } catch (IllegalArgumentException e) {
1780                        // Expected
1781                    }
1782                    try {
1783                        navigableMap_startExcluded_endExcluded.subMap(
1784                                startEntry.getKey(), true, endEntry.getKey(),
1785                                false);
1786                        fail("should throw IllegalArgumentException");
1787                    } catch (IllegalArgumentException e) {
1788                        // Expected
1789                    }
1790                    try {
1791                        navigableMap_startExcluded_endExcluded.subMap(
1792                                startEntry.getKey(), true, endEntry.getKey(),
1793                                true);
1794                        fail("should throw IllegalArgumentException");
1795                    } catch (IllegalArgumentException e) {
1796                        // Expected
1797                    }
1798                } else {
1799                    subMap = navigableMap_startExcluded_endExcluded.subMap(
1800                            startEntry.getKey(), endEntry.getKey());
1801                    subMapSetIterator = subMap.entrySet().iterator();
1802                    for (int index = startIndex; index < endIndex; index++) {
1803                        assertEquals(index, ((Entry) subMapSetIterator.next())
1804                                .getValue());
1805                    }
1806
1807                    subMap = navigableMap_startExcluded_endExcluded.subMap(
1808                            startEntry.getKey(), false, endEntry.getKey(),
1809                            false);
1810                    subMapSetIterator = subMap.entrySet().iterator();
1811                    for (int index = startIndex + 1; index < endIndex; index++) {
1812                        assertEquals(index, ((Entry) subMapSetIterator.next())
1813                                .getValue());
1814                    }
1815
1816                    subMap = navigableMap_startExcluded_endExcluded
1817                            .subMap(startEntry.getKey(), false, endEntry
1818                                    .getKey(), true);
1819                    subMapSetIterator = subMap.entrySet().iterator();
1820                    for (int index = startIndex + 1; index < endIndex; index++) {
1821                        assertEquals(index, ((Entry) subMapSetIterator.next())
1822                                .getValue());
1823                    }
1824
1825                    subMap = navigableMap_startExcluded_endExcluded
1826                            .subMap(startEntry.getKey(), true, endEntry
1827                                    .getKey(), false);
1828                    subMapSetIterator = subMap.entrySet().iterator();
1829                    for (int index = startIndex; index < endIndex; index++) {
1830                        assertEquals(index, ((Entry) subMapSetIterator.next())
1831                                .getValue());
1832                    }
1833
1834                    subMap = navigableMap_startExcluded_endExcluded.subMap(
1835                            startEntry.getKey(), true, endEntry.getKey(), true);
1836                    subMapSetIterator = subMap.entrySet().iterator();
1837                    for (int index = startIndex; index <= endIndex; index++) {
1838                        assertEquals(index, ((Entry) subMapSetIterator.next())
1839                                .getValue());
1840                    }
1841                }
1842            }
1843        }
1844    }
1845
1846    public void test_DescendingSubMap_ceilingEntry() {
1847        NavigableMap decendingMap = tm.descendingMap();
1848        String key = new Integer(-1).toString();
1849        assertNull(decendingMap.ceilingEntry(key));
1850        for (int i = 0; i < objArray.length; i++) {
1851            key = objArray[i].toString();
1852            assertEquals(objArray[i], decendingMap.ceilingEntry(key).getValue());
1853        }
1854        key = new Integer(1000).toString();
1855        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1856        key = new Integer(1001).toString();
1857        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1858
1859        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
1860        key = new Integer(100).toString();
1861        assertNull(decendingMap.ceilingEntry(key));
1862        for (int i = 101; i < 109; i++) {
1863            key = new Integer(i).toString();
1864            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1865        }
1866        key = new Integer(109).toString();
1867        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1868
1869        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
1870        key = new Integer(100).toString();
1871        assertNull(decendingMap.ceilingEntry(key));
1872        for (int i = 101; i < 109; i++) {
1873            key = new Integer(i).toString();
1874            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1875        }
1876        key = new Integer(109).toString();
1877        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1878
1879        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
1880        key = new Integer(100).toString();
1881        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1882        for (int i = 101; i < 109; i++) {
1883            key = new Integer(i).toString();
1884            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1885        }
1886        key = new Integer(109).toString();
1887        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1888
1889        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
1890        key = new Integer(100).toString();
1891        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1892        for (int i = 101; i < 109; i++) {
1893            key = new Integer(i).toString();
1894            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1895        }
1896        key = new Integer(109).toString();
1897        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1898
1899        // With Comparator
1900        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
1901                .descendingMap();
1902        key = new Integer(100).toString();
1903        assertNull(decendingMap.ceilingEntry(key));
1904        for (int i = 101; i < 109; i++) {
1905            key = new Integer(i).toString();
1906            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1907        }
1908        key = new Integer(109).toString();
1909        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1910
1911        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
1912                .descendingMap();
1913        key = new Integer(100).toString();
1914        assertNull(decendingMap.ceilingEntry(key));
1915        for (int i = 101; i < 109; i++) {
1916            key = new Integer(i).toString();
1917            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1918        }
1919        key = new Integer(109).toString();
1920        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1921
1922        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
1923                .descendingMap();
1924        key = new Integer(100).toString();
1925        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1926        for (int i = 101; i < 109; i++) {
1927            key = new Integer(i).toString();
1928            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1929        }
1930        key = new Integer(109).toString();
1931        assertEquals(108, decendingMap.ceilingEntry(key).getValue());
1932
1933        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
1934                .descendingMap();
1935        key = new Integer(100).toString();
1936        assertEquals(100, decendingMap.ceilingEntry(key).getValue());
1937        for (int i = 101; i < 109; i++) {
1938            key = new Integer(i).toString();
1939            assertEquals(i, decendingMap.ceilingEntry(key).getValue());
1940        }
1941        key = new Integer(109).toString();
1942        assertEquals(109, decendingMap.ceilingEntry(key).getValue());
1943    }
1944
1945    public void test_DescendingSubMap_descendingMap() {
1946        NavigableMap decendingMap = tm.descendingMap();
1947        NavigableMap decendingDecendingMap = decendingMap.descendingMap();
1948        assertEquals(decendingMap, decendingDecendingMap);
1949
1950        NavigableMap decendingMapHeadMap = decendingMap.headMap(
1951                new Integer(990).toString(), false);
1952        NavigableMap decendingDecendingHeadMap = decendingMapHeadMap
1953                .descendingMap();
1954        assertNotNull(decendingMapHeadMap);
1955        assertNotNull(decendingDecendingHeadMap);
1956        assertEquals(decendingMapHeadMap, decendingDecendingHeadMap);
1957
1958        NavigableMap decendingMapTailMap = decendingMap.tailMap(
1959                new Integer(990).toString(), false);
1960        NavigableMap decendingDecendingTailMap = decendingMapTailMap
1961                .descendingMap();
1962        assertNotNull(decendingMapTailMap);
1963        assertNotNull(decendingDecendingTailMap);
1964        // assertEquals(decendingMapTailMap,decendingDecendingTailMap);
1965
1966        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
1967        decendingDecendingMap = decendingMap.descendingMap();
1968        assertEquals(decendingMap, decendingDecendingMap);
1969
1970        decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(),
1971                false);
1972        decendingDecendingHeadMap = decendingMapHeadMap.descendingMap();
1973        assertEquals(decendingMapHeadMap, decendingDecendingHeadMap);
1974
1975        decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(),
1976                false);
1977        decendingDecendingTailMap = decendingMapTailMap.descendingMap();
1978        assertEquals(decendingMapTailMap, decendingDecendingTailMap);
1979
1980        decendingMap = navigableMap_startExcluded_endIncluded.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_startIncluded_endExcluded.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_endIncluded.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
2023    public void test_DescendingSubMap_firstEntry() {
2024        NavigableMap decendingMap = tm.descendingMap();
2025        assertEquals(999, decendingMap.firstEntry().getValue());
2026
2027        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2028        assertEquals(108, decendingMap.firstEntry().getValue());
2029
2030        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2031        assertEquals(109, decendingMap.firstEntry().getValue());
2032
2033        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2034        assertEquals(108, decendingMap.firstEntry().getValue());
2035
2036        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2037        assertEquals(109, decendingMap.firstEntry().getValue());
2038    }
2039
2040    public void test_DescendingSubMap_floorEntry() {
2041        NavigableMap decendingMap = tm.descendingMap();
2042        String key = new Integer(-1).toString();
2043        assertEquals(0, decendingMap.floorEntry(key).getValue());
2044        for (int i = 0; i < objArray.length; i++) {
2045            key = objArray[i].toString();
2046            assertEquals(objArray[i], decendingMap.floorEntry(key).getValue());
2047        }
2048        key = new Integer(1000).toString();
2049        assertEquals(101, decendingMap.floorEntry(key).getValue());
2050        key = new Integer(1001).toString();
2051        assertEquals(101, decendingMap.floorEntry(key).getValue());
2052
2053        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2054        key = new Integer(100).toString();
2055        assertEquals(101, decendingMap.floorEntry(key).getValue());
2056        for (int i = 101; i < 109; i++) {
2057            key = new Integer(i).toString();
2058            assertEquals(i, decendingMap.floorEntry(key).getValue());
2059        }
2060        key = new Integer(109).toString();
2061        assertNull(decendingMap.floorEntry(key));
2062
2063        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2064        key = new Integer(100).toString();
2065        assertEquals(101, decendingMap.floorEntry(key).getValue());
2066        for (int i = 101; i < 109; i++) {
2067            key = new Integer(i).toString();
2068            assertEquals(i, decendingMap.floorEntry(key).getValue());
2069        }
2070        key = new Integer(109).toString();
2071        assertEquals(109, decendingMap.floorEntry(key).getValue());
2072
2073        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2074        key = new Integer(100).toString();
2075        assertEquals(100, decendingMap.floorEntry(key).getValue());
2076        for (int i = 101; i < 109; i++) {
2077            key = new Integer(i).toString();
2078            assertEquals(i, decendingMap.floorEntry(key).getValue());
2079        }
2080        key = new Integer(109).toString();
2081        assertNull(decendingMap.floorEntry(key));
2082
2083        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2084        key = new Integer(100).toString();
2085        assertEquals(100, decendingMap.floorEntry(key).getValue());
2086        for (int i = 101; i < 109; i++) {
2087            key = new Integer(i).toString();
2088            assertEquals(i, decendingMap.floorEntry(key).getValue());
2089        }
2090        key = new Integer(109).toString();
2091        assertEquals(109, decendingMap.floorEntry(key).getValue());
2092
2093        // With Comparator
2094        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
2095                .descendingMap();
2096        key = new Integer(100).toString();
2097        assertEquals(101, decendingMap.floorEntry(key).getValue());
2098        for (int i = 101; i < 109; i++) {
2099            key = new Integer(i).toString();
2100            assertEquals(i, decendingMap.floorEntry(key).getValue());
2101        }
2102        key = new Integer(109).toString();
2103        assertNull(decendingMap.floorEntry(key));
2104
2105        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
2106                .descendingMap();
2107        key = new Integer(100).toString();
2108        assertEquals(101, decendingMap.floorEntry(key).getValue());
2109        for (int i = 101; i < 109; i++) {
2110            key = new Integer(i).toString();
2111            assertEquals(i, decendingMap.floorEntry(key).getValue());
2112        }
2113        key = new Integer(109).toString();
2114        assertEquals(109, decendingMap.floorEntry(key).getValue());
2115
2116        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
2117                .descendingMap();
2118        key = new Integer(100).toString();
2119        assertEquals(100, decendingMap.floorEntry(key).getValue());
2120        for (int i = 101; i < 109; i++) {
2121            key = new Integer(i).toString();
2122            assertEquals(i, decendingMap.floorEntry(key).getValue());
2123        }
2124        key = new Integer(109).toString();
2125        assertNull(decendingMap.floorEntry(key));
2126
2127        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
2128                .descendingMap();
2129        key = new Integer(100).toString();
2130        assertEquals(100, decendingMap.floorEntry(key).getValue());
2131        for (int i = 101; i < 109; i++) {
2132            key = new Integer(i).toString();
2133            assertEquals(i, decendingMap.floorEntry(key).getValue());
2134        }
2135        key = new Integer(109).toString();
2136        assertEquals(109, decendingMap.floorEntry(key).getValue());
2137    }
2138
2139    public void test_DescendingSubMap_lastEntry() {
2140        NavigableMap decendingMap = tm.descendingMap();
2141        assertEquals(0, decendingMap.lastEntry().getValue());
2142
2143        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2144        assertEquals(101, decendingMap.lastEntry().getValue());
2145
2146        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2147        assertEquals(101, decendingMap.lastEntry().getValue());
2148
2149        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2150        assertEquals(100, decendingMap.lastEntry().getValue());
2151
2152        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2153        assertEquals(100, decendingMap.lastEntry().getValue());
2154    }
2155
2156    public void test_DescendingSubMap_higherEntry() {
2157        NavigableMap decendingMap;
2158        NavigableMap decendingTailMap;
2159        Integer value;
2160        Entry entry;
2161        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2162        value = new Integer(101);
2163        assertNull(decendingMap.higherEntry(value.toString()));
2164
2165        for (int i = 108; i > 101; i--) {
2166            value = new Integer(i);
2167            entry = decendingMap.higherEntry(value.toString());
2168            assertEquals(value - 1, entry.getValue());
2169        }
2170
2171        value = new Integer(109);
2172        entry = decendingMap.higherEntry(value.toString());
2173        assertEquals(108, entry.getValue());
2174
2175        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2176                false);
2177        value = new Integer(109);
2178        entry = decendingTailMap.higherEntry(value.toString());
2179        assertEquals(103, entry.getValue());
2180
2181        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2182        value = new Integer(100);
2183        assertNull(decendingMap.higherEntry(value.toString()));
2184
2185        for (int i = 108; i > 100; i--) {
2186            value = new Integer(i);
2187            entry = decendingMap.higherEntry(value.toString());
2188            assertEquals(value - 1, entry.getValue());
2189        }
2190
2191        value = new Integer(109);
2192        entry = decendingMap.higherEntry(value.toString());
2193        assertEquals(108, entry.getValue());
2194
2195        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2196                false);
2197        value = new Integer(109);
2198        entry = decendingTailMap.higherEntry(value.toString());
2199        assertEquals(103, entry.getValue());
2200
2201        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2202        value = new Integer(101);
2203        assertNull(decendingMap.higherEntry(value.toString()));
2204
2205        for (int i = 109; i > 101; i--) {
2206            value = new Integer(i);
2207            entry = decendingMap.higherEntry(value.toString());
2208            assertEquals(value - 1, entry.getValue());
2209        }
2210
2211        value = new Integer(2);
2212        entry = decendingMap.higherEntry(value.toString());
2213        assertEquals(109, entry.getValue());
2214
2215        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2216                false);
2217        value = new Integer(109);
2218        entry = decendingTailMap.higherEntry(value.toString());
2219        assertEquals(103, entry.getValue());
2220
2221        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2222        value = new Integer(100);
2223        assertNull(decendingMap.higherEntry(value.toString()));
2224
2225        for (int i = 109; i > 100; i--) {
2226            value = new Integer(i);
2227            entry = decendingMap.higherEntry(value.toString());
2228            assertEquals(value - 1, entry.getValue());
2229        }
2230
2231        value = new Integer(2);
2232        entry = decendingMap.higherEntry(value.toString());
2233        assertEquals(109, entry.getValue());
2234
2235        decendingTailMap = decendingMap.tailMap(new Integer(104).toString(),
2236                false);
2237        value = new Integer(109);
2238        entry = decendingTailMap.higherEntry(value.toString());
2239        assertEquals(103, entry.getValue());
2240    }
2241
2242    public void test_DescendingSubMap_lowerEntry() {
2243        NavigableMap decendingMap;
2244        NavigableMap decendingHeadMap;
2245        Integer value;
2246        Entry entry;
2247        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2248        value = new Integer(99);
2249        assertNull(decendingMap.lowerEntry(value.toString()));
2250        for (int i = 100; i < 108; i++) {
2251            value = new Integer(i);
2252            entry = decendingMap.lowerEntry(value.toString());
2253            assertEquals(value + 1, entry.getValue());
2254        }
2255        value = new Integer(109);
2256        assertNull(decendingMap.lowerEntry(value.toString()));
2257
2258        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2259                false);
2260        for (int i = 104; i < 106; i++) {
2261            value = new Integer(i);
2262            entry = decendingHeadMap.lowerEntry(value.toString());
2263            assertEquals(value + 1, entry.getValue());
2264        }
2265        value = new Integer(102);
2266        entry = decendingHeadMap.lowerEntry(value.toString());
2267        assertEquals(104, entry.getValue());
2268
2269        value = new Integer(109);
2270        entry = decendingHeadMap.lowerEntry(value.toString());
2271        assertNull(entry);
2272
2273        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2274        value = new Integer(99);
2275        assertNull(decendingMap.lowerEntry(value.toString()));
2276        for (int i = 100; i < 109; i++) {
2277            value = new Integer(i);
2278            entry = decendingMap.lowerEntry(value.toString());
2279            assertEquals(value + 1, entry.getValue());
2280        }
2281        value = new Integer(110);
2282        assertNull(decendingMap.lowerEntry(value.toString()));
2283
2284        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2285                false);
2286        for (int i = 104; i < 109; i++) {
2287            value = new Integer(i);
2288            entry = decendingHeadMap.lowerEntry(value.toString());
2289            assertEquals(value + 1, entry.getValue());
2290        }
2291        value = new Integer(102);
2292        entry = decendingHeadMap.lowerEntry(value.toString());
2293        assertEquals(104, entry.getValue());
2294
2295        value = new Integer(2);
2296        entry = decendingHeadMap.lowerEntry(value.toString());
2297        assertNull(entry);
2298
2299        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2300        value = new Integer(99);
2301        assertNull(decendingMap.lowerEntry(value.toString()));
2302        for (int i = 100; i < 108; i++) {
2303            value = new Integer(i);
2304            entry = decendingMap.lowerEntry(value.toString());
2305            assertEquals(value + 1, entry.getValue());
2306        }
2307        value = new Integer(109);
2308        assertNull(decendingMap.lowerEntry(value.toString()));
2309
2310        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2311                false);
2312        for (int i = 104; i < 107; i++) {
2313            value = new Integer(i);
2314            entry = decendingHeadMap.lowerEntry(value.toString());
2315            assertEquals(value + 1, entry.getValue());
2316        }
2317        value = new Integer(102);
2318        entry = decendingHeadMap.lowerEntry(value.toString());
2319        assertEquals(104, entry.getValue());
2320
2321        value = new Integer(2);
2322        entry = decendingHeadMap.lowerEntry(value.toString());
2323        assertNull(entry);
2324
2325        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2326        value = new Integer(99);
2327        assertNull(decendingMap.lowerEntry(value.toString()));
2328        for (int i = 100; i < 109; i++) {
2329            value = new Integer(i);
2330            entry = decendingMap.lowerEntry(value.toString());
2331            assertEquals(value + 1, entry.getValue());
2332        }
2333        value = new Integer(110);
2334        assertNull(decendingMap.lowerEntry(value.toString()));
2335
2336        decendingHeadMap = decendingMap.headMap(new Integer(103).toString(),
2337                false);
2338        for (int i = 104; i < 109; i++) {
2339            value = new Integer(i);
2340            entry = decendingHeadMap.lowerEntry(value.toString());
2341            assertEquals(value + 1, entry.getValue());
2342        }
2343        value = new Integer(102);
2344        entry = decendingHeadMap.lowerEntry(value.toString());
2345        assertEquals(104, entry.getValue());
2346
2347        value = new Integer(2);
2348        entry = decendingHeadMap.lowerEntry(value.toString());
2349        assertNull(entry);
2350    }
2351
2352    public void test_DescendingSubMap_pollFirstEntry() {
2353        NavigableMap decendingMap = tm.descendingMap();
2354        assertEquals(999, decendingMap.pollFirstEntry().getValue());
2355
2356        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2357        assertEquals(108, decendingMap.pollFirstEntry().getValue());
2358
2359        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2360        assertEquals(109, decendingMap.pollFirstEntry().getValue());
2361
2362        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2363        assertEquals(107, decendingMap.pollFirstEntry().getValue());
2364
2365        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2366        assertEquals(106, decendingMap.pollFirstEntry().getValue());
2367    }
2368
2369    public void test_DescendingSubMap_pollLastEntry() {
2370        NavigableMap decendingMap = tm.descendingMap();
2371        assertEquals(0, decendingMap.pollLastEntry().getValue());
2372
2373        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2374        assertEquals(101, decendingMap.pollLastEntry().getValue());
2375
2376        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2377        assertEquals(102, decendingMap.pollLastEntry().getValue());
2378
2379        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2380        assertEquals(100, decendingMap.pollLastEntry().getValue());
2381
2382        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2383        assertEquals(103, decendingMap.pollLastEntry().getValue());
2384    }
2385
2386    public void test_DescendingSubMap_values() {
2387        NavigableMap decendingMap = tm.descendingMap();
2388        Collection values = decendingMap.values();
2389        assertFalse(values.isEmpty());
2390        assertFalse(values.contains(1000));
2391        for (int i = 999; i > 0; i--) {
2392            assertTrue(values.contains(i));
2393        }
2394        assertTrue(values.contains(0));
2395
2396        String endKey = new Integer(99).toString();
2397        NavigableMap headMap = decendingMap.headMap(endKey, false);
2398        values = headMap.values();
2399        Iterator it = values.iterator();
2400        for (int i = 999; i > 990; i--) {
2401            assertTrue(values.contains(i));
2402            assertEquals(i, it.next());
2403        }
2404
2405        String startKey = new Integer(11).toString();
2406        NavigableMap tailMap = decendingMap.tailMap(startKey, false);
2407        values = tailMap.values();
2408        it = values.iterator();
2409        for (int i = 109; i > 100; i--) {
2410            assertTrue(values.contains(i));
2411            assertEquals(i, it.next());
2412        }
2413
2414        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2415        values = decendingMap.values();
2416        assertFalse(values.isEmpty());
2417        assertFalse(values.contains(109));
2418        for (int i = 108; i > 100; i--) {
2419            assertTrue(values.contains(i));
2420        }
2421        assertFalse(values.contains(100));
2422
2423        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2424        values = decendingMap.values();
2425        assertFalse(values.isEmpty());
2426        assertFalse(values.contains(100));
2427        for (int i = 108; i > 100; i--) {
2428            assertTrue(values.contains(i));
2429        }
2430        assertTrue(values.contains(109));
2431
2432        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2433        values = decendingMap.values();
2434        assertFalse(values.isEmpty());
2435        assertTrue(values.contains(100));
2436        for (int i = 108; i > 100; i--) {
2437            assertTrue(values.contains(i));
2438        }
2439        assertFalse(values.contains(109));
2440
2441        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2442        values = decendingMap.values();
2443        assertFalse(values.isEmpty());
2444        assertTrue(values.contains(100));
2445        for (int i = 108; i > 100; i--) {
2446            assertTrue(values.contains(i));
2447        }
2448        assertTrue(values.contains(109));
2449    }
2450
2451    public void test_DescendingSubMap_headMap() {
2452        NavigableMap decendingMap = tm.descendingMap();
2453        String endKey = new Integer(0).toString(), key;
2454        SortedMap subDecendingMap_Included = decendingMap.headMap(endKey, true);
2455        SortedMap subDecendingMap_Excluded = decendingMap
2456                .headMap(endKey, false);
2457        key = endKey;
2458        assertTrue(subDecendingMap_Included.containsKey(key));
2459        assertFalse(subDecendingMap_Excluded.containsKey(key));
2460        for (int i = 1; i < 1000; i++) {
2461            key = new Integer(i).toString();
2462            assertTrue(subDecendingMap_Included.containsKey(key));
2463            assertTrue(subDecendingMap_Excluded.containsKey(key));
2464        }
2465        key = new Integer(1000).toString();
2466        assertFalse(subDecendingMap_Included.containsKey(key));
2467        assertFalse(subDecendingMap_Excluded.containsKey(key));
2468
2469        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2470        endKey = new Integer(100).toString();
2471        try {
2472            decendingMap.headMap(endKey, true);
2473            fail("should throw IllegalArgumentException");
2474        } catch (IllegalArgumentException e) {
2475            // Expected
2476        }
2477        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2478        key = endKey;
2479        assertFalse(subDecendingMap_Excluded.containsKey(key));
2480
2481        endKey = new Integer(101).toString();
2482        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2483        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2484
2485        key = endKey;
2486        assertTrue(subDecendingMap_Included.containsKey(key));
2487        assertFalse(subDecendingMap_Excluded.containsKey(key));
2488
2489        for (int i = 102; i < 109; i++) {
2490            key = new Integer(i).toString();
2491            assertTrue(subDecendingMap_Included.containsKey(key));
2492            assertTrue(subDecendingMap_Excluded.containsKey(key));
2493        }
2494        key = new Integer(109).toString();
2495        assertFalse(subDecendingMap_Included.containsKey(key));
2496        assertFalse(subDecendingMap_Excluded.containsKey(key));
2497
2498        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2499        endKey = new Integer(100).toString();
2500        try {
2501            decendingMap.headMap(endKey, true);
2502            fail("should throw IllegalArgumentException");
2503        } catch (IllegalArgumentException e) {
2504            // Expected
2505        }
2506        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2507        key = endKey;
2508        assertFalse(subDecendingMap_Excluded.containsKey(key));
2509
2510        endKey = new Integer(101).toString();
2511        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2512        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2513
2514        key = endKey;
2515        assertTrue(subDecendingMap_Included.containsKey(key));
2516        assertFalse(subDecendingMap_Excluded.containsKey(key));
2517
2518        for (int i = 102; i < 109; i++) {
2519            key = new Integer(i).toString();
2520            assertTrue(subDecendingMap_Included.containsKey(key));
2521            assertTrue(subDecendingMap_Excluded.containsKey(key));
2522        }
2523        key = new Integer(109).toString();
2524        assertTrue(subDecendingMap_Included.containsKey(key));
2525        assertTrue(subDecendingMap_Excluded.containsKey(key));
2526
2527        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2528        endKey = new Integer(100).toString();
2529        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2530        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2531        key = endKey;
2532        assertTrue(subDecendingMap_Included.containsKey(key));
2533        assertFalse(subDecendingMap_Excluded.containsKey(key));
2534
2535        endKey = new Integer(101).toString();
2536        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2537        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2538
2539        key = endKey;
2540        assertTrue(subDecendingMap_Included.containsKey(key));
2541        assertFalse(subDecendingMap_Excluded.containsKey(key));
2542
2543        for (int i = 102; i < 109; i++) {
2544            key = new Integer(i).toString();
2545            assertTrue(subDecendingMap_Included.containsKey(key));
2546            assertTrue(subDecendingMap_Excluded.containsKey(key));
2547        }
2548        key = new Integer(109).toString();
2549        assertFalse(subDecendingMap_Included.containsKey(key));
2550        assertFalse(subDecendingMap_Excluded.containsKey(key));
2551
2552        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
2553        endKey = new Integer(100).toString();
2554        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2555        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2556        key = endKey;
2557        assertTrue(subDecendingMap_Included.containsKey(key));
2558        assertFalse(subDecendingMap_Excluded.containsKey(key));
2559
2560        endKey = new Integer(101).toString();
2561        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2562        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2563
2564        key = endKey;
2565        assertTrue(subDecendingMap_Included.containsKey(key));
2566        assertFalse(subDecendingMap_Excluded.containsKey(key));
2567
2568        for (int i = 102; i < 109; i++) {
2569            key = new Integer(i).toString();
2570            assertTrue(subDecendingMap_Included.containsKey(key));
2571            assertTrue(subDecendingMap_Excluded.containsKey(key));
2572        }
2573        key = new Integer(109).toString();
2574        assertTrue(subDecendingMap_Included.containsKey(key));
2575        assertTrue(subDecendingMap_Excluded.containsKey(key));
2576
2577        // With Comparator
2578
2579        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
2580                .descendingMap();
2581        endKey = new Integer(100).toString();
2582        try {
2583            decendingMap.headMap(endKey, true);
2584            fail("should throw IllegalArgumentException");
2585        } catch (IllegalArgumentException e) {
2586            // Expected
2587        }
2588        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2589        key = endKey;
2590        assertFalse(subDecendingMap_Excluded.containsKey(key));
2591
2592        endKey = new Integer(101).toString();
2593        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2594        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2595
2596        key = endKey;
2597        assertTrue(subDecendingMap_Included.containsKey(key));
2598        assertFalse(subDecendingMap_Excluded.containsKey(key));
2599
2600        for (int i = 102; i < 109; i++) {
2601            key = new Integer(i).toString();
2602            assertTrue(subDecendingMap_Included.containsKey(key));
2603            assertTrue(subDecendingMap_Excluded.containsKey(key));
2604        }
2605        key = new Integer(109).toString();
2606        assertFalse(subDecendingMap_Included.containsKey(key));
2607        assertFalse(subDecendingMap_Excluded.containsKey(key));
2608
2609        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
2610                .descendingMap();
2611        endKey = new Integer(100).toString();
2612        try {
2613            decendingMap.headMap(endKey, true);
2614            fail("should throw IllegalArgumentException");
2615        } catch (IllegalArgumentException e) {
2616            // Expected
2617        }
2618        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2619        key = endKey;
2620        assertFalse(subDecendingMap_Excluded.containsKey(key));
2621
2622        endKey = new Integer(101).toString();
2623        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2624        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2625
2626        key = endKey;
2627        assertTrue(subDecendingMap_Included.containsKey(key));
2628        assertFalse(subDecendingMap_Excluded.containsKey(key));
2629
2630        for (int i = 102; i < 109; i++) {
2631            key = new Integer(i).toString();
2632            assertTrue(subDecendingMap_Included.containsKey(key));
2633            assertTrue(subDecendingMap_Excluded.containsKey(key));
2634        }
2635        key = new Integer(109).toString();
2636        assertTrue(subDecendingMap_Included.containsKey(key));
2637        assertTrue(subDecendingMap_Excluded.containsKey(key));
2638
2639        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
2640                .descendingMap();
2641        endKey = new Integer(100).toString();
2642        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2643        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2644        key = endKey;
2645        assertTrue(subDecendingMap_Included.containsKey(key));
2646        assertFalse(subDecendingMap_Excluded.containsKey(key));
2647
2648        endKey = new Integer(101).toString();
2649        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2650        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2651
2652        key = endKey;
2653        assertTrue(subDecendingMap_Included.containsKey(key));
2654        assertFalse(subDecendingMap_Excluded.containsKey(key));
2655
2656        for (int i = 102; i < 109; i++) {
2657            key = new Integer(i).toString();
2658            assertTrue(subDecendingMap_Included.containsKey(key));
2659            assertTrue(subDecendingMap_Excluded.containsKey(key));
2660        }
2661        key = new Integer(109).toString();
2662        assertFalse(subDecendingMap_Included.containsKey(key));
2663        assertFalse(subDecendingMap_Excluded.containsKey(key));
2664
2665        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
2666                .descendingMap();
2667        endKey = new Integer(100).toString();
2668        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2669        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2670        key = endKey;
2671        assertTrue(subDecendingMap_Included.containsKey(key));
2672        assertFalse(subDecendingMap_Excluded.containsKey(key));
2673
2674        endKey = new Integer(101).toString();
2675        subDecendingMap_Included = decendingMap.headMap(endKey, true);
2676        subDecendingMap_Excluded = decendingMap.headMap(endKey, false);
2677
2678        key = endKey;
2679        assertTrue(subDecendingMap_Included.containsKey(key));
2680        assertFalse(subDecendingMap_Excluded.containsKey(key));
2681
2682        for (int i = 102; i < 109; i++) {
2683            key = new Integer(i).toString();
2684            assertTrue(subDecendingMap_Included.containsKey(key));
2685            assertTrue(subDecendingMap_Excluded.containsKey(key));
2686        }
2687        key = new Integer(109).toString();
2688        assertTrue(subDecendingMap_Included.containsKey(key));
2689        assertTrue(subDecendingMap_Excluded.containsKey(key));
2690    }
2691
2692    public void test_DescendingSubMap_subMap() {
2693        NavigableMap descendingMap = tm.descendingMap();
2694        String startKey = new Integer(109).toString();
2695        String endKey = new Integer(100).toString();
2696        try {
2697            descendingMap.subMap(endKey, false, startKey, false);
2698        } catch (IllegalArgumentException e) {
2699            // Expected
2700        }
2701
2702        SortedMap subDescendingMap = descendingMap.subMap(startKey, false,
2703                endKey, false);
2704        String key = new Integer(100).toString();
2705        assertFalse(subDescendingMap.containsKey(key));
2706        for (int i = 101; i < 109; i++) {
2707            key = new Integer(i).toString();
2708            assertTrue(subDescendingMap.containsKey(key));
2709        }
2710        key = new Integer(109).toString();
2711        assertFalse(subDescendingMap.containsKey(key));
2712
2713        subDescendingMap = descendingMap.subMap(startKey, false, endKey, true);
2714        key = new Integer(100).toString();
2715        assertTrue(subDescendingMap.containsKey(key));
2716        for (int i = 101; i < 109; i++) {
2717            key = new Integer(i).toString();
2718            assertTrue(subDescendingMap.containsKey(key));
2719        }
2720        key = new Integer(109).toString();
2721        assertFalse(subDescendingMap.containsKey(key));
2722
2723        subDescendingMap = descendingMap.subMap(startKey, true, endKey, false);
2724        key = new Integer(100).toString();
2725        assertFalse(subDescendingMap.containsKey(key));
2726        for (int i = 101; i < 109; i++) {
2727            key = new Integer(i).toString();
2728            assertTrue(subDescendingMap.containsKey(key));
2729        }
2730        key = new Integer(109).toString();
2731        assertTrue(subDescendingMap.containsKey(key));
2732
2733        subDescendingMap = descendingMap.subMap(startKey, true, endKey, true);
2734        key = new Integer(100).toString();
2735        assertTrue(subDescendingMap.containsKey(key));
2736        for (int i = 101; i < 109; i++) {
2737            key = new Integer(i).toString();
2738            assertTrue(subDescendingMap.containsKey(key));
2739        }
2740        key = new Integer(109).toString();
2741        assertTrue(subDescendingMap.containsKey(key));
2742
2743        TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>();
2744        for (int i = -10; i < 10; i++) {
2745            treeMap.put(i, String.valueOf(i));
2746        }
2747        descendingMap = treeMap.descendingMap();
2748        subDescendingMap = descendingMap.subMap(5, 0);
2749        assertEquals(5, subDescendingMap.size());
2750    }
2751
2752    public void test_DescendingSubMap_tailMap() {
2753        // tm
2754        NavigableMap decendingMap = tm.descendingMap();
2755        String endKey = new Integer(1000).toString(), key;
2756        SortedMap subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2757        SortedMap subDecendingMap_Excluded = decendingMap
2758                .tailMap(endKey, false);
2759
2760        key = endKey;
2761        assertFalse(subDecendingMap_Included.containsKey(key));
2762        assertFalse(subDecendingMap_Excluded.containsKey(key));
2763        key = new Integer(100).toString();
2764        assertTrue(subDecendingMap_Included.containsKey(key));
2765        assertTrue(subDecendingMap_Excluded.containsKey(key));
2766
2767        key = new Integer(10).toString();
2768        assertTrue(subDecendingMap_Included.containsKey(key));
2769        assertTrue(subDecendingMap_Excluded.containsKey(key));
2770
2771        key = new Integer(1).toString();
2772        assertTrue(subDecendingMap_Included.containsKey(key));
2773        assertTrue(subDecendingMap_Excluded.containsKey(key));
2774
2775        key = new Integer(0).toString();
2776        assertTrue(subDecendingMap_Included.containsKey(key));
2777        assertTrue(subDecendingMap_Excluded.containsKey(key));
2778
2779        endKey = new Integer(999).toString();
2780        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2781        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2782        key = endKey;
2783        assertTrue(subDecendingMap_Included.containsKey(key));
2784        assertFalse(subDecendingMap_Excluded.containsKey(key));
2785        for (int i = 998; i > 0; i--) {
2786            key = new Integer(i).toString();
2787            assertTrue(subDecendingMap_Included.containsKey(key));
2788            assertTrue(subDecendingMap_Excluded.containsKey(key));
2789        }
2790        key = new Integer(0).toString();
2791        assertTrue(subDecendingMap_Included.containsKey(key));
2792        assertTrue(subDecendingMap_Excluded.containsKey(key));
2793
2794        endKey = new Integer(0).toString();
2795        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2796        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2797        assertEquals(1, subDecendingMap_Included.size());
2798        key = endKey;
2799        assertTrue(subDecendingMap_Included.containsKey(key));
2800        assertTrue(subDecendingMap_Excluded.isEmpty());
2801
2802        // navigableMap_startExcluded_endExcluded
2803        decendingMap = navigableMap_startExcluded_endExcluded.descendingMap();
2804        endKey = new Integer(110).toString();
2805        try {
2806            decendingMap.tailMap(endKey, true);
2807            fail("should throw IllegalArgumentException");
2808        } catch (IllegalArgumentException e) {
2809            // Expected
2810        }
2811
2812        try {
2813            decendingMap.tailMap(endKey, false);
2814            fail("should throw IllegalArgumentException");
2815        } catch (IllegalArgumentException e) {
2816            // Expected
2817        }
2818
2819        endKey = new Integer(109).toString();
2820        try {
2821            decendingMap.tailMap(endKey, true);
2822            fail("should throw IllegalArgumentException");
2823        } catch (IllegalArgumentException e) {
2824            // Expected
2825        }
2826        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2827        key = endKey;
2828        assertFalse(subDecendingMap_Excluded.containsKey(key));
2829
2830        endKey = new Integer(108).toString();
2831        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2832        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2833        key = endKey;
2834        assertTrue(subDecendingMap_Included.containsKey(key));
2835        assertFalse(subDecendingMap_Excluded.containsKey(key));
2836        for (int i = 107; i > 100; i--) {
2837            key = new Integer(i).toString();
2838            assertTrue(subDecendingMap_Included.containsKey(key));
2839            assertTrue(subDecendingMap_Excluded.containsKey(key));
2840        }
2841        key = new Integer(100).toString();
2842        assertFalse(subDecendingMap_Included.containsKey(key));
2843        assertFalse(subDecendingMap_Included.containsKey(key));
2844
2845        endKey = new Integer(101).toString();
2846        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2847        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2848        key = endKey;
2849        assertEquals(1, subDecendingMap_Included.size());
2850        assertTrue(subDecendingMap_Included.containsKey(key));
2851        assertTrue(subDecendingMap_Excluded.isEmpty());
2852
2853        endKey = new Integer(100).toString();
2854        try {
2855            decendingMap.tailMap(endKey, true);
2856            fail("should throw IllegalArgumentException");
2857        } catch (IllegalArgumentException e) {
2858            // Expected
2859        }
2860        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2861        assertTrue(subDecendingMap_Excluded.isEmpty());
2862
2863        endKey = new Integer(99).toString();
2864        try {
2865            decendingMap.tailMap(endKey, true);
2866            fail("should throw IllegalArgumentException");
2867        } catch (IllegalArgumentException e) {
2868            // Expected
2869        }
2870
2871        try {
2872            decendingMap.tailMap(endKey, false);
2873            fail("should throw IllegalArgumentException");
2874        } catch (IllegalArgumentException e) {
2875            // Expected
2876        }
2877
2878        // navigableMap_startExcluded_endIncluded
2879        decendingMap = navigableMap_startExcluded_endIncluded.descendingMap();
2880        endKey = new Integer(110).toString();
2881        try {
2882            decendingMap.tailMap(endKey, true);
2883            fail("should throw IllegalArgumentException");
2884        } catch (IllegalArgumentException e) {
2885            // Expected
2886        }
2887
2888        try {
2889            decendingMap.tailMap(endKey, false);
2890            fail("should throw IllegalArgumentException");
2891        } catch (IllegalArgumentException e) {
2892            // Expected
2893        }
2894
2895        endKey = new Integer(109).toString();
2896        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2897        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2898        key = endKey;
2899        assertTrue(subDecendingMap_Included.containsKey(key));
2900        assertFalse(subDecendingMap_Excluded.containsKey(key));
2901
2902        endKey = new Integer(108).toString();
2903        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2904        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2905        key = endKey;
2906        assertTrue(subDecendingMap_Included.containsKey(key));
2907        assertFalse(subDecendingMap_Excluded.containsKey(key));
2908        for (int i = 107; i > 100; i--) {
2909            key = new Integer(i).toString();
2910            assertTrue(subDecendingMap_Included.containsKey(key));
2911            assertTrue(subDecendingMap_Excluded.containsKey(key));
2912        }
2913        key = new Integer(100).toString();
2914        assertFalse(subDecendingMap_Included.containsKey(key));
2915        assertFalse(subDecendingMap_Included.containsKey(key));
2916
2917        endKey = new Integer(101).toString();
2918        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2919        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2920        key = endKey;
2921        assertEquals(1, subDecendingMap_Included.size());
2922        assertTrue(subDecendingMap_Included.containsKey(key));
2923        assertTrue(subDecendingMap_Excluded.isEmpty());
2924
2925        endKey = new Integer(100).toString();
2926        try {
2927            decendingMap.tailMap(endKey, true);
2928            fail("should throw IllegalArgumentException");
2929        } catch (IllegalArgumentException e) {
2930            // Expected
2931        }
2932        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2933        assertTrue(subDecendingMap_Excluded.isEmpty());
2934
2935        endKey = new Integer(99).toString();
2936        try {
2937            decendingMap.tailMap(endKey, true);
2938            fail("should throw IllegalArgumentException");
2939        } catch (IllegalArgumentException e) {
2940            // Expected
2941        }
2942        try {
2943            decendingMap.tailMap(endKey, false);
2944            fail("should throw IllegalArgumentException");
2945        } catch (IllegalArgumentException e) {
2946            // Expected
2947        }
2948
2949        // navigableMap_startIncluded_endExcluded
2950        decendingMap = navigableMap_startIncluded_endExcluded.descendingMap();
2951        endKey = new Integer(110).toString();
2952        try {
2953            decendingMap.tailMap(endKey, true);
2954            fail("should throw IllegalArgumentException");
2955        } catch (IllegalArgumentException e) {
2956            // Expected
2957        }
2958
2959        try {
2960            decendingMap.tailMap(endKey, false);
2961            fail("should throw IllegalArgumentException");
2962        } catch (IllegalArgumentException e) {
2963            // Expected
2964        }
2965
2966        endKey = new Integer(109).toString();
2967        try {
2968            decendingMap.tailMap(endKey, true);
2969
2970        } catch (IllegalArgumentException e) {
2971            // Expected
2972        }
2973        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2974        key = endKey;
2975        assertFalse(subDecendingMap_Excluded.containsKey(key));
2976
2977        endKey = new Integer(108).toString();
2978        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2979        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2980        key = endKey;
2981        assertTrue(subDecendingMap_Included.containsKey(key));
2982        assertFalse(subDecendingMap_Excluded.containsKey(key));
2983        for (int i = 107; i > 100; i--) {
2984            key = new Integer(i).toString();
2985            assertTrue(subDecendingMap_Included.containsKey(key));
2986            assertTrue(subDecendingMap_Excluded.containsKey(key));
2987        }
2988        key = new Integer(100).toString();
2989        assertTrue(subDecendingMap_Included.containsKey(key));
2990        assertTrue(subDecendingMap_Included.containsKey(key));
2991
2992        endKey = new Integer(101).toString();
2993        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
2994        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
2995        key = endKey;
2996        assertEquals(2, subDecendingMap_Included.size());
2997        assertTrue(subDecendingMap_Included.containsKey(key));
2998        assertFalse(subDecendingMap_Excluded.containsKey(key));
2999
3000        endKey = new Integer(100).toString();
3001        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3002        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3003        key = endKey;
3004        assertTrue(subDecendingMap_Included.containsKey(key));
3005        assertFalse(subDecendingMap_Excluded.containsKey(key));
3006
3007        endKey = new Integer(99).toString();
3008        try {
3009            decendingMap.tailMap(endKey, true);
3010            fail("should throw IllegalArgumentException");
3011        } catch (IllegalArgumentException e) {
3012            // Expected
3013        }
3014        try {
3015            decendingMap.tailMap(endKey, false);
3016            fail("should throw IllegalArgumentException");
3017        } catch (IllegalArgumentException e) {
3018            // Expected
3019        }
3020
3021        // navigableMap_startIncluded_endIncluded
3022        decendingMap = navigableMap_startIncluded_endIncluded.descendingMap();
3023        endKey = new Integer(110).toString();
3024        try {
3025            decendingMap.tailMap(endKey, true);
3026            fail("should throw IllegalArgumentException");
3027        } catch (IllegalArgumentException e) {
3028            // Expected
3029        }
3030        try {
3031            decendingMap.tailMap(endKey, false);
3032            fail("should throw IllegalArgumentException");
3033        } catch (IllegalArgumentException e) {
3034            // Expected
3035        }
3036
3037        endKey = new Integer(109).toString();
3038        try {
3039            decendingMap.tailMap(endKey, true);
3040
3041        } catch (IllegalArgumentException e) {
3042            // Expected
3043        }
3044        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3045        key = endKey;
3046        assertFalse(subDecendingMap_Excluded.containsKey(key));
3047
3048        endKey = new Integer(108).toString();
3049        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3050        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3051        key = endKey;
3052        assertTrue(subDecendingMap_Included.containsKey(key));
3053        assertFalse(subDecendingMap_Excluded.containsKey(key));
3054        for (int i = 107; i > 100; i--) {
3055            key = new Integer(i).toString();
3056            assertTrue(subDecendingMap_Included.containsKey(key));
3057            assertTrue(subDecendingMap_Excluded.containsKey(key));
3058        }
3059        key = new Integer(100).toString();
3060        assertTrue(subDecendingMap_Included.containsKey(key));
3061        assertTrue(subDecendingMap_Included.containsKey(key));
3062
3063        endKey = new Integer(101).toString();
3064        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3065        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3066        key = endKey;
3067        assertEquals(2, subDecendingMap_Included.size());
3068        assertTrue(subDecendingMap_Included.containsKey(key));
3069        assertFalse(subDecendingMap_Excluded.containsKey(key));
3070
3071        endKey = new Integer(100).toString();
3072        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3073        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3074        key = endKey;
3075        assertTrue(subDecendingMap_Included.containsKey(key));
3076        assertFalse(subDecendingMap_Excluded.containsKey(key));
3077
3078        endKey = new Integer(99).toString();
3079        try {
3080            decendingMap.tailMap(endKey, true);
3081            fail("should throw IllegalArgumentException");
3082        } catch (IllegalArgumentException e) {
3083            // Expected
3084        }
3085        try {
3086            decendingMap.tailMap(endKey, false);
3087            fail("should throw IllegalArgumentException");
3088        } catch (IllegalArgumentException e) {
3089            // Expected
3090        }
3091
3092        // With Comparator
3093        decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
3094                .descendingMap();
3095        endKey = new Integer(110).toString();
3096        try {
3097            decendingMap.tailMap(endKey, true);
3098            fail("should throw IllegalArgumentException");
3099        } catch (IllegalArgumentException e) {
3100            // Expected
3101        }
3102
3103        try {
3104            decendingMap.tailMap(endKey, false);
3105            fail("should throw IllegalArgumentException");
3106        } catch (IllegalArgumentException e) {
3107            // Expected
3108        }
3109
3110        endKey = new Integer(109).toString();
3111        try {
3112            decendingMap.tailMap(endKey, true);
3113            fail("should throw IllegalArgumentException");
3114        } catch (IllegalArgumentException e) {
3115            // Expected
3116        }
3117        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3118        key = endKey;
3119        assertFalse(subDecendingMap_Excluded.containsKey(key));
3120
3121        endKey = new Integer(108).toString();
3122        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3123        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3124        key = endKey;
3125        assertTrue(subDecendingMap_Included.containsKey(key));
3126        assertFalse(subDecendingMap_Excluded.containsKey(key));
3127        for (int i = 107; i > 100; i--) {
3128            key = new Integer(i).toString();
3129            assertTrue(subDecendingMap_Included.containsKey(key));
3130            assertTrue(subDecendingMap_Excluded.containsKey(key));
3131        }
3132        key = new Integer(100).toString();
3133        assertFalse(subDecendingMap_Included.containsKey(key));
3134        assertFalse(subDecendingMap_Included.containsKey(key));
3135
3136        endKey = new Integer(101).toString();
3137        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3138        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3139        key = endKey;
3140        assertEquals(1, subDecendingMap_Included.size());
3141        assertTrue(subDecendingMap_Included.containsKey(key));
3142        assertTrue(subDecendingMap_Excluded.isEmpty());
3143
3144        endKey = new Integer(100).toString();
3145        try {
3146            decendingMap.tailMap(endKey, true);
3147            fail("should throw IllegalArgumentException");
3148        } catch (IllegalArgumentException e) {
3149            // Expected
3150        }
3151        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3152        assertTrue(subDecendingMap_Excluded.isEmpty());
3153
3154        endKey = new Integer(99).toString();
3155        try {
3156            decendingMap.tailMap(endKey, true);
3157            fail("should throw IllegalArgumentException");
3158        } catch (IllegalArgumentException e) {
3159            // Expected
3160        }
3161
3162        try {
3163            decendingMap.tailMap(endKey, false);
3164            fail("should throw IllegalArgumentException");
3165        } catch (IllegalArgumentException e) {
3166            // Expected
3167        }
3168
3169        decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
3170                .descendingMap();
3171        endKey = new Integer(110).toString();
3172        try {
3173            decendingMap.tailMap(endKey, true);
3174            fail("should throw IllegalArgumentException");
3175        } catch (IllegalArgumentException e) {
3176            // Expected
3177        }
3178
3179        try {
3180            decendingMap.tailMap(endKey, false);
3181            fail("should throw IllegalArgumentException");
3182        } catch (IllegalArgumentException e) {
3183            // Expected
3184        }
3185
3186        endKey = new Integer(109).toString();
3187        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3188        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3189        key = endKey;
3190        assertTrue(subDecendingMap_Included.containsKey(key));
3191        assertFalse(subDecendingMap_Excluded.containsKey(key));
3192
3193        endKey = new Integer(108).toString();
3194        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3195        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3196        key = endKey;
3197        assertTrue(subDecendingMap_Included.containsKey(key));
3198        assertFalse(subDecendingMap_Excluded.containsKey(key));
3199        for (int i = 107; i > 100; i--) {
3200            key = new Integer(i).toString();
3201            assertTrue(subDecendingMap_Included.containsKey(key));
3202            assertTrue(subDecendingMap_Excluded.containsKey(key));
3203        }
3204        key = new Integer(100).toString();
3205        assertFalse(subDecendingMap_Included.containsKey(key));
3206        assertFalse(subDecendingMap_Included.containsKey(key));
3207
3208        endKey = new Integer(101).toString();
3209        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3210        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3211        key = endKey;
3212        assertEquals(1, subDecendingMap_Included.size());
3213        assertTrue(subDecendingMap_Included.containsKey(key));
3214        assertTrue(subDecendingMap_Excluded.isEmpty());
3215
3216        endKey = new Integer(100).toString();
3217        try {
3218            decendingMap.tailMap(endKey, true);
3219            fail("should throw IllegalArgumentException");
3220        } catch (IllegalArgumentException e) {
3221            // Expected
3222        }
3223        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3224        assertTrue(subDecendingMap_Excluded.isEmpty());
3225
3226        endKey = new Integer(99).toString();
3227        try {
3228            decendingMap.tailMap(endKey, true);
3229            fail("should throw IllegalArgumentException");
3230        } catch (IllegalArgumentException e) {
3231            // Expected
3232        }
3233        try {
3234            decendingMap.tailMap(endKey, false);
3235            fail("should throw IllegalArgumentException");
3236        } catch (IllegalArgumentException e) {
3237            // Expected
3238        }
3239
3240        // navigableMap_startIncluded_endExcluded
3241        decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded)
3242                .descendingMap();
3243        endKey = new Integer(110).toString();
3244        try {
3245            decendingMap.tailMap(endKey, true);
3246            fail("should throw IllegalArgumentException");
3247        } catch (IllegalArgumentException e) {
3248            // Expected
3249        }
3250
3251        try {
3252            decendingMap.tailMap(endKey, false);
3253            fail("should throw IllegalArgumentException");
3254        } catch (IllegalArgumentException e) {
3255            // Expected
3256        }
3257
3258        endKey = new Integer(109).toString();
3259        try {
3260            decendingMap.tailMap(endKey, true);
3261
3262        } catch (IllegalArgumentException e) {
3263            // Expected
3264        }
3265        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3266        key = endKey;
3267        assertFalse(subDecendingMap_Excluded.containsKey(key));
3268
3269        endKey = new Integer(108).toString();
3270        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3271        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3272        key = endKey;
3273        assertTrue(subDecendingMap_Included.containsKey(key));
3274        assertFalse(subDecendingMap_Excluded.containsKey(key));
3275        for (int i = 107; i > 100; i--) {
3276            key = new Integer(i).toString();
3277            assertTrue(subDecendingMap_Included.containsKey(key));
3278            assertTrue(subDecendingMap_Excluded.containsKey(key));
3279        }
3280        key = new Integer(100).toString();
3281        assertTrue(subDecendingMap_Included.containsKey(key));
3282        assertTrue(subDecendingMap_Included.containsKey(key));
3283
3284        endKey = new Integer(101).toString();
3285        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3286        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3287        key = endKey;
3288        assertEquals(2, subDecendingMap_Included.size());
3289        assertTrue(subDecendingMap_Included.containsKey(key));
3290        assertFalse(subDecendingMap_Excluded.containsKey(key));
3291
3292        endKey = new Integer(100).toString();
3293        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3294        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3295        key = endKey;
3296        assertTrue(subDecendingMap_Included.containsKey(key));
3297        assertFalse(subDecendingMap_Excluded.containsKey(key));
3298
3299        endKey = new Integer(99).toString();
3300        try {
3301            decendingMap.tailMap(endKey, true);
3302            fail("should throw IllegalArgumentException");
3303        } catch (IllegalArgumentException e) {
3304            // Expected
3305        }
3306        try {
3307            decendingMap.tailMap(endKey, false);
3308            fail("should throw IllegalArgumentException");
3309        } catch (IllegalArgumentException e) {
3310            // Expected
3311        }
3312
3313        decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded)
3314                .descendingMap();
3315        endKey = new Integer(110).toString();
3316        try {
3317            decendingMap.tailMap(endKey, true);
3318            fail("should throw IllegalArgumentException");
3319        } catch (IllegalArgumentException e) {
3320            // Expected
3321        }
3322        try {
3323            decendingMap.tailMap(endKey, false);
3324            fail("should throw IllegalArgumentException");
3325        } catch (IllegalArgumentException e) {
3326            // Expected
3327        }
3328
3329        endKey = new Integer(109).toString();
3330        try {
3331            decendingMap.tailMap(endKey, true);
3332
3333        } catch (IllegalArgumentException e) {
3334            // Expected
3335        }
3336        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3337        key = endKey;
3338        assertFalse(subDecendingMap_Excluded.containsKey(key));
3339
3340        endKey = new Integer(108).toString();
3341        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3342        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3343        key = endKey;
3344        assertTrue(subDecendingMap_Included.containsKey(key));
3345        assertFalse(subDecendingMap_Excluded.containsKey(key));
3346        for (int i = 107; i > 100; i--) {
3347            key = new Integer(i).toString();
3348            assertTrue(subDecendingMap_Included.containsKey(key));
3349            assertTrue(subDecendingMap_Excluded.containsKey(key));
3350        }
3351        key = new Integer(100).toString();
3352        assertTrue(subDecendingMap_Included.containsKey(key));
3353        assertTrue(subDecendingMap_Included.containsKey(key));
3354
3355        endKey = new Integer(101).toString();
3356        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3357        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3358        key = endKey;
3359        assertEquals(2, subDecendingMap_Included.size());
3360        assertTrue(subDecendingMap_Included.containsKey(key));
3361        assertFalse(subDecendingMap_Excluded.containsKey(key));
3362
3363        endKey = new Integer(100).toString();
3364        subDecendingMap_Included = decendingMap.tailMap(endKey, true);
3365        subDecendingMap_Excluded = decendingMap.tailMap(endKey, false);
3366        key = endKey;
3367        assertTrue(subDecendingMap_Included.containsKey(key));
3368        assertFalse(subDecendingMap_Excluded.containsKey(key));
3369
3370        endKey = new Integer(99).toString();
3371        try {
3372            decendingMap.tailMap(endKey, true);
3373            fail("should throw IllegalArgumentException");
3374        } catch (IllegalArgumentException e) {
3375            // Expected
3376        }
3377        try {
3378            decendingMap.tailMap(endKey, false);
3379            fail("should throw IllegalArgumentException");
3380        } catch (IllegalArgumentException e) {
3381            // Expected
3382        }
3383    }
3384
3385    public void test_Entry_setValue() {
3386        TreeMap treeMap = new TreeMap();
3387        Integer value = null;
3388        for (int i = 0; i < 50; i++) {
3389            value = new Integer(i);
3390            treeMap.put(value, value);
3391        }
3392        Map checkedMap = Collections.checkedMap(treeMap, Integer.class,
3393                Integer.class);
3394        Set entrySet = checkedMap.entrySet();
3395        Iterator iterator = entrySet.iterator();
3396        Entry entry;
3397        value = new Integer(0);
3398        for (; iterator.hasNext(); value++) {
3399            entry = (Entry) iterator.next();
3400            assertEquals(value, entry.setValue(value + 1));
3401            assertEquals(value + 1, entry.getValue());
3402        }
3403    }
3404
3405    public void test_DescendingSubMapEntrySet_comparator() {
3406        Set entrySet;
3407        NavigableSet descendingSet;
3408        Comparator comparator;
3409        Entry[] entryArray;
3410        Integer value1, value2;
3411
3412        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3413        if (entrySet instanceof NavigableSet) {
3414            descendingSet = ((NavigableSet) entrySet).descendingSet();
3415            assertNull(((NavigableSet) entrySet).comparator());
3416            comparator = descendingSet.comparator();
3417            assertNotNull(comparator);
3418
3419            entryArray = (Entry[]) descendingSet
3420                    .toArray(new Entry[descendingSet.size()]);
3421            for (int i = 1; i < entryArray.length; i++) {
3422                value1 = (Integer) entryArray[i - 1].getValue();
3423                value2 = (Integer) entryArray[i].getValue();
3424                assertTrue(value1 > value2);
3425                assertTrue(comparator.compare(value1, value2) < 0);
3426            }
3427        }
3428
3429        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3430        if (entrySet instanceof NavigableSet) {
3431            descendingSet = ((NavigableSet) entrySet).descendingSet();
3432            assertNull(((NavigableSet) entrySet).comparator());
3433            comparator = descendingSet.comparator();
3434            assertNotNull(comparator);
3435
3436            entryArray = (Entry[]) descendingSet
3437                    .toArray(new Entry[descendingSet.size()]);
3438            for (int i = 1; i < entryArray.length; i++) {
3439                value1 = (Integer) entryArray[i - 1].getValue();
3440                value2 = (Integer) entryArray[i].getValue();
3441                assertTrue(value1 > value2);
3442                assertTrue(comparator.compare(value1, value2) < 0);
3443            }
3444        }
3445
3446        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3447        if (entrySet instanceof NavigableSet) {
3448            descendingSet = ((NavigableSet) entrySet).descendingSet();
3449            assertNull(((NavigableSet) entrySet).comparator());
3450            comparator = descendingSet.comparator();
3451            assertNotNull(comparator);
3452
3453            entryArray = (Entry[]) descendingSet
3454                    .toArray(new Entry[descendingSet.size()]);
3455            for (int i = 1; i < entryArray.length; i++) {
3456                value1 = (Integer) entryArray[i - 1].getValue();
3457                value2 = (Integer) entryArray[i].getValue();
3458                assertTrue(value1 > value2);
3459                assertTrue(comparator.compare(value1, value2) < 0);
3460            }
3461        }
3462
3463        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3464        if (entrySet instanceof NavigableSet) {
3465            descendingSet = ((NavigableSet) entrySet).descendingSet();
3466            assertNull(((NavigableSet) entrySet).comparator());
3467            comparator = descendingSet.comparator();
3468            assertNotNull(comparator);
3469
3470            entryArray = (Entry[]) descendingSet
3471                    .toArray(new Entry[descendingSet.size()]);
3472            for (int i = 1; i < entryArray.length; i++) {
3473                value1 = (Integer) entryArray[i - 1].getValue();
3474                value2 = (Integer) entryArray[i].getValue();
3475                assertTrue(value1 > value2);
3476                assertTrue(comparator.compare(value1, value2) < 0);
3477            }
3478        }
3479
3480        String endKey = new Integer(2).toString();
3481        entrySet = tm.headMap(endKey, true).entrySet();
3482        if (entrySet instanceof NavigableSet) {
3483            descendingSet = ((NavigableSet) entrySet).descendingSet();
3484            assertNotNull(descendingSet.comparator());
3485        }
3486    }
3487
3488    public void test_DescendingSubMapEntrySet_descendingSet() {
3489        Set entrySet;
3490        NavigableSet ascendingSubMapEntrySet, descendingSet, descendingDescedingSet;
3491        Entry[] ascendingEntryArray, descendingDescendingArray;
3492
3493        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3494        if (entrySet instanceof NavigableSet) {
3495            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3496            descendingSet = ascendingSubMapEntrySet.descendingSet();
3497            descendingDescedingSet = descendingSet.descendingSet();
3498            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3499                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3500
3501            descendingDescendingArray = (Entry[]) descendingDescedingSet
3502                    .toArray(new Entry[descendingDescedingSet.size()]);
3503
3504            assertEquals(ascendingEntryArray.length,
3505                    descendingDescendingArray.length);
3506            for (int i = 0; i < ascendingEntryArray.length; i++) {
3507                assertEquals(ascendingEntryArray[i],
3508                        descendingDescendingArray[i]);
3509            }
3510        }
3511
3512        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3513        if (entrySet instanceof NavigableSet) {
3514            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3515            descendingSet = ascendingSubMapEntrySet.descendingSet();
3516            descendingDescedingSet = descendingSet.descendingSet();
3517            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3518                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3519
3520            descendingDescendingArray = (Entry[]) descendingDescedingSet
3521                    .toArray(new Entry[descendingDescedingSet.size()]);
3522
3523            assertEquals(ascendingEntryArray.length,
3524                    descendingDescendingArray.length);
3525            for (int i = 0; i < ascendingEntryArray.length; i++) {
3526                assertEquals(ascendingEntryArray[i],
3527                        descendingDescendingArray[i]);
3528            }
3529        }
3530
3531        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3532        if (entrySet instanceof NavigableSet) {
3533            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3534            descendingSet = ascendingSubMapEntrySet.descendingSet();
3535            descendingDescedingSet = descendingSet.descendingSet();
3536            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3537                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3538
3539            descendingDescendingArray = (Entry[]) descendingDescedingSet
3540                    .toArray(new Entry[descendingDescedingSet.size()]);
3541
3542            assertEquals(ascendingEntryArray.length,
3543                    descendingDescendingArray.length);
3544            for (int i = 0; i < ascendingEntryArray.length; i++) {
3545                assertEquals(ascendingEntryArray[i],
3546                        descendingDescendingArray[i]);
3547            }
3548        }
3549
3550        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3551        if (entrySet instanceof NavigableSet) {
3552            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3553            descendingSet = ascendingSubMapEntrySet.descendingSet();
3554            descendingDescedingSet = descendingSet.descendingSet();
3555            ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet
3556                    .toArray(new Entry[ascendingSubMapEntrySet.size()]);
3557
3558            descendingDescendingArray = (Entry[]) descendingDescedingSet
3559                    .toArray(new Entry[descendingDescedingSet.size()]);
3560
3561            assertEquals(ascendingEntryArray.length,
3562                    descendingDescendingArray.length);
3563            for (int i = 0; i < ascendingEntryArray.length; i++) {
3564                assertEquals(ascendingEntryArray[i],
3565                        descendingDescendingArray[i]);
3566            }
3567        }
3568
3569        String endKey = new Integer(2).toString();
3570        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
3571        if (entrySet instanceof NavigableSet) {
3572            // [2...0]
3573            descendingSet = ((NavigableSet) entrySet).descendingSet();
3574            // [0...2]
3575            descendingDescedingSet = descendingSet.descendingSet();
3576            Iterator iterator = descendingDescedingSet.iterator();
3577            assertEquals(0, ((Entry) iterator.next()).getValue());
3578        }
3579
3580        String startKey = new Integer(2).toString();
3581        entrySet = tm.tailMap(startKey, true).entrySet();// 2...
3582        if (entrySet instanceof NavigableSet) {
3583            // [2...0]
3584            descendingSet = ((NavigableSet) entrySet).descendingSet();
3585            // [0...2]
3586            descendingDescedingSet = descendingSet.descendingSet();
3587            Iterator iterator = descendingDescedingSet.iterator();
3588            assertEquals(2, ((Entry) iterator.next()).getValue());
3589        }
3590
3591    }
3592
3593    public void test_DescendingSubMapEntrySet_first() {
3594        Set entrySet;
3595        NavigableSet ascendingSubMapEntrySet, descendingSet;
3596        Entry entry;
3597
3598        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3599        if (entrySet instanceof NavigableSet) {
3600            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3601            descendingSet = ascendingSubMapEntrySet.descendingSet();
3602            entry = (Entry) descendingSet.first();
3603            assertEquals(101, entry.getValue());
3604        }
3605
3606        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3607        if (entrySet instanceof NavigableSet) {
3608            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3609            descendingSet = ascendingSubMapEntrySet.descendingSet();
3610            entry = (Entry) descendingSet.first();
3611            assertEquals(101, entry.getValue());
3612        }
3613
3614        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3615        if (entrySet instanceof NavigableSet) {
3616            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3617            descendingSet = ascendingSubMapEntrySet.descendingSet();
3618            entry = (Entry) descendingSet.first();
3619            assertEquals(100, entry.getValue());
3620        }
3621
3622        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3623        if (entrySet instanceof NavigableSet) {
3624            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3625            descendingSet = ascendingSubMapEntrySet.descendingSet();
3626            entry = (Entry) descendingSet.first();
3627            assertEquals(100, entry.getValue());
3628        }
3629    }
3630
3631    public void test_DescendingSubMapEntrySet_last() {
3632        Set entrySet;
3633        NavigableSet ascendingSubMapEntrySet, descendingSet;
3634        Entry entry;
3635
3636        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3637        if (entrySet instanceof NavigableSet) {
3638            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3639            descendingSet = ascendingSubMapEntrySet.descendingSet();
3640            entry = (Entry) descendingSet.last();
3641            assertEquals(108, entry.getValue());
3642        }
3643
3644        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3645        if (entrySet instanceof NavigableSet) {
3646            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3647            descendingSet = ascendingSubMapEntrySet.descendingSet();
3648            entry = (Entry) descendingSet.last();
3649            assertEquals(109, entry.getValue());
3650        }
3651
3652        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3653        if (entrySet instanceof NavigableSet) {
3654            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3655            descendingSet = ascendingSubMapEntrySet.descendingSet();
3656            entry = (Entry) descendingSet.last();
3657            assertEquals(108, entry.getValue());
3658        }
3659
3660        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3661        if (entrySet instanceof NavigableSet) {
3662            ascendingSubMapEntrySet = (NavigableSet) entrySet;
3663            descendingSet = ascendingSubMapEntrySet.descendingSet();
3664            entry = (Entry) descendingSet.last();
3665            assertEquals(109, entry.getValue());
3666        }
3667    }
3668
3669    public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() {
3670        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3671        Entry entry;
3672        if (entrySet instanceof NavigableSet) {
3673            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3674                    .descendingSet();
3675            assertEquals(8, descendingSubMapEntrySet.size());
3676            for (int i = 101; i < 109; i++) {
3677                entry = (Entry) descendingSubMapEntrySet.pollFirst();
3678                assertEquals(i, entry.getValue());
3679            }
3680            assertNull(descendingSubMapEntrySet.pollFirst());
3681        }
3682    }
3683
3684    public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() {
3685        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3686        Entry entry;
3687        if (entrySet instanceof NavigableSet) {
3688            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3689                    .descendingSet();
3690            assertEquals(9, descendingSubMapEntrySet.size());
3691            for (int i = 101; i < 110; i++) {
3692                entry = (Entry) descendingSubMapEntrySet.pollFirst();
3693                assertEquals(i, entry.getValue());
3694            }
3695            assertNull(descendingSubMapEntrySet.pollFirst());
3696        }
3697    }
3698
3699    public void test_DescendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() {
3700        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3701        Entry entry;
3702        if (entrySet instanceof NavigableSet) {
3703            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3704                    .descendingSet();
3705            assertEquals(9, descendingSubMapEntrySet.size());
3706            for (int i = 100; 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_startIncluded_endIncluded() {
3715        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3716        Entry entry;
3717        if (entrySet instanceof NavigableSet) {
3718            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3719                    .descendingSet();
3720            assertEquals(10, descendingSubMapEntrySet.size());
3721            for (int i = 100; 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() {
3730        String key = new Integer(2).toString();
3731        Set entrySet = tm.headMap(key, true).entrySet();// [0...2]
3732        NavigableSet descendingEntrySet;
3733        Entry entry;
3734
3735        if (entrySet instanceof NavigableSet) {
3736            // [2...0]
3737            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3738            entry = (Entry) descendingEntrySet.pollFirst();
3739            assertEquals(0, entry.getValue());
3740        }
3741
3742        entrySet = tm.tailMap(key, true).entrySet();
3743        if (entrySet instanceof NavigableSet) {
3744            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3745            entry = (Entry) descendingEntrySet.pollFirst();
3746            assertEquals(2, entry.getValue());
3747        }
3748    }
3749
3750    public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endExclued() {
3751        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3752        Entry entry;
3753        if (entrySet instanceof NavigableSet) {
3754            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3755                    .descendingSet();
3756            assertEquals(8, descendingSubMapEntrySet.size());
3757            for (int i = 108; i > 100; i--) {
3758                entry = (Entry) descendingSubMapEntrySet.pollLast();
3759                assertEquals(i, entry.getValue());
3760            }
3761            assertNull(descendingSubMapEntrySet.pollFirst());
3762        }
3763    }
3764
3765    public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endInclued() {
3766        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3767        Entry entry;
3768        if (entrySet instanceof NavigableSet) {
3769            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3770                    .descendingSet();
3771            assertEquals(9, descendingSubMapEntrySet.size());
3772            for (int i = 109; i > 100; i--) {
3773                entry = (Entry) descendingSubMapEntrySet.pollLast();
3774                assertEquals(i, entry.getValue());
3775            }
3776            assertNull(descendingSubMapEntrySet.pollFirst());
3777        }
3778    }
3779
3780    public void test_DescendingSubMapEntrySet_pollLast_startIncluded_endExclued() {
3781        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3782        Entry entry;
3783        if (entrySet instanceof NavigableSet) {
3784            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3785                    .descendingSet();
3786            assertEquals(9, descendingSubMapEntrySet.size());
3787            for (int i = 108; i > 99; 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_startIncluded_endInclued() {
3796        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3797        Entry entry;
3798        if (entrySet instanceof NavigableSet) {
3799            NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet)
3800                    .descendingSet();
3801            assertEquals(10, descendingSubMapEntrySet.size());
3802            for (int i = 109; i > 99; 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() {
3811        String key = new Integer(2).toString();
3812        Set entrySet = tm.headMap(key, true).entrySet();// [0...2]
3813        NavigableSet descendingEntrySet;
3814        Entry entry;
3815
3816        if (entrySet instanceof NavigableSet) {
3817            // [2...0]
3818            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3819            entry = (Entry) descendingEntrySet.pollLast();
3820            assertEquals(2, entry.getValue());
3821        }
3822
3823        entrySet = tm.tailMap(key, true).entrySet();
3824        if (entrySet instanceof NavigableSet) {
3825            descendingEntrySet = ((NavigableSet) entrySet).descendingSet();
3826            entry = (Entry) descendingEntrySet.pollLast();
3827            assertEquals(999, entry.getValue());
3828        }
3829    }
3830
3831    public void test_DescendingSubMapEntrySet_descendingIterator() {
3832        Set entrySet;
3833        NavigableSet descendingSet;
3834        Iterator iterator;
3835
3836        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3837        if (entrySet instanceof NavigableSet) {
3838            descendingSet = ((NavigableSet) entrySet).descendingSet();
3839            iterator = descendingSet.iterator();
3840            for (int value = 108; value > 100; value--) {
3841                assertTrue(iterator.hasNext());
3842                assertEquals(value, ((Entry) iterator.next()).getValue());
3843            }
3844            assertFalse(iterator.hasNext());
3845            try {
3846                iterator.next();
3847                fail("should throw NoSuchElementException");
3848            } catch (NoSuchElementException e) {
3849                // Expected
3850            }
3851        }
3852
3853        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3854        if (entrySet instanceof NavigableSet) {
3855            descendingSet = ((NavigableSet) entrySet).descendingSet();
3856            iterator = descendingSet.iterator();
3857            for (int value = 109; value > 100; value--) {
3858                assertTrue(iterator.hasNext());
3859                assertEquals(value, ((Entry) iterator.next()).getValue());
3860            }
3861            assertFalse(iterator.hasNext());
3862            try {
3863                iterator.next();
3864                fail("should throw NoSuchElementException");
3865            } catch (NoSuchElementException e) {
3866                // Expected
3867            }
3868        }
3869
3870        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
3871        if (entrySet instanceof NavigableSet) {
3872            descendingSet = ((NavigableSet) entrySet).descendingSet();
3873            iterator = descendingSet.iterator();
3874            for (int value = 108; value > 99; value--) {
3875                assertTrue(iterator.hasNext());
3876                assertEquals(value, ((Entry) iterator.next()).getValue());
3877            }
3878            assertFalse(iterator.hasNext());
3879            try {
3880                iterator.next();
3881                fail("should throw NoSuchElementException");
3882            } catch (NoSuchElementException e) {
3883                // Expected
3884            }
3885        }
3886
3887        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
3888        if (entrySet instanceof NavigableSet) {
3889            descendingSet = ((NavigableSet) entrySet).descendingSet();
3890            iterator = descendingSet.iterator();
3891            for (int value = 109; value > 99; value--) {
3892                assertTrue(iterator.hasNext());
3893                assertEquals(value, ((Entry) iterator.next()).getValue());
3894            }
3895            assertFalse(iterator.hasNext());
3896            try {
3897                iterator.next();
3898                fail("should throw NoSuchElementException");
3899            } catch (NoSuchElementException e) {
3900                // Expected
3901            }
3902        }
3903
3904        String endKey = new Integer(2).toString();
3905        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
3906        if (entrySet instanceof NavigableSet) {
3907            // [2...0]
3908            descendingSet = ((NavigableSet) entrySet).descendingSet();
3909            iterator = descendingSet.descendingIterator();
3910            assertEquals(0, ((Entry) iterator.next()).getValue());// 0...2
3911        }
3912    }
3913
3914    public void test_DescendingSubMapEntrySet_headSet() {
3915        Set entrySet, headSet;
3916        NavigableSet descendingSubMapEntrySet;
3917        Iterator iterator, headSetIterator;
3918        Entry entry;
3919        int value;
3920
3921        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
3922        if (entrySet instanceof NavigableSet) {
3923            descendingSubMapEntrySet = ((NavigableSet) entrySet)
3924                    .descendingSet();
3925            iterator = descendingSubMapEntrySet.iterator();
3926            while (iterator.hasNext()) {
3927                entry = (Entry) iterator.next();
3928                headSet = descendingSubMapEntrySet.headSet(entry);
3929                headSetIterator = headSet.iterator();
3930                for (value = 108; headSetIterator.hasNext(); value--) {
3931                    assertEquals(value, ((Entry) headSetIterator.next())
3932                            .getValue());
3933                }
3934                try {
3935                    headSetIterator.next();
3936                    fail("should throw NoSuchElementException");
3937                } catch (NoSuchElementException e) {
3938                    // Expected
3939                }
3940
3941                headSet = descendingSubMapEntrySet.headSet(entry, false);
3942                headSetIterator = headSet.iterator();
3943                for (value = 108; headSetIterator.hasNext(); value--) {
3944                    assertEquals(value, ((Entry) headSetIterator.next())
3945                            .getValue());
3946                }
3947                try {
3948                    headSetIterator.next();
3949                    fail("should throw NoSuchElementException");
3950                } catch (NoSuchElementException e) {
3951                    // Expected
3952                }
3953
3954                headSet = descendingSubMapEntrySet.headSet(entry, true);
3955                headSetIterator = headSet.iterator();
3956                for (value = 108; headSetIterator.hasNext(); value--) {
3957                    assertEquals(value, ((Entry) headSetIterator.next())
3958                            .getValue());
3959                }
3960                try {
3961                    headSetIterator.next();
3962                    fail("should throw NoSuchElementException");
3963                } catch (NoSuchElementException e) {
3964                    // Expected
3965                }
3966            }
3967        }
3968
3969        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
3970        if (entrySet instanceof NavigableSet) {
3971            descendingSubMapEntrySet = ((NavigableSet) entrySet)
3972                    .descendingSet();
3973            iterator = descendingSubMapEntrySet.iterator();
3974            while (iterator.hasNext()) {
3975                entry = (Entry) iterator.next();
3976                headSet = descendingSubMapEntrySet.headSet(entry);
3977                headSetIterator = headSet.iterator();
3978                for (value = 109; headSetIterator.hasNext(); value--) {
3979                    assertEquals(value, ((Entry) headSetIterator.next())
3980                            .getValue());
3981                }
3982                try {
3983                    headSetIterator.next();
3984                    fail("should throw NoSuchElementException");
3985                } catch (NoSuchElementException e) {
3986                    // Expected
3987                }
3988
3989                headSet = descendingSubMapEntrySet.headSet(entry, false);
3990                headSetIterator = headSet.iterator();
3991                for (value = 109; headSetIterator.hasNext(); value--) {
3992                    assertEquals(value, ((Entry) headSetIterator.next())
3993                            .getValue());
3994                }
3995                try {
3996                    headSetIterator.next();
3997                    fail("should throw NoSuchElementException");
3998                } catch (NoSuchElementException e) {
3999                    // Expected
4000                }
4001
4002                headSet = descendingSubMapEntrySet.headSet(entry, true);
4003                headSetIterator = headSet.iterator();
4004                for (value = 109; headSetIterator.hasNext(); value--) {
4005                    assertEquals(value, ((Entry) headSetIterator.next())
4006                            .getValue());
4007                }
4008                try {
4009                    headSetIterator.next();
4010                    fail("should throw NoSuchElementException");
4011                } catch (NoSuchElementException e) {
4012                    // Expected
4013                }
4014            }
4015        }
4016
4017        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4018        if (entrySet instanceof NavigableSet) {
4019            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4020                    .descendingSet();
4021            iterator = descendingSubMapEntrySet.iterator();
4022            while (iterator.hasNext()) {
4023                entry = (Entry) iterator.next();
4024                headSet = descendingSubMapEntrySet.headSet(entry);
4025                headSetIterator = headSet.iterator();
4026                for (value = 108; headSetIterator.hasNext(); value--) {
4027                    assertEquals(value, ((Entry) headSetIterator.next())
4028                            .getValue());
4029                }
4030                try {
4031                    headSetIterator.next();
4032                    fail("should throw NoSuchElementException");
4033                } catch (NoSuchElementException e) {
4034                    // Expected
4035                }
4036
4037                headSet = descendingSubMapEntrySet.headSet(entry, false);
4038                headSetIterator = headSet.iterator();
4039                for (value = 108; headSetIterator.hasNext(); value--) {
4040                    assertEquals(value, ((Entry) headSetIterator.next())
4041                            .getValue());
4042                }
4043                try {
4044                    headSetIterator.next();
4045                    fail("should throw NoSuchElementException");
4046                } catch (NoSuchElementException e) {
4047                    // Expected
4048                }
4049
4050                headSet = descendingSubMapEntrySet.headSet(entry, true);
4051                headSetIterator = headSet.iterator();
4052                for (value = 108; headSetIterator.hasNext(); value--) {
4053                    assertEquals(value, ((Entry) headSetIterator.next())
4054                            .getValue());
4055                }
4056                try {
4057                    headSetIterator.next();
4058                    fail("should throw NoSuchElementException");
4059                } catch (NoSuchElementException e) {
4060                    // Expected
4061                }
4062            }
4063        }
4064
4065        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4066        if (entrySet instanceof NavigableSet) {
4067            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4068                    .descendingSet();
4069            iterator = descendingSubMapEntrySet.iterator();
4070            while (iterator.hasNext()) {
4071                entry = (Entry) iterator.next();
4072                headSet = descendingSubMapEntrySet.headSet(entry);
4073                headSetIterator = headSet.iterator();
4074                for (value = 109; headSetIterator.hasNext(); value--) {
4075                    assertEquals(value, ((Entry) headSetIterator.next())
4076                            .getValue());
4077                }
4078                try {
4079                    headSetIterator.next();
4080                    fail("should throw NoSuchElementException");
4081                } catch (NoSuchElementException e) {
4082                    // Expected
4083                }
4084
4085                headSet = descendingSubMapEntrySet.headSet(entry, false);
4086                headSetIterator = headSet.iterator();
4087                for (value = 109; headSetIterator.hasNext(); value--) {
4088                    assertEquals(value, ((Entry) headSetIterator.next())
4089                            .getValue());
4090                }
4091                try {
4092                    headSetIterator.next();
4093                    fail("should throw NoSuchElementException");
4094                } catch (NoSuchElementException e) {
4095                    // Expected
4096                }
4097
4098                headSet = descendingSubMapEntrySet.headSet(entry, true);
4099                headSetIterator = headSet.iterator();
4100                for (value = 109; headSetIterator.hasNext(); value--) {
4101                    assertEquals(value, ((Entry) headSetIterator.next())
4102                            .getValue());
4103                }
4104                try {
4105                    headSetIterator.next();
4106                    fail("should throw NoSuchElementException");
4107                } catch (NoSuchElementException e) {
4108                    // Expected
4109                }
4110            }
4111        }
4112
4113        String endKey = new Integer(2).toString();
4114        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
4115        if (entrySet instanceof NavigableSet) {
4116            // [2...0]
4117            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4118                    .descendingSet();
4119            iterator = descendingSubMapEntrySet.iterator();
4120            iterator.next();// 2
4121            iterator.next();// 199
4122            entry = (Entry) iterator.next();// 198
4123            headSet = descendingSubMapEntrySet.headSet(entry);
4124            assertEquals(2, headSet.size());// 2 199
4125            headSetIterator = headSet.iterator();
4126            assertEquals(2, ((Entry) headSetIterator.next()).getValue());
4127            assertEquals(199, ((Entry) headSetIterator.next()).getValue());
4128
4129            headSet = descendingSubMapEntrySet.headSet(entry, true);
4130            assertEquals(3, headSet.size());// 2 199
4131            headSetIterator = headSet.iterator();
4132            assertEquals(2, ((Entry) headSetIterator.next()).getValue());
4133            assertEquals(199, ((Entry) headSetIterator.next()).getValue());
4134            assertEquals(198, ((Entry) headSetIterator.next()).getValue());
4135        }
4136    }
4137
4138    public void test_DescendingSubMapEntrySet_tailSet() {
4139        Set entrySet, tailSet;
4140        NavigableSet descendingSubMapEntrySet;
4141        Iterator iterator, tailSetIterator;
4142        Entry entry;
4143        int value;
4144
4145        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4146        if (entrySet instanceof NavigableSet) {
4147            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4148                    .descendingSet();
4149            iterator = descendingSubMapEntrySet.iterator();
4150            while (iterator.hasNext()) {
4151                entry = (Entry) iterator.next();
4152                tailSet = descendingSubMapEntrySet.tailSet(entry);
4153                tailSetIterator = tailSet.iterator();
4154                for (value = (Integer) entry.getValue(); tailSetIterator
4155                        .hasNext(); value--) {
4156                    assertEquals(value, ((Entry) tailSetIterator.next())
4157                            .getValue());
4158                }
4159                try {
4160                    tailSetIterator.next();
4161                    fail("should throw NoSuchElementException");
4162                } catch (NoSuchElementException e) {
4163                    // Expected
4164                }
4165
4166                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4167                tailSetIterator = tailSet.iterator();
4168                for (value = (Integer) entry.getValue(); tailSetIterator
4169                        .hasNext(); value--) {
4170                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4171                            .getValue());
4172                }
4173                try {
4174                    tailSetIterator.next();
4175                    fail("should throw NoSuchElementException");
4176                } catch (NoSuchElementException e) {
4177                    // Expected
4178                }
4179
4180                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4181                tailSetIterator = tailSet.iterator();
4182                for (value = (Integer) entry.getValue(); tailSetIterator
4183                        .hasNext(); value--) {
4184                    assertEquals(value, ((Entry) tailSetIterator.next())
4185                            .getValue());
4186                }
4187                try {
4188                    tailSetIterator.next();
4189                    fail("should throw NoSuchElementException");
4190                } catch (NoSuchElementException e) {
4191                    // Expected
4192                }
4193            }
4194        }
4195
4196        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4197        if (entrySet instanceof NavigableSet) {
4198            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4199                    .descendingSet();
4200            iterator = descendingSubMapEntrySet.iterator();
4201            while (iterator.hasNext()) {
4202                entry = (Entry) iterator.next();
4203                tailSet = descendingSubMapEntrySet.tailSet(entry);
4204                tailSetIterator = tailSet.iterator();
4205                for (value = (Integer) entry.getValue(); tailSetIterator
4206                        .hasNext(); value--) {
4207                    assertEquals(value, ((Entry) tailSetIterator.next())
4208                            .getValue());
4209                }
4210                try {
4211                    tailSetIterator.next();
4212                    fail("should throw NoSuchElementException");
4213                } catch (NoSuchElementException e) {
4214                    // Expected
4215                }
4216
4217                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4218                tailSetIterator = tailSet.iterator();
4219                for (value = (Integer) entry.getValue(); tailSetIterator
4220                        .hasNext(); value--) {
4221                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4222                            .getValue());
4223                }
4224                try {
4225                    tailSetIterator.next();
4226                    fail("should throw NoSuchElementException");
4227                } catch (NoSuchElementException e) {
4228                    // Expected
4229                }
4230
4231                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4232                tailSetIterator = tailSet.iterator();
4233                for (value = (Integer) entry.getValue(); tailSetIterator
4234                        .hasNext(); value--) {
4235                    assertEquals(value, ((Entry) tailSetIterator.next())
4236                            .getValue());
4237                }
4238                try {
4239                    tailSetIterator.next();
4240                    fail("should throw NoSuchElementException");
4241                } catch (NoSuchElementException e) {
4242                    // Expected
4243                }
4244            }
4245        }
4246
4247        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4248        if (entrySet instanceof NavigableSet) {
4249            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4250                    .descendingSet();
4251            iterator = descendingSubMapEntrySet.iterator();
4252            while (iterator.hasNext()) {
4253                entry = (Entry) iterator.next();
4254                tailSet = descendingSubMapEntrySet.tailSet(entry);
4255                tailSetIterator = tailSet.iterator();
4256                for (value = (Integer) entry.getValue(); tailSetIterator
4257                        .hasNext(); value--) {
4258                    assertEquals(value, ((Entry) tailSetIterator.next())
4259                            .getValue());
4260                }
4261                try {
4262                    tailSetIterator.next();
4263                    fail("should throw NoSuchElementException");
4264                } catch (NoSuchElementException e) {
4265                    // Expected
4266                }
4267
4268                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4269                tailSetIterator = tailSet.iterator();
4270                for (value = (Integer) entry.getValue(); tailSetIterator
4271                        .hasNext(); value--) {
4272                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4273                            .getValue());
4274                }
4275                try {
4276                    tailSetIterator.next();
4277                    fail("should throw NoSuchElementException");
4278                } catch (NoSuchElementException e) {
4279                    // Expected
4280                }
4281
4282                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4283                tailSetIterator = tailSet.iterator();
4284                for (value = (Integer) entry.getValue(); tailSetIterator
4285                        .hasNext(); value--) {
4286                    assertEquals(value, ((Entry) tailSetIterator.next())
4287                            .getValue());
4288                }
4289                try {
4290                    tailSetIterator.next();
4291                    fail("should throw NoSuchElementException");
4292                } catch (NoSuchElementException e) {
4293                    // Expected
4294                }
4295            }
4296        }
4297
4298        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4299        if (entrySet instanceof NavigableSet) {
4300            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4301                    .descendingSet();
4302            iterator = descendingSubMapEntrySet.iterator();
4303            while (iterator.hasNext()) {
4304                entry = (Entry) iterator.next();
4305                tailSet = descendingSubMapEntrySet.tailSet(entry);
4306                tailSetIterator = tailSet.iterator();
4307                for (value = (Integer) entry.getValue(); tailSetIterator
4308                        .hasNext(); value--) {
4309                    assertEquals(value, ((Entry) tailSetIterator.next())
4310                            .getValue());
4311                }
4312                try {
4313                    tailSetIterator.next();
4314                    fail("should throw NoSuchElementException");
4315                } catch (NoSuchElementException e) {
4316                    // Expected
4317                }
4318
4319                tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4320                tailSetIterator = tailSet.iterator();
4321                for (value = (Integer) entry.getValue(); tailSetIterator
4322                        .hasNext(); value--) {
4323                    assertEquals(value - 1, ((Entry) tailSetIterator.next())
4324                            .getValue());
4325                }
4326                try {
4327                    tailSetIterator.next();
4328                    fail("should throw NoSuchElementException");
4329                } catch (NoSuchElementException e) {
4330                    // Expected
4331                }
4332
4333                tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4334                tailSetIterator = tailSet.iterator();
4335                for (value = (Integer) entry.getValue(); tailSetIterator
4336                        .hasNext(); value--) {
4337                    assertEquals(value, ((Entry) tailSetIterator.next())
4338                            .getValue());
4339                }
4340                try {
4341                    tailSetIterator.next();
4342                    fail("should throw NoSuchElementException");
4343                } catch (NoSuchElementException e) {
4344                    // Expected
4345                }
4346            }
4347        }
4348
4349        String endKey = new Integer(2).toString();
4350        entrySet = tm.headMap(endKey, true).entrySet();// 0...2
4351        if (entrySet instanceof NavigableSet) {
4352            // [2...0]
4353            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4354                    .descendingSet();
4355            iterator = descendingSubMapEntrySet.iterator();
4356            iterator.next();// 2
4357            entry = (Entry) iterator.next();// 199
4358            tailSet = descendingSubMapEntrySet.tailSet(entry);
4359            tailSetIterator = tailSet.iterator();
4360            assertEquals(199, ((Entry) tailSetIterator.next()).getValue());
4361
4362            tailSet = descendingSubMapEntrySet.tailSet(entry, false);
4363            tailSetIterator = tailSet.iterator();
4364            assertEquals(198, ((Entry) tailSetIterator.next()).getValue());
4365
4366            tailSet = descendingSubMapEntrySet.tailSet(entry, true);
4367            tailSetIterator = tailSet.iterator();
4368            assertEquals(199, ((Entry) tailSetIterator.next()).getValue());
4369        }
4370    }
4371
4372    public void test_DescendingSubMapEntrySet_subSet() {
4373        Set entrySet, subSet;
4374        NavigableSet descendingSubMapEntrySet;
4375        Entry startEntry, endEntry;
4376        Iterator subSetIterator;
4377
4378        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4379        if (entrySet instanceof NavigableSet) {
4380            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4381                    .descendingSet();
4382            Iterator iteratorStart = descendingSubMapEntrySet.iterator();
4383            while (iteratorStart.hasNext()) {
4384                startEntry = (Entry) iteratorStart.next();
4385                Iterator iteratorEnd = descendingSubMapEntrySet.iterator();
4386                while (iteratorEnd.hasNext()) {
4387                    endEntry = (Entry) iteratorEnd.next();
4388                    int startIndex = (Integer) startEntry.getValue();
4389                    int endIndex = (Integer) endEntry.getValue();
4390                    if (startIndex < endIndex) {
4391                        try {
4392                            descendingSubMapEntrySet.subSet(startEntry,
4393                                    endEntry);
4394                            fail("should throw IllegalArgumentException");
4395                        } catch (IllegalArgumentException e) {
4396                            // Expected
4397                        }
4398
4399                        try {
4400                            descendingSubMapEntrySet.subSet(startEntry, false,
4401                                    endEntry, false);
4402                            fail("should throw IllegalArgumentException");
4403                        } catch (IllegalArgumentException e) {
4404                            // Expected
4405                        }
4406
4407                        try {
4408                            descendingSubMapEntrySet.subSet(startEntry, false,
4409                                    endEntry, true);
4410                            fail("should throw IllegalArgumentException");
4411                        } catch (IllegalArgumentException e) {
4412                            // Expected
4413                        }
4414
4415                        try {
4416                            descendingSubMapEntrySet.subSet(startEntry, true,
4417                                    endEntry, false);
4418                            fail("should throw IllegalArgumentException");
4419                        } catch (IllegalArgumentException e) {
4420                            // Expected
4421                        }
4422
4423                        try {
4424                            descendingSubMapEntrySet.subSet(startEntry, true,
4425                                    endEntry, true);
4426                            fail("should throw IllegalArgumentException");
4427                        } catch (IllegalArgumentException e) {
4428                            // Expected
4429                        }
4430                    } else {
4431                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4432                                endEntry);
4433                        subSetIterator = subSet.iterator();
4434                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4435                            assertEquals(index, ((Entry) subSetIterator.next())
4436                                    .getValue());
4437                        }
4438
4439                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4440                                false, endEntry, false);
4441                        subSetIterator = subSet.iterator();
4442                        for (int index = startIndex - 1; subSetIterator
4443                                .hasNext(); index--) {
4444                            assertEquals(index, ((Entry) subSetIterator.next())
4445                                    .getValue());
4446                        }
4447
4448                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4449                                false, endEntry, true);
4450                        subSetIterator = subSet.iterator();
4451                        for (int index = startIndex - 1; subSetIterator
4452                                .hasNext(); index--) {
4453                            assertEquals(index, ((Entry) subSetIterator.next())
4454                                    .getValue());
4455                        }
4456
4457                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4458                                true, endEntry, false);
4459                        subSetIterator = subSet.iterator();
4460                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4461                            assertEquals(index, ((Entry) subSetIterator.next())
4462                                    .getValue());
4463                        }
4464
4465                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4466                                true, endEntry, true);
4467                        subSetIterator = subSet.iterator();
4468                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4469                            assertEquals(index, ((Entry) subSetIterator.next())
4470                                    .getValue());
4471                        }
4472                    }
4473                }
4474            }
4475        }
4476
4477        String endKey = new Integer(2).toString();
4478        entrySet = tm.headMap(endKey, true).entrySet();
4479        if (entrySet instanceof NavigableSet) {
4480            // [2...0]
4481            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4482                    .descendingSet();
4483            Iterator iterator = descendingSubMapEntrySet.iterator();
4484            startEntry = (Entry) iterator.next();
4485            iterator.next();
4486            endEntry = (Entry) iterator.next();
4487            subSet = descendingSubMapEntrySet.subSet(startEntry, endEntry);
4488            assertEquals(2, subSet.size());
4489
4490            subSet = descendingSubMapEntrySet.subSet(startEntry, false,
4491                    endEntry, false);
4492            assertEquals(1, subSet.size());
4493            subSetIterator = subSet.iterator();
4494            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4495
4496            subSet = descendingSubMapEntrySet.subSet(startEntry, false,
4497                    endEntry, true);
4498            assertEquals(2, subSet.size());
4499            subSetIterator = subSet.iterator();
4500            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4501            assertEquals(198, ((Entry) subSetIterator.next()).getValue());
4502
4503            subSet = descendingSubMapEntrySet.subSet(startEntry, true,
4504                    endEntry, false);
4505            assertEquals(2, subSet.size());
4506            subSetIterator = subSet.iterator();
4507            assertEquals(2, ((Entry) subSetIterator.next()).getValue());
4508            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4509
4510            subSet = descendingSubMapEntrySet.subSet(startEntry, true,
4511                    endEntry, true);
4512            assertEquals(3, subSet.size());
4513            subSetIterator = subSet.iterator();
4514            assertEquals(2, ((Entry) subSetIterator.next()).getValue());
4515            assertEquals(199, ((Entry) subSetIterator.next()).getValue());
4516            assertEquals(198, ((Entry) subSetIterator.next()).getValue());
4517        }
4518
4519        // With Comnparator
4520        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
4521        if (entrySet instanceof NavigableSet) {
4522            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4523                    .descendingSet();
4524            Iterator iteratorStart = descendingSubMapEntrySet.iterator();
4525            while (iteratorStart.hasNext()) {
4526                startEntry = (Entry) iteratorStart.next();
4527                Iterator iteratorEnd = descendingSubMapEntrySet.iterator();
4528                while (iteratorEnd.hasNext()) {
4529                    endEntry = (Entry) iteratorEnd.next();
4530                    int startIndex = (Integer) startEntry.getValue();
4531                    int endIndex = (Integer) endEntry.getValue();
4532                    if (startIndex < endIndex) {
4533                        try {
4534                            descendingSubMapEntrySet.subSet(startEntry,
4535                                    endEntry);
4536                            fail("should throw IllegalArgumentException");
4537                        } catch (IllegalArgumentException e) {
4538                            // Expected
4539                        }
4540
4541                        try {
4542                            descendingSubMapEntrySet.subSet(startEntry, false,
4543                                    endEntry, false);
4544                            fail("should throw IllegalArgumentException");
4545                        } catch (IllegalArgumentException e) {
4546                            // Expected
4547                        }
4548
4549                        try {
4550                            descendingSubMapEntrySet.subSet(startEntry, false,
4551                                    endEntry, true);
4552                            fail("should throw IllegalArgumentException");
4553                        } catch (IllegalArgumentException e) {
4554                            // Expected
4555                        }
4556
4557                        try {
4558                            descendingSubMapEntrySet.subSet(startEntry, true,
4559                                    endEntry, false);
4560                            fail("should throw IllegalArgumentException");
4561                        } catch (IllegalArgumentException e) {
4562                            // Expected
4563                        }
4564
4565                        try {
4566                            descendingSubMapEntrySet.subSet(startEntry, true,
4567                                    endEntry, true);
4568                            fail("should throw IllegalArgumentException");
4569                        } catch (IllegalArgumentException e) {
4570                            // Expected
4571                        }
4572                    } else {
4573                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4574                                endEntry);
4575                        subSetIterator = subSet.iterator();
4576                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4577                            assertEquals(index, ((Entry) subSetIterator.next())
4578                                    .getValue());
4579                        }
4580
4581                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4582                                false, endEntry, false);
4583                        subSetIterator = subSet.iterator();
4584                        for (int index = startIndex - 1; subSetIterator
4585                                .hasNext(); index--) {
4586                            assertEquals(index, ((Entry) subSetIterator.next())
4587                                    .getValue());
4588                        }
4589
4590                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4591                                false, endEntry, true);
4592                        subSetIterator = subSet.iterator();
4593                        for (int index = startIndex - 1; subSetIterator
4594                                .hasNext(); index--) {
4595                            assertEquals(index, ((Entry) subSetIterator.next())
4596                                    .getValue());
4597                        }
4598
4599                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4600                                true, endEntry, false);
4601                        subSetIterator = subSet.iterator();
4602                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4603                            assertEquals(index, ((Entry) subSetIterator.next())
4604                                    .getValue());
4605                        }
4606
4607                        subSet = descendingSubMapEntrySet.subSet(startEntry,
4608                                true, endEntry, true);
4609                        subSetIterator = subSet.iterator();
4610                        for (int index = startIndex; subSetIterator.hasNext(); index--) {
4611                            assertEquals(index, ((Entry) subSetIterator.next())
4612                                    .getValue());
4613                        }
4614                    }
4615                }
4616            }
4617        }
4618    }
4619
4620    public void test_DescendingSubMapEntrySet_lower() {
4621        Set entrySet, subSet;
4622        NavigableSet descendingSubMapEntrySet;
4623        Iterator iterator;
4624        Entry entry, lowerEntry;
4625        int value;
4626
4627        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4628        if (entrySet instanceof NavigableSet) {
4629            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4630                    .descendingSet();
4631            iterator = descendingSubMapEntrySet.iterator();
4632            while (iterator.hasNext()) {
4633                entry = (Entry) iterator.next();
4634                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4635                value = (Integer) entry.getValue();
4636                if (value < 108) {
4637                    assertEquals(value + 1, lowerEntry.getValue());
4638                } else {
4639                    assertNull(lowerEntry);
4640                }
4641            }
4642
4643            // System.out.println(descendingSubMapEntrySet);
4644            // System.out.println(tm);
4645            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4646                    .iterator().next();
4647            // System.out.println("o:" + afterEnd);
4648            Object x = descendingSubMapEntrySet.lower(afterEnd);
4649            // System.out.println("x:" + x);
4650            assertNull(x);
4651            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4652                    .iterator().next();
4653            // System.out.println("before: " + beforeStart);
4654            Object y = descendingSubMapEntrySet.lower(beforeStart);
4655            // System.out.println("y: " + y);
4656            assertNotNull(y);
4657            assertEquals(101, (((Entry) y).getValue()));
4658        }
4659
4660        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4661        if (entrySet instanceof NavigableSet) {
4662            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4663                    .descendingSet();
4664            iterator = descendingSubMapEntrySet.iterator();
4665            while (iterator.hasNext()) {
4666                entry = (Entry) iterator.next();
4667                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4668                value = (Integer) entry.getValue();
4669                if (value < 109) {
4670                    assertEquals(value + 1, lowerEntry.getValue());
4671                } else {
4672                    assertNull(lowerEntry);
4673                }
4674            }
4675        }
4676
4677        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4678        if (entrySet instanceof NavigableSet) {
4679            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4680                    .descendingSet();
4681            iterator = descendingSubMapEntrySet.iterator();
4682            while (iterator.hasNext()) {
4683                entry = (Entry) iterator.next();
4684                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4685                value = (Integer) entry.getValue();
4686                if (value < 108) {
4687                    assertEquals(value + 1, lowerEntry.getValue());
4688                } else {
4689                    assertNull(lowerEntry);
4690                }
4691            }
4692        }
4693
4694        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4695        if (entrySet instanceof NavigableSet) {
4696            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4697                    .descendingSet();
4698            iterator = descendingSubMapEntrySet.iterator();
4699            while (iterator.hasNext()) {
4700                entry = (Entry) iterator.next();
4701                lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4702                value = (Integer) entry.getValue();
4703                if (value < 109) {
4704                    assertEquals(value + 1, lowerEntry.getValue());
4705                } else {
4706                    assertNull(lowerEntry);
4707                }
4708            }
4709        }
4710
4711        String endKey = new Integer(2).toString();
4712        entrySet = tm.headMap(endKey, true).entrySet();
4713        if (entrySet instanceof NavigableSet) {
4714            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4715                    .descendingSet();
4716            iterator = descendingSubMapEntrySet.iterator();
4717            iterator.next();// 2
4718            iterator.next();// 199
4719            entry = (Entry) iterator.next();// 198
4720            lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry);
4721            assertEquals(199, lowerEntry.getValue());
4722        }
4723    }
4724
4725    public void test_DescendingSubMapEntrySet_higher() {
4726        Set entrySet, subSet;
4727        NavigableSet descendingSubMapEntrySet;
4728        Iterator iterator;
4729        Entry entry, higherEntry;
4730        int value;
4731
4732        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4733        if (entrySet instanceof NavigableSet) {
4734            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4735                    .descendingSet();
4736            iterator = descendingSubMapEntrySet.iterator();
4737            while (iterator.hasNext()) {
4738                entry = (Entry) iterator.next();
4739                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4740                value = (Integer) entry.getValue();
4741                if (value > 101) {
4742                    assertEquals(value - 1, higherEntry.getValue());
4743                } else {
4744                    assertNull(higherEntry);
4745                }
4746            }
4747
4748            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4749                    .iterator().next();
4750            Object x = descendingSubMapEntrySet.higher(afterEnd);
4751            assertNotNull(x);
4752            assertEquals(108, ((Entry) x).getValue());
4753            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4754                    .iterator().next();
4755            Object y = descendingSubMapEntrySet.higher(beforeStart);
4756            assertNull(y);
4757        }
4758
4759        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4760        if (entrySet instanceof NavigableSet) {
4761            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4762                    .descendingSet();
4763            iterator = descendingSubMapEntrySet.iterator();
4764            while (iterator.hasNext()) {
4765                entry = (Entry) iterator.next();
4766                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4767                value = (Integer) entry.getValue();
4768                if (value > 101) {
4769                    assertEquals(value - 1, higherEntry.getValue());
4770                } else {
4771                    assertNull(higherEntry);
4772                }
4773            }
4774        }
4775
4776        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4777        if (entrySet instanceof NavigableSet) {
4778            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4779                    .descendingSet();
4780            iterator = descendingSubMapEntrySet.iterator();
4781            while (iterator.hasNext()) {
4782                entry = (Entry) iterator.next();
4783                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4784                value = (Integer) entry.getValue();
4785                if (value > 100) {
4786                    assertEquals(value - 1, higherEntry.getValue());
4787                } else {
4788                    assertNull(higherEntry);
4789                }
4790            }
4791        }
4792
4793        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4794        if (entrySet instanceof NavigableSet) {
4795            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4796                    .descendingSet();
4797            iterator = descendingSubMapEntrySet.iterator();
4798            while (iterator.hasNext()) {
4799                entry = (Entry) iterator.next();
4800                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4801                value = (Integer) entry.getValue();
4802                if (value > 100) {
4803                    assertEquals(value - 1, higherEntry.getValue());
4804                } else {
4805                    assertNull(higherEntry);
4806                }
4807            }
4808        }
4809
4810        String endKey = new Integer(2).toString();
4811        entrySet = tm.headMap(endKey, true).entrySet();
4812        if (entrySet instanceof NavigableSet) {
4813            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4814                    .descendingSet();
4815            iterator = descendingSubMapEntrySet.iterator();
4816            iterator.next();// 2
4817            iterator.next();// 199
4818            entry = (Entry) iterator.next();// 198
4819            higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4820            assertEquals(197, higherEntry.getValue());
4821        }
4822
4823        // With Comparator
4824        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
4825        if (entrySet instanceof NavigableSet) {
4826            descendingSubMapEntrySet = ((NavigableSet) entrySet)
4827                    .descendingSet();
4828            iterator = descendingSubMapEntrySet.iterator();
4829            while (iterator.hasNext()) {
4830                entry = (Entry) iterator.next();
4831                higherEntry = (Entry) descendingSubMapEntrySet.higher(entry);
4832                value = (Integer) entry.getValue();
4833                if (value > 101) {
4834                    assertEquals(value - 1, higherEntry.getValue());
4835                } else {
4836                    assertNull(higherEntry);
4837                }
4838            }
4839
4840            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4841                    .iterator().next();
4842            Object x = descendingSubMapEntrySet.higher(afterEnd);
4843            assertNotNull(x);
4844            assertEquals(108, ((Entry) x).getValue());
4845            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4846                    .iterator().next();
4847            Object y = descendingSubMapEntrySet.higher(beforeStart);
4848            assertNull(y);
4849        }
4850    }
4851
4852    public void test_DescendingSubMapEntrySet_ceiling() {
4853        Set entrySet;
4854        NavigableSet ascendingSubMapEntrySet, descendingSet;
4855        Entry entry;
4856        Entry[] entryArray;
4857
4858        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4859        if (entrySet instanceof NavigableSet) {
4860            ascendingSubMapEntrySet = (NavigableSet) entrySet;
4861            descendingSet = ascendingSubMapEntrySet.descendingSet();
4862            try {
4863                descendingSet.ceiling(null);
4864                fail("should throw NPE");
4865            } catch (NullPointerException e) {
4866                // Expected
4867            }
4868
4869            entryArray = (Entry[]) descendingSet
4870                    .toArray(new Entry[descendingSet.size()]);
4871            for (int i = 0, j = 108; i < entryArray.length; i++) {
4872                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4873                assertEquals(j - i, entry.getValue());
4874            }
4875
4876            // System.out.println(descendingSet);
4877            // System.out.println(tm);
4878            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4879                    .iterator().next();
4880            // System.out.println("o:" + afterEnd);//110
4881            Object x = descendingSet.ceiling(afterEnd);
4882            assertNotNull(x);
4883            // System.out.println("x:" + x);
4884            assertEquals(108, ((Entry) x).getValue());
4885            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
4886                    .iterator().next();
4887            // System.out.println("before: " + beforeStart);//0
4888            Object y = descendingSet.ceiling(beforeStart);
4889            assertNull(y);
4890        }
4891
4892        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
4893        if (entrySet instanceof NavigableSet) {
4894            ascendingSubMapEntrySet = (NavigableSet) entrySet;
4895            descendingSet = ascendingSubMapEntrySet.descendingSet();
4896            try {
4897                descendingSet.ceiling(null);
4898                fail("should throw NPE");
4899            } catch (NullPointerException e) {
4900                // Expected
4901            }
4902
4903            entryArray = (Entry[]) descendingSet
4904                    .toArray(new Entry[descendingSet.size()]);
4905            for (int i = 0, j = 109; i < entryArray.length; i++) {
4906                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4907                assertEquals(j - i, entry.getValue());
4908            }
4909        }
4910
4911        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
4912        if (entrySet instanceof NavigableSet) {
4913            ascendingSubMapEntrySet = (NavigableSet) entrySet;
4914            descendingSet = ascendingSubMapEntrySet.descendingSet();
4915            try {
4916                descendingSet.ceiling(null);
4917                fail("should throw NPE");
4918            } catch (NullPointerException e) {
4919                // Expected
4920            }
4921
4922            entryArray = (Entry[]) descendingSet
4923                    .toArray(new Entry[descendingSet.size()]);
4924            for (int i = 0, j = 108; i < entryArray.length; i++) {
4925                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4926                assertEquals(j - i, entry.getValue());
4927            }
4928        }
4929
4930        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
4931        if (entrySet instanceof NavigableSet) {
4932            descendingSet = ((NavigableSet) entrySet).descendingSet();
4933            try {
4934                descendingSet.ceiling(null);
4935                fail("should throw NPE");
4936            } catch (NullPointerException e) {
4937                // Expected
4938            }
4939
4940            entryArray = (Entry[]) descendingSet
4941                    .toArray(new Entry[descendingSet.size()]);
4942            for (int i = 0, j = 109; i < entryArray.length; i++) {
4943                entry = (Entry) descendingSet.ceiling(entryArray[i]);
4944                assertEquals(j - i, entry.getValue());
4945            }
4946        }
4947
4948        String endKey = new Integer(2).toString();
4949        entrySet = tm.headMap(endKey, true).entrySet();
4950        if (entrySet instanceof NavigableSet) {
4951            descendingSet = ((NavigableSet) entrySet).descendingSet();
4952            try {
4953                descendingSet.ceiling(null);
4954                fail("should throw NPE");
4955            } catch (NullPointerException e) {
4956                // Expected
4957            }
4958
4959            Iterator iterator = descendingSet.iterator();
4960            Entry ceilingEntry;
4961            while (iterator.hasNext()) {
4962                entry = (Entry) iterator.next();
4963                ceilingEntry = (Entry) descendingSet.ceiling(entry);
4964                assertEquals(entry, ceilingEntry);
4965            }
4966        }
4967
4968    }
4969
4970    public void test_DescendingSubMapEntrySet_floor() {
4971        Set entrySet;
4972        NavigableSet ascendingSubMapEntrySet, descendingSet;
4973        Entry entry;
4974        Entry[] entryArray;
4975
4976        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
4977        if (entrySet instanceof NavigableSet) {
4978            ascendingSubMapEntrySet = (NavigableSet) entrySet;
4979            descendingSet = ascendingSubMapEntrySet.descendingSet();
4980            try {
4981                descendingSet.floor(null);
4982                fail("should throw NPE");
4983            } catch (NullPointerException e) {
4984                // Expected
4985            }
4986
4987            entryArray = (Entry[]) descendingSet
4988                    .toArray(new Entry[descendingSet.size()]);
4989            for (int i = 0, j = 108; i < entryArray.length; i++) {
4990                entry = (Entry) descendingSet.floor(entryArray[i]);
4991                assertEquals(j - i, entry.getValue());
4992            }
4993
4994            Object afterEnd = this.subMap_default_afterEnd_109.entrySet()
4995                    .iterator().next();
4996            Object x = descendingSet.floor(afterEnd);
4997            assertNull(x);
4998
4999            Object beforeStart = this.subMap_default_beforeStart_100.entrySet()
5000                    .iterator().next();
5001            Object y = descendingSet.floor(beforeStart);
5002            assertNotNull(y);
5003            assertEquals(101, (((Entry) y).getValue()));
5004        }
5005
5006        entrySet = navigableMap_startExcluded_endIncluded.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 = 109; i < entryArray.length; i++) {
5020                entry = (Entry) descendingSet.floor(entryArray[i]);
5021                assertEquals(j - i, entry.getValue());
5022            }
5023        }
5024
5025        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
5026        if (entrySet instanceof NavigableSet) {
5027            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5028            descendingSet = ascendingSubMapEntrySet.descendingSet();
5029            try {
5030                descendingSet.floor(null);
5031                fail("should throw NPE");
5032            } catch (NullPointerException e) {
5033                // Expected
5034            }
5035
5036            entryArray = (Entry[]) descendingSet
5037                    .toArray(new Entry[descendingSet.size()]);
5038            for (int i = 0, j = 108; i < entryArray.length; i++) {
5039                entry = (Entry) descendingSet.floor(entryArray[i]);
5040                assertEquals(j - i, entry.getValue());
5041            }
5042        }
5043
5044        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
5045        if (entrySet instanceof NavigableSet) {
5046            descendingSet = ((NavigableSet) entrySet).descendingSet();
5047            try {
5048                descendingSet.floor(null);
5049                fail("should throw NPE");
5050            } catch (NullPointerException e) {
5051                // Expected
5052            }
5053
5054            entryArray = (Entry[]) descendingSet
5055                    .toArray(new Entry[descendingSet.size()]);
5056            for (int i = 0, j = 109; i < entryArray.length; i++) {
5057                entry = (Entry) descendingSet.floor(entryArray[i]);
5058                assertEquals(j - i, entry.getValue());
5059            }
5060        }
5061
5062        String endKey = new Integer(2).toString();
5063        entrySet = tm.headMap(endKey, true).entrySet();
5064        if (entrySet instanceof NavigableSet) {
5065            descendingSet = ((NavigableSet) entrySet).descendingSet();
5066
5067            Iterator iterator = descendingSet.iterator();
5068            Entry floorEntry;
5069            while (iterator.hasNext()) {
5070                entry = (Entry) iterator.next();
5071                floorEntry = (Entry) descendingSet.floor(entry);
5072                assertEquals(entry, floorEntry);
5073            }
5074        }
5075
5076        // With Comparator
5077        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
5078        if (entrySet instanceof NavigableSet) {
5079            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5080            descendingSet = ascendingSubMapEntrySet.descendingSet();
5081            try {
5082                descendingSet.floor(null);
5083                fail("should throw NPE");
5084            } catch (NullPointerException e) {
5085                // Expected
5086            }
5087
5088            entryArray = (Entry[]) descendingSet
5089                    .toArray(new Entry[descendingSet.size()]);
5090            for (int i = 0, j = 108; i < entryArray.length; i++) {
5091                entry = (Entry) descendingSet.floor(entryArray[i]);
5092                assertEquals(j - i, entry.getValue());
5093            }
5094        }
5095
5096        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
5097        if (entrySet instanceof NavigableSet) {
5098            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5099            descendingSet = ascendingSubMapEntrySet.descendingSet();
5100            try {
5101                descendingSet.floor(null);
5102                fail("should throw NPE");
5103            } catch (NullPointerException e) {
5104                // Expected
5105            }
5106
5107            entryArray = (Entry[]) descendingSet
5108                    .toArray(new Entry[descendingSet.size()]);
5109            for (int i = 0, j = 109; i < entryArray.length; i++) {
5110                entry = (Entry) descendingSet.floor(entryArray[i]);
5111                assertEquals(j - i, entry.getValue());
5112            }
5113        }
5114
5115        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
5116        if (entrySet instanceof NavigableSet) {
5117            ascendingSubMapEntrySet = (NavigableSet) entrySet;
5118            descendingSet = ascendingSubMapEntrySet.descendingSet();
5119            try {
5120                descendingSet.floor(null);
5121                fail("should throw NPE");
5122            } catch (NullPointerException e) {
5123                // Expected
5124            }
5125
5126            entryArray = (Entry[]) descendingSet
5127                    .toArray(new Entry[descendingSet.size()]);
5128            for (int i = 0, j = 108; i < entryArray.length; i++) {
5129                entry = (Entry) descendingSet.floor(entryArray[i]);
5130                assertEquals(j - i, entry.getValue());
5131            }
5132        }
5133
5134        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
5135        if (entrySet instanceof NavigableSet) {
5136            descendingSet = ((NavigableSet) entrySet).descendingSet();
5137            try {
5138                descendingSet.floor(null);
5139                fail("should throw NPE");
5140            } catch (NullPointerException e) {
5141                // Expected
5142            }
5143
5144            entryArray = (Entry[]) descendingSet
5145                    .toArray(new Entry[descendingSet.size()]);
5146            for (int i = 0, j = 109; i < entryArray.length; i++) {
5147                entry = (Entry) descendingSet.floor(entryArray[i]);
5148                assertEquals(j - i, entry.getValue());
5149            }
5150        }
5151    }
5152
5153    public void test_DescendingSubMapKeySet_comparator() {
5154        NavigableSet keySet, descendingKeySet;
5155        Comparator comparator;
5156        String[] keyArray;
5157        Integer value1, value2;
5158
5159        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
5160        assertNull(keySet.comparator());
5161        descendingKeySet = keySet.descendingSet();
5162        comparator = descendingKeySet.comparator();
5163        assertNotNull(comparator);
5164        keyArray = (String[]) descendingKeySet
5165                .toArray(new String[descendingKeySet.size()]);
5166        for (int i = 1; i < keyArray.length; i++) {
5167            value1 = Integer.valueOf(keyArray[i - 1]);
5168            value2 = Integer.valueOf(keyArray[i]);
5169            assertTrue(value1 > value2);
5170            assertTrue(comparator.compare(value1, value2) < 0);
5171        }
5172
5173        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
5174        assertNull(keySet.comparator());
5175        descendingKeySet = keySet.descendingSet();
5176        comparator = descendingKeySet.comparator();
5177        assertNotNull(comparator);
5178        keyArray = (String[]) descendingKeySet
5179                .toArray(new String[descendingKeySet.size()]);
5180        for (int i = 1; i < keyArray.length; i++) {
5181            value1 = Integer.valueOf(keyArray[i - 1]);
5182            value2 = Integer.valueOf(keyArray[i]);
5183            assertTrue(value1 > value2);
5184            assertTrue(comparator.compare(value1, value2) < 0);
5185        }
5186
5187        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
5188        assertNull(keySet.comparator());
5189        descendingKeySet = keySet.descendingSet();
5190        comparator = descendingKeySet.comparator();
5191        assertNotNull(comparator);
5192        keyArray = (String[]) descendingKeySet
5193                .toArray(new String[descendingKeySet.size()]);
5194        for (int i = 1; i < keyArray.length; i++) {
5195            value1 = Integer.valueOf(keyArray[i - 1]);
5196            value2 = Integer.valueOf(keyArray[i]);
5197            assertTrue(value1 > value2);
5198            assertTrue(comparator.compare(value1, value2) < 0);
5199        }
5200
5201        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
5202        assertNull(keySet.comparator());
5203        descendingKeySet = keySet.descendingSet();
5204        comparator = descendingKeySet.comparator();
5205        assertNotNull(comparator);
5206        keyArray = (String[]) descendingKeySet
5207                .toArray(new String[descendingKeySet.size()]);
5208        for (int i = 1; i < keyArray.length; i++) {
5209            value1 = Integer.valueOf(keyArray[i - 1]);
5210            value2 = Integer.valueOf(keyArray[i]);
5211            assertTrue(value1 > value2);
5212            assertTrue(comparator.compare(value1, value2) < 0);
5213        }
5214
5215        String endKey = new Integer(2).toString();
5216        keySet = tm.headMap(endKey, true).navigableKeySet();
5217        assertNull(keySet.comparator());
5218        descendingKeySet = keySet.descendingSet();
5219        assertNotNull(descendingKeySet.comparator());
5220    }
5221
5222    public void test_AscendingSubMapKeySet_first() {
5223        NavigableSet keySet;
5224        String firstKey1 = new Integer(100).toString();
5225        String firstKey2 = new Integer(101).toString();
5226
5227        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
5228        assertEquals(firstKey2, keySet.first());
5229
5230        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
5231        assertEquals(firstKey2, keySet.first());
5232
5233        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
5234        assertEquals(firstKey1, keySet.first());
5235
5236        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
5237        assertEquals(firstKey1, keySet.first());
5238    }
5239
5240    public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endExcluded() {
5241        NavigableSet keySet = navigableMap_startExcluded_endExcluded
5242                .navigableKeySet();
5243        NavigableSet descendingKeySet = keySet.descendingSet();
5244        Iterator iterator = descendingKeySet.iterator();
5245        assertEquals(8, keySet.size());
5246        for (int value = 101; value < 109; value++) {
5247            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5248        }
5249        assertEquals(0, keySet.size());
5250        assertNull(keySet.pollLast());
5251    }
5252
5253    public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endIncluded() {
5254        NavigableSet keySet = navigableMap_startExcluded_endIncluded
5255                .navigableKeySet();
5256        NavigableSet descendingKeySet = keySet.descendingSet();
5257        Iterator iterator = descendingKeySet.iterator();
5258        assertEquals(9, keySet.size());
5259        for (int value = 101; value < 110; value++) {
5260            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5261        }
5262        assertEquals(0, keySet.size());
5263        assertNull(keySet.pollLast());
5264    }
5265
5266    public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endExcluded() {
5267        NavigableSet keySet = navigableMap_startIncluded_endExcluded
5268                .navigableKeySet();
5269        NavigableSet descendingKeySet = keySet.descendingSet();
5270        Iterator iterator = descendingKeySet.iterator();
5271        assertEquals(9, keySet.size());
5272        for (int value = 100; value < 109; value++) {
5273            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5274        }
5275        assertEquals(0, keySet.size());
5276        assertNull(keySet.pollLast());
5277    }
5278
5279    public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endIncluded() {
5280        NavigableSet keySet = navigableMap_startIncluded_endIncluded
5281                .navigableKeySet();
5282        NavigableSet descendingKeySet = keySet.descendingSet();
5283        Iterator iterator = descendingKeySet.iterator();
5284        assertEquals(10, keySet.size());
5285        for (int value = 100; value < 110; value++) {
5286            assertEquals(new Integer(value).toString(), keySet.pollFirst());
5287        }
5288        assertEquals(0, keySet.size());
5289        assertNull(keySet.pollLast());
5290    }
5291
5292    public void test_DescendingSubMapKeySet_pollFirst() {
5293        String endKey = new Integer(2).toString();
5294        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
5295        NavigableSet descendingKeySet = keySet.descendingSet();
5296        assertEquals(endKey, descendingKeySet.pollFirst());
5297    }
5298
5299    public void test_DescendingSubMapKeySet_pollLast_startExcluded_endExcluded() {
5300        NavigableSet keySet = navigableMap_startExcluded_endExcluded
5301                .navigableKeySet();
5302        NavigableSet descendingKeySet = keySet.descendingSet();
5303        Iterator iterator = descendingKeySet.iterator();
5304        assertEquals(8, keySet.size());
5305        for (int value = 108; value > 100; value--) {
5306            assertEquals(new Integer(value).toString(), keySet.pollLast());
5307        }
5308        assertEquals(0, keySet.size());
5309        assertNull(keySet.pollLast());
5310    }
5311
5312    public void test_DescendingSubMapKeySet_pollLast_startExcluded_endIncluded() {
5313        NavigableSet keySet = navigableMap_startExcluded_endIncluded
5314                .navigableKeySet();
5315        NavigableSet descendingKeySet = keySet.descendingSet();
5316        Iterator iterator = descendingKeySet.iterator();
5317        assertEquals(9, keySet.size());
5318        for (int value = 109; value > 100; value--) {
5319            assertEquals(new Integer(value).toString(), keySet.pollLast());
5320        }
5321        assertEquals(0, keySet.size());
5322        assertNull(keySet.pollLast());
5323    }
5324
5325    public void test_DescendingSubMapKeySet_pollLast_startIncluded_endExcluded() {
5326        NavigableSet keySet = navigableMap_startIncluded_endExcluded
5327                .navigableKeySet();
5328        NavigableSet descendingKeySet = keySet.descendingSet();
5329        Iterator iterator = descendingKeySet.iterator();
5330        assertEquals(9, keySet.size());
5331        for (int value = 108; value > 99; value--) {
5332            assertEquals(new Integer(value).toString(), keySet.pollLast());
5333        }
5334        assertEquals(0, keySet.size());
5335        assertNull(keySet.pollLast());
5336    }
5337
5338    public void test_DescendingSubMapKeySet_pollLast_startIncluded_endIncluded() {
5339        NavigableSet keySet = navigableMap_startIncluded_endIncluded
5340                .navigableKeySet();
5341        NavigableSet descendingKeySet = keySet.descendingSet();
5342        Iterator iterator = descendingKeySet.iterator();
5343        assertEquals(10, keySet.size());
5344        for (int value = 109; value > 99; value--) {
5345            assertEquals(new Integer(value).toString(), keySet.pollLast());
5346        }
5347        assertEquals(0, keySet.size());
5348        assertNull(keySet.pollLast());
5349    }
5350
5351    public void test_DescendingSubMapKeySet_pollLast() {
5352        String endKey = new Integer(2).toString();
5353        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
5354        NavigableSet descendingKeySet = keySet.descendingSet();
5355        assertEquals(new Integer(0).toString(), descendingKeySet.pollLast());
5356    }
5357
5358    public void test_DescendingSubMapKeySet_headSet() {
5359        NavigableSet keySet, descendingKeySet;
5360        SortedSet headSet;
5361        String endKey, key;
5362        Iterator iterator;
5363        int index;
5364
5365        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
5366        descendingKeySet = keySet.descendingSet();
5367        endKey = new Integer(99).toString();
5368        try {
5369            descendingKeySet.headSet(endKey);
5370            fail("should throw IllegalArgumentException");
5371        } catch (IllegalArgumentException e) {
5372            // Expected
5373        }
5374        try {
5375            descendingKeySet.headSet(endKey, false);
5376            fail("should throw IllegalArgumentException");
5377        } catch (IllegalArgumentException e) {
5378            // Expected
5379        }
5380        try {
5381            descendingKeySet.headSet(endKey, true);
5382            fail("should throw IllegalArgumentException");
5383        } catch (IllegalArgumentException e) {
5384            // Expected
5385        }
5386
5387        endKey = new Integer(100).toString();
5388        headSet = descendingKeySet.headSet(endKey);
5389        iterator = headSet.iterator();
5390        for (index = 108; iterator.hasNext(); index--) {
5391            key = (String) iterator.next();
5392            assertEquals(new Integer(index).toString(), key);
5393        }
5394        assertEquals(100, index);
5395
5396        headSet = descendingKeySet.headSet(endKey, false);
5397        iterator = headSet.iterator();
5398        for (index = 108; iterator.hasNext(); index--) {
5399            key = (String) iterator.next();
5400            assertEquals(new Integer(index).toString(), key);
5401        }
5402        assertEquals(100, index);
5403
5404        try {
5405            descendingKeySet.headSet(endKey, true);
5406            fail("should throw IllegalArgumentException");
5407        } catch (IllegalArgumentException e) {
5408            // Expected
5409        }
5410
5411        endKey = new Integer(101).toString();
5412        headSet = descendingKeySet.headSet(endKey);
5413        iterator = headSet.iterator();
5414        for (index = 108; iterator.hasNext(); index--) {
5415            key = (String) iterator.next();
5416            assertEquals(new Integer(index).toString(), key);
5417        }
5418        assertEquals(101, index);
5419
5420        headSet = descendingKeySet.headSet(endKey, false);
5421        iterator = headSet.iterator();
5422        for (index = 108; iterator.hasNext(); index--) {
5423            key = (String) iterator.next();
5424            assertEquals(new Integer(index).toString(), key);
5425        }
5426        assertEquals(101, index);
5427
5428        headSet = descendingKeySet.headSet(endKey, true);
5429        iterator = headSet.iterator();
5430        for (index = 108; iterator.hasNext(); index--) {
5431            key = (String) iterator.next();
5432            assertEquals(new Integer(index).toString(), key);
5433        }
5434        assertEquals(100, index);
5435
5436        for (int i = 102; i < 109; i++) {
5437            endKey = new Integer(i).toString();
5438            headSet = descendingKeySet.headSet(endKey);
5439            iterator = headSet.iterator();
5440            int j;
5441            for (j = 108; iterator.hasNext(); j--) {
5442                key = (String) iterator.next();
5443                assertEquals(new Integer(j).toString(), key);
5444            }
5445            assertEquals(i, j);
5446
5447            headSet = descendingKeySet.headSet(endKey, false);
5448            iterator = headSet.iterator();
5449            for (j = 108; iterator.hasNext(); j--) {
5450                key = (String) iterator.next();
5451                assertEquals(new Integer(j).toString(), key);
5452            }
5453            assertEquals(i, j);
5454
5455            headSet = descendingKeySet.headSet(endKey, true);
5456            iterator = headSet.iterator();
5457            for (j = 108; iterator.hasNext(); j--) {
5458                key = (String) iterator.next();
5459                assertEquals(new Integer(j).toString(), key);
5460            }
5461            assertEquals(i - 1, j);
5462        }
5463
5464        endKey = new Integer(109).toString();
5465        headSet = descendingKeySet.headSet(endKey);
5466        iterator = headSet.iterator();
5467        for (index = 108; iterator.hasNext(); index--) {
5468            key = (String) iterator.next();
5469            assertEquals(new Integer(index).toString(), key);
5470        }
5471        assertEquals(108, index);
5472
5473        headSet = descendingKeySet.headSet(endKey, false);
5474        iterator = headSet.iterator();
5475        for (index = 108; iterator.hasNext(); index--) {
5476            key = (String) iterator.next();
5477            assertEquals(new Integer(index).toString(), key);
5478        }
5479        assertEquals(108, index);
5480
5481        try {
5482            descendingKeySet.headSet(endKey, true);
5483            fail("should throw IllegalArgumentException");
5484        } catch (IllegalArgumentException e) {
5485            // Expected
5486        }
5487
5488        endKey = new Integer(110).toString();
5489        try {
5490            descendingKeySet.headSet(endKey);
5491            fail("should throw IllegalArgumentException");
5492        } catch (IllegalArgumentException e) {
5493            // Expected
5494        }
5495        try {
5496            descendingKeySet.headSet(endKey, true);
5497            fail("should throw IllegalArgumentException");
5498        } catch (IllegalArgumentException e) {
5499            // Expected
5500        }
5501        try {
5502            descendingKeySet.headSet(endKey, false);
5503            fail("should throw IllegalArgumentException");
5504        } catch (IllegalArgumentException e) {
5505            // Expected
5506        }
5507
5508        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
5509        descendingKeySet = keySet.descendingSet();
5510        endKey = new Integer(99).toString();
5511        try {
5512            descendingKeySet.headSet(endKey);
5513            fail("should throw IllegalArgumentException");
5514        } catch (IllegalArgumentException e) {
5515            // Expected
5516        }
5517        try {
5518            descendingKeySet.headSet(endKey, false);
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
5530        endKey = new Integer(100).toString();
5531        headSet = descendingKeySet.headSet(endKey);
5532        iterator = headSet.iterator();
5533        for (index = 109; iterator.hasNext(); index--) {
5534            key = (String) iterator.next();
5535            assertEquals(new Integer(index).toString(), key);
5536        }
5537        assertEquals(100, index);
5538
5539        headSet = descendingKeySet.headSet(endKey, false);
5540        iterator = headSet.iterator();
5541        for (index = 109; iterator.hasNext(); index--) {
5542            key = (String) iterator.next();
5543            assertEquals(new Integer(index).toString(), key);
5544        }
5545        assertEquals(100, index);
5546
5547        try {
5548            descendingKeySet.headSet(endKey, true);
5549            fail("should throw IllegalArgumentException");
5550        } catch (IllegalArgumentException e) {
5551            // Expected
5552        }
5553
5554        endKey = new Integer(101).toString();
5555        headSet = descendingKeySet.headSet(endKey);
5556        iterator = headSet.iterator();
5557        for (index = 109; iterator.hasNext(); index--) {
5558            key = (String) iterator.next();
5559            assertEquals(new Integer(index).toString(), key);
5560        }
5561        assertEquals(101, index);
5562
5563        headSet = descendingKeySet.headSet(endKey, false);
5564        iterator = headSet.iterator();
5565        for (index = 109; iterator.hasNext(); index--) {
5566            key = (String) iterator.next();
5567            assertEquals(new Integer(index).toString(), key);
5568        }
5569        assertEquals(101, index);
5570
5571        headSet = descendingKeySet.headSet(endKey, true);
5572        iterator = headSet.iterator();
5573        for (index = 109; iterator.hasNext(); index--) {
5574            key = (String) iterator.next();
5575            assertEquals(new Integer(index).toString(), key);
5576        }
5577        assertEquals(100, index);
5578
5579        for (int i = 102; i < 109; i++) {
5580            endKey = new Integer(i).toString();
5581            headSet = descendingKeySet.headSet(endKey);
5582            iterator = headSet.iterator();
5583            int j;
5584            for (j = 109; iterator.hasNext(); j--) {
5585                key = (String) iterator.next();
5586                assertEquals(new Integer(j).toString(), key);
5587            }
5588            assertEquals(i, j);
5589
5590            headSet = descendingKeySet.headSet(endKey, false);
5591            iterator = headSet.iterator();
5592            for (j = 109; iterator.hasNext(); j--) {
5593                key = (String) iterator.next();
5594                assertEquals(new Integer(j).toString(), key);
5595            }
5596            assertEquals(i, j);
5597
5598            headSet = descendingKeySet.headSet(endKey, true);
5599            iterator = headSet.iterator();
5600            for (j = 109; iterator.hasNext(); j--) {
5601                key = (String) iterator.next();
5602                assertEquals(new Integer(j).toString(), key);
5603            }
5604            assertEquals(i - 1, j);
5605        }
5606
5607        endKey = new Integer(109).toString();
5608        headSet = descendingKeySet.headSet(endKey);
5609        iterator = headSet.iterator();
5610        for (index = 109; iterator.hasNext(); index--) {
5611            key = (String) iterator.next();
5612            assertEquals(new Integer(index).toString(), key);
5613        }
5614        assertEquals(109, index);
5615
5616        headSet = descendingKeySet.headSet(endKey, false);
5617        iterator = headSet.iterator();
5618        for (index = 109; iterator.hasNext(); index--) {
5619            key = (String) iterator.next();
5620            assertEquals(new Integer(index).toString(), key);
5621        }
5622        assertEquals(109, index);
5623
5624        headSet = descendingKeySet.headSet(endKey, true);
5625        iterator = headSet.iterator();
5626        for (index = 109; iterator.hasNext(); index--) {
5627            key = (String) iterator.next();
5628            assertEquals(new Integer(index).toString(), key);
5629        }
5630        assertEquals(108, index);
5631
5632        endKey = new Integer(110).toString();
5633        try {
5634            descendingKeySet.headSet(endKey);
5635            fail("should throw IllegalArgumentException");
5636        } catch (IllegalArgumentException e) {
5637            // Expected
5638        }
5639        try {
5640            descendingKeySet.headSet(endKey, true);
5641            fail("should throw IllegalArgumentException");
5642        } catch (IllegalArgumentException e) {
5643            // Expected
5644        }
5645        try {
5646            descendingKeySet.headSet(endKey, false);
5647            fail("should throw IllegalArgumentException");
5648        } catch (IllegalArgumentException e) {
5649            // Expected
5650        }
5651
5652        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
5653        descendingKeySet = keySet.descendingSet();
5654        endKey = new Integer(99).toString();
5655        try {
5656            descendingKeySet.headSet(endKey);
5657            fail("should throw IllegalArgumentException");
5658        } catch (IllegalArgumentException e) {
5659            // Expected
5660        }
5661        try {
5662            descendingKeySet.headSet(endKey, false);
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
5674        endKey = new Integer(100).toString();
5675        headSet = descendingKeySet.headSet(endKey);
5676        iterator = headSet.iterator();
5677        for (index = 108; iterator.hasNext(); index--) {
5678            key = (String) iterator.next();
5679            assertEquals(new Integer(index).toString(), key);
5680        }
5681        assertEquals(100, index);
5682
5683        headSet = descendingKeySet.headSet(endKey, false);
5684        iterator = headSet.iterator();
5685        for (index = 108; iterator.hasNext(); index--) {
5686            key = (String) iterator.next();
5687            assertEquals(new Integer(index).toString(), key);
5688        }
5689        assertEquals(100, index);
5690
5691        headSet = descendingKeySet.headSet(endKey, true);
5692        iterator = headSet.iterator();
5693        for (index = 108; iterator.hasNext(); index--) {
5694            key = (String) iterator.next();
5695            assertEquals(new Integer(index).toString(), key);
5696        }
5697        assertEquals(99, index);
5698
5699        endKey = new Integer(101).toString();
5700        headSet = descendingKeySet.headSet(endKey);
5701        iterator = headSet.iterator();
5702        for (index = 108; iterator.hasNext(); index--) {
5703            key = (String) iterator.next();
5704            assertEquals(new Integer(index).toString(), key);
5705        }
5706        assertEquals(101, index);
5707
5708        headSet = descendingKeySet.headSet(endKey, false);
5709        iterator = headSet.iterator();
5710        for (index = 108; iterator.hasNext(); index--) {
5711            key = (String) iterator.next();
5712            assertEquals(new Integer(index).toString(), key);
5713        }
5714        assertEquals(101, index);
5715
5716        headSet = descendingKeySet.headSet(endKey, true);
5717        iterator = headSet.iterator();
5718        for (index = 108; iterator.hasNext(); index--) {
5719            key = (String) iterator.next();
5720            assertEquals(new Integer(index).toString(), key);
5721        }
5722        assertEquals(100, index);
5723
5724        for (int i = 102; i < 109; i++) {
5725            endKey = new Integer(i).toString();
5726            headSet = descendingKeySet.headSet(endKey);
5727            iterator = headSet.iterator();
5728            int j;
5729            for (j = 108; iterator.hasNext(); j--) {
5730                key = (String) iterator.next();
5731                assertEquals(new Integer(j).toString(), key);
5732            }
5733            assertEquals(i, j);
5734
5735            headSet = descendingKeySet.headSet(endKey, false);
5736            iterator = headSet.iterator();
5737            for (j = 108; iterator.hasNext(); j--) {
5738                key = (String) iterator.next();
5739                assertEquals(new Integer(j).toString(), key);
5740            }
5741            assertEquals(i, j);
5742
5743            headSet = descendingKeySet.headSet(endKey, true);
5744            iterator = headSet.iterator();
5745            for (j = 108; iterator.hasNext(); j--) {
5746                key = (String) iterator.next();
5747                assertEquals(new Integer(j).toString(), key);
5748            }
5749            assertEquals(i - 1, j);
5750        }
5751
5752        endKey = new Integer(109).toString();
5753        headSet = descendingKeySet.headSet(endKey);
5754        iterator = headSet.iterator();
5755        for (index = 108; iterator.hasNext(); index--) {
5756            key = (String) iterator.next();
5757            assertEquals(new Integer(index).toString(), key);
5758        }
5759        assertEquals(108, index);
5760
5761        headSet = descendingKeySet.headSet(endKey, false);
5762        iterator = headSet.iterator();
5763        for (index = 108; iterator.hasNext(); index--) {
5764            key = (String) iterator.next();
5765            assertEquals(new Integer(index).toString(), key);
5766        }
5767        assertEquals(108, index);
5768
5769        try {
5770            descendingKeySet.headSet(endKey, true);
5771            fail("should throw IllegalArgumentException");
5772        } catch (IllegalArgumentException e) {
5773            // Expected
5774        }
5775
5776        endKey = new Integer(110).toString();
5777        try {
5778            descendingKeySet.headSet(endKey);
5779            fail("should throw IllegalArgumentException");
5780        } catch (IllegalArgumentException e) {
5781            // Expected
5782        }
5783        try {
5784            descendingKeySet.headSet(endKey, true);
5785            fail("should throw IllegalArgumentException");
5786        } catch (IllegalArgumentException e) {
5787            // Expected
5788        }
5789        try {
5790            descendingKeySet.headSet(endKey, false);
5791            fail("should throw IllegalArgumentException");
5792        } catch (IllegalArgumentException e) {
5793            // Expected
5794        }
5795
5796        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
5797        descendingKeySet = keySet.descendingSet();
5798        endKey = new Integer(99).toString();
5799        try {
5800            descendingKeySet.headSet(endKey);
5801            fail("should throw IllegalArgumentException");
5802        } catch (IllegalArgumentException e) {
5803            // Expected
5804        }
5805        try {
5806            descendingKeySet.headSet(endKey, false);
5807            fail("should throw IllegalArgumentException");
5808        } catch (IllegalArgumentException e) {
5809            // Expected
5810        }
5811        try {
5812            descendingKeySet.headSet(endKey, true);
5813            fail("should throw IllegalArgumentException");
5814        } catch (IllegalArgumentException e) {
5815            // Expected
5816        }
5817
5818        endKey = new Integer(100).toString();
5819        headSet = descendingKeySet.headSet(endKey);
5820        iterator = headSet.iterator();
5821        for (index = 109; iterator.hasNext(); index--) {
5822            key = (String) iterator.next();
5823            assertEquals(new Integer(index).toString(), key);
5824        }
5825        assertEquals(100, index);
5826
5827        headSet = descendingKeySet.headSet(endKey, false);
5828        iterator = headSet.iterator();
5829        for (index = 109; iterator.hasNext(); index--) {
5830            key = (String) iterator.next();
5831            assertEquals(new Integer(index).toString(), key);
5832        }
5833        assertEquals(100, index);
5834
5835        headSet = descendingKeySet.headSet(endKey, true);
5836        iterator = headSet.iterator();
5837        for (index = 109; iterator.hasNext(); index--) {
5838            key = (String) iterator.next();
5839            assertEquals(new Integer(index).toString(), key);
5840        }
5841        assertEquals(99, index);
5842
5843        endKey = new Integer(101).toString();
5844        headSet = descendingKeySet.headSet(endKey);
5845        iterator = headSet.iterator();
5846        for (index = 109; iterator.hasNext(); index--) {
5847            key = (String) iterator.next();
5848            assertEquals(new Integer(index).toString(), key);
5849        }
5850        assertEquals(101, index);
5851
5852        headSet = descendingKeySet.headSet(endKey, false);
5853        iterator = headSet.iterator();
5854        for (index = 109; iterator.hasNext(); index--) {
5855            key = (String) iterator.next();
5856            assertEquals(new Integer(index).toString(), key);
5857        }
5858        assertEquals(101, index);
5859
5860        headSet = descendingKeySet.headSet(endKey, true);
5861        iterator = headSet.iterator();
5862        for (index = 109; iterator.hasNext(); index--) {
5863            key = (String) iterator.next();
5864            assertEquals(new Integer(index).toString(), key);
5865        }
5866        assertEquals(100, index);
5867
5868        for (int i = 102; i < 109; i++) {
5869            endKey = new Integer(i).toString();
5870            headSet = descendingKeySet.headSet(endKey);
5871            iterator = headSet.iterator();
5872            int j;
5873            for (j = 109; iterator.hasNext(); j--) {
5874                key = (String) iterator.next();
5875                assertEquals(new Integer(j).toString(), key);
5876            }
5877            assertEquals(i, j);
5878
5879            headSet = descendingKeySet.headSet(endKey, false);
5880            iterator = headSet.iterator();
5881            for (j = 109; iterator.hasNext(); j--) {
5882                key = (String) iterator.next();
5883                assertEquals(new Integer(j).toString(), key);
5884            }
5885            assertEquals(i, j);
5886
5887            headSet = descendingKeySet.headSet(endKey, true);
5888            iterator = headSet.iterator();
5889            for (j = 109; iterator.hasNext(); j--) {
5890                key = (String) iterator.next();
5891                assertEquals(new Integer(j).toString(), key);
5892            }
5893            assertEquals(i - 1, j);
5894        }
5895
5896        endKey = new Integer(109).toString();
5897        headSet = descendingKeySet.headSet(endKey);
5898        iterator = headSet.iterator();
5899        for (index = 109; iterator.hasNext(); index--) {
5900            key = (String) iterator.next();
5901            assertEquals(new Integer(index).toString(), key);
5902        }
5903        assertEquals(109, index);
5904
5905        headSet = descendingKeySet.headSet(endKey, false);
5906        iterator = headSet.iterator();
5907        for (index = 109; iterator.hasNext(); index--) {
5908            key = (String) iterator.next();
5909            assertEquals(new Integer(index).toString(), key);
5910        }
5911        assertEquals(109, index);
5912
5913        headSet = descendingKeySet.headSet(endKey, true);
5914        iterator = headSet.iterator();
5915        for (index = 109; iterator.hasNext(); index--) {
5916            key = (String) iterator.next();
5917            assertEquals(new Integer(index).toString(), key);
5918        }
5919        assertEquals(108, index);
5920
5921        endKey = new Integer(110).toString();
5922        try {
5923            descendingKeySet.headSet(endKey);
5924            fail("should throw IllegalArgumentException");
5925        } catch (IllegalArgumentException e) {
5926            // Expected
5927        }
5928        try {
5929            descendingKeySet.headSet(endKey, true);
5930            fail("should throw IllegalArgumentException");
5931        } catch (IllegalArgumentException e) {
5932            // Expected
5933        }
5934        try {
5935            descendingKeySet.headSet(endKey, false);
5936            fail("should throw IllegalArgumentException");
5937        } catch (IllegalArgumentException e) {
5938            // Expected
5939        }
5940
5941        key = new Integer(2).toString();
5942        keySet = tm.headMap(key, true).navigableKeySet();
5943        descendingKeySet = keySet.descendingSet();
5944        iterator = descendingKeySet.iterator();
5945        iterator.next();
5946        endKey = (String) iterator.next();
5947
5948        headSet = descendingKeySet.headSet(endKey);
5949        assertEquals(1, headSet.size());
5950
5951        headSet = descendingKeySet.headSet(endKey, false);
5952        assertEquals(1, headSet.size());
5953
5954        headSet = descendingKeySet.headSet(endKey, true);
5955        assertEquals(2, headSet.size());
5956
5957        key = new Integer(2).toString();
5958        keySet = tm.tailMap(key, true).navigableKeySet();
5959        descendingKeySet = keySet.descendingSet();
5960        iterator = descendingKeySet.iterator();
5961        iterator.next();
5962        endKey = (String) iterator.next();
5963        headSet = descendingKeySet.headSet(endKey);
5964        assertEquals(1, headSet.size());
5965        iterator = headSet.iterator();
5966        assertEquals(999, Integer.parseInt((String) iterator.next()));
5967    }
5968
5969    public void test_DescendingSubMapKeySet_tailSet() {
5970        NavigableSet keySet, descendingKeySet;
5971        SortedSet tailSet;
5972        String startKey, key;
5973        Iterator iterator;
5974        int index;
5975
5976        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
5977        descendingKeySet = keySet.descendingSet();
5978        startKey = new Integer(99).toString();
5979        try {
5980            descendingKeySet.tailSet(startKey);
5981            fail("should throw IllegalArgumentException");
5982        } catch (IllegalArgumentException e) {
5983            // Expected
5984        }
5985
5986        try {
5987            descendingKeySet.tailSet(startKey, true);
5988            fail("should throw IllegalArgumentException");
5989        } catch (IllegalArgumentException e) {
5990            // Expected
5991        }
5992
5993        try {
5994            descendingKeySet.tailSet(startKey, false);
5995            fail("should throw IllegalArgumentException");
5996        } catch (IllegalArgumentException e) {
5997            // Expected
5998        }
5999
6000        startKey = new Integer(100).toString();
6001        try {
6002            descendingKeySet.tailSet(startKey);
6003            fail("should throw IllegalArgumentException");
6004        } catch (IllegalArgumentException e) {
6005            // Expected
6006        }
6007        try {
6008            descendingKeySet.tailSet(startKey, true);
6009            fail("should throw IllegalArgumentException");
6010        } catch (IllegalArgumentException e) {
6011            // Expected
6012        }
6013        tailSet = descendingKeySet.tailSet(startKey, false);
6014        assertEquals(0, tailSet.size());
6015
6016        startKey = new Integer(101).toString();
6017        tailSet = descendingKeySet.tailSet(startKey);
6018        iterator = tailSet.iterator();
6019        for (index = 101; iterator.hasNext(); index--) {
6020            key = (String) iterator.next();
6021            assertEquals(new Integer(index).toString(), key);
6022        }
6023        assertEquals(100, index);
6024
6025        tailSet = descendingKeySet.tailSet(startKey, true);
6026        iterator = tailSet.iterator();
6027        for (index = 101; iterator.hasNext(); index--) {
6028            key = (String) iterator.next();
6029            assertEquals(new Integer(index).toString(), key);
6030        }
6031        assertEquals(100, index);
6032
6033        tailSet = descendingKeySet.tailSet(startKey, false);
6034        iterator = tailSet.iterator();
6035        for (index = 101; iterator.hasNext(); index--) {
6036            key = (String) iterator.next();
6037            assertEquals(new Integer(index).toString(), key);
6038        }
6039        assertEquals(101, index);
6040
6041        for (int i = 102; i < 109; i++) {
6042            startKey = new Integer(i).toString();
6043
6044            tailSet = descendingKeySet.tailSet(startKey);
6045            iterator = tailSet.iterator();
6046            int j;
6047            for (j = i; iterator.hasNext(); j--) {
6048                key = (String) iterator.next();
6049                assertEquals(new Integer(j).toString(), key);
6050            }
6051            assertEquals(100, j);
6052
6053            tailSet = descendingKeySet.tailSet(startKey, true);
6054            iterator = tailSet.iterator();
6055            for (j = i; iterator.hasNext(); j--) {
6056                key = (String) iterator.next();
6057                assertEquals(new Integer(j).toString(), key);
6058            }
6059            assertEquals(100, j);
6060
6061            tailSet = descendingKeySet.tailSet(startKey, false);
6062            iterator = tailSet.iterator();
6063            for (j = i; iterator.hasNext(); j--) {
6064                key = (String) iterator.next();
6065                assertEquals(new Integer(j - 1).toString(), key);
6066            }
6067            assertEquals(101, j);
6068        }
6069
6070        startKey = new Integer(109).toString();
6071        try {
6072            descendingKeySet.tailSet(startKey);
6073            fail("should throw IllegalArgumentException");
6074        } catch (IllegalArgumentException e) {
6075            // Expected
6076        }
6077        try {
6078            descendingKeySet.tailSet(startKey, true);
6079            fail("should throw IllegalArgumentException");
6080        } catch (IllegalArgumentException e) {
6081            // Expected
6082        }
6083        tailSet = descendingKeySet.tailSet(startKey, false);
6084        iterator = tailSet.iterator();
6085        for (index = 109; iterator.hasNext(); index--) {
6086            key = (String) iterator.next();
6087            assertEquals(new Integer(index - 1).toString(), key);
6088        }
6089        assertEquals(101, index);
6090
6091        startKey = new Integer(110).toString();
6092        try {
6093            descendingKeySet.tailSet(startKey);
6094            fail("should throw IllegalArgumentException");
6095        } catch (IllegalArgumentException e) {
6096            // Expected
6097        }
6098        try {
6099            descendingKeySet.tailSet(startKey, true);
6100            fail("should throw IllegalArgumentException");
6101        } catch (IllegalArgumentException e) {
6102            // Expected
6103        }
6104        try {
6105            descendingKeySet.tailSet(startKey, false);
6106            fail("should throw IllegalArgumentException");
6107        } catch (IllegalArgumentException e) {
6108            // Expected
6109        }
6110
6111        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
6112        descendingKeySet = keySet.descendingSet();
6113        startKey = new Integer(99).toString();
6114        try {
6115            descendingKeySet.tailSet(startKey);
6116            fail("should throw IllegalArgumentException");
6117        } catch (IllegalArgumentException e) {
6118            // Expected
6119        }
6120
6121        try {
6122            descendingKeySet.tailSet(startKey, true);
6123            fail("should throw IllegalArgumentException");
6124        } catch (IllegalArgumentException e) {
6125            // Expected
6126        }
6127
6128        try {
6129            descendingKeySet.tailSet(startKey, false);
6130            fail("should throw IllegalArgumentException");
6131        } catch (IllegalArgumentException e) {
6132            // Expected
6133        }
6134
6135        startKey = new Integer(100).toString();
6136        try {
6137            descendingKeySet.tailSet(startKey);
6138            fail("should throw IllegalArgumentException");
6139        } catch (IllegalArgumentException e) {
6140            // Expected
6141        }
6142        try {
6143            descendingKeySet.tailSet(startKey, true);
6144            fail("should throw IllegalArgumentException");
6145        } catch (IllegalArgumentException e) {
6146            // Expected
6147        }
6148        tailSet = descendingKeySet.tailSet(startKey, false);
6149        assertEquals(0, tailSet.size());
6150
6151        startKey = new Integer(101).toString();
6152        tailSet = descendingKeySet.tailSet(startKey);
6153        iterator = tailSet.iterator();
6154        for (index = 101; iterator.hasNext(); index--) {
6155            key = (String) iterator.next();
6156            assertEquals(new Integer(index).toString(), key);
6157        }
6158        assertEquals(100, index);
6159
6160        tailSet = descendingKeySet.tailSet(startKey, true);
6161        iterator = tailSet.iterator();
6162        for (index = 101; iterator.hasNext(); index--) {
6163            key = (String) iterator.next();
6164            assertEquals(new Integer(index).toString(), key);
6165        }
6166        assertEquals(100, index);
6167
6168        tailSet = descendingKeySet.tailSet(startKey, false);
6169        iterator = tailSet.iterator();
6170        for (index = 101; iterator.hasNext(); index--) {
6171            key = (String) iterator.next();
6172            assertEquals(new Integer(index).toString(), key);
6173        }
6174        assertEquals(101, index);
6175
6176        for (int i = 102; i < 109; i++) {
6177            startKey = new Integer(i).toString();
6178
6179            tailSet = descendingKeySet.tailSet(startKey);
6180            iterator = tailSet.iterator();
6181            int j;
6182            for (j = i; iterator.hasNext(); j--) {
6183                key = (String) iterator.next();
6184                assertEquals(new Integer(j).toString(), key);
6185            }
6186            assertEquals(100, j);
6187
6188            tailSet = descendingKeySet.tailSet(startKey, true);
6189            iterator = tailSet.iterator();
6190            for (j = i; iterator.hasNext(); j--) {
6191                key = (String) iterator.next();
6192                assertEquals(new Integer(j).toString(), key);
6193            }
6194            assertEquals(100, j);
6195
6196            tailSet = descendingKeySet.tailSet(startKey, false);
6197            iterator = tailSet.iterator();
6198            for (j = i; iterator.hasNext(); j--) {
6199                key = (String) iterator.next();
6200                assertEquals(new Integer(j - 1).toString(), key);
6201            }
6202            assertEquals(101, j);
6203        }
6204
6205        startKey = new Integer(109).toString();
6206        tailSet = descendingKeySet.tailSet(startKey);
6207        iterator = tailSet.iterator();
6208        for (index = 109; iterator.hasNext(); index--) {
6209            key = (String) iterator.next();
6210            assertEquals(new Integer(index).toString(), key);
6211        }
6212        assertEquals(100, index);
6213
6214        tailSet = descendingKeySet.tailSet(startKey, true);
6215        iterator = tailSet.iterator();
6216        for (index = 109; iterator.hasNext(); index--) {
6217            key = (String) iterator.next();
6218            assertEquals(new Integer(index).toString(), key);
6219        }
6220        assertEquals(100, index);
6221
6222        tailSet = descendingKeySet.tailSet(startKey, false);
6223        iterator = tailSet.iterator();
6224        for (index = 109; iterator.hasNext(); index--) {
6225            key = (String) iterator.next();
6226            assertEquals(new Integer(index - 1).toString(), key);
6227        }
6228        assertEquals(101, index);
6229
6230        startKey = new Integer(110).toString();
6231        try {
6232            descendingKeySet.tailSet(startKey);
6233            fail("should throw IllegalArgumentException");
6234        } catch (IllegalArgumentException e) {
6235            // Expected
6236        }
6237        try {
6238            descendingKeySet.tailSet(startKey, true);
6239            fail("should throw IllegalArgumentException");
6240        } catch (IllegalArgumentException e) {
6241            // Expected
6242        }
6243        try {
6244            descendingKeySet.tailSet(startKey, false);
6245            fail("should throw IllegalArgumentException");
6246        } catch (IllegalArgumentException e) {
6247            // Expected
6248        }
6249
6250        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
6251        descendingKeySet = keySet.descendingSet();
6252        startKey = new Integer(99).toString();
6253        try {
6254            descendingKeySet.tailSet(startKey);
6255            fail("should throw IllegalArgumentException");
6256        } catch (IllegalArgumentException e) {
6257            // Expected
6258        }
6259        try {
6260            descendingKeySet.tailSet(startKey, true);
6261            fail("should throw IllegalArgumentException");
6262        } catch (IllegalArgumentException e) {
6263            // Expected
6264        }
6265        try {
6266            descendingKeySet.tailSet(startKey, false);
6267            fail("should throw IllegalArgumentException");
6268        } catch (IllegalArgumentException e) {
6269            // Expected
6270        }
6271
6272        startKey = new Integer(100).toString();
6273        tailSet = descendingKeySet.tailSet(startKey);
6274        assertEquals(1, tailSet.size());
6275        iterator = tailSet.iterator();
6276        assertEquals(startKey, iterator.next());
6277
6278        tailSet = descendingKeySet.tailSet(startKey, true);
6279        assertEquals(1, tailSet.size());
6280        iterator = tailSet.iterator();
6281        assertEquals(startKey, iterator.next());
6282
6283        tailSet = descendingKeySet.tailSet(startKey, false);
6284        assertEquals(0, tailSet.size());
6285
6286        startKey = new Integer(101).toString();
6287        tailSet = descendingKeySet.tailSet(startKey);
6288        iterator = tailSet.iterator();
6289        for (index = 101; iterator.hasNext(); index--) {
6290            key = (String) iterator.next();
6291            assertEquals(new Integer(index).toString(), key);
6292        }
6293        assertEquals(99, index);
6294
6295        tailSet = descendingKeySet.tailSet(startKey, true);
6296        iterator = tailSet.iterator();
6297        for (index = 101; iterator.hasNext(); index--) {
6298            key = (String) iterator.next();
6299            assertEquals(new Integer(index).toString(), key);
6300        }
6301        assertEquals(99, index);
6302
6303        tailSet = descendingKeySet.tailSet(startKey, false);
6304        iterator = tailSet.iterator();
6305        for (index = 101; iterator.hasNext(); index--) {
6306            key = (String) iterator.next();
6307            assertEquals(new Integer(index - 1).toString(), key);
6308        }
6309        assertEquals(100, index);
6310
6311        for (int i = 102; i < 109; i++) {
6312            startKey = new Integer(i).toString();
6313
6314            tailSet = descendingKeySet.tailSet(startKey);
6315            iterator = tailSet.iterator();
6316            int j;
6317            for (j = i; iterator.hasNext(); j--) {
6318                key = (String) iterator.next();
6319                assertEquals(new Integer(j).toString(), key);
6320            }
6321            assertEquals(99, j);
6322
6323            tailSet = descendingKeySet.tailSet(startKey, true);
6324            iterator = tailSet.iterator();
6325            for (j = i; iterator.hasNext(); j--) {
6326                key = (String) iterator.next();
6327                assertEquals(new Integer(j).toString(), key);
6328            }
6329            assertEquals(99, j);
6330
6331            tailSet = descendingKeySet.tailSet(startKey, false);
6332            iterator = tailSet.iterator();
6333            for (j = i; iterator.hasNext(); j--) {
6334                key = (String) iterator.next();
6335                assertEquals(new Integer(j - 1).toString(), key);
6336            }
6337            assertEquals(100, j);
6338        }
6339
6340        startKey = new Integer(109).toString();
6341        try {
6342            descendingKeySet.tailSet(startKey);
6343            fail("should throw IllegalArgumentException");
6344        } catch (IllegalArgumentException e) {
6345            // Expected
6346        }
6347        try {
6348            descendingKeySet.tailSet(startKey, true);
6349            fail("should throw IllegalArgumentException");
6350        } catch (IllegalArgumentException e) {
6351            // Expected
6352        }
6353        tailSet = descendingKeySet.tailSet(startKey, false);
6354        iterator = tailSet.iterator();
6355        for (index = 109; iterator.hasNext(); index--) {
6356            key = (String) iterator.next();
6357            assertEquals(new Integer(index - 1).toString(), key);
6358        }
6359        assertEquals(100, index);
6360
6361        startKey = new Integer(110).toString();
6362        try {
6363            descendingKeySet.tailSet(startKey);
6364            fail("should throw IllegalArgumentException");
6365        } catch (IllegalArgumentException e) {
6366            // Expected
6367        }
6368        try {
6369            descendingKeySet.tailSet(startKey, true);
6370            fail("should throw IllegalArgumentException");
6371        } catch (IllegalArgumentException e) {
6372            // Expected
6373        }
6374        try {
6375            descendingKeySet.tailSet(startKey, false);
6376            fail("should throw IllegalArgumentException");
6377        } catch (IllegalArgumentException e) {
6378            // Expected
6379        }
6380
6381        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
6382        descendingKeySet = keySet.descendingSet();
6383        startKey = new Integer(99).toString();
6384        try {
6385            descendingKeySet.tailSet(startKey);
6386            fail("should throw IllegalArgumentException");
6387        } catch (IllegalArgumentException e) {
6388            // Expected
6389        }
6390        try {
6391            descendingKeySet.tailSet(startKey, true);
6392            fail("should throw IllegalArgumentException");
6393        } catch (IllegalArgumentException e) {
6394            // Expected
6395        }
6396        try {
6397            descendingKeySet.tailSet(startKey, false);
6398            fail("should throw IllegalArgumentException");
6399        } catch (IllegalArgumentException e) {
6400            // Expected
6401        }
6402
6403        startKey = new Integer(100).toString();
6404        tailSet = descendingKeySet.tailSet(startKey);
6405        assertEquals(1, tailSet.size());
6406        iterator = tailSet.iterator();
6407        assertEquals(startKey, iterator.next());
6408
6409        tailSet = descendingKeySet.tailSet(startKey, true);
6410        assertEquals(1, tailSet.size());
6411        iterator = tailSet.iterator();
6412        assertEquals(startKey, iterator.next());
6413
6414        tailSet = descendingKeySet.tailSet(startKey, false);
6415        assertEquals(0, tailSet.size());
6416
6417        startKey = new Integer(101).toString();
6418        tailSet = descendingKeySet.tailSet(startKey);
6419        iterator = tailSet.iterator();
6420        for (index = 101; iterator.hasNext(); index--) {
6421            key = (String) iterator.next();
6422            assertEquals(new Integer(index).toString(), key);
6423        }
6424        assertEquals(99, index);
6425
6426        tailSet = descendingKeySet.tailSet(startKey, true);
6427        iterator = tailSet.iterator();
6428        for (index = 101; iterator.hasNext(); index--) {
6429            key = (String) iterator.next();
6430            assertEquals(new Integer(index).toString(), key);
6431        }
6432        assertEquals(99, index);
6433
6434        tailSet = descendingKeySet.tailSet(startKey, false);
6435        iterator = tailSet.iterator();
6436        for (index = 101; iterator.hasNext(); index--) {
6437            key = (String) iterator.next();
6438            assertEquals(new Integer(index - 1).toString(), key);
6439        }
6440        assertEquals(100, index);
6441
6442        for (int i = 102; i < 109; i++) {
6443            startKey = new Integer(i).toString();
6444
6445            tailSet = descendingKeySet.tailSet(startKey);
6446            iterator = tailSet.iterator();
6447            int j;
6448            for (j = i; iterator.hasNext(); j--) {
6449                key = (String) iterator.next();
6450                assertEquals(new Integer(j).toString(), key);
6451            }
6452            assertEquals(99, j);
6453
6454            tailSet = descendingKeySet.tailSet(startKey, true);
6455            iterator = tailSet.iterator();
6456            for (j = i; iterator.hasNext(); j--) {
6457                key = (String) iterator.next();
6458                assertEquals(new Integer(j).toString(), key);
6459            }
6460            assertEquals(99, j);
6461
6462            tailSet = descendingKeySet.tailSet(startKey, false);
6463            iterator = tailSet.iterator();
6464            for (j = i; iterator.hasNext(); j--) {
6465                key = (String) iterator.next();
6466                assertEquals(new Integer(j - 1).toString(), key);
6467            }
6468            assertEquals(100, j);
6469        }
6470
6471        startKey = new Integer(109).toString();
6472        tailSet = descendingKeySet.tailSet(startKey);
6473        iterator = tailSet.iterator();
6474        for (index = 109; iterator.hasNext(); index--) {
6475            key = (String) iterator.next();
6476            assertEquals(new Integer(index).toString(), key);
6477        }
6478        assertEquals(99, index);
6479
6480        tailSet = descendingKeySet.tailSet(startKey, true);
6481        iterator = tailSet.iterator();
6482        for (index = 109; iterator.hasNext(); index--) {
6483            key = (String) iterator.next();
6484            assertEquals(new Integer(index).toString(), key);
6485        }
6486        assertEquals(99, index);
6487
6488        tailSet = descendingKeySet.tailSet(startKey, false);
6489        iterator = tailSet.iterator();
6490        for (index = 109; iterator.hasNext(); index--) {
6491            key = (String) iterator.next();
6492            assertEquals(new Integer(index - 1).toString(), key);
6493        }
6494        assertEquals(100, index);
6495
6496        startKey = new Integer(110).toString();
6497        try {
6498            descendingKeySet.tailSet(startKey);
6499            fail("should throw IllegalArgumentException");
6500        } catch (IllegalArgumentException e) {
6501            // Expected
6502        }
6503        try {
6504            descendingKeySet.tailSet(startKey, true);
6505            fail("should throw IllegalArgumentException");
6506        } catch (IllegalArgumentException e) {
6507            // Expected
6508        }
6509        try {
6510            descendingKeySet.tailSet(startKey, false);
6511            fail("should throw IllegalArgumentException");
6512        } catch (IllegalArgumentException e) {
6513            // Expected
6514        }
6515
6516        key = new Integer(2).toString();
6517        keySet = tm.headMap(key, true).navigableKeySet();
6518        descendingKeySet = keySet.descendingSet();
6519        iterator = descendingKeySet.iterator();
6520        iterator.next();
6521        startKey = (String) iterator.next();
6522
6523        tailSet = descendingKeySet.tailSet(startKey);
6524        assertEquals(112, tailSet.size());
6525        Iterator tailIterator = tailSet.iterator();
6526        assertEquals(new Integer(199).toString(), tailIterator.next());
6527
6528        tailSet = descendingKeySet.tailSet(startKey, true);
6529        assertEquals(112, tailSet.size());
6530        tailIterator = tailSet.iterator();
6531        assertEquals(new Integer(199).toString(), tailIterator.next());
6532
6533        tailSet = descendingKeySet.tailSet(startKey, false);
6534        assertEquals(111, tailSet.size());
6535        tailIterator = tailSet.iterator();
6536        assertEquals(new Integer(198).toString(), tailIterator.next());
6537    }
6538
6539    public void test_DescendingSubMapKeySet_subSet() {
6540        NavigableSet keySet, descendingKeySet;
6541        SortedSet subSet;
6542        String startKey, endKey, key;
6543        Iterator startIterator, endIterator, subSetIterator;
6544
6545        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
6546        descendingKeySet = keySet.descendingSet();
6547        startIterator = descendingKeySet.iterator();
6548        while (startIterator.hasNext()) {
6549            startKey = (String) startIterator.next();
6550            endIterator = descendingKeySet.iterator();
6551            while (endIterator.hasNext()) {
6552                endKey = (String) endIterator.next();
6553                int startIndex = Integer.valueOf(startKey);
6554                int endIndex = Integer.valueOf(endKey);
6555                if (startIndex < endIndex) {
6556                    try {
6557                        descendingKeySet.subSet(startKey, endKey);
6558                        fail("should throw IllegalArgumentException");
6559                    } catch (IllegalArgumentException e) {
6560                        // Expected
6561                    }
6562
6563                    try {
6564                        descendingKeySet.subSet(startKey, false, endKey, false);
6565                        fail("shoudl throw IllegalArgumentException");
6566                    } catch (IllegalArgumentException e) {
6567                        // Expected
6568                    }
6569
6570                    try {
6571                        descendingKeySet.subSet(startKey, false, endKey, true);
6572                        fail("shoudl throw IllegalArgumentException");
6573                    } catch (IllegalArgumentException e) {
6574                        // Expected
6575                    }
6576
6577                    try {
6578                        descendingKeySet.subSet(startKey, true, endKey, false);
6579                        fail("shoudl throw IllegalArgumentException");
6580                    } catch (IllegalArgumentException e) {
6581                        // Expected
6582                    }
6583
6584                    try {
6585                        descendingKeySet.subSet(startKey, true, endKey, true);
6586                        fail("shoudl throw IllegalArgumentException");
6587                    } catch (IllegalArgumentException e) {
6588                        // Expected
6589                    }
6590                } else {
6591                    subSet = descendingKeySet.subSet(startKey, endKey);
6592                    subSetIterator = subSet.iterator();
6593                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6594                        assertEquals(new Integer(index).toString(),
6595                                subSetIterator.next());
6596                    }
6597
6598                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6599                            false);
6600                    subSetIterator = subSet.iterator();
6601                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6602                        assertEquals(new Integer(index).toString(),
6603                                subSetIterator.next());
6604                    }
6605
6606                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6607                            true);
6608                    subSetIterator = subSet.iterator();
6609                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6610                        assertEquals(new Integer(index).toString(),
6611                                subSetIterator.next());
6612                    }
6613
6614                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6615                            false);
6616                    subSetIterator = subSet.iterator();
6617                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6618                        assertEquals(new Integer(index).toString(),
6619                                subSetIterator.next());
6620                    }
6621
6622                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6623                            true);
6624                    subSetIterator = subSet.iterator();
6625                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6626                        assertEquals(new Integer(index).toString(),
6627                                subSetIterator.next());
6628                    }
6629                }
6630            }
6631        }
6632
6633        endKey = new Integer(2).toString();
6634        keySet = tm.headMap(endKey, true).navigableKeySet();
6635        descendingKeySet = keySet.descendingSet();
6636        Iterator iterator = descendingKeySet.iterator();
6637
6638        startKey = (String) iterator.next();
6639        iterator.next();
6640        endKey = (String) iterator.next();
6641
6642        subSet = descendingKeySet.subSet(startKey, endKey);
6643        assertEquals(2, subSet.size());
6644        subSetIterator = subSet.iterator();
6645        assertEquals(startKey, subSetIterator.next());
6646        subSetIterator.next();
6647        try {
6648            subSetIterator.next();
6649            fail("should throw NoSuchElementException");
6650        } catch (NoSuchElementException e) {
6651            // Expected
6652        }
6653
6654        subSet = descendingKeySet.subSet(startKey, false, endKey, false);
6655        assertEquals(1, subSet.size());
6656        subSetIterator = subSet.iterator();
6657        subSetIterator.next();
6658        try {
6659            subSetIterator.next();
6660            fail("should throw NoSuchElementException");
6661        } catch (NoSuchElementException e) {
6662            // Expected
6663        }
6664
6665        subSet = descendingKeySet.subSet(startKey, false, endKey, true);
6666        assertEquals(2, subSet.size());
6667        subSetIterator = subSet.iterator();
6668        subSetIterator.next();
6669        assertEquals(endKey, subSetIterator.next());
6670        try {
6671            subSetIterator.next();
6672            fail("should throw NoSuchElementException");
6673        } catch (NoSuchElementException e) {
6674            // Expected
6675        }
6676
6677        subSet = descendingKeySet.subSet(startKey, true, endKey, false);
6678        assertEquals(2, subSet.size());
6679        subSetIterator = subSet.iterator();
6680        assertEquals(startKey, subSetIterator.next());
6681        subSetIterator.next();
6682        try {
6683            subSetIterator.next();
6684            fail("should throw NoSuchElementException");
6685        } catch (NoSuchElementException e) {
6686            // Expected
6687        }
6688
6689        subSet = descendingKeySet.subSet(startKey, true, endKey, true);
6690        assertEquals(3, subSet.size());
6691        subSetIterator = subSet.iterator();
6692        assertEquals(startKey, subSetIterator.next());
6693        subSetIterator.next();
6694        assertEquals(endKey, subSetIterator.next());
6695        try {
6696            subSetIterator.next();
6697            fail("should throw NoSuchElementException");
6698        } catch (NoSuchElementException e) {
6699            // Expected
6700        }
6701
6702        // With Comparator
6703        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
6704                .navigableKeySet();
6705        descendingKeySet = keySet.descendingSet();
6706        startIterator = descendingKeySet.iterator();
6707        while (startIterator.hasNext()) {
6708            startKey = (String) startIterator.next();
6709            endIterator = descendingKeySet.iterator();
6710            while (endIterator.hasNext()) {
6711                endKey = (String) endIterator.next();
6712                int startIndex = Integer.valueOf(startKey);
6713                int endIndex = Integer.valueOf(endKey);
6714                if (startIndex < endIndex) {
6715                    try {
6716                        descendingKeySet.subSet(startKey, endKey);
6717                        fail("should throw IllegalArgumentException");
6718                    } catch (IllegalArgumentException e) {
6719                        // Expected
6720                    }
6721
6722                    try {
6723                        descendingKeySet.subSet(startKey, false, endKey, false);
6724                        fail("shoudl throw IllegalArgumentException");
6725                    } catch (IllegalArgumentException e) {
6726                        // Expected
6727                    }
6728
6729                    try {
6730                        descendingKeySet.subSet(startKey, false, endKey, true);
6731                        fail("shoudl throw IllegalArgumentException");
6732                    } catch (IllegalArgumentException e) {
6733                        // Expected
6734                    }
6735
6736                    try {
6737                        descendingKeySet.subSet(startKey, true, endKey, false);
6738                        fail("shoudl throw IllegalArgumentException");
6739                    } catch (IllegalArgumentException e) {
6740                        // Expected
6741                    }
6742
6743                    try {
6744                        descendingKeySet.subSet(startKey, true, endKey, true);
6745                        fail("shoudl throw IllegalArgumentException");
6746                    } catch (IllegalArgumentException e) {
6747                        // Expected
6748                    }
6749                } else {
6750                    subSet = descendingKeySet.subSet(startKey, endKey);
6751                    subSetIterator = subSet.iterator();
6752                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6753                        assertEquals(new Integer(index).toString(),
6754                                subSetIterator.next());
6755                    }
6756
6757                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6758                            false);
6759                    subSetIterator = subSet.iterator();
6760                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6761                        assertEquals(new Integer(index).toString(),
6762                                subSetIterator.next());
6763                    }
6764
6765                    subSet = descendingKeySet.subSet(startKey, false, endKey,
6766                            true);
6767                    subSetIterator = subSet.iterator();
6768                    for (int index = startIndex - 1; subSetIterator.hasNext(); index--) {
6769                        assertEquals(new Integer(index).toString(),
6770                                subSetIterator.next());
6771                    }
6772
6773                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6774                            false);
6775                    subSetIterator = subSet.iterator();
6776                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6777                        assertEquals(new Integer(index).toString(),
6778                                subSetIterator.next());
6779                    }
6780
6781                    subSet = descendingKeySet.subSet(startKey, true, endKey,
6782                            true);
6783                    subSetIterator = subSet.iterator();
6784                    for (int index = startIndex; subSetIterator.hasNext(); index--) {
6785                        assertEquals(new Integer(index).toString(),
6786                                subSetIterator.next());
6787                    }
6788                }
6789            }
6790        }
6791    }
6792
6793    public void test_DescendingSubMapKeySet_descendingSet() {
6794        NavigableSet keySet, descendingSet, descendingDescendingSet;
6795        int value;
6796        Iterator iterator;
6797
6798        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
6799        descendingSet = keySet.descendingSet();
6800        descendingDescendingSet = descendingSet.descendingSet();
6801        iterator = descendingDescendingSet.iterator();
6802        assertTrue(iterator.hasNext());
6803        for (value = 101; iterator.hasNext(); value++) {
6804            assertEquals(new Integer(value).toString(), iterator.next());
6805        }
6806        assertEquals(109, value);
6807        try {
6808            iterator.next();
6809            fail("should throw NoSuchElementException");
6810        } catch (NoSuchElementException e) {
6811            // Expected
6812        }
6813
6814        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
6815        descendingSet = keySet.descendingSet();
6816        descendingDescendingSet = descendingSet.descendingSet();
6817        iterator = descendingDescendingSet.iterator();
6818        assertTrue(iterator.hasNext());
6819        for (value = 101; iterator.hasNext(); value++) {
6820            assertEquals(new Integer(value).toString(), iterator.next());
6821        }
6822        assertEquals(110, value);
6823        try {
6824            iterator.next();
6825            fail("should throw NoSuchElementException");
6826        } catch (NoSuchElementException e) {
6827            // Expected
6828        }
6829
6830        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
6831        descendingSet = keySet.descendingSet();
6832        descendingDescendingSet = descendingSet.descendingSet();
6833        iterator = descendingDescendingSet.iterator();
6834        assertTrue(iterator.hasNext());
6835        for (value = 100; iterator.hasNext(); value++) {
6836            assertEquals(new Integer(value).toString(), iterator.next());
6837        }
6838        assertEquals(109, value);
6839        try {
6840            iterator.next();
6841            fail("should throw NoSuchElementException");
6842        } catch (NoSuchElementException e) {
6843            // Expected
6844        }
6845
6846        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
6847        descendingSet = keySet.descendingSet();
6848        descendingDescendingSet = descendingSet.descendingSet();
6849        iterator = descendingDescendingSet.iterator();
6850        assertTrue(iterator.hasNext());
6851        for (value = 100; iterator.hasNext(); value++) {
6852            assertEquals(new Integer(value).toString(), iterator.next());
6853        }
6854        assertEquals(110, value);
6855        try {
6856            iterator.next();
6857            fail("should throw NoSuchElementException");
6858        } catch (NoSuchElementException e) {
6859            // Expected
6860        }
6861
6862        String endKey = new Integer(2).toString();
6863        keySet = tm.headMap(endKey, true).navigableKeySet();
6864        descendingSet = keySet.descendingSet();
6865        descendingDescendingSet = descendingSet.descendingSet();
6866        assertEquals(keySet, descendingDescendingSet);
6867
6868        String startKey = new Integer(2).toString();
6869        keySet = tm.tailMap(startKey, true).navigableKeySet();
6870        descendingSet = keySet.descendingSet();
6871        descendingDescendingSet = descendingSet.descendingSet();
6872        assertEquals(keySet, descendingDescendingSet);
6873    }
6874
6875    public void test_DescendingSubMapKeySet_descendingIterator() {
6876        NavigableSet keySet, descendingSet;
6877        int value;
6878        Iterator iterator, descendingIterator;
6879
6880        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
6881        descendingSet = keySet.descendingSet();
6882        descendingIterator = descendingSet.descendingIterator();
6883        assertTrue(descendingIterator.hasNext());
6884        for (value = 101; descendingIterator.hasNext(); value++) {
6885            assertEquals(new Integer(value).toString(), descendingIterator
6886                    .next());
6887        }
6888        assertEquals(109, value);
6889        try {
6890            descendingIterator.next();
6891            fail("should throw NoSuchElementException");
6892        } catch (NoSuchElementException e) {
6893            // Expected
6894        }
6895
6896        descendingSet = descendingSet
6897                .headSet(new Integer(105).toString(), true);
6898        descendingIterator = descendingSet.descendingIterator();
6899        for (value = 105; descendingIterator.hasNext(); value++) {
6900            assertEquals(new Integer(value).toString(), descendingIterator
6901                    .next());
6902        }
6903
6904        descendingSet = keySet.descendingSet();
6905        descendingSet = descendingSet
6906                .tailSet(new Integer(105).toString(), true);
6907        descendingIterator = descendingSet.descendingIterator();
6908        for (value = 101; descendingIterator.hasNext(); value++) {
6909            assertEquals(new Integer(value).toString(), descendingIterator
6910                    .next());
6911        }
6912
6913        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
6914        descendingSet = keySet.descendingSet();
6915        descendingIterator = descendingSet.descendingIterator();
6916        assertTrue(descendingIterator.hasNext());
6917        for (value = 101; descendingIterator.hasNext(); value++) {
6918            assertEquals(new Integer(value).toString(), descendingIterator
6919                    .next());
6920        }
6921        assertEquals(110, value);
6922        try {
6923            descendingIterator.next();
6924            fail("should throw NoSuchElementException");
6925        } catch (NoSuchElementException e) {
6926            // Expected
6927        }
6928
6929        descendingSet = descendingSet
6930                .headSet(new Integer(105).toString(), true);
6931        descendingIterator = descendingSet.descendingIterator();
6932        for (value = 105; descendingIterator.hasNext(); value++) {
6933            assertEquals(new Integer(value).toString(), descendingIterator
6934                    .next());
6935        }
6936
6937        descendingSet = keySet.descendingSet();
6938        descendingSet = descendingSet
6939                .tailSet(new Integer(105).toString(), true);
6940        descendingIterator = descendingSet.descendingIterator();
6941        for (value = 101; descendingIterator.hasNext(); value++) {
6942            assertEquals(new Integer(value).toString(), descendingIterator
6943                    .next());
6944        }
6945
6946        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
6947        descendingSet = keySet.descendingSet();
6948        descendingIterator = descendingSet.descendingIterator();
6949        assertTrue(descendingIterator.hasNext());
6950        for (value = 100; descendingIterator.hasNext(); value++) {
6951            assertEquals(new Integer(value).toString(), descendingIterator
6952                    .next());
6953        }
6954        assertEquals(109, value);
6955        try {
6956            descendingIterator.next();
6957            fail("should throw NoSuchElementException");
6958        } catch (NoSuchElementException e) {
6959            // Expected
6960        }
6961
6962        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
6963        descendingSet = keySet.descendingSet();
6964        descendingIterator = descendingSet.descendingIterator();
6965        assertTrue(descendingIterator.hasNext());
6966        for (value = 100; descendingIterator.hasNext(); value++) {
6967            assertEquals(new Integer(value).toString(), descendingIterator
6968                    .next());
6969        }
6970        assertEquals(110, value);
6971        try {
6972            descendingIterator.next();
6973            fail("should throw NoSuchElementException");
6974        } catch (NoSuchElementException e) {
6975            // Expected
6976        }
6977
6978        String endKey = new Integer(2).toString();
6979        keySet = tm.headMap(endKey, true).navigableKeySet();
6980        iterator = keySet.iterator();
6981
6982        descendingSet = keySet.descendingSet();
6983        descendingIterator = descendingSet.descendingIterator();
6984
6985        while (iterator.hasNext()) {
6986            assertEquals(iterator.next(), descendingIterator.next());
6987        }
6988
6989        String startKey = new Integer(2).toString();
6990        keySet = tm.tailMap(startKey, true).navigableKeySet();
6991        iterator = keySet.iterator();
6992        descendingSet = keySet.descendingSet();
6993        descendingIterator = descendingSet.descendingIterator();
6994
6995        while (iterator.hasNext()) {
6996            assertEquals(iterator.next(), descendingIterator.next());
6997        }
6998    }
6999
7000    public void test_DescendingSubMapKeySet_lower() {
7001        NavigableSet keySet, descendingKeySet;
7002        Iterator iterator;
7003        String key, lowerKey;
7004        int value, lowerValue;
7005
7006        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7007        descendingKeySet = keySet.descendingSet();
7008        iterator = descendingKeySet.iterator();
7009        while (iterator.hasNext()) {
7010            key = (String) iterator.next();
7011            value = Integer.valueOf(key);
7012            lowerKey = (String) descendingKeySet.lower(key);
7013            if (value < 108) {
7014                lowerValue = Integer.valueOf(lowerKey);
7015                assertEquals(value + 1, lowerValue);
7016            } else {
7017                assertNull(lowerKey);
7018            }
7019        }
7020
7021        key = new Integer(0).toString();
7022        lowerKey = (String) descendingKeySet.lower(key);
7023        assertEquals(101, Integer.parseInt(lowerKey));
7024
7025        key = new Integer(2).toString();
7026        lowerKey = (String) descendingKeySet.lower(key);
7027        assertNull(lowerKey);
7028
7029        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7030        descendingKeySet = keySet.descendingSet();
7031        iterator = descendingKeySet.iterator();
7032        while (iterator.hasNext()) {
7033            key = (String) iterator.next();
7034            value = Integer.valueOf(key);
7035            lowerKey = (String) descendingKeySet.lower(key);
7036            if (value < 109) {
7037                lowerValue = Integer.valueOf(lowerKey);
7038                assertEquals(value + 1, lowerValue);
7039            } else {
7040                assertNull(lowerKey);
7041            }
7042        }
7043
7044        key = new Integer(0).toString();
7045        lowerKey = (String) descendingKeySet.lower(key);
7046        assertEquals(101, Integer.parseInt(lowerKey));
7047
7048        key = new Integer(2).toString();
7049        lowerKey = (String) descendingKeySet.lower(key);
7050        assertNull(lowerKey);
7051
7052        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7053        descendingKeySet = keySet.descendingSet();
7054        iterator = descendingKeySet.iterator();
7055        while (iterator.hasNext()) {
7056            key = (String) iterator.next();
7057            value = Integer.valueOf(key);
7058            lowerKey = (String) descendingKeySet.lower(key);
7059            if (value < 108) {
7060                lowerValue = Integer.valueOf(lowerKey);
7061                assertEquals(value + 1, lowerValue);
7062            } else {
7063                assertNull(lowerKey);
7064            }
7065        }
7066
7067        key = new Integer(0).toString();
7068        lowerKey = (String) descendingKeySet.lower(key);
7069        assertEquals(100, Integer.parseInt(lowerKey));
7070
7071        key = new Integer(2).toString();
7072        lowerKey = (String) descendingKeySet.lower(key);
7073        assertNull(lowerKey);
7074
7075        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7076        descendingKeySet = keySet.descendingSet();
7077        iterator = descendingKeySet.iterator();
7078        while (iterator.hasNext()) {
7079            key = (String) iterator.next();
7080            value = Integer.valueOf(key);
7081            lowerKey = (String) descendingKeySet.lower(key);
7082            if (value < 109) {
7083                lowerValue = Integer.valueOf(lowerKey);
7084                assertEquals(value + 1, lowerValue);
7085            } else {
7086                assertNull(lowerKey);
7087            }
7088        }
7089
7090        key = new Integer(0).toString();
7091        lowerKey = (String) descendingKeySet.lower(key);
7092        assertEquals(100, Integer.parseInt(lowerKey));
7093
7094        key = new Integer(2).toString();
7095        lowerKey = (String) descendingKeySet.lower(key);
7096        assertNull(lowerKey);
7097
7098        key = new Integer(2).toString();
7099        keySet = tm.headMap(key, true).navigableKeySet();
7100        descendingKeySet = keySet.descendingSet();
7101        iterator = descendingKeySet.iterator();
7102        iterator.next();
7103        iterator.next();
7104        key = (String) iterator.next();
7105        lowerKey = (String) descendingKeySet.lower(key);
7106        assertEquals(new Integer(199).toString(), lowerKey);
7107        try {
7108            descendingKeySet.lower(null);
7109            fail("should throw NPE");
7110        } catch (NullPointerException e) {
7111            // Expected
7112        }
7113
7114        key = new Integer(0).toString();
7115        String endKey = key;
7116
7117        keySet = tm.headMap(endKey, true).navigableKeySet();
7118        descendingKeySet = keySet.descendingSet();
7119        assertNull(descendingKeySet.lower(endKey));
7120
7121        key = new Integer(0).toString();
7122        keySet = tm.headMap(endKey, false).navigableKeySet();
7123        descendingKeySet = keySet.descendingSet();
7124        assertNull(descendingKeySet.lower(endKey));
7125
7126        endKey = new Integer(999).toString();
7127        keySet = tm.headMap(endKey, true).navigableKeySet();
7128        descendingKeySet = keySet.descendingSet();
7129        assertNull(descendingKeySet.lower(endKey));
7130        assertEquals(new Integer(1).toString(), descendingKeySet.lower(key));
7131
7132        endKey = new Integer(999).toString();
7133        keySet = tm.headMap(endKey, false).navigableKeySet();
7134        descendingKeySet = keySet.descendingSet();
7135        assertNull(descendingKeySet.lower(endKey));
7136        assertEquals(new Integer(1).toString(), descendingKeySet.lower(key));
7137
7138        // With Comparator
7139        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7140                .navigableKeySet();
7141        descendingKeySet = keySet.descendingSet();
7142        iterator = descendingKeySet.iterator();
7143        while (iterator.hasNext()) {
7144            key = (String) iterator.next();
7145            value = Integer.valueOf(key);
7146            lowerKey = (String) descendingKeySet.lower(key);
7147            if (value < 108) {
7148                lowerValue = Integer.valueOf(lowerKey);
7149                assertEquals(value + 1, lowerValue);
7150            } else {
7151                assertNull(lowerKey);
7152            }
7153        }
7154
7155        key = new Integer(0).toString();
7156        lowerKey = (String) descendingKeySet.lower(key);
7157        assertEquals(101, Integer.parseInt(lowerKey));
7158
7159        key = new Integer(2).toString();
7160        lowerKey = (String) descendingKeySet.lower(key);
7161        assertNull(lowerKey);
7162
7163        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
7164                .navigableKeySet();
7165        descendingKeySet = keySet.descendingSet();
7166        iterator = descendingKeySet.iterator();
7167        while (iterator.hasNext()) {
7168            key = (String) iterator.next();
7169            value = Integer.valueOf(key);
7170            lowerKey = (String) descendingKeySet.lower(key);
7171            if (value < 109) {
7172                lowerValue = Integer.valueOf(lowerKey);
7173                assertEquals(value + 1, lowerValue);
7174            } else {
7175                assertNull(lowerKey);
7176            }
7177        }
7178
7179        key = new Integer(0).toString();
7180        lowerKey = (String) descendingKeySet.lower(key);
7181        assertEquals(101, Integer.parseInt(lowerKey));
7182
7183        key = new Integer(2).toString();
7184        lowerKey = (String) descendingKeySet.lower(key);
7185        assertNull(lowerKey);
7186
7187        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
7188                .navigableKeySet();
7189        descendingKeySet = keySet.descendingSet();
7190        iterator = descendingKeySet.iterator();
7191        while (iterator.hasNext()) {
7192            key = (String) iterator.next();
7193            value = Integer.valueOf(key);
7194            lowerKey = (String) descendingKeySet.lower(key);
7195            if (value < 108) {
7196                lowerValue = Integer.valueOf(lowerKey);
7197                assertEquals(value + 1, lowerValue);
7198            } else {
7199                assertNull(lowerKey);
7200            }
7201        }
7202
7203        key = new Integer(0).toString();
7204        lowerKey = (String) descendingKeySet.lower(key);
7205        assertEquals(100, Integer.parseInt(lowerKey));
7206
7207        key = new Integer(2).toString();
7208        lowerKey = (String) descendingKeySet.lower(key);
7209        assertNull(lowerKey);
7210
7211        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
7212                .navigableKeySet();
7213        descendingKeySet = keySet.descendingSet();
7214        iterator = descendingKeySet.iterator();
7215        while (iterator.hasNext()) {
7216            key = (String) iterator.next();
7217            value = Integer.valueOf(key);
7218            lowerKey = (String) descendingKeySet.lower(key);
7219            if (value < 109) {
7220                lowerValue = Integer.valueOf(lowerKey);
7221                assertEquals(value + 1, lowerValue);
7222            } else {
7223                assertNull(lowerKey);
7224            }
7225        }
7226    }
7227
7228    public void test_DescendingSubMapKeySet_higher() {
7229        NavigableSet keySet, descendingKeySet;
7230        Iterator iterator;
7231        String key, higherKey;
7232        int value, higherValue;
7233
7234        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7235        descendingKeySet = keySet.descendingSet();
7236        iterator = descendingKeySet.iterator();
7237        while (iterator.hasNext()) {
7238            key = (String) iterator.next();
7239            value = Integer.valueOf(key);
7240            higherKey = (String) descendingKeySet.higher(key);
7241            if (value > 101) {
7242                higherValue = Integer.valueOf(higherKey);
7243                assertEquals(value - 1, higherValue);
7244            } else {
7245                assertNull(higherKey);
7246            }
7247        }
7248
7249        key = new Integer(99999).toString();
7250        higherKey = (String) descendingKeySet.higher(key);
7251        assertEquals("108", higherKey);
7252
7253        key = new Integer(-1).toString();
7254        higherKey = (String) descendingKeySet.higher(key);
7255        assertNull(higherKey);
7256
7257        key = new Integer(100).toString();
7258        higherKey = (String) descendingKeySet.higher(key);
7259        assertNull(higherKey);
7260
7261        key = new Integer(0).toString();
7262        higherKey = (String) descendingKeySet.higher(key);
7263        assertNull(higherKey);
7264
7265        key = new Integer(2).toString();
7266        higherKey = (String) descendingKeySet.higher(key);
7267        assertEquals(108, Integer.parseInt(higherKey));
7268
7269        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7270        descendingKeySet = keySet.descendingSet();
7271        iterator = descendingKeySet.iterator();
7272        while (iterator.hasNext()) {
7273            key = (String) iterator.next();
7274            value = Integer.valueOf(key);
7275            higherKey = (String) descendingKeySet.higher(key);
7276            if (value > 101) {
7277                higherValue = Integer.valueOf(higherKey);
7278                assertEquals(value - 1, higherValue);
7279            } else {
7280                assertNull(higherKey);
7281            }
7282        }
7283
7284        key = new Integer(99999).toString();
7285        higherKey = (String) descendingKeySet.higher(key);
7286        assertEquals("109", higherKey);
7287
7288        key = new Integer(-1).toString();
7289        higherKey = (String) descendingKeySet.higher(key);
7290        assertNull(higherKey);
7291
7292        key = new Integer(100).toString();
7293        higherKey = (String) descendingKeySet.higher(key);
7294        assertNull(higherKey);
7295
7296        key = new Integer(2).toString();
7297        higherKey = (String) descendingKeySet.higher(key);
7298        assertEquals(109, Integer.parseInt(higherKey));
7299
7300        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7301        descendingKeySet = keySet.descendingSet();
7302        iterator = descendingKeySet.iterator();
7303        while (iterator.hasNext()) {
7304            key = (String) iterator.next();
7305            value = Integer.valueOf(key);
7306            higherKey = (String) descendingKeySet.higher(key);
7307            if (value > 100) {
7308                higherValue = Integer.valueOf(higherKey);
7309                assertEquals(value - 1, higherValue);
7310            } else {
7311                assertNull(higherKey);
7312            }
7313        }
7314
7315        key = new Integer(99999).toString();
7316        higherKey = (String) descendingKeySet.higher(key);
7317        assertEquals("108", higherKey);
7318
7319        key = new Integer(-1).toString();
7320        higherKey = (String) descendingKeySet.higher(key);
7321        assertNull(higherKey);
7322
7323        key = new Integer(100).toString();
7324        higherKey = (String) descendingKeySet.higher(key);
7325        assertNull(higherKey);
7326
7327        key = new Integer(2).toString();
7328        higherKey = (String) descendingKeySet.higher(key);
7329        assertEquals(108, Integer.parseInt(higherKey));
7330
7331        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7332        descendingKeySet = keySet.descendingSet();
7333        iterator = descendingKeySet.iterator();
7334        while (iterator.hasNext()) {
7335            key = (String) iterator.next();
7336            value = Integer.valueOf(key);
7337            higherKey = (String) descendingKeySet.higher(key);
7338            if (value > 100) {
7339                higherValue = Integer.valueOf(higherKey);
7340                assertEquals(value - 1, higherValue);
7341            } else {
7342                assertNull(higherKey);
7343            }
7344        }
7345
7346        key = new Integer(99999).toString();
7347        higherKey = (String) descendingKeySet.higher(key);
7348        assertEquals("109", higherKey);
7349
7350        key = new Integer(-1).toString();
7351        higherKey = (String) descendingKeySet.higher(key);
7352        assertNull(higherKey);
7353
7354        key = new Integer(100).toString();
7355        higherKey = (String) descendingKeySet.higher(key);
7356        assertNull(higherKey);
7357
7358        key = new Integer(2).toString();
7359        higherKey = (String) descendingKeySet.higher(key);
7360        assertEquals(109, Integer.parseInt(higherKey));
7361
7362        key = new Integer(2).toString();
7363        keySet = tm.headMap(key, true).navigableKeySet();
7364        descendingKeySet = keySet.descendingSet();
7365        iterator = descendingKeySet.iterator();
7366        key = (String) iterator.next();
7367        higherKey = (String) descendingKeySet.higher(key);
7368        assertEquals(new Integer(199).toString(), higherKey);
7369        try {
7370            descendingKeySet.higher(null);
7371            fail("should throw NPE");
7372        } catch (NullPointerException e) {
7373            // Expected
7374        }
7375
7376        key = new Integer(0).toString();
7377        String endKey = key;
7378
7379        keySet = tm.headMap(endKey, true).navigableKeySet();
7380        descendingKeySet = keySet.descendingSet();
7381        assertNull(descendingKeySet.higher(endKey));
7382
7383        key = new Integer(0).toString();
7384        keySet = tm.headMap(endKey, false).navigableKeySet();
7385        descendingKeySet = keySet.descendingSet();
7386        assertNull(descendingKeySet.higher(endKey));
7387
7388        endKey = new Integer(999).toString();
7389        keySet = tm.headMap(endKey, true).navigableKeySet();
7390        descendingKeySet = keySet.descendingSet();
7391        assertEquals(new Integer(998).toString(), descendingKeySet
7392                .higher(endKey));
7393        assertNull(descendingKeySet.higher(key));
7394
7395        endKey = new Integer(999).toString();
7396        keySet = tm.headMap(endKey, false).navigableKeySet();
7397        descendingKeySet = keySet.descendingSet();
7398        assertEquals(new Integer(998).toString(), descendingKeySet
7399                .higher(endKey));
7400        assertNull(descendingKeySet.higher(key));
7401
7402        // With Comparator
7403        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7404                .navigableKeySet();
7405        descendingKeySet = keySet.descendingSet();
7406        iterator = descendingKeySet.iterator();
7407        while (iterator.hasNext()) {
7408            key = (String) iterator.next();
7409            value = Integer.valueOf(key);
7410            higherKey = (String) descendingKeySet.higher(key);
7411            if (value > 101) {
7412                higherValue = Integer.valueOf(higherKey);
7413                assertEquals(value - 1, higherValue);
7414            } else {
7415                assertNull(higherKey);
7416            }
7417        }
7418
7419        key = new Integer(99999).toString();
7420        higherKey = (String) descendingKeySet.higher(key);
7421        assertEquals("108", higherKey);
7422
7423        key = new Integer(-1).toString();
7424        higherKey = (String) descendingKeySet.higher(key);
7425        assertNull(higherKey);
7426
7427        key = new Integer(100).toString();
7428        higherKey = (String) descendingKeySet.higher(key);
7429        assertNull(higherKey);
7430
7431        key = new Integer(0).toString();
7432        higherKey = (String) descendingKeySet.higher(key);
7433        assertNull(higherKey);
7434
7435        key = new Integer(2).toString();
7436        higherKey = (String) descendingKeySet.higher(key);
7437        assertEquals(108, Integer.parseInt(higherKey));
7438
7439        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_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("109", 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(2).toString();
7468        higherKey = (String) descendingKeySet.higher(key);
7469        assertEquals(109, Integer.parseInt(higherKey));
7470
7471        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
7472                .navigableKeySet();
7473        descendingKeySet = keySet.descendingSet();
7474        iterator = descendingKeySet.iterator();
7475        while (iterator.hasNext()) {
7476            key = (String) iterator.next();
7477            value = Integer.valueOf(key);
7478            higherKey = (String) descendingKeySet.higher(key);
7479            if (value > 100) {
7480                higherValue = Integer.valueOf(higherKey);
7481                assertEquals(value - 1, higherValue);
7482            } else {
7483                assertNull(higherKey);
7484            }
7485        }
7486
7487        key = new Integer(99999).toString();
7488        higherKey = (String) descendingKeySet.higher(key);
7489        assertEquals("108", higherKey);
7490
7491        key = new Integer(-1).toString();
7492        higherKey = (String) descendingKeySet.higher(key);
7493        assertNull(higherKey);
7494
7495        key = new Integer(100).toString();
7496        higherKey = (String) descendingKeySet.higher(key);
7497        assertNull(higherKey);
7498
7499        key = new Integer(2).toString();
7500        higherKey = (String) descendingKeySet.higher(key);
7501        assertEquals(108, Integer.parseInt(higherKey));
7502
7503        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
7504                .navigableKeySet();
7505        descendingKeySet = keySet.descendingSet();
7506        iterator = descendingKeySet.iterator();
7507        while (iterator.hasNext()) {
7508            key = (String) iterator.next();
7509            value = Integer.valueOf(key);
7510            higherKey = (String) descendingKeySet.higher(key);
7511            if (value > 100) {
7512                higherValue = Integer.valueOf(higherKey);
7513                assertEquals(value - 1, higherValue);
7514            } else {
7515                assertNull(higherKey);
7516            }
7517        }
7518
7519        key = new Integer(99999).toString();
7520        higherKey = (String) descendingKeySet.higher(key);
7521        assertEquals("109", higherKey);
7522
7523        key = new Integer(-1).toString();
7524        higherKey = (String) descendingKeySet.higher(key);
7525        assertNull(higherKey);
7526
7527        key = new Integer(100).toString();
7528        higherKey = (String) descendingKeySet.higher(key);
7529        assertNull(higherKey);
7530
7531        key = new Integer(2).toString();
7532        higherKey = (String) descendingKeySet.higher(key);
7533        assertEquals(109, Integer.parseInt(higherKey));
7534
7535        key = new Integer(2).toString();
7536        keySet = tm.headMap(key, true).navigableKeySet();
7537        descendingKeySet = keySet.descendingSet();
7538        iterator = descendingKeySet.iterator();
7539        key = (String) iterator.next();
7540        higherKey = (String) descendingKeySet.higher(key);
7541        assertEquals(new Integer(199).toString(), higherKey);
7542        try {
7543            descendingKeySet.higher(null);
7544            fail("should throw NPE");
7545        } catch (NullPointerException e) {
7546            // Expected
7547        }
7548
7549        key = new Integer(0).toString();
7550        endKey = key;
7551
7552        keySet = tm.headMap(endKey, true).navigableKeySet();
7553        descendingKeySet = keySet.descendingSet();
7554        assertNull(descendingKeySet.higher(endKey));
7555
7556        key = new Integer(0).toString();
7557        keySet = tm.headMap(endKey, false).navigableKeySet();
7558        descendingKeySet = keySet.descendingSet();
7559        assertNull(descendingKeySet.higher(endKey));
7560
7561        endKey = new Integer(999).toString();
7562        keySet = tm.headMap(endKey, true).navigableKeySet();
7563        descendingKeySet = keySet.descendingSet();
7564        assertEquals(new Integer(998).toString(), descendingKeySet
7565                .higher(endKey));
7566        assertNull(descendingKeySet.higher(key));
7567
7568        endKey = new Integer(999).toString();
7569        keySet = tm.headMap(endKey, false).navigableKeySet();
7570        descendingKeySet = keySet.descendingSet();
7571        assertEquals(new Integer(998).toString(), descendingKeySet
7572                .higher(endKey));
7573        assertNull(descendingKeySet.higher(key));
7574    }
7575
7576    public void test_DescendingSubMapKeySet_ceiling() {
7577        NavigableSet keySet, descendingKeySet;
7578        String[] keyArray;
7579        String key, ceilingKey;
7580
7581        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7582        descendingKeySet = keySet.descendingSet();
7583        keyArray = (String[]) descendingKeySet
7584                .toArray(new String[descendingKeySet.size()]);
7585        for (int i = 0, j = 108; i < keyArray.length; i++) {
7586            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7587            assertEquals(new Integer(j - i).toString(), ceilingKey);
7588        }
7589
7590        key = new Integer(2).toString();
7591        ceilingKey = (String) descendingKeySet.ceiling(key);
7592        assertEquals(108, Integer.parseInt(ceilingKey));
7593
7594        key = new Integer(0).toString();
7595        ceilingKey = (String) descendingKeySet.ceiling(key);
7596        assertNull(ceilingKey);
7597
7598        key = new Integer(-1).toString();
7599        ceilingKey = (String) descendingKeySet.ceiling(key);
7600        assertNull(ceilingKey);
7601
7602        key = new Integer(99999).toString();
7603        ceilingKey = (String) descendingKeySet.ceiling(key);
7604        assertEquals(108, Integer.parseInt(ceilingKey));
7605
7606        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7607        descendingKeySet = keySet.descendingSet();
7608        keyArray = (String[]) descendingKeySet
7609                .toArray(new String[descendingKeySet.size()]);
7610        for (int i = 0, j = 109; i < keyArray.length; i++) {
7611            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7612            assertEquals(new Integer(j - i).toString(), ceilingKey);
7613        }
7614
7615        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7616        descendingKeySet = keySet.descendingSet();
7617        keyArray = (String[]) descendingKeySet
7618                .toArray(new String[descendingKeySet.size()]);
7619        for (int i = 0, j = 108; i < keyArray.length; i++) {
7620            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7621            assertEquals(new Integer(j - i).toString(), ceilingKey);
7622        }
7623
7624        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7625        descendingKeySet = keySet.descendingSet();
7626        keyArray = (String[]) descendingKeySet
7627                .toArray(new String[descendingKeySet.size()]);
7628        for (int i = 0, j = 109; i < keyArray.length; i++) {
7629            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7630            assertEquals(new Integer(j - i).toString(), ceilingKey);
7631        }
7632
7633        key = new Integer(2).toString();
7634        keySet = tm.headMap(key, true).navigableKeySet();
7635        descendingKeySet = keySet.descendingSet();
7636        Iterator iterator = descendingKeySet.iterator();
7637        assertEquals(key, descendingKeySet.ceiling(iterator.next()));
7638        try {
7639            descendingKeySet.ceiling(null);
7640            fail("should throw NPE");
7641        } catch (NullPointerException e) {
7642            // Expected
7643        }
7644
7645        key = new Integer(0).toString();
7646        String endKey = key;
7647
7648        keySet = tm.headMap(endKey, true).navigableKeySet();
7649        descendingKeySet = keySet.descendingSet();
7650        assertEquals(key, descendingKeySet.ceiling(endKey));
7651
7652        key = new Integer(0).toString();
7653        keySet = tm.headMap(endKey, false).navigableKeySet();
7654        descendingKeySet = keySet.descendingSet();
7655        assertNull(descendingKeySet.ceiling(endKey));
7656
7657        endKey = new Integer(999).toString();
7658        keySet = tm.headMap(endKey, true).navigableKeySet();
7659        descendingKeySet = keySet.descendingSet();
7660        assertEquals(new Integer(999).toString(), descendingKeySet
7661                .ceiling(endKey));
7662        assertEquals(key, descendingKeySet.ceiling(key));
7663
7664        endKey = new Integer(999).toString();
7665        keySet = tm.headMap(endKey, false).navigableKeySet();
7666        descendingKeySet = keySet.descendingSet();
7667        assertEquals(new Integer(998).toString(), descendingKeySet
7668                .ceiling(endKey));
7669        assertEquals(key, descendingKeySet.ceiling(key));
7670
7671        // With Comparator
7672        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7673                .navigableKeySet();
7674        descendingKeySet = keySet.descendingSet();
7675        keyArray = (String[]) descendingKeySet
7676                .toArray(new String[descendingKeySet.size()]);
7677        for (int i = 0, j = 108; i < keyArray.length; i++) {
7678            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7679            assertEquals(new Integer(j - i).toString(), ceilingKey);
7680        }
7681
7682        key = new Integer(2).toString();
7683        ceilingKey = (String) descendingKeySet.ceiling(key);
7684        assertEquals(108, Integer.parseInt(ceilingKey));
7685
7686        key = new Integer(0).toString();
7687        ceilingKey = (String) descendingKeySet.ceiling(key);
7688        assertNull(ceilingKey);
7689
7690        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
7691                .navigableKeySet();
7692        descendingKeySet = keySet.descendingSet();
7693        keyArray = (String[]) descendingKeySet
7694                .toArray(new String[descendingKeySet.size()]);
7695        for (int i = 0, j = 109; i < keyArray.length; i++) {
7696            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7697            assertEquals(new Integer(j - i).toString(), ceilingKey);
7698        }
7699
7700        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
7701                .navigableKeySet();
7702        descendingKeySet = keySet.descendingSet();
7703        keyArray = (String[]) descendingKeySet
7704                .toArray(new String[descendingKeySet.size()]);
7705        for (int i = 0, j = 108; i < keyArray.length; i++) {
7706            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7707            assertEquals(new Integer(j - i).toString(), ceilingKey);
7708        }
7709
7710        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
7711                .navigableKeySet();
7712        descendingKeySet = keySet.descendingSet();
7713        keyArray = (String[]) descendingKeySet
7714                .toArray(new String[descendingKeySet.size()]);
7715        for (int i = 0, j = 109; i < keyArray.length; i++) {
7716            ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]);
7717            assertEquals(new Integer(j - i).toString(), ceilingKey);
7718        }
7719    }
7720
7721    public void test_DescendingSubMapKeySet_floor() {
7722        NavigableSet keySet, descendingKeySet;
7723        String[] keyArray;
7724        String floorKey;
7725
7726        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7727        descendingKeySet = keySet.descendingSet();
7728        keyArray = (String[]) descendingKeySet
7729                .toArray(new String[descendingKeySet.size()]);
7730        for (int i = 0, j = 108; i < keyArray.length; i++) {
7731            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7732            assertEquals(new Integer(j - i).toString(), floorKey);
7733        }
7734
7735        String key = new Integer(0).toString();
7736        floorKey = (String) descendingKeySet.floor(key);
7737        assertEquals(101, Integer.parseInt(floorKey));
7738
7739        key = new Integer(2).toString();
7740        floorKey = (String) descendingKeySet.floor(key);
7741        assertNull(floorKey);
7742
7743        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7744        descendingKeySet = keySet.descendingSet();
7745        keyArray = (String[]) descendingKeySet
7746                .toArray(new String[descendingKeySet.size()]);
7747        for (int i = 0, j = 109; i < keyArray.length; i++) {
7748            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7749            assertEquals(new Integer(j - i).toString(), floorKey);
7750        }
7751
7752        key = new Integer(0).toString();
7753        floorKey = (String) descendingKeySet.floor(key);
7754        assertEquals(101, Integer.parseInt(floorKey));
7755
7756        key = new Integer(2).toString();
7757        floorKey = (String) descendingKeySet.floor(key);
7758        assertNull(floorKey);
7759
7760        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7761        descendingKeySet = keySet.descendingSet();
7762        keyArray = (String[]) descendingKeySet
7763                .toArray(new String[descendingKeySet.size()]);
7764        for (int i = 0, j = 108; i < keyArray.length; i++) {
7765            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7766            assertEquals(new Integer(j - i).toString(), floorKey);
7767        }
7768
7769        key = new Integer(0).toString();
7770        floorKey = (String) descendingKeySet.floor(key);
7771        assertEquals(100, Integer.parseInt(floorKey));
7772
7773        key = new Integer(2).toString();
7774        floorKey = (String) descendingKeySet.floor(key);
7775        assertNull(floorKey);
7776
7777        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7778        descendingKeySet = keySet.descendingSet();
7779        keyArray = (String[]) descendingKeySet
7780                .toArray(new String[descendingKeySet.size()]);
7781        for (int i = 0, j = 109; i < keyArray.length; i++) {
7782            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7783            assertEquals(new Integer(j - i).toString(), floorKey);
7784        }
7785
7786        key = new Integer(0).toString();
7787        floorKey = (String) descendingKeySet.floor(key);
7788        assertEquals(100, Integer.parseInt(floorKey));
7789
7790        key = new Integer(2).toString();
7791        floorKey = (String) descendingKeySet.floor(key);
7792        assertNull(floorKey);
7793
7794        key = new Integer(2).toString();
7795        keySet = tm.headMap(key, true).navigableKeySet();
7796        descendingKeySet = keySet.descendingSet();
7797        Iterator iterator = descendingKeySet.iterator();
7798        assertEquals(key, descendingKeySet.floor(iterator.next()));
7799        try {
7800            descendingKeySet.floor(null);
7801            fail("should throw NPE");
7802        } catch (NullPointerException e) {
7803            // Expected
7804        }
7805
7806        key = new Integer(0).toString();
7807        String endKey = key;
7808
7809        keySet = tm.headMap(endKey, true).navigableKeySet();
7810        descendingKeySet = keySet.descendingSet();
7811        assertEquals(key, descendingKeySet.floor(endKey));
7812
7813        key = new Integer(0).toString();
7814        keySet = tm.headMap(endKey, false).navigableKeySet();
7815        descendingKeySet = keySet.descendingSet();
7816        assertNull(descendingKeySet.floor(endKey));
7817
7818        endKey = new Integer(999).toString();
7819        keySet = tm.headMap(endKey, true).navigableKeySet();
7820        descendingKeySet = keySet.descendingSet();
7821        assertEquals(new Integer(999).toString(), descendingKeySet
7822                .floor(endKey));
7823        assertEquals(key, descendingKeySet.floor(key));
7824
7825        endKey = new Integer(999).toString();
7826        keySet = tm.headMap(endKey, false).navigableKeySet();
7827        descendingKeySet = keySet.descendingSet();
7828        assertNull(descendingKeySet.floor(endKey));
7829        assertEquals(key, descendingKeySet.floor(key));
7830
7831        // With Comparator
7832        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
7833                .navigableKeySet();
7834        descendingKeySet = keySet.descendingSet();
7835        keyArray = (String[]) descendingKeySet
7836                .toArray(new String[descendingKeySet.size()]);
7837        for (int i = 0, j = 108; i < keyArray.length; i++) {
7838            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7839            assertEquals(new Integer(j - i).toString(), floorKey);
7840        }
7841
7842        key = new Integer(0).toString();
7843        floorKey = (String) descendingKeySet.floor(key);
7844        assertEquals(101, Integer.parseInt(floorKey));
7845
7846        key = new Integer(2).toString();
7847        floorKey = (String) descendingKeySet.floor(key);
7848        assertNull(floorKey);
7849
7850        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
7851                .navigableKeySet();
7852        descendingKeySet = keySet.descendingSet();
7853        keyArray = (String[]) descendingKeySet
7854                .toArray(new String[descendingKeySet.size()]);
7855        for (int i = 0, j = 109; i < keyArray.length; i++) {
7856            floorKey = (String) descendingKeySet.floor(keyArray[i]);
7857            assertEquals(new Integer(j - i).toString(), floorKey);
7858        }
7859
7860        key = new Integer(0).toString();
7861        floorKey = (String) descendingKeySet.floor(key);
7862        assertEquals(101, Integer.parseInt(floorKey));
7863
7864        key = new Integer(2).toString();
7865        floorKey = (String) descendingKeySet.floor(key);
7866        assertNull(floorKey);
7867
7868        keySet = ((NavigableMap) subMap_startIncluded_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(100, Integer.parseInt(floorKey));
7881
7882        key = new Integer(2).toString();
7883        floorKey = (String) descendingKeySet.floor(key);
7884        assertNull(floorKey);
7885
7886        keySet = ((NavigableMap) subMap_startIncluded_endIncluded)
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(100, Integer.parseInt(floorKey));
7899
7900        key = new Integer(2).toString();
7901        floorKey = (String) descendingKeySet.floor(key);
7902        assertNull(floorKey);
7903    }
7904
7905    public void test_AscendingSubMapKeySet_last() {
7906        NavigableSet keySet;
7907        String firstKey1 = new Integer(108).toString();
7908        String firstKey2 = new Integer(109).toString();
7909
7910        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7911        assertEquals(firstKey1, keySet.last());
7912
7913        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7914        assertEquals(firstKey2, keySet.last());
7915
7916        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7917        assertEquals(firstKey1, keySet.last());
7918
7919        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7920        assertEquals(firstKey2, keySet.last());
7921    }
7922
7923    public void test_AscendingSubMapKeySet_comparator() {
7924        NavigableSet keySet;
7925        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
7926        assertNull(keySet.comparator());
7927
7928        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
7929        assertNull(keySet.comparator());
7930
7931        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
7932        assertNull(keySet.comparator());
7933
7934        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
7935        assertNull(keySet.comparator());
7936
7937        String endKey = new Integer(2).toString();
7938        keySet = tm.headMap(endKey, true).navigableKeySet();
7939        assertNull(keySet.comparator());
7940    }
7941
7942    public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endExcluded() {
7943        NavigableSet keySet = navigableMap_startExcluded_endExcluded
7944                .navigableKeySet();
7945        Iterator iterator = keySet.iterator();
7946        assertEquals(8, keySet.size());
7947        for (int value = 101; value < 109; value++) {
7948            assertEquals(new Integer(value).toString(), keySet.pollFirst());
7949        }
7950        assertEquals(0, keySet.size());
7951        assertNull(keySet.pollFirst());
7952    }
7953
7954    public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endIncluded() {
7955        NavigableSet keySet = navigableMap_startExcluded_endIncluded
7956                .navigableKeySet();
7957        Iterator iterator = keySet.iterator();
7958        assertEquals(9, keySet.size());
7959        for (int value = 101; value < 110; value++) {
7960            assertEquals(new Integer(value).toString(), keySet.pollFirst());
7961        }
7962        assertEquals(0, keySet.size());
7963        assertNull(keySet.pollFirst());
7964    }
7965
7966    public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endExcluded() {
7967        NavigableSet keySet = navigableMap_startIncluded_endExcluded
7968                .navigableKeySet();
7969        Iterator iterator = keySet.iterator();
7970        assertEquals(9, keySet.size());
7971        for (int value = 100; value < 109; value++) {
7972            assertEquals(new Integer(value).toString(), keySet.pollFirst());
7973        }
7974        assertEquals(0, keySet.size());
7975        assertNull(keySet.pollFirst());
7976    }
7977
7978    public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endIncluded() {
7979        NavigableSet keySet = navigableMap_startIncluded_endIncluded
7980                .navigableKeySet();
7981        Iterator iterator = keySet.iterator();
7982        assertEquals(10, keySet.size());
7983        for (int value = 100; value < 110; 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() {
7991        String endKey = new Integer(2).toString();
7992        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
7993        assertEquals(new Integer(0).toString(), keySet.pollFirst());
7994
7995        keySet = tm.tailMap(endKey, true).navigableKeySet();
7996        assertEquals(new Integer(2).toString(), keySet.pollFirst());
7997    }
7998
7999    public void test_AscendingSubMapKeySet_pollLast_startExcluded_endExcluded() {
8000        NavigableSet keySet = navigableMap_startExcluded_endExcluded
8001                .navigableKeySet();
8002        Iterator iterator = keySet.iterator();
8003        assertEquals(8, keySet.size());
8004        for (int value = 108; value > 100; value--) {
8005            assertEquals(new Integer(value).toString(), keySet.pollLast());
8006        }
8007        assertEquals(0, keySet.size());
8008        assertNull(keySet.pollLast());
8009    }
8010
8011    public void test_AscendingSubMapKeySet_pollLast_startExcluded_endIncluded() {
8012        NavigableSet keySet = navigableMap_startExcluded_endIncluded
8013                .navigableKeySet();
8014        Iterator iterator = keySet.iterator();
8015        assertEquals(9, keySet.size());
8016        for (int value = 109; value > 100; value--) {
8017            assertEquals(new Integer(value).toString(), keySet.pollLast());
8018        }
8019        assertEquals(0, keySet.size());
8020        assertNull(keySet.pollLast());
8021    }
8022
8023    public void test_AscendingSubMapKeySet_pollLast_startIncluded_endExcluded() {
8024        NavigableSet keySet = navigableMap_startIncluded_endExcluded
8025                .navigableKeySet();
8026        Iterator iterator = keySet.iterator();
8027        assertEquals(9, keySet.size());
8028        for (int value = 108; value > 99; value--) {
8029            assertEquals(new Integer(value).toString(), keySet.pollLast());
8030        }
8031        assertEquals(0, keySet.size());
8032        assertNull(keySet.pollLast());
8033    }
8034
8035    public void test_AscendingSubMapKeySet_pollLast_startIncluded_endIncluded() {
8036        NavigableSet keySet = navigableMap_startIncluded_endIncluded
8037                .navigableKeySet();
8038        Iterator iterator = keySet.iterator();
8039        assertEquals(10, keySet.size());
8040        for (int value = 109; value > 99; 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() {
8048        String endKey = new Integer(2).toString();
8049        NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet();
8050        assertEquals(new Integer(2).toString(), keySet.pollLast());
8051
8052        keySet = tm.tailMap(endKey, true).navigableKeySet();
8053        assertEquals(new Integer(999).toString(), keySet.pollLast());
8054    }
8055
8056    public void test_AscendingSubMapKeySet_descendingIterator() {
8057        NavigableSet keySet;
8058        Iterator iterator;
8059
8060        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
8061        iterator = keySet.descendingIterator();
8062        for (int value = 108; value > 100; value--) {
8063            assertTrue(iterator.hasNext());
8064            assertEquals(new Integer(value).toString(), iterator.next());
8065        }
8066        assertFalse(iterator.hasNext());
8067        try {
8068            iterator.next();
8069            fail("should throw NoSuchElementException");
8070        } catch (NoSuchElementException e) {
8071            // Expected
8072        }
8073
8074        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
8075        iterator = keySet.descendingIterator();
8076        for (int value = 109; value > 100; value--) {
8077            assertTrue(iterator.hasNext());
8078            assertEquals(new Integer(value).toString(), iterator.next());
8079        }
8080        assertFalse(iterator.hasNext());
8081        try {
8082            iterator.next();
8083            fail("should throw NoSuchElementException");
8084        } catch (NoSuchElementException e) {
8085            // Expected
8086        }
8087
8088        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
8089        iterator = keySet.descendingIterator();
8090        for (int value = 108; value > 99; value--) {
8091            assertTrue(iterator.hasNext());
8092            assertEquals(new Integer(value).toString(), iterator.next());
8093        }
8094        assertFalse(iterator.hasNext());
8095        try {
8096            iterator.next();
8097            fail("should throw NoSuchElementException");
8098        } catch (NoSuchElementException e) {
8099            // Expected
8100        }
8101
8102        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
8103        iterator = keySet.descendingIterator();
8104        for (int value = 109; value > 99; value--) {
8105            assertTrue(iterator.hasNext());
8106            assertEquals(new Integer(value).toString(), iterator.next());
8107        }
8108        assertFalse(iterator.hasNext());
8109        try {
8110            iterator.next();
8111            fail("should throw NoSuchElementException");
8112        } catch (NoSuchElementException e) {
8113            // Expected
8114        }
8115
8116        String endKey = new Integer(2).toString();
8117        keySet = tm.headMap(endKey, true).navigableKeySet();
8118        iterator = keySet.descendingIterator();
8119        assertEquals(new Integer(2).toString(), iterator.next());
8120        assertEquals(new Integer(199).toString(), iterator.next());
8121    }
8122
8123    public void test_AscendingSubMapKeySet_descendingSet() {
8124        NavigableSet keySet, descendingSet;
8125        Iterator iterator;
8126
8127        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet()
8128                .descendingSet();
8129        descendingSet = keySet.descendingSet();
8130        iterator = descendingSet.iterator();
8131        for (int value = 101; value < 109; value++) {
8132            assertTrue(iterator.hasNext());
8133            assertEquals(new Integer(value).toString(), iterator.next());
8134        }
8135        assertFalse(iterator.hasNext());
8136        try {
8137            iterator.next();
8138            fail("should throw NoSuchElementException");
8139        } catch (NoSuchElementException e) {
8140            // Expected
8141        }
8142
8143        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet()
8144                .descendingSet();
8145        descendingSet = keySet.descendingSet();
8146        iterator = descendingSet.iterator();
8147        for (int value = 101; value < 110; value++) {
8148            assertTrue(iterator.hasNext());
8149            assertEquals(new Integer(value).toString(), iterator.next());
8150        }
8151        assertFalse(iterator.hasNext());
8152        try {
8153            iterator.next();
8154            fail("should throw NoSuchElementException");
8155        } catch (NoSuchElementException e) {
8156            // Expected
8157        }
8158
8159        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet()
8160                .descendingSet();
8161        descendingSet = keySet.descendingSet();
8162        iterator = descendingSet.iterator();
8163        for (int value = 100; value < 109; value++) {
8164            assertTrue(iterator.hasNext());
8165            assertEquals(new Integer(value).toString(), iterator.next());
8166        }
8167        assertFalse(iterator.hasNext());
8168        try {
8169            iterator.next();
8170            fail("should throw NoSuchElementException");
8171        } catch (NoSuchElementException e) {
8172            // Expected
8173        }
8174
8175        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet()
8176                .descendingSet();
8177        descendingSet = keySet.descendingSet();
8178        iterator = descendingSet.iterator();
8179        for (int value = 100; value < 110; value++) {
8180            assertTrue(iterator.hasNext());
8181            assertEquals(new Integer(value).toString(), iterator.next());
8182        }
8183        assertFalse(iterator.hasNext());
8184        try {
8185            iterator.next();
8186            fail("should throw NoSuchElementException");
8187        } catch (NoSuchElementException e) {
8188            // Expected
8189        }
8190
8191        String endKey = new Integer(1).toString();
8192        keySet = tm.headMap(endKey, true).navigableKeySet();
8193        descendingSet = keySet.descendingSet();
8194        iterator = descendingSet.iterator();
8195        assertEquals(new Integer(1).toString(), iterator.next());
8196        assertEquals(new Integer(0).toString(), iterator.next());
8197    }
8198
8199    public void test_AscendingSubMapKeySet_headSet() {
8200        NavigableSet keySet;
8201        SortedSet headSet;
8202        String endKey, key;
8203        Iterator iterator;
8204
8205        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
8206        endKey = new Integer(99).toString();
8207        try {
8208            keySet.headSet(endKey);
8209            fail("should throw IllegalArgumentException");
8210        } catch (IllegalArgumentException e) {
8211            // Expected
8212        }
8213        try {
8214            keySet.headSet(endKey, false);
8215            fail("should throw IllegalArgumentException");
8216        } catch (IllegalArgumentException e) {
8217            // Expected
8218        }
8219        try {
8220            keySet.headSet(endKey, true);
8221            fail("should throw IllegalArgumentException");
8222        } catch (IllegalArgumentException e) {
8223            // Expected
8224        }
8225
8226        endKey = new Integer(100).toString();
8227        assertEquals(0, keySet.headSet(endKey).size());
8228        assertEquals(0, keySet.headSet(endKey, false).size());
8229        try {
8230            keySet.headSet(endKey, true).size();
8231            fail("should throw IllegalArgumentException");
8232        } catch (IllegalArgumentException e) {
8233            // Expected
8234        }
8235
8236        endKey = new Integer(101).toString();
8237        assertEquals(0, keySet.headSet(endKey).size());
8238        assertEquals(0, keySet.headSet(endKey, false).size());
8239        assertEquals(1, keySet.headSet(endKey, true).size());
8240
8241        for (int i = 102; i < 109; i++) {
8242            endKey = new Integer(i).toString();
8243            headSet = keySet.headSet(endKey);
8244            iterator = headSet.iterator();
8245            int j;
8246            for (j = 101; iterator.hasNext(); j++) {
8247                key = (String) iterator.next();
8248                assertEquals(new Integer(j).toString(), key);
8249            }
8250            assertEquals(i, j);
8251
8252            headSet = keySet.headSet(endKey, false);
8253            iterator = headSet.iterator();
8254            for (j = 101; iterator.hasNext(); j++) {
8255                key = (String) iterator.next();
8256                assertEquals(new Integer(j).toString(), key);
8257            }
8258            assertEquals(i, j);
8259
8260            headSet = keySet.headSet(endKey, true);
8261            iterator = headSet.iterator();
8262            for (j = 101; iterator.hasNext(); j++) {
8263                key = (String) iterator.next();
8264                assertEquals(new Integer(j).toString(), key);
8265            }
8266            assertEquals(i + 1, j);
8267        }
8268
8269        endKey = new Integer(109).toString();
8270        headSet = keySet.headSet(endKey);
8271        iterator = headSet.iterator();
8272        int index;
8273        for (index = 101; iterator.hasNext(); index++) {
8274            key = (String) iterator.next();
8275            assertEquals(new Integer(index).toString(), key);
8276        }
8277        assertEquals(109, index);
8278
8279        headSet = keySet.headSet(endKey, false);
8280        iterator = headSet.iterator();
8281        for (index = 101; iterator.hasNext(); index++) {
8282            key = (String) iterator.next();
8283            assertEquals(new Integer(index).toString(), key);
8284        }
8285        assertEquals(109, index);
8286
8287        try {
8288            keySet.headSet(endKey, true);
8289            fail("should throw IllegalArgumentException");
8290        } catch (IllegalArgumentException e) {
8291            // Expected
8292        }
8293
8294        endKey = new Integer(110).toString();
8295        try {
8296            keySet.headSet(endKey);
8297            fail("should throw IllegalArgumentException");
8298        } catch (IllegalArgumentException e) {
8299            // Expected
8300        }
8301        try {
8302            keySet.headSet(endKey, true);
8303            fail("should throw IllegalArgumentException");
8304        } catch (IllegalArgumentException e) {
8305            // Expected
8306        }
8307        try {
8308            keySet.headSet(endKey, false);
8309            fail("should throw IllegalArgumentException");
8310        } catch (IllegalArgumentException e) {
8311            // Expected
8312        }
8313
8314        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
8315        endKey = new Integer(99).toString();
8316        try {
8317            keySet.headSet(endKey);
8318            fail("should throw IllegalArgumentException");
8319        } catch (IllegalArgumentException e) {
8320            // Expected
8321        }
8322        try {
8323            keySet.headSet(endKey, true);
8324            fail("should throw IllegalArgumentException");
8325        } catch (IllegalArgumentException e) {
8326            // Expected
8327        }
8328        try {
8329            keySet.headSet(endKey, false);
8330            fail("should throw IllegalArgumentException");
8331        } catch (IllegalArgumentException e) {
8332            // Expected
8333        }
8334
8335        endKey = new Integer(100).toString();
8336        assertEquals(0, keySet.headSet(endKey).size());
8337        assertEquals(0, keySet.headSet(endKey, false).size());
8338        try {
8339            keySet.headSet(endKey, true);
8340            fail("should throw IllegalArgumentException");
8341        } catch (IllegalArgumentException e) {
8342            // Expected
8343        }
8344
8345        endKey = new Integer(101).toString();
8346        assertEquals(0, keySet.headSet(endKey).size());
8347        assertEquals(0, keySet.headSet(endKey).size());
8348        assertEquals(1, keySet.headSet(endKey, true).size());
8349
8350        for (int i = 102; i < 109; i++) {
8351            endKey = new Integer(i).toString();
8352
8353            headSet = keySet.headSet(endKey);
8354            iterator = headSet.iterator();
8355            int j;
8356            for (j = 101; iterator.hasNext(); j++) {
8357                key = (String) iterator.next();
8358                assertEquals(new Integer(j).toString(), key);
8359            }
8360            assertEquals(i, j);
8361
8362            headSet = keySet.headSet(endKey, false);
8363            iterator = headSet.iterator();
8364            for (j = 101; iterator.hasNext(); j++) {
8365                key = (String) iterator.next();
8366                assertEquals(new Integer(j).toString(), key);
8367            }
8368            assertEquals(i, j);
8369
8370            headSet = keySet.headSet(endKey, true);
8371            iterator = headSet.iterator();
8372            for (j = 101; iterator.hasNext(); j++) {
8373                key = (String) iterator.next();
8374                assertEquals(new Integer(j).toString(), key);
8375            }
8376            assertEquals(i + 1, j);
8377        }
8378
8379        endKey = new Integer(109).toString();
8380        headSet = keySet.headSet(endKey);
8381        iterator = headSet.iterator();
8382        for (index = 101; iterator.hasNext(); index++) {
8383            key = (String) iterator.next();
8384            assertEquals(new Integer(index).toString(), key);
8385        }
8386        assertEquals(109, index);
8387
8388        headSet = keySet.headSet(endKey, false);
8389        iterator = headSet.iterator();
8390        for (index = 101; iterator.hasNext(); index++) {
8391            key = (String) iterator.next();
8392            assertEquals(new Integer(index).toString(), key);
8393        }
8394        assertEquals(109, index);
8395
8396        headSet = keySet.headSet(endKey, true);
8397        iterator = headSet.iterator();
8398        for (index = 101; iterator.hasNext(); index++) {
8399            key = (String) iterator.next();
8400            assertEquals(new Integer(index).toString(), key);
8401        }
8402        assertEquals(110, index);
8403
8404        endKey = new Integer(110).toString();
8405        try {
8406            keySet.headSet(endKey);
8407            fail("should throw IllegalArgumentException");
8408        } catch (IllegalArgumentException e) {
8409            // Expected
8410        }
8411        try {
8412            keySet.headSet(endKey, false);
8413            fail("should throw IllegalArgumentException");
8414        } catch (IllegalArgumentException e) {
8415            // Expected
8416        }
8417        try {
8418            keySet.headSet(endKey, true);
8419            fail("should throw IllegalArgumentException");
8420        } catch (IllegalArgumentException e) {
8421            // Expected
8422        }
8423
8424        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
8425        endKey = new Integer(99).toString();
8426        try {
8427            keySet.headSet(endKey);
8428            fail("should throw IllegalArgumentException");
8429        } catch (IllegalArgumentException e) {
8430            // Expected
8431        }
8432        try {
8433            keySet.headSet(endKey, false);
8434            fail("should throw IllegalArgumentException");
8435        } catch (IllegalArgumentException e) {
8436            // Expected
8437        }
8438        try {
8439            keySet.headSet(endKey, true);
8440            fail("should throw IllegalArgumentException");
8441        } catch (IllegalArgumentException e) {
8442            // Expected
8443        }
8444
8445        endKey = new Integer(100).toString();
8446        assertEquals(0, keySet.headSet(endKey).size());
8447        assertEquals(0, keySet.headSet(endKey, false).size());
8448        assertEquals(1, keySet.headSet(endKey, true).size());
8449
8450        endKey = new Integer(101).toString();
8451        headSet = keySet.headSet(endKey);
8452        iterator = headSet.iterator();
8453        for (index = 100; iterator.hasNext(); index++) {
8454            key = (String) iterator.next();
8455            assertEquals(new Integer(index).toString(), key);
8456        }
8457        assertEquals(101, index);
8458
8459        headSet = keySet.headSet(endKey, false);
8460        iterator = headSet.iterator();
8461        for (index = 100; iterator.hasNext(); index++) {
8462            key = (String) iterator.next();
8463            assertEquals(new Integer(index).toString(), key);
8464        }
8465        assertEquals(101, index);
8466
8467        headSet = keySet.headSet(endKey, true);
8468        iterator = headSet.iterator();
8469        for (index = 100; iterator.hasNext(); index++) {
8470            key = (String) iterator.next();
8471            assertEquals(new Integer(index).toString(), key);
8472        }
8473        assertEquals(102, index);
8474
8475        for (int i = 102; i < 109; i++) {
8476            endKey = new Integer(i).toString();
8477
8478            headSet = keySet.headSet(endKey);
8479            iterator = headSet.iterator();
8480            int j;
8481            for (j = 100; iterator.hasNext(); j++) {
8482                key = (String) iterator.next();
8483                assertEquals(new Integer(j).toString(), key);
8484            }
8485            assertEquals(i, j);
8486
8487            headSet = keySet.headSet(endKey, false);
8488            iterator = headSet.iterator();
8489            for (j = 100; iterator.hasNext(); j++) {
8490                key = (String) iterator.next();
8491                assertEquals(new Integer(j).toString(), key);
8492            }
8493            assertEquals(i, j);
8494
8495            headSet = keySet.headSet(endKey, true);
8496            iterator = headSet.iterator();
8497            for (j = 100; iterator.hasNext(); j++) {
8498                key = (String) iterator.next();
8499                assertEquals(new Integer(j).toString(), key);
8500            }
8501            assertEquals(i + 1, j);
8502        }
8503
8504        endKey = new Integer(109).toString();
8505        headSet = keySet.headSet(endKey);
8506        iterator = headSet.iterator();
8507        for (index = 100; iterator.hasNext(); index++) {
8508            key = (String) iterator.next();
8509            assertEquals(new Integer(index).toString(), key);
8510        }
8511        assertEquals(109, index);
8512
8513        headSet = keySet.headSet(endKey, false);
8514        iterator = headSet.iterator();
8515        for (index = 100; iterator.hasNext(); index++) {
8516            key = (String) iterator.next();
8517            assertEquals(new Integer(index).toString(), key);
8518        }
8519        assertEquals(109, index);
8520
8521        try {
8522            keySet.headSet(endKey, true);
8523            fail("should throw IllegalArgumentException");
8524        } catch (IllegalArgumentException e) {
8525            // Expected
8526        }
8527
8528        endKey = new Integer(110).toString();
8529        try {
8530            keySet.headSet(endKey);
8531            fail("should throw IllegalArgumentException");
8532        } catch (IllegalArgumentException e) {
8533            // Expected
8534        }
8535
8536        try {
8537            keySet.headSet(endKey, false);
8538            fail("should throw IllegalArgumentException");
8539        } catch (IllegalArgumentException e) {
8540            // Expected
8541        }
8542
8543        try {
8544            keySet.headSet(endKey, true);
8545            fail("should throw IllegalArgumentException");
8546        } catch (IllegalArgumentException e) {
8547            // Expected
8548        }
8549
8550        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
8551        endKey = new Integer(99).toString();
8552        try {
8553            keySet.headSet(endKey);
8554            fail("should throw IllegalArgumentException");
8555        } catch (IllegalArgumentException e) {
8556            // Expected
8557        }
8558        try {
8559            keySet.headSet(endKey, false);
8560            fail("should throw IllegalArgumentException");
8561        } catch (IllegalArgumentException e) {
8562            // Expected
8563        }
8564        try {
8565            keySet.headSet(endKey, true);
8566            fail("should throw IllegalArgumentException");
8567        } catch (IllegalArgumentException e) {
8568            // Expected
8569        }
8570
8571        endKey = new Integer(100).toString();
8572        assertEquals(0, keySet.headSet(endKey).size());
8573        assertEquals(0, keySet.headSet(endKey, false).size());
8574        assertEquals(1, keySet.headSet(endKey, true).size());
8575
8576        endKey = new Integer(101).toString();
8577        headSet = keySet.headSet(endKey);
8578        iterator = headSet.iterator();
8579        for (index = 100; iterator.hasNext(); index++) {
8580            key = (String) iterator.next();
8581            assertEquals(new Integer(index).toString(), key);
8582        }
8583        assertEquals(101, index);
8584
8585        headSet = keySet.headSet(endKey, false);
8586        iterator = headSet.iterator();
8587        for (index = 100; iterator.hasNext(); index++) {
8588            key = (String) iterator.next();
8589            assertEquals(new Integer(index).toString(), key);
8590        }
8591        assertEquals(101, index);
8592
8593        headSet = keySet.headSet(endKey, true);
8594        iterator = headSet.iterator();
8595        for (index = 100; iterator.hasNext(); index++) {
8596            key = (String) iterator.next();
8597            assertEquals(new Integer(index).toString(), key);
8598        }
8599        assertEquals(102, index);
8600
8601        for (int i = 102; i < 109; i++) {
8602            endKey = new Integer(i).toString();
8603
8604            headSet = keySet.headSet(endKey);
8605            iterator = headSet.iterator();
8606            int j;
8607            for (j = 100; iterator.hasNext(); j++) {
8608                key = (String) iterator.next();
8609                assertEquals(new Integer(j).toString(), key);
8610            }
8611            assertEquals(i, j);
8612
8613            headSet = keySet.headSet(endKey, false);
8614            iterator = headSet.iterator();
8615            for (j = 100; iterator.hasNext(); j++) {
8616                key = (String) iterator.next();
8617                assertEquals(new Integer(j).toString(), key);
8618            }
8619            assertEquals(i, j);
8620
8621            headSet = keySet.headSet(endKey, true);
8622            iterator = headSet.iterator();
8623            for (j = 100; iterator.hasNext(); j++) {
8624                key = (String) iterator.next();
8625                assertEquals(new Integer(j).toString(), key);
8626            }
8627            assertEquals(i + 1, j);
8628        }
8629
8630        endKey = new Integer(109).toString();
8631        headSet = keySet.headSet(endKey);
8632        iterator = headSet.iterator();
8633        for (index = 100; iterator.hasNext(); index++) {
8634            key = (String) iterator.next();
8635            assertEquals(new Integer(index).toString(), key);
8636        }
8637        assertEquals(109, index);
8638
8639        headSet = keySet.headSet(endKey, false);
8640        iterator = headSet.iterator();
8641        for (index = 100; iterator.hasNext(); index++) {
8642            key = (String) iterator.next();
8643            assertEquals(new Integer(index).toString(), key);
8644        }
8645        assertEquals(109, index);
8646
8647        headSet = keySet.headSet(endKey, true);
8648        iterator = headSet.iterator();
8649        for (index = 100; iterator.hasNext(); index++) {
8650            key = (String) iterator.next();
8651            assertEquals(new Integer(index).toString(), key);
8652        }
8653        assertEquals(110, index);
8654
8655        endKey = new Integer(110).toString();
8656        try {
8657            keySet.headSet(endKey);
8658            fail("should throw IllegalArgumentException");
8659        } catch (IllegalArgumentException e) {
8660            // Expected
8661        }
8662        try {
8663            keySet.headSet(endKey, false);
8664            fail("should throw IllegalArgumentException");
8665        } catch (IllegalArgumentException e) {
8666            // Expected
8667        }
8668        try {
8669            keySet.headSet(endKey, true);
8670            fail("should throw IllegalArgumentException");
8671        } catch (IllegalArgumentException e) {
8672            // Expected
8673        }
8674
8675        key = new Integer(1).toString();
8676        keySet = tm.headMap(key, true).navigableKeySet();
8677        iterator = keySet.iterator();
8678        iterator.next();
8679        endKey = (String) iterator.next();
8680        headSet = keySet.headSet(endKey, false);
8681        assertEquals(1, headSet.size());
8682        Iterator headSetIterator = headSet.iterator();
8683        assertEquals(new Integer(0).toString(), headSetIterator.next());
8684        assertFalse(headSetIterator.hasNext());
8685        try {
8686            headSetIterator.next();
8687            fail("should throw NoSuchElementException");
8688        } catch (NoSuchElementException e) {
8689            // Expected
8690        }
8691        try {
8692            keySet.headSet(null, false);
8693            fail("should throw NPE");
8694        } catch (NullPointerException e) {
8695            // Expected
8696        }
8697
8698        headSet = keySet.headSet(endKey, true);
8699        assertEquals(2, headSet.size());
8700        headSetIterator = headSet.iterator();
8701        assertEquals(new Integer(0).toString(), headSetIterator.next());
8702        assertEquals(new Integer(1).toString(), headSetIterator.next());
8703        assertFalse(headSetIterator.hasNext());
8704        try {
8705            headSetIterator.next();
8706            fail("should throw NoSuchElementException");
8707        } catch (NoSuchElementException e) {
8708            // Expected
8709        }
8710        try {
8711            keySet.headSet(null, false);
8712            fail("should throw NPE");
8713        } catch (NullPointerException e) {
8714            // Expected
8715        }
8716
8717        // With Comparator
8718        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
8719                .navigableKeySet();
8720        endKey = new Integer(99).toString();
8721        try {
8722            keySet.headSet(endKey);
8723            fail("should throw IllegalArgumentException");
8724        } catch (IllegalArgumentException e) {
8725            // Expected
8726        }
8727        try {
8728            keySet.headSet(endKey, false);
8729            fail("should throw IllegalArgumentException");
8730        } catch (IllegalArgumentException e) {
8731            // Expected
8732        }
8733        try {
8734            keySet.headSet(endKey, true);
8735            fail("should throw IllegalArgumentException");
8736        } catch (IllegalArgumentException e) {
8737            // Expected
8738        }
8739
8740        endKey = new Integer(100).toString();
8741        assertEquals(0, keySet.headSet(endKey).size());
8742        assertEquals(0, keySet.headSet(endKey, false).size());
8743        try {
8744            keySet.headSet(endKey, true).size();
8745            fail("should throw IllegalArgumentException");
8746        } catch (IllegalArgumentException e) {
8747            // Expected
8748        }
8749
8750        endKey = new Integer(101).toString();
8751        assertEquals(0, keySet.headSet(endKey).size());
8752        assertEquals(0, keySet.headSet(endKey, false).size());
8753        assertEquals(1, keySet.headSet(endKey, true).size());
8754
8755        for (int i = 102; i < 109; i++) {
8756            endKey = new Integer(i).toString();
8757            headSet = keySet.headSet(endKey);
8758            iterator = headSet.iterator();
8759            int j;
8760            for (j = 101; iterator.hasNext(); j++) {
8761                key = (String) iterator.next();
8762                assertEquals(new Integer(j).toString(), key);
8763            }
8764            assertEquals(i, j);
8765
8766            headSet = keySet.headSet(endKey, false);
8767            iterator = headSet.iterator();
8768            for (j = 101; iterator.hasNext(); j++) {
8769                key = (String) iterator.next();
8770                assertEquals(new Integer(j).toString(), key);
8771            }
8772            assertEquals(i, j);
8773
8774            headSet = keySet.headSet(endKey, true);
8775            iterator = headSet.iterator();
8776            for (j = 101; iterator.hasNext(); j++) {
8777                key = (String) iterator.next();
8778                assertEquals(new Integer(j).toString(), key);
8779            }
8780            assertEquals(i + 1, j);
8781        }
8782
8783        endKey = new Integer(109).toString();
8784        headSet = keySet.headSet(endKey);
8785        iterator = headSet.iterator();
8786        for (index = 101; iterator.hasNext(); index++) {
8787            key = (String) iterator.next();
8788            assertEquals(new Integer(index).toString(), key);
8789        }
8790        assertEquals(109, index);
8791
8792        headSet = keySet.headSet(endKey, false);
8793        iterator = headSet.iterator();
8794        for (index = 101; iterator.hasNext(); index++) {
8795            key = (String) iterator.next();
8796            assertEquals(new Integer(index).toString(), key);
8797        }
8798        assertEquals(109, index);
8799
8800        try {
8801            keySet.headSet(endKey, true);
8802            fail("should throw IllegalArgumentException");
8803        } catch (IllegalArgumentException e) {
8804            // Expected
8805        }
8806
8807        endKey = new Integer(110).toString();
8808        try {
8809            keySet.headSet(endKey);
8810            fail("should throw IllegalArgumentException");
8811        } catch (IllegalArgumentException e) {
8812            // Expected
8813        }
8814        try {
8815            keySet.headSet(endKey, true);
8816            fail("should throw IllegalArgumentException");
8817        } catch (IllegalArgumentException e) {
8818            // Expected
8819        }
8820        try {
8821            keySet.headSet(endKey, false);
8822            fail("should throw IllegalArgumentException");
8823        } catch (IllegalArgumentException e) {
8824            // Expected
8825        }
8826
8827        keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator)
8828                .navigableKeySet();
8829        endKey = new Integer(99).toString();
8830        try {
8831            keySet.headSet(endKey);
8832            fail("should throw IllegalArgumentException");
8833        } catch (IllegalArgumentException e) {
8834            // Expected
8835        }
8836        try {
8837            keySet.headSet(endKey, true);
8838            fail("should throw IllegalArgumentException");
8839        } catch (IllegalArgumentException e) {
8840            // Expected
8841        }
8842        try {
8843            keySet.headSet(endKey, false);
8844            fail("should throw IllegalArgumentException");
8845        } catch (IllegalArgumentException e) {
8846            // Expected
8847        }
8848
8849        endKey = new Integer(100).toString();
8850        assertEquals(0, keySet.headSet(endKey).size());
8851        assertEquals(0, keySet.headSet(endKey, false).size());
8852        try {
8853            keySet.headSet(endKey, true);
8854            fail("should throw IllegalArgumentException");
8855        } catch (IllegalArgumentException e) {
8856            // Expected
8857        }
8858
8859        endKey = new Integer(101).toString();
8860        assertEquals(0, keySet.headSet(endKey).size());
8861        assertEquals(0, keySet.headSet(endKey).size());
8862        assertEquals(1, keySet.headSet(endKey, true).size());
8863
8864        for (int i = 102; i < 109; i++) {
8865            endKey = new Integer(i).toString();
8866
8867            headSet = keySet.headSet(endKey);
8868            iterator = headSet.iterator();
8869            int j;
8870            for (j = 101; iterator.hasNext(); j++) {
8871                key = (String) iterator.next();
8872                assertEquals(new Integer(j).toString(), key);
8873            }
8874            assertEquals(i, j);
8875
8876            headSet = keySet.headSet(endKey, false);
8877            iterator = headSet.iterator();
8878            for (j = 101; iterator.hasNext(); j++) {
8879                key = (String) iterator.next();
8880                assertEquals(new Integer(j).toString(), key);
8881            }
8882            assertEquals(i, j);
8883
8884            headSet = keySet.headSet(endKey, true);
8885            iterator = headSet.iterator();
8886            for (j = 101; iterator.hasNext(); j++) {
8887                key = (String) iterator.next();
8888                assertEquals(new Integer(j).toString(), key);
8889            }
8890            assertEquals(i + 1, j);
8891        }
8892
8893        endKey = new Integer(109).toString();
8894        headSet = keySet.headSet(endKey);
8895        iterator = headSet.iterator();
8896        for (index = 101; iterator.hasNext(); index++) {
8897            key = (String) iterator.next();
8898            assertEquals(new Integer(index).toString(), key);
8899        }
8900        assertEquals(109, index);
8901
8902        headSet = keySet.headSet(endKey, false);
8903        iterator = headSet.iterator();
8904        for (index = 101; iterator.hasNext(); index++) {
8905            key = (String) iterator.next();
8906            assertEquals(new Integer(index).toString(), key);
8907        }
8908        assertEquals(109, index);
8909
8910        headSet = keySet.headSet(endKey, true);
8911        iterator = headSet.iterator();
8912        for (index = 101; iterator.hasNext(); index++) {
8913            key = (String) iterator.next();
8914            assertEquals(new Integer(index).toString(), key);
8915        }
8916        assertEquals(110, index);
8917
8918        endKey = new Integer(110).toString();
8919        try {
8920            keySet.headSet(endKey);
8921            fail("should throw IllegalArgumentException");
8922        } catch (IllegalArgumentException e) {
8923            // Expected
8924        }
8925        try {
8926            keySet.headSet(endKey, false);
8927            fail("should throw IllegalArgumentException");
8928        } catch (IllegalArgumentException e) {
8929            // Expected
8930        }
8931        try {
8932            keySet.headSet(endKey, true);
8933            fail("should throw IllegalArgumentException");
8934        } catch (IllegalArgumentException e) {
8935            // Expected
8936        }
8937
8938        keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator)
8939                .navigableKeySet();
8940        endKey = new Integer(99).toString();
8941        try {
8942            keySet.headSet(endKey);
8943            fail("should throw IllegalArgumentException");
8944        } catch (IllegalArgumentException e) {
8945            // Expected
8946        }
8947        try {
8948            keySet.headSet(endKey, false);
8949            fail("should throw IllegalArgumentException");
8950        } catch (IllegalArgumentException e) {
8951            // Expected
8952        }
8953        try {
8954            keySet.headSet(endKey, true);
8955            fail("should throw IllegalArgumentException");
8956        } catch (IllegalArgumentException e) {
8957            // Expected
8958        }
8959
8960        endKey = new Integer(100).toString();
8961        assertEquals(0, keySet.headSet(endKey).size());
8962        assertEquals(0, keySet.headSet(endKey, false).size());
8963        assertEquals(1, keySet.headSet(endKey, true).size());
8964
8965        endKey = new Integer(101).toString();
8966        headSet = keySet.headSet(endKey);
8967        iterator = headSet.iterator();
8968        for (index = 100; iterator.hasNext(); index++) {
8969            key = (String) iterator.next();
8970            assertEquals(new Integer(index).toString(), key);
8971        }
8972        assertEquals(101, index);
8973
8974        headSet = keySet.headSet(endKey, false);
8975        iterator = headSet.iterator();
8976        for (index = 100; iterator.hasNext(); index++) {
8977            key = (String) iterator.next();
8978            assertEquals(new Integer(index).toString(), key);
8979        }
8980        assertEquals(101, index);
8981
8982        headSet = keySet.headSet(endKey, true);
8983        iterator = headSet.iterator();
8984        for (index = 100; iterator.hasNext(); index++) {
8985            key = (String) iterator.next();
8986            assertEquals(new Integer(index).toString(), key);
8987        }
8988        assertEquals(102, index);
8989
8990        for (int i = 102; i < 109; i++) {
8991            endKey = new Integer(i).toString();
8992
8993            headSet = keySet.headSet(endKey);
8994            iterator = headSet.iterator();
8995            int j;
8996            for (j = 100; iterator.hasNext(); j++) {
8997                key = (String) iterator.next();
8998                assertEquals(new Integer(j).toString(), key);
8999            }
9000            assertEquals(i, j);
9001
9002            headSet = keySet.headSet(endKey, false);
9003            iterator = headSet.iterator();
9004            for (j = 100; iterator.hasNext(); j++) {
9005                key = (String) iterator.next();
9006                assertEquals(new Integer(j).toString(), key);
9007            }
9008            assertEquals(i, j);
9009
9010            headSet = keySet.headSet(endKey, true);
9011            iterator = headSet.iterator();
9012            for (j = 100; iterator.hasNext(); j++) {
9013                key = (String) iterator.next();
9014                assertEquals(new Integer(j).toString(), key);
9015            }
9016            assertEquals(i + 1, j);
9017        }
9018
9019        endKey = new Integer(109).toString();
9020        headSet = keySet.headSet(endKey);
9021        iterator = headSet.iterator();
9022        for (index = 100; iterator.hasNext(); index++) {
9023            key = (String) iterator.next();
9024            assertEquals(new Integer(index).toString(), key);
9025        }
9026        assertEquals(109, index);
9027
9028        headSet = keySet.headSet(endKey, false);
9029        iterator = headSet.iterator();
9030        for (index = 100; iterator.hasNext(); index++) {
9031            key = (String) iterator.next();
9032            assertEquals(new Integer(index).toString(), key);
9033        }
9034        assertEquals(109, index);
9035
9036        try {
9037            keySet.headSet(endKey, true);
9038            fail("should throw IllegalArgumentException");
9039        } catch (IllegalArgumentException e) {
9040            // Expected
9041        }
9042
9043        endKey = new Integer(110).toString();
9044        try {
9045            keySet.headSet(endKey);
9046            fail("should throw IllegalArgumentException");
9047        } catch (IllegalArgumentException e) {
9048            // Expected
9049        }
9050
9051        try {
9052            keySet.headSet(endKey, false);
9053            fail("should throw IllegalArgumentException");
9054        } catch (IllegalArgumentException e) {
9055            // Expected
9056        }
9057
9058        try {
9059            keySet.headSet(endKey, true);
9060            fail("should throw IllegalArgumentException");
9061        } catch (IllegalArgumentException e) {
9062            // Expected
9063        }
9064
9065        keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator)
9066                .navigableKeySet();
9067        endKey = new Integer(99).toString();
9068        try {
9069            keySet.headSet(endKey);
9070            fail("should throw IllegalArgumentException");
9071        } catch (IllegalArgumentException e) {
9072            // Expected
9073        }
9074        try {
9075            keySet.headSet(endKey, false);
9076            fail("should throw IllegalArgumentException");
9077        } catch (IllegalArgumentException e) {
9078            // Expected
9079        }
9080        try {
9081            keySet.headSet(endKey, true);
9082            fail("should throw IllegalArgumentException");
9083        } catch (IllegalArgumentException e) {
9084            // Expected
9085        }
9086
9087        endKey = new Integer(100).toString();
9088        assertEquals(0, keySet.headSet(endKey).size());
9089        assertEquals(0, keySet.headSet(endKey, false).size());
9090        assertEquals(1, keySet.headSet(endKey, true).size());
9091
9092        endKey = new Integer(101).toString();
9093        headSet = keySet.headSet(endKey);
9094        iterator = headSet.iterator();
9095        for (index = 100; iterator.hasNext(); index++) {
9096            key = (String) iterator.next();
9097            assertEquals(new Integer(index).toString(), key);
9098        }
9099        assertEquals(101, index);
9100
9101        headSet = keySet.headSet(endKey, false);
9102        iterator = headSet.iterator();
9103        for (index = 100; iterator.hasNext(); index++) {
9104            key = (String) iterator.next();
9105            assertEquals(new Integer(index).toString(), key);
9106        }
9107        assertEquals(101, index);
9108
9109        headSet = keySet.headSet(endKey, true);
9110        iterator = headSet.iterator();
9111        for (index = 100; iterator.hasNext(); index++) {
9112            key = (String) iterator.next();
9113            assertEquals(new Integer(index).toString(), key);
9114        }
9115        assertEquals(102, index);
9116
9117        for (int i = 102; i < 109; i++) {
9118            endKey = new Integer(i).toString();
9119
9120            headSet = keySet.headSet(endKey);
9121            iterator = headSet.iterator();
9122            int j;
9123            for (j = 100; iterator.hasNext(); j++) {
9124                key = (String) iterator.next();
9125                assertEquals(new Integer(j).toString(), key);
9126            }
9127            assertEquals(i, j);
9128
9129            headSet = keySet.headSet(endKey, false);
9130            iterator = headSet.iterator();
9131            for (j = 100; iterator.hasNext(); j++) {
9132                key = (String) iterator.next();
9133                assertEquals(new Integer(j).toString(), key);
9134            }
9135            assertEquals(i, j);
9136
9137            headSet = keySet.headSet(endKey, true);
9138            iterator = headSet.iterator();
9139            for (j = 100; iterator.hasNext(); j++) {
9140                key = (String) iterator.next();
9141                assertEquals(new Integer(j).toString(), key);
9142            }
9143            assertEquals(i + 1, j);
9144        }
9145
9146        endKey = new Integer(109).toString();
9147        headSet = keySet.headSet(endKey);
9148        iterator = headSet.iterator();
9149        for (index = 100; iterator.hasNext(); index++) {
9150            key = (String) iterator.next();
9151            assertEquals(new Integer(index).toString(), key);
9152        }
9153        assertEquals(109, index);
9154
9155        headSet = keySet.headSet(endKey, false);
9156        iterator = headSet.iterator();
9157        for (index = 100; iterator.hasNext(); index++) {
9158            key = (String) iterator.next();
9159            assertEquals(new Integer(index).toString(), key);
9160        }
9161        assertEquals(109, index);
9162
9163        headSet = keySet.headSet(endKey, true);
9164        iterator = headSet.iterator();
9165        for (index = 100; iterator.hasNext(); index++) {
9166            key = (String) iterator.next();
9167            assertEquals(new Integer(index).toString(), key);
9168        }
9169        assertEquals(110, index);
9170
9171        endKey = new Integer(110).toString();
9172        try {
9173            keySet.headSet(endKey);
9174            fail("should throw IllegalArgumentException");
9175        } catch (IllegalArgumentException e) {
9176            // Expected
9177        }
9178        try {
9179            keySet.headSet(endKey, false);
9180            fail("should throw IllegalArgumentException");
9181        } catch (IllegalArgumentException e) {
9182            // Expected
9183        }
9184        try {
9185            keySet.headSet(endKey, true);
9186            fail("should throw IllegalArgumentException");
9187        } catch (IllegalArgumentException e) {
9188            // Expected
9189        }
9190
9191        key = new Integer(1).toString();
9192        keySet = tm.headMap(key, true).navigableKeySet();
9193        iterator = keySet.iterator();
9194        iterator.next();
9195        endKey = (String) iterator.next();
9196        headSet = keySet.headSet(endKey, false);
9197        assertEquals(1, headSet.size());
9198        headSetIterator = headSet.iterator();
9199        assertEquals(new Integer(0).toString(), headSetIterator.next());
9200        assertFalse(headSetIterator.hasNext());
9201        try {
9202            headSetIterator.next();
9203            fail("should throw NoSuchElementException");
9204        } catch (NoSuchElementException e) {
9205            // Expected
9206        }
9207        try {
9208            keySet.headSet(null, false);
9209            fail("should throw NPE");
9210        } catch (NullPointerException e) {
9211            // Expected
9212        }
9213
9214        headSet = keySet.headSet(endKey, true);
9215        assertEquals(2, headSet.size());
9216        headSetIterator = headSet.iterator();
9217        assertEquals(new Integer(0).toString(), headSetIterator.next());
9218        assertEquals(new Integer(1).toString(), headSetIterator.next());
9219        assertFalse(headSetIterator.hasNext());
9220        try {
9221            headSetIterator.next();
9222            fail("should throw NoSuchElementException");
9223        } catch (NoSuchElementException e) {
9224            // Expected
9225        }
9226        try {
9227            keySet.headSet(null, false);
9228            fail("should throw NPE");
9229        } catch (NullPointerException e) {
9230            // Expected
9231        }
9232
9233    }
9234
9235    public void test_AscendingSubMapKeySet_remove() {
9236        TreeMap tm_rm = new TreeMap(tm);
9237        SortedMap subMap_startExcluded_endExcluded_rm = tm_rm.subMap(
9238                objArray[100].toString(), false, objArray[109].toString(),
9239                false);
9240        assertNull(subMap_startExcluded_endExcluded_rm.remove("0"));
9241        try {
9242            subMap_startExcluded_endExcluded_rm.remove(null);
9243            fail("should throw NPE");
9244        } catch (Exception e) {
9245            // Expected
9246        }
9247        for (int i = 101; i < 108; i++) {
9248            assertNotNull(subMap_startExcluded_endExcluded_rm
9249                    .remove(new Integer(i).toString()));
9250        }
9251    }
9252
9253    public void test_AscendingSubMapKeySet_tailSet() {
9254        NavigableSet keySet;
9255        SortedSet tailSet;
9256        String startKey, key;
9257        Iterator iterator;
9258
9259        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
9260        startKey = new Integer(99).toString();
9261        try {
9262            keySet.tailSet(startKey);
9263            fail("should throw IllegalArgumentException");
9264        } catch (IllegalArgumentException e) {
9265            // Expected
9266        }
9267
9268        try {
9269            keySet.tailSet(startKey, true);
9270            fail("should throw IllegalArgumentException");
9271        } catch (IllegalArgumentException e) {
9272            // Expected
9273        }
9274
9275        try {
9276            keySet.tailSet(startKey, false);
9277            fail("should throw IllegalArgumentException");
9278        } catch (IllegalArgumentException e) {
9279            // Expected
9280        }
9281
9282        startKey = new Integer(100).toString();
9283        try {
9284            keySet.tailSet(startKey);
9285            fail("should throw IllegalArgumentException");
9286        } catch (IllegalArgumentException e) {
9287            // Expected
9288        }
9289        try {
9290            keySet.tailSet(startKey, true);
9291            fail("should throw IllegalArgumentException");
9292        } catch (IllegalArgumentException e) {
9293            // Expected
9294        }
9295        int index;
9296        tailSet = keySet.tailSet(startKey, false);
9297        iterator = tailSet.iterator();
9298        for (index = 101; index < 109; index++) {
9299            key = (String) iterator.next();
9300            assertEquals(new Integer(index).toString(), key);
9301        }
9302
9303        startKey = new Integer(101).toString();
9304        tailSet = keySet.tailSet(startKey);
9305        iterator = tailSet.iterator();
9306        for (index = 101; iterator.hasNext(); index++) {
9307            key = (String) iterator.next();
9308            assertEquals(new Integer(index).toString(), key);
9309        }
9310        assertEquals(109, index);
9311
9312        tailSet = keySet.tailSet(startKey, true);
9313        iterator = tailSet.iterator();
9314        for (index = 101; iterator.hasNext(); index++) {
9315            key = (String) iterator.next();
9316            assertEquals(new Integer(index).toString(), key);
9317        }
9318        assertEquals(109, index);
9319
9320        tailSet = keySet.tailSet(startKey, false);
9321        iterator = tailSet.iterator();
9322        for (index = 101; iterator.hasNext(); index++) {
9323            key = (String) iterator.next();
9324            assertEquals(new Integer(index + 1).toString(), key);
9325        }
9326        assertEquals(108, index);
9327
9328        for (int i = 102; i < 109; i++) {
9329            startKey = new Integer(i).toString();
9330
9331            tailSet = keySet.tailSet(startKey);
9332            iterator = tailSet.iterator();
9333            int j;
9334            for (j = i; iterator.hasNext(); j++) {
9335                key = (String) iterator.next();
9336                assertEquals(new Integer(j).toString(), key);
9337            }
9338            assertEquals(109, j);
9339
9340            tailSet = keySet.tailSet(startKey, true);
9341            iterator = tailSet.iterator();
9342            for (j = i; iterator.hasNext(); j++) {
9343                key = (String) iterator.next();
9344                assertEquals(new Integer(j).toString(), key);
9345            }
9346            assertEquals(109, j);
9347
9348            tailSet = keySet.tailSet(startKey, false);
9349            iterator = tailSet.iterator();
9350            for (j = i; iterator.hasNext(); j++) {
9351                key = (String) iterator.next();
9352                assertEquals(new Integer(j + 1).toString(), key);
9353            }
9354            assertEquals(108, j);
9355        }
9356
9357        startKey = new Integer(109).toString();
9358        try {
9359            keySet.tailSet(startKey);
9360            fail("should throw IllegalArgumentException");
9361        } catch (IllegalArgumentException e) {
9362            // Expected
9363        }
9364        try {
9365            keySet.tailSet(startKey, true);
9366            fail("should throw IllegalArgumentException");
9367        } catch (IllegalArgumentException e) {
9368            // Expected
9369        }
9370        tailSet = keySet.tailSet(startKey, false);
9371        iterator = tailSet.iterator();
9372        for (index = 109; iterator.hasNext(); index++) {
9373            key = (String) iterator.next();
9374            assertEquals(new Integer(index + 1).toString(), key);
9375        }
9376        assertEquals(109, index);
9377
9378        startKey = new Integer(110).toString();
9379        try {
9380            keySet.tailSet(startKey);
9381            fail("should throw IllegalArgumentException");
9382        } catch (IllegalArgumentException e) {
9383            // Expected
9384        }
9385        try {
9386            keySet.tailSet(startKey, true);
9387            fail("should throw IllegalArgumentException");
9388        } catch (IllegalArgumentException e) {
9389            // Expected
9390        }
9391        try {
9392            keySet.tailSet(startKey, false);
9393            fail("should throw IllegalArgumentException");
9394        } catch (IllegalArgumentException e) {
9395            // Expected
9396        }
9397
9398        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
9399        startKey = new Integer(99).toString();
9400        try {
9401            keySet.tailSet(startKey);
9402            fail("should throw IllegalArgumentException");
9403        } catch (IllegalArgumentException e) {
9404            // Expected
9405        }
9406        try {
9407            keySet.tailSet(startKey, true);
9408            fail("should throw IllegalArgumentException");
9409        } catch (IllegalArgumentException e) {
9410            // Expected
9411        }
9412        try {
9413            keySet.tailSet(startKey, false);
9414            fail("should throw IllegalArgumentException");
9415        } catch (IllegalArgumentException e) {
9416            // Expected
9417        }
9418
9419        startKey = new Integer(100).toString();
9420        try {
9421            keySet.tailSet(startKey);
9422            fail("should throw IllegalArgumentException");
9423        } catch (IllegalArgumentException e) {
9424            // Expected
9425        }
9426        try {
9427            keySet.tailSet(startKey, true);
9428            fail("should throw IllegalArgumentException");
9429        } catch (IllegalArgumentException e) {
9430            // Expected
9431        }
9432
9433        tailSet = keySet.tailSet(startKey, false);
9434        iterator = tailSet.iterator();
9435        for (index = 100; iterator.hasNext(); index++) {
9436            key = (String) iterator.next();
9437            assertEquals(new Integer(index + 1).toString(), key);
9438        }
9439        assertEquals(109, index);
9440
9441        for (int i = 102; i < 109; i++) {
9442            startKey = new Integer(i).toString();
9443
9444            tailSet = keySet.tailSet(startKey);
9445            iterator = tailSet.iterator();
9446            int j;
9447            for (j = i; iterator.hasNext(); j++) {
9448                key = (String) iterator.next();
9449                assertEquals(new Integer(j).toString(), key);
9450            }
9451            assertEquals(110, j);
9452
9453            tailSet = keySet.tailSet(startKey, true);
9454            iterator = tailSet.iterator();
9455            for (j = i; iterator.hasNext(); j++) {
9456                key = (String) iterator.next();
9457                assertEquals(new Integer(j).toString(), key);
9458            }
9459            assertEquals(110, j);
9460
9461            tailSet = keySet.tailSet(startKey, false);
9462            iterator = tailSet.iterator();
9463            for (j = i; iterator.hasNext(); j++) {
9464                key = (String) iterator.next();
9465                assertEquals(new Integer(j + 1).toString(), key);
9466            }
9467            assertEquals(109, j);
9468        }
9469
9470        startKey = new Integer(109).toString();
9471        tailSet = keySet.tailSet(startKey);
9472        iterator = tailSet.iterator();
9473        for (index = 109; iterator.hasNext(); index++) {
9474            key = (String) iterator.next();
9475            assertEquals(new Integer(index).toString(), key);
9476        }
9477        assertEquals(110, index);
9478
9479        tailSet = keySet.tailSet(startKey, true);
9480        iterator = tailSet.iterator();
9481        for (index = 109; iterator.hasNext(); index++) {
9482            key = (String) iterator.next();
9483            assertEquals(new Integer(index).toString(), key);
9484        }
9485        assertEquals(110, index);
9486
9487        tailSet = keySet.tailSet(startKey, false);
9488        iterator = tailSet.iterator();
9489        for (index = 109; iterator.hasNext(); index++) {
9490            key = (String) iterator.next();
9491            assertEquals(new Integer(index + 1).toString(), key);
9492        }
9493        assertEquals(109, index);
9494
9495        startKey = new Integer(110).toString();
9496        try {
9497            keySet.tailSet(startKey);
9498            fail("should throw IllegalArgumentException");
9499        } catch (IllegalArgumentException e) {
9500            // Expected
9501        }
9502        try {
9503            keySet.tailSet(startKey, true);
9504            fail("should throw IllegalArgumentException");
9505        } catch (IllegalArgumentException e) {
9506            // Expected
9507        }
9508        try {
9509            keySet.tailSet(startKey, false);
9510            fail("should throw IllegalArgumentException");
9511        } catch (IllegalArgumentException e) {
9512            // Expected
9513        }
9514
9515        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
9516        startKey = new Integer(99).toString();
9517        try {
9518            keySet.tailSet(startKey);
9519            fail("should throw IllegalArgumentException");
9520        } catch (IllegalArgumentException e) {
9521            // Expected
9522        }
9523        try {
9524            keySet.tailSet(startKey, true);
9525            fail("should throw IllegalArgumentException");
9526        } catch (IllegalArgumentException e) {
9527            // Expected
9528        }
9529        try {
9530            keySet.tailSet(startKey, false);
9531            fail("should throw IllegalArgumentException");
9532        } catch (IllegalArgumentException e) {
9533            // Expected
9534        }
9535
9536        startKey = new Integer(100).toString();
9537        tailSet = keySet.tailSet(startKey);
9538        iterator = tailSet.iterator();
9539        for (index = 100; iterator.hasNext(); index++) {
9540            key = (String) iterator.next();
9541            assertEquals(new Integer(index).toString(), key);
9542        }
9543        assertEquals(109, index);
9544
9545        tailSet = keySet.tailSet(startKey, true);
9546        iterator = tailSet.iterator();
9547        for (index = 100; iterator.hasNext(); index++) {
9548            key = (String) iterator.next();
9549            assertEquals(new Integer(index).toString(), key);
9550        }
9551        assertEquals(109, index);
9552
9553        tailSet = keySet.tailSet(startKey, false);
9554        iterator = tailSet.iterator();
9555        for (index = 100; iterator.hasNext(); index++) {
9556            key = (String) iterator.next();
9557            assertEquals(new Integer(index + 1).toString(), key);
9558        }
9559        assertEquals(108, index);
9560
9561        startKey = new Integer(101).toString();
9562        tailSet = keySet.tailSet(startKey);
9563        iterator = tailSet.iterator();
9564        for (index = 101; iterator.hasNext(); index++) {
9565            key = (String) iterator.next();
9566            assertEquals(new Integer(index).toString(), key);
9567        }
9568        assertEquals(109, index);
9569
9570        tailSet = keySet.tailSet(startKey, true);
9571        iterator = tailSet.iterator();
9572        for (index = 101; iterator.hasNext(); index++) {
9573            key = (String) iterator.next();
9574            assertEquals(new Integer(index).toString(), key);
9575        }
9576        assertEquals(109, index);
9577
9578        tailSet = keySet.tailSet(startKey, false);
9579        iterator = tailSet.iterator();
9580        for (index = 101; iterator.hasNext(); index++) {
9581            key = (String) iterator.next();
9582            assertEquals(new Integer(index + 1).toString(), key);
9583        }
9584        assertEquals(108, index);
9585
9586        for (int i = 102; i < 109; i++) {
9587            startKey = new Integer(i).toString();
9588
9589            tailSet = keySet.tailSet(startKey);
9590            iterator = tailSet.iterator();
9591            int j;
9592            for (j = i; iterator.hasNext(); j++) {
9593                key = (String) iterator.next();
9594                assertEquals(new Integer(j).toString(), key);
9595            }
9596            assertEquals(109, j);
9597
9598            tailSet = keySet.tailSet(startKey, true);
9599            iterator = tailSet.iterator();
9600            for (j = i; iterator.hasNext(); j++) {
9601                key = (String) iterator.next();
9602                assertEquals(new Integer(j).toString(), key);
9603            }
9604            assertEquals(109, j);
9605
9606            tailSet = keySet.tailSet(startKey, false);
9607            iterator = tailSet.iterator();
9608            for (j = i; iterator.hasNext(); j++) {
9609                key = (String) iterator.next();
9610                assertEquals(new Integer(j + 1).toString(), key);
9611            }
9612            assertEquals(108, j);
9613        }
9614
9615        startKey = new Integer(109).toString();
9616        try {
9617            keySet.tailSet(startKey);
9618            fail("should throw IllegalArgumentException");
9619        } catch (IllegalArgumentException e) {
9620            // Expected
9621        }
9622        try {
9623            keySet.tailSet(startKey, true);
9624            fail("should throw IllegalArgumentException");
9625        } catch (IllegalArgumentException e) {
9626            // Expected
9627        }
9628        tailSet = keySet.tailSet(startKey, false);
9629        iterator = tailSet.iterator();
9630        for (index = 109; iterator.hasNext(); index++) {
9631            key = (String) iterator.next();
9632            assertEquals(new Integer(index + 1).toString(), key);
9633        }
9634        assertEquals(109, index);
9635
9636        startKey = new Integer(110).toString();
9637        try {
9638            keySet.tailSet(startKey);
9639            fail("should throw IllegalArgumentException");
9640        } catch (IllegalArgumentException e) {
9641            // Expected
9642        }
9643        try {
9644            keySet.tailSet(startKey, true);
9645            fail("should throw IllegalArgumentException");
9646        } catch (IllegalArgumentException e) {
9647            // Expected
9648        }
9649        try {
9650            keySet.tailSet(startKey, false);
9651            fail("should throw IllegalArgumentException");
9652        } catch (IllegalArgumentException e) {
9653            // Expected
9654        }
9655
9656        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
9657        startKey = new Integer(99).toString();
9658        try {
9659            keySet.tailSet(startKey);
9660            fail("should throw IllegalArgumentException");
9661        } catch (IllegalArgumentException e) {
9662            // Expected
9663        }
9664        try {
9665            keySet.tailSet(startKey, true);
9666            fail("should throw IllegalArgumentException");
9667        } catch (IllegalArgumentException e) {
9668            // Expected
9669        }
9670        try {
9671            keySet.tailSet(startKey, false);
9672            fail("should throw IllegalArgumentException");
9673        } catch (IllegalArgumentException e) {
9674            // Expected
9675        }
9676        startKey = new Integer(100).toString();
9677        tailSet = keySet.tailSet(startKey);
9678        iterator = tailSet.iterator();
9679        for (index = 100; iterator.hasNext(); index++) {
9680            key = (String) iterator.next();
9681            assertEquals(new Integer(index).toString(), key);
9682        }
9683        assertEquals(110, index);
9684
9685        tailSet = keySet.tailSet(startKey, true);
9686        iterator = tailSet.iterator();
9687        for (index = 100; iterator.hasNext(); index++) {
9688            key = (String) iterator.next();
9689            assertEquals(new Integer(index).toString(), key);
9690        }
9691        assertEquals(110, index);
9692
9693        tailSet = keySet.tailSet(startKey, false);
9694        iterator = tailSet.iterator();
9695        for (index = 100; iterator.hasNext(); index++) {
9696            key = (String) iterator.next();
9697            assertEquals(new Integer(index + 1).toString(), key);
9698        }
9699        assertEquals(109, index);
9700
9701        startKey = new Integer(101).toString();
9702        tailSet = keySet.tailSet(startKey);
9703        iterator = tailSet.iterator();
9704        for (index = 101; iterator.hasNext(); index++) {
9705            key = (String) iterator.next();
9706            assertEquals(new Integer(index).toString(), key);
9707        }
9708        assertEquals(110, index);
9709
9710        tailSet = keySet.tailSet(startKey, true);
9711        iterator = tailSet.iterator();
9712        for (index = 101; iterator.hasNext(); index++) {
9713            key = (String) iterator.next();
9714            assertEquals(new Integer(index).toString(), key);
9715        }
9716        assertEquals(110, index);
9717
9718        tailSet = keySet.tailSet(startKey, false);
9719        iterator = tailSet.iterator();
9720        for (index = 101; iterator.hasNext(); index++) {
9721            key = (String) iterator.next();
9722            assertEquals(new Integer(index + 1).toString(), key);
9723        }
9724        assertEquals(109, index);
9725
9726        for (int i = 102; i < 109; i++) {
9727            startKey = new Integer(i).toString();
9728
9729            tailSet = keySet.tailSet(startKey);
9730            iterator = tailSet.iterator();
9731            int j;
9732            for (j = i; iterator.hasNext(); j++) {
9733                key = (String) iterator.next();
9734                assertEquals(new Integer(j).toString(), key);
9735            }
9736            assertEquals(110, j);
9737
9738            tailSet = keySet.tailSet(startKey, true);
9739            iterator = tailSet.iterator();
9740            for (j = i; iterator.hasNext(); j++) {
9741                key = (String) iterator.next();
9742                assertEquals(new Integer(j).toString(), key);
9743            }
9744            assertEquals(110, j);
9745
9746            tailSet = keySet.tailSet(startKey, false);
9747            iterator = tailSet.iterator();
9748            for (j = i; iterator.hasNext(); j++) {
9749                key = (String) iterator.next();
9750                assertEquals(new Integer(j + 1).toString(), key);
9751            }
9752            assertEquals(109, j);
9753        }
9754
9755        startKey = new Integer(109).toString();
9756        tailSet = keySet.tailSet(startKey);
9757        iterator = tailSet.iterator();
9758        for (index = 109; iterator.hasNext(); index++) {
9759            key = (String) iterator.next();
9760            assertEquals(new Integer(index).toString(), key);
9761        }
9762        assertEquals(110, index);
9763
9764        tailSet = keySet.tailSet(startKey, true);
9765        iterator = tailSet.iterator();
9766        for (index = 109; iterator.hasNext(); index++) {
9767            key = (String) iterator.next();
9768            assertEquals(new Integer(index).toString(), key);
9769        }
9770        assertEquals(110, index);
9771
9772        tailSet = keySet.tailSet(startKey, false);
9773        iterator = tailSet.iterator();
9774        for (index = 109; iterator.hasNext(); index++) {
9775            key = (String) iterator.next();
9776            assertEquals(new Integer(index + 1).toString(), key);
9777        }
9778        assertEquals(109, index);
9779
9780        startKey = new Integer(110).toString();
9781        try {
9782            keySet.tailSet(startKey);
9783            fail("should throw IllegalArgumentException");
9784        } catch (IllegalArgumentException e) {
9785            // Expected
9786        }
9787        try {
9788            keySet.tailSet(startKey, true);
9789            fail("should throw IllegalArgumentException");
9790        } catch (IllegalArgumentException e) {
9791            // Expected
9792        }
9793        try {
9794            keySet.tailSet(startKey, false);
9795            fail("should throw IllegalArgumentException");
9796        } catch (IllegalArgumentException e) {
9797            // Expected
9798        }
9799
9800        String endKey = new Integer(1).toString();
9801        keySet = tm.headMap(endKey, true).navigableKeySet();
9802        iterator = keySet.iterator();
9803        iterator.next();
9804        startKey = (String) iterator.next();
9805        tailSet = keySet.tailSet(startKey);
9806        assertEquals(1, tailSet.size());
9807        Iterator tailSetIterator = tailSet.iterator();
9808        assertEquals(endKey, tailSetIterator.next());
9809        try {
9810            tailSetIterator.next();
9811            fail("should throw NoSuchElementException");
9812        } catch (NoSuchElementException e) {
9813            // Expected
9814        }
9815        try {
9816            keySet.tailSet(null);
9817            fail("should throw NPE");
9818        } catch (NullPointerException e) {
9819            // Expected
9820        }
9821
9822        tailSet = keySet.tailSet(startKey, true);
9823        assertEquals(1, tailSet.size());
9824        tailSetIterator = tailSet.iterator();
9825        assertEquals(endKey, tailSetIterator.next());
9826
9827        tailSet = keySet.tailSet(startKey, false);
9828        assertEquals(0, tailSet.size());
9829        tailSetIterator = tailSet.iterator();
9830        try {
9831            tailSetIterator.next();
9832            fail("should throw NoSuchElementException");
9833        } catch (NoSuchElementException e) {
9834            // Expected
9835        }
9836        try {
9837            keySet.tailSet(null, false);
9838            fail("should throw NPE");
9839        } catch (NullPointerException e) {
9840            // Expected
9841        }
9842        try {
9843            keySet.tailSet(null, true);
9844            fail("should throw NPE");
9845        } catch (NullPointerException e) {
9846            // Expected
9847        }
9848
9849        // With Comparator
9850        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
9851                .navigableKeySet();
9852        startKey = new Integer(99).toString();
9853        try {
9854            keySet.tailSet(startKey);
9855            fail("should throw IllegalArgumentException");
9856        } catch (IllegalArgumentException e) {
9857            // Expected
9858        }
9859
9860        try {
9861            keySet.tailSet(startKey, true);
9862            fail("should throw IllegalArgumentException");
9863        } catch (IllegalArgumentException e) {
9864            // Expected
9865        }
9866
9867        try {
9868            keySet.tailSet(startKey, false);
9869            fail("should throw IllegalArgumentException");
9870        } catch (IllegalArgumentException e) {
9871            // Expected
9872        }
9873
9874        startKey = new Integer(100).toString();
9875        try {
9876            keySet.tailSet(startKey);
9877            fail("should throw IllegalArgumentException");
9878        } catch (IllegalArgumentException e) {
9879            // Expected
9880        }
9881        try {
9882            keySet.tailSet(startKey, true);
9883            fail("should throw IllegalArgumentException");
9884        } catch (IllegalArgumentException e) {
9885            // Expected
9886        }
9887        tailSet = keySet.tailSet(startKey, false);
9888        iterator = tailSet.iterator();
9889        for (index = 101; index < 109; index++) {
9890            key = (String) iterator.next();
9891            assertEquals(new Integer(index).toString(), key);
9892        }
9893
9894        startKey = new Integer(101).toString();
9895        tailSet = keySet.tailSet(startKey);
9896        iterator = tailSet.iterator();
9897        for (index = 101; iterator.hasNext(); index++) {
9898            key = (String) iterator.next();
9899            assertEquals(new Integer(index).toString(), key);
9900        }
9901        assertEquals(109, index);
9902
9903        tailSet = keySet.tailSet(startKey, true);
9904        iterator = tailSet.iterator();
9905        for (index = 101; iterator.hasNext(); index++) {
9906            key = (String) iterator.next();
9907            assertEquals(new Integer(index).toString(), key);
9908        }
9909        assertEquals(109, index);
9910
9911        tailSet = keySet.tailSet(startKey, false);
9912        iterator = tailSet.iterator();
9913        for (index = 101; iterator.hasNext(); index++) {
9914            key = (String) iterator.next();
9915            assertEquals(new Integer(index + 1).toString(), key);
9916        }
9917        assertEquals(108, index);
9918
9919        for (int i = 102; i < 109; i++) {
9920            startKey = new Integer(i).toString();
9921
9922            tailSet = keySet.tailSet(startKey);
9923            iterator = tailSet.iterator();
9924            int j;
9925            for (j = i; iterator.hasNext(); j++) {
9926                key = (String) iterator.next();
9927                assertEquals(new Integer(j).toString(), key);
9928            }
9929            assertEquals(109, j);
9930
9931            tailSet = keySet.tailSet(startKey, true);
9932            iterator = tailSet.iterator();
9933            for (j = i; iterator.hasNext(); j++) {
9934                key = (String) iterator.next();
9935                assertEquals(new Integer(j).toString(), key);
9936            }
9937            assertEquals(109, j);
9938
9939            tailSet = keySet.tailSet(startKey, false);
9940            iterator = tailSet.iterator();
9941            for (j = i; iterator.hasNext(); j++) {
9942                key = (String) iterator.next();
9943                assertEquals(new Integer(j + 1).toString(), key);
9944            }
9945            assertEquals(108, j);
9946        }
9947
9948        startKey = new Integer(109).toString();
9949        try {
9950            keySet.tailSet(startKey);
9951            fail("should throw IllegalArgumentException");
9952        } catch (IllegalArgumentException e) {
9953            // Expected
9954        }
9955        try {
9956            keySet.tailSet(startKey, true);
9957            fail("should throw IllegalArgumentException");
9958        } catch (IllegalArgumentException e) {
9959            // Expected
9960        }
9961        tailSet = keySet.tailSet(startKey, false);
9962        iterator = tailSet.iterator();
9963        for (index = 109; iterator.hasNext(); index++) {
9964            key = (String) iterator.next();
9965            assertEquals(new Integer(index + 1).toString(), key);
9966        }
9967        assertEquals(109, index);
9968
9969        startKey = new Integer(110).toString();
9970        try {
9971            keySet.tailSet(startKey);
9972            fail("should throw IllegalArgumentException");
9973        } catch (IllegalArgumentException e) {
9974            // Expected
9975        }
9976        try {
9977            keySet.tailSet(startKey, true);
9978            fail("should throw IllegalArgumentException");
9979        } catch (IllegalArgumentException e) {
9980            // Expected
9981        }
9982        try {
9983            keySet.tailSet(startKey, false);
9984            fail("should throw IllegalArgumentException");
9985        } catch (IllegalArgumentException e) {
9986            // Expected
9987        }
9988
9989        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
9990        startKey = new Integer(99).toString();
9991        try {
9992            keySet.tailSet(startKey);
9993            fail("should throw IllegalArgumentException");
9994        } catch (IllegalArgumentException e) {
9995            // Expected
9996        }
9997        try {
9998            keySet.tailSet(startKey, true);
9999            fail("should throw IllegalArgumentException");
10000        } catch (IllegalArgumentException e) {
10001            // Expected
10002        }
10003        try {
10004            keySet.tailSet(startKey, false);
10005            fail("should throw IllegalArgumentException");
10006        } catch (IllegalArgumentException e) {
10007            // Expected
10008        }
10009
10010        startKey = new Integer(100).toString();
10011        try {
10012            keySet.tailSet(startKey);
10013            fail("should throw IllegalArgumentException");
10014        } catch (IllegalArgumentException e) {
10015            // Expected
10016        }
10017        try {
10018            keySet.tailSet(startKey, true);
10019            fail("should throw IllegalArgumentException");
10020        } catch (IllegalArgumentException e) {
10021            // Expected
10022        }
10023
10024        tailSet = keySet.tailSet(startKey, false);
10025        iterator = tailSet.iterator();
10026        for (index = 100; iterator.hasNext(); index++) {
10027            key = (String) iterator.next();
10028            assertEquals(new Integer(index + 1).toString(), key);
10029        }
10030        assertEquals(109, index);
10031
10032        for (int i = 102; i < 109; i++) {
10033            startKey = new Integer(i).toString();
10034
10035            tailSet = keySet.tailSet(startKey);
10036            iterator = tailSet.iterator();
10037            int j;
10038            for (j = i; iterator.hasNext(); j++) {
10039                key = (String) iterator.next();
10040                assertEquals(new Integer(j).toString(), key);
10041            }
10042            assertEquals(110, j);
10043
10044            tailSet = keySet.tailSet(startKey, true);
10045            iterator = tailSet.iterator();
10046            for (j = i; iterator.hasNext(); j++) {
10047                key = (String) iterator.next();
10048                assertEquals(new Integer(j).toString(), key);
10049            }
10050            assertEquals(110, j);
10051
10052            tailSet = keySet.tailSet(startKey, false);
10053            iterator = tailSet.iterator();
10054            for (j = i; iterator.hasNext(); j++) {
10055                key = (String) iterator.next();
10056                assertEquals(new Integer(j + 1).toString(), key);
10057            }
10058            assertEquals(109, j);
10059        }
10060
10061        startKey = new Integer(109).toString();
10062        tailSet = keySet.tailSet(startKey);
10063        iterator = tailSet.iterator();
10064        for (index = 109; iterator.hasNext(); index++) {
10065            key = (String) iterator.next();
10066            assertEquals(new Integer(index).toString(), key);
10067        }
10068        assertEquals(110, index);
10069
10070        tailSet = keySet.tailSet(startKey, true);
10071        iterator = tailSet.iterator();
10072        for (index = 109; iterator.hasNext(); index++) {
10073            key = (String) iterator.next();
10074            assertEquals(new Integer(index).toString(), key);
10075        }
10076        assertEquals(110, index);
10077
10078        tailSet = keySet.tailSet(startKey, false);
10079        iterator = tailSet.iterator();
10080        for (index = 109; iterator.hasNext(); index++) {
10081            key = (String) iterator.next();
10082            assertEquals(new Integer(index + 1).toString(), key);
10083        }
10084        assertEquals(109, index);
10085
10086        startKey = new Integer(110).toString();
10087        try {
10088            keySet.tailSet(startKey);
10089            fail("should throw IllegalArgumentException");
10090        } catch (IllegalArgumentException e) {
10091            // Expected
10092        }
10093        try {
10094            keySet.tailSet(startKey, true);
10095            fail("should throw IllegalArgumentException");
10096        } catch (IllegalArgumentException e) {
10097            // Expected
10098        }
10099        try {
10100            keySet.tailSet(startKey, false);
10101            fail("should throw IllegalArgumentException");
10102        } catch (IllegalArgumentException e) {
10103            // Expected
10104        }
10105    }
10106
10107    public void test_AscendingSubMapKeySet_subSet() {
10108        NavigableSet keySet;
10109        SortedSet subSet;
10110        String startKey, endKey, key;
10111        Iterator startIterator, endIterator, subSetIterator;
10112
10113        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10114        startIterator = keySet.iterator();
10115        while (startIterator.hasNext()) {
10116            startKey = (String) startIterator.next();
10117            endIterator = keySet.iterator();
10118            while (endIterator.hasNext()) {
10119                endKey = (String) endIterator.next();
10120                int startIndex = Integer.valueOf(startKey);
10121                int endIndex = Integer.valueOf(endKey);
10122                if (startIndex > endIndex) {
10123                    try {
10124                        keySet.subSet(startKey, endKey);
10125                        fail("should throw IllegalArgumentException");
10126                    } catch (IllegalArgumentException e) {
10127                        // Expected
10128                    }
10129
10130                    try {
10131                        keySet.subSet(startKey, false, endKey, false);
10132                        fail("shoudl throw IllegalArgumentException");
10133                    } catch (IllegalArgumentException e) {
10134                        // Expected
10135                    }
10136
10137                    try {
10138                        keySet.subSet(startKey, false, endKey, true);
10139                        fail("shoudl throw IllegalArgumentException");
10140                    } catch (IllegalArgumentException e) {
10141                        // Expected
10142                    }
10143
10144                    try {
10145                        keySet.subSet(startKey, true, endKey, false);
10146                        fail("shoudl throw IllegalArgumentException");
10147                    } catch (IllegalArgumentException e) {
10148                        // Expected
10149                    }
10150
10151                    try {
10152                        keySet.subSet(startKey, true, endKey, true);
10153                        fail("shoudl throw IllegalArgumentException");
10154                    } catch (IllegalArgumentException e) {
10155                        // Expected
10156                    }
10157                } else {
10158                    subSet = keySet.subSet(startKey, endKey);
10159                    subSetIterator = subSet.iterator();
10160                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10161                        assertEquals(new Integer(index).toString(),
10162                                subSetIterator.next());
10163                    }
10164
10165                    subSet = keySet.subSet(startKey, false, endKey, false);
10166                    subSetIterator = subSet.iterator();
10167                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10168                        assertEquals(new Integer(index).toString(),
10169                                subSetIterator.next());
10170                    }
10171
10172                    subSet = keySet.subSet(startKey, false, endKey, true);
10173                    subSetIterator = subSet.iterator();
10174                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10175                        assertEquals(new Integer(index).toString(),
10176                                subSetIterator.next());
10177                    }
10178
10179                    subSet = keySet.subSet(startKey, true, endKey, false);
10180                    subSetIterator = subSet.iterator();
10181                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10182                        assertEquals(new Integer(index).toString(),
10183                                subSetIterator.next());
10184                    }
10185
10186                    subSet = keySet.subSet(startKey, true, endKey, true);
10187                    subSetIterator = subSet.iterator();
10188                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10189                        assertEquals(new Integer(index).toString(),
10190                                subSetIterator.next());
10191                    }
10192                }
10193            }
10194        }
10195
10196        key = new Integer(1).toString();
10197        keySet = tm.headMap(key, true).navigableKeySet();
10198        Iterator iterator = keySet.iterator();
10199        startKey = (String) iterator.next();
10200        endKey = (String) iterator.next();
10201
10202        subSet = keySet.subSet(startKey, endKey);
10203        assertEquals(1, subSet.size());
10204        subSetIterator = subSet.iterator();
10205        assertEquals(new Integer(0).toString(), subSetIterator.next());
10206        try {
10207            subSetIterator.next();
10208            fail("should throw NoSuchElementException");
10209        } catch (NoSuchElementException e) {
10210            // Expected
10211        }
10212
10213        subSet = keySet.subSet(startKey, false, endKey, false);
10214        assertEquals(0, subSet.size());
10215
10216        subSet = keySet.subSet(startKey, false, endKey, true);
10217        assertEquals(1, subSet.size());
10218        subSetIterator = subSet.iterator();
10219        assertEquals(new Integer(1).toString(), subSetIterator.next());
10220        try {
10221            subSetIterator.next();
10222            fail("should throw NoSuchElementException");
10223        } catch (NoSuchElementException e) {
10224            // Expected
10225        }
10226
10227        subSet = keySet.subSet(startKey, true, endKey, false);
10228        assertEquals(1, subSet.size());
10229        subSetIterator = subSet.iterator();
10230        assertEquals(new Integer(0).toString(), subSetIterator.next());
10231        try {
10232            subSetIterator.next();
10233            fail("should throw NoSuchElementException");
10234        } catch (NoSuchElementException e) {
10235            // Expected
10236        }
10237
10238        subSet = keySet.subSet(startKey, true, endKey, true);
10239        assertEquals(2, subSet.size());
10240        subSetIterator = subSet.iterator();
10241        assertEquals(new Integer(0).toString(), subSetIterator.next());
10242        assertEquals(new Integer(1).toString(), subSetIterator.next());
10243        try {
10244            subSetIterator.next();
10245            fail("should throw NoSuchElementException");
10246        } catch (NoSuchElementException e) {
10247            // Expected
10248        }
10249
10250        try {
10251            keySet.subSet(null, null);
10252            fail("should throw NPE");
10253        } catch (NullPointerException e) {
10254            // Expected
10255        }
10256
10257        try {
10258            keySet.subSet(null, false, null, false);
10259            fail("should throw NPE");
10260        } catch (NullPointerException e) {
10261            // Expected
10262        }
10263
10264        try {
10265            keySet.subSet(null, false, null, true);
10266            fail("should throw NPE");
10267        } catch (NullPointerException e) {
10268            // Expected
10269        }
10270
10271        try {
10272            keySet.subSet(null, true, null, false);
10273            fail("should throw NPE");
10274        } catch (NullPointerException e) {
10275            // Expected
10276        }
10277
10278        try {
10279            keySet.subSet(null, true, null, true);
10280            fail("should throw NPE");
10281        } catch (NullPointerException e) {
10282            // Expected
10283        }
10284
10285        try {
10286            keySet.subSet(null, endKey);
10287            fail("should throw NPE");
10288        } catch (NullPointerException e) {
10289            // Expected
10290        }
10291
10292        try {
10293            keySet.subSet(null, false, endKey, false);
10294            fail("should throw NPE");
10295        } catch (NullPointerException e) {
10296            // Expected
10297        }
10298
10299        try {
10300            keySet.subSet(null, false, endKey, true);
10301            fail("should throw NPE");
10302        } catch (NullPointerException e) {
10303            // Expected
10304        }
10305
10306        try {
10307            keySet.subSet(null, true, endKey, false);
10308            fail("should throw NPE");
10309        } catch (NullPointerException e) {
10310            // Expected
10311        }
10312
10313        try {
10314            keySet.subSet(null, true, endKey, true);
10315            fail("should throw NPE");
10316        } catch (NullPointerException e) {
10317            // Expected
10318        }
10319
10320        try {
10321            keySet.subSet(startKey, null);
10322            fail("should throw NPE");
10323        } catch (NullPointerException e) {
10324            // Expected
10325        }
10326
10327        try {
10328            keySet.subSet(startKey, false, null, false);
10329            fail("should throw NPE");
10330        } catch (NullPointerException e) {
10331            // Expected
10332        }
10333
10334        try {
10335            keySet.subSet(startKey, false, null, true);
10336            fail("should throw NPE");
10337        } catch (NullPointerException e) {
10338            // Expected
10339        }
10340
10341        try {
10342            keySet.subSet(startKey, true, null, false);
10343            fail("should throw NPE");
10344        } catch (NullPointerException e) {
10345            // Expected
10346        }
10347
10348        try {
10349            keySet.subSet(startKey, true, null, true);
10350            fail("should throw NPE");
10351        } catch (NullPointerException e) {
10352            // Expected
10353        }
10354
10355        // With Comparator
10356        keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator)
10357                .navigableKeySet();
10358        startIterator = keySet.iterator();
10359        while (startIterator.hasNext()) {
10360            startKey = (String) startIterator.next();
10361            endIterator = keySet.iterator();
10362            while (endIterator.hasNext()) {
10363                endKey = (String) endIterator.next();
10364                int startIndex = Integer.valueOf(startKey);
10365                int endIndex = Integer.valueOf(endKey);
10366                if (startIndex > endIndex) {
10367                    try {
10368                        keySet.subSet(startKey, endKey);
10369                        fail("should throw IllegalArgumentException");
10370                    } catch (IllegalArgumentException e) {
10371                        // Expected
10372                    }
10373
10374                    try {
10375                        keySet.subSet(startKey, false, endKey, false);
10376                        fail("shoudl throw IllegalArgumentException");
10377                    } catch (IllegalArgumentException e) {
10378                        // Expected
10379                    }
10380
10381                    try {
10382                        keySet.subSet(startKey, false, endKey, true);
10383                        fail("shoudl throw IllegalArgumentException");
10384                    } catch (IllegalArgumentException e) {
10385                        // Expected
10386                    }
10387
10388                    try {
10389                        keySet.subSet(startKey, true, endKey, false);
10390                        fail("shoudl throw IllegalArgumentException");
10391                    } catch (IllegalArgumentException e) {
10392                        // Expected
10393                    }
10394
10395                    try {
10396                        keySet.subSet(startKey, true, endKey, true);
10397                        fail("shoudl throw IllegalArgumentException");
10398                    } catch (IllegalArgumentException e) {
10399                        // Expected
10400                    }
10401                } else {
10402                    subSet = keySet.subSet(startKey, endKey);
10403                    subSetIterator = subSet.iterator();
10404                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10405                        assertEquals(new Integer(index).toString(),
10406                                subSetIterator.next());
10407                    }
10408
10409                    subSet = keySet.subSet(startKey, false, endKey, false);
10410                    subSetIterator = subSet.iterator();
10411                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10412                        assertEquals(new Integer(index).toString(),
10413                                subSetIterator.next());
10414                    }
10415
10416                    subSet = keySet.subSet(startKey, false, endKey, true);
10417                    subSetIterator = subSet.iterator();
10418                    for (int index = startIndex + 1; subSetIterator.hasNext(); index++) {
10419                        assertEquals(new Integer(index).toString(),
10420                                subSetIterator.next());
10421                    }
10422
10423                    subSet = keySet.subSet(startKey, true, endKey, false);
10424                    subSetIterator = subSet.iterator();
10425                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10426                        assertEquals(new Integer(index).toString(),
10427                                subSetIterator.next());
10428                    }
10429
10430                    subSet = keySet.subSet(startKey, true, endKey, true);
10431                    subSetIterator = subSet.iterator();
10432                    for (int index = startIndex; subSetIterator.hasNext(); index++) {
10433                        assertEquals(new Integer(index).toString(),
10434                                subSetIterator.next());
10435                    }
10436                }
10437            }
10438        }
10439
10440        key = new Integer(1).toString();
10441        keySet = tm.headMap(key, true).navigableKeySet();
10442        iterator = keySet.iterator();
10443        startKey = (String) iterator.next();
10444        endKey = (String) iterator.next();
10445
10446        subSet = keySet.subSet(startKey, endKey);
10447        assertEquals(1, subSet.size());
10448        subSetIterator = subSet.iterator();
10449        assertEquals(new Integer(0).toString(), subSetIterator.next());
10450        try {
10451            subSetIterator.next();
10452            fail("should throw NoSuchElementException");
10453        } catch (NoSuchElementException e) {
10454            // Expected
10455        }
10456
10457        subSet = keySet.subSet(startKey, false, endKey, false);
10458        assertEquals(0, subSet.size());
10459
10460        subSet = keySet.subSet(startKey, false, endKey, true);
10461        assertEquals(1, subSet.size());
10462        subSetIterator = subSet.iterator();
10463        assertEquals(new Integer(1).toString(), subSetIterator.next());
10464        try {
10465            subSetIterator.next();
10466            fail("should throw NoSuchElementException");
10467        } catch (NoSuchElementException e) {
10468            // Expected
10469        }
10470
10471        subSet = keySet.subSet(startKey, true, endKey, false);
10472        assertEquals(1, subSet.size());
10473        subSetIterator = subSet.iterator();
10474        assertEquals(new Integer(0).toString(), subSetIterator.next());
10475        try {
10476            subSetIterator.next();
10477            fail("should throw NoSuchElementException");
10478        } catch (NoSuchElementException e) {
10479            // Expected
10480        }
10481
10482        subSet = keySet.subSet(startKey, true, endKey, true);
10483        assertEquals(2, subSet.size());
10484        subSetIterator = subSet.iterator();
10485        assertEquals(new Integer(0).toString(), subSetIterator.next());
10486        assertEquals(new Integer(1).toString(), subSetIterator.next());
10487        try {
10488            subSetIterator.next();
10489            fail("should throw NoSuchElementException");
10490        } catch (NoSuchElementException e) {
10491            // Expected
10492        }
10493
10494        try {
10495            keySet.subSet(null, null);
10496            fail("should throw NPE");
10497        } catch (NullPointerException e) {
10498            // Expected
10499        }
10500
10501        try {
10502            keySet.subSet(null, false, null, false);
10503            fail("should throw NPE");
10504        } catch (NullPointerException e) {
10505            // Expected
10506        }
10507
10508        try {
10509            keySet.subSet(null, false, null, true);
10510            fail("should throw NPE");
10511        } catch (NullPointerException e) {
10512            // Expected
10513        }
10514
10515        try {
10516            keySet.subSet(null, true, null, false);
10517            fail("should throw NPE");
10518        } catch (NullPointerException e) {
10519            // Expected
10520        }
10521
10522        try {
10523            keySet.subSet(null, true, null, true);
10524            fail("should throw NPE");
10525        } catch (NullPointerException e) {
10526            // Expected
10527        }
10528
10529        try {
10530            keySet.subSet(null, endKey);
10531            fail("should throw NPE");
10532        } catch (NullPointerException e) {
10533            // Expected
10534        }
10535
10536        try {
10537            keySet.subSet(null, false, endKey, false);
10538            fail("should throw NPE");
10539        } catch (NullPointerException e) {
10540            // Expected
10541        }
10542
10543        try {
10544            keySet.subSet(null, false, endKey, true);
10545            fail("should throw NPE");
10546        } catch (NullPointerException e) {
10547            // Expected
10548        }
10549
10550        try {
10551            keySet.subSet(null, true, endKey, false);
10552            fail("should throw NPE");
10553        } catch (NullPointerException e) {
10554            // Expected
10555        }
10556
10557        try {
10558            keySet.subSet(null, true, endKey, true);
10559            fail("should throw NPE");
10560        } catch (NullPointerException e) {
10561            // Expected
10562        }
10563
10564        try {
10565            keySet.subSet(startKey, null);
10566            fail("should throw NPE");
10567        } catch (NullPointerException e) {
10568            // Expected
10569        }
10570
10571        try {
10572            keySet.subSet(startKey, false, null, false);
10573            fail("should throw NPE");
10574        } catch (NullPointerException e) {
10575            // Expected
10576        }
10577
10578        try {
10579            keySet.subSet(startKey, false, null, true);
10580            fail("should throw NPE");
10581        } catch (NullPointerException e) {
10582            // Expected
10583        }
10584
10585        try {
10586            keySet.subSet(startKey, true, null, false);
10587            fail("should throw NPE");
10588        } catch (NullPointerException e) {
10589            // Expected
10590        }
10591
10592        try {
10593            keySet.subSet(startKey, true, null, true);
10594            fail("should throw NPE");
10595        } catch (NullPointerException e) {
10596            // Expected
10597        }
10598
10599    }
10600
10601    public void test_AscendingSubMapKeySet_lower() {
10602        NavigableSet keySet;
10603        Iterator iterator;
10604        String key, lowerKey;
10605        int value, lowerValue;
10606
10607        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10608        iterator = keySet.iterator();
10609        while (iterator.hasNext()) {
10610            key = (String) iterator.next();
10611            value = Integer.valueOf(key);
10612            lowerKey = (String) keySet.lower(key);
10613            if (value > 101) {
10614                lowerValue = Integer.valueOf(lowerKey);
10615                assertEquals(value - 1, lowerValue);
10616            } else {
10617                assertNull(lowerKey);
10618            }
10619        }
10620
10621        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10622        iterator = keySet.iterator();
10623        while (iterator.hasNext()) {
10624            key = (String) iterator.next();
10625            value = Integer.valueOf(key);
10626            lowerKey = (String) keySet.lower(key);
10627            if (value > 101) {
10628                lowerValue = Integer.valueOf(lowerKey);
10629                assertEquals(value - 1, lowerValue);
10630            } else {
10631                assertNull(lowerKey);
10632            }
10633        }
10634
10635        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10636        iterator = keySet.iterator();
10637        while (iterator.hasNext()) {
10638            key = (String) iterator.next();
10639            value = Integer.valueOf(key);
10640            lowerKey = (String) keySet.lower(key);
10641            if (value > 100) {
10642                lowerValue = Integer.valueOf(lowerKey);
10643                assertEquals(value - 1, lowerValue);
10644            } else {
10645                assertNull(lowerKey);
10646            }
10647        }
10648
10649        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10650        iterator = keySet.iterator();
10651        while (iterator.hasNext()) {
10652            key = (String) iterator.next();
10653            value = Integer.valueOf(key);
10654            lowerKey = (String) keySet.lower(key);
10655            if (value > 100) {
10656                lowerValue = Integer.valueOf(lowerKey);
10657                assertEquals(value - 1, lowerValue);
10658            } else {
10659                assertNull(lowerKey);
10660            }
10661        }
10662
10663        key = new Integer(2).toString();
10664        keySet = tm.headMap(key, true).navigableKeySet();
10665        iterator = keySet.iterator();
10666        iterator.next();// 0
10667        String expectedLowerKey = (String) iterator.next();// 1
10668        assertEquals(expectedLowerKey, keySet.lower(iterator.next()));
10669
10670        try {
10671            keySet.lower(null);
10672            fail("should throw NPE");
10673        } catch (NullPointerException e) {
10674            // Expected
10675        }
10676
10677        key = new Integer(0).toString();
10678        keySet = tm.headMap(key, true).navigableKeySet();
10679        assertNull(keySet.lower(key));
10680
10681        key = new Integer(0).toString();
10682        keySet = tm.headMap(key, false).navigableKeySet();
10683        assertNull(keySet.lower(key));
10684
10685        key = new Integer(999).toString();
10686        keySet = tm.headMap(key, true).navigableKeySet();
10687        assertNotNull(keySet.lower(key));
10688
10689        key = new Integer(999).toString();
10690        keySet = tm.headMap(key, false).navigableKeySet();
10691        assertNotNull(keySet.lower(key));
10692    }
10693
10694    public void test_AscendingSubMapKeySet_higher() {
10695        NavigableSet keySet;
10696        Iterator iterator;
10697        String key, lowerKey;
10698        int value, lowerValue;
10699
10700        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10701        iterator = keySet.iterator();
10702        while (iterator.hasNext()) {
10703            key = (String) iterator.next();
10704            value = Integer.valueOf(key);
10705            lowerKey = (String) keySet.higher(key);
10706            if (value < 108) {
10707                lowerValue = Integer.valueOf(lowerKey);
10708                assertEquals(value + 1, lowerValue);
10709            } else {
10710                assertNull(lowerKey);
10711            }
10712        }
10713
10714        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10715        iterator = keySet.iterator();
10716        while (iterator.hasNext()) {
10717            key = (String) iterator.next();
10718            value = Integer.valueOf(key);
10719            lowerKey = (String) keySet.higher(key);
10720            if (value < 109) {
10721                lowerValue = Integer.valueOf(lowerKey);
10722                assertEquals(value + 1, lowerValue);
10723            } else {
10724                assertNull(lowerKey);
10725            }
10726        }
10727
10728        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10729        iterator = keySet.iterator();
10730        while (iterator.hasNext()) {
10731            key = (String) iterator.next();
10732            value = Integer.valueOf(key);
10733            lowerKey = (String) keySet.higher(key);
10734            if (value < 108) {
10735                lowerValue = Integer.valueOf(lowerKey);
10736                assertEquals(value + 1, lowerValue);
10737            } else {
10738                assertNull(lowerKey);
10739            }
10740        }
10741
10742        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10743        iterator = keySet.iterator();
10744        while (iterator.hasNext()) {
10745            key = (String) iterator.next();
10746            value = Integer.valueOf(key);
10747            lowerKey = (String) keySet.higher(key);
10748            if (value < 109) {
10749                lowerValue = Integer.valueOf(lowerKey);
10750                assertEquals(value + 1, lowerValue);
10751            } else {
10752                assertNull(lowerKey);
10753            }
10754        }
10755
10756        key = new Integer(2).toString();
10757        keySet = tm.headMap(key, true).navigableKeySet();
10758        iterator = keySet.iterator();
10759        iterator.next();// 0
10760        iterator.next();// 1
10761        lowerKey = (String) keySet.higher(iterator.next());
10762        String expectedLowerKey = (String) iterator.next();
10763        assertEquals(expectedLowerKey, lowerKey);
10764
10765        try {
10766            keySet.higher(null);
10767            fail("should throw NPE");
10768        } catch (NullPointerException e) {
10769            // Expected
10770        }
10771
10772        key = new Integer(0).toString();
10773        keySet = tm.headMap(key, true).navigableKeySet();
10774        assertNull(keySet.higher(key));
10775
10776        key = new Integer(0).toString();
10777        keySet = tm.headMap(key, false).navigableKeySet();
10778        assertNull(keySet.higher(key));
10779
10780        key = new Integer(999).toString();
10781        keySet = tm.headMap(key, true).navigableKeySet();
10782        assertNull(keySet.higher(key));
10783
10784        key = new Integer(999).toString();
10785        keySet = tm.headMap(key, false).navigableKeySet();
10786        assertNull(keySet.higher(key));
10787    }
10788
10789    public void test_AscendingSubMapKeySet_ceiling() {
10790        NavigableSet keySet;
10791        String key;
10792        String[] keyArray;
10793
10794        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10795        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10796        for (int i = 0, j = 101; i < keyArray.length; i++) {
10797            key = (String) keySet.ceiling(keyArray[i]);
10798            assertEquals(new Integer(i + j).toString(), key);
10799        }
10800
10801        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10802        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10803        for (int i = 0, j = 101; i < keyArray.length; i++) {
10804            key = (String) keySet.ceiling(keyArray[i]);
10805            assertEquals(new Integer(i + j).toString(), key);
10806        }
10807
10808        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10809        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10810        for (int i = 0, j = 100; i < keyArray.length; i++) {
10811            key = (String) keySet.ceiling(keyArray[i]);
10812            assertEquals(new Integer(i + j).toString(), key);
10813        }
10814
10815        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10816        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10817        for (int i = 0, j = 100; i < keyArray.length; i++) {
10818            key = (String) keySet.ceiling(keyArray[i]);
10819            assertEquals(new Integer(i + j).toString(), key);
10820        }
10821
10822        key = new Integer(2).toString();
10823        keySet = tm.headMap(key, true).navigableKeySet();
10824        Iterator iterator = keySet.iterator();
10825        iterator.next();
10826        assertEquals(new Integer(1).toString(), keySet.ceiling(iterator.next()));
10827
10828        try {
10829            keySet.ceiling(null);
10830            fail("should throw NPE");
10831        } catch (NullPointerException e) {
10832            // Expected
10833        }
10834
10835        key = new Integer(0).toString();
10836        keySet = tm.headMap(key, true).navigableKeySet();
10837        assertEquals(key, keySet.ceiling(key));
10838
10839        key = new Integer(0).toString();
10840        keySet = tm.headMap(key, false).navigableKeySet();
10841        assertNull(keySet.higher(key));
10842
10843        key = new Integer(999).toString();
10844        keySet = tm.headMap(key, true).navigableKeySet();
10845        assertNull(keySet.higher(key));
10846
10847        key = new Integer(999).toString();
10848        keySet = tm.headMap(key, false).navigableKeySet();
10849        assertNull(keySet.higher(key));
10850    }
10851
10852    public void test_AscendingSubMapKeySet_floor() {
10853        NavigableSet keySet;
10854        String key;
10855        String[] keyArray;
10856
10857        keySet = navigableMap_startExcluded_endExcluded.navigableKeySet();
10858        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10859        for (int i = 0, j = 101; i < keyArray.length; i++) {
10860            key = (String) keySet.floor(keyArray[i]);
10861            assertEquals(new Integer(i + j).toString(), key);
10862        }
10863
10864        keySet = navigableMap_startExcluded_endIncluded.navigableKeySet();
10865        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10866        for (int i = 0, j = 101; i < keyArray.length; i++) {
10867            key = (String) keySet.floor(keyArray[i]);
10868            assertEquals(new Integer(i + j).toString(), key);
10869        }
10870
10871        keySet = navigableMap_startIncluded_endExcluded.navigableKeySet();
10872        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10873        for (int i = 0, j = 100; i < keyArray.length; i++) {
10874            key = (String) keySet.floor(keyArray[i]);
10875            assertEquals(new Integer(i + j).toString(), key);
10876        }
10877
10878        keySet = navigableMap_startIncluded_endIncluded.navigableKeySet();
10879        keyArray = (String[]) keySet.toArray(new String[keySet.size()]);
10880        for (int i = 0, j = 100; i < keyArray.length; i++) {
10881            key = (String) keySet.floor(keyArray[i]);
10882            assertEquals(new Integer(i + j).toString(), key);
10883        }
10884
10885        key = new Integer(2).toString();
10886        keySet = tm.headMap(key, true).navigableKeySet();
10887        Iterator iterator = keySet.iterator();
10888        iterator.next();
10889        assertEquals(new Integer(1).toString(), keySet.floor(iterator.next()));
10890
10891        try {
10892            keySet.floor(null);
10893            fail("should throw NPE");
10894        } catch (NullPointerException e) {
10895            // Expected
10896        }
10897
10898        key = new Integer(0).toString();
10899        keySet = tm.headMap(key, true).navigableKeySet();
10900        assertEquals(key, keySet.floor(key));
10901
10902        key = new Integer(0).toString();
10903        keySet = tm.headMap(key, false).navigableKeySet();
10904        assertNull(keySet.floor(key));
10905
10906        key = new Integer(999).toString();
10907        keySet = tm.headMap(key, true).navigableKeySet();
10908        assertEquals(key, keySet.floor(key));
10909
10910        key = new Integer(999).toString();
10911        keySet = tm.headMap(key, false).navigableKeySet();
10912        assertEquals(new Integer(998).toString(), keySet.floor(key));
10913    }
10914
10915    public void test_BoundedEntryIterator_next() {
10916        Iterator iterator = subMap_default.entrySet().iterator();
10917        assertTrue(iterator.hasNext());
10918        for (int i = 100; iterator.hasNext(); i++) {
10919            assertEquals(i, ((Entry) iterator.next()).getValue());
10920        }
10921
10922        try {
10923            iterator.next();
10924            fail("should throw java.util.NoSuchElementException");
10925        } catch (NoSuchElementException e) {
10926            // Expected
10927        }
10928
10929    }
10930
10931    public void test_BoundedKeyIterator_next() {
10932        Iterator iterator = subMap_default.keySet().iterator();
10933        assertTrue(iterator.hasNext());
10934        for (int i = 100; iterator.hasNext(); i++) {
10935            assertEquals(new Integer(i).toString(), iterator.next());
10936        }
10937
10938        try {
10939            iterator.next();
10940            fail("should throw java.util.NoSuchElementException");
10941        } catch (NoSuchElementException e) {
10942            // Expected
10943        }
10944    }
10945
10946    public void test_BoundedValueIterator_next() {
10947        String startKey = new Integer(101).toString();
10948        String endKey = new Integer(108).toString();
10949
10950        Collection values = tm.subMap(startKey, endKey).values();
10951        Iterator iter = values.iterator();
10952        for (int i = 101; i < 108; i++) {
10953            assertEquals(i, iter.next());
10954        }
10955        try {
10956            iter.next();
10957            fail("should throw java.util.NoSuchElementException");
10958        } catch (Exception e) {
10959            // Expected
10960        }
10961    }
10962
10963    /*
10964     * SubMapEntrySet
10965     */
10966    public void test_SubMapEntrySet_Constructor() {
10967    }
10968
10969    public void test_SubMapEntrySet_contains() {
10970        // covered in test_SubMapEntrySet_remove
10971    }
10972
10973    public void test_SubMapEntrySet_iterator() {
10974        Set entrySet = subMap_default.entrySet();
10975        Iterator iterator;
10976        Entry entry;
10977        Integer value = new Integer(100);
10978        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
10979            entry = (Entry) iterator.next();
10980            assertEquals(value.toString(), entry.getKey());
10981            assertEquals(value, entry.getValue());
10982        }
10983        assertEquals(109, value.intValue());
10984        try {
10985            iterator.next();
10986            fail("should throw NoSuchElementException");
10987        } catch (NoSuchElementException e) {
10988            // Expected
10989        }
10990
10991        entrySet = subMap_startExcluded_endExcluded.entrySet();
10992        value = new Integer(101);
10993        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
10994            entry = (Entry) iterator.next();
10995            assertEquals(value.toString(), entry.getKey());
10996            assertEquals(value, entry.getValue());
10997        }
10998        assertEquals(109, value.intValue());
10999        try {
11000            iterator.next();
11001            fail("should throw NoSuchElementException");
11002        } catch (NoSuchElementException e) {
11003            // Expected
11004        }
11005
11006        entrySet = subMap_startExcluded_endIncluded.entrySet();
11007        value = new Integer(101);
11008        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11009            entry = (Entry) iterator.next();
11010            assertEquals(value.toString(), entry.getKey());
11011            assertEquals(value, entry.getValue());
11012        }
11013        assertEquals(110, value.intValue());
11014        try {
11015            iterator.next();
11016            fail("should throw NoSuchElementException");
11017        } catch (NoSuchElementException e) {
11018            // Expected
11019        }
11020
11021        entrySet = subMap_startIncluded_endExcluded.entrySet();
11022        value = new Integer(100);
11023        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11024            entry = (Entry) iterator.next();
11025            assertEquals(value.toString(), entry.getKey());
11026            assertEquals(value, entry.getValue());
11027        }
11028        assertEquals(109, value.intValue());
11029        try {
11030            iterator.next();
11031            fail("should throw NoSuchElementException");
11032        } catch (NoSuchElementException e) {
11033            // Expected
11034        }
11035
11036        entrySet = subMap_startIncluded_endIncluded.entrySet();
11037        value = new Integer(100);
11038        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11039            entry = (Entry) iterator.next();
11040            assertEquals(value.toString(), entry.getKey());
11041            assertEquals(value, entry.getValue());
11042        }
11043        assertEquals(110, value.intValue());
11044        try {
11045            iterator.next();
11046            fail("should throw NoSuchElementException");
11047        } catch (NoSuchElementException e) {
11048            // Expected
11049        }
11050
11051        String startKey = new Integer(-1).toString();
11052        String endKey = new Integer(0).toString();
11053        SortedMap subMap = tm.subMap(startKey, endKey);
11054        entrySet = subMap.entrySet();
11055        iterator = entrySet.iterator();
11056        try {
11057            iterator.next();
11058            fail("should throw NoSuchElementException");
11059        } catch (NoSuchElementException e) {
11060            // Expected
11061        }
11062
11063        endKey = new Integer(1).toString();
11064        subMap = tm.subMap(startKey, endKey);
11065        entrySet = subMap.entrySet();
11066        iterator = entrySet.iterator();
11067        assertEquals(0, ((Entry) iterator.next()).getValue());
11068        try {
11069            iterator.next();
11070            fail("should throw NoSuchElementException");
11071        } catch (NoSuchElementException e) {
11072            // Expected
11073        }
11074
11075        endKey = new Integer(2000).toString();
11076        subMap = tm.subMap(startKey, endKey);
11077        entrySet = subMap.entrySet();
11078        iterator = entrySet.iterator();
11079        for (int i = 0; i < subMap.size(); i++) {
11080            iterator.next();
11081        }
11082        try {
11083            iterator.next();
11084            fail("should throw NoSuchElementException");
11085        } catch (NoSuchElementException e) {
11086            // Expected
11087        }
11088
11089        startKey = new Integer(9).toString();
11090        endKey = new Integer(100).toString();
11091        try {
11092            tm.subMap(startKey, endKey);
11093            fail("should throw IllegalArgumentException");
11094        } catch (IllegalArgumentException e) {
11095            // Expected
11096        }
11097
11098        // With Comparator
11099        entrySet = subMap_default_comparator.entrySet();
11100        value = new Integer(100);
11101        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11102            entry = (Entry) iterator.next();
11103            assertEquals(value.toString(), entry.getKey());
11104            assertEquals(value, entry.getValue());
11105        }
11106        assertEquals(109, value.intValue());
11107        try {
11108            iterator.next();
11109            fail("should throw NoSuchElementException");
11110        } catch (NoSuchElementException e) {
11111            // Expected
11112        }
11113
11114        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
11115        value = new Integer(101);
11116        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11117            entry = (Entry) iterator.next();
11118            assertEquals(value.toString(), entry.getKey());
11119            assertEquals(value, entry.getValue());
11120        }
11121        assertEquals(109, value.intValue());
11122        try {
11123            iterator.next();
11124            fail("should throw NoSuchElementException");
11125        } catch (NoSuchElementException e) {
11126            // Expected
11127        }
11128
11129        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
11130        value = new Integer(101);
11131        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11132            entry = (Entry) iterator.next();
11133            assertEquals(value.toString(), entry.getKey());
11134            assertEquals(value, entry.getValue());
11135        }
11136        assertEquals(110, value.intValue());
11137        try {
11138            iterator.next();
11139            fail("should throw NoSuchElementException");
11140        } catch (NoSuchElementException e) {
11141            // Expected
11142        }
11143
11144        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
11145        value = new Integer(100);
11146        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11147            entry = (Entry) iterator.next();
11148            assertEquals(value.toString(), entry.getKey());
11149            assertEquals(value, entry.getValue());
11150        }
11151        assertEquals(109, value.intValue());
11152        try {
11153            iterator.next();
11154            fail("should throw NoSuchElementException");
11155        } catch (NoSuchElementException e) {
11156            // Expected
11157        }
11158
11159        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
11160        value = new Integer(100);
11161        for (iterator = entrySet.iterator(); iterator.hasNext(); value++) {
11162            entry = (Entry) iterator.next();
11163            assertEquals(value.toString(), entry.getKey());
11164            assertEquals(value, entry.getValue());
11165        }
11166        assertEquals(110, value.intValue());
11167        try {
11168            iterator.next();
11169            fail("should throw NoSuchElementException");
11170        } catch (NoSuchElementException e) {
11171            // Expected
11172        }
11173    }
11174
11175    public void test_SubMapEntrySet_remove() {
11176        Set entrySet = subMap_default.entrySet();
11177        assertFalse(entrySet.remove(null));
11178        int size = entrySet.size();
11179        for (int i = 0; i < size; i++) {
11180            Iterator iterator = entrySet.iterator();
11181            assertTrue(entrySet.remove(iterator.next()));
11182        }
11183
11184        entrySet = subMap_startExcluded_endExcluded.entrySet();
11185        assertFalse(entrySet.remove(null));
11186        size = entrySet.size();
11187        for (int i = 0; i < size; i++) {
11188            Iterator iterator = entrySet.iterator();
11189            assertTrue(entrySet.remove(iterator.next()));
11190        }
11191
11192        entrySet = subMap_startExcluded_endIncluded.entrySet();
11193        assertFalse(entrySet.remove(null));
11194        size = entrySet.size();
11195        for (int i = 0; i < size; i++) {
11196            Iterator iterator = entrySet.iterator();
11197            assertTrue(entrySet.remove(iterator.next()));
11198        }
11199
11200        entrySet = subMap_startIncluded_endExcluded.entrySet();
11201        assertFalse(entrySet.remove(null));
11202        size = entrySet.size();
11203        for (int i = 0; i < size; i++) {
11204            Iterator iterator = entrySet.iterator();
11205            assertTrue(entrySet.remove(iterator.next()));
11206        }
11207
11208        entrySet = subMap_startIncluded_endIncluded.entrySet();
11209        assertFalse(entrySet.remove(null));
11210        size = entrySet.size();
11211        for (int i = 0; i < size; i++) {
11212            Iterator iterator = entrySet.iterator();
11213            assertTrue(entrySet.remove(iterator.next()));
11214        }
11215    }
11216
11217    public void test_SubMapEntrySet_isEmpty() {
11218        assertFalse(subMap_default.entrySet().isEmpty());
11219        assertFalse(subMap_startExcluded_endExcluded.entrySet().isEmpty());
11220        assertFalse(subMap_startExcluded_endIncluded.entrySet().isEmpty());
11221        assertFalse(subMap_startIncluded_endExcluded.entrySet().isEmpty());
11222        assertFalse(subMap_startIncluded_endIncluded.entrySet().isEmpty());
11223
11224        String startKey = new Integer(0).toString();
11225        String endKey = startKey;
11226        SortedMap subMap = tm.subMap(startKey, endKey);
11227        assertTrue(subMap.entrySet().isEmpty());
11228
11229        startKey = new Integer(-1).toString();
11230        subMap = tm.subMap(startKey, endKey);
11231        assertTrue(subMap.entrySet().isEmpty());
11232
11233        endKey = new Integer(1).toString();
11234        subMap = tm.subMap(startKey, endKey);
11235        assertFalse(subMap.entrySet().isEmpty());
11236    }
11237
11238    public void test_SubMapEntrySet_size() {
11239        assertEquals(9, subMap_default.entrySet().size());
11240        assertEquals(8, subMap_startExcluded_endExcluded.entrySet().size());
11241        assertEquals(9, subMap_startExcluded_endIncluded.entrySet().size());
11242        assertEquals(9, subMap_startIncluded_endExcluded.entrySet().size());
11243        assertEquals(10, subMap_startIncluded_endIncluded.entrySet().size());
11244
11245        String startKey = new Integer(0).toString();
11246        String endKey = new Integer(2).toString();
11247        SortedMap subMap = tm.subMap(startKey, endKey);
11248        assertEquals(112, subMap.entrySet().size());
11249
11250        startKey = new Integer(0).toString();
11251        endKey = startKey;
11252        subMap = tm.subMap(startKey, endKey);
11253        assertEquals(0, subMap.entrySet().size());
11254
11255        startKey = new Integer(-1).toString();
11256        endKey = startKey;
11257        subMap = tm.subMap(startKey, endKey);
11258        assertEquals(0, subMap.entrySet().size());
11259
11260        endKey = new Integer(1).toString();
11261        subMap = tm.subMap(startKey, endKey);
11262        assertEquals(1, subMap.entrySet().size());
11263
11264        startKey = new Integer(999).toString();
11265        endKey = startKey;
11266        subMap = tm.subMap(startKey, endKey);
11267        assertEquals(0, subMap.entrySet().size());
11268    }
11269
11270    /*
11271     * SubMapKeySet
11272     */
11273    public void test_SubMapKeySet_Constructor() {
11274        // covered in other test
11275    }
11276
11277    public void test_SubMapKeySet_iterator() {
11278        Set keySet = subMap_default.keySet();
11279        Iterator iterator = keySet.iterator();
11280        for (int i = 0; i < keySet.size(); i++) {
11281            assertEquals(new Integer(100 + i).toString(), iterator.next());
11282        }
11283        assertFalse(iterator.hasNext());
11284        try {
11285            iterator.next();
11286            fail("should throw NoSuchElementException");
11287        } catch (NoSuchElementException e) {
11288            // Expected
11289        }
11290
11291        keySet = subMap_startExcluded_endExcluded.keySet();
11292        iterator = keySet.iterator();
11293        for (int i = 0; i < keySet.size(); i++) {
11294            assertEquals(new Integer(101 + i).toString(), iterator.next());
11295        }
11296        assertFalse(iterator.hasNext());
11297        try {
11298            iterator.next();
11299            fail("should throw NoSuchElementException");
11300        } catch (NoSuchElementException e) {
11301            // Expected
11302        }
11303
11304        keySet = subMap_startExcluded_endIncluded.keySet();
11305        iterator = keySet.iterator();
11306        for (int i = 0; i < keySet.size(); i++) {
11307            assertEquals(new Integer(101 + i).toString(), iterator.next());
11308        }
11309        assertFalse(iterator.hasNext());
11310        try {
11311            iterator.next();
11312            fail("should throw NoSuchElementException");
11313        } catch (NoSuchElementException e) {
11314            // Expected
11315        }
11316
11317        keySet = subMap_startIncluded_endExcluded.keySet();
11318        iterator = keySet.iterator();
11319        for (int i = 0; i < keySet.size(); i++) {
11320            assertEquals(new Integer(100 + i).toString(), iterator.next());
11321        }
11322        assertFalse(iterator.hasNext());
11323        try {
11324            iterator.next();
11325            fail("should throw NoSuchElementException");
11326        } catch (NoSuchElementException e) {
11327            // Expected
11328        }
11329
11330        keySet = subMap_startIncluded_endIncluded.keySet();
11331        iterator = keySet.iterator();
11332        for (int i = 0; i < keySet.size(); i++) {
11333            assertEquals(new Integer(100 + i).toString(), iterator.next());
11334        }
11335        assertFalse(iterator.hasNext());
11336        try {
11337            iterator.next();
11338            fail("should throw NoSuchElementException");
11339        } catch (NoSuchElementException e) {
11340            // Expected
11341        }
11342
11343        // With Comparator
11344        keySet = subMap_default_comparator.keySet();
11345        iterator = keySet.iterator();
11346        for (int i = 0; i < keySet.size(); i++) {
11347            assertEquals(new Integer(100 + i).toString(), iterator.next());
11348        }
11349        assertFalse(iterator.hasNext());
11350        try {
11351            iterator.next();
11352            fail("should throw NoSuchElementException");
11353        } catch (NoSuchElementException e) {
11354            // Expected
11355        }
11356
11357        keySet = subMap_startExcluded_endExcluded_comparator.keySet();
11358        iterator = keySet.iterator();
11359        for (int i = 0; i < keySet.size(); i++) {
11360            assertEquals(new Integer(101 + i).toString(), iterator.next());
11361        }
11362        assertFalse(iterator.hasNext());
11363        try {
11364            iterator.next();
11365            fail("should throw NoSuchElementException");
11366        } catch (NoSuchElementException e) {
11367            // Expected
11368        }
11369
11370        keySet = subMap_startExcluded_endIncluded_comparator.keySet();
11371        iterator = keySet.iterator();
11372        for (int i = 0; i < keySet.size(); i++) {
11373            assertEquals(new Integer(101 + i).toString(), iterator.next());
11374        }
11375        assertFalse(iterator.hasNext());
11376        try {
11377            iterator.next();
11378            fail("should throw NoSuchElementException");
11379        } catch (NoSuchElementException e) {
11380            // Expected
11381        }
11382
11383        keySet = subMap_startIncluded_endExcluded_comparator.keySet();
11384        iterator = keySet.iterator();
11385        for (int i = 0; i < keySet.size(); i++) {
11386            assertEquals(new Integer(100 + i).toString(), iterator.next());
11387        }
11388        assertFalse(iterator.hasNext());
11389        try {
11390            iterator.next();
11391            fail("should throw NoSuchElementException");
11392        } catch (NoSuchElementException e) {
11393            // Expected
11394        }
11395
11396        keySet = subMap_startIncluded_endIncluded_comparator.keySet();
11397        iterator = keySet.iterator();
11398        for (int i = 0; i < keySet.size(); i++) {
11399            assertEquals(new Integer(100 + i).toString(), iterator.next());
11400        }
11401        assertFalse(iterator.hasNext());
11402        try {
11403            iterator.next();
11404            fail("should throw NoSuchElementException");
11405        } catch (NoSuchElementException e) {
11406            // Expected
11407        }
11408    }
11409
11410    public void test_SubMapKeySet_isEmpty() {
11411        assertFalse(subMap_default.keySet().isEmpty());
11412        assertFalse(subMap_startExcluded_endExcluded.keySet().isEmpty());
11413        assertFalse(subMap_startExcluded_endIncluded.keySet().isEmpty());
11414        assertFalse(subMap_startIncluded_endExcluded.keySet().isEmpty());
11415        assertFalse(subMap_startIncluded_endIncluded.keySet().isEmpty());
11416
11417        String startKey = new Integer(0).toString();
11418        String endKey = startKey;
11419        SortedMap subMap = tm.subMap(startKey, endKey);
11420        assertTrue(subMap.keySet().isEmpty());
11421
11422        startKey = new Integer(999).toString();
11423        endKey = startKey;
11424        subMap = tm.subMap(startKey, endKey);
11425        assertTrue(subMap.keySet().isEmpty());
11426
11427        startKey = new Integer(-1).toString();
11428        endKey = new Integer(1).toString();
11429        subMap = tm.subMap(startKey, endKey);
11430        assertFalse(subMap.keySet().isEmpty());
11431
11432        endKey = new Integer(0).toString();
11433        subMap = tm.subMap(startKey, endKey);
11434        assertTrue(subMap.keySet().isEmpty());
11435    }
11436
11437    public void test_SubMapKeySet_contains() {
11438        Set keySet = subMap_default.keySet();
11439        try {
11440            keySet.contains(null);
11441            fail("should throw NullPointerException");
11442        } catch (NullPointerException e) {
11443            // Expected
11444        }
11445        String key = new Integer(-1).toString();
11446        assertFalse(keySet.contains(key));
11447        key = new Integer(99).toString();
11448        assertFalse(keySet.contains(key));
11449        key = new Integer(100).toString();
11450        assertTrue(keySet.contains(key));
11451        for (int i = 101; i < 109; i++) {
11452            key = new Integer(i).toString();
11453            assertTrue(keySet.contains(key));
11454        }
11455        key = new Integer(109).toString();
11456        assertFalse(keySet.contains(key));
11457        key = new Integer(110).toString();
11458        assertFalse(keySet.contains(key));
11459        key = new Integer(1001).toString();
11460        assertFalse(keySet.contains(key));
11461
11462        keySet = subMap_startExcluded_endExcluded.keySet();
11463        try {
11464            keySet.contains(null);
11465            fail("should throw NullPointerException");
11466        } catch (NullPointerException e) {
11467            // Expected
11468        }
11469        key = new Integer(-1).toString();
11470        assertFalse(keySet.contains(key));
11471        key = new Integer(99).toString();
11472        assertFalse(keySet.contains(key));
11473        key = new Integer(100).toString();
11474        assertFalse(keySet.contains(key));
11475        for (int i = 101; i < 109; i++) {
11476            key = new Integer(i).toString();
11477            assertTrue(keySet.contains(key));
11478        }
11479        key = new Integer(109).toString();
11480        assertFalse(keySet.contains(key));
11481        key = new Integer(110).toString();
11482        assertFalse(keySet.contains(key));
11483        key = new Integer(1001).toString();
11484        assertFalse(keySet.contains(key));
11485
11486        keySet = subMap_startExcluded_endIncluded.keySet();
11487        try {
11488            keySet.contains(null);
11489            fail("should throw NullPointerException");
11490        } catch (NullPointerException e) {
11491            // Expected
11492        }
11493        key = new Integer(-1).toString();
11494        assertFalse(keySet.contains(key));
11495        key = new Integer(99).toString();
11496        assertFalse(keySet.contains(key));
11497        key = new Integer(100).toString();
11498        assertFalse(keySet.contains(key));
11499        for (int i = 101; i < 109; i++) {
11500            key = new Integer(i).toString();
11501            assertTrue(keySet.contains(key));
11502        }
11503        key = new Integer(109).toString();
11504        assertTrue(keySet.contains(key));
11505        key = new Integer(110).toString();
11506        assertFalse(keySet.contains(key));
11507        key = new Integer(1001).toString();
11508        assertFalse(keySet.contains(key));
11509
11510        keySet = subMap_startIncluded_endExcluded.keySet();
11511        try {
11512            keySet.contains(null);
11513            fail("should throw NullPointerException");
11514        } catch (NullPointerException e) {
11515            // Expected
11516        }
11517        key = new Integer(-1).toString();
11518        assertFalse(keySet.contains(key));
11519        key = new Integer(99).toString();
11520        assertFalse(keySet.contains(key));
11521        key = new Integer(100).toString();
11522        assertTrue(keySet.contains(key));
11523        for (int i = 101; i < 109; i++) {
11524            key = new Integer(i).toString();
11525            assertTrue(keySet.contains(key));
11526        }
11527        key = new Integer(109).toString();
11528        assertFalse(keySet.contains(key));
11529        key = new Integer(110).toString();
11530        assertFalse(keySet.contains(key));
11531        key = new Integer(1001).toString();
11532        assertFalse(keySet.contains(key));
11533
11534        keySet = subMap_startIncluded_endIncluded.keySet();
11535        try {
11536            keySet.contains(null);
11537            fail("should throw NullPointerException");
11538        } catch (NullPointerException e) {
11539            // Expected
11540        }
11541        key = new Integer(-1).toString();
11542        assertFalse(keySet.contains(key));
11543        key = new Integer(99).toString();
11544        assertFalse(keySet.contains(key));
11545        key = new Integer(100).toString();
11546        assertTrue(keySet.contains(key));
11547        for (int i = 101; i < 109; i++) {
11548            key = new Integer(i).toString();
11549            assertTrue(keySet.contains(key));
11550        }
11551        key = new Integer(109).toString();
11552        assertTrue(keySet.contains(key));
11553        key = new Integer(110).toString();
11554        assertFalse(keySet.contains(key));
11555        key = new Integer(1001).toString();
11556        assertFalse(keySet.contains(key));
11557    }
11558
11559    public void test_SubMapKeySet_size() {
11560        assertEquals(9, subMap_default.keySet().size());
11561        assertEquals(8, subMap_startExcluded_endExcluded.keySet().size());
11562        assertEquals(9, subMap_startExcluded_endIncluded.keySet().size());
11563        assertEquals(9, subMap_startIncluded_endExcluded.keySet().size());
11564        assertEquals(10, subMap_startIncluded_endIncluded.keySet().size());
11565
11566        String startKey = new Integer(0).toString();
11567        String endKey = new Integer(2).toString();
11568        SortedMap subMap = tm.subMap(startKey, endKey);
11569        assertEquals(112, subMap.keySet().size());
11570
11571        startKey = new Integer(0).toString();
11572        endKey = startKey;
11573        subMap = tm.subMap(startKey, endKey);
11574        assertEquals(0, subMap.keySet().size());
11575
11576        startKey = new Integer(-1).toString();
11577        endKey = startKey;
11578        subMap = tm.subMap(startKey, endKey);
11579        assertEquals(0, subMap.keySet().size());
11580
11581        endKey = new Integer(1).toString();
11582        subMap = tm.subMap(startKey, endKey);
11583        assertEquals(1, subMap.keySet().size());
11584
11585        startKey = new Integer(999).toString();
11586        endKey = startKey;
11587        subMap = tm.subMap(startKey, endKey);
11588        assertEquals(0, subMap.keySet().size());
11589    }
11590
11591    public void test_SubMapKeySet_remove() {
11592        Set keySet = subMap_default.keySet();
11593        try {
11594            keySet.remove(null);
11595            fail("should throw NullPointerException");
11596        } catch (NullPointerException e) {
11597            // Expected
11598        }
11599        int size = keySet.size();
11600        for (int i = 0; i < size; i++) {
11601            Iterator iterator = keySet.iterator();
11602            assertTrue(keySet.remove(iterator.next()));
11603        }
11604
11605        keySet = subMap_startExcluded_endExcluded.keySet();
11606        try {
11607            keySet.remove(null);
11608            fail("should throw NullPointerException");
11609        } catch (NullPointerException e) {
11610            // Expected
11611        }
11612        size = keySet.size();
11613        for (int i = 0; i < size; i++) {
11614            Iterator iterator = keySet.iterator();
11615            assertTrue(keySet.remove(iterator.next()));
11616        }
11617
11618        keySet = subMap_startExcluded_endIncluded.keySet();
11619        try {
11620            keySet.remove(null);
11621            fail("should throw NullPointerException");
11622        } catch (NullPointerException e) {
11623            // Expected
11624        }
11625        size = keySet.size();
11626        for (int i = 0; i < size; i++) {
11627            Iterator iterator = keySet.iterator();
11628            assertTrue(keySet.remove(iterator.next()));
11629        }
11630
11631        keySet = subMap_startIncluded_endExcluded.keySet();
11632        try {
11633            keySet.remove(null);
11634            fail("should throw NullPointerException");
11635        } catch (NullPointerException e) {
11636            // Expected
11637        }
11638        size = keySet.size();
11639        for (int i = 0; i < size; i++) {
11640            Iterator iterator = keySet.iterator();
11641            assertTrue(keySet.remove(iterator.next()));
11642        }
11643
11644        keySet = subMap_startIncluded_endIncluded.keySet();
11645        try {
11646            keySet.remove(null);
11647            fail("should throw NullPointerException");
11648        } catch (NullPointerException e) {
11649            // Expected
11650        }
11651        size = keySet.size();
11652        for (int i = 0; i < size; i++) {
11653            Iterator iterator = keySet.iterator();
11654            assertTrue(keySet.remove(iterator.next()));
11655        }
11656    }
11657
11658    /*
11659     * AscendingSubMapEntrySet
11660     */
11661
11662    public void test_AscendingSubMapEntrySet_comparator() {
11663        Set entrySet;
11664        NavigableSet ascendingSubMapEntrySet;
11665
11666        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11667        if (entrySet instanceof NavigableSet) {
11668            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11669            assertNull(ascendingSubMapEntrySet.comparator());
11670        }
11671
11672        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11673        if (entrySet instanceof NavigableSet) {
11674            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11675            assertNull(ascendingSubMapEntrySet.comparator());
11676        }
11677
11678        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11679        if (entrySet instanceof NavigableSet) {
11680            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11681            assertNull(ascendingSubMapEntrySet.comparator());
11682        }
11683
11684        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11685        if (entrySet instanceof NavigableSet) {
11686            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11687            assertNull(ascendingSubMapEntrySet.comparator());
11688        }
11689    }
11690
11691    public void test_AscendingSubMapEntrySet_descendingSet() {
11692        Set entrySet;
11693        NavigableSet ascendingSubMapEntrySet, descendingSet;
11694        Entry entry;
11695        int value;
11696        Iterator iterator;
11697
11698        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11699        if (entrySet instanceof NavigableSet) {
11700            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11701            descendingSet = ascendingSubMapEntrySet.descendingSet();
11702            iterator = descendingSet.iterator();
11703            assertTrue(iterator.hasNext());
11704            for (value = 108; iterator.hasNext(); value--) {
11705                entry = (Entry) iterator.next();
11706                assertEquals(value, entry.getValue());
11707            }
11708            assertEquals(100, value);
11709        }
11710
11711        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11712        if (entrySet instanceof NavigableSet) {
11713            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11714            descendingSet = ascendingSubMapEntrySet.descendingSet();
11715            iterator = descendingSet.iterator();
11716            assertTrue(iterator.hasNext());
11717            for (value = 109; iterator.hasNext(); value--) {
11718                entry = (Entry) iterator.next();
11719                assertEquals(value, entry.getValue());
11720            }
11721            assertEquals(100, value);
11722        }
11723
11724        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11725        if (entrySet instanceof NavigableSet) {
11726            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11727            descendingSet = ascendingSubMapEntrySet.descendingSet();
11728            iterator = descendingSet.iterator();
11729            assertTrue(iterator.hasNext());
11730            for (value = 108; iterator.hasNext(); value--) {
11731                entry = (Entry) iterator.next();
11732                assertEquals(value, entry.getValue());
11733            }
11734            assertEquals(99, value);
11735        }
11736
11737        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11738        if (entrySet instanceof NavigableSet) {
11739            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11740            descendingSet = ascendingSubMapEntrySet.descendingSet();
11741            iterator = descendingSet.iterator();
11742            assertTrue(iterator.hasNext());
11743            for (value = 109; iterator.hasNext(); value--) {
11744                entry = (Entry) iterator.next();
11745                assertEquals(value, entry.getValue());
11746            }
11747            assertEquals(99, value);
11748        }
11749    }
11750
11751    public void test_AscendingSubMapEntrySet_descendingIterator() {
11752        Set entrySet;
11753        NavigableSet ascendingSubMapEntrySet;
11754        Iterator iterator;
11755        Entry entry;
11756        int value;
11757
11758        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11759        if (entrySet instanceof NavigableSet) {
11760            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11761            iterator = ascendingSubMapEntrySet.descendingIterator();
11762            assertTrue(iterator.hasNext());
11763            for (value = 108; iterator.hasNext(); value--) {
11764                entry = (Entry) iterator.next();
11765                assertEquals(value, entry.getValue());
11766            }
11767            assertEquals(100, value);
11768        }
11769
11770        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11771        if (entrySet instanceof NavigableSet) {
11772            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11773            iterator = ascendingSubMapEntrySet.descendingIterator();
11774            assertTrue(iterator.hasNext());
11775            for (value = 109; iterator.hasNext(); value--) {
11776                entry = (Entry) iterator.next();
11777                assertEquals(value, entry.getValue());
11778            }
11779            assertEquals(100, value);
11780        }
11781
11782        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11783        if (entrySet instanceof NavigableSet) {
11784            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11785            iterator = ascendingSubMapEntrySet.descendingIterator();
11786            assertTrue(iterator.hasNext());
11787            for (value = 108; iterator.hasNext(); value--) {
11788                entry = (Entry) iterator.next();
11789                assertEquals(value, entry.getValue());
11790            }
11791            assertEquals(99, value);
11792        }
11793
11794        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11795        if (entrySet instanceof NavigableSet) {
11796            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11797            iterator = ascendingSubMapEntrySet.descendingIterator();
11798            assertTrue(iterator.hasNext());
11799            for (value = 109; iterator.hasNext(); value--) {
11800                entry = (Entry) iterator.next();
11801                assertEquals(value, entry.getValue());
11802            }
11803            assertEquals(99, value);
11804        }
11805
11806        String startKey = new Integer(2).toString();
11807        entrySet = tm.headMap(startKey, true).entrySet();
11808        if (entrySet instanceof NavigableSet) {
11809            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11810            iterator = ascendingSubMapEntrySet.descendingIterator();
11811            assertTrue(iterator.hasNext());
11812            assertEquals(2, ((Entry) iterator.next()).getValue());
11813        }
11814    }
11815
11816    public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() {
11817        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11818        if (entrySet instanceof NavigableSet) {
11819            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11820            for (int value = 101; value < 109; value++) {
11821                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11822                assertEquals(value, entry.getValue());
11823            }
11824            assertTrue(ascendingSubMapEntrySet.isEmpty());
11825            // should return null if the set is empty.
11826            assertNull(ascendingSubMapEntrySet.pollFirst());
11827        }
11828    }
11829
11830    public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() {
11831        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11832        if (entrySet instanceof NavigableSet) {
11833            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11834            for (int value = 101; value < 110; value++) {
11835                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11836                assertEquals(value, entry.getValue());
11837            }
11838            assertTrue(ascendingSubMapEntrySet.isEmpty());
11839            // should return null if the set is empty.
11840            assertNull(ascendingSubMapEntrySet.pollFirst());
11841        }
11842    }
11843
11844    public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() {
11845        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11846        if (entrySet instanceof NavigableSet) {
11847            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11848            for (int value = 100; value < 109; value++) {
11849                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11850                assertEquals(value, entry.getValue());
11851            }
11852            assertTrue(ascendingSubMapEntrySet.isEmpty());
11853            // should return null if the set is empty.
11854            assertNull(ascendingSubMapEntrySet.pollFirst());
11855        }
11856    }
11857
11858    public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endIncluded() {
11859        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11860        if (entrySet instanceof NavigableSet) {
11861            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11862            for (int value = 100; value < 110; value++) {
11863                Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst();
11864                assertEquals(value, entry.getValue());
11865            }
11866            assertTrue(ascendingSubMapEntrySet.isEmpty());
11867            // should return null if the set is empty.
11868            assertNull(ascendingSubMapEntrySet.pollFirst());
11869        }
11870    }
11871
11872    public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endExcluded() {
11873        Set entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11874        if (entrySet instanceof NavigableSet) {
11875            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11876            for (int value = 108; value > 100; value--) {
11877                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
11878                assertEquals(value, entry.getValue());
11879            }
11880            assertTrue(ascendingSubMapEntrySet.isEmpty());
11881            // should return null if the set is empty
11882            assertNull(ascendingSubMapEntrySet.pollLast());
11883        }
11884
11885        // NavigableMap ascendingSubMap = tm.headMap("2", true);
11886        // Set entrySet = ascendingSubMap.entrySet();
11887        // Object last;
11888        // if (entrySet instanceof NavigableSet) {
11889        // last = ((NavigableSet) entrySet).pollLast();
11890        // assertEquals("2=2", last.toString());
11891        // }
11892        //
11893        // ascendingSubMap = tm.tailMap("2", true);
11894        // entrySet = ascendingSubMap.entrySet();
11895        // if (entrySet instanceof NavigableSet) {
11896        // last = ((NavigableSet) entrySet).pollLast();
11897        // assertEquals("999=999", last.toString());
11898        // }
11899    }
11900
11901    public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endIncluded() {
11902        Set entrySet = navigableMap_startExcluded_endIncluded.entrySet();
11903        if (entrySet instanceof NavigableSet) {
11904            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11905            for (int value = 109; value > 100; value--) {
11906                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
11907                assertEquals(value, entry.getValue());
11908            }
11909            assertTrue(ascendingSubMapEntrySet.isEmpty());
11910            // should return null if the set is empty
11911            assertNull(ascendingSubMapEntrySet.pollLast());
11912        }
11913    }
11914
11915    public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endExcluded() {
11916        Set entrySet = navigableMap_startIncluded_endExcluded.entrySet();
11917        if (entrySet instanceof NavigableSet) {
11918            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11919            for (int value = 108; value > 99; value--) {
11920                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
11921                assertEquals(value, entry.getValue());
11922            }
11923            assertTrue(ascendingSubMapEntrySet.isEmpty());
11924            // should return null if the set is empty
11925            assertNull(ascendingSubMapEntrySet.pollLast());
11926        }
11927    }
11928
11929    public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endIncluded() {
11930        Set entrySet = navigableMap_startIncluded_endIncluded.entrySet();
11931        if (entrySet instanceof NavigableSet) {
11932            NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet;
11933            for (int value = 109; value > 99; value--) {
11934                Entry entry = (Entry) ascendingSubMapEntrySet.pollLast();
11935                assertEquals(value, entry.getValue());
11936            }
11937            assertTrue(ascendingSubMapEntrySet.isEmpty());
11938            // should return null if the set is empty
11939            assertNull(ascendingSubMapEntrySet.pollLast());
11940        }
11941    }
11942
11943    public void test_AscendingSubMapEntrySet_headSet() {
11944        Set entrySet, headSet;
11945        NavigableSet ascendingSubMapEntrySet;
11946        Iterator iterator, headSetIterator;
11947        Entry entry;
11948        int value;
11949
11950        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
11951        if (entrySet instanceof NavigableSet) {
11952            ascendingSubMapEntrySet = (NavigableSet) entrySet;
11953            iterator = ascendingSubMapEntrySet.iterator();
11954            while (iterator.hasNext()) {
11955                entry = (Entry) iterator.next();
11956                headSet = ascendingSubMapEntrySet.headSet(entry);
11957                headSetIterator = headSet.iterator();
11958                for (value = 101; headSetIterator.hasNext(); value++) {
11959                    assertEquals(value, ((Entry) headSetIterator.next())
11960                            .getValue());
11961                }
11962                assertEquals(entry.getValue(), value);
11963                try {
11964                    headSetIterator.next();
11965                    fail("should throw NoSuchElementException");
11966                } catch (NoSuchElementException e) {
11967                    // Expected
11968                }
11969
11970                headSet = ascendingSubMapEntrySet.headSet(entry, false);
11971                headSetIterator = headSet.iterator();
11972                for (value = 101; headSetIterator.hasNext(); value++) {
11973                    assertEquals(value, ((Entry) headSetIterator.next())
11974                            .getValue());
11975                }
11976                assertEquals(entry.getValue(), value);
11977                try {
11978                    headSetIterator.next();
11979                    fail("should throw NoSuchElementException");
11980                } catch (NoSuchElementException e) {
11981                    // Expected
11982                }
11983
11984                headSet = ascendingSubMapEntrySet.headSet(entry, true);
11985                headSetIterator = headSet.iterator();
11986                for (value = 101; headSetIterator.hasNext(); value++) {
11987                    assertEquals(value, ((Entry) headSetIterator.next())
11988                            .getValue());
11989                }
11990                assertEquals(entry.getValue(), value - 1);
11991                try {
11992                    headSetIterator.next();
11993                    fail("should throw NoSuchElementException");
11994                } catch (NoSuchElementException e) {
11995                    // Expected
11996                }
11997            }
11998        }
11999
12000        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12001        if (entrySet instanceof NavigableSet) {
12002            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12003            iterator = ascendingSubMapEntrySet.iterator();
12004            while (iterator.hasNext()) {
12005                entry = (Entry) iterator.next();
12006                headSet = ascendingSubMapEntrySet.headSet(entry);
12007                headSetIterator = headSet.iterator();
12008                for (value = 101; headSetIterator.hasNext(); value++) {
12009                    assertEquals(value, ((Entry) headSetIterator.next())
12010                            .getValue());
12011                }
12012                assertEquals(entry.getValue(), value);
12013                try {
12014                    headSetIterator.next();
12015                    fail("should throw NoSuchElementException");
12016                } catch (NoSuchElementException e) {
12017                    // Expected
12018                }
12019
12020                headSet = ascendingSubMapEntrySet.headSet(entry, false);
12021                headSetIterator = headSet.iterator();
12022                for (value = 101; headSetIterator.hasNext(); value++) {
12023                    assertEquals(value, ((Entry) headSetIterator.next())
12024                            .getValue());
12025                }
12026                assertEquals(entry.getValue(), value);
12027                try {
12028                    headSetIterator.next();
12029                    fail("should throw NoSuchElementException");
12030                } catch (NoSuchElementException e) {
12031                    // Expected
12032                }
12033
12034                headSet = ascendingSubMapEntrySet.headSet(entry, true);
12035                headSetIterator = headSet.iterator();
12036                for (value = 101; headSetIterator.hasNext(); value++) {
12037                    assertEquals(value, ((Entry) headSetIterator.next())
12038                            .getValue());
12039                }
12040                assertEquals(entry.getValue(), value - 1);
12041                try {
12042                    headSetIterator.next();
12043                    fail("should throw NoSuchElementException");
12044                } catch (NoSuchElementException e) {
12045                    // Expected
12046                }
12047            }
12048        }
12049
12050        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12051        if (entrySet instanceof NavigableSet) {
12052            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12053            iterator = ascendingSubMapEntrySet.iterator();
12054            while (iterator.hasNext()) {
12055                entry = (Entry) iterator.next();
12056                headSet = ascendingSubMapEntrySet.headSet(entry);
12057                headSetIterator = headSet.iterator();
12058                for (value = 100; headSetIterator.hasNext(); value++) {
12059                    assertEquals(value, ((Entry) headSetIterator.next())
12060                            .getValue());
12061                }
12062                assertEquals(entry.getValue(), value);
12063                try {
12064                    headSetIterator.next();
12065                    fail("should throw NoSuchElementException");
12066                } catch (NoSuchElementException e) {
12067                    // Expected
12068                }
12069
12070                headSet = ascendingSubMapEntrySet.headSet(entry, false);
12071                headSetIterator = headSet.iterator();
12072                for (value = 100; headSetIterator.hasNext(); value++) {
12073                    assertEquals(value, ((Entry) headSetIterator.next())
12074                            .getValue());
12075                }
12076                assertEquals(entry.getValue(), value);
12077                try {
12078                    headSetIterator.next();
12079                    fail("should throw NoSuchElementException");
12080                } catch (NoSuchElementException e) {
12081                    // Expected
12082                }
12083
12084                headSet = ascendingSubMapEntrySet.headSet(entry, true);
12085                headSetIterator = headSet.iterator();
12086                for (value = 100; headSetIterator.hasNext(); value++) {
12087                    assertEquals(value, ((Entry) headSetIterator.next())
12088                            .getValue());
12089                }
12090                assertEquals(entry.getValue(), value - 1);
12091                try {
12092                    headSetIterator.next();
12093                    fail("should throw NoSuchElementException");
12094                } catch (NoSuchElementException e) {
12095                    // Expected
12096                }
12097            }
12098        }
12099
12100        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12101        if (entrySet instanceof NavigableSet) {
12102            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12103            iterator = ascendingSubMapEntrySet.iterator();
12104            while (iterator.hasNext()) {
12105                entry = (Entry) iterator.next();
12106                headSet = ascendingSubMapEntrySet.headSet(entry);
12107                headSetIterator = headSet.iterator();
12108                for (value = 100; headSetIterator.hasNext(); value++) {
12109                    assertEquals(value, ((Entry) headSetIterator.next())
12110                            .getValue());
12111                }
12112                assertEquals(entry.getValue(), value);
12113                try {
12114                    headSetIterator.next();
12115                    fail("should throw NoSuchElementException");
12116                } catch (NoSuchElementException e) {
12117                    // Expected
12118                }
12119
12120                headSet = ascendingSubMapEntrySet.headSet(entry, false);
12121                headSetIterator = headSet.iterator();
12122                for (value = 100; headSetIterator.hasNext(); value++) {
12123                    assertEquals(value, ((Entry) headSetIterator.next())
12124                            .getValue());
12125                }
12126                assertEquals(entry.getValue(), value);
12127                try {
12128                    headSetIterator.next();
12129                    fail("should throw NoSuchElementException");
12130                } catch (NoSuchElementException e) {
12131                    // Expected
12132                }
12133
12134                headSet = ascendingSubMapEntrySet.headSet(entry, true);
12135                headSetIterator = headSet.iterator();
12136                for (value = 100; headSetIterator.hasNext(); value++) {
12137                    assertEquals(value, ((Entry) headSetIterator.next())
12138                            .getValue());
12139                }
12140                assertEquals(entry.getValue(), value - 1);
12141                try {
12142                    headSetIterator.next();
12143                    fail("should throw NoSuchElementException");
12144                } catch (NoSuchElementException e) {
12145                    // Expected
12146                }
12147            }
12148        }
12149
12150        // NavigableMap ascendingSubMap = tm.headMap("1", true);
12151        // entrySet = ascendingSubMap.entrySet();
12152        // if (entrySet instanceof SortedSet) {
12153        // Iterator it = entrySet.iterator();
12154        // it.next();
12155        // Object end = it.next();// 1=1
12156        // Set headSet = ((NavigableSet) entrySet).headSet(end);// inclusive
12157        // // false
12158        // assertEquals(1, headSet.size());
12159        // }
12160    }
12161
12162    public void test_AscendingSubMapEntrySet_tailSet() {
12163        Set entrySet, tailSet;
12164        NavigableSet ascendingSubMapEntrySet;
12165        Iterator iterator, tailSetIterator;
12166        Entry entry;
12167        int value;
12168
12169        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12170        if (entrySet instanceof NavigableSet) {
12171            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12172            iterator = entrySet.iterator();
12173            while (iterator.hasNext()) {
12174                entry = (Entry) iterator.next();
12175                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12176                tailSetIterator = tailSet.iterator();
12177                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12178                        .hasNext(); value++) {
12179                    assertEquals(value, ((Entry) tailSetIterator.next())
12180                            .getValue());
12181                }
12182                assertEquals(109, value);
12183                try {
12184                    tailSetIterator.next();
12185                    fail("should throw NoSuchElementException");
12186                } catch (NoSuchElementException e) {
12187                    // Expected
12188                }
12189
12190                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12191                tailSetIterator = tailSet.iterator();
12192                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12193                        .hasNext(); value++) {
12194                    assertEquals(value, ((Entry) tailSetIterator.next())
12195                            .getValue());
12196                }
12197                assertEquals(109, value);
12198                try {
12199                    tailSetIterator.next();
12200                    fail("should throw NoSuchElementException");
12201                } catch (NoSuchElementException e) {
12202                    // Expected
12203                }
12204
12205                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12206                tailSetIterator = tailSet.iterator();
12207                for (value = (Integer) entry.getValue(); tailSetIterator
12208                        .hasNext(); value++) {
12209                    assertEquals(value, ((Entry) tailSetIterator.next())
12210                            .getValue());
12211                }
12212                assertEquals(109, value);
12213                try {
12214                    tailSetIterator.next();
12215                    fail("should throw NoSuchElementException");
12216                } catch (NoSuchElementException e) {
12217                    // Expected
12218                }
12219            }
12220        }
12221
12222        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12223        if (entrySet instanceof NavigableSet) {
12224            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12225            iterator = entrySet.iterator();
12226            while (iterator.hasNext()) {
12227                entry = (Entry) iterator.next();
12228                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12229                tailSetIterator = tailSet.iterator();
12230                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12231                        .hasNext(); value++) {
12232                    assertEquals(value, ((Entry) tailSetIterator.next())
12233                            .getValue());
12234                }
12235                assertEquals(110, value);
12236                try {
12237                    tailSetIterator.next();
12238                    fail("should throw NoSuchElementException");
12239                } catch (NoSuchElementException e) {
12240                    // Expected
12241                }
12242
12243                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12244                tailSetIterator = tailSet.iterator();
12245                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12246                        .hasNext(); value++) {
12247                    assertEquals(value, ((Entry) tailSetIterator.next())
12248                            .getValue());
12249                }
12250                assertEquals(110, value);
12251                try {
12252                    tailSetIterator.next();
12253                    fail("should throw NoSuchElementException");
12254                } catch (NoSuchElementException e) {
12255                    // Expected
12256                }
12257
12258                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12259                tailSetIterator = tailSet.iterator();
12260                for (value = (Integer) entry.getValue(); tailSetIterator
12261                        .hasNext(); value++) {
12262                    assertEquals(value, ((Entry) tailSetIterator.next())
12263                            .getValue());
12264                }
12265                assertEquals(110, value);
12266                try {
12267                    tailSetIterator.next();
12268                    fail("should throw NoSuchElementException");
12269                } catch (NoSuchElementException e) {
12270                    // Expected
12271                }
12272            }
12273        }
12274
12275        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12276        if (entrySet instanceof NavigableSet) {
12277            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12278            iterator = entrySet.iterator();
12279            while (iterator.hasNext()) {
12280                entry = (Entry) iterator.next();
12281                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12282                tailSetIterator = tailSet.iterator();
12283                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12284                        .hasNext(); value++) {
12285                    assertEquals(value, ((Entry) tailSetIterator.next())
12286                            .getValue());
12287                }
12288                assertEquals(109, value);
12289                try {
12290                    tailSetIterator.next();
12291                    fail("should throw NoSuchElementException");
12292                } catch (NoSuchElementException e) {
12293                    // Expected
12294                }
12295
12296                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12297                tailSetIterator = tailSet.iterator();
12298                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12299                        .hasNext(); value++) {
12300                    assertEquals(value, ((Entry) tailSetIterator.next())
12301                            .getValue());
12302                }
12303                assertEquals(109, value);
12304                try {
12305                    tailSetIterator.next();
12306                    fail("should throw NoSuchElementException");
12307                } catch (NoSuchElementException e) {
12308                    // Expected
12309                }
12310
12311                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12312                tailSetIterator = tailSet.iterator();
12313                for (value = (Integer) entry.getValue(); tailSetIterator
12314                        .hasNext(); value++) {
12315                    assertEquals(value, ((Entry) tailSetIterator.next())
12316                            .getValue());
12317                }
12318                assertEquals(109, value);
12319                try {
12320                    tailSetIterator.next();
12321                    fail("should throw NoSuchElementException");
12322                } catch (NoSuchElementException e) {
12323                    // Expected
12324                }
12325            }
12326        }
12327
12328        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12329        if (entrySet instanceof NavigableSet) {
12330            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12331            iterator = entrySet.iterator();
12332            while (iterator.hasNext()) {
12333                entry = (Entry) iterator.next();
12334                tailSet = ascendingSubMapEntrySet.tailSet(entry);
12335                tailSetIterator = tailSet.iterator();
12336                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12337                        .hasNext(); value++) {
12338                    assertEquals(value, ((Entry) tailSetIterator.next())
12339                            .getValue());
12340                }
12341                assertEquals(110, value);
12342                try {
12343                    tailSetIterator.next();
12344                    fail("should throw NoSuchElementException");
12345                } catch (NoSuchElementException e) {
12346                    // Expected
12347                }
12348
12349                tailSet = ascendingSubMapEntrySet.tailSet(entry, false);
12350                tailSetIterator = tailSet.iterator();
12351                for (value = (Integer) entry.getValue() + 1; tailSetIterator
12352                        .hasNext(); value++) {
12353                    assertEquals(value, ((Entry) tailSetIterator.next())
12354                            .getValue());
12355                }
12356                assertEquals(110, value);
12357                try {
12358                    tailSetIterator.next();
12359                    fail("should throw NoSuchElementException");
12360                } catch (NoSuchElementException e) {
12361                    // Expected
12362                }
12363
12364                tailSet = ascendingSubMapEntrySet.tailSet(entry, true);
12365                tailSetIterator = tailSet.iterator();
12366                for (value = (Integer) entry.getValue(); tailSetIterator
12367                        .hasNext(); value++) {
12368                    assertEquals(value, ((Entry) tailSetIterator.next())
12369                            .getValue());
12370                }
12371                assertEquals(110, value);
12372                try {
12373                    tailSetIterator.next();
12374                    fail("should throw NoSuchElementException");
12375                } catch (NoSuchElementException e) {
12376                    // Expected
12377                }
12378            }
12379        }
12380
12381        // NavigableMap ascendingSubMap = tm.headMap("1", true);
12382        // Set entrySet = ascendingSubMap.entrySet();
12383        // if (entrySet instanceof NavigableSet) {
12384        // Iterator it = entrySet.iterator();
12385        // Object start = it.next();// 0=0
12386        // Set tailSet = ((NavigableSet) entrySet).tailSet(start);// default
12387        // // inclusive
12388        // // false
12389        // assertEquals(1, tailSet.size());
12390        // }
12391    }
12392
12393    public void test_AscendingSubMapEntrySet_subSet() {
12394        Set entrySet, subSet;
12395        NavigableSet ascendingSubMapEntrySet;
12396
12397        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12398        if (entrySet instanceof NavigableSet) {
12399            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12400            Iterator iteratorStart = ascendingSubMapEntrySet.iterator();
12401            while (iteratorStart.hasNext()) {
12402                Entry startEntry = (Entry) iteratorStart.next();
12403                Iterator iteratorEnd = ascendingSubMapEntrySet.iterator();
12404                while (iteratorEnd.hasNext()) {
12405                    Entry endEntry = (Entry) iteratorEnd.next();
12406                    int startIndex = (Integer) startEntry.getValue();
12407                    int endIndex = (Integer) endEntry.getValue();
12408                    if (startIndex > endIndex) {
12409                        try {
12410                            ascendingSubMapEntrySet
12411                                    .subSet(startEntry, endEntry);
12412                            fail("should throw IllegalArgumentException");
12413                        } catch (IllegalArgumentException e) {
12414                            // Expected
12415                        }
12416
12417                        try {
12418                            ascendingSubMapEntrySet.subSet(startEntry, false,
12419                                    endEntry, false);
12420                            fail("should throw IllegalArgumentException");
12421                        } catch (IllegalArgumentException e) {
12422                            // Expected
12423                        }
12424
12425                        try {
12426                            ascendingSubMapEntrySet.subSet(startEntry, false,
12427                                    endEntry, true);
12428                            fail("should throw IllegalArgumentException");
12429                        } catch (IllegalArgumentException e) {
12430                            // Expected
12431                        }
12432
12433                        try {
12434                            ascendingSubMapEntrySet.subSet(startEntry, true,
12435                                    endEntry, false);
12436                            fail("should throw IllegalArgumentException");
12437                        } catch (IllegalArgumentException e) {
12438                            // Expected
12439                        }
12440
12441                        try {
12442                            ascendingSubMapEntrySet.subSet(startEntry, true,
12443                                    endEntry, true);
12444                            fail("should throw IllegalArgumentException");
12445                        } catch (IllegalArgumentException e) {
12446                            // Expected
12447                        }
12448                    } else {
12449                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12450                                endEntry);
12451                        Iterator subSetIterator = subSet.iterator();
12452                        for (int index = startIndex + 1; subSetIterator
12453                                .hasNext(); index++) {
12454                            assertEquals(index, ((Entry) subSetIterator.next())
12455                                    .getValue());
12456                        }
12457
12458                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12459                                false, endEntry, false);
12460                        subSetIterator = subSet.iterator();
12461                        for (int index = startIndex + 1; subSetIterator
12462                                .hasNext(); index++) {
12463                            assertEquals(index, ((Entry) subSetIterator.next())
12464                                    .getValue());
12465                        }
12466
12467                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12468                                false, endEntry, true);
12469                        subSetIterator = subSet.iterator();
12470                        for (int index = startIndex + 1; subSetIterator
12471                                .hasNext(); index++) {
12472                            assertEquals(index, ((Entry) subSetIterator.next())
12473                                    .getValue());
12474                        }
12475
12476                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12477                                true, endEntry, false);
12478                        subSetIterator = subSet.iterator();
12479                        for (int index = startIndex; subSetIterator.hasNext(); index++) {
12480                            assertEquals(index, ((Entry) subSetIterator.next())
12481                                    .getValue());
12482                        }
12483
12484                        subSet = ascendingSubMapEntrySet.subSet(startEntry,
12485                                true, endEntry, true);
12486                        subSetIterator = subSet.iterator();
12487                        for (int index = startIndex; subSetIterator.hasNext(); index++) {
12488                            assertEquals(index, ((Entry) subSetIterator.next())
12489                                    .getValue());
12490                        }
12491                    }
12492                }
12493            }
12494        }
12495
12496        String endKey = new Integer(2).toString();
12497        entrySet = tm.headMap(endKey, true).entrySet();
12498        if (entrySet instanceof NavigableSet) {
12499            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12500            Iterator iterator = entrySet.iterator();
12501            Object startEntry = iterator.next();
12502            iterator.next();
12503            Object endEntry = iterator.next();
12504            subSet = ascendingSubMapEntrySet.subSet(startEntry, endEntry);
12505            assertEquals(1, subSet.size());
12506
12507            subSet = ascendingSubMapEntrySet.subSet(startEntry, false,
12508                    endEntry, false);
12509            assertEquals(1, subSet.size());
12510
12511            subSet = ascendingSubMapEntrySet.subSet(startEntry, false,
12512                    endEntry, true);
12513            assertEquals(2, subSet.size());
12514
12515            subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry,
12516                    false);
12517            assertEquals(2, subSet.size());
12518
12519            subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry,
12520                    true);
12521            assertEquals(3, subSet.size());
12522        }
12523    }
12524
12525    public void test_AscendingSubMapEntrySet_lower() {
12526        Set entrySet;
12527        NavigableSet ascendingSubMapEntrySet;
12528        Iterator iterator;
12529        Entry entry, lowerEntry;
12530        int value;
12531
12532        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12533        if (entrySet instanceof NavigableSet) {
12534            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12535            iterator = ascendingSubMapEntrySet.iterator();
12536            while (iterator.hasNext()) {
12537                entry = (Entry) iterator.next();
12538                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12539                value = (Integer) entry.getValue();
12540                if (value > 101) {
12541                    assertEquals(value - 1, lowerEntry.getValue());
12542                } else {
12543                    assertNull(lowerEntry);
12544                }
12545            }
12546        }
12547
12548        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12549        if (entrySet instanceof NavigableSet) {
12550            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12551            iterator = ascendingSubMapEntrySet.iterator();
12552            while (iterator.hasNext()) {
12553                entry = (Entry) iterator.next();
12554                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12555                value = (Integer) entry.getValue();
12556                if (value > 101) {
12557                    assertEquals(value - 1, lowerEntry.getValue());
12558                } else {
12559                    assertNull(lowerEntry);
12560                }
12561            }
12562        }
12563
12564        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12565        if (entrySet instanceof NavigableSet) {
12566            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12567            iterator = ascendingSubMapEntrySet.iterator();
12568            while (iterator.hasNext()) {
12569                entry = (Entry) iterator.next();
12570                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12571                value = (Integer) entry.getValue();
12572                if (value > 100) {
12573                    assertEquals(value - 1, lowerEntry.getValue());
12574                } else {
12575                    assertNull(lowerEntry);
12576                }
12577            }
12578        }
12579
12580        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12581        if (entrySet instanceof NavigableSet) {
12582            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12583            iterator = ascendingSubMapEntrySet.iterator();
12584            while (iterator.hasNext()) {
12585                entry = (Entry) iterator.next();
12586                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12587                value = (Integer) entry.getValue();
12588                if (value > 100) {
12589                    assertEquals(value - 1, lowerEntry.getValue());
12590                } else {
12591                    assertNull(lowerEntry);
12592                }
12593            }
12594        }
12595
12596        String endKey = new Integer(2).toString();
12597        entrySet = tm.headMap(endKey, true).entrySet();
12598        if (entrySet instanceof NavigableSet) {
12599            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12600            iterator = entrySet.iterator();
12601            Entry expectedEntry = (Entry) iterator.next();
12602            entry = (Entry) iterator.next();
12603            assertEquals(expectedEntry, ascendingSubMapEntrySet.lower(entry));
12604        }
12605
12606        // With Comparator
12607
12608        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
12609        if (entrySet instanceof NavigableSet) {
12610            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12611            iterator = ascendingSubMapEntrySet.iterator();
12612            while (iterator.hasNext()) {
12613                entry = (Entry) iterator.next();
12614                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12615                value = (Integer) entry.getValue();
12616                if (value > 101) {
12617                    assertEquals(value - 1, lowerEntry.getValue());
12618                } else {
12619                    assertNull(lowerEntry);
12620                }
12621            }
12622        }
12623
12624        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
12625        if (entrySet instanceof NavigableSet) {
12626            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12627            iterator = ascendingSubMapEntrySet.iterator();
12628            while (iterator.hasNext()) {
12629                entry = (Entry) iterator.next();
12630                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12631                value = (Integer) entry.getValue();
12632                if (value > 101) {
12633                    assertEquals(value - 1, lowerEntry.getValue());
12634                } else {
12635                    assertNull(lowerEntry);
12636                }
12637            }
12638        }
12639
12640        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
12641        if (entrySet instanceof NavigableSet) {
12642            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12643            iterator = ascendingSubMapEntrySet.iterator();
12644            while (iterator.hasNext()) {
12645                entry = (Entry) iterator.next();
12646                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12647                value = (Integer) entry.getValue();
12648                if (value > 100) {
12649                    assertEquals(value - 1, lowerEntry.getValue());
12650                } else {
12651                    assertNull(lowerEntry);
12652                }
12653            }
12654        }
12655
12656        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
12657        if (entrySet instanceof NavigableSet) {
12658            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12659            iterator = ascendingSubMapEntrySet.iterator();
12660            while (iterator.hasNext()) {
12661                entry = (Entry) iterator.next();
12662                lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry);
12663                value = (Integer) entry.getValue();
12664                if (value > 100) {
12665                    assertEquals(value - 1, lowerEntry.getValue());
12666                } else {
12667                    assertNull(lowerEntry);
12668                }
12669            }
12670        }
12671    }
12672
12673    public void test_AscendingSubMapEntrySet_higher() {
12674        Set entrySet;
12675        NavigableSet ascendingSubMapEntrySet;
12676        Iterator iterator;
12677        Entry entry, lowerEntry;
12678        int value;
12679
12680        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12681        if (entrySet instanceof NavigableSet) {
12682            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12683            iterator = ascendingSubMapEntrySet.iterator();
12684            while (iterator.hasNext()) {
12685                entry = (Entry) iterator.next();
12686                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12687                value = (Integer) entry.getValue();
12688                if (value < 108) {
12689                    assertEquals(value + 1, lowerEntry.getValue());
12690                } else {
12691                    assertNull(lowerEntry);
12692                }
12693            }
12694        }
12695
12696        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12697        if (entrySet instanceof NavigableSet) {
12698            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12699            iterator = ascendingSubMapEntrySet.iterator();
12700            while (iterator.hasNext()) {
12701                entry = (Entry) iterator.next();
12702                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12703                value = (Integer) entry.getValue();
12704                if (value < 109) {
12705                    assertEquals(value + 1, lowerEntry.getValue());
12706                } else {
12707                    assertNull(lowerEntry);
12708                }
12709            }
12710        }
12711
12712        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12713        if (entrySet instanceof NavigableSet) {
12714            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12715            iterator = ascendingSubMapEntrySet.iterator();
12716            while (iterator.hasNext()) {
12717                entry = (Entry) iterator.next();
12718                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12719                value = (Integer) entry.getValue();
12720                if (value < 108) {
12721                    assertEquals(value + 1, lowerEntry.getValue());
12722                } else {
12723                    assertNull(lowerEntry);
12724                }
12725            }
12726        }
12727
12728        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12729        if (entrySet instanceof NavigableSet) {
12730            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12731            iterator = ascendingSubMapEntrySet.iterator();
12732            while (iterator.hasNext()) {
12733                entry = (Entry) iterator.next();
12734                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12735                value = (Integer) entry.getValue();
12736                if (value < 109) {
12737                    assertEquals(value + 1, lowerEntry.getValue());
12738                } else {
12739                    assertNull(lowerEntry);
12740                }
12741            }
12742        }
12743
12744        String endKey = new Integer(2).toString();
12745        entrySet = tm.headMap(endKey, true).entrySet();
12746        if (entrySet instanceof NavigableSet) {
12747            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12748            iterator = entrySet.iterator();
12749            entry = (Entry) iterator.next();
12750            Entry expectedEntry = (Entry) iterator.next();
12751            assertEquals(expectedEntry, ascendingSubMapEntrySet.higher(entry));
12752        }
12753
12754        // With Comparator
12755        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
12756        if (entrySet instanceof NavigableSet) {
12757            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12758            iterator = ascendingSubMapEntrySet.iterator();
12759            while (iterator.hasNext()) {
12760                entry = (Entry) iterator.next();
12761                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12762                value = (Integer) entry.getValue();
12763                if (value < 108) {
12764                    assertEquals(value + 1, lowerEntry.getValue());
12765                } else {
12766                    assertNull(lowerEntry);
12767                }
12768            }
12769        }
12770
12771        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
12772        if (entrySet instanceof NavigableSet) {
12773            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12774            iterator = ascendingSubMapEntrySet.iterator();
12775            while (iterator.hasNext()) {
12776                entry = (Entry) iterator.next();
12777                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12778                value = (Integer) entry.getValue();
12779                if (value < 109) {
12780                    assertEquals(value + 1, lowerEntry.getValue());
12781                } else {
12782                    assertNull(lowerEntry);
12783                }
12784            }
12785        }
12786
12787        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
12788        if (entrySet instanceof NavigableSet) {
12789            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12790            iterator = ascendingSubMapEntrySet.iterator();
12791            while (iterator.hasNext()) {
12792                entry = (Entry) iterator.next();
12793                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12794                value = (Integer) entry.getValue();
12795                if (value < 108) {
12796                    assertEquals(value + 1, lowerEntry.getValue());
12797                } else {
12798                    assertNull(lowerEntry);
12799                }
12800            }
12801        }
12802
12803        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
12804        if (entrySet instanceof NavigableSet) {
12805            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12806            iterator = ascendingSubMapEntrySet.iterator();
12807            while (iterator.hasNext()) {
12808                entry = (Entry) iterator.next();
12809                lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry);
12810                value = (Integer) entry.getValue();
12811                if (value < 109) {
12812                    assertEquals(value + 1, lowerEntry.getValue());
12813                } else {
12814                    assertNull(lowerEntry);
12815                }
12816            }
12817        }
12818    }
12819
12820    public void test_AscendingSubMapEntrySet_ceiling() {
12821        Set entrySet;
12822        NavigableSet ascendingSubMapEntrySet;
12823        Iterator iterator;
12824
12825        Set entrySet_beyondBound;
12826        Iterator iterator_beyondBound;
12827        Entry beyondBoundEntry;
12828
12829        Entry entry, lowerEntry;
12830        int value = 0;
12831
12832        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
12833        if (entrySet instanceof NavigableSet) {
12834            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12835            try {
12836                ascendingSubMapEntrySet.ceiling(null);
12837                fail("should throw NullPointerException");
12838            } catch (NullPointerException e) {
12839                // Expected
12840            }
12841
12842            iterator = ascendingSubMapEntrySet.iterator();
12843            while (iterator.hasNext()) {
12844                entry = (Entry) iterator.next();
12845                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12846                value = (Integer) entry.getValue();
12847                assertEquals(value, lowerEntry.getValue());
12848            }
12849            assertEquals(108, value);
12850
12851        }
12852
12853        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
12854        if (entrySet instanceof NavigableSet) {
12855            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12856            try {
12857                ascendingSubMapEntrySet.ceiling(null);
12858                fail("should throw NullPointerException");
12859            } catch (NullPointerException e) {
12860                // Expected
12861            }
12862
12863            iterator = ascendingSubMapEntrySet.iterator();
12864            while (iterator.hasNext()) {
12865                entry = (Entry) iterator.next();
12866                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12867                value = (Integer) entry.getValue();
12868                assertEquals(value, lowerEntry.getValue());
12869            }
12870            assertEquals(109, value);
12871        }
12872
12873        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
12874        if (entrySet instanceof NavigableSet) {
12875            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12876            try {
12877                ascendingSubMapEntrySet.ceiling(null);
12878                fail("should throw NullPointerException");
12879            } catch (NullPointerException e) {
12880                // Expected
12881            }
12882
12883            iterator = ascendingSubMapEntrySet.iterator();
12884            while (iterator.hasNext()) {
12885                entry = (Entry) iterator.next();
12886                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12887                value = (Integer) entry.getValue();
12888                assertEquals(value, lowerEntry.getValue());
12889            }
12890            assertEquals(108, value);
12891        }
12892
12893        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
12894        if (entrySet instanceof NavigableSet) {
12895            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12896            try {
12897                ascendingSubMapEntrySet.ceiling(null);
12898                fail("should throw NullPointerException");
12899            } catch (NullPointerException e) {
12900                // Expected
12901            }
12902
12903            iterator = ascendingSubMapEntrySet.iterator();
12904            while (iterator.hasNext()) {
12905                entry = (Entry) iterator.next();
12906                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12907                value = (Integer) entry.getValue();
12908                assertEquals(value, lowerEntry.getValue());
12909            }
12910            assertEquals(109, value);
12911        }
12912
12913        // With Comparator
12914        entrySet = subMap_startIncluded_endIncluded_comparator.entrySet();
12915        if (entrySet instanceof NavigableSet) {
12916            ascendingSubMapEntrySet = (NavigableSet) entrySet;
12917            try {
12918                ascendingSubMapEntrySet.ceiling(null);
12919                fail("should throw NullPointerException");
12920            } catch (NullPointerException e) {
12921                // Expected
12922            }
12923
12924            iterator = ascendingSubMapEntrySet.iterator();
12925            while (iterator.hasNext()) {
12926                entry = (Entry) iterator.next();
12927                lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry);
12928                value = (Integer) entry.getValue();
12929                assertEquals(value, lowerEntry.getValue());
12930            }
12931            assertEquals(109, value);
12932        }
12933
12934        entrySet = subMap_startIncluded_endExcluded_comparator.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(108, value);
12952        }
12953
12954        entrySet = subMap_startExcluded_endIncluded_comparator.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(109, value);
12972        }
12973
12974        entrySet = subMap_startExcluded_endExcluded_comparator.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(108, value);
12992        }
12993    }
12994
12995    public void test_AscendingSubMapEntrySet_floor() {
12996        Set entrySet;
12997        NavigableSet ascendingSubMapEntrySet;
12998        Iterator iterator;
12999        Entry entry, floorEntry;
13000        int value;
13001
13002        entrySet = navigableMap_startExcluded_endExcluded.entrySet();
13003        if (entrySet instanceof NavigableSet) {
13004            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13005            try {
13006                ascendingSubMapEntrySet.floor(null);
13007                fail("should throw NullPointerException");
13008            } catch (NullPointerException e) {
13009                // Expected
13010            }
13011
13012            iterator = ascendingSubMapEntrySet.iterator();
13013            for (int i = 101; i < 109; i++) {
13014                entry = (Entry) iterator.next();
13015                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13016                assertEquals(entry.getValue(), floorEntry.getValue());
13017            }
13018            assertFalse(iterator.hasNext());
13019        }
13020
13021        entrySet = navigableMap_startExcluded_endIncluded.entrySet();
13022        if (entrySet instanceof NavigableSet) {
13023            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13024            try {
13025                ascendingSubMapEntrySet.floor(null);
13026                fail("should throw NullPointerException");
13027            } catch (NullPointerException e) {
13028                // Expected
13029            }
13030
13031            iterator = ascendingSubMapEntrySet.iterator();
13032            for (int i = 101; i < 110; i++) {
13033                entry = (Entry) iterator.next();
13034                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13035                assertEquals(entry.getValue(), floorEntry.getValue());
13036            }
13037            assertFalse(iterator.hasNext());
13038        }
13039
13040        entrySet = navigableMap_startIncluded_endExcluded.entrySet();
13041        if (entrySet instanceof NavigableSet) {
13042            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13043            try {
13044                ascendingSubMapEntrySet.floor(null);
13045                fail("should throw NullPointerException");
13046            } catch (NullPointerException e) {
13047                // Expected
13048            }
13049
13050            iterator = ascendingSubMapEntrySet.iterator();
13051            for (int i = 100; i < 109; i++) {
13052                entry = (Entry) iterator.next();
13053                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13054                assertEquals(entry.getValue(), floorEntry.getValue());
13055            }
13056            assertFalse(iterator.hasNext());
13057        }
13058
13059        entrySet = navigableMap_startIncluded_endIncluded.entrySet();
13060        if (entrySet instanceof NavigableSet) {
13061            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13062            try {
13063                ascendingSubMapEntrySet.floor(null);
13064                fail("should throw NullPointerException");
13065            } catch (NullPointerException e) {
13066                // Expected
13067            }
13068
13069            iterator = ascendingSubMapEntrySet.iterator();
13070            for (int i = 100; i < 110; i++) {
13071                entry = (Entry) iterator.next();
13072                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13073                assertEquals(entry.getValue(), floorEntry.getValue());
13074            }
13075            assertFalse(iterator.hasNext());
13076        }
13077
13078        // With Comparator
13079        entrySet = subMap_startExcluded_endExcluded_comparator.entrySet();
13080        if (entrySet instanceof NavigableSet) {
13081            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13082            try {
13083                ascendingSubMapEntrySet.floor(null);
13084                fail("should throw NullPointerException");
13085            } catch (NullPointerException e) {
13086                // Expected
13087            }
13088
13089            iterator = ascendingSubMapEntrySet.iterator();
13090            for (int i = 101; i < 109; i++) {
13091                entry = (Entry) iterator.next();
13092                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13093                assertEquals(entry.getValue(), floorEntry.getValue());
13094            }
13095            assertFalse(iterator.hasNext());
13096        }
13097
13098        entrySet = subMap_startExcluded_endIncluded_comparator.entrySet();
13099        if (entrySet instanceof NavigableSet) {
13100            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13101            try {
13102                ascendingSubMapEntrySet.floor(null);
13103                fail("should throw NullPointerException");
13104            } catch (NullPointerException e) {
13105                // Expected
13106            }
13107
13108            iterator = ascendingSubMapEntrySet.iterator();
13109            for (int i = 101; i < 110; i++) {
13110                entry = (Entry) iterator.next();
13111                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13112                assertEquals(entry.getValue(), floorEntry.getValue());
13113            }
13114            assertFalse(iterator.hasNext());
13115        }
13116
13117        entrySet = subMap_startIncluded_endExcluded_comparator.entrySet();
13118        if (entrySet instanceof NavigableSet) {
13119            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13120            try {
13121                ascendingSubMapEntrySet.floor(null);
13122                fail("should throw NullPointerException");
13123            } catch (NullPointerException e) {
13124                // Expected
13125            }
13126
13127            iterator = ascendingSubMapEntrySet.iterator();
13128            for (int i = 100; i < 109; i++) {
13129                entry = (Entry) iterator.next();
13130                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13131                assertEquals(entry.getValue(), floorEntry.getValue());
13132            }
13133            assertFalse(iterator.hasNext());
13134        }
13135
13136        entrySet = subMap_startIncluded_endIncluded.entrySet();
13137        if (entrySet instanceof NavigableSet) {
13138            ascendingSubMapEntrySet = (NavigableSet) entrySet;
13139            try {
13140                ascendingSubMapEntrySet.floor(null);
13141                fail("should throw NullPointerException");
13142            } catch (NullPointerException e) {
13143                // Expected
13144            }
13145
13146            iterator = ascendingSubMapEntrySet.iterator();
13147            for (int i = 100; i < 110; i++) {
13148                entry = (Entry) iterator.next();
13149                floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry);
13150                assertEquals(entry.getValue(), floorEntry.getValue());
13151            }
13152            assertFalse(iterator.hasNext());
13153        }
13154    }
13155
13156    @Override
13157    protected void setUp() {
13158        tm = new TreeMap();
13159        tm_comparator = new TreeMap(new MockComparator());
13160        for (int i = 0; i < objArray.length; i++) {
13161            Object x = objArray[i] = new Integer(i);
13162            tm.put(x.toString(), x);
13163            tm_comparator.put(x.toString(), x);
13164        }
13165
13166        subMap_default = tm.subMap(objArray[100].toString(), objArray[109]
13167                .toString());
13168        subMap_startExcluded_endExcluded = tm.subMap(objArray[100].toString(),
13169                false, objArray[109].toString(), false);
13170        subMap_startExcluded_endIncluded = tm.subMap(objArray[100].toString(),
13171                false, objArray[109].toString(), true);
13172        subMap_startIncluded_endExcluded = tm.subMap(objArray[100].toString(),
13173                true, objArray[109].toString(), false);
13174        subMap_startIncluded_endIncluded = tm.subMap(objArray[100].toString(),
13175                true, objArray[109].toString(), true);
13176
13177        subMap_default_beforeStart_100 = tm.subMap(objArray[0].toString(),
13178                objArray[1].toString());
13179
13180        subMap_default_afterEnd_109 = tm.subMap(objArray[110].toString(),
13181                objArray[119].toString());
13182
13183        assertTrue(subMap_startExcluded_endExcluded instanceof NavigableMap);
13184        assertTrue(subMap_startExcluded_endIncluded instanceof NavigableMap);
13185        assertTrue(subMap_startIncluded_endExcluded instanceof NavigableMap);
13186        assertTrue(subMap_startIncluded_endIncluded instanceof NavigableMap);
13187
13188        navigableMap_startExcluded_endExcluded = (NavigableMap) subMap_startExcluded_endExcluded;
13189        navigableMap_startExcluded_endIncluded = (NavigableMap) subMap_startExcluded_endIncluded;
13190        navigableMap_startIncluded_endExcluded = (NavigableMap) subMap_startIncluded_endExcluded;
13191        navigableMap_startIncluded_endIncluded = (NavigableMap) subMap_startIncluded_endIncluded;
13192
13193        subMap_default_comparator = tm_comparator.subMap(objArray[100]
13194                .toString(), objArray[109].toString());
13195        subMap_startExcluded_endExcluded_comparator = tm_comparator.subMap(
13196                objArray[100].toString(), false, objArray[109].toString(),
13197                false);
13198
13199        subMap_startExcluded_endIncluded_comparator = tm_comparator
13200                .subMap(objArray[100].toString(), false, objArray[109]
13201                        .toString(), true);
13202        subMap_startIncluded_endExcluded_comparator = tm_comparator
13203                .subMap(objArray[100].toString(), true, objArray[109]
13204                        .toString(), false);
13205        subMap_startIncluded_endIncluded_comparator = tm_comparator.subMap(
13206                objArray[100].toString(), true, objArray[109].toString(), true);
13207    }
13208
13209    @Override
13210    protected void tearDown() {
13211        tm = null;
13212        tm_comparator = null;
13213
13214        subMap_default = null;
13215        subMap_startExcluded_endExcluded = null;
13216        subMap_startExcluded_endIncluded = null;
13217        subMap_startIncluded_endExcluded = null;
13218        subMap_startIncluded_endIncluded = null;
13219
13220        subMap_default_beforeStart_100 = null;
13221        subMap_default_afterEnd_109 = null;
13222
13223        subMap_default_comparator = null;
13224        subMap_startExcluded_endExcluded_comparator = null;
13225        subMap_startExcluded_endIncluded_comparator = null;
13226        subMap_startIncluded_endExcluded_comparator = null;
13227        subMap_startIncluded_endIncluded_comparator = null;
13228    }
13229
13230    public void test_lower_null() throws Exception {
13231        NavigableMap map = tm.subMap(objArray[100].toString(), true,
13232                objArray[100].toString(), false);
13233        assertNull(map.ceilingKey(objArray[100].toString()));
13234        assertNull(map.floorKey(objArray[100].toString()));
13235        assertNull(map.lowerKey(objArray[100].toString()));
13236        assertNull(map.higherKey(objArray[100].toString()));
13237        assertNull(map.ceilingKey(objArray[111].toString()));
13238        assertNull(map.floorKey(objArray[111].toString()));
13239        assertNull(map.lowerKey(objArray[111].toString()));
13240        assertNull(map.higherKey(objArray[111].toString()));
13241        assertNull(map.ceilingKey(objArray[1].toString()));
13242        assertNull(map.floorKey(objArray[1].toString()));
13243        assertNull(map.lowerKey(objArray[1].toString()));
13244        assertNull(map.higherKey(objArray[1].toString()));
13245        map = map.descendingMap();
13246        assertNull(map.ceilingKey(objArray[100].toString()));
13247        assertNull(map.floorKey(objArray[100].toString()));
13248        assertNull(map.lowerKey(objArray[100].toString()));
13249        assertNull(map.higherKey(objArray[100].toString()));
13250        assertNull(map.ceilingKey(objArray[111].toString()));
13251        assertNull(map.floorKey(objArray[111].toString()));
13252        assertNull(map.lowerKey(objArray[111].toString()));
13253        assertNull(map.higherKey(objArray[111].toString()));
13254        assertNull(map.ceilingKey(objArray[1].toString()));
13255        assertNull(map.floorKey(objArray[1].toString()));
13256        assertNull(map.lowerKey(objArray[1].toString()));
13257        assertNull(map.higherKey(objArray[1].toString()));
13258    }
13259
13260    public void test_lower_tail() throws Exception {
13261        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13262                objArray[103].toString(), false);
13263        assertTrue(map.containsKey(objArray[102].toString()));
13264        assertFalse(map.containsKey(objArray[101].toString()));
13265        assertFalse(map.containsKey(objArray[103].toString()));
13266        assertFalse(map.containsKey(objArray[104].toString()));
13267        map = map.descendingMap();
13268        assertTrue(map.containsKey(objArray[102].toString()));
13269        assertFalse(map.containsKey(objArray[101].toString()));
13270        assertFalse(map.containsKey(objArray[103].toString()));
13271        assertFalse(map.containsKey(objArray[104].toString()));
13272        map = tm.subMap(objArray[102].toString(), true, objArray[102]
13273                .toString(), false);
13274        assertFalse(map.containsKey(objArray[102].toString()));
13275        assertFalse(map.containsKey(objArray[101].toString()));
13276        assertFalse(map.containsKey(objArray[103].toString()));
13277        assertFalse(map.containsKey(objArray[104].toString()));
13278        map = map.descendingMap();
13279        assertFalse(map.containsKey(objArray[102].toString()));
13280        assertFalse(map.containsKey(objArray[101].toString()));
13281        assertFalse(map.containsKey(objArray[103].toString()));
13282        assertFalse(map.containsKey(objArray[104].toString()));
13283    }
13284
13285    public void test_contains_null() throws Exception {
13286        NavigableMap map = tm.subMap(objArray[100].toString(), true,
13287                objArray[100].toString(), false);
13288        assertFalse(map.containsKey(objArray[100].toString()));
13289        assertFalse(map.containsKey(objArray[10].toString()));
13290        assertFalse(map.containsKey(objArray[101].toString()));
13291        assertFalse(map.containsKey(objArray[102].toString()));
13292        assertFalse(map.containsKey(objArray[1].toString()));
13293        map = map.descendingMap();
13294        assertFalse(map.containsKey(objArray[100].toString()));
13295        assertFalse(map.containsKey(objArray[10].toString()));
13296        assertFalse(map.containsKey(objArray[101].toString()));
13297        assertFalse(map.containsKey(objArray[102].toString()));
13298        assertFalse(map.containsKey(objArray[1].toString()));
13299    }
13300
13301    public void test_contains() throws Exception {
13302        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13303                objArray[103].toString(), false);
13304        assertFalse(map.containsKey(objArray[100].toString()));
13305        assertFalse(map.containsKey(objArray[104].toString()));
13306        assertFalse(map.containsKey(objArray[101].toString()));
13307        assertTrue(map.containsKey(objArray[102].toString()));
13308        map = map.descendingMap();
13309        assertFalse(map.containsKey(objArray[100].toString()));
13310        assertFalse(map.containsKey(objArray[104].toString()));
13311        assertFalse(map.containsKey(objArray[101].toString()));
13312        assertTrue(map.containsKey(objArray[102].toString()));
13313    }
13314
13315    public void test_size() throws Exception {
13316        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13317                objArray[103].toString(), false);
13318        assertEquals(0, map.headMap(objArray[102].toString(), false).size());
13319        assertEquals(1, map.headMap(objArray[102].toString(), true).size());
13320        try {
13321            assertEquals(1, map.headMap(objArray[103].toString(), true).size());
13322            fail("should throw IAE");
13323        } catch (IllegalArgumentException e) {
13324        }
13325        assertEquals(1, map.headMap(objArray[103].toString(), false).size());
13326        assertEquals(1, map.tailMap(objArray[102].toString(), true).size());
13327        assertEquals(0, map.tailMap(objArray[102].toString(), false).size());
13328        assertTrue(map.headMap(objArray[103].toString(), false).containsKey(
13329                objArray[102].toString()));
13330        try {
13331            assertTrue(map.headMap(objArray[103].toString(), true).containsKey(
13332                    objArray[102].toString()));
13333            fail("should throw IAE");
13334        } catch (IllegalArgumentException e) {
13335        }
13336        assertFalse(map.headMap(objArray[102].toString(), false).containsKey(
13337                objArray[102].toString()));
13338        assertTrue(map.headMap(objArray[102].toString(), true).containsKey(
13339                objArray[102].toString()));
13340        assertTrue(map.tailMap(objArray[102].toString(), true).containsKey(
13341                objArray[102].toString()));
13342        assertFalse(map.tailMap(objArray[102].toString(), true).containsKey(
13343                objArray[103].toString()));
13344        try {
13345            assertEquals(0, map.tailMap(objArray[101].toString()).size());
13346            fail("should throw IAE");
13347        } catch (IllegalArgumentException e) {
13348        }
13349        map = map.descendingMap();
13350        try {
13351            map = map.subMap(objArray[103].toString(), true, objArray[102]
13352                    .toString(), true);
13353            fail("should throw IAE");
13354        } catch (IllegalArgumentException e) {
13355        }
13356        map = map.subMap(objArray[102].toString(), true, objArray[102]
13357                .toString(), true);
13358        assertEquals(1, map.headMap(objArray[102].toString(), true).size());
13359        assertEquals(0, map.headMap(objArray[102].toString(), false).size());
13360        try {
13361            assertEquals(0, map.headMap(objArray[103].toString(), true).size());
13362            fail("should throw IAE");
13363        } catch (IllegalArgumentException e) {
13364        }
13365
13366        assertEquals(1, map.tailMap(objArray[102].toString(), true).size());
13367        try {
13368            assertFalse(map.headMap(objArray[103].toString(), true)
13369                    .containsKey(objArray[102].toString()));
13370            fail("should throw IAE");
13371        } catch (IllegalArgumentException e) {
13372        }
13373        assertTrue(map.headMap(objArray[102].toString(), true).containsKey(
13374                objArray[102].toString()));
13375        assertFalse(map.headMap(objArray[102].toString(), false).containsKey(
13376                objArray[102].toString()));
13377        assertTrue(map.tailMap(objArray[102].toString(), true).containsKey(
13378                objArray[102].toString()));
13379        assertFalse(map.tailMap(objArray[102].toString(), true).containsKey(
13380                objArray[103].toString()));
13381        try {
13382            assertEquals(0, map.tailMap(objArray[101].toString()).size());
13383            fail("should throw IAE");
13384        } catch (IllegalArgumentException e) {
13385        }
13386    }
13387
13388    public void test_lower() throws Exception {
13389        NavigableMap map = tm.subMap(objArray[102].toString(), true,
13390                objArray[103].toString(), false);
13391        assertEquals(objArray[102].toString(), map.higherKey(objArray[101]
13392                .toString()));
13393        assertEquals(null, map.higherKey(objArray[102].toString()));
13394        assertEquals(null, map.higherKey(objArray[103].toString()));
13395        assertEquals(null, map.higherKey(objArray[104].toString()));
13396        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[101]
13397                .toString()));
13398        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102]
13399                .toString()));
13400        assertEquals(null, map.ceilingKey(objArray[103].toString()));
13401        assertEquals(null, map.ceilingKey(objArray[104].toString()));
13402        assertEquals(null, map.lowerKey(objArray[101].toString()));
13403        assertEquals(null, map.lowerKey(objArray[102].toString()));
13404        assertEquals(objArray[102].toString(), map.lowerKey(objArray[103]
13405                .toString()));
13406        assertEquals(objArray[102].toString(), map.lowerKey(objArray[104]
13407                .toString()));
13408        assertEquals(null, map.floorKey(objArray[101].toString()));
13409        assertEquals(objArray[102].toString(), map.floorKey(objArray[102]
13410                .toString()));
13411        assertEquals(objArray[102].toString(), map.floorKey(objArray[103]
13412                .toString()));
13413        assertEquals(objArray[102].toString(), map.floorKey(objArray[104]
13414                .toString()));
13415        map = map.descendingMap();
13416        assertEquals(null, map.higherKey(objArray[101].toString()));
13417        assertEquals(null, map.higherKey(objArray[102].toString()));
13418        assertEquals(objArray[102].toString(), map.higherKey(objArray[103]
13419                .toString()));
13420        assertEquals(objArray[102].toString(), map.higherKey(objArray[104]
13421                .toString()));
13422        assertEquals(null, map.ceilingKey(objArray[101].toString()));
13423        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102]
13424                .toString()));
13425        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[103]
13426                .toString()));
13427        assertEquals(objArray[102].toString(), map.ceilingKey(objArray[104]
13428                .toString()));
13429        assertEquals(objArray[102].toString(), map.lowerKey(objArray[101]
13430                .toString()));
13431        assertEquals(null, map.lowerKey(objArray[102].toString()));
13432        assertEquals(null, map.lowerKey(objArray[103].toString()));
13433        assertEquals(null, map.lowerKey(objArray[104].toString()));
13434        assertEquals(objArray[102].toString(), map.floorKey(objArray[101]
13435                .toString()));
13436        assertEquals(objArray[102].toString(), map.floorKey(objArray[102]
13437                .toString()));
13438        assertEquals(null, map.floorKey(objArray[103].toString()));
13439        assertEquals(null, map.floorKey(objArray[104].toString()));
13440    }
13441
13442    public void test_lowerkey() throws Exception {
13443        try {
13444            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13445                    false).descendingMap().firstKey();
13446            fail("should throw NoSuchElementException");
13447        } catch (Exception e) {
13448            // expected
13449        }
13450        try {
13451            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13452                    false).descendingMap().lastKey();
13453            fail("should throw NoSuchElementException");
13454        } catch (Exception e) {
13455            // expected
13456        }
13457        try {
13458            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13459                    false).firstKey();
13460            fail("should throw NoSuchElementException");
13461        } catch (Exception e) {
13462            // expected
13463        }
13464        try {
13465            tm.subMap(objArray[100].toString(), true, objArray[100].toString(),
13466                    false).lastKey();
13467            fail("should throw NoSuchElementException");
13468        } catch (Exception e) {
13469            // expected
13470        }
13471
13472    }
13473
13474    public void test_headMap() throws Exception {
13475        TreeMap tree = new TreeMap();
13476        tree.put(new Integer(0), null);
13477        tree.put(new Integer(1), null);
13478        Map submap = tree.subMap(tree.firstKey(), tree.lastKey());
13479        tree.remove(tree.lastKey());
13480        assertEquals(submap, tree);
13481    }
13482
13483    public void testname() throws Exception {
13484        TreeMap nullTree = new TreeMap(new Comparator() {
13485            public int compare(Object o1, Object o2) {
13486                if (o1 == null) {
13487                    return o2 == null ? 0 : -1;
13488                }
13489                return ((String) o1).compareTo((String) o2);
13490            }
13491        });
13492        nullTree.put(new String("One"), 1);
13493        nullTree.put(new String("Two"), 2);
13494        nullTree.put(new String("Three"), 3);
13495        nullTree.put(new String("Four"), 4);
13496        nullTree.put(null, 0);
13497        nullTree.subMap(null, "two").size();
13498    }
13499
13500}
13501