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