LinkedHashMapTest.java revision 6d5c5d6c3e64b37d67af1d516b70a3fee38b2796
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 * @tests java.util.LinkedHashMap#putAll(java.util.Map) 214 */ 215 @TestTargetNew( 216 level = TestLevel.PARTIAL_COMPLETE, 217 notes = "", 218 method = "putAll", 219 args = {java.util.Map.class} 220 ) 221 public void test_putAllLjava_util_Map() { 222 // Test for method void java.util.LinkedHashMap.putAll(java.util.Map) 223 LinkedHashMap hm2 = new LinkedHashMap(); 224 hm2.putAll(hm); 225 for (int i = 0; i < 1000; i++) 226 assertTrue("Failed to clear all elements", hm2.get( 227 new Integer(i).toString()).equals((new Integer(i)))); 228 } 229 230 /** 231 * @tests java.util.LinkedHashMap#putAll(java.util.Map) 232 */ 233 @TestTargetNew( 234 level = TestLevel.PARTIAL_COMPLETE, 235 notes = "Verifies NullPointerException.", 236 method = "putAll", 237 args = {java.util.Map.class} 238 ) 239 public void test_putAll_Ljava_util_Map_Null() { 240 LinkedHashMap linkedHashMap = new LinkedHashMap(); 241 try { 242 linkedHashMap.putAll(new MockMapNull()); 243 fail("Should throw NullPointerException"); 244 } catch (NullPointerException e) { 245 // expected. 246 } 247 248 try { 249 linkedHashMap = new LinkedHashMap(new MockMapNull()); 250 fail("Should throw NullPointerException"); 251 } catch (NullPointerException e) { 252 // expected. 253 } 254 } 255 256 /** 257 * @tests java.util.LinkedHashMap#entrySet() 258 */ 259 @TestTargetNew( 260 level = TestLevel.COMPLETE, 261 notes = "", 262 method = "entrySet", 263 args = {} 264 ) 265 public void test_entrySet() { 266 // Test for method java.util.Set java.util.LinkedHashMap.entrySet() 267 Set s = hm.entrySet(); 268 Iterator i = s.iterator(); 269 assertTrue("Returned set of incorrect size", hm.size() == s.size()); 270 while (i.hasNext()) { 271 Map.Entry m = (Map.Entry) i.next(); 272 assertTrue("Returned incorrect entry set", hm.containsKey(m 273 .getKey()) 274 && hm.containsValue(m.getValue())); 275 } 276 } 277 278 /** 279 * @tests java.util.LinkedHashMap#keySet() 280 */ 281 @TestTargetNew( 282 level = TestLevel.COMPLETE, 283 notes = "", 284 method = "keySet", 285 args = {} 286 ) 287 public void test_keySet() { 288 // Test for method java.util.Set java.util.LinkedHashMap.keySet() 289 Set s = hm.keySet(); 290 assertTrue("Returned set of incorrect size()", s.size() == hm.size()); 291 for (int i = 0; i < objArray.length; i++) 292 assertTrue("Returned set does not contain all keys", s 293 .contains(objArray[i].toString())); 294 295 LinkedHashMap m = new LinkedHashMap(); 296 m.put(null, "test"); 297 assertTrue("Failed with null key", m.keySet().contains(null)); 298 assertNull("Failed with null key", m.keySet().iterator().next()); 299 300 Map map = new LinkedHashMap(101); 301 map.put(new Integer(1), "1"); 302 map.put(new Integer(102), "102"); 303 map.put(new Integer(203), "203"); 304 Iterator it = map.keySet().iterator(); 305 Integer remove1 = (Integer) it.next(); 306 it.hasNext(); 307 it.remove(); 308 Integer remove2 = (Integer) it.next(); 309 it.remove(); 310 ArrayList list = new ArrayList(Arrays.asList(new Integer[] { 311 new Integer(1), new Integer(102), new Integer(203) })); 312 list.remove(remove1); 313 list.remove(remove2); 314 assertTrue("Wrong result", it.next().equals(list.get(0))); 315 assertEquals("Wrong size", 1, map.size()); 316 assertTrue("Wrong contents", map.keySet().iterator().next().equals( 317 list.get(0))); 318 319 Map map2 = new LinkedHashMap(101); 320 map2.put(new Integer(1), "1"); 321 map2.put(new Integer(4), "4"); 322 Iterator it2 = map2.keySet().iterator(); 323 Integer remove3 = (Integer) it2.next(); 324 Integer next; 325 if (remove3.intValue() == 1) 326 next = new Integer(4); 327 else 328 next = new Integer(1); 329 it2.hasNext(); 330 it2.remove(); 331 assertTrue("Wrong result 2", it2.next().equals(next)); 332 assertEquals("Wrong size 2", 1, map2.size()); 333 assertTrue("Wrong contents 2", map2.keySet().iterator().next().equals( 334 next)); 335 } 336 337 /** 338 * @tests java.util.LinkedHashMap#values() 339 */ 340 @TestTargetNew( 341 level = TestLevel.COMPLETE, 342 notes = "", 343 method = "values", 344 args = {} 345 ) 346 public void test_values() { 347 // Test for method java.util.Collection java.util.LinkedHashMap.values() 348 Collection c = hm.values(); 349 assertTrue("Returned collection of incorrect size()", c.size() == hm 350 .size()); 351 for (int i = 0; i < objArray.length; i++) 352 assertTrue("Returned collection does not contain all keys", c 353 .contains(objArray[i])); 354 355 LinkedHashMap myLinkedHashMap = new LinkedHashMap(); 356 for (int i = 0; i < 100; i++) 357 myLinkedHashMap.put(objArray2[i], objArray[i]); 358 Collection values = myLinkedHashMap.values(); 359 new Support_UnmodifiableCollectionTest( 360 "Test Returned Collection From LinkedHashMap.values()", values) 361 .runTest(); 362 values.remove(new Integer(0)); 363 assertTrue( 364 "Removing from the values collection should remove from the original map", 365 !myLinkedHashMap.containsValue(new Integer(0))); 366 367 } 368 369 /** 370 * @tests java.util.LinkedHashMap#remove(java.lang.Object) 371 */ 372 @TestTargetNew( 373 level = TestLevel.COMPLETE, 374 notes = "", 375 method = "remove", 376 args = {java.lang.Object.class} 377 ) 378 public void test_removeLjava_lang_Object() { 379 // Test for method java.lang.Object 380 // java.util.LinkedHashMap.remove(java.lang.Object) 381 int size = hm.size(); 382 Integer y = new Integer(9); 383 Integer x = ((Integer) hm.remove(y.toString())); 384 assertTrue("Remove returned incorrect value", x.equals(new Integer(9))); 385 assertNull("Failed to remove given key", hm.get(new Integer(9))); 386 assertTrue("Failed to decrement size", hm.size() == (size - 1)); 387 assertNull("Remove of non-existent key returned non-null", hm 388 .remove("LCLCLC")); 389 390 LinkedHashMap m = new LinkedHashMap(); 391 m.put(null, "test"); 392 assertNull("Failed with same hash as null", 393 m.remove(new Integer(0))); 394 assertEquals("Failed with null key", "test", m.remove(null)); 395 } 396 397 /** 398 * @tests java.util.LinkedHashMap#clear() 399 */ 400 @TestTargetNew( 401 level = TestLevel.COMPLETE, 402 notes = "", 403 method = "clear", 404 args = {} 405 ) 406 public void test_clear() { 407 // Test for method void java.util.LinkedHashMap.clear() 408 hm.clear(); 409 assertEquals("Clear failed to reset size", 0, hm.size()); 410 for (int i = 0; i < hmSize; i++) 411 assertNull("Failed to clear all elements", 412 hm.get(objArray2[i])); 413 414 } 415 416 /** 417 * @tests java.util.LinkedHashMap#clone() 418 */ 419 @TestTargetNew( 420 level = TestLevel.COMPLETE, 421 notes = "", 422 method = "clone", 423 args = {} 424 ) 425 public void test_clone() { 426 // Test for method java.lang.Object java.util.LinkedHashMap.clone() 427 LinkedHashMap hm2 = (LinkedHashMap) hm.clone(); 428 assertTrue("Clone answered equivalent LinkedHashMap", hm2 != hm); 429 for (int counter = 0; counter < hmSize; counter++) 430 assertTrue("Clone answered unequal LinkedHashMap", hm 431 .get(objArray2[counter]) == hm2.get(objArray2[counter])); 432 433 LinkedHashMap map = new LinkedHashMap(); 434 map.put("key", "value"); 435 // get the keySet() and values() on the original Map 436 Set keys = map.keySet(); 437 Collection values = map.values(); 438 assertEquals("values() does not work", 439 "value", values.iterator().next()); 440 assertEquals("keySet() does not work", 441 "key", keys.iterator().next()); 442 AbstractMap map2 = (AbstractMap) map.clone(); 443 map2.put("key", "value2"); 444 Collection values2 = map2.values(); 445 assertTrue("values() is identical", values2 != values); 446 447 // values() and keySet() on the cloned() map should be different 448 assertEquals("values() was not cloned", 449 "value2", values2.iterator().next()); 450 map2.clear(); 451 map2.put("key2", "value3"); 452 Set key2 = map2.keySet(); 453 assertTrue("keySet() is identical", key2 != keys); 454 assertEquals("keySet() was not cloned", 455 "key2", key2.iterator().next()); 456 } 457 458 /** 459 * @tests java.util.LinkedHashMap#clone() 460 */ 461 @TestTargetNew( 462 level = TestLevel.PARTIAL_COMPLETE, 463 notes = "", 464 method = "clone", 465 args = {} 466 ) 467 public void test_clone_ordered() { 468 // Test for method java.lang.Object java.util.LinkedHashMap.clone() 469 LinkedHashMap<String, String> hm1 = new LinkedHashMap<String, String>(10, 0.75f, true); 470 hm1.put("a", "a"); 471 hm1.put("b", "b"); 472 hm1.put("c", "c"); 473 LinkedHashMap<String, String> hm2 = (LinkedHashMap<String, String>) hm1.clone(); 474 hm1.get("a"); 475 476 Map.Entry<String, String>[] set = new Map.Entry[3]; 477 Iterator<Map.Entry<String,String>> iterator = hm1.entrySet().iterator(); 478 479 assertEquals("b", iterator.next().getKey()); 480 assertEquals("c", iterator.next().getKey()); 481 assertEquals("a", iterator.next().getKey()); 482 483 iterator = hm2.entrySet().iterator(); 484 assertEquals("a", iterator.next().getKey()); 485 assertEquals("b", iterator.next().getKey()); 486 assertEquals("c", iterator.next().getKey()); 487 } 488 489 @TestTargetNew( 490 level = TestLevel.PARTIAL_COMPLETE, 491 notes = "Regression test.", 492 method = "clone", 493 args = {} 494 ) 495 // regresion test for HARMONY-4603 496 public void test_clone_Mock() { 497 LinkedHashMap hashMap = new MockMap(); 498 String value = "value a"; 499 hashMap.put("key", value); 500 MockMap cloneMap = (MockMap) hashMap.clone(); 501 assertEquals(value, cloneMap.get("key")); 502 assertEquals(hashMap, cloneMap); 503 assertEquals(1, cloneMap.num); 504 505 hashMap.put("key", "value b"); 506 assertFalse(hashMap.equals(cloneMap)); 507 } 508 509 class MockMap extends LinkedHashMap { 510 int num; 511 512 public Object put(Object k, Object v) { 513 num++; 514 return super.put(k, v); 515 } 516 517 protected boolean removeEldestEntry(Map.Entry e) { 518 return num > 1; 519 } 520 } 521 522 /** 523 * @tests java.util.LinkedHashMap#containsKey(java.lang.Object) 524 */ 525 @TestTargetNew( 526 level = TestLevel.PARTIAL_COMPLETE, 527 notes = "Doesn't verify ClassCastException, NullPointerException.", 528 method = "containsKey", 529 args = {java.lang.Object.class} 530 ) 531 public void test_containsKeyLjava_lang_Object() { 532 // Test for method boolean 533 // java.util.LinkedHashMap.containsKey(java.lang.Object) 534 assertTrue("Returned false for valid key", hm.containsKey(new Integer( 535 876).toString())); 536 assertTrue("Returned true for invalid key", !hm.containsKey("KKDKDKD")); 537 538 LinkedHashMap m = new LinkedHashMap(); 539 m.put(null, "test"); 540 assertTrue("Failed with null key", m.containsKey(null)); 541 assertTrue("Failed with missing key matching null hash", !m 542 .containsKey(new Integer(0))); 543 } 544 545 /** 546 * @tests java.util.LinkedHashMap#containsValue(java.lang.Object) 547 */ 548 @TestTargetNew( 549 level = TestLevel.PARTIAL_COMPLETE, 550 notes = "Doesn't verify ClassCastException, NullPointerException.", 551 method = "containsValue", 552 args = {java.lang.Object.class} 553 ) 554 public void test_containsValueLjava_lang_Object() { 555 // Test for method boolean 556 // java.util.LinkedHashMap.containsValue(java.lang.Object) 557 assertTrue("Returned false for valid value", hm 558 .containsValue(new Integer(875))); 559 assertTrue("Returned true for invalid valie", !hm 560 .containsValue(new Integer(-9))); 561 } 562 563 /** 564 * @tests java.util.LinkedHashMap#isEmpty() 565 */ 566 @TestTargetNew( 567 level = TestLevel.COMPLETE, 568 notes = "", 569 method = "isEmpty", 570 args = {} 571 ) 572 public void test_isEmpty() { 573 // Test for method boolean java.util.LinkedHashMap.isEmpty() 574 assertTrue("Returned false for new map", new LinkedHashMap().isEmpty()); 575 assertTrue("Returned true for non-empty", !hm.isEmpty()); 576 } 577 578 /** 579 * @tests java.util.LinkedHashMap#size() 580 */ 581 @TestTargetNew( 582 level = TestLevel.COMPLETE, 583 notes = "", 584 method = "size", 585 args = {} 586 ) 587 public void test_size() { 588 // Test for method int java.util.LinkedHashMap.size() 589 assertTrue("Returned incorrect size", 590 hm.size() == (objArray.length + 2)); 591 } 592 593 /** 594 * @tests java.util.LinkedHashMap#entrySet() 595 */ 596 @TestTargetNew( 597 level = TestLevel.COMPLETE, 598 notes = "", 599 method = "entrySet", 600 args = {} 601 ) 602 public void test_ordered_entrySet() { 603 int i; 604 int sz = 100; 605 LinkedHashMap lhm = new LinkedHashMap(); 606 for (i = 0; i < sz; i++) { 607 Integer ii = new Integer(i); 608 lhm.put(ii, ii.toString()); 609 } 610 611 Set s1 = lhm.entrySet(); 612 Iterator it1 = s1.iterator(); 613 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 614 for (i = 0; it1.hasNext(); i++) { 615 Map.Entry m = (Map.Entry) it1.next(); 616 Integer jj = (Integer) m.getKey(); 617 assertTrue("Returned incorrect entry set 1", jj.intValue() == i); 618 } 619 620 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 621 for (i = 0; i < sz; i++) { 622 Integer ii = new Integer(i); 623 lruhm.put(ii, ii.toString()); 624 } 625 626 Set s3 = lruhm.entrySet(); 627 Iterator it3 = s3.iterator(); 628 assertTrue("Returned set of incorrect size 2", lruhm.size() == s3 629 .size()); 630 for (i = 0; i < sz && it3.hasNext(); i++) { 631 Map.Entry m = (Map.Entry) it3.next(); 632 Integer jj = (Integer) m.getKey(); 633 assertTrue("Returned incorrect entry set 2", jj.intValue() == i); 634 } 635 636 /* fetch the even numbered entries to affect traversal order */ 637 int p = 0; 638 for (i = 0; i < sz; i += 2) { 639 String ii = (String) lruhm.get(new Integer(i)); 640 p = p + Integer.parseInt(ii); 641 } 642 assertEquals("invalid sum of even numbers", 2450, p); 643 644 Set s2 = lruhm.entrySet(); 645 Iterator it2 = s2.iterator(); 646 assertTrue("Returned set of incorrect size 3", lruhm.size() == s2 647 .size()); 648 for (i = 1; i < sz && it2.hasNext(); i += 2) { 649 Map.Entry m = (Map.Entry) it2.next(); 650 Integer jj = (Integer) m.getKey(); 651 assertTrue("Returned incorrect entry set 3", jj.intValue() == i); 652 } 653 for (i = 0; i < sz && it2.hasNext(); i += 2) { 654 Map.Entry m = (Map.Entry) it2.next(); 655 Integer jj = (Integer) m.getKey(); 656 assertTrue("Returned incorrect entry set 4", jj.intValue() == i); 657 } 658 assertTrue("Entries left to iterate on", !it2.hasNext()); 659 } 660 661 /** 662 * @tests java.util.LinkedHashMap#keySet() 663 */ 664 @TestTargetNew( 665 level = TestLevel.COMPLETE, 666 notes = "", 667 method = "keySet", 668 args = {} 669 ) 670 public void test_ordered_keySet() { 671 int i; 672 int sz = 100; 673 LinkedHashMap lhm = new LinkedHashMap(); 674 for (i = 0; i < sz; i++) { 675 Integer ii = new Integer(i); 676 lhm.put(ii, ii.toString()); 677 } 678 679 Set s1 = lhm.keySet(); 680 Iterator it1 = s1.iterator(); 681 assertTrue("Returned set of incorrect size", lhm.size() == s1.size()); 682 for (i = 0; it1.hasNext(); i++) { 683 Integer jj = (Integer) it1.next(); 684 assertTrue("Returned incorrect entry set", jj.intValue() == i); 685 } 686 687 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 688 for (i = 0; i < sz; i++) { 689 Integer ii = new Integer(i); 690 lruhm.put(ii, ii.toString()); 691 } 692 693 Set s3 = lruhm.keySet(); 694 Iterator it3 = s3.iterator(); 695 assertTrue("Returned set of incorrect size", lruhm.size() == s3.size()); 696 for (i = 0; i < sz && it3.hasNext(); i++) { 697 Integer jj = (Integer) it3.next(); 698 assertTrue("Returned incorrect entry set", jj.intValue() == i); 699 } 700 701 /* fetch the even numbered entries to affect traversal order */ 702 int p = 0; 703 for (i = 0; i < sz; i += 2) { 704 String ii = (String) lruhm.get(new Integer(i)); 705 p = p + Integer.parseInt(ii); 706 } 707 assertEquals("invalid sum of even numbers", 2450, p); 708 709 Set s2 = lruhm.keySet(); 710 Iterator it2 = s2.iterator(); 711 assertTrue("Returned set of incorrect size", lruhm.size() == s2.size()); 712 for (i = 1; i < sz && it2.hasNext(); i += 2) { 713 Integer jj = (Integer) it2.next(); 714 assertTrue("Returned incorrect entry set", jj.intValue() == i); 715 } 716 for (i = 0; i < sz && it2.hasNext(); i += 2) { 717 Integer jj = (Integer) it2.next(); 718 assertTrue("Returned incorrect entry set", jj.intValue() == i); 719 } 720 assertTrue("Entries left to iterate on", !it2.hasNext()); 721 } 722 723 /** 724 * @tests java.util.LinkedHashMap#values() 725 */ 726 @TestTargetNew( 727 level = TestLevel.COMPLETE, 728 notes = "", 729 method = "values", 730 args = {} 731 ) 732 public void test_ordered_values() { 733 int i; 734 int sz = 100; 735 LinkedHashMap lhm = new LinkedHashMap(); 736 for (i = 0; i < sz; i++) { 737 Integer ii = new Integer(i); 738 lhm.put(ii, new Integer(i * 2)); 739 } 740 741 Collection s1 = lhm.values(); 742 Iterator it1 = s1.iterator(); 743 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 744 for (i = 0; it1.hasNext(); i++) { 745 Integer jj = (Integer) it1.next(); 746 assertTrue("Returned incorrect entry set 1", jj.intValue() == i * 2); 747 } 748 749 LinkedHashMap lruhm = new LinkedHashMap(200, .75f, true); 750 for (i = 0; i < sz; i++) { 751 Integer ii = new Integer(i); 752 lruhm.put(ii, new Integer(i * 2)); 753 } 754 755 Collection s3 = lruhm.values(); 756 Iterator it3 = s3.iterator(); 757 assertTrue("Returned set of incorrect size", lruhm.size() == s3.size()); 758 for (i = 0; i < sz && it3.hasNext(); i++) { 759 Integer jj = (Integer) it3.next(); 760 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 761 } 762 763 // fetch the even numbered entries to affect traversal order 764 int p = 0; 765 for (i = 0; i < sz; i += 2) { 766 Integer ii = (Integer) lruhm.get(new Integer(i)); 767 p = p + ii.intValue(); 768 } 769 assertTrue("invalid sum of even numbers", p == 2450 * 2); 770 771 Collection s2 = lruhm.values(); 772 Iterator it2 = s2.iterator(); 773 assertTrue("Returned set of incorrect size", lruhm.size() == s2.size()); 774 for (i = 1; i < sz && it2.hasNext(); i += 2) { 775 Integer jj = (Integer) it2.next(); 776 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 777 } 778 for (i = 0; i < sz && it2.hasNext(); i += 2) { 779 Integer jj = (Integer) it2.next(); 780 assertTrue("Returned incorrect entry set", jj.intValue() == i * 2); 781 } 782 assertTrue("Entries left to iterate on", !it2.hasNext()); 783 } 784 785 /** 786 * @tests java.util.LinkedHashMap#removeEldestEntry(java.util.Map$Entry) 787 */ 788 @TestTargetNew( 789 level = TestLevel.COMPLETE, 790 notes = "", 791 method = "removeEldestEntry", 792 args = {java.util.Map.Entry.class} 793 ) 794 public void test_remove_eldest() { 795 int i; 796 int sz = 10; 797 CacheMap lhm = new CacheMap(); 798 for (i = 0; i < sz; i++) { 799 Integer ii = new Integer(i); 800 lhm.put(ii, new Integer(i * 2)); 801 } 802 803 Collection s1 = lhm.values(); 804 Iterator it1 = s1.iterator(); 805 assertTrue("Returned set of incorrect size 1", lhm.size() == s1.size()); 806 for (i = 5; it1.hasNext(); i++) { 807 Integer jj = (Integer) it1.next(); 808 assertTrue("Returned incorrect entry set 1", jj.intValue() == i * 2); 809 } 810 assertTrue("Entries left in map", !it1.hasNext()); 811 } 812 813 /** 814 * Sets up the fixture, for example, open a network connection. This method 815 * is called before a test is executed. 816 */ 817 protected void setUp() { 818 objArray = new Object[hmSize]; 819 objArray2 = new Object[hmSize]; 820 for (int i = 0; i < objArray.length; i++) { 821 objArray[i] = new Integer(i); 822 objArray2[i] = objArray[i].toString(); 823 } 824 825 hm = new LinkedHashMap(); 826 for (int i = 0; i < objArray.length; i++) 827 hm.put(objArray2[i], objArray[i]); 828 hm.put("test", null); 829 hm.put(null, "test"); 830 } 831 832 /** 833 * Tears down the fixture, for example, close a network connection. This 834 * method is called after a test is executed. 835 */ 836 protected void tearDown() { 837 objArray = null; 838 objArray2 = null; 839 hm = null; 840 } 841} 842