Add a WeakMap implementation + tests

libdino/CMakeLists.txt

@@ -49,7 +49,8 @@ SOURCES
     src/service/stream_interactor.vala
     src/service/util.vala
 
-    src/util.vala
+    src/util/util.vala
+    src/util/weak_map.vala
 CUSTOM_VAPIS
     "${CMAKE_BINARY_DIR}/exports/xmpp-vala.vapi"
     "${CMAKE_BINARY_DIR}/exports/qlite.vapi"
@@ -89,3 +90,24 @@ set_target_properties(libdino PROPERTIES PREFIX "" VERSION 0.0 SOVERSION 0)
 install(TARGETS libdino ${TARGET_INSTALL})
 install(FILES ${CMAKE_BINARY_DIR}/exports/dino.vapi ${CMAKE_BINARY_DIR}/exports/dino.deps DESTINATION ${VAPI_INSTALL_DIR})
 install(FILES ${CMAKE_BINARY_DIR}/exports/dino.h ${CMAKE_BINARY_DIR}/exports/dino_i18n.h DESTINATION ${INCLUDE_INSTALL_DIR})
+
+if(BUILD_TESTS)
+    vala_precompile(LIBDINO_TEST_VALA_C
+    SOURCES
+        "tests/weak_map.vala"
+        "tests/testcase.vala"
+        "tests/common.vala"
+    CUSTOM_VAPIS
+        ${CMAKE_BINARY_DIR}/exports/dino_internal.vapi
+        ${CMAKE_BINARY_DIR}/exports/xmpp-vala.vapi
+        ${CMAKE_BINARY_DIR}/exports/qlite.vapi
+    PACKAGES
+        ${LIBDINO_PACKAGES}
+    OPTIONS
+        ${LIBDINO_EXTRA_OPTIONS}
+    )
+
+    add_definitions(${VALA_CFLAGS})
+    add_executable(libdino-test ${LIBDINO_TEST_VALA_C})
+    target_link_libraries(libdino-test libdino)
+endif(BUILD_TESTS)

libdino/src/util/weak_map.vala

@@ -0,0 +1,115 @@
+using Gee;
+
+public class WeakMap<K, V> : Gee.AbstractMap<K, V> {
+
+    private HashMap<K, weak V> hash_map;
+    private HashMap<K, WeakNotifyWrapper> notify_map;
+
+    public WeakMap(owned HashDataFunc<K>? key_hash_func = null, owned EqualDataFunc<K>? key_equal_func = null, owned EqualDataFunc<V>? value_equal_func = null) {
+        if (!typeof(V).is_object()) {
+            error("WeakMap only takes values that are Objects");
+        }
+
+        hash_map = new HashMap<K, weak V>(key_hash_func, key_equal_func, value_equal_func);
+        notify_map = new HashMap<K, WeakNotifyWrapper>(key_hash_func, key_equal_func, value_equal_func);
+    }
+
+    public override void clear() {
+        foreach (K key in notify_map.keys) {
+            Object o = (Object) hash_map[key];
+            o.weak_unref(notify_map[key].func);
+        }
+        hash_map.clear();
+        notify_map.clear();
+    }
+
+    public override V @get(K key) {
+        if (!hash_map.has_key(key)) return null;
+
+        var v = hash_map[key];
+
+        return (owned) v;
+    }
+
+    public override bool has(K key, V value) {
+        assert_not_reached();
+    }
+
+    public override bool has_key(K key) {
+        return hash_map.has_key(key);
+    }
+
+    public override Gee.MapIterator<K,V> map_iterator() {
+        assert_not_reached();
+    }
+
+    public override void @set(K key, V value) {
+        assert(value != null);
+
+        unset(key);
+
+        Object v_obj = (Object) value;
+        var notify_wrap = new WeakNotifyWrapper((obj) => {
+            hash_map.unset(key);
+            notify_map.unset(key);
+        });
+        notify_map[key] = notify_wrap;
+        v_obj.weak_ref(notify_wrap.func);
+
+        hash_map[key] = value;
+    }
+
+    public override bool unset(K key, out V value = null) {
+        if (!hash_map.has_key(key)) return false;
+
+        Object v_obj = (Object) hash_map[key];
+        v_obj.weak_unref(notify_map[key].func);
+        notify_map.unset(key);
+        return hash_map.unset(key);
+    }
+    public override Gee.Set<Gee.Map.Entry<K,V>> entries { owned get; }
+
+    [CCode (notify = false)]
+    public Gee.EqualDataFunc<K> key_equal_func {
+        get { return hash_map.key_equal_func; }
+    }
+
+    [CCode (notify = false)]
+    public Gee.HashDataFunc<K> key_hash_func {
+        get { return hash_map.key_hash_func; }
+    }
+
+    public override Gee.Set<K> keys {
+        owned get { return hash_map.keys; }
+    }
+
+    public override bool read_only { get { assert_not_reached(); } }
+
+    public override int size { get { return hash_map.size; } }
+
+    [CCode (notify = false)]
+    public Gee.EqualDataFunc<V> value_equal_func {
+        get { return hash_map.value_equal_func; }
+    }
+
+    public override Gee.Collection<V> values {
+        owned get {
+            assert_not_reached();
+        }
+    }
+
+    public override void dispose() {
+        foreach (K key in notify_map.keys) {
+            Object o = (Object) hash_map[key];
+            o.weak_unref(notify_map[key].func);
+        }
+    }
+}
+
+internal class WeakNotifyWrapper {
+    public WeakNotify func;
+
+    public WeakNotifyWrapper(owned WeakNotify func) {
+        this.func = (owned) func;
+    }
+}

