LinkedHashMapTest.java revision 2330890bd0c7c08a45a1bcf5e708e472e5a17b64
1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package tests.api.java.util; 19 20import dalvik.annotation.TestTargetNew; 21import dalvik.annotation.TestTargets; 22import dalvik.annotation.TestLevel; 23import dalvik.annotation.TestTargetClass; 24 25import java.util.AbstractMap; 26import java.util.ArrayList; 27import java.util.Arrays; 28import java.util.Collection; 29import java.util.Iterator; 30import java.util.LinkedHashMap; 31import java.util.Map; 32import java.util.Set; 33import java.util.TreeMap; 34 35import tests.support.Support_MapTest2; 36import tests.support.Support_UnmodifiableCollectionTest; 37 38/** 39 * @tests java.util.LinkedHashMap 40 */ 41@TestTargetClass(LinkedHashMap.class) 42public class LinkedHashMapTest extends junit.framework.TestCase { 43 44 LinkedHashMap hm; 45 46 final static int hmSize = 1000; 47 48 Object[] objArray; 49 50 Object[] objArray2; 51 52 static final class CacheMap extends LinkedHashMap { 53 protected boolean removeEldestEntry(Map.Entry e) { 54 return size() > 5; 55 } 56 } 57 58 private static class MockMapNull extends AbstractMap { 59 @Override 60 public Set entrySet() { 61 return null; 62 } 63 64 @Override 65 public int size() { 66 return 10; 67 } 68 } 69 70 /** 71 * @tests java.util.LinkedHashMap#LinkedHashMap() 72 */ 73 @TestTargetNew( 74 level = TestLevel.COMPLETE, 75 notes = "", 76 method = "LinkedHashMap", 77 args = {} 78 ) 79 public void test_Constructor() { 80 // Test for method java.util.LinkedHashMap() 81 new Support_MapTest2(new LinkedHashMap()).runTest(); 82 83 LinkedHashMap hm2 = new LinkedHashMap(); 84 assertEquals("Created incorrect LinkedHashMap", 0, hm2.size()); 85 } 86 87 /** 88 * @tests java.util.LinkedHashMap#LinkedHashMap(int) 89 */ 90 @TestTargetNew( 91 level = TestLevel.COMPLETE, 92 notes = "Need to improve code.", 93 method = "LinkedHashMap", 94 args = {int.class} 95 ) 96 public void test_ConstructorI() { 97 // Test for method java.util.LinkedHashMap(int) 98 LinkedHashMap hm2 = new LinkedHashMap(5); 99 assertEquals("Created incorrect LinkedHashMap", 0, hm2.size()); 100 try { 101 new LinkedHashMap(-1); 102 fail("Failed to throw IllegalArgumentException for initial " + 103 "capacity < 0"); 104 } catch (IllegalArgumentException e) { 105 //expected 106 } 107 108 LinkedHashMap empty = new LinkedHashMap(0); 109 assertNull("Empty LinkedHashMap access", empty.get("nothing")); 110 empty.put("something", "here"); 111 assertTrue("cannot get element", empty.get("something") == "here"); 112 } 113 114 /** 115 * @tests java.util.LinkedHashMap#LinkedHashMap(int, float) 116 */ 117 @TestTargetNew( 118 level = TestLevel.COMPLETE, 119 notes = "Need to improve code.", 120 method = "LinkedHashMap", 121 args = {int.class, float.class} 122 ) 123 public void test_ConstructorIF() { 124 // Test for method java.util.LinkedHashMap(int, float) 125 LinkedHashMap hm2 = new LinkedHashMap(5, (float) 0.5); 126 assertEquals("Created incorrect LinkedHashMap", 0, hm2.size()); 127 try { 128 new LinkedHashMap(0, 0); 129 fail("Failed to throw IllegalArgumentException for initial " + 130 "load factor <= 0"); 131 } catch (IllegalArgumentException e) { 132 //expected 133 } 134 135 LinkedHashMap empty = new LinkedHashMap(0, 0.75f); 136 assertNull("Empty hashtable access", empty.get("nothing")); 137 empty.put("something", "here"); 138 assertTrue("cannot get element", empty.get("something") == "here"); 139 } 140 141 /** 142 * @tests java.util.LinkedHashMap#LinkedHashMap(java.util.Map) 143 */ 144 @TestTargetNew( 145 level = TestLevel.PARTIAL_COMPLETE, 146 notes = "Doesn't verify IllegalArgumentException.", 147 method = "LinkedHashMap", 148 args = {java.util.Map.class} 149 ) 150 public void test_ConstructorLjava_util_Map() { 151 // Test for method java.util.LinkedHashMap(java.util.Map) 152 Map myMap = new TreeMap(); 153 for (int counter = 0; counter < hmSize; counter++) 154 myMap.put(objArray2[counter], objArray[counter]); 155 LinkedHashMap hm2 = new LinkedHashMap(myMap); 156 for (int counter = 0; counter < hmSize; counter++) 157 assertTrue("Failed to construct correct LinkedHashMap", hm 158 .get(objArray2[counter]) == hm2.get(objArray2[counter])); 159 } 160 161 /** 162 * @tests java.util.LinkedHashMap#get(java.lang.Object) 163 */ 164 @TestTargetNew( 165 level = TestLevel.PARTIAL_COMPLETE, 166 notes = "Doesn't verify ClassCastException, NullPointerException.", 167 method = "get", 168 args = {java.lang.Object.class} 169 ) 170 public void test_getLjava_lang_Object() { 171 // Test for method java.lang.Object 172 // java.util.LinkedHashMap.get(java.lang.Object) 173 assertNull("Get returned non-null for non existent key", 174 hm.get("T")); 175 hm.put("T", "HELLO"); 176 assertEquals("Get returned incorecct value for existing key", "HELLO", hm.get("T") 177 ); 178 179 LinkedHashMap m = new LinkedHashMap(); 180 m.put(null, "test"); 181 assertEquals("Failed with null key", "test", m.get(null)); 182 assertNull("Failed with missing key matching null hash", m 183 .get(new Integer(0))); 184 } 185 186 /** 187 * @tests java.util.LinkedHashMap#put(java.lang.Object, java.lang.Object) 188 */ 189 @TestTargetNew( 190 level = TestLevel.PARTIAL_COMPLETE, 191 notes = "Doesn't verify that put returns null if there was no mapping for key, or associated null with the specified key.", 192 method = "put", 193 args = {java.lang.Object.class, java.lang.Object.class} 194 ) 195 public void test_putLjava_lang_ObjectLjava_lang_Object() { 196 // Test for method java.lang.Object 197 // java.util.LinkedHashMap.put(java.lang.Object, java.lang.Object) 198 hm.put("KEY", "VALUE"); 199 assertEquals("Failed to install key/value pair", 200 "VALUE", hm.get("KEY")); 201 202 LinkedHashMap m = new LinkedHashMap(); 203 m.put(new Short((short) 0), "short"); 204 m.put(null, "test"); 205 m.put(new Integer(0), "int"); 206 assertEquals("Failed adding to bucket containing null", "short", m.get( 207 new Short((short) 0))); 208 assertEquals("Failed adding to bucket containing null2", "int", m.get( 209 new Integer(0))); 210 } 211 212 213 @TestTargetNew( 214 level = TestLevel.PARTIAL_COMPLETE, 215 notes = "test that put on an already present key causes entry to move to tail.", 216 method = "put", 217 args = {java.lang.Object.class, java.lang.Object.class} 218 ) 219 public void test_putPresent() { 220 Map<String, String> m = new LinkedHashMap<String, String>(8, .75f, true); 221 m.put("KEY", "VALUE"); 222 m.put("WOMBAT", "COMBAT"); 223 m.put("KEY", "VALUE"); 224 Map.Entry newest = null; 225 for (Map.Entry<String, String> e : m.entrySet()) { 226 newest = e; 227 } 228 assertEquals("KEY", newest.getKey()); 229 assertEquals("VALUE", newest.getValue()); 230 } 231 232 /** 233 * @tests java.util.LinkedHashMap#putAll(java.util.Map) 234 */ 235 @TestTargetNew( 236 level = TestLevel.PARTIAL_COMPLETE, 237 notes = "", 238 method = "putAll", 239 args = {java.util.Map.class} 240 ) 241 public void test_putAllLjava_util_Map() { 242 // Test for method void java.util.LinkedHashMap.putAll(java.util.Map) 243 LinkedHashMap hm2 = new LinkedHashMap(); 244 hm2.putAll(hm); 245 for (int i = 0; i < 1000; i++) 246 assertTrue("Failed to clear all elements", hm2.get( 247 new Integer(i).toString()).equals((new Integer(i)))); 248 } 249 250 /** 251 * @tests java.util.LinkedHashMap#putAll(java.util.Map) 252 */ 253 @TestTargetNew( 254 level = TestLevel.PARTIAL_COMPLETE, 255 notes = "Verifies NullPointerException.", 256 method = "putAll", 257 args = {java.util.Map.class} 258 ) 259 public void test_putAll_Ljava_util_Map_Null() { 260 LinkedHashMap linkedHashMap = new LinkedHashMap(); 261 try { 262 linkedHashMap.putAll(new MockMapNull()); 263 fail("Should throw NullPointerException"); 264 } catch (NullPointerException e) { 265 // expected. 266 } 267 268 try { 269 linkedHashMap = new LinkedHashMap(new MockMapNull()); 270 fail("Should throw NullPointerException"); 271 } catch (NullPointerException e) { 272 // expected. 273 } 274 } 275 276 /** 277 * @tests java.util.LinkedHashMap#entrySet() 278 */ 279 @TestTargetNew( 280 level = TestLevel.COMPLETE, 281 notes = "", 282 method = "entrySet", 283 args = {} 284 ) 285 public void test_entrySet() { 286 // Test for method java.util.Set java.util.LinkedHashMap.entrySet() 287 Set s = hm.entrySet(); 288 Iterator i = s.iterator(); 289 assertTrue("Returned set of incorrect size", hm.size() == s.size()); 290 while (i.hasNext()) { 291 Map.Entry m = (Map.Entry) i.next(); 292 assertTrue("Returned incorrect entry set", hm.containsKey(m 293 .getKey()) 294 && hm.containsValue(m.getValue())); 295 } 296 } 297 298 @TestTargetNew( 299 level = TestLevel.COMPLETE, 300 notes = "Test that remove removes the entry from the linked list", 301 method = "entrySet", 302 args = {} 303 ) 304 public void test_entrySetRemove() { 305 entrySetRemoveHelper("military", "intelligence"); 306 entrySetRemoveHelper(null, "hypothesis"); 307 } 308 private void entrySetRemoveHelper(String key, String value) { 309 Map<String, String> m1 = new LinkedHashMap<String, String>(); 310 m1.put(key, value); 311 m1.put("jumbo", "shrimp"); 312 LinkedHashMap<String, String> m2 = new LinkedHashMap<String, String>(m1); 313 Set<Map.Entry<String, String>> s1 = m1.entrySet(); 314 s1.remove(m2.entrySet().iterator().next()); 315 assertEquals("jumbo", s1.iterator().next().getKey()); 316 } 317 318 /** 319 * @tests java.util.LinkedHashMap#keySet() 320 */ 321 @TestTargetNew( 322 level = TestLevel.COMPLETE, 323 notes = "", 324 method = "keySet", 325 args = {} 326 ) 327 public void test_keySet() { 328 // Test for method java.util.Set java.util.LinkedHashMap.keySet() 329 Set s = hm.keySet(); 330 assertTrue("Returned set of incorrect size()", s.size() == hm.size()); 331 for (int i = 0; i < objArray.length; i++) 332 assertTrue("Returned set does not contain all keys", s 333 .contains(objArray[i].toString())); 334 335 LinkedHashMap m = new LinkedHashMap(); 336 m.put(null, "test"); 337 assertTrue("Failed with null key", m.keySet().contains(null)); 338 assertNull("Failed with null key", m.keySet().iterator().next()); 339 340 Map map = new LinkedHashMap(101); 341 map.put(new Integer(1), "1"); 342 map.put(new Integer(102), "102"); 343 map.put(new Integer(203), "203"); 344 Iterator it = map.keySet().iterator(); 345 Integer remove1 = (Integer) it.next(); 346 it.hasNext(); 347 it.remove(); 348 Integer remove2 = (Integer) it.next(); 349 it.remove(); 350 ArrayList list = new ArrayList(Arrays.asList(new Integer[] { 351 new Integer(1), new Integer(102), new Integer(203) })); 352 list.remove(remove1); 353 list.remove(remove2); 354 assertTrue("Wrong result", it.next().equals(list.get(0))); 355 assertEquals("Wrong size", 1, map.size()); 356 assertTrue("Wrong contents", map.keySet().iterator().next().equals( 357 list.get(0))); 358 359 Map map2 = new LinkedHashMap(101); 360 map2.put(new Integer(1), "1"); 361 map2.put(new Integer(4), "4"); 362 Iterator it2 = map2.keySet().iterator(); 363 Integer remove3 = (Integer) it2.next(); 364 Integer next; 365 if (remove3.intValue() == 1) 366 next = new Integer(4); 367 else 368 next = new Integer(1); 369 it2.hasNext(); 370 it2.remove(); 371 assertTrue("Wrong result 2", it2.next().equals(next)); 372 assertEquals("Wrong size 2", 1, map2.size()); 373 assertTrue("Wrong contents 2", map2.keySet().iterator().next().equals( 374 next)); 375 } 376 377 /** 378 * @tests java.util.LinkedHashMap#values() 379 */ 380 @TestTargetNew( 381 level = TestLevel.COMPLETE, 382 notes = "", 383 method = "values", 384 args = {} 385 ) 386 public void test_values() { 387 // Test for method java.util.Collection java.util.LinkedHashMap.values() 388 Collection c = hm.values(); 389 assertTrue("Returned collection of incorrect size()", c.size() == hm 390 .size()); 391 for (int i = 0; i < objArray.length; i++) 392 assertTrue("Returned collection does not contain all keys", c 393 .contains(objArray[i])); 394 395 LinkedHashMap myLinkedHashMap = new LinkedHashMap(); 396 for (int i = 0; i < 100; i++) 397 myLinkedHashMap.put(objArray2[i], objArray[i]); 398 Collection values = myLinkedHashMap.values(); 399 new Support_UnmodifiableCollectionTest( 400 "Test Returned Collection From LinkedHashMap.values()", values) 401 .runTest(); 402 values.remove(new Integer(0)); 403 assertTrue( 404 "Removing from the values collection should remove from the original map", 405 !myLinkedHashMap.containsValue(new Integer(0))); 406 407 } 408 409 /** 410 * @tests java.util.LinkedHashMap#remove(java.lang.Object) 411 */ 412 @TestTargetNew( 413 level = TestLevel.COMPLETE, 414 notes = "", 415 method = "remove", 416 args = {java.lang.Object.class} 417 ) 418 public void test_removeLjava_lang_Object() { 419 // Test for method java.lang.Object 420 // java.util.LinkedHashMap.remove(java.lang.Object) 421 int size = hm.size(); 422 Integer y = new Integer(9); 423 Integer x = ((Integer) hm.remove(y.toString())); 424 assertTrue("Remove returned incorrect value", x.equals(new Integer(9))); 425 assertNull("Failed to remove given key", hm.get(new Integer(9))); 426 assertTrue("Failed to decrement size", hm.size() == (size - 1)); 427 assertNull("Remove of non-existent key returned non-null", hm 428 .remove("LCLCLC")); 429 430 LinkedHashMap m = new LinkedHashMap(); 431 m.put(null, "test"); 432 assertNull("Failed with same hash as null", 433 m.remove(new Integer(0))); 434 assertEquals("Failed with null key", "test", m.remove(null)); 435 } 436 437 /** 438 * @tests java.util.LinkedHashMap#clear() 439 */ 440 @TestTargetNew( 441 level = TestLevel.COMPLETE, 442 notes = "", 443 method = "clear", 444 args = {} 445 ) 446 public void test_clear() { 447 // Test for method void java.util.LinkedHashMap.clear() 448 hm.clear(); 449 assertEquals("Clear failed to reset size", 0, hm.size()); 450 for (int i = 0; i < hmSize; i++) 451 assertNull("Failed to clear all elements", 452 hm.get(objArray2[i])); 453 454 } 455 456 /** 457 * @tests java.util.LinkedHashMap#clone() 458 */ 459 @TestTargetNew( 460 level = TestLevel.COMPLETE, 461 notes = "", 462 method = "clone", 463 args = {} 464 ) 465 public void test_clone() { 466 // Test for method java.lang.Object java.util.LinkedHashMap.clone() 467 LinkedHashMap hm2 = (LinkedHashMap) hm.clone(); 468 assertTrue("Clone answered equivalent LinkedHashMap", hm2 != hm); 469 for (int counter = 0; counter < hmSize; counter++) 470 assertTrue("Clone answered unequal LinkedHashMap", hm 471 .get(objArray2[counter]) == hm2.get(objArray2[counter])); 472 473 LinkedHashMap map = new LinkedHashMap(); 474 map.put("key", "value"); 475 // get the keySet() and values() on the original Map 476 Set keys = map.keySet(); 477 Collection values = map.values(); 478 assertEquals("values() does not work", 479 "value", values.iterator().next()); 480 assertEquals("keySet() does not work", 481 "key", keys.iterator().next()); 482 AbstractMap map2 = (AbstractMap) map.clone(); 483 map2.put("key", "value2"); 484 Collection values2 = map2.values(); 485 assertTrue("values() is identical", values2 != values); 486 487 // values() and keySet() on the cloned() map should be different 488 assertEquals("values() was not cloned", 489 "value2", values2.iterator().next()); 490 map2.clear(); 491 map2.put("key2", "value3"); 492 Set key2 = map2.keySet(); 493 assertTrue("keySet() is identical", key2 != keys); 494 assertEquals("keySet() was not cloned", 495 "key2", key2.iterator().next()); 496 } 497 498 /** 499 * @tests java.util.LinkedHashMap#clone() 500 */ 501 @TestTargetNew( 502 level = TestLevel.PARTIAL_COMPLETE, 503 notes = "", 504 method = "clone", 505 args = {} 506 ) 507 public void test_clone_ordered() { 508 // Test for method java.lang.Object java.util.LinkedHashMap.clone() 509 LinkedHashMap<String, String> hm1 = new LinkedHashMap<String, String>(10, 0.75f, true); 510 hm1.put("a", "a"); 511 hm1.put("b", "b"); 512 hm1.put("c", "c"); 513 LinkedHashMap<String, String> hm2 = (LinkedHashMap<String, String>) hm1.clone(); 514 hm1.get("a"); 515 516 Map.Entry<String, String>[] set = new Map.Entry[3]; 517 Iterator<Map.Entry<String,String>> iterator = hm1.entrySet().iterator(); 518 519 assertEquals("b", iterator.next().getKey()); 520 assertEquals("c", iterator.next().getKey()); 521 assertEquals("a", iterator.next().getKey()); 522 523 iterator = hm2.entrySet().iterator(); 524 assertEquals("a", iterator.next().getKey()); 525 assertEquals("b", iterator.next().getKey()); 526 assertEquals("c", iterator.next().getKey()); 527 } 528 529 @TestTargetNew( 530 level = TestLevel.PARTIAL_COMPLETE, 531 notes = "Regression test.", 532 method = "clone", 533 args = {} 534 ) 535 // regresion test for HARMONY-4603 536 public void test_clone_Mock() { 537 LinkedHashMap hashMap = new MockMap(); 538 String value = "value a"; 539 hashMap.put("key", value); 540 MockMap cloneMap = (MockMap) hashMap.clone(); 541 assertEquals(value, cloneMap.get("key")); 542 assertEquals(hashMap, cloneMap); 543 assertEquals(1, cloneMap.num); 544 545 hashMap.put("key", "value b"); 546 assertFalse(hashMap.equals(cloneMap)); 547 } 548 549 class MockMap extends LinkedHashMap { 550 int num; 551 552 public Object put(Object k, Object v) { 553 num++; 554 return super.put(k, v); 555 } 556 557 protected boolean removeEldestEntry(Map.Entry e) { 558 return num > 1; 559 } 560 } 561 562 /** 563 * @tests java.util.LinkedHashMap#containsKey(java.lang.Object) 564 */ 565 @TestTargetNew( 566 level = TestLevel.PARTIAL_COMPLETE, 567 notes = "Doesn't verify ClassCastException, NullPointerException.", 568 method = "containsKey", 569 args = {java.lang.Object.class} 570 ) 571 public void test_containsKeyLjava_lang_Object() { 572 // Test for method boolean 573 // java.util.LinkedHashMap.containsKey(java.lang.Object) 574 assertTrue("Returned false for valid key", hm.containsKey(new Integer( 575 876).toString())); 576 assertTrue("Returned true for invalid key", !hm.containsKey("KKDKDKD")); 577 578 LinkedHashMap m = new LinkedHashMap(); 579 m.put(null, "test"); 580 assertTrue("Failed with null key", m.containsKey(null)); 581 assertTrue("Failed with missing key matching null hash", !m 582 .containsKey(new Integer(0))); 583 } 584 585 /** 586 * @tests java.util.LinkedHashMap#containsValue(java.lang.Object) 587 */ 588 @TestTargetNew( 589 level = TestLevel.PARTIAL_COMPLETE, 590 notes = "Doesn't verify ClassCastException, NullPointerException.", 591 method = "containsValue", 592 args = {java.lang.Object.class} 593 ) 594 public void test_containsValueLjava_lang_Object() { 595 // Test for method boolean 596 // java.util.LinkedHashMap.containsValue(java.lang.Object) 597 assertTrue("Returned false for valid value", hm 598 .containsValue(new Integer(875))); 599 assertTrue("Returned true for invalid valie", !hm 600 .containsValue(new Integer(-9))); 601 } 602 603 /** 604 * @tests java.util.LinkedHashMap#isEmpty() 605 */ 606 @TestTargetNew( 607 level = TestLevel.COMPLETE, 608 notes = "", 609 method = "isEmpty", 610 args = {} 611 ) 612 public void test_isEmpty() { 613 // Test for method boolean java.util.LinkedHashMap.isEmpty() 614 assertTrue("Returned false for new map", new LinkedHashMap().isEmpty()); 615 assertTrue("Returned true for non-empty", !hm.isEmpty()); 616 } 617 618 /** 619 * @tests java.util.LinkedHashMap#size() 620 */ 621 @TestTargetNew( 622 level = TestLevel.COMPLETE, 623 notes = "", 624 method = "size", 625 args = {} 626 ) 627 public void test_size() { 628 // Test for method int java.util.LinkedHashMap.size() 629 assertTrue("Returned incorrect size", 630 hm.size() == (objArray.length + 2)); 631 } 632 633 /** 634 * @tests java.util.LinkedHashMap#entrySet() 635 */ 636 @TestTargetNew( 637 level = TestLevel.COMPLETE, 638 notes = "", 639 method = "entrySet", 640 args = {} 641 ) 642 public void test_ordered_entrySet() { 643 int i; 644 int sz = 100; 645 LinkedHashMap lhm = new LinkedHashMap(); 646 for (i = 0; i < sz; i++) { 647 Integer ii = new Integer(i); 648 lhm.put(ii, ii.toString()); 649 } 650 651 Set s1 = lhm.entrySet(); 652 Iterator it1 = s1.iterator(); 653 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 654 for (i = 0; it1.hasNext(); i++) { 655 Map.Entry m = (Map.Entry) it1.next(); 656 Integer jj = (Integer) m.getKey(); 657 assertTrue("Returned incorrect entry set 1", jj.intValue() == i); 658 } 659 660 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 661 for (i = 0; i < sz; i++) { 662 Integer ii = new Integer(i); 663 lruhm.put(ii, ii.toString()); 664 } 665 666 Set s3 = lruhm.entrySet(); 667 Iterator it3 = s3.iterator(); 668 assertTrue("Returned set of incorrect size 2", lruhm.size() == s3 669 .size()); 670 for (i = 0; i < sz && it3.hasNext(); i++) { 671 Map.Entry m = (Map.Entry) it3.next(); 672 Integer jj = (Integer) m.getKey(); 673 assertTrue("Returned incorrect entry set 2", jj.intValue() == i); 674 } 675 676 /* fetch the even numbered entries to affect traversal order */ 677 int p = 0; 678 for (i = 0; i < sz; i += 2) { 679 String ii = (String) lruhm.get(new Integer(i)); 680 p = p + Integer.parseInt(ii); 681 } 682 assertEquals("invalid sum of even numbers", 2450, p); 683 684 Set s2 = lruhm.entrySet(); 685 Iterator it2 = s2.iterator(); 686 assertTrue("Returned set of incorrect size 3", lruhm.size() == s2 687 .size()); 688 for (i = 1; i < sz && it2.hasNext(); i += 2) { 689 Map.Entry m = (Map.Entry) it2.next(); 690 Integer jj = (Integer) m.getKey(); 691 assertTrue("Returned incorrect entry set 3", jj.intValue() == i); 692 } 693 for (i = 0; i < sz && it2.hasNext(); i += 2) { 694 Map.Entry m = (Map.Entry) it2.next(); 695 Integer jj = (Integer) m.getKey(); 696 assertTrue("Returned incorrect entry set 4", jj.intValue() == i); 697 } 698 assertTrue("Entries left to iterate on", !it2.hasNext()); 699 } 700 701 /** 702 * @tests java.util.LinkedHashMap#keySet() 703 */ 704 @TestTargetNew( 705 level = TestLevel.COMPLETE, 706 notes = "", 707 method = "keySet", 708 args = {} 709 ) 710 public void test_ordered_keySet() { 711 int i; 712 int sz = 100; 713 LinkedHashMap lhm = new LinkedHashMap(); 714 for (i = 0; i < sz; i++) { 715 Integer ii = new Integer(i); 716 lhm.put(ii, ii.toString()); 717 } 718 719 Set s1 = lhm.keySet(); 720 Iterator it1 = s1.iterator(); 721 assertTrue("Returned set of incorrect size", lhm.size() == s1.size()); 722 for (i = 0; it1.hasNext(); i++) { 723 Integer jj = (Integer) it1.next(); 724 assertTrue("Returned incorrect entry set", jj.intValue() == i); 725 } 726 727 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 728 for (i = 0; i < sz; i++) { 729 Integer ii = new Integer(i); 730 lruhm.put(ii, ii.toString()); 731 } 732 733 Set s3 = lruhm.keySet(); 734 Iterator it3 = s3.iterator(); 735 assertTrue("Returned set of incorrect size", lruhm.size() == s3.size()); 736 for (i = 0; i < sz && it3.hasNext(); i++) { 737 Integer jj = (Integer) it3.next(); 738 assertTrue("Returned incorrect entry set", jj.intValue() == i); 739 } 740 741 /* fetch the even numbered entries to affect traversal order */ 742 int p = 0; 743 for (i = 0; i < sz; i += 2) { 744 String ii = (String) lruhm.get(new Integer(i)); 745 p = p + Integer.parseInt(ii); 746 } 747 assertEquals("invalid sum of even numbers", 2450, p); 748 749 Set s2 = lruhm.keySet(); 750 Iterator it2 = s2.iterator(); 751 assertTrue("Returned set of incorrect size", lruhm.size() == s2.size()); 752 for (i = 1; i < sz && it2.hasNext(); i += 2) { 753 Integer jj = (Integer) it2.next(); 754 assertTrue("Returned incorrect entry set", jj.intValue() == i); 755 } 756 for (i = 0; i < sz && it2.hasNext(); i += 2) { 757 Integer jj = (Integer) it2.next(); 758 assertTrue("Returned incorrect entry set", jj.intValue() == i); 759 } 760 assertTrue("Entries left to iterate on", !it2.hasNext()); 761 } 762 763 /** 764 * @tests java.util.LinkedHashMap#values() 765 */ 766 @TestTargetNew( 767 level = TestLevel.COMPLETE, 768 notes = "", 769 method = "values", 770 args = {} 771 ) 772 public void test_ordered_values() { 773 int i; 774 int sz = 100; 775 LinkedHashMap lhm = new LinkedHashMap(); 776 for (i = 0; i < sz; i++) { 777 Integer ii = new Integer(i); 778 lhm.put(ii, new Integer(i * 2)); 779 } 780 781 Collection s1 = lhm.values(); 782 Iterator it1 = s1.iterator(); 783 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 784 for (i = 0; it1.hasNext(); i++) { 785 Integer jj = (Integer) it1.next(); 786 assertTrue("Returned incorrect entry set 1", jj.intValue() == i * 2); 787 } 788 789 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 790 for (i = 0; i < sz; i++) { 791 Integer ii = new Integer(i); 792 lruhm.put(ii, new Integer(i * 2)); 793 } 794 795 Collection s3 = lruhm.values(); 796 Iterator it3 = s3.iterator(); 797 assertTrue("Returned set of incorrect size", lruhm.size() == s3.size()); 798 for (i = 0; i < sz && it3.hasNext(); i++) { 799 Integer jj = (Integer) it3.next(); 800 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 801 } 802 803 // fetch the even numbered entries to affect traversal order 804 int p = 0; 805 for (i = 0; i < sz; i += 2) { 806 Integer ii = (Integer) lruhm.get(new Integer(i)); 807 p = p + ii.intValue(); 808 } 809 assertTrue("invalid sum of even numbers", p == 2450 * 2); 810 811 Collection s2 = lruhm.values(); 812 Iterator it2 = s2.iterator(); 813 assertTrue("Returned set of incorrect size", lruhm.size() == s2.size()); 814 for (i = 1; i < sz && it2.hasNext(); i += 2) { 815 Integer jj = (Integer) it2.next(); 816 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 817 } 818 for (i = 0; i < sz && it2.hasNext(); i += 2) { 819 Integer jj = (Integer) it2.next(); 820 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 821 } 822 assertTrue("Entries left to iterate on", !it2.hasNext()); 823 } 824 825 /** 826 * @tests java.util.LinkedHashMap#removeEldestEntry(java.util.Map$Entry) 827 */ 828 @TestTargetNew( 829 level = TestLevel.COMPLETE, 830 notes = "", 831 method = "removeEldestEntry", 832 args = {java.util.Map.Entry.class} 833 ) 834 public void test_remove_eldest() { 835 int i; 836 int sz = 10; 837 CacheMap lhm = new CacheMap(); 838 for (i = 0; i < sz; i++) { 839 Integer ii = new Integer(i); 840 lhm.put(ii, new Integer(i * 2)); 841 } 842 843 Collection s1 = lhm.values(); 844 Iterator it1 = s1.iterator(); 845 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 846 for (i = 5; it1.hasNext(); i++) { 847 Integer jj = (Integer) it1.next(); 848 assertTrue("Returned incorrect entry set 1", jj.intValue() == i * 2); 849 } 850 assertTrue("Entries left in map", !it1.hasNext()); 851 } 852 853 /** 854 * Sets up the fixture, for example, open a network connection. This method 855 * is called before a test is executed. 856 */ 857 protected void setUp() { 858 objArray = new Object[hmSize]; 859 objArray2 = new Object[hmSize]; 860 for (int i = 0; i < objArray.length; i++) { 861 objArray[i] = new Integer(i); 862 objArray2[i] = objArray[i].toString(); 863 } 864 865 hm = new LinkedHashMap(); 866 for (int i = 0; i < objArray.length; i++) 867 hm.put(objArray2[i], objArray[i]); 868 hm.put("test", null); 869 hm.put(null, "test"); 870 } 871 872 /** 873 * Tears down the fixture, for example, close a network connection. This 874 * method is called after a test is executed. 875 */ 876 protected void tearDown() { 877 objArray = null; 878 objArray2 = null; 879 hm = null; 880 } 881} 882