eina_mono: custom iterators for Inlist and Hash, and more tests

5 files changed, 491 insertions, 39 deletions

diff --git a/src/bindings/mono/eina_mono/eina_container_common.cs b/src/bindings/mono/eina_mono/eina_container_common.cs
index 0f78d7adb0..e798fd11a1 100644
--- a/src/bindings/mono/eina_mono/eina_container_common.cs
+++ b/src/bindings/mono/eina_mono/eina_container_common.cs
@@ -83,6 +83,7 @@ public interface IBaseElementTraits<T>
     IntPtr EinaFreeCb();
     IntPtr EinaHashNew();
     IntPtr EinaInarrayNew(uint step);
+    IntPtr EinaHashIteratorKeyNew(IntPtr hash);
 }
 
 public class StringElementTraits<T> : IBaseElementTraits<T>
@@ -208,6 +209,11 @@ public class StringElementTraits<T> : IBaseElementTraits<T>
     {
         return eina_inarray_new((uint)Marshal.SizeOf<IntPtr>(), step);
     }
+
+    public IntPtr EinaHashIteratorKeyNew(IntPtr hash)
+    {
+        return eina_hash_iterator_key_new(hash);
+    }
 }
 
 public class EflObjectElementTraits<T> : IBaseElementTraits<T>
@@ -343,6 +349,11 @@ public class EflObjectElementTraits<T> : IBaseElementTraits<T>
     {
         return eina_inarray_new((uint)Marshal.SizeOf<IntPtr>(), step);
     }
+
+    public IntPtr EinaHashIteratorKeyNew(IntPtr hash)
+    {
+        return eina_hash_iterator_ptr_key_wrapper_new_custom_export_mono(hash);
+    }
 }
 
 public abstract class PrimitiveElementTraits<T>
@@ -454,6 +465,11 @@ public abstract class PrimitiveElementTraits<T>
     {
         return eina_inarray_new((uint)Marshal.SizeOf<T>(), step);
     }
+
+    public IntPtr EinaHashIteratorKeyNew(IntPtr hash)
+    {
+        return eina_hash_iterator_key_new(hash);
+    }
 }
 
 public class Primitive32ElementTraits<T> : PrimitiveElementTraits<T>, IBaseElementTraits<T>
@@ -680,6 +696,11 @@ public static class TraitFunctions
     {
         return GetTypeTraits<T>().EinaInarrayNew(step);
     }
+
+    public static IntPtr EinaHashIteratorKeyNew<T>(IntPtr hash)
+    {
+        return GetTypeTraits<T>().EinaHashIteratorKeyNew(hash);
+    }
 }
 
 }
diff --git a/src/bindings/mono/eina_mono/eina_hash.cs b/src/bindings/mono/eina_mono/eina_hash.cs
index e63a89df24..1b4711f78d 100644
--- a/src/bindings/mono/eina_mono/eina_hash.cs
+++ b/src/bindings/mono/eina_mono/eina_hash.cs
@@ -123,6 +123,9 @@ public static class HashNativeFunctions
 
     [DllImport("eina")] public static extern int
         eina_hash_superfast(string key, int len);
+
+    [DllImport("eflcustomexportsmono")] public static extern IntPtr
+        eina_hash_iterator_ptr_key_wrapper_new_custom_export_mono(IntPtr hash);
 }
 
 public class Hash<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IDisposable
@@ -360,12 +363,12 @@ public class Hash<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>, IDi
         return eina_hash_population(Handle);
     }
 
-    public eina.Iterator<TKey> GetKeyIterator()
+    public eina.Iterator<TKey> Keys()
     {
-        return new eina.Iterator<TKey>(eina_hash_iterator_key_new(Handle), true, false);
+        return new eina.Iterator<TKey>(EinaHashIteratorKeyNew<TKey>(Handle), true, false);
     }
 
-    public eina.Iterator<TValue> GetValueIterator()
+    public eina.Iterator<TValue> Values()
     {
         return new eina.Iterator<TValue>(eina_hash_iterator_data_new(Handle), true, false);
     }
diff --git a/src/bindings/mono/eina_mono/eina_inlist.cs b/src/bindings/mono/eina_mono/eina_inlist.cs
index ab5468e903..10feba23fc 100644
--- a/src/bindings/mono/eina_mono/eina_inlist.cs
+++ b/src/bindings/mono/eina_mono/eina_inlist.cs
@@ -72,6 +72,9 @@ public static class InlistNativeFunctions
         eina_inlist_next_custom_export_mono(IntPtr list);
     [DllImport("eflcustomexportsmono")] public static extern IntPtr
         eina_inlist_prev_custom_export_mono(IntPtr list);
