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
  10 #include <check.h>
  11
  12 #ifdef HAVE_CONFIG_H
  13 # include <config.h>
  14 #endif
  15
  16 #include <Eina.h>
  17
  18 #include "eet_suite.h"
  19
  20 START_TEST(eet_test_init)
  21 {
  22    int ret;
  23
  24    ret = eet_init();
  25    fail_if(ret != 1);
  26
  27    ret = eet_shutdown();
  28    fail_if(ret != 0);
  29 }
  30 END_TEST
  31
  32 typedef struct _Eet_Test_Basic_Type Eet_Test_Basic_Type;
  33 struct _Eet_Test_Basic_Type
  34 {
  35    char c;
  36    short s;
  37    int i;
  38    long long l;
  39    char *str;
  40    char *istr;
  41    float f1;
  42    float f2;
  43    double d;
  44    unsigned char uc;
  45    unsigned short us;
  46    unsigned int ui;
  47    unsigned long long ul;
  48    Eet_Test_Basic_Type *empty;
  49    Eet_Test_Basic_Type *with;
  50 };
  51
  52 #define EET_TEST_CHAR 0x42
  53 #define EET_TEST_SHORT 0x4224
  54 #define EET_TEST_INT 0x42211224
  55 #define EET_TEST_LONG_LONG 0x84CB42211224BC48
  56 #define EET_TEST_STRING "my little test with escape \\\""
  57 #define EET_TEST_KEY1 "key1"
  58 #define EET_TEST_KEY2 "key2"
  59 #define EET_TEST_FLOAT 123.45689
  60 #define EET_TEST_FLOAT2 1.0
  61 #define EET_TEST_FLOAT3 0.25
  62 #define EET_TEST_FLOAT4 0.0001234
  63 #define EET_TEST_DOUBLE 123456789.9876543210
  64 #define EET_TEST_DOUBLE2 1.0
  65 #define EET_TEST_DOUBLE3 0.25
  66 #define EET_TEST_FILE_KEY1 "keys/data/1"
  67 #define EET_TEST_FILE_KEY2 "keys/data/2"
  68 #define EET_TEST_FILE_IMAGE "keys/images/"
  69
  70 typedef struct _Eet_Test_Image Eet_Test_Image;
  71 struct _Eet_Test_Image
  72 {
  73    unsigned int w;
  74    unsigned int h;
  75    int alpha;
  76    unsigned int color[];
  77 };
  78
  79 static const Eet_Test_Image test_noalpha = {
  80   8, 8, 0,
  81   {
  82     0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000,
  83     0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000,
  84     0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00,
  85     0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA,
  86     0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000,
  87     0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000,
  88     0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00,
  89     0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA
  90   }
  91 };
  92
  93 static const Eet_Test_Image test_alpha = {
  94   8, 8, 1,
  95   {
  96     0x0FAA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x0F110000,
  97     0x0000AA00, 0x0F0000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x0F110000, 0x00AA0000,
  98     0x000000AA, 0x00110000, 0x0FAA0000, 0x0000AA00, 0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00,
  99     0x00110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA,
 100     0x00AA0000, 0x0000AA00, 0x000000AA, 0x0F110000, 0x0FAA0000, 0x0000AA00, 0x000000AA, 0x00110000,
 101     0x0000AA00, 0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA, 0x00110000, 0x00AA0000,
 102     0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x0FAA0000, 0x0000AA00,
 103     0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA
 104   }
 105 };
 106
 107 static void
 108 _eet_test_basic_set(Eet_Test_Basic_Type *res, int i)
 109 {
 110    res->c = EET_TEST_CHAR;
 111    res->s = EET_TEST_SHORT;
 112    res->i = EET_TEST_INT + i;
 113    res->l = EET_TEST_LONG_LONG;
 114    res->str = EET_TEST_STRING;
 115    res->istr = EET_TEST_STRING;
 116    res->f1 = - EET_TEST_FLOAT;
 117    res->d = - EET_TEST_DOUBLE;
 118    res->f2 = EET_TEST_FLOAT4;
 119    res->uc = EET_TEST_CHAR;
 120    res->us = EET_TEST_SHORT;
 121    res->ui = EET_TEST_INT;
 122    res->ul = EET_TEST_LONG_LONG;
 123    res->empty = NULL;
 124    res->with = NULL;
 125
 126    if (i == 0)
 127      {
 128         Eet_Test_Basic_Type *tmp;
 129
 130         tmp = malloc(sizeof (Eet_Test_Basic_Type));
 131         fail_if(!tmp);
 132
 133         res->with = tmp;
 134         tmp->c = EET_TEST_CHAR;
 135         tmp->s = EET_TEST_SHORT;
 136         tmp->i = EET_TEST_INT + i + 1;
 137         tmp->l = EET_TEST_LONG_LONG;
 138         tmp->str = EET_TEST_STRING;
 139         tmp->istr = EET_TEST_STRING;
 140         tmp->f1 = - EET_TEST_FLOAT;
 141         tmp->d = - EET_TEST_DOUBLE;
 142         tmp->f2 = EET_TEST_FLOAT4;
 143         tmp->uc = EET_TEST_CHAR;
 144         tmp->us = EET_TEST_SHORT;
 145         tmp->ui = EET_TEST_INT;
 146         tmp->ul = EET_TEST_LONG_LONG;
 147         tmp->empty = NULL;
 148         tmp->with = NULL;
 149      }
 150 }
 151
 152 static void
 153 _eet_test_basic_check(Eet_Test_Basic_Type *result, int i)
 154 {
 155    float tmp;
 156
 157    fail_if(result->c != EET_TEST_CHAR);
 158    fail_if(result->s != EET_TEST_SHORT);
 159    fail_if(result->i != EET_TEST_INT + i);
 160    fail_if(result->l != (long long) EET_TEST_LONG_LONG);
 161    fail_if(strcmp(result->str, EET_TEST_STRING) != 0);
 162    fail_if(strcmp(result->istr, EET_TEST_STRING) != 0);
 163    fail_if(result->uc != EET_TEST_CHAR);
 164    fail_if(result->us != EET_TEST_SHORT);
 165    fail_if(result->ui != EET_TEST_INT);
 166    fail_if(result->ul != EET_TEST_LONG_LONG);
 167
 168    tmp = (result->f1 + EET_TEST_FLOAT);
 169    if (tmp < 0) tmp = -tmp;
 170    fail_if(tmp > 0.005);
 171
 172    tmp = (result->f2 - EET_TEST_FLOAT4);
 173    if (tmp < 0) tmp = -tmp;
 174    fail_if(tmp > 0.005);
 175
 176    tmp = (result->d + EET_TEST_DOUBLE);
 177    if (tmp < 0) tmp = -tmp;
 178    fail_if(tmp > 0.00005);
 179
 180    fail_if(result->empty != NULL);
 181    if (i == 0)
 182      {
 183         Eet_Test_Basic_Type *tmp;
 184
 185         tmp = result->with;
 186         fail_if(tmp == NULL);
 187
 188         fail_if(tmp->c != EET_TEST_CHAR);
 189         fail_if(tmp->s != EET_TEST_SHORT);
 190         fail_if(tmp->i != EET_TEST_INT + i + 1);
 191         fail_if(tmp->l != (long long) EET_TEST_LONG_LONG);
 192         fail_if(strcmp(tmp->str, EET_TEST_STRING) != 0);
 193         fail_if(strcmp(tmp->istr, EET_TEST_STRING) != 0);
 194         fail_if(tmp->uc != EET_TEST_CHAR);
 195         fail_if(tmp->us != EET_TEST_SHORT);
 196         fail_if(tmp->ui != EET_TEST_INT);
 197         fail_if(tmp->ul != EET_TEST_LONG_LONG);
 198      }
 199    else
 200      fail_if(result->with != NULL);
 201 }
 202
 203 static void
 204 _eet_build_basic_descriptor(Eet_Data_Descriptor *edd)
 205 {
 206    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "c", c, EET_T_CHAR);
 207    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "s", s, EET_T_SHORT);
 208    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "i", i, EET_T_INT);
 209    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "l", l, EET_T_LONG_LONG);
 210    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "str", str, EET_T_STRING);
 211    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "istr", istr, EET_T_INLINED_STRING);
 212    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "f1", f1, EET_T_FLOAT);
 213    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "f2", f2, EET_T_FLOAT);
 214    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "d", d, EET_T_DOUBLE);
 215    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "uc", uc, EET_T_UCHAR);
 216    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "us", us, EET_T_USHORT);
 217    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "ui", ui, EET_T_UINT);
 218    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "ul", ul, EET_T_ULONG_LONG);
 219
 220    EET_DATA_DESCRIPTOR_ADD_SUB(edd, Eet_Test_Basic_Type, "empty", empty, edd);
 221    EET_DATA_DESCRIPTOR_ADD_SUB(edd, Eet_Test_Basic_Type, "with", with, edd);
 222 }
 223
 224 START_TEST(eet_test_basic_data_type_encoding_decoding)
 225 {
 226    Eet_Data_Descriptor *edd;
 227    Eet_Test_Basic_Type *result;
 228    Eet_Data_Descriptor_Class eddc;
 229    Eet_Test_Basic_Type etbt;
 230    void *transfert;
 231    int size;
 232
 233    eet_init();
 234
 235    _eet_test_basic_set(&etbt, 0);
 236
 237    eet_test_setup_eddc(&eddc);
 238    eddc.name = "Eet_Test_Basic_Type";
 239    eddc.size = sizeof(Eet_Test_Basic_Type);
 240
 241    edd = eet_data_descriptor2_new(&eddc);
 242    fail_if(!edd);
 243
 244    _eet_build_basic_descriptor(edd);
 245
 246    transfert = eet_data_descriptor_encode(edd, &etbt, &size);
 247    fail_if(!transfert || size <= 0);
 248
 249    result = eet_data_descriptor_decode(edd, transfert, size);
 250    fail_if(!result);
 251
 252    _eet_test_basic_check(result, 0);
 253
 254    free(result->str);
 255    free(result);
 256
 257    eet_data_descriptor_free(edd);
 258
 259    eet_shutdown();
 260 }
 261 END_TEST
 262
 263 typedef struct _Eet_Test_Ex_Type Eet_Test_Ex_Type;
 264 struct _Eet_Test_Ex_Type
 265 {
 266    char c;
 267    short s;
 268    int i;
 269    unsigned long long l;
 270    char *str;
 271    char *istr;
 272    float f1;
 273    float f2;
 274    float f3;
 275    float f4;
 276    double d1;
 277    double d2;
 278    double d3;
 279    double d4;
 280    Eina_List *list;
 281    Eina_Hash *hash;
 282    Eina_List *ilist;
 283    Eina_Hash *ihash;
 284    Eet_Test_Basic_Type sarray1[10];
 285    unsigned int sarray2[5];
 286    unsigned int varray1_count;
 287    unsigned int *varray1;
 288    unsigned int varray2_count;
 289    Eet_Test_Basic_Type *varray2;
 290    unsigned char uc;
 291    unsigned short us;
 292    unsigned int ui;
 293    unsigned long long ul;
 294 };
 295
 296 static int i42 = 42;
 297 static int i7 = 7;
 298
 299
 300 static void
 301 _eet_build_ex_descriptor(Eet_Data_Descriptor *edd)
 302 {
 303    Eet_Data_Descriptor_Class eddc;
 304    Eet_Test_Ex_Type etbt;
 305    Eet_Data_Descriptor *eddb;
 306
 307    eet_test_setup_eddc(&eddc);
 308    eddc.name = "Eet_Test_Basic_Type";
 309    eddc.size = sizeof(Eet_Test_Basic_Type);
 310    eddb = eet_data_descriptor3_new(&eddc);
 311    fail_if(!eddb);
 312
 313    _eet_build_basic_descriptor(eddb);
 314
 315    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "c", c, EET_T_CHAR);
 316    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "s", s, EET_T_SHORT);
 317    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "i", i, EET_T_INT);
 318    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "l", l, EET_T_LONG_LONG);
 319    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "str", str, EET_T_STRING);
 320    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "istr", istr, EET_T_INLINED_STRING);
 321    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f1", f1, EET_T_FLOAT);
 322    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f2", f2, EET_T_FLOAT);
 323    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f3", f3, EET_T_FLOAT);
 324    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f4", f4, EET_T_FLOAT);
 325    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d1", d1, EET_T_DOUBLE);
 326    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d2", d2, EET_T_DOUBLE);
 327    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d3", d3, EET_T_DOUBLE);
 328    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d4", d4, EET_T_DOUBLE);
 329    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "uc", uc, EET_T_UCHAR);
 330    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "us", us, EET_T_USHORT);
 331    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ui", ui, EET_T_UINT);
 332    EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ul", ul, EET_T_ULONG_LONG);
 333    EET_DATA_DESCRIPTOR_ADD_ARRAY(edd, Eet_Test_Ex_Type, "sarray1", sarray1, eddb);
 334    EET_DATA_DESCRIPTOR_ADD_VAR_ARRAY(edd, Eet_Test_Ex_Type, "varray2", varray2, eddb);
 335    eet_data_descriptor_element_add(edd, "varray1", EET_T_INT, EET_G_VAR_ARRAY,
 336                                    (char *)(&(etbt.varray1)) - (char *)(&(etbt)),
 337                                    (char *)(&(etbt.varray1_count)) - (char *)(&(etbt)), /* 0,  */NULL, NULL);
 338    eet_data_descriptor_element_add(edd, "sarray2", EET_T_INT, EET_G_ARRAY,
 339                                    (char *)(&(etbt.sarray2)) - (char *)(&(etbt)),
 340                                    /* 0,  */sizeof(etbt.sarray2)/sizeof(etbt.sarray2[0]), NULL, NULL);
 341    EET_DATA_DESCRIPTOR_ADD_LIST(edd, Eet_Test_Ex_Type, "list", list, edd);
 342    EET_DATA_DESCRIPTOR_ADD_HASH(edd, Eet_Test_Ex_Type, "hash", hash, edd);
 343    eet_data_descriptor_element_add(edd, "ilist", EET_T_INT, EET_G_LIST,
 344                                    (char *)(&(etbt.ilist)) - (char *)(&(etbt)),
 345                                    0, /* 0,  */NULL, NULL);
 346    eet_data_descriptor_element_add(edd, "ihash", EET_T_INT, EET_G_HASH,
 347                                    (char *)(&(etbt.ihash)) - (char *)(&(etbt)),
 348                                    0, /* 0,  */NULL, NULL);
 349 }
 350
 351 static Eet_Test_Ex_Type*
 352 _eet_test_ex_set(Eet_Test_Ex_Type *res, int offset)
 353 {
 354    int i;
 355
 356    if (!res) res = malloc( sizeof(Eet_Test_Ex_Type));
 357    if (!res) return NULL;
 358
 359    res->c = EET_TEST_CHAR + offset;
 360    res->s = EET_TEST_SHORT + offset;
 361    res->i = EET_TEST_INT + offset;
 362    res->l = EET_TEST_LONG_LONG + offset;
 363    res->str = EET_TEST_STRING;
 364    res->istr = EET_TEST_STRING;
 365    res->f1 = EET_TEST_FLOAT + offset;
 366    res->f2 = -(EET_TEST_FLOAT2 + offset);
 367    res->f3 = EET_TEST_FLOAT3 + offset;
 368    res->f4 = EET_TEST_FLOAT2 + offset;
 369    res->d1 = EET_TEST_DOUBLE + offset;
 370    res->d2 = -(EET_TEST_DOUBLE2 + offset);
 371    res->d3 = EET_TEST_DOUBLE3 + offset;
 372    res->d4 = EET_TEST_DOUBLE2 + offset;
 373    res->list = NULL;
 374    res->hash = NULL;
 375    res->ilist = NULL;
 376    res->ihash = NULL;
 377
 378    res->varray2 = malloc(sizeof (Eet_Test_Basic_Type) * 10);
 379    res->varray1 = malloc(sizeof (int) * 5);
 380    fail_if(!res->varray1 || !res->varray2);
 381    for (i = 0; i < 10; ++i)
 382      {
 383         _eet_test_basic_set(res->sarray1 + i, i);
 384         _eet_test_basic_set(res->varray2 + i, i);
 385      }
 386    res->varray2_count = 10;
 387    for (i = 0; i < 5; ++i)
 388      {
 389         res->sarray2[i] = i * 42 + 1;
 390         res->varray1[i] = i * 42 + 1;
 391      }
 392    res->varray1_count = 5;
 393
 394    res->uc = EET_TEST_CHAR + offset;
 395    res->us = EET_TEST_SHORT + offset;
 396    res->ui = EET_TEST_INT + offset;
 397    res->ul = EET_TEST_LONG_LONG + offset;
 398
 399    return res;
 400 }
 401
 402 static int
 403 _eet_test_ex_check(Eet_Test_Ex_Type *stuff, int offset)
 404 {
 405    double tmp;
 406    unsigned int i;
 407
 408    if (!stuff) return 1;
 409
 410    if (stuff->c != EET_TEST_CHAR + offset) return 1;
 411    if (stuff->s != EET_TEST_SHORT + offset) return 1;
 412    if (stuff->i != EET_TEST_INT + offset) return 1;
 413    if (stuff->l != EET_TEST_LONG_LONG + offset) return 1;
 414    if (strcmp(stuff->str, EET_TEST_STRING) != 0) return 1;
 415    if (strcmp(stuff->istr, EET_TEST_STRING) != 0) return 1;
 416
 417    tmp = stuff->f1 - (EET_TEST_FLOAT + offset);
 418    if (tmp < 0) tmp = -tmp;
 419    if (tmp > 0.005) return 1;
 420
 421    tmp = stuff->d1 - (EET_TEST_DOUBLE + offset);
 422    if (tmp < 0) tmp = -tmp;
 423    if (tmp > 0.00005) return 1;
 424
 425    if (stuff->f2 != - (EET_TEST_FLOAT2 + offset)) return 1;
 426    if (stuff->d2 != - (EET_TEST_DOUBLE2 + offset)) return 1;
 427
 428    if (stuff->f3 != EET_TEST_FLOAT3 + offset) return 1;
 429    if (stuff->d3 != EET_TEST_DOUBLE3 + offset) return 1;
 430
 431    if (stuff->f4 != EET_TEST_FLOAT2 + offset) return 1;
 432    if (stuff->d4 != EET_TEST_DOUBLE2 + offset) return 1;
 433
 434    if (stuff->uc != EET_TEST_CHAR + offset) return 1;
 435    if (stuff->us != EET_TEST_SHORT + offset) return 1;
 436    if (stuff->ui != (unsigned int) EET_TEST_INT + offset) return 1;
 437    if (stuff->ul != EET_TEST_LONG_LONG + offset) return 1;
 438
 439    for (i = 0; i < 5; ++i)
 440      if (stuff->sarray2[i] != i * 42 + 1)
 441        return 1;
 442
 443    for (i = 0; i < 10; ++i)
 444      _eet_test_basic_check(stuff->sarray1 + i, i);
 445
 446    return 0;
 447 }
 448
 449 static Eina_Bool
 450 func(__UNUSED__ const Eina_Hash *hash, const char *key, void *data, void *fdata)
 451 {
 452    int *res = fdata;
 453
 454    if (strcmp(key, EET_TEST_KEY1) != 0
 455        && strcmp(key, EET_TEST_KEY2) != 0) *res = 1;
 456    if (_eet_test_ex_check(data, 2)) *res = 1;
 457
 458    return EINA_TRUE;
 459 }
 460
 461 static Eina_Bool
 462 func7(__UNUSED__ const Eina_Hash *hash, __UNUSED__ const char *key, void *data, void *fdata)
 463 {
 464    int *res = fdata;
 465    int *val;
 466
 467    val = data;
 468    if (!val) *res = 1;
 469    if (*val != 7) *res = 1;
 470
 471    return EINA_TRUE;
 472 }
 473
 474 START_TEST(eet_test_data_type_encoding_decoding)
 475 {
 476    Eet_Data_Descriptor *edd;
 477    Eet_Test_Ex_Type *result;
 478    void *transfert;
 479    Eet_Data_Descriptor_Class eddc;
 480    Eet_Test_Ex_Type etbt;
 481    int size;
 482    int test;
 483
 484    eet_init();
 485
 486    _eet_test_ex_set(&etbt, 0);
 487    etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
 488    etbt.hash = eina_hash_string_superfast_new(NULL);
 489    eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
 490    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 491    etbt.ihash = eina_hash_string_superfast_new(NULL);
 492    eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
 493
 494    eet_test_setup_eddc(&eddc);
 495    eddc.name = "Eet_Test_Ex_Type";
 496    eddc.size = sizeof(Eet_Test_Ex_Type);
 497
 498    edd = eet_data_descriptor3_new(&eddc);
 499    fail_if(!edd);
 500
 501    _eet_build_ex_descriptor(edd);
 502
 503    transfert = eet_data_descriptor_encode(edd, &etbt, &size);
 504    fail_if(!transfert || size <= 0);
 505
 506    result = eet_data_descriptor_decode(edd, transfert, size);
 507    fail_if(!result);
 508
 509    fail_if(_eet_test_ex_check(result, 0) != 0);
 510    fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
 511    fail_if(eina_list_data_get(result->ilist) == NULL);
 512    fail_if(*((int*)eina_list_data_get(result->ilist)) != 42);
 513
 514    test = 0;
 515    eina_hash_foreach(result->hash, func, &test);
 516    fail_if(test != 0);
 517    eina_hash_foreach(result->ihash, func7, &test);
 518    fail_if(test != 0);
 519
 520    eet_shutdown();
 521 }
 522 END_TEST
 523
 524 static void
 525 append_string(void *data, const char *str)
 526 {
 527    char **string = data;
 528    int length;
 529
 530    if (!data) return ;
 531
 532    length = *string ? strlen(*string) : 0;
 533    *string = realloc(*string, strlen(str) + length + 1);
 534
 535    memcpy((*string) + length, str, strlen(str) + 1);
 536 }
 537
 538 START_TEST(eet_test_data_type_dump_undump)
 539 {
 540    Eet_Data_Descriptor *edd;
 541    Eet_Test_Ex_Type *result;
 542    Eet_Data_Descriptor_Class eddc;
 543    Eet_Test_Ex_Type etbt;
 544    char *transfert1;
 545    char *transfert2;
 546    char *string1;
 547    char *string2;
 548    int size1;
 549    int size2;
 550    int test;
 551
 552    eet_init();
 553
 554    _eet_test_ex_set(&etbt, 0);
 555    etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
 556    etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
 557    etbt.hash = eina_hash_string_superfast_new(NULL);
 558    eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
 559    etbt.hash = eina_hash_string_superfast_new(NULL);
 560    eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
 561    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 562    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 563    etbt.ihash = eina_hash_string_superfast_new(NULL);
 564    eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
 565    etbt.ihash = eina_hash_string_superfast_new(NULL);
 566    eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
 567
 568    eet_test_setup_eddc(&eddc);
 569    eddc.name = "Eet_Test_Ex_Type";
 570    eddc.size = sizeof(Eet_Test_Ex_Type);
 571
 572    edd = eet_data_descriptor3_new(&eddc);
 573    fail_if(!edd);
 574
 575    _eet_build_ex_descriptor(edd);
 576
 577    transfert1 = eet_data_descriptor_encode(edd, &etbt, &size1);
 578    fail_if(!transfert1 || size1 <= 0);
 579
 580    string1 = NULL;
 581    eet_data_text_dump(transfert1, size1, append_string, &string1);
 582    fail_if(!string1);
 583
 584    transfert2 = eet_data_text_undump(string1, strlen(string1), &size2);
 585    fail_if(!transfert2 && size2 <= 0);
 586    fail_if(size1 != size2);
 587
 588    string2 = NULL;
 589    eet_data_text_dump(transfert2, size2, append_string, &string2);
 590    fail_if(!string2);
 591
 592    fail_if(memcmp(transfert1, transfert2, size1) != 0);
 593
 594    result = eet_data_descriptor_decode(edd, transfert2, size2);
 595    fail_if(!result);
 596
 597    fail_if(_eet_test_ex_check(result, 0) != 0);
 598    fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
 599    fail_if(eina_list_data_get(result->ilist) == NULL);
 600    fail_if(*((int*)eina_list_data_get(result->ilist)) != 42);
 601
 602    test = 0;
 603    eina_hash_foreach(result->hash, func, &test);
 604    fail_if(test != 0);
 605    eina_hash_foreach(result->ihash, func7, &test);
 606    fail_if(test != 0);
 607
 608    eet_shutdown();
 609 }
 610 END_TEST
 611
 612 START_TEST(eet_file_simple_write)
 613 {
 614    const char *buffer = "Here is a string of data to save !";
 615    Eet_File *ef;
 616    char *test;
 617    char *file = strdup("/tmp/eet_suite_testXXXXXX");
 618    int size;
 619
 620    eet_init();
 621
 622    mktemp(file);
 623
 624    fail_if(eet_mode_get(NULL) != EET_FILE_MODE_INVALID);
 625
 626    ef = eet_open(file, EET_FILE_MODE_WRITE);
 627    fail_if(!ef);
 628
 629    fail_if(!eet_write(ef, "keys/tests", buffer, strlen(buffer) + 1, 1));
 630
 631    fail_if(eet_mode_get(ef) != EET_FILE_MODE_WRITE);
 632
 633    fail_if(eet_list(ef, "*", &size) != NULL);
 634    fail_if(eet_num_entries(ef) != -1);
 635
 636    eet_close(ef);
 637
 638    /* Test read of simple file */
 639    ef = eet_open(file, EET_FILE_MODE_READ);
 640    fail_if(!ef);
 641
 642    test = eet_read(ef, "keys/tests", &size);
 643    fail_if(!test);
 644    fail_if(size != (int) strlen(buffer) + 1);
 645
 646    fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
 647
 648    fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ);
 649    fail_if(eet_num_entries(ef) != 1);
 650
 651    eet_close(ef);
 652
 653    /* Test eet cache system */
 654    ef = eet_open(file, EET_FILE_MODE_READ);
 655    fail_if(!ef);
 656
 657    test = eet_read(ef, "keys/tests", &size);
 658    fail_if(!test);
 659    fail_if(size != (int) strlen(buffer) + 1);
 660
 661    fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
 662
 663    eet_close(ef);
 664
 665    fail_if(unlink(file) != 0);
 666
 667    eet_shutdown();
 668 }
 669 END_TEST
 670
 671 START_TEST(eet_file_data_test)
 672 {
 673    Eet_Data_Descriptor *edd;
 674    Eet_Test_Ex_Type *result;
 675    Eet_Dictionary *ed;
 676    Eet_File *ef;
 677    char **list;
 678    char *file = strdup("/tmp/eet_suite_testXXXXXX");
 679    Eet_Data_Descriptor_Class eddc;
 680    Eet_Test_Ex_Type etbt;
 681    int size;
 682    int test;
 683
 684    eet_init();
 685
 686    _eet_test_ex_set(&etbt, 0);
 687    etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
 688    etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
 689    etbt.hash = eina_hash_string_superfast_new(NULL);
 690    eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
 691    etbt.hash = eina_hash_string_superfast_new(NULL);
 692    eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
 693    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 694    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 695    etbt.ihash = eina_hash_string_superfast_new(NULL);
 696    eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
 697    etbt.ihash = eina_hash_string_superfast_new(NULL);
 698    eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
 699
 700    eet_test_setup_eddc(&eddc);
 701    eddc.name = "Eet_Test_Ex_Type";
 702    eddc.size = sizeof(Eet_Test_Ex_Type);
 703
 704    edd = eet_data_descriptor3_new(&eddc);
 705    fail_if(!edd);
 706
 707    _eet_build_ex_descriptor(edd);
 708
 709    mktemp(file);
 710
 711    /* Insert an error in etbt. */
 712    etbt.i = 0;
 713
 714    /* Save the encoded data in a file. */
 715    ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
 716    fail_if(!ef);
 717
 718    fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
 719
 720    result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
 721    fail_if(!result);
 722
 723    fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ_WRITE);
 724
 725    /* Test string space. */
 726    ed = eet_dictionary_get(ef);
 727
 728    fail_if(!eet_dictionary_string_check(ed, result->str));
 729    fail_if(eet_dictionary_string_check(ed, result->istr));
 730
 731    eet_close(ef);
 732
 733    /* Attempt to replace etbt by the correct one. */
 734    etbt.i = EET_TEST_INT;
 735
 736    ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
 737    fail_if(!ef);
 738
 739    fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
 740
 741    eet_close(ef);
 742
 743    /* Read back the data. */
 744    ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
 745    fail_if(!ef);
 746
 747    fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY2, &etbt, 1));
 748
 749    result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
 750    fail_if(!result);
 751
 752    /* Test string space. */
 753    ed = eet_dictionary_get(ef);
 754    fail_if(!ed);
 755
 756    fail_if(!eet_dictionary_string_check(ed, result->str));
 757    fail_if(eet_dictionary_string_check(ed, result->istr));
 758
 759    /* Test the resulting data. */
 760    fail_if(_eet_test_ex_check(result, 0) != 0);
 761    fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
 762    fail_if(eina_list_data_get(result->ilist) == NULL);
 763    fail_if(*((int*)eina_list_data_get(result->ilist)) != 42);
 764
 765    test = 0;
 766    eina_hash_foreach(result->hash, func, &test);
 767    fail_if(test != 0);
 768    eina_hash_foreach(result->ihash, func7, &test);
 769    fail_if(test != 0);
 770
 771    list = eet_list(ef, "keys/*", &size);
 772    fail_if(eet_num_entries(ef) != 2);
 773    fail_if(size != 2);
 774    fail_if(!(strcmp(list[0], EET_TEST_FILE_KEY1) == 0 && strcmp(list[1], EET_TEST_FILE_KEY2) == 0)
 775            && !(strcmp(list[0], EET_TEST_FILE_KEY2) == 0 && strcmp(list[1], EET_TEST_FILE_KEY1) == 0));
 776    free(list);
 777
 778    fail_if(eet_delete(ef, NULL) != 0);
 779    fail_if(eet_delete(NULL, EET_TEST_FILE_KEY1) != 0);
 780    fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0);
 781
 782    list = eet_list(ef, "keys/*", &size);
 783    fail_if(size != 1);
 784    fail_if(eet_num_entries(ef) != 1);
 785
 786    /* Test some more wrong case */
 787    fail_if(eet_data_read(ef, edd, "plop") != NULL);
 788    fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) != NULL);
 789
 790    /* Reinsert and reread data */
 791    fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
 792    fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) == NULL);
 793    fail_if(eet_read_direct(ef, EET_TEST_FILE_KEY1, &size) == NULL);
 794
 795    eet_close(ef);
 796
 797    fail_if(unlink(file) != 0);
 798
 799    eet_shutdown();
 800 }
 801 END_TEST
 802
 803 START_TEST(eet_file_data_dump_test)
 804 {
 805    Eet_Data_Descriptor *edd;
 806    Eet_Test_Ex_Type *result;
 807    Eet_Data_Descriptor_Class eddc;
 808    Eet_Test_Ex_Type etbt;
 809    Eet_File *ef;
 810    char *string1;
 811    char *file = strdup("/tmp/eet_suite_testXXXXXX");
 812    int test;
 813
 814    eet_init();
 815
 816    _eet_test_ex_set(&etbt, 0);
 817    etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
 818    etbt.list = eina_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1));
 819    etbt.hash = eina_hash_string_superfast_new(NULL);
 820    eina_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2));
 821    etbt.hash = eina_hash_string_superfast_new(NULL);
 822    eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
 823    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 824    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 825    etbt.ihash = eina_hash_string_superfast_new(NULL);
 826    eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
 827    etbt.ihash = eina_hash_string_superfast_new(NULL);
 828    eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
 829
 830    eet_test_setup_eddc(&eddc);
 831    eddc.name = "Eet_Test_Ex_Type";
 832    eddc.size = sizeof(Eet_Test_Ex_Type);
 833
 834    edd = eet_data_descriptor3_new(&eddc);
 835    fail_if(!edd);
 836
 837    _eet_build_ex_descriptor(edd);
 838
 839    mktemp(file);
 840
 841    /* Save the encoded data in a file. */
 842    ef = eet_open(file, EET_FILE_MODE_WRITE);
 843    fail_if(!ef);
 844
 845    fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 1));
 846
 847    eet_close(ef);
 848
 849    /* Use dump/undump in the middle */
 850    ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
 851    fail_if(!ef);
 852
 853    string1 = NULL;
 854    fail_if(eet_data_dump(ef, EET_TEST_FILE_KEY1, append_string, &string1) != 1);
 855    fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0);
 856    fail_if(!eet_data_undump(ef, EET_TEST_FILE_KEY1, string1, strlen(string1), 1));
 857
 858    eet_close(ef);
 859
 860    /* Test the correctness of the reinsertion. */
 861    ef = eet_open(file, EET_FILE_MODE_READ);
 862    fail_if(!ef);
 863
 864    result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
 865    fail_if(!result);
 866
 867    eet_close(ef);
 868
 869    /* Test the resulting data. */
 870    fail_if(_eet_test_ex_check(result, 0) != 0);
 871    fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
 872    fail_if(eina_list_data_get(result->ilist) == NULL);
 873    fail_if(*((int*)eina_list_data_get(result->ilist)) != 42);
 874
 875    test = 0;
 876    eina_hash_foreach(result->hash, func, &test);
 877    fail_if(test != 0);
 878    eina_hash_foreach(result->ihash, func7, &test);
 879    fail_if(test != 0);
 880
 881    fail_if(unlink(file) != 0);
 882
 883    eet_shutdown();
 884 }
 885 END_TEST
 886
 887 START_TEST(eet_image)
 888 {
 889    Eet_File *ef;
 890    char *file = strdup("/tmp/eet_suite_testXXXXXX");
 891    unsigned int *data;
 892    int compress;
 893    int quality;
 894    int result;
 895    int lossy;
 896    int alpha;
 897    unsigned int w;
 898    unsigned int h;
 899
 900    mktemp(file);
 901
 902    /* Save the encoded data in a file. */
 903    ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
 904    fail_if(!ef);
 905
 906    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "0", test_noalpha.color,
 907                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 908                                  0, 100, 0);
 909    fail_if(result == 0);
 910
 911    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "1", test_noalpha.color,
 912                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 913                                  5, 100, 0);
 914    fail_if(result == 0);
 915
 916    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "2", test_noalpha.color,
 917                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 918                                  9, 100, 0);
 919    fail_if(result == 0);
 920
 921    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "3", test_noalpha.color,
 922                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 923                                  0, 100, 1);
 924    fail_if(result == 0);
 925
 926    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "4", test_noalpha.color,
 927                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 928                                  0, 60, 1);
 929    fail_if(result == 0);
 930
 931    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "5", test_noalpha.color,
 932                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 933                                  0, 10, 1);
 934    fail_if(result == 0);
 935
 936    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "6", test_noalpha.color,
 937                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 938                                  0, 0, 1);
 939    fail_if(result == 0);
 940
 941    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "7", test_alpha.color,
 942                                  test_alpha.w, test_alpha.h, test_alpha.alpha,
 943                                  9, 100, 0);
 944    fail_if(result == 0);
 945
 946    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "8", test_alpha.color,
 947                                  test_alpha.w, test_alpha.h, test_alpha.alpha,
 948                                  0, 80, 1);
 949    fail_if(result == 0);
 950
 951    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "9", test_alpha.color,
 952                                  test_alpha.w, test_alpha.h, test_alpha.alpha,
 953                                  0, 100, 1);
 954    fail_if(result == 0);
 955
 956    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy);
 957    fail_if(data == NULL);
 958    fail_if(w != test_noalpha.w);
 959    fail_if(h != test_noalpha.h);
 960    fail_if(alpha != test_noalpha.alpha);
 961    fail_if(compress != 9);
 962    fail_if(lossy != 0);
 963    fail_if(data[0] != test_noalpha.color[0]);
 964    free(data);
 965
 966    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy);
 967    fail_if(result == 0);
 968    fail_if(w != test_noalpha.w);
 969    fail_if(h != test_noalpha.h);
 970    fail_if(alpha != test_noalpha.alpha);
 971    fail_if(compress != 9);
 972    fail_if(lossy != 0);
 973
 974    eet_close(ef);
 975
 976    /* Test read of image */
 977    ef = eet_open(file, EET_FILE_MODE_READ);
 978    fail_if(!ef);
 979
 980    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "0", &w, &h, &alpha, &compress, &quality, &lossy);
 981    fail_if(result == 0);
 982    fail_if(w != test_noalpha.w);
 983    fail_if(h != test_noalpha.h);
 984    fail_if(alpha != test_noalpha.alpha);
 985    fail_if(compress != 0);
 986    fail_if(lossy != 0);
 987
 988    data = malloc(w * h * 4);
 989    fail_if(data == NULL);
 990    result = eet_data_image_read_to_surface(ef, EET_TEST_FILE_IMAGE "0", 4, 4, data, 2, 2, w * 4, &alpha, &compress, &quality, &lossy);
 991    fail_if(result != 1);
 992    fail_if(alpha != test_noalpha.alpha);
 993    fail_if(compress != 0);
 994    fail_if(quality != 100);
 995    fail_if(lossy != 0);
 996    fail_if(data[0] != test_noalpha.color[4 + 4 * w]);
 997    free(data);
 998
 999    data = malloc(w * h * 4);
