tests (88)

fix: LookupUtils.LazyMap - contract for default values

assira/pom.xml

@@ -92,6 +92,8 @@
 								<exclude>net/ranides/assira/collection/maps/ASortedMap.class</exclude>
 								<exclude>net/ranides/assira/collection/maps/AVLTreeMap$*</exclude>
 								<exclude>net/ranides/assira/collection/maps/AVLTreeMap.class</exclude>
+								<exclude>net/ranides/assira/collection/maps/Cache$*</exclude>
+								<exclude>net/ranides/assira/collection/maps/Cache.class</exclude>
 								<exclude>net/ranides/assira/collection/maps/CustomMap.class</exclude>
 								<exclude>net/ranides/assira/collection/maps/HashMap$*</exclude>
 								<exclude>net/ranides/assira/collection/maps/HashMap.class</exclude>
@@ -110,6 +112,8 @@
 								<exclude>net/ranides/assira/collection/maps/IntRBTreeMap$*</exclude>
 								<exclude>net/ranides/assira/collection/maps/IntRBTreeMap.class</exclude>
 								<exclude>net/ranides/assira/collection/maps/MultiMap.class</exclude>
+								<exclude>net/ranides/assira/collection/maps/RandomAccessMap$*</exclude>
+								<exclude>net/ranides/assira/collection/maps/RandomAccessMap.class</exclude>
 								<exclude>net/ranides/assira/collection/maps/RBTreeMap$*</exclude>
 								<exclude>net/ranides/assira/collection/maps/RBTreeMap.class</exclude>
                                 

assira/src/main/java/net/ranides/assira/collection/lookups/LookupUtils.java

@@ -227,7 +227,7 @@ public final class LookupUtils {
         
         private final Lookup<K> data;
         
-        private final IntSupplier supplier;
+        private IntSupplier supplier;
 
         public LazyMap(Lookup<K> data, IntSupplier supplier) {
             this.data = data;
@@ -273,14 +273,33 @@ public final class LookupUtils {
 
         @Override
         public int removeInt(Object key) {
-            return data.removeInt(key);
+			if(!data.containsKey(key)) {
+				return supplier.getAsInt();
+			} else {
+				return data.removeInt(key);
+			}
         }
 
         @Override
         public int put(K key, int value) {
-            return data.put(key, value);
-        }
-        
+			if(!data.containsKey(key)) {
+				return data.put(key, value);
+			} else {
+				data.put(key, value);
+				return supplier.getAsInt();
+			}
+        }
+
+		@Override
+		public int defaultReturnValue() {
+			return supplier.getAsInt();
+		}
+
+		@Override
+		public void defaultReturnValue(int rv) {
+			supplier = () -> rv;
+		}
+		
     }
     
 }

assira/src/test/java/net/ranides/assira/collection/lists/JoinListTest.java

