Java tutorial
/* * Copyright (c) MuleSoft, Inc. All rights reserved. http://www.mulesoft.com * The software in this package is published under the terms of the CPAL v1.0 * license, a copy of which has been included with this distribution in the * LICENSE.txt file. */ package org.mule.util; import static junit.framework.Assert.fail; import static org.hamcrest.CoreMatchers.instanceOf; import static org.hamcrest.CoreMatchers.is; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; import org.mule.tck.junit4.AbstractMuleTestCase; import org.mule.tck.size.SmallTest; import java.io.Serializable; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.NoSuchElementException; import java.util.Set; import org.apache.commons.lang.SerializationUtils; import org.junit.Test; @SuppressWarnings("unchecked") @SmallTest public class CopyOnWriteCaseInsensitiveMapTestCase extends AbstractMuleTestCase { private static final String KEY1 = "FOO"; private static final String KEY2 = "doo"; @Test public void caseInsensitive() throws Exception { assertMapContents(createTestMap()); } @Test public void keysCaseSensitive() throws Exception { Map<String, Object> map = createTestMap(); assertEquals(2, map.keySet().size()); assertTrue(map.keySet().toArray()[0].equals("FOO") || map.keySet().toArray()[0].equals("doo")); assertTrue(map.keySet().toArray()[1].equals("FOO") || map.keySet().toArray()[1].equals("doo")); } @Test public void caseInsensitiveDelegate() throws Exception { assertMapContents(createTestMap().clone()); } @Test public void caseInsensitiveCopiedDelegate() throws Exception { Map<String, Object> map = createTestMap().clone(); map.put("new", "val"); assertMapContents(map); } @Test public void serialize() throws Exception { assertMapContents(serializeAndDeserialize(createTestMap())); } @Test public void serializeDelegate() throws Exception { assertMapContents(serializeAndDeserialize(createTestMap().clone())); } @Test public void serializeCopiedDelegate() throws Exception { Map<String, Object> map = createTestMap().clone(); map.put("new", "val"); assertMapContents(serializeAndDeserialize(map)); } protected Map<String, Object> serializeAndDeserialize(Map<String, Object> map) { byte[] bytes = SerializationUtils.serialize((Serializable) map); return (Map) SerializationUtils.deserialize(bytes); } /* * Assert that Map created with createTestMap() has both of the original properties (FOO and DOO) and that * these can be accessed using case-insensitive keys */ protected void assertMapContents(Map<String, Object> map) { assertEquals("BAR", map.get("FOO")); assertEquals("BAR", map.get("foo")); assertEquals("BAR", map.get("Foo")); assertEquals(Integer.valueOf(3), map.get("DOO")); assertEquals(Integer.valueOf(3), map.get("doo")); assertEquals(Integer.valueOf(3), map.get("Doo")); } /* * Create a CopyOnWriteCaseInsensitiveMap with two properties: F00=BAR (String) and DOO=3 (int). */ protected CopyOnWriteCaseInsensitiveMap<String, Object> createTestMap() { CopyOnWriteCaseInsensitiveMap<String, Object> map = new CopyOnWriteCaseInsensitiveMap<String, Object>(); map.put(KEY1, "BAR"); map.put(KEY2, Integer.valueOf(3)); return map; } @Test public void entrySet() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); assertEquals(2, original.size()); original.keySet().remove("FOO"); assertEquals(1, original.size()); original.keySet().clear(); assertEquals(0, original.size()); } @Test public void entrySetCloneMutateOriginal() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = original.clone(); assertEquals(2, original.size()); assertEquals(2, copyOnWriteMap.size()); original.keySet().remove("FOO"); assertEquals(1, original.size()); assertEquals(2, copyOnWriteMap.size()); original.keySet().clear(); assertEquals(0, original.size()); assertEquals(2, copyOnWriteMap.size()); } @Test public void entrySetCloneMutateClone() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = original.clone(); assertEquals(2, original.size()); assertEquals(2, copyOnWriteMap.size()); copyOnWriteMap.keySet().remove("FOO"); assertEquals(2, original.size()); assertEquals(1, copyOnWriteMap.size()); copyOnWriteMap.keySet().clear(); assertEquals(2, original.size()); assertEquals(0, copyOnWriteMap.size()); } @Test public void putClone() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = original.clone(); original.put("newOriginal", "val"); copyOnWriteMap.put("newCopy", "val"); // Assert state of original map assertMapContents(original); assertEquals(3, original.size()); assertFalse(original.containsKey("newCopy")); assertTrue(original.containsKey("newOriginal")); // Assert state of copy on write map assertMapContents(copyOnWriteMap); assertEquals(3, copyOnWriteMap.size()); assertTrue(copyOnWriteMap.containsKey("newCopy")); assertFalse(copyOnWriteMap.containsKey("newOriginal")); } @Test public void putAllClone() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = original.clone(); Map<String, String> newOriginalEntriesMap = new HashMap<String, String>(); newOriginalEntriesMap.put("newOriginal1", "val"); newOriginalEntriesMap.put("newOriginal2", "val"); newOriginalEntriesMap.put("newOriginal3", "val"); original.putAll(newOriginalEntriesMap); Map<String, String> newCopyEntriesMap = new HashMap<String, String>(); newCopyEntriesMap.put("newCopy1", "val"); newCopyEntriesMap.put("newCopy2", "val"); newCopyEntriesMap.put("newCopy3", "val"); copyOnWriteMap.putAll(newCopyEntriesMap); // Assert state of original map assertMapContents(original); assertEquals(5, original.size()); assertTrue(original.containsKey("newOriginal1")); assertTrue(original.containsKey("newOriginal2")); assertTrue(original.containsKey("newOriginal3")); assertFalse(original.containsKey("newCopy1")); assertFalse(original.containsKey("newCopy2")); assertFalse(original.containsKey("newCopy3")); // Assert state of copy on write map assertMapContents(copyOnWriteMap); assertEquals(5, copyOnWriteMap.size()); assertTrue(copyOnWriteMap.containsKey("newCopy1")); assertTrue(copyOnWriteMap.containsKey("newCopy2")); assertTrue(copyOnWriteMap.containsKey("newCopy3")); assertFalse(copyOnWriteMap.containsKey("newOriginal1")); assertFalse(copyOnWriteMap.containsKey("newOriginal2")); assertFalse(copyOnWriteMap.containsKey("newOriginal3")); } @Test public void removeClone() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); original.put("extra", "value"); original.put("extra2", "value"); Map<String, Object> copyOnWriteMap = original.clone(); original.remove("extra"); copyOnWriteMap.remove("extra2"); // Assert state of original map assertMapContents(original); assertEquals(3, original.size()); assertFalse(original.containsKey("extra")); assertTrue(original.containsKey("extra2")); // Assert state of copy on write map assertMapContents(copyOnWriteMap); assertEquals(3, copyOnWriteMap.size()); assertTrue(copyOnWriteMap.containsKey("extra")); assertFalse(copyOnWriteMap.containsKey("extra2")); } @Test public void clearOrignalClone() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = original.clone(); original.clear(); assertEquals(0, original.size()); assertEquals(0, original.entrySet().size()); assertEquals(2, copyOnWriteMap.size()); assertEquals(2, copyOnWriteMap.entrySet().size()); } @Test public void clearCopyClone() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = original.clone(); copyOnWriteMap.clear(); assertEquals(2, original.size()); assertEquals(2, original.entrySet().size()); assertEquals(0, copyOnWriteMap.size()); assertEquals(0, copyOnWriteMap.entrySet().size()); } @Test public void entrySetDeserializedMutateOriginal() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = serializeAndDeserialize(original); assertEquals(2, original.size()); assertEquals(2, copyOnWriteMap.size()); original.keySet().remove("FOO"); assertEquals(1, original.size()); assertEquals(2, copyOnWriteMap.size()); original.keySet().clear(); assertEquals(0, original.size()); assertEquals(2, copyOnWriteMap.size()); } @Test public void entrySetDeserializedMutateClone() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = serializeAndDeserialize(original); assertEquals(2, original.size()); assertEquals(2, copyOnWriteMap.size()); copyOnWriteMap.keySet().remove("FOO"); assertEquals(2, original.size()); assertEquals(1, copyOnWriteMap.size()); copyOnWriteMap.keySet().clear(); assertEquals(2, original.size()); assertEquals(0, copyOnWriteMap.size()); } @Test public void putDeserialized() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = serializeAndDeserialize(original); original.put("newOriginal", "val"); copyOnWriteMap.put("newCopy", "val"); // Assert state of original map assertMapContents(original); assertEquals(3, original.size()); assertFalse(original.containsKey("newCopy")); assertTrue(original.containsKey("newOriginal")); // Assert state of copy on write map assertMapContents(copyOnWriteMap); assertEquals(3, copyOnWriteMap.size()); assertTrue(copyOnWriteMap.containsKey("newCopy")); assertFalse(copyOnWriteMap.containsKey("newOriginal")); } @Test public void putAllDeserialized() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = serializeAndDeserialize(original); Map<String, String> newOriginalEntriesMap = new HashMap<String, String>(); newOriginalEntriesMap.put("newOriginal1", "val"); newOriginalEntriesMap.put("newOriginal2", "val"); newOriginalEntriesMap.put("newOriginal3", "val"); original.putAll(newOriginalEntriesMap); Map<String, String> newCopyEntriesMap = new HashMap<String, String>(); newCopyEntriesMap.put("newCopy1", "val"); newCopyEntriesMap.put("newCopy2", "val"); newCopyEntriesMap.put("newCopy3", "val"); copyOnWriteMap.putAll(newCopyEntriesMap); // Assert state of original map assertMapContents(original); assertEquals(5, original.size()); assertTrue(original.containsKey("newOriginal1")); assertTrue(original.containsKey("newOriginal2")); assertTrue(original.containsKey("newOriginal3")); assertFalse(original.containsKey("newCopy1")); assertFalse(original.containsKey("newCopy2")); assertFalse(original.containsKey("newCopy3")); // Assert state of copy on write map assertMapContents(copyOnWriteMap); assertEquals(5, copyOnWriteMap.size()); assertTrue(copyOnWriteMap.containsKey("newCopy1")); assertTrue(copyOnWriteMap.containsKey("newCopy2")); assertTrue(copyOnWriteMap.containsKey("newCopy3")); assertFalse(copyOnWriteMap.containsKey("newOriginal1")); assertFalse(copyOnWriteMap.containsKey("newOriginal2")); assertFalse(copyOnWriteMap.containsKey("newOriginal3")); } @Test public void removeDeserialized() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); original.put("extra", "value"); original.put("extra2", "value"); Map<String, Object> copyOnWriteMap = serializeAndDeserialize(original); original.remove("extra"); copyOnWriteMap.remove("extra2"); // Assert state of original map assertMapContents(original); assertEquals(3, original.size()); assertFalse(original.containsKey("extra")); assertTrue(original.containsKey("extra2")); // Assert state of copy on write map assertMapContents(copyOnWriteMap); assertEquals(3, copyOnWriteMap.size()); assertTrue(copyOnWriteMap.containsKey("extra")); assertFalse(copyOnWriteMap.containsKey("extra2")); } @Test public void clearOrignalDeserialized() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = serializeAndDeserialize(original); original.clear(); assertEquals(0, original.size()); assertEquals(0, original.entrySet().size()); assertEquals(2, copyOnWriteMap.size()); assertEquals(2, copyOnWriteMap.entrySet().size()); } @Test public void clearCopyDeserialized() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> original = createTestMap(); Map<String, Object> copyOnWriteMap = serializeAndDeserialize(original); copyOnWriteMap.clear(); assertEquals(2, original.size()); assertEquals(2, original.entrySet().size()); assertEquals(0, copyOnWriteMap.size()); assertEquals(0, copyOnWriteMap.entrySet().size()); } @Test public void keySetGivesAllKeys() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> map = createTestMap(); Set<String> foundKeys = new HashSet<String>(); for (String key : map.keySet()) { assertTrue(KEY1.equals(key) || KEY2.equals(key)); assertFalse(foundKeys.contains(key)); foundKeys.add(key); } } @Test public void removeKeySetItem() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> map = createTestMap(); Iterator<String> it = map.keySet().iterator(); assertTrue(it.hasNext()); String key = it.next(); it.remove(); assertFalse(map.keySet().contains(key)); it = map.keySet().iterator(); assertTrue(it.hasNext()); String key2 = it.next(); assertFalse(key.equals(key2)); assertFalse(it.hasNext()); it.remove(); assertFalse(it.hasNext()); assertTrue(map.keySet().isEmpty()); it = map.keySet().iterator(); assertFalse(it.hasNext()); try { it.next(); fail("Was expecting NoSuchElementException"); } catch (NoSuchElementException e) { // happyness } } @Test(expected = NoSuchElementException.class) public void emptyMapKeySetIterator() throws Exception { Map<String, String> map = new CopyOnWriteCaseInsensitiveMap<String, String>(); assertTrue(map.keySet().isEmpty()); Iterator<String> iterator = map.keySet().iterator(); assertFalse(iterator.hasNext()); iterator.next(); } @Test(expected = IllegalStateException.class) public void removeInKeySetIteratorBeforeAnyNext() throws Exception { createTestMap().keySet().iterator().remove(); } @Test(expected = IllegalStateException.class) public void keySetIteratorWithTwoRemovesInTheSameNext() throws Exception { Iterator<String> iterator = createTestMap().keySet().iterator(); iterator.next(); iterator.remove(); iterator.remove(); } @Test public void removeShouldNotMoveForward() throws Exception { CopyOnWriteCaseInsensitiveMap<String, Object> map = createTestMap(); //add a third element to spice things up final String EXTRA_KEY = "THIRD"; map.put(EXTRA_KEY, new Object()); // store iteration order List<String> keys = new ArrayList<String>(); for (String key : map.keySet()) { keys.add(key); } //now remove second element and make sure that the next element is the third Iterator<String> iterator = map.keySet().iterator(); iterator.next(); iterator.next(); iterator.remove(); String key = iterator.next(); assertEquals(keys.get(2), key); assertFalse(iterator.hasNext()); } @Test public void asHashMap() { CopyOnWriteCaseInsensitiveMap<String, Object> map = createTestMap(); Map<String, Object> regularMap = map.asHashMap(); assertThat(regularMap, is(instanceOf(HashMap.class))); assertThat(regularMap.size(), is(map.size())); for (Map.Entry<String, Object> entry : map.entrySet()) { assertThat(map.get(entry.getKey()), is(regularMap.get(entry.getKey()))); } } }