src/tests/eet_suite.c

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