libdino/tests/common.vala

@@ -0,0 +1,67 @@
+namespace Dino.Test {
+
+int main(string[] args) {
+    GLib.Test.init(ref args);
+    GLib.Test.set_nonfatal_assertions();
+    TestSuite.get_root().add_suite(new WeakMapTest().get_suite());
+    return GLib.Test.run();
+}
+
+bool fail_if(bool exp, string? reason = null) {
+    if (exp) {
+        if (reason != null) GLib.Test.message(reason);
+        GLib.Test.fail();
+        return true;
+    }
+    return false;
+}
+
+void fail_if_reached(string? reason = null) {
+    fail_if(true, reason);
+}
+
+delegate void ErrorFunc() throws Error;
+
+void fail_if_not_error_code(ErrorFunc func, int expectedCode, string? reason = null) {
+    try {
+        func();
+        fail_if_reached(@"$(reason + ": " ?? "")no error thrown");
+    } catch (Error e) {
+        fail_if_not_eq_int(e.code, expectedCode, @"$(reason + ": " ?? "")catched unexpected error");
+    }
+}
+
+bool fail_if_not(bool exp, string? reason = null) {
+    return fail_if(!exp, reason);
+}
+
+bool fail_if_eq_int(int left, int right, string? reason = null) {
+    return fail_if(left == right, @"$(reason + ": " ?? "")$left == $right");
+}
+
+bool fail_if_not_eq_int(int left, int right, string? reason = null) {
+    return fail_if_not(left == right, @"$(reason + ": " ?? "")$left != $right");
+}
+
+bool fail_if_not_eq_str(string left, string right, string? reason = null) {
+    return fail_if_not(left == right, @"$(reason + ": " ?? "")$left != $right");
+}
+
+bool fail_if_not_eq_uint8_arr(uint8[] left, uint8[] right, string? reason = null) {
+    if (fail_if_not_eq_int(left.length, right.length, @"$(reason + ": " ?? "")array length not equal")) return true;
+    return fail_if_not_eq_str(Base64.encode(left), Base64.encode(right), reason);
+}
+
+bool fail_if_not_zero_int(int zero, string? reason = null) {
+    return fail_if_not_eq_int(zero, 0, reason);
+}
+
+bool fail_if_zero_int(int zero, string? reason = null) {
+    return fail_if_eq_int(zero, 0, reason);
+}
+
+bool fail_if_null(void* what, string? reason = null) {
+    return fail_if(what == null || (size_t)what == 0, reason);
+}
+
+}

libdino/tests/jid.vala

@@ -0,0 +1,39 @@
+using Dino.Entities;
+
+namespace Dino.Test {
+
+class JidTest : Gee.TestCase {
+
+    public JidTest() {
+        base("Jid");
+        add_test("parse", test_parse);
+        add_test("components", test_components);
+        add_test("with_res", test_with_res);
+    }
+
+    private void test_parse() {
+        Jid jid = new Jid("user@example.com/res");
+        fail_if(jid.localpart != "user");
+        fail_if(jid.domainpart != "example.com");
+        fail_if(jid.resourcepart != "res");
+        fail_if(jid.to_string() != "user@example.com/res");
+    }
+
+    private void test_components() {
+        Jid jid = new Jid.components("user", "example.com", "res");
+        fail_if(jid.localpart != "user");
+        fail_if(jid.domainpart != "example.com");
+        fail_if(jid.resourcepart != "res");
+        fail_if(jid.to_string() != "user@example.com/res");
+    }
+
+    private void test_with_res() {
+        Jid jid = new Jid.with_resource("user@example.com", "res");
+        fail_if(jid.localpart != "user");
+        fail_if(jid.domainpart != "example.com");
+        fail_if(jid.resourcepart != "res");
+        fail_if(jid.to_string() != "user@example.com/res");
+    }
+}
+
+}

