Java tutorial
/* * Copyright 2008 Google Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in compliance with the License. You may obtain a copy of * the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations under * the License. */ package com.google.gwt.emultest.java.util; import org.apache.commons.collections.TestMap; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.NoSuchElementException; import java.util.Set; /** * Tests <code>HashMap</code>. */ public class HashMapTest extends TestMap { private static final int CAPACITY_16 = 16; private static final int CAPACITY_NEG_ONE_HALF = -1; private static final int CAPACITY_ZERO = 0; private static final Integer INTEGER_1 = new Integer(1); private static final Integer INTEGER_11 = new Integer(11); private static final Integer INTEGER_2 = new Integer(2); private static final Integer INTEGER_22 = new Integer(22); private static final Integer INTEGER_3 = new Integer(3); private static final Integer INTEGER_33 = new Integer(33); private static final Integer INTEGER_ZERO_KEY = new Integer(0); private static final String INTEGER_ZERO_VALUE = "integer zero"; private static final String KEY_1 = "key1"; private static final String KEY_2 = "key2"; private static final String KEY_3 = "key3"; private static final String KEY_4 = "key4"; private static final String KEY_KEY = "key"; private static final String KEY_TEST_CONTAINS_KEY = "testContainsKey"; private static final String KEY_TEST_CONTAINS_VALUE = "testContainsValue"; private static final String KEY_TEST_ENTRY_SET = "testEntrySet"; private static final String KEY_TEST_GET = "testGet"; private static final String KEY_TEST_KEY_SET = "testKeySet"; private static final String KEY_TEST_PUT = "testPut"; private static final String KEY_TEST_REMOVE = "testRemove"; private static final float LOAD_FACTOR_NEG_ONE = -1.0F; private static final float LOAD_FACTOR_ONE_HALF = 0.5F; private static final float LOAD_FACTOR_ONE_TENTH = 0.1F; private static final float LOAD_FACTOR_ZERO = 0.0F; private static final Object ODD_ZERO_KEY = new Object() { @Override public int hashCode() { return 0; } }; private static final String ODD_ZERO_VALUE = "odd zero"; private static final int SIZE_ONE = 1; private static final int SIZE_THREE = 3; private static final int SIZE_TWO = 2; private static final int SIZE_ZERO = 0; private static final String STRING_ZERO_KEY = "0"; private static final String STRING_ZERO_VALUE = "string zero"; private static final String VALUE_1 = "val1"; private static final String VALUE_2 = "val2"; private static final String VALUE_3 = "val3"; private static final String VALUE_4 = "val4"; private static final String VALUE_TEST_CONTAINS_DOES_NOT_EXIST = "does not exist"; private static final Integer VALUE_TEST_CONTAINS_KEY = new Integer(5); private static final String VALUE_TEST_ENTRY_SET_1 = KEY_TEST_ENTRY_SET + " - value1"; private static final String VALUE_TEST_ENTRY_SET_2 = KEY_TEST_ENTRY_SET + " - value2"; private static final String VALUE_TEST_GET = KEY_TEST_GET + " - Value"; private static final String VALUE_TEST_KEY_SET = KEY_TEST_KEY_SET + " - value"; private static final String VALUE_TEST_PUT_1 = KEY_TEST_PUT + " - value 1"; private static final String VALUE_TEST_PUT_2 = KEY_TEST_PUT + " - value 2"; private static final String VALUE_TEST_REMOVE = KEY_TEST_REMOVE + " - value"; private static final String VALUE_VAL = "value"; private static void assertEmptyIterator(Iterator<?> it) { assertNotNull(it); assertFalse(it.hasNext()); try { it.next(); fail("Expected NoSuchElementException"); } catch (NoSuchElementException expected) { } } /** * Check the state of a newly constructed, empty HashMap. * * @param hashMap */ private static void checkEmptyHashMapAssumptions(HashMap<?, ?> hashMap) { assertNotNull(hashMap); assertTrue(hashMap.isEmpty()); assertNotNull(hashMap.values()); assertTrue(hashMap.values().isEmpty()); assertTrue(hashMap.values().size() == 0); assertNotNull(hashMap.keySet()); assertTrue(hashMap.keySet().isEmpty()); assertTrue(hashMap.keySet().size() == 0); assertNotNull(hashMap.entrySet()); assertTrue(hashMap.entrySet().isEmpty()); assertTrue(hashMap.entrySet().size() == 0); assertEmptyIterator(hashMap.entrySet().iterator()); } @Override public String getModuleName() { return "com.google.gwt.emultest.EmulSuite"; } public void testAddEqualKeys() { final HashMap<Number, Object> expected = new HashMap<Number, Object>(); assertEquals(expected.size(), 0); iterateThrough(expected); expected.put(new Long(45), new Object()); assertEquals(expected.size(), 1); iterateThrough(expected); expected.put(new Integer(45), new Object()); assertNotSame(new Integer(45), new Long(45)); assertEquals(expected.size(), 2); iterateThrough(expected); } public void testAddWatch() { HashMap<String, String> m = new HashMap<String, String>(); m.put("watch", "watch"); assertEquals(m.get("watch"), "watch"); } /* * Test method for 'java.util.HashMap.clear()' */ public void testClear() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); hashMap.put("Hello", "Bye"); assertFalse(hashMap.isEmpty()); assertTrue(hashMap.size() == SIZE_ONE); hashMap.clear(); assertTrue(hashMap.isEmpty()); assertTrue(hashMap.size() == 0); } /* * Test method for 'java.util.HashMap.clone()' */ public void testClone() { HashMap<String, String> srcMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(srcMap); HashMap<String, String> dstMap = cloneMap(srcMap); assertNotNull(dstMap); assertEquals(dstMap.size(), srcMap.size()); // assertTrue(dstMap.values().toArray().equals(srcMap.values().toArray())); assertTrue(dstMap.keySet().equals(srcMap.keySet())); assertTrue(dstMap.entrySet().equals(srcMap.entrySet())); // Check non-empty clone behavior srcMap.put(KEY_1, VALUE_1); srcMap.put(KEY_2, VALUE_2); srcMap.put(KEY_3, VALUE_3); dstMap = cloneMap(srcMap); assertNotNull(dstMap); assertEquals(dstMap.size(), srcMap.size()); assertTrue(dstMap.keySet().equals(srcMap.keySet())); assertTrue(dstMap.entrySet().equals(srcMap.entrySet())); } /* * Test method for 'java.util.HashMap.containsKey(Object)' */ public void testContainsKey() { HashMap<String, Integer> hashMap = new HashMap<String, Integer>(); checkEmptyHashMapAssumptions(hashMap); assertFalse(hashMap.containsKey(KEY_TEST_CONTAINS_KEY)); hashMap.put(KEY_TEST_CONTAINS_KEY, VALUE_TEST_CONTAINS_KEY); assertTrue(hashMap.containsKey(KEY_TEST_CONTAINS_KEY)); assertFalse(hashMap.containsKey(VALUE_TEST_CONTAINS_DOES_NOT_EXIST)); assertFalse(hashMap.containsKey(null)); hashMap.put(null, VALUE_TEST_CONTAINS_KEY); assertTrue(hashMap.containsKey(null)); } /* * Test method for 'java.util.HashMap.containsValue(Object)' */ public void testContainsValue() { HashMap<String, Integer> hashMap = new HashMap<String, Integer>(); checkEmptyHashMapAssumptions(hashMap); assertFalse("check contains of empty map", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY)); hashMap.put(KEY_TEST_CONTAINS_VALUE, VALUE_TEST_CONTAINS_KEY); assertTrue("check contains of map with element", hashMap.containsValue(VALUE_TEST_CONTAINS_KEY)); assertFalse("check contains of map other element", hashMap.containsValue(VALUE_TEST_CONTAINS_DOES_NOT_EXIST)); assertFalse(hashMap.containsValue(null)); hashMap.put(KEY_TEST_CONTAINS_VALUE, null); assertTrue(hashMap.containsValue(null)); } /* * Test method for 'java.util.HashMap.entrySet()' */ public void testEntrySet() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); Set<Map.Entry<String, String>> entrySet = hashMap.entrySet(); assertNotNull(entrySet); // Check that the entry set looks right hashMap.put(KEY_TEST_ENTRY_SET, VALUE_TEST_ENTRY_SET_1); entrySet = hashMap.entrySet(); assertEquals(entrySet.size(), SIZE_ONE); Iterator<Map.Entry<String, String>> itSet = entrySet.iterator(); Map.Entry<String, String> entry = itSet.next(); assertEquals(entry.getKey(), KEY_TEST_ENTRY_SET); assertEquals(entry.getValue(), VALUE_TEST_ENTRY_SET_1); assertEmptyIterator(itSet); // Check that entries in the entrySet are update correctly on overwrites hashMap.put(KEY_TEST_ENTRY_SET, VALUE_TEST_ENTRY_SET_2); entrySet = hashMap.entrySet(); assertEquals(entrySet.size(), SIZE_ONE); itSet = entrySet.iterator(); entry = itSet.next(); assertEquals(entry.getKey(), KEY_TEST_ENTRY_SET); assertEquals(entry.getValue(), VALUE_TEST_ENTRY_SET_2); assertEmptyIterator(itSet); // Check that entries are updated on removes hashMap.remove(KEY_TEST_ENTRY_SET); checkEmptyHashMapAssumptions(hashMap); } /* * Used to test the entrySet entry's set method. */ public void testEntrySetEntrySetterNonString() { HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>(); hashMap.put(1, 2); Set<Map.Entry<Integer, Integer>> entrySet = hashMap.entrySet(); Map.Entry<Integer, Integer> entry = entrySet.iterator().next(); entry.setValue(3); assertEquals(3, hashMap.get(1).intValue()); hashMap.put(1, 4); assertEquals(4, entry.getValue().intValue()); assertEquals(1, hashMap.size()); } /* * Used to test the entrySet entry's set method. */ public void testEntrySetEntrySetterNull() { HashMap<String, Integer> hashMap = new HashMap<String, Integer>(); hashMap.put(null, 2); Set<Map.Entry<String, Integer>> entrySet = hashMap.entrySet(); Map.Entry<String, Integer> entry = entrySet.iterator().next(); entry.setValue(3); assertEquals(3, hashMap.get(null).intValue()); hashMap.put(null, 4); assertEquals(4, entry.getValue().intValue()); assertEquals(1, hashMap.size()); } /* * Used to test the entrySet entry's set method. */ public void testEntrySetEntrySetterString() { HashMap<String, String> hashMap = new HashMap<String, String>(); hashMap.put("A", "B"); Set<Map.Entry<String, String>> entrySet = hashMap.entrySet(); Map.Entry<String, String> entry = entrySet.iterator().next(); entry.setValue("C"); assertEquals("C", hashMap.get("A")); hashMap.put("A", "D"); assertEquals("D", entry.getValue()); assertEquals(1, hashMap.size()); } /* * Used to test the entrySet remove method. */ public void testEntrySetRemove() { HashMap<String, String> hashMap = new HashMap<String, String>(); hashMap.put("A", "B"); HashMap<String, String> dummy = new HashMap<String, String>(); dummy.put("A", "b"); Map.Entry<String, String> bogus = dummy.entrySet().iterator().next(); Set<Map.Entry<String, String>> entrySet = hashMap.entrySet(); boolean removed = entrySet.remove(bogus); assertEquals(removed, false); assertEquals(hashMap.get("A"), "B"); } /* * Test method for 'java.util.AbstractMap.equals(Object)' */ public void testEquals() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); hashMap.put(KEY_KEY, VALUE_VAL); HashMap<String, String> copyMap = cloneMap(hashMap); assertTrue(hashMap.equals(copyMap)); hashMap.put(VALUE_VAL, KEY_KEY); assertFalse(hashMap.equals(copyMap)); } @SuppressWarnings("unchecked") private HashMap<String, String> cloneMap(HashMap<String, String> hashMap) { return (HashMap<String, String>) hashMap.clone(); } /* * Test method for 'java.lang.Object.finalize()'. */ public void testFinalize() { // no tests for finalize } /* * Test method for 'java.util.HashMap.get(Object)'. */ public void testGet() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); assertNull(hashMap.get(KEY_TEST_GET)); hashMap.put(KEY_TEST_GET, VALUE_TEST_GET); assertNotNull(hashMap.get(KEY_TEST_GET)); assertNull(hashMap.get(null)); hashMap.put(null, VALUE_TEST_GET); assertNotNull(hashMap.get(null)); hashMap.put(null, null); assertNull(hashMap.get(null)); } /* * Test method for 'java.util.AbstractMap.hashCode()'. */ public void testHashCode() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); // Check that hashCode changes int hashCode1 = hashMap.hashCode(); hashMap.put(KEY_KEY, VALUE_VAL); int hashCode2 = hashMap.hashCode(); assertTrue(hashCode1 != hashCode2); } /* * Test method for 'java.util.HashMap.HashMap()'. */ public void testHashMap() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); } /* * Test method for 'java.util.HashMap.HashMap(int)' */ public void testHashMapInt() { HashMap<String, String> hashMap = new HashMap<String, String>(CAPACITY_16); checkEmptyHashMapAssumptions(hashMap); // TODO(mmendez): how do we verify capacity? boolean failed = true; try { new HashMap<String, String>(-SIZE_ONE); } catch (Throwable ex) { if (ex instanceof IllegalArgumentException) { failed = false; } } if (failed) { fail("Failure testing new HashMap(-1)"); } HashMap<String, String> zeroSizedHashMap = new HashMap<String, String>(0); assertNotNull(zeroSizedHashMap); } /* * Test method for 'java.util.HashMap.HashMap(int, float)' */ public void testHashMapIntFloat() { HashMap<String, String> hashMap = new HashMap<String, String>(CAPACITY_16, LOAD_FACTOR_ONE_HALF); checkEmptyHashMapAssumptions(hashMap); // TODO(mmendez): how do we verify capacity and load factor? // Test new HashMap(-1, 0.0F) boolean failed = true; try { new HashMap<String, String>(CAPACITY_NEG_ONE_HALF, LOAD_FACTOR_ZERO); } catch (Throwable ex) { if (ex instanceof IllegalArgumentException) { failed = false; } } if (failed) { fail("Failure testing new HashMap(-1, 0.0F)"); } // Test new HashMap(0, -1.0F) failed = true; try { new HashMap<String, String>(CAPACITY_ZERO, LOAD_FACTOR_NEG_ONE); } catch (Throwable ex) { if (ex instanceof IllegalArgumentException) { failed = false; } } if (failed) { fail("Failure testing new HashMap(0, -1.0F)"); } // Test new HashMap(0,0F); hashMap = new HashMap<String, String>(CAPACITY_ZERO, LOAD_FACTOR_ONE_TENTH); assertNotNull(hashMap); } /* * Test method for 'java.util.HashMap.HashMap(Map)' */ public void testHashMapMap() { HashMap<Integer, Integer> srcMap = new HashMap<Integer, Integer>(); assertNotNull(srcMap); checkEmptyHashMapAssumptions(srcMap); srcMap.put(INTEGER_1, INTEGER_11); srcMap.put(INTEGER_2, INTEGER_22); srcMap.put(INTEGER_3, INTEGER_33); HashMap<Integer, Integer> hashMap = new HashMap<Integer, Integer>(srcMap); assertFalse(hashMap.isEmpty()); assertTrue(hashMap.size() == SIZE_THREE); Collection<Integer> valColl = hashMap.values(); assertTrue(valColl.contains(INTEGER_11)); assertTrue(valColl.contains(INTEGER_22)); assertTrue(valColl.contains(INTEGER_33)); Collection<Integer> keyColl = hashMap.keySet(); assertTrue(keyColl.contains(INTEGER_1)); assertTrue(keyColl.contains(INTEGER_2)); assertTrue(keyColl.contains(INTEGER_3)); } /* * Test method for 'java.util.AbstractMap.isEmpty()' */ public void testIsEmpty() { HashMap<String, String> srcMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(srcMap); HashMap<String, String> dstMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(dstMap); dstMap.putAll(srcMap); assertTrue(dstMap.isEmpty()); dstMap.put(KEY_KEY, VALUE_VAL); assertFalse(dstMap.isEmpty()); dstMap.remove(KEY_KEY); assertTrue(dstMap.isEmpty()); assertEquals(dstMap.size(), 0); } public void testKeysConflict() { HashMap<Object, String> hashMap = new HashMap<Object, String>(); hashMap.put(STRING_ZERO_KEY, STRING_ZERO_VALUE); hashMap.put(INTEGER_ZERO_KEY, INTEGER_ZERO_VALUE); hashMap.put(ODD_ZERO_KEY, ODD_ZERO_VALUE); assertEquals(hashMap.get(INTEGER_ZERO_KEY), INTEGER_ZERO_VALUE); assertEquals(hashMap.get(ODD_ZERO_KEY), ODD_ZERO_VALUE); assertEquals(hashMap.get(STRING_ZERO_KEY), STRING_ZERO_VALUE); hashMap.remove(INTEGER_ZERO_KEY); assertEquals(hashMap.get(ODD_ZERO_KEY), ODD_ZERO_VALUE); assertEquals(hashMap.get(STRING_ZERO_KEY), STRING_ZERO_VALUE); assertEquals(hashMap.get(INTEGER_ZERO_KEY), null); hashMap.remove(ODD_ZERO_KEY); assertEquals(hashMap.get(INTEGER_ZERO_KEY), null); assertEquals(hashMap.get(ODD_ZERO_KEY), null); assertEquals(hashMap.get(STRING_ZERO_KEY), STRING_ZERO_VALUE); hashMap.remove(STRING_ZERO_KEY); assertEquals(hashMap.get(INTEGER_ZERO_KEY), null); assertEquals(hashMap.get(ODD_ZERO_KEY), null); assertEquals(hashMap.get(STRING_ZERO_KEY), null); assertEquals(hashMap.size(), 0); } /* * Test method for 'java.util.HashMap.keySet()' */ public void testKeySet() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); Set<String> keySet = hashMap.keySet(); assertNotNull(keySet); assertTrue(keySet.isEmpty()); assertTrue(keySet.size() == 0); hashMap.put(KEY_TEST_KEY_SET, VALUE_TEST_KEY_SET); assertTrue(keySet.size() == SIZE_ONE); assertTrue(keySet.contains(KEY_TEST_KEY_SET)); assertFalse(keySet.contains(VALUE_TEST_KEY_SET)); assertFalse(keySet.contains(KEY_TEST_KEY_SET.toUpperCase(Locale.ROOT))); } /* * Test from issue 2499. * The problem was actually in other objects hashCode() function, as * the value was not coerced to an int and therefore parseInt in * AbstractHashMap.addAllHashEntries was failing. This was fixed * both in our JRE classes to ensure int overflow is handled properly * in their hashCode() implementation and in HashMap so that user * objects which don't account for int overflow will still be * handled properly. There is a slight performance penalty, as * the coercion will be done twice, but that should be fixeable with * improved compiler optimization. */ public void testLargeHashCodes() { final int LIST_COUNT = 20; List<Integer> values = new ArrayList<Integer>(LIST_COUNT); for (int n = 0; n < LIST_COUNT; n++) { values.add(n); } Map<List<Integer>, String> testMap = new HashMap<List<Integer>, String>(); testMap.put(values, "test"); int count = 0; for (Map.Entry<List<Integer>, String> entry : testMap.entrySet()) { count++; } assertEquals(testMap.size(), count); } /* * Test method for 'java.util.HashMap.put(Object, Object)' */ public void testPut() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); assertNull(hashMap.put(KEY_TEST_PUT, VALUE_TEST_PUT_1)); assertEquals(hashMap.put(KEY_TEST_PUT, VALUE_TEST_PUT_2), VALUE_TEST_PUT_1); assertNull(hashMap.put(null, VALUE_TEST_PUT_1)); assertEquals(hashMap.put(null, VALUE_TEST_PUT_2), VALUE_TEST_PUT_1); } /** * Test method for 'java.util.HashMap.putAll(Map)'. */ public void testPutAll() { HashMap<String, String> srcMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(srcMap); srcMap.put(KEY_1, VALUE_1); srcMap.put(KEY_2, VALUE_2); srcMap.put(KEY_3, VALUE_3); // Make sure that the data is copied correctly HashMap<String, String> dstMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(dstMap); dstMap.putAll(srcMap); assertEquals(srcMap.size(), dstMap.size()); assertTrue(dstMap.containsKey(KEY_1)); assertTrue(dstMap.containsValue(VALUE_1)); assertFalse(dstMap.containsKey(KEY_1.toUpperCase(Locale.ROOT))); assertFalse(dstMap.containsValue(VALUE_1.toUpperCase(Locale.ROOT))); assertTrue(dstMap.containsKey(KEY_2)); assertTrue(dstMap.containsValue(VALUE_2)); assertFalse(dstMap.containsKey(KEY_2.toUpperCase(Locale.ROOT))); assertFalse(dstMap.containsValue(VALUE_2.toUpperCase(Locale.ROOT))); assertTrue(dstMap.containsKey(KEY_3)); assertTrue(dstMap.containsValue(VALUE_3)); assertFalse(dstMap.containsKey(KEY_3.toUpperCase(Locale.ROOT))); assertFalse(dstMap.containsValue(VALUE_3.toUpperCase(Locale.ROOT))); // Check that an empty map does not blow away the contents of the // destination map HashMap<String, String> emptyMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(emptyMap); dstMap.putAll(emptyMap); assertTrue(dstMap.size() == srcMap.size()); // Check that put all overwrite any existing mapping in the destination map srcMap.put(KEY_1, VALUE_2); srcMap.put(KEY_2, VALUE_3); srcMap.put(KEY_3, VALUE_1); dstMap.putAll(srcMap); assertEquals(dstMap.size(), srcMap.size()); assertEquals(dstMap.get(KEY_1), VALUE_2); assertEquals(dstMap.get(KEY_2), VALUE_3); assertEquals(dstMap.get(KEY_3), VALUE_1); // Check that a putAll does adds data but does not remove it srcMap.put(KEY_4, VALUE_4); dstMap.putAll(srcMap); assertEquals(dstMap.size(), srcMap.size()); assertTrue(dstMap.containsKey(KEY_4)); assertTrue(dstMap.containsValue(VALUE_4)); assertEquals(dstMap.get(KEY_1), VALUE_2); assertEquals(dstMap.get(KEY_2), VALUE_3); assertEquals(dstMap.get(KEY_3), VALUE_1); assertEquals(dstMap.get(KEY_4), VALUE_4); dstMap.putAll(dstMap); } /** * Test method for 'java.util.HashMap.remove(Object)'. */ public void testRemove() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); assertNull(hashMap.remove(null)); hashMap.put(null, VALUE_TEST_REMOVE); assertNotNull(hashMap.remove(null)); hashMap.put(KEY_TEST_REMOVE, VALUE_TEST_REMOVE); assertEquals(hashMap.remove(KEY_TEST_REMOVE), VALUE_TEST_REMOVE); assertNull(hashMap.remove(KEY_TEST_REMOVE)); } /** * Test method for 'java.util.HashMap.size()'. */ public void testSize() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); // Test size behavior on put assertEquals(hashMap.size(), SIZE_ZERO); hashMap.put(KEY_1, VALUE_1); assertEquals(hashMap.size(), SIZE_ONE); hashMap.put(KEY_2, VALUE_2); assertEquals(hashMap.size(), SIZE_TWO); hashMap.put(KEY_3, VALUE_3); assertEquals(hashMap.size(), SIZE_THREE); // Test size behavior on remove hashMap.remove(KEY_1); assertEquals(hashMap.size(), SIZE_TWO); hashMap.remove(KEY_2); assertEquals(hashMap.size(), SIZE_ONE); hashMap.remove(KEY_3); assertEquals(hashMap.size(), SIZE_ZERO); // Test size behavior on putAll hashMap.put(KEY_1, VALUE_1); hashMap.put(KEY_2, VALUE_2); hashMap.put(KEY_3, VALUE_3); HashMap<String, String> srcMap = new HashMap<String, String>(hashMap); hashMap.putAll(srcMap); assertEquals(hashMap.size(), SIZE_THREE); // Test size behavior on clear hashMap.clear(); assertEquals(hashMap.size(), SIZE_ZERO); } /** * Test method for 'java.util.AbstractMap.toString()'. */ public void testToString() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); hashMap.put(KEY_KEY, VALUE_VAL); String entryString = makeEntryString(KEY_KEY, VALUE_VAL); assertTrue(entryString.equals(hashMap.toString())); } /** * Test method for 'java.util.AbstractMap.values()'. */ public void testValues() { HashMap<String, String> hashMap = new HashMap<String, String>(); checkEmptyHashMapAssumptions(hashMap); assertNotNull(hashMap.values()); hashMap.put(KEY_KEY, VALUE_VAL); Collection<String> valColl = hashMap.values(); assertNotNull(valColl); assertEquals(valColl.size(), SIZE_ONE); Iterator<String> itVal = valColl.iterator(); String val = itVal.next(); assertEquals(val, VALUE_VAL); } @SuppressWarnings("rawtypes") @Override protected Map makeEmptyMap() { return new HashMap(); } // see: https://github.com/gwtproject/gwt/issues/9184 public void testIteration_withCollidingHashCodes() { Object firstKey = createObjectWithHashCode(1); Object secondKey = createObjectWithHashCode(1); // make sure we actually have a hash collision for this test assertEquals(firstKey.hashCode(), secondKey.hashCode()); HashMap<Object, String> testMap = new HashMap<>(); testMap.put(firstKey, "one"); testMap.put(secondKey, "two"); Iterator<Object> it = testMap.keySet().iterator(); assertTrue("new iterator should have next", it.hasNext()); Object keyFromMap1 = it.next(); it.remove(); assertTrue("iterator should have next after first removal", it.hasNext()); Object keyFromMap2 = it.next(); it.remove(); assertFalse(it.hasNext()); // since iteration order is not defined for HashMap we need to make this test work with // both outcomes of the iteration if ((firstKey == keyFromMap1 && secondKey == keyFromMap2) || (firstKey == keyFromMap2 && secondKey == keyFromMap1)) { return; } fail("Wrong keys returned in iteration"); } // see: https://github.com/gwtproject/gwt/issues/9184 public void testIteration_withCollidingHashCodesAndFullIteration() { List<Object> keys = new ArrayList<>(); HashMap<Object, String> testMap = new HashMap<>(); for (int i = 0; i < 100; i++) { Object key = createObjectWithHashCode((i + 10) / 10); keys.add(key); testMap.put(key, "" + i); } int expectedSize = keys.size(); for (Iterator<Object> it = testMap.keySet().iterator(); it.hasNext(); expectedSize--) { Object key = it.next(); assertTrue("Unexpected key was returned", keys.contains(key)); keys.remove(key); it.remove(); assertEquals("Map size", expectedSize - 1, testMap.size()); } assertEquals("expected size", 0, expectedSize); assertTrue(testMap.isEmpty()); assertTrue(keys.isEmpty()); } public void testIteration_hasNextThenRemove() { HashMap<Object, String> testMap = new HashMap<>(); testMap.put(createObjectWithHashCode(1), "one"); testMap.put(createObjectWithHashCode(2), "two"); Iterator<Object> it = testMap.keySet().iterator(); it.next(); assertTrue("iterator should have next after first", it.hasNext()); it.remove(); assertTrue("iterator should have next after removal", it.hasNext()); it.next(); it.remove(); assertFalse(it.hasNext()); } private Object createObjectWithHashCode(final int hashCode) { return new Object() { @Override public int hashCode() { return hashCode; } @Override public String toString() { return "" + hashCode; } }; } private void iterateThrough(final HashMap<?, ?> expected) { Iterator<?> iter = expected.entrySet().iterator(); for (int i = 0; i < expected.size(); i++) { iter.next(); } } private String makeEntryString(final String key, final String value) { return "{" + key + "=" + value + "}"; } }