efl

1
#ifdef HAVE_CONFIG_H
2
# include "config.h"
3
#endif
4

5
#include <Eina.h>
6
#include <Eet.h>
7

8
#include "eet_suite.h"
9
#include "eet_test_common.h"
10

11
typedef struct _Eet_Union_Test    Eet_Union_Test;
12
typedef struct _Eet_Variant_Test  Eet_Variant_Test;
13
typedef struct _Eet_Variant_Type  Eet_Variant_Type;
14
typedef struct _Eet_Inherit_Test1 Eet_Inherit_Test1;
15
typedef struct _Eet_Inherit_Test2 Eet_Inherit_Test2;
16
typedef struct _Eet_Inherit_Test3 Eet_Inherit_Test3;
17
typedef struct _Eet_St1           Eet_St1;
18
typedef struct _Eet_St2           Eet_St2;
19
typedef struct _Eet_St3           Eet_St3;
20
typedef struct _Eet_List          Eet_List;
21
typedef struct _Eet_Hash          Eet_Hash;
22

23
typedef enum _Eet_Union
24
{
25
   EET_UNKNOWN,
26
   EET_ST1,
27
   EET_ST2,
28
   EET_ST3
29
} Eet_Union;
30

31
struct
32
{
33
   Eet_Union   u;
34
   const char *name;
35
} eet_mapping[] = {
36
   { EET_ST1, "ST1" },
37
   { EET_ST2, "ST2" },
38
   { EET_ST3, "ST3" },
39
   { EET_UNKNOWN, NULL }
40
};
41

42
struct _Eet_St1
43
{
44
   double val1;
45
   int    stuff;
46
   char  *s1;
47
};
48

49
struct _Eet_St2
50
{
51
   Eina_Bool          b1;
52
   unsigned long long v1;
53
};
54

55
struct _Eet_St3
56
{
57
   int boby;
58
};
59

60
struct _Eet_Union_Test
61
{
62
   Eet_Union type;
63

64
   union {
65
      Eet_St1 st1;
66
      Eet_St2 st2;
67
      Eet_St3 st3;
68
   } u;
69
};
70

71
struct _Eet_Variant_Type
72
{
73
   const char *type;
74
   Eina_Bool   unknow : 1;
75
};
76

77
struct _Eet_Variant_Test
78
{
79
   Eet_Variant_Type t;
80

81
   void            *data;
82
   Eina_List       *data_list;
83
};
84

85
struct _Eet_Inherit_Test1
86
{
87
   Eet_Union type;
88
   Eet_St1   st1;
89
};
90
struct _Eet_Inherit_Test2
91
{
92
   Eet_Union type;
93
   Eet_St2   st2;
94
};
95
struct _Eet_Inherit_Test3
96
{
97
   Eet_Union type;
98
   Eet_St3   st3;
99
};
100

101
struct _Eet_List
102
{
103
   Eina_List *list;
104
};
105

106
struct _Eet_Hash
107
{
108
   Eina_Hash *hash;
109
};
110

111
static const char *
112
_eet_union_type_get(const void *data,
113
                    Eina_Bool  *unknow)
114
{
115
   const Eet_Union *u = data;
116
   int i;
117

118
   if (unknow)
119
     *unknow = EINA_FALSE;
120

121
   for (i = 0; eet_mapping[i].name != NULL; ++i)
122
     if (*u == eet_mapping[i].u)
123
       return eet_mapping[i].name;
124

125
   if (unknow)
126
     *unknow = EINA_TRUE;
127

128
   return NULL;
129
} /* _eet_union_type_get */
130

131
static Eina_Bool
132
_eet_union_type_set(const char *type,
133
                    void       *data,
134
                    Eina_Bool   unknow)
135
{
136
   Eet_Union *u = data;
137
   int i;
138

139
   if (unknow)
140
     return EINA_FALSE;
141

142
   for (i = 0; eet_mapping[i].name != NULL; ++i)
143
     if (strcmp(eet_mapping[i].name, type) == 0)
144
       {
145
          *u = eet_mapping[i].u;
146
          return EINA_TRUE;
147
       }
148

149
   return EINA_FALSE;
150
} /* _eet_union_type_set */
151

152
static const char *
153
_eet_variant_type_get(const void *data,
154
                      Eina_Bool  *unknow)