1000    fail_if(data == NULL);
1001    result = eet_data_image_read_to_surface(ef, EET_TEST_FILE_IMAGE "0", 0, 0, data, w, h, w * 4, &alpha, &compress, &quality, &lossy);
1002    fail_if(result != 1);
1003    fail_if(alpha != test_noalpha.alpha);
1004    fail_if(compress != 0);
1005    fail_if(quality != 100);
1006    fail_if(lossy != 0);
1007    fail_if(data[0] != test_noalpha.color[0]);
1008    free(data);
1009
1010    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "1", &w, &h, &alpha, &compress, &quality, &lossy);
1011    fail_if(data == NULL);
1012    fail_if(w != test_noalpha.w);
1013    fail_if(h != test_noalpha.h);
1014    fail_if(alpha != test_noalpha.alpha);
1015    fail_if(compress != 5);
1016    fail_if(quality != 100);
1017    fail_if(lossy != 0);
1018    fail_if(data[0] != test_noalpha.color[0]);
1019    free(data);
1020
1021    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy);
1022    fail_if(data == NULL);
1023    fail_if(w != test_noalpha.w);
1024    fail_if(h != test_noalpha.h);
1025    fail_if(alpha != test_noalpha.alpha);
1026    fail_if(compress != 9);
1027    fail_if(lossy != 0);
1028    fail_if(data[0] != test_noalpha.color[0]);
1029    free(data);
1030
1031    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "3", &w, &h, &alpha, &compress, &quality, &lossy);
1032    fail_if(data == NULL);
1033    fail_if(w != test_noalpha.w);
1034    fail_if(h != test_noalpha.h);
1035    fail_if(alpha != test_noalpha.alpha);
1036    fail_if(lossy != 1);
1037    free(data);
1038
1039    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "5", &w, &h, &alpha, &compress, &quality, &lossy);
1040    fail_if(data == NULL);
1041    fail_if(w != test_noalpha.w);
1042    fail_if(h != test_noalpha.h);
1043    fail_if(alpha != test_noalpha.alpha);
1044    fail_if(lossy != 1);
1045    free(data);
1046
1047    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "6", &w, &h, &alpha, &compress, &quality, &lossy);
1048    fail_if(data == NULL);
1049    fail_if(w != test_noalpha.w);
1050    fail_if(h != test_noalpha.h);
1051    fail_if(alpha != test_noalpha.alpha);
1052    fail_if(lossy != 1);
1053    free(data);
1054
1055    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "7", &w, &h, &alpha, &compress, &quality, &lossy);
1056    fail_if(result == 0);
1057    fail_if(w != test_alpha.w);
1058    fail_if(h != test_alpha.h);
1059    fail_if(alpha != test_alpha.alpha);
1060    fail_if(compress != 9);
1061    fail_if(lossy != 0);
1062
1063    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "7", &w, &h, &alpha, &compress, &quality, &lossy);
1064    fail_if(data == NULL);
1065    fail_if(w != test_alpha.w);
1066    fail_if(h != test_alpha.h);
1067    fail_if(alpha != test_alpha.alpha);
1068    fail_if(compress != 9);
1069    fail_if(lossy != 0);
1070    fail_if(data[0] != test_alpha.color[0]);
1071    free(data);
1072
1073    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "9", &w, &h, &alpha, &compress, &quality, &lossy);
1074    fail_if(result == 0);
1075    fail_if(w != test_alpha.w);
1076    fail_if(h != test_alpha.h);
1077    fail_if(alpha != test_alpha.alpha);
1078    fail_if(lossy != 1);
1079
1080    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "9", &w, &h, &alpha, &compress, &quality, &lossy);
1081    fail_if(data == NULL);
1082    fail_if(w != test_alpha.w);
1083    fail_if(h != test_alpha.h);
1084    fail_if(alpha != test_alpha.alpha);
1085    fail_if(lossy != 1);
1086    free(data);
1087
1088    eet_close(ef);
1089
1090    eet_shutdown();
1091 }
1092 END_TEST
1093
1094 #define IM0 0x00112233
1095 #define IM1 0x44556677
1096 #define IM2 0x8899aabb
1097 #define IM3 0xccddeeff
1098
1099 START_TEST(eet_small_image)
1100 {
1101    char *file = strdup("/tmp/eet_suite_testXXXXXX");
1102    unsigned int image[4];
1103    unsigned int *data;
1104    Eet_File *ef;
1105    unsigned int w;
1106    unsigned int h;
1107    int alpha;
1108    int compression;
1109    int quality;
1110    int lossy;
1111    int result;
1112
1113    image[0] = IM0;
1114    image[1] = IM1;
1115    image[2] = IM2;
1116    image[3] = IM3;
1117
1118    eet_init();
1119
1120    mktemp(file);
1121
1122    ef = eet_open(file, EET_FILE_MODE_WRITE);
1123    fail_if(!ef);
1124
1125    result = eet_data_image_write(ef, "/images/test", image, 2, 2, 1, 9, 100, 0);
1126    fail_if(result == 0);
1127
1128    eet_close(ef);
1129
1130    ef = eet_open(file, EET_FILE_MODE_READ);
1131    fail_if(!ef);
1132
1133    data = (unsigned int*) eet_data_image_read(ef, "/images/test", &w, &h, &alpha, &compression, &quality, &lossy);
1134    fail_if(data == NULL);
1135
1136    eet_close(ef);
1137
1138    fail_if(data[0] != IM0);
1139    fail_if(data[1] != IM1);
1140    fail_if(data[2] != IM2);
1141    fail_if(data[3] != IM3);
1142
1143    free(data);
1144
1145    eet_shutdown();
1146 }
1147 END_TEST
1148
1149 START_TEST(eet_identity_simple)
1150 {
1151    const char *buffer = "Here is a string of data to save !";
1152    const void *tmp;
1153    Eet_File *ef;
1154    Eet_Key *k;
1155    char *test;
1156    char *file = strdup("/tmp/eet_suite_testXXXXXX");
1157    int size;
1158    int fd;
1159
1160    eet_init();
1161
1162    mktemp(file);
1163    chdir("src/tests");
1164
1165    /* Sign an eet file. */
1166    ef = eet_open(file, EET_FILE_MODE_WRITE);
1167    fail_if(!ef);
1168
1169    fail_if(!eet_write(ef, "keys/tests", buffer, strlen(buffer) + 1, 0));
1170
1171    k = eet_identity_open("cert.pem", "key.pem", NULL);
1172    fail_if(!k);
1173
1174    fail_if(eet_identity_set(ef, k) != EET_ERROR_NONE);
1175
1176    eet_close(ef);
1177
1178    /* Open a signed file. */
1179    ef = eet_open(file, EET_FILE_MODE_READ);
1180    fail_if(!ef);
1181
1182    test = eet_read(ef, "keys/tests", &size);
1183    fail_if(!test);
1184    fail_if(size != (int) strlen(buffer) + 1);
1185
1186    fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
1187
1188    tmp = eet_identity_x509(ef, &size);
1189    fail_if(tmp == NULL);
1190
1191    eet_close(ef);
1192
1193    /* As we are changing file contain in less than 1s, this could get unnoticed
1194       by eet cache system. */
1195    eet_clearcache();
1196
1197    /* Corrupting the file. */
1198    fd = open(file, O_WRONLY);
1199    fail_if(fd < 0);
1200
1201    fail_if(lseek(fd, 200, SEEK_SET) != 200);
1202    fail_if(write(fd, "42", 2) != 2);
1203    fail_if(lseek(fd, 50, SEEK_SET) != 50);
1204    fail_if(write(fd, "42", 2) != 2);
1205    fail_if(lseek(fd, 88, SEEK_SET) != 88);
1206    fail_if(write(fd, "42", 2) != 2);
1207
1208    close(fd);
1209
1210    /* Attempt to open a modified file. */
1211    ef = eet_open(file, EET_FILE_MODE_READ);
1212    fail_if(ef);
1213
1214    fail_if(unlink(file) != 0);
1215
1216    eet_shutdown();
1217 }
1218 END_TEST
1219
1220 Suite *
1221 eet_suite(void)
1222 {
1223    Suite *s;
1224    TCase *tc;
1225
1226    s = suite_create("Eet");
1227
1228    tc = tcase_create("Eet_Init");
1229    tcase_add_test(tc, eet_test_init);
1230    suite_add_tcase(s, tc);
1231
1232    tc = tcase_create("Eet Data Encoding/Decoding");
1233    tcase_add_test(tc, eet_test_basic_data_type_encoding_decoding);
1234    tcase_add_test(tc, eet_test_data_type_encoding_decoding);
1235    tcase_add_test(tc, eet_test_data_type_dump_undump);
1236    suite_add_tcase(s, tc);
1237
1238    tc = tcase_create("Eet File");
1239    tcase_add_test(tc, eet_file_simple_write);
1240    tcase_add_test(tc, eet_file_data_test);
1241    tcase_add_test(tc, eet_file_data_dump_test);
1242    suite_add_tcase(s, tc);
1243
1244    tc = tcase_create("Eet Image");
1245    tcase_add_test(tc, eet_image);
1246    tcase_add_test(tc, eet_small_image);
1247    suite_add_tcase(s, tc);
1248
1249 #ifdef HAVE_SIGNATURE
1250    tc = tcase_create("Eet Identity");
1251    tcase_add_test(tc, eet_identity_simple);
1252    suite_add_tcase(s, tc);
1253 #endif
1254
1255    return s;
1256 }
1257
1258 int
1259 main(void)
1260 {
1261    Suite   *s;
1262    SRunner *sr;
1263    int      failed_count;
1264
1265    s = eet_suite();
1266    sr = srunner_create(s);
1267    srunner_run_all(sr, CK_NORMAL);
1268    failed_count = srunner_ntests_failed(sr);
1269    srunner_free(sr);
1270
1271    return (failed_count == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
1272 }