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