155
{
156
   const Eet_Variant_Type *type = data;
157
   int i;
158

159
   if (unknow)
160
     *unknow = type->unknow;
161

162
   for (i = 0; eet_mapping[i].name != NULL; ++i)
163
     if (strcmp(type->type, eet_mapping[i].name) == 0)
164
       return eet_mapping[i].name;
165

166
   if (unknow)
167
     *unknow = EINA_FALSE;
168

169
   return type->type;
170
} /* _eet_variant_type_get */
171

172
static Eina_Bool
173
_eet_variant_type_set(const char *type,
174
                      void       *data,
175
                      Eina_Bool   unknow)
176
{
177
   Eet_Variant_Type *vt = data;
178

179
   vt->type = type;
180
   vt->unknow = unknow;
181
   return EINA_TRUE;
182
} /* _eet_variant_type_set */
183

184
static Eet_Data_Descriptor *
185
_eet_st1_dd(void)
186
{
187
   Eet_Data_Descriptor_Class eddc;
188
   Eet_Data_Descriptor *res;
189

190
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_St1);
191
   res = eet_data_descriptor_stream_new(&eddc);
192
   EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St1, "val1", val1, EET_T_DOUBLE);
193
   EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St1, "stuff", stuff, EET_T_INT);
194
   EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St1, "s1", s1, EET_T_STRING);
195

196
   return res;
197
} /* _eet_st1_dd */
198

199
static void
200
_eet_st1_set(Eet_St1 *st1,
201
             int      i)
202
{
203
   st1->val1 = EET_TEST_DOUBLE;
204
   st1->stuff = EET_TEST_INT + i;
205
   st1->s1 = EET_TEST_STRING;
206
} /* _eet_st1_set */
207

208
static void
209
_eet_st1_cmp(Eet_St1 *st1,
210
             int      i)
211
{
212
   double tmp;
213

214
   fail_if(!st1);
215

216
   tmp = st1->val1 - EET_TEST_DOUBLE;
217
   if (tmp < 0)
218
     tmp = -tmp;
219

220
   fail_if(tmp > 0.005);
221
   fail_if(st1->stuff != EET_TEST_INT + i);
222
   fail_if(strcmp(st1->s1, EET_TEST_STRING));
223
} /* _eet_st1_cmp */
224

225
static Eet_Data_Descriptor *
226
_eet_st2_dd(void)
227
{
228
   Eet_Data_Descriptor_Class eddc;
229
   Eet_Data_Descriptor *res;
230

231
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_St2);
232
   res = eet_data_descriptor_stream_new(&eddc);
233
   EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St2, "b1", b1, EET_T_UCHAR);
234
   EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St2, "v1", v1, EET_T_ULONG_LONG);
235

236
   return res;
237
} /* _eet_st2_dd */
238

239
static void
240
_eet_st2_set(Eet_St2 *st2,
241
             int      i)
242
{
243
   st2->b1 = EINA_TRUE;
244
   st2->v1 = EET_TEST_LONG_LONG + i;
245
} /* _eet_st2_set */
246

247
static void
248
_eet_st2_cmp(Eet_St2 *st2,
249
             int      i)
250
{
251
   fail_if(!st2->b1);
252
   fail_if(st2->v1 != EET_TEST_LONG_LONG + i);
253
} /* _eet_st2_cmp */
254

255
static Eet_Data_Descriptor *
256
_eet_st3_dd(void)
257
{
258
   Eet_Data_Descriptor_Class eddc;
259
   Eet_Data_Descriptor *res;
260

261
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_St3);
262
   res = eet_data_descriptor_stream_new(&eddc);
263
   EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St3, "boby", boby, EET_T_INT);
264

265
   return res;
266
} /* _eet_st3_dd */
267

268
static void
269
_eet_st3_set(Eet_St3 *st3,
270
             int      i)
271
{
272
   st3->boby = EET_TEST_INT + i;
273
} /* _eet_st3_set */
274

275
static void
276
_eet_st3_cmp(Eet_St3 *st3,
277
             int      i)
278
{
279
   fail_if(st3->boby != EET_TEST_INT + i);
280
} /* _eet_st3_cmp */
281