+
+    [DllImport("eflcustomexportsmono")] public static extern IntPtr
+        eina_inlist_iterator_wrapper_new_custom_export_mono(IntPtr in_list);
 }
 
 public class Inlist<T> : IEnumerable<T>, IDisposable
@@ -293,7 +296,7 @@ public class Inlist<T> : IEnumerable<T>, IDisposable
 
     public eina.Iterator<T> GetIterator()
     {
-        return new eina.Iterator<T>(eina_inlist_iterator_new(Handle), true, false);
+        return new eina.Iterator<T>(eina_inlist_iterator_wrapper_new_custom_export_mono(Handle), true, false);
     }
 
     public IEnumerator<T> GetEnumerator()
diff --git a/src/lib/efl_mono/efl_custom_exports_mono.c b/src/lib/efl_mono/efl_custom_exports_mono.c
index cd48721daf..d6110317b9 100644
--- a/src/lib/efl_mono/efl_custom_exports_mono.c
+++ b/src/lib/efl_mono/efl_custom_exports_mono.c
@@ -79,6 +79,50 @@ EAPI Eina_Free_Cb efl_mono_native_efl_unref_addr_get()
     return (Eina_Free_Cb)efl_unref;
 }
 
+// Iterator Wrapper //
+
+typedef struct _Eina_Iterator_Wrapper_Mono
+{
+   Eina_Iterator iterator; // Must be the first
+   Eina_Iterator *internal;
+} Eina_Iterator_Wrapper_Mono;
+
+static void *eina_iterator_wrapper_get_container_mono(Eina_Iterator_Wrapper_Mono *it)
+{
+   return eina_iterator_container_get(it->internal);
+}
+
+static void eina_iterator_wrapper_free_mono(Eina_Iterator_Wrapper_Mono *it)
+{
+   eina_iterator_free(it->internal);
+   free(it);
+}
+
+
+static Eina_Iterator *eina_iterator_wrapper_new_mono(Eina_Iterator *internal, Eina_Iterator_Next_Callback next_cb)
+{
+   if (!internal) return NULL;
+
+   Eina_Iterator_Wrapper_Mono *it = calloc(1, sizeof(Eina_Iterator_Wrapper_Mono));
+   if (!it)
+     {
+        eina_iterator_free(internal);
+        return NULL;
+     }
+
+   it->internal = internal;
+
+   it->iterator.next = next_cb;
+
+   it->iterator.version = EINA_ITERATOR_VERSION;
+   it->iterator.get_container = FUNC_ITERATOR_GET_CONTAINER(eina_iterator_wrapper_get_container_mono);
+   it->iterator.free = FUNC_ITERATOR_FREE(eina_iterator_wrapper_free_mono);
+
+   EINA_MAGIC_SET(&it->iterator, EINA_MAGIC_ITERATOR);
+
+   return &it->iterator;
+}
+
 // Array //
 
 EAPI void eina_array_free_generic_custom_export_mono(Eina_Array *array) EINA_ARG_NONNULL(1)
@@ -182,6 +226,30 @@ EAPI void *eina_list_last_data_get_custom_export_mono(const Eina_List *list)
 
 // Inlist //
 
+typedef struct _Inlist_Node_Mono
+{
+   EINA_INLIST;
+   char mem_start;
+} Inlist_Node_Mono;
+
+static Eina_Bool eina_inlist_iterator_wrapper_next_mono(Eina_Iterator_Wrapper_Mono *it, void **data)
+{
+   Inlist_Node_Mono *node = NULL;
+
+   if (!eina_iterator_next(it->internal, (void**)&node))
+     return EINA_FALSE;
+
+   if (data)
+     *data = &node->mem_start;
+
+   return EINA_TRUE;
+}
+
+EAPI Eina_Iterator *eina_inlist_iterator_wrapper_new_custom_export_mono(const Eina_Inlist *in_list)
+{
+   return eina_iterator_wrapper_new_mono(eina_inlist_iterator_new(in_list), FUNC_ITERATOR_NEXT(eina_inlist_iterator_wrapper_next_mono));
+}
+
 EAPI Eina_Inlist *eina_inlist_first_custom_export_mono(const Eina_Inlist *list)
 {
    return eina_inlist_first(list);
@@ -205,3 +273,24 @@ EAPI Eina_Inlist *eina_inlist_prev_custom_export_mono(const Eina_Inlist *list)
      return list->prev;
    return NULL;
 }
