efl

1
/* EINA - EFL data type library
2
 * Copyright (C) 2008 Cedric Bail
3
 *
4
 * This library is free software; you can redistribute it and/or
5
 * modify it under the terms of the GNU Lesser General Public
6
 * License as published by the Free Software Foundation; either
7
 * version 2.1 of the License, or (at your option) any later version.
8
 *
9
 * This library is distributed in the hope that it will be useful,
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12
 * Lesser General Public License for more details.
13
 *
14
 * You should have received a copy of the GNU Lesser General Public
15
 * License along with this library;
16
 * if not, see <http://www.gnu.org/licenses/>.
17
 */
18

19
#ifdef HAVE_CONFIG_H
20
# include "config.h"
21
#endif
22

23
#include <stdio.h>
24

25
#include <Eina.h>
26

27
#include "eina_suite.h"
28

29
struct Number{
30
   int number;
31
};
32

33
static Eina_Bool
34
_filter(const void *it EINA_UNUSED, void *data, void *fdata)
35
{
36
   struct Number *numb = data;
37

38
   ck_assert_ptr_eq(fdata, (void*)1);
39
   return numb->number % 2;
40
}
41

42
EFL_START_TEST(eina_iterator_filter_simple)
43
{
44
   Eina_Iterator *it, *filtered;
45
   Eina_Array *ea;
46

47
   ea = eina_array_new(11);
48
   fail_if(!ea);
49

50
   for(int i = 0; i <= 10; i++)
51
     {
52
        struct Number *number;
53

54
        number = calloc(1, sizeof(struct Number));
55
        number->number = i;
56

57
        eina_array_push(ea, number);
58
     }
59

60
   it = eina_array_iterator_new(ea);
61
   filtered = eina_iterator_filter_new(it, _filter, NULL, (void*)1);
62
   for(int i = 1; i <= 10; i+=2)
63
     {
64
        struct Number *numb;
65
        Eina_Bool ret;
66

67
        ret = eina_iterator_next(filtered, (void**)&numb);
68

69
        fail_if(!ret);
70
        ck_assert_int_eq(numb->number, i);
71
     }
72

73
   {
74
      struct Number *numb;
75
      Eina_Bool ret;
76

77
      ret = eina_iterator_next(filtered, (void**)&numb);
78
      fail_if(ret);
79
   }
80

81

82
   eina_iterator_free(it);
83

84
   eina_array_free(ea);
85

86
}
87
EFL_END_TEST
88

89
struct Free_test {
90
   Eina_Bool got_freed;
91
};
92

93
static Eina_Bool
94
_filter_free(const void *it EINA_UNUSED, void *data EINA_UNUSED, void *fdata EINA_UNUSED)
95
{
96
   return EINA_TRUE;
97
}
98

99
static void
100
_free(void *data)
101
{
102
   struct Free_test *test = data;
103
   test->got_freed = EINA_TRUE;
104
}
105

106
EFL_START_TEST(eina_iterator_filter_free)
107
{
108
   Eina_Iterator *it, *filtered;
109
   Eina_Array *ea;
110
   struct Free_test *data;
111

112
   data = calloc(1, sizeof(struct Free_test));
113
   ea = eina_array_new(11);
114
   fail_if(!ea);
115

116
   it = eina_array_iterator_new(ea);
117
   filtered = eina_iterator_filter_new(it, _filter_free, _free, data);
118
   eina_iterator_free(filtered);
119

120
   eina_array_free(ea);
121

122
   ck_assert_int_ne(data->got_freed, 0);
123

124
   free(data);
125

126
}
127
EFL_END_TEST
128
static Eina_Bool
129
eina_iterator_array_check(EINA_UNUSED const Eina_Array *array,
130
                          int *data,  int *fdata)
131
{
132
   fail_if(*fdata > *data);
133
   *fdata = *data;
134

135
   return EINA_TRUE;
136
}
137

