summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorVitor Sousa <vitorsousasilva@gmail.com>2017-06-27 11:26:09 -0300
committerFelipe Magno de Almeida <felipe@expertisesolutions.com.br>2017-07-13 18:34:55 -0300
commit4f7b463d5a8fdb02da61d5bb9c66a6531dac5d24 (patch)
treedb8eb192393e2981962830c4a08908cef04151ed
parent3857187f541124a2f7129c616ae7b5ea5141e3e2 (diff)
eina_mono: some tests for eina.Iterator and rename aux test arrays from 'arr' to 'seq'
-rw-r--r--src/tests/efl_mono/Eina.cs553
-rw-r--r--src/tests/efl_mono/libefl_mono_native_test.c192
2 files changed, 459 insertions, 286 deletions
diff --git a/src/tests/efl_mono/Eina.cs b/src/tests/efl_mono/Eina.cs
index ef32d9a571..46bc65be56 100644
--- a/src/tests/efl_mono/Eina.cs
+++ b/src/tests/efl_mono/Eina.cs
@@ -9,7 +9,7 @@ using static EinaTestData.BaseData;
9namespace EinaTestData 9namespace EinaTestData
10{ 10{
11 11
12class BaseArray 12class BaseSequence
13{ 13{
14 public static byte[] Values() 14 public static byte[] Values()
15 { 15 {
@@ -19,13 +19,13 @@ class BaseArray
19 19
20public static class BaseData 20public static class BaseData
21{ 21{
22 public static readonly int[] base_arr_int = {0x0,0x2A,0x42}; 22 public static readonly int[] base_seq_int = {0x0,0x2A,0x42};
23 public static readonly int[] append_arr_int = {42,43,33}; 23 public static readonly int[] append_seq_int = {42,43,33};
24 public static readonly int[] modified_arr_int = {0x0,0x2A,0x42,42,43,33}; 24 public static readonly int[] modified_seq_int = {0x0,0x2A,0x42,42,43,33};
25 25
26 public static readonly string[] base_arr_str = {"0x0","0x2A","0x42"}; 26 public static readonly string[] base_seq_str = {"0x0","0x2A","0x42"};
27 public static readonly string[] append_arr_str = {"42","43","33"}; 27 public static readonly string[] append_seq_str = {"42","43","33"};
28 public static readonly string[] modified_arr_str = {"0x0","0x2A","0x42","42","43","33"}; 28 public static readonly string[] modified_seq_str = {"0x0","0x2A","0x42","42","43","33"};
29 29
30 public static test.Numberwrapper NW(int n) 30 public static test.Numberwrapper NW(int n)
31 { 31 {
@@ -34,7 +34,7 @@ public static class BaseData
34 return nw; 34 return nw;
35 } 35 }
36 36
37 public static test.Numberwrapper[] BaseArrObj() 37 public static test.Numberwrapper[] BaseSeqObj()
38 { 38 {
39 var a = new test.NumberwrapperConcrete(); 39 var a = new test.NumberwrapperConcrete();
40 var b = new test.NumberwrapperConcrete(); 40 var b = new test.NumberwrapperConcrete();
@@ -45,7 +45,7 @@ public static class BaseData
45 return new test.NumberwrapperConcrete[]{a,b,c}; 45 return new test.NumberwrapperConcrete[]{a,b,c};
46 } 46 }
47 47
48 public static test.Numberwrapper[] AppendArrObj() 48 public static test.Numberwrapper[] AppendSeqObj()
49 { 49 {
50 var a = new test.NumberwrapperConcrete(); 50 var a = new test.NumberwrapperConcrete();
51 var b = new test.NumberwrapperConcrete(); 51 var b = new test.NumberwrapperConcrete();
@@ -56,7 +56,7 @@ public static class BaseData
56 return new test.NumberwrapperConcrete[]{a,b,c}; 56 return new test.NumberwrapperConcrete[]{a,b,c};
57 } 57 }
58 58
59 public static test.Numberwrapper[] ModifiedArrObj() 59 public static test.Numberwrapper[] ModifiedSeqObj()
60 { 60 {
61 var a = new test.NumberwrapperConcrete(); 61 var a = new test.NumberwrapperConcrete();
62 var b = new test.NumberwrapperConcrete(); 62 var b = new test.NumberwrapperConcrete();
@@ -108,43 +108,43 @@ class NativeInheritImpl : test.TestingInherit
108 override public bool eina_slice_in(eina.Slice slice) 108 override public bool eina_slice_in(eina.Slice slice)
109 { 109 {
110 slice_in_flag = true; 110 slice_in_flag = true;
111 return slice.GetBytes().SequenceEqual(BaseArray.Values()); 111 return slice.GetBytes().SequenceEqual(BaseSequence.Values());
112 } 112 }
113 113
114 override public bool eina_rw_slice_in(eina.Rw_Slice slice) 114 override public bool eina_rw_slice_in(eina.Rw_Slice slice)
115 { 115 {
116 rw_slice_in_flag = true; 116 rw_slice_in_flag = true;
117 return slice.GetBytes().SequenceEqual(BaseArray.Values()); 117 return slice.GetBytes().SequenceEqual(BaseSequence.Values());
118 } 118 }
119 119
120 private byte[] slice_out_arr = null; 120 private byte[] slice_out_seq = null;
121 private GCHandle slice_out_pinned; 121 private GCHandle slice_out_pinned;
122 override public bool eina_slice_out(ref eina.Slice slice) 122 override public bool eina_slice_out(ref eina.Slice slice)
123 { 123 {
124 slice_out_flag = true; 124 slice_out_flag = true;
125 125
126 slice_out_arr = (byte[]) BaseArray.Values(); 126 slice_out_seq = (byte[]) BaseSequence.Values();
127 slice_out_pinned = GCHandle.Alloc(slice_out_arr, GCHandleType.Pinned); 127 slice_out_pinned = GCHandle.Alloc(slice_out_seq, GCHandleType.Pinned);
128 IntPtr ptr = slice_out_pinned.AddrOfPinnedObject(); 128 IntPtr ptr = slice_out_pinned.AddrOfPinnedObject();
129 129
130 slice.Mem = ptr; 130 slice.Mem = ptr;
131 slice.Len = (UIntPtr) slice_out_arr.Length; 131 slice.Len = (UIntPtr) slice_out_seq.Length;
132 132
133 return true; 133 return true;
134 } 134 }
135 135
136 private byte[] rw_slice_out_arr = null; 136 private byte[] rw_slice_out_seq = null;
137 private GCHandle rw_slice_out_pinned; 137 private GCHandle rw_slice_out_pinned;
138 override public bool eina_rw_slice_out(ref eina.Rw_Slice slice) 138 override public bool eina_rw_slice_out(ref eina.Rw_Slice slice)
139 { 139 {
140 rw_slice_out_flag = true; 140 rw_slice_out_flag = true;
141 141
142 rw_slice_out_arr = (byte[]) BaseArray.Values(); 142 rw_slice_out_seq = (byte[]) BaseSequence.Values();
143 rw_slice_out_pinned = GCHandle.Alloc(rw_slice_out_arr, GCHandleType.Pinned); 143 rw_slice_out_pinned = GCHandle.Alloc(rw_slice_out_seq, GCHandleType.Pinned);
144 IntPtr ptr = rw_slice_out_pinned.AddrOfPinnedObject(); 144 IntPtr ptr = rw_slice_out_pinned.AddrOfPinnedObject();
145 145
146 slice.Mem = ptr; 146 slice.Mem = ptr;
147 slice.Len = (UIntPtr) rw_slice_out_arr.Length; 147 slice.Len = (UIntPtr) rw_slice_out_seq.Length;
148 148
149 return true; 149 return true;
150 } 150 }
@@ -155,7 +155,7 @@ class NativeInheritImpl : test.TestingInherit
155 { 155 {
156 binbuf_in_flag = true; 156 binbuf_in_flag = true;
157 157
158 bool r = binbuf.GetBytes().SequenceEqual(BaseArray.Values()); 158 bool r = binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
159 r = r && !binbuf.Own; 159 r = r && !binbuf.Own;
160 160
161 binbuf.Insert(42, 0); 161 binbuf.Insert(42, 0);
@@ -172,7 +172,7 @@ class NativeInheritImpl : test.TestingInherit
172 { 172 {
173 binbuf_in_own_flag = true; 173 binbuf_in_own_flag = true;
174 174
175 bool r = binbuf.GetBytes().SequenceEqual(BaseArray.Values()); 175 bool r = binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
176 r = r && binbuf.Own; 176 r = r && binbuf.Own;
177 177
178 binbuf.Insert(42, 0); 178 binbuf.Insert(42, 0);
@@ -208,7 +208,7 @@ class NativeInheritImpl : test.TestingInherit
208 } 208 }
209 public bool binbuf_out_still_usable() 209 public bool binbuf_out_still_usable()
210 { 210 {
211 bool r = binbuf_out_binbuf.GetBytes().SequenceEqual(BaseArray.Values()); 211 bool r = binbuf_out_binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
212 r = r && binbuf_out_binbuf.Own; 212 r = r && binbuf_out_binbuf.Own;
213 213
214 binbuf_out_binbuf.Dispose(); 214 binbuf_out_binbuf.Dispose();
@@ -251,7 +251,7 @@ class NativeInheritImpl : test.TestingInherit
251 } 251 }
252 public bool binbuf_return_still_usable() 252 public bool binbuf_return_still_usable()
253 { 253 {
254 bool r = binbuf_return_binbuf.GetBytes().SequenceEqual(BaseArray.Values()); 254 bool r = binbuf_return_binbuf.GetBytes().SequenceEqual(BaseSequence.Values());
255 r = r && binbuf_return_binbuf.Own; 255 r = r && binbuf_return_binbuf.Own;
256 256
257 binbuf_return_binbuf.Dispose(); 257 binbuf_return_binbuf.Dispose();
@@ -290,7 +290,7 @@ class TestEinaBinbuf
290{ 290{
291 private static readonly byte[] test_string = System.Text.Encoding.UTF8.GetBytes("0123456789ABCDEF"); 291 private static readonly byte[] test_string = System.Text.Encoding.UTF8.GetBytes("0123456789ABCDEF");
292 292
293 private static readonly byte[] base_arr = BaseArray.Values(); 293 private static readonly byte[] base_seq = BaseSequence.Values();
294 294
295 public static void eina_binbuf_default() 295 public static void eina_binbuf_default()
296 { 296 {
@@ -430,7 +430,7 @@ class TestEinaBinbuf
430 public static void test_eina_binbuf_in() 430 public static void test_eina_binbuf_in()
431 { 431 {
432 test.Testing t = new test.TestingConcrete(); 432 test.Testing t = new test.TestingConcrete();
433 var binbuf = new eina.Binbuf(base_arr, (uint)base_arr.Length); 433 var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
434 Test.Assert(t.eina_binbuf_in(binbuf)); 434 Test.Assert(t.eina_binbuf_in(binbuf));
435 Test.Assert(binbuf.Own); 435 Test.Assert(binbuf.Own);
436 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33})); 436 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
@@ -441,7 +441,7 @@ class TestEinaBinbuf
441 public static void test_eina_binbuf_in_own() 441 public static void test_eina_binbuf_in_own()
442 { 442 {
443 test.Testing t = new test.TestingConcrete(); 443 test.Testing t = new test.TestingConcrete();
444 var binbuf = new eina.Binbuf(base_arr, (uint)base_arr.Length); 444 var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
445 Test.Assert(t.eina_binbuf_in_own(binbuf)); 445 Test.Assert(t.eina_binbuf_in_own(binbuf));
446 Test.Assert(!binbuf.Own); 446 Test.Assert(!binbuf.Own);
447 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33})); 447 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{43,42,0x0,0x2A,0x42,33}));
@@ -458,7 +458,7 @@ class TestEinaBinbuf
458 Test.Assert(!binbuf.Own); 458 Test.Assert(!binbuf.Own);
459 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 459 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
460 binbuf.Reset(); 460 binbuf.Reset();
461 Test.Assert(binbuf.Append(base_arr)); 461 Test.Assert(binbuf.Append(base_seq));
462 binbuf.Dispose(); 462 binbuf.Dispose();
463 Test.Assert(binbuf.Handle == IntPtr.Zero); 463 Test.Assert(binbuf.Handle == IntPtr.Zero);
464 Test.Assert(t.check_binbuf_out()); 464 Test.Assert(t.check_binbuf_out());
@@ -472,7 +472,7 @@ class TestEinaBinbuf
472 Test.Assert(binbuf.Own); 472 Test.Assert(binbuf.Own);
473 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 473 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
474 binbuf.Reset(); 474 binbuf.Reset();
475 Test.Assert(binbuf.Append(base_arr)); 475 Test.Assert(binbuf.Append(base_seq));
476 binbuf.Dispose(); 476 binbuf.Dispose();
477 Test.Assert(binbuf.Handle == IntPtr.Zero); 477 Test.Assert(binbuf.Handle == IntPtr.Zero);
478 } 478 }
@@ -484,7 +484,7 @@ class TestEinaBinbuf
484 Test.Assert(!binbuf.Own); 484 Test.Assert(!binbuf.Own);
485 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 485 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
486 binbuf.Reset(); 486 binbuf.Reset();
487 Test.Assert(binbuf.Append(base_arr)); 487 Test.Assert(binbuf.Append(base_seq));
488 binbuf.Dispose(); 488 binbuf.Dispose();
489 Test.Assert(binbuf.Handle == IntPtr.Zero); 489 Test.Assert(binbuf.Handle == IntPtr.Zero);
490 Test.Assert(t.check_binbuf_return()); 490 Test.Assert(t.check_binbuf_return());
@@ -497,7 +497,7 @@ class TestEinaBinbuf
497 Test.Assert(binbuf.Own); 497 Test.Assert(binbuf.Own);
498 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 498 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
499 binbuf.Reset(); 499 binbuf.Reset();
500 Test.Assert(binbuf.Append(base_arr)); 500 Test.Assert(binbuf.Append(base_seq));
501 binbuf.Dispose(); 501 binbuf.Dispose();
502 Test.Assert(binbuf.Handle == IntPtr.Zero); 502 Test.Assert(binbuf.Handle == IntPtr.Zero);
503 } 503 }
@@ -508,7 +508,7 @@ class TestEinaBinbuf
508 public static void test_inherit_eina_binbuf_in() 508 public static void test_inherit_eina_binbuf_in()
509 { 509 {
510 var t = new NativeInheritImpl(); 510 var t = new NativeInheritImpl();
511 var binbuf = new eina.Binbuf(base_arr, (uint)base_arr.Length); 511 var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
512 Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_in(t.raw_handle, binbuf.Handle)); 512 Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_in(t.raw_handle, binbuf.Handle));
513 Test.Assert(t.binbuf_in_flag); 513 Test.Assert(t.binbuf_in_flag);
514 Test.Assert(binbuf.Own); 514 Test.Assert(binbuf.Own);
@@ -520,7 +520,7 @@ class TestEinaBinbuf
520 public static void test_inherit_eina_binbuf_in_own() 520 public static void test_inherit_eina_binbuf_in_own()
521 { 521 {
522 var t = new NativeInheritImpl(); 522 var t = new NativeInheritImpl();
523 var binbuf = new eina.Binbuf(base_arr, (uint)base_arr.Length); 523 var binbuf = new eina.Binbuf(base_seq, (uint)base_seq.Length);
524 binbuf.Own = false; 524 binbuf.Own = false;
525 Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_in_own(t.raw_handle, binbuf.Handle)); 525 Test.Assert(NativeInheritImpl.test_testing_eina_binbuf_in_own(t.raw_handle, binbuf.Handle));
526 Test.Assert(t.binbuf_in_own_flag); 526 Test.Assert(t.binbuf_in_own_flag);
@@ -540,7 +540,7 @@ class TestEinaBinbuf
540 var binbuf = new eina.Binbuf(bb_hdl, false); 540 var binbuf = new eina.Binbuf(bb_hdl, false);
541 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 541 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
542 binbuf.Reset(); 542 binbuf.Reset();
543 Test.Assert(binbuf.Append(base_arr)); 543 Test.Assert(binbuf.Append(base_seq));
544 binbuf.Dispose(); 544 binbuf.Dispose();
545 Test.Assert(binbuf.Handle == IntPtr.Zero); 545 Test.Assert(binbuf.Handle == IntPtr.Zero);
546 Test.Assert(t.binbuf_out_still_usable()); 546 Test.Assert(t.binbuf_out_still_usable());
@@ -556,7 +556,7 @@ class TestEinaBinbuf
556 var binbuf = new eina.Binbuf(bb_hdl, true); 556 var binbuf = new eina.Binbuf(bb_hdl, true);
557 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 557 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
558 binbuf.Reset(); 558 binbuf.Reset();
559 Test.Assert(binbuf.Append(base_arr)); 559 Test.Assert(binbuf.Append(base_seq));
560 binbuf.Dispose(); 560 binbuf.Dispose();
561 Test.Assert(binbuf.Handle == IntPtr.Zero); 561 Test.Assert(binbuf.Handle == IntPtr.Zero);
562 Test.Assert(t.binbuf_out_own_no_longer_own()); 562 Test.Assert(t.binbuf_out_own_no_longer_own());
@@ -571,7 +571,7 @@ class TestEinaBinbuf
571 var binbuf = new eina.Binbuf(bb_hdl, false); 571 var binbuf = new eina.Binbuf(bb_hdl, false);
572 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 572 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
573 binbuf.Reset(); 573 binbuf.Reset();
574 Test.Assert(binbuf.Append(base_arr)); 574 Test.Assert(binbuf.Append(base_seq));
575 binbuf.Dispose(); 575 binbuf.Dispose();
576 Test.Assert(binbuf.Handle == IntPtr.Zero); 576 Test.Assert(binbuf.Handle == IntPtr.Zero);
577 Test.Assert(t.binbuf_return_still_usable()); 577 Test.Assert(t.binbuf_return_still_usable());
@@ -586,7 +586,7 @@ class TestEinaBinbuf
586 var binbuf = new eina.Binbuf(bb_hdl, true); 586 var binbuf = new eina.Binbuf(bb_hdl, true);
587 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33})); 587 Test.Assert(binbuf.GetBytes().SequenceEqual(new byte[]{33}));
588 binbuf.Reset(); 588 binbuf.Reset();
589 Test.Assert(binbuf.Append(base_arr)); 589 Test.Assert(binbuf.Append(base_seq));
590 binbuf.Dispose(); 590 binbuf.Dispose();
591 Test.Assert(binbuf.Handle == IntPtr.Zero); 591 Test.Assert(binbuf.Handle == IntPtr.Zero);
592 Test.Assert(t.binbuf_return_own_no_longer_own()); 592 Test.Assert(t.binbuf_return_own_no_longer_own());
@@ -595,19 +595,19 @@ class TestEinaBinbuf
595 595
596class TestEinaSlice 596class TestEinaSlice
597{ 597{
598 private static readonly byte[] base_arr = BaseArray.Values(); 598 private static readonly byte[] base_seq = BaseSequence.Values();
599 private static readonly GCHandle pinnedData = GCHandle.Alloc(base_arr, GCHandleType.Pinned); 599 private static readonly GCHandle pinnedData = GCHandle.Alloc(base_seq, GCHandleType.Pinned);
600 private static readonly IntPtr pinnedPtr = pinnedData.AddrOfPinnedObject(); 600 private static readonly IntPtr pinnedPtr = pinnedData.AddrOfPinnedObject();
601 601
602 public static void eina_slice_marshalling() 602 public static void eina_slice_marshalling()
603 { 603 {
604 var binbuf = new eina.Binbuf(base_arr); 604 var binbuf = new eina.Binbuf(base_seq);
605 Test.Assert(binbuf.Handle != IntPtr.Zero); 605 Test.Assert(binbuf.Handle != IntPtr.Zero);
606 606
607 eina.Slice slc = eina.Binbuf.eina_binbuf_slice_get(binbuf.Handle); 607 eina.Slice slc = eina.Binbuf.eina_binbuf_slice_get(binbuf.Handle);
608 608
609 Test.Assert(slc.GetBytes().SequenceEqual(base_arr)); 609 Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
610 Test.Assert(base_arr.Length == (int)(slc.Len)); 610 Test.Assert(base_seq.Length == (int)(slc.Len));
611 } 611 }
612 612
613 public static void eina_slice_size() 613 public static void eina_slice_size()
@@ -620,7 +620,7 @@ class TestEinaSlice
620 { 620 {
621 var binbuf = new eina.Binbuf(); 621 var binbuf = new eina.Binbuf();
622 binbuf.Append(new eina.Slice().PinnedDataSet(pinnedPtr, (UIntPtr)3)); 622 binbuf.Append(new eina.Slice().PinnedDataSet(pinnedPtr, (UIntPtr)3));
623 Test.Assert(binbuf.GetBytes().SequenceEqual(base_arr)); 623 Test.Assert(binbuf.GetBytes().SequenceEqual(base_seq));
624 } 624 }
625 625
626 public static void test_eina_slice_in() 626 public static void test_eina_slice_in()
@@ -632,8 +632,8 @@ class TestEinaSlice
632 632
633 public static void test_eina_rw_slice_in() 633 public static void test_eina_rw_slice_in()
634 { 634 {
635 var rw_arr = base_arr.Clone(); 635 var rw_seq = base_seq.Clone();
636 GCHandle pinnedRWData = GCHandle.Alloc(rw_arr, GCHandleType.Pinned); 636 GCHandle pinnedRWData = GCHandle.Alloc(rw_seq, GCHandleType.Pinned);
637 IntPtr ptr = pinnedRWData.AddrOfPinnedObject(); 637 IntPtr ptr = pinnedRWData.AddrOfPinnedObject();
638 638
639 var slc = new eina.Rw_Slice(ptr, (UIntPtr)3); 639 var slc = new eina.Rw_Slice(ptr, (UIntPtr)3);
@@ -652,8 +652,8 @@ class TestEinaSlice
652 var slc = new eina.Slice(); 652 var slc = new eina.Slice();
653 Test.Assert(t.eina_slice_out(ref slc)); 653 Test.Assert(t.eina_slice_out(ref slc));
654 Test.Assert(slc.Mem != IntPtr.Zero); 654 Test.Assert(slc.Mem != IntPtr.Zero);
655 Test.Assert(slc.Length == base_arr.Length); 655 Test.Assert(slc.Length == base_seq.Length);
656 Test.Assert(slc.GetBytes().SequenceEqual(base_arr)); 656 Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
657 } 657 }
658 658
659 public static void test_eina_rw_slice_out() 659 public static void test_eina_rw_slice_out()
@@ -662,8 +662,8 @@ class TestEinaSlice
662 var slc = new eina.Rw_Slice(); 662 var slc = new eina.Rw_Slice();
663 Test.Assert(t.eina_rw_slice_out(ref slc)); 663 Test.Assert(t.eina_rw_slice_out(ref slc));
664 Test.Assert(slc.Mem != IntPtr.Zero); 664 Test.Assert(slc.Mem != IntPtr.Zero);
665 Test.Assert(slc.Length == base_arr.Length); 665 Test.Assert(slc.Length == base_seq.Length);
666 Test.Assert(slc.GetBytes().SequenceEqual(base_arr)); 666 Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
667 } 667 }
668 668
669 /* 669 /*
@@ -686,8 +686,8 @@ class TestEinaSlice
686 686
687 public static void test_inherit_eina_rw_slice_in() 687 public static void test_inherit_eina_rw_slice_in()
688 { 688 {
689 var rw_arr = base_arr.Clone(); 689 var rw_seq = base_seq.Clone();
690 GCHandle pinnedRWData = GCHandle.Alloc(rw_arr, GCHandleType.Pinned); 690 GCHandle pinnedRWData = GCHandle.Alloc(rw_seq, GCHandleType.Pinned);
691 IntPtr ptr = pinnedRWData.AddrOfPinnedObject(); 691 IntPtr ptr = pinnedRWData.AddrOfPinnedObject();
692 692
693 var slc = new eina.Rw_Slice(ptr, (UIntPtr)3); 693 var slc = new eina.Rw_Slice(ptr, (UIntPtr)3);
@@ -696,7 +696,7 @@ class TestEinaSlice
696 Test.Assert(NativeInheritImpl.test_testing_eina_rw_slice_in(t.raw_handle, slc)); 696 Test.Assert(NativeInheritImpl.test_testing_eina_rw_slice_in(t.raw_handle, slc));
697 697
698 Test.Assert(t.rw_slice_in_flag); 698 Test.Assert(t.rw_slice_in_flag);
699 Test.Assert(slc.GetBytes().SequenceEqual(base_arr)); 699 Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
700 700
701 pinnedRWData.Free(); 701 pinnedRWData.Free();
702 } 702 }
@@ -708,8 +708,8 @@ class TestEinaSlice
708 Test.Assert(NativeInheritImpl.test_testing_eina_slice_out(t.raw_handle, ref slc)); 708 Test.Assert(NativeInheritImpl.test_testing_eina_slice_out(t.raw_handle, ref slc));
709 Test.Assert(t.slice_out_flag); 709 Test.Assert(t.slice_out_flag);
710 Test.Assert(slc.Mem != IntPtr.Zero); 710 Test.Assert(slc.Mem != IntPtr.Zero);
711 Test.Assert(slc.Length == base_arr.Length); 711 Test.Assert(slc.Length == base_seq.Length);
712 Test.Assert(slc.GetBytes().SequenceEqual(base_arr)); 712 Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
713 } 713 }
714 714
715 public static void test_inherit_eina_rw_slice_out() 715 public static void test_inherit_eina_rw_slice_out()
@@ -719,8 +719,8 @@ class TestEinaSlice
719 Test.Assert(NativeInheritImpl.test_testing_eina_rw_slice_out(t.raw_handle, ref slc)); 719 Test.Assert(NativeInheritImpl.test_testing_eina_rw_slice_out(t.raw_handle, ref slc));
720 Test.Assert(t.rw_slice_out_flag); 720 Test.Assert(t.rw_slice_out_flag);
721 Test.Assert(slc.Mem != IntPtr.Zero); 721 Test.Assert(slc.Mem != IntPtr.Zero);
722 Test.Assert(slc.Length == base_arr.Length); 722 Test.Assert(slc.Length == base_seq.Length);
723 Test.Assert(slc.GetBytes().SequenceEqual(base_arr)); 723 Test.Assert(slc.GetBytes().SequenceEqual(base_seq));
724 } 724 }
725} 725}
726 726
@@ -1001,10 +1001,10 @@ class TestEinaArray
1001 { 1001 {
1002 test.Testing t = new test.TestingConcrete(); 1002 test.Testing t = new test.TestingConcrete();
1003 var arr = new eina.Array<int>(); 1003 var arr = new eina.Array<int>();
1004 arr.Append(base_arr_int); 1004 arr.Append(base_seq_int);
1005 Test.Assert(t.eina_array_int_in(arr)); 1005 Test.Assert(t.eina_array_int_in(arr));
1006 Test.Assert(arr.Own); 1006 Test.Assert(arr.Own);
1007 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_int)); 1007 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
1008 arr.Dispose(); 1008 arr.Dispose();
1009 Test.Assert(arr.Handle == IntPtr.Zero); 1009 Test.Assert(arr.Handle == IntPtr.Zero);
1010 } 1010 }
@@ -1013,10 +1013,10 @@ class TestEinaArray
1013 { 1013 {
1014 test.Testing t = new test.TestingConcrete(); 1014 test.Testing t = new test.TestingConcrete();
1015 var arr = new eina.Array<int>(); 1015 var arr = new eina.Array<int>();
1016 arr.Append(base_arr_int); 1016 arr.Append(base_seq_int);
1017 Test.Assert(t.eina_array_int_in_own(arr)); 1017 Test.Assert(t.eina_array_int_in_own(arr));
1018 Test.Assert(!arr.Own); 1018 Test.Assert(!arr.Own);
1019 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_int)); 1019 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
1020 arr.Dispose(); 1020 arr.Dispose();
1021 Test.Assert(arr.Handle == IntPtr.Zero); 1021 Test.Assert(arr.Handle == IntPtr.Zero);
1022 Test.Assert(t.check_eina_array_int_in_own()); 1022 Test.Assert(t.check_eina_array_int_in_own());
@@ -1028,8 +1028,8 @@ class TestEinaArray
1028 eina.Array<int> arr; 1028 eina.Array<int> arr;
1029 Test.Assert(t.eina_array_int_out(out arr)); 1029 Test.Assert(t.eina_array_int_out(out arr));
1030 Test.Assert(!arr.Own); 1030 Test.Assert(!arr.Own);
1031 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1031 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1032 Test.Assert(arr.Append(append_arr_int)); 1032 Test.Assert(arr.Append(append_seq_int));
1033 arr.Dispose(); 1033 arr.Dispose();
1034 Test.Assert(arr.Handle == IntPtr.Zero); 1034 Test.Assert(arr.Handle == IntPtr.Zero);
1035 Test.Assert(t.check_eina_array_int_out()); 1035 Test.Assert(t.check_eina_array_int_out());
@@ -1041,8 +1041,8 @@ class TestEinaArray
1041 eina.Array<int> arr; 1041 eina.Array<int> arr;
1042 Test.Assert(t.eina_array_int_out_own(out arr)); 1042 Test.Assert(t.eina_array_int_out_own(out arr));
1043 Test.Assert(arr.Own); 1043 Test.Assert(arr.Own);
1044 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1044 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1045 Test.Assert(arr.Append(append_arr_int)); 1045 Test.Assert(arr.Append(append_seq_int));
1046 arr.Dispose(); 1046 arr.Dispose();
1047 Test.Assert(arr.Handle == IntPtr.Zero); 1047 Test.Assert(arr.Handle == IntPtr.Zero);
1048 } 1048 }
@@ -1052,8 +1052,8 @@ class TestEinaArray
1052 test.Testing t = new test.TestingConcrete(); 1052 test.Testing t = new test.TestingConcrete();
1053 var arr = t.eina_array_int_return(); 1053 var arr = t.eina_array_int_return();
1054 Test.Assert(!arr.Own); 1054 Test.Assert(!arr.Own);
1055 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1055 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1056 Test.Assert(arr.Append(append_arr_int)); 1056 Test.Assert(arr.Append(append_seq_int));
1057 arr.Dispose(); 1057 arr.Dispose();
1058 Test.Assert(arr.Handle == IntPtr.Zero); 1058 Test.Assert(arr.Handle == IntPtr.Zero);
1059 Test.Assert(t.check_eina_array_int_return()); 1059 Test.Assert(t.check_eina_array_int_return());
@@ -1064,8 +1064,8 @@ class TestEinaArray
1064 test.Testing t = new test.TestingConcrete(); 1064 test.Testing t = new test.TestingConcrete();
1065 var arr = t.eina_array_int_return_own(); 1065 var arr = t.eina_array_int_return_own();
1066 Test.Assert(arr.Own); 1066 Test.Assert(arr.Own);
1067 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1067 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1068 Test.Assert(arr.Append(append_arr_int)); 1068 Test.Assert(arr.Append(append_seq_int));
1069 arr.Dispose(); 1069 arr.Dispose();
1070 Test.Assert(arr.Handle == IntPtr.Zero); 1070 Test.Assert(arr.Handle == IntPtr.Zero);
1071 } 1071 }
@@ -1075,10 +1075,10 @@ class TestEinaArray
1075 { 1075 {
1076 test.Testing t = new test.TestingConcrete(); 1076 test.Testing t = new test.TestingConcrete();
1077 var arr = new eina.Array<string>(); 1077 var arr = new eina.Array<string>();
1078 arr.Append(base_arr_str); 1078 arr.Append(base_seq_str);
1079 Test.Assert(t.eina_array_str_in(arr)); 1079 Test.Assert(t.eina_array_str_in(arr));
1080 Test.Assert(arr.Own); 1080 Test.Assert(arr.Own);
1081 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_str)); 1081 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
1082 arr.Dispose(); 1082 arr.Dispose();
1083 Test.Assert(arr.Handle == IntPtr.Zero); 1083 Test.Assert(arr.Handle == IntPtr.Zero);
1084 } 1084 }
@@ -1087,10 +1087,10 @@ class TestEinaArray
1087 { 1087 {
1088 test.Testing t = new test.TestingConcrete(); 1088 test.Testing t = new test.TestingConcrete();
1089 var arr = new eina.Array<string>(); 1089 var arr = new eina.Array<string>();
1090 arr.Append(base_arr_str); 1090 arr.Append(base_seq_str);
1091 Test.Assert(t.eina_array_str_in_own(arr)); 1091 Test.Assert(t.eina_array_str_in_own(arr));
1092 Test.Assert(!arr.Own); 1092 Test.Assert(!arr.Own);
1093 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_str)); 1093 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
1094 arr.Dispose(); 1094 arr.Dispose();
1095 Test.Assert(arr.Handle == IntPtr.Zero); 1095 Test.Assert(arr.Handle == IntPtr.Zero);
1096 Test.Assert(t.check_eina_array_str_in_own()); 1096 Test.Assert(t.check_eina_array_str_in_own());
@@ -1102,8 +1102,8 @@ class TestEinaArray
1102 eina.Array<string> arr; 1102 eina.Array<string> arr;
1103 Test.Assert(t.eina_array_str_out(out arr)); 1103 Test.Assert(t.eina_array_str_out(out arr));
1104 Test.Assert(!arr.Own); 1104 Test.Assert(!arr.Own);
1105 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1105 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1106 Test.Assert(arr.Append(append_arr_str)); 1106 Test.Assert(arr.Append(append_seq_str));
1107 arr.Dispose(); 1107 arr.Dispose();
1108 Test.Assert(arr.Handle == IntPtr.Zero); 1108 Test.Assert(arr.Handle == IntPtr.Zero);
1109 Test.Assert(t.check_eina_array_str_out()); 1109 Test.Assert(t.check_eina_array_str_out());
@@ -1115,8 +1115,8 @@ class TestEinaArray
1115 eina.Array<string> arr; 1115 eina.Array<string> arr;
1116 Test.Assert(t.eina_array_str_out_own(out arr)); 1116 Test.Assert(t.eina_array_str_out_own(out arr));
1117 Test.Assert(arr.Own); 1117 Test.Assert(arr.Own);
1118 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1118 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1119 Test.Assert(arr.Append(append_arr_str)); 1119 Test.Assert(arr.Append(append_seq_str));
1120 arr.Dispose(); 1120 arr.Dispose();
1121 Test.Assert(arr.Handle == IntPtr.Zero); 1121 Test.Assert(arr.Handle == IntPtr.Zero);
1122 } 1122 }
@@ -1126,8 +1126,8 @@ class TestEinaArray
1126 test.Testing t = new test.TestingConcrete(); 1126 test.Testing t = new test.TestingConcrete();
1127 var arr = t.eina_array_str_return(); 1127 var arr = t.eina_array_str_return();
1128 Test.Assert(!arr.Own); 1128 Test.Assert(!arr.Own);
1129 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1129 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1130 Test.Assert(arr.Append(append_arr_str)); 1130 Test.Assert(arr.Append(append_seq_str));
1131 arr.Dispose(); 1131 arr.Dispose();
1132 Test.Assert(arr.Handle == IntPtr.Zero); 1132 Test.Assert(arr.Handle == IntPtr.Zero);
1133 Test.Assert(t.check_eina_array_str_return()); 1133 Test.Assert(t.check_eina_array_str_return());
@@ -1138,8 +1138,8 @@ class TestEinaArray
1138 test.Testing t = new test.TestingConcrete(); 1138 test.Testing t = new test.TestingConcrete();
1139 var arr = t.eina_array_str_return_own(); 1139 var arr = t.eina_array_str_return_own();
1140 Test.Assert(arr.Own); 1140 Test.Assert(arr.Own);
1141 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1141 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1142 Test.Assert(arr.Append(append_arr_str)); 1142 Test.Assert(arr.Append(append_seq_str));
1143 arr.Dispose(); 1143 arr.Dispose();
1144 Test.Assert(arr.Handle == IntPtr.Zero); 1144 Test.Assert(arr.Handle == IntPtr.Zero);
1145 } 1145 }
@@ -1150,10 +1150,10 @@ class TestEinaArray
1150 { 1150 {
1151 test.Testing t = new test.TestingConcrete(); 1151 test.Testing t = new test.TestingConcrete();
1152 var arr = new eina.Array<test.Numberwrapper>(); 1152 var arr = new eina.Array<test.Numberwrapper>();
1153 arr.Append(BaseArrObj()); 1153 arr.Append(BaseSeqObj());
1154 Test.Assert(t.eina_array_obj_in(arr)); 1154 Test.Assert(t.eina_array_obj_in(arr));
1155 Test.Assert(arr.Own); 1155 Test.Assert(arr.Own);
1156 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedArrObj()); 1156 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
1157 arr.Dispose(); 1157 arr.Dispose();
1158 Test.Assert(arr.Handle == IntPtr.Zero); 1158 Test.Assert(arr.Handle == IntPtr.Zero);
1159 } 1159 }
@@ -1162,10 +1162,10 @@ class TestEinaArray
1162 { 1162 {
1163 test.Testing t = new test.TestingConcrete(); 1163 test.Testing t = new test.TestingConcrete();
1164 var arr = new eina.Array<test.Numberwrapper>(); 1164 var arr = new eina.Array<test.Numberwrapper>();
1165 arr.Append(BaseArrObj()); 1165 arr.Append(BaseSeqObj());
1166 Test.Assert(t.eina_array_obj_in_own(arr)); 1166 Test.Assert(t.eina_array_obj_in_own(arr));
1167 Test.Assert(!arr.Own); 1167 Test.Assert(!arr.Own);
1168 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedArrObj()); 1168 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
1169 arr.Dispose(); 1169 arr.Dispose();
1170 Test.Assert(arr.Handle == IntPtr.Zero); 1170 Test.Assert(arr.Handle == IntPtr.Zero);
1171 Test.Assert(t.check_eina_array_obj_in_own()); 1171 Test.Assert(t.check_eina_array_obj_in_own());
@@ -1177,8 +1177,8 @@ class TestEinaArray
1177 eina.Array<test.Numberwrapper> arr; 1177 eina.Array<test.Numberwrapper> arr;
1178 Test.Assert(t.eina_array_obj_out(out arr)); 1178 Test.Assert(t.eina_array_obj_out(out arr));
1179 Test.Assert(!arr.Own); 1179 Test.Assert(!arr.Own);
1180 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1180 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1181 Test.Assert(arr.Append(AppendArrObj())); 1181 Test.Assert(arr.Append(AppendSeqObj()));
1182 arr.Dispose(); 1182 arr.Dispose();
1183 Test.Assert(arr.Handle == IntPtr.Zero); 1183 Test.Assert(arr.Handle == IntPtr.Zero);
1184 Test.Assert(t.check_eina_array_obj_out()); 1184 Test.Assert(t.check_eina_array_obj_out());
@@ -1190,8 +1190,8 @@ class TestEinaArray
1190 eina.Array<test.Numberwrapper> arr; 1190 eina.Array<test.Numberwrapper> arr;
1191 Test.Assert(t.eina_array_obj_out_own(out arr)); 1191 Test.Assert(t.eina_array_obj_out_own(out arr));
1192 Test.Assert(arr.Own); 1192 Test.Assert(arr.Own);
1193 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1193 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1194 Test.Assert(arr.Append(AppendArrObj())); 1194 Test.Assert(arr.Append(AppendSeqObj()));
1195 arr.Dispose(); 1195 arr.Dispose();
1196 Test.Assert(arr.Handle == IntPtr.Zero); 1196 Test.Assert(arr.Handle == IntPtr.Zero);
1197 } 1197 }
@@ -1201,8 +1201,8 @@ class TestEinaArray
1201 test.Testing t = new test.TestingConcrete(); 1201 test.Testing t = new test.TestingConcrete();
1202 var arr = t.eina_array_obj_return(); 1202 var arr = t.eina_array_obj_return();
1203 Test.Assert(!arr.Own); 1203 Test.Assert(!arr.Own);
1204 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1204 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1205 Test.Assert(arr.Append(AppendArrObj())); 1205 Test.Assert(arr.Append(AppendSeqObj()));
1206 arr.Dispose(); 1206 arr.Dispose();
1207 Test.Assert(arr.Handle == IntPtr.Zero); 1207 Test.Assert(arr.Handle == IntPtr.Zero);
1208 Test.Assert(t.check_eina_array_obj_return()); 1208 Test.Assert(t.check_eina_array_obj_return());
@@ -1213,8 +1213,8 @@ class TestEinaArray
1213 test.Testing t = new test.TestingConcrete(); 1213 test.Testing t = new test.TestingConcrete();
1214 var arr = t.eina_array_obj_return_own(); 1214 var arr = t.eina_array_obj_return_own();
1215 Test.Assert(arr.Own); 1215 Test.Assert(arr.Own);
1216 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1216 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1217 Test.Assert(arr.Append(AppendArrObj())); 1217 Test.Assert(arr.Append(AppendSeqObj()));
1218 arr.Dispose(); 1218 arr.Dispose();
1219 Test.Assert(arr.Handle == IntPtr.Zero); 1219 Test.Assert(arr.Handle == IntPtr.Zero);
1220 } 1220 }
@@ -1222,12 +1222,12 @@ class TestEinaArray
1222 public static void test_eina_array_obj_return_in_same_id() 1222 public static void test_eina_array_obj_return_in_same_id()
1223 { 1223 {
1224 test.Testing t = new test.TestingConcrete(); 1224 test.Testing t = new test.TestingConcrete();
1225 var cmp = BaseArrObj(); 1225 var cmp = BaseSeqObj();
1226 var a = new eina.Array<test.Numberwrapper>(); 1226 var a = new eina.Array<test.Numberwrapper>();
1227 a.Append(cmp); 1227 a.Append(cmp);
1228 var b = t.eina_array_obj_return_in(a); 1228 var b = t.eina_array_obj_return_in(a);
1229 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray()); 1229 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
1230 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseArrObj()); 1230 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
1231 int len = a.Length; 1231 int len = a.Length;
1232 for (int i=0; i < len; ++i) 1232 for (int i=0; i < len; ++i)
1233 { 1233 {
@@ -1545,10 +1545,10 @@ class TestEinaInarray
1545 { 1545 {
1546 test.Testing t = new test.TestingConcrete(); 1546 test.Testing t = new test.TestingConcrete();
1547 var arr = new eina.Inarray<int>(); 1547 var arr = new eina.Inarray<int>();
1548 arr.Append(base_arr_int); 1548 arr.Append(base_seq_int);
1549 Test.Assert(t.eina_inarray_int_in(arr)); 1549 Test.Assert(t.eina_inarray_int_in(arr));
1550 Test.Assert(arr.Own); 1550 Test.Assert(arr.Own);
1551 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_int)); 1551 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
1552 arr.Dispose(); 1552 arr.Dispose();
1553 Test.Assert(arr.Handle == IntPtr.Zero); 1553 Test.Assert(arr.Handle == IntPtr.Zero);
1554 } 1554 }
@@ -1557,10 +1557,10 @@ class TestEinaInarray
1557 { 1557 {
1558 test.Testing t = new test.TestingConcrete(); 1558 test.Testing t = new test.TestingConcrete();
1559 var arr = new eina.Inarray<int>(); 1559 var arr = new eina.Inarray<int>();
1560 arr.Append(base_arr_int); 1560 arr.Append(base_seq_int);
1561 Test.Assert(t.eina_inarray_int_in_own(arr)); 1561 Test.Assert(t.eina_inarray_int_in_own(arr));
1562 Test.Assert(!arr.Own); 1562 Test.Assert(!arr.Own);
1563 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_int)); 1563 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_int));
1564 arr.Dispose(); 1564 arr.Dispose();
1565 Test.Assert(arr.Handle == IntPtr.Zero); 1565 Test.Assert(arr.Handle == IntPtr.Zero);
1566 Test.Assert(t.check_eina_inarray_int_in_own()); 1566 Test.Assert(t.check_eina_inarray_int_in_own());
@@ -1572,8 +1572,8 @@ class TestEinaInarray
1572 eina.Inarray<int> arr; 1572 eina.Inarray<int> arr;
1573 Test.Assert(t.eina_inarray_int_out(out arr)); 1573 Test.Assert(t.eina_inarray_int_out(out arr));
1574 Test.Assert(!arr.Own); 1574 Test.Assert(!arr.Own);
1575 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1575 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1576 Test.Assert(arr.Append(append_arr_int)); 1576 Test.Assert(arr.Append(append_seq_int));
1577 arr.Dispose(); 1577 arr.Dispose();
1578 Test.Assert(arr.Handle == IntPtr.Zero); 1578 Test.Assert(arr.Handle == IntPtr.Zero);
1579 Test.Assert(t.check_eina_inarray_int_out()); 1579 Test.Assert(t.check_eina_inarray_int_out());
@@ -1585,8 +1585,8 @@ class TestEinaInarray
1585 eina.Inarray<int> arr; 1585 eina.Inarray<int> arr;
1586 Test.Assert(t.eina_inarray_int_out_own(out arr)); 1586 Test.Assert(t.eina_inarray_int_out_own(out arr));
1587 Test.Assert(arr.Own); 1587 Test.Assert(arr.Own);
1588 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1588 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1589 Test.Assert(arr.Append(append_arr_int)); 1589 Test.Assert(arr.Append(append_seq_int));
1590 arr.Dispose(); 1590 arr.Dispose();
1591 Test.Assert(arr.Handle == IntPtr.Zero); 1591 Test.Assert(arr.Handle == IntPtr.Zero);
1592 } 1592 }
@@ -1596,8 +1596,8 @@ class TestEinaInarray
1596 test.Testing t = new test.TestingConcrete(); 1596 test.Testing t = new test.TestingConcrete();
1597 var arr = t.eina_inarray_int_return(); 1597 var arr = t.eina_inarray_int_return();
1598 Test.Assert(!arr.Own); 1598 Test.Assert(!arr.Own);
1599 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1599 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1600 Test.Assert(arr.Append(append_arr_int)); 1600 Test.Assert(arr.Append(append_seq_int));
1601 arr.Dispose(); 1601 arr.Dispose();
1602 Test.Assert(arr.Handle == IntPtr.Zero); 1602 Test.Assert(arr.Handle == IntPtr.Zero);
1603 Test.Assert(t.check_eina_inarray_int_return()); 1603 Test.Assert(t.check_eina_inarray_int_return());
@@ -1608,8 +1608,8 @@ class TestEinaInarray
1608 test.Testing t = new test.TestingConcrete(); 1608 test.Testing t = new test.TestingConcrete();
1609 var arr = t.eina_inarray_int_return_own(); 1609 var arr = t.eina_inarray_int_return_own();
1610 Test.Assert(arr.Own); 1610 Test.Assert(arr.Own);
1611 Test.Assert(arr.ToArray().SequenceEqual(base_arr_int)); 1611 Test.Assert(arr.ToArray().SequenceEqual(base_seq_int));
1612 Test.Assert(arr.Append(append_arr_int)); 1612 Test.Assert(arr.Append(append_seq_int));
1613 arr.Dispose(); 1613 arr.Dispose();
1614 Test.Assert(arr.Handle == IntPtr.Zero); 1614 Test.Assert(arr.Handle == IntPtr.Zero);
1615 } 1615 }
@@ -1619,10 +1619,10 @@ class TestEinaInarray
1619 { 1619 {
1620 test.Testing t = new test.TestingConcrete(); 1620 test.Testing t = new test.TestingConcrete();
1621 var arr = new eina.Inarray<string>(); 1621 var arr = new eina.Inarray<string>();
1622 arr.Append(base_arr_str); 1622 arr.Append(base_seq_str);
1623 Test.Assert(t.eina_inarray_str_in(arr)); 1623 Test.Assert(t.eina_inarray_str_in(arr));
1624 Test.Assert(arr.Own); 1624 Test.Assert(arr.Own);
1625 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_str)); 1625 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
1626 arr.Dispose(); 1626 arr.Dispose();
1627 Test.Assert(arr.Handle == IntPtr.Zero); 1627 Test.Assert(arr.Handle == IntPtr.Zero);
1628 } 1628 }
@@ -1631,10 +1631,10 @@ class TestEinaInarray
1631 { 1631 {
1632 test.Testing t = new test.TestingConcrete(); 1632 test.Testing t = new test.TestingConcrete();
1633 var arr = new eina.Inarray<string>(); 1633 var arr = new eina.Inarray<string>();
1634 arr.Append(base_arr_str); 1634 arr.Append(base_seq_str);
1635 Test.Assert(t.eina_inarray_str_in_own(arr)); 1635 Test.Assert(t.eina_inarray_str_in_own(arr));
1636 Test.Assert(!arr.Own); 1636 Test.Assert(!arr.Own);
1637 Test.Assert(arr.ToArray().SequenceEqual(modified_arr_str)); 1637 Test.Assert(arr.ToArray().SequenceEqual(modified_seq_str));
1638 arr.Dispose(); 1638 arr.Dispose();
1639 Test.Assert(arr.Handle == IntPtr.Zero); 1639 Test.Assert(arr.Handle == IntPtr.Zero);
1640 Test.Assert(t.check_eina_inarray_str_in_own()); 1640 Test.Assert(t.check_eina_inarray_str_in_own());
@@ -1646,8 +1646,8 @@ class TestEinaInarray
1646 eina.Inarray<string> arr; 1646 eina.Inarray<string> arr;
1647 Test.Assert(t.eina_inarray_str_out(out arr)); 1647 Test.Assert(t.eina_inarray_str_out(out arr));
1648 Test.Assert(!arr.Own); 1648 Test.Assert(!arr.Own);
1649 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1649 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1650 Test.Assert(arr.Append(append_arr_str)); 1650 Test.Assert(arr.Append(append_seq_str));
1651 arr.Dispose(); 1651 arr.Dispose();
1652 Test.Assert(arr.Handle == IntPtr.Zero); 1652 Test.Assert(arr.Handle == IntPtr.Zero);
1653 Test.Assert(t.check_eina_inarray_str_out()); 1653 Test.Assert(t.check_eina_inarray_str_out());
@@ -1659,8 +1659,8 @@ class TestEinaInarray
1659 eina.Inarray<string> arr; 1659 eina.Inarray<string> arr;
1660 Test.Assert(t.eina_inarray_str_out_own(out arr)); 1660 Test.Assert(t.eina_inarray_str_out_own(out arr));
1661 Test.Assert(arr.Own); 1661 Test.Assert(arr.Own);
1662 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1662 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1663 Test.Assert(arr.Append(append_arr_str)); 1663 Test.Assert(arr.Append(append_seq_str));
1664 arr.Dispose(); 1664 arr.Dispose();
1665 Test.Assert(arr.Handle == IntPtr.Zero); 1665 Test.Assert(arr.Handle == IntPtr.Zero);
1666 } 1666 }
@@ -1670,8 +1670,8 @@ class TestEinaInarray
1670 test.Testing t = new test.TestingConcrete(); 1670 test.Testing t = new test.TestingConcrete();
1671 var arr = t.eina_inarray_str_return(); 1671 var arr = t.eina_inarray_str_return();
1672 Test.Assert(!arr.Own); 1672 Test.Assert(!arr.Own);
1673 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1673 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1674 Test.Assert(arr.Append(append_arr_str)); 1674 Test.Assert(arr.Append(append_seq_str));
1675 arr.Dispose(); 1675 arr.Dispose();
1676 Test.Assert(arr.Handle == IntPtr.Zero); 1676 Test.Assert(arr.Handle == IntPtr.Zero);
1677 Test.Assert(t.check_eina_inarray_str_return()); 1677 Test.Assert(t.check_eina_inarray_str_return());
@@ -1682,8 +1682,8 @@ class TestEinaInarray
1682 test.Testing t = new test.TestingConcrete(); 1682 test.Testing t = new test.TestingConcrete();
1683 var arr = t.eina_inarray_str_return_own(); 1683 var arr = t.eina_inarray_str_return_own();
1684 Test.Assert(arr.Own); 1684 Test.Assert(arr.Own);
1685 Test.Assert(arr.ToArray().SequenceEqual(base_arr_str)); 1685 Test.Assert(arr.ToArray().SequenceEqual(base_seq_str));
1686 Test.Assert(arr.Append(append_arr_str)); 1686 Test.Assert(arr.Append(append_seq_str));
1687 arr.Dispose(); 1687 arr.Dispose();
1688 Test.Assert(arr.Handle == IntPtr.Zero); 1688 Test.Assert(arr.Handle == IntPtr.Zero);
1689 } 1689 }
@@ -1694,10 +1694,10 @@ class TestEinaInarray
1694 { 1694 {
1695 test.Testing t = new test.TestingConcrete(); 1695 test.Testing t = new test.TestingConcrete();
1696 var arr = new eina.Inarray<test.Numberwrapper>(); 1696 var arr = new eina.Inarray<test.Numberwrapper>();
1697 arr.Append(BaseArrObj()); 1697 arr.Append(BaseSeqObj());
1698 Test.Assert(t.eina_inarray_obj_in(arr)); 1698 Test.Assert(t.eina_inarray_obj_in(arr));
1699 Test.Assert(arr.Own); 1699 Test.Assert(arr.Own);
1700 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedArrObj()); 1700 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
1701 arr.Dispose(); 1701 arr.Dispose();
1702 Test.Assert(arr.Handle == IntPtr.Zero); 1702 Test.Assert(arr.Handle == IntPtr.Zero);
1703 } 1703 }
@@ -1706,10 +1706,10 @@ class TestEinaInarray
1706 { 1706 {
1707 test.Testing t = new test.TestingConcrete(); 1707 test.Testing t = new test.TestingConcrete();
1708 var arr = new eina.Inarray<test.Numberwrapper>(); 1708 var arr = new eina.Inarray<test.Numberwrapper>();
1709 arr.Append(BaseArrObj()); 1709 arr.Append(BaseSeqObj());
1710 Test.Assert(t.eina_inarray_obj_in_own(arr)); 1710 Test.Assert(t.eina_inarray_obj_in_own(arr));
1711 Test.Assert(!arr.Own); 1711 Test.Assert(!arr.Own);
1712 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedArrObj()); 1712 NumberwrapperSequenceAssertEqual(arr.ToArray(), ModifiedSeqObj());
1713 arr.Dispose(); 1713 arr.Dispose();
1714 Test.Assert(arr.Handle == IntPtr.Zero); 1714 Test.Assert(arr.Handle == IntPtr.Zero);
1715 Test.Assert(t.check_eina_inarray_obj_in_own()); 1715 Test.Assert(t.check_eina_inarray_obj_in_own());
@@ -1721,8 +1721,8 @@ class TestEinaInarray
1721 eina.Inarray<test.Numberwrapper> arr; 1721 eina.Inarray<test.Numberwrapper> arr;
1722 Test.Assert(t.eina_inarray_obj_out(out arr)); 1722 Test.Assert(t.eina_inarray_obj_out(out arr));
1723 Test.Assert(!arr.Own); 1723 Test.Assert(!arr.Own);
1724 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1724 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1725 Test.Assert(arr.Append(AppendArrObj())); 1725 Test.Assert(arr.Append(AppendSeqObj()));
1726 arr.Dispose(); 1726 arr.Dispose();
1727 Test.Assert(arr.Handle == IntPtr.Zero); 1727 Test.Assert(arr.Handle == IntPtr.Zero);
1728 Test.Assert(t.check_eina_inarray_obj_out()); 1728 Test.Assert(t.check_eina_inarray_obj_out());
@@ -1734,8 +1734,8 @@ class TestEinaInarray
1734 eina.Inarray<test.Numberwrapper> arr; 1734 eina.Inarray<test.Numberwrapper> arr;
1735 Test.Assert(t.eina_inarray_obj_out_own(out arr)); 1735 Test.Assert(t.eina_inarray_obj_out_own(out arr));
1736 Test.Assert(arr.Own); 1736 Test.Assert(arr.Own);
1737 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1737 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1738 Test.Assert(arr.Append(AppendArrObj())); 1738 Test.Assert(arr.Append(AppendSeqObj()));
1739 arr.Dispose(); 1739 arr.Dispose();
1740 Test.Assert(arr.Handle == IntPtr.Zero); 1740 Test.Assert(arr.Handle == IntPtr.Zero);
1741 } 1741 }
@@ -1745,8 +1745,8 @@ class TestEinaInarray
1745 test.Testing t = new test.TestingConcrete(); 1745 test.Testing t = new test.TestingConcrete();
1746 var arr = t.eina_inarray_obj_return(); 1746 var arr = t.eina_inarray_obj_return();
1747 Test.Assert(!arr.Own); 1747 Test.Assert(!arr.Own);
1748 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1748 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1749 Test.Assert(arr.Append(AppendArrObj())); 1749 Test.Assert(arr.Append(AppendSeqObj()));
1750 arr.Dispose(); 1750 arr.Dispose();
1751 Test.Assert(arr.Handle == IntPtr.Zero); 1751 Test.Assert(arr.Handle == IntPtr.Zero);
1752 Test.Assert(t.check_eina_inarray_obj_return()); 1752 Test.Assert(t.check_eina_inarray_obj_return());
@@ -1757,8 +1757,8 @@ class TestEinaInarray
1757 test.Testing t = new test.TestingConcrete(); 1757 test.Testing t = new test.TestingConcrete();
1758 var arr = t.eina_inarray_obj_return_own(); 1758 var arr = t.eina_inarray_obj_return_own();
1759 Test.Assert(arr.Own); 1759 Test.Assert(arr.Own);
1760 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseArrObj()); 1760 NumberwrapperSequenceAssertEqual(arr.ToArray(), BaseSeqObj());
1761 Test.Assert(arr.Append(AppendArrObj())); 1761 Test.Assert(arr.Append(AppendSeqObj()));
1762 arr.Dispose(); 1762 arr.Dispose();
1763 Test.Assert(arr.Handle == IntPtr.Zero); 1763 Test.Assert(arr.Handle == IntPtr.Zero);
1764 } 1764 }
@@ -1766,12 +1766,12 @@ class TestEinaInarray
1766 public static void test_eina_inarray_obj_return_in_same_id() 1766 public static void test_eina_inarray_obj_return_in_same_id()
1767 { 1767 {
1768 test.Testing t = new test.TestingConcrete(); 1768 test.Testing t = new test.TestingConcrete();
1769 var cmp = BaseArrObj(); 1769 var cmp = BaseSeqObj();
1770 var a = new eina.Inarray<test.Numberwrapper>(); 1770 var a = new eina.Inarray<test.Numberwrapper>();
1771 a.Append(cmp); 1771 a.Append(cmp);
1772 var b = t.eina_inarray_obj_return_in(a); 1772 var b = t.eina_inarray_obj_return_in(a);
1773 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray()); 1773 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
1774 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseArrObj()); 1774 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
1775 int len = a.Length; 1775 int len = a.Length;
1776 for (int i=0; i < len; ++i) 1776 for (int i=0; i < len; ++i)
1777 { 1777 {
@@ -2114,10 +2114,10 @@ class TestEinaList
2114 { 2114 {
2115 test.Testing t = new test.TestingConcrete(); 2115 test.Testing t = new test.TestingConcrete();
2116 var lst = new eina.List<int>(); 2116 var lst = new eina.List<int>();
2117 lst.AppendArray(base_arr_int); 2117 lst.AppendArray(base_seq_int);
2118 Test.Assert(t.eina_list_int_in(lst)); 2118 Test.Assert(t.eina_list_int_in(lst));
2119 Test.Assert(lst.Own); 2119 Test.Assert(lst.Own);
2120 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2120 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2121 lst.Dispose(); 2121 lst.Dispose();
2122 Test.Assert(lst.Handle == IntPtr.Zero); 2122 Test.Assert(lst.Handle == IntPtr.Zero);
2123 } 2123 }
@@ -2126,7 +2126,7 @@ class TestEinaList
2126 { 2126 {
2127 test.Testing t = new test.TestingConcrete(); 2127 test.Testing t = new test.TestingConcrete();
2128 var lst = new eina.List<int>(); 2128 var lst = new eina.List<int>();
2129 lst.AppendArray(base_arr_int); 2129 lst.AppendArray(base_seq_int);
2130 Test.Assert(t.eina_list_int_in_own(lst)); 2130 Test.Assert(t.eina_list_int_in_own(lst));
2131 Test.Assert(!lst.Own); 2131 Test.Assert(!lst.Own);
2132 lst.Dispose(); 2132 lst.Dispose();
@@ -2140,7 +2140,7 @@ class TestEinaList
2140 eina.List<int> lst; 2140 eina.List<int> lst;
2141 Test.Assert(t.eina_list_int_out(out lst)); 2141 Test.Assert(t.eina_list_int_out(out lst));
2142 Test.Assert(!lst.Own); 2142 Test.Assert(!lst.Own);
2143 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2143 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2144 lst.Dispose(); 2144 lst.Dispose();
2145 Test.Assert(lst.Handle == IntPtr.Zero); 2145 Test.Assert(lst.Handle == IntPtr.Zero);
2146 Test.Assert(t.check_eina_list_int_out()); 2146 Test.Assert(t.check_eina_list_int_out());
@@ -2152,8 +2152,8 @@ class TestEinaList
2152 eina.List<int> lst; 2152 eina.List<int> lst;
2153 Test.Assert(t.eina_list_int_out_own(out lst)); 2153 Test.Assert(t.eina_list_int_out_own(out lst));
2154 Test.Assert(lst.Own); 2154 Test.Assert(lst.Own);
2155 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2155 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2156 lst.AppendArray(append_arr_int); 2156 lst.AppendArray(append_seq_int);
2157 lst.Dispose(); 2157 lst.Dispose();
2158 Test.Assert(lst.Handle == IntPtr.Zero); 2158 Test.Assert(lst.Handle == IntPtr.Zero);
2159 } 2159 }
@@ -2163,7 +2163,7 @@ class TestEinaList
2163 test.Testing t = new test.TestingConcrete(); 2163 test.Testing t = new test.TestingConcrete();
2164 var lst = t.eina_list_int_return(); 2164 var lst = t.eina_list_int_return();
2165 Test.Assert(!lst.Own); 2165 Test.Assert(!lst.Own);
2166 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2166 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2167 lst.Dispose(); 2167 lst.Dispose();
2168 Test.Assert(lst.Handle == IntPtr.Zero); 2168 Test.Assert(lst.Handle == IntPtr.Zero);
2169 Test.Assert(t.check_eina_list_int_return()); 2169 Test.Assert(t.check_eina_list_int_return());
@@ -2174,8 +2174,8 @@ class TestEinaList
2174 test.Testing t = new test.TestingConcrete(); 2174 test.Testing t = new test.TestingConcrete();
2175 var lst = t.eina_list_int_return_own(); 2175 var lst = t.eina_list_int_return_own();
2176 Test.Assert(lst.Own); 2176 Test.Assert(lst.Own);
2177 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2177 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2178 lst.AppendArray(append_arr_int); 2178 lst.AppendArray(append_seq_int);
2179 lst.Dispose(); 2179 lst.Dispose();
2180 Test.Assert(lst.Handle == IntPtr.Zero); 2180 Test.Assert(lst.Handle == IntPtr.Zero);
2181 } 2181 }
@@ -2185,10 +2185,10 @@ class TestEinaList
2185 { 2185 {
2186 test.Testing t = new test.TestingConcrete(); 2186 test.Testing t = new test.TestingConcrete();
2187 var lst = new eina.List<string>(); 2187 var lst = new eina.List<string>();
2188 lst.AppendArray(base_arr_str); 2188 lst.AppendArray(base_seq_str);
2189 Test.Assert(t.eina_list_str_in(lst)); 2189 Test.Assert(t.eina_list_str_in(lst));
2190 Test.Assert(lst.Own); 2190 Test.Assert(lst.Own);
2191 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2191 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2192 lst.Dispose(); 2192 lst.Dispose();
2193 Test.Assert(lst.Handle == IntPtr.Zero); 2193 Test.Assert(lst.Handle == IntPtr.Zero);
2194 } 2194 }
@@ -2197,7 +2197,7 @@ class TestEinaList
2197 { 2197 {
2198 test.Testing t = new test.TestingConcrete(); 2198 test.Testing t = new test.TestingConcrete();
2199 var lst = new eina.List<string>(); 2199 var lst = new eina.List<string>();
2200 lst.AppendArray(base_arr_str); 2200 lst.AppendArray(base_seq_str);
2201 Test.Assert(t.eina_list_str_in_own(lst)); 2201 Test.Assert(t.eina_list_str_in_own(lst));
2202 Test.Assert(!lst.Own); 2202 Test.Assert(!lst.Own);
2203 lst.Dispose(); 2203 lst.Dispose();
@@ -2211,7 +2211,7 @@ class TestEinaList
2211 eina.List<string> lst; 2211 eina.List<string> lst;
2212 Test.Assert(t.eina_list_str_out(out lst)); 2212 Test.Assert(t.eina_list_str_out(out lst));
2213 Test.Assert(!lst.Own); 2213 Test.Assert(!lst.Own);
2214 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2214 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2215 lst.Dispose(); 2215 lst.Dispose();
2216 Test.Assert(lst.Handle == IntPtr.Zero); 2216 Test.Assert(lst.Handle == IntPtr.Zero);
2217 Test.Assert(t.check_eina_list_str_out()); 2217 Test.Assert(t.check_eina_list_str_out());
@@ -2223,8 +2223,8 @@ class TestEinaList
2223 eina.List<string> lst; 2223 eina.List<string> lst;
2224 Test.Assert(t.eina_list_str_out_own(out lst)); 2224 Test.Assert(t.eina_list_str_out_own(out lst));
2225 Test.Assert(lst.Own); 2225 Test.Assert(lst.Own);
2226 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2226 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2227 lst.AppendArray(append_arr_str); 2227 lst.AppendArray(append_seq_str);
2228 lst.Dispose(); 2228 lst.Dispose();
2229 Test.Assert(lst.Handle == IntPtr.Zero); 2229 Test.Assert(lst.Handle == IntPtr.Zero);
2230 } 2230 }
@@ -2234,7 +2234,7 @@ class TestEinaList
2234 test.Testing t = new test.TestingConcrete(); 2234 test.Testing t = new test.TestingConcrete();
2235 var lst = t.eina_list_str_return(); 2235 var lst = t.eina_list_str_return();
2236 Test.Assert(!lst.Own); 2236 Test.Assert(!lst.Own);
2237 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2237 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2238 lst.Dispose(); 2238 lst.Dispose();
2239 Test.Assert(lst.Handle == IntPtr.Zero); 2239 Test.Assert(lst.Handle == IntPtr.Zero);
2240 Test.Assert(t.check_eina_list_str_return()); 2240 Test.Assert(t.check_eina_list_str_return());
@@ -2245,8 +2245,8 @@ class TestEinaList
2245 test.Testing t = new test.TestingConcrete(); 2245 test.Testing t = new test.TestingConcrete();
2246 var lst = t.eina_list_str_return_own(); 2246 var lst = t.eina_list_str_return_own();
2247 Test.Assert(lst.Own); 2247 Test.Assert(lst.Own);
2248 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2248 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2249 lst.AppendArray(append_arr_str); 2249 lst.AppendArray(append_seq_str);
2250 lst.Dispose(); 2250 lst.Dispose();
2251 Test.Assert(lst.Handle == IntPtr.Zero); 2251 Test.Assert(lst.Handle == IntPtr.Zero);
2252 } 2252 }
@@ -2257,10 +2257,10 @@ class TestEinaList
2257 { 2257 {
2258 test.Testing t = new test.TestingConcrete(); 2258 test.Testing t = new test.TestingConcrete();
2259 var lst = new eina.List<test.Numberwrapper>(); 2259 var lst = new eina.List<test.Numberwrapper>();
2260 lst.AppendArray(BaseArrObj()); 2260 lst.AppendArray(BaseSeqObj());
2261 Test.Assert(t.eina_list_obj_in(lst)); 2261 Test.Assert(t.eina_list_obj_in(lst));
2262 Test.Assert(lst.Own); 2262 Test.Assert(lst.Own);
2263 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2263 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2264 lst.Dispose(); 2264 lst.Dispose();
2265 Test.Assert(lst.Handle == IntPtr.Zero); 2265 Test.Assert(lst.Handle == IntPtr.Zero);
2266 } 2266 }
@@ -2269,7 +2269,7 @@ class TestEinaList
2269 { 2269 {
2270 test.Testing t = new test.TestingConcrete(); 2270 test.Testing t = new test.TestingConcrete();
2271 var lst = new eina.List<test.Numberwrapper>(); 2271 var lst = new eina.List<test.Numberwrapper>();
2272 lst.AppendArray(BaseArrObj()); 2272 lst.AppendArray(BaseSeqObj());
2273 Test.Assert(t.eina_list_obj_in_own(lst)); 2273 Test.Assert(t.eina_list_obj_in_own(lst));
2274 Test.Assert(!lst.Own); 2274 Test.Assert(!lst.Own);
2275 lst.Dispose(); 2275 lst.Dispose();
@@ -2283,7 +2283,7 @@ class TestEinaList
2283 eina.List<test.Numberwrapper> lst; 2283 eina.List<test.Numberwrapper> lst;
2284 Test.Assert(t.eina_list_obj_out(out lst)); 2284 Test.Assert(t.eina_list_obj_out(out lst));
2285 Test.Assert(!lst.Own); 2285 Test.Assert(!lst.Own);
2286 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2286 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2287 lst.Dispose(); 2287 lst.Dispose();
2288 Test.Assert(lst.Handle == IntPtr.Zero); 2288 Test.Assert(lst.Handle == IntPtr.Zero);
2289 Test.Assert(t.check_eina_list_obj_out()); 2289 Test.Assert(t.check_eina_list_obj_out());
@@ -2295,8 +2295,8 @@ class TestEinaList
2295 eina.List<test.Numberwrapper> lst; 2295 eina.List<test.Numberwrapper> lst;
2296 Test.Assert(t.eina_list_obj_out_own(out lst)); 2296 Test.Assert(t.eina_list_obj_out_own(out lst));
2297 Test.Assert(lst.Own); 2297 Test.Assert(lst.Own);
2298 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2298 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2299 lst.AppendArray(AppendArrObj()); 2299 lst.AppendArray(AppendSeqObj());
2300 lst.Dispose(); 2300 lst.Dispose();
2301 Test.Assert(lst.Handle == IntPtr.Zero); 2301 Test.Assert(lst.Handle == IntPtr.Zero);
2302 } 2302 }
@@ -2306,7 +2306,7 @@ class TestEinaList
2306 test.Testing t = new test.TestingConcrete(); 2306 test.Testing t = new test.TestingConcrete();
2307 var lst = t.eina_list_obj_return(); 2307 var lst = t.eina_list_obj_return();
2308 Test.Assert(!lst.Own); 2308 Test.Assert(!lst.Own);
2309 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2309 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2310 lst.Dispose(); 2310 lst.Dispose();
2311 Test.Assert(lst.Handle == IntPtr.Zero); 2311 Test.Assert(lst.Handle == IntPtr.Zero);
2312 Test.Assert(t.check_eina_list_obj_return()); 2312 Test.Assert(t.check_eina_list_obj_return());
@@ -2317,8 +2317,8 @@ class TestEinaList
2317 test.Testing t = new test.TestingConcrete(); 2317 test.Testing t = new test.TestingConcrete();
2318 var lst = t.eina_list_obj_return_own(); 2318 var lst = t.eina_list_obj_return_own();
2319 Test.Assert(lst.Own); 2319 Test.Assert(lst.Own);
2320 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2320 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2321 lst.AppendArray(AppendArrObj()); 2321 lst.AppendArray(AppendSeqObj());
2322 lst.Dispose(); 2322 lst.Dispose();
2323 Test.Assert(lst.Handle == IntPtr.Zero); 2323 Test.Assert(lst.Handle == IntPtr.Zero);
2324 } 2324 }
@@ -2326,12 +2326,12 @@ class TestEinaList
2326 public static void test_eina_list_obj_return_in_same_id() 2326 public static void test_eina_list_obj_return_in_same_id()
2327 { 2327 {
2328 test.Testing t = new test.TestingConcrete(); 2328 test.Testing t = new test.TestingConcrete();
2329 var cmp = BaseArrObj(); 2329 var cmp = BaseSeqObj();
2330 var a = new eina.List<test.Numberwrapper>(); 2330 var a = new eina.List<test.Numberwrapper>();
2331 a.AppendArray(cmp); 2331 a.AppendArray(cmp);
2332 var b = t.eina_list_obj_return_in(a); 2332 var b = t.eina_list_obj_return_in(a);
2333 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray()); 2333 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
2334 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseArrObj()); 2334 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
2335 int len = a.Length; 2335 int len = a.Length;
2336 for (int i=0; i < len; ++i) 2336 for (int i=0; i < len; ++i)
2337 { 2337 {
@@ -2605,10 +2605,10 @@ class TestEinaInlist
2605 { 2605 {
2606 test.Testing t = new test.TestingConcrete(); 2606 test.Testing t = new test.TestingConcrete();
2607 var lst = new eina.Inlist<int>(); 2607 var lst = new eina.Inlist<int>();
2608 lst.AppendArray(base_arr_int); 2608 lst.AppendArray(base_seq_int);
2609 Test.Assert(t.eina_inlist_int_in(lst)); 2609 Test.Assert(t.eina_inlist_int_in(lst));
2610 Test.Assert(lst.Own); 2610 Test.Assert(lst.Own);
2611 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2611 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2612 lst.Dispose(); 2612 lst.Dispose();
2613 Test.Assert(lst.Handle == IntPtr.Zero); 2613 Test.Assert(lst.Handle == IntPtr.Zero);
2614 } 2614 }
@@ -2617,7 +2617,7 @@ class TestEinaInlist
2617 { 2617 {
2618 test.Testing t = new test.TestingConcrete(); 2618 test.Testing t = new test.TestingConcrete();
2619 var lst = new eina.Inlist<int>(); 2619 var lst = new eina.Inlist<int>();
2620 lst.AppendArray(base_arr_int); 2620 lst.AppendArray(base_seq_int);
2621 Test.Assert(t.eina_inlist_int_in_own(lst)); 2621 Test.Assert(t.eina_inlist_int_in_own(lst));
2622 Test.Assert(!lst.Own); 2622 Test.Assert(!lst.Own);
2623 lst.Dispose(); 2623 lst.Dispose();
@@ -2631,7 +2631,7 @@ class TestEinaInlist
2631 eina.Inlist<int> lst; 2631 eina.Inlist<int> lst;
2632 Test.Assert(t.eina_inlist_int_out(out lst)); 2632 Test.Assert(t.eina_inlist_int_out(out lst));
2633 Test.Assert(!lst.Own); 2633 Test.Assert(!lst.Own);
2634 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2634 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2635 lst.Dispose(); 2635 lst.Dispose();
2636 Test.Assert(lst.Handle == IntPtr.Zero); 2636 Test.Assert(lst.Handle == IntPtr.Zero);
2637 Test.Assert(t.check_eina_inlist_int_out()); 2637 Test.Assert(t.check_eina_inlist_int_out());
@@ -2643,8 +2643,8 @@ class TestEinaInlist
2643 eina.Inlist<int> lst; 2643 eina.Inlist<int> lst;
2644 Test.Assert(t.eina_inlist_int_out_own(out lst)); 2644 Test.Assert(t.eina_inlist_int_out_own(out lst));
2645 Test.Assert(lst.Own); 2645 Test.Assert(lst.Own);
2646 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2646 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2647 lst.AppendArray(append_arr_int); 2647 lst.AppendArray(append_seq_int);
2648 lst.Dispose(); 2648 lst.Dispose();
2649 Test.Assert(lst.Handle == IntPtr.Zero); 2649 Test.Assert(lst.Handle == IntPtr.Zero);
2650 } 2650 }
@@ -2654,7 +2654,7 @@ class TestEinaInlist
2654 test.Testing t = new test.TestingConcrete(); 2654 test.Testing t = new test.TestingConcrete();
2655 var lst = t.eina_inlist_int_return(); 2655 var lst = t.eina_inlist_int_return();
2656 Test.Assert(!lst.Own); 2656 Test.Assert(!lst.Own);
2657 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2657 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2658 lst.Dispose(); 2658 lst.Dispose();
2659 Test.Assert(lst.Handle == IntPtr.Zero); 2659 Test.Assert(lst.Handle == IntPtr.Zero);
2660 Test.Assert(t.check_eina_inlist_int_return()); 2660 Test.Assert(t.check_eina_inlist_int_return());
@@ -2665,8 +2665,8 @@ class TestEinaInlist
2665 test.Testing t = new test.TestingConcrete(); 2665 test.Testing t = new test.TestingConcrete();
2666 var lst = t.eina_inlist_int_return_own(); 2666 var lst = t.eina_inlist_int_return_own();
2667 Test.Assert(lst.Own); 2667 Test.Assert(lst.Own);
2668 Test.Assert(lst.ToArray().SequenceEqual(base_arr_int)); 2668 Test.Assert(lst.ToArray().SequenceEqual(base_seq_int));
2669 lst.AppendArray(append_arr_int); 2669 lst.AppendArray(append_seq_int);
2670 lst.Dispose(); 2670 lst.Dispose();
2671 Test.Assert(lst.Handle == IntPtr.Zero); 2671 Test.Assert(lst.Handle == IntPtr.Zero);
2672 } 2672 }
@@ -2676,10 +2676,10 @@ class TestEinaInlist
2676 { 2676 {
2677 test.Testing t = new test.TestingConcrete(); 2677 test.Testing t = new test.TestingConcrete();
2678 var lst = new eina.Inlist<string>(); 2678 var lst = new eina.Inlist<string>();
2679 lst.AppendArray(base_arr_str); 2679 lst.AppendArray(base_seq_str);
2680 Test.Assert(t.eina_inlist_str_in(lst)); 2680 Test.Assert(t.eina_inlist_str_in(lst));
2681 Test.Assert(lst.Own); 2681 Test.Assert(lst.Own);
2682 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2682 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2683 lst.Dispose(); 2683 lst.Dispose();
2684 Test.Assert(lst.Handle == IntPtr.Zero); 2684 Test.Assert(lst.Handle == IntPtr.Zero);
2685 } 2685 }
@@ -2688,7 +2688,7 @@ class TestEinaInlist
2688 { 2688 {
2689 test.Testing t = new test.TestingConcrete(); 2689 test.Testing t = new test.TestingConcrete();
2690 var lst = new eina.Inlist<string>(); 2690 var lst = new eina.Inlist<string>();
2691 lst.AppendArray(base_arr_str); 2691 lst.AppendArray(base_seq_str);
2692 Test.Assert(t.eina_inlist_str_in_own(lst)); 2692 Test.Assert(t.eina_inlist_str_in_own(lst));
2693 Test.Assert(!lst.Own); 2693 Test.Assert(!lst.Own);
2694 lst.Dispose(); 2694 lst.Dispose();
@@ -2702,7 +2702,7 @@ class TestEinaInlist
2702 eina.Inlist<string> lst; 2702 eina.Inlist<string> lst;
2703 Test.Assert(t.eina_inlist_str_out(out lst)); 2703 Test.Assert(t.eina_inlist_str_out(out lst));
2704 Test.Assert(!lst.Own); 2704 Test.Assert(!lst.Own);
2705 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2705 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2706 lst.Dispose(); 2706 lst.Dispose();
2707 Test.Assert(lst.Handle == IntPtr.Zero); 2707 Test.Assert(lst.Handle == IntPtr.Zero);
2708 Test.Assert(t.check_eina_inlist_str_out()); 2708 Test.Assert(t.check_eina_inlist_str_out());
@@ -2714,8 +2714,8 @@ class TestEinaInlist
2714 eina.Inlist<string> lst; 2714 eina.Inlist<string> lst;
2715 Test.Assert(t.eina_inlist_str_out_own(out lst)); 2715 Test.Assert(t.eina_inlist_str_out_own(out lst));
2716 Test.Assert(lst.Own); 2716 Test.Assert(lst.Own);
2717 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2717 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2718 lst.AppendArray(append_arr_str); 2718 lst.AppendArray(append_seq_str);
2719 lst.Dispose(); 2719 lst.Dispose();
2720 Test.Assert(lst.Handle == IntPtr.Zero); 2720 Test.Assert(lst.Handle == IntPtr.Zero);
2721 } 2721 }
@@ -2725,7 +2725,7 @@ class TestEinaInlist
2725 test.Testing t = new test.TestingConcrete(); 2725 test.Testing t = new test.TestingConcrete();
2726 var lst = t.eina_inlist_str_return(); 2726 var lst = t.eina_inlist_str_return();
2727 Test.Assert(!lst.Own); 2727 Test.Assert(!lst.Own);
2728 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2728 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2729 lst.Dispose(); 2729 lst.Dispose();
2730 Test.Assert(lst.Handle == IntPtr.Zero); 2730 Test.Assert(lst.Handle == IntPtr.Zero);
2731 Test.Assert(t.check_eina_inlist_str_return()); 2731 Test.Assert(t.check_eina_inlist_str_return());
@@ -2736,8 +2736,8 @@ class TestEinaInlist
2736 test.Testing t = new test.TestingConcrete(); 2736 test.Testing t = new test.TestingConcrete();
2737 var lst = t.eina_inlist_str_return_own(); 2737 var lst = t.eina_inlist_str_return_own();
2738 Test.Assert(lst.Own); 2738 Test.Assert(lst.Own);
2739 Test.Assert(lst.ToArray().SequenceEqual(base_arr_str)); 2739 Test.Assert(lst.ToArray().SequenceEqual(base_seq_str));
2740 lst.AppendArray(append_arr_str); 2740 lst.AppendArray(append_seq_str);
2741 lst.Dispose(); 2741 lst.Dispose();
2742 Test.Assert(lst.Handle == IntPtr.Zero); 2742 Test.Assert(lst.Handle == IntPtr.Zero);
2743 } 2743 }
@@ -2748,10 +2748,10 @@ class TestEinaInlist
2748 { 2748 {
2749 test.Testing t = new test.TestingConcrete(); 2749 test.Testing t = new test.TestingConcrete();
2750 var lst = new eina.Inlist<test.Numberwrapper>(); 2750 var lst = new eina.Inlist<test.Numberwrapper>();
2751 lst.AppendArray(BaseArrObj()); 2751 lst.AppendArray(BaseSeqObj());
2752 Test.Assert(t.eina_inlist_obj_in(lst)); 2752 Test.Assert(t.eina_inlist_obj_in(lst));
2753 Test.Assert(lst.Own); 2753 Test.Assert(lst.Own);
2754 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2754 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2755 lst.Dispose(); 2755 lst.Dispose();
2756 Test.Assert(lst.Handle == IntPtr.Zero); 2756 Test.Assert(lst.Handle == IntPtr.Zero);
2757 } 2757 }
@@ -2760,7 +2760,7 @@ class TestEinaInlist
2760 { 2760 {
2761 test.Testing t = new test.TestingConcrete(); 2761 test.Testing t = new test.TestingConcrete();
2762 var lst = new eina.Inlist<test.Numberwrapper>(); 2762 var lst = new eina.Inlist<test.Numberwrapper>();
2763 lst.AppendArray(BaseArrObj()); 2763 lst.AppendArray(BaseSeqObj());
2764 Test.Assert(t.eina_inlist_obj_in_own(lst)); 2764 Test.Assert(t.eina_inlist_obj_in_own(lst));
2765 Test.Assert(!lst.Own); 2765 Test.Assert(!lst.Own);
2766 lst.Dispose(); 2766 lst.Dispose();
@@ -2774,7 +2774,7 @@ class TestEinaInlist
2774 eina.Inlist<test.Numberwrapper> lst; 2774 eina.Inlist<test.Numberwrapper> lst;
2775 Test.Assert(t.eina_inlist_obj_out(out lst)); 2775 Test.Assert(t.eina_inlist_obj_out(out lst));
2776 Test.Assert(!lst.Own); 2776 Test.Assert(!lst.Own);
2777 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2777 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2778 lst.Dispose(); 2778 lst.Dispose();
2779 Test.Assert(lst.Handle == IntPtr.Zero); 2779 Test.Assert(lst.Handle == IntPtr.Zero);
2780 Test.Assert(t.check_eina_inlist_obj_out()); 2780 Test.Assert(t.check_eina_inlist_obj_out());
@@ -2786,8 +2786,8 @@ class TestEinaInlist
2786 eina.Inlist<test.Numberwrapper> lst; 2786 eina.Inlist<test.Numberwrapper> lst;
2787 Test.Assert(t.eina_inlist_obj_out_own(out lst)); 2787 Test.Assert(t.eina_inlist_obj_out_own(out lst));
2788 Test.Assert(lst.Own); 2788 Test.Assert(lst.Own);
2789 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2789 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2790 lst.AppendArray(AppendArrObj()); 2790 lst.AppendArray(AppendSeqObj());
2791 lst.Dispose(); 2791 lst.Dispose();
2792 Test.Assert(lst.Handle == IntPtr.Zero); 2792 Test.Assert(lst.Handle == IntPtr.Zero);
2793 } 2793 }
@@ -2797,7 +2797,7 @@ class TestEinaInlist
2797 test.Testing t = new test.TestingConcrete(); 2797 test.Testing t = new test.TestingConcrete();
2798 var lst = t.eina_inlist_obj_return(); 2798 var lst = t.eina_inlist_obj_return();
2799 Test.Assert(!lst.Own); 2799 Test.Assert(!lst.Own);
2800 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2800 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2801 lst.Dispose(); 2801 lst.Dispose();
2802 Test.Assert(lst.Handle == IntPtr.Zero); 2802 Test.Assert(lst.Handle == IntPtr.Zero);
2803 Test.Assert(t.check_eina_inlist_obj_return()); 2803 Test.Assert(t.check_eina_inlist_obj_return());
@@ -2808,8 +2808,8 @@ class TestEinaInlist
2808 test.Testing t = new test.TestingConcrete(); 2808 test.Testing t = new test.TestingConcrete();
2809 var lst = t.eina_inlist_obj_return_own(); 2809 var lst = t.eina_inlist_obj_return_own();
2810 Test.Assert(lst.Own); 2810 Test.Assert(lst.Own);
2811 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseArrObj()); 2811 NumberwrapperSequenceAssertEqual(lst.ToArray(), BaseSeqObj());
2812 lst.AppendArray(AppendArrObj()); 2812 lst.AppendArray(AppendSeqObj());
2813 lst.Dispose(); 2813 lst.Dispose();
2814 Test.Assert(lst.Handle == IntPtr.Zero); 2814 Test.Assert(lst.Handle == IntPtr.Zero);
2815 } 2815 }
@@ -2817,12 +2817,12 @@ class TestEinaInlist
2817 public static void test_eina_inlist_obj_return_in_same_id() 2817 public static void test_eina_inlist_obj_return_in_same_id()
2818 { 2818 {
2819 test.Testing t = new test.TestingConcrete(); 2819 test.Testing t = new test.TestingConcrete();
2820 var cmp = BaseArrObj(); 2820 var cmp = BaseSeqObj();
2821 var a = new eina.Inlist<test.Numberwrapper>(); 2821 var a = new eina.Inlist<test.Numberwrapper>();
2822 a.AppendArray(cmp); 2822 a.AppendArray(cmp);
2823 var b = t.eina_inlist_obj_return_in(a); 2823 var b = t.eina_inlist_obj_return_in(a);
2824 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray()); 2824 NumberwrapperSequenceAssertEqual(a.ToArray(), b.ToArray());
2825 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseArrObj()); 2825 NumberwrapperSequenceAssertEqual(a.ToArray(), BaseSeqObj());
2826 int len = a.Length; 2826 int len = a.Length;
2827 for (int i=0; i < len; ++i) 2827 for (int i=0; i < len; ++i)
2828 { 2828 {
@@ -3138,4 +3138,177 @@ class TestEinaHash
3138 } 3138 }
3139} 3139}
3140 3140
3141
3142class TestEinaIterator
3143{
3144 public static void eina_array_int_empty_iterator()
3145 {
3146 var arr = new eina.Array<int>();
3147 var itr = arr.GetIterator();
3148 bool entered = false;
3149 foreach (int e in itr)
3150 {
3151 entered = true;
3152 }
3153 Test.Assert(!entered);
3154 }
3155
3156 public static void eina_array_int_filled_iterator()
3157 {
3158 var arr = new eina.Array<int>();
3159 arr.Append(base_seq_int);
3160 var itr = arr.GetIterator();
3161 bool entered = false;
3162 var i = 0;
3163 foreach (int e in itr)
3164 {
3165 entered = true;
3166 Test.Assert(e == base_seq_int[i]);
3167 ++i;
3168 }
3169 Test.Assert(entered);
3170 }
3171
3172 public static void eina_array_str_empty_iterator()
3173 {
3174 var arr = new eina.Array<string>();
3175 var itr = arr.GetIterator();
3176 bool entered = false;
3177 foreach (string e in itr)
3178 {
3179 entered = true;
3180 }
3181 Test.Assert(!entered);
3182 }
3183
3184 public static void eina_array_str_filled_iterator()
3185 {
3186 var arr = new eina.Array<string>();
3187 arr.Append(base_seq_str);
3188 var itr = arr.GetIterator();
3189 bool entered = false;
3190 var i = 0;
3191 foreach (string e in itr)
3192 {
3193 entered = true;
3194 Test.Assert(e == base_seq_str[i]);
3195 ++i;
3196 }
3197 Test.Assert(entered);
3198 }
3199
3200 public static void eina_array_obj_empty_iterator()
3201 {
3202 var arr = new eina.Array<test.Numberwrapper>();
3203 var itr = arr.GetIterator();
3204 bool entered = false;
3205 foreach (test.Numberwrapper e in itr)
3206 {
3207 entered = true;
3208 }
3209 Test.Assert(!entered);
3210 }
3211
3212 public static void eina_array_obj_filled_iterator()
3213 {
3214 var arr = new eina.Array<test.Numberwrapper>();
3215 var base_objs = BaseSeqObj();
3216 arr.Append(base_objs);
3217 var itr = arr.GetIterator();
3218 bool entered = false;
3219 var i = 0;
3220 foreach (test.Numberwrapper e in itr)
3221 {
3222 entered = true;
3223 Test.Assert(e.raw_handle == base_objs[i].raw_handle);
3224 Test.Assert(e.number_get() == base_objs[i].number_get());
3225 ++i;
3226 }
3227 Test.Assert(entered);
3228 }
3229
3230
3231// // //
3232// // Code Generation
3233// //
3234//
3235// // Integer //
3236//
3237// public static void test_eina_iterator_int_in()
3238// {
3239// }
3240//
3241// public static void test_eina_iterator_int_in_own()
3242// {
3243// }
3244//
3245// public static void test_eina_iterator_int_out()
3246// {
3247// }
3248//
3249// public static void test_eina_iterator_int_out_own()
3250// {
3251// }
3252//
3253// public static void test_eina_iterator_int_return()
3254// {
3255// }
3256//
3257// public static void test_eina_iterator_int_return_own()
3258// {
3259// }
3260//
3261// // String //
3262//
3263// public static void test_eina_iterator_str_in()
3264// {
3265// }
3266//
3267// public static void test_eina_iterator_str_in_own()
3268// {
3269// }
3270//
3271// public static void test_eina_iterator_str_out()
3272// {
3273// }
3274//
3275// public static void test_eina_iterator_str_out_own()
3276// {
3277// }
3278//
3279// public static void test_eina_iterator_str_return()
3280// {
3281// }
3282//
3283// public static void test_eina_iterator_str_return_own()
3284// {
3285// }
3286//
3287// // Object //
3288//
3289// public static void test_eina_iterator_obj_in()
3290// {
3291// }
3292//
3293// public static void test_eina_iterator_obj_in_own()
3294// {
3295// }
3296//
3297// public static void test_eina_iterator_obj_out()
3298// {
3299// }
3300//
3301// public static void test_eina_iterator_obj_out_own()
3302// {
3303// }
3304//
3305// public static void test_eina_iterator_obj_return()
3306// {
3307// }
3308//
3309// public static void test_eina_iterator_obj_return_own()
3310// {
3311// }
3312} // < TestEinaIterator
3313
3141} 3314}
diff --git a/src/tests/efl_mono/libefl_mono_native_test.c b/src/tests/efl_mono/libefl_mono_native_test.c
index 16f5304423..0fed3b43e6 100644
--- a/src/tests/efl_mono/libefl_mono_native_test.c
+++ b/src/tests/efl_mono/libefl_mono_native_test.c
@@ -238,8 +238,8 @@ Eina_Stringshare *_test_testing_call_out_own_stringshare(Eo *obj, EINA_UNUSED Te
238} 238}
239 239
240 240
241static const uint8_t base_arr[] = {0x0,0x2A,0x42}; 241static const uint8_t base_seq[] = {0x0,0x2A,0x42};
242// static const size_t base_arr_size = 3; // TODO: Use it!!! 242// static const size_t base_seq_size = 3; // TODO: Use it!!!
243 243
244static void *memdup(const void* mem, size_t size) 244static void *memdup(const void* mem, size_t size)
245{ 245{
@@ -252,12 +252,12 @@ Eina_Bool _test_testing_eina_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Test
252{ 252{
253 uint8_t *buf = memdup(slice.mem, slice.len); 253 uint8_t *buf = memdup(slice.mem, slice.len);
254 free(buf); 254 free(buf);
255 return 0 == memcmp(slice.mem, base_arr, slice.len); 255 return 0 == memcmp(slice.mem, base_seq, slice.len);
256} 256}
257 257
258Eina_Bool _test_testing_eina_rw_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Rw_Slice slice) 258Eina_Bool _test_testing_eina_rw_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Rw_Slice slice)
259{ 259{
260 Eina_Bool r = (0 == memcmp(slice.mem, base_arr, slice.len)); 260 Eina_Bool r = (0 == memcmp(slice.mem, base_seq, slice.len));
261 unsigned char *buf = memdup(slice.mem, slice.len); 261 unsigned char *buf = memdup(slice.mem, slice.len);
262 free(buf); 262 free(buf);
263 for (unsigned i = 0; i < slice.len; ++i) 263 for (unsigned i = 0; i < slice.len; ++i)
@@ -268,7 +268,7 @@ Eina_Bool _test_testing_eina_rw_slice_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_T
268Eina_Bool _test_testing_eina_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Slice *slice) 268Eina_Bool _test_testing_eina_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Slice *slice)
269{ 269{
270 if (!slice) return EINA_FALSE; 270 if (!slice) return EINA_FALSE;
271 static const Eina_Slice slc = EINA_SLICE_ARRAY(base_arr); 271 static const Eina_Slice slc = EINA_SLICE_ARRAY(base_seq);
272 slice->len = slc.len; 272 slice->len = slc.len;
273 slice->mem = slc.mem; 273 slice->mem = slc.mem;
274 return EINA_TRUE; 274 return EINA_TRUE;
@@ -278,25 +278,25 @@ Eina_Bool _test_testing_eina_rw_slice_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_
278{ 278{
279 if (!slice) return EINA_FALSE; 279 if (!slice) return EINA_FALSE;
280 slice->len = 3; 280 slice->len = 3;
281 slice->mem = memdup(base_arr, 3); 281 slice->mem = memdup(base_seq, 3);
282 return EINA_TRUE; 282 return EINA_TRUE;
283} 283}
284 284
285Eina_Slice _test_testing_eina_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd) 285Eina_Slice _test_testing_eina_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
286{ 286{
287 Eina_Slice slc = EINA_SLICE_ARRAY(base_arr); 287 Eina_Slice slc = EINA_SLICE_ARRAY(base_seq);
288 return slc; 288 return slc;
289} 289}
290 290
291Eina_Rw_Slice _test_testing_eina_rw_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd) 291Eina_Rw_Slice _test_testing_eina_rw_slice_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
292{ 292{
293 Eina_Rw_Slice slc = { .len = 3, .mem = memdup(base_arr, 3) }; 293 Eina_Rw_Slice slc = { .len = 3, .mem = memdup(base_seq, 3) };
294 return slc; 294 return slc;
295} 295}
296 296
297Eina_Bool _test_testing_eina_binbuf_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf) 297Eina_Bool _test_testing_eina_binbuf_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
298{ 298{
299 Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_arr, eina_binbuf_length_get(binbuf))); 299 Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_seq, eina_binbuf_length_get(binbuf)));
300 eina_binbuf_insert_char(binbuf, 42, 0); 300 eina_binbuf_insert_char(binbuf, 42, 0);
301 eina_binbuf_insert_char(binbuf, 43, 0); 301 eina_binbuf_insert_char(binbuf, 43, 0);
302 eina_binbuf_append_char(binbuf, 33); 302 eina_binbuf_append_char(binbuf, 33);
@@ -307,7 +307,7 @@ Eina_Binbuf *_binbuf_in_own_to_check = NULL;
307 307
308Eina_Bool _test_testing_eina_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf) 308Eina_Bool _test_testing_eina_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf *binbuf)
309{ 309{
310 Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_arr, eina_binbuf_length_get(binbuf))); 310 Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(binbuf), base_seq, eina_binbuf_length_get(binbuf)));
311 eina_binbuf_insert_char(binbuf, 42, 0); 311 eina_binbuf_insert_char(binbuf, 42, 0);
312 eina_binbuf_insert_char(binbuf, 43, 0); 312 eina_binbuf_insert_char(binbuf, 43, 0);
313 eina_binbuf_append_char(binbuf, 33); 313 eina_binbuf_append_char(binbuf, 33);
@@ -318,8 +318,8 @@ Eina_Bool _test_testing_eina_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test
318Eina_Bool _test_testing_check_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd) 318Eina_Bool _test_testing_check_binbuf_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
319{ 319{
320 if (!_binbuf_in_own_to_check) return EINA_FALSE; 320 if (!_binbuf_in_own_to_check) return EINA_FALSE;
321 const uint8_t mod_arr[] = {43,42,0x0,0x2A,0x42,33}; 321 const uint8_t mod_seq[] = {43,42,0x0,0x2A,0x42,33};
322 Eina_Bool r = (0 == memcmp(eina_binbuf_string_get(_binbuf_in_own_to_check), mod_arr, eina_binbuf_length_get(_binbuf_in_own_to_check))); 322 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)));
323 eina_binbuf_string_free(_binbuf_in_own_to_check); 323 eina_binbuf_string_free(_binbuf_in_own_to_check);
324 return r; 324 return r;
325} 325}
@@ -338,7 +338,7 @@ Eina_Bool _test_testing_eina_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Te
338Eina_Bool _test_testing_check_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd) 338Eina_Bool _test_testing_check_binbuf_out(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
339{ 339{
340 if (!_binbuf_out_to_check) return EINA_FALSE; 340 if (!_binbuf_out_to_check) return EINA_FALSE;
341 return 0 == memcmp(eina_binbuf_string_get(_binbuf_out_to_check), base_arr, eina_binbuf_length_get(_binbuf_out_to_check)); 341 return 0 == memcmp(eina_binbuf_string_get(_binbuf_out_to_check), base_seq, eina_binbuf_length_get(_binbuf_out_to_check));
342} 342}
343 343
344Eina_Bool _test_testing_eina_binbuf_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf **binbuf) 344Eina_Bool _test_testing_eina_binbuf_out_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Binbuf **binbuf)
@@ -362,7 +362,7 @@ Eina_Binbuf *_test_testing_eina_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED T
362Eina_Bool _test_testing_check_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd) 362Eina_Bool _test_testing_check_binbuf_return(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
363{ 363{
364 if (!_binbuf_return_to_check) return EINA_FALSE; 364 if (!_binbuf_return_to_check) return EINA_FALSE;
365 return 0 == memcmp(eina_binbuf_string_get(_binbuf_return_to_check), base_arr, eina_binbuf_length_get(_binbuf_return_to_check)); 365 return 0 == memcmp(eina_binbuf_string_get(_binbuf_return_to_check), base_seq, eina_binbuf_length_get(_binbuf_return_to_check));
366} 366}
367 367
368Eina_Binbuf *_test_testing_eina_binbuf_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd) 368Eina_Binbuf *_test_testing_eina_binbuf_return_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd)
@@ -372,20 +372,20 @@ Eina_Binbuf *_test_testing_eina_binbuf_return_own(EINA_UNUSED Eo *obj, EINA_UNUS
372 return binbuf; 372 return binbuf;
373} 373}
374 374
375static const int base_arr_int[] = {0x0,0x2A,0x42}; 375static const int base_seq_int[] = {0x0,0x2A,0x42};
376static const unsigned int base_arr_int_size = EINA_C_ARRAY_LENGTH(base_arr_int); 376static const unsigned int base_seq_int_size = EINA_C_ARRAY_LENGTH(base_seq_int);
377static const int modified_arr_int[] = {0x0,0x2A,0x42,42,43,33}; 377static const int modified_seq_int[] = {0x0,0x2A,0x42,42,43,33};
378static const unsigned int modified_arr_int_size = EINA_C_ARRAY_LENGTH(modified_arr_int); 378static const unsigned int modified_seq_int_size = EINA_C_ARRAY_LENGTH(modified_seq_int);
379 379
380static const char * const base_arr_str[] = {"0x0","0x2A","0x42"}; 380static const char * const base_seq_str[] = {"0x0","0x2A","0x42"};
381static const unsigned int base_arr_str_size = EINA_C_ARRAY_LENGTH(base_arr_str); 381static const unsigned int base_seq_str_size = EINA_C_ARRAY_LENGTH(base_seq_str);
382static const char * const modified_arr_str[] = {"0x0","0x2A","0x42","42","43","33"}; 382static const char * const modified_seq_str[] = {"0x0","0x2A","0x42","42","43","33"};
383static const unsigned int modified_arr_str_size = EINA_C_ARRAY_LENGTH(modified_arr_str); 383static const unsigned int modified_seq_str_size = EINA_C_ARRAY_LENGTH(modified_seq_str);
384 384
385static const Test_Numberwrapper *base_arr_obj[] = {NULL,NULL,NULL}; 385static const Test_Numberwrapper *base_seq_obj[] = {NULL,NULL,NULL};
386static const unsigned int base_arr_obj_size = EINA_C_ARRAY_LENGTH(base_arr_str); 386static const unsigned int base_seq_obj_size = EINA_C_ARRAY_LENGTH(base_seq_str);
387static const Test_Numberwrapper *modified_arr_obj[] = {NULL,NULL,NULL,NULL,NULL,NULL}; 387static const Test_Numberwrapper *modified_seq_obj[] = {NULL,NULL,NULL,NULL,NULL,NULL};
388static const unsigned int modified_arr_obj_size = EINA_C_ARRAY_LENGTH(modified_arr_str); 388static const unsigned int modified_seq_obj_size = EINA_C_ARRAY_LENGTH(modified_seq_str);
389 389
390// // 390// //
391// Array 391// Array
@@ -409,7 +409,7 @@ Eina_Bool _array_int_equal(const Eina_Array *arr, const int base[], unsigned int
409 409
410Eina_Bool _test_testing_eina_array_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr) 410Eina_Bool _test_testing_eina_array_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
411{ 411{
412 Eina_Bool r = _array_int_equal(arr, base_arr_int, base_arr_int_size); 412 Eina_Bool r = _array_int_equal(arr, base_seq_int, base_seq_int_size);
413 eina_array_push(arr, _new_int(42)); 413 eina_array_push(arr, _new_int(42));
414 eina_array_push(arr, _new_int(43)); 414 eina_array_push(arr, _new_int(43));
415 eina_array_push(arr, _new_int(33)); 415 eina_array_push(arr, _new_int(33));
@@ -420,7 +420,7 @@ static Eina_Array *_array_int_in_own_to_check = NULL;
420 420
421Eina_Bool _test_testing_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr) 421Eina_Bool _test_testing_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
422{ 422{
423 Eina_Bool r = _array_int_equal(arr, base_arr_int, base_arr_int_size); 423 Eina_Bool r = _array_int_equal(arr, base_seq_int, base_seq_int_size);
424 eina_array_push(arr, _new_int(42)); 424 eina_array_push(arr, _new_int(42));
425 eina_array_push(arr, _new_int(43)); 425 eina_array_push(arr, _new_int(43));
426 eina_array_push(arr, _new_int(33)); 426 eina_array_push(arr, _new_int(33));
@@ -432,7 +432,7 @@ Eina_Bool _test_testing_check_eina_array_int_in_own(EINA_UNUSED Eo *obj, EINA_UN
432{ 432{
433 if (!_array_int_in_own_to_check) return EINA_FALSE; 433 if (!_array_int_in_own_to_check) return EINA_FALSE;
434 434
435 Eina_Bool r = _array_int_equal(_array_int_in_own_to_check, modified_arr_int, modified_arr_int_size); 435 Eina_Bool r = _array_int_equal(_array_int_in_own_to_check, modified_seq_int, modified_seq_int_size);
436 436
437 unsigned int i; 437 unsigned int i;
438 int *ele; 438 int *ele;
@@ -461,7 +461,7 @@ Eina_Bool _test_testing_check_eina_array_int_out(EINA_UNUSED Eo *obj, EINA_UNUSE
461{ 461{
462 if (!_array_int_out_to_check) return EINA_FALSE; 462 if (!_array_int_out_to_check) return EINA_FALSE;
463 463
464 Eina_Bool r = _array_int_equal(_array_int_out_to_check, modified_arr_int, modified_arr_int_size); 464 Eina_Bool r = _array_int_equal(_array_int_out_to_check, modified_seq_int, modified_seq_int_size);
465 465
466 unsigned int i; 466 unsigned int i;
467 int *ele; 467 int *ele;
@@ -499,7 +499,7 @@ Eina_Bool _test_testing_check_eina_array_int_return(EINA_UNUSED Eo *obj, EINA_UN
499{ 499{
500 if (!_array_int_return_to_check) return EINA_FALSE; 500 if (!_array_int_return_to_check) return EINA_FALSE;
501 501
502 Eina_Bool r = _array_int_equal(_array_int_return_to_check, modified_arr_int, modified_arr_int_size); 502 Eina_Bool r = _array_int_equal(_array_int_return_to_check, modified_seq_int, modified_seq_int_size);
503 503
504 unsigned int i; 504 unsigned int i;
505 int *ele; 505 int *ele;
@@ -537,7 +537,7 @@ Eina_Bool _array_str_equal(const Eina_Array *arr, const char * const base[], uns
537 537
538Eina_Bool _test_testing_eina_array_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr) 538Eina_Bool _test_testing_eina_array_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
539{ 539{
540 Eina_Bool r = _array_str_equal(arr, base_arr_str, base_arr_str_size); 540 Eina_Bool r = _array_str_equal(arr, base_seq_str, base_seq_str_size);
541 eina_array_push(arr, strdup("42")); 541 eina_array_push(arr, strdup("42"));
542 eina_array_push(arr, strdup("43")); 542 eina_array_push(arr, strdup("43"));
543 eina_array_push(arr, strdup("33")); 543 eina_array_push(arr, strdup("33"));
@@ -548,7 +548,7 @@ static Eina_Array *_array_str_in_own_to_check = NULL;
548 548
549Eina_Bool _test_testing_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr) 549Eina_Bool _test_testing_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
550{ 550{
551 Eina_Bool r = _array_str_equal(arr, base_arr_str, base_arr_str_size); 551 Eina_Bool r = _array_str_equal(arr, base_seq_str, base_seq_str_size);
552 eina_array_push(arr, strdup("42")); 552 eina_array_push(arr, strdup("42"));
553 eina_array_push(arr, strdup("43")); 553 eina_array_push(arr, strdup("43"));
554 eina_array_push(arr, strdup("33")); 554 eina_array_push(arr, strdup("33"));
@@ -560,7 +560,7 @@ Eina_Bool _test_testing_check_eina_array_str_in_own(EINA_UNUSED Eo *obj, EINA_UN
560{ 560{
561 if (!_array_str_in_own_to_check) return EINA_FALSE; 561 if (!_array_str_in_own_to_check) return EINA_FALSE;
562 562
563 Eina_Bool r = _array_str_equal(_array_str_in_own_to_check, modified_arr_str, modified_arr_str_size); 563 Eina_Bool r = _array_str_equal(_array_str_in_own_to_check, modified_seq_str, modified_seq_str_size);
564 564
565 unsigned int i; 565 unsigned int i;
566 char *ele; 566 char *ele;
@@ -589,7 +589,7 @@ Eina_Bool _test_testing_check_eina_array_str_out(EINA_UNUSED Eo *obj, EINA_UNUSE
589{ 589{
590 if (!_array_str_out_to_check) return EINA_FALSE; 590 if (!_array_str_out_to_check) return EINA_FALSE;
591 591
592 Eina_Bool r = _array_str_equal(_array_str_out_to_check, modified_arr_str, modified_arr_str_size); 592 Eina_Bool r = _array_str_equal(_array_str_out_to_check, modified_seq_str, modified_seq_str_size);
593 593
594 unsigned int i; 594 unsigned int i;
595 char *ele; 595 char *ele;
@@ -627,7 +627,7 @@ Eina_Bool _test_testing_check_eina_array_str_return(EINA_UNUSED Eo *obj, EINA_UN
627{ 627{
628 if (!_array_str_return_to_check) return EINA_FALSE; 628 if (!_array_str_return_to_check) return EINA_FALSE;
629 629
630 Eina_Bool r = _array_str_equal(_array_str_return_to_check, modified_arr_str, modified_arr_str_size); 630 Eina_Bool r = _array_str_equal(_array_str_return_to_check, modified_seq_str, modified_seq_str_size);
631 631
632 unsigned int i; 632 unsigned int i;
633 char *ele; 633 char *ele;
@@ -668,7 +668,7 @@ Eina_Bool _array_obj_equal(const Eina_Array *arr, const Test_Numberwrapper * con
668 668
669Eina_Bool _test_testing_eina_array_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr) 669Eina_Bool _test_testing_eina_array_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
670{ 670{
671 Eina_Bool r = _array_obj_equal(arr, base_arr_obj, base_arr_obj_size); 671 Eina_Bool r = _array_obj_equal(arr, base_seq_obj, base_seq_obj_size);
672 if (!r) return r; 672 if (!r) return r;
673 eina_array_push(arr, _new_obj(42)); 673 eina_array_push(arr, _new_obj(42));
674 eina_array_push(arr, _new_obj(43)); 674 eina_array_push(arr, _new_obj(43));
@@ -680,7 +680,7 @@ static Eina_Array *_array_obj_in_own_to_check = NULL;
680 680
681Eina_Bool _test_testing_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr) 681Eina_Bool _test_testing_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Array *arr)
682{ 682{
683 Eina_Bool r = _array_obj_equal(arr, base_arr_obj, base_arr_obj_size); 683 Eina_Bool r = _array_obj_equal(arr, base_seq_obj, base_seq_obj_size);
684 if (!r) return r; 684 if (!r) return r;
685 eina_array_push(arr, _new_obj(42)); 685 eina_array_push(arr, _new_obj(42));
686 eina_array_push(arr, _new_obj(43)); 686 eina_array_push(arr, _new_obj(43));
@@ -693,7 +693,7 @@ Eina_Bool _test_testing_check_eina_array_obj_in_own(EINA_UNUSED Eo *obj, EINA_UN
693{ 693{
694 if (!_array_obj_in_own_to_check) return EINA_FALSE; 694 if (!_array_obj_in_own_to_check) return EINA_FALSE;
695 695
696 Eina_Bool r = _array_obj_equal(_array_obj_in_own_to_check, modified_arr_obj, modified_arr_obj_size); 696 Eina_Bool r = _array_obj_equal(_array_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
697 if (!r) return r; 697 if (!r) return r;
698 698
699 unsigned int i; 699 unsigned int i;
@@ -723,7 +723,7 @@ Eina_Bool _test_testing_check_eina_array_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSE
723{ 723{
724 if (!_array_obj_out_to_check) return EINA_FALSE; 724 if (!_array_obj_out_to_check) return EINA_FALSE;
725 725
726 Eina_Bool r = _array_obj_equal(_array_obj_out_to_check, modified_arr_obj, modified_arr_obj_size); 726 Eina_Bool r = _array_obj_equal(_array_obj_out_to_check, modified_seq_obj, modified_seq_obj_size);
727 if (!r) return r; 727 if (!r) return r;
728 728
729 unsigned int i; 729 unsigned int i;
@@ -762,7 +762,7 @@ Eina_Bool _test_testing_check_eina_array_obj_return(EINA_UNUSED Eo *obj, EINA_UN
762{ 762{
763 if (!_array_obj_return_to_check) return EINA_FALSE; 763 if (!_array_obj_return_to_check) return EINA_FALSE;
764 764
765 Eina_Bool r = _array_obj_equal(_array_obj_return_to_check, modified_arr_obj, modified_arr_obj_size); 765 Eina_Bool r = _array_obj_equal(_array_obj_return_to_check, modified_seq_obj, modified_seq_obj_size);
766 if (!r) return r; 766 if (!r) return r;
767 767
768 unsigned int i; 768 unsigned int i;
@@ -810,7 +810,7 @@ Eina_Bool _inarray_int_equal(const Eina_Inarray *arr, const int base[], unsigned
810 810
811Eina_Bool _test_testing_eina_inarray_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr) 811Eina_Bool _test_testing_eina_inarray_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
812{ 812{
813 Eina_Bool r = _inarray_int_equal(arr, base_arr_int, base_arr_int_size); 813 Eina_Bool r = _inarray_int_equal(arr, base_seq_int, base_seq_int_size);
814 eina_inarray_push(arr, _int_ref(42)); 814 eina_inarray_push(arr, _int_ref(42));
815 eina_inarray_push(arr, _int_ref(43)); 815 eina_inarray_push(arr, _int_ref(43));
816 eina_inarray_push(arr, _int_ref(33)); 816 eina_inarray_push(arr, _int_ref(33));
@@ -821,7 +821,7 @@ static Eina_Inarray *_inarray_int_in_own_to_check = NULL;
821 821
822Eina_Bool _test_testing_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr) 822Eina_Bool _test_testing_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
823{ 823{
824 Eina_Bool r = _inarray_int_equal(arr, base_arr_int, base_arr_int_size); 824 Eina_Bool r = _inarray_int_equal(arr, base_seq_int, base_seq_int_size);
825 eina_inarray_push(arr, _int_ref(42)); 825 eina_inarray_push(arr, _int_ref(42));
826 eina_inarray_push(arr, _int_ref(43)); 826 eina_inarray_push(arr, _int_ref(43));
827 eina_inarray_push(arr, _int_ref(33)); 827 eina_inarray_push(arr, _int_ref(33));
@@ -832,7 +832,7 @@ Eina_Bool _test_testing_check_eina_inarray_int_in_own(EINA_UNUSED Eo *obj, EINA_
832{ 832{
833 if (!_inarray_int_in_own_to_check) return EINA_FALSE; 833 if (!_inarray_int_in_own_to_check) return EINA_FALSE;
834 834
835 Eina_Bool r = _inarray_int_equal(_inarray_int_in_own_to_check, modified_arr_int, modified_arr_int_size); 835 Eina_Bool r = _inarray_int_equal(_inarray_int_in_own_to_check, modified_seq_int, modified_seq_int_size);
836 836
837 eina_inarray_free(_inarray_int_in_own_to_check); 837 eina_inarray_free(_inarray_int_in_own_to_check);
838 _inarray_int_in_own_to_check = NULL; 838 _inarray_int_in_own_to_check = NULL;
@@ -855,7 +855,7 @@ Eina_Bool _test_testing_check_eina_inarray_int_out(EINA_UNUSED Eo *obj, EINA_UNU
855{ 855{
856 if (!_inarray_int_out_to_check) return EINA_FALSE; 856 if (!_inarray_int_out_to_check) return EINA_FALSE;
857 857
858 Eina_Bool r = _inarray_int_equal(_inarray_int_out_to_check, modified_arr_int, modified_arr_int_size); 858 Eina_Bool r = _inarray_int_equal(_inarray_int_out_to_check, modified_seq_int, modified_seq_int_size);
859 859
860 eina_inarray_free(_inarray_int_out_to_check); 860 eina_inarray_free(_inarray_int_out_to_check);
861 _inarray_int_out_to_check = NULL; 861 _inarray_int_out_to_check = NULL;
@@ -887,7 +887,7 @@ Eina_Bool _test_testing_check_eina_inarray_int_return(EINA_UNUSED Eo *obj, EINA_
887{ 887{
888 if (!_inarray_int_return_to_check) return EINA_FALSE; 888 if (!_inarray_int_return_to_check) return EINA_FALSE;
889 889
890 Eina_Bool r = _inarray_int_equal(_inarray_int_return_to_check, modified_arr_int, modified_arr_int_size); 890 Eina_Bool r = _inarray_int_equal(_inarray_int_return_to_check, modified_seq_int, modified_seq_int_size);
891 891
892 eina_inarray_free(_inarray_int_return_to_check); 892 eina_inarray_free(_inarray_int_return_to_check);
893 _inarray_int_return_to_check = NULL; 893 _inarray_int_return_to_check = NULL;
@@ -919,7 +919,7 @@ Eina_Bool _inarray_str_equal(const Eina_Inarray *arr, const char * const base[],
919 919
920Eina_Bool _test_testing_eina_inarray_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr) 920Eina_Bool _test_testing_eina_inarray_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
921{ 921{
922 Eina_Bool r = _inarray_str_equal(arr, base_arr_str, base_arr_str_size); 922 Eina_Bool r = _inarray_str_equal(arr, base_seq_str, base_seq_str_size);
923 eina_inarray_push(arr, _new_str_ref("42")); 923 eina_inarray_push(arr, _new_str_ref("42"));
924 eina_inarray_push(arr, _new_str_ref("43")); 924 eina_inarray_push(arr, _new_str_ref("43"));
925 eina_inarray_push(arr, _new_str_ref("33")); 925 eina_inarray_push(arr, _new_str_ref("33"));
@@ -930,7 +930,7 @@ static Eina_Inarray *_inarray_str_in_own_to_check = NULL;
930 930
931Eina_Bool _test_testing_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr) 931Eina_Bool _test_testing_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
932{ 932{
933 Eina_Bool r = _inarray_str_equal(arr, base_arr_str, base_arr_str_size); 933 Eina_Bool r = _inarray_str_equal(arr, base_seq_str, base_seq_str_size);
934 eina_inarray_push(arr, _new_str_ref("42")); 934 eina_inarray_push(arr, _new_str_ref("42"));
935 eina_inarray_push(arr, _new_str_ref("43")); 935 eina_inarray_push(arr, _new_str_ref("43"));
936 eina_inarray_push(arr, _new_str_ref("33")); 936 eina_inarray_push(arr, _new_str_ref("33"));
@@ -942,7 +942,7 @@ Eina_Bool _test_testing_check_eina_inarray_str_in_own(EINA_UNUSED Eo *obj, EINA_
942{ 942{
943 if (!_inarray_str_in_own_to_check) return EINA_FALSE; 943 if (!_inarray_str_in_own_to_check) return EINA_FALSE;
944 944
945 Eina_Bool r = _inarray_str_equal(_inarray_str_in_own_to_check, modified_arr_str, modified_arr_str_size); 945 Eina_Bool r = _inarray_str_equal(_inarray_str_in_own_to_check, modified_seq_str, modified_seq_str_size);
946 946
947 char **ele; 947 char **ele;
948 EINA_INARRAY_FOREACH(_inarray_str_in_own_to_check, ele) 948 EINA_INARRAY_FOREACH(_inarray_str_in_own_to_check, ele)
@@ -969,7 +969,7 @@ Eina_Bool _test_testing_check_eina_inarray_str_out(EINA_UNUSED Eo *obj, EINA_UNU
969{ 969{
970 if (!_inarray_str_out_to_check) return EINA_FALSE; 970 if (!_inarray_str_out_to_check) return EINA_FALSE;
971 971
972 Eina_Bool r = _inarray_str_equal(_inarray_str_out_to_check, modified_arr_str, modified_arr_str_size); 972 Eina_Bool r = _inarray_str_equal(_inarray_str_out_to_check, modified_seq_str, modified_seq_str_size);
973 973
974 char **ele; 974 char **ele;
975 EINA_INARRAY_FOREACH(_inarray_str_out_to_check, ele) 975 EINA_INARRAY_FOREACH(_inarray_str_out_to_check, ele)
@@ -1005,7 +1005,7 @@ Eina_Bool _test_testing_check_eina_inarray_str_return(EINA_UNUSED Eo *obj, EINA_
1005{ 1005{
1006 if (!_inarray_str_return_to_check) return EINA_FALSE; 1006 if (!_inarray_str_return_to_check) return EINA_FALSE;
1007 1007
1008 Eina_Bool r = _inarray_str_equal(_inarray_str_return_to_check, modified_arr_str, modified_arr_str_size); 1008 Eina_Bool r = _inarray_str_equal(_inarray_str_return_to_check, modified_seq_str, modified_seq_str_size);
1009 1009
1010 char **ele; 1010 char **ele;
1011 EINA_INARRAY_FOREACH(_inarray_str_return_to_check, ele) 1011 EINA_INARRAY_FOREACH(_inarray_str_return_to_check, ele)
@@ -1044,7 +1044,7 @@ Eina_Bool _inarray_obj_equal(const Eina_Inarray *arr, const Test_Numberwrapper *
1044 1044
1045Eina_Bool _test_testing_eina_inarray_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr) 1045Eina_Bool _test_testing_eina_inarray_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
1046{ 1046{
1047 Eina_Bool r = _inarray_obj_equal(arr, base_arr_obj, base_arr_obj_size); 1047 Eina_Bool r = _inarray_obj_equal(arr, base_seq_obj, base_seq_obj_size);
1048 if (!r) return r; 1048 if (!r) return r;
1049 eina_inarray_push(arr, _new_obj_ref(42)); 1049 eina_inarray_push(arr, _new_obj_ref(42));
1050 eina_inarray_push(arr, _new_obj_ref(43)); 1050 eina_inarray_push(arr, _new_obj_ref(43));
@@ -1056,7 +1056,7 @@ static Eina_Inarray *_inarray_obj_in_own_to_check = NULL;
1056 1056
1057Eina_Bool _test_testing_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr) 1057Eina_Bool _test_testing_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inarray *arr)
1058{ 1058{
1059 Eina_Bool r = _inarray_obj_equal(arr, base_arr_obj, base_arr_obj_size); 1059 Eina_Bool r = _inarray_obj_equal(arr, base_seq_obj, base_seq_obj_size);
1060 if (!r) return r; 1060 if (!r) return r;
1061 eina_inarray_push(arr, _new_obj_ref(42)); 1061 eina_inarray_push(arr, _new_obj_ref(42));
1062 eina_inarray_push(arr, _new_obj_ref(43)); 1062 eina_inarray_push(arr, _new_obj_ref(43));
@@ -1068,7 +1068,7 @@ Eina_Bool _test_testing_check_eina_inarray_obj_in_own(EINA_UNUSED Eo *obj, EINA_
1068{ 1068{
1069 if (!_inarray_obj_in_own_to_check) return EINA_FALSE; 1069 if (!_inarray_obj_in_own_to_check) return EINA_FALSE;
1070 1070
1071 Eina_Bool r = _inarray_obj_equal(_inarray_obj_in_own_to_check, modified_arr_obj, modified_arr_obj_size); 1071 Eina_Bool r = _inarray_obj_equal(_inarray_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
1072 if (!r) return r; 1072 if (!r) return r;
1073 1073
1074 Test_Numberwrapper **ele; 1074 Test_Numberwrapper **ele;
@@ -1096,7 +1096,7 @@ Eina_Bool _test_testing_check_eina_inarray_obj_out(EINA_UNUSED Eo *obj, EINA_UNU
1096{ 1096{
1097 if (!_inarray_obj_out_to_check) return EINA_FALSE; 1097 if (!_inarray_obj_out_to_check) return EINA_FALSE;
1098 1098
1099 Eina_Bool r = _inarray_obj_equal(_inarray_obj_out_to_check, modified_arr_obj, modified_arr_obj_size); 1099 Eina_Bool r = _inarray_obj_equal(_inarray_obj_out_to_check, modified_seq_obj, modified_seq_obj_size);
1100 if (!r) return r; 1100 if (!r) return r;
1101 1101
1102 Test_Numberwrapper **ele; 1102 Test_Numberwrapper **ele;
@@ -1133,7 +1133,7 @@ Eina_Bool _test_testing_check_eina_inarray_obj_return(EINA_UNUSED Eo *obj, EINA_
1133{ 1133{
1134 if (!_inarray_obj_return_to_check) return EINA_FALSE; 1134 if (!_inarray_obj_return_to_check) return EINA_FALSE;
1135 1135
1136 Eina_Bool r = _inarray_obj_equal(_inarray_obj_return_to_check, modified_arr_obj, modified_arr_obj_size); 1136 Eina_Bool r = _inarray_obj_equal(_inarray_obj_return_to_check, modified_seq_obj, modified_seq_obj_size);
1137 if (!r) return r; 1137 if (!r) return r;
1138 1138
1139 Test_Numberwrapper **ele; 1139 Test_Numberwrapper **ele;
@@ -1184,7 +1184,7 @@ Eina_Bool _list_int_equal(const Eina_List *lst, const int base[], unsigned int l
1184 1184
1185Eina_Bool _test_testing_eina_list_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst) 1185Eina_Bool _test_testing_eina_list_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
1186{ 1186{
1187 Eina_Bool r = _list_int_equal(lst, base_arr_int, base_arr_int_size); 1187 Eina_Bool r = _list_int_equal(lst, base_seq_int, base_seq_int_size);
1188 return r; 1188 return r;
1189} 1189}
1190 1190
@@ -1192,7 +1192,7 @@ static Eina_List *_list_int_in_own_to_check = NULL;
1192 1192
1193Eina_Bool _test_testing_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst) 1193Eina_Bool _test_testing_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
1194{ 1194{
1195 Eina_Bool r = _list_int_equal(lst, base_arr_int, base_arr_int_size); 1195 Eina_Bool r = _list_int_equal(lst, base_seq_int, base_seq_int_size);
1196 if (!r) return r; 1196 if (!r) return r;
1197 1197
1198 lst = eina_list_append(lst, _new_int(42)); 1198 lst = eina_list_append(lst, _new_int(42));
@@ -1206,7 +1206,7 @@ Eina_Bool _test_testing_check_eina_list_int_in_own(EINA_UNUSED Eo *obj, EINA_UNU
1206{ 1206{
1207 if (!_list_int_in_own_to_check) return EINA_FALSE; 1207 if (!_list_int_in_own_to_check) return EINA_FALSE;
1208 1208
1209 Eina_Bool r = _list_int_equal(_list_int_in_own_to_check, modified_arr_int, modified_arr_int_size); 1209 Eina_Bool r = _list_int_equal(_list_int_in_own_to_check, modified_seq_int, modified_seq_int_size);
1210 if (!r) return r; 1210 if (!r) return r;
1211 1211
1212 int *ele; 1212 int *ele;
@@ -1231,7 +1231,7 @@ Eina_Bool _test_testing_check_eina_list_int_out(EINA_UNUSED Eo *obj, EINA_UNUSED
1231{ 1231{
1232 if (!_list_int_out_to_check) return EINA_FALSE; 1232 if (!_list_int_out_to_check) return EINA_FALSE;
1233 1233
1234 Eina_Bool r = _list_int_equal(_list_int_out_to_check, base_arr_int, base_arr_int_size); 1234 Eina_Bool r = _list_int_equal(_list_int_out_to_check, base_seq_int, base_seq_int_size);
1235 if (!r) return r; 1235 if (!r) return r;
1236 1236
1237 int *ele; 1237 int *ele;
@@ -1266,7 +1266,7 @@ Eina_Bool _test_testing_check_eina_list_int_return(EINA_UNUSED Eo *obj, EINA_UNU
1266{ 1266{
1267 if (!_list_int_return_to_check) return EINA_FALSE; 1267 if (!_list_int_return_to_check) return EINA_FALSE;
1268 1268
1269 Eina_Bool r = _list_int_equal(_list_int_return_to_check, base_arr_int, base_arr_int_size); 1269 Eina_Bool r = _list_int_equal(_list_int_return_to_check, base_seq_int, base_seq_int_size);
1270 if (!r) return r; 1270 if (!r) return r;
1271 1271
1272 int *ele; 1272 int *ele;
@@ -1307,7 +1307,7 @@ Eina_Bool _list_str_equal(const Eina_List *lst, const char * const base[], unsig
1307 1307
1308Eina_Bool _test_testing_eina_list_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst) 1308Eina_Bool _test_testing_eina_list_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
1309{ 1309{
1310 Eina_Bool r = _list_str_equal(lst, base_arr_str, base_arr_str_size); 1310 Eina_Bool r = _list_str_equal(lst, base_seq_str, base_seq_str_size);
1311 return r; 1311 return r;
1312} 1312}
1313 1313
@@ -1315,7 +1315,7 @@ static Eina_List *_list_str_in_own_to_check = NULL;
1315 1315
1316Eina_Bool _test_testing_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst) 1316Eina_Bool _test_testing_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
1317{ 1317{
1318 Eina_Bool r = _list_str_equal(lst, base_arr_str, base_arr_str_size); 1318 Eina_Bool r = _list_str_equal(lst, base_seq_str, base_seq_str_size);
1319 if (!r) return r; 1319 if (!r) return r;
1320 lst = eina_list_append(lst, strdup("42")); 1320 lst = eina_list_append(lst, strdup("42"));
1321 lst = eina_list_append(lst, strdup("43")); 1321 lst = eina_list_append(lst, strdup("43"));
@@ -1328,7 +1328,7 @@ Eina_Bool _test_testing_check_eina_list_str_in_own(EINA_UNUSED Eo *obj, EINA_UNU
1328{ 1328{
1329 if (!_list_str_in_own_to_check) return EINA_FALSE; 1329 if (!_list_str_in_own_to_check) return EINA_FALSE;
1330 1330
1331 Eina_Bool r = _list_str_equal(_list_str_in_own_to_check, modified_arr_str, modified_arr_str_size); 1331 Eina_Bool r = _list_str_equal(_list_str_in_own_to_check, modified_seq_str, modified_seq_str_size);
1332 if (!r) return r; 1332 if (!r) return r;
1333 1333
1334 char *ele; 1334 char *ele;
@@ -1354,7 +1354,7 @@ Eina_Bool _test_testing_check_eina_list_str_out(EINA_UNUSED Eo *obj, EINA_UNUSED
1354{ 1354{
1355 if (!_list_str_out_to_check) return EINA_FALSE; 1355 if (!_list_str_out_to_check) return EINA_FALSE;
1356 1356
1357 Eina_Bool r = _list_str_equal(_list_str_out_to_check, base_arr_str, base_arr_str_size); 1357 Eina_Bool r = _list_str_equal(_list_str_out_to_check, base_seq_str, base_seq_str_size);
1358 if (!r) return r; 1358 if (!r) return r;
1359 1359
1360 char *ele; 1360 char *ele;
@@ -1389,7 +1389,7 @@ Eina_Bool _test_testing_check_eina_list_str_return(EINA_UNUSED Eo *obj, EINA_UNU
1389{ 1389{
1390 if (!_list_str_return_to_check) return EINA_FALSE; 1390 if (!_list_str_return_to_check) return EINA_FALSE;
1391 1391
1392 Eina_Bool r = _list_str_equal(_list_str_return_to_check, base_arr_str, base_arr_str_size); 1392 Eina_Bool r = _list_str_equal(_list_str_return_to_check, base_seq_str, base_seq_str_size);
1393 if (!r) return r; 1393 if (!r) return r;
1394 1394
1395 char *ele; 1395 char *ele;
@@ -1432,7 +1432,7 @@ Eina_Bool _list_obj_equal(const Eina_List *lst, const Test_Numberwrapper * const
1432 1432
1433Eina_Bool _test_testing_eina_list_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst) 1433Eina_Bool _test_testing_eina_list_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
1434{ 1434{
1435 Eina_Bool r = _list_obj_equal(lst, base_arr_obj, base_arr_obj_size); 1435 Eina_Bool r = _list_obj_equal(lst, base_seq_obj, base_seq_obj_size);
1436 return r; 1436 return r;
1437} 1437}
1438 1438
@@ -1440,7 +1440,7 @@ static Eina_List *_list_obj_in_own_to_check = NULL;
1440 1440
1441Eina_Bool _test_testing_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst) 1441Eina_Bool _test_testing_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_List *lst)
1442{ 1442{
1443 Eina_Bool r = _list_obj_equal(lst, base_arr_obj, base_arr_obj_size); 1443 Eina_Bool r = _list_obj_equal(lst, base_seq_obj, base_seq_obj_size);
1444 if (!r) return r; 1444 if (!r) return r;
1445 lst = eina_list_append(lst, _new_obj(42)); 1445 lst = eina_list_append(lst, _new_obj(42));
1446 lst = eina_list_append(lst, _new_obj(43)); 1446 lst = eina_list_append(lst, _new_obj(43));
@@ -1453,7 +1453,7 @@ Eina_Bool _test_testing_check_eina_list_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNU
1453{ 1453{
1454 if (!_list_obj_in_own_to_check) return EINA_FALSE; 1454 if (!_list_obj_in_own_to_check) return EINA_FALSE;
1455 1455
1456 Eina_Bool r = _list_obj_equal(_list_obj_in_own_to_check, modified_arr_obj, modified_arr_obj_size); 1456 Eina_Bool r = _list_obj_equal(_list_obj_in_own_to_check, modified_seq_obj, modified_seq_obj_size);
1457 if (!r) return r; 1457 if (!r) return r;
1458 1458
1459 Test_Numberwrapper *ele; 1459 Test_Numberwrapper *ele;
@@ -1479,7 +1479,7 @@ Eina_Bool _test_testing_check_eina_list_obj_out(EINA_UNUSED Eo *obj, EINA_UNUSED
1479{ 1479{
1480 if (!_list_obj_out_to_check) return EINA_FALSE; 1480 if (!_list_obj_out_to_check) return EINA_FALSE;
1481 1481
1482 Eina_Bool r = _list_obj_equal(_list_obj_out_to_check, base_arr_obj, base_arr_obj_size); 1482 Eina_Bool r = _list_obj_equal(_list_obj_out_to_check, base_seq_obj, base_seq_obj_size);
1483 if (!r) return r; 1483 if (!r) return r;
1484 1484
1485 Test_Numberwrapper *ele; 1485 Test_Numberwrapper *ele;
@@ -1514,7 +1514,7 @@ Eina_Bool _test_testing_check_eina_list_obj_return(EINA_UNUSED Eo *obj, EINA_UNU
1514{ 1514{
1515 if (!_list_obj_return_to_check) return EINA_FALSE; 1515 if (!_list_obj_return_to_check) return EINA_FALSE;
1516 1516
1517 Eina_Bool r = _list_obj_equal(_list_obj_return_to_check, base_arr_obj, base_arr_obj_size); 1517 Eina_Bool r = _list_obj_equal(_list_obj_return_to_check, base_seq_obj, base_seq_obj_size);
1518 if (!r) return r; 1518 if (!r) return r;
1519 1519
1520 Test_Numberwrapper *ele; 1520 Test_Numberwrapper *ele;
@@ -1579,7 +1579,7 @@ Eina_Bool _inlist_int_equal(const Eina_Inlist *lst, const int base[], unsigned i
1579 1579
1580Eina_Bool _test_testing_eina_inlist_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst) 1580Eina_Bool _test_testing_eina_inlist_int_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
1581{ 1581{
1582 Eina_Bool r = _inlist_int_equal(lst, base_arr_int, base_arr_int_size); 1582 Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
1583 return r; 1583 return r;
1584} 1584}
1585 1585
@@ -1587,7 +1587,7 @@ static Eina_Inlist *_inlist_int_in_own_to_check = NULL;
1587 1587
1588Eina_Bool _test_testing_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst) 1588Eina_Bool _test_testing_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
1589{ 1589{
1590 Eina_Bool r = _inlist_int_equal(lst, base_arr_int, base_arr_int_size); 1590 Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
1591 if (!r) return r; 1591 if (!r) return r;
1592 1592
1593 lst = eina_inlist_append(lst, _new_inlist_int(42)); 1593 lst = eina_inlist_append(lst, _new_inlist_int(42));
@@ -1603,7 +1603,7 @@ Eina_Bool _test_testing_check_eina_inlist_int_in_own(EINA_UNUSED Eo *obj, EINA_U
1603 if (!lst) return EINA_FALSE; 1603 if (!lst) return EINA_FALSE;
1604 _inlist_int_in_own_to_check = NULL; 1604 _inlist_int_in_own_to_check = NULL;
1605 1605
1606 Eina_Bool r = _inlist_int_equal(lst, modified_arr_int, modified_arr_int_size); 1606 Eina_Bool r = _inlist_int_equal(lst, modified_seq_int, modified_seq_int_size);
1607 if (!r) return r; 1607 if (!r) return r;
1608 1608
1609 Test_Inlist_Node_Int *node; 1609 Test_Inlist_Node_Int *node;
@@ -1632,7 +1632,7 @@ Eina_Bool _test_testing_check_eina_inlist_int_out(EINA_UNUSED Eo *obj, EINA_UNUS
1632 if (!lst) return EINA_FALSE; 1632 if (!lst) return EINA_FALSE;
1633 _inlist_int_out_to_check = NULL; 1633 _inlist_int_out_to_check = NULL;
1634 1634
1635 Eina_Bool r = _inlist_int_equal(lst, base_arr_int, base_arr_int_size); 1635 Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
1636 if (!r) return r; 1636 if (!r) return r;
1637 1637
1638 Test_Inlist_Node_Int *node; 1638 Test_Inlist_Node_Int *node;
@@ -1671,7 +1671,7 @@ Eina_Bool _test_testing_check_eina_inlist_int_return(EINA_UNUSED Eo *obj, EINA_U
1671 if (!lst) return EINA_FALSE; 1671 if (!lst) return EINA_FALSE;
1672 _inlist_int_return_to_check = NULL; 1672 _inlist_int_return_to_check = NULL;
1673 1673
1674 Eina_Bool r = _inlist_int_equal(lst, base_arr_int, base_arr_int_size); 1674 Eina_Bool r = _inlist_int_equal(lst, base_seq_int, base_seq_int_size);
1675 if (!r) return r; 1675 if (!r) return r;
1676 1676
1677 Test_Inlist_Node_Int *node; 1677 Test_Inlist_Node_Int *node;
@@ -1727,7 +1727,7 @@ Eina_Bool _inlist_str_equal(const Eina_Inlist *lst, const char * const base[], u
1727 1727
1728Eina_Bool _test_testing_eina_inlist_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst) 1728Eina_Bool _test_testing_eina_inlist_str_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
1729{ 1729{
1730 Eina_Bool r = _inlist_str_equal(lst, base_arr_str, base_arr_str_size); 1730 Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
1731 return r; 1731 return r;
1732} 1732}
1733 1733
@@ -1735,7 +1735,7 @@ static Eina_Inlist *_inlist_str_in_own_to_check = NULL;
1735 1735
1736Eina_Bool _test_testing_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst) 1736Eina_Bool _test_testing_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
1737{ 1737{
1738 Eina_Bool r = _inlist_str_equal(lst, base_arr_str, base_arr_str_size); 1738 Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
1739 if (!r) return r; 1739 if (!r) return r;
1740 lst = eina_inlist_append(lst, _new_inlist_str("42")); 1740 lst = eina_inlist_append(lst, _new_inlist_str("42"));
1741 lst = eina_inlist_append(lst, _new_inlist_str("43")); 1741 lst = eina_inlist_append(lst, _new_inlist_str("43"));
@@ -1750,7 +1750,7 @@ Eina_Bool _test_testing_check_eina_inlist_str_in_own(EINA_UNUSED Eo *obj, EINA_U
1750 if (!lst) return EINA_FALSE; 1750 if (!lst) return EINA_FALSE;
1751 _inlist_str_in_own_to_check = NULL; 1751 _inlist_str_in_own_to_check = NULL;
1752 1752
1753 Eina_Bool r = _inlist_str_equal(lst, modified_arr_str, modified_arr_str_size); 1753 Eina_Bool r = _inlist_str_equal(lst, modified_seq_str, modified_seq_str_size);
1754 if (!r) return r; 1754 if (!r) return r;
1755 1755
1756 Test_Inlist_Node_Str *node; 1756 Test_Inlist_Node_Str *node;
@@ -1781,7 +1781,7 @@ Eina_Bool _test_testing_check_eina_inlist_str_out(EINA_UNUSED Eo *obj, EINA_UNUS
1781 if (!lst) return EINA_FALSE; 1781 if (!lst) return EINA_FALSE;
1782 _inlist_str_out_to_check = NULL; 1782 _inlist_str_out_to_check = NULL;
1783 1783
1784 Eina_Bool r = _inlist_str_equal(lst, base_arr_str, base_arr_str_size); 1784 Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
1785 if (!r) return r; 1785 if (!r) return r;
1786 1786
1787 Test_Inlist_Node_Str *node; 1787 Test_Inlist_Node_Str *node;
@@ -1821,7 +1821,7 @@ Eina_Bool _test_testing_check_eina_inlist_str_return(EINA_UNUSED Eo *obj, EINA_U
1821 if (!lst) return EINA_FALSE; 1821 if (!lst) return EINA_FALSE;
1822 _inlist_str_return_to_check = NULL; 1822 _inlist_str_return_to_check = NULL;
1823 1823
1824 Eina_Bool r = _inlist_str_equal(lst, base_arr_str, base_arr_str_size); 1824 Eina_Bool r = _inlist_str_equal(lst, base_seq_str, base_seq_str_size);
1825 if (!r) return r; 1825 if (!r) return r;
1826 1826
1827 Test_Inlist_Node_Str *node; 1827 Test_Inlist_Node_Str *node;
@@ -1880,7 +1880,7 @@ Eina_Bool _inlist_obj_equal(const Eina_Inlist *lst, const Test_Numberwrapper * c
1880 1880
1881Eina_Bool _test_testing_eina_inlist_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst) 1881Eina_Bool _test_testing_eina_inlist_obj_in(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
1882{ 1882{
1883 Eina_Bool r = _inlist_obj_equal(lst, base_arr_obj, base_arr_obj_size); 1883 Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
1884 return r; 1884 return r;
1885} 1885}
1886 1886
@@ -1888,7 +1888,7 @@ static Eina_Inlist *_inlist_obj_in_own_to_check = NULL;
1888 1888
1889Eina_Bool _test_testing_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst) 1889Eina_Bool _test_testing_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_UNUSED Test_Testing_Data *pd, Eina_Inlist *lst)
1890{ 1890{
1891 Eina_Bool r = _inlist_obj_equal(lst, base_arr_obj, base_arr_obj_size); 1891 Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
1892 if (!r) return r; 1892 if (!r) return r;
1893 lst = eina_inlist_append(lst, _new_inlist_obj(42)); 1893 lst = eina_inlist_append(lst, _new_inlist_obj(42));
1894 lst = eina_inlist_append(lst, _new_inlist_obj(43)); 1894 lst = eina_inlist_append(lst, _new_inlist_obj(43));
@@ -1903,7 +1903,7 @@ Eina_Bool _test_testing_check_eina_inlist_obj_in_own(EINA_UNUSED Eo *obj, EINA_U
1903 if (!lst) return EINA_FALSE; 1903 if (!lst) return EINA_FALSE;
1904 _inlist_obj_in_own_to_check = NULL; 1904 _inlist_obj_in_own_to_check = NULL;
1905 1905
1906 Eina_Bool r = _inlist_obj_equal(lst, modified_arr_obj, modified_arr_obj_size); 1906 Eina_Bool r = _inlist_obj_equal(lst, modified_seq_obj, modified_seq_obj_size);
1907 if (!r) return r; 1907 if (!r) return r;
1908 1908
1909 Test_Inlist_Node_Obj *node; 1909 Test_Inlist_Node_Obj *node;
@@ -1934,7 +1934,7 @@ Eina_Bool _test_testing_check_eina_inlist_obj_out(EINA_UNUSED Eo *obj, EINA_UNUS
1934 if (!lst) return EINA_FALSE; 1934 if (!lst) return EINA_FALSE;
1935 _inlist_obj_out_to_check = NULL; 1935 _inlist_obj_out_to_check = NULL;
1936 1936
1937 Eina_Bool r = _inlist_obj_equal(lst, base_arr_obj, base_arr_obj_size); 1937 Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
1938 if (!r) return r; 1938 if (!r) return r;
1939 1939
1940 Test_Inlist_Node_Obj *node; 1940 Test_Inlist_Node_Obj *node;
@@ -1974,7 +1974,7 @@ Eina_Bool _test_testing_check_eina_inlist_obj_return(EINA_UNUSED Eo *obj, EINA_U
1974 if (!lst) return EINA_FALSE; 1974 if (!lst) return EINA_FALSE;
1975 _inlist_obj_return_to_check = NULL; 1975 _inlist_obj_return_to_check = NULL;
1976 1976
1977 Eina_Bool r = _inlist_obj_equal(lst, base_arr_obj, base_arr_obj_size); 1977 Eina_Bool r = _inlist_obj_equal(lst, base_seq_obj, base_seq_obj_size);
1978 if (!r) return r; 1978 if (!r) return r;
1979 1979
1980 Test_Inlist_Node_Obj *node; 1980 Test_Inlist_Node_Obj *node;
@@ -2562,22 +2562,22 @@ EOLIAN static void
2562_test_testing_class_constructor(Efl_Class *klass) 2562_test_testing_class_constructor(Efl_Class *klass)
2563{ 2563{
2564 (void)klass; 2564 (void)klass;
2565 modified_arr_obj[0] = base_arr_obj[0] = _new_obj(0x0); 2565 modified_seq_obj[0] = base_seq_obj[0] = _new_obj(0x0);
2566 modified_arr_obj[1] = base_arr_obj[1] = _new_obj(0x2A); 2566 modified_seq_obj[1] = base_seq_obj[1] = _new_obj(0x2A);
2567 modified_arr_obj[2] = base_arr_obj[2] = _new_obj(0x42); 2567 modified_seq_obj[2] = base_seq_obj[2] = _new_obj(0x42);
2568 modified_arr_obj[3] = _new_obj(42); 2568 modified_seq_obj[3] = _new_obj(42);
2569 modified_arr_obj[4] = _new_obj(43); 2569 modified_seq_obj[4] = _new_obj(43);
2570 modified_arr_obj[5] = _new_obj(33); 2570 modified_seq_obj[5] = _new_obj(33);
2571} 2571}
2572 2572
2573EOLIAN static void 2573EOLIAN static void
2574_test_testing_class_destructor(Efl_Class *klass) 2574_test_testing_class_destructor(Efl_Class *klass)
2575{ 2575{
2576 (void)klass; 2576 (void)klass;
2577 for (unsigned i = 0; i < base_arr_obj_size; ++i) 2577 for (unsigned i = 0; i < base_seq_obj_size; ++i)
2578 efl_unref(base_arr_obj[i]); 2578 efl_unref(base_seq_obj[i]);
2579 for (unsigned i = 0; i < modified_arr_obj_size; ++i) 2579 for (unsigned i = 0; i < modified_seq_obj_size; ++i)
2580 efl_unref(modified_arr_obj[i]); 2580 efl_unref(modified_seq_obj[i]);
2581} 2581}
2582 2582
2583 2583