0001: /* Licensed to the Apache Software Foundation (ASF) under one or more
0002: * contributor license agreements. See the NOTICE file distributed with
0003: * this work for additional information regarding copyright ownership.
0004: * The ASF licenses this file to You under the Apache License, Version 2.0
0005: * (the "License"); you may not use this file except in compliance with
0006: * the License. You may obtain a copy of the License at
0007: *
0008: * http://www.apache.org/licenses/LICENSE-2.0
0009: *
0010: * Unless required by applicable law or agreed to in writing, software
0011: * distributed under the License is distributed on an "AS IS" BASIS,
0012: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
0013: * See the License for the specific language governing permissions and
0014: * limitations under the License.
0015: */
0016:
0017: package org.apache.harmony.luni.tests.java.util;
0018:
0019: import java.util.ArrayList;
0020: import java.util.Collection;
0021: import java.util.EnumMap;
0022: import java.util.HashMap;
0023: import java.util.Iterator;
0024: import java.util.Map;
0025: import java.util.NoSuchElementException;
0026: import java.util.Set;
0027:
0028: import org.apache.harmony.testframework.serialization.SerializationTest;
0029:
0030: import junit.framework.TestCase;
0031:
0032: public class EnumMapTest extends TestCase {
0033: enum Size {
0034: Small, Middle, Big {
0035: };
0036: }
0037:
0038: enum Color {
0039: Red, Green, Blue {
0040: };
0041: }
0042:
0043: enum Empty {
0044: //Empty
0045: }
0046:
0047: private static class MockEntry<K, V> implements Map.Entry<K, V> {
0048: private K key;
0049:
0050: private V value;
0051:
0052: public MockEntry(K key, V value) {
0053: this .key = key;
0054: this .value = value;
0055: }
0056:
0057: @Override
0058: public int hashCode() {
0059: return (key == null ? 0 : key.hashCode())
0060: ^ (value == null ? 0 : value.hashCode());
0061: }
0062:
0063: public K getKey() {
0064: return key;
0065: }
0066:
0067: public V getValue() {
0068: return value;
0069: }
0070:
0071: public V setValue(V object) {
0072: V oldValue = value;
0073: value = object;
0074: return oldValue;
0075: }
0076: }
0077:
0078: /**
0079: * @tests java.util.EnumMap#EnumMap(Class)
0080: */
0081: @SuppressWarnings({"unchecked","boxing"})
0082: public void test_ConstructorLjava_lang_Class() {
0083: try {
0084: new EnumMap((Class) null);
0085: fail("Expected NullPointerException"); //$NON-NLS-1$
0086: } catch (NullPointerException e) {
0087: // Expected
0088: }
0089:
0090: try {
0091: new EnumMap(Size.Big.getClass());
0092: fail("Expected NullPointerException"); //$NON-NLS-1$
0093: } catch (NullPointerException e) {
0094: // Expected
0095: }
0096:
0097: try {
0098: new EnumMap(Integer.class);
0099: fail("Expected NullPointerException"); //$NON-NLS-1$
0100: } catch (NullPointerException e) {
0101: // Expected
0102: }
0103:
0104: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
0105: assertNull(
0106: "Return non-null for non mapped key", enumColorMap.put( //$NON-NLS-1$
0107: Color.Green, 2));
0108: assertEquals("Get returned incorrect value for given key", 2, //$NON-NLS-1$
0109: enumColorMap.get(Color.Green));
0110:
0111: EnumMap enumEmptyMap = new EnumMap<Empty, Double>(Empty.class);
0112: try {
0113: enumEmptyMap.put(Color.Red, 2);
0114: fail("Expected ClassCastException"); //$NON-NLS-1$
0115: } catch (ClassCastException e) {
0116: // Expected
0117: }
0118:
0119: EnumMap enumSizeMap = new EnumMap(Size.class);
0120: assertNull(
0121: "Return non-null for non mapped key", enumSizeMap.put( //$NON-NLS-1$
0122: Size.Big, 2));
0123: assertEquals("Get returned incorrect value for given key", 2, //$NON-NLS-1$
0124: enumSizeMap.get(Size.Big));
0125: try {
0126: enumSizeMap.put(Color.Red, 2);
0127: fail("Expected ClassCastException"); //$NON-NLS-1$
0128: } catch (ClassCastException e) {
0129: // Expected
0130: }
0131:
0132: enumSizeMap = new EnumMap(Size.Middle.getClass());
0133: assertNull(
0134: "Return non-null for non mapped key", enumSizeMap.put( //$NON-NLS-1$
0135: Size.Small, 1));
0136: assertEquals("Get returned incorrect value for given key", 1, //$NON-NLS-1$
0137: enumSizeMap.get(Size.Small));
0138: try {
0139: enumSizeMap.put(Color.Red, 2);
0140: fail("Expected ClassCastException"); //$NON-NLS-1$
0141: } catch (ClassCastException e) {
0142: // Expected
0143: }
0144: }
0145:
0146: /**
0147: * @tests java.util.EnumMap#EnumMap(EnumMap)
0148: */
0149: @SuppressWarnings({"unchecked","boxing"})
0150: public void test_ConstructorLjava_util_EnumMap() {
0151: EnumMap enumMap;
0152: EnumMap enumColorMap = null;
0153: try {
0154: enumMap = new EnumMap(enumColorMap);
0155: fail("Expected NullPointerException"); //$NON-NLS-1$
0156: } catch (NullPointerException e) {
0157: // Expected
0158: }
0159:
0160: enumColorMap = new EnumMap<Color, Double>(Color.class);
0161: Double double1 = new Double(1);
0162: enumColorMap.put(Color.Green, 2);
0163: enumColorMap.put(Color.Blue, double1);
0164:
0165: enumMap = new EnumMap(enumColorMap);
0166: assertEquals("Constructor fails", 2, enumMap.get(Color.Green)); //$NON-NLS-1$
0167: assertSame(
0168: "Constructor fails", double1, enumMap.get(Color.Blue)); //$NON-NLS-1$
0169: assertNull("Constructor fails", enumMap.get(Color.Red)); //$NON-NLS-1$
0170: enumMap.put(Color.Red, 1);
0171: assertEquals("Wrong value", 1, enumMap.get(Color.Red)); //$NON-NLS-1$
0172:
0173: try {
0174: enumMap.put(Size.Middle, 2);
0175: fail("Expected ClassCastException"); //$NON-NLS-1$
0176: } catch (ClassCastException e) {
0177: // Expected
0178: }
0179: }
0180:
0181: /**
0182: * @tests java.util.EnumMap#EnumMap(Map)
0183: */
0184: @SuppressWarnings({"unchecked","boxing"})
0185: public void test_ConstructorLjava_util_Map() {
0186: EnumMap enumMap;
0187: Map enumColorMap = null;
0188: try {
0189: enumMap = new EnumMap(enumColorMap);
0190: fail("Expected NullPointerException"); //$NON-NLS-1$
0191: } catch (NullPointerException e) {
0192: // Expected
0193: }
0194: enumColorMap = new EnumMap<Color, Double>(Color.class);
0195: enumMap = new EnumMap(enumColorMap);
0196: enumColorMap.put(Color.Blue, 3);
0197: enumMap = new EnumMap(enumColorMap);
0198:
0199: HashMap hashColorMap = null;
0200: try {
0201: enumMap = new EnumMap(hashColorMap);
0202: fail("Expected NullPointerException");//$NON-NLS-1$
0203: } catch (NullPointerException e) {
0204: // Expected
0205: }
0206:
0207: hashColorMap = new HashMap();
0208: try {
0209: enumMap = new EnumMap(hashColorMap);
0210: fail("Expected IllegalArgumentException"); //$NON-NLS-1$
0211: } catch (IllegalArgumentException e) {
0212: // Expected
0213: }
0214:
0215: hashColorMap.put(Color.Green, 2);
0216: enumMap = new EnumMap(hashColorMap);
0217: assertEquals("Constructor fails", 2, enumMap.get(Color.Green)); //$NON-NLS-1$
0218: assertNull("Constructor fails", enumMap.get(Color.Red)); //$NON-NLS-1$
0219: enumMap.put(Color.Red, 1);
0220: assertEquals("Wrong value", 1, enumMap.get(Color.Red)); //$NON-NLS-1$
0221: hashColorMap.put(Size.Big, 3);
0222: try {
0223: enumMap = new EnumMap(hashColorMap);
0224: fail("Expected ClassCastException"); //$NON-NLS-1$
0225: } catch (ClassCastException e) {
0226: // Expected
0227: }
0228:
0229: hashColorMap = new HashMap();
0230: hashColorMap.put(new Integer(1), 1);
0231: try {
0232: enumMap = new EnumMap(hashColorMap);
0233: fail("Expected ClassCastException"); //$NON-NLS-1$
0234: } catch (ClassCastException e) {
0235: // Expected
0236: }
0237: }
0238:
0239: /**
0240: * @tests java.util.EnumMap#clear()
0241: */
0242: @SuppressWarnings({"unchecked","boxing"})
0243: public void test_clear() {
0244: EnumMap enumSizeMap = new EnumMap(Size.class);
0245: enumSizeMap.put(Size.Small, 1);
0246: enumSizeMap.clear();
0247: assertNull(
0248: "Failed to clear all elements", enumSizeMap.get(Size.Small)); //$NON-NLS-1$
0249: }
0250:
0251: /**
0252: * @tests java.util.EnumMap#containsKey(Object)
0253: */
0254: @SuppressWarnings({"unchecked","boxing"})
0255: public void test_containsKeyLjava_lang_Object() {
0256: EnumMap enumSizeMap = new EnumMap(Size.class);
0257: assertFalse("Returned true for uncontained key", enumSizeMap //$NON-NLS-1$
0258: .containsKey(Size.Small));
0259: enumSizeMap.put(Size.Small, 1);
0260: assertTrue("Returned false for contained key", enumSizeMap //$NON-NLS-1$
0261: .containsKey(Size.Small));
0262:
0263: enumSizeMap.put(Size.Big, null);
0264: assertTrue("Returned false for contained key", enumSizeMap //$NON-NLS-1$
0265: .containsKey(Size.Big));
0266:
0267: assertFalse("Returned true for uncontained key", enumSizeMap //$NON-NLS-1$
0268: .containsKey(Color.Red));
0269: assertFalse("Returned true for uncontained key", enumSizeMap //$NON-NLS-1$
0270: .containsKey(new Integer("3"))); //$NON-NLS-1$
0271: assertFalse("Returned true for uncontained key", enumSizeMap //$NON-NLS-1$
0272: .containsKey(null));
0273: }
0274:
0275: /**
0276: * @tests java.util.EnumMap#clone()
0277: */
0278: @SuppressWarnings({"unchecked","boxing"})
0279: public void test_clone() {
0280: EnumMap enumSizeMap = new EnumMap(Size.class);
0281: Integer integer = new Integer("3"); //$NON-NLS-1$
0282: enumSizeMap.put(Size.Small, integer);
0283: EnumMap enumSizeMapClone = enumSizeMap.clone();
0284: assertNotSame(
0285: "Should not be same", enumSizeMap, enumSizeMapClone); //$NON-NLS-1$
0286: assertEquals("Clone answered unequal EnumMap", enumSizeMap, //$NON-NLS-1$
0287: enumSizeMapClone);
0288:
0289: assertSame("Should be same", enumSizeMap.get(Size.Small), //$NON-NLS-1$
0290: enumSizeMapClone.get(Size.Small));
0291: assertSame(
0292: "Clone is not shallow clone", integer, enumSizeMapClone //$NON-NLS-1$
0293: .get(Size.Small));
0294: enumSizeMap.remove(Size.Small);
0295: assertSame(
0296: "Clone is not shallow clone", integer, enumSizeMapClone //$NON-NLS-1$
0297: .get(Size.Small));
0298: }
0299:
0300: /**
0301: * @tests java.util.EnumMap#containsValue(Object)
0302: */
0303: @SuppressWarnings({"unchecked","boxing"})
0304: public void test_containsValueLjava_lang_Object() {
0305: EnumMap enumSizeMap = new EnumMap(Size.class);
0306: Double double1 = new Double(3);
0307: Double double2 = new Double(3);
0308:
0309: assertFalse("Returned true for uncontained value", enumSizeMap //$NON-NLS-1$
0310: .containsValue(double1));
0311: enumSizeMap.put(Size.Middle, 2);
0312: enumSizeMap.put(Size.Small, double1);
0313: assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
0314: .containsValue(double1));
0315: assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
0316: .containsValue(double2));
0317: assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
0318: .containsValue(2));
0319: assertFalse("Returned true for uncontained value", enumSizeMap //$NON-NLS-1$
0320: .containsValue(1));
0321:
0322: assertFalse("Returned true for uncontained value", enumSizeMap //$NON-NLS-1$
0323: .containsValue(null));
0324: enumSizeMap.put(Size.Big, null);
0325: assertTrue("Returned false for contained value", enumSizeMap //$NON-NLS-1$
0326: .containsValue(null));
0327: }
0328:
0329: /**
0330: * @tests java.util.EnumMap#entrySet()
0331: */
0332: @SuppressWarnings({"unchecked","boxing"})
0333: public void test_entrySet() {
0334: EnumMap enumSizeMap = new EnumMap(Size.class);
0335: enumSizeMap.put(Size.Middle, 1);
0336: enumSizeMap.put(Size.Big, null);
0337: MockEntry mockEntry = new MockEntry(Size.Middle, 1);
0338: Set set = enumSizeMap.entrySet();
0339:
0340: Set set1 = enumSizeMap.entrySet();
0341: assertSame("Should be same", set1, set); //$NON-NLS-1$
0342: try {
0343: set.add(mockEntry);
0344: fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
0345: } catch (UnsupportedOperationException e) {
0346: // Expected
0347: }
0348:
0349: assertTrue("Returned false for contained object", set//$NON-NLS-1$
0350: .contains(mockEntry));
0351: mockEntry = new MockEntry(Size.Middle, null);
0352: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0353: .contains(mockEntry));
0354: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0355: .contains(Size.Small));
0356: mockEntry = new MockEntry(new Integer(1), 1);
0357: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0358: .contains(mockEntry));
0359: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0360: .contains(new Integer(1)));
0361:
0362: mockEntry = new MockEntry(Size.Big, null);
0363: assertTrue("Returned false for contained object", set//$NON-NLS-1$
0364: .contains(mockEntry));
0365: assertTrue("Returned false when the object can be removed", set //$NON-NLS-1$
0366: .remove(mockEntry));
0367: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0368: .contains(mockEntry));
0369: assertFalse(
0370: "Returned true when the object can not be removed", set //$NON-NLS-1$
0371: .remove(mockEntry));
0372: mockEntry = new MockEntry(new Integer(1), 1);
0373: assertFalse(
0374: "Returned true when the object can not be removed", set //$NON-NLS-1$
0375: .remove(mockEntry));
0376: assertFalse(
0377: "Returned true when the object can not be removed", set //$NON-NLS-1$
0378: .remove(new Integer(1)));
0379:
0380: // The set is backed by the map so changes to one are reflected by the
0381: // other.
0382: enumSizeMap.put(Size.Big, 3);
0383: mockEntry = new MockEntry(Size.Big, 3);
0384: assertTrue("Returned false for contained object", set//$NON-NLS-1$
0385: .contains(mockEntry));
0386: enumSizeMap.remove(Size.Big);
0387: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0388: .contains(mockEntry));
0389:
0390: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0391: set.clear();
0392: assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$
0393:
0394: enumSizeMap = new EnumMap(Size.class);
0395: enumSizeMap.put(Size.Middle, 1);
0396: enumSizeMap.put(Size.Big, null);
0397: set = enumSizeMap.entrySet();
0398: Collection c = new ArrayList();
0399: c.add(new MockEntry(Size.Middle, 1));
0400: assertTrue("Return wrong value", set.containsAll(c)); //$NON-NLS-1$
0401: assertTrue("Remove does not success", set.removeAll(c)); //$NON-NLS-1$
0402:
0403: enumSizeMap.put(Size.Middle, 1);
0404: c.add(new MockEntry(Size.Big, 3));
0405: assertTrue("Remove does not success", set.removeAll(c)); //$NON-NLS-1$
0406: assertFalse("Should return false", set.removeAll(c)); //$NON-NLS-1$
0407: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0408:
0409: enumSizeMap = new EnumMap(Size.class);
0410: enumSizeMap.put(Size.Middle, 1);
0411: enumSizeMap.put(Size.Big, null);
0412: set = enumSizeMap.entrySet();
0413: c = new ArrayList();
0414: c.add(new MockEntry(Size.Middle, 1));
0415: c.add(new MockEntry(Size.Big, 3));
0416:
0417: assertTrue("Retain does not success", set.retainAll(c)); //$NON-NLS-1$
0418: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0419: assertFalse("Should return false", set.retainAll(c)); //$NON-NLS-1$
0420:
0421: enumSizeMap = new EnumMap(Size.class);
0422: enumSizeMap.put(Size.Middle, 1);
0423: enumSizeMap.put(Size.Big, null);
0424:
0425: set = enumSizeMap.entrySet();
0426: Object[] array = set.toArray();
0427: assertEquals("Wrong length", 2, array.length); //$NON-NLS-1$
0428: Map.Entry entry = (Map.Entry) array[0];
0429: assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
0430: assertEquals("Wrong value", 1, entry.getValue()); //$NON-NLS-1$
0431:
0432: Object[] array1 = new Object[10];
0433: array1 = set.toArray();
0434: assertEquals("Wrong length", 2, array1.length); //$NON-NLS-1$
0435: entry = (Map.Entry) array[0];
0436: assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
0437: assertEquals("Wrong value", 1, entry.getValue()); //$NON-NLS-1$
0438:
0439: array1 = new Object[10];
0440: array1 = set.toArray(array1);
0441: assertEquals("Wrong length", 10, array1.length); //$NON-NLS-1$
0442: entry = (Map.Entry) array[1];
0443: assertEquals("Wrong key", Size.Big, entry.getKey()); //$NON-NLS-1$
0444: assertNull("Should be null", array1[2]); //$NON-NLS-1$
0445:
0446: set = enumSizeMap.entrySet();
0447: Integer integer = new Integer("1"); //$NON-NLS-1$
0448: assertFalse(
0449: "Returned true when the object can not be removed", set //$NON-NLS-1$
0450: .remove(integer));
0451: assertTrue("Returned false when the object can be removed", set //$NON-NLS-1$
0452: .remove(entry));
0453:
0454: enumSizeMap = new EnumMap(Size.class);
0455: enumSizeMap.put(Size.Middle, 1);
0456: enumSizeMap.put(Size.Big, null);
0457: set = enumSizeMap.entrySet();
0458: Iterator iter = set.iterator();
0459: entry = (Map.Entry) iter.next();
0460: assertTrue(
0461: "Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
0462: mockEntry = new MockEntry(Size.Middle, 2);
0463: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0464: .contains(mockEntry));
0465: mockEntry = new MockEntry(new Integer(2), 2);
0466: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0467: .contains(mockEntry));
0468: entry = (Map.Entry) iter.next();
0469: assertTrue(
0470: "Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
0471:
0472: enumSizeMap.put(Size.Middle, 1);
0473: enumSizeMap.remove(Size.Big);
0474: mockEntry = new MockEntry(Size.Big, null);
0475: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0476: assertFalse(
0477: "Returned true for uncontained object", set.contains(mockEntry)); //$NON-NLS-1$
0478: enumSizeMap.put(Size.Big, 2);
0479: mockEntry = new MockEntry(Size.Big, 2);
0480: assertTrue("Returned false for contained object", set //$NON-NLS-1$
0481: .contains(mockEntry));
0482:
0483: iter.remove();
0484: try {
0485: iter.remove();
0486: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0487: } catch (IllegalStateException e) {
0488: // Expected
0489: }
0490: try {
0491: entry.setValue(2);
0492: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0493: } catch (IllegalStateException e) {
0494: // Expected
0495: }
0496: try {
0497: set.contains(entry);
0498: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0499: } catch (IllegalStateException e) {
0500: // Expected
0501: }
0502:
0503: enumSizeMap = new EnumMap(Size.class);
0504: enumSizeMap.put(Size.Middle, 1);
0505: enumSizeMap.put(Size.Big, null);
0506: set = enumSizeMap.entrySet();
0507: iter = set.iterator();
0508: entry = (Map.Entry) iter.next();
0509: assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
0510:
0511: assertTrue(
0512: "Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
0513: enumSizeMap.put(Size.Middle, 3);
0514: assertTrue(
0515: "Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
0516: entry.setValue(2);
0517: assertTrue(
0518: "Returned false for contained object", set.contains(entry)); //$NON-NLS-1$
0519: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0520: .remove(new Integer(1)));
0521:
0522: iter.next();
0523: //The following test case fails on RI.
0524: assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
0525: set.clear();
0526: assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$
0527:
0528: enumSizeMap = new EnumMap(Size.class);
0529: enumSizeMap.put(Size.Middle, 1);
0530: enumSizeMap.put(Size.Big, null);
0531: set = enumSizeMap.entrySet();
0532: iter = set.iterator();
0533: mockEntry = new MockEntry(Size.Middle, 1);
0534:
0535: assertFalse("Wrong result", entry.equals(mockEntry)); //$NON-NLS-1$
0536: try {
0537: iter.remove();
0538: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0539: } catch (IllegalStateException e) {
0540: // Expected
0541: }
0542: entry = (Map.Entry) iter.next();
0543: assertEquals("Wrong key", Size.Middle, entry.getKey()); //$NON-NLS-1$
0544: assertTrue("Should return true", entry.equals(mockEntry)); //$NON-NLS-1$
0545: assertEquals(
0546: "Should be equal", mockEntry.hashCode(), entry.hashCode()); //$NON-NLS-1$
0547: mockEntry = new MockEntry(Size.Big, 1);
0548: assertFalse("Wrong result", entry.equals(mockEntry)); //$NON-NLS-1$
0549:
0550: entry = (Map.Entry) iter.next();
0551: assertFalse("Wrong result", entry.equals(mockEntry)); //$NON-NLS-1$
0552: assertEquals("Wrong key", Size.Big, entry.getKey()); //$NON-NLS-1$
0553: iter.remove();
0554: assertFalse("Wrong result", entry.equals(mockEntry)); //$NON-NLS-1$
0555: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0556: try {
0557: iter.remove();
0558: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0559: } catch (IllegalStateException e) {
0560: // Expected
0561: }
0562: try {
0563: iter.next();
0564: fail("Should throw NoSuchElementException"); //$NON-NLS-1$
0565: } catch (NoSuchElementException e) {
0566: // Expected
0567: }
0568: }
0569:
0570: /**
0571: * @tests java.util.EnumMap#equals(Object)
0572: */
0573: @SuppressWarnings({"unchecked","boxing"})
0574: public void test_equalsLjava_lang_Object() {
0575: EnumMap enumMap = new EnumMap(Size.class);
0576: enumMap.put(Size.Small, 1);
0577:
0578: EnumMap enumSizeMap = new EnumMap(Size.class);
0579: assertFalse("Returned true for unequal EnumMap", enumSizeMap //$NON-NLS-1$
0580: .equals(enumMap));
0581: enumSizeMap.put(Size.Small, 1);
0582: assertTrue("Returned false for equal EnumMap", enumSizeMap //$NON-NLS-1$
0583: .equals(enumMap));
0584: enumSizeMap.put(Size.Big, null);
0585: assertFalse("Returned true for unequal EnumMap", enumSizeMap //$NON-NLS-1$
0586: .equals(enumMap));
0587:
0588: enumMap.put(Size.Middle, null);
0589: assertFalse("Returned true for unequal EnumMap", enumSizeMap //$NON-NLS-1$
0590: .equals(enumMap));
0591: enumMap.remove(Size.Middle);
0592: enumMap.put(Size.Big, 3);
0593: assertFalse("Returned true for unequal EnumMap", enumSizeMap //$NON-NLS-1$
0594: .equals(enumMap));
0595: enumMap.put(Size.Big, null);
0596: assertTrue("Returned false for equal EnumMap", enumSizeMap //$NON-NLS-1$
0597: .equals(enumMap));
0598:
0599: HashMap hashMap = new HashMap();
0600: hashMap.put(Size.Small, 1);
0601: assertFalse("Returned true for unequal EnumMap", hashMap //$NON-NLS-1$
0602: .equals(enumMap));
0603: hashMap.put(Size.Big, null);
0604: assertTrue(
0605: "Returned false for equal EnumMap", enumMap.equals(hashMap)); //$NON-NLS-1$
0606:
0607: assertFalse("Should return false", enumSizeMap //$NON-NLS-1$
0608: .equals(new Integer(1)));
0609: }
0610:
0611: /**
0612: * @tests java.util.EnumMap#keySet()
0613: */
0614: @SuppressWarnings({"unchecked","boxing"})
0615: public void test_keySet() {
0616: EnumMap enumSizeMap = new EnumMap(Size.class);
0617: enumSizeMap.put(Size.Middle, 2);
0618: enumSizeMap.put(Size.Big, null);
0619: Set set = enumSizeMap.keySet();
0620:
0621: Set set1 = enumSizeMap.keySet();
0622: assertSame("Should be same", set1, set); //$NON-NLS-1$
0623: try {
0624: set.add(Size.Big);
0625: fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
0626: } catch (UnsupportedOperationException e) {
0627: // Expected
0628: }
0629:
0630: assertTrue("Returned false for contained object", set//$NON-NLS-1$
0631: .contains(Size.Middle));
0632: assertTrue("Returned false for contained object", set//$NON-NLS-1$
0633: .contains(Size.Big));
0634: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0635: .contains(Size.Small));
0636: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0637: .contains(new Integer(1)));
0638: assertTrue("Returned false when the object can be removed", set //$NON-NLS-1$
0639: .remove(Size.Big));
0640: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0641: .contains(Size.Big));
0642: assertFalse(
0643: "Returned true when the object can not be removed", set //$NON-NLS-1$
0644: .remove(Size.Big));
0645: assertFalse(
0646: "Returned true when the object can not be removed", set //$NON-NLS-1$
0647: .remove(new Integer(1)));
0648:
0649: // The set is backed by the map so changes to one are reflected by the
0650: // other.
0651: enumSizeMap.put(Size.Big, 3);
0652: assertTrue("Returned false for contained object", set//$NON-NLS-1$
0653: .contains(Size.Big));
0654: enumSizeMap.remove(Size.Big);
0655: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0656: .contains(Size.Big));
0657:
0658: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0659: set.clear();
0660: assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$
0661:
0662: enumSizeMap = new EnumMap(Size.class);
0663: enumSizeMap.put(Size.Middle, 1);
0664: enumSizeMap.put(Size.Big, null);
0665: set = enumSizeMap.keySet();
0666: Collection c = new ArrayList();
0667: c.add(Size.Big);
0668: assertTrue("Should return true", set.containsAll(c)); //$NON-NLS-1$
0669: c.add(Size.Small);
0670: assertFalse("Should return false", set.containsAll(c)); //$NON-NLS-1$
0671: assertTrue("Should return true", set.removeAll(c)); //$NON-NLS-1$
0672: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0673: assertFalse("Should return false", set.removeAll(c)); //$NON-NLS-1$
0674: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0675: try {
0676: set.addAll(c);
0677: fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
0678: } catch (UnsupportedOperationException e) {
0679: // Expected
0680: }
0681:
0682: enumSizeMap.put(Size.Big, null);
0683: assertEquals("Wrong size", 2, set.size()); //$NON-NLS-1$
0684: assertTrue("Should return true", set.retainAll(c)); //$NON-NLS-1$
0685: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0686: assertFalse("Should return false", set.retainAll(c)); //$NON-NLS-1$
0687: assertEquals(1, set.size());
0688: Object[] array = set.toArray();
0689: assertEquals("Wrong length", 1, array.length); //$NON-NLS-1$
0690: assertEquals("Wrong key", Size.Big, array[0]); //$NON-NLS-1$
0691:
0692: enumSizeMap = new EnumMap(Size.class);
0693: enumSizeMap.put(Size.Middle, 1);
0694: enumSizeMap.put(Size.Big, null);
0695: set = enumSizeMap.keySet();
0696: c = new ArrayList();
0697: c.add(Color.Blue);
0698: assertFalse("Should return false", set.remove(c)); //$NON-NLS-1$
0699: assertEquals("Wrong size", 2, set.size()); //$NON-NLS-1$
0700: assertTrue("Should return true", set.retainAll(c)); //$NON-NLS-1$
0701: assertEquals("Wrong size", 0, set.size()); //$NON-NLS-1$
0702:
0703: enumSizeMap = new EnumMap(Size.class);
0704: enumSizeMap.put(Size.Middle, 1);
0705: enumSizeMap.put(Size.Big, null);
0706: set = enumSizeMap.keySet();
0707:
0708: Iterator iter = set.iterator();
0709: Enum enumKey = (Enum) iter.next();
0710: assertTrue(
0711: "Returned false for contained object", set.contains(enumKey)); //$NON-NLS-1$
0712: enumKey = (Enum) iter.next();
0713: assertTrue(
0714: "Returned false for contained object", set.contains(enumKey)); //$NON-NLS-1$
0715:
0716: enumSizeMap.remove(Size.Big);
0717: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0718: .contains(enumKey));
0719: iter.remove();
0720: try {
0721: iter.remove();
0722: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0723: } catch (IllegalStateException e) {
0724: // Expected
0725: }
0726: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0727: .contains(enumKey));
0728:
0729: iter = set.iterator();
0730: enumKey = (Enum) iter.next();
0731: assertTrue(
0732: "Returned false for contained object", set.contains(enumKey)); //$NON-NLS-1$
0733: enumSizeMap.put(Size.Middle, 3);
0734: assertTrue(
0735: "Returned false for contained object", set.contains(enumKey)); //$NON-NLS-1$
0736:
0737: enumSizeMap = new EnumMap(Size.class);
0738: enumSizeMap.put(Size.Middle, 1);
0739: enumSizeMap.put(Size.Big, null);
0740: set = enumSizeMap.keySet();
0741: iter = set.iterator();
0742: try {
0743: iter.remove();
0744: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0745: } catch (IllegalStateException e) {
0746: // Expected
0747: }
0748: enumKey = (Enum) iter.next();
0749: assertEquals("Wrong key", Size.Middle, enumKey); //$NON-NLS-1$
0750: assertSame("Wrong key", Size.Middle, enumKey); //$NON-NLS-1$
0751: assertFalse(
0752: "Returned true for unequal object", iter.equals(enumKey)); //$NON-NLS-1$
0753: iter.remove();
0754: assertFalse("Returned true for uncontained object", set //$NON-NLS-1$
0755: .contains(enumKey));
0756: try {
0757: iter.remove();
0758: fail("Should throw IllegalStateException"); //$NON-NLS-1$
0759: } catch (IllegalStateException e) {
0760: // Expected
0761: }
0762:
0763: assertEquals("Wrong size", 1, set.size()); //$NON-NLS-1$
0764: enumKey = (Enum) iter.next();
0765: assertEquals("Wrong key", Size.Big, enumKey); //$NON-NLS-1$
0766: iter.remove();
0767: try {
0768: iter.next();
0769: fail("Should throw NoSuchElementException"); //$NON-NLS-1$
0770: } catch (NoSuchElementException e) {
0771: // Expected
0772: }
0773: }
0774:
0775: /**
0776: * @tests java.util.EnumMap#get(Object)
0777: */
0778: @SuppressWarnings({"unchecked","boxing"})
0779: public void test_getLjava_lang_Object() {
0780: EnumMap enumSizeMap = new EnumMap(Size.class);
0781: assertNull(
0782: "Get returned non-null for non mapped key", enumSizeMap //$NON-NLS-1$
0783: .get(Size.Big));
0784: enumSizeMap.put(Size.Big, 1);
0785: assertEquals("Get returned incorrect value for given key", 1, //$NON-NLS-1$
0786: enumSizeMap.get(Size.Big));
0787:
0788: assertNull(
0789: "Get returned non-null for non mapped key", enumSizeMap //$NON-NLS-1$
0790: .get(Size.Small));
0791: assertNull(
0792: "Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
0793: .get(Color.Red));
0794: assertNull(
0795: "Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
0796: .get(new Integer(1)));
0797: assertNull(
0798: "Get returned non-null for non existent key", enumSizeMap //$NON-NLS-1$
0799: .get(null));
0800:
0801: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
0802: assertNull(
0803: "Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
0804: .get(Color.Green));
0805: enumColorMap.put(Color.Green, 2);
0806: assertEquals("Get returned incorrect value for given key", 2, //$NON-NLS-1$
0807: enumColorMap.get(Color.Green));
0808: assertNull(
0809: "Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
0810: .get(Color.Blue));
0811:
0812: enumColorMap.put(Color.Green, new Double(4));
0813: assertEquals("Get returned incorrect value for given key", //$NON-NLS-1$
0814: new Double(4), enumColorMap.get(Color.Green));
0815: enumColorMap.put(Color.Green, new Integer("3"));//$NON-NLS-1$
0816: assertEquals(
0817: "Get returned incorrect value for given key", new Integer( //$NON-NLS-1$
0818: "3"), enumColorMap.get(Color.Green));//$NON-NLS-1$
0819: enumColorMap.put(Color.Green, null);
0820: assertNull(
0821: "Can not handle null value", enumColorMap.get(Color.Green)); //$NON-NLS-1$
0822: Float f = new Float("3.4");//$NON-NLS-1$
0823: enumColorMap.put(Color.Green, f);
0824: assertSame("Get returned incorrect value for given key", f, //$NON-NLS-1$
0825: enumColorMap.get(Color.Green));
0826: }
0827:
0828: /**
0829: * @tests java.util.EnumMap#put(Object,Object)
0830: */
0831: @SuppressWarnings({"unchecked","boxing"})
0832: public void test_putLjava_lang_ObjectLjava_lang_Object() {
0833: EnumMap enumSizeMap = new EnumMap(Size.class);
0834: try {
0835: enumSizeMap.put(Color.Red, 2);
0836: fail("Expected ClassCastException"); //$NON-NLS-1$
0837: } catch (ClassCastException e) {
0838: // Expected
0839: }
0840: assertNull(
0841: "Return non-null for non mapped key", enumSizeMap.put( //$NON-NLS-1$
0842: Size.Small, 1));
0843:
0844: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
0845: try {
0846: enumColorMap.put(Size.Big, 2);
0847: fail("Expected ClassCastException"); //$NON-NLS-1$
0848: } catch (ClassCastException e) {
0849: // Expected
0850: }
0851: try {
0852: enumColorMap.put(null, 2);
0853: fail("Expected NullPointerException"); //$NON-NLS-1$
0854: } catch (NullPointerException e) {
0855: // Expected
0856: }
0857: assertNull(
0858: "Return non-null for non mapped key", enumColorMap.put( //$NON-NLS-1$
0859: Color.Green, 2));
0860: assertEquals(
0861: "Return wrong value", 2, enumColorMap.put(Color.Green, //$NON-NLS-1$
0862: new Double(4)));
0863: assertEquals(
0864: "Return wrong value", new Double(4), enumColorMap.put( //$NON-NLS-1$
0865: Color.Green, new Integer("3")));//$NON-NLS-1$
0866: assertEquals(
0867: "Return wrong value", new Integer("3"), enumColorMap.put( //$NON-NLS-1$//$NON-NLS-2$
0868: Color.Green, null));
0869: Float f = new Float("3.4");//$NON-NLS-1$
0870: assertNull(
0871: "Return non-null for non mapped key", enumColorMap.put( //$NON-NLS-1$
0872: Color.Green, f));
0873: assertNull(
0874: "Return non-null for non mapped key", enumColorMap.put( //$NON-NLS-1$
0875: Color.Blue, 2));
0876: assertEquals(
0877: "Return wrong value", 2, enumColorMap.put(Color.Blue, //$NON-NLS-1$
0878: new Double(4)));
0879: }
0880:
0881: /**
0882: * @tests java.util.EnumMap#putAll(Map)
0883: */
0884: @SuppressWarnings({"unchecked","boxing"})
0885: public void test_putAllLjava_util_Map() {
0886: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
0887: enumColorMap.put(Color.Green, 2);
0888:
0889: EnumMap enumSizeMap = new EnumMap(Size.class);
0890: enumColorMap.putAll(enumSizeMap);
0891:
0892: enumSizeMap.put(Size.Big, 1);
0893: try {
0894: enumColorMap.putAll(enumSizeMap);
0895: fail("Expected ClassCastException"); //$NON-NLS-1$
0896: } catch (ClassCastException e) {
0897: // Expected
0898: }
0899:
0900: EnumMap enumColorMap1 = new EnumMap<Color, Double>(Color.class);
0901: enumColorMap1.put(Color.Blue, 3);
0902: enumColorMap.putAll(enumColorMap1);
0903: assertEquals("Get returned incorrect value for given key", 3, //$NON-NLS-1$
0904: enumColorMap.get(Color.Blue));
0905: assertEquals("Wrong Size", 2, enumColorMap.size()); //$NON-NLS-1$
0906:
0907: enumColorMap = new EnumMap<Color, Double>(Color.class);
0908:
0909: HashMap hashColorMap = null;
0910: try {
0911: enumColorMap.putAll(hashColorMap);
0912: fail("Expected NullPointerException"); //$NON-NLS-1$
0913: } catch (NullPointerException e) {
0914: // Expected
0915: }
0916:
0917: hashColorMap = new HashMap();
0918: enumColorMap.putAll(hashColorMap);
0919:
0920: hashColorMap.put(Color.Green, 2);
0921: enumColorMap.putAll(hashColorMap);
0922: assertEquals("Get returned incorrect value for given key", 2, //$NON-NLS-1$
0923: enumColorMap.get(Color.Green));
0924: assertNull(
0925: "Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
0926: .get(Color.Red));
0927: hashColorMap.put(Color.Red, new Integer(1));
0928: enumColorMap.putAll(hashColorMap);
0929: assertEquals(
0930: "Get returned incorrect value for given key", new Integer(//$NON-NLS-1$
0931: 2), enumColorMap.get(Color.Green));
0932: hashColorMap.put(Size.Big, 3);
0933: try {
0934: enumColorMap.putAll(hashColorMap);
0935: fail("Expected ClassCastException"); //$NON-NLS-1$
0936: } catch (ClassCastException e) {
0937: // Expected
0938: }
0939:
0940: hashColorMap = new HashMap();
0941: hashColorMap.put(new Integer(1), 1);
0942: try {
0943: enumColorMap.putAll(hashColorMap);
0944: fail("Expected ClassCastException"); //$NON-NLS-1$
0945: } catch (ClassCastException e) {
0946: // Expected
0947: }
0948: }
0949:
0950: /**
0951: * @tests java.util.EnumMap#remove(Object)
0952: */
0953: @SuppressWarnings({"unchecked","boxing"})
0954: public void test_removeLjava_lang_Object() {
0955: EnumMap enumSizeMap = new EnumMap(Size.class);
0956: assertNull(
0957: "Remove of non-mapped key returned non-null", enumSizeMap //$NON-NLS-1$
0958: .remove(Size.Big));
0959: enumSizeMap.put(Size.Big, 3);
0960: enumSizeMap.put(Size.Middle, 2);
0961:
0962: assertNull(
0963: "Get returned non-null for non mapped key", enumSizeMap //$NON-NLS-1$
0964: .get(Size.Small));
0965: assertEquals("Remove returned incorrect value", 3, enumSizeMap //$NON-NLS-1$
0966: .remove(Size.Big));
0967: assertNull(
0968: "Get returned non-null for non mapped key", enumSizeMap //$NON-NLS-1$
0969: .get(Size.Big));
0970: assertNull(
0971: "Remove of non-mapped key returned non-null", enumSizeMap //$NON-NLS-1$
0972: .remove(Size.Big));
0973: assertNull(
0974: "Remove of non-existent key returned non-null", enumSizeMap //$NON-NLS-1$
0975: .remove(Color.Red));
0976: assertNull(
0977: "Remove of non-existent key returned non-null", enumSizeMap //$NON-NLS-1$
0978: .remove(new Double(4)));
0979: assertNull(
0980: "Remove of non-existent key returned non-null", enumSizeMap //$NON-NLS-1$
0981: .remove(null));
0982:
0983: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
0984: assertNull(
0985: "Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
0986: .get(Color.Green));
0987: enumColorMap.put(Color.Green, new Double(4));
0988: assertEquals("Remove returned incorrect value", new Double(4), //$NON-NLS-1$
0989: enumColorMap.remove(Color.Green));
0990: assertNull(
0991: "Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
0992: .get(Color.Green));
0993: enumColorMap.put(Color.Green, null);
0994: assertNull("Can not handle null value", enumColorMap //$NON-NLS-1$
0995: .remove(Color.Green));
0996: assertNull(
0997: "Get returned non-null for non mapped key", enumColorMap //$NON-NLS-1$
0998: .get(Color.Green));
0999: }
1000:
1001: /**
1002: * @tests java.util.EnumMap#size()
1003: */
1004: @SuppressWarnings({"unchecked","boxing"})
1005: public void test_size() {
1006: EnumMap enumSizeMap = new EnumMap(Size.class);
1007: assertEquals("Wrong size", 0, enumSizeMap.size()); //$NON-NLS-1$
1008: enumSizeMap.put(Size.Small, 1);
1009: assertEquals("Wrong size", 1, enumSizeMap.size()); //$NON-NLS-1$
1010: enumSizeMap.put(Size.Small, 0);
1011: assertEquals("Wrong size", 1, enumSizeMap.size()); //$NON-NLS-1$
1012: try {
1013: enumSizeMap.put(Color.Red, 2);
1014: fail("Expected ClassCastException"); //$NON-NLS-1$
1015: } catch (ClassCastException e) {
1016: // Expected
1017: }
1018: assertEquals("Wrong size", 1, enumSizeMap.size()); //$NON-NLS-1$
1019:
1020: enumSizeMap.put(Size.Middle, null);
1021: assertEquals("Wrong size", 2, enumSizeMap.size()); //$NON-NLS-1$
1022: enumSizeMap.remove(Size.Big);
1023: assertEquals("Wrong size", 2, enumSizeMap.size()); //$NON-NLS-1$
1024: enumSizeMap.remove(Size.Middle);
1025: assertEquals("Wrong size", 1, enumSizeMap.size()); //$NON-NLS-1$
1026: enumSizeMap.remove(Color.Green);
1027: assertEquals("Wrong size", 1, enumSizeMap.size()); //$NON-NLS-1$
1028:
1029: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
1030: enumColorMap.put(Color.Green, 2);
1031: assertEquals("Wrong size", 1, enumColorMap.size()); //$NON-NLS-1$
1032: enumColorMap.remove(Color.Green);
1033: assertEquals("Wrong size", 0, enumColorMap.size()); //$NON-NLS-1$
1034:
1035: EnumMap enumEmptyMap = new EnumMap<Empty, Double>(Empty.class);
1036: assertEquals("Wrong size", 0, enumEmptyMap.size()); //$NON-NLS-1$
1037: }
1038:
1039: /**
1040: * @tests java.util.EnumMap#values()
1041: */
1042: @SuppressWarnings({"unchecked","boxing"})
1043: public void test_values() {
1044: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
1045: enumColorMap.put(Color.Red, 1);
1046: enumColorMap.put(Color.Blue, null);
1047: Collection collection = enumColorMap.values();
1048:
1049: Collection collection1 = enumColorMap.values();
1050: assertSame("Should be same", collection1, collection); //$NON-NLS-1$
1051: try {
1052: collection.add(new Integer(1));
1053: fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
1054: } catch (UnsupportedOperationException e) {
1055: // Expected
1056: }
1057:
1058: assertTrue("Returned false for contained object", collection//$NON-NLS-1$
1059: .contains(1));
1060: assertTrue("Returned false for contained object", collection//$NON-NLS-1$
1061: .contains(null));
1062: assertFalse("Returned true for uncontained object", collection //$NON-NLS-1$
1063: .contains(2));
1064:
1065: assertTrue(
1066: "Returned false when the object can be removed", collection //$NON-NLS-1$
1067: .remove(null));
1068: assertFalse("Returned true for uncontained object", collection //$NON-NLS-1$
1069: .contains(null));
1070: assertFalse("Returned true when the object can not be removed", //$NON-NLS-1$
1071: collection.remove(null));
1072:
1073: // The set is backed by the map so changes to one are reflected by the
1074: // other.
1075: enumColorMap.put(Color.Blue, 3);
1076: assertTrue("Returned false for contained object", collection//$NON-NLS-1$
1077: .contains(3));
1078: enumColorMap.remove(Color.Blue);
1079: assertFalse("Returned true for uncontained object", collection//$NON-NLS-1$
1080: .contains(3));
1081:
1082: assertEquals("Wrong size", 1, collection.size()); //$NON-NLS-1$
1083: collection.clear();
1084: assertEquals("Wrong size", 0, collection.size()); //$NON-NLS-1$
1085:
1086: enumColorMap = new EnumMap<Color, Double>(Color.class);
1087: enumColorMap.put(Color.Red, 1);
1088: enumColorMap.put(Color.Blue, null);
1089: collection = enumColorMap.values();
1090: Collection c = new ArrayList();
1091: c.add(new Integer(1));
1092: assertTrue("Should return true", collection.containsAll(c)); //$NON-NLS-1$
1093: c.add(new Double(3.4));
1094: assertFalse("Should return false", collection.containsAll(c)); //$NON-NLS-1$
1095: assertTrue("Should return true", collection.removeAll(c)); //$NON-NLS-1$
1096: assertEquals("Wrong size", 1, collection.size()); //$NON-NLS-1$
1097: assertFalse("Should return false", collection.removeAll(c)); //$NON-NLS-1$
1098: assertEquals("Wrong size", 1, collection.size()); //$NON-NLS-1$
1099: try {
1100: collection.addAll(c);
1101: fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
1102: } catch (UnsupportedOperationException e) {
1103: // Expected
1104: }
1105:
1106: enumColorMap.put(Color.Red, 1);
1107: assertEquals("Wrong size", 2, collection.size()); //$NON-NLS-1$
1108: assertTrue("Should return true", collection.retainAll(c)); //$NON-NLS-1$
1109: assertEquals("Wrong size", 1, collection.size()); //$NON-NLS-1$
1110: assertFalse("Should return false", collection.retainAll(c)); //$NON-NLS-1$
1111: assertEquals(1, collection.size());
1112: Object[] array = collection.toArray();
1113: assertEquals("Wrong length", 1, array.length); //$NON-NLS-1$
1114: assertEquals("Wrong key", 1, array[0]); //$NON-NLS-1$
1115:
1116: enumColorMap = new EnumMap<Color, Double>(Color.class);
1117: enumColorMap.put(Color.Red, 1);
1118: enumColorMap.put(Color.Blue, null);
1119: collection = enumColorMap.values();
1120:
1121: assertEquals("Wrong size", 2, collection.size()); //$NON-NLS-1$
1122: assertFalse("Returned true when the object can not be removed", //$NON-NLS-1$
1123: collection.remove(new Integer("10"))); //$NON-NLS-1$
1124:
1125: Iterator iter = enumColorMap.values().iterator();
1126: Object value = iter.next();
1127: assertTrue("Returned false for contained object", collection //$NON-NLS-1$
1128: .contains(value));
1129: value = iter.next();
1130: assertTrue("Returned false for contained object", collection //$NON-NLS-1$
1131: .contains(value));
1132:
1133: enumColorMap.put(Color.Green, 1);
1134: enumColorMap.remove(Color.Blue);
1135: assertFalse("Returned true for uncontained object", collection //$NON-NLS-1$
1136: .contains(value));
1137: iter.remove();
1138: try {
1139: iter.remove();
1140: fail("Should throw IllegalStateException"); //$NON-NLS-1$
1141: } catch (IllegalStateException e) {
1142: // Expected
1143: }
1144: assertFalse("Returned true for uncontained object", collection //$NON-NLS-1$
1145: .contains(value));
1146:
1147: iter = enumColorMap.values().iterator();
1148: value = iter.next();
1149: assertTrue("Returned false for contained object", collection //$NON-NLS-1$
1150: .contains(value));
1151: enumColorMap.put(Color.Green, 3);
1152: assertTrue("Returned false for contained object", collection //$NON-NLS-1$
1153: .contains(value));
1154: assertTrue("Returned false for contained object", collection //$NON-NLS-1$
1155: .remove(new Integer("1"))); //$NON-NLS-1$
1156: assertEquals("Wrong size", 1, collection.size()); //$NON-NLS-1$
1157: collection.clear();
1158: assertEquals("Wrong size", 0, collection.size()); //$NON-NLS-1$
1159:
1160: enumColorMap = new EnumMap<Color, Double>(Color.class);
1161: Integer integer1 = new Integer(1);
1162: enumColorMap.put(Color.Green, integer1);
1163: enumColorMap.put(Color.Blue, null);
1164: collection = enumColorMap.values();
1165: iter = enumColorMap.values().iterator();
1166: try {
1167: iter.remove();
1168: fail("Should throw IllegalStateException"); //$NON-NLS-1$
1169: } catch (IllegalStateException e) {
1170: // Expected
1171: }
1172: value = iter.next();
1173: assertEquals("Wrong value", integer1, value); //$NON-NLS-1$
1174: assertSame("Wrong value", integer1, value); //$NON-NLS-1$
1175: assertFalse(
1176: "Returned true for unequal object", iter.equals(value)); //$NON-NLS-1$
1177: iter.remove();
1178: assertFalse(
1179: "Returned true for unequal object", iter.equals(value)); //$NON-NLS-1$
1180: try {
1181: iter.remove();
1182: fail("Should throw IllegalStateException"); //$NON-NLS-1$
1183: } catch (IllegalStateException e) {
1184: // Expected
1185: }
1186: assertEquals("Wrong size", 1, collection.size()); //$NON-NLS-1$
1187: value = iter.next();
1188: assertFalse(
1189: "Returned true for unequal object", iter.equals(value)); //$NON-NLS-1$
1190: iter.remove();
1191: try {
1192: iter.next();
1193: fail("Should throw NoSuchElementException"); //$NON-NLS-1$
1194: } catch (NoSuchElementException e) {
1195: // Expected
1196: }
1197: }
1198:
1199: /**
1200: * @tests serialization/deserialization.
1201: */
1202: @SuppressWarnings({"unchecked","boxing"})
1203: public void testSerializationSelf() throws Exception {
1204: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
1205: enumColorMap.put(Color.Blue, 3);
1206: SerializationTest.verifySelf(enumColorMap);
1207: }
1208:
1209: /**
1210: * @tests serialization/deserialization compatibility with RI.
1211: */
1212: @SuppressWarnings({"unchecked","boxing"})
1213: public void testSerializationCompatibility() throws Exception {
1214: EnumMap enumColorMap = new EnumMap<Color, Double>(Color.class);
1215: enumColorMap.put(Color.Red, 1);
1216: enumColorMap.put(Color.Blue, 3);
1217: SerializationTest.verifyGolden(this, enumColorMap);
1218: }
1219: }
|