138
EFL_START_TEST(eina_iterator_array_simple)
139
{
140
   Eina_Iterator *it;
141
   Eina_Array *ea;
142
   int *tmp;
143
   int i;
144

145
   ea = eina_array_new(11);
146
        fail_if(!ea);
147

148
   for (i = 0; i < 200; ++i)
149
     {
150
        tmp = malloc(sizeof(int));
151
        fail_if(!tmp);
152
        *tmp = i;
153

154
        eina_array_push(ea, tmp);
155
     }
156

157
   it = eina_array_iterator_new(ea);
158
   fail_if(!it);
159

160
   i = -1;
161
   eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_array_check), &i);
162
   fail_if(i != 199);
163

164
   fail_if(eina_iterator_container_get(it) != ea);
165
   fail_if(eina_iterator_next(it, (void **)&tmp) != EINA_FALSE);
166

167
   eina_iterator_free(it);
168

169
   eina_array_free(ea);
170

171
}
172
EFL_END_TEST
173

174
static Eina_Bool
175
eina_iterator_hash_key_check(const Eina_Hash *hash,
176
                             const char *key,
177
                             EINA_UNUSED void *fdata)
178
{
179
   fail_if(eina_hash_find(hash, key) == NULL);
180

181
   return EINA_TRUE;
182
}
183
static Eina_Bool
184
eina_iterator_hash_data_check(const Eina_Hash *hash,
185
                              int *data,
186
                              EINA_UNUSED void *fdata)
187
{
188
   char tmp[10];
189

190
   snprintf(tmp, 10, "%i", *data);
191
   fail_if(eina_hash_find(hash, tmp) != data);
192

193
   return EINA_TRUE;
194
}
195
static Eina_Bool
196
eina_iterator_hash_tuple_check(EINA_UNUSED const Eina_Hash *hash,
197
                               Eina_Hash_Tuple *tuple,
198
                               EINA_UNUSED void *fdata)
199
{
200
   fail_if(atoi((char *)tuple->key) != *((int *)tuple->data));
201

202
   return EINA_TRUE;
203
}
204

205
EFL_START_TEST(eina_iterator_hash_simple)
206
{
207
   Eina_Iterator *it;
208
   Eina_Hash *hash;
209
   int array[] = { 1, 42, 7, 8, 6 };
210

211

212
   hash = eina_hash_string_superfast_new(NULL);
213
   fail_if(hash == NULL);
214

215
   fail_if(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE);
216
   fail_if(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE);
217
   fail_if(eina_hash_add(hash, "7", &array[2]) != EINA_TRUE);
218
   fail_if(eina_hash_add(hash, "8", &array[3]) != EINA_TRUE);
219
   fail_if(eina_hash_add(hash, "6", &array[4]) != EINA_TRUE);
220

221
   it = eina_hash_iterator_key_new(hash);
222
   eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_hash_key_check), NULL);
223
   eina_iterator_free(it);
224

225
   it = eina_hash_iterator_data_new(hash);
226
   eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_hash_data_check), NULL);
227
   eina_iterator_free(it);
228

229
   it = eina_hash_iterator_tuple_new(hash);
230
   eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_hash_tuple_check), NULL);
231
   eina_iterator_free(it);
232

233
   eina_hash_free(hash);
234

235
}
236
EFL_END_TEST
237

238
typedef struct _Eina_Test_Inlist Eina_Test_Inlist;
239
struct _Eina_Test_Inlist
240
{
241
   EINA_INLIST;
242
   int i;
243
};
244

245
static Eina_Test_Inlist *
246
_eina_test_inlist_build(int i)
247
{
248
   Eina_Test_Inlist *tmp;
249

250
   tmp = malloc(sizeof(Eina_Test_Inlist));
251
   fail_if(!tmp);
252
   tmp->i = i;
253

254
   return tmp;
255
}
256

