eina_mono eolian_mono: tests for eina.Iterator in eolian binding generation

3 files changed, 1053 insertions, 81 deletions

diff --git a/src/tests/efl_mono/Eina.cs b/src/tests/efl_mono/Eina.cs
index dba58d64b0..4d9ee03603 100644
--- a/src/tests/efl_mono/Eina.cs
+++ b/src/tests/efl_mono/Eina.cs
@@ -3832,87 +3832,436 @@ class TestEinaIterator
         hsh.Dispose();
     }
 
-//     // //
-//     // Code Generation
-//     //
-//
-//     // Integer //
-//
-//     public static void test_eina_iterator_int_in()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_int_in_own()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_int_out()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_int_out_own()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_int_return()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_int_return_own()
-//     {
-//     }
-//
-//     // String //
-//
-//     public static void test_eina_iterator_str_in()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_str_in_own()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_str_out()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_str_out_own()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_str_return()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_str_return_own()
-//     {
-//     }
-//
-//     // Object //
-//
-//     public static void test_eina_iterator_obj_in()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_obj_in_own()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_obj_out()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_obj_out_own()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_obj_return()
-//     {
-//     }
-//
-//     public static void test_eina_iterator_obj_return_own()
-//     {
-//     }
+    // //
+    // Code Generation
+    //
+
+    // Integer //
+
+    public static void test_eina_iterator_int_in()
+    {
+        test.Testing t = new test.TestingConcrete();
+        var arr = new eina.Array<int>();
+        arr.Append(base_seq_int);
+        var itr = arr.GetIterator();
+
+        Test.Assert(itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(arr.OwnContent);
+
+        Test.Assert(t.eina_iterator_int_in(itr));
+
+        Test.Assert(itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(arr.OwnContent);
+
+        itr.Dispose();
+        arr.Dispose();
+    }
+
+    public static void test_eina_iterator_int_in_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+        var arr = new eina.Array<int>();
+        arr.Append(base_seq_int);
+        var itr = arr.GetIterator();
+        arr.OwnContent = false;
+        itr.OwnContent = true;
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(!arr.OwnContent);
+
+        Test.Assert(t.eina_iterator_int_in_own(itr));
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(!arr.OwnContent);
+
+        itr.Dispose();
+        arr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_int_in_own());
+    }
+
+    public static void test_eina_iterator_int_out()
+    {
+        test.Testing t = new test.TestingConcrete();
+        eina.Iterator<int> itr;
+
+        Test.Assert(t.eina_iterator_int_out(out itr));
+
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.AssertEquals(e, base_seq_int[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_int.Length);
+
+        itr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_int_out());
+    }
+
+    public static void test_eina_iterator_int_out_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+        eina.Iterator<int> itr;
+
+        Test.Assert(t.eina_iterator_int_out_own(out itr));
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.AssertEquals(e, base_seq_int[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_int.Length);
+
+        itr.Dispose();
+    }
+
+    public static void test_eina_iterator_int_return()
+    {
+        test.Testing t = new test.TestingConcrete();
+
+        var itr = t.eina_iterator_int_return();
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.AssertEquals(e, base_seq_int[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_int.Length);
+
+        itr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_int_return());
+    }
+
+    public static void test_eina_iterator_int_return_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+
+        var itr = t.eina_iterator_int_return_own();
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+
+        int idx = 0;
+        foreach (int e in itr)
+        {
+            Test.AssertEquals(e, base_seq_int[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_int.Length);
+
+        itr.Dispose();
+    }
+
+    // String //
+
+    public static void test_eina_iterator_str_in()
+    {
+        test.Testing t = new test.TestingConcrete();
+        var arr = new eina.Array<string>();
+        arr.Append(base_seq_str);
+        var itr = arr.GetIterator();
+
+        Test.Assert(itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(arr.OwnContent);
+
+        Test.Assert(t.eina_iterator_str_in(itr));
+
+        Test.Assert(itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(arr.OwnContent);
+
+        itr.Dispose();
+        arr.Dispose();
+    }
+
+    public static void test_eina_iterator_str_in_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+        var arr = new eina.Array<string>();
+        arr.Append(base_seq_str);
+        var itr = arr.GetIterator();
+        arr.OwnContent = false;
+        itr.OwnContent = true;
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(!arr.OwnContent);
+
+        Test.Assert(t.eina_iterator_str_in_own(itr));
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(!arr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(!arr.OwnContent);
+
+        itr.Dispose();
+        arr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_str_in_own());
+    }
+
+    public static void test_eina_iterator_str_out()
+    {
+        test.Testing t = new test.TestingConcrete();
+        eina.Iterator<string> itr;
+
+        Test.Assert(t.eina_iterator_str_out(out itr));
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            Test.AssertEquals(e, base_seq_str[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_str.Length);
+
+        itr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_str_out());
+    }
+
+    public static void test_eina_iterator_str_out_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+        eina.Iterator<string> itr;
+
+        Test.Assert(t.eina_iterator_str_out_own(out itr));
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            Test.AssertEquals(e, base_seq_str[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_str.Length);
+
+        itr.Dispose();
+    }
+
+    public static void test_eina_iterator_str_return()
+    {
+        test.Testing t = new test.TestingConcrete();
+
+        var itr = t.eina_iterator_str_return();
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            Test.AssertEquals(e, base_seq_str[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_str.Length);
+
+        itr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_str_return());
+    }
+
+    public static void test_eina_iterator_str_return_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+
+        var itr = t.eina_iterator_str_return_own();
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+
+        int idx = 0;
+        foreach (string e in itr)
+        {
+            Test.AssertEquals(e, base_seq_str[idx]);
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_str.Length);
+
+        itr.Dispose();
+    }
+
+    // Object //
+
+    public static void test_eina_iterator_obj_in()
+    {
+        test.Testing t = new test.TestingConcrete();
+        var arr = new eina.Array<test.Numberwrapper>();
+        arr.Append(BaseSeqObj());
+        var itr = arr.GetIterator();
+
+        Test.Assert(itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(arr.OwnContent);
+
+        Test.Assert(t.eina_iterator_obj_in(itr));
+
+        Test.Assert(itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(arr.OwnContent);
+
+        itr.Dispose();
+        arr.Dispose();
+    }
+
+    public static void test_eina_iterator_obj_in_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+        var arr = new eina.Array<test.Numberwrapper>();
+        arr.Append(BaseSeqObj());
+        var itr = arr.GetIterator();
+        arr.OwnContent = false;
+        itr.OwnContent = true;
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(!arr.OwnContent);
+
+        Test.Assert(t.eina_iterator_obj_in_own(itr));
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+        Test.Assert(arr.Own);
+        Test.Assert(!arr.OwnContent);
+
+        itr.Dispose();
+        arr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_obj_in_own());
+    }
+
+    public static void test_eina_iterator_obj_out()
+    {
+        test.Testing t = new test.TestingConcrete();
+        eina.Iterator<test.Numberwrapper> itr;
+
+        Test.Assert(t.eina_iterator_obj_out(out itr));
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+
+        var base_seq_obj = BaseSeqObj();
+
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            Test.AssertEquals(e.number_get(), base_seq_obj[idx].number_get());
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_obj.Length);
+
+        itr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_obj_out());
+    }
+
+    public static void test_eina_iterator_obj_out_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+        eina.Iterator<test.Numberwrapper> itr;
+
+        Test.Assert(t.eina_iterator_obj_out_own(out itr));
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+
+        var base_seq_obj = BaseSeqObj();
+
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            Test.AssertEquals(e.number_get(), base_seq_obj[idx].number_get());
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_obj.Length);
+
+        itr.Dispose();
+    }
+
+    public static void test_eina_iterator_obj_return()
+    {
+        test.Testing t = new test.TestingConcrete();
+
+        var itr = t.eina_iterator_obj_return();
+
+        Test.Assert(!itr.Own);
+        Test.Assert(!itr.OwnContent);
+
+        var base_seq_obj = BaseSeqObj();
+
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            Test.AssertEquals(e.number_get(), base_seq_obj[idx].number_get());
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_obj.Length);
+
+        itr.Dispose();
+
+        Test.Assert(t.check_eina_iterator_obj_return());
+    }
+
+    public static void test_eina_iterator_obj_return_own()
+    {
+        test.Testing t = new test.TestingConcrete();
+
+        var itr = t.eina_iterator_obj_return_own();
+
+        Test.Assert(itr.Own);
+        Test.Assert(itr.OwnContent);
+
+        var base_seq_obj = BaseSeqObj();
+
+        int idx = 0;
+        foreach (test.Numberwrapper e in itr)
+        {
+            Test.AssertEquals(e.number_get(), base_seq_obj[idx].number_get());
+            ++idx;
+        }
+        Test.AssertEquals(idx, base_seq_obj.Length);
+
+        itr.Dispose();
+    }
 } // < TestEinaIterator
 
 }
