| /******************************************************************************* |
| * Copyright (c) 2013, 2015 Oracle. All rights reserved. |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v1.0, which accompanies this distribution |
| * and is available at http://www.eclipse.org/legal/epl-v10.html. |
| * |
| * Contributors: |
| * Oracle - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.jpt.common.utility.tests.internal.collection; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.ConcurrentModificationException; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedHashMap; |
| import java.util.Map; |
| import java.util.NoSuchElementException; |
| import java.util.Set; |
| import org.eclipse.jpt.common.utility.internal.ArrayTools; |
| import org.eclipse.jpt.common.utility.internal.ObjectTools; |
| import org.eclipse.jpt.common.utility.internal.StringTools; |
| import org.eclipse.jpt.common.utility.internal.collection.CollectionTools; |
| import org.eclipse.jpt.common.utility.internal.collection.TightMap; |
| import org.eclipse.jpt.common.utility.internal.iterator.IteratorTools; |
| import org.eclipse.jpt.common.utility.tests.internal.TestTools; |
| import junit.framework.TestCase; |
| |
| @SuppressWarnings("nls") |
| public class TightMapTests |
| extends TestCase |
| { |
| private TightMap<String, String> map; |
| |
| public TightMapTests(String name) { |
| super(name); |
| } |
| |
| @Override |
| protected void setUp() throws Exception { |
| super.setUp(); |
| this.map = this.buildMap(); |
| } |
| |
| private TightMap<String, String> buildMap() { |
| TightMap<String, String> m = new TightMap<String, String>(); |
| this.populateMap(m); |
| return m; |
| } |
| |
| private void populateMap(Map<? super String, ? super String> m) { |
| m.put(null, "null"); |
| m.put("null", null); |
| m.put("1", "one"); |
| m.put("2", "two"); |
| m.put("3", "three"); |
| m.put("4", "four"); |
| } |
| |
| @Override |
| protected void tearDown() throws Exception { |
| TestTools.clear(this); |
| super.tearDown(); |
| } |
| |
| public void testCtorMap() { |
| Map<String, String> map2 = new HashMap<String, String>(); |
| |
| this.map = new TightMap<String, String>(map2); |
| assertEquals(this.map, map2); |
| } |
| |
| public void testSize() { |
| assertEquals(6, this.map.size()); |
| |
| this.map = new TightMap<String, String>(); |
| assertEquals(0, this.map.size()); |
| } |
| |
| public void testIsEmpty() { |
| assertFalse(this.map.isEmpty()); |
| |
| this.map = new TightMap<String, String>(); |
| assertTrue(this.map.isEmpty()); |
| } |
| |
| public void testContainsValue() { |
| assertTrue(this.map.containsValue("null")); |
| assertTrue(this.map.containsValue(null)); |
| assertTrue(this.map.containsValue("two")); |
| assertFalse(this.map.containsValue("2")); |
| assertFalse(this.map.containsValue("five")); |
| |
| this.map = new TightMap<String, String>(); |
| assertFalse(this.map.containsValue("null")); |
| assertFalse(this.map.containsValue(null)); |
| assertFalse(this.map.containsValue("two")); |
| assertFalse(this.map.containsValue("2")); |
| assertFalse(this.map.containsValue("five")); |
| } |
| |
| public void testContainsKey() { |
| assertTrue(this.map.containsKey("null")); |
| assertTrue(this.map.containsKey(null)); |
| assertFalse(this.map.containsKey("two")); |
| assertTrue(this.map.containsKey("2")); |
| assertFalse(this.map.containsKey("five")); |
| |
| this.map = new TightMap<String, String>(); |
| assertFalse(this.map.containsKey("null")); |
| assertFalse(this.map.containsKey(null)); |
| assertFalse(this.map.containsKey("two")); |
| assertFalse(this.map.containsKey("2")); |
| assertFalse(this.map.containsKey("five")); |
| } |
| |
| public void testGet() { |
| assertEquals(null, this.map.get("null")); |
| assertEquals("null", this.map.get(null)); |
| assertEquals(null, this.map.get("two")); |
| assertEquals("two", this.map.get("2")); |
| assertEquals(null, this.map.get("five")); |
| |
| this.map = new TightMap<String, String>(); |
| assertEquals(null, this.map.get("null")); |
| assertEquals(null, this.map.get(null)); |
| assertEquals(null, this.map.get("two")); |
| assertEquals(null, this.map.get("2")); |
| assertEquals(null, this.map.get("five")); |
| } |
| |
| public void testPut() { |
| assertEquals(null, this.map.put("null", "seven")); |
| assertEquals("seven", this.map.get("null")); |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("null")); |
| assertTrue(this.map.containsValue("seven")); |
| |
| assertEquals("null", this.map.put(null, "eight")); |
| assertEquals("eight", this.map.get(null)); |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey(null)); |
| assertTrue(this.map.containsValue("eight")); |
| |
| assertEquals(null, this.map.put("5", "five")); |
| assertEquals("five", this.map.get("5")); |
| assertEquals(7, this.map.size()); |
| assertTrue(this.map.containsKey("5")); |
| assertTrue(this.map.containsValue("five")); |
| |
| this.map = new TightMap<String, String>(); |
| |
| assertEquals(null, this.map.put("null", "seven")); |
| assertEquals("seven", this.map.get("null")); |
| assertEquals(1, this.map.size()); |
| assertTrue(this.map.containsKey("null")); |
| assertTrue(this.map.containsValue("seven")); |
| |
| assertEquals(null, this.map.put(null, "eight")); |
| assertEquals("eight", this.map.get(null)); |
| assertEquals(2, this.map.size()); |
| assertTrue(this.map.containsKey(null)); |
| assertTrue(this.map.containsValue("eight")); |
| |
| assertEquals(null, this.map.put("5", "five")); |
| assertEquals("five", this.map.get("5")); |
| assertEquals(3, this.map.size()); |
| assertTrue(this.map.containsKey("5")); |
| assertTrue(this.map.containsValue("five")); |
| } |
| |
| public void testRemove() { |
| assertEquals(null, this.map.get("null")); |
| assertTrue(this.map.containsKey("null")); |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsValue(null)); |
| assertEquals(null, this.map.remove("null")); |
| assertEquals(null, this.map.get("null")); |
| assertFalse(this.map.containsKey("null")); |
| assertEquals(5, this.map.size()); |
| assertFalse(this.map.containsValue(null)); |
| |
| assertEquals("null", this.map.get(null)); |
| assertTrue(this.map.containsKey(null)); |
| assertTrue(this.map.containsValue("null")); |
| assertEquals("null", this.map.remove(null)); |
| assertEquals(null, this.map.get(null)); |
| assertFalse(this.map.containsKey(null)); |
| assertEquals(4, this.map.size()); |
| assertFalse(this.map.containsValue("null")); |
| |
| assertEquals("three", this.map.get("3")); |
| assertTrue(this.map.containsKey("3")); |
| assertTrue(this.map.containsValue("three")); |
| assertEquals("three", this.map.remove("3")); |
| assertEquals(null, this.map.get("3")); |
| assertFalse(this.map.containsKey("3")); |
| assertEquals(3, this.map.size()); |
| assertFalse(this.map.containsValue("null")); |
| |
| assertEquals(null, this.map.get("7")); |
| assertFalse(this.map.containsKey("3")); |
| assertFalse(this.map.containsValue("seven")); |
| assertEquals(null, this.map.remove("7")); |
| assertEquals(null, this.map.get("7")); |
| assertFalse(this.map.containsKey("7")); |
| assertEquals(3, this.map.size()); |
| assertFalse(this.map.containsValue("seven")); |
| |
| assertEquals("one", this.map.remove("1")); |
| assertEquals("two", this.map.remove("2")); |
| assertEquals("four", this.map.remove("4")); |
| } |
| |
| public void testPutAll() { |
| assertEquals(6, this.map.size()); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| map2.put("8", "eight"); |
| map2.put("9", "nine"); |
| map2.put("10", "ten"); |
| this.map.putAll(map2); |
| assertEquals(9, this.map.size()); |
| assertEquals("eight", this.map.get("8")); |
| assertEquals("nine", this.map.get("9")); |
| assertEquals("ten", this.map.get("10")); |
| } |
| |
| public void testPutAll_emptyMap() { |
| assertEquals(6, this.map.size()); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.map.putAll(map2); |
| assertEquals(6, this.map.size()); |
| } |
| |
| public void testClear() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("1")); |
| assertEquals("one", this.map.get("1")); |
| this.map.clear(); |
| assertEquals(0, this.map.size()); |
| assertEquals(null, this.map.get("1")); |
| assertFalse(this.map.containsKey("1")); |
| } |
| |
| public void testKeySet_iterator_hasNext() { |
| Set<String> keySet = this.map.keySet(); |
| assertEquals(6, keySet.size()); |
| assertEquals(6, IteratorTools.size(keySet.iterator())); |
| } |
| |
| public void testKeySet_iterator_next1() { |
| Set<String> keySet = this.map.keySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (String entry : map2.keySet()) { |
| assertTrue(IteratorTools.contains(keySet.iterator(), entry)); |
| } |
| } |
| |
| public void testKeySet_iterator_next2() { |
| Set<String> keySet = this.map.keySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<String> keySet2 = map2.keySet(); |
| for (Iterator<String> stream = keySet.iterator(); stream.hasNext(); ) { |
| keySet2.contains(stream.next()); |
| } |
| } |
| |
| public void testKeySet_iterator_next_CME() { |
| Set<String> keySet = this.map.keySet(); |
| Iterator<String> stream = keySet.iterator(); |
| this.map.remove("1"); |
| boolean exCaught = false; |
| try { |
| stream.next(); |
| } catch (ConcurrentModificationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testKeySet_iterator_next_NSEE() { |
| Set<String> keySet = this.map.keySet(); |
| assertEquals(6, keySet.size()); |
| int size = 0; |
| Iterator<String> stream = keySet.iterator(); |
| while (stream.hasNext()) { |
| stream.next(); |
| size++; |
| } |
| assertEquals(6, size); |
| boolean exCaught = false; |
| try { |
| stream.next(); |
| } catch (NoSuchElementException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testKeySet_iterator_remove1() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Set<String> keySet = this.map.keySet(); |
| assertEquals(6, keySet.size()); |
| |
| Iterator<String> stream = keySet.iterator(); |
| assertTrue(stream.hasNext()); |
| String key = stream.next(); |
| assertEquals(null, key); |
| assertTrue(stream.hasNext()); |
| key = stream.next(); |
| assertEquals("null", key); |
| assertTrue(stream.hasNext()); |
| key = stream.next(); |
| assertEquals("1", key); |
| assertTrue(stream.hasNext()); |
| key = stream.next(); |
| assertEquals("2", key); |
| |
| stream.remove(); |
| |
| assertTrue(stream.hasNext()); |
| key = stream.next(); |
| assertEquals("3", key); |
| assertTrue(stream.hasNext()); |
| key = stream.next(); |
| assertEquals("4", key); |
| assertFalse(stream.hasNext()); |
| |
| assertEquals(5, keySet.size()); |
| assertFalse(this.map.containsKey("2")); |
| assertFalse(this.map.containsValue("two")); |
| assertEquals(5, this.map.size()); |
| } |
| |
| public void testKeySet_iterator_remove2() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Set<String> keySet = this.map.keySet(); |
| assertEquals(6, keySet.size()); |
| for (Iterator<String> stream = keySet.iterator(); stream.hasNext(); ) { |
| String key = stream.next(); |
| if (ObjectTools.equals(key, "2")) { |
| stream.remove(); |
| } |
| } |
| assertEquals(5, keySet.size()); |
| assertFalse(this.map.containsKey("2")); |
| assertFalse(this.map.containsValue("two")); |
| assertEquals(5, this.map.size()); |
| } |
| |
| public void testKeySet_iterator_remove_CME() { |
| Set<String> keySet = this.map.keySet(); |
| boolean exCaught = false; |
| for (Iterator<String> stream = keySet.iterator(); stream.hasNext(); ) { |
| String key = stream.next(); |
| if (ObjectTools.equals(key, "2")) { |
| this.map.remove("1"); |
| try { |
| stream.remove(); |
| fail(); |
| } catch (ConcurrentModificationException ex) { |
| exCaught = true; |
| break; // expected - stop loop |
| } |
| } |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testKeySet_iterator_remove_ISE() { |
| Set<String> keySet = this.map.keySet(); |
| boolean exCaught = false; |
| for (Iterator<String> stream = keySet.iterator(); stream.hasNext(); ) { |
| String key = stream.next(); |
| if (ObjectTools.equals(key, "2")) { |
| stream.remove(); |
| try { |
| stream.remove(); |
| fail(); |
| } catch (IllegalStateException ex) { |
| exCaught = true; |
| break; // expected - stop loop |
| } |
| } |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testKeySet_size() { |
| Set<String> keySet = this.map.keySet(); |
| assertEquals(6, keySet.size()); |
| } |
| |
| public void testKeySet_contains() { |
| Set<String> keySet = this.map.keySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (String entry : map2.keySet()) { |
| assertTrue(keySet.contains(entry)); |
| } |
| } |
| |
| public void testKeySet_remove1() { |
| Set<String> keySet = this.map.keySet(); |
| assertTrue(keySet.remove("2")); |
| assertFalse(keySet.contains("2")); |
| assertFalse(this.map.containsKey("2")); |
| } |
| |
| public void testKeySet_remove2() { |
| assertEquals(6, this.map.size()); |
| Set<String> keySet = this.map.keySet(); |
| assertEquals(6, keySet.size()); |
| assertFalse(keySet.remove("88")); |
| assertEquals(6, keySet.size()); |
| assertEquals(6, this.map.size()); |
| } |
| |
| public void testKeySet_clear() { |
| assertEquals(6, this.map.size()); |
| Set<String> keySet = this.map.keySet(); |
| assertEquals(6, keySet.size()); |
| keySet.clear(); |
| assertEquals(0, keySet.size()); |
| assertEquals(0, this.map.size()); |
| } |
| |
| public void testKeySet_equals() { |
| Set<String> keySet = this.map.keySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertTrue(keySet.equals(map2.keySet())); |
| assertTrue(map2.keySet().equals(keySet)); |
| } |
| |
| public void testKeySet_hashCode() { |
| Set<String> keySet = this.map.keySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertEquals(keySet.hashCode(), map2.keySet().hashCode()); |
| } |
| |
| public void testKeySet_removeAll() { |
| ArrayList<String> remove = new ArrayList<String>(); |
| remove.add(null); |
| remove.add("1"); |
| |
| Set<String> keySet = this.map.keySet(); |
| assertTrue(keySet.removeAll(remove)); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<String> keySet2 = map2.keySet(); |
| assertTrue(keySet2.removeAll(remove)); |
| |
| assertEquals(keySet2, keySet); |
| } |
| |
| public void testKeySet_add() { |
| Set<String> keySet = this.map.keySet(); |
| boolean exCaught = false; |
| try { |
| keySet.add("88"); |
| } catch (UnsupportedOperationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testKeySet_addAll() { |
| ArrayList<String> add = new ArrayList<String>(); |
| add.add(null); |
| add.add("1"); |
| |
| Set<String> keySet = this.map.keySet(); |
| boolean exCaught = false; |
| try { |
| keySet.addAll(add); |
| } catch (UnsupportedOperationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testKeySet_containsAll() { |
| ArrayList<String> keys = new ArrayList<String>(); |
| keys.add(null); |
| keys.add("1"); |
| |
| Set<String> keySet = this.map.keySet(); |
| assertTrue(keySet.containsAll(keys)); |
| } |
| |
| public void testKeySet_isEmpty() { |
| Set<String> keySet = this.map.keySet(); |
| assertFalse(keySet.isEmpty()); |
| keySet.clear(); |
| assertTrue(keySet.isEmpty()); |
| } |
| |
| public void testKeySet_retainAll() { |
| ArrayList<String> retain = new ArrayList<String>(); |
| retain.add(null); |
| retain.add("1"); |
| |
| Set<String> keySet = this.map.keySet(); |
| assertTrue(keySet.retainAll(retain)); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<String> keySet2 = map2.keySet(); |
| assertTrue(keySet2.retainAll(retain)); |
| |
| assertEquals(keySet2, keySet); |
| } |
| |
| public void testKeySet_toArray() { |
| Set<String> keySet = this.map.keySet(); |
| Object[] keys = keySet.toArray(); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<String> keySet2 = map2.keySet(); |
| assertEquals(keys.length, keySet2.size()); |
| for (String entry : map2.keySet()) { |
| assertTrue(ArrayTools.contains(keys, entry)); |
| } |
| for (Object key : keys) { |
| assertTrue(keySet2.contains(key)); |
| } |
| } |
| |
| public void testKeySet_toArray2() { |
| Set<String> keySet = this.map.keySet(); |
| String[] keys = keySet.toArray(StringTools.EMPTY_STRING_ARRAY); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<String> keySet2 = map2.keySet(); |
| assertEquals(keys.length, keySet2.size()); |
| for (String entry : map2.keySet()) { |
| assertTrue(ArrayTools.contains(keys, entry)); |
| } |
| for (String key : keys) { |
| assertTrue(keySet2.contains(key)); |
| } |
| } |
| |
| public void testKeySet_toString() { |
| String expected = "[null, null, 1, 2, 3, 4]"; |
| assertEquals(expected, this.map.keySet().toString()); |
| } |
| |
| public void testValues_iterator_hasNext() { |
| Collection<String> values = this.map.values(); |
| assertEquals(6, values.size()); |
| assertEquals(6, IteratorTools.size(values.iterator())); |
| } |
| |
| public void testValues_iterator_next1() { |
| Collection<String> values = this.map.values(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (String entry : map2.values()) { |
| assertTrue(IteratorTools.contains(values.iterator(), entry)); |
| } |
| } |
| |
| public void testValues_iterator_next2() { |
| Collection<String> values = this.map.values(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Collection<String> values2 = map2.values(); |
| for (Iterator<String> stream = values.iterator(); stream.hasNext(); ) { |
| values2.contains(stream.next()); |
| } |
| } |
| |
| public void testValues_iterator_next_CME() { |
| Collection<String> values = this.map.values(); |
| Iterator<String> stream = values.iterator(); |
| this.map.remove("1"); |
| boolean exCaught = false; |
| try { |
| stream.next(); |
| } catch (ConcurrentModificationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testValues_iterator_next_NSEE() { |
| Collection<String> values = this.map.values(); |
| assertEquals(6, values.size()); |
| int size = 0; |
| Iterator<String> stream = values.iterator(); |
| while (stream.hasNext()) { |
| stream.next(); |
| size++; |
| } |
| assertEquals(6, size); |
| boolean exCaught = false; |
| try { |
| stream.next(); |
| } catch (NoSuchElementException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testValues_iterator_remove1() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Collection<String> values = this.map.values(); |
| assertEquals(6, values.size()); |
| |
| Iterator<String> stream = values.iterator(); |
| assertTrue(stream.hasNext()); |
| String value = stream.next(); |
| assertEquals("null", value); |
| assertTrue(stream.hasNext()); |
| value = stream.next(); |
| assertEquals(null, value); |
| assertTrue(stream.hasNext()); |
| value = stream.next(); |
| assertEquals("one", value); |
| assertTrue(stream.hasNext()); |
| value = stream.next(); |
| assertEquals("two", value); |
| |
| stream.remove(); |
| |
| assertTrue(stream.hasNext()); |
| value = stream.next(); |
| assertEquals("three", value); |
| assertTrue(stream.hasNext()); |
| value = stream.next(); |
| assertEquals("four", value); |
| assertFalse(stream.hasNext()); |
| |
| assertEquals(5, values.size()); |
| assertFalse(this.map.containsKey("2")); |
| assertFalse(this.map.containsValue("two")); |
| assertEquals(5, this.map.size()); |
| } |
| |
| public void testValues_iterator_remove2() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Collection<String> values = this.map.values(); |
| assertEquals(6, values.size()); |
| for (Iterator<String> stream = values.iterator(); stream.hasNext(); ) { |
| String value = stream.next(); |
| if (ObjectTools.equals(value, "two")) { |
| stream.remove(); |
| } |
| } |
| assertEquals(5, values.size()); |
| assertFalse(this.map.containsKey("2")); |
| assertFalse(this.map.containsValue("two")); |
| assertEquals(5, this.map.size()); |
| } |
| |
| public void testValues_iterator_remove_CME() { |
| Collection<String> values = this.map.values(); |
| boolean exCaught = false; |
| for (Iterator<String> stream = values.iterator(); stream.hasNext(); ) { |
| String value = stream.next(); |
| if (ObjectTools.equals(value, "two")) { |
| this.map.remove("1"); |
| try { |
| stream.remove(); |
| fail(); |
| } catch (ConcurrentModificationException ex) { |
| exCaught = true; |
| break; // expected - stop loop |
| } |
| } |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testValues_iterator_remove_ISE() { |
| Collection<String> values = this.map.values(); |
| boolean exCaught = false; |
| for (Iterator<String> stream = values.iterator(); stream.hasNext(); ) { |
| String value = stream.next(); |
| if (ObjectTools.equals(value, "two")) { |
| stream.remove(); |
| try { |
| stream.remove(); |
| fail(); |
| } catch (IllegalStateException ex) { |
| exCaught = true; |
| break; // expected - stop loop |
| } |
| } |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testValues_size() { |
| Collection<String> values = this.map.values(); |
| assertEquals(6, values.size()); |
| } |
| |
| public void testValues_contains() { |
| Collection<String> values = this.map.values(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (String entry : map2.values()) { |
| assertTrue(values.contains(entry)); |
| } |
| } |
| |
| public void testValues_remove1() { |
| Collection<String> values = this.map.values(); |
| assertTrue(values.remove("two")); |
| assertFalse(values.contains("two")); |
| assertFalse(this.map.containsKey("2")); |
| } |
| |
| public void testValues_remove2() { |
| assertEquals(6, this.map.size()); |
| Collection<String> values = this.map.values(); |
| assertEquals(6, values.size()); |
| assertFalse(values.remove("eleventy")); |
| assertEquals(6, values.size()); |
| assertEquals(6, this.map.size()); |
| } |
| |
| public void testValues_clear() { |
| assertEquals(6, this.map.size()); |
| Collection<String> values = this.map.values(); |
| assertEquals(6, values.size()); |
| values.clear(); |
| assertEquals(0, values.size()); |
| assertEquals(0, this.map.size()); |
| } |
| |
| public void testValues_equals() { |
| Collection<String> values = this.map.values(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertTrue(CollectionTools.hashBag(values).equals(CollectionTools.hashBag(map2.values()))); |
| } |
| |
| public void testValues_hashCode() { |
| Collection<String> values = this.map.values(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertEquals(CollectionTools.hashBag(values).hashCode(), CollectionTools.hashBag(map2.values()).hashCode()); |
| } |
| |
| public void testValues_removeAll() { |
| ArrayList<String> remove = new ArrayList<String>(); |
| remove.add(null); |
| remove.add("two"); |
| |
| Collection<String> values = this.map.values(); |
| assertTrue(values.removeAll(remove)); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Collection<String> values2 = map2.values(); |
| assertTrue(values2.removeAll(remove)); |
| |
| assertEquals(CollectionTools.hashBag(values2), CollectionTools.hashBag(values)); |
| } |
| |
| public void testValues_add() { |
| Collection<String> values = this.map.values(); |
| boolean exCaught = false; |
| try { |
| values.add("eleventy"); |
| } catch (UnsupportedOperationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testValues_addAll() { |
| ArrayList<String> add = new ArrayList<String>(); |
| add.add(null); |
| add.add("one"); |
| |
| Collection<String> values = this.map.values(); |
| boolean exCaught = false; |
| try { |
| values.addAll(add); |
| } catch (UnsupportedOperationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testValues_containsAll() { |
| ArrayList<String> strings = new ArrayList<String>(); |
| strings.add(null); |
| strings.add("two"); |
| |
| Collection<String> values = this.map.values(); |
| assertTrue(values.containsAll(strings)); |
| } |
| |
| public void testValues_isEmpty() { |
| Collection<String> values = this.map.values(); |
| assertFalse(values.isEmpty()); |
| values.clear(); |
| assertTrue(values.isEmpty()); |
| } |
| |
| public void testValues_retainAll() { |
| ArrayList<String> retain = new ArrayList<String>(); |
| retain.add(null); |
| retain.add("one"); |
| |
| Collection<String> values = this.map.values(); |
| assertTrue(values.retainAll(retain)); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Collection<String> values2 = map2.values(); |
| assertTrue(values2.retainAll(retain)); |
| |
| assertEquals(CollectionTools.hashBag(values2), CollectionTools.hashBag(values)); |
| } |
| |
| public void testValues_toArray() { |
| Collection<String> values = this.map.values(); |
| Object[] strings = values.toArray(); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Collection<String> values2 = map2.values(); |
| assertEquals(strings.length, values2.size()); |
| for (String entry : map2.values()) { |
| assertTrue(ArrayTools.contains(strings, entry)); |
| } |
| for (Object string : strings) { |
| assertTrue(values2.contains(string)); |
| } |
| } |
| |
| public void testValues_toArray2() { |
| Collection<String> values = this.map.values(); |
| String[] strings = values.toArray(StringTools.EMPTY_STRING_ARRAY); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Collection<String> values2 = map2.values(); |
| assertEquals(strings.length, values2.size()); |
| for (String entry : map2.values()) { |
| assertTrue(ArrayTools.contains(strings, entry)); |
| } |
| for (String string : strings) { |
| assertTrue(values2.contains(string)); |
| } |
| } |
| |
| public void testValues_toString() { |
| String expected = "[null, null, one, two, three, four]"; |
| assertEquals(expected, this.map.values().toString()); |
| } |
| |
| public void testEntrySet_iterator_hasNext() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| assertEquals(6, IteratorTools.size(entrySet.iterator())); |
| } |
| |
| public void testEntrySet_iterator_next1() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (Map.Entry<String, String> entry : map2.entrySet()) { |
| assertTrue(IteratorTools.contains(entrySet.iterator(), entry)); |
| } |
| } |
| |
| public void testEntrySet_iterator_next2() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| for (Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); stream.hasNext(); ) { |
| entrySet2.contains(stream.next()); |
| } |
| } |
| |
| public void testEntrySet_iterator_next_CME() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); |
| this.map.remove("1"); |
| boolean exCaught = false; |
| try { |
| stream.next(); |
| } catch (ConcurrentModificationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEntrySet_iterator_next_NSEE() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| int size = 0; |
| Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); |
| while (stream.hasNext()) { |
| stream.next(); |
| size++; |
| } |
| assertEquals(6, size); |
| boolean exCaught = false; |
| try { |
| stream.next(); |
| } catch (NoSuchElementException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEntrySet_iterator_remove1() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| |
| Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); |
| assertTrue(stream.hasNext()); |
| Map.Entry<String, String> entry = stream.next(); |
| assertEquals(null, entry.getKey()); |
| assertEquals("null", entry.getValue()); |
| assertTrue(stream.hasNext()); |
| entry = stream.next(); |
| assertEquals("null", entry.getKey()); |
| assertEquals(null, entry.getValue()); |
| assertTrue(stream.hasNext()); |
| entry = stream.next(); |
| assertEquals("1", entry.getKey()); |
| assertEquals("one", entry.getValue()); |
| assertTrue(stream.hasNext()); |
| entry = stream.next(); |
| assertEquals("2", entry.getKey()); |
| assertEquals("two", entry.getValue()); |
| |
| stream.remove(); |
| |
| assertTrue(stream.hasNext()); |
| entry = stream.next(); |
| assertEquals("3", entry.getKey()); |
| assertEquals("three", entry.getValue()); |
| assertTrue(stream.hasNext()); |
| entry = stream.next(); |
| assertEquals("4", entry.getKey()); |
| assertEquals("four", entry.getValue()); |
| assertFalse(stream.hasNext()); |
| |
| assertEquals(5, entrySet.size()); |
| assertFalse(this.map.containsKey("2")); |
| assertFalse(this.map.containsValue("two")); |
| assertEquals(5, this.map.size()); |
| } |
| |
| public void testEntrySet_iterator_remove2() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| for (Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); stream.hasNext(); ) { |
| Map.Entry<String, String> entry = stream.next(); |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| stream.remove(); |
| } |
| } |
| assertEquals(5, entrySet.size()); |
| assertFalse(this.map.containsKey("2")); |
| assertFalse(this.map.containsValue("two")); |
| assertEquals(5, this.map.size()); |
| } |
| |
| public void testEntrySet_iterator_remove_CME() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| boolean exCaught = false; |
| for (Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); stream.hasNext(); ) { |
| Map.Entry<String, String> entry = stream.next(); |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| this.map.remove("1"); |
| try { |
| stream.remove(); |
| fail(); |
| } catch (ConcurrentModificationException ex) { |
| exCaught = true; |
| break; // expected - stop loop |
| } |
| } |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEntrySet_iterator_remove_ISE() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| boolean exCaught = false; |
| for (Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); stream.hasNext(); ) { |
| Map.Entry<String, String> entry = stream.next(); |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| stream.remove(); |
| try { |
| stream.remove(); |
| fail(); |
| } catch (IllegalStateException ex) { |
| exCaught = true; |
| break; // expected - stop loop |
| } |
| } |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEntrySet_iterator_entry_setValueObject() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| for (Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); stream.hasNext(); ) { |
| Map.Entry<String, String> entry = stream.next(); |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| entry.setValue("XXX"); |
| } |
| } |
| assertEquals(6, entrySet.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertFalse(this.map.containsValue("two")); |
| assertEquals("XXX", this.map.get("2")); |
| assertTrue(this.map.containsValue("XXX")); |
| assertEquals(6, this.map.size()); |
| } |
| |
| public void testEntrySet_iterator_entry_equalsObject() { |
| assertEquals(6, this.map.size()); |
| assertTrue(this.map.containsKey("2")); |
| assertTrue(this.map.containsValue("two")); |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| for (Iterator<Map.Entry<String, String>> stream = entrySet.iterator(); stream.hasNext(); ) { |
| Map.Entry<String, String> entry = stream.next(); |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| assertFalse(entry.equals("XXX")); |
| } |
| } |
| } |
| |
| public void testEntrySet_iterator_entry_equalsObject2() { |
| Map<String, String> map1 = new TightMap<String, String>(); |
| map1.put("foo", "bar"); |
| Map<String, String> map2 = new TightMap<String, String>(); |
| map2.put("foo", "XXX"); |
| Set<Map.Entry<String, String>> entrySet1 = map1.entrySet(); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| Map.Entry<String, String> entry1 = entrySet1.iterator().next(); |
| Map.Entry<String, String> entry2 = entrySet2.iterator().next(); |
| assertFalse(entry1.equals(entry2)); |
| } |
| |
| public void testEntrySet_size() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| } |
| |
| public void testEntrySet_contains1() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (Map.Entry<String, String> entry : map2.entrySet()) { |
| assertTrue(entrySet.contains(entry)); |
| } |
| } |
| |
| public void testEntrySet_contains2() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| map2.put("xxx", "XXX"); |
| for (Map.Entry<String, String> entry : map2.entrySet()) { |
| String key = entry.getKey(); |
| if ((key != null) && key.equals("xxx")) { |
| assertFalse(entrySet.contains(entry)); |
| } else { |
| assertTrue(entrySet.contains(entry)); |
| } |
| } |
| } |
| |
| public void testEntrySet_contains3() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertFalse(entrySet.contains("XXX")); |
| } |
| |
| @SuppressWarnings("null") |
| public void testEntrySet_remove1() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| |
| Map.Entry<String, String> remove = null; |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (Map.Entry<String, String> entry : map2.entrySet()) { |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| remove = entry; |
| } |
| } |
| |
| assertTrue(entrySet.contains(remove)); |
| assertTrue(this.map.containsKey(remove.getKey())); |
| assertTrue(this.map.containsValue(remove.getValue())); |
| |
| assertTrue(entrySet.remove(remove)); |
| assertFalse(entrySet.contains(remove)); |
| assertFalse(this.map.containsKey(remove.getKey())); |
| assertFalse(this.map.containsValue(remove.getValue())); |
| } |
| |
| public void testEntrySet_remove2() { |
| assertEquals(6, this.map.size()); |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| assertFalse(entrySet.remove("eleventy")); |
| assertEquals(6, entrySet.size()); |
| assertEquals(6, this.map.size()); |
| } |
| |
| public void testEntrySet_remove3() { |
| Map<String, String> map1 = new TightMap<String, String>(); |
| Set<Map.Entry<String, String>> entrySet1 = map1.entrySet(); |
| |
| Map<String, String> map2 = new TightMap<String, String>(); |
| map2.put("foo", "FOO"); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| Map.Entry<String, String> entry2 = entrySet2.iterator().next(); |
| |
| assertFalse(entrySet1.remove(entry2)); |
| map1.put("foo", "XXX"); |
| assertFalse(entrySet1.remove(entry2)); |
| } |
| |
| public void testEntrySet_clear() { |
| assertEquals(6, this.map.size()); |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertEquals(6, entrySet.size()); |
| entrySet.clear(); |
| assertEquals(0, entrySet.size()); |
| assertEquals(0, this.map.size()); |
| } |
| |
| public void testEntrySet_equals() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertTrue(CollectionTools.hashBag(entrySet).equals(CollectionTools.hashBag(map2.entrySet()))); |
| } |
| |
| public void testEntrySet_hashCode() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertEquals(CollectionTools.hashBag(entrySet).hashCode(), CollectionTools.hashBag(map2.entrySet()).hashCode()); |
| } |
| |
| public void testEntrySet_removeAll() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| |
| ArrayList<Map.Entry<String, String>> remove = new ArrayList<Map.Entry<String, String>>(); |
| for (Map.Entry<String, String> entry : entrySet2) { |
| if (ObjectTools.equals(entry.getKey(), null)) { |
| remove.add(entry); |
| } |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| remove.add(entry); |
| } |
| } |
| |
| assertTrue(entrySet.removeAll(remove)); |
| assertTrue(entrySet2.removeAll(remove)); |
| |
| assertEquals(CollectionTools.hashBag(entrySet2), CollectionTools.hashBag(entrySet)); |
| } |
| |
| public void testEntrySet_add() { |
| Map.Entry<String, String> add = null; |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| for (Map.Entry<String, String> entry : map2.entrySet()) { |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| add = entry; |
| } |
| } |
| |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| boolean exCaught = false; |
| try { |
| entrySet.add(add); |
| } catch (UnsupportedOperationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEntrySet_addAll() { |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| |
| ArrayList<Map.Entry<String, String>> add = new ArrayList<Map.Entry<String, String>>(); |
| for (Map.Entry<String, String> entry : entrySet2) { |
| if (ObjectTools.equals(entry.getKey(), null)) { |
| add.add(entry); |
| } |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| add.add(entry); |
| } |
| } |
| |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| boolean exCaught = false; |
| try { |
| entrySet.addAll(add); |
| } catch (UnsupportedOperationException ex) { |
| exCaught = true; |
| } |
| assertTrue(exCaught); |
| } |
| |
| public void testEntrySet_containsAll() { |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| |
| ArrayList<Map.Entry<String, String>> strings = new ArrayList<Map.Entry<String, String>>(); |
| for (Map.Entry<String, String> entry : entrySet2) { |
| if (ObjectTools.equals(entry.getKey(), null)) { |
| strings.add(entry); |
| } |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| strings.add(entry); |
| } |
| } |
| |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertTrue(entrySet.containsAll(strings)); |
| } |
| |
| public void testEntrySet_isEmpty() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertFalse(entrySet.isEmpty()); |
| entrySet.clear(); |
| assertTrue(entrySet.isEmpty()); |
| } |
| |
| public void testEntrySet_retainAll() { |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| |
| ArrayList<Map.Entry<String, String>> retain = new ArrayList<Map.Entry<String, String>>(); |
| for (Map.Entry<String, String> entry : entrySet2) { |
| if (ObjectTools.equals(entry.getKey(), null)) { |
| retain.add(entry); |
| } |
| if (ObjectTools.equals(entry.getKey(), "2")) { |
| retain.add(entry); |
| } |
| } |
| |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| assertTrue(entrySet.retainAll(retain)); |
| assertTrue(entrySet2.retainAll(retain)); |
| assertEquals(CollectionTools.hashBag(entrySet2), CollectionTools.hashBag(entrySet)); |
| } |
| |
| public void testEntrySet_toArray() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| Object[] strings = entrySet.toArray(); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| assertEquals(strings.length, entrySet2.size()); |
| for (Map.Entry<String, String> entry : map2.entrySet()) { |
| assertTrue(ArrayTools.contains(strings, entry)); |
| } |
| for (Object string : strings) { |
| assertTrue(entrySet2.contains(string)); |
| } |
| } |
| |
| public void testEntrySet_toArray2() { |
| Set<Map.Entry<String, String>> entrySet = this.map.entrySet(); |
| @SuppressWarnings("rawtypes") |
| Map.Entry[] entries = entrySet.toArray(new Map.Entry[0]); |
| |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| Set<Map.Entry<String, String>> entrySet2 = map2.entrySet(); |
| assertEquals(entries.length, entrySet2.size()); |
| for (Map.Entry<String, String> entry : map2.entrySet()) { |
| assertTrue(ArrayTools.contains(entries, entry)); |
| } |
| for (@SuppressWarnings("rawtypes") Map.Entry entry : entries) { |
| assertTrue(entrySet2.contains(entry)); |
| } |
| } |
| |
| public void testEntrySet_toString() { |
| String expected = "[null=null, null=null, 1=one, 2=two, 3=three, 4=four]"; |
| assertEquals(expected, this.map.entrySet().toString()); |
| } |
| |
| public void testEquals0() { |
| assertTrue(this.map.equals(this.map)); |
| } |
| |
| public void testEquals1() { |
| assertFalse(this.map.equals("map2")); |
| } |
| |
| public void testEquals2() { |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| assertFalse(this.map.equals(map2)); |
| } |
| |
| public void testEquals3() { |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| map2.remove("1"); |
| assertFalse(this.map.equals(map2)); |
| } |
| |
| public void testEquals4() { |
| HashMap<String, Integer> map2 = new HashMap<String, Integer>(); |
| map2.put(null, Integer.valueOf(0)); |
| map2.put("null", Integer.valueOf(0)); |
| map2.put("1", Integer.valueOf(1)); |
| map2.put("2", Integer.valueOf(2)); |
| map2.put("3", Integer.valueOf(3)); |
| map2.put("4", Integer.valueOf(4)); |
| assertFalse(this.map.equals(map2)); |
| } |
| |
| public void testEquals5() { |
| HashMap<Integer, String> map2 = new HashMap<Integer, String>(); |
| map2.put(Integer.valueOf(0), null); |
| map2.put(Integer.valueOf(0), "null"); |
| map2.put(Integer.valueOf(1), "1"); |
| map2.put(Integer.valueOf(2), "2"); |
| map2.put(Integer.valueOf(3), "3"); |
| map2.put(Integer.valueOf(4), "4"); |
| assertFalse(this.map.equals(map2)); |
| } |
| |
| public void testEquals6() { |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertTrue(this.map.equals(map2)); |
| } |
| |
| public void testEquals7() { |
| TightMap<String, String> map1 = new TightMap<String, String>(); |
| map1.put("null", null); |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| assertFalse(map1.equals(map2)); |
| map2.put("null", "null"); |
| assertFalse(map1.equals(map2)); |
| map2.put("null", null); |
| assertTrue(map1.equals(map2)); |
| } |
| |
| public void testHashCode1() { |
| HashMap<String, String> map2 = new HashMap<String, String>(); |
| this.populateMap(map2); |
| assertEquals(this.map.hashCode(), map2.hashCode()); |
| } |
| |
| public void testHashCode2() { |
| LinkedHashMap<String, String> map2 = new LinkedHashMap<String, String>(); |
| this.populateMap(map2); |
| assertEquals(this.map.hashCode(), map2.hashCode()); |
| } |
| |
| public void testToString1() { |
| String expected = "{null=null, null=null, 1=one, 2=two, 3=three, 4=four}"; |
| assertEquals(expected, this.map.toString()); |
| } |
| |
| public void testToString2() { |
| this.map.clear(); |
| String expected = "{}"; |
| assertEquals(expected, this.map.toString()); |
| } |
| |
| public void testToString3() { |
| TightMap<Object, Object> map2 = new TightMap<Object, Object>(); |
| this.populateMap(map2); |
| map2.put(map2, "this"); |
| String expected = "{null=null, null=null, 1=one, 2=two, 3=three, 4=four, (this Map)=this}"; |
| assertEquals(expected, map2.toString()); |
| } |
| |
| public void testToString4() { |
| TightMap<Object, Object> map2 = new TightMap<Object, Object>(); |
| this.populateMap(map2); |
| map2.put("this", map2); |
| String expected = "{null=null, null=null, 1=one, 2=two, 3=three, 4=four, this=(this Map)}"; |
| assertEquals(expected, map2.toString()); |
| } |
| } |