1 package org.apache.harmony.tests.java.util; 2 3 /* 4 * Licensed to the Apache Software Foundation (ASF) under one or more 5 * contributor license agreements. See the NOTICE file distributed with 6 * this work for additional information regarding copyright ownership. 7 * The ASF licenses this file to You under the Apache License, Version 2.0 8 * (the "License"); you may not use this file except in compliance with 9 * the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 */ 19 20 import junit.framework.TestCase; 21 import org.apache.harmony.tests.java.util.TreeMapTest.MockComparator; 22 import java.util.Collection; 23 import java.util.Collections; 24 import java.util.Comparator; 25 import java.util.Iterator; 26 import java.util.Map; 27 import java.util.Map.Entry; 28 import java.util.NavigableMap; 29 import java.util.NavigableSet; 30 import java.util.NoSuchElementException; 31 import java.util.Set; 32 import java.util.SortedMap; 33 import java.util.SortedSet; 34 import java.util.TreeMap; 35 36 // 37 public class TreeMapExtendTest extends TestCase { 38 39 TreeMap tm; 40 41 TreeMap tm_comparator; 42 43 SortedMap subMap_default; 44 45 SortedMap subMap_startExcluded_endExcluded; 46 47 SortedMap subMap_startExcluded_endIncluded; 48 49 SortedMap subMap_startIncluded_endExcluded; 50 51 SortedMap subMap_startIncluded_endIncluded; 52 53 SortedMap subMap_default_beforeStart_100; 54 55 SortedMap subMap_default_afterEnd_109; 56 57 NavigableMap navigableMap_startExcluded_endExcluded; 58 59 NavigableMap navigableMap_startExcluded_endIncluded; 60 61 NavigableMap navigableMap_startIncluded_endExcluded; 62 63 NavigableMap navigableMap_startIncluded_endIncluded; 64 65 SortedMap subMap_default_comparator; 66 67 SortedMap subMap_startExcluded_endExcluded_comparator; 68 69 SortedMap subMap_startExcluded_endIncluded_comparator; 70 71 SortedMap subMap_startIncluded_endExcluded_comparator; 72 73 SortedMap subMap_startIncluded_endIncluded_comparator; 74 75 Object objArray[] = new Object[1000]; 76 77 public void test_TreeMap_Constructor_Default() { 78 TreeMap treeMap = new TreeMap(); 79 assertTrue(treeMap.isEmpty()); 80 assertNull(treeMap.comparator()); 81 assertEquals(0, treeMap.size()); 82 83 try { 84 treeMap.firstKey(); 85 fail("should throw NoSuchElementException"); 86 } catch (NoSuchElementException e) { 87 // Expected 88 } 89 assertNull(treeMap.firstEntry()); 90 91 try { 92 treeMap.lastKey(); 93 fail("should throw NoSuchElementException"); 94 } catch (NoSuchElementException e) { 95 // Expected 96 } 97 assertNull(treeMap.lastEntry()); 98 99 try { 100 treeMap.ceilingKey(1); 101 } catch (NoSuchElementException e) { 102 // Expected 103 } 104 assertNull(treeMap.ceilingEntry(1)); 105 106 try { 107 treeMap.floorKey(1); 108 } catch (NoSuchElementException e) { 109 // Expected 110 } 111 assertNull(treeMap.floorEntry(1)); 112 assertNull(treeMap.lowerKey(1)); 113 assertNull(treeMap.lowerEntry(1)); 114 assertNull(treeMap.higherKey(1)); 115 assertNull(treeMap.higherEntry(1)); 116 assertFalse(treeMap.containsKey(1)); 117 assertFalse(treeMap.containsValue(1)); 118 assertNull(treeMap.get(1)); 119 120 assertNull(treeMap.pollFirstEntry()); 121 assertNull(treeMap.pollLastEntry()); 122 assertEquals(0, treeMap.values().size()); 123 } 124 125 public void test_TreeMap_Constructor_Comparator() { 126 MockComparator mockComparator = new MockComparator(); 127 TreeMap treeMap = new TreeMap(mockComparator); 128 129 assertEquals(mockComparator, treeMap.comparator()); 130 } 131 132 public void test_TreeMap_Constructor_Map() { 133 TreeMap treeMap = new TreeMap(tm); 134 assertEquals(tm.size(), treeMap.size()); 135 assertEquals(tm.firstKey(), treeMap.firstKey()); 136 assertEquals(tm.firstEntry(), treeMap.firstEntry()); 137 assertEquals(tm.lastKey(), treeMap.lastKey()); 138 assertEquals(tm.lastEntry(), treeMap.lastEntry()); 139 assertEquals(tm.keySet(), treeMap.keySet()); 140 141 String key = new Integer(100).toString(); 142 assertEquals(tm.ceilingKey(key), treeMap.ceilingKey(key)); 143 assertEquals(tm.ceilingEntry(key), treeMap.ceilingEntry(key)); 144 assertEquals(tm.floorKey(key), treeMap.floorKey(key)); 145 assertEquals(tm.floorEntry(key), treeMap.floorEntry(key)); 146 assertEquals(tm.lowerKey(key), treeMap.lowerKey(key)); 147 assertEquals(tm.lowerEntry(key), treeMap.lowerEntry(key)); 148 assertEquals(tm.higherKey(key), treeMap.higherKey(key)); 149 assertEquals(tm.higherEntry(key), treeMap.higherEntry(key)); 150 assertEquals(tm.entrySet(), treeMap.entrySet()); 151 } 152 153 public void test_TreeMap_Constructor_SortedMap() { 154 TreeMap treeMap = new TreeMap(subMap_default); 155 assertEquals(subMap_default.size(), treeMap.size()); 156 assertEquals(subMap_default.firstKey(), treeMap.firstKey()); 157 assertEquals(subMap_default.lastKey(), treeMap.lastKey()); 158 assertEquals(subMap_default.keySet(), treeMap.keySet()); 159 assertEquals(subMap_default.entrySet(), treeMap.entrySet()); 160 } 161 162 public void test_TreeMap_clear() { 163 tm.clear(); 164 assertEquals(0, tm.size()); 165 } 166 167 public void test_TreeMap_clone() { 168 TreeMap cloneTreeMap = (TreeMap) tm.clone(); 169 assertEquals(tm, cloneTreeMap); 170 } 171 172 public void test_SubMap_Constructor() { 173 } 174 175 public void test_SubMap_clear() { 176 subMap_default.clear(); 177 assertEquals(0, subMap_default.size()); 178 } 179 180 public void test_SubMap_comparator() { 181 assertEquals(tm.comparator(), subMap_default.comparator()); 182 } 183 184 public void test_SubMap_containsKey() { 185 String key = null; 186 for (int counter = 101; counter < 109; counter++) { 187 key = objArray[counter].toString(); 188 assertTrue("SubMap contains incorrect elements", subMap_default 189 .containsKey(key)); 190 assertTrue("SubMap contains incorrect elements", 191 subMap_startExcluded_endExcluded.containsKey(key)); 192 assertTrue("SubMap contains incorrect elements", 193 subMap_startExcluded_endIncluded.containsKey(key)); 194 assertTrue("SubMap contains incorrect elements", 195 subMap_startIncluded_endExcluded.containsKey(key)); 196 assertTrue("SubMap contains incorrect elements", 197 subMap_startIncluded_endIncluded.containsKey(key)); 198 } 199 200 // Check boundary 201 key = objArray[100].toString(); 202 assertTrue("SubMap contains incorrect elements", subMap_default 203 .containsKey(key)); 204 assertFalse("SubMap contains incorrect elements", 205 subMap_startExcluded_endExcluded.containsKey(key)); 206 assertFalse("SubMap contains incorrect elements", 207 subMap_startExcluded_endIncluded.containsKey(key)); 208 assertTrue("SubMap contains incorrect elements", 209 subMap_startIncluded_endExcluded.containsKey(key)); 210 assertTrue("SubMap contains incorrect elements", 211 subMap_startIncluded_endIncluded.containsKey(key)); 212 213 key = objArray[109].toString(); 214 assertFalse("SubMap contains incorrect elements", subMap_default 215 .containsKey(key)); 216 assertFalse("SubMap contains incorrect elements", 217 subMap_startExcluded_endExcluded.containsKey(key)); 218 assertTrue("SubMap contains incorrect elements", 219 subMap_startExcluded_endIncluded.containsKey(key)); 220 assertFalse("SubMap contains incorrect elements", 221 subMap_startIncluded_endExcluded.containsKey(key)); 222 assertTrue("SubMap contains incorrect elements", 223 subMap_startIncluded_endIncluded.containsKey(key)); 224 225 // With Comparator 226 for (int counter = 101; counter < 109; counter++) { 227 key = objArray[counter].toString(); 228 assertTrue("SubMap contains incorrect elements", 229 subMap_default_comparator.containsKey(key)); 230 assertTrue("SubMap contains incorrect elements", 231 subMap_startExcluded_endExcluded_comparator 232 .containsKey(key)); 233 assertTrue("SubMap contains incorrect elements", 234 subMap_startExcluded_endIncluded_comparator 235 .containsKey(key)); 236 assertTrue("SubMap contains incorrect elements", 237 subMap_startIncluded_endExcluded_comparator 238 .containsKey(key)); 239 assertTrue("SubMap contains incorrect elements", 240 subMap_startIncluded_endIncluded_comparator 241 .containsKey(key)); 242 } 243 244 // Check boundary 245 key = objArray[100].toString(); 246 assertTrue("SubMap contains incorrect elements", 247 subMap_default_comparator.containsKey(key)); 248 assertFalse("SubMap contains incorrect elements", 249 subMap_startExcluded_endExcluded_comparator.containsKey(key)); 250 assertFalse("SubMap contains incorrect elements", 251 subMap_startExcluded_endIncluded_comparator.containsKey(key)); 252 assertTrue("SubMap contains incorrect elements", 253 subMap_startIncluded_endExcluded_comparator.containsKey(key)); 254 assertTrue("SubMap contains incorrect elements", 255 subMap_startIncluded_endIncluded_comparator.containsKey(key)); 256 257 key = objArray[109].toString(); 258 assertFalse("SubMap contains incorrect elements", 259 subMap_default_comparator.containsKey(key)); 260 assertFalse("SubMap contains incorrect elements", 261 subMap_startExcluded_endExcluded_comparator.containsKey(key)); 262 assertTrue("SubMap contains incorrect elements", 263 subMap_startExcluded_endIncluded_comparator.containsKey(key)); 264 assertFalse("SubMap contains incorrect elements", 265 subMap_startIncluded_endExcluded_comparator.containsKey(key)); 266 assertTrue("SubMap contains incorrect elements", 267 subMap_startIncluded_endIncluded_comparator.containsKey(key)); 268 } 269 270 public void test_SubMap_containsValue() { 271 Object value = null; 272 for (int counter = 101; counter < 109; counter++) { 273 value = objArray[counter]; 274 assertTrue("SubMap contains incorrect elements", subMap_default 275 .containsValue(value)); 276 assertTrue("SubMap contains incorrect elements", 277 subMap_startExcluded_endExcluded.containsValue(value)); 278 assertTrue("SubMap contains incorrect elements", 279 subMap_startExcluded_endIncluded.containsValue(value)); 280 assertTrue("SubMap contains incorrect elements", 281 subMap_startIncluded_endExcluded.containsValue(value)); 282 assertTrue("SubMap contains incorrect elements", 283 subMap_startIncluded_endIncluded.containsValue(value)); 284 } 285 286 // Check boundary 287 value = objArray[100]; 288 assertTrue("SubMap contains incorrect elements", subMap_default 289 .containsValue(value)); 290 assertFalse("SubMap contains incorrect elements", 291 subMap_startExcluded_endExcluded.containsValue(value)); 292 assertFalse("SubMap contains incorrect elements", 293 subMap_startExcluded_endIncluded.containsValue(value)); 294 assertTrue("SubMap contains incorrect elements", 295 subMap_startIncluded_endExcluded.containsValue(value)); 296 assertTrue("SubMap contains incorrect elements", 297 subMap_startIncluded_endIncluded.containsValue(value)); 298 299 value = objArray[109]; 300 assertFalse("SubMap contains incorrect elements", subMap_default 301 .containsValue(value)); 302 assertFalse("SubMap contains incorrect elements", 303 subMap_startExcluded_endExcluded.containsValue(value)); 304 assertTrue("SubMap contains incorrect elements", 305 subMap_startExcluded_endIncluded.containsValue(value)); 306 assertFalse("SubMap contains incorrect elements", 307 subMap_startIncluded_endExcluded.containsValue(value)); 308 assertTrue("SubMap contains incorrect elements", 309 subMap_startIncluded_endIncluded.containsValue(value)); 310 311 assertFalse(subMap_default.containsValue(null)); 312 313 TreeMap tm_null = new TreeMap(); 314 tm_null.put("0", 1); 315 tm_null.put("1", null); 316 tm_null.put("2", 2); 317 SortedMap subMap = tm_null.subMap("0", "2"); 318 assertTrue(subMap.containsValue(null)); 319 320 subMap.remove("1"); 321 assertFalse(subMap.containsValue(null)); 322 } 323 324 public void test_SubMap_entrySet() { 325 Set entrySet = subMap_default.entrySet(); 326 assertFalse(entrySet.isEmpty()); 327 assertEquals(9, entrySet.size()); 328 329 entrySet = subMap_startExcluded_endExcluded.entrySet(); 330 assertFalse(entrySet.isEmpty()); 331 assertEquals(8, entrySet.size()); 332 333 entrySet = subMap_startExcluded_endIncluded.entrySet(); 334 assertFalse(entrySet.isEmpty()); 335 assertEquals(9, entrySet.size()); 336 337 entrySet = subMap_startIncluded_endExcluded.entrySet(); 338 assertFalse(entrySet.isEmpty()); 339 assertEquals(9, entrySet.size()); 340 341 entrySet = subMap_startIncluded_endIncluded.entrySet(); 342 assertFalse(entrySet.isEmpty()); 343 assertEquals(10, entrySet.size()); 344 } 345 346 public void test_SubMap_firstKey() { 347 String firstKey1 = new Integer(100).toString(); 348 String firstKey2 = new Integer(101).toString(); 349 assertEquals(firstKey1, subMap_default.firstKey()); 350 assertEquals(firstKey2, subMap_startExcluded_endExcluded.firstKey()); 351 assertEquals(firstKey2, subMap_startExcluded_endIncluded.firstKey()); 352 assertEquals(firstKey1, subMap_startIncluded_endExcluded.firstKey()); 353 assertEquals(firstKey1, subMap_startIncluded_endIncluded.firstKey()); 354 355 try { 356 subMap_default.subMap(firstKey1, firstKey1).firstKey(); 357 fail("should throw NoSuchElementException"); 358 } catch (NoSuchElementException e) { 359 // Expected 360 } 361 362 try { 363 subMap_startExcluded_endExcluded.subMap(firstKey2, firstKey2) 364 .firstKey(); 365 fail("should throw NoSuchElementException"); 366 } catch (NoSuchElementException e) { 367 // Expected 368 } 369 370 try { 371 subMap_startExcluded_endIncluded.subMap(firstKey2, firstKey2) 372 .firstKey(); 373 fail("should throw NoSuchElementException"); 374 } catch (NoSuchElementException e) { 375 // Expected 376 } 377 378 try { 379 subMap_startIncluded_endExcluded.subMap(firstKey1, firstKey1) 380 .firstKey(); 381 fail("should throw NoSuchElementException"); 382 } catch (NoSuchElementException e) { 383 // Expected 384 } 385 386 try { 387 subMap_startIncluded_endIncluded.subMap(firstKey1, firstKey1) 388 .firstKey(); 389 fail("should throw NoSuchElementException"); 390 } catch (NoSuchElementException e) { 391 // Expected 392 } 393 394 // With Comparator 395 assertEquals(firstKey1, subMap_default_comparator.firstKey()); 396 assertEquals(firstKey2, subMap_startExcluded_endExcluded_comparator 397 .firstKey()); 398 assertEquals(firstKey2, subMap_startExcluded_endIncluded_comparator 399 .firstKey()); 400 assertEquals(firstKey1, subMap_startIncluded_endExcluded_comparator 401 .firstKey()); 402 assertEquals(firstKey1, subMap_startIncluded_endIncluded_comparator 403 .firstKey()); 404 405 try { 406 subMap_default_comparator.subMap(firstKey1, firstKey1).firstKey(); 407 fail("should throw NoSuchElementException"); 408 } catch (NoSuchElementException e) { 409 // Expected 410 } 411 412 try { 413 subMap_startExcluded_endExcluded_comparator.subMap(firstKey2, 414 firstKey2).firstKey(); 415 fail("should throw NoSuchElementException"); 416 } catch (NoSuchElementException e) { 417 // Expected 418 } 419 420 try { 421 subMap_startExcluded_endIncluded_comparator.subMap(firstKey2, 422 firstKey2).firstKey(); 423 fail("should throw NoSuchElementException"); 424 } catch (NoSuchElementException e) { 425 // Expected 426 } 427 428 try { 429 subMap_startIncluded_endExcluded_comparator.subMap(firstKey1, 430 firstKey1).firstKey(); 431 fail("should throw NoSuchElementException"); 432 } catch (NoSuchElementException e) { 433 // Expected 434 } 435 436 try { 437 subMap_startIncluded_endIncluded_comparator.subMap(firstKey1, 438 firstKey1).firstKey(); 439 fail("should throw NoSuchElementException"); 440 } catch (NoSuchElementException e) { 441 // Expected 442 } 443 444 } 445 446 public void test_SubMap_lastKey() { 447 String lastKey1 = new Integer(108).toString(); 448 String lastKey2 = new Integer(109).toString(); 449 assertEquals(lastKey1, subMap_default.lastKey()); 450 assertEquals(lastKey1, subMap_startExcluded_endExcluded.lastKey()); 451 assertEquals(lastKey2, subMap_startExcluded_endIncluded.lastKey()); 452 assertEquals(lastKey1, subMap_startIncluded_endExcluded.lastKey()); 453 assertEquals(lastKey2, subMap_startIncluded_endIncluded.lastKey()); 454 455 try { 456 subMap_default.subMap(lastKey1, lastKey1).lastKey(); 457 fail("should throw NoSuchElementException"); 458 } catch (NoSuchElementException e) { 459 // Expected 460 } 461 462 try { 463 subMap_startExcluded_endExcluded.subMap(lastKey1, lastKey1) 464 .lastKey(); 465 fail("should throw NoSuchElementException"); 466 } catch (NoSuchElementException e) { 467 // Expected 468 } 469 470 try { 471 subMap_startExcluded_endIncluded.subMap(lastKey2, lastKey2) 472 .lastKey(); 473 fail("should throw NoSuchElementException"); 474 } catch (NoSuchElementException e) { 475 // Expected 476 } 477 478 try { 479 subMap_startIncluded_endExcluded.subMap(lastKey1, lastKey1) 480 .lastKey(); 481 fail("should throw NoSuchElementException"); 482 } catch (NoSuchElementException e) { 483 // Expected 484 } 485 486 try { 487 subMap_startIncluded_endIncluded.subMap(lastKey2, lastKey2) 488 .lastKey(); 489 fail("should throw NoSuchElementException"); 490 } catch (NoSuchElementException e) { 491 // Expected 492 } 493 494 // With Comparator 495 assertEquals(lastKey1, subMap_default_comparator.lastKey()); 496 assertEquals(lastKey1, subMap_startExcluded_endExcluded_comparator 497 .lastKey()); 498 assertEquals(lastKey2, subMap_startExcluded_endIncluded_comparator 499 .lastKey()); 500 assertEquals(lastKey1, subMap_startIncluded_endExcluded_comparator 501 .lastKey()); 502 assertEquals(lastKey2, subMap_startIncluded_endIncluded_comparator 503 .lastKey()); 504 505 try { 506 subMap_default_comparator.subMap(lastKey1, lastKey1).lastKey(); 507 fail("should throw NoSuchElementException"); 508 } catch (NoSuchElementException e) { 509 // Expected 510 } 511 512 try { 513 subMap_startExcluded_endExcluded_comparator.subMap(lastKey1, 514 lastKey1).lastKey(); 515 fail("should throw NoSuchElementException"); 516 } catch (NoSuchElementException e) { 517 // Expected 518 } 519 520 try { 521 subMap_startExcluded_endIncluded_comparator.subMap(lastKey2, 522 lastKey2).lastKey(); 523 fail("should throw NoSuchElementException"); 524 } catch (NoSuchElementException e) { 525 // Expected 526 } 527 528 try { 529 subMap_startIncluded_endExcluded_comparator.subMap(lastKey1, 530 lastKey1).lastKey(); 531 fail("should throw NoSuchElementException"); 532 } catch (NoSuchElementException e) { 533 // Expected 534 } 535 536 try { 537 subMap_startIncluded_endIncluded_comparator.subMap(lastKey2, 538 lastKey2).lastKey(); 539 fail("should throw NoSuchElementException"); 540 } catch (NoSuchElementException e) { 541 // Expected 542 } 543 } 544 545 public void test_SubMap_get() { 546 // left boundary 547 Integer value = new Integer(100); 548 assertEquals(value, subMap_default.get(value.toString())); 549 assertEquals(null, subMap_startExcluded_endExcluded.get(value 550 .toString())); 551 assertEquals(null, subMap_startExcluded_endIncluded.get(value 552 .toString())); 553 assertEquals(value, subMap_startIncluded_endExcluded.get(value 554 .toString())); 555 assertEquals(value, subMap_startIncluded_endIncluded.get(value 556 .toString())); 557 558 // normal value 559 value = new Integer(105); 560 assertEquals(value, subMap_default.get(value.toString())); 561 assertEquals(value, subMap_startExcluded_endExcluded.get(value 562 .toString())); 563 assertEquals(value, subMap_startExcluded_endIncluded.get(value 564 .toString())); 565 assertEquals(value, subMap_startIncluded_endExcluded.get(value 566 .toString())); 567 assertEquals(value, subMap_startIncluded_endIncluded.get(value 568 .toString())); 569 570 // right boundary 571 value = new Integer(109); 572 assertEquals(null, subMap_default.get(value.toString())); 573 assertEquals(null, subMap_startExcluded_endExcluded.get(value 574 .toString())); 575 assertEquals(value, subMap_startExcluded_endIncluded.get(value 576 .toString())); 577 assertEquals(null, subMap_startIncluded_endExcluded.get(value 578 .toString())); 579 assertEquals(value, subMap_startIncluded_endIncluded.get(value 580 .toString())); 581 582 // With Comparator to test inInRange 583 // left boundary 584 value = new Integer(100); 585 assertEquals(value, subMap_default_comparator.get(value.toString())); 586 587 // normal value 588 value = new Integer(105); 589 assertEquals(value, subMap_default_comparator.get(value.toString())); 590 591 // right boundary 592 value = new Integer(109); 593 assertEquals(null, subMap_default_comparator.get(value.toString())); 594 } 595 596 public void test_SubMap_headMap() { 597 String endKey = new Integer(99).toString(); 598 try { 599 subMap_default.headMap(endKey); 600 fail("should throw IllegalArgumentException"); 601 } catch (IllegalArgumentException e) { 602 // Expected 603 } 604 605 try { 606 subMap_startExcluded_endExcluded.headMap(endKey); 607 fail("should throw IllegalArgumentException"); 608 } catch (IllegalArgumentException e) { 609 // Expected 610 } 611 612 try { 613 subMap_startExcluded_endIncluded.headMap(endKey); 614 fail("should throw IllegalArgumentException"); 615 } catch (IllegalArgumentException e) { 616 // Expected 617 } 618 619 try { 620 subMap_startIncluded_endExcluded.headMap(endKey); 621 fail("should throw IllegalArgumentException"); 622 } catch (IllegalArgumentException e) { 623 // Expected 624 } 625 626 try { 627 subMap_startIncluded_endIncluded.headMap(endKey); 628 fail("should throw IllegalArgumentException"); 629 } catch (IllegalArgumentException e) { 630 // Expected 631 } 632 633 SortedMap headMap = null; 634 endKey = new Integer(100).toString(); 635 headMap = subMap_default.headMap(endKey); 636 assertEquals(0, headMap.size()); 637 638 try { 639 headMap = subMap_startExcluded_endExcluded.headMap(endKey); 640 fail("should throw IllegalArgumentException"); 641 } catch (IllegalArgumentException e) { 642 // Expected 643 } 644 645 try { 646 headMap = subMap_startExcluded_endIncluded.headMap(endKey); 647 fail("should throw IllegalArgumentException"); 648 } catch (IllegalArgumentException e) { 649 // Expected 650 } 651 652 headMap = subMap_startIncluded_endExcluded.headMap(endKey); 653 assertEquals(0, headMap.size()); 654 655 headMap = subMap_startIncluded_endIncluded.headMap(endKey); 656 assertEquals(0, headMap.size()); 657 658 for (int i = 0, j = 101; i < 8; i++) { 659 endKey = new Integer(i + j).toString(); 660 headMap = subMap_default.headMap(endKey); 661 assertEquals(i + 1, headMap.size()); 662 663 headMap = subMap_startExcluded_endExcluded.headMap(endKey); 664 assertEquals(i, headMap.size()); 665 666 headMap = subMap_startExcluded_endIncluded.headMap(endKey); 667 assertEquals(i, headMap.size()); 668 669 headMap = subMap_startIncluded_endExcluded.headMap(endKey); 670 assertEquals(i + 1, headMap.size()); 671 672 headMap = subMap_startIncluded_endIncluded.headMap(endKey); 673 assertEquals(i + 1, headMap.size()); 674 } 675 676 endKey = new Integer(109).toString(); 677 headMap = subMap_default.headMap(endKey); 678 assertEquals(9, headMap.size()); 679 680 headMap = subMap_startExcluded_endExcluded.headMap(endKey); 681 assertEquals(8, headMap.size()); 682 683 headMap = subMap_startExcluded_endIncluded.headMap(endKey); 684 assertEquals(8, headMap.size()); 685 686 headMap = subMap_startIncluded_endExcluded.headMap(endKey); 687 assertEquals(9, headMap.size()); 688 689 headMap = subMap_startIncluded_endIncluded.headMap(endKey); 690 assertEquals(9, headMap.size()); 691 692 endKey = new Integer(110).toString(); 693 try { 694 subMap_default.headMap(endKey); 695 fail("should throw IllegalArgumentException"); 696 } catch (IllegalArgumentException e) { 697 // Expected 698 } 699 700 try { 701 subMap_startExcluded_endExcluded.headMap(endKey); 702 fail("should throw IllegalArgumentException"); 703 } catch (IllegalArgumentException e) { 704 // Expected 705 } 706 707 try { 708 subMap_startExcluded_endIncluded.headMap(endKey); 709 fail("should throw IllegalArgumentException"); 710 } catch (IllegalArgumentException e) { 711 // Expected 712 } 713 714 try { 715 subMap_startIncluded_endExcluded.headMap(endKey); 716 fail("should throw IllegalArgumentException"); 717 } catch (IllegalArgumentException e) { 718 // Expected 719 } 720 721 try { 722 subMap_startIncluded_endIncluded.headMap(endKey); 723 fail("should throw IllegalArgumentException"); 724 } catch (IllegalArgumentException e) { 725 // Expected 726 } 727 728 // With Comparator 729 endKey = new Integer(99).toString(); 730 try { 731 subMap_default_comparator.headMap(endKey); 732 fail("should throw IllegalArgumentException"); 733 } catch (IllegalArgumentException e) { 734 // Expected 735 } 736 737 try { 738 subMap_startExcluded_endExcluded_comparator.headMap(endKey); 739 fail("should throw IllegalArgumentException"); 740 } catch (IllegalArgumentException e) { 741 // Expected 742 } 743 744 try { 745 subMap_startExcluded_endIncluded_comparator.headMap(endKey); 746 fail("should throw IllegalArgumentException"); 747 } catch (IllegalArgumentException e) { 748 // Expected 749 } 750 751 try { 752 subMap_startIncluded_endExcluded_comparator.headMap(endKey); 753 fail("should throw IllegalArgumentException"); 754 } catch (IllegalArgumentException e) { 755 // Expected 756 } 757 758 try { 759 subMap_startIncluded_endIncluded_comparator.headMap(endKey); 760 fail("should throw IllegalArgumentException"); 761 } catch (IllegalArgumentException e) { 762 // Expected 763 } 764 765 headMap = null; 766 endKey = new Integer(100).toString(); 767 headMap = subMap_default_comparator.headMap(endKey); 768 assertEquals(0, headMap.size()); 769 770 try { 771 headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey); 772 fail("should throw IllegalArgumentException"); 773 } catch (IllegalArgumentException e) { 774 // Expected 775 } 776 777 try { 778 headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey); 779 fail("should throw IllegalArgumentException"); 780 } catch (IllegalArgumentException e) { 781 // Expected 782 } 783 784 headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey); 785 assertEquals(0, headMap.size()); 786 787 headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey); 788 assertEquals(0, headMap.size()); 789 790 for (int i = 0, j = 101; i < 8; i++) { 791 endKey = new Integer(i + j).toString(); 792 headMap = subMap_default_comparator.headMap(endKey); 793 assertEquals(i + 1, headMap.size()); 794 795 headMap = subMap_startExcluded_endExcluded_comparator 796 .headMap(endKey); 797 assertEquals(i, headMap.size()); 798 799 headMap = subMap_startExcluded_endIncluded_comparator 800 .headMap(endKey); 801 assertEquals(i, headMap.size()); 802 803 headMap = subMap_startIncluded_endExcluded_comparator 804 .headMap(endKey); 805 assertEquals(i + 1, headMap.size()); 806 807 headMap = subMap_startIncluded_endIncluded_comparator 808 .headMap(endKey); 809 assertEquals(i + 1, headMap.size()); 810 } 811 812 endKey = new Integer(108).toString(); 813 headMap = subMap_default_comparator.headMap(endKey); 814 assertEquals(8, headMap.size()); 815 816 headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey); 817 assertEquals(7, headMap.size()); 818 819 headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey); 820 assertEquals(7, headMap.size()); 821 822 headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey); 823 assertEquals(8, headMap.size()); 824 825 headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey); 826 assertEquals(8, headMap.size()); 827 828 endKey = new Integer(110).toString(); 829 try { 830 subMap_default_comparator.headMap(endKey); 831 fail("should throw IllegalArgumentException"); 832 } catch (IllegalArgumentException e) { 833 // Expected 834 } 835 836 try { 837 subMap_startExcluded_endExcluded_comparator.headMap(endKey); 838 fail("should throw IllegalArgumentException"); 839 } catch (IllegalArgumentException e) { 840 // Expected 841 } 842 843 try { 844 subMap_startExcluded_endIncluded_comparator.headMap(endKey); 845 fail("should throw IllegalArgumentException"); 846 } catch (IllegalArgumentException e) { 847 // Expected 848 } 849 850 try { 851 subMap_startIncluded_endExcluded_comparator.headMap(endKey); 852 fail("should throw IllegalArgumentException"); 853 } catch (IllegalArgumentException e) { 854 // Expected 855 } 856 857 try { 858 subMap_startIncluded_endIncluded_comparator.headMap(endKey); 859 fail("should throw IllegalArgumentException"); 860 } catch (IllegalArgumentException e) { 861 // Expected 862 } 863 } 864 865 public void test_SubMap_isEmpty() { 866 assertFalse(subMap_default.isEmpty()); 867 assertFalse(subMap_startExcluded_endExcluded.isEmpty()); 868 assertFalse(subMap_startExcluded_endIncluded.isEmpty()); 869 assertFalse(subMap_startIncluded_endExcluded.isEmpty()); 870 assertFalse(subMap_startIncluded_endIncluded.isEmpty()); 871 872 Object startKey = new Integer(100); 873 Object endKey = startKey; 874 SortedMap subMap = tm.subMap(startKey.toString(), endKey.toString()); 875 assertTrue(subMap.isEmpty()); 876 subMap = subMap_default.subMap(startKey.toString(), endKey.toString()); 877 assertTrue(subMap.isEmpty()); 878 subMap = subMap_startIncluded_endExcluded.subMap(startKey.toString(), 879 endKey.toString()); 880 assertTrue(subMap.isEmpty()); 881 subMap = subMap_startIncluded_endIncluded.subMap(startKey.toString(), 882 endKey.toString()); 883 assertTrue(subMap.isEmpty()); 884 885 for (int i = 0, j = 101; i < 8; i++) { 886 startKey = i + j; 887 endKey = startKey; 888 889 subMap = subMap_default.subMap(startKey.toString(), endKey 890 .toString()); 891 assertTrue(subMap.isEmpty()); 892 893 subMap = subMap_startExcluded_endExcluded.subMap(startKey 894 .toString(), endKey.toString()); 895 assertTrue(subMap.isEmpty()); 896 897 subMap = subMap_startExcluded_endIncluded.subMap(startKey 898 .toString(), endKey.toString()); 899 assertTrue(subMap.isEmpty()); 900 901 subMap = subMap_startIncluded_endExcluded.subMap(startKey 902 .toString(), endKey.toString()); 903 assertTrue(subMap.isEmpty()); 904 905 subMap = subMap_startIncluded_endIncluded.subMap(startKey 906 .toString(), endKey.toString()); 907 assertTrue(subMap.isEmpty()); 908 } 909 910 for (int i = 0, j = 101; i < 5; i++) { 911 startKey = i + j; 912 endKey = i + j + 4; 913 914 subMap = subMap_default.subMap(startKey.toString(), endKey 915 .toString()); 916 assertFalse(subMap.isEmpty()); 917 918 subMap = subMap_startExcluded_endExcluded.subMap(startKey 919 .toString(), endKey.toString()); 920 assertFalse(subMap.isEmpty()); 921 922 subMap = subMap_startExcluded_endIncluded.subMap(startKey 923 .toString(), endKey.toString()); 924 assertFalse(subMap.isEmpty()); 925 926 subMap = subMap_startIncluded_endExcluded.subMap(startKey 927 .toString(), endKey.toString()); 928 assertFalse(subMap.isEmpty()); 929 930 subMap = subMap_startIncluded_endIncluded.subMap(startKey 931 .toString(), endKey.toString()); 932 assertFalse(subMap.isEmpty()); 933 } 934 935 startKey = new Integer(109).toString(); 936 endKey = startKey; 937 subMap = tm.subMap(startKey.toString(), endKey.toString()); 938 assertTrue(subMap.isEmpty()); 939 subMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey); 940 assertTrue(subMap.isEmpty()); 941 subMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey); 942 assertTrue(subMap.isEmpty()); 943 944 } 945 946 public void test_SubMap_keySet() { 947 Set keySet = subMap_default.keySet(); 948 assertFalse(keySet.isEmpty()); 949 assertEquals(9, keySet.size()); 950 951 keySet = subMap_startExcluded_endExcluded.entrySet(); 952 assertFalse(keySet.isEmpty()); 953 assertEquals(8, keySet.size()); 954 955 keySet = subMap_startExcluded_endIncluded.entrySet(); 956 assertFalse(keySet.isEmpty()); 957 assertEquals(9, keySet.size()); 958 959 keySet = subMap_startIncluded_endExcluded.entrySet(); 960 assertFalse(keySet.isEmpty()); 961 assertEquals(9, keySet.size()); 962 963 keySet = subMap_startIncluded_endIncluded.entrySet(); 964 assertFalse(keySet.isEmpty()); 965 assertEquals(10, keySet.size()); 966 } 967 968 public void test_SubMap_put() { 969 Integer value = new Integer(100); 970 int addValue = 5; 971 972 subMap_default.put(value.toString(), value + addValue); 973 assertEquals(value + addValue, subMap_default.get(value.toString())); 974 975 try { 976 subMap_startExcluded_endExcluded.put(value.toString(), value 977 + addValue); 978 fail("should throw IllegalArgumentException"); 979 } catch (IllegalArgumentException e) { 980 // Expected 981 } 982 983 try { 984 subMap_startExcluded_endIncluded.put(value.toString(), value 985 + addValue); 986 fail("should throw IllegalArgumentException"); 987 } catch (IllegalArgumentException e) { 988 // Expected 989 } 990 991 subMap_startIncluded_endExcluded 992 .put(value.toString(), value + addValue); 993 assertEquals(value + addValue, subMap_startIncluded_endExcluded 994 .get(value.toString())); 995 996 subMap_startIncluded_endIncluded 997 .put(value.toString(), value + addValue); 998 assertEquals(value + addValue, subMap_startIncluded_endIncluded 999 .get(value.toString())); 1000 1001 value = new Integer(109); 1002 try { 1003 subMap_default.put(value.toString(), value + addValue); 1004 fail("should throw IllegalArgumentException"); 1005 } catch (IllegalArgumentException e) { 1006 // Expected 1007 } 1008 1009 try { 1010 subMap_startExcluded_endExcluded.put(value.toString(), value 1011 + addValue); 1012 fail("should throw IllegalArgumentException"); 1013 } catch (IllegalArgumentException e) { 1014 // Expected 1015 } 1016 1017 subMap_startExcluded_endIncluded 1018 .put(value.toString(), value + addValue); 1019 assertEquals(value + addValue, subMap_startExcluded_endIncluded 1020 .get(value.toString())); 1021 1022 try { 1023 subMap_startIncluded_endExcluded.put(value.toString(), value 1024 + addValue); 1025 fail("should throw IllegalArgumentException"); 1026 } catch (IllegalArgumentException e) { 1027 // Expected 1028 } 1029 1030 subMap_startIncluded_endIncluded 1031 .put(value.toString(), value + addValue); 1032 assertEquals(value + addValue, subMap_startIncluded_endIncluded 1033 .get(value.toString())); 1034 } 1035 1036 public void test_SubMap_remove() { 1037 Integer value = new Integer(100); 1038 1039 subMap_default.remove(value.toString()); 1040 assertNull(subMap_default.get(value.toString())); 1041 1042 subMap_startExcluded_endExcluded.remove(value.toString()); 1043 assertNull(subMap_startExcluded_endExcluded.get(value.toString())); 1044 1045 subMap_startExcluded_endIncluded.remove(value.toString()); 1046 assertNull(subMap_startExcluded_endIncluded.get(value.toString())); 1047 1048 subMap_startIncluded_endExcluded.remove(value.toString()); 1049 assertNull(subMap_startIncluded_endExcluded.get(value.toString())); 1050 1051 subMap_startIncluded_endIncluded.remove(value.toString()); 1052 assertNull(subMap_startIncluded_endIncluded.get(value.toString())); 1053 1054 value = new Integer(109); 1055 subMap_default.remove(value.toString()); 1056 assertNull(subMap_default.get(value.toString())); 1057 1058 subMap_startExcluded_endExcluded.remove(value.toString()); 1059 assertNull(subMap_startExcluded_endExcluded.get(value.toString())); 1060 1061 subMap_startExcluded_endIncluded.remove(value.toString()); 1062 assertNull(subMap_startExcluded_endIncluded.get(value.toString())); 1063 1064 subMap_startIncluded_endExcluded.remove(value.toString()); 1065 assertNull(subMap_startIncluded_endExcluded.get(value.toString())); 1066 1067 subMap_startIncluded_endIncluded.remove(value.toString()); 1068 assertNull(subMap_startIncluded_endIncluded.get(value.toString())); 1069 } 1070 1071 public void test_SubMap_subMap_NoComparator() { 1072 String startKey = new Integer[100].toString(); 1073 String endKey = new Integer[100].toString(); 1074 try { 1075 subMap_default.subMap(startKey, endKey); 1076 fail("should throw IllegalArgumentException"); 1077 } catch (IllegalArgumentException e) { 1078 // Expected 1079 } 1080 1081 try { 1082 subMap_startExcluded_endExcluded.subMap(startKey, endKey); 1083 fail("should throw IllegalArgumentException"); 1084 } catch (IllegalArgumentException e) { 1085 // Expected 1086 } 1087 1088 try { 1089 subMap_startExcluded_endIncluded.subMap(startKey, endKey); 1090 fail("should throw IllegalArgumentException"); 1091 } catch (IllegalArgumentException e) { 1092 // Expected 1093 } 1094 1095 try { 1096 subMap_startIncluded_endExcluded.subMap(startKey, endKey); 1097 fail("should throw IllegalArgumentException"); 1098 } catch (IllegalArgumentException e) { 1099 // Expected 1100 } 1101 1102 try { 1103 subMap_startIncluded_endIncluded.subMap(startKey, endKey); 1104 fail("should throw IllegalArgumentException"); 1105 } catch (IllegalArgumentException e) { 1106 // Expected 1107 } 1108 1109 SortedMap subSubMap = null; 1110 for (int i = 101; i < 109; i++) { 1111 startKey = new Integer(i).toString(); 1112 endKey = startKey; 1113 1114 subSubMap = subMap_default.subMap(startKey, endKey); 1115 assertEquals(0, subSubMap.size()); 1116 1117 subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, 1118 endKey); 1119 assertEquals(0, subSubMap.size()); 1120 1121 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, 1122 endKey); 1123 assertEquals(0, subSubMap.size()); 1124 1125 subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, 1126 endKey); 1127 assertEquals(0, subSubMap.size()); 1128 1129 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, 1130 endKey); 1131 assertEquals(0, subSubMap.size()); 1132 } 1133 1134 for (int i = 101, j = 5; i < 105; i++) { 1135 startKey = new Integer(i).toString(); 1136 endKey = new Integer(i + j).toString(); 1137 1138 subSubMap = subMap_default.subMap(startKey, endKey); 1139 assertEquals(j, subSubMap.size()); 1140 1141 subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, 1142 endKey); 1143 assertEquals(j, subSubMap.size()); 1144 1145 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, 1146 endKey); 1147 assertEquals(j, subSubMap.size()); 1148 1149 subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, 1150 endKey); 1151 assertEquals(j, subSubMap.size()); 1152 1153 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, 1154 endKey); 1155 assertEquals(j, subSubMap.size()); 1156 } 1157 1158 startKey = new Integer(108).toString(); 1159 endKey = new Integer(109).toString(); 1160 1161 subSubMap = subMap_default.subMap(startKey, endKey); 1162 assertEquals(1, subSubMap.size()); 1163 1164 subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, endKey); 1165 assertEquals(1, subSubMap.size()); 1166 1167 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey); 1168 assertEquals(1, subSubMap.size()); 1169 1170 subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, endKey); 1171 assertEquals(1, subSubMap.size()); 1172 1173 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey); 1174 assertEquals(1, subSubMap.size()); 1175 1176 startKey = new Integer(109).toString(); 1177 endKey = new Integer(109).toString(); 1178 1179 try { 1180 subMap_default.subMap(startKey, endKey); 1181 fail("should throw IllegalArgumentException"); 1182 } catch (IllegalArgumentException e) { 1183 // Expected 1184 } 1185 1186 try { 1187 subMap_startExcluded_endExcluded.subMap(startKey, endKey); 1188 fail("should throw IllegalArgumentException"); 1189 } catch (IllegalArgumentException e) { 1190 // Expected 1191 } 1192 1193 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey); 1194 assertEquals(0, subSubMap.size()); 1195 1196 try { 1197 subMap_startIncluded_endExcluded.subMap(startKey, endKey); 1198 fail("should throw IllegalArgumentException"); 1199 } catch (IllegalArgumentException e) { 1200 // Expected 1201 } 1202 1203 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey); 1204 assertEquals(0, subSubMap.size()); 1205 } 1206 1207 public void test_SubMap_subMap_Comparator() { 1208 String startKey = new Integer[100].toString(); 1209 String endKey = new Integer[100].toString(); 1210 try { 1211 subMap_default_comparator.subMap(startKey, endKey); 1212 fail("should throw IllegalArgumentException"); 1213 } catch (IllegalArgumentException e) { 1214 // Expected 1215 } 1216 1217 try { 1218 subMap_startExcluded_endExcluded_comparator 1219 .subMap(startKey, endKey); 1220 fail("should throw IllegalArgumentException"); 1221 } catch (IllegalArgumentException e) { 1222 // Expected 1223 } 1224 1225 try { 1226 subMap_startExcluded_endIncluded_comparator 1227 .subMap(startKey, endKey); 1228 fail("should throw IllegalArgumentException"); 1229 } catch (IllegalArgumentException e) { 1230 // Expected 1231 } 1232 1233 try { 1234 subMap_startIncluded_endExcluded_comparator 1235 .subMap(startKey, endKey); 1236 fail("should throw IllegalArgumentException"); 1237 } catch (IllegalArgumentException e) { 1238 // Expected 1239 } 1240 1241 try { 1242 subMap_startIncluded_endIncluded_comparator 1243 .subMap(startKey, endKey); 1244 fail("should throw IllegalArgumentException"); 1245 } catch (IllegalArgumentException e) { 1246 // Expected 1247 } 1248 1249 SortedMap subSubMap = null; 1250 for (int i = 101; i < 109; i++) { 1251 startKey = new Integer(i).toString(); 1252 endKey = startKey; 1253 1254 subSubMap = subMap_default_comparator.subMap(startKey, endKey); 1255 assertEquals(0, subSubMap.size()); 1256 1257 subSubMap = subMap_startExcluded_endExcluded_comparator.subMap( 1258 startKey, endKey); 1259 assertEquals(0, subSubMap.size()); 1260 1261 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1262 startKey, endKey); 1263 assertEquals(0, subSubMap.size()); 1264 1265 subSubMap = subMap_startIncluded_endExcluded_comparator.subMap( 1266 startKey, endKey); 1267 assertEquals(0, subSubMap.size()); 1268 1269 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1270 startKey, endKey); 1271 assertEquals(0, subSubMap.size()); 1272 } 1273 1274 for (int i = 101, j = 5; i < 105; i++) { 1275 startKey = new Integer(i).toString(); 1276 endKey = new Integer(i + j).toString(); 1277 1278 subSubMap = subMap_default_comparator.subMap(startKey, endKey); 1279 assertEquals(j, subSubMap.size()); 1280 1281 subSubMap = subMap_startExcluded_endExcluded_comparator.subMap( 1282 startKey, endKey); 1283 assertEquals(j, subSubMap.size()); 1284 1285 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1286 startKey, endKey); 1287 assertEquals(j, subSubMap.size()); 1288 1289 subSubMap = subMap_startIncluded_endExcluded_comparator.subMap( 1290 startKey, endKey); 1291 assertEquals(j, subSubMap.size()); 1292 1293 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1294 startKey, endKey); 1295 assertEquals(j, subSubMap.size()); 1296 } 1297 1298 startKey = new Integer(108).toString(); 1299 endKey = new Integer(109).toString(); 1300 1301 subSubMap = subMap_default_comparator.subMap(startKey, endKey); 1302 assertEquals(1, subSubMap.size()); 1303 1304 subSubMap = subMap_startExcluded_endExcluded_comparator.subMap( 1305 startKey, endKey); 1306 assertEquals(1, subSubMap.size()); 1307 1308 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1309 startKey, endKey); 1310 assertEquals(1, subSubMap.size()); 1311 1312 subSubMap = subMap_startIncluded_endExcluded_comparator.subMap( 1313 startKey, endKey); 1314 assertEquals(1, subSubMap.size()); 1315 1316 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1317 startKey, endKey); 1318 assertEquals(1, subSubMap.size()); 1319 1320 startKey = new Integer(109).toString(); 1321 endKey = new Integer(109).toString(); 1322 1323 try { 1324 subMap_default_comparator.subMap(startKey, endKey); 1325 fail("should throw IllegalArgumentException"); 1326 } catch (IllegalArgumentException e) { 1327 // Expected 1328 } 1329 1330 try { 1331 subMap_startExcluded_endExcluded_comparator 1332 .subMap(startKey, endKey); 1333 fail("should throw IllegalArgumentException"); 1334 } catch (IllegalArgumentException e) { 1335 // Expected 1336 } 1337 1338 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1339 startKey, endKey); 1340 assertEquals(0, subSubMap.size()); 1341 1342 try { 1343 subMap_startIncluded_endExcluded_comparator 1344 .subMap(startKey, endKey); 1345 fail("should throw IllegalArgumentException"); 1346 } catch (IllegalArgumentException e) { 1347 // Expected 1348 } 1349 1350 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1351 startKey, endKey); 1352 assertEquals(0, subSubMap.size()); 1353 } 1354 1355 public void test_SubMap_tailMap() { 1356 String startKey = new Integer(99).toString(); 1357 try { 1358 subMap_default.tailMap(startKey); 1359 fail("should throw IllegalArgumentException"); 1360 } catch (IllegalArgumentException e) { 1361 // Expected 1362 } 1363 1364 try { 1365 subMap_startExcluded_endExcluded.tailMap(startKey); 1366 fail("should throw IllegalArgumentException"); 1367 } catch (IllegalArgumentException e) { 1368 // Expected 1369 } 1370 1371 try { 1372 subMap_startExcluded_endIncluded.tailMap(startKey); 1373 fail("should throw IllegalArgumentException"); 1374 } catch (IllegalArgumentException e) { 1375 // Expected 1376 } 1377 1378 try { 1379 subMap_startIncluded_endExcluded.tailMap(startKey); 1380 fail("should throw IllegalArgumentException"); 1381 } catch (IllegalArgumentException e) { 1382 // Expected 1383 } 1384 1385 try { 1386 subMap_startIncluded_endIncluded.tailMap(startKey); 1387 fail("should throw IllegalArgumentException"); 1388 } catch (IllegalArgumentException e) { 1389 // Expected 1390 } 1391 SortedMap tailMap = null; 1392 1393 startKey = new Integer(100).toString(); 1394 tailMap = subMap_default.tailMap(startKey); 1395 assertEquals(9, tailMap.size()); 1396 1397 try { 1398 subMap_startExcluded_endExcluded.tailMap(startKey); 1399 fail("should throw IllegalArgumentException"); 1400 } catch (IllegalArgumentException e) { 1401 // Expected 1402 } 1403 1404 try { 1405 subMap_startExcluded_endIncluded.tailMap(startKey); 1406 fail("should throw IllegalArgumentException"); 1407 } catch (IllegalArgumentException e) { 1408 // Expected 1409 } 1410 1411 tailMap = subMap_startIncluded_endExcluded.tailMap(startKey); 1412 assertEquals(9, tailMap.size()); 1413 1414 tailMap = subMap_startIncluded_endIncluded.tailMap(startKey); 1415 assertEquals(10, tailMap.size()); 1416 1417 for (int i = 0, j = 101, end = 8; i < end; i++) { 1418 startKey = new Integer(i + j).toString(); 1419 tailMap = subMap_default.tailMap(startKey); 1420 assertEquals(end - i, tailMap.size()); 1421 1422 tailMap = subMap_startExcluded_endExcluded.tailMap(startKey); 1423 assertEquals(end - i, tailMap.size()); 1424 1425 tailMap = subMap_startExcluded_endIncluded.tailMap(startKey); 1426 assertEquals(end - i + 1, tailMap.size()); 1427 1428 tailMap = subMap_startIncluded_endExcluded.tailMap(startKey); 1429 assertEquals(end - i, tailMap.size()); 1430 1431 tailMap = subMap_startIncluded_endIncluded.tailMap(startKey); 1432 assertEquals(end - i + 1, tailMap.size()); 1433 } 1434 1435 startKey = new Integer(109).toString(); 1436 try { 1437 subMap_default.tailMap(startKey); 1438 fail("should throw IllegalArgumentException"); 1439 } catch (IllegalArgumentException e) { 1440 // Expected 1441 } 1442 try { 1443 subMap_startExcluded_endExcluded.tailMap(startKey); 1444 fail("should throw IllegalArgumentException"); 1445 } catch (IllegalArgumentException e) { 1446 // Expected 1447 } 1448 1449 tailMap = subMap_startExcluded_endIncluded.tailMap(startKey); 1450 assertEquals(1, tailMap.size()); 1451 1452 try { 1453 subMap_startIncluded_endExcluded.tailMap(startKey); 1454 fail("should throw IllegalArgumentException"); 1455 } catch (IllegalArgumentException e) { 1456 // Expected 1457 } 1458 1459 tailMap = subMap_startIncluded_endIncluded.tailMap(startKey); 1460 assertEquals(1, tailMap.size()); 1461 1462 startKey = new Integer(110).toString(); 1463 try { 1464 subMap_default.tailMap(startKey); 1465 fail("should throw IllegalArgumentException"); 1466 } catch (IllegalArgumentException e) { 1467 // Expected 1468 } 1469 1470 try { 1471 subMap_startExcluded_endExcluded.tailMap(startKey); 1472 fail("should throw IllegalArgumentException"); 1473 } catch (IllegalArgumentException e) { 1474 // Expected 1475 } 1476 try { 1477 subMap_startExcluded_endIncluded.tailMap(startKey); 1478 fail("should throw IllegalArgumentException"); 1479 } catch (IllegalArgumentException e) { 1480 // Expected 1481 } 1482 try { 1483 subMap_startIncluded_endExcluded.tailMap(startKey); 1484 fail("should throw IllegalArgumentException"); 1485 } catch (IllegalArgumentException e) { 1486 // Expected 1487 } 1488 try { 1489 subMap_startIncluded_endIncluded.tailMap(startKey); 1490 fail("should throw IllegalArgumentException"); 1491 } catch (IllegalArgumentException e) { 1492 // Expected 1493 } 1494 } 1495 1496 public void test_SubMap_values() { 1497 Collection values = subMap_default.values(); 1498 1499 assertFalse(values.isEmpty()); 1500 assertTrue(values.contains(100)); 1501 for (int i = 101; i < 109; i++) { 1502 assertTrue(values.contains(i)); 1503 } 1504 assertFalse(values.contains(109)); 1505 1506 values = subMap_startExcluded_endExcluded.values(); 1507 assertFalse(values.isEmpty()); 1508 assertFalse(values.contains(100)); 1509 for (int i = 101; i < 109; i++) { 1510 assertTrue(values.contains(i)); 1511 } 1512 assertFalse(values.contains(109)); 1513 1514 values = subMap_startExcluded_endIncluded.values(); 1515 assertFalse(values.isEmpty()); 1516 assertFalse(values.contains(100)); 1517 for (int i = 101; i < 109; i++) { 1518 assertTrue(values.contains(i)); 1519 } 1520 assertTrue(values.contains(109)); 1521 1522 values = subMap_startIncluded_endExcluded.values(); 1523 assertFalse(values.isEmpty()); 1524 assertTrue(values.contains(100)); 1525 for (int i = 101; i < 109; i++) { 1526 assertTrue(values.contains(i)); 1527 } 1528 assertFalse(values.contains(109)); 1529 1530 values = subMap_startIncluded_endIncluded.values(); 1531 assertFalse(values.isEmpty()); 1532 assertTrue(values.contains(100)); 1533 for (int i = 100; i < 109; i++) { 1534 assertTrue(values.contains(i)); 1535 } 1536 assertTrue(values.contains(109)); 1537 } 1538 1539 public void test_SubMap_size() { 1540 assertEquals(9, subMap_default.size()); 1541 assertEquals(8, subMap_startExcluded_endExcluded.size()); 1542 assertEquals(9, subMap_startExcluded_endIncluded.size()); 1543 assertEquals(9, subMap_startIncluded_endExcluded.size()); 1544 assertEquals(10, subMap_startIncluded_endIncluded.size()); 1545 1546 assertEquals(9, subMap_default_comparator.size()); 1547 assertEquals(8, subMap_startExcluded_endExcluded_comparator.size()); 1548 assertEquals(9, subMap_startExcluded_endIncluded_comparator.size()); 1549 assertEquals(9, subMap_startIncluded_endExcluded_comparator.size()); 1550 assertEquals(10, subMap_startIncluded_endIncluded_comparator.size()); 1551 } 1552 1553 public void test_SubMap_readObject() throws Exception { 1554 // SerializationTest.verifySelf(subMap_default); 1555 // SerializationTest.verifySelf(subMap_startExcluded_endExcluded); 1556 // SerializationTest.verifySelf(subMap_startExcluded_endIncluded); 1557 // SerializationTest.verifySelf(subMap_startIncluded_endExcluded); 1558 // SerializationTest.verifySelf(subMap_startIncluded_endIncluded); 1559 } 1560 1561 public void test_AscendingSubMap_ceilingEntry() { 1562 String key = new Integer(99).toString(); 1563 assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key)); 1564 assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key)); 1565 assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key)); 1566 assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key)); 1567 1568 key = new Integer(100).toString(); 1569 assertEquals(101, navigableMap_startExcluded_endExcluded.ceilingEntry( 1570 key).getValue()); 1571 assertEquals(101, navigableMap_startExcluded_endIncluded.ceilingEntry( 1572 key).getValue()); 1573 assertEquals(100, navigableMap_startIncluded_endExcluded.ceilingEntry( 1574 key).getValue()); 1575 assertEquals(100, navigableMap_startIncluded_endIncluded.ceilingEntry( 1576 key).getValue()); 1577 1578 for (int i = 101; i < 109; i++) { 1579 key = new Integer(i).toString(); 1580 assertEquals(i, navigableMap_startExcluded_endExcluded 1581 .ceilingEntry(key).getValue()); 1582 assertEquals(i, navigableMap_startExcluded_endIncluded 1583 .ceilingEntry(key).getValue()); 1584 assertEquals(i, navigableMap_startIncluded_endExcluded 1585 .ceilingEntry(key).getValue()); 1586 assertEquals(i, navigableMap_startIncluded_endIncluded 1587 .ceilingEntry(key).getValue()); 1588 1589 } 1590 1591 key = new Integer(109).toString(); 1592 assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key)); 1593 assertEquals(109, navigableMap_startExcluded_endIncluded.ceilingEntry( 1594 key).getValue()); 1595 assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key)); 1596 assertEquals(109, navigableMap_startIncluded_endIncluded.ceilingEntry( 1597 key).getValue()); 1598 1599 key = new Integer(110).toString(); 1600 assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key)); 1601 assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key)); 1602 assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key)); 1603 assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key)); 1604 } 1605 1606 public void test_AscendingSubMap_descendingMap() { 1607 NavigableMap descendingMap = navigableMap_startExcluded_endExcluded 1608 .descendingMap(); 1609 assertEquals(navigableMap_startExcluded_endExcluded.size(), 1610 descendingMap.size()); 1611 assertNotNull(descendingMap.comparator()); 1612 1613 assertEquals(navigableMap_startExcluded_endExcluded.firstKey(), 1614 descendingMap.lastKey()); 1615 assertEquals(navigableMap_startExcluded_endExcluded.firstEntry(), 1616 descendingMap.lastEntry()); 1617 1618 assertEquals(navigableMap_startExcluded_endExcluded.lastKey(), 1619 descendingMap.firstKey()); 1620 assertEquals(navigableMap_startExcluded_endExcluded.lastEntry(), 1621 descendingMap.firstEntry()); 1622 1623 descendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 1624 assertEquals(navigableMap_startExcluded_endIncluded.size(), 1625 descendingMap.size()); 1626 assertNotNull(descendingMap.comparator()); 1627 1628 assertEquals(navigableMap_startExcluded_endIncluded.firstKey(), 1629 descendingMap.lastKey()); 1630 assertEquals(navigableMap_startExcluded_endIncluded.firstEntry(), 1631 descendingMap.lastEntry()); 1632 1633 assertEquals(navigableMap_startExcluded_endIncluded.lastKey(), 1634 descendingMap.firstKey()); 1635 assertEquals(navigableMap_startExcluded_endIncluded.lastEntry(), 1636 descendingMap.firstEntry()); 1637 1638 descendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 1639 assertEquals(navigableMap_startIncluded_endExcluded.size(), 1640 descendingMap.size()); 1641 assertNotNull(descendingMap.comparator()); 1642 1643 assertEquals(navigableMap_startIncluded_endExcluded.firstKey(), 1644 descendingMap.lastKey()); 1645 assertEquals(navigableMap_startIncluded_endExcluded.firstEntry(), 1646 descendingMap.lastEntry()); 1647 1648 assertEquals(navigableMap_startIncluded_endExcluded.lastKey(), 1649 descendingMap.firstKey()); 1650 assertEquals(navigableMap_startIncluded_endExcluded.lastEntry(), 1651 descendingMap.firstEntry()); 1652 1653 descendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 1654 assertEquals(navigableMap_startIncluded_endIncluded.size(), 1655 descendingMap.size()); 1656 assertNotNull(descendingMap.comparator()); 1657 1658 assertEquals(navigableMap_startIncluded_endIncluded.firstKey(), 1659 descendingMap.lastKey()); 1660 assertEquals(navigableMap_startIncluded_endIncluded.firstEntry(), 1661 descendingMap.lastEntry()); 1662 1663 assertEquals(navigableMap_startIncluded_endIncluded.lastKey(), 1664 descendingMap.firstKey()); 1665 assertEquals(navigableMap_startIncluded_endIncluded.lastEntry(), 1666 descendingMap.firstEntry()); 1667 } 1668 1669 public void test_AscendingSubMap_floorEntry() { 1670 String key = new Integer(99).toString(); 1671 assertEquals(108, navigableMap_startExcluded_endExcluded 1672 .floorEntry(key).getValue()); 1673 assertEquals(109, navigableMap_startExcluded_endIncluded 1674 .floorEntry(key).getValue()); 1675 assertEquals(108, navigableMap_startIncluded_endExcluded 1676 .floorEntry(key).getValue()); 1677 assertEquals(109, navigableMap_startIncluded_endIncluded 1678 .floorEntry(key).getValue()); 1679 1680 key = new Integer(100).toString(); 1681 assertNull(navigableMap_startExcluded_endExcluded.floorEntry(key)); 1682 assertNull(navigableMap_startExcluded_endIncluded.floorEntry(key)); 1683 assertEquals(100, navigableMap_startIncluded_endExcluded 1684 .floorEntry(key).getValue()); 1685 assertEquals(100, navigableMap_startIncluded_endIncluded 1686 .floorEntry(key).getValue()); 1687 1688 for (int i = 101; i < 109; i++) { 1689 key = new Integer(i).toString(); 1690 assertEquals(i, navigableMap_startExcluded_endExcluded.floorEntry( 1691 key).getValue()); 1692 assertEquals(i, navigableMap_startExcluded_endIncluded.floorEntry( 1693 key).getValue()); 1694 assertEquals(i, navigableMap_startIncluded_endExcluded.floorEntry( 1695 key).getValue()); 1696 assertEquals(i, navigableMap_startIncluded_endIncluded.floorEntry( 1697 key).getValue()); 1698 1699 } 1700 1701 key = new Integer(109).toString(); 1702 assertEquals(108, navigableMap_startExcluded_endExcluded 1703 .floorEntry(key).getValue()); 1704 assertEquals(109, navigableMap_startExcluded_endIncluded 1705 .floorEntry(key).getValue()); 1706 assertEquals(108, navigableMap_startIncluded_endExcluded 1707 .floorEntry(key).getValue()); 1708 assertEquals(109, navigableMap_startIncluded_endIncluded 1709 .floorEntry(key).getValue()); 1710 1711 key = new Integer(110).toString(); 1712 assertEquals(108, navigableMap_startExcluded_endExcluded 1713 .floorEntry(key).getValue()); 1714 assertEquals(109, navigableMap_startExcluded_endIncluded 1715 .floorEntry(key).getValue()); 1716 assertEquals(108, navigableMap_startIncluded_endExcluded 1717 .floorEntry(key).getValue()); 1718 assertEquals(109, navigableMap_startIncluded_endIncluded 1719 .floorEntry(key).getValue()); 1720 } 1721 1722 public void test_AscendingSubMap_pollFirstEntry() { 1723 assertEquals(101, navigableMap_startExcluded_endExcluded 1724 .pollFirstEntry().getValue()); 1725 assertEquals(102, navigableMap_startExcluded_endIncluded 1726 .pollFirstEntry().getValue()); 1727 assertEquals(100, navigableMap_startIncluded_endExcluded 1728 .pollFirstEntry().getValue()); 1729 assertEquals(103, navigableMap_startIncluded_endIncluded 1730 .pollFirstEntry().getValue()); 1731 } 1732 1733 public void test_AscendingSubMap_pollLastEntry() { 1734 assertEquals(108, navigableMap_startExcluded_endExcluded 1735 .pollLastEntry().getValue()); 1736 assertEquals(109, navigableMap_startExcluded_endIncluded 1737 .pollLastEntry().getValue()); 1738 assertEquals(107, navigableMap_startIncluded_endExcluded 1739 .pollLastEntry().getValue()); 1740 assertEquals(106, navigableMap_startIncluded_endIncluded 1741 .pollLastEntry().getValue()); 1742 } 1743 1744 public void test_AscendingSubMap_entrySet() { 1745 assertEquals(8, navigableMap_startExcluded_endExcluded.entrySet() 1746 .size()); 1747 assertEquals(9, navigableMap_startExcluded_endIncluded.entrySet() 1748 .size()); 1749 assertEquals(9, navigableMap_startIncluded_endExcluded.entrySet() 1750 .size()); 1751 assertEquals(10, navigableMap_startIncluded_endIncluded.entrySet() 1752 .size()); 1753 } 1754 1755 public void test_AscendingSubMap_subMap() { 1756 Set entrySet; 1757 Entry startEntry, endEntry; 1758 int startIndex, endIndex; 1759 SortedMap subMap; 1760 Iterator subMapSetIterator; 1761 1762 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 1763 Iterator startIterator = entrySet.iterator(); 1764 while (startIterator.hasNext()) { 1765 startEntry = (Entry) startIterator.next(); 1766 startIndex = (Integer) startEntry.getValue(); 1767 Iterator endIterator = entrySet.iterator(); 1768 while (endIterator.hasNext()) { 1769 endEntry = (Entry) endIterator.next(); 1770 endIndex = (Integer) endEntry.getValue(); 1771 1772 if (startIndex > endIndex) { 1773 try { 1774 navigableMap_startExcluded_endExcluded.subMap( 1775 startEntry.getKey(), endEntry.getKey()); 1776 fail("should throw IllegalArgumentException"); 1777 } catch (IllegalArgumentException e) { 1778 // Expected 1779 } 1780 try { 1781 navigableMap_startExcluded_endExcluded.subMap( 1782 startEntry.getKey(), false, endEntry.getKey(), 1783 false); 1784 fail("should throw IllegalArgumentException"); 1785 } catch (IllegalArgumentException e) { 1786 // Expected 1787 } 1788 try { 1789 navigableMap_startExcluded_endExcluded.subMap( 1790 startEntry.getKey(), false, endEntry.getKey(), 1791 true); 1792 fail("should throw IllegalArgumentException"); 1793 } catch (IllegalArgumentException e) { 1794 // Expected 1795 } 1796 try { 1797 navigableMap_startExcluded_endExcluded.subMap( 1798 startEntry.getKey(), true, endEntry.getKey(), 1799 false); 1800 fail("should throw IllegalArgumentException"); 1801 } catch (IllegalArgumentException e) { 1802 // Expected 1803 } 1804 try { 1805 navigableMap_startExcluded_endExcluded.subMap( 1806 startEntry.getKey(), true, endEntry.getKey(), 1807 true); 1808 fail("should throw IllegalArgumentException"); 1809 } catch (IllegalArgumentException e) { 1810 // Expected 1811 } 1812 } else { 1813 subMap = navigableMap_startExcluded_endExcluded.subMap( 1814 startEntry.getKey(), endEntry.getKey()); 1815 subMapSetIterator = subMap.entrySet().iterator(); 1816 for (int index = startIndex; index < endIndex; index++) { 1817 assertEquals(index, ((Entry) subMapSetIterator.next()) 1818 .getValue()); 1819 } 1820 1821 subMap = navigableMap_startExcluded_endExcluded.subMap( 1822 startEntry.getKey(), false, endEntry.getKey(), 1823 false); 1824 subMapSetIterator = subMap.entrySet().iterator(); 1825 for (int index = startIndex + 1; index < endIndex; index++) { 1826 assertEquals(index, ((Entry) subMapSetIterator.next()) 1827 .getValue()); 1828 } 1829 1830 subMap = navigableMap_startExcluded_endExcluded 1831 .subMap(startEntry.getKey(), false, endEntry 1832 .getKey(), true); 1833 subMapSetIterator = subMap.entrySet().iterator(); 1834 for (int index = startIndex + 1; index < endIndex; index++) { 1835 assertEquals(index, ((Entry) subMapSetIterator.next()) 1836 .getValue()); 1837 } 1838 1839 subMap = navigableMap_startExcluded_endExcluded 1840 .subMap(startEntry.getKey(), true, endEntry 1841 .getKey(), false); 1842 subMapSetIterator = subMap.entrySet().iterator(); 1843 for (int index = startIndex; index < endIndex; index++) { 1844 assertEquals(index, ((Entry) subMapSetIterator.next()) 1845 .getValue()); 1846 } 1847 1848 subMap = navigableMap_startExcluded_endExcluded.subMap( 1849 startEntry.getKey(), true, endEntry.getKey(), true); 1850 subMapSetIterator = subMap.entrySet().iterator(); 1851 for (int index = startIndex; index <= endIndex; index++) { 1852 assertEquals(index, ((Entry) subMapSetIterator.next()) 1853 .getValue()); 1854 } 1855 } 1856 } 1857 } 1858 } 1859 1860 public void test_DescendingSubMap_ceilingEntry() { 1861 NavigableMap decendingMap = tm.descendingMap(); 1862 String key = new Integer(-1).toString(); 1863 assertNull(decendingMap.ceilingEntry(key)); 1864 for (int i = 0; i < objArray.length; i++) { 1865 key = objArray[i].toString(); 1866 assertEquals(objArray[i], decendingMap.ceilingEntry(key).getValue()); 1867 } 1868 key = new Integer(1000).toString(); 1869 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1870 key = new Integer(1001).toString(); 1871 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1872 1873 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 1874 key = new Integer(100).toString(); 1875 assertNull(decendingMap.ceilingEntry(key)); 1876 for (int i = 101; i < 109; i++) { 1877 key = new Integer(i).toString(); 1878 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1879 } 1880 key = new Integer(109).toString(); 1881 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1882 1883 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 1884 key = new Integer(100).toString(); 1885 assertNull(decendingMap.ceilingEntry(key)); 1886 for (int i = 101; i < 109; i++) { 1887 key = new Integer(i).toString(); 1888 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1889 } 1890 key = new Integer(109).toString(); 1891 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1892 1893 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 1894 key = new Integer(100).toString(); 1895 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1896 for (int i = 101; i < 109; i++) { 1897 key = new Integer(i).toString(); 1898 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1899 } 1900 key = new Integer(109).toString(); 1901 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1902 1903 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 1904 key = new Integer(100).toString(); 1905 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1906 for (int i = 101; i < 109; i++) { 1907 key = new Integer(i).toString(); 1908 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1909 } 1910 key = new Integer(109).toString(); 1911 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1912 1913 // With Comparator 1914 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 1915 .descendingMap(); 1916 key = new Integer(100).toString(); 1917 assertNull(decendingMap.ceilingEntry(key)); 1918 for (int i = 101; i < 109; i++) { 1919 key = new Integer(i).toString(); 1920 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1921 } 1922 key = new Integer(109).toString(); 1923 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1924 1925 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 1926 .descendingMap(); 1927 key = new Integer(100).toString(); 1928 assertNull(decendingMap.ceilingEntry(key)); 1929 for (int i = 101; i < 109; i++) { 1930 key = new Integer(i).toString(); 1931 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1932 } 1933 key = new Integer(109).toString(); 1934 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1935 1936 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 1937 .descendingMap(); 1938 key = new Integer(100).toString(); 1939 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1940 for (int i = 101; i < 109; i++) { 1941 key = new Integer(i).toString(); 1942 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1943 } 1944 key = new Integer(109).toString(); 1945 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1946 1947 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 1948 .descendingMap(); 1949 key = new Integer(100).toString(); 1950 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1951 for (int i = 101; i < 109; i++) { 1952 key = new Integer(i).toString(); 1953 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1954 } 1955 key = new Integer(109).toString(); 1956 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1957 } 1958 1959 public void test_DescendingSubMap_descendingMap() { 1960 NavigableMap decendingMap = tm.descendingMap(); 1961 NavigableMap decendingDecendingMap = decendingMap.descendingMap(); 1962 assertEquals(decendingMap, decendingDecendingMap); 1963 1964 NavigableMap decendingMapHeadMap = decendingMap.headMap( 1965 new Integer(990).toString(), false); 1966 NavigableMap decendingDecendingHeadMap = decendingMapHeadMap 1967 .descendingMap(); 1968 assertNotNull(decendingMapHeadMap); 1969 assertNotNull(decendingDecendingHeadMap); 1970 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 1971 1972 NavigableMap decendingMapTailMap = decendingMap.tailMap( 1973 new Integer(990).toString(), false); 1974 NavigableMap decendingDecendingTailMap = decendingMapTailMap 1975 .descendingMap(); 1976 assertNotNull(decendingMapTailMap); 1977 assertNotNull(decendingDecendingTailMap); 1978 // assertEquals(decendingMapTailMap,decendingDecendingTailMap); 1979 1980 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 1981 decendingDecendingMap = decendingMap.descendingMap(); 1982 assertEquals(decendingMap, decendingDecendingMap); 1983 1984 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 1985 false); 1986 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 1987 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 1988 1989 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 1990 false); 1991 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 1992 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 1993 1994 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 1995 decendingDecendingMap = decendingMap.descendingMap(); 1996 assertEquals(decendingMap, decendingDecendingMap); 1997 1998 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 1999 false); 2000 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 2001 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 2002 2003 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 2004 false); 2005 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 2006 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 2007 2008 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2009 decendingDecendingMap = decendingMap.descendingMap(); 2010 assertEquals(decendingMap, decendingDecendingMap); 2011 2012 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 2013 false); 2014 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 2015 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 2016 2017 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 2018 false); 2019 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 2020 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 2021 2022 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2023 decendingDecendingMap = decendingMap.descendingMap(); 2024 assertEquals(decendingMap, decendingDecendingMap); 2025 2026 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 2027 false); 2028 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 2029 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 2030 2031 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 2032 false); 2033 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 2034 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 2035 } 2036 2037 public void test_DescendingSubMap_firstEntry() { 2038 NavigableMap decendingMap = tm.descendingMap(); 2039 assertEquals(999, decendingMap.firstEntry().getValue()); 2040 2041 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2042 assertEquals(108, decendingMap.firstEntry().getValue()); 2043 2044 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2045 assertEquals(109, decendingMap.firstEntry().getValue()); 2046 2047 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2048 assertEquals(108, decendingMap.firstEntry().getValue()); 2049 2050 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2051 assertEquals(109, decendingMap.firstEntry().getValue()); 2052 } 2053 2054 public void test_DescendingSubMap_floorEntry() { 2055 NavigableMap decendingMap = tm.descendingMap(); 2056 String key = new Integer(-1).toString(); 2057 assertEquals(0, decendingMap.floorEntry(key).getValue()); 2058 for (int i = 0; i < objArray.length; i++) { 2059 key = objArray[i].toString(); 2060 assertEquals(objArray[i], decendingMap.floorEntry(key).getValue()); 2061 } 2062 key = new Integer(1000).toString(); 2063 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2064 key = new Integer(1001).toString(); 2065 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2066 2067 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2068 key = new Integer(100).toString(); 2069 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2070 for (int i = 101; i < 109; i++) { 2071 key = new Integer(i).toString(); 2072 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2073 } 2074 key = new Integer(109).toString(); 2075 assertNull(decendingMap.floorEntry(key)); 2076 2077 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2078 key = new Integer(100).toString(); 2079 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2080 for (int i = 101; i < 109; i++) { 2081 key = new Integer(i).toString(); 2082 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2083 } 2084 key = new Integer(109).toString(); 2085 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2086 2087 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2088 key = new Integer(100).toString(); 2089 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2090 for (int i = 101; i < 109; i++) { 2091 key = new Integer(i).toString(); 2092 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2093 } 2094 key = new Integer(109).toString(); 2095 assertNull(decendingMap.floorEntry(key)); 2096 2097 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2098 key = new Integer(100).toString(); 2099 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2100 for (int i = 101; i < 109; i++) { 2101 key = new Integer(i).toString(); 2102 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2103 } 2104 key = new Integer(109).toString(); 2105 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2106 2107 // With Comparator 2108 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 2109 .descendingMap(); 2110 key = new Integer(100).toString(); 2111 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2112 for (int i = 101; i < 109; i++) { 2113 key = new Integer(i).toString(); 2114 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2115 } 2116 key = new Integer(109).toString(); 2117 assertNull(decendingMap.floorEntry(key)); 2118 2119 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 2120 .descendingMap(); 2121 key = new Integer(100).toString(); 2122 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2123 for (int i = 101; i < 109; i++) { 2124 key = new Integer(i).toString(); 2125 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2126 } 2127 key = new Integer(109).toString(); 2128 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2129 2130 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 2131 .descendingMap(); 2132 key = new Integer(100).toString(); 2133 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2134 for (int i = 101; i < 109; i++) { 2135 key = new Integer(i).toString(); 2136 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2137 } 2138 key = new Integer(109).toString(); 2139 assertNull(decendingMap.floorEntry(key)); 2140 2141 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 2142 .descendingMap(); 2143 key = new Integer(100).toString(); 2144 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2145 for (int i = 101; i < 109; i++) { 2146 key = new Integer(i).toString(); 2147 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2148 } 2149 key = new Integer(109).toString(); 2150 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2151 } 2152 2153 public void test_DescendingSubMap_lastEntry() { 2154 NavigableMap decendingMap = tm.descendingMap(); 2155 assertEquals(0, decendingMap.lastEntry().getValue()); 2156 2157 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2158 assertEquals(101, decendingMap.lastEntry().getValue()); 2159 2160 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2161 assertEquals(101, decendingMap.lastEntry().getValue()); 2162 2163 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2164 assertEquals(100, decendingMap.lastEntry().getValue()); 2165 2166 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2167 assertEquals(100, decendingMap.lastEntry().getValue()); 2168 } 2169 2170 public void test_DescendingSubMap_higherEntry() { 2171 NavigableMap decendingMap; 2172 NavigableMap decendingTailMap; 2173 Integer value; 2174 Entry entry; 2175 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2176 value = new Integer(101); 2177 assertNull(decendingMap.higherEntry(value.toString())); 2178 2179 for (int i = 108; i > 101; i--) { 2180 value = new Integer(i); 2181 entry = decendingMap.higherEntry(value.toString()); 2182 assertEquals(value - 1, entry.getValue()); 2183 } 2184 2185 value = new Integer(109); 2186 entry = decendingMap.higherEntry(value.toString()); 2187 assertEquals(108, entry.getValue()); 2188 2189 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2190 false); 2191 value = new Integer(109); 2192 entry = decendingTailMap.higherEntry(value.toString()); 2193 assertEquals(103, entry.getValue()); 2194 2195 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2196 value = new Integer(100); 2197 assertNull(decendingMap.higherEntry(value.toString())); 2198 2199 for (int i = 108; i > 100; i--) { 2200 value = new Integer(i); 2201 entry = decendingMap.higherEntry(value.toString()); 2202 assertEquals(value - 1, entry.getValue()); 2203 } 2204 2205 value = new Integer(109); 2206 entry = decendingMap.higherEntry(value.toString()); 2207 assertEquals(108, entry.getValue()); 2208 2209 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2210 false); 2211 value = new Integer(109); 2212 entry = decendingTailMap.higherEntry(value.toString()); 2213 assertEquals(103, entry.getValue()); 2214 2215 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2216 value = new Integer(101); 2217 assertNull(decendingMap.higherEntry(value.toString())); 2218 2219 for (int i = 109; i > 101; i--) { 2220 value = new Integer(i); 2221 entry = decendingMap.higherEntry(value.toString()); 2222 assertEquals(value - 1, entry.getValue()); 2223 } 2224 2225 value = new Integer(2); 2226 entry = decendingMap.higherEntry(value.toString()); 2227 assertEquals(109, entry.getValue()); 2228 2229 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2230 false); 2231 value = new Integer(109); 2232 entry = decendingTailMap.higherEntry(value.toString()); 2233 assertEquals(103, entry.getValue()); 2234 2235 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2236 value = new Integer(100); 2237 assertNull(decendingMap.higherEntry(value.toString())); 2238 2239 for (int i = 109; i > 100; i--) { 2240 value = new Integer(i); 2241 entry = decendingMap.higherEntry(value.toString()); 2242 assertEquals(value - 1, entry.getValue()); 2243 } 2244 2245 value = new Integer(2); 2246 entry = decendingMap.higherEntry(value.toString()); 2247 assertEquals(109, entry.getValue()); 2248 2249 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2250 false); 2251 value = new Integer(109); 2252 entry = decendingTailMap.higherEntry(value.toString()); 2253 assertEquals(103, entry.getValue()); 2254 } 2255 2256 public void test_DescendingSubMap_lowerEntry() { 2257 NavigableMap decendingMap; 2258 NavigableMap decendingHeadMap; 2259 Integer value; 2260 Entry entry; 2261 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2262 value = new Integer(99); 2263 assertNull(decendingMap.lowerEntry(value.toString())); 2264 for (int i = 100; i < 108; i++) { 2265 value = new Integer(i); 2266 entry = decendingMap.lowerEntry(value.toString()); 2267 assertEquals(value + 1, entry.getValue()); 2268 } 2269 value = new Integer(109); 2270 assertNull(decendingMap.lowerEntry(value.toString())); 2271 2272 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2273 false); 2274 for (int i = 104; i < 106; i++) { 2275 value = new Integer(i); 2276 entry = decendingHeadMap.lowerEntry(value.toString()); 2277 assertEquals(value + 1, entry.getValue()); 2278 } 2279 value = new Integer(102); 2280 entry = decendingHeadMap.lowerEntry(value.toString()); 2281 assertEquals(104, entry.getValue()); 2282 2283 value = new Integer(109); 2284 entry = decendingHeadMap.lowerEntry(value.toString()); 2285 assertNull(entry); 2286 2287 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2288 value = new Integer(99); 2289 assertNull(decendingMap.lowerEntry(value.toString())); 2290 for (int i = 100; i < 109; i++) { 2291 value = new Integer(i); 2292 entry = decendingMap.lowerEntry(value.toString()); 2293 assertEquals(value + 1, entry.getValue()); 2294 } 2295 value = new Integer(110); 2296 assertNull(decendingMap.lowerEntry(value.toString())); 2297 2298 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2299 false); 2300 for (int i = 104; i < 109; i++) { 2301 value = new Integer(i); 2302 entry = decendingHeadMap.lowerEntry(value.toString()); 2303 assertEquals(value + 1, entry.getValue()); 2304 } 2305 value = new Integer(102); 2306 entry = decendingHeadMap.lowerEntry(value.toString()); 2307 assertEquals(104, entry.getValue()); 2308 2309 value = new Integer(2); 2310 entry = decendingHeadMap.lowerEntry(value.toString()); 2311 assertNull(entry); 2312 2313 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2314 value = new Integer(99); 2315 assertNull(decendingMap.lowerEntry(value.toString())); 2316 for (int i = 100; i < 108; i++) { 2317 value = new Integer(i); 2318 entry = decendingMap.lowerEntry(value.toString()); 2319 assertEquals(value + 1, entry.getValue()); 2320 } 2321 value = new Integer(109); 2322 assertNull(decendingMap.lowerEntry(value.toString())); 2323 2324 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2325 false); 2326 for (int i = 104; i < 107; i++) { 2327 value = new Integer(i); 2328 entry = decendingHeadMap.lowerEntry(value.toString()); 2329 assertEquals(value + 1, entry.getValue()); 2330 } 2331 value = new Integer(102); 2332 entry = decendingHeadMap.lowerEntry(value.toString()); 2333 assertEquals(104, entry.getValue()); 2334 2335 value = new Integer(2); 2336 entry = decendingHeadMap.lowerEntry(value.toString()); 2337 assertNull(entry); 2338 2339 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2340 value = new Integer(99); 2341 assertNull(decendingMap.lowerEntry(value.toString())); 2342 for (int i = 100; i < 109; i++) { 2343 value = new Integer(i); 2344 entry = decendingMap.lowerEntry(value.toString()); 2345 assertEquals(value + 1, entry.getValue()); 2346 } 2347 value = new Integer(110); 2348 assertNull(decendingMap.lowerEntry(value.toString())); 2349 2350 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2351 false); 2352 for (int i = 104; i < 109; i++) { 2353 value = new Integer(i); 2354 entry = decendingHeadMap.lowerEntry(value.toString()); 2355 assertEquals(value + 1, entry.getValue()); 2356 } 2357 value = new Integer(102); 2358 entry = decendingHeadMap.lowerEntry(value.toString()); 2359 assertEquals(104, entry.getValue()); 2360 2361 value = new Integer(2); 2362 entry = decendingHeadMap.lowerEntry(value.toString()); 2363 assertNull(entry); 2364 } 2365 2366 public void test_DescendingSubMap_pollFirstEntry() { 2367 NavigableMap decendingMap = tm.descendingMap(); 2368 assertEquals(999, decendingMap.pollFirstEntry().getValue()); 2369 2370 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2371 assertEquals(108, decendingMap.pollFirstEntry().getValue()); 2372 2373 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2374 assertEquals(109, decendingMap.pollFirstEntry().getValue()); 2375 2376 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2377 assertEquals(107, decendingMap.pollFirstEntry().getValue()); 2378 2379 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2380 assertEquals(106, decendingMap.pollFirstEntry().getValue()); 2381 } 2382 2383 public void test_DescendingSubMap_pollLastEntry() { 2384 NavigableMap decendingMap = tm.descendingMap(); 2385 assertEquals(0, decendingMap.pollLastEntry().getValue()); 2386 2387 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2388 assertEquals(101, decendingMap.pollLastEntry().getValue()); 2389 2390 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2391 assertEquals(102, decendingMap.pollLastEntry().getValue()); 2392 2393 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2394 assertEquals(100, decendingMap.pollLastEntry().getValue()); 2395 2396 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2397 assertEquals(103, decendingMap.pollLastEntry().getValue()); 2398 } 2399 2400 public void test_DescendingSubMap_values() { 2401 NavigableMap decendingMap = tm.descendingMap(); 2402 Collection values = decendingMap.values(); 2403 assertFalse(values.isEmpty()); 2404 assertFalse(values.contains(1000)); 2405 for (int i = 999; i > 0; i--) { 2406 assertTrue(values.contains(i)); 2407 } 2408 assertTrue(values.contains(0)); 2409 2410 String endKey = new Integer(99).toString(); 2411 NavigableMap headMap = decendingMap.headMap(endKey, false); 2412 values = headMap.values(); 2413 Iterator it = values.iterator(); 2414 for (int i = 999; i > 990; i--) { 2415 assertTrue(values.contains(i)); 2416 assertEquals(i, it.next()); 2417 } 2418 2419 String startKey = new Integer(11).toString(); 2420 NavigableMap tailMap = decendingMap.tailMap(startKey, false); 2421 values = tailMap.values(); 2422 it = values.iterator(); 2423 for (int i = 109; i > 100; i--) { 2424 assertTrue(values.contains(i)); 2425 assertEquals(i, it.next()); 2426 } 2427 2428 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2429 values = decendingMap.values(); 2430 assertFalse(values.isEmpty()); 2431 assertFalse(values.contains(109)); 2432 for (int i = 108; i > 100; i--) { 2433 assertTrue(values.contains(i)); 2434 } 2435 assertFalse(values.contains(100)); 2436 2437 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2438 values = decendingMap.values(); 2439 assertFalse(values.isEmpty()); 2440 assertFalse(values.contains(100)); 2441 for (int i = 108; i > 100; i--) { 2442 assertTrue(values.contains(i)); 2443 } 2444 assertTrue(values.contains(109)); 2445 2446 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2447 values = decendingMap.values(); 2448 assertFalse(values.isEmpty()); 2449 assertTrue(values.contains(100)); 2450 for (int i = 108; i > 100; i--) { 2451 assertTrue(values.contains(i)); 2452 } 2453 assertFalse(values.contains(109)); 2454 2455 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2456 values = decendingMap.values(); 2457 assertFalse(values.isEmpty()); 2458 assertTrue(values.contains(100)); 2459 for (int i = 108; i > 100; i--) { 2460 assertTrue(values.contains(i)); 2461 } 2462 assertTrue(values.contains(109)); 2463 } 2464 2465 public void test_DescendingSubMap_headMap() { 2466 NavigableMap decendingMap = tm.descendingMap(); 2467 String endKey = new Integer(0).toString(), key; 2468 SortedMap subDecendingMap_Included = decendingMap.headMap(endKey, true); 2469 SortedMap subDecendingMap_Excluded = decendingMap 2470 .headMap(endKey, false); 2471 key = endKey; 2472 assertTrue(subDecendingMap_Included.containsKey(key)); 2473 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2474 for (int i = 1; i < 1000; i++) { 2475 key = new Integer(i).toString(); 2476 assertTrue(subDecendingMap_Included.containsKey(key)); 2477 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2478 } 2479 key = new Integer(1000).toString(); 2480 assertFalse(subDecendingMap_Included.containsKey(key)); 2481 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2482 2483 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2484 endKey = new Integer(100).toString(); 2485 try { 2486 decendingMap.headMap(endKey, true); 2487 fail("should throw IllegalArgumentException"); 2488 } catch (IllegalArgumentException e) { 2489 // Expected 2490 } 2491 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2492 key = endKey; 2493 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2494 2495 endKey = new Integer(101).toString(); 2496 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2497 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2498 2499 key = endKey; 2500 assertTrue(subDecendingMap_Included.containsKey(key)); 2501 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2502 2503 for (int i = 102; i < 109; i++) { 2504 key = new Integer(i).toString(); 2505 assertTrue(subDecendingMap_Included.containsKey(key)); 2506 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2507 } 2508 key = new Integer(109).toString(); 2509 assertFalse(subDecendingMap_Included.containsKey(key)); 2510 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2511 2512 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2513 endKey = new Integer(100).toString(); 2514 try { 2515 decendingMap.headMap(endKey, true); 2516 fail("should throw IllegalArgumentException"); 2517 } catch (IllegalArgumentException e) { 2518 // Expected 2519 } 2520 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2521 key = endKey; 2522 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2523 2524 endKey = new Integer(101).toString(); 2525 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2526 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2527 2528 key = endKey; 2529 assertTrue(subDecendingMap_Included.containsKey(key)); 2530 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2531 2532 for (int i = 102; i < 109; i++) { 2533 key = new Integer(i).toString(); 2534 assertTrue(subDecendingMap_Included.containsKey(key)); 2535 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2536 } 2537 key = new Integer(109).toString(); 2538 assertTrue(subDecendingMap_Included.containsKey(key)); 2539 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2540 2541 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2542 endKey = new Integer(100).toString(); 2543 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2544 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2545 key = endKey; 2546 assertTrue(subDecendingMap_Included.containsKey(key)); 2547 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2548 2549 endKey = new Integer(101).toString(); 2550 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2551 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2552 2553 key = endKey; 2554 assertTrue(subDecendingMap_Included.containsKey(key)); 2555 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2556 2557 for (int i = 102; i < 109; i++) { 2558 key = new Integer(i).toString(); 2559 assertTrue(subDecendingMap_Included.containsKey(key)); 2560 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2561 } 2562 key = new Integer(109).toString(); 2563 assertFalse(subDecendingMap_Included.containsKey(key)); 2564 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2565 2566 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2567 endKey = new Integer(100).toString(); 2568 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2569 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2570 key = endKey; 2571 assertTrue(subDecendingMap_Included.containsKey(key)); 2572 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2573 2574 endKey = new Integer(101).toString(); 2575 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2576 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2577 2578 key = endKey; 2579 assertTrue(subDecendingMap_Included.containsKey(key)); 2580 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2581 2582 for (int i = 102; i < 109; i++) { 2583 key = new Integer(i).toString(); 2584 assertTrue(subDecendingMap_Included.containsKey(key)); 2585 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2586 } 2587 key = new Integer(109).toString(); 2588 assertTrue(subDecendingMap_Included.containsKey(key)); 2589 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2590 2591 // With Comparator 2592 2593 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 2594 .descendingMap(); 2595 endKey = new Integer(100).toString(); 2596 try { 2597 decendingMap.headMap(endKey, true); 2598 fail("should throw IllegalArgumentException"); 2599 } catch (IllegalArgumentException e) { 2600 // Expected 2601 } 2602 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2603 key = endKey; 2604 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2605 2606 endKey = new Integer(101).toString(); 2607 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2608 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2609 2610 key = endKey; 2611 assertTrue(subDecendingMap_Included.containsKey(key)); 2612 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2613 2614 for (int i = 102; i < 109; i++) { 2615 key = new Integer(i).toString(); 2616 assertTrue(subDecendingMap_Included.containsKey(key)); 2617 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2618 } 2619 key = new Integer(109).toString(); 2620 assertFalse(subDecendingMap_Included.containsKey(key)); 2621 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2622 2623 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 2624 .descendingMap(); 2625 endKey = new Integer(100).toString(); 2626 try { 2627 decendingMap.headMap(endKey, true); 2628 fail("should throw IllegalArgumentException"); 2629 } catch (IllegalArgumentException e) { 2630 // Expected 2631 } 2632 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2633 key = endKey; 2634 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2635 2636 endKey = new Integer(101).toString(); 2637 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2638 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2639 2640 key = endKey; 2641 assertTrue(subDecendingMap_Included.containsKey(key)); 2642 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2643 2644 for (int i = 102; i < 109; i++) { 2645 key = new Integer(i).toString(); 2646 assertTrue(subDecendingMap_Included.containsKey(key)); 2647 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2648 } 2649 key = new Integer(109).toString(); 2650 assertTrue(subDecendingMap_Included.containsKey(key)); 2651 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2652 2653 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 2654 .descendingMap(); 2655 endKey = new Integer(100).toString(); 2656 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2657 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2658 key = endKey; 2659 assertTrue(subDecendingMap_Included.containsKey(key)); 2660 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2661 2662 endKey = new Integer(101).toString(); 2663 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2664 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2665 2666 key = endKey; 2667 assertTrue(subDecendingMap_Included.containsKey(key)); 2668 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2669 2670 for (int i = 102; i < 109; i++) { 2671 key = new Integer(i).toString(); 2672 assertTrue(subDecendingMap_Included.containsKey(key)); 2673 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2674 } 2675 key = new Integer(109).toString(); 2676 assertFalse(subDecendingMap_Included.containsKey(key)); 2677 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2678 2679 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 2680 .descendingMap(); 2681 endKey = new Integer(100).toString(); 2682 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2683 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2684 key = endKey; 2685 assertTrue(subDecendingMap_Included.containsKey(key)); 2686 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2687 2688 endKey = new Integer(101).toString(); 2689 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2690 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2691 2692 key = endKey; 2693 assertTrue(subDecendingMap_Included.containsKey(key)); 2694 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2695 2696 for (int i = 102; i < 109; i++) { 2697 key = new Integer(i).toString(); 2698 assertTrue(subDecendingMap_Included.containsKey(key)); 2699 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2700 } 2701 key = new Integer(109).toString(); 2702 assertTrue(subDecendingMap_Included.containsKey(key)); 2703 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2704 } 2705 2706 public void test_DescendingSubMap_subMap() { 2707 NavigableMap descendingMap = tm.descendingMap(); 2708 String startKey = new Integer(109).toString(); 2709 String endKey = new Integer(100).toString(); 2710 try { 2711 descendingMap.subMap(endKey, false, startKey, false); 2712 } catch (IllegalArgumentException e) { 2713 // Expected 2714 } 2715 2716 SortedMap subDescendingMap = descendingMap.subMap(startKey, false, 2717 endKey, false); 2718 String key = new Integer(100).toString(); 2719 assertFalse(subDescendingMap.containsKey(key)); 2720 for (int i = 101; i < 109; i++) { 2721 key = new Integer(i).toString(); 2722 assertTrue(subDescendingMap.containsKey(key)); 2723 } 2724 key = new Integer(109).toString(); 2725 assertFalse(subDescendingMap.containsKey(key)); 2726 2727 subDescendingMap = descendingMap.subMap(startKey, false, endKey, true); 2728 key = new Integer(100).toString(); 2729 assertTrue(subDescendingMap.containsKey(key)); 2730 for (int i = 101; i < 109; i++) { 2731 key = new Integer(i).toString(); 2732 assertTrue(subDescendingMap.containsKey(key)); 2733 } 2734 key = new Integer(109).toString(); 2735 assertFalse(subDescendingMap.containsKey(key)); 2736 2737 subDescendingMap = descendingMap.subMap(startKey, true, endKey, false); 2738 key = new Integer(100).toString(); 2739 assertFalse(subDescendingMap.containsKey(key)); 2740 for (int i = 101; i < 109; i++) { 2741 key = new Integer(i).toString(); 2742 assertTrue(subDescendingMap.containsKey(key)); 2743 } 2744 key = new Integer(109).toString(); 2745 assertTrue(subDescendingMap.containsKey(key)); 2746 2747 subDescendingMap = descendingMap.subMap(startKey, true, endKey, true); 2748 key = new Integer(100).toString(); 2749 assertTrue(subDescendingMap.containsKey(key)); 2750 for (int i = 101; i < 109; i++) { 2751 key = new Integer(i).toString(); 2752 assertTrue(subDescendingMap.containsKey(key)); 2753 } 2754 key = new Integer(109).toString(); 2755 assertTrue(subDescendingMap.containsKey(key)); 2756 2757 TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>(); 2758 for (int i = -10; i < 10; i++) { 2759 treeMap.put(i, String.valueOf(i)); 2760 } 2761 descendingMap = treeMap.descendingMap(); 2762 subDescendingMap = descendingMap.subMap(5, 0); 2763 assertEquals(5, subDescendingMap.size()); 2764 } 2765 2766 public void test_DescendingSubMap_tailMap() { 2767 // tm 2768 NavigableMap decendingMap = tm.descendingMap(); 2769 String endKey = new Integer(1000).toString(), key; 2770 SortedMap subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2771 SortedMap subDecendingMap_Excluded = decendingMap 2772 .tailMap(endKey, false); 2773 2774 key = endKey; 2775 assertFalse(subDecendingMap_Included.containsKey(key)); 2776 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2777 key = new Integer(100).toString(); 2778 assertTrue(subDecendingMap_Included.containsKey(key)); 2779 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2780 2781 key = new Integer(10).toString(); 2782 assertTrue(subDecendingMap_Included.containsKey(key)); 2783 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2784 2785 key = new Integer(1).toString(); 2786 assertTrue(subDecendingMap_Included.containsKey(key)); 2787 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2788 2789 key = new Integer(0).toString(); 2790 assertTrue(subDecendingMap_Included.containsKey(key)); 2791 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2792 2793 endKey = new Integer(999).toString(); 2794 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2795 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2796 key = endKey; 2797 assertTrue(subDecendingMap_Included.containsKey(key)); 2798 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2799 for (int i = 998; i > 0; i--) { 2800 key = new Integer(i).toString(); 2801 assertTrue(subDecendingMap_Included.containsKey(key)); 2802 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2803 } 2804 key = new Integer(0).toString(); 2805 assertTrue(subDecendingMap_Included.containsKey(key)); 2806 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2807 2808 endKey = new Integer(0).toString(); 2809 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2810 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2811 assertEquals(1, subDecendingMap_Included.size()); 2812 key = endKey; 2813 assertTrue(subDecendingMap_Included.containsKey(key)); 2814 assertTrue(subDecendingMap_Excluded.isEmpty()); 2815 2816 // navigableMap_startExcluded_endExcluded 2817 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2818 endKey = new Integer(110).toString(); 2819 try { 2820 decendingMap.tailMap(endKey, true); 2821 fail("should throw IllegalArgumentException"); 2822 } catch (IllegalArgumentException e) { 2823 // Expected 2824 } 2825 2826 try { 2827 decendingMap.tailMap(endKey, false); 2828 fail("should throw IllegalArgumentException"); 2829 } catch (IllegalArgumentException e) { 2830 // Expected 2831 } 2832 2833 endKey = new Integer(109).toString(); 2834 try { 2835 decendingMap.tailMap(endKey, true); 2836 fail("should throw IllegalArgumentException"); 2837 } catch (IllegalArgumentException e) { 2838 // Expected 2839 } 2840 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2841 key = endKey; 2842 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2843 2844 endKey = new Integer(108).toString(); 2845 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2846 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2847 key = endKey; 2848 assertTrue(subDecendingMap_Included.containsKey(key)); 2849 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2850 for (int i = 107; i > 100; i--) { 2851 key = new Integer(i).toString(); 2852 assertTrue(subDecendingMap_Included.containsKey(key)); 2853 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2854 } 2855 key = new Integer(100).toString(); 2856 assertFalse(subDecendingMap_Included.containsKey(key)); 2857 assertFalse(subDecendingMap_Included.containsKey(key)); 2858 2859 endKey = new Integer(101).toString(); 2860 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2861 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2862 key = endKey; 2863 assertEquals(1, subDecendingMap_Included.size()); 2864 assertTrue(subDecendingMap_Included.containsKey(key)); 2865 assertTrue(subDecendingMap_Excluded.isEmpty()); 2866 2867 endKey = new Integer(100).toString(); 2868 try { 2869 decendingMap.tailMap(endKey, true); 2870 fail("should throw IllegalArgumentException"); 2871 } catch (IllegalArgumentException e) { 2872 // Expected 2873 } 2874 try { 2875 decendingMap.tailMap(endKey, false); 2876 fail("should throw IllegalArgumentException"); 2877 } catch (IllegalArgumentException e) { 2878 // Expected 2879 } 2880 2881 endKey = new Integer(99).toString(); 2882 try { 2883 decendingMap.tailMap(endKey, true); 2884 fail("should throw IllegalArgumentException"); 2885 } catch (IllegalArgumentException e) { 2886 // Expected 2887 } 2888 2889 try { 2890 decendingMap.tailMap(endKey, false); 2891 fail("should throw IllegalArgumentException"); 2892 } catch (IllegalArgumentException e) { 2893 // Expected 2894 } 2895 2896 // navigableMap_startExcluded_endIncluded 2897 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2898 endKey = new Integer(110).toString(); 2899 try { 2900 decendingMap.tailMap(endKey, true); 2901 fail("should throw IllegalArgumentException"); 2902 } catch (IllegalArgumentException e) { 2903 // Expected 2904 } 2905 2906 try { 2907 decendingMap.tailMap(endKey, false); 2908 fail("should throw IllegalArgumentException"); 2909 } catch (IllegalArgumentException e) { 2910 // Expected 2911 } 2912 2913 endKey = new Integer(109).toString(); 2914 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2915 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2916 key = endKey; 2917 assertTrue(subDecendingMap_Included.containsKey(key)); 2918 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2919 2920 endKey = new Integer(108).toString(); 2921 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2922 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2923 key = endKey; 2924 assertTrue(subDecendingMap_Included.containsKey(key)); 2925 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2926 for (int i = 107; i > 100; i--) { 2927 key = new Integer(i).toString(); 2928 assertTrue(subDecendingMap_Included.containsKey(key)); 2929 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2930 } 2931 key = new Integer(100).toString(); 2932 assertFalse(subDecendingMap_Included.containsKey(key)); 2933 assertFalse(subDecendingMap_Included.containsKey(key)); 2934 2935 endKey = new Integer(101).toString(); 2936 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2937 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2938 key = endKey; 2939 assertEquals(1, subDecendingMap_Included.size()); 2940 assertTrue(subDecendingMap_Included.containsKey(key)); 2941 assertTrue(subDecendingMap_Excluded.isEmpty()); 2942 2943 endKey = new Integer(100).toString(); 2944 try { 2945 decendingMap.tailMap(endKey, true); 2946 fail("should throw IllegalArgumentException"); 2947 } catch (IllegalArgumentException e) { 2948 // Expected 2949 } 2950 try { 2951 decendingMap.tailMap(endKey, false); 2952 fail("should throw IllegalArgumentException"); 2953 } catch (IllegalArgumentException e) { 2954 // Expected 2955 } 2956 2957 endKey = new Integer(99).toString(); 2958 try { 2959 decendingMap.tailMap(endKey, true); 2960 fail("should throw IllegalArgumentException"); 2961 } catch (IllegalArgumentException e) { 2962 // Expected 2963 } 2964 try { 2965 decendingMap.tailMap(endKey, false); 2966 fail("should throw IllegalArgumentException"); 2967 } catch (IllegalArgumentException e) { 2968 // Expected 2969 } 2970 2971 // navigableMap_startIncluded_endExcluded 2972 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2973 endKey = new Integer(110).toString(); 2974 try { 2975 decendingMap.tailMap(endKey, true); 2976 fail("should throw IllegalArgumentException"); 2977 } catch (IllegalArgumentException e) { 2978 // Expected 2979 } 2980 2981 try { 2982 decendingMap.tailMap(endKey, false); 2983 fail("should throw IllegalArgumentException"); 2984 } catch (IllegalArgumentException e) { 2985 // Expected 2986 } 2987 2988 endKey = new Integer(109).toString(); 2989 try { 2990 decendingMap.tailMap(endKey, true); 2991 2992 } catch (IllegalArgumentException e) { 2993 // Expected 2994 } 2995 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2996 key = endKey; 2997 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2998 2999 endKey = new Integer(108).toString(); 3000 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3001 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3002 key = endKey; 3003 assertTrue(subDecendingMap_Included.containsKey(key)); 3004 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3005 for (int i = 107; i > 100; i--) { 3006 key = new Integer(i).toString(); 3007 assertTrue(subDecendingMap_Included.containsKey(key)); 3008 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3009 } 3010 key = new Integer(100).toString(); 3011 assertTrue(subDecendingMap_Included.containsKey(key)); 3012 assertTrue(subDecendingMap_Included.containsKey(key)); 3013 3014 endKey = new Integer(101).toString(); 3015 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3016 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3017 key = endKey; 3018 assertEquals(2, subDecendingMap_Included.size()); 3019 assertTrue(subDecendingMap_Included.containsKey(key)); 3020 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3021 3022 endKey = new Integer(100).toString(); 3023 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3024 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3025 key = endKey; 3026 assertTrue(subDecendingMap_Included.containsKey(key)); 3027 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3028 3029 endKey = new Integer(99).toString(); 3030 try { 3031 decendingMap.tailMap(endKey, true); 3032 fail("should throw IllegalArgumentException"); 3033 } catch (IllegalArgumentException e) { 3034 // Expected 3035 } 3036 try { 3037 decendingMap.tailMap(endKey, false); 3038 fail("should throw IllegalArgumentException"); 3039 } catch (IllegalArgumentException e) { 3040 // Expected 3041 } 3042 3043 // navigableMap_startIncluded_endIncluded 3044 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 3045 endKey = new Integer(110).toString(); 3046 try { 3047 decendingMap.tailMap(endKey, true); 3048 fail("should throw IllegalArgumentException"); 3049 } catch (IllegalArgumentException e) { 3050 // Expected 3051 } 3052 try { 3053 decendingMap.tailMap(endKey, false); 3054 fail("should throw IllegalArgumentException"); 3055 } catch (IllegalArgumentException e) { 3056 // Expected 3057 } 3058 3059 endKey = new Integer(109).toString(); 3060 try { 3061 decendingMap.tailMap(endKey, true); 3062 3063 } catch (IllegalArgumentException e) { 3064 // Expected 3065 } 3066 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3067 key = endKey; 3068 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3069 3070 endKey = new Integer(108).toString(); 3071 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3072 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3073 key = endKey; 3074 assertTrue(subDecendingMap_Included.containsKey(key)); 3075 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3076 for (int i = 107; i > 100; i--) { 3077 key = new Integer(i).toString(); 3078 assertTrue(subDecendingMap_Included.containsKey(key)); 3079 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3080 } 3081 key = new Integer(100).toString(); 3082 assertTrue(subDecendingMap_Included.containsKey(key)); 3083 assertTrue(subDecendingMap_Included.containsKey(key)); 3084 3085 endKey = new Integer(101).toString(); 3086 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3087 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3088 key = endKey; 3089 assertEquals(2, subDecendingMap_Included.size()); 3090 assertTrue(subDecendingMap_Included.containsKey(key)); 3091 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3092 3093 endKey = new Integer(100).toString(); 3094 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3095 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3096 key = endKey; 3097 assertTrue(subDecendingMap_Included.containsKey(key)); 3098 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3099 3100 endKey = new Integer(99).toString(); 3101 try { 3102 decendingMap.tailMap(endKey, true); 3103 fail("should throw IllegalArgumentException"); 3104 } catch (IllegalArgumentException e) { 3105 // Expected 3106 } 3107 try { 3108 decendingMap.tailMap(endKey, false); 3109 fail("should throw IllegalArgumentException"); 3110 } catch (IllegalArgumentException e) { 3111 // Expected 3112 } 3113 3114 // With Comparator 3115 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 3116 .descendingMap(); 3117 endKey = new Integer(110).toString(); 3118 try { 3119 decendingMap.tailMap(endKey, true); 3120 fail("should throw IllegalArgumentException"); 3121 } catch (IllegalArgumentException e) { 3122 // Expected 3123 } 3124 3125 try { 3126 decendingMap.tailMap(endKey, false); 3127 fail("should throw IllegalArgumentException"); 3128 } catch (IllegalArgumentException e) { 3129 // Expected 3130 } 3131 3132 endKey = new Integer(109).toString(); 3133 try { 3134 decendingMap.tailMap(endKey, true); 3135 fail("should throw IllegalArgumentException"); 3136 } catch (IllegalArgumentException e) { 3137 // Expected 3138 } 3139 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3140 key = endKey; 3141 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3142 3143 endKey = new Integer(108).toString(); 3144 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3145 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3146 key = endKey; 3147 assertTrue(subDecendingMap_Included.containsKey(key)); 3148 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3149 for (int i = 107; i > 100; i--) { 3150 key = new Integer(i).toString(); 3151 assertTrue(subDecendingMap_Included.containsKey(key)); 3152 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3153 } 3154 key = new Integer(100).toString(); 3155 assertFalse(subDecendingMap_Included.containsKey(key)); 3156 assertFalse(subDecendingMap_Included.containsKey(key)); 3157 3158 endKey = new Integer(101).toString(); 3159 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3160 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3161 key = endKey; 3162 assertEquals(1, subDecendingMap_Included.size()); 3163 assertTrue(subDecendingMap_Included.containsKey(key)); 3164 assertTrue(subDecendingMap_Excluded.isEmpty()); 3165 3166 endKey = new Integer(100).toString(); 3167 try { 3168 decendingMap.tailMap(endKey, true); 3169 fail("should throw IllegalArgumentException"); 3170 } catch (IllegalArgumentException e) { 3171 // Expected 3172 } 3173 try { 3174 decendingMap.tailMap(endKey, false); 3175 fail("should throw IllegalArgumentException"); 3176 } catch (IllegalArgumentException e) { 3177 // Expected 3178 } 3179 3180 endKey = new Integer(99).toString(); 3181 try { 3182 decendingMap.tailMap(endKey, true); 3183 fail("should throw IllegalArgumentException"); 3184 } catch (IllegalArgumentException e) { 3185 // Expected 3186 } 3187 3188 try { 3189 decendingMap.tailMap(endKey, false); 3190 fail("should throw IllegalArgumentException"); 3191 } catch (IllegalArgumentException e) { 3192 // Expected 3193 } 3194 3195 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 3196 .descendingMap(); 3197 endKey = new Integer(110).toString(); 3198 try { 3199 decendingMap.tailMap(endKey, true); 3200 fail("should throw IllegalArgumentException"); 3201 } catch (IllegalArgumentException e) { 3202 // Expected 3203 } 3204 3205 try { 3206 decendingMap.tailMap(endKey, false); 3207 fail("should throw IllegalArgumentException"); 3208 } catch (IllegalArgumentException e) { 3209 // Expected 3210 } 3211 3212 endKey = new Integer(109).toString(); 3213 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3214 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3215 key = endKey; 3216 assertTrue(subDecendingMap_Included.containsKey(key)); 3217 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3218 3219 endKey = new Integer(108).toString(); 3220 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3221 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3222 key = endKey; 3223 assertTrue(subDecendingMap_Included.containsKey(key)); 3224 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3225 for (int i = 107; i > 100; i--) { 3226 key = new Integer(i).toString(); 3227 assertTrue(subDecendingMap_Included.containsKey(key)); 3228 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3229 } 3230 key = new Integer(100).toString(); 3231 assertFalse(subDecendingMap_Included.containsKey(key)); 3232 assertFalse(subDecendingMap_Included.containsKey(key)); 3233 3234 endKey = new Integer(101).toString(); 3235 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3236 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3237 key = endKey; 3238 assertEquals(1, subDecendingMap_Included.size()); 3239 assertTrue(subDecendingMap_Included.containsKey(key)); 3240 assertTrue(subDecendingMap_Excluded.isEmpty()); 3241 3242 endKey = new Integer(100).toString(); 3243 try { 3244 decendingMap.tailMap(endKey, true); 3245 fail("should throw IllegalArgumentException"); 3246 } catch (IllegalArgumentException e) { 3247 // Expected 3248 } 3249 try { 3250 decendingMap.tailMap(endKey, false); 3251 fail("should throw IllegalArgumentException"); 3252 } catch (IllegalArgumentException e) { 3253 // Expected 3254 } 3255 3256 endKey = new Integer(99).toString(); 3257 try { 3258 decendingMap.tailMap(endKey, true); 3259 fail("should throw IllegalArgumentException"); 3260 } catch (IllegalArgumentException e) { 3261 // Expected 3262 } 3263 try { 3264 decendingMap.tailMap(endKey, false); 3265 fail("should throw IllegalArgumentException"); 3266 } catch (IllegalArgumentException e) { 3267 // Expected 3268 } 3269 3270 // navigableMap_startIncluded_endExcluded 3271 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded) 3272 .descendingMap(); 3273 endKey = new Integer(110).toString(); 3274 try { 3275 decendingMap.tailMap(endKey, true); 3276 fail("should throw IllegalArgumentException"); 3277 } catch (IllegalArgumentException e) { 3278 // Expected 3279 } 3280 3281 try { 3282 decendingMap.tailMap(endKey, false); 3283 fail("should throw IllegalArgumentException"); 3284 } catch (IllegalArgumentException e) { 3285 // Expected 3286 } 3287 3288 endKey = new Integer(109).toString(); 3289 try { 3290 decendingMap.tailMap(endKey, true); 3291 3292 } catch (IllegalArgumentException e) { 3293 // Expected 3294 } 3295 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3296 key = endKey; 3297 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3298 3299 endKey = new Integer(108).toString(); 3300 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3301 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3302 key = endKey; 3303 assertTrue(subDecendingMap_Included.containsKey(key)); 3304 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3305 for (int i = 107; i > 100; i--) { 3306 key = new Integer(i).toString(); 3307 assertTrue(subDecendingMap_Included.containsKey(key)); 3308 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3309 } 3310 key = new Integer(100).toString(); 3311 assertTrue(subDecendingMap_Included.containsKey(key)); 3312 assertTrue(subDecendingMap_Included.containsKey(key)); 3313 3314 endKey = new Integer(101).toString(); 3315 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3316 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3317 key = endKey; 3318 assertEquals(2, subDecendingMap_Included.size()); 3319 assertTrue(subDecendingMap_Included.containsKey(key)); 3320 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3321 3322 endKey = new Integer(100).toString(); 3323 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3324 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3325 key = endKey; 3326 assertTrue(subDecendingMap_Included.containsKey(key)); 3327 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3328 3329 endKey = new Integer(99).toString(); 3330 try { 3331 decendingMap.tailMap(endKey, true); 3332 fail("should throw IllegalArgumentException"); 3333 } catch (IllegalArgumentException e) { 3334 // Expected 3335 } 3336 try { 3337 decendingMap.tailMap(endKey, false); 3338 fail("should throw IllegalArgumentException"); 3339 } catch (IllegalArgumentException e) { 3340 // Expected 3341 } 3342 3343 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded) 3344 .descendingMap(); 3345 endKey = new Integer(110).toString(); 3346 try { 3347 decendingMap.tailMap(endKey, true); 3348 fail("should throw IllegalArgumentException"); 3349 } catch (IllegalArgumentException e) { 3350 // Expected 3351 } 3352 try { 3353 decendingMap.tailMap(endKey, false); 3354 fail("should throw IllegalArgumentException"); 3355 } catch (IllegalArgumentException e) { 3356 // Expected 3357 } 3358 3359 endKey = new Integer(109).toString(); 3360 try { 3361 decendingMap.tailMap(endKey, true); 3362 3363 } catch (IllegalArgumentException e) { 3364 // Expected 3365 } 3366 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3367 key = endKey; 3368 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3369 3370 endKey = new Integer(108).toString(); 3371 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3372 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3373 key = endKey; 3374 assertTrue(subDecendingMap_Included.containsKey(key)); 3375 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3376 for (int i = 107; i > 100; i--) { 3377 key = new Integer(i).toString(); 3378 assertTrue(subDecendingMap_Included.containsKey(key)); 3379 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3380 } 3381 key = new Integer(100).toString(); 3382 assertTrue(subDecendingMap_Included.containsKey(key)); 3383 assertTrue(subDecendingMap_Included.containsKey(key)); 3384 3385 endKey = new Integer(101).toString(); 3386 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3387 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3388 key = endKey; 3389 assertEquals(2, subDecendingMap_Included.size()); 3390 assertTrue(subDecendingMap_Included.containsKey(key)); 3391 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3392 3393 endKey = new Integer(100).toString(); 3394 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3395 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3396 key = endKey; 3397 assertTrue(subDecendingMap_Included.containsKey(key)); 3398 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3399 3400 endKey = new Integer(99).toString(); 3401 try { 3402 decendingMap.tailMap(endKey, true); 3403 fail("should throw IllegalArgumentException"); 3404 } catch (IllegalArgumentException e) { 3405 // Expected 3406 } 3407 try { 3408 decendingMap.tailMap(endKey, false); 3409 fail("should throw IllegalArgumentException"); 3410 } catch (IllegalArgumentException e) { 3411 // Expected 3412 } 3413 } 3414 3415 public void test_Entry_setValue() { 3416 TreeMap treeMap = new TreeMap(); 3417 Integer value = null; 3418 for (int i = 0; i < 50; i++) { 3419 value = new Integer(i); 3420 treeMap.put(value, value); 3421 } 3422 Map checkedMap = Collections.checkedMap(treeMap, Integer.class, 3423 Integer.class); 3424 Set entrySet = checkedMap.entrySet(); 3425 Iterator iterator = entrySet.iterator(); 3426 Entry entry; 3427 value = new Integer(0); 3428 for (; iterator.hasNext(); value++) { 3429 entry = (Entry) iterator.next(); 3430 assertEquals(value, entry.setValue(value + 1)); 3431 assertEquals(value + 1, entry.getValue()); 3432 } 3433 } 3434 3435 public void test_DescendingSubMapEntrySet_comparator() { 3436 Set entrySet; 3437 NavigableSet descendingSet; 3438 Comparator comparator; 3439 Entry[] entryArray; 3440 Integer value1, value2; 3441 3442 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3443 if (entrySet instanceof NavigableSet) { 3444 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3445 assertNull(((NavigableSet) entrySet).comparator()); 3446 comparator = descendingSet.comparator(); 3447 assertNotNull(comparator); 3448 3449 entryArray = (Entry[]) descendingSet 3450 .toArray(new Entry[descendingSet.size()]); 3451 for (int i = 1; i < entryArray.length; i++) { 3452 value1 = (Integer) entryArray[i - 1].getValue(); 3453 value2 = (Integer) entryArray[i].getValue(); 3454 assertTrue(value1 > value2); 3455 assertTrue(comparator.compare(value1, value2) < 0); 3456 } 3457 } 3458 3459 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3460 if (entrySet instanceof NavigableSet) { 3461 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3462 assertNull(((NavigableSet) entrySet).comparator()); 3463 comparator = descendingSet.comparator(); 3464 assertNotNull(comparator); 3465 3466 entryArray = (Entry[]) descendingSet 3467 .toArray(new Entry[descendingSet.size()]); 3468 for (int i = 1; i < entryArray.length; i++) { 3469 value1 = (Integer) entryArray[i - 1].getValue(); 3470 value2 = (Integer) entryArray[i].getValue(); 3471 assertTrue(value1 > value2); 3472 assertTrue(comparator.compare(value1, value2) < 0); 3473 } 3474 } 3475 3476 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3477 if (entrySet instanceof NavigableSet) { 3478 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3479 assertNull(((NavigableSet) entrySet).comparator()); 3480 comparator = descendingSet.comparator(); 3481 assertNotNull(comparator); 3482 3483 entryArray = (Entry[]) descendingSet 3484 .toArray(new Entry[descendingSet.size()]); 3485 for (int i = 1; i < entryArray.length; i++) { 3486 value1 = (Integer) entryArray[i - 1].getValue(); 3487 value2 = (Integer) entryArray[i].getValue(); 3488 assertTrue(value1 > value2); 3489 assertTrue(comparator.compare(value1, value2) < 0); 3490 } 3491 } 3492 3493 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3494 if (entrySet instanceof NavigableSet) { 3495 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3496 assertNull(((NavigableSet) entrySet).comparator()); 3497 comparator = descendingSet.comparator(); 3498 assertNotNull(comparator); 3499 3500 entryArray = (Entry[]) descendingSet 3501 .toArray(new Entry[descendingSet.size()]); 3502 for (int i = 1; i < entryArray.length; i++) { 3503 value1 = (Integer) entryArray[i - 1].getValue(); 3504 value2 = (Integer) entryArray[i].getValue(); 3505 assertTrue(value1 > value2); 3506 assertTrue(comparator.compare(value1, value2) < 0); 3507 } 3508 } 3509 3510 String endKey = new Integer(2).toString(); 3511 entrySet = tm.headMap(endKey, true).entrySet(); 3512 if (entrySet instanceof NavigableSet) { 3513 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3514 assertNotNull(descendingSet.comparator()); 3515 } 3516 } 3517 3518 public void test_DescendingSubMapEntrySet_descendingSet() { 3519 Set entrySet; 3520 NavigableSet ascendingSubMapEntrySet, descendingSet, descendingDescedingSet; 3521 Entry[] ascendingEntryArray, descendingDescendingArray; 3522 3523 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3524 if (entrySet instanceof NavigableSet) { 3525 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3526 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3527 descendingDescedingSet = descendingSet.descendingSet(); 3528 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3529 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3530 3531 descendingDescendingArray = (Entry[]) descendingDescedingSet 3532 .toArray(new Entry[descendingDescedingSet.size()]); 3533 3534 assertEquals(ascendingEntryArray.length, 3535 descendingDescendingArray.length); 3536 for (int i = 0; i < ascendingEntryArray.length; i++) { 3537 assertEquals(ascendingEntryArray[i], 3538 descendingDescendingArray[i]); 3539 } 3540 } 3541 3542 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3543 if (entrySet instanceof NavigableSet) { 3544 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3545 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3546 descendingDescedingSet = descendingSet.descendingSet(); 3547 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3548 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3549 3550 descendingDescendingArray = (Entry[]) descendingDescedingSet 3551 .toArray(new Entry[descendingDescedingSet.size()]); 3552 3553 assertEquals(ascendingEntryArray.length, 3554 descendingDescendingArray.length); 3555 for (int i = 0; i < ascendingEntryArray.length; i++) { 3556 assertEquals(ascendingEntryArray[i], 3557 descendingDescendingArray[i]); 3558 } 3559 } 3560 3561 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3562 if (entrySet instanceof NavigableSet) { 3563 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3564 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3565 descendingDescedingSet = descendingSet.descendingSet(); 3566 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3567 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3568 3569 descendingDescendingArray = (Entry[]) descendingDescedingSet 3570 .toArray(new Entry[descendingDescedingSet.size()]); 3571 3572 assertEquals(ascendingEntryArray.length, 3573 descendingDescendingArray.length); 3574 for (int i = 0; i < ascendingEntryArray.length; i++) { 3575 assertEquals(ascendingEntryArray[i], 3576 descendingDescendingArray[i]); 3577 } 3578 } 3579 3580 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3581 if (entrySet instanceof NavigableSet) { 3582 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3583 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3584 descendingDescedingSet = descendingSet.descendingSet(); 3585 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3586 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3587 3588 descendingDescendingArray = (Entry[]) descendingDescedingSet 3589 .toArray(new Entry[descendingDescedingSet.size()]); 3590 3591 assertEquals(ascendingEntryArray.length, 3592 descendingDescendingArray.length); 3593 for (int i = 0; i < ascendingEntryArray.length; i++) { 3594 assertEquals(ascendingEntryArray[i], 3595 descendingDescendingArray[i]); 3596 } 3597 } 3598 3599 String endKey = new Integer(2).toString(); 3600 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 3601 if (entrySet instanceof NavigableSet) { 3602 // [2...0] 3603 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3604 // [0...2] 3605 descendingDescedingSet = descendingSet.descendingSet(); 3606 Iterator iterator = descendingDescedingSet.iterator(); 3607 assertEquals(0, ((Entry) iterator.next()).getValue()); 3608 } 3609 3610 String startKey = new Integer(2).toString(); 3611 entrySet = tm.tailMap(startKey, true).entrySet();// 2... 3612 if (entrySet instanceof NavigableSet) { 3613 // [2...0] 3614 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3615 // [0...2] 3616 descendingDescedingSet = descendingSet.descendingSet(); 3617 Iterator iterator = descendingDescedingSet.iterator(); 3618 assertEquals(2, ((Entry) iterator.next()).getValue()); 3619 } 3620 3621 } 3622 3623 public void test_DescendingSubMapEntrySet_first() { 3624 Set entrySet; 3625 NavigableSet ascendingSubMapEntrySet, descendingSet; 3626 Entry entry; 3627 3628 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3629 if (entrySet instanceof NavigableSet) { 3630 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3631 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3632 entry = (Entry) descendingSet.first(); 3633 assertEquals(101, entry.getValue()); 3634 } 3635 3636 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3637 if (entrySet instanceof NavigableSet) { 3638 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3639 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3640 entry = (Entry) descendingSet.first(); 3641 assertEquals(101, entry.getValue()); 3642 } 3643 3644 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3645 if (entrySet instanceof NavigableSet) { 3646 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3647 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3648 entry = (Entry) descendingSet.first(); 3649 assertEquals(100, entry.getValue()); 3650 } 3651 3652 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3653 if (entrySet instanceof NavigableSet) { 3654 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3655 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3656 entry = (Entry) descendingSet.first(); 3657 assertEquals(100, entry.getValue()); 3658 } 3659 } 3660 3661 public void test_DescendingSubMapEntrySet_last() { 3662 Set entrySet; 3663 NavigableSet ascendingSubMapEntrySet, descendingSet; 3664 Entry entry; 3665 3666 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3667 if (entrySet instanceof NavigableSet) { 3668 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3669 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3670 entry = (Entry) descendingSet.last(); 3671 assertEquals(108, entry.getValue()); 3672 } 3673 3674 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3675 if (entrySet instanceof NavigableSet) { 3676 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3677 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3678 entry = (Entry) descendingSet.last(); 3679 assertEquals(109, entry.getValue()); 3680 } 3681 3682 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3683 if (entrySet instanceof NavigableSet) { 3684 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3685 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3686 entry = (Entry) descendingSet.last(); 3687 assertEquals(108, entry.getValue()); 3688 } 3689 3690 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3691 if (entrySet instanceof NavigableSet) { 3692 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3693 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3694 entry = (Entry) descendingSet.last(); 3695 assertEquals(109, entry.getValue()); 3696 } 3697 } 3698 3699 public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() { 3700 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3701 Entry entry; 3702 if (entrySet instanceof NavigableSet) { 3703 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3704 .descendingSet(); 3705 assertEquals(8, descendingSubMapEntrySet.size()); 3706 for (int i = 101; i < 109; i++) { 3707 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3708 assertEquals(i, entry.getValue()); 3709 } 3710 assertNull(descendingSubMapEntrySet.pollFirst()); 3711 } 3712 } 3713 3714 public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() { 3715 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3716 Entry entry; 3717 if (entrySet instanceof NavigableSet) { 3718 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3719 .descendingSet(); 3720 assertEquals(9, descendingSubMapEntrySet.size()); 3721 for (int i = 101; i < 110; i++) { 3722 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3723 assertEquals(i, entry.getValue()); 3724 } 3725 assertNull(descendingSubMapEntrySet.pollFirst()); 3726 } 3727 } 3728 3729 public void test_DescendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() { 3730 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3731 Entry entry; 3732 if (entrySet instanceof NavigableSet) { 3733 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3734 .descendingSet(); 3735 assertEquals(9, descendingSubMapEntrySet.size()); 3736 for (int i = 100; i < 109; i++) { 3737 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3738 assertEquals(i, entry.getValue()); 3739 } 3740 assertNull(descendingSubMapEntrySet.pollFirst()); 3741 } 3742 } 3743 3744 public void test_DescendingSubMapEntrySet_pollFirst_startIncluded_endIncluded() { 3745 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3746 Entry entry; 3747 if (entrySet instanceof NavigableSet) { 3748 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3749 .descendingSet(); 3750 assertEquals(10, descendingSubMapEntrySet.size()); 3751 for (int i = 100; i < 110; i++) { 3752 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3753 assertEquals(i, entry.getValue()); 3754 } 3755 assertNull(descendingSubMapEntrySet.pollFirst()); 3756 } 3757 } 3758 3759 public void test_DescendingSubMapEntrySet_pollFirst() { 3760 String key = new Integer(2).toString(); 3761 Set entrySet = tm.headMap(key, true).entrySet();// [0...2] 3762 NavigableSet descendingEntrySet; 3763 Entry entry; 3764 3765 if (entrySet instanceof NavigableSet) { 3766 // [2...0] 3767 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3768 entry = (Entry) descendingEntrySet.pollFirst(); 3769 assertEquals(0, entry.getValue()); 3770 } 3771 3772 entrySet = tm.tailMap(key, true).entrySet(); 3773 if (entrySet instanceof NavigableSet) { 3774 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3775 entry = (Entry) descendingEntrySet.pollFirst(); 3776 assertEquals(2, entry.getValue()); 3777 } 3778 } 3779 3780 public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endExclued() { 3781 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3782 Entry entry; 3783 if (entrySet instanceof NavigableSet) { 3784 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3785 .descendingSet(); 3786 assertEquals(8, descendingSubMapEntrySet.size()); 3787 for (int i = 108; i > 100; i--) { 3788 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3789 assertEquals(i, entry.getValue()); 3790 } 3791 assertNull(descendingSubMapEntrySet.pollFirst()); 3792 } 3793 } 3794 3795 public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endInclued() { 3796 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3797 Entry entry; 3798 if (entrySet instanceof NavigableSet) { 3799 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3800 .descendingSet(); 3801 assertEquals(9, descendingSubMapEntrySet.size()); 3802 for (int i = 109; i > 100; i--) { 3803 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3804 assertEquals(i, entry.getValue()); 3805 } 3806 assertNull(descendingSubMapEntrySet.pollFirst()); 3807 } 3808 } 3809 3810 public void test_DescendingSubMapEntrySet_pollLast_startIncluded_endExclued() { 3811 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3812 Entry entry; 3813 if (entrySet instanceof NavigableSet) { 3814 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3815 .descendingSet(); 3816 assertEquals(9, descendingSubMapEntrySet.size()); 3817 for (int i = 108; i > 99; i--) { 3818 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3819 assertEquals(i, entry.getValue()); 3820 } 3821 assertNull(descendingSubMapEntrySet.pollFirst()); 3822 } 3823 } 3824 3825 public void test_DescendingSubMapEntrySet_pollLast_startIncluded_endInclued() { 3826 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3827 Entry entry; 3828 if (entrySet instanceof NavigableSet) { 3829 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3830 .descendingSet(); 3831 assertEquals(10, descendingSubMapEntrySet.size()); 3832 for (int i = 109; i > 99; i--) { 3833 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3834 assertEquals(i, entry.getValue()); 3835 } 3836 assertNull(descendingSubMapEntrySet.pollFirst()); 3837 } 3838 } 3839 3840 public void test_DescendingSubMapEntrySet_pollLast() { 3841 String key = new Integer(2).toString(); 3842 Set entrySet = tm.headMap(key, true).entrySet();// [0...2] 3843 NavigableSet descendingEntrySet; 3844 Entry entry; 3845 3846 if (entrySet instanceof NavigableSet) { 3847 // [2...0] 3848 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3849 entry = (Entry) descendingEntrySet.pollLast(); 3850 assertEquals(2, entry.getValue()); 3851 } 3852 3853 entrySet = tm.tailMap(key, true).entrySet(); 3854 if (entrySet instanceof NavigableSet) { 3855 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3856 entry = (Entry) descendingEntrySet.pollLast(); 3857 assertEquals(999, entry.getValue()); 3858 } 3859 } 3860 3861 public void test_DescendingSubMapEntrySet_descendingIterator() { 3862 Set entrySet; 3863 NavigableSet descendingSet; 3864 Iterator iterator; 3865 3866 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3867 if (entrySet instanceof NavigableSet) { 3868 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3869 iterator = descendingSet.iterator(); 3870 for (int value = 108; value > 100; value--) { 3871 assertTrue(iterator.hasNext()); 3872 assertEquals(value, ((Entry) iterator.next()).getValue()); 3873 } 3874 assertFalse(iterator.hasNext()); 3875 try { 3876 iterator.next(); 3877 fail("should throw NoSuchElementException"); 3878 } catch (NoSuchElementException e) { 3879 // Expected 3880 } 3881 } 3882 3883 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3884 if (entrySet instanceof NavigableSet) { 3885 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3886 iterator = descendingSet.iterator(); 3887 for (int value = 109; value > 100; value--) { 3888 assertTrue(iterator.hasNext()); 3889 assertEquals(value, ((Entry) iterator.next()).getValue()); 3890 } 3891 assertFalse(iterator.hasNext()); 3892 try { 3893 iterator.next(); 3894 fail("should throw NoSuchElementException"); 3895 } catch (NoSuchElementException e) { 3896 // Expected 3897 } 3898 } 3899 3900 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3901 if (entrySet instanceof NavigableSet) { 3902 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3903 iterator = descendingSet.iterator(); 3904 for (int value = 108; value > 99; value--) { 3905 assertTrue(iterator.hasNext()); 3906 assertEquals(value, ((Entry) iterator.next()).getValue()); 3907 } 3908 assertFalse(iterator.hasNext()); 3909 try { 3910 iterator.next(); 3911 fail("should throw NoSuchElementException"); 3912 } catch (NoSuchElementException e) { 3913 // Expected 3914 } 3915 } 3916 3917 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3918 if (entrySet instanceof NavigableSet) { 3919 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3920 iterator = descendingSet.iterator(); 3921 for (int value = 109; value > 99; value--) { 3922 assertTrue(iterator.hasNext()); 3923 assertEquals(value, ((Entry) iterator.next()).getValue()); 3924 } 3925 assertFalse(iterator.hasNext()); 3926 try { 3927 iterator.next(); 3928 fail("should throw NoSuchElementException"); 3929 } catch (NoSuchElementException e) { 3930 // Expected 3931 } 3932 } 3933 3934 String endKey = new Integer(2).toString(); 3935 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 3936 if (entrySet instanceof NavigableSet) { 3937 // [2...0] 3938 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3939 iterator = descendingSet.descendingIterator(); 3940 assertEquals(0, ((Entry) iterator.next()).getValue());// 0...2 3941 } 3942 } 3943 3944 public void test_DescendingSubMapEntrySet_headSet() { 3945 Set entrySet, headSet; 3946 NavigableSet descendingSubMapEntrySet; 3947 Iterator iterator, headSetIterator; 3948 Entry entry; 3949 int value; 3950 3951 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3952 if (entrySet instanceof NavigableSet) { 3953 descendingSubMapEntrySet = ((NavigableSet) entrySet) 3954 .descendingSet(); 3955 iterator = descendingSubMapEntrySet.iterator(); 3956 while (iterator.hasNext()) { 3957 entry = (Entry) iterator.next(); 3958 headSet = descendingSubMapEntrySet.headSet(entry); 3959 headSetIterator = headSet.iterator(); 3960 for (value = 108; headSetIterator.hasNext(); value--) { 3961 assertEquals(value, ((Entry) headSetIterator.next()) 3962 .getValue()); 3963 } 3964 try { 3965 headSetIterator.next(); 3966 fail("should throw NoSuchElementException"); 3967 } catch (NoSuchElementException e) { 3968 // Expected 3969 } 3970 3971 headSet = descendingSubMapEntrySet.headSet(entry, false); 3972 headSetIterator = headSet.iterator(); 3973 for (value = 108; headSetIterator.hasNext(); value--) { 3974 assertEquals(value, ((Entry) headSetIterator.next()) 3975 .getValue()); 3976 } 3977 try { 3978 headSetIterator.next(); 3979 fail("should throw NoSuchElementException"); 3980 } catch (NoSuchElementException e) { 3981 // Expected 3982 } 3983 3984 headSet = descendingSubMapEntrySet.headSet(entry, true); 3985 headSetIterator = headSet.iterator(); 3986 for (value = 108; headSetIterator.hasNext(); value--) { 3987 assertEquals(value, ((Entry) headSetIterator.next()) 3988 .getValue()); 3989 } 3990 try { 3991 headSetIterator.next(); 3992 fail("should throw NoSuchElementException"); 3993 } catch (NoSuchElementException e) { 3994 // Expected 3995 } 3996 } 3997 } 3998 3999 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4000 if (entrySet instanceof NavigableSet) { 4001 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4002 .descendingSet(); 4003 iterator = descendingSubMapEntrySet.iterator(); 4004 while (iterator.hasNext()) { 4005 entry = (Entry) iterator.next(); 4006 headSet = descendingSubMapEntrySet.headSet(entry); 4007 headSetIterator = headSet.iterator(); 4008 for (value = 109; headSetIterator.hasNext(); value--) { 4009 assertEquals(value, ((Entry) headSetIterator.next()) 4010 .getValue()); 4011 } 4012 try { 4013 headSetIterator.next(); 4014 fail("should throw NoSuchElementException"); 4015 } catch (NoSuchElementException e) { 4016 // Expected 4017 } 4018 4019 headSet = descendingSubMapEntrySet.headSet(entry, false); 4020 headSetIterator = headSet.iterator(); 4021 for (value = 109; headSetIterator.hasNext(); value--) { 4022 assertEquals(value, ((Entry) headSetIterator.next()) 4023 .getValue()); 4024 } 4025 try { 4026 headSetIterator.next(); 4027 fail("should throw NoSuchElementException"); 4028 } catch (NoSuchElementException e) { 4029 // Expected 4030 } 4031 4032 headSet = descendingSubMapEntrySet.headSet(entry, true); 4033 headSetIterator = headSet.iterator(); 4034 for (value = 109; headSetIterator.hasNext(); value--) { 4035 assertEquals(value, ((Entry) headSetIterator.next()) 4036 .getValue()); 4037 } 4038 try { 4039 headSetIterator.next(); 4040 fail("should throw NoSuchElementException"); 4041 } catch (NoSuchElementException e) { 4042 // Expected 4043 } 4044 } 4045 } 4046 4047 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4048 if (entrySet instanceof NavigableSet) { 4049 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4050 .descendingSet(); 4051 iterator = descendingSubMapEntrySet.iterator(); 4052 while (iterator.hasNext()) { 4053 entry = (Entry) iterator.next(); 4054 headSet = descendingSubMapEntrySet.headSet(entry); 4055 headSetIterator = headSet.iterator(); 4056 for (value = 108; headSetIterator.hasNext(); value--) { 4057 assertEquals(value, ((Entry) headSetIterator.next()) 4058 .getValue()); 4059 } 4060 try { 4061 headSetIterator.next(); 4062 fail("should throw NoSuchElementException"); 4063 } catch (NoSuchElementException e) { 4064 // Expected 4065 } 4066 4067 headSet = descendingSubMapEntrySet.headSet(entry, false); 4068 headSetIterator = headSet.iterator(); 4069 for (value = 108; headSetIterator.hasNext(); value--) { 4070 assertEquals(value, ((Entry) headSetIterator.next()) 4071 .getValue()); 4072 } 4073 try { 4074 headSetIterator.next(); 4075 fail("should throw NoSuchElementException"); 4076 } catch (NoSuchElementException e) { 4077 // Expected 4078 } 4079 4080 headSet = descendingSubMapEntrySet.headSet(entry, true); 4081 headSetIterator = headSet.iterator(); 4082 for (value = 108; headSetIterator.hasNext(); value--) { 4083 assertEquals(value, ((Entry) headSetIterator.next()) 4084 .getValue()); 4085 } 4086 try { 4087 headSetIterator.next(); 4088 fail("should throw NoSuchElementException"); 4089 } catch (NoSuchElementException e) { 4090 // Expected 4091 } 4092 } 4093 } 4094 4095 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4096 if (entrySet instanceof NavigableSet) { 4097 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4098 .descendingSet(); 4099 iterator = descendingSubMapEntrySet.iterator(); 4100 while (iterator.hasNext()) { 4101 entry = (Entry) iterator.next(); 4102 headSet = descendingSubMapEntrySet.headSet(entry); 4103 headSetIterator = headSet.iterator(); 4104 for (value = 109; headSetIterator.hasNext(); value--) { 4105 assertEquals(value, ((Entry) headSetIterator.next()) 4106 .getValue()); 4107 } 4108 try { 4109 headSetIterator.next(); 4110 fail("should throw NoSuchElementException"); 4111 } catch (NoSuchElementException e) { 4112 // Expected 4113 } 4114 4115 headSet = descendingSubMapEntrySet.headSet(entry, false); 4116 headSetIterator = headSet.iterator(); 4117 for (value = 109; headSetIterator.hasNext(); value--) { 4118 assertEquals(value, ((Entry) headSetIterator.next()) 4119 .getValue()); 4120 } 4121 try { 4122 headSetIterator.next(); 4123 fail("should throw NoSuchElementException"); 4124 } catch (NoSuchElementException e) { 4125 // Expected 4126 } 4127 4128 headSet = descendingSubMapEntrySet.headSet(entry, true); 4129 headSetIterator = headSet.iterator(); 4130 for (value = 109; headSetIterator.hasNext(); value--) { 4131 assertEquals(value, ((Entry) headSetIterator.next()) 4132 .getValue()); 4133 } 4134 try { 4135 headSetIterator.next(); 4136 fail("should throw NoSuchElementException"); 4137 } catch (NoSuchElementException e) { 4138 // Expected 4139 } 4140 } 4141 } 4142 4143 String endKey = new Integer(2).toString(); 4144 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 4145 if (entrySet instanceof NavigableSet) { 4146 // [2...0] 4147 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4148 .descendingSet(); 4149 iterator = descendingSubMapEntrySet.iterator(); 4150 iterator.next();// 2 4151 iterator.next();// 199 4152 entry = (Entry) iterator.next();// 198 4153 headSet = descendingSubMapEntrySet.headSet(entry); 4154 assertEquals(2, headSet.size());// 2 199 4155 headSetIterator = headSet.iterator(); 4156 assertEquals(2, ((Entry) headSetIterator.next()).getValue()); 4157 assertEquals(199, ((Entry) headSetIterator.next()).getValue()); 4158 4159 headSet = descendingSubMapEntrySet.headSet(entry, true); 4160 assertEquals(3, headSet.size());// 2 199 4161 headSetIterator = headSet.iterator(); 4162 assertEquals(2, ((Entry) headSetIterator.next()).getValue()); 4163 assertEquals(199, ((Entry) headSetIterator.next()).getValue()); 4164 assertEquals(198, ((Entry) headSetIterator.next()).getValue()); 4165 } 4166 } 4167 4168 public void test_DescendingSubMapEntrySet_tailSet() { 4169 Set entrySet, tailSet; 4170 NavigableSet descendingSubMapEntrySet; 4171 Iterator iterator, tailSetIterator; 4172 Entry entry; 4173 int value; 4174 4175 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4176 if (entrySet instanceof NavigableSet) { 4177 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4178 .descendingSet(); 4179 iterator = descendingSubMapEntrySet.iterator(); 4180 while (iterator.hasNext()) { 4181 entry = (Entry) iterator.next(); 4182 tailSet = descendingSubMapEntrySet.tailSet(entry); 4183 tailSetIterator = tailSet.iterator(); 4184 for (value = (Integer) entry.getValue(); tailSetIterator 4185 .hasNext(); value--) { 4186 assertEquals(value, ((Entry) tailSetIterator.next()) 4187 .getValue()); 4188 } 4189 try { 4190 tailSetIterator.next(); 4191 fail("should throw NoSuchElementException"); 4192 } catch (NoSuchElementException e) { 4193 // Expected 4194 } 4195 4196 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4197 tailSetIterator = tailSet.iterator(); 4198 for (value = (Integer) entry.getValue(); tailSetIterator 4199 .hasNext(); value--) { 4200 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4201 .getValue()); 4202 } 4203 try { 4204 tailSetIterator.next(); 4205 fail("should throw NoSuchElementException"); 4206 } catch (NoSuchElementException e) { 4207 // Expected 4208 } 4209 4210 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4211 tailSetIterator = tailSet.iterator(); 4212 for (value = (Integer) entry.getValue(); tailSetIterator 4213 .hasNext(); value--) { 4214 assertEquals(value, ((Entry) tailSetIterator.next()) 4215 .getValue()); 4216 } 4217 try { 4218 tailSetIterator.next(); 4219 fail("should throw NoSuchElementException"); 4220 } catch (NoSuchElementException e) { 4221 // Expected 4222 } 4223 } 4224 } 4225 4226 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4227 if (entrySet instanceof NavigableSet) { 4228 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4229 .descendingSet(); 4230 iterator = descendingSubMapEntrySet.iterator(); 4231 while (iterator.hasNext()) { 4232 entry = (Entry) iterator.next(); 4233 tailSet = descendingSubMapEntrySet.tailSet(entry); 4234 tailSetIterator = tailSet.iterator(); 4235 for (value = (Integer) entry.getValue(); tailSetIterator 4236 .hasNext(); value--) { 4237 assertEquals(value, ((Entry) tailSetIterator.next()) 4238 .getValue()); 4239 } 4240 try { 4241 tailSetIterator.next(); 4242 fail("should throw NoSuchElementException"); 4243 } catch (NoSuchElementException e) { 4244 // Expected 4245 } 4246 4247 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4248 tailSetIterator = tailSet.iterator(); 4249 for (value = (Integer) entry.getValue(); tailSetIterator 4250 .hasNext(); value--) { 4251 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4252 .getValue()); 4253 } 4254 try { 4255 tailSetIterator.next(); 4256 fail("should throw NoSuchElementException"); 4257 } catch (NoSuchElementException e) { 4258 // Expected 4259 } 4260 4261 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4262 tailSetIterator = tailSet.iterator(); 4263 for (value = (Integer) entry.getValue(); tailSetIterator 4264 .hasNext(); value--) { 4265 assertEquals(value, ((Entry) tailSetIterator.next()) 4266 .getValue()); 4267 } 4268 try { 4269 tailSetIterator.next(); 4270 fail("should throw NoSuchElementException"); 4271 } catch (NoSuchElementException e) { 4272 // Expected 4273 } 4274 } 4275 } 4276 4277 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4278 if (entrySet instanceof NavigableSet) { 4279 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4280 .descendingSet(); 4281 iterator = descendingSubMapEntrySet.iterator(); 4282 while (iterator.hasNext()) { 4283 entry = (Entry) iterator.next(); 4284 tailSet = descendingSubMapEntrySet.tailSet(entry); 4285 tailSetIterator = tailSet.iterator(); 4286 for (value = (Integer) entry.getValue(); tailSetIterator 4287 .hasNext(); value--) { 4288 assertEquals(value, ((Entry) tailSetIterator.next()) 4289 .getValue()); 4290 } 4291 try { 4292 tailSetIterator.next(); 4293 fail("should throw NoSuchElementException"); 4294 } catch (NoSuchElementException e) { 4295 // Expected 4296 } 4297 4298 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4299 tailSetIterator = tailSet.iterator(); 4300 for (value = (Integer) entry.getValue(); tailSetIterator 4301 .hasNext(); value--) { 4302 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4303 .getValue()); 4304 } 4305 try { 4306 tailSetIterator.next(); 4307 fail("should throw NoSuchElementException"); 4308 } catch (NoSuchElementException e) { 4309 // Expected 4310 } 4311 4312 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4313 tailSetIterator = tailSet.iterator(); 4314 for (value = (Integer) entry.getValue(); tailSetIterator 4315 .hasNext(); value--) { 4316 assertEquals(value, ((Entry) tailSetIterator.next()) 4317 .getValue()); 4318 } 4319 try { 4320 tailSetIterator.next(); 4321 fail("should throw NoSuchElementException"); 4322 } catch (NoSuchElementException e) { 4323 // Expected 4324 } 4325 } 4326 } 4327 4328 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4329 if (entrySet instanceof NavigableSet) { 4330 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4331 .descendingSet(); 4332 iterator = descendingSubMapEntrySet.iterator(); 4333 while (iterator.hasNext()) { 4334 entry = (Entry) iterator.next(); 4335 tailSet = descendingSubMapEntrySet.tailSet(entry); 4336 tailSetIterator = tailSet.iterator(); 4337 for (value = (Integer) entry.getValue(); tailSetIterator 4338 .hasNext(); value--) { 4339 assertEquals(value, ((Entry) tailSetIterator.next()) 4340 .getValue()); 4341 } 4342 try { 4343 tailSetIterator.next(); 4344 fail("should throw NoSuchElementException"); 4345 } catch (NoSuchElementException e) { 4346 // Expected 4347 } 4348 4349 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4350 tailSetIterator = tailSet.iterator(); 4351 for (value = (Integer) entry.getValue(); tailSetIterator 4352 .hasNext(); value--) { 4353 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4354 .getValue()); 4355 } 4356 try { 4357 tailSetIterator.next(); 4358 fail("should throw NoSuchElementException"); 4359 } catch (NoSuchElementException e) { 4360 // Expected 4361 } 4362 4363 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4364 tailSetIterator = tailSet.iterator(); 4365 for (value = (Integer) entry.getValue(); tailSetIterator 4366 .hasNext(); value--) { 4367 assertEquals(value, ((Entry) tailSetIterator.next()) 4368 .getValue()); 4369 } 4370 try { 4371 tailSetIterator.next(); 4372 fail("should throw NoSuchElementException"); 4373 } catch (NoSuchElementException e) { 4374 // Expected 4375 } 4376 } 4377 } 4378 4379 String endKey = new Integer(2).toString(); 4380 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 4381 if (entrySet instanceof NavigableSet) { 4382 // [2...0] 4383 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4384 .descendingSet(); 4385 iterator = descendingSubMapEntrySet.iterator(); 4386 iterator.next();// 2 4387 entry = (Entry) iterator.next();// 199 4388 tailSet = descendingSubMapEntrySet.tailSet(entry); 4389 tailSetIterator = tailSet.iterator(); 4390 assertEquals(199, ((Entry) tailSetIterator.next()).getValue()); 4391 4392 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4393 tailSetIterator = tailSet.iterator(); 4394 assertEquals(198, ((Entry) tailSetIterator.next()).getValue()); 4395 4396 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4397 tailSetIterator = tailSet.iterator(); 4398 assertEquals(199, ((Entry) tailSetIterator.next()).getValue()); 4399 } 4400 } 4401 4402 public void test_DescendingSubMapEntrySet_subSet() { 4403 Set entrySet, subSet; 4404 NavigableSet descendingSubMapEntrySet; 4405 Entry startEntry, endEntry; 4406 Iterator subSetIterator; 4407 4408 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4409 if (entrySet instanceof NavigableSet) { 4410 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4411 .descendingSet(); 4412 Iterator iteratorStart = descendingSubMapEntrySet.iterator(); 4413 while (iteratorStart.hasNext()) { 4414 startEntry = (Entry) iteratorStart.next(); 4415 Iterator iteratorEnd = descendingSubMapEntrySet.iterator(); 4416 while (iteratorEnd.hasNext()) { 4417 endEntry = (Entry) iteratorEnd.next(); 4418 int startIndex = (Integer) startEntry.getValue(); 4419 int endIndex = (Integer) endEntry.getValue(); 4420 if (startIndex < endIndex) { 4421 try { 4422 descendingSubMapEntrySet.subSet(startEntry, 4423 endEntry); 4424 fail("should throw IllegalArgumentException"); 4425 } catch (IllegalArgumentException e) { 4426 // Expected 4427 } 4428 4429 try { 4430 descendingSubMapEntrySet.subSet(startEntry, false, 4431 endEntry, false); 4432 fail("should throw IllegalArgumentException"); 4433 } catch (IllegalArgumentException e) { 4434 // Expected 4435 } 4436 4437 try { 4438 descendingSubMapEntrySet.subSet(startEntry, false, 4439 endEntry, true); 4440 fail("should throw IllegalArgumentException"); 4441 } catch (IllegalArgumentException e) { 4442 // Expected 4443 } 4444 4445 try { 4446 descendingSubMapEntrySet.subSet(startEntry, true, 4447 endEntry, false); 4448 fail("should throw IllegalArgumentException"); 4449 } catch (IllegalArgumentException e) { 4450 // Expected 4451 } 4452 4453 try { 4454 descendingSubMapEntrySet.subSet(startEntry, true, 4455 endEntry, true); 4456 fail("should throw IllegalArgumentException"); 4457 } catch (IllegalArgumentException e) { 4458 // Expected 4459 } 4460 } else { 4461 subSet = descendingSubMapEntrySet.subSet(startEntry, 4462 endEntry); 4463 subSetIterator = subSet.iterator(); 4464 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4465 assertEquals(index, ((Entry) subSetIterator.next()) 4466 .getValue()); 4467 } 4468 4469 subSet = descendingSubMapEntrySet.subSet(startEntry, 4470 false, endEntry, false); 4471 subSetIterator = subSet.iterator(); 4472 for (int index = startIndex - 1; subSetIterator 4473 .hasNext(); index--) { 4474 assertEquals(index, ((Entry) subSetIterator.next()) 4475 .getValue()); 4476 } 4477 4478 subSet = descendingSubMapEntrySet.subSet(startEntry, 4479 false, endEntry, true); 4480 subSetIterator = subSet.iterator(); 4481 for (int index = startIndex - 1; subSetIterator 4482 .hasNext(); index--) { 4483 assertEquals(index, ((Entry) subSetIterator.next()) 4484 .getValue()); 4485 } 4486 4487 subSet = descendingSubMapEntrySet.subSet(startEntry, 4488 true, endEntry, false); 4489 subSetIterator = subSet.iterator(); 4490 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4491 assertEquals(index, ((Entry) subSetIterator.next()) 4492 .getValue()); 4493 } 4494 4495 subSet = descendingSubMapEntrySet.subSet(startEntry, 4496 true, endEntry, true); 4497 subSetIterator = subSet.iterator(); 4498 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4499 assertEquals(index, ((Entry) subSetIterator.next()) 4500 .getValue()); 4501 } 4502 } 4503 } 4504 } 4505 } 4506 4507 String endKey = new Integer(2).toString(); 4508 entrySet = tm.headMap(endKey, true).entrySet(); 4509 if (entrySet instanceof NavigableSet) { 4510 // [2...0] 4511 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4512 .descendingSet(); 4513 Iterator iterator = descendingSubMapEntrySet.iterator(); 4514 startEntry = (Entry) iterator.next(); 4515 iterator.next(); 4516 endEntry = (Entry) iterator.next(); 4517 subSet = descendingSubMapEntrySet.subSet(startEntry, endEntry); 4518 assertEquals(2, subSet.size()); 4519 4520 subSet = descendingSubMapEntrySet.subSet(startEntry, false, 4521 endEntry, false); 4522 assertEquals(1, subSet.size()); 4523 subSetIterator = subSet.iterator(); 4524 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4525 4526 subSet = descendingSubMapEntrySet.subSet(startEntry, false, 4527 endEntry, true); 4528 assertEquals(2, subSet.size()); 4529 subSetIterator = subSet.iterator(); 4530 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4531 assertEquals(198, ((Entry) subSetIterator.next()).getValue()); 4532 4533 subSet = descendingSubMapEntrySet.subSet(startEntry, true, 4534 endEntry, false); 4535 assertEquals(2, subSet.size()); 4536 subSetIterator = subSet.iterator(); 4537 assertEquals(2, ((Entry) subSetIterator.next()).getValue()); 4538 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4539 4540 subSet = descendingSubMapEntrySet.subSet(startEntry, true, 4541 endEntry, true); 4542 assertEquals(3, subSet.size()); 4543 subSetIterator = subSet.iterator(); 4544 assertEquals(2, ((Entry) subSetIterator.next()).getValue()); 4545 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4546 assertEquals(198, ((Entry) subSetIterator.next()).getValue()); 4547 } 4548 4549 // With Comnparator 4550 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 4551 if (entrySet instanceof NavigableSet) { 4552 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4553 .descendingSet(); 4554 Iterator iteratorStart = descendingSubMapEntrySet.iterator(); 4555 while (iteratorStart.hasNext()) { 4556 startEntry = (Entry) iteratorStart.next(); 4557 Iterator iteratorEnd = descendingSubMapEntrySet.iterator(); 4558 while (iteratorEnd.hasNext()) { 4559 endEntry = (Entry) iteratorEnd.next(); 4560 int startIndex = (Integer) startEntry.getValue(); 4561 int endIndex = (Integer) endEntry.getValue(); 4562 if (startIndex < endIndex) { 4563 try { 4564 descendingSubMapEntrySet.subSet(startEntry, 4565 endEntry); 4566 fail("should throw IllegalArgumentException"); 4567 } catch (IllegalArgumentException e) { 4568 // Expected 4569 } 4570 4571 try { 4572 descendingSubMapEntrySet.subSet(startEntry, false, 4573 endEntry, false); 4574 fail("should throw IllegalArgumentException"); 4575 } catch (IllegalArgumentException e) { 4576 // Expected 4577 } 4578 4579 try { 4580 descendingSubMapEntrySet.subSet(startEntry, false, 4581 endEntry, true); 4582 fail("should throw IllegalArgumentException"); 4583 } catch (IllegalArgumentException e) { 4584 // Expected 4585 } 4586 4587 try { 4588 descendingSubMapEntrySet.subSet(startEntry, true, 4589 endEntry, false); 4590 fail("should throw IllegalArgumentException"); 4591 } catch (IllegalArgumentException e) { 4592 // Expected 4593 } 4594 4595 try { 4596 descendingSubMapEntrySet.subSet(startEntry, true, 4597 endEntry, true); 4598 fail("should throw IllegalArgumentException"); 4599 } catch (IllegalArgumentException e) { 4600 // Expected 4601 } 4602 } else { 4603 subSet = descendingSubMapEntrySet.subSet(startEntry, 4604 endEntry); 4605 subSetIterator = subSet.iterator(); 4606 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4607 assertEquals(index, ((Entry) subSetIterator.next()) 4608 .getValue()); 4609 } 4610 4611 subSet = descendingSubMapEntrySet.subSet(startEntry, 4612 false, endEntry, false); 4613 subSetIterator = subSet.iterator(); 4614 for (int index = startIndex - 1; subSetIterator 4615 .hasNext(); index--) { 4616 assertEquals(index, ((Entry) subSetIterator.next()) 4617 .getValue()); 4618 } 4619 4620 subSet = descendingSubMapEntrySet.subSet(startEntry, 4621 false, endEntry, true); 4622 subSetIterator = subSet.iterator(); 4623 for (int index = startIndex - 1; subSetIterator 4624 .hasNext(); index--) { 4625 assertEquals(index, ((Entry) subSetIterator.next()) 4626 .getValue()); 4627 } 4628 4629 subSet = descendingSubMapEntrySet.subSet(startEntry, 4630 true, endEntry, false); 4631 subSetIterator = subSet.iterator(); 4632 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4633 assertEquals(index, ((Entry) subSetIterator.next()) 4634 .getValue()); 4635 } 4636 4637 subSet = descendingSubMapEntrySet.subSet(startEntry, 4638 true, endEntry, true); 4639 subSetIterator = subSet.iterator(); 4640 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4641 assertEquals(index, ((Entry) subSetIterator.next()) 4642 .getValue()); 4643 } 4644 } 4645 } 4646 } 4647 } 4648 } 4649 4650 public void test_DescendingSubMapEntrySet_lower() { 4651 Set entrySet, subSet; 4652 NavigableSet descendingSubMapEntrySet; 4653 Iterator iterator; 4654 Entry entry, lowerEntry; 4655 int value; 4656 4657 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4658 if (entrySet instanceof NavigableSet) { 4659 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4660 .descendingSet(); 4661 iterator = descendingSubMapEntrySet.iterator(); 4662 while (iterator.hasNext()) { 4663 entry = (Entry) iterator.next(); 4664 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4665 value = (Integer) entry.getValue(); 4666 if (value < 108) { 4667 assertEquals(value + 1, lowerEntry.getValue()); 4668 } else { 4669 assertNull(lowerEntry); 4670 } 4671 } 4672 4673 // System.out.println(descendingSubMapEntrySet); 4674 // System.out.println(tm); 4675 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4676 .iterator().next(); 4677 // System.out.println("o:" + afterEnd); 4678 Object x = descendingSubMapEntrySet.lower(afterEnd); 4679 // System.out.println("x:" + x); 4680 assertNull(x); 4681 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4682 .iterator().next(); 4683 // System.out.println("before: " + beforeStart); 4684 Object y = descendingSubMapEntrySet.lower(beforeStart); 4685 // System.out.println("y: " + y); 4686 assertNotNull(y); 4687 assertEquals(101, (((Entry) y).getValue())); 4688 } 4689 4690 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4691 if (entrySet instanceof NavigableSet) { 4692 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4693 .descendingSet(); 4694 iterator = descendingSubMapEntrySet.iterator(); 4695 while (iterator.hasNext()) { 4696 entry = (Entry) iterator.next(); 4697 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4698 value = (Integer) entry.getValue(); 4699 if (value < 109) { 4700 assertEquals(value + 1, lowerEntry.getValue()); 4701 } else { 4702 assertNull(lowerEntry); 4703 } 4704 } 4705 } 4706 4707 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4708 if (entrySet instanceof NavigableSet) { 4709 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4710 .descendingSet(); 4711 iterator = descendingSubMapEntrySet.iterator(); 4712 while (iterator.hasNext()) { 4713 entry = (Entry) iterator.next(); 4714 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4715 value = (Integer) entry.getValue(); 4716 if (value < 108) { 4717 assertEquals(value + 1, lowerEntry.getValue()); 4718 } else { 4719 assertNull(lowerEntry); 4720 } 4721 } 4722 } 4723 4724 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4725 if (entrySet instanceof NavigableSet) { 4726 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4727 .descendingSet(); 4728 iterator = descendingSubMapEntrySet.iterator(); 4729 while (iterator.hasNext()) { 4730 entry = (Entry) iterator.next(); 4731 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4732 value = (Integer) entry.getValue(); 4733 if (value < 109) { 4734 assertEquals(value + 1, lowerEntry.getValue()); 4735 } else { 4736 assertNull(lowerEntry); 4737 } 4738 } 4739 } 4740 4741 String endKey = new Integer(2).toString(); 4742 entrySet = tm.headMap(endKey, true).entrySet(); 4743 if (entrySet instanceof NavigableSet) { 4744 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4745 .descendingSet(); 4746 iterator = descendingSubMapEntrySet.iterator(); 4747 iterator.next();// 2 4748 iterator.next();// 199 4749 entry = (Entry) iterator.next();// 198 4750 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4751 assertEquals(199, lowerEntry.getValue()); 4752 } 4753 } 4754 4755 public void test_DescendingSubMapEntrySet_higher() { 4756 Set entrySet, subSet; 4757 NavigableSet descendingSubMapEntrySet; 4758 Iterator iterator; 4759 Entry entry, higherEntry; 4760 int value; 4761 4762 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4763 if (entrySet instanceof NavigableSet) { 4764 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4765 .descendingSet(); 4766 iterator = descendingSubMapEntrySet.iterator(); 4767 while (iterator.hasNext()) { 4768 entry = (Entry) iterator.next(); 4769 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4770 value = (Integer) entry.getValue(); 4771 if (value > 101) { 4772 assertEquals(value - 1, higherEntry.getValue()); 4773 } else { 4774 assertNull(higherEntry); 4775 } 4776 } 4777 4778 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4779 .iterator().next(); 4780 Object x = descendingSubMapEntrySet.higher(afterEnd); 4781 assertNotNull(x); 4782 assertEquals(108, ((Entry) x).getValue()); 4783 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4784 .iterator().next(); 4785 Object y = descendingSubMapEntrySet.higher(beforeStart); 4786 assertNull(y); 4787 } 4788 4789 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4790 if (entrySet instanceof NavigableSet) { 4791 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4792 .descendingSet(); 4793 iterator = descendingSubMapEntrySet.iterator(); 4794 while (iterator.hasNext()) { 4795 entry = (Entry) iterator.next(); 4796 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4797 value = (Integer) entry.getValue(); 4798 if (value > 101) { 4799 assertEquals(value - 1, higherEntry.getValue()); 4800 } else { 4801 assertNull(higherEntry); 4802 } 4803 } 4804 } 4805 4806 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4807 if (entrySet instanceof NavigableSet) { 4808 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4809 .descendingSet(); 4810 iterator = descendingSubMapEntrySet.iterator(); 4811 while (iterator.hasNext()) { 4812 entry = (Entry) iterator.next(); 4813 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4814 value = (Integer) entry.getValue(); 4815 if (value > 100) { 4816 assertEquals(value - 1, higherEntry.getValue()); 4817 } else { 4818 assertNull(higherEntry); 4819 } 4820 } 4821 } 4822 4823 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4824 if (entrySet instanceof NavigableSet) { 4825 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4826 .descendingSet(); 4827 iterator = descendingSubMapEntrySet.iterator(); 4828 while (iterator.hasNext()) { 4829 entry = (Entry) iterator.next(); 4830 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4831 value = (Integer) entry.getValue(); 4832 if (value > 100) { 4833 assertEquals(value - 1, higherEntry.getValue()); 4834 } else { 4835 assertNull(higherEntry); 4836 } 4837 } 4838 } 4839 4840 String endKey = new Integer(2).toString(); 4841 entrySet = tm.headMap(endKey, true).entrySet(); 4842 if (entrySet instanceof NavigableSet) { 4843 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4844 .descendingSet(); 4845 iterator = descendingSubMapEntrySet.iterator(); 4846 iterator.next();// 2 4847 iterator.next();// 199 4848 entry = (Entry) iterator.next();// 198 4849 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4850 assertEquals(197, higherEntry.getValue()); 4851 } 4852 4853 // With Comparator 4854 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 4855 if (entrySet instanceof NavigableSet) { 4856 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4857 .descendingSet(); 4858 iterator = descendingSubMapEntrySet.iterator(); 4859 while (iterator.hasNext()) { 4860 entry = (Entry) iterator.next(); 4861 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4862 value = (Integer) entry.getValue(); 4863 if (value > 101) { 4864 assertEquals(value - 1, higherEntry.getValue()); 4865 } else { 4866 assertNull(higherEntry); 4867 } 4868 } 4869 4870 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4871 .iterator().next(); 4872 Object x = descendingSubMapEntrySet.higher(afterEnd); 4873 assertNotNull(x); 4874 assertEquals(108, ((Entry) x).getValue()); 4875 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4876 .iterator().next(); 4877 Object y = descendingSubMapEntrySet.higher(beforeStart); 4878 assertNull(y); 4879 } 4880 } 4881 4882 public void test_DescendingSubMapEntrySet_ceiling() { 4883 Set entrySet; 4884 NavigableSet ascendingSubMapEntrySet, descendingSet; 4885 Entry entry; 4886 Entry[] entryArray; 4887 4888 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4889 if (entrySet instanceof NavigableSet) { 4890 ascendingSubMapEntrySet = (NavigableSet) entrySet; 4891 descendingSet = ascendingSubMapEntrySet.descendingSet(); 4892 try { 4893 descendingSet.ceiling(null); 4894 fail("should throw NPE"); 4895 } catch (NullPointerException e) { 4896 // Expected 4897 } 4898 4899 entryArray = (Entry[]) descendingSet 4900 .toArray(new Entry[descendingSet.size()]); 4901 for (int i = 0, j = 108; i < entryArray.length; i++) { 4902 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4903 assertEquals(j - i, entry.getValue()); 4904 } 4905 4906 // System.out.println(descendingSet); 4907 // System.out.println(tm); 4908 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4909 .iterator().next(); 4910 // System.out.println("o:" + afterEnd);//110 4911 Object x = descendingSet.ceiling(afterEnd); 4912 assertNotNull(x); 4913 // System.out.println("x:" + x); 4914 assertEquals(108, ((Entry) x).getValue()); 4915 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4916 .iterator().next(); 4917 // System.out.println("before: " + beforeStart);//0 4918 Object y = descendingSet.ceiling(beforeStart); 4919 assertNull(y); 4920 } 4921 4922 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4923 if (entrySet instanceof NavigableSet) { 4924 ascendingSubMapEntrySet = (NavigableSet) entrySet; 4925 descendingSet = ascendingSubMapEntrySet.descendingSet(); 4926 try { 4927 descendingSet.ceiling(null); 4928 fail("should throw NPE"); 4929 } catch (NullPointerException e) { 4930 // Expected 4931 } 4932 4933 entryArray = (Entry[]) descendingSet 4934 .toArray(new Entry[descendingSet.size()]); 4935 for (int i = 0, j = 109; i < entryArray.length; i++) { 4936 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4937 assertEquals(j - i, entry.getValue()); 4938 } 4939 } 4940 4941 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4942 if (entrySet instanceof NavigableSet) { 4943 ascendingSubMapEntrySet = (NavigableSet) entrySet; 4944 descendingSet = ascendingSubMapEntrySet.descendingSet(); 4945 try { 4946 descendingSet.ceiling(null); 4947 fail("should throw NPE"); 4948 } catch (NullPointerException e) { 4949 // Expected 4950 } 4951 4952 entryArray = (Entry[]) descendingSet 4953 .toArray(new Entry[descendingSet.size()]); 4954 for (int i = 0, j = 108; i < entryArray.length; i++) { 4955 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4956 assertEquals(j - i, entry.getValue()); 4957 } 4958 } 4959 4960 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4961 if (entrySet instanceof NavigableSet) { 4962 descendingSet = ((NavigableSet) entrySet).descendingSet(); 4963 try { 4964 descendingSet.ceiling(null); 4965 fail("should throw NPE"); 4966 } catch (NullPointerException e) { 4967 // Expected 4968 } 4969 4970 entryArray = (Entry[]) descendingSet 4971 .toArray(new Entry[descendingSet.size()]); 4972 for (int i = 0, j = 109; i < entryArray.length; i++) { 4973 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4974 assertEquals(j - i, entry.getValue()); 4975 } 4976 } 4977 4978 String endKey = new Integer(2).toString(); 4979 entrySet = tm.headMap(endKey, true).entrySet(); 4980 if (entrySet instanceof NavigableSet) { 4981 descendingSet = ((NavigableSet) entrySet).descendingSet(); 4982 try { 4983 descendingSet.ceiling(null); 4984 fail("should throw NPE"); 4985 } catch (NullPointerException e) { 4986 // Expected 4987 } 4988 4989 Iterator iterator = descendingSet.iterator(); 4990 Entry ceilingEntry; 4991 while (iterator.hasNext()) { 4992 entry = (Entry) iterator.next(); 4993 ceilingEntry = (Entry) descendingSet.ceiling(entry); 4994 assertEquals(entry, ceilingEntry); 4995 } 4996 } 4997 4998 } 4999 5000 public void test_DescendingSubMapEntrySet_floor() { 5001 Set entrySet; 5002 NavigableSet ascendingSubMapEntrySet, descendingSet; 5003 Entry entry; 5004 Entry[] entryArray; 5005 5006 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 5007 if (entrySet instanceof NavigableSet) { 5008 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5009 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5010 try { 5011 descendingSet.floor(null); 5012 fail("should throw NPE"); 5013 } catch (NullPointerException e) { 5014 // Expected 5015 } 5016 5017 entryArray = (Entry[]) descendingSet 5018 .toArray(new Entry[descendingSet.size()]); 5019 for (int i = 0, j = 108; i < entryArray.length; i++) { 5020 entry = (Entry) descendingSet.floor(entryArray[i]); 5021 assertEquals(j - i, entry.getValue()); 5022 } 5023 5024 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 5025 .iterator().next(); 5026 Object x = descendingSet.floor(afterEnd); 5027 assertNull(x); 5028 5029 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 5030 .iterator().next(); 5031 Object y = descendingSet.floor(beforeStart); 5032 assertNotNull(y); 5033 assertEquals(101, (((Entry) y).getValue())); 5034 } 5035 5036 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 5037 if (entrySet instanceof NavigableSet) { 5038 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5039 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5040 try { 5041 descendingSet.floor(null); 5042 fail("should throw NPE"); 5043 } catch (NullPointerException e) { 5044 // Expected 5045 } 5046 5047 entryArray = (Entry[]) descendingSet 5048 .toArray(new Entry[descendingSet.size()]); 5049 for (int i = 0, j = 109; i < entryArray.length; i++) { 5050 entry = (Entry) descendingSet.floor(entryArray[i]); 5051 assertEquals(j - i, entry.getValue()); 5052 } 5053 } 5054 5055 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 5056 if (entrySet instanceof NavigableSet) { 5057 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5058 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5059 try { 5060 descendingSet.floor(null); 5061 fail("should throw NPE"); 5062 } catch (NullPointerException e) { 5063 // Expected 5064 } 5065 5066 entryArray = (Entry[]) descendingSet 5067 .toArray(new Entry[descendingSet.size()]); 5068 for (int i = 0, j = 108; i < entryArray.length; i++) { 5069 entry = (Entry) descendingSet.floor(entryArray[i]); 5070 assertEquals(j - i, entry.getValue()); 5071 } 5072 } 5073 5074 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 5075 if (entrySet instanceof NavigableSet) { 5076 descendingSet = ((NavigableSet) entrySet).descendingSet(); 5077 try { 5078 descendingSet.floor(null); 5079 fail("should throw NPE"); 5080 } catch (NullPointerException e) { 5081 // Expected 5082 } 5083 5084 entryArray = (Entry[]) descendingSet 5085 .toArray(new Entry[descendingSet.size()]); 5086 for (int i = 0, j = 109; i < entryArray.length; i++) { 5087 entry = (Entry) descendingSet.floor(entryArray[i]); 5088 assertEquals(j - i, entry.getValue()); 5089 } 5090 } 5091 5092 String endKey = new Integer(2).toString(); 5093 entrySet = tm.headMap(endKey, true).entrySet(); 5094 if (entrySet instanceof NavigableSet) { 5095 descendingSet = ((NavigableSet) entrySet).descendingSet(); 5096 5097 Iterator iterator = descendingSet.iterator(); 5098 Entry floorEntry; 5099 while (iterator.hasNext()) { 5100 entry = (Entry) iterator.next(); 5101 floorEntry = (Entry) descendingSet.floor(entry); 5102 assertEquals(entry, floorEntry); 5103 } 5104 } 5105 5106 // With Comparator 5107 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 5108 if (entrySet instanceof NavigableSet) { 5109 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5110 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5111 try { 5112 descendingSet.floor(null); 5113 fail("should throw NPE"); 5114 } catch (NullPointerException e) { 5115 // Expected 5116 } 5117 5118 entryArray = (Entry[]) descendingSet 5119 .toArray(new Entry[descendingSet.size()]); 5120 for (int i = 0, j = 108; i < entryArray.length; i++) { 5121 entry = (Entry) descendingSet.floor(entryArray[i]); 5122 assertEquals(j - i, entry.getValue()); 5123 } 5124 } 5125 5126 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 5127 if (entrySet instanceof NavigableSet) { 5128 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5129 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5130 try { 5131 descendingSet.floor(null); 5132 fail("should throw NPE"); 5133 } catch (NullPointerException e) { 5134 // Expected 5135 } 5136 5137 entryArray = (Entry[]) descendingSet 5138 .toArray(new Entry[descendingSet.size()]); 5139 for (int i = 0, j = 109; i < entryArray.length; i++) { 5140 entry = (Entry) descendingSet.floor(entryArray[i]); 5141 assertEquals(j - i, entry.getValue()); 5142 } 5143 } 5144 5145 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 5146 if (entrySet instanceof NavigableSet) { 5147 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5148 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5149 try { 5150 descendingSet.floor(null); 5151 fail("should throw NPE"); 5152 } catch (NullPointerException e) { 5153 // Expected 5154 } 5155 5156 entryArray = (Entry[]) descendingSet 5157 .toArray(new Entry[descendingSet.size()]); 5158 for (int i = 0, j = 108; i < entryArray.length; i++) { 5159 entry = (Entry) descendingSet.floor(entryArray[i]); 5160 assertEquals(j - i, entry.getValue()); 5161 } 5162 } 5163 5164 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 5165 if (entrySet instanceof NavigableSet) { 5166 descendingSet = ((NavigableSet) entrySet).descendingSet(); 5167 try { 5168 descendingSet.floor(null); 5169 fail("should throw NPE"); 5170 } catch (NullPointerException e) { 5171 // Expected 5172 } 5173 5174 entryArray = (Entry[]) descendingSet 5175 .toArray(new Entry[descendingSet.size()]); 5176 for (int i = 0, j = 109; i < entryArray.length; i++) { 5177 entry = (Entry) descendingSet.floor(entryArray[i]); 5178 assertEquals(j - i, entry.getValue()); 5179 } 5180 } 5181 } 5182 5183 public void test_DescendingSubMapKeySet_comparator() { 5184 NavigableSet keySet, descendingKeySet; 5185 Comparator comparator; 5186 String[] keyArray; 5187 Integer value1, value2; 5188 5189 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 5190 assertNull(keySet.comparator()); 5191 descendingKeySet = keySet.descendingSet(); 5192 comparator = descendingKeySet.comparator(); 5193 assertNotNull(comparator); 5194 keyArray = (String[]) descendingKeySet 5195 .toArray(new String[descendingKeySet.size()]); 5196 for (int i = 1; i < keyArray.length; i++) { 5197 value1 = Integer.valueOf(keyArray[i - 1]); 5198 value2 = Integer.valueOf(keyArray[i]); 5199 assertTrue(value1 > value2); 5200 assertTrue(comparator.compare(value1, value2) < 0); 5201 } 5202 5203 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 5204 assertNull(keySet.comparator()); 5205 descendingKeySet = keySet.descendingSet(); 5206 comparator = descendingKeySet.comparator(); 5207 assertNotNull(comparator); 5208 keyArray = (String[]) descendingKeySet 5209 .toArray(new String[descendingKeySet.size()]); 5210 for (int i = 1; i < keyArray.length; i++) { 5211 value1 = Integer.valueOf(keyArray[i - 1]); 5212 value2 = Integer.valueOf(keyArray[i]); 5213 assertTrue(value1 > value2); 5214 assertTrue(comparator.compare(value1, value2) < 0); 5215 } 5216 5217 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 5218 assertNull(keySet.comparator()); 5219 descendingKeySet = keySet.descendingSet(); 5220 comparator = descendingKeySet.comparator(); 5221 assertNotNull(comparator); 5222 keyArray = (String[]) descendingKeySet 5223 .toArray(new String[descendingKeySet.size()]); 5224 for (int i = 1; i < keyArray.length; i++) { 5225 value1 = Integer.valueOf(keyArray[i - 1]); 5226 value2 = Integer.valueOf(keyArray[i]); 5227 assertTrue(value1 > value2); 5228 assertTrue(comparator.compare(value1, value2) < 0); 5229 } 5230 5231 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 5232 assertNull(keySet.comparator()); 5233 descendingKeySet = keySet.descendingSet(); 5234 comparator = descendingKeySet.comparator(); 5235 assertNotNull(comparator); 5236 keyArray = (String[]) descendingKeySet 5237 .toArray(new String[descendingKeySet.size()]); 5238 for (int i = 1; i < keyArray.length; i++) { 5239 value1 = Integer.valueOf(keyArray[i - 1]); 5240 value2 = Integer.valueOf(keyArray[i]); 5241 assertTrue(value1 > value2); 5242 assertTrue(comparator.compare(value1, value2) < 0); 5243 } 5244 5245 String endKey = new Integer(2).toString(); 5246 keySet = tm.headMap(endKey, true).navigableKeySet(); 5247 assertNull(keySet.comparator()); 5248 descendingKeySet = keySet.descendingSet(); 5249 assertNotNull(descendingKeySet.comparator()); 5250 } 5251 5252 public void test_AscendingSubMapKeySet_first() { 5253 NavigableSet keySet; 5254 String firstKey1 = new Integer(100).toString(); 5255 String firstKey2 = new Integer(101).toString(); 5256 5257 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 5258 assertEquals(firstKey2, keySet.first()); 5259 5260 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 5261 assertEquals(firstKey2, keySet.first()); 5262 5263 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 5264 assertEquals(firstKey1, keySet.first()); 5265 5266 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 5267 assertEquals(firstKey1, keySet.first()); 5268 } 5269 5270 public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endExcluded() { 5271 NavigableSet keySet = navigableMap_startExcluded_endExcluded 5272 .navigableKeySet(); 5273 NavigableSet descendingKeySet = keySet.descendingSet(); 5274 Iterator iterator = descendingKeySet.iterator(); 5275 assertEquals(8, keySet.size()); 5276 for (int value = 101; value < 109; value++) { 5277 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5278 } 5279 assertEquals(0, keySet.size()); 5280 assertNull(keySet.pollLast()); 5281 } 5282 5283 public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endIncluded() { 5284 NavigableSet keySet = navigableMap_startExcluded_endIncluded 5285 .navigableKeySet(); 5286 NavigableSet descendingKeySet = keySet.descendingSet(); 5287 Iterator iterator = descendingKeySet.iterator(); 5288 assertEquals(9, keySet.size()); 5289 for (int value = 101; value < 110; value++) { 5290 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5291 } 5292 assertEquals(0, keySet.size()); 5293 assertNull(keySet.pollLast()); 5294 } 5295 5296 public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endExcluded() { 5297 NavigableSet keySet = navigableMap_startIncluded_endExcluded 5298 .navigableKeySet(); 5299 NavigableSet descendingKeySet = keySet.descendingSet(); 5300 Iterator iterator = descendingKeySet.iterator(); 5301 assertEquals(9, keySet.size()); 5302 for (int value = 100; value < 109; value++) { 5303 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5304 } 5305 assertEquals(0, keySet.size()); 5306 assertNull(keySet.pollLast()); 5307 } 5308 5309 public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endIncluded() { 5310 NavigableSet keySet = navigableMap_startIncluded_endIncluded 5311 .navigableKeySet(); 5312 NavigableSet descendingKeySet = keySet.descendingSet(); 5313 Iterator iterator = descendingKeySet.iterator(); 5314 assertEquals(10, keySet.size()); 5315 for (int value = 100; value < 110; value++) { 5316 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5317 } 5318 assertEquals(0, keySet.size()); 5319 assertNull(keySet.pollLast()); 5320 } 5321 5322 public void test_DescendingSubMapKeySet_pollFirst() { 5323 String endKey = new Integer(2).toString(); 5324 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 5325 NavigableSet descendingKeySet = keySet.descendingSet(); 5326 assertEquals(endKey, descendingKeySet.pollFirst()); 5327 } 5328 5329 public void test_DescendingSubMapKeySet_pollLast_startExcluded_endExcluded() { 5330 NavigableSet keySet = navigableMap_startExcluded_endExcluded 5331 .navigableKeySet(); 5332 NavigableSet descendingKeySet = keySet.descendingSet(); 5333 Iterator iterator = descendingKeySet.iterator(); 5334 assertEquals(8, keySet.size()); 5335 for (int value = 108; value > 100; value--) { 5336 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5337 } 5338 assertEquals(0, keySet.size()); 5339 assertNull(keySet.pollLast()); 5340 } 5341 5342 public void test_DescendingSubMapKeySet_pollLast_startExcluded_endIncluded() { 5343 NavigableSet keySet = navigableMap_startExcluded_endIncluded 5344 .navigableKeySet(); 5345 NavigableSet descendingKeySet = keySet.descendingSet(); 5346 Iterator iterator = descendingKeySet.iterator(); 5347 assertEquals(9, keySet.size()); 5348 for (int value = 109; value > 100; value--) { 5349 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5350 } 5351 assertEquals(0, keySet.size()); 5352 assertNull(keySet.pollLast()); 5353 } 5354 5355 public void test_DescendingSubMapKeySet_pollLast_startIncluded_endExcluded() { 5356 NavigableSet keySet = navigableMap_startIncluded_endExcluded 5357 .navigableKeySet(); 5358 NavigableSet descendingKeySet = keySet.descendingSet(); 5359 Iterator iterator = descendingKeySet.iterator(); 5360 assertEquals(9, keySet.size()); 5361 for (int value = 108; value > 99; value--) { 5362 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5363 } 5364 assertEquals(0, keySet.size()); 5365 assertNull(keySet.pollLast()); 5366 } 5367 5368 public void test_DescendingSubMapKeySet_pollLast_startIncluded_endIncluded() { 5369 NavigableSet keySet = navigableMap_startIncluded_endIncluded 5370 .navigableKeySet(); 5371 NavigableSet descendingKeySet = keySet.descendingSet(); 5372 Iterator iterator = descendingKeySet.iterator(); 5373 assertEquals(10, keySet.size()); 5374 for (int value = 109; value > 99; value--) { 5375 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5376 } 5377 assertEquals(0, keySet.size()); 5378 assertNull(keySet.pollLast()); 5379 } 5380 5381 public void test_DescendingSubMapKeySet_pollLast() { 5382 String endKey = new Integer(2).toString(); 5383 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 5384 NavigableSet descendingKeySet = keySet.descendingSet(); 5385 assertEquals(new Integer(0).toString(), descendingKeySet.pollLast()); 5386 } 5387 5388 public void test_DescendingSubMapKeySet_headSet() { 5389 NavigableSet keySet, descendingKeySet; 5390 SortedSet headSet; 5391 String endKey, key; 5392 Iterator iterator; 5393 int index; 5394 5395 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 5396 descendingKeySet = keySet.descendingSet(); 5397 endKey = new Integer(99).toString(); 5398 try { 5399 descendingKeySet.headSet(endKey); 5400 fail("should throw IllegalArgumentException"); 5401 } catch (IllegalArgumentException e) { 5402 // Expected 5403 } 5404 try { 5405 descendingKeySet.headSet(endKey, false); 5406 fail("should throw IllegalArgumentException"); 5407 } catch (IllegalArgumentException e) { 5408 // Expected 5409 } 5410 try { 5411 descendingKeySet.headSet(endKey, true); 5412 fail("should throw IllegalArgumentException"); 5413 } catch (IllegalArgumentException e) { 5414 // Expected 5415 } 5416 5417 endKey = new Integer(100).toString(); 5418 headSet = descendingKeySet.headSet(endKey); 5419 iterator = headSet.iterator(); 5420 for (index = 108; iterator.hasNext(); index--) { 5421 key = (String) iterator.next(); 5422 assertEquals(new Integer(index).toString(), key); 5423 } 5424 assertEquals(100, index); 5425 5426 headSet = descendingKeySet.headSet(endKey, false); 5427 iterator = headSet.iterator(); 5428 for (index = 108; iterator.hasNext(); index--) { 5429 key = (String) iterator.next(); 5430 assertEquals(new Integer(index).toString(), key); 5431 } 5432 assertEquals(100, index); 5433 5434 try { 5435 descendingKeySet.headSet(endKey, true); 5436 fail("should throw IllegalArgumentException"); 5437 } catch (IllegalArgumentException e) { 5438 // Expected 5439 } 5440 5441 endKey = new Integer(101).toString(); 5442 headSet = descendingKeySet.headSet(endKey); 5443 iterator = headSet.iterator(); 5444 for (index = 108; iterator.hasNext(); index--) { 5445 key = (String) iterator.next(); 5446 assertEquals(new Integer(index).toString(), key); 5447 } 5448 assertEquals(101, index); 5449 5450 headSet = descendingKeySet.headSet(endKey, false); 5451 iterator = headSet.iterator(); 5452 for (index = 108; iterator.hasNext(); index--) { 5453 key = (String) iterator.next(); 5454 assertEquals(new Integer(index).toString(), key); 5455 } 5456 assertEquals(101, index); 5457 5458 headSet = descendingKeySet.headSet(endKey, true); 5459 iterator = headSet.iterator(); 5460 for (index = 108; iterator.hasNext(); index--) { 5461 key = (String) iterator.next(); 5462 assertEquals(new Integer(index).toString(), key); 5463 } 5464 assertEquals(100, index); 5465 5466 for (int i = 102; i < 109; i++) { 5467 endKey = new Integer(i).toString(); 5468 headSet = descendingKeySet.headSet(endKey); 5469 iterator = headSet.iterator(); 5470 int j; 5471 for (j = 108; iterator.hasNext(); j--) { 5472 key = (String) iterator.next(); 5473 assertEquals(new Integer(j).toString(), key); 5474 } 5475 assertEquals(i, j); 5476 5477 headSet = descendingKeySet.headSet(endKey, false); 5478 iterator = headSet.iterator(); 5479 for (j = 108; iterator.hasNext(); j--) { 5480 key = (String) iterator.next(); 5481 assertEquals(new Integer(j).toString(), key); 5482 } 5483 assertEquals(i, j); 5484 5485 headSet = descendingKeySet.headSet(endKey, true); 5486 iterator = headSet.iterator(); 5487 for (j = 108; iterator.hasNext(); j--) { 5488 key = (String) iterator.next(); 5489 assertEquals(new Integer(j).toString(), key); 5490 } 5491 assertEquals(i - 1, j); 5492 } 5493 5494 endKey = new Integer(109).toString(); 5495 try { 5496 headSet = descendingKeySet.headSet(endKey); 5497 fail("should throw IllegalArgumentException"); 5498 } catch (IllegalArgumentException expected) { 5499 // Expected 5500 } 5501 5502 try { 5503 descendingKeySet.headSet(endKey, false); 5504 fail("should throw IllegalArgumentException"); 5505 } catch (IllegalArgumentException e) { 5506 // Expected 5507 } 5508 5509 try { 5510 descendingKeySet.headSet(endKey, true); 5511 fail("should throw IllegalArgumentException"); 5512 } catch (IllegalArgumentException e) { 5513 // Expected 5514 } 5515 5516 endKey = new Integer(110).toString(); 5517 try { 5518 descendingKeySet.headSet(endKey); 5519 fail("should throw IllegalArgumentException"); 5520 } catch (IllegalArgumentException e) { 5521 // Expected 5522 } 5523 try { 5524 descendingKeySet.headSet(endKey, true); 5525 fail("should throw IllegalArgumentException"); 5526 } catch (IllegalArgumentException e) { 5527 // Expected 5528 } 5529 try { 5530 descendingKeySet.headSet(endKey, false); 5531 fail("should throw IllegalArgumentException"); 5532 } catch (IllegalArgumentException e) { 5533 // Expected 5534 } 5535 5536 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 5537 descendingKeySet = keySet.descendingSet(); 5538 endKey = new Integer(99).toString(); 5539 try { 5540 descendingKeySet.headSet(endKey); 5541 fail("should throw IllegalArgumentException"); 5542 } catch (IllegalArgumentException e) { 5543 // Expected 5544 } 5545 try { 5546 descendingKeySet.headSet(endKey, false); 5547 fail("should throw IllegalArgumentException"); 5548 } catch (IllegalArgumentException e) { 5549 // Expected 5550 } 5551 try { 5552 descendingKeySet.headSet(endKey, true); 5553 fail("should throw IllegalArgumentException"); 5554 } catch (IllegalArgumentException e) { 5555 // Expected 5556 } 5557 5558 endKey = new Integer(100).toString(); 5559 headSet = descendingKeySet.headSet(endKey); 5560 iterator = headSet.iterator(); 5561 for (index = 109; iterator.hasNext(); index--) { 5562 key = (String) iterator.next(); 5563 assertEquals(new Integer(index).toString(), key); 5564 } 5565 assertEquals(100, index); 5566 5567 headSet = descendingKeySet.headSet(endKey, false); 5568 iterator = headSet.iterator(); 5569 for (index = 109; iterator.hasNext(); index--) { 5570 key = (String) iterator.next(); 5571 assertEquals(new Integer(index).toString(), key); 5572 } 5573 assertEquals(100, index); 5574 5575 try { 5576 descendingKeySet.headSet(endKey, true); 5577 fail("should throw IllegalArgumentException"); 5578 } catch (IllegalArgumentException e) { 5579 // Expected 5580 } 5581 5582 endKey = new Integer(101).toString(); 5583 headSet = descendingKeySet.headSet(endKey); 5584 iterator = headSet.iterator(); 5585 for (index = 109; iterator.hasNext(); index--) { 5586 key = (String) iterator.next(); 5587 assertEquals(new Integer(index).toString(), key); 5588 } 5589 assertEquals(101, index); 5590 5591 headSet = descendingKeySet.headSet(endKey, false); 5592 iterator = headSet.iterator(); 5593 for (index = 109; iterator.hasNext(); index--) { 5594 key = (String) iterator.next(); 5595 assertEquals(new Integer(index).toString(), key); 5596 } 5597 assertEquals(101, index); 5598 5599 headSet = descendingKeySet.headSet(endKey, true); 5600 iterator = headSet.iterator(); 5601 for (index = 109; iterator.hasNext(); index--) { 5602 key = (String) iterator.next(); 5603 assertEquals(new Integer(index).toString(), key); 5604 } 5605 assertEquals(100, index); 5606 5607 for (int i = 102; i < 109; i++) { 5608 endKey = new Integer(i).toString(); 5609 headSet = descendingKeySet.headSet(endKey); 5610 iterator = headSet.iterator(); 5611 int j; 5612 for (j = 109; iterator.hasNext(); j--) { 5613 key = (String) iterator.next(); 5614 assertEquals(new Integer(j).toString(), key); 5615 } 5616 assertEquals(i, j); 5617 5618 headSet = descendingKeySet.headSet(endKey, false); 5619 iterator = headSet.iterator(); 5620 for (j = 109; iterator.hasNext(); j--) { 5621 key = (String) iterator.next(); 5622 assertEquals(new Integer(j).toString(), key); 5623 } 5624 assertEquals(i, j); 5625 5626 headSet = descendingKeySet.headSet(endKey, true); 5627 iterator = headSet.iterator(); 5628 for (j = 109; iterator.hasNext(); j--) { 5629 key = (String) iterator.next(); 5630 assertEquals(new Integer(j).toString(), key); 5631 } 5632 assertEquals(i - 1, j); 5633 } 5634 5635 endKey = new Integer(109).toString(); 5636 headSet = descendingKeySet.headSet(endKey); 5637 iterator = headSet.iterator(); 5638 for (index = 109; iterator.hasNext(); index--) { 5639 key = (String) iterator.next(); 5640 assertEquals(new Integer(index).toString(), key); 5641 } 5642 assertEquals(109, index); 5643 5644 headSet = descendingKeySet.headSet(endKey, false); 5645 iterator = headSet.iterator(); 5646 for (index = 109; iterator.hasNext(); index--) { 5647 key = (String) iterator.next(); 5648 assertEquals(new Integer(index).toString(), key); 5649 } 5650 assertEquals(109, index); 5651 5652 headSet = descendingKeySet.headSet(endKey, true); 5653 iterator = headSet.iterator(); 5654 for (index = 109; iterator.hasNext(); index--) { 5655 key = (String) iterator.next(); 5656 assertEquals(new Integer(index).toString(), key); 5657 } 5658 assertEquals(108, index); 5659 5660 endKey = new Integer(110).toString(); 5661 try { 5662 descendingKeySet.headSet(endKey); 5663 fail("should throw IllegalArgumentException"); 5664 } catch (IllegalArgumentException e) { 5665 // Expected 5666 } 5667 try { 5668 descendingKeySet.headSet(endKey, true); 5669 fail("should throw IllegalArgumentException"); 5670 } catch (IllegalArgumentException e) { 5671 // Expected 5672 } 5673 try { 5674 descendingKeySet.headSet(endKey, false); 5675 fail("should throw IllegalArgumentException"); 5676 } catch (IllegalArgumentException e) { 5677 // Expected 5678 } 5679 5680 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 5681 descendingKeySet = keySet.descendingSet(); 5682 endKey = new Integer(99).toString(); 5683 try { 5684 descendingKeySet.headSet(endKey); 5685 fail("should throw IllegalArgumentException"); 5686 } catch (IllegalArgumentException e) { 5687 // Expected 5688 } 5689 try { 5690 descendingKeySet.headSet(endKey, false); 5691 fail("should throw IllegalArgumentException"); 5692 } catch (IllegalArgumentException e) { 5693 // Expected 5694 } 5695 try { 5696 descendingKeySet.headSet(endKey, true); 5697 fail("should throw IllegalArgumentException"); 5698 } catch (IllegalArgumentException e) { 5699 // Expected 5700 } 5701 5702 endKey = new Integer(100).toString(); 5703 headSet = descendingKeySet.headSet(endKey); 5704 iterator = headSet.iterator(); 5705 for (index = 108; iterator.hasNext(); index--) { 5706 key = (String) iterator.next(); 5707 assertEquals(new Integer(index).toString(), key); 5708 } 5709 assertEquals(100, index); 5710 5711 headSet = descendingKeySet.headSet(endKey, false); 5712 iterator = headSet.iterator(); 5713 for (index = 108; iterator.hasNext(); index--) { 5714 key = (String) iterator.next(); 5715 assertEquals(new Integer(index).toString(), key); 5716 } 5717 assertEquals(100, index); 5718 5719 headSet = descendingKeySet.headSet(endKey, true); 5720 iterator = headSet.iterator(); 5721 for (index = 108; iterator.hasNext(); index--) { 5722 key = (String) iterator.next(); 5723 assertEquals(new Integer(index).toString(), key); 5724 } 5725 assertEquals(99, index); 5726 5727 endKey = new Integer(101).toString(); 5728 headSet = descendingKeySet.headSet(endKey); 5729 iterator = headSet.iterator(); 5730 for (index = 108; iterator.hasNext(); index--) { 5731 key = (String) iterator.next(); 5732 assertEquals(new Integer(index).toString(), key); 5733 } 5734 assertEquals(101, index); 5735 5736 headSet = descendingKeySet.headSet(endKey, false); 5737 iterator = headSet.iterator(); 5738 for (index = 108; iterator.hasNext(); index--) { 5739 key = (String) iterator.next(); 5740 assertEquals(new Integer(index).toString(), key); 5741 } 5742 assertEquals(101, index); 5743 5744 headSet = descendingKeySet.headSet(endKey, true); 5745 iterator = headSet.iterator(); 5746 for (index = 108; iterator.hasNext(); index--) { 5747 key = (String) iterator.next(); 5748 assertEquals(new Integer(index).toString(), key); 5749 } 5750 assertEquals(100, index); 5751 5752 for (int i = 102; i < 109; i++) { 5753 endKey = new Integer(i).toString(); 5754 headSet = descendingKeySet.headSet(endKey); 5755 iterator = headSet.iterator(); 5756 int j; 5757 for (j = 108; iterator.hasNext(); j--) { 5758 key = (String) iterator.next(); 5759 assertEquals(new Integer(j).toString(), key); 5760 } 5761 assertEquals(i, j); 5762 5763 headSet = descendingKeySet.headSet(endKey, false); 5764 iterator = headSet.iterator(); 5765 for (j = 108; iterator.hasNext(); j--) { 5766 key = (String) iterator.next(); 5767 assertEquals(new Integer(j).toString(), key); 5768 } 5769 assertEquals(i, j); 5770 5771 headSet = descendingKeySet.headSet(endKey, true); 5772 iterator = headSet.iterator(); 5773 for (j = 108; iterator.hasNext(); j--) { 5774 key = (String) iterator.next(); 5775 assertEquals(new Integer(j).toString(), key); 5776 } 5777 assertEquals(i - 1, j); 5778 } 5779 5780 endKey = new Integer(109).toString(); 5781 5782 try { 5783 descendingKeySet.headSet(endKey); 5784 fail("should throw IllegalArgumentException"); 5785 } catch (IllegalArgumentException e) { 5786 // Expected 5787 } 5788 5789 try { 5790 descendingKeySet.headSet(endKey, false); 5791 fail("should throw IllegalArgumentException"); 5792 } catch (IllegalArgumentException e) { 5793 // Expected 5794 } 5795 5796 try { 5797 descendingKeySet.headSet(endKey, true); 5798 fail("should throw IllegalArgumentException"); 5799 } catch (IllegalArgumentException e) { 5800 // Expected 5801 } 5802 5803 endKey = new Integer(110).toString(); 5804 try { 5805 descendingKeySet.headSet(endKey); 5806 fail("should throw IllegalArgumentException"); 5807 } catch (IllegalArgumentException e) { 5808 // Expected 5809 } 5810 try { 5811 descendingKeySet.headSet(endKey, true); 5812 fail("should throw IllegalArgumentException"); 5813 } catch (IllegalArgumentException e) { 5814 // Expected 5815 } 5816 try { 5817 descendingKeySet.headSet(endKey, false); 5818 fail("should throw IllegalArgumentException"); 5819 } catch (IllegalArgumentException e) { 5820 // Expected 5821 } 5822 5823 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 5824 descendingKeySet = keySet.descendingSet(); 5825 endKey = new Integer(99).toString(); 5826 try { 5827 descendingKeySet.headSet(endKey); 5828 fail("should throw IllegalArgumentException"); 5829 } catch (IllegalArgumentException e) { 5830 // Expected 5831 } 5832 try { 5833 descendingKeySet.headSet(endKey, false); 5834 fail("should throw IllegalArgumentException"); 5835 } catch (IllegalArgumentException e) { 5836 // Expected 5837 } 5838 try { 5839 descendingKeySet.headSet(endKey, true); 5840 fail("should throw IllegalArgumentException"); 5841 } catch (IllegalArgumentException e) { 5842 // Expected 5843 } 5844 5845 endKey = new Integer(100).toString(); 5846 headSet = descendingKeySet.headSet(endKey); 5847 iterator = headSet.iterator(); 5848 for (index = 109; iterator.hasNext(); index--) { 5849 key = (String) iterator.next(); 5850 assertEquals(new Integer(index).toString(), key); 5851 } 5852 assertEquals(100, index); 5853 5854 headSet = descendingKeySet.headSet(endKey, false); 5855 iterator = headSet.iterator(); 5856 for (index = 109; iterator.hasNext(); index--) { 5857 key = (String) iterator.next(); 5858 assertEquals(new Integer(index).toString(), key); 5859 } 5860 assertEquals(100, index); 5861 5862 headSet = descendingKeySet.headSet(endKey, true); 5863 iterator = headSet.iterator(); 5864 for (index = 109; iterator.hasNext(); index--) { 5865 key = (String) iterator.next(); 5866 assertEquals(new Integer(index).toString(), key); 5867 } 5868 assertEquals(99, index); 5869 5870 endKey = new Integer(101).toString(); 5871 headSet = descendingKeySet.headSet(endKey); 5872 iterator = headSet.iterator(); 5873 for (index = 109; iterator.hasNext(); index--) { 5874 key = (String) iterator.next(); 5875 assertEquals(new Integer(index).toString(), key); 5876 } 5877 assertEquals(101, index); 5878 5879 headSet = descendingKeySet.headSet(endKey, false); 5880 iterator = headSet.iterator(); 5881 for (index = 109; iterator.hasNext(); index--) { 5882 key = (String) iterator.next(); 5883 assertEquals(new Integer(index).toString(), key); 5884 } 5885 assertEquals(101, index); 5886 5887 headSet = descendingKeySet.headSet(endKey, true); 5888 iterator = headSet.iterator(); 5889 for (index = 109; iterator.hasNext(); index--) { 5890 key = (String) iterator.next(); 5891 assertEquals(new Integer(index).toString(), key); 5892 } 5893 assertEquals(100, index); 5894 5895 for (int i = 102; i < 109; i++) { 5896 endKey = new Integer(i).toString(); 5897 headSet = descendingKeySet.headSet(endKey); 5898 iterator = headSet.iterator(); 5899 int j; 5900 for (j = 109; iterator.hasNext(); j--) { 5901 key = (String) iterator.next(); 5902 assertEquals(new Integer(j).toString(), key); 5903 } 5904 assertEquals(i, j); 5905 5906 headSet = descendingKeySet.headSet(endKey, false); 5907 iterator = headSet.iterator(); 5908 for (j = 109; iterator.hasNext(); j--) { 5909 key = (String) iterator.next(); 5910 assertEquals(new Integer(j).toString(), key); 5911 } 5912 assertEquals(i, j); 5913 5914 headSet = descendingKeySet.headSet(endKey, true); 5915 iterator = headSet.iterator(); 5916 for (j = 109; iterator.hasNext(); j--) { 5917 key = (String) iterator.next(); 5918 assertEquals(new Integer(j).toString(), key); 5919 } 5920 assertEquals(i - 1, j); 5921 } 5922 5923 endKey = new Integer(109).toString(); 5924 headSet = descendingKeySet.headSet(endKey); 5925 iterator = headSet.iterator(); 5926 for (index = 109; iterator.hasNext(); index--) { 5927 key = (String) iterator.next(); 5928 assertEquals(new Integer(index).toString(), key); 5929 } 5930 assertEquals(109, index); 5931 5932 headSet = descendingKeySet.headSet(endKey, false); 5933 iterator = headSet.iterator(); 5934 for (index = 109; iterator.hasNext(); index--) { 5935 key = (String) iterator.next(); 5936 assertEquals(new Integer(index).toString(), key); 5937 } 5938 assertEquals(109, index); 5939 5940 headSet = descendingKeySet.headSet(endKey, true); 5941 iterator = headSet.iterator(); 5942 for (index = 109; iterator.hasNext(); index--) { 5943 key = (String) iterator.next(); 5944 assertEquals(new Integer(index).toString(), key); 5945 } 5946 assertEquals(108, index); 5947 5948 endKey = new Integer(110).toString(); 5949 try { 5950 descendingKeySet.headSet(endKey); 5951 fail("should throw IllegalArgumentException"); 5952 } catch (IllegalArgumentException e) { 5953 // Expected 5954 } 5955 try { 5956 descendingKeySet.headSet(endKey, true); 5957 fail("should throw IllegalArgumentException"); 5958 } catch (IllegalArgumentException e) { 5959 // Expected 5960 } 5961 try { 5962 descendingKeySet.headSet(endKey, false); 5963 fail("should throw IllegalArgumentException"); 5964 } catch (IllegalArgumentException e) { 5965 // Expected 5966 } 5967 5968 key = new Integer(2).toString(); 5969 keySet = tm.headMap(key, true).navigableKeySet(); 5970 descendingKeySet = keySet.descendingSet(); 5971 iterator = descendingKeySet.iterator(); 5972 iterator.next(); 5973 endKey = (String) iterator.next(); 5974 5975 headSet = descendingKeySet.headSet(endKey); 5976 assertEquals(1, headSet.size()); 5977 5978 headSet = descendingKeySet.headSet(endKey, false); 5979 assertEquals(1, headSet.size()); 5980 5981 headSet = descendingKeySet.headSet(endKey, true); 5982 assertEquals(2, headSet.size()); 5983 5984 key = new Integer(2).toString(); 5985 keySet = tm.tailMap(key, true).navigableKeySet(); 5986 descendingKeySet = keySet.descendingSet(); 5987 iterator = descendingKeySet.iterator(); 5988 iterator.next(); 5989 endKey = (String) iterator.next(); 5990 headSet = descendingKeySet.headSet(endKey); 5991 assertEquals(1, headSet.size()); 5992 iterator = headSet.iterator(); 5993 assertEquals(999, Integer.parseInt((String) iterator.next())); 5994 } 5995 5996 public void test_DescendingSubMapKeySet_tailSet() { 5997 NavigableSet keySet, descendingKeySet; 5998 SortedSet tailSet; 5999 String startKey, key; 6000 Iterator iterator; 6001 int index; 6002 6003 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 6004 descendingKeySet = keySet.descendingSet(); 6005 startKey = new Integer(99).toString(); 6006 try { 6007 descendingKeySet.tailSet(startKey); 6008 fail("should throw IllegalArgumentException"); 6009 } catch (IllegalArgumentException e) { 6010 // Expected 6011 } 6012 6013 try { 6014 descendingKeySet.tailSet(startKey, true); 6015 fail("should throw IllegalArgumentException"); 6016 } catch (IllegalArgumentException e) { 6017 // Expected 6018 } 6019 6020 try { 6021 descendingKeySet.tailSet(startKey, false); 6022 fail("should throw IllegalArgumentException"); 6023 } catch (IllegalArgumentException e) { 6024 // Expected 6025 } 6026 6027 startKey = new Integer(100).toString(); 6028 try { 6029 descendingKeySet.tailSet(startKey); 6030 fail("should throw IllegalArgumentException"); 6031 } catch (IllegalArgumentException e) { 6032 // Expected 6033 } 6034 try { 6035 descendingKeySet.tailSet(startKey, true); 6036 fail("should throw IllegalArgumentException"); 6037 } catch (IllegalArgumentException e) { 6038 // Expected 6039 } 6040 6041 try { 6042 descendingKeySet.tailSet(startKey, false); 6043 fail("should throw IllegalArgumentException"); 6044 } catch (IllegalArgumentException e) { 6045 // Expected 6046 } 6047 6048 startKey = new Integer(101).toString(); 6049 tailSet = descendingKeySet.tailSet(startKey); 6050 iterator = tailSet.iterator(); 6051 for (index = 101; iterator.hasNext(); index--) { 6052 key = (String) iterator.next(); 6053 assertEquals(new Integer(index).toString(), key); 6054 } 6055 assertEquals(100, index); 6056 6057 tailSet = descendingKeySet.tailSet(startKey, true); 6058 iterator = tailSet.iterator(); 6059 for (index = 101; iterator.hasNext(); index--) { 6060 key = (String) iterator.next(); 6061 assertEquals(new Integer(index).toString(), key); 6062 } 6063 assertEquals(100, index); 6064 6065 tailSet = descendingKeySet.tailSet(startKey, false); 6066 iterator = tailSet.iterator(); 6067 for (index = 101; iterator.hasNext(); index--) { 6068 key = (String) iterator.next(); 6069 assertEquals(new Integer(index).toString(), key); 6070 } 6071 assertEquals(101, index); 6072 6073 for (int i = 102; i < 109; i++) { 6074 startKey = new Integer(i).toString(); 6075 6076 tailSet = descendingKeySet.tailSet(startKey); 6077 iterator = tailSet.iterator(); 6078 int j; 6079 for (j = i; iterator.hasNext(); j--) { 6080 key = (String) iterator.next(); 6081 assertEquals(new Integer(j).toString(), key); 6082 } 6083 assertEquals(100, j); 6084 6085 tailSet = descendingKeySet.tailSet(startKey, true); 6086 iterator = tailSet.iterator(); 6087 for (j = i; iterator.hasNext(); j--) { 6088 key = (String) iterator.next(); 6089 assertEquals(new Integer(j).toString(), key); 6090 } 6091 assertEquals(100, j); 6092 6093 tailSet = descendingKeySet.tailSet(startKey, false); 6094 iterator = tailSet.iterator(); 6095 for (j = i; iterator.hasNext(); j--) { 6096 key = (String) iterator.next(); 6097 assertEquals(new Integer(j - 1).toString(), key); 6098 } 6099 assertEquals(101, j); 6100 } 6101 6102 startKey = new Integer(109).toString(); 6103 try { 6104 descendingKeySet.tailSet(startKey); 6105 fail("should throw IllegalArgumentException"); 6106 } catch (IllegalArgumentException e) { 6107 // Expected 6108 } 6109 try { 6110 descendingKeySet.tailSet(startKey, true); 6111 fail("should throw IllegalArgumentException"); 6112 } catch (IllegalArgumentException e) { 6113 // Expected 6114 } 6115 tailSet = descendingKeySet.tailSet(startKey, false); 6116 iterator = tailSet.iterator(); 6117 for (index = 109; iterator.hasNext(); index--) { 6118 key = (String) iterator.next(); 6119 assertEquals(new Integer(index - 1).toString(), key); 6120 } 6121 assertEquals(101, index); 6122 6123 startKey = new Integer(110).toString(); 6124 try { 6125 descendingKeySet.tailSet(startKey); 6126 fail("should throw IllegalArgumentException"); 6127 } catch (IllegalArgumentException e) { 6128 // Expected 6129 } 6130 try { 6131 descendingKeySet.tailSet(startKey, true); 6132 fail("should throw IllegalArgumentException"); 6133 } catch (IllegalArgumentException e) { 6134 // Expected 6135 } 6136 try { 6137 descendingKeySet.tailSet(startKey, false); 6138 fail("should throw IllegalArgumentException"); 6139 } catch (IllegalArgumentException e) { 6140 // Expected 6141 } 6142 6143 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 6144 descendingKeySet = keySet.descendingSet(); 6145 startKey = new Integer(99).toString(); 6146 try { 6147 descendingKeySet.tailSet(startKey); 6148 fail("should throw IllegalArgumentException"); 6149 } catch (IllegalArgumentException e) { 6150 // Expected 6151 } 6152 6153 try { 6154 descendingKeySet.tailSet(startKey, true); 6155 fail("should throw IllegalArgumentException"); 6156 } catch (IllegalArgumentException e) { 6157 // Expected 6158 } 6159 6160 try { 6161 descendingKeySet.tailSet(startKey, false); 6162 fail("should throw IllegalArgumentException"); 6163 } catch (IllegalArgumentException e) { 6164 // Expected 6165 } 6166 6167 startKey = new Integer(100).toString(); 6168 try { 6169 descendingKeySet.tailSet(startKey); 6170 fail("should throw IllegalArgumentException"); 6171 } catch (IllegalArgumentException e) { 6172 // Expected 6173 } 6174 try { 6175 descendingKeySet.tailSet(startKey, true); 6176 fail("should throw IllegalArgumentException"); 6177 } catch (IllegalArgumentException e) { 6178 // Expected 6179 } 6180 try { 6181 descendingKeySet.tailSet(startKey, false); 6182 fail("should throw IllegalArgumentException"); 6183 } catch (IllegalArgumentException e) { 6184 // Expected 6185 } 6186 6187 startKey = new Integer(101).toString(); 6188 tailSet = descendingKeySet.tailSet(startKey); 6189 iterator = tailSet.iterator(); 6190 for (index = 101; iterator.hasNext(); index--) { 6191 key = (String) iterator.next(); 6192 assertEquals(new Integer(index).toString(), key); 6193 } 6194 assertEquals(100, index); 6195 6196 tailSet = descendingKeySet.tailSet(startKey, true); 6197 iterator = tailSet.iterator(); 6198 for (index = 101; iterator.hasNext(); index--) { 6199 key = (String) iterator.next(); 6200 assertEquals(new Integer(index).toString(), key); 6201 } 6202 assertEquals(100, index); 6203 6204 tailSet = descendingKeySet.tailSet(startKey, false); 6205 iterator = tailSet.iterator(); 6206 for (index = 101; iterator.hasNext(); index--) { 6207 key = (String) iterator.next(); 6208 assertEquals(new Integer(index).toString(), key); 6209 } 6210 assertEquals(101, index); 6211 6212 for (int i = 102; i < 109; i++) { 6213 startKey = new Integer(i).toString(); 6214 6215 tailSet = descendingKeySet.tailSet(startKey); 6216 iterator = tailSet.iterator(); 6217 int j; 6218 for (j = i; iterator.hasNext(); j--) { 6219 key = (String) iterator.next(); 6220 assertEquals(new Integer(j).toString(), key); 6221 } 6222 assertEquals(100, j); 6223 6224 tailSet = descendingKeySet.tailSet(startKey, true); 6225 iterator = tailSet.iterator(); 6226 for (j = i; iterator.hasNext(); j--) { 6227 key = (String) iterator.next(); 6228 assertEquals(new Integer(j).toString(), key); 6229 } 6230 assertEquals(100, j); 6231 6232 tailSet = descendingKeySet.tailSet(startKey, false); 6233 iterator = tailSet.iterator(); 6234 for (j = i; iterator.hasNext(); j--) { 6235 key = (String) iterator.next(); 6236 assertEquals(new Integer(j - 1).toString(), key); 6237 } 6238 assertEquals(101, j); 6239 } 6240 6241 startKey = new Integer(109).toString(); 6242 tailSet = descendingKeySet.tailSet(startKey); 6243 iterator = tailSet.iterator(); 6244 for (index = 109; iterator.hasNext(); index--) { 6245 key = (String) iterator.next(); 6246 assertEquals(new Integer(index).toString(), key); 6247 } 6248 assertEquals(100, index); 6249 6250 tailSet = descendingKeySet.tailSet(startKey, true); 6251 iterator = tailSet.iterator(); 6252 for (index = 109; iterator.hasNext(); index--) { 6253 key = (String) iterator.next(); 6254 assertEquals(new Integer(index).toString(), key); 6255 } 6256 assertEquals(100, index); 6257 6258 tailSet = descendingKeySet.tailSet(startKey, false); 6259 iterator = tailSet.iterator(); 6260 for (index = 109; iterator.hasNext(); index--) { 6261 key = (String) iterator.next(); 6262 assertEquals(new Integer(index - 1).toString(), key); 6263 } 6264 assertEquals(101, index); 6265 6266 startKey = new Integer(110).toString(); 6267 try { 6268 descendingKeySet.tailSet(startKey); 6269 fail("should throw IllegalArgumentException"); 6270 } catch (IllegalArgumentException e) { 6271 // Expected 6272 } 6273 try { 6274 descendingKeySet.tailSet(startKey, true); 6275 fail("should throw IllegalArgumentException"); 6276 } catch (IllegalArgumentException e) { 6277 // Expected 6278 } 6279 try { 6280 descendingKeySet.tailSet(startKey, false); 6281 fail("should throw IllegalArgumentException"); 6282 } catch (IllegalArgumentException e) { 6283 // Expected 6284 } 6285 6286 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 6287 descendingKeySet = keySet.descendingSet(); 6288 startKey = new Integer(99).toString(); 6289 try { 6290 descendingKeySet.tailSet(startKey); 6291 fail("should throw IllegalArgumentException"); 6292 } catch (IllegalArgumentException e) { 6293 // Expected 6294 } 6295 try { 6296 descendingKeySet.tailSet(startKey, true); 6297 fail("should throw IllegalArgumentException"); 6298 } catch (IllegalArgumentException e) { 6299 // Expected 6300 } 6301 try { 6302 descendingKeySet.tailSet(startKey, false); 6303 fail("should throw IllegalArgumentException"); 6304 } catch (IllegalArgumentException e) { 6305 // Expected 6306 } 6307 6308 startKey = new Integer(100).toString(); 6309 tailSet = descendingKeySet.tailSet(startKey); 6310 assertEquals(1, tailSet.size()); 6311 iterator = tailSet.iterator(); 6312 assertEquals(startKey, iterator.next()); 6313 6314 tailSet = descendingKeySet.tailSet(startKey, true); 6315 assertEquals(1, tailSet.size()); 6316 iterator = tailSet.iterator(); 6317 assertEquals(startKey, iterator.next()); 6318 6319 tailSet = descendingKeySet.tailSet(startKey, false); 6320 assertEquals(0, tailSet.size()); 6321 6322 startKey = new Integer(101).toString(); 6323 tailSet = descendingKeySet.tailSet(startKey); 6324 iterator = tailSet.iterator(); 6325 for (index = 101; iterator.hasNext(); index--) { 6326 key = (String) iterator.next(); 6327 assertEquals(new Integer(index).toString(), key); 6328 } 6329 assertEquals(99, index); 6330 6331 tailSet = descendingKeySet.tailSet(startKey, true); 6332 iterator = tailSet.iterator(); 6333 for (index = 101; iterator.hasNext(); index--) { 6334 key = (String) iterator.next(); 6335 assertEquals(new Integer(index).toString(), key); 6336 } 6337 assertEquals(99, index); 6338 6339 tailSet = descendingKeySet.tailSet(startKey, false); 6340 iterator = tailSet.iterator(); 6341 for (index = 101; iterator.hasNext(); index--) { 6342 key = (String) iterator.next(); 6343 assertEquals(new Integer(index - 1).toString(), key); 6344 } 6345 assertEquals(100, index); 6346 6347 for (int i = 102; i < 109; i++) { 6348 startKey = new Integer(i).toString(); 6349 6350 tailSet = descendingKeySet.tailSet(startKey); 6351 iterator = tailSet.iterator(); 6352 int j; 6353 for (j = i; iterator.hasNext(); j--) { 6354 key = (String) iterator.next(); 6355 assertEquals(new Integer(j).toString(), key); 6356 } 6357 assertEquals(99, j); 6358 6359 tailSet = descendingKeySet.tailSet(startKey, true); 6360 iterator = tailSet.iterator(); 6361 for (j = i; iterator.hasNext(); j--) { 6362 key = (String) iterator.next(); 6363 assertEquals(new Integer(j).toString(), key); 6364 } 6365 assertEquals(99, j); 6366 6367 tailSet = descendingKeySet.tailSet(startKey, false); 6368 iterator = tailSet.iterator(); 6369 for (j = i; iterator.hasNext(); j--) { 6370 key = (String) iterator.next(); 6371 assertEquals(new Integer(j - 1).toString(), key); 6372 } 6373 assertEquals(100, j); 6374 } 6375 6376 startKey = new Integer(109).toString(); 6377 try { 6378 descendingKeySet.tailSet(startKey); 6379 fail("should throw IllegalArgumentException"); 6380 } catch (IllegalArgumentException e) { 6381 // Expected 6382 } 6383 try { 6384 descendingKeySet.tailSet(startKey, true); 6385 fail("should throw IllegalArgumentException"); 6386 } catch (IllegalArgumentException e) { 6387 // Expected 6388 } 6389 tailSet = descendingKeySet.tailSet(startKey, false); 6390 iterator = tailSet.iterator(); 6391 for (index = 109; iterator.hasNext(); index--) { 6392 key = (String) iterator.next(); 6393 assertEquals(new Integer(index - 1).toString(), key); 6394 } 6395 assertEquals(100, index); 6396 6397 startKey = new Integer(110).toString(); 6398 try { 6399 descendingKeySet.tailSet(startKey); 6400 fail("should throw IllegalArgumentException"); 6401 } catch (IllegalArgumentException e) { 6402 // Expected 6403 } 6404 try { 6405 descendingKeySet.tailSet(startKey, true); 6406 fail("should throw IllegalArgumentException"); 6407 } catch (IllegalArgumentException e) { 6408 // Expected 6409 } 6410 try { 6411 descendingKeySet.tailSet(startKey, false); 6412 fail("should throw IllegalArgumentException"); 6413 } catch (IllegalArgumentException e) { 6414 // Expected 6415 } 6416 6417 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 6418 descendingKeySet = keySet.descendingSet(); 6419 startKey = new Integer(99).toString(); 6420 try { 6421 descendingKeySet.tailSet(startKey); 6422 fail("should throw IllegalArgumentException"); 6423 } catch (IllegalArgumentException e) { 6424 // Expected 6425 } 6426 try { 6427 descendingKeySet.tailSet(startKey, true); 6428 fail("should throw IllegalArgumentException"); 6429 } catch (IllegalArgumentException e) { 6430 // Expected 6431 } 6432 try { 6433 descendingKeySet.tailSet(startKey, false); 6434 fail("should throw IllegalArgumentException"); 6435 } catch (IllegalArgumentException e) { 6436 // Expected 6437 } 6438 6439 startKey = new Integer(100).toString(); 6440 tailSet = descendingKeySet.tailSet(startKey); 6441 assertEquals(1, tailSet.size()); 6442 iterator = tailSet.iterator(); 6443 assertEquals(startKey, iterator.next()); 6444 6445 tailSet = descendingKeySet.tailSet(startKey, true); 6446 assertEquals(1, tailSet.size()); 6447 iterator = tailSet.iterator(); 6448 assertEquals(startKey, iterator.next()); 6449 6450 tailSet = descendingKeySet.tailSet(startKey, false); 6451 assertEquals(0, tailSet.size()); 6452 6453 startKey = new Integer(101).toString(); 6454 tailSet = descendingKeySet.tailSet(startKey); 6455 iterator = tailSet.iterator(); 6456 for (index = 101; iterator.hasNext(); index--) { 6457 key = (String) iterator.next(); 6458 assertEquals(new Integer(index).toString(), key); 6459 } 6460 assertEquals(99, index); 6461 6462 tailSet = descendingKeySet.tailSet(startKey, true); 6463 iterator = tailSet.iterator(); 6464 for (index = 101; iterator.hasNext(); index--) { 6465 key = (String) iterator.next(); 6466 assertEquals(new Integer(index).toString(), key); 6467 } 6468 assertEquals(99, index); 6469 6470 tailSet = descendingKeySet.tailSet(startKey, false); 6471 iterator = tailSet.iterator(); 6472 for (index = 101; iterator.hasNext(); index--) { 6473 key = (String) iterator.next(); 6474 assertEquals(new Integer(index - 1).toString(), key); 6475 } 6476 assertEquals(100, index); 6477 6478 for (int i = 102; i < 109; i++) { 6479 startKey = new Integer(i).toString(); 6480 6481 tailSet = descendingKeySet.tailSet(startKey); 6482 iterator = tailSet.iterator(); 6483 int j; 6484 for (j = i; iterator.hasNext(); j--) { 6485 key = (String) iterator.next(); 6486 assertEquals(new Integer(j).toString(), key); 6487 } 6488 assertEquals(99, j); 6489 6490 tailSet = descendingKeySet.tailSet(startKey, true); 6491 iterator = tailSet.iterator(); 6492 for (j = i; iterator.hasNext(); j--) { 6493 key = (String) iterator.next(); 6494 assertEquals(new Integer(j).toString(), key); 6495 } 6496 assertEquals(99, j); 6497 6498 tailSet = descendingKeySet.tailSet(startKey, false); 6499 iterator = tailSet.iterator(); 6500 for (j = i; iterator.hasNext(); j--) { 6501 key = (String) iterator.next(); 6502 assertEquals(new Integer(j - 1).toString(), key); 6503 } 6504 assertEquals(100, j); 6505 } 6506 6507 startKey = new Integer(109).toString(); 6508 tailSet = descendingKeySet.tailSet(startKey); 6509 iterator = tailSet.iterator(); 6510 for (index = 109; iterator.hasNext(); index--) { 6511 key = (String) iterator.next(); 6512 assertEquals(new Integer(index).toString(), key); 6513 } 6514 assertEquals(99, index); 6515 6516 tailSet = descendingKeySet.tailSet(startKey, true); 6517 iterator = tailSet.iterator(); 6518 for (index = 109; iterator.hasNext(); index--) { 6519 key = (String) iterator.next(); 6520 assertEquals(new Integer(index).toString(), key); 6521 } 6522 assertEquals(99, index); 6523 6524 tailSet = descendingKeySet.tailSet(startKey, false); 6525 iterator = tailSet.iterator(); 6526 for (index = 109; iterator.hasNext(); index--) { 6527 key = (String) iterator.next(); 6528 assertEquals(new Integer(index - 1).toString(), key); 6529 } 6530 assertEquals(100, index); 6531 6532 startKey = new Integer(110).toString(); 6533 try { 6534 descendingKeySet.tailSet(startKey); 6535 fail("should throw IllegalArgumentException"); 6536 } catch (IllegalArgumentException e) { 6537 // Expected 6538 } 6539 try { 6540 descendingKeySet.tailSet(startKey, true); 6541 fail("should throw IllegalArgumentException"); 6542 } catch (IllegalArgumentException e) { 6543 // Expected 6544 } 6545 try { 6546 descendingKeySet.tailSet(startKey, false); 6547 fail("should throw IllegalArgumentException"); 6548 } catch (IllegalArgumentException e) { 6549 // Expected 6550 } 6551 6552 key = new Integer(2).toString(); 6553 keySet = tm.headMap(key, true).navigableKeySet(); 6554 descendingKeySet = keySet.descendingSet(); 6555 iterator = descendingKeySet.iterator(); 6556 iterator.next(); 6557 startKey = (String) iterator.next(); 6558 6559 tailSet = descendingKeySet.tailSet(startKey); 6560 assertEquals(112, tailSet.size()); 6561 Iterator tailIterator = tailSet.iterator(); 6562 assertEquals(new Integer(199).toString(), tailIterator.next()); 6563 6564 tailSet = descendingKeySet.tailSet(startKey, true); 6565 assertEquals(112, tailSet.size()); 6566 tailIterator = tailSet.iterator(); 6567 assertEquals(new Integer(199).toString(), tailIterator.next()); 6568 6569 tailSet = descendingKeySet.tailSet(startKey, false); 6570 assertEquals(111, tailSet.size()); 6571 tailIterator = tailSet.iterator(); 6572 assertEquals(new Integer(198).toString(), tailIterator.next()); 6573 } 6574 6575 public void test_DescendingSubMapKeySet_subSet() { 6576 NavigableSet keySet, descendingKeySet; 6577 SortedSet subSet; 6578 String startKey, endKey, key; 6579 Iterator startIterator, endIterator, subSetIterator; 6580 6581 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 6582 descendingKeySet = keySet.descendingSet(); 6583 startIterator = descendingKeySet.iterator(); 6584 while (startIterator.hasNext()) { 6585 startKey = (String) startIterator.next(); 6586 endIterator = descendingKeySet.iterator(); 6587 while (endIterator.hasNext()) { 6588 endKey = (String) endIterator.next(); 6589 int startIndex = Integer.valueOf(startKey); 6590 int endIndex = Integer.valueOf(endKey); 6591 if (startIndex < endIndex) { 6592 try { 6593 descendingKeySet.subSet(startKey, endKey); 6594 fail("should throw IllegalArgumentException"); 6595 } catch (IllegalArgumentException e) { 6596 // Expected 6597 } 6598 6599 try { 6600 descendingKeySet.subSet(startKey, false, endKey, false); 6601 fail("shoudl throw IllegalArgumentException"); 6602 } catch (IllegalArgumentException e) { 6603 // Expected 6604 } 6605 6606 try { 6607 descendingKeySet.subSet(startKey, false, endKey, true); 6608 fail("shoudl throw IllegalArgumentException"); 6609 } catch (IllegalArgumentException e) { 6610 // Expected 6611 } 6612 6613 try { 6614 descendingKeySet.subSet(startKey, true, endKey, false); 6615 fail("shoudl throw IllegalArgumentException"); 6616 } catch (IllegalArgumentException e) { 6617 // Expected 6618 } 6619 6620 try { 6621 descendingKeySet.subSet(startKey, true, endKey, true); 6622 fail("shoudl throw IllegalArgumentException"); 6623 } catch (IllegalArgumentException e) { 6624 // Expected 6625 } 6626 } else { 6627 subSet = descendingKeySet.subSet(startKey, endKey); 6628 subSetIterator = subSet.iterator(); 6629 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6630 assertEquals(new Integer(index).toString(), 6631 subSetIterator.next()); 6632 } 6633 6634 subSet = descendingKeySet.subSet(startKey, false, endKey, 6635 false); 6636 subSetIterator = subSet.iterator(); 6637 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6638 assertEquals(new Integer(index).toString(), 6639 subSetIterator.next()); 6640 } 6641 6642 subSet = descendingKeySet.subSet(startKey, false, endKey, 6643 true); 6644 subSetIterator = subSet.iterator(); 6645 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6646 assertEquals(new Integer(index).toString(), 6647 subSetIterator.next()); 6648 } 6649 6650 subSet = descendingKeySet.subSet(startKey, true, endKey, 6651 false); 6652 subSetIterator = subSet.iterator(); 6653 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6654 assertEquals(new Integer(index).toString(), 6655 subSetIterator.next()); 6656 } 6657 6658 subSet = descendingKeySet.subSet(startKey, true, endKey, 6659 true); 6660 subSetIterator = subSet.iterator(); 6661 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6662 assertEquals(new Integer(index).toString(), 6663 subSetIterator.next()); 6664 } 6665 } 6666 } 6667 } 6668 6669 endKey = new Integer(2).toString(); 6670 keySet = tm.headMap(endKey, true).navigableKeySet(); 6671 descendingKeySet = keySet.descendingSet(); 6672 Iterator iterator = descendingKeySet.iterator(); 6673 6674 startKey = (String) iterator.next(); 6675 iterator.next(); 6676 endKey = (String) iterator.next(); 6677 6678 subSet = descendingKeySet.subSet(startKey, endKey); 6679 assertEquals(2, subSet.size()); 6680 subSetIterator = subSet.iterator(); 6681 assertEquals(startKey, subSetIterator.next()); 6682 subSetIterator.next(); 6683 try { 6684 subSetIterator.next(); 6685 fail("should throw NoSuchElementException"); 6686 } catch (NoSuchElementException e) { 6687 // Expected 6688 } 6689 6690 subSet = descendingKeySet.subSet(startKey, false, endKey, false); 6691 assertEquals(1, subSet.size()); 6692 subSetIterator = subSet.iterator(); 6693 subSetIterator.next(); 6694 try { 6695 subSetIterator.next(); 6696 fail("should throw NoSuchElementException"); 6697 } catch (NoSuchElementException e) { 6698 // Expected 6699 } 6700 6701 subSet = descendingKeySet.subSet(startKey, false, endKey, true); 6702 assertEquals(2, subSet.size()); 6703 subSetIterator = subSet.iterator(); 6704 subSetIterator.next(); 6705 assertEquals(endKey, subSetIterator.next()); 6706 try { 6707 subSetIterator.next(); 6708 fail("should throw NoSuchElementException"); 6709 } catch (NoSuchElementException e) { 6710 // Expected 6711 } 6712 6713 subSet = descendingKeySet.subSet(startKey, true, endKey, false); 6714 assertEquals(2, subSet.size()); 6715 subSetIterator = subSet.iterator(); 6716 assertEquals(startKey, subSetIterator.next()); 6717 subSetIterator.next(); 6718 try { 6719 subSetIterator.next(); 6720 fail("should throw NoSuchElementException"); 6721 } catch (NoSuchElementException e) { 6722 // Expected 6723 } 6724 6725 subSet = descendingKeySet.subSet(startKey, true, endKey, true); 6726 assertEquals(3, subSet.size()); 6727 subSetIterator = subSet.iterator(); 6728 assertEquals(startKey, subSetIterator.next()); 6729 subSetIterator.next(); 6730 assertEquals(endKey, subSetIterator.next()); 6731 try { 6732 subSetIterator.next(); 6733 fail("should throw NoSuchElementException"); 6734 } catch (NoSuchElementException e) { 6735 // Expected 6736 } 6737 6738 // With Comparator 6739 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 6740 .navigableKeySet(); 6741 descendingKeySet = keySet.descendingSet(); 6742 startIterator = descendingKeySet.iterator(); 6743 while (startIterator.hasNext()) { 6744 startKey = (String) startIterator.next(); 6745 endIterator = descendingKeySet.iterator(); 6746 while (endIterator.hasNext()) { 6747 endKey = (String) endIterator.next(); 6748 int startIndex = Integer.valueOf(startKey); 6749 int endIndex = Integer.valueOf(endKey); 6750 if (startIndex < endIndex) { 6751 try { 6752 descendingKeySet.subSet(startKey, endKey); 6753 fail("should throw IllegalArgumentException"); 6754 } catch (IllegalArgumentException e) { 6755 // Expected 6756 } 6757 6758 try { 6759 descendingKeySet.subSet(startKey, false, endKey, false); 6760 fail("shoudl throw IllegalArgumentException"); 6761 } catch (IllegalArgumentException e) { 6762 // Expected 6763 } 6764 6765 try { 6766 descendingKeySet.subSet(startKey, false, endKey, true); 6767 fail("shoudl throw IllegalArgumentException"); 6768 } catch (IllegalArgumentException e) { 6769 // Expected 6770 } 6771 6772 try { 6773 descendingKeySet.subSet(startKey, true, endKey, false); 6774 fail("shoudl throw IllegalArgumentException"); 6775 } catch (IllegalArgumentException e) { 6776 // Expected 6777 } 6778 6779 try { 6780 descendingKeySet.subSet(startKey, true, endKey, true); 6781 fail("shoudl throw IllegalArgumentException"); 6782 } catch (IllegalArgumentException e) { 6783 // Expected 6784 } 6785 } else { 6786 subSet = descendingKeySet.subSet(startKey, endKey); 6787 subSetIterator = subSet.iterator(); 6788 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6789 assertEquals(new Integer(index).toString(), 6790 subSetIterator.next()); 6791 } 6792 6793 subSet = descendingKeySet.subSet(startKey, false, endKey, 6794 false); 6795 subSetIterator = subSet.iterator(); 6796 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6797 assertEquals(new Integer(index).toString(), 6798 subSetIterator.next()); 6799 } 6800 6801 subSet = descendingKeySet.subSet(startKey, false, endKey, 6802 true); 6803 subSetIterator = subSet.iterator(); 6804 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6805 assertEquals(new Integer(index).toString(), 6806 subSetIterator.next()); 6807 } 6808 6809 subSet = descendingKeySet.subSet(startKey, true, endKey, 6810 false); 6811 subSetIterator = subSet.iterator(); 6812 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6813 assertEquals(new Integer(index).toString(), 6814 subSetIterator.next()); 6815 } 6816 6817 subSet = descendingKeySet.subSet(startKey, true, endKey, 6818 true); 6819 subSetIterator = subSet.iterator(); 6820 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6821 assertEquals(new Integer(index).toString(), 6822 subSetIterator.next()); 6823 } 6824 } 6825 } 6826 } 6827 } 6828 6829 public void test_DescendingSubMapKeySet_descendingSet() { 6830 NavigableSet keySet, descendingSet, descendingDescendingSet; 6831 int value; 6832 Iterator iterator; 6833 6834 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 6835 descendingSet = keySet.descendingSet(); 6836 descendingDescendingSet = descendingSet.descendingSet(); 6837 iterator = descendingDescendingSet.iterator(); 6838 assertTrue(iterator.hasNext()); 6839 for (value = 101; iterator.hasNext(); value++) { 6840 assertEquals(new Integer(value).toString(), iterator.next()); 6841 } 6842 assertEquals(109, value); 6843 try { 6844 iterator.next(); 6845 fail("should throw NoSuchElementException"); 6846 } catch (NoSuchElementException e) { 6847 // Expected 6848 } 6849 6850 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 6851 descendingSet = keySet.descendingSet(); 6852 descendingDescendingSet = descendingSet.descendingSet(); 6853 iterator = descendingDescendingSet.iterator(); 6854 assertTrue(iterator.hasNext()); 6855 for (value = 101; iterator.hasNext(); value++) { 6856 assertEquals(new Integer(value).toString(), iterator.next()); 6857 } 6858 assertEquals(110, value); 6859 try { 6860 iterator.next(); 6861 fail("should throw NoSuchElementException"); 6862 } catch (NoSuchElementException e) { 6863 // Expected 6864 } 6865 6866 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 6867 descendingSet = keySet.descendingSet(); 6868 descendingDescendingSet = descendingSet.descendingSet(); 6869 iterator = descendingDescendingSet.iterator(); 6870 assertTrue(iterator.hasNext()); 6871 for (value = 100; iterator.hasNext(); value++) { 6872 assertEquals(new Integer(value).toString(), iterator.next()); 6873 } 6874 assertEquals(109, value); 6875 try { 6876 iterator.next(); 6877 fail("should throw NoSuchElementException"); 6878 } catch (NoSuchElementException e) { 6879 // Expected 6880 } 6881 6882 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 6883 descendingSet = keySet.descendingSet(); 6884 descendingDescendingSet = descendingSet.descendingSet(); 6885 iterator = descendingDescendingSet.iterator(); 6886 assertTrue(iterator.hasNext()); 6887 for (value = 100; iterator.hasNext(); value++) { 6888 assertEquals(new Integer(value).toString(), iterator.next()); 6889 } 6890 assertEquals(110, value); 6891 try { 6892 iterator.next(); 6893 fail("should throw NoSuchElementException"); 6894 } catch (NoSuchElementException e) { 6895 // Expected 6896 } 6897 6898 String endKey = new Integer(2).toString(); 6899 keySet = tm.headMap(endKey, true).navigableKeySet(); 6900 descendingSet = keySet.descendingSet(); 6901 descendingDescendingSet = descendingSet.descendingSet(); 6902 assertEquals(keySet, descendingDescendingSet); 6903 6904 String startKey = new Integer(2).toString(); 6905 keySet = tm.tailMap(startKey, true).navigableKeySet(); 6906 descendingSet = keySet.descendingSet(); 6907 descendingDescendingSet = descendingSet.descendingSet(); 6908 assertEquals(keySet, descendingDescendingSet); 6909 } 6910 6911 public void test_DescendingSubMapKeySet_descendingIterator() { 6912 NavigableSet keySet, descendingSet; 6913 int value; 6914 Iterator iterator, descendingIterator; 6915 6916 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 6917 descendingSet = keySet.descendingSet(); 6918 descendingIterator = descendingSet.descendingIterator(); 6919 assertTrue(descendingIterator.hasNext()); 6920 for (value = 101; descendingIterator.hasNext(); value++) { 6921 assertEquals(new Integer(value).toString(), descendingIterator 6922 .next()); 6923 } 6924 assertEquals(109, value); 6925 try { 6926 descendingIterator.next(); 6927 fail("should throw NoSuchElementException"); 6928 } catch (NoSuchElementException e) { 6929 // Expected 6930 } 6931 6932 descendingSet = descendingSet 6933 .headSet(new Integer(105).toString(), true); 6934 descendingIterator = descendingSet.descendingIterator(); 6935 for (value = 105; descendingIterator.hasNext(); value++) { 6936 assertEquals(new Integer(value).toString(), descendingIterator 6937 .next()); 6938 } 6939 6940 descendingSet = keySet.descendingSet(); 6941 descendingSet = descendingSet 6942 .tailSet(new Integer(105).toString(), true); 6943 descendingIterator = descendingSet.descendingIterator(); 6944 for (value = 101; descendingIterator.hasNext(); value++) { 6945 assertEquals(new Integer(value).toString(), descendingIterator 6946 .next()); 6947 } 6948 6949 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 6950 descendingSet = keySet.descendingSet(); 6951 descendingIterator = descendingSet.descendingIterator(); 6952 assertTrue(descendingIterator.hasNext()); 6953 for (value = 101; descendingIterator.hasNext(); value++) { 6954 assertEquals(new Integer(value).toString(), descendingIterator 6955 .next()); 6956 } 6957 assertEquals(110, value); 6958 try { 6959 descendingIterator.next(); 6960 fail("should throw NoSuchElementException"); 6961 } catch (NoSuchElementException e) { 6962 // Expected 6963 } 6964 6965 descendingSet = descendingSet 6966 .headSet(new Integer(105).toString(), true); 6967 descendingIterator = descendingSet.descendingIterator(); 6968 for (value = 105; descendingIterator.hasNext(); value++) { 6969 assertEquals(new Integer(value).toString(), descendingIterator 6970 .next()); 6971 } 6972 6973 descendingSet = keySet.descendingSet(); 6974 descendingSet = descendingSet 6975 .tailSet(new Integer(105).toString(), true); 6976 descendingIterator = descendingSet.descendingIterator(); 6977 for (value = 101; descendingIterator.hasNext(); value++) { 6978 assertEquals(new Integer(value).toString(), descendingIterator 6979 .next()); 6980 } 6981 6982 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 6983 descendingSet = keySet.descendingSet(); 6984 descendingIterator = descendingSet.descendingIterator(); 6985 assertTrue(descendingIterator.hasNext()); 6986 for (value = 100; descendingIterator.hasNext(); value++) { 6987 assertEquals(new Integer(value).toString(), descendingIterator 6988 .next()); 6989 } 6990 assertEquals(109, value); 6991 try { 6992 descendingIterator.next(); 6993 fail("should throw NoSuchElementException"); 6994 } catch (NoSuchElementException e) { 6995 // Expected 6996 } 6997 6998 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 6999 descendingSet = keySet.descendingSet(); 7000 descendingIterator = descendingSet.descendingIterator(); 7001 assertTrue(descendingIterator.hasNext()); 7002 for (value = 100; descendingIterator.hasNext(); value++) { 7003 assertEquals(new Integer(value).toString(), descendingIterator 7004 .next()); 7005 } 7006 assertEquals(110, value); 7007 try { 7008 descendingIterator.next(); 7009 fail("should throw NoSuchElementException"); 7010 } catch (NoSuchElementException e) { 7011 // Expected 7012 } 7013 7014 String endKey = new Integer(2).toString(); 7015 keySet = tm.headMap(endKey, true).navigableKeySet(); 7016 iterator = keySet.iterator(); 7017 7018 descendingSet = keySet.descendingSet(); 7019 descendingIterator = descendingSet.descendingIterator(); 7020 7021 while (iterator.hasNext()) { 7022 assertEquals(iterator.next(), descendingIterator.next()); 7023 } 7024 7025 String startKey = new Integer(2).toString(); 7026 keySet = tm.tailMap(startKey, true).navigableKeySet(); 7027 iterator = keySet.iterator(); 7028 descendingSet = keySet.descendingSet(); 7029 descendingIterator = descendingSet.descendingIterator(); 7030 7031 while (iterator.hasNext()) { 7032 assertEquals(iterator.next(), descendingIterator.next()); 7033 } 7034 } 7035 7036 public void test_DescendingSubMapKeySet_lower() { 7037 NavigableSet keySet, descendingKeySet; 7038 Iterator iterator; 7039 String key, lowerKey; 7040 int value, lowerValue; 7041 7042 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7043 descendingKeySet = keySet.descendingSet(); 7044 iterator = descendingKeySet.iterator(); 7045 while (iterator.hasNext()) { 7046 key = (String) iterator.next(); 7047 value = Integer.valueOf(key); 7048 lowerKey = (String) descendingKeySet.lower(key); 7049 if (value < 108) { 7050 lowerValue = Integer.valueOf(lowerKey); 7051 assertEquals(value + 1, lowerValue); 7052 } else { 7053 assertNull(lowerKey); 7054 } 7055 } 7056 7057 key = new Integer(0).toString(); 7058 lowerKey = (String) descendingKeySet.lower(key); 7059 assertEquals(101, Integer.parseInt(lowerKey)); 7060 7061 key = new Integer(2).toString(); 7062 lowerKey = (String) descendingKeySet.lower(key); 7063 assertNull(lowerKey); 7064 7065 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7066 descendingKeySet = keySet.descendingSet(); 7067 iterator = descendingKeySet.iterator(); 7068 while (iterator.hasNext()) { 7069 key = (String) iterator.next(); 7070 value = Integer.valueOf(key); 7071 lowerKey = (String) descendingKeySet.lower(key); 7072 if (value < 109) { 7073 lowerValue = Integer.valueOf(lowerKey); 7074 assertEquals(value + 1, lowerValue); 7075 } else { 7076 assertNull(lowerKey); 7077 } 7078 } 7079 7080 key = new Integer(0).toString(); 7081 lowerKey = (String) descendingKeySet.lower(key); 7082 assertEquals(101, Integer.parseInt(lowerKey)); 7083 7084 key = new Integer(2).toString(); 7085 lowerKey = (String) descendingKeySet.lower(key); 7086 assertNull(lowerKey); 7087 7088 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7089 descendingKeySet = keySet.descendingSet(); 7090 iterator = descendingKeySet.iterator(); 7091 while (iterator.hasNext()) { 7092 key = (String) iterator.next(); 7093 value = Integer.valueOf(key); 7094 lowerKey = (String) descendingKeySet.lower(key); 7095 if (value < 108) { 7096 lowerValue = Integer.valueOf(lowerKey); 7097 assertEquals(value + 1, lowerValue); 7098 } else { 7099 assertNull(lowerKey); 7100 } 7101 } 7102 7103 key = new Integer(0).toString(); 7104 lowerKey = (String) descendingKeySet.lower(key); 7105 assertEquals(100, Integer.parseInt(lowerKey)); 7106 7107 key = new Integer(2).toString(); 7108 lowerKey = (String) descendingKeySet.lower(key); 7109 assertNull(lowerKey); 7110 7111 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7112 descendingKeySet = keySet.descendingSet(); 7113 iterator = descendingKeySet.iterator(); 7114 while (iterator.hasNext()) { 7115 key = (String) iterator.next(); 7116 value = Integer.valueOf(key); 7117 lowerKey = (String) descendingKeySet.lower(key); 7118 if (value < 109) { 7119 lowerValue = Integer.valueOf(lowerKey); 7120 assertEquals(value + 1, lowerValue); 7121 } else { 7122 assertNull(lowerKey); 7123 } 7124 } 7125 7126 key = new Integer(0).toString(); 7127 lowerKey = (String) descendingKeySet.lower(key); 7128 assertEquals(100, Integer.parseInt(lowerKey)); 7129 7130 key = new Integer(2).toString(); 7131 lowerKey = (String) descendingKeySet.lower(key); 7132 assertNull(lowerKey); 7133 7134 key = new Integer(2).toString(); 7135 keySet = tm.headMap(key, true).navigableKeySet(); 7136 descendingKeySet = keySet.descendingSet(); 7137 iterator = descendingKeySet.iterator(); 7138 iterator.next(); 7139 iterator.next(); 7140 key = (String) iterator.next(); 7141 lowerKey = (String) descendingKeySet.lower(key); 7142 assertEquals(new Integer(199).toString(), lowerKey); 7143 try { 7144 descendingKeySet.lower(null); 7145 fail("should throw NPE"); 7146 } catch (NullPointerException e) { 7147 // Expected 7148 } 7149 7150 key = new Integer(0).toString(); 7151 String endKey = key; 7152 7153 keySet = tm.headMap(endKey, true).navigableKeySet(); 7154 descendingKeySet = keySet.descendingSet(); 7155 assertNull(descendingKeySet.lower(endKey)); 7156 7157 key = new Integer(0).toString(); 7158 keySet = tm.headMap(endKey, false).navigableKeySet(); 7159 descendingKeySet = keySet.descendingSet(); 7160 assertNull(descendingKeySet.lower(endKey)); 7161 7162 endKey = new Integer(999).toString(); 7163 keySet = tm.headMap(endKey, true).navigableKeySet(); 7164 descendingKeySet = keySet.descendingSet(); 7165 assertNull(descendingKeySet.lower(endKey)); 7166 assertEquals(new Integer(1).toString(), descendingKeySet.lower(key)); 7167 7168 endKey = new Integer(999).toString(); 7169 keySet = tm.headMap(endKey, false).navigableKeySet(); 7170 descendingKeySet = keySet.descendingSet(); 7171 assertNull(descendingKeySet.lower(endKey)); 7172 assertEquals(new Integer(1).toString(), descendingKeySet.lower(key)); 7173 7174 // With Comparator 7175 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7176 .navigableKeySet(); 7177 descendingKeySet = keySet.descendingSet(); 7178 iterator = descendingKeySet.iterator(); 7179 while (iterator.hasNext()) { 7180 key = (String) iterator.next(); 7181 value = Integer.valueOf(key); 7182 lowerKey = (String) descendingKeySet.lower(key); 7183 if (value < 108) { 7184 lowerValue = Integer.valueOf(lowerKey); 7185 assertEquals(value + 1, lowerValue); 7186 } else { 7187 assertNull(lowerKey); 7188 } 7189 } 7190 7191 key = new Integer(0).toString(); 7192 lowerKey = (String) descendingKeySet.lower(key); 7193 assertEquals(101, Integer.parseInt(lowerKey)); 7194 7195 key = new Integer(2).toString(); 7196 lowerKey = (String) descendingKeySet.lower(key); 7197 assertNull(lowerKey); 7198 7199 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7200 .navigableKeySet(); 7201 descendingKeySet = keySet.descendingSet(); 7202 iterator = descendingKeySet.iterator(); 7203 while (iterator.hasNext()) { 7204 key = (String) iterator.next(); 7205 value = Integer.valueOf(key); 7206 lowerKey = (String) descendingKeySet.lower(key); 7207 if (value < 109) { 7208 lowerValue = Integer.valueOf(lowerKey); 7209 assertEquals(value + 1, lowerValue); 7210 } else { 7211 assertNull(lowerKey); 7212 } 7213 } 7214 7215 key = new Integer(0).toString(); 7216 lowerKey = (String) descendingKeySet.lower(key); 7217 assertEquals(101, Integer.parseInt(lowerKey)); 7218 7219 key = new Integer(2).toString(); 7220 lowerKey = (String) descendingKeySet.lower(key); 7221 assertNull(lowerKey); 7222 7223 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7224 .navigableKeySet(); 7225 descendingKeySet = keySet.descendingSet(); 7226 iterator = descendingKeySet.iterator(); 7227 while (iterator.hasNext()) { 7228 key = (String) iterator.next(); 7229 value = Integer.valueOf(key); 7230 lowerKey = (String) descendingKeySet.lower(key); 7231 if (value < 108) { 7232 lowerValue = Integer.valueOf(lowerKey); 7233 assertEquals(value + 1, lowerValue); 7234 } else { 7235 assertNull(lowerKey); 7236 } 7237 } 7238 7239 key = new Integer(0).toString(); 7240 lowerKey = (String) descendingKeySet.lower(key); 7241 assertEquals(100, Integer.parseInt(lowerKey)); 7242 7243 key = new Integer(2).toString(); 7244 lowerKey = (String) descendingKeySet.lower(key); 7245 assertNull(lowerKey); 7246 7247 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 7248 .navigableKeySet(); 7249 descendingKeySet = keySet.descendingSet(); 7250 iterator = descendingKeySet.iterator(); 7251 while (iterator.hasNext()) { 7252 key = (String) iterator.next(); 7253 value = Integer.valueOf(key); 7254 lowerKey = (String) descendingKeySet.lower(key); 7255 if (value < 109) { 7256 lowerValue = Integer.valueOf(lowerKey); 7257 assertEquals(value + 1, lowerValue); 7258 } else { 7259 assertNull(lowerKey); 7260 } 7261 } 7262 } 7263 7264 public void test_DescendingSubMapKeySet_higher() { 7265 NavigableSet keySet, descendingKeySet; 7266 Iterator iterator; 7267 String key, higherKey; 7268 int value, higherValue; 7269 7270 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7271 descendingKeySet = keySet.descendingSet(); 7272 iterator = descendingKeySet.iterator(); 7273 while (iterator.hasNext()) { 7274 key = (String) iterator.next(); 7275 value = Integer.valueOf(key); 7276 higherKey = (String) descendingKeySet.higher(key); 7277 if (value > 101) { 7278 higherValue = Integer.valueOf(higherKey); 7279 assertEquals(value - 1, higherValue); 7280 } else { 7281 assertNull(higherKey); 7282 } 7283 } 7284 7285 key = new Integer(99999).toString(); 7286 higherKey = (String) descendingKeySet.higher(key); 7287 assertEquals("108", higherKey); 7288 7289 key = new Integer(-1).toString(); 7290 higherKey = (String) descendingKeySet.higher(key); 7291 assertNull(higherKey); 7292 7293 key = new Integer(100).toString(); 7294 higherKey = (String) descendingKeySet.higher(key); 7295 assertNull(higherKey); 7296 7297 key = new Integer(0).toString(); 7298 higherKey = (String) descendingKeySet.higher(key); 7299 assertNull(higherKey); 7300 7301 key = new Integer(2).toString(); 7302 higherKey = (String) descendingKeySet.higher(key); 7303 assertEquals(108, Integer.parseInt(higherKey)); 7304 7305 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7306 descendingKeySet = keySet.descendingSet(); 7307 iterator = descendingKeySet.iterator(); 7308 while (iterator.hasNext()) { 7309 key = (String) iterator.next(); 7310 value = Integer.valueOf(key); 7311 higherKey = (String) descendingKeySet.higher(key); 7312 if (value > 101) { 7313 higherValue = Integer.valueOf(higherKey); 7314 assertEquals(value - 1, higherValue); 7315 } else { 7316 assertNull(higherKey); 7317 } 7318 } 7319 7320 key = new Integer(99999).toString(); 7321 higherKey = (String) descendingKeySet.higher(key); 7322 assertEquals("109", higherKey); 7323 7324 key = new Integer(-1).toString(); 7325 higherKey = (String) descendingKeySet.higher(key); 7326 assertNull(higherKey); 7327 7328 key = new Integer(100).toString(); 7329 higherKey = (String) descendingKeySet.higher(key); 7330 assertNull(higherKey); 7331 7332 key = new Integer(2).toString(); 7333 higherKey = (String) descendingKeySet.higher(key); 7334 assertEquals(109, Integer.parseInt(higherKey)); 7335 7336 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7337 descendingKeySet = keySet.descendingSet(); 7338 iterator = descendingKeySet.iterator(); 7339 while (iterator.hasNext()) { 7340 key = (String) iterator.next(); 7341 value = Integer.valueOf(key); 7342 higherKey = (String) descendingKeySet.higher(key); 7343 if (value > 100) { 7344 higherValue = Integer.valueOf(higherKey); 7345 assertEquals(value - 1, higherValue); 7346 } else { 7347 assertNull(higherKey); 7348 } 7349 } 7350 7351 key = new Integer(99999).toString(); 7352 higherKey = (String) descendingKeySet.higher(key); 7353 assertEquals("108", higherKey); 7354 7355 key = new Integer(-1).toString(); 7356 higherKey = (String) descendingKeySet.higher(key); 7357 assertNull(higherKey); 7358 7359 key = new Integer(100).toString(); 7360 higherKey = (String) descendingKeySet.higher(key); 7361 assertNull(higherKey); 7362 7363 key = new Integer(2).toString(); 7364 higherKey = (String) descendingKeySet.higher(key); 7365 assertEquals(108, Integer.parseInt(higherKey)); 7366 7367 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7368 descendingKeySet = keySet.descendingSet(); 7369 iterator = descendingKeySet.iterator(); 7370 while (iterator.hasNext()) { 7371 key = (String) iterator.next(); 7372 value = Integer.valueOf(key); 7373 higherKey = (String) descendingKeySet.higher(key); 7374 if (value > 100) { 7375 higherValue = Integer.valueOf(higherKey); 7376 assertEquals(value - 1, higherValue); 7377 } else { 7378 assertNull(higherKey); 7379 } 7380 } 7381 7382 key = new Integer(99999).toString(); 7383 higherKey = (String) descendingKeySet.higher(key); 7384 assertEquals("109", higherKey); 7385 7386 key = new Integer(-1).toString(); 7387 higherKey = (String) descendingKeySet.higher(key); 7388 assertNull(higherKey); 7389 7390 key = new Integer(100).toString(); 7391 higherKey = (String) descendingKeySet.higher(key); 7392 assertNull(higherKey); 7393 7394 key = new Integer(2).toString(); 7395 higherKey = (String) descendingKeySet.higher(key); 7396 assertEquals(109, Integer.parseInt(higherKey)); 7397 7398 key = new Integer(2).toString(); 7399 keySet = tm.headMap(key, true).navigableKeySet(); 7400 descendingKeySet = keySet.descendingSet(); 7401 iterator = descendingKeySet.iterator(); 7402 key = (String) iterator.next(); 7403 higherKey = (String) descendingKeySet.higher(key); 7404 assertEquals(new Integer(199).toString(), higherKey); 7405 try { 7406 descendingKeySet.higher(null); 7407 fail("should throw NPE"); 7408 } catch (NullPointerException e) { 7409 // Expected 7410 } 7411 7412 key = new Integer(0).toString(); 7413 String endKey = key; 7414 7415 keySet = tm.headMap(endKey, true).navigableKeySet(); 7416 descendingKeySet = keySet.descendingSet(); 7417 assertNull(descendingKeySet.higher(endKey)); 7418 7419 key = new Integer(0).toString(); 7420 keySet = tm.headMap(endKey, false).navigableKeySet(); 7421 descendingKeySet = keySet.descendingSet(); 7422 assertNull(descendingKeySet.higher(endKey)); 7423 7424 endKey = new Integer(999).toString(); 7425 keySet = tm.headMap(endKey, true).navigableKeySet(); 7426 descendingKeySet = keySet.descendingSet(); 7427 assertEquals(new Integer(998).toString(), descendingKeySet 7428 .higher(endKey)); 7429 assertNull(descendingKeySet.higher(key)); 7430 7431 endKey = new Integer(999).toString(); 7432 keySet = tm.headMap(endKey, false).navigableKeySet(); 7433 descendingKeySet = keySet.descendingSet(); 7434 assertEquals(new Integer(998).toString(), descendingKeySet 7435 .higher(endKey)); 7436 assertNull(descendingKeySet.higher(key)); 7437 7438 // With Comparator 7439 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7440 .navigableKeySet(); 7441 descendingKeySet = keySet.descendingSet(); 7442 iterator = descendingKeySet.iterator(); 7443 while (iterator.hasNext()) { 7444 key = (String) iterator.next(); 7445 value = Integer.valueOf(key); 7446 higherKey = (String) descendingKeySet.higher(key); 7447 if (value > 101) { 7448 higherValue = Integer.valueOf(higherKey); 7449 assertEquals(value - 1, higherValue); 7450 } else { 7451 assertNull(higherKey); 7452 } 7453 } 7454 7455 key = new Integer(99999).toString(); 7456 higherKey = (String) descendingKeySet.higher(key); 7457 assertEquals("108", higherKey); 7458 7459 key = new Integer(-1).toString(); 7460 higherKey = (String) descendingKeySet.higher(key); 7461 assertNull(higherKey); 7462 7463 key = new Integer(100).toString(); 7464 higherKey = (String) descendingKeySet.higher(key); 7465 assertNull(higherKey); 7466 7467 key = new Integer(0).toString(); 7468 higherKey = (String) descendingKeySet.higher(key); 7469 assertNull(higherKey); 7470 7471 key = new Integer(2).toString(); 7472 higherKey = (String) descendingKeySet.higher(key); 7473 assertEquals(108, Integer.parseInt(higherKey)); 7474 7475 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7476 .navigableKeySet(); 7477 descendingKeySet = keySet.descendingSet(); 7478 iterator = descendingKeySet.iterator(); 7479 while (iterator.hasNext()) { 7480 key = (String) iterator.next(); 7481 value = Integer.valueOf(key); 7482 higherKey = (String) descendingKeySet.higher(key); 7483 if (value > 101) { 7484 higherValue = Integer.valueOf(higherKey); 7485 assertEquals(value - 1, higherValue); 7486 } else { 7487 assertNull(higherKey); 7488 } 7489 } 7490 7491 key = new Integer(99999).toString(); 7492 higherKey = (String) descendingKeySet.higher(key); 7493 assertEquals("109", higherKey); 7494 7495 key = new Integer(-1).toString(); 7496 higherKey = (String) descendingKeySet.higher(key); 7497 assertNull(higherKey); 7498 7499 key = new Integer(100).toString(); 7500 higherKey = (String) descendingKeySet.higher(key); 7501 assertNull(higherKey); 7502 7503 key = new Integer(2).toString(); 7504 higherKey = (String) descendingKeySet.higher(key); 7505 assertEquals(109, Integer.parseInt(higherKey)); 7506 7507 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7508 .navigableKeySet(); 7509 descendingKeySet = keySet.descendingSet(); 7510 iterator = descendingKeySet.iterator(); 7511 while (iterator.hasNext()) { 7512 key = (String) iterator.next(); 7513 value = Integer.valueOf(key); 7514 higherKey = (String) descendingKeySet.higher(key); 7515 if (value > 100) { 7516 higherValue = Integer.valueOf(higherKey); 7517 assertEquals(value - 1, higherValue); 7518 } else { 7519 assertNull(higherKey); 7520 } 7521 } 7522 7523 key = new Integer(99999).toString(); 7524 higherKey = (String) descendingKeySet.higher(key); 7525 assertEquals("108", higherKey); 7526 7527 key = new Integer(-1).toString(); 7528 higherKey = (String) descendingKeySet.higher(key); 7529 assertNull(higherKey); 7530 7531 key = new Integer(100).toString(); 7532 higherKey = (String) descendingKeySet.higher(key); 7533 assertNull(higherKey); 7534 7535 key = new Integer(2).toString(); 7536 higherKey = (String) descendingKeySet.higher(key); 7537 assertEquals(108, Integer.parseInt(higherKey)); 7538 7539 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 7540 .navigableKeySet(); 7541 descendingKeySet = keySet.descendingSet(); 7542 iterator = descendingKeySet.iterator(); 7543 while (iterator.hasNext()) { 7544 key = (String) iterator.next(); 7545 value = Integer.valueOf(key); 7546 higherKey = (String) descendingKeySet.higher(key); 7547 if (value > 100) { 7548 higherValue = Integer.valueOf(higherKey); 7549 assertEquals(value - 1, higherValue); 7550 } else { 7551 assertNull(higherKey); 7552 } 7553 } 7554 7555 key = new Integer(99999).toString(); 7556 higherKey = (String) descendingKeySet.higher(key); 7557 assertEquals("109", higherKey); 7558 7559 key = new Integer(-1).toString(); 7560 higherKey = (String) descendingKeySet.higher(key); 7561 assertNull(higherKey); 7562 7563 key = new Integer(100).toString(); 7564 higherKey = (String) descendingKeySet.higher(key); 7565 assertNull(higherKey); 7566 7567 key = new Integer(2).toString(); 7568 higherKey = (String) descendingKeySet.higher(key); 7569 assertEquals(109, Integer.parseInt(higherKey)); 7570 7571 key = new Integer(2).toString(); 7572 keySet = tm.headMap(key, true).navigableKeySet(); 7573 descendingKeySet = keySet.descendingSet(); 7574 iterator = descendingKeySet.iterator(); 7575 key = (String) iterator.next(); 7576 higherKey = (String) descendingKeySet.higher(key); 7577 assertEquals(new Integer(199).toString(), higherKey); 7578 try { 7579 descendingKeySet.higher(null); 7580 fail("should throw NPE"); 7581 } catch (NullPointerException e) { 7582 // Expected 7583 } 7584 7585 key = new Integer(0).toString(); 7586 endKey = key; 7587 7588 keySet = tm.headMap(endKey, true).navigableKeySet(); 7589 descendingKeySet = keySet.descendingSet(); 7590 assertNull(descendingKeySet.higher(endKey)); 7591 7592 key = new Integer(0).toString(); 7593 keySet = tm.headMap(endKey, false).navigableKeySet(); 7594 descendingKeySet = keySet.descendingSet(); 7595 assertNull(descendingKeySet.higher(endKey)); 7596 7597 endKey = new Integer(999).toString(); 7598 keySet = tm.headMap(endKey, true).navigableKeySet(); 7599 descendingKeySet = keySet.descendingSet(); 7600 assertEquals(new Integer(998).toString(), descendingKeySet 7601 .higher(endKey)); 7602 assertNull(descendingKeySet.higher(key)); 7603 7604 endKey = new Integer(999).toString(); 7605 keySet = tm.headMap(endKey, false).navigableKeySet(); 7606 descendingKeySet = keySet.descendingSet(); 7607 assertEquals(new Integer(998).toString(), descendingKeySet 7608 .higher(endKey)); 7609 assertNull(descendingKeySet.higher(key)); 7610 } 7611 7612 public void test_DescendingSubMapKeySet_ceiling() { 7613 NavigableSet keySet, descendingKeySet; 7614 String[] keyArray; 7615 String key, ceilingKey; 7616 7617 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7618 descendingKeySet = keySet.descendingSet(); 7619 keyArray = (String[]) descendingKeySet 7620 .toArray(new String[descendingKeySet.size()]); 7621 for (int i = 0, j = 108; i < keyArray.length; i++) { 7622 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7623 assertEquals(new Integer(j - i).toString(), ceilingKey); 7624 } 7625 7626 key = new Integer(2).toString(); 7627 ceilingKey = (String) descendingKeySet.ceiling(key); 7628 assertEquals(108, Integer.parseInt(ceilingKey)); 7629 7630 key = new Integer(0).toString(); 7631 ceilingKey = (String) descendingKeySet.ceiling(key); 7632 assertNull(ceilingKey); 7633 7634 key = new Integer(-1).toString(); 7635 ceilingKey = (String) descendingKeySet.ceiling(key); 7636 assertNull(ceilingKey); 7637 7638 key = new Integer(99999).toString(); 7639 ceilingKey = (String) descendingKeySet.ceiling(key); 7640 assertEquals(108, Integer.parseInt(ceilingKey)); 7641 7642 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7643 descendingKeySet = keySet.descendingSet(); 7644 keyArray = (String[]) descendingKeySet 7645 .toArray(new String[descendingKeySet.size()]); 7646 for (int i = 0, j = 109; i < keyArray.length; i++) { 7647 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7648 assertEquals(new Integer(j - i).toString(), ceilingKey); 7649 } 7650 7651 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7652 descendingKeySet = keySet.descendingSet(); 7653 keyArray = (String[]) descendingKeySet 7654 .toArray(new String[descendingKeySet.size()]); 7655 for (int i = 0, j = 108; i < keyArray.length; i++) { 7656 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7657 assertEquals(new Integer(j - i).toString(), ceilingKey); 7658 } 7659 7660 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7661 descendingKeySet = keySet.descendingSet(); 7662 keyArray = (String[]) descendingKeySet 7663 .toArray(new String[descendingKeySet.size()]); 7664 for (int i = 0, j = 109; i < keyArray.length; i++) { 7665 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7666 assertEquals(new Integer(j - i).toString(), ceilingKey); 7667 } 7668 7669 key = new Integer(2).toString(); 7670 keySet = tm.headMap(key, true).navigableKeySet(); 7671 descendingKeySet = keySet.descendingSet(); 7672 Iterator iterator = descendingKeySet.iterator(); 7673 assertEquals(key, descendingKeySet.ceiling(iterator.next())); 7674 try { 7675 descendingKeySet.ceiling(null); 7676 fail("should throw NPE"); 7677 } catch (NullPointerException e) { 7678 // Expected 7679 } 7680 7681 key = new Integer(0).toString(); 7682 String endKey = key; 7683 7684 keySet = tm.headMap(endKey, true).navigableKeySet(); 7685 descendingKeySet = keySet.descendingSet(); 7686 assertEquals(key, descendingKeySet.ceiling(endKey)); 7687 7688 key = new Integer(0).toString(); 7689 keySet = tm.headMap(endKey, false).navigableKeySet(); 7690 descendingKeySet = keySet.descendingSet(); 7691 assertNull(descendingKeySet.ceiling(endKey)); 7692 7693 endKey = new Integer(999).toString(); 7694 keySet = tm.headMap(endKey, true).navigableKeySet(); 7695 descendingKeySet = keySet.descendingSet(); 7696 assertEquals(new Integer(999).toString(), descendingKeySet 7697 .ceiling(endKey)); 7698 assertEquals(key, descendingKeySet.ceiling(key)); 7699 7700 endKey = new Integer(999).toString(); 7701 keySet = tm.headMap(endKey, false).navigableKeySet(); 7702 descendingKeySet = keySet.descendingSet(); 7703 assertEquals(new Integer(998).toString(), descendingKeySet 7704 .ceiling(endKey)); 7705 assertEquals(key, descendingKeySet.ceiling(key)); 7706 7707 // With Comparator 7708 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7709 .navigableKeySet(); 7710 descendingKeySet = keySet.descendingSet(); 7711 keyArray = (String[]) descendingKeySet 7712 .toArray(new String[descendingKeySet.size()]); 7713 for (int i = 0, j = 108; i < keyArray.length; i++) { 7714 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7715 assertEquals(new Integer(j - i).toString(), ceilingKey); 7716 } 7717 7718 key = new Integer(2).toString(); 7719 ceilingKey = (String) descendingKeySet.ceiling(key); 7720 assertEquals(108, Integer.parseInt(ceilingKey)); 7721 7722 key = new Integer(0).toString(); 7723 ceilingKey = (String) descendingKeySet.ceiling(key); 7724 assertNull(ceilingKey); 7725 7726 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7727 .navigableKeySet(); 7728 descendingKeySet = keySet.descendingSet(); 7729 keyArray = (String[]) descendingKeySet 7730 .toArray(new String[descendingKeySet.size()]); 7731 for (int i = 0, j = 109; i < keyArray.length; i++) { 7732 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7733 assertEquals(new Integer(j - i).toString(), ceilingKey); 7734 } 7735 7736 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7737 .navigableKeySet(); 7738 descendingKeySet = keySet.descendingSet(); 7739 keyArray = (String[]) descendingKeySet 7740 .toArray(new String[descendingKeySet.size()]); 7741 for (int i = 0, j = 108; i < keyArray.length; i++) { 7742 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7743 assertEquals(new Integer(j - i).toString(), ceilingKey); 7744 } 7745 7746 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 7747 .navigableKeySet(); 7748 descendingKeySet = keySet.descendingSet(); 7749 keyArray = (String[]) descendingKeySet 7750 .toArray(new String[descendingKeySet.size()]); 7751 for (int i = 0, j = 109; i < keyArray.length; i++) { 7752 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7753 assertEquals(new Integer(j - i).toString(), ceilingKey); 7754 } 7755 } 7756 7757 public void test_DescendingSubMapKeySet_floor() { 7758 NavigableSet keySet, descendingKeySet; 7759 String[] keyArray; 7760 String floorKey; 7761 7762 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7763 descendingKeySet = keySet.descendingSet(); 7764 keyArray = (String[]) descendingKeySet 7765 .toArray(new String[descendingKeySet.size()]); 7766 for (int i = 0, j = 108; i < keyArray.length; i++) { 7767 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7768 assertEquals(new Integer(j - i).toString(), floorKey); 7769 } 7770 7771 String key = new Integer(0).toString(); 7772 floorKey = (String) descendingKeySet.floor(key); 7773 assertEquals(101, Integer.parseInt(floorKey)); 7774 7775 key = new Integer(2).toString(); 7776 floorKey = (String) descendingKeySet.floor(key); 7777 assertNull(floorKey); 7778 7779 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7780 descendingKeySet = keySet.descendingSet(); 7781 keyArray = (String[]) descendingKeySet 7782 .toArray(new String[descendingKeySet.size()]); 7783 for (int i = 0, j = 109; i < keyArray.length; i++) { 7784 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7785 assertEquals(new Integer(j - i).toString(), floorKey); 7786 } 7787 7788 key = new Integer(0).toString(); 7789 floorKey = (String) descendingKeySet.floor(key); 7790 assertEquals(101, Integer.parseInt(floorKey)); 7791 7792 key = new Integer(2).toString(); 7793 floorKey = (String) descendingKeySet.floor(key); 7794 assertNull(floorKey); 7795 7796 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7797 descendingKeySet = keySet.descendingSet(); 7798 keyArray = (String[]) descendingKeySet 7799 .toArray(new String[descendingKeySet.size()]); 7800 for (int i = 0, j = 108; i < keyArray.length; i++) { 7801 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7802 assertEquals(new Integer(j - i).toString(), floorKey); 7803 } 7804 7805 key = new Integer(0).toString(); 7806 floorKey = (String) descendingKeySet.floor(key); 7807 assertEquals(100, Integer.parseInt(floorKey)); 7808 7809 key = new Integer(2).toString(); 7810 floorKey = (String) descendingKeySet.floor(key); 7811 assertNull(floorKey); 7812 7813 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7814 descendingKeySet = keySet.descendingSet(); 7815 keyArray = (String[]) descendingKeySet 7816 .toArray(new String[descendingKeySet.size()]); 7817 for (int i = 0, j = 109; i < keyArray.length; i++) { 7818 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7819 assertEquals(new Integer(j - i).toString(), floorKey); 7820 } 7821 7822 key = new Integer(0).toString(); 7823 floorKey = (String) descendingKeySet.floor(key); 7824 assertEquals(100, Integer.parseInt(floorKey)); 7825 7826 key = new Integer(2).toString(); 7827 floorKey = (String) descendingKeySet.floor(key); 7828 assertNull(floorKey); 7829 7830 key = new Integer(2).toString(); 7831 keySet = tm.headMap(key, true).navigableKeySet(); 7832 descendingKeySet = keySet.descendingSet(); 7833 Iterator iterator = descendingKeySet.iterator(); 7834 assertEquals(key, descendingKeySet.floor(iterator.next())); 7835 try { 7836 descendingKeySet.floor(null); 7837 fail("should throw NPE"); 7838 } catch (NullPointerException e) { 7839 // Expected 7840 } 7841 7842 key = new Integer(0).toString(); 7843 String endKey = key; 7844 7845 keySet = tm.headMap(endKey, true).navigableKeySet(); 7846 descendingKeySet = keySet.descendingSet(); 7847 assertEquals(key, descendingKeySet.floor(endKey)); 7848 7849 key = new Integer(0).toString(); 7850 keySet = tm.headMap(endKey, false).navigableKeySet(); 7851 descendingKeySet = keySet.descendingSet(); 7852 assertNull(descendingKeySet.floor(endKey)); 7853 7854 endKey = new Integer(999).toString(); 7855 keySet = tm.headMap(endKey, true).navigableKeySet(); 7856 descendingKeySet = keySet.descendingSet(); 7857 assertEquals(new Integer(999).toString(), descendingKeySet 7858 .floor(endKey)); 7859 assertEquals(key, descendingKeySet.floor(key)); 7860 7861 endKey = new Integer(999).toString(); 7862 keySet = tm.headMap(endKey, false).navigableKeySet(); 7863 descendingKeySet = keySet.descendingSet(); 7864 assertNull(descendingKeySet.floor(endKey)); 7865 assertEquals(key, descendingKeySet.floor(key)); 7866 7867 // With Comparator 7868 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7869 .navigableKeySet(); 7870 descendingKeySet = keySet.descendingSet(); 7871 keyArray = (String[]) descendingKeySet 7872 .toArray(new String[descendingKeySet.size()]); 7873 for (int i = 0, j = 108; i < keyArray.length; i++) { 7874 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7875 assertEquals(new Integer(j - i).toString(), floorKey); 7876 } 7877 7878 key = new Integer(0).toString(); 7879 floorKey = (String) descendingKeySet.floor(key); 7880 assertEquals(101, Integer.parseInt(floorKey)); 7881 7882 key = new Integer(2).toString(); 7883 floorKey = (String) descendingKeySet.floor(key); 7884 assertNull(floorKey); 7885 7886 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7887 .navigableKeySet(); 7888 descendingKeySet = keySet.descendingSet(); 7889 keyArray = (String[]) descendingKeySet 7890 .toArray(new String[descendingKeySet.size()]); 7891 for (int i = 0, j = 109; i < keyArray.length; i++) { 7892 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7893 assertEquals(new Integer(j - i).toString(), floorKey); 7894 } 7895 7896 key = new Integer(0).toString(); 7897 floorKey = (String) descendingKeySet.floor(key); 7898 assertEquals(101, Integer.parseInt(floorKey)); 7899 7900 key = new Integer(2).toString(); 7901 floorKey = (String) descendingKeySet.floor(key); 7902 assertNull(floorKey); 7903 7904 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7905 .navigableKeySet(); 7906 descendingKeySet = keySet.descendingSet(); 7907 keyArray = (String[]) descendingKeySet 7908 .toArray(new String[descendingKeySet.size()]); 7909 for (int i = 0, j = 108; i < keyArray.length; i++) { 7910 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7911 assertEquals(new Integer(j - i).toString(), floorKey); 7912 } 7913 7914 key = new Integer(0).toString(); 7915 floorKey = (String) descendingKeySet.floor(key); 7916 assertEquals(100, Integer.parseInt(floorKey)); 7917 7918 key = new Integer(2).toString(); 7919 floorKey = (String) descendingKeySet.floor(key); 7920 assertNull(floorKey); 7921 7922 keySet = ((NavigableMap) subMap_startIncluded_endIncluded) 7923 .navigableKeySet(); 7924 descendingKeySet = keySet.descendingSet(); 7925 keyArray = (String[]) descendingKeySet 7926 .toArray(new String[descendingKeySet.size()]); 7927 for (int i = 0, j = 109; i < keyArray.length; i++) { 7928 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7929 assertEquals(new Integer(j - i).toString(), floorKey); 7930 } 7931 7932 key = new Integer(0).toString(); 7933 floorKey = (String) descendingKeySet.floor(key); 7934 assertEquals(100, Integer.parseInt(floorKey)); 7935 7936 key = new Integer(2).toString(); 7937 floorKey = (String) descendingKeySet.floor(key); 7938 assertNull(floorKey); 7939 } 7940 7941 public void test_AscendingSubMapKeySet_last() { 7942 NavigableSet keySet; 7943 String firstKey1 = new Integer(108).toString(); 7944 String firstKey2 = new Integer(109).toString(); 7945 7946 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7947 assertEquals(firstKey1, keySet.last()); 7948 7949 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7950 assertEquals(firstKey2, keySet.last()); 7951 7952 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7953 assertEquals(firstKey1, keySet.last()); 7954 7955 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7956 assertEquals(firstKey2, keySet.last()); 7957 } 7958 7959 public void test_AscendingSubMapKeySet_comparator() { 7960 NavigableSet keySet; 7961 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7962 assertNull(keySet.comparator()); 7963 7964 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7965 assertNull(keySet.comparator()); 7966 7967 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7968 assertNull(keySet.comparator()); 7969 7970 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7971 assertNull(keySet.comparator()); 7972 7973 String endKey = new Integer(2).toString(); 7974 keySet = tm.headMap(endKey, true).navigableKeySet(); 7975 assertNull(keySet.comparator()); 7976 } 7977 7978 public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endExcluded() { 7979 NavigableSet keySet = navigableMap_startExcluded_endExcluded 7980 .navigableKeySet(); 7981 Iterator iterator = keySet.iterator(); 7982 assertEquals(8, keySet.size()); 7983 for (int value = 101; value < 109; value++) { 7984 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 7985 } 7986 assertEquals(0, keySet.size()); 7987 assertNull(keySet.pollFirst()); 7988 } 7989 7990 public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endIncluded() { 7991 NavigableSet keySet = navigableMap_startExcluded_endIncluded 7992 .navigableKeySet(); 7993 Iterator iterator = keySet.iterator(); 7994 assertEquals(9, keySet.size()); 7995 for (int value = 101; value < 110; value++) { 7996 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 7997 } 7998 assertEquals(0, keySet.size()); 7999 assertNull(keySet.pollFirst()); 8000 } 8001 8002 public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endExcluded() { 8003 NavigableSet keySet = navigableMap_startIncluded_endExcluded 8004 .navigableKeySet(); 8005 Iterator iterator = keySet.iterator(); 8006 assertEquals(9, keySet.size()); 8007 for (int value = 100; value < 109; value++) { 8008 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 8009 } 8010 assertEquals(0, keySet.size()); 8011 assertNull(keySet.pollFirst()); 8012 } 8013 8014 public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endIncluded() { 8015 NavigableSet keySet = navigableMap_startIncluded_endIncluded 8016 .navigableKeySet(); 8017 Iterator iterator = keySet.iterator(); 8018 assertEquals(10, keySet.size()); 8019 for (int value = 100; value < 110; value++) { 8020 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 8021 } 8022 assertEquals(0, keySet.size()); 8023 assertNull(keySet.pollFirst()); 8024 } 8025 8026 public void test_AscendingSubMapKeySet_pollFirst() { 8027 String endKey = new Integer(2).toString(); 8028 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 8029 assertEquals(new Integer(0).toString(), keySet.pollFirst()); 8030 8031 keySet = tm.tailMap(endKey, true).navigableKeySet(); 8032 assertEquals(new Integer(2).toString(), keySet.pollFirst()); 8033 } 8034 8035 public void test_AscendingSubMapKeySet_pollLast_startExcluded_endExcluded() { 8036 NavigableSet keySet = navigableMap_startExcluded_endExcluded 8037 .navigableKeySet(); 8038 Iterator iterator = keySet.iterator(); 8039 assertEquals(8, keySet.size()); 8040 for (int value = 108; value > 100; value--) { 8041 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8042 } 8043 assertEquals(0, keySet.size()); 8044 assertNull(keySet.pollLast()); 8045 } 8046 8047 public void test_AscendingSubMapKeySet_pollLast_startExcluded_endIncluded() { 8048 NavigableSet keySet = navigableMap_startExcluded_endIncluded 8049 .navigableKeySet(); 8050 Iterator iterator = keySet.iterator(); 8051 assertEquals(9, keySet.size()); 8052 for (int value = 109; value > 100; value--) { 8053 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8054 } 8055 assertEquals(0, keySet.size()); 8056 assertNull(keySet.pollLast()); 8057 } 8058 8059 public void test_AscendingSubMapKeySet_pollLast_startIncluded_endExcluded() { 8060 NavigableSet keySet = navigableMap_startIncluded_endExcluded 8061 .navigableKeySet(); 8062 Iterator iterator = keySet.iterator(); 8063 assertEquals(9, keySet.size()); 8064 for (int value = 108; value > 99; value--) { 8065 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8066 } 8067 assertEquals(0, keySet.size()); 8068 assertNull(keySet.pollLast()); 8069 } 8070 8071 public void test_AscendingSubMapKeySet_pollLast_startIncluded_endIncluded() { 8072 NavigableSet keySet = navigableMap_startIncluded_endIncluded 8073 .navigableKeySet(); 8074 Iterator iterator = keySet.iterator(); 8075 assertEquals(10, keySet.size()); 8076 for (int value = 109; value > 99; value--) { 8077 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8078 } 8079 assertEquals(0, keySet.size()); 8080 assertNull(keySet.pollLast()); 8081 } 8082 8083 public void test_AscendingSubMapKeySet_pollLast() { 8084 String endKey = new Integer(2).toString(); 8085 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 8086 assertEquals(new Integer(2).toString(), keySet.pollLast()); 8087 8088 keySet = tm.tailMap(endKey, true).navigableKeySet(); 8089 assertEquals(new Integer(999).toString(), keySet.pollLast()); 8090 } 8091 8092 public void test_AscendingSubMapKeySet_descendingIterator() { 8093 NavigableSet keySet; 8094 Iterator iterator; 8095 8096 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 8097 iterator = keySet.descendingIterator(); 8098 for (int value = 108; value > 100; value--) { 8099 assertTrue(iterator.hasNext()); 8100 assertEquals(new Integer(value).toString(), iterator.next()); 8101 } 8102 assertFalse(iterator.hasNext()); 8103 try { 8104 iterator.next(); 8105 fail("should throw NoSuchElementException"); 8106 } catch (NoSuchElementException e) { 8107 // Expected 8108 } 8109 8110 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 8111 iterator = keySet.descendingIterator(); 8112 for (int value = 109; value > 100; value--) { 8113 assertTrue(iterator.hasNext()); 8114 assertEquals(new Integer(value).toString(), iterator.next()); 8115 } 8116 assertFalse(iterator.hasNext()); 8117 try { 8118 iterator.next(); 8119 fail("should throw NoSuchElementException"); 8120 } catch (NoSuchElementException e) { 8121 // Expected 8122 } 8123 8124 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 8125 iterator = keySet.descendingIterator(); 8126 for (int value = 108; value > 99; value--) { 8127 assertTrue(iterator.hasNext()); 8128 assertEquals(new Integer(value).toString(), iterator.next()); 8129 } 8130 assertFalse(iterator.hasNext()); 8131 try { 8132 iterator.next(); 8133 fail("should throw NoSuchElementException"); 8134 } catch (NoSuchElementException e) { 8135 // Expected 8136 } 8137 8138 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 8139 iterator = keySet.descendingIterator(); 8140 for (int value = 109; value > 99; value--) { 8141 assertTrue(iterator.hasNext()); 8142 assertEquals(new Integer(value).toString(), iterator.next()); 8143 } 8144 assertFalse(iterator.hasNext()); 8145 try { 8146 iterator.next(); 8147 fail("should throw NoSuchElementException"); 8148 } catch (NoSuchElementException e) { 8149 // Expected 8150 } 8151 8152 String endKey = new Integer(2).toString(); 8153 keySet = tm.headMap(endKey, true).navigableKeySet(); 8154 iterator = keySet.descendingIterator(); 8155 assertEquals(new Integer(2).toString(), iterator.next()); 8156 assertEquals(new Integer(199).toString(), iterator.next()); 8157 } 8158 8159 public void test_AscendingSubMapKeySet_descendingSet() { 8160 NavigableSet keySet, descendingSet; 8161 Iterator iterator; 8162 8163 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet() 8164 .descendingSet(); 8165 descendingSet = keySet.descendingSet(); 8166 iterator = descendingSet.iterator(); 8167 for (int value = 101; value < 109; value++) { 8168 assertTrue(iterator.hasNext()); 8169 assertEquals(new Integer(value).toString(), iterator.next()); 8170 } 8171 assertFalse(iterator.hasNext()); 8172 try { 8173 iterator.next(); 8174 fail("should throw NoSuchElementException"); 8175 } catch (NoSuchElementException e) { 8176 // Expected 8177 } 8178 8179 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet() 8180 .descendingSet(); 8181 descendingSet = keySet.descendingSet(); 8182 iterator = descendingSet.iterator(); 8183 for (int value = 101; value < 110; value++) { 8184 assertTrue(iterator.hasNext()); 8185 assertEquals(new Integer(value).toString(), iterator.next()); 8186 } 8187 assertFalse(iterator.hasNext()); 8188 try { 8189 iterator.next(); 8190 fail("should throw NoSuchElementException"); 8191 } catch (NoSuchElementException e) { 8192 // Expected 8193 } 8194 8195 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet() 8196 .descendingSet(); 8197 descendingSet = keySet.descendingSet(); 8198 iterator = descendingSet.iterator(); 8199 for (int value = 100; value < 109; value++) { 8200 assertTrue(iterator.hasNext()); 8201 assertEquals(new Integer(value).toString(), iterator.next()); 8202 } 8203 assertFalse(iterator.hasNext()); 8204 try { 8205 iterator.next(); 8206 fail("should throw NoSuchElementException"); 8207 } catch (NoSuchElementException e) { 8208 // Expected 8209 } 8210 8211 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet() 8212 .descendingSet(); 8213 descendingSet = keySet.descendingSet(); 8214 iterator = descendingSet.iterator(); 8215 for (int value = 100; value < 110; value++) { 8216 assertTrue(iterator.hasNext()); 8217 assertEquals(new Integer(value).toString(), iterator.next()); 8218 } 8219 assertFalse(iterator.hasNext()); 8220 try { 8221 iterator.next(); 8222 fail("should throw NoSuchElementException"); 8223 } catch (NoSuchElementException e) { 8224 // Expected 8225 } 8226 8227 String endKey = new Integer(1).toString(); 8228 keySet = tm.headMap(endKey, true).navigableKeySet(); 8229 descendingSet = keySet.descendingSet(); 8230 iterator = descendingSet.iterator(); 8231 assertEquals(new Integer(1).toString(), iterator.next()); 8232 assertEquals(new Integer(0).toString(), iterator.next()); 8233 } 8234 8235 public void test_AscendingSubMapKeySet_headSet() { 8236 NavigableSet keySet; 8237 SortedSet headSet; 8238 String endKey, key; 8239 Iterator iterator; 8240 8241 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 8242 endKey = new Integer(99).toString(); 8243 try { 8244 keySet.headSet(endKey); 8245 fail("should throw IllegalArgumentException"); 8246 } catch (IllegalArgumentException e) { 8247 // Expected 8248 } 8249 try { 8250 keySet.headSet(endKey, false); 8251 fail("should throw IllegalArgumentException"); 8252 } catch (IllegalArgumentException e) { 8253 // Expected 8254 } 8255 try { 8256 keySet.headSet(endKey, true); 8257 fail("should throw IllegalArgumentException"); 8258 } catch (IllegalArgumentException e) { 8259 // Expected 8260 } 8261 8262 endKey = new Integer(100).toString(); 8263 try { 8264 keySet.headSet(endKey, false); 8265 fail("should throw IllegalArgumentException"); 8266 } catch (IllegalArgumentException e) { 8267 // Expected 8268 } 8269 8270 try { 8271 keySet.headSet(endKey); 8272 fail("should throw IllegalArgumentException"); 8273 } catch (IllegalArgumentException e) { 8274 // Expected 8275 } 8276 8277 try { 8278 keySet.headSet(endKey, true); 8279 fail("should throw IllegalArgumentException"); 8280 } catch (IllegalArgumentException e) { 8281 // Expected 8282 } 8283 8284 endKey = new Integer(101).toString(); 8285 assertEquals(0, keySet.headSet(endKey).size()); 8286 assertEquals(0, keySet.headSet(endKey, false).size()); 8287 assertEquals(1, keySet.headSet(endKey, true).size()); 8288 8289 for (int i = 102; i < 109; i++) { 8290 endKey = new Integer(i).toString(); 8291 headSet = keySet.headSet(endKey); 8292 iterator = headSet.iterator(); 8293 int j; 8294 for (j = 101; iterator.hasNext(); j++) { 8295 key = (String) iterator.next(); 8296 assertEquals(new Integer(j).toString(), key); 8297 } 8298 assertEquals(i, j); 8299 8300 headSet = keySet.headSet(endKey, false); 8301 iterator = headSet.iterator(); 8302 for (j = 101; iterator.hasNext(); j++) { 8303 key = (String) iterator.next(); 8304 assertEquals(new Integer(j).toString(), key); 8305 } 8306 assertEquals(i, j); 8307 8308 headSet = keySet.headSet(endKey, true); 8309 iterator = headSet.iterator(); 8310 for (j = 101; iterator.hasNext(); j++) { 8311 key = (String) iterator.next(); 8312 assertEquals(new Integer(j).toString(), key); 8313 } 8314 assertEquals(i + 1, j); 8315 } 8316 8317 endKey = new Integer(109).toString(); 8318 headSet = keySet.headSet(endKey); 8319 iterator = headSet.iterator(); 8320 int index; 8321 for (index = 101; iterator.hasNext(); index++) { 8322 key = (String) iterator.next(); 8323 assertEquals(new Integer(index).toString(), key); 8324 } 8325 assertEquals(109, index); 8326 8327 headSet = keySet.headSet(endKey, false); 8328 iterator = headSet.iterator(); 8329 for (index = 101; iterator.hasNext(); index++) { 8330 key = (String) iterator.next(); 8331 assertEquals(new Integer(index).toString(), key); 8332 } 8333 assertEquals(109, index); 8334 8335 try { 8336 keySet.headSet(endKey, true); 8337 fail("should throw IllegalArgumentException"); 8338 } catch (IllegalArgumentException e) { 8339 // Expected 8340 } 8341 8342 endKey = new Integer(110).toString(); 8343 try { 8344 keySet.headSet(endKey); 8345 fail("should throw IllegalArgumentException"); 8346 } catch (IllegalArgumentException e) { 8347 // Expected 8348 } 8349 try { 8350 keySet.headSet(endKey, true); 8351 fail("should throw IllegalArgumentException"); 8352 } catch (IllegalArgumentException e) { 8353 // Expected 8354 } 8355 try { 8356 keySet.headSet(endKey, false); 8357 fail("should throw IllegalArgumentException"); 8358 } catch (IllegalArgumentException e) { 8359 // Expected 8360 } 8361 8362 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 8363 endKey = new Integer(99).toString(); 8364 try { 8365 keySet.headSet(endKey); 8366 fail("should throw IllegalArgumentException"); 8367 } catch (IllegalArgumentException e) { 8368 // Expected 8369 } 8370 try { 8371 keySet.headSet(endKey, true); 8372 fail("should throw IllegalArgumentException"); 8373 } catch (IllegalArgumentException e) { 8374 // Expected 8375 } 8376 try { 8377 keySet.headSet(endKey, false); 8378 fail("should throw IllegalArgumentException"); 8379 } catch (IllegalArgumentException e) { 8380 // Expected 8381 } 8382 8383 endKey = new Integer(100).toString(); 8384 try { 8385 keySet.headSet(endKey); 8386 fail("should throw IllegalArgumentException"); 8387 } catch (IllegalArgumentException e) { 8388 // Expected 8389 } 8390 8391 try { 8392 keySet.headSet(endKey, false); 8393 fail("should throw IllegalArgumentException"); 8394 } catch (IllegalArgumentException e) { 8395 // Expected 8396 } 8397 8398 try { 8399 keySet.headSet(endKey, true); 8400 fail("should throw IllegalArgumentException"); 8401 } catch (IllegalArgumentException e) { 8402 // Expected 8403 } 8404 8405 endKey = new Integer(101).toString(); 8406 assertEquals(0, keySet.headSet(endKey).size()); 8407 assertEquals(0, keySet.headSet(endKey).size()); 8408 assertEquals(1, keySet.headSet(endKey, true).size()); 8409 8410 for (int i = 102; i < 109; i++) { 8411 endKey = new Integer(i).toString(); 8412 8413 headSet = keySet.headSet(endKey); 8414 iterator = headSet.iterator(); 8415 int j; 8416 for (j = 101; iterator.hasNext(); j++) { 8417 key = (String) iterator.next(); 8418 assertEquals(new Integer(j).toString(), key); 8419 } 8420 assertEquals(i, j); 8421 8422 headSet = keySet.headSet(endKey, false); 8423 iterator = headSet.iterator(); 8424 for (j = 101; iterator.hasNext(); j++) { 8425 key = (String) iterator.next(); 8426 assertEquals(new Integer(j).toString(), key); 8427 } 8428 assertEquals(i, j); 8429 8430 headSet = keySet.headSet(endKey, true); 8431 iterator = headSet.iterator(); 8432 for (j = 101; iterator.hasNext(); j++) { 8433 key = (String) iterator.next(); 8434 assertEquals(new Integer(j).toString(), key); 8435 } 8436 assertEquals(i + 1, j); 8437 } 8438 8439 endKey = new Integer(109).toString(); 8440 headSet = keySet.headSet(endKey); 8441 iterator = headSet.iterator(); 8442 for (index = 101; iterator.hasNext(); index++) { 8443 key = (String) iterator.next(); 8444 assertEquals(new Integer(index).toString(), key); 8445 } 8446 assertEquals(109, index); 8447 8448 headSet = keySet.headSet(endKey, false); 8449 iterator = headSet.iterator(); 8450 for (index = 101; iterator.hasNext(); index++) { 8451 key = (String) iterator.next(); 8452 assertEquals(new Integer(index).toString(), key); 8453 } 8454 assertEquals(109, index); 8455 8456 headSet = keySet.headSet(endKey, true); 8457 iterator = headSet.iterator(); 8458 for (index = 101; iterator.hasNext(); index++) { 8459 key = (String) iterator.next(); 8460 assertEquals(new Integer(index).toString(), key); 8461 } 8462 assertEquals(110, index); 8463 8464 endKey = new Integer(110).toString(); 8465 try { 8466 keySet.headSet(endKey); 8467 fail("should throw IllegalArgumentException"); 8468 } catch (IllegalArgumentException e) { 8469 // Expected 8470 } 8471 try { 8472 keySet.headSet(endKey, false); 8473 fail("should throw IllegalArgumentException"); 8474 } catch (IllegalArgumentException e) { 8475 // Expected 8476 } 8477 try { 8478 keySet.headSet(endKey, true); 8479 fail("should throw IllegalArgumentException"); 8480 } catch (IllegalArgumentException e) { 8481 // Expected 8482 } 8483 8484 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 8485 endKey = new Integer(99).toString(); 8486 try { 8487 keySet.headSet(endKey); 8488 fail("should throw IllegalArgumentException"); 8489 } catch (IllegalArgumentException e) { 8490 // Expected 8491 } 8492 try { 8493 keySet.headSet(endKey, false); 8494 fail("should throw IllegalArgumentException"); 8495 } catch (IllegalArgumentException e) { 8496 // Expected 8497 } 8498 try { 8499 keySet.headSet(endKey, true); 8500 fail("should throw IllegalArgumentException"); 8501 } catch (IllegalArgumentException e) { 8502 // Expected 8503 } 8504 8505 endKey = new Integer(100).toString(); 8506 assertEquals(0, keySet.headSet(endKey).size()); 8507 assertEquals(0, keySet.headSet(endKey, false).size()); 8508 assertEquals(1, keySet.headSet(endKey, true).size()); 8509 8510 endKey = new Integer(101).toString(); 8511 headSet = keySet.headSet(endKey); 8512 iterator = headSet.iterator(); 8513 for (index = 100; iterator.hasNext(); index++) { 8514 key = (String) iterator.next(); 8515 assertEquals(new Integer(index).toString(), key); 8516 } 8517 assertEquals(101, index); 8518 8519 headSet = keySet.headSet(endKey, false); 8520 iterator = headSet.iterator(); 8521 for (index = 100; iterator.hasNext(); index++) { 8522 key = (String) iterator.next(); 8523 assertEquals(new Integer(index).toString(), key); 8524 } 8525 assertEquals(101, index); 8526 8527 headSet = keySet.headSet(endKey, true); 8528 iterator = headSet.iterator(); 8529 for (index = 100; iterator.hasNext(); index++) { 8530 key = (String) iterator.next(); 8531 assertEquals(new Integer(index).toString(), key); 8532 } 8533 assertEquals(102, index); 8534 8535 for (int i = 102; i < 109; i++) { 8536 endKey = new Integer(i).toString(); 8537 8538 headSet = keySet.headSet(endKey); 8539 iterator = headSet.iterator(); 8540 int j; 8541 for (j = 100; iterator.hasNext(); j++) { 8542 key = (String) iterator.next(); 8543 assertEquals(new Integer(j).toString(), key); 8544 } 8545 assertEquals(i, j); 8546 8547 headSet = keySet.headSet(endKey, false); 8548 iterator = headSet.iterator(); 8549 for (j = 100; iterator.hasNext(); j++) { 8550 key = (String) iterator.next(); 8551 assertEquals(new Integer(j).toString(), key); 8552 } 8553 assertEquals(i, j); 8554 8555 headSet = keySet.headSet(endKey, true); 8556 iterator = headSet.iterator(); 8557 for (j = 100; iterator.hasNext(); j++) { 8558 key = (String) iterator.next(); 8559 assertEquals(new Integer(j).toString(), key); 8560 } 8561 assertEquals(i + 1, j); 8562 } 8563 8564 endKey = new Integer(109).toString(); 8565 headSet = keySet.headSet(endKey); 8566 iterator = headSet.iterator(); 8567 for (index = 100; iterator.hasNext(); index++) { 8568 key = (String) iterator.next(); 8569 assertEquals(new Integer(index).toString(), key); 8570 } 8571 assertEquals(109, index); 8572 8573 headSet = keySet.headSet(endKey, false); 8574 iterator = headSet.iterator(); 8575 for (index = 100; iterator.hasNext(); index++) { 8576 key = (String) iterator.next(); 8577 assertEquals(new Integer(index).toString(), key); 8578 } 8579 assertEquals(109, index); 8580 8581 try { 8582 keySet.headSet(endKey, true); 8583 fail("should throw IllegalArgumentException"); 8584 } catch (IllegalArgumentException e) { 8585 // Expected 8586 } 8587 8588 endKey = new Integer(110).toString(); 8589 try { 8590 keySet.headSet(endKey); 8591 fail("should throw IllegalArgumentException"); 8592 } catch (IllegalArgumentException e) { 8593 // Expected 8594 } 8595 8596 try { 8597 keySet.headSet(endKey, false); 8598 fail("should throw IllegalArgumentException"); 8599 } catch (IllegalArgumentException e) { 8600 // Expected 8601 } 8602 8603 try { 8604 keySet.headSet(endKey, true); 8605 fail("should throw IllegalArgumentException"); 8606 } catch (IllegalArgumentException e) { 8607 // Expected 8608 } 8609 8610 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 8611 endKey = new Integer(99).toString(); 8612 try { 8613 keySet.headSet(endKey); 8614 fail("should throw IllegalArgumentException"); 8615 } catch (IllegalArgumentException e) { 8616 // Expected 8617 } 8618 try { 8619 keySet.headSet(endKey, false); 8620 fail("should throw IllegalArgumentException"); 8621 } catch (IllegalArgumentException e) { 8622 // Expected 8623 } 8624 try { 8625 keySet.headSet(endKey, true); 8626 fail("should throw IllegalArgumentException"); 8627 } catch (IllegalArgumentException e) { 8628 // Expected 8629 } 8630 8631 endKey = new Integer(100).toString(); 8632 assertEquals(0, keySet.headSet(endKey).size()); 8633 assertEquals(0, keySet.headSet(endKey, false).size()); 8634 assertEquals(1, keySet.headSet(endKey, true).size()); 8635 8636 endKey = new Integer(101).toString(); 8637 headSet = keySet.headSet(endKey); 8638 iterator = headSet.iterator(); 8639 for (index = 100; iterator.hasNext(); index++) { 8640 key = (String) iterator.next(); 8641 assertEquals(new Integer(index).toString(), key); 8642 } 8643 assertEquals(101, index); 8644 8645 headSet = keySet.headSet(endKey, false); 8646 iterator = headSet.iterator(); 8647 for (index = 100; iterator.hasNext(); index++) { 8648 key = (String) iterator.next(); 8649 assertEquals(new Integer(index).toString(), key); 8650 } 8651 assertEquals(101, index); 8652 8653 headSet = keySet.headSet(endKey, true); 8654 iterator = headSet.iterator(); 8655 for (index = 100; iterator.hasNext(); index++) { 8656 key = (String) iterator.next(); 8657 assertEquals(new Integer(index).toString(), key); 8658 } 8659 assertEquals(102, index); 8660 8661 for (int i = 102; i < 109; i++) { 8662 endKey = new Integer(i).toString(); 8663 8664 headSet = keySet.headSet(endKey); 8665 iterator = headSet.iterator(); 8666 int j; 8667 for (j = 100; iterator.hasNext(); j++) { 8668 key = (String) iterator.next(); 8669 assertEquals(new Integer(j).toString(), key); 8670 } 8671 assertEquals(i, j); 8672 8673 headSet = keySet.headSet(endKey, false); 8674 iterator = headSet.iterator(); 8675 for (j = 100; iterator.hasNext(); j++) { 8676 key = (String) iterator.next(); 8677 assertEquals(new Integer(j).toString(), key); 8678 } 8679 assertEquals(i, j); 8680 8681 headSet = keySet.headSet(endKey, true); 8682 iterator = headSet.iterator(); 8683 for (j = 100; iterator.hasNext(); j++) { 8684 key = (String) iterator.next(); 8685 assertEquals(new Integer(j).toString(), key); 8686 } 8687 assertEquals(i + 1, j); 8688 } 8689 8690 endKey = new Integer(109).toString(); 8691 headSet = keySet.headSet(endKey); 8692 iterator = headSet.iterator(); 8693 for (index = 100; iterator.hasNext(); index++) { 8694 key = (String) iterator.next(); 8695 assertEquals(new Integer(index).toString(), key); 8696 } 8697 assertEquals(109, index); 8698 8699 headSet = keySet.headSet(endKey, false); 8700 iterator = headSet.iterator(); 8701 for (index = 100; iterator.hasNext(); index++) { 8702 key = (String) iterator.next(); 8703 assertEquals(new Integer(index).toString(), key); 8704 } 8705 assertEquals(109, index); 8706 8707 headSet = keySet.headSet(endKey, true); 8708 iterator = headSet.iterator(); 8709 for (index = 100; iterator.hasNext(); index++) { 8710 key = (String) iterator.next(); 8711 assertEquals(new Integer(index).toString(), key); 8712 } 8713 assertEquals(110, index); 8714 8715 endKey = new Integer(110).toString(); 8716 try { 8717 keySet.headSet(endKey); 8718 fail("should throw IllegalArgumentException"); 8719 } catch (IllegalArgumentException e) { 8720 // Expected 8721 } 8722 try { 8723 keySet.headSet(endKey, false); 8724 fail("should throw IllegalArgumentException"); 8725 } catch (IllegalArgumentException e) { 8726 // Expected 8727 } 8728 try { 8729 keySet.headSet(endKey, true); 8730 fail("should throw IllegalArgumentException"); 8731 } catch (IllegalArgumentException e) { 8732 // Expected 8733 } 8734 8735 key = new Integer(1).toString(); 8736 keySet = tm.headMap(key, true).navigableKeySet(); 8737 iterator = keySet.iterator(); 8738 iterator.next(); 8739 endKey = (String) iterator.next(); 8740 headSet = keySet.headSet(endKey, false); 8741 assertEquals(1, headSet.size()); 8742 Iterator headSetIterator = headSet.iterator(); 8743 assertEquals(new Integer(0).toString(), headSetIterator.next()); 8744 assertFalse(headSetIterator.hasNext()); 8745 try { 8746 headSetIterator.next(); 8747 fail("should throw NoSuchElementException"); 8748 } catch (NoSuchElementException e) { 8749 // Expected 8750 } 8751 try { 8752 keySet.headSet(null, false); 8753 fail("should throw NPE"); 8754 } catch (NullPointerException e) { 8755 // Expected 8756 } 8757 8758 headSet = keySet.headSet(endKey, true); 8759 assertEquals(2, headSet.size()); 8760 headSetIterator = headSet.iterator(); 8761 assertEquals(new Integer(0).toString(), headSetIterator.next()); 8762 assertEquals(new Integer(1).toString(), headSetIterator.next()); 8763 assertFalse(headSetIterator.hasNext()); 8764 try { 8765 headSetIterator.next(); 8766 fail("should throw NoSuchElementException"); 8767 } catch (NoSuchElementException e) { 8768 // Expected 8769 } 8770 try { 8771 keySet.headSet(null, false); 8772 fail("should throw NPE"); 8773 } catch (NullPointerException e) { 8774 // Expected 8775 } 8776 8777 // With Comparator 8778 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 8779 .navigableKeySet(); 8780 endKey = new Integer(99).toString(); 8781 try { 8782 keySet.headSet(endKey); 8783 fail("should throw IllegalArgumentException"); 8784 } catch (IllegalArgumentException e) { 8785 // Expected 8786 } 8787 try { 8788 keySet.headSet(endKey, false); 8789 fail("should throw IllegalArgumentException"); 8790 } catch (IllegalArgumentException e) { 8791 // Expected 8792 } 8793 try { 8794 keySet.headSet(endKey, true); 8795 fail("should throw IllegalArgumentException"); 8796 } catch (IllegalArgumentException e) { 8797 // Expected 8798 } 8799 8800 endKey = new Integer(100).toString(); 8801 try { 8802 keySet.headSet(endKey).size(); 8803 fail("should throw IllegalArgumentException"); 8804 } catch (IllegalArgumentException e) { 8805 // Expected 8806 } 8807 8808 try { 8809 keySet.headSet(endKey, false).size(); 8810 fail("should throw IllegalArgumentException"); 8811 } catch (IllegalArgumentException e) { 8812 // Expected 8813 } 8814 8815 try { 8816 keySet.headSet(endKey, true).size(); 8817 fail("should throw IllegalArgumentException"); 8818 } catch (IllegalArgumentException e) { 8819 // Expected 8820 } 8821 8822 endKey = new Integer(101).toString(); 8823 assertEquals(0, keySet.headSet(endKey).size()); 8824 assertEquals(0, keySet.headSet(endKey, false).size()); 8825 assertEquals(1, keySet.headSet(endKey, true).size()); 8826 8827 for (int i = 102; i < 109; i++) { 8828 endKey = new Integer(i).toString(); 8829 headSet = keySet.headSet(endKey); 8830 iterator = headSet.iterator(); 8831 int j; 8832 for (j = 101; iterator.hasNext(); j++) { 8833 key = (String) iterator.next(); 8834 assertEquals(new Integer(j).toString(), key); 8835 } 8836 assertEquals(i, j); 8837 8838 headSet = keySet.headSet(endKey, false); 8839 iterator = headSet.iterator(); 8840 for (j = 101; iterator.hasNext(); j++) { 8841 key = (String) iterator.next(); 8842 assertEquals(new Integer(j).toString(), key); 8843 } 8844 assertEquals(i, j); 8845 8846 headSet = keySet.headSet(endKey, true); 8847 iterator = headSet.iterator(); 8848 for (j = 101; iterator.hasNext(); j++) { 8849 key = (String) iterator.next(); 8850 assertEquals(new Integer(j).toString(), key); 8851 } 8852 assertEquals(i + 1, j); 8853 } 8854 8855 endKey = new Integer(109).toString(); 8856 headSet = keySet.headSet(endKey); 8857 iterator = headSet.iterator(); 8858 for (index = 101; iterator.hasNext(); index++) { 8859 key = (String) iterator.next(); 8860 assertEquals(new Integer(index).toString(), key); 8861 } 8862 assertEquals(109, index); 8863 8864 headSet = keySet.headSet(endKey, false); 8865 iterator = headSet.iterator(); 8866 for (index = 101; iterator.hasNext(); index++) { 8867 key = (String) iterator.next(); 8868 assertEquals(new Integer(index).toString(), key); 8869 } 8870 assertEquals(109, index); 8871 8872 try { 8873 keySet.headSet(endKey, true); 8874 fail("should throw IllegalArgumentException"); 8875 } catch (IllegalArgumentException e) { 8876 // Expected 8877 } 8878 8879 endKey = new Integer(110).toString(); 8880 try { 8881 keySet.headSet(endKey); 8882 fail("should throw IllegalArgumentException"); 8883 } catch (IllegalArgumentException e) { 8884 // Expected 8885 } 8886 try { 8887 keySet.headSet(endKey, true); 8888 fail("should throw IllegalArgumentException"); 8889 } catch (IllegalArgumentException e) { 8890 // Expected 8891 } 8892 try { 8893 keySet.headSet(endKey, false); 8894 fail("should throw IllegalArgumentException"); 8895 } catch (IllegalArgumentException e) { 8896 // Expected 8897 } 8898 8899 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 8900 .navigableKeySet(); 8901 endKey = new Integer(99).toString(); 8902 try { 8903 keySet.headSet(endKey); 8904 fail("should throw IllegalArgumentException"); 8905 } catch (IllegalArgumentException e) { 8906 // Expected 8907 } 8908 try { 8909 keySet.headSet(endKey, true); 8910 fail("should throw IllegalArgumentException"); 8911 } catch (IllegalArgumentException e) { 8912 // Expected 8913 } 8914 try { 8915 keySet.headSet(endKey, false); 8916 fail("should throw IllegalArgumentException"); 8917 } catch (IllegalArgumentException e) { 8918 // Expected 8919 } 8920 8921 endKey = new Integer(100).toString(); 8922 try { 8923 keySet.headSet(endKey); 8924 fail("should throw IllegalArgumentException"); 8925 } catch (IllegalArgumentException e) { 8926 // Expected 8927 } 8928 8929 try { 8930 keySet.headSet(endKey, false); 8931 fail("should throw IllegalArgumentException"); 8932 } catch (IllegalArgumentException e) { 8933 // Expected 8934 } 8935 8936 try { 8937 keySet.headSet(endKey, true); 8938 fail("should throw IllegalArgumentException"); 8939 } catch (IllegalArgumentException e) { 8940 // Expected 8941 } 8942 8943 endKey = new Integer(101).toString(); 8944 assertEquals(0, keySet.headSet(endKey).size()); 8945 assertEquals(0, keySet.headSet(endKey).size()); 8946 assertEquals(1, keySet.headSet(endKey, true).size()); 8947 8948 for (int i = 102; i < 109; i++) { 8949 endKey = new Integer(i).toString(); 8950 8951 headSet = keySet.headSet(endKey); 8952 iterator = headSet.iterator(); 8953 int j; 8954 for (j = 101; iterator.hasNext(); j++) { 8955 key = (String) iterator.next(); 8956 assertEquals(new Integer(j).toString(), key); 8957 } 8958 assertEquals(i, j); 8959 8960 headSet = keySet.headSet(endKey, false); 8961 iterator = headSet.iterator(); 8962 for (j = 101; iterator.hasNext(); j++) { 8963 key = (String) iterator.next(); 8964 assertEquals(new Integer(j).toString(), key); 8965 } 8966 assertEquals(i, j); 8967 8968 headSet = keySet.headSet(endKey, true); 8969 iterator = headSet.iterator(); 8970 for (j = 101; iterator.hasNext(); j++) { 8971 key = (String) iterator.next(); 8972 assertEquals(new Integer(j).toString(), key); 8973 } 8974 assertEquals(i + 1, j); 8975 } 8976 8977 endKey = new Integer(109).toString(); 8978 headSet = keySet.headSet(endKey); 8979 iterator = headSet.iterator(); 8980 for (index = 101; iterator.hasNext(); index++) { 8981 key = (String) iterator.next(); 8982 assertEquals(new Integer(index).toString(), key); 8983 } 8984 assertEquals(109, index); 8985 8986 headSet = keySet.headSet(endKey, false); 8987 iterator = headSet.iterator(); 8988 for (index = 101; iterator.hasNext(); index++) { 8989 key = (String) iterator.next(); 8990 assertEquals(new Integer(index).toString(), key); 8991 } 8992 assertEquals(109, index); 8993 8994 headSet = keySet.headSet(endKey, true); 8995 iterator = headSet.iterator(); 8996 for (index = 101; iterator.hasNext(); index++) { 8997 key = (String) iterator.next(); 8998 assertEquals(new Integer(index).toString(), key); 8999 } 9000 assertEquals(110, index); 9001 9002 endKey = new Integer(110).toString(); 9003 try { 9004 keySet.headSet(endKey); 9005 fail("should throw IllegalArgumentException"); 9006 } catch (IllegalArgumentException e) { 9007 // Expected 9008 } 9009 try { 9010 keySet.headSet(endKey, false); 9011 fail("should throw IllegalArgumentException"); 9012 } catch (IllegalArgumentException e) { 9013 // Expected 9014 } 9015 try { 9016 keySet.headSet(endKey, true); 9017 fail("should throw IllegalArgumentException"); 9018 } catch (IllegalArgumentException e) { 9019 // Expected 9020 } 9021 9022 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 9023 .navigableKeySet(); 9024 endKey = new Integer(99).toString(); 9025 try { 9026 keySet.headSet(endKey); 9027 fail("should throw IllegalArgumentException"); 9028 } catch (IllegalArgumentException e) { 9029 // Expected 9030 } 9031 try { 9032 keySet.headSet(endKey, false); 9033 fail("should throw IllegalArgumentException"); 9034 } catch (IllegalArgumentException e) { 9035 // Expected 9036 } 9037 try { 9038 keySet.headSet(endKey, true); 9039 fail("should throw IllegalArgumentException"); 9040 } catch (IllegalArgumentException e) { 9041 // Expected 9042 } 9043 9044 endKey = new Integer(100).toString(); 9045 assertEquals(0, keySet.headSet(endKey).size()); 9046 assertEquals(0, keySet.headSet(endKey, false).size()); 9047 assertEquals(1, keySet.headSet(endKey, true).size()); 9048 9049 endKey = new Integer(101).toString(); 9050 headSet = keySet.headSet(endKey); 9051 iterator = headSet.iterator(); 9052 for (index = 100; iterator.hasNext(); index++) { 9053 key = (String) iterator.next(); 9054 assertEquals(new Integer(index).toString(), key); 9055 } 9056 assertEquals(101, index); 9057 9058 headSet = keySet.headSet(endKey, false); 9059 iterator = headSet.iterator(); 9060 for (index = 100; iterator.hasNext(); index++) { 9061 key = (String) iterator.next(); 9062 assertEquals(new Integer(index).toString(), key); 9063 } 9064 assertEquals(101, index); 9065 9066 headSet = keySet.headSet(endKey, true); 9067 iterator = headSet.iterator(); 9068 for (index = 100; iterator.hasNext(); index++) { 9069 key = (String) iterator.next(); 9070 assertEquals(new Integer(index).toString(), key); 9071 } 9072 assertEquals(102, index); 9073 9074 for (int i = 102; i < 109; i++) { 9075 endKey = new Integer(i).toString(); 9076 9077 headSet = keySet.headSet(endKey); 9078 iterator = headSet.iterator(); 9079 int j; 9080 for (j = 100; iterator.hasNext(); j++) { 9081 key = (String) iterator.next(); 9082 assertEquals(new Integer(j).toString(), key); 9083 } 9084 assertEquals(i, j); 9085 9086 headSet = keySet.headSet(endKey, false); 9087 iterator = headSet.iterator(); 9088 for (j = 100; iterator.hasNext(); j++) { 9089 key = (String) iterator.next(); 9090 assertEquals(new Integer(j).toString(), key); 9091 } 9092 assertEquals(i, j); 9093 9094 headSet = keySet.headSet(endKey, true); 9095 iterator = headSet.iterator(); 9096 for (j = 100; iterator.hasNext(); j++) { 9097 key = (String) iterator.next(); 9098 assertEquals(new Integer(j).toString(), key); 9099 } 9100 assertEquals(i + 1, j); 9101 } 9102 9103 endKey = new Integer(109).toString(); 9104 headSet = keySet.headSet(endKey); 9105 iterator = headSet.iterator(); 9106 for (index = 100; iterator.hasNext(); index++) { 9107 key = (String) iterator.next(); 9108 assertEquals(new Integer(index).toString(), key); 9109 } 9110 assertEquals(109, index); 9111 9112 headSet = keySet.headSet(endKey, false); 9113 iterator = headSet.iterator(); 9114 for (index = 100; iterator.hasNext(); index++) { 9115 key = (String) iterator.next(); 9116 assertEquals(new Integer(index).toString(), key); 9117 } 9118 assertEquals(109, index); 9119 9120 try { 9121 keySet.headSet(endKey, true); 9122 fail("should throw IllegalArgumentException"); 9123 } catch (IllegalArgumentException e) { 9124 // Expected 9125 } 9126 9127 endKey = new Integer(110).toString(); 9128 try { 9129 keySet.headSet(endKey); 9130 fail("should throw IllegalArgumentException"); 9131 } catch (IllegalArgumentException e) { 9132 // Expected 9133 } 9134 9135 try { 9136 keySet.headSet(endKey, false); 9137 fail("should throw IllegalArgumentException"); 9138 } catch (IllegalArgumentException e) { 9139 // Expected 9140 } 9141 9142 try { 9143 keySet.headSet(endKey, true); 9144 fail("should throw IllegalArgumentException"); 9145 } catch (IllegalArgumentException e) { 9146 // Expected 9147 } 9148 9149 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 9150 .navigableKeySet(); 9151 endKey = new Integer(99).toString(); 9152 try { 9153 keySet.headSet(endKey); 9154 fail("should throw IllegalArgumentException"); 9155 } catch (IllegalArgumentException e) { 9156 // Expected 9157 } 9158 try { 9159 keySet.headSet(endKey, false); 9160 fail("should throw IllegalArgumentException"); 9161 } catch (IllegalArgumentException e) { 9162 // Expected 9163 } 9164 try { 9165 keySet.headSet(endKey, true); 9166 fail("should throw IllegalArgumentException"); 9167 } catch (IllegalArgumentException e) { 9168 // Expected 9169 } 9170 9171 endKey = new Integer(100).toString(); 9172 assertEquals(0, keySet.headSet(endKey).size()); 9173 assertEquals(0, keySet.headSet(endKey, false).size()); 9174 assertEquals(1, keySet.headSet(endKey, true).size()); 9175 9176 endKey = new Integer(101).toString(); 9177 headSet = keySet.headSet(endKey); 9178 iterator = headSet.iterator(); 9179 for (index = 100; iterator.hasNext(); index++) { 9180 key = (String) iterator.next(); 9181 assertEquals(new Integer(index).toString(), key); 9182 } 9183 assertEquals(101, index); 9184 9185 headSet = keySet.headSet(endKey, false); 9186 iterator = headSet.iterator(); 9187 for (index = 100; iterator.hasNext(); index++) { 9188 key = (String) iterator.next(); 9189 assertEquals(new Integer(index).toString(), key); 9190 } 9191 assertEquals(101, index); 9192 9193 headSet = keySet.headSet(endKey, true); 9194 iterator = headSet.iterator(); 9195 for (index = 100; iterator.hasNext(); index++) { 9196 key = (String) iterator.next(); 9197 assertEquals(new Integer(index).toString(), key); 9198 } 9199 assertEquals(102, index); 9200 9201 for (int i = 102; i < 109; i++) { 9202 endKey = new Integer(i).toString(); 9203 9204 headSet = keySet.headSet(endKey); 9205 iterator = headSet.iterator(); 9206 int j; 9207 for (j = 100; iterator.hasNext(); j++) { 9208 key = (String) iterator.next(); 9209 assertEquals(new Integer(j).toString(), key); 9210 } 9211 assertEquals(i, j); 9212 9213 headSet = keySet.headSet(endKey, false); 9214 iterator = headSet.iterator(); 9215 for (j = 100; iterator.hasNext(); j++) { 9216 key = (String) iterator.next(); 9217 assertEquals(new Integer(j).toString(), key); 9218 } 9219 assertEquals(i, j); 9220 9221 headSet = keySet.headSet(endKey, true); 9222 iterator = headSet.iterator(); 9223 for (j = 100; iterator.hasNext(); j++) { 9224 key = (String) iterator.next(); 9225 assertEquals(new Integer(j).toString(), key); 9226 } 9227 assertEquals(i + 1, j); 9228 } 9229 9230 endKey = new Integer(109).toString(); 9231 headSet = keySet.headSet(endKey); 9232 iterator = headSet.iterator(); 9233 for (index = 100; iterator.hasNext(); index++) { 9234 key = (String) iterator.next(); 9235 assertEquals(new Integer(index).toString(), key); 9236 } 9237 assertEquals(109, index); 9238 9239 headSet = keySet.headSet(endKey, false); 9240 iterator = headSet.iterator(); 9241 for (index = 100; iterator.hasNext(); index++) { 9242 key = (String) iterator.next(); 9243 assertEquals(new Integer(index).toString(), key); 9244 } 9245 assertEquals(109, index); 9246 9247 headSet = keySet.headSet(endKey, true); 9248 iterator = headSet.iterator(); 9249 for (index = 100; iterator.hasNext(); index++) { 9250 key = (String) iterator.next(); 9251 assertEquals(new Integer(index).toString(), key); 9252 } 9253 assertEquals(110, index); 9254 9255 endKey = new Integer(110).toString(); 9256 try { 9257 keySet.headSet(endKey); 9258 fail("should throw IllegalArgumentException"); 9259 } catch (IllegalArgumentException e) { 9260 // Expected 9261 } 9262 try { 9263 keySet.headSet(endKey, false); 9264 fail("should throw IllegalArgumentException"); 9265 } catch (IllegalArgumentException e) { 9266 // Expected 9267 } 9268 try { 9269 keySet.headSet(endKey, true); 9270 fail("should throw IllegalArgumentException"); 9271 } catch (IllegalArgumentException e) { 9272 // Expected 9273 } 9274 9275 key = new Integer(1).toString(); 9276 keySet = tm.headMap(key, true).navigableKeySet(); 9277 iterator = keySet.iterator(); 9278 iterator.next(); 9279 endKey = (String) iterator.next(); 9280 headSet = keySet.headSet(endKey, false); 9281 assertEquals(1, headSet.size()); 9282 headSetIterator = headSet.iterator(); 9283 assertEquals(new Integer(0).toString(), headSetIterator.next()); 9284 assertFalse(headSetIterator.hasNext()); 9285 try { 9286 headSetIterator.next(); 9287 fail("should throw NoSuchElementException"); 9288 } catch (NoSuchElementException e) { 9289 // Expected 9290 } 9291 try { 9292 keySet.headSet(null, false); 9293 fail("should throw NPE"); 9294 } catch (NullPointerException e) { 9295 // Expected 9296 } 9297 9298 headSet = keySet.headSet(endKey, true); 9299 assertEquals(2, headSet.size()); 9300 headSetIterator = headSet.iterator(); 9301 assertEquals(new Integer(0).toString(), headSetIterator.next()); 9302 assertEquals(new Integer(1).toString(), headSetIterator.next()); 9303 assertFalse(headSetIterator.hasNext()); 9304 try { 9305 headSetIterator.next(); 9306 fail("should throw NoSuchElementException"); 9307 } catch (NoSuchElementException e) { 9308 // Expected 9309 } 9310 try { 9311 keySet.headSet(null, false); 9312 fail("should throw NPE"); 9313 } catch (NullPointerException e) { 9314 // Expected 9315 } 9316 9317 } 9318 9319 public void test_AscendingSubMapKeySet_remove() { 9320 TreeMap tm_rm = new TreeMap(tm); 9321 SortedMap subMap_startExcluded_endExcluded_rm = tm_rm.subMap( 9322 objArray[100].toString(), false, objArray[109].toString(), 9323 false); 9324 assertNull(subMap_startExcluded_endExcluded_rm.remove("0")); 9325 try { 9326 subMap_startExcluded_endExcluded_rm.remove(null); 9327 fail("should throw NPE"); 9328 } catch (Exception e) { 9329 // Expected 9330 } 9331 for (int i = 101; i < 108; i++) { 9332 assertNotNull(subMap_startExcluded_endExcluded_rm 9333 .remove(new Integer(i).toString())); 9334 } 9335 } 9336 9337 public void test_AscendingSubMapKeySet_tailSet() { 9338 NavigableSet keySet; 9339 SortedSet tailSet; 9340 String startKey, key; 9341 Iterator iterator; 9342 9343 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 9344 startKey = new Integer(99).toString(); 9345 try { 9346 keySet.tailSet(startKey); 9347 fail("should throw IllegalArgumentException"); 9348 } catch (IllegalArgumentException e) { 9349 // Expected 9350 } 9351 9352 try { 9353 keySet.tailSet(startKey, true); 9354 fail("should throw IllegalArgumentException"); 9355 } catch (IllegalArgumentException e) { 9356 // Expected 9357 } 9358 9359 try { 9360 keySet.tailSet(startKey, false); 9361 fail("should throw IllegalArgumentException"); 9362 } catch (IllegalArgumentException e) { 9363 // Expected 9364 } 9365 9366 startKey = new Integer(100).toString(); 9367 try { 9368 keySet.tailSet(startKey); 9369 fail("should throw IllegalArgumentException"); 9370 } catch (IllegalArgumentException e) { 9371 // Expected 9372 } 9373 try { 9374 keySet.tailSet(startKey, true); 9375 fail("should throw IllegalArgumentException"); 9376 } catch (IllegalArgumentException e) { 9377 // Expected 9378 } 9379 int index; 9380 tailSet = keySet.tailSet(startKey, false); 9381 iterator = tailSet.iterator(); 9382 for (index = 101; index < 109; index++) { 9383 key = (String) iterator.next(); 9384 assertEquals(new Integer(index).toString(), key); 9385 } 9386 9387 startKey = new Integer(101).toString(); 9388 tailSet = keySet.tailSet(startKey); 9389 iterator = tailSet.iterator(); 9390 for (index = 101; iterator.hasNext(); index++) { 9391 key = (String) iterator.next(); 9392 assertEquals(new Integer(index).toString(), key); 9393 } 9394 assertEquals(109, index); 9395 9396 tailSet = keySet.tailSet(startKey, true); 9397 iterator = tailSet.iterator(); 9398 for (index = 101; iterator.hasNext(); index++) { 9399 key = (String) iterator.next(); 9400 assertEquals(new Integer(index).toString(), key); 9401 } 9402 assertEquals(109, index); 9403 9404 tailSet = keySet.tailSet(startKey, false); 9405 iterator = tailSet.iterator(); 9406 for (index = 101; iterator.hasNext(); index++) { 9407 key = (String) iterator.next(); 9408 assertEquals(new Integer(index + 1).toString(), key); 9409 } 9410 assertEquals(108, index); 9411 9412 for (int i = 102; i < 109; i++) { 9413 startKey = new Integer(i).toString(); 9414 9415 tailSet = keySet.tailSet(startKey); 9416 iterator = tailSet.iterator(); 9417 int j; 9418 for (j = i; iterator.hasNext(); j++) { 9419 key = (String) iterator.next(); 9420 assertEquals(new Integer(j).toString(), key); 9421 } 9422 assertEquals(109, j); 9423 9424 tailSet = keySet.tailSet(startKey, true); 9425 iterator = tailSet.iterator(); 9426 for (j = i; iterator.hasNext(); j++) { 9427 key = (String) iterator.next(); 9428 assertEquals(new Integer(j).toString(), key); 9429 } 9430 assertEquals(109, j); 9431 9432 tailSet = keySet.tailSet(startKey, false); 9433 iterator = tailSet.iterator(); 9434 for (j = i; iterator.hasNext(); j++) { 9435 key = (String) iterator.next(); 9436 assertEquals(new Integer(j + 1).toString(), key); 9437 } 9438 assertEquals(108, j); 9439 } 9440 9441 startKey = new Integer(109).toString(); 9442 try { 9443 keySet.tailSet(startKey); 9444 fail("should throw IllegalArgumentException"); 9445 } catch (IllegalArgumentException e) { 9446 // Expected 9447 } 9448 try { 9449 keySet.tailSet(startKey, true); 9450 fail("should throw IllegalArgumentException"); 9451 } catch (IllegalArgumentException e) { 9452 // Expected 9453 } 9454 try { 9455 keySet.tailSet(startKey, false); 9456 fail("should throw IllegalArgumentException"); 9457 } catch (IllegalArgumentException e) { 9458 // Expected 9459 } 9460 9461 startKey = new Integer(110).toString(); 9462 try { 9463 keySet.tailSet(startKey); 9464 fail("should throw IllegalArgumentException"); 9465 } catch (IllegalArgumentException e) { 9466 // Expected 9467 } 9468 try { 9469 keySet.tailSet(startKey, true); 9470 fail("should throw IllegalArgumentException"); 9471 } catch (IllegalArgumentException e) { 9472 // Expected 9473 } 9474 try { 9475 keySet.tailSet(startKey, false); 9476 fail("should throw IllegalArgumentException"); 9477 } catch (IllegalArgumentException e) { 9478 // Expected 9479 } 9480 9481 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 9482 startKey = new Integer(99).toString(); 9483 try { 9484 keySet.tailSet(startKey); 9485 fail("should throw IllegalArgumentException"); 9486 } catch (IllegalArgumentException e) { 9487 // Expected 9488 } 9489 try { 9490 keySet.tailSet(startKey, true); 9491 fail("should throw IllegalArgumentException"); 9492 } catch (IllegalArgumentException e) { 9493 // Expected 9494 } 9495 try { 9496 keySet.tailSet(startKey, false); 9497 fail("should throw IllegalArgumentException"); 9498 } catch (IllegalArgumentException e) { 9499 // Expected 9500 } 9501 9502 startKey = new Integer(100).toString(); 9503 try { 9504 keySet.tailSet(startKey); 9505 fail("should throw IllegalArgumentException"); 9506 } catch (IllegalArgumentException e) { 9507 // Expected 9508 } 9509 try { 9510 keySet.tailSet(startKey, true); 9511 fail("should throw IllegalArgumentException"); 9512 } catch (IllegalArgumentException e) { 9513 // Expected 9514 } 9515 9516 tailSet = keySet.tailSet(startKey, false); 9517 iterator = tailSet.iterator(); 9518 for (index = 100; iterator.hasNext(); index++) { 9519 key = (String) iterator.next(); 9520 assertEquals(new Integer(index + 1).toString(), key); 9521 } 9522 assertEquals(109, index); 9523 9524 for (int i = 102; i < 109; i++) { 9525 startKey = new Integer(i).toString(); 9526 9527 tailSet = keySet.tailSet(startKey); 9528 iterator = tailSet.iterator(); 9529 int j; 9530 for (j = i; iterator.hasNext(); j++) { 9531 key = (String) iterator.next(); 9532 assertEquals(new Integer(j).toString(), key); 9533 } 9534 assertEquals(110, j); 9535 9536 tailSet = keySet.tailSet(startKey, true); 9537 iterator = tailSet.iterator(); 9538 for (j = i; iterator.hasNext(); j++) { 9539 key = (String) iterator.next(); 9540 assertEquals(new Integer(j).toString(), key); 9541 } 9542 assertEquals(110, j); 9543 9544 tailSet = keySet.tailSet(startKey, false); 9545 iterator = tailSet.iterator(); 9546 for (j = i; iterator.hasNext(); j++) { 9547 key = (String) iterator.next(); 9548 assertEquals(new Integer(j + 1).toString(), key); 9549 } 9550 assertEquals(109, j); 9551 } 9552 9553 startKey = new Integer(109).toString(); 9554 tailSet = keySet.tailSet(startKey); 9555 iterator = tailSet.iterator(); 9556 for (index = 109; iterator.hasNext(); index++) { 9557 key = (String) iterator.next(); 9558 assertEquals(new Integer(index).toString(), key); 9559 } 9560 assertEquals(110, index); 9561 9562 tailSet = keySet.tailSet(startKey, true); 9563 iterator = tailSet.iterator(); 9564 for (index = 109; iterator.hasNext(); index++) { 9565 key = (String) iterator.next(); 9566 assertEquals(new Integer(index).toString(), key); 9567 } 9568 assertEquals(110, index); 9569 9570 tailSet = keySet.tailSet(startKey, false); 9571 iterator = tailSet.iterator(); 9572 for (index = 109; iterator.hasNext(); index++) { 9573 key = (String) iterator.next(); 9574 assertEquals(new Integer(index + 1).toString(), key); 9575 } 9576 assertEquals(109, index); 9577 9578 startKey = new Integer(110).toString(); 9579 try { 9580 keySet.tailSet(startKey); 9581 fail("should throw IllegalArgumentException"); 9582 } catch (IllegalArgumentException e) { 9583 // Expected 9584 } 9585 try { 9586 keySet.tailSet(startKey, true); 9587 fail("should throw IllegalArgumentException"); 9588 } catch (IllegalArgumentException e) { 9589 // Expected 9590 } 9591 try { 9592 keySet.tailSet(startKey, false); 9593 fail("should throw IllegalArgumentException"); 9594 } catch (IllegalArgumentException e) { 9595 // Expected 9596 } 9597 9598 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 9599 startKey = new Integer(99).toString(); 9600 try { 9601 keySet.tailSet(startKey); 9602 fail("should throw IllegalArgumentException"); 9603 } catch (IllegalArgumentException e) { 9604 // Expected 9605 } 9606 try { 9607 keySet.tailSet(startKey, true); 9608 fail("should throw IllegalArgumentException"); 9609 } catch (IllegalArgumentException e) { 9610 // Expected 9611 } 9612 try { 9613 keySet.tailSet(startKey, false); 9614 fail("should throw IllegalArgumentException"); 9615 } catch (IllegalArgumentException e) { 9616 // Expected 9617 } 9618 9619 startKey = new Integer(100).toString(); 9620 tailSet = keySet.tailSet(startKey); 9621 iterator = tailSet.iterator(); 9622 for (index = 100; iterator.hasNext(); index++) { 9623 key = (String) iterator.next(); 9624 assertEquals(new Integer(index).toString(), key); 9625 } 9626 assertEquals(109, index); 9627 9628 tailSet = keySet.tailSet(startKey, true); 9629 iterator = tailSet.iterator(); 9630 for (index = 100; iterator.hasNext(); index++) { 9631 key = (String) iterator.next(); 9632 assertEquals(new Integer(index).toString(), key); 9633 } 9634 assertEquals(109, index); 9635 9636 tailSet = keySet.tailSet(startKey, false); 9637 iterator = tailSet.iterator(); 9638 for (index = 100; iterator.hasNext(); index++) { 9639 key = (String) iterator.next(); 9640 assertEquals(new Integer(index + 1).toString(), key); 9641 } 9642 assertEquals(108, index); 9643 9644 startKey = new Integer(101).toString(); 9645 tailSet = keySet.tailSet(startKey); 9646 iterator = tailSet.iterator(); 9647 for (index = 101; iterator.hasNext(); index++) { 9648 key = (String) iterator.next(); 9649 assertEquals(new Integer(index).toString(), key); 9650 } 9651 assertEquals(109, index); 9652 9653 tailSet = keySet.tailSet(startKey, true); 9654 iterator = tailSet.iterator(); 9655 for (index = 101; iterator.hasNext(); index++) { 9656 key = (String) iterator.next(); 9657 assertEquals(new Integer(index).toString(), key); 9658 } 9659 assertEquals(109, index); 9660 9661 tailSet = keySet.tailSet(startKey, false); 9662 iterator = tailSet.iterator(); 9663 for (index = 101; iterator.hasNext(); index++) { 9664 key = (String) iterator.next(); 9665 assertEquals(new Integer(index + 1).toString(), key); 9666 } 9667 assertEquals(108, index); 9668 9669 for (int i = 102; i < 109; i++) { 9670 startKey = new Integer(i).toString(); 9671 9672 tailSet = keySet.tailSet(startKey); 9673 iterator = tailSet.iterator(); 9674 int j; 9675 for (j = i; iterator.hasNext(); j++) { 9676 key = (String) iterator.next(); 9677 assertEquals(new Integer(j).toString(), key); 9678 } 9679 assertEquals(109, j); 9680 9681 tailSet = keySet.tailSet(startKey, true); 9682 iterator = tailSet.iterator(); 9683 for (j = i; iterator.hasNext(); j++) { 9684 key = (String) iterator.next(); 9685 assertEquals(new Integer(j).toString(), key); 9686 } 9687 assertEquals(109, j); 9688 9689 tailSet = keySet.tailSet(startKey, false); 9690 iterator = tailSet.iterator(); 9691 for (j = i; iterator.hasNext(); j++) { 9692 key = (String) iterator.next(); 9693 assertEquals(new Integer(j + 1).toString(), key); 9694 } 9695 assertEquals(108, j); 9696 } 9697 9698 startKey = new Integer(109).toString(); 9699 try { 9700 keySet.tailSet(startKey); 9701 fail("should throw IllegalArgumentException"); 9702 } catch (IllegalArgumentException e) { 9703 // Expected 9704 } 9705 try { 9706 keySet.tailSet(startKey, true); 9707 fail("should throw IllegalArgumentException"); 9708 } catch (IllegalArgumentException e) { 9709 // Expected 9710 } 9711 try { 9712 keySet.tailSet(startKey, false); 9713 fail("should throw IllegalArgumentException"); 9714 } catch (IllegalArgumentException e) { 9715 // Expected 9716 } 9717 9718 startKey = new Integer(110).toString(); 9719 try { 9720 keySet.tailSet(startKey); 9721 fail("should throw IllegalArgumentException"); 9722 } catch (IllegalArgumentException e) { 9723 // Expected 9724 } 9725 try { 9726 keySet.tailSet(startKey, true); 9727 fail("should throw IllegalArgumentException"); 9728 } catch (IllegalArgumentException e) { 9729 // Expected 9730 } 9731 try { 9732 keySet.tailSet(startKey, false); 9733 fail("should throw IllegalArgumentException"); 9734 } catch (IllegalArgumentException e) { 9735 // Expected 9736 } 9737 9738 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 9739 startKey = new Integer(99).toString(); 9740 try { 9741 keySet.tailSet(startKey); 9742 fail("should throw IllegalArgumentException"); 9743 } catch (IllegalArgumentException e) { 9744 // Expected 9745 } 9746 try { 9747 keySet.tailSet(startKey, true); 9748 fail("should throw IllegalArgumentException"); 9749 } catch (IllegalArgumentException e) { 9750 // Expected 9751 } 9752 try { 9753 keySet.tailSet(startKey, false); 9754 fail("should throw IllegalArgumentException"); 9755 } catch (IllegalArgumentException e) { 9756 // Expected 9757 } 9758 startKey = new Integer(100).toString(); 9759 tailSet = keySet.tailSet(startKey); 9760 iterator = tailSet.iterator(); 9761 for (index = 100; iterator.hasNext(); index++) { 9762 key = (String) iterator.next(); 9763 assertEquals(new Integer(index).toString(), key); 9764 } 9765 assertEquals(110, index); 9766 9767 tailSet = keySet.tailSet(startKey, true); 9768 iterator = tailSet.iterator(); 9769 for (index = 100; iterator.hasNext(); index++) { 9770 key = (String) iterator.next(); 9771 assertEquals(new Integer(index).toString(), key); 9772 } 9773 assertEquals(110, index); 9774 9775 tailSet = keySet.tailSet(startKey, false); 9776 iterator = tailSet.iterator(); 9777 for (index = 100; iterator.hasNext(); index++) { 9778 key = (String) iterator.next(); 9779 assertEquals(new Integer(index + 1).toString(), key); 9780 } 9781 assertEquals(109, index); 9782 9783 startKey = new Integer(101).toString(); 9784 tailSet = keySet.tailSet(startKey); 9785 iterator = tailSet.iterator(); 9786 for (index = 101; iterator.hasNext(); index++) { 9787 key = (String) iterator.next(); 9788 assertEquals(new Integer(index).toString(), key); 9789 } 9790 assertEquals(110, index); 9791 9792 tailSet = keySet.tailSet(startKey, true); 9793 iterator = tailSet.iterator(); 9794 for (index = 101; iterator.hasNext(); index++) { 9795 key = (String) iterator.next(); 9796 assertEquals(new Integer(index).toString(), key); 9797 } 9798 assertEquals(110, index); 9799 9800 tailSet = keySet.tailSet(startKey, false); 9801 iterator = tailSet.iterator(); 9802 for (index = 101; iterator.hasNext(); index++) { 9803 key = (String) iterator.next(); 9804 assertEquals(new Integer(index + 1).toString(), key); 9805 } 9806 assertEquals(109, index); 9807 9808 for (int i = 102; i < 109; i++) { 9809 startKey = new Integer(i).toString(); 9810 9811 tailSet = keySet.tailSet(startKey); 9812 iterator = tailSet.iterator(); 9813 int j; 9814 for (j = i; iterator.hasNext(); j++) { 9815 key = (String) iterator.next(); 9816 assertEquals(new Integer(j).toString(), key); 9817 } 9818 assertEquals(110, j); 9819 9820 tailSet = keySet.tailSet(startKey, true); 9821 iterator = tailSet.iterator(); 9822 for (j = i; iterator.hasNext(); j++) { 9823 key = (String) iterator.next(); 9824 assertEquals(new Integer(j).toString(), key); 9825 } 9826 assertEquals(110, j); 9827 9828 tailSet = keySet.tailSet(startKey, false); 9829 iterator = tailSet.iterator(); 9830 for (j = i; iterator.hasNext(); j++) { 9831 key = (String) iterator.next(); 9832 assertEquals(new Integer(j + 1).toString(), key); 9833 } 9834 assertEquals(109, j); 9835 } 9836 9837 startKey = new Integer(109).toString(); 9838 tailSet = keySet.tailSet(startKey); 9839 iterator = tailSet.iterator(); 9840 for (index = 109; iterator.hasNext(); index++) { 9841 key = (String) iterator.next(); 9842 assertEquals(new Integer(index).toString(), key); 9843 } 9844 assertEquals(110, index); 9845 9846 tailSet = keySet.tailSet(startKey, true); 9847 iterator = tailSet.iterator(); 9848 for (index = 109; iterator.hasNext(); index++) { 9849 key = (String) iterator.next(); 9850 assertEquals(new Integer(index).toString(), key); 9851 } 9852 assertEquals(110, index); 9853 9854 tailSet = keySet.tailSet(startKey, false); 9855 iterator = tailSet.iterator(); 9856 for (index = 109; iterator.hasNext(); index++) { 9857 key = (String) iterator.next(); 9858 assertEquals(new Integer(index + 1).toString(), key); 9859 } 9860 assertEquals(109, index); 9861 9862 startKey = new Integer(110).toString(); 9863 try { 9864 keySet.tailSet(startKey); 9865 fail("should throw IllegalArgumentException"); 9866 } catch (IllegalArgumentException e) { 9867 // Expected 9868 } 9869 try { 9870 keySet.tailSet(startKey, true); 9871 fail("should throw IllegalArgumentException"); 9872 } catch (IllegalArgumentException e) { 9873 // Expected 9874 } 9875 try { 9876 keySet.tailSet(startKey, false); 9877 fail("should throw IllegalArgumentException"); 9878 } catch (IllegalArgumentException e) { 9879 // Expected 9880 } 9881 9882 String endKey = new Integer(1).toString(); 9883 keySet = tm.headMap(endKey, true).navigableKeySet(); 9884 iterator = keySet.iterator(); 9885 iterator.next(); 9886 startKey = (String) iterator.next(); 9887 tailSet = keySet.tailSet(startKey); 9888 assertEquals(1, tailSet.size()); 9889 Iterator tailSetIterator = tailSet.iterator(); 9890 assertEquals(endKey, tailSetIterator.next()); 9891 try { 9892 tailSetIterator.next(); 9893 fail("should throw NoSuchElementException"); 9894 } catch (NoSuchElementException e) { 9895 // Expected 9896 } 9897 try { 9898 keySet.tailSet(null); 9899 fail("should throw NPE"); 9900 } catch (NullPointerException e) { 9901 // Expected 9902 } 9903 9904 tailSet = keySet.tailSet(startKey, true); 9905 assertEquals(1, tailSet.size()); 9906 tailSetIterator = tailSet.iterator(); 9907 assertEquals(endKey, tailSetIterator.next()); 9908 9909 tailSet = keySet.tailSet(startKey, false); 9910 assertEquals(0, tailSet.size()); 9911 tailSetIterator = tailSet.iterator(); 9912 try { 9913 tailSetIterator.next(); 9914 fail("should throw NoSuchElementException"); 9915 } catch (NoSuchElementException e) { 9916 // Expected 9917 } 9918 try { 9919 keySet.tailSet(null, false); 9920 fail("should throw NPE"); 9921 } catch (NullPointerException e) { 9922 // Expected 9923 } 9924 try { 9925 keySet.tailSet(null, true); 9926 fail("should throw NPE"); 9927 } catch (NullPointerException e) { 9928 // Expected 9929 } 9930 9931 // With Comparator 9932 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 9933 .navigableKeySet(); 9934 startKey = new Integer(99).toString(); 9935 try { 9936 keySet.tailSet(startKey); 9937 fail("should throw IllegalArgumentException"); 9938 } catch (IllegalArgumentException e) { 9939 // Expected 9940 } 9941 9942 try { 9943 keySet.tailSet(startKey, true); 9944 fail("should throw IllegalArgumentException"); 9945 } catch (IllegalArgumentException e) { 9946 // Expected 9947 } 9948 9949 try { 9950 keySet.tailSet(startKey, false); 9951 fail("should throw IllegalArgumentException"); 9952 } catch (IllegalArgumentException e) { 9953 // Expected 9954 } 9955 9956 startKey = new Integer(100).toString(); 9957 try { 9958 keySet.tailSet(startKey); 9959 fail("should throw IllegalArgumentException"); 9960 } catch (IllegalArgumentException e) { 9961 // Expected 9962 } 9963 try { 9964 keySet.tailSet(startKey, true); 9965 fail("should throw IllegalArgumentException"); 9966 } catch (IllegalArgumentException e) { 9967 // Expected 9968 } 9969 tailSet = keySet.tailSet(startKey, false); 9970 iterator = tailSet.iterator(); 9971 for (index = 101; index < 109; index++) { 9972 key = (String) iterator.next(); 9973 assertEquals(new Integer(index).toString(), key); 9974 } 9975 9976 startKey = new Integer(101).toString(); 9977 tailSet = keySet.tailSet(startKey); 9978 iterator = tailSet.iterator(); 9979 for (index = 101; iterator.hasNext(); index++) { 9980 key = (String) iterator.next(); 9981 assertEquals(new Integer(index).toString(), key); 9982 } 9983 assertEquals(109, index); 9984 9985 tailSet = keySet.tailSet(startKey, true); 9986 iterator = tailSet.iterator(); 9987 for (index = 101; iterator.hasNext(); index++) { 9988 key = (String) iterator.next(); 9989 assertEquals(new Integer(index).toString(), key); 9990 } 9991 assertEquals(109, index); 9992 9993 tailSet = keySet.tailSet(startKey, false); 9994 iterator = tailSet.iterator(); 9995 for (index = 101; iterator.hasNext(); index++) { 9996 key = (String) iterator.next(); 9997 assertEquals(new Integer(index + 1).toString(), key); 9998 } 9999 assertEquals(108, index); 10000 10001 for (int i = 102; i < 109; i++) { 10002 startKey = new Integer(i).toString(); 10003 10004 tailSet = keySet.tailSet(startKey); 10005 iterator = tailSet.iterator(); 10006 int j; 10007 for (j = i; iterator.hasNext(); j++) { 10008 key = (String) iterator.next(); 10009 assertEquals(new Integer(j).toString(), key); 10010 } 10011 assertEquals(109, j); 10012 10013 tailSet = keySet.tailSet(startKey, true); 10014 iterator = tailSet.iterator(); 10015 for (j = i; iterator.hasNext(); j++) { 10016 key = (String) iterator.next(); 10017 assertEquals(new Integer(j).toString(), key); 10018 } 10019 assertEquals(109, j); 10020 10021 tailSet = keySet.tailSet(startKey, false); 10022 iterator = tailSet.iterator(); 10023 for (j = i; iterator.hasNext(); j++) { 10024 key = (String) iterator.next(); 10025 assertEquals(new Integer(j + 1).toString(), key); 10026 } 10027 assertEquals(108, j); 10028 } 10029 10030 startKey = new Integer(109).toString(); 10031 try { 10032 keySet.tailSet(startKey); 10033 fail("should throw IllegalArgumentException"); 10034 } catch (IllegalArgumentException e) { 10035 // Expected 10036 } 10037 try { 10038 keySet.tailSet(startKey, true); 10039 fail("should throw IllegalArgumentException"); 10040 } catch (IllegalArgumentException e) { 10041 // Expected 10042 } 10043 try { 10044 keySet.tailSet(startKey, false); 10045 fail("should throw IllegalArgumentException"); 10046 } catch (IllegalArgumentException e) { 10047 // Expected 10048 } 10049 10050 startKey = new Integer(110).toString(); 10051 try { 10052 keySet.tailSet(startKey); 10053 fail("should throw IllegalArgumentException"); 10054 } catch (IllegalArgumentException e) { 10055 // Expected 10056 } 10057 try { 10058 keySet.tailSet(startKey, true); 10059 fail("should throw IllegalArgumentException"); 10060 } catch (IllegalArgumentException e) { 10061 // Expected 10062 } 10063 try { 10064 keySet.tailSet(startKey, false); 10065 fail("should throw IllegalArgumentException"); 10066 } catch (IllegalArgumentException e) { 10067 // Expected 10068 } 10069 10070 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10071 startKey = new Integer(99).toString(); 10072 try { 10073 keySet.tailSet(startKey); 10074 fail("should throw IllegalArgumentException"); 10075 } catch (IllegalArgumentException e) { 10076 // Expected 10077 } 10078 try { 10079 keySet.tailSet(startKey, true); 10080 fail("should throw IllegalArgumentException"); 10081 } catch (IllegalArgumentException e) { 10082 // Expected 10083 } 10084 try { 10085 keySet.tailSet(startKey, false); 10086 fail("should throw IllegalArgumentException"); 10087 } catch (IllegalArgumentException e) { 10088 // Expected 10089 } 10090 10091 startKey = new Integer(100).toString(); 10092 try { 10093 keySet.tailSet(startKey); 10094 fail("should throw IllegalArgumentException"); 10095 } catch (IllegalArgumentException e) { 10096 // Expected 10097 } 10098 try { 10099 keySet.tailSet(startKey, true); 10100 fail("should throw IllegalArgumentException"); 10101 } catch (IllegalArgumentException e) { 10102 // Expected 10103 } 10104 10105 tailSet = keySet.tailSet(startKey, false); 10106 iterator = tailSet.iterator(); 10107 for (index = 100; iterator.hasNext(); index++) { 10108 key = (String) iterator.next(); 10109 assertEquals(new Integer(index + 1).toString(), key); 10110 } 10111 assertEquals(109, index); 10112 10113 for (int i = 102; i < 109; i++) { 10114 startKey = new Integer(i).toString(); 10115 10116 tailSet = keySet.tailSet(startKey); 10117 iterator = tailSet.iterator(); 10118 int j; 10119 for (j = i; iterator.hasNext(); j++) { 10120 key = (String) iterator.next(); 10121 assertEquals(new Integer(j).toString(), key); 10122 } 10123 assertEquals(110, j); 10124 10125 tailSet = keySet.tailSet(startKey, true); 10126 iterator = tailSet.iterator(); 10127 for (j = i; iterator.hasNext(); j++) { 10128 key = (String) iterator.next(); 10129 assertEquals(new Integer(j).toString(), key); 10130 } 10131 assertEquals(110, j); 10132 10133 tailSet = keySet.tailSet(startKey, false); 10134 iterator = tailSet.iterator(); 10135 for (j = i; iterator.hasNext(); j++) { 10136 key = (String) iterator.next(); 10137 assertEquals(new Integer(j + 1).toString(), key); 10138 } 10139 assertEquals(109, j); 10140 } 10141 10142 startKey = new Integer(109).toString(); 10143 tailSet = keySet.tailSet(startKey); 10144 iterator = tailSet.iterator(); 10145 for (index = 109; iterator.hasNext(); index++) { 10146 key = (String) iterator.next(); 10147 assertEquals(new Integer(index).toString(), key); 10148 } 10149 assertEquals(110, index); 10150 10151 tailSet = keySet.tailSet(startKey, true); 10152 iterator = tailSet.iterator(); 10153 for (index = 109; iterator.hasNext(); index++) { 10154 key = (String) iterator.next(); 10155 assertEquals(new Integer(index).toString(), key); 10156 } 10157 assertEquals(110, index); 10158 10159 tailSet = keySet.tailSet(startKey, false); 10160 iterator = tailSet.iterator(); 10161 for (index = 109; iterator.hasNext(); index++) { 10162 key = (String) iterator.next(); 10163 assertEquals(new Integer(index + 1).toString(), key); 10164 } 10165 assertEquals(109, index); 10166 10167 startKey = new Integer(110).toString(); 10168 try { 10169 keySet.tailSet(startKey); 10170 fail("should throw IllegalArgumentException"); 10171 } catch (IllegalArgumentException e) { 10172 // Expected 10173 } 10174 try { 10175 keySet.tailSet(startKey, true); 10176 fail("should throw IllegalArgumentException"); 10177 } catch (IllegalArgumentException e) { 10178 // Expected 10179 } 10180 try { 10181 keySet.tailSet(startKey, false); 10182 fail("should throw IllegalArgumentException"); 10183 } catch (IllegalArgumentException e) { 10184 // Expected 10185 } 10186 } 10187 10188 public void test_AscendingSubMapKeySet_subSet() { 10189 NavigableSet keySet; 10190 SortedSet subSet; 10191 String startKey, endKey, key; 10192 Iterator startIterator, endIterator, subSetIterator; 10193 10194 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10195 startIterator = keySet.iterator(); 10196 while (startIterator.hasNext()) { 10197 startKey = (String) startIterator.next(); 10198 endIterator = keySet.iterator(); 10199 while (endIterator.hasNext()) { 10200 endKey = (String) endIterator.next(); 10201 int startIndex = Integer.valueOf(startKey); 10202 int endIndex = Integer.valueOf(endKey); 10203 if (startIndex > endIndex) { 10204 try { 10205 keySet.subSet(startKey, endKey); 10206 fail("should throw IllegalArgumentException"); 10207 } catch (IllegalArgumentException e) { 10208 // Expected 10209 } 10210 10211 try { 10212 keySet.subSet(startKey, false, endKey, false); 10213 fail("shoudl throw IllegalArgumentException"); 10214 } catch (IllegalArgumentException e) { 10215 // Expected 10216 } 10217 10218 try { 10219 keySet.subSet(startKey, false, endKey, true); 10220 fail("shoudl throw IllegalArgumentException"); 10221 } catch (IllegalArgumentException e) { 10222 // Expected 10223 } 10224 10225 try { 10226 keySet.subSet(startKey, true, endKey, false); 10227 fail("shoudl throw IllegalArgumentException"); 10228 } catch (IllegalArgumentException e) { 10229 // Expected 10230 } 10231 10232 try { 10233 keySet.subSet(startKey, true, endKey, true); 10234 fail("shoudl throw IllegalArgumentException"); 10235 } catch (IllegalArgumentException e) { 10236 // Expected 10237 } 10238 } else { 10239 subSet = keySet.subSet(startKey, endKey); 10240 subSetIterator = subSet.iterator(); 10241 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10242 assertEquals(new Integer(index).toString(), 10243 subSetIterator.next()); 10244 } 10245 10246 subSet = keySet.subSet(startKey, false, endKey, false); 10247 subSetIterator = subSet.iterator(); 10248 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10249 assertEquals(new Integer(index).toString(), 10250 subSetIterator.next()); 10251 } 10252 10253 subSet = keySet.subSet(startKey, false, endKey, true); 10254 subSetIterator = subSet.iterator(); 10255 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10256 assertEquals(new Integer(index).toString(), 10257 subSetIterator.next()); 10258 } 10259 10260 subSet = keySet.subSet(startKey, true, endKey, false); 10261 subSetIterator = subSet.iterator(); 10262 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10263 assertEquals(new Integer(index).toString(), 10264 subSetIterator.next()); 10265 } 10266 10267 subSet = keySet.subSet(startKey, true, endKey, true); 10268 subSetIterator = subSet.iterator(); 10269 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10270 assertEquals(new Integer(index).toString(), 10271 subSetIterator.next()); 10272 } 10273 } 10274 } 10275 } 10276 10277 key = new Integer(1).toString(); 10278 keySet = tm.headMap(key, true).navigableKeySet(); 10279 Iterator iterator = keySet.iterator(); 10280 startKey = (String) iterator.next(); 10281 endKey = (String) iterator.next(); 10282 10283 subSet = keySet.subSet(startKey, endKey); 10284 assertEquals(1, subSet.size()); 10285 subSetIterator = subSet.iterator(); 10286 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10287 try { 10288 subSetIterator.next(); 10289 fail("should throw NoSuchElementException"); 10290 } catch (NoSuchElementException e) { 10291 // Expected 10292 } 10293 10294 subSet = keySet.subSet(startKey, false, endKey, false); 10295 assertEquals(0, subSet.size()); 10296 10297 subSet = keySet.subSet(startKey, false, endKey, true); 10298 assertEquals(1, subSet.size()); 10299 subSetIterator = subSet.iterator(); 10300 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10301 try { 10302 subSetIterator.next(); 10303 fail("should throw NoSuchElementException"); 10304 } catch (NoSuchElementException e) { 10305 // Expected 10306 } 10307 10308 subSet = keySet.subSet(startKey, true, endKey, false); 10309 assertEquals(1, subSet.size()); 10310 subSetIterator = subSet.iterator(); 10311 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10312 try { 10313 subSetIterator.next(); 10314 fail("should throw NoSuchElementException"); 10315 } catch (NoSuchElementException e) { 10316 // Expected 10317 } 10318 10319 subSet = keySet.subSet(startKey, true, endKey, true); 10320 assertEquals(2, subSet.size()); 10321 subSetIterator = subSet.iterator(); 10322 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10323 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10324 try { 10325 subSetIterator.next(); 10326 fail("should throw NoSuchElementException"); 10327 } catch (NoSuchElementException e) { 10328 // Expected 10329 } 10330 10331 try { 10332 keySet.subSet(null, null); 10333 fail("should throw NPE"); 10334 } catch (NullPointerException e) { 10335 // Expected 10336 } 10337 10338 try { 10339 keySet.subSet(null, false, null, false); 10340 fail("should throw NPE"); 10341 } catch (NullPointerException e) { 10342 // Expected 10343 } 10344 10345 try { 10346 keySet.subSet(null, false, null, true); 10347 fail("should throw NPE"); 10348 } catch (NullPointerException e) { 10349 // Expected 10350 } 10351 10352 try { 10353 keySet.subSet(null, true, null, false); 10354 fail("should throw NPE"); 10355 } catch (NullPointerException e) { 10356 // Expected 10357 } 10358 10359 try { 10360 keySet.subSet(null, true, null, true); 10361 fail("should throw NPE"); 10362 } catch (NullPointerException e) { 10363 // Expected 10364 } 10365 10366 try { 10367 keySet.subSet(null, endKey); 10368 fail("should throw NPE"); 10369 } catch (NullPointerException e) { 10370 // Expected 10371 } 10372 10373 try { 10374 keySet.subSet(null, false, endKey, false); 10375 fail("should throw NPE"); 10376 } catch (NullPointerException e) { 10377 // Expected 10378 } 10379 10380 try { 10381 keySet.subSet(null, false, endKey, true); 10382 fail("should throw NPE"); 10383 } catch (NullPointerException e) { 10384 // Expected 10385 } 10386 10387 try { 10388 keySet.subSet(null, true, endKey, false); 10389 fail("should throw NPE"); 10390 } catch (NullPointerException e) { 10391 // Expected 10392 } 10393 10394 try { 10395 keySet.subSet(null, true, endKey, true); 10396 fail("should throw NPE"); 10397 } catch (NullPointerException e) { 10398 // Expected 10399 } 10400 10401 try { 10402 keySet.subSet(startKey, null); 10403 fail("should throw NPE"); 10404 } catch (NullPointerException e) { 10405 // Expected 10406 } 10407 10408 try { 10409 keySet.subSet(startKey, false, null, false); 10410 fail("should throw NPE"); 10411 } catch (NullPointerException e) { 10412 // Expected 10413 } 10414 10415 try { 10416 keySet.subSet(startKey, false, null, true); 10417 fail("should throw NPE"); 10418 } catch (NullPointerException e) { 10419 // Expected 10420 } 10421 10422 try { 10423 keySet.subSet(startKey, true, null, false); 10424 fail("should throw NPE"); 10425 } catch (NullPointerException e) { 10426 // Expected 10427 } 10428 10429 try { 10430 keySet.subSet(startKey, true, null, true); 10431 fail("should throw NPE"); 10432 } catch (NullPointerException e) { 10433 // Expected 10434 } 10435 10436 // With Comparator 10437 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 10438 .navigableKeySet(); 10439 startIterator = keySet.iterator(); 10440 while (startIterator.hasNext()) { 10441 startKey = (String) startIterator.next(); 10442 endIterator = keySet.iterator(); 10443 while (endIterator.hasNext()) { 10444 endKey = (String) endIterator.next(); 10445 int startIndex = Integer.valueOf(startKey); 10446 int endIndex = Integer.valueOf(endKey); 10447 if (startIndex > endIndex) { 10448 try { 10449 keySet.subSet(startKey, endKey); 10450 fail("should throw IllegalArgumentException"); 10451 } catch (IllegalArgumentException e) { 10452 // Expected 10453 } 10454 10455 try { 10456 keySet.subSet(startKey, false, endKey, false); 10457 fail("shoudl throw IllegalArgumentException"); 10458 } catch (IllegalArgumentException e) { 10459 // Expected 10460 } 10461 10462 try { 10463 keySet.subSet(startKey, false, endKey, true); 10464 fail("shoudl throw IllegalArgumentException"); 10465 } catch (IllegalArgumentException e) { 10466 // Expected 10467 } 10468 10469 try { 10470 keySet.subSet(startKey, true, endKey, false); 10471 fail("shoudl throw IllegalArgumentException"); 10472 } catch (IllegalArgumentException e) { 10473 // Expected 10474 } 10475 10476 try { 10477 keySet.subSet(startKey, true, endKey, true); 10478 fail("shoudl throw IllegalArgumentException"); 10479 } catch (IllegalArgumentException e) { 10480 // Expected 10481 } 10482 } else { 10483 subSet = keySet.subSet(startKey, endKey); 10484 subSetIterator = subSet.iterator(); 10485 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10486 assertEquals(new Integer(index).toString(), 10487 subSetIterator.next()); 10488 } 10489 10490 subSet = keySet.subSet(startKey, false, endKey, false); 10491 subSetIterator = subSet.iterator(); 10492 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10493 assertEquals(new Integer(index).toString(), 10494 subSetIterator.next()); 10495 } 10496 10497 subSet = keySet.subSet(startKey, false, endKey, true); 10498 subSetIterator = subSet.iterator(); 10499 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10500 assertEquals(new Integer(index).toString(), 10501 subSetIterator.next()); 10502 } 10503 10504 subSet = keySet.subSet(startKey, true, endKey, false); 10505 subSetIterator = subSet.iterator(); 10506 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10507 assertEquals(new Integer(index).toString(), 10508 subSetIterator.next()); 10509 } 10510 10511 subSet = keySet.subSet(startKey, true, endKey, true); 10512 subSetIterator = subSet.iterator(); 10513 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10514 assertEquals(new Integer(index).toString(), 10515 subSetIterator.next()); 10516 } 10517 } 10518 } 10519 } 10520 10521 key = new Integer(1).toString(); 10522 keySet = tm.headMap(key, true).navigableKeySet(); 10523 iterator = keySet.iterator(); 10524 startKey = (String) iterator.next(); 10525 endKey = (String) iterator.next(); 10526 10527 subSet = keySet.subSet(startKey, endKey); 10528 assertEquals(1, subSet.size()); 10529 subSetIterator = subSet.iterator(); 10530 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10531 try { 10532 subSetIterator.next(); 10533 fail("should throw NoSuchElementException"); 10534 } catch (NoSuchElementException e) { 10535 // Expected 10536 } 10537 10538 subSet = keySet.subSet(startKey, false, endKey, false); 10539 assertEquals(0, subSet.size()); 10540 10541 subSet = keySet.subSet(startKey, false, endKey, true); 10542 assertEquals(1, subSet.size()); 10543 subSetIterator = subSet.iterator(); 10544 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10545 try { 10546 subSetIterator.next(); 10547 fail("should throw NoSuchElementException"); 10548 } catch (NoSuchElementException e) { 10549 // Expected 10550 } 10551 10552 subSet = keySet.subSet(startKey, true, endKey, false); 10553 assertEquals(1, subSet.size()); 10554 subSetIterator = subSet.iterator(); 10555 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10556 try { 10557 subSetIterator.next(); 10558 fail("should throw NoSuchElementException"); 10559 } catch (NoSuchElementException e) { 10560 // Expected 10561 } 10562 10563 subSet = keySet.subSet(startKey, true, endKey, true); 10564 assertEquals(2, subSet.size()); 10565 subSetIterator = subSet.iterator(); 10566 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10567 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10568 try { 10569 subSetIterator.next(); 10570 fail("should throw NoSuchElementException"); 10571 } catch (NoSuchElementException e) { 10572 // Expected 10573 } 10574 10575 try { 10576 keySet.subSet(null, null); 10577 fail("should throw NPE"); 10578 } catch (NullPointerException e) { 10579 // Expected 10580 } 10581 10582 try { 10583 keySet.subSet(null, false, null, false); 10584 fail("should throw NPE"); 10585 } catch (NullPointerException e) { 10586 // Expected 10587 } 10588 10589 try { 10590 keySet.subSet(null, false, null, true); 10591 fail("should throw NPE"); 10592 } catch (NullPointerException e) { 10593 // Expected 10594 } 10595 10596 try { 10597 keySet.subSet(null, true, null, false); 10598 fail("should throw NPE"); 10599 } catch (NullPointerException e) { 10600 // Expected 10601 } 10602 10603 try { 10604 keySet.subSet(null, true, null, true); 10605 fail("should throw NPE"); 10606 } catch (NullPointerException e) { 10607 // Expected 10608 } 10609 10610 try { 10611 keySet.subSet(null, endKey); 10612 fail("should throw NPE"); 10613 } catch (NullPointerException e) { 10614 // Expected 10615 } 10616 10617 try { 10618 keySet.subSet(null, false, endKey, false); 10619 fail("should throw NPE"); 10620 } catch (NullPointerException e) { 10621 // Expected 10622 } 10623 10624 try { 10625 keySet.subSet(null, false, endKey, true); 10626 fail("should throw NPE"); 10627 } catch (NullPointerException e) { 10628 // Expected 10629 } 10630 10631 try { 10632 keySet.subSet(null, true, endKey, false); 10633 fail("should throw NPE"); 10634 } catch (NullPointerException e) { 10635 // Expected 10636 } 10637 10638 try { 10639 keySet.subSet(null, true, endKey, true); 10640 fail("should throw NPE"); 10641 } catch (NullPointerException e) { 10642 // Expected 10643 } 10644 10645 try { 10646 keySet.subSet(startKey, null); 10647 fail("should throw NPE"); 10648 } catch (NullPointerException e) { 10649 // Expected 10650 } 10651 10652 try { 10653 keySet.subSet(startKey, false, null, false); 10654 fail("should throw NPE"); 10655 } catch (NullPointerException e) { 10656 // Expected 10657 } 10658 10659 try { 10660 keySet.subSet(startKey, false, null, true); 10661 fail("should throw NPE"); 10662 } catch (NullPointerException e) { 10663 // Expected 10664 } 10665 10666 try { 10667 keySet.subSet(startKey, true, null, false); 10668 fail("should throw NPE"); 10669 } catch (NullPointerException e) { 10670 // Expected 10671 } 10672 10673 try { 10674 keySet.subSet(startKey, true, null, true); 10675 fail("should throw NPE"); 10676 } catch (NullPointerException e) { 10677 // Expected 10678 } 10679 10680 } 10681 10682 public void test_AscendingSubMapKeySet_lower() { 10683 NavigableSet keySet; 10684 Iterator iterator; 10685 String key, lowerKey; 10686 int value, lowerValue; 10687 10688 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10689 iterator = keySet.iterator(); 10690 while (iterator.hasNext()) { 10691 key = (String) iterator.next(); 10692 value = Integer.valueOf(key); 10693 lowerKey = (String) keySet.lower(key); 10694 if (value > 101) { 10695 lowerValue = Integer.valueOf(lowerKey); 10696 assertEquals(value - 1, lowerValue); 10697 } else { 10698 assertNull(lowerKey); 10699 } 10700 } 10701 10702 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10703 iterator = keySet.iterator(); 10704 while (iterator.hasNext()) { 10705 key = (String) iterator.next(); 10706 value = Integer.valueOf(key); 10707 lowerKey = (String) keySet.lower(key); 10708 if (value > 101) { 10709 lowerValue = Integer.valueOf(lowerKey); 10710 assertEquals(value - 1, lowerValue); 10711 } else { 10712 assertNull(lowerKey); 10713 } 10714 } 10715 10716 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10717 iterator = keySet.iterator(); 10718 while (iterator.hasNext()) { 10719 key = (String) iterator.next(); 10720 value = Integer.valueOf(key); 10721 lowerKey = (String) keySet.lower(key); 10722 if (value > 100) { 10723 lowerValue = Integer.valueOf(lowerKey); 10724 assertEquals(value - 1, lowerValue); 10725 } else { 10726 assertNull(lowerKey); 10727 } 10728 } 10729 10730 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10731 iterator = keySet.iterator(); 10732 while (iterator.hasNext()) { 10733 key = (String) iterator.next(); 10734 value = Integer.valueOf(key); 10735 lowerKey = (String) keySet.lower(key); 10736 if (value > 100) { 10737 lowerValue = Integer.valueOf(lowerKey); 10738 assertEquals(value - 1, lowerValue); 10739 } else { 10740 assertNull(lowerKey); 10741 } 10742 } 10743 10744 key = new Integer(2).toString(); 10745 keySet = tm.headMap(key, true).navigableKeySet(); 10746 iterator = keySet.iterator(); 10747 iterator.next();// 0 10748 String expectedLowerKey = (String) iterator.next();// 1 10749 assertEquals(expectedLowerKey, keySet.lower(iterator.next())); 10750 10751 try { 10752 keySet.lower(null); 10753 fail("should throw NPE"); 10754 } catch (NullPointerException e) { 10755 // Expected 10756 } 10757 10758 key = new Integer(0).toString(); 10759 keySet = tm.headMap(key, true).navigableKeySet(); 10760 assertNull(keySet.lower(key)); 10761 10762 key = new Integer(0).toString(); 10763 keySet = tm.headMap(key, false).navigableKeySet(); 10764 assertNull(keySet.lower(key)); 10765 10766 key = new Integer(999).toString(); 10767 keySet = tm.headMap(key, true).navigableKeySet(); 10768 assertNotNull(keySet.lower(key)); 10769 10770 key = new Integer(999).toString(); 10771 keySet = tm.headMap(key, false).navigableKeySet(); 10772 assertNotNull(keySet.lower(key)); 10773 } 10774 10775 public void test_AscendingSubMapKeySet_higher() { 10776 NavigableSet keySet; 10777 Iterator iterator; 10778 String key, lowerKey; 10779 int value, lowerValue; 10780 10781 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10782 iterator = keySet.iterator(); 10783 while (iterator.hasNext()) { 10784 key = (String) iterator.next(); 10785 value = Integer.valueOf(key); 10786 lowerKey = (String) keySet.higher(key); 10787 if (value < 108) { 10788 lowerValue = Integer.valueOf(lowerKey); 10789 assertEquals(value + 1, lowerValue); 10790 } else { 10791 assertNull(lowerKey); 10792 } 10793 } 10794 10795 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10796 iterator = keySet.iterator(); 10797 while (iterator.hasNext()) { 10798 key = (String) iterator.next(); 10799 value = Integer.valueOf(key); 10800 lowerKey = (String) keySet.higher(key); 10801 if (value < 109) { 10802 lowerValue = Integer.valueOf(lowerKey); 10803 assertEquals(value + 1, lowerValue); 10804 } else { 10805 assertNull(lowerKey); 10806 } 10807 } 10808 10809 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10810 iterator = keySet.iterator(); 10811 while (iterator.hasNext()) { 10812 key = (String) iterator.next(); 10813 value = Integer.valueOf(key); 10814 lowerKey = (String) keySet.higher(key); 10815 if (value < 108) { 10816 lowerValue = Integer.valueOf(lowerKey); 10817 assertEquals(value + 1, lowerValue); 10818 } else { 10819 assertNull(lowerKey); 10820 } 10821 } 10822 10823 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10824 iterator = keySet.iterator(); 10825 while (iterator.hasNext()) { 10826 key = (String) iterator.next(); 10827 value = Integer.valueOf(key); 10828 lowerKey = (String) keySet.higher(key); 10829 if (value < 109) { 10830 lowerValue = Integer.valueOf(lowerKey); 10831 assertEquals(value + 1, lowerValue); 10832 } else { 10833 assertNull(lowerKey); 10834 } 10835 } 10836 10837 key = new Integer(2).toString(); 10838 keySet = tm.headMap(key, true).navigableKeySet(); 10839 iterator = keySet.iterator(); 10840 iterator.next();// 0 10841 iterator.next();// 1 10842 lowerKey = (String) keySet.higher(iterator.next()); 10843 String expectedLowerKey = (String) iterator.next(); 10844 assertEquals(expectedLowerKey, lowerKey); 10845 10846 try { 10847 keySet.higher(null); 10848 fail("should throw NPE"); 10849 } catch (NullPointerException e) { 10850 // Expected 10851 } 10852 10853 key = new Integer(0).toString(); 10854 keySet = tm.headMap(key, true).navigableKeySet(); 10855 assertNull(keySet.higher(key)); 10856 10857 key = new Integer(0).toString(); 10858 keySet = tm.headMap(key, false).navigableKeySet(); 10859 assertNull(keySet.higher(key)); 10860 10861 key = new Integer(999).toString(); 10862 keySet = tm.headMap(key, true).navigableKeySet(); 10863 assertNull(keySet.higher(key)); 10864 10865 key = new Integer(999).toString(); 10866 keySet = tm.headMap(key, false).navigableKeySet(); 10867 assertNull(keySet.higher(key)); 10868 } 10869 10870 public void test_AscendingSubMapKeySet_ceiling() { 10871 NavigableSet keySet; 10872 String key; 10873 String[] keyArray; 10874 10875 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10876 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10877 for (int i = 0, j = 101; i < keyArray.length; i++) { 10878 key = (String) keySet.ceiling(keyArray[i]); 10879 assertEquals(new Integer(i + j).toString(), key); 10880 } 10881 10882 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10883 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10884 for (int i = 0, j = 101; i < keyArray.length; i++) { 10885 key = (String) keySet.ceiling(keyArray[i]); 10886 assertEquals(new Integer(i + j).toString(), key); 10887 } 10888 10889 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10890 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10891 for (int i = 0, j = 100; i < keyArray.length; i++) { 10892 key = (String) keySet.ceiling(keyArray[i]); 10893 assertEquals(new Integer(i + j).toString(), key); 10894 } 10895 10896 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10897 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10898 for (int i = 0, j = 100; i < keyArray.length; i++) { 10899 key = (String) keySet.ceiling(keyArray[i]); 10900 assertEquals(new Integer(i + j).toString(), key); 10901 } 10902 10903 key = new Integer(2).toString(); 10904 keySet = tm.headMap(key, true).navigableKeySet(); 10905 Iterator iterator = keySet.iterator(); 10906 iterator.next(); 10907 assertEquals(new Integer(1).toString(), keySet.ceiling(iterator.next())); 10908 10909 try { 10910 keySet.ceiling(null); 10911 fail("should throw NPE"); 10912 } catch (NullPointerException e) { 10913 // Expected 10914 } 10915 10916 key = new Integer(0).toString(); 10917 keySet = tm.headMap(key, true).navigableKeySet(); 10918 assertEquals(key, keySet.ceiling(key)); 10919 10920 key = new Integer(0).toString(); 10921 keySet = tm.headMap(key, false).navigableKeySet(); 10922 assertNull(keySet.higher(key)); 10923 10924 key = new Integer(999).toString(); 10925 keySet = tm.headMap(key, true).navigableKeySet(); 10926 assertNull(keySet.higher(key)); 10927 10928 key = new Integer(999).toString(); 10929 keySet = tm.headMap(key, false).navigableKeySet(); 10930 assertNull(keySet.higher(key)); 10931 } 10932 10933 public void test_AscendingSubMapKeySet_floor() { 10934 NavigableSet keySet; 10935 String key; 10936 String[] keyArray; 10937 10938 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10939 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10940 for (int i = 0, j = 101; i < keyArray.length; i++) { 10941 key = (String) keySet.floor(keyArray[i]); 10942 assertEquals(new Integer(i + j).toString(), key); 10943 } 10944 10945 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10946 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10947 for (int i = 0, j = 101; i < keyArray.length; i++) { 10948 key = (String) keySet.floor(keyArray[i]); 10949 assertEquals(new Integer(i + j).toString(), key); 10950 } 10951 10952 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10953 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10954 for (int i = 0, j = 100; i < keyArray.length; i++) { 10955 key = (String) keySet.floor(keyArray[i]); 10956 assertEquals(new Integer(i + j).toString(), key); 10957 } 10958 10959 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10960 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10961 for (int i = 0, j = 100; i < keyArray.length; i++) { 10962 key = (String) keySet.floor(keyArray[i]); 10963 assertEquals(new Integer(i + j).toString(), key); 10964 } 10965 10966 key = new Integer(2).toString(); 10967 keySet = tm.headMap(key, true).navigableKeySet(); 10968 Iterator iterator = keySet.iterator(); 10969 iterator.next(); 10970 assertEquals(new Integer(1).toString(), keySet.floor(iterator.next())); 10971 10972 try { 10973 keySet.floor(null); 10974 fail("should throw NPE"); 10975 } catch (NullPointerException e) { 10976 // Expected 10977 } 10978 10979 key = new Integer(0).toString(); 10980 keySet = tm.headMap(key, true).navigableKeySet(); 10981 assertEquals(key, keySet.floor(key)); 10982 10983 key = new Integer(0).toString(); 10984 keySet = tm.headMap(key, false).navigableKeySet(); 10985 assertNull(keySet.floor(key)); 10986 10987 key = new Integer(999).toString(); 10988 keySet = tm.headMap(key, true).navigableKeySet(); 10989 assertEquals(key, keySet.floor(key)); 10990 10991 key = new Integer(999).toString(); 10992 keySet = tm.headMap(key, false).navigableKeySet(); 10993 assertEquals(new Integer(998).toString(), keySet.floor(key)); 10994 } 10995 10996 public void test_BoundedEntryIterator_next() { 10997 Iterator iterator = subMap_default.entrySet().iterator(); 10998 assertTrue(iterator.hasNext()); 10999 for (int i = 100; iterator.hasNext(); i++) { 11000 assertEquals(i, ((Entry) iterator.next()).getValue()); 11001 } 11002 11003 try { 11004 iterator.next(); 11005 fail("should throw java.util.NoSuchElementException"); 11006 } catch (NoSuchElementException e) { 11007 // Expected 11008 } 11009 11010 } 11011 11012 public void test_BoundedKeyIterator_next() { 11013 Iterator iterator = subMap_default.keySet().iterator(); 11014 assertTrue(iterator.hasNext()); 11015 for (int i = 100; iterator.hasNext(); i++) { 11016 assertEquals(new Integer(i).toString(), iterator.next()); 11017 } 11018 11019 try { 11020 iterator.next(); 11021 fail("should throw java.util.NoSuchElementException"); 11022 } catch (NoSuchElementException e) { 11023 // Expected 11024 } 11025 } 11026 11027 public void test_BoundedValueIterator_next() { 11028 String startKey = new Integer(101).toString(); 11029 String endKey = new Integer(108).toString(); 11030 11031 Collection values = tm.subMap(startKey, endKey).values(); 11032 Iterator iter = values.iterator(); 11033 for (int i = 101; i < 108; i++) { 11034 assertEquals(i, iter.next()); 11035 } 11036 try { 11037 iter.next(); 11038 fail("should throw java.util.NoSuchElementException"); 11039 } catch (Exception e) { 11040 // Expected 11041 } 11042 } 11043 11044 /* 11045 * SubMapEntrySet 11046 */ 11047 public void test_SubMapEntrySet_Constructor() { 11048 } 11049 11050 public void test_SubMapEntrySet_contains() { 11051 // covered in test_SubMapEntrySet_remove 11052 } 11053 11054 public void test_SubMapEntrySet_iterator() { 11055 Set entrySet = subMap_default.entrySet(); 11056 Iterator iterator; 11057 Entry entry; 11058 Integer value = new Integer(100); 11059 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11060 entry = (Entry) iterator.next(); 11061 assertEquals(value.toString(), entry.getKey()); 11062 assertEquals(value, entry.getValue()); 11063 } 11064 assertEquals(109, value.intValue()); 11065 try { 11066 iterator.next(); 11067 fail("should throw NoSuchElementException"); 11068 } catch (NoSuchElementException e) { 11069 // Expected 11070 } 11071 11072 entrySet = subMap_startExcluded_endExcluded.entrySet(); 11073 value = new Integer(101); 11074 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11075 entry = (Entry) iterator.next(); 11076 assertEquals(value.toString(), entry.getKey()); 11077 assertEquals(value, entry.getValue()); 11078 } 11079 assertEquals(109, value.intValue()); 11080 try { 11081 iterator.next(); 11082 fail("should throw NoSuchElementException"); 11083 } catch (NoSuchElementException e) { 11084 // Expected 11085 } 11086 11087 entrySet = subMap_startExcluded_endIncluded.entrySet(); 11088 value = new Integer(101); 11089 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11090 entry = (Entry) iterator.next(); 11091 assertEquals(value.toString(), entry.getKey()); 11092 assertEquals(value, entry.getValue()); 11093 } 11094 assertEquals(110, value.intValue()); 11095 try { 11096 iterator.next(); 11097 fail("should throw NoSuchElementException"); 11098 } catch (NoSuchElementException e) { 11099 // Expected 11100 } 11101 11102 entrySet = subMap_startIncluded_endExcluded.entrySet(); 11103 value = new Integer(100); 11104 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11105 entry = (Entry) iterator.next(); 11106 assertEquals(value.toString(), entry.getKey()); 11107 assertEquals(value, entry.getValue()); 11108 } 11109 assertEquals(109, value.intValue()); 11110 try { 11111 iterator.next(); 11112 fail("should throw NoSuchElementException"); 11113 } catch (NoSuchElementException e) { 11114 // Expected 11115 } 11116 11117 entrySet = subMap_startIncluded_endIncluded.entrySet(); 11118 value = new Integer(100); 11119 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11120 entry = (Entry) iterator.next(); 11121 assertEquals(value.toString(), entry.getKey()); 11122 assertEquals(value, entry.getValue()); 11123 } 11124 assertEquals(110, value.intValue()); 11125 try { 11126 iterator.next(); 11127 fail("should throw NoSuchElementException"); 11128 } catch (NoSuchElementException e) { 11129 // Expected 11130 } 11131 11132 String startKey = new Integer(-1).toString(); 11133 String endKey = new Integer(0).toString(); 11134 SortedMap subMap = tm.subMap(startKey, endKey); 11135 entrySet = subMap.entrySet(); 11136 iterator = entrySet.iterator(); 11137 try { 11138 iterator.next(); 11139 fail("should throw NoSuchElementException"); 11140 } catch (NoSuchElementException e) { 11141 // Expected 11142 } 11143 11144 endKey = new Integer(1).toString(); 11145 subMap = tm.subMap(startKey, endKey); 11146 entrySet = subMap.entrySet(); 11147 iterator = entrySet.iterator(); 11148 assertEquals(0, ((Entry) iterator.next()).getValue()); 11149 try { 11150 iterator.next(); 11151 fail("should throw NoSuchElementException"); 11152 } catch (NoSuchElementException e) { 11153 // Expected 11154 } 11155 11156 endKey = new Integer(2000).toString(); 11157 subMap = tm.subMap(startKey, endKey); 11158 entrySet = subMap.entrySet(); 11159 iterator = entrySet.iterator(); 11160 for (int i = 0; i < subMap.size(); i++) { 11161 iterator.next(); 11162 } 11163 try { 11164 iterator.next(); 11165 fail("should throw NoSuchElementException"); 11166 } catch (NoSuchElementException e) { 11167 // Expected 11168 } 11169 11170 startKey = new Integer(9).toString(); 11171 endKey = new Integer(100).toString(); 11172 try { 11173 tm.subMap(startKey, endKey); 11174 fail("should throw IllegalArgumentException"); 11175 } catch (IllegalArgumentException e) { 11176 // Expected 11177 } 11178 11179 // With Comparator 11180 entrySet = subMap_default_comparator.entrySet(); 11181 value = new Integer(100); 11182 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11183 entry = (Entry) iterator.next(); 11184 assertEquals(value.toString(), entry.getKey()); 11185 assertEquals(value, entry.getValue()); 11186 } 11187 assertEquals(109, value.intValue()); 11188 try { 11189 iterator.next(); 11190 fail("should throw NoSuchElementException"); 11191 } catch (NoSuchElementException e) { 11192 // Expected 11193 } 11194 11195 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 11196 value = new Integer(101); 11197 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11198 entry = (Entry) iterator.next(); 11199 assertEquals(value.toString(), entry.getKey()); 11200 assertEquals(value, entry.getValue()); 11201 } 11202 assertEquals(109, value.intValue()); 11203 try { 11204 iterator.next(); 11205 fail("should throw NoSuchElementException"); 11206 } catch (NoSuchElementException e) { 11207 // Expected 11208 } 11209 11210 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 11211 value = new Integer(101); 11212 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11213 entry = (Entry) iterator.next(); 11214 assertEquals(value.toString(), entry.getKey()); 11215 assertEquals(value, entry.getValue()); 11216 } 11217 assertEquals(110, value.intValue()); 11218 try { 11219 iterator.next(); 11220 fail("should throw NoSuchElementException"); 11221 } catch (NoSuchElementException e) { 11222 // Expected 11223 } 11224 11225 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 11226 value = new Integer(100); 11227 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11228 entry = (Entry) iterator.next(); 11229 assertEquals(value.toString(), entry.getKey()); 11230 assertEquals(value, entry.getValue()); 11231 } 11232 assertEquals(109, value.intValue()); 11233 try { 11234 iterator.next(); 11235 fail("should throw NoSuchElementException"); 11236 } catch (NoSuchElementException e) { 11237 // Expected 11238 } 11239 11240 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 11241 value = new Integer(100); 11242 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11243 entry = (Entry) iterator.next(); 11244 assertEquals(value.toString(), entry.getKey()); 11245 assertEquals(value, entry.getValue()); 11246 } 11247 assertEquals(110, value.intValue()); 11248 try { 11249 iterator.next(); 11250 fail("should throw NoSuchElementException"); 11251 } catch (NoSuchElementException e) { 11252 // Expected 11253 } 11254 } 11255 11256 public void test_SubMapEntrySet_remove() { 11257 Set entrySet = subMap_default.entrySet(); 11258 assertFalse(entrySet.remove(null)); 11259 int size = entrySet.size(); 11260 for (int i = 0; i < size; i++) { 11261 Iterator iterator = entrySet.iterator(); 11262 assertTrue(entrySet.remove(iterator.next())); 11263 } 11264 11265 entrySet = subMap_startExcluded_endExcluded.entrySet(); 11266 assertFalse(entrySet.remove(null)); 11267 size = entrySet.size(); 11268 for (int i = 0; i < size; i++) { 11269 Iterator iterator = entrySet.iterator(); 11270 assertTrue(entrySet.remove(iterator.next())); 11271 } 11272 11273 entrySet = subMap_startExcluded_endIncluded.entrySet(); 11274 assertFalse(entrySet.remove(null)); 11275 size = entrySet.size(); 11276 for (int i = 0; i < size; i++) { 11277 Iterator iterator = entrySet.iterator(); 11278 assertTrue(entrySet.remove(iterator.next())); 11279 } 11280 11281 entrySet = subMap_startIncluded_endExcluded.entrySet(); 11282 assertFalse(entrySet.remove(null)); 11283 size = entrySet.size(); 11284 for (int i = 0; i < size; i++) { 11285 Iterator iterator = entrySet.iterator(); 11286 assertTrue(entrySet.remove(iterator.next())); 11287 } 11288 11289 entrySet = subMap_startIncluded_endIncluded.entrySet(); 11290 assertFalse(entrySet.remove(null)); 11291 size = entrySet.size(); 11292 for (int i = 0; i < size; i++) { 11293 Iterator iterator = entrySet.iterator(); 11294 assertTrue(entrySet.remove(iterator.next())); 11295 } 11296 } 11297 11298 public void test_SubMapEntrySet_isEmpty() { 11299 assertFalse(subMap_default.entrySet().isEmpty()); 11300 assertFalse(subMap_startExcluded_endExcluded.entrySet().isEmpty()); 11301 assertFalse(subMap_startExcluded_endIncluded.entrySet().isEmpty()); 11302 assertFalse(subMap_startIncluded_endExcluded.entrySet().isEmpty()); 11303 assertFalse(subMap_startIncluded_endIncluded.entrySet().isEmpty()); 11304 11305 String startKey = new Integer(0).toString(); 11306 String endKey = startKey; 11307 SortedMap subMap = tm.subMap(startKey, endKey); 11308 assertTrue(subMap.entrySet().isEmpty()); 11309 11310 startKey = new Integer(-1).toString(); 11311 subMap = tm.subMap(startKey, endKey); 11312 assertTrue(subMap.entrySet().isEmpty()); 11313 11314 endKey = new Integer(1).toString(); 11315 subMap = tm.subMap(startKey, endKey); 11316 assertFalse(subMap.entrySet().isEmpty()); 11317 } 11318 11319 public void test_SubMapEntrySet_size() { 11320 assertEquals(9, subMap_default.entrySet().size()); 11321 assertEquals(8, subMap_startExcluded_endExcluded.entrySet().size()); 11322 assertEquals(9, subMap_startExcluded_endIncluded.entrySet().size()); 11323 assertEquals(9, subMap_startIncluded_endExcluded.entrySet().size()); 11324 assertEquals(10, subMap_startIncluded_endIncluded.entrySet().size()); 11325 11326 String startKey = new Integer(0).toString(); 11327 String endKey = new Integer(2).toString(); 11328 SortedMap subMap = tm.subMap(startKey, endKey); 11329 assertEquals(112, subMap.entrySet().size()); 11330 11331 startKey = new Integer(0).toString(); 11332 endKey = startKey; 11333 subMap = tm.subMap(startKey, endKey); 11334 assertEquals(0, subMap.entrySet().size()); 11335 11336 startKey = new Integer(-1).toString(); 11337 endKey = startKey; 11338 subMap = tm.subMap(startKey, endKey); 11339 assertEquals(0, subMap.entrySet().size()); 11340 11341 endKey = new Integer(1).toString(); 11342 subMap = tm.subMap(startKey, endKey); 11343 assertEquals(1, subMap.entrySet().size()); 11344 11345 startKey = new Integer(999).toString(); 11346 endKey = startKey; 11347 subMap = tm.subMap(startKey, endKey); 11348 assertEquals(0, subMap.entrySet().size()); 11349 } 11350 11351 /* 11352 * SubMapKeySet 11353 */ 11354 public void test_SubMapKeySet_Constructor() { 11355 // covered in other test 11356 } 11357 11358 public void test_SubMapKeySet_iterator() { 11359 Set keySet = subMap_default.keySet(); 11360 Iterator iterator = keySet.iterator(); 11361 for (int i = 0; i < keySet.size(); i++) { 11362 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11363 } 11364 assertFalse(iterator.hasNext()); 11365 try { 11366 iterator.next(); 11367 fail("should throw NoSuchElementException"); 11368 } catch (NoSuchElementException e) { 11369 // Expected 11370 } 11371 11372 keySet = subMap_startExcluded_endExcluded.keySet(); 11373 iterator = keySet.iterator(); 11374 for (int i = 0; i < keySet.size(); i++) { 11375 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11376 } 11377 assertFalse(iterator.hasNext()); 11378 try { 11379 iterator.next(); 11380 fail("should throw NoSuchElementException"); 11381 } catch (NoSuchElementException e) { 11382 // Expected 11383 } 11384 11385 keySet = subMap_startExcluded_endIncluded.keySet(); 11386 iterator = keySet.iterator(); 11387 for (int i = 0; i < keySet.size(); i++) { 11388 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11389 } 11390 assertFalse(iterator.hasNext()); 11391 try { 11392 iterator.next(); 11393 fail("should throw NoSuchElementException"); 11394 } catch (NoSuchElementException e) { 11395 // Expected 11396 } 11397 11398 keySet = subMap_startIncluded_endExcluded.keySet(); 11399 iterator = keySet.iterator(); 11400 for (int i = 0; i < keySet.size(); i++) { 11401 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11402 } 11403 assertFalse(iterator.hasNext()); 11404 try { 11405 iterator.next(); 11406 fail("should throw NoSuchElementException"); 11407 } catch (NoSuchElementException e) { 11408 // Expected 11409 } 11410 11411 keySet = subMap_startIncluded_endIncluded.keySet(); 11412 iterator = keySet.iterator(); 11413 for (int i = 0; i < keySet.size(); i++) { 11414 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11415 } 11416 assertFalse(iterator.hasNext()); 11417 try { 11418 iterator.next(); 11419 fail("should throw NoSuchElementException"); 11420 } catch (NoSuchElementException e) { 11421 // Expected 11422 } 11423 11424 // With Comparator 11425 keySet = subMap_default_comparator.keySet(); 11426 iterator = keySet.iterator(); 11427 for (int i = 0; i < keySet.size(); i++) { 11428 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11429 } 11430 assertFalse(iterator.hasNext()); 11431 try { 11432 iterator.next(); 11433 fail("should throw NoSuchElementException"); 11434 } catch (NoSuchElementException e) { 11435 // Expected 11436 } 11437 11438 keySet = subMap_startExcluded_endExcluded_comparator.keySet(); 11439 iterator = keySet.iterator(); 11440 for (int i = 0; i < keySet.size(); i++) { 11441 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11442 } 11443 assertFalse(iterator.hasNext()); 11444 try { 11445 iterator.next(); 11446 fail("should throw NoSuchElementException"); 11447 } catch (NoSuchElementException e) { 11448 // Expected 11449 } 11450 11451 keySet = subMap_startExcluded_endIncluded_comparator.keySet(); 11452 iterator = keySet.iterator(); 11453 for (int i = 0; i < keySet.size(); i++) { 11454 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11455 } 11456 assertFalse(iterator.hasNext()); 11457 try { 11458 iterator.next(); 11459 fail("should throw NoSuchElementException"); 11460 } catch (NoSuchElementException e) { 11461 // Expected 11462 } 11463 11464 keySet = subMap_startIncluded_endExcluded_comparator.keySet(); 11465 iterator = keySet.iterator(); 11466 for (int i = 0; i < keySet.size(); i++) { 11467 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11468 } 11469 assertFalse(iterator.hasNext()); 11470 try { 11471 iterator.next(); 11472 fail("should throw NoSuchElementException"); 11473 } catch (NoSuchElementException e) { 11474 // Expected 11475 } 11476 11477 keySet = subMap_startIncluded_endIncluded_comparator.keySet(); 11478 iterator = keySet.iterator(); 11479 for (int i = 0; i < keySet.size(); i++) { 11480 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11481 } 11482 assertFalse(iterator.hasNext()); 11483 try { 11484 iterator.next(); 11485 fail("should throw NoSuchElementException"); 11486 } catch (NoSuchElementException e) { 11487 // Expected 11488 } 11489 } 11490 11491 public void test_SubMapKeySet_isEmpty() { 11492 assertFalse(subMap_default.keySet().isEmpty()); 11493 assertFalse(subMap_startExcluded_endExcluded.keySet().isEmpty()); 11494 assertFalse(subMap_startExcluded_endIncluded.keySet().isEmpty()); 11495 assertFalse(subMap_startIncluded_endExcluded.keySet().isEmpty()); 11496 assertFalse(subMap_startIncluded_endIncluded.keySet().isEmpty()); 11497 11498 String startKey = new Integer(0).toString(); 11499 String endKey = startKey; 11500 SortedMap subMap = tm.subMap(startKey, endKey); 11501 assertTrue(subMap.keySet().isEmpty()); 11502 11503 startKey = new Integer(999).toString(); 11504 endKey = startKey; 11505 subMap = tm.subMap(startKey, endKey); 11506 assertTrue(subMap.keySet().isEmpty()); 11507 11508 startKey = new Integer(-1).toString(); 11509 endKey = new Integer(1).toString(); 11510 subMap = tm.subMap(startKey, endKey); 11511 assertFalse(subMap.keySet().isEmpty()); 11512 11513 endKey = new Integer(0).toString(); 11514 subMap = tm.subMap(startKey, endKey); 11515 assertTrue(subMap.keySet().isEmpty()); 11516 } 11517 11518 public void test_SubMapKeySet_contains() { 11519 Set keySet = subMap_default.keySet(); 11520 try { 11521 keySet.contains(null); 11522 fail("should throw NullPointerException"); 11523 } catch (NullPointerException e) { 11524 // Expected 11525 } 11526 String key = new Integer(-1).toString(); 11527 assertFalse(keySet.contains(key)); 11528 key = new Integer(99).toString(); 11529 assertFalse(keySet.contains(key)); 11530 key = new Integer(100).toString(); 11531 assertTrue(keySet.contains(key)); 11532 for (int i = 101; i < 109; i++) { 11533 key = new Integer(i).toString(); 11534 assertTrue(keySet.contains(key)); 11535 } 11536 key = new Integer(109).toString(); 11537 assertFalse(keySet.contains(key)); 11538 key = new Integer(110).toString(); 11539 assertFalse(keySet.contains(key)); 11540 key = new Integer(1001).toString(); 11541 assertFalse(keySet.contains(key)); 11542 11543 keySet = subMap_startExcluded_endExcluded.keySet(); 11544 try { 11545 keySet.contains(null); 11546 fail("should throw NullPointerException"); 11547 } catch (NullPointerException e) { 11548 // Expected 11549 } 11550 key = new Integer(-1).toString(); 11551 assertFalse(keySet.contains(key)); 11552 key = new Integer(99).toString(); 11553 assertFalse(keySet.contains(key)); 11554 key = new Integer(100).toString(); 11555 assertFalse(keySet.contains(key)); 11556 for (int i = 101; i < 109; i++) { 11557 key = new Integer(i).toString(); 11558 assertTrue(keySet.contains(key)); 11559 } 11560 key = new Integer(109).toString(); 11561 assertFalse(keySet.contains(key)); 11562 key = new Integer(110).toString(); 11563 assertFalse(keySet.contains(key)); 11564 key = new Integer(1001).toString(); 11565 assertFalse(keySet.contains(key)); 11566 11567 keySet = subMap_startExcluded_endIncluded.keySet(); 11568 try { 11569 keySet.contains(null); 11570 fail("should throw NullPointerException"); 11571 } catch (NullPointerException e) { 11572 // Expected 11573 } 11574 key = new Integer(-1).toString(); 11575 assertFalse(keySet.contains(key)); 11576 key = new Integer(99).toString(); 11577 assertFalse(keySet.contains(key)); 11578 key = new Integer(100).toString(); 11579 assertFalse(keySet.contains(key)); 11580 for (int i = 101; i < 109; i++) { 11581 key = new Integer(i).toString(); 11582 assertTrue(keySet.contains(key)); 11583 } 11584 key = new Integer(109).toString(); 11585 assertTrue(keySet.contains(key)); 11586 key = new Integer(110).toString(); 11587 assertFalse(keySet.contains(key)); 11588 key = new Integer(1001).toString(); 11589 assertFalse(keySet.contains(key)); 11590 11591 keySet = subMap_startIncluded_endExcluded.keySet(); 11592 try { 11593 keySet.contains(null); 11594 fail("should throw NullPointerException"); 11595 } catch (NullPointerException e) { 11596 // Expected 11597 } 11598 key = new Integer(-1).toString(); 11599 assertFalse(keySet.contains(key)); 11600 key = new Integer(99).toString(); 11601 assertFalse(keySet.contains(key)); 11602 key = new Integer(100).toString(); 11603 assertTrue(keySet.contains(key)); 11604 for (int i = 101; i < 109; i++) { 11605 key = new Integer(i).toString(); 11606 assertTrue(keySet.contains(key)); 11607 } 11608 key = new Integer(109).toString(); 11609 assertFalse(keySet.contains(key)); 11610 key = new Integer(110).toString(); 11611 assertFalse(keySet.contains(key)); 11612 key = new Integer(1001).toString(); 11613 assertFalse(keySet.contains(key)); 11614 11615 keySet = subMap_startIncluded_endIncluded.keySet(); 11616 try { 11617 keySet.contains(null); 11618 fail("should throw NullPointerException"); 11619 } catch (NullPointerException e) { 11620 // Expected 11621 } 11622 key = new Integer(-1).toString(); 11623 assertFalse(keySet.contains(key)); 11624 key = new Integer(99).toString(); 11625 assertFalse(keySet.contains(key)); 11626 key = new Integer(100).toString(); 11627 assertTrue(keySet.contains(key)); 11628 for (int i = 101; i < 109; i++) { 11629 key = new Integer(i).toString(); 11630 assertTrue(keySet.contains(key)); 11631 } 11632 key = new Integer(109).toString(); 11633 assertTrue(keySet.contains(key)); 11634 key = new Integer(110).toString(); 11635 assertFalse(keySet.contains(key)); 11636 key = new Integer(1001).toString(); 11637 assertFalse(keySet.contains(key)); 11638 } 11639 11640 public void test_SubMapKeySet_size() { 11641 assertEquals(9, subMap_default.keySet().size()); 11642 assertEquals(8, subMap_startExcluded_endExcluded.keySet().size()); 11643 assertEquals(9, subMap_startExcluded_endIncluded.keySet().size()); 11644 assertEquals(9, subMap_startIncluded_endExcluded.keySet().size()); 11645 assertEquals(10, subMap_startIncluded_endIncluded.keySet().size()); 11646 11647 String startKey = new Integer(0).toString(); 11648 String endKey = new Integer(2).toString(); 11649 SortedMap subMap = tm.subMap(startKey, endKey); 11650 assertEquals(112, subMap.keySet().size()); 11651 11652 startKey = new Integer(0).toString(); 11653 endKey = startKey; 11654 subMap = tm.subMap(startKey, endKey); 11655 assertEquals(0, subMap.keySet().size()); 11656 11657 startKey = new Integer(-1).toString(); 11658 endKey = startKey; 11659 subMap = tm.subMap(startKey, endKey); 11660 assertEquals(0, subMap.keySet().size()); 11661 11662 endKey = new Integer(1).toString(); 11663 subMap = tm.subMap(startKey, endKey); 11664 assertEquals(1, subMap.keySet().size()); 11665 11666 startKey = new Integer(999).toString(); 11667 endKey = startKey; 11668 subMap = tm.subMap(startKey, endKey); 11669 assertEquals(0, subMap.keySet().size()); 11670 } 11671 11672 public void test_SubMapKeySet_remove() { 11673 Set keySet = subMap_default.keySet(); 11674 try { 11675 keySet.remove(null); 11676 fail("should throw NullPointerException"); 11677 } catch (NullPointerException e) { 11678 // Expected 11679 } 11680 int size = keySet.size(); 11681 for (int i = 0; i < size; i++) { 11682 Iterator iterator = keySet.iterator(); 11683 assertTrue(keySet.remove(iterator.next())); 11684 } 11685 11686 keySet = subMap_startExcluded_endExcluded.keySet(); 11687 try { 11688 keySet.remove(null); 11689 fail("should throw NullPointerException"); 11690 } catch (NullPointerException e) { 11691 // Expected 11692 } 11693 size = keySet.size(); 11694 for (int i = 0; i < size; i++) { 11695 Iterator iterator = keySet.iterator(); 11696 assertTrue(keySet.remove(iterator.next())); 11697 } 11698 11699 keySet = subMap_startExcluded_endIncluded.keySet(); 11700 try { 11701 keySet.remove(null); 11702 fail("should throw NullPointerException"); 11703 } catch (NullPointerException e) { 11704 // Expected 11705 } 11706 size = keySet.size(); 11707 for (int i = 0; i < size; i++) { 11708 Iterator iterator = keySet.iterator(); 11709 assertTrue(keySet.remove(iterator.next())); 11710 } 11711 11712 keySet = subMap_startIncluded_endExcluded.keySet(); 11713 try { 11714 keySet.remove(null); 11715 fail("should throw NullPointerException"); 11716 } catch (NullPointerException e) { 11717 // Expected 11718 } 11719 size = keySet.size(); 11720 for (int i = 0; i < size; i++) { 11721 Iterator iterator = keySet.iterator(); 11722 assertTrue(keySet.remove(iterator.next())); 11723 } 11724 11725 keySet = subMap_startIncluded_endIncluded.keySet(); 11726 try { 11727 keySet.remove(null); 11728 fail("should throw NullPointerException"); 11729 } catch (NullPointerException e) { 11730 // Expected 11731 } 11732 size = keySet.size(); 11733 for (int i = 0; i < size; i++) { 11734 Iterator iterator = keySet.iterator(); 11735 assertTrue(keySet.remove(iterator.next())); 11736 } 11737 } 11738 11739 /* 11740 * AscendingSubMapEntrySet 11741 */ 11742 11743 public void test_AscendingSubMapEntrySet_comparator() { 11744 Set entrySet; 11745 NavigableSet ascendingSubMapEntrySet; 11746 11747 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11748 if (entrySet instanceof NavigableSet) { 11749 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11750 assertNull(ascendingSubMapEntrySet.comparator()); 11751 } 11752 11753 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11754 if (entrySet instanceof NavigableSet) { 11755 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11756 assertNull(ascendingSubMapEntrySet.comparator()); 11757 } 11758 11759 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11760 if (entrySet instanceof NavigableSet) { 11761 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11762 assertNull(ascendingSubMapEntrySet.comparator()); 11763 } 11764 11765 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11766 if (entrySet instanceof NavigableSet) { 11767 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11768 assertNull(ascendingSubMapEntrySet.comparator()); 11769 } 11770 } 11771 11772 public void test_AscendingSubMapEntrySet_descendingSet() { 11773 Set entrySet; 11774 NavigableSet ascendingSubMapEntrySet, descendingSet; 11775 Entry entry; 11776 int value; 11777 Iterator iterator; 11778 11779 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11780 if (entrySet instanceof NavigableSet) { 11781 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11782 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11783 iterator = descendingSet.iterator(); 11784 assertTrue(iterator.hasNext()); 11785 for (value = 108; iterator.hasNext(); value--) { 11786 entry = (Entry) iterator.next(); 11787 assertEquals(value, entry.getValue()); 11788 } 11789 assertEquals(100, value); 11790 } 11791 11792 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11793 if (entrySet instanceof NavigableSet) { 11794 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11795 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11796 iterator = descendingSet.iterator(); 11797 assertTrue(iterator.hasNext()); 11798 for (value = 109; iterator.hasNext(); value--) { 11799 entry = (Entry) iterator.next(); 11800 assertEquals(value, entry.getValue()); 11801 } 11802 assertEquals(100, value); 11803 } 11804 11805 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11806 if (entrySet instanceof NavigableSet) { 11807 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11808 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11809 iterator = descendingSet.iterator(); 11810 assertTrue(iterator.hasNext()); 11811 for (value = 108; iterator.hasNext(); value--) { 11812 entry = (Entry) iterator.next(); 11813 assertEquals(value, entry.getValue()); 11814 } 11815 assertEquals(99, value); 11816 } 11817 11818 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11819 if (entrySet instanceof NavigableSet) { 11820 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11821 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11822 iterator = descendingSet.iterator(); 11823 assertTrue(iterator.hasNext()); 11824 for (value = 109; iterator.hasNext(); value--) { 11825 entry = (Entry) iterator.next(); 11826 assertEquals(value, entry.getValue()); 11827 } 11828 assertEquals(99, value); 11829 } 11830 } 11831 11832 public void test_AscendingSubMapEntrySet_descendingIterator() { 11833 Set entrySet; 11834 NavigableSet ascendingSubMapEntrySet; 11835 Iterator iterator; 11836 Entry entry; 11837 int value; 11838 11839 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11840 if (entrySet instanceof NavigableSet) { 11841 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11842 iterator = ascendingSubMapEntrySet.descendingIterator(); 11843 assertTrue(iterator.hasNext()); 11844 for (value = 108; iterator.hasNext(); value--) { 11845 entry = (Entry) iterator.next(); 11846 assertEquals(value, entry.getValue()); 11847 } 11848 assertEquals(100, value); 11849 } 11850 11851 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11852 if (entrySet instanceof NavigableSet) { 11853 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11854 iterator = ascendingSubMapEntrySet.descendingIterator(); 11855 assertTrue(iterator.hasNext()); 11856 for (value = 109; iterator.hasNext(); value--) { 11857 entry = (Entry) iterator.next(); 11858 assertEquals(value, entry.getValue()); 11859 } 11860 assertEquals(100, value); 11861 } 11862 11863 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11864 if (entrySet instanceof NavigableSet) { 11865 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11866 iterator = ascendingSubMapEntrySet.descendingIterator(); 11867 assertTrue(iterator.hasNext()); 11868 for (value = 108; iterator.hasNext(); value--) { 11869 entry = (Entry) iterator.next(); 11870 assertEquals(value, entry.getValue()); 11871 } 11872 assertEquals(99, value); 11873 } 11874 11875 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11876 if (entrySet instanceof NavigableSet) { 11877 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11878 iterator = ascendingSubMapEntrySet.descendingIterator(); 11879 assertTrue(iterator.hasNext()); 11880 for (value = 109; iterator.hasNext(); value--) { 11881 entry = (Entry) iterator.next(); 11882 assertEquals(value, entry.getValue()); 11883 } 11884 assertEquals(99, value); 11885 } 11886 11887 String startKey = new Integer(2).toString(); 11888 entrySet = tm.headMap(startKey, true).entrySet(); 11889 if (entrySet instanceof NavigableSet) { 11890 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11891 iterator = ascendingSubMapEntrySet.descendingIterator(); 11892 assertTrue(iterator.hasNext()); 11893 assertEquals(2, ((Entry) iterator.next()).getValue()); 11894 } 11895 } 11896 11897 public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() { 11898 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11899 if (entrySet instanceof NavigableSet) { 11900 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11901 for (int value = 101; value < 109; value++) { 11902 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11903 assertEquals(value, entry.getValue()); 11904 } 11905 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11906 // should return null if the set is empty. 11907 assertNull(ascendingSubMapEntrySet.pollFirst()); 11908 } 11909 } 11910 11911 public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() { 11912 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11913 if (entrySet instanceof NavigableSet) { 11914 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11915 for (int value = 101; value < 110; value++) { 11916 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11917 assertEquals(value, entry.getValue()); 11918 } 11919 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11920 // should return null if the set is empty. 11921 assertNull(ascendingSubMapEntrySet.pollFirst()); 11922 } 11923 } 11924 11925 public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() { 11926 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11927 if (entrySet instanceof NavigableSet) { 11928 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11929 for (int value = 100; value < 109; value++) { 11930 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11931 assertEquals(value, entry.getValue()); 11932 } 11933 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11934 // should return null if the set is empty. 11935 assertNull(ascendingSubMapEntrySet.pollFirst()); 11936 } 11937 } 11938 11939 public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endIncluded() { 11940 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11941 if (entrySet instanceof NavigableSet) { 11942 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11943 for (int value = 100; value < 110; value++) { 11944 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11945 assertEquals(value, entry.getValue()); 11946 } 11947 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11948 // should return null if the set is empty. 11949 assertNull(ascendingSubMapEntrySet.pollFirst()); 11950 } 11951 } 11952 11953 public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endExcluded() { 11954 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11955 if (entrySet instanceof NavigableSet) { 11956 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11957 for (int value = 108; value > 100; value--) { 11958 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 11959 assertEquals(value, entry.getValue()); 11960 } 11961 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11962 // should return null if the set is empty 11963 assertNull(ascendingSubMapEntrySet.pollLast()); 11964 } 11965 11966 // NavigableMap ascendingSubMap = tm.headMap("2", true); 11967 // Set entrySet = ascendingSubMap.entrySet(); 11968 // Object last; 11969 // if (entrySet instanceof NavigableSet) { 11970 // last = ((NavigableSet) entrySet).pollLast(); 11971 // assertEquals("2=2", last.toString()); 11972 // } 11973 // 11974 // ascendingSubMap = tm.tailMap("2", true); 11975 // entrySet = ascendingSubMap.entrySet(); 11976 // if (entrySet instanceof NavigableSet) { 11977 // last = ((NavigableSet) entrySet).pollLast(); 11978 // assertEquals("999=999", last.toString()); 11979 // } 11980 } 11981 11982 public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endIncluded() { 11983 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11984 if (entrySet instanceof NavigableSet) { 11985 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11986 for (int value = 109; value > 100; value--) { 11987 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 11988 assertEquals(value, entry.getValue()); 11989 } 11990 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11991 // should return null if the set is empty 11992 assertNull(ascendingSubMapEntrySet.pollLast()); 11993 } 11994 } 11995 11996 public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endExcluded() { 11997 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11998 if (entrySet instanceof NavigableSet) { 11999 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 12000 for (int value = 108; value > 99; value--) { 12001 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 12002 assertEquals(value, entry.getValue()); 12003 } 12004 assertTrue(ascendingSubMapEntrySet.isEmpty()); 12005 // should return null if the set is empty 12006 assertNull(ascendingSubMapEntrySet.pollLast()); 12007 } 12008 } 12009 12010 public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endIncluded() { 12011 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12012 if (entrySet instanceof NavigableSet) { 12013 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 12014 for (int value = 109; value > 99; value--) { 12015 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 12016 assertEquals(value, entry.getValue()); 12017 } 12018 assertTrue(ascendingSubMapEntrySet.isEmpty()); 12019 // should return null if the set is empty 12020 assertNull(ascendingSubMapEntrySet.pollLast()); 12021 } 12022 } 12023 12024 public void test_AscendingSubMapEntrySet_headSet() { 12025 Set entrySet, headSet; 12026 NavigableSet ascendingSubMapEntrySet; 12027 Iterator iterator, headSetIterator; 12028 Entry entry; 12029 int value; 12030 12031 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12032 if (entrySet instanceof NavigableSet) { 12033 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12034 iterator = ascendingSubMapEntrySet.iterator(); 12035 while (iterator.hasNext()) { 12036 entry = (Entry) iterator.next(); 12037 headSet = ascendingSubMapEntrySet.headSet(entry); 12038 headSetIterator = headSet.iterator(); 12039 for (value = 101; headSetIterator.hasNext(); value++) { 12040 assertEquals(value, ((Entry) headSetIterator.next()) 12041 .getValue()); 12042 } 12043 assertEquals(entry.getValue(), value); 12044 try { 12045 headSetIterator.next(); 12046 fail("should throw NoSuchElementException"); 12047 } catch (NoSuchElementException e) { 12048 // Expected 12049 } 12050 12051 headSet = ascendingSubMapEntrySet.headSet(entry, false); 12052 headSetIterator = headSet.iterator(); 12053 for (value = 101; headSetIterator.hasNext(); value++) { 12054 assertEquals(value, ((Entry) headSetIterator.next()) 12055 .getValue()); 12056 } 12057 assertEquals(entry.getValue(), value); 12058 try { 12059 headSetIterator.next(); 12060 fail("should throw NoSuchElementException"); 12061 } catch (NoSuchElementException e) { 12062 // Expected 12063 } 12064 12065 headSet = ascendingSubMapEntrySet.headSet(entry, true); 12066 headSetIterator = headSet.iterator(); 12067 for (value = 101; headSetIterator.hasNext(); value++) { 12068 assertEquals(value, ((Entry) headSetIterator.next()) 12069 .getValue()); 12070 } 12071 assertEquals(entry.getValue(), value - 1); 12072 try { 12073 headSetIterator.next(); 12074 fail("should throw NoSuchElementException"); 12075 } catch (NoSuchElementException e) { 12076 // Expected 12077 } 12078 } 12079 } 12080 12081 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12082 if (entrySet instanceof NavigableSet) { 12083 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12084 iterator = ascendingSubMapEntrySet.iterator(); 12085 while (iterator.hasNext()) { 12086 entry = (Entry) iterator.next(); 12087 headSet = ascendingSubMapEntrySet.headSet(entry); 12088 headSetIterator = headSet.iterator(); 12089 for (value = 101; headSetIterator.hasNext(); value++) { 12090 assertEquals(value, ((Entry) headSetIterator.next()) 12091 .getValue()); 12092 } 12093 assertEquals(entry.getValue(), value); 12094 try { 12095 headSetIterator.next(); 12096 fail("should throw NoSuchElementException"); 12097 } catch (NoSuchElementException e) { 12098 // Expected 12099 } 12100 12101 headSet = ascendingSubMapEntrySet.headSet(entry, false); 12102 headSetIterator = headSet.iterator(); 12103 for (value = 101; headSetIterator.hasNext(); value++) { 12104 assertEquals(value, ((Entry) headSetIterator.next()) 12105 .getValue()); 12106 } 12107 assertEquals(entry.getValue(), value); 12108 try { 12109 headSetIterator.next(); 12110 fail("should throw NoSuchElementException"); 12111 } catch (NoSuchElementException e) { 12112 // Expected 12113 } 12114 12115 headSet = ascendingSubMapEntrySet.headSet(entry, true); 12116 headSetIterator = headSet.iterator(); 12117 for (value = 101; headSetIterator.hasNext(); value++) { 12118 assertEquals(value, ((Entry) headSetIterator.next()) 12119 .getValue()); 12120 } 12121 assertEquals(entry.getValue(), value - 1); 12122 try { 12123 headSetIterator.next(); 12124 fail("should throw NoSuchElementException"); 12125 } catch (NoSuchElementException e) { 12126 // Expected 12127 } 12128 } 12129 } 12130 12131 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12132 if (entrySet instanceof NavigableSet) { 12133 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12134 iterator = ascendingSubMapEntrySet.iterator(); 12135 while (iterator.hasNext()) { 12136 entry = (Entry) iterator.next(); 12137 headSet = ascendingSubMapEntrySet.headSet(entry); 12138 headSetIterator = headSet.iterator(); 12139 for (value = 100; headSetIterator.hasNext(); value++) { 12140 assertEquals(value, ((Entry) headSetIterator.next()) 12141 .getValue()); 12142 } 12143 assertEquals(entry.getValue(), value); 12144 try { 12145 headSetIterator.next(); 12146 fail("should throw NoSuchElementException"); 12147 } catch (NoSuchElementException e) { 12148 // Expected 12149 } 12150 12151 headSet = ascendingSubMapEntrySet.headSet(entry, false); 12152 headSetIterator = headSet.iterator(); 12153 for (value = 100; headSetIterator.hasNext(); value++) { 12154 assertEquals(value, ((Entry) headSetIterator.next()) 12155 .getValue()); 12156 } 12157 assertEquals(entry.getValue(), value); 12158 try { 12159 headSetIterator.next(); 12160 fail("should throw NoSuchElementException"); 12161 } catch (NoSuchElementException e) { 12162 // Expected 12163 } 12164 12165 headSet = ascendingSubMapEntrySet.headSet(entry, true); 12166 headSetIterator = headSet.iterator(); 12167 for (value = 100; headSetIterator.hasNext(); value++) { 12168 assertEquals(value, ((Entry) headSetIterator.next()) 12169 .getValue()); 12170 } 12171 assertEquals(entry.getValue(), value - 1); 12172 try { 12173 headSetIterator.next(); 12174 fail("should throw NoSuchElementException"); 12175 } catch (NoSuchElementException e) { 12176 // Expected 12177 } 12178 } 12179 } 12180 12181 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12182 if (entrySet instanceof NavigableSet) { 12183 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12184 iterator = ascendingSubMapEntrySet.iterator(); 12185 while (iterator.hasNext()) { 12186 entry = (Entry) iterator.next(); 12187 headSet = ascendingSubMapEntrySet.headSet(entry); 12188 headSetIterator = headSet.iterator(); 12189 for (value = 100; headSetIterator.hasNext(); value++) { 12190 assertEquals(value, ((Entry) headSetIterator.next()) 12191 .getValue()); 12192 } 12193 assertEquals(entry.getValue(), value); 12194 try { 12195 headSetIterator.next(); 12196 fail("should throw NoSuchElementException"); 12197 } catch (NoSuchElementException e) { 12198 // Expected 12199 } 12200 12201 headSet = ascendingSubMapEntrySet.headSet(entry, false); 12202 headSetIterator = headSet.iterator(); 12203 for (value = 100; headSetIterator.hasNext(); value++) { 12204 assertEquals(value, ((Entry) headSetIterator.next()) 12205 .getValue()); 12206 } 12207 assertEquals(entry.getValue(), value); 12208 try { 12209 headSetIterator.next(); 12210 fail("should throw NoSuchElementException"); 12211 } catch (NoSuchElementException e) { 12212 // Expected 12213 } 12214 12215 headSet = ascendingSubMapEntrySet.headSet(entry, true); 12216 headSetIterator = headSet.iterator(); 12217 for (value = 100; headSetIterator.hasNext(); value++) { 12218 assertEquals(value, ((Entry) headSetIterator.next()) 12219 .getValue()); 12220 } 12221 assertEquals(entry.getValue(), value - 1); 12222 try { 12223 headSetIterator.next(); 12224 fail("should throw NoSuchElementException"); 12225 } catch (NoSuchElementException e) { 12226 // Expected 12227 } 12228 } 12229 } 12230 12231 // NavigableMap ascendingSubMap = tm.headMap("1", true); 12232 // entrySet = ascendingSubMap.entrySet(); 12233 // if (entrySet instanceof SortedSet) { 12234 // Iterator it = entrySet.iterator(); 12235 // it.next(); 12236 // Object end = it.next();// 1=1 12237 // Set headSet = ((NavigableSet) entrySet).headSet(end);// inclusive 12238 // // false 12239 // assertEquals(1, headSet.size()); 12240 // } 12241 } 12242 12243 public void test_AscendingSubMapEntrySet_tailSet() { 12244 Set entrySet, tailSet; 12245 NavigableSet ascendingSubMapEntrySet; 12246 Iterator iterator, tailSetIterator; 12247 Entry entry; 12248 int value; 12249 12250 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12251 if (entrySet instanceof NavigableSet) { 12252 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12253 iterator = entrySet.iterator(); 12254 while (iterator.hasNext()) { 12255 entry = (Entry) iterator.next(); 12256 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12257 tailSetIterator = tailSet.iterator(); 12258 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12259 .hasNext(); value++) { 12260 assertEquals(value, ((Entry) tailSetIterator.next()) 12261 .getValue()); 12262 } 12263 assertEquals(109, value); 12264 try { 12265 tailSetIterator.next(); 12266 fail("should throw NoSuchElementException"); 12267 } catch (NoSuchElementException e) { 12268 // Expected 12269 } 12270 12271 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12272 tailSetIterator = tailSet.iterator(); 12273 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12274 .hasNext(); value++) { 12275 assertEquals(value, ((Entry) tailSetIterator.next()) 12276 .getValue()); 12277 } 12278 assertEquals(109, value); 12279 try { 12280 tailSetIterator.next(); 12281 fail("should throw NoSuchElementException"); 12282 } catch (NoSuchElementException e) { 12283 // Expected 12284 } 12285 12286 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12287 tailSetIterator = tailSet.iterator(); 12288 for (value = (Integer) entry.getValue(); tailSetIterator 12289 .hasNext(); value++) { 12290 assertEquals(value, ((Entry) tailSetIterator.next()) 12291 .getValue()); 12292 } 12293 assertEquals(109, value); 12294 try { 12295 tailSetIterator.next(); 12296 fail("should throw NoSuchElementException"); 12297 } catch (NoSuchElementException e) { 12298 // Expected 12299 } 12300 } 12301 } 12302 12303 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12304 if (entrySet instanceof NavigableSet) { 12305 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12306 iterator = entrySet.iterator(); 12307 while (iterator.hasNext()) { 12308 entry = (Entry) iterator.next(); 12309 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12310 tailSetIterator = tailSet.iterator(); 12311 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12312 .hasNext(); value++) { 12313 assertEquals(value, ((Entry) tailSetIterator.next()) 12314 .getValue()); 12315 } 12316 assertEquals(110, value); 12317 try { 12318 tailSetIterator.next(); 12319 fail("should throw NoSuchElementException"); 12320 } catch (NoSuchElementException e) { 12321 // Expected 12322 } 12323 12324 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12325 tailSetIterator = tailSet.iterator(); 12326 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12327 .hasNext(); value++) { 12328 assertEquals(value, ((Entry) tailSetIterator.next()) 12329 .getValue()); 12330 } 12331 assertEquals(110, value); 12332 try { 12333 tailSetIterator.next(); 12334 fail("should throw NoSuchElementException"); 12335 } catch (NoSuchElementException e) { 12336 // Expected 12337 } 12338 12339 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12340 tailSetIterator = tailSet.iterator(); 12341 for (value = (Integer) entry.getValue(); tailSetIterator 12342 .hasNext(); value++) { 12343 assertEquals(value, ((Entry) tailSetIterator.next()) 12344 .getValue()); 12345 } 12346 assertEquals(110, value); 12347 try { 12348 tailSetIterator.next(); 12349 fail("should throw NoSuchElementException"); 12350 } catch (NoSuchElementException e) { 12351 // Expected 12352 } 12353 } 12354 } 12355 12356 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12357 if (entrySet instanceof NavigableSet) { 12358 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12359 iterator = entrySet.iterator(); 12360 while (iterator.hasNext()) { 12361 entry = (Entry) iterator.next(); 12362 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12363 tailSetIterator = tailSet.iterator(); 12364 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12365 .hasNext(); value++) { 12366 assertEquals(value, ((Entry) tailSetIterator.next()) 12367 .getValue()); 12368 } 12369 assertEquals(109, value); 12370 try { 12371 tailSetIterator.next(); 12372 fail("should throw NoSuchElementException"); 12373 } catch (NoSuchElementException e) { 12374 // Expected 12375 } 12376 12377 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12378 tailSetIterator = tailSet.iterator(); 12379 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12380 .hasNext(); value++) { 12381 assertEquals(value, ((Entry) tailSetIterator.next()) 12382 .getValue()); 12383 } 12384 assertEquals(109, value); 12385 try { 12386 tailSetIterator.next(); 12387 fail("should throw NoSuchElementException"); 12388 } catch (NoSuchElementException e) { 12389 // Expected 12390 } 12391 12392 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12393 tailSetIterator = tailSet.iterator(); 12394 for (value = (Integer) entry.getValue(); tailSetIterator 12395 .hasNext(); value++) { 12396 assertEquals(value, ((Entry) tailSetIterator.next()) 12397 .getValue()); 12398 } 12399 assertEquals(109, value); 12400 try { 12401 tailSetIterator.next(); 12402 fail("should throw NoSuchElementException"); 12403 } catch (NoSuchElementException e) { 12404 // Expected 12405 } 12406 } 12407 } 12408 12409 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12410 if (entrySet instanceof NavigableSet) { 12411 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12412 iterator = entrySet.iterator(); 12413 while (iterator.hasNext()) { 12414 entry = (Entry) iterator.next(); 12415 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12416 tailSetIterator = tailSet.iterator(); 12417 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12418 .hasNext(); value++) { 12419 assertEquals(value, ((Entry) tailSetIterator.next()) 12420 .getValue()); 12421 } 12422 assertEquals(110, value); 12423 try { 12424 tailSetIterator.next(); 12425 fail("should throw NoSuchElementException"); 12426 } catch (NoSuchElementException e) { 12427 // Expected 12428 } 12429 12430 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12431 tailSetIterator = tailSet.iterator(); 12432 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12433 .hasNext(); value++) { 12434 assertEquals(value, ((Entry) tailSetIterator.next()) 12435 .getValue()); 12436 } 12437 assertEquals(110, value); 12438 try { 12439 tailSetIterator.next(); 12440 fail("should throw NoSuchElementException"); 12441 } catch (NoSuchElementException e) { 12442 // Expected 12443 } 12444 12445 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12446 tailSetIterator = tailSet.iterator(); 12447 for (value = (Integer) entry.getValue(); tailSetIterator 12448 .hasNext(); value++) { 12449 assertEquals(value, ((Entry) tailSetIterator.next()) 12450 .getValue()); 12451 } 12452 assertEquals(110, value); 12453 try { 12454 tailSetIterator.next(); 12455 fail("should throw NoSuchElementException"); 12456 } catch (NoSuchElementException e) { 12457 // Expected 12458 } 12459 } 12460 } 12461 12462 // NavigableMap ascendingSubMap = tm.headMap("1", true); 12463 // Set entrySet = ascendingSubMap.entrySet(); 12464 // if (entrySet instanceof NavigableSet) { 12465 // Iterator it = entrySet.iterator(); 12466 // Object start = it.next();// 0=0 12467 // Set tailSet = ((NavigableSet) entrySet).tailSet(start);// default 12468 // // inclusive 12469 // // false 12470 // assertEquals(1, tailSet.size()); 12471 // } 12472 } 12473 12474 public void test_AscendingSubMapEntrySet_subSet() { 12475 Set entrySet, subSet; 12476 NavigableSet ascendingSubMapEntrySet; 12477 12478 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12479 if (entrySet instanceof NavigableSet) { 12480 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12481 Iterator iteratorStart = ascendingSubMapEntrySet.iterator(); 12482 while (iteratorStart.hasNext()) { 12483 Entry startEntry = (Entry) iteratorStart.next(); 12484 Iterator iteratorEnd = ascendingSubMapEntrySet.iterator(); 12485 while (iteratorEnd.hasNext()) { 12486 Entry endEntry = (Entry) iteratorEnd.next(); 12487 int startIndex = (Integer) startEntry.getValue(); 12488 int endIndex = (Integer) endEntry.getValue(); 12489 if (startIndex > endIndex) { 12490 try { 12491 ascendingSubMapEntrySet 12492 .subSet(startEntry, endEntry); 12493 fail("should throw IllegalArgumentException"); 12494 } catch (IllegalArgumentException e) { 12495 // Expected 12496 } 12497 12498 try { 12499 ascendingSubMapEntrySet.subSet(startEntry, false, 12500 endEntry, false); 12501 fail("should throw IllegalArgumentException"); 12502 } catch (IllegalArgumentException e) { 12503 // Expected 12504 } 12505 12506 try { 12507 ascendingSubMapEntrySet.subSet(startEntry, false, 12508 endEntry, true); 12509 fail("should throw IllegalArgumentException"); 12510 } catch (IllegalArgumentException e) { 12511 // Expected 12512 } 12513 12514 try { 12515 ascendingSubMapEntrySet.subSet(startEntry, true, 12516 endEntry, false); 12517 fail("should throw IllegalArgumentException"); 12518 } catch (IllegalArgumentException e) { 12519 // Expected 12520 } 12521 12522 try { 12523 ascendingSubMapEntrySet.subSet(startEntry, true, 12524 endEntry, true); 12525 fail("should throw IllegalArgumentException"); 12526 } catch (IllegalArgumentException e) { 12527 // Expected 12528 } 12529 } else { 12530 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12531 endEntry); 12532 Iterator subSetIterator = subSet.iterator(); 12533 for (int index = startIndex + 1; subSetIterator 12534 .hasNext(); index++) { 12535 assertEquals(index, ((Entry) subSetIterator.next()) 12536 .getValue()); 12537 } 12538 12539 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12540 false, endEntry, false); 12541 subSetIterator = subSet.iterator(); 12542 for (int index = startIndex + 1; subSetIterator 12543 .hasNext(); index++) { 12544 assertEquals(index, ((Entry) subSetIterator.next()) 12545 .getValue()); 12546 } 12547 12548 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12549 false, endEntry, true); 12550 subSetIterator = subSet.iterator(); 12551 for (int index = startIndex + 1; subSetIterator 12552 .hasNext(); index++) { 12553 assertEquals(index, ((Entry) subSetIterator.next()) 12554 .getValue()); 12555 } 12556 12557 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12558 true, endEntry, false); 12559 subSetIterator = subSet.iterator(); 12560 for (int index = startIndex; subSetIterator.hasNext(); index++) { 12561 assertEquals(index, ((Entry) subSetIterator.next()) 12562 .getValue()); 12563 } 12564 12565 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12566 true, endEntry, true); 12567 subSetIterator = subSet.iterator(); 12568 for (int index = startIndex; subSetIterator.hasNext(); index++) { 12569 assertEquals(index, ((Entry) subSetIterator.next()) 12570 .getValue()); 12571 } 12572 } 12573 } 12574 } 12575 } 12576 12577 String endKey = new Integer(2).toString(); 12578 entrySet = tm.headMap(endKey, true).entrySet(); 12579 if (entrySet instanceof NavigableSet) { 12580 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12581 Iterator iterator = entrySet.iterator(); 12582 Object startEntry = iterator.next(); 12583 iterator.next(); 12584 Object endEntry = iterator.next(); 12585 subSet = ascendingSubMapEntrySet.subSet(startEntry, endEntry); 12586 assertEquals(1, subSet.size()); 12587 12588 subSet = ascendingSubMapEntrySet.subSet(startEntry, false, 12589 endEntry, false); 12590 assertEquals(1, subSet.size()); 12591 12592 subSet = ascendingSubMapEntrySet.subSet(startEntry, false, 12593 endEntry, true); 12594 assertEquals(2, subSet.size()); 12595 12596 subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry, 12597 false); 12598 assertEquals(2, subSet.size()); 12599 12600 subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry, 12601 true); 12602 assertEquals(3, subSet.size()); 12603 } 12604 } 12605 12606 public void test_AscendingSubMapEntrySet_lower() { 12607 Set entrySet; 12608 NavigableSet ascendingSubMapEntrySet; 12609 Iterator iterator; 12610 Entry entry, lowerEntry; 12611 int value; 12612 12613 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12614 if (entrySet instanceof NavigableSet) { 12615 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12616 iterator = ascendingSubMapEntrySet.iterator(); 12617 while (iterator.hasNext()) { 12618 entry = (Entry) iterator.next(); 12619 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12620 value = (Integer) entry.getValue(); 12621 if (value > 101) { 12622 assertEquals(value - 1, lowerEntry.getValue()); 12623 } else { 12624 assertNull(lowerEntry); 12625 } 12626 } 12627 } 12628 12629 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12630 if (entrySet instanceof NavigableSet) { 12631 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12632 iterator = ascendingSubMapEntrySet.iterator(); 12633 while (iterator.hasNext()) { 12634 entry = (Entry) iterator.next(); 12635 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12636 value = (Integer) entry.getValue(); 12637 if (value > 101) { 12638 assertEquals(value - 1, lowerEntry.getValue()); 12639 } else { 12640 assertNull(lowerEntry); 12641 } 12642 } 12643 } 12644 12645 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12646 if (entrySet instanceof NavigableSet) { 12647 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12648 iterator = ascendingSubMapEntrySet.iterator(); 12649 while (iterator.hasNext()) { 12650 entry = (Entry) iterator.next(); 12651 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12652 value = (Integer) entry.getValue(); 12653 if (value > 100) { 12654 assertEquals(value - 1, lowerEntry.getValue()); 12655 } else { 12656 assertNull(lowerEntry); 12657 } 12658 } 12659 } 12660 12661 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12662 if (entrySet instanceof NavigableSet) { 12663 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12664 iterator = ascendingSubMapEntrySet.iterator(); 12665 while (iterator.hasNext()) { 12666 entry = (Entry) iterator.next(); 12667 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12668 value = (Integer) entry.getValue(); 12669 if (value > 100) { 12670 assertEquals(value - 1, lowerEntry.getValue()); 12671 } else { 12672 assertNull(lowerEntry); 12673 } 12674 } 12675 } 12676 12677 String endKey = new Integer(2).toString(); 12678 entrySet = tm.headMap(endKey, true).entrySet(); 12679 if (entrySet instanceof NavigableSet) { 12680 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12681 iterator = entrySet.iterator(); 12682 Entry expectedEntry = (Entry) iterator.next(); 12683 entry = (Entry) iterator.next(); 12684 assertEquals(expectedEntry, ascendingSubMapEntrySet.lower(entry)); 12685 } 12686 12687 // With Comparator 12688 12689 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 12690 if (entrySet instanceof NavigableSet) { 12691 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12692 iterator = ascendingSubMapEntrySet.iterator(); 12693 while (iterator.hasNext()) { 12694 entry = (Entry) iterator.next(); 12695 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12696 value = (Integer) entry.getValue(); 12697 if (value > 101) { 12698 assertEquals(value - 1, lowerEntry.getValue()); 12699 } else { 12700 assertNull(lowerEntry); 12701 } 12702 } 12703 } 12704 12705 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 12706 if (entrySet instanceof NavigableSet) { 12707 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12708 iterator = ascendingSubMapEntrySet.iterator(); 12709 while (iterator.hasNext()) { 12710 entry = (Entry) iterator.next(); 12711 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12712 value = (Integer) entry.getValue(); 12713 if (value > 101) { 12714 assertEquals(value - 1, lowerEntry.getValue()); 12715 } else { 12716 assertNull(lowerEntry); 12717 } 12718 } 12719 } 12720 12721 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 12722 if (entrySet instanceof NavigableSet) { 12723 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12724 iterator = ascendingSubMapEntrySet.iterator(); 12725 while (iterator.hasNext()) { 12726 entry = (Entry) iterator.next(); 12727 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12728 value = (Integer) entry.getValue(); 12729 if (value > 100) { 12730 assertEquals(value - 1, lowerEntry.getValue()); 12731 } else { 12732 assertNull(lowerEntry); 12733 } 12734 } 12735 } 12736 12737 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 12738 if (entrySet instanceof NavigableSet) { 12739 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12740 iterator = ascendingSubMapEntrySet.iterator(); 12741 while (iterator.hasNext()) { 12742 entry = (Entry) iterator.next(); 12743 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12744 value = (Integer) entry.getValue(); 12745 if (value > 100) { 12746 assertEquals(value - 1, lowerEntry.getValue()); 12747 } else { 12748 assertNull(lowerEntry); 12749 } 12750 } 12751 } 12752 } 12753 12754 public void test_AscendingSubMapEntrySet_higher() { 12755 Set entrySet; 12756 NavigableSet ascendingSubMapEntrySet; 12757 Iterator iterator; 12758 Entry entry, lowerEntry; 12759 int value; 12760 12761 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12762 if (entrySet instanceof NavigableSet) { 12763 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12764 iterator = ascendingSubMapEntrySet.iterator(); 12765 while (iterator.hasNext()) { 12766 entry = (Entry) iterator.next(); 12767 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12768 value = (Integer) entry.getValue(); 12769 if (value < 108) { 12770 assertEquals(value + 1, lowerEntry.getValue()); 12771 } else { 12772 assertNull(lowerEntry); 12773 } 12774 } 12775 } 12776 12777 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12778 if (entrySet instanceof NavigableSet) { 12779 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12780 iterator = ascendingSubMapEntrySet.iterator(); 12781 while (iterator.hasNext()) { 12782 entry = (Entry) iterator.next(); 12783 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12784 value = (Integer) entry.getValue(); 12785 if (value < 109) { 12786 assertEquals(value + 1, lowerEntry.getValue()); 12787 } else { 12788 assertNull(lowerEntry); 12789 } 12790 } 12791 } 12792 12793 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12794 if (entrySet instanceof NavigableSet) { 12795 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12796 iterator = ascendingSubMapEntrySet.iterator(); 12797 while (iterator.hasNext()) { 12798 entry = (Entry) iterator.next(); 12799 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12800 value = (Integer) entry.getValue(); 12801 if (value < 108) { 12802 assertEquals(value + 1, lowerEntry.getValue()); 12803 } else { 12804 assertNull(lowerEntry); 12805 } 12806 } 12807 } 12808 12809 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12810 if (entrySet instanceof NavigableSet) { 12811 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12812 iterator = ascendingSubMapEntrySet.iterator(); 12813 while (iterator.hasNext()) { 12814 entry = (Entry) iterator.next(); 12815 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12816 value = (Integer) entry.getValue(); 12817 if (value < 109) { 12818 assertEquals(value + 1, lowerEntry.getValue()); 12819 } else { 12820 assertNull(lowerEntry); 12821 } 12822 } 12823 } 12824 12825 String endKey = new Integer(2).toString(); 12826 entrySet = tm.headMap(endKey, true).entrySet(); 12827 if (entrySet instanceof NavigableSet) { 12828 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12829 iterator = entrySet.iterator(); 12830 entry = (Entry) iterator.next(); 12831 Entry expectedEntry = (Entry) iterator.next(); 12832 assertEquals(expectedEntry, ascendingSubMapEntrySet.higher(entry)); 12833 } 12834 12835 // With Comparator 12836 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 12837 if (entrySet instanceof NavigableSet) { 12838 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12839 iterator = ascendingSubMapEntrySet.iterator(); 12840 while (iterator.hasNext()) { 12841 entry = (Entry) iterator.next(); 12842 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12843 value = (Integer) entry.getValue(); 12844 if (value < 108) { 12845 assertEquals(value + 1, lowerEntry.getValue()); 12846 } else { 12847 assertNull(lowerEntry); 12848 } 12849 } 12850 } 12851 12852 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 12853 if (entrySet instanceof NavigableSet) { 12854 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12855 iterator = ascendingSubMapEntrySet.iterator(); 12856 while (iterator.hasNext()) { 12857 entry = (Entry) iterator.next(); 12858 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12859 value = (Integer) entry.getValue(); 12860 if (value < 109) { 12861 assertEquals(value + 1, lowerEntry.getValue()); 12862 } else { 12863 assertNull(lowerEntry); 12864 } 12865 } 12866 } 12867 12868 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 12869 if (entrySet instanceof NavigableSet) { 12870 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12871 iterator = ascendingSubMapEntrySet.iterator(); 12872 while (iterator.hasNext()) { 12873 entry = (Entry) iterator.next(); 12874 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12875 value = (Integer) entry.getValue(); 12876 if (value < 108) { 12877 assertEquals(value + 1, lowerEntry.getValue()); 12878 } else { 12879 assertNull(lowerEntry); 12880 } 12881 } 12882 } 12883 12884 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 12885 if (entrySet instanceof NavigableSet) { 12886 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12887 iterator = ascendingSubMapEntrySet.iterator(); 12888 while (iterator.hasNext()) { 12889 entry = (Entry) iterator.next(); 12890 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12891 value = (Integer) entry.getValue(); 12892 if (value < 109) { 12893 assertEquals(value + 1, lowerEntry.getValue()); 12894 } else { 12895 assertNull(lowerEntry); 12896 } 12897 } 12898 } 12899 } 12900 12901 public void test_AscendingSubMapEntrySet_ceiling() { 12902 Set entrySet; 12903 NavigableSet ascendingSubMapEntrySet; 12904 Iterator iterator; 12905 12906 Set entrySet_beyondBound; 12907 Iterator iterator_beyondBound; 12908 Entry beyondBoundEntry; 12909 12910 Entry entry, lowerEntry; 12911 int value = 0; 12912 12913 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12914 if (entrySet instanceof NavigableSet) { 12915 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12916 try { 12917 ascendingSubMapEntrySet.ceiling(null); 12918 fail("should throw NullPointerException"); 12919 } catch (NullPointerException e) { 12920 // Expected 12921 } 12922 12923 iterator = ascendingSubMapEntrySet.iterator(); 12924 while (iterator.hasNext()) { 12925 entry = (Entry) iterator.next(); 12926 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12927 value = (Integer) entry.getValue(); 12928 assertEquals(value, lowerEntry.getValue()); 12929 } 12930 assertEquals(108, value); 12931 12932 } 12933 12934 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12935 if (entrySet instanceof NavigableSet) { 12936 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12937 try { 12938 ascendingSubMapEntrySet.ceiling(null); 12939 fail("should throw NullPointerException"); 12940 } catch (NullPointerException e) { 12941 // Expected 12942 } 12943 12944 iterator = ascendingSubMapEntrySet.iterator(); 12945 while (iterator.hasNext()) { 12946 entry = (Entry) iterator.next(); 12947 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12948 value = (Integer) entry.getValue(); 12949 assertEquals(value, lowerEntry.getValue()); 12950 } 12951 assertEquals(109, value); 12952 } 12953 12954 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12955 if (entrySet instanceof NavigableSet) { 12956 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12957 try { 12958 ascendingSubMapEntrySet.ceiling(null); 12959 fail("should throw NullPointerException"); 12960 } catch (NullPointerException e) { 12961 // Expected 12962 } 12963 12964 iterator = ascendingSubMapEntrySet.iterator(); 12965 while (iterator.hasNext()) { 12966 entry = (Entry) iterator.next(); 12967 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12968 value = (Integer) entry.getValue(); 12969 assertEquals(value, lowerEntry.getValue()); 12970 } 12971 assertEquals(108, value); 12972 } 12973 12974 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12975 if (entrySet instanceof NavigableSet) { 12976 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12977 try { 12978 ascendingSubMapEntrySet.ceiling(null); 12979 fail("should throw NullPointerException"); 12980 } catch (NullPointerException e) { 12981 // Expected 12982 } 12983 12984 iterator = ascendingSubMapEntrySet.iterator(); 12985 while (iterator.hasNext()) { 12986 entry = (Entry) iterator.next(); 12987 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12988 value = (Integer) entry.getValue(); 12989 assertEquals(value, lowerEntry.getValue()); 12990 } 12991 assertEquals(109, value); 12992 } 12993 12994 // With Comparator 12995 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 12996 if (entrySet instanceof NavigableSet) { 12997 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12998 try { 12999 ascendingSubMapEntrySet.ceiling(null); 13000 fail("should throw NullPointerException"); 13001 } catch (NullPointerException e) { 13002 // Expected 13003 } 13004 13005 iterator = ascendingSubMapEntrySet.iterator(); 13006 while (iterator.hasNext()) { 13007 entry = (Entry) iterator.next(); 13008 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 13009 value = (Integer) entry.getValue(); 13010 assertEquals(value, lowerEntry.getValue()); 13011 } 13012 assertEquals(109, value); 13013 } 13014 13015 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 13016 if (entrySet instanceof NavigableSet) { 13017 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13018 try { 13019 ascendingSubMapEntrySet.ceiling(null); 13020 fail("should throw NullPointerException"); 13021 } catch (NullPointerException e) { 13022 // Expected 13023 } 13024 13025 iterator = ascendingSubMapEntrySet.iterator(); 13026 while (iterator.hasNext()) { 13027 entry = (Entry) iterator.next(); 13028 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 13029 value = (Integer) entry.getValue(); 13030 assertEquals(value, lowerEntry.getValue()); 13031 } 13032 assertEquals(108, value); 13033 } 13034 13035 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 13036 if (entrySet instanceof NavigableSet) { 13037 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13038 try { 13039 ascendingSubMapEntrySet.ceiling(null); 13040 fail("should throw NullPointerException"); 13041 } catch (NullPointerException e) { 13042 // Expected 13043 } 13044 13045 iterator = ascendingSubMapEntrySet.iterator(); 13046 while (iterator.hasNext()) { 13047 entry = (Entry) iterator.next(); 13048 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 13049 value = (Integer) entry.getValue(); 13050 assertEquals(value, lowerEntry.getValue()); 13051 } 13052 assertEquals(109, value); 13053 } 13054 13055 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 13056 if (entrySet instanceof NavigableSet) { 13057 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13058 try { 13059 ascendingSubMapEntrySet.ceiling(null); 13060 fail("should throw NullPointerException"); 13061 } catch (NullPointerException e) { 13062 // Expected 13063 } 13064 13065 iterator = ascendingSubMapEntrySet.iterator(); 13066 while (iterator.hasNext()) { 13067 entry = (Entry) iterator.next(); 13068 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 13069 value = (Integer) entry.getValue(); 13070 assertEquals(value, lowerEntry.getValue()); 13071 } 13072 assertEquals(108, value); 13073 } 13074 } 13075 13076 public void test_AscendingSubMapEntrySet_floor() { 13077 Set entrySet; 13078 NavigableSet ascendingSubMapEntrySet; 13079 Iterator iterator; 13080 Entry entry, floorEntry; 13081 int value; 13082 13083 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 13084 if (entrySet instanceof NavigableSet) { 13085 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13086 try { 13087 ascendingSubMapEntrySet.floor(null); 13088 fail("should throw NullPointerException"); 13089 } catch (NullPointerException e) { 13090 // Expected 13091 } 13092 13093 iterator = ascendingSubMapEntrySet.iterator(); 13094 for (int i = 101; i < 109; i++) { 13095 entry = (Entry) iterator.next(); 13096 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13097 assertEquals(entry.getValue(), floorEntry.getValue()); 13098 } 13099 assertFalse(iterator.hasNext()); 13100 } 13101 13102 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 13103 if (entrySet instanceof NavigableSet) { 13104 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13105 try { 13106 ascendingSubMapEntrySet.floor(null); 13107 fail("should throw NullPointerException"); 13108 } catch (NullPointerException e) { 13109 // Expected 13110 } 13111 13112 iterator = ascendingSubMapEntrySet.iterator(); 13113 for (int i = 101; i < 110; i++) { 13114 entry = (Entry) iterator.next(); 13115 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13116 assertEquals(entry.getValue(), floorEntry.getValue()); 13117 } 13118 assertFalse(iterator.hasNext()); 13119 } 13120 13121 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 13122 if (entrySet instanceof NavigableSet) { 13123 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13124 try { 13125 ascendingSubMapEntrySet.floor(null); 13126 fail("should throw NullPointerException"); 13127 } catch (NullPointerException e) { 13128 // Expected 13129 } 13130 13131 iterator = ascendingSubMapEntrySet.iterator(); 13132 for (int i = 100; i < 109; i++) { 13133 entry = (Entry) iterator.next(); 13134 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13135 assertEquals(entry.getValue(), floorEntry.getValue()); 13136 } 13137 assertFalse(iterator.hasNext()); 13138 } 13139 13140 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 13141 if (entrySet instanceof NavigableSet) { 13142 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13143 try { 13144 ascendingSubMapEntrySet.floor(null); 13145 fail("should throw NullPointerException"); 13146 } catch (NullPointerException e) { 13147 // Expected 13148 } 13149 13150 iterator = ascendingSubMapEntrySet.iterator(); 13151 for (int i = 100; i < 110; i++) { 13152 entry = (Entry) iterator.next(); 13153 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13154 assertEquals(entry.getValue(), floorEntry.getValue()); 13155 } 13156 assertFalse(iterator.hasNext()); 13157 } 13158 13159 // With Comparator 13160 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 13161 if (entrySet instanceof NavigableSet) { 13162 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13163 try { 13164 ascendingSubMapEntrySet.floor(null); 13165 fail("should throw NullPointerException"); 13166 } catch (NullPointerException e) { 13167 // Expected 13168 } 13169 13170 iterator = ascendingSubMapEntrySet.iterator(); 13171 for (int i = 101; i < 109; i++) { 13172 entry = (Entry) iterator.next(); 13173 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13174 assertEquals(entry.getValue(), floorEntry.getValue()); 13175 } 13176 assertFalse(iterator.hasNext()); 13177 } 13178 13179 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 13180 if (entrySet instanceof NavigableSet) { 13181 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13182 try { 13183 ascendingSubMapEntrySet.floor(null); 13184 fail("should throw NullPointerException"); 13185 } catch (NullPointerException e) { 13186 // Expected 13187 } 13188 13189 iterator = ascendingSubMapEntrySet.iterator(); 13190 for (int i = 101; i < 110; i++) { 13191 entry = (Entry) iterator.next(); 13192 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13193 assertEquals(entry.getValue(), floorEntry.getValue()); 13194 } 13195 assertFalse(iterator.hasNext()); 13196 } 13197 13198 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 13199 if (entrySet instanceof NavigableSet) { 13200 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13201 try { 13202 ascendingSubMapEntrySet.floor(null); 13203 fail("should throw NullPointerException"); 13204 } catch (NullPointerException e) { 13205 // Expected 13206 } 13207 13208 iterator = ascendingSubMapEntrySet.iterator(); 13209 for (int i = 100; i < 109; i++) { 13210 entry = (Entry) iterator.next(); 13211 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13212 assertEquals(entry.getValue(), floorEntry.getValue()); 13213 } 13214 assertFalse(iterator.hasNext()); 13215 } 13216 13217 entrySet = subMap_startIncluded_endIncluded.entrySet(); 13218 if (entrySet instanceof NavigableSet) { 13219 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13220 try { 13221 ascendingSubMapEntrySet.floor(null); 13222 fail("should throw NullPointerException"); 13223 } catch (NullPointerException e) { 13224 // Expected 13225 } 13226 13227 iterator = ascendingSubMapEntrySet.iterator(); 13228 for (int i = 100; i < 110; i++) { 13229 entry = (Entry) iterator.next(); 13230 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13231 assertEquals(entry.getValue(), floorEntry.getValue()); 13232 } 13233 assertFalse(iterator.hasNext()); 13234 } 13235 } 13236 13237 @Override 13238 protected void setUp() { 13239 tm = new TreeMap(); 13240 tm_comparator = new TreeMap(new MockComparator()); 13241 for (int i = 0; i < objArray.length; i++) { 13242 Object x = objArray[i] = new Integer(i); 13243 tm.put(x.toString(), x); 13244 tm_comparator.put(x.toString(), x); 13245 } 13246 13247 subMap_default = tm.subMap(objArray[100].toString(), objArray[109] 13248 .toString()); 13249 subMap_startExcluded_endExcluded = tm.subMap(objArray[100].toString(), 13250 false, objArray[109].toString(), false); 13251 subMap_startExcluded_endIncluded = tm.subMap(objArray[100].toString(), 13252 false, objArray[109].toString(), true); 13253 subMap_startIncluded_endExcluded = tm.subMap(objArray[100].toString(), 13254 true, objArray[109].toString(), false); 13255 subMap_startIncluded_endIncluded = tm.subMap(objArray[100].toString(), 13256 true, objArray[109].toString(), true); 13257 13258 subMap_default_beforeStart_100 = tm.subMap(objArray[0].toString(), 13259 objArray[1].toString()); 13260 13261 subMap_default_afterEnd_109 = tm.subMap(objArray[110].toString(), 13262 objArray[119].toString()); 13263 13264 assertTrue(subMap_startExcluded_endExcluded instanceof NavigableMap); 13265 assertTrue(subMap_startExcluded_endIncluded instanceof NavigableMap); 13266 assertTrue(subMap_startIncluded_endExcluded instanceof NavigableMap); 13267 assertTrue(subMap_startIncluded_endIncluded instanceof NavigableMap); 13268 13269 navigableMap_startExcluded_endExcluded = (NavigableMap) subMap_startExcluded_endExcluded; 13270 navigableMap_startExcluded_endIncluded = (NavigableMap) subMap_startExcluded_endIncluded; 13271 navigableMap_startIncluded_endExcluded = (NavigableMap) subMap_startIncluded_endExcluded; 13272 navigableMap_startIncluded_endIncluded = (NavigableMap) subMap_startIncluded_endIncluded; 13273 13274 subMap_default_comparator = tm_comparator.subMap(objArray[100] 13275 .toString(), objArray[109].toString()); 13276 subMap_startExcluded_endExcluded_comparator = tm_comparator.subMap( 13277 objArray[100].toString(), false, objArray[109].toString(), 13278 false); 13279 13280 subMap_startExcluded_endIncluded_comparator = tm_comparator 13281 .subMap(objArray[100].toString(), false, objArray[109] 13282 .toString(), true); 13283 subMap_startIncluded_endExcluded_comparator = tm_comparator 13284 .subMap(objArray[100].toString(), true, objArray[109] 13285 .toString(), false); 13286 subMap_startIncluded_endIncluded_comparator = tm_comparator.subMap( 13287 objArray[100].toString(), true, objArray[109].toString(), true); 13288 } 13289 13290 @Override 13291 protected void tearDown() { 13292 tm = null; 13293 tm_comparator = null; 13294 13295 subMap_default = null; 13296 subMap_startExcluded_endExcluded = null; 13297 subMap_startExcluded_endIncluded = null; 13298 subMap_startIncluded_endExcluded = null; 13299 subMap_startIncluded_endIncluded = null; 13300 13301 subMap_default_beforeStart_100 = null; 13302 subMap_default_afterEnd_109 = null; 13303 13304 subMap_default_comparator = null; 13305 subMap_startExcluded_endExcluded_comparator = null; 13306 subMap_startExcluded_endIncluded_comparator = null; 13307 subMap_startIncluded_endExcluded_comparator = null; 13308 subMap_startIncluded_endIncluded_comparator = null; 13309 } 13310 13311 public void test_lower_null() throws Exception { 13312 NavigableMap map = tm.subMap(objArray[100].toString(), true, 13313 objArray[100].toString(), false); 13314 assertNull(map.ceilingKey(objArray[100].toString())); 13315 assertNull(map.floorKey(objArray[100].toString())); 13316 assertNull(map.lowerKey(objArray[100].toString())); 13317 assertNull(map.higherKey(objArray[100].toString())); 13318 assertNull(map.ceilingKey(objArray[111].toString())); 13319 assertNull(map.floorKey(objArray[111].toString())); 13320 assertNull(map.lowerKey(objArray[111].toString())); 13321 assertNull(map.higherKey(objArray[111].toString())); 13322 assertNull(map.ceilingKey(objArray[1].toString())); 13323 assertNull(map.floorKey(objArray[1].toString())); 13324 assertNull(map.lowerKey(objArray[1].toString())); 13325 assertNull(map.higherKey(objArray[1].toString())); 13326 map = map.descendingMap(); 13327 assertNull(map.ceilingKey(objArray[100].toString())); 13328 assertNull(map.floorKey(objArray[100].toString())); 13329 assertNull(map.lowerKey(objArray[100].toString())); 13330 assertNull(map.higherKey(objArray[100].toString())); 13331 assertNull(map.ceilingKey(objArray[111].toString())); 13332 assertNull(map.floorKey(objArray[111].toString())); 13333 assertNull(map.lowerKey(objArray[111].toString())); 13334 assertNull(map.higherKey(objArray[111].toString())); 13335 assertNull(map.ceilingKey(objArray[1].toString())); 13336 assertNull(map.floorKey(objArray[1].toString())); 13337 assertNull(map.lowerKey(objArray[1].toString())); 13338 assertNull(map.higherKey(objArray[1].toString())); 13339 } 13340 13341 public void test_lower_tail() throws Exception { 13342 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13343 objArray[103].toString(), false); 13344 assertTrue(map.containsKey(objArray[102].toString())); 13345 assertFalse(map.containsKey(objArray[101].toString())); 13346 assertFalse(map.containsKey(objArray[103].toString())); 13347 assertFalse(map.containsKey(objArray[104].toString())); 13348 map = map.descendingMap(); 13349 assertTrue(map.containsKey(objArray[102].toString())); 13350 assertFalse(map.containsKey(objArray[101].toString())); 13351 assertFalse(map.containsKey(objArray[103].toString())); 13352 assertFalse(map.containsKey(objArray[104].toString())); 13353 map = tm.subMap(objArray[102].toString(), true, objArray[102] 13354 .toString(), false); 13355 assertFalse(map.containsKey(objArray[102].toString())); 13356 assertFalse(map.containsKey(objArray[101].toString())); 13357 assertFalse(map.containsKey(objArray[103].toString())); 13358 assertFalse(map.containsKey(objArray[104].toString())); 13359 map = map.descendingMap(); 13360 assertFalse(map.containsKey(objArray[102].toString())); 13361 assertFalse(map.containsKey(objArray[101].toString())); 13362 assertFalse(map.containsKey(objArray[103].toString())); 13363 assertFalse(map.containsKey(objArray[104].toString())); 13364 } 13365 13366 public void test_contains_null() throws Exception { 13367 NavigableMap map = tm.subMap(objArray[100].toString(), true, 13368 objArray[100].toString(), false); 13369 assertFalse(map.containsKey(objArray[100].toString())); 13370 assertFalse(map.containsKey(objArray[10].toString())); 13371 assertFalse(map.containsKey(objArray[101].toString())); 13372 assertFalse(map.containsKey(objArray[102].toString())); 13373 assertFalse(map.containsKey(objArray[1].toString())); 13374 map = map.descendingMap(); 13375 assertFalse(map.containsKey(objArray[100].toString())); 13376 assertFalse(map.containsKey(objArray[10].toString())); 13377 assertFalse(map.containsKey(objArray[101].toString())); 13378 assertFalse(map.containsKey(objArray[102].toString())); 13379 assertFalse(map.containsKey(objArray[1].toString())); 13380 } 13381 13382 public void test_contains() throws Exception { 13383 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13384 objArray[103].toString(), false); 13385 assertFalse(map.containsKey(objArray[100].toString())); 13386 assertFalse(map.containsKey(objArray[104].toString())); 13387 assertFalse(map.containsKey(objArray[101].toString())); 13388 assertTrue(map.containsKey(objArray[102].toString())); 13389 map = map.descendingMap(); 13390 assertFalse(map.containsKey(objArray[100].toString())); 13391 assertFalse(map.containsKey(objArray[104].toString())); 13392 assertFalse(map.containsKey(objArray[101].toString())); 13393 assertTrue(map.containsKey(objArray[102].toString())); 13394 } 13395 13396 public void test_size() throws Exception { 13397 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13398 objArray[103].toString(), false); 13399 assertEquals(0, map.headMap(objArray[102].toString(), false).size()); 13400 assertEquals(1, map.headMap(objArray[102].toString(), true).size()); 13401 try { 13402 assertEquals(1, map.headMap(objArray[103].toString(), true).size()); 13403 fail("should throw IAE"); 13404 } catch (IllegalArgumentException e) { 13405 } 13406 assertEquals(1, map.headMap(objArray[103].toString(), false).size()); 13407 assertEquals(1, map.tailMap(objArray[102].toString(), true).size()); 13408 assertEquals(0, map.tailMap(objArray[102].toString(), false).size()); 13409 assertTrue(map.headMap(objArray[103].toString(), false).containsKey( 13410 objArray[102].toString())); 13411 try { 13412 assertTrue(map.headMap(objArray[103].toString(), true).containsKey( 13413 objArray[102].toString())); 13414 fail("should throw IAE"); 13415 } catch (IllegalArgumentException e) { 13416 } 13417 assertFalse(map.headMap(objArray[102].toString(), false).containsKey( 13418 objArray[102].toString())); 13419 assertTrue(map.headMap(objArray[102].toString(), true).containsKey( 13420 objArray[102].toString())); 13421 assertTrue(map.tailMap(objArray[102].toString(), true).containsKey( 13422 objArray[102].toString())); 13423 assertFalse(map.tailMap(objArray[102].toString(), true).containsKey( 13424 objArray[103].toString())); 13425 try { 13426 assertEquals(0, map.tailMap(objArray[101].toString()).size()); 13427 fail("should throw IAE"); 13428 } catch (IllegalArgumentException e) { 13429 } 13430 map = map.descendingMap(); 13431 try { 13432 map = map.subMap(objArray[103].toString(), true, objArray[102] 13433 .toString(), true); 13434 fail("should throw IAE"); 13435 } catch (IllegalArgumentException e) { 13436 } 13437 map = map.subMap(objArray[102].toString(), true, objArray[102] 13438 .toString(), true); 13439 assertEquals(1, map.headMap(objArray[102].toString(), true).size()); 13440 assertEquals(0, map.headMap(objArray[102].toString(), false).size()); 13441 try { 13442 assertEquals(0, map.headMap(objArray[103].toString(), true).size()); 13443 fail("should throw IAE"); 13444 } catch (IllegalArgumentException e) { 13445 } 13446 13447 assertEquals(1, map.tailMap(objArray[102].toString(), true).size()); 13448 try { 13449 assertFalse(map.headMap(objArray[103].toString(), true) 13450 .containsKey(objArray[102].toString())); 13451 fail("should throw IAE"); 13452 } catch (IllegalArgumentException e) { 13453 } 13454 assertTrue(map.headMap(objArray[102].toString(), true).containsKey( 13455 objArray[102].toString())); 13456 assertFalse(map.headMap(objArray[102].toString(), false).containsKey( 13457 objArray[102].toString())); 13458 assertTrue(map.tailMap(objArray[102].toString(), true).containsKey( 13459 objArray[102].toString())); 13460 assertFalse(map.tailMap(objArray[102].toString(), true).containsKey( 13461 objArray[103].toString())); 13462 try { 13463 assertEquals(0, map.tailMap(objArray[101].toString()).size()); 13464 fail("should throw IAE"); 13465 } catch (IllegalArgumentException e) { 13466 } 13467 } 13468 13469 public void test_lower() throws Exception { 13470 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13471 objArray[103].toString(), false); 13472 assertEquals(objArray[102].toString(), map.higherKey(objArray[101] 13473 .toString())); 13474 assertEquals(null, map.higherKey(objArray[102].toString())); 13475 assertEquals(null, map.higherKey(objArray[103].toString())); 13476 assertEquals(null, map.higherKey(objArray[104].toString())); 13477 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[101] 13478 .toString())); 13479 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102] 13480 .toString())); 13481 assertEquals(null, map.ceilingKey(objArray[103].toString())); 13482 assertEquals(null, map.ceilingKey(objArray[104].toString())); 13483 assertEquals(null, map.lowerKey(objArray[101].toString())); 13484 assertEquals(null, map.lowerKey(objArray[102].toString())); 13485 assertEquals(objArray[102].toString(), map.lowerKey(objArray[103] 13486 .toString())); 13487 assertEquals(objArray[102].toString(), map.lowerKey(objArray[104] 13488 .toString())); 13489 assertEquals(null, map.floorKey(objArray[101].toString())); 13490 assertEquals(objArray[102].toString(), map.floorKey(objArray[102] 13491 .toString())); 13492 assertEquals(objArray[102].toString(), map.floorKey(objArray[103] 13493 .toString())); 13494 assertEquals(objArray[102].toString(), map.floorKey(objArray[104] 13495 .toString())); 13496 map = map.descendingMap(); 13497 assertEquals(null, map.higherKey(objArray[101].toString())); 13498 assertEquals(null, map.higherKey(objArray[102].toString())); 13499 assertEquals(objArray[102].toString(), map.higherKey(objArray[103] 13500 .toString())); 13501 assertEquals(objArray[102].toString(), map.higherKey(objArray[104] 13502 .toString())); 13503 assertEquals(null, map.ceilingKey(objArray[101].toString())); 13504 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102] 13505 .toString())); 13506 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[103] 13507 .toString())); 13508 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[104] 13509 .toString())); 13510 assertEquals(objArray[102].toString(), map.lowerKey(objArray[101] 13511 .toString())); 13512 assertEquals(null, map.lowerKey(objArray[102].toString())); 13513 assertEquals(null, map.lowerKey(objArray[103].toString())); 13514 assertEquals(null, map.lowerKey(objArray[104].toString())); 13515 assertEquals(objArray[102].toString(), map.floorKey(objArray[101] 13516 .toString())); 13517 assertEquals(objArray[102].toString(), map.floorKey(objArray[102] 13518 .toString())); 13519 assertEquals(null, map.floorKey(objArray[103].toString())); 13520 assertEquals(null, map.floorKey(objArray[104].toString())); 13521 } 13522 13523 public void test_lowerkey() throws Exception { 13524 try { 13525 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13526 false).descendingMap().firstKey(); 13527 fail("should throw NoSuchElementException"); 13528 } catch (Exception e) { 13529 // expected 13530 } 13531 try { 13532 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13533 false).descendingMap().lastKey(); 13534 fail("should throw NoSuchElementException"); 13535 } catch (Exception e) { 13536 // expected 13537 } 13538 try { 13539 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13540 false).firstKey(); 13541 fail("should throw NoSuchElementException"); 13542 } catch (Exception e) { 13543 // expected 13544 } 13545 try { 13546 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13547 false).lastKey(); 13548 fail("should throw NoSuchElementException"); 13549 } catch (Exception e) { 13550 // expected 13551 } 13552 13553 } 13554 13555 public void test_headMap() throws Exception { 13556 TreeMap tree = new TreeMap(); 13557 tree.put(new Integer(0), null); 13558 tree.put(new Integer(1), null); 13559 Map submap = tree.subMap(tree.firstKey(), tree.lastKey()); 13560 tree.remove(tree.lastKey()); 13561 assertEquals(submap, tree); 13562 } 13563 13564 public void testname() throws Exception { 13565 TreeMap nullTree = new TreeMap(new Comparator() { 13566 public int compare(Object o1, Object o2) { 13567 if (o1 == null) { 13568 return o2 == null ? 0 : -1; 13569 } 13570 return ((String) o1).compareTo((String) o2); 13571 } 13572 }); 13573 nullTree.put(new String("One"), 1); 13574 nullTree.put(new String("Two"), 2); 13575 nullTree.put(new String("Three"), 3); 13576 nullTree.put(new String("Four"), 4); 13577 nullTree.put(null, 0); 13578 nullTree.subMap(null, "two").size(); 13579 } 13580 13581 } 13582