+
+// Hash //
+
+static Eina_Bool eina_hash_iterator_ptr_key_wrapper_next_mono(Eina_Iterator_Wrapper_Mono *it, void **data)
+{
+   void **ptr = NULL;
+
+   if (!eina_iterator_next(it->internal, (void**)&ptr))
+     return EINA_FALSE;
+
+   if (data)
+     *data = *ptr;
+
+   return EINA_TRUE;
+}
+
+EAPI Eina_Iterator *eina_hash_iterator_ptr_key_wrapper_new_custom_export_mono(const Eina_Hash *hash)
+{
+   return eina_iterator_wrapper_new_mono(eina_hash_iterator_key_new(hash), FUNC_ITERATOR_NEXT(eina_hash_iterator_ptr_key_wrapper_next_mono));
+}
+
diff --git a/src/tests/efl_mono/Eina.cs b/src/tests/efl_mono/Eina.cs
index 2a0b972f56..2039475a4d 100644
--- a/src/tests/efl_mono/Eina.cs
+++ b/src/tests/efl_mono/Eina.cs
@@ -3300,12 +3300,12 @@ class TestEinaIterator
     {
         var arr = new eina.Array<int>();
         var itr = arr.GetIterator();
-        bool entered = false;
+        int idx = 0;
         foreach (int e in itr)
         {
-            entered = true;
+            ++idx;
         }
-        Test.Assert(!entered);
+        Test.AssertEquals(idx, 0);
     }
 
     public static void eina_array_int_filled_iterator()
@@ -3313,27 +3313,25 @@ class TestEinaIterator
         var arr = new eina.Array<int>();
         arr.Append(base_seq_int);
         var itr = arr.GetIterator();
-        bool entered = false;
-        var i = 0;
+        int idx = 0;
         foreach (int e in itr)
         {
-            entered = true;
-            Test.Assert(e == base_seq_int[i]);
-            ++i;
+            Test.Assert(e == base_seq_int[idx]);
+            ++idx;
         }
-        Test.Assert(entered);
+        Test.AssertEquals(idx, base_seq_int.Length);
     }
 
     public static void eina_array_str_empty_iterator()
     {
         var arr = new eina.Array<string>();
         var itr = arr.GetIterator();
-        bool entered = false;
+        int idx = 0;
         foreach (string e in itr)
         {
-            entered = true;
+            ++idx;
         }
-        Test.Assert(!entered);
+        Test.AssertEquals(idx, 0);
     }
 
     public static void eina_array_str_filled_iterator()
@@ -3341,27 +3339,25 @@ class TestEinaIterator
         var arr = new eina.Array<string>();
         arr.Append(base_seq_str);
         var itr = arr.GetIterator();
-        bool entered = false;
-        var i = 0;
+        int idx = 0;
         foreach (string e in itr)
         {
-            entered = true;
-            Test.Assert(e == base_seq_str[i]);
-            ++i;
+            Test.Assert(e == base_seq_str[idx]);
+            ++idx;
         }
-        Test.Assert(entered);
+        Test.AssertEquals(idx, base_seq_str.Length);
     }
 
     public static void eina_array_obj_empty_iterator()
     {
         var arr = new eina.Array<test.Numberwrapper>();
         var itr = arr.GetIterator();
-        bool entered = false;
+        int idx = 0;
         foreach (test.Numberwrapper e in itr)
         {
-            entered = true;
+            ++idx;
         }
-        Test.Assert(!entered);
+        Test.AssertEquals(idx, 0);
     }
 
     public static void eina_array_obj_filled_iterator()
@@ -3370,16 +3366,14 @@ class TestEinaIterator
         var base_objs = BaseSeqObj();
         arr.Append(base_objs);
         var itr = arr.GetIterator();
-        bool entered = false;
-        var i = 0;
+        int idx = 0;
         foreach (test.Numberwrapper e in itr)
         {
-            entered = true;
-            Test.Assert(e.raw_handle == base_objs[i].raw_handle);
-            Test.Assert(e.number_get() == base_objs[i].number_get());
-            ++i;
+            Test.Assert(e.raw_handle == base_objs[idx].raw_handle);
+            Test.Assert(e.number_get() == base_objs[idx].number_get());
+            ++idx;
         }
-        Test.Assert(entered);
+        Test.AssertEquals(idx, base_objs.Length);
     }
 
     // Inarray
@@ -3388,12 +3382,12 @@ class TestEinaIterator
     {
         var arr = new eina.Inarray<int>();
         var itr = arr.GetIterator();
-        bool entered = false;
+        int idx = 0;
         foreach (int e in itr)
         {
-            entered = true;
+            ++idx;
         }
-        Test.Assert(!entered);
+        Test.AssertEquals(idx, 0);
     }
 
     public static void eina_inarray_int_filled_iterator()
