1package org.apache.harmony.luni.tests.java.util; 2 3/* 4 * Licensed to the Apache Software Foundation (ASF) under one or more 5 * contributor license agreements. See the NOTICE file distributed with 6 * this work for additional information regarding copyright ownership. 7 * The ASF licenses this file to You under the Apache License, Version 2.0 8 * (the "License"); you may not use this file except in compliance with 9 * the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 */ 19 20import java.util.Collection; 21import java.util.Collections; 22import java.util.Comparator; 23import java.util.Iterator; 24import java.util.Map; 25import java.util.NavigableMap; 26import java.util.NavigableSet; 27import java.util.NoSuchElementException; 28import java.util.Set; 29import java.util.SortedMap; 30import java.util.SortedSet; 31import java.util.TreeMap; 32import java.util.Map.Entry; 33 34import junit.framework.TestCase; 35 36import org.apache.harmony.luni.tests.java.util.TreeMapTest.MockComparator; 37 38// 39public class TreeMapExtendTest extends TestCase { 40 41 TreeMap tm; 42 43 TreeMap tm_comparator; 44 45 SortedMap subMap_default; 46 47 SortedMap subMap_startExcluded_endExcluded; 48 49 SortedMap subMap_startExcluded_endIncluded; 50 51 SortedMap subMap_startIncluded_endExcluded; 52 53 SortedMap subMap_startIncluded_endIncluded; 54 55 SortedMap subMap_default_beforeStart_100; 56 57 SortedMap subMap_default_afterEnd_109; 58 59 NavigableMap navigableMap_startExcluded_endExcluded; 60 61 NavigableMap navigableMap_startExcluded_endIncluded; 62 63 NavigableMap navigableMap_startIncluded_endExcluded; 64 65 NavigableMap navigableMap_startIncluded_endIncluded; 66 67 SortedMap subMap_default_comparator; 68 69 SortedMap subMap_startExcluded_endExcluded_comparator; 70 71 SortedMap subMap_startExcluded_endIncluded_comparator; 72 73 SortedMap subMap_startIncluded_endExcluded_comparator; 74 75 SortedMap subMap_startIncluded_endIncluded_comparator; 76 77 Object objArray[] = new Object[1000]; 78 79 public void test_TreeMap_Constructor_Default() { 80 TreeMap treeMap = new TreeMap(); 81 assertTrue(treeMap.isEmpty()); 82 assertNull(treeMap.comparator()); 83 assertEquals(0, treeMap.size()); 84 85 try { 86 treeMap.firstKey(); 87 fail("should throw NoSuchElementException"); 88 } catch (NoSuchElementException e) { 89 // Expected 90 } 91 assertNull(treeMap.firstEntry()); 92 93 try { 94 treeMap.lastKey(); 95 fail("should throw NoSuchElementException"); 96 } catch (NoSuchElementException e) { 97 // Expected 98 } 99 assertNull(treeMap.lastEntry()); 100 101 try { 102 treeMap.ceilingKey(1); 103 } catch (NoSuchElementException e) { 104 // Expected 105 } 106 assertNull(treeMap.ceilingEntry(1)); 107 108 try { 109 treeMap.floorKey(1); 110 } catch (NoSuchElementException e) { 111 // Expected 112 } 113 assertNull(treeMap.floorEntry(1)); 114 assertNull(treeMap.lowerKey(1)); 115 assertNull(treeMap.lowerEntry(1)); 116 assertNull(treeMap.higherKey(1)); 117 assertNull(treeMap.higherEntry(1)); 118 assertFalse(treeMap.containsKey(1)); 119 assertFalse(treeMap.containsValue(1)); 120 assertNull(treeMap.get(1)); 121 122 assertNull(treeMap.pollFirstEntry()); 123 assertNull(treeMap.pollLastEntry()); 124 assertEquals(0, treeMap.values().size()); 125 } 126 127 public void test_TreeMap_Constructor_Comparator() { 128 MockComparator mockComparator = new MockComparator(); 129 TreeMap treeMap = new TreeMap(mockComparator); 130 131 assertEquals(mockComparator, treeMap.comparator()); 132 } 133 134 public void test_TreeMap_Constructor_Map() { 135 TreeMap treeMap = new TreeMap(tm); 136 assertEquals(tm.size(), treeMap.size()); 137 assertEquals(tm.firstKey(), treeMap.firstKey()); 138 assertEquals(tm.firstEntry(), treeMap.firstEntry()); 139 assertEquals(tm.lastKey(), treeMap.lastKey()); 140 assertEquals(tm.lastEntry(), treeMap.lastEntry()); 141 assertEquals(tm.keySet(), treeMap.keySet()); 142 143 String key = new Integer(100).toString(); 144 assertEquals(tm.ceilingKey(key), treeMap.ceilingKey(key)); 145 assertEquals(tm.ceilingEntry(key), treeMap.ceilingEntry(key)); 146 assertEquals(tm.floorKey(key), treeMap.floorKey(key)); 147 assertEquals(tm.floorEntry(key), treeMap.floorEntry(key)); 148 assertEquals(tm.lowerKey(key), treeMap.lowerKey(key)); 149 assertEquals(tm.lowerEntry(key), treeMap.lowerEntry(key)); 150 assertEquals(tm.higherKey(key), treeMap.higherKey(key)); 151 assertEquals(tm.higherEntry(key), treeMap.higherEntry(key)); 152 assertEquals(tm.entrySet(), treeMap.entrySet()); 153 } 154 155 public void test_TreeMap_Constructor_SortedMap() { 156 TreeMap treeMap = new TreeMap(subMap_default); 157 assertEquals(subMap_default.size(), treeMap.size()); 158 assertEquals(subMap_default.firstKey(), treeMap.firstKey()); 159 assertEquals(subMap_default.lastKey(), treeMap.lastKey()); 160 assertEquals(subMap_default.keySet(), treeMap.keySet()); 161 assertEquals(subMap_default.entrySet(), treeMap.entrySet()); 162 } 163 164 public void test_TreeMap_clear() { 165 tm.clear(); 166 assertEquals(0, tm.size()); 167 } 168 169 public void test_TreeMap_clone() { 170 TreeMap cloneTreeMap = (TreeMap) tm.clone(); 171 assertEquals(tm, cloneTreeMap); 172 } 173 174 public void test_SubMap_Constructor() { 175 } 176 177 public void test_SubMap_clear() { 178 subMap_default.clear(); 179 assertEquals(0, subMap_default.size()); 180 } 181 182 public void test_SubMap_comparator() { 183 assertEquals(tm.comparator(), subMap_default.comparator()); 184 } 185 186 public void test_SubMap_containsKey() { 187 String key = null; 188 for (int counter = 101; counter < 109; counter++) { 189 key = objArray[counter].toString(); 190 assertTrue("SubMap contains incorrect elements", subMap_default 191 .containsKey(key)); 192 assertTrue("SubMap contains incorrect elements", 193 subMap_startExcluded_endExcluded.containsKey(key)); 194 assertTrue("SubMap contains incorrect elements", 195 subMap_startExcluded_endIncluded.containsKey(key)); 196 assertTrue("SubMap contains incorrect elements", 197 subMap_startIncluded_endExcluded.containsKey(key)); 198 assertTrue("SubMap contains incorrect elements", 199 subMap_startIncluded_endIncluded.containsKey(key)); 200 } 201 202 // Check boundary 203 key = objArray[100].toString(); 204 assertTrue("SubMap contains incorrect elements", subMap_default 205 .containsKey(key)); 206 assertFalse("SubMap contains incorrect elements", 207 subMap_startExcluded_endExcluded.containsKey(key)); 208 assertFalse("SubMap contains incorrect elements", 209 subMap_startExcluded_endIncluded.containsKey(key)); 210 assertTrue("SubMap contains incorrect elements", 211 subMap_startIncluded_endExcluded.containsKey(key)); 212 assertTrue("SubMap contains incorrect elements", 213 subMap_startIncluded_endIncluded.containsKey(key)); 214 215 key = objArray[109].toString(); 216 assertFalse("SubMap contains incorrect elements", subMap_default 217 .containsKey(key)); 218 assertFalse("SubMap contains incorrect elements", 219 subMap_startExcluded_endExcluded.containsKey(key)); 220 assertTrue("SubMap contains incorrect elements", 221 subMap_startExcluded_endIncluded.containsKey(key)); 222 assertFalse("SubMap contains incorrect elements", 223 subMap_startIncluded_endExcluded.containsKey(key)); 224 assertTrue("SubMap contains incorrect elements", 225 subMap_startIncluded_endIncluded.containsKey(key)); 226 227 // With Comparator 228 for (int counter = 101; counter < 109; counter++) { 229 key = objArray[counter].toString(); 230 assertTrue("SubMap contains incorrect elements", 231 subMap_default_comparator.containsKey(key)); 232 assertTrue("SubMap contains incorrect elements", 233 subMap_startExcluded_endExcluded_comparator 234 .containsKey(key)); 235 assertTrue("SubMap contains incorrect elements", 236 subMap_startExcluded_endIncluded_comparator 237 .containsKey(key)); 238 assertTrue("SubMap contains incorrect elements", 239 subMap_startIncluded_endExcluded_comparator 240 .containsKey(key)); 241 assertTrue("SubMap contains incorrect elements", 242 subMap_startIncluded_endIncluded_comparator 243 .containsKey(key)); 244 } 245 246 // Check boundary 247 key = objArray[100].toString(); 248 assertTrue("SubMap contains incorrect elements", 249 subMap_default_comparator.containsKey(key)); 250 assertFalse("SubMap contains incorrect elements", 251 subMap_startExcluded_endExcluded_comparator.containsKey(key)); 252 assertFalse("SubMap contains incorrect elements", 253 subMap_startExcluded_endIncluded_comparator.containsKey(key)); 254 assertTrue("SubMap contains incorrect elements", 255 subMap_startIncluded_endExcluded_comparator.containsKey(key)); 256 assertTrue("SubMap contains incorrect elements", 257 subMap_startIncluded_endIncluded_comparator.containsKey(key)); 258 259 key = objArray[109].toString(); 260 assertFalse("SubMap contains incorrect elements", 261 subMap_default_comparator.containsKey(key)); 262 assertFalse("SubMap contains incorrect elements", 263 subMap_startExcluded_endExcluded_comparator.containsKey(key)); 264 assertTrue("SubMap contains incorrect elements", 265 subMap_startExcluded_endIncluded_comparator.containsKey(key)); 266 assertFalse("SubMap contains incorrect elements", 267 subMap_startIncluded_endExcluded_comparator.containsKey(key)); 268 assertTrue("SubMap contains incorrect elements", 269 subMap_startIncluded_endIncluded_comparator.containsKey(key)); 270 } 271 272 public void test_SubMap_containsValue() { 273 Object value = null; 274 for (int counter = 101; counter < 109; counter++) { 275 value = objArray[counter]; 276 assertTrue("SubMap contains incorrect elements", subMap_default 277 .containsValue(value)); 278 assertTrue("SubMap contains incorrect elements", 279 subMap_startExcluded_endExcluded.containsValue(value)); 280 assertTrue("SubMap contains incorrect elements", 281 subMap_startExcluded_endIncluded.containsValue(value)); 282 assertTrue("SubMap contains incorrect elements", 283 subMap_startIncluded_endExcluded.containsValue(value)); 284 assertTrue("SubMap contains incorrect elements", 285 subMap_startIncluded_endIncluded.containsValue(value)); 286 } 287 288 // Check boundary 289 value = objArray[100]; 290 assertTrue("SubMap contains incorrect elements", subMap_default 291 .containsValue(value)); 292 assertFalse("SubMap contains incorrect elements", 293 subMap_startExcluded_endExcluded.containsValue(value)); 294 assertFalse("SubMap contains incorrect elements", 295 subMap_startExcluded_endIncluded.containsValue(value)); 296 assertTrue("SubMap contains incorrect elements", 297 subMap_startIncluded_endExcluded.containsValue(value)); 298 assertTrue("SubMap contains incorrect elements", 299 subMap_startIncluded_endIncluded.containsValue(value)); 300 301 value = objArray[109]; 302 assertFalse("SubMap contains incorrect elements", subMap_default 303 .containsValue(value)); 304 assertFalse("SubMap contains incorrect elements", 305 subMap_startExcluded_endExcluded.containsValue(value)); 306 assertTrue("SubMap contains incorrect elements", 307 subMap_startExcluded_endIncluded.containsValue(value)); 308 assertFalse("SubMap contains incorrect elements", 309 subMap_startIncluded_endExcluded.containsValue(value)); 310 assertTrue("SubMap contains incorrect elements", 311 subMap_startIncluded_endIncluded.containsValue(value)); 312 313 assertFalse(subMap_default.containsValue(null)); 314 315 TreeMap tm_null = new TreeMap(); 316 tm_null.put("0", 1); 317 tm_null.put("1", null); 318 tm_null.put("2", 2); 319 SortedMap subMap = tm_null.subMap("0", "2"); 320 assertTrue(subMap.containsValue(null)); 321 322 subMap.remove("1"); 323 assertFalse(subMap.containsValue(null)); 324 } 325 326 public void test_SubMap_entrySet() { 327 Set entrySet = subMap_default.entrySet(); 328 assertFalse(entrySet.isEmpty()); 329 assertEquals(9, entrySet.size()); 330 331 entrySet = subMap_startExcluded_endExcluded.entrySet(); 332 assertFalse(entrySet.isEmpty()); 333 assertEquals(8, entrySet.size()); 334 335 entrySet = subMap_startExcluded_endIncluded.entrySet(); 336 assertFalse(entrySet.isEmpty()); 337 assertEquals(9, entrySet.size()); 338 339 entrySet = subMap_startIncluded_endExcluded.entrySet(); 340 assertFalse(entrySet.isEmpty()); 341 assertEquals(9, entrySet.size()); 342 343 entrySet = subMap_startIncluded_endIncluded.entrySet(); 344 assertFalse(entrySet.isEmpty()); 345 assertEquals(10, entrySet.size()); 346 } 347 348 public void test_SubMap_firstKey() { 349 String firstKey1 = new Integer(100).toString(); 350 String firstKey2 = new Integer(101).toString(); 351 assertEquals(firstKey1, subMap_default.firstKey()); 352 assertEquals(firstKey2, subMap_startExcluded_endExcluded.firstKey()); 353 assertEquals(firstKey2, subMap_startExcluded_endIncluded.firstKey()); 354 assertEquals(firstKey1, subMap_startIncluded_endExcluded.firstKey()); 355 assertEquals(firstKey1, subMap_startIncluded_endIncluded.firstKey()); 356 357 try { 358 subMap_default.subMap(firstKey1, firstKey1).firstKey(); 359 fail("should throw NoSuchElementException"); 360 } catch (NoSuchElementException e) { 361 // Expected 362 } 363 364 try { 365 subMap_startExcluded_endExcluded.subMap(firstKey2, firstKey2) 366 .firstKey(); 367 fail("should throw NoSuchElementException"); 368 } catch (NoSuchElementException e) { 369 // Expected 370 } 371 372 try { 373 subMap_startExcluded_endIncluded.subMap(firstKey2, firstKey2) 374 .firstKey(); 375 fail("should throw NoSuchElementException"); 376 } catch (NoSuchElementException e) { 377 // Expected 378 } 379 380 try { 381 subMap_startIncluded_endExcluded.subMap(firstKey1, firstKey1) 382 .firstKey(); 383 fail("should throw NoSuchElementException"); 384 } catch (NoSuchElementException e) { 385 // Expected 386 } 387 388 try { 389 subMap_startIncluded_endIncluded.subMap(firstKey1, firstKey1) 390 .firstKey(); 391 fail("should throw NoSuchElementException"); 392 } catch (NoSuchElementException e) { 393 // Expected 394 } 395 396 // With Comparator 397 assertEquals(firstKey1, subMap_default_comparator.firstKey()); 398 assertEquals(firstKey2, subMap_startExcluded_endExcluded_comparator 399 .firstKey()); 400 assertEquals(firstKey2, subMap_startExcluded_endIncluded_comparator 401 .firstKey()); 402 assertEquals(firstKey1, subMap_startIncluded_endExcluded_comparator 403 .firstKey()); 404 assertEquals(firstKey1, subMap_startIncluded_endIncluded_comparator 405 .firstKey()); 406 407 try { 408 subMap_default_comparator.subMap(firstKey1, firstKey1).firstKey(); 409 fail("should throw NoSuchElementException"); 410 } catch (NoSuchElementException e) { 411 // Expected 412 } 413 414 try { 415 subMap_startExcluded_endExcluded_comparator.subMap(firstKey2, 416 firstKey2).firstKey(); 417 fail("should throw NoSuchElementException"); 418 } catch (NoSuchElementException e) { 419 // Expected 420 } 421 422 try { 423 subMap_startExcluded_endIncluded_comparator.subMap(firstKey2, 424 firstKey2).firstKey(); 425 fail("should throw NoSuchElementException"); 426 } catch (NoSuchElementException e) { 427 // Expected 428 } 429 430 try { 431 subMap_startIncluded_endExcluded_comparator.subMap(firstKey1, 432 firstKey1).firstKey(); 433 fail("should throw NoSuchElementException"); 434 } catch (NoSuchElementException e) { 435 // Expected 436 } 437 438 try { 439 subMap_startIncluded_endIncluded_comparator.subMap(firstKey1, 440 firstKey1).firstKey(); 441 fail("should throw NoSuchElementException"); 442 } catch (NoSuchElementException e) { 443 // Expected 444 } 445 446 } 447 448 public void test_SubMap_lastKey() { 449 String lastKey1 = new Integer(108).toString(); 450 String lastKey2 = new Integer(109).toString(); 451 assertEquals(lastKey1, subMap_default.lastKey()); 452 assertEquals(lastKey1, subMap_startExcluded_endExcluded.lastKey()); 453 assertEquals(lastKey2, subMap_startExcluded_endIncluded.lastKey()); 454 assertEquals(lastKey1, subMap_startIncluded_endExcluded.lastKey()); 455 assertEquals(lastKey2, subMap_startIncluded_endIncluded.lastKey()); 456 457 try { 458 subMap_default.subMap(lastKey1, lastKey1).lastKey(); 459 fail("should throw NoSuchElementException"); 460 } catch (NoSuchElementException e) { 461 // Expected 462 } 463 464 try { 465 subMap_startExcluded_endExcluded.subMap(lastKey1, lastKey1) 466 .lastKey(); 467 fail("should throw NoSuchElementException"); 468 } catch (NoSuchElementException e) { 469 // Expected 470 } 471 472 try { 473 subMap_startExcluded_endIncluded.subMap(lastKey2, lastKey2) 474 .lastKey(); 475 fail("should throw NoSuchElementException"); 476 } catch (NoSuchElementException e) { 477 // Expected 478 } 479 480 try { 481 subMap_startIncluded_endExcluded.subMap(lastKey1, lastKey1) 482 .lastKey(); 483 fail("should throw NoSuchElementException"); 484 } catch (NoSuchElementException e) { 485 // Expected 486 } 487 488 try { 489 subMap_startIncluded_endIncluded.subMap(lastKey2, lastKey2) 490 .lastKey(); 491 fail("should throw NoSuchElementException"); 492 } catch (NoSuchElementException e) { 493 // Expected 494 } 495 496 // With Comparator 497 assertEquals(lastKey1, subMap_default_comparator.lastKey()); 498 assertEquals(lastKey1, subMap_startExcluded_endExcluded_comparator 499 .lastKey()); 500 assertEquals(lastKey2, subMap_startExcluded_endIncluded_comparator 501 .lastKey()); 502 assertEquals(lastKey1, subMap_startIncluded_endExcluded_comparator 503 .lastKey()); 504 assertEquals(lastKey2, subMap_startIncluded_endIncluded_comparator 505 .lastKey()); 506 507 try { 508 subMap_default_comparator.subMap(lastKey1, lastKey1).lastKey(); 509 fail("should throw NoSuchElementException"); 510 } catch (NoSuchElementException e) { 511 // Expected 512 } 513 514 try { 515 subMap_startExcluded_endExcluded_comparator.subMap(lastKey1, 516 lastKey1).lastKey(); 517 fail("should throw NoSuchElementException"); 518 } catch (NoSuchElementException e) { 519 // Expected 520 } 521 522 try { 523 subMap_startExcluded_endIncluded_comparator.subMap(lastKey2, 524 lastKey2).lastKey(); 525 fail("should throw NoSuchElementException"); 526 } catch (NoSuchElementException e) { 527 // Expected 528 } 529 530 try { 531 subMap_startIncluded_endExcluded_comparator.subMap(lastKey1, 532 lastKey1).lastKey(); 533 fail("should throw NoSuchElementException"); 534 } catch (NoSuchElementException e) { 535 // Expected 536 } 537 538 try { 539 subMap_startIncluded_endIncluded_comparator.subMap(lastKey2, 540 lastKey2).lastKey(); 541 fail("should throw NoSuchElementException"); 542 } catch (NoSuchElementException e) { 543 // Expected 544 } 545 } 546 547 public void test_SubMap_get() { 548 // left boundary 549 Integer value = new Integer(100); 550 assertEquals(value, subMap_default.get(value.toString())); 551 assertEquals(null, subMap_startExcluded_endExcluded.get(value 552 .toString())); 553 assertEquals(null, subMap_startExcluded_endIncluded.get(value 554 .toString())); 555 assertEquals(value, subMap_startIncluded_endExcluded.get(value 556 .toString())); 557 assertEquals(value, subMap_startIncluded_endIncluded.get(value 558 .toString())); 559 560 // normal value 561 value = new Integer(105); 562 assertEquals(value, subMap_default.get(value.toString())); 563 assertEquals(value, subMap_startExcluded_endExcluded.get(value 564 .toString())); 565 assertEquals(value, subMap_startExcluded_endIncluded.get(value 566 .toString())); 567 assertEquals(value, subMap_startIncluded_endExcluded.get(value 568 .toString())); 569 assertEquals(value, subMap_startIncluded_endIncluded.get(value 570 .toString())); 571 572 // right boundary 573 value = new Integer(109); 574 assertEquals(null, subMap_default.get(value.toString())); 575 assertEquals(null, subMap_startExcluded_endExcluded.get(value 576 .toString())); 577 assertEquals(value, subMap_startExcluded_endIncluded.get(value 578 .toString())); 579 assertEquals(null, subMap_startIncluded_endExcluded.get(value 580 .toString())); 581 assertEquals(value, subMap_startIncluded_endIncluded.get(value 582 .toString())); 583 584 // With Comparator to test inInRange 585 // left boundary 586 value = new Integer(100); 587 assertEquals(value, subMap_default_comparator.get(value.toString())); 588 589 // normal value 590 value = new Integer(105); 591 assertEquals(value, subMap_default_comparator.get(value.toString())); 592 593 // right boundary 594 value = new Integer(109); 595 assertEquals(null, subMap_default_comparator.get(value.toString())); 596 } 597 598 public void test_SubMap_headMap() { 599 String endKey = new Integer(99).toString(); 600 try { 601 subMap_default.headMap(endKey); 602 fail("should throw IllegalArgumentException"); 603 } catch (IllegalArgumentException e) { 604 // Expected 605 } 606 607 try { 608 subMap_startExcluded_endExcluded.headMap(endKey); 609 fail("should throw IllegalArgumentException"); 610 } catch (IllegalArgumentException e) { 611 // Expected 612 } 613 614 try { 615 subMap_startExcluded_endIncluded.headMap(endKey); 616 fail("should throw IllegalArgumentException"); 617 } catch (IllegalArgumentException e) { 618 // Expected 619 } 620 621 try { 622 subMap_startIncluded_endExcluded.headMap(endKey); 623 fail("should throw IllegalArgumentException"); 624 } catch (IllegalArgumentException e) { 625 // Expected 626 } 627 628 try { 629 subMap_startIncluded_endIncluded.headMap(endKey); 630 fail("should throw IllegalArgumentException"); 631 } catch (IllegalArgumentException e) { 632 // Expected 633 } 634 635 SortedMap headMap = null; 636 endKey = new Integer(100).toString(); 637 headMap = subMap_default.headMap(endKey); 638 assertEquals(0, headMap.size()); 639 640 headMap = subMap_startExcluded_endExcluded.headMap(endKey); 641 assertEquals(0, headMap.size()); 642 643 headMap = subMap_startExcluded_endIncluded.headMap(endKey); 644 assertEquals(0, headMap.size()); 645 646 headMap = subMap_startIncluded_endExcluded.headMap(endKey); 647 assertEquals(0, headMap.size()); 648 649 headMap = subMap_startIncluded_endIncluded.headMap(endKey); 650 assertEquals(0, headMap.size()); 651 652 for (int i = 0, j = 101; i < 8; i++) { 653 endKey = new Integer(i + j).toString(); 654 headMap = subMap_default.headMap(endKey); 655 assertEquals(i + 1, headMap.size()); 656 657 headMap = subMap_startExcluded_endExcluded.headMap(endKey); 658 assertEquals(i, headMap.size()); 659 660 headMap = subMap_startExcluded_endIncluded.headMap(endKey); 661 assertEquals(i, headMap.size()); 662 663 headMap = subMap_startIncluded_endExcluded.headMap(endKey); 664 assertEquals(i + 1, headMap.size()); 665 666 headMap = subMap_startIncluded_endIncluded.headMap(endKey); 667 assertEquals(i + 1, headMap.size()); 668 } 669 670 endKey = new Integer(109).toString(); 671 headMap = subMap_default.headMap(endKey); 672 assertEquals(9, headMap.size()); 673 674 headMap = subMap_startExcluded_endExcluded.headMap(endKey); 675 assertEquals(8, headMap.size()); 676 677 headMap = subMap_startExcluded_endIncluded.headMap(endKey); 678 assertEquals(8, headMap.size()); 679 680 headMap = subMap_startIncluded_endExcluded.headMap(endKey); 681 assertEquals(9, headMap.size()); 682 683 headMap = subMap_startIncluded_endIncluded.headMap(endKey); 684 assertEquals(9, headMap.size()); 685 686 endKey = new Integer(110).toString(); 687 try { 688 subMap_default.headMap(endKey); 689 fail("should throw IllegalArgumentException"); 690 } catch (IllegalArgumentException e) { 691 // Expected 692 } 693 694 try { 695 subMap_startExcluded_endExcluded.headMap(endKey); 696 fail("should throw IllegalArgumentException"); 697 } catch (IllegalArgumentException e) { 698 // Expected 699 } 700 701 try { 702 subMap_startExcluded_endIncluded.headMap(endKey); 703 fail("should throw IllegalArgumentException"); 704 } catch (IllegalArgumentException e) { 705 // Expected 706 } 707 708 try { 709 subMap_startIncluded_endExcluded.headMap(endKey); 710 fail("should throw IllegalArgumentException"); 711 } catch (IllegalArgumentException e) { 712 // Expected 713 } 714 715 try { 716 subMap_startIncluded_endIncluded.headMap(endKey); 717 fail("should throw IllegalArgumentException"); 718 } catch (IllegalArgumentException e) { 719 // Expected 720 } 721 722 // With Comparator 723 endKey = new Integer(99).toString(); 724 try { 725 subMap_default_comparator.headMap(endKey); 726 fail("should throw IllegalArgumentException"); 727 } catch (IllegalArgumentException e) { 728 // Expected 729 } 730 731 try { 732 subMap_startExcluded_endExcluded_comparator.headMap(endKey); 733 fail("should throw IllegalArgumentException"); 734 } catch (IllegalArgumentException e) { 735 // Expected 736 } 737 738 try { 739 subMap_startExcluded_endIncluded_comparator.headMap(endKey); 740 fail("should throw IllegalArgumentException"); 741 } catch (IllegalArgumentException e) { 742 // Expected 743 } 744 745 try { 746 subMap_startIncluded_endExcluded_comparator.headMap(endKey); 747 fail("should throw IllegalArgumentException"); 748 } catch (IllegalArgumentException e) { 749 // Expected 750 } 751 752 try { 753 subMap_startIncluded_endIncluded_comparator.headMap(endKey); 754 fail("should throw IllegalArgumentException"); 755 } catch (IllegalArgumentException e) { 756 // Expected 757 } 758 759 headMap = null; 760 endKey = new Integer(100).toString(); 761 headMap = subMap_default_comparator.headMap(endKey); 762 assertEquals(0, headMap.size()); 763 764 headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey); 765 assertEquals(0, headMap.size()); 766 767 headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey); 768 assertEquals(0, headMap.size()); 769 770 headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey); 771 assertEquals(0, headMap.size()); 772 773 headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey); 774 assertEquals(0, headMap.size()); 775 776 for (int i = 0, j = 101; i < 8; i++) { 777 endKey = new Integer(i + j).toString(); 778 headMap = subMap_default_comparator.headMap(endKey); 779 assertEquals(i + 1, headMap.size()); 780 781 headMap = subMap_startExcluded_endExcluded_comparator 782 .headMap(endKey); 783 assertEquals(i, headMap.size()); 784 785 headMap = subMap_startExcluded_endIncluded_comparator 786 .headMap(endKey); 787 assertEquals(i, headMap.size()); 788 789 headMap = subMap_startIncluded_endExcluded_comparator 790 .headMap(endKey); 791 assertEquals(i + 1, headMap.size()); 792 793 headMap = subMap_startIncluded_endIncluded_comparator 794 .headMap(endKey); 795 assertEquals(i + 1, headMap.size()); 796 } 797 798 endKey = new Integer(108).toString(); 799 headMap = subMap_default_comparator.headMap(endKey); 800 assertEquals(8, headMap.size()); 801 802 headMap = subMap_startExcluded_endExcluded_comparator.headMap(endKey); 803 assertEquals(7, headMap.size()); 804 805 headMap = subMap_startExcluded_endIncluded_comparator.headMap(endKey); 806 assertEquals(7, headMap.size()); 807 808 headMap = subMap_startIncluded_endExcluded_comparator.headMap(endKey); 809 assertEquals(8, headMap.size()); 810 811 headMap = subMap_startIncluded_endIncluded_comparator.headMap(endKey); 812 assertEquals(8, headMap.size()); 813 814 endKey = new Integer(110).toString(); 815 try { 816 subMap_default_comparator.headMap(endKey); 817 fail("should throw IllegalArgumentException"); 818 } catch (IllegalArgumentException e) { 819 // Expected 820 } 821 822 try { 823 subMap_startExcluded_endExcluded_comparator.headMap(endKey); 824 fail("should throw IllegalArgumentException"); 825 } catch (IllegalArgumentException e) { 826 // Expected 827 } 828 829 try { 830 subMap_startExcluded_endIncluded_comparator.headMap(endKey); 831 fail("should throw IllegalArgumentException"); 832 } catch (IllegalArgumentException e) { 833 // Expected 834 } 835 836 try { 837 subMap_startIncluded_endExcluded_comparator.headMap(endKey); 838 fail("should throw IllegalArgumentException"); 839 } catch (IllegalArgumentException e) { 840 // Expected 841 } 842 843 try { 844 subMap_startIncluded_endIncluded_comparator.headMap(endKey); 845 fail("should throw IllegalArgumentException"); 846 } catch (IllegalArgumentException e) { 847 // Expected 848 } 849 } 850 851 public void test_SubMap_isEmpty() { 852 assertFalse(subMap_default.isEmpty()); 853 assertFalse(subMap_startExcluded_endExcluded.isEmpty()); 854 assertFalse(subMap_startExcluded_endIncluded.isEmpty()); 855 assertFalse(subMap_startIncluded_endExcluded.isEmpty()); 856 assertFalse(subMap_startIncluded_endIncluded.isEmpty()); 857 858 Object startKey = new Integer(100); 859 Object endKey = startKey; 860 SortedMap subMap = tm.subMap(startKey.toString(), endKey.toString()); 861 assertTrue(subMap.isEmpty()); 862 subMap = subMap_default.subMap(startKey.toString(), endKey.toString()); 863 assertTrue(subMap.isEmpty()); 864 subMap = subMap_startIncluded_endExcluded.subMap(startKey.toString(), 865 endKey.toString()); 866 assertTrue(subMap.isEmpty()); 867 subMap = subMap_startIncluded_endIncluded.subMap(startKey.toString(), 868 endKey.toString()); 869 assertTrue(subMap.isEmpty()); 870 871 for (int i = 0, j = 101; i < 8; i++) { 872 startKey = i + j; 873 endKey = startKey; 874 875 subMap = subMap_default.subMap(startKey.toString(), endKey 876 .toString()); 877 assertTrue(subMap.isEmpty()); 878 879 subMap = subMap_startExcluded_endExcluded.subMap(startKey 880 .toString(), endKey.toString()); 881 assertTrue(subMap.isEmpty()); 882 883 subMap = subMap_startExcluded_endIncluded.subMap(startKey 884 .toString(), endKey.toString()); 885 assertTrue(subMap.isEmpty()); 886 887 subMap = subMap_startIncluded_endExcluded.subMap(startKey 888 .toString(), endKey.toString()); 889 assertTrue(subMap.isEmpty()); 890 891 subMap = subMap_startIncluded_endIncluded.subMap(startKey 892 .toString(), endKey.toString()); 893 assertTrue(subMap.isEmpty()); 894 } 895 896 for (int i = 0, j = 101; i < 5; i++) { 897 startKey = i + j; 898 endKey = i + j + 4; 899 900 subMap = subMap_default.subMap(startKey.toString(), endKey 901 .toString()); 902 assertFalse(subMap.isEmpty()); 903 904 subMap = subMap_startExcluded_endExcluded.subMap(startKey 905 .toString(), endKey.toString()); 906 assertFalse(subMap.isEmpty()); 907 908 subMap = subMap_startExcluded_endIncluded.subMap(startKey 909 .toString(), endKey.toString()); 910 assertFalse(subMap.isEmpty()); 911 912 subMap = subMap_startIncluded_endExcluded.subMap(startKey 913 .toString(), endKey.toString()); 914 assertFalse(subMap.isEmpty()); 915 916 subMap = subMap_startIncluded_endIncluded.subMap(startKey 917 .toString(), endKey.toString()); 918 assertFalse(subMap.isEmpty()); 919 } 920 921 startKey = new Integer(109).toString(); 922 endKey = startKey; 923 subMap = tm.subMap(startKey.toString(), endKey.toString()); 924 assertTrue(subMap.isEmpty()); 925 subMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey); 926 assertTrue(subMap.isEmpty()); 927 subMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey); 928 assertTrue(subMap.isEmpty()); 929 930 } 931 932 public void test_SubMap_keySet() { 933 Set keySet = subMap_default.keySet(); 934 assertFalse(keySet.isEmpty()); 935 assertEquals(9, keySet.size()); 936 937 keySet = subMap_startExcluded_endExcluded.entrySet(); 938 assertFalse(keySet.isEmpty()); 939 assertEquals(8, keySet.size()); 940 941 keySet = subMap_startExcluded_endIncluded.entrySet(); 942 assertFalse(keySet.isEmpty()); 943 assertEquals(9, keySet.size()); 944 945 keySet = subMap_startIncluded_endExcluded.entrySet(); 946 assertFalse(keySet.isEmpty()); 947 assertEquals(9, keySet.size()); 948 949 keySet = subMap_startIncluded_endIncluded.entrySet(); 950 assertFalse(keySet.isEmpty()); 951 assertEquals(10, keySet.size()); 952 } 953 954 public void test_SubMap_put() { 955 Integer value = new Integer(100); 956 int addValue = 5; 957 958 subMap_default.put(value.toString(), value + addValue); 959 assertEquals(value + addValue, subMap_default.get(value.toString())); 960 961 try { 962 subMap_startExcluded_endExcluded.put(value.toString(), value 963 + addValue); 964 fail("should throw IllegalArgumentException"); 965 } catch (IllegalArgumentException e) { 966 // Expected 967 } 968 969 try { 970 subMap_startExcluded_endIncluded.put(value.toString(), value 971 + addValue); 972 fail("should throw IllegalArgumentException"); 973 } catch (IllegalArgumentException e) { 974 // Expected 975 } 976 977 subMap_startIncluded_endExcluded 978 .put(value.toString(), value + addValue); 979 assertEquals(value + addValue, subMap_startIncluded_endExcluded 980 .get(value.toString())); 981 982 subMap_startIncluded_endIncluded 983 .put(value.toString(), value + addValue); 984 assertEquals(value + addValue, subMap_startIncluded_endIncluded 985 .get(value.toString())); 986 987 value = new Integer(109); 988 try { 989 subMap_default.put(value.toString(), value + addValue); 990 fail("should throw IllegalArgumentException"); 991 } catch (IllegalArgumentException e) { 992 // Expected 993 } 994 995 try { 996 subMap_startExcluded_endExcluded.put(value.toString(), value 997 + addValue); 998 fail("should throw IllegalArgumentException"); 999 } catch (IllegalArgumentException e) { 1000 // Expected 1001 } 1002 1003 subMap_startExcluded_endIncluded 1004 .put(value.toString(), value + addValue); 1005 assertEquals(value + addValue, subMap_startExcluded_endIncluded 1006 .get(value.toString())); 1007 1008 try { 1009 subMap_startIncluded_endExcluded.put(value.toString(), value 1010 + addValue); 1011 fail("should throw IllegalArgumentException"); 1012 } catch (IllegalArgumentException e) { 1013 // Expected 1014 } 1015 1016 subMap_startIncluded_endIncluded 1017 .put(value.toString(), value + addValue); 1018 assertEquals(value + addValue, subMap_startIncluded_endIncluded 1019 .get(value.toString())); 1020 } 1021 1022 public void test_SubMap_remove() { 1023 Integer value = new Integer(100); 1024 1025 subMap_default.remove(value.toString()); 1026 assertNull(subMap_default.get(value.toString())); 1027 1028 subMap_startExcluded_endExcluded.remove(value.toString()); 1029 assertNull(subMap_startExcluded_endExcluded.get(value.toString())); 1030 1031 subMap_startExcluded_endIncluded.remove(value.toString()); 1032 assertNull(subMap_startExcluded_endIncluded.get(value.toString())); 1033 1034 subMap_startIncluded_endExcluded.remove(value.toString()); 1035 assertNull(subMap_startIncluded_endExcluded.get(value.toString())); 1036 1037 subMap_startIncluded_endIncluded.remove(value.toString()); 1038 assertNull(subMap_startIncluded_endIncluded.get(value.toString())); 1039 1040 value = new Integer(109); 1041 subMap_default.remove(value.toString()); 1042 assertNull(subMap_default.get(value.toString())); 1043 1044 subMap_startExcluded_endExcluded.remove(value.toString()); 1045 assertNull(subMap_startExcluded_endExcluded.get(value.toString())); 1046 1047 subMap_startExcluded_endIncluded.remove(value.toString()); 1048 assertNull(subMap_startExcluded_endIncluded.get(value.toString())); 1049 1050 subMap_startIncluded_endExcluded.remove(value.toString()); 1051 assertNull(subMap_startIncluded_endExcluded.get(value.toString())); 1052 1053 subMap_startIncluded_endIncluded.remove(value.toString()); 1054 assertNull(subMap_startIncluded_endIncluded.get(value.toString())); 1055 } 1056 1057 public void test_SubMap_subMap_NoComparator() { 1058 String startKey = new Integer[100].toString(); 1059 String endKey = new Integer[100].toString(); 1060 try { 1061 subMap_default.subMap(startKey, endKey); 1062 fail("should throw IllegalArgumentException"); 1063 } catch (IllegalArgumentException e) { 1064 // Expected 1065 } 1066 1067 try { 1068 subMap_startExcluded_endExcluded.subMap(startKey, endKey); 1069 fail("should throw IllegalArgumentException"); 1070 } catch (IllegalArgumentException e) { 1071 // Expected 1072 } 1073 1074 try { 1075 subMap_startExcluded_endIncluded.subMap(startKey, endKey); 1076 fail("should throw IllegalArgumentException"); 1077 } catch (IllegalArgumentException e) { 1078 // Expected 1079 } 1080 1081 try { 1082 subMap_startIncluded_endExcluded.subMap(startKey, endKey); 1083 fail("should throw IllegalArgumentException"); 1084 } catch (IllegalArgumentException e) { 1085 // Expected 1086 } 1087 1088 try { 1089 subMap_startIncluded_endIncluded.subMap(startKey, endKey); 1090 fail("should throw IllegalArgumentException"); 1091 } catch (IllegalArgumentException e) { 1092 // Expected 1093 } 1094 1095 SortedMap subSubMap = null; 1096 for (int i = 101; i < 109; i++) { 1097 startKey = new Integer(i).toString(); 1098 endKey = startKey; 1099 1100 subSubMap = subMap_default.subMap(startKey, endKey); 1101 assertEquals(0, subSubMap.size()); 1102 1103 subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, 1104 endKey); 1105 assertEquals(0, subSubMap.size()); 1106 1107 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, 1108 endKey); 1109 assertEquals(0, subSubMap.size()); 1110 1111 subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, 1112 endKey); 1113 assertEquals(0, subSubMap.size()); 1114 1115 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, 1116 endKey); 1117 assertEquals(0, subSubMap.size()); 1118 } 1119 1120 for (int i = 101, j = 5; i < 105; i++) { 1121 startKey = new Integer(i).toString(); 1122 endKey = new Integer(i + j).toString(); 1123 1124 subSubMap = subMap_default.subMap(startKey, endKey); 1125 assertEquals(j, subSubMap.size()); 1126 1127 subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, 1128 endKey); 1129 assertEquals(j, subSubMap.size()); 1130 1131 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, 1132 endKey); 1133 assertEquals(j, subSubMap.size()); 1134 1135 subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, 1136 endKey); 1137 assertEquals(j, subSubMap.size()); 1138 1139 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, 1140 endKey); 1141 assertEquals(j, subSubMap.size()); 1142 } 1143 1144 startKey = new Integer(108).toString(); 1145 endKey = new Integer(109).toString(); 1146 1147 subSubMap = subMap_default.subMap(startKey, endKey); 1148 assertEquals(1, subSubMap.size()); 1149 1150 subSubMap = subMap_startExcluded_endExcluded.subMap(startKey, endKey); 1151 assertEquals(1, subSubMap.size()); 1152 1153 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey); 1154 assertEquals(1, subSubMap.size()); 1155 1156 subSubMap = subMap_startIncluded_endExcluded.subMap(startKey, endKey); 1157 assertEquals(1, subSubMap.size()); 1158 1159 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey); 1160 assertEquals(1, subSubMap.size()); 1161 1162 startKey = new Integer(109).toString(); 1163 endKey = new Integer(109).toString(); 1164 1165 try { 1166 subMap_default.subMap(startKey, endKey); 1167 fail("should throw IllegalArgumentException"); 1168 } catch (IllegalArgumentException e) { 1169 // Expected 1170 } 1171 1172 try { 1173 subMap_startExcluded_endExcluded.subMap(startKey, endKey); 1174 fail("should throw IllegalArgumentException"); 1175 } catch (IllegalArgumentException e) { 1176 // Expected 1177 } 1178 1179 subSubMap = subMap_startExcluded_endIncluded.subMap(startKey, endKey); 1180 assertEquals(0, subSubMap.size()); 1181 1182 try { 1183 subMap_startIncluded_endExcluded.subMap(startKey, endKey); 1184 fail("should throw IllegalArgumentException"); 1185 } catch (IllegalArgumentException e) { 1186 // Expected 1187 } 1188 1189 subSubMap = subMap_startIncluded_endIncluded.subMap(startKey, endKey); 1190 assertEquals(0, subSubMap.size()); 1191 } 1192 1193 public void test_SubMap_subMap_Comparator() { 1194 String startKey = new Integer[100].toString(); 1195 String endKey = new Integer[100].toString(); 1196 try { 1197 subMap_default_comparator.subMap(startKey, endKey); 1198 fail("should throw IllegalArgumentException"); 1199 } catch (IllegalArgumentException e) { 1200 // Expected 1201 } 1202 1203 try { 1204 subMap_startExcluded_endExcluded_comparator 1205 .subMap(startKey, endKey); 1206 fail("should throw IllegalArgumentException"); 1207 } catch (IllegalArgumentException e) { 1208 // Expected 1209 } 1210 1211 try { 1212 subMap_startExcluded_endIncluded_comparator 1213 .subMap(startKey, endKey); 1214 fail("should throw IllegalArgumentException"); 1215 } catch (IllegalArgumentException e) { 1216 // Expected 1217 } 1218 1219 try { 1220 subMap_startIncluded_endExcluded_comparator 1221 .subMap(startKey, endKey); 1222 fail("should throw IllegalArgumentException"); 1223 } catch (IllegalArgumentException e) { 1224 // Expected 1225 } 1226 1227 try { 1228 subMap_startIncluded_endIncluded_comparator 1229 .subMap(startKey, endKey); 1230 fail("should throw IllegalArgumentException"); 1231 } catch (IllegalArgumentException e) { 1232 // Expected 1233 } 1234 1235 SortedMap subSubMap = null; 1236 for (int i = 101; i < 109; i++) { 1237 startKey = new Integer(i).toString(); 1238 endKey = startKey; 1239 1240 subSubMap = subMap_default_comparator.subMap(startKey, endKey); 1241 assertEquals(0, subSubMap.size()); 1242 1243 subSubMap = subMap_startExcluded_endExcluded_comparator.subMap( 1244 startKey, endKey); 1245 assertEquals(0, subSubMap.size()); 1246 1247 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1248 startKey, endKey); 1249 assertEquals(0, subSubMap.size()); 1250 1251 subSubMap = subMap_startIncluded_endExcluded_comparator.subMap( 1252 startKey, endKey); 1253 assertEquals(0, subSubMap.size()); 1254 1255 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1256 startKey, endKey); 1257 assertEquals(0, subSubMap.size()); 1258 } 1259 1260 for (int i = 101, j = 5; i < 105; i++) { 1261 startKey = new Integer(i).toString(); 1262 endKey = new Integer(i + j).toString(); 1263 1264 subSubMap = subMap_default_comparator.subMap(startKey, endKey); 1265 assertEquals(j, subSubMap.size()); 1266 1267 subSubMap = subMap_startExcluded_endExcluded_comparator.subMap( 1268 startKey, endKey); 1269 assertEquals(j, subSubMap.size()); 1270 1271 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1272 startKey, endKey); 1273 assertEquals(j, subSubMap.size()); 1274 1275 subSubMap = subMap_startIncluded_endExcluded_comparator.subMap( 1276 startKey, endKey); 1277 assertEquals(j, subSubMap.size()); 1278 1279 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1280 startKey, endKey); 1281 assertEquals(j, subSubMap.size()); 1282 } 1283 1284 startKey = new Integer(108).toString(); 1285 endKey = new Integer(109).toString(); 1286 1287 subSubMap = subMap_default_comparator.subMap(startKey, endKey); 1288 assertEquals(1, subSubMap.size()); 1289 1290 subSubMap = subMap_startExcluded_endExcluded_comparator.subMap( 1291 startKey, endKey); 1292 assertEquals(1, subSubMap.size()); 1293 1294 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1295 startKey, endKey); 1296 assertEquals(1, subSubMap.size()); 1297 1298 subSubMap = subMap_startIncluded_endExcluded_comparator.subMap( 1299 startKey, endKey); 1300 assertEquals(1, subSubMap.size()); 1301 1302 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1303 startKey, endKey); 1304 assertEquals(1, subSubMap.size()); 1305 1306 startKey = new Integer(109).toString(); 1307 endKey = new Integer(109).toString(); 1308 1309 try { 1310 subMap_default_comparator.subMap(startKey, endKey); 1311 fail("should throw IllegalArgumentException"); 1312 } catch (IllegalArgumentException e) { 1313 // Expected 1314 } 1315 1316 try { 1317 subMap_startExcluded_endExcluded_comparator 1318 .subMap(startKey, endKey); 1319 fail("should throw IllegalArgumentException"); 1320 } catch (IllegalArgumentException e) { 1321 // Expected 1322 } 1323 1324 subSubMap = subMap_startExcluded_endIncluded_comparator.subMap( 1325 startKey, endKey); 1326 assertEquals(0, subSubMap.size()); 1327 1328 try { 1329 subMap_startIncluded_endExcluded_comparator 1330 .subMap(startKey, endKey); 1331 fail("should throw IllegalArgumentException"); 1332 } catch (IllegalArgumentException e) { 1333 // Expected 1334 } 1335 1336 subSubMap = subMap_startIncluded_endIncluded_comparator.subMap( 1337 startKey, endKey); 1338 assertEquals(0, subSubMap.size()); 1339 } 1340 1341 public void test_SubMap_tailMap() { 1342 String startKey = new Integer(99).toString(); 1343 try { 1344 subMap_default.tailMap(startKey); 1345 fail("should throw IllegalArgumentException"); 1346 } catch (IllegalArgumentException e) { 1347 // Expected 1348 } 1349 1350 try { 1351 subMap_startExcluded_endExcluded.tailMap(startKey); 1352 fail("should throw IllegalArgumentException"); 1353 } catch (IllegalArgumentException e) { 1354 // Expected 1355 } 1356 1357 try { 1358 subMap_startExcluded_endIncluded.tailMap(startKey); 1359 fail("should throw IllegalArgumentException"); 1360 } catch (IllegalArgumentException e) { 1361 // Expected 1362 } 1363 1364 try { 1365 subMap_startIncluded_endExcluded.tailMap(startKey); 1366 fail("should throw IllegalArgumentException"); 1367 } catch (IllegalArgumentException e) { 1368 // Expected 1369 } 1370 1371 try { 1372 subMap_startIncluded_endIncluded.tailMap(startKey); 1373 fail("should throw IllegalArgumentException"); 1374 } catch (IllegalArgumentException e) { 1375 // Expected 1376 } 1377 SortedMap tailMap = null; 1378 1379 startKey = new Integer(100).toString(); 1380 tailMap = subMap_default.tailMap(startKey); 1381 assertEquals(9, tailMap.size()); 1382 1383 try { 1384 subMap_startExcluded_endExcluded.tailMap(startKey); 1385 fail("should throw IllegalArgumentException"); 1386 } catch (IllegalArgumentException e) { 1387 // Expected 1388 } 1389 1390 try { 1391 subMap_startExcluded_endIncluded.tailMap(startKey); 1392 fail("should throw IllegalArgumentException"); 1393 } catch (IllegalArgumentException e) { 1394 // Expected 1395 } 1396 1397 tailMap = subMap_startIncluded_endExcluded.tailMap(startKey); 1398 assertEquals(9, tailMap.size()); 1399 1400 tailMap = subMap_startIncluded_endIncluded.tailMap(startKey); 1401 assertEquals(10, tailMap.size()); 1402 1403 for (int i = 0, j = 101, end = 8; i < end; i++) { 1404 startKey = new Integer(i + j).toString(); 1405 tailMap = subMap_default.tailMap(startKey); 1406 assertEquals(end - i, tailMap.size()); 1407 1408 tailMap = subMap_startExcluded_endExcluded.tailMap(startKey); 1409 assertEquals(end - i, tailMap.size()); 1410 1411 tailMap = subMap_startExcluded_endIncluded.tailMap(startKey); 1412 assertEquals(end - i + 1, tailMap.size()); 1413 1414 tailMap = subMap_startIncluded_endExcluded.tailMap(startKey); 1415 assertEquals(end - i, tailMap.size()); 1416 1417 tailMap = subMap_startIncluded_endIncluded.tailMap(startKey); 1418 assertEquals(end - i + 1, tailMap.size()); 1419 } 1420 1421 startKey = new Integer(109).toString(); 1422 try { 1423 subMap_default.tailMap(startKey); 1424 fail("should throw IllegalArgumentException"); 1425 } catch (IllegalArgumentException e) { 1426 // Expected 1427 } 1428 try { 1429 subMap_startExcluded_endExcluded.tailMap(startKey); 1430 fail("should throw IllegalArgumentException"); 1431 } catch (IllegalArgumentException e) { 1432 // Expected 1433 } 1434 1435 tailMap = subMap_startExcluded_endIncluded.tailMap(startKey); 1436 assertEquals(1, tailMap.size()); 1437 1438 try { 1439 subMap_startIncluded_endExcluded.tailMap(startKey); 1440 fail("should throw IllegalArgumentException"); 1441 } catch (IllegalArgumentException e) { 1442 // Expected 1443 } 1444 1445 tailMap = subMap_startIncluded_endIncluded.tailMap(startKey); 1446 assertEquals(1, tailMap.size()); 1447 1448 startKey = new Integer(110).toString(); 1449 try { 1450 subMap_default.tailMap(startKey); 1451 fail("should throw IllegalArgumentException"); 1452 } catch (IllegalArgumentException e) { 1453 // Expected 1454 } 1455 1456 try { 1457 subMap_startExcluded_endExcluded.tailMap(startKey); 1458 fail("should throw IllegalArgumentException"); 1459 } catch (IllegalArgumentException e) { 1460 // Expected 1461 } 1462 try { 1463 subMap_startExcluded_endIncluded.tailMap(startKey); 1464 fail("should throw IllegalArgumentException"); 1465 } catch (IllegalArgumentException e) { 1466 // Expected 1467 } 1468 try { 1469 subMap_startIncluded_endExcluded.tailMap(startKey); 1470 fail("should throw IllegalArgumentException"); 1471 } catch (IllegalArgumentException e) { 1472 // Expected 1473 } 1474 try { 1475 subMap_startIncluded_endIncluded.tailMap(startKey); 1476 fail("should throw IllegalArgumentException"); 1477 } catch (IllegalArgumentException e) { 1478 // Expected 1479 } 1480 } 1481 1482 public void test_SubMap_values() { 1483 Collection values = subMap_default.values(); 1484 1485 assertFalse(values.isEmpty()); 1486 assertTrue(values.contains(100)); 1487 for (int i = 101; i < 109; i++) { 1488 assertTrue(values.contains(i)); 1489 } 1490 assertFalse(values.contains(109)); 1491 1492 values = subMap_startExcluded_endExcluded.values(); 1493 assertFalse(values.isEmpty()); 1494 assertFalse(values.contains(100)); 1495 for (int i = 101; i < 109; i++) { 1496 assertTrue(values.contains(i)); 1497 } 1498 assertFalse(values.contains(109)); 1499 1500 values = subMap_startExcluded_endIncluded.values(); 1501 assertFalse(values.isEmpty()); 1502 assertFalse(values.contains(100)); 1503 for (int i = 101; i < 109; i++) { 1504 assertTrue(values.contains(i)); 1505 } 1506 assertTrue(values.contains(109)); 1507 1508 values = subMap_startIncluded_endExcluded.values(); 1509 assertFalse(values.isEmpty()); 1510 assertTrue(values.contains(100)); 1511 for (int i = 101; i < 109; i++) { 1512 assertTrue(values.contains(i)); 1513 } 1514 assertFalse(values.contains(109)); 1515 1516 values = subMap_startIncluded_endIncluded.values(); 1517 assertFalse(values.isEmpty()); 1518 assertTrue(values.contains(100)); 1519 for (int i = 100; i < 109; i++) { 1520 assertTrue(values.contains(i)); 1521 } 1522 assertTrue(values.contains(109)); 1523 } 1524 1525 public void test_SubMap_size() { 1526 assertEquals(9, subMap_default.size()); 1527 assertEquals(8, subMap_startExcluded_endExcluded.size()); 1528 assertEquals(9, subMap_startExcluded_endIncluded.size()); 1529 assertEquals(9, subMap_startIncluded_endExcluded.size()); 1530 assertEquals(10, subMap_startIncluded_endIncluded.size()); 1531 1532 assertEquals(9, subMap_default_comparator.size()); 1533 assertEquals(8, subMap_startExcluded_endExcluded_comparator.size()); 1534 assertEquals(9, subMap_startExcluded_endIncluded_comparator.size()); 1535 assertEquals(9, subMap_startIncluded_endExcluded_comparator.size()); 1536 assertEquals(10, subMap_startIncluded_endIncluded_comparator.size()); 1537 } 1538 1539 public void test_SubMap_readObject() throws Exception { 1540 // SerializationTest.verifySelf(subMap_default); 1541 // SerializationTest.verifySelf(subMap_startExcluded_endExcluded); 1542 // SerializationTest.verifySelf(subMap_startExcluded_endIncluded); 1543 // SerializationTest.verifySelf(subMap_startIncluded_endExcluded); 1544 // SerializationTest.verifySelf(subMap_startIncluded_endIncluded); 1545 } 1546 1547 public void test_AscendingSubMap_ceilingEntry() { 1548 String key = new Integer(99).toString(); 1549 assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key)); 1550 assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key)); 1551 assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key)); 1552 assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key)); 1553 1554 key = new Integer(100).toString(); 1555 assertEquals(101, navigableMap_startExcluded_endExcluded.ceilingEntry( 1556 key).getValue()); 1557 assertEquals(101, navigableMap_startExcluded_endIncluded.ceilingEntry( 1558 key).getValue()); 1559 assertEquals(100, navigableMap_startIncluded_endExcluded.ceilingEntry( 1560 key).getValue()); 1561 assertEquals(100, navigableMap_startIncluded_endIncluded.ceilingEntry( 1562 key).getValue()); 1563 1564 for (int i = 101; i < 109; i++) { 1565 key = new Integer(i).toString(); 1566 assertEquals(i, navigableMap_startExcluded_endExcluded 1567 .ceilingEntry(key).getValue()); 1568 assertEquals(i, navigableMap_startExcluded_endIncluded 1569 .ceilingEntry(key).getValue()); 1570 assertEquals(i, navigableMap_startIncluded_endExcluded 1571 .ceilingEntry(key).getValue()); 1572 assertEquals(i, navigableMap_startIncluded_endIncluded 1573 .ceilingEntry(key).getValue()); 1574 1575 } 1576 1577 key = new Integer(109).toString(); 1578 assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key)); 1579 assertEquals(109, navigableMap_startExcluded_endIncluded.ceilingEntry( 1580 key).getValue()); 1581 assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key)); 1582 assertEquals(109, navigableMap_startIncluded_endIncluded.ceilingEntry( 1583 key).getValue()); 1584 1585 key = new Integer(110).toString(); 1586 assertNull(navigableMap_startExcluded_endExcluded.ceilingEntry(key)); 1587 assertNull(navigableMap_startExcluded_endIncluded.ceilingEntry(key)); 1588 assertNull(navigableMap_startIncluded_endExcluded.ceilingEntry(key)); 1589 assertNull(navigableMap_startIncluded_endIncluded.ceilingEntry(key)); 1590 } 1591 1592 public void test_AscendingSubMap_descendingMap() { 1593 NavigableMap descendingMap = navigableMap_startExcluded_endExcluded 1594 .descendingMap(); 1595 assertEquals(navigableMap_startExcluded_endExcluded.size(), 1596 descendingMap.size()); 1597 assertNotNull(descendingMap.comparator()); 1598 1599 assertEquals(navigableMap_startExcluded_endExcluded.firstKey(), 1600 descendingMap.lastKey()); 1601 assertEquals(navigableMap_startExcluded_endExcluded.firstEntry(), 1602 descendingMap.lastEntry()); 1603 1604 assertEquals(navigableMap_startExcluded_endExcluded.lastKey(), 1605 descendingMap.firstKey()); 1606 assertEquals(navigableMap_startExcluded_endExcluded.lastEntry(), 1607 descendingMap.firstEntry()); 1608 1609 descendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 1610 assertEquals(navigableMap_startExcluded_endIncluded.size(), 1611 descendingMap.size()); 1612 assertNotNull(descendingMap.comparator()); 1613 1614 assertEquals(navigableMap_startExcluded_endIncluded.firstKey(), 1615 descendingMap.lastKey()); 1616 assertEquals(navigableMap_startExcluded_endIncluded.firstEntry(), 1617 descendingMap.lastEntry()); 1618 1619 assertEquals(navigableMap_startExcluded_endIncluded.lastKey(), 1620 descendingMap.firstKey()); 1621 assertEquals(navigableMap_startExcluded_endIncluded.lastEntry(), 1622 descendingMap.firstEntry()); 1623 1624 descendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 1625 assertEquals(navigableMap_startIncluded_endExcluded.size(), 1626 descendingMap.size()); 1627 assertNotNull(descendingMap.comparator()); 1628 1629 assertEquals(navigableMap_startIncluded_endExcluded.firstKey(), 1630 descendingMap.lastKey()); 1631 assertEquals(navigableMap_startIncluded_endExcluded.firstEntry(), 1632 descendingMap.lastEntry()); 1633 1634 assertEquals(navigableMap_startIncluded_endExcluded.lastKey(), 1635 descendingMap.firstKey()); 1636 assertEquals(navigableMap_startIncluded_endExcluded.lastEntry(), 1637 descendingMap.firstEntry()); 1638 1639 descendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 1640 assertEquals(navigableMap_startIncluded_endIncluded.size(), 1641 descendingMap.size()); 1642 assertNotNull(descendingMap.comparator()); 1643 1644 assertEquals(navigableMap_startIncluded_endIncluded.firstKey(), 1645 descendingMap.lastKey()); 1646 assertEquals(navigableMap_startIncluded_endIncluded.firstEntry(), 1647 descendingMap.lastEntry()); 1648 1649 assertEquals(navigableMap_startIncluded_endIncluded.lastKey(), 1650 descendingMap.firstKey()); 1651 assertEquals(navigableMap_startIncluded_endIncluded.lastEntry(), 1652 descendingMap.firstEntry()); 1653 } 1654 1655 public void test_AscendingSubMap_floorEntry() { 1656 String key = new Integer(99).toString(); 1657 assertEquals(108, navigableMap_startExcluded_endExcluded 1658 .floorEntry(key).getValue()); 1659 assertEquals(109, navigableMap_startExcluded_endIncluded 1660 .floorEntry(key).getValue()); 1661 assertEquals(108, navigableMap_startIncluded_endExcluded 1662 .floorEntry(key).getValue()); 1663 assertEquals(109, navigableMap_startIncluded_endIncluded 1664 .floorEntry(key).getValue()); 1665 1666 key = new Integer(100).toString(); 1667 assertNull(navigableMap_startExcluded_endExcluded.floorEntry(key)); 1668 assertNull(navigableMap_startExcluded_endIncluded.floorEntry(key)); 1669 assertEquals(100, navigableMap_startIncluded_endExcluded 1670 .floorEntry(key).getValue()); 1671 assertEquals(100, navigableMap_startIncluded_endIncluded 1672 .floorEntry(key).getValue()); 1673 1674 for (int i = 101; i < 109; i++) { 1675 key = new Integer(i).toString(); 1676 assertEquals(i, navigableMap_startExcluded_endExcluded.floorEntry( 1677 key).getValue()); 1678 assertEquals(i, navigableMap_startExcluded_endIncluded.floorEntry( 1679 key).getValue()); 1680 assertEquals(i, navigableMap_startIncluded_endExcluded.floorEntry( 1681 key).getValue()); 1682 assertEquals(i, navigableMap_startIncluded_endIncluded.floorEntry( 1683 key).getValue()); 1684 1685 } 1686 1687 key = new Integer(109).toString(); 1688 assertEquals(108, navigableMap_startExcluded_endExcluded 1689 .floorEntry(key).getValue()); 1690 assertEquals(109, navigableMap_startExcluded_endIncluded 1691 .floorEntry(key).getValue()); 1692 assertEquals(108, navigableMap_startIncluded_endExcluded 1693 .floorEntry(key).getValue()); 1694 assertEquals(109, navigableMap_startIncluded_endIncluded 1695 .floorEntry(key).getValue()); 1696 1697 key = new Integer(110).toString(); 1698 assertEquals(108, navigableMap_startExcluded_endExcluded 1699 .floorEntry(key).getValue()); 1700 assertEquals(109, navigableMap_startExcluded_endIncluded 1701 .floorEntry(key).getValue()); 1702 assertEquals(108, navigableMap_startIncluded_endExcluded 1703 .floorEntry(key).getValue()); 1704 assertEquals(109, navigableMap_startIncluded_endIncluded 1705 .floorEntry(key).getValue()); 1706 } 1707 1708 public void test_AscendingSubMap_pollFirstEntry() { 1709 assertEquals(101, navigableMap_startExcluded_endExcluded 1710 .pollFirstEntry().getValue()); 1711 assertEquals(102, navigableMap_startExcluded_endIncluded 1712 .pollFirstEntry().getValue()); 1713 assertEquals(100, navigableMap_startIncluded_endExcluded 1714 .pollFirstEntry().getValue()); 1715 assertEquals(103, navigableMap_startIncluded_endIncluded 1716 .pollFirstEntry().getValue()); 1717 } 1718 1719 public void test_AscendingSubMap_pollLastEntry() { 1720 assertEquals(108, navigableMap_startExcluded_endExcluded 1721 .pollLastEntry().getValue()); 1722 assertEquals(109, navigableMap_startExcluded_endIncluded 1723 .pollLastEntry().getValue()); 1724 assertEquals(107, navigableMap_startIncluded_endExcluded 1725 .pollLastEntry().getValue()); 1726 assertEquals(106, navigableMap_startIncluded_endIncluded 1727 .pollLastEntry().getValue()); 1728 } 1729 1730 public void test_AscendingSubMap_entrySet() { 1731 assertEquals(8, navigableMap_startExcluded_endExcluded.entrySet() 1732 .size()); 1733 assertEquals(9, navigableMap_startExcluded_endIncluded.entrySet() 1734 .size()); 1735 assertEquals(9, navigableMap_startIncluded_endExcluded.entrySet() 1736 .size()); 1737 assertEquals(10, navigableMap_startIncluded_endIncluded.entrySet() 1738 .size()); 1739 } 1740 1741 public void test_AscendingSubMap_subMap() { 1742 Set entrySet; 1743 Entry startEntry, endEntry; 1744 int startIndex, endIndex; 1745 SortedMap subMap; 1746 Iterator subMapSetIterator; 1747 1748 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 1749 Iterator startIterator = entrySet.iterator(); 1750 while (startIterator.hasNext()) { 1751 startEntry = (Entry) startIterator.next(); 1752 startIndex = (Integer) startEntry.getValue(); 1753 Iterator endIterator = entrySet.iterator(); 1754 while (endIterator.hasNext()) { 1755 endEntry = (Entry) endIterator.next(); 1756 endIndex = (Integer) endEntry.getValue(); 1757 1758 if (startIndex > endIndex) { 1759 try { 1760 navigableMap_startExcluded_endExcluded.subMap( 1761 startEntry.getKey(), endEntry.getKey()); 1762 fail("should throw IllegalArgumentException"); 1763 } catch (IllegalArgumentException e) { 1764 // Expected 1765 } 1766 try { 1767 navigableMap_startExcluded_endExcluded.subMap( 1768 startEntry.getKey(), false, endEntry.getKey(), 1769 false); 1770 fail("should throw IllegalArgumentException"); 1771 } catch (IllegalArgumentException e) { 1772 // Expected 1773 } 1774 try { 1775 navigableMap_startExcluded_endExcluded.subMap( 1776 startEntry.getKey(), false, endEntry.getKey(), 1777 true); 1778 fail("should throw IllegalArgumentException"); 1779 } catch (IllegalArgumentException e) { 1780 // Expected 1781 } 1782 try { 1783 navigableMap_startExcluded_endExcluded.subMap( 1784 startEntry.getKey(), true, endEntry.getKey(), 1785 false); 1786 fail("should throw IllegalArgumentException"); 1787 } catch (IllegalArgumentException e) { 1788 // Expected 1789 } 1790 try { 1791 navigableMap_startExcluded_endExcluded.subMap( 1792 startEntry.getKey(), true, endEntry.getKey(), 1793 true); 1794 fail("should throw IllegalArgumentException"); 1795 } catch (IllegalArgumentException e) { 1796 // Expected 1797 } 1798 } else { 1799 subMap = navigableMap_startExcluded_endExcluded.subMap( 1800 startEntry.getKey(), endEntry.getKey()); 1801 subMapSetIterator = subMap.entrySet().iterator(); 1802 for (int index = startIndex; index < endIndex; index++) { 1803 assertEquals(index, ((Entry) subMapSetIterator.next()) 1804 .getValue()); 1805 } 1806 1807 subMap = navigableMap_startExcluded_endExcluded.subMap( 1808 startEntry.getKey(), false, endEntry.getKey(), 1809 false); 1810 subMapSetIterator = subMap.entrySet().iterator(); 1811 for (int index = startIndex + 1; index < endIndex; index++) { 1812 assertEquals(index, ((Entry) subMapSetIterator.next()) 1813 .getValue()); 1814 } 1815 1816 subMap = navigableMap_startExcluded_endExcluded 1817 .subMap(startEntry.getKey(), false, endEntry 1818 .getKey(), true); 1819 subMapSetIterator = subMap.entrySet().iterator(); 1820 for (int index = startIndex + 1; index < endIndex; index++) { 1821 assertEquals(index, ((Entry) subMapSetIterator.next()) 1822 .getValue()); 1823 } 1824 1825 subMap = navigableMap_startExcluded_endExcluded 1826 .subMap(startEntry.getKey(), true, endEntry 1827 .getKey(), false); 1828 subMapSetIterator = subMap.entrySet().iterator(); 1829 for (int index = startIndex; index < endIndex; index++) { 1830 assertEquals(index, ((Entry) subMapSetIterator.next()) 1831 .getValue()); 1832 } 1833 1834 subMap = navigableMap_startExcluded_endExcluded.subMap( 1835 startEntry.getKey(), true, endEntry.getKey(), true); 1836 subMapSetIterator = subMap.entrySet().iterator(); 1837 for (int index = startIndex; index <= endIndex; index++) { 1838 assertEquals(index, ((Entry) subMapSetIterator.next()) 1839 .getValue()); 1840 } 1841 } 1842 } 1843 } 1844 } 1845 1846 public void test_DescendingSubMap_ceilingEntry() { 1847 NavigableMap decendingMap = tm.descendingMap(); 1848 String key = new Integer(-1).toString(); 1849 assertNull(decendingMap.ceilingEntry(key)); 1850 for (int i = 0; i < objArray.length; i++) { 1851 key = objArray[i].toString(); 1852 assertEquals(objArray[i], decendingMap.ceilingEntry(key).getValue()); 1853 } 1854 key = new Integer(1000).toString(); 1855 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1856 key = new Integer(1001).toString(); 1857 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1858 1859 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 1860 key = new Integer(100).toString(); 1861 assertNull(decendingMap.ceilingEntry(key)); 1862 for (int i = 101; i < 109; i++) { 1863 key = new Integer(i).toString(); 1864 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1865 } 1866 key = new Integer(109).toString(); 1867 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1868 1869 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 1870 key = new Integer(100).toString(); 1871 assertNull(decendingMap.ceilingEntry(key)); 1872 for (int i = 101; i < 109; i++) { 1873 key = new Integer(i).toString(); 1874 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1875 } 1876 key = new Integer(109).toString(); 1877 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1878 1879 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 1880 key = new Integer(100).toString(); 1881 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1882 for (int i = 101; i < 109; i++) { 1883 key = new Integer(i).toString(); 1884 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1885 } 1886 key = new Integer(109).toString(); 1887 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1888 1889 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 1890 key = new Integer(100).toString(); 1891 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1892 for (int i = 101; i < 109; i++) { 1893 key = new Integer(i).toString(); 1894 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1895 } 1896 key = new Integer(109).toString(); 1897 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1898 1899 // With Comparator 1900 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 1901 .descendingMap(); 1902 key = new Integer(100).toString(); 1903 assertNull(decendingMap.ceilingEntry(key)); 1904 for (int i = 101; i < 109; i++) { 1905 key = new Integer(i).toString(); 1906 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1907 } 1908 key = new Integer(109).toString(); 1909 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1910 1911 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 1912 .descendingMap(); 1913 key = new Integer(100).toString(); 1914 assertNull(decendingMap.ceilingEntry(key)); 1915 for (int i = 101; i < 109; i++) { 1916 key = new Integer(i).toString(); 1917 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1918 } 1919 key = new Integer(109).toString(); 1920 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1921 1922 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 1923 .descendingMap(); 1924 key = new Integer(100).toString(); 1925 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1926 for (int i = 101; i < 109; i++) { 1927 key = new Integer(i).toString(); 1928 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1929 } 1930 key = new Integer(109).toString(); 1931 assertEquals(108, decendingMap.ceilingEntry(key).getValue()); 1932 1933 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 1934 .descendingMap(); 1935 key = new Integer(100).toString(); 1936 assertEquals(100, decendingMap.ceilingEntry(key).getValue()); 1937 for (int i = 101; i < 109; i++) { 1938 key = new Integer(i).toString(); 1939 assertEquals(i, decendingMap.ceilingEntry(key).getValue()); 1940 } 1941 key = new Integer(109).toString(); 1942 assertEquals(109, decendingMap.ceilingEntry(key).getValue()); 1943 } 1944 1945 public void test_DescendingSubMap_descendingMap() { 1946 NavigableMap decendingMap = tm.descendingMap(); 1947 NavigableMap decendingDecendingMap = decendingMap.descendingMap(); 1948 assertEquals(decendingMap, decendingDecendingMap); 1949 1950 NavigableMap decendingMapHeadMap = decendingMap.headMap( 1951 new Integer(990).toString(), false); 1952 NavigableMap decendingDecendingHeadMap = decendingMapHeadMap 1953 .descendingMap(); 1954 assertNotNull(decendingMapHeadMap); 1955 assertNotNull(decendingDecendingHeadMap); 1956 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 1957 1958 NavigableMap decendingMapTailMap = decendingMap.tailMap( 1959 new Integer(990).toString(), false); 1960 NavigableMap decendingDecendingTailMap = decendingMapTailMap 1961 .descendingMap(); 1962 assertNotNull(decendingMapTailMap); 1963 assertNotNull(decendingDecendingTailMap); 1964 // assertEquals(decendingMapTailMap,decendingDecendingTailMap); 1965 1966 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 1967 decendingDecendingMap = decendingMap.descendingMap(); 1968 assertEquals(decendingMap, decendingDecendingMap); 1969 1970 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 1971 false); 1972 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 1973 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 1974 1975 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 1976 false); 1977 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 1978 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 1979 1980 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 1981 decendingDecendingMap = decendingMap.descendingMap(); 1982 assertEquals(decendingMap, decendingDecendingMap); 1983 1984 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 1985 false); 1986 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 1987 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 1988 1989 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 1990 false); 1991 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 1992 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 1993 1994 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 1995 decendingDecendingMap = decendingMap.descendingMap(); 1996 assertEquals(decendingMap, decendingDecendingMap); 1997 1998 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 1999 false); 2000 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 2001 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 2002 2003 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 2004 false); 2005 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 2006 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 2007 2008 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2009 decendingDecendingMap = decendingMap.descendingMap(); 2010 assertEquals(decendingMap, decendingDecendingMap); 2011 2012 decendingMapHeadMap = decendingMap.headMap(new Integer(104).toString(), 2013 false); 2014 decendingDecendingHeadMap = decendingMapHeadMap.descendingMap(); 2015 assertEquals(decendingMapHeadMap, decendingDecendingHeadMap); 2016 2017 decendingMapTailMap = decendingMap.tailMap(new Integer(104).toString(), 2018 false); 2019 decendingDecendingTailMap = decendingMapTailMap.descendingMap(); 2020 assertEquals(decendingMapTailMap, decendingDecendingTailMap); 2021 } 2022 2023 public void test_DescendingSubMap_firstEntry() { 2024 NavigableMap decendingMap = tm.descendingMap(); 2025 assertEquals(999, decendingMap.firstEntry().getValue()); 2026 2027 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2028 assertEquals(108, decendingMap.firstEntry().getValue()); 2029 2030 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2031 assertEquals(109, decendingMap.firstEntry().getValue()); 2032 2033 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2034 assertEquals(108, decendingMap.firstEntry().getValue()); 2035 2036 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2037 assertEquals(109, decendingMap.firstEntry().getValue()); 2038 } 2039 2040 public void test_DescendingSubMap_floorEntry() { 2041 NavigableMap decendingMap = tm.descendingMap(); 2042 String key = new Integer(-1).toString(); 2043 assertEquals(0, decendingMap.floorEntry(key).getValue()); 2044 for (int i = 0; i < objArray.length; i++) { 2045 key = objArray[i].toString(); 2046 assertEquals(objArray[i], decendingMap.floorEntry(key).getValue()); 2047 } 2048 key = new Integer(1000).toString(); 2049 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2050 key = new Integer(1001).toString(); 2051 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2052 2053 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2054 key = new Integer(100).toString(); 2055 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2056 for (int i = 101; i < 109; i++) { 2057 key = new Integer(i).toString(); 2058 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2059 } 2060 key = new Integer(109).toString(); 2061 assertNull(decendingMap.floorEntry(key)); 2062 2063 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2064 key = new Integer(100).toString(); 2065 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2066 for (int i = 101; i < 109; i++) { 2067 key = new Integer(i).toString(); 2068 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2069 } 2070 key = new Integer(109).toString(); 2071 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2072 2073 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2074 key = new Integer(100).toString(); 2075 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2076 for (int i = 101; i < 109; i++) { 2077 key = new Integer(i).toString(); 2078 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2079 } 2080 key = new Integer(109).toString(); 2081 assertNull(decendingMap.floorEntry(key)); 2082 2083 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2084 key = new Integer(100).toString(); 2085 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2086 for (int i = 101; i < 109; i++) { 2087 key = new Integer(i).toString(); 2088 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2089 } 2090 key = new Integer(109).toString(); 2091 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2092 2093 // With Comparator 2094 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 2095 .descendingMap(); 2096 key = new Integer(100).toString(); 2097 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2098 for (int i = 101; i < 109; i++) { 2099 key = new Integer(i).toString(); 2100 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2101 } 2102 key = new Integer(109).toString(); 2103 assertNull(decendingMap.floorEntry(key)); 2104 2105 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 2106 .descendingMap(); 2107 key = new Integer(100).toString(); 2108 assertEquals(101, decendingMap.floorEntry(key).getValue()); 2109 for (int i = 101; i < 109; i++) { 2110 key = new Integer(i).toString(); 2111 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2112 } 2113 key = new Integer(109).toString(); 2114 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2115 2116 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 2117 .descendingMap(); 2118 key = new Integer(100).toString(); 2119 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2120 for (int i = 101; i < 109; i++) { 2121 key = new Integer(i).toString(); 2122 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2123 } 2124 key = new Integer(109).toString(); 2125 assertNull(decendingMap.floorEntry(key)); 2126 2127 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 2128 .descendingMap(); 2129 key = new Integer(100).toString(); 2130 assertEquals(100, decendingMap.floorEntry(key).getValue()); 2131 for (int i = 101; i < 109; i++) { 2132 key = new Integer(i).toString(); 2133 assertEquals(i, decendingMap.floorEntry(key).getValue()); 2134 } 2135 key = new Integer(109).toString(); 2136 assertEquals(109, decendingMap.floorEntry(key).getValue()); 2137 } 2138 2139 public void test_DescendingSubMap_lastEntry() { 2140 NavigableMap decendingMap = tm.descendingMap(); 2141 assertEquals(0, decendingMap.lastEntry().getValue()); 2142 2143 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2144 assertEquals(101, decendingMap.lastEntry().getValue()); 2145 2146 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2147 assertEquals(101, decendingMap.lastEntry().getValue()); 2148 2149 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2150 assertEquals(100, decendingMap.lastEntry().getValue()); 2151 2152 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2153 assertEquals(100, decendingMap.lastEntry().getValue()); 2154 } 2155 2156 public void test_DescendingSubMap_higherEntry() { 2157 NavigableMap decendingMap; 2158 NavigableMap decendingTailMap; 2159 Integer value; 2160 Entry entry; 2161 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2162 value = new Integer(101); 2163 assertNull(decendingMap.higherEntry(value.toString())); 2164 2165 for (int i = 108; i > 101; i--) { 2166 value = new Integer(i); 2167 entry = decendingMap.higherEntry(value.toString()); 2168 assertEquals(value - 1, entry.getValue()); 2169 } 2170 2171 value = new Integer(109); 2172 entry = decendingMap.higherEntry(value.toString()); 2173 assertEquals(108, entry.getValue()); 2174 2175 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2176 false); 2177 value = new Integer(109); 2178 entry = decendingTailMap.higherEntry(value.toString()); 2179 assertEquals(103, entry.getValue()); 2180 2181 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2182 value = new Integer(100); 2183 assertNull(decendingMap.higherEntry(value.toString())); 2184 2185 for (int i = 108; i > 100; i--) { 2186 value = new Integer(i); 2187 entry = decendingMap.higherEntry(value.toString()); 2188 assertEquals(value - 1, entry.getValue()); 2189 } 2190 2191 value = new Integer(109); 2192 entry = decendingMap.higherEntry(value.toString()); 2193 assertEquals(108, entry.getValue()); 2194 2195 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2196 false); 2197 value = new Integer(109); 2198 entry = decendingTailMap.higherEntry(value.toString()); 2199 assertEquals(103, entry.getValue()); 2200 2201 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2202 value = new Integer(101); 2203 assertNull(decendingMap.higherEntry(value.toString())); 2204 2205 for (int i = 109; i > 101; i--) { 2206 value = new Integer(i); 2207 entry = decendingMap.higherEntry(value.toString()); 2208 assertEquals(value - 1, entry.getValue()); 2209 } 2210 2211 value = new Integer(2); 2212 entry = decendingMap.higherEntry(value.toString()); 2213 assertEquals(109, entry.getValue()); 2214 2215 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2216 false); 2217 value = new Integer(109); 2218 entry = decendingTailMap.higherEntry(value.toString()); 2219 assertEquals(103, entry.getValue()); 2220 2221 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2222 value = new Integer(100); 2223 assertNull(decendingMap.higherEntry(value.toString())); 2224 2225 for (int i = 109; i > 100; i--) { 2226 value = new Integer(i); 2227 entry = decendingMap.higherEntry(value.toString()); 2228 assertEquals(value - 1, entry.getValue()); 2229 } 2230 2231 value = new Integer(2); 2232 entry = decendingMap.higherEntry(value.toString()); 2233 assertEquals(109, entry.getValue()); 2234 2235 decendingTailMap = decendingMap.tailMap(new Integer(104).toString(), 2236 false); 2237 value = new Integer(109); 2238 entry = decendingTailMap.higherEntry(value.toString()); 2239 assertEquals(103, entry.getValue()); 2240 } 2241 2242 public void test_DescendingSubMap_lowerEntry() { 2243 NavigableMap decendingMap; 2244 NavigableMap decendingHeadMap; 2245 Integer value; 2246 Entry entry; 2247 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2248 value = new Integer(99); 2249 assertNull(decendingMap.lowerEntry(value.toString())); 2250 for (int i = 100; i < 108; i++) { 2251 value = new Integer(i); 2252 entry = decendingMap.lowerEntry(value.toString()); 2253 assertEquals(value + 1, entry.getValue()); 2254 } 2255 value = new Integer(109); 2256 assertNull(decendingMap.lowerEntry(value.toString())); 2257 2258 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2259 false); 2260 for (int i = 104; i < 106; i++) { 2261 value = new Integer(i); 2262 entry = decendingHeadMap.lowerEntry(value.toString()); 2263 assertEquals(value + 1, entry.getValue()); 2264 } 2265 value = new Integer(102); 2266 entry = decendingHeadMap.lowerEntry(value.toString()); 2267 assertEquals(104, entry.getValue()); 2268 2269 value = new Integer(109); 2270 entry = decendingHeadMap.lowerEntry(value.toString()); 2271 assertNull(entry); 2272 2273 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2274 value = new Integer(99); 2275 assertNull(decendingMap.lowerEntry(value.toString())); 2276 for (int i = 100; i < 109; i++) { 2277 value = new Integer(i); 2278 entry = decendingMap.lowerEntry(value.toString()); 2279 assertEquals(value + 1, entry.getValue()); 2280 } 2281 value = new Integer(110); 2282 assertNull(decendingMap.lowerEntry(value.toString())); 2283 2284 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2285 false); 2286 for (int i = 104; i < 109; i++) { 2287 value = new Integer(i); 2288 entry = decendingHeadMap.lowerEntry(value.toString()); 2289 assertEquals(value + 1, entry.getValue()); 2290 } 2291 value = new Integer(102); 2292 entry = decendingHeadMap.lowerEntry(value.toString()); 2293 assertEquals(104, entry.getValue()); 2294 2295 value = new Integer(2); 2296 entry = decendingHeadMap.lowerEntry(value.toString()); 2297 assertNull(entry); 2298 2299 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2300 value = new Integer(99); 2301 assertNull(decendingMap.lowerEntry(value.toString())); 2302 for (int i = 100; i < 108; i++) { 2303 value = new Integer(i); 2304 entry = decendingMap.lowerEntry(value.toString()); 2305 assertEquals(value + 1, entry.getValue()); 2306 } 2307 value = new Integer(109); 2308 assertNull(decendingMap.lowerEntry(value.toString())); 2309 2310 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2311 false); 2312 for (int i = 104; i < 107; i++) { 2313 value = new Integer(i); 2314 entry = decendingHeadMap.lowerEntry(value.toString()); 2315 assertEquals(value + 1, entry.getValue()); 2316 } 2317 value = new Integer(102); 2318 entry = decendingHeadMap.lowerEntry(value.toString()); 2319 assertEquals(104, entry.getValue()); 2320 2321 value = new Integer(2); 2322 entry = decendingHeadMap.lowerEntry(value.toString()); 2323 assertNull(entry); 2324 2325 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2326 value = new Integer(99); 2327 assertNull(decendingMap.lowerEntry(value.toString())); 2328 for (int i = 100; i < 109; i++) { 2329 value = new Integer(i); 2330 entry = decendingMap.lowerEntry(value.toString()); 2331 assertEquals(value + 1, entry.getValue()); 2332 } 2333 value = new Integer(110); 2334 assertNull(decendingMap.lowerEntry(value.toString())); 2335 2336 decendingHeadMap = decendingMap.headMap(new Integer(103).toString(), 2337 false); 2338 for (int i = 104; i < 109; i++) { 2339 value = new Integer(i); 2340 entry = decendingHeadMap.lowerEntry(value.toString()); 2341 assertEquals(value + 1, entry.getValue()); 2342 } 2343 value = new Integer(102); 2344 entry = decendingHeadMap.lowerEntry(value.toString()); 2345 assertEquals(104, entry.getValue()); 2346 2347 value = new Integer(2); 2348 entry = decendingHeadMap.lowerEntry(value.toString()); 2349 assertNull(entry); 2350 } 2351 2352 public void test_DescendingSubMap_pollFirstEntry() { 2353 NavigableMap decendingMap = tm.descendingMap(); 2354 assertEquals(999, decendingMap.pollFirstEntry().getValue()); 2355 2356 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2357 assertEquals(108, decendingMap.pollFirstEntry().getValue()); 2358 2359 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2360 assertEquals(109, decendingMap.pollFirstEntry().getValue()); 2361 2362 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2363 assertEquals(107, decendingMap.pollFirstEntry().getValue()); 2364 2365 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2366 assertEquals(106, decendingMap.pollFirstEntry().getValue()); 2367 } 2368 2369 public void test_DescendingSubMap_pollLastEntry() { 2370 NavigableMap decendingMap = tm.descendingMap(); 2371 assertEquals(0, decendingMap.pollLastEntry().getValue()); 2372 2373 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2374 assertEquals(101, decendingMap.pollLastEntry().getValue()); 2375 2376 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2377 assertEquals(102, decendingMap.pollLastEntry().getValue()); 2378 2379 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2380 assertEquals(100, decendingMap.pollLastEntry().getValue()); 2381 2382 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2383 assertEquals(103, decendingMap.pollLastEntry().getValue()); 2384 } 2385 2386 public void test_DescendingSubMap_values() { 2387 NavigableMap decendingMap = tm.descendingMap(); 2388 Collection values = decendingMap.values(); 2389 assertFalse(values.isEmpty()); 2390 assertFalse(values.contains(1000)); 2391 for (int i = 999; i > 0; i--) { 2392 assertTrue(values.contains(i)); 2393 } 2394 assertTrue(values.contains(0)); 2395 2396 String endKey = new Integer(99).toString(); 2397 NavigableMap headMap = decendingMap.headMap(endKey, false); 2398 values = headMap.values(); 2399 Iterator it = values.iterator(); 2400 for (int i = 999; i > 990; i--) { 2401 assertTrue(values.contains(i)); 2402 assertEquals(i, it.next()); 2403 } 2404 2405 String startKey = new Integer(11).toString(); 2406 NavigableMap tailMap = decendingMap.tailMap(startKey, false); 2407 values = tailMap.values(); 2408 it = values.iterator(); 2409 for (int i = 109; i > 100; i--) { 2410 assertTrue(values.contains(i)); 2411 assertEquals(i, it.next()); 2412 } 2413 2414 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2415 values = decendingMap.values(); 2416 assertFalse(values.isEmpty()); 2417 assertFalse(values.contains(109)); 2418 for (int i = 108; i > 100; i--) { 2419 assertTrue(values.contains(i)); 2420 } 2421 assertFalse(values.contains(100)); 2422 2423 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2424 values = decendingMap.values(); 2425 assertFalse(values.isEmpty()); 2426 assertFalse(values.contains(100)); 2427 for (int i = 108; i > 100; i--) { 2428 assertTrue(values.contains(i)); 2429 } 2430 assertTrue(values.contains(109)); 2431 2432 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2433 values = decendingMap.values(); 2434 assertFalse(values.isEmpty()); 2435 assertTrue(values.contains(100)); 2436 for (int i = 108; i > 100; i--) { 2437 assertTrue(values.contains(i)); 2438 } 2439 assertFalse(values.contains(109)); 2440 2441 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2442 values = decendingMap.values(); 2443 assertFalse(values.isEmpty()); 2444 assertTrue(values.contains(100)); 2445 for (int i = 108; i > 100; i--) { 2446 assertTrue(values.contains(i)); 2447 } 2448 assertTrue(values.contains(109)); 2449 } 2450 2451 public void test_DescendingSubMap_headMap() { 2452 NavigableMap decendingMap = tm.descendingMap(); 2453 String endKey = new Integer(0).toString(), key; 2454 SortedMap subDecendingMap_Included = decendingMap.headMap(endKey, true); 2455 SortedMap subDecendingMap_Excluded = decendingMap 2456 .headMap(endKey, false); 2457 key = endKey; 2458 assertTrue(subDecendingMap_Included.containsKey(key)); 2459 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2460 for (int i = 1; i < 1000; i++) { 2461 key = new Integer(i).toString(); 2462 assertTrue(subDecendingMap_Included.containsKey(key)); 2463 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2464 } 2465 key = new Integer(1000).toString(); 2466 assertFalse(subDecendingMap_Included.containsKey(key)); 2467 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2468 2469 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2470 endKey = new Integer(100).toString(); 2471 try { 2472 decendingMap.headMap(endKey, true); 2473 fail("should throw IllegalArgumentException"); 2474 } catch (IllegalArgumentException e) { 2475 // Expected 2476 } 2477 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2478 key = endKey; 2479 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2480 2481 endKey = new Integer(101).toString(); 2482 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2483 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2484 2485 key = endKey; 2486 assertTrue(subDecendingMap_Included.containsKey(key)); 2487 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2488 2489 for (int i = 102; i < 109; i++) { 2490 key = new Integer(i).toString(); 2491 assertTrue(subDecendingMap_Included.containsKey(key)); 2492 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2493 } 2494 key = new Integer(109).toString(); 2495 assertFalse(subDecendingMap_Included.containsKey(key)); 2496 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2497 2498 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2499 endKey = new Integer(100).toString(); 2500 try { 2501 decendingMap.headMap(endKey, true); 2502 fail("should throw IllegalArgumentException"); 2503 } catch (IllegalArgumentException e) { 2504 // Expected 2505 } 2506 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2507 key = endKey; 2508 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2509 2510 endKey = new Integer(101).toString(); 2511 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2512 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2513 2514 key = endKey; 2515 assertTrue(subDecendingMap_Included.containsKey(key)); 2516 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2517 2518 for (int i = 102; i < 109; i++) { 2519 key = new Integer(i).toString(); 2520 assertTrue(subDecendingMap_Included.containsKey(key)); 2521 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2522 } 2523 key = new Integer(109).toString(); 2524 assertTrue(subDecendingMap_Included.containsKey(key)); 2525 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2526 2527 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2528 endKey = new Integer(100).toString(); 2529 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2530 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2531 key = endKey; 2532 assertTrue(subDecendingMap_Included.containsKey(key)); 2533 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2534 2535 endKey = new Integer(101).toString(); 2536 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2537 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2538 2539 key = endKey; 2540 assertTrue(subDecendingMap_Included.containsKey(key)); 2541 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2542 2543 for (int i = 102; i < 109; i++) { 2544 key = new Integer(i).toString(); 2545 assertTrue(subDecendingMap_Included.containsKey(key)); 2546 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2547 } 2548 key = new Integer(109).toString(); 2549 assertFalse(subDecendingMap_Included.containsKey(key)); 2550 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2551 2552 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 2553 endKey = new Integer(100).toString(); 2554 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2555 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2556 key = endKey; 2557 assertTrue(subDecendingMap_Included.containsKey(key)); 2558 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2559 2560 endKey = new Integer(101).toString(); 2561 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2562 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2563 2564 key = endKey; 2565 assertTrue(subDecendingMap_Included.containsKey(key)); 2566 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2567 2568 for (int i = 102; i < 109; i++) { 2569 key = new Integer(i).toString(); 2570 assertTrue(subDecendingMap_Included.containsKey(key)); 2571 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2572 } 2573 key = new Integer(109).toString(); 2574 assertTrue(subDecendingMap_Included.containsKey(key)); 2575 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2576 2577 // With Comparator 2578 2579 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 2580 .descendingMap(); 2581 endKey = new Integer(100).toString(); 2582 try { 2583 decendingMap.headMap(endKey, true); 2584 fail("should throw IllegalArgumentException"); 2585 } catch (IllegalArgumentException e) { 2586 // Expected 2587 } 2588 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2589 key = endKey; 2590 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2591 2592 endKey = new Integer(101).toString(); 2593 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2594 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2595 2596 key = endKey; 2597 assertTrue(subDecendingMap_Included.containsKey(key)); 2598 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2599 2600 for (int i = 102; i < 109; i++) { 2601 key = new Integer(i).toString(); 2602 assertTrue(subDecendingMap_Included.containsKey(key)); 2603 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2604 } 2605 key = new Integer(109).toString(); 2606 assertFalse(subDecendingMap_Included.containsKey(key)); 2607 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2608 2609 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 2610 .descendingMap(); 2611 endKey = new Integer(100).toString(); 2612 try { 2613 decendingMap.headMap(endKey, true); 2614 fail("should throw IllegalArgumentException"); 2615 } catch (IllegalArgumentException e) { 2616 // Expected 2617 } 2618 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2619 key = endKey; 2620 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2621 2622 endKey = new Integer(101).toString(); 2623 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2624 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2625 2626 key = endKey; 2627 assertTrue(subDecendingMap_Included.containsKey(key)); 2628 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2629 2630 for (int i = 102; i < 109; i++) { 2631 key = new Integer(i).toString(); 2632 assertTrue(subDecendingMap_Included.containsKey(key)); 2633 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2634 } 2635 key = new Integer(109).toString(); 2636 assertTrue(subDecendingMap_Included.containsKey(key)); 2637 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2638 2639 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 2640 .descendingMap(); 2641 endKey = new Integer(100).toString(); 2642 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2643 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2644 key = endKey; 2645 assertTrue(subDecendingMap_Included.containsKey(key)); 2646 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2647 2648 endKey = new Integer(101).toString(); 2649 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2650 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2651 2652 key = endKey; 2653 assertTrue(subDecendingMap_Included.containsKey(key)); 2654 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2655 2656 for (int i = 102; i < 109; i++) { 2657 key = new Integer(i).toString(); 2658 assertTrue(subDecendingMap_Included.containsKey(key)); 2659 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2660 } 2661 key = new Integer(109).toString(); 2662 assertFalse(subDecendingMap_Included.containsKey(key)); 2663 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2664 2665 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 2666 .descendingMap(); 2667 endKey = new Integer(100).toString(); 2668 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2669 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2670 key = endKey; 2671 assertTrue(subDecendingMap_Included.containsKey(key)); 2672 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2673 2674 endKey = new Integer(101).toString(); 2675 subDecendingMap_Included = decendingMap.headMap(endKey, true); 2676 subDecendingMap_Excluded = decendingMap.headMap(endKey, false); 2677 2678 key = endKey; 2679 assertTrue(subDecendingMap_Included.containsKey(key)); 2680 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2681 2682 for (int i = 102; i < 109; i++) { 2683 key = new Integer(i).toString(); 2684 assertTrue(subDecendingMap_Included.containsKey(key)); 2685 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2686 } 2687 key = new Integer(109).toString(); 2688 assertTrue(subDecendingMap_Included.containsKey(key)); 2689 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2690 } 2691 2692 public void test_DescendingSubMap_subMap() { 2693 NavigableMap descendingMap = tm.descendingMap(); 2694 String startKey = new Integer(109).toString(); 2695 String endKey = new Integer(100).toString(); 2696 try { 2697 descendingMap.subMap(endKey, false, startKey, false); 2698 } catch (IllegalArgumentException e) { 2699 // Expected 2700 } 2701 2702 SortedMap subDescendingMap = descendingMap.subMap(startKey, false, 2703 endKey, false); 2704 String key = new Integer(100).toString(); 2705 assertFalse(subDescendingMap.containsKey(key)); 2706 for (int i = 101; i < 109; i++) { 2707 key = new Integer(i).toString(); 2708 assertTrue(subDescendingMap.containsKey(key)); 2709 } 2710 key = new Integer(109).toString(); 2711 assertFalse(subDescendingMap.containsKey(key)); 2712 2713 subDescendingMap = descendingMap.subMap(startKey, false, endKey, true); 2714 key = new Integer(100).toString(); 2715 assertTrue(subDescendingMap.containsKey(key)); 2716 for (int i = 101; i < 109; i++) { 2717 key = new Integer(i).toString(); 2718 assertTrue(subDescendingMap.containsKey(key)); 2719 } 2720 key = new Integer(109).toString(); 2721 assertFalse(subDescendingMap.containsKey(key)); 2722 2723 subDescendingMap = descendingMap.subMap(startKey, true, endKey, false); 2724 key = new Integer(100).toString(); 2725 assertFalse(subDescendingMap.containsKey(key)); 2726 for (int i = 101; i < 109; i++) { 2727 key = new Integer(i).toString(); 2728 assertTrue(subDescendingMap.containsKey(key)); 2729 } 2730 key = new Integer(109).toString(); 2731 assertTrue(subDescendingMap.containsKey(key)); 2732 2733 subDescendingMap = descendingMap.subMap(startKey, true, endKey, true); 2734 key = new Integer(100).toString(); 2735 assertTrue(subDescendingMap.containsKey(key)); 2736 for (int i = 101; i < 109; i++) { 2737 key = new Integer(i).toString(); 2738 assertTrue(subDescendingMap.containsKey(key)); 2739 } 2740 key = new Integer(109).toString(); 2741 assertTrue(subDescendingMap.containsKey(key)); 2742 2743 TreeMap<Integer, String> treeMap = new TreeMap<Integer, String>(); 2744 for (int i = -10; i < 10; i++) { 2745 treeMap.put(i, String.valueOf(i)); 2746 } 2747 descendingMap = treeMap.descendingMap(); 2748 subDescendingMap = descendingMap.subMap(5, 0); 2749 assertEquals(5, subDescendingMap.size()); 2750 } 2751 2752 public void test_DescendingSubMap_tailMap() { 2753 // tm 2754 NavigableMap decendingMap = tm.descendingMap(); 2755 String endKey = new Integer(1000).toString(), key; 2756 SortedMap subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2757 SortedMap subDecendingMap_Excluded = decendingMap 2758 .tailMap(endKey, false); 2759 2760 key = endKey; 2761 assertFalse(subDecendingMap_Included.containsKey(key)); 2762 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2763 key = new Integer(100).toString(); 2764 assertTrue(subDecendingMap_Included.containsKey(key)); 2765 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2766 2767 key = new Integer(10).toString(); 2768 assertTrue(subDecendingMap_Included.containsKey(key)); 2769 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2770 2771 key = new Integer(1).toString(); 2772 assertTrue(subDecendingMap_Included.containsKey(key)); 2773 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2774 2775 key = new Integer(0).toString(); 2776 assertTrue(subDecendingMap_Included.containsKey(key)); 2777 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2778 2779 endKey = new Integer(999).toString(); 2780 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2781 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2782 key = endKey; 2783 assertTrue(subDecendingMap_Included.containsKey(key)); 2784 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2785 for (int i = 998; i > 0; i--) { 2786 key = new Integer(i).toString(); 2787 assertTrue(subDecendingMap_Included.containsKey(key)); 2788 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2789 } 2790 key = new Integer(0).toString(); 2791 assertTrue(subDecendingMap_Included.containsKey(key)); 2792 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2793 2794 endKey = new Integer(0).toString(); 2795 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2796 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2797 assertEquals(1, subDecendingMap_Included.size()); 2798 key = endKey; 2799 assertTrue(subDecendingMap_Included.containsKey(key)); 2800 assertTrue(subDecendingMap_Excluded.isEmpty()); 2801 2802 // navigableMap_startExcluded_endExcluded 2803 decendingMap = navigableMap_startExcluded_endExcluded.descendingMap(); 2804 endKey = new Integer(110).toString(); 2805 try { 2806 decendingMap.tailMap(endKey, true); 2807 fail("should throw IllegalArgumentException"); 2808 } catch (IllegalArgumentException e) { 2809 // Expected 2810 } 2811 2812 try { 2813 decendingMap.tailMap(endKey, false); 2814 fail("should throw IllegalArgumentException"); 2815 } catch (IllegalArgumentException e) { 2816 // Expected 2817 } 2818 2819 endKey = new Integer(109).toString(); 2820 try { 2821 decendingMap.tailMap(endKey, true); 2822 fail("should throw IllegalArgumentException"); 2823 } catch (IllegalArgumentException e) { 2824 // Expected 2825 } 2826 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2827 key = endKey; 2828 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2829 2830 endKey = new Integer(108).toString(); 2831 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2832 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2833 key = endKey; 2834 assertTrue(subDecendingMap_Included.containsKey(key)); 2835 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2836 for (int i = 107; i > 100; i--) { 2837 key = new Integer(i).toString(); 2838 assertTrue(subDecendingMap_Included.containsKey(key)); 2839 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2840 } 2841 key = new Integer(100).toString(); 2842 assertFalse(subDecendingMap_Included.containsKey(key)); 2843 assertFalse(subDecendingMap_Included.containsKey(key)); 2844 2845 endKey = new Integer(101).toString(); 2846 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2847 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2848 key = endKey; 2849 assertEquals(1, subDecendingMap_Included.size()); 2850 assertTrue(subDecendingMap_Included.containsKey(key)); 2851 assertTrue(subDecendingMap_Excluded.isEmpty()); 2852 2853 endKey = new Integer(100).toString(); 2854 try { 2855 decendingMap.tailMap(endKey, true); 2856 fail("should throw IllegalArgumentException"); 2857 } catch (IllegalArgumentException e) { 2858 // Expected 2859 } 2860 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2861 assertTrue(subDecendingMap_Excluded.isEmpty()); 2862 2863 endKey = new Integer(99).toString(); 2864 try { 2865 decendingMap.tailMap(endKey, true); 2866 fail("should throw IllegalArgumentException"); 2867 } catch (IllegalArgumentException e) { 2868 // Expected 2869 } 2870 2871 try { 2872 decendingMap.tailMap(endKey, false); 2873 fail("should throw IllegalArgumentException"); 2874 } catch (IllegalArgumentException e) { 2875 // Expected 2876 } 2877 2878 // navigableMap_startExcluded_endIncluded 2879 decendingMap = navigableMap_startExcluded_endIncluded.descendingMap(); 2880 endKey = new Integer(110).toString(); 2881 try { 2882 decendingMap.tailMap(endKey, true); 2883 fail("should throw IllegalArgumentException"); 2884 } catch (IllegalArgumentException e) { 2885 // Expected 2886 } 2887 2888 try { 2889 decendingMap.tailMap(endKey, false); 2890 fail("should throw IllegalArgumentException"); 2891 } catch (IllegalArgumentException e) { 2892 // Expected 2893 } 2894 2895 endKey = new Integer(109).toString(); 2896 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2897 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2898 key = endKey; 2899 assertTrue(subDecendingMap_Included.containsKey(key)); 2900 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2901 2902 endKey = new Integer(108).toString(); 2903 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2904 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2905 key = endKey; 2906 assertTrue(subDecendingMap_Included.containsKey(key)); 2907 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2908 for (int i = 107; i > 100; i--) { 2909 key = new Integer(i).toString(); 2910 assertTrue(subDecendingMap_Included.containsKey(key)); 2911 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2912 } 2913 key = new Integer(100).toString(); 2914 assertFalse(subDecendingMap_Included.containsKey(key)); 2915 assertFalse(subDecendingMap_Included.containsKey(key)); 2916 2917 endKey = new Integer(101).toString(); 2918 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2919 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2920 key = endKey; 2921 assertEquals(1, subDecendingMap_Included.size()); 2922 assertTrue(subDecendingMap_Included.containsKey(key)); 2923 assertTrue(subDecendingMap_Excluded.isEmpty()); 2924 2925 endKey = new Integer(100).toString(); 2926 try { 2927 decendingMap.tailMap(endKey, true); 2928 fail("should throw IllegalArgumentException"); 2929 } catch (IllegalArgumentException e) { 2930 // Expected 2931 } 2932 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2933 assertTrue(subDecendingMap_Excluded.isEmpty()); 2934 2935 endKey = new Integer(99).toString(); 2936 try { 2937 decendingMap.tailMap(endKey, true); 2938 fail("should throw IllegalArgumentException"); 2939 } catch (IllegalArgumentException e) { 2940 // Expected 2941 } 2942 try { 2943 decendingMap.tailMap(endKey, false); 2944 fail("should throw IllegalArgumentException"); 2945 } catch (IllegalArgumentException e) { 2946 // Expected 2947 } 2948 2949 // navigableMap_startIncluded_endExcluded 2950 decendingMap = navigableMap_startIncluded_endExcluded.descendingMap(); 2951 endKey = new Integer(110).toString(); 2952 try { 2953 decendingMap.tailMap(endKey, true); 2954 fail("should throw IllegalArgumentException"); 2955 } catch (IllegalArgumentException e) { 2956 // Expected 2957 } 2958 2959 try { 2960 decendingMap.tailMap(endKey, false); 2961 fail("should throw IllegalArgumentException"); 2962 } catch (IllegalArgumentException e) { 2963 // Expected 2964 } 2965 2966 endKey = new Integer(109).toString(); 2967 try { 2968 decendingMap.tailMap(endKey, true); 2969 2970 } catch (IllegalArgumentException e) { 2971 // Expected 2972 } 2973 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2974 key = endKey; 2975 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2976 2977 endKey = new Integer(108).toString(); 2978 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2979 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2980 key = endKey; 2981 assertTrue(subDecendingMap_Included.containsKey(key)); 2982 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2983 for (int i = 107; i > 100; i--) { 2984 key = new Integer(i).toString(); 2985 assertTrue(subDecendingMap_Included.containsKey(key)); 2986 assertTrue(subDecendingMap_Excluded.containsKey(key)); 2987 } 2988 key = new Integer(100).toString(); 2989 assertTrue(subDecendingMap_Included.containsKey(key)); 2990 assertTrue(subDecendingMap_Included.containsKey(key)); 2991 2992 endKey = new Integer(101).toString(); 2993 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 2994 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 2995 key = endKey; 2996 assertEquals(2, subDecendingMap_Included.size()); 2997 assertTrue(subDecendingMap_Included.containsKey(key)); 2998 assertFalse(subDecendingMap_Excluded.containsKey(key)); 2999 3000 endKey = new Integer(100).toString(); 3001 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3002 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3003 key = endKey; 3004 assertTrue(subDecendingMap_Included.containsKey(key)); 3005 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3006 3007 endKey = new Integer(99).toString(); 3008 try { 3009 decendingMap.tailMap(endKey, true); 3010 fail("should throw IllegalArgumentException"); 3011 } catch (IllegalArgumentException e) { 3012 // Expected 3013 } 3014 try { 3015 decendingMap.tailMap(endKey, false); 3016 fail("should throw IllegalArgumentException"); 3017 } catch (IllegalArgumentException e) { 3018 // Expected 3019 } 3020 3021 // navigableMap_startIncluded_endIncluded 3022 decendingMap = navigableMap_startIncluded_endIncluded.descendingMap(); 3023 endKey = new Integer(110).toString(); 3024 try { 3025 decendingMap.tailMap(endKey, true); 3026 fail("should throw IllegalArgumentException"); 3027 } catch (IllegalArgumentException e) { 3028 // Expected 3029 } 3030 try { 3031 decendingMap.tailMap(endKey, false); 3032 fail("should throw IllegalArgumentException"); 3033 } catch (IllegalArgumentException e) { 3034 // Expected 3035 } 3036 3037 endKey = new Integer(109).toString(); 3038 try { 3039 decendingMap.tailMap(endKey, true); 3040 3041 } catch (IllegalArgumentException e) { 3042 // Expected 3043 } 3044 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3045 key = endKey; 3046 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3047 3048 endKey = new Integer(108).toString(); 3049 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3050 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3051 key = endKey; 3052 assertTrue(subDecendingMap_Included.containsKey(key)); 3053 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3054 for (int i = 107; i > 100; i--) { 3055 key = new Integer(i).toString(); 3056 assertTrue(subDecendingMap_Included.containsKey(key)); 3057 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3058 } 3059 key = new Integer(100).toString(); 3060 assertTrue(subDecendingMap_Included.containsKey(key)); 3061 assertTrue(subDecendingMap_Included.containsKey(key)); 3062 3063 endKey = new Integer(101).toString(); 3064 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3065 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3066 key = endKey; 3067 assertEquals(2, subDecendingMap_Included.size()); 3068 assertTrue(subDecendingMap_Included.containsKey(key)); 3069 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3070 3071 endKey = new Integer(100).toString(); 3072 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3073 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3074 key = endKey; 3075 assertTrue(subDecendingMap_Included.containsKey(key)); 3076 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3077 3078 endKey = new Integer(99).toString(); 3079 try { 3080 decendingMap.tailMap(endKey, true); 3081 fail("should throw IllegalArgumentException"); 3082 } catch (IllegalArgumentException e) { 3083 // Expected 3084 } 3085 try { 3086 decendingMap.tailMap(endKey, false); 3087 fail("should throw IllegalArgumentException"); 3088 } catch (IllegalArgumentException e) { 3089 // Expected 3090 } 3091 3092 // With Comparator 3093 decendingMap = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 3094 .descendingMap(); 3095 endKey = new Integer(110).toString(); 3096 try { 3097 decendingMap.tailMap(endKey, true); 3098 fail("should throw IllegalArgumentException"); 3099 } catch (IllegalArgumentException e) { 3100 // Expected 3101 } 3102 3103 try { 3104 decendingMap.tailMap(endKey, false); 3105 fail("should throw IllegalArgumentException"); 3106 } catch (IllegalArgumentException e) { 3107 // Expected 3108 } 3109 3110 endKey = new Integer(109).toString(); 3111 try { 3112 decendingMap.tailMap(endKey, true); 3113 fail("should throw IllegalArgumentException"); 3114 } catch (IllegalArgumentException e) { 3115 // Expected 3116 } 3117 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3118 key = endKey; 3119 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3120 3121 endKey = new Integer(108).toString(); 3122 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3123 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3124 key = endKey; 3125 assertTrue(subDecendingMap_Included.containsKey(key)); 3126 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3127 for (int i = 107; i > 100; i--) { 3128 key = new Integer(i).toString(); 3129 assertTrue(subDecendingMap_Included.containsKey(key)); 3130 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3131 } 3132 key = new Integer(100).toString(); 3133 assertFalse(subDecendingMap_Included.containsKey(key)); 3134 assertFalse(subDecendingMap_Included.containsKey(key)); 3135 3136 endKey = new Integer(101).toString(); 3137 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3138 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3139 key = endKey; 3140 assertEquals(1, subDecendingMap_Included.size()); 3141 assertTrue(subDecendingMap_Included.containsKey(key)); 3142 assertTrue(subDecendingMap_Excluded.isEmpty()); 3143 3144 endKey = new Integer(100).toString(); 3145 try { 3146 decendingMap.tailMap(endKey, true); 3147 fail("should throw IllegalArgumentException"); 3148 } catch (IllegalArgumentException e) { 3149 // Expected 3150 } 3151 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3152 assertTrue(subDecendingMap_Excluded.isEmpty()); 3153 3154 endKey = new Integer(99).toString(); 3155 try { 3156 decendingMap.tailMap(endKey, true); 3157 fail("should throw IllegalArgumentException"); 3158 } catch (IllegalArgumentException e) { 3159 // Expected 3160 } 3161 3162 try { 3163 decendingMap.tailMap(endKey, false); 3164 fail("should throw IllegalArgumentException"); 3165 } catch (IllegalArgumentException e) { 3166 // Expected 3167 } 3168 3169 decendingMap = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 3170 .descendingMap(); 3171 endKey = new Integer(110).toString(); 3172 try { 3173 decendingMap.tailMap(endKey, true); 3174 fail("should throw IllegalArgumentException"); 3175 } catch (IllegalArgumentException e) { 3176 // Expected 3177 } 3178 3179 try { 3180 decendingMap.tailMap(endKey, false); 3181 fail("should throw IllegalArgumentException"); 3182 } catch (IllegalArgumentException e) { 3183 // Expected 3184 } 3185 3186 endKey = new Integer(109).toString(); 3187 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3188 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3189 key = endKey; 3190 assertTrue(subDecendingMap_Included.containsKey(key)); 3191 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3192 3193 endKey = new Integer(108).toString(); 3194 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3195 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3196 key = endKey; 3197 assertTrue(subDecendingMap_Included.containsKey(key)); 3198 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3199 for (int i = 107; i > 100; i--) { 3200 key = new Integer(i).toString(); 3201 assertTrue(subDecendingMap_Included.containsKey(key)); 3202 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3203 } 3204 key = new Integer(100).toString(); 3205 assertFalse(subDecendingMap_Included.containsKey(key)); 3206 assertFalse(subDecendingMap_Included.containsKey(key)); 3207 3208 endKey = new Integer(101).toString(); 3209 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3210 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3211 key = endKey; 3212 assertEquals(1, subDecendingMap_Included.size()); 3213 assertTrue(subDecendingMap_Included.containsKey(key)); 3214 assertTrue(subDecendingMap_Excluded.isEmpty()); 3215 3216 endKey = new Integer(100).toString(); 3217 try { 3218 decendingMap.tailMap(endKey, true); 3219 fail("should throw IllegalArgumentException"); 3220 } catch (IllegalArgumentException e) { 3221 // Expected 3222 } 3223 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3224 assertTrue(subDecendingMap_Excluded.isEmpty()); 3225 3226 endKey = new Integer(99).toString(); 3227 try { 3228 decendingMap.tailMap(endKey, true); 3229 fail("should throw IllegalArgumentException"); 3230 } catch (IllegalArgumentException e) { 3231 // Expected 3232 } 3233 try { 3234 decendingMap.tailMap(endKey, false); 3235 fail("should throw IllegalArgumentException"); 3236 } catch (IllegalArgumentException e) { 3237 // Expected 3238 } 3239 3240 // navigableMap_startIncluded_endExcluded 3241 decendingMap = ((NavigableMap) subMap_startIncluded_endExcluded) 3242 .descendingMap(); 3243 endKey = new Integer(110).toString(); 3244 try { 3245 decendingMap.tailMap(endKey, true); 3246 fail("should throw IllegalArgumentException"); 3247 } catch (IllegalArgumentException e) { 3248 // Expected 3249 } 3250 3251 try { 3252 decendingMap.tailMap(endKey, false); 3253 fail("should throw IllegalArgumentException"); 3254 } catch (IllegalArgumentException e) { 3255 // Expected 3256 } 3257 3258 endKey = new Integer(109).toString(); 3259 try { 3260 decendingMap.tailMap(endKey, true); 3261 3262 } catch (IllegalArgumentException e) { 3263 // Expected 3264 } 3265 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3266 key = endKey; 3267 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3268 3269 endKey = new Integer(108).toString(); 3270 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3271 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3272 key = endKey; 3273 assertTrue(subDecendingMap_Included.containsKey(key)); 3274 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3275 for (int i = 107; i > 100; i--) { 3276 key = new Integer(i).toString(); 3277 assertTrue(subDecendingMap_Included.containsKey(key)); 3278 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3279 } 3280 key = new Integer(100).toString(); 3281 assertTrue(subDecendingMap_Included.containsKey(key)); 3282 assertTrue(subDecendingMap_Included.containsKey(key)); 3283 3284 endKey = new Integer(101).toString(); 3285 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3286 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3287 key = endKey; 3288 assertEquals(2, subDecendingMap_Included.size()); 3289 assertTrue(subDecendingMap_Included.containsKey(key)); 3290 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3291 3292 endKey = new Integer(100).toString(); 3293 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3294 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3295 key = endKey; 3296 assertTrue(subDecendingMap_Included.containsKey(key)); 3297 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3298 3299 endKey = new Integer(99).toString(); 3300 try { 3301 decendingMap.tailMap(endKey, true); 3302 fail("should throw IllegalArgumentException"); 3303 } catch (IllegalArgumentException e) { 3304 // Expected 3305 } 3306 try { 3307 decendingMap.tailMap(endKey, false); 3308 fail("should throw IllegalArgumentException"); 3309 } catch (IllegalArgumentException e) { 3310 // Expected 3311 } 3312 3313 decendingMap = ((NavigableMap) subMap_startIncluded_endIncluded) 3314 .descendingMap(); 3315 endKey = new Integer(110).toString(); 3316 try { 3317 decendingMap.tailMap(endKey, true); 3318 fail("should throw IllegalArgumentException"); 3319 } catch (IllegalArgumentException e) { 3320 // Expected 3321 } 3322 try { 3323 decendingMap.tailMap(endKey, false); 3324 fail("should throw IllegalArgumentException"); 3325 } catch (IllegalArgumentException e) { 3326 // Expected 3327 } 3328 3329 endKey = new Integer(109).toString(); 3330 try { 3331 decendingMap.tailMap(endKey, true); 3332 3333 } catch (IllegalArgumentException e) { 3334 // Expected 3335 } 3336 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3337 key = endKey; 3338 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3339 3340 endKey = new Integer(108).toString(); 3341 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3342 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3343 key = endKey; 3344 assertTrue(subDecendingMap_Included.containsKey(key)); 3345 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3346 for (int i = 107; i > 100; i--) { 3347 key = new Integer(i).toString(); 3348 assertTrue(subDecendingMap_Included.containsKey(key)); 3349 assertTrue(subDecendingMap_Excluded.containsKey(key)); 3350 } 3351 key = new Integer(100).toString(); 3352 assertTrue(subDecendingMap_Included.containsKey(key)); 3353 assertTrue(subDecendingMap_Included.containsKey(key)); 3354 3355 endKey = new Integer(101).toString(); 3356 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3357 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3358 key = endKey; 3359 assertEquals(2, subDecendingMap_Included.size()); 3360 assertTrue(subDecendingMap_Included.containsKey(key)); 3361 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3362 3363 endKey = new Integer(100).toString(); 3364 subDecendingMap_Included = decendingMap.tailMap(endKey, true); 3365 subDecendingMap_Excluded = decendingMap.tailMap(endKey, false); 3366 key = endKey; 3367 assertTrue(subDecendingMap_Included.containsKey(key)); 3368 assertFalse(subDecendingMap_Excluded.containsKey(key)); 3369 3370 endKey = new Integer(99).toString(); 3371 try { 3372 decendingMap.tailMap(endKey, true); 3373 fail("should throw IllegalArgumentException"); 3374 } catch (IllegalArgumentException e) { 3375 // Expected 3376 } 3377 try { 3378 decendingMap.tailMap(endKey, false); 3379 fail("should throw IllegalArgumentException"); 3380 } catch (IllegalArgumentException e) { 3381 // Expected 3382 } 3383 } 3384 3385 public void test_Entry_setValue() { 3386 TreeMap treeMap = new TreeMap(); 3387 Integer value = null; 3388 for (int i = 0; i < 50; i++) { 3389 value = new Integer(i); 3390 treeMap.put(value, value); 3391 } 3392 Map checkedMap = Collections.checkedMap(treeMap, Integer.class, 3393 Integer.class); 3394 Set entrySet = checkedMap.entrySet(); 3395 Iterator iterator = entrySet.iterator(); 3396 Entry entry; 3397 value = new Integer(0); 3398 for (; iterator.hasNext(); value++) { 3399 entry = (Entry) iterator.next(); 3400 assertEquals(value, entry.setValue(value + 1)); 3401 assertEquals(value + 1, entry.getValue()); 3402 } 3403 } 3404 3405 public void test_DescendingSubMapEntrySet_comparator() { 3406 Set entrySet; 3407 NavigableSet descendingSet; 3408 Comparator comparator; 3409 Entry[] entryArray; 3410 Integer value1, value2; 3411 3412 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3413 if (entrySet instanceof NavigableSet) { 3414 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3415 assertNull(((NavigableSet) entrySet).comparator()); 3416 comparator = descendingSet.comparator(); 3417 assertNotNull(comparator); 3418 3419 entryArray = (Entry[]) descendingSet 3420 .toArray(new Entry[descendingSet.size()]); 3421 for (int i = 1; i < entryArray.length; i++) { 3422 value1 = (Integer) entryArray[i - 1].getValue(); 3423 value2 = (Integer) entryArray[i].getValue(); 3424 assertTrue(value1 > value2); 3425 assertTrue(comparator.compare(value1, value2) < 0); 3426 } 3427 } 3428 3429 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3430 if (entrySet instanceof NavigableSet) { 3431 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3432 assertNull(((NavigableSet) entrySet).comparator()); 3433 comparator = descendingSet.comparator(); 3434 assertNotNull(comparator); 3435 3436 entryArray = (Entry[]) descendingSet 3437 .toArray(new Entry[descendingSet.size()]); 3438 for (int i = 1; i < entryArray.length; i++) { 3439 value1 = (Integer) entryArray[i - 1].getValue(); 3440 value2 = (Integer) entryArray[i].getValue(); 3441 assertTrue(value1 > value2); 3442 assertTrue(comparator.compare(value1, value2) < 0); 3443 } 3444 } 3445 3446 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3447 if (entrySet instanceof NavigableSet) { 3448 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3449 assertNull(((NavigableSet) entrySet).comparator()); 3450 comparator = descendingSet.comparator(); 3451 assertNotNull(comparator); 3452 3453 entryArray = (Entry[]) descendingSet 3454 .toArray(new Entry[descendingSet.size()]); 3455 for (int i = 1; i < entryArray.length; i++) { 3456 value1 = (Integer) entryArray[i - 1].getValue(); 3457 value2 = (Integer) entryArray[i].getValue(); 3458 assertTrue(value1 > value2); 3459 assertTrue(comparator.compare(value1, value2) < 0); 3460 } 3461 } 3462 3463 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3464 if (entrySet instanceof NavigableSet) { 3465 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3466 assertNull(((NavigableSet) entrySet).comparator()); 3467 comparator = descendingSet.comparator(); 3468 assertNotNull(comparator); 3469 3470 entryArray = (Entry[]) descendingSet 3471 .toArray(new Entry[descendingSet.size()]); 3472 for (int i = 1; i < entryArray.length; i++) { 3473 value1 = (Integer) entryArray[i - 1].getValue(); 3474 value2 = (Integer) entryArray[i].getValue(); 3475 assertTrue(value1 > value2); 3476 assertTrue(comparator.compare(value1, value2) < 0); 3477 } 3478 } 3479 3480 String endKey = new Integer(2).toString(); 3481 entrySet = tm.headMap(endKey, true).entrySet(); 3482 if (entrySet instanceof NavigableSet) { 3483 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3484 assertNotNull(descendingSet.comparator()); 3485 } 3486 } 3487 3488 public void test_DescendingSubMapEntrySet_descendingSet() { 3489 Set entrySet; 3490 NavigableSet ascendingSubMapEntrySet, descendingSet, descendingDescedingSet; 3491 Entry[] ascendingEntryArray, descendingDescendingArray; 3492 3493 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3494 if (entrySet instanceof NavigableSet) { 3495 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3496 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3497 descendingDescedingSet = descendingSet.descendingSet(); 3498 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3499 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3500 3501 descendingDescendingArray = (Entry[]) descendingDescedingSet 3502 .toArray(new Entry[descendingDescedingSet.size()]); 3503 3504 assertEquals(ascendingEntryArray.length, 3505 descendingDescendingArray.length); 3506 for (int i = 0; i < ascendingEntryArray.length; i++) { 3507 assertEquals(ascendingEntryArray[i], 3508 descendingDescendingArray[i]); 3509 } 3510 } 3511 3512 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3513 if (entrySet instanceof NavigableSet) { 3514 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3515 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3516 descendingDescedingSet = descendingSet.descendingSet(); 3517 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3518 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3519 3520 descendingDescendingArray = (Entry[]) descendingDescedingSet 3521 .toArray(new Entry[descendingDescedingSet.size()]); 3522 3523 assertEquals(ascendingEntryArray.length, 3524 descendingDescendingArray.length); 3525 for (int i = 0; i < ascendingEntryArray.length; i++) { 3526 assertEquals(ascendingEntryArray[i], 3527 descendingDescendingArray[i]); 3528 } 3529 } 3530 3531 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3532 if (entrySet instanceof NavigableSet) { 3533 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3534 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3535 descendingDescedingSet = descendingSet.descendingSet(); 3536 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3537 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3538 3539 descendingDescendingArray = (Entry[]) descendingDescedingSet 3540 .toArray(new Entry[descendingDescedingSet.size()]); 3541 3542 assertEquals(ascendingEntryArray.length, 3543 descendingDescendingArray.length); 3544 for (int i = 0; i < ascendingEntryArray.length; i++) { 3545 assertEquals(ascendingEntryArray[i], 3546 descendingDescendingArray[i]); 3547 } 3548 } 3549 3550 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3551 if (entrySet instanceof NavigableSet) { 3552 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3553 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3554 descendingDescedingSet = descendingSet.descendingSet(); 3555 ascendingEntryArray = (Entry[]) ascendingSubMapEntrySet 3556 .toArray(new Entry[ascendingSubMapEntrySet.size()]); 3557 3558 descendingDescendingArray = (Entry[]) descendingDescedingSet 3559 .toArray(new Entry[descendingDescedingSet.size()]); 3560 3561 assertEquals(ascendingEntryArray.length, 3562 descendingDescendingArray.length); 3563 for (int i = 0; i < ascendingEntryArray.length; i++) { 3564 assertEquals(ascendingEntryArray[i], 3565 descendingDescendingArray[i]); 3566 } 3567 } 3568 3569 String endKey = new Integer(2).toString(); 3570 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 3571 if (entrySet instanceof NavigableSet) { 3572 // [2...0] 3573 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3574 // [0...2] 3575 descendingDescedingSet = descendingSet.descendingSet(); 3576 Iterator iterator = descendingDescedingSet.iterator(); 3577 assertEquals(0, ((Entry) iterator.next()).getValue()); 3578 } 3579 3580 String startKey = new Integer(2).toString(); 3581 entrySet = tm.tailMap(startKey, true).entrySet();// 2... 3582 if (entrySet instanceof NavigableSet) { 3583 // [2...0] 3584 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3585 // [0...2] 3586 descendingDescedingSet = descendingSet.descendingSet(); 3587 Iterator iterator = descendingDescedingSet.iterator(); 3588 assertEquals(2, ((Entry) iterator.next()).getValue()); 3589 } 3590 3591 } 3592 3593 public void test_DescendingSubMapEntrySet_first() { 3594 Set entrySet; 3595 NavigableSet ascendingSubMapEntrySet, descendingSet; 3596 Entry entry; 3597 3598 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3599 if (entrySet instanceof NavigableSet) { 3600 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3601 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3602 entry = (Entry) descendingSet.first(); 3603 assertEquals(101, entry.getValue()); 3604 } 3605 3606 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3607 if (entrySet instanceof NavigableSet) { 3608 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3609 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3610 entry = (Entry) descendingSet.first(); 3611 assertEquals(101, entry.getValue()); 3612 } 3613 3614 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3615 if (entrySet instanceof NavigableSet) { 3616 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3617 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3618 entry = (Entry) descendingSet.first(); 3619 assertEquals(100, entry.getValue()); 3620 } 3621 3622 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3623 if (entrySet instanceof NavigableSet) { 3624 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3625 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3626 entry = (Entry) descendingSet.first(); 3627 assertEquals(100, entry.getValue()); 3628 } 3629 } 3630 3631 public void test_DescendingSubMapEntrySet_last() { 3632 Set entrySet; 3633 NavigableSet ascendingSubMapEntrySet, descendingSet; 3634 Entry entry; 3635 3636 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3637 if (entrySet instanceof NavigableSet) { 3638 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3639 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3640 entry = (Entry) descendingSet.last(); 3641 assertEquals(108, entry.getValue()); 3642 } 3643 3644 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3645 if (entrySet instanceof NavigableSet) { 3646 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3647 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3648 entry = (Entry) descendingSet.last(); 3649 assertEquals(109, entry.getValue()); 3650 } 3651 3652 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3653 if (entrySet instanceof NavigableSet) { 3654 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3655 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3656 entry = (Entry) descendingSet.last(); 3657 assertEquals(108, entry.getValue()); 3658 } 3659 3660 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3661 if (entrySet instanceof NavigableSet) { 3662 ascendingSubMapEntrySet = (NavigableSet) entrySet; 3663 descendingSet = ascendingSubMapEntrySet.descendingSet(); 3664 entry = (Entry) descendingSet.last(); 3665 assertEquals(109, entry.getValue()); 3666 } 3667 } 3668 3669 public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() { 3670 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3671 Entry entry; 3672 if (entrySet instanceof NavigableSet) { 3673 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3674 .descendingSet(); 3675 assertEquals(8, descendingSubMapEntrySet.size()); 3676 for (int i = 101; i < 109; i++) { 3677 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3678 assertEquals(i, entry.getValue()); 3679 } 3680 assertNull(descendingSubMapEntrySet.pollFirst()); 3681 } 3682 } 3683 3684 public void test_DescendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() { 3685 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3686 Entry entry; 3687 if (entrySet instanceof NavigableSet) { 3688 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3689 .descendingSet(); 3690 assertEquals(9, descendingSubMapEntrySet.size()); 3691 for (int i = 101; i < 110; i++) { 3692 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3693 assertEquals(i, entry.getValue()); 3694 } 3695 assertNull(descendingSubMapEntrySet.pollFirst()); 3696 } 3697 } 3698 3699 public void test_DescendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() { 3700 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3701 Entry entry; 3702 if (entrySet instanceof NavigableSet) { 3703 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3704 .descendingSet(); 3705 assertEquals(9, descendingSubMapEntrySet.size()); 3706 for (int i = 100; i < 109; i++) { 3707 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3708 assertEquals(i, entry.getValue()); 3709 } 3710 assertNull(descendingSubMapEntrySet.pollFirst()); 3711 } 3712 } 3713 3714 public void test_DescendingSubMapEntrySet_pollFirst_startIncluded_endIncluded() { 3715 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3716 Entry entry; 3717 if (entrySet instanceof NavigableSet) { 3718 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3719 .descendingSet(); 3720 assertEquals(10, descendingSubMapEntrySet.size()); 3721 for (int i = 100; i < 110; i++) { 3722 entry = (Entry) descendingSubMapEntrySet.pollFirst(); 3723 assertEquals(i, entry.getValue()); 3724 } 3725 assertNull(descendingSubMapEntrySet.pollFirst()); 3726 } 3727 } 3728 3729 public void test_DescendingSubMapEntrySet_pollFirst() { 3730 String key = new Integer(2).toString(); 3731 Set entrySet = tm.headMap(key, true).entrySet();// [0...2] 3732 NavigableSet descendingEntrySet; 3733 Entry entry; 3734 3735 if (entrySet instanceof NavigableSet) { 3736 // [2...0] 3737 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3738 entry = (Entry) descendingEntrySet.pollFirst(); 3739 assertEquals(0, entry.getValue()); 3740 } 3741 3742 entrySet = tm.tailMap(key, true).entrySet(); 3743 if (entrySet instanceof NavigableSet) { 3744 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3745 entry = (Entry) descendingEntrySet.pollFirst(); 3746 assertEquals(2, entry.getValue()); 3747 } 3748 } 3749 3750 public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endExclued() { 3751 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3752 Entry entry; 3753 if (entrySet instanceof NavigableSet) { 3754 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3755 .descendingSet(); 3756 assertEquals(8, descendingSubMapEntrySet.size()); 3757 for (int i = 108; i > 100; i--) { 3758 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3759 assertEquals(i, entry.getValue()); 3760 } 3761 assertNull(descendingSubMapEntrySet.pollFirst()); 3762 } 3763 } 3764 3765 public void test_DescendingSubMapEntrySet_pollLast_startExcluded_endInclued() { 3766 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3767 Entry entry; 3768 if (entrySet instanceof NavigableSet) { 3769 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3770 .descendingSet(); 3771 assertEquals(9, descendingSubMapEntrySet.size()); 3772 for (int i = 109; i > 100; i--) { 3773 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3774 assertEquals(i, entry.getValue()); 3775 } 3776 assertNull(descendingSubMapEntrySet.pollFirst()); 3777 } 3778 } 3779 3780 public void test_DescendingSubMapEntrySet_pollLast_startIncluded_endExclued() { 3781 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3782 Entry entry; 3783 if (entrySet instanceof NavigableSet) { 3784 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3785 .descendingSet(); 3786 assertEquals(9, descendingSubMapEntrySet.size()); 3787 for (int i = 108; i > 99; i--) { 3788 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3789 assertEquals(i, entry.getValue()); 3790 } 3791 assertNull(descendingSubMapEntrySet.pollFirst()); 3792 } 3793 } 3794 3795 public void test_DescendingSubMapEntrySet_pollLast_startIncluded_endInclued() { 3796 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3797 Entry entry; 3798 if (entrySet instanceof NavigableSet) { 3799 NavigableSet descendingSubMapEntrySet = ((NavigableSet) entrySet) 3800 .descendingSet(); 3801 assertEquals(10, descendingSubMapEntrySet.size()); 3802 for (int i = 109; i > 99; i--) { 3803 entry = (Entry) descendingSubMapEntrySet.pollLast(); 3804 assertEquals(i, entry.getValue()); 3805 } 3806 assertNull(descendingSubMapEntrySet.pollFirst()); 3807 } 3808 } 3809 3810 public void test_DescendingSubMapEntrySet_pollLast() { 3811 String key = new Integer(2).toString(); 3812 Set entrySet = tm.headMap(key, true).entrySet();// [0...2] 3813 NavigableSet descendingEntrySet; 3814 Entry entry; 3815 3816 if (entrySet instanceof NavigableSet) { 3817 // [2...0] 3818 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3819 entry = (Entry) descendingEntrySet.pollLast(); 3820 assertEquals(2, entry.getValue()); 3821 } 3822 3823 entrySet = tm.tailMap(key, true).entrySet(); 3824 if (entrySet instanceof NavigableSet) { 3825 descendingEntrySet = ((NavigableSet) entrySet).descendingSet(); 3826 entry = (Entry) descendingEntrySet.pollLast(); 3827 assertEquals(999, entry.getValue()); 3828 } 3829 } 3830 3831 public void test_DescendingSubMapEntrySet_descendingIterator() { 3832 Set entrySet; 3833 NavigableSet descendingSet; 3834 Iterator iterator; 3835 3836 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3837 if (entrySet instanceof NavigableSet) { 3838 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3839 iterator = descendingSet.iterator(); 3840 for (int value = 108; value > 100; value--) { 3841 assertTrue(iterator.hasNext()); 3842 assertEquals(value, ((Entry) iterator.next()).getValue()); 3843 } 3844 assertFalse(iterator.hasNext()); 3845 try { 3846 iterator.next(); 3847 fail("should throw NoSuchElementException"); 3848 } catch (NoSuchElementException e) { 3849 // Expected 3850 } 3851 } 3852 3853 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3854 if (entrySet instanceof NavigableSet) { 3855 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3856 iterator = descendingSet.iterator(); 3857 for (int value = 109; value > 100; value--) { 3858 assertTrue(iterator.hasNext()); 3859 assertEquals(value, ((Entry) iterator.next()).getValue()); 3860 } 3861 assertFalse(iterator.hasNext()); 3862 try { 3863 iterator.next(); 3864 fail("should throw NoSuchElementException"); 3865 } catch (NoSuchElementException e) { 3866 // Expected 3867 } 3868 } 3869 3870 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 3871 if (entrySet instanceof NavigableSet) { 3872 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3873 iterator = descendingSet.iterator(); 3874 for (int value = 108; value > 99; value--) { 3875 assertTrue(iterator.hasNext()); 3876 assertEquals(value, ((Entry) iterator.next()).getValue()); 3877 } 3878 assertFalse(iterator.hasNext()); 3879 try { 3880 iterator.next(); 3881 fail("should throw NoSuchElementException"); 3882 } catch (NoSuchElementException e) { 3883 // Expected 3884 } 3885 } 3886 3887 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 3888 if (entrySet instanceof NavigableSet) { 3889 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3890 iterator = descendingSet.iterator(); 3891 for (int value = 109; value > 99; value--) { 3892 assertTrue(iterator.hasNext()); 3893 assertEquals(value, ((Entry) iterator.next()).getValue()); 3894 } 3895 assertFalse(iterator.hasNext()); 3896 try { 3897 iterator.next(); 3898 fail("should throw NoSuchElementException"); 3899 } catch (NoSuchElementException e) { 3900 // Expected 3901 } 3902 } 3903 3904 String endKey = new Integer(2).toString(); 3905 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 3906 if (entrySet instanceof NavigableSet) { 3907 // [2...0] 3908 descendingSet = ((NavigableSet) entrySet).descendingSet(); 3909 iterator = descendingSet.descendingIterator(); 3910 assertEquals(0, ((Entry) iterator.next()).getValue());// 0...2 3911 } 3912 } 3913 3914 public void test_DescendingSubMapEntrySet_headSet() { 3915 Set entrySet, headSet; 3916 NavigableSet descendingSubMapEntrySet; 3917 Iterator iterator, headSetIterator; 3918 Entry entry; 3919 int value; 3920 3921 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 3922 if (entrySet instanceof NavigableSet) { 3923 descendingSubMapEntrySet = ((NavigableSet) entrySet) 3924 .descendingSet(); 3925 iterator = descendingSubMapEntrySet.iterator(); 3926 while (iterator.hasNext()) { 3927 entry = (Entry) iterator.next(); 3928 headSet = descendingSubMapEntrySet.headSet(entry); 3929 headSetIterator = headSet.iterator(); 3930 for (value = 108; headSetIterator.hasNext(); value--) { 3931 assertEquals(value, ((Entry) headSetIterator.next()) 3932 .getValue()); 3933 } 3934 try { 3935 headSetIterator.next(); 3936 fail("should throw NoSuchElementException"); 3937 } catch (NoSuchElementException e) { 3938 // Expected 3939 } 3940 3941 headSet = descendingSubMapEntrySet.headSet(entry, false); 3942 headSetIterator = headSet.iterator(); 3943 for (value = 108; headSetIterator.hasNext(); value--) { 3944 assertEquals(value, ((Entry) headSetIterator.next()) 3945 .getValue()); 3946 } 3947 try { 3948 headSetIterator.next(); 3949 fail("should throw NoSuchElementException"); 3950 } catch (NoSuchElementException e) { 3951 // Expected 3952 } 3953 3954 headSet = descendingSubMapEntrySet.headSet(entry, true); 3955 headSetIterator = headSet.iterator(); 3956 for (value = 108; headSetIterator.hasNext(); value--) { 3957 assertEquals(value, ((Entry) headSetIterator.next()) 3958 .getValue()); 3959 } 3960 try { 3961 headSetIterator.next(); 3962 fail("should throw NoSuchElementException"); 3963 } catch (NoSuchElementException e) { 3964 // Expected 3965 } 3966 } 3967 } 3968 3969 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 3970 if (entrySet instanceof NavigableSet) { 3971 descendingSubMapEntrySet = ((NavigableSet) entrySet) 3972 .descendingSet(); 3973 iterator = descendingSubMapEntrySet.iterator(); 3974 while (iterator.hasNext()) { 3975 entry = (Entry) iterator.next(); 3976 headSet = descendingSubMapEntrySet.headSet(entry); 3977 headSetIterator = headSet.iterator(); 3978 for (value = 109; headSetIterator.hasNext(); value--) { 3979 assertEquals(value, ((Entry) headSetIterator.next()) 3980 .getValue()); 3981 } 3982 try { 3983 headSetIterator.next(); 3984 fail("should throw NoSuchElementException"); 3985 } catch (NoSuchElementException e) { 3986 // Expected 3987 } 3988 3989 headSet = descendingSubMapEntrySet.headSet(entry, false); 3990 headSetIterator = headSet.iterator(); 3991 for (value = 109; headSetIterator.hasNext(); value--) { 3992 assertEquals(value, ((Entry) headSetIterator.next()) 3993 .getValue()); 3994 } 3995 try { 3996 headSetIterator.next(); 3997 fail("should throw NoSuchElementException"); 3998 } catch (NoSuchElementException e) { 3999 // Expected 4000 } 4001 4002 headSet = descendingSubMapEntrySet.headSet(entry, true); 4003 headSetIterator = headSet.iterator(); 4004 for (value = 109; headSetIterator.hasNext(); value--) { 4005 assertEquals(value, ((Entry) headSetIterator.next()) 4006 .getValue()); 4007 } 4008 try { 4009 headSetIterator.next(); 4010 fail("should throw NoSuchElementException"); 4011 } catch (NoSuchElementException e) { 4012 // Expected 4013 } 4014 } 4015 } 4016 4017 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4018 if (entrySet instanceof NavigableSet) { 4019 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4020 .descendingSet(); 4021 iterator = descendingSubMapEntrySet.iterator(); 4022 while (iterator.hasNext()) { 4023 entry = (Entry) iterator.next(); 4024 headSet = descendingSubMapEntrySet.headSet(entry); 4025 headSetIterator = headSet.iterator(); 4026 for (value = 108; headSetIterator.hasNext(); value--) { 4027 assertEquals(value, ((Entry) headSetIterator.next()) 4028 .getValue()); 4029 } 4030 try { 4031 headSetIterator.next(); 4032 fail("should throw NoSuchElementException"); 4033 } catch (NoSuchElementException e) { 4034 // Expected 4035 } 4036 4037 headSet = descendingSubMapEntrySet.headSet(entry, false); 4038 headSetIterator = headSet.iterator(); 4039 for (value = 108; headSetIterator.hasNext(); value--) { 4040 assertEquals(value, ((Entry) headSetIterator.next()) 4041 .getValue()); 4042 } 4043 try { 4044 headSetIterator.next(); 4045 fail("should throw NoSuchElementException"); 4046 } catch (NoSuchElementException e) { 4047 // Expected 4048 } 4049 4050 headSet = descendingSubMapEntrySet.headSet(entry, true); 4051 headSetIterator = headSet.iterator(); 4052 for (value = 108; headSetIterator.hasNext(); value--) { 4053 assertEquals(value, ((Entry) headSetIterator.next()) 4054 .getValue()); 4055 } 4056 try { 4057 headSetIterator.next(); 4058 fail("should throw NoSuchElementException"); 4059 } catch (NoSuchElementException e) { 4060 // Expected 4061 } 4062 } 4063 } 4064 4065 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4066 if (entrySet instanceof NavigableSet) { 4067 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4068 .descendingSet(); 4069 iterator = descendingSubMapEntrySet.iterator(); 4070 while (iterator.hasNext()) { 4071 entry = (Entry) iterator.next(); 4072 headSet = descendingSubMapEntrySet.headSet(entry); 4073 headSetIterator = headSet.iterator(); 4074 for (value = 109; headSetIterator.hasNext(); value--) { 4075 assertEquals(value, ((Entry) headSetIterator.next()) 4076 .getValue()); 4077 } 4078 try { 4079 headSetIterator.next(); 4080 fail("should throw NoSuchElementException"); 4081 } catch (NoSuchElementException e) { 4082 // Expected 4083 } 4084 4085 headSet = descendingSubMapEntrySet.headSet(entry, false); 4086 headSetIterator = headSet.iterator(); 4087 for (value = 109; headSetIterator.hasNext(); value--) { 4088 assertEquals(value, ((Entry) headSetIterator.next()) 4089 .getValue()); 4090 } 4091 try { 4092 headSetIterator.next(); 4093 fail("should throw NoSuchElementException"); 4094 } catch (NoSuchElementException e) { 4095 // Expected 4096 } 4097 4098 headSet = descendingSubMapEntrySet.headSet(entry, true); 4099 headSetIterator = headSet.iterator(); 4100 for (value = 109; headSetIterator.hasNext(); value--) { 4101 assertEquals(value, ((Entry) headSetIterator.next()) 4102 .getValue()); 4103 } 4104 try { 4105 headSetIterator.next(); 4106 fail("should throw NoSuchElementException"); 4107 } catch (NoSuchElementException e) { 4108 // Expected 4109 } 4110 } 4111 } 4112 4113 String endKey = new Integer(2).toString(); 4114 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 4115 if (entrySet instanceof NavigableSet) { 4116 // [2...0] 4117 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4118 .descendingSet(); 4119 iterator = descendingSubMapEntrySet.iterator(); 4120 iterator.next();// 2 4121 iterator.next();// 199 4122 entry = (Entry) iterator.next();// 198 4123 headSet = descendingSubMapEntrySet.headSet(entry); 4124 assertEquals(2, headSet.size());// 2 199 4125 headSetIterator = headSet.iterator(); 4126 assertEquals(2, ((Entry) headSetIterator.next()).getValue()); 4127 assertEquals(199, ((Entry) headSetIterator.next()).getValue()); 4128 4129 headSet = descendingSubMapEntrySet.headSet(entry, true); 4130 assertEquals(3, headSet.size());// 2 199 4131 headSetIterator = headSet.iterator(); 4132 assertEquals(2, ((Entry) headSetIterator.next()).getValue()); 4133 assertEquals(199, ((Entry) headSetIterator.next()).getValue()); 4134 assertEquals(198, ((Entry) headSetIterator.next()).getValue()); 4135 } 4136 } 4137 4138 public void test_DescendingSubMapEntrySet_tailSet() { 4139 Set entrySet, tailSet; 4140 NavigableSet descendingSubMapEntrySet; 4141 Iterator iterator, tailSetIterator; 4142 Entry entry; 4143 int value; 4144 4145 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4146 if (entrySet instanceof NavigableSet) { 4147 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4148 .descendingSet(); 4149 iterator = descendingSubMapEntrySet.iterator(); 4150 while (iterator.hasNext()) { 4151 entry = (Entry) iterator.next(); 4152 tailSet = descendingSubMapEntrySet.tailSet(entry); 4153 tailSetIterator = tailSet.iterator(); 4154 for (value = (Integer) entry.getValue(); tailSetIterator 4155 .hasNext(); value--) { 4156 assertEquals(value, ((Entry) tailSetIterator.next()) 4157 .getValue()); 4158 } 4159 try { 4160 tailSetIterator.next(); 4161 fail("should throw NoSuchElementException"); 4162 } catch (NoSuchElementException e) { 4163 // Expected 4164 } 4165 4166 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4167 tailSetIterator = tailSet.iterator(); 4168 for (value = (Integer) entry.getValue(); tailSetIterator 4169 .hasNext(); value--) { 4170 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4171 .getValue()); 4172 } 4173 try { 4174 tailSetIterator.next(); 4175 fail("should throw NoSuchElementException"); 4176 } catch (NoSuchElementException e) { 4177 // Expected 4178 } 4179 4180 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4181 tailSetIterator = tailSet.iterator(); 4182 for (value = (Integer) entry.getValue(); tailSetIterator 4183 .hasNext(); value--) { 4184 assertEquals(value, ((Entry) tailSetIterator.next()) 4185 .getValue()); 4186 } 4187 try { 4188 tailSetIterator.next(); 4189 fail("should throw NoSuchElementException"); 4190 } catch (NoSuchElementException e) { 4191 // Expected 4192 } 4193 } 4194 } 4195 4196 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4197 if (entrySet instanceof NavigableSet) { 4198 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4199 .descendingSet(); 4200 iterator = descendingSubMapEntrySet.iterator(); 4201 while (iterator.hasNext()) { 4202 entry = (Entry) iterator.next(); 4203 tailSet = descendingSubMapEntrySet.tailSet(entry); 4204 tailSetIterator = tailSet.iterator(); 4205 for (value = (Integer) entry.getValue(); tailSetIterator 4206 .hasNext(); value--) { 4207 assertEquals(value, ((Entry) tailSetIterator.next()) 4208 .getValue()); 4209 } 4210 try { 4211 tailSetIterator.next(); 4212 fail("should throw NoSuchElementException"); 4213 } catch (NoSuchElementException e) { 4214 // Expected 4215 } 4216 4217 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4218 tailSetIterator = tailSet.iterator(); 4219 for (value = (Integer) entry.getValue(); tailSetIterator 4220 .hasNext(); value--) { 4221 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4222 .getValue()); 4223 } 4224 try { 4225 tailSetIterator.next(); 4226 fail("should throw NoSuchElementException"); 4227 } catch (NoSuchElementException e) { 4228 // Expected 4229 } 4230 4231 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4232 tailSetIterator = tailSet.iterator(); 4233 for (value = (Integer) entry.getValue(); tailSetIterator 4234 .hasNext(); value--) { 4235 assertEquals(value, ((Entry) tailSetIterator.next()) 4236 .getValue()); 4237 } 4238 try { 4239 tailSetIterator.next(); 4240 fail("should throw NoSuchElementException"); 4241 } catch (NoSuchElementException e) { 4242 // Expected 4243 } 4244 } 4245 } 4246 4247 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4248 if (entrySet instanceof NavigableSet) { 4249 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4250 .descendingSet(); 4251 iterator = descendingSubMapEntrySet.iterator(); 4252 while (iterator.hasNext()) { 4253 entry = (Entry) iterator.next(); 4254 tailSet = descendingSubMapEntrySet.tailSet(entry); 4255 tailSetIterator = tailSet.iterator(); 4256 for (value = (Integer) entry.getValue(); tailSetIterator 4257 .hasNext(); value--) { 4258 assertEquals(value, ((Entry) tailSetIterator.next()) 4259 .getValue()); 4260 } 4261 try { 4262 tailSetIterator.next(); 4263 fail("should throw NoSuchElementException"); 4264 } catch (NoSuchElementException e) { 4265 // Expected 4266 } 4267 4268 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4269 tailSetIterator = tailSet.iterator(); 4270 for (value = (Integer) entry.getValue(); tailSetIterator 4271 .hasNext(); value--) { 4272 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4273 .getValue()); 4274 } 4275 try { 4276 tailSetIterator.next(); 4277 fail("should throw NoSuchElementException"); 4278 } catch (NoSuchElementException e) { 4279 // Expected 4280 } 4281 4282 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4283 tailSetIterator = tailSet.iterator(); 4284 for (value = (Integer) entry.getValue(); tailSetIterator 4285 .hasNext(); value--) { 4286 assertEquals(value, ((Entry) tailSetIterator.next()) 4287 .getValue()); 4288 } 4289 try { 4290 tailSetIterator.next(); 4291 fail("should throw NoSuchElementException"); 4292 } catch (NoSuchElementException e) { 4293 // Expected 4294 } 4295 } 4296 } 4297 4298 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4299 if (entrySet instanceof NavigableSet) { 4300 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4301 .descendingSet(); 4302 iterator = descendingSubMapEntrySet.iterator(); 4303 while (iterator.hasNext()) { 4304 entry = (Entry) iterator.next(); 4305 tailSet = descendingSubMapEntrySet.tailSet(entry); 4306 tailSetIterator = tailSet.iterator(); 4307 for (value = (Integer) entry.getValue(); tailSetIterator 4308 .hasNext(); value--) { 4309 assertEquals(value, ((Entry) tailSetIterator.next()) 4310 .getValue()); 4311 } 4312 try { 4313 tailSetIterator.next(); 4314 fail("should throw NoSuchElementException"); 4315 } catch (NoSuchElementException e) { 4316 // Expected 4317 } 4318 4319 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4320 tailSetIterator = tailSet.iterator(); 4321 for (value = (Integer) entry.getValue(); tailSetIterator 4322 .hasNext(); value--) { 4323 assertEquals(value - 1, ((Entry) tailSetIterator.next()) 4324 .getValue()); 4325 } 4326 try { 4327 tailSetIterator.next(); 4328 fail("should throw NoSuchElementException"); 4329 } catch (NoSuchElementException e) { 4330 // Expected 4331 } 4332 4333 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4334 tailSetIterator = tailSet.iterator(); 4335 for (value = (Integer) entry.getValue(); tailSetIterator 4336 .hasNext(); value--) { 4337 assertEquals(value, ((Entry) tailSetIterator.next()) 4338 .getValue()); 4339 } 4340 try { 4341 tailSetIterator.next(); 4342 fail("should throw NoSuchElementException"); 4343 } catch (NoSuchElementException e) { 4344 // Expected 4345 } 4346 } 4347 } 4348 4349 String endKey = new Integer(2).toString(); 4350 entrySet = tm.headMap(endKey, true).entrySet();// 0...2 4351 if (entrySet instanceof NavigableSet) { 4352 // [2...0] 4353 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4354 .descendingSet(); 4355 iterator = descendingSubMapEntrySet.iterator(); 4356 iterator.next();// 2 4357 entry = (Entry) iterator.next();// 199 4358 tailSet = descendingSubMapEntrySet.tailSet(entry); 4359 tailSetIterator = tailSet.iterator(); 4360 assertEquals(199, ((Entry) tailSetIterator.next()).getValue()); 4361 4362 tailSet = descendingSubMapEntrySet.tailSet(entry, false); 4363 tailSetIterator = tailSet.iterator(); 4364 assertEquals(198, ((Entry) tailSetIterator.next()).getValue()); 4365 4366 tailSet = descendingSubMapEntrySet.tailSet(entry, true); 4367 tailSetIterator = tailSet.iterator(); 4368 assertEquals(199, ((Entry) tailSetIterator.next()).getValue()); 4369 } 4370 } 4371 4372 public void test_DescendingSubMapEntrySet_subSet() { 4373 Set entrySet, subSet; 4374 NavigableSet descendingSubMapEntrySet; 4375 Entry startEntry, endEntry; 4376 Iterator subSetIterator; 4377 4378 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4379 if (entrySet instanceof NavigableSet) { 4380 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4381 .descendingSet(); 4382 Iterator iteratorStart = descendingSubMapEntrySet.iterator(); 4383 while (iteratorStart.hasNext()) { 4384 startEntry = (Entry) iteratorStart.next(); 4385 Iterator iteratorEnd = descendingSubMapEntrySet.iterator(); 4386 while (iteratorEnd.hasNext()) { 4387 endEntry = (Entry) iteratorEnd.next(); 4388 int startIndex = (Integer) startEntry.getValue(); 4389 int endIndex = (Integer) endEntry.getValue(); 4390 if (startIndex < endIndex) { 4391 try { 4392 descendingSubMapEntrySet.subSet(startEntry, 4393 endEntry); 4394 fail("should throw IllegalArgumentException"); 4395 } catch (IllegalArgumentException e) { 4396 // Expected 4397 } 4398 4399 try { 4400 descendingSubMapEntrySet.subSet(startEntry, false, 4401 endEntry, false); 4402 fail("should throw IllegalArgumentException"); 4403 } catch (IllegalArgumentException e) { 4404 // Expected 4405 } 4406 4407 try { 4408 descendingSubMapEntrySet.subSet(startEntry, false, 4409 endEntry, true); 4410 fail("should throw IllegalArgumentException"); 4411 } catch (IllegalArgumentException e) { 4412 // Expected 4413 } 4414 4415 try { 4416 descendingSubMapEntrySet.subSet(startEntry, true, 4417 endEntry, false); 4418 fail("should throw IllegalArgumentException"); 4419 } catch (IllegalArgumentException e) { 4420 // Expected 4421 } 4422 4423 try { 4424 descendingSubMapEntrySet.subSet(startEntry, true, 4425 endEntry, true); 4426 fail("should throw IllegalArgumentException"); 4427 } catch (IllegalArgumentException e) { 4428 // Expected 4429 } 4430 } else { 4431 subSet = descendingSubMapEntrySet.subSet(startEntry, 4432 endEntry); 4433 subSetIterator = subSet.iterator(); 4434 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4435 assertEquals(index, ((Entry) subSetIterator.next()) 4436 .getValue()); 4437 } 4438 4439 subSet = descendingSubMapEntrySet.subSet(startEntry, 4440 false, endEntry, false); 4441 subSetIterator = subSet.iterator(); 4442 for (int index = startIndex - 1; subSetIterator 4443 .hasNext(); index--) { 4444 assertEquals(index, ((Entry) subSetIterator.next()) 4445 .getValue()); 4446 } 4447 4448 subSet = descendingSubMapEntrySet.subSet(startEntry, 4449 false, endEntry, true); 4450 subSetIterator = subSet.iterator(); 4451 for (int index = startIndex - 1; subSetIterator 4452 .hasNext(); index--) { 4453 assertEquals(index, ((Entry) subSetIterator.next()) 4454 .getValue()); 4455 } 4456 4457 subSet = descendingSubMapEntrySet.subSet(startEntry, 4458 true, endEntry, false); 4459 subSetIterator = subSet.iterator(); 4460 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4461 assertEquals(index, ((Entry) subSetIterator.next()) 4462 .getValue()); 4463 } 4464 4465 subSet = descendingSubMapEntrySet.subSet(startEntry, 4466 true, endEntry, true); 4467 subSetIterator = subSet.iterator(); 4468 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4469 assertEquals(index, ((Entry) subSetIterator.next()) 4470 .getValue()); 4471 } 4472 } 4473 } 4474 } 4475 } 4476 4477 String endKey = new Integer(2).toString(); 4478 entrySet = tm.headMap(endKey, true).entrySet(); 4479 if (entrySet instanceof NavigableSet) { 4480 // [2...0] 4481 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4482 .descendingSet(); 4483 Iterator iterator = descendingSubMapEntrySet.iterator(); 4484 startEntry = (Entry) iterator.next(); 4485 iterator.next(); 4486 endEntry = (Entry) iterator.next(); 4487 subSet = descendingSubMapEntrySet.subSet(startEntry, endEntry); 4488 assertEquals(2, subSet.size()); 4489 4490 subSet = descendingSubMapEntrySet.subSet(startEntry, false, 4491 endEntry, false); 4492 assertEquals(1, subSet.size()); 4493 subSetIterator = subSet.iterator(); 4494 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4495 4496 subSet = descendingSubMapEntrySet.subSet(startEntry, false, 4497 endEntry, true); 4498 assertEquals(2, subSet.size()); 4499 subSetIterator = subSet.iterator(); 4500 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4501 assertEquals(198, ((Entry) subSetIterator.next()).getValue()); 4502 4503 subSet = descendingSubMapEntrySet.subSet(startEntry, true, 4504 endEntry, false); 4505 assertEquals(2, subSet.size()); 4506 subSetIterator = subSet.iterator(); 4507 assertEquals(2, ((Entry) subSetIterator.next()).getValue()); 4508 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4509 4510 subSet = descendingSubMapEntrySet.subSet(startEntry, true, 4511 endEntry, true); 4512 assertEquals(3, subSet.size()); 4513 subSetIterator = subSet.iterator(); 4514 assertEquals(2, ((Entry) subSetIterator.next()).getValue()); 4515 assertEquals(199, ((Entry) subSetIterator.next()).getValue()); 4516 assertEquals(198, ((Entry) subSetIterator.next()).getValue()); 4517 } 4518 4519 // With Comnparator 4520 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 4521 if (entrySet instanceof NavigableSet) { 4522 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4523 .descendingSet(); 4524 Iterator iteratorStart = descendingSubMapEntrySet.iterator(); 4525 while (iteratorStart.hasNext()) { 4526 startEntry = (Entry) iteratorStart.next(); 4527 Iterator iteratorEnd = descendingSubMapEntrySet.iterator(); 4528 while (iteratorEnd.hasNext()) { 4529 endEntry = (Entry) iteratorEnd.next(); 4530 int startIndex = (Integer) startEntry.getValue(); 4531 int endIndex = (Integer) endEntry.getValue(); 4532 if (startIndex < endIndex) { 4533 try { 4534 descendingSubMapEntrySet.subSet(startEntry, 4535 endEntry); 4536 fail("should throw IllegalArgumentException"); 4537 } catch (IllegalArgumentException e) { 4538 // Expected 4539 } 4540 4541 try { 4542 descendingSubMapEntrySet.subSet(startEntry, false, 4543 endEntry, false); 4544 fail("should throw IllegalArgumentException"); 4545 } catch (IllegalArgumentException e) { 4546 // Expected 4547 } 4548 4549 try { 4550 descendingSubMapEntrySet.subSet(startEntry, false, 4551 endEntry, true); 4552 fail("should throw IllegalArgumentException"); 4553 } catch (IllegalArgumentException e) { 4554 // Expected 4555 } 4556 4557 try { 4558 descendingSubMapEntrySet.subSet(startEntry, true, 4559 endEntry, false); 4560 fail("should throw IllegalArgumentException"); 4561 } catch (IllegalArgumentException e) { 4562 // Expected 4563 } 4564 4565 try { 4566 descendingSubMapEntrySet.subSet(startEntry, true, 4567 endEntry, true); 4568 fail("should throw IllegalArgumentException"); 4569 } catch (IllegalArgumentException e) { 4570 // Expected 4571 } 4572 } else { 4573 subSet = descendingSubMapEntrySet.subSet(startEntry, 4574 endEntry); 4575 subSetIterator = subSet.iterator(); 4576 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4577 assertEquals(index, ((Entry) subSetIterator.next()) 4578 .getValue()); 4579 } 4580 4581 subSet = descendingSubMapEntrySet.subSet(startEntry, 4582 false, endEntry, false); 4583 subSetIterator = subSet.iterator(); 4584 for (int index = startIndex - 1; subSetIterator 4585 .hasNext(); index--) { 4586 assertEquals(index, ((Entry) subSetIterator.next()) 4587 .getValue()); 4588 } 4589 4590 subSet = descendingSubMapEntrySet.subSet(startEntry, 4591 false, endEntry, true); 4592 subSetIterator = subSet.iterator(); 4593 for (int index = startIndex - 1; subSetIterator 4594 .hasNext(); index--) { 4595 assertEquals(index, ((Entry) subSetIterator.next()) 4596 .getValue()); 4597 } 4598 4599 subSet = descendingSubMapEntrySet.subSet(startEntry, 4600 true, endEntry, false); 4601 subSetIterator = subSet.iterator(); 4602 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4603 assertEquals(index, ((Entry) subSetIterator.next()) 4604 .getValue()); 4605 } 4606 4607 subSet = descendingSubMapEntrySet.subSet(startEntry, 4608 true, endEntry, true); 4609 subSetIterator = subSet.iterator(); 4610 for (int index = startIndex; subSetIterator.hasNext(); index--) { 4611 assertEquals(index, ((Entry) subSetIterator.next()) 4612 .getValue()); 4613 } 4614 } 4615 } 4616 } 4617 } 4618 } 4619 4620 public void test_DescendingSubMapEntrySet_lower() { 4621 Set entrySet, subSet; 4622 NavigableSet descendingSubMapEntrySet; 4623 Iterator iterator; 4624 Entry entry, lowerEntry; 4625 int value; 4626 4627 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4628 if (entrySet instanceof NavigableSet) { 4629 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4630 .descendingSet(); 4631 iterator = descendingSubMapEntrySet.iterator(); 4632 while (iterator.hasNext()) { 4633 entry = (Entry) iterator.next(); 4634 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4635 value = (Integer) entry.getValue(); 4636 if (value < 108) { 4637 assertEquals(value + 1, lowerEntry.getValue()); 4638 } else { 4639 assertNull(lowerEntry); 4640 } 4641 } 4642 4643 // System.out.println(descendingSubMapEntrySet); 4644 // System.out.println(tm); 4645 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4646 .iterator().next(); 4647 // System.out.println("o:" + afterEnd); 4648 Object x = descendingSubMapEntrySet.lower(afterEnd); 4649 // System.out.println("x:" + x); 4650 assertNull(x); 4651 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4652 .iterator().next(); 4653 // System.out.println("before: " + beforeStart); 4654 Object y = descendingSubMapEntrySet.lower(beforeStart); 4655 // System.out.println("y: " + y); 4656 assertNotNull(y); 4657 assertEquals(101, (((Entry) y).getValue())); 4658 } 4659 4660 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4661 if (entrySet instanceof NavigableSet) { 4662 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4663 .descendingSet(); 4664 iterator = descendingSubMapEntrySet.iterator(); 4665 while (iterator.hasNext()) { 4666 entry = (Entry) iterator.next(); 4667 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4668 value = (Integer) entry.getValue(); 4669 if (value < 109) { 4670 assertEquals(value + 1, lowerEntry.getValue()); 4671 } else { 4672 assertNull(lowerEntry); 4673 } 4674 } 4675 } 4676 4677 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4678 if (entrySet instanceof NavigableSet) { 4679 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4680 .descendingSet(); 4681 iterator = descendingSubMapEntrySet.iterator(); 4682 while (iterator.hasNext()) { 4683 entry = (Entry) iterator.next(); 4684 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4685 value = (Integer) entry.getValue(); 4686 if (value < 108) { 4687 assertEquals(value + 1, lowerEntry.getValue()); 4688 } else { 4689 assertNull(lowerEntry); 4690 } 4691 } 4692 } 4693 4694 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4695 if (entrySet instanceof NavigableSet) { 4696 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4697 .descendingSet(); 4698 iterator = descendingSubMapEntrySet.iterator(); 4699 while (iterator.hasNext()) { 4700 entry = (Entry) iterator.next(); 4701 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4702 value = (Integer) entry.getValue(); 4703 if (value < 109) { 4704 assertEquals(value + 1, lowerEntry.getValue()); 4705 } else { 4706 assertNull(lowerEntry); 4707 } 4708 } 4709 } 4710 4711 String endKey = new Integer(2).toString(); 4712 entrySet = tm.headMap(endKey, true).entrySet(); 4713 if (entrySet instanceof NavigableSet) { 4714 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4715 .descendingSet(); 4716 iterator = descendingSubMapEntrySet.iterator(); 4717 iterator.next();// 2 4718 iterator.next();// 199 4719 entry = (Entry) iterator.next();// 198 4720 lowerEntry = (Entry) descendingSubMapEntrySet.lower(entry); 4721 assertEquals(199, lowerEntry.getValue()); 4722 } 4723 } 4724 4725 public void test_DescendingSubMapEntrySet_higher() { 4726 Set entrySet, subSet; 4727 NavigableSet descendingSubMapEntrySet; 4728 Iterator iterator; 4729 Entry entry, higherEntry; 4730 int value; 4731 4732 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4733 if (entrySet instanceof NavigableSet) { 4734 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4735 .descendingSet(); 4736 iterator = descendingSubMapEntrySet.iterator(); 4737 while (iterator.hasNext()) { 4738 entry = (Entry) iterator.next(); 4739 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4740 value = (Integer) entry.getValue(); 4741 if (value > 101) { 4742 assertEquals(value - 1, higherEntry.getValue()); 4743 } else { 4744 assertNull(higherEntry); 4745 } 4746 } 4747 4748 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4749 .iterator().next(); 4750 Object x = descendingSubMapEntrySet.higher(afterEnd); 4751 assertNotNull(x); 4752 assertEquals(108, ((Entry) x).getValue()); 4753 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4754 .iterator().next(); 4755 Object y = descendingSubMapEntrySet.higher(beforeStart); 4756 assertNull(y); 4757 } 4758 4759 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4760 if (entrySet instanceof NavigableSet) { 4761 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4762 .descendingSet(); 4763 iterator = descendingSubMapEntrySet.iterator(); 4764 while (iterator.hasNext()) { 4765 entry = (Entry) iterator.next(); 4766 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4767 value = (Integer) entry.getValue(); 4768 if (value > 101) { 4769 assertEquals(value - 1, higherEntry.getValue()); 4770 } else { 4771 assertNull(higherEntry); 4772 } 4773 } 4774 } 4775 4776 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4777 if (entrySet instanceof NavigableSet) { 4778 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4779 .descendingSet(); 4780 iterator = descendingSubMapEntrySet.iterator(); 4781 while (iterator.hasNext()) { 4782 entry = (Entry) iterator.next(); 4783 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4784 value = (Integer) entry.getValue(); 4785 if (value > 100) { 4786 assertEquals(value - 1, higherEntry.getValue()); 4787 } else { 4788 assertNull(higherEntry); 4789 } 4790 } 4791 } 4792 4793 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4794 if (entrySet instanceof NavigableSet) { 4795 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4796 .descendingSet(); 4797 iterator = descendingSubMapEntrySet.iterator(); 4798 while (iterator.hasNext()) { 4799 entry = (Entry) iterator.next(); 4800 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4801 value = (Integer) entry.getValue(); 4802 if (value > 100) { 4803 assertEquals(value - 1, higherEntry.getValue()); 4804 } else { 4805 assertNull(higherEntry); 4806 } 4807 } 4808 } 4809 4810 String endKey = new Integer(2).toString(); 4811 entrySet = tm.headMap(endKey, true).entrySet(); 4812 if (entrySet instanceof NavigableSet) { 4813 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4814 .descendingSet(); 4815 iterator = descendingSubMapEntrySet.iterator(); 4816 iterator.next();// 2 4817 iterator.next();// 199 4818 entry = (Entry) iterator.next();// 198 4819 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4820 assertEquals(197, higherEntry.getValue()); 4821 } 4822 4823 // With Comparator 4824 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 4825 if (entrySet instanceof NavigableSet) { 4826 descendingSubMapEntrySet = ((NavigableSet) entrySet) 4827 .descendingSet(); 4828 iterator = descendingSubMapEntrySet.iterator(); 4829 while (iterator.hasNext()) { 4830 entry = (Entry) iterator.next(); 4831 higherEntry = (Entry) descendingSubMapEntrySet.higher(entry); 4832 value = (Integer) entry.getValue(); 4833 if (value > 101) { 4834 assertEquals(value - 1, higherEntry.getValue()); 4835 } else { 4836 assertNull(higherEntry); 4837 } 4838 } 4839 4840 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4841 .iterator().next(); 4842 Object x = descendingSubMapEntrySet.higher(afterEnd); 4843 assertNotNull(x); 4844 assertEquals(108, ((Entry) x).getValue()); 4845 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4846 .iterator().next(); 4847 Object y = descendingSubMapEntrySet.higher(beforeStart); 4848 assertNull(y); 4849 } 4850 } 4851 4852 public void test_DescendingSubMapEntrySet_ceiling() { 4853 Set entrySet; 4854 NavigableSet ascendingSubMapEntrySet, descendingSet; 4855 Entry entry; 4856 Entry[] entryArray; 4857 4858 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4859 if (entrySet instanceof NavigableSet) { 4860 ascendingSubMapEntrySet = (NavigableSet) entrySet; 4861 descendingSet = ascendingSubMapEntrySet.descendingSet(); 4862 try { 4863 descendingSet.ceiling(null); 4864 fail("should throw NPE"); 4865 } catch (NullPointerException e) { 4866 // Expected 4867 } 4868 4869 entryArray = (Entry[]) descendingSet 4870 .toArray(new Entry[descendingSet.size()]); 4871 for (int i = 0, j = 108; i < entryArray.length; i++) { 4872 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4873 assertEquals(j - i, entry.getValue()); 4874 } 4875 4876 // System.out.println(descendingSet); 4877 // System.out.println(tm); 4878 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4879 .iterator().next(); 4880 // System.out.println("o:" + afterEnd);//110 4881 Object x = descendingSet.ceiling(afterEnd); 4882 assertNotNull(x); 4883 // System.out.println("x:" + x); 4884 assertEquals(108, ((Entry) x).getValue()); 4885 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 4886 .iterator().next(); 4887 // System.out.println("before: " + beforeStart);//0 4888 Object y = descendingSet.ceiling(beforeStart); 4889 assertNull(y); 4890 } 4891 4892 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 4893 if (entrySet instanceof NavigableSet) { 4894 ascendingSubMapEntrySet = (NavigableSet) entrySet; 4895 descendingSet = ascendingSubMapEntrySet.descendingSet(); 4896 try { 4897 descendingSet.ceiling(null); 4898 fail("should throw NPE"); 4899 } catch (NullPointerException e) { 4900 // Expected 4901 } 4902 4903 entryArray = (Entry[]) descendingSet 4904 .toArray(new Entry[descendingSet.size()]); 4905 for (int i = 0, j = 109; i < entryArray.length; i++) { 4906 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4907 assertEquals(j - i, entry.getValue()); 4908 } 4909 } 4910 4911 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 4912 if (entrySet instanceof NavigableSet) { 4913 ascendingSubMapEntrySet = (NavigableSet) entrySet; 4914 descendingSet = ascendingSubMapEntrySet.descendingSet(); 4915 try { 4916 descendingSet.ceiling(null); 4917 fail("should throw NPE"); 4918 } catch (NullPointerException e) { 4919 // Expected 4920 } 4921 4922 entryArray = (Entry[]) descendingSet 4923 .toArray(new Entry[descendingSet.size()]); 4924 for (int i = 0, j = 108; i < entryArray.length; i++) { 4925 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4926 assertEquals(j - i, entry.getValue()); 4927 } 4928 } 4929 4930 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 4931 if (entrySet instanceof NavigableSet) { 4932 descendingSet = ((NavigableSet) entrySet).descendingSet(); 4933 try { 4934 descendingSet.ceiling(null); 4935 fail("should throw NPE"); 4936 } catch (NullPointerException e) { 4937 // Expected 4938 } 4939 4940 entryArray = (Entry[]) descendingSet 4941 .toArray(new Entry[descendingSet.size()]); 4942 for (int i = 0, j = 109; i < entryArray.length; i++) { 4943 entry = (Entry) descendingSet.ceiling(entryArray[i]); 4944 assertEquals(j - i, entry.getValue()); 4945 } 4946 } 4947 4948 String endKey = new Integer(2).toString(); 4949 entrySet = tm.headMap(endKey, true).entrySet(); 4950 if (entrySet instanceof NavigableSet) { 4951 descendingSet = ((NavigableSet) entrySet).descendingSet(); 4952 try { 4953 descendingSet.ceiling(null); 4954 fail("should throw NPE"); 4955 } catch (NullPointerException e) { 4956 // Expected 4957 } 4958 4959 Iterator iterator = descendingSet.iterator(); 4960 Entry ceilingEntry; 4961 while (iterator.hasNext()) { 4962 entry = (Entry) iterator.next(); 4963 ceilingEntry = (Entry) descendingSet.ceiling(entry); 4964 assertEquals(entry, ceilingEntry); 4965 } 4966 } 4967 4968 } 4969 4970 public void test_DescendingSubMapEntrySet_floor() { 4971 Set entrySet; 4972 NavigableSet ascendingSubMapEntrySet, descendingSet; 4973 Entry entry; 4974 Entry[] entryArray; 4975 4976 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 4977 if (entrySet instanceof NavigableSet) { 4978 ascendingSubMapEntrySet = (NavigableSet) entrySet; 4979 descendingSet = ascendingSubMapEntrySet.descendingSet(); 4980 try { 4981 descendingSet.floor(null); 4982 fail("should throw NPE"); 4983 } catch (NullPointerException e) { 4984 // Expected 4985 } 4986 4987 entryArray = (Entry[]) descendingSet 4988 .toArray(new Entry[descendingSet.size()]); 4989 for (int i = 0, j = 108; i < entryArray.length; i++) { 4990 entry = (Entry) descendingSet.floor(entryArray[i]); 4991 assertEquals(j - i, entry.getValue()); 4992 } 4993 4994 Object afterEnd = this.subMap_default_afterEnd_109.entrySet() 4995 .iterator().next(); 4996 Object x = descendingSet.floor(afterEnd); 4997 assertNull(x); 4998 4999 Object beforeStart = this.subMap_default_beforeStart_100.entrySet() 5000 .iterator().next(); 5001 Object y = descendingSet.floor(beforeStart); 5002 assertNotNull(y); 5003 assertEquals(101, (((Entry) y).getValue())); 5004 } 5005 5006 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 5007 if (entrySet instanceof NavigableSet) { 5008 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5009 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5010 try { 5011 descendingSet.floor(null); 5012 fail("should throw NPE"); 5013 } catch (NullPointerException e) { 5014 // Expected 5015 } 5016 5017 entryArray = (Entry[]) descendingSet 5018 .toArray(new Entry[descendingSet.size()]); 5019 for (int i = 0, j = 109; i < entryArray.length; i++) { 5020 entry = (Entry) descendingSet.floor(entryArray[i]); 5021 assertEquals(j - i, entry.getValue()); 5022 } 5023 } 5024 5025 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 5026 if (entrySet instanceof NavigableSet) { 5027 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5028 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5029 try { 5030 descendingSet.floor(null); 5031 fail("should throw NPE"); 5032 } catch (NullPointerException e) { 5033 // Expected 5034 } 5035 5036 entryArray = (Entry[]) descendingSet 5037 .toArray(new Entry[descendingSet.size()]); 5038 for (int i = 0, j = 108; i < entryArray.length; i++) { 5039 entry = (Entry) descendingSet.floor(entryArray[i]); 5040 assertEquals(j - i, entry.getValue()); 5041 } 5042 } 5043 5044 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 5045 if (entrySet instanceof NavigableSet) { 5046 descendingSet = ((NavigableSet) entrySet).descendingSet(); 5047 try { 5048 descendingSet.floor(null); 5049 fail("should throw NPE"); 5050 } catch (NullPointerException e) { 5051 // Expected 5052 } 5053 5054 entryArray = (Entry[]) descendingSet 5055 .toArray(new Entry[descendingSet.size()]); 5056 for (int i = 0, j = 109; i < entryArray.length; i++) { 5057 entry = (Entry) descendingSet.floor(entryArray[i]); 5058 assertEquals(j - i, entry.getValue()); 5059 } 5060 } 5061 5062 String endKey = new Integer(2).toString(); 5063 entrySet = tm.headMap(endKey, true).entrySet(); 5064 if (entrySet instanceof NavigableSet) { 5065 descendingSet = ((NavigableSet) entrySet).descendingSet(); 5066 5067 Iterator iterator = descendingSet.iterator(); 5068 Entry floorEntry; 5069 while (iterator.hasNext()) { 5070 entry = (Entry) iterator.next(); 5071 floorEntry = (Entry) descendingSet.floor(entry); 5072 assertEquals(entry, floorEntry); 5073 } 5074 } 5075 5076 // With Comparator 5077 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 5078 if (entrySet instanceof NavigableSet) { 5079 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5080 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5081 try { 5082 descendingSet.floor(null); 5083 fail("should throw NPE"); 5084 } catch (NullPointerException e) { 5085 // Expected 5086 } 5087 5088 entryArray = (Entry[]) descendingSet 5089 .toArray(new Entry[descendingSet.size()]); 5090 for (int i = 0, j = 108; i < entryArray.length; i++) { 5091 entry = (Entry) descendingSet.floor(entryArray[i]); 5092 assertEquals(j - i, entry.getValue()); 5093 } 5094 } 5095 5096 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 5097 if (entrySet instanceof NavigableSet) { 5098 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5099 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5100 try { 5101 descendingSet.floor(null); 5102 fail("should throw NPE"); 5103 } catch (NullPointerException e) { 5104 // Expected 5105 } 5106 5107 entryArray = (Entry[]) descendingSet 5108 .toArray(new Entry[descendingSet.size()]); 5109 for (int i = 0, j = 109; i < entryArray.length; i++) { 5110 entry = (Entry) descendingSet.floor(entryArray[i]); 5111 assertEquals(j - i, entry.getValue()); 5112 } 5113 } 5114 5115 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 5116 if (entrySet instanceof NavigableSet) { 5117 ascendingSubMapEntrySet = (NavigableSet) entrySet; 5118 descendingSet = ascendingSubMapEntrySet.descendingSet(); 5119 try { 5120 descendingSet.floor(null); 5121 fail("should throw NPE"); 5122 } catch (NullPointerException e) { 5123 // Expected 5124 } 5125 5126 entryArray = (Entry[]) descendingSet 5127 .toArray(new Entry[descendingSet.size()]); 5128 for (int i = 0, j = 108; i < entryArray.length; i++) { 5129 entry = (Entry) descendingSet.floor(entryArray[i]); 5130 assertEquals(j - i, entry.getValue()); 5131 } 5132 } 5133 5134 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 5135 if (entrySet instanceof NavigableSet) { 5136 descendingSet = ((NavigableSet) entrySet).descendingSet(); 5137 try { 5138 descendingSet.floor(null); 5139 fail("should throw NPE"); 5140 } catch (NullPointerException e) { 5141 // Expected 5142 } 5143 5144 entryArray = (Entry[]) descendingSet 5145 .toArray(new Entry[descendingSet.size()]); 5146 for (int i = 0, j = 109; i < entryArray.length; i++) { 5147 entry = (Entry) descendingSet.floor(entryArray[i]); 5148 assertEquals(j - i, entry.getValue()); 5149 } 5150 } 5151 } 5152 5153 public void test_DescendingSubMapKeySet_comparator() { 5154 NavigableSet keySet, descendingKeySet; 5155 Comparator comparator; 5156 String[] keyArray; 5157 Integer value1, value2; 5158 5159 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 5160 assertNull(keySet.comparator()); 5161 descendingKeySet = keySet.descendingSet(); 5162 comparator = descendingKeySet.comparator(); 5163 assertNotNull(comparator); 5164 keyArray = (String[]) descendingKeySet 5165 .toArray(new String[descendingKeySet.size()]); 5166 for (int i = 1; i < keyArray.length; i++) { 5167 value1 = Integer.valueOf(keyArray[i - 1]); 5168 value2 = Integer.valueOf(keyArray[i]); 5169 assertTrue(value1 > value2); 5170 assertTrue(comparator.compare(value1, value2) < 0); 5171 } 5172 5173 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 5174 assertNull(keySet.comparator()); 5175 descendingKeySet = keySet.descendingSet(); 5176 comparator = descendingKeySet.comparator(); 5177 assertNotNull(comparator); 5178 keyArray = (String[]) descendingKeySet 5179 .toArray(new String[descendingKeySet.size()]); 5180 for (int i = 1; i < keyArray.length; i++) { 5181 value1 = Integer.valueOf(keyArray[i - 1]); 5182 value2 = Integer.valueOf(keyArray[i]); 5183 assertTrue(value1 > value2); 5184 assertTrue(comparator.compare(value1, value2) < 0); 5185 } 5186 5187 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 5188 assertNull(keySet.comparator()); 5189 descendingKeySet = keySet.descendingSet(); 5190 comparator = descendingKeySet.comparator(); 5191 assertNotNull(comparator); 5192 keyArray = (String[]) descendingKeySet 5193 .toArray(new String[descendingKeySet.size()]); 5194 for (int i = 1; i < keyArray.length; i++) { 5195 value1 = Integer.valueOf(keyArray[i - 1]); 5196 value2 = Integer.valueOf(keyArray[i]); 5197 assertTrue(value1 > value2); 5198 assertTrue(comparator.compare(value1, value2) < 0); 5199 } 5200 5201 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 5202 assertNull(keySet.comparator()); 5203 descendingKeySet = keySet.descendingSet(); 5204 comparator = descendingKeySet.comparator(); 5205 assertNotNull(comparator); 5206 keyArray = (String[]) descendingKeySet 5207 .toArray(new String[descendingKeySet.size()]); 5208 for (int i = 1; i < keyArray.length; i++) { 5209 value1 = Integer.valueOf(keyArray[i - 1]); 5210 value2 = Integer.valueOf(keyArray[i]); 5211 assertTrue(value1 > value2); 5212 assertTrue(comparator.compare(value1, value2) < 0); 5213 } 5214 5215 String endKey = new Integer(2).toString(); 5216 keySet = tm.headMap(endKey, true).navigableKeySet(); 5217 assertNull(keySet.comparator()); 5218 descendingKeySet = keySet.descendingSet(); 5219 assertNotNull(descendingKeySet.comparator()); 5220 } 5221 5222 public void test_AscendingSubMapKeySet_first() { 5223 NavigableSet keySet; 5224 String firstKey1 = new Integer(100).toString(); 5225 String firstKey2 = new Integer(101).toString(); 5226 5227 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 5228 assertEquals(firstKey2, keySet.first()); 5229 5230 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 5231 assertEquals(firstKey2, keySet.first()); 5232 5233 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 5234 assertEquals(firstKey1, keySet.first()); 5235 5236 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 5237 assertEquals(firstKey1, keySet.first()); 5238 } 5239 5240 public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endExcluded() { 5241 NavigableSet keySet = navigableMap_startExcluded_endExcluded 5242 .navigableKeySet(); 5243 NavigableSet descendingKeySet = keySet.descendingSet(); 5244 Iterator iterator = descendingKeySet.iterator(); 5245 assertEquals(8, keySet.size()); 5246 for (int value = 101; value < 109; value++) { 5247 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5248 } 5249 assertEquals(0, keySet.size()); 5250 assertNull(keySet.pollLast()); 5251 } 5252 5253 public void test_DescendingSubMapKeySet_pollFirst_startExcluded_endIncluded() { 5254 NavigableSet keySet = navigableMap_startExcluded_endIncluded 5255 .navigableKeySet(); 5256 NavigableSet descendingKeySet = keySet.descendingSet(); 5257 Iterator iterator = descendingKeySet.iterator(); 5258 assertEquals(9, keySet.size()); 5259 for (int value = 101; value < 110; value++) { 5260 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5261 } 5262 assertEquals(0, keySet.size()); 5263 assertNull(keySet.pollLast()); 5264 } 5265 5266 public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endExcluded() { 5267 NavigableSet keySet = navigableMap_startIncluded_endExcluded 5268 .navigableKeySet(); 5269 NavigableSet descendingKeySet = keySet.descendingSet(); 5270 Iterator iterator = descendingKeySet.iterator(); 5271 assertEquals(9, keySet.size()); 5272 for (int value = 100; value < 109; value++) { 5273 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5274 } 5275 assertEquals(0, keySet.size()); 5276 assertNull(keySet.pollLast()); 5277 } 5278 5279 public void test_DescendingSubMapKeySet_pollFirst_startIncluded_endIncluded() { 5280 NavigableSet keySet = navigableMap_startIncluded_endIncluded 5281 .navigableKeySet(); 5282 NavigableSet descendingKeySet = keySet.descendingSet(); 5283 Iterator iterator = descendingKeySet.iterator(); 5284 assertEquals(10, keySet.size()); 5285 for (int value = 100; value < 110; value++) { 5286 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 5287 } 5288 assertEquals(0, keySet.size()); 5289 assertNull(keySet.pollLast()); 5290 } 5291 5292 public void test_DescendingSubMapKeySet_pollFirst() { 5293 String endKey = new Integer(2).toString(); 5294 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 5295 NavigableSet descendingKeySet = keySet.descendingSet(); 5296 assertEquals(endKey, descendingKeySet.pollFirst()); 5297 } 5298 5299 public void test_DescendingSubMapKeySet_pollLast_startExcluded_endExcluded() { 5300 NavigableSet keySet = navigableMap_startExcluded_endExcluded 5301 .navigableKeySet(); 5302 NavigableSet descendingKeySet = keySet.descendingSet(); 5303 Iterator iterator = descendingKeySet.iterator(); 5304 assertEquals(8, keySet.size()); 5305 for (int value = 108; value > 100; value--) { 5306 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5307 } 5308 assertEquals(0, keySet.size()); 5309 assertNull(keySet.pollLast()); 5310 } 5311 5312 public void test_DescendingSubMapKeySet_pollLast_startExcluded_endIncluded() { 5313 NavigableSet keySet = navigableMap_startExcluded_endIncluded 5314 .navigableKeySet(); 5315 NavigableSet descendingKeySet = keySet.descendingSet(); 5316 Iterator iterator = descendingKeySet.iterator(); 5317 assertEquals(9, keySet.size()); 5318 for (int value = 109; value > 100; value--) { 5319 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5320 } 5321 assertEquals(0, keySet.size()); 5322 assertNull(keySet.pollLast()); 5323 } 5324 5325 public void test_DescendingSubMapKeySet_pollLast_startIncluded_endExcluded() { 5326 NavigableSet keySet = navigableMap_startIncluded_endExcluded 5327 .navigableKeySet(); 5328 NavigableSet descendingKeySet = keySet.descendingSet(); 5329 Iterator iterator = descendingKeySet.iterator(); 5330 assertEquals(9, keySet.size()); 5331 for (int value = 108; value > 99; value--) { 5332 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5333 } 5334 assertEquals(0, keySet.size()); 5335 assertNull(keySet.pollLast()); 5336 } 5337 5338 public void test_DescendingSubMapKeySet_pollLast_startIncluded_endIncluded() { 5339 NavigableSet keySet = navigableMap_startIncluded_endIncluded 5340 .navigableKeySet(); 5341 NavigableSet descendingKeySet = keySet.descendingSet(); 5342 Iterator iterator = descendingKeySet.iterator(); 5343 assertEquals(10, keySet.size()); 5344 for (int value = 109; value > 99; value--) { 5345 assertEquals(new Integer(value).toString(), keySet.pollLast()); 5346 } 5347 assertEquals(0, keySet.size()); 5348 assertNull(keySet.pollLast()); 5349 } 5350 5351 public void test_DescendingSubMapKeySet_pollLast() { 5352 String endKey = new Integer(2).toString(); 5353 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 5354 NavigableSet descendingKeySet = keySet.descendingSet(); 5355 assertEquals(new Integer(0).toString(), descendingKeySet.pollLast()); 5356 } 5357 5358 public void test_DescendingSubMapKeySet_headSet() { 5359 NavigableSet keySet, descendingKeySet; 5360 SortedSet headSet; 5361 String endKey, key; 5362 Iterator iterator; 5363 int index; 5364 5365 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 5366 descendingKeySet = keySet.descendingSet(); 5367 endKey = new Integer(99).toString(); 5368 try { 5369 descendingKeySet.headSet(endKey); 5370 fail("should throw IllegalArgumentException"); 5371 } catch (IllegalArgumentException e) { 5372 // Expected 5373 } 5374 try { 5375 descendingKeySet.headSet(endKey, false); 5376 fail("should throw IllegalArgumentException"); 5377 } catch (IllegalArgumentException e) { 5378 // Expected 5379 } 5380 try { 5381 descendingKeySet.headSet(endKey, true); 5382 fail("should throw IllegalArgumentException"); 5383 } catch (IllegalArgumentException e) { 5384 // Expected 5385 } 5386 5387 endKey = new Integer(100).toString(); 5388 headSet = descendingKeySet.headSet(endKey); 5389 iterator = headSet.iterator(); 5390 for (index = 108; iterator.hasNext(); index--) { 5391 key = (String) iterator.next(); 5392 assertEquals(new Integer(index).toString(), key); 5393 } 5394 assertEquals(100, index); 5395 5396 headSet = descendingKeySet.headSet(endKey, false); 5397 iterator = headSet.iterator(); 5398 for (index = 108; iterator.hasNext(); index--) { 5399 key = (String) iterator.next(); 5400 assertEquals(new Integer(index).toString(), key); 5401 } 5402 assertEquals(100, index); 5403 5404 try { 5405 descendingKeySet.headSet(endKey, true); 5406 fail("should throw IllegalArgumentException"); 5407 } catch (IllegalArgumentException e) { 5408 // Expected 5409 } 5410 5411 endKey = new Integer(101).toString(); 5412 headSet = descendingKeySet.headSet(endKey); 5413 iterator = headSet.iterator(); 5414 for (index = 108; iterator.hasNext(); index--) { 5415 key = (String) iterator.next(); 5416 assertEquals(new Integer(index).toString(), key); 5417 } 5418 assertEquals(101, index); 5419 5420 headSet = descendingKeySet.headSet(endKey, false); 5421 iterator = headSet.iterator(); 5422 for (index = 108; iterator.hasNext(); index--) { 5423 key = (String) iterator.next(); 5424 assertEquals(new Integer(index).toString(), key); 5425 } 5426 assertEquals(101, index); 5427 5428 headSet = descendingKeySet.headSet(endKey, true); 5429 iterator = headSet.iterator(); 5430 for (index = 108; iterator.hasNext(); index--) { 5431 key = (String) iterator.next(); 5432 assertEquals(new Integer(index).toString(), key); 5433 } 5434 assertEquals(100, index); 5435 5436 for (int i = 102; i < 109; i++) { 5437 endKey = new Integer(i).toString(); 5438 headSet = descendingKeySet.headSet(endKey); 5439 iterator = headSet.iterator(); 5440 int j; 5441 for (j = 108; iterator.hasNext(); j--) { 5442 key = (String) iterator.next(); 5443 assertEquals(new Integer(j).toString(), key); 5444 } 5445 assertEquals(i, j); 5446 5447 headSet = descendingKeySet.headSet(endKey, false); 5448 iterator = headSet.iterator(); 5449 for (j = 108; iterator.hasNext(); j--) { 5450 key = (String) iterator.next(); 5451 assertEquals(new Integer(j).toString(), key); 5452 } 5453 assertEquals(i, j); 5454 5455 headSet = descendingKeySet.headSet(endKey, true); 5456 iterator = headSet.iterator(); 5457 for (j = 108; iterator.hasNext(); j--) { 5458 key = (String) iterator.next(); 5459 assertEquals(new Integer(j).toString(), key); 5460 } 5461 assertEquals(i - 1, j); 5462 } 5463 5464 endKey = new Integer(109).toString(); 5465 headSet = descendingKeySet.headSet(endKey); 5466 iterator = headSet.iterator(); 5467 for (index = 108; iterator.hasNext(); index--) { 5468 key = (String) iterator.next(); 5469 assertEquals(new Integer(index).toString(), key); 5470 } 5471 assertEquals(108, index); 5472 5473 headSet = descendingKeySet.headSet(endKey, false); 5474 iterator = headSet.iterator(); 5475 for (index = 108; iterator.hasNext(); index--) { 5476 key = (String) iterator.next(); 5477 assertEquals(new Integer(index).toString(), key); 5478 } 5479 assertEquals(108, index); 5480 5481 try { 5482 descendingKeySet.headSet(endKey, true); 5483 fail("should throw IllegalArgumentException"); 5484 } catch (IllegalArgumentException e) { 5485 // Expected 5486 } 5487 5488 endKey = new Integer(110).toString(); 5489 try { 5490 descendingKeySet.headSet(endKey); 5491 fail("should throw IllegalArgumentException"); 5492 } catch (IllegalArgumentException e) { 5493 // Expected 5494 } 5495 try { 5496 descendingKeySet.headSet(endKey, true); 5497 fail("should throw IllegalArgumentException"); 5498 } catch (IllegalArgumentException e) { 5499 // Expected 5500 } 5501 try { 5502 descendingKeySet.headSet(endKey, false); 5503 fail("should throw IllegalArgumentException"); 5504 } catch (IllegalArgumentException e) { 5505 // Expected 5506 } 5507 5508 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 5509 descendingKeySet = keySet.descendingSet(); 5510 endKey = new Integer(99).toString(); 5511 try { 5512 descendingKeySet.headSet(endKey); 5513 fail("should throw IllegalArgumentException"); 5514 } catch (IllegalArgumentException e) { 5515 // Expected 5516 } 5517 try { 5518 descendingKeySet.headSet(endKey, false); 5519 fail("should throw IllegalArgumentException"); 5520 } catch (IllegalArgumentException e) { 5521 // Expected 5522 } 5523 try { 5524 descendingKeySet.headSet(endKey, true); 5525 fail("should throw IllegalArgumentException"); 5526 } catch (IllegalArgumentException e) { 5527 // Expected 5528 } 5529 5530 endKey = new Integer(100).toString(); 5531 headSet = descendingKeySet.headSet(endKey); 5532 iterator = headSet.iterator(); 5533 for (index = 109; iterator.hasNext(); index--) { 5534 key = (String) iterator.next(); 5535 assertEquals(new Integer(index).toString(), key); 5536 } 5537 assertEquals(100, index); 5538 5539 headSet = descendingKeySet.headSet(endKey, false); 5540 iterator = headSet.iterator(); 5541 for (index = 109; iterator.hasNext(); index--) { 5542 key = (String) iterator.next(); 5543 assertEquals(new Integer(index).toString(), key); 5544 } 5545 assertEquals(100, index); 5546 5547 try { 5548 descendingKeySet.headSet(endKey, true); 5549 fail("should throw IllegalArgumentException"); 5550 } catch (IllegalArgumentException e) { 5551 // Expected 5552 } 5553 5554 endKey = new Integer(101).toString(); 5555 headSet = descendingKeySet.headSet(endKey); 5556 iterator = headSet.iterator(); 5557 for (index = 109; iterator.hasNext(); index--) { 5558 key = (String) iterator.next(); 5559 assertEquals(new Integer(index).toString(), key); 5560 } 5561 assertEquals(101, index); 5562 5563 headSet = descendingKeySet.headSet(endKey, false); 5564 iterator = headSet.iterator(); 5565 for (index = 109; iterator.hasNext(); index--) { 5566 key = (String) iterator.next(); 5567 assertEquals(new Integer(index).toString(), key); 5568 } 5569 assertEquals(101, index); 5570 5571 headSet = descendingKeySet.headSet(endKey, true); 5572 iterator = headSet.iterator(); 5573 for (index = 109; iterator.hasNext(); index--) { 5574 key = (String) iterator.next(); 5575 assertEquals(new Integer(index).toString(), key); 5576 } 5577 assertEquals(100, index); 5578 5579 for (int i = 102; i < 109; i++) { 5580 endKey = new Integer(i).toString(); 5581 headSet = descendingKeySet.headSet(endKey); 5582 iterator = headSet.iterator(); 5583 int j; 5584 for (j = 109; iterator.hasNext(); j--) { 5585 key = (String) iterator.next(); 5586 assertEquals(new Integer(j).toString(), key); 5587 } 5588 assertEquals(i, j); 5589 5590 headSet = descendingKeySet.headSet(endKey, false); 5591 iterator = headSet.iterator(); 5592 for (j = 109; iterator.hasNext(); j--) { 5593 key = (String) iterator.next(); 5594 assertEquals(new Integer(j).toString(), key); 5595 } 5596 assertEquals(i, j); 5597 5598 headSet = descendingKeySet.headSet(endKey, true); 5599 iterator = headSet.iterator(); 5600 for (j = 109; iterator.hasNext(); j--) { 5601 key = (String) iterator.next(); 5602 assertEquals(new Integer(j).toString(), key); 5603 } 5604 assertEquals(i - 1, j); 5605 } 5606 5607 endKey = new Integer(109).toString(); 5608 headSet = descendingKeySet.headSet(endKey); 5609 iterator = headSet.iterator(); 5610 for (index = 109; iterator.hasNext(); index--) { 5611 key = (String) iterator.next(); 5612 assertEquals(new Integer(index).toString(), key); 5613 } 5614 assertEquals(109, index); 5615 5616 headSet = descendingKeySet.headSet(endKey, false); 5617 iterator = headSet.iterator(); 5618 for (index = 109; iterator.hasNext(); index--) { 5619 key = (String) iterator.next(); 5620 assertEquals(new Integer(index).toString(), key); 5621 } 5622 assertEquals(109, index); 5623 5624 headSet = descendingKeySet.headSet(endKey, true); 5625 iterator = headSet.iterator(); 5626 for (index = 109; iterator.hasNext(); index--) { 5627 key = (String) iterator.next(); 5628 assertEquals(new Integer(index).toString(), key); 5629 } 5630 assertEquals(108, index); 5631 5632 endKey = new Integer(110).toString(); 5633 try { 5634 descendingKeySet.headSet(endKey); 5635 fail("should throw IllegalArgumentException"); 5636 } catch (IllegalArgumentException e) { 5637 // Expected 5638 } 5639 try { 5640 descendingKeySet.headSet(endKey, true); 5641 fail("should throw IllegalArgumentException"); 5642 } catch (IllegalArgumentException e) { 5643 // Expected 5644 } 5645 try { 5646 descendingKeySet.headSet(endKey, false); 5647 fail("should throw IllegalArgumentException"); 5648 } catch (IllegalArgumentException e) { 5649 // Expected 5650 } 5651 5652 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 5653 descendingKeySet = keySet.descendingSet(); 5654 endKey = new Integer(99).toString(); 5655 try { 5656 descendingKeySet.headSet(endKey); 5657 fail("should throw IllegalArgumentException"); 5658 } catch (IllegalArgumentException e) { 5659 // Expected 5660 } 5661 try { 5662 descendingKeySet.headSet(endKey, false); 5663 fail("should throw IllegalArgumentException"); 5664 } catch (IllegalArgumentException e) { 5665 // Expected 5666 } 5667 try { 5668 descendingKeySet.headSet(endKey, true); 5669 fail("should throw IllegalArgumentException"); 5670 } catch (IllegalArgumentException e) { 5671 // Expected 5672 } 5673 5674 endKey = new Integer(100).toString(); 5675 headSet = descendingKeySet.headSet(endKey); 5676 iterator = headSet.iterator(); 5677 for (index = 108; iterator.hasNext(); index--) { 5678 key = (String) iterator.next(); 5679 assertEquals(new Integer(index).toString(), key); 5680 } 5681 assertEquals(100, index); 5682 5683 headSet = descendingKeySet.headSet(endKey, false); 5684 iterator = headSet.iterator(); 5685 for (index = 108; iterator.hasNext(); index--) { 5686 key = (String) iterator.next(); 5687 assertEquals(new Integer(index).toString(), key); 5688 } 5689 assertEquals(100, index); 5690 5691 headSet = descendingKeySet.headSet(endKey, true); 5692 iterator = headSet.iterator(); 5693 for (index = 108; iterator.hasNext(); index--) { 5694 key = (String) iterator.next(); 5695 assertEquals(new Integer(index).toString(), key); 5696 } 5697 assertEquals(99, index); 5698 5699 endKey = new Integer(101).toString(); 5700 headSet = descendingKeySet.headSet(endKey); 5701 iterator = headSet.iterator(); 5702 for (index = 108; iterator.hasNext(); index--) { 5703 key = (String) iterator.next(); 5704 assertEquals(new Integer(index).toString(), key); 5705 } 5706 assertEquals(101, index); 5707 5708 headSet = descendingKeySet.headSet(endKey, false); 5709 iterator = headSet.iterator(); 5710 for (index = 108; iterator.hasNext(); index--) { 5711 key = (String) iterator.next(); 5712 assertEquals(new Integer(index).toString(), key); 5713 } 5714 assertEquals(101, index); 5715 5716 headSet = descendingKeySet.headSet(endKey, true); 5717 iterator = headSet.iterator(); 5718 for (index = 108; iterator.hasNext(); index--) { 5719 key = (String) iterator.next(); 5720 assertEquals(new Integer(index).toString(), key); 5721 } 5722 assertEquals(100, index); 5723 5724 for (int i = 102; i < 109; i++) { 5725 endKey = new Integer(i).toString(); 5726 headSet = descendingKeySet.headSet(endKey); 5727 iterator = headSet.iterator(); 5728 int j; 5729 for (j = 108; iterator.hasNext(); j--) { 5730 key = (String) iterator.next(); 5731 assertEquals(new Integer(j).toString(), key); 5732 } 5733 assertEquals(i, j); 5734 5735 headSet = descendingKeySet.headSet(endKey, false); 5736 iterator = headSet.iterator(); 5737 for (j = 108; iterator.hasNext(); j--) { 5738 key = (String) iterator.next(); 5739 assertEquals(new Integer(j).toString(), key); 5740 } 5741 assertEquals(i, j); 5742 5743 headSet = descendingKeySet.headSet(endKey, true); 5744 iterator = headSet.iterator(); 5745 for (j = 108; iterator.hasNext(); j--) { 5746 key = (String) iterator.next(); 5747 assertEquals(new Integer(j).toString(), key); 5748 } 5749 assertEquals(i - 1, j); 5750 } 5751 5752 endKey = new Integer(109).toString(); 5753 headSet = descendingKeySet.headSet(endKey); 5754 iterator = headSet.iterator(); 5755 for (index = 108; iterator.hasNext(); index--) { 5756 key = (String) iterator.next(); 5757 assertEquals(new Integer(index).toString(), key); 5758 } 5759 assertEquals(108, index); 5760 5761 headSet = descendingKeySet.headSet(endKey, false); 5762 iterator = headSet.iterator(); 5763 for (index = 108; iterator.hasNext(); index--) { 5764 key = (String) iterator.next(); 5765 assertEquals(new Integer(index).toString(), key); 5766 } 5767 assertEquals(108, index); 5768 5769 try { 5770 descendingKeySet.headSet(endKey, true); 5771 fail("should throw IllegalArgumentException"); 5772 } catch (IllegalArgumentException e) { 5773 // Expected 5774 } 5775 5776 endKey = new Integer(110).toString(); 5777 try { 5778 descendingKeySet.headSet(endKey); 5779 fail("should throw IllegalArgumentException"); 5780 } catch (IllegalArgumentException e) { 5781 // Expected 5782 } 5783 try { 5784 descendingKeySet.headSet(endKey, true); 5785 fail("should throw IllegalArgumentException"); 5786 } catch (IllegalArgumentException e) { 5787 // Expected 5788 } 5789 try { 5790 descendingKeySet.headSet(endKey, false); 5791 fail("should throw IllegalArgumentException"); 5792 } catch (IllegalArgumentException e) { 5793 // Expected 5794 } 5795 5796 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 5797 descendingKeySet = keySet.descendingSet(); 5798 endKey = new Integer(99).toString(); 5799 try { 5800 descendingKeySet.headSet(endKey); 5801 fail("should throw IllegalArgumentException"); 5802 } catch (IllegalArgumentException e) { 5803 // Expected 5804 } 5805 try { 5806 descendingKeySet.headSet(endKey, false); 5807 fail("should throw IllegalArgumentException"); 5808 } catch (IllegalArgumentException e) { 5809 // Expected 5810 } 5811 try { 5812 descendingKeySet.headSet(endKey, true); 5813 fail("should throw IllegalArgumentException"); 5814 } catch (IllegalArgumentException e) { 5815 // Expected 5816 } 5817 5818 endKey = new Integer(100).toString(); 5819 headSet = descendingKeySet.headSet(endKey); 5820 iterator = headSet.iterator(); 5821 for (index = 109; iterator.hasNext(); index--) { 5822 key = (String) iterator.next(); 5823 assertEquals(new Integer(index).toString(), key); 5824 } 5825 assertEquals(100, index); 5826 5827 headSet = descendingKeySet.headSet(endKey, false); 5828 iterator = headSet.iterator(); 5829 for (index = 109; iterator.hasNext(); index--) { 5830 key = (String) iterator.next(); 5831 assertEquals(new Integer(index).toString(), key); 5832 } 5833 assertEquals(100, index); 5834 5835 headSet = descendingKeySet.headSet(endKey, true); 5836 iterator = headSet.iterator(); 5837 for (index = 109; iterator.hasNext(); index--) { 5838 key = (String) iterator.next(); 5839 assertEquals(new Integer(index).toString(), key); 5840 } 5841 assertEquals(99, index); 5842 5843 endKey = new Integer(101).toString(); 5844 headSet = descendingKeySet.headSet(endKey); 5845 iterator = headSet.iterator(); 5846 for (index = 109; iterator.hasNext(); index--) { 5847 key = (String) iterator.next(); 5848 assertEquals(new Integer(index).toString(), key); 5849 } 5850 assertEquals(101, index); 5851 5852 headSet = descendingKeySet.headSet(endKey, false); 5853 iterator = headSet.iterator(); 5854 for (index = 109; iterator.hasNext(); index--) { 5855 key = (String) iterator.next(); 5856 assertEquals(new Integer(index).toString(), key); 5857 } 5858 assertEquals(101, index); 5859 5860 headSet = descendingKeySet.headSet(endKey, true); 5861 iterator = headSet.iterator(); 5862 for (index = 109; iterator.hasNext(); index--) { 5863 key = (String) iterator.next(); 5864 assertEquals(new Integer(index).toString(), key); 5865 } 5866 assertEquals(100, index); 5867 5868 for (int i = 102; i < 109; i++) { 5869 endKey = new Integer(i).toString(); 5870 headSet = descendingKeySet.headSet(endKey); 5871 iterator = headSet.iterator(); 5872 int j; 5873 for (j = 109; iterator.hasNext(); j--) { 5874 key = (String) iterator.next(); 5875 assertEquals(new Integer(j).toString(), key); 5876 } 5877 assertEquals(i, j); 5878 5879 headSet = descendingKeySet.headSet(endKey, false); 5880 iterator = headSet.iterator(); 5881 for (j = 109; iterator.hasNext(); j--) { 5882 key = (String) iterator.next(); 5883 assertEquals(new Integer(j).toString(), key); 5884 } 5885 assertEquals(i, j); 5886 5887 headSet = descendingKeySet.headSet(endKey, true); 5888 iterator = headSet.iterator(); 5889 for (j = 109; iterator.hasNext(); j--) { 5890 key = (String) iterator.next(); 5891 assertEquals(new Integer(j).toString(), key); 5892 } 5893 assertEquals(i - 1, j); 5894 } 5895 5896 endKey = new Integer(109).toString(); 5897 headSet = descendingKeySet.headSet(endKey); 5898 iterator = headSet.iterator(); 5899 for (index = 109; iterator.hasNext(); index--) { 5900 key = (String) iterator.next(); 5901 assertEquals(new Integer(index).toString(), key); 5902 } 5903 assertEquals(109, index); 5904 5905 headSet = descendingKeySet.headSet(endKey, false); 5906 iterator = headSet.iterator(); 5907 for (index = 109; iterator.hasNext(); index--) { 5908 key = (String) iterator.next(); 5909 assertEquals(new Integer(index).toString(), key); 5910 } 5911 assertEquals(109, index); 5912 5913 headSet = descendingKeySet.headSet(endKey, true); 5914 iterator = headSet.iterator(); 5915 for (index = 109; iterator.hasNext(); index--) { 5916 key = (String) iterator.next(); 5917 assertEquals(new Integer(index).toString(), key); 5918 } 5919 assertEquals(108, index); 5920 5921 endKey = new Integer(110).toString(); 5922 try { 5923 descendingKeySet.headSet(endKey); 5924 fail("should throw IllegalArgumentException"); 5925 } catch (IllegalArgumentException e) { 5926 // Expected 5927 } 5928 try { 5929 descendingKeySet.headSet(endKey, true); 5930 fail("should throw IllegalArgumentException"); 5931 } catch (IllegalArgumentException e) { 5932 // Expected 5933 } 5934 try { 5935 descendingKeySet.headSet(endKey, false); 5936 fail("should throw IllegalArgumentException"); 5937 } catch (IllegalArgumentException e) { 5938 // Expected 5939 } 5940 5941 key = new Integer(2).toString(); 5942 keySet = tm.headMap(key, true).navigableKeySet(); 5943 descendingKeySet = keySet.descendingSet(); 5944 iterator = descendingKeySet.iterator(); 5945 iterator.next(); 5946 endKey = (String) iterator.next(); 5947 5948 headSet = descendingKeySet.headSet(endKey); 5949 assertEquals(1, headSet.size()); 5950 5951 headSet = descendingKeySet.headSet(endKey, false); 5952 assertEquals(1, headSet.size()); 5953 5954 headSet = descendingKeySet.headSet(endKey, true); 5955 assertEquals(2, headSet.size()); 5956 5957 key = new Integer(2).toString(); 5958 keySet = tm.tailMap(key, true).navigableKeySet(); 5959 descendingKeySet = keySet.descendingSet(); 5960 iterator = descendingKeySet.iterator(); 5961 iterator.next(); 5962 endKey = (String) iterator.next(); 5963 headSet = descendingKeySet.headSet(endKey); 5964 assertEquals(1, headSet.size()); 5965 iterator = headSet.iterator(); 5966 assertEquals(999, Integer.parseInt((String) iterator.next())); 5967 } 5968 5969 public void test_DescendingSubMapKeySet_tailSet() { 5970 NavigableSet keySet, descendingKeySet; 5971 SortedSet tailSet; 5972 String startKey, key; 5973 Iterator iterator; 5974 int index; 5975 5976 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 5977 descendingKeySet = keySet.descendingSet(); 5978 startKey = new Integer(99).toString(); 5979 try { 5980 descendingKeySet.tailSet(startKey); 5981 fail("should throw IllegalArgumentException"); 5982 } catch (IllegalArgumentException e) { 5983 // Expected 5984 } 5985 5986 try { 5987 descendingKeySet.tailSet(startKey, true); 5988 fail("should throw IllegalArgumentException"); 5989 } catch (IllegalArgumentException e) { 5990 // Expected 5991 } 5992 5993 try { 5994 descendingKeySet.tailSet(startKey, false); 5995 fail("should throw IllegalArgumentException"); 5996 } catch (IllegalArgumentException e) { 5997 // Expected 5998 } 5999 6000 startKey = new Integer(100).toString(); 6001 try { 6002 descendingKeySet.tailSet(startKey); 6003 fail("should throw IllegalArgumentException"); 6004 } catch (IllegalArgumentException e) { 6005 // Expected 6006 } 6007 try { 6008 descendingKeySet.tailSet(startKey, true); 6009 fail("should throw IllegalArgumentException"); 6010 } catch (IllegalArgumentException e) { 6011 // Expected 6012 } 6013 tailSet = descendingKeySet.tailSet(startKey, false); 6014 assertEquals(0, tailSet.size()); 6015 6016 startKey = new Integer(101).toString(); 6017 tailSet = descendingKeySet.tailSet(startKey); 6018 iterator = tailSet.iterator(); 6019 for (index = 101; iterator.hasNext(); index--) { 6020 key = (String) iterator.next(); 6021 assertEquals(new Integer(index).toString(), key); 6022 } 6023 assertEquals(100, index); 6024 6025 tailSet = descendingKeySet.tailSet(startKey, true); 6026 iterator = tailSet.iterator(); 6027 for (index = 101; iterator.hasNext(); index--) { 6028 key = (String) iterator.next(); 6029 assertEquals(new Integer(index).toString(), key); 6030 } 6031 assertEquals(100, index); 6032 6033 tailSet = descendingKeySet.tailSet(startKey, false); 6034 iterator = tailSet.iterator(); 6035 for (index = 101; iterator.hasNext(); index--) { 6036 key = (String) iterator.next(); 6037 assertEquals(new Integer(index).toString(), key); 6038 } 6039 assertEquals(101, index); 6040 6041 for (int i = 102; i < 109; i++) { 6042 startKey = new Integer(i).toString(); 6043 6044 tailSet = descendingKeySet.tailSet(startKey); 6045 iterator = tailSet.iterator(); 6046 int j; 6047 for (j = i; iterator.hasNext(); j--) { 6048 key = (String) iterator.next(); 6049 assertEquals(new Integer(j).toString(), key); 6050 } 6051 assertEquals(100, j); 6052 6053 tailSet = descendingKeySet.tailSet(startKey, true); 6054 iterator = tailSet.iterator(); 6055 for (j = i; iterator.hasNext(); j--) { 6056 key = (String) iterator.next(); 6057 assertEquals(new Integer(j).toString(), key); 6058 } 6059 assertEquals(100, j); 6060 6061 tailSet = descendingKeySet.tailSet(startKey, false); 6062 iterator = tailSet.iterator(); 6063 for (j = i; iterator.hasNext(); j--) { 6064 key = (String) iterator.next(); 6065 assertEquals(new Integer(j - 1).toString(), key); 6066 } 6067 assertEquals(101, j); 6068 } 6069 6070 startKey = new Integer(109).toString(); 6071 try { 6072 descendingKeySet.tailSet(startKey); 6073 fail("should throw IllegalArgumentException"); 6074 } catch (IllegalArgumentException e) { 6075 // Expected 6076 } 6077 try { 6078 descendingKeySet.tailSet(startKey, true); 6079 fail("should throw IllegalArgumentException"); 6080 } catch (IllegalArgumentException e) { 6081 // Expected 6082 } 6083 tailSet = descendingKeySet.tailSet(startKey, false); 6084 iterator = tailSet.iterator(); 6085 for (index = 109; iterator.hasNext(); index--) { 6086 key = (String) iterator.next(); 6087 assertEquals(new Integer(index - 1).toString(), key); 6088 } 6089 assertEquals(101, index); 6090 6091 startKey = new Integer(110).toString(); 6092 try { 6093 descendingKeySet.tailSet(startKey); 6094 fail("should throw IllegalArgumentException"); 6095 } catch (IllegalArgumentException e) { 6096 // Expected 6097 } 6098 try { 6099 descendingKeySet.tailSet(startKey, true); 6100 fail("should throw IllegalArgumentException"); 6101 } catch (IllegalArgumentException e) { 6102 // Expected 6103 } 6104 try { 6105 descendingKeySet.tailSet(startKey, false); 6106 fail("should throw IllegalArgumentException"); 6107 } catch (IllegalArgumentException e) { 6108 // Expected 6109 } 6110 6111 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 6112 descendingKeySet = keySet.descendingSet(); 6113 startKey = new Integer(99).toString(); 6114 try { 6115 descendingKeySet.tailSet(startKey); 6116 fail("should throw IllegalArgumentException"); 6117 } catch (IllegalArgumentException e) { 6118 // Expected 6119 } 6120 6121 try { 6122 descendingKeySet.tailSet(startKey, true); 6123 fail("should throw IllegalArgumentException"); 6124 } catch (IllegalArgumentException e) { 6125 // Expected 6126 } 6127 6128 try { 6129 descendingKeySet.tailSet(startKey, false); 6130 fail("should throw IllegalArgumentException"); 6131 } catch (IllegalArgumentException e) { 6132 // Expected 6133 } 6134 6135 startKey = new Integer(100).toString(); 6136 try { 6137 descendingKeySet.tailSet(startKey); 6138 fail("should throw IllegalArgumentException"); 6139 } catch (IllegalArgumentException e) { 6140 // Expected 6141 } 6142 try { 6143 descendingKeySet.tailSet(startKey, true); 6144 fail("should throw IllegalArgumentException"); 6145 } catch (IllegalArgumentException e) { 6146 // Expected 6147 } 6148 tailSet = descendingKeySet.tailSet(startKey, false); 6149 assertEquals(0, tailSet.size()); 6150 6151 startKey = new Integer(101).toString(); 6152 tailSet = descendingKeySet.tailSet(startKey); 6153 iterator = tailSet.iterator(); 6154 for (index = 101; iterator.hasNext(); index--) { 6155 key = (String) iterator.next(); 6156 assertEquals(new Integer(index).toString(), key); 6157 } 6158 assertEquals(100, index); 6159 6160 tailSet = descendingKeySet.tailSet(startKey, true); 6161 iterator = tailSet.iterator(); 6162 for (index = 101; iterator.hasNext(); index--) { 6163 key = (String) iterator.next(); 6164 assertEquals(new Integer(index).toString(), key); 6165 } 6166 assertEquals(100, index); 6167 6168 tailSet = descendingKeySet.tailSet(startKey, false); 6169 iterator = tailSet.iterator(); 6170 for (index = 101; iterator.hasNext(); index--) { 6171 key = (String) iterator.next(); 6172 assertEquals(new Integer(index).toString(), key); 6173 } 6174 assertEquals(101, index); 6175 6176 for (int i = 102; i < 109; i++) { 6177 startKey = new Integer(i).toString(); 6178 6179 tailSet = descendingKeySet.tailSet(startKey); 6180 iterator = tailSet.iterator(); 6181 int j; 6182 for (j = i; iterator.hasNext(); j--) { 6183 key = (String) iterator.next(); 6184 assertEquals(new Integer(j).toString(), key); 6185 } 6186 assertEquals(100, j); 6187 6188 tailSet = descendingKeySet.tailSet(startKey, true); 6189 iterator = tailSet.iterator(); 6190 for (j = i; iterator.hasNext(); j--) { 6191 key = (String) iterator.next(); 6192 assertEquals(new Integer(j).toString(), key); 6193 } 6194 assertEquals(100, j); 6195 6196 tailSet = descendingKeySet.tailSet(startKey, false); 6197 iterator = tailSet.iterator(); 6198 for (j = i; iterator.hasNext(); j--) { 6199 key = (String) iterator.next(); 6200 assertEquals(new Integer(j - 1).toString(), key); 6201 } 6202 assertEquals(101, j); 6203 } 6204 6205 startKey = new Integer(109).toString(); 6206 tailSet = descendingKeySet.tailSet(startKey); 6207 iterator = tailSet.iterator(); 6208 for (index = 109; iterator.hasNext(); index--) { 6209 key = (String) iterator.next(); 6210 assertEquals(new Integer(index).toString(), key); 6211 } 6212 assertEquals(100, index); 6213 6214 tailSet = descendingKeySet.tailSet(startKey, true); 6215 iterator = tailSet.iterator(); 6216 for (index = 109; iterator.hasNext(); index--) { 6217 key = (String) iterator.next(); 6218 assertEquals(new Integer(index).toString(), key); 6219 } 6220 assertEquals(100, index); 6221 6222 tailSet = descendingKeySet.tailSet(startKey, false); 6223 iterator = tailSet.iterator(); 6224 for (index = 109; iterator.hasNext(); index--) { 6225 key = (String) iterator.next(); 6226 assertEquals(new Integer(index - 1).toString(), key); 6227 } 6228 assertEquals(101, index); 6229 6230 startKey = new Integer(110).toString(); 6231 try { 6232 descendingKeySet.tailSet(startKey); 6233 fail("should throw IllegalArgumentException"); 6234 } catch (IllegalArgumentException e) { 6235 // Expected 6236 } 6237 try { 6238 descendingKeySet.tailSet(startKey, true); 6239 fail("should throw IllegalArgumentException"); 6240 } catch (IllegalArgumentException e) { 6241 // Expected 6242 } 6243 try { 6244 descendingKeySet.tailSet(startKey, false); 6245 fail("should throw IllegalArgumentException"); 6246 } catch (IllegalArgumentException e) { 6247 // Expected 6248 } 6249 6250 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 6251 descendingKeySet = keySet.descendingSet(); 6252 startKey = new Integer(99).toString(); 6253 try { 6254 descendingKeySet.tailSet(startKey); 6255 fail("should throw IllegalArgumentException"); 6256 } catch (IllegalArgumentException e) { 6257 // Expected 6258 } 6259 try { 6260 descendingKeySet.tailSet(startKey, true); 6261 fail("should throw IllegalArgumentException"); 6262 } catch (IllegalArgumentException e) { 6263 // Expected 6264 } 6265 try { 6266 descendingKeySet.tailSet(startKey, false); 6267 fail("should throw IllegalArgumentException"); 6268 } catch (IllegalArgumentException e) { 6269 // Expected 6270 } 6271 6272 startKey = new Integer(100).toString(); 6273 tailSet = descendingKeySet.tailSet(startKey); 6274 assertEquals(1, tailSet.size()); 6275 iterator = tailSet.iterator(); 6276 assertEquals(startKey, iterator.next()); 6277 6278 tailSet = descendingKeySet.tailSet(startKey, true); 6279 assertEquals(1, tailSet.size()); 6280 iterator = tailSet.iterator(); 6281 assertEquals(startKey, iterator.next()); 6282 6283 tailSet = descendingKeySet.tailSet(startKey, false); 6284 assertEquals(0, tailSet.size()); 6285 6286 startKey = new Integer(101).toString(); 6287 tailSet = descendingKeySet.tailSet(startKey); 6288 iterator = tailSet.iterator(); 6289 for (index = 101; iterator.hasNext(); index--) { 6290 key = (String) iterator.next(); 6291 assertEquals(new Integer(index).toString(), key); 6292 } 6293 assertEquals(99, index); 6294 6295 tailSet = descendingKeySet.tailSet(startKey, true); 6296 iterator = tailSet.iterator(); 6297 for (index = 101; iterator.hasNext(); index--) { 6298 key = (String) iterator.next(); 6299 assertEquals(new Integer(index).toString(), key); 6300 } 6301 assertEquals(99, index); 6302 6303 tailSet = descendingKeySet.tailSet(startKey, false); 6304 iterator = tailSet.iterator(); 6305 for (index = 101; iterator.hasNext(); index--) { 6306 key = (String) iterator.next(); 6307 assertEquals(new Integer(index - 1).toString(), key); 6308 } 6309 assertEquals(100, index); 6310 6311 for (int i = 102; i < 109; i++) { 6312 startKey = new Integer(i).toString(); 6313 6314 tailSet = descendingKeySet.tailSet(startKey); 6315 iterator = tailSet.iterator(); 6316 int j; 6317 for (j = i; iterator.hasNext(); j--) { 6318 key = (String) iterator.next(); 6319 assertEquals(new Integer(j).toString(), key); 6320 } 6321 assertEquals(99, j); 6322 6323 tailSet = descendingKeySet.tailSet(startKey, true); 6324 iterator = tailSet.iterator(); 6325 for (j = i; iterator.hasNext(); j--) { 6326 key = (String) iterator.next(); 6327 assertEquals(new Integer(j).toString(), key); 6328 } 6329 assertEquals(99, j); 6330 6331 tailSet = descendingKeySet.tailSet(startKey, false); 6332 iterator = tailSet.iterator(); 6333 for (j = i; iterator.hasNext(); j--) { 6334 key = (String) iterator.next(); 6335 assertEquals(new Integer(j - 1).toString(), key); 6336 } 6337 assertEquals(100, j); 6338 } 6339 6340 startKey = new Integer(109).toString(); 6341 try { 6342 descendingKeySet.tailSet(startKey); 6343 fail("should throw IllegalArgumentException"); 6344 } catch (IllegalArgumentException e) { 6345 // Expected 6346 } 6347 try { 6348 descendingKeySet.tailSet(startKey, true); 6349 fail("should throw IllegalArgumentException"); 6350 } catch (IllegalArgumentException e) { 6351 // Expected 6352 } 6353 tailSet = descendingKeySet.tailSet(startKey, false); 6354 iterator = tailSet.iterator(); 6355 for (index = 109; iterator.hasNext(); index--) { 6356 key = (String) iterator.next(); 6357 assertEquals(new Integer(index - 1).toString(), key); 6358 } 6359 assertEquals(100, index); 6360 6361 startKey = new Integer(110).toString(); 6362 try { 6363 descendingKeySet.tailSet(startKey); 6364 fail("should throw IllegalArgumentException"); 6365 } catch (IllegalArgumentException e) { 6366 // Expected 6367 } 6368 try { 6369 descendingKeySet.tailSet(startKey, true); 6370 fail("should throw IllegalArgumentException"); 6371 } catch (IllegalArgumentException e) { 6372 // Expected 6373 } 6374 try { 6375 descendingKeySet.tailSet(startKey, false); 6376 fail("should throw IllegalArgumentException"); 6377 } catch (IllegalArgumentException e) { 6378 // Expected 6379 } 6380 6381 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 6382 descendingKeySet = keySet.descendingSet(); 6383 startKey = new Integer(99).toString(); 6384 try { 6385 descendingKeySet.tailSet(startKey); 6386 fail("should throw IllegalArgumentException"); 6387 } catch (IllegalArgumentException e) { 6388 // Expected 6389 } 6390 try { 6391 descendingKeySet.tailSet(startKey, true); 6392 fail("should throw IllegalArgumentException"); 6393 } catch (IllegalArgumentException e) { 6394 // Expected 6395 } 6396 try { 6397 descendingKeySet.tailSet(startKey, false); 6398 fail("should throw IllegalArgumentException"); 6399 } catch (IllegalArgumentException e) { 6400 // Expected 6401 } 6402 6403 startKey = new Integer(100).toString(); 6404 tailSet = descendingKeySet.tailSet(startKey); 6405 assertEquals(1, tailSet.size()); 6406 iterator = tailSet.iterator(); 6407 assertEquals(startKey, iterator.next()); 6408 6409 tailSet = descendingKeySet.tailSet(startKey, true); 6410 assertEquals(1, tailSet.size()); 6411 iterator = tailSet.iterator(); 6412 assertEquals(startKey, iterator.next()); 6413 6414 tailSet = descendingKeySet.tailSet(startKey, false); 6415 assertEquals(0, tailSet.size()); 6416 6417 startKey = new Integer(101).toString(); 6418 tailSet = descendingKeySet.tailSet(startKey); 6419 iterator = tailSet.iterator(); 6420 for (index = 101; iterator.hasNext(); index--) { 6421 key = (String) iterator.next(); 6422 assertEquals(new Integer(index).toString(), key); 6423 } 6424 assertEquals(99, index); 6425 6426 tailSet = descendingKeySet.tailSet(startKey, true); 6427 iterator = tailSet.iterator(); 6428 for (index = 101; iterator.hasNext(); index--) { 6429 key = (String) iterator.next(); 6430 assertEquals(new Integer(index).toString(), key); 6431 } 6432 assertEquals(99, index); 6433 6434 tailSet = descendingKeySet.tailSet(startKey, false); 6435 iterator = tailSet.iterator(); 6436 for (index = 101; iterator.hasNext(); index--) { 6437 key = (String) iterator.next(); 6438 assertEquals(new Integer(index - 1).toString(), key); 6439 } 6440 assertEquals(100, index); 6441 6442 for (int i = 102; i < 109; i++) { 6443 startKey = new Integer(i).toString(); 6444 6445 tailSet = descendingKeySet.tailSet(startKey); 6446 iterator = tailSet.iterator(); 6447 int j; 6448 for (j = i; iterator.hasNext(); j--) { 6449 key = (String) iterator.next(); 6450 assertEquals(new Integer(j).toString(), key); 6451 } 6452 assertEquals(99, j); 6453 6454 tailSet = descendingKeySet.tailSet(startKey, true); 6455 iterator = tailSet.iterator(); 6456 for (j = i; iterator.hasNext(); j--) { 6457 key = (String) iterator.next(); 6458 assertEquals(new Integer(j).toString(), key); 6459 } 6460 assertEquals(99, j); 6461 6462 tailSet = descendingKeySet.tailSet(startKey, false); 6463 iterator = tailSet.iterator(); 6464 for (j = i; iterator.hasNext(); j--) { 6465 key = (String) iterator.next(); 6466 assertEquals(new Integer(j - 1).toString(), key); 6467 } 6468 assertEquals(100, j); 6469 } 6470 6471 startKey = new Integer(109).toString(); 6472 tailSet = descendingKeySet.tailSet(startKey); 6473 iterator = tailSet.iterator(); 6474 for (index = 109; iterator.hasNext(); index--) { 6475 key = (String) iterator.next(); 6476 assertEquals(new Integer(index).toString(), key); 6477 } 6478 assertEquals(99, index); 6479 6480 tailSet = descendingKeySet.tailSet(startKey, true); 6481 iterator = tailSet.iterator(); 6482 for (index = 109; iterator.hasNext(); index--) { 6483 key = (String) iterator.next(); 6484 assertEquals(new Integer(index).toString(), key); 6485 } 6486 assertEquals(99, index); 6487 6488 tailSet = descendingKeySet.tailSet(startKey, false); 6489 iterator = tailSet.iterator(); 6490 for (index = 109; iterator.hasNext(); index--) { 6491 key = (String) iterator.next(); 6492 assertEquals(new Integer(index - 1).toString(), key); 6493 } 6494 assertEquals(100, index); 6495 6496 startKey = new Integer(110).toString(); 6497 try { 6498 descendingKeySet.tailSet(startKey); 6499 fail("should throw IllegalArgumentException"); 6500 } catch (IllegalArgumentException e) { 6501 // Expected 6502 } 6503 try { 6504 descendingKeySet.tailSet(startKey, true); 6505 fail("should throw IllegalArgumentException"); 6506 } catch (IllegalArgumentException e) { 6507 // Expected 6508 } 6509 try { 6510 descendingKeySet.tailSet(startKey, false); 6511 fail("should throw IllegalArgumentException"); 6512 } catch (IllegalArgumentException e) { 6513 // Expected 6514 } 6515 6516 key = new Integer(2).toString(); 6517 keySet = tm.headMap(key, true).navigableKeySet(); 6518 descendingKeySet = keySet.descendingSet(); 6519 iterator = descendingKeySet.iterator(); 6520 iterator.next(); 6521 startKey = (String) iterator.next(); 6522 6523 tailSet = descendingKeySet.tailSet(startKey); 6524 assertEquals(112, tailSet.size()); 6525 Iterator tailIterator = tailSet.iterator(); 6526 assertEquals(new Integer(199).toString(), tailIterator.next()); 6527 6528 tailSet = descendingKeySet.tailSet(startKey, true); 6529 assertEquals(112, tailSet.size()); 6530 tailIterator = tailSet.iterator(); 6531 assertEquals(new Integer(199).toString(), tailIterator.next()); 6532 6533 tailSet = descendingKeySet.tailSet(startKey, false); 6534 assertEquals(111, tailSet.size()); 6535 tailIterator = tailSet.iterator(); 6536 assertEquals(new Integer(198).toString(), tailIterator.next()); 6537 } 6538 6539 public void test_DescendingSubMapKeySet_subSet() { 6540 NavigableSet keySet, descendingKeySet; 6541 SortedSet subSet; 6542 String startKey, endKey, key; 6543 Iterator startIterator, endIterator, subSetIterator; 6544 6545 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 6546 descendingKeySet = keySet.descendingSet(); 6547 startIterator = descendingKeySet.iterator(); 6548 while (startIterator.hasNext()) { 6549 startKey = (String) startIterator.next(); 6550 endIterator = descendingKeySet.iterator(); 6551 while (endIterator.hasNext()) { 6552 endKey = (String) endIterator.next(); 6553 int startIndex = Integer.valueOf(startKey); 6554 int endIndex = Integer.valueOf(endKey); 6555 if (startIndex < endIndex) { 6556 try { 6557 descendingKeySet.subSet(startKey, endKey); 6558 fail("should throw IllegalArgumentException"); 6559 } catch (IllegalArgumentException e) { 6560 // Expected 6561 } 6562 6563 try { 6564 descendingKeySet.subSet(startKey, false, endKey, false); 6565 fail("shoudl throw IllegalArgumentException"); 6566 } catch (IllegalArgumentException e) { 6567 // Expected 6568 } 6569 6570 try { 6571 descendingKeySet.subSet(startKey, false, endKey, true); 6572 fail("shoudl throw IllegalArgumentException"); 6573 } catch (IllegalArgumentException e) { 6574 // Expected 6575 } 6576 6577 try { 6578 descendingKeySet.subSet(startKey, true, endKey, false); 6579 fail("shoudl throw IllegalArgumentException"); 6580 } catch (IllegalArgumentException e) { 6581 // Expected 6582 } 6583 6584 try { 6585 descendingKeySet.subSet(startKey, true, endKey, true); 6586 fail("shoudl throw IllegalArgumentException"); 6587 } catch (IllegalArgumentException e) { 6588 // Expected 6589 } 6590 } else { 6591 subSet = descendingKeySet.subSet(startKey, endKey); 6592 subSetIterator = subSet.iterator(); 6593 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6594 assertEquals(new Integer(index).toString(), 6595 subSetIterator.next()); 6596 } 6597 6598 subSet = descendingKeySet.subSet(startKey, false, endKey, 6599 false); 6600 subSetIterator = subSet.iterator(); 6601 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6602 assertEquals(new Integer(index).toString(), 6603 subSetIterator.next()); 6604 } 6605 6606 subSet = descendingKeySet.subSet(startKey, false, endKey, 6607 true); 6608 subSetIterator = subSet.iterator(); 6609 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6610 assertEquals(new Integer(index).toString(), 6611 subSetIterator.next()); 6612 } 6613 6614 subSet = descendingKeySet.subSet(startKey, true, endKey, 6615 false); 6616 subSetIterator = subSet.iterator(); 6617 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6618 assertEquals(new Integer(index).toString(), 6619 subSetIterator.next()); 6620 } 6621 6622 subSet = descendingKeySet.subSet(startKey, true, endKey, 6623 true); 6624 subSetIterator = subSet.iterator(); 6625 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6626 assertEquals(new Integer(index).toString(), 6627 subSetIterator.next()); 6628 } 6629 } 6630 } 6631 } 6632 6633 endKey = new Integer(2).toString(); 6634 keySet = tm.headMap(endKey, true).navigableKeySet(); 6635 descendingKeySet = keySet.descendingSet(); 6636 Iterator iterator = descendingKeySet.iterator(); 6637 6638 startKey = (String) iterator.next(); 6639 iterator.next(); 6640 endKey = (String) iterator.next(); 6641 6642 subSet = descendingKeySet.subSet(startKey, endKey); 6643 assertEquals(2, subSet.size()); 6644 subSetIterator = subSet.iterator(); 6645 assertEquals(startKey, subSetIterator.next()); 6646 subSetIterator.next(); 6647 try { 6648 subSetIterator.next(); 6649 fail("should throw NoSuchElementException"); 6650 } catch (NoSuchElementException e) { 6651 // Expected 6652 } 6653 6654 subSet = descendingKeySet.subSet(startKey, false, endKey, false); 6655 assertEquals(1, subSet.size()); 6656 subSetIterator = subSet.iterator(); 6657 subSetIterator.next(); 6658 try { 6659 subSetIterator.next(); 6660 fail("should throw NoSuchElementException"); 6661 } catch (NoSuchElementException e) { 6662 // Expected 6663 } 6664 6665 subSet = descendingKeySet.subSet(startKey, false, endKey, true); 6666 assertEquals(2, subSet.size()); 6667 subSetIterator = subSet.iterator(); 6668 subSetIterator.next(); 6669 assertEquals(endKey, subSetIterator.next()); 6670 try { 6671 subSetIterator.next(); 6672 fail("should throw NoSuchElementException"); 6673 } catch (NoSuchElementException e) { 6674 // Expected 6675 } 6676 6677 subSet = descendingKeySet.subSet(startKey, true, endKey, false); 6678 assertEquals(2, subSet.size()); 6679 subSetIterator = subSet.iterator(); 6680 assertEquals(startKey, subSetIterator.next()); 6681 subSetIterator.next(); 6682 try { 6683 subSetIterator.next(); 6684 fail("should throw NoSuchElementException"); 6685 } catch (NoSuchElementException e) { 6686 // Expected 6687 } 6688 6689 subSet = descendingKeySet.subSet(startKey, true, endKey, true); 6690 assertEquals(3, subSet.size()); 6691 subSetIterator = subSet.iterator(); 6692 assertEquals(startKey, subSetIterator.next()); 6693 subSetIterator.next(); 6694 assertEquals(endKey, subSetIterator.next()); 6695 try { 6696 subSetIterator.next(); 6697 fail("should throw NoSuchElementException"); 6698 } catch (NoSuchElementException e) { 6699 // Expected 6700 } 6701 6702 // With Comparator 6703 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 6704 .navigableKeySet(); 6705 descendingKeySet = keySet.descendingSet(); 6706 startIterator = descendingKeySet.iterator(); 6707 while (startIterator.hasNext()) { 6708 startKey = (String) startIterator.next(); 6709 endIterator = descendingKeySet.iterator(); 6710 while (endIterator.hasNext()) { 6711 endKey = (String) endIterator.next(); 6712 int startIndex = Integer.valueOf(startKey); 6713 int endIndex = Integer.valueOf(endKey); 6714 if (startIndex < endIndex) { 6715 try { 6716 descendingKeySet.subSet(startKey, endKey); 6717 fail("should throw IllegalArgumentException"); 6718 } catch (IllegalArgumentException e) { 6719 // Expected 6720 } 6721 6722 try { 6723 descendingKeySet.subSet(startKey, false, endKey, false); 6724 fail("shoudl throw IllegalArgumentException"); 6725 } catch (IllegalArgumentException e) { 6726 // Expected 6727 } 6728 6729 try { 6730 descendingKeySet.subSet(startKey, false, endKey, true); 6731 fail("shoudl throw IllegalArgumentException"); 6732 } catch (IllegalArgumentException e) { 6733 // Expected 6734 } 6735 6736 try { 6737 descendingKeySet.subSet(startKey, true, endKey, false); 6738 fail("shoudl throw IllegalArgumentException"); 6739 } catch (IllegalArgumentException e) { 6740 // Expected 6741 } 6742 6743 try { 6744 descendingKeySet.subSet(startKey, true, endKey, true); 6745 fail("shoudl throw IllegalArgumentException"); 6746 } catch (IllegalArgumentException e) { 6747 // Expected 6748 } 6749 } else { 6750 subSet = descendingKeySet.subSet(startKey, endKey); 6751 subSetIterator = subSet.iterator(); 6752 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6753 assertEquals(new Integer(index).toString(), 6754 subSetIterator.next()); 6755 } 6756 6757 subSet = descendingKeySet.subSet(startKey, false, endKey, 6758 false); 6759 subSetIterator = subSet.iterator(); 6760 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6761 assertEquals(new Integer(index).toString(), 6762 subSetIterator.next()); 6763 } 6764 6765 subSet = descendingKeySet.subSet(startKey, false, endKey, 6766 true); 6767 subSetIterator = subSet.iterator(); 6768 for (int index = startIndex - 1; subSetIterator.hasNext(); index--) { 6769 assertEquals(new Integer(index).toString(), 6770 subSetIterator.next()); 6771 } 6772 6773 subSet = descendingKeySet.subSet(startKey, true, endKey, 6774 false); 6775 subSetIterator = subSet.iterator(); 6776 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6777 assertEquals(new Integer(index).toString(), 6778 subSetIterator.next()); 6779 } 6780 6781 subSet = descendingKeySet.subSet(startKey, true, endKey, 6782 true); 6783 subSetIterator = subSet.iterator(); 6784 for (int index = startIndex; subSetIterator.hasNext(); index--) { 6785 assertEquals(new Integer(index).toString(), 6786 subSetIterator.next()); 6787 } 6788 } 6789 } 6790 } 6791 } 6792 6793 public void test_DescendingSubMapKeySet_descendingSet() { 6794 NavigableSet keySet, descendingSet, descendingDescendingSet; 6795 int value; 6796 Iterator iterator; 6797 6798 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 6799 descendingSet = keySet.descendingSet(); 6800 descendingDescendingSet = descendingSet.descendingSet(); 6801 iterator = descendingDescendingSet.iterator(); 6802 assertTrue(iterator.hasNext()); 6803 for (value = 101; iterator.hasNext(); value++) { 6804 assertEquals(new Integer(value).toString(), iterator.next()); 6805 } 6806 assertEquals(109, value); 6807 try { 6808 iterator.next(); 6809 fail("should throw NoSuchElementException"); 6810 } catch (NoSuchElementException e) { 6811 // Expected 6812 } 6813 6814 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 6815 descendingSet = keySet.descendingSet(); 6816 descendingDescendingSet = descendingSet.descendingSet(); 6817 iterator = descendingDescendingSet.iterator(); 6818 assertTrue(iterator.hasNext()); 6819 for (value = 101; iterator.hasNext(); value++) { 6820 assertEquals(new Integer(value).toString(), iterator.next()); 6821 } 6822 assertEquals(110, value); 6823 try { 6824 iterator.next(); 6825 fail("should throw NoSuchElementException"); 6826 } catch (NoSuchElementException e) { 6827 // Expected 6828 } 6829 6830 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 6831 descendingSet = keySet.descendingSet(); 6832 descendingDescendingSet = descendingSet.descendingSet(); 6833 iterator = descendingDescendingSet.iterator(); 6834 assertTrue(iterator.hasNext()); 6835 for (value = 100; iterator.hasNext(); value++) { 6836 assertEquals(new Integer(value).toString(), iterator.next()); 6837 } 6838 assertEquals(109, value); 6839 try { 6840 iterator.next(); 6841 fail("should throw NoSuchElementException"); 6842 } catch (NoSuchElementException e) { 6843 // Expected 6844 } 6845 6846 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 6847 descendingSet = keySet.descendingSet(); 6848 descendingDescendingSet = descendingSet.descendingSet(); 6849 iterator = descendingDescendingSet.iterator(); 6850 assertTrue(iterator.hasNext()); 6851 for (value = 100; iterator.hasNext(); value++) { 6852 assertEquals(new Integer(value).toString(), iterator.next()); 6853 } 6854 assertEquals(110, value); 6855 try { 6856 iterator.next(); 6857 fail("should throw NoSuchElementException"); 6858 } catch (NoSuchElementException e) { 6859 // Expected 6860 } 6861 6862 String endKey = new Integer(2).toString(); 6863 keySet = tm.headMap(endKey, true).navigableKeySet(); 6864 descendingSet = keySet.descendingSet(); 6865 descendingDescendingSet = descendingSet.descendingSet(); 6866 assertEquals(keySet, descendingDescendingSet); 6867 6868 String startKey = new Integer(2).toString(); 6869 keySet = tm.tailMap(startKey, true).navigableKeySet(); 6870 descendingSet = keySet.descendingSet(); 6871 descendingDescendingSet = descendingSet.descendingSet(); 6872 assertEquals(keySet, descendingDescendingSet); 6873 } 6874 6875 public void test_DescendingSubMapKeySet_descendingIterator() { 6876 NavigableSet keySet, descendingSet; 6877 int value; 6878 Iterator iterator, descendingIterator; 6879 6880 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 6881 descendingSet = keySet.descendingSet(); 6882 descendingIterator = descendingSet.descendingIterator(); 6883 assertTrue(descendingIterator.hasNext()); 6884 for (value = 101; descendingIterator.hasNext(); value++) { 6885 assertEquals(new Integer(value).toString(), descendingIterator 6886 .next()); 6887 } 6888 assertEquals(109, value); 6889 try { 6890 descendingIterator.next(); 6891 fail("should throw NoSuchElementException"); 6892 } catch (NoSuchElementException e) { 6893 // Expected 6894 } 6895 6896 descendingSet = descendingSet 6897 .headSet(new Integer(105).toString(), true); 6898 descendingIterator = descendingSet.descendingIterator(); 6899 for (value = 105; descendingIterator.hasNext(); value++) { 6900 assertEquals(new Integer(value).toString(), descendingIterator 6901 .next()); 6902 } 6903 6904 descendingSet = keySet.descendingSet(); 6905 descendingSet = descendingSet 6906 .tailSet(new Integer(105).toString(), true); 6907 descendingIterator = descendingSet.descendingIterator(); 6908 for (value = 101; descendingIterator.hasNext(); value++) { 6909 assertEquals(new Integer(value).toString(), descendingIterator 6910 .next()); 6911 } 6912 6913 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 6914 descendingSet = keySet.descendingSet(); 6915 descendingIterator = descendingSet.descendingIterator(); 6916 assertTrue(descendingIterator.hasNext()); 6917 for (value = 101; descendingIterator.hasNext(); value++) { 6918 assertEquals(new Integer(value).toString(), descendingIterator 6919 .next()); 6920 } 6921 assertEquals(110, value); 6922 try { 6923 descendingIterator.next(); 6924 fail("should throw NoSuchElementException"); 6925 } catch (NoSuchElementException e) { 6926 // Expected 6927 } 6928 6929 descendingSet = descendingSet 6930 .headSet(new Integer(105).toString(), true); 6931 descendingIterator = descendingSet.descendingIterator(); 6932 for (value = 105; descendingIterator.hasNext(); value++) { 6933 assertEquals(new Integer(value).toString(), descendingIterator 6934 .next()); 6935 } 6936 6937 descendingSet = keySet.descendingSet(); 6938 descendingSet = descendingSet 6939 .tailSet(new Integer(105).toString(), true); 6940 descendingIterator = descendingSet.descendingIterator(); 6941 for (value = 101; descendingIterator.hasNext(); value++) { 6942 assertEquals(new Integer(value).toString(), descendingIterator 6943 .next()); 6944 } 6945 6946 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 6947 descendingSet = keySet.descendingSet(); 6948 descendingIterator = descendingSet.descendingIterator(); 6949 assertTrue(descendingIterator.hasNext()); 6950 for (value = 100; descendingIterator.hasNext(); value++) { 6951 assertEquals(new Integer(value).toString(), descendingIterator 6952 .next()); 6953 } 6954 assertEquals(109, value); 6955 try { 6956 descendingIterator.next(); 6957 fail("should throw NoSuchElementException"); 6958 } catch (NoSuchElementException e) { 6959 // Expected 6960 } 6961 6962 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 6963 descendingSet = keySet.descendingSet(); 6964 descendingIterator = descendingSet.descendingIterator(); 6965 assertTrue(descendingIterator.hasNext()); 6966 for (value = 100; descendingIterator.hasNext(); value++) { 6967 assertEquals(new Integer(value).toString(), descendingIterator 6968 .next()); 6969 } 6970 assertEquals(110, value); 6971 try { 6972 descendingIterator.next(); 6973 fail("should throw NoSuchElementException"); 6974 } catch (NoSuchElementException e) { 6975 // Expected 6976 } 6977 6978 String endKey = new Integer(2).toString(); 6979 keySet = tm.headMap(endKey, true).navigableKeySet(); 6980 iterator = keySet.iterator(); 6981 6982 descendingSet = keySet.descendingSet(); 6983 descendingIterator = descendingSet.descendingIterator(); 6984 6985 while (iterator.hasNext()) { 6986 assertEquals(iterator.next(), descendingIterator.next()); 6987 } 6988 6989 String startKey = new Integer(2).toString(); 6990 keySet = tm.tailMap(startKey, true).navigableKeySet(); 6991 iterator = keySet.iterator(); 6992 descendingSet = keySet.descendingSet(); 6993 descendingIterator = descendingSet.descendingIterator(); 6994 6995 while (iterator.hasNext()) { 6996 assertEquals(iterator.next(), descendingIterator.next()); 6997 } 6998 } 6999 7000 public void test_DescendingSubMapKeySet_lower() { 7001 NavigableSet keySet, descendingKeySet; 7002 Iterator iterator; 7003 String key, lowerKey; 7004 int value, lowerValue; 7005 7006 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7007 descendingKeySet = keySet.descendingSet(); 7008 iterator = descendingKeySet.iterator(); 7009 while (iterator.hasNext()) { 7010 key = (String) iterator.next(); 7011 value = Integer.valueOf(key); 7012 lowerKey = (String) descendingKeySet.lower(key); 7013 if (value < 108) { 7014 lowerValue = Integer.valueOf(lowerKey); 7015 assertEquals(value + 1, lowerValue); 7016 } else { 7017 assertNull(lowerKey); 7018 } 7019 } 7020 7021 key = new Integer(0).toString(); 7022 lowerKey = (String) descendingKeySet.lower(key); 7023 assertEquals(101, Integer.parseInt(lowerKey)); 7024 7025 key = new Integer(2).toString(); 7026 lowerKey = (String) descendingKeySet.lower(key); 7027 assertNull(lowerKey); 7028 7029 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7030 descendingKeySet = keySet.descendingSet(); 7031 iterator = descendingKeySet.iterator(); 7032 while (iterator.hasNext()) { 7033 key = (String) iterator.next(); 7034 value = Integer.valueOf(key); 7035 lowerKey = (String) descendingKeySet.lower(key); 7036 if (value < 109) { 7037 lowerValue = Integer.valueOf(lowerKey); 7038 assertEquals(value + 1, lowerValue); 7039 } else { 7040 assertNull(lowerKey); 7041 } 7042 } 7043 7044 key = new Integer(0).toString(); 7045 lowerKey = (String) descendingKeySet.lower(key); 7046 assertEquals(101, Integer.parseInt(lowerKey)); 7047 7048 key = new Integer(2).toString(); 7049 lowerKey = (String) descendingKeySet.lower(key); 7050 assertNull(lowerKey); 7051 7052 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7053 descendingKeySet = keySet.descendingSet(); 7054 iterator = descendingKeySet.iterator(); 7055 while (iterator.hasNext()) { 7056 key = (String) iterator.next(); 7057 value = Integer.valueOf(key); 7058 lowerKey = (String) descendingKeySet.lower(key); 7059 if (value < 108) { 7060 lowerValue = Integer.valueOf(lowerKey); 7061 assertEquals(value + 1, lowerValue); 7062 } else { 7063 assertNull(lowerKey); 7064 } 7065 } 7066 7067 key = new Integer(0).toString(); 7068 lowerKey = (String) descendingKeySet.lower(key); 7069 assertEquals(100, Integer.parseInt(lowerKey)); 7070 7071 key = new Integer(2).toString(); 7072 lowerKey = (String) descendingKeySet.lower(key); 7073 assertNull(lowerKey); 7074 7075 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7076 descendingKeySet = keySet.descendingSet(); 7077 iterator = descendingKeySet.iterator(); 7078 while (iterator.hasNext()) { 7079 key = (String) iterator.next(); 7080 value = Integer.valueOf(key); 7081 lowerKey = (String) descendingKeySet.lower(key); 7082 if (value < 109) { 7083 lowerValue = Integer.valueOf(lowerKey); 7084 assertEquals(value + 1, lowerValue); 7085 } else { 7086 assertNull(lowerKey); 7087 } 7088 } 7089 7090 key = new Integer(0).toString(); 7091 lowerKey = (String) descendingKeySet.lower(key); 7092 assertEquals(100, Integer.parseInt(lowerKey)); 7093 7094 key = new Integer(2).toString(); 7095 lowerKey = (String) descendingKeySet.lower(key); 7096 assertNull(lowerKey); 7097 7098 key = new Integer(2).toString(); 7099 keySet = tm.headMap(key, true).navigableKeySet(); 7100 descendingKeySet = keySet.descendingSet(); 7101 iterator = descendingKeySet.iterator(); 7102 iterator.next(); 7103 iterator.next(); 7104 key = (String) iterator.next(); 7105 lowerKey = (String) descendingKeySet.lower(key); 7106 assertEquals(new Integer(199).toString(), lowerKey); 7107 try { 7108 descendingKeySet.lower(null); 7109 fail("should throw NPE"); 7110 } catch (NullPointerException e) { 7111 // Expected 7112 } 7113 7114 key = new Integer(0).toString(); 7115 String endKey = key; 7116 7117 keySet = tm.headMap(endKey, true).navigableKeySet(); 7118 descendingKeySet = keySet.descendingSet(); 7119 assertNull(descendingKeySet.lower(endKey)); 7120 7121 key = new Integer(0).toString(); 7122 keySet = tm.headMap(endKey, false).navigableKeySet(); 7123 descendingKeySet = keySet.descendingSet(); 7124 assertNull(descendingKeySet.lower(endKey)); 7125 7126 endKey = new Integer(999).toString(); 7127 keySet = tm.headMap(endKey, true).navigableKeySet(); 7128 descendingKeySet = keySet.descendingSet(); 7129 assertNull(descendingKeySet.lower(endKey)); 7130 assertEquals(new Integer(1).toString(), descendingKeySet.lower(key)); 7131 7132 endKey = new Integer(999).toString(); 7133 keySet = tm.headMap(endKey, false).navigableKeySet(); 7134 descendingKeySet = keySet.descendingSet(); 7135 assertNull(descendingKeySet.lower(endKey)); 7136 assertEquals(new Integer(1).toString(), descendingKeySet.lower(key)); 7137 7138 // With Comparator 7139 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7140 .navigableKeySet(); 7141 descendingKeySet = keySet.descendingSet(); 7142 iterator = descendingKeySet.iterator(); 7143 while (iterator.hasNext()) { 7144 key = (String) iterator.next(); 7145 value = Integer.valueOf(key); 7146 lowerKey = (String) descendingKeySet.lower(key); 7147 if (value < 108) { 7148 lowerValue = Integer.valueOf(lowerKey); 7149 assertEquals(value + 1, lowerValue); 7150 } else { 7151 assertNull(lowerKey); 7152 } 7153 } 7154 7155 key = new Integer(0).toString(); 7156 lowerKey = (String) descendingKeySet.lower(key); 7157 assertEquals(101, Integer.parseInt(lowerKey)); 7158 7159 key = new Integer(2).toString(); 7160 lowerKey = (String) descendingKeySet.lower(key); 7161 assertNull(lowerKey); 7162 7163 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7164 .navigableKeySet(); 7165 descendingKeySet = keySet.descendingSet(); 7166 iterator = descendingKeySet.iterator(); 7167 while (iterator.hasNext()) { 7168 key = (String) iterator.next(); 7169 value = Integer.valueOf(key); 7170 lowerKey = (String) descendingKeySet.lower(key); 7171 if (value < 109) { 7172 lowerValue = Integer.valueOf(lowerKey); 7173 assertEquals(value + 1, lowerValue); 7174 } else { 7175 assertNull(lowerKey); 7176 } 7177 } 7178 7179 key = new Integer(0).toString(); 7180 lowerKey = (String) descendingKeySet.lower(key); 7181 assertEquals(101, Integer.parseInt(lowerKey)); 7182 7183 key = new Integer(2).toString(); 7184 lowerKey = (String) descendingKeySet.lower(key); 7185 assertNull(lowerKey); 7186 7187 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7188 .navigableKeySet(); 7189 descendingKeySet = keySet.descendingSet(); 7190 iterator = descendingKeySet.iterator(); 7191 while (iterator.hasNext()) { 7192 key = (String) iterator.next(); 7193 value = Integer.valueOf(key); 7194 lowerKey = (String) descendingKeySet.lower(key); 7195 if (value < 108) { 7196 lowerValue = Integer.valueOf(lowerKey); 7197 assertEquals(value + 1, lowerValue); 7198 } else { 7199 assertNull(lowerKey); 7200 } 7201 } 7202 7203 key = new Integer(0).toString(); 7204 lowerKey = (String) descendingKeySet.lower(key); 7205 assertEquals(100, Integer.parseInt(lowerKey)); 7206 7207 key = new Integer(2).toString(); 7208 lowerKey = (String) descendingKeySet.lower(key); 7209 assertNull(lowerKey); 7210 7211 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 7212 .navigableKeySet(); 7213 descendingKeySet = keySet.descendingSet(); 7214 iterator = descendingKeySet.iterator(); 7215 while (iterator.hasNext()) { 7216 key = (String) iterator.next(); 7217 value = Integer.valueOf(key); 7218 lowerKey = (String) descendingKeySet.lower(key); 7219 if (value < 109) { 7220 lowerValue = Integer.valueOf(lowerKey); 7221 assertEquals(value + 1, lowerValue); 7222 } else { 7223 assertNull(lowerKey); 7224 } 7225 } 7226 } 7227 7228 public void test_DescendingSubMapKeySet_higher() { 7229 NavigableSet keySet, descendingKeySet; 7230 Iterator iterator; 7231 String key, higherKey; 7232 int value, higherValue; 7233 7234 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7235 descendingKeySet = keySet.descendingSet(); 7236 iterator = descendingKeySet.iterator(); 7237 while (iterator.hasNext()) { 7238 key = (String) iterator.next(); 7239 value = Integer.valueOf(key); 7240 higherKey = (String) descendingKeySet.higher(key); 7241 if (value > 101) { 7242 higherValue = Integer.valueOf(higherKey); 7243 assertEquals(value - 1, higherValue); 7244 } else { 7245 assertNull(higherKey); 7246 } 7247 } 7248 7249 key = new Integer(99999).toString(); 7250 higherKey = (String) descendingKeySet.higher(key); 7251 assertEquals("108", higherKey); 7252 7253 key = new Integer(-1).toString(); 7254 higherKey = (String) descendingKeySet.higher(key); 7255 assertNull(higherKey); 7256 7257 key = new Integer(100).toString(); 7258 higherKey = (String) descendingKeySet.higher(key); 7259 assertNull(higherKey); 7260 7261 key = new Integer(0).toString(); 7262 higherKey = (String) descendingKeySet.higher(key); 7263 assertNull(higherKey); 7264 7265 key = new Integer(2).toString(); 7266 higherKey = (String) descendingKeySet.higher(key); 7267 assertEquals(108, Integer.parseInt(higherKey)); 7268 7269 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7270 descendingKeySet = keySet.descendingSet(); 7271 iterator = descendingKeySet.iterator(); 7272 while (iterator.hasNext()) { 7273 key = (String) iterator.next(); 7274 value = Integer.valueOf(key); 7275 higherKey = (String) descendingKeySet.higher(key); 7276 if (value > 101) { 7277 higherValue = Integer.valueOf(higherKey); 7278 assertEquals(value - 1, higherValue); 7279 } else { 7280 assertNull(higherKey); 7281 } 7282 } 7283 7284 key = new Integer(99999).toString(); 7285 higherKey = (String) descendingKeySet.higher(key); 7286 assertEquals("109", higherKey); 7287 7288 key = new Integer(-1).toString(); 7289 higherKey = (String) descendingKeySet.higher(key); 7290 assertNull(higherKey); 7291 7292 key = new Integer(100).toString(); 7293 higherKey = (String) descendingKeySet.higher(key); 7294 assertNull(higherKey); 7295 7296 key = new Integer(2).toString(); 7297 higherKey = (String) descendingKeySet.higher(key); 7298 assertEquals(109, Integer.parseInt(higherKey)); 7299 7300 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7301 descendingKeySet = keySet.descendingSet(); 7302 iterator = descendingKeySet.iterator(); 7303 while (iterator.hasNext()) { 7304 key = (String) iterator.next(); 7305 value = Integer.valueOf(key); 7306 higherKey = (String) descendingKeySet.higher(key); 7307 if (value > 100) { 7308 higherValue = Integer.valueOf(higherKey); 7309 assertEquals(value - 1, higherValue); 7310 } else { 7311 assertNull(higherKey); 7312 } 7313 } 7314 7315 key = new Integer(99999).toString(); 7316 higherKey = (String) descendingKeySet.higher(key); 7317 assertEquals("108", higherKey); 7318 7319 key = new Integer(-1).toString(); 7320 higherKey = (String) descendingKeySet.higher(key); 7321 assertNull(higherKey); 7322 7323 key = new Integer(100).toString(); 7324 higherKey = (String) descendingKeySet.higher(key); 7325 assertNull(higherKey); 7326 7327 key = new Integer(2).toString(); 7328 higherKey = (String) descendingKeySet.higher(key); 7329 assertEquals(108, Integer.parseInt(higherKey)); 7330 7331 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7332 descendingKeySet = keySet.descendingSet(); 7333 iterator = descendingKeySet.iterator(); 7334 while (iterator.hasNext()) { 7335 key = (String) iterator.next(); 7336 value = Integer.valueOf(key); 7337 higherKey = (String) descendingKeySet.higher(key); 7338 if (value > 100) { 7339 higherValue = Integer.valueOf(higherKey); 7340 assertEquals(value - 1, higherValue); 7341 } else { 7342 assertNull(higherKey); 7343 } 7344 } 7345 7346 key = new Integer(99999).toString(); 7347 higherKey = (String) descendingKeySet.higher(key); 7348 assertEquals("109", higherKey); 7349 7350 key = new Integer(-1).toString(); 7351 higherKey = (String) descendingKeySet.higher(key); 7352 assertNull(higherKey); 7353 7354 key = new Integer(100).toString(); 7355 higherKey = (String) descendingKeySet.higher(key); 7356 assertNull(higherKey); 7357 7358 key = new Integer(2).toString(); 7359 higherKey = (String) descendingKeySet.higher(key); 7360 assertEquals(109, Integer.parseInt(higherKey)); 7361 7362 key = new Integer(2).toString(); 7363 keySet = tm.headMap(key, true).navigableKeySet(); 7364 descendingKeySet = keySet.descendingSet(); 7365 iterator = descendingKeySet.iterator(); 7366 key = (String) iterator.next(); 7367 higherKey = (String) descendingKeySet.higher(key); 7368 assertEquals(new Integer(199).toString(), higherKey); 7369 try { 7370 descendingKeySet.higher(null); 7371 fail("should throw NPE"); 7372 } catch (NullPointerException e) { 7373 // Expected 7374 } 7375 7376 key = new Integer(0).toString(); 7377 String endKey = key; 7378 7379 keySet = tm.headMap(endKey, true).navigableKeySet(); 7380 descendingKeySet = keySet.descendingSet(); 7381 assertNull(descendingKeySet.higher(endKey)); 7382 7383 key = new Integer(0).toString(); 7384 keySet = tm.headMap(endKey, false).navigableKeySet(); 7385 descendingKeySet = keySet.descendingSet(); 7386 assertNull(descendingKeySet.higher(endKey)); 7387 7388 endKey = new Integer(999).toString(); 7389 keySet = tm.headMap(endKey, true).navigableKeySet(); 7390 descendingKeySet = keySet.descendingSet(); 7391 assertEquals(new Integer(998).toString(), descendingKeySet 7392 .higher(endKey)); 7393 assertNull(descendingKeySet.higher(key)); 7394 7395 endKey = new Integer(999).toString(); 7396 keySet = tm.headMap(endKey, false).navigableKeySet(); 7397 descendingKeySet = keySet.descendingSet(); 7398 assertEquals(new Integer(998).toString(), descendingKeySet 7399 .higher(endKey)); 7400 assertNull(descendingKeySet.higher(key)); 7401 7402 // With Comparator 7403 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7404 .navigableKeySet(); 7405 descendingKeySet = keySet.descendingSet(); 7406 iterator = descendingKeySet.iterator(); 7407 while (iterator.hasNext()) { 7408 key = (String) iterator.next(); 7409 value = Integer.valueOf(key); 7410 higherKey = (String) descendingKeySet.higher(key); 7411 if (value > 101) { 7412 higherValue = Integer.valueOf(higherKey); 7413 assertEquals(value - 1, higherValue); 7414 } else { 7415 assertNull(higherKey); 7416 } 7417 } 7418 7419 key = new Integer(99999).toString(); 7420 higherKey = (String) descendingKeySet.higher(key); 7421 assertEquals("108", higherKey); 7422 7423 key = new Integer(-1).toString(); 7424 higherKey = (String) descendingKeySet.higher(key); 7425 assertNull(higherKey); 7426 7427 key = new Integer(100).toString(); 7428 higherKey = (String) descendingKeySet.higher(key); 7429 assertNull(higherKey); 7430 7431 key = new Integer(0).toString(); 7432 higherKey = (String) descendingKeySet.higher(key); 7433 assertNull(higherKey); 7434 7435 key = new Integer(2).toString(); 7436 higherKey = (String) descendingKeySet.higher(key); 7437 assertEquals(108, Integer.parseInt(higherKey)); 7438 7439 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7440 .navigableKeySet(); 7441 descendingKeySet = keySet.descendingSet(); 7442 iterator = descendingKeySet.iterator(); 7443 while (iterator.hasNext()) { 7444 key = (String) iterator.next(); 7445 value = Integer.valueOf(key); 7446 higherKey = (String) descendingKeySet.higher(key); 7447 if (value > 101) { 7448 higherValue = Integer.valueOf(higherKey); 7449 assertEquals(value - 1, higherValue); 7450 } else { 7451 assertNull(higherKey); 7452 } 7453 } 7454 7455 key = new Integer(99999).toString(); 7456 higherKey = (String) descendingKeySet.higher(key); 7457 assertEquals("109", higherKey); 7458 7459 key = new Integer(-1).toString(); 7460 higherKey = (String) descendingKeySet.higher(key); 7461 assertNull(higherKey); 7462 7463 key = new Integer(100).toString(); 7464 higherKey = (String) descendingKeySet.higher(key); 7465 assertNull(higherKey); 7466 7467 key = new Integer(2).toString(); 7468 higherKey = (String) descendingKeySet.higher(key); 7469 assertEquals(109, Integer.parseInt(higherKey)); 7470 7471 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7472 .navigableKeySet(); 7473 descendingKeySet = keySet.descendingSet(); 7474 iterator = descendingKeySet.iterator(); 7475 while (iterator.hasNext()) { 7476 key = (String) iterator.next(); 7477 value = Integer.valueOf(key); 7478 higherKey = (String) descendingKeySet.higher(key); 7479 if (value > 100) { 7480 higherValue = Integer.valueOf(higherKey); 7481 assertEquals(value - 1, higherValue); 7482 } else { 7483 assertNull(higherKey); 7484 } 7485 } 7486 7487 key = new Integer(99999).toString(); 7488 higherKey = (String) descendingKeySet.higher(key); 7489 assertEquals("108", higherKey); 7490 7491 key = new Integer(-1).toString(); 7492 higherKey = (String) descendingKeySet.higher(key); 7493 assertNull(higherKey); 7494 7495 key = new Integer(100).toString(); 7496 higherKey = (String) descendingKeySet.higher(key); 7497 assertNull(higherKey); 7498 7499 key = new Integer(2).toString(); 7500 higherKey = (String) descendingKeySet.higher(key); 7501 assertEquals(108, Integer.parseInt(higherKey)); 7502 7503 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 7504 .navigableKeySet(); 7505 descendingKeySet = keySet.descendingSet(); 7506 iterator = descendingKeySet.iterator(); 7507 while (iterator.hasNext()) { 7508 key = (String) iterator.next(); 7509 value = Integer.valueOf(key); 7510 higherKey = (String) descendingKeySet.higher(key); 7511 if (value > 100) { 7512 higherValue = Integer.valueOf(higherKey); 7513 assertEquals(value - 1, higherValue); 7514 } else { 7515 assertNull(higherKey); 7516 } 7517 } 7518 7519 key = new Integer(99999).toString(); 7520 higherKey = (String) descendingKeySet.higher(key); 7521 assertEquals("109", higherKey); 7522 7523 key = new Integer(-1).toString(); 7524 higherKey = (String) descendingKeySet.higher(key); 7525 assertNull(higherKey); 7526 7527 key = new Integer(100).toString(); 7528 higherKey = (String) descendingKeySet.higher(key); 7529 assertNull(higherKey); 7530 7531 key = new Integer(2).toString(); 7532 higherKey = (String) descendingKeySet.higher(key); 7533 assertEquals(109, Integer.parseInt(higherKey)); 7534 7535 key = new Integer(2).toString(); 7536 keySet = tm.headMap(key, true).navigableKeySet(); 7537 descendingKeySet = keySet.descendingSet(); 7538 iterator = descendingKeySet.iterator(); 7539 key = (String) iterator.next(); 7540 higherKey = (String) descendingKeySet.higher(key); 7541 assertEquals(new Integer(199).toString(), higherKey); 7542 try { 7543 descendingKeySet.higher(null); 7544 fail("should throw NPE"); 7545 } catch (NullPointerException e) { 7546 // Expected 7547 } 7548 7549 key = new Integer(0).toString(); 7550 endKey = key; 7551 7552 keySet = tm.headMap(endKey, true).navigableKeySet(); 7553 descendingKeySet = keySet.descendingSet(); 7554 assertNull(descendingKeySet.higher(endKey)); 7555 7556 key = new Integer(0).toString(); 7557 keySet = tm.headMap(endKey, false).navigableKeySet(); 7558 descendingKeySet = keySet.descendingSet(); 7559 assertNull(descendingKeySet.higher(endKey)); 7560 7561 endKey = new Integer(999).toString(); 7562 keySet = tm.headMap(endKey, true).navigableKeySet(); 7563 descendingKeySet = keySet.descendingSet(); 7564 assertEquals(new Integer(998).toString(), descendingKeySet 7565 .higher(endKey)); 7566 assertNull(descendingKeySet.higher(key)); 7567 7568 endKey = new Integer(999).toString(); 7569 keySet = tm.headMap(endKey, false).navigableKeySet(); 7570 descendingKeySet = keySet.descendingSet(); 7571 assertEquals(new Integer(998).toString(), descendingKeySet 7572 .higher(endKey)); 7573 assertNull(descendingKeySet.higher(key)); 7574 } 7575 7576 public void test_DescendingSubMapKeySet_ceiling() { 7577 NavigableSet keySet, descendingKeySet; 7578 String[] keyArray; 7579 String key, ceilingKey; 7580 7581 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7582 descendingKeySet = keySet.descendingSet(); 7583 keyArray = (String[]) descendingKeySet 7584 .toArray(new String[descendingKeySet.size()]); 7585 for (int i = 0, j = 108; i < keyArray.length; i++) { 7586 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7587 assertEquals(new Integer(j - i).toString(), ceilingKey); 7588 } 7589 7590 key = new Integer(2).toString(); 7591 ceilingKey = (String) descendingKeySet.ceiling(key); 7592 assertEquals(108, Integer.parseInt(ceilingKey)); 7593 7594 key = new Integer(0).toString(); 7595 ceilingKey = (String) descendingKeySet.ceiling(key); 7596 assertNull(ceilingKey); 7597 7598 key = new Integer(-1).toString(); 7599 ceilingKey = (String) descendingKeySet.ceiling(key); 7600 assertNull(ceilingKey); 7601 7602 key = new Integer(99999).toString(); 7603 ceilingKey = (String) descendingKeySet.ceiling(key); 7604 assertEquals(108, Integer.parseInt(ceilingKey)); 7605 7606 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7607 descendingKeySet = keySet.descendingSet(); 7608 keyArray = (String[]) descendingKeySet 7609 .toArray(new String[descendingKeySet.size()]); 7610 for (int i = 0, j = 109; i < keyArray.length; i++) { 7611 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7612 assertEquals(new Integer(j - i).toString(), ceilingKey); 7613 } 7614 7615 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7616 descendingKeySet = keySet.descendingSet(); 7617 keyArray = (String[]) descendingKeySet 7618 .toArray(new String[descendingKeySet.size()]); 7619 for (int i = 0, j = 108; i < keyArray.length; i++) { 7620 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7621 assertEquals(new Integer(j - i).toString(), ceilingKey); 7622 } 7623 7624 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7625 descendingKeySet = keySet.descendingSet(); 7626 keyArray = (String[]) descendingKeySet 7627 .toArray(new String[descendingKeySet.size()]); 7628 for (int i = 0, j = 109; i < keyArray.length; i++) { 7629 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7630 assertEquals(new Integer(j - i).toString(), ceilingKey); 7631 } 7632 7633 key = new Integer(2).toString(); 7634 keySet = tm.headMap(key, true).navigableKeySet(); 7635 descendingKeySet = keySet.descendingSet(); 7636 Iterator iterator = descendingKeySet.iterator(); 7637 assertEquals(key, descendingKeySet.ceiling(iterator.next())); 7638 try { 7639 descendingKeySet.ceiling(null); 7640 fail("should throw NPE"); 7641 } catch (NullPointerException e) { 7642 // Expected 7643 } 7644 7645 key = new Integer(0).toString(); 7646 String endKey = key; 7647 7648 keySet = tm.headMap(endKey, true).navigableKeySet(); 7649 descendingKeySet = keySet.descendingSet(); 7650 assertEquals(key, descendingKeySet.ceiling(endKey)); 7651 7652 key = new Integer(0).toString(); 7653 keySet = tm.headMap(endKey, false).navigableKeySet(); 7654 descendingKeySet = keySet.descendingSet(); 7655 assertNull(descendingKeySet.ceiling(endKey)); 7656 7657 endKey = new Integer(999).toString(); 7658 keySet = tm.headMap(endKey, true).navigableKeySet(); 7659 descendingKeySet = keySet.descendingSet(); 7660 assertEquals(new Integer(999).toString(), descendingKeySet 7661 .ceiling(endKey)); 7662 assertEquals(key, descendingKeySet.ceiling(key)); 7663 7664 endKey = new Integer(999).toString(); 7665 keySet = tm.headMap(endKey, false).navigableKeySet(); 7666 descendingKeySet = keySet.descendingSet(); 7667 assertEquals(new Integer(998).toString(), descendingKeySet 7668 .ceiling(endKey)); 7669 assertEquals(key, descendingKeySet.ceiling(key)); 7670 7671 // With Comparator 7672 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7673 .navigableKeySet(); 7674 descendingKeySet = keySet.descendingSet(); 7675 keyArray = (String[]) descendingKeySet 7676 .toArray(new String[descendingKeySet.size()]); 7677 for (int i = 0, j = 108; i < keyArray.length; i++) { 7678 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7679 assertEquals(new Integer(j - i).toString(), ceilingKey); 7680 } 7681 7682 key = new Integer(2).toString(); 7683 ceilingKey = (String) descendingKeySet.ceiling(key); 7684 assertEquals(108, Integer.parseInt(ceilingKey)); 7685 7686 key = new Integer(0).toString(); 7687 ceilingKey = (String) descendingKeySet.ceiling(key); 7688 assertNull(ceilingKey); 7689 7690 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7691 .navigableKeySet(); 7692 descendingKeySet = keySet.descendingSet(); 7693 keyArray = (String[]) descendingKeySet 7694 .toArray(new String[descendingKeySet.size()]); 7695 for (int i = 0, j = 109; i < keyArray.length; i++) { 7696 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7697 assertEquals(new Integer(j - i).toString(), ceilingKey); 7698 } 7699 7700 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7701 .navigableKeySet(); 7702 descendingKeySet = keySet.descendingSet(); 7703 keyArray = (String[]) descendingKeySet 7704 .toArray(new String[descendingKeySet.size()]); 7705 for (int i = 0, j = 108; i < keyArray.length; i++) { 7706 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7707 assertEquals(new Integer(j - i).toString(), ceilingKey); 7708 } 7709 7710 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 7711 .navigableKeySet(); 7712 descendingKeySet = keySet.descendingSet(); 7713 keyArray = (String[]) descendingKeySet 7714 .toArray(new String[descendingKeySet.size()]); 7715 for (int i = 0, j = 109; i < keyArray.length; i++) { 7716 ceilingKey = (String) descendingKeySet.ceiling(keyArray[i]); 7717 assertEquals(new Integer(j - i).toString(), ceilingKey); 7718 } 7719 } 7720 7721 public void test_DescendingSubMapKeySet_floor() { 7722 NavigableSet keySet, descendingKeySet; 7723 String[] keyArray; 7724 String floorKey; 7725 7726 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7727 descendingKeySet = keySet.descendingSet(); 7728 keyArray = (String[]) descendingKeySet 7729 .toArray(new String[descendingKeySet.size()]); 7730 for (int i = 0, j = 108; i < keyArray.length; i++) { 7731 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7732 assertEquals(new Integer(j - i).toString(), floorKey); 7733 } 7734 7735 String key = new Integer(0).toString(); 7736 floorKey = (String) descendingKeySet.floor(key); 7737 assertEquals(101, Integer.parseInt(floorKey)); 7738 7739 key = new Integer(2).toString(); 7740 floorKey = (String) descendingKeySet.floor(key); 7741 assertNull(floorKey); 7742 7743 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7744 descendingKeySet = keySet.descendingSet(); 7745 keyArray = (String[]) descendingKeySet 7746 .toArray(new String[descendingKeySet.size()]); 7747 for (int i = 0, j = 109; i < keyArray.length; i++) { 7748 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7749 assertEquals(new Integer(j - i).toString(), floorKey); 7750 } 7751 7752 key = new Integer(0).toString(); 7753 floorKey = (String) descendingKeySet.floor(key); 7754 assertEquals(101, Integer.parseInt(floorKey)); 7755 7756 key = new Integer(2).toString(); 7757 floorKey = (String) descendingKeySet.floor(key); 7758 assertNull(floorKey); 7759 7760 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7761 descendingKeySet = keySet.descendingSet(); 7762 keyArray = (String[]) descendingKeySet 7763 .toArray(new String[descendingKeySet.size()]); 7764 for (int i = 0, j = 108; i < keyArray.length; i++) { 7765 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7766 assertEquals(new Integer(j - i).toString(), floorKey); 7767 } 7768 7769 key = new Integer(0).toString(); 7770 floorKey = (String) descendingKeySet.floor(key); 7771 assertEquals(100, Integer.parseInt(floorKey)); 7772 7773 key = new Integer(2).toString(); 7774 floorKey = (String) descendingKeySet.floor(key); 7775 assertNull(floorKey); 7776 7777 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7778 descendingKeySet = keySet.descendingSet(); 7779 keyArray = (String[]) descendingKeySet 7780 .toArray(new String[descendingKeySet.size()]); 7781 for (int i = 0, j = 109; i < keyArray.length; i++) { 7782 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7783 assertEquals(new Integer(j - i).toString(), floorKey); 7784 } 7785 7786 key = new Integer(0).toString(); 7787 floorKey = (String) descendingKeySet.floor(key); 7788 assertEquals(100, Integer.parseInt(floorKey)); 7789 7790 key = new Integer(2).toString(); 7791 floorKey = (String) descendingKeySet.floor(key); 7792 assertNull(floorKey); 7793 7794 key = new Integer(2).toString(); 7795 keySet = tm.headMap(key, true).navigableKeySet(); 7796 descendingKeySet = keySet.descendingSet(); 7797 Iterator iterator = descendingKeySet.iterator(); 7798 assertEquals(key, descendingKeySet.floor(iterator.next())); 7799 try { 7800 descendingKeySet.floor(null); 7801 fail("should throw NPE"); 7802 } catch (NullPointerException e) { 7803 // Expected 7804 } 7805 7806 key = new Integer(0).toString(); 7807 String endKey = key; 7808 7809 keySet = tm.headMap(endKey, true).navigableKeySet(); 7810 descendingKeySet = keySet.descendingSet(); 7811 assertEquals(key, descendingKeySet.floor(endKey)); 7812 7813 key = new Integer(0).toString(); 7814 keySet = tm.headMap(endKey, false).navigableKeySet(); 7815 descendingKeySet = keySet.descendingSet(); 7816 assertNull(descendingKeySet.floor(endKey)); 7817 7818 endKey = new Integer(999).toString(); 7819 keySet = tm.headMap(endKey, true).navigableKeySet(); 7820 descendingKeySet = keySet.descendingSet(); 7821 assertEquals(new Integer(999).toString(), descendingKeySet 7822 .floor(endKey)); 7823 assertEquals(key, descendingKeySet.floor(key)); 7824 7825 endKey = new Integer(999).toString(); 7826 keySet = tm.headMap(endKey, false).navigableKeySet(); 7827 descendingKeySet = keySet.descendingSet(); 7828 assertNull(descendingKeySet.floor(endKey)); 7829 assertEquals(key, descendingKeySet.floor(key)); 7830 7831 // With Comparator 7832 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 7833 .navigableKeySet(); 7834 descendingKeySet = keySet.descendingSet(); 7835 keyArray = (String[]) descendingKeySet 7836 .toArray(new String[descendingKeySet.size()]); 7837 for (int i = 0, j = 108; i < keyArray.length; i++) { 7838 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7839 assertEquals(new Integer(j - i).toString(), floorKey); 7840 } 7841 7842 key = new Integer(0).toString(); 7843 floorKey = (String) descendingKeySet.floor(key); 7844 assertEquals(101, Integer.parseInt(floorKey)); 7845 7846 key = new Integer(2).toString(); 7847 floorKey = (String) descendingKeySet.floor(key); 7848 assertNull(floorKey); 7849 7850 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 7851 .navigableKeySet(); 7852 descendingKeySet = keySet.descendingSet(); 7853 keyArray = (String[]) descendingKeySet 7854 .toArray(new String[descendingKeySet.size()]); 7855 for (int i = 0, j = 109; i < keyArray.length; i++) { 7856 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7857 assertEquals(new Integer(j - i).toString(), floorKey); 7858 } 7859 7860 key = new Integer(0).toString(); 7861 floorKey = (String) descendingKeySet.floor(key); 7862 assertEquals(101, Integer.parseInt(floorKey)); 7863 7864 key = new Integer(2).toString(); 7865 floorKey = (String) descendingKeySet.floor(key); 7866 assertNull(floorKey); 7867 7868 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 7869 .navigableKeySet(); 7870 descendingKeySet = keySet.descendingSet(); 7871 keyArray = (String[]) descendingKeySet 7872 .toArray(new String[descendingKeySet.size()]); 7873 for (int i = 0, j = 108; i < keyArray.length; i++) { 7874 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7875 assertEquals(new Integer(j - i).toString(), floorKey); 7876 } 7877 7878 key = new Integer(0).toString(); 7879 floorKey = (String) descendingKeySet.floor(key); 7880 assertEquals(100, Integer.parseInt(floorKey)); 7881 7882 key = new Integer(2).toString(); 7883 floorKey = (String) descendingKeySet.floor(key); 7884 assertNull(floorKey); 7885 7886 keySet = ((NavigableMap) subMap_startIncluded_endIncluded) 7887 .navigableKeySet(); 7888 descendingKeySet = keySet.descendingSet(); 7889 keyArray = (String[]) descendingKeySet 7890 .toArray(new String[descendingKeySet.size()]); 7891 for (int i = 0, j = 109; i < keyArray.length; i++) { 7892 floorKey = (String) descendingKeySet.floor(keyArray[i]); 7893 assertEquals(new Integer(j - i).toString(), floorKey); 7894 } 7895 7896 key = new Integer(0).toString(); 7897 floorKey = (String) descendingKeySet.floor(key); 7898 assertEquals(100, Integer.parseInt(floorKey)); 7899 7900 key = new Integer(2).toString(); 7901 floorKey = (String) descendingKeySet.floor(key); 7902 assertNull(floorKey); 7903 } 7904 7905 public void test_AscendingSubMapKeySet_last() { 7906 NavigableSet keySet; 7907 String firstKey1 = new Integer(108).toString(); 7908 String firstKey2 = new Integer(109).toString(); 7909 7910 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7911 assertEquals(firstKey1, keySet.last()); 7912 7913 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7914 assertEquals(firstKey2, keySet.last()); 7915 7916 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7917 assertEquals(firstKey1, keySet.last()); 7918 7919 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7920 assertEquals(firstKey2, keySet.last()); 7921 } 7922 7923 public void test_AscendingSubMapKeySet_comparator() { 7924 NavigableSet keySet; 7925 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 7926 assertNull(keySet.comparator()); 7927 7928 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 7929 assertNull(keySet.comparator()); 7930 7931 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 7932 assertNull(keySet.comparator()); 7933 7934 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 7935 assertNull(keySet.comparator()); 7936 7937 String endKey = new Integer(2).toString(); 7938 keySet = tm.headMap(endKey, true).navigableKeySet(); 7939 assertNull(keySet.comparator()); 7940 } 7941 7942 public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endExcluded() { 7943 NavigableSet keySet = navigableMap_startExcluded_endExcluded 7944 .navigableKeySet(); 7945 Iterator iterator = keySet.iterator(); 7946 assertEquals(8, keySet.size()); 7947 for (int value = 101; value < 109; value++) { 7948 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 7949 } 7950 assertEquals(0, keySet.size()); 7951 assertNull(keySet.pollFirst()); 7952 } 7953 7954 public void test_AscendingSubMapKeySet_pollFirst_startExcluded_endIncluded() { 7955 NavigableSet keySet = navigableMap_startExcluded_endIncluded 7956 .navigableKeySet(); 7957 Iterator iterator = keySet.iterator(); 7958 assertEquals(9, keySet.size()); 7959 for (int value = 101; value < 110; value++) { 7960 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 7961 } 7962 assertEquals(0, keySet.size()); 7963 assertNull(keySet.pollFirst()); 7964 } 7965 7966 public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endExcluded() { 7967 NavigableSet keySet = navigableMap_startIncluded_endExcluded 7968 .navigableKeySet(); 7969 Iterator iterator = keySet.iterator(); 7970 assertEquals(9, keySet.size()); 7971 for (int value = 100; value < 109; value++) { 7972 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 7973 } 7974 assertEquals(0, keySet.size()); 7975 assertNull(keySet.pollFirst()); 7976 } 7977 7978 public void test_AscendingSubMapKeySet_pollFirst_startIncluded_endIncluded() { 7979 NavigableSet keySet = navigableMap_startIncluded_endIncluded 7980 .navigableKeySet(); 7981 Iterator iterator = keySet.iterator(); 7982 assertEquals(10, keySet.size()); 7983 for (int value = 100; value < 110; value++) { 7984 assertEquals(new Integer(value).toString(), keySet.pollFirst()); 7985 } 7986 assertEquals(0, keySet.size()); 7987 assertNull(keySet.pollFirst()); 7988 } 7989 7990 public void test_AscendingSubMapKeySet_pollFirst() { 7991 String endKey = new Integer(2).toString(); 7992 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 7993 assertEquals(new Integer(0).toString(), keySet.pollFirst()); 7994 7995 keySet = tm.tailMap(endKey, true).navigableKeySet(); 7996 assertEquals(new Integer(2).toString(), keySet.pollFirst()); 7997 } 7998 7999 public void test_AscendingSubMapKeySet_pollLast_startExcluded_endExcluded() { 8000 NavigableSet keySet = navigableMap_startExcluded_endExcluded 8001 .navigableKeySet(); 8002 Iterator iterator = keySet.iterator(); 8003 assertEquals(8, keySet.size()); 8004 for (int value = 108; value > 100; value--) { 8005 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8006 } 8007 assertEquals(0, keySet.size()); 8008 assertNull(keySet.pollLast()); 8009 } 8010 8011 public void test_AscendingSubMapKeySet_pollLast_startExcluded_endIncluded() { 8012 NavigableSet keySet = navigableMap_startExcluded_endIncluded 8013 .navigableKeySet(); 8014 Iterator iterator = keySet.iterator(); 8015 assertEquals(9, keySet.size()); 8016 for (int value = 109; value > 100; value--) { 8017 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8018 } 8019 assertEquals(0, keySet.size()); 8020 assertNull(keySet.pollLast()); 8021 } 8022 8023 public void test_AscendingSubMapKeySet_pollLast_startIncluded_endExcluded() { 8024 NavigableSet keySet = navigableMap_startIncluded_endExcluded 8025 .navigableKeySet(); 8026 Iterator iterator = keySet.iterator(); 8027 assertEquals(9, keySet.size()); 8028 for (int value = 108; value > 99; value--) { 8029 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8030 } 8031 assertEquals(0, keySet.size()); 8032 assertNull(keySet.pollLast()); 8033 } 8034 8035 public void test_AscendingSubMapKeySet_pollLast_startIncluded_endIncluded() { 8036 NavigableSet keySet = navigableMap_startIncluded_endIncluded 8037 .navigableKeySet(); 8038 Iterator iterator = keySet.iterator(); 8039 assertEquals(10, keySet.size()); 8040 for (int value = 109; value > 99; value--) { 8041 assertEquals(new Integer(value).toString(), keySet.pollLast()); 8042 } 8043 assertEquals(0, keySet.size()); 8044 assertNull(keySet.pollLast()); 8045 } 8046 8047 public void test_AscendingSubMapKeySet_pollLast() { 8048 String endKey = new Integer(2).toString(); 8049 NavigableSet keySet = tm.headMap(endKey, true).navigableKeySet(); 8050 assertEquals(new Integer(2).toString(), keySet.pollLast()); 8051 8052 keySet = tm.tailMap(endKey, true).navigableKeySet(); 8053 assertEquals(new Integer(999).toString(), keySet.pollLast()); 8054 } 8055 8056 public void test_AscendingSubMapKeySet_descendingIterator() { 8057 NavigableSet keySet; 8058 Iterator iterator; 8059 8060 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 8061 iterator = keySet.descendingIterator(); 8062 for (int value = 108; value > 100; value--) { 8063 assertTrue(iterator.hasNext()); 8064 assertEquals(new Integer(value).toString(), iterator.next()); 8065 } 8066 assertFalse(iterator.hasNext()); 8067 try { 8068 iterator.next(); 8069 fail("should throw NoSuchElementException"); 8070 } catch (NoSuchElementException e) { 8071 // Expected 8072 } 8073 8074 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 8075 iterator = keySet.descendingIterator(); 8076 for (int value = 109; value > 100; value--) { 8077 assertTrue(iterator.hasNext()); 8078 assertEquals(new Integer(value).toString(), iterator.next()); 8079 } 8080 assertFalse(iterator.hasNext()); 8081 try { 8082 iterator.next(); 8083 fail("should throw NoSuchElementException"); 8084 } catch (NoSuchElementException e) { 8085 // Expected 8086 } 8087 8088 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 8089 iterator = keySet.descendingIterator(); 8090 for (int value = 108; value > 99; value--) { 8091 assertTrue(iterator.hasNext()); 8092 assertEquals(new Integer(value).toString(), iterator.next()); 8093 } 8094 assertFalse(iterator.hasNext()); 8095 try { 8096 iterator.next(); 8097 fail("should throw NoSuchElementException"); 8098 } catch (NoSuchElementException e) { 8099 // Expected 8100 } 8101 8102 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 8103 iterator = keySet.descendingIterator(); 8104 for (int value = 109; value > 99; value--) { 8105 assertTrue(iterator.hasNext()); 8106 assertEquals(new Integer(value).toString(), iterator.next()); 8107 } 8108 assertFalse(iterator.hasNext()); 8109 try { 8110 iterator.next(); 8111 fail("should throw NoSuchElementException"); 8112 } catch (NoSuchElementException e) { 8113 // Expected 8114 } 8115 8116 String endKey = new Integer(2).toString(); 8117 keySet = tm.headMap(endKey, true).navigableKeySet(); 8118 iterator = keySet.descendingIterator(); 8119 assertEquals(new Integer(2).toString(), iterator.next()); 8120 assertEquals(new Integer(199).toString(), iterator.next()); 8121 } 8122 8123 public void test_AscendingSubMapKeySet_descendingSet() { 8124 NavigableSet keySet, descendingSet; 8125 Iterator iterator; 8126 8127 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet() 8128 .descendingSet(); 8129 descendingSet = keySet.descendingSet(); 8130 iterator = descendingSet.iterator(); 8131 for (int value = 101; value < 109; value++) { 8132 assertTrue(iterator.hasNext()); 8133 assertEquals(new Integer(value).toString(), iterator.next()); 8134 } 8135 assertFalse(iterator.hasNext()); 8136 try { 8137 iterator.next(); 8138 fail("should throw NoSuchElementException"); 8139 } catch (NoSuchElementException e) { 8140 // Expected 8141 } 8142 8143 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet() 8144 .descendingSet(); 8145 descendingSet = keySet.descendingSet(); 8146 iterator = descendingSet.iterator(); 8147 for (int value = 101; value < 110; value++) { 8148 assertTrue(iterator.hasNext()); 8149 assertEquals(new Integer(value).toString(), iterator.next()); 8150 } 8151 assertFalse(iterator.hasNext()); 8152 try { 8153 iterator.next(); 8154 fail("should throw NoSuchElementException"); 8155 } catch (NoSuchElementException e) { 8156 // Expected 8157 } 8158 8159 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet() 8160 .descendingSet(); 8161 descendingSet = keySet.descendingSet(); 8162 iterator = descendingSet.iterator(); 8163 for (int value = 100; value < 109; value++) { 8164 assertTrue(iterator.hasNext()); 8165 assertEquals(new Integer(value).toString(), iterator.next()); 8166 } 8167 assertFalse(iterator.hasNext()); 8168 try { 8169 iterator.next(); 8170 fail("should throw NoSuchElementException"); 8171 } catch (NoSuchElementException e) { 8172 // Expected 8173 } 8174 8175 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet() 8176 .descendingSet(); 8177 descendingSet = keySet.descendingSet(); 8178 iterator = descendingSet.iterator(); 8179 for (int value = 100; value < 110; value++) { 8180 assertTrue(iterator.hasNext()); 8181 assertEquals(new Integer(value).toString(), iterator.next()); 8182 } 8183 assertFalse(iterator.hasNext()); 8184 try { 8185 iterator.next(); 8186 fail("should throw NoSuchElementException"); 8187 } catch (NoSuchElementException e) { 8188 // Expected 8189 } 8190 8191 String endKey = new Integer(1).toString(); 8192 keySet = tm.headMap(endKey, true).navigableKeySet(); 8193 descendingSet = keySet.descendingSet(); 8194 iterator = descendingSet.iterator(); 8195 assertEquals(new Integer(1).toString(), iterator.next()); 8196 assertEquals(new Integer(0).toString(), iterator.next()); 8197 } 8198 8199 public void test_AscendingSubMapKeySet_headSet() { 8200 NavigableSet keySet; 8201 SortedSet headSet; 8202 String endKey, key; 8203 Iterator iterator; 8204 8205 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 8206 endKey = new Integer(99).toString(); 8207 try { 8208 keySet.headSet(endKey); 8209 fail("should throw IllegalArgumentException"); 8210 } catch (IllegalArgumentException e) { 8211 // Expected 8212 } 8213 try { 8214 keySet.headSet(endKey, false); 8215 fail("should throw IllegalArgumentException"); 8216 } catch (IllegalArgumentException e) { 8217 // Expected 8218 } 8219 try { 8220 keySet.headSet(endKey, true); 8221 fail("should throw IllegalArgumentException"); 8222 } catch (IllegalArgumentException e) { 8223 // Expected 8224 } 8225 8226 endKey = new Integer(100).toString(); 8227 assertEquals(0, keySet.headSet(endKey).size()); 8228 assertEquals(0, keySet.headSet(endKey, false).size()); 8229 try { 8230 keySet.headSet(endKey, true).size(); 8231 fail("should throw IllegalArgumentException"); 8232 } catch (IllegalArgumentException e) { 8233 // Expected 8234 } 8235 8236 endKey = new Integer(101).toString(); 8237 assertEquals(0, keySet.headSet(endKey).size()); 8238 assertEquals(0, keySet.headSet(endKey, false).size()); 8239 assertEquals(1, keySet.headSet(endKey, true).size()); 8240 8241 for (int i = 102; i < 109; i++) { 8242 endKey = new Integer(i).toString(); 8243 headSet = keySet.headSet(endKey); 8244 iterator = headSet.iterator(); 8245 int j; 8246 for (j = 101; iterator.hasNext(); j++) { 8247 key = (String) iterator.next(); 8248 assertEquals(new Integer(j).toString(), key); 8249 } 8250 assertEquals(i, j); 8251 8252 headSet = keySet.headSet(endKey, false); 8253 iterator = headSet.iterator(); 8254 for (j = 101; iterator.hasNext(); j++) { 8255 key = (String) iterator.next(); 8256 assertEquals(new Integer(j).toString(), key); 8257 } 8258 assertEquals(i, j); 8259 8260 headSet = keySet.headSet(endKey, true); 8261 iterator = headSet.iterator(); 8262 for (j = 101; iterator.hasNext(); j++) { 8263 key = (String) iterator.next(); 8264 assertEquals(new Integer(j).toString(), key); 8265 } 8266 assertEquals(i + 1, j); 8267 } 8268 8269 endKey = new Integer(109).toString(); 8270 headSet = keySet.headSet(endKey); 8271 iterator = headSet.iterator(); 8272 int index; 8273 for (index = 101; iterator.hasNext(); index++) { 8274 key = (String) iterator.next(); 8275 assertEquals(new Integer(index).toString(), key); 8276 } 8277 assertEquals(109, index); 8278 8279 headSet = keySet.headSet(endKey, false); 8280 iterator = headSet.iterator(); 8281 for (index = 101; iterator.hasNext(); index++) { 8282 key = (String) iterator.next(); 8283 assertEquals(new Integer(index).toString(), key); 8284 } 8285 assertEquals(109, index); 8286 8287 try { 8288 keySet.headSet(endKey, true); 8289 fail("should throw IllegalArgumentException"); 8290 } catch (IllegalArgumentException e) { 8291 // Expected 8292 } 8293 8294 endKey = new Integer(110).toString(); 8295 try { 8296 keySet.headSet(endKey); 8297 fail("should throw IllegalArgumentException"); 8298 } catch (IllegalArgumentException e) { 8299 // Expected 8300 } 8301 try { 8302 keySet.headSet(endKey, true); 8303 fail("should throw IllegalArgumentException"); 8304 } catch (IllegalArgumentException e) { 8305 // Expected 8306 } 8307 try { 8308 keySet.headSet(endKey, false); 8309 fail("should throw IllegalArgumentException"); 8310 } catch (IllegalArgumentException e) { 8311 // Expected 8312 } 8313 8314 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 8315 endKey = new Integer(99).toString(); 8316 try { 8317 keySet.headSet(endKey); 8318 fail("should throw IllegalArgumentException"); 8319 } catch (IllegalArgumentException e) { 8320 // Expected 8321 } 8322 try { 8323 keySet.headSet(endKey, true); 8324 fail("should throw IllegalArgumentException"); 8325 } catch (IllegalArgumentException e) { 8326 // Expected 8327 } 8328 try { 8329 keySet.headSet(endKey, false); 8330 fail("should throw IllegalArgumentException"); 8331 } catch (IllegalArgumentException e) { 8332 // Expected 8333 } 8334 8335 endKey = new Integer(100).toString(); 8336 assertEquals(0, keySet.headSet(endKey).size()); 8337 assertEquals(0, keySet.headSet(endKey, false).size()); 8338 try { 8339 keySet.headSet(endKey, true); 8340 fail("should throw IllegalArgumentException"); 8341 } catch (IllegalArgumentException e) { 8342 // Expected 8343 } 8344 8345 endKey = new Integer(101).toString(); 8346 assertEquals(0, keySet.headSet(endKey).size()); 8347 assertEquals(0, keySet.headSet(endKey).size()); 8348 assertEquals(1, keySet.headSet(endKey, true).size()); 8349 8350 for (int i = 102; i < 109; i++) { 8351 endKey = new Integer(i).toString(); 8352 8353 headSet = keySet.headSet(endKey); 8354 iterator = headSet.iterator(); 8355 int j; 8356 for (j = 101; iterator.hasNext(); j++) { 8357 key = (String) iterator.next(); 8358 assertEquals(new Integer(j).toString(), key); 8359 } 8360 assertEquals(i, j); 8361 8362 headSet = keySet.headSet(endKey, false); 8363 iterator = headSet.iterator(); 8364 for (j = 101; iterator.hasNext(); j++) { 8365 key = (String) iterator.next(); 8366 assertEquals(new Integer(j).toString(), key); 8367 } 8368 assertEquals(i, j); 8369 8370 headSet = keySet.headSet(endKey, true); 8371 iterator = headSet.iterator(); 8372 for (j = 101; iterator.hasNext(); j++) { 8373 key = (String) iterator.next(); 8374 assertEquals(new Integer(j).toString(), key); 8375 } 8376 assertEquals(i + 1, j); 8377 } 8378 8379 endKey = new Integer(109).toString(); 8380 headSet = keySet.headSet(endKey); 8381 iterator = headSet.iterator(); 8382 for (index = 101; iterator.hasNext(); index++) { 8383 key = (String) iterator.next(); 8384 assertEquals(new Integer(index).toString(), key); 8385 } 8386 assertEquals(109, index); 8387 8388 headSet = keySet.headSet(endKey, false); 8389 iterator = headSet.iterator(); 8390 for (index = 101; iterator.hasNext(); index++) { 8391 key = (String) iterator.next(); 8392 assertEquals(new Integer(index).toString(), key); 8393 } 8394 assertEquals(109, index); 8395 8396 headSet = keySet.headSet(endKey, true); 8397 iterator = headSet.iterator(); 8398 for (index = 101; iterator.hasNext(); index++) { 8399 key = (String) iterator.next(); 8400 assertEquals(new Integer(index).toString(), key); 8401 } 8402 assertEquals(110, index); 8403 8404 endKey = new Integer(110).toString(); 8405 try { 8406 keySet.headSet(endKey); 8407 fail("should throw IllegalArgumentException"); 8408 } catch (IllegalArgumentException e) { 8409 // Expected 8410 } 8411 try { 8412 keySet.headSet(endKey, false); 8413 fail("should throw IllegalArgumentException"); 8414 } catch (IllegalArgumentException e) { 8415 // Expected 8416 } 8417 try { 8418 keySet.headSet(endKey, true); 8419 fail("should throw IllegalArgumentException"); 8420 } catch (IllegalArgumentException e) { 8421 // Expected 8422 } 8423 8424 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 8425 endKey = new Integer(99).toString(); 8426 try { 8427 keySet.headSet(endKey); 8428 fail("should throw IllegalArgumentException"); 8429 } catch (IllegalArgumentException e) { 8430 // Expected 8431 } 8432 try { 8433 keySet.headSet(endKey, false); 8434 fail("should throw IllegalArgumentException"); 8435 } catch (IllegalArgumentException e) { 8436 // Expected 8437 } 8438 try { 8439 keySet.headSet(endKey, true); 8440 fail("should throw IllegalArgumentException"); 8441 } catch (IllegalArgumentException e) { 8442 // Expected 8443 } 8444 8445 endKey = new Integer(100).toString(); 8446 assertEquals(0, keySet.headSet(endKey).size()); 8447 assertEquals(0, keySet.headSet(endKey, false).size()); 8448 assertEquals(1, keySet.headSet(endKey, true).size()); 8449 8450 endKey = new Integer(101).toString(); 8451 headSet = keySet.headSet(endKey); 8452 iterator = headSet.iterator(); 8453 for (index = 100; iterator.hasNext(); index++) { 8454 key = (String) iterator.next(); 8455 assertEquals(new Integer(index).toString(), key); 8456 } 8457 assertEquals(101, index); 8458 8459 headSet = keySet.headSet(endKey, false); 8460 iterator = headSet.iterator(); 8461 for (index = 100; iterator.hasNext(); index++) { 8462 key = (String) iterator.next(); 8463 assertEquals(new Integer(index).toString(), key); 8464 } 8465 assertEquals(101, index); 8466 8467 headSet = keySet.headSet(endKey, true); 8468 iterator = headSet.iterator(); 8469 for (index = 100; iterator.hasNext(); index++) { 8470 key = (String) iterator.next(); 8471 assertEquals(new Integer(index).toString(), key); 8472 } 8473 assertEquals(102, index); 8474 8475 for (int i = 102; i < 109; i++) { 8476 endKey = new Integer(i).toString(); 8477 8478 headSet = keySet.headSet(endKey); 8479 iterator = headSet.iterator(); 8480 int j; 8481 for (j = 100; iterator.hasNext(); j++) { 8482 key = (String) iterator.next(); 8483 assertEquals(new Integer(j).toString(), key); 8484 } 8485 assertEquals(i, j); 8486 8487 headSet = keySet.headSet(endKey, false); 8488 iterator = headSet.iterator(); 8489 for (j = 100; iterator.hasNext(); j++) { 8490 key = (String) iterator.next(); 8491 assertEquals(new Integer(j).toString(), key); 8492 } 8493 assertEquals(i, j); 8494 8495 headSet = keySet.headSet(endKey, true); 8496 iterator = headSet.iterator(); 8497 for (j = 100; iterator.hasNext(); j++) { 8498 key = (String) iterator.next(); 8499 assertEquals(new Integer(j).toString(), key); 8500 } 8501 assertEquals(i + 1, j); 8502 } 8503 8504 endKey = new Integer(109).toString(); 8505 headSet = keySet.headSet(endKey); 8506 iterator = headSet.iterator(); 8507 for (index = 100; iterator.hasNext(); index++) { 8508 key = (String) iterator.next(); 8509 assertEquals(new Integer(index).toString(), key); 8510 } 8511 assertEquals(109, index); 8512 8513 headSet = keySet.headSet(endKey, false); 8514 iterator = headSet.iterator(); 8515 for (index = 100; iterator.hasNext(); index++) { 8516 key = (String) iterator.next(); 8517 assertEquals(new Integer(index).toString(), key); 8518 } 8519 assertEquals(109, index); 8520 8521 try { 8522 keySet.headSet(endKey, true); 8523 fail("should throw IllegalArgumentException"); 8524 } catch (IllegalArgumentException e) { 8525 // Expected 8526 } 8527 8528 endKey = new Integer(110).toString(); 8529 try { 8530 keySet.headSet(endKey); 8531 fail("should throw IllegalArgumentException"); 8532 } catch (IllegalArgumentException e) { 8533 // Expected 8534 } 8535 8536 try { 8537 keySet.headSet(endKey, false); 8538 fail("should throw IllegalArgumentException"); 8539 } catch (IllegalArgumentException e) { 8540 // Expected 8541 } 8542 8543 try { 8544 keySet.headSet(endKey, true); 8545 fail("should throw IllegalArgumentException"); 8546 } catch (IllegalArgumentException e) { 8547 // Expected 8548 } 8549 8550 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 8551 endKey = new Integer(99).toString(); 8552 try { 8553 keySet.headSet(endKey); 8554 fail("should throw IllegalArgumentException"); 8555 } catch (IllegalArgumentException e) { 8556 // Expected 8557 } 8558 try { 8559 keySet.headSet(endKey, false); 8560 fail("should throw IllegalArgumentException"); 8561 } catch (IllegalArgumentException e) { 8562 // Expected 8563 } 8564 try { 8565 keySet.headSet(endKey, true); 8566 fail("should throw IllegalArgumentException"); 8567 } catch (IllegalArgumentException e) { 8568 // Expected 8569 } 8570 8571 endKey = new Integer(100).toString(); 8572 assertEquals(0, keySet.headSet(endKey).size()); 8573 assertEquals(0, keySet.headSet(endKey, false).size()); 8574 assertEquals(1, keySet.headSet(endKey, true).size()); 8575 8576 endKey = new Integer(101).toString(); 8577 headSet = keySet.headSet(endKey); 8578 iterator = headSet.iterator(); 8579 for (index = 100; iterator.hasNext(); index++) { 8580 key = (String) iterator.next(); 8581 assertEquals(new Integer(index).toString(), key); 8582 } 8583 assertEquals(101, index); 8584 8585 headSet = keySet.headSet(endKey, false); 8586 iterator = headSet.iterator(); 8587 for (index = 100; iterator.hasNext(); index++) { 8588 key = (String) iterator.next(); 8589 assertEquals(new Integer(index).toString(), key); 8590 } 8591 assertEquals(101, index); 8592 8593 headSet = keySet.headSet(endKey, true); 8594 iterator = headSet.iterator(); 8595 for (index = 100; iterator.hasNext(); index++) { 8596 key = (String) iterator.next(); 8597 assertEquals(new Integer(index).toString(), key); 8598 } 8599 assertEquals(102, index); 8600 8601 for (int i = 102; i < 109; i++) { 8602 endKey = new Integer(i).toString(); 8603 8604 headSet = keySet.headSet(endKey); 8605 iterator = headSet.iterator(); 8606 int j; 8607 for (j = 100; iterator.hasNext(); j++) { 8608 key = (String) iterator.next(); 8609 assertEquals(new Integer(j).toString(), key); 8610 } 8611 assertEquals(i, j); 8612 8613 headSet = keySet.headSet(endKey, false); 8614 iterator = headSet.iterator(); 8615 for (j = 100; iterator.hasNext(); j++) { 8616 key = (String) iterator.next(); 8617 assertEquals(new Integer(j).toString(), key); 8618 } 8619 assertEquals(i, j); 8620 8621 headSet = keySet.headSet(endKey, true); 8622 iterator = headSet.iterator(); 8623 for (j = 100; iterator.hasNext(); j++) { 8624 key = (String) iterator.next(); 8625 assertEquals(new Integer(j).toString(), key); 8626 } 8627 assertEquals(i + 1, j); 8628 } 8629 8630 endKey = new Integer(109).toString(); 8631 headSet = keySet.headSet(endKey); 8632 iterator = headSet.iterator(); 8633 for (index = 100; iterator.hasNext(); index++) { 8634 key = (String) iterator.next(); 8635 assertEquals(new Integer(index).toString(), key); 8636 } 8637 assertEquals(109, index); 8638 8639 headSet = keySet.headSet(endKey, false); 8640 iterator = headSet.iterator(); 8641 for (index = 100; iterator.hasNext(); index++) { 8642 key = (String) iterator.next(); 8643 assertEquals(new Integer(index).toString(), key); 8644 } 8645 assertEquals(109, index); 8646 8647 headSet = keySet.headSet(endKey, true); 8648 iterator = headSet.iterator(); 8649 for (index = 100; iterator.hasNext(); index++) { 8650 key = (String) iterator.next(); 8651 assertEquals(new Integer(index).toString(), key); 8652 } 8653 assertEquals(110, index); 8654 8655 endKey = new Integer(110).toString(); 8656 try { 8657 keySet.headSet(endKey); 8658 fail("should throw IllegalArgumentException"); 8659 } catch (IllegalArgumentException e) { 8660 // Expected 8661 } 8662 try { 8663 keySet.headSet(endKey, false); 8664 fail("should throw IllegalArgumentException"); 8665 } catch (IllegalArgumentException e) { 8666 // Expected 8667 } 8668 try { 8669 keySet.headSet(endKey, true); 8670 fail("should throw IllegalArgumentException"); 8671 } catch (IllegalArgumentException e) { 8672 // Expected 8673 } 8674 8675 key = new Integer(1).toString(); 8676 keySet = tm.headMap(key, true).navigableKeySet(); 8677 iterator = keySet.iterator(); 8678 iterator.next(); 8679 endKey = (String) iterator.next(); 8680 headSet = keySet.headSet(endKey, false); 8681 assertEquals(1, headSet.size()); 8682 Iterator headSetIterator = headSet.iterator(); 8683 assertEquals(new Integer(0).toString(), headSetIterator.next()); 8684 assertFalse(headSetIterator.hasNext()); 8685 try { 8686 headSetIterator.next(); 8687 fail("should throw NoSuchElementException"); 8688 } catch (NoSuchElementException e) { 8689 // Expected 8690 } 8691 try { 8692 keySet.headSet(null, false); 8693 fail("should throw NPE"); 8694 } catch (NullPointerException e) { 8695 // Expected 8696 } 8697 8698 headSet = keySet.headSet(endKey, true); 8699 assertEquals(2, headSet.size()); 8700 headSetIterator = headSet.iterator(); 8701 assertEquals(new Integer(0).toString(), headSetIterator.next()); 8702 assertEquals(new Integer(1).toString(), headSetIterator.next()); 8703 assertFalse(headSetIterator.hasNext()); 8704 try { 8705 headSetIterator.next(); 8706 fail("should throw NoSuchElementException"); 8707 } catch (NoSuchElementException e) { 8708 // Expected 8709 } 8710 try { 8711 keySet.headSet(null, false); 8712 fail("should throw NPE"); 8713 } catch (NullPointerException e) { 8714 // Expected 8715 } 8716 8717 // With Comparator 8718 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 8719 .navigableKeySet(); 8720 endKey = new Integer(99).toString(); 8721 try { 8722 keySet.headSet(endKey); 8723 fail("should throw IllegalArgumentException"); 8724 } catch (IllegalArgumentException e) { 8725 // Expected 8726 } 8727 try { 8728 keySet.headSet(endKey, false); 8729 fail("should throw IllegalArgumentException"); 8730 } catch (IllegalArgumentException e) { 8731 // Expected 8732 } 8733 try { 8734 keySet.headSet(endKey, true); 8735 fail("should throw IllegalArgumentException"); 8736 } catch (IllegalArgumentException e) { 8737 // Expected 8738 } 8739 8740 endKey = new Integer(100).toString(); 8741 assertEquals(0, keySet.headSet(endKey).size()); 8742 assertEquals(0, keySet.headSet(endKey, false).size()); 8743 try { 8744 keySet.headSet(endKey, true).size(); 8745 fail("should throw IllegalArgumentException"); 8746 } catch (IllegalArgumentException e) { 8747 // Expected 8748 } 8749 8750 endKey = new Integer(101).toString(); 8751 assertEquals(0, keySet.headSet(endKey).size()); 8752 assertEquals(0, keySet.headSet(endKey, false).size()); 8753 assertEquals(1, keySet.headSet(endKey, true).size()); 8754 8755 for (int i = 102; i < 109; i++) { 8756 endKey = new Integer(i).toString(); 8757 headSet = keySet.headSet(endKey); 8758 iterator = headSet.iterator(); 8759 int j; 8760 for (j = 101; iterator.hasNext(); j++) { 8761 key = (String) iterator.next(); 8762 assertEquals(new Integer(j).toString(), key); 8763 } 8764 assertEquals(i, j); 8765 8766 headSet = keySet.headSet(endKey, false); 8767 iterator = headSet.iterator(); 8768 for (j = 101; iterator.hasNext(); j++) { 8769 key = (String) iterator.next(); 8770 assertEquals(new Integer(j).toString(), key); 8771 } 8772 assertEquals(i, j); 8773 8774 headSet = keySet.headSet(endKey, true); 8775 iterator = headSet.iterator(); 8776 for (j = 101; iterator.hasNext(); j++) { 8777 key = (String) iterator.next(); 8778 assertEquals(new Integer(j).toString(), key); 8779 } 8780 assertEquals(i + 1, j); 8781 } 8782 8783 endKey = new Integer(109).toString(); 8784 headSet = keySet.headSet(endKey); 8785 iterator = headSet.iterator(); 8786 for (index = 101; iterator.hasNext(); index++) { 8787 key = (String) iterator.next(); 8788 assertEquals(new Integer(index).toString(), key); 8789 } 8790 assertEquals(109, index); 8791 8792 headSet = keySet.headSet(endKey, false); 8793 iterator = headSet.iterator(); 8794 for (index = 101; iterator.hasNext(); index++) { 8795 key = (String) iterator.next(); 8796 assertEquals(new Integer(index).toString(), key); 8797 } 8798 assertEquals(109, index); 8799 8800 try { 8801 keySet.headSet(endKey, true); 8802 fail("should throw IllegalArgumentException"); 8803 } catch (IllegalArgumentException e) { 8804 // Expected 8805 } 8806 8807 endKey = new Integer(110).toString(); 8808 try { 8809 keySet.headSet(endKey); 8810 fail("should throw IllegalArgumentException"); 8811 } catch (IllegalArgumentException e) { 8812 // Expected 8813 } 8814 try { 8815 keySet.headSet(endKey, true); 8816 fail("should throw IllegalArgumentException"); 8817 } catch (IllegalArgumentException e) { 8818 // Expected 8819 } 8820 try { 8821 keySet.headSet(endKey, false); 8822 fail("should throw IllegalArgumentException"); 8823 } catch (IllegalArgumentException e) { 8824 // Expected 8825 } 8826 8827 keySet = ((NavigableMap) subMap_startExcluded_endIncluded_comparator) 8828 .navigableKeySet(); 8829 endKey = new Integer(99).toString(); 8830 try { 8831 keySet.headSet(endKey); 8832 fail("should throw IllegalArgumentException"); 8833 } catch (IllegalArgumentException e) { 8834 // Expected 8835 } 8836 try { 8837 keySet.headSet(endKey, true); 8838 fail("should throw IllegalArgumentException"); 8839 } catch (IllegalArgumentException e) { 8840 // Expected 8841 } 8842 try { 8843 keySet.headSet(endKey, false); 8844 fail("should throw IllegalArgumentException"); 8845 } catch (IllegalArgumentException e) { 8846 // Expected 8847 } 8848 8849 endKey = new Integer(100).toString(); 8850 assertEquals(0, keySet.headSet(endKey).size()); 8851 assertEquals(0, keySet.headSet(endKey, false).size()); 8852 try { 8853 keySet.headSet(endKey, true); 8854 fail("should throw IllegalArgumentException"); 8855 } catch (IllegalArgumentException e) { 8856 // Expected 8857 } 8858 8859 endKey = new Integer(101).toString(); 8860 assertEquals(0, keySet.headSet(endKey).size()); 8861 assertEquals(0, keySet.headSet(endKey).size()); 8862 assertEquals(1, keySet.headSet(endKey, true).size()); 8863 8864 for (int i = 102; i < 109; i++) { 8865 endKey = new Integer(i).toString(); 8866 8867 headSet = keySet.headSet(endKey); 8868 iterator = headSet.iterator(); 8869 int j; 8870 for (j = 101; iterator.hasNext(); j++) { 8871 key = (String) iterator.next(); 8872 assertEquals(new Integer(j).toString(), key); 8873 } 8874 assertEquals(i, j); 8875 8876 headSet = keySet.headSet(endKey, false); 8877 iterator = headSet.iterator(); 8878 for (j = 101; iterator.hasNext(); j++) { 8879 key = (String) iterator.next(); 8880 assertEquals(new Integer(j).toString(), key); 8881 } 8882 assertEquals(i, j); 8883 8884 headSet = keySet.headSet(endKey, true); 8885 iterator = headSet.iterator(); 8886 for (j = 101; iterator.hasNext(); j++) { 8887 key = (String) iterator.next(); 8888 assertEquals(new Integer(j).toString(), key); 8889 } 8890 assertEquals(i + 1, j); 8891 } 8892 8893 endKey = new Integer(109).toString(); 8894 headSet = keySet.headSet(endKey); 8895 iterator = headSet.iterator(); 8896 for (index = 101; iterator.hasNext(); index++) { 8897 key = (String) iterator.next(); 8898 assertEquals(new Integer(index).toString(), key); 8899 } 8900 assertEquals(109, index); 8901 8902 headSet = keySet.headSet(endKey, false); 8903 iterator = headSet.iterator(); 8904 for (index = 101; iterator.hasNext(); index++) { 8905 key = (String) iterator.next(); 8906 assertEquals(new Integer(index).toString(), key); 8907 } 8908 assertEquals(109, index); 8909 8910 headSet = keySet.headSet(endKey, true); 8911 iterator = headSet.iterator(); 8912 for (index = 101; iterator.hasNext(); index++) { 8913 key = (String) iterator.next(); 8914 assertEquals(new Integer(index).toString(), key); 8915 } 8916 assertEquals(110, index); 8917 8918 endKey = new Integer(110).toString(); 8919 try { 8920 keySet.headSet(endKey); 8921 fail("should throw IllegalArgumentException"); 8922 } catch (IllegalArgumentException e) { 8923 // Expected 8924 } 8925 try { 8926 keySet.headSet(endKey, false); 8927 fail("should throw IllegalArgumentException"); 8928 } catch (IllegalArgumentException e) { 8929 // Expected 8930 } 8931 try { 8932 keySet.headSet(endKey, true); 8933 fail("should throw IllegalArgumentException"); 8934 } catch (IllegalArgumentException e) { 8935 // Expected 8936 } 8937 8938 keySet = ((NavigableMap) subMap_startIncluded_endExcluded_comparator) 8939 .navigableKeySet(); 8940 endKey = new Integer(99).toString(); 8941 try { 8942 keySet.headSet(endKey); 8943 fail("should throw IllegalArgumentException"); 8944 } catch (IllegalArgumentException e) { 8945 // Expected 8946 } 8947 try { 8948 keySet.headSet(endKey, false); 8949 fail("should throw IllegalArgumentException"); 8950 } catch (IllegalArgumentException e) { 8951 // Expected 8952 } 8953 try { 8954 keySet.headSet(endKey, true); 8955 fail("should throw IllegalArgumentException"); 8956 } catch (IllegalArgumentException e) { 8957 // Expected 8958 } 8959 8960 endKey = new Integer(100).toString(); 8961 assertEquals(0, keySet.headSet(endKey).size()); 8962 assertEquals(0, keySet.headSet(endKey, false).size()); 8963 assertEquals(1, keySet.headSet(endKey, true).size()); 8964 8965 endKey = new Integer(101).toString(); 8966 headSet = keySet.headSet(endKey); 8967 iterator = headSet.iterator(); 8968 for (index = 100; iterator.hasNext(); index++) { 8969 key = (String) iterator.next(); 8970 assertEquals(new Integer(index).toString(), key); 8971 } 8972 assertEquals(101, index); 8973 8974 headSet = keySet.headSet(endKey, false); 8975 iterator = headSet.iterator(); 8976 for (index = 100; iterator.hasNext(); index++) { 8977 key = (String) iterator.next(); 8978 assertEquals(new Integer(index).toString(), key); 8979 } 8980 assertEquals(101, index); 8981 8982 headSet = keySet.headSet(endKey, true); 8983 iterator = headSet.iterator(); 8984 for (index = 100; iterator.hasNext(); index++) { 8985 key = (String) iterator.next(); 8986 assertEquals(new Integer(index).toString(), key); 8987 } 8988 assertEquals(102, index); 8989 8990 for (int i = 102; i < 109; i++) { 8991 endKey = new Integer(i).toString(); 8992 8993 headSet = keySet.headSet(endKey); 8994 iterator = headSet.iterator(); 8995 int j; 8996 for (j = 100; iterator.hasNext(); j++) { 8997 key = (String) iterator.next(); 8998 assertEquals(new Integer(j).toString(), key); 8999 } 9000 assertEquals(i, j); 9001 9002 headSet = keySet.headSet(endKey, false); 9003 iterator = headSet.iterator(); 9004 for (j = 100; iterator.hasNext(); j++) { 9005 key = (String) iterator.next(); 9006 assertEquals(new Integer(j).toString(), key); 9007 } 9008 assertEquals(i, j); 9009 9010 headSet = keySet.headSet(endKey, true); 9011 iterator = headSet.iterator(); 9012 for (j = 100; iterator.hasNext(); j++) { 9013 key = (String) iterator.next(); 9014 assertEquals(new Integer(j).toString(), key); 9015 } 9016 assertEquals(i + 1, j); 9017 } 9018 9019 endKey = new Integer(109).toString(); 9020 headSet = keySet.headSet(endKey); 9021 iterator = headSet.iterator(); 9022 for (index = 100; iterator.hasNext(); index++) { 9023 key = (String) iterator.next(); 9024 assertEquals(new Integer(index).toString(), key); 9025 } 9026 assertEquals(109, index); 9027 9028 headSet = keySet.headSet(endKey, false); 9029 iterator = headSet.iterator(); 9030 for (index = 100; iterator.hasNext(); index++) { 9031 key = (String) iterator.next(); 9032 assertEquals(new Integer(index).toString(), key); 9033 } 9034 assertEquals(109, index); 9035 9036 try { 9037 keySet.headSet(endKey, true); 9038 fail("should throw IllegalArgumentException"); 9039 } catch (IllegalArgumentException e) { 9040 // Expected 9041 } 9042 9043 endKey = new Integer(110).toString(); 9044 try { 9045 keySet.headSet(endKey); 9046 fail("should throw IllegalArgumentException"); 9047 } catch (IllegalArgumentException e) { 9048 // Expected 9049 } 9050 9051 try { 9052 keySet.headSet(endKey, false); 9053 fail("should throw IllegalArgumentException"); 9054 } catch (IllegalArgumentException e) { 9055 // Expected 9056 } 9057 9058 try { 9059 keySet.headSet(endKey, true); 9060 fail("should throw IllegalArgumentException"); 9061 } catch (IllegalArgumentException e) { 9062 // Expected 9063 } 9064 9065 keySet = ((NavigableMap) subMap_startIncluded_endIncluded_comparator) 9066 .navigableKeySet(); 9067 endKey = new Integer(99).toString(); 9068 try { 9069 keySet.headSet(endKey); 9070 fail("should throw IllegalArgumentException"); 9071 } catch (IllegalArgumentException e) { 9072 // Expected 9073 } 9074 try { 9075 keySet.headSet(endKey, false); 9076 fail("should throw IllegalArgumentException"); 9077 } catch (IllegalArgumentException e) { 9078 // Expected 9079 } 9080 try { 9081 keySet.headSet(endKey, true); 9082 fail("should throw IllegalArgumentException"); 9083 } catch (IllegalArgumentException e) { 9084 // Expected 9085 } 9086 9087 endKey = new Integer(100).toString(); 9088 assertEquals(0, keySet.headSet(endKey).size()); 9089 assertEquals(0, keySet.headSet(endKey, false).size()); 9090 assertEquals(1, keySet.headSet(endKey, true).size()); 9091 9092 endKey = new Integer(101).toString(); 9093 headSet = keySet.headSet(endKey); 9094 iterator = headSet.iterator(); 9095 for (index = 100; iterator.hasNext(); index++) { 9096 key = (String) iterator.next(); 9097 assertEquals(new Integer(index).toString(), key); 9098 } 9099 assertEquals(101, index); 9100 9101 headSet = keySet.headSet(endKey, false); 9102 iterator = headSet.iterator(); 9103 for (index = 100; iterator.hasNext(); index++) { 9104 key = (String) iterator.next(); 9105 assertEquals(new Integer(index).toString(), key); 9106 } 9107 assertEquals(101, index); 9108 9109 headSet = keySet.headSet(endKey, true); 9110 iterator = headSet.iterator(); 9111 for (index = 100; iterator.hasNext(); index++) { 9112 key = (String) iterator.next(); 9113 assertEquals(new Integer(index).toString(), key); 9114 } 9115 assertEquals(102, index); 9116 9117 for (int i = 102; i < 109; i++) { 9118 endKey = new Integer(i).toString(); 9119 9120 headSet = keySet.headSet(endKey); 9121 iterator = headSet.iterator(); 9122 int j; 9123 for (j = 100; iterator.hasNext(); j++) { 9124 key = (String) iterator.next(); 9125 assertEquals(new Integer(j).toString(), key); 9126 } 9127 assertEquals(i, j); 9128 9129 headSet = keySet.headSet(endKey, false); 9130 iterator = headSet.iterator(); 9131 for (j = 100; iterator.hasNext(); j++) { 9132 key = (String) iterator.next(); 9133 assertEquals(new Integer(j).toString(), key); 9134 } 9135 assertEquals(i, j); 9136 9137 headSet = keySet.headSet(endKey, true); 9138 iterator = headSet.iterator(); 9139 for (j = 100; iterator.hasNext(); j++) { 9140 key = (String) iterator.next(); 9141 assertEquals(new Integer(j).toString(), key); 9142 } 9143 assertEquals(i + 1, j); 9144 } 9145 9146 endKey = new Integer(109).toString(); 9147 headSet = keySet.headSet(endKey); 9148 iterator = headSet.iterator(); 9149 for (index = 100; iterator.hasNext(); index++) { 9150 key = (String) iterator.next(); 9151 assertEquals(new Integer(index).toString(), key); 9152 } 9153 assertEquals(109, index); 9154 9155 headSet = keySet.headSet(endKey, false); 9156 iterator = headSet.iterator(); 9157 for (index = 100; iterator.hasNext(); index++) { 9158 key = (String) iterator.next(); 9159 assertEquals(new Integer(index).toString(), key); 9160 } 9161 assertEquals(109, index); 9162 9163 headSet = keySet.headSet(endKey, true); 9164 iterator = headSet.iterator(); 9165 for (index = 100; iterator.hasNext(); index++) { 9166 key = (String) iterator.next(); 9167 assertEquals(new Integer(index).toString(), key); 9168 } 9169 assertEquals(110, index); 9170 9171 endKey = new Integer(110).toString(); 9172 try { 9173 keySet.headSet(endKey); 9174 fail("should throw IllegalArgumentException"); 9175 } catch (IllegalArgumentException e) { 9176 // Expected 9177 } 9178 try { 9179 keySet.headSet(endKey, false); 9180 fail("should throw IllegalArgumentException"); 9181 } catch (IllegalArgumentException e) { 9182 // Expected 9183 } 9184 try { 9185 keySet.headSet(endKey, true); 9186 fail("should throw IllegalArgumentException"); 9187 } catch (IllegalArgumentException e) { 9188 // Expected 9189 } 9190 9191 key = new Integer(1).toString(); 9192 keySet = tm.headMap(key, true).navigableKeySet(); 9193 iterator = keySet.iterator(); 9194 iterator.next(); 9195 endKey = (String) iterator.next(); 9196 headSet = keySet.headSet(endKey, false); 9197 assertEquals(1, headSet.size()); 9198 headSetIterator = headSet.iterator(); 9199 assertEquals(new Integer(0).toString(), headSetIterator.next()); 9200 assertFalse(headSetIterator.hasNext()); 9201 try { 9202 headSetIterator.next(); 9203 fail("should throw NoSuchElementException"); 9204 } catch (NoSuchElementException e) { 9205 // Expected 9206 } 9207 try { 9208 keySet.headSet(null, false); 9209 fail("should throw NPE"); 9210 } catch (NullPointerException e) { 9211 // Expected 9212 } 9213 9214 headSet = keySet.headSet(endKey, true); 9215 assertEquals(2, headSet.size()); 9216 headSetIterator = headSet.iterator(); 9217 assertEquals(new Integer(0).toString(), headSetIterator.next()); 9218 assertEquals(new Integer(1).toString(), headSetIterator.next()); 9219 assertFalse(headSetIterator.hasNext()); 9220 try { 9221 headSetIterator.next(); 9222 fail("should throw NoSuchElementException"); 9223 } catch (NoSuchElementException e) { 9224 // Expected 9225 } 9226 try { 9227 keySet.headSet(null, false); 9228 fail("should throw NPE"); 9229 } catch (NullPointerException e) { 9230 // Expected 9231 } 9232 9233 } 9234 9235 public void test_AscendingSubMapKeySet_remove() { 9236 TreeMap tm_rm = new TreeMap(tm); 9237 SortedMap subMap_startExcluded_endExcluded_rm = tm_rm.subMap( 9238 objArray[100].toString(), false, objArray[109].toString(), 9239 false); 9240 assertNull(subMap_startExcluded_endExcluded_rm.remove("0")); 9241 try { 9242 subMap_startExcluded_endExcluded_rm.remove(null); 9243 fail("should throw NPE"); 9244 } catch (Exception e) { 9245 // Expected 9246 } 9247 for (int i = 101; i < 108; i++) { 9248 assertNotNull(subMap_startExcluded_endExcluded_rm 9249 .remove(new Integer(i).toString())); 9250 } 9251 } 9252 9253 public void test_AscendingSubMapKeySet_tailSet() { 9254 NavigableSet keySet; 9255 SortedSet tailSet; 9256 String startKey, key; 9257 Iterator iterator; 9258 9259 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 9260 startKey = new Integer(99).toString(); 9261 try { 9262 keySet.tailSet(startKey); 9263 fail("should throw IllegalArgumentException"); 9264 } catch (IllegalArgumentException e) { 9265 // Expected 9266 } 9267 9268 try { 9269 keySet.tailSet(startKey, true); 9270 fail("should throw IllegalArgumentException"); 9271 } catch (IllegalArgumentException e) { 9272 // Expected 9273 } 9274 9275 try { 9276 keySet.tailSet(startKey, false); 9277 fail("should throw IllegalArgumentException"); 9278 } catch (IllegalArgumentException e) { 9279 // Expected 9280 } 9281 9282 startKey = new Integer(100).toString(); 9283 try { 9284 keySet.tailSet(startKey); 9285 fail("should throw IllegalArgumentException"); 9286 } catch (IllegalArgumentException e) { 9287 // Expected 9288 } 9289 try { 9290 keySet.tailSet(startKey, true); 9291 fail("should throw IllegalArgumentException"); 9292 } catch (IllegalArgumentException e) { 9293 // Expected 9294 } 9295 int index; 9296 tailSet = keySet.tailSet(startKey, false); 9297 iterator = tailSet.iterator(); 9298 for (index = 101; index < 109; index++) { 9299 key = (String) iterator.next(); 9300 assertEquals(new Integer(index).toString(), key); 9301 } 9302 9303 startKey = new Integer(101).toString(); 9304 tailSet = keySet.tailSet(startKey); 9305 iterator = tailSet.iterator(); 9306 for (index = 101; iterator.hasNext(); index++) { 9307 key = (String) iterator.next(); 9308 assertEquals(new Integer(index).toString(), key); 9309 } 9310 assertEquals(109, index); 9311 9312 tailSet = keySet.tailSet(startKey, true); 9313 iterator = tailSet.iterator(); 9314 for (index = 101; iterator.hasNext(); index++) { 9315 key = (String) iterator.next(); 9316 assertEquals(new Integer(index).toString(), key); 9317 } 9318 assertEquals(109, index); 9319 9320 tailSet = keySet.tailSet(startKey, false); 9321 iterator = tailSet.iterator(); 9322 for (index = 101; iterator.hasNext(); index++) { 9323 key = (String) iterator.next(); 9324 assertEquals(new Integer(index + 1).toString(), key); 9325 } 9326 assertEquals(108, index); 9327 9328 for (int i = 102; i < 109; i++) { 9329 startKey = new Integer(i).toString(); 9330 9331 tailSet = keySet.tailSet(startKey); 9332 iterator = tailSet.iterator(); 9333 int j; 9334 for (j = i; iterator.hasNext(); j++) { 9335 key = (String) iterator.next(); 9336 assertEquals(new Integer(j).toString(), key); 9337 } 9338 assertEquals(109, j); 9339 9340 tailSet = keySet.tailSet(startKey, true); 9341 iterator = tailSet.iterator(); 9342 for (j = i; iterator.hasNext(); j++) { 9343 key = (String) iterator.next(); 9344 assertEquals(new Integer(j).toString(), key); 9345 } 9346 assertEquals(109, j); 9347 9348 tailSet = keySet.tailSet(startKey, false); 9349 iterator = tailSet.iterator(); 9350 for (j = i; iterator.hasNext(); j++) { 9351 key = (String) iterator.next(); 9352 assertEquals(new Integer(j + 1).toString(), key); 9353 } 9354 assertEquals(108, j); 9355 } 9356 9357 startKey = new Integer(109).toString(); 9358 try { 9359 keySet.tailSet(startKey); 9360 fail("should throw IllegalArgumentException"); 9361 } catch (IllegalArgumentException e) { 9362 // Expected 9363 } 9364 try { 9365 keySet.tailSet(startKey, true); 9366 fail("should throw IllegalArgumentException"); 9367 } catch (IllegalArgumentException e) { 9368 // Expected 9369 } 9370 tailSet = keySet.tailSet(startKey, false); 9371 iterator = tailSet.iterator(); 9372 for (index = 109; iterator.hasNext(); index++) { 9373 key = (String) iterator.next(); 9374 assertEquals(new Integer(index + 1).toString(), key); 9375 } 9376 assertEquals(109, index); 9377 9378 startKey = new Integer(110).toString(); 9379 try { 9380 keySet.tailSet(startKey); 9381 fail("should throw IllegalArgumentException"); 9382 } catch (IllegalArgumentException e) { 9383 // Expected 9384 } 9385 try { 9386 keySet.tailSet(startKey, true); 9387 fail("should throw IllegalArgumentException"); 9388 } catch (IllegalArgumentException e) { 9389 // Expected 9390 } 9391 try { 9392 keySet.tailSet(startKey, false); 9393 fail("should throw IllegalArgumentException"); 9394 } catch (IllegalArgumentException e) { 9395 // Expected 9396 } 9397 9398 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 9399 startKey = new Integer(99).toString(); 9400 try { 9401 keySet.tailSet(startKey); 9402 fail("should throw IllegalArgumentException"); 9403 } catch (IllegalArgumentException e) { 9404 // Expected 9405 } 9406 try { 9407 keySet.tailSet(startKey, true); 9408 fail("should throw IllegalArgumentException"); 9409 } catch (IllegalArgumentException e) { 9410 // Expected 9411 } 9412 try { 9413 keySet.tailSet(startKey, false); 9414 fail("should throw IllegalArgumentException"); 9415 } catch (IllegalArgumentException e) { 9416 // Expected 9417 } 9418 9419 startKey = new Integer(100).toString(); 9420 try { 9421 keySet.tailSet(startKey); 9422 fail("should throw IllegalArgumentException"); 9423 } catch (IllegalArgumentException e) { 9424 // Expected 9425 } 9426 try { 9427 keySet.tailSet(startKey, true); 9428 fail("should throw IllegalArgumentException"); 9429 } catch (IllegalArgumentException e) { 9430 // Expected 9431 } 9432 9433 tailSet = keySet.tailSet(startKey, false); 9434 iterator = tailSet.iterator(); 9435 for (index = 100; iterator.hasNext(); index++) { 9436 key = (String) iterator.next(); 9437 assertEquals(new Integer(index + 1).toString(), key); 9438 } 9439 assertEquals(109, index); 9440 9441 for (int i = 102; i < 109; i++) { 9442 startKey = new Integer(i).toString(); 9443 9444 tailSet = keySet.tailSet(startKey); 9445 iterator = tailSet.iterator(); 9446 int j; 9447 for (j = i; iterator.hasNext(); j++) { 9448 key = (String) iterator.next(); 9449 assertEquals(new Integer(j).toString(), key); 9450 } 9451 assertEquals(110, j); 9452 9453 tailSet = keySet.tailSet(startKey, true); 9454 iterator = tailSet.iterator(); 9455 for (j = i; iterator.hasNext(); j++) { 9456 key = (String) iterator.next(); 9457 assertEquals(new Integer(j).toString(), key); 9458 } 9459 assertEquals(110, j); 9460 9461 tailSet = keySet.tailSet(startKey, false); 9462 iterator = tailSet.iterator(); 9463 for (j = i; iterator.hasNext(); j++) { 9464 key = (String) iterator.next(); 9465 assertEquals(new Integer(j + 1).toString(), key); 9466 } 9467 assertEquals(109, j); 9468 } 9469 9470 startKey = new Integer(109).toString(); 9471 tailSet = keySet.tailSet(startKey); 9472 iterator = tailSet.iterator(); 9473 for (index = 109; iterator.hasNext(); index++) { 9474 key = (String) iterator.next(); 9475 assertEquals(new Integer(index).toString(), key); 9476 } 9477 assertEquals(110, index); 9478 9479 tailSet = keySet.tailSet(startKey, true); 9480 iterator = tailSet.iterator(); 9481 for (index = 109; iterator.hasNext(); index++) { 9482 key = (String) iterator.next(); 9483 assertEquals(new Integer(index).toString(), key); 9484 } 9485 assertEquals(110, index); 9486 9487 tailSet = keySet.tailSet(startKey, false); 9488 iterator = tailSet.iterator(); 9489 for (index = 109; iterator.hasNext(); index++) { 9490 key = (String) iterator.next(); 9491 assertEquals(new Integer(index + 1).toString(), key); 9492 } 9493 assertEquals(109, index); 9494 9495 startKey = new Integer(110).toString(); 9496 try { 9497 keySet.tailSet(startKey); 9498 fail("should throw IllegalArgumentException"); 9499 } catch (IllegalArgumentException e) { 9500 // Expected 9501 } 9502 try { 9503 keySet.tailSet(startKey, true); 9504 fail("should throw IllegalArgumentException"); 9505 } catch (IllegalArgumentException e) { 9506 // Expected 9507 } 9508 try { 9509 keySet.tailSet(startKey, false); 9510 fail("should throw IllegalArgumentException"); 9511 } catch (IllegalArgumentException e) { 9512 // Expected 9513 } 9514 9515 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 9516 startKey = new Integer(99).toString(); 9517 try { 9518 keySet.tailSet(startKey); 9519 fail("should throw IllegalArgumentException"); 9520 } catch (IllegalArgumentException e) { 9521 // Expected 9522 } 9523 try { 9524 keySet.tailSet(startKey, true); 9525 fail("should throw IllegalArgumentException"); 9526 } catch (IllegalArgumentException e) { 9527 // Expected 9528 } 9529 try { 9530 keySet.tailSet(startKey, false); 9531 fail("should throw IllegalArgumentException"); 9532 } catch (IllegalArgumentException e) { 9533 // Expected 9534 } 9535 9536 startKey = new Integer(100).toString(); 9537 tailSet = keySet.tailSet(startKey); 9538 iterator = tailSet.iterator(); 9539 for (index = 100; iterator.hasNext(); index++) { 9540 key = (String) iterator.next(); 9541 assertEquals(new Integer(index).toString(), key); 9542 } 9543 assertEquals(109, index); 9544 9545 tailSet = keySet.tailSet(startKey, true); 9546 iterator = tailSet.iterator(); 9547 for (index = 100; iterator.hasNext(); index++) { 9548 key = (String) iterator.next(); 9549 assertEquals(new Integer(index).toString(), key); 9550 } 9551 assertEquals(109, index); 9552 9553 tailSet = keySet.tailSet(startKey, false); 9554 iterator = tailSet.iterator(); 9555 for (index = 100; iterator.hasNext(); index++) { 9556 key = (String) iterator.next(); 9557 assertEquals(new Integer(index + 1).toString(), key); 9558 } 9559 assertEquals(108, index); 9560 9561 startKey = new Integer(101).toString(); 9562 tailSet = keySet.tailSet(startKey); 9563 iterator = tailSet.iterator(); 9564 for (index = 101; iterator.hasNext(); index++) { 9565 key = (String) iterator.next(); 9566 assertEquals(new Integer(index).toString(), key); 9567 } 9568 assertEquals(109, index); 9569 9570 tailSet = keySet.tailSet(startKey, true); 9571 iterator = tailSet.iterator(); 9572 for (index = 101; iterator.hasNext(); index++) { 9573 key = (String) iterator.next(); 9574 assertEquals(new Integer(index).toString(), key); 9575 } 9576 assertEquals(109, index); 9577 9578 tailSet = keySet.tailSet(startKey, false); 9579 iterator = tailSet.iterator(); 9580 for (index = 101; iterator.hasNext(); index++) { 9581 key = (String) iterator.next(); 9582 assertEquals(new Integer(index + 1).toString(), key); 9583 } 9584 assertEquals(108, index); 9585 9586 for (int i = 102; i < 109; i++) { 9587 startKey = new Integer(i).toString(); 9588 9589 tailSet = keySet.tailSet(startKey); 9590 iterator = tailSet.iterator(); 9591 int j; 9592 for (j = i; iterator.hasNext(); j++) { 9593 key = (String) iterator.next(); 9594 assertEquals(new Integer(j).toString(), key); 9595 } 9596 assertEquals(109, j); 9597 9598 tailSet = keySet.tailSet(startKey, true); 9599 iterator = tailSet.iterator(); 9600 for (j = i; iterator.hasNext(); j++) { 9601 key = (String) iterator.next(); 9602 assertEquals(new Integer(j).toString(), key); 9603 } 9604 assertEquals(109, j); 9605 9606 tailSet = keySet.tailSet(startKey, false); 9607 iterator = tailSet.iterator(); 9608 for (j = i; iterator.hasNext(); j++) { 9609 key = (String) iterator.next(); 9610 assertEquals(new Integer(j + 1).toString(), key); 9611 } 9612 assertEquals(108, j); 9613 } 9614 9615 startKey = new Integer(109).toString(); 9616 try { 9617 keySet.tailSet(startKey); 9618 fail("should throw IllegalArgumentException"); 9619 } catch (IllegalArgumentException e) { 9620 // Expected 9621 } 9622 try { 9623 keySet.tailSet(startKey, true); 9624 fail("should throw IllegalArgumentException"); 9625 } catch (IllegalArgumentException e) { 9626 // Expected 9627 } 9628 tailSet = keySet.tailSet(startKey, false); 9629 iterator = tailSet.iterator(); 9630 for (index = 109; iterator.hasNext(); index++) { 9631 key = (String) iterator.next(); 9632 assertEquals(new Integer(index + 1).toString(), key); 9633 } 9634 assertEquals(109, index); 9635 9636 startKey = new Integer(110).toString(); 9637 try { 9638 keySet.tailSet(startKey); 9639 fail("should throw IllegalArgumentException"); 9640 } catch (IllegalArgumentException e) { 9641 // Expected 9642 } 9643 try { 9644 keySet.tailSet(startKey, true); 9645 fail("should throw IllegalArgumentException"); 9646 } catch (IllegalArgumentException e) { 9647 // Expected 9648 } 9649 try { 9650 keySet.tailSet(startKey, false); 9651 fail("should throw IllegalArgumentException"); 9652 } catch (IllegalArgumentException e) { 9653 // Expected 9654 } 9655 9656 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 9657 startKey = new Integer(99).toString(); 9658 try { 9659 keySet.tailSet(startKey); 9660 fail("should throw IllegalArgumentException"); 9661 } catch (IllegalArgumentException e) { 9662 // Expected 9663 } 9664 try { 9665 keySet.tailSet(startKey, true); 9666 fail("should throw IllegalArgumentException"); 9667 } catch (IllegalArgumentException e) { 9668 // Expected 9669 } 9670 try { 9671 keySet.tailSet(startKey, false); 9672 fail("should throw IllegalArgumentException"); 9673 } catch (IllegalArgumentException e) { 9674 // Expected 9675 } 9676 startKey = new Integer(100).toString(); 9677 tailSet = keySet.tailSet(startKey); 9678 iterator = tailSet.iterator(); 9679 for (index = 100; iterator.hasNext(); index++) { 9680 key = (String) iterator.next(); 9681 assertEquals(new Integer(index).toString(), key); 9682 } 9683 assertEquals(110, index); 9684 9685 tailSet = keySet.tailSet(startKey, true); 9686 iterator = tailSet.iterator(); 9687 for (index = 100; iterator.hasNext(); index++) { 9688 key = (String) iterator.next(); 9689 assertEquals(new Integer(index).toString(), key); 9690 } 9691 assertEquals(110, index); 9692 9693 tailSet = keySet.tailSet(startKey, false); 9694 iterator = tailSet.iterator(); 9695 for (index = 100; iterator.hasNext(); index++) { 9696 key = (String) iterator.next(); 9697 assertEquals(new Integer(index + 1).toString(), key); 9698 } 9699 assertEquals(109, index); 9700 9701 startKey = new Integer(101).toString(); 9702 tailSet = keySet.tailSet(startKey); 9703 iterator = tailSet.iterator(); 9704 for (index = 101; iterator.hasNext(); index++) { 9705 key = (String) iterator.next(); 9706 assertEquals(new Integer(index).toString(), key); 9707 } 9708 assertEquals(110, index); 9709 9710 tailSet = keySet.tailSet(startKey, true); 9711 iterator = tailSet.iterator(); 9712 for (index = 101; iterator.hasNext(); index++) { 9713 key = (String) iterator.next(); 9714 assertEquals(new Integer(index).toString(), key); 9715 } 9716 assertEquals(110, index); 9717 9718 tailSet = keySet.tailSet(startKey, false); 9719 iterator = tailSet.iterator(); 9720 for (index = 101; iterator.hasNext(); index++) { 9721 key = (String) iterator.next(); 9722 assertEquals(new Integer(index + 1).toString(), key); 9723 } 9724 assertEquals(109, index); 9725 9726 for (int i = 102; i < 109; i++) { 9727 startKey = new Integer(i).toString(); 9728 9729 tailSet = keySet.tailSet(startKey); 9730 iterator = tailSet.iterator(); 9731 int j; 9732 for (j = i; iterator.hasNext(); j++) { 9733 key = (String) iterator.next(); 9734 assertEquals(new Integer(j).toString(), key); 9735 } 9736 assertEquals(110, j); 9737 9738 tailSet = keySet.tailSet(startKey, true); 9739 iterator = tailSet.iterator(); 9740 for (j = i; iterator.hasNext(); j++) { 9741 key = (String) iterator.next(); 9742 assertEquals(new Integer(j).toString(), key); 9743 } 9744 assertEquals(110, j); 9745 9746 tailSet = keySet.tailSet(startKey, false); 9747 iterator = tailSet.iterator(); 9748 for (j = i; iterator.hasNext(); j++) { 9749 key = (String) iterator.next(); 9750 assertEquals(new Integer(j + 1).toString(), key); 9751 } 9752 assertEquals(109, j); 9753 } 9754 9755 startKey = new Integer(109).toString(); 9756 tailSet = keySet.tailSet(startKey); 9757 iterator = tailSet.iterator(); 9758 for (index = 109; iterator.hasNext(); index++) { 9759 key = (String) iterator.next(); 9760 assertEquals(new Integer(index).toString(), key); 9761 } 9762 assertEquals(110, index); 9763 9764 tailSet = keySet.tailSet(startKey, true); 9765 iterator = tailSet.iterator(); 9766 for (index = 109; iterator.hasNext(); index++) { 9767 key = (String) iterator.next(); 9768 assertEquals(new Integer(index).toString(), key); 9769 } 9770 assertEquals(110, index); 9771 9772 tailSet = keySet.tailSet(startKey, false); 9773 iterator = tailSet.iterator(); 9774 for (index = 109; iterator.hasNext(); index++) { 9775 key = (String) iterator.next(); 9776 assertEquals(new Integer(index + 1).toString(), key); 9777 } 9778 assertEquals(109, index); 9779 9780 startKey = new Integer(110).toString(); 9781 try { 9782 keySet.tailSet(startKey); 9783 fail("should throw IllegalArgumentException"); 9784 } catch (IllegalArgumentException e) { 9785 // Expected 9786 } 9787 try { 9788 keySet.tailSet(startKey, true); 9789 fail("should throw IllegalArgumentException"); 9790 } catch (IllegalArgumentException e) { 9791 // Expected 9792 } 9793 try { 9794 keySet.tailSet(startKey, false); 9795 fail("should throw IllegalArgumentException"); 9796 } catch (IllegalArgumentException e) { 9797 // Expected 9798 } 9799 9800 String endKey = new Integer(1).toString(); 9801 keySet = tm.headMap(endKey, true).navigableKeySet(); 9802 iterator = keySet.iterator(); 9803 iterator.next(); 9804 startKey = (String) iterator.next(); 9805 tailSet = keySet.tailSet(startKey); 9806 assertEquals(1, tailSet.size()); 9807 Iterator tailSetIterator = tailSet.iterator(); 9808 assertEquals(endKey, tailSetIterator.next()); 9809 try { 9810 tailSetIterator.next(); 9811 fail("should throw NoSuchElementException"); 9812 } catch (NoSuchElementException e) { 9813 // Expected 9814 } 9815 try { 9816 keySet.tailSet(null); 9817 fail("should throw NPE"); 9818 } catch (NullPointerException e) { 9819 // Expected 9820 } 9821 9822 tailSet = keySet.tailSet(startKey, true); 9823 assertEquals(1, tailSet.size()); 9824 tailSetIterator = tailSet.iterator(); 9825 assertEquals(endKey, tailSetIterator.next()); 9826 9827 tailSet = keySet.tailSet(startKey, false); 9828 assertEquals(0, tailSet.size()); 9829 tailSetIterator = tailSet.iterator(); 9830 try { 9831 tailSetIterator.next(); 9832 fail("should throw NoSuchElementException"); 9833 } catch (NoSuchElementException e) { 9834 // Expected 9835 } 9836 try { 9837 keySet.tailSet(null, false); 9838 fail("should throw NPE"); 9839 } catch (NullPointerException e) { 9840 // Expected 9841 } 9842 try { 9843 keySet.tailSet(null, true); 9844 fail("should throw NPE"); 9845 } catch (NullPointerException e) { 9846 // Expected 9847 } 9848 9849 // With Comparator 9850 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 9851 .navigableKeySet(); 9852 startKey = new Integer(99).toString(); 9853 try { 9854 keySet.tailSet(startKey); 9855 fail("should throw IllegalArgumentException"); 9856 } catch (IllegalArgumentException e) { 9857 // Expected 9858 } 9859 9860 try { 9861 keySet.tailSet(startKey, true); 9862 fail("should throw IllegalArgumentException"); 9863 } catch (IllegalArgumentException e) { 9864 // Expected 9865 } 9866 9867 try { 9868 keySet.tailSet(startKey, false); 9869 fail("should throw IllegalArgumentException"); 9870 } catch (IllegalArgumentException e) { 9871 // Expected 9872 } 9873 9874 startKey = new Integer(100).toString(); 9875 try { 9876 keySet.tailSet(startKey); 9877 fail("should throw IllegalArgumentException"); 9878 } catch (IllegalArgumentException e) { 9879 // Expected 9880 } 9881 try { 9882 keySet.tailSet(startKey, true); 9883 fail("should throw IllegalArgumentException"); 9884 } catch (IllegalArgumentException e) { 9885 // Expected 9886 } 9887 tailSet = keySet.tailSet(startKey, false); 9888 iterator = tailSet.iterator(); 9889 for (index = 101; index < 109; index++) { 9890 key = (String) iterator.next(); 9891 assertEquals(new Integer(index).toString(), key); 9892 } 9893 9894 startKey = new Integer(101).toString(); 9895 tailSet = keySet.tailSet(startKey); 9896 iterator = tailSet.iterator(); 9897 for (index = 101; iterator.hasNext(); index++) { 9898 key = (String) iterator.next(); 9899 assertEquals(new Integer(index).toString(), key); 9900 } 9901 assertEquals(109, index); 9902 9903 tailSet = keySet.tailSet(startKey, true); 9904 iterator = tailSet.iterator(); 9905 for (index = 101; iterator.hasNext(); index++) { 9906 key = (String) iterator.next(); 9907 assertEquals(new Integer(index).toString(), key); 9908 } 9909 assertEquals(109, index); 9910 9911 tailSet = keySet.tailSet(startKey, false); 9912 iterator = tailSet.iterator(); 9913 for (index = 101; iterator.hasNext(); index++) { 9914 key = (String) iterator.next(); 9915 assertEquals(new Integer(index + 1).toString(), key); 9916 } 9917 assertEquals(108, index); 9918 9919 for (int i = 102; i < 109; i++) { 9920 startKey = new Integer(i).toString(); 9921 9922 tailSet = keySet.tailSet(startKey); 9923 iterator = tailSet.iterator(); 9924 int j; 9925 for (j = i; iterator.hasNext(); j++) { 9926 key = (String) iterator.next(); 9927 assertEquals(new Integer(j).toString(), key); 9928 } 9929 assertEquals(109, j); 9930 9931 tailSet = keySet.tailSet(startKey, true); 9932 iterator = tailSet.iterator(); 9933 for (j = i; iterator.hasNext(); j++) { 9934 key = (String) iterator.next(); 9935 assertEquals(new Integer(j).toString(), key); 9936 } 9937 assertEquals(109, j); 9938 9939 tailSet = keySet.tailSet(startKey, false); 9940 iterator = tailSet.iterator(); 9941 for (j = i; iterator.hasNext(); j++) { 9942 key = (String) iterator.next(); 9943 assertEquals(new Integer(j + 1).toString(), key); 9944 } 9945 assertEquals(108, j); 9946 } 9947 9948 startKey = new Integer(109).toString(); 9949 try { 9950 keySet.tailSet(startKey); 9951 fail("should throw IllegalArgumentException"); 9952 } catch (IllegalArgumentException e) { 9953 // Expected 9954 } 9955 try { 9956 keySet.tailSet(startKey, true); 9957 fail("should throw IllegalArgumentException"); 9958 } catch (IllegalArgumentException e) { 9959 // Expected 9960 } 9961 tailSet = keySet.tailSet(startKey, false); 9962 iterator = tailSet.iterator(); 9963 for (index = 109; iterator.hasNext(); index++) { 9964 key = (String) iterator.next(); 9965 assertEquals(new Integer(index + 1).toString(), key); 9966 } 9967 assertEquals(109, index); 9968 9969 startKey = new Integer(110).toString(); 9970 try { 9971 keySet.tailSet(startKey); 9972 fail("should throw IllegalArgumentException"); 9973 } catch (IllegalArgumentException e) { 9974 // Expected 9975 } 9976 try { 9977 keySet.tailSet(startKey, true); 9978 fail("should throw IllegalArgumentException"); 9979 } catch (IllegalArgumentException e) { 9980 // Expected 9981 } 9982 try { 9983 keySet.tailSet(startKey, false); 9984 fail("should throw IllegalArgumentException"); 9985 } catch (IllegalArgumentException e) { 9986 // Expected 9987 } 9988 9989 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 9990 startKey = new Integer(99).toString(); 9991 try { 9992 keySet.tailSet(startKey); 9993 fail("should throw IllegalArgumentException"); 9994 } catch (IllegalArgumentException e) { 9995 // Expected 9996 } 9997 try { 9998 keySet.tailSet(startKey, true); 9999 fail("should throw IllegalArgumentException"); 10000 } catch (IllegalArgumentException e) { 10001 // Expected 10002 } 10003 try { 10004 keySet.tailSet(startKey, false); 10005 fail("should throw IllegalArgumentException"); 10006 } catch (IllegalArgumentException e) { 10007 // Expected 10008 } 10009 10010 startKey = new Integer(100).toString(); 10011 try { 10012 keySet.tailSet(startKey); 10013 fail("should throw IllegalArgumentException"); 10014 } catch (IllegalArgumentException e) { 10015 // Expected 10016 } 10017 try { 10018 keySet.tailSet(startKey, true); 10019 fail("should throw IllegalArgumentException"); 10020 } catch (IllegalArgumentException e) { 10021 // Expected 10022 } 10023 10024 tailSet = keySet.tailSet(startKey, false); 10025 iterator = tailSet.iterator(); 10026 for (index = 100; iterator.hasNext(); index++) { 10027 key = (String) iterator.next(); 10028 assertEquals(new Integer(index + 1).toString(), key); 10029 } 10030 assertEquals(109, index); 10031 10032 for (int i = 102; i < 109; i++) { 10033 startKey = new Integer(i).toString(); 10034 10035 tailSet = keySet.tailSet(startKey); 10036 iterator = tailSet.iterator(); 10037 int j; 10038 for (j = i; iterator.hasNext(); j++) { 10039 key = (String) iterator.next(); 10040 assertEquals(new Integer(j).toString(), key); 10041 } 10042 assertEquals(110, j); 10043 10044 tailSet = keySet.tailSet(startKey, true); 10045 iterator = tailSet.iterator(); 10046 for (j = i; iterator.hasNext(); j++) { 10047 key = (String) iterator.next(); 10048 assertEquals(new Integer(j).toString(), key); 10049 } 10050 assertEquals(110, j); 10051 10052 tailSet = keySet.tailSet(startKey, false); 10053 iterator = tailSet.iterator(); 10054 for (j = i; iterator.hasNext(); j++) { 10055 key = (String) iterator.next(); 10056 assertEquals(new Integer(j + 1).toString(), key); 10057 } 10058 assertEquals(109, j); 10059 } 10060 10061 startKey = new Integer(109).toString(); 10062 tailSet = keySet.tailSet(startKey); 10063 iterator = tailSet.iterator(); 10064 for (index = 109; iterator.hasNext(); index++) { 10065 key = (String) iterator.next(); 10066 assertEquals(new Integer(index).toString(), key); 10067 } 10068 assertEquals(110, index); 10069 10070 tailSet = keySet.tailSet(startKey, true); 10071 iterator = tailSet.iterator(); 10072 for (index = 109; iterator.hasNext(); index++) { 10073 key = (String) iterator.next(); 10074 assertEquals(new Integer(index).toString(), key); 10075 } 10076 assertEquals(110, index); 10077 10078 tailSet = keySet.tailSet(startKey, false); 10079 iterator = tailSet.iterator(); 10080 for (index = 109; iterator.hasNext(); index++) { 10081 key = (String) iterator.next(); 10082 assertEquals(new Integer(index + 1).toString(), key); 10083 } 10084 assertEquals(109, index); 10085 10086 startKey = new Integer(110).toString(); 10087 try { 10088 keySet.tailSet(startKey); 10089 fail("should throw IllegalArgumentException"); 10090 } catch (IllegalArgumentException e) { 10091 // Expected 10092 } 10093 try { 10094 keySet.tailSet(startKey, true); 10095 fail("should throw IllegalArgumentException"); 10096 } catch (IllegalArgumentException e) { 10097 // Expected 10098 } 10099 try { 10100 keySet.tailSet(startKey, false); 10101 fail("should throw IllegalArgumentException"); 10102 } catch (IllegalArgumentException e) { 10103 // Expected 10104 } 10105 } 10106 10107 public void test_AscendingSubMapKeySet_subSet() { 10108 NavigableSet keySet; 10109 SortedSet subSet; 10110 String startKey, endKey, key; 10111 Iterator startIterator, endIterator, subSetIterator; 10112 10113 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10114 startIterator = keySet.iterator(); 10115 while (startIterator.hasNext()) { 10116 startKey = (String) startIterator.next(); 10117 endIterator = keySet.iterator(); 10118 while (endIterator.hasNext()) { 10119 endKey = (String) endIterator.next(); 10120 int startIndex = Integer.valueOf(startKey); 10121 int endIndex = Integer.valueOf(endKey); 10122 if (startIndex > endIndex) { 10123 try { 10124 keySet.subSet(startKey, endKey); 10125 fail("should throw IllegalArgumentException"); 10126 } catch (IllegalArgumentException e) { 10127 // Expected 10128 } 10129 10130 try { 10131 keySet.subSet(startKey, false, endKey, false); 10132 fail("shoudl throw IllegalArgumentException"); 10133 } catch (IllegalArgumentException e) { 10134 // Expected 10135 } 10136 10137 try { 10138 keySet.subSet(startKey, false, endKey, true); 10139 fail("shoudl throw IllegalArgumentException"); 10140 } catch (IllegalArgumentException e) { 10141 // Expected 10142 } 10143 10144 try { 10145 keySet.subSet(startKey, true, endKey, false); 10146 fail("shoudl throw IllegalArgumentException"); 10147 } catch (IllegalArgumentException e) { 10148 // Expected 10149 } 10150 10151 try { 10152 keySet.subSet(startKey, true, endKey, true); 10153 fail("shoudl throw IllegalArgumentException"); 10154 } catch (IllegalArgumentException e) { 10155 // Expected 10156 } 10157 } else { 10158 subSet = keySet.subSet(startKey, endKey); 10159 subSetIterator = subSet.iterator(); 10160 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10161 assertEquals(new Integer(index).toString(), 10162 subSetIterator.next()); 10163 } 10164 10165 subSet = keySet.subSet(startKey, false, endKey, false); 10166 subSetIterator = subSet.iterator(); 10167 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10168 assertEquals(new Integer(index).toString(), 10169 subSetIterator.next()); 10170 } 10171 10172 subSet = keySet.subSet(startKey, false, endKey, true); 10173 subSetIterator = subSet.iterator(); 10174 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10175 assertEquals(new Integer(index).toString(), 10176 subSetIterator.next()); 10177 } 10178 10179 subSet = keySet.subSet(startKey, true, endKey, false); 10180 subSetIterator = subSet.iterator(); 10181 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10182 assertEquals(new Integer(index).toString(), 10183 subSetIterator.next()); 10184 } 10185 10186 subSet = keySet.subSet(startKey, true, endKey, true); 10187 subSetIterator = subSet.iterator(); 10188 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10189 assertEquals(new Integer(index).toString(), 10190 subSetIterator.next()); 10191 } 10192 } 10193 } 10194 } 10195 10196 key = new Integer(1).toString(); 10197 keySet = tm.headMap(key, true).navigableKeySet(); 10198 Iterator iterator = keySet.iterator(); 10199 startKey = (String) iterator.next(); 10200 endKey = (String) iterator.next(); 10201 10202 subSet = keySet.subSet(startKey, endKey); 10203 assertEquals(1, subSet.size()); 10204 subSetIterator = subSet.iterator(); 10205 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10206 try { 10207 subSetIterator.next(); 10208 fail("should throw NoSuchElementException"); 10209 } catch (NoSuchElementException e) { 10210 // Expected 10211 } 10212 10213 subSet = keySet.subSet(startKey, false, endKey, false); 10214 assertEquals(0, subSet.size()); 10215 10216 subSet = keySet.subSet(startKey, false, endKey, true); 10217 assertEquals(1, subSet.size()); 10218 subSetIterator = subSet.iterator(); 10219 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10220 try { 10221 subSetIterator.next(); 10222 fail("should throw NoSuchElementException"); 10223 } catch (NoSuchElementException e) { 10224 // Expected 10225 } 10226 10227 subSet = keySet.subSet(startKey, true, endKey, false); 10228 assertEquals(1, subSet.size()); 10229 subSetIterator = subSet.iterator(); 10230 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10231 try { 10232 subSetIterator.next(); 10233 fail("should throw NoSuchElementException"); 10234 } catch (NoSuchElementException e) { 10235 // Expected 10236 } 10237 10238 subSet = keySet.subSet(startKey, true, endKey, true); 10239 assertEquals(2, subSet.size()); 10240 subSetIterator = subSet.iterator(); 10241 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10242 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10243 try { 10244 subSetIterator.next(); 10245 fail("should throw NoSuchElementException"); 10246 } catch (NoSuchElementException e) { 10247 // Expected 10248 } 10249 10250 try { 10251 keySet.subSet(null, null); 10252 fail("should throw NPE"); 10253 } catch (NullPointerException e) { 10254 // Expected 10255 } 10256 10257 try { 10258 keySet.subSet(null, false, null, false); 10259 fail("should throw NPE"); 10260 } catch (NullPointerException e) { 10261 // Expected 10262 } 10263 10264 try { 10265 keySet.subSet(null, false, null, true); 10266 fail("should throw NPE"); 10267 } catch (NullPointerException e) { 10268 // Expected 10269 } 10270 10271 try { 10272 keySet.subSet(null, true, null, false); 10273 fail("should throw NPE"); 10274 } catch (NullPointerException e) { 10275 // Expected 10276 } 10277 10278 try { 10279 keySet.subSet(null, true, null, true); 10280 fail("should throw NPE"); 10281 } catch (NullPointerException e) { 10282 // Expected 10283 } 10284 10285 try { 10286 keySet.subSet(null, endKey); 10287 fail("should throw NPE"); 10288 } catch (NullPointerException e) { 10289 // Expected 10290 } 10291 10292 try { 10293 keySet.subSet(null, false, endKey, false); 10294 fail("should throw NPE"); 10295 } catch (NullPointerException e) { 10296 // Expected 10297 } 10298 10299 try { 10300 keySet.subSet(null, false, endKey, true); 10301 fail("should throw NPE"); 10302 } catch (NullPointerException e) { 10303 // Expected 10304 } 10305 10306 try { 10307 keySet.subSet(null, true, endKey, false); 10308 fail("should throw NPE"); 10309 } catch (NullPointerException e) { 10310 // Expected 10311 } 10312 10313 try { 10314 keySet.subSet(null, true, endKey, true); 10315 fail("should throw NPE"); 10316 } catch (NullPointerException e) { 10317 // Expected 10318 } 10319 10320 try { 10321 keySet.subSet(startKey, null); 10322 fail("should throw NPE"); 10323 } catch (NullPointerException e) { 10324 // Expected 10325 } 10326 10327 try { 10328 keySet.subSet(startKey, false, null, false); 10329 fail("should throw NPE"); 10330 } catch (NullPointerException e) { 10331 // Expected 10332 } 10333 10334 try { 10335 keySet.subSet(startKey, false, null, true); 10336 fail("should throw NPE"); 10337 } catch (NullPointerException e) { 10338 // Expected 10339 } 10340 10341 try { 10342 keySet.subSet(startKey, true, null, false); 10343 fail("should throw NPE"); 10344 } catch (NullPointerException e) { 10345 // Expected 10346 } 10347 10348 try { 10349 keySet.subSet(startKey, true, null, true); 10350 fail("should throw NPE"); 10351 } catch (NullPointerException e) { 10352 // Expected 10353 } 10354 10355 // With Comparator 10356 keySet = ((NavigableMap) subMap_startExcluded_endExcluded_comparator) 10357 .navigableKeySet(); 10358 startIterator = keySet.iterator(); 10359 while (startIterator.hasNext()) { 10360 startKey = (String) startIterator.next(); 10361 endIterator = keySet.iterator(); 10362 while (endIterator.hasNext()) { 10363 endKey = (String) endIterator.next(); 10364 int startIndex = Integer.valueOf(startKey); 10365 int endIndex = Integer.valueOf(endKey); 10366 if (startIndex > endIndex) { 10367 try { 10368 keySet.subSet(startKey, endKey); 10369 fail("should throw IllegalArgumentException"); 10370 } catch (IllegalArgumentException e) { 10371 // Expected 10372 } 10373 10374 try { 10375 keySet.subSet(startKey, false, endKey, false); 10376 fail("shoudl throw IllegalArgumentException"); 10377 } catch (IllegalArgumentException e) { 10378 // Expected 10379 } 10380 10381 try { 10382 keySet.subSet(startKey, false, endKey, true); 10383 fail("shoudl throw IllegalArgumentException"); 10384 } catch (IllegalArgumentException e) { 10385 // Expected 10386 } 10387 10388 try { 10389 keySet.subSet(startKey, true, endKey, false); 10390 fail("shoudl throw IllegalArgumentException"); 10391 } catch (IllegalArgumentException e) { 10392 // Expected 10393 } 10394 10395 try { 10396 keySet.subSet(startKey, true, endKey, true); 10397 fail("shoudl throw IllegalArgumentException"); 10398 } catch (IllegalArgumentException e) { 10399 // Expected 10400 } 10401 } else { 10402 subSet = keySet.subSet(startKey, endKey); 10403 subSetIterator = subSet.iterator(); 10404 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10405 assertEquals(new Integer(index).toString(), 10406 subSetIterator.next()); 10407 } 10408 10409 subSet = keySet.subSet(startKey, false, endKey, false); 10410 subSetIterator = subSet.iterator(); 10411 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10412 assertEquals(new Integer(index).toString(), 10413 subSetIterator.next()); 10414 } 10415 10416 subSet = keySet.subSet(startKey, false, endKey, true); 10417 subSetIterator = subSet.iterator(); 10418 for (int index = startIndex + 1; subSetIterator.hasNext(); index++) { 10419 assertEquals(new Integer(index).toString(), 10420 subSetIterator.next()); 10421 } 10422 10423 subSet = keySet.subSet(startKey, true, endKey, false); 10424 subSetIterator = subSet.iterator(); 10425 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10426 assertEquals(new Integer(index).toString(), 10427 subSetIterator.next()); 10428 } 10429 10430 subSet = keySet.subSet(startKey, true, endKey, true); 10431 subSetIterator = subSet.iterator(); 10432 for (int index = startIndex; subSetIterator.hasNext(); index++) { 10433 assertEquals(new Integer(index).toString(), 10434 subSetIterator.next()); 10435 } 10436 } 10437 } 10438 } 10439 10440 key = new Integer(1).toString(); 10441 keySet = tm.headMap(key, true).navigableKeySet(); 10442 iterator = keySet.iterator(); 10443 startKey = (String) iterator.next(); 10444 endKey = (String) iterator.next(); 10445 10446 subSet = keySet.subSet(startKey, endKey); 10447 assertEquals(1, subSet.size()); 10448 subSetIterator = subSet.iterator(); 10449 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10450 try { 10451 subSetIterator.next(); 10452 fail("should throw NoSuchElementException"); 10453 } catch (NoSuchElementException e) { 10454 // Expected 10455 } 10456 10457 subSet = keySet.subSet(startKey, false, endKey, false); 10458 assertEquals(0, subSet.size()); 10459 10460 subSet = keySet.subSet(startKey, false, endKey, true); 10461 assertEquals(1, subSet.size()); 10462 subSetIterator = subSet.iterator(); 10463 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10464 try { 10465 subSetIterator.next(); 10466 fail("should throw NoSuchElementException"); 10467 } catch (NoSuchElementException e) { 10468 // Expected 10469 } 10470 10471 subSet = keySet.subSet(startKey, true, endKey, false); 10472 assertEquals(1, subSet.size()); 10473 subSetIterator = subSet.iterator(); 10474 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10475 try { 10476 subSetIterator.next(); 10477 fail("should throw NoSuchElementException"); 10478 } catch (NoSuchElementException e) { 10479 // Expected 10480 } 10481 10482 subSet = keySet.subSet(startKey, true, endKey, true); 10483 assertEquals(2, subSet.size()); 10484 subSetIterator = subSet.iterator(); 10485 assertEquals(new Integer(0).toString(), subSetIterator.next()); 10486 assertEquals(new Integer(1).toString(), subSetIterator.next()); 10487 try { 10488 subSetIterator.next(); 10489 fail("should throw NoSuchElementException"); 10490 } catch (NoSuchElementException e) { 10491 // Expected 10492 } 10493 10494 try { 10495 keySet.subSet(null, null); 10496 fail("should throw NPE"); 10497 } catch (NullPointerException e) { 10498 // Expected 10499 } 10500 10501 try { 10502 keySet.subSet(null, false, null, false); 10503 fail("should throw NPE"); 10504 } catch (NullPointerException e) { 10505 // Expected 10506 } 10507 10508 try { 10509 keySet.subSet(null, false, null, true); 10510 fail("should throw NPE"); 10511 } catch (NullPointerException e) { 10512 // Expected 10513 } 10514 10515 try { 10516 keySet.subSet(null, true, null, false); 10517 fail("should throw NPE"); 10518 } catch (NullPointerException e) { 10519 // Expected 10520 } 10521 10522 try { 10523 keySet.subSet(null, true, null, true); 10524 fail("should throw NPE"); 10525 } catch (NullPointerException e) { 10526 // Expected 10527 } 10528 10529 try { 10530 keySet.subSet(null, endKey); 10531 fail("should throw NPE"); 10532 } catch (NullPointerException e) { 10533 // Expected 10534 } 10535 10536 try { 10537 keySet.subSet(null, false, endKey, false); 10538 fail("should throw NPE"); 10539 } catch (NullPointerException e) { 10540 // Expected 10541 } 10542 10543 try { 10544 keySet.subSet(null, false, endKey, true); 10545 fail("should throw NPE"); 10546 } catch (NullPointerException e) { 10547 // Expected 10548 } 10549 10550 try { 10551 keySet.subSet(null, true, endKey, false); 10552 fail("should throw NPE"); 10553 } catch (NullPointerException e) { 10554 // Expected 10555 } 10556 10557 try { 10558 keySet.subSet(null, true, endKey, true); 10559 fail("should throw NPE"); 10560 } catch (NullPointerException e) { 10561 // Expected 10562 } 10563 10564 try { 10565 keySet.subSet(startKey, null); 10566 fail("should throw NPE"); 10567 } catch (NullPointerException e) { 10568 // Expected 10569 } 10570 10571 try { 10572 keySet.subSet(startKey, false, null, false); 10573 fail("should throw NPE"); 10574 } catch (NullPointerException e) { 10575 // Expected 10576 } 10577 10578 try { 10579 keySet.subSet(startKey, false, null, true); 10580 fail("should throw NPE"); 10581 } catch (NullPointerException e) { 10582 // Expected 10583 } 10584 10585 try { 10586 keySet.subSet(startKey, true, null, false); 10587 fail("should throw NPE"); 10588 } catch (NullPointerException e) { 10589 // Expected 10590 } 10591 10592 try { 10593 keySet.subSet(startKey, true, null, true); 10594 fail("should throw NPE"); 10595 } catch (NullPointerException e) { 10596 // Expected 10597 } 10598 10599 } 10600 10601 public void test_AscendingSubMapKeySet_lower() { 10602 NavigableSet keySet; 10603 Iterator iterator; 10604 String key, lowerKey; 10605 int value, lowerValue; 10606 10607 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10608 iterator = keySet.iterator(); 10609 while (iterator.hasNext()) { 10610 key = (String) iterator.next(); 10611 value = Integer.valueOf(key); 10612 lowerKey = (String) keySet.lower(key); 10613 if (value > 101) { 10614 lowerValue = Integer.valueOf(lowerKey); 10615 assertEquals(value - 1, lowerValue); 10616 } else { 10617 assertNull(lowerKey); 10618 } 10619 } 10620 10621 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10622 iterator = keySet.iterator(); 10623 while (iterator.hasNext()) { 10624 key = (String) iterator.next(); 10625 value = Integer.valueOf(key); 10626 lowerKey = (String) keySet.lower(key); 10627 if (value > 101) { 10628 lowerValue = Integer.valueOf(lowerKey); 10629 assertEquals(value - 1, lowerValue); 10630 } else { 10631 assertNull(lowerKey); 10632 } 10633 } 10634 10635 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10636 iterator = keySet.iterator(); 10637 while (iterator.hasNext()) { 10638 key = (String) iterator.next(); 10639 value = Integer.valueOf(key); 10640 lowerKey = (String) keySet.lower(key); 10641 if (value > 100) { 10642 lowerValue = Integer.valueOf(lowerKey); 10643 assertEquals(value - 1, lowerValue); 10644 } else { 10645 assertNull(lowerKey); 10646 } 10647 } 10648 10649 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10650 iterator = keySet.iterator(); 10651 while (iterator.hasNext()) { 10652 key = (String) iterator.next(); 10653 value = Integer.valueOf(key); 10654 lowerKey = (String) keySet.lower(key); 10655 if (value > 100) { 10656 lowerValue = Integer.valueOf(lowerKey); 10657 assertEquals(value - 1, lowerValue); 10658 } else { 10659 assertNull(lowerKey); 10660 } 10661 } 10662 10663 key = new Integer(2).toString(); 10664 keySet = tm.headMap(key, true).navigableKeySet(); 10665 iterator = keySet.iterator(); 10666 iterator.next();// 0 10667 String expectedLowerKey = (String) iterator.next();// 1 10668 assertEquals(expectedLowerKey, keySet.lower(iterator.next())); 10669 10670 try { 10671 keySet.lower(null); 10672 fail("should throw NPE"); 10673 } catch (NullPointerException e) { 10674 // Expected 10675 } 10676 10677 key = new Integer(0).toString(); 10678 keySet = tm.headMap(key, true).navigableKeySet(); 10679 assertNull(keySet.lower(key)); 10680 10681 key = new Integer(0).toString(); 10682 keySet = tm.headMap(key, false).navigableKeySet(); 10683 assertNull(keySet.lower(key)); 10684 10685 key = new Integer(999).toString(); 10686 keySet = tm.headMap(key, true).navigableKeySet(); 10687 assertNotNull(keySet.lower(key)); 10688 10689 key = new Integer(999).toString(); 10690 keySet = tm.headMap(key, false).navigableKeySet(); 10691 assertNotNull(keySet.lower(key)); 10692 } 10693 10694 public void test_AscendingSubMapKeySet_higher() { 10695 NavigableSet keySet; 10696 Iterator iterator; 10697 String key, lowerKey; 10698 int value, lowerValue; 10699 10700 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10701 iterator = keySet.iterator(); 10702 while (iterator.hasNext()) { 10703 key = (String) iterator.next(); 10704 value = Integer.valueOf(key); 10705 lowerKey = (String) keySet.higher(key); 10706 if (value < 108) { 10707 lowerValue = Integer.valueOf(lowerKey); 10708 assertEquals(value + 1, lowerValue); 10709 } else { 10710 assertNull(lowerKey); 10711 } 10712 } 10713 10714 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10715 iterator = keySet.iterator(); 10716 while (iterator.hasNext()) { 10717 key = (String) iterator.next(); 10718 value = Integer.valueOf(key); 10719 lowerKey = (String) keySet.higher(key); 10720 if (value < 109) { 10721 lowerValue = Integer.valueOf(lowerKey); 10722 assertEquals(value + 1, lowerValue); 10723 } else { 10724 assertNull(lowerKey); 10725 } 10726 } 10727 10728 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10729 iterator = keySet.iterator(); 10730 while (iterator.hasNext()) { 10731 key = (String) iterator.next(); 10732 value = Integer.valueOf(key); 10733 lowerKey = (String) keySet.higher(key); 10734 if (value < 108) { 10735 lowerValue = Integer.valueOf(lowerKey); 10736 assertEquals(value + 1, lowerValue); 10737 } else { 10738 assertNull(lowerKey); 10739 } 10740 } 10741 10742 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10743 iterator = keySet.iterator(); 10744 while (iterator.hasNext()) { 10745 key = (String) iterator.next(); 10746 value = Integer.valueOf(key); 10747 lowerKey = (String) keySet.higher(key); 10748 if (value < 109) { 10749 lowerValue = Integer.valueOf(lowerKey); 10750 assertEquals(value + 1, lowerValue); 10751 } else { 10752 assertNull(lowerKey); 10753 } 10754 } 10755 10756 key = new Integer(2).toString(); 10757 keySet = tm.headMap(key, true).navigableKeySet(); 10758 iterator = keySet.iterator(); 10759 iterator.next();// 0 10760 iterator.next();// 1 10761 lowerKey = (String) keySet.higher(iterator.next()); 10762 String expectedLowerKey = (String) iterator.next(); 10763 assertEquals(expectedLowerKey, lowerKey); 10764 10765 try { 10766 keySet.higher(null); 10767 fail("should throw NPE"); 10768 } catch (NullPointerException e) { 10769 // Expected 10770 } 10771 10772 key = new Integer(0).toString(); 10773 keySet = tm.headMap(key, true).navigableKeySet(); 10774 assertNull(keySet.higher(key)); 10775 10776 key = new Integer(0).toString(); 10777 keySet = tm.headMap(key, false).navigableKeySet(); 10778 assertNull(keySet.higher(key)); 10779 10780 key = new Integer(999).toString(); 10781 keySet = tm.headMap(key, true).navigableKeySet(); 10782 assertNull(keySet.higher(key)); 10783 10784 key = new Integer(999).toString(); 10785 keySet = tm.headMap(key, false).navigableKeySet(); 10786 assertNull(keySet.higher(key)); 10787 } 10788 10789 public void test_AscendingSubMapKeySet_ceiling() { 10790 NavigableSet keySet; 10791 String key; 10792 String[] keyArray; 10793 10794 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10795 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10796 for (int i = 0, j = 101; i < keyArray.length; i++) { 10797 key = (String) keySet.ceiling(keyArray[i]); 10798 assertEquals(new Integer(i + j).toString(), key); 10799 } 10800 10801 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10802 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10803 for (int i = 0, j = 101; i < keyArray.length; i++) { 10804 key = (String) keySet.ceiling(keyArray[i]); 10805 assertEquals(new Integer(i + j).toString(), key); 10806 } 10807 10808 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10809 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10810 for (int i = 0, j = 100; i < keyArray.length; i++) { 10811 key = (String) keySet.ceiling(keyArray[i]); 10812 assertEquals(new Integer(i + j).toString(), key); 10813 } 10814 10815 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10816 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10817 for (int i = 0, j = 100; i < keyArray.length; i++) { 10818 key = (String) keySet.ceiling(keyArray[i]); 10819 assertEquals(new Integer(i + j).toString(), key); 10820 } 10821 10822 key = new Integer(2).toString(); 10823 keySet = tm.headMap(key, true).navigableKeySet(); 10824 Iterator iterator = keySet.iterator(); 10825 iterator.next(); 10826 assertEquals(new Integer(1).toString(), keySet.ceiling(iterator.next())); 10827 10828 try { 10829 keySet.ceiling(null); 10830 fail("should throw NPE"); 10831 } catch (NullPointerException e) { 10832 // Expected 10833 } 10834 10835 key = new Integer(0).toString(); 10836 keySet = tm.headMap(key, true).navigableKeySet(); 10837 assertEquals(key, keySet.ceiling(key)); 10838 10839 key = new Integer(0).toString(); 10840 keySet = tm.headMap(key, false).navigableKeySet(); 10841 assertNull(keySet.higher(key)); 10842 10843 key = new Integer(999).toString(); 10844 keySet = tm.headMap(key, true).navigableKeySet(); 10845 assertNull(keySet.higher(key)); 10846 10847 key = new Integer(999).toString(); 10848 keySet = tm.headMap(key, false).navigableKeySet(); 10849 assertNull(keySet.higher(key)); 10850 } 10851 10852 public void test_AscendingSubMapKeySet_floor() { 10853 NavigableSet keySet; 10854 String key; 10855 String[] keyArray; 10856 10857 keySet = navigableMap_startExcluded_endExcluded.navigableKeySet(); 10858 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10859 for (int i = 0, j = 101; i < keyArray.length; i++) { 10860 key = (String) keySet.floor(keyArray[i]); 10861 assertEquals(new Integer(i + j).toString(), key); 10862 } 10863 10864 keySet = navigableMap_startExcluded_endIncluded.navigableKeySet(); 10865 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10866 for (int i = 0, j = 101; i < keyArray.length; i++) { 10867 key = (String) keySet.floor(keyArray[i]); 10868 assertEquals(new Integer(i + j).toString(), key); 10869 } 10870 10871 keySet = navigableMap_startIncluded_endExcluded.navigableKeySet(); 10872 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10873 for (int i = 0, j = 100; i < keyArray.length; i++) { 10874 key = (String) keySet.floor(keyArray[i]); 10875 assertEquals(new Integer(i + j).toString(), key); 10876 } 10877 10878 keySet = navigableMap_startIncluded_endIncluded.navigableKeySet(); 10879 keyArray = (String[]) keySet.toArray(new String[keySet.size()]); 10880 for (int i = 0, j = 100; i < keyArray.length; i++) { 10881 key = (String) keySet.floor(keyArray[i]); 10882 assertEquals(new Integer(i + j).toString(), key); 10883 } 10884 10885 key = new Integer(2).toString(); 10886 keySet = tm.headMap(key, true).navigableKeySet(); 10887 Iterator iterator = keySet.iterator(); 10888 iterator.next(); 10889 assertEquals(new Integer(1).toString(), keySet.floor(iterator.next())); 10890 10891 try { 10892 keySet.floor(null); 10893 fail("should throw NPE"); 10894 } catch (NullPointerException e) { 10895 // Expected 10896 } 10897 10898 key = new Integer(0).toString(); 10899 keySet = tm.headMap(key, true).navigableKeySet(); 10900 assertEquals(key, keySet.floor(key)); 10901 10902 key = new Integer(0).toString(); 10903 keySet = tm.headMap(key, false).navigableKeySet(); 10904 assertNull(keySet.floor(key)); 10905 10906 key = new Integer(999).toString(); 10907 keySet = tm.headMap(key, true).navigableKeySet(); 10908 assertEquals(key, keySet.floor(key)); 10909 10910 key = new Integer(999).toString(); 10911 keySet = tm.headMap(key, false).navigableKeySet(); 10912 assertEquals(new Integer(998).toString(), keySet.floor(key)); 10913 } 10914 10915 public void test_BoundedEntryIterator_next() { 10916 Iterator iterator = subMap_default.entrySet().iterator(); 10917 assertTrue(iterator.hasNext()); 10918 for (int i = 100; iterator.hasNext(); i++) { 10919 assertEquals(i, ((Entry) iterator.next()).getValue()); 10920 } 10921 10922 try { 10923 iterator.next(); 10924 fail("should throw java.util.NoSuchElementException"); 10925 } catch (NoSuchElementException e) { 10926 // Expected 10927 } 10928 10929 } 10930 10931 public void test_BoundedKeyIterator_next() { 10932 Iterator iterator = subMap_default.keySet().iterator(); 10933 assertTrue(iterator.hasNext()); 10934 for (int i = 100; iterator.hasNext(); i++) { 10935 assertEquals(new Integer(i).toString(), iterator.next()); 10936 } 10937 10938 try { 10939 iterator.next(); 10940 fail("should throw java.util.NoSuchElementException"); 10941 } catch (NoSuchElementException e) { 10942 // Expected 10943 } 10944 } 10945 10946 public void test_BoundedValueIterator_next() { 10947 String startKey = new Integer(101).toString(); 10948 String endKey = new Integer(108).toString(); 10949 10950 Collection values = tm.subMap(startKey, endKey).values(); 10951 Iterator iter = values.iterator(); 10952 for (int i = 101; i < 108; i++) { 10953 assertEquals(i, iter.next()); 10954 } 10955 try { 10956 iter.next(); 10957 fail("should throw java.util.NoSuchElementException"); 10958 } catch (Exception e) { 10959 // Expected 10960 } 10961 } 10962 10963 /* 10964 * SubMapEntrySet 10965 */ 10966 public void test_SubMapEntrySet_Constructor() { 10967 } 10968 10969 public void test_SubMapEntrySet_contains() { 10970 // covered in test_SubMapEntrySet_remove 10971 } 10972 10973 public void test_SubMapEntrySet_iterator() { 10974 Set entrySet = subMap_default.entrySet(); 10975 Iterator iterator; 10976 Entry entry; 10977 Integer value = new Integer(100); 10978 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 10979 entry = (Entry) iterator.next(); 10980 assertEquals(value.toString(), entry.getKey()); 10981 assertEquals(value, entry.getValue()); 10982 } 10983 assertEquals(109, value.intValue()); 10984 try { 10985 iterator.next(); 10986 fail("should throw NoSuchElementException"); 10987 } catch (NoSuchElementException e) { 10988 // Expected 10989 } 10990 10991 entrySet = subMap_startExcluded_endExcluded.entrySet(); 10992 value = new Integer(101); 10993 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 10994 entry = (Entry) iterator.next(); 10995 assertEquals(value.toString(), entry.getKey()); 10996 assertEquals(value, entry.getValue()); 10997 } 10998 assertEquals(109, value.intValue()); 10999 try { 11000 iterator.next(); 11001 fail("should throw NoSuchElementException"); 11002 } catch (NoSuchElementException e) { 11003 // Expected 11004 } 11005 11006 entrySet = subMap_startExcluded_endIncluded.entrySet(); 11007 value = new Integer(101); 11008 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11009 entry = (Entry) iterator.next(); 11010 assertEquals(value.toString(), entry.getKey()); 11011 assertEquals(value, entry.getValue()); 11012 } 11013 assertEquals(110, value.intValue()); 11014 try { 11015 iterator.next(); 11016 fail("should throw NoSuchElementException"); 11017 } catch (NoSuchElementException e) { 11018 // Expected 11019 } 11020 11021 entrySet = subMap_startIncluded_endExcluded.entrySet(); 11022 value = new Integer(100); 11023 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11024 entry = (Entry) iterator.next(); 11025 assertEquals(value.toString(), entry.getKey()); 11026 assertEquals(value, entry.getValue()); 11027 } 11028 assertEquals(109, value.intValue()); 11029 try { 11030 iterator.next(); 11031 fail("should throw NoSuchElementException"); 11032 } catch (NoSuchElementException e) { 11033 // Expected 11034 } 11035 11036 entrySet = subMap_startIncluded_endIncluded.entrySet(); 11037 value = new Integer(100); 11038 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11039 entry = (Entry) iterator.next(); 11040 assertEquals(value.toString(), entry.getKey()); 11041 assertEquals(value, entry.getValue()); 11042 } 11043 assertEquals(110, value.intValue()); 11044 try { 11045 iterator.next(); 11046 fail("should throw NoSuchElementException"); 11047 } catch (NoSuchElementException e) { 11048 // Expected 11049 } 11050 11051 String startKey = new Integer(-1).toString(); 11052 String endKey = new Integer(0).toString(); 11053 SortedMap subMap = tm.subMap(startKey, endKey); 11054 entrySet = subMap.entrySet(); 11055 iterator = entrySet.iterator(); 11056 try { 11057 iterator.next(); 11058 fail("should throw NoSuchElementException"); 11059 } catch (NoSuchElementException e) { 11060 // Expected 11061 } 11062 11063 endKey = new Integer(1).toString(); 11064 subMap = tm.subMap(startKey, endKey); 11065 entrySet = subMap.entrySet(); 11066 iterator = entrySet.iterator(); 11067 assertEquals(0, ((Entry) iterator.next()).getValue()); 11068 try { 11069 iterator.next(); 11070 fail("should throw NoSuchElementException"); 11071 } catch (NoSuchElementException e) { 11072 // Expected 11073 } 11074 11075 endKey = new Integer(2000).toString(); 11076 subMap = tm.subMap(startKey, endKey); 11077 entrySet = subMap.entrySet(); 11078 iterator = entrySet.iterator(); 11079 for (int i = 0; i < subMap.size(); i++) { 11080 iterator.next(); 11081 } 11082 try { 11083 iterator.next(); 11084 fail("should throw NoSuchElementException"); 11085 } catch (NoSuchElementException e) { 11086 // Expected 11087 } 11088 11089 startKey = new Integer(9).toString(); 11090 endKey = new Integer(100).toString(); 11091 try { 11092 tm.subMap(startKey, endKey); 11093 fail("should throw IllegalArgumentException"); 11094 } catch (IllegalArgumentException e) { 11095 // Expected 11096 } 11097 11098 // With Comparator 11099 entrySet = subMap_default_comparator.entrySet(); 11100 value = new Integer(100); 11101 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11102 entry = (Entry) iterator.next(); 11103 assertEquals(value.toString(), entry.getKey()); 11104 assertEquals(value, entry.getValue()); 11105 } 11106 assertEquals(109, value.intValue()); 11107 try { 11108 iterator.next(); 11109 fail("should throw NoSuchElementException"); 11110 } catch (NoSuchElementException e) { 11111 // Expected 11112 } 11113 11114 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 11115 value = new Integer(101); 11116 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11117 entry = (Entry) iterator.next(); 11118 assertEquals(value.toString(), entry.getKey()); 11119 assertEquals(value, entry.getValue()); 11120 } 11121 assertEquals(109, value.intValue()); 11122 try { 11123 iterator.next(); 11124 fail("should throw NoSuchElementException"); 11125 } catch (NoSuchElementException e) { 11126 // Expected 11127 } 11128 11129 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 11130 value = new Integer(101); 11131 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11132 entry = (Entry) iterator.next(); 11133 assertEquals(value.toString(), entry.getKey()); 11134 assertEquals(value, entry.getValue()); 11135 } 11136 assertEquals(110, value.intValue()); 11137 try { 11138 iterator.next(); 11139 fail("should throw NoSuchElementException"); 11140 } catch (NoSuchElementException e) { 11141 // Expected 11142 } 11143 11144 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 11145 value = new Integer(100); 11146 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11147 entry = (Entry) iterator.next(); 11148 assertEquals(value.toString(), entry.getKey()); 11149 assertEquals(value, entry.getValue()); 11150 } 11151 assertEquals(109, value.intValue()); 11152 try { 11153 iterator.next(); 11154 fail("should throw NoSuchElementException"); 11155 } catch (NoSuchElementException e) { 11156 // Expected 11157 } 11158 11159 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 11160 value = new Integer(100); 11161 for (iterator = entrySet.iterator(); iterator.hasNext(); value++) { 11162 entry = (Entry) iterator.next(); 11163 assertEquals(value.toString(), entry.getKey()); 11164 assertEquals(value, entry.getValue()); 11165 } 11166 assertEquals(110, value.intValue()); 11167 try { 11168 iterator.next(); 11169 fail("should throw NoSuchElementException"); 11170 } catch (NoSuchElementException e) { 11171 // Expected 11172 } 11173 } 11174 11175 public void test_SubMapEntrySet_remove() { 11176 Set entrySet = subMap_default.entrySet(); 11177 assertFalse(entrySet.remove(null)); 11178 int size = entrySet.size(); 11179 for (int i = 0; i < size; i++) { 11180 Iterator iterator = entrySet.iterator(); 11181 assertTrue(entrySet.remove(iterator.next())); 11182 } 11183 11184 entrySet = subMap_startExcluded_endExcluded.entrySet(); 11185 assertFalse(entrySet.remove(null)); 11186 size = entrySet.size(); 11187 for (int i = 0; i < size; i++) { 11188 Iterator iterator = entrySet.iterator(); 11189 assertTrue(entrySet.remove(iterator.next())); 11190 } 11191 11192 entrySet = subMap_startExcluded_endIncluded.entrySet(); 11193 assertFalse(entrySet.remove(null)); 11194 size = entrySet.size(); 11195 for (int i = 0; i < size; i++) { 11196 Iterator iterator = entrySet.iterator(); 11197 assertTrue(entrySet.remove(iterator.next())); 11198 } 11199 11200 entrySet = subMap_startIncluded_endExcluded.entrySet(); 11201 assertFalse(entrySet.remove(null)); 11202 size = entrySet.size(); 11203 for (int i = 0; i < size; i++) { 11204 Iterator iterator = entrySet.iterator(); 11205 assertTrue(entrySet.remove(iterator.next())); 11206 } 11207 11208 entrySet = subMap_startIncluded_endIncluded.entrySet(); 11209 assertFalse(entrySet.remove(null)); 11210 size = entrySet.size(); 11211 for (int i = 0; i < size; i++) { 11212 Iterator iterator = entrySet.iterator(); 11213 assertTrue(entrySet.remove(iterator.next())); 11214 } 11215 } 11216 11217 public void test_SubMapEntrySet_isEmpty() { 11218 assertFalse(subMap_default.entrySet().isEmpty()); 11219 assertFalse(subMap_startExcluded_endExcluded.entrySet().isEmpty()); 11220 assertFalse(subMap_startExcluded_endIncluded.entrySet().isEmpty()); 11221 assertFalse(subMap_startIncluded_endExcluded.entrySet().isEmpty()); 11222 assertFalse(subMap_startIncluded_endIncluded.entrySet().isEmpty()); 11223 11224 String startKey = new Integer(0).toString(); 11225 String endKey = startKey; 11226 SortedMap subMap = tm.subMap(startKey, endKey); 11227 assertTrue(subMap.entrySet().isEmpty()); 11228 11229 startKey = new Integer(-1).toString(); 11230 subMap = tm.subMap(startKey, endKey); 11231 assertTrue(subMap.entrySet().isEmpty()); 11232 11233 endKey = new Integer(1).toString(); 11234 subMap = tm.subMap(startKey, endKey); 11235 assertFalse(subMap.entrySet().isEmpty()); 11236 } 11237 11238 public void test_SubMapEntrySet_size() { 11239 assertEquals(9, subMap_default.entrySet().size()); 11240 assertEquals(8, subMap_startExcluded_endExcluded.entrySet().size()); 11241 assertEquals(9, subMap_startExcluded_endIncluded.entrySet().size()); 11242 assertEquals(9, subMap_startIncluded_endExcluded.entrySet().size()); 11243 assertEquals(10, subMap_startIncluded_endIncluded.entrySet().size()); 11244 11245 String startKey = new Integer(0).toString(); 11246 String endKey = new Integer(2).toString(); 11247 SortedMap subMap = tm.subMap(startKey, endKey); 11248 assertEquals(112, subMap.entrySet().size()); 11249 11250 startKey = new Integer(0).toString(); 11251 endKey = startKey; 11252 subMap = tm.subMap(startKey, endKey); 11253 assertEquals(0, subMap.entrySet().size()); 11254 11255 startKey = new Integer(-1).toString(); 11256 endKey = startKey; 11257 subMap = tm.subMap(startKey, endKey); 11258 assertEquals(0, subMap.entrySet().size()); 11259 11260 endKey = new Integer(1).toString(); 11261 subMap = tm.subMap(startKey, endKey); 11262 assertEquals(1, subMap.entrySet().size()); 11263 11264 startKey = new Integer(999).toString(); 11265 endKey = startKey; 11266 subMap = tm.subMap(startKey, endKey); 11267 assertEquals(0, subMap.entrySet().size()); 11268 } 11269 11270 /* 11271 * SubMapKeySet 11272 */ 11273 public void test_SubMapKeySet_Constructor() { 11274 // covered in other test 11275 } 11276 11277 public void test_SubMapKeySet_iterator() { 11278 Set keySet = subMap_default.keySet(); 11279 Iterator iterator = keySet.iterator(); 11280 for (int i = 0; i < keySet.size(); i++) { 11281 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11282 } 11283 assertFalse(iterator.hasNext()); 11284 try { 11285 iterator.next(); 11286 fail("should throw NoSuchElementException"); 11287 } catch (NoSuchElementException e) { 11288 // Expected 11289 } 11290 11291 keySet = subMap_startExcluded_endExcluded.keySet(); 11292 iterator = keySet.iterator(); 11293 for (int i = 0; i < keySet.size(); i++) { 11294 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11295 } 11296 assertFalse(iterator.hasNext()); 11297 try { 11298 iterator.next(); 11299 fail("should throw NoSuchElementException"); 11300 } catch (NoSuchElementException e) { 11301 // Expected 11302 } 11303 11304 keySet = subMap_startExcluded_endIncluded.keySet(); 11305 iterator = keySet.iterator(); 11306 for (int i = 0; i < keySet.size(); i++) { 11307 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11308 } 11309 assertFalse(iterator.hasNext()); 11310 try { 11311 iterator.next(); 11312 fail("should throw NoSuchElementException"); 11313 } catch (NoSuchElementException e) { 11314 // Expected 11315 } 11316 11317 keySet = subMap_startIncluded_endExcluded.keySet(); 11318 iterator = keySet.iterator(); 11319 for (int i = 0; i < keySet.size(); i++) { 11320 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11321 } 11322 assertFalse(iterator.hasNext()); 11323 try { 11324 iterator.next(); 11325 fail("should throw NoSuchElementException"); 11326 } catch (NoSuchElementException e) { 11327 // Expected 11328 } 11329 11330 keySet = subMap_startIncluded_endIncluded.keySet(); 11331 iterator = keySet.iterator(); 11332 for (int i = 0; i < keySet.size(); i++) { 11333 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11334 } 11335 assertFalse(iterator.hasNext()); 11336 try { 11337 iterator.next(); 11338 fail("should throw NoSuchElementException"); 11339 } catch (NoSuchElementException e) { 11340 // Expected 11341 } 11342 11343 // With Comparator 11344 keySet = subMap_default_comparator.keySet(); 11345 iterator = keySet.iterator(); 11346 for (int i = 0; i < keySet.size(); i++) { 11347 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11348 } 11349 assertFalse(iterator.hasNext()); 11350 try { 11351 iterator.next(); 11352 fail("should throw NoSuchElementException"); 11353 } catch (NoSuchElementException e) { 11354 // Expected 11355 } 11356 11357 keySet = subMap_startExcluded_endExcluded_comparator.keySet(); 11358 iterator = keySet.iterator(); 11359 for (int i = 0; i < keySet.size(); i++) { 11360 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11361 } 11362 assertFalse(iterator.hasNext()); 11363 try { 11364 iterator.next(); 11365 fail("should throw NoSuchElementException"); 11366 } catch (NoSuchElementException e) { 11367 // Expected 11368 } 11369 11370 keySet = subMap_startExcluded_endIncluded_comparator.keySet(); 11371 iterator = keySet.iterator(); 11372 for (int i = 0; i < keySet.size(); i++) { 11373 assertEquals(new Integer(101 + i).toString(), iterator.next()); 11374 } 11375 assertFalse(iterator.hasNext()); 11376 try { 11377 iterator.next(); 11378 fail("should throw NoSuchElementException"); 11379 } catch (NoSuchElementException e) { 11380 // Expected 11381 } 11382 11383 keySet = subMap_startIncluded_endExcluded_comparator.keySet(); 11384 iterator = keySet.iterator(); 11385 for (int i = 0; i < keySet.size(); i++) { 11386 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11387 } 11388 assertFalse(iterator.hasNext()); 11389 try { 11390 iterator.next(); 11391 fail("should throw NoSuchElementException"); 11392 } catch (NoSuchElementException e) { 11393 // Expected 11394 } 11395 11396 keySet = subMap_startIncluded_endIncluded_comparator.keySet(); 11397 iterator = keySet.iterator(); 11398 for (int i = 0; i < keySet.size(); i++) { 11399 assertEquals(new Integer(100 + i).toString(), iterator.next()); 11400 } 11401 assertFalse(iterator.hasNext()); 11402 try { 11403 iterator.next(); 11404 fail("should throw NoSuchElementException"); 11405 } catch (NoSuchElementException e) { 11406 // Expected 11407 } 11408 } 11409 11410 public void test_SubMapKeySet_isEmpty() { 11411 assertFalse(subMap_default.keySet().isEmpty()); 11412 assertFalse(subMap_startExcluded_endExcluded.keySet().isEmpty()); 11413 assertFalse(subMap_startExcluded_endIncluded.keySet().isEmpty()); 11414 assertFalse(subMap_startIncluded_endExcluded.keySet().isEmpty()); 11415 assertFalse(subMap_startIncluded_endIncluded.keySet().isEmpty()); 11416 11417 String startKey = new Integer(0).toString(); 11418 String endKey = startKey; 11419 SortedMap subMap = tm.subMap(startKey, endKey); 11420 assertTrue(subMap.keySet().isEmpty()); 11421 11422 startKey = new Integer(999).toString(); 11423 endKey = startKey; 11424 subMap = tm.subMap(startKey, endKey); 11425 assertTrue(subMap.keySet().isEmpty()); 11426 11427 startKey = new Integer(-1).toString(); 11428 endKey = new Integer(1).toString(); 11429 subMap = tm.subMap(startKey, endKey); 11430 assertFalse(subMap.keySet().isEmpty()); 11431 11432 endKey = new Integer(0).toString(); 11433 subMap = tm.subMap(startKey, endKey); 11434 assertTrue(subMap.keySet().isEmpty()); 11435 } 11436 11437 public void test_SubMapKeySet_contains() { 11438 Set keySet = subMap_default.keySet(); 11439 try { 11440 keySet.contains(null); 11441 fail("should throw NullPointerException"); 11442 } catch (NullPointerException e) { 11443 // Expected 11444 } 11445 String key = new Integer(-1).toString(); 11446 assertFalse(keySet.contains(key)); 11447 key = new Integer(99).toString(); 11448 assertFalse(keySet.contains(key)); 11449 key = new Integer(100).toString(); 11450 assertTrue(keySet.contains(key)); 11451 for (int i = 101; i < 109; i++) { 11452 key = new Integer(i).toString(); 11453 assertTrue(keySet.contains(key)); 11454 } 11455 key = new Integer(109).toString(); 11456 assertFalse(keySet.contains(key)); 11457 key = new Integer(110).toString(); 11458 assertFalse(keySet.contains(key)); 11459 key = new Integer(1001).toString(); 11460 assertFalse(keySet.contains(key)); 11461 11462 keySet = subMap_startExcluded_endExcluded.keySet(); 11463 try { 11464 keySet.contains(null); 11465 fail("should throw NullPointerException"); 11466 } catch (NullPointerException e) { 11467 // Expected 11468 } 11469 key = new Integer(-1).toString(); 11470 assertFalse(keySet.contains(key)); 11471 key = new Integer(99).toString(); 11472 assertFalse(keySet.contains(key)); 11473 key = new Integer(100).toString(); 11474 assertFalse(keySet.contains(key)); 11475 for (int i = 101; i < 109; i++) { 11476 key = new Integer(i).toString(); 11477 assertTrue(keySet.contains(key)); 11478 } 11479 key = new Integer(109).toString(); 11480 assertFalse(keySet.contains(key)); 11481 key = new Integer(110).toString(); 11482 assertFalse(keySet.contains(key)); 11483 key = new Integer(1001).toString(); 11484 assertFalse(keySet.contains(key)); 11485 11486 keySet = subMap_startExcluded_endIncluded.keySet(); 11487 try { 11488 keySet.contains(null); 11489 fail("should throw NullPointerException"); 11490 } catch (NullPointerException e) { 11491 // Expected 11492 } 11493 key = new Integer(-1).toString(); 11494 assertFalse(keySet.contains(key)); 11495 key = new Integer(99).toString(); 11496 assertFalse(keySet.contains(key)); 11497 key = new Integer(100).toString(); 11498 assertFalse(keySet.contains(key)); 11499 for (int i = 101; i < 109; i++) { 11500 key = new Integer(i).toString(); 11501 assertTrue(keySet.contains(key)); 11502 } 11503 key = new Integer(109).toString(); 11504 assertTrue(keySet.contains(key)); 11505 key = new Integer(110).toString(); 11506 assertFalse(keySet.contains(key)); 11507 key = new Integer(1001).toString(); 11508 assertFalse(keySet.contains(key)); 11509 11510 keySet = subMap_startIncluded_endExcluded.keySet(); 11511 try { 11512 keySet.contains(null); 11513 fail("should throw NullPointerException"); 11514 } catch (NullPointerException e) { 11515 // Expected 11516 } 11517 key = new Integer(-1).toString(); 11518 assertFalse(keySet.contains(key)); 11519 key = new Integer(99).toString(); 11520 assertFalse(keySet.contains(key)); 11521 key = new Integer(100).toString(); 11522 assertTrue(keySet.contains(key)); 11523 for (int i = 101; i < 109; i++) { 11524 key = new Integer(i).toString(); 11525 assertTrue(keySet.contains(key)); 11526 } 11527 key = new Integer(109).toString(); 11528 assertFalse(keySet.contains(key)); 11529 key = new Integer(110).toString(); 11530 assertFalse(keySet.contains(key)); 11531 key = new Integer(1001).toString(); 11532 assertFalse(keySet.contains(key)); 11533 11534 keySet = subMap_startIncluded_endIncluded.keySet(); 11535 try { 11536 keySet.contains(null); 11537 fail("should throw NullPointerException"); 11538 } catch (NullPointerException e) { 11539 // Expected 11540 } 11541 key = new Integer(-1).toString(); 11542 assertFalse(keySet.contains(key)); 11543 key = new Integer(99).toString(); 11544 assertFalse(keySet.contains(key)); 11545 key = new Integer(100).toString(); 11546 assertTrue(keySet.contains(key)); 11547 for (int i = 101; i < 109; i++) { 11548 key = new Integer(i).toString(); 11549 assertTrue(keySet.contains(key)); 11550 } 11551 key = new Integer(109).toString(); 11552 assertTrue(keySet.contains(key)); 11553 key = new Integer(110).toString(); 11554 assertFalse(keySet.contains(key)); 11555 key = new Integer(1001).toString(); 11556 assertFalse(keySet.contains(key)); 11557 } 11558 11559 public void test_SubMapKeySet_size() { 11560 assertEquals(9, subMap_default.keySet().size()); 11561 assertEquals(8, subMap_startExcluded_endExcluded.keySet().size()); 11562 assertEquals(9, subMap_startExcluded_endIncluded.keySet().size()); 11563 assertEquals(9, subMap_startIncluded_endExcluded.keySet().size()); 11564 assertEquals(10, subMap_startIncluded_endIncluded.keySet().size()); 11565 11566 String startKey = new Integer(0).toString(); 11567 String endKey = new Integer(2).toString(); 11568 SortedMap subMap = tm.subMap(startKey, endKey); 11569 assertEquals(112, subMap.keySet().size()); 11570 11571 startKey = new Integer(0).toString(); 11572 endKey = startKey; 11573 subMap = tm.subMap(startKey, endKey); 11574 assertEquals(0, subMap.keySet().size()); 11575 11576 startKey = new Integer(-1).toString(); 11577 endKey = startKey; 11578 subMap = tm.subMap(startKey, endKey); 11579 assertEquals(0, subMap.keySet().size()); 11580 11581 endKey = new Integer(1).toString(); 11582 subMap = tm.subMap(startKey, endKey); 11583 assertEquals(1, subMap.keySet().size()); 11584 11585 startKey = new Integer(999).toString(); 11586 endKey = startKey; 11587 subMap = tm.subMap(startKey, endKey); 11588 assertEquals(0, subMap.keySet().size()); 11589 } 11590 11591 public void test_SubMapKeySet_remove() { 11592 Set keySet = subMap_default.keySet(); 11593 try { 11594 keySet.remove(null); 11595 fail("should throw NullPointerException"); 11596 } catch (NullPointerException e) { 11597 // Expected 11598 } 11599 int size = keySet.size(); 11600 for (int i = 0; i < size; i++) { 11601 Iterator iterator = keySet.iterator(); 11602 assertTrue(keySet.remove(iterator.next())); 11603 } 11604 11605 keySet = subMap_startExcluded_endExcluded.keySet(); 11606 try { 11607 keySet.remove(null); 11608 fail("should throw NullPointerException"); 11609 } catch (NullPointerException e) { 11610 // Expected 11611 } 11612 size = keySet.size(); 11613 for (int i = 0; i < size; i++) { 11614 Iterator iterator = keySet.iterator(); 11615 assertTrue(keySet.remove(iterator.next())); 11616 } 11617 11618 keySet = subMap_startExcluded_endIncluded.keySet(); 11619 try { 11620 keySet.remove(null); 11621 fail("should throw NullPointerException"); 11622 } catch (NullPointerException e) { 11623 // Expected 11624 } 11625 size = keySet.size(); 11626 for (int i = 0; i < size; i++) { 11627 Iterator iterator = keySet.iterator(); 11628 assertTrue(keySet.remove(iterator.next())); 11629 } 11630 11631 keySet = subMap_startIncluded_endExcluded.keySet(); 11632 try { 11633 keySet.remove(null); 11634 fail("should throw NullPointerException"); 11635 } catch (NullPointerException e) { 11636 // Expected 11637 } 11638 size = keySet.size(); 11639 for (int i = 0; i < size; i++) { 11640 Iterator iterator = keySet.iterator(); 11641 assertTrue(keySet.remove(iterator.next())); 11642 } 11643 11644 keySet = subMap_startIncluded_endIncluded.keySet(); 11645 try { 11646 keySet.remove(null); 11647 fail("should throw NullPointerException"); 11648 } catch (NullPointerException e) { 11649 // Expected 11650 } 11651 size = keySet.size(); 11652 for (int i = 0; i < size; i++) { 11653 Iterator iterator = keySet.iterator(); 11654 assertTrue(keySet.remove(iterator.next())); 11655 } 11656 } 11657 11658 /* 11659 * AscendingSubMapEntrySet 11660 */ 11661 11662 public void test_AscendingSubMapEntrySet_comparator() { 11663 Set entrySet; 11664 NavigableSet ascendingSubMapEntrySet; 11665 11666 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11667 if (entrySet instanceof NavigableSet) { 11668 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11669 assertNull(ascendingSubMapEntrySet.comparator()); 11670 } 11671 11672 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11673 if (entrySet instanceof NavigableSet) { 11674 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11675 assertNull(ascendingSubMapEntrySet.comparator()); 11676 } 11677 11678 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11679 if (entrySet instanceof NavigableSet) { 11680 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11681 assertNull(ascendingSubMapEntrySet.comparator()); 11682 } 11683 11684 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11685 if (entrySet instanceof NavigableSet) { 11686 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11687 assertNull(ascendingSubMapEntrySet.comparator()); 11688 } 11689 } 11690 11691 public void test_AscendingSubMapEntrySet_descendingSet() { 11692 Set entrySet; 11693 NavigableSet ascendingSubMapEntrySet, descendingSet; 11694 Entry entry; 11695 int value; 11696 Iterator iterator; 11697 11698 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11699 if (entrySet instanceof NavigableSet) { 11700 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11701 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11702 iterator = descendingSet.iterator(); 11703 assertTrue(iterator.hasNext()); 11704 for (value = 108; iterator.hasNext(); value--) { 11705 entry = (Entry) iterator.next(); 11706 assertEquals(value, entry.getValue()); 11707 } 11708 assertEquals(100, value); 11709 } 11710 11711 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11712 if (entrySet instanceof NavigableSet) { 11713 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11714 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11715 iterator = descendingSet.iterator(); 11716 assertTrue(iterator.hasNext()); 11717 for (value = 109; iterator.hasNext(); value--) { 11718 entry = (Entry) iterator.next(); 11719 assertEquals(value, entry.getValue()); 11720 } 11721 assertEquals(100, value); 11722 } 11723 11724 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11725 if (entrySet instanceof NavigableSet) { 11726 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11727 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11728 iterator = descendingSet.iterator(); 11729 assertTrue(iterator.hasNext()); 11730 for (value = 108; iterator.hasNext(); value--) { 11731 entry = (Entry) iterator.next(); 11732 assertEquals(value, entry.getValue()); 11733 } 11734 assertEquals(99, value); 11735 } 11736 11737 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11738 if (entrySet instanceof NavigableSet) { 11739 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11740 descendingSet = ascendingSubMapEntrySet.descendingSet(); 11741 iterator = descendingSet.iterator(); 11742 assertTrue(iterator.hasNext()); 11743 for (value = 109; iterator.hasNext(); value--) { 11744 entry = (Entry) iterator.next(); 11745 assertEquals(value, entry.getValue()); 11746 } 11747 assertEquals(99, value); 11748 } 11749 } 11750 11751 public void test_AscendingSubMapEntrySet_descendingIterator() { 11752 Set entrySet; 11753 NavigableSet ascendingSubMapEntrySet; 11754 Iterator iterator; 11755 Entry entry; 11756 int value; 11757 11758 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11759 if (entrySet instanceof NavigableSet) { 11760 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11761 iterator = ascendingSubMapEntrySet.descendingIterator(); 11762 assertTrue(iterator.hasNext()); 11763 for (value = 108; iterator.hasNext(); value--) { 11764 entry = (Entry) iterator.next(); 11765 assertEquals(value, entry.getValue()); 11766 } 11767 assertEquals(100, value); 11768 } 11769 11770 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11771 if (entrySet instanceof NavigableSet) { 11772 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11773 iterator = ascendingSubMapEntrySet.descendingIterator(); 11774 assertTrue(iterator.hasNext()); 11775 for (value = 109; iterator.hasNext(); value--) { 11776 entry = (Entry) iterator.next(); 11777 assertEquals(value, entry.getValue()); 11778 } 11779 assertEquals(100, value); 11780 } 11781 11782 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11783 if (entrySet instanceof NavigableSet) { 11784 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11785 iterator = ascendingSubMapEntrySet.descendingIterator(); 11786 assertTrue(iterator.hasNext()); 11787 for (value = 108; iterator.hasNext(); value--) { 11788 entry = (Entry) iterator.next(); 11789 assertEquals(value, entry.getValue()); 11790 } 11791 assertEquals(99, value); 11792 } 11793 11794 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11795 if (entrySet instanceof NavigableSet) { 11796 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11797 iterator = ascendingSubMapEntrySet.descendingIterator(); 11798 assertTrue(iterator.hasNext()); 11799 for (value = 109; iterator.hasNext(); value--) { 11800 entry = (Entry) iterator.next(); 11801 assertEquals(value, entry.getValue()); 11802 } 11803 assertEquals(99, value); 11804 } 11805 11806 String startKey = new Integer(2).toString(); 11807 entrySet = tm.headMap(startKey, true).entrySet(); 11808 if (entrySet instanceof NavigableSet) { 11809 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11810 iterator = ascendingSubMapEntrySet.descendingIterator(); 11811 assertTrue(iterator.hasNext()); 11812 assertEquals(2, ((Entry) iterator.next()).getValue()); 11813 } 11814 } 11815 11816 public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endExcluded() { 11817 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11818 if (entrySet instanceof NavigableSet) { 11819 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11820 for (int value = 101; value < 109; value++) { 11821 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11822 assertEquals(value, entry.getValue()); 11823 } 11824 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11825 // should return null if the set is empty. 11826 assertNull(ascendingSubMapEntrySet.pollFirst()); 11827 } 11828 } 11829 11830 public void test_AscendingSubMapEntrySet_pollFirst_startExcluded_endIncluded() { 11831 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11832 if (entrySet instanceof NavigableSet) { 11833 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11834 for (int value = 101; value < 110; value++) { 11835 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11836 assertEquals(value, entry.getValue()); 11837 } 11838 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11839 // should return null if the set is empty. 11840 assertNull(ascendingSubMapEntrySet.pollFirst()); 11841 } 11842 } 11843 11844 public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endExcluded() { 11845 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11846 if (entrySet instanceof NavigableSet) { 11847 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11848 for (int value = 100; value < 109; value++) { 11849 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11850 assertEquals(value, entry.getValue()); 11851 } 11852 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11853 // should return null if the set is empty. 11854 assertNull(ascendingSubMapEntrySet.pollFirst()); 11855 } 11856 } 11857 11858 public void test_AscendingSubMapEntrySet_pollFirst_startIncluded_endIncluded() { 11859 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11860 if (entrySet instanceof NavigableSet) { 11861 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11862 for (int value = 100; value < 110; value++) { 11863 Entry entry = (Entry) ascendingSubMapEntrySet.pollFirst(); 11864 assertEquals(value, entry.getValue()); 11865 } 11866 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11867 // should return null if the set is empty. 11868 assertNull(ascendingSubMapEntrySet.pollFirst()); 11869 } 11870 } 11871 11872 public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endExcluded() { 11873 Set entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11874 if (entrySet instanceof NavigableSet) { 11875 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11876 for (int value = 108; value > 100; value--) { 11877 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 11878 assertEquals(value, entry.getValue()); 11879 } 11880 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11881 // should return null if the set is empty 11882 assertNull(ascendingSubMapEntrySet.pollLast()); 11883 } 11884 11885 // NavigableMap ascendingSubMap = tm.headMap("2", true); 11886 // Set entrySet = ascendingSubMap.entrySet(); 11887 // Object last; 11888 // if (entrySet instanceof NavigableSet) { 11889 // last = ((NavigableSet) entrySet).pollLast(); 11890 // assertEquals("2=2", last.toString()); 11891 // } 11892 // 11893 // ascendingSubMap = tm.tailMap("2", true); 11894 // entrySet = ascendingSubMap.entrySet(); 11895 // if (entrySet instanceof NavigableSet) { 11896 // last = ((NavigableSet) entrySet).pollLast(); 11897 // assertEquals("999=999", last.toString()); 11898 // } 11899 } 11900 11901 public void test_AscendingSubMapEntrySet_pollLast_startExcluded_endIncluded() { 11902 Set entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 11903 if (entrySet instanceof NavigableSet) { 11904 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11905 for (int value = 109; value > 100; value--) { 11906 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 11907 assertEquals(value, entry.getValue()); 11908 } 11909 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11910 // should return null if the set is empty 11911 assertNull(ascendingSubMapEntrySet.pollLast()); 11912 } 11913 } 11914 11915 public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endExcluded() { 11916 Set entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 11917 if (entrySet instanceof NavigableSet) { 11918 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11919 for (int value = 108; value > 99; value--) { 11920 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 11921 assertEquals(value, entry.getValue()); 11922 } 11923 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11924 // should return null if the set is empty 11925 assertNull(ascendingSubMapEntrySet.pollLast()); 11926 } 11927 } 11928 11929 public void test_AscendingSubMapEntrySet_pollLast_startIncluded_endIncluded() { 11930 Set entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 11931 if (entrySet instanceof NavigableSet) { 11932 NavigableSet ascendingSubMapEntrySet = (NavigableSet) entrySet; 11933 for (int value = 109; value > 99; value--) { 11934 Entry entry = (Entry) ascendingSubMapEntrySet.pollLast(); 11935 assertEquals(value, entry.getValue()); 11936 } 11937 assertTrue(ascendingSubMapEntrySet.isEmpty()); 11938 // should return null if the set is empty 11939 assertNull(ascendingSubMapEntrySet.pollLast()); 11940 } 11941 } 11942 11943 public void test_AscendingSubMapEntrySet_headSet() { 11944 Set entrySet, headSet; 11945 NavigableSet ascendingSubMapEntrySet; 11946 Iterator iterator, headSetIterator; 11947 Entry entry; 11948 int value; 11949 11950 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 11951 if (entrySet instanceof NavigableSet) { 11952 ascendingSubMapEntrySet = (NavigableSet) entrySet; 11953 iterator = ascendingSubMapEntrySet.iterator(); 11954 while (iterator.hasNext()) { 11955 entry = (Entry) iterator.next(); 11956 headSet = ascendingSubMapEntrySet.headSet(entry); 11957 headSetIterator = headSet.iterator(); 11958 for (value = 101; headSetIterator.hasNext(); value++) { 11959 assertEquals(value, ((Entry) headSetIterator.next()) 11960 .getValue()); 11961 } 11962 assertEquals(entry.getValue(), value); 11963 try { 11964 headSetIterator.next(); 11965 fail("should throw NoSuchElementException"); 11966 } catch (NoSuchElementException e) { 11967 // Expected 11968 } 11969 11970 headSet = ascendingSubMapEntrySet.headSet(entry, false); 11971 headSetIterator = headSet.iterator(); 11972 for (value = 101; headSetIterator.hasNext(); value++) { 11973 assertEquals(value, ((Entry) headSetIterator.next()) 11974 .getValue()); 11975 } 11976 assertEquals(entry.getValue(), value); 11977 try { 11978 headSetIterator.next(); 11979 fail("should throw NoSuchElementException"); 11980 } catch (NoSuchElementException e) { 11981 // Expected 11982 } 11983 11984 headSet = ascendingSubMapEntrySet.headSet(entry, true); 11985 headSetIterator = headSet.iterator(); 11986 for (value = 101; headSetIterator.hasNext(); value++) { 11987 assertEquals(value, ((Entry) headSetIterator.next()) 11988 .getValue()); 11989 } 11990 assertEquals(entry.getValue(), value - 1); 11991 try { 11992 headSetIterator.next(); 11993 fail("should throw NoSuchElementException"); 11994 } catch (NoSuchElementException e) { 11995 // Expected 11996 } 11997 } 11998 } 11999 12000 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12001 if (entrySet instanceof NavigableSet) { 12002 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12003 iterator = ascendingSubMapEntrySet.iterator(); 12004 while (iterator.hasNext()) { 12005 entry = (Entry) iterator.next(); 12006 headSet = ascendingSubMapEntrySet.headSet(entry); 12007 headSetIterator = headSet.iterator(); 12008 for (value = 101; headSetIterator.hasNext(); value++) { 12009 assertEquals(value, ((Entry) headSetIterator.next()) 12010 .getValue()); 12011 } 12012 assertEquals(entry.getValue(), value); 12013 try { 12014 headSetIterator.next(); 12015 fail("should throw NoSuchElementException"); 12016 } catch (NoSuchElementException e) { 12017 // Expected 12018 } 12019 12020 headSet = ascendingSubMapEntrySet.headSet(entry, false); 12021 headSetIterator = headSet.iterator(); 12022 for (value = 101; headSetIterator.hasNext(); value++) { 12023 assertEquals(value, ((Entry) headSetIterator.next()) 12024 .getValue()); 12025 } 12026 assertEquals(entry.getValue(), value); 12027 try { 12028 headSetIterator.next(); 12029 fail("should throw NoSuchElementException"); 12030 } catch (NoSuchElementException e) { 12031 // Expected 12032 } 12033 12034 headSet = ascendingSubMapEntrySet.headSet(entry, true); 12035 headSetIterator = headSet.iterator(); 12036 for (value = 101; headSetIterator.hasNext(); value++) { 12037 assertEquals(value, ((Entry) headSetIterator.next()) 12038 .getValue()); 12039 } 12040 assertEquals(entry.getValue(), value - 1); 12041 try { 12042 headSetIterator.next(); 12043 fail("should throw NoSuchElementException"); 12044 } catch (NoSuchElementException e) { 12045 // Expected 12046 } 12047 } 12048 } 12049 12050 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12051 if (entrySet instanceof NavigableSet) { 12052 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12053 iterator = ascendingSubMapEntrySet.iterator(); 12054 while (iterator.hasNext()) { 12055 entry = (Entry) iterator.next(); 12056 headSet = ascendingSubMapEntrySet.headSet(entry); 12057 headSetIterator = headSet.iterator(); 12058 for (value = 100; headSetIterator.hasNext(); value++) { 12059 assertEquals(value, ((Entry) headSetIterator.next()) 12060 .getValue()); 12061 } 12062 assertEquals(entry.getValue(), value); 12063 try { 12064 headSetIterator.next(); 12065 fail("should throw NoSuchElementException"); 12066 } catch (NoSuchElementException e) { 12067 // Expected 12068 } 12069 12070 headSet = ascendingSubMapEntrySet.headSet(entry, false); 12071 headSetIterator = headSet.iterator(); 12072 for (value = 100; headSetIterator.hasNext(); value++) { 12073 assertEquals(value, ((Entry) headSetIterator.next()) 12074 .getValue()); 12075 } 12076 assertEquals(entry.getValue(), value); 12077 try { 12078 headSetIterator.next(); 12079 fail("should throw NoSuchElementException"); 12080 } catch (NoSuchElementException e) { 12081 // Expected 12082 } 12083 12084 headSet = ascendingSubMapEntrySet.headSet(entry, true); 12085 headSetIterator = headSet.iterator(); 12086 for (value = 100; headSetIterator.hasNext(); value++) { 12087 assertEquals(value, ((Entry) headSetIterator.next()) 12088 .getValue()); 12089 } 12090 assertEquals(entry.getValue(), value - 1); 12091 try { 12092 headSetIterator.next(); 12093 fail("should throw NoSuchElementException"); 12094 } catch (NoSuchElementException e) { 12095 // Expected 12096 } 12097 } 12098 } 12099 12100 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12101 if (entrySet instanceof NavigableSet) { 12102 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12103 iterator = ascendingSubMapEntrySet.iterator(); 12104 while (iterator.hasNext()) { 12105 entry = (Entry) iterator.next(); 12106 headSet = ascendingSubMapEntrySet.headSet(entry); 12107 headSetIterator = headSet.iterator(); 12108 for (value = 100; headSetIterator.hasNext(); value++) { 12109 assertEquals(value, ((Entry) headSetIterator.next()) 12110 .getValue()); 12111 } 12112 assertEquals(entry.getValue(), value); 12113 try { 12114 headSetIterator.next(); 12115 fail("should throw NoSuchElementException"); 12116 } catch (NoSuchElementException e) { 12117 // Expected 12118 } 12119 12120 headSet = ascendingSubMapEntrySet.headSet(entry, false); 12121 headSetIterator = headSet.iterator(); 12122 for (value = 100; headSetIterator.hasNext(); value++) { 12123 assertEquals(value, ((Entry) headSetIterator.next()) 12124 .getValue()); 12125 } 12126 assertEquals(entry.getValue(), value); 12127 try { 12128 headSetIterator.next(); 12129 fail("should throw NoSuchElementException"); 12130 } catch (NoSuchElementException e) { 12131 // Expected 12132 } 12133 12134 headSet = ascendingSubMapEntrySet.headSet(entry, true); 12135 headSetIterator = headSet.iterator(); 12136 for (value = 100; headSetIterator.hasNext(); value++) { 12137 assertEquals(value, ((Entry) headSetIterator.next()) 12138 .getValue()); 12139 } 12140 assertEquals(entry.getValue(), value - 1); 12141 try { 12142 headSetIterator.next(); 12143 fail("should throw NoSuchElementException"); 12144 } catch (NoSuchElementException e) { 12145 // Expected 12146 } 12147 } 12148 } 12149 12150 // NavigableMap ascendingSubMap = tm.headMap("1", true); 12151 // entrySet = ascendingSubMap.entrySet(); 12152 // if (entrySet instanceof SortedSet) { 12153 // Iterator it = entrySet.iterator(); 12154 // it.next(); 12155 // Object end = it.next();// 1=1 12156 // Set headSet = ((NavigableSet) entrySet).headSet(end);// inclusive 12157 // // false 12158 // assertEquals(1, headSet.size()); 12159 // } 12160 } 12161 12162 public void test_AscendingSubMapEntrySet_tailSet() { 12163 Set entrySet, tailSet; 12164 NavigableSet ascendingSubMapEntrySet; 12165 Iterator iterator, tailSetIterator; 12166 Entry entry; 12167 int value; 12168 12169 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12170 if (entrySet instanceof NavigableSet) { 12171 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12172 iterator = entrySet.iterator(); 12173 while (iterator.hasNext()) { 12174 entry = (Entry) iterator.next(); 12175 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12176 tailSetIterator = tailSet.iterator(); 12177 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12178 .hasNext(); value++) { 12179 assertEquals(value, ((Entry) tailSetIterator.next()) 12180 .getValue()); 12181 } 12182 assertEquals(109, value); 12183 try { 12184 tailSetIterator.next(); 12185 fail("should throw NoSuchElementException"); 12186 } catch (NoSuchElementException e) { 12187 // Expected 12188 } 12189 12190 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12191 tailSetIterator = tailSet.iterator(); 12192 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12193 .hasNext(); value++) { 12194 assertEquals(value, ((Entry) tailSetIterator.next()) 12195 .getValue()); 12196 } 12197 assertEquals(109, value); 12198 try { 12199 tailSetIterator.next(); 12200 fail("should throw NoSuchElementException"); 12201 } catch (NoSuchElementException e) { 12202 // Expected 12203 } 12204 12205 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12206 tailSetIterator = tailSet.iterator(); 12207 for (value = (Integer) entry.getValue(); tailSetIterator 12208 .hasNext(); value++) { 12209 assertEquals(value, ((Entry) tailSetIterator.next()) 12210 .getValue()); 12211 } 12212 assertEquals(109, value); 12213 try { 12214 tailSetIterator.next(); 12215 fail("should throw NoSuchElementException"); 12216 } catch (NoSuchElementException e) { 12217 // Expected 12218 } 12219 } 12220 } 12221 12222 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12223 if (entrySet instanceof NavigableSet) { 12224 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12225 iterator = entrySet.iterator(); 12226 while (iterator.hasNext()) { 12227 entry = (Entry) iterator.next(); 12228 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12229 tailSetIterator = tailSet.iterator(); 12230 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12231 .hasNext(); value++) { 12232 assertEquals(value, ((Entry) tailSetIterator.next()) 12233 .getValue()); 12234 } 12235 assertEquals(110, value); 12236 try { 12237 tailSetIterator.next(); 12238 fail("should throw NoSuchElementException"); 12239 } catch (NoSuchElementException e) { 12240 // Expected 12241 } 12242 12243 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12244 tailSetIterator = tailSet.iterator(); 12245 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12246 .hasNext(); value++) { 12247 assertEquals(value, ((Entry) tailSetIterator.next()) 12248 .getValue()); 12249 } 12250 assertEquals(110, value); 12251 try { 12252 tailSetIterator.next(); 12253 fail("should throw NoSuchElementException"); 12254 } catch (NoSuchElementException e) { 12255 // Expected 12256 } 12257 12258 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12259 tailSetIterator = tailSet.iterator(); 12260 for (value = (Integer) entry.getValue(); tailSetIterator 12261 .hasNext(); value++) { 12262 assertEquals(value, ((Entry) tailSetIterator.next()) 12263 .getValue()); 12264 } 12265 assertEquals(110, value); 12266 try { 12267 tailSetIterator.next(); 12268 fail("should throw NoSuchElementException"); 12269 } catch (NoSuchElementException e) { 12270 // Expected 12271 } 12272 } 12273 } 12274 12275 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12276 if (entrySet instanceof NavigableSet) { 12277 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12278 iterator = entrySet.iterator(); 12279 while (iterator.hasNext()) { 12280 entry = (Entry) iterator.next(); 12281 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12282 tailSetIterator = tailSet.iterator(); 12283 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12284 .hasNext(); value++) { 12285 assertEquals(value, ((Entry) tailSetIterator.next()) 12286 .getValue()); 12287 } 12288 assertEquals(109, value); 12289 try { 12290 tailSetIterator.next(); 12291 fail("should throw NoSuchElementException"); 12292 } catch (NoSuchElementException e) { 12293 // Expected 12294 } 12295 12296 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12297 tailSetIterator = tailSet.iterator(); 12298 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12299 .hasNext(); value++) { 12300 assertEquals(value, ((Entry) tailSetIterator.next()) 12301 .getValue()); 12302 } 12303 assertEquals(109, value); 12304 try { 12305 tailSetIterator.next(); 12306 fail("should throw NoSuchElementException"); 12307 } catch (NoSuchElementException e) { 12308 // Expected 12309 } 12310 12311 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12312 tailSetIterator = tailSet.iterator(); 12313 for (value = (Integer) entry.getValue(); tailSetIterator 12314 .hasNext(); value++) { 12315 assertEquals(value, ((Entry) tailSetIterator.next()) 12316 .getValue()); 12317 } 12318 assertEquals(109, value); 12319 try { 12320 tailSetIterator.next(); 12321 fail("should throw NoSuchElementException"); 12322 } catch (NoSuchElementException e) { 12323 // Expected 12324 } 12325 } 12326 } 12327 12328 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12329 if (entrySet instanceof NavigableSet) { 12330 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12331 iterator = entrySet.iterator(); 12332 while (iterator.hasNext()) { 12333 entry = (Entry) iterator.next(); 12334 tailSet = ascendingSubMapEntrySet.tailSet(entry); 12335 tailSetIterator = tailSet.iterator(); 12336 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12337 .hasNext(); value++) { 12338 assertEquals(value, ((Entry) tailSetIterator.next()) 12339 .getValue()); 12340 } 12341 assertEquals(110, value); 12342 try { 12343 tailSetIterator.next(); 12344 fail("should throw NoSuchElementException"); 12345 } catch (NoSuchElementException e) { 12346 // Expected 12347 } 12348 12349 tailSet = ascendingSubMapEntrySet.tailSet(entry, false); 12350 tailSetIterator = tailSet.iterator(); 12351 for (value = (Integer) entry.getValue() + 1; tailSetIterator 12352 .hasNext(); value++) { 12353 assertEquals(value, ((Entry) tailSetIterator.next()) 12354 .getValue()); 12355 } 12356 assertEquals(110, value); 12357 try { 12358 tailSetIterator.next(); 12359 fail("should throw NoSuchElementException"); 12360 } catch (NoSuchElementException e) { 12361 // Expected 12362 } 12363 12364 tailSet = ascendingSubMapEntrySet.tailSet(entry, true); 12365 tailSetIterator = tailSet.iterator(); 12366 for (value = (Integer) entry.getValue(); tailSetIterator 12367 .hasNext(); value++) { 12368 assertEquals(value, ((Entry) tailSetIterator.next()) 12369 .getValue()); 12370 } 12371 assertEquals(110, value); 12372 try { 12373 tailSetIterator.next(); 12374 fail("should throw NoSuchElementException"); 12375 } catch (NoSuchElementException e) { 12376 // Expected 12377 } 12378 } 12379 } 12380 12381 // NavigableMap ascendingSubMap = tm.headMap("1", true); 12382 // Set entrySet = ascendingSubMap.entrySet(); 12383 // if (entrySet instanceof NavigableSet) { 12384 // Iterator it = entrySet.iterator(); 12385 // Object start = it.next();// 0=0 12386 // Set tailSet = ((NavigableSet) entrySet).tailSet(start);// default 12387 // // inclusive 12388 // // false 12389 // assertEquals(1, tailSet.size()); 12390 // } 12391 } 12392 12393 public void test_AscendingSubMapEntrySet_subSet() { 12394 Set entrySet, subSet; 12395 NavigableSet ascendingSubMapEntrySet; 12396 12397 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12398 if (entrySet instanceof NavigableSet) { 12399 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12400 Iterator iteratorStart = ascendingSubMapEntrySet.iterator(); 12401 while (iteratorStart.hasNext()) { 12402 Entry startEntry = (Entry) iteratorStart.next(); 12403 Iterator iteratorEnd = ascendingSubMapEntrySet.iterator(); 12404 while (iteratorEnd.hasNext()) { 12405 Entry endEntry = (Entry) iteratorEnd.next(); 12406 int startIndex = (Integer) startEntry.getValue(); 12407 int endIndex = (Integer) endEntry.getValue(); 12408 if (startIndex > endIndex) { 12409 try { 12410 ascendingSubMapEntrySet 12411 .subSet(startEntry, endEntry); 12412 fail("should throw IllegalArgumentException"); 12413 } catch (IllegalArgumentException e) { 12414 // Expected 12415 } 12416 12417 try { 12418 ascendingSubMapEntrySet.subSet(startEntry, false, 12419 endEntry, false); 12420 fail("should throw IllegalArgumentException"); 12421 } catch (IllegalArgumentException e) { 12422 // Expected 12423 } 12424 12425 try { 12426 ascendingSubMapEntrySet.subSet(startEntry, false, 12427 endEntry, true); 12428 fail("should throw IllegalArgumentException"); 12429 } catch (IllegalArgumentException e) { 12430 // Expected 12431 } 12432 12433 try { 12434 ascendingSubMapEntrySet.subSet(startEntry, true, 12435 endEntry, false); 12436 fail("should throw IllegalArgumentException"); 12437 } catch (IllegalArgumentException e) { 12438 // Expected 12439 } 12440 12441 try { 12442 ascendingSubMapEntrySet.subSet(startEntry, true, 12443 endEntry, true); 12444 fail("should throw IllegalArgumentException"); 12445 } catch (IllegalArgumentException e) { 12446 // Expected 12447 } 12448 } else { 12449 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12450 endEntry); 12451 Iterator subSetIterator = subSet.iterator(); 12452 for (int index = startIndex + 1; subSetIterator 12453 .hasNext(); index++) { 12454 assertEquals(index, ((Entry) subSetIterator.next()) 12455 .getValue()); 12456 } 12457 12458 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12459 false, endEntry, false); 12460 subSetIterator = subSet.iterator(); 12461 for (int index = startIndex + 1; subSetIterator 12462 .hasNext(); index++) { 12463 assertEquals(index, ((Entry) subSetIterator.next()) 12464 .getValue()); 12465 } 12466 12467 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12468 false, endEntry, true); 12469 subSetIterator = subSet.iterator(); 12470 for (int index = startIndex + 1; subSetIterator 12471 .hasNext(); index++) { 12472 assertEquals(index, ((Entry) subSetIterator.next()) 12473 .getValue()); 12474 } 12475 12476 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12477 true, endEntry, false); 12478 subSetIterator = subSet.iterator(); 12479 for (int index = startIndex; subSetIterator.hasNext(); index++) { 12480 assertEquals(index, ((Entry) subSetIterator.next()) 12481 .getValue()); 12482 } 12483 12484 subSet = ascendingSubMapEntrySet.subSet(startEntry, 12485 true, endEntry, true); 12486 subSetIterator = subSet.iterator(); 12487 for (int index = startIndex; subSetIterator.hasNext(); index++) { 12488 assertEquals(index, ((Entry) subSetIterator.next()) 12489 .getValue()); 12490 } 12491 } 12492 } 12493 } 12494 } 12495 12496 String endKey = new Integer(2).toString(); 12497 entrySet = tm.headMap(endKey, true).entrySet(); 12498 if (entrySet instanceof NavigableSet) { 12499 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12500 Iterator iterator = entrySet.iterator(); 12501 Object startEntry = iterator.next(); 12502 iterator.next(); 12503 Object endEntry = iterator.next(); 12504 subSet = ascendingSubMapEntrySet.subSet(startEntry, endEntry); 12505 assertEquals(1, subSet.size()); 12506 12507 subSet = ascendingSubMapEntrySet.subSet(startEntry, false, 12508 endEntry, false); 12509 assertEquals(1, subSet.size()); 12510 12511 subSet = ascendingSubMapEntrySet.subSet(startEntry, false, 12512 endEntry, true); 12513 assertEquals(2, subSet.size()); 12514 12515 subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry, 12516 false); 12517 assertEquals(2, subSet.size()); 12518 12519 subSet = ascendingSubMapEntrySet.subSet(startEntry, true, endEntry, 12520 true); 12521 assertEquals(3, subSet.size()); 12522 } 12523 } 12524 12525 public void test_AscendingSubMapEntrySet_lower() { 12526 Set entrySet; 12527 NavigableSet ascendingSubMapEntrySet; 12528 Iterator iterator; 12529 Entry entry, lowerEntry; 12530 int value; 12531 12532 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12533 if (entrySet instanceof NavigableSet) { 12534 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12535 iterator = ascendingSubMapEntrySet.iterator(); 12536 while (iterator.hasNext()) { 12537 entry = (Entry) iterator.next(); 12538 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12539 value = (Integer) entry.getValue(); 12540 if (value > 101) { 12541 assertEquals(value - 1, lowerEntry.getValue()); 12542 } else { 12543 assertNull(lowerEntry); 12544 } 12545 } 12546 } 12547 12548 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12549 if (entrySet instanceof NavigableSet) { 12550 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12551 iterator = ascendingSubMapEntrySet.iterator(); 12552 while (iterator.hasNext()) { 12553 entry = (Entry) iterator.next(); 12554 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12555 value = (Integer) entry.getValue(); 12556 if (value > 101) { 12557 assertEquals(value - 1, lowerEntry.getValue()); 12558 } else { 12559 assertNull(lowerEntry); 12560 } 12561 } 12562 } 12563 12564 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12565 if (entrySet instanceof NavigableSet) { 12566 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12567 iterator = ascendingSubMapEntrySet.iterator(); 12568 while (iterator.hasNext()) { 12569 entry = (Entry) iterator.next(); 12570 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12571 value = (Integer) entry.getValue(); 12572 if (value > 100) { 12573 assertEquals(value - 1, lowerEntry.getValue()); 12574 } else { 12575 assertNull(lowerEntry); 12576 } 12577 } 12578 } 12579 12580 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12581 if (entrySet instanceof NavigableSet) { 12582 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12583 iterator = ascendingSubMapEntrySet.iterator(); 12584 while (iterator.hasNext()) { 12585 entry = (Entry) iterator.next(); 12586 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12587 value = (Integer) entry.getValue(); 12588 if (value > 100) { 12589 assertEquals(value - 1, lowerEntry.getValue()); 12590 } else { 12591 assertNull(lowerEntry); 12592 } 12593 } 12594 } 12595 12596 String endKey = new Integer(2).toString(); 12597 entrySet = tm.headMap(endKey, true).entrySet(); 12598 if (entrySet instanceof NavigableSet) { 12599 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12600 iterator = entrySet.iterator(); 12601 Entry expectedEntry = (Entry) iterator.next(); 12602 entry = (Entry) iterator.next(); 12603 assertEquals(expectedEntry, ascendingSubMapEntrySet.lower(entry)); 12604 } 12605 12606 // With Comparator 12607 12608 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 12609 if (entrySet instanceof NavigableSet) { 12610 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12611 iterator = ascendingSubMapEntrySet.iterator(); 12612 while (iterator.hasNext()) { 12613 entry = (Entry) iterator.next(); 12614 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12615 value = (Integer) entry.getValue(); 12616 if (value > 101) { 12617 assertEquals(value - 1, lowerEntry.getValue()); 12618 } else { 12619 assertNull(lowerEntry); 12620 } 12621 } 12622 } 12623 12624 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 12625 if (entrySet instanceof NavigableSet) { 12626 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12627 iterator = ascendingSubMapEntrySet.iterator(); 12628 while (iterator.hasNext()) { 12629 entry = (Entry) iterator.next(); 12630 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12631 value = (Integer) entry.getValue(); 12632 if (value > 101) { 12633 assertEquals(value - 1, lowerEntry.getValue()); 12634 } else { 12635 assertNull(lowerEntry); 12636 } 12637 } 12638 } 12639 12640 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 12641 if (entrySet instanceof NavigableSet) { 12642 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12643 iterator = ascendingSubMapEntrySet.iterator(); 12644 while (iterator.hasNext()) { 12645 entry = (Entry) iterator.next(); 12646 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12647 value = (Integer) entry.getValue(); 12648 if (value > 100) { 12649 assertEquals(value - 1, lowerEntry.getValue()); 12650 } else { 12651 assertNull(lowerEntry); 12652 } 12653 } 12654 } 12655 12656 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 12657 if (entrySet instanceof NavigableSet) { 12658 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12659 iterator = ascendingSubMapEntrySet.iterator(); 12660 while (iterator.hasNext()) { 12661 entry = (Entry) iterator.next(); 12662 lowerEntry = (Entry) ascendingSubMapEntrySet.lower(entry); 12663 value = (Integer) entry.getValue(); 12664 if (value > 100) { 12665 assertEquals(value - 1, lowerEntry.getValue()); 12666 } else { 12667 assertNull(lowerEntry); 12668 } 12669 } 12670 } 12671 } 12672 12673 public void test_AscendingSubMapEntrySet_higher() { 12674 Set entrySet; 12675 NavigableSet ascendingSubMapEntrySet; 12676 Iterator iterator; 12677 Entry entry, lowerEntry; 12678 int value; 12679 12680 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12681 if (entrySet instanceof NavigableSet) { 12682 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12683 iterator = ascendingSubMapEntrySet.iterator(); 12684 while (iterator.hasNext()) { 12685 entry = (Entry) iterator.next(); 12686 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12687 value = (Integer) entry.getValue(); 12688 if (value < 108) { 12689 assertEquals(value + 1, lowerEntry.getValue()); 12690 } else { 12691 assertNull(lowerEntry); 12692 } 12693 } 12694 } 12695 12696 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12697 if (entrySet instanceof NavigableSet) { 12698 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12699 iterator = ascendingSubMapEntrySet.iterator(); 12700 while (iterator.hasNext()) { 12701 entry = (Entry) iterator.next(); 12702 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12703 value = (Integer) entry.getValue(); 12704 if (value < 109) { 12705 assertEquals(value + 1, lowerEntry.getValue()); 12706 } else { 12707 assertNull(lowerEntry); 12708 } 12709 } 12710 } 12711 12712 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12713 if (entrySet instanceof NavigableSet) { 12714 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12715 iterator = ascendingSubMapEntrySet.iterator(); 12716 while (iterator.hasNext()) { 12717 entry = (Entry) iterator.next(); 12718 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12719 value = (Integer) entry.getValue(); 12720 if (value < 108) { 12721 assertEquals(value + 1, lowerEntry.getValue()); 12722 } else { 12723 assertNull(lowerEntry); 12724 } 12725 } 12726 } 12727 12728 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12729 if (entrySet instanceof NavigableSet) { 12730 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12731 iterator = ascendingSubMapEntrySet.iterator(); 12732 while (iterator.hasNext()) { 12733 entry = (Entry) iterator.next(); 12734 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12735 value = (Integer) entry.getValue(); 12736 if (value < 109) { 12737 assertEquals(value + 1, lowerEntry.getValue()); 12738 } else { 12739 assertNull(lowerEntry); 12740 } 12741 } 12742 } 12743 12744 String endKey = new Integer(2).toString(); 12745 entrySet = tm.headMap(endKey, true).entrySet(); 12746 if (entrySet instanceof NavigableSet) { 12747 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12748 iterator = entrySet.iterator(); 12749 entry = (Entry) iterator.next(); 12750 Entry expectedEntry = (Entry) iterator.next(); 12751 assertEquals(expectedEntry, ascendingSubMapEntrySet.higher(entry)); 12752 } 12753 12754 // With Comparator 12755 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 12756 if (entrySet instanceof NavigableSet) { 12757 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12758 iterator = ascendingSubMapEntrySet.iterator(); 12759 while (iterator.hasNext()) { 12760 entry = (Entry) iterator.next(); 12761 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12762 value = (Integer) entry.getValue(); 12763 if (value < 108) { 12764 assertEquals(value + 1, lowerEntry.getValue()); 12765 } else { 12766 assertNull(lowerEntry); 12767 } 12768 } 12769 } 12770 12771 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 12772 if (entrySet instanceof NavigableSet) { 12773 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12774 iterator = ascendingSubMapEntrySet.iterator(); 12775 while (iterator.hasNext()) { 12776 entry = (Entry) iterator.next(); 12777 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12778 value = (Integer) entry.getValue(); 12779 if (value < 109) { 12780 assertEquals(value + 1, lowerEntry.getValue()); 12781 } else { 12782 assertNull(lowerEntry); 12783 } 12784 } 12785 } 12786 12787 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 12788 if (entrySet instanceof NavigableSet) { 12789 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12790 iterator = ascendingSubMapEntrySet.iterator(); 12791 while (iterator.hasNext()) { 12792 entry = (Entry) iterator.next(); 12793 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12794 value = (Integer) entry.getValue(); 12795 if (value < 108) { 12796 assertEquals(value + 1, lowerEntry.getValue()); 12797 } else { 12798 assertNull(lowerEntry); 12799 } 12800 } 12801 } 12802 12803 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 12804 if (entrySet instanceof NavigableSet) { 12805 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12806 iterator = ascendingSubMapEntrySet.iterator(); 12807 while (iterator.hasNext()) { 12808 entry = (Entry) iterator.next(); 12809 lowerEntry = (Entry) ascendingSubMapEntrySet.higher(entry); 12810 value = (Integer) entry.getValue(); 12811 if (value < 109) { 12812 assertEquals(value + 1, lowerEntry.getValue()); 12813 } else { 12814 assertNull(lowerEntry); 12815 } 12816 } 12817 } 12818 } 12819 12820 public void test_AscendingSubMapEntrySet_ceiling() { 12821 Set entrySet; 12822 NavigableSet ascendingSubMapEntrySet; 12823 Iterator iterator; 12824 12825 Set entrySet_beyondBound; 12826 Iterator iterator_beyondBound; 12827 Entry beyondBoundEntry; 12828 12829 Entry entry, lowerEntry; 12830 int value = 0; 12831 12832 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 12833 if (entrySet instanceof NavigableSet) { 12834 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12835 try { 12836 ascendingSubMapEntrySet.ceiling(null); 12837 fail("should throw NullPointerException"); 12838 } catch (NullPointerException e) { 12839 // Expected 12840 } 12841 12842 iterator = ascendingSubMapEntrySet.iterator(); 12843 while (iterator.hasNext()) { 12844 entry = (Entry) iterator.next(); 12845 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12846 value = (Integer) entry.getValue(); 12847 assertEquals(value, lowerEntry.getValue()); 12848 } 12849 assertEquals(108, value); 12850 12851 } 12852 12853 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 12854 if (entrySet instanceof NavigableSet) { 12855 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12856 try { 12857 ascendingSubMapEntrySet.ceiling(null); 12858 fail("should throw NullPointerException"); 12859 } catch (NullPointerException e) { 12860 // Expected 12861 } 12862 12863 iterator = ascendingSubMapEntrySet.iterator(); 12864 while (iterator.hasNext()) { 12865 entry = (Entry) iterator.next(); 12866 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12867 value = (Integer) entry.getValue(); 12868 assertEquals(value, lowerEntry.getValue()); 12869 } 12870 assertEquals(109, value); 12871 } 12872 12873 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 12874 if (entrySet instanceof NavigableSet) { 12875 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12876 try { 12877 ascendingSubMapEntrySet.ceiling(null); 12878 fail("should throw NullPointerException"); 12879 } catch (NullPointerException e) { 12880 // Expected 12881 } 12882 12883 iterator = ascendingSubMapEntrySet.iterator(); 12884 while (iterator.hasNext()) { 12885 entry = (Entry) iterator.next(); 12886 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12887 value = (Integer) entry.getValue(); 12888 assertEquals(value, lowerEntry.getValue()); 12889 } 12890 assertEquals(108, value); 12891 } 12892 12893 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 12894 if (entrySet instanceof NavigableSet) { 12895 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12896 try { 12897 ascendingSubMapEntrySet.ceiling(null); 12898 fail("should throw NullPointerException"); 12899 } catch (NullPointerException e) { 12900 // Expected 12901 } 12902 12903 iterator = ascendingSubMapEntrySet.iterator(); 12904 while (iterator.hasNext()) { 12905 entry = (Entry) iterator.next(); 12906 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12907 value = (Integer) entry.getValue(); 12908 assertEquals(value, lowerEntry.getValue()); 12909 } 12910 assertEquals(109, value); 12911 } 12912 12913 // With Comparator 12914 entrySet = subMap_startIncluded_endIncluded_comparator.entrySet(); 12915 if (entrySet instanceof NavigableSet) { 12916 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12917 try { 12918 ascendingSubMapEntrySet.ceiling(null); 12919 fail("should throw NullPointerException"); 12920 } catch (NullPointerException e) { 12921 // Expected 12922 } 12923 12924 iterator = ascendingSubMapEntrySet.iterator(); 12925 while (iterator.hasNext()) { 12926 entry = (Entry) iterator.next(); 12927 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12928 value = (Integer) entry.getValue(); 12929 assertEquals(value, lowerEntry.getValue()); 12930 } 12931 assertEquals(109, value); 12932 } 12933 12934 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 12935 if (entrySet instanceof NavigableSet) { 12936 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12937 try { 12938 ascendingSubMapEntrySet.ceiling(null); 12939 fail("should throw NullPointerException"); 12940 } catch (NullPointerException e) { 12941 // Expected 12942 } 12943 12944 iterator = ascendingSubMapEntrySet.iterator(); 12945 while (iterator.hasNext()) { 12946 entry = (Entry) iterator.next(); 12947 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12948 value = (Integer) entry.getValue(); 12949 assertEquals(value, lowerEntry.getValue()); 12950 } 12951 assertEquals(108, value); 12952 } 12953 12954 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 12955 if (entrySet instanceof NavigableSet) { 12956 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12957 try { 12958 ascendingSubMapEntrySet.ceiling(null); 12959 fail("should throw NullPointerException"); 12960 } catch (NullPointerException e) { 12961 // Expected 12962 } 12963 12964 iterator = ascendingSubMapEntrySet.iterator(); 12965 while (iterator.hasNext()) { 12966 entry = (Entry) iterator.next(); 12967 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12968 value = (Integer) entry.getValue(); 12969 assertEquals(value, lowerEntry.getValue()); 12970 } 12971 assertEquals(109, value); 12972 } 12973 12974 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 12975 if (entrySet instanceof NavigableSet) { 12976 ascendingSubMapEntrySet = (NavigableSet) entrySet; 12977 try { 12978 ascendingSubMapEntrySet.ceiling(null); 12979 fail("should throw NullPointerException"); 12980 } catch (NullPointerException e) { 12981 // Expected 12982 } 12983 12984 iterator = ascendingSubMapEntrySet.iterator(); 12985 while (iterator.hasNext()) { 12986 entry = (Entry) iterator.next(); 12987 lowerEntry = (Entry) ascendingSubMapEntrySet.ceiling(entry); 12988 value = (Integer) entry.getValue(); 12989 assertEquals(value, lowerEntry.getValue()); 12990 } 12991 assertEquals(108, value); 12992 } 12993 } 12994 12995 public void test_AscendingSubMapEntrySet_floor() { 12996 Set entrySet; 12997 NavigableSet ascendingSubMapEntrySet; 12998 Iterator iterator; 12999 Entry entry, floorEntry; 13000 int value; 13001 13002 entrySet = navigableMap_startExcluded_endExcluded.entrySet(); 13003 if (entrySet instanceof NavigableSet) { 13004 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13005 try { 13006 ascendingSubMapEntrySet.floor(null); 13007 fail("should throw NullPointerException"); 13008 } catch (NullPointerException e) { 13009 // Expected 13010 } 13011 13012 iterator = ascendingSubMapEntrySet.iterator(); 13013 for (int i = 101; i < 109; i++) { 13014 entry = (Entry) iterator.next(); 13015 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13016 assertEquals(entry.getValue(), floorEntry.getValue()); 13017 } 13018 assertFalse(iterator.hasNext()); 13019 } 13020 13021 entrySet = navigableMap_startExcluded_endIncluded.entrySet(); 13022 if (entrySet instanceof NavigableSet) { 13023 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13024 try { 13025 ascendingSubMapEntrySet.floor(null); 13026 fail("should throw NullPointerException"); 13027 } catch (NullPointerException e) { 13028 // Expected 13029 } 13030 13031 iterator = ascendingSubMapEntrySet.iterator(); 13032 for (int i = 101; i < 110; i++) { 13033 entry = (Entry) iterator.next(); 13034 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13035 assertEquals(entry.getValue(), floorEntry.getValue()); 13036 } 13037 assertFalse(iterator.hasNext()); 13038 } 13039 13040 entrySet = navigableMap_startIncluded_endExcluded.entrySet(); 13041 if (entrySet instanceof NavigableSet) { 13042 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13043 try { 13044 ascendingSubMapEntrySet.floor(null); 13045 fail("should throw NullPointerException"); 13046 } catch (NullPointerException e) { 13047 // Expected 13048 } 13049 13050 iterator = ascendingSubMapEntrySet.iterator(); 13051 for (int i = 100; i < 109; i++) { 13052 entry = (Entry) iterator.next(); 13053 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13054 assertEquals(entry.getValue(), floorEntry.getValue()); 13055 } 13056 assertFalse(iterator.hasNext()); 13057 } 13058 13059 entrySet = navigableMap_startIncluded_endIncluded.entrySet(); 13060 if (entrySet instanceof NavigableSet) { 13061 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13062 try { 13063 ascendingSubMapEntrySet.floor(null); 13064 fail("should throw NullPointerException"); 13065 } catch (NullPointerException e) { 13066 // Expected 13067 } 13068 13069 iterator = ascendingSubMapEntrySet.iterator(); 13070 for (int i = 100; i < 110; i++) { 13071 entry = (Entry) iterator.next(); 13072 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13073 assertEquals(entry.getValue(), floorEntry.getValue()); 13074 } 13075 assertFalse(iterator.hasNext()); 13076 } 13077 13078 // With Comparator 13079 entrySet = subMap_startExcluded_endExcluded_comparator.entrySet(); 13080 if (entrySet instanceof NavigableSet) { 13081 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13082 try { 13083 ascendingSubMapEntrySet.floor(null); 13084 fail("should throw NullPointerException"); 13085 } catch (NullPointerException e) { 13086 // Expected 13087 } 13088 13089 iterator = ascendingSubMapEntrySet.iterator(); 13090 for (int i = 101; i < 109; i++) { 13091 entry = (Entry) iterator.next(); 13092 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13093 assertEquals(entry.getValue(), floorEntry.getValue()); 13094 } 13095 assertFalse(iterator.hasNext()); 13096 } 13097 13098 entrySet = subMap_startExcluded_endIncluded_comparator.entrySet(); 13099 if (entrySet instanceof NavigableSet) { 13100 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13101 try { 13102 ascendingSubMapEntrySet.floor(null); 13103 fail("should throw NullPointerException"); 13104 } catch (NullPointerException e) { 13105 // Expected 13106 } 13107 13108 iterator = ascendingSubMapEntrySet.iterator(); 13109 for (int i = 101; i < 110; i++) { 13110 entry = (Entry) iterator.next(); 13111 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13112 assertEquals(entry.getValue(), floorEntry.getValue()); 13113 } 13114 assertFalse(iterator.hasNext()); 13115 } 13116 13117 entrySet = subMap_startIncluded_endExcluded_comparator.entrySet(); 13118 if (entrySet instanceof NavigableSet) { 13119 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13120 try { 13121 ascendingSubMapEntrySet.floor(null); 13122 fail("should throw NullPointerException"); 13123 } catch (NullPointerException e) { 13124 // Expected 13125 } 13126 13127 iterator = ascendingSubMapEntrySet.iterator(); 13128 for (int i = 100; i < 109; i++) { 13129 entry = (Entry) iterator.next(); 13130 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13131 assertEquals(entry.getValue(), floorEntry.getValue()); 13132 } 13133 assertFalse(iterator.hasNext()); 13134 } 13135 13136 entrySet = subMap_startIncluded_endIncluded.entrySet(); 13137 if (entrySet instanceof NavigableSet) { 13138 ascendingSubMapEntrySet = (NavigableSet) entrySet; 13139 try { 13140 ascendingSubMapEntrySet.floor(null); 13141 fail("should throw NullPointerException"); 13142 } catch (NullPointerException e) { 13143 // Expected 13144 } 13145 13146 iterator = ascendingSubMapEntrySet.iterator(); 13147 for (int i = 100; i < 110; i++) { 13148 entry = (Entry) iterator.next(); 13149 floorEntry = (Entry) ascendingSubMapEntrySet.floor(entry); 13150 assertEquals(entry.getValue(), floorEntry.getValue()); 13151 } 13152 assertFalse(iterator.hasNext()); 13153 } 13154 } 13155 13156 @Override 13157 protected void setUp() { 13158 tm = new TreeMap(); 13159 tm_comparator = new TreeMap(new MockComparator()); 13160 for (int i = 0; i < objArray.length; i++) { 13161 Object x = objArray[i] = new Integer(i); 13162 tm.put(x.toString(), x); 13163 tm_comparator.put(x.toString(), x); 13164 } 13165 13166 subMap_default = tm.subMap(objArray[100].toString(), objArray[109] 13167 .toString()); 13168 subMap_startExcluded_endExcluded = tm.subMap(objArray[100].toString(), 13169 false, objArray[109].toString(), false); 13170 subMap_startExcluded_endIncluded = tm.subMap(objArray[100].toString(), 13171 false, objArray[109].toString(), true); 13172 subMap_startIncluded_endExcluded = tm.subMap(objArray[100].toString(), 13173 true, objArray[109].toString(), false); 13174 subMap_startIncluded_endIncluded = tm.subMap(objArray[100].toString(), 13175 true, objArray[109].toString(), true); 13176 13177 subMap_default_beforeStart_100 = tm.subMap(objArray[0].toString(), 13178 objArray[1].toString()); 13179 13180 subMap_default_afterEnd_109 = tm.subMap(objArray[110].toString(), 13181 objArray[119].toString()); 13182 13183 assertTrue(subMap_startExcluded_endExcluded instanceof NavigableMap); 13184 assertTrue(subMap_startExcluded_endIncluded instanceof NavigableMap); 13185 assertTrue(subMap_startIncluded_endExcluded instanceof NavigableMap); 13186 assertTrue(subMap_startIncluded_endIncluded instanceof NavigableMap); 13187 13188 navigableMap_startExcluded_endExcluded = (NavigableMap) subMap_startExcluded_endExcluded; 13189 navigableMap_startExcluded_endIncluded = (NavigableMap) subMap_startExcluded_endIncluded; 13190 navigableMap_startIncluded_endExcluded = (NavigableMap) subMap_startIncluded_endExcluded; 13191 navigableMap_startIncluded_endIncluded = (NavigableMap) subMap_startIncluded_endIncluded; 13192 13193 subMap_default_comparator = tm_comparator.subMap(objArray[100] 13194 .toString(), objArray[109].toString()); 13195 subMap_startExcluded_endExcluded_comparator = tm_comparator.subMap( 13196 objArray[100].toString(), false, objArray[109].toString(), 13197 false); 13198 13199 subMap_startExcluded_endIncluded_comparator = tm_comparator 13200 .subMap(objArray[100].toString(), false, objArray[109] 13201 .toString(), true); 13202 subMap_startIncluded_endExcluded_comparator = tm_comparator 13203 .subMap(objArray[100].toString(), true, objArray[109] 13204 .toString(), false); 13205 subMap_startIncluded_endIncluded_comparator = tm_comparator.subMap( 13206 objArray[100].toString(), true, objArray[109].toString(), true); 13207 } 13208 13209 @Override 13210 protected void tearDown() { 13211 tm = null; 13212 tm_comparator = null; 13213 13214 subMap_default = null; 13215 subMap_startExcluded_endExcluded = null; 13216 subMap_startExcluded_endIncluded = null; 13217 subMap_startIncluded_endExcluded = null; 13218 subMap_startIncluded_endIncluded = null; 13219 13220 subMap_default_beforeStart_100 = null; 13221 subMap_default_afterEnd_109 = null; 13222 13223 subMap_default_comparator = null; 13224 subMap_startExcluded_endExcluded_comparator = null; 13225 subMap_startExcluded_endIncluded_comparator = null; 13226 subMap_startIncluded_endExcluded_comparator = null; 13227 subMap_startIncluded_endIncluded_comparator = null; 13228 } 13229 13230 public void test_lower_null() throws Exception { 13231 NavigableMap map = tm.subMap(objArray[100].toString(), true, 13232 objArray[100].toString(), false); 13233 assertNull(map.ceilingKey(objArray[100].toString())); 13234 assertNull(map.floorKey(objArray[100].toString())); 13235 assertNull(map.lowerKey(objArray[100].toString())); 13236 assertNull(map.higherKey(objArray[100].toString())); 13237 assertNull(map.ceilingKey(objArray[111].toString())); 13238 assertNull(map.floorKey(objArray[111].toString())); 13239 assertNull(map.lowerKey(objArray[111].toString())); 13240 assertNull(map.higherKey(objArray[111].toString())); 13241 assertNull(map.ceilingKey(objArray[1].toString())); 13242 assertNull(map.floorKey(objArray[1].toString())); 13243 assertNull(map.lowerKey(objArray[1].toString())); 13244 assertNull(map.higherKey(objArray[1].toString())); 13245 map = map.descendingMap(); 13246 assertNull(map.ceilingKey(objArray[100].toString())); 13247 assertNull(map.floorKey(objArray[100].toString())); 13248 assertNull(map.lowerKey(objArray[100].toString())); 13249 assertNull(map.higherKey(objArray[100].toString())); 13250 assertNull(map.ceilingKey(objArray[111].toString())); 13251 assertNull(map.floorKey(objArray[111].toString())); 13252 assertNull(map.lowerKey(objArray[111].toString())); 13253 assertNull(map.higherKey(objArray[111].toString())); 13254 assertNull(map.ceilingKey(objArray[1].toString())); 13255 assertNull(map.floorKey(objArray[1].toString())); 13256 assertNull(map.lowerKey(objArray[1].toString())); 13257 assertNull(map.higherKey(objArray[1].toString())); 13258 } 13259 13260 public void test_lower_tail() throws Exception { 13261 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13262 objArray[103].toString(), false); 13263 assertTrue(map.containsKey(objArray[102].toString())); 13264 assertFalse(map.containsKey(objArray[101].toString())); 13265 assertFalse(map.containsKey(objArray[103].toString())); 13266 assertFalse(map.containsKey(objArray[104].toString())); 13267 map = map.descendingMap(); 13268 assertTrue(map.containsKey(objArray[102].toString())); 13269 assertFalse(map.containsKey(objArray[101].toString())); 13270 assertFalse(map.containsKey(objArray[103].toString())); 13271 assertFalse(map.containsKey(objArray[104].toString())); 13272 map = tm.subMap(objArray[102].toString(), true, objArray[102] 13273 .toString(), false); 13274 assertFalse(map.containsKey(objArray[102].toString())); 13275 assertFalse(map.containsKey(objArray[101].toString())); 13276 assertFalse(map.containsKey(objArray[103].toString())); 13277 assertFalse(map.containsKey(objArray[104].toString())); 13278 map = map.descendingMap(); 13279 assertFalse(map.containsKey(objArray[102].toString())); 13280 assertFalse(map.containsKey(objArray[101].toString())); 13281 assertFalse(map.containsKey(objArray[103].toString())); 13282 assertFalse(map.containsKey(objArray[104].toString())); 13283 } 13284 13285 public void test_contains_null() throws Exception { 13286 NavigableMap map = tm.subMap(objArray[100].toString(), true, 13287 objArray[100].toString(), false); 13288 assertFalse(map.containsKey(objArray[100].toString())); 13289 assertFalse(map.containsKey(objArray[10].toString())); 13290 assertFalse(map.containsKey(objArray[101].toString())); 13291 assertFalse(map.containsKey(objArray[102].toString())); 13292 assertFalse(map.containsKey(objArray[1].toString())); 13293 map = map.descendingMap(); 13294 assertFalse(map.containsKey(objArray[100].toString())); 13295 assertFalse(map.containsKey(objArray[10].toString())); 13296 assertFalse(map.containsKey(objArray[101].toString())); 13297 assertFalse(map.containsKey(objArray[102].toString())); 13298 assertFalse(map.containsKey(objArray[1].toString())); 13299 } 13300 13301 public void test_contains() throws Exception { 13302 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13303 objArray[103].toString(), false); 13304 assertFalse(map.containsKey(objArray[100].toString())); 13305 assertFalse(map.containsKey(objArray[104].toString())); 13306 assertFalse(map.containsKey(objArray[101].toString())); 13307 assertTrue(map.containsKey(objArray[102].toString())); 13308 map = map.descendingMap(); 13309 assertFalse(map.containsKey(objArray[100].toString())); 13310 assertFalse(map.containsKey(objArray[104].toString())); 13311 assertFalse(map.containsKey(objArray[101].toString())); 13312 assertTrue(map.containsKey(objArray[102].toString())); 13313 } 13314 13315 public void test_size() throws Exception { 13316 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13317 objArray[103].toString(), false); 13318 assertEquals(0, map.headMap(objArray[102].toString(), false).size()); 13319 assertEquals(1, map.headMap(objArray[102].toString(), true).size()); 13320 try { 13321 assertEquals(1, map.headMap(objArray[103].toString(), true).size()); 13322 fail("should throw IAE"); 13323 } catch (IllegalArgumentException e) { 13324 } 13325 assertEquals(1, map.headMap(objArray[103].toString(), false).size()); 13326 assertEquals(1, map.tailMap(objArray[102].toString(), true).size()); 13327 assertEquals(0, map.tailMap(objArray[102].toString(), false).size()); 13328 assertTrue(map.headMap(objArray[103].toString(), false).containsKey( 13329 objArray[102].toString())); 13330 try { 13331 assertTrue(map.headMap(objArray[103].toString(), true).containsKey( 13332 objArray[102].toString())); 13333 fail("should throw IAE"); 13334 } catch (IllegalArgumentException e) { 13335 } 13336 assertFalse(map.headMap(objArray[102].toString(), false).containsKey( 13337 objArray[102].toString())); 13338 assertTrue(map.headMap(objArray[102].toString(), true).containsKey( 13339 objArray[102].toString())); 13340 assertTrue(map.tailMap(objArray[102].toString(), true).containsKey( 13341 objArray[102].toString())); 13342 assertFalse(map.tailMap(objArray[102].toString(), true).containsKey( 13343 objArray[103].toString())); 13344 try { 13345 assertEquals(0, map.tailMap(objArray[101].toString()).size()); 13346 fail("should throw IAE"); 13347 } catch (IllegalArgumentException e) { 13348 } 13349 map = map.descendingMap(); 13350 try { 13351 map = map.subMap(objArray[103].toString(), true, objArray[102] 13352 .toString(), true); 13353 fail("should throw IAE"); 13354 } catch (IllegalArgumentException e) { 13355 } 13356 map = map.subMap(objArray[102].toString(), true, objArray[102] 13357 .toString(), true); 13358 assertEquals(1, map.headMap(objArray[102].toString(), true).size()); 13359 assertEquals(0, map.headMap(objArray[102].toString(), false).size()); 13360 try { 13361 assertEquals(0, map.headMap(objArray[103].toString(), true).size()); 13362 fail("should throw IAE"); 13363 } catch (IllegalArgumentException e) { 13364 } 13365 13366 assertEquals(1, map.tailMap(objArray[102].toString(), true).size()); 13367 try { 13368 assertFalse(map.headMap(objArray[103].toString(), true) 13369 .containsKey(objArray[102].toString())); 13370 fail("should throw IAE"); 13371 } catch (IllegalArgumentException e) { 13372 } 13373 assertTrue(map.headMap(objArray[102].toString(), true).containsKey( 13374 objArray[102].toString())); 13375 assertFalse(map.headMap(objArray[102].toString(), false).containsKey( 13376 objArray[102].toString())); 13377 assertTrue(map.tailMap(objArray[102].toString(), true).containsKey( 13378 objArray[102].toString())); 13379 assertFalse(map.tailMap(objArray[102].toString(), true).containsKey( 13380 objArray[103].toString())); 13381 try { 13382 assertEquals(0, map.tailMap(objArray[101].toString()).size()); 13383 fail("should throw IAE"); 13384 } catch (IllegalArgumentException e) { 13385 } 13386 } 13387 13388 public void test_lower() throws Exception { 13389 NavigableMap map = tm.subMap(objArray[102].toString(), true, 13390 objArray[103].toString(), false); 13391 assertEquals(objArray[102].toString(), map.higherKey(objArray[101] 13392 .toString())); 13393 assertEquals(null, map.higherKey(objArray[102].toString())); 13394 assertEquals(null, map.higherKey(objArray[103].toString())); 13395 assertEquals(null, map.higherKey(objArray[104].toString())); 13396 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[101] 13397 .toString())); 13398 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102] 13399 .toString())); 13400 assertEquals(null, map.ceilingKey(objArray[103].toString())); 13401 assertEquals(null, map.ceilingKey(objArray[104].toString())); 13402 assertEquals(null, map.lowerKey(objArray[101].toString())); 13403 assertEquals(null, map.lowerKey(objArray[102].toString())); 13404 assertEquals(objArray[102].toString(), map.lowerKey(objArray[103] 13405 .toString())); 13406 assertEquals(objArray[102].toString(), map.lowerKey(objArray[104] 13407 .toString())); 13408 assertEquals(null, map.floorKey(objArray[101].toString())); 13409 assertEquals(objArray[102].toString(), map.floorKey(objArray[102] 13410 .toString())); 13411 assertEquals(objArray[102].toString(), map.floorKey(objArray[103] 13412 .toString())); 13413 assertEquals(objArray[102].toString(), map.floorKey(objArray[104] 13414 .toString())); 13415 map = map.descendingMap(); 13416 assertEquals(null, map.higherKey(objArray[101].toString())); 13417 assertEquals(null, map.higherKey(objArray[102].toString())); 13418 assertEquals(objArray[102].toString(), map.higherKey(objArray[103] 13419 .toString())); 13420 assertEquals(objArray[102].toString(), map.higherKey(objArray[104] 13421 .toString())); 13422 assertEquals(null, map.ceilingKey(objArray[101].toString())); 13423 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[102] 13424 .toString())); 13425 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[103] 13426 .toString())); 13427 assertEquals(objArray[102].toString(), map.ceilingKey(objArray[104] 13428 .toString())); 13429 assertEquals(objArray[102].toString(), map.lowerKey(objArray[101] 13430 .toString())); 13431 assertEquals(null, map.lowerKey(objArray[102].toString())); 13432 assertEquals(null, map.lowerKey(objArray[103].toString())); 13433 assertEquals(null, map.lowerKey(objArray[104].toString())); 13434 assertEquals(objArray[102].toString(), map.floorKey(objArray[101] 13435 .toString())); 13436 assertEquals(objArray[102].toString(), map.floorKey(objArray[102] 13437 .toString())); 13438 assertEquals(null, map.floorKey(objArray[103].toString())); 13439 assertEquals(null, map.floorKey(objArray[104].toString())); 13440 } 13441 13442 public void test_lowerkey() throws Exception { 13443 try { 13444 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13445 false).descendingMap().firstKey(); 13446 fail("should throw NoSuchElementException"); 13447 } catch (Exception e) { 13448 // expected 13449 } 13450 try { 13451 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13452 false).descendingMap().lastKey(); 13453 fail("should throw NoSuchElementException"); 13454 } catch (Exception e) { 13455 // expected 13456 } 13457 try { 13458 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13459 false).firstKey(); 13460 fail("should throw NoSuchElementException"); 13461 } catch (Exception e) { 13462 // expected 13463 } 13464 try { 13465 tm.subMap(objArray[100].toString(), true, objArray[100].toString(), 13466 false).lastKey(); 13467 fail("should throw NoSuchElementException"); 13468 } catch (Exception e) { 13469 // expected 13470 } 13471 13472 } 13473 13474 public void test_headMap() throws Exception { 13475 TreeMap tree = new TreeMap(); 13476 tree.put(new Integer(0), null); 13477 tree.put(new Integer(1), null); 13478 Map submap = tree.subMap(tree.firstKey(), tree.lastKey()); 13479 tree.remove(tree.lastKey()); 13480 assertEquals(submap, tree); 13481 } 13482 13483 public void testname() throws Exception { 13484 TreeMap nullTree = new TreeMap(new Comparator() { 13485 public int compare(Object o1, Object o2) { 13486 if (o1 == null) { 13487 return o2 == null ? 0 : -1; 13488 } 13489 return ((String) o1).compareTo((String) o2); 13490 } 13491 }); 13492 nullTree.put(new String("One"), 1); 13493 nullTree.put(new String("Two"), 2); 13494 nullTree.put(new String("Three"), 3); 13495 nullTree.put(new String("Four"), 4); 13496 nullTree.put(null, 0); 13497 nullTree.subMap(null, "two").size(); 13498 } 13499 13500} 13501