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