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 char *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 char *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    etbt.hash = eina_hash_string_superfast_new(NULL);
 870    eina_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2));
 871    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 872    etbt.ilist = eina_list_prepend(etbt.ilist, &i42);
 873    etbt.ihash = eina_hash_string_superfast_new(NULL);
 874    eina_hash_add(etbt.ihash, EET_TEST_KEY1, &i7);
 875    etbt.ihash = eina_hash_string_superfast_new(NULL);
 876    eina_hash_add(etbt.ihash, EET_TEST_KEY2, &i7);
 877    etbt.slist = eina_list_prepend(NULL, "test");
 878    etbt.hash = eina_hash_string_superfast_new(NULL);
 879    eina_hash_add(etbt.shash, EET_TEST_KEY1, "test");
 880    memset(&etbt.charray, 0, sizeof(etbt.charray));
 881    etbt.charray[0] = "test";
 882
 883    eet_test_setup_eddc(&eddc);
 884    eddc.name = "Eet_Test_Ex_Type";
 885    eddc.size = sizeof(Eet_Test_Ex_Type);
 886
 887    edd = eet_data_descriptor3_new(&eddc);
 888    fail_if(!edd);
 889
 890    _eet_build_ex_descriptor(edd);
 891
 892    mktemp(file);
 893
 894    /* Save the encoded data in a file. */
 895    ef = eet_open(file, EET_FILE_MODE_WRITE);
 896    fail_if(!ef);
 897
 898    fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0));
 899
 900    eet_close(ef);
 901
 902    /* Use dump/undump in the middle */
 903    ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
 904    fail_if(!ef);
 905
 906    string1 = NULL;
 907    fail_if(eet_data_dump(ef, EET_TEST_FILE_KEY1, append_string, &string1) != 1);
 908    fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0);
 909    fail_if(!eet_data_undump(ef, EET_TEST_FILE_KEY1, string1, strlen(string1), 1));
 910
 911    eet_close(ef);
 912
 913    /* Test the correctness of the reinsertion. */
 914    ef = eet_open(file, EET_FILE_MODE_READ);
 915    fail_if(!ef);
 916
 917    result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1);
 918    fail_if(!result);
 919
 920    eet_close(ef);
 921
 922    /* Test the resulting data. */
 923    fail_if(_eet_test_ex_check(result, 0) != 0);
 924    fail_if(_eet_test_ex_check(eina_list_data_get(result->list), 1) != 0);
 925    fail_if(eina_list_data_get(result->ilist) == NULL);
 926    fail_if(*((int*)eina_list_data_get(result->ilist)) != 42);
 927    fail_if(eina_list_data_get(result->slist) == NULL);
 928    fail_if(strcmp(eina_list_data_get(result->slist), "test") != 0);
 929    fail_if(eina_hash_find(result->shash, EET_TEST_KEY1) == NULL);
 930    fail_if(strcmp(eina_hash_find(result->shash, EET_TEST_KEY1), "test") != 0);
 931    fail_if(strcmp(result->charray[0], "test") != 0);
 932
 933    test = 0;
 934    eina_hash_foreach(result->hash, func, &test);
 935    fail_if(test != 0);
 936    eina_hash_foreach(result->ihash, func7, &test);
 937    fail_if(test != 0);
 938
 939    fail_if(unlink(file) != 0);
 940
 941    eet_shutdown();
 942 }
 943 END_TEST
 944
 945 START_TEST(eet_image)
 946 {
 947    Eet_File *ef;
 948    char *file = strdup("/tmp/eet_suite_testXXXXXX");
 949    unsigned int *data;
 950    int compress;
 951    int quality;
 952    int result;
 953    int lossy;
 954    int alpha;
 955    unsigned int w;
 956    unsigned int h;
 957
 958    mktemp(file);
 959
 960    /* Save the encoded data in a file. */
 961    ef = eet_open(file, EET_FILE_MODE_READ_WRITE);
 962    fail_if(!ef);
 963
 964    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "0", test_noalpha.color,
 965                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 966                                  0, 100, 0);
 967    fail_if(result == 0);
 968
 969    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "1", test_noalpha.color,
 970                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 971                                  5, 100, 0);
 972    fail_if(result == 0);
 973
 974    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "2", test_noalpha.color,
 975                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 976                                  9, 100, 0);
 977    fail_if(result == 0);
 978
 979    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "3", test_noalpha.color,
 980                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 981                                  0, 100, 1);
 982    fail_if(result == 0);
 983
 984    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "4", test_noalpha.color,
 985                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 986                                  0, 60, 1);
 987    fail_if(result == 0);
 988
 989    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "5", test_noalpha.color,
 990                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 991                                  0, 10, 1);
 992    fail_if(result == 0);
 993
 994    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "6", test_noalpha.color,
 995                                  test_noalpha.w, test_noalpha.h, test_noalpha.alpha,
 996                                  0, 0, 1);
 997    fail_if(result == 0);
 998
 999    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "7", test_alpha.color,
