Buildsystem integration will come in a future commit.
--- /dev/null
+/libefl_mono_test.dll
--- /dev/null
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+
+using EinaTestData;
+using static EinaTestData.BaseData;
+
+namespace EinaTestData
+{
+
+class BaseSequence
+{
+ public static byte[] Values()
+ {
+ return new byte[3]{0x0,0x2A,0x42};
+ }
+}
+
+public static class BaseData
+{
+ public static readonly int[] base_seq_int = {0x0,0x2A,0x42};
+ public static readonly int[] append_seq_int = {42,43,33};
+ public static readonly int[] modified_seq_int = {0x0,0x2A,0x42,42,43,33};
+
+ public static readonly string[] base_seq_str = {"0x0","0x2A","0x42"};
+ public static readonly string[] append_seq_str = {"42","43","33"};
+ public static readonly string[] modified_seq_str = {"0x0","0x2A","0x42","42","43","33"};
+
+ public static test.Numberwrapper NW(int n)
+ {
+ var nw = new test.NumberwrapperConcrete();
+ nw.SetNumber(n);
+ return nw;
+ }
+
+ public static test.Numberwrapper[] BaseSeqObj()
+ {
+ var a = new test.NumberwrapperConcrete();
+ var b = new test.NumberwrapperConcrete();
+ var c = new test.NumberwrapperConcrete();
+ a.SetNumber(0x0);
+ b.SetNumber(0x2A);
+ c.SetNumber(0x42);
+ return new test.NumberwrapperConcrete[]{a,b,c};
+ }
+
+ public static test.Numberwrapper[] AppendSeqObj()
+ {
+ var a = new test.NumberwrapperConcrete();
+ var b = new test.NumberwrapperConcrete();
+ var c = new test.NumberwrapperConcrete();
+ a.SetNumber(42);
+ b.SetNumber(43);
+ c.SetNumber(33);
+ return new test.NumberwrapperConcrete[]{a,b,c};
+ }
+
+ public static test.Numberwrapper[] ModifiedSeqObj()
+ {
+ var a = new test.NumberwrapperConcrete();
+ var b = new test.NumberwrapperConcrete();
+ var c = new test.NumberwrapperConcrete();
+ var d = new test.NumberwrapperConcrete();
+ var e = new test.NumberwrapperConcrete();
+ var f = new test.NumberwrapperConcrete();
+ a.SetNumber(0x0);
+ b.SetNumber(0x2A);
+ c.SetNumber(0x42);
+ d.SetNumber(42);
+ e.SetNumber(43);
+ f.SetNumber(33);
+ return new test.NumberwrapperConcrete[]{a,b,c,d,e,f};
+ }
+
+ public static void NumberwrapperSequenceAssertEqual(
+ test.Numberwrapper[] a
+ , test.Numberwrapper[] b
+ , [CallerLineNumber] int line = 0
+ , [CallerFilePath] string file = null
+ , [CallerMemberName] string member = null)
+ {
+ Test.Assert(a.Length == b.Length, "Different lenght", line, file, member);
+ for (int i = 0; i < a.Length; ++i)
+ {
+ int av = a[i].GetNumber();
+ int bv = b[i].GetNumber();
+ Test.Assert(av == bv, $"Different values for element [{i}]: {av} == {bv}", line, file, member);
+ }
+ }
+}
+
+class NativeInheritImpl : test.TestingInherit
+{
+ public NativeInheritImpl(efl.Object parent = null) : base(parent) {}
+
+ public bool slice_in_flag = false;
+ public bool rw_slice_in_flag = false;
+ public bool slice_out_flag = false;
+ public bool rw_slice_out_flag = false;
+ public bool binbuf_in_flag = false;
+ public bool binbuf_in_own_flag = false;
+ public bool binbuf_out_flag = false;
+ public bool binbuf_out_own_flag = false;
+ public bool binbuf_return_flag = false;
+ public bool binbuf_return_own_flag = false;
+
+ override public bool EinaSliceIn(eina.Slice slice)
+ {
+ slice_in_flag = true;
+ return slice.GetBytes().SequenceEqual(BaseSequence.Values());
+ }
+
+ override public bool EinaRwSliceIn(eina.Rw_Slice slice)
+ {
+ rw_slice_in_flag = true;
+ return slice.GetBytes().SequenceEqual(BaseSequence.Values());
+ }
+
+ private byte[] slice_out_seq = null;
+ private GCHandle slice_out_pinned;
+ override public bool EinaSliceOut(ref eina.Slice slice)
+ {
+ slice_out_flag = true;
+
+ slice_out_seq = (byte[]) BaseSequence.Values();
+ slice_out_pinned = GCHandle.Alloc(slice_out_seq, GCHandleType.Pinned);
+ IntPtr ptr = slice_out_pinned.AddrOfPinnedObject();
+
+ slice.Mem = ptr;
+ slice.Len = (UIntPtr) slice_out_seq.Length;
+
+ return true;
+ }
+
+ private byte[] rw_slice_out_seq = null;
+ private GCHandle rw_slice_out_pinned;
+ override public bool EinaRwSliceOut(ref eina.Rw_Slice slice)
+ {
+ rw_slice_out_flag = true;
+
+ rw_slice_out_seq = (byte[]) BaseSequence.Values();
+ rw_slice_out_pinned = GCHandle.Alloc(rw_slice_out_seq, GCHandleType.Pinned);
+ IntPtr ptr = rw_slice_out_pinned.AddrOfPinnedObject();
+
+ slice.Mem = ptr;
+ slice.Len = (UIntPtr) rw_slice_out_seq.Length;
+
+ return true;
+ }
+
+ // //
+ //
+ override public bool EinaBinbufIn(eina.Binbuf binbuf)
+ {
+ binbuf_in_flag = true;
+
+ bool r = binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
+ r = r && !binbuf.Own;
+
+ binbuf.Insert(42, 0);
+ binbuf.Insert(43, 0);
+ binbuf.Append(33);
+
+ binbuf.Dispose();
+
+ return r;
+ }
+
+ private eina.Binbuf binbuf_in_own_binbuf = null;
+ override public bool EinaBinbufInOwn(eina.Binbuf binbuf)
+ {
+ binbuf_in_own_flag = true;
+
+ bool r = binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
+ r = r && binbuf.Own;
+
+ binbuf.Insert(42, 0);
+ binbuf.Insert(43, 0);
+ binbuf.Append(33);
+
+ binbuf_in_own_binbuf = binbuf;
+
+ return r;
+ }
+ public bool binbuf_in_own_still_usable()
+ {
+ bool r = binbuf_in_own_binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33});
+ r = r && binbuf_in_own_binbuf.Own;
+
+ binbuf_in_own_binbuf.Dispose();
+ binbuf_in_own_binbuf = null;
+
+ return r;
+ }
+
+ private eina.Binbuf binbuf_out_binbuf = null;
+ override public bool EinaBinbufOut(out eina.Binbuf binbuf)
+ {
+ binbuf_out_flag = true;
+
+ binbuf = new eina.Binbuf();
+ binbuf.Append(33);
+
+ binbuf_out_binbuf = binbuf;
+
+ return true;
+ }
+ public bool binbuf_out_still_usable()
+ {
+ bool r = binbuf_out_binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
+ r = r && binbuf_out_binbuf.Own;
+
+ binbuf_out_binbuf.Dispose();
+ binbuf_out_binbuf = null;
+
+ return r;
+ }
+
+ private eina.Binbuf binbuf_out_own_binbuf = null;
+ override public bool EinaBinbufOutOwn(out eina.Binbuf binbuf)
+ {
+ binbuf_out_own_flag = true;
+
+ binbuf = new eina.Binbuf();
+ binbuf.Append(33);
+
+ binbuf_out_own_binbuf = binbuf;
+
+ return true;
+ }
+ public bool binbuf_out_own_no_longer_own()
+ {
+ bool r = !binbuf_out_own_binbuf.Own;
+ binbuf_out_own_binbuf.Dispose();
+ binbuf_out_own_binbuf = null;
+ return r;
+ }
+
+ private eina.Binbuf binbuf_return_binbuf = null;
+ override public eina.Binbuf EinaBinbufReturn()
+ {
+ binbuf_return_flag = true;
+
+ var binbuf = new eina.Binbuf();
+ binbuf.Append(33);
+
+ binbuf_return_binbuf = binbuf;
+
+ return binbuf;
+ }
+ public bool binbuf_return_still_usable()
+ {
+ bool r = binbuf_return_binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
+ r = r && binbuf_return_binbuf.Own;
+
+ binbuf_return_binbuf.Dispose();
+ binbuf_return_binbuf = null;
+
+ return r;
+ }
+
+ private eina.Binbuf binbuf_return_own_binbuf = null;
+ override public eina.Binbuf EinaBinbufReturnOwn()
+ {
+ binbuf_return_own_flag = true;
+
+ var binbuf = new eina.Binbuf();
+ binbuf.Append(33);
+
+ binbuf_return_own_binbuf = binbuf;
+
+ return binbuf;
+ }
+ public bool binbuf_return_own_no_longer_own()
+ {
+ bool r = !binbuf_return_own_binbuf.Own;
+ binbuf_return_own_binbuf.Dispose();
+ binbuf_return_own_binbuf = null;
+ return r;
+ }
+}
+
+} // EinaTestData
+
+namespace TestSuite
+{
+
+class TestEinaBinbuf
+{
+ private static readonly byte[] test_string = System.Text.Encoding.UTF8.GetBytes("0123456789ABCDEF");
+
+ private static readonly byte[] base_seq = BaseSequence.Values();
+
+ public static void eina_binbuf_default()
+ {
+ var binbuf = new eina.Binbuf();
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[0]));
+ }
+
+ public static void eina_binbuf_bytes()
+ {
+ var binbuf = new eina.Binbuf(test_string);
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ byte[] cmp = binbuf.GetBytes();
+ Test.Assert(cmp != test_string);
+ Test.Assert(cmp.SequenceEqual(test_string));
+ }
+
+ public static void eina_binbuf_bytes_length()
+ {
+ var binbuf = new eina.Binbuf(test_string, 7);
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ byte[] cmp = binbuf.GetBytes();
+ byte[] expected = System.Text.Encoding.UTF8.GetBytes("0123456");
+ Test.Assert(cmp != test_string);
+ Test.Assert(cmp != expected);
+ Test.Assert(cmp.SequenceEqual(expected));
+ }
+
+ public static void eina_binbuf_copy_ctor()
+ {
+ var binbuf = new eina.Binbuf(test_string);
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ var binbuf2 = new eina.Binbuf(binbuf);
+ Test.Assert(binbuf2.Handle != IntPtr.Zero && binbuf.Handle != binbuf2.Handle);
+ byte[] cmp = binbuf.GetBytes();
+ byte[] cmp2 = binbuf2.GetBytes();
+ Test.Assert(cmp != cmp2);
+ Test.Assert(cmp.SequenceEqual(cmp2));
+ }
+
+ public static void free_get_null_handle()
+ {
+ var binbuf = new eina.Binbuf(test_string);
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ binbuf.Free();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ }
+
+ public static void reset_get_empty_string()
+ {
+ var binbuf = new eina.Binbuf(test_string);
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ byte[] cmp = binbuf.GetBytes();
+ Test.Assert(cmp != test_string);
+ Test.Assert(cmp.SequenceEqual(test_string));
+ binbuf.Reset();
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[0]));
+ }
+
+ public static void append_bytes()
+ {
+ var binbuf = new eina.Binbuf();
+ binbuf.Append(test_string);
+ byte[] cmp = binbuf.GetBytes();
+ Test.Assert(cmp != test_string);
+ Test.Assert(cmp.SequenceEqual(test_string));
+ }
+
+ public static void append_bytes_length()
+ {
+ var binbuf = new eina.Binbuf();
+ binbuf.Append(test_string, 7);
+ byte[] cmp = binbuf.GetBytes();
+ byte[] expected = System.Text.Encoding.UTF8.GetBytes("0123456");
+ Test.Assert(cmp != expected);
+ Test.Assert(cmp.SequenceEqual(expected));
+ }
+
+ public static void append_binbuf()
+ {
+ var binbuf = new eina.Binbuf();
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[0]));
+ var binbuf2 = new eina.Binbuf(test_string);
+ binbuf.Append(binbuf2);
+ byte[] cmp = binbuf.GetBytes();
+ byte[] cmp2 = binbuf2.GetBytes();
+ Test.Assert(cmp != cmp2);
+ Test.Assert(cmp2.SequenceEqual(cmp));
+ Test.Assert(cmp2.SequenceEqual(test_string));
+ }
+
+ public static void append_char()
+ {
+ var binbuf = new eina.Binbuf();
+ binbuf.Append((byte) 0);
+ binbuf.Append((byte) 12);
+ binbuf.Append((byte) 42);
+ byte[] cmp = binbuf.GetBytes();
+ Test.Assert(cmp.Length == 3);
+ Test.Assert(cmp[0] == 0 && cmp[1] == 12 && cmp[2] == 42);
+ }
+
+ public static void remove()
+ {
+ var binbuf = new eina.Binbuf(test_string);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(test_string));
+ binbuf.Remove(2, 9);
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ byte[] expected = System.Text.Encoding.UTF8.GetBytes("019ABCDEF");
+ Test.Assert(binbuf.GetBytes().SequenceEqual(expected));
+ }
+
+ public static void get_string_native()
+ {
+ var binbuf = new eina.Binbuf(test_string);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(test_string));
+ Test.Assert(binbuf.GetStringNative() != IntPtr.Zero);
+ }
+
+ public static void binbuf_free_string()
+ {
+ var binbuf = new eina.Binbuf(test_string);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(test_string));
+ binbuf.FreeString();
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[0]));
+ }
+
+ public static void binbuf_length()
+ {
+ var binbuf = new eina.Binbuf(test_string, 6);
+ Test.Assert(binbuf.Length == 6);
+ Test.Assert(binbuf.GetBytes().Length == 6);
+ }
+
+ public static void test_eina_binbuf_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ Test.Assert(t.EinaBinbufIn(binbuf));
+ Test.Assert(binbuf.Own);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_binbuf_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ Test.Assert(t.EinaBinbufInOwn(binbuf));
+ Test.Assert(!binbuf.Own);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckBinbufInOwn());
+ }
+
+ public static void test_eina_binbuf_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Binbuf binbuf;
+ Test.Assert(t.EinaBinbufOut(out binbuf));
+ Test.Assert(!binbuf.Own);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckBinbufOut());
+ }
+
+ public static void test_eina_binbuf_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Binbuf binbuf;
+ Test.Assert(t.EinaBinbufOutOwn(out binbuf));
+ Test.Assert(binbuf.Own);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_binbuf_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var binbuf = t.EinaBinbufReturn();
+ Test.Assert(!binbuf.Own);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckBinbufReturn());
+ }
+
+ public static void test_eina_binbuf_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var binbuf = t.EinaBinbufReturnOwn();
+ Test.Assert(binbuf.Own);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ }
+
+ // //
+ // Inherit
+ //
+ public static void test_inherit_eina_binbuf_in()
+ {
+ var t = new NativeInheritImpl();
+ var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_in(t.raw_handle, binbuf.Handle));
+ Test.Assert(t.binbuf_in_flag);
+ Test.Assert(binbuf.Own);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ }
+
+ public static void test_inherit_eina_binbuf_in_own()
+ {
+ var t = new NativeInheritImpl();
+ var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
+ binbuf.Own = false;
+ Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_in_own(t.raw_handle, binbuf.Handle));
+ Test.Assert(t.binbuf_in_own_flag);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.binbuf_in_own_still_usable());
+ }
+
+ public static void test_inherit_eina_binbuf_out()
+ {
+ var t = new NativeInheritImpl();
+ IntPtr bb_hdl;
+ Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_out(t.raw_handle, out bb_hdl));
+ Test.Assert(t.binbuf_out_flag);
+ Test.Assert(bb_hdl != IntPtr.Zero);
+ var binbuf = new eina.Binbuf(bb_hdl, false);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.binbuf_out_still_usable());
+ }
+
+ public static void test_inherit_eina_binbuf_out_own()
+ {
+ var t = new NativeInheritImpl();
+ IntPtr bb_hdl;
+ Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_out_own(t.raw_handle, out bb_hdl));
+ Test.Assert(t.binbuf_out_own_flag);
+ Test.Assert(bb_hdl != IntPtr.Zero);
+ var binbuf = new eina.Binbuf(bb_hdl, true);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.binbuf_out_own_no_longer_own());
+ }
+
+ public static void test_inherit_eina_binbuf_return()
+ {
+ var t = new NativeInheritImpl();
+ IntPtr bb_hdl = NativeInheritImpl.test_testing_eina_binbuf_return(t.raw_handle);
+ Test.Assert(t.binbuf_return_flag);
+ Test.Assert(bb_hdl != IntPtr.Zero);
+ var binbuf = new eina.Binbuf(bb_hdl, false);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.binbuf_return_still_usable());
+ }
+
+ public static void test_inherit_eina_binbuf_return_own()
+ {
+ var t = new NativeInheritImpl();
+ IntPtr bb_hdl = NativeInheritImpl.test_testing_eina_binbuf_return_own(t.raw_handle);
+ Test.Assert(t.binbuf_return_own_flag);
+ Test.Assert(bb_hdl != IntPtr.Zero);
+ var binbuf = new eina.Binbuf(bb_hdl, true);
+ Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
+ binbuf.Reset();
+ Test.Assert(binbuf.Append(base_seq));
+ binbuf.Dispose();
+ Test.Assert(binbuf.Handle == IntPtr.Zero);
+ Test.Assert(t.binbuf_return_own_no_longer_own());
+ }
+}
+
+class TestEinaSlice
+{
+ private static readonly byte[] base_seq = BaseSequence.Values();
+ private static readonly GCHandle pinnedData = GCHandle.Alloc(base_seq, GCHandleType.Pinned);
+ private static readonly IntPtr pinnedPtr = pinnedData.AddrOfPinnedObject();
+
+ public static void eina_slice_marshalling()
+ {
+ var binbuf = new eina.Binbuf(base_seq);
+ Test.Assert(binbuf.Handle != IntPtr.Zero);
+
+ eina.Slice slc = eina.Binbuf.eina_binbuf_slice_get(binbuf.Handle);
+
+ Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
+ Test.Assert(base_seq.Length == (int)(slc.Len));
+ }
+
+ public static void eina_slice_size()
+ {
+ Test.Assert(Marshal.SizeOf(typeof(eina.Slice)) == Marshal.SizeOf(typeof(UIntPtr)) + Marshal.SizeOf(typeof(IntPtr)));
+ Test.Assert(Marshal.SizeOf(typeof(eina.Rw_Slice)) == Marshal.SizeOf(typeof(UIntPtr)) + Marshal.SizeOf(typeof(IntPtr)));
+ }
+
+ public static void pinned_data_set()
+ {
+ var binbuf = new eina.Binbuf();
+ binbuf.Append(new eina.Slice().PinnedDataSet(pinnedPtr, (UIntPtr)3));
+ Test.Assert(binbuf.GetBytes().SequenceEqual(base_seq));
+ }
+
+ public static void test_eina_slice_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var slc = new eina.Slice(pinnedPtr, (UIntPtr)3);
+ Test.Assert(t.EinaSliceIn(slc));
+ }
+
+ public static void test_eina_rw_slice_in()
+ {
+ var rw_seq = base_seq.Clone();
+ GCHandle pinnedRWData = GCHandle.Alloc(rw_seq, GCHandleType.Pinned);
+ IntPtr ptr = pinnedRWData.AddrOfPinnedObject();
+
+ var slc = new eina.Rw_Slice(ptr, (UIntPtr)3);
+
+ test.Testing t = new test.TestingConcrete();
+ Test.Assert(t.EinaRwSliceIn(slc));
+
+ Test.Assert(slc.GetBytes().SequenceEqual(new byte[3]{0x1,0x2B,0x43}));
+
+ pinnedRWData.Free();
+ }
+
+ public static void test_eina_slice_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var slc = new eina.Slice();
+ Test.Assert(t.EinaSliceOut(ref slc));
+ Test.Assert(slc.Mem != IntPtr.Zero);
+ Test.Assert(slc.Length == base_seq.Length);
+ Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
+ }
+
+ public static void test_eina_rw_slice_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var slc = new eina.Rw_Slice();
+ Test.Assert(t.EinaRwSliceOut(ref slc));
+ Test.Assert(slc.Mem != IntPtr.Zero);
+ Test.Assert(slc.Length == base_seq.Length);
+ Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
+ }
+
+ /*
+ public static void test_eina_slice_return()
+ {
+ }
+
+ public static void test_eina_rw_slice_return()
+ {
+ }
+ */
+
+ public static void test_inherit_eina_slice_in()
+ {
+ var t = new NativeInheritImpl();
+ var slc = new eina.Slice(pinnedPtr, (UIntPtr)3);
+ Test.Assert(NativeInheritImpl.test_testing_eina_slice_in(t.raw_handle, slc));
+ Test.Assert(t.slice_in_flag);
+ }
+
+ public static void test_inherit_eina_rw_slice_in()
+ {
+ var rw_seq = base_seq.Clone();
+ GCHandle pinnedRWData = GCHandle.Alloc(rw_seq, GCHandleType.Pinned);
+ IntPtr ptr = pinnedRWData.AddrOfPinnedObject();
+
+ var slc = new eina.Rw_Slice(ptr, (UIntPtr)3);
+
+ var t = new NativeInheritImpl();
+ Test.Assert(NativeInheritImpl.test_testing_eina_rw_slice_in(t.raw_handle, slc));
+
+ Test.Assert(t.rw_slice_in_flag);
+ Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
+
+ pinnedRWData.Free();
+ }
+
+ public static void test_inherit_eina_slice_out()
+ {
+ var t = new NativeInheritImpl();
+ var slc = new eina.Slice();
+ Test.Assert(NativeInheritImpl.test_testing_eina_slice_out(t.raw_handle, ref slc));
+ Test.Assert(t.slice_out_flag);
+ Test.Assert(slc.Mem != IntPtr.Zero);
+ Test.Assert(slc.Length == base_seq.Length);
+ Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
+ }
+
+ public static void test_inherit_eina_rw_slice_out()
+ {
+ var t = new NativeInheritImpl();
+ var slc = new eina.Rw_Slice();
+ Test.Assert(NativeInheritImpl.test_testing_eina_rw_slice_out(t.raw_handle, ref slc));
+ Test.Assert(t.rw_slice_out_flag);
+ Test.Assert(slc.Mem != IntPtr.Zero);
+ Test.Assert(slc.Length == base_seq.Length);
+ Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
+ }
+}
+
+class TestEinaArray
+{
+ public static void eina_array_default()
+ {
+ var a = new eina.Array<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ }
+
+ public static void push_int()
+ {
+ var a = new eina.Array<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88));
+ Test.Assert(a[0] == 88);
+ }
+
+ public static void push_string()
+ {
+ var a = new eina.Array<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("test string §éΨبÿツ"));
+ Test.AssertEquals("test string §éΨبÿツ", a[0]);
+ }
+
+ public static void push_obj()
+ {
+ var a = new eina.Array<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ var o = new test.NumberwrapperConcrete();
+ o.SetNumber(88);
+ Test.Assert(a.Push(o));
+ Test.Assert(a[0].raw_handle == o.raw_handle);
+ Test.Assert(a[0].GetNumber() == 88);
+ }
+
+ public static void pop_int()
+ {
+ var a = new eina.Array<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88));
+ Test.Assert(a.Pop() == 88);
+ Test.Assert(a.Count() == 0);
+ }
+
+ public static void pop_string()
+ {
+ var a = new eina.Array<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("test string"));
+ Test.Assert(a.Pop() == "test string");
+ Test.Assert(a.Count() == 0);
+ }
+
+ public static void pop_obj()
+ {
+ var a = new eina.Array<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ var o = new test.NumberwrapperConcrete();
+ o.SetNumber(88);
+ Test.Assert(a.Push(o));
+ var p = a.Pop();
+ Test.Assert(p.raw_handle == o.raw_handle);
+ Test.Assert(p.GetNumber() == 88);
+ Test.Assert(a.Count() == 0);
+ }
+
+ public static void data_set_int()
+ {
+ var a = new eina.Array<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88));
+ Test.Assert(a[0] == 88);
+ a.DataSet(0, 44);
+ Test.Assert(a[0] == 44);
+ a[0] = 22;
+ Test.Assert(a[0] == 22);
+ }
+
+ public static void data_set_string()
+ {
+ var a = new eina.Array<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("test string"));
+ Test.Assert(a[0] == "test string");
+ a.DataSet(0, "other string");
+ Test.Assert(a[0] == "other string");
+ a[0] = "abc";
+ Test.Assert(a[0] == "abc");
+ }
+
+ public static void data_set_obj()
+ {
+ var a = new eina.Array<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+
+ Test.Assert(a.Push(o1));
+ Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].GetNumber() == 88);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+
+ a.DataSet(0, o2);
+ Test.Assert(a[0].raw_handle == o2.raw_handle);
+ Test.Assert(a[0].GetNumber() == 44);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+
+ a[0] = o3;
+ Test.Assert(a[0].raw_handle == o3.raw_handle);
+ Test.Assert(a[0].GetNumber() == 22);
+ }
+
+ public static void count_int()
+ {
+ var a = new eina.Array<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Count() == 0);
+ Test.Assert(a.Push(88));
+ Test.Assert(a[0] == 88);
+ Test.Assert(a.Count() == 1);
+ Test.Assert(a.Push(44));
+ Test.Assert(a[1] == 44);
+ Test.Assert(a.Count() == 2);
+ Test.Assert(a.Push(22));
+ Test.Assert(a[2] == 22);
+ Test.Assert(a.Count() == 3);
+ }
+
+ public static void count_string()
+ {
+ var a = new eina.Array<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Count() == 0);
+ Test.Assert(a.Push("a"));
+ Test.Assert(a[0] == "a");
+ Test.Assert(a.Count() == 1);
+ Test.Assert(a.Push("b"));
+ Test.Assert(a[1] == "b");
+ Test.Assert(a.Count() == 2);
+ Test.Assert(a.Push("c"));
+ Test.Assert(a[2] == "c");
+ Test.Assert(a.Count() == 3);
+ }
+
+ public static void count_obj()
+ {
+ var a = new eina.Array<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+
+ Test.Assert(a.Count() == 0);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+ Test.Assert(a.Push(o1));
+ Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].GetNumber() == 88);
+ Test.Assert(a.Count() == 1);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+ Test.Assert(a.Push(o2));
+ Test.Assert(a[1].raw_handle == o2.raw_handle);
+ Test.Assert(a[1].GetNumber() == 44);
+ Test.Assert(a.Count() == 2);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+ Test.Assert(a.Push(o3));
+ Test.Assert(a[2].raw_handle == o3.raw_handle);
+ Test.Assert(a[2].GetNumber() == 22);
+ Test.Assert(a.Count() == 3);
+ }
+
+ public static void length_int()
+ {
+ var a = new eina.Array<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Length == 0);
+ Test.Assert(a.Push(88));
+ Test.Assert(a[0] == 88);
+ Test.Assert(a.Length == 1);
+ Test.Assert(a.Push(44));
+ Test.Assert(a[1] == 44);
+ Test.Assert(a.Length == 2);
+ Test.Assert(a.Push(22));
+ Test.Assert(a[2] == 22);
+ Test.Assert(a.Length == 3);
+ }
+
+ public static void length_string()
+ {
+ var a = new eina.Array<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Length == 0);
+ Test.Assert(a.Push("a"));
+ Test.Assert(a[0] == "a");
+ Test.Assert(a.Length == 1);
+ Test.Assert(a.Push("b"));
+ Test.Assert(a[1] == "b");
+ Test.Assert(a.Length == 2);
+ Test.Assert(a.Push("c"));
+ Test.Assert(a[2] == "c");
+ Test.Assert(a.Length == 3);
+ }
+
+ public static void eina_array_as_ienumerable_int()
+ {
+ var a = new eina.Array<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88));
+ Test.Assert(a.Push(44));
+ Test.Assert(a.Push(22));
+
+ int cmp = 88;
+ foreach (int e in a)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp /= 2;
+ }
+ }
+
+ public static void eina_array_as_ienumerable_string()
+ {
+ var a = new eina.Array<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("X"));
+ Test.Assert(a.Push("XX"));
+ Test.Assert(a.Push("XXX"));
+
+ string cmp = "X";
+ foreach (string e in a)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp = cmp + "X";
+ }
+ }
+
+ public static void eina_array_as_ienumerable_obj()
+ {
+ var a = new test.NumberwrapperConcrete();
+ var b = new test.NumberwrapperConcrete();
+ var c = new test.NumberwrapperConcrete();
+ a.SetNumber(88);
+ b.SetNumber(44);
+ c.SetNumber(22);
+ var cmp = new test.NumberwrapperConcrete[]{a,b,c};
+
+ var arr = new eina.Array<test.NumberwrapperConcrete>();
+ Test.Assert(arr.Handle != IntPtr.Zero);
+ Test.Assert(arr.Push(a));
+ Test.Assert(arr.Push(b));
+ Test.Assert(arr.Push(c));
+
+ int i = 0;
+ foreach (test.NumberwrapperConcrete e in arr)
+ {
+ Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
+ Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ ++i;
+ }
+ }
+
+ // //
+ // Code Generation
+ //
+
+ // Integer //
+
+ public static void test_eina_array_int_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Array<int>();
+ arr.Append(base_seq_int);
+ Test.Assert(t.EinaArrayIntIn(arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_array_int_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Array<int>();
+ arr.Append(base_seq_int);
+ Test.Assert(t.EinaArrayIntInOwn(arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayIntInOwn());
+ }
+
+ public static void test_eina_array_int_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Array<int> arr;
+ Test.Assert(t.EinaArrayIntOut(out arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayIntOut());
+ }
+
+ public static void test_eina_array_int_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Array<int> arr;
+ Test.Assert(t.EinaArrayIntOutOwn(out arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_array_int_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaArrayIntReturn();
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayIntReturn());
+ }
+
+ public static void test_eina_array_int_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaArrayIntReturnOwn();
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ // String //
+ public static void test_eina_array_str_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Array<string>();
+ arr.Append(base_seq_str);
+ Test.Assert(t.EinaArrayStrIn(arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_array_str_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Array<string>();
+ arr.Append(base_seq_str);
+ Test.Assert(t.EinaArrayStrInOwn(arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayStrInOwn());
+ }
+
+ public static void test_eina_array_str_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Array<string> arr;
+ Test.Assert(t.EinaArrayStrOut(out arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayStrOut());
+ }
+
+ public static void test_eina_array_str_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Array<string> arr;
+ Test.Assert(t.EinaArrayStrOutOwn(out arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_array_str_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaArrayStrReturn();
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayStrReturn());
+ }
+
+ public static void test_eina_array_str_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaArrayStrReturnOwn();
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ // Object //
+
+ public static void test_eina_array_obj_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Array<test.Numberwrapper>();
+ arr.Append(BaseSeqObj());
+ Test.Assert(t.EinaArrayObjIn(arr));
+ Test.Assert(arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_array_obj_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Array<test.Numberwrapper>();
+ arr.Append(BaseSeqObj());
+ Test.Assert(t.EinaArrayObjInOwn(arr));
+ Test.Assert(!arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayObjInOwn());
+ }
+
+ public static void test_eina_array_obj_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Array<test.Numberwrapper> arr;
+ Test.Assert(t.EinaArrayObjOut(out arr));
+ Test.Assert(!arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayObjOut());
+ }
+
+ public static void test_eina_array_obj_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Array<test.Numberwrapper> arr;
+ Test.Assert(t.EinaArrayObjOutOwn(out arr));
+ Test.Assert(arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_array_obj_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaArrayObjReturn();
+ Test.Assert(!arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaArrayObjReturn());
+ }
+
+ public static void test_eina_array_obj_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaArrayObjReturnOwn();
+ Test.Assert(arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_array_obj_return_in_same_id()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var cmp = BaseSeqObj();
+ var a = new eina.Array<test.Numberwrapper>();
+ a.Append(cmp);
+ var b = t.EinaArrayObjReturnIn(a);
+ NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
+ NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
+ int len = a.Length;
+ for (int i=0; i < len; ++i)
+ {
+ Test.Assert(a[i].raw_handle == b[i].raw_handle);
+ Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ }
+ }
+
+
+ // //
+ // Inherit
+ //
+}
+
+class TestEinaInarray
+{
+ public static void eina_inarray_default()
+ {
+ var a = new eina.Inarray<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ a.Dispose();
+ }
+
+ public static void push_int()
+ {
+ var a = new eina.Inarray<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88) == 0);
+ Test.Assert(a[0] == 88);
+ a.Dispose();
+ }
+
+ public static void push_string()
+ {
+ var a = new eina.Inarray<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("test string") == 0);
+ Test.Assert(a[0] == "test string");
+ a.Dispose();
+ }
+
+ public static void push_obj()
+ {
+ var a = new eina.Inarray<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ var o = new test.NumberwrapperConcrete();
+ o.SetNumber(88);
+ Test.Assert(a.Push(o) == 0);
+ Test.Assert(a[0].raw_handle == o.raw_handle);
+ Test.Assert(a[0].GetNumber() == 88);
+ a.Dispose();
+ }
+
+ public static void pop_int()
+ {
+ var a = new eina.Inarray<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88) >= 0);
+ Test.Assert(a.Pop() == 88);
+ Test.Assert(a.Count() == 0);
+ a.Dispose();
+ }
+
+ public static void pop_string()
+ {
+ var a = new eina.Inarray<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("test string") >= 0);
+ Test.Assert(a.Pop() == "test string");
+ Test.Assert(a.Count() == 0);
+ a.Dispose();
+ }
+
+ public static void pop_obj()
+ {
+ var a = new eina.Inarray<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ var o = new test.NumberwrapperConcrete();
+ o.SetNumber(88);
+ Test.Assert(a.Push(o) >= 0);
+ var p = a.Pop();
+ Test.Assert(p.raw_handle == o.raw_handle);
+ Test.Assert(p.GetNumber() == 88);
+ Test.Assert(a.Count() == 0);
+ a.Dispose();
+ }
+
+ public static void replace_at_int()
+ {
+ var a = new eina.Inarray<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88) >= 0);
+ Test.Assert(a[0] == 88);
+ a.ReplaceAt(0, 44);
+ Test.Assert(a[0] == 44);
+ Test.Assert(a.Count() == 1);
+ a[0] = 22;
+ Test.Assert(a[0] == 22);
+ Test.Assert(a.Count() == 1);
+ a.Dispose();
+ }
+
+ public static void replace_at_string()
+ {
+ var a = new eina.Inarray<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("test string") >= 0);
+ Test.Assert(a[0] == "test string");
+ a.ReplaceAt(0, "other string");
+ Test.Assert(a[0] == "other string");
+ Test.Assert(a.Count() == 1);
+ a[0] = "abc";
+ Test.Assert(a[0] == "abc");
+ Test.Assert(a.Count() == 1);
+ a.Dispose();
+ }
+
+ public static void replace_at_obj()
+ {
+ var a = new eina.Inarray<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+
+ Test.Assert(a.Push(o1) >= 0);
+ Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].GetNumber() == 88);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+
+ a.ReplaceAt(0, o2);
+ Test.Assert(a[0].raw_handle == o2.raw_handle);
+ Test.Assert(a[0].GetNumber() == 44);
+ Test.Assert(a.Count() == 1);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+
+ a[0] = o3;
+ Test.Assert(a[0].raw_handle == o3.raw_handle);
+ Test.Assert(a[0].GetNumber() == 22);
+ Test.Assert(a.Count() == 1);
+
+ a.Dispose();
+ }
+
+ public static void count_int()
+ {
+ var a = new eina.Inarray<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Count() == 0);
+ Test.Assert(a.Push(88) == 0);
+ Test.Assert(a[0] == 88);
+ Test.Assert(a.Count() == 1);
+ Test.Assert(a.Push(44) == 1);
+ Test.Assert(a[1] == 44);
+ Test.Assert(a.Count() == 2);
+ Test.Assert(a.Push(22) == 2);
+ Test.Assert(a[2] == 22);
+ Test.Assert(a.Count() == 3);
+ a.Dispose();
+ }
+
+ public static void count_string()
+ {
+ var a = new eina.Inarray<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Count() == 0);
+ Test.Assert(a.Push("a") == 0);
+ Test.Assert(a[0] == "a");
+ Test.Assert(a.Count() == 1);
+ Test.Assert(a.Push("b") == 1);
+ Test.Assert(a[1] == "b");
+ Test.Assert(a.Count() == 2);
+ Test.Assert(a.Push("c") == 2);
+ Test.Assert(a[2] == "c");
+ Test.Assert(a.Count() == 3);
+ a.Dispose();
+ }
+
+ public static void count_obj()
+ {
+ var a = new eina.Inarray<test.NumberwrapperConcrete>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+
+ Test.Assert(a.Count() == 0);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+ Test.Assert(a.Push(o1) == 0);
+ Test.Assert(a[0].raw_handle == o1.raw_handle);
+ Test.Assert(a[0].GetNumber() == 88);
+ Test.Assert(a.Count() == 1);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+ Test.Assert(a.Push(o2) == 1);
+ Test.Assert(a[1].raw_handle == o2.raw_handle);
+ Test.Assert(a[1].GetNumber() == 44);
+ Test.Assert(a.Count() == 2);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+ Test.Assert(a.Push(o3) == 2);
+ Test.Assert(a[2].raw_handle == o3.raw_handle);
+ Test.Assert(a[2].GetNumber() == 22);
+ Test.Assert(a.Count() == 3);
+
+ a.Dispose();
+ }
+
+ public static void length_int()
+ {
+ var a = new eina.Inarray<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Length == 0);
+ Test.Assert(a.Push(88) >= 0);
+ Test.Assert(a[0] == 88);
+ Test.Assert(a.Length == 1);
+ Test.Assert(a.Push(44) >= 0);
+ Test.Assert(a[1] == 44);
+ Test.Assert(a.Length == 2);
+ Test.Assert(a.Push(22) >= 0);
+ Test.Assert(a[2] == 22);
+ Test.Assert(a.Length == 3);
+ a.Dispose();
+ }
+
+ public static void length_string()
+ {
+ var a = new eina.Inarray<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Length == 0);
+ Test.Assert(a.Push("a") >= 0);
+ Test.Assert(a[0] == "a");
+ Test.Assert(a.Length == 1);
+ Test.Assert(a.Push("b") >= 0);
+ Test.Assert(a[1] == "b");
+ Test.Assert(a.Length == 2);
+ Test.Assert(a.Push("c") >= 0);
+ Test.Assert(a[2] == "c");
+ Test.Assert(a.Length == 3);
+ a.Dispose();
+ }
+
+ public static void eina_inarray_as_ienumerable_int()
+ {
+ var a = new eina.Inarray<int>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push(88) == 0);
+ Test.Assert(a.Push(44) == 1);
+ Test.Assert(a.Push(22) == 2);
+
+ int cmp = 88;
+ foreach (int e in a)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp /= 2;
+ }
+ a.Dispose();
+ }
+
+ public static void eina_inarray_as_ienumerable_string()
+ {
+ var a = new eina.Inarray<string>();
+ Test.Assert(a.Handle != IntPtr.Zero);
+ Test.Assert(a.Push("X") == 0);
+ Test.Assert(a.Push("XX") == 1);
+ Test.Assert(a.Push("XXX") == 2);
+
+ string cmp = "X";
+ foreach (string e in a)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp = cmp + "X";
+ }
+ a.Dispose();
+ }
+
+ public static void eina_inarray_as_ienumerable_obj()
+ {
+ var a = new test.NumberwrapperConcrete();
+ var b = new test.NumberwrapperConcrete();
+ var c = new test.NumberwrapperConcrete();
+ a.SetNumber(88);
+ b.SetNumber(44);
+ c.SetNumber(22);
+ var cmp = new test.NumberwrapperConcrete[]{a,b,c};
+
+ var arr = new eina.Inarray<test.NumberwrapperConcrete>();
+ Test.Assert(arr.Handle != IntPtr.Zero);
+ Test.Assert(arr.Push(a) == 0);
+ Test.Assert(arr.Push(b) == 1);
+ Test.Assert(arr.Push(c) == 2);
+
+ int i = 0;
+ foreach (test.NumberwrapperConcrete e in arr)
+ {
+ Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
+ Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ ++i;
+ }
+ arr.Dispose();
+ }
+
+ // //
+ // Code Generation
+ //
+
+ // Integer //
+
+ public static void test_eina_inarray_int_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Inarray<int>();
+ arr.Append(base_seq_int);
+ Test.Assert(t.EinaInarrayIntIn(arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inarray_int_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Inarray<int>();
+ arr.Append(base_seq_int);
+ Test.Assert(t.EinaInarrayIntInOwn(arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayIntInOwn());
+ }
+
+ public static void test_eina_inarray_int_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inarray<int> arr;
+ Test.Assert(t.EinaInarrayIntOut(out arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayIntOut());
+ }
+
+ public static void test_eina_inarray_int_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inarray<int> arr;
+ Test.Assert(t.EinaInarrayIntOutOwn(out arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inarray_int_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaInarrayIntReturn();
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayIntReturn());
+ }
+
+ public static void test_eina_inarray_int_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaInarrayIntReturnOwn();
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
+ Test.Assert(arr.Append(append_seq_int));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ // String //
+ public static void test_eina_inarray_str_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Inarray<string>();
+ arr.Append(base_seq_str);
+ Test.Assert(t.EinaInarrayStrIn(arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inarray_str_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Inarray<string>();
+ arr.Append(base_seq_str);
+ Test.Assert(t.EinaInarrayStrInOwn(arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayStrInOwn());
+ }
+
+ public static void test_eina_inarray_str_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inarray<string> arr;
+ Test.Assert(t.EinaInarrayStrOut(out arr));
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayStrOut());
+ }
+
+ public static void test_eina_inarray_str_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inarray<string> arr;
+ Test.Assert(t.EinaInarrayStrOutOwn(out arr));
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inarray_str_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaInarrayStrReturn();
+ Test.Assert(!arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayStrReturn());
+ }
+
+ public static void test_eina_inarray_str_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaInarrayStrReturnOwn();
+ Test.Assert(arr.Own);
+ Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
+ Test.Assert(arr.Append(append_seq_str));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ // Object //
+
+ public static void test_eina_inarray_obj_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Inarray<test.Numberwrapper>();
+ arr.Append(BaseSeqObj());
+ Test.Assert(t.EinaInarrayObjIn(arr));
+ Test.Assert(arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inarray_obj_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = new eina.Inarray<test.Numberwrapper>();
+ arr.Append(BaseSeqObj());
+ Test.Assert(t.EinaInarrayObjInOwn(arr));
+ Test.Assert(!arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayObjInOwn());
+ }
+
+ public static void test_eina_inarray_obj_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inarray<test.Numberwrapper> arr;
+ Test.Assert(t.EinaInarrayObjOut(out arr));
+ Test.Assert(!arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayObjOut());
+ }
+
+ public static void test_eina_inarray_obj_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inarray<test.Numberwrapper> arr;
+ Test.Assert(t.EinaInarrayObjOutOwn(out arr));
+ Test.Assert(arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inarray_obj_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaInarrayObjReturn();
+ Test.Assert(!arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInarrayObjReturn());
+ }
+
+ public static void test_eina_inarray_obj_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var arr = t.EinaInarrayObjReturnOwn();
+ Test.Assert(arr.Own);
+ NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
+ Test.Assert(arr.Append(AppendSeqObj()));
+ arr.Dispose();
+ Test.Assert(arr.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inarray_obj_return_in_same_id()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var cmp = BaseSeqObj();
+ var a = new eina.Inarray<test.Numberwrapper>();
+ a.Append(cmp);
+ var b = t.EinaInarrayObjReturnIn(a);
+ NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
+ NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
+ int len = a.Length;
+ for (int i=0; i < len; ++i)
+ {
+ Test.Assert(a[i].raw_handle == b[i].raw_handle);
+ Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ }
+ a.Dispose();
+ }
+}
+
+class TestEinaList
+{
+ public static void data_set_int()
+ {
+ var lst = new eina.List<int>();
+ lst.Append(88);
+ Test.Assert(lst[0] == 88);
+ lst.DataSet(0, 44);
+ Test.Assert(lst[0] == 44);
+ lst[0] = 22;
+ Test.Assert(lst[0] == 22);
+ }
+
+ public static void data_set_string()
+ {
+ var lst = new eina.List<string>();
+ lst.Append("test string");
+ Test.Assert(lst[0] == "test string");
+ lst.DataSet(0, "other string");
+ Test.Assert(lst[0] == "other string");
+ lst[0] = "abc";
+ Test.Assert(lst[0] == "abc");
+ }
+
+ public static void data_set_obj()
+ {
+ var lst = new eina.List<test.NumberwrapperConcrete>();
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+
+ lst.Append(o1);
+ Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 88);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+
+ lst.DataSet(0, o2);
+ Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 44);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+
+ lst[0] = o3;
+ Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 22);
+ }
+
+ public static void append_count_int()
+ {
+ var lst = new eina.List<int>();
+ Test.Assert(lst.Count() == 0);
+ lst.Append(88);
+ Test.Assert(lst[0] == 88);
+ Test.Assert(lst.Count() == 1);
+ lst.Append(44);
+ Test.Assert(lst[1] == 44);
+ Test.Assert(lst.Count() == 2);
+ lst.Append(22);
+ Test.Assert(lst[2] == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void append_count_string()
+ {
+ var lst = new eina.List<string>();
+ Test.Assert(lst.Count() == 0);
+ lst.Append("a");
+ Test.Assert(lst[0] == "a");
+ Test.Assert(lst.Count() == 1);
+ lst.Append("b");
+ Test.Assert(lst[1] == "b");
+ Test.Assert(lst.Count() == 2);
+ lst.Append("c");
+ Test.Assert(lst[2] == "c");
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void append_count_obj()
+ {
+ var lst = new eina.List<test.NumberwrapperConcrete>();
+
+ Test.Assert(lst.Count() == 0);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+ lst.Append(o1);
+ Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 88);
+ Test.Assert(lst.Count() == 1);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+ lst.Append(o2);
+ Test.Assert(lst[1].raw_handle == o2.raw_handle);
+ Test.Assert(lst[1].GetNumber() == 44);
+ Test.Assert(lst.Count() == 2);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+ lst.Append(o3);
+ Test.Assert(lst[2].raw_handle == o3.raw_handle);
+ Test.Assert(lst[2].GetNumber() == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void length_int()
+ {
+ var lst = new eina.List<int>();
+ Test.Assert(lst.Length == 0);
+ lst.Append(88);
+ Test.Assert(lst[0] == 88);
+ Test.Assert(lst.Length == 1);
+ lst.Append(44);
+ Test.Assert(lst[1] == 44);
+ Test.Assert(lst.Length == 2);
+ lst.Append(22);
+ Test.Assert(lst[2] == 22);
+ Test.Assert(lst.Length == 3);
+ }
+
+ public static void length_string()
+ {
+ var lst = new eina.List<string>();
+ Test.Assert(lst.Length == 0);
+ lst.Append("a");
+ Test.Assert(lst[0] == "a");
+ Test.Assert(lst.Length == 1);
+ lst.Append("b");
+ Test.Assert(lst[1] == "b");
+ Test.Assert(lst.Length == 2);
+ lst.Append("c");
+ Test.Assert(lst[2] == "c");
+ Test.Assert(lst.Length == 3);
+ }
+
+ public static void prepend_count_int()
+ {
+ var lst = new eina.List<int>();
+ Test.Assert(lst.Count() == 0);
+ lst.Prepend(88);
+ Test.Assert(lst[0] == 88);
+ Test.Assert(lst.Count() == 1);
+ lst.Prepend(44);
+ Test.Assert(lst[0] == 44);
+ Test.Assert(lst.Count() == 2);
+ lst.Prepend(22);
+ Test.Assert(lst[0] == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void prepend_count_string()
+ {
+ var lst = new eina.List<string>();
+ Test.Assert(lst.Count() == 0);
+ lst.Prepend("a");
+ Test.Assert(lst[0] == "a");
+ Test.Assert(lst.Count() == 1);
+ lst.Prepend("b");
+ Test.Assert(lst[0] == "b");
+ Test.Assert(lst.Count() == 2);
+ lst.Prepend("c");
+ Test.Assert(lst[0] == "c");
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void prepend_count_obj()
+ {
+ var lst = new eina.List<test.NumberwrapperConcrete>();
+
+ Test.Assert(lst.Count() == 0);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+ lst.Prepend(o1);
+ Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 88);
+ Test.Assert(lst.Count() == 1);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+ lst.Prepend(o2);
+ Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 44);
+ Test.Assert(lst.Count() == 2);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+ lst.Prepend(o3);
+ Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void sorted_insert_int()
+ {
+ var lst = new eina.List<int>();
+ lst.SortedInsert(88);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{88}));
+ lst.SortedInsert(22);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{22,88}));
+ lst.SortedInsert(44);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{22,44,88}));
+
+ }
+
+ public static void sorted_insert_string()
+ {
+ var lst = new eina.List<string>();
+ lst.SortedInsert("c");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"c"}));
+ lst.SortedInsert("a");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"a","c"}));
+ lst.SortedInsert("b");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"a","b","c"}));
+
+ }
+
+ public static void sort_int()
+ {
+ var lst = new eina.List<int>();
+ lst.Append(88);
+ lst.Append(22);
+ lst.Append(11);
+ lst.Append(44);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{88,22,11,44}));
+ lst.Sort();
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{11,22,44,88}));
+
+ }
+
+ public static void sort_string()
+ {
+ var lst = new eina.List<string>();
+ lst.Append("d");
+ lst.Append("b");
+ lst.Append("a");
+ lst.Append("c");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"d","b","a","c"}));
+ lst.Sort();
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"a","b","c","d"}));
+ }
+
+ public static void reverse_int()
+ {
+ var lst = new eina.List<int>();
+ lst.Append(22);
+ lst.Append(44);
+ lst.Append(88);
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{22,44,88}));
+ lst.Reverse();
+ Test.Assert(lst.ToArray().SequenceEqual(new int[]{88,44,22}));
+
+ }
+
+ public static void reverse_string()
+ {
+ var lst = new eina.List<string>();
+ lst.Append("a");
+ lst.Append("b");
+ lst.Append("c");
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"a","b","c"}));
+ lst.Reverse();
+ Test.Assert(lst.ToArray().SequenceEqual(new string[]{"c","b","a"}));
+ }
+
+ public static void eina_list_as_ienumerable_int()
+ {
+ var lst = new eina.List<int>();
+ lst.Append(88);
+ lst.Append(44);
+ lst.Append(22);
+
+ int cmp = 88;
+ foreach (int e in lst)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp /= 2;
+ }
+ }
+
+ public static void eina_list_as_ienumerable_string()
+ {
+ var lst = new eina.List<string>();
+ lst.Append("X");
+ lst.Append("XX");
+ lst.Append("XXX");
+
+ string cmp = "X";
+ foreach (string e in lst)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp = cmp + "X";
+ }
+ }
+
+ public static void eina_list_as_ienumerable_obj()
+ {
+ var a = new test.NumberwrapperConcrete();
+ var b = new test.NumberwrapperConcrete();
+ var c = new test.NumberwrapperConcrete();
+ a.SetNumber(88);
+ b.SetNumber(44);
+ c.SetNumber(22);
+ var cmp = new test.NumberwrapperConcrete[]{a,b,c};
+
+ var lst = new eina.List<test.NumberwrapperConcrete>();
+ lst.Append(a);
+ lst.Append(b);
+ lst.Append(c);
+
+ int i = 0;
+ foreach (test.NumberwrapperConcrete e in lst)
+ {
+ Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
+ Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ ++i;
+ }
+ }
+
+ // //
+ // Code Generation
+ //
+
+ // Integer //
+
+ public static void test_eina_list_int_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.List<int>();
+ lst.AppendArray(base_seq_int);
+ Test.Assert(t.EinaListIntIn(lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_list_int_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.List<int>();
+ lst.AppendArray(base_seq_int);
+ Test.Assert(t.EinaListIntInOwn(lst));
+ Test.Assert(!lst.Own);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListIntInOwn());
+ }
+
+ public static void test_eina_list_int_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.List<int> lst;
+ Test.Assert(t.EinaListIntOut(out lst));
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListIntOut());
+ }
+
+ public static void test_eina_list_int_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.List<int> lst;
+ Test.Assert(t.EinaListIntOutOwn(out lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.AppendArray(append_seq_int);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_list_int_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaListIntReturn();
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListIntReturn());
+ }
+
+ public static void test_eina_list_int_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaListIntReturnOwn();
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.AppendArray(append_seq_int);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ // String //
+ public static void test_eina_list_str_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.List<string>();
+ lst.AppendArray(base_seq_str);
+ Test.Assert(t.EinaListStrIn(lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_list_str_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.List<string>();
+ lst.AppendArray(base_seq_str);
+ Test.Assert(t.EinaListStrInOwn(lst));
+ Test.Assert(!lst.Own);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListStrInOwn());
+ }
+
+ public static void test_eina_list_str_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.List<string> lst;
+ Test.Assert(t.EinaListStrOut(out lst));
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListStrOut());
+ }
+
+ public static void test_eina_list_str_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.List<string> lst;
+ Test.Assert(t.EinaListStrOutOwn(out lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.AppendArray(append_seq_str);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_list_str_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaListStrReturn();
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListStrReturn());
+ }
+
+ public static void test_eina_list_str_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaListStrReturnOwn();
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.AppendArray(append_seq_str);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ // Object //
+
+ public static void test_eina_list_obj_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.List<test.Numberwrapper>();
+ lst.AppendArray(BaseSeqObj());
+ Test.Assert(t.EinaListObjIn(lst));
+ Test.Assert(lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_list_obj_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.List<test.Numberwrapper>();
+ lst.AppendArray(BaseSeqObj());
+ Test.Assert(t.EinaListObjInOwn(lst));
+ Test.Assert(!lst.Own);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListObjInOwn());
+ }
+
+ public static void test_eina_list_obj_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.List<test.Numberwrapper> lst;
+ Test.Assert(t.EinaListObjOut(out lst));
+ Test.Assert(!lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListObjOut());
+ }
+
+ public static void test_eina_list_obj_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.List<test.Numberwrapper> lst;
+ Test.Assert(t.EinaListObjOutOwn(out lst));
+ Test.Assert(lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.AppendArray(AppendSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_list_obj_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaListObjReturn();
+ Test.Assert(!lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaListObjReturn());
+ }
+
+ public static void test_eina_list_obj_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaListObjReturnOwn();
+ Test.Assert(lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.AppendArray(AppendSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_list_obj_return_in_same_id()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var cmp = BaseSeqObj();
+ var a = new eina.List<test.Numberwrapper>();
+ a.AppendArray(cmp);
+ var b = t.EinaListObjReturnIn(a);
+ NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
+ NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
+ int len = a.Length;
+ for (int i=0; i < len; ++i)
+ {
+ Test.Assert(a[i].raw_handle == b[i].raw_handle);
+ Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ }
+ }
+}
+
+class TestEinaInlist
+{
+ public static void data_set_int()
+ {
+ var lst = new eina.Inlist<int>();
+ lst.Append(88);
+ Test.Assert(lst[0] == 88);
+ lst.DataSet(0, 44);
+ Test.Assert(lst[0] == 44);
+ lst[0] = 22;
+ Test.Assert(lst[0] == 22);
+ Test.Assert(lst.Count() == 1);
+ }
+
+ public static void data_set_string()
+ {
+ var lst = new eina.Inlist<string>();
+ lst.Append("test string");
+ Test.Assert(lst[0] == "test string");
+ lst.DataSet(0, "other string");
+ Test.Assert(lst[0] == "other string");
+ lst[0] = "abc";
+ Test.Assert(lst[0] == "abc");
+ Test.Assert(lst.Count() == 1);
+ }
+
+ public static void data_set_obj()
+ {
+ var lst = new eina.Inlist<test.NumberwrapperConcrete>();
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+
+ lst.Append(o1);
+ Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 88);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+
+ lst.DataSet(0, o2);
+ Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 44);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+
+ lst[0] = o3;
+ Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 22);
+
+ Test.Assert(lst.Count() == 1);
+ }
+
+ public static void append_count_int()
+ {
+ var lst = new eina.Inlist<int>();
+ Test.Assert(lst.Count() == 0);
+ lst.Append(88);
+ Test.Assert(lst[0] == 88);
+ Test.Assert(lst.Count() == 1);
+ lst.Append(44);
+ Test.Assert(lst[1] == 44);
+ Test.Assert(lst.Count() == 2);
+ lst.Append(22);
+ Test.Assert(lst[2] == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void append_count_string()
+ {
+ var lst = new eina.Inlist<string>();
+ Test.Assert(lst.Count() == 0);
+ lst.Append("a");
+ Test.Assert(lst[0] == "a");
+ Test.Assert(lst.Count() == 1);
+ lst.Append("b");
+ Test.Assert(lst[1] == "b");
+ Test.Assert(lst.Count() == 2);
+ lst.Append("c");
+ Test.Assert(lst[2] == "c");
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void append_count_obj()
+ {
+ var lst = new eina.Inlist<test.NumberwrapperConcrete>();
+
+ Test.Assert(lst.Count() == 0);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+ lst.Append(o1);
+ Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 88);
+ Test.Assert(lst.Count() == 1);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+ lst.Append(o2);
+ Test.Assert(lst[1].raw_handle == o2.raw_handle);
+ Test.Assert(lst[1].GetNumber() == 44);
+ Test.Assert(lst.Count() == 2);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+ lst.Append(o3);
+ Test.Assert(lst[2].raw_handle == o3.raw_handle);
+ Test.Assert(lst[2].GetNumber() == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void length_int()
+ {
+ var lst = new eina.Inlist<int>();
+ Test.Assert(lst.Length == 0);
+ lst.Append(88);
+ Test.Assert(lst[0] == 88);
+ Test.Assert(lst.Length == 1);
+ lst.Append(44);
+ Test.Assert(lst[1] == 44);
+ Test.Assert(lst.Length == 2);
+ lst.Append(22);
+ Test.Assert(lst[2] == 22);
+ Test.Assert(lst.Length == 3);
+ }
+
+ public static void length_string()
+ {
+ var lst = new eina.Inlist<string>();
+ Test.Assert(lst.Length == 0);
+ lst.Append("a");
+ Test.Assert(lst[0] == "a");
+ Test.Assert(lst.Length == 1);
+ lst.Append("b");
+ Test.Assert(lst[1] == "b");
+ Test.Assert(lst.Length == 2);
+ lst.Append("c");
+ Test.Assert(lst[2] == "c");
+ Test.Assert(lst.Length == 3);
+ }
+
+ public static void prepend_count_int()
+ {
+ var lst = new eina.Inlist<int>();
+ Test.Assert(lst.Count() == 0);
+ lst.Prepend(88);
+ Test.Assert(lst[0] == 88);
+ Test.Assert(lst.Count() == 1);
+ lst.Prepend(44);
+ Test.Assert(lst[0] == 44);
+ Test.Assert(lst.Count() == 2);
+ lst.Prepend(22);
+ Test.Assert(lst[0] == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void prepend_count_string()
+ {
+ var lst = new eina.Inlist<string>();
+ Test.Assert(lst.Count() == 0);
+ lst.Prepend("a");
+ Test.Assert(lst[0] == "a");
+ Test.Assert(lst.Count() == 1);
+ lst.Prepend("b");
+ Test.Assert(lst[0] == "b");
+ Test.Assert(lst.Count() == 2);
+ lst.Prepend("c");
+ Test.Assert(lst[0] == "c");
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void prepend_count_obj()
+ {
+ var lst = new eina.Inlist<test.NumberwrapperConcrete>();
+
+ Test.Assert(lst.Count() == 0);
+
+ var o1 = new test.NumberwrapperConcrete();
+ o1.SetNumber(88);
+ lst.Prepend(o1);
+ Test.Assert(lst[0].raw_handle == o1.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 88);
+ Test.Assert(lst.Count() == 1);
+
+ var o2 = new test.NumberwrapperConcrete();
+ o2.SetNumber(44);
+ lst.Prepend(o2);
+ Test.Assert(lst[0].raw_handle == o2.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 44);
+ Test.Assert(lst.Count() == 2);
+
+ var o3 = new test.NumberwrapperConcrete();
+ o3.SetNumber(22);
+ lst.Prepend(o3);
+ Test.Assert(lst[0].raw_handle == o3.raw_handle);
+ Test.Assert(lst[0].GetNumber() == 22);
+ Test.Assert(lst.Count() == 3);
+ }
+
+ public static void eina_inlist_as_ienumerable_int()
+ {
+ var lst = new eina.Inlist<int>();
+ lst.Append(88);
+ lst.Append(44);
+ lst.Append(22);
+
+ int cmp = 88;
+ foreach (int e in lst)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp /= 2;
+ }
+ }
+
+ public static void eina_inlist_as_ienumerable_string()
+ {
+ var lst = new eina.Inlist<string>();
+ lst.Append("X");
+ lst.Append("XX");
+ lst.Append("XXX");
+
+ string cmp = "X";
+ foreach (string e in lst)
+ {
+ Test.AssertEquals(cmp, e);
+ cmp = cmp + "X";
+ }
+ }
+
+ public static void eina_inlist_as_ienumerable_obj()
+ {
+ var a = new test.NumberwrapperConcrete();
+ var b = new test.NumberwrapperConcrete();
+ var c = new test.NumberwrapperConcrete();
+ a.SetNumber(88);
+ b.SetNumber(44);
+ c.SetNumber(22);
+ var cmp = new test.NumberwrapperConcrete[]{a,b,c};
+
+ var lst = new eina.Inlist<test.NumberwrapperConcrete>();
+ lst.Append(a);
+ lst.Append(b);
+ lst.Append(c);
+
+ int i = 0;
+ foreach (test.NumberwrapperConcrete e in lst)
+ {
+ Test.AssertEquals(cmp[i].GetNumber(), e.GetNumber());
+ Test.Assert(cmp[i].raw_handle == e.raw_handle);
+ ++i;
+ }
+ }
+
+ // //
+ // Code Generation
+ //
+
+ // Integer //
+
+ public static void test_eina_inlist_int_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.Inlist<int>();
+ lst.AppendArray(base_seq_int);
+ Test.Assert(t.EinaInlistIntIn(lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inlist_int_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.Inlist<int>();
+ lst.AppendArray(base_seq_int);
+ Test.Assert(t.EinaInlistIntInOwn(lst));
+ Test.Assert(!lst.Own);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistIntInOwn());
+ }
+
+ public static void test_eina_inlist_int_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inlist<int> lst;
+ Test.Assert(t.EinaInlistIntOut(out lst));
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistIntOut());
+ }
+
+ public static void test_eina_inlist_int_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inlist<int> lst;
+ Test.Assert(t.EinaInlistIntOutOwn(out lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.AppendArray(append_seq_int);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inlist_int_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaInlistIntReturn();
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistIntReturn());
+ }
+
+ public static void test_eina_inlist_int_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaInlistIntReturnOwn();
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
+ lst.AppendArray(append_seq_int);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ // String //
+ public static void test_eina_inlist_str_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.Inlist<string>();
+ lst.AppendArray(base_seq_str);
+ Test.Assert(t.EinaInlistStrIn(lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inlist_str_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.Inlist<string>();
+ lst.AppendArray(base_seq_str);
+ Test.Assert(t.EinaInlistStrInOwn(lst));
+ Test.Assert(!lst.Own);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistStrInOwn());
+ }
+
+ public static void test_eina_inlist_str_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inlist<string> lst;
+ Test.Assert(t.EinaInlistStrOut(out lst));
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistStrOut());
+ }
+
+ public static void test_eina_inlist_str_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inlist<string> lst;
+ Test.Assert(t.EinaInlistStrOutOwn(out lst));
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.AppendArray(append_seq_str);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inlist_str_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaInlistStrReturn();
+ Test.Assert(!lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistStrReturn());
+ }
+
+ public static void test_eina_inlist_str_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaInlistStrReturnOwn();
+ Test.Assert(lst.Own);
+ Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
+ lst.AppendArray(append_seq_str);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ // Object //
+
+ public static void test_eina_inlist_obj_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.Inlist<test.Numberwrapper>();
+ lst.AppendArray(BaseSeqObj());
+ Test.Assert(t.EinaInlistObjIn(lst));
+ Test.Assert(lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inlist_obj_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = new eina.Inlist<test.Numberwrapper>();
+ lst.AppendArray(BaseSeqObj());
+ Test.Assert(t.EinaInlistObjInOwn(lst));
+ Test.Assert(!lst.Own);
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistObjInOwn());
+ }
+
+ public static void test_eina_inlist_obj_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inlist<test.Numberwrapper> lst;
+ Test.Assert(t.EinaInlistObjOut(out lst));
+ Test.Assert(!lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistObjOut());
+ }
+
+ public static void test_eina_inlist_obj_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Inlist<test.Numberwrapper> lst;
+ Test.Assert(t.EinaInlistObjOutOwn(out lst));
+ Test.Assert(lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.AppendArray(AppendSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inlist_obj_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaInlistObjReturn();
+ Test.Assert(!lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaInlistObjReturn());
+ }
+
+ public static void test_eina_inlist_obj_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var lst = t.EinaInlistObjReturnOwn();
+ Test.Assert(lst.Own);
+ NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
+ lst.AppendArray(AppendSeqObj());
+ lst.Dispose();
+ Test.Assert(lst.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_inlist_obj_return_in_same_id()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var cmp = BaseSeqObj();
+ var a = new eina.Inlist<test.Numberwrapper>();
+ a.AppendArray(cmp);
+ var b = t.EinaInlistObjReturnIn(a);
+ NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
+ NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
+ int len = a.Length;
+ for (int i=0; i < len; ++i)
+ {
+ Test.Assert(a[i].raw_handle == b[i].raw_handle);
+ Test.Assert(a[i].raw_handle == cmp[i].raw_handle);
+ }
+ }
+} // < TestEinaInlist
+
+
+class TestEinaHash
+{
+ public static void data_set_int()
+ {
+ var hsh = new eina.Hash<int, int>();
+ Test.Assert(hsh.Count == 0);
+
+ hsh[88] = 888;
+ Test.Assert(hsh[88] == 888);
+ Test.Assert(hsh.Count == 1);
+
+ hsh[44] = 444;
+ Test.Assert(hsh[44] == 444);
+ Test.Assert(hsh.Count == 2);
+
+ hsh[22] = 222;
+ Test.Assert(hsh[22] == 222);
+ Test.Assert(hsh.Count == 3);
+
+ hsh.Dispose();
+ }
+
+ public static void data_set_str()
+ {
+ var hsh = new eina.Hash<string, string>();
+ Test.Assert(hsh.Count == 0);
+
+ hsh["aa"] = "aaa";
+ Test.Assert(hsh["aa"] == "aaa");
+ Test.Assert(hsh.Count == 1);
+
+ hsh["bb"] = "bbb";
+ Test.Assert(hsh["bb"] == "bbb");
+ Test.Assert(hsh.Count == 2);
+
+ hsh["cc"] = "ccc";
+ Test.Assert(hsh["cc"] == "ccc");
+ Test.Assert(hsh.Count == 3);
+
+ hsh.Dispose();
+ }
+
+ public static void data_set_obj()
+ {
+ var hsh = new eina.Hash<test.Numberwrapper, test.Numberwrapper>();
+ Test.Assert(hsh.Count == 0);
+
+ var a = NW(22);
+ var aa = NW(222);
+ var b = NW(44);
+ var bb = NW(444);
+ var c = NW(88);
+ var cc = NW(888);
+
+ hsh[a] = aa;
+ Test.Assert(hsh[a].raw_handle == aa.raw_handle);
+ Test.Assert(hsh[a].GetNumber() == aa.GetNumber());
+ Test.Assert(hsh.Count == 1);
+
+ hsh[b] = bb;
+ Test.Assert(hsh[b].raw_handle == bb.raw_handle);
+ Test.Assert(hsh[b].GetNumber() == bb.GetNumber());
+ Test.Assert(hsh.Count == 2);
+
+ hsh[c] = cc;
+ Test.Assert(hsh[c].raw_handle == cc.raw_handle);
+ Test.Assert(hsh[c].GetNumber() == cc.GetNumber());
+
+ Test.Assert(hsh.Count == 3);
+
+ hsh.Dispose();
+ }
+
+ public static void eina_hash_as_ienumerable_int()
+ {
+ var hsh = new eina.Hash<int, int>();
+ var dct = new Dictionary<int, int>();
+
+ hsh[88] = 888;
+ hsh[44] = 444;
+ hsh[22] = 222;
+
+ dct[88] = 888;
+ dct[44] = 444;
+ dct[22] = 222;
+
+ int count = 0;
+
+ foreach (KeyValuePair<int, int> kvp in hsh)
+ {
+ Test.Assert(dct[kvp.Key] == kvp.Value);
+ dct.Remove(kvp.Key);
+ ++count;
+ }
+
+ Test.AssertEquals(count, 3);
+ Test.AssertEquals(dct.Count, 0);
+
+ hsh.Dispose();
+ }
+
+ public static void eina_hash_as_ienumerable_str()
+ {
+ var hsh = new eina.Hash<string, string>();
+ var dct = new Dictionary<string, string>();
+
+ hsh["aa"] = "aaa";
+ hsh["bb"] = "bbb";
+ hsh["cc"] = "ccc";
+
+ dct["aa"] = "aaa";
+ dct["bb"] = "bbb";
+ dct["cc"] = "ccc";
+
+ int count = 0;
+
+ foreach (KeyValuePair<string, string> kvp in hsh)
+ {
+ Test.Assert(dct[kvp.Key] == kvp.Value);
+ dct.Remove(kvp.Key);
+ ++count;
+ }
+
+ Test.AssertEquals(count, 3);
+ Test.AssertEquals(dct.Count, 0);
+
+ hsh.Dispose();
+ }
+
+ public static void eina_hash_as_ienumerable_obj()
+ {
+ var hsh = new eina.Hash<test.Numberwrapper, test.Numberwrapper>();
+ var dct = new Dictionary<int, test.Numberwrapper>();
+
+ var a = NW(22);
+ var aa = NW(222);
+ var b = NW(44);
+ var bb = NW(444);
+ var c = NW(88);
+ var cc = NW(888);
+
+ hsh[a] = aa;
+ hsh[b] = bb;
+ hsh[c] = cc;
+
+ dct[a.GetNumber()] = aa;
+ dct[b.GetNumber()] = bb;
+ dct[c.GetNumber()] = cc;
+
+ int count = 0;
+
+ foreach (KeyValuePair<test.Numberwrapper, test.Numberwrapper> kvp in hsh)
+ {
+ Test.Assert(dct[kvp.Key.GetNumber()].raw_handle == kvp.Value.raw_handle);
+ Test.Assert(dct[kvp.Key.GetNumber()].GetNumber() == kvp.Value.GetNumber());
+ dct.Remove(kvp.Key.GetNumber());
+ ++count;
+ }
+
+ Test.AssertEquals(count, 3);
+ Test.AssertEquals(dct.Count, 0);
+
+ hsh.Dispose();
+ }
+
+ // //
+ // Code Generation
+ //
+
+ // Integer //
+
+ public static void test_eina_hash_int_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = new eina.Hash<int,int>();
+ hsh[22] = 222;
+ Test.Assert(t.EinaHashIntIn(hsh));
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh[22] == 222);
+ Test.Assert(hsh[44] == 444);
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_hash_int_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = new eina.Hash<int,int>();
+ hsh[22] = 222;
+ Test.Assert(t.EinaHashIntInOwn(hsh));
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh[22] == 222);
+ Test.Assert(hsh[44] == 444);
+ hsh[88] = 888;
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashIntInOwn());
+ }
+
+ public static void test_eina_hash_int_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Hash<int,int> hsh;
+ Test.Assert(t.EinaHashIntOut(out hsh));
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh[22] == 222);
+ hsh[44] = 444;
+ Test.Assert(hsh[44] == 444);
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashIntOut());
+ }
+
+ public static void test_eina_hash_int_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Hash<int,int> hsh;
+ Test.Assert(t.EinaHashIntOutOwn(out hsh));
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh[22] == 222);
+ hsh[44] = 444;
+ Test.Assert(hsh[44] == 444);
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashIntOutOwn());
+ }
+
+ public static void test_eina_hash_int_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = t.EinaHashIntReturn();
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh[22] == 222);
+ hsh[44] = 444;
+ Test.Assert(hsh[44] == 444);
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashIntReturn());
+ }
+
+ public static void test_eina_hash_int_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = t.EinaHashIntReturnOwn();
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh[22] == 222);
+ hsh[44] = 444;
+ Test.Assert(hsh[44] == 444);
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashIntReturnOwn());
+ }
+
+ // String //
+
+ public static void test_eina_hash_str_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = new eina.Hash<string,string>();
+ hsh["aa"] = "aaa";
+ Test.Assert(t.EinaHashStrIn(hsh));
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh["aa"] == "aaa");
+ Test.Assert(hsh["bb"] == "bbb");
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_hash_str_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = new eina.Hash<string,string>();
+ hsh["aa"] = "aaa";
+ Test.Assert(t.EinaHashStrInOwn(hsh));
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh["aa"] == "aaa");
+ Test.Assert(hsh["bb"] == "bbb");
+ hsh["cc"] = "ccc";
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashStrInOwn());
+ }
+
+ public static void test_eina_hash_str_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Hash<string,string> hsh;
+ Test.Assert(t.EinaHashStrOut(out hsh));
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh["aa"] == "aaa");
+ hsh["bb"] = "bbb";
+ Test.Assert(hsh["bb"] == "bbb");
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashStrOut());
+ }
+
+ public static void test_eina_hash_str_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Hash<string,string> hsh;
+ Test.Assert(t.EinaHashStrOutOwn(out hsh));
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh["aa"] == "aaa");
+ hsh["bb"] = "bbb";
+ Test.Assert(hsh["bb"] == "bbb");
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashStrOutOwn());
+ }
+
+ public static void test_eina_hash_str_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = t.EinaHashStrReturn();
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh["aa"] == "aaa");
+ hsh["bb"] = "bbb";
+ Test.Assert(hsh["bb"] == "bbb");
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashStrReturn());
+ }
+
+ public static void test_eina_hash_str_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = t.EinaHashStrReturnOwn();
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh["aa"] == "aaa");
+ hsh["bb"] = "bbb";
+ Test.Assert(hsh["bb"] == "bbb");
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashStrReturnOwn());
+ }
+
+ // Object //
+
+ public static void test_eina_hash_obj_in()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = new eina.Hash<test.Numberwrapper,test.Numberwrapper>();
+ var nwk1 = NW(22);
+ var nwv1 = NW(222);
+ hsh[nwk1] = nwv1;
+ test.Numberwrapper nwk2;
+ test.Numberwrapper nwv2;
+ Test.Assert(t.EinaHashObjIn(hsh, nwk1, nwv1, out nwk2, out nwv2));
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
+ Test.Assert(hsh[nwk1].GetNumber() == 222);
+ Test.Assert(hsh[nwk2].raw_handle == nwv2.raw_handle);
+ Test.Assert(hsh[nwk2].GetNumber() == nwv2.GetNumber());
+ Test.Assert(hsh[nwk2].GetNumber() == 444);
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ }
+
+ public static void test_eina_hash_obj_in_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ var hsh = new eina.Hash<test.Numberwrapper,test.Numberwrapper>();
+ var nwk1 = NW(22);
+ var nwv1 = NW(222);
+ hsh[nwk1] = nwv1;
+ test.Numberwrapper nwk2;
+ test.Numberwrapper nwv2;
+ Test.Assert(t.EinaHashObjInOwn(hsh, nwk1, nwv1, out nwk2, out nwv2));
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
+ Test.Assert(hsh[nwk1].GetNumber() == 222);
+ Test.Assert(hsh[nwk2].raw_handle == nwv2.raw_handle);
+ Test.Assert(hsh[nwk2].GetNumber() == nwv2.GetNumber());
+ Test.Assert(hsh[nwk2].GetNumber() == 444);
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashObjInOwn(nwk1, nwv1, nwk2, nwv2));
+ }
+
+ public static void test_eina_hash_obj_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Hash<test.Numberwrapper,test.Numberwrapper> hsh;
+ test.Numberwrapper nwk1;
+ test.Numberwrapper nwv1;
+ Test.Assert(t.EinaHashObjOut(out hsh, out nwk1, out nwv1));
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
+ Test.Assert(hsh[nwk1].GetNumber() == 222);
+ test.Numberwrapper nwk2 = NW(44);
+ test.Numberwrapper nwv2 = NW(444);
+ hsh[nwk2] = nwv2;
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashObjOut(nwk1, nwv1, nwk2, nwv2));
+ }
+
+ public static void test_eina_hash_obj_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Hash<test.Numberwrapper,test.Numberwrapper> hsh;
+ test.Numberwrapper nwk1;
+ test.Numberwrapper nwv1;
+ Test.Assert(t.EinaHashObjOutOwn(out hsh, out nwk1, out nwv1));
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
+ Test.Assert(hsh[nwk1].GetNumber() == 222);
+ test.Numberwrapper nwk2 = NW(44);
+ test.Numberwrapper nwv2 = NW(444);
+ hsh[nwk2] = nwv2;
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashObjOutOwn());
+ }
+
+ public static void test_eina_hash_obj_return()
+ {
+ test.Testing t = new test.TestingConcrete();
+ test.Numberwrapper nwk1;
+ test.Numberwrapper nwv1;
+ var hsh = t.EinaHashObjReturn(out nwk1, out nwv1);
+ Test.Assert(!hsh.Own);
+ Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
+ Test.Assert(hsh[nwk1].GetNumber() == 222);
+ test.Numberwrapper nwk2 = NW(44);
+ test.Numberwrapper nwv2 = NW(444);
+ hsh[nwk2] = nwv2;
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashObjReturn(nwk1, nwv1, nwk2, nwv2));
+ }
+
+ public static void test_eina_hash_obj_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ test.Numberwrapper nwk1;
+ test.Numberwrapper nwv1;
+ var hsh = t.EinaHashObjReturnOwn(out nwk1, out nwv1);
+ Test.Assert(hsh.Own);
+ Test.Assert(hsh[nwk1].raw_handle == nwv1.raw_handle);
+ Test.Assert(hsh[nwk1].GetNumber() == nwv1.GetNumber());
+ Test.Assert(hsh[nwk1].GetNumber() == 222);
+ test.Numberwrapper nwk2 = NW(44);
+ test.Numberwrapper nwv2 = NW(444);
+ hsh[nwk2] = nwv2;
+ hsh.Dispose();
+ Test.Assert(hsh.Handle == IntPtr.Zero);
+ Test.Assert(t.CheckEinaHashObjReturnOwn());
+ }
+}
+
+
+class TestEinaIterator
+{
+ // Array //
+
+ public static void eina_array_int_empty_iterator()
+ {
+ var arr = new eina.Array<int>();
+ var itr = arr.GetIterator();
+ int idx = 0;
+ foreach (int e in itr)
+ {
+ ++idx;
+ }
+ Test.AssertEquals(idx, 0);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ public static void eina_array_int_filled_iterator()
+ {
+ var arr = new eina.Array<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);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ public static void eina_array_str_empty_iterator()
+ {
+ var arr = new eina.Array<string>();
+ var itr = arr.GetIterator();
+ int idx = 0;
+ foreach (string e in itr)
+ {
+ ++idx;
+ }
+ Test.AssertEquals(idx, 0);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ public static void eina_array_str_filled_iterator()
+ {
+ var arr = new eina.Array<string>();
+ arr.Append(base_seq_str);
+ var itr = arr.GetIterator();
+ int idx = 0;
+ foreach (string e in itr)
+ {
+ Test.Assert(e == base_seq_str[idx]);
+ ++idx;
+ }
+ Test.AssertEquals(idx, base_seq_str.Length);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ public static void eina_array_obj_empty_iterator()
+ {
+ var arr = new eina.Array<test.Numberwrapper>();
+ var itr = arr.GetIterator();
+ int idx = 0;
+ foreach (test.Numberwrapper e in itr)
+ {
+ ++idx;
+ }
+ Test.AssertEquals(idx, 0);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ public static void eina_array_obj_filled_iterator()
+ {
+ var arr = new eina.Array<test.Numberwrapper>();
+ var base_objs = BaseSeqObj();
+ arr.Append(base_objs);
+ var itr = arr.GetIterator();
+ int idx = 0;
+ foreach (test.Numberwrapper e in itr)
+ {
+ Test.Assert(e.raw_handle == base_objs[idx].raw_handle);
+ Test.Assert(e.GetNumber() == base_objs[idx].GetNumber());
+ ++idx;
+ }
+ Test.AssertEquals(idx, base_objs.Length);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ // Inarray
+
+ public static void eina_inarray_int_empty_iterator()
+ {
+ var arr = new eina.Inarray<int>();
+ var itr = arr.GetIterator();
+ int idx = 0;
+ foreach (int e in itr)
+ {
+ ++idx;
+ }
+ Test.AssertEquals(idx, 0);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ public static void eina_inarray_int_filled_iterator()
+ {
+ 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);
+
+ itr.Dispose();
+ arr.Dispose();
+ }
+
+ // 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);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ 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.GetNumber() == base_objs[idx].GetNumber());
+ ++idx;
+ }
+ Test.AssertEquals(idx, base_objs.Length);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ // 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);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ lst.Dispose();
+ }
+
+ // Hash //
+
+ public static void eina_hash_keys_int_empty_iterator()
+ {
+ var hsh = new eina.Hash<int, int>();
+ var itr = hsh.Keys();
+ bool entered = false;
+ foreach (int e in itr)
+ {
+ entered = true;
+ }
+ Test.Assert(!entered);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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.GetNumber()] = a;
+ dct[b.GetNumber()] = b;
+ dct[c.GetNumber()] = c;
+
+ var itr = hsh.Keys();
+
+ int idx = 0;
+ foreach (test.Numberwrapper e in itr)
+ {
+ Test.Assert(dct[e.GetNumber()] != null);
+ Test.Assert(dct[e.GetNumber()].raw_handle == e.raw_handle);
+ Test.Assert(dct[e.GetNumber()].GetNumber() == e.GetNumber());
+ dct.Remove(e.GetNumber());
+ ++idx;
+ }
+ Test.AssertEquals(dct.Count, 0);
+ Test.AssertEquals(idx, 3);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ 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.GetNumber()] = aa;
+ dct[bb.GetNumber()] = bb;
+ dct[cc.GetNumber()] = cc;
+
+ var itr = hsh.Values();
+
+ int idx = 0;
+ foreach (test.Numberwrapper e in itr)
+ {
+ Test.Assert(dct[e.GetNumber()] != null);
+ Test.Assert(dct[e.GetNumber()].raw_handle == e.raw_handle);
+ Test.Assert(dct[e.GetNumber()].GetNumber() == e.GetNumber());
+ dct.Remove(e.GetNumber());
+ ++idx;
+ }
+ Test.AssertEquals(dct.Count, 0);
+ Test.AssertEquals(idx, 3);
+
+ itr.Dispose();
+ hsh.Dispose();
+ }
+
+ // //
+ // 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.EinaIteratorIntIn(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.EinaIteratorIntInOwn(itr));
+
+ Test.Assert(!itr.Own);
+ Test.Assert(!itr.OwnContent);
+ Test.Assert(arr.Own);
+ Test.Assert(!arr.OwnContent);
+
+ itr.Dispose();
+ arr.Dispose();
+
+ Test.Assert(t.CheckEinaIteratorIntInOwn());
+ }
+
+ public static void test_eina_iterator_int_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Iterator<int> itr;
+
+ Test.Assert(t.EinaIteratorIntOut(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.CheckEinaIteratorIntOut());
+ }
+
+ public static void test_eina_iterator_int_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Iterator<int> itr;
+
+ Test.Assert(t.EinaIteratorIntOutOwn(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.EinaIteratorIntReturn();
+
+ 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.CheckEinaIteratorIntReturn());
+ }
+
+ public static void test_eina_iterator_int_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+
+ var itr = t.EinaIteratorIntReturnOwn();
+
+ 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.EinaIteratorStrIn(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.EinaIteratorStrInOwn(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.CheckEinaIteratorStrInOwn());
+ }
+
+ public static void test_eina_iterator_str_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Iterator<string> itr;
+
+ Test.Assert(t.EinaIteratorStrOut(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.CheckEinaIteratorStrOut());
+ }
+
+ public static void test_eina_iterator_str_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Iterator<string> itr;
+
+ Test.Assert(t.EinaIteratorStrOutOwn(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.EinaIteratorStrReturn();
+
+ 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.CheckEinaIteratorStrReturn());
+ }
+
+ public static void test_eina_iterator_str_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+
+ var itr = t.EinaIteratorStrReturnOwn();
+
+ 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.EinaIteratorObjIn(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.EinaIteratorObjInOwn(itr));
+
+ Test.Assert(!itr.Own);
+ Test.Assert(!itr.OwnContent);
+ Test.Assert(arr.Own);
+ Test.Assert(!arr.OwnContent);
+
+ itr.Dispose();
+ arr.Dispose();
+
+ Test.Assert(t.CheckEinaIteratorObjInOwn());
+ }
+
+ public static void test_eina_iterator_obj_out()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Iterator<test.Numberwrapper> itr;
+
+ Test.Assert(t.EinaIteratorObjOut(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.GetNumber(), base_seq_obj[idx].GetNumber());
+ ++idx;
+ }
+ Test.AssertEquals(idx, base_seq_obj.Length);
+
+ itr.Dispose();
+
+ Test.Assert(t.CheckEinaIteratorObjOut());
+ }
+
+ public static void test_eina_iterator_obj_out_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+ eina.Iterator<test.Numberwrapper> itr;
+
+ Test.Assert(t.EinaIteratorObjOutOwn(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.GetNumber(), base_seq_obj[idx].GetNumber());
+ ++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.EinaIteratorObjReturn();
+
+ 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.GetNumber(), base_seq_obj[idx].GetNumber());
+ ++idx;
+ }
+ Test.AssertEquals(idx, base_seq_obj.Length);
+
+ itr.Dispose();
+
+ Test.Assert(t.CheckEinaIteratorObjReturn());
+ }
+
+ public static void test_eina_iterator_obj_return_own()
+ {
+ test.Testing t = new test.TestingConcrete();
+
+ var itr = t.EinaIteratorObjReturnOwn();
+
+ 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.GetNumber(), base_seq_obj[idx].GetNumber());
+ ++idx;
+ }
+ Test.AssertEquals(idx, base_seq_obj.Length);
+
+ itr.Dispose();
+ }
+} // < TestEinaIterator
+
+}
--- /dev/null
+#if !WIN32
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+
+using static EldbusTestUtil;
+using static Test;
+
+public static class EldbusTestUtil
+{
+ public const string DBusBus = "org.freedesktop.DBus";
+ public const string DBusInterface = "org.freedesktop.DBus";
+ public const string DBusPath = "/org/freedesktop/DBus";
+
+ [return: MarshalAs(UnmanagedType.U1)] public delegate bool Ecore_Task_Cb(IntPtr data);
+
+ public static Ecore_Task_Cb GetEcoreLoopClose()
+ {
+ if (_ecore_loop_close == null)
+ _ecore_loop_close = new Ecore_Task_Cb(_ecore_loop_close_impl);
+ return _ecore_loop_close;
+ }
+
+ [DllImport(efl.Libs.Ecore)] public static extern IntPtr
+ ecore_timer_add(double _in, Ecore_Task_Cb func, IntPtr data);
+ [DllImport(efl.Libs.Ecore)] public static extern IntPtr
+ ecore_timer_del(IntPtr timer);
+
+ [DllImport(efl.Libs.Ecore)] public static extern void
+ ecore_main_loop_begin();
+ [DllImport(efl.Libs.Ecore)] public static extern void
+ ecore_main_loop_quit();
+
+
+ static private bool _ecore_loop_close_impl(IntPtr data)
+ {
+ ecore_main_loop_quit();
+ return false;
+ }
+ static private Ecore_Task_Cb _ecore_loop_close = null;
+}
+
+namespace TestSuite
+{
+
+class TestEldbusConnection
+{
+ public static void eldbus_connection_new_session()
+ {
+ var conn = new eldbus.Connection(eldbus.Connection.Type.Session);
+ conn.Dispose();
+ }
+
+ public static void eldbus_connection_new_system()
+ {
+ var conn = new eldbus.Connection(eldbus.Connection.Type.System);
+ conn.Dispose();
+ }
+
+ public static void eldbus_connection_new_starter()
+ {
+ var conn = new eldbus.Connection(eldbus.Connection.Type.Starter);
+ conn.Dispose();
+ }
+
+ public static void eldbus_connection_new_private_session()
+ {
+ var conn = eldbus.Connection.GetPrivate(eldbus.Connection.Type.Session);
+ conn.Dispose();
+ }
+
+ public static void eldbus_connection_new_private_system()
+ {
+ var conn = eldbus.Connection.GetPrivate(eldbus.Connection.Type.System);
+ conn.Dispose();
+ }
+
+ public static void eldbus_connection_new_private_starter()
+ {
+ var conn = eldbus.Connection.GetPrivate(eldbus.Connection.Type.Starter);
+ conn.Dispose();
+ }
+
+ public static void eldbus_connection_get_unique_name()
+ {
+ var conn = new eldbus.Connection(eldbus.Connection.Type.Session);
+ Console.WriteLine(conn.GetUniqueName());
+ conn.Dispose();
+ }
+}
+
+class TestEldbusObject
+{
+ public static void utc_eldbus_object_send_info_get_p()
+ {
+ var conn = new eldbus.Connection(eldbus.Connection.Type.System);
+
+ var obj = new eldbus.Object(conn, DBusBus, DBusPath);
+
+ string busFromObject = obj.GetBusName();
+
+ AssertEquals(DBusBus, busFromObject);
+
+ string pathFromObject = obj.GetPath();
+
+ AssertEquals(DBusPath, pathFromObject);
+
+ obj.Ref();
+ obj.Unref();
+
+ {
+ var connectionFromObj = obj.GetConnection();
+ Assert(conn.Handle == connectionFromObj.Handle);
+ connectionFromObj.Dispose();
+ }
+
+ IntPtr timeout = IntPtr.Zero;
+ int messageCapture = 0;
+ bool isSuccess = false;
+
+ eldbus.MessageDelegate objectMessageCb = delegate(eldbus.Message msg, eldbus.Pending p)
+ {
+ try
+ {
+ if (timeout != IntPtr.Zero)
+ {
+ ecore_timer_del(timeout);
+ timeout = IntPtr.Zero;
+ }
+
+ string errname;
+ string errmsg;
+
+ if (messageCapture == 5)
+ {
+ if (!msg.GetError(out errname, out errmsg))
+ {
+ string txt;
+ if (msg.Get(out txt))
+ {
+ if (!String.IsNullOrEmpty(txt))
+ isSuccess = true;
+ }
+ }
+ }
+ }
+ finally
+ {
+ ecore_main_loop_quit();
+ }
+ };
+
+ var methodName = "GetId";
+ var message = obj.NewMethodCall(DBusInterface, methodName);
+
+ eldbus.Pending pending = obj.Send(message, objectMessageCb, -1);
+
+ timeout = ecore_timer_add(2.0, GetEcoreLoopClose(), IntPtr.Zero);
+ Assert(timeout != IntPtr.Zero);
+
+ messageCapture = 5;
+
+ ecore_main_loop_begin();
+
+ Assert(isSuccess, $"Method {methodName} is not call");
+
+ message.Dispose();
+ obj.Dispose();
+ conn.Dispose();
+ }
+
+ public static void utc_eldbus_introspect_p()
+ {
+ var conn = new eldbus.Connection(eldbus.Connection.Type.System);
+
+ var obj = new eldbus.Object(conn, DBusBus, DBusPath);
+
+ IntPtr timeout = IntPtr.Zero;
+ int messageCapture = 0;
+ bool isSuccess = false;
+
+ eldbus.MessageDelegate objectMessageCb = delegate(eldbus.Message msg, eldbus.Pending p)
+ {
+ try
+ {
+ if (timeout != IntPtr.Zero)
+ {
+ ecore_timer_del(timeout);
+ timeout = IntPtr.Zero;
+ }
+
+ string errname;
+ string errmsg;
+
+ if (messageCapture == 5)
+ {
+ if (!msg.GetError(out errname, out errmsg))
+ {
+ string txt;
+ if (msg.Get(out txt))
+ {
+ if (!String.IsNullOrEmpty(txt))
+ isSuccess = true;
+ }
+ }
+ }
+ }
+ finally
+ {
+ ecore_main_loop_quit();
+ }
+ };
+
+ eldbus.Pending pending = obj.Introspect(objectMessageCb);
+
+ timeout = ecore_timer_add(2.0, GetEcoreLoopClose(), IntPtr.Zero);
+ Assert(timeout != IntPtr.Zero);
+
+ messageCapture = 5;
+
+ ecore_main_loop_begin();
+
+ Assert(isSuccess, "Method Introspect is not call");
+
+ obj.Dispose();
+ conn.Dispose();
+ }
+}
+
+class TestEldbusMessage
+{
+ private static IntPtr timeout = IntPtr.Zero;
+ private static bool isSuccess = false;
+
+
+ private static void ActivableList(eldbus.MessageDelegate messageCb)
+ {
+ isSuccess = false;
+
+ var conn = new eldbus.Connection(eldbus.Connection.Type.System);
+
+ eldbus.Pending pending = conn.ActivableList(messageCb);
+
+ timeout = ecore_timer_add(2.0, GetEcoreLoopClose(), IntPtr.Zero);
+ Assert(timeout != IntPtr.Zero);
+
+ ecore_main_loop_begin();
+
+ Assert(isSuccess, "Method ListActivatableNames is not call");
+
+ conn.Dispose();
+ }
+
+ public static void utc_eldbus_message_iterator_activatable_list_p()
+ {
+ eldbus.MessageDelegate responseMessageCb = delegate(eldbus.Message msg, eldbus.Pending p)
+ {
+ try
+ {
+ if (timeout != IntPtr.Zero)
+ {
+ ecore_timer_del(timeout);
+ timeout = IntPtr.Zero;
+ }
+
+ string errname, errmsg;
+ if (msg.GetError(out errname, out errmsg))
+ {
+ return;
+ }
+
+ eldbus.MessageIterator iterMain = msg.GetMessageIterator();
+
+ string signature = iterMain.GetSignature();
+ if (String.IsNullOrEmpty(signature))
+ {
+ return;
+ }
+
+ eldbus.MessageIterator iterator;
+ iterMain.Get(out iterator, signature);
+
+ string bus_name;
+ bool isHasData = false;
+
+ while(iterator.GetAndNext(out bus_name))
+ {
+ if (String.IsNullOrEmpty(bus_name))
+ {
+ return;
+ }
+ isHasData = true;
+ }
+
+ isSuccess = isHasData;
+ }
+ finally
+ {
+ ecore_main_loop_quit();
+ }
+ };
+
+ ActivableList(responseMessageCb);
+ }
+
+ public static void utc_eldbus_message_info_data_get_p()
+ {
+ isSuccess = false;
+
+ var conn = new eldbus.Connection(eldbus.Connection.Type.System);
+
+ string methodName = "GetId";
+ eldbus.Message msg = eldbus.Message.NewMethodCall(DBusBus, DBusPath, DBusInterface, methodName);
+
+ string interfaceMsg = msg.GetInterface();
+ AssertEquals(DBusInterface, interfaceMsg);
+
+ string methodMsg = msg.GetMember();
+ AssertEquals(methodName, methodMsg);
+
+ string pathMsg = msg.GetPath();
+ AssertEquals(DBusPath, pathMsg);
+
+ eldbus.MessageDelegate messageMethodCb = delegate(eldbus.Message m, eldbus.Pending p)
+ {
+ try
+ {
+ if (timeout != IntPtr.Zero)
+ {
+ ecore_timer_del(timeout);
+ timeout = IntPtr.Zero;
+ }
+
+ string errname, errmsg;
+ if (!m.GetError(out errname, out errmsg))
+ {
+ string txt;
+ if (m.Get(out txt))
+ {
+ if (!String.IsNullOrEmpty(txt))
+ {
+ if (m.GetSender() == DBusBus &&
+ !String.IsNullOrEmpty(m.GetDestination()))
+ {
+ isSuccess = true;
+ }
+ }
+ }
+ }
+ }
+ finally
+ {
+ ecore_main_loop_quit();
+ }
+ };
+
+ const int timeoutSendMs = 1000;
+ eldbus.Pending pending = conn.Send(msg, messageMethodCb, timeoutSendMs);
+
+ timeout = ecore_timer_add(2.0, GetEcoreLoopClose(), IntPtr.Zero);
+ Assert(timeout != IntPtr.Zero);
+
+ ecore_main_loop_begin();
+
+ Assert(isSuccess, $"Method {methodName} is not call");
+
+ msg.Dispose();
+ conn.Dispose();
+ }
+
+ public static void utc_eldbus_message_ref_unref_p()
+ {
+ var conn = new eldbus.Connection(eldbus.Connection.Type.System);
+
+ eldbus.Message msg = eldbus.Message.NewMethodCall(DBusBus, DBusPath, DBusInterface, "GetId");
+
+ msg.Ref();
+ msg.Unref();
+
+ string pathMsg = msg.GetPath();
+ AssertEquals(DBusPath, pathMsg);
+
+ msg.Unref();
+ msg.Own = false;
+
+ msg.Dispose();
+ conn.Dispose();
+ }
+
+ public static void utc_eldbus_message_iter_next_p()
+ {
+ eldbus.MessageDelegate activatableListResponseCb = delegate(eldbus.Message msg, eldbus.Pending p)
+ {
+ try
+ {
+ if (timeout != IntPtr.Zero)
+ {
+ ecore_timer_del(timeout);
+ timeout = IntPtr.Zero;
+ }
+
+ string errname, errmsg;
+ if (msg.GetError(out errname, out errmsg))
+ {
+ return;
+ }
+
+ eldbus.MessageIterator iterMain = msg.GetMessageIterator();
+
+ string signature = iterMain.GetSignature();
+ if (String.IsNullOrEmpty(signature))
+ {
+ return;
+ }
+
+ eldbus.MessageIterator iterator;
+ iterMain.Get(out iterator, signature);
+
+ bool isHasData = false;
+ do
+ {
+ string busName;
+ iterator.Get(out busName);
+ if (String.IsNullOrEmpty(busName))
+ {
+ return;
+ }
+ isHasData = true;
+ } while (iterator.Next());
+
+ isSuccess = isHasData;
+ }
+ finally
+ {
+ ecore_main_loop_quit();
+ }
+ };
+ ActivableList(activatableListResponseCb);
+ }
+}
+
+}
+
+#endif
--- /dev/null
+using System;
+
+namespace TestSuite
+{
+
+class TestEo
+{
+ private class Derived : test.TestingInherit
+ {
+ }
+
+ //
+ // Test cases:
+ //
+ public static void return_same_object()
+ {
+ test.Testing testing = new test.TestingConcrete();
+ test.Testing o1 = testing.ReturnObject();
+ Test.Assert(o1.raw_handle != IntPtr.Zero);
+ Test.Assert(o1.raw_handle == testing.raw_handle);
+ test.Testing o2 = o1.ReturnObject();
+ Test.Assert(o2.raw_handle != IntPtr.Zero);
+ Test.Assert(o2.raw_handle == o1.raw_handle);
+ }
+
+ /* Commented out as adding the event listener seems to prevent it from being GC'd.
+ public static void destructor_really_frees()
+ {
+ bool delEventCalled = false;
+ {
+ test.Testing obj = new test.TestingConcrete();
+ obj.DEL += (object sender, EventArgs e) => { delEventCalled = true; };
+ }
+
+ System.GC.WaitForPendingFinalizers();
+ System.GC.Collect();
+ System.GC.WaitForPendingFinalizers();
+ System.GC.Collect();
+ System.GC.WaitForPendingFinalizers();
+
+ Test.Assert(delEventCalled, "DEL event not called");
+ } */
+
+ public static void dispose_really_frees()
+ {
+ bool delEventCalled = false;
+ {
+ test.Testing obj = new test.TestingConcrete();
+ obj.DEL += (object sender, EventArgs e) => { delEventCalled = true; };
+ ((IDisposable)obj).Dispose();
+ }
+
+ Test.Assert(delEventCalled, "DEL event not called");
+ }
+
+ /* Commented out as adding the event listener seems to prevent it from being GC'd.
+ public static void derived_destructor_really_frees()
+ {
+ bool delEventCalled = false;
+ {
+ test.Testing obj = new Derived();
+ obj.DEL += (object sender, EventArgs e) => { delEventCalled = true; };
+ }
+
+ System.GC.WaitForPendingFinalizers();
+ System.GC.Collect();
+ System.GC.WaitForPendingFinalizers();
+ System.GC.Collect();
+ System.GC.WaitForPendingFinalizers();
+
+ Test.Assert(delEventCalled, "DEL event not called");
+ }
+
+ public static void derived_dispose_really_frees()
+ {
+ bool delEventCalled = false;
+ {
+ test.Testing obj = new Derived();
+ obj.DEL += (object sender, EventArgs e) => { delEventCalled = true; };
+ ((IDisposable)obj).Dispose();
+ }
+
+ Test.Assert(delEventCalled, "DEL event not called");
+ }
+ */
+}
+
+class MyLoop : efl.LoopInherit
+{
+ public MyLoop() : base(null) { }
+}
+
+class TestEoInherit
+{
+ public static void instantiate_inherited()
+ {
+ efl.Loop loop = new MyLoop();
+ Test.Assert(loop.raw_handle != System.IntPtr.Zero);
+ }
+}
+
+class TestEoNames
+{
+ public static void name_getset()
+ {
+ test.Testing obj = new test.TestingConcrete();
+
+ string name = "Dummy";
+ obj.SetName(name);
+ Test.AssertEquals(name, obj.GetName());
+ }
+}
+
+class TestEoConstructingMethods
+{
+ public static void constructing_method()
+ {
+ bool called = false;
+ string name = "Test object";
+ test.Testing obj = new test.TestingConcrete(null, (test.Testing a) => {
+ called = true;
+ Console.WriteLine("callback: obj raw_handle: {0:x}", a.raw_handle);
+ a.SetName(name);
+ });
+
+ Test.Assert(called);
+ Test.AssertEquals(name, obj.GetName());
+ }
+
+ private class Derived : test.TestingInherit
+ {
+ public Derived(test.Testing parent = null,
+ test.TestingInherit.ConstructingMethod cb = null) : base(parent, cb) {
+ }
+ }
+
+ public static void constructing_method_inherit()
+ {
+ bool called = false;
+ string name = "Another test object";
+ Derived obj = new Derived(null, (test.Testing a) => {
+ called = true;
+ a.SetComment(name);
+ });
+
+ Test.Assert(called);
+ Test.AssertEquals(name, obj.GetComment());
+ }
+}
+
+class TestEoParent
+{
+ public static void basic_parent()
+ {
+ test.Testing parent = new test.TestingConcrete(null);
+ test.Testing child = new test.TestingConcrete(parent);
+
+ Test.AssertEquals(parent, child.GetParent());
+
+ test.Testing parent_retrieved = test.TestingConcrete.static_cast(child.GetParent());
+ Test.AssertEquals(parent, parent_retrieved);
+ }
+
+ public static void parent_inherited_class()
+ {
+ test.Numberwrapper parent = new test.NumberwrapperConcrete(null);
+ test.Testing child = new test.TestingConcrete(parent);
+
+ Test.AssertEquals(parent, child.GetParent());
+
+ test.Numberwrapper parent_retrieved = test.NumberwrapperConcrete.static_cast(child.GetParent());
+ Test.AssertEquals(parent, parent_retrieved);
+ }
+
+ private class Derived : test.TestingInherit
+ {
+ public Derived(test.Testing parent = null) : base (parent)
+ {
+ }
+ }
+
+ public static void basic_parent_managed_inherit()
+ {
+ test.Testing parent = new Derived(null);
+ test.Testing child = new Derived(parent);
+
+ Test.AssertEquals(parent, child.GetParent());
+
+ test.Testing parent_from_cast = test.TestingInherit.static_cast(child.GetParent());
+ Test.AssertEquals(parent, parent_from_cast);
+ }
+}
+
+}
--- /dev/null
+using System;
+
+namespace TestSuite
+{
+
+class TestEinaError
+{
+ public static void basic_test()
+ {
+ eina.Error.Clear();
+ Test.AssertNotRaises<efl.EflException>(eina.Error.RaiseIfOccurred);
+ eina.Error.Set(eina.Error.ENOENT);
+ Test.AssertRaises<efl.EflException>(eina.Error.RaiseIfOccurred);
+ }
+}
+
+class TestEolianError
+{
+
+ public static void global_eina_error()
+ {
+ test.Testing obj = new test.TestingConcrete();
+ Test.AssertRaises<efl.EflException>(() => obj.RaisesEinaError());
+ }
+
+ class Child : test.TestingInherit {
+ }
+
+ public static void global_eina_error_inherited()
+ {
+ test.Testing obj = new Child();
+ Test.AssertRaises<efl.EflException>(() => obj.RaisesEinaError());
+ }
+
+ class CustomException : Exception {
+ public CustomException(string msg): base(msg) {}
+ }
+
+ class Overrider : test.TestingInherit {
+ public override void ChildrenRaiseError() {
+ throw (new CustomException("Children error"));
+ }
+ }
+
+ public static void exception_raised_from_inherited_virtual()
+ {
+ test.Testing obj = new Overrider();
+
+ Test.AssertRaises<efl.EflException>(obj.CallChildrenRaiseError);
+ }
+
+ // return eina_error
+ public static void eina_error_return()
+ {
+ test.Testing obj = new test.TestingConcrete();
+ eina.Error expected = 42;
+ obj.SetErrorRet(expected);
+ eina.Error error = obj.ReturnsError();
+
+ Test.AssertEquals(expected, error);
+
+ expected = 0;
+ obj.SetErrorRet(expected);
+ error = obj.ReturnsError();
+
+ Test.AssertEquals(expected, error);
+ }
+
+ class ReturnOverride : test.TestingInherit {
+ eina.Error code;
+ public override void SetErrorRet(eina.Error err) {
+ code = 2 * err;
+ }
+ public override eina.Error ReturnsError()
+ {
+ return code;
+ }
+ }
+
+ public static void eina_error_return_from_inherited_virtual()
+ {
+ test.Testing obj = new ReturnOverride();
+ eina.Error expected = 42;
+ obj.SetErrorRet(expected);
+ eina.Error error = obj.ReturnsError();
+
+ Test.AssertEquals(new eina.Error(expected * 2), error);
+
+ expected = 0;
+ obj.SetErrorRet(expected);
+ error = obj.ReturnsError();
+
+ Test.AssertEquals(new eina.Error(expected * 2), error);
+ }
+
+ // events
+ class Listener
+ {
+ public bool called = false;
+ public void callback(object sender, EventArgs e) {
+ throw (new CustomException("Event exception"));
+ }
+ public void another_callback(object sender, EventArgs e) {}
+ }
+
+ public static void eina_error_event_raise_exception()
+ {
+ // An event whose managed delegate generates an exception
+ // must set an eina_error so it can be reported back to
+ // the managed code
+ efl.Loop loop = new efl.LoopConcrete();
+ Listener listener = new Listener();
+ loop.CALLBACK_ADD += listener.callback;
+
+ Test.AssertRaises<efl.EflException>(() => loop.IDLE += listener.another_callback);
+ }
+}
+}
--- /dev/null
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+
+public class MyBox : evas.BoxInherit
+{
+ public MyBox(efl.Object parent) : base(parent) {}
+
+ [DllImport("evas")] static extern void evas_obj_box_layout_vertical(IntPtr obj, IntPtr data, IntPtr privdata);
+ [DllImport("evas")] static extern void evas_obj_box_layout_horizontal(IntPtr obj, IntPtr data, IntPtr privdata);
+ [DllImport("evas")] static extern void evas_object_box_layout_horizontal(IntPtr obj, IntPtr data, IntPtr privdata);
+ [DllImport("evas")] static extern IntPtr evas_object_evas_get(IntPtr obj);
+ [DllImport("evas")] static extern void evas_event_freeze(IntPtr obj);
+ [DllImport("evas")] static extern void evas_event_thaw(IntPtr obj);
+
+ override public void CalculateGroup()
+ {
+ IntPtr evas = evas_object_evas_get(raw_handle);
+ evas_event_freeze(evas);
+ eina.Log.Debug("called group_calculate");
+ // slayouting_set(true);
+ evas_obj_box_layout_vertical(raw_handle, IntPtr.Zero, IntPtr.Zero);
+ // layouting_set(false);
+ // children_changed_set(false);
+ evas_event_thaw(evas);
+ }
+}
+
+namespace TestSuite
+{
+
+class TestEvas
+{
+ /* private static string ImagePath([CallerFilePath] string folder="") */
+ /* { */
+ /* return System.IO.Path.GetDirectoryName(folder); */
+ /* } */
+
+ /* public static void simple_layout() */
+ /* { */
+/* // efl.Loop loop = new efl.LoopConcrete(); */
+
+ /* EcoreEvas ecore_evas = new EcoreEvas(); */
+
+ /* efl.canvas.Object canvas = ecore_evas.canvas; */
+ /* canvas.visible_set(true); */
+
+ /* efl.Object parent = canvas.parent_get(); */
+ /* Test.Assert(parent.raw_handle != IntPtr.Zero); */
+
+ /* efl.canvas.Rectangle rect = new efl.canvas.RectangleConcrete(canvas); */
+ /* rect.color_set(255, 255, 255, 255); */
+ /* rect.size_set(640, 480); */
+ /* rect.visible_set(true); */
+
+ /* evas.Box box = new MyBox(canvas); */
+ /* rect.size_set(320, 240); */
+ /* box.visible_set(true); */
+
+ /* efl.canvas.Image image1 = new efl.canvas.ImageConcrete(canvas); */
+ /* image1.file_set(ImagePath() + "/../../examples/elementary/sphere_hunter/score.jpg", ""); */
+ /* image1.hint_min_set(160, 240); */
+ /* image1.visible_set(true); */
+
+ /* efl.canvas.Image image2 = new efl.canvas.ImageConcrete(canvas); */
+ /* image2.file_set(ImagePath() + "/../../examples/evas/shooter/assets/images/bricks.jpg", ""); */
+ /* image2.hint_min_set(160, 120); */
+ /* image2.visible_set(true); */
+
+ /* box.append(image1); */
+ /* box.append(image2); */
+
+/* // loop.begin(); */
+ /* } */
+}
+
+}
--- /dev/null
+using System;
+
+namespace TestSuite
+{
+
+class TestEoEvents
+{
+ public bool called = false;
+ protected void callback(object sender, EventArgs e) {
+ called = true;
+ }
+ protected void another_callback(object sender, EventArgs e) { }
+
+ public static void callback_add_event()
+ {
+ efl.Loop loop = new efl.LoopConcrete();
+ TestEoEvents listener = new TestEoEvents();
+ loop.CALLBACK_ADD += listener.callback;
+
+ Test.Assert(!listener.called);
+ loop.IDLE += listener.another_callback;
+ Test.Assert(listener.called);
+ }
+}
+
+}
--- /dev/null
+using System;
+using System.Runtime.InteropServices;
+
+namespace TestSuite
+{
+
+class TestFunctionPointers
+{
+
+ static bool called = false;
+
+ static int twice(int a)
+ {
+ called = true;
+ return a * 2;
+ }
+
+ static int thrice(int a)
+ {
+ called = true;
+ return a * 3;
+ }
+
+ static void setup()
+ {
+ called = false;
+ }
+
+ public static void set_callback_basic()
+ {
+ setup();
+ test.Testing obj = new test.TestingConcrete();
+ obj.SetCallback(twice);
+
+ Test.Assert(called == false, "set_callback should not call the callback");
+
+ int x = obj.CallCallback(42);
+
+ Test.Assert(called, "call_callback must call a callback");
+ Test.AssertEquals(42 * 2, x);
+ }
+
+ public static void set_callback_with_lambda()
+ {
+ setup();
+
+ test.Testing obj = new test.TestingConcrete();
+ obj.SetCallback(y => {
+ called = true;
+ return y + 4;
+ });
+
+ Test.Assert(called == false, "set_callback should not call the callback");
+
+ int x = obj.CallCallback(37);
+
+ Test.Assert(called, "call_callback must call a callback");
+ Test.AssertEquals(37 + 4, x);
+ }
+
+ public static void replace_callback()
+ {
+ setup();
+
+ test.Testing obj = new test.TestingConcrete();
+ obj.SetCallback(twice);
+ Test.Assert(called == false, "set_callback should not call the callback");
+
+ int x = obj.CallCallback(42);
+ Test.Assert(called, "call_callback must call a callback");
+ Test.AssertEquals(42 * 2, x);
+
+ bool new_called = false;
+ obj.SetCallback(y => {
+ new_called = true;
+ return y * y;
+ });
+
+ Test.Assert(new_called == false, "set_callback should not call the callback");
+
+ x = obj.CallCallback(42);
+ Test.Assert(new_called, "call_callback must call a callback");
+ Test.AssertEquals(42 * 42, x);
+ }
+
+ class NoOverride : test.TestingInherit {
+ }
+ public static void set_callback_inherited_no_override()
+ {
+ setup();
+ NoOverride obj = new NoOverride();
+ obj.SetCallback(thrice);
+
+ Test.Assert(!called, "set_callback in virtual should not call the callback");
+
+ int x = obj.CallCallback(42);
+
+ Test.Assert(called, "call_callback must call a callback");
+ Test.AssertEquals(42 * 3, x);
+ }
+
+ class WithOverride : test.TestingInherit {
+ public bool set_called = false;
+ public bool invoke_called = false;
+ public test.SimpleCb cb = null;
+
+ public WithOverride() : base() {
+
+ }
+ public override void SetCallback(test.SimpleCb cb) {
+ set_called = true;
+ this.cb = cb;
+ }
+ public override int CallCallback(int a) {
+ invoke_called = true;
+ if (cb != null)
+ return cb(a);
+ eina.Log.Error("No callback set upon call_callback invocation");
+ return -1;
+ }
+ }
+ public static void set_callback_inherited_with_override()
+ {
+ setup();
+ WithOverride obj = new WithOverride();
+ obj.SetCallback(thrice);
+
+ Test.Assert(obj.set_called, "set_callback override must have been called");
+ Test.Assert(!obj.invoke_called, "invoke_callback must not have been called");
+
+ obj.set_called = false;
+ int x = obj.CallCallback(42);
+
+ Test.Assert(!obj.set_called, "set_callback override must not have been called");
+ Test.Assert(obj.invoke_called, "set_callback in virtual should not call the callback");
+
+ Test.Assert(called, "call_callback must call a callback");
+ Test.AssertEquals(42 * 3, x);
+ }
+
+ // These are needed due to issues calling methods on obj from the GC thread (where the
+ // free function is actually called)
+ [System.Runtime.InteropServices.DllImport("efl_mono_native_test")] static extern bool free_called_get();
+ [System.Runtime.InteropServices.DllImport("efl_mono_native_test")] static extern bool free_called_set(bool val);
+
+ public static void set_callback_inherited_called_from_c()
+ {
+ setup();
+ WithOverride obj = new WithOverride();
+ free_called_set(false);
+ obj.CallSetCallback();
+
+ Test.Assert(obj.set_called, "set_callback override must have been called");
+ Test.Assert(!obj.invoke_called, "invoke_callback must not have been called");
+ Test.Assert(!free_called_get(), "call_set_callback must not call the free callback");
+
+ obj.set_called = false;
+ int x = obj.CallCallback(42);
+
+ Test.Assert(!obj.set_called, "set_callback override must not have been called");
+ Test.Assert(obj.invoke_called, "set_callback in virtual should not call the callback");
+ Test.Assert(!free_called_get(), "call_callback must not call the free callback");
+
+ Test.AssertEquals(42 * 3, x);
+
+ setup();
+ obj.set_called = false;
+ obj.invoke_called = false;
+ free_called_set(false);
+
+ // Should release the handle to the wrapper allocated when calling set_callback from C.
+ obj.SetCallback(twice);
+
+ GC.Collect();
+ GC.WaitForPendingFinalizers();
+
+ Test.Assert(obj.set_called, "set_callback override must have been called");
+ Test.Assert(!obj.invoke_called, "invoke_callback must not have been called");
+ Test.Assert(free_called_get(), "free callback must have been called");
+
+ obj.set_called = false;
+ free_called_set(false);
+ x = obj.CallCallback(42);
+
+ Test.Assert(!obj.set_called, "set_callback override must not have been called");
+ Test.Assert(obj.invoke_called, "set_callback in virtual should not call the callback");
+ Test.Assert(!free_called_get(), "must not call old free_callback on new callback");
+
+ Test.Assert(called, "call_callback must call a callback");
+ Test.AssertEquals(42 * 2, x);
+
+ }
+}
+
+}
+
--- /dev/null
+using System;
+using System.Runtime.InteropServices;
+using System.Runtime.CompilerServices;
+using System.Reflection;
+using System.Linq;
+
+class TestMain
+{
+ static Type[] GetTestCases(String name="")
+ {
+ return Assembly.GetExecutingAssembly().GetTypes().Where(t => String.Equals(t.Namespace, "TestSuite", StringComparison.Ordinal) &&
+ t.Name.StartsWith("Test") &&
+ t.Name.Contains(name)).ToArray();
+ }
+
+ static int Main(string[] args)
+ {
+ efl.All.Init();
+
+ bool pass = true;
+
+ String ckRunSuite = Environment.GetEnvironmentVariable("CK_RUN_SUITE");
+ String ckRunCase = Environment.GetEnvironmentVariable("CK_RUN_CASE");
+
+ if (ckRunSuite != null && !ckRunSuite.Equals("mono"))
+ return 0;
+
+ if (ckRunCase == null)
+ ckRunCase = String.Empty;
+
+ Console.WriteLine("[ START SUITE ] " + ckRunSuite);
+ var cases= GetTestCases(ckRunCase);
+ foreach(var testCase in cases)
+ {
+ var localTestCases = testCase.GetMethods(BindingFlags.Static | BindingFlags.Public);
+
+ var setUp = Array.Find(localTestCases, m => String.Equals(m.Name, "SetUp", StringComparison.Ordinal));
+ var tearDown = Array.Find(localTestCases, m => String.Equals(m.Name, "TearDown", StringComparison.Ordinal));
+
+ foreach(var localTestCase in localTestCases)
+ {
+ if (localTestCase == setUp || localTestCase == tearDown)
+ continue;
+
+ Console.WriteLine("[ RUN ] " + testCase.Name + "." + localTestCase.Name);
+ bool caseResult = true;
+
+ if (setUp != null)
+ {
+ try
+ {
+ setUp.Invoke(null, null);
+ }
+ catch (Exception e)
+ {
+ pass = false;
+ caseResult = false;
+ Console.WriteLine("[ ERROR ] SetUp fail: " + e.InnerException.ToString());
+ }
+ }
+
+ if (caseResult)
+ {
+ try
+ {
+ localTestCase.Invoke(null, null);
+ }
+ catch (Exception e)
+ {
+ pass = false;
+ caseResult = false;
+ Console.WriteLine("[ ERROR ] " + e.InnerException.ToString());
+ }
+ }
+
+ if (caseResult && tearDown != null)
+ {
+ try
+ {
+ tearDown.Invoke(null, null);
+ }
+ catch (Exception e)
+ {
+ pass = false;
+ caseResult = false;
+ Console.WriteLine("[ ERROR ] TearDown failed: " + e.InnerException.ToString());
+ }
+ }
+
+ Console.WriteLine("[ " + (caseResult ? "PASS" : "FAIL") + " ] " + testCase.Name + "." + localTestCase.Name);
+ }
+ }
+ Console.WriteLine("[ END SUITE ] " + ckRunSuite);
+
+ if (!pass)
+ return -1;
+
+ return 0;
+ }
+}
--- /dev/null
+using System;
+
+namespace TestSuite {
+
+class TestStrings
+{
+ /* The managed call is still owner of the sent string */
+ public static void in_string()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ String sent = "in_string";
+ String returned = obj.InString(sent);
+ Test.AssertEquals(sent, returned);
+ }
+ System.GC.Collect();
+ }
+
+ /* The managed call must not keep ownership of the C string after the
+ * call */
+ public static void in_own_string()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ String sent = "in_own_string";
+ String returned = obj.InOwnString(sent);
+ Test.AssertEquals(sent, returned);
+ }
+ System.GC.Collect();
+ }
+
+ /* The managed call must not take ownership of the returned string */
+ public static void return_string()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ Test.AssertEquals("string", obj.ReturnString());
+ }
+ System.GC.Collect();
+ }
+
+ /* The managed call is free to own the returned string */
+ public static void return_own_string()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ Test.AssertEquals("own_string", obj.ReturnOwnString());
+ }
+ System.GC.Collect();
+ }
+
+ /* The managed call is *not* the owner of the string put in the out argument */
+ public static void out_string()
+ {
+ {
+ String str = String.Empty;
+ test.Testing obj = new test.TestingConcrete();
+ obj.OutString(out str);
+ Test.AssertEquals("out_string", str);
+ }
+ System.GC.Collect();
+ }
+
+ /* The managed call is the owner of the string in the out parameter */
+ public static void out_own_string()
+ {
+ {
+ String str = String.Empty;
+ test.Testing obj = new test.TestingConcrete();
+ obj.OutOwnString(out str);
+ Test.AssertEquals(str.ToString(), "out_own_string");
+ }
+ System.GC.Collect();
+ }
+
+ private class StringReturner : test.TestingInherit
+ {
+ public String received_in;
+ public String received_in_own;
+ public StringReturner() : base(null) {
+ received_in = String.Empty;
+ received_in_own = String.Empty;
+ }
+
+ public override String InString(String str)
+ {
+ received_in = str;
+ return String.Empty;
+ }
+
+ public override String InOwnString(String str)
+ {
+ /* Console.WriteLine("Called my own virtual"); */
+ received_in_own = str;
+ return String.Empty;
+ }
+
+ public override String ReturnString()
+ {
+ return "inherited";
+ }
+
+ public override String ReturnOwnString()
+ {
+ return "own_inherited";
+ }
+
+ public override void OutString(out String str)
+ {
+ str = "out_inherited";
+ }
+
+ public override void OutOwnString(out System.String str)
+ {
+ str = "out_own_inherited";
+ }
+ }
+
+ /* The managed wrapper must not take ownership of the in parameter */
+ public static void in_string_from_virtual()
+ {
+ StringReturner obj = new StringReturner();
+ /* for (int i = 0; i < 10000; i++) { */
+ String sent = "in_inherited";
+ obj.CallInString(sent);
+ Test.AssertEquals(sent, obj.received_in);
+ /* } */
+ System.GC.Collect();
+ }
+
+ /* The managed wrapper should take ownership of the in parameter */
+ public static void in_own_string_from_virtual()
+ {
+ StringReturner obj = new StringReturner();
+ /* for (int i = 0; i < 10000; i++) { */
+ String sent = "in_own_inherited";
+ obj.CallInOwnString(sent);
+ Test.AssertEquals(sent, obj.received_in_own);
+ /* } */
+ System.GC.Collect();
+ }
+
+ /* The managed wrapper still owns the returned C string. We need to cache it until
+ * some time in the future */
+ public static void return_string_from_virtual()
+ {
+ test.Testing obj = new StringReturner();
+ /* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
+ Test.AssertEquals("inherited", obj.CallReturnString());
+ System.GC.Collect();
+ }
+
+ /* The managed wrapper must surrender the ownership to the C after the virtual call. */
+ public static void return_own_string_from_virtual()
+ {
+ test.Testing obj = new StringReturner();
+ /* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
+ Test.AssertEquals("own_inherited", obj.CallReturnOwnString());
+ System.GC.Collect();
+ }
+
+ /* The managed wrapper still owns the C string after the call. Like return without own, we may
+ * need to cache it until some time in the future. */
+ public static void out_string_from_virtual()
+ {
+ test.Testing obj = new StringReturner();
+ /* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
+ Test.AssertEquals("out_inherited", obj.CallOutString());
+ System.GC.Collect();
+ }
+
+ /* The managed wrapper gives C the ownership of the filled out parameter */
+ public static void out_own_string_from_virtual()
+ {
+ test.Testing obj = new StringReturner();
+ /* for (int i = 0; i < 10000; i ++) // Uncomment this to check for memory leaks. */
+ Test.AssertEquals("out_own_inherited", obj.CallOutOwnString());
+ System.GC.Collect();
+ }
+
+}
+
+class TestStringshare
+{
+ public static void in_stringshare()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ String sent = "in_stringshare";
+ String returned = obj.InStringshare(sent);
+ Test.AssertEquals(sent, returned);
+ }
+ System.GC.Collect();
+ }
+
+ public static void in_own_stringshare()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ String sent = "in_own_stringshare";
+ String returned = obj.InOwnStringshare(sent);
+ Test.AssertEquals(sent, returned);
+ }
+ System.GC.Collect();
+ }
+
+ public static void return_stringshare()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ Test.AssertEquals("stringshare", obj.ReturnStringshare());
+ }
+ System.GC.Collect();
+ }
+
+ public static void return_own_stringshare()
+ {
+ {
+ test.Testing obj = new test.TestingConcrete();
+ Test.AssertEquals("own_stringshare", obj.ReturnOwnStringshare());
+ }
+ System.GC.Collect();
+ }
+
+ public static void out_stringshare()
+ {
+ {
+ String str = String.Empty;
+ test.Testing obj = new test.TestingConcrete();
+ obj.OutStringshare(out str);
+ Test.AssertEquals("out_stringshare", str);
+ }
+ System.GC.Collect();
+ }
+
+ public static void out_own_stringshare()
+ {
+ {
+ String str = String.Empty;
+ test.Testing obj = new test.TestingConcrete();
+ obj.OutOwnStringshare(out str);
+ Test.AssertEquals(str.ToString(), "out_own_stringshare");
+ }
+ System.GC.Collect();
+ }
+
+ private class StringshareReturner : test.TestingInherit
+ {
+ public String received_in;
+ public String received_in_own;
+ public StringshareReturner() : base(null) {
+ received_in = String.Empty;
+ received_in_own = String.Empty;
+ }
+
+ public override String InStringshare(String str)
+ {
+ received_in = str;
+ return String.Empty;
+ }
+
+ public override String InOwnStringshare(String str)
+ {
+ received_in_own = str;
+ return String.Empty;
+ }
+
+ public override String ReturnStringshare()
+ {
+ return "inherited";
+ }
+
+ public override String ReturnOwnStringshare()
+ {
+ return "own_inherited";
+ }
+
+ public override void OutStringshare(out String str)
+ {
+ str = "out_inherited";
+ }
+
+ public override void OutOwnStringshare(out System.String str)
+ {
+ str = "out_own_inherited";
+ }
+ }
+
+ public static void in_stringshare_from_virtual()
+ {
+ StringshareReturner obj = new StringshareReturner();
+ String sent = "in_inherited";
+ obj.CallInStringshare(sent);
+ Test.AssertEquals(sent, obj.received_in);
+ }
+
+ public static void in_own_stringshare_from_virtual()
+ {
+ StringshareReturner obj = new StringshareReturner();
+ String sent = "in_own_inherited";
+ obj.CallInOwnStringshare(sent);
+ Test.AssertEquals(sent, obj.received_in_own);
+ }
+
+ public static void return_stringshare_from_virtual()
+ {
+ test.Testing obj = new StringshareReturner();
+ // for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
+ Test.AssertEquals("inherited", obj.CallReturnStringshare());
+ }
+
+ public static void return_own_stringshare_from_virtual()
+ {
+ test.Testing obj = new StringshareReturner();
+ // for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
+ Test.AssertEquals("own_inherited", obj.CallReturnOwnStringshare());
+ }
+
+ public static void out_stringshare_from_virtual()
+ {
+ test.Testing obj = new StringshareReturner();
+ // for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
+ Test.AssertEquals("out_inherited", obj.CallOutStringshare());
+ }
+
+ public static void out_own_stringshare_from_virtual()
+ {
+ test.Testing obj = new StringshareReturner();
+ // for (int i = 0; i < 1000000; i ++) // Uncomment this to check for memory leaks.
+ Test.AssertEquals("out_own_inherited", obj.CallOutOwnStringshare());
+ }
+}
+
+}
--- /dev/null
+using System;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+using System.Diagnostics.CodeAnalysis;
+
+
+/// <summary>Exception for assertion failures.</summary>
+[Serializable]
+public class AssertionException : Exception
+{
+ /// <summary> Default constructor.</summary>
+ public AssertionException() : base () { }
+ /// <summary> Most commonly used contructor.</summary>
+ public AssertionException(string msg) : base(msg) { }
+ /// <summary> Wraps an inner exception.</summary>
+ public AssertionException(string msg, Exception inner) : base(msg, inner) { }
+ /// <summary> Serializable constructor.</summary>
+ protected AssertionException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+}
+
+/// <summary> Helper class for Mono EFL bindings tests.</summary>
+public static class Test
+{
+ /// <summary> Asserts a boolean condition.</summary>
+ public static void Assert(bool res, String msg = "Assertion failed",
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null)
+ {
+ if (msg == null)
+ msg = "Assertion failed.";
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ if (!res)
+ throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}");
+ }
+
+ /// <summary> Asserts if expected is equal to actual, using expected.Equals(actual).</summary>
+ public static void AssertEquals<T>(T expected, T actual, String msg = null,
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null)
+ {
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ if (expected == null)
+ throw new AssertionException($"{file}:{line} ({member}) Null expected value. Use AssertNull.");
+ if (!expected.Equals(actual)) {
+ if (msg == null || msg.Length == 0)
+ msg = $"Expected \"{expected}\", actual \"{actual}\"";
+ throw new AssertionException($"{file}:{line} ({member}) {msg}");
+ }
+ }
+
+ /// <summary> Asserts if expected is not equal to actual, using !expected.Equals(actual).</summary>
+ public static void AssertNotEquals<T>(T expected, T actual, String msg = null,
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null)
+ {
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ if (expected == null)
+ throw new AssertionException($"{file}:{line} ({member}) Null expected value. Use AssertNull.");
+ if (expected.Equals(actual)) {
+ if (msg == null || msg.Length == 0)
+ msg = $"Expected \"{expected}\" shouldn't be equal to actual \"{actual}\"";
+ throw new AssertionException($"{file}:{line} ({member}) {msg}");
+ }
+ }
+
+ /// <summary> Asserts if actual is near enough of expected, using the optional tolerance (default 0.00001).</summary>
+ public static void AssertAlmostEquals(double expected, double actual, double tolerance=0.00001,
+ String msg = null,
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null)
+ {
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ double difference = Math.Abs(expected - actual);
+ if (difference > tolerance) {
+ if (msg == null || msg.Length == 0)
+ msg = $"Expected \"{expected}\". Difference: \"{difference}\"";
+ throw new AssertionException($"{file}:{line} ({member}) {msg}");
+ }
+ }
+
+ /// <summary> Asserts if greater is greater than smaller , using greater.CompareTo(smaller) > 0.</summary>
+ public static void AssertGreaterThan<T>(T greater, T smaller, String msg = null,
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null) where T : System.IComparable<T>
+ {
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ if (greater == null || smaller == null)
+ throw new AssertionException($"{file}:{line} ({member}) Null input value. Use AssertNull.");
+ if (greater.CompareTo(smaller) <= 0) {
+ if (msg == null || msg.Length == 0)
+ msg = $"Greater \"{greater}\" is not greater than smaller \"{smaller}\"";
+ throw new AssertionException($"{file}:{line} ({member}) {msg}");
+ }
+ }
+
+ /// <summary> Asserts if smaller is smaller than greater, using greater.CompareTo(smaller) < 0.</summary>
+ public static void AssertLessThan<T>(T smaller, T greater, String msg = null,
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null) where T : System.IComparable<T>
+ {
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ if (greater == null || smaller == null)
+ throw new AssertionException($"{file}:{line} ({member}) Null input value. Use AssertNull.");
+ if (smaller.CompareTo(greater) >= 0) {
+ if (msg == null || msg.Length == 0)
+ msg = $"Smaller \"{smaller}\" is not smaller than greater \"{greater}\"";
+ throw new AssertionException($"{file}:{line} ({member}) {msg}");
+ }
+ }
+
+ /// <summary> Asserts if op, when called, raises the exception T.</summary>
+ [SuppressMessage("Gendarme.Rules.Design.Generic", "AvoidMethodWithUnusedGenericTypeRule")]
+ public static void AssertRaises<T>(Action op, String msg = null,
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null) where T: Exception
+ {
+ if (msg == null)
+ msg = "Exception not raised.";
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ if (op == null)
+ throw new AssertionException($"Assertion failed: {file}:{line} ({member}) Null operation.");
+ try {
+ op();
+ } catch (T) {
+ return;
+ }
+ throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}");
+ }
+
+ /// <summary> Asserts if op, when called, does not raise the exception T.</summary>
+ [SuppressMessage("Gendarme.Rules.Design.Generic", "AvoidMethodWithUnusedGenericTypeRule")]
+ public static void AssertNotRaises<T>(Action op, String msg = null,
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null) where T: Exception
+ {
+ if (msg == null)
+ msg = "Exception raised.";
+ if (file == null)
+ file = "(unknown file)";
+ if (member == null)
+ member = "(unknown member)";
+ if (op == null)
+ throw new AssertionException($"Assertion failed: {file}:{line} ({member}) Null operation.");
+ try {
+ op();
+ } catch (T) {
+ throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}");
+ }
+ }
+
+ /// <summary> Asserts if the given reference is null.</summary>
+ public static void AssertNull(object reference, String msg = "Reference not null",
+ [CallerLineNumber] int line = 0,
+ [CallerFilePath] string file = null,
+ [CallerMemberName] string member = null)
+ {
+ if (reference != null)
+ throw new AssertionException($"Assertion failed: {file}:{line} ({member}) {msg}");
+ }
+}
+
+
--- /dev/null
+#define CODE_ANALYSIS
+
+#pragma warning disable 1591
+
+using System;
+using System.Diagnostics.CodeAnalysis;
+
+namespace TestSuite {
+
+
+[SuppressMessage("Gendarme.Rules.Portability", "DoNotHardcodePathsRule")]
+public static class TestEinaValue {
+
+ public static void TestByteSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Byte)) {
+ byte val = 0xff;
+ Test.Assert(v.Set(val));
+ byte x;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(val, x);
+ }
+ }
+
+ public static void TestSByteSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.SByte)) {
+ sbyte val = -45;
+ Test.Assert(v.Set(val));
+ sbyte x;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(val, x);
+ }
+ }
+
+ public static void TestShortSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Short)) {
+ short val = -128;
+ Test.Assert(v.Set(val));
+ short x;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(val, x);
+ }
+ }
+
+ public static void TestUShortSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.UShort)) {
+ ushort val = 0xff55;
+ Test.Assert(v.Set(val));
+ ushort x;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(val, x);
+ }
+ }
+
+ public static void TestLongSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Long)) {
+ long val = 0xdeadbeef;
+ Test.Assert(v.Set(val));
+ long x;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(val, x);
+ }
+ }
+
+ public static void TestULongSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.ULong)) {
+ ulong val = 0xdeadbeef;
+ Test.Assert(v.Set(val));
+ ulong x;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(val, x);
+ }
+ }
+
+ public static void TestFloatSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Float)) {
+ float val = 1.609344f;
+ Test.Assert(v.Set(val));
+ float x;
+ Test.Assert(v.Get(out x));
+ Test.AssertAlmostEquals(val, x);
+ }
+ }
+
+ public static void TestDoubleSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Double)) {
+ double val = 1.609344;
+ Test.Assert(v.Set(val));
+ double x;
+ Test.Assert(v.Get(out x));
+ Test.AssertAlmostEquals(val, x);
+ }
+ }
+
+
+ public static void TestIntSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(v.Set(32));
+ int x;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(32, x);
+
+ Test.Assert(v.Set(-45));
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(-45, x);
+ }
+ }
+
+ public static void TestUIntSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(v.Set(0xdeadbeef));
+ uint x = 0;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(0xdeadbeef, x);
+ }
+ }
+
+ public static void TestStringSimple()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.String)) {
+ string expected_str = "Hello";
+ Test.Assert(v.Set(expected_str));
+ string str = null;
+ Test.Assert(v.Get(out str));
+ Test.AssertEquals(expected_str, str);
+ }
+ }
+
+ public static void TestSetWrongType()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.String)) {
+ Test.AssertRaises<ArgumentException>(() => v.Set(42));
+ Test.AssertNotRaises<ArgumentException>(() => v.Set("Wumpus"));
+ Test.Assert(v.Setup(eina.ValueType.Int32));
+ Test.AssertRaises<ArgumentException>(() => v.Set("Wat?"));
+ Test.AssertNotRaises<ArgumentException>(() => v.Set(1984));
+ }
+ }
+
+ public static void TestValueSetup()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(v.Set(44));
+ int x = 0;
+ Test.Assert(v.Get(out x));
+ Test.AssertEquals(44, x);
+ v.Setup(eina.ValueType.String);
+
+ string str = "Hello";
+ Test.Assert(v.Get(out str));
+ Test.AssertNull(str);
+ }
+ }
+
+ public static void TestValueDispose()
+ {
+ eina.Value v = new eina.Value(eina.ValueType.Int32);
+ v.Dispose();
+ Test.AssertRaises<ObjectDisposedException>(v.Flush);
+ Test.AssertRaises<ObjectDisposedException>(() => v.ToString());
+ Test.AssertRaises<ObjectDisposedException>(() => v.Set(24));
+ }
+
+ public static void TestValueFlush()
+ {
+ using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(v.Set(44));
+ Test.Assert(!v.Flushed);
+ v.Flush();
+ Test.Assert(v.Flushed);
+
+ int x;
+ Test.AssertRaises<eina.ValueFlushedException>(() => v.Get(out x));
+ x = 42;
+ Test.AssertRaises<eina.ValueFlushedException>(() => v.Set(x));
+
+ v.Setup(eina.ValueType.String);
+ Test.AssertNotRaises<eina.ValueFlushedException>(() => v.Set("Hello, EFL"));
+
+ string y = String.Empty;
+ Test.AssertNotRaises<eina.ValueFlushedException>(() => v.Get(out y));
+ v.Flush();
+ Test.AssertRaises<eina.ValueFlushedException>(() => v.Get(out y));
+
+ v.Setup(eina.ValueType.Array, eina.ValueType.UInt32);
+
+ Test.AssertNotRaises<eina.ValueFlushedException>(() =>
+ v.Append(42));
+ v.Flush();
+ Test.AssertRaises<eina.ValueFlushedException>(() =>
+ v.Append(42));
+
+ Test.AssertRaises<eina.ValueFlushedException>(() => v.GetValueSubType());
+
+ }
+ }
+
+ private delegate bool BoolRet();
+ public static void TestValueOptionalInt()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Optional)) {
+ Test.Assert(a.Optional);
+ Test.Assert(a.Empty); // By default, optional values are empty
+
+ // Sets expectation
+ int expected = 1984;
+ Test.Assert(a.Set(expected));
+ Test.Assert(a.Optional);
+ Test.Assert(!a.Empty);
+
+ Test.Assert(a.Reset());
+ Test.Assert(a.Empty);
+
+ expected = -4891;
+ Test.Assert(a.Set(expected)); // Set() automatically infers the subtype from the argument.
+ Test.Assert(!a.Empty);
+
+ int actual = 0;
+ Test.Assert(a.Get(out actual));
+ Test.AssertEquals(expected, actual);
+ }
+ }
+ public static void TestValueOptionalUint()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Optional)) {
+ Test.Assert(a.Optional);
+ Test.Assert(a.Empty); // By default, optional values are empty
+
+ // Sets expectation
+ uint expected = 1984;
+ Test.Assert(a.Set(expected));
+ Test.Assert(a.Optional);
+ Test.Assert(!a.Empty);
+
+ Test.Assert(a.Reset());
+ Test.Assert(a.Empty);
+
+ expected = 0xdeadbeef;
+ Test.Assert(a.Set(expected));
+ Test.Assert(!a.Empty);
+
+ uint actual = 0;
+ Test.Assert(a.Get(out actual));
+ Test.AssertEquals(expected, actual);
+ }
+ }
+ public static void TestValueOptionalString()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(!a.Optional);
+ BoolRet dummy = () => a.Empty;
+ Test.AssertRaises<eina.InvalidValueTypeException>(() => dummy());
+ }
+
+ using (eina.Value a = new eina.Value(eina.ValueType.Optional)) {
+ Test.Assert(a.Optional);
+ Test.Assert(a.Empty); // By default, optional values are empty
+
+ // Sets expectation
+ string expected = "Hello, world!";
+ Test.Assert(a.Set(expected));
+ Test.Assert(a.Optional);
+ Test.Assert(!a.Empty);
+
+ Test.Assert(a.Reset());
+ Test.Assert(a.Empty);
+
+ expected = "!dlrow olleH";
+ Test.Assert(a.Set(expected));
+ Test.Assert(!a.Empty);
+
+ string actual = String.Empty;
+ Test.Assert(a.Get(out actual));
+ Test.AssertEquals(expected, actual);
+ }
+ }
+ public static void TestValueOptionalArrays()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Optional))
+ using (eina.Value expected = new eina.Value(eina.ValueType.Array,
+ eina.ValueType.Int32))
+ {
+
+ Test.Assert(a.Optional);
+ Test.Assert(a.Empty); // By default, optional values are empty
+
+ // Sets expectation
+ Test.Assert(expected.Append(-1));
+ Test.Assert(expected.Append(0));
+ Test.Assert(expected.Append(2));
+
+ Test.Assert(a.Set(expected));
+ Test.Assert(a.Optional);
+ Test.Assert(!a.Empty);
+
+ Test.Assert(a.Reset());
+ Test.Assert(a.Empty);
+
+ expected.Append(-42);
+ Test.Assert(a.Set(expected));
+ Test.Assert(!a.Empty);
+
+ eina.Value actual = null;
+ Test.Assert(a.Get(out actual));
+ Test.AssertEquals(expected, actual);
+
+ Test.Assert(a.Reset());
+ Test.Assert(a.Set(expected));
+ }
+ }
+ public static void TestValueOptionalLists()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Optional))
+ using (eina.Value expected = new eina.Value(eina.ValueType.List,
+ eina.ValueType.Int32))
+ {
+
+ Test.Assert(a.Optional);
+ Test.Assert(a.Empty); // By default, optional values are empty
+
+ // Sets expectation
+ Test.Assert(expected.Append(-1));
+ Test.Assert(expected.Append(0));
+ Test.Assert(expected.Append(2));
+
+ Test.Assert(a.Set(expected));
+ Test.Assert(a.Optional);
+ Test.Assert(!a.Empty);
+
+ Test.Assert(a.Reset());
+ Test.Assert(a.Empty);
+
+ expected.Append(-42);
+ Test.Assert(a.Set(expected));
+ Test.Assert(!a.Empty);
+
+ eina.Value actual = null;
+ Test.Assert(a.Get(out actual));
+ Test.AssertEquals(expected, actual);
+ }
+ }
+
+ public static void TestValueCompareInts()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Int32))
+ using (eina.Value b = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(a.Set(123));
+ Test.Assert(b.Set(123));
+ Test.AssertEquals(0, a.CompareTo(b));
+
+ Test.Assert(a.Set(-10));
+ Test.AssertLessThan(a, b);
+
+ Test.Assert(a.Set(123));
+ Test.Assert(b.Set(10));
+ Test.AssertGreaterThan(a, b);
+ }
+ }
+
+ public static void TestValueComparisonEquals()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Int32))
+ using (eina.Value b = new eina.Value(eina.ValueType.Int32))
+ using (eina.Value c = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(a.Set(1));
+ Test.Assert(b.Set(1));
+ Test.Assert(c.Set(1));
+
+ Test.Assert(a.Equals(a), "A equals A");
+ Test.Assert(a.Equals(b) == b.Equals(a), "A equals B == B equals A");
+ Test.Assert(a.Equals(b) == b.Equals(c) == a.Equals(c));
+
+ Test.Assert(b.Set(0));
+ Test.Assert(a.Equals(b) == b.Equals(a), "A equals B == B equals A");
+
+ Test.Assert(a.Equals(null) == false, "A == null");
+ }
+ }
+
+ public static void TestValueComparisonOverloadEquals()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Int32))
+ using (eina.Value b = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(a.Set(1));
+ Test.Assert(b.Set(1));
+
+ Test.Assert(a == b);
+ Test.Assert(!(a != b));
+ Test.Assert(b == a);
+ Test.Assert(!(b != a));
+
+ Test.Assert(b.Set(42));
+
+ Test.Assert(a != b);
+ Test.Assert(!(a == b));
+ Test.Assert(b != a);
+ Test.Assert(!(b == a));
+
+ Test.Assert(b.Set(42));
+
+ }
+ }
+
+ public static void TestValueComparisonOverloadLessMore()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.Int32))
+ using (eina.Value b = new eina.Value(eina.ValueType.Int32)) {
+ Test.Assert(a.Set(1));
+ Test.Assert(b.Set(0));
+
+ Test.Assert(a > b);
+ Test.Assert(!(a < b));
+ Test.Assert(b < a);
+ Test.Assert(!(b > a));
+ }
+ }
+
+ public static void TestValueCompareStrings()
+ {
+ using (eina.Value a = new eina.Value(eina.ValueType.String))
+ using (eina.Value b = new eina.Value(eina.ValueType.String)) {
+ Test.Assert(a.Set("aaa"));
+ Test.Assert(b.Set("aaa"));
+ Test.AssertEquals(0, a.CompareTo(b));
+
+ Test.Assert(a.Set("abc"));
+ Test.Assert(b.Set("acd"));
+ Test.AssertLessThan(a, b);
+
+ Test.Assert(a.Set("acd"));
+ Test.Assert(b.Set("abc"));
+ Test.AssertGreaterThan(a, b);
+ }
+ }
+
+ public static void TestValueCompareArray()
+ {
+ using(eina.Value a = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32))
+ using(eina.Value b = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32)) {
+
+ Test.AssertEquals(a, b);
+
+ Test.Assert(a.Append(0));
+ Test.Assert(a.Append(1));
+ Test.Assert(a.Append(5));
+ Test.Assert(a.Append(42));
+
+ Test.Assert(b.Append(0));
+ Test.Assert(b.Append(1));
+ Test.Assert(b.Append(5));
+ Test.Assert(b.Append(42));
+
+ Test.AssertEquals(a, b);
+
+ a[0] = -1;
+ Test.Assert(!a.Equals(b));
+ Test.AssertLessThan(a, b);
+
+ a[0] = 10;
+ Test.AssertGreaterThan(a, b);
+
+ a[0] = 0;
+ Test.AssertEquals(a, b);
+
+ // bigger arrays are greater
+ Test.Assert(b.Append(0));
+ Test.AssertLessThan(a, b);
+
+ Test.Assert(a.Append(0));
+ Test.Assert(a.Append(0));
+ Test.AssertGreaterThan(a, b);
+
+ // bigger arrays are greater, unless an element says other wise
+ b[0] = 10;
+ Test.AssertGreaterThan(b, a);
+ }
+ }
+
+ public static void TestValueCompareList()
+ {
+ using(eina.Value a = new eina.Value(eina.ValueType.List, eina.ValueType.Int32))
+ using(eina.Value b = new eina.Value(eina.ValueType.List, eina.ValueType.Int32)) {
+
+ Test.AssertEquals(a, b);
+
+ Test.Assert(a.Append(0));
+ Test.Assert(a.Append(1));
+ Test.Assert(a.Append(5));
+ Test.Assert(a.Append(42));
+
+ Test.Assert(b.Append(0));
+ Test.Assert(b.Append(1));
+ Test.Assert(b.Append(5));
+ Test.Assert(b.Append(42));
+
+ Test.AssertEquals(a, b);
+
+ a[0] = -1;
+ Test.Assert(!a.Equals(b));
+ Test.AssertLessThan(a, b);
+
+ a[0] = 10;
+ Test.AssertGreaterThan(a, b);
+
+ a[0] = 0;
+ Test.AssertEquals(a, b);
+
+ // bigger arrays are greater
+ Test.Assert(b.Append(0));
+ Test.AssertLessThan(a, b);
+
+ Test.Assert(a.Append(0));
+ Test.Assert(a.Append(0));
+ Test.AssertGreaterThan(a, b);
+
+ // bigger arrays are greater, unless an element says other wise
+ b[0] = 10;
+ Test.AssertGreaterThan(b, a);
+ }
+ }
+
+ /* public static void TestValueCompareHash() */
+ /* { */
+ /* Test.Assert(false, "Implement me."); */
+ /* } */
+
+ public static void TestValueToString()
+ {
+ using(eina.Value a = new eina.Value(eina.ValueType.Int32)) {
+ int i = -12345;
+ string x = $"{i}";
+ Test.Assert(a.Set(i));
+ Test.AssertEquals(x, a.ToString());
+
+ uint u = 0xdeadbeef;
+ x = $"{u}";
+ Test.Assert(a.Setup(eina.ValueType.UInt32));
+ Test.Assert(a.Set(u));
+ Test.AssertEquals(x, a.ToString());
+
+ string s = "Hello, Johnny!";
+ x = s;
+ Test.Assert(a.Setup(eina.ValueType.String));
+ Test.Assert(a.Set(s));
+ Test.AssertEquals(x, a.ToString());
+ }
+ }
+
+ public static void TestValueConvertInt()
+ {
+ using(eina.Value from = new eina.Value(eina.ValueType.Int32))
+ using(eina.Value to = new eina.Value(eina.ValueType.UInt32)) {
+ int source = 0x7FFFFFFF;
+ uint target_uint;
+ int target_int;
+ string target_str;
+ string source_str = $"{source}";
+
+ Test.Assert(from.Set(source));
+ Test.Assert(from.ConvertTo(to));
+ Test.Assert(to.Get(out target_uint));
+ Test.AssertEquals(target_uint, (uint)source);
+
+ Test.Assert(to.Setup(eina.ValueType.Int32));
+ Test.Assert(from.ConvertTo(to));
+ Test.Assert(to.Get(out target_int));
+ Test.AssertEquals(target_int, source);
+
+ Test.Assert(to.Setup(eina.ValueType.String));
+ Test.Assert(from.ConvertTo(to));
+ Test.Assert(to.Get(out target_str));
+ Test.AssertEquals(target_str, source_str);
+
+ // FIXME Add tests for failing ConvertTo() calls when downcasting
+ // to smaller types
+ }
+ }
+
+ public static void TestValueConvertUInt()
+ {
+ using(eina.Value from = new eina.Value(eina.ValueType.UInt32))
+ using(eina.Value to = new eina.Value(eina.ValueType.UInt32)) {
+ uint source = 0xFFFFFFFF;
+ uint target_uint;
+ string target_str;
+ string source_str = $"{source}";
+
+ Test.Assert(from.Set(source));
+ Test.Assert(from.ConvertTo(to));
+ Test.Assert(to.Get(out target_uint));
+ Test.AssertEquals(target_uint, source);
+
+ Test.Assert(to.Setup(eina.ValueType.Int32));
+ Test.Assert(!from.ConvertTo(to));
+
+ Test.Assert(to.Setup(eina.ValueType.String));
+ Test.Assert(from.ConvertTo(to));
+ Test.Assert(to.Get(out target_str));
+ Test.AssertEquals(target_str, source_str);
+
+ // FIXME Add tests for failing ConvertTo() calls when downcasting
+ // to smaller types
+ }
+ }
+
+ public static void TestValueContainerConstructorWrongArgs()
+ {
+ Test.AssertRaises<ArgumentException>(() => {
+ using(eina.Value array = new eina.Value(eina.ValueType.String, eina.ValueType.String)) { }
+ });
+ }
+
+ public static void TestValueContainerWithNonContainerAccess()
+ {
+ using(eina.Value array = new eina.Value(eina.ValueType.Int32)) {
+ Test.AssertRaises<eina.InvalidValueTypeException>(() => array[0] = 1);
+ object val = null;
+ Test.AssertRaises<eina.InvalidValueTypeException>(() => val = array[0]);
+ }
+ }
+
+ public static void TestValueArray() {
+ using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32)) {
+ Test.AssertEquals(0, array.Count());
+ Test.Assert(array.Append(0));
+ Test.AssertEquals(1, array.Count());
+ Test.Assert(array.Append(1));
+ Test.AssertEquals(2, array.Count());
+ Test.Assert(array.Append(5));
+ Test.AssertEquals(3, array.Count());
+ Test.Assert(array.Append(42));
+ Test.AssertEquals(4, array.Count());
+
+
+ Test.AssertEquals((int)array[0], 0);
+ Test.AssertEquals((int)array[1], 1);
+ Test.AssertEquals((int)array[2], 5);
+ Test.AssertEquals((int)array[3], 42);
+
+ array[0] = 1984;
+ array[1] = -42;
+ Test.AssertEquals(4, array.Count());
+
+ Test.AssertEquals((int)array[0], 1984);
+ Test.AssertEquals((int)array[1], -42);
+ Test.AssertEquals((int)array[2], 5);
+ Test.AssertEquals((int)array[3], 42);
+
+ Test.AssertEquals("[1984, -42, 5, 42]", array.ToString());
+ }
+
+ using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.UInt32)) {
+ Test.Assert(array.Append(2));
+ Test.AssertEquals((uint)array[0], (uint)2);
+ Test.AssertRaises<OverflowException>(() => array[0] = -1);
+ }
+
+ using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.String)) {
+
+ Test.Assert(array.Append("hello"));
+ Test.Assert(array.Append("world"));
+
+ Test.AssertEquals((string)array[0], "hello");
+ Test.AssertEquals((string)array[1], "world");
+
+ array[0] = "efl";
+ array[1] = "rocks";
+
+ Test.AssertEquals((string)array[0], "efl");
+ Test.AssertEquals((string)array[1], "rocks");
+ }
+ }
+
+ public static void TestArrayOutOfBounds() {
+ using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32)) {
+ object placeholder = null;
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => array[0] = 1);
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => placeholder = array[0]);
+ Test.Assert(array.Append(0));
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => array[0] = 1);
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => placeholder = array[0]);
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => array[1] = 1);
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => placeholder = array[1]);
+ Test.Assert(array.Append(0));
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => array[1] = 1);
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => placeholder = array[1]);
+ }
+ }
+
+ public static void TestValueArraySubType() {
+ using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32))
+ Test.AssertEquals(eina.ValueType.Int32, array.GetValueSubType());
+
+ using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.UInt32))
+ Test.AssertEquals(eina.ValueType.UInt32, array.GetValueSubType());
+ }
+
+ public static void TestValueArrayConvert() {
+ using(eina.Value array = new eina.Value(eina.ValueType.Array, eina.ValueType.Int32))
+ using(eina.Value other = new eina.Value(eina.ValueType.Int32)) {
+ other.Set(100);
+ other.ConvertTo(array);
+ Test.AssertEquals(100, (int)array[0]);
+ Test.AssertEquals("[100]", array.ToString());
+ }
+ }
+
+ public static void TestValueList() {
+ using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32)) {
+ Test.AssertEquals(0, list.Count());
+ Test.Assert(list.Append(0));
+ Test.AssertEquals(1, list.Count());
+ Test.Assert(list.Append(1));
+ Test.AssertEquals(2, list.Count());
+ Test.Assert(list.Append(5));
+ Test.AssertEquals(3, list.Count());
+ Test.Assert(list.Append(42));
+ Test.AssertEquals(4, list.Count());
+
+
+ Test.AssertEquals((int)list[0], 0);
+ Test.AssertEquals((int)list[1], 1);
+ Test.AssertEquals((int)list[2], 5);
+ Test.AssertEquals((int)list[3], 42);
+
+ list[0] = 1984;
+ list[1] = -42;
+ Test.AssertEquals(4, list.Count());
+
+ Test.AssertEquals((int)list[0], 1984);
+ Test.AssertEquals((int)list[1], -42);
+ Test.AssertEquals((int)list[2], 5);
+ Test.AssertEquals((int)list[3], 42);
+
+ Test.AssertEquals("[1984, -42, 5, 42]", list.ToString());
+ }
+
+ using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.UInt32)) {
+ Test.Assert(list.Append(2));
+ Test.AssertEquals((uint)list[0], (uint)2);
+ Test.AssertRaises<OverflowException>(() => list[0] = -1);
+ }
+
+ using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.String)) {
+
+ Test.Assert(list.Append("hello"));
+ Test.Assert(list.Append("world"));
+
+ Test.AssertEquals((string)list[0], "hello");
+ Test.AssertEquals((string)list[1], "world");
+
+ list[0] = "efl";
+ list[1] = "rocks";
+
+ Test.AssertEquals((string)list[0], "efl");
+ Test.AssertEquals((string)list[1], "rocks");
+ }
+ }
+
+ public static void TestListOutOfBounds() {
+ using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32)) {
+ object placeholder = null;
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => list[0] = 1);
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => placeholder = list[0]);
+ Test.Assert(list.Append(0));
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => list[0] = 1);
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => placeholder = list[0]);
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => list[1] = 1);
+ Test.AssertRaises<System.ArgumentOutOfRangeException>(() => placeholder = list[1]);
+ Test.Assert(list.Append(0));
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => list[1] = 1);
+ Test.AssertNotRaises<System.ArgumentOutOfRangeException>(() => placeholder = list[1]);
+ }
+ }
+
+ public static void TestValueListSubType() {
+ using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32))
+ Test.AssertEquals(eina.ValueType.Int32, list.GetValueSubType());
+
+ using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.UInt32))
+ Test.AssertEquals(eina.ValueType.UInt32, list.GetValueSubType());
+ }
+
+ public static void TestValueListConvert() {
+ using(eina.Value list = new eina.Value(eina.ValueType.List, eina.ValueType.Int32))
+ using(eina.Value other = new eina.Value(eina.ValueType.Int32)) {
+ other.Set(100);
+ other.ConvertTo(list);
+ Test.AssertEquals(100, (int)list[0]);
+ Test.AssertEquals("[100]", list.ToString());
+ }
+ }
+
+
+ // FIXME Add remaining list tests
+
+ /* public static void TestValueHash() { */
+ /* Test.Assert(false, "Implement me."); */
+ /* } */
+
+ /* public static void TestValueTimeVal() { */
+ /* Test.Assert(false, "Implement me."); */
+ /* } */
+
+ /* public static void TestValueBlob() { */
+ /* Test.Assert(false, "Implement me."); */
+ /* } */
+
+ /* public static void TestValueStruct() { */
+ /* Test.Assert(false, "Implement me."); */
+ /* } */
+
+ /* public static void TestValueArrayOfStructs() { */
+ /* Test.Assert(false, "Implement me."); */
+ /* } */
+
+ /* public static void TestValueOptionalStructMembers() { */
+ /* Test.Assert(false, "Implement me."); */
+ /* } */
+}
+#pragma warning restore 1591
+}
--- /dev/null
+#define CODE_ANALYSIS
+
+// Disable warning about missing docs when generating docs
+#pragma warning disable 1591
+
+using System;
+
+namespace TestSuite {
+
+
+public static class TestEinaValueEolian {
+ public static void TestEolianEinaValueInReturn()
+ {
+ test.Testing obj = new test.TestingConcrete();
+
+ using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ v.Set(42);
+ obj.SetValuePtr(v);
+ Test.AssertEquals(eina.ValueOwnership.Managed, v.Ownership);
+
+ eina.Value v_received = obj.GetValuePtrOwn();
+ Test.AssertEquals(eina.ValueOwnership.Managed, v_received.Ownership);
+ Test.AssertEquals(v, v_received);
+ v_received.Dispose();
+ }
+ }
+
+ public static void TestEolianEinaValueInOwn()
+ {
+ test.Testing obj = new test.TestingConcrete();
+
+ using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ v.Set(2001);
+ Test.AssertEquals(eina.ValueOwnership.Managed, v.Ownership);
+
+ obj.SetValuePtrOwn(v);
+ Test.AssertEquals(eina.ValueOwnership.Unmanaged, v.Ownership);
+
+ eina.Value v_received = obj.GetValuePtr();
+ Test.AssertEquals(eina.ValueOwnership.Unmanaged, v_received.Ownership);
+
+ Test.AssertEquals(v, v_received);
+
+ obj.ClearValue();
+ }
+ }
+
+ public static void TestEolianEinaValueOut()
+ {
+ test.Testing obj = new test.TestingConcrete();
+
+ using (eina.Value v = new eina.Value(eina.ValueType.String)) {
+ eina.Value v_out = null;
+
+ v.Set("hello!");
+ obj.SetValuePtr(v);
+ obj.OutValuePtr(out v_out);
+
+ Test.AssertEquals(v, v_out);
+ Test.AssertEquals(eina.ValueOwnership.Unmanaged, v_out.Ownership);
+ }
+ }
+
+ public static void TestEolianEinaValueOutOwn()
+ {
+ test.Testing obj = new test.TestingConcrete();
+
+ using (eina.Value v = new eina.Value(eina.ValueType.String)) {
+ eina.Value v_out = null;
+
+ v.Set("hello!");
+ obj.SetValuePtr(v);
+ obj.OutValuePtrOwn(out v_out);
+
+ Test.AssertEquals(v, v_out);
+ Test.AssertEquals(eina.ValueOwnership.Managed, v_out.Ownership);
+ }
+ }
+
+ public static void TestEolianEinaValueInReturnByValue()
+ {
+ test.Testing obj = new test.TestingConcrete();
+
+ using (eina.Value v = new eina.Value(eina.ValueType.Int32)) {
+ v.Set(42);
+ obj.SetValue(v);
+ Test.AssertEquals(eina.ValueOwnership.Managed, v.Ownership);
+
+ // Using get_value_ptr while get_value() is not supported.
+ eina.Value v_received = obj.GetValuePtrOwn();
+ Test.AssertEquals(eina.ValueOwnership.Managed, v_received.Ownership);
+ Test.AssertEquals(v, v_received);
+ v_received.Dispose();
+ }
+ }
+
+ public static void TestEolianEinaValueOutByValue()
+ {
+ test.Testing obj = new test.TestingConcrete();
+
+ using (eina.Value v = new eina.Value(eina.ValueType.String)) {
+ eina.Value v_out = null;
+
+ v.Set("hello!");
+ obj.SetValue(v);
+ obj.OutValue(out v_out);
+
+ Test.AssertEquals(v, v_out);
+ Test.AssertEquals(eina.ValueOwnership.Managed, v_out.Ownership);
+ }
+ }
+}
+#pragma warning restore 1591
+}
+
--- /dev/null
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <Eo.h>
+
+#undef EOAPI
+#undef EAPI
+#define EOAPI EAPI EAPI_WEAK
+
+#ifdef _WIN32
+# ifdef EFL_EO_BUILD
+# ifdef DLL_EXPORT
+# define EAPI __declspec(dllexport)
+# else
+# define EAPI
+# endif /* ! DLL_EXPORT */
+# else
+# define EAPI __declspec(dllimport)
+# endif /* ! EFL_EO_BUILD */
+#else
+# ifdef __GNUC__
+# if __GNUC__ >= 4
+# define EAPI __attribute__ ((visibility("default")))
+# else
+# define EAPI
+# endif
+# else
+# define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+#include "test_numberwrapper.eo.h"
+#include "test_testing.eo.h"
+
+typedef struct Test_Testing_Data
+{
+ Test_SimpleCb cb;
+ void *cb_data;
+ Eina_Free_Cb free_cb;
+ Eina_Error error_code;
+ Eina_Value *stored_value;
+
+} Test_Testing_Data;
+
+typedef struct Test_Numberwrapper_Data
+{
+ int number;
+} Test_Numberwrapper_Data;
+
+
+static
+void *_new_int(int v)
+{
+ int *r = malloc(sizeof(int));
+ *r = v;
+ return r;
+}
+
+static
+int *_int_ref(int n)
+{
+ static int r;
+ r = n;
+ return &r;
+}
+
+static
+char **_new_str_ref(const char* str)
+{
+ static char *r;
+ r = strdup(str);
+ return &r;
+}
+
+static
+Test_Numberwrapper *_new_obj(int n)
+{
+ return efl_add(TEST_NUMBERWRAPPER_CLASS, NULL, test_numberwrapper_number_set(efl_added, n));
+}
+
+static
+Test_Numberwrapper **_new_obj_ref(int n)
+{
+ static Test_Numberwrapper *r;
+ r = _new_obj(n);
+ return &r;
+}
+
+// ############ //
+// Test.Testing //
+// ############ //
+
+Efl_Object *_test_testing_return_object(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return obj;
+}
+
+const char *_test_testing_in_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char *str)
+{
+ const char *ret = malloc(sizeof(char)*(strlen(str) + 1));
+ return strcpy((char*)ret, str);
+}
+
+char *_test_testing_in_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, char *str)
+{
+ char *ret = malloc(sizeof(char)*(strlen(str) + 1));
+ strcpy(ret, str);
+ free((void*)str); // Actually take ownership of it.
+ return ret;
+}
+
+Eina_Stringshare *_test_testing_return_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Stringshare *str = eina_stringshare_add("stringshare");
+ return str;
+}
+
+Eina_Stringshare *_test_testing_return_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Stringshare *str = eina_stringshare_add("own_stringshare");
+ return str;
+}
+
+const char *_test_testing_return_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return "string";
+}
+
+const char *_test_testing_return_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ static const char* reference = "own_string";
+ const char *ret = malloc(sizeof(char)*(strlen(reference) + 1));
+ return strcpy((char*)ret, reference);
+}
+
+void _test_testing_out_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+{
+ *str = "out_string";
+}
+
+void _test_testing_out_own_string(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+{
+ static const char* reference = "out_own_string";
+ *str = malloc(sizeof(char)*(strlen(reference) + 1));
+ strcpy((char*)*str, reference);
+}
+
+void _test_testing_call_in_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char *str)
+{
+ test_testing_in_string(obj, str);
+}
+
+void _test_testing_call_in_own_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, char *str)
+{
+ test_testing_in_own_string(obj, str);
+}
+
+const char *_test_testing_call_return_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return test_testing_return_string(obj);
+}
+
+const char *_test_testing_call_return_own_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return test_testing_return_own_string(obj);
+}
+
+const char *_test_testing_call_out_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ const char *ret = NULL;
+ test_testing_out_string(obj, &ret);
+ return ret;
+}
+
+const char *_test_testing_call_out_own_string(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ const char *ret = NULL;
+ test_testing_out_own_string(obj, &ret);
+ return ret;
+}
+
+// Stringshare virtual test helpers
+void _test_testing_call_in_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+{
+ test_testing_in_stringshare(obj, str);
+}
+
+void _test_testing_call_in_own_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+{
+ str = test_testing_in_own_stringshare(obj, str);
+ eina_stringshare_del(str);
+}
+
+Eina_Stringshare *_test_testing_in_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+{
+ return eina_stringshare_add(str);
+}
+
+Eina_Stringshare *_test_testing_in_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Stringshare *str)
+{
+ return str;
+}
+
+void _test_testing_out_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+{
+ // Returning simple string but the binding shouldn't del it as it is not owned by the caller
+ *str = "out_stringshare";
+}
+
+void _test_testing_out_own_stringshare(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, const char**str)
+{
+ *str = eina_stringshare_add("out_own_stringshare");
+}
+
+Eina_Stringshare *_test_testing_call_return_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return test_testing_return_stringshare(obj);
+}
+
+Eina_Stringshare *_test_testing_call_return_own_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return test_testing_return_own_stringshare(obj);
+}
+
+Eina_Stringshare *_test_testing_call_out_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Stringshare *ret = NULL;
+ test_testing_out_stringshare(obj, &ret);
+ return ret;
+}
+
+Eina_Stringshare *_test_testing_call_out_own_stringshare(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Stringshare *ret = NULL;
+ test_testing_out_own_stringshare(obj, &ret);
+ return ret;
+}
+
+
+static const uint8_t base_seq[] = {0x0,0x2A,0x42};
+// static const size_t base_seq_size = 3; // TODO: Use it!!!
+
+static void *memdup(const void* mem, size_t size)
+{
+ void *out = malloc(size);
+ memcpy(out, mem, size);
+ return out;
+}
+
+Eina_Bool _test_testing_eina_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Slice slice)
+{
+ uint8_t *buf = memdup(slice.mem, slice.len);
+ free(buf);
+ return 0 == memcmp(slice.mem, base_seq, slice.len);
+}
+
+Eina_Bool _test_testing_eina_rw_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Rw_Slice slice)
+{
+ Eina_Bool r = (0 == memcmp(slice.mem, base_seq, slice.len));
+ unsigned char *buf = memdup(slice.mem, slice.len);
+ free(buf);
+ for (unsigned i = 0; i < slice.len; ++i)
+ slice.bytes[i] += 1;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Slice *slice)
+{
+ if (!slice) return EINA_FALSE;
+ static const Eina_Slice slc = EINA_SLICE_ARRAY(base_seq);
+ slice->len = slc.len;
+ slice->mem = slc.mem;
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_rw_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Rw_Slice *slice)
+{
+ if (!slice) return EINA_FALSE;
+ slice->len = 3;
+ slice->mem = memdup(base_seq, 3);
+ return EINA_TRUE;
+}
+
+Eina_Slice _test_testing_eina_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Slice slc = EINA_SLICE_ARRAY(base_seq);
+ return slc;
+}
+
+Eina_Rw_Slice _test_testing_eina_rw_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Rw_Slice slc = { .len = 3, .mem = memdup(base_seq, 3) };
+ return slc;
+}
+
+Eina_Bool _test_testing_eina_binbuf_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
+{
+ Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_seq, eina_binbuf_length_get(binbuf)));
+ eina_binbuf_insert_char(binbuf, 42, 0);
+ eina_binbuf_insert_char(binbuf, 43, 0);
+ eina_binbuf_append_char(binbuf, 33);
+ return r;
+}
+
+Eina_Binbuf *_binbuf_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
+{
+ Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_seq, eina_binbuf_length_get(binbuf)));
+ eina_binbuf_insert_char(binbuf, 42, 0);
+ eina_binbuf_insert_char(binbuf, 43, 0);
+ eina_binbuf_append_char(binbuf, 33);
+ _binbuf_in_own_to_check = binbuf;
+ return r;
+}
+
+Eina_Bool _test_testing_check_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_binbuf_in_own_to_check) return EINA_FALSE;
+ const uint8_t mod_seq[] = {43,42,0x0,0x2A,0x42,33};
+ Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(_binbuf_in_own_to_check), mod_seq, eina_binbuf_length_get(_binbuf_in_own_to_check)));
+ eina_binbuf_string_free(_binbuf_in_own_to_check);
+ return r;
+}
+
+Eina_Binbuf *_binbuf_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf **binbuf)
+{
+ if (!binbuf) return EINA_FALSE;
+ *binbuf = eina_binbuf_new();
+ eina_binbuf_append_char(*binbuf, 33);
+ _binbuf_out_to_check = *binbuf;
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_check_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_binbuf_out_to_check) return EINA_FALSE;
+ return 0 == memcmp(eina_binbuf_string_get(_binbuf_out_to_check), base_seq, eina_binbuf_length_get(_binbuf_out_to_check));
+}
+
+Eina_Bool _test_testing_eina_binbuf_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf **binbuf)
+{
+ if (!binbuf) return EINA_FALSE;
+ *binbuf = eina_binbuf_new();
+ eina_binbuf_append_char(*binbuf, 33);
+ return EINA_TRUE;
+}
+
+Eina_Binbuf *_binbuf_return_to_check = NULL;
+
+Eina_Binbuf *_test_testing_eina_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Binbuf *binbuf = eina_binbuf_new();
+ eina_binbuf_append_char(binbuf, 33);
+ _binbuf_return_to_check = binbuf;
+ return binbuf;
+}
+
+Eina_Bool _test_testing_check_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_binbuf_return_to_check) return EINA_FALSE;
+ return 0 == memcmp(eina_binbuf_string_get(_binbuf_return_to_check), base_seq, eina_binbuf_length_get(_binbuf_return_to_check));
+}
+
+Eina_Binbuf *_test_testing_eina_binbuf_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Binbuf *binbuf = eina_binbuf_new();
+ eina_binbuf_append_char(binbuf, 33);
+ return binbuf;
+}
+
+static const int base_seq_int[] = {0x0,0x2A,0x42};
+static const unsigned int base_seq_int_size = EINA_C_ARRAY_LENGTH(base_seq_int);
+static const int modified_seq_int[] = {0x0,0x2A,0x42,42,43,33};
+static const unsigned int modified_seq_int_size = EINA_C_ARRAY_LENGTH(modified_seq_int);
+
+static const char * const base_seq_str[] = {"0x0","0x2A","0x42"};
+static const unsigned int base_seq_str_size = EINA_C_ARRAY_LENGTH(base_seq_str);
+static const char * const modified_seq_str[] = {"0x0","0x2A","0x42","42","43","33"};
+static const unsigned int modified_seq_str_size = EINA_C_ARRAY_LENGTH(modified_seq_str);
+
+static const Test_Numberwrapper *base_seq_obj[] = {NULL,NULL,NULL};
+static const unsigned int base_seq_obj_size = EINA_C_ARRAY_LENGTH(base_seq_str);
+static const Test_Numberwrapper *modified_seq_obj[] = {NULL,NULL,NULL,NULL,NULL,NULL};
+static const unsigned int modified_seq_obj_size = EINA_C_ARRAY_LENGTH(modified_seq_str);
+
+// //
+// Array
+//
+
+static const unsigned int default_step = 32;
+
+// Integer
+
+Eina_Bool _array_int_equal(const Eina_Array *arr, const int base[], unsigned int len)
+{
+ if (eina_array_count(arr) != len)
+ return EINA_FALSE;
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ if (*((int*)eina_array_data_get(arr, i)) != base[i])
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_array_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+{
+ Eina_Bool r = _array_int_equal(arr, base_seq_int, base_seq_int_size);
+ eina_array_push(arr, _new_int(42));
+ eina_array_push(arr, _new_int(43));
+ eina_array_push(arr, _new_int(33));
+ return r;
+}
+
+static Eina_Array *_array_int_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+{
+ Eina_Bool r = _array_int_equal(arr, base_seq_int, base_seq_int_size);
+ eina_array_push(arr, _new_int(42));
+ eina_array_push(arr, _new_int(43));
+ eina_array_push(arr, _new_int(33));
+ _array_int_in_own_to_check = arr;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_int_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_int_equal(_array_int_in_own_to_check, modified_seq_int, modified_seq_int_size);
+
+ unsigned int i;
+ int *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_int_in_own_to_check, i, ele, it)
+ free(ele);
+
+ eina_array_free(_array_int_in_own_to_check);
+ _array_int_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_Array *_array_int_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_array_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_array_new(default_step);
+ eina_array_push(*arr, _new_int(0x0));
+ eina_array_push(*arr, _new_int(0x2A));
+ eina_array_push(*arr, _new_int(0x42));
+ _array_int_out_to_check = *arr;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_array_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_int_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_int_equal(_array_int_out_to_check, modified_seq_int, modified_seq_int_size);
+
+ unsigned int i;
+ int *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_int_out_to_check, i, ele, it)
+ free(ele);
+
+ eina_array_free(_array_int_out_to_check);
+ _array_int_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_array_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_array_new(default_step);
+ eina_array_push(*arr, _new_int(0x0));
+ eina_array_push(*arr, _new_int(0x2A));
+ eina_array_push(*arr, _new_int(0x42));
+ return EINA_TRUE;
+}
+
+Eina_Array *_array_int_return_to_check = NULL;
+
+Eina_Array *_test_testing_eina_array_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Array *arr = eina_array_new(default_step);
+ eina_array_push(arr, _new_int(0x0));
+ eina_array_push(arr, _new_int(0x2A));
+ eina_array_push(arr, _new_int(0x42));
+ _array_int_return_to_check = arr;
+ return arr;
+}
+Eina_Bool _test_testing_check_eina_array_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_int_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_int_equal(_array_int_return_to_check, modified_seq_int, modified_seq_int_size);
+
+ unsigned int i;
+ int *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_int_return_to_check, i, ele, it)
+ free(ele);
+
+ eina_array_free(_array_int_return_to_check);
+ _array_int_return_to_check = NULL;
+ return r;
+}
+
+Eina_Array *_test_testing_eina_array_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Array *arr = eina_array_new(default_step);
+ eina_array_push(arr, _new_int(0x0));
+ eina_array_push(arr, _new_int(0x2A));
+ eina_array_push(arr, _new_int(0x42));
+ return arr;
+}
+
+// String
+
+Eina_Bool _array_str_equal(const Eina_Array *arr, const char * const base[], unsigned int len)
+{
+ if (eina_array_count(arr) != len)
+ return EINA_FALSE;
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ if (0 != strcmp(eina_array_data_get(arr, i), base[i]))
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_array_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+{
+ Eina_Bool r = _array_str_equal(arr, base_seq_str, base_seq_str_size);
+ eina_array_push(arr, strdup("42"));
+ eina_array_push(arr, strdup("43"));
+ eina_array_push(arr, strdup("33"));
+ return r;
+}
+
+static Eina_Array *_array_str_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+{
+ Eina_Bool r = _array_str_equal(arr, base_seq_str, base_seq_str_size);
+ eina_array_push(arr, strdup("42"));
+ eina_array_push(arr, strdup("43"));
+ eina_array_push(arr, strdup("33"));
+ _array_str_in_own_to_check = arr;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_str_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_str_equal(_array_str_in_own_to_check, modified_seq_str, modified_seq_str_size);
+
+ unsigned int i;
+ char *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_str_in_own_to_check, i, ele, it)
+ free(ele);
+
+ eina_array_free(_array_str_in_own_to_check);
+ _array_str_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_Array *_array_str_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_array_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_array_new(default_step);
+ eina_array_push(*arr, strdup("0x0"));
+ eina_array_push(*arr, strdup("0x2A"));
+ eina_array_push(*arr, strdup("0x42"));
+ _array_str_out_to_check = *arr;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_array_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_str_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_str_equal(_array_str_out_to_check, modified_seq_str, modified_seq_str_size);
+
+ unsigned int i;
+ char *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_str_out_to_check, i, ele, it)
+ free(ele);
+
+ eina_array_free(_array_str_out_to_check);
+ _array_str_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_array_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_array_new(default_step);
+ eina_array_push(*arr, strdup("0x0"));
+ eina_array_push(*arr, strdup("0x2A"));
+ eina_array_push(*arr, strdup("0x42"));
+ return EINA_TRUE;
+}
+
+Eina_Array *_array_str_return_to_check = NULL;
+
+Eina_Array *_test_testing_eina_array_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Array *arr = eina_array_new(default_step);
+ eina_array_push(arr, strdup("0x0"));
+ eina_array_push(arr, strdup("0x2A"));
+ eina_array_push(arr, strdup("0x42"));
+ _array_str_return_to_check = arr;
+ return arr;
+}
+Eina_Bool _test_testing_check_eina_array_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_str_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_str_equal(_array_str_return_to_check, modified_seq_str, modified_seq_str_size);
+
+ unsigned int i;
+ char *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_str_return_to_check, i, ele, it)
+ free(ele);
+
+ eina_array_free(_array_str_return_to_check);
+ _array_str_return_to_check = NULL;
+ return r;
+}
+
+Eina_Array *_test_testing_eina_array_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Array *arr = eina_array_new(default_step);
+ eina_array_push(arr, strdup("0x0"));
+ eina_array_push(arr, strdup("0x2A"));
+ eina_array_push(arr, strdup("0x42"));
+ return arr;
+}
+
+// Object
+
+Eina_Bool _array_obj_equal(const Eina_Array *arr, const Test_Numberwrapper * const base[], unsigned int len)
+{
+ if (eina_array_count(arr) != len)
+ return EINA_FALSE;
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ const Test_Numberwrapper *eo = eina_array_data_get(arr, i);
+ int a = test_numberwrapper_number_get(eo);
+ int b = test_numberwrapper_number_get(base[i]);
+ if (a != b)
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_array_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+{
+ Eina_Bool r = _array_obj_equal(arr, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+ eina_array_push(arr, _new_obj(42));
+ eina_array_push(arr, _new_obj(43));
+ eina_array_push(arr, _new_obj(33));
+ return r;
+}
+
+static Eina_Array *_array_obj_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+{
+ Eina_Bool r = _array_obj_equal(arr, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+ eina_array_push(arr, _new_obj(42));
+ eina_array_push(arr, _new_obj(43));
+ eina_array_push(arr, _new_obj(33));
+ _array_obj_in_own_to_check = arr;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_obj_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_obj_equal(_array_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ unsigned int i;
+ Test_Numberwrapper *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_obj_in_own_to_check, i, ele, it)
+ efl_unref(ele);
+
+ eina_array_free(_array_obj_in_own_to_check);
+ _array_obj_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_Array *_array_obj_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_array_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_array_new(default_step);
+ eina_array_push(*arr, _new_obj(0x0));
+ eina_array_push(*arr, _new_obj(0x2A));
+ eina_array_push(*arr, _new_obj(0x42));
+ _array_obj_out_to_check = *arr;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_array_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_obj_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_obj_equal(_array_obj_out_to_check, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ unsigned int i;
+ Test_Numberwrapper *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_obj_out_to_check, i, ele, it)
+ efl_unref(ele);
+
+ eina_array_free(_array_obj_out_to_check);
+ _array_obj_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_array_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_array_new(default_step);
+ eina_array_push(*arr, _new_obj(0x0));
+ eina_array_push(*arr, _new_obj(0x2A));
+ eina_array_push(*arr, _new_obj(0x42));
+ return EINA_TRUE;
+}
+
+Eina_Array *_array_obj_return_to_check = NULL;
+
+Eina_Array *_test_testing_eina_array_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Array *arr = eina_array_new(default_step);
+ eina_array_push(arr, _new_obj(0x0));
+ eina_array_push(arr, _new_obj(0x2A));
+ eina_array_push(arr, _new_obj(0x42));
+ _array_obj_return_to_check = arr;
+ return arr;
+}
+Eina_Bool _test_testing_check_eina_array_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_array_obj_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _array_obj_equal(_array_obj_return_to_check, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ unsigned int i;
+ Test_Numberwrapper *ele;
+ Eina_Array_Iterator it;
+ EINA_ARRAY_ITER_NEXT(_array_obj_return_to_check, i, ele, it)
+ efl_unref(ele);
+
+ eina_array_free(_array_obj_return_to_check);
+ _array_obj_return_to_check = NULL;
+ return r;
+}
+
+Eina_Array *_test_testing_eina_array_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Array *arr = eina_array_new(default_step);
+ eina_array_push(arr, _new_obj(0x0));
+ eina_array_push(arr, _new_obj(0x2A));
+ eina_array_push(arr, _new_obj(0x42));
+ return arr;
+}
+
+Eina_Array *_test_testing_eina_array_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
+{
+ return arr;
+}
+
+// //
+// Inarray
+//
+
+// Integer
+
+Eina_Bool _inarray_int_equal(const Eina_Inarray *arr, const int base[], unsigned int len)
+{
+ if (eina_inarray_count(arr) != len)
+ return EINA_FALSE;
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ if (*((int*)eina_inarray_nth(arr, i)) != base[i])
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_inarray_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+{
+ Eina_Bool r = _inarray_int_equal(arr, base_seq_int, base_seq_int_size);
+ eina_inarray_push(arr, _int_ref(42));
+ eina_inarray_push(arr, _int_ref(43));
+ eina_inarray_push(arr, _int_ref(33));
+ return r;
+}
+
+static Eina_Inarray *_inarray_int_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+{
+ Eina_Bool r = _inarray_int_equal(arr, base_seq_int, base_seq_int_size);
+ eina_inarray_push(arr, _int_ref(42));
+ eina_inarray_push(arr, _int_ref(43));
+ eina_inarray_push(arr, _int_ref(33));
+ _inarray_int_in_own_to_check = arr;
+ return r;
+}
+Eina_Bool _test_testing_check_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_int_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_int_equal(_inarray_int_in_own_to_check, modified_seq_int, modified_seq_int_size);
+
+ eina_inarray_free(_inarray_int_in_own_to_check);
+ _inarray_int_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_Inarray *_inarray_int_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inarray_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_inarray_new(sizeof(int), 0);
+ eina_inarray_push(*arr, _int_ref(0x0));
+ eina_inarray_push(*arr, _int_ref(0x2A));
+ eina_inarray_push(*arr, _int_ref(0x42));
+ _inarray_int_out_to_check = *arr;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_inarray_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_int_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_int_equal(_inarray_int_out_to_check, modified_seq_int, modified_seq_int_size);
+
+ eina_inarray_free(_inarray_int_out_to_check);
+ _inarray_int_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_inarray_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_inarray_new(sizeof(int), 0);
+ eina_inarray_push(*arr, _int_ref(0x0));
+ eina_inarray_push(*arr, _int_ref(0x2A));
+ eina_inarray_push(*arr, _int_ref(0x42));
+ return EINA_TRUE;
+}
+
+Eina_Inarray *_inarray_int_return_to_check = NULL;
+
+Eina_Inarray *_test_testing_eina_inarray_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inarray *arr = eina_inarray_new(sizeof(int), 0);
+ eina_inarray_push(arr, _int_ref(0x0));
+ eina_inarray_push(arr, _int_ref(0x2A));
+ eina_inarray_push(arr, _int_ref(0x42));
+ _inarray_int_return_to_check = arr;
+ return arr;
+}
+Eina_Bool _test_testing_check_eina_inarray_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_int_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_int_equal(_inarray_int_return_to_check, modified_seq_int, modified_seq_int_size);
+
+ eina_inarray_free(_inarray_int_return_to_check);
+ _inarray_int_return_to_check = NULL;
+ return r;
+}
+
+Eina_Inarray *_test_testing_eina_inarray_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inarray *arr = eina_inarray_new(sizeof(int), 0);
+ eina_inarray_push(arr, _int_ref(0x0));
+ eina_inarray_push(arr, _int_ref(0x2A));
+ eina_inarray_push(arr, _int_ref(0x42));
+ return arr;
+}
+
+// String
+
+Eina_Bool _inarray_str_equal(const Eina_Inarray *arr, const char * const base[], unsigned int len)
+{
+ if (eina_inarray_count(arr) != len)
+ return EINA_FALSE;
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ if (0 != strcmp(*((char**)eina_inarray_nth(arr, i)), base[i]))
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_inarray_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+{
+ Eina_Bool r = _inarray_str_equal(arr, base_seq_str, base_seq_str_size);
+ eina_inarray_push(arr, _new_str_ref("42"));
+ eina_inarray_push(arr, _new_str_ref("43"));
+ eina_inarray_push(arr, _new_str_ref("33"));
+ return r;
+}
+
+static Eina_Inarray *_inarray_str_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+{
+ Eina_Bool r = _inarray_str_equal(arr, base_seq_str, base_seq_str_size);
+ eina_inarray_push(arr, _new_str_ref("42"));
+ eina_inarray_push(arr, _new_str_ref("43"));
+ eina_inarray_push(arr, _new_str_ref("33"));
+ _inarray_str_in_own_to_check = arr;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_str_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_str_equal(_inarray_str_in_own_to_check, modified_seq_str, modified_seq_str_size);
+
+ char **ele;
+ EINA_INARRAY_FOREACH(_inarray_str_in_own_to_check, ele)
+ free(*ele);
+
+ eina_inarray_free(_inarray_str_in_own_to_check);
+ _inarray_str_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_Inarray *_inarray_str_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inarray_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_inarray_new(sizeof(char*), 0);
+ eina_inarray_push(*arr, _new_str_ref("0x0"));
+ eina_inarray_push(*arr, _new_str_ref("0x2A"));
+ eina_inarray_push(*arr, _new_str_ref("0x42"));
+ _inarray_str_out_to_check = *arr;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_inarray_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_str_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_str_equal(_inarray_str_out_to_check, modified_seq_str, modified_seq_str_size);
+
+ char **ele;
+ EINA_INARRAY_FOREACH(_inarray_str_out_to_check, ele)
+ free(*ele);
+
+ eina_inarray_free(_inarray_str_out_to_check);
+ _inarray_str_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_inarray_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_inarray_new(sizeof(char*), 0);
+ eina_inarray_push(*arr, _new_str_ref("0x0"));
+ eina_inarray_push(*arr, _new_str_ref("0x2A"));
+ eina_inarray_push(*arr, _new_str_ref("0x42"));
+ return EINA_TRUE;
+}
+
+Eina_Inarray *_inarray_str_return_to_check = NULL;
+
+Eina_Inarray *_test_testing_eina_inarray_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inarray *arr = eina_inarray_new(sizeof(char*), 0);
+ eina_inarray_push(arr, _new_str_ref("0x0"));
+ eina_inarray_push(arr, _new_str_ref("0x2A"));
+ eina_inarray_push(arr, _new_str_ref("0x42"));
+ _inarray_str_return_to_check = arr;
+ return arr;
+}
+Eina_Bool _test_testing_check_eina_inarray_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_str_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_str_equal(_inarray_str_return_to_check, modified_seq_str, modified_seq_str_size);
+
+ char **ele;
+ EINA_INARRAY_FOREACH(_inarray_str_return_to_check, ele)
+ free(*ele);
+
+ eina_inarray_free(_inarray_str_return_to_check);
+ _inarray_str_return_to_check = NULL;
+ return r;
+}
+
+Eina_Inarray *_test_testing_eina_inarray_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inarray *arr = eina_inarray_new(sizeof(char*), 0);
+ eina_inarray_push(arr, _new_str_ref("0x0"));
+ eina_inarray_push(arr, _new_str_ref("0x2A"));
+ eina_inarray_push(arr, _new_str_ref("0x42"));
+ return arr;
+}
+
+// Object
+
+Eina_Bool _inarray_obj_equal(const Eina_Inarray *arr, const Test_Numberwrapper * const base[], unsigned int len)
+{
+ if (eina_inarray_count(arr) != len)
+ return EINA_FALSE;
+ for (unsigned int i = 0; i < len; ++i)
+ {
+ const Test_Numberwrapper **eo = eina_inarray_nth(arr, i);
+ int a = test_numberwrapper_number_get(*eo);
+ int b = test_numberwrapper_number_get(base[i]);
+ if (a != b)
+ return EINA_FALSE;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_inarray_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+{
+ Eina_Bool r = _inarray_obj_equal(arr, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+ eina_inarray_push(arr, _new_obj_ref(42));
+ eina_inarray_push(arr, _new_obj_ref(43));
+ eina_inarray_push(arr, _new_obj_ref(33));
+ return r;
+}
+
+static Eina_Inarray *_inarray_obj_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+{
+ Eina_Bool r = _inarray_obj_equal(arr, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+ eina_inarray_push(arr, _new_obj_ref(42));
+ eina_inarray_push(arr, _new_obj_ref(43));
+ eina_inarray_push(arr, _new_obj_ref(33));
+ _inarray_obj_in_own_to_check = arr;
+ return r;
+}
+Eina_Bool _test_testing_check_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_obj_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_obj_equal(_inarray_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ Test_Numberwrapper **ele;
+ EINA_INARRAY_FOREACH(_inarray_obj_in_own_to_check, ele)
+ efl_unref(*ele);
+
+ eina_inarray_free(_inarray_obj_in_own_to_check);
+ _inarray_obj_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_Inarray *_inarray_obj_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inarray_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_inarray_new(sizeof(Eo*), 0);
+ eina_inarray_push(*arr, _new_obj_ref(0x0));
+ eina_inarray_push(*arr, _new_obj_ref(0x2A));
+ eina_inarray_push(*arr, _new_obj_ref(0x42));
+ _inarray_obj_out_to_check = *arr;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_inarray_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_obj_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_obj_equal(_inarray_obj_out_to_check, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ Test_Numberwrapper **ele;
+ EINA_INARRAY_FOREACH(_inarray_obj_out_to_check, ele)
+ efl_unref(*ele);
+
+ eina_inarray_free(_inarray_obj_out_to_check);
+ _inarray_obj_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_inarray_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray **arr)
+{
+ if (!arr) return EINA_FALSE;
+ *arr = eina_inarray_new(sizeof(Eo*), 0);
+ eina_inarray_push(*arr, _new_obj_ref(0x0));
+ eina_inarray_push(*arr, _new_obj_ref(0x2A));
+ eina_inarray_push(*arr, _new_obj_ref(0x42));
+ return EINA_TRUE;
+}
+
+Eina_Inarray *_inarray_obj_return_to_check = NULL;
+
+Eina_Inarray *_test_testing_eina_inarray_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inarray *arr = eina_inarray_new(sizeof(Eo*), 0);
+ eina_inarray_push(arr, _new_obj_ref(0x0));
+ eina_inarray_push(arr, _new_obj_ref(0x2A));
+ eina_inarray_push(arr, _new_obj_ref(0x42));
+ _inarray_obj_return_to_check = arr;
+ return arr;
+}
+Eina_Bool _test_testing_check_eina_inarray_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_inarray_obj_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _inarray_obj_equal(_inarray_obj_return_to_check, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ Test_Numberwrapper **ele;
+ EINA_INARRAY_FOREACH(_inarray_obj_return_to_check, ele)
+ efl_unref(*ele);
+
+ eina_inarray_free(_inarray_obj_return_to_check);
+ _inarray_obj_return_to_check = NULL;
+ return r;
+}
+
+Eina_Inarray *_test_testing_eina_inarray_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inarray *arr = eina_inarray_new(sizeof(Eo*), 0);
+ eina_inarray_push(arr, _new_obj_ref(0x0));
+ eina_inarray_push(arr, _new_obj_ref(0x2A));
+ eina_inarray_push(arr, _new_obj_ref(0x42));
+ return arr;
+}
+
+Eina_Inarray *_test_testing_eina_inarray_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
+{
+ return arr;
+}
+
+// //
+// List
+//
+
+// Integer
+
+Eina_Bool _list_int_equal(const Eina_List *lst, const int base[], unsigned int len)
+{
+ if (eina_list_count(lst) != len)
+ return EINA_FALSE;
+
+ const Eina_List *l;
+ int *data;
+ int i = 0;
+ EINA_LIST_FOREACH(lst, l, data)
+ {
+ if (*data != base[i])
+ return EINA_FALSE;
+ ++i;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_list_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+{
+ Eina_Bool r = _list_int_equal(lst, base_seq_int, base_seq_int_size);
+ return r;
+}
+
+static Eina_List *_list_int_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+{
+ Eina_Bool r = _list_int_equal(lst, base_seq_int, base_seq_int_size);
+ if (!r) return r;
+
+ lst = eina_list_append(lst, _new_int(42));
+ lst = eina_list_append(lst, _new_int(43));
+ lst = eina_list_append(lst, _new_int(33));
+ _list_int_in_own_to_check = lst;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_int_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_int_equal(_list_int_in_own_to_check, modified_seq_int, modified_seq_int_size);
+ if (!r) return r;
+
+ int *ele;
+ EINA_LIST_FREE(_list_int_in_own_to_check, ele)
+ free(ele);
+ _list_int_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_List *_list_int_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_list_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_list_append(*lst, _new_int(0x0));
+ *lst = eina_list_append(*lst, _new_int(0x2A));
+ *lst = eina_list_append(*lst, _new_int(0x42));
+ _list_int_out_to_check = *lst;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_list_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_int_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_int_equal(_list_int_out_to_check, base_seq_int, base_seq_int_size);
+ if (!r) return r;
+
+ int *ele;
+ EINA_LIST_FREE(_list_int_out_to_check, ele)
+ free(ele);
+
+ _list_int_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_list_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_list_append(*lst, _new_int(0x0));
+ *lst = eina_list_append(*lst, _new_int(0x2A));
+ *lst = eina_list_append(*lst, _new_int(0x42));
+ return EINA_TRUE;
+}
+
+Eina_List *_list_int_return_to_check = NULL;
+
+Eina_List *_test_testing_eina_list_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_List *lst = NULL;
+ lst = eina_list_append(lst, _new_int(0x0));
+ lst = eina_list_append(lst, _new_int(0x2A));
+ lst = eina_list_append(lst, _new_int(0x42));
+ _list_int_return_to_check = lst;
+ return lst;
+}
+Eina_Bool _test_testing_check_eina_list_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_int_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_int_equal(_list_int_return_to_check, base_seq_int, base_seq_int_size);
+ if (!r) return r;
+
+ int *ele;
+ EINA_LIST_FREE(_list_int_return_to_check, ele)
+ free(ele);
+
+ _list_int_return_to_check = NULL;
+ return r;
+}
+
+Eina_List *_test_testing_eina_list_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_List *lst = NULL;
+ lst = eina_list_append(lst, _new_int(0x0));
+ lst = eina_list_append(lst, _new_int(0x2A));
+ lst = eina_list_append(lst, _new_int(0x42));
+ return lst;
+}
+
+// String
+
+Eina_Bool _list_str_equal(const Eina_List *lst, const char * const base[], unsigned int len)
+{
+ if (eina_list_count(lst) != len)
+ return EINA_FALSE;
+
+ const Eina_List *l;
+ char *data;
+ int i = 0;
+ EINA_LIST_FOREACH(lst, l, data)
+ {
+ if (0 != strcmp(data, base[i]))
+ return EINA_FALSE;
+ ++i;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_list_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+{
+ Eina_Bool r = _list_str_equal(lst, base_seq_str, base_seq_str_size);
+ return r;
+}
+
+static Eina_List *_list_str_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+{
+ Eina_Bool r = _list_str_equal(lst, base_seq_str, base_seq_str_size);
+ if (!r) return r;
+ lst = eina_list_append(lst, strdup("42"));
+ lst = eina_list_append(lst, strdup("43"));
+ lst = eina_list_append(lst, strdup("33"));
+ _list_str_in_own_to_check = lst;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_str_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_str_equal(_list_str_in_own_to_check, modified_seq_str, modified_seq_str_size);
+ if (!r) return r;
+
+ char *ele;
+ EINA_LIST_FREE(_list_str_in_own_to_check, ele)
+ free(ele);
+
+ _list_str_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_List *_list_str_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_list_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_list_append(*lst, strdup("0x0"));
+ *lst = eina_list_append(*lst, strdup("0x2A"));
+ *lst = eina_list_append(*lst, strdup("0x42"));
+ _list_str_out_to_check = *lst;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_list_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_str_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_str_equal(_list_str_out_to_check, base_seq_str, base_seq_str_size);
+ if (!r) return r;
+
+ char *ele;
+ EINA_LIST_FREE(_list_str_out_to_check, ele)
+ free(ele);
+
+ _list_str_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_list_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_list_append(*lst, strdup("0x0"));
+ *lst = eina_list_append(*lst, strdup("0x2A"));
+ *lst = eina_list_append(*lst, strdup("0x42"));
+ return EINA_TRUE;
+}
+
+Eina_List *_list_str_return_to_check = NULL;
+
+Eina_List *_test_testing_eina_list_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_List *lst = NULL;
+ lst = eina_list_append(lst, strdup("0x0"));
+ lst = eina_list_append(lst, strdup("0x2A"));
+ lst = eina_list_append(lst, strdup("0x42"));
+ _list_str_return_to_check = lst;
+ return lst;
+}
+Eina_Bool _test_testing_check_eina_list_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_str_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_str_equal(_list_str_return_to_check, base_seq_str, base_seq_str_size);
+ if (!r) return r;
+
+ char *ele;
+ EINA_LIST_FREE(_list_str_return_to_check, ele)
+ free(ele);
+
+ _list_str_return_to_check = NULL;
+ return r;
+}
+
+Eina_List *_test_testing_eina_list_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_List *lst = NULL;
+ lst = eina_list_append(lst, strdup("0x0"));
+ lst = eina_list_append(lst, strdup("0x2A"));
+ lst = eina_list_append(lst, strdup("0x42"));
+ return lst;
+}
+
+// Object
+
+Eina_Bool _list_obj_equal(const Eina_List *lst, const Test_Numberwrapper * const base[], unsigned int len)
+{
+ if (eina_list_count(lst) != len)
+ return EINA_FALSE;
+
+ const Eina_List *l;
+ Test_Numberwrapper *eo;
+ int i = 0;
+ EINA_LIST_FOREACH(lst, l, eo)
+ {
+ int a = test_numberwrapper_number_get(eo);
+ int b = test_numberwrapper_number_get(base[i]);
+ if (a != b)
+ return EINA_FALSE;
+ ++i;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_list_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+{
+ Eina_Bool r = _list_obj_equal(lst, base_seq_obj, base_seq_obj_size);
+ return r;
+}
+
+static Eina_List *_list_obj_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+{
+ Eina_Bool r = _list_obj_equal(lst, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+ lst = eina_list_append(lst, _new_obj(42));
+ lst = eina_list_append(lst, _new_obj(43));
+ lst = eina_list_append(lst, _new_obj(33));
+ _list_obj_in_own_to_check = lst;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_obj_in_own_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_obj_equal(_list_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ Test_Numberwrapper *ele;
+ EINA_LIST_FREE(_list_obj_in_own_to_check, ele)
+ efl_unref(ele);
+
+ _list_obj_in_own_to_check = NULL;
+ return r;
+}
+
+Eina_List *_list_obj_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_list_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_list_append(*lst, _new_obj(0x0));
+ *lst = eina_list_append(*lst, _new_obj(0x2A));
+ *lst = eina_list_append(*lst, _new_obj(0x42));
+ _list_obj_out_to_check = *lst;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_list_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_obj_out_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_obj_equal(_list_obj_out_to_check, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+
+ Test_Numberwrapper *ele;
+ EINA_LIST_FREE(_list_obj_out_to_check, ele)
+ efl_unref(ele);
+
+ _list_obj_out_to_check = NULL;
+ return r;
+}
+
+Eina_Bool _test_testing_eina_list_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_list_append(*lst, _new_obj(0x0));
+ *lst = eina_list_append(*lst, _new_obj(0x2A));
+ *lst = eina_list_append(*lst, _new_obj(0x42));
+ return EINA_TRUE;
+}
+
+Eina_List *_list_obj_return_to_check = NULL;
+
+Eina_List *_test_testing_eina_list_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_List *lst = NULL;
+ lst = eina_list_append(lst, _new_obj(0x0));
+ lst = eina_list_append(lst, _new_obj(0x2A));
+ lst = eina_list_append(lst, _new_obj(0x42));
+ _list_obj_return_to_check = lst;
+ return lst;
+}
+Eina_Bool _test_testing_check_eina_list_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_list_obj_return_to_check) return EINA_FALSE;
+
+ Eina_Bool r = _list_obj_equal(_list_obj_return_to_check, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+
+ Test_Numberwrapper *ele;
+ EINA_LIST_FREE(_list_obj_return_to_check, ele)
+ efl_unref(ele);
+
+ _list_obj_return_to_check = NULL;
+ return r;
+}
+
+Eina_List *_test_testing_eina_list_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_List *lst = NULL;
+ lst = eina_list_append(lst, _new_obj(0x0));
+ lst = eina_list_append(lst, _new_obj(0x2A));
+ lst = eina_list_append(lst, _new_obj(0x42));
+ return lst;
+}
+
+Eina_List *_test_testing_eina_list_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
+{
+ return lst;
+}
+
+
+// //
+// Inlist
+//
+
+// Integer
+
+typedef struct _Test_Inlist_Node_Int
+{
+ EINA_INLIST;
+ int val;
+} Test_Inlist_Node_Int;
+
+
+Eina_Inlist *_new_inlist_int(int v)
+{
+ Test_Inlist_Node_Int *node = malloc(sizeof(Test_Inlist_Node_Int));
+ node->val = v;
+ return EINA_INLIST_GET(node);
+}
+
+Eina_Bool _inlist_int_equal(const Eina_Inlist *lst, const int base[], unsigned int len)
+{
+ if (eina_inlist_count(lst) != len)
+ return EINA_FALSE;
+
+ const Test_Inlist_Node_Int *node;
+ int i = 0;
+ EINA_INLIST_FOREACH(lst, node)
+ {
+ if (node->val != base[i])
+ return EINA_FALSE;
+ ++i;
+ }
+
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_inlist_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+{
+ Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
+ return r;
+}
+
+static Eina_Inlist *_inlist_int_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+{
+ Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
+ if (!r) return r;
+
+ lst = eina_inlist_append(lst, _new_inlist_int(42));
+ lst = eina_inlist_append(lst, _new_inlist_int(43));
+ lst = eina_inlist_append(lst, _new_inlist_int(33));
+ _inlist_int_in_own_to_check = lst;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_int_in_own_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_int_in_own_to_check = NULL;
+
+ Eina_Bool r = _inlist_int_equal(lst, modified_seq_int, modified_seq_int_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Int *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ free(node);
+ }
+ return r;
+}
+
+Eina_Inlist *_inlist_int_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inlist_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_inlist_append(*lst, _new_inlist_int(0x0));
+ *lst = eina_inlist_append(*lst, _new_inlist_int(0x2A));
+ *lst = eina_inlist_append(*lst, _new_inlist_int(0x42));
+ _inlist_int_out_to_check = *lst;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_inlist_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_int_out_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_int_out_to_check = NULL;
+
+ Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Int *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Bool _test_testing_eina_inlist_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_inlist_append(*lst, _new_inlist_int(0x0));
+ *lst = eina_inlist_append(*lst, _new_inlist_int(0x2A));
+ *lst = eina_inlist_append(*lst, _new_inlist_int(0x42));
+ return EINA_TRUE;
+}
+
+Eina_Inlist *_inlist_int_return_to_check = NULL;
+
+Eina_Inlist *_test_testing_eina_inlist_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = NULL;
+ lst = eina_inlist_append(lst, _new_inlist_int(0x0));
+ lst = eina_inlist_append(lst, _new_inlist_int(0x2A));
+ lst = eina_inlist_append(lst, _new_inlist_int(0x42));
+ _inlist_int_return_to_check = lst;
+ return lst;
+}
+Eina_Bool _test_testing_check_eina_inlist_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_int_return_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_int_return_to_check = NULL;
+
+ Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Int *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Inlist *_test_testing_eina_inlist_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = NULL;
+ lst = eina_inlist_append(lst, _new_inlist_int(0x0));
+ lst = eina_inlist_append(lst, _new_inlist_int(0x2A));
+ lst = eina_inlist_append(lst, _new_inlist_int(0x42));
+ return lst;
+}
+
+// String
+
+typedef struct _Test_Inlist_Node_Str
+{
+ EINA_INLIST;
+ char *val;
+} Test_Inlist_Node_Str;
+
+
+Eina_Inlist *_new_inlist_str(const char *v)
+{
+ Test_Inlist_Node_Str *node = malloc(sizeof(Test_Inlist_Node_Str));
+ node->val = strdup(v);
+ return EINA_INLIST_GET(node);
+}
+
+Eina_Bool _inlist_str_equal(const Eina_Inlist *lst, const char * const base[], unsigned int len)
+{
+ if (eina_inlist_count(lst) != len)
+ return EINA_FALSE;
+
+ const Test_Inlist_Node_Str *node;
+ int i = 0;
+ EINA_INLIST_FOREACH(lst, node)
+ {
+ if (0 != strcmp(node->val, base[i]))
+ return EINA_FALSE;
+ ++i;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_inlist_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+{
+ Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
+ return r;
+}
+
+static Eina_Inlist *_inlist_str_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+{
+ Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
+ if (!r) return r;
+ lst = eina_inlist_append(lst, _new_inlist_str("42"));
+ lst = eina_inlist_append(lst, _new_inlist_str("43"));
+ lst = eina_inlist_append(lst, _new_inlist_str("33"));
+ _inlist_str_in_own_to_check = lst;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_str_in_own_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_str_in_own_to_check = NULL;
+
+ Eina_Bool r = _inlist_str_equal(lst, modified_seq_str, modified_seq_str_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Str *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ free(node->val);
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Inlist *_inlist_str_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inlist_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_inlist_append(*lst, _new_inlist_str("0x0"));
+ *lst = eina_inlist_append(*lst, _new_inlist_str("0x2A"));
+ *lst = eina_inlist_append(*lst, _new_inlist_str("0x42"));
+ _inlist_str_out_to_check = *lst;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_inlist_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_str_out_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_str_out_to_check = NULL;
+
+ Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Str *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ free(node->val);
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Bool _test_testing_eina_inlist_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_inlist_append(*lst, _new_inlist_str("0x0"));
+ *lst = eina_inlist_append(*lst, _new_inlist_str("0x2A"));
+ *lst = eina_inlist_append(*lst, _new_inlist_str("0x42"));
+ return EINA_TRUE;
+}
+
+Eina_Inlist *_inlist_str_return_to_check = NULL;
+
+Eina_Inlist *_test_testing_eina_inlist_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = NULL;
+ lst = eina_inlist_append(lst, _new_inlist_str("0x0"));
+ lst = eina_inlist_append(lst, _new_inlist_str("0x2A"));
+ lst = eina_inlist_append(lst, _new_inlist_str("0x42"));
+ _inlist_str_return_to_check = lst;
+ return lst;
+}
+Eina_Bool _test_testing_check_eina_inlist_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_str_return_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_str_return_to_check = NULL;
+
+ Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Str *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ free(node->val);
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Inlist *_test_testing_eina_inlist_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = NULL;
+ lst = eina_inlist_append(lst, _new_inlist_str("0x0"));
+ lst = eina_inlist_append(lst, _new_inlist_str("0x2A"));
+ lst = eina_inlist_append(lst, _new_inlist_str("0x42"));
+ return lst;
+}
+
+// Object
+
+typedef struct _Test_Inlist_Node_Obj
+{
+ EINA_INLIST;
+ Test_Numberwrapper *val;
+} Test_Inlist_Node_Obj;
+
+
+Eina_Inlist *_new_inlist_obj(int v)
+{
+ Test_Inlist_Node_Obj *node = malloc(sizeof(Test_Inlist_Node_Obj));
+ node->val = _new_obj(v);
+ return EINA_INLIST_GET(node);
+}
+
+Eina_Bool _inlist_obj_equal(const Eina_Inlist *lst, const Test_Numberwrapper * const base[], unsigned int len)
+{
+ if (eina_inlist_count(lst) != len)
+ return EINA_FALSE;
+
+ const Test_Inlist_Node_Obj *node;
+ int i = 0;
+ EINA_INLIST_FOREACH(lst, node)
+ {
+ int a = test_numberwrapper_number_get(node->val);
+ int b = test_numberwrapper_number_get(base[i]);
+ if (a != b)
+ return EINA_FALSE;
+ ++i;
+ }
+ return EINA_TRUE;
+}
+
+Eina_Bool _test_testing_eina_inlist_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+{
+ Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
+ return r;
+}
+
+static Eina_Inlist *_inlist_obj_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+{
+ Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+ lst = eina_inlist_append(lst, _new_inlist_obj(42));
+ lst = eina_inlist_append(lst, _new_inlist_obj(43));
+ lst = eina_inlist_append(lst, _new_inlist_obj(33));
+ _inlist_obj_in_own_to_check = lst;
+ return r;
+}
+
+Eina_Bool _test_testing_check_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_obj_in_own_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_obj_in_own_to_check = NULL;
+
+ Eina_Bool r = _inlist_obj_equal(lst, modified_seq_obj, modified_seq_obj_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Obj *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ efl_unref(node->val);
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Inlist *_inlist_obj_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_inlist_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_inlist_append(*lst, _new_inlist_obj(0x0));
+ *lst = eina_inlist_append(*lst, _new_inlist_obj(0x2A));
+ *lst = eina_inlist_append(*lst, _new_inlist_obj(0x42));
+ _inlist_obj_out_to_check = *lst;
+ return EINA_TRUE;
+}
+Eina_Bool _test_testing_check_eina_inlist_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_obj_out_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_obj_out_to_check = NULL;
+
+ Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Obj *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ efl_unref(node->val);
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Bool _test_testing_eina_inlist_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist **lst)
+{
+ if (!lst) return EINA_FALSE;
+ *lst = eina_inlist_append(*lst, _new_inlist_obj(0x0));
+ *lst = eina_inlist_append(*lst, _new_inlist_obj(0x2A));
+ *lst = eina_inlist_append(*lst, _new_inlist_obj(0x42));
+ return EINA_TRUE;
+}
+
+Eina_Inlist *_inlist_obj_return_to_check = NULL;
+
+Eina_Inlist *_test_testing_eina_inlist_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = NULL;
+ lst = eina_inlist_append(lst, _new_inlist_obj(0x0));
+ lst = eina_inlist_append(lst, _new_inlist_obj(0x2A));
+ lst = eina_inlist_append(lst, _new_inlist_obj(0x42));
+ _inlist_obj_return_to_check = lst;
+ return lst;
+}
+Eina_Bool _test_testing_check_eina_inlist_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = _inlist_obj_return_to_check;
+ if (!lst) return EINA_FALSE;
+ _inlist_obj_return_to_check = NULL;
+
+ Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
+ if (!r) return r;
+
+ Test_Inlist_Node_Obj *node;
+ EINA_INLIST_FREE(lst, node)
+ {
+ lst = eina_inlist_remove(lst, EINA_INLIST_GET(node));
+ efl_unref(node->val);
+ free(node);
+ }
+
+ return r;
+}
+
+Eina_Inlist *_test_testing_eina_inlist_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Inlist *lst = NULL;
+ lst = eina_inlist_append(lst, _new_inlist_obj(0x0));
+ lst = eina_inlist_append(lst, _new_inlist_obj(0x2A));
+ lst = eina_inlist_append(lst, _new_inlist_obj(0x42));
+ return lst;
+}
+
+Eina_Inlist *_test_testing_eina_inlist_obj_return_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
+{
+ return lst;
+}
+
+
+// //
+// Hash //
+// //
+
+// Integer //
+
+Eina_Bool _hash_int_check(const Eina_Hash *hsh, int key, int expected_val)
+{
+ int *val = eina_hash_find(hsh, &key);
+ return val && (*val == expected_val);
+}
+
+
+// int in
+
+Eina_Bool _test_testing_eina_hash_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+{
+ if (!_hash_int_check(hsh, 22, 222))
+ return EINA_FALSE;
+
+ int key = 44;
+ return eina_hash_add(hsh, &key, _new_int(444));
+}
+
+
+// int in own
+
+static Eina_Bool _hash_int_in_own_free_flag = EINA_FALSE;
+static void _hash_int_in_own_free_cb(void *data)
+{
+ _hash_int_in_own_free_flag = EINA_TRUE;
+ free(data);
+}
+static Eina_Hash *_hash_int_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_hash_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+{
+ eina_hash_free_cb_set(hsh, _hash_int_in_own_free_cb);
+
+ if (!_hash_int_check(hsh, 22, 222))
+ return EINA_FALSE;
+
+ _hash_int_in_own_to_check = hsh;
+
+ int key = 44;
+ return eina_hash_add(hsh, &key, _new_int(444));
+}
+Eina_Bool _test_testing_check_eina_hash_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_hash_int_in_own_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_int_in_own_to_check;
+
+ if (!_hash_int_check(hsh, 22, 222)
+ || !_hash_int_check(hsh, 44, 444)
+ || !_hash_int_check(hsh, 88, 888))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ return _hash_int_in_own_free_flag;
+}
+
+
+// int out
+
+static Eina_Bool _hash_int_out_free_flag = EINA_FALSE;
+static void _hash_int_out_free_cb(void *data)
+{
+ _hash_int_out_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Hash *_hash_int_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_hash_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+{
+ if (!hsh) return EINA_FALSE;
+
+ *hsh = eina_hash_int32_new(_hash_int_out_free_cb);
+
+ _hash_int_out_to_check = *hsh;
+
+ int key = 22;
+ return eina_hash_add(*hsh, &key, _new_int(222));
+}
+Eina_Bool _test_testing_check_eina_hash_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_hash_int_out_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_int_out_to_check;
+
+ if (!_hash_int_check(hsh, 22, 222)
+ || !_hash_int_check(hsh, 44, 444))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ _hash_int_out_to_check = NULL;
+ return _hash_int_out_free_flag;
+}
+
+
+// int out own
+
+static Eina_Bool _hash_int_out_own_free_flag = EINA_FALSE;
+static void _hash_int_out_own_free_cb(void *data)
+{
+ _hash_int_out_own_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Bool _test_testing_eina_hash_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+{
+ if (!hsh) return EINA_FALSE;
+
+ *hsh = eina_hash_int32_new(_hash_int_out_own_free_cb);
+
+ int key = 22;
+ return eina_hash_add(*hsh, &key, _new_int(222));
+}
+Eina_Bool _test_testing_check_eina_hash_int_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return !_hash_int_out_own_free_flag;
+}
+
+
+// int return
+
+static Eina_Bool _hash_int_return_free_flag = EINA_FALSE;
+static void _hash_int_return_free_cb(void *data)
+{
+ _hash_int_return_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Hash *_hash_int_return_to_check = NULL;
+
+Eina_Hash *_test_testing_eina_hash_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Hash *hsh = eina_hash_int32_new(_hash_int_return_free_cb);
+
+ int key = 22;
+ eina_hash_add(hsh, &key, _new_int(222));
+
+ _hash_int_return_to_check = hsh;
+
+ return hsh;
+}
+Eina_Bool _test_testing_check_eina_hash_int_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_hash_int_return_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_int_return_to_check;
+
+ if (!_hash_int_check(hsh, 22, 222)
+ || !_hash_int_check(hsh, 44, 444))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ _hash_int_return_to_check = NULL;
+ return _hash_int_return_free_flag;
+}
+
+
+// int return own
+
+static Eina_Bool _hash_int_return_own_free_flag = EINA_FALSE;
+static void _hash_int_return_own_free_cb(void *data)
+{
+ _hash_int_return_own_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Hash *_test_testing_eina_hash_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Hash *hsh = eina_hash_int32_new(_hash_int_return_own_free_cb);
+
+ int key = 22;
+ eina_hash_add(hsh, &key, _new_int(222));
+
+ return hsh;
+}
+Eina_Bool _test_testing_check_eina_hash_int_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return !_hash_int_return_own_free_flag;
+}
+
+
+// String //
+
+Eina_Bool _hash_str_check(const Eina_Hash *hsh, const char *key, const char *expected_val)
+{
+ const char *val = eina_hash_find(hsh, key);
+ return val && 0 == strcmp(val, expected_val);
+}
+
+
+// str in
+
+Eina_Bool _test_testing_eina_hash_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+{
+ if (!_hash_str_check(hsh, "aa", "aaa"))
+ return EINA_FALSE;
+
+ return eina_hash_add(hsh, "bb", strdup("bbb"));
+}
+
+
+// str in own
+
+static Eina_Bool _hash_str_in_own_free_flag = EINA_FALSE;
+static void _hash_str_in_own_free_cb(void *data)
+{
+ _hash_str_in_own_free_flag = EINA_TRUE;
+ free(data);
+}
+static Eina_Hash *_hash_str_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_hash_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh)
+{
+ eina_hash_free_cb_set(hsh, _hash_str_in_own_free_cb);
+
+ if (!_hash_str_check(hsh, "aa", "aaa"))
+ return EINA_FALSE;
+
+ _hash_str_in_own_to_check = hsh;
+
+ return eina_hash_add(hsh, "bb", strdup("bbb"));
+}
+Eina_Bool _test_testing_check_eina_hash_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_hash_str_in_own_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_str_in_own_to_check;
+
+ if (!_hash_str_check(hsh, "aa", "aaa")
+ || !_hash_str_check(hsh, "bb", "bbb")
+ || !_hash_str_check(hsh, "cc", "ccc"))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ return _hash_str_in_own_free_flag;
+}
+
+
+// str out
+
+static Eina_Bool _hash_str_out_free_flag = EINA_FALSE;
+static void _hash_str_out_free_cb(void *data)
+{
+ _hash_str_out_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Hash *_hash_str_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_hash_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+{
+ if (!hsh) return EINA_FALSE;
+
+ *hsh = eina_hash_string_superfast_new(_hash_str_out_free_cb);
+
+ _hash_str_out_to_check = *hsh;
+
+ return eina_hash_add(*hsh, "aa", strdup("aaa"));
+}
+Eina_Bool _test_testing_check_eina_hash_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_hash_str_out_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_str_out_to_check;
+
+ if (!_hash_str_check(hsh, "aa", "aaa")
+ || !_hash_str_check(hsh, "bb", "bbb"))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ _hash_str_out_to_check = NULL;
+ return _hash_str_out_free_flag;
+}
+
+
+// str out own
+
+static Eina_Bool _hash_str_out_own_free_flag = EINA_FALSE;
+static void _hash_str_out_own_free_cb(void *data)
+{
+ _hash_str_out_own_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Bool _test_testing_eina_hash_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh)
+{
+ if (!hsh) return EINA_FALSE;
+
+ *hsh = eina_hash_string_superfast_new(_hash_str_out_own_free_cb);
+
+ return eina_hash_add(*hsh, "aa", strdup("aaa"));
+}
+Eina_Bool _test_testing_check_eina_hash_str_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return !_hash_str_out_own_free_flag;
+}
+
+
+// str return
+
+static Eina_Bool _hash_str_return_free_flag = EINA_FALSE;
+static void _hash_str_return_free_cb(void *data)
+{
+ _hash_str_return_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Hash *_hash_str_return_to_check = NULL;
+
+Eina_Hash *_test_testing_eina_hash_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Hash *hsh = eina_hash_string_superfast_new(_hash_str_return_free_cb);
+
+ eina_hash_add(hsh, "aa", strdup("aaa"));
+
+ _hash_str_return_to_check = hsh;
+
+ return hsh;
+}
+Eina_Bool _test_testing_check_eina_hash_str_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ if (!_hash_str_return_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_str_return_to_check;
+
+ if (!_hash_str_check(hsh, "aa", "aaa")
+ || !_hash_str_check(hsh, "bb", "bbb"))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ _hash_str_return_to_check = NULL;
+ return _hash_str_return_free_flag;
+}
+
+
+// str return own
+
+static Eina_Bool _hash_str_return_own_free_flag = EINA_FALSE;
+static void _hash_str_return_own_free_cb(void *data)
+{
+ _hash_str_return_own_free_flag = EINA_TRUE;
+ free(data);
+}
+Eina_Hash *_test_testing_eina_hash_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ Eina_Hash *hsh = eina_hash_string_superfast_new(_hash_str_return_own_free_cb);
+
+ eina_hash_add(hsh, "aa", strdup("aaa"));
+
+ return hsh;
+}
+Eina_Bool _test_testing_check_eina_hash_str_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return !_hash_str_return_own_free_flag;
+}
+
+
+// Object //
+
+Eina_Bool _hash_obj_check(const Eina_Hash *hsh, Test_Numberwrapper *key, Test_Numberwrapper *expected_val, int knum, int vnum)
+{
+ Test_Numberwrapper *val = eina_hash_find(hsh, &key);
+ return val && (val == expected_val) && (test_numberwrapper_number_get(key) == knum) && (test_numberwrapper_number_get(val) == vnum);
+}
+
+
+// obj in
+
+Eina_Bool _test_testing_eina_hash_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper **nwk2, Test_Numberwrapper **nwv2)
+{
+ if (!_hash_obj_check(hsh, nwk1, nwv1, 22, 222))
+ return EINA_FALSE;
+
+ *nwk2 = _new_obj(44);
+ *nwv2 = _new_obj(444);
+
+ return eina_hash_add(hsh, nwk2, *nwv2);
+}
+
+
+// obj in own
+
+static Eina_Bool _hash_obj_in_own_free_flag = EINA_FALSE;
+static void _hash_obj_in_own_free_cb(void *data)
+{
+ _hash_obj_in_own_free_flag = EINA_TRUE;
+ efl_unref(data);
+}
+static Eina_Hash *_hash_obj_in_own_to_check = NULL;
+
+Eina_Bool _test_testing_eina_hash_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash *hsh, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper **nwk2, Test_Numberwrapper **nwv2)
+{
+ eina_hash_free_cb_set(hsh, _hash_obj_in_own_free_cb);
+
+ if (!_hash_obj_check(hsh, nwk1, nwv1, 22, 222))
+ return EINA_FALSE;
+
+ _hash_obj_in_own_to_check = hsh;
+
+ *nwk2 = _new_obj(44);
+ *nwv2 = _new_obj(444);
+
+ return eina_hash_add(hsh, nwk2, *nwv2);
+}
+Eina_Bool _test_testing_check_eina_hash_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper *nwk2, Test_Numberwrapper *nwv2)
+{
+ if (!_hash_obj_in_own_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_obj_in_own_to_check;
+
+ if (!_hash_obj_check(hsh, nwk1, nwv1, 22, 222)
+ || !_hash_obj_check(hsh, nwk2, nwv2, 44, 444))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ return _hash_obj_in_own_free_flag;
+}
+
+
+// obj out
+
+static Eina_Bool _hash_obj_out_free_flag = EINA_FALSE;
+static void _hash_obj_out_free_cb(void *data)
+{
+ _hash_obj_out_free_flag = EINA_TRUE;
+ efl_unref(data);
+}
+Eina_Hash *_hash_obj_out_to_check = NULL;
+
+Eina_Bool _test_testing_eina_hash_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+{
+ if (!hsh) return EINA_FALSE;
+
+ *hsh = eina_hash_pointer_new(_hash_obj_out_free_cb);
+
+ _hash_obj_out_to_check = *hsh;
+
+ *nwk = _new_obj(22);
+ *nwv = _new_obj(222);
+ return eina_hash_add(*hsh, nwk, *nwv);
+}
+Eina_Bool _test_testing_check_eina_hash_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper *nwk2, Test_Numberwrapper *nwv2)
+{
+ if (!_hash_obj_out_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_obj_out_to_check;
+
+ if (!_hash_obj_check(hsh, nwk1, nwv1, 22, 222)
+ || !_hash_obj_check(hsh, nwk2, nwv2, 44, 444))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ _hash_obj_out_to_check = NULL;
+ return _hash_obj_out_free_flag;
+}
+
+
+// obj out own
+
+static Eina_Bool _hash_obj_out_own_free_flag = EINA_FALSE;
+static void _hash_obj_out_own_free_cb(void *data)
+{
+ _hash_obj_out_own_free_flag = EINA_TRUE;
+ efl_unref(data);
+}
+Eina_Bool _test_testing_eina_hash_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Hash **hsh, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+{
+ if (!hsh) return EINA_FALSE;
+
+ *hsh = eina_hash_pointer_new(_hash_obj_out_own_free_cb);
+
+ *nwk = _new_obj(22);
+ *nwv = _new_obj(222);
+ return eina_hash_add(*hsh, nwk, *nwv);
+}
+Eina_Bool _test_testing_check_eina_hash_obj_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return !_hash_obj_out_own_free_flag;
+}
+
+
+// obj return
+
+static Eina_Bool _hash_obj_return_free_flag = EINA_FALSE;
+static void _hash_obj_return_free_cb(void *data)
+{
+ _hash_obj_return_free_flag = EINA_TRUE;
+ efl_unref(data);
+}
+Eina_Hash *_hash_obj_return_to_check = NULL;
+
+Eina_Hash *_test_testing_eina_hash_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+{
+ Eina_Hash *hsh = eina_hash_pointer_new(_hash_obj_return_free_cb);
+
+ *nwk = _new_obj(22);
+ *nwv = _new_obj(222);
+
+ eina_hash_add(hsh, nwk, *nwv);
+
+ _hash_obj_return_to_check = hsh;
+
+ return hsh;
+}
+Eina_Bool _test_testing_check_eina_hash_obj_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper *nwk1, Test_Numberwrapper *nwv1, Test_Numberwrapper *nwk2, Test_Numberwrapper *nwv2)
+{
+ if (!_hash_obj_return_to_check) return EINA_FALSE;
+
+ Eina_Hash *hsh = _hash_obj_return_to_check;
+
+ if (!_hash_obj_check(hsh, nwk1, nwv1, 22, 222)
+ || !_hash_obj_check(hsh, nwk2, nwv2, 44, 444))
+ return EINA_FALSE;
+
+ eina_hash_free(hsh);
+
+ _hash_obj_return_to_check = NULL;
+ return _hash_obj_return_free_flag;
+}
+
+
+// obj return own
+
+static Eina_Bool _hash_obj_return_own_free_flag = EINA_FALSE;
+static void _hash_obj_return_own_free_cb(void *data)
+{
+ _hash_obj_return_own_free_flag = EINA_TRUE;
+ efl_unref(data);
+}
+Eina_Hash *_test_testing_eina_hash_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Test_Numberwrapper **nwk, Test_Numberwrapper **nwv)
+{
+ Eina_Hash *hsh = eina_hash_pointer_new(_hash_obj_return_own_free_cb);
+
+ *nwk = _new_obj(22);
+ *nwv = _new_obj(222);
+ eina_hash_add(hsh, nwk, *nwv);
+
+ return hsh;
+}
+Eina_Bool _test_testing_check_eina_hash_obj_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ return !_hash_obj_return_own_free_flag;
+}
+
+
+// //
+// 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);
+}
+
+// //
+// Callbacks and Function Pointers //
+// //
+
+void _test_testing_set_callback(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, void *cb_data, Test_SimpleCb cb, Eina_Free_Cb cb_free_cb)
+{
+ if (!pd)
+ {
+ EINA_LOG_ERR("Null private data");
+ return -1;
+ }
+
+ if (pd->free_cb)
+ pd->free_cb(pd->cb_data);
+
+ pd->cb = cb;
+ pd->cb_data = cb_data;
+ pd->free_cb = cb_free_cb;
+}
+
+int _test_testing_call_callback(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, int a)
+{
+ if (!pd->cb)
+ {
+ EINA_LOG_ERR("Trying to call with no callback set");
+ return -1; // FIXME Maybe use Eina error when exceptions are supported?
+ }
+
+ return pd->cb(pd->cb_data, a);
+}
+
+// Global var used due to the current issue of calling methods from the GC thread
+static Eina_Bool _free_called = EINA_FALSE;
+
+EAPI Eina_Bool free_called_get() {
+ return _free_called;
+}
+
+EAPI void free_called_set(Eina_Bool b) {
+ _free_called = b;
+}
+
+static void _free_callback(void *data)
+{
+ Eo *obj = data;
+
+ free_called_set(EINA_TRUE);
+ efl_unref(obj);
+}
+
+int _wrapper_cb(EINA_UNUSED void *data, int a)
+{
+ return a * 3;
+}
+
+void _test_testing_call_set_callback(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ test_testing_set_callback(obj, efl_ref(obj), _wrapper_cb, _free_callback);
+}
+
+void _test_testing_raises_eina_error(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ eina_error_set(EIO);
+}
+
+void _test_testing_children_raise_error(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ // Native method shouldn't throw any error. Children must raise it.
+}
+
+void _test_testing_call_children_raise_error(Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
+{
+ test_testing_children_raise_error(obj);
+}
+
+void _test_testing_error_ret_set(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Error error)
+{
+ pd->error_code = error;
+}
+
+Eina_Error _test_testing_returns_error(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+{
+ return pd->error_code;
+}
+
+// //
+// Class constructor
+// //
+EOLIAN static void
+_test_testing_class_constructor(Efl_Class *klass)
+{
+ (void)klass;
+ modified_seq_obj[0] = base_seq_obj[0] = _new_obj(0x0);
+ modified_seq_obj[1] = base_seq_obj[1] = _new_obj(0x2A);
+ modified_seq_obj[2] = base_seq_obj[2] = _new_obj(0x42);
+ modified_seq_obj[3] = _new_obj(42);
+ modified_seq_obj[4] = _new_obj(43);
+ modified_seq_obj[5] = _new_obj(33);
+}
+
+EOLIAN static void
+_test_testing_class_destructor(Efl_Class *klass)
+{
+ (void)klass;
+ for (unsigned i = 0; i < base_seq_obj_size; ++i)
+ efl_unref(base_seq_obj[i]);
+ for (unsigned i = 0; i < modified_seq_obj_size; ++i)
+ efl_unref(modified_seq_obj[i]);
+}
+
+
+// ################## //
+// Test.Numberwrapper //
+// ################## //
+
+
+void _test_numberwrapper_number_set(EINA_UNUSED Eo *obj, Test_Numberwrapper_Data *pd, int n)
+{
+ pd->number = n;
+}
+
+int _test_numberwrapper_number_get(EINA_UNUSED Eo *obj, Test_Numberwrapper_Data *pd)
+{
+ return pd->number;
+}
+
+void _test_testing_set_value_ptr(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value *value)
+{
+ if (pd->stored_value) {
+ eina_value_free(pd->stored_value);
+ free(pd->stored_value);
+ }
+
+ pd->stored_value = malloc(sizeof(Eina_Value));
+
+ eina_value_copy(value, pd->stored_value);
+}
+
+void _test_testing_set_value_ptr_own(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value *value)
+{
+ if (pd->stored_value) {
+ eina_value_free(pd->stored_value);
+ free(pd->stored_value);
+ }
+
+ pd->stored_value = value;
+}
+
+void _test_testing_set_value(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value value)
+{
+ if (pd->stored_value) {
+ eina_value_free(pd->stored_value);
+ } else {
+ pd->stored_value = malloc(sizeof(Eina_Value));
+ }
+ eina_value_copy(&value, pd->stored_value);
+}
+
+Eina_Value *_test_testing_get_value_ptr_own(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+{
+ Eina_Value *val = pd->stored_value;
+ pd->stored_value = NULL;
+ return val;
+}
+
+Eina_Value *_test_testing_get_value_ptr(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+{
+ return pd->stored_value;
+}
+
+/* Currently the Eolian declaration FUNC_BODY in the .eo.c file seems to be broken for
+ * generic value.
+ */
+/* Eina_Value _test_testing_get_value(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+{
+ return *pd->stored_value;
+}*/
+
+void _test_testing_clear_value(EINA_UNUSED Eo *obj, Test_Testing_Data *pd)
+{
+ if (pd->stored_value) {
+ eina_value_free(pd->stored_value);
+ free(pd->stored_value);
+ }
+}
+
+void _test_testing_out_value_ptr(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value **value)
+{
+ *value = pd->stored_value;
+}
+
+void _test_testing_out_value_ptr_own(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value **value)
+{
+ *value = pd->stored_value;
+ pd->stored_value = NULL;
+}
+
+void _test_testing_out_value(EINA_UNUSED Eo *obj, Test_Testing_Data *pd, Eina_Value *value)
+{
+ *value = *pd->stored_value;
+}
+
+#include "test_testing.eo.c"
+#include "test_numberwrapper.eo.c"
+
--- /dev/null
+#!/bin/sh
+
+echo $LD_LIBRARY_PATH
+EINA_LOG_LEVEL=8 MONO_LOG_LEVEL=debug $MONO $MONO_BUILDPATH/src/tests/efl_mono/efl_mono.exe$EXEEXT
+
--- /dev/null
+class Test.Numberwrapper (Efl.Object) {
+ methods {
+ @property number {
+ get {
+ }
+ set {
+ }
+ values {
+ n: int;
+ }
+ }
+ }
+}
--- /dev/null
+import eina_types;
+
+function Test.SimpleCb {
+ params {
+ a: int;
+ }
+ return: int;
+};
+
+class Test.Testing (Efl.Object) {
+ methods {
+ return_object {
+ return: Test.Testing;
+ }
+
+ in_stringshare {
+ params {
+ @in v: stringshare;
+ }
+ return: stringshare @owned;
+ }
+ in_own_stringshare {
+ params {
+ @in v: stringshare @owned;
+ }
+ return: stringshare @owned;
+ }
+
+ out_stringshare {
+ params {
+ @out v: stringshare;
+ }
+ }
+ out_own_stringshare {
+ params {
+ @out v: stringshare @owned;
+ }
+ }
+
+ return_stringshare {
+ return: stringshare;
+ }
+ return_own_stringshare {
+ return: stringshare @owned;
+ }
+
+ in_string {
+ params {
+ @in str: string;
+ }
+ return: string @owned;
+ }
+
+ in_own_string {
+ params {
+ @in str: mstring @owned;
+ }
+ return: mstring @owned;
+ }
+
+ return_string {
+ return: string;
+ }
+
+ return_own_string {
+ return: string @owned;
+ }
+
+ out_string {
+ params {
+ @out str: string;
+ }
+ }
+
+ out_own_string {
+ params {
+ @out str: string @owned;
+ }
+ }
+
+ call_in_string {
+ params {
+ @in str: string;
+ }
+ }
+
+ call_in_own_string {
+ params {
+ @in str: mstring @owned;
+ }
+ }
+
+ call_return_string {
+ return: string;
+ }
+
+ call_return_own_string {
+ return: string @owned;
+ }
+
+ call_out_string {
+ return: string;
+ }
+
+ call_out_own_string {
+ return: string @owned;
+ }
+
+ // Stringshare virtual helpers
+ call_in_stringshare {
+ params {
+ @in str: stringshare;
+ }
+ }
+
+ call_in_own_stringshare {
+ params {
+ @in str: stringshare @owned;
+ }
+ }
+
+ call_return_stringshare {
+ return: stringshare;
+ }
+
+ call_return_own_stringshare {
+ return: stringshare @owned;
+ }
+
+ call_out_stringshare {
+ return: stringshare;
+ }
+
+ call_out_own_stringshare {
+ return: stringshare @owned;
+ }
+
+ eina_slice_in {
+ params {
+ @in slice: Eina.Slice;
+ }
+ return: bool;
+ }
+
+ eina_rw_slice_in {
+ params {
+ @in slice: Eina.Rw_Slice;
+ }
+ return: bool;
+ }
+
+ eina_slice_out {
+ params {
+ @out slice: Eina.Slice;
+ }
+ return: bool;
+ }
+
+ eina_rw_slice_out {
+ params {
+ @out slice: Eina.Rw_Slice;
+ }
+ return: bool;
+ }
+
+ /*
+ eina_slice_return {
+ return: Eina.Slice;
+ }
+
+ eina_rw_slice_return {
+ return: Eina.Rw_Slice;
+ }
+ */
+
+ eina_binbuf_in {
+ params {
+ @in binbuf: ptr(Eina.Binbuf);
+ }
+ return: bool;
+ }
+
+ eina_binbuf_in_own {
+ params {
+ @in binbuf: ptr(Eina.Binbuf) @owned;
+ }
+ return: bool;
+ }
+ check_binbuf_in_own {
+ return: bool;
+ }
+
+ eina_binbuf_out {
+ params {
+ @out binbuf: ptr(Eina.Binbuf);
+ }
+ return: bool;
+ }
+ check_binbuf_out {
+ return: bool;
+ }
+
+ eina_binbuf_out_own {
+ params {
+ @out binbuf: ptr(Eina.Binbuf) @owned;
+ }
+ return: bool;
+ }
+
+ eina_binbuf_return {
+ return: ptr(Eina.Binbuf);
+ }
+ check_binbuf_return {
+ return: bool;
+ }
+
+ eina_binbuf_return_own {
+ return: ptr(Eina.Binbuf) @owned;
+ }
+
+ /* Eina Array */
+
+ /* Integer */
+ eina_array_int_in {
+ params {
+ @in arr: array<ptr(int)>;
+ }
+ return: bool;
+ }
+
+ eina_array_int_in_own {
+ params {
+ @in arr: array<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_array_int_in_own {
+ return: bool;
+ }
+
+ eina_array_int_out {
+ params {
+ @out arr: array<ptr(int)>;
+ }
+ return: bool;
+ }
+ check_eina_array_int_out {
+ return: bool;
+ }
+
+ eina_array_int_out_own {
+ params {
+ @out arr: array<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_array_int_return {
+ return: array<ptr(int)>;
+ }
+ check_eina_array_int_return {
+ return: bool;
+ }
+
+ eina_array_int_return_own {
+ return: array<ptr(int) @owned> @owned;
+ }
+
+ /* String */
+ eina_array_str_in {
+ params {
+ @in arr: array<string>;
+ }
+ return: bool;
+ }
+
+ eina_array_str_in_own {
+ params {
+ @in arr: array<string @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_array_str_in_own {
+ return: bool;
+ }
+
+ eina_array_str_out {
+ params {
+ @out arr: array<string>;
+ }
+ return: bool;
+ }
+ check_eina_array_str_out {
+ return: bool;
+ }
+
+ eina_array_str_out_own {
+ params {
+ @out arr: array<string @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_array_str_return {
+ return: array<string>;
+ }
+ check_eina_array_str_return {
+ return: bool;
+ }
+
+ eina_array_str_return_own {
+ return: array<string @owned> @owned;
+ }
+
+ /* Object */
+ eina_array_obj_in {
+ params {
+ @in arr: array<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+
+ eina_array_obj_in_own {
+ params {
+ @in arr: array<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_array_obj_in_own {
+ return: bool;
+ }
+
+ eina_array_obj_out {
+ params {
+ @out arr: array<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+ check_eina_array_obj_out {
+ return: bool;
+ }
+
+ eina_array_obj_out_own {
+ params {
+ @out arr: array<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_array_obj_return {
+ return: array<Test.Numberwrapper>;
+ }
+ check_eina_array_obj_return {
+ return: bool;
+ }
+
+ eina_array_obj_return_own {
+ return: array<Test.Numberwrapper @owned> @owned;
+ }
+
+ eina_array_obj_return_in {
+ params {
+ @in arr: array<Test.Numberwrapper>;
+ }
+ return: array<Test.Numberwrapper>;
+ }
+
+ /* Eina Inarray */
+
+ /* Integer */
+ eina_inarray_int_in {
+ params {
+ @in arr: inarray<int>;
+ }
+ return: bool;
+ }
+
+ eina_inarray_int_in_own {
+ params {
+ @in arr: inarray<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_inarray_int_in_own {
+ return: bool;
+ }
+
+ eina_inarray_int_out {
+ params {
+ @out arr: inarray<int>;
+ }
+ return: bool;
+ }
+ check_eina_inarray_int_out {
+ return: bool;
+ }
+
+ eina_inarray_int_out_own {
+ params {
+ @out arr: inarray<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_inarray_int_return {
+ return: inarray<int>;
+ }
+ check_eina_inarray_int_return {
+ return: bool;
+ }
+
+ eina_inarray_int_return_own {
+ return: inarray<ptr(int) @owned> @owned;
+ }
+
+ /* String */
+ eina_inarray_str_in {
+ params {
+ @in arr: inarray<string>;
+ }
+ return: bool;
+ }
+
+ eina_inarray_str_in_own {
+ params {
+ @in arr: inarray<string @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_inarray_str_in_own {
+ return: bool;
+ }
+
+ eina_inarray_str_out {
+ params {
+ @out arr: inarray<string>;
+ }
+ return: bool;
+ }
+ check_eina_inarray_str_out {
+ return: bool;
+ }
+
+ eina_inarray_str_out_own {
+ params {
+ @out arr: inarray<string @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_inarray_str_return {
+ return: inarray<string>;
+ }
+ check_eina_inarray_str_return {
+ return: bool;
+ }
+
+ eina_inarray_str_return_own {
+ return: inarray<string @owned> @owned;
+ }
+
+ /* Object */
+ eina_inarray_obj_in {
+ params {
+ @in arr: inarray<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+
+ eina_inarray_obj_in_own {
+ params {
+ @in arr: inarray<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_inarray_obj_in_own {
+ return: bool;
+ }
+
+ eina_inarray_obj_out {
+ params {
+ @out arr: inarray<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+ check_eina_inarray_obj_out {
+ return: bool;
+ }
+
+ eina_inarray_obj_out_own {
+ params {
+ @out arr: inarray<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_inarray_obj_return {
+ return: inarray<Test.Numberwrapper>;
+ }
+ check_eina_inarray_obj_return {
+ return: bool;
+ }
+
+ eina_inarray_obj_return_own {
+ return: inarray<Test.Numberwrapper @owned> @owned;
+ }
+
+ eina_inarray_obj_return_in {
+ params {
+ @in arr: inarray<Test.Numberwrapper>;
+ }
+ return: inarray<Test.Numberwrapper>;
+ }
+
+ /* Eina List */
+
+ /* Integer */
+ eina_list_int_in {
+ params {
+ @in lst: list<ptr(int)>;
+ }
+ return: bool;
+ }
+
+ eina_list_int_in_own {
+ params {
+ @in lst: list<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_list_int_in_own {
+ return: bool;
+ }
+
+ eina_list_int_out {
+ params {
+ @out lst: list<ptr(int)>;
+ }
+ return: bool;
+ }
+ check_eina_list_int_out {
+ return: bool;
+ }
+
+ eina_list_int_out_own {
+ params {
+ @out lst: list<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_list_int_return {
+ return: list<ptr(int)>;
+ }
+ check_eina_list_int_return {
+ return: bool;
+ }
+
+ eina_list_int_return_own {
+ return: list<ptr(int) @owned> @owned;
+ }
+
+ /* String */
+ eina_list_str_in {
+ params {
+ @in lst: list<string>;
+ }
+ return: bool;
+ }
+
+ eina_list_str_in_own {
+ params {
+ @in lst: list<string @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_list_str_in_own {
+ return: bool;
+ }
+
+ eina_list_str_out {
+ params {
+ @out lst: list<string>;
+ }
+ return: bool;
+ }
+ check_eina_list_str_out {
+ return: bool;
+ }
+
+ eina_list_str_out_own {
+ params {
+ @out lst: list<string @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_list_str_return {
+ return: list<string>;
+ }
+ check_eina_list_str_return {
+ return: bool;
+ }
+
+ eina_list_str_return_own {
+ return: list<string @owned> @owned;
+ }
+
+ /* Object */
+ eina_list_obj_in {
+ params {
+ @in lst: list<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+
+ eina_list_obj_in_own {
+ params {
+ @in lst: list<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_list_obj_in_own {
+ return: bool;
+ }
+
+ eina_list_obj_out {
+ params {
+ @out lst: list<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+ check_eina_list_obj_out {
+ return: bool;
+ }
+
+ eina_list_obj_out_own {
+ params {
+ @out lst: list<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_list_obj_return {
+ return: list<Test.Numberwrapper>;
+ }
+ check_eina_list_obj_return {
+ return: bool;
+ }
+
+ eina_list_obj_return_own {
+ return: list<Test.Numberwrapper @owned> @owned;
+ }
+
+ eina_list_obj_return_in {
+ params {
+ @in lst: list<Test.Numberwrapper>;
+ }
+ return: list<Test.Numberwrapper>;
+ }
+
+ /* Eina Inlist */
+
+ /* Integer */
+ eina_inlist_int_in {
+ params {
+ @in lst: inlist<int>;
+ }
+ return: bool;
+ }
+
+ eina_inlist_int_in_own {
+ params {
+ @in lst: inlist<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_inlist_int_in_own {
+ return: bool;
+ }
+
+ eina_inlist_int_out {
+ params {
+ @out lst: inlist<int>;
+ }
+ return: bool;
+ }
+ check_eina_inlist_int_out {
+ return: bool;
+ }
+
+ eina_inlist_int_out_own {
+ params {
+ @out lst: inlist<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_inlist_int_return {
+ return: inlist<int>;
+ }
+ check_eina_inlist_int_return {
+ return: bool;
+ }
+
+ eina_inlist_int_return_own {
+ return: inlist<ptr(int) @owned> @owned;
+ }
+
+ /* String */
+ eina_inlist_str_in {
+ params {
+ @in lst: inlist<string>;
+ }
+ return: bool;
+ }
+
+ eina_inlist_str_in_own {
+ params {
+ @in lst: inlist<string @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_inlist_str_in_own {
+ return: bool;
+ }
+
+ eina_inlist_str_out {
+ params {
+ @out lst: inlist<string>;
+ }
+ return: bool;
+ }
+ check_eina_inlist_str_out {
+ return: bool;
+ }
+
+ eina_inlist_str_out_own {
+ params {
+ @out lst: inlist<string @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_inlist_str_return {
+ return: inlist<string>;
+ }
+ check_eina_inlist_str_return {
+ return: bool;
+ }
+
+ eina_inlist_str_return_own {
+ return: inlist<string @owned> @owned;
+ }
+
+ /* Object */
+ eina_inlist_obj_in {
+ params {
+ @in lst: inlist<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+
+ eina_inlist_obj_in_own {
+ params {
+ @in lst: inlist<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_inlist_obj_in_own {
+ return: bool;
+ }
+
+ eina_inlist_obj_out {
+ params {
+ @out lst: inlist<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+ check_eina_inlist_obj_out {
+ return: bool;
+ }
+
+ eina_inlist_obj_out_own {
+ params {
+ @out lst: inlist<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_inlist_obj_return {
+ return: inlist<Test.Numberwrapper>;
+ }
+ check_eina_inlist_obj_return {
+ return: bool;
+ }
+
+ eina_inlist_obj_return_own {
+ return: inlist<Test.Numberwrapper @owned> @owned;
+ }
+
+ eina_inlist_obj_return_in {
+ params {
+ @in lst: inlist<Test.Numberwrapper>;
+ }
+ return: inlist<Test.Numberwrapper>;
+ }
+
+
+ // Eina Hash //
+
+ // Integer //
+ eina_hash_int_in {
+ params {
+ @in hsh: hash<ptr(int), ptr(int)>;
+ }
+ return: bool;
+ }
+
+ eina_hash_int_in_own {
+ params {
+ @in hsh: hash<ptr(int), ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_hash_int_in_own {
+ return: bool;
+ }
+
+ eina_hash_int_out {
+ params {
+ @out hsh: hash<ptr(int), ptr(int)>;
+ }
+ return: bool;
+ }
+ check_eina_hash_int_out {
+ return: bool;
+ }
+
+ eina_hash_int_out_own {
+ params {
+ @out hsh: hash<ptr(int), ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_hash_int_out_own {
+ return: bool;
+ }
+
+ eina_hash_int_return {
+ return: hash<ptr(int), ptr(int)>;
+ }
+ check_eina_hash_int_return {
+ return: bool;
+ }
+
+ eina_hash_int_return_own {
+ return: hash<ptr(int), ptr(int) @owned> @owned;
+ }
+ check_eina_hash_int_return_own {
+ return: bool;
+ }
+
+ // String //
+ eina_hash_str_in {
+ params {
+ @in hsh: hash<string, string>;
+ }
+ return: bool;
+ }
+
+ eina_hash_str_in_own {
+ params {
+ @in hsh: hash<string, string @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_hash_str_in_own {
+ return: bool;
+ }
+
+ eina_hash_str_out {
+ params {
+ @out hsh: hash<string, string>;
+ }
+ return: bool;
+ }
+ check_eina_hash_str_out {
+ return: bool;
+ }
+
+ eina_hash_str_out_own {
+ params {
+ @out hsh: hash<string, string @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_hash_str_out_own {
+ return: bool;
+ }
+
+ eina_hash_str_return {
+ return: hash<string, string>;
+ }
+ check_eina_hash_str_return {
+ return: bool;
+ }
+
+ eina_hash_str_return_own {
+ return: hash<string, string @owned> @owned;
+ }
+ check_eina_hash_str_return_own {
+ return: bool;
+ }
+
+ // Object //
+ eina_hash_obj_in {
+ params {
+ @in hsh: hash<Test.Numberwrapper, Test.Numberwrapper>;
+ @in nwk1: Test.Numberwrapper;
+ @in nwv1: Test.Numberwrapper;
+ @out nwk2: Test.Numberwrapper;
+ @out nwv2: Test.Numberwrapper;
+ }
+ return: bool;
+ }
+
+ eina_hash_obj_in_own {
+ params {
+ @in hsh: hash<Test.Numberwrapper, Test.Numberwrapper @owned> @owned;
+ @in nwk1: Test.Numberwrapper;
+ @in nwv1: Test.Numberwrapper;
+ @out nwk2: Test.Numberwrapper;
+ @out nwv2: Test.Numberwrapper;
+ }
+ return: bool;
+ }
+ check_eina_hash_obj_in_own {
+ params {
+ @in nwk1: Test.Numberwrapper;
+ @in nwv1: Test.Numberwrapper;
+ @in nwk2: Test.Numberwrapper;
+ @in nwv2: Test.Numberwrapper;
+ }
+ return: bool;
+ }
+
+ eina_hash_obj_out {
+ params {
+ @out hsh: hash<Test.Numberwrapper, Test.Numberwrapper>;
+ @out nwk: Test.Numberwrapper;
+ @out nwv: Test.Numberwrapper;
+ }
+ return: bool;
+ }
+ check_eina_hash_obj_out {
+ params {
+ @in nwk1: Test.Numberwrapper;
+ @in nwv1: Test.Numberwrapper;
+ @in nwk2: Test.Numberwrapper;
+ @in nwv2: Test.Numberwrapper;
+ }
+ return: bool;
+ }
+
+ eina_hash_obj_out_own {
+ params {
+ @out hsh: hash<Test.Numberwrapper, Test.Numberwrapper @owned> @owned;
+ @out nwk: Test.Numberwrapper;
+ @out nwv: Test.Numberwrapper;
+ }
+ return: bool;
+ }
+ check_eina_hash_obj_out_own {
+ return: bool;
+ }
+
+ eina_hash_obj_return {
+ params {
+ @out nwk: Test.Numberwrapper;
+ @out nwv: Test.Numberwrapper;
+ }
+ return: hash<Test.Numberwrapper, Test.Numberwrapper>;
+ }
+ check_eina_hash_obj_return {
+ params {
+ @in nwk1: Test.Numberwrapper;
+ @in nwv1: Test.Numberwrapper;
+ @in nwk2: Test.Numberwrapper;
+ @in nwv2: Test.Numberwrapper;
+ }
+ return: bool;
+ }
+
+ eina_hash_obj_return_own {
+ params {
+ @out nwk: Test.Numberwrapper;
+ @out nwv: Test.Numberwrapper;
+ }
+ return: hash<Test.Numberwrapper, Test.Numberwrapper @owned> @owned;
+ }
+ check_eina_hash_obj_return_own {
+ return: bool;
+ }
+
+ /* Eina Iterator */
+
+ /* Integer */
+ eina_iterator_int_in {
+ params {
+ @in itr: iterator<ptr(int)>;
+ }
+ return: bool;
+ }
+
+ eina_iterator_int_in_own {
+ params {
+ @in itr: iterator<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+ check_eina_iterator_int_in_own {
+ return: bool;
+ }
+
+ eina_iterator_int_out {
+ params {
+ @out itr: iterator<ptr(int)>;
+ }
+ return: bool;
+ }
+ check_eina_iterator_int_out {
+ return: bool;
+ }
+
+ eina_iterator_int_out_own {
+ params {
+ @out itr: iterator<ptr(int) @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_iterator_int_return {
+ return: iterator<ptr(int)>;
+ }
+ check_eina_iterator_int_return {
+ return: bool;
+ }
+
+ eina_iterator_int_return_own {
+ return: iterator<ptr(int) @owned> @owned;
+ }
+
+ /* String */
+ eina_iterator_str_in {
+ params {
+ @in itr: iterator<string>;
+ }
+ return: bool;
+ }
+
+ eina_iterator_str_in_own {
+ params {
+ @in itr: iterator<string @owned> @owned;
+ }
+ 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: iterator<string @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_iterator_str_return {
+ return: iterator<string>;
+ }
+ check_eina_iterator_str_return {
+ return: bool;
+ }
+
+ eina_iterator_str_return_own {
+ return: iterator<string @owned> @owned;
+ }
+
+ /* Object */
+ eina_iterator_obj_in {
+ params {
+ @in itr: iterator<Test.Numberwrapper>;
+ }
+ return: bool;
+ }
+
+ eina_iterator_obj_in_own {
+ params {
+ @in itr: iterator<Test.Numberwrapper @owned> @owned;
+ }
+ 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: iterator<Test.Numberwrapper @owned> @owned;
+ }
+ return: bool;
+ }
+
+ eina_iterator_obj_return {
+ return: iterator<Test.Numberwrapper>;
+ }
+ check_eina_iterator_obj_return {
+ return: bool;
+ }
+
+ eina_iterator_obj_return_own {
+ return: iterator<Test.Numberwrapper @owned> @owned;
+ }
+
+ /* Function Pointer */
+
+ set_callback {
+ params {
+ cb: Test.SimpleCb;
+ }
+ }
+
+ call_callback {
+ params {
+ a: int;
+ }
+ return: int;
+ }
+
+ call_set_callback {
+ }
+
+ raises_eina_error {
+
+ }
+
+ children_raise_error {
+
+ }
+ call_children_raise_error {
+
+ }
+
+ error_ret_set {
+ params {
+ error: Eina.Error;
+ }
+ }
+
+ returns_error {
+ return: Eina.Error;
+ }
+
+ /* Eina Values */
+ set_value_ptr {
+ params {
+ value: any_value_ptr;
+ }
+ }
+
+ set_value_ptr_own {
+ params {
+ value: any_value_ptr @owned;
+ }
+ }
+
+ set_value {
+ params {
+ value: any_value;
+ }
+ }
+
+ get_value_ptr_own {
+ return: any_value_ptr @owned;
+ }
+
+ get_value_ptr {
+ return: any_value_ptr;
+ }
+
+ /* Commented out due to issues regarding eolian treatment of any_value.
+ * Somehow eolian is giving 0 as the default value when declaring the function below,
+ * leading to compiler errors.
+ */
+ /* get_value {
+ return: any_value;
+ }
+ */
+
+ clear_value {
+ }
+
+ out_value_ptr {
+ params {
+ @out value: any_value_ptr;
+ }
+ }
+
+ out_value_ptr_own {
+ params {
+ @out value: any_value_ptr @owned;
+ }
+ }
+
+ out_value {
+ params {
+ @out value: any_value;
+ }
+ }
+ }
+ implements {
+ class.constructor;
+ class.destructor;
+ }
+}
projects / platform / upstream / efl.git / commitdiff