257
static Eina_Bool
258
eina_iterator_inlist_data_check(EINA_UNUSED const Eina_Inlist *in_list,
259
                                Eina_Test_Inlist *data,
260
                                int *fdata)
261
{
262
   switch (*fdata)
263
     {
264
      case 0: fail_if(data->i != 27); break;
265

266
      case 1: fail_if(data->i != 42); break;
267

268
      case 2: fail_if(data->i != 3227); break;
269

270
      case 3: fail_if(data->i != 1664); break;
271

272
      case 4: fail_if(data->i != 81); break;
273
     }
274

275
   (*fdata)++;
276

277
   return EINA_TRUE;
278
}
279

280
EFL_START_TEST(eina_iterator_inlist_simple)
281
{
282
   Eina_Inlist *lst = NULL;
283
   Eina_Test_Inlist *tmp;
284
   Eina_Test_Inlist *prev;
285
   Eina_Iterator *it;
286
   int i = 0;
287

288
   tmp = _eina_test_inlist_build(42);
289
   lst = eina_inlist_append(lst, EINA_INLIST_GET(tmp));
290
   fail_if(!lst);
291

292
   tmp = _eina_test_inlist_build(1664);
293
   lst = eina_inlist_append_relative(lst, EINA_INLIST_GET(tmp), lst);
294
   fail_if(!lst);
295
   fail_if(((Eina_Test_Inlist *)lst)->i != 42);
296

297
   prev = tmp;
298
   tmp = _eina_test_inlist_build(3227);
299
   lst = eina_inlist_prepend_relative(lst, EINA_INLIST_GET(
300
                                         tmp), EINA_INLIST_GET(prev));
301
   fail_if(!lst);
302
   fail_if(((Eina_Test_Inlist *)lst)->i != 42);
303

304
   tmp = _eina_test_inlist_build(27);
305
   lst = eina_inlist_prepend_relative(lst, EINA_INLIST_GET(tmp), NULL);
306

307
   tmp = _eina_test_inlist_build(81);
308
   lst = eina_inlist_append_relative(lst, EINA_INLIST_GET(tmp), NULL);
309

310
   it = eina_inlist_iterator_new(lst);
311
   fail_if(!it);
312

313
   eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_inlist_data_check), &i);
314
   eina_iterator_free(it);
315

316
   fail_if(i != 5);
317
}
318
EFL_END_TEST
319

320
static Eina_Bool
321
eina_iterator_list_data_check(EINA_UNUSED const Eina_List *list,
322
                              int *data,
323
                              int *fdata)
324
{
325
   switch (*fdata)
326
     {
327
      case 0: fail_if(*data != 81); break;
328

329
      case 1: fail_if(*data != 7); break;
330

331
      case 2: fail_if(*data != 9); break;
332

333
      case 3: fail_if(*data != 6); break;
334

335
      case 4: fail_if(*data != 42); break;
336

337
      case 5: fail_if(*data != 1); break;
338

339
      case 6: fail_if(*data != 1337); break;
340
     }
341

342
   (*fdata)++;
343

344
   return EINA_TRUE;
345
}
346

347
EFL_START_TEST(eina_iterator_list_simple)
348
{
349
   Eina_List *list = NULL;
350
   Eina_Iterator *it;
351
   int data[] = { 6, 9, 42, 1, 7, 1337, 81, 1664 };
352
   int i = 0;
353

354

355
   list = eina_list_append(list, &data[0]);
356
   fail_if(list == NULL);
357

358
   list = eina_list_prepend(list, &data[1]);
359
   fail_if(list == NULL);
360

361
   list = eina_list_append(list, &data[2]);
362
   fail_if(list == NULL);
363

364
   list = eina_list_append(list, &data[3]);
365
   fail_if(list == NULL);
366

367
   list = eina_list_prepend(list, &data[4]);
368
   fail_if(list == NULL);
369

370
   list = eina_list_append(list, &data[5]);
371
   fail_if(list == NULL);
372

373
   list = eina_list_prepend(list, &data[6]);
374
   fail_if(list == NULL);
375

376
   it = eina_list_iterator_new(list);
377
   fail_if(!it);
378

379
   eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_list_data_check), &i);