282
EFL_START_TEST(eet_test_data_basic_type_encoding_decoding)
283
{
284
   Eet_Data_Descriptor *edd;
285
   Eet_Test_Basic_Type *result;
286
   Eet_Data_Descriptor_Class eddc;
287
   Eet_Test_Basic_Type etbt;
288
   void *transfert;
289
   int size;
290

291
   eet_test_basic_set(&etbt, 0);
292

293
   eet_test_setup_eddc(&eddc);
294
   eddc.name = "Eet_Test_Basic_Type";
295
   eddc.size = sizeof(Eet_Test_Basic_Type);
296

297
   edd = eet_data_descriptor_stream_new(&eddc);
298
   fail_if(!edd);
299

300
   eet_build_basic_descriptor(edd);
301

302
   transfert = eet_data_descriptor_encode(edd, &etbt, &size);
303
   fail_if(!transfert || size <= 0);
304

305
   result = eet_data_descriptor_decode(edd, transfert, size);
306
   fail_if(!result);
307

308
   eet_test_basic_check(result, 0, EINA_FALSE);
309

310
   free(result->str);
311
   free(result);
312

313
   eet_data_descriptor_free(edd);
314
}
315
EFL_END_TEST
316

317
EFL_START_TEST(eet_test_data_type_encoding_decoding)
318
{
319
   Eet_Data_Descriptor *edd;
320
   Eet_Test_Ex_Type *result;
321
   void *transfert;
322
   Eet_Data_Descriptor_Class eddc;
323
   Eet_Test_Ex_Type etbt;
324
   int size;
325
   int test;
326

327
   eet_test_ex_set(&etbt, 0);
328
   etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1));
329
   etbt.hash = eina_hash_string_superfast_new(NULL);
330
   eina_hash_add(etbt.hash, EET_TEST_KEY1, eet_test_ex_set(NULL, 2));
331
   etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
332
   etbt.ihash = eina_hash_string_superfast_new(NULL);
333
   eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
334
   etbt.slist = eina_list_prepend(NULL, "test");
335
   etbt.shash = eina_hash_string_superfast_new(NULL);
336
   eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
337
   memset(&etbt.charray, 0, sizeof(etbt.charray));
338
   etbt.charray[0] = "test";
339
   etbt.charray[5] = "plouf";
340

341
   eet_test_setup_eddc(&eddc);
342
   eddc.name = "Eet_Test_Ex_Type";
343
   eddc.size = sizeof(Eet_Test_Ex_Type);
344

345
   edd = eet_data_descriptor_file_new(&eddc);
346
   fail_if(!edd);
347

348
   eet_build_ex_descriptor(edd, EINA_FALSE);
349

350
   transfert = eet_data_descriptor_encode(edd, &etbt, &size);
351
   fail_if(!transfert || size <= 0);
352

353
   result = eet_data_descriptor_decode(edd, transfert, size);
354
   fail_if(!result);
355

356
   fail_if(eet_test_ex_check(result, 0, EINA_FALSE) != 0);
357
   fail_if(eet_test_ex_check(eina_list_data_get(result->list), 1, EINA_FALSE) != 0);
358
   fail_if(eina_list_data_get(result->ilist) == NULL);
359
   fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
360
   fail_if(eina_list_data_get(result->slist) == NULL);
361
   fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
362
   fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
363
   fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
364
   fail_if(strcmp(result->charray[0], "test") != 0);
365
   fail_if(strcmp(result->charray[5], "plouf") != 0);
366

367
   test = 0;
368
   if (result->hash)
369
     eina_hash_foreach(result->hash, func, &test);
370

371
   fail_if(test != 0);
372
   if (result->ihash)
373
     eina_hash_foreach(result->ihash, func7, &test);
374

375
   fail_if(test != 0);
376
}
377
EFL_END_TEST
378

379
EFL_START_TEST(eet_test_data_type_dump_undump)
380
{
381
   Eet_Data_Descriptor *edd;
382
   Eet_Test_Ex_Type *result;
383
   Eet_Data_Descriptor_Class eddc;
384
   Eet_Test_Ex_Type etbt;
385
   char *transfert1;
386
   char *transfert2;
387
   char *string1;
388
   char *string2;
389
   int size1;
390
   int size2;
391
   int test;
392

393
   eet_test_ex_set(&etbt, 0);
394
   etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1));
395
   etbt.list = eina_list_prepend(etbt.list, eet_test_ex_set(NULL, 1));
