From 345336c46dd7ceb04005305c5dc567d402db0dce Mon Sep 17 00:00:00 2001 From: Lauro Moura Date: Thu, 23 Nov 2017 21:53:28 -0300 Subject: [PATCH] efl_mono: Added test files for the C# bindings. Buildsystem integration will come in a future commit. --- src/tests/efl_mono/.gitignore | 1 + src/tests/efl_mono/Eina.cs | 4267 ++++++++++++++++++ src/tests/efl_mono/Eldbus.cs | 447 ++ src/tests/efl_mono/Eo.cs | 194 + src/tests/efl_mono/Errors.cs | 118 + src/tests/efl_mono/Evas.cs | 77 + src/tests/efl_mono/Events.cs | 26 + src/tests/efl_mono/FunctionPointers.cs | 196 + src/tests/efl_mono/Main.cs | 100 + src/tests/efl_mono/Strings.cs | 334 ++ src/tests/efl_mono/TestUtils.cs | 191 + src/tests/efl_mono/Value.cs | 831 ++++ src/tests/efl_mono/ValueEolian.cs | 115 + src/tests/efl_mono/libefl_mono_native_test.c | 3245 +++++++++++++ src/tests/efl_mono/mono_test_driver.sh | 5 + src/tests/efl_mono/test_numberwrapper.eo | 13 + src/tests/efl_mono/test_testing.eo | 1246 +++++ 17 files changed, 11406 insertions(+) create mode 100644 src/tests/efl_mono/.gitignore create mode 100644 src/tests/efl_mono/Eina.cs create mode 100644 src/tests/efl_mono/Eldbus.cs create mode 100644 src/tests/efl_mono/Eo.cs create mode 100644 src/tests/efl_mono/Errors.cs create mode 100644 src/tests/efl_mono/Evas.cs create mode 100644 src/tests/efl_mono/Events.cs create mode 100644 src/tests/efl_mono/FunctionPointers.cs create mode 100644 src/tests/efl_mono/Main.cs create mode 100644 src/tests/efl_mono/Strings.cs create mode 100644 src/tests/efl_mono/TestUtils.cs create mode 100644 src/tests/efl_mono/Value.cs create mode 100644 src/tests/efl_mono/ValueEolian.cs create mode 100644 src/tests/efl_mono/libefl_mono_native_test.c create mode 100755 src/tests/efl_mono/mono_test_driver.sh create mode 100644 src/tests/efl_mono/test_numberwrapper.eo create mode 100644 src/tests/efl_mono/test_testing.eo diff --git a/src/tests/efl_mono/.gitignore b/src/tests/efl_mono/.gitignore new file mode 100644 index 0000000000..ecab14810c --- /dev/null +++ b/src/tests/efl_mono/.gitignore @@ -0,0 +1 @@ +/libefl_mono_test.dll diff --git a/src/tests/efl_mono/Eina.cs b/src/tests/efl_mono/Eina.cs new file mode 100644 index 0000000000..e5baa8e32a --- /dev/null +++ b/src/tests/efl_mono/Eina.cs @@ -0,0 +1,4267 @@ +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(); + Test.Assert(a.Handle != IntPtr.Zero); + } + + public static void push_int() + { + var a = new eina.Array(); + 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(); + 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.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(); + 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(); + 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.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(); + 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(); + 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.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(); + 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(); + 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.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(); + 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(); + 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(); + 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(); + 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.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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + Test.Assert(a.Handle != IntPtr.Zero); + a.Dispose(); + } + + public static void push_int() + { + var a = new eina.Inarray(); + 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(); + 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.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(); + 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(); + 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.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(); + 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(); + 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.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(); + 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(); + 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.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(); + 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(); + 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(); + 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(); + 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.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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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(); + 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(); + + 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(); + 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(); + 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.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(); + 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(); + 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(); + 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(); + 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.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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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(); + 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(); + + 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(); + 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(); + 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.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(); + 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(); + 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(); + 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(); + 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.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(); + 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(); + 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(); + 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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(); + 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.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(); + var dct = new Dictionary(); + + hsh[88] = 888; + hsh[44] = 444; + hsh[22] = 222; + + dct[88] = 888; + dct[44] = 444; + dct[22] = 222; + + int count = 0; + + foreach (KeyValuePair 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(); + var dct = new Dictionary(); + + hsh["aa"] = "aaa"; + hsh["bb"] = "bbb"; + hsh["cc"] = "ccc"; + + dct["aa"] = "aaa"; + dct["bb"] = "bbb"; + dct["cc"] = "ccc"; + + int count = 0; + + foreach (KeyValuePair 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(); + var dct = new Dictionary(); + + 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 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + 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(); + var dct = new Dictionary(); + 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(); + var dct = new Dictionary(); + 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(); + 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(); + 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(); + var dct = new Dictionary(); + 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(); + var dct = new Dictionary(); + 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(); + 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(); + 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(); + var dct = new eina.Hash(); + 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(); + var dct = new eina.Hash(); + 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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(); + 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(); + 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 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 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 + +} diff --git a/src/tests/efl_mono/Eldbus.cs b/src/tests/efl_mono/Eldbus.cs new file mode 100644 index 0000000000..9c9fe35e88 --- /dev/null +++ b/src/tests/efl_mono/Eldbus.cs @@ -0,0 +1,447 @@ +#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 diff --git a/src/tests/efl_mono/Eo.cs b/src/tests/efl_mono/Eo.cs new file mode 100644 index 0000000000..60d66821c7 --- /dev/null +++ b/src/tests/efl_mono/Eo.cs @@ -0,0 +1,194 @@ +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); + } +} + +} diff --git a/src/tests/efl_mono/Errors.cs b/src/tests/efl_mono/Errors.cs new file mode 100644 index 0000000000..a903cf1605 --- /dev/null +++ b/src/tests/efl_mono/Errors.cs @@ -0,0 +1,118 @@ +using System; + +namespace TestSuite +{ + +class TestEinaError +{ + public static void basic_test() + { + eina.Error.Clear(); + Test.AssertNotRaises(eina.Error.RaiseIfOccurred); + eina.Error.Set(eina.Error.ENOENT); + Test.AssertRaises(eina.Error.RaiseIfOccurred); + } +} + +class TestEolianError +{ + + public static void global_eina_error() + { + test.Testing obj = new test.TestingConcrete(); + Test.AssertRaises(() => obj.RaisesEinaError()); + } + + class Child : test.TestingInherit { + } + + public static void global_eina_error_inherited() + { + test.Testing obj = new Child(); + Test.AssertRaises(() => 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(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(() => loop.IDLE += listener.another_callback); + } +} +} diff --git a/src/tests/efl_mono/Evas.cs b/src/tests/efl_mono/Evas.cs new file mode 100644 index 0000000000..4b5622593e --- /dev/null +++ b/src/tests/efl_mono/Evas.cs @@ -0,0 +1,77 @@ +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(); */ + /* } */ +} + +} diff --git a/src/tests/efl_mono/Events.cs b/src/tests/efl_mono/Events.cs new file mode 100644 index 0000000000..025e501a19 --- /dev/null +++ b/src/tests/efl_mono/Events.cs @@ -0,0 +1,26 @@ +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); + } +} + +} diff --git a/src/tests/efl_mono/FunctionPointers.cs b/src/tests/efl_mono/FunctionPointers.cs new file mode 100644 index 0000000000..2514d79b82 --- /dev/null +++ b/src/tests/efl_mono/FunctionPointers.cs @@ -0,0 +1,196 @@ +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); + + } +} + +} + diff --git a/src/tests/efl_mono/Main.cs b/src/tests/efl_mono/Main.cs new file mode 100644 index 0000000000..eae6882a45 --- /dev/null +++ b/src/tests/efl_mono/Main.cs @@ -0,0 +1,100 @@ +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; + } +} diff --git a/src/tests/efl_mono/Strings.cs b/src/tests/efl_mono/Strings.cs new file mode 100644 index 0000000000..f798f20715 --- /dev/null +++ b/src/tests/efl_mono/Strings.cs @@ -0,0 +1,334 @@ +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()); + } +} + +} diff --git a/src/tests/efl_mono/TestUtils.cs b/src/tests/efl_mono/TestUtils.cs new file mode 100644 index 0000000000..615a8f3c6d --- /dev/null +++ b/src/tests/efl_mono/TestUtils.cs @@ -0,0 +1,191 @@ +using System; +using System.Runtime.CompilerServices; +using System.Runtime.Serialization; +using System.Diagnostics.CodeAnalysis; + + +/// Exception for assertion failures. +[Serializable] +public class AssertionException : Exception +{ + /// Default constructor. + public AssertionException() : base () { } + /// Most commonly used contructor. + public AssertionException(string msg) : base(msg) { } + /// Wraps an inner exception. + public AssertionException(string msg, Exception inner) : base(msg, inner) { } + /// Serializable constructor. + protected AssertionException(SerializationInfo info, StreamingContext context) : base(info, context) { } +} + +/// Helper class for Mono EFL bindings tests. +public static class Test +{ + /// Asserts a boolean condition. + 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}"); + } + + /// Asserts if expected is equal to actual, using expected.Equals(actual). + public static void AssertEquals(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}"); + } + } + + /// Asserts if expected is not equal to actual, using !expected.Equals(actual). + public static void AssertNotEquals(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}"); + } + } + + /// Asserts if actual is near enough of expected, using the optional tolerance (default 0.00001). + 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}"); + } + } + + /// Asserts if greater is greater than smaller , using greater.CompareTo(smaller) > 0. + public static void AssertGreaterThan(T greater, T smaller, String msg = null, + [CallerLineNumber] int line = 0, + [CallerFilePath] string file = null, + [CallerMemberName] string member = null) where T : System.IComparable + { + 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}"); + } + } + + /// Asserts if smaller is smaller than greater, using greater.CompareTo(smaller) < 0. + public static void AssertLessThan(T smaller, T greater, String msg = null, + [CallerLineNumber] int line = 0, + [CallerFilePath] string file = null, + [CallerMemberName] string member = null) where T : System.IComparable + { + 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}"); + } + } + + /// Asserts if op, when called, raises the exception T. + [SuppressMessage("Gendarme.Rules.Design.Generic", "AvoidMethodWithUnusedGenericTypeRule")] + public static void AssertRaises(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}"); + } + + /// Asserts if op, when called, does not raise the exception T. + [SuppressMessage("Gendarme.Rules.Design.Generic", "AvoidMethodWithUnusedGenericTypeRule")] + public static void AssertNotRaises(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}"); + } + } + + /// Asserts if the given reference is null. + 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}"); + } +} + + diff --git a/src/tests/efl_mono/Value.cs b/src/tests/efl_mono/Value.cs new file mode 100644 index 0000000000..4744aa2ad7 --- /dev/null +++ b/src/tests/efl_mono/Value.cs @@ -0,0 +1,831 @@ +#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(() => v.Set(42)); + Test.AssertNotRaises(() => v.Set("Wumpus")); + Test.Assert(v.Setup(eina.ValueType.Int32)); + Test.AssertRaises(() => v.Set("Wat?")); + Test.AssertNotRaises(() => 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(v.Flush); + Test.AssertRaises(() => v.ToString()); + Test.AssertRaises(() => 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(() => v.Get(out x)); + x = 42; + Test.AssertRaises(() => v.Set(x)); + + v.Setup(eina.ValueType.String); + Test.AssertNotRaises(() => v.Set("Hello, EFL")); + + string y = String.Empty; + Test.AssertNotRaises(() => v.Get(out y)); + v.Flush(); + Test.AssertRaises(() => v.Get(out y)); + + v.Setup(eina.ValueType.Array, eina.ValueType.UInt32); + + Test.AssertNotRaises(() => + v.Append(42)); + v.Flush(); + Test.AssertRaises(() => + v.Append(42)); + + Test.AssertRaises(() => 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(() => 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(() => { + 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(() => array[0] = 1); + object val = null; + Test.AssertRaises(() => 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(() => 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(() => array[0] = 1); + Test.AssertRaises(() => placeholder = array[0]); + Test.Assert(array.Append(0)); + Test.AssertNotRaises(() => array[0] = 1); + Test.AssertNotRaises(() => placeholder = array[0]); + Test.AssertRaises(() => array[1] = 1); + Test.AssertRaises(() => placeholder = array[1]); + Test.Assert(array.Append(0)); + Test.AssertNotRaises(() => array[1] = 1); + Test.AssertNotRaises(() => 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(() => 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(() => list[0] = 1); + Test.AssertRaises(() => placeholder = list[0]); + Test.Assert(list.Append(0)); + Test.AssertNotRaises(() => list[0] = 1); + Test.AssertNotRaises(() => placeholder = list[0]); + Test.AssertRaises(() => list[1] = 1); + Test.AssertRaises(() => placeholder = list[1]); + Test.Assert(list.Append(0)); + Test.AssertNotRaises(() => list[1] = 1); + Test.AssertNotRaises(() => 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 +} diff --git a/src/tests/efl_mono/ValueEolian.cs b/src/tests/efl_mono/ValueEolian.cs new file mode 100644 index 0000000000..ec95e42269 --- /dev/null +++ b/src/tests/efl_mono/ValueEolian.cs @@ -0,0 +1,115 @@ +#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 +} + diff --git a/src/tests/efl_mono/libefl_mono_native_test.c b/src/tests/efl_mono/libefl_mono_native_test.c new file mode 100644 index 0000000000..09d0cd418c --- /dev/null +++ b/src/tests/efl_mono/libefl_mono_native_test.c @@ -0,0 +1,3245 @@ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +#include + +#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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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; +} + +// 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" + diff --git a/src/tests/efl_mono/mono_test_driver.sh b/src/tests/efl_mono/mono_test_driver.sh new file mode 100755 index 0000000000..56e3f12c74 --- /dev/null +++ b/src/tests/efl_mono/mono_test_driver.sh @@ -0,0 +1,5 @@ +#!/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 + diff --git a/src/tests/efl_mono/test_numberwrapper.eo b/src/tests/efl_mono/test_numberwrapper.eo new file mode 100644 index 0000000000..3402fbd54f --- /dev/null +++ b/src/tests/efl_mono/test_numberwrapper.eo @@ -0,0 +1,13 @@ +class Test.Numberwrapper (Efl.Object) { + methods { + @property number { + get { + } + set { + } + values { + n: int; + } + } + } +} diff --git a/src/tests/efl_mono/test_testing.eo b/src/tests/efl_mono/test_testing.eo new file mode 100644 index 0000000000..db6f13bcf2 --- /dev/null +++ b/src/tests/efl_mono/test_testing.eo @@ -0,0 +1,1246 @@ +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; + } + return: bool; + } + + eina_array_int_in_own { + params { + @in arr: array @owned; + } + return: bool; + } + check_eina_array_int_in_own { + return: bool; + } + + eina_array_int_out { + params { + @out arr: array; + } + return: bool; + } + check_eina_array_int_out { + return: bool; + } + + eina_array_int_out_own { + params { + @out arr: array @owned; + } + return: bool; + } + + eina_array_int_return { + return: array; + } + check_eina_array_int_return { + return: bool; + } + + eina_array_int_return_own { + return: array @owned; + } + + /* String */ + eina_array_str_in { + params { + @in arr: array; + } + return: bool; + } + + eina_array_str_in_own { + params { + @in arr: array @owned; + } + return: bool; + } + check_eina_array_str_in_own { + return: bool; + } + + eina_array_str_out { + params { + @out arr: array; + } + return: bool; + } + check_eina_array_str_out { + return: bool; + } + + eina_array_str_out_own { + params { + @out arr: array @owned; + } + return: bool; + } + + eina_array_str_return { + return: array; + } + check_eina_array_str_return { + return: bool; + } + + eina_array_str_return_own { + return: array @owned; + } + + /* Object */ + eina_array_obj_in { + params { + @in arr: array; + } + return: bool; + } + + eina_array_obj_in_own { + params { + @in arr: array @owned; + } + return: bool; + } + check_eina_array_obj_in_own { + return: bool; + } + + eina_array_obj_out { + params { + @out arr: array; + } + return: bool; + } + check_eina_array_obj_out { + return: bool; + } + + eina_array_obj_out_own { + params { + @out arr: array @owned; + } + return: bool; + } + + eina_array_obj_return { + return: array; + } + check_eina_array_obj_return { + return: bool; + } + + eina_array_obj_return_own { + return: array @owned; + } + + eina_array_obj_return_in { + params { + @in arr: array; + } + return: array; + } + + /* Eina Inarray */ + + /* Integer */ + eina_inarray_int_in { + params { + @in arr: inarray; + } + return: bool; + } + + eina_inarray_int_in_own { + params { + @in arr: inarray @owned; + } + return: bool; + } + check_eina_inarray_int_in_own { + return: bool; + } + + eina_inarray_int_out { + params { + @out arr: inarray; + } + return: bool; + } + check_eina_inarray_int_out { + return: bool; + } + + eina_inarray_int_out_own { + params { + @out arr: inarray @owned; + } + return: bool; + } + + eina_inarray_int_return { + return: inarray; + } + check_eina_inarray_int_return { + return: bool; + } + + eina_inarray_int_return_own { + return: inarray @owned; + } + + /* String */ + eina_inarray_str_in { + params { + @in arr: inarray; + } + return: bool; + } + + eina_inarray_str_in_own { + params { + @in arr: inarray @owned; + } + return: bool; + } + check_eina_inarray_str_in_own { + return: bool; + } + + eina_inarray_str_out { + params { + @out arr: inarray; + } + return: bool; + } + check_eina_inarray_str_out { + return: bool; + } + + eina_inarray_str_out_own { + params { + @out arr: inarray @owned; + } + return: bool; + } + + eina_inarray_str_return { + return: inarray; + } + check_eina_inarray_str_return { + return: bool; + } + + eina_inarray_str_return_own { + return: inarray @owned; + } + + /* Object */ + eina_inarray_obj_in { + params { + @in arr: inarray; + } + return: bool; + } + + eina_inarray_obj_in_own { + params { + @in arr: inarray @owned; + } + return: bool; + } + check_eina_inarray_obj_in_own { + return: bool; + } + + eina_inarray_obj_out { + params { + @out arr: inarray; + } + return: bool; + } + check_eina_inarray_obj_out { + return: bool; + } + + eina_inarray_obj_out_own { + params { + @out arr: inarray @owned; + } + return: bool; + } + + eina_inarray_obj_return { + return: inarray; + } + check_eina_inarray_obj_return { + return: bool; + } + + eina_inarray_obj_return_own { + return: inarray @owned; + } + + eina_inarray_obj_return_in { + params { + @in arr: inarray; + } + return: inarray; + } + + /* Eina List */ + + /* Integer */ + eina_list_int_in { + params { + @in lst: list; + } + return: bool; + } + + eina_list_int_in_own { + params { + @in lst: list @owned; + } + return: bool; + } + check_eina_list_int_in_own { + return: bool; + } + + eina_list_int_out { + params { + @out lst: list; + } + return: bool; + } + check_eina_list_int_out { + return: bool; + } + + eina_list_int_out_own { + params { + @out lst: list @owned; + } + return: bool; + } + + eina_list_int_return { + return: list; + } + check_eina_list_int_return { + return: bool; + } + + eina_list_int_return_own { + return: list @owned; + } + + /* String */ + eina_list_str_in { + params { + @in lst: list; + } + return: bool; + } + + eina_list_str_in_own { + params { + @in lst: list @owned; + } + return: bool; + } + check_eina_list_str_in_own { + return: bool; + } + + eina_list_str_out { + params { + @out lst: list; + } + return: bool; + } + check_eina_list_str_out { + return: bool; + } + + eina_list_str_out_own { + params { + @out lst: list @owned; + } + return: bool; + } + + eina_list_str_return { + return: list; + } + check_eina_list_str_return { + return: bool; + } + + eina_list_str_return_own { + return: list @owned; + } + + /* Object */ + eina_list_obj_in { + params { + @in lst: list; + } + return: bool; + } + + eina_list_obj_in_own { + params { + @in lst: list @owned; + } + return: bool; + } + check_eina_list_obj_in_own { + return: bool; + } + + eina_list_obj_out { + params { + @out lst: list; + } + return: bool; + } + check_eina_list_obj_out { + return: bool; + } + + eina_list_obj_out_own { + params { + @out lst: list @owned; + } + return: bool; + } + + eina_list_obj_return { + return: list; + } + check_eina_list_obj_return { + return: bool; + } + + eina_list_obj_return_own { + return: list @owned; + } + + eina_list_obj_return_in { + params { + @in lst: list; + } + return: list; + } + + /* Eina Inlist */ + + /* Integer */ + eina_inlist_int_in { + params { + @in lst: inlist; + } + return: bool; + } + + eina_inlist_int_in_own { + params { + @in lst: inlist @owned; + } + return: bool; + } + check_eina_inlist_int_in_own { + return: bool; + } + + eina_inlist_int_out { + params { + @out lst: inlist; + } + return: bool; + } + check_eina_inlist_int_out { + return: bool; + } + + eina_inlist_int_out_own { + params { + @out lst: inlist @owned; + } + return: bool; + } + + eina_inlist_int_return { + return: inlist; + } + check_eina_inlist_int_return { + return: bool; + } + + eina_inlist_int_return_own { + return: inlist @owned; + } + + /* String */ + eina_inlist_str_in { + params { + @in lst: inlist; + } + return: bool; + } + + eina_inlist_str_in_own { + params { + @in lst: inlist @owned; + } + return: bool; + } + check_eina_inlist_str_in_own { + return: bool; + } + + eina_inlist_str_out { + params { + @out lst: inlist; + } + return: bool; + } + check_eina_inlist_str_out { + return: bool; + } + + eina_inlist_str_out_own { + params { + @out lst: inlist @owned; + } + return: bool; + } + + eina_inlist_str_return { + return: inlist; + } + check_eina_inlist_str_return { + return: bool; + } + + eina_inlist_str_return_own { + return: inlist @owned; + } + + /* Object */ + eina_inlist_obj_in { + params { + @in lst: inlist; + } + return: bool; + } + + eina_inlist_obj_in_own { + params { + @in lst: inlist @owned; + } + return: bool; + } + check_eina_inlist_obj_in_own { + return: bool; + } + + eina_inlist_obj_out { + params { + @out lst: inlist; + } + return: bool; + } + check_eina_inlist_obj_out { + return: bool; + } + + eina_inlist_obj_out_own { + params { + @out lst: inlist @owned; + } + return: bool; + } + + eina_inlist_obj_return { + return: inlist; + } + check_eina_inlist_obj_return { + return: bool; + } + + eina_inlist_obj_return_own { + return: inlist @owned; + } + + eina_inlist_obj_return_in { + params { + @in lst: inlist; + } + return: inlist; + } + + + // Eina Hash // + + // Integer // + eina_hash_int_in { + params { + @in hsh: hash; + } + return: bool; + } + + eina_hash_int_in_own { + params { + @in hsh: hash @owned; + } + return: bool; + } + check_eina_hash_int_in_own { + return: bool; + } + + eina_hash_int_out { + params { + @out hsh: hash; + } + return: bool; + } + check_eina_hash_int_out { + return: bool; + } + + eina_hash_int_out_own { + params { + @out hsh: hash @owned; + } + return: bool; + } + check_eina_hash_int_out_own { + return: bool; + } + + eina_hash_int_return { + return: hash; + } + check_eina_hash_int_return { + return: bool; + } + + eina_hash_int_return_own { + return: hash @owned; + } + check_eina_hash_int_return_own { + return: bool; + } + + // String // + eina_hash_str_in { + params { + @in hsh: hash; + } + return: bool; + } + + eina_hash_str_in_own { + params { + @in hsh: hash @owned; + } + return: bool; + } + check_eina_hash_str_in_own { + return: bool; + } + + eina_hash_str_out { + params { + @out hsh: hash; + } + return: bool; + } + check_eina_hash_str_out { + return: bool; + } + + eina_hash_str_out_own { + params { + @out hsh: hash @owned; + } + return: bool; + } + check_eina_hash_str_out_own { + return: bool; + } + + eina_hash_str_return { + return: hash; + } + check_eina_hash_str_return { + return: bool; + } + + eina_hash_str_return_own { + return: hash @owned; + } + check_eina_hash_str_return_own { + return: bool; + } + + // Object // + eina_hash_obj_in { + params { + @in hsh: hash; + @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 @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; + @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 @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; + } + 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 @owned; + } + check_eina_hash_obj_return_own { + return: bool; + } + + /* Eina Iterator */ + + /* Integer */ + eina_iterator_int_in { + params { + @in itr: iterator; + } + return: bool; + } + + eina_iterator_int_in_own { + params { + @in itr: iterator @owned; + } + return: bool; + } + check_eina_iterator_int_in_own { + return: bool; + } + + eina_iterator_int_out { + params { + @out itr: iterator; + } + return: bool; + } + check_eina_iterator_int_out { + return: bool; + } + + eina_iterator_int_out_own { + params { + @out itr: iterator @owned; + } + return: bool; + } + + eina_iterator_int_return { + return: iterator; + } + check_eina_iterator_int_return { + return: bool; + } + + eina_iterator_int_return_own { + return: iterator @owned; + } + + /* String */ + eina_iterator_str_in { + params { + @in itr: iterator; + } + return: bool; + } + + eina_iterator_str_in_own { + params { + @in itr: iterator @owned; + } + return: bool; + } + check_eina_iterator_str_in_own { + return: bool; + } + + eina_iterator_str_out { + params { + @out itr: iterator; + } + return: bool; + } + check_eina_iterator_str_out { + return: bool; + } + + eina_iterator_str_out_own { + params { + @out itr: iterator @owned; + } + return: bool; + } + + eina_iterator_str_return { + return: iterator; + } + check_eina_iterator_str_return { + return: bool; + } + + eina_iterator_str_return_own { + return: iterator @owned; + } + + /* Object */ + eina_iterator_obj_in { + params { + @in itr: iterator; + } + return: bool; + } + + eina_iterator_obj_in_own { + params { + @in itr: iterator @owned; + } + return: bool; + } + check_eina_iterator_obj_in_own { + return: bool; + } + + eina_iterator_obj_out { + params { + @out itr: iterator; + } + return: bool; + } + check_eina_iterator_obj_out { + return: bool; + } + + eina_iterator_obj_out_own { + params { + @out itr: iterator @owned; + } + return: bool; + } + + eina_iterator_obj_return { + return: iterator; + } + check_eina_iterator_obj_return { + return: bool; + } + + eina_iterator_obj_return_own { + return: iterator @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; + } +}