380
   eina_iterator_free(it);
381
}
382
EFL_END_TEST
383

384
static Eina_Bool
385
eina_reverse_iterator_list_data_check(EINA_UNUSED const Eina_List *list,
386
                              int *data,
387
                              int *fdata)
388
{
389
   switch (*fdata)
390
     {
391
      case 0: fail_if(*data != 1337); break;
392

393
      case 1: fail_if(*data != 1); break;
394

395
      case 2: fail_if(*data != 42); break;
396

397
      case 3: fail_if(*data != 6); break;
398

399
      case 4: fail_if(*data != 9); break;
400

401
      case 5: fail_if(*data != 7); break;
402

403
      case 6: fail_if(*data != 81); break;
404
     }
405

406
   (*fdata)++;
407

408
   return EINA_TRUE;
409
}
410

411
EFL_START_TEST(eina_reverse_iterator_list_simple)
412
{
413
   Eina_List *list = NULL;
414
   Eina_Iterator *it;
415
   int data[] = { 6, 9, 42, 1, 7, 1337, 81, 1664 };
416
   int i = 0;
417

418

419
   list = eina_list_append(list, &data[0]);
420
   fail_if(list == NULL);
421

422
   list = eina_list_prepend(list, &data[1]);
423
   fail_if(list == NULL);
424

425
   list = eina_list_append(list, &data[2]);
426
   fail_if(list == NULL);
427

428
   list = eina_list_append(list, &data[3]);
429
   fail_if(list == NULL);
430

431
   list = eina_list_prepend(list, &data[4]);
432
   fail_if(list == NULL);
433

434
   list = eina_list_append(list, &data[5]);
435
   fail_if(list == NULL);
436

437
   list = eina_list_prepend(list, &data[6]);
438
   fail_if(list == NULL);
439

440
   it = eina_list_iterator_reversed_new(list);
441
   fail_if(!it);
442

443
   eina_iterator_foreach(it, EINA_EACH_CB(eina_reverse_iterator_list_data_check), &i);
444
   eina_iterator_free(it);
445
}
446
EFL_END_TEST
447

448
typedef struct _Eina_Rbtree_Int Eina_Rbtree_Int;
449
struct _Eina_Rbtree_Int
450
{
451
   Eina_Rbtree node;
452
   int value;
453
};
454

455
static Eina_Rbtree_Direction
456
eina_rbtree_int_cmp(const Eina_Rbtree_Int *left, const Eina_Rbtree_Int *right, void *data EINA_UNUSED)
457
{
458
   fail_if(!left);
459
   fail_if(!right);
460

461
   if (left->value < right->value)
462
      return EINA_RBTREE_LEFT;
463

464
   return EINA_RBTREE_RIGHT;
465
}
466

467
static Eina_Rbtree *
468
_eina_rbtree_int_new(int value)
469
{
470
   Eina_Rbtree_Int *it;
471

472
   it = malloc(sizeof (Eina_Rbtree_Int));
473
   fail_if(!it);
474

475
   it->value = value;
476

477
   return &it->node;
478
}
479

480
static Eina_Bool
481
eina_iterator_rbtree_data_check_sorted(EINA_UNUSED const Eina_List *list,
482
                                       Eina_Rbtree_Int *data,
483
                                       int *fdata)
484
{
485
   switch (*fdata)
486
     {
487
      case 0: fail_if(data->value != 10); break;
488

489
      case 1: fail_if(data->value != 27); break;
490

491
      case 2: fail_if(data->value != 42); break;
492

493
      case 3: fail_if(data->value != 69); break;
494

495
      case 4: fail_if(data->value != 1337); break;
496
     }
497

498
   (*fdata)++;
499

500
   return EINA_TRUE;
501
}
502