396
   etbt.hash = eina_hash_string_superfast_new(NULL);
397
   eina_hash_add(etbt.hash, EET_TEST_KEY1, eet_test_ex_set(NULL, 2));
398
   etbt.hash = eina_hash_string_superfast_new(NULL);
399
   eina_hash_add(etbt.hash, EET_TEST_KEY2, eet_test_ex_set(NULL, 2));
400
   etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
401
   etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
402
   etbt.ihash = eina_hash_string_superfast_new(NULL);
403
   eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
404
   etbt.ihash = eina_hash_string_superfast_new(NULL);
405
   eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
406
   etbt.slist = eina_list_prepend(NULL, "test");
407
   etbt.shash = eina_hash_string_superfast_new(NULL);
408
   eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
409
   memset(&etbt.charray, 0, sizeof(etbt.charray));
410
   etbt.charray[0] = "test";
411

412
   eet_test_setup_eddc(&eddc);
413
   eddc.name = "Eet_Test_Ex_Type";
414
   eddc.size = sizeof(Eet_Test_Ex_Type);
415

416
   edd = eet_data_descriptor_file_new(&eddc);
417
   fail_if(!edd);
418

419
   eet_build_ex_descriptor(edd, EINA_FALSE);
420

421
   transfert1 = eet_data_descriptor_encode(edd, &etbt, &size1);
422
   fail_if(!transfert1 || size1 <= 0);
423

424
   string1 = NULL;
425
   eet_data_text_dump(transfert1, size1, append_string, &string1);
426
   fail_if(!string1);
427

428
   transfert2 = eet_data_text_undump(string1, string1 ? strlen(
429
                                       string1) : 0, &size2);
430
   fail_if(!transfert2 && size2 <= 0);
431

432
   string2 = NULL;
433
   eet_data_text_dump(transfert2, size2, append_string, &string2);
434
   fail_if(!string2);
435

436
   fail_if(strlen(string2) != strlen(string1));
437

438
   result = eet_data_descriptor_decode(edd, transfert2, size2);
439
   fail_if(!result);
440

441
   fail_if(eet_test_ex_check(result, 0, EINA_TRUE) != 0);
442
   fail_if(eet_test_ex_check(eina_list_data_get(result->list), 1, EINA_TRUE) != 0);
443
   fail_if(eina_list_data_get(result->ilist) == NULL);
444
   fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
445
   fail_if(eina_list_data_get(result->slist) == NULL);
446
   fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
447
   fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
448
   fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
449
   fail_if(strcmp(result->charray[0], "test") != 0);
450

451
   test = 0;
452
   _dump_call = EINA_TRUE;
453
   if (result->hash)
454
     eina_hash_foreach(result->hash, func, &test);
455
   _dump_call = EINA_FALSE;
456

457
   fail_if(test != 0);
458
   if (result->ihash)
459
     eina_hash_foreach(result->ihash, func7, &test);
460

461
   fail_if(test != 0);
462

463
}
464
EFL_END_TEST
465

466
EFL_START_TEST(eet_test_data_type_escape_dump_undump)
467
{
468
   void *blob;
469
   int blob_len;
470
   int ret = 0;
471
   const char *outputstr;
472
   Eina_Strbuf *strbuf;
473
   const char inputstr[] = ""
474
     "group \"\\\\My\\\"Group\\\\\" struct {\n"
475
     "    value \"\\\\My\\\\BackSlash\\\\\" string: \"\\\\\";\n"
476
     "    value \"\\\\My\\\\DoubleQuote\\\\\" string: \"\\\"\";\n"
477
     "    value \"\\\\My\\\\NewLine\\\\\" string: \"\\n\";\n"
478
     "}\n";
479

480
   blob = eet_data_text_undump(inputstr, strlen(inputstr), &blob_len);
481
   fail_if(!blob);
482

483
   strbuf = eina_strbuf_new();
484
   ret = eet_data_text_dump(blob, blob_len, append_strbuf_string, strbuf);
485
   ck_assert_int_eq(ret, 1);
486

487
   outputstr = eina_strbuf_string_get(strbuf);
488
   fail_if(!outputstr);
489
   ck_assert_str_eq(inputstr, outputstr);
490

491
   eina_strbuf_free(strbuf);
492
   free(blob);
493

494
}
495
EFL_END_TEST
496

