Examples of java.util.EnumMap

java.util.EnumMap
A specialized {@link Map} implementation for use with enum type keys. Allof the keys in an enum map must come from a single enum type that is specified, explicitly or implicitly, when the map is created. Enum maps are represented internally as arrays. This representation is extremely compact and efficient.
Enum maps are maintained in the natural order of their keys (the order in which the enum constants are declared). This is reflected in the iterators returned by the collections views ( {@link #keySet()}, {@link #entrySet()}, and {@link #values()}).
Iterators returned by the collection views are weakly consistent: they will never throw {@link ConcurrentModificationException} and they mayor may not show the effects of any modifications to the map that occur while the iteration is in progress.
Null keys are not permitted. Attempts to insert a null key will throw {@link NullPointerException}. Attempts to test for the presence of a null key or to remove one will, however, function properly. Null values are permitted.
Like most collection implementations EnumMap is not synchronized. If multiple threads access an enum map concurrently, and at least one of the threads modifies the map, it should be synchronized externally. This is typically accomplished by synchronizing on some object that naturally encapsulates the enum map. If no such object exists, the map should be "wrapped" using the {@link Collections#synchronizedMap}method. This is best done at creation time, to prevent accidental unsynchronized access:
```
 Map<EnumKey, V> m = Collections.synchronizedMap(new EnumMap<EnumKey, V>(...)); 
```
Implementation note: All basic operations execute in constant time. They are likely (though not guaranteed) to be faster than their {@link HashMap} counterparts.
This class is a member of the Java Collections Framework. @author Josh Bloch @version 1.16, 04/21/06 @see EnumSet @since 1.5

    /**
     * @tests 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"); //$NON-NLS-1$
        } 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)); //$NON-NLS-1$
        assertSame("Constructor fails", double1, enumMap.get(Color.Blue)); //$NON-NLS-1$
        assertNull("Constructor fails", enumMap.get(Color.Red)); //$NON-NLS-1$
        enumMap.put(Color.Red, 1);
        assertEquals("Wrong value", 1, enumMap.get(Color.Red)); //$NON-NLS-1$

View Full Code Here

    /**
     * @tests 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"); //$NON-NLS-1$
        } 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");//$NON-NLS-1$
        } catch (NullPointerException e) {
            // Expected
        }


        hashColorMap = new HashMap();
        try {
            enumMap = new EnumMap(hashColorMap);
            fail("Expected IllegalArgumentException"); //$NON-NLS-1$
        } catch (IllegalArgumentException e) {
            // Expected
        }


        hashColorMap.put(Color.Green, 2);
        enumMap = new EnumMap(hashColorMap);
        assertEquals("Constructor fails", 2, enumMap.get(Color.Green)); //$NON-NLS-1$
        assertNull("Constructor fails", enumMap.get(Color.Red)); //$NON-NLS-1$
        enumMap.put(Color.Red, 1);
        assertEquals("Wrong value", 1, enumMap.get(Color.Red)); //$NON-NLS-1$
        hashColorMap.put(Size.Big, 3);
        try {
            enumMap = new EnumMap(hashColorMap);
            fail("Expected ClassCastException"); //$NON-NLS-1$
        } catch (ClassCastException e) {
            // Expected
        }


        hashColorMap = new HashMap();
        hashColorMap.put(new Integer(1), 1);
        try {
            enumMap = new EnumMap(hashColorMap);
            fail("Expected ClassCastException"); //$NON-NLS-1$
        } catch (ClassCastException e) {
            // Expected
        }
    }

View Full Code Here

    /**
     * @tests 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)); //$NON-NLS-1$
    }

View Full Code Here

    /**
     * @tests 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 //$NON-NLS-1$
                .containsKey(Size.Small));
        enumSizeMap.put(Size.Small, 1);
        assertTrue("Returned false for contained key", enumSizeMap //$NON-NLS-1$
                .containsKey(Size.Small));


        enumSizeMap.put(Size.Big, null);
        assertTrue("Returned false for contained key", enumSizeMap //$NON-NLS-1$
                .containsKey(Size.Big));


        assertFalse("Returned true for uncontained key", enumSizeMap //$NON-NLS-1$
                .containsKey(Color.Red));
        assertFalse("Returned true for uncontained key", enumSizeMap //$NON-NLS-1$
                .containsKey(new Integer("3"))); //$NON-NLS-1$
        assertFalse("Returned true for uncontained key", enumSizeMap //$NON-NLS-1$
                .containsKey(null));
    }

View Full Code Here

    /**
     * @tests java.util.EnumMap#clone()
     */
    @SuppressWarnings( { "unchecked", "boxing" })
    public void test_clone() {
        EnumMap enumSizeMap = new EnumMap(Size.class);
        Integer integer = new Integer("3"); //$NON-NLS-1$
        enumSizeMap.put(Size.Small, integer);
        EnumMap enumSizeMapClone = enumSizeMap.clone();
        assertNotSame("Should not be same", enumSizeMap, enumSizeMapClone); //$NON-NLS-1$
        assertEquals("Clone answered unequal EnumMap", enumSizeMap, //$NON-NLS-1$
                enumSizeMapClone);


        assertSame("Should be same", enumSizeMap.get(Size.Small), //$NON-NLS-1$
                enumSizeMapClone.get(Size.Small));
        assertSame("Clone is not shallow clone", integer, enumSizeMapClone //$NON-NLS-1$
                .get(Size.Small));
        enumSizeMap.remove(Size.Small);
        assertSame("Clone is not shallow clone", integer, enumSizeMapClone //$NON-NLS-1$
                .get(Size.Small));
    }

View Full Code Here

    /**
     * @tests 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 //$NON-NLS-1$
                .containsValue(double1));
        enumSizeMap.put(Size.Middle, 2);
        enumSizeMap.put(Size.Small, double1);
        assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
                .containsValue(double1));
        assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
                .containsValue(double2));
        assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
                .containsValue(2));
        assertFalse("Returned true for uncontained value", enumSizeMap //$NON-NLS-1$
                .containsValue(1));


        assertFalse("Returned true for uncontained value", enumSizeMap //$NON-NLS-1$
                .containsValue(null));
        enumSizeMap.put(Size.Big, null);
        assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
                .containsValue(null));
    }

View Full Code Here

    /**
     * @tests java.util.EnumMap#entrySet()
     */
    @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); //$NON-NLS-1$
        try {
            set.add(mockEntry);
            fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
        } catch (UnsupportedOperationException e) {
            // Expected
        }


        assertTrue("Returned false for contained object", set//$NON-NLS-1$
                .contains(mockEntry));
        mockEntry = new MockEntry(Size.Middle, null);
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(mockEntry));
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(Size.Small));
        mockEntry = new MockEntry(new Integer(1), 1);
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(mockEntry));
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(new Integer(1)));


        mockEntry = new MockEntry(Size.Big, null);
        assertTrue("Returned false for contained object", set//$NON-NLS-1$
                .contains(mockEntry));
        assertTrue("Returned false when the object can be removed", set //$NON-NLS-1$
                .remove(mockEntry));
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(mockEntry));
        assertFalse("Returned true when the object can not be removed", set //$NON-NLS-1$
                .remove(mockEntry));
        mockEntry = new MockEntry(new Integer(1), 1);
        assertFalse("Returned true when the object can not be removed", set //$NON-NLS-1$
                .remove(mockEntry));
        assertFalse("Returned true when the object can not be removed", set //$NON-NLS-1$
                .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//$NON-NLS-1$
                .contains(mockEntry));
        enumSizeMap.remove(Size.Big);
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(mockEntry));


        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
        set.clear();
        assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$


        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)); //$NON-NLS-1$
        assertTrue("Remove does not success", set.removeAll(c)); //$NON-NLS-1$


        enumSizeMap.put(Size.Middle, 1);
        c.add(new MockEntry(Size.Big, 3));
        assertTrue("Remove does not success", set.removeAll(c)); //$NON-NLS-1$
        assertFalse("Should return false", set.removeAll(c)); //$NON-NLS-1$
        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$


        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)); //$NON-NLS-1$
        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
        assertFalse("Should return false", set.retainAll(c)); //$NON-NLS-1$


        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); //$NON-NLS-1$
        Map.Entry entry = (Map.Entry) array[0];
        assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
        assertEquals("Wrong value", 1, entry.getValue()); //$NON-NLS-1$


        Object[] array1 = new Object[10];
        array1 = set.toArray();
        assertEquals("Wrong length", 2, array1.length); //$NON-NLS-1$
        entry = (Map.Entry) array[0];
        assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
        assertEquals("Wrong value", 1, entry.getValue()); //$NON-NLS-1$


        array1 = new Object[10];
        array1 = set.toArray(array1);
        assertEquals("Wrong length", 10, array1.length); //$NON-NLS-1$
        entry = (Map.Entry) array[1];
        assertEquals("Wrong key", Size.Big, entry.getKey()); //$NON-NLS-1$
        assertNull("Should be null", array1[2]); //$NON-NLS-1$


        set = enumSizeMap.entrySet();
        Integer integer = new Integer("1"); //$NON-NLS-1$
        assertFalse("Returned true when the object can not be removed", set //$NON-NLS-1$
                .remove(integer));
        assertTrue("Returned false when the object can be removed", set //$NON-NLS-1$
                .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)); //$NON-NLS-1$
        mockEntry = new MockEntry(Size.Middle, 2);
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(mockEntry));
        mockEntry = new MockEntry(new Integer(2), 2);
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(mockEntry));
        entry = (Map.Entry) iter.next();
        assertTrue("Returned false for contained object", set.contains(entry)); //$NON-NLS-1$


        enumSizeMap.put(Size.Middle, 1);
        enumSizeMap.remove(Size.Big);
        mockEntry = new MockEntry(Size.Big, null);
        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
        assertFalse("Returned true for uncontained object", set.contains(mockEntry)); //$NON-NLS-1$
        enumSizeMap.put(Size.Big, 2);
        mockEntry = new MockEntry(Size.Big, 2);
        assertTrue("Returned false for contained object", set //$NON-NLS-1$
                .contains(mockEntry));


        iter.remove();
        try {
            iter.remove();
            fail("Should throw IllegalStateException"); //$NON-NLS-1$
        } catch (IllegalStateException e) {
            // Expected
        }
        try {
            entry.setValue(2);
            fail("Should throw IllegalStateException"); //$NON-NLS-1$
        } catch (IllegalStateException e) {
            // Expected
        }
        try {
            set.contains(entry);
            fail("Should throw IllegalStateException"); //$NON-NLS-1$
        } 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()); //$NON-NLS-1$


        assertTrue("Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
        enumSizeMap.put(Size.Middle, 3);
        assertTrue("Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
        entry.setValue(2);
        assertTrue("Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .remove(new Integer(1)));


        iter.next();
        //The following test case fails on RI.
        assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
        set.clear();
        assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$


        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)); //$NON-NLS-1$
        try {

View Full Code Here

    /**
     * @tests 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 //$NON-NLS-1$
                .equals(enumMap));
        enumSizeMap.put(Size.Small, 1);
        assertTrue("Returned false for equal EnumMap", enumSizeMap //$NON-NLS-1$
                .equals(enumMap));
        enumSizeMap.put(Size.Big, null);
        assertFalse("Returned true for unequal EnumMap", enumSizeMap //$NON-NLS-1$
                .equals(enumMap));


        enumMap.put(Size.Middle, null);
        assertFalse("Returned true for unequal EnumMap", enumSizeMap //$NON-NLS-1$
                .equals(enumMap));
        enumMap.remove(Size.Middle);
        enumMap.put(Size.Big, 3);
        assertFalse("Returned true for unequal EnumMap", enumSizeMap //$NON-NLS-1$
                .equals(enumMap));
        enumMap.put(Size.Big, null);
        assertTrue("Returned false for equal EnumMap", enumSizeMap //$NON-NLS-1$
                .equals(enumMap));


        HashMap hashMap = new HashMap();
        hashMap.put(Size.Small, 1);
        assertFalse("Returned true for unequal EnumMap", hashMap //$NON-NLS-1$
                .equals(enumMap));
        hashMap.put(Size.Big, null);
        assertTrue("Returned false for equal EnumMap", enumMap.equals(hashMap)); //$NON-NLS-1$


        assertFalse("Should return false", enumSizeMap //$NON-NLS-1$
                .equals(new Integer(1)));
    }

View Full Code Here

    /**
     * @tests 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); //$NON-NLS-1$
        try {
            set.add(Size.Big);
            fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
        } catch (UnsupportedOperationException e) {
            // Expected
        }


        assertTrue("Returned false for contained object", set//$NON-NLS-1$
                .contains(Size.Middle));
        assertTrue("Returned false for contained object", set//$NON-NLS-1$
                .contains(Size.Big));
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(Size.Small));
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(new Integer(1)));
        assertTrue("Returned false when the object can be removed", set //$NON-NLS-1$
                .remove(Size.Big));
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(Size.Big));
        assertFalse("Returned true when the object can not be removed", set //$NON-NLS-1$
                .remove(Size.Big));
        assertFalse("Returned true when the object can not be removed", set //$NON-NLS-1$
                .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//$NON-NLS-1$
                .contains(Size.Big));
        enumSizeMap.remove(Size.Big);
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(Size.Big));


        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
        set.clear();
        assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$


        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)); //$NON-NLS-1$
        c.add(Size.Small);
        assertFalse("Should return false", set.containsAll(c)); //$NON-NLS-1$
        assertTrue("Should return true", set.removeAll(c)); //$NON-NLS-1$
        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
        assertFalse("Should return false", set.removeAll(c)); //$NON-NLS-1$
        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
        try {
            set.addAll(c);
            fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
        } catch (UnsupportedOperationException e) {
            // Expected
        }


        enumSizeMap.put(Size.Big, null);
        assertEquals("Wrong size", 2, set.size()); //$NON-NLS-1$
        assertTrue("Should return true", set.retainAll(c)); //$NON-NLS-1$
        assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
        assertFalse("Should return false", set.retainAll(c)); //$NON-NLS-1$
        assertEquals(1, set.size());
        Object[] array = set.toArray();
        assertEquals("Wrong length", 1, array.length); //$NON-NLS-1$
        assertEquals("Wrong key", Size.Big, array[0]); //$NON-NLS-1$


        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)); //$NON-NLS-1$
        assertEquals("Wrong size", 2, set.size()); //$NON-NLS-1$
        assertTrue("Should return true", set.retainAll(c)); //$NON-NLS-1$
        assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$


        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)); //$NON-NLS-1$
        enumKey = (Enum) iter.next();
        assertTrue("Returned false for contained object", set.contains(enumKey)); //$NON-NLS-1$


        enumSizeMap.remove(Size.Big);
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(enumKey));
        iter.remove();
        try {
            iter.remove();
            fail("Should throw IllegalStateException"); //$NON-NLS-1$
        } catch (IllegalStateException e) {
            // Expected
        }
        assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
                .contains(enumKey));


        iter = set.iterator();
        enumKey = (Enum) iter.next();
        assertTrue("Returned false for contained object", set.contains(enumKey)); //$NON-NLS-1$
        enumSizeMap.put(Size.Middle, 3);
        assertTrue("Returned false for contained object", set.contains(enumKey)); //$NON-NLS-1$


        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"); //$NON-NLS-1$
        } catch (IllegalStateException e) {

View Full Code Here

    /**
     * @tests 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 //$NON-NLS-1$
                .get(Size.Big));
        enumSizeMap.put(Size.Big, 1);
        assertEquals("Get returned incorrect value for given key", 1, //$NON-NLS-1$
                enumSizeMap.get(Size.Big));
        
        assertNull("Get returned non-null for non mapped key", enumSizeMap //$NON-NLS-1$
                .get(Size.Small));
        assertNull("Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
                .get(Color.Red));
        assertNull("Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
                .get(new Integer(1)));
        assertNull("Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
                .get(null));


        EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
        assertNull("Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
                .get(Color.Green));
        enumColorMap.put(Color.Green, 2);
        assertEquals("Get returned incorrect value for given key", 2, //$NON-NLS-1$
                enumColorMap.get(Color.Green));
        assertNull("Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
                .get(Color.Blue));
        
        enumColorMap.put(Color.Green, new Double(4));
        assertEquals("Get returned incorrect value for given key", //$NON-NLS-1$
                new Double(4), enumColorMap.get(Color.Green));
        enumColorMap.put(Color.Green, new Integer("3"));//$NON-NLS-1$
        assertEquals("Get returned incorrect value for given key", new Integer( //$NON-NLS-1$
                "3"), enumColorMap.get(Color.Green));//$NON-NLS-1$
        enumColorMap.put(Color.Green, null);
        assertNull("Can not handle null value", enumColorMap.get(Color.Green)); //$NON-NLS-1$
        Float f = new Float("3.4");//$NON-NLS-1$
        enumColorMap.put(Color.Green, f);
        assertSame("Get returned incorrect value for given key", f, //$NON-NLS-1$
                enumColorMap.get(Color.Green));
    }

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of java.util.EnumMap

booton.css.StyleDeclarable

com.google.caja.util.Maps

com.google.common.collect.EnumBiMap

com.google.common.collect.EnumHashBiMap

com.google.common.collect.EnumMultiset

com.google.common.collect.ImmutableMap

com.google.common.collect.Maps

com.google.gwt.user.client.rpc.core.java.util.EnumMap_CustomFieldSerializer

com.redhat.ceylon.compiler.typechecker.util.WarningSuppressionVisitor

com.sun.xml.bind.v2.model.impl.RuntimeEnumLeafInfoImpl

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.