aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/eet/src/tests/eet_suite.c
diff options
context:
space:
mode:
Diffstat (limited to 'libraries/eet/src/tests/eet_suite.c')
-rw-r--r--libraries/eet/src/tests/eet_suite.c2777
1 files changed, 2777 insertions, 0 deletions
diff --git a/libraries/eet/src/tests/eet_suite.c b/libraries/eet/src/tests/eet_suite.c
new file mode 100644
index 0000000..5230c86
--- /dev/null
+++ b/libraries/eet/src/tests/eet_suite.c
@@ -0,0 +1,2777 @@
1#ifdef HAVE_CONFIG_H
2# include <config.h>
3#endif /* ifdef HAVE_CONFIG_H */
4
5#include <sys/types.h>
6#include <sys/stat.h>
7#include <stdlib.h>
8#include <string.h>
9#include <strings.h>
10#include <stdio.h>
11#include <fcntl.h>
12#include <unistd.h>
13
14#include <Eina.h>
15
16#ifdef EINA_HAVE_THREADS
17#if ((!defined(_WIN32_WCE)) && (!defined(_WIN32)))
18# include <pthread.h>
19# define _EET_INCLUDED_PTHREAD
20#endif
21#endif /* ifdef EINA_HAVE_THREADS */
22
23#include <check.h>
24
25#include "eet_suite.h"
26
27START_TEST(eet_test_init)
28{
29 int ret;
30
31 ret = eet_init();
32 fail_if(ret != 1);
33
34 ret = eet_shutdown();
35 fail_if(ret != 0);
36}
37END_TEST
38
39typedef struct _Eet_Test_Basic_Type Eet_Test_Basic_Type;
40struct _Eet_Test_Basic_Type
41{
42 char c;
43 short s;
44 int i;
45 long long l;
46 char *str;
47 char *istr;
48 float f1;
49 float f2;
50 double d;
51 unsigned char uc;
52 unsigned short us;
53 unsigned int ui;
54 unsigned long long ul;
55 Eet_Test_Basic_Type *empty;
56 Eet_Test_Basic_Type *with;
57};
58
59#define EET_TEST_CHAR 0x42
60#define EET_TEST_SHORT 0x4224
61#define EET_TEST_INT 0x42211224
62#define EET_TEST_LONG_LONG 0x84CB42211224BC48
63#define EET_TEST_STRING "my little test with escape \\\""
64#define EET_TEST_KEY1 "key1"
65#define EET_TEST_KEY2 "key2"
66#define EET_TEST_FLOAT 123.45689
67#define EET_TEST_FLOAT2 1.0
68#define EET_TEST_FLOAT3 0.25
69#define EET_TEST_FLOAT4 0.0001234
70#define EET_TEST_DOUBLE 123456789.9876543210
71#define EET_TEST_DOUBLE2 1.0
72#define EET_TEST_DOUBLE3 0.25
73#define EET_TEST_FILE_KEY1 "keys/data/1"
74#define EET_TEST_FILE_KEY2 "keys/data/2"
75#define EET_TEST_FILE_IMAGE "keys/images/"
76
77typedef struct _Eet_Test_Image Eet_Test_Image;
78struct _Eet_Test_Image
79{
80 unsigned int w;
81 unsigned int h;
82 int alpha;
83 unsigned int color[64];
84};
85
86static const Eet_Test_Image test_noalpha = {
87 8, 8, 0,
88 {
89 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00,
90 0x000000AA, 0x00110000,
91 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA,
92 0x00110000, 0x00AA0000,
93 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000,
94 0x00AA0000, 0x0000AA00,
95 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000,
96 0x0000AA00, 0x000000AA,
97 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00,
98 0x000000AA, 0x00110000,
99 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA,
100 0x00110000, 0x00AA0000,
101 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000,
102 0x00AA0000, 0x0000AA00,
103 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000,
104 0x0000AA00, 0x000000AA
105 }
106};
107
108static const Eet_Test_Image test_alpha = {
109 8, 8, 1,
110 {
111 0x0FAA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00,
112 0x000000AA, 0x0F110000,
113 0x0000AA00, 0x0F0000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA,
114 0x0F110000, 0x00AA0000,
115 0x000000AA, 0x00110000, 0x0FAA0000, 0x0000AA00, 0x000000AA, 0x0F110000,
116 0x00AA0000, 0x0000AA00,
117 0x00110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA, 0x0F110000, 0x00AA0000,
118 0x0000AA00, 0x000000AA,
119 0x00AA0000, 0x0000AA00, 0x000000AA, 0x0F110000, 0x0FAA0000, 0x0000AA00,
120 0x000000AA, 0x00110000,
121 0x0000AA00, 0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA,
122 0x00110000, 0x00AA0000,
123 0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000,
124 0x0FAA0000, 0x0000AA00,
125 0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000,
126 0x0000AA00, 0x0F0000AA
127 }
128};
129
130static void
131_eet_test_basic_set(Eet_Test_Basic_Type *res,
132 int i)
133{
134 res->c = EET_TEST_CHAR;
135 res->s = EET_TEST_SHORT;
136 res->i = EET_TEST_INT + i;
137 res->l = EET_TEST_LONG_LONG;
138 res->str = EET_TEST_STRING;
139 res->istr = EET_TEST_STRING;
140 res->f1 = -EET_TEST_FLOAT;
141 res->d = -EET_TEST_DOUBLE;
142 res->f2 = EET_TEST_FLOAT4;
143 res->uc = EET_TEST_CHAR;
144 res->us = EET_TEST_SHORT;
145 res->ui = EET_TEST_INT;
146 res->ul = EET_TEST_LONG_LONG;
147 res->empty = NULL;
148 res->with = NULL;
149
150 if (i == 0)
151 {
152 Eet_Test_Basic_Type *tmp;
153
154 tmp = malloc(sizeof (Eet_Test_Basic_Type));
155 fail_if(!tmp);
156
157 res->with = tmp;
158 tmp->c = EET_TEST_CHAR;
159 tmp->s = EET_TEST_SHORT;
160 tmp->i = EET_TEST_INT + i + 1;
161 tmp->l = EET_TEST_LONG_LONG;
162 tmp->str = EET_TEST_STRING;
163 tmp->istr = EET_TEST_STRING;
164 tmp->f1 = -EET_TEST_FLOAT;
165 tmp->d = -EET_TEST_DOUBLE;
166 tmp->f2 = EET_TEST_FLOAT4;
167 tmp->uc = EET_TEST_CHAR;
168 tmp->us = EET_TEST_SHORT;
169 tmp->ui = EET_TEST_INT;
170 tmp->ul = EET_TEST_LONG_LONG;
171 tmp->empty = NULL;
172 tmp->with = NULL;
173 }
174} /* _eet_test_basic_set */
175
176static void
177_eet_test_basic_check(Eet_Test_Basic_Type *result,
178 int i)
179{
180 float tmp;
181
182 fail_if(result->c != EET_TEST_CHAR);
183 fail_if(result->s != EET_TEST_SHORT);
184 fail_if(result->i != EET_TEST_INT + i);
185 fail_if(result->l != (long long)EET_TEST_LONG_LONG);
186 fail_if(strcmp(result->str, EET_TEST_STRING) != 0);
187 fail_if(strcmp(result->istr, EET_TEST_STRING) != 0);
188 fail_if(result->uc != EET_TEST_CHAR);
189 fail_if(result->us != EET_TEST_SHORT);
190 fail_if(result->ui != EET_TEST_INT);
191 fail_if(result->ul != EET_TEST_LONG_LONG);
192
193 tmp = (result->f1 + EET_TEST_FLOAT);
194 if (tmp < 0)
195 tmp = -tmp;
196
197 fail_if(tmp > 0.005);
198
199 tmp = (result->f2 - EET_TEST_FLOAT4);
200 if (tmp < 0)
201 tmp = -tmp;
202
203 fail_if(tmp > 0.005);
204
205 tmp = (result->d + EET_TEST_DOUBLE);
206 if (tmp < 0)
207 tmp = -tmp;
208
209 fail_if(tmp > 0.00005);
210
211 fail_if(result->empty != NULL);
212 if (i == 0)
213 {
214 Eet_Test_Basic_Type *tmp;
215
216 tmp = result->with;
217 fail_if(tmp == NULL);
218
219 fail_if(tmp->c != EET_TEST_CHAR);
220 fail_if(tmp->s != EET_TEST_SHORT);
221 fail_if(tmp->i != EET_TEST_INT + i + 1);
222 fail_if(tmp->l != (long long)EET_TEST_LONG_LONG);
223 fail_if(strcmp(tmp->str, EET_TEST_STRING) != 0);
224 fail_if(strcmp(tmp->istr, EET_TEST_STRING) != 0);
225 fail_if(tmp->uc != EET_TEST_CHAR);
226 fail_if(tmp->us != EET_TEST_SHORT);
227 fail_if(tmp->ui != EET_TEST_INT);
228 fail_if(tmp->ul != EET_TEST_LONG_LONG);
229 }
230 else
231 fail_if(result->with != NULL);
232} /* _eet_test_basic_check */
233
234static void
235_eet_build_basic_descriptor(Eet_Data_Descriptor *edd)
236{
237 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
238 Eet_Test_Basic_Type,
239 "c",
240 c,
241 EET_T_CHAR);
242 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
243 Eet_Test_Basic_Type,
244 "s",
245 s,
246 EET_T_SHORT);
247 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
248 Eet_Test_Basic_Type,
249 "i",
250 i,
251 EET_T_INT);
252 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
253 Eet_Test_Basic_Type,
254 "l",
255 l,
256 EET_T_LONG_LONG);
257 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
258 Eet_Test_Basic_Type,
259 "str",
260 str,
261 EET_T_STRING);
262 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
263 Eet_Test_Basic_Type,
264 "istr",
265 istr,
266 EET_T_INLINED_STRING);
267 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
268 Eet_Test_Basic_Type,
269 "f1",
270 f1,
271 EET_T_FLOAT);
272 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
273 Eet_Test_Basic_Type,
274 "f2",
275 f2,
276 EET_T_FLOAT);
277 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
278 Eet_Test_Basic_Type,
279 "d",
280 d,
281 EET_T_DOUBLE);
282 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
283 Eet_Test_Basic_Type,
284 "uc",
285 uc,
286 EET_T_UCHAR);
287 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
288 Eet_Test_Basic_Type,
289 "us",
290 us,
291 EET_T_USHORT);
292 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
293 Eet_Test_Basic_Type,
294 "ui",
295 ui,
296 EET_T_UINT);
297 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
298 Eet_Test_Basic_Type,
299 "ul",
300 ul,
301 EET_T_ULONG_LONG);
302
303 EET_DATA_DESCRIPTOR_ADD_SUB(edd, Eet_Test_Basic_Type, "empty", empty, edd);
304 EET_DATA_DESCRIPTOR_ADD_SUB(edd, Eet_Test_Basic_Type, "with", with, edd);
305} /* _eet_build_basic_descriptor */
306
307START_TEST(eet_test_basic_data_type_encoding_decoding)
308{
309 Eet_Data_Descriptor *edd;
310 Eet_Test_Basic_Type *result;
311 Eet_Data_Descriptor_Class eddc;
312 Eet_Test_Basic_Type etbt;
313 void *transfert;
314 int size;
315
316 eet_init();
317
318 _eet_test_basic_set(&etbt, 0);
319
320 eet_test_setup_eddc(&eddc);
321 eddc.name = "Eet_Test_Basic_Type";
322 eddc.size = sizeof(Eet_Test_Basic_Type);
323
324 edd = eet_data_descriptor_stream_new(&eddc);
325 fail_if(!edd);
326
327 _eet_build_basic_descriptor(edd);
328
329 transfert = eet_data_descriptor_encode(edd, &etbt, &size);
330 fail_if(!transfert || size <= 0);
331
332 result = eet_data_descriptor_decode(edd, transfert, size);
333 fail_if(!result);
334
335 _eet_test_basic_check(result, 0);
336
337 free(result->str);
338 free(result);
339
340 eet_data_descriptor_free(edd);
341
342 eet_shutdown();
343}
344END_TEST
345
346typedef struct _Eet_Test_Ex_Type Eet_Test_Ex_Type;
347struct _Eet_Test_Ex_Type
348{
349 char c;
350 short s;
351 int i;
352 unsigned long long l;
353 char *str;
354 char *istr;
355 float f1;
356 float f2;
357 float f3;
358 float f4;
359 double d1;
360 double d2;
361 double d3;
362 double d4;
363 Eina_List *list;
364 Eina_Hash *hash;
365 Eina_List *ilist;
366 Eina_List *slist;
367 Eina_Hash *ihash;
368 Eina_Hash *shash;
369 Eet_Test_Basic_Type sarray1[10];
370 unsigned int sarray2[5];
371 unsigned int varray1_count;
372 unsigned int *varray1;
373 unsigned int varray2_count;
374 Eet_Test_Basic_Type *varray2;
375 unsigned char uc;
376 unsigned short us;
377 unsigned int ui;
378 unsigned long long ul;
379 char *charray[10];
380};
381
382static int i42 = 42;
383static int i7 = 7;
384
385static void
386_eet_build_ex_descriptor(Eet_Data_Descriptor *edd)
387{
388 Eet_Data_Descriptor_Class eddc;
389 Eet_Test_Ex_Type etbt;
390 Eet_Data_Descriptor *eddb;
391
392 eet_test_setup_eddc(&eddc);
393 eddc.name = "Eet_Test_Basic_Type";
394 eddc.size = sizeof(Eet_Test_Basic_Type);
395 eddb = eet_data_descriptor_file_new(&eddc);
396 fail_if(!eddb);
397
398 _eet_build_basic_descriptor(eddb);
399
400 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
401 Eet_Test_Ex_Type,
402 "c",
403 c,
404 EET_T_CHAR);
405 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
406 Eet_Test_Ex_Type,
407 "s",
408 s,
409 EET_T_SHORT);
410 EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "i", i, EET_T_INT);
411 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
412 Eet_Test_Ex_Type,
413 "l",
414 l,
415 EET_T_LONG_LONG);
416 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
417 Eet_Test_Ex_Type,
418 "str",
419 str,
420 EET_T_STRING);
421 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
422 Eet_Test_Ex_Type,
423 "istr",
424 istr,
425 EET_T_INLINED_STRING);
426 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
427 Eet_Test_Ex_Type,
428 "f1",
429 f1,
430 EET_T_FLOAT);
431 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
432 Eet_Test_Ex_Type,
433 "f2",
434 f2,
435 EET_T_FLOAT);
436 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
437 Eet_Test_Ex_Type,
438 "f3",
439 f3,
440 EET_T_FLOAT);
441 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
442 Eet_Test_Ex_Type,
443 "f4",
444 f4,
445 EET_T_FLOAT);
446 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
447 Eet_Test_Ex_Type,
448 "d1",
449 d1,
450 EET_T_DOUBLE);
451 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
452 Eet_Test_Ex_Type,
453 "d2",
454 d2,
455 EET_T_DOUBLE);
456 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
457 Eet_Test_Ex_Type,
458 "d3",
459 d3,
460 EET_T_DOUBLE);
461 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
462 Eet_Test_Ex_Type,
463 "d4",
464 d4,
465 EET_T_DOUBLE);
466 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
467 Eet_Test_Ex_Type,
468 "uc",
469 uc,
470 EET_T_UCHAR);
471 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
472 Eet_Test_Ex_Type,
473 "us",
474 us,
475 EET_T_USHORT);
476 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
477 Eet_Test_Ex_Type,
478 "ui",
479 ui,
480 EET_T_UINT);
481 EET_DATA_DESCRIPTOR_ADD_BASIC(edd,
482 Eet_Test_Ex_Type,
483 "ul",
484 ul,
485 EET_T_ULONG_LONG);
486 EET_DATA_DESCRIPTOR_ADD_ARRAY(edd,
487 Eet_Test_Ex_Type,
488 "sarray1",
489 sarray1,
490 eddb);
491 EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY(edd,
492 Eet_Test_Ex_Type,
493 "varray2",
494 varray2,
495 eddb);
496 eet_data_descriptor_element_add(edd,
497 "varray1",
498 EET_T_INT,
499 EET_G_VAR_ARRAY,
500 (char *)(&(etbt.varray1)) - (char *)(&(etbt)),
501 (char *)(&(etbt.varray1_count)) -
502 (char *)(&(etbt)),
503 /* 0, */ NULL,
504 NULL);
505 eet_data_descriptor_element_add(edd, "sarray2", EET_T_INT, EET_G_ARRAY,
506 (char *)(&(etbt.sarray2)) - (char *)(&(etbt)),
507 /* 0, */ sizeof(etbt.sarray2) /
508 sizeof(etbt.sarray2[0]), NULL, NULL);
509 eet_data_descriptor_element_add(edd, "charray", EET_T_STRING, EET_G_ARRAY,
510 (char *)(&(etbt.charray)) - (char *)(&(etbt)),
511 /* 0, */ sizeof(etbt.charray) /
512 sizeof(etbt.charray[0]), NULL, NULL);
513 EET_DATA_DESCRIPTOR_ADD_LIST(edd, Eet_Test_Ex_Type, "list", list, edd);
514 EET_DATA_DESCRIPTOR_ADD_HASH(edd, Eet_Test_Ex_Type, "hash", hash, edd);
515 eet_data_descriptor_element_add(edd, "ilist", EET_T_INT, EET_G_LIST,
516 (char *)(&(etbt.ilist)) - (char *)(&(etbt)),
517 0, /* 0, */ NULL, NULL);
518 eet_data_descriptor_element_add(edd, "ihash", EET_T_INT, EET_G_HASH,
519 (char *)(&(etbt.ihash)) - (char *)(&(etbt)),
520 0, /* 0, */ NULL, NULL);
521 eet_data_descriptor_element_add(edd, "slist", EET_T_STRING, EET_G_LIST,
522 (char *)(&(etbt.slist)) - (char *)(&(etbt)),
523 0, /* 0, */ NULL, NULL);
524 eet_data_descriptor_element_add(edd, "shash", EET_T_STRING, EET_G_HASH,
525 (char *)(&(etbt.shash)) - (char *)(&(etbt)),
526 0, /* 0, */ NULL, NULL);
527} /* _eet_build_ex_descriptor */
528
529static Eet_Test_Ex_Type *
530_eet_test_ex_set(Eet_Test_Ex_Type *res,
531 int offset)
532{
533 unsigned int i;
534
535 if (!res)
536 res = malloc(sizeof(Eet_Test_Ex_Type));
537
538 if (!res)
539 return NULL;
540
541 res->c = EET_TEST_CHAR + offset;
542 res->s = EET_TEST_SHORT + offset;
543 res->i = EET_TEST_INT + offset;
544 res->l = EET_TEST_LONG_LONG + offset;
545 res->str = EET_TEST_STRING;
546 res->istr = EET_TEST_STRING;
547 res->f1 = EET_TEST_FLOAT + offset;
548 res->f2 = -(EET_TEST_FLOAT2 + offset);
549 res->f3 = EET_TEST_FLOAT3 + offset;
550 res->f4 = EET_TEST_FLOAT2 + offset;
551 res->d1 = EET_TEST_DOUBLE + offset;
552 res->d2 = -(EET_TEST_DOUBLE2 + offset);
553 res->d3 = EET_TEST_DOUBLE3 + offset;
554 res->d4 = EET_TEST_DOUBLE2 + offset;
555 res->list = NULL;
556 res->hash = NULL;
557 res->ilist = NULL;
558 res->ihash = NULL;
559 res->slist = NULL;
560 res->shash = NULL;
561 for (i = 0; i < sizeof(res->charray) / sizeof(res->charray[0]); ++i)
562 res->charray[i] = NULL;
563
564 res->varray2 = malloc(sizeof (Eet_Test_Basic_Type) * 10);
565 res->varray1 = malloc(sizeof (int) * 5);
566 fail_if(!res->varray1 || !res->varray2);
567 for (i = 0; i < 10; ++i)
568 {
569 _eet_test_basic_set(res->sarray1 + i, i);
570 _eet_test_basic_set(res->varray2 + i, i);
571 }
572 res->varray2_count = 10;
573 for (i = 0; i < 5; ++i)
574 {
575 res->sarray2[i] = i * 42 + 1;
576 res->varray1[i] = i * 42 + 1;
577 }
578 res->varray1_count = 5;
579
580 res->uc = EET_TEST_CHAR + offset;
581 res->us = EET_TEST_SHORT + offset;
582 res->ui = EET_TEST_INT + offset;
583 res->ul = EET_TEST_LONG_LONG + offset;
584
585 return res;
586} /* _eet_test_ex_set */
587
588static int
589_eet_test_ex_check(Eet_Test_Ex_Type *stuff,
590 int offset)
591{
592 double tmp;
593 unsigned int i;
594
595 if (!stuff)
596 return 1;
597
598 if (stuff->c != EET_TEST_CHAR + offset)
599 return 1;
600
601 if (stuff->s != EET_TEST_SHORT + offset)
602 return 1;
603
604 if (stuff->i != EET_TEST_INT + offset)
605 return 1;
606
607 if (stuff->l != EET_TEST_LONG_LONG + offset)
608 return 1;
609
610 if (strcmp(stuff->str, EET_TEST_STRING) != 0)
611 return 1;
612
613 if (strcmp(stuff->istr, EET_TEST_STRING) != 0)
614 return 1;
615
616 tmp = stuff->f1 - (EET_TEST_FLOAT + offset);
617 if (tmp < 0)
618 tmp = -tmp;
619
620 if (tmp > 0.005)
621 return 1;
622
623 tmp = stuff->d1 - (EET_TEST_DOUBLE + offset);
624 if (tmp < 0)
625 tmp = -tmp;
626
627 if (tmp > 0.00005)
628 return 1;
629
630 if (stuff->f2 != -(EET_TEST_FLOAT2 + offset))
631 return 1;
632
633 if (stuff->d2 != -(EET_TEST_DOUBLE2 + offset))
634 return 1;
635
636 if (stuff->f3 != EET_TEST_FLOAT3 + offset)
637 return 1;
638
639 if (stuff->d3 != EET_TEST_DOUBLE3 + offset)
640 return 1;
641
642 if (stuff->f4 != EET_TEST_FLOAT2 + offset)
643 return 1;
644
645 if (stuff->d4 != EET_TEST_DOUBLE2 + offset)
646 return 1;
647
648 if (stuff->uc != EET_TEST_CHAR + offset)
649 return 1;
650
651 if (stuff->us != EET_TEST_SHORT + offset)
652 return 1;
653
654 if (stuff->ui != (unsigned int)EET_TEST_INT + offset)
655 return 1;
656
657 if (stuff->ul != EET_TEST_LONG_LONG + offset)
658 return 1;
659
660 if (stuff->varray1_count != 5)
661 return 1;
662
663 if (stuff->varray2_count != 10)
664 return 1;
665
666 for (i = 0; i < 5; ++i)
667 if (stuff->sarray2[i] != i * 42 + 1 && stuff->varray1[i] != i * 42 + 1)
668 return 1;
669
670 for (i = 0; i < 10; ++i)
671 {
672 _eet_test_basic_check(stuff->sarray1 + i, i);
673 _eet_test_basic_check(stuff->varray2 + i, i);
674 }
675
676 return 0;
677} /* _eet_test_ex_check */
678
679static Eina_Bool
680func(__UNUSED__ const Eina_Hash *hash,
681 const void *key,
682 void *data,
683 void *fdata)
684{
685 int *res = fdata;
686
687 if (strcmp(key, EET_TEST_KEY1) != 0
688 && strcmp(key, EET_TEST_KEY2) != 0)
689 *res = 1;
690
691 if (_eet_test_ex_check(data, 2))
692 *res = 1;
693
694 return EINA_TRUE;
695} /* func */
696
697static Eina_Bool
698func7(__UNUSED__ const Eina_Hash *hash,
699 __UNUSED__ const void *key,
700 void *data,
701 void *fdata)
702{
703 int *res = fdata;
704 int *val;
705
706 val = data;
707 if (!val)
708 *res = 1;
709
710 if (*val != 7)
711 *res = 1;
712
713 return EINA_TRUE;
714} /* func7 */
715
716START_TEST(eet_test_data_type_encoding_decoding)
717{
718 Eet_Data_Descriptor *edd;
719 Eet_Test_Ex_Type *result;
720 void *transfert;
721 Eet_Data_Descriptor_Class eddc;
722 Eet_Test_Ex_Type etbt;
723 int size;
724 int test;
725
726 eet_init();
727
728 _eet_test_ex_set(&etbt, 0);
729 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
730 etbt.hash = eina_hash_string_superfast_new(NULL);
731 eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
732 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
733 etbt.ihash = eina_hash_string_superfast_new(NULL);
734 eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
735 etbt.slist = eina_list_prepend(NULL, "test");
736 etbt.shash = eina_hash_string_superfast_new(NULL);
737 eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
738 memset(&etbt.charray, 0, sizeof(etbt.charray));
739 etbt.charray[0] = "test";
740 etbt.charray[5] = "plouf";
741
742 eet_test_setup_eddc(&eddc);
743 eddc.name = "Eet_Test_Ex_Type";
744 eddc.size = sizeof(Eet_Test_Ex_Type);
745
746 edd = eet_data_descriptor_file_new(&eddc);
747 fail_if(!edd);
748
749 _eet_build_ex_descriptor(edd);
750
751 transfert = eet_data_descriptor_encode(edd, &etbt, &size);
752 fail_if(!transfert || size <= 0);
753
754 result = eet_data_descriptor_decode(edd, transfert, size);
755 fail_if(!result);
756
757 fail_if(_eet_test_ex_check(result, 0) != 0);
758 fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
759 fail_if(eina_list_data_get(result->ilist) == NULL);
760 fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
761 fail_if(eina_list_data_get(result->slist) == NULL);
762 fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
763 fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
764 fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
765 fail_if(strcmp(result->charray[0], "test") != 0);
766 fail_if(strcmp(result->charray[5], "plouf") != 0);
767
768 test = 0;
769 if (result->hash)
770 eina_hash_foreach(result->hash, func, &test);
771
772 fail_if(test != 0);
773 if (result->ihash)
774 eina_hash_foreach(result->ihash, func7, &test);
775
776 fail_if(test != 0);
777
778 eet_shutdown();
779}
780END_TEST
781
782static void
783append_string(void *data,
784 const char *str)
785{
786 char **string = data;
787 int length;
788
789 if (!data)
790 return;
791
792 length = *string ? strlen(*string) : 0;
793 *string = realloc(*string, strlen(str) + length + 1);
794
795 memcpy((*string) + length, str, strlen(str) + 1);
796} /* append_string */
797
798START_TEST(eet_test_data_type_dump_undump)
799{
800 Eet_Data_Descriptor *edd;
801 Eet_Test_Ex_Type *result;
802 Eet_Data_Descriptor_Class eddc;
803 Eet_Test_Ex_Type etbt;
804 char *transfert1;
805 char *transfert2;
806 char *string1;
807 char *string2;
808 int size1;
809 int size2;
810 int test;
811
812 eet_init();
813
814 _eet_test_ex_set(&etbt, 0);
815 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
816 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
817 etbt.hash = eina_hash_string_superfast_new(NULL);
818 eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
819 etbt.hash = eina_hash_string_superfast_new(NULL);
820 eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
821 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
822 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
823 etbt.ihash = eina_hash_string_superfast_new(NULL);
824 eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
825 etbt.ihash = eina_hash_string_superfast_new(NULL);
826 eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
827 etbt.slist = eina_list_prepend(NULL, "test");
828 etbt.shash = eina_hash_string_superfast_new(NULL);
829 eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
830 memset(&etbt.charray, 0, sizeof(etbt.charray));
831 etbt.charray[0] = "test";
832
833 eet_test_setup_eddc(&eddc);
834 eddc.name = "Eet_Test_Ex_Type";
835 eddc.size = sizeof(Eet_Test_Ex_Type);
836
837 edd = eet_data_descriptor_file_new(&eddc);
838 fail_if(!edd);
839
840 _eet_build_ex_descriptor(edd);
841
842 transfert1 = eet_data_descriptor_encode(edd, &etbt, &size1);
843 fail_if(!transfert1 || size1 <= 0);
844
845 string1 = NULL;
846 eet_data_text_dump(transfert1, size1, append_string, &string1);
847 fail_if(!string1);
848
849 transfert2 = eet_data_text_undump(string1, string1 ? strlen(
850 string1) : 0, &size2);
851 fail_if(!transfert2 && size2 <= 0);
852
853 string2 = NULL;
854 eet_data_text_dump(transfert2, size2, append_string, &string2);
855 fail_if(!string2);
856
857 fail_if(strlen(string2) != strlen(string1));
858
859 result = eet_data_descriptor_decode(edd, transfert2, size2);
860 fail_if(!result);
861
862 fail_if(_eet_test_ex_check(result, 0) != 0);
863 fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
864 fail_if(eina_list_data_get(result->ilist) == NULL);
865 fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
866 fail_if(eina_list_data_get(result->slist) == NULL);
867 fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
868 fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
869 fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
870 fail_if(strcmp(result->charray[0], "test") != 0);
871
872 test = 0;
873 if (result->hash)
874 eina_hash_foreach(result->hash, func, &test);
875
876 fail_if(test != 0);
877 if (result->ihash)
878 eina_hash_foreach(result->ihash, func7, &test);
879
880 fail_if(test != 0);
881
882 eet_shutdown();
883}
884END_TEST
885START_TEST(eet_file_simple_write)
886{
887 const char *buffer = "Here is a string of data to save !";
888 Eet_File *ef;
889 char *test;
890 char *file = strdup("/tmp/eet_suite_testXXXXXX");
891 int size;
892
893 eet_init();
894
895 fail_if(!(file = tmpnam(file)));
896
897 fail_if(eet_mode_get(NULL) != EET_FILE_MODE_INVALID);
898
899 ef = eet_open(file, EET_FILE_MODE_WRITE);
900 fail_if(!ef);
901
902 fail_if(!eet_write(ef, "keys/tests", buffer, strlen(buffer) + 1, 1));
903 fail_if(!eet_alias(ef, "keys/alias", "keys/tests", 0));
904 fail_if(!eet_alias(ef, "keys/alias2", "keys/alias", 1));
905
906 fail_if(eet_mode_get(ef) != EET_FILE_MODE_WRITE);
907
908 fail_if(eet_list(ef, "*", &size) != NULL);
909 fail_if(eet_num_entries(ef) != -1);
910
911 eet_close(ef);
912
913 /* Test read of simple file */
914 ef = eet_open(file, EET_FILE_MODE_READ);
915 fail_if(!ef);
916
917 test = eet_read(ef, "keys/tests", &size);
918 fail_if(!test);
919 fail_if(size != (int)strlen(buffer) + 1);
920
921 fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
922
923 test = eet_read(ef, "keys/alias2", &size);
924 fail_if(!test);
925 fail_if(size != (int)strlen(buffer) + 1);
926
927 fail_if(eet_read_direct(ef, "key/alias2", &size));
928
929 fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ);
930 fail_if(eet_num_entries(ef) != 3);
931
932 eet_close(ef);
933
934 /* Test eet cache system */
935 ef = eet_open(file, EET_FILE_MODE_READ);
936 fail_if(!ef);
937
938 test = eet_read(ef, "keys/tests", &size);
939 fail_if(!test);
940 fail_if(size != (int)strlen(buffer) + 1);
941
942 fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
943
944 eet_close(ef);
945
946 fail_if(unlink(file) != 0);
947
948 eet_shutdown();
949} /* START_TEST */
950
951END_TEST
952START_TEST(eet_file_data_test)
953{
954 Eet_Data_Descriptor *edd;
955 Eet_Test_Ex_Type *result;
956 Eet_Dictionary *ed;
957 Eet_File *ef;
958 char **list;
959 char *file = strdup("/tmp/eet_suite_testXXXXXX");
960 Eet_Data_Descriptor_Class eddc;
961 Eet_Test_Ex_Type etbt;
962 int size;
963 int test;
964
965 eet_init();
966
967 _eet_test_ex_set(&etbt, 0);
968 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
969 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
970 etbt.hash = eina_hash_string_superfast_new(NULL);
971 eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
972 etbt.hash = eina_hash_string_superfast_new(NULL);
973 eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
974 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
975 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
976 etbt.ihash = eina_hash_string_superfast_new(NULL);
977 eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
978 etbt.ihash = eina_hash_string_superfast_new(NULL);
979 eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
980 etbt.slist = eina_list_prepend(NULL, "test");
981 etbt.shash = eina_hash_string_superfast_new(NULL);
982 eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
983 memset(&etbt.charray, 0, sizeof(etbt.charray));
984 etbt.charray[0] = "test";
985
986 eet_test_setup_eddc(&eddc);
987 eddc.name = "Eet_Test_Ex_Type";
988 eddc.size = sizeof(Eet_Test_Ex_Type);
989
990 edd = eet_data_descriptor_file_new(&eddc);
991 fail_if(!edd);
992
993 _eet_build_ex_descriptor(edd);
994
995 fail_if(!(file = tmpnam(file)));
996
997 /* Insert an error in etbt. */
998 etbt.i = 0;
999
1000 /* Save the encoded data in a file. */
1001 ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
1002 fail_if(!ef);
1003
1004 fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
1005
1006 result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
1007 fail_if(!result);
1008
1009 fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ_WRITE);
1010
1011 /* Test string space. */
1012 ed = eet_dictionary_get(ef);
1013
1014 fail_if(!eet_dictionary_string_check(ed, result->str));
1015 fail_if(eet_dictionary_string_check(ed, result->istr));
1016
1017 eet_close(ef);
1018
1019 /* Attempt to replace etbt by the correct one. */
1020 etbt.i = EET_TEST_INT;
1021
1022 ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
1023 fail_if(!ef);
1024
1025 fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
1026
1027 result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
1028 fail_if(!result);
1029
1030 /* Test the resulting data. */
1031 fail_if(_eet_test_ex_check(result, 0) != 0);
1032
1033 eet_close(ef);
1034
1035 /* Read back the data. */
1036 ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
1037 fail_if(!ef);
1038
1039 fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY2, &etbt, 0));
1040
1041 result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
1042 fail_if(!result);
1043
1044 /* Test string space. */
1045 ed = eet_dictionary_get(ef);
1046 fail_if(!ed);
1047
1048 fail_if(!eet_dictionary_string_check(ed, result->str));
1049 fail_if(eet_dictionary_string_check(ed, result->istr));
1050
1051 /* Test the resulting data. */
1052 fail_if(_eet_test_ex_check(result, 0) != 0);
1053 fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
1054 fail_if(eina_list_data_get(result->ilist) == NULL);
1055 fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
1056 fail_if(eina_list_data_get(result->slist) == NULL);
1057 fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
1058 fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
1059 fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
1060 fail_if(strcmp(result->charray[0], "test") != 0);
1061
1062 test = 0;
1063 if (result->hash)
1064 eina_hash_foreach(result->hash, func, &test);
1065
1066 fail_if(test != 0);
1067 if (result->ihash)
1068 eina_hash_foreach(result->ihash, func7, &test);
1069
1070 fail_if(test != 0);
1071
1072 list = eet_list(ef, "keys/*", &size);
1073 fail_if(eet_num_entries(ef) != 2);
1074 fail_if(size != 2);
1075 fail_if(!(strcmp(list[0],
1076 EET_TEST_FILE_KEY1) == 0 &&
1077 strcmp(list[1], EET_TEST_FILE_KEY2) == 0)
1078 && !(strcmp(list[0],
1079 EET_TEST_FILE_KEY2) == 0 &&
1080 strcmp(list[1], EET_TEST_FILE_KEY1) == 0));
1081 free(list);
1082
1083 fail_if(eet_delete(ef, NULL) != 0);
1084 fail_if(eet_delete(NULL, EET_TEST_FILE_KEY1) != 0);
1085 fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0);
1086
1087 list = eet_list(ef, "keys/*", &size);
1088 fail_if(size != 1);
1089 fail_if(eet_num_entries(ef) != 1);
1090
1091 /* Test some more wrong case */
1092 fail_if(eet_data_read(ef, edd, "plop") != NULL);
1093 fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) != NULL);
1094
1095 /* Reinsert and reread data */
1096 fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
1097 fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) == NULL);
1098 fail_if(eet_read_direct(ef, EET_TEST_FILE_KEY1, &size) == NULL);
1099
1100 eet_close(ef);
1101
1102 fail_if(unlink(file) != 0);
1103
1104 eet_shutdown();
1105} /* START_TEST */
1106
1107END_TEST
1108START_TEST(eet_file_data_dump_test)
1109{
1110 Eet_Data_Descriptor *edd;
1111 Eet_Test_Ex_Type *result;
1112 Eet_Data_Descriptor_Class eddc;
1113 Eet_Test_Ex_Type etbt;
1114 Eet_File *ef;
1115 char *string1;
1116 char *file = strdup("/tmp/eet_suite_testXXXXXX");
1117 int test;
1118
1119 eet_init();
1120
1121 _eet_test_ex_set(&etbt, 0);
1122 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
1123 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
1124 etbt.hash = eina_hash_string_superfast_new(NULL);
1125 eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
1126 eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
1127 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
1128 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
1129 etbt.ihash = eina_hash_string_superfast_new(NULL);
1130 eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
1131 eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
1132 etbt.slist = eina_list_prepend(NULL, "test");
1133 etbt.shash = eina_hash_string_superfast_new(NULL);
1134 eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
1135 memset(&etbt.charray, 0, sizeof(etbt.charray));
1136 etbt.charray[0] = "test";
1137
1138 eet_eina_file_data_descriptor_class_set(&eddc, sizeof (eddc),
1139 "Eet_Test_Ex_Type",
1140 sizeof(Eet_Test_Ex_Type));
1141
1142 edd = eet_data_descriptor_file_new(&eddc);
1143 fail_if(!edd);
1144
1145 _eet_build_ex_descriptor(edd);
1146
1147 fail_if(!(file = tmpnam(file)));
1148
1149 /* Save the encoded data in a file. */
1150 ef = eet_open(file, EET_FILE_MODE_WRITE);
1151 fail_if(!ef);
1152
1153 fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
1154
1155 eet_close(ef);
1156
1157 /* Use dump/undump in the middle */
1158 ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
1159 fail_if(!ef);
1160
1161 string1 = NULL;
1162 fail_if(eet_data_dump(ef, EET_TEST_FILE_KEY1, append_string, &string1) != 1);
1163 fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0);
1164 fail_if(!eet_data_undump(ef, EET_TEST_FILE_KEY1, string1, strlen(string1), 1));
1165
1166 eet_close(ef);
1167
1168 /* Test the correctness of the reinsertion. */
1169 ef = eet_open(file, EET_FILE_MODE_READ);
1170 fail_if(!ef);
1171
1172 result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
1173 fail_if(!result);
1174
1175 eet_close(ef);
1176
1177 /* Test the resulting data. */
1178 fail_if(_eet_test_ex_check(result, 0) != 0);
1179 fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
1180 fail_if(eina_list_data_get(result->ilist) == NULL);
1181 fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
1182 fail_if(eina_list_data_get(result->slist) == NULL);
1183 fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
1184 fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
1185 fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
1186 fail_if(strcmp(result->charray[0], "test") != 0);
1187
1188 test = 0;
1189 if (result->hash)
1190 eina_hash_foreach(result->hash, func, &test);
1191
1192 fail_if(test != 0);
1193 if (result->ihash)
1194 eina_hash_foreach(result->ihash, func7, &test);
1195
1196 fail_if(test != 0);
1197
1198 fail_if(unlink(file) != 0);
1199
1200 eet_shutdown();
1201} /* START_TEST */
1202
1203END_TEST
1204START_TEST(eet_image)
1205{
1206 Eet_File *ef;
1207 char *file = strdup("/tmp/eet_suite_testXXXXXX");
1208 unsigned int *data;
1209 int compress;
1210 int quality;
1211 int result;
1212 int lossy;
1213 int alpha;
1214 unsigned int w;
1215 unsigned int h;
1216
1217 eet_init();
1218
1219 fail_if(!(file = tmpnam(file)));
1220
1221 /* Save the encoded data in a file. */
1222 ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
1223 fail_if(!ef);
1224
1225 result = eet_data_image_write(ef,
1226 EET_TEST_FILE_IMAGE "0",
1227 test_noalpha.color,
1228 test_noalpha.w,
1229 test_noalpha.h,
1230 test_noalpha.alpha,
1231 0,
1232 100,
1233 0);
1234 fail_if(result == 0);
1235
1236 result = eet_data_image_write(ef,
1237 EET_TEST_FILE_IMAGE "1",
1238 test_noalpha.color,
1239 test_noalpha.w,
1240 test_noalpha.h,
1241 test_noalpha.alpha,
1242 5,
1243 100,
1244 0);
1245 fail_if(result == 0);
1246
1247 result = eet_data_image_write(ef,
1248 EET_TEST_FILE_IMAGE "2",
1249 test_noalpha.color,
1250 test_noalpha.w,
1251 test_noalpha.h,
1252 test_noalpha.alpha,
1253 9,
1254 100,
1255 0);
1256 fail_if(result == 0);
1257
1258 result = eet_data_image_write(ef,
1259 EET_TEST_FILE_IMAGE "3",
1260 test_noalpha.color,
1261 test_noalpha.w,
1262 test_noalpha.h,
1263 test_noalpha.alpha,
1264 0,
1265 100,
1266 1);
1267 fail_if(result == 0);
1268
1269 result = eet_data_image_write(ef,
1270 EET_TEST_FILE_IMAGE "4",
1271 test_noalpha.color,
1272 test_noalpha.w,
1273 test_noalpha.h,
1274 test_noalpha.alpha,
1275 0,
1276 60,
1277 1);
1278 fail_if(result == 0);
1279
1280 result = eet_data_image_write(ef,
1281 EET_TEST_FILE_IMAGE "5",
1282 test_noalpha.color,
1283 test_noalpha.w,
1284 test_noalpha.h,
1285 test_noalpha.alpha,
1286 0,
1287 10,
1288 1);
1289 fail_if(result == 0);
1290
1291 result = eet_data_image_write(ef,
1292 EET_TEST_FILE_IMAGE "6",
1293 test_noalpha.color,
1294 test_noalpha.w,
1295 test_noalpha.h,
1296 test_noalpha.alpha,
1297 0,
1298 0,
1299 1);
1300 fail_if(result == 0);
1301
1302 result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "7", test_alpha.color,
1303 test_alpha.w, test_alpha.h, test_alpha.alpha,
1304 9, 100, 0);
1305 fail_if(result == 0);
1306
1307 result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "8", test_alpha.color,
1308 test_alpha.w, test_alpha.h, test_alpha.alpha,
1309 0, 80, 1);
1310 fail_if(result == 0);
1311
1312 result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "9", test_alpha.color,
1313 test_alpha.w, test_alpha.h, test_alpha.alpha,
1314 0, 100, 1);
1315 fail_if(result == 0);
1316
1317 data = eet_data_image_read(ef,
1318 EET_TEST_FILE_IMAGE "2",
1319 &w,
1320 &h,
1321 &alpha,
1322 &compress,
1323 &quality,
1324 &lossy);
1325 fail_if(data == NULL);
1326 fail_if(w != test_noalpha.w);
1327 fail_if(h != test_noalpha.h);
1328 fail_if(alpha != test_noalpha.alpha);
1329 fail_if(compress != 9);
1330 fail_if(lossy != 0);
1331 fail_if(data[0] != test_noalpha.color[0]);
1332 free(data);
1333
1334 result = eet_data_image_header_read(ef,
1335 EET_TEST_FILE_IMAGE "2",
1336 &w,
1337 &h,
1338 &alpha,
1339 &compress,
1340 &quality,
1341 &lossy);
1342 fail_if(result == 0);
1343 fail_if(w != test_noalpha.w);
1344 fail_if(h != test_noalpha.h);
1345 fail_if(alpha != test_noalpha.alpha);
1346 fail_if(compress != 9);
1347 fail_if(lossy != 0);
1348
1349 eet_close(ef);
1350
1351 /* Test read of image */
1352 ef = eet_open(file, EET_FILE_MODE_READ);
1353 fail_if(!ef);
1354
1355 result = eet_data_image_header_read(ef,
1356 EET_TEST_FILE_IMAGE "0",
1357 &w,
1358 &h,
1359 &alpha,
1360 &compress,
1361 &quality,
1362 &lossy);
1363 fail_if(result == 0);
1364 fail_if(w != test_noalpha.w);
1365 fail_if(h != test_noalpha.h);
1366 fail_if(alpha != test_noalpha.alpha);
1367 fail_if(compress != 0);
1368 fail_if(lossy != 0);
1369
1370 data = malloc(w * h * 4);
1371 fail_if(data == NULL);
1372 result = eet_data_image_read_to_surface(ef,
1373 EET_TEST_FILE_IMAGE "0",
1374 4,
1375 4,
1376 data,
1377 2,
1378 2,
1379 w * 4,
1380 &alpha,
1381 &compress,
1382 &quality,
1383 &lossy);
1384 fail_if(result != 1);
1385 fail_if(alpha != test_noalpha.alpha);
1386 fail_if(compress != 0);
1387 fail_if(quality != 100);
1388 fail_if(lossy != 0);
1389 fail_if(data[0] != test_noalpha.color[4 + 4 * w]);
1390 free(data);
1391
1392 data = malloc(w * h * 4);
1393 fail_if(data == NULL);
1394 result = eet_data_image_read_to_surface(ef,
1395 EET_TEST_FILE_IMAGE "0",
1396 0,
1397 0,
1398 data,
1399 w,
1400 h,
1401 w * 4,
1402 &alpha,
1403 &compress,
1404 &quality,
1405 &lossy);
1406 fail_if(result != 1);
1407 fail_if(alpha != test_noalpha.alpha);
1408 fail_if(compress != 0);
1409 fail_if(quality != 100);
1410 fail_if(lossy != 0);
1411 fail_if(data[0] != test_noalpha.color[0]);
1412 free(data);
1413
1414 data = eet_data_image_read(ef,
1415 EET_TEST_FILE_IMAGE "1",
1416 &w,
1417 &h,
1418 &alpha,
1419 &compress,
1420 &quality,
1421 &lossy);
1422 fail_if(data == NULL);
1423 fail_if(w != test_noalpha.w);
1424 fail_if(h != test_noalpha.h);
1425 fail_if(alpha != test_noalpha.alpha);
1426 fail_if(compress != 5);
1427 fail_if(quality != 100);
1428 fail_if(lossy != 0);
1429 fail_if(data[0] != test_noalpha.color[0]);
1430 free(data);
1431
1432 data = eet_data_image_read(ef,
1433 EET_TEST_FILE_IMAGE "2",
1434 &w,
1435 &h,
1436 &alpha,
1437 &compress,
1438 &quality,
1439 &lossy);
1440 fail_if(data == NULL);
1441 fail_if(w != test_noalpha.w);
1442 fail_if(h != test_noalpha.h);
1443 fail_if(alpha != test_noalpha.alpha);
1444 fail_if(compress != 9);
1445 fail_if(lossy != 0);
1446 fail_if(data[0] != test_noalpha.color[0]);
1447 free(data);
1448
1449 data = eet_data_image_read(ef,
1450 EET_TEST_FILE_IMAGE "3",
1451 &w,
1452 &h,
1453 &alpha,
1454 &compress,
1455 &quality,
1456 &lossy);
1457 fail_if(data == NULL);
1458 fail_if(w != test_noalpha.w);
1459 fail_if(h != test_noalpha.h);
1460 fail_if(alpha != test_noalpha.alpha);
1461 fail_if(lossy != 1);
1462 free(data);
1463
1464 data = eet_data_image_read(ef,
1465 EET_TEST_FILE_IMAGE "5",
1466 &w,
1467 &h,
1468 &alpha,
1469 &compress,
1470 &quality,
1471 &lossy);
1472 fail_if(data == NULL);
1473 fail_if(w != test_noalpha.w);
1474 fail_if(h != test_noalpha.h);
1475 fail_if(alpha != test_noalpha.alpha);
1476 fail_if(lossy != 1);
1477 free(data);
1478
1479 data = eet_data_image_read(ef,
1480 EET_TEST_FILE_IMAGE "6",
1481 &w,
1482 &h,
1483 &alpha,
1484 &compress,
1485 &quality,
1486 &lossy);
1487 fail_if(data == NULL);
1488 fail_if(w != test_noalpha.w);
1489 fail_if(h != test_noalpha.h);
1490 fail_if(alpha != test_noalpha.alpha);
1491 fail_if(lossy != 1);
1492 free(data);
1493
1494 result = eet_data_image_header_read(ef,
1495 EET_TEST_FILE_IMAGE "7",
1496 &w,
1497 &h,
1498 &alpha,
1499 &compress,
1500 &quality,
1501 &lossy);
1502 fail_if(result == 0);
1503 fail_if(w != test_alpha.w);
1504 fail_if(h != test_alpha.h);
1505 fail_if(alpha != test_alpha.alpha);
1506 fail_if(compress != 9);
1507 fail_if(lossy != 0);
1508
1509 data = eet_data_image_read(ef,
1510 EET_TEST_FILE_IMAGE "7",
1511 &w,
1512 &h,
1513 &alpha,
1514 &compress,
1515 &quality,
1516 &lossy);
1517 fail_if(data == NULL);
1518 fail_if(w != test_alpha.w);
1519 fail_if(h != test_alpha.h);
1520 fail_if(alpha != test_alpha.alpha);
1521 fail_if(compress != 9);
1522 fail_if(lossy != 0);
1523 fail_if(data[0] != test_alpha.color[0]);
1524 free(data);
1525
1526 result = eet_data_image_header_read(ef,
1527 EET_TEST_FILE_IMAGE "9",
1528 &w,
1529 &h,
1530 &alpha,
1531 &compress,
1532 &quality,
1533 &lossy);
1534 fail_if(result == 0);
1535 fail_if(w != test_alpha.w);
1536 fail_if(h != test_alpha.h);
1537 fail_if(alpha != test_alpha.alpha);
1538 fail_if(lossy != 1);
1539
1540 data = eet_data_image_read(ef,
1541 EET_TEST_FILE_IMAGE "9",
1542 &w,
1543 &h,
1544 &alpha,
1545 &compress,
1546 &quality,
1547 &lossy);
1548 fail_if(data == NULL);
1549 fail_if(w != test_alpha.w);
1550 fail_if(h != test_alpha.h);
1551 fail_if(alpha != test_alpha.alpha);
1552 fail_if(lossy != 1);
1553 free(data);
1554
1555 eet_close(ef);
1556
1557 fail_if(unlink(file) != 0);
1558
1559 eet_shutdown();
1560} /* START_TEST */
1561
1562END_TEST
1563
1564#define IM0 0x00112233
1565#define IM1 0x44556677
1566#define IM2 0x8899aabb
1567#define IM3 0xccddeeff
1568
1569START_TEST(eet_small_image)
1570{
1571 char *file = strdup("/tmp/eet_suite_testXXXXXX");
1572 unsigned int image[4];
1573 unsigned int *data;
1574 Eet_File *ef;
1575 unsigned int w;
1576 unsigned int h;
1577 int alpha;
1578 int compression;
1579 int quality;
1580 int lossy;
1581 int result;
1582
1583 image[0] = IM0;
1584 image[1] = IM1;
1585 image[2] = IM2;
1586 image[3] = IM3;
1587
1588 eet_init();
1589
1590 fail_if(!(file = tmpnam(file)));
1591
1592 ef = eet_open(file, EET_FILE_MODE_WRITE);
1593 fail_if(!ef);
1594
1595 result = eet_data_image_write(ef, "/images/test", image, 2, 2, 1, 9, 100, 0);
1596 fail_if(result == 0);
1597
1598 eet_close(ef);
1599
1600 ef = eet_open(file, EET_FILE_MODE_READ);
1601 fail_if(!ef);
1602
1603 data = (unsigned int *)eet_data_image_read(ef,
1604 "/images/test",
1605 &w,
1606 &h,
1607 &alpha,
1608 &compression,
1609 &quality,
1610 &lossy);
1611 fail_if(data == NULL);
1612
1613 eet_close(ef);
1614
1615 fail_if(unlink(file) != 0);
1616
1617 fail_if(data[0] != IM0);
1618 fail_if(data[1] != IM1);
1619 fail_if(data[2] != IM2);
1620 fail_if(data[3] != IM3);
1621
1622 free(data);
1623
1624 eet_shutdown();
1625} /* START_TEST */
1626
1627END_TEST
1628START_TEST(eet_identity_simple)
1629{
1630 const char *buffer = "Here is a string of data to save !";
1631 const void *tmp;
1632 Eet_File *ef;
1633 Eet_Key *k;
1634 FILE *noread;
1635 char *test;
1636 char *file = strdup("/tmp/eet_suite_testXXXXXX");
1637 int size;
1638 int fd;
1639
1640 eet_init();
1641
1642 fail_if(!(file = tmpnam(file)));
1643 fail_if(chdir("src/tests"));
1644 fail_if(!(noread = fopen("/dev/null", "w")));
1645
1646 /* Sign an eet file. */
1647 ef = eet_open(file, EET_FILE_MODE_WRITE);
1648 fail_if(!ef);
1649
1650 fail_if(!eet_write(ef, "keys/tests", buffer, strlen(buffer) + 1, 0));
1651
1652 k = eet_identity_open("cert.pem", "key.pem", NULL);
1653 fail_if(!k);
1654
1655 fail_if(eet_identity_set(ef, k) != EET_ERROR_NONE);
1656 eet_identity_print(k, noread);
1657
1658 eet_close(ef);
1659
1660 /* Open a signed file. */
1661 ef = eet_open(file, EET_FILE_MODE_READ);
1662 fail_if(!ef);
1663
1664 test = eet_read(ef, "keys/tests", &size);
1665 fail_if(!test);
1666 fail_if(size != (int)strlen(buffer) + 1);
1667
1668 fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
1669
1670 tmp = eet_identity_x509(ef, &size);
1671 fail_if(tmp == NULL);
1672
1673 eet_identity_certificate_print(tmp, size, noread);
1674
1675 eet_close(ef);
1676
1677 /* As we are changing file contain in less than 1s, this could get unnoticed
1678 by eet cache system. */
1679 eet_clearcache();
1680
1681 /* Corrupting the file. */
1682 fd = open(file, O_WRONLY);
1683 fail_if(fd < 0);
1684
1685 fail_if(lseek(fd, 200, SEEK_SET) != 200);
1686 fail_if(write(fd, "42", 2) != 2);
1687 fail_if(lseek(fd, 50, SEEK_SET) != 50);
1688 fail_if(write(fd, "42", 2) != 2);
1689 fail_if(lseek(fd, 88, SEEK_SET) != 88);
1690 fail_if(write(fd, "42", 2) != 2);
1691
1692 close(fd);
1693
1694 /* Attempt to open a modified file. */
1695 ef = eet_open(file, EET_FILE_MODE_READ);
1696 fail_if(ef);
1697
1698 fail_if(unlink(file) != 0);
1699
1700 eet_shutdown();
1701} /* START_TEST */
1702
1703END_TEST
1704START_TEST(eet_identity_open_simple)
1705{
1706 Eet_Key *k = NULL;
1707
1708 eet_init();
1709
1710 fail_if(chdir("src/tests"));
1711
1712 k = eet_identity_open("cert.pem", "key.pem", NULL);
1713 fail_if(!k);
1714
1715 if (k)
1716 eet_identity_close(k);
1717
1718 eet_shutdown();
1719} /* START_TEST */
1720
1721END_TEST
1722START_TEST(eet_identity_open_pkcs8)
1723{
1724 Eet_Key *k = NULL;
1725
1726 eet_init();
1727
1728 fail_if(chdir("src/tests"));
1729
1730 k = eet_identity_open("cert.pem", "key_enc_none.pem", NULL);
1731 fail_if(!k);
1732
1733 if (k)
1734 eet_identity_close(k);
1735
1736 eet_shutdown();
1737} /* START_TEST */
1738
1739END_TEST
1740
1741static int
1742pass_get(char *pass,
1743 int size,
1744 __UNUSED__ int rwflags,
1745 __UNUSED__ void *u)
1746{
1747 memset(pass, 0, size);
1748
1749 if ((int)strlen("password") > size)
1750 return 0;
1751
1752 snprintf(pass, size, "%s", "password");
1753 return strlen(pass);
1754} /* pass_get */
1755
1756static int
1757badpass_get(char *pass,
1758 int size,
1759 __UNUSED__ int rwflags,
1760 __UNUSED__ void *u)
1761{
1762 memset(pass, 0, size);
1763
1764 if ((int)strlen("bad password") > size)
1765 return 0;
1766
1767 snprintf(pass, size, "%s", "bad password");
1768 return strlen(pass);
1769} /* badpass_get */
1770
1771START_TEST(eet_identity_open_pkcs8_enc)
1772{
1773 Eet_Key *k = NULL;
1774
1775 eet_init();
1776
1777 fail_if(chdir("src/tests"));
1778
1779 k = eet_identity_open("cert.pem", "key_enc.pem", NULL);
1780 fail_if(k);
1781
1782 if (k)
1783 eet_identity_close(k);
1784
1785 k = eet_identity_open("cert.pem", "key_enc.pem", &badpass_get);
1786 fail_if(k);
1787
1788 if (k)
1789 eet_identity_close(k);
1790
1791 k = eet_identity_open("cert.pem", "key_enc.pem", &pass_get);
1792 fail_if(!k);
1793
1794 if (k)
1795 eet_identity_close(k);
1796
1797 eet_shutdown();
1798}
1799END_TEST
1800START_TEST(eet_cipher_decipher_simple)
1801{
1802 const char *buffer = "Here is a string of data to save !";
1803 const char *key = "This is a crypto key";
1804 const char *key_bad = "This is another crypto key";
1805 Eet_File *ef;
1806 char *test;
1807 char *file = strdup("/tmp/eet_suite_testXXXXXX");
1808 int size;
1809
1810 eet_init();
1811
1812 fail_if(!(file = tmpnam(file)));
1813 fail_if(chdir("src/tests"));
1814
1815 /* Crypt an eet file. */
1816 ef = eet_open(file, EET_FILE_MODE_WRITE);
1817 fail_if(!ef);
1818
1819 fail_if(!eet_write_cipher(ef, "keys/tests", buffer, strlen(buffer) + 1, 0,
1820 key));
1821
1822 eet_close(ef);
1823
1824 /* Decrypt an eet file. */
1825 ef = eet_open(file, EET_FILE_MODE_READ);
1826 fail_if(!ef);
1827
1828 test = eet_read_cipher(ef, "keys/tests", &size, key);
1829 fail_if(!test);
1830 fail_if(size != (int)strlen(buffer) + 1);
1831
1832 fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
1833
1834 eet_close(ef);
1835
1836 /* Decrypt an eet file. */
1837 ef = eet_open(file, EET_FILE_MODE_READ);
1838 fail_if(!ef);
1839
1840 test = eet_read_cipher(ef, "keys/tests", &size, key_bad);
1841
1842 if (size == (int)strlen(buffer) + 1)
1843 fail_if(memcmp(test, buffer, strlen(buffer) + 1) == 0);
1844
1845 eet_close(ef);
1846
1847 fail_if(unlink(file) != 0);
1848
1849 eet_shutdown();
1850} /* START_TEST */
1851
1852END_TEST
1853
1854#ifdef EINA_HAVE_THREADS
1855
1856static Eina_Bool open_worker_stop;
1857
1858# ifdef _EET_INCLUDED_PTHREAD
1859
1860static void *
1861open_close_worker(void *path)
1862{
1863 while (!open_worker_stop)
1864 {
1865 Eet_File *ef = eet_open((char const *)path, EET_FILE_MODE_READ);
1866 if (ef == NULL)
1867 pthread_exit("eet_open() failed");
1868 else
1869 {
1870 Eet_Error err_code = eet_close(ef);
1871 if (err_code != EET_ERROR_NONE)
1872 pthread_exit("eet_close() failed");
1873 }
1874 }
1875
1876 pthread_exit(NULL);
1877} /* open_close_worker */
1878
1879# else /* ifdef _EET_INCLUDED_PTHREAD */
1880
1881static unsigned int __stdcall
1882open_close_worker(void *path)
1883{
1884 while (!open_worker_stop)
1885 {
1886 Eet_File *ef = eet_open((char const *)path, EET_FILE_MODE_READ);
1887 if (ef == NULL)
1888 _endthreadex(-1);
1889 else
1890 {
1891 Eet_Error err_code = eet_close(ef);
1892 if (err_code != EET_ERROR_NONE)
1893 _endthreadex(-2);
1894 }
1895 }
1896
1897 _endthreadex(0);
1898} /* open_close_worker */
1899
1900# endif /* ifdef _EET_INCLUDED_PTHREAD */
1901
1902START_TEST(eet_cache_concurrency)
1903{
1904 char *file = strdup("/tmp/eet_suite_testXXXXXX");
1905 const char *buffer = "test data";
1906 Eet_File *ef;
1907 void *thread_ret;
1908 unsigned int n;
1909# ifdef _EET_INCLUDED_PTHREAD
1910 pthread_t thread;
1911# else /* ifdef _EET_INCLUDED_PTHREAD */
1912 uintptr_t thread;
1913 unsigned int thread_id;
1914 DWORD ret;
1915# endif /* ifdef _EET_INCLUDED_PTHREAD */
1916
1917 eet_init();
1918 eina_threads_init();
1919
1920 /* create a file to test with */
1921 fail_if(!(file = tmpnam(file)));
1922 ef = eet_open(file, EET_FILE_MODE_WRITE);
1923 fail_if(!ef);
1924 fail_if(!eet_write(ef, "keys/tests", buffer, strlen(buffer) + 1, 0));
1925
1926 /* start a thread that repeatedly opens and closes a file */
1927 open_worker_stop = 0;
1928# ifdef _EET_INCLUDED_PTHREAD
1929 pthread_create(&thread, NULL, open_close_worker, file);
1930# else /* ifdef _EET_INCLUDED_PTHREAD */
1931 thread = _beginthreadex(NULL, 0, open_close_worker, file, 0, &thread_id);
1932# endif /* ifdef _EET_INCLUDED_PTHREAD */
1933 /* clear the cache repeatedly in this thread */
1934 for (n = 0; n < 50000; ++n)
1935 {
1936 eet_clearcache();
1937 }
1938
1939 /* join the other thread, and fail if it returned an error message */
1940 open_worker_stop = 1;
1941# ifdef _EET_INCLUDED_PTHREAD
1942 fail_if(pthread_join(thread, &thread_ret) != 0);
1943 fail_unless(thread_ret == NULL, (char const *)thread_ret);
1944# else /* ifdef _EET_INCLUDED_PTHREAD */
1945 ret = WaitForSingleObject((HANDLE)thread, INFINITE);
1946 fail_if(ret != WAIT_OBJECT_0);
1947 fail_if(GetExitCodeThread((HANDLE)thread, &ret) == FALSE);
1948 fail_if(ret != 0);
1949# endif /* ifdef _EET_INCLUDED_PTHREAD */
1950
1951 fail_if(unlink(file) != 0);
1952
1953 eina_threads_shutdown();
1954 eet_shutdown();
1955}
1956END_TEST
1957
1958#endif /* EINA_HAVE_THREADS */
1959
1960typedef struct _Eet_Connection_Data Eet_Connection_Data;
1961struct _Eet_Connection_Data
1962{
1963 Eet_Connection *conn;
1964 Eet_Data_Descriptor *edd;
1965 Eina_Bool test;
1966};
1967
1968static Eina_Bool
1969_eet_connection_read(const void *eet_data,
1970 size_t size,
1971 void *user_data)
1972{
1973 Eet_Connection_Data *dt = user_data;
1974 Eet_Test_Ex_Type *result;
1975 Eet_Node *node;
1976 int test;
1977
1978 result = eet_data_descriptor_decode(dt->edd, eet_data, size);
1979 node = eet_data_node_decode_cipher(eet_data, NULL, size);
1980
1981 /* Test the resulting data. */
1982 fail_if(!node);
1983 fail_if(_eet_test_ex_check(result, 0) != 0);
1984 fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
1985 fail_if(eina_list_data_get(result->ilist) == NULL);
1986 fail_if(*((int *)eina_list_data_get(result->ilist)) != 42);
1987 fail_if(eina_list_data_get(result->slist) == NULL);
1988 fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
1989 fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
1990 fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
1991 fail_if(strcmp(result->charray[0], "test") != 0);
1992
1993 test = 0;
1994 if (result->hash)
1995 eina_hash_foreach(result->hash, func, &test);
1996
1997 fail_if(test != 0);
1998 if (result->ihash)
1999 eina_hash_foreach(result->ihash, func7, &test);
2000
2001 fail_if(test != 0);
2002
2003 if (!dt->test)
2004 {
2005 dt->test = EINA_TRUE;
2006 fail_if(!eet_connection_node_send(dt->conn, node, NULL));
2007 }
2008
2009 return EINA_TRUE;
2010} /* _eet_connection_read */
2011
2012static Eina_Bool
2013_eet_connection_write(const void *data,
2014 size_t size,
2015 void *user_data)
2016{
2017 Eet_Connection_Data *dt = user_data;
2018 int still;
2019
2020 if (!dt->test)
2021 {
2022 int step = size / 3;
2023
2024 eet_connection_received(dt->conn, data, step);
2025 eet_connection_received(dt->conn, (char *)data + step, step);
2026 size -= 2 * step;
2027 still = eet_connection_received(dt->conn, (char *)data + 2 * step, size);
2028 }
2029 else
2030 still = eet_connection_received(dt->conn, data, size);
2031
2032 fail_if(still);
2033
2034 return EINA_TRUE;
2035} /* _eet_connection_write */
2036
2037START_TEST(eet_connection_check)
2038{
2039 Eet_Connection *conn;
2040 Eet_Data_Descriptor *edd;
2041 Eet_Data_Descriptor_Class eddc;
2042 Eet_Connection_Data ecd;
2043 Eet_Test_Ex_Type etbt;
2044 Eina_Bool on_going;
2045
2046 eet_init();
2047
2048 _eet_test_ex_set(&etbt, 0);
2049 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
2050 etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
2051 etbt.hash = eina_hash_string_superfast_new(NULL);
2052 eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
2053 eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
2054 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
2055 etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
2056 etbt.ihash = eina_hash_string_superfast_new(NULL);
2057 eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
2058 eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
2059 etbt.slist = eina_list_prepend(NULL, "test");
2060 etbt.shash = eina_hash_string_superfast_new(NULL);
2061 eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
2062 memset(&etbt.charray, 0, sizeof(etbt.charray));
2063 etbt.charray[0] = "test";
2064
2065 eet_eina_file_data_descriptor_class_set(&eddc, sizeof (eddc),
2066 "Eet_Test_Ex_Type",
2067 sizeof(Eet_Test_Ex_Type));
2068
2069 edd = eet_data_descriptor_file_new(&eddc);
2070 fail_if(!edd);
2071
2072 _eet_build_ex_descriptor(edd);
2073
2074 /* Create a connection. */
2075 conn = eet_connection_new(_eet_connection_read, _eet_connection_write, &ecd);
2076 fail_if(!conn);
2077
2078 /* Init context. */
2079 ecd.test = EINA_FALSE;
2080 ecd.conn = conn;
2081 ecd.edd = edd;
2082
2083 /* Test the connection. */
2084 fail_if(!eet_connection_send(conn, edd, &etbt, NULL));
2085
2086 fail_if(!ecd.test);
2087
2088 fail_if(!eet_connection_close(conn, &on_going));
2089
2090 fail_if(on_going);
2091
2092 eet_shutdown();
2093}
2094END_TEST
2095
2096struct _Eet_5FP
2097{
2098 Eina_F32p32 fp32;
2099 Eina_F16p16 fp16;
2100 Eina_F8p24 fp8;
2101 Eina_F32p32 f1;
2102 Eina_F32p32 f0;
2103};
2104typedef struct _Eet_5FP Eet_5FP;
2105
2106struct _Eet_5DBL
2107{
2108 double fp32;
2109 double fp16;
2110 float fp8;
2111 double f1;
2112 double f0;
2113};
2114typedef struct _Eet_5DBL Eet_5DBL;
2115
2116START_TEST(eet_fp)
2117{
2118 Eet_Data_Descriptor_Class eddc;
2119 Eet_Data_Descriptor *edd_5FP;
2120 Eet_Data_Descriptor *edd_5DBL;
2121 Eet_5FP origin;
2122 Eet_5DBL *convert;
2123 Eet_5FP *build;
2124 void *blob;
2125 int size;
2126
2127 eet_init();
2128
2129 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_5FP);
2130 edd_5FP = eet_data_descriptor_stream_new(&eddc);
2131
2132 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp32", fp32, EET_T_F32P32);
2133 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp16", fp16, EET_T_F16P16);
2134 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp8", fp8, EET_T_F8P24);
2135 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f1", f1, EET_T_F32P32);
2136 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f0", f0, EET_T_F32P32);
2137
2138 eet_eina_stream_data_descriptor_class_set(&eddc, sizeof (eddc), "Eet_5FP", sizeof (Eet_5DBL));
2139 edd_5DBL = eet_data_descriptor_stream_new(&eddc);
2140
2141 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp32", fp32, EET_T_DOUBLE);
2142 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp16", fp16, EET_T_DOUBLE);
2143 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp8", fp8, EET_T_FLOAT);
2144 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f1", f1, EET_T_DOUBLE);
2145 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f0", f0, EET_T_DOUBLE);
2146
2147 origin.fp32 = eina_f32p32_double_from(1.125);
2148 origin.fp16 = eina_f16p16_int_from(2000);
2149 origin.fp8 = eina_f8p24_int_from(125);
2150 origin.f1 = eina_f32p32_int_from(1);
2151 origin.f0 = 0;
2152
2153 blob = eet_data_descriptor_encode(edd_5FP, &origin, &size);
2154 fail_if(!blob || size <= 0);
2155
2156 build = eet_data_descriptor_decode(edd_5FP, blob, size);
2157 fail_if(!build);
2158
2159 convert = eet_data_descriptor_decode(edd_5DBL, blob, size);
2160 fail_if(!convert);
2161
2162 fail_if(build->fp32 != eina_f32p32_double_from(1.125));
2163 fail_if(build->fp16 != eina_f16p16_int_from(2000));
2164 fail_if(build->fp8 != eina_f8p24_int_from(125));
2165 fail_if(build->f1 != eina_f32p32_int_from(1));
2166 fail_if(build->f0 != 0);
2167
2168 fail_if(convert->fp32 != 1.125);
2169 fail_if(convert->fp16 != 2000);
2170 fail_if(convert->fp8 != 125);
2171 fail_if(convert->f1 != 1);
2172 fail_if(convert->f0 != 0);
2173
2174 eet_shutdown();
2175}
2176END_TEST
2177START_TEST(eet_file_fp)
2178{
2179 char *file = strdup("/tmp/eet_suite_testXXXXXX");
2180 Eet_Data_Descriptor_Class eddc;
2181 Eet_Data_Descriptor *edd_5FP;
2182 Eet_Data_Descriptor *edd_5DBL;
2183 Eet_File *ef;
2184 Eet_5FP origin;
2185 Eet_5DBL *convert;
2186 Eet_5FP *build;
2187
2188 eet_init();
2189
2190 EET_EINA_FILE_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_5FP);
2191 edd_5FP = eet_data_descriptor_file_new(&eddc);
2192
2193 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp32", fp32, EET_T_F32P32);
2194 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp16", fp16, EET_T_F16P16);
2195 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "fp8", fp8, EET_T_F8P24);
2196 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f1", f1, EET_T_F32P32);
2197 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5FP, Eet_5FP, "f0", f0, EET_T_F32P32);
2198
2199 eet_eina_file_data_descriptor_class_set(&eddc, sizeof (eddc), "Eet_5FP", sizeof (Eet_5DBL));
2200 edd_5DBL = eet_data_descriptor_file_new(&eddc);
2201
2202 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp32", fp32, EET_T_DOUBLE);
2203 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp16", fp16, EET_T_DOUBLE);
2204 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "fp8", fp8, EET_T_FLOAT);
2205 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f1", f1, EET_T_DOUBLE);
2206 EET_DATA_DESCRIPTOR_ADD_BASIC(edd_5DBL, Eet_5DBL, "f0", f0, EET_T_DOUBLE);
2207
2208 origin.fp32 = eina_f32p32_double_from(1.125);
2209 origin.fp16 = eina_f16p16_int_from(2000);
2210 origin.fp8 = eina_f8p24_int_from(125);
2211 origin.f1 = eina_f32p32_int_from(1);
2212 origin.f0 = 0;
2213
2214 fail_if(!(file = tmpnam(file)));
2215
2216 ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
2217 fail_if(!ef);
2218
2219 fail_if(!eet_data_write(ef, edd_5FP, EET_TEST_FILE_KEY1, &origin, 1));
2220
2221 build = eet_data_read(ef, edd_5FP, EET_TEST_FILE_KEY1);
2222 fail_if(!build);
2223
2224 convert = eet_data_read(ef, edd_5DBL, EET_TEST_FILE_KEY1);
2225 fail_if(!convert);
2226
2227 fail_if(build->fp32 != eina_f32p32_double_from(1.125));
2228 fail_if(build->fp16 != eina_f16p16_int_from(2000));
2229 fail_if(build->fp8 != eina_f8p24_int_from(125));
2230 fail_if(build->f1 != eina_f32p32_int_from(1));
2231 fail_if(build->f0 != 0);
2232
2233 fail_if(convert->fp32 != 1.125);
2234 fail_if(convert->fp16 != 2000);
2235 fail_if(convert->fp8 != 125);
2236 fail_if(convert->f1 != 1);
2237 fail_if(convert->f0 != 0);
2238
2239 eet_close(ef);
2240
2241 fail_if(unlink(file) != 0);
2242
2243 eet_shutdown();
2244} /* START_TEST */
2245
2246END_TEST
2247
2248typedef struct _Eet_Union_Test Eet_Union_Test;
2249typedef struct _Eet_Variant_Test Eet_Variant_Test;
2250typedef struct _Eet_Variant_Type Eet_Variant_Type;
2251typedef struct _Eet_Inherit_Test1 Eet_Inherit_Test1;
2252typedef struct _Eet_Inherit_Test2 Eet_Inherit_Test2;
2253typedef struct _Eet_Inherit_Test3 Eet_Inherit_Test3;
2254typedef struct _Eet_St1 Eet_St1;
2255typedef struct _Eet_St2 Eet_St2;
2256typedef struct _Eet_St3 Eet_St3;
2257typedef struct _Eet_List Eet_List;
2258
2259typedef enum _Eet_Union
2260{
2261 EET_UNKNOWN,
2262 EET_ST1,
2263 EET_ST2,
2264 EET_ST3
2265} Eet_Union;
2266
2267struct
2268{
2269 Eet_Union u;
2270 const char *name;
2271} eet_mapping[] = {
2272 { EET_ST1, "ST1" },
2273 { EET_ST2, "ST2" },
2274 { EET_ST3, "ST3" },
2275 { EET_UNKNOWN, NULL }
2276};
2277
2278struct _Eet_St1
2279{
2280 double val1;
2281 int stuff;
2282 char *s1;
2283};
2284
2285struct _Eet_St2
2286{
2287 Eina_Bool b1;
2288 unsigned long long v1;
2289};
2290
2291struct _Eet_St3
2292{
2293 int boby;
2294};
2295
2296struct _Eet_Union_Test
2297{
2298 Eet_Union type;
2299
2300 union {
2301 Eet_St1 st1;
2302 Eet_St2 st2;
2303 Eet_St3 st3;
2304 } u;
2305};
2306
2307struct _Eet_Variant_Type
2308{
2309 const char *type;
2310 Eina_Bool unknow : 1;
2311};
2312
2313struct _Eet_Variant_Test
2314{
2315 Eet_Variant_Type t;
2316
2317 void *data;
2318 Eina_List *data_list;
2319};
2320
2321struct _Eet_Inherit_Test1
2322{
2323 Eet_Union type;
2324 Eet_St1 st1;
2325};
2326struct _Eet_Inherit_Test2
2327{
2328 Eet_Union type;
2329 Eet_St2 st2;
2330};
2331struct _Eet_Inherit_Test3
2332{
2333 Eet_Union type;
2334 Eet_St3 st3;
2335};
2336
2337struct _Eet_List
2338{
2339 Eina_List *list;
2340};
2341
2342static const char *
2343_eet_union_type_get(const void *data,
2344 Eina_Bool *unknow)
2345{
2346 const Eet_Union *u = data;
2347 int i;
2348
2349 if (unknow)
2350 *unknow = EINA_FALSE;
2351
2352 for (i = 0; eet_mapping[i].name != NULL; ++i)
2353 if (*u == eet_mapping[i].u)
2354 return eet_mapping[i].name;
2355
2356 if (unknow)
2357 *unknow = EINA_TRUE;
2358
2359 return NULL;
2360} /* _eet_union_type_get */
2361
2362static Eina_Bool
2363_eet_union_type_set(const char *type,
2364 void *data,
2365 Eina_Bool unknow)
2366{
2367 Eet_Union *u = data;
2368 int i;
2369
2370 if (unknow)
2371 return EINA_FALSE;
2372
2373 for (i = 0; eet_mapping[i].name != NULL; ++i)
2374 if (strcmp(eet_mapping[i].name, type) == 0)
2375 {
2376 *u = eet_mapping[i].u;
2377 return EINA_TRUE;
2378 }
2379
2380 return EINA_FALSE;
2381} /* _eet_union_type_set */
2382
2383static const char *
2384_eet_variant_type_get(const void *data,
2385 Eina_Bool *unknow)
2386{
2387 const Eet_Variant_Type *type = data;
2388 int i;
2389
2390 if (unknow)
2391 *unknow = type->unknow;
2392
2393 for (i = 0; eet_mapping[i].name != NULL; ++i)
2394 if (strcmp(type->type, eet_mapping[i].name) == 0)
2395 return eet_mapping[i].name;
2396
2397 if (unknow)
2398 *unknow = EINA_FALSE;
2399
2400 return type->type;
2401} /* _eet_variant_type_get */
2402
2403static Eina_Bool
2404_eet_variant_type_set(const char *type,
2405 void *data,
2406 Eina_Bool unknow)
2407{
2408 Eet_Variant_Type *vt = data;
2409
2410 vt->type = type;
2411 vt->unknow = unknow;
2412 return EINA_TRUE;
2413} /* _eet_variant_type_set */
2414
2415static Eet_Data_Descriptor *
2416_eet_st1_dd(void)
2417{
2418 Eet_Data_Descriptor_Class eddc;
2419 Eet_Data_Descriptor *res;
2420
2421 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_St1);
2422 res = eet_data_descriptor_stream_new(&eddc);
2423 EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St1, "val1", val1, EET_T_DOUBLE);
2424 EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St1, "stuff", stuff, EET_T_INT);
2425 EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St1, "s1", s1, EET_T_STRING);
2426
2427 return res;
2428} /* _eet_st1_dd */
2429
2430static void
2431_eet_st1_set(Eet_St1 *st1,
2432 int i)
2433{
2434 st1->val1 = EET_TEST_DOUBLE;
2435 st1->stuff = EET_TEST_INT + i;
2436 st1->s1 = EET_TEST_STRING;
2437} /* _eet_st1_set */
2438
2439static void
2440_eet_st1_cmp(Eet_St1 *st1,
2441 int i)
2442{
2443 double tmp;
2444
2445 fail_if(!st1);
2446
2447 tmp = st1->val1 - EET_TEST_DOUBLE;
2448 if (tmp < 0)
2449 tmp = -tmp;
2450
2451 fail_if(tmp > 0.005);
2452 fail_if(st1->stuff != EET_TEST_INT + i);
2453 fail_if(strcmp(st1->s1, EET_TEST_STRING));
2454} /* _eet_st1_cmp */
2455
2456static Eet_Data_Descriptor *
2457_eet_st2_dd(void)
2458{
2459 Eet_Data_Descriptor_Class eddc;
2460 Eet_Data_Descriptor *res;
2461
2462 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_St2);
2463 res = eet_data_descriptor_stream_new(&eddc);
2464 EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St2, "b1", b1, EET_T_UCHAR);
2465 EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St2, "v1", v1, EET_T_ULONG_LONG);
2466
2467 return res;
2468} /* _eet_st2_dd */
2469
2470static void
2471_eet_st2_set(Eet_St2 *st2,
2472 int i)
2473{
2474 st2->b1 = EINA_TRUE;
2475 st2->v1 = EET_TEST_LONG_LONG + i;
2476} /* _eet_st2_set */
2477
2478static void
2479_eet_st2_cmp(Eet_St2 *st2,
2480 int i)
2481{
2482 fail_if(!st2->b1);
2483 fail_if(st2->v1 != EET_TEST_LONG_LONG + i);
2484} /* _eet_st2_cmp */
2485
2486static Eet_Data_Descriptor *
2487_eet_st3_dd(void)
2488{
2489 Eet_Data_Descriptor_Class eddc;
2490 Eet_Data_Descriptor *res;
2491
2492 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_St3);
2493 res = eet_data_descriptor_stream_new(&eddc);
2494 EET_DATA_DESCRIPTOR_ADD_BASIC(res, Eet_St3, "boby", boby, EET_T_INT);
2495
2496 return res;
2497} /* _eet_st3_dd */
2498
2499static void
2500_eet_st3_set(Eet_St3 *st3,
2501 int i)
2502{
2503 st3->boby = EET_TEST_INT + i;
2504} /* _eet_st3_set */
2505
2506static void
2507_eet_st3_cmp(Eet_St3 *st3,
2508 int i)
2509{
2510 fail_if(st3->boby != EET_TEST_INT + i);
2511} /* _eet_st3_cmp */
2512
2513START_TEST(eet_test_union)
2514{
2515 Eet_Union_Test *eut;
2516 Eet_List *l;
2517 Eet_Data_Descriptor_Class eddc;
2518 Eet_Data_Descriptor *edd;
2519 Eet_Data_Descriptor *unified;
2520 Eet_Data_Descriptor *m;
2521 void *blob;
2522 int size;
2523 int i;
2524
2525 eina_init();
2526 eet_init();
2527
2528 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Union_Test);
2529 edd = eet_data_descriptor_stream_new(&eddc);
2530
2531 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Union_Test);
2532 m = eet_data_descriptor_stream_new(&eddc);
2533
2534 eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
2535 eddc.func.type_get = _eet_union_type_get;
2536 eddc.func.type_set = _eet_union_type_set;
2537 unified = eet_data_descriptor_stream_new(&eddc);
2538
2539 EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST1", _eet_st1_dd());
2540 EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST2", _eet_st2_dd());
2541 EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST3", _eet_st3_dd());
2542
2543 EET_DATA_DESCRIPTOR_ADD_UNION(edd, Eet_Union_Test, "u", u, type, unified);
2544
2545 EET_DATA_DESCRIPTOR_ADD_LIST(m, Eet_List, "list", list, edd);
2546
2547 l = calloc(1, sizeof (Eet_List));
2548
2549#define EUT_NEW(Type_Index) \
2550 eut = calloc(1, sizeof (Eet_Union_Test)); \
2551 eut->type = EET_ST ## Type_Index; \
2552 _eet_st ## Type_Index ## _set(&(eut->u.st ## Type_Index), i);
2553
2554 for (i = 0; i < 3; ++i)
2555 {
2556 EUT_NEW(1);
2557 l->list = eina_list_append(l->list, eut);
2558
2559 EUT_NEW(2);
2560 l->list = eina_list_append(l->list, eut);
2561
2562 EUT_NEW(3);
2563 l->list = eina_list_append(l->list, eut);
2564 }
2565
2566 blob = eet_data_descriptor_encode(m, l, &size);
2567 fail_if(!blob || size <= 0);
2568
2569 l = eet_data_descriptor_decode(m, blob, size);
2570 fail_if(!l);
2571
2572 fail_if(eina_list_count(l->list) != 9);
2573
2574#define EUT_CMP(Type_Index) \
2575 eut = eina_list_nth(l->list, i * 3 + Type_Index - 1); \
2576 fail_if(eut->type != EET_ST ## Type_Index); \
2577 _eet_st ## Type_Index ## _cmp(&(eut->u.st ## Type_Index), i);
2578
2579 for (i = 0; i < 3; ++i)
2580 {
2581 EUT_CMP(1);
2582 EUT_CMP(2);
2583 EUT_CMP(3);
2584 }
2585
2586 eet_shutdown();
2587 eina_shutdown();
2588}
2589END_TEST
2590START_TEST(eet_test_variant)
2591{
2592 Eet_Variant_Test *evt;
2593 Eet_List *l;
2594 Eet_St1 *st1;
2595 Eet_St2 *st2;
2596 Eet_St3 *st3;
2597 Eet_Data_Descriptor_Class eddc;
2598 Eet_Data_Descriptor *edd;
2599 Eet_Data_Descriptor *unified;
2600 Eet_Data_Descriptor *m;
2601 void *blob;
2602 int size;
2603 int i;
2604
2605 eina_init();
2606 eet_init();
2607
2608 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Variant_Test);
2609 edd = eet_data_descriptor_stream_new(&eddc);
2610
2611 EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eddc, Eet_Variant_Test);
2612 m = eet_data_descriptor_stream_new(&eddc);
2613
2614 eddc.version = EET_DATA_DESCRIPTOR_CLASS_VERSION;
2615 eddc.func.type_get = _eet_variant_type_get;
2616 eddc.func.type_set = _eet_variant_type_set;
2617 unified = eet_data_descriptor_stream_new(&eddc);
2618
2619 EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST1", _eet_st1_dd());
2620 EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST2", _eet_st2_dd());
2621 EET_DATA_DESCRIPTOR_ADD_MAPPING(unified, "ST3", _eet_st3_dd());
2622
2623 EET_DATA_DESCRIPTOR_ADD_VARIANT(edd,
2624 Eet_Variant_Test,
2625 "data",
2626 data,
2627 t,
2628 unified);
2629
2630 unified = eet_data_descriptor_stream_new(&eddc);
2631 eet_data_descriptor_element_add(unified, "ST1",
2632 EET_T_UNKNOW, EET_G_LIST,
2633 0, 0, NULL, _eet_st1_dd());
2634 eet_data_descriptor_element_add(unified, "ST2",
2635 EET_T_UNKNOW, EET_G_LIST,
2636 0, 0, NULL, _eet_st2_dd());
2637
2638 EET_DATA_DESCRIPTOR_ADD_VARIANT(edd, Eet_Variant_Test,
2639 "data_list", data_list, t, unified);
2640
2641 EET_DATA_DESCRIPTOR_ADD_LIST(m, Eet_List, "list", list, edd);
2642
2643 l = calloc(1, sizeof (Eet_List));
2644
2645#define EVT_NEW(Type_Index) \
2646 evt = calloc(1, sizeof (Eet_Variant_Test)); \
2647 evt->t.type = eet_mapping[Type_Index - 1].name; \
2648 st ## Type_Index = calloc(1, sizeof (Eet_St ## Type_Index)); \
2649 _eet_st ## Type_Index ## _set(st ## Type_Index, i); \
2650 evt->data = st ## Type_Index;
2651
2652 for (i = 0; i < 3; ++i)
2653 {
2654 EVT_NEW(1);
2655 l->list = eina_list_append(l->list, evt);
2656
2657 st1 = calloc(1, sizeof (Eet_St1));
2658 _eet_st1_set(st1, i);
2659 evt->data_list = eina_list_append(evt->data_list, st1);
2660
2661 EVT_NEW(2);
2662 l->list = eina_list_append(l->list, evt);
2663
2664 EVT_NEW(3);
2665 l->list = eina_list_append(l->list, evt);
2666 }
2667
2668 blob = eet_data_descriptor_encode(m, l, &size);
2669 fail_if(!blob || size <= 0);
2670
2671 l = eet_data_descriptor_decode(m, blob, size);
2672 fail_if(!l);
2673
2674 fail_if(eina_list_count(l->list) != 9);
2675
2676#define EVT_CMP(Type_Index) \
2677 evt = eina_list_nth(l->list, i * 3 + Type_Index - 1); \
2678 fail_if(strcmp(evt->t.type, eet_mapping[Type_Index - 1].name) != 0); \
2679 _eet_st ## Type_Index ## _cmp(evt->data, i);
2680
2681 for (i = 0; i < 3; ++i)
2682 {
2683 EVT_CMP(1);
2684
2685 fail_if(!evt->data_list);
2686 fail_if(eina_list_count(evt->data_list) != 1);
2687
2688 st1 = eina_list_data_get(evt->data_list);
2689 _eet_st1_cmp(st1, i);
2690
2691 EVT_CMP(2);
2692 EVT_CMP(3);
2693 }
2694
2695 eet_shutdown();
2696 eina_shutdown();
2697} /* START_TEST */
2698
2699END_TEST
2700
2701Suite *
2702eet_suite(void)
2703{
2704 Suite *s;
2705 TCase *tc;
2706
2707 s = suite_create("Eet");
2708
2709 tc = tcase_create("Eet_Init");
2710 tcase_add_test(tc, eet_test_init);
2711 suite_add_tcase(s, tc);
2712
2713 tc = tcase_create("Eet Data Encoding/Decoding");
2714 tcase_add_test(tc, eet_test_basic_data_type_encoding_decoding);
2715 tcase_add_test(tc, eet_test_data_type_encoding_decoding);
2716 tcase_add_test(tc, eet_test_data_type_dump_undump);
2717 tcase_add_test(tc, eet_fp);
2718 tcase_add_test(tc, eet_test_union);
2719 tcase_add_test(tc, eet_test_variant);
2720 suite_add_tcase(s, tc);
2721
2722 tc = tcase_create("Eet File");
2723 tcase_add_test(tc, eet_file_simple_write);
2724 tcase_add_test(tc, eet_file_data_test);
2725 tcase_add_test(tc, eet_file_data_dump_test);
2726 tcase_add_test(tc, eet_file_fp);
2727 suite_add_tcase(s, tc);
2728
2729 tc = tcase_create("Eet Image");
2730 tcase_add_test(tc, eet_image);
2731 tcase_add_test(tc, eet_small_image);
2732 suite_add_tcase(s, tc);
2733
2734#ifdef HAVE_SIGNATURE
2735 tc = tcase_create("Eet Identity");
2736 tcase_add_test(tc, eet_identity_simple);
2737 tcase_add_test(tc, eet_identity_open_simple);
2738 tcase_add_test(tc, eet_identity_open_pkcs8);
2739 tcase_add_test(tc, eet_identity_open_pkcs8_enc);
2740 suite_add_tcase(s, tc);
2741#endif /* ifdef HAVE_SIGNATURE */
2742
2743#ifdef HAVE_CIPHER
2744 tc = tcase_create("Eet Cipher");
2745 tcase_add_test(tc, eet_cipher_decipher_simple);
2746 suite_add_tcase(s, tc);
2747#endif /* ifdef HAVE_CIPHER */
2748
2749#ifdef EINA_HAVE_THREADS
2750 tc = tcase_create("Eet Cache");
2751 tcase_add_test(tc, eet_cache_concurrency);
2752 suite_add_tcase(s, tc);
2753#endif /* ifdef EFL_HAVE_THREADS */
2754
2755 tc = tcase_create("Eet Connection");
2756 tcase_add_test(tc, eet_connection_check);
2757 suite_add_tcase(s, tc);
2758
2759 return s;
2760} /* eet_suite */
2761
2762int
2763main(void)
2764{
2765 Suite *s;
2766 SRunner *sr;
2767 int failed_count;
2768
2769 s = eet_suite();
2770 sr = srunner_create(s);
2771 srunner_run_all(sr, CK_ENV);
2772 failed_count = srunner_ntests_failed(sr);
2773 srunner_free(sr);
2774
2775 return (failed_count == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
2776} /* main */
2777
generated by cgit v1.1 at 2024-07-17 20:32:57 +0000