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 java.util.AbstractMap; 21import java.util.ArrayList; 22import java.util.Arrays; 23import java.util.Collection; 24import java.util.Iterator; 25import java.util.LinkedHashMap; 26import java.util.Map; 27import java.util.Set; 28import java.util.TreeMap; 29 30import tests.support.Support_MapTest2; 31import tests.support.Support_UnmodifiableCollectionTest; 32 33/** 34 * java.util.LinkedHashMap 35 */ 36public class LinkedHashMapTest extends junit.framework.TestCase { 37 38 LinkedHashMap hm; 39 40 final static int hmSize = 1000; 41 42 Object[] objArray; 43 44 Object[] objArray2; 45 46 static final class CacheMap extends LinkedHashMap { 47 protected boolean removeEldestEntry(Map.Entry e) { 48 return size() > 5; 49 } 50 } 51 52 private static class MockMapNull extends AbstractMap { 53 @Override 54 public Set entrySet() { 55 return null; 56 } 57 58 @Override 59 public int size() { 60 return 10; 61 } 62 } 63 64 /** 65 * java.util.LinkedHashMap#LinkedHashMap() 66 */ 67 public void test_Constructor() { 68 // Test for method java.util.LinkedHashMap() 69 new Support_MapTest2(new LinkedHashMap()).runTest(); 70 71 LinkedHashMap hm2 = new LinkedHashMap(); 72 assertEquals("Created incorrect LinkedHashMap", 0, hm2.size()); 73 } 74 75 /** 76 * java.util.LinkedHashMap#LinkedHashMap(int) 77 */ 78 public void test_ConstructorI() { 79 // Test for method java.util.LinkedHashMap(int) 80 LinkedHashMap hm2 = new LinkedHashMap(5); 81 assertEquals("Created incorrect LinkedHashMap", 0, hm2.size()); 82 try { 83 new LinkedHashMap(-1); 84 fail("Failed to throw IllegalArgumentException for initial " + 85 "capacity < 0"); 86 } catch (IllegalArgumentException e) { 87 //expected 88 } 89 90 LinkedHashMap empty = new LinkedHashMap(0); 91 assertNull("Empty LinkedHashMap access", empty.get("nothing")); 92 empty.put("something", "here"); 93 assertTrue("cannot get element", empty.get("something") == "here"); 94 } 95 96 /** 97 * java.util.LinkedHashMap#LinkedHashMap(int, float) 98 */ 99 public void test_ConstructorIF() { 100 // Test for method java.util.LinkedHashMap(int, float) 101 LinkedHashMap hm2 = new LinkedHashMap(5, (float) 0.5); 102 assertEquals("Created incorrect LinkedHashMap", 0, hm2.size()); 103 try { 104 new LinkedHashMap(0, 0); 105 fail("Failed to throw IllegalArgumentException for initial " + 106 "load factor <= 0"); 107 } catch (IllegalArgumentException e) { 108 //expected 109 } 110 111 LinkedHashMap empty = new LinkedHashMap(0, 0.75f); 112 assertNull("Empty hashtable access", empty.get("nothing")); 113 empty.put("something", "here"); 114 assertTrue("cannot get element", empty.get("something") == "here"); 115 } 116 117 /** 118 * java.util.LinkedHashMap#LinkedHashMap(java.util.Map) 119 */ 120 public void test_ConstructorLjava_util_Map() { 121 // Test for method java.util.LinkedHashMap(java.util.Map) 122 Map myMap = new TreeMap(); 123 for (int counter = 0; counter < hmSize; counter++) 124 myMap.put(objArray2[counter], objArray[counter]); 125 LinkedHashMap hm2 = new LinkedHashMap(myMap); 126 for (int counter = 0; counter < hmSize; counter++) 127 assertTrue("Failed to construct correct LinkedHashMap", hm 128 .get(objArray2[counter]) == hm2.get(objArray2[counter])); 129 } 130 131 /** 132 * java.util.LinkedHashMap#get(java.lang.Object) 133 */ 134 public void test_getLjava_lang_Object() { 135 // Test for method java.lang.Object 136 // java.util.LinkedHashMap.get(java.lang.Object) 137 assertNull("Get returned non-null for non existent key", 138 hm.get("T")); 139 hm.put("T", "HELLO"); 140 assertEquals("Get returned incorecct value for existing key", "HELLO", hm.get("T") 141 ); 142 143 LinkedHashMap m = new LinkedHashMap(); 144 m.put(null, "test"); 145 assertEquals("Failed with null key", "test", m.get(null)); 146 assertNull("Failed with missing key matching null hash", m 147 .get(new Integer(0))); 148 } 149 150 /** 151 * java.util.LinkedHashMap#put(java.lang.Object, java.lang.Object) 152 */ 153 public void test_putLjava_lang_ObjectLjava_lang_Object() { 154 // Test for method java.lang.Object 155 // java.util.LinkedHashMap.put(java.lang.Object, java.lang.Object) 156 hm.put("KEY", "VALUE"); 157 assertEquals("Failed to install key/value pair", 158 "VALUE", hm.get("KEY")); 159 160 LinkedHashMap m = new LinkedHashMap(); 161 m.put(new Short((short) 0), "short"); 162 m.put(null, "test"); 163 m.put(new Integer(0), "int"); 164 assertEquals("Failed adding to bucket containing null", "short", m.get( 165 new Short((short) 0))); 166 assertEquals("Failed adding to bucket containing null2", "int", m.get( 167 new Integer(0))); 168 } 169 170 171 public void test_putPresent() { 172 Map<String, String> m = new LinkedHashMap<String, String>(8, .75f, true); 173 m.put("KEY", "VALUE"); 174 m.put("WOMBAT", "COMBAT"); 175 m.put("KEY", "VALUE"); 176 Map.Entry newest = null; 177 for (Map.Entry<String, String> e : m.entrySet()) { 178 newest = e; 179 } 180 assertEquals("KEY", newest.getKey()); 181 assertEquals("VALUE", newest.getValue()); 182 } 183 184 /** 185 * java.util.LinkedHashMap#putAll(java.util.Map) 186 */ 187 public void test_putAllLjava_util_Map() { 188 // Test for method void java.util.LinkedHashMap.putAll(java.util.Map) 189 LinkedHashMap hm2 = new LinkedHashMap(); 190 hm2.putAll(hm); 191 for (int i = 0; i < 1000; i++) 192 assertTrue("Failed to clear all elements", hm2.get( 193 new Integer(i).toString()).equals((new Integer(i)))); 194 } 195 196 /** 197 * java.util.LinkedHashMap#putAll(java.util.Map) 198 */ 199 public void test_putAll_Ljava_util_Map_Null() { 200 LinkedHashMap linkedHashMap = new LinkedHashMap(); 201 try { 202 linkedHashMap.putAll(new MockMapNull()); 203 fail("Should throw NullPointerException"); 204 } catch (NullPointerException e) { 205 // expected. 206 } 207 208 try { 209 linkedHashMap = new LinkedHashMap(new MockMapNull()); 210 fail("Should throw NullPointerException"); 211 } catch (NullPointerException e) { 212 // expected. 213 } 214 } 215 216 /** 217 * java.util.LinkedHashMap#entrySet() 218 */ 219 public void test_entrySet() { 220 // Test for method java.util.Set java.util.LinkedHashMap.entrySet() 221 Set s = hm.entrySet(); 222 Iterator i = s.iterator(); 223 assertTrue("Returned set of incorrect size", hm.size() == s.size()); 224 while (i.hasNext()) { 225 Map.Entry m = (Map.Entry) i.next(); 226 assertTrue("Returned incorrect entry set", hm.containsKey(m 227 .getKey()) 228 && hm.containsValue(m.getValue())); 229 } 230 } 231 232 public void test_entrySetRemove() { 233 entrySetRemoveHelper("military", "intelligence"); 234 entrySetRemoveHelper(null, "hypothesis"); 235 } 236 private void entrySetRemoveHelper(String key, String value) { 237 Map<String, String> m1 = new LinkedHashMap<String, String>(); 238 m1.put(key, value); 239 m1.put("jumbo", "shrimp"); 240 LinkedHashMap<String, String> m2 = new LinkedHashMap<String, String>(m1); 241 Set<Map.Entry<String, String>> s1 = m1.entrySet(); 242 s1.remove(m2.entrySet().iterator().next()); 243 assertEquals("jumbo", s1.iterator().next().getKey()); 244 } 245 246 /** 247 * java.util.LinkedHashMap#keySet() 248 */ 249 public void test_keySet() { 250 // Test for method java.util.Set java.util.LinkedHashMap.keySet() 251 Set s = hm.keySet(); 252 assertTrue("Returned set of incorrect size()", s.size() == hm.size()); 253 for (int i = 0; i < objArray.length; i++) 254 assertTrue("Returned set does not contain all keys", s 255 .contains(objArray[i].toString())); 256 257 LinkedHashMap m = new LinkedHashMap(); 258 m.put(null, "test"); 259 assertTrue("Failed with null key", m.keySet().contains(null)); 260 assertNull("Failed with null key", m.keySet().iterator().next()); 261 262 Map map = new LinkedHashMap(101); 263 map.put(new Integer(1), "1"); 264 map.put(new Integer(102), "102"); 265 map.put(new Integer(203), "203"); 266 Iterator it = map.keySet().iterator(); 267 Integer remove1 = (Integer) it.next(); 268 it.hasNext(); 269 it.remove(); 270 Integer remove2 = (Integer) it.next(); 271 it.remove(); 272 ArrayList list = new ArrayList(Arrays.asList(new Integer[] { 273 new Integer(1), new Integer(102), new Integer(203) })); 274 list.remove(remove1); 275 list.remove(remove2); 276 assertTrue("Wrong result", it.next().equals(list.get(0))); 277 assertEquals("Wrong size", 1, map.size()); 278 assertTrue("Wrong contents", map.keySet().iterator().next().equals( 279 list.get(0))); 280 281 Map map2 = new LinkedHashMap(101); 282 map2.put(new Integer(1), "1"); 283 map2.put(new Integer(4), "4"); 284 Iterator it2 = map2.keySet().iterator(); 285 Integer remove3 = (Integer) it2.next(); 286 Integer next; 287 if (remove3.intValue() == 1) 288 next = new Integer(4); 289 else 290 next = new Integer(1); 291 it2.hasNext(); 292 it2.remove(); 293 assertTrue("Wrong result 2", it2.next().equals(next)); 294 assertEquals("Wrong size 2", 1, map2.size()); 295 assertTrue("Wrong contents 2", map2.keySet().iterator().next().equals( 296 next)); 297 } 298 299 /** 300 * java.util.LinkedHashMap#values() 301 */ 302 public void test_values() { 303 // Test for method java.util.Collection java.util.LinkedHashMap.values() 304 Collection c = hm.values(); 305 assertTrue("Returned collection of incorrect size()", c.size() == hm 306 .size()); 307 for (int i = 0; i < objArray.length; i++) 308 assertTrue("Returned collection does not contain all keys", c 309 .contains(objArray[i])); 310 311 LinkedHashMap myLinkedHashMap = new LinkedHashMap(); 312 for (int i = 0; i < 100; i++) 313 myLinkedHashMap.put(objArray2[i], objArray[i]); 314 Collection values = myLinkedHashMap.values(); 315 new Support_UnmodifiableCollectionTest( 316 "Test Returned Collection From LinkedHashMap.values()", values) 317 .runTest(); 318 values.remove(new Integer(0)); 319 assertTrue( 320 "Removing from the values collection should remove from the original map", 321 !myLinkedHashMap.containsValue(new Integer(0))); 322 323 } 324 325 /** 326 * java.util.LinkedHashMap#remove(java.lang.Object) 327 */ 328 public void test_removeLjava_lang_Object() { 329 // Test for method java.lang.Object 330 // java.util.LinkedHashMap.remove(java.lang.Object) 331 int size = hm.size(); 332 Integer y = new Integer(9); 333 Integer x = ((Integer) hm.remove(y.toString())); 334 assertTrue("Remove returned incorrect value", x.equals(new Integer(9))); 335 assertNull("Failed to remove given key", hm.get(new Integer(9))); 336 assertTrue("Failed to decrement size", hm.size() == (size - 1)); 337 assertNull("Remove of non-existent key returned non-null", hm 338 .remove("LCLCLC")); 339 340 LinkedHashMap m = new LinkedHashMap(); 341 m.put(null, "test"); 342 assertNull("Failed with same hash as null", 343 m.remove(new Integer(0))); 344 assertEquals("Failed with null key", "test", m.remove(null)); 345 } 346 347 /** 348 * java.util.LinkedHashMap#clear() 349 */ 350 public void test_clear() { 351 // Test for method void java.util.LinkedHashMap.clear() 352 hm.clear(); 353 assertEquals("Clear failed to reset size", 0, hm.size()); 354 for (int i = 0; i < hmSize; i++) 355 assertNull("Failed to clear all elements", 356 hm.get(objArray2[i])); 357 358 } 359 360 /** 361 * java.util.LinkedHashMap#clone() 362 */ 363 public void test_clone() { 364 // Test for method java.lang.Object java.util.LinkedHashMap.clone() 365 LinkedHashMap hm2 = (LinkedHashMap) hm.clone(); 366 assertTrue("Clone answered equivalent LinkedHashMap", hm2 != hm); 367 for (int counter = 0; counter < hmSize; counter++) 368 assertTrue("Clone answered unequal LinkedHashMap", hm 369 .get(objArray2[counter]) == hm2.get(objArray2[counter])); 370 371 LinkedHashMap map = new LinkedHashMap(); 372 map.put("key", "value"); 373 // get the keySet() and values() on the original Map 374 Set keys = map.keySet(); 375 Collection values = map.values(); 376 assertEquals("values() does not work", 377 "value", values.iterator().next()); 378 assertEquals("keySet() does not work", 379 "key", keys.iterator().next()); 380 AbstractMap map2 = (AbstractMap) map.clone(); 381 map2.put("key", "value2"); 382 Collection values2 = map2.values(); 383 assertTrue("values() is identical", values2 != values); 384 385 // values() and keySet() on the cloned() map should be different 386 assertEquals("values() was not cloned", 387 "value2", values2.iterator().next()); 388 map2.clear(); 389 map2.put("key2", "value3"); 390 Set key2 = map2.keySet(); 391 assertTrue("keySet() is identical", key2 != keys); 392 assertEquals("keySet() was not cloned", 393 "key2", key2.iterator().next()); 394 } 395 396 /** 397 * java.util.LinkedHashMap#clone() 398 */ 399 public void test_clone_ordered() { 400 // Test for method java.lang.Object java.util.LinkedHashMap.clone() 401 LinkedHashMap<String, String> hm1 = new LinkedHashMap<String, String>(10, 0.75f, true); 402 hm1.put("a", "a"); 403 hm1.put("b", "b"); 404 hm1.put("c", "c"); 405 LinkedHashMap<String, String> hm2 = (LinkedHashMap<String, String>) hm1.clone(); 406 hm1.get("a"); 407 408 Map.Entry<String, String>[] set = new Map.Entry[3]; 409 Iterator<Map.Entry<String,String>> iterator = hm1.entrySet().iterator(); 410 411 assertEquals("b", iterator.next().getKey()); 412 assertEquals("c", iterator.next().getKey()); 413 assertEquals("a", iterator.next().getKey()); 414 415 iterator = hm2.entrySet().iterator(); 416 assertEquals("a", iterator.next().getKey()); 417 assertEquals("b", iterator.next().getKey()); 418 assertEquals("c", iterator.next().getKey()); 419 } 420 421 // regresion test for HARMONY-4603 422 public void test_clone_Mock() { 423 LinkedHashMap hashMap = new MockMap(); 424 String value = "value a"; 425 hashMap.put("key", value); 426 MockMap cloneMap = (MockMap) hashMap.clone(); 427 assertEquals(value, cloneMap.get("key")); 428 assertEquals(hashMap, cloneMap); 429 assertEquals(1, cloneMap.num); 430 431 hashMap.put("key", "value b"); 432 assertFalse(hashMap.equals(cloneMap)); 433 } 434 435 class MockMap extends LinkedHashMap { 436 int num; 437 438 public Object put(Object k, Object v) { 439 num++; 440 return super.put(k, v); 441 } 442 443 protected boolean removeEldestEntry(Map.Entry e) { 444 return num > 1; 445 } 446 } 447 448 /** 449 * put/get interaction in access-order map where removeEldest 450 * returns true. 451 */ 452 public void test_removeEldestFromSameBucketAsNewEntry() { 453 LinkedHashMap<String, String> map 454 = new LinkedHashMap<String, String>(6, 0.75F, true) { 455 @Override 456 protected boolean removeEldestEntry(Entry<String, String> e) { 457 return true; 458 } 459 }; 460 map.put("N", "E"); 461 map.put("F", "I"); 462 assertEquals(null, map.get("N")); 463 } 464 465 /** 466 * java.util.LinkedHashMap#containsKey(java.lang.Object) 467 */ 468 public void test_containsKeyLjava_lang_Object() { 469 // Test for method boolean 470 // java.util.LinkedHashMap.containsKey(java.lang.Object) 471 assertTrue("Returned false for valid key", hm.containsKey(new Integer( 472 876).toString())); 473 assertTrue("Returned true for invalid key", !hm.containsKey("KKDKDKD")); 474 475 LinkedHashMap m = new LinkedHashMap(); 476 m.put(null, "test"); 477 assertTrue("Failed with null key", m.containsKey(null)); 478 assertTrue("Failed with missing key matching null hash", !m 479 .containsKey(new Integer(0))); 480 } 481 482 /** 483 * java.util.LinkedHashMap#containsValue(java.lang.Object) 484 */ 485 public void test_containsValueLjava_lang_Object() { 486 // Test for method boolean 487 // java.util.LinkedHashMap.containsValue(java.lang.Object) 488 assertTrue("Returned false for valid value", hm 489 .containsValue(new Integer(875))); 490 assertTrue("Returned true for invalid valie", !hm 491 .containsValue(new Integer(-9))); 492 } 493 494 /** 495 * java.util.LinkedHashMap#isEmpty() 496 */ 497 public void test_isEmpty() { 498 // Test for method boolean java.util.LinkedHashMap.isEmpty() 499 assertTrue("Returned false for new map", new LinkedHashMap().isEmpty()); 500 assertTrue("Returned true for non-empty", !hm.isEmpty()); 501 } 502 503 /** 504 * java.util.LinkedHashMap#size() 505 */ 506 public void test_size() { 507 // Test for method int java.util.LinkedHashMap.size() 508 assertTrue("Returned incorrect size", 509 hm.size() == (objArray.length + 2)); 510 } 511 512 /** 513 * java.util.LinkedHashMap#entrySet() 514 */ 515 public void test_ordered_entrySet() { 516 int i; 517 int sz = 100; 518 LinkedHashMap lhm = new LinkedHashMap(); 519 for (i = 0; i < sz; i++) { 520 Integer ii = new Integer(i); 521 lhm.put(ii, ii.toString()); 522 } 523 524 Set s1 = lhm.entrySet(); 525 Iterator it1 = s1.iterator(); 526 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 527 for (i = 0; it1.hasNext(); i++) { 528 Map.Entry m = (Map.Entry) it1.next(); 529 Integer jj = (Integer) m.getKey(); 530 assertTrue("Returned incorrect entry set 1", jj.intValue() == i); 531 } 532 533 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 534 for (i = 0; i < sz; i++) { 535 Integer ii = new Integer(i); 536 lruhm.put(ii, ii.toString()); 537 } 538 539 Set s3 = lruhm.entrySet(); 540 Iterator it3 = s3.iterator(); 541 assertTrue("Returned set of incorrect size 2", lruhm.size() == s3 542 .size()); 543 for (i = 0; i < sz && it3.hasNext(); i++) { 544 Map.Entry m = (Map.Entry) it3.next(); 545 Integer jj = (Integer) m.getKey(); 546 assertTrue("Returned incorrect entry set 2", jj.intValue() == i); 547 } 548 549 /* fetch the even numbered entries to affect traversal order */ 550 int p = 0; 551 for (i = 0; i < sz; i += 2) { 552 String ii = (String) lruhm.get(new Integer(i)); 553 p = p + Integer.parseInt(ii); 554 } 555 assertEquals("invalid sum of even numbers", 2450, p); 556 557 Set s2 = lruhm.entrySet(); 558 Iterator it2 = s2.iterator(); 559 assertTrue("Returned set of incorrect size 3", lruhm.size() == s2 560 .size()); 561 for (i = 1; i < sz && it2.hasNext(); i += 2) { 562 Map.Entry m = (Map.Entry) it2.next(); 563 Integer jj = (Integer) m.getKey(); 564 assertTrue("Returned incorrect entry set 3", jj.intValue() == i); 565 } 566 for (i = 0; i < sz && it2.hasNext(); i += 2) { 567 Map.Entry m = (Map.Entry) it2.next(); 568 Integer jj = (Integer) m.getKey(); 569 assertTrue("Returned incorrect entry set 4", jj.intValue() == i); 570 } 571 assertTrue("Entries left to iterate on", !it2.hasNext()); 572 } 573 574 /** 575 * java.util.LinkedHashMap#keySet() 576 */ 577 public void test_ordered_keySet() { 578 int i; 579 int sz = 100; 580 LinkedHashMap lhm = new LinkedHashMap(); 581 for (i = 0; i < sz; i++) { 582 Integer ii = new Integer(i); 583 lhm.put(ii, ii.toString()); 584 } 585 586 Set s1 = lhm.keySet(); 587 Iterator it1 = s1.iterator(); 588 assertTrue("Returned set of incorrect size", lhm.size() == s1.size()); 589 for (i = 0; it1.hasNext(); i++) { 590 Integer jj = (Integer) it1.next(); 591 assertTrue("Returned incorrect entry set", jj.intValue() == i); 592 } 593 594 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 595 for (i = 0; i < sz; i++) { 596 Integer ii = new Integer(i); 597 lruhm.put(ii, ii.toString()); 598 } 599 600 Set s3 = lruhm.keySet(); 601 Iterator it3 = s3.iterator(); 602 assertTrue("Returned set of incorrect size", lruhm.size() == s3.size()); 603 for (i = 0; i < sz && it3.hasNext(); i++) { 604 Integer jj = (Integer) it3.next(); 605 assertTrue("Returned incorrect entry set", jj.intValue() == i); 606 } 607 608 /* fetch the even numbered entries to affect traversal order */ 609 int p = 0; 610 for (i = 0; i < sz; i += 2) { 611 String ii = (String) lruhm.get(new Integer(i)); 612 p = p + Integer.parseInt(ii); 613 } 614 assertEquals("invalid sum of even numbers", 2450, p); 615 616 Set s2 = lruhm.keySet(); 617 Iterator it2 = s2.iterator(); 618 assertTrue("Returned set of incorrect size", lruhm.size() == s2.size()); 619 for (i = 1; i < sz && it2.hasNext(); i += 2) { 620 Integer jj = (Integer) it2.next(); 621 assertTrue("Returned incorrect entry set", jj.intValue() == i); 622 } 623 for (i = 0; i < sz && it2.hasNext(); i += 2) { 624 Integer jj = (Integer) it2.next(); 625 assertTrue("Returned incorrect entry set", jj.intValue() == i); 626 } 627 assertTrue("Entries left to iterate on", !it2.hasNext()); 628 } 629 630 /** 631 * java.util.LinkedHashMap#values() 632 */ 633 public void test_ordered_values() { 634 int i; 635 int sz = 100; 636 LinkedHashMap lhm = new LinkedHashMap(); 637 for (i = 0; i < sz; i++) { 638 Integer ii = new Integer(i); 639 lhm.put(ii, new Integer(i * 2)); 640 } 641 642 Collection s1 = lhm.values(); 643 Iterator it1 = s1.iterator(); 644 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 645 for (i = 0; it1.hasNext(); i++) { 646 Integer jj = (Integer) it1.next(); 647 assertTrue("Returned incorrect entry set 1", jj.intValue() == i * 2); 648 } 649 650 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 651 for (i = 0; i < sz; i++) { 652 Integer ii = new Integer(i); 653 lruhm.put(ii, new Integer(i * 2)); 654 } 655 656 Collection s3 = lruhm.values(); 657 Iterator it3 = s3.iterator(); 658 assertTrue("Returned set of incorrect size", lruhm.size() == s3.size()); 659 for (i = 0; i < sz && it3.hasNext(); i++) { 660 Integer jj = (Integer) it3.next(); 661 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 662 } 663 664 // fetch the even numbered entries to affect traversal order 665 int p = 0; 666 for (i = 0; i < sz; i += 2) { 667 Integer ii = (Integer) lruhm.get(new Integer(i)); 668 p = p + ii.intValue(); 669 } 670 assertTrue("invalid sum of even numbers", p == 2450 * 2); 671 672 Collection s2 = lruhm.values(); 673 Iterator it2 = s2.iterator(); 674 assertTrue("Returned set of incorrect size", lruhm.size() == s2.size()); 675 for (i = 1; i < sz && it2.hasNext(); i += 2) { 676 Integer jj = (Integer) it2.next(); 677 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 678 } 679 for (i = 0; i < sz && it2.hasNext(); i += 2) { 680 Integer jj = (Integer) it2.next(); 681 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 682 } 683 assertTrue("Entries left to iterate on", !it2.hasNext()); 684 } 685 686 /** 687 * java.util.LinkedHashMap#removeEldestEntry(java.util.Map$Entry) 688 */ 689 public void test_remove_eldest() { 690 int i; 691 int sz = 10; 692 CacheMap lhm = new CacheMap(); 693 for (i = 0; i < sz; i++) { 694 Integer ii = new Integer(i); 695 lhm.put(ii, new Integer(i * 2)); 696 } 697 698 Collection s1 = lhm.values(); 699 Iterator it1 = s1.iterator(); 700 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 701 for (i = 5; it1.hasNext(); i++) { 702 Integer jj = (Integer) it1.next(); 703 assertTrue("Returned incorrect entry set 1", jj.intValue() == i * 2); 704 } 705 assertTrue("Entries left in map", !it1.hasNext()); 706 } 707 708 /** 709 * Sets up the fixture, for example, open a network connection. This method 710 * is called before a test is executed. 711 */ 712 protected void setUp() { 713 objArray = new Object[hmSize]; 714 objArray2 = new Object[hmSize]; 715 for (int i = 0; i < objArray.length; i++) { 716 objArray[i] = new Integer(i); 717 objArray2[i] = objArray[i].toString(); 718 } 719 720 hm = new LinkedHashMap(); 721 for (int i = 0; i < objArray.length; i++) 722 hm.put(objArray2[i], objArray[i]); 723 hm.put("test", null); 724 hm.put(null, "test"); 725 } 726 727 /** 728 * Tears down the fixture, for example, close a network connection. This 729 * method is called after a test is executed. 730 */ 731 protected void tearDown() { 732 objArray = null; 733 objArray2 = null; 734 hm = null; 735 } 736} 737