497
EFL_START_TEST(eet_test_data_fp)
498
{
499
   Eet_Data_Descriptor_Class eddc;
500
   Eet_Data_Descriptor *edd_5FP;
501
   Eet_Data_Descriptor *edd_5DBL;
502
   Eet_5FP origin;
503
   Eet_5DBL *convert;
504
   Eet_5FP *build;
505
   void *blob;
506
   int size;
507

508
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_5FP);
509
   edd_5FP = eet_data_descriptor_stream_new(&eddc);
510

511
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp32", fp32, EET_T_F32P32);
512
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp16", fp16, EET_T_F16P16);
513
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp8", fp8, EET_T_F8P24);
514
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f1", f1, EET_T_F32P32);
515
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f0", f0, EET_T_F32P32);
516

517
   eet_eina_stream_data_descriptor_class_set(&eddc, sizeof (eddc), "Eet_5FP", sizeof (Eet_5DBL));
518
   edd_5DBL = eet_data_descriptor_stream_new(&eddc);
519

520
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp32", fp32, EET_T_DOUBLE);
521
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp16", fp16, EET_T_DOUBLE);
522
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp8", fp8, EET_T_FLOAT);
523
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f1", f1, EET_T_DOUBLE);
524
   EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f0", f0, EET_T_DOUBLE);
525

526
   origin.fp32 = eina_f32p32_double_from(1.125);
527
   origin.fp16 = eina_f16p16_int_from(2000);
528
   origin.fp8 = eina_f8p24_int_from(125);
529
   origin.f1 = eina_f32p32_int_from(1);
530
   origin.f0 = 0;
531

532
   blob = eet_data_descriptor_encode(edd_5FP, &origin, &size);
533
   fail_if(!blob || size <= 0);
534

535
   build = eet_data_descriptor_decode(edd_5FP, blob, size);
536
   fail_if(!build);
537

538
   convert = eet_data_descriptor_decode(edd_5DBL, blob, size);
539
   fail_if(!convert);
540

541
   fail_if(build->fp32 != eina_f32p32_double_from(1.125));
542
   fail_if(build->fp16 != eina_f16p16_int_from(2000));
543
   fail_if(build->fp8 != eina_f8p24_int_from(125));
544
   fail_if(build->f1 != eina_f32p32_int_from(1));
545
   fail_if(build->f0 != 0);
546

547
   fail_if(!EINA_DBL_EQ(convert->fp32, 1.125));
548
   fail_if(!EINA_DBL_EQ(convert->fp16, 2000));
549
   fail_if(!EINA_DBL_EQ(convert->fp8, 125));
550
   fail_if(!EINA_DBL_EQ(convert->f1, 1));
551
   fail_if(!EINA_DBL_EQ(convert->f0, 0));
552

553
}
554
EFL_END_TEST
555

556
EFL_START_TEST(eet_test_data_union)
557
{
558
   Eet_Union_Test *eut;
559
   Eet_List *l;
560
   Eet_Data_Descriptor_Class eddc;
561
   Eet_Data_Descriptor *edd;
562
   Eet_Data_Descriptor *unified;
563
   Eet_Data_Descriptor *m;
564
   void *blob;
565
   int size;
566
   int i;
567

568
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Union_Test);
569
   edd = eet_data_descriptor_stream_new(&eddc);
570

571
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Union_Test);
572
   m = eet_data_descriptor_stream_new(&eddc);
573

574
   eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
575
   eddc.func.type_get = _eet_union_type_get;
576
   eddc.func.type_set = _eet_union_type_set;
577
   unified = eet_data_descriptor_stream_new(&eddc);
578

579
   EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST1", _eet_st1_dd());
580
   EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST2", _eet_st2_dd());
581
   EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST3", _eet_st3_dd());
582

583
   EET_DATA_DESCRIPTOR_ADD_UNION(edd, Eet_Union_Test, "u", u, type, unified);
584

585
   EET_DATA_DESCRIPTOR_ADD_LIST(m, Eet_List, "list", list, edd);
586

587
   l = calloc(1, sizeof (Eet_List));
588

589
#define EUT_NEW(Type_Index)                 \
590
  eut = calloc(1, sizeof (Eet_Union_Test)); \
