resolve #91

assira.commons/src/main/java/net/ranides/assira/observable/ObservableList.java

@@ -69,9 +69,12 @@ public class ObservableList<T> extends AbstractList<T> {
 
     @Override
     public boolean addAll(int index, Collection<? extends T> c) {
-        list.addAll(index, c);
-        router.signalEvent(new ListEvent.AddMany<>(list, c));
-        return true;
+        if(list.addAll(index, c)) {
+            router.signalEvent(new ListEvent.AddMany<>(list, c));
+            return true;
+        } else {
+            return false;
+        }
     }
 
     @Override

assira.commons/src/test/java/net/ranides/assira/observable/ObservableCollectionTest.java

@@ -0,0 +1,25 @@
+package net.ranides.assira.observable;
+
+import net.ranides.assira.collection.ACollectionTest;
+import net.ranides.assira.events.EventDispatcher;
+import net.ranides.test.ContractTesters;
+import net.ranides.test.data.TCollection;
+import net.ranides.test.data.TMaps;
+import net.ranides.test.data.TPoint;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ObservableCollectionTest {
+
+    private final TCollection<TPoint> $var = TMaps.MAP_PI.keys();
+
+    @Test
+    public void testSuite() {
+        ContractTesters.runner()
+            .param("collection!", $var)
+            .function(new int[0], (array) -> new ObservableCollection(EventDispatcher.newInstance(), $var.list(array).intoList() ))
+            .run();
+    }
+
+}

assira.commons/src/test/java/net/ranides/assira/observable/ObservableGenericMapTest.java

@@ -0,0 +1,60 @@
+package net.ranides.assira.observable;
+
+import net.ranides.assira.collection.prototype.GenericMap;
+import net.ranides.assira.collection.prototype.OpenGenericMap;
+import net.ranides.assira.events.EventDispatcher;
+import net.ranides.assira.events.EventRouter;
+import net.ranides.assira.math.MutableNumber;
+import net.ranides.assira.math.MutableNumber.MutableInteger;
+import net.ranides.test.contracts.collection.maps.GenericMapTester;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ObservableGenericMapTest {
+
+    @Test
+    public void basic() {
+        MutableInteger counter = new MutableInteger(0);
+        GenericMapTester.basic(() -> newMap(counter));
+        assertEquals(6, counter.intValue());
+    }
+
+    @Test
+    public void contains() {
+        MutableInteger counter = new MutableInteger(0);
+        GenericMapTester.contains(() -> newMap(counter));
+        assertEquals(4, counter.intValue());
+    }
+
+    @Test
+    public void entries() {
+        MutableInteger counter = new MutableInteger(0);
+        GenericMapTester.entries(() -> newMap(counter));
+        assertEquals(4, counter.intValue());
+    }
+
+    @Test
+    public void views() {
+        MutableInteger counter = new MutableInteger(0);
+        GenericMapTester.views(() -> newMap(counter));
+        assertEquals(4, counter.intValue());
+    }
+
+    @Test
+    public void setEntry() {
+        MutableInteger counter = new MutableInteger(0);
+        GenericMapTester.setEntry(() -> newMap(counter));
+        assertEquals(4, counter.intValue());
+    }
+
+    private <T> GenericMap<T> newMap(MutableInteger counter) {
+        EventDispatcher dispatcher = EventDispatcher.newInstance();
+        ObservableGenericMap<T> map = new ObservableGenericMap<>(dispatcher);
+        map.addEventListener(GenericMapEvent.class, v -> {
+            counter.increment();
+        });
+        return map;
+    }
+
+}

assira.commons/src/test/java/net/ranides/assira/observable/ObservableListTest.java

@@ -0,0 +1,26 @@
+package net.ranides.assira.observable;
+
+import net.ranides.assira.collection.lists.RTList;
+import net.ranides.assira.events.EventDispatcher;
+import net.ranides.test.ContractTesters;
+import net.ranides.test.data.TCollection;
+import net.ranides.test.data.TMaps;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ObservableListTest {
+
+    private final TCollection<Integer> $var = TMaps.MAP_IS.keys();
+
+    @Test
+    public void testSuite() {
+        ContractTesters.runner()
+            .param("collection!", $var)
+            .ignore("ListTester.basicSerializable")
+            .function(new int[0], array -> new ObservableList(EventDispatcher.newInstance(), $var.list(array).intoList()))
+            .run();
+
+    }
+
+}

assira.commons/src/test/java/net/ranides/assira/observable/ObservableMapTest.java

@@ -0,0 +1,27 @@
+package net.ranides.assira.observable;
+
+import net.ranides.assira.collection.maps.OpenMap;
+import net.ranides.assira.events.EventDispatcher;
+import net.ranides.assira.events.EventRouter;
+import net.ranides.test.ContractTesters;
+import net.ranides.test.data.TMap;
+import net.ranides.test.data.TMaps;
+import net.ranides.test.data.TPoint;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class ObservableMapTest {
+    private final TMap<TPoint, Integer> $map = TMaps.MAP_PI;
+
+    @Test
+    public void testSuite() {
+        EventRouter router = EventDispatcher.newInstance();
+        ContractTesters.runner()
+            .param("map!", $map)
+            .ignore("MapTester.basicSerializable")
+            .ignore("MapTester.basicSerializable_HC")
+            .function(new int[0], array -> $map.list(array).into(new ObservableMap<>(router, new OpenMap<>())))
+            .run();
+    }
+}

assira.commons/src/test/java/net/ranides/assira/observable/ObservablePrototypeMapTest.java

@@ -0,0 +1,107 @@
+package net.ranides.assira.observable;
+
+import net.ranides.assira.collection.prototype.PrototypeMap;
+import net.ranides.assira.events.EventDispatcher;
+import net.ranides.assira.events.EventRouter;
+import net.ranides.test.ContractTesters;
+import net.ranides.test.data.TMap;
+import net.ranides.test.data.TMaps;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.*;
+import java.util.regex.Pattern;
+
+import static org.junit.Assert.*;
+
+public class ObservablePrototypeMapTest {
+
+    private final TMap<Object, Object> $map = TMaps.MAP_SI;
+
+    List<MapEvent<Object, Object>> events;
+    EventRouter router;
+    PrototypeMap map1;
+    PrototypeMap map2;
+    PrototypeMap map3;
+    PrototypeMap map4;
+
+    @Before
+    public void init() {
+        events = new ArrayList<>();
+        router = EventDispatcher.newInstance();
+        router.addEventListener(MapEvent.class, v -> events.add(v));
+
+        map1 = new ObservablePrototypeMap(router);
+        map2 = new ObservablePrototypeMap(router, map1);
+        map3 = new ObservablePrototypeMap(router, map2);
+        map4 = new ObservablePrototypeMap(router, map3);
+
+        map1.getDeclaredMap().put("a", 11);
+        map1.getDeclaredMap().put("b", 12);
+        map2.getDeclaredMap().put("c", 13);
+        map2.getDeclaredMap().put("d", 14);
+        map3.getDeclaredMap().put("e", 15);
+        map3.getDeclaredMap().put("f", 16);
+    }
+
+    @Test
+    public void testSuite() {
+        ContractTesters.runner()
+            .param("map!", $map)
+            .ignore(Pattern.compile(".*_HC"))
+            .ignore("MapTester.basicSerializable")
+            .function(new int[0], array -> $map.list(array).into(new ObservablePrototypeMap(EventDispatcher.newInstance())))
+            .run();
+    }
+
+    @Test
+    public void basic() {
+        assertEquals(12, map1.get("b"));
+        assertEquals(12, map2.get("b"));
+        assertEquals(12, map3.get("b"));
+        assertEquals(12, map4.get("b"));
+
+        assertEquals(16, map3.get("f"));
+        assertEquals(16, map4.get("f"));
+
+        assertTrue(map1.containsKey("b"));
+        assertTrue(map4.containsKey("b"));
+
+        assertTrue(map3.containsKey("f"));
+        assertTrue(map4.containsKey("f"));
+
+        assertTrue(map1.getDeclaredMap().containsKey("b"));
+        assertFalse(map4.getDeclaredMap().containsKey("b"));
+
+        assertTrue(map3.containsKey("f"));
+        assertFalse(map4.getDeclaredMap().containsKey("f"));
+
+        long declared = events.stream().map(event -> System.identityHashCode(event.map())).distinct().count();
+        assertEquals(3, declared);
+        assertEquals(6, events.size());
+    }
+
+    @Test
+    public void entrySet_remove() {
+        List<Map.Entry<Object, Object>> entries = new ArrayList<>(map1.entrySet());
+
+        Iterator<Map.Entry<Object, Object>> a = map1.entrySet().iterator();
+        a.next();
+        a.remove();
+
+        for (Map.Entry<Object, Object> entry : entries) {
+            assertNotNull(entry.getKey());
+            assertNotNull(entry.getValue());
+        }
+
+        assertEquals(1, map1.size());
+        assertEquals(7, events.size());
+
+        a.next();
+        a.remove();
+
+        assertEquals(0, map1.size());
+        assertEquals(8, events.size());
+    }
+
+}

assira.core/src/test/java/net/ranides/assira/collection/maps/OpenGenericMapTest.java

@@ -1,129 +1,34 @@
 package net.ranides.assira.collection.maps;
 
-import net.ranides.assira.collection.prototype.GenericEntry;
 import net.ranides.assira.collection.prototype.OpenGenericMap;
-import net.ranides.assira.collection.prototype.GenericKey;
-import net.ranides.assira.collection.prototype.GenericMap;
-import net.ranides.assira.junit.NewAssert;
+import net.ranides.test.contracts.collection.maps.GenericMapTester;
 import org.junit.Test;
 
-import java.util.stream.Collectors;
-
-import static org.junit.Assert.*;
-
 public class OpenGenericMapTest {
 
-    private static final GenericKey<String, Integer>      I_A = GenericKey.of(Integer.class, "a");
-    private static final GenericKey<String, String>       S_A = GenericKey.of(String.class, "a");
-    private static final GenericKey<String, Integer>      I_B = GenericKey.of(Integer.class, "b");
-    private static final GenericKey<String, Double>       D_C = GenericKey.of(Double.class, "c");
-    private static final GenericKey<String, CharSequence> C_D = GenericKey.of(CharSequence.class, "d");
-    private static final GenericKey<String, CharSequence> C_E = GenericKey.of(CharSequence.class, "e");
-
     @Test
     public void basic() {
-        GenericMap<String> map1 = new OpenGenericMap<>();
-
-//        map.put(a, "Hello"); // compiler error :-)
-//        map.put(a, 45.6); // compiler error :-)
-//        map.put(c, 1); // compiler error :-)
-
-        map1.put(I_A, 45);
-        map1.put(I_B, 32);
-        map1.put(D_C, 1.5);
-        map1.put(C_D, "text");
-
-        GenericMap<String> map2 = new OpenGenericMap<>();
-        map2.putAll(map1);
-
-        assertEquals(map1, map2);
-
-        assertEquals((Integer)45, map1.remove(I_A));
-        assertNull(map1.remove(I_A));
-        assertNull(map1.remove(C_E));
-
-        assertEquals(3, map1.size());
-        assertEquals(4, map2.size());
-
-        assertNotEquals(map1, map2);
-
-        assertFalse(map1.containsKey(I_A));
-        assertTrue(map1.containsKey(C_D));
-        assertTrue(map1.containsValue("text"));
-        assertFalse(map1.containsValue(45));
+        GenericMapTester.basic(OpenGenericMap::new);
     }
 
     @Test
     public void contains() {
-        GenericMap<String> map1 = new OpenGenericMap<>();
-
-        map1.put(I_A, 45);
-        map1.put(I_B, 32);
-        map1.put(D_C, 1.5);
-        map1.put(C_D, "text");
-
-        assertTrue(map1.containsKey(I_A));
-        assertTrue(map1.containsKey(I_B));
-        assertFalse(map1.containsKey(S_A));
+        GenericMapTester.contains(OpenGenericMap::new);
     }
 
     @Test
     public void entries() {
-        GenericMap<String> map1 = new OpenGenericMap<>();
-
-        map1.put(I_A, 45);
-        map1.put(I_B, 32);
-        map1.put(D_C, 1.5);
-        map1.put(C_D, "text");
-
-        assertEquals(4, map1.entrySet().size());
-
-        assertTrue(map1.entrySet().contains(new GenericEntry.Simple<>(I_A, 45)));
-        assertFalse(map1.entrySet().contains(new GenericEntry.Simple<>(I_A, 44)));
-
-        boolean found = map1.entrySet().stream()
-                .filter(e -> e.getKey().equals(I_B))
-                .findFirst()
-                .map(e -> e.equals(new GenericEntry.Simple<>(I_B, 32)))
-                .orElse(false);
-
-        assertTrue(found);
-
+        GenericMapTester.entries(OpenGenericMap::new);
     }
 
     @Test
     public void views() {
-        GenericMap<String> map1 = new OpenGenericMap<>();
-
-        map1.put(I_A, 45);
-        map1.put(I_B, 32);
-        map1.put(D_C, 1.5);
-        map1.put(C_D, "text");
-
-        assertEquals("1.5,32,45,text", map1.values().stream().map(String::valueOf).sorted().collect(Collectors.joining(",")) );
-        assertEquals("a:Integer,b:Integer,c:Double,d:CharSequence", map1.keySet().stream().map(String::valueOf).sorted().collect(Collectors.joining(",")) );
+        GenericMapTester.views(OpenGenericMap::new);
     }
 
     @Test
     public void setEntry() {
-        GenericMap<String> map1 = new OpenGenericMap<>();
-
-        map1.put(I_A, 45);
-        map1.put(I_B, 32);
-        map1.put(D_C, 1.5);
-        map1.put(C_D, "text");
-
-        GenericEntry<String> entry = map1.entrySet().stream()
-                .filter(e -> e.getKey().equals(I_B))
-                .findFirst()
-                .get();
-
-        entry.setValue(88);
-        assertEquals((Integer)88, map1.get(I_B));
-
-        NewAssert.assertThrows(ClassCastException.class, () -> {
-            entry.setValue("text");
-        });
+        GenericMapTester.setEntry(OpenGenericMap::new);
     }
 
 }

assira.core/src/test/java/net/ranides/test/contracts/collection/maps/GenericMapTester.java

@@ -0,0 +1,121 @@
+package net.ranides.test.contracts.collection.maps;
+
+import net.ranides.assira.collection.prototype.*;
+import net.ranides.assira.junit.NewAssert;
+
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+
+import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+
+public class GenericMapTester {
+
+    private static final GenericKey<String, Integer> I_A = GenericKey.of(Integer.class, "a");
+    private static final GenericKey<String, String>       S_A = GenericKey.of(String.class, "a");
+    private static final GenericKey<String, Integer>      I_B = GenericKey.of(Integer.class, "b");
+    private static final GenericKey<String, Double>       D_C = GenericKey.of(Double.class, "c");
+    private static final GenericKey<String, CharSequence> C_D = GenericKey.of(CharSequence.class, "d");
+    private static final GenericKey<String, CharSequence> C_E = GenericKey.of(CharSequence.class, "e");
+
+    public static void basic(Supplier<GenericMap<String>> factory) {
+        GenericMap<String> map1 = factory.get();
+
+//        map.put(a, "Hello"); // compiler error :-)
+//        map.put(a, 45.6); // compiler error :-)
+//        map.put(c, 1); // compiler error :-)
+
+        map1.put(I_A, 45);
+        map1.put(I_B, 32);
+        map1.put(D_C, 1.5);
+        map1.put(C_D, "text");
+
+        GenericMap<String> map2 = factory.get();
+        map2.putAll(map1);
+
+        assertEquals(map1, map2);
+
+        assertEquals((Integer)45, map1.remove(I_A));
+        assertNull(map1.remove(I_A));
+        assertNull(map1.remove(C_E));
+
+        assertEquals(3, map1.size());
+        assertEquals(4, map2.size());
+
+        assertNotEquals(map1, map2);
+
+        assertFalse(map1.containsKey(I_A));
+        assertTrue(map1.containsKey(C_D));
+        assertTrue(map1.containsValue("text"));
+        assertFalse(map1.containsValue(45));
+    }
+
+    public static void contains(Supplier<GenericMap<String>> factory) {
+        GenericMap<String> map1 = factory.get();
+
+        map1.put(I_A, 45);
+        map1.put(I_B, 32);
+        map1.put(D_C, 1.5);
+        map1.put(C_D, "text");
+
+        assertTrue(map1.containsKey(I_A));
+        assertTrue(map1.containsKey(I_B));
+        assertFalse(map1.containsKey(S_A));
+    }
+
+    public static void entries(Supplier<GenericMap<String>> factory) {
+        GenericMap<String> map1 = factory.get();
+
+        map1.put(I_A, 45);
+        map1.put(I_B, 32);
+        map1.put(D_C, 1.5);
+        map1.put(C_D, "text");
+
+        assertEquals(4, map1.entrySet().size());
+
+        assertTrue(map1.entrySet().contains(new GenericEntry.Simple<>(I_A, 45)));
+        assertFalse(map1.entrySet().contains(new GenericEntry.Simple<>(I_A, 44)));
+
+        boolean found = map1.entrySet().stream()
+            .filter(e -> e.getKey().equals(I_B))
+            .findFirst()
+            .map(e -> e.equals(new GenericEntry.Simple<>(I_B, 32)))
+            .orElse(false);
+
+        assertTrue(found);
+
+    }
+
+    public static void views(Supplier<GenericMap<String>> factory) {
+        GenericMap<String> map1 = factory.get();
+
+        map1.put(I_A, 45);
+        map1.put(I_B, 32);
+        map1.put(D_C, 1.5);
+        map1.put(C_D, "text");
+
+        assertEquals("1.5,32,45,text", map1.values().stream().map(String::valueOf).sorted().collect(Collectors.joining(",")) );
+        assertEquals("a:Integer,b:Integer,c:Double,d:CharSequence", map1.keySet().stream().map(String::valueOf).sorted().collect(Collectors.joining(",")) );
+    }
+
+    public static void setEntry(Supplier<GenericMap<String>> factory) {
+        GenericMap<String> map1 = factory.get();
+
+        map1.put(I_A, 45);
+        map1.put(I_B, 32);
+        map1.put(D_C, 1.5);
+        map1.put(C_D, "text");
+
+        GenericEntry<String> entry = map1.entrySet().stream()
+            .filter(e -> e.getKey().equals(I_B))
+            .findFirst()
+            .get();
+
+        entry.setValue(88);
+        assertEquals((Integer)88, map1.get(I_B));
+
+        NewAssert.assertThrows(ClassCastException.class, () -> {
+            entry.setValue("text");
+        });
+    }
+}