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