diff --git a/src/tests/efl_mono/libefl_mono_native_test.c b/src/tests/efl_mono/libefl_mono_native_test.c
index 0fed3b43e6..cc34499d3a 100644
--- a/src/tests/efl_mono/libefl_mono_native_test.c
+++ b/src/tests/efl_mono/libefl_mono_native_test.c
@@ -2555,6 +2555,488 @@ Eina_Bool _test_testing_check_eina_hash_obj_return_own(EINA_UNUSED Eo *obj, EINA
 }
 
 
+//          //
+// Iterator //
+//          //
+
+// Integer //
+
+Eina_Bool _iterator_int_equal(Eina_Iterator *itr, const int base[], unsigned int len, Eina_Bool release)
+{
+   int *data;
+   unsigned i = 0;
+   EINA_ITERATOR_FOREACH(itr, data)
+     {
+        if (*data != base[i])
+          return EINA_FALSE;
+        if (release)
+          free(data);
+        ++i;
+     }
+
+   if (i != len)
+     return EINA_FALSE;
+
+   return EINA_TRUE;
+}
+
+Eina_Array *_iterator_int_eina_array_new()
+{
+   Eina_Array *arr = eina_array_new(32);
+   for (unsigned i = 0; i < base_seq_int_size; ++i)
+     {
+        eina_array_push(arr, _new_int(base_seq_int[i]));
+     }
+   return arr;
+}
+
+Eina_Bool _iterator_int_test_array(Eina_Array *arr)
+{
+   if (eina_array_count(arr) != base_seq_int_size)
+     return EINA_FALSE;
+
+   for (unsigned i = 0; i < base_seq_int_size; ++i)
+     {
+        int *data = eina_array_data_get(arr, i);
+        if (*data != base_seq_int[i])
+          return EINA_FALSE;
+        free(data);
+     }
+
+   eina_array_free(arr);
+
+   return EINA_TRUE;
+}
+
+// <int> in
+
+Eina_Bool _test_testing_eina_iterator_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+{
+   Eina_Bool r = _iterator_int_equal(itr, base_seq_int, base_seq_int_size, EINA_FALSE);
+   return r;
+}
+
+// <int> in own
+
+static Eina_Iterator *_iterator_int_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_iterator_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+{
+   Eina_Bool r = _iterator_int_equal(itr, base_seq_int, base_seq_int_size, EINA_TRUE);
+   _iterator_int_in_own_to_check = itr;
+   return r;
+}
+Eina_Bool _test_testing_check_eina_iterator_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   eina_iterator_free(_iterator_int_in_own_to_check);
+   _iterator_int_in_own_to_check = NULL;
+   return EINA_TRUE;
+}
+
+// <int> out
+
+Eina_Iterator *_iterator_int_out_to_check = NULL;
+Eina_Array *_iterator_int_out_array = NULL;
+
+Eina_Bool _test_testing_eina_iterator_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+{
+   if (!itr) return EINA_FALSE;
+
+   _iterator_int_out_array = _iterator_int_eina_array_new();
+
+   *itr = eina_array_iterator_new(_iterator_int_out_array);
+   _iterator_int_out_to_check = *itr;
+
+   return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_iterator_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Iterator *itr = _iterator_int_out_to_check;
+   if (!itr) return EINA_FALSE;
+   _iterator_int_out_to_check = NULL;
+
+   Eina_Array *arr = _iterator_int_out_array;
+   if (!arr) return EINA_FALSE;
+   _iterator_int_out_array = NULL;
+
+   Eina_Bool r = _iterator_int_test_array(arr);
+   if (!r) return r;
+
+   eina_iterator_free(itr);
+
+   return r;
+}
+
+// <int> out own
+
+Eina_Bool _test_testing_eina_iterator_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+{
+   if (!itr) return EINA_FALSE;
+
+   Eina_Array *arr = _iterator_int_eina_array_new();
+
+   *itr = eina_array_iterator_new(arr);
+
+   return EINA_TRUE;
+}
+
+// <int> return
+
+Eina_Iterator *_iterator_int_return_to_check = NULL;
+Eina_Array *_iterator_int_return_array = NULL;
+
+Eina_Iterator *_test_testing_eina_iterator_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   _iterator_int_return_array = _iterator_int_eina_array_new();
+   _iterator_int_return_to_check = eina_array_iterator_new(_iterator_int_return_array);
+   return _iterator_int_return_to_check;
+}
+Eina_Bool _test_testing_check_eina_iterator_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Iterator *itr = _iterator_int_return_to_check;
+   if (!itr) return EINA_FALSE;
+   _iterator_int_return_to_check = NULL;
+
+   Eina_Array *arr = _iterator_int_return_array;
+   if (!arr) return EINA_FALSE;
+   _iterator_int_return_array = NULL;
+
+   Eina_Bool r = _iterator_int_test_array(arr);
+   if (!r) return r;
+
+   eina_iterator_free(itr);
+
+   return r;
+}
+
+// <int> return own
+
+Eina_Iterator *_test_testing_eina_iterator_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Array *arr = _iterator_int_eina_array_new();
+   return eina_array_iterator_new(arr);
+}
+
+// String //
+
+Eina_Bool _iterator_str_equal(Eina_Iterator *itr, const char * const base[], unsigned int len, Eina_Bool release)
+{
+   const char *data;
+   unsigned i = 0;
+   EINA_ITERATOR_FOREACH(itr, data)
+     {
+        if (0 != strcmp(data, base[i]))
+          return EINA_FALSE;
+        if (release)
+          free((void*)data);
+        ++i;
+     }
+
+   if (i != len)
+     return EINA_FALSE;
+
+   return EINA_TRUE;
+}
+
+Eina_Array *_iterator_str_eina_array_new()
+{
+   Eina_Array *arr = eina_array_new(32);
+   for (unsigned i = 0; i < base_seq_str_size; ++i)
+     {
+        eina_array_push(arr, strdup(base_seq_str[i]));
+     }
+   return arr;
+}
+
+Eina_Bool _iterator_str_test_array(Eina_Array *arr)
+{
+   if (eina_array_count(arr) != base_seq_str_size)
+     return EINA_FALSE;
+
+   for (unsigned i = 0; i < base_seq_str_size; ++i)
+     {
+        const char *data = eina_array_data_get(arr, i);
+        if (0 != strcmp(data, base_seq_str[i]))
+          return EINA_FALSE;
+        free((void*)data);
+     }
+
+   eina_array_free(arr);
+
+   return EINA_TRUE;
+}
+
+// <str> in
+
+Eina_Bool _test_testing_eina_iterator_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+{
+   Eina_Bool r = _iterator_str_equal(itr, base_seq_str, base_seq_str_size, EINA_FALSE);
+   return r;
+}
+
+// <str> in own
+
+static Eina_Iterator *_iterator_str_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_iterator_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+{
+   Eina_Bool r = _iterator_str_equal(itr, base_seq_str, base_seq_str_size, EINA_TRUE);
+   _iterator_str_in_own_to_check = itr;
+   return r;
+}
+Eina_Bool _test_testing_check_eina_iterator_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   eina_iterator_free(_iterator_str_in_own_to_check);
+   _iterator_str_in_own_to_check = NULL;
+   return EINA_TRUE;
+}
+
+// <str> out
+
+Eina_Iterator *_iterator_str_out_to_check = NULL;
+Eina_Array *_iterator_str_out_array = NULL;
+
+Eina_Bool _test_testing_eina_iterator_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+{
+   if (!itr) return EINA_FALSE;
+
+   _iterator_str_out_array = _iterator_str_eina_array_new();
+
+   *itr = eina_array_iterator_new(_iterator_str_out_array);
+   _iterator_str_out_to_check = *itr;
+
+   return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_iterator_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Iterator *itr = _iterator_str_out_to_check;
+   if (!itr) return EINA_FALSE;
+   _iterator_str_out_to_check = NULL;
+
+   Eina_Array *arr = _iterator_str_out_array;
+   if (!arr) return EINA_FALSE;
+   _iterator_str_out_array = NULL;
+
+   Eina_Bool r = _iterator_str_test_array(arr);
+   if (!r) return r;
+
+   eina_iterator_free(itr);
+
+   return r;
+}
+
+// <str> out own
+
+Eina_Bool _test_testing_eina_iterator_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+{
+   if (!itr) return EINA_FALSE;
+
+   Eina_Array *arr = _iterator_str_eina_array_new();
+
+   *itr = eina_array_iterator_new(arr);
+
+   return EINA_TRUE;
+}
+
+// <str> return
+
+Eina_Iterator *_iterator_str_return_to_check = NULL;
+Eina_Array *_iterator_str_return_array = NULL;
+
+Eina_Iterator *_test_testing_eina_iterator_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   _iterator_str_return_array = _iterator_str_eina_array_new();
+   _iterator_str_return_to_check = eina_array_iterator_new(_iterator_str_return_array);
+   return _iterator_str_return_to_check;
+}
+Eina_Bool _test_testing_check_eina_iterator_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Iterator *itr = _iterator_str_return_to_check;
+   if (!itr) return EINA_FALSE;
+   _iterator_str_return_to_check = NULL;
+
+   Eina_Array *arr = _iterator_str_return_array;
+   if (!arr) return EINA_FALSE;
+   _iterator_str_return_array = NULL;
+
+   Eina_Bool r = _iterator_str_test_array(arr);
+   if (!r) return r;
+
+   eina_iterator_free(itr);
+
+   return r;
+}
+
+// <str> return own
+
+Eina_Iterator *_test_testing_eina_iterator_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Array *arr = _iterator_str_eina_array_new();
+   return eina_array_iterator_new(arr);
+}
+
+// Object //
+
+Eina_Bool _iterator_obj_equal(Eina_Iterator *itr, const Test_Numberwrapper * const base[], unsigned int len, Eina_Bool release)
+{
+   Test_Numberwrapper *data;
+   unsigned i = 0;
+   EINA_ITERATOR_FOREACH(itr, data)
+     {
+        int a = test_numberwrapper_number_get(data);
+        int b = test_numberwrapper_number_get(base[i]);
+        if (a != b)
+          return EINA_FALSE;
+        if (release)
+          efl_unref(data);
+        ++i;
+     }
+
+   if (i != len)
+     return EINA_FALSE;
+
+   return EINA_TRUE;
+}
+
+Eina_Array *_iterator_obj_eina_array_new()
+{
+   Eina_Array *arr = eina_array_new(32);
+   for (unsigned i = 0; i < base_seq_obj_size; ++i)
+     {
+        eina_array_push(arr, _new_obj(test_numberwrapper_number_get(base_seq_obj[i])));
+     }
+   return arr;
+}
+
+Eina_Bool _iterator_obj_test_array(Eina_Array *arr)
+{
+   if (eina_array_count(arr) != base_seq_obj_size)
+     return EINA_FALSE;
+
+   for (unsigned i = 0; i < base_seq_obj_size; ++i)
+     {
+        Test_Numberwrapper *data = eina_array_data_get(arr, i);
+        int a = test_numberwrapper_number_get(data);
+        int b = test_numberwrapper_number_get(base_seq_obj[i]);
+        if (a != b)
+          return EINA_FALSE;
+        efl_unref(data);
+     }
+
+   eina_array_free(arr);
+
+   return EINA_TRUE;
+}
+
+// <obj> in
+
+Eina_Bool _test_testing_eina_iterator_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+{
+   Eina_Bool r = _iterator_obj_equal(itr, base_seq_obj, base_seq_obj_size, EINA_FALSE);
+   return r;
+}
+
+// <obj> in own
+
+static Eina_Iterator *_iterator_obj_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_iterator_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator *itr)
+{
+   Eina_Bool r = _iterator_obj_equal(itr, base_seq_obj, base_seq_obj_size, EINA_TRUE);
+   _iterator_obj_in_own_to_check = itr;
+   return r;
+}
+Eina_Bool _test_testing_check_eina_iterator_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   eina_iterator_free(_iterator_obj_in_own_to_check);
+   _iterator_obj_in_own_to_check = NULL;
+   return EINA_TRUE;
+}
+
+// <obj> out
+
+Eina_Iterator *_iterator_obj_out_to_check = NULL;
+Eina_Array *_iterator_obj_out_array = NULL;
+
+Eina_Bool _test_testing_eina_iterator_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+{
+   if (!itr) return EINA_FALSE;
+
+   _iterator_obj_out_array = _iterator_obj_eina_array_new();
+
+   *itr = eina_array_iterator_new(_iterator_obj_out_array);
+   _iterator_obj_out_to_check = *itr;
+
+   return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_iterator_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Iterator *itr = _iterator_obj_out_to_check;
+   if (!itr) return EINA_FALSE;
+   _iterator_obj_out_to_check = NULL;
+
+   Eina_Array *arr = _iterator_obj_out_array;
+   if (!arr) return EINA_FALSE;
+   _iterator_obj_out_array = NULL;
+
+   Eina_Bool r = _iterator_obj_test_array(arr);
+   if (!r) return r;
+
+   eina_iterator_free(itr);
+
+   return r;
+}
+
+// <obj> out own
+
+Eina_Bool _test_testing_eina_iterator_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Iterator **itr)
+{
+   if (!itr) return EINA_FALSE;
+
+   Eina_Array *arr = _iterator_obj_eina_array_new();
+
+   *itr = eina_array_iterator_new(arr);
+
+   return EINA_TRUE;
+}
+
+// <obj> return
+
+Eina_Iterator *_iterator_obj_return_to_check = NULL;
+Eina_Array *_iterator_obj_return_array = NULL;
+
+Eina_Iterator *_test_testing_eina_iterator_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   _iterator_obj_return_array = _iterator_obj_eina_array_new();
+   _iterator_obj_return_to_check = eina_array_iterator_new(_iterator_obj_return_array);
+   return _iterator_obj_return_to_check;
+}
+Eina_Bool _test_testing_check_eina_iterator_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Iterator *itr = _iterator_obj_return_to_check;
+   if (!itr) return EINA_FALSE;
+   _iterator_obj_return_to_check = NULL;
+
+   Eina_Array *arr = _iterator_obj_return_array;
+   if (!arr) return EINA_FALSE;
+   _iterator_obj_return_array = NULL;
+
+   Eina_Bool r = _iterator_obj_test_array(arr);
+   if (!r) return r;
+
+   eina_iterator_free(itr);
+
+   return r;
+}
+
+// <obj> return own
+
+Eina_Iterator *_test_testing_eina_iterator_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+   Eina_Array *arr = _iterator_obj_eina_array_new();
+   return eina_array_iterator_new(arr);
+}
+
 //                   //
 // Class constructor
 //                   //