503
static Eina_Bool
504
eina_iterator_rbtree_data_check_prefix(EINA_UNUSED const Eina_List *list,
505
                                       Eina_Rbtree_Int *data,
506
                                       int *fdata)
507
{
508
   switch (*fdata)
509
     {
510
      case 0: fail_if(data->value != 27); break;
511

512
      case 1: fail_if(data->value != 10); break;
513

514
      case 2: fail_if(data->value != 69); break;
515

516
      case 3: fail_if(data->value != 42); break;
517

518
      case 4: fail_if(data->value != 1337); break;
519
     }
520

521
   (*fdata)++;
522

523
   return EINA_TRUE;
524
}
525

526
static Eina_Bool
527
eina_iterator_rbtree_data_check_postfix(EINA_UNUSED const Eina_List *list,
528
                                        Eina_Rbtree_Int *data,
529
                                        int *fdata)
530
{
531
   switch (*fdata)
532
     {
533
      case 0: fail_if(data->value != 10); break;
534

535
      case 1: fail_if(data->value != 42); break;
536

537
      case 2: fail_if(data->value != 1337); break;
538

539
      case 3: fail_if(data->value != 69); break;
540

541
      case 4: fail_if(data->value != 27); break;
542
     }
543

544
   (*fdata)++;
545

546
   return EINA_TRUE;
547
}
548

549
EFL_START_TEST(eina_iterator_rbtree_simple)
550
{
551
   Eina_Rbtree *root = NULL;
552
   Eina_Iterator *it;
553
   int i;
554

555
   root = eina_rbtree_inline_insert(NULL,
556
				    _eina_rbtree_int_new(10),
557
                                    EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp),
558
				    NULL);
559
   fail_if(!root);
560

561
   root = eina_rbtree_inline_insert(root,
562
				    _eina_rbtree_int_new(1337),
563
                                    EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp),
564
				    NULL);
565
   fail_if(!root);
566

567
   root = eina_rbtree_inline_insert(root,
568
				    _eina_rbtree_int_new(27),
569
                                    EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp),
570
				    NULL);
571
   fail_if(!root);
572

573
   root = eina_rbtree_inline_insert(root,
574
				    _eina_rbtree_int_new(69),
575
                                    EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp),
576
				    NULL);
577
   fail_if(!root);
578

579
   root = eina_rbtree_inline_insert(root,
580
				    _eina_rbtree_int_new(42),
581
                                    EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp),
582
				    NULL);
583
   fail_if(!root);
584

585
   i = 0;
586
   it = eina_rbtree_iterator_prefix(root);
587
   fail_if(!it);
588

589
   eina_iterator_foreach(it,
590
			 EINA_EACH_CB(eina_iterator_rbtree_data_check_prefix),
591
			 &i);
592
   eina_iterator_free(it);
593

594
   /* This will return the item sorted. */
595
   i = 0;
596
   it = eina_rbtree_iterator_infix(root);
597
   fail_if(!it);
598

599
   eina_iterator_foreach(it,
600
			 EINA_EACH_CB(eina_iterator_rbtree_data_check_sorted),
601
			 &i);
602
   eina_iterator_free(it);
603

604
   i = 0;
605
   it = eina_rbtree_iterator_postfix(root);
606
   fail_if(!it);
607

608
   eina_iterator_foreach(it,
609
			 EINA_EACH_CB(eina_iterator_rbtree_data_check_postfix),
610
			 &i);
611
   eina_iterator_free(it);
612
}
613
EFL_END_TEST
614

