1/* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to You under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package tests.api.java.util; 18 19import dalvik.annotation.AndroidOnly; 20 21import java.util.ArrayList; 22import java.util.Collection; 23import java.util.EnumMap; 24import java.util.HashMap; 25import java.util.Iterator; 26import java.util.Map; 27import java.util.NoSuchElementException; 28import java.util.Set; 29 30import org.apache.harmony.testframework.serialization.SerializationTest; 31 32import junit.framework.TestCase; 33 34public class EnumMapTest extends TestCase { 35 enum Size { 36 Small, Middle, Big {}; 37 } 38 39 enum Color { 40 Red, Green, Blue {}; 41 } 42 43 enum Empty { 44 //Empty 45 } 46 47 private static class MockEntry<K, V> implements Map.Entry<K, V> { 48 private K key; 49 50 private V value; 51 52 public MockEntry(K key, V value) { 53 this.key = key; 54 this.value = value; 55 } 56 57 @Override 58 public int hashCode() { 59 return (key == null ? 0 : key.hashCode()) 60 ^ (value == null ? 0 : value.hashCode()); 61 } 62 63 public K getKey() { 64 return key; 65 } 66 67 public V getValue() { 68 return value; 69 } 70 71 public V setValue(V object) { 72 V oldValue = value; 73 value = object; 74 return oldValue; 75 } 76 } 77 78 /** 79 * java.util.EnumMap#EnumMap(Class) 80 */ 81 @SuppressWarnings({ "unchecked", "boxing" }) 82 public void test_ConstructorLjava_lang_Class() { 83 try { 84 new EnumMap((Class) null); 85 fail("Expected NullPointerException"); 86 } catch (NullPointerException e) { 87 // Expected 88 } 89 90 91 try { 92 new EnumMap(Size.Big.getClass()); 93 fail("Expected NullPointerException"); 94 } catch (NullPointerException e) { 95 // Expected 96 } 97 98 try { 99 new EnumMap(Integer.class); 100 fail("Expected NullPointerException"); 101 } catch (NullPointerException e) { 102 // Expected 103 } 104 105 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 106 assertNull("Return non-null for non mapped key", enumColorMap.put( 107 Color.Green, 2)); 108 assertEquals("Get returned incorrect value for given key", 2, 109 enumColorMap.get(Color.Green)); 110 111 EnumMap enumEmptyMap = new EnumMap<Empty, Double>(Empty.class); 112 try { 113 enumEmptyMap.put(Color.Red, 2); 114 fail("Expected ClassCastException"); 115 } catch (ClassCastException e) { 116 // Expected 117 } 118 119 EnumMap enumSizeMap = new EnumMap(Size.class); 120 assertNull("Return non-null for non mapped key", enumSizeMap.put( 121 Size.Big, 2)); 122 assertEquals("Get returned incorrect value for given key", 2, 123 enumSizeMap.get(Size.Big)); 124 try { 125 enumSizeMap.put(Color.Red, 2); 126 fail("Expected ClassCastException"); 127 } catch (ClassCastException e) { 128 // Expected 129 } 130 131 enumSizeMap = new EnumMap(Size.Middle.getClass()); 132 assertNull("Return non-null for non mapped key", enumSizeMap.put( 133 Size.Small, 1)); 134 assertEquals("Get returned incorrect value for given key", 1, 135 enumSizeMap.get(Size.Small)); 136 try { 137 enumSizeMap.put(Color.Red, 2); 138 fail("Expected ClassCastException"); 139 } catch (ClassCastException e) { 140 // Expected 141 } 142 } 143 144 /** 145 * java.util.EnumMap#EnumMap(EnumMap) 146 */ 147 @SuppressWarnings({ "unchecked", "boxing" }) 148 public void test_ConstructorLjava_util_EnumMap() { 149 EnumMap enumMap; 150 EnumMap enumColorMap = null; 151 try { 152 enumMap = new EnumMap(enumColorMap); 153 fail("Expected NullPointerException"); 154 } catch (NullPointerException e) { 155 // Expected 156 } 157 158 enumColorMap = new EnumMap<Color, Double>(Color.class); 159 Double double1 = new Double(1); 160 enumColorMap.put(Color.Green, 2); 161 enumColorMap.put(Color.Blue, double1); 162 163 enumMap = new EnumMap(enumColorMap); 164 assertEquals("Constructor fails", 2, enumMap.get(Color.Green)); 165 assertSame("Constructor fails", double1, enumMap.get(Color.Blue)); 166 assertNull("Constructor fails", enumMap.get(Color.Red)); 167 enumMap.put(Color.Red, 1); 168 assertEquals("Wrong value", 1, enumMap.get(Color.Red)); 169 170 try { 171 enumMap.put(Size.Middle, 2); 172 fail("Expected ClassCastException"); 173 } catch (ClassCastException e) { 174 // Expected 175 } 176 } 177 178 /** 179 * java.util.EnumMap#EnumMap(Map) 180 */ 181 @SuppressWarnings({ "unchecked", "boxing" }) 182 public void test_ConstructorLjava_util_Map() { 183 EnumMap enumMap; 184 Map enumColorMap = null; 185 try { 186 enumMap = new EnumMap(enumColorMap); 187 fail("Expected NullPointerException"); 188 } catch (NullPointerException e) { 189 // Expected 190 } 191 enumColorMap = new EnumMap<Color, Double>(Color.class); 192 enumMap = new EnumMap(enumColorMap); 193 enumColorMap.put(Color.Blue, 3); 194 enumMap = new EnumMap(enumColorMap); 195 196 HashMap hashColorMap = null; 197 try { 198 enumMap = new EnumMap(hashColorMap); 199 fail("Expected NullPointerException"); 200 } catch (NullPointerException e) { 201 // Expected 202 } 203 204 hashColorMap = new HashMap(); 205 try { 206 enumMap = new EnumMap(hashColorMap); 207 fail("Expected IllegalArgumentException"); 208 } catch (IllegalArgumentException e) { 209 // Expected 210 } 211 212 hashColorMap.put(Color.Green, 2); 213 enumMap = new EnumMap(hashColorMap); 214 assertEquals("Constructor fails", 2, enumMap.get(Color.Green)); 215 assertNull("Constructor fails", enumMap.get(Color.Red)); 216 enumMap.put(Color.Red, 1); 217 assertEquals("Wrong value", 1, enumMap.get(Color.Red)); 218 hashColorMap.put(Size.Big, 3); 219 try { 220 enumMap = new EnumMap(hashColorMap); 221 fail("Expected ClassCastException"); 222 } catch (ClassCastException e) { 223 // Expected 224 } 225 226 hashColorMap = new HashMap(); 227 hashColorMap.put(new Integer(1), 1); 228 try { 229 enumMap = new EnumMap(hashColorMap); 230 fail("Expected ClassCastException"); 231 } catch (ClassCastException e) { 232 // Expected 233 } 234 } 235 236 /** 237 * java.util.EnumMap#clear() 238 */ 239 @SuppressWarnings({ "unchecked", "boxing" }) 240 public void test_clear() { 241 EnumMap enumSizeMap = new EnumMap(Size.class); 242 enumSizeMap.put(Size.Small, 1); 243 enumSizeMap.clear(); 244 assertNull("Failed to clear all elements", enumSizeMap.get(Size.Small)); 245 } 246 247 /** 248 * java.util.EnumMap#containsKey(Object) 249 */ 250 @SuppressWarnings( { "unchecked", "boxing" }) 251 public void test_containsKeyLjava_lang_Object() { 252 EnumMap enumSizeMap = new EnumMap(Size.class); 253 assertFalse("Returned true for uncontained key", enumSizeMap 254 .containsKey(Size.Small)); 255 enumSizeMap.put(Size.Small, 1); 256 assertTrue("Returned false for contained key", enumSizeMap 257 .containsKey(Size.Small)); 258 259 enumSizeMap.put(Size.Big, null); 260 assertTrue("Returned false for contained key", enumSizeMap 261 .containsKey(Size.Big)); 262 263 assertFalse("Returned true for uncontained key", enumSizeMap 264 .containsKey(Color.Red)); 265 assertFalse("Returned true for uncontained key", enumSizeMap 266 .containsKey(new Integer("3"))); 267 assertFalse("Returned true for uncontained key", enumSizeMap 268 .containsKey(null)); 269 } 270 271 /** 272 * java.util.EnumMap#clone() 273 */ 274 @SuppressWarnings( { "unchecked", "boxing" }) 275 public void test_clone() { 276 EnumMap enumSizeMap = new EnumMap(Size.class); 277 Integer integer = new Integer("3"); 278 enumSizeMap.put(Size.Small, integer); 279 EnumMap enumSizeMapClone = enumSizeMap.clone(); 280 assertNotSame("Should not be same", enumSizeMap, enumSizeMapClone); 281 assertEquals("Clone answered unequal EnumMap", enumSizeMap, 282 enumSizeMapClone); 283 284 assertSame("Should be same", enumSizeMap.get(Size.Small), 285 enumSizeMapClone.get(Size.Small)); 286 assertSame("Clone is not shallow clone", integer, enumSizeMapClone 287 .get(Size.Small)); 288 enumSizeMap.remove(Size.Small); 289 assertSame("Clone is not shallow clone", integer, enumSizeMapClone 290 .get(Size.Small)); 291 } 292 293 /** 294 * java.util.EnumMap#containsValue(Object) 295 */ 296 @SuppressWarnings( { "unchecked", "boxing" }) 297 public void test_containsValueLjava_lang_Object() { 298 EnumMap enumSizeMap = new EnumMap(Size.class); 299 Double double1 = new Double(3); 300 Double double2 = new Double(3); 301 302 assertFalse("Returned true for uncontained value", enumSizeMap 303 .containsValue(double1)); 304 enumSizeMap.put(Size.Middle, 2); 305 enumSizeMap.put(Size.Small, double1); 306 assertTrue("Returned false for contained value", enumSizeMap 307 .containsValue(double1)); 308 assertTrue("Returned false for contained value", enumSizeMap 309 .containsValue(double2)); 310 assertTrue("Returned false for contained value", enumSizeMap 311 .containsValue(2)); 312 assertFalse("Returned true for uncontained value", enumSizeMap 313 .containsValue(1)); 314 315 assertFalse("Returned true for uncontained value", enumSizeMap 316 .containsValue(null)); 317 enumSizeMap.put(Size.Big, null); 318 assertTrue("Returned false for contained value", enumSizeMap 319 .containsValue(null)); 320 } 321 322 /** 323 * java.util.EnumMap#entrySet() 324 */ 325 @AndroidOnly("Map.Entry is indirectly modified on RI when Iterator.next() is invoked") 326 @SuppressWarnings({ "unchecked", "boxing" }) 327 public void test_entrySet() { 328 EnumMap enumSizeMap = new EnumMap(Size.class); 329 enumSizeMap.put(Size.Middle, 1); 330 enumSizeMap.put(Size.Big, null); 331 MockEntry mockEntry = new MockEntry(Size.Middle, 1); 332 Set set = enumSizeMap.entrySet(); 333 334 Set set1 = enumSizeMap.entrySet(); 335 assertSame("Should be same", set1, set); 336 try { 337 set.add(mockEntry); 338 fail("Should throw UnsupportedOperationException"); 339 } catch (UnsupportedOperationException e) { 340 // Expected 341 } 342 343 assertTrue("Returned false for contained object", set 344 .contains(mockEntry)); 345 mockEntry = new MockEntry(Size.Middle, null); 346 assertFalse("Returned true for uncontained object", set 347 .contains(mockEntry)); 348 assertFalse("Returned true for uncontained object", set 349 .contains(Size.Small)); 350 mockEntry = new MockEntry(new Integer(1), 1); 351 assertFalse("Returned true for uncontained object", set 352 .contains(mockEntry)); 353 assertFalse("Returned true for uncontained object", set 354 .contains(new Integer(1))); 355 356 mockEntry = new MockEntry(Size.Big, null); 357 assertTrue("Returned false for contained object", set 358 .contains(mockEntry)); 359 assertTrue("Returned false when the object can be removed", set 360 .remove(mockEntry)); 361 assertFalse("Returned true for uncontained object", set 362 .contains(mockEntry)); 363 assertFalse("Returned true when the object can not be removed", set 364 .remove(mockEntry)); 365 mockEntry = new MockEntry(new Integer(1), 1); 366 assertFalse("Returned true when the object can not be removed", set 367 .remove(mockEntry)); 368 assertFalse("Returned true when the object can not be removed", set 369 .remove(new Integer(1))); 370 371 // The set is backed by the map so changes to one are reflected by the 372 // other. 373 enumSizeMap.put(Size.Big, 3); 374 mockEntry = new MockEntry(Size.Big, 3); 375 assertTrue("Returned false for contained object", set 376 .contains(mockEntry)); 377 enumSizeMap.remove(Size.Big); 378 assertFalse("Returned true for uncontained object", set 379 .contains(mockEntry)); 380 381 assertEquals("Wrong size", 1, set.size()); 382 set.clear(); 383 assertEquals("Wrong size", 0, set.size()); 384 385 enumSizeMap = new EnumMap(Size.class); 386 enumSizeMap.put(Size.Middle, 1); 387 enumSizeMap.put(Size.Big, null); 388 set = enumSizeMap.entrySet(); 389 Collection c = new ArrayList(); 390 c.add(new MockEntry(Size.Middle, 1)); 391 assertTrue("Return wrong value", set.containsAll(c)); 392 assertTrue("Remove does not success", set.removeAll(c)); 393 394 enumSizeMap.put(Size.Middle, 1); 395 c.add(new MockEntry(Size.Big, 3)); 396 assertTrue("Remove does not success", set.removeAll(c)); 397 assertFalse("Should return false", set.removeAll(c)); 398 assertEquals("Wrong size", 1, set.size()); 399 400 enumSizeMap = new EnumMap(Size.class); 401 enumSizeMap.put(Size.Middle, 1); 402 enumSizeMap.put(Size.Big, null); 403 set = enumSizeMap.entrySet(); 404 c = new ArrayList(); 405 c.add(new MockEntry(Size.Middle, 1)); 406 c.add(new MockEntry(Size.Big, 3)); 407 408 assertTrue("Retain does not success", set.retainAll(c)); 409 assertEquals("Wrong size", 1, set.size()); 410 assertFalse("Should return false", set.retainAll(c)); 411 412 enumSizeMap = new EnumMap(Size.class); 413 enumSizeMap.put(Size.Middle, 1); 414 enumSizeMap.put(Size.Big, null); 415 416 set = enumSizeMap.entrySet(); 417 Object[] array = set.toArray(); 418 assertEquals("Wrong length", 2, array.length); 419 Map.Entry entry = (Map.Entry) array[0]; 420 assertEquals("Wrong key", Size.Middle, entry.getKey()); 421 assertEquals("Wrong value", 1, entry.getValue()); 422 423 Object[] array1 = new Object[10]; 424 array1 = set.toArray(); 425 assertEquals("Wrong length", 2, array1.length); 426 entry = (Map.Entry) array[0]; 427 assertEquals("Wrong key", Size.Middle, entry.getKey()); 428 assertEquals("Wrong value", 1, entry.getValue()); 429 430 array1 = new Object[10]; 431 array1 = set.toArray(array1); 432 assertEquals("Wrong length", 10, array1.length); 433 entry = (Map.Entry) array[1]; 434 assertEquals("Wrong key", Size.Big, entry.getKey()); 435 assertNull("Should be null", array1[2]); 436 437 set = enumSizeMap.entrySet(); 438 Integer integer = new Integer("1"); 439 assertFalse("Returned true when the object can not be removed", set 440 .remove(integer)); 441 assertTrue("Returned false when the object can be removed", set 442 .remove(entry)); 443 444 enumSizeMap = new EnumMap(Size.class); 445 enumSizeMap.put(Size.Middle, 1); 446 enumSizeMap.put(Size.Big, null); 447 set = enumSizeMap.entrySet(); 448 Iterator iter = set.iterator(); 449 entry = (Map.Entry) iter.next(); 450 assertTrue("Returned false for contained object", set.contains(entry)); 451 mockEntry = new MockEntry(Size.Middle, 2); 452 assertFalse("Returned true for uncontained object", set 453 .contains(mockEntry)); 454 mockEntry = new MockEntry(new Integer(2), 2); 455 assertFalse("Returned true for uncontained object", set 456 .contains(mockEntry)); 457 entry = (Map.Entry) iter.next(); 458 assertTrue("Returned false for contained object", set.contains(entry)); 459 460 enumSizeMap.put(Size.Middle, 1); 461 enumSizeMap.remove(Size.Big); 462 mockEntry = new MockEntry(Size.Big, null); 463 assertEquals("Wrong size", 1, set.size()); 464 assertFalse("Returned true for uncontained object", set.contains(mockEntry)); 465 enumSizeMap.put(Size.Big, 2); 466 mockEntry = new MockEntry(Size.Big, 2); 467 assertTrue("Returned false for contained object", set 468 .contains(mockEntry)); 469 470 iter.remove(); 471 try { 472 iter.remove(); 473 fail("Should throw IllegalStateException"); 474 } catch (IllegalStateException e) { 475 // Expected 476 } 477 try { 478 entry.setValue(2); 479 fail("Should throw IllegalStateException"); 480 } catch (IllegalStateException e) { 481 // Expected 482 } 483 try { 484 set.contains(entry); 485 fail("Should throw IllegalStateException"); 486 } catch (IllegalStateException e) { 487 // Expected 488 } 489 490 enumSizeMap = new EnumMap(Size.class); 491 enumSizeMap.put(Size.Middle, 1); 492 enumSizeMap.put(Size.Big, null); 493 set = enumSizeMap.entrySet(); 494 iter = set.iterator(); 495 entry = (Map.Entry) iter.next(); 496 assertEquals("Wrong key", Size.Middle, entry.getKey()); 497 498 assertTrue("Returned false for contained object", set.contains(entry)); 499 enumSizeMap.put(Size.Middle, 3); 500 assertTrue("Returned false for contained object", set.contains(entry)); 501 entry.setValue(2); 502 assertTrue("Returned false for contained object", set.contains(entry)); 503 assertFalse("Returned true for uncontained object", set 504 .remove(new Integer(1))); 505 506 iter.next(); 507 assertEquals("Wrong key", Size.Middle, entry.getKey()); 508 set.clear(); 509 assertEquals("Wrong size", 0, set.size()); 510 511 enumSizeMap = new EnumMap(Size.class); 512 enumSizeMap.put(Size.Middle, 1); 513 enumSizeMap.put(Size.Big, null); 514 set = enumSizeMap.entrySet(); 515 iter = set.iterator(); 516 mockEntry = new MockEntry(Size.Middle, 1); 517 518 assertFalse("Wrong result", entry.equals(mockEntry)); 519 try { 520 iter.remove(); 521 fail("Should throw IllegalStateException"); 522 } catch (IllegalStateException e) { 523 // Expected 524 } 525 entry = (Map.Entry) iter.next(); 526 assertEquals("Wrong key", Size.Middle, entry.getKey()); 527 assertTrue("Should return true", entry.equals(mockEntry)); 528 assertEquals("Should be equal", mockEntry.hashCode(), entry.hashCode()); 529 mockEntry = new MockEntry(Size.Big, 1); 530 assertFalse("Wrong result", entry.equals(mockEntry)); 531 532 entry = (Map.Entry) iter.next(); 533 assertFalse("Wrong result", entry.equals(mockEntry)); 534 assertEquals("Wrong key", Size.Big, entry.getKey()); 535 iter.remove(); 536 assertFalse("Wrong result", entry.equals(mockEntry)); 537 assertEquals("Wrong size", 1, set.size()); 538 try { 539 iter.remove(); 540 fail("Should throw IllegalStateException"); 541 } catch (IllegalStateException e) { 542 // Expected 543 } 544 try { 545 iter.next(); 546 fail("Should throw NoSuchElementException"); 547 } catch (NoSuchElementException e) { 548 // Expected 549 } 550 } 551 552 /** 553 * java.util.EnumMap#equals(Object) 554 */ 555 @SuppressWarnings( { "unchecked", "boxing" }) 556 public void test_equalsLjava_lang_Object() { 557 EnumMap enumMap = new EnumMap(Size.class); 558 enumMap.put(Size.Small, 1); 559 560 EnumMap enumSizeMap = new EnumMap(Size.class); 561 assertFalse("Returned true for unequal EnumMap", enumSizeMap 562 .equals(enumMap)); 563 enumSizeMap.put(Size.Small, 1); 564 assertTrue("Returned false for equal EnumMap", enumSizeMap 565 .equals(enumMap)); 566 enumSizeMap.put(Size.Big, null); 567 assertFalse("Returned true for unequal EnumMap", enumSizeMap 568 .equals(enumMap)); 569 570 enumMap.put(Size.Middle, null); 571 assertFalse("Returned true for unequal EnumMap", enumSizeMap 572 .equals(enumMap)); 573 enumMap.remove(Size.Middle); 574 enumMap.put(Size.Big, 3); 575 assertFalse("Returned true for unequal EnumMap", enumSizeMap 576 .equals(enumMap)); 577 enumMap.put(Size.Big, null); 578 assertTrue("Returned false for equal EnumMap", enumSizeMap 579 .equals(enumMap)); 580 581 HashMap hashMap = new HashMap(); 582 hashMap.put(Size.Small, 1); 583 assertFalse("Returned true for unequal EnumMap", hashMap 584 .equals(enumMap)); 585 hashMap.put(Size.Big, null); 586 assertTrue("Returned false for equal EnumMap", enumMap.equals(hashMap)); 587 588 assertFalse("Should return false", enumSizeMap 589 .equals(new Integer(1))); 590 } 591 592 /** 593 * java.util.EnumMap#keySet() 594 */ 595 @SuppressWarnings( { "unchecked", "boxing" }) 596 public void test_keySet() { 597 EnumMap enumSizeMap = new EnumMap(Size.class); 598 enumSizeMap.put(Size.Middle, 2); 599 enumSizeMap.put(Size.Big, null); 600 Set set = enumSizeMap.keySet(); 601 602 Set set1 = enumSizeMap.keySet(); 603 assertSame("Should be same", set1, set); 604 try { 605 set.add(Size.Big); 606 fail("Should throw UnsupportedOperationException"); 607 } catch (UnsupportedOperationException e) { 608 // Expected 609 } 610 611 assertTrue("Returned false for contained object", set 612 .contains(Size.Middle)); 613 assertTrue("Returned false for contained object", set 614 .contains(Size.Big)); 615 assertFalse("Returned true for uncontained object", set 616 .contains(Size.Small)); 617 assertFalse("Returned true for uncontained object", set 618 .contains(new Integer(1))); 619 assertTrue("Returned false when the object can be removed", set 620 .remove(Size.Big)); 621 assertFalse("Returned true for uncontained object", set 622 .contains(Size.Big)); 623 assertFalse("Returned true when the object can not be removed", set 624 .remove(Size.Big)); 625 assertFalse("Returned true when the object can not be removed", set 626 .remove(new Integer(1))); 627 628 // The set is backed by the map so changes to one are reflected by the 629 // other. 630 enumSizeMap.put(Size.Big, 3); 631 assertTrue("Returned false for contained object", set 632 .contains(Size.Big)); 633 enumSizeMap.remove(Size.Big); 634 assertFalse("Returned true for uncontained object", set 635 .contains(Size.Big)); 636 637 assertEquals("Wrong size", 1, set.size()); 638 set.clear(); 639 assertEquals("Wrong size", 0, set.size()); 640 641 enumSizeMap = new EnumMap(Size.class); 642 enumSizeMap.put(Size.Middle, 1); 643 enumSizeMap.put(Size.Big, null); 644 set = enumSizeMap.keySet(); 645 Collection c = new ArrayList(); 646 c.add(Size.Big); 647 assertTrue("Should return true", set.containsAll(c)); 648 c.add(Size.Small); 649 assertFalse("Should return false", set.containsAll(c)); 650 assertTrue("Should return true", set.removeAll(c)); 651 assertEquals("Wrong size", 1, set.size()); 652 assertFalse("Should return false", set.removeAll(c)); 653 assertEquals("Wrong size", 1, set.size()); 654 try { 655 set.addAll(c); 656 fail("Should throw UnsupportedOperationException"); 657 } catch (UnsupportedOperationException e) { 658 // Expected 659 } 660 661 enumSizeMap.put(Size.Big, null); 662 assertEquals("Wrong size", 2, set.size()); 663 assertTrue("Should return true", set.retainAll(c)); 664 assertEquals("Wrong size", 1, set.size()); 665 assertFalse("Should return false", set.retainAll(c)); 666 assertEquals(1, set.size()); 667 Object[] array = set.toArray(); 668 assertEquals("Wrong length", 1, array.length); 669 assertEquals("Wrong key", Size.Big, array[0]); 670 671 enumSizeMap = new EnumMap(Size.class); 672 enumSizeMap.put(Size.Middle, 1); 673 enumSizeMap.put(Size.Big, null); 674 set = enumSizeMap.keySet(); 675 c = new ArrayList(); 676 c.add(Color.Blue); 677 assertFalse("Should return false", set.remove(c)); 678 assertEquals("Wrong size", 2, set.size()); 679 assertTrue("Should return true", set.retainAll(c)); 680 assertEquals("Wrong size", 0, set.size()); 681 682 enumSizeMap = new EnumMap(Size.class); 683 enumSizeMap.put(Size.Middle, 1); 684 enumSizeMap.put(Size.Big, null); 685 set = enumSizeMap.keySet(); 686 687 Iterator iter = set.iterator(); 688 Enum enumKey = (Enum) iter.next(); 689 assertTrue("Returned false for contained object", set.contains(enumKey)); 690 enumKey = (Enum) iter.next(); 691 assertTrue("Returned false for contained object", set.contains(enumKey)); 692 693 enumSizeMap.remove(Size.Big); 694 assertFalse("Returned true for uncontained object", set 695 .contains(enumKey)); 696 iter.remove(); 697 try { 698 iter.remove(); 699 fail("Should throw IllegalStateException"); 700 } catch (IllegalStateException e) { 701 // Expected 702 } 703 assertFalse("Returned true for uncontained object", set 704 .contains(enumKey)); 705 706 iter = set.iterator(); 707 enumKey = (Enum) iter.next(); 708 assertTrue("Returned false for contained object", set.contains(enumKey)); 709 enumSizeMap.put(Size.Middle, 3); 710 assertTrue("Returned false for contained object", set.contains(enumKey)); 711 712 enumSizeMap = new EnumMap(Size.class); 713 enumSizeMap.put(Size.Middle, 1); 714 enumSizeMap.put(Size.Big, null); 715 set = enumSizeMap.keySet(); 716 iter = set.iterator(); 717 try { 718 iter.remove(); 719 fail("Should throw IllegalStateException"); 720 } catch (IllegalStateException e) { 721 // Expected 722 } 723 enumKey = (Enum) iter.next(); 724 assertEquals("Wrong key", Size.Middle, enumKey); 725 assertSame("Wrong key", Size.Middle, enumKey); 726 assertFalse("Returned true for unequal object", iter.equals(enumKey)); 727 iter.remove(); 728 assertFalse("Returned true for uncontained object", set 729 .contains(enumKey)); 730 try { 731 iter.remove(); 732 fail("Should throw IllegalStateException"); 733 } catch (IllegalStateException e) { 734 // Expected 735 } 736 737 assertEquals("Wrong size", 1, set.size()); 738 enumKey = (Enum) iter.next(); 739 assertEquals("Wrong key", Size.Big, enumKey); 740 iter.remove(); 741 try { 742 iter.next(); 743 fail("Should throw NoSuchElementException"); 744 } catch (NoSuchElementException e) { 745 // Expected 746 } 747 } 748 749 /** 750 * java.util.EnumMap#get(Object) 751 */ 752 @SuppressWarnings({ "unchecked", "boxing" }) 753 public void test_getLjava_lang_Object() { 754 EnumMap enumSizeMap = new EnumMap(Size.class); 755 assertNull("Get returned non-null for non mapped key", enumSizeMap 756 .get(Size.Big)); 757 enumSizeMap.put(Size.Big, 1); 758 assertEquals("Get returned incorrect value for given key", 1, 759 enumSizeMap.get(Size.Big)); 760 761 assertNull("Get returned non-null for non mapped key", enumSizeMap 762 .get(Size.Small)); 763 assertNull("Get returned non-null for non existent key", enumSizeMap 764 .get(Color.Red)); 765 assertNull("Get returned non-null for non existent key", enumSizeMap 766 .get(new Integer(1))); 767 assertNull("Get returned non-null for non existent key", enumSizeMap 768 .get(null)); 769 770 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 771 assertNull("Get returned non-null for non mapped key", enumColorMap 772 .get(Color.Green)); 773 enumColorMap.put(Color.Green, 2); 774 assertEquals("Get returned incorrect value for given key", 2, 775 enumColorMap.get(Color.Green)); 776 assertNull("Get returned non-null for non mapped key", enumColorMap 777 .get(Color.Blue)); 778 779 enumColorMap.put(Color.Green, new Double(4)); 780 assertEquals("Get returned incorrect value for given key", 781 new Double(4), enumColorMap.get(Color.Green)); 782 enumColorMap.put(Color.Green, new Integer("3")); 783 assertEquals("Get returned incorrect value for given key", new Integer( 784 "3"), enumColorMap.get(Color.Green)); 785 enumColorMap.put(Color.Green, null); 786 assertNull("Can not handle null value", enumColorMap.get(Color.Green)); 787 Float f = new Float("3.4"); 788 enumColorMap.put(Color.Green, f); 789 assertSame("Get returned incorrect value for given key", f, 790 enumColorMap.get(Color.Green)); 791 } 792 793 /** 794 * java.util.EnumMap#put(Object,Object) 795 */ 796 public void test_putLjava_lang_ObjectLjava_lang_Object() { 797 EnumMap enumSizeMap = new EnumMap(Size.class); 798 try { 799 enumSizeMap.put(Color.Red, 2); 800 fail("Expected ClassCastException"); 801 } catch (ClassCastException e) { 802 // Expected 803 } 804 assertNull("Return non-null for non mapped key", enumSizeMap.put( 805 Size.Small, 1)); 806 807 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 808 try { 809 enumColorMap.put(Size.Big, 2); 810 fail("Expected ClassCastException"); 811 } catch (ClassCastException e) { 812 // Expected 813 } 814 try { 815 enumColorMap.put(null, 2); 816 fail("Expected NullPointerException"); 817 } catch (NullPointerException e) { 818 // Expected 819 } 820 assertNull("Return non-null for non mapped key", enumColorMap.put( 821 Color.Green, 2)); 822 assertEquals("Return wrong value", 2, enumColorMap.put(Color.Green, 823 new Double(4))); 824 assertEquals("Return wrong value", new Double(4), enumColorMap.put( 825 Color.Green, new Integer("3"))); 826 assertEquals("Return wrong value", new Integer("3"), enumColorMap.put( 827 Color.Green, null)); 828 Float f = new Float("3.4"); 829 assertNull("Return non-null for non mapped key", enumColorMap.put( 830 Color.Green, f)); 831 assertNull("Return non-null for non mapped key", enumColorMap.put( 832 Color.Blue, 2)); 833 assertEquals("Return wrong value", 2, enumColorMap.put(Color.Blue, 834 new Double(4))); 835 } 836 837 /** 838 * java.util.EnumMap#putAll(Map) 839 */ 840 @SuppressWarnings({ "unchecked", "boxing" }) 841 public void test_putAllLjava_util_Map() { 842 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 843 enumColorMap.put(Color.Green, 2); 844 845 EnumMap enumSizeMap = new EnumMap(Size.class); 846 enumColorMap.putAll(enumSizeMap); 847 848 enumSizeMap.put(Size.Big, 1); 849 try { 850 enumColorMap.putAll(enumSizeMap); 851 fail("Expected ClassCastException"); 852 } catch (ClassCastException e) { 853 // Expected 854 } 855 856 EnumMap enumColorMap1 = new EnumMap<Color, Double>(Color.class); 857 enumColorMap1.put(Color.Blue, 3); 858 enumColorMap.putAll(enumColorMap1); 859 assertEquals("Get returned incorrect value for given key", 3, 860 enumColorMap.get(Color.Blue)); 861 assertEquals("Wrong Size", 2, enumColorMap.size()); 862 863 enumColorMap = new EnumMap<Color, Double>(Color.class); 864 865 HashMap hashColorMap = null; 866 try { 867 enumColorMap.putAll(hashColorMap); 868 fail("Expected NullPointerException"); 869 } catch (NullPointerException e) { 870 // Expected 871 } 872 873 hashColorMap = new HashMap(); 874 enumColorMap.putAll(hashColorMap); 875 876 hashColorMap.put(Color.Green, 2); 877 enumColorMap.putAll(hashColorMap); 878 assertEquals("Get returned incorrect value for given key", 2, 879 enumColorMap.get(Color.Green)); 880 assertNull("Get returned non-null for non mapped key", enumColorMap 881 .get(Color.Red)); 882 hashColorMap.put(Color.Red, new Integer(1)); 883 enumColorMap.putAll(hashColorMap); 884 assertEquals("Get returned incorrect value for given key", new Integer( 885 2), enumColorMap.get(Color.Green)); 886 hashColorMap.put(Size.Big, 3); 887 try { 888 enumColorMap.putAll(hashColorMap); 889 fail("Expected ClassCastException"); 890 } catch (ClassCastException e) { 891 // Expected 892 } 893 894 hashColorMap = new HashMap(); 895 hashColorMap.put(new Integer(1), 1); 896 try { 897 enumColorMap.putAll(hashColorMap); 898 fail("Expected ClassCastException"); 899 } catch (ClassCastException e) { 900 // Expected 901 } 902 } 903 904 /** 905 * java.util.EnumMap#remove(Object) 906 */ 907 @SuppressWarnings({ "unchecked", "boxing" }) 908 public void test_removeLjava_lang_Object() { 909 EnumMap enumSizeMap = new EnumMap(Size.class); 910 assertNull("Remove of non-mapped key returned non-null", enumSizeMap 911 .remove(Size.Big)); 912 enumSizeMap.put(Size.Big, 3); 913 enumSizeMap.put(Size.Middle, 2); 914 915 assertNull("Get returned non-null for non mapped key", enumSizeMap 916 .get(Size.Small)); 917 assertEquals("Remove returned incorrect value", 3, enumSizeMap 918 .remove(Size.Big)); 919 assertNull("Get returned non-null for non mapped key", enumSizeMap 920 .get(Size.Big)); 921 assertNull("Remove of non-mapped key returned non-null", enumSizeMap 922 .remove(Size.Big)); 923 assertNull("Remove of non-existent key returned non-null", enumSizeMap 924 .remove(Color.Red)); 925 assertNull("Remove of non-existent key returned non-null", enumSizeMap 926 .remove(new Double(4))); 927 assertNull("Remove of non-existent key returned non-null", enumSizeMap 928 .remove(null)); 929 930 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 931 assertNull("Get returned non-null for non mapped key", enumColorMap 932 .get(Color.Green)); 933 enumColorMap.put(Color.Green, new Double(4)); 934 assertEquals("Remove returned incorrect value", new Double(4), 935 enumColorMap.remove(Color.Green)); 936 assertNull("Get returned non-null for non mapped key", enumColorMap 937 .get(Color.Green)); 938 enumColorMap.put(Color.Green, null); 939 assertNull("Can not handle null value", enumColorMap 940 .remove(Color.Green)); 941 assertNull("Get returned non-null for non mapped key", enumColorMap 942 .get(Color.Green)); 943 } 944 945 /** 946 * java.util.EnumMap#size() 947 */ 948 @SuppressWarnings({ "unchecked", "boxing" }) 949 public void test_size() { 950 EnumMap enumSizeMap = new EnumMap(Size.class); 951 assertEquals("Wrong size", 0, enumSizeMap.size()); 952 enumSizeMap.put(Size.Small, 1); 953 assertEquals("Wrong size", 1, enumSizeMap.size()); 954 enumSizeMap.put(Size.Small, 0); 955 assertEquals("Wrong size", 1, enumSizeMap.size()); 956 try { 957 enumSizeMap.put(Color.Red, 2); 958 fail("Expected ClassCastException"); 959 } catch (ClassCastException e) { 960 // Expected 961 } 962 assertEquals("Wrong size", 1, enumSizeMap.size()); 963 964 enumSizeMap.put(Size.Middle, null); 965 assertEquals("Wrong size", 2, enumSizeMap.size()); 966 enumSizeMap.remove(Size.Big); 967 assertEquals("Wrong size", 2, enumSizeMap.size()); 968 enumSizeMap.remove(Size.Middle); 969 assertEquals("Wrong size", 1, enumSizeMap.size()); 970 enumSizeMap.remove(Color.Green); 971 assertEquals("Wrong size", 1, enumSizeMap.size()); 972 973 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 974 enumColorMap.put(Color.Green, 2); 975 assertEquals("Wrong size", 1, enumColorMap.size()); 976 enumColorMap.remove(Color.Green); 977 assertEquals("Wrong size", 0, enumColorMap.size()); 978 979 EnumMap enumEmptyMap = new EnumMap<Empty, Double>(Empty.class); 980 assertEquals("Wrong size", 0, enumEmptyMap.size()); 981 } 982 983 /** 984 * java.util.EnumMap#values() 985 */ 986 @SuppressWarnings( { "unchecked", "boxing" }) 987 public void test_values() { 988 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 989 enumColorMap.put(Color.Red, 1); 990 enumColorMap.put(Color.Blue, null); 991 Collection collection = enumColorMap.values(); 992 993 Collection collection1 = enumColorMap.values(); 994 assertSame("Should be same", collection1, collection); 995 try { 996 collection.add(new Integer(1)); 997 fail("Should throw UnsupportedOperationException"); 998 } catch (UnsupportedOperationException e) { 999 // Expected 1000 } 1001 1002 assertTrue("Returned false for contained object", collection 1003 .contains(1)); 1004 assertTrue("Returned false for contained object", collection 1005 .contains(null)); 1006 assertFalse("Returned true for uncontained object", collection 1007 .contains(2)); 1008 1009 assertTrue("Returned false when the object can be removed", collection 1010 .remove(null)); 1011 assertFalse("Returned true for uncontained object", collection 1012 .contains(null)); 1013 assertFalse("Returned true when the object can not be removed", 1014 collection.remove(null)); 1015 1016 // The set is backed by the map so changes to one are reflected by the 1017 // other. 1018 enumColorMap.put(Color.Blue, 3); 1019 assertTrue("Returned false for contained object", collection 1020 .contains(3)); 1021 enumColorMap.remove(Color.Blue); 1022 assertFalse("Returned true for uncontained object", collection 1023 .contains(3)); 1024 1025 assertEquals("Wrong size", 1, collection.size()); 1026 collection.clear(); 1027 assertEquals("Wrong size", 0, collection.size()); 1028 1029 enumColorMap = new EnumMap<Color, Double>(Color.class); 1030 enumColorMap.put(Color.Red, 1); 1031 enumColorMap.put(Color.Blue, null); 1032 collection = enumColorMap.values(); 1033 Collection c = new ArrayList(); 1034 c.add(new Integer(1)); 1035 assertTrue("Should return true", collection.containsAll(c)); 1036 c.add(new Double(3.4)); 1037 assertFalse("Should return false", collection.containsAll(c)); 1038 assertTrue("Should return true", collection.removeAll(c)); 1039 assertEquals("Wrong size", 1, collection.size()); 1040 assertFalse("Should return false", collection.removeAll(c)); 1041 assertEquals("Wrong size", 1, collection.size()); 1042 try { 1043 collection.addAll(c); 1044 fail("Should throw UnsupportedOperationException"); 1045 } catch (UnsupportedOperationException e) { 1046 // Expected 1047 } 1048 1049 enumColorMap.put(Color.Red, 1); 1050 assertEquals("Wrong size", 2, collection.size()); 1051 assertTrue("Should return true", collection.retainAll(c)); 1052 assertEquals("Wrong size", 1, collection.size()); 1053 assertFalse("Should return false", collection.retainAll(c)); 1054 assertEquals(1, collection.size()); 1055 Object[] array = collection.toArray(); 1056 assertEquals("Wrong length", 1, array.length); 1057 assertEquals("Wrong key", 1, array[0]); 1058 1059 enumColorMap = new EnumMap<Color, Double>(Color.class); 1060 enumColorMap.put(Color.Red, 1); 1061 enumColorMap.put(Color.Blue, null); 1062 collection = enumColorMap.values(); 1063 1064 assertEquals("Wrong size", 2, collection.size()); 1065 assertFalse("Returned true when the object can not be removed", 1066 collection.remove(new Integer("10"))); 1067 1068 Iterator iter = enumColorMap.values().iterator(); 1069 Object value = iter.next(); 1070 assertTrue("Returned false for contained object", collection 1071 .contains(value)); 1072 value = iter.next(); 1073 assertTrue("Returned false for contained object", collection 1074 .contains(value)); 1075 1076 enumColorMap.put(Color.Green, 1); 1077 enumColorMap.remove(Color.Blue); 1078 assertFalse("Returned true for uncontained object", collection 1079 .contains(value)); 1080 iter.remove(); 1081 try { 1082 iter.remove(); 1083 fail("Should throw IllegalStateException"); 1084 } catch (IllegalStateException e) { 1085 // Expected 1086 } 1087 assertFalse("Returned true for uncontained object", collection 1088 .contains(value)); 1089 1090 iter = enumColorMap.values().iterator(); 1091 value = iter.next(); 1092 assertTrue("Returned false for contained object", collection 1093 .contains(value)); 1094 enumColorMap.put(Color.Green, 3); 1095 assertTrue("Returned false for contained object", collection 1096 .contains(value)); 1097 assertTrue("Returned false for contained object", collection 1098 .remove(new Integer("1"))); 1099 assertEquals("Wrong size", 1, collection.size()); 1100 collection.clear(); 1101 assertEquals("Wrong size", 0, collection.size()); 1102 1103 enumColorMap = new EnumMap<Color, Double>(Color.class); 1104 Integer integer1 = new Integer(1); 1105 enumColorMap.put(Color.Green, integer1); 1106 enumColorMap.put(Color.Blue, null); 1107 collection = enumColorMap.values(); 1108 iter = enumColorMap.values().iterator(); 1109 try { 1110 iter.remove(); 1111 fail("Should throw IllegalStateException"); 1112 } catch (IllegalStateException e) { 1113 // Expected 1114 } 1115 value = iter.next(); 1116 assertEquals("Wrong value", integer1, value); 1117 assertSame("Wrong value", integer1, value); 1118 assertFalse("Returned true for unequal object", iter.equals(value)); 1119 iter.remove(); 1120 assertFalse("Returned true for unequal object", iter.equals(value)); 1121 try { 1122 iter.remove(); 1123 fail("Should throw IllegalStateException"); 1124 } catch (IllegalStateException e) { 1125 // Expected 1126 } 1127 assertEquals("Wrong size", 1, collection.size()); 1128 value = iter.next(); 1129 assertFalse("Returned true for unequal object", iter.equals(value)); 1130 iter.remove(); 1131 try { 1132 iter.next(); 1133 fail("Should throw NoSuchElementException"); 1134 } catch (NoSuchElementException e) { 1135 // Expected 1136 } 1137 } 1138 1139 /** 1140 * serialization/deserialization. 1141 */ 1142 @SuppressWarnings({ "unchecked", "boxing" }) 1143 public void testSerializationSelf() throws Exception { 1144 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 1145 enumColorMap.put(Color.Blue, 3); 1146 SerializationTest.verifySelf(enumColorMap); 1147 } 1148 1149 /** 1150 * serialization/deserialization compatibility with RI. 1151 */ 1152 @SuppressWarnings({ "unchecked", "boxing" }) 1153 public void testSerializationCompatibility() throws Exception { 1154 EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); 1155 enumColorMap.put(Color.Red, 1); 1156 enumColorMap.put(Color.Blue, 3); 1157 SerializationTest.verifyGolden(this, enumColorMap); 1158 } 1159 1160 /** 1161 * Sets up the fixture. 1162 */ 1163 @Override 1164 protected void setUp() throws Exception { 1165 super.setUp(); 1166 } 1167 1168 /** 1169 * Tears down the fixture. 1170 */ 1171 @Override 1172 protected void tearDown() throws Exception{ 1173 super.tearDown(); 1174 } 1175} 1176