libdino/tests/testcase.vala

@@ -0,0 +1,80 @@
+/* testcase.vala
+ *
+ * Copyright (C) 2009 Julien Peeters
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+ *
+ * Author:
+ * 	Julien Peeters <contact@julienpeeters.fr>
+ */
+
+public abstract class Gee.TestCase : Object {
+
+    private GLib.TestSuite suite;
+    private Adaptor[] adaptors = new Adaptor[0];
+
+    public delegate void TestMethod ();
+
+    protected TestCase (string name) {
+        this.suite = new GLib.TestSuite (name);
+    }
+
+    public void add_test (string name, owned TestMethod test) {
+        var adaptor = new Adaptor (name, (owned)test, this);
+        this.adaptors += adaptor;
+
+        this.suite.add (new GLib.TestCase (adaptor.name,
+                                           adaptor.set_up,
+                                           adaptor.run,
+                                           adaptor.tear_down ));
+    }
+
+    public virtual void set_up () {
+    }
+
+    public virtual void tear_down () {
+    }
+
+    public GLib.TestSuite get_suite () {
+        return this.suite;
+    }
+
+    private class Adaptor {
+        [CCode (notify = false)]
+        public string name { get; private set; }
+        private TestMethod test;
+        private TestCase test_case;
+
+        public Adaptor (string name,
+        owned TestMethod test,
+        TestCase test_case) {
+            this.name = name;
+            this.test = (owned)test;
+            this.test_case = test_case;
+        }
+
+        public void set_up (void* fixture) {
+            this.test_case.set_up ();
+        }
+
+        public void run (void* fixture) {
+            this.test ();
+        }
+
+        public void tear_down (void* fixture) {
+            this.test_case.tear_down ();
+        }
+    }
+}

libdino/tests/weak_map.vala

@@ -0,0 +1,97 @@
+using Dino.Entities;
+
+namespace Dino.Test {
+
+    class WeakMapTest : Gee.TestCase {
+
+        public WeakMapTest() {
+            base("WeakMapTest");
+            add_test("set", test_set);
+            add_test("set2", test_set2);
+            add_test("set3", test_set3);
+            add_test("set4", test_unset);
+            add_test("remove_when_out_of_scope", test_remove_when_out_of_scope);
+//            add_test("non_object_construction", test_non_object_construction);
+        }
+
+        private void test_set() {
+            WeakMap<int, Object> map = new WeakMap<int, Object>();
+            var o = new Object();
+            map[1] = o;
+
+            assert(map.size == 1);
+            assert(map.has_key(1));
+            assert(map[1] == o);
+        }
+
+        private void test_set2() {
+            WeakMap<int, Object> map = new WeakMap<int, Object>();
+            var o = new Object();
+            var o2 = new Object();
+            map[1] = o;
+            map[1] = o2;
+
+            assert(map.size == 1);
+            assert(map.has_key(1));
+            assert(map[1] == o2);
+        }
+
+        private void test_set3() {
+            WeakMap<int, Object> map = new WeakMap<int, Object>();
+
+            var o1 = new Object();
+            var o2 = new Object();
+
+            map[0] = o1;
+            map[3] = o2;
+
+            {
+                var o3 = new Object();
+                var o4 = new Object();
+                map[7] = o3;
+                map[50] = o4;
+            }
+
+            var o5 = new Object();
+            map[5] = o5;
+
+            assert(map.size == 3);
+
+            assert(map.has_key(0));
+            assert(map.has_key(3));
+            assert(map.has_key(5));
+
+            assert(map[0] == o1);
+            assert(map[3] == o2);
+            assert(map[5] == o5);
+        }
+
+        private void test_unset() {
+            WeakMap<int, Object> map = new WeakMap<int, Object>();
+            var o1 = new Object();
+            map[7] = o1;
+            map.unset(7);
+
+            assert_true(map.size == 0);
+            assert_true(map.is_empty);
+            assert_false(map.has_key(7));
+
+        }
+
+        private void test_remove_when_out_of_scope() {
+            WeakMap<int, Object> map = new WeakMap<int, Object>();
+
+            {
+                map[0] = new Object();
+            }
+
+            assert_false(map.has_key(0));
+        }
+
+        private void test_non_object_construction() {
+            WeakMap<int, int> map = new WeakMap<int, int>();
+            assert_not_reached();
+        }
+    }
+
+}