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