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