615
EFL_START_TEST(eina_iterator_carray_length)
616
{
617
   unsigned int array[] = { 1, 4, 9, 16 };
618
   Eina_Iterator *it;
619
   unsigned int j = 1;
620
   unsigned int i = 0;
621

622
   it = EINA_C_ARRAY_ITERATOR_NEW(array);
623
   EINA_ITERATOR_FOREACH(it, i)
624
     {
625
        fail_if(i != j * j);
626
        j++;
627
     }
628
   fail_if(j < EINA_C_ARRAY_LENGTH(array));
629
   eina_iterator_free(it);
630
}
631
EFL_END_TEST
632

633
EFL_START_TEST(eina_iterator_multi)
634
{
635
   unsigned int array1[] = { 1, 4, 9, 16 };
636
   unsigned int array2[] = { 25, 36, 49, 64 };
637
   unsigned int array3[] = { 81, 100, 121, 144 };
638
   Eina_Iterator *it;
639
   unsigned int i;
640
   unsigned int j = 1;
641

642
   it = eina_multi_iterator_new(EINA_C_ARRAY_ITERATOR_NEW(array1),
643
                                EINA_C_ARRAY_ITERATOR_NEW(array2),
644
                                EINA_C_ARRAY_ITERATOR_NEW(array3));
645
   EINA_ITERATOR_FOREACH(it, i)
646
     {
647
        fail_if(i != j * j);
648
        j++;
649
     }
650
   fail_if(j < EINA_C_ARRAY_LENGTH(array1)
651
             + EINA_C_ARRAY_LENGTH(array2)
652
             + EINA_C_ARRAY_LENGTH(array3));
653
   eina_iterator_free(it);
654
}
655
EFL_END_TEST
656

657
static void*
658
_return_x(const void *container EINA_UNUSED, void *data, void *fdata)
659
{
660
   Eina_Rectangle *rect = data;
661
   ck_assert_int_eq(*((int*)fdata), 1337);
662

663
   return &rect->x;
664
}
665

666
static void
667
_free_cb(void *data)
668
{
669
   int *free_data = data;
670

671
   *free_data = 0;
672
}
673

674
EFL_START_TEST(eina_iterator_process)
675
{
676
   Eina_Inarray *rects = eina_inarray_new(sizeof(Eina_Rectangle), 5);
677
   Eina_Rectangle rect_arr[] = {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11}, {12, 13, 14, 15}, {16, 17, 18, 19}};
678
   Eina_Iterator *it;
679
   int free = 1337;
680
   int *a, i = 0;
681

682
   eina_inarray_push(rects, &rect_arr[0]);
683
   eina_inarray_push(rects, &rect_arr[1]);
684
   eina_inarray_push(rects, &rect_arr[2]);
685
   eina_inarray_push(rects, &rect_arr[3]);
686
   eina_inarray_push(rects, &rect_arr[4]);
687

688
   it = eina_iterator_processed_new(eina_inarray_iterator_new(rects), _return_x, _free_cb, &free);
689
   EINA_ITERATOR_FOREACH(it, a)
690
     {
691
         ck_assert_int_eq(*a, i*4);
692
         i++;
693
     }
694
   ck_assert_int_eq(i, 5);
695
   eina_iterator_free(it);
696
   ck_assert_int_eq(free, 0);
697
}
698
EFL_END_TEST
699

700
void
701
eina_test_iterator(TCase *tc)
702
{
703
   tcase_add_test(tc, eina_iterator_array_simple);
704
   tcase_add_test(tc, eina_iterator_hash_simple);
705
   tcase_add_test(tc, eina_iterator_inlist_simple);
706
   tcase_add_test(tc, eina_iterator_list_simple);
707
   tcase_add_test(tc, eina_reverse_iterator_list_simple);
708
   tcase_add_test(tc, eina_iterator_rbtree_simple);
709
   tcase_add_test(tc, eina_iterator_filter_simple);
710
   tcase_add_test(tc, eina_iterator_filter_free);
711
   tcase_add_test(tc, eina_iterator_carray_length);
712
   tcase_add_test(tc, eina_iterator_multi);
713
   tcase_add_test(tc, eina_iterator_process);
714
}
715