@@ -27,57 +27,38 @@ public class JoinListTest {
 	
 	@Test
 	public void testContract() {
+		
 		ContractTesters.runner()
 			.param("collection!", $var)
-			.function(new int[0], array -> {
-				JoinList<TPoint> ret = new JoinList<>();
-				ret.join($var.list(array).into(new ArrayList<>()));
-				return ret;
-			})
+			.function(new int[0], this::jlist1)
 			.run();
 		
 		ContractTesters.runner()
 			.param("collection!", $var)
-			.function(new int[0], array -> {
-				TPoint[] src = $var.list(array).values();
-				JoinList<TPoint> ret = new JoinList<>();
-				
-				List<TPoint> now = new ArrayList<>();
-				for(int i=0; i<src.length; i++) {
-					now.add(src[i]);
-					if(4 == i % 5) {
-						ret.join(now);
-						now = new ArrayList<>();
-					}
-				}
-				ret.join(now);
-				return ret;
-			})
+			.function(new int[0], this::jlist2)
 			.run();
 	}
 	
-	@Test
-	public void testIterator() {
-		JoinList<Integer> list = new JoinList<>();
-		list.join(Arrays.asList(1,2,3));
-		list.join(Arrays.asList(4,5,6,7));
-		list.join(Arrays.asList(8,9,10));
-		list.join(Arrays.asList(11));
-		
-		ListIterator<Integer> i = list.listIterator(11);
-		int c = 11;
-		while(i.hasPrevious()) {
-			c--;
-			Integer v = i.previous();
-			int pi = i.previousIndex();
-			int ni = i.nextIndex();
+	private JoinList<TPoint> jlist1(int[] array) {
+		JoinList<TPoint> ret = new JoinList<>();
+		ret.join($var.list(array).into(new ArrayList<>()));
+		return ret;
+	}
+	
+	private JoinList<TPoint> jlist2(int[] array) {
+		TPoint[] src = $var.list(array).values();
+		JoinList<TPoint> ret = new JoinList<>();
 
-			System.out.printf("%d[%d] = %d->%d%n", v, c, pi, ni);
+		List<TPoint> now = new ArrayList<>();
+		for(int i=0; i<src.length; i++) {
+			now.add(src[i]);
+			if(4 == i % 5) {
+				ret.join(now);
+				now = new ArrayList<>();
+			}
 		}
-		System.out.printf("p = %s%n", i.hasPrevious());
-		System.out.printf("n = %s%n", i.hasNext());
-		System.out.printf("p = %s%n", i.hasPrevious());
-		System.out.printf("n = %s%n", i.hasNext());
+		ret.join(now);
+		return ret;
 	}
 	
 }

assira/src/test/java/net/ranides/assira/collection/lookups/LookupUtilsTest.java

@@ -0,0 +1,38 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.lookups;
+
+import java.io.Serializable;
+import java.util.function.IntSupplier;
+import java.util.function.Supplier;
+import net.ranides.assira.ContractTesters;
+import net.ranides.assira.collection.mockup.TMaps;
+import net.ranides.assira.collection.mockup.TPoint;
+import net.ranides.assira.test.TMap;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class LookupUtilsTest {
+	
+	private final TMap<TPoint, Integer> $map = TMaps.MAP_PI;
+    
+    @Test
+    public void testContract() {
+		IntSupplier sup1 = (Serializable & IntSupplier) () -> -12;
+		ContractTesters.runner()
+            .param("map!", $map)
+            .param("map.default!", -12)
+            .supplier(() -> LookupUtils.lazy(new RBTreeLookup<>($map.comparator()), sup1))
+			.run();
+		assertTrue(true);
+    }
+	
+}

assira/src/test/java/net/ranides/assira/collection/maps/CacheTest.java

@@ -0,0 +1,271 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.maps;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.Set;
+import net.ranides.assira.collection.CollectionUtils;
+import net.ranides.assira.system.RuntimeUtils;
+import net.ranides.assira.text.StrBuilder;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class CacheTest {
+	
+    public Cache<Integer, String> createPMap() {
+        // tworzymy cache, który chroni wszystkie swoje elementy przed GC
+        Cache<Integer, String> cache = new Cache<>(32);
+        for(int i=0; i<48; i++) {
+            cache.put(i, "BNGV-"+i);
+        }
+        return cache;
+    }
+
+    @Test
+    public void testContainsKey() {
+        Cache<Integer, String> cache = createPMap();
+        
+        assertFalse( cache.containsKey(5) );
+        assertFalse( cache.containsKey(12) );
+        assertFalse( cache.containsKey(15) );
+        
+        assertTrue( cache.containsKey(16) );
+        assertTrue( cache.containsKey(30) );
+        assertTrue( cache.containsKey(47) );
+    }
+
+    @Test
+    public void testGet() {
+        Cache<Integer, String> cache = createPMap();
+        assertNull( cache.get(5) );
+        assertNull( cache.get(12) );
+        assertNull( cache.get(15) );
+        
+        assertEquals("BNGV-16", cache.get(16));
+        assertEquals("BNGV-30", cache.get(30));
+        assertEquals("BNGV-47", cache.get(47));
+    }
+
+    @Test
+    public void testRemove() {
+        Cache<Integer, String> cache = createPMap();
+        assertTrue( cache.containsKey(32) );
+        cache.remove(32);
+        assertFalse( cache.containsKey(32) );
+        cache.remove(3);
+        cache.remove(300);
+        assertFalse( cache.containsKey(3) );
+        assertFalse( cache.containsKey(300) );
+    }
+
+    @Test
+    public void testClear() {
+        Cache<Integer, String> cache = createPMap();
+        cache.clear();
+        assertEquals(0, cache.size());
+        assertFalse( cache.containsKey(16) );
+        assertFalse( cache.containsKey(30) );
+        assertFalse( cache.containsKey(47) );
+    }
+
+    @Test
+    public void testSize() {
+        Cache<Integer, String> cache = createPMap();
+        assertEquals(32, cache.size());
+    }
+
+    @Test
+    public void testEntrySet() {
+        Cache<Integer, String> cache = createPMap();
+        
+        Set<Map.Entry<Integer,String>> entries = cache.entrySet();
+        assertEquals(cache.size(), entries.size());
+        
+        Map<Integer, String> copy1 = new java.util.HashMap<>();
+        for(Map.Entry<Integer,String> entry : entries) {
+            copy1.put(entry.getKey(), entry.getValue());
+        }
+        
+        assertEquals(cache, copy1);
+        
+        Map<Integer, String> copy2 = new java.util.HashMap<>();
+        Iterator<Map.Entry<Integer,String>> iterator = entries.iterator();
+        int i = 0;
+        while(iterator.hasNext()) {
+            Map.Entry<Integer,String> entry = iterator.next();
+            copy2.put(entry.getKey(), entry.getValue());
+            if( i++%2 == 0 ) {
+                iterator.remove();
+            }
+        }
+        
+        assertEquals(copy1.size() / 2, cache.size());
+        assertEquals(copy1, copy2);
+    }
+
+    @Test
+    public void testKeySet() {
+        Cache<Integer, String> cache = createPMap();
+        
+        Set<Integer> keys = cache.keySet();
+        assertEquals(cache.size(), keys.size());
+        
+        Set<Integer> keys1 = new HashSet<>(keys);
+        Map<Integer, String> copy1 = new java.util.HashMap<>();
+        for(Integer key : keys1) {
+            copy1.put(key, cache.get(key));
+        }
+        
+        assertEquals(cache, copy1);
+
+        Iterator<Integer> iterator = keys.iterator();
+        int i = 0;
+        while(iterator.hasNext()) {
+            iterator.next();
+            if( i++%2 == 0 ) {
+                iterator.remove();
+            }
+        }
+        
+        assertEquals(copy1.size() / 2, cache.size());
+    }
+
+    @Test
+    public void testValues() {
+        Cache<Integer, String> cache = createPMap();
+        
+        Collection<String> values = cache.values();
+        assertEquals(cache.size(), values.size());
+        
+        Map<Integer, String> copy1 = new LinkedHashMap<>(cache);
+        List<String> values1 = new ArrayList<>(values);
+        
+        assertEquals(cache.size(), copy1.size());
+
+        // kolejność nie musi być zachowana
+        assertTrue( CollectionUtils.equivalent(copy1.values(), values) );
+        // kolejność nie musi być zachowana
+        assertTrue( CollectionUtils.equivalent(values1, values) );
+
+        Iterator<String> iterator = values.iterator();
+        int i = 0;
+        while(iterator.hasNext()) {
+            iterator.next();
+            if( i++%2 == 0 ) {
+                iterator.remove();
+            }
+        }
+        
+        assertEquals(copy1.size() / 2, cache.size());
+    }
+    
+    @Test
+    public void testRelease() {
+        // we created that cache to check as much things as possible in one method
+        // we don't want to run "forceGC" more than once, because its very costly
+        Cache<Integer, String> cache0 = new Cache<>(32);
+		Random rand = new Random(777);
+        
+        Cache<Integer, String> cache = new Cache<>(128, 16);
+        for(int i=0; i<256; i++) {
+            cache0.put(i, text(rand, 32));
+            cache.put(i, text(rand, 32));
+        }
+        
+        assertEquals(32, cache0.hold());
+        
+        // we should have only last 128 elements
+        assertEquals(128, cache.size());
+        // we should not hold anything (we didn't make any access till now)
+        assertEquals(0, cache.holdsize());
+        
+        assertFalse( cache.containsKey(12) );
+        assertTrue( cache.containsKey(160) );
+        // we should hold 1 accessed element (i.e. 160)
+        assertEquals(1, cache.holdsize());
+        
+        // we should hold as many as possible
+        assertEquals(16, cache.hold());
+        assertEquals(true, cache.hold(255)); // it will create "duplicate in holdlist"
+        assertEquals(false, cache.hold(17));
+        assertEquals(16, cache.holdsize());
+        assertEquals(128, cache.size());
+        
+        // 512 KB is reasonable minimum of unreachable memory 
+        // all soft references should stay
+        assertTrue( RuntimeUtils.performGC() > 512*1024);
+        
+        assertEquals(128, cache.size());
+        assertEquals(16, cache.holdsize());
+        assertTrue(cache.containsKey(160)); // it will create "duplicate in holdlist"
+        assertTrue(cache.containsKey(252)); // it will create "duplicate in holdlist"
+        assertEquals(16, cache.holdsize());
+        
+        // 512 KB is reasonable minimum of unreachable memory 
+        // all soft references should go away
+        assertTrue( RuntimeUtils.forceGC() > 512*1024 );
+        
+        // test clean-up code in "get". 
+        // we can't invoke almost any method after GC, because it will run 
+        // clean-up code in #relase method
+        // we can't invoke #contains on existing key, because it will create
+        // "duplicate in holdlist"
+        assertFalse(cache.containsKey(161));
+        assertFalse(cache.containsKey(240));
+        
+        // we have 3 duplicates in holdlist
+        assertEquals(13, cache.size());
+        assertEquals(16, cache.holdsize());
+        
+        assertTrue(cache.containsKey(160));
+        assertTrue(cache.containsKey(252));
+        
+        // we dont have any duplicates
+        assertEquals(32, cache0.size());
+        assertEquals(32, cache0.holdsize());
+    }
+    
+    @Test
+    public void testPass() {
+        Cache<Integer, String> cache = new Cache<>();
+        assertSame("A", cache.pass(17, "A"));
+        assertSame("B", cache.pass(17, "B"));
+        assertSame("C", cache.pass(17, "C"));
+        assertEquals(1, cache.size());
+    }
+    
+    @Test
+    public void testConstruct() {
+        try {
+            Cache<Integer, String> cache3 = new Cache<>(32,48);
+            fail("IllegalArgumentException expected");
+        } catch(IllegalArgumentException cause) {
+            assertTrue(true);
+        }
+    }
+	
+	private static String text(Random rand, int size) {
+		StrBuilder sb = new StrBuilder(size);
+		for(int i=0; i<size; i++) {
+			sb.append( (char)(' '+rand.nextInt(128)) );
+		}
+		return sb.toString();
+	}
+    
+	
+}

assira/src/test/java/net/ranides/assira/collection/maps/IntMapUtilsTest.java

@@ -0,0 +1,39 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.maps;
+
+import java.io.Serializable;
+import java.util.function.Supplier;
+import java.util.regex.Pattern;
+import net.ranides.assira.ContractTesters;
+import net.ranides.assira.collection.mockup.TMaps;
+import net.ranides.assira.collection.mockup.TPoint;
+import net.ranides.assira.test.TMap;
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class IntMapUtilsTest {
+	
+	private final TMap<Integer, String> $map = TMaps.MAP_IS;
+
+    @Test
+    public void testContract() {
+		Supplier<Integer> sup1 = (Serializable & Supplier<Integer>) () -> null;
+		
+        ContractTesters.runner()
+			.ignore(Pattern.compile(".*_HC"))
+			.param("map!", $map)
+			.supplier(() -> IntMapUtils.lazy(new IntAVLTreeMap<>($map.comparator()), sup1))
+			.run();
+    }
+	
+	
+}

assira/src/test/java/net/ranides/assira/collection/maps/MapUtilsTest.java

@@ -0,0 +1,36 @@
+/*
+ * @author Ranides Atterwim <ranides@gmail.com>
+ * @copyright Ranides Atterwim
+ * @license WTFPL
+ * @url http://ranides.net/projects/assira
+ */
+package net.ranides.assira.collection.maps;
+
+import java.io.Serializable;
+import java.util.function.Supplier;
+import net.ranides.assira.ContractTesters;
+import net.ranides.assira.collection.mockup.TMaps;
+import net.ranides.assira.collection.mockup.TPoint;
+import net.ranides.assira.test.TMap;
+import org.junit.Test;
+
+/**
+ *
+ * @author Ranides Atterwim <ranides@gmail.com>
+ */
+public class MapUtilsTest {
+	
+	private final TMap<TPoint, Integer> $map = TMaps.MAP_PI;
+
+    @Test
+    public void testContract() {
+		Supplier<Integer> sup1 = (Serializable & Supplier<Integer>) () -> null;
+		Supplier<Integer> sup2 = (Serializable & Supplier<Integer>) () -> 0;
+		
+        ContractTesters.runner()
+			.param("map!", $map)
+			.supplier(() -> MapUtils.lazy(new AVLTreeMap<>($map.comparator()), sup1))
+			.run();
+    }
+	
+}

assira/src/test/java/net/ranides/assira/collection/suite/lookups/LookupTester.java

@@ -9,6 +9,7 @@ package net.ranides.assira.collection.suite.lookups;
 import java.util.Iterator;
 import java.util.NoSuchElementException;
 import java.util.Set;
+import java.util.function.Supplier;
 import javax.annotation.Resource;
 import net.ranides.assira.collection.IntCollection;
 import net.ranides.assira.collection.iterators.IntIterator;
@@ -29,6 +30,11 @@ public final class LookupTester<K> {
     @Resource(name = "map!")
     private TMap<K,Integer> $var;
 	
+	@Resource(name = "map.default!")
+    private int $default = 0;
+	
+	private static final int DEFAULT = -4;
+	
     private static final int BASIC_PUT_MANY = 128;
     
     private static final int BASIC_PUT_REPLACE = 40;
@@ -127,7 +133,7 @@ public final class LookupTester<K> {
 	    
     @TestContract
     public void basicRemove(Lookup<K> target) {
-        target.defaultReturnValue(-1);
+        target.defaultReturnValue(DEFAULT);
         $var.list(1,2,3).into(target);
         
         assertNotRemove(target, $var.item(7));
@@ -143,7 +149,7 @@ public final class LookupTester<K> {
 	
 	@TestContract
     public void basicRemove_HC(Lookup<K> target) {
-        target.defaultReturnValue(-1);
+        target.defaultReturnValue(DEFAULT);
         $var.list(1,2,3).into(target);
         
         assertNotRemove(target, $var.item(1,1));
@@ -189,36 +195,49 @@ public final class LookupTester<K> {
     }
 	
 	@TestContract
-    public void basicGet(Lookup<K> target) {
-        target.defaultReturnValue(-1);
-        assertEquals(-1, target.getInt($var.item(1).key()));
+    public void basicGet(Supplier<Lookup<K>> f) {
+		Lookup<K> target1 = f.get();
+        target1.defaultReturnValue(DEFAULT);
+        assertEquals(DEFAULT, target1.getInt($var.item(1).key()));
 
-        $var.list(1,2,3).into(target);
-        assertEquals(3, target.size());
-        assertEquals(-1, target.getInt($var.item(7).key()));
+        $var.list(1,2,3).into(target1);
+        assertEquals(3, target1.size());
+        assertEquals(DEFAULT, target1.getInt($var.item(7).key()));
         
-        assertEquals($var.item(1).valueInt(), target.getInt($var.item(1).key()));
-        assertEquals($var.item(2).valueInt(), target.getInt($var.item(2).key()));
-        assertEquals($var.item(3).valueInt(), target.getInt($var.item(3).key()));
+        assertEquals($var.item(1).valueInt(), target1.getInt($var.item(1).key()));
+        assertEquals($var.item(2).valueInt(), target1.getInt($var.item(2).key()));
+        assertEquals($var.item(3).valueInt(), target1.getInt($var.item(3).key()));
+		
+		Lookup<K> target2 = f.get();
+        assertEquals($default, target2.getInt($var.item(1).key()));
+        $var.list(1,2,3).into(target2);
+        assertEquals($default, target2.getInt($var.item(7).key()));
     }
     
     @TestContract
-    public void basicGet_HC(Lookup<K> target) {
-        target.defaultReturnValue(-1);
-        assertEquals(-1, target.getInt($var.item(1).key()));
+    public void basicGet_HC(Supplier<Lookup<K>> f) {
+		Lookup<K> target1 = f.get();
+        target1.defaultReturnValue(DEFAULT);
+        assertEquals(DEFAULT, target1.getInt($var.item(1).key()));
 
-        $var.list(1,2,3).into(target);
-        assertEquals(3, target.size());
-        assertEquals(-1, target.getInt($var.item(1,1).key()));
+        $var.list(1,2,3).into(target1);
+        assertEquals(3, target1.size());
+        assertEquals(DEFAULT, target1.getInt($var.item(1,1).key()));
         
-        assertEquals($var.item(1).valueInt(), target.getInt($var.item(1).key()));
-        assertEquals($var.item(2).valueInt(), target.getInt($var.item(2).key()));
-        assertEquals($var.item(3).valueInt(), target.getInt($var.item(3).key()));
+        assertEquals($var.item(1).valueInt(), target1.getInt($var.item(1).key()));
+        assertEquals($var.item(2).valueInt(), target1.getInt($var.item(2).key()));
+        assertEquals($var.item(3).valueInt(), target1.getInt($var.item(3).key()));
+		
+		Lookup<K> target2 = f.get();
+        assertEquals($default, target2.getInt($var.item(1).key()));
+
+        $var.list(1,2,3).into(target2);
+        assertEquals($default, target2.getInt($var.item(1,1).key()));
     }
     
     @TestContract
     public void logicRemove(Lookup<K> target) {
-        target.defaultReturnValue(-1);
+        target.defaultReturnValue(DEFAULT);
 		$var.list(1,2,3).into(target);
 
 		assertNotRemove(target, $var.item(7));
@@ -237,10 +256,10 @@ public final class LookupTester<K> {
 	
 	@TestContract
     public void logicRemove_HC(Lookup<K> target) {
-        target.defaultReturnValue(-1);
+        target.defaultReturnValue(DEFAULT);
 		$var.list(1,2,3).into(target);
         
-        assertEquals(-1, target.removeInt($var.item(1,1).key()));
+        assertEquals(DEFAULT, target.removeInt($var.item(1,1).key()));
         assertEquals(3, target.size());
 		
         assertContains(target, $var.item(1));

assira/src/test/java/net/ranides/assira/collection/suite/maps/MapTester.java

@@ -598,11 +598,23 @@ public final class MapTester<K,V> {
     public void basicEquals_Entry(Map<K, V> target) {
         $var.list().item(5).item(5).item(6).item(2).into(target);
         
-        assertEquality(
-            findEntry(target, $var.item(5).key()), 
-            findEntry(target, $var.item(5).key()), 
-            findEntry(target, $var.item(2).key())
-        );
+		Entry<K,V> m1 = findEntry(target, $var.item(5).key());
+		Entry<K,V> m2 = findEntry(target, $var.item(5).key());
+		Entry<K,V> m3 = findEntry(target, $var.item(2).key());
+		Entry<K,V> e1 = $var.item(5).entry();
+		Entry<K,V> e2 = $var.item(5).entry();
+		Entry<K,V> e3 = $var.item(2).entry();
+		
+        assertEquality(m1,m2,m3);
+		
+		assertTrue( m1.equals(m1));
+		assertTrue( m1.equals(m2));
+		assertTrue( m1.equals(e1));
+		assertTrue( m1.equals(e2));
+		
+		assertFalse( m1.equals(m3));
+		assertFalse( m1.equals(e3));
+		assertFalse( m1.equals("qq"));
     }
     
     private Entry<K,V> findEntry(Map<K, V> target, K key) {