src/tests/eet_suite.c

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