diff --git a/legacy/eet/ChangeLog b/legacy/eet/ChangeLog index 6d491b8c11..41eb3e1542 100644 --- a/legacy/eet/ChangeLog +++ b/legacy/eet/ChangeLog @@ -8,4 +8,37 @@ (IS_SIMPLE_TYPE) to alloc the correct amount (using the correct type offset). Also fixed a hash (EET_G_HASH) of simple types too. +2008-05-14 Cedric BAIL + * Fix convertion from a text to a hash (EET_G_HASH). + + * Fix inlined string (EET_T_INLINED_STRING) dump/undump by introducing + the new word for the parser 'inlined'. + +2008-05-15 Cedric BAIL + + * Fix a typo preventing the parsing of unsigned int (EET_T_UINT). + + * Fix group of simple type by implicitly creating a structure with + the simple type in it. + + * Remove dead code handling group of simple type and put assert + instead. + +2008-05-16 Cedric BAIL + + * Fix eet_data_descriptor3_new as it purpose was to introduce + str_direct_alloc/str_direct_free usage. Application should now receive + direct pointer to read only (mmaped) string. + + * Fix EET_FILE_MODE_READ_WRITE when file doesn't exist. + + * Fix some miss use of efn->offset. + + * Introduce unit test in EFL. The current set provide an overall + coverage rate of 2111 of 2607 lines (81.0%) for eet. It helped + finding and fixing the bugs of the last three days. + The test suite is based on library check. At this time we need + cvs version, look at http://check.sourceforge.net/ to find it. + The covering is done by lcov and we also need the cvs version that + you can found at http://ltp.sourceforge.net/coverage/lcov.php. diff --git a/legacy/eet/INSTALL b/legacy/eet/INSTALL index 97806b21b8..aafe372ea2 100644 --- a/legacy/eet/INSTALL +++ b/legacy/eet/INSTALL @@ -39,3 +39,11 @@ after the mingw32ce case 3) run configure with the option --host=arm-wince-cegcc + +NOTE: If you want to be able to run make check, you need library check + from http://check.sourceforge.net/. + +NOTE: If you want to be able to run coverage test over eet, you will need + lcov from http://ltp.sourceforge.net/coverage/lcov.php. + +NOTE: For coverage support you also need check support. diff --git a/legacy/eet/Makefile.am b/legacy/eet/Makefile.am index 0fc3ca44bf..76993fd1f0 100644 --- a/legacy/eet/Makefile.am +++ b/legacy/eet/Makefile.am @@ -38,3 +38,49 @@ gendoc pkgconfigdir = $(libdir)/pkgconfig pkgconfig_DATA = eet.pc + + +if EET_ENABLE_TESTS + +check-local: + @./src/tests/eet_suite + +else + +check-local: + @echo "reconfigure with --enable-tests" + +endif + +if EET_ENABLE_COVERAGE +lcov-reset: + @rm -rf coverage + @find . -name "*.gcda" -exec rm {} \; + @lcov --directory . --zerocounters + +lcov-report: + @mkdir coverage + @lcov --compat-libtool --directory . --capture --output-file coverage/coverage.info + @lcov -l coverage/coverage.info | grep -v "`cd $(top_srcdir) && pwd`" | cut -d: -f1 > coverage/remove + @lcov -r coverage/coverage.info `cat coverage/remove` > coverage/coverage.cleaned.info + @rm coverage/remove + @mv coverage/coverage.cleaned.info coverage/coverage.info + @genhtml -t "$(PACKAGE_STRING)" -o coverage coverage/coverage.info + +coverage: + @make lcov-reset + @make check + @make lcov-report + +clean-local: + @rm -rf coverage +else +lcov-reset: + @echo "reconfigure with --enable-gcov" + +lcov-report: + @echo "reconfigure with --enable-gcov" + +coverage: + @echo "reconfigure with --enable-tests --enable-gcov" +endif diff --git a/legacy/eet/configure.in b/legacy/eet/configure.in index 8c704385da..a8f5b7bb4b 100644 --- a/legacy/eet/configure.in +++ b/legacy/eet/configure.in @@ -29,6 +29,8 @@ SNAP=`echo $PACKAGE_VERSION | awk -F. '{printf("%s", $4);}'` version_info=`expr $VMAJ + $VMIN`":$VMIC:$VMIN" AC_SUBST(version_info) +PKG_PROG_PKG_CONFIG + WIN32_CFLAGS="" WIN32_LIBS="" lt_no_undefined="" @@ -115,6 +117,73 @@ int main (int argc, char **argv) { ], AC_MSG_WARN([Cannot check when cross-compiling -- assuming null is okay]) ) +dnl Unit Tests + +AC_ARG_ENABLE(tests, + [AC_HELP_STRING([--enable-tests], [Enable tests @<:@default=no@:>@])], + [ + if test "x${enableval}" = "xyes" ; then + enable_tests="yes" + else + enable_tests="no" + fi + ], + [enable_tests="no"] +) +AC_MSG_CHECKING([if tests are built]) +AC_MSG_RESULT([${enable_tests}]) + +if test "x${enable_tests}" = "xyes" ; then + PKG_CHECK_MODULES([CHECK], + [check >= 0.9.5], + [dummy="yes"], + [enable_tests="no"] + ) +fi + +AM_CONDITIONAL(EET_ENABLE_TESTS, test "x${enable_tests}" = "xyes") + +dnl Coverage + +AC_ARG_ENABLE(coverage, + [AC_HELP_STRING([--enable-coverage], + [compile with coverage profiling instrumentation @<:@default=no@:>@])], + [ + if test "x${enableval}" = "xyes" ; then + enable_coverage="yes" + else + enable_coverage="no" + fi], + [enable_coverage="no"] +) +AC_MSG_CHECKING([whether to use profiling instrumentation]) +AC_MSG_RESULT($enable_coverage) + +if test "x$enable_tests" = "xno" -a "x$enable_coverage" = "xyes"; then + enable_coverage="no" +fi + +if test "x$enable_coverage" = "xyes"; then + AC_CHECK_PROG(have_lcov, + [lcov], + [yes], + [no] + ) + if test "x$have_lcov" = "xyes" ; then + COVERAGE_CFLAGS="-fprofile-arcs -ftest-coverage" + COVERAGE_LIBS="-lgcov" +dnl remove any optimisation flag and force debug symbols + CFLAGS="-g -O0" + else + AC_MSG_WARN([lcov is not found, disable profiling instrumentation]) + enable_coverage="no" + fi +fi +AC_SUBST(COVERAGE_CFLAGS) +AC_SUBST(COVERAGE_LIBS) + +AM_CONDITIONAL(EET_ENABLE_COVERAGE, test "x$enable_coverage" = "xyes") + #AM_CHECK_DOXYGEN() AC_OUTPUT([ @@ -124,6 +193,7 @@ eet.c src/Makefile src/lib/Makefile src/bin/Makefile +src/tests/Makefile README eet.spec ]) @@ -141,6 +211,9 @@ echo "------------------------------------------------------------------------" echo echo "Configuration Options Summary:" echo +echo " Tests................: ${enable_tests}" +echo " Coverage.............: ${enable_coverage}" +echo echo " Compilation..........: make" echo echo " Installation.........: make install" diff --git a/legacy/eet/src/Makefile.am b/legacy/eet/src/Makefile.am index a8590b2f0d..a6fc38fef0 100644 --- a/legacy/eet/src/Makefile.am +++ b/legacy/eet/src/Makefile.am @@ -1,3 +1,3 @@ MAINTAINERCLEANFILES = Makefile.in -SUBDIRS = lib bin +SUBDIRS = lib bin tests diff --git a/legacy/eet/src/lib/Makefile.am b/legacy/eet/src/lib/Makefile.am index c2e3c67881..4141f7ab23 100644 --- a/legacy/eet/src/lib/Makefile.am +++ b/legacy/eet/src/lib/Makefile.am @@ -7,7 +7,8 @@ AM_CPPFLAGS = \ -DPACKAGE_BIN_DIR=\"$(bindir)\" \ -DPACKAGE_LIB_DIR=\"$(libdir)\" \ -DPACKAGE_DATA_DIR=\"$(datadir)/$(PACKAGE)\" \ -@EVIL_CFLAGS@ +@EVIL_CFLAGS@ \ +@COVERAGE_CFLAGS@ include_HEADERS = Eet.h @@ -22,8 +23,11 @@ eet_dictionary.c \ eet_utils.c libeet_la_CFLAGS = @WIN32_CFLAGS@ -libeet_la_LIBADD = @EVIL_LIBS@ @WIN32_LIBS@ -lz -ljpeg @fnmatch_libs@ -lm +libeet_la_LIBADD = @COVERAGE_LIBS@ @EVIL_LIBS@ @WIN32_LIBS@ -lz -ljpeg @fnmatch_libs@ -lm libeet_la_LDFLAGS = @lt_no_undefined@ @lt_enable_auto_import@ -version-info @version_info@ libeet_la_DEPENDENCIES = $(top_builddir)/config.h EXTRA_DIST = Eet_private.h + +clean-local: + @rm -rf *.gcno diff --git a/legacy/eet/src/tests/Makefile.am b/legacy/eet/src/tests/Makefile.am new file mode 100644 index 0000000000..11dbc614ab --- /dev/null +++ b/legacy/eet/src/tests/Makefile.am @@ -0,0 +1,17 @@ +MAINTAINERCLEANFILES = Makefile.in + +AM_CPPFLAGS = \ +-I$(top_srcdir)/src/lib \ +@CHECK_CFLAGS@ + + +if EET_ENABLE_TESTS + +check_PROGRAMS = eet_suite + +eet_suite_SOURCES = eet_suite.c eet_data_suite.c +eet_suite_LDADD = @CHECK_LIBS@ $(top_builddir)/src/lib/libeet.la + +EXTRA_DIST = eet_suite.h + +endif diff --git a/legacy/eet/src/tests/TODO b/legacy/eet/src/tests/TODO new file mode 100644 index 0000000000..da5fa1bd19 --- /dev/null +++ b/legacy/eet/src/tests/TODO @@ -0,0 +1,3 @@ +The purpose of the current test is to check the validity of the result in a +normal environment. But we should at some point also test the robustness of +this library when for example malloc fail. diff --git a/legacy/eet/src/tests/eet_data_suite.c b/legacy/eet/src/tests/eet_data_suite.c new file mode 100644 index 0000000000..697bff353a --- /dev/null +++ b/legacy/eet/src/tests/eet_data_suite.c @@ -0,0 +1,163 @@ +#include +#include + +#include "eet_suite.h" + +static char* +_eet_str_direct_alloc(const char *str) +{ + return (char*) str; +} + +static void +_eet_str_direct_free(const char *str) +{ +} + +/* Internal list stuff. */ +struct _Eet_List +{ + Eet_List *next; + const void *data; +}; +Eet_List* +eet_list_prepend(Eet_List *list, const void *data) +{ + Eet_List *new; + + new = malloc(sizeof (Eet_List)); + if (!new) return list; + + new->next = list; + new->data = data; + + return new; +} +Eet_List* +eet_list_next(Eet_List *list) +{ + if (!list) return NULL; + + return list->next; +} +void* +eet_list_data(Eet_List *list) +{ + if (!list) return NULL; + + return (void*) list->data; +} +void +eet_list_free(Eet_List *list) +{ + while (list) + { + Eet_List *current = list; + + list = list->next; + free(current); + } +} + +/* Internal hash stuff */ +struct _Eet_Hash +{ + Eet_List *bucket[256]; +}; +typedef struct _Eet_Hash_Item Eet_Hash_Item; +struct _Eet_Hash_Item +{ + const void *data; + char *key; +}; +static inline int +_eet_hash_gen(const char *key) +{ + unsigned int hash_num = 5381; + const unsigned char *ptr; + + if (!key) return 0; + for (ptr = (unsigned char *)key; *ptr; ptr++) + hash_num = (hash_num * 33) ^ *ptr; + + hash_num &= 0xff; + return (int)hash_num; +} +void +eet_hash_foreach(const Eet_Hash *hash, int (*func) (const Eet_Hash *hash, const char *key, void *data, void *fdata), const void *fdata) +{ + int i; + + if (!hash) return ; + + for (i = 0; i < 256; ++i) + { + Eet_List *over; + + for (over = hash->bucket[i]; over; over = eet_list_next(over)) + { + Eet_Hash_Item *item = eet_list_data(over); + + if (!func(hash, item->key, (void*) item->data, (void*) fdata)) return ; + } + } +} +Eet_Hash* +eet_hash_add(Eet_Hash *hash, const char *key, const void *data) +{ + Eet_Hash_Item *item; + Eet_List *find; + int index; + + if (!hash) hash = calloc(1, sizeof (Eet_Hash)); + if (!hash) return NULL; + + item = malloc(sizeof (Eet_Hash_Item) + strlen(key) + 1); + if (!item) return hash; + + item->data = data; + item->key = (char*)(item + 1); + strcpy(item->key, key); + + hash->bucket[_eet_hash_gen(key)] = eet_list_prepend(hash->bucket[_eet_hash_gen(key)], item); + + return hash; +} +void +eet_hash_free(Eet_Hash *hash) +{ + int i; + + if (!hash) return ; + + for (i = 0; i < 256; ++i) + { + Eet_List *over; + + for (over = hash->bucket[i]; over; over = eet_list_next(over)) + free(eet_list_data(over)); + eet_list_free(hash->bucket[i]); + } + + free(hash); +} + +void +eet_test_setup_eddc(Eet_Data_Descriptor_Class *eddc) +{ + eddc->version = EET_DATA_DESCRIPTOR_CLASS_VERSION; + eddc->func.mem_alloc = NULL; + eddc->func.mem_free = NULL; + eddc->func.str_alloc = NULL; + eddc->func.str_free = NULL; + eddc->func.list_next = eet_list_next; + eddc->func.list_append = eet_list_prepend; + eddc->func.list_data = eet_list_data; + eddc->func.list_free = eet_list_free; + eddc->func.hash_foreach = eet_hash_foreach; + eddc->func.hash_add = eet_hash_add; + eddc->func.hash_free = eet_hash_free; + eddc->func.str_direct_alloc = _eet_str_direct_alloc; + eddc->func.str_direct_free = _eet_str_direct_free; +} + diff --git a/legacy/eet/src/tests/eet_suite.c b/legacy/eet/src/tests/eet_suite.c new file mode 100644 index 0000000000..fece6795de --- /dev/null +++ b/legacy/eet/src/tests/eet_suite.c @@ -0,0 +1,1044 @@ +#include +#include +#include + +#include + +#include "eet_suite.h" + +START_TEST(eet_test_init) +{ + int ret; + + ret = eet_init(); + fail_if(ret != 1); + + ret = eet_shutdown(); + fail_if(ret != 0); +} +END_TEST + +typedef struct _Eet_Test_Basic_Type Eet_Test_Basic_Type; +struct _Eet_Test_Basic_Type +{ + char c; + short s; + int i; + long long l; + char *str; + char *istr; + float f1; + float f2; + double d; + unsigned char uc; + unsigned short us; + unsigned int ui; + unsigned long long ul; +}; + +#define EET_TEST_CHAR 0x42 +#define EET_TEST_SHORT 0x4224 +#define EET_TEST_INT 0x42211224 +#define EET_TEST_LONG_LONG 0x84CB42211224BC48 +#define EET_TEST_STRING "my little test with escape \\\"" +#define EET_TEST_KEY1 "key1" +#define EET_TEST_KEY2 "key2" +#define EET_TEST_FLOAT 123.45689 +#define EET_TEST_FLOAT2 1.0 +#define EET_TEST_FLOAT3 0.25 +#define EET_TEST_FLOAT4 0.0001234 +#define EET_TEST_DOUBLE 123456789.9876543210 +#define EET_TEST_DOUBLE2 1.0 +#define EET_TEST_DOUBLE3 0.25 +#define EET_TEST_FILE_KEY1 "keys/data/1" +#define EET_TEST_FILE_KEY2 "keys/data/2" +#define EET_TEST_FILE_IMAGE "keys/images/" + +typedef struct _Eet_Test_Image Eet_Test_Image; +struct _Eet_Test_Image +{ + unsigned int w; + unsigned int h; + unsigned int alpha; + unsigned int color[]; +}; + +static const Eet_Test_Image test_noalpha = { + 8, 8, 0, + { + 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, + 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, + 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, + 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, + 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, + 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, + 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, + 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA + } +}; + +static const Eet_Test_Image test_alpha = { + 8, 8, 1, + { + 0x0FAA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x0F110000, + 0x0000AA00, 0x0F0000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x0F110000, 0x00AA0000, + 0x000000AA, 0x00110000, 0x0FAA0000, 0x0000AA00, 0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, + 0x00110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA, + 0x00AA0000, 0x0000AA00, 0x000000AA, 0x0F110000, 0x0FAA0000, 0x0000AA00, 0x000000AA, 0x00110000, + 0x0000AA00, 0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA, 0x00110000, 0x00AA0000, + 0x000000AA, 0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x0FAA0000, 0x0000AA00, + 0x0F110000, 0x00AA0000, 0x0000AA00, 0x000000AA, 0x00110000, 0x00AA0000, 0x0000AA00, 0x0F0000AA + } +}; + + +START_TEST(eet_test_basic_data_type_encoding_decoding) +{ + Eet_Data_Descriptor *edd; + Eet_Test_Basic_Type *result; + Eet_Data_Descriptor_Class eddc; + Eet_Test_Basic_Type etbt; + void *transfert; + int size; + float tmp; + + etbt.c = EET_TEST_CHAR; + etbt.s = EET_TEST_SHORT; + etbt.i = EET_TEST_INT; + etbt.l = EET_TEST_LONG_LONG; + etbt.str = EET_TEST_STRING; + etbt.istr = EET_TEST_STRING; + etbt.f1 = - EET_TEST_FLOAT; + etbt.d = - EET_TEST_DOUBLE; + etbt.f2 = EET_TEST_FLOAT4; + etbt.uc = EET_TEST_CHAR; + etbt.us = EET_TEST_SHORT; + etbt.ui = EET_TEST_INT; + etbt.ul = EET_TEST_LONG_LONG; + + eet_test_setup_eddc(&eddc); + eddc.name = "Eet_Test_Basic_Type"; + eddc.size = sizeof(Eet_Test_Basic_Type); + + edd = eet_data_descriptor2_new(&eddc); + fail_if(!edd); + + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "c", c, EET_T_CHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "s", s, EET_T_SHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "i", i, EET_T_INT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "l", l, EET_T_LONG_LONG); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "str", str, EET_T_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "istr", istr, EET_T_INLINED_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "f1", f1, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "f2", f2, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "d", d, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "uc", uc, EET_T_UCHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "us", us, EET_T_USHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "ui", ui, EET_T_UINT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Basic_Type, "ul", ul, EET_T_ULONG_LONG); + + transfert = eet_data_descriptor_encode(edd, &etbt, &size); + fail_if(!transfert || size <= 0); + + result = eet_data_descriptor_decode(edd, transfert, size); + fail_if(!result); + + fail_if(result->c != EET_TEST_CHAR); + fail_if(result->s != EET_TEST_SHORT); + fail_if(result->i != EET_TEST_INT); + fail_if(result->l != EET_TEST_LONG_LONG); + fail_if(strcmp(result->str, EET_TEST_STRING) != 0); + fail_if(strcmp(result->istr, EET_TEST_STRING) != 0); + fail_if(result->uc != EET_TEST_CHAR); + fail_if(result->us != EET_TEST_SHORT); + fail_if(result->ui != EET_TEST_INT); + fail_if(result->ul != EET_TEST_LONG_LONG); + + tmp = (result->f1 + EET_TEST_FLOAT); + if (tmp < 0) tmp = -tmp; + fail_if(tmp > 0.005); + + tmp = (result->f2 - EET_TEST_FLOAT4); + if (tmp < 0) tmp = -tmp; + fail_if(tmp > 0.005); + + tmp = (result->d + EET_TEST_DOUBLE); + if (tmp < 0) tmp = -tmp; + fail_if(tmp > 0.00005); + + free(result->str); + free(result); + + eet_data_descriptor_free(edd); +} +END_TEST + +typedef struct _Eet_Test_Ex_Type Eet_Test_Ex_Type; +struct _Eet_Test_Ex_Type +{ + char c; + short s; + int i; + unsigned long long l; + char *str; + char *istr; + float f1; + float f2; + float f3; + float f4; + double d1; + double d2; + double d3; + double d4; + Eet_List *list; + Eet_Hash *hash; + Eet_List *ilist; + Eet_Hash *ihash; + unsigned char uc; + unsigned short us; + unsigned int ui; + unsigned long long ul; +}; + +static int i42 = 42; +static int i7 = 7; + +static Eet_Test_Ex_Type* +_eet_test_ex_set(Eet_Test_Ex_Type *res, int offset) +{ + if (!res) res = malloc( sizeof(Eet_Test_Ex_Type)); + if (!res) return NULL; + + res->c = EET_TEST_CHAR + offset; + res->s = EET_TEST_SHORT + offset; + res->i = EET_TEST_INT + offset; + res->l = EET_TEST_LONG_LONG + offset; + res->str = EET_TEST_STRING; + res->istr = EET_TEST_STRING; + res->f1 = EET_TEST_FLOAT + offset; + res->f2 = -(EET_TEST_FLOAT2 + offset); + res->f3 = EET_TEST_FLOAT3 + offset; + res->f4 = EET_TEST_FLOAT2 + offset; + res->d1 = EET_TEST_DOUBLE + offset; + res->d2 = -(EET_TEST_DOUBLE2 + offset); + res->d3 = EET_TEST_DOUBLE3 + offset; + res->d4 = EET_TEST_DOUBLE2 + offset; + res->list = NULL; + res->hash = NULL; + res->ilist = NULL; + res->ihash = NULL; + res->uc = EET_TEST_CHAR + offset; + res->us = EET_TEST_SHORT + offset; + res->ui = EET_TEST_INT + offset; + res->ul = EET_TEST_LONG_LONG + offset; + + return res; +} + +static int +_eet_test_ex_check(Eet_Test_Ex_Type *stuff, int offset) +{ + double tmp; + + if (!stuff) return 1; + + if (stuff->c != EET_TEST_CHAR + offset) return 1; + if (stuff->s != EET_TEST_SHORT + offset) return 1; + if (stuff->i != EET_TEST_INT + offset) return 1; + if (stuff->l != EET_TEST_LONG_LONG + offset) return 1; + if (strcmp(stuff->str, EET_TEST_STRING) != 0) return 1; + if (strcmp(stuff->istr, EET_TEST_STRING) != 0) return 1; + + tmp = stuff->f1 - (EET_TEST_FLOAT + offset); + if (tmp < 0) tmp = -tmp; + if (tmp > 0.005) return 1; + + tmp = stuff->d1 - (EET_TEST_DOUBLE + offset); + if (tmp < 0) tmp = -tmp; + if (tmp > 0.00005) return 1; + + if (stuff->f2 != - (EET_TEST_FLOAT2 + offset)) return 1; + if (stuff->d2 != - (EET_TEST_DOUBLE2 + offset)) return 1; + + if (stuff->f3 != EET_TEST_FLOAT3 + offset) return 1; + if (stuff->d3 != EET_TEST_DOUBLE3 + offset) return 1; + + if (stuff->f4 != EET_TEST_FLOAT2 + offset) return 1; + if (stuff->d4 != EET_TEST_DOUBLE2 + offset) return 1; + + if (stuff->uc != EET_TEST_CHAR + offset) return 1; + if (stuff->us != EET_TEST_SHORT + offset) return 1; + if (stuff->ui != EET_TEST_INT + offset) return 1; + if (stuff->ul != EET_TEST_LONG_LONG + offset) return 1; + + return 0; +} + +static int +func(const Eet_Hash *hash, const char *key, void *data, void *fdata) +{ + int *res = fdata; + + if (strcmp(key, EET_TEST_KEY1) != 0 + && strcmp(key, EET_TEST_KEY2) != 0) *res = 1; + if (_eet_test_ex_check(data, 2)) *res = 1; + + return 1; +} + +static int +func7(const Eet_Hash *hash, const char *key, void *data, void *fdata) +{ + int *res = fdata; + int *val; + + val = data; + if (!val) *res = 1; + if (*val != 7) *res = 1; + + return 1; +} + +START_TEST(eet_test_data_type_encoding_decoding) +{ + Eet_Data_Descriptor *edd; + Eet_Test_Ex_Type *result; + Eet_Test_Ex_Type *tmp; + void *transfert; + Eet_Data_Descriptor_Class eddc; + Eet_Test_Ex_Type etbt; + int size; + int test; + + _eet_test_ex_set(&etbt, 0); + etbt.list = eet_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1)); + etbt.hash = eet_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2)); + etbt.ilist = eet_list_prepend(etbt.ilist, &i42); + etbt.ihash = eet_hash_add(etbt.ihash, EET_TEST_KEY1, &i7); + + eet_test_setup_eddc(&eddc); + eddc.name = "Eet_Test_Ex_Type"; + eddc.size = sizeof(Eet_Test_Ex_Type); + + edd = eet_data_descriptor3_new(&eddc); + fail_if(!edd); + + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "c", c, EET_T_CHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "s", s, EET_T_SHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "i", i, EET_T_INT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "l", l, EET_T_LONG_LONG); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "str", str, EET_T_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "istr", istr, EET_T_INLINED_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f1", f1, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f2", f2, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f3", f3, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f4", f4, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d1", d1, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d2", d2, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d3", d3, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d4", d4, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "uc", uc, EET_T_UCHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "us", us, EET_T_USHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ui", ui, EET_T_UINT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ul", ul, EET_T_ULONG_LONG); + EET_DATA_DESCRIPTOR_ADD_LIST(edd, Eet_Test_Ex_Type, "list", list, edd); + EET_DATA_DESCRIPTOR_ADD_HASH(edd, Eet_Test_Ex_Type, "hash", hash, edd); + eet_data_descriptor_element_add(edd, "ilist", EET_T_INT, EET_G_LIST, + (char *)(&(etbt.ilist)) - (char *)(&(etbt)), + 0, NULL, NULL); + eet_data_descriptor_element_add(edd, "ihash", EET_T_INT, EET_G_HASH, + (char *)(&(etbt.ihash)) - (char *)(&(etbt)), + 0, NULL, NULL); + + transfert = eet_data_descriptor_encode(edd, &etbt, &size); + fail_if(!transfert || size <= 0); + + result = eet_data_descriptor_decode(edd, transfert, size); + fail_if(!result); + + fail_if(_eet_test_ex_check(result, 0) != 0); + fail_if(_eet_test_ex_check(eet_list_data(result->list), 1) != 0); + fail_if(eet_list_data(result->ilist) == NULL); + fail_if(*((int*)eet_list_data(result->ilist)) != 42); + + test = 0; + eet_hash_foreach(result->hash, func, &test); + fail_if(test != 0); + eet_hash_foreach(result->ihash, func7, &test); + fail_if(test != 0); +} +END_TEST + +static void +append_string(void *data, const char *str) +{ + char **string = data; + int length; + + if (!data) return ; + + length = *string ? strlen(*string) : 0; + *string = realloc(*string, strlen(str) + length + 1); + + memcpy((*string) + length, str, strlen(str) + 1); +} + +START_TEST(eet_test_data_type_dump_undump) +{ + Eet_Data_Descriptor *edd; + Eet_Test_Ex_Type *result; + Eet_Test_Ex_Type *tmp; + Eet_Data_Descriptor_Class eddc; + Eet_Test_Ex_Type etbt; + char *transfert1; + char *transfert2; + char *string1; + char *string2; + int size1; + int size2; + int test; + + int i; + + _eet_test_ex_set(&etbt, 0); + etbt.list = eet_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1)); + etbt.list = eet_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1)); + etbt.hash = eet_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2)); + etbt.hash = eet_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2)); + etbt.ilist = eet_list_prepend(etbt.ilist, &i42); + etbt.ilist = eet_list_prepend(etbt.ilist, &i42); + etbt.ihash = eet_hash_add(etbt.ihash, EET_TEST_KEY1, &i7); + etbt.ihash = eet_hash_add(etbt.ihash, EET_TEST_KEY2, &i7); + + eet_test_setup_eddc(&eddc); + eddc.name = "Eet_Test_Ex_Type"; + eddc.size = sizeof(Eet_Test_Ex_Type); + + edd = eet_data_descriptor3_new(&eddc); + fail_if(!edd); + + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "c", c, EET_T_CHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "s", s, EET_T_SHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "i", i, EET_T_INT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "l", l, EET_T_LONG_LONG); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "str", str, EET_T_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "istr", istr, EET_T_INLINED_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f1", f1, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f2", f2, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f3", f3, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f4", f4, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d1", d1, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d2", d2, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d3", d3, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d4", d4, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "uc", uc, EET_T_UCHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "us", us, EET_T_USHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ui", ui, EET_T_UINT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ul", ul, EET_T_ULONG_LONG); + EET_DATA_DESCRIPTOR_ADD_LIST(edd, Eet_Test_Ex_Type, "list", list, edd); + EET_DATA_DESCRIPTOR_ADD_HASH(edd, Eet_Test_Ex_Type, "hash", hash, edd); + eet_data_descriptor_element_add(edd, "ilist", EET_T_INT, EET_G_LIST, + (char *)(&(etbt.ilist)) - (char *)(&(etbt)), + 0, NULL, NULL); + eet_data_descriptor_element_add(edd, "ihash", EET_T_INT, EET_G_HASH, + (char *)(&(etbt.ihash)) - (char *)(&(etbt)), + 0, NULL, NULL); + + transfert1 = eet_data_descriptor_encode(edd, &etbt, &size1); + fail_if(!transfert1 || size1 <= 0); + + string1 = NULL; + eet_data_text_dump(transfert1, size1, append_string, &string1); + fail_if(!string1); + + transfert2 = eet_data_text_undump(string1, strlen(string1), &size2); + fail_if(!transfert2 && size2 <= 0); + fail_if(size1 != size2); + + string2 = NULL; + eet_data_text_dump(transfert2, size2, append_string, &string2); + fail_if(!string2); + + fail_if(memcmp(transfert1, transfert2, size1) != 0); + + result = eet_data_descriptor_decode(edd, transfert2, size2); + fail_if(!result); + + fail_if(_eet_test_ex_check(result, 0) != 0); + fail_if(_eet_test_ex_check(eet_list_data(result->list), 1) != 0); + fail_if(eet_list_data(result->ilist) == NULL); + fail_if(*((int*)eet_list_data(result->ilist)) != 42); + + test = 0; + eet_hash_foreach(result->hash, func, &test); + fail_if(test != 0); + eet_hash_foreach(result->ihash, func7, &test); + fail_if(test != 0); +} +END_TEST + +START_TEST(eet_file_simple_write) +{ + const char *buffer = "Here is a string of data to save !"; + Eet_File *ef; + char *test; + char *file = strdup("/tmp/eet_suite_testXXXXXX"); + int size; + + mktemp(file); + + fail_if(eet_mode_get(NULL) != EET_FILE_MODE_INVALID); + + ef = eet_open(file, EET_FILE_MODE_WRITE); + fail_if(!ef); + + fail_if(!eet_write(ef, "keys/tests", buffer, sizeof(*buffer), 1)); + + fail_if(eet_mode_get(ef) != EET_FILE_MODE_WRITE); + + fail_if(eet_list(ef, "*", &size) != NULL); + fail_if(eet_num_entries(ef) != -1); + + eet_close(ef); + + /* Test read of simple file */ + ef = eet_open(file, EET_FILE_MODE_READ); + fail_if(!ef); + + test = eet_read(ef, "keys/tests", &size); + fail_if(!test); + fail_if(size != sizeof(*buffer)); + + fail_if(memcmp(test, buffer, sizeof(*buffer)) != 0); + + fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ); + fail_if(eet_num_entries(ef) != 1); + + eet_close(ef); + + /* Test eet cache system */ + ef = eet_open(file, EET_FILE_MODE_READ); + fail_if(!ef); + + test = eet_read(ef, "keys/tests", &size); + fail_if(!test); + fail_if(size != sizeof(*buffer)); + + fail_if(memcmp(test, buffer, sizeof(*buffer)) != 0); + + eet_close(ef); + + fail_if(unlink(file) != 0); +} +END_TEST + +START_TEST(eet_file_data_test) +{ + const char *buffer = "Here is a string of data to save !"; + Eet_Data_Descriptor *edd; + Eet_Test_Ex_Type *result; + Eet_Test_Ex_Type *tmp; + Eet_Dictionary *ed; + Eet_File *ef; + char **list; + char *transfert1; + char *transfert2; + char *string1; + char *string2; + char *file = strdup("/tmp/eet_suite_testXXXXXX"); + Eet_Data_Descriptor_Class eddc; + Eet_Test_Ex_Type etbt; + int size; + int size1; + int size2; + int test; + + int i; + + _eet_test_ex_set(&etbt, 0); + etbt.list = eet_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1)); + etbt.list = eet_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1)); + etbt.hash = eet_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2)); + etbt.hash = eet_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2)); + etbt.ilist = eet_list_prepend(etbt.ilist, &i42); + etbt.ilist = eet_list_prepend(etbt.ilist, &i42); + etbt.ihash = eet_hash_add(etbt.ihash, EET_TEST_KEY1, &i7); + etbt.ihash = eet_hash_add(etbt.ihash, EET_TEST_KEY2, &i7); + + eet_test_setup_eddc(&eddc); + eddc.name = "Eet_Test_Ex_Type"; + eddc.size = sizeof(Eet_Test_Ex_Type); + + edd = eet_data_descriptor3_new(&eddc); + fail_if(!edd); + + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "c", c, EET_T_CHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "s", s, EET_T_SHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "i", i, EET_T_INT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "l", l, EET_T_LONG_LONG); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "str", str, EET_T_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "istr", istr, EET_T_INLINED_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f1", f1, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f2", f2, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f3", f3, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f4", f4, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d1", d1, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d2", d2, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d3", d3, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d4", d4, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "uc", uc, EET_T_UCHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "us", us, EET_T_USHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ui", ui, EET_T_UINT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ul", ul, EET_T_ULONG_LONG); + EET_DATA_DESCRIPTOR_ADD_LIST(edd, Eet_Test_Ex_Type, "list", list, edd); + EET_DATA_DESCRIPTOR_ADD_HASH(edd, Eet_Test_Ex_Type, "hash", hash, edd); + eet_data_descriptor_element_add(edd, "ilist", EET_T_INT, EET_G_LIST, + (char *)(&(etbt.ilist)) - (char *)(&(etbt)), + 0, NULL, NULL); + eet_data_descriptor_element_add(edd, "ihash", EET_T_INT, EET_G_HASH, + (char *)(&(etbt.ihash)) - (char *)(&(etbt)), + 0, NULL, NULL); + + mktemp(file); + + /* Insert an error in etbt. */ + etbt.i = 0; + + /* Save the encoded data in a file. */ + ef = eet_open(file, EET_FILE_MODE_READ_WRITE); + fail_if(!ef); + + fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 1)); + + result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1); + fail_if(!result); + + fail_if(eet_mode_get(ef) != EET_FILE_MODE_READ_WRITE); + + /* Test string space. */ + ed = eet_dictionary_get(ef); + + fail_if(!eet_dictionary_string_check(ed, result->str)); + fail_if(eet_dictionary_string_check(ed, result->istr)); + + eet_close(ef); + + /* Attempt to replace etbt by the correct one. */ + etbt.i = EET_TEST_INT; + + ef = eet_open(file, EET_FILE_MODE_READ_WRITE); + fail_if(!ef); + + fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0)); + + eet_close(ef); + + /* Read back the data. */ + ef = eet_open(file, EET_FILE_MODE_READ_WRITE); + fail_if(!ef); + + fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY2, &etbt, 1)); + + result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1); + fail_if(!result); + + /* Test string space. */ + ed = eet_dictionary_get(ef); + fail_if(!ed); + + fail_if(!eet_dictionary_string_check(ed, result->str)); + fail_if(eet_dictionary_string_check(ed, result->istr)); + + /* Test the resulting data. */ + fail_if(_eet_test_ex_check(result, 0) != 0); + fail_if(_eet_test_ex_check(eet_list_data(result->list), 1) != 0); + fail_if(eet_list_data(result->ilist) == NULL); + fail_if(*((int*)eet_list_data(result->ilist)) != 42); + + test = 0; + eet_hash_foreach(result->hash, func, &test); + fail_if(test != 0); + eet_hash_foreach(result->ihash, func7, &test); + fail_if(test != 0); + + list = eet_list(ef, "keys/*", &size); + fail_if(eet_num_entries(ef) != 2); + fail_if(size != 2); + fail_if(!(strcmp(list[0], EET_TEST_FILE_KEY1) == 0 && strcmp(list[1], EET_TEST_FILE_KEY2) == 0) + && !(strcmp(list[0], EET_TEST_FILE_KEY2) == 0 && strcmp(list[1], EET_TEST_FILE_KEY1) == 0)); + free(list); + + fail_if(eet_delete(ef, NULL) != 0); + fail_if(eet_delete(NULL, EET_TEST_FILE_KEY1) != 0); + fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0); + + list = eet_list(ef, "keys/*", &size); + fail_if(size != 1); + fail_if(eet_num_entries(ef) != 1); + + /* Test some more wrong case */ + fail_if(eet_data_read(ef, edd, "plop") != NULL); + fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) != NULL); + + /* Reinsert and reread data */ + fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 0)); + fail_if(eet_data_read(ef, edd, EET_TEST_FILE_KEY1) == NULL); + fail_if(eet_read_direct(ef, EET_TEST_FILE_KEY1, &size) == NULL); + + eet_close(ef); + + fail_if(unlink(file) != 0); +} +END_TEST + +START_TEST(eet_file_data_dump_test) +{ + const char *buffer = "Here is a string of data to save !"; + Eet_Data_Descriptor *edd; + Eet_Test_Ex_Type *result; + Eet_Test_Ex_Type *tmp; + Eet_Data_Descriptor_Class eddc; + Eet_Test_Ex_Type etbt; + Eet_File *ef; + char *transfert1; + char *transfert2; + char *string1; + char *string2; + char *file = strdup("/tmp/eet_suite_testXXXXXX"); + int size; + int size1; + int size2; + int test; + + int i; + + _eet_test_ex_set(&etbt, 0); + etbt.list = eet_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1)); + etbt.list = eet_list_prepend(etbt.list, _eet_test_ex_set(NULL, 1)); + etbt.hash = eet_hash_add(etbt.hash, EET_TEST_KEY1, _eet_test_ex_set(NULL, 2)); + etbt.hash = eet_hash_add(etbt.hash, EET_TEST_KEY2, _eet_test_ex_set(NULL, 2)); + etbt.ilist = eet_list_prepend(etbt.ilist, &i42); + etbt.ilist = eet_list_prepend(etbt.ilist, &i42); + etbt.ihash = eet_hash_add(etbt.ihash, EET_TEST_KEY1, &i7); + etbt.ihash = eet_hash_add(etbt.ihash, EET_TEST_KEY2, &i7); + + eet_test_setup_eddc(&eddc); + eddc.name = "Eet_Test_Ex_Type"; + eddc.size = sizeof(Eet_Test_Ex_Type); + + edd = eet_data_descriptor3_new(&eddc); + fail_if(!edd); + + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "c", c, EET_T_CHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "s", s, EET_T_SHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "i", i, EET_T_INT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "l", l, EET_T_LONG_LONG); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "str", str, EET_T_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "istr", istr, EET_T_INLINED_STRING); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f1", f1, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f2", f2, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f3", f3, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "f4", f4, EET_T_FLOAT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d1", d1, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d2", d2, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d3", d3, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "d4", d4, EET_T_DOUBLE); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "uc", uc, EET_T_UCHAR); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "us", us, EET_T_USHORT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ui", ui, EET_T_UINT); + EET_DATA_DESCRIPTOR_ADD_BASIC(edd, Eet_Test_Ex_Type, "ul", ul, EET_T_ULONG_LONG); + EET_DATA_DESCRIPTOR_ADD_LIST(edd, Eet_Test_Ex_Type, "list", list, edd); + EET_DATA_DESCRIPTOR_ADD_HASH(edd, Eet_Test_Ex_Type, "hash", hash, edd); + eet_data_descriptor_element_add(edd, "ilist", EET_T_INT, EET_G_LIST, + (char *)(&(etbt.ilist)) - (char *)(&(etbt)), + 0, NULL, NULL); + eet_data_descriptor_element_add(edd, "ihash", EET_T_INT, EET_G_HASH, + (char *)(&(etbt.ihash)) - (char *)(&(etbt)), + 0, NULL, NULL); + + mktemp(file); + + /* Save the encoded data in a file. */ + ef = eet_open(file, EET_FILE_MODE_WRITE); + fail_if(!ef); + + fail_if(!eet_data_write(ef, edd, EET_TEST_FILE_KEY1, &etbt, 1)); + + eet_close(ef); + + /* Use dump/undump in the middle */ + ef = eet_open(file, EET_FILE_MODE_READ_WRITE); + fail_if(!ef); + + string1 = NULL; + fail_if(eet_data_dump(ef, EET_TEST_FILE_KEY1, append_string, &string1) != 1); + fail_if(eet_delete(ef, EET_TEST_FILE_KEY1) == 0); + fail_if(!eet_data_undump(ef, EET_TEST_FILE_KEY1, string1, strlen(string1), 1)); + + eet_close(ef); + + /* Test the correctness of the reinsertion. */ + ef = eet_open(file, EET_FILE_MODE_READ); + fail_if(!ef); + + result = eet_data_read(ef, edd, EET_TEST_FILE_KEY1); + fail_if(!transfert1); + + eet_close(ef); + + /* Test the resulting data. */ + fail_if(_eet_test_ex_check(result, 0) != 0); + fail_if(_eet_test_ex_check(eet_list_data(result->list), 1) != 0); + fail_if(eet_list_data(result->ilist) == NULL); + fail_if(*((int*)eet_list_data(result->ilist)) != 42); + + test = 0; + eet_hash_foreach(result->hash, func, &test); + fail_if(test != 0); + eet_hash_foreach(result->ihash, func7, &test); + fail_if(test != 0); + + fail_if(unlink(file) != 0); +} +END_TEST + +START_TEST(eet_image) +{ + Eet_File *ef; + char *file = strdup("/tmp/eet_suite_testXXXXXX"); + int *data; + int compress; + int quality; + int result; + int lossy; + int alpha; + int w; + int h; + + mktemp(file); + + /* Save the encoded data in a file. */ + ef = eet_open(file, EET_FILE_MODE_READ_WRITE); + fail_if(!ef); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "0", test_noalpha.color, + test_noalpha.w, test_noalpha.h, test_noalpha.alpha, + 0, 100, 0); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "1", test_noalpha.color, + test_noalpha.w, test_noalpha.h, test_noalpha.alpha, + 5, 100, 0); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "2", test_noalpha.color, + test_noalpha.w, test_noalpha.h, test_noalpha.alpha, + 9, 100, 0); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "3", test_noalpha.color, + test_noalpha.w, test_noalpha.h, test_noalpha.alpha, + 0, 100, 1); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "4", test_noalpha.color, + test_noalpha.w, test_noalpha.h, test_noalpha.alpha, + 0, 60, 1); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "5", test_noalpha.color, + test_noalpha.w, test_noalpha.h, test_noalpha.alpha, + 0, 10, 1); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "6", test_noalpha.color, + test_noalpha.w, test_noalpha.h, test_noalpha.alpha, + 0, 0, 1); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "7", test_alpha.color, + test_alpha.w, test_alpha.h, test_alpha.alpha, + 9, 100, 0); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "8", test_alpha.color, + test_alpha.w, test_alpha.h, test_alpha.alpha, + 0, 80, 1); + fail_if(result == 0); + + result = eet_data_image_write(ef, EET_TEST_FILE_IMAGE "9", test_alpha.color, + test_alpha.w, test_alpha.h, test_alpha.alpha, + 0, 100, 1); + fail_if(result == 0); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(compress != 9); + fail_if(lossy != 0); + fail_if(data[0] != test_noalpha.color[0]); + free(data); + + result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(result == 0); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(compress != 9); + fail_if(lossy != 0); + + eet_close(ef); + + /* Test read of image */ + ef = eet_open(file, EET_FILE_MODE_READ); + fail_if(!ef); + + result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "0", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(result == 0); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(compress != 0); + fail_if(lossy != 0); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "0", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(compress != 0); + fail_if(quality != 100); + fail_if(lossy != 0); + fail_if(data[0] != test_noalpha.color[0]); + free(data); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "1", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(compress != 5); + fail_if(quality != 100); + fail_if(lossy != 0); + fail_if(data[0] != test_noalpha.color[0]); + free(data); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "2", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(compress != 9); + fail_if(lossy != 0); + fail_if(data[0] != test_noalpha.color[0]); + free(data); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "3", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(lossy != 1); + free(data); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "5", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(lossy != 1); + free(data); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "6", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_noalpha.w); + fail_if(h != test_noalpha.h); + fail_if(alpha != test_noalpha.alpha); + fail_if(lossy != 1); + free(data); + + result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "7", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(result == 0); + fail_if(w != test_alpha.w); + fail_if(h != test_alpha.h); + fail_if(alpha != test_alpha.alpha); + fail_if(compress != 9); + fail_if(lossy != 0); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "7", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_alpha.w); + fail_if(h != test_alpha.h); + fail_if(alpha != test_alpha.alpha); + fail_if(compress != 9); + fail_if(lossy != 0); + fail_if(data[0] != test_alpha.color[0]); + free(data); + + result = eet_data_image_header_read(ef, EET_TEST_FILE_IMAGE "9", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(result == 0); + fail_if(w != test_alpha.w); + fail_if(h != test_alpha.h); + fail_if(alpha != test_alpha.alpha); + fail_if(lossy != 1); + + data = eet_data_image_read(ef, EET_TEST_FILE_IMAGE "9", &w, &h, &alpha, &compress, &quality, &lossy); + fail_if(data == NULL); + fail_if(w != test_alpha.w); + fail_if(h != test_alpha.h); + fail_if(alpha != test_alpha.alpha); + fail_if(lossy != 1); + free(data); + + eet_close(ef); +} +END_TEST + +Suite * +eet_suite(void) +{ + Suite *s; + TCase *tc; + + s = suite_create("Eet"); + + tc = tcase_create("Eet_Init"); + tcase_add_test(tc, eet_test_init); + suite_add_tcase(s, tc); + + tc = tcase_create("Eet Data Encoding/Decoding"); + tcase_add_test(tc, eet_test_basic_data_type_encoding_decoding); + tcase_add_test(tc, eet_test_data_type_encoding_decoding); + tcase_add_test(tc, eet_test_data_type_dump_undump); + suite_add_tcase(s, tc); + + tc = tcase_create("Eet File"); + tcase_add_test(tc, eet_file_simple_write); + tcase_add_test(tc, eet_file_data_test); + tcase_add_test(tc, eet_file_data_dump_test); + suite_add_tcase(s, tc); + + tc = tcase_create("Eet Image"); + tcase_add_test(tc, eet_image); + suite_add_tcase(s, tc); + + return s; +} + +int +main(void) +{ + Suite *s; + SRunner *sr; + int failed_count; + + s = eet_suite(); + sr = srunner_create(s); + srunner_run_all(sr, CK_NORMAL); + failed_count = srunner_ntests_failed(sr); + srunner_free(sr); + + return (failed_count == 0) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/legacy/eet/src/tests/eet_suite.h b/legacy/eet/src/tests/eet_suite.h new file mode 100644 index 0000000000..4b979a2386 --- /dev/null +++ b/legacy/eet/src/tests/eet_suite.h @@ -0,0 +1,21 @@ +#ifndef _EET_SUITE_H +# define _EET_SUITE_H + +#include "Eet.h" + +typedef struct _Eet_List Eet_List; +typedef struct _Eet_Hash Eet_Hash; + +Eet_List* eet_list_prepend(Eet_List *list, const void *data); +Eet_List* eet_list_next(Eet_List *list); +void* eet_list_data(Eet_List *list); +void eet_list_free(Eet_List *list); + +void eet_hash_foreach(const Eet_Hash *hash, int (*func) (const Eet_Hash *hash, const char *key, void *data, void *fdata), const void *fdata); +Eet_Hash* eet_hash_add(Eet_Hash *hash, const char *key, const void *data); +void eet_hash_free(Eet_Hash *hash); + +void eet_test_setup_eddc(Eet_Data_Descriptor_Class *eddc); + + +#endif /* _EET_SUITE_H */