591
  eut->type = EET_ST ## Type_Index;         \
592
  _eet_st ## Type_Index ## _set(&(eut->u.st ## Type_Index), i);
593

594
   for (i = 0; i < 3; ++i)
595
     {
596
        EUT_NEW(1);
597
        l->list = eina_list_append(l->list, eut);
598

599
        EUT_NEW(2);
600
        l->list = eina_list_append(l->list, eut);
601

602
        EUT_NEW(3);
603
        l->list = eina_list_append(l->list, eut);
604
     }
605

606
   blob = eet_data_descriptor_encode(m, l, &size);
607
   fail_if(!blob || size <= 0);
608

609
   l = eet_data_descriptor_decode(m, blob, size);
610
   fail_if(!l);
611

612
   fail_if(eina_list_count(l->list) != 9);
613

614
#define EUT_CMP(Type_Index)                             \
615
  eut = eina_list_nth(l->list, i * 3 + Type_Index - 1); \
616
  fail_if(eut->type != EET_ST ## Type_Index);           \
617
  _eet_st ## Type_Index ## _cmp(&(eut->u.st ## Type_Index), i);
618

619
   for (i = 0; i < 3; ++i)
620
     {
621
        EUT_CMP(1);
622
        EUT_CMP(2);
623
        EUT_CMP(3);
624
     }
625
}
626
EFL_END_TEST
627

628
EFL_START_TEST(eet_test_data_variant)
629
{
630
   Eet_Variant_Test *evt;
631
   Eet_List *l;
632
   Eet_St1 *st1;
633
   Eet_St2 *st2;
634
   Eet_St3 *st3;
635
   Eet_Data_Descriptor_Class eddc;
636
   Eet_Data_Descriptor *edd;
637
   Eet_Data_Descriptor *unified;
638
   Eet_Data_Descriptor *m;
639
   void *blob;
640
   int size;
641
   int i;
642

643
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Variant_Test);
644
   edd = eet_data_descriptor_stream_new(&eddc);
645

646
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Variant_Test);
647
   m = eet_data_descriptor_stream_new(&eddc);
648

649
   eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
650
   eddc.func.type_get = _eet_variant_type_get;
651
   eddc.func.type_set = _eet_variant_type_set;
652
   unified = eet_data_descriptor_stream_new(&eddc);
653

654
   EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST1", _eet_st1_dd());
655
   EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST2", _eet_st2_dd());
656
   EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST3", _eet_st3_dd());
657

658
   EET_DATA_DESCRIPTOR_ADD_VARIANT(edd,
659
                                   Eet_Variant_Test,
660
                                   "data",
661
                                   data,
662
                                   t,
663
                                   unified);
664

665
   unified = eet_data_descriptor_stream_new(&eddc);
666
   eet_data_descriptor_element_add(unified, "ST1",
667
                                   EET_T_UNKNOW, EET_G_LIST,
668
                                   0, 0, NULL, _eet_st1_dd());
669
   eet_data_descriptor_element_add(unified, "ST2",
670
                                   EET_T_UNKNOW, EET_G_LIST,
671
                                   0, 0, NULL, _eet_st2_dd());
672

673
   EET_DATA_DESCRIPTOR_ADD_VARIANT(edd, Eet_Variant_Test,
674
                                   "data_list", data_list, t, unified);
675

676
   EET_DATA_DESCRIPTOR_ADD_LIST(m, Eet_List, "list", list, edd);
677

678
   l = calloc(1, sizeof (Eet_List));
679

680
#define EVT_NEW(Type_Index)                                    \
681
  evt = calloc(1, sizeof (Eet_Variant_Test));                  \
682
  evt->t.type = eet_mapping[Type_Index - 1].name;              \
683
  st ## Type_Index = calloc(1, sizeof (Eet_St ## Type_Index)); \
684
  _eet_st ## Type_Index ## _set(st ## Type_Index, i);          \
685
  evt->data = st ## Type_Index;
686

687
   for (i = 0; i < 3; ++i)
688
     {
689
        EVT_NEW(1);
690
        l->list = eina_list_append(l->list, evt);
691

692
        st1 = calloc(1, sizeof (Eet_St1));
693
        _eet_st1_set(st1, i);
694
        evt->data_list = eina_list_append(evt->data_list, st1);
695

696
        EVT_NEW(2);
697
        l->list = eina_list_append(l->list, evt);
698

699
        EVT_NEW(3);
700
        l->list = eina_list_append(l->list, evt);
701
     }
