diff options
Diffstat (limited to 'harmony-tests/src/test/java/org/apache/harmony/tests/java/util/EnumMapTest.java')
| -rw-r--r-- | harmony-tests/src/test/java/org/apache/harmony/tests/java/util/EnumMapTest.java | 1175 |
1 files changed, 1175 insertions, 0 deletions
diff --git a/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/EnumMapTest.java b/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/EnumMapTest.java new file mode 100644 index 0000000..2a37a18 --- /dev/null +++ b/harmony-tests/src/test/java/org/apache/harmony/tests/java/util/EnumMapTest.java @@ -0,0 +1,1175 @@ +/* Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package org.apache.harmony.tests.java.util; + +import dalvik.annotation.AndroidOnly; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.EnumMap; +import java.util.HashMap; +import java.util.Iterator; +import java.util.Map; +import java.util.NoSuchElementException; +import java.util.Set; + +import org.apache.harmony.testframework.serialization.SerializationTest; + +import junit.framework.TestCase; + +public class EnumMapTest extends TestCase { + enum Size { + Small, Middle, Big {}; + } + + enum Color { + Red, Green, Blue {}; + } + + enum Empty { + //Empty + } + + private static class MockEntry<K, V> implements Map.Entry<K, V> { + private K key; + + private V value; + + public MockEntry(K key, V value) { + this.key = key; + this.value = value; + } + + @Override + public int hashCode() { + return (key == null ? 0 : key.hashCode()) + ^ (value == null ? 0 : value.hashCode()); + } + + public K getKey() { + return key; + } + + public V getValue() { + return value; + } + + public V setValue(V object) { + V oldValue = value; + value = object; + return oldValue; + } + } + + /** + * java.util.EnumMap#EnumMap(Class) + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_ConstructorLjava_lang_Class() { + try { + new EnumMap((Class) null); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + + + try { + new EnumMap(Size.Big.getClass()); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + + try { + new EnumMap(Integer.class); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + assertNull("Return non-null for non mapped key", enumColorMap.put( + Color.Green, 2)); + assertEquals("Get returned incorrect value for given key", 2, + enumColorMap.get(Color.Green)); + + EnumMap enumEmptyMap = new EnumMap<Empty, Double>(Empty.class); + try { + enumEmptyMap.put(Color.Red, 2); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + + EnumMap enumSizeMap = new EnumMap(Size.class); + assertNull("Return non-null for non mapped key", enumSizeMap.put( + Size.Big, 2)); + assertEquals("Get returned incorrect value for given key", 2, + enumSizeMap.get(Size.Big)); + try { + enumSizeMap.put(Color.Red, 2); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + + enumSizeMap = new EnumMap(Size.Middle.getClass()); + assertNull("Return non-null for non mapped key", enumSizeMap.put( + Size.Small, 1)); + assertEquals("Get returned incorrect value for given key", 1, + enumSizeMap.get(Size.Small)); + try { + enumSizeMap.put(Color.Red, 2); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + } + + /** + * java.util.EnumMap#EnumMap(EnumMap) + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_ConstructorLjava_util_EnumMap() { + EnumMap enumMap; + EnumMap enumColorMap = null; + try { + enumMap = new EnumMap(enumColorMap); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + + enumColorMap = new EnumMap<Color, Double>(Color.class); + Double double1 = new Double(1); + enumColorMap.put(Color.Green, 2); + enumColorMap.put(Color.Blue, double1); + + enumMap = new EnumMap(enumColorMap); + assertEquals("Constructor fails", 2, enumMap.get(Color.Green)); + assertSame("Constructor fails", double1, enumMap.get(Color.Blue)); + assertNull("Constructor fails", enumMap.get(Color.Red)); + enumMap.put(Color.Red, 1); + assertEquals("Wrong value", 1, enumMap.get(Color.Red)); + + try { + enumMap.put(Size.Middle, 2); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + } + + /** + * java.util.EnumMap#EnumMap(Map) + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_ConstructorLjava_util_Map() { + EnumMap enumMap; + Map enumColorMap = null; + try { + enumMap = new EnumMap(enumColorMap); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + enumColorMap = new EnumMap<Color, Double>(Color.class); + enumMap = new EnumMap(enumColorMap); + enumColorMap.put(Color.Blue, 3); + enumMap = new EnumMap(enumColorMap); + + HashMap hashColorMap = null; + try { + enumMap = new EnumMap(hashColorMap); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + + hashColorMap = new HashMap(); + try { + enumMap = new EnumMap(hashColorMap); + fail("Expected IllegalArgumentException"); + } catch (IllegalArgumentException e) { + // Expected + } + + hashColorMap.put(Color.Green, 2); + enumMap = new EnumMap(hashColorMap); + assertEquals("Constructor fails", 2, enumMap.get(Color.Green)); + assertNull("Constructor fails", enumMap.get(Color.Red)); + enumMap.put(Color.Red, 1); + assertEquals("Wrong value", 1, enumMap.get(Color.Red)); + hashColorMap.put(Size.Big, 3); + try { + enumMap = new EnumMap(hashColorMap); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + + hashColorMap = new HashMap(); + hashColorMap.put(new Integer(1), 1); + try { + enumMap = new EnumMap(hashColorMap); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + } + + /** + * java.util.EnumMap#clear() + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_clear() { + EnumMap enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Small, 1); + enumSizeMap.clear(); + assertNull("Failed to clear all elements", enumSizeMap.get(Size.Small)); + } + + /** + * java.util.EnumMap#containsKey(Object) + */ + @SuppressWarnings( { "unchecked", "boxing" }) + public void test_containsKeyLjava_lang_Object() { + EnumMap enumSizeMap = new EnumMap(Size.class); + assertFalse("Returned true for uncontained key", enumSizeMap + .containsKey(Size.Small)); + enumSizeMap.put(Size.Small, 1); + assertTrue("Returned false for contained key", enumSizeMap + .containsKey(Size.Small)); + + enumSizeMap.put(Size.Big, null); + assertTrue("Returned false for contained key", enumSizeMap + .containsKey(Size.Big)); + + assertFalse("Returned true for uncontained key", enumSizeMap + .containsKey(Color.Red)); + assertFalse("Returned true for uncontained key", enumSizeMap + .containsKey(new Integer("3"))); + assertFalse("Returned true for uncontained key", enumSizeMap + .containsKey(null)); + } + + /** + * java.util.EnumMap#clone() + */ + @SuppressWarnings( { "unchecked", "boxing" }) + public void test_clone() { + EnumMap enumSizeMap = new EnumMap(Size.class); + Integer integer = new Integer("3"); + enumSizeMap.put(Size.Small, integer); + EnumMap enumSizeMapClone = enumSizeMap.clone(); + assertNotSame("Should not be same", enumSizeMap, enumSizeMapClone); + assertEquals("Clone answered unequal EnumMap", enumSizeMap, + enumSizeMapClone); + + assertSame("Should be same", enumSizeMap.get(Size.Small), + enumSizeMapClone.get(Size.Small)); + assertSame("Clone is not shallow clone", integer, enumSizeMapClone + .get(Size.Small)); + enumSizeMap.remove(Size.Small); + assertSame("Clone is not shallow clone", integer, enumSizeMapClone + .get(Size.Small)); + } + + /** + * java.util.EnumMap#containsValue(Object) + */ + @SuppressWarnings( { "unchecked", "boxing" }) + public void test_containsValueLjava_lang_Object() { + EnumMap enumSizeMap = new EnumMap(Size.class); + Double double1 = new Double(3); + Double double2 = new Double(3); + + assertFalse("Returned true for uncontained value", enumSizeMap + .containsValue(double1)); + enumSizeMap.put(Size.Middle, 2); + enumSizeMap.put(Size.Small, double1); + assertTrue("Returned false for contained value", enumSizeMap + .containsValue(double1)); + assertTrue("Returned false for contained value", enumSizeMap + .containsValue(double2)); + assertTrue("Returned false for contained value", enumSizeMap + .containsValue(2)); + assertFalse("Returned true for uncontained value", enumSizeMap + .containsValue(1)); + + assertFalse("Returned true for uncontained value", enumSizeMap + .containsValue(null)); + enumSizeMap.put(Size.Big, null); + assertTrue("Returned false for contained value", enumSizeMap + .containsValue(null)); + } + + /** + * java.util.EnumMap#entrySet() + */ + @AndroidOnly("Map.Entry is indirectly modified on RI when Iterator.next() is invoked") + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_entrySet() { + EnumMap enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + MockEntry mockEntry = new MockEntry(Size.Middle, 1); + Set set = enumSizeMap.entrySet(); + + Set set1 = enumSizeMap.entrySet(); + assertSame("Should be same", set1, set); + try { + set.add(mockEntry); + fail("Should throw UnsupportedOperationException"); + } catch (UnsupportedOperationException e) { + // Expected + } + + assertTrue("Returned false for contained object", set + .contains(mockEntry)); + mockEntry = new MockEntry(Size.Middle, null); + assertFalse("Returned true for uncontained object", set + .contains(mockEntry)); + assertFalse("Returned true for uncontained object", set + .contains(Size.Small)); + mockEntry = new MockEntry(new Integer(1), 1); + assertFalse("Returned true for uncontained object", set + .contains(mockEntry)); + assertFalse("Returned true for uncontained object", set + .contains(new Integer(1))); + + mockEntry = new MockEntry(Size.Big, null); + assertTrue("Returned false for contained object", set + .contains(mockEntry)); + assertTrue("Returned false when the object can be removed", set + .remove(mockEntry)); + assertFalse("Returned true for uncontained object", set + .contains(mockEntry)); + assertFalse("Returned true when the object can not be removed", set + .remove(mockEntry)); + mockEntry = new MockEntry(new Integer(1), 1); + assertFalse("Returned true when the object can not be removed", set + .remove(mockEntry)); + assertFalse("Returned true when the object can not be removed", set + .remove(new Integer(1))); + + // The set is backed by the map so changes to one are reflected by the + // other. + enumSizeMap.put(Size.Big, 3); + mockEntry = new MockEntry(Size.Big, 3); + assertTrue("Returned false for contained object", set + .contains(mockEntry)); + enumSizeMap.remove(Size.Big); + assertFalse("Returned true for uncontained object", set + .contains(mockEntry)); + + assertEquals("Wrong size", 1, set.size()); + set.clear(); + assertEquals("Wrong size", 0, set.size()); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.entrySet(); + Collection c = new ArrayList(); + c.add(new MockEntry(Size.Middle, 1)); + assertTrue("Return wrong value", set.containsAll(c)); + assertTrue("Remove does not success", set.removeAll(c)); + + enumSizeMap.put(Size.Middle, 1); + c.add(new MockEntry(Size.Big, 3)); + assertTrue("Remove does not success", set.removeAll(c)); + assertFalse("Should return false", set.removeAll(c)); + assertEquals("Wrong size", 1, set.size()); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.entrySet(); + c = new ArrayList(); + c.add(new MockEntry(Size.Middle, 1)); + c.add(new MockEntry(Size.Big, 3)); + + assertTrue("Retain does not success", set.retainAll(c)); + assertEquals("Wrong size", 1, set.size()); + assertFalse("Should return false", set.retainAll(c)); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + + set = enumSizeMap.entrySet(); + Object[] array = set.toArray(); + assertEquals("Wrong length", 2, array.length); + Map.Entry entry = (Map.Entry) array[0]; + assertEquals("Wrong key", Size.Middle, entry.getKey()); + assertEquals("Wrong value", 1, entry.getValue()); + + Object[] array1 = new Object[10]; + array1 = set.toArray(); + assertEquals("Wrong length", 2, array1.length); + entry = (Map.Entry) array[0]; + assertEquals("Wrong key", Size.Middle, entry.getKey()); + assertEquals("Wrong value", 1, entry.getValue()); + + array1 = new Object[10]; + array1 = set.toArray(array1); + assertEquals("Wrong length", 10, array1.length); + entry = (Map.Entry) array[1]; + assertEquals("Wrong key", Size.Big, entry.getKey()); + assertNull("Should be null", array1[2]); + + set = enumSizeMap.entrySet(); + Integer integer = new Integer("1"); + assertFalse("Returned true when the object can not be removed", set + .remove(integer)); + assertTrue("Returned false when the object can be removed", set + .remove(entry)); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.entrySet(); + Iterator iter = set.iterator(); + entry = (Map.Entry) iter.next(); + assertTrue("Returned false for contained object", set.contains(entry)); + mockEntry = new MockEntry(Size.Middle, 2); + assertFalse("Returned true for uncontained object", set + .contains(mockEntry)); + mockEntry = new MockEntry(new Integer(2), 2); + assertFalse("Returned true for uncontained object", set + .contains(mockEntry)); + entry = (Map.Entry) iter.next(); + assertTrue("Returned false for contained object", set.contains(entry)); + + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.remove(Size.Big); + mockEntry = new MockEntry(Size.Big, null); + assertEquals("Wrong size", 1, set.size()); + assertFalse("Returned true for uncontained object", set.contains(mockEntry)); + enumSizeMap.put(Size.Big, 2); + mockEntry = new MockEntry(Size.Big, 2); + assertTrue("Returned false for contained object", set + .contains(mockEntry)); + + iter.remove(); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + try { + entry.setValue(2); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + try { + set.contains(entry); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.entrySet(); + iter = set.iterator(); + entry = (Map.Entry) iter.next(); + assertEquals("Wrong key", Size.Middle, entry.getKey()); + + assertTrue("Returned false for contained object", set.contains(entry)); + enumSizeMap.put(Size.Middle, 3); + assertTrue("Returned false for contained object", set.contains(entry)); + entry.setValue(2); + assertTrue("Returned false for contained object", set.contains(entry)); + assertFalse("Returned true for uncontained object", set + .remove(new Integer(1))); + + iter.next(); + assertEquals("Wrong key", Size.Middle, entry.getKey()); + set.clear(); + assertEquals("Wrong size", 0, set.size()); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.entrySet(); + iter = set.iterator(); + mockEntry = new MockEntry(Size.Middle, 1); + + assertFalse("Wrong result", entry.equals(mockEntry)); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + entry = (Map.Entry) iter.next(); + assertEquals("Wrong key", Size.Middle, entry.getKey()); + assertTrue("Should return true", entry.equals(mockEntry)); + assertEquals("Should be equal", mockEntry.hashCode(), entry.hashCode()); + mockEntry = new MockEntry(Size.Big, 1); + assertFalse("Wrong result", entry.equals(mockEntry)); + + entry = (Map.Entry) iter.next(); + assertFalse("Wrong result", entry.equals(mockEntry)); + assertEquals("Wrong key", Size.Big, entry.getKey()); + iter.remove(); + assertFalse("Wrong result", entry.equals(mockEntry)); + assertEquals("Wrong size", 1, set.size()); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + try { + iter.next(); + fail("Should throw NoSuchElementException"); + } catch (NoSuchElementException e) { + // Expected + } + } + + /** + * java.util.EnumMap#equals(Object) + */ + @SuppressWarnings( { "unchecked", "boxing" }) + public void test_equalsLjava_lang_Object() { + EnumMap enumMap = new EnumMap(Size.class); + enumMap.put(Size.Small, 1); + + EnumMap enumSizeMap = new EnumMap(Size.class); + assertFalse("Returned true for unequal EnumMap", enumSizeMap + .equals(enumMap)); + enumSizeMap.put(Size.Small, 1); + assertTrue("Returned false for equal EnumMap", enumSizeMap + .equals(enumMap)); + enumSizeMap.put(Size.Big, null); + assertFalse("Returned true for unequal EnumMap", enumSizeMap + .equals(enumMap)); + + enumMap.put(Size.Middle, null); + assertFalse("Returned true for unequal EnumMap", enumSizeMap + .equals(enumMap)); + enumMap.remove(Size.Middle); + enumMap.put(Size.Big, 3); + assertFalse("Returned true for unequal EnumMap", enumSizeMap + .equals(enumMap)); + enumMap.put(Size.Big, null); + assertTrue("Returned false for equal EnumMap", enumSizeMap + .equals(enumMap)); + + HashMap hashMap = new HashMap(); + hashMap.put(Size.Small, 1); + assertFalse("Returned true for unequal EnumMap", hashMap + .equals(enumMap)); + hashMap.put(Size.Big, null); + assertTrue("Returned false for equal EnumMap", enumMap.equals(hashMap)); + + assertFalse("Should return false", enumSizeMap + .equals(new Integer(1))); + } + + /** + * java.util.EnumMap#keySet() + */ + @SuppressWarnings( { "unchecked", "boxing" }) + public void test_keySet() { + EnumMap enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 2); + enumSizeMap.put(Size.Big, null); + Set set = enumSizeMap.keySet(); + + Set set1 = enumSizeMap.keySet(); + assertSame("Should be same", set1, set); + try { + set.add(Size.Big); + fail("Should throw UnsupportedOperationException"); + } catch (UnsupportedOperationException e) { + // Expected + } + + assertTrue("Returned false for contained object", set + .contains(Size.Middle)); + assertTrue("Returned false for contained object", set + .contains(Size.Big)); + assertFalse("Returned true for uncontained object", set + .contains(Size.Small)); + assertFalse("Returned true for uncontained object", set + .contains(new Integer(1))); + assertTrue("Returned false when the object can be removed", set + .remove(Size.Big)); + assertFalse("Returned true for uncontained object", set + .contains(Size.Big)); + assertFalse("Returned true when the object can not be removed", set + .remove(Size.Big)); + assertFalse("Returned true when the object can not be removed", set + .remove(new Integer(1))); + + // The set is backed by the map so changes to one are reflected by the + // other. + enumSizeMap.put(Size.Big, 3); + assertTrue("Returned false for contained object", set + .contains(Size.Big)); + enumSizeMap.remove(Size.Big); + assertFalse("Returned true for uncontained object", set + .contains(Size.Big)); + + assertEquals("Wrong size", 1, set.size()); + set.clear(); + assertEquals("Wrong size", 0, set.size()); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.keySet(); + Collection c = new ArrayList(); + c.add(Size.Big); + assertTrue("Should return true", set.containsAll(c)); + c.add(Size.Small); + assertFalse("Should return false", set.containsAll(c)); + assertTrue("Should return true", set.removeAll(c)); + assertEquals("Wrong size", 1, set.size()); + assertFalse("Should return false", set.removeAll(c)); + assertEquals("Wrong size", 1, set.size()); + try { + set.addAll(c); + fail("Should throw UnsupportedOperationException"); + } catch (UnsupportedOperationException e) { + // Expected + } + + enumSizeMap.put(Size.Big, null); + assertEquals("Wrong size", 2, set.size()); + assertTrue("Should return true", set.retainAll(c)); + assertEquals("Wrong size", 1, set.size()); + assertFalse("Should return false", set.retainAll(c)); + assertEquals(1, set.size()); + Object[] array = set.toArray(); + assertEquals("Wrong length", 1, array.length); + assertEquals("Wrong key", Size.Big, array[0]); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.keySet(); + c = new ArrayList(); + c.add(Color.Blue); + assertFalse("Should return false", set.remove(c)); + assertEquals("Wrong size", 2, set.size()); + assertTrue("Should return true", set.retainAll(c)); + assertEquals("Wrong size", 0, set.size()); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.keySet(); + + Iterator iter = set.iterator(); + Enum enumKey = (Enum) iter.next(); + assertTrue("Returned false for contained object", set.contains(enumKey)); + enumKey = (Enum) iter.next(); + assertTrue("Returned false for contained object", set.contains(enumKey)); + + enumSizeMap.remove(Size.Big); + assertFalse("Returned true for uncontained object", set + .contains(enumKey)); + iter.remove(); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + assertFalse("Returned true for uncontained object", set + .contains(enumKey)); + + iter = set.iterator(); + enumKey = (Enum) iter.next(); + assertTrue("Returned false for contained object", set.contains(enumKey)); + enumSizeMap.put(Size.Middle, 3); + assertTrue("Returned false for contained object", set.contains(enumKey)); + + enumSizeMap = new EnumMap(Size.class); + enumSizeMap.put(Size.Middle, 1); + enumSizeMap.put(Size.Big, null); + set = enumSizeMap.keySet(); + iter = set.iterator(); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + enumKey = (Enum) iter.next(); + assertEquals("Wrong key", Size.Middle, enumKey); + assertSame("Wrong key", Size.Middle, enumKey); + assertFalse("Returned true for unequal object", iter.equals(enumKey)); + iter.remove(); + assertFalse("Returned true for uncontained object", set + .contains(enumKey)); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + + assertEquals("Wrong size", 1, set.size()); + enumKey = (Enum) iter.next(); + assertEquals("Wrong key", Size.Big, enumKey); + iter.remove(); + try { + iter.next(); + fail("Should throw NoSuchElementException"); + } catch (NoSuchElementException e) { + // Expected + } + } + + /** + * java.util.EnumMap#get(Object) + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_getLjava_lang_Object() { + EnumMap enumSizeMap = new EnumMap(Size.class); + assertNull("Get returned non-null for non mapped key", enumSizeMap + .get(Size.Big)); + enumSizeMap.put(Size.Big, 1); + assertEquals("Get returned incorrect value for given key", 1, + enumSizeMap.get(Size.Big)); + + assertNull("Get returned non-null for non mapped key", enumSizeMap + .get(Size.Small)); + assertNull("Get returned non-null for non existent key", enumSizeMap + .get(Color.Red)); + assertNull("Get returned non-null for non existent key", enumSizeMap + .get(new Integer(1))); + assertNull("Get returned non-null for non existent key", enumSizeMap + .get(null)); + + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + assertNull("Get returned non-null for non mapped key", enumColorMap + .get(Color.Green)); + enumColorMap.put(Color.Green, 2); + assertEquals("Get returned incorrect value for given key", 2, + enumColorMap.get(Color.Green)); + assertNull("Get returned non-null for non mapped key", enumColorMap + .get(Color.Blue)); + + enumColorMap.put(Color.Green, new Double(4)); + assertEquals("Get returned incorrect value for given key", + new Double(4), enumColorMap.get(Color.Green)); + enumColorMap.put(Color.Green, new Integer("3")); + assertEquals("Get returned incorrect value for given key", new Integer( + "3"), enumColorMap.get(Color.Green)); + enumColorMap.put(Color.Green, null); + assertNull("Can not handle null value", enumColorMap.get(Color.Green)); + Float f = new Float("3.4"); + enumColorMap.put(Color.Green, f); + assertSame("Get returned incorrect value for given key", f, + enumColorMap.get(Color.Green)); + } + + /** + * java.util.EnumMap#put(Object,Object) + */ + public void test_putLjava_lang_ObjectLjava_lang_Object() { + EnumMap enumSizeMap = new EnumMap(Size.class); + try { + enumSizeMap.put(Color.Red, 2); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + assertNull("Return non-null for non mapped key", enumSizeMap.put( + Size.Small, 1)); + + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + try { + enumColorMap.put(Size.Big, 2); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + try { + enumColorMap.put(null, 2); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + assertNull("Return non-null for non mapped key", enumColorMap.put( + Color.Green, 2)); + assertEquals("Return wrong value", 2, enumColorMap.put(Color.Green, + new Double(4))); + assertEquals("Return wrong value", new Double(4), enumColorMap.put( + Color.Green, new Integer("3"))); + assertEquals("Return wrong value", new Integer("3"), enumColorMap.put( + Color.Green, null)); + Float f = new Float("3.4"); + assertNull("Return non-null for non mapped key", enumColorMap.put( + Color.Green, f)); + assertNull("Return non-null for non mapped key", enumColorMap.put( + Color.Blue, 2)); + assertEquals("Return wrong value", 2, enumColorMap.put(Color.Blue, + new Double(4))); + } + + /** + * java.util.EnumMap#putAll(Map) + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_putAllLjava_util_Map() { + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + enumColorMap.put(Color.Green, 2); + + EnumMap enumSizeMap = new EnumMap(Size.class); + enumColorMap.putAll(enumSizeMap); + + enumSizeMap.put(Size.Big, 1); + try { + enumColorMap.putAll(enumSizeMap); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + + EnumMap enumColorMap1 = new EnumMap<Color, Double>(Color.class); + enumColorMap1.put(Color.Blue, 3); + enumColorMap.putAll(enumColorMap1); + assertEquals("Get returned incorrect value for given key", 3, + enumColorMap.get(Color.Blue)); + assertEquals("Wrong Size", 2, enumColorMap.size()); + + enumColorMap = new EnumMap<Color, Double>(Color.class); + + HashMap hashColorMap = null; + try { + enumColorMap.putAll(hashColorMap); + fail("Expected NullPointerException"); + } catch (NullPointerException e) { + // Expected + } + + hashColorMap = new HashMap(); + enumColorMap.putAll(hashColorMap); + + hashColorMap.put(Color.Green, 2); + enumColorMap.putAll(hashColorMap); + assertEquals("Get returned incorrect value for given key", 2, + enumColorMap.get(Color.Green)); + assertNull("Get returned non-null for non mapped key", enumColorMap + .get(Color.Red)); + hashColorMap.put(Color.Red, new Integer(1)); + enumColorMap.putAll(hashColorMap); + assertEquals("Get returned incorrect value for given key", new Integer( + 2), enumColorMap.get(Color.Green)); + hashColorMap.put(Size.Big, 3); + try { + enumColorMap.putAll(hashColorMap); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + + hashColorMap = new HashMap(); + hashColorMap.put(new Integer(1), 1); + try { + enumColorMap.putAll(hashColorMap); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + } + + /** + * java.util.EnumMap#remove(Object) + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_removeLjava_lang_Object() { + EnumMap enumSizeMap = new EnumMap(Size.class); + assertNull("Remove of non-mapped key returned non-null", enumSizeMap + .remove(Size.Big)); + enumSizeMap.put(Size.Big, 3); + enumSizeMap.put(Size.Middle, 2); + + assertNull("Get returned non-null for non mapped key", enumSizeMap + .get(Size.Small)); + assertEquals("Remove returned incorrect value", 3, enumSizeMap + .remove(Size.Big)); + assertNull("Get returned non-null for non mapped key", enumSizeMap + .get(Size.Big)); + assertNull("Remove of non-mapped key returned non-null", enumSizeMap + .remove(Size.Big)); + assertNull("Remove of non-existent key returned non-null", enumSizeMap + .remove(Color.Red)); + assertNull("Remove of non-existent key returned non-null", enumSizeMap + .remove(new Double(4))); + assertNull("Remove of non-existent key returned non-null", enumSizeMap + .remove(null)); + + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + assertNull("Get returned non-null for non mapped key", enumColorMap + .get(Color.Green)); + enumColorMap.put(Color.Green, new Double(4)); + assertEquals("Remove returned incorrect value", new Double(4), + enumColorMap.remove(Color.Green)); + assertNull("Get returned non-null for non mapped key", enumColorMap + .get(Color.Green)); + enumColorMap.put(Color.Green, null); + assertNull("Can not handle null value", enumColorMap + .remove(Color.Green)); + assertNull("Get returned non-null for non mapped key", enumColorMap + .get(Color.Green)); + } + + /** + * java.util.EnumMap#size() + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void test_size() { + EnumMap enumSizeMap = new EnumMap(Size.class); + assertEquals("Wrong size", 0, enumSizeMap.size()); + enumSizeMap.put(Size.Small, 1); + assertEquals("Wrong size", 1, enumSizeMap.size()); + enumSizeMap.put(Size.Small, 0); + assertEquals("Wrong size", 1, enumSizeMap.size()); + try { + enumSizeMap.put(Color.Red, 2); + fail("Expected ClassCastException"); + } catch (ClassCastException e) { + // Expected + } + assertEquals("Wrong size", 1, enumSizeMap.size()); + + enumSizeMap.put(Size.Middle, null); + assertEquals("Wrong size", 2, enumSizeMap.size()); + enumSizeMap.remove(Size.Big); + assertEquals("Wrong size", 2, enumSizeMap.size()); + enumSizeMap.remove(Size.Middle); + assertEquals("Wrong size", 1, enumSizeMap.size()); + enumSizeMap.remove(Color.Green); + assertEquals("Wrong size", 1, enumSizeMap.size()); + + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + enumColorMap.put(Color.Green, 2); + assertEquals("Wrong size", 1, enumColorMap.size()); + enumColorMap.remove(Color.Green); + assertEquals("Wrong size", 0, enumColorMap.size()); + + EnumMap enumEmptyMap = new EnumMap<Empty, Double>(Empty.class); + assertEquals("Wrong size", 0, enumEmptyMap.size()); + } + + /** + * java.util.EnumMap#values() + */ + @SuppressWarnings( { "unchecked", "boxing" }) + public void test_values() { + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + enumColorMap.put(Color.Red, 1); + enumColorMap.put(Color.Blue, null); + Collection collection = enumColorMap.values(); + + Collection collection1 = enumColorMap.values(); + assertSame("Should be same", collection1, collection); + try { + collection.add(new Integer(1)); + fail("Should throw UnsupportedOperationException"); + } catch (UnsupportedOperationException e) { + // Expected + } + + assertTrue("Returned false for contained object", collection + .contains(1)); + assertTrue("Returned false for contained object", collection + .contains(null)); + assertFalse("Returned true for uncontained object", collection + .contains(2)); + + assertTrue("Returned false when the object can be removed", collection + .remove(null)); + assertFalse("Returned true for uncontained object", collection + .contains(null)); + assertFalse("Returned true when the object can not be removed", + collection.remove(null)); + + // The set is backed by the map so changes to one are reflected by the + // other. + enumColorMap.put(Color.Blue, 3); + assertTrue("Returned false for contained object", collection + .contains(3)); + enumColorMap.remove(Color.Blue); + assertFalse("Returned true for uncontained object", collection + .contains(3)); + + assertEquals("Wrong size", 1, collection.size()); + collection.clear(); + assertEquals("Wrong size", 0, collection.size()); + + enumColorMap = new EnumMap<Color, Double>(Color.class); + enumColorMap.put(Color.Red, 1); + enumColorMap.put(Color.Blue, null); + collection = enumColorMap.values(); + Collection c = new ArrayList(); + c.add(new Integer(1)); + assertTrue("Should return true", collection.containsAll(c)); + c.add(new Double(3.4)); + assertFalse("Should return false", collection.containsAll(c)); + assertTrue("Should return true", collection.removeAll(c)); + assertEquals("Wrong size", 1, collection.size()); + assertFalse("Should return false", collection.removeAll(c)); + assertEquals("Wrong size", 1, collection.size()); + try { + collection.addAll(c); + fail("Should throw UnsupportedOperationException"); + } catch (UnsupportedOperationException e) { + // Expected + } + + enumColorMap.put(Color.Red, 1); + assertEquals("Wrong size", 2, collection.size()); + assertTrue("Should return true", collection.retainAll(c)); + assertEquals("Wrong size", 1, collection.size()); + assertFalse("Should return false", collection.retainAll(c)); + assertEquals(1, collection.size()); + Object[] array = collection.toArray(); + assertEquals("Wrong length", 1, array.length); + assertEquals("Wrong key", 1, array[0]); + + enumColorMap = new EnumMap<Color, Double>(Color.class); + enumColorMap.put(Color.Red, 1); + enumColorMap.put(Color.Blue, null); + collection = enumColorMap.values(); + + assertEquals("Wrong size", 2, collection.size()); + assertFalse("Returned true when the object can not be removed", + collection.remove(new Integer("10"))); + + Iterator iter = enumColorMap.values().iterator(); + Object value = iter.next(); + assertTrue("Returned false for contained object", collection + .contains(value)); + value = iter.next(); + assertTrue("Returned false for contained object", collection + .contains(value)); + + enumColorMap.put(Color.Green, 1); + enumColorMap.remove(Color.Blue); + assertFalse("Returned true for uncontained object", collection + .contains(value)); + iter.remove(); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + assertFalse("Returned true for uncontained object", collection + .contains(value)); + + iter = enumColorMap.values().iterator(); + value = iter.next(); + assertTrue("Returned false for contained object", collection + .contains(value)); + enumColorMap.put(Color.Green, 3); + assertTrue("Returned false for contained object", collection + .contains(value)); + assertTrue("Returned false for contained object", collection + .remove(new Integer("1"))); + assertEquals("Wrong size", 1, collection.size()); + collection.clear(); + assertEquals("Wrong size", 0, collection.size()); + + enumColorMap = new EnumMap<Color, Double>(Color.class); + Integer integer1 = new Integer(1); + enumColorMap.put(Color.Green, integer1); + enumColorMap.put(Color.Blue, null); + collection = enumColorMap.values(); + iter = enumColorMap.values().iterator(); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + value = iter.next(); + assertEquals("Wrong value", integer1, value); + assertSame("Wrong value", integer1, value); + assertFalse("Returned true for unequal object", iter.equals(value)); + iter.remove(); + assertFalse("Returned true for unequal object", iter.equals(value)); + try { + iter.remove(); + fail("Should throw IllegalStateException"); + } catch (IllegalStateException e) { + // Expected + } + assertEquals("Wrong size", 1, collection.size()); + value = iter.next(); + assertFalse("Returned true for unequal object", iter.equals(value)); + iter.remove(); + try { + iter.next(); + fail("Should throw NoSuchElementException"); + } catch (NoSuchElementException e) { + // Expected + } + } + + /** + * serialization/deserialization. + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void testSerializationSelf() throws Exception { + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + enumColorMap.put(Color.Blue, 3); + SerializationTest.verifySelf(enumColorMap); + } + + /** + * serialization/deserialization compatibility with RI. + */ + @SuppressWarnings({ "unchecked", "boxing" }) + public void testSerializationCompatibility() throws Exception { + EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class); + enumColorMap.put(Color.Red, 1); + enumColorMap.put(Color.Blue, 3); + SerializationTest.verifyGolden(this, enumColorMap); + } + + /** + * Sets up the fixture. + */ + @Override + protected void setUp() throws Exception { + super.setUp(); + } + + /** + * Tears down the fixture. + */ + @Override + protected void tearDown() throws Exception{ + super.tearDown(); + } +} |