BUG-4803: invalidate cache before each test

[yangtools.git] / common / util / src / test / java / org / opendaylight / yangtools / util / OffsetMapTest.java

diff --git a/common/util/src/test/java/org/opendaylight/yangtools/util/OffsetMapTest.java b/common/util/src/test/java/org/opendaylight/yangtools/util/OffsetMapTest.java
index 6f5ed87487f442296dc886b416816a85b2aaf39a..17a6f2e1edf8d308b76e258d2363e6cb90daadae 100644 (file)
--- a/common/util/src/test/java/org/opendaylight/yangtools/util/OffsetMapTest.java
+++ b/common/util/src/test/java/org/opendaylight/yangtools/util/OffsetMapTest.java
@@ -29,6 +29,7 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NoSuchElementException;
 import java.util.Set;
+import org.junit.Before;
 import org.junit.Test;
 
 public class OffsetMapTest {
@@ -39,6 +40,16 @@ public class OffsetMapTest {
         return (ImmutableOffsetMap<String, String>) ImmutableOffsetMap.copyOf(twoEntryMap);
     }
 
+    @Before
+    public void setup() {
+        OffsetMapCache.invalidateCache();
+    }
+
+    @Test(expected=IllegalArgumentException.class)
+    public void testWrongImmutableConstruction() {
+        new ImmutableOffsetMap.Ordered<String, String>(Collections.<String, Integer>emptyMap(), new String[1]);
+    }
+
     @Test
     public void testCopyEmptyMap() {
         final Map<String, String> source = Collections.emptyMap();
@@ -54,24 +65,42 @@ public class OffsetMapTest {
         final Map<String, String> result = ImmutableOffsetMap.copyOf(source);
 
         assertEquals(source, result);
-        assertTrue(result instanceof ImmutableMap);
+        assertTrue(result instanceof SharedSingletonMap);
     }
 
     @Test
     public void testCopyMap() {
-        final Map<String, String> result = createMap();
-
-        assertTrue(result instanceof ImmutableOffsetMap);
+        final ImmutableOffsetMap<String, String> map = createMap();
 
         // Equality in both directions
-        assertEquals(twoEntryMap, result);
-        assertEquals(result, twoEntryMap);
+        assertEquals(twoEntryMap, map);
+        assertEquals(map, twoEntryMap);
+
+        // hashcode has to match
+        assertEquals(twoEntryMap.hashCode(), map.hashCode());
 
         // Iterator order needs to be preserved
-        assertTrue(Iterators.elementsEqual(twoEntryMap.entrySet().iterator(), result.entrySet().iterator()));
+        assertTrue(Iterators.elementsEqual(twoEntryMap.entrySet().iterator(), map.entrySet().iterator()));
 
         // Should result in the same object
-        assertSame(result, ImmutableOffsetMap.copyOf(result));
+        assertSame(map, ImmutableOffsetMap.copyOf(map));
+
+        final Map<String, String> mutable = map.toModifiableMap();
+        final Map<String, String> copy = ImmutableOffsetMap.copyOf(mutable);
+
+        assertEquals(mutable, copy);
+        assertEquals(map, copy);
+        assertNotSame(mutable, copy);
+        assertNotSame(map, copy);
+    }
+
+    @Test
+    public void testImmutableSimpleEquals() {
+        final Map<String, String> map = createMap();
+
+        assertTrue(map.equals(map));
+        assertFalse(map.equals(null));
+        assertFalse(map.equals("string"));
     }
 
     @Test
@@ -222,6 +251,17 @@ public class OffsetMapTest {
         assertTrue(map.containsKey("k2"));
         assertFalse(map.containsKey("non-existent"));
         assertFalse(map.containsKey(null));
+        assertTrue(map.containsValue("v1"));
+        assertFalse(map.containsValue("non-existent"));
+    }
+
+    @Test
+    public void testImmutableEquals() {
+        final Map<String, String> map = createMap();
+
+        assertFalse(map.equals(threeEntryMap));
+        assertFalse(map.equals(ImmutableMap.of("k1", "v1", "k3", "v3")));
+        assertFalse(map.equals(ImmutableMap.of("k1", "v1", "k2", "different-value")));
     }
 
     @Test
@@ -296,6 +336,16 @@ public class OffsetMapTest {
         assertTrue(Iterators.elementsEqual(source.entrySet().iterator(), result.entrySet().iterator()));
     }
 
+    @Test
+    public void testEmptyMutable() throws CloneNotSupportedException {
+        final MutableOffsetMap<String, String> map = MutableOffsetMap.of();
+        assertTrue(map.isEmpty());
+
+        final Map<String, String> other = map.clone();
+        assertEquals(other, map);
+        assertNotSame(other, map);
+    }
+
     @Test
     public void testMutableToEmpty() {
         final MutableOffsetMap<String, String> mutable = createMap().toModifiableMap();
@@ -320,6 +370,19 @@ public class OffsetMapTest {
         assertEquals(ImmutableMap.of("k2", "v2"), result);
     }
 
+    @Test
+    public void testMutableToNewSingleton() {
+        final MutableOffsetMap<String, String> mutable = createMap().toModifiableMap();
+
+        mutable.remove("k1");
+        mutable.put("k3", "v3");
+
+        final Map<String, String> result = mutable.toUnmodifiableMap();
+
+        assertTrue(result instanceof ImmutableOffsetMap);
+        assertEquals(ImmutableMap.of("k2", "v2", "k3", "v3"), result);
+    }
+
     @Test
     public void testMutableSize() {
         final MutableOffsetMap<String, String> mutable = createMap().toModifiableMap();
@@ -440,6 +503,24 @@ public class OffsetMapTest {
         }
     }
 
+    @Test
+    public void testMutableSimpleEquals() {
+        final ImmutableOffsetMap<String, String> source = createMap();
+        final Map<String, String> map = source.toModifiableMap();
+
+        assertTrue(map.equals(map));
+        assertFalse(map.equals(null));
+        assertFalse(map.equals("string"));
+        assertTrue(map.equals(source));
+    }
+
+    @Test
+    public void testMutableSimpleHashCode() {
+        final Map<String, String> map = createMap().toModifiableMap();
+
+        assertEquals(twoEntryMap.hashCode(), map.hashCode());
+    }
+
     @Test
     public void testMutableIteratorBasics() {
         final MutableOffsetMap<String, String> map = createMap().toModifiableMap();