1000                                  test_alpha.w, test_alpha.h, test_alpha.alpha,
1001                                  9, 100, 0);
1002    fail_if(result == 0);
1003
1004    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "8", test_alpha.color,
1005                                  test_alpha.w, test_alpha.h, test_alpha.alpha,
1006                                  0, 80, 1);
1007    fail_if(result == 0);
1008
1009    result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "9", test_alpha.color,
1010                                  test_alpha.w, test_alpha.h, test_alpha.alpha,
1011                                  0, 100, 1);
1012    fail_if(result == 0);
1013
1014    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy);
1015    fail_if(data == NULL);
1016    fail_if(w != test_noalpha.w);
1017    fail_if(h != test_noalpha.h);
1018    fail_if(alpha != test_noalpha.alpha);
1019    fail_if(compress != 9);
1020    fail_if(lossy != 0);
1021    fail_if(data[0] != test_noalpha.color[0]);
1022    free(data);
1023
1024    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy);
1025    fail_if(result == 0);
1026    fail_if(w != test_noalpha.w);
1027    fail_if(h != test_noalpha.h);
1028    fail_if(alpha != test_noalpha.alpha);
1029    fail_if(compress != 9);
1030    fail_if(lossy != 0);
1031
1032    eet_close(ef);
1033
1034    /* Test read of image */
1035    ef = eet_open(file, EET_FILE_MODE_READ);
1036    fail_if(!ef);
1037
1038    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "0", &w, &h, &alpha, &compress, &quality, &lossy);
1039    fail_if(result == 0);
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 != 0);
1044    fail_if(lossy != 0);
1045
1046    data = malloc(w * h * 4);
1047    fail_if(data == NULL);
1048    result = eet_data_image_read_to_surface(ef, EET_TEST_FILE_IMAGE "0", 4, 4, data, 2, 2, w * 4, &alpha, &compress, &quality, &lossy);
1049    fail_if(result != 1);
1050    fail_if(alpha != test_noalpha.alpha);
1051    fail_if(compress != 0);
1052    fail_if(quality != 100);
1053    fail_if(lossy != 0);
1054    fail_if(data[0] != test_noalpha.color[4 + 4 * w]);
1055    free(data);
1056
1057    data = malloc(w * h * 4);
1058    fail_if(data == NULL);
1059    result = eet_data_image_read_to_surface(ef, EET_TEST_FILE_IMAGE "0", 0, 0, data, w, h, w * 4, &alpha, &compress, &quality, &lossy);
1060    fail_if(result != 1);
1061    fail_if(alpha != test_noalpha.alpha);
1062    fail_if(compress != 0);
1063    fail_if(quality != 100);
1064    fail_if(lossy != 0);
1065    fail_if(data[0] != test_noalpha.color[0]);
1066    free(data);
1067
1068    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "1", &w, &h, &alpha, &compress, &quality, &lossy);
1069    fail_if(data == NULL);
1070    fail_if(w != test_noalpha.w);
1071    fail_if(h != test_noalpha.h);
1072    fail_if(alpha != test_noalpha.alpha);
1073    fail_if(compress != 5);
1074    fail_if(quality != 100);
1075    fail_if(lossy != 0);
1076    fail_if(data[0] != test_noalpha.color[0]);
1077    free(data);
1078
1079    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy);
1080    fail_if(data == NULL);
1081    fail_if(w != test_noalpha.w);
1082    fail_if(h != test_noalpha.h);
1083    fail_if(alpha != test_noalpha.alpha);
1084    fail_if(compress != 9);
1085    fail_if(lossy != 0);
1086    fail_if(data[0] != test_noalpha.color[0]);
1087    free(data);
1088
1089    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "3", &w, &h, &alpha, &compress, &quality, &lossy);
1090    fail_if(data == NULL);
1091    fail_if(w != test_noalpha.w);
1092    fail_if(h != test_noalpha.h);
1093    fail_if(alpha != test_noalpha.alpha);
1094    fail_if(lossy != 1);
1095    free(data);
1096
1097    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "5", &w, &h, &alpha, &compress, &quality, &lossy);
1098    fail_if(data == NULL);
1099    fail_if(w != test_noalpha.w);
1100    fail_if(h != test_noalpha.h);
1101    fail_if(alpha != test_noalpha.alpha);
1102    fail_if(lossy != 1);
1103    free(data);
1104
1105    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "6", &w, &h, &alpha, &compress, &quality, &lossy);
1106    fail_if(data == NULL);
1107    fail_if(w != test_noalpha.w);
1108    fail_if(h != test_noalpha.h);
1109    fail_if(alpha != test_noalpha.alpha);
1110    fail_if(lossy != 1);
1111    free(data);
1112
1113    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "7", &w, &h, &alpha, &compress, &quality, &lossy);
1114    fail_if(result == 0);
1115    fail_if(w != test_alpha.w);
1116    fail_if(h != test_alpha.h);
1117    fail_if(alpha != test_alpha.alpha);
1118    fail_if(compress != 9);
1119    fail_if(lossy != 0);
1120
1121    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "7", &w, &h, &alpha, &compress, &quality, &lossy);
1122    fail_if(data == NULL);
1123    fail_if(w != test_alpha.w);
1124    fail_if(h != test_alpha.h);
1125    fail_if(alpha != test_alpha.alpha);
1126    fail_if(compress != 9);
1127    fail_if(lossy != 0);
1128    fail_if(data[0] != test_alpha.color[0]);
1129    free(data);
1130
1131    result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "9", &w, &h, &alpha, &compress, &quality, &lossy);
1132    fail_if(result == 0);
1133    fail_if(w != test_alpha.w);
1134    fail_if(h != test_alpha.h);
1135    fail_if(alpha != test_alpha.alpha);
1136    fail_if(lossy != 1);
1137
1138    data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "9", &w, &h, &alpha, &compress, &quality, &lossy);
1139    fail_if(data == NULL);
1140    fail_if(w != test_alpha.w);
1141    fail_if(h != test_alpha.h);
1142    fail_if(alpha != test_alpha.alpha);
1143    fail_if(lossy != 1);
1144    free(data);
1145
1146    eet_close(ef);
1147
1148    eet_shutdown();
1149 }
1150 END_TEST
1151
1152 #define IM0 0x00112233
1153 #define IM1 0x44556677
1154 #define IM2 0x8899aabb
1155 #define IM3 0xccddeeff
1156
1157 START_TEST(eet_small_image)
1158 {
1159    char *file = strdup("/tmp/eet_suite_testXXXXXX");
1160    unsigned int image[4];
1161    unsigned int *data;
1162    Eet_File *ef;
1163    unsigned int w;
1164    unsigned int h;
1165    int alpha;
1166    int compression;
1167    int quality;
1168    int lossy;
1169    int result;
1170
1171    image[0] = IM0;
1172    image[1] = IM1;
1173    image[2] = IM2;
1174    image[3] = IM3;
1175
1176    eet_init();
1177
1178    mktemp(file);
1179
1180    ef = eet_open(file, EET_FILE_MODE_WRITE);
1181    fail_if(!ef);
1182
1183    result = eet_data_image_write(ef, "/images/test", image, 2, 2, 1, 9, 100, 0);
1184    fail_if(result == 0);
1185
1186    eet_close(ef);
1187
1188    ef = eet_open(file, EET_FILE_MODE_READ);
1189    fail_if(!ef);
1190
1191    data = (unsigned int*) eet_data_image_read(ef, "/images/test", &w, &h, &alpha, &compression, &quality, &lossy);
1192    fail_if(data == NULL);
1193
1194    eet_close(ef);
1195
1196    fail_if(data[0] != IM0);
1197    fail_if(data[1] != IM1);
1198    fail_if(data[2] != IM2);
1199    fail_if(data[3] != IM3);
1200
1201    free(data);
1202
1203    eet_shutdown();
1204 }
1205 END_TEST
1206
1207 START_TEST(eet_identity_simple)
1208 {
1209    const char *buffer = "Here is a string of data to save !";
1210    const void *tmp;
1211    Eet_File *ef;
1212    Eet_Key *k;
1213    char *test;
1214    char *file = strdup("/tmp/eet_suite_testXXXXXX");
1215    int size;
1216    int fd;
1217
1218    eet_init();
1219
1220    mktemp(file);
1221    chdir("src/tests");
1222
1223    /* Sign an eet file. */
1224    ef = eet_open(file, EET_FILE_MODE_WRITE);
1225    fail_if(!ef);
1226
1227    fail_if(!eet_write(ef, "keys/tests", buffer, strlen(buffer) + 1, 0));
1228
1229    k = eet_identity_open("cert.pem", "key.pem", NULL);
1230    fail_if(!k);
1231
1232    fail_if(eet_identity_set(ef, k) != EET_ERROR_NONE);
1233
1234    eet_close(ef);
1235
1236    /* Open a signed file. */
1237    ef = eet_open(file, EET_FILE_MODE_READ);
1238    fail_if(!ef);
1239
1240    test = eet_read(ef, "keys/tests", &size);
1241    fail_if(!test);
1242    fail_if(size != (int) strlen(buffer) + 1);
1243
1244    fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
1245
1246    tmp = eet_identity_x509(ef, &size);
1247    fail_if(tmp == NULL);
1248
1249    eet_close(ef);
1250
1251    /* As we are changing file contain in less than 1s, this could get unnoticed
1252       by eet cache system. */
1253    eet_clearcache();
1254
1255    /* Corrupting the file. */
1256    fd = open(file, O_WRONLY);
1257    fail_if(fd < 0);
1258
1259    fail_if(lseek(fd, 200, SEEK_SET) != 200);
1260    fail_if(write(fd, "42", 2) != 2);
1261    fail_if(lseek(fd, 50, SEEK_SET) != 50);
1262    fail_if(write(fd, "42", 2) != 2);
1263    fail_if(lseek(fd, 88, SEEK_SET) != 88);
1264    fail_if(write(fd, "42", 2) != 2);
1265
1266    close(fd);
1267
1268    /* Attempt to open a modified file. */
1269    ef = eet_open(file, EET_FILE_MODE_READ);
1270    fail_if(ef);
1271
1272    fail_if(unlink(file) != 0);
1273
1274    eet_shutdown();
1275 }
1276 END_TEST
1277
1278 START_TEST(eet_cipher_decipher_simple)
1279 {
1280    const char *buffer = "Here is a string of data to save !";
1281    const char *key = "This is a crypto key";
1282    const char *key_bad = "This is another crypto key";
1283    Eet_File *ef;
1284    char *test;
1285    char *file = strdup("/tmp/eet_suite_testXXXXXX");
1286    int size;
1287    int fd;
1288
1289    eet_init();
1290
1291    mktemp(file);
1292    chdir("src/tests");
1293
1294    /* Crypt an eet file. */
1295    ef = eet_open(file, EET_FILE_MODE_WRITE);
1296    fail_if(!ef);
1297
1298    fail_if(!eet_write_cipher(ef, "keys/tests", buffer, strlen(buffer) + 1, 0, key));
1299
1300    eet_close(ef);
1301
1302    /* Decrypt an eet file. */
1303    ef = eet_open(file, EET_FILE_MODE_READ);
1304    fail_if(!ef);
1305
1306    test = eet_read_cipher(ef, "keys/tests", &size, key);
1307    fail_if(!test);
1308    fail_if(size != (int) strlen(buffer) + 1);
1309
1310    fail_if(memcmp(test, buffer, strlen(buffer) + 1) != 0);
1311
1312    eet_close(ef);
1313
1314    /* Decrypt an eet file. */
1315    ef = eet_open(file, EET_FILE_MODE_READ);
1316    fail_if(!ef);
1317
1318    test = eet_read_cipher(ef, "keys/tests", &size, key_bad);
1319
1320    if (size == (int) strlen(buffer) + 1)
1321      fail_if(memcmp(test, buffer, strlen(buffer) + 1) == 0);
1322
1323    eet_close(ef);
1324
1325    fail_if(unlink(file) != 0);
1326
1327    eet_shutdown();
1328 }
1329 END_TEST
1330
1331
1332 Suite *
1333 eet_suite(void)
1334 {
1335    Suite *s;
1336    TCase *tc;
1337
1338    s = suite_create("Eet");
1339
1340    tc = tcase_create("Eet_Init");
1341    tcase_add_test(tc, eet_test_init);
1342    suite_add_tcase(s, tc);
1343
1344    tc = tcase_create("Eet Data Encoding/Decoding");
1345    tcase_add_test(tc, eet_test_basic_data_type_encoding_decoding);
1346    tcase_add_test(tc, eet_test_data_type_encoding_decoding);
1347    tcase_add_test(tc, eet_test_data_type_dump_undump);
1348    suite_add_tcase(s, tc);
1349
1350    tc = tcase_create("Eet File");
1351    tcase_add_test(tc, eet_file_simple_write);
1352    tcase_add_test(tc, eet_file_data_test);
1353    tcase_add_test(tc, eet_file_data_dump_test);
1354    suite_add_tcase(s, tc);
1355
1356    tc = tcase_create("Eet Image");
1357    tcase_add_test(tc, eet_image);
1358    tcase_add_test(tc, eet_small_image);
1359    suite_add_tcase(s, tc);
1360
1361 #ifdef HAVE_SIGNATURE
1362    tc = tcase_create("Eet Identity");
1363    tcase_add_test(tc, eet_identity_simple);
1364    suite_add_tcase(s, tc);
1365 #endif
1366
1367 #ifdef HAVE_CIPHER
1368    tc = tcase_create("Eet Cipher");
1369    tcase_add_test(tc, eet_cipher_decipher_simple);
1370    suite_add_tcase(s, tc);
1371 #endif
1372
1373    return s;
1374 }
1375
1376 int
1377 main(void)
1378 {
1379    Suite   *s;
1380    SRunner *sr;
1381    int      failed_count;
1382
1383    s = eet_suite();
1384    sr = srunner_create(s);
1385    srunner_run_all(sr, CK_NORMAL);
1386    failed_count = srunner_ntests_failed(sr);
1387    srunner_free(sr);
1388
1389    return (failed_count == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
1390 }