@@ -3401,15 +3395,357 @@ class TestEinaIterator
         var arr = new eina.Inarray<int>();
         arr.Append(base_seq_int);
         var itr = arr.GetIterator();
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.Assert(e == base_seq_int[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_int.Length);
+    }
+
+    // List //
+
+    public static void eina_list_int_empty_iterator()
+    {
+        var lst = new eina.List<int>();
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            ++idx;
+        }
+        Test.AssertEquals(idx, 0);
+    }
+
+    public static void eina_list_int_filled_iterator()
+    {
+        var lst = new eina.List<int>();
+        lst.AppendArray(base_seq_int);
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.Assert(e == base_seq_int[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_int.Length);
+    }
+
+    public static void eina_list_str_empty_iterator()
+    {
+        var lst = new eina.List<string>();
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            ++idx;
+        }
+        Test.AssertEquals(idx, 0);
+    }
+
+    public static void eina_list_str_filled_iterator()
+    {
+        var lst = new eina.List<string>();
+        lst.AppendArray(base_seq_str);
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            Test.Assert(e == base_seq_str[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_str.Length);
+    }
+
+    public static void eina_list_obj_empty_iterator()
+    {
+        var lst = new eina.List<test.Numberwrapper>();
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            ++idx;
+        }
+        Test.AssertEquals(idx, 0);
+    }
+
+    public static void eina_list_obj_filled_iterator()
+    {
+        var lst = new eina.List<test.Numberwrapper>();
+        var base_objs = BaseSeqObj();
+        lst.AppendArray(base_objs);
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            Test.Assert(e.raw_handle == base_objs[idx].raw_handle);
+            Test.Assert(e.number_get() == base_objs[idx].number_get());
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_objs.Length);
+    }
+
+    // Inlist //
+
+    public static void eina_inlist_int_empty_iterator()
+    {
+        var lst = new eina.Inlist<int>();
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            ++idx;
+        }
+        Test.AssertEquals(idx, 0);
+    }
+
+    public static void eina_inlist_int_filled_iterator()
+    {
+        var lst = new eina.Inlist<int>();
+        lst.AppendArray(base_seq_int);
+        var itr = lst.GetIterator();
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.Assert(e == base_seq_int[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_int.Length);
+    }
+
+    // Hash //
+
+    public static void eina_hash_keys_int_empty_iterator()
+    {
+        var hsh = new eina.Hash<int, int>();
+        var itr = hsh.Keys();
         bool entered = false;
-        var i = 0;
         foreach (int e in itr)
         {
             entered = true;
-            Test.Assert(e == base_seq_int[i]);
-            ++i;
         }
-        Test.Assert(entered);
+        Test.Assert(!entered);
+    }
+
+    public static void eina_hash_values_int_empty_iterator()
+    {
+        var hsh = new eina.Hash<int, int>();
+        var itr = hsh.Values();
+        bool entered = false;
+        foreach (int e in itr)
+        {
+            entered = true;
+        }
+        Test.Assert(!entered);
+    }
+
+    public static void eina_hash_keys_int_filled_iterator()
+    {
+        var hsh = new eina.Hash<int, int>();
+        var dct = new Dictionary<int, bool>();
+        hsh[22] = 222;
+        hsh[44] = 444;
+        hsh[88] = 888;
+        dct[22] = true;
+        dct[44] = true;
+        dct[88] = true;
+
+        var itr = hsh.Keys();
+
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.Assert(dct[e]);
+            dct.Remove(e);
+            ++idx;
+        }
+        Test.AssertEquals(dct.Count, 0);
+        Test.AssertEquals(idx, 3);
+    }
+
+    public static void eina_hash_values_int_filled_iterator()
+    {
+        var hsh = new eina.Hash<int, int>();
+        var dct = new Dictionary<int, bool>();
+        hsh[22] = 222;
+        hsh[44] = 444;
+        hsh[88] = 888;
+        dct[222] = true;
+        dct[444] = true;
+        dct[888] = true;
+
+        var itr = hsh.Values();
+
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.Assert(dct[e]);
+            dct.Remove(e);
+            ++idx;
+        }
+        Test.AssertEquals(dct.Count, 0);
+        Test.AssertEquals(idx, 3);
+    }
+
+    public static void eina_hash_keys_str_empty_iterator()
+    {
+        var hsh = new eina.Hash<string, string>();
+        var itr = hsh.Keys();
+        bool entered = false;
+        foreach (string e in itr)
+        {
+            entered = true;
+        }
+        Test.Assert(!entered);
+    }
+
+    public static void eina_hash_values_str_empty_iterator()
+    {
+        var hsh = new eina.Hash<string, string>();
+        var itr = hsh.Values();
+        bool entered = false;
+        foreach (string e in itr)
+        {
+            entered = true;
+        }
+        Test.Assert(!entered);
+    }
+
+    public static void eina_hash_keys_str_filled_iterator()
+    {
+        var hsh = new eina.Hash<string, string>();
+        var dct = new Dictionary<string, bool>();
+        hsh["aa"] = "aaa";
+        hsh["bb"] = "bbb";
+        hsh["cc"] = "ccc";
+        dct["aa"] = true;
+        dct["bb"] = true;
+        dct["cc"] = true;
+
+        var itr = hsh.Keys();
+
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            Test.Assert(dct[e]);
+            dct.Remove(e);
+            ++idx;
+        }
+        Test.AssertEquals(dct.Count, 0);
+        Test.AssertEquals(idx, 3);
+    }
+
+    public static void eina_hash_values_str_filled_iterator()
+    {
+        var hsh = new eina.Hash<string, string>();
+        var dct = new Dictionary<string, bool>();
+        hsh["aa"] = "aaa";
+        hsh["bb"] = "bbb";
+        hsh["cc"] = "ccc";
+        dct["aaa"] = true;
+        dct["bbb"] = true;
+        dct["ccc"] = true;
+
+        var itr = hsh.Values();
+
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            Test.Assert(dct[e]);
+            dct.Remove(e);
+            ++idx;
+        }
+        Test.AssertEquals(dct.Count, 0);
+        Test.AssertEquals(idx, 3);
+    }
+
+    public static void eina_hash_keys_obj_empty_iterator()
+    {
+        var hsh = new eina.Hash<test.Numberwrapper, test.Numberwrapper>();
+        var itr = hsh.Keys();
+        bool entered = false;
+        foreach (test.Numberwrapper e in itr)
+        {
+            entered = true;
+        }
+        Test.Assert(!entered);
+    }
+
+    public static void eina_hash_values_obj_empty_iterator()
+    {
+        var hsh = new eina.Hash<test.Numberwrapper, test.Numberwrapper>();
+        var itr = hsh.Values();
+        bool entered = false;
+        foreach (test.Numberwrapper e in itr)
+        {
+            entered = true;
+        }
+        Test.Assert(!entered);
+    }
+
+    public static void eina_hash_keys_obj_filled_iterator()
+    {
+        var hsh = new eina.Hash<test.Numberwrapper, test.Numberwrapper>();
+        var dct = new eina.Hash<int, test.Numberwrapper>();
+        var a = NW(22);
+        var b = NW(44);
+        var c = NW(88);
+        var aa = NW(222);
+        var bb = NW(444);
+        var cc = NW(888);
+        hsh[a] = aa;
+        hsh[b] = bb;
+        hsh[c] = cc;
+        dct[a.number_get()] = a;
+        dct[b.number_get()] = b;
+        dct[c.number_get()] = c;
+
+        var itr = hsh.Keys();
+
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            Test.Assert(dct[e.number_get()] != null);
+            Test.Assert(dct[e.number_get()].raw_handle == e.raw_handle);
+            Test.Assert(dct[e.number_get()].number_get() == e.number_get());
+            dct.Remove(e.number_get());
+            ++idx;
+        }
+        Test.AssertEquals(dct.Count, 0);
+        Test.AssertEquals(idx, 3);
+    }
+
+    public static void eina_hash_values_obj_filled_iterator()
+    {
+        var hsh = new eina.Hash<test.Numberwrapper, test.Numberwrapper>();
+        var dct = new eina.Hash<int, test.Numberwrapper>();
+        var a = NW(22);
+        var b = NW(44);
+        var c = NW(88);
+        var aa = NW(222);
+        var bb = NW(444);
+        var cc = NW(888);
+        hsh[a] = aa;
+        hsh[b] = bb;
+        hsh[c] = cc;
+        dct[aa.number_get()] = aa;
+        dct[bb.number_get()] = bb;
+        dct[cc.number_get()] = cc;
+
+        var itr = hsh.Values();
+
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            Test.Assert(dct[e.number_get()] != null);
+            Test.Assert(dct[e.number_get()].raw_handle == e.raw_handle);
+            Test.Assert(dct[e.number_get()].number_get() == e.number_get());
+            dct.Remove(e.number_get());
+            ++idx;
+        }
+        Test.AssertEquals(dct.Count, 0);
+        Test.AssertEquals(idx, 3);
     }
 
 //     // //