diff --git a/src/tests/efl_mono/test_testing.eo b/src/tests/efl_mono/test_testing.eo
index b47d3cc17d..5b5192358d 100644
--- a/src/tests/efl_mono/test_testing.eo
+++ b/src/tests/efl_mono/test_testing.eo
@@ -1003,6 +1003,147 @@ class Test.Testing (Efl.Object) {
          return: bool;
       }
 
+      /* Eina Iterator */
+
+      /* Integer */
+      eina_iterator_int_in {
+         params {
+            @in itr: iterator<int>;
+         }
+         return: bool;
+      }
+
+      eina_iterator_int_in_own {
+         params {
+            @in itr: own(iterator<own(ref(int))>);
+         }
+         return: bool;
+      }
+      check_eina_iterator_int_in_own {
+         return: bool;
+      }
+
+      eina_iterator_int_out {
+         params {
+            @out itr: iterator<int>;
+         }
+         return: bool;
+      }
+      check_eina_iterator_int_out {
+         return: bool;
+      }
+
+      eina_iterator_int_out_own {
+         params {
+            @out itr: own(iterator<own(ref(int))>);
+         }
+         return: bool;
+      }
+
+      eina_iterator_int_return {
+         return: iterator<int>;
+      }
+      check_eina_iterator_int_return {
+         return: bool;
+      }
+
+      eina_iterator_int_return_own {
+         return: own(iterator<own(ref(int))>);
+      }
+
+      /* String */
+      eina_iterator_str_in {
+         params {
+            @in itr: iterator<string>;
+         }
+         return: bool;
+      }
+
+      eina_iterator_str_in_own {
+         params {
+            @in itr: own(iterator<own(string)>);
+         }
+         return: bool;
+      }
+      check_eina_iterator_str_in_own {
+         return: bool;
+      }
+
+      eina_iterator_str_out {
+         params {
+            @out itr: iterator<string>;
+         }
+         return: bool;
+      }
+      check_eina_iterator_str_out {
+         return: bool;
+      }
+
+      eina_iterator_str_out_own {
+         params {
+            @out itr: own(iterator<own(string)>);
+         }
+         return: bool;
+      }
+
+      eina_iterator_str_return {
+         return: iterator<string>;
+      }
+      check_eina_iterator_str_return {
+         return: bool;
+      }
+
+      eina_iterator_str_return_own {
+         return: own(iterator<own(string)>);
+      }
+
+      /* Object */
+      eina_iterator_obj_in {
+         params {
+            @in itr: iterator<Test.Numberwrapper>;
+         }
+         return: bool;
+      }
+
+      eina_iterator_obj_in_own {
+         params {
+            @in itr: own(iterator<own(Test.Numberwrapper)>);
+         }
+         return: bool;
+      }
+      check_eina_iterator_obj_in_own {
+         return: bool;
+      }
+
+      eina_iterator_obj_out {
+         params {
+            @out itr: iterator<Test.Numberwrapper>;
+         }
+         return: bool;
+      }
+      check_eina_iterator_obj_out {
+         return: bool;
+      }
+
+      eina_iterator_obj_out_own {
+         params {
+            @out itr: own(iterator<own(Test.Numberwrapper)>);
+         }
+         return: bool;
+      }
+
+      eina_iterator_obj_return {
+         return: iterator<Test.Numberwrapper>;
+      }
+      check_eina_iterator_obj_return {
+         return: bool;
+      }
+
+      eina_iterator_obj_return_own {
+         return: own(iterator<own(Test.Numberwrapper)>);
+      }
+
+     /* Function Pointer */
 
      set_callback {
          params {