702

703
   blob = eet_data_descriptor_encode(m, l, &size);
704
   fail_if(!blob || size <= 0);
705

706
   l = eet_data_descriptor_decode(m, blob, size);
707
   fail_if(!l);
708

709
   fail_if(eina_list_count(l->list) != 9);
710

711
#define EVT_CMP(Type_Index)                                            \
712
  evt = eina_list_nth(l->list, i * 3 + Type_Index - 1);                \
713
  fail_if(strcmp(evt->t.type, eet_mapping[Type_Index - 1].name) != 0); \
714
  _eet_st ## Type_Index ## _cmp(evt->data, i);
715

716
   for (i = 0; i < 3; ++i)
717
     {
718
        EVT_CMP(1);
719

720
        fail_if(!evt->data_list);
721
        fail_if(eina_list_count(evt->data_list) != 1);
722

723
        st1 = eina_list_data_get(evt->data_list);
724
        _eet_st1_cmp(st1, i);
725

726
        EVT_CMP(2);
727
        EVT_CMP(3);
728
     }
729

730
} /* EFL_START_TEST */
731
EFL_END_TEST
732

733
EFL_START_TEST(eet_test_data_hash_value)
734
{
735
   Eet_Hash *h;
736
   Eina_Value *val;
737
   Eet_Data_Descriptor_Class eddc;
738
   Eet_Data_Descriptor *edd;
739
   void *blob;
740
   int size;
741
   int i;
742
   double d;
743
   char *s;
744

745
   EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Hash);
746
   edd = eet_data_descriptor_stream_new(&eddc);
747

748
   EET_DATA_DESCRIPTOR_ADD_HASH_VALUE(edd, Eet_Hash, "hash", hash);
749

750
   h = calloc(1, sizeof(Eet_Hash));
751
   h->hash = eina_hash_string_small_new((Eina_Free_Cb)eina_value_free);
752

753
   val = eina_value_new(EINA_VALUE_TYPE_INT);
754
   eina_value_set(val, EET_TEST_INT);
755
   eina_hash_direct_add(h->hash, "val/int", val);
756

757
   val = eina_value_new(EINA_VALUE_TYPE_DOUBLE);
758
   eina_value_set(val, EET_TEST_DOUBLE);
759
   eina_hash_direct_add(h->hash, "val/double", val);
760

761
   val = eina_value_new(EINA_VALUE_TYPE_STRING);
762
   eina_value_set(val, EET_TEST_STRING);
763
   eina_hash_direct_add(h->hash, "val/string", val);
764

765
   blob = eet_data_descriptor_encode(edd, h, &size);
766
   fail_if((!blob) || (size <= 0));
767

768
   h = eet_data_descriptor_decode(edd, blob, size);
769
   fail_if(!h);
770

771
   val = (Eina_Value *)eina_hash_find(h->hash, "val/int");
772
   eina_value_get(val, &i);
773
   fail_if((!val) || (i != EET_TEST_INT));
774

775
   val = (Eina_Value *)eina_hash_find(h->hash, "val/double");
776
   eina_value_get(val, &d);
777
   fail_if((!val) || (!EINA_DBL_EQ(d, EET_TEST_DOUBLE)));
778

779
   val = (Eina_Value *)eina_hash_find(h->hash, "val/string");
780
   eina_value_get(val, &s);
781
   fail_if((!val) || strcmp(s, EET_TEST_STRING));
782
} /* EFL_START_TEST */
783
EFL_END_TEST
784

785
void eet_test_data(TCase *tc)
786
{
787
   tcase_add_test(tc, eet_test_data_basic_type_encoding_decoding);
788
   tcase_add_test(tc, eet_test_data_type_encoding_decoding);
789
   tcase_add_test(tc, eet_test_data_type_dump_undump);
790
   tcase_add_test(tc, eet_test_data_type_escape_dump_undump);
791
   tcase_add_test(tc, eet_test_data_fp);
792
   tcase_add_test(tc, eet_test_data_union);
793
   tcase_add_test(tc, eet_test_data_variant);
794
   tcase_add_test(tc, eet_test_data_hash_value);
795
}
796