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