From b6d43ec705ec42206d23866131dd24d33d684978 Mon Sep 17 00:00:00 2001 From: dimmus Date: Mon, 7 Aug 2023 22:01:59 +0500 Subject: [PATCH] tests: eina - replaced deprecated fail_* functions The fail* APIs have been deprecated since check version 0.9.9 a decade ago. Solved warnings about having too many arguments for the supplied format string. --- src/tests/eina/eina_test_abi.c | 84 +- src/tests/eina/eina_test_accessor.c | 134 +- src/tests/eina/eina_test_array.c | 64 +- src/tests/eina/eina_test_barrier.c | 12 +- src/tests/eina/eina_test_benchmark.c | 10 +- src/tests/eina/eina_test_bezier.c | 24 +- src/tests/eina/eina_test_binbuf.c | 150 +- src/tests/eina/eina_test_binshare.c | 32 +- src/tests/eina/eina_test_clist.c | 22 +- src/tests/eina/eina_test_convert.c | 84 +- src/tests/eina/eina_test_counter.c | 20 +- src/tests/eina/eina_test_cow.c | 38 +- src/tests/eina/eina_test_crc.c | 4 +- src/tests/eina/eina_test_error.c | 36 +- src/tests/eina/eina_test_file.c | 214 +- src/tests/eina/eina_test_fp.c | 8 +- src/tests/eina/eina_test_freeq.c | 40 +- src/tests/eina/eina_test_hash.c | 154 +- src/tests/eina/eina_test_inarray.c | 136 +- src/tests/eina/eina_test_inlist.c | 64 +- src/tests/eina/eina_test_iterator.c | 186 +- src/tests/eina/eina_test_lalloc.c | 22 +- src/tests/eina/eina_test_list.c | 256 +- src/tests/eina/eina_test_lock.c | 112 +- src/tests/eina/eina_test_log.c | 62 +- src/tests/eina/eina_test_magic.c | 20 +- src/tests/eina/eina_test_main.c | 4 +- src/tests/eina/eina_test_matrix.c | 114 +- src/tests/eina/eina_test_matrixsparse.c | 180 +- src/tests/eina/eina_test_mempool.c | 14 +- src/tests/eina/eina_test_module.c | 16 +- src/tests/eina/eina_test_quadtree.c | 16 +- src/tests/eina/eina_test_quaternion.c | 104 +- src/tests/eina/eina_test_rbtree.c | 34 +- src/tests/eina/eina_test_rectangle.c | 66 +- src/tests/eina/eina_test_sched.c | 2 +- src/tests/eina/eina_test_simple_xml_parser.c | 36 +- src/tests/eina/eina_test_slice.c | 158 +- src/tests/eina/eina_test_slstr.c | 4 +- src/tests/eina/eina_test_str.c | 282 +- src/tests/eina/eina_test_strbuf.c | 330 +- src/tests/eina/eina_test_stringshare.c | 106 +- src/tests/eina/eina_test_tiler.c | 112 +- src/tests/eina/eina_test_tmpstr.c | 12 +- src/tests/eina/eina_test_trash.c | 18 +- src/tests/eina/eina_test_ustr.c | 228 +- src/tests/eina/eina_test_ustringshare.c | 34 +- src/tests/eina/eina_test_value.c | 2808 +++++++++--------- src/tests/eina/eina_test_vector.c | 98 +- src/tests/eina/eina_test_xattr.c | 76 +- 50 files changed, 3421 insertions(+), 3419 deletions(-) diff --git a/src/tests/eina/eina_test_abi.c b/src/tests/eina/eina_test_abi.c index e1e1423d03..ad2c2f21c9 100644 --- a/src/tests/eina/eina_test_abi.c +++ b/src/tests/eina/eina_test_abi.c @@ -51,80 +51,80 @@ EFL_START_TEST(eina_unicode_utf8) /* Valid utf-8 cases */ /* First possible sequence of a certain length */ ind = 0; - fail_if((eina_unicode_utf8_get_next("\x00", &ind) != 0x00) || + ck_assert((eina_unicode_utf8_get_next("\x00", &ind) != 0x00) || (ind != 0)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\x01", &ind) != 0x01) || + ck_assert((eina_unicode_utf8_get_next("\x01", &ind) != 0x01) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xC2\x80", &ind) != 0x80) || + ck_assert((eina_unicode_utf8_get_next("\xC2\x80", &ind) != 0x80) || (ind != 2)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xE0\xA0\x80", &ind) != 0x800) || + ck_assert((eina_unicode_utf8_get_next("\xE0\xA0\x80", &ind) != 0x800) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF0\x90\x80\x80", &ind) != 0x10000) || + ck_assert((eina_unicode_utf8_get_next("\xF0\x90\x80\x80", &ind) != 0x10000) || (ind != 4)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF8\x88\x80\x80\x80", &ind) != 0x200000) || (ind != 5)); + ck_assert((eina_unicode_utf8_get_next("\xF8\x88\x80\x80\x80", &ind) != 0x200000) || (ind != 5)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xFC\x84\x80\x80\x80\x80", &ind) != 0x4000000) || (ind != 6)); + ck_assert((eina_unicode_utf8_get_next("\xFC\x84\x80\x80\x80\x80", &ind) != 0x4000000) || (ind != 6)); /* Last possible sequence of a certain length */ ind = 0; - fail_if((eina_unicode_utf8_get_next("\x7F", &ind) != 0x7F) || + ck_assert((eina_unicode_utf8_get_next("\x7F", &ind) != 0x7F) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xDF\xBF", &ind) != 0x7FF) || + ck_assert((eina_unicode_utf8_get_next("\xDF\xBF", &ind) != 0x7FF) || (ind != 2)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xEF\xBF\xBF", &ind) != 0xFFFF) || + ck_assert((eina_unicode_utf8_get_next("\xEF\xBF\xBF", &ind) != 0xFFFF) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF7\xBF\xBF\xBF", &ind) != 0x1FFFFF) || + ck_assert((eina_unicode_utf8_get_next("\xF7\xBF\xBF\xBF", &ind) != 0x1FFFFF) || (ind != 4)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xFB\xBF\xBF\xBF\xBF", &ind) != 0x3FFFFFF) || (ind != 5)); + ck_assert((eina_unicode_utf8_get_next("\xFB\xBF\xBF\xBF\xBF", &ind) != 0x3FFFFFF) || (ind != 5)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xFD\xBF\xBF\xBF\xBF\xBF", &ind) != 0x7FFFFFFF) || (ind != 6)); + ck_assert((eina_unicode_utf8_get_next("\xFD\xBF\xBF\xBF\xBF\xBF", &ind) != 0x7FFFFFFF) || (ind != 6)); /* Other boundary conditions */ ind = 0; - fail_if((eina_unicode_utf8_get_next("\xED\x9F\xBF", &ind) != 0xD7FF) || + ck_assert((eina_unicode_utf8_get_next("\xED\x9F\xBF", &ind) != 0xD7FF) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xEE\x80\x80", &ind) != 0xE000) || + ck_assert((eina_unicode_utf8_get_next("\xEE\x80\x80", &ind) != 0xE000) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xEF\xBF\xBD", &ind) != 0xFFFD) || + ck_assert((eina_unicode_utf8_get_next("\xEF\xBF\xBD", &ind) != 0xFFFD) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF4\x8F\xBF\xBF", &ind) != 0x10FFFF) || + ck_assert((eina_unicode_utf8_get_next("\xF4\x8F\xBF\xBF", &ind) != 0x10FFFF) || (ind != 4)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF4\x90\x80\x80", &ind) != 0x110000) || + ck_assert((eina_unicode_utf8_get_next("\xF4\x90\x80\x80", &ind) != 0x110000) || (ind != 4)); /* Error cases */ /* Standalone continuation bytes */ ind = 0; - fail_if((eina_unicode_utf8_get_next("\x80", &ind) != 0xDC80) || + ck_assert((eina_unicode_utf8_get_next("\x80", &ind) != 0xDC80) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xBF", &ind) != 0xDCBF) || + ck_assert((eina_unicode_utf8_get_next("\xBF", &ind) != 0xDCBF) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\x80\xBF", &ind) != 0xDC80) || + ck_assert((eina_unicode_utf8_get_next("\x80\xBF", &ind) != 0xDC80) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xBF\x80", &ind) != 0xDCBF) || + ck_assert((eina_unicode_utf8_get_next("\xBF\x80", &ind) != 0xDCBF) || (ind != 1)); /* All possible continuation bytes */ for (ch = 0x80 ; ch <= 0xBF ; ch++) { char buf[] = {ch, 0}; ind = 0; - fail_if((eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | ch)) || + ck_assert((eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | ch)) || (ind != 1)); } @@ -142,9 +142,9 @@ EFL_START_TEST(eina_unicode_utf8) ind = 0; \ for (i = 0, ch = start ; ch <= end ; ch++) \ { \ - fail_if((eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | ch)) || \ + ck_assert((eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | ch)) || \ (ind != ++i)); \ - fail_if((eina_unicode_utf8_get_next(buf, &ind) != 0x20) || \ + ck_assert((eina_unicode_utf8_get_next(buf, &ind) != 0x20) || \ (ind != ++i)); \ } \ } \ @@ -178,13 +178,13 @@ EFL_START_TEST(eina_unicode_utf8) } \ buf[j] = 0; \ ind = 0; \ - fail_if( \ + ck_assert( \ (eina_unicode_utf8_get_next(buf, &ind) != (0xDC00 | first))); \ while ((val = eina_unicode_utf8_get_next(buf, &ind))) \ { \ - fail_if(val != (0xDC00 | conti)); \ + ck_assert(val != (0xDC00 | conti)); \ } \ - fail_if(ind != i); \ + ck_assert(ind != i); \ } \ } \ while (0) @@ -203,44 +203,44 @@ EFL_START_TEST(eina_unicode_utf8) /* Impossible bytes */ ind = 0; - fail_if((eina_unicode_utf8_get_next("\xFE", &ind) != 0xDCFE) || + ck_assert((eina_unicode_utf8_get_next("\xFE", &ind) != 0xDCFE) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xFF", &ind) != 0xDCFF) || + ck_assert((eina_unicode_utf8_get_next("\xFF", &ind) != 0xDCFF) || (ind != 1)); /* Overlong sequences */ ind = 0; - fail_if((eina_unicode_utf8_get_next("\xC0\xAF", &ind) != 0xDCC0) || + ck_assert((eina_unicode_utf8_get_next("\xC0\xAF", &ind) != 0xDCC0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xE0\x80\xAF", &ind) != 0xDCE0) || + ck_assert((eina_unicode_utf8_get_next("\xE0\x80\xAF", &ind) != 0xDCE0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF0\x80\x80\xAF", &ind) != 0xDCF0) || + ck_assert((eina_unicode_utf8_get_next("\xF0\x80\x80\xAF", &ind) != 0xDCF0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF8\x80\x80\x80\xAF", &ind) != 0xDCF8) || + ck_assert((eina_unicode_utf8_get_next("\xF8\x80\x80\x80\xAF", &ind) != 0xDCF8) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xFC\x80\x80\x80\x80\xAF", &ind) != 0xDCFC) || + ck_assert((eina_unicode_utf8_get_next("\xFC\x80\x80\x80\x80\xAF", &ind) != 0xDCFC) || (ind != 1)); /* Maximum overlong sequences */ ind = 0; - fail_if((eina_unicode_utf8_get_next("\xC1\xBF", &ind) != 0xDCC1) || + ck_assert((eina_unicode_utf8_get_next("\xC1\xBF", &ind) != 0xDCC1) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xE0\x9F\xBF", &ind) != 0xDCE0) || + ck_assert((eina_unicode_utf8_get_next("\xE0\x9F\xBF", &ind) != 0xDCE0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF0\x8F\xBF\xBF", &ind) != 0xDCF0) || + ck_assert((eina_unicode_utf8_get_next("\xF0\x8F\xBF\xBF", &ind) != 0xDCF0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xF8\x87\xBF\xBF\xBF", &ind) != 0xDCF8) || + ck_assert((eina_unicode_utf8_get_next("\xF8\x87\xBF\xBF\xBF", &ind) != 0xDCF8) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_get_next("\xFC\x83\xBF\xBF\xBF\xBF", &ind) != 0xDCFC) || + ck_assert((eina_unicode_utf8_get_next("\xFC\x83\xBF\xBF\xBF\xBF", &ind) != 0xDCFC) || (ind != 1)); /* Add some more error cases here */ } @@ -248,8 +248,8 @@ EFL_END_TEST EFL_START_TEST(eina_alignof) { - fail_if(eina_mempool_alignof(6) != 8); - fail_if((eina_mempool_alignof(10) & 0x7) != 0); + ck_assert(eina_mempool_alignof(6) != 8); + ck_assert((eina_mempool_alignof(10) & 0x7) != 0); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_accessor.c b/src/tests/eina/eina_test_accessor.c index 62e77e06ee..9a86ad0f30 100644 --- a/src/tests/eina/eina_test_accessor.c +++ b/src/tests/eina/eina_test_accessor.c @@ -30,7 +30,7 @@ static Eina_Bool eina_accessor_check(EINA_UNUSED const Eina_Array *array, int *data, int *fdata) { - fail_if(*fdata > *data); + ck_assert(*fdata > *data); *fdata = *data; return EINA_TRUE; @@ -44,29 +44,29 @@ EFL_START_TEST(eina_accessor_array_simple) int i; ea = eina_array_new(11); - fail_if(!ea); + ck_assert(!ea); for (i = 0; i < 200; ++i) { tmp = malloc(sizeof(int)); - fail_if(!tmp); + ck_assert(!tmp); *tmp = i; eina_array_push(ea, tmp); } it = eina_array_accessor_new(ea); - fail_if(!it); + ck_assert(!it); - fail_if(eina_accessor_data_get(it, 100, (void **)&tmp) != EINA_TRUE); - fail_if(!tmp); - fail_if(*tmp != 100); + ck_assert(eina_accessor_data_get(it, 100, (void **)&tmp) != EINA_TRUE); + ck_assert(!tmp); + ck_assert(*tmp != 100); i = 50; eina_accessor_over(it, EINA_EACH_CB(eina_accessor_check), 50, 100, &i); - fail_if(i != 99); + ck_assert(i != 99); - fail_if(eina_accessor_container_get(it) != ea); + ck_assert(eina_accessor_container_get(it) != ea); eina_accessor_free(it); @@ -88,7 +88,7 @@ _eina_test_inlist_build(int i) Eina_Test_Inlist *tmp; tmp = malloc(sizeof(Eina_Test_Inlist)); - fail_if(!tmp); + ck_assert(!tmp); tmp->i = i; return tmp; @@ -101,9 +101,9 @@ eina_accessor_inlist_data_check(EINA_UNUSED const Eina_Inlist *in_list, { switch (*fdata) { - case 0: fail_if(data->i != 3227); break; + case 0: ck_assert(data->i != 3227); break; - case 1: fail_if(data->i != 1664); break; + case 1: ck_assert(data->i != 1664); break; } (*fdata)++; @@ -121,19 +121,19 @@ EFL_START_TEST(eina_accessor_inlist_simple) tmp = _eina_test_inlist_build(42); lst = eina_inlist_append(lst, EINA_INLIST_GET(tmp)); - fail_if(!lst); + ck_assert(!lst); tmp = _eina_test_inlist_build(1664); lst = eina_inlist_append_relative(lst, EINA_INLIST_GET(tmp), lst); - fail_if(!lst); - fail_if(((Eina_Test_Inlist *)lst)->i != 42); + ck_assert(!lst); + ck_assert(((Eina_Test_Inlist *)lst)->i != 42); prev = tmp; tmp = _eina_test_inlist_build(3227); lst = eina_inlist_prepend_relative(lst, EINA_INLIST_GET( tmp), EINA_INLIST_GET(prev)); - fail_if(!lst); - fail_if(((Eina_Test_Inlist *)lst)->i != 42); + ck_assert(!lst); + ck_assert(((Eina_Test_Inlist *)lst)->i != 42); tmp = _eina_test_inlist_build(27); lst = eina_inlist_prepend_relative(lst, EINA_INLIST_GET(tmp), NULL); @@ -145,22 +145,22 @@ EFL_START_TEST(eina_accessor_inlist_simple) lst = eina_inlist_append(lst, EINA_INLIST_GET(tmp)); it = eina_inlist_accessor_new(lst); - fail_if(!it); - fail_if(eina_accessor_container_get(it) != lst); + ck_assert(!it); + ck_assert(eina_accessor_container_get(it) != lst); eina_accessor_over(it, EINA_EACH_CB(eina_accessor_inlist_data_check), 2, 4, &i); - fail_if(eina_accessor_data_get(it, 5, (void **)&tmp) != EINA_TRUE); - fail_if(eina_accessor_data_get(it, 3, (void **)&tmp) != EINA_TRUE); - fail_if(tmp->i != 1664); - fail_if(eina_accessor_data_get(it, 3, (void **)&tmp) != EINA_TRUE); - fail_if(tmp->i != 1664); - fail_if(eina_accessor_data_get(it, 1, (void **)&tmp) != EINA_TRUE); - fail_if(tmp->i != 42); + ck_assert(eina_accessor_data_get(it, 5, (void **)&tmp) != EINA_TRUE); + ck_assert(eina_accessor_data_get(it, 3, (void **)&tmp) != EINA_TRUE); + ck_assert(tmp->i != 1664); + ck_assert(eina_accessor_data_get(it, 3, (void **)&tmp) != EINA_TRUE); + ck_assert(tmp->i != 1664); + ck_assert(eina_accessor_data_get(it, 1, (void **)&tmp) != EINA_TRUE); + ck_assert(tmp->i != 42); eina_accessor_free(it); - fail_if(i != 2); + ck_assert(i != 2); } EFL_END_TEST @@ -171,9 +171,9 @@ eina_iterator_list_data_check(EINA_UNUSED const Eina_List *list, { switch (*fdata) { - case 0: fail_if(*data != 9); break; + case 0: ck_assert(*data != 9); break; - case 1: fail_if(*data != 6); break; + case 1: ck_assert(*data != 6); break; } (*fdata)++; @@ -190,41 +190,41 @@ EFL_START_TEST(eina_accessor_list_simple) int i = 0; list = eina_list_append(list, &data[0]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[1]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[2]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[3]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[4]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[5]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[6]); - fail_if(list == NULL); + ck_assert(list == NULL); it = eina_list_accessor_new(list); - fail_if(!it); + ck_assert(!it); eina_accessor_over(it, EINA_EACH_CB(eina_iterator_list_data_check), 2, 4, &i); - fail_if(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); - fail_if(*j != 1); - fail_if(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); - fail_if(*j != 6); - fail_if(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); - fail_if(*j != 6); - fail_if(eina_accessor_data_get(it, 1, (void **)&j) != EINA_TRUE); - fail_if(*j != 7); - fail_if(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); - fail_if(*j != 1); + ck_assert(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); + ck_assert(*j != 1); + ck_assert(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); + ck_assert(*j != 6); + ck_assert(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); + ck_assert(*j != 6); + ck_assert(eina_accessor_data_get(it, 1, (void **)&j) != EINA_TRUE); + ck_assert(*j != 7); + ck_assert(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); + ck_assert(*j != 1); eina_accessor_free(it); } @@ -243,16 +243,16 @@ EFL_START_TEST(eina_accessor_carray_simple_ptr) ck_assert_int_eq(data[c], j); } - fail_if(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); - fail_if(j != 1337); - fail_if(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); - fail_if(j != 1); - fail_if(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); - fail_if(j != 1); - fail_if(eina_accessor_data_get(it, 1, (void **)&j) != EINA_TRUE); - fail_if(j != 9); - fail_if(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); - fail_if(j != 1337); + ck_assert(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); + ck_assert(j != 1337); + ck_assert(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); + ck_assert(j != 1); + ck_assert(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); + ck_assert(j != 1); + ck_assert(eina_accessor_data_get(it, 1, (void **)&j) != EINA_TRUE); + ck_assert(j != 9); + ck_assert(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); + ck_assert(j != 1337); eina_accessor_free(it); } @@ -271,16 +271,16 @@ EFL_START_TEST(eina_accessor_carray_simple) ck_assert_int_eq(data[c], *j); } - fail_if(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); - fail_if(*j != 1337); - fail_if(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); - fail_if(*j != 1); - fail_if(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); - fail_if(*j != 1); - fail_if(eina_accessor_data_get(it, 1, (void **)&j) != EINA_TRUE); - fail_if(*j != 9); - fail_if(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); - fail_if(*j != 1337); + ck_assert(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); + ck_assert(*j != 1337); + ck_assert(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); + ck_assert(*j != 1); + ck_assert(eina_accessor_data_get(it, 3, (void **)&j) != EINA_TRUE); + ck_assert(*j != 1); + ck_assert(eina_accessor_data_get(it, 1, (void **)&j) != EINA_TRUE); + ck_assert(*j != 9); + ck_assert(eina_accessor_data_get(it, 5, (void **)&j) != EINA_TRUE); + ck_assert(*j != 1337); eina_accessor_free(it); } diff --git a/src/tests/eina/eina_test_array.c b/src/tests/eina/eina_test_array.c index 3373f07ae1..8ee0940cd1 100644 --- a/src/tests/eina/eina_test_array.c +++ b/src/tests/eina/eina_test_array.c @@ -34,31 +34,31 @@ EFL_START_TEST(eina_array_simple) unsigned int i; ea = eina_array_new(11); - fail_if(!ea); + ck_assert(!ea); for (i = 0; i < 201; ++i) { tmp = malloc(sizeof(char) * 10); - fail_if(!tmp); + ck_assert(!tmp); eina_convert_itoa(i, tmp); eina_array_push(ea, tmp); } - fail_if(eina_array_data_get(ea, 10) == NULL); - fail_if(atoi(eina_array_data_get(ea, 10)) != 10); + ck_assert(eina_array_data_get(ea, 10) == NULL); + ck_assert(atoi(eina_array_data_get(ea, 10)) != 10); tmp = eina_array_pop(ea); - fail_if(tmp == NULL); - fail_if(atoi(tmp) != 200); + ck_assert(tmp == NULL); + ck_assert(atoi(tmp) != 200); free(tmp); EINA_ARRAY_ITER_NEXT(ea, i, tmp, it) { - fail_if((unsigned int)atoi(tmp) != i); + ck_assert((unsigned int)atoi(tmp) != i); free(tmp); } - fail_if(i != 200); + ck_assert(i != 200); eina_array_clean(ea); eina_array_flush(ea); @@ -79,22 +79,22 @@ EFL_START_TEST(eina_array_static) for (i = 0; i < 200; ++i) { tmp = malloc(sizeof(char) * 10); - fail_if(!tmp); + ck_assert(!tmp); eina_convert_itoa(i, tmp); eina_array_push(&sea, tmp); } - fail_if(eina_array_data_get(&sea, 10) == NULL); - fail_if(atoi(eina_array_data_get(&sea, 10)) != 10); + ck_assert(eina_array_data_get(&sea, 10) == NULL); + ck_assert(atoi(eina_array_data_get(&sea, 10)) != 10); EINA_ARRAY_ITER_NEXT(&sea, i, tmp, it) { - fail_if((unsigned int)atoi(tmp) != i); + ck_assert((unsigned int)atoi(tmp) != i); free(tmp); } - fail_if(i != 200); + ck_assert(i != 200); eina_array_clean(&sea); eina_array_flush(&sea); @@ -107,8 +107,8 @@ keep_int(void *data, void *gdata) { int *tmp = data; - fail_if(gdata); - fail_if(!tmp); + ck_assert(gdata); + ck_assert(!tmp); if (*tmp == 0) return EINA_FALSE; @@ -124,12 +124,12 @@ EFL_START_TEST(eina_array_remove_stuff) unsigned int i; ea = eina_array_new(64); - fail_if(!ea); + ck_assert(!ea); for (i = 0; i < 1000; ++i) { tmp = malloc(sizeof(int)); - fail_if(!tmp); + ck_assert(!tmp); *tmp = i; eina_array_push(ea, tmp); @@ -139,35 +139,35 @@ EFL_START_TEST(eina_array_remove_stuff) for (i = 0; i < 10; ++i) { tmp = eina_array_data_get(ea, i); - fail_if(!tmp); + ck_assert(!tmp); *tmp = 0; } - fail_if(eina_array_remove(ea, keep_int, NULL) != EINA_TRUE); + ck_assert(eina_array_remove(ea, keep_int, NULL) != EINA_TRUE); - fail_if(eina_array_count(ea) != 990); + ck_assert(eina_array_count(ea) != 990); EINA_ARRAY_ITER_NEXT(ea, i, tmp, it) - fail_if(*tmp == 0); + ck_assert(*tmp == 0); // Remove the last items for (i = 980; i < 990; ++i) { tmp = eina_array_data_get(ea, i); - fail_if(!tmp); + ck_assert(!tmp); *tmp = 0; } eina_array_remove(ea, keep_int, NULL); // Remove all items - fail_if(eina_array_count(ea) != 980); + ck_assert(eina_array_count(ea) != 980); EINA_ARRAY_ITER_NEXT(ea, i, tmp, it) { - fail_if(*tmp == 0); + ck_assert(*tmp == 0); *tmp = 0; } eina_array_remove(ea, keep_int, NULL); - fail_if(eina_array_count(ea) != 0); + ck_assert(eina_array_count(ea) != 0); eina_array_free(ea); @@ -180,22 +180,22 @@ EFL_START_TEST(eina_array_find_test) uintptr_t i; unsigned int out = 0; - fail_if(eina_array_find(NULL, (void *)1, NULL) != EINA_FALSE); + ck_assert(eina_array_find(NULL, (void *)1, NULL) != EINA_FALSE); eina_array_step_set(&sea, sizeof(sea), 5); for (i = 1 ; i < 10 ; i++) eina_array_push(&sea, (void *)i); - fail_if(eina_array_find(&sea, (void *)15, NULL) != EINA_FALSE); + ck_assert(eina_array_find(&sea, (void *)15, NULL) != EINA_FALSE); - fail_if(eina_array_find(&sea, (void *)5, NULL) != EINA_TRUE); - fail_if(eina_array_find(&sea, (void *)6, &out) != EINA_TRUE); - fail_if(out != 5); + ck_assert(eina_array_find(&sea, (void *)5, NULL) != EINA_TRUE); + ck_assert(eina_array_find(&sea, (void *)6, &out) != EINA_TRUE); + ck_assert(out != 5); eina_array_data_set(&sea, 7, (void *)99); - fail_if(eina_array_find(&sea, (void *)99, &out) != EINA_TRUE); - fail_if(out != 7); + ck_assert(eina_array_find(&sea, (void *)99, &out) != EINA_TRUE); + ck_assert(out != 7); eina_array_flush(&sea); diff --git a/src/tests/eina/eina_test_barrier.c b/src/tests/eina/eina_test_barrier.c index 369edc99bd..8bd24e7789 100644 --- a/src/tests/eina/eina_test_barrier.c +++ b/src/tests/eina/eina_test_barrier.c @@ -66,22 +66,22 @@ EFL_START_TEST(eina_barrier_test_simple) _ck_assert_int(i, >=, 1); r = eina_barrier_new(&barrier, 6); - fail_unless(r); + ck_assert(r); r = eina_thread_create(&wk1, EINA_THREAD_NORMAL, -1, wk_func, NULL); - fail_unless(r); + ck_assert(r); r = eina_thread_create(&wk2, EINA_THREAD_NORMAL, -1, wk_func, NULL); - fail_unless(r); + ck_assert(r); r = eina_thread_create(&wk3, EINA_THREAD_NORMAL, -1, wk1_func, NULL); - fail_unless(r); + ck_assert(r); r = eina_thread_create(&wk4, EINA_THREAD_NORMAL, -1, wk2_func, NULL); - fail_unless(r); + ck_assert(r); r = eina_thread_create(&wk5, EINA_THREAD_NORMAL, -1, wk3_func, NULL); - fail_unless(r); + ck_assert(r); eina_barrier_wait(&barrier); diff --git a/src/tests/eina/eina_test_benchmark.c b/src/tests/eina/eina_test_benchmark.c index 9fb7a568ef..b3565e5af3 100644 --- a/src/tests/eina/eina_test_benchmark.c +++ b/src/tests/eina/eina_test_benchmark.c @@ -48,22 +48,22 @@ EFL_START_TEST(eina_benchmark_simple) unsigned int i; eb = eina_benchmark_new("benchmark", "test"); - fail_if(!eb); + ck_assert(!eb); eina_benchmark_register(eb, "specimens_check", EINA_BENCHMARK(_eina_benchmark_specimens), 1000, 1100, 100); ea = eina_benchmark_run(eb); - fail_if(!ea); + ck_assert(!ea); EINA_ARRAY_ITER_NEXT(ea, i, tmp, it) { - fail_if(!tmp); - fail_if(unlink(tmp)); + ck_assert(!tmp); + ck_assert(unlink(tmp)); } - fail_if(global_test != 499500); + ck_assert(global_test != 499500); eina_benchmark_free(eb); } diff --git a/src/tests/eina/eina_test_bezier.c b/src/tests/eina/eina_test_bezier.c index f07bb5f5c2..fd04a0f877 100644 --- a/src/tests/eina/eina_test_bezier.c +++ b/src/tests/eina/eina_test_bezier.c @@ -42,7 +42,7 @@ EFL_START_TEST(eina_bezier_test_values) &cx1, &cy1, &cx2, &cy2, &ex, &ey); - fail_if(!EINA_DBL_EQ(sx, 1) || + ck_assert(!EINA_DBL_EQ(sx, 1) || !EINA_DBL_EQ(sy, 2) || !EINA_DBL_EQ(cx1, 3) || !EINA_DBL_EQ(cy1, 4) || @@ -65,7 +65,7 @@ EFL_START_TEST(eina_bezier_test_angle) 7, 1); angle = eina_bezier_angle_at(&b, 0.5); - fail_if(EINA_DBL_NONZERO(angle)); + ck_assert(EINA_DBL_NONZERO(angle)); eina_bezier_values_set(&b, 1, 2, @@ -73,7 +73,7 @@ EFL_START_TEST(eina_bezier_test_angle) 1, 6, 1, 8); angle = eina_bezier_angle_at(&b, 0.5); - fail_if(!EINA_DBL_EQ(floor(angle), 90)); + ck_assert(!EINA_DBL_EQ(floor(angle), 90)); } EFL_END_TEST @@ -89,7 +89,7 @@ EFL_START_TEST(eina_bezier_test_length) 5, 1, 7, 1); length = eina_bezier_length_get(&b); - fail_if(!EINA_DBL_EQ(floor(length), 6)); + ck_assert(!EINA_DBL_EQ(floor(length), 6)); eina_bezier_values_set(&b, 1, 1, @@ -97,7 +97,7 @@ EFL_START_TEST(eina_bezier_test_length) 1, 1, 1, 1); length = eina_bezier_length_get(&b); - fail_if(!EINA_DBL_EQ(length, 0)); + ck_assert(!EINA_DBL_EQ(length, 0)); } EFL_END_TEST @@ -114,10 +114,10 @@ EFL_START_TEST(eina_bezier_test_t_at) 7, 1); length = eina_bezier_length_get(&b); t = eina_bezier_t_at(&b, 0); - fail_if(!EINA_DBL_EQ(floor(t), 0)); + ck_assert(!EINA_DBL_EQ(floor(t), 0)); t = eina_bezier_t_at(&b, length); - fail_if(!EINA_DBL_EQ(t, 1)); + ck_assert(!EINA_DBL_EQ(t, 1)); } EFL_END_TEST @@ -133,12 +133,12 @@ EFL_START_TEST(eina_bezier_test_point_at) 5, 6, 7, 8); eina_bezier_point_at(&b, 0, &x , &y); - fail_if(!EINA_DBL_EQ(x, 1) || + ck_assert(!EINA_DBL_EQ(x, 1) || !EINA_DBL_EQ(y, 2)); eina_bezier_point_at(&b, 1, &x , &y); - fail_if(!EINA_DBL_EQ(x, 7) || + ck_assert(!EINA_DBL_EQ(x, 7) || !EINA_DBL_EQ(y, 8)); } @@ -159,7 +159,7 @@ EFL_START_TEST(eina_bezier_test_split_at_length) len1 = eina_bezier_length_get(&l); len2 = eina_bezier_length_get(&r); - fail_if(!EINA_DBL_EQ(len, (len1 + len2))); + ck_assert(!EINA_DBL_EQ(len, (len1 + len2))); } EFL_END_TEST @@ -177,7 +177,7 @@ EFL_START_TEST(eina_bezier_test_bounds_get) eina_bezier_bounds_get(&b, &x, &y, &w, &h); - fail_if(!EINA_DBL_EQ(x, 0) || !EINA_DBL_EQ(y, 0) || !EINA_DBL_EQ(w, 100) || !EINA_DBL_EQ(h, 100)); + ck_assert(!EINA_DBL_EQ(x, 0) || !EINA_DBL_EQ(y, 0) || !EINA_DBL_EQ(w, 100) || !EINA_DBL_EQ(h, 100)); } EFL_END_TEST @@ -196,7 +196,7 @@ EFL_START_TEST(eina_bezier_test_on_interval) eina_bezier_on_interval(&b, 0.25, 0.5, &res); eina_bezier_point_at(&res, 0, &px2, &py2); - fail_if(!EINA_DBL_EQ(px1, px2) || !EINA_DBL_EQ(py1, py2)); + ck_assert(!EINA_DBL_EQ(px1, px2) || !EINA_DBL_EQ(py1, py2)); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_binbuf.c b/src/tests/eina/eina_test_binbuf.c index 929d549a4c..a532bac97c 100644 --- a/src/tests/eina/eina_test_binbuf.c +++ b/src/tests/eina/eina_test_binbuf.c @@ -35,46 +35,46 @@ EFL_START_TEST(binbuf_simple) Eina_Rw_Slice rw_slice; buf = eina_binbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_binbuf_append_length(buf, cbuf, size); - fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); - fail_if(size != eina_binbuf_length_get(buf)); + ck_assert(memcmp(eina_binbuf_string_get(buf), cbuf, size)); + ck_assert(size != eina_binbuf_length_get(buf)); ro_slice = eina_binbuf_slice_get(buf); - fail_if(ro_slice.len != size); - fail_if(ro_slice.mem != eina_binbuf_string_get(buf)); + ck_assert(ro_slice.len != size); + ck_assert(ro_slice.mem != eina_binbuf_string_get(buf)); rw_slice = eina_binbuf_rw_slice_get(buf); - fail_if(rw_slice.len != size); - fail_if(rw_slice.mem != eina_binbuf_string_get(buf)); + ck_assert(rw_slice.len != size); + ck_assert(rw_slice.mem != eina_binbuf_string_get(buf)); test_buf = eina_binbuf_new(); - fail_if(!test_buf); - fail_if(!eina_binbuf_append_buffer(test_buf, buf)); - fail_if(memcmp(eina_binbuf_string_get(test_buf), cbuf, size)); - fail_if(size != eina_binbuf_length_get(test_buf)); + ck_assert(!test_buf); + ck_assert(!eina_binbuf_append_buffer(test_buf, buf)); + ck_assert(memcmp(eina_binbuf_string_get(test_buf), cbuf, size)); + ck_assert(size != eina_binbuf_length_get(test_buf)); ro_slice.mem = cbuf; ro_slice.len = size; eina_binbuf_append_slice(buf, ro_slice); - fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); - fail_if(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); - fail_if(2 * size != eina_binbuf_length_get(buf)); + ck_assert(memcmp(eina_binbuf_string_get(buf), cbuf, size)); + ck_assert(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); + ck_assert(2 * size != eina_binbuf_length_get(buf)); txt = eina_binbuf_string_steal(buf); - fail_if(memcmp(txt, cbuf, size)); - fail_if(memcmp(txt + size, cbuf, size)); + ck_assert(memcmp(txt, cbuf, size)); + ck_assert(memcmp(txt + size, cbuf, size)); free(txt); - fail_if(eina_binbuf_length_get(buf) != 0); + ck_assert(eina_binbuf_length_get(buf) != 0); eina_binbuf_append_length(buf, cbuf, size); - fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); - fail_if(size != eina_binbuf_length_get(buf)); + ck_assert(memcmp(eina_binbuf_string_get(buf), cbuf, size)); + ck_assert(size != eina_binbuf_length_get(buf)); eina_binbuf_reset(buf); - fail_if(eina_binbuf_length_get(buf) != 0); + ck_assert(eina_binbuf_length_get(buf) != 0); eina_binbuf_free(test_buf); eina_binbuf_free(buf); @@ -90,22 +90,22 @@ EFL_START_TEST(binbuf_remove) size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ buf = eina_binbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_binbuf_append_length(buf, cbuf, size); - fail_if(size != eina_binbuf_length_get(buf)); + ck_assert(size != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 0, 4); - fail_if(size - 4 != eina_binbuf_length_get(buf)); + ck_assert(size - 4 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 8, 1000); - fail_if(8 != eina_binbuf_length_get(buf)); + ck_assert(8 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 7, eina_binbuf_length_get(buf)); - fail_if(7 != eina_binbuf_length_get(buf)); + ck_assert(7 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 2, 4); - fail_if(5 != eina_binbuf_length_get(buf)); + ck_assert(5 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 4, 1); - fail_if(5 != eina_binbuf_length_get(buf)); + ck_assert(5 != eina_binbuf_length_get(buf)); eina_binbuf_remove(buf, 0, eina_binbuf_length_get(buf)); - fail_if(0 != eina_binbuf_length_get(buf)); + ck_assert(0 != eina_binbuf_length_get(buf)); eina_binbuf_free(buf); } @@ -125,14 +125,14 @@ EFL_START_TEST(binbuf_manage_simple) memcpy(alloc_buf, cbuf, size); buf = eina_binbuf_manage_new_length(alloc_buf, size); - fail_if(!buf); + ck_assert(!buf); - fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); - fail_if(size != eina_binbuf_length_get(buf)); + ck_assert(memcmp(eina_binbuf_string_get(buf), cbuf, size)); + ck_assert(size != eina_binbuf_length_get(buf)); eina_binbuf_append_length(buf, cbuf, size); - fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); - fail_if(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); - fail_if(2 * size != eina_binbuf_length_get(buf)); + ck_assert(memcmp(eina_binbuf_string_get(buf), cbuf, size)); + ck_assert(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); + ck_assert(2 * size != eina_binbuf_length_get(buf)); eina_binbuf_free(buf); @@ -147,19 +147,19 @@ EFL_START_TEST(binbuf_manage_read_only_simple) size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ buf = eina_binbuf_manage_read_only_new_length(cbuf, size); - fail_if(!buf); + ck_assert(!buf); eina_binbuf_free(buf); buf = eina_binbuf_manage_read_only_new_length(cbuf, size); - fail_if(!buf); + ck_assert(!buf); - fail_if(eina_binbuf_string_get(buf) != cbuf); - fail_if(size != eina_binbuf_length_get(buf)); + ck_assert(eina_binbuf_string_get(buf) != cbuf); + ck_assert(size != eina_binbuf_length_get(buf)); eina_binbuf_append_length(buf, cbuf, size); - fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); - fail_if(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); - fail_if(2 * size != eina_binbuf_length_get(buf)); + ck_assert(memcmp(eina_binbuf_string_get(buf), cbuf, size)); + ck_assert(memcmp(eina_binbuf_string_get(buf) + size, cbuf, size)); + ck_assert(2 * size != eina_binbuf_length_get(buf)); eina_binbuf_free(buf); @@ -173,40 +173,40 @@ EFL_START_TEST(binbuf_insert) Eina_Binbuf *buf; buf = eina_binbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_binbuf_insert(buf, "abc", 10); - fail_if(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); - fail_if(strcmp(eina_binbuf_string_get(buf), "abc")); + ck_assert(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); + ck_assert(strcmp(eina_binbuf_string_get(buf), "abc")); eina_binbuf_insert(buf, "123", 0); - fail_if(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); - fail_if(strcmp(eina_binbuf_string_get(buf), "123abc")); + ck_assert(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); + ck_assert(strcmp(eina_binbuf_string_get(buf), "123abc")); eina_binbuf_insert(buf, "xyz", eina_binbuf_length_get(buf)); - fail_if(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); - fail_if(strcmp(eina_binbuf_string_get(buf), "123abcxyz")); + ck_assert(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); + ck_assert(strcmp(eina_binbuf_string_get(buf), "123abcxyz")); eina_binbuf_insert(buf, "xyz", 1); - fail_if(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); - fail_if(strcmp(eina_binbuf_string_get(buf), "1xyz23abcxyz")); + ck_assert(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); + ck_assert(strcmp(eina_binbuf_string_get(buf), "1xyz23abcxyz")); eina_binbuf_insert_n(buf, "ABCDEF", 2, 1); - fail_if(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); - fail_if(strcmp(eina_binbuf_string_get(buf), "1ABxyz23abcxyz")); + ck_assert(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); + ck_assert(strcmp(eina_binbuf_string_get(buf), "1ABxyz23abcxyz")); eina_binbuf_insert_n(buf, "EINA", 2, 3); - fail_if(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); - fail_if(strcmp(eina_binbuf_string_get(buf), "1ABEIxyz23abcxyz")); + ck_assert(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); + ck_assert(strcmp(eina_binbuf_string_get(buf), "1ABEIxyz23abcxyz")); eina_binbuf_insert_escaped(buf, "678", 3); - fail_if(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); - fail_if(strncmp(eina_binbuf_string_get(buf) + 3, "678", 3)); + ck_assert(strlen(eina_binbuf_string_get(buf)) != eina_binbuf_length_get(buf)); + ck_assert(strncmp(eina_binbuf_string_get(buf) + 3, "678", 3)); eina_binbuf_insert_escaped(buf, "089 '\\", 9); - fail_if(strlen(eina_binbuf_string_get( + ck_assert(strlen(eina_binbuf_string_get( buf)) != eina_binbuf_length_get(buf)); - fail_if(strncmp(eina_binbuf_string_get(buf) + 9, + ck_assert(strncmp(eina_binbuf_string_get(buf) + 9, "089\\ \\'\\\\", strlen("089\\ \\'\\\\"))); eina_binbuf_reset(buf); @@ -234,52 +234,52 @@ EFL_START_TEST(binbuf_realloc) pattern[i] = '\0'; buf = eina_binbuf_new(); - fail_if(!buf); + ck_assert(!buf); sz = 0; eina_binbuf_append_length(buf, pattern, 1); - fail_if(eina_binbuf_length_get(buf) != sz + 1); - fail_if(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 1)); + ck_assert(eina_binbuf_length_get(buf) != sz + 1); + ck_assert(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 1)); sz += 1; eina_binbuf_append_length(buf, pattern, 32); - fail_if(eina_binbuf_length_get(buf) != sz + 32); - fail_if(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 32)); + ck_assert(eina_binbuf_length_get(buf) != sz + 32); + ck_assert(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 32)); sz += 32; eina_binbuf_append_length(buf, pattern, 64); - fail_if(eina_binbuf_length_get(buf) != sz + 64); - fail_if(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 64)); + ck_assert(eina_binbuf_length_get(buf) != sz + 64); + ck_assert(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 64)); sz += 64; eina_binbuf_append_length(buf, pattern, 128); - fail_if(eina_binbuf_length_get(buf) != sz + 128); - fail_if(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 128)); + ck_assert(eina_binbuf_length_get(buf) != sz + 128); + ck_assert(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 128)); sz += 128; eina_binbuf_append_length(buf, pattern, 4096); - fail_if(eina_binbuf_length_get(buf) != sz + 4096); - fail_if(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 4096)); + ck_assert(eina_binbuf_length_get(buf) != sz + 4096); + ck_assert(memcmp(eina_binbuf_string_get(buf) + sz, pattern, 4096)); sz += 4096; eina_binbuf_append_length(buf, pattern, sizeof(pattern) - 1); - fail_if(eina_binbuf_length_get(buf) != sz + sizeof(pattern) - 1); - fail_if(memcmp(eina_binbuf_string_get(buf) + sz, pattern, sizeof(pattern) - + ck_assert(eina_binbuf_length_get(buf) != sz + sizeof(pattern) - 1); + ck_assert(memcmp(eina_binbuf_string_get(buf) + sz, pattern, sizeof(pattern) - 1)); sz += sizeof(pattern) - 1; eina_binbuf_remove(buf, 1024, 1024 + 1234); - fail_if(eina_binbuf_length_get(buf) != sz - 1234); + ck_assert(eina_binbuf_length_get(buf) != sz - 1234); sz -= 1234; eina_binbuf_remove(buf, 0, 0 + 8192); - fail_if(eina_binbuf_length_get(buf) != sz - 8192); + ck_assert(eina_binbuf_length_get(buf) != sz - 8192); sz -= 8192; eina_binbuf_remove(buf, 0, 0 + 32); - fail_if(eina_binbuf_length_get(buf) != sz - 32); + ck_assert(eina_binbuf_length_get(buf) != sz - 32); sz -= 32; @@ -299,7 +299,7 @@ EFL_START_TEST(binbuf_expand) Eina_Bool r; buf = eina_binbuf_new(); - fail_if(!buf); + ck_assert(!buf); rw_slice = eina_binbuf_rw_slice_get(buf); ck_assert_int_eq(rw_slice.len, 0); diff --git a/src/tests/eina/eina_test_binshare.c b/src/tests/eina/eina_test_binshare.c index 0e3c01f652..4a2bd25fc1 100644 --- a/src/tests/eina/eina_test_binshare.c +++ b/src/tests/eina/eina_test_binshare.c @@ -42,14 +42,14 @@ EFL_START_TEST(eina_binshare_simple) t0 = eina_binshare_add_length(TEST0, TEST0_SIZE); t1 = eina_binshare_add_length(TEST1, TEST1_SIZE); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(memcmp(t0, TEST0, TEST0_SIZE) != 0); - fail_if(memcmp(t1, TEST1, TEST1_SIZE) != 0); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(memcmp(t0, TEST0, TEST0_SIZE) != 0); + ck_assert(memcmp(t1, TEST1, TEST1_SIZE) != 0); t0 = eina_binshare_ref(t0); - fail_if(t0 == NULL); - fail_if(memcmp(t0, TEST0, TEST0_SIZE) != 0); + ck_assert(t0 == NULL); + ck_assert(memcmp(t0, TEST0, TEST0_SIZE) != 0); eina_binshare_del(t0); eina_binshare_del(t0); @@ -78,10 +78,10 @@ EFL_START_TEST(eina_binshare_small) t0 = eina_binshare_add_length(buf, i); t1 = eina_binshare_add_length(buf, i); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(t0 != t1); - fail_if(memcmp(t0, buf, i) != 0); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(t0 != t1); + ck_assert(memcmp(t0, buf, i) != 0); eina_binshare_del(t0); eina_binshare_del(t1); @@ -98,12 +98,12 @@ EFL_START_TEST(eina_binshare_test_share) t0 = eina_binshare_add_length(TEST0, TEST0_SIZE); t1 = eina_binshare_add_length(TEST0, TEST0_SIZE); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(memcmp(t0, TEST0, TEST0_SIZE) != 0); - fail_if(memcmp(t1, TEST0, TEST0_SIZE) != 0); - fail_if(t0 != t1); - fail_if(TEST0_SIZE != eina_binshare_length(t0)); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(memcmp(t0, TEST0, TEST0_SIZE) != 0); + ck_assert(memcmp(t1, TEST0, TEST0_SIZE) != 0); + ck_assert(t0 != t1); + ck_assert(TEST0_SIZE != eina_binshare_length(t0)); eina_binshare_del(t0); eina_binshare_del(t1); diff --git a/src/tests/eina/eina_test_clist.c b/src/tests/eina/eina_test_clist.c index fc0e6ceef2..99fcd74336 100644 --- a/src/tests/eina/eina_test_clist.c +++ b/src/tests/eina/eina_test_clist.c @@ -72,7 +72,7 @@ static void add_string_head(const char *string_to_add) entry_to_add->string = string_to_add; eina_clist_add_head(&string_list, &entry_to_add->entry); - fail_if(eina_clist_head(&string_list) != &entry_to_add->entry); + ck_assert(eina_clist_head(&string_list) != &entry_to_add->entry); } static void iterating_two_phase_with_add_head(unsigned int n, const char *str, int n_ent) @@ -87,8 +87,8 @@ static void iterating_two_phase_with_add_head(unsigned int n, const char *str, i entries[0]->string = str; eina_clist_add_tail(&string_list, &entries[0]->entry); n++; - fail_if(eina_clist_next(&string_list, tail) != &entries[0]->entry); - fail_if(eina_clist_tail(&string_list) != &entries[0]->entry); + ck_assert(eina_clist_next(&string_list, tail) != &entries[0]->entry); + ck_assert(eina_clist_tail(&string_list) != &entries[0]->entry); for (i=1; istring = str; eina_clist_add_tail(&string_list, &entries[i]->entry); n++; - fail_if(eina_clist_count(&string_list) != n); - fail_if(eina_clist_tail(&string_list) != &entries[i]->entry); - fail_if(eina_clist_next(&string_list, &entries[i-1]->entry) != &entries[i]->entry); + ck_assert(eina_clist_count(&string_list) != n); + ck_assert(eina_clist_tail(&string_list) != &entries[i]->entry); + ck_assert(eina_clist_next(&string_list, &entries[i-1]->entry) != &entries[i]->entry); }; } @@ -106,7 +106,7 @@ EFL_START_TEST(eina_clist_basic) { unsigned int n = 0; - fail_if(!eina_clist_empty(&string_list)); + ck_assert(!eina_clist_empty(&string_list)); add_string("this"); n++; @@ -127,7 +127,7 @@ EFL_START_TEST(eina_clist_basic) add_string("world"); n++; - fail_if(eina_clist_count(&string_list) != n); + ck_assert(eina_clist_count(&string_list) != n); print_strings(); @@ -148,7 +148,7 @@ EFL_START_TEST(eina_clist_basic) add_string_after("eight\n"); n++; - fail_if(eina_clist_count(&string_list) != n); + ck_assert(eina_clist_count(&string_list) != n); add_string_head("one2\n"); n++; @@ -167,13 +167,13 @@ EFL_START_TEST(eina_clist_basic) add_string_head("eight2\n"); n++; - fail_if(eina_clist_count(&string_list) != n); + ck_assert(eina_clist_count(&string_list) != n); iterating_two_phase_with_add_head(n, "theString", 16); free_list(); - fail_if(eina_clist_count(&string_list) != 0); + ck_assert(eina_clist_count(&string_list) != 0); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_convert.c b/src/tests/eina/eina_test_convert.c index 0824d86656..23573a2d17 100644 --- a/src/tests/eina/eina_test_convert.c +++ b/src/tests/eina/eina_test_convert.c @@ -36,33 +36,33 @@ EFL_START_TEST(eina_convert_simple) char tmp[128]; char ref[128]; - fail_if(eina_convert_itoa(0, tmp) != 1); - fail_if(strcmp(tmp, "0") != 0); + ck_assert(eina_convert_itoa(0, tmp) != 1); + ck_assert(strcmp(tmp, "0") != 0); - fail_if(eina_convert_itoa(-1, tmp) != 2); - fail_if(strcmp(tmp, "-1") != 0); + ck_assert(eina_convert_itoa(-1, tmp) != 2); + ck_assert(strcmp(tmp, "-1") != 0); - fail_if(eina_convert_itoa(100, tmp) != 3); - fail_if(strcmp(tmp, "100") != 0); + ck_assert(eina_convert_itoa(100, tmp) != 3); + ck_assert(strcmp(tmp, "100") != 0); - fail_if(eina_convert_itoa(-100, tmp) != 4); - fail_if(strcmp(tmp, "-100") != 0); + ck_assert(eina_convert_itoa(-100, tmp) != 4); + ck_assert(strcmp(tmp, "-100") != 0); - fail_if(eina_convert_itoa(10000000, tmp) != 8); - fail_if(strcmp(tmp, "10000000") != 0); + ck_assert(eina_convert_itoa(10000000, tmp) != 8); + ck_assert(strcmp(tmp, "10000000") != 0); snprintf(ref, sizeof (ref), "%d", INT_MIN); - fail_if(eina_convert_itoa(INT_MIN, tmp) != (int) strlen(ref)); - fail_if(strcmp(tmp, ref) != 0); + ck_assert(eina_convert_itoa(INT_MIN, tmp) != (int) strlen(ref)); + ck_assert(strcmp(tmp, ref) != 0); - fail_if(eina_convert_xtoa(0, tmp) != 1); - fail_if(strcmp(tmp, "0") != 0); + ck_assert(eina_convert_xtoa(0, tmp) != 1); + ck_assert(strcmp(tmp, "0") != 0); - fail_if(eina_convert_xtoa(0xA1, tmp) != 2); - fail_if(strcmp(tmp, "a1") != 0); + ck_assert(eina_convert_xtoa(0xA1, tmp) != 2); + ck_assert(strcmp(tmp, "a1") != 0); - fail_if(eina_convert_xtoa(0xFF00EF0E, tmp) != 8); - fail_if(strcmp(tmp, "ff00ef0e") != 0); + ck_assert(eina_convert_xtoa(0xFF00EF0E, tmp) != 8); + ck_assert(strcmp(tmp, "ff00ef0e") != 0); } EFL_END_TEST @@ -80,10 +80,10 @@ _eina_convert_check(double test, int length) long e = 0; double r; - fail_if(eina_convert_dtoa(test, tmp) != length); - fail_if(eina_convert_atod(tmp, 128, &m, &e) != EINA_TRUE); + ck_assert(eina_convert_dtoa(test, tmp) != length); + ck_assert(eina_convert_atod(tmp, 128, &m, &e) != EINA_TRUE); r = ldexp((double)m, e); - fail_if(fabs(r - test) > DBL_MIN); + ck_assert(fabs(r - test) > DBL_MIN); } EFL_START_TEST(eina_convert_double) @@ -98,9 +98,9 @@ _eina_convert_check(double test, int length) _eina_convert_check(EET_TEST_DOUBLE3, 21); _eina_convert_check(EET_TEST_DOUBLE4, 21); - fail_if(eina_convert_atod("ah ah ah", 8, &m, &e) != EINA_FALSE); - fail_if(eina_convert_atod("0xjo", 8, &m, &e) != EINA_FALSE); - fail_if(eina_convert_atod("0xp", 8, &m, &e) != EINA_FALSE); + ck_assert(eina_convert_atod("ah ah ah", 8, &m, &e) != EINA_FALSE); + ck_assert(eina_convert_atod("0xjo", 8, &m, &e) != EINA_FALSE); + ck_assert(eina_convert_atod("0xp", 8, &m, &e) != EINA_FALSE); } EFL_END_TEST @@ -118,36 +118,36 @@ _eina_convert_fp_check(double d, Eina_F32p32 fp, int length) l1 = eina_convert_dtoa(d, tmp1); l2 = eina_convert_fptoa(fp, tmp2); /* fprintf(stderr, "[%s](%i) vs [%s](%i)\n", tmp1, l1, tmp2, l2); */ - fail_if(l1 != l2); - fail_if(length != l1); - fail_if(strcmp(tmp1, tmp2) != 0); + ck_assert(l1 != l2); + ck_assert(length != l1); + ck_assert(strcmp(tmp1, tmp2) != 0); - fail_if(!eina_convert_atofp(tmp2, l2, &fpc)); + ck_assert(!eina_convert_atofp(tmp2, l2, &fpc)); /* fprintf(stderr, "%016x vs %016x\n", fpc, fp); */ - fail_if(fpc != fp); + ck_assert(fpc != fp); - fail_if(!eina_convert_atofp(tmp1, l1, &fpc)); + ck_assert(!eina_convert_atofp(tmp1, l1, &fpc)); fpd = eina_f32p32_double_to(fpc); /* fprintf(stderr, "%0.16f vs %0.16f\n", fpd, d); */ - fail_if(fabs(fpd - d) > DBL_MIN); + ck_assert(fabs(fpd - d) > DBL_MIN); d = -d; fp = -fp; l1 = eina_convert_dtoa(d, tmp1); l2 = eina_convert_fptoa(fp, tmp2); - fail_if(l1 != l2); - fail_if(length + 1 != l1); - fail_if(strcmp(tmp1, tmp2) != 0); + ck_assert(l1 != l2); + ck_assert(length + 1 != l1); + ck_assert(strcmp(tmp1, tmp2) != 0); - fail_if(!eina_convert_atofp(tmp2, l2, &fpc)); + ck_assert(!eina_convert_atofp(tmp2, l2, &fpc)); /* fprintf(stderr, "%016x vs %016x\n", fpc, fp); */ - fail_if(fpc != fp); + ck_assert(fpc != fp); - fail_if(!eina_convert_atofp(tmp1, l1, &fpc)); + ck_assert(!eina_convert_atofp(tmp1, l1, &fpc)); fpd = eina_f32p32_double_to(fpc); /* fprintf(stderr, "%0.16f vs %0.16f\n", fpd, d); */ - fail_if(fabs(fpd - d) > DBL_MIN); + ck_assert(fabs(fpd - d) > DBL_MIN); } EFL_START_TEST(eina_convert_fp) @@ -178,13 +178,13 @@ _eina_convert_strtod_c_check(const char *str) switch(fpclassify(d2)) { case FP_NAN: - fail_if(fpclassify(d1) != FP_NAN); + ck_assert(fpclassify(d1) != FP_NAN); break; case FP_INFINITE: - fail_if(fpclassify(d1) != FP_INFINITE); + ck_assert(fpclassify(d1) != FP_INFINITE); break; default: - fail_if((fpclassify(d1) != FP_ZERO) && + ck_assert((fpclassify(d1) != FP_ZERO) && (fpclassify(d1) != FP_SUBNORMAL) && (fpclassify(d1) != FP_NORMAL)); if (!EINA_DBL_EQ(d1,d2) || (e1 != e2)) @@ -197,7 +197,7 @@ _eina_convert_strtod_c_check(const char *str) if (e1 != e2) printf("different end position\n"); } - fail_if(!EINA_DBL_EQ(d1,d2) || (e1 != e2)); + ck_assert(!EINA_DBL_EQ(d1,d2) || (e1 != e2)); break; } diff --git a/src/tests/eina/eina_test_counter.c b/src/tests/eina/eina_test_counter.c index 2f813e93e1..8900543e76 100644 --- a/src/tests/eina/eina_test_counter.c +++ b/src/tests/eina/eina_test_counter.c @@ -72,7 +72,7 @@ EFL_START_TEST(eina_counter_simple) int i; cnt = eina_counter_new("eina_test"); - fail_if(!cnt); + ck_assert(!cnt); eina_counter_start(cnt); @@ -95,7 +95,7 @@ EFL_START_TEST(eina_counter_simple) eina_counter_stop(cnt, i); dump = eina_counter_dump(cnt); - fail_if(!dump); + ck_assert(!dump); /* TODO: parse dump and check if it's right */ fprintf(stderr, "%s", dump); @@ -112,7 +112,7 @@ EFL_START_TEST(eina_counter_break) Eina_Counter *cnt; cnt = eina_counter_new("eina_test"); - fail_if(!cnt); + ck_assert(!cnt); eina_counter_stop(cnt, 10); @@ -136,8 +136,8 @@ EFL_START_TEST(eina_counter_break) TEST_MAGIC_SAFETY("eina_counter_new", "safety check failed: name == NULL"); cnt = eina_counter_new(NULL); - fail_if(cnt); - fail_unless(ctx.did); + ck_assert(cnt); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -145,7 +145,7 @@ EFL_START_TEST(eina_counter_break) TEST_MAGIC_SAFETY("eina_counter_free", "safety check failed: counter == NULL"); eina_counter_free(NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -153,7 +153,7 @@ EFL_START_TEST(eina_counter_break) TEST_MAGIC_SAFETY("eina_counter_start", "safety check failed: counter == NULL"); eina_counter_start(NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -161,7 +161,7 @@ EFL_START_TEST(eina_counter_break) TEST_MAGIC_SAFETY("eina_counter_stop", "safety check failed: counter == NULL"); eina_counter_stop(NULL, 0); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG @@ -170,8 +170,8 @@ EFL_START_TEST(eina_counter_break) TEST_MAGIC_SAFETY("eina_counter_dump", "safety check failed: counter == NULL"); dump = eina_counter_dump(NULL); - fail_if(dump); - fail_unless(ctx.did); + ck_assert(dump); + ck_assert(ctx.did); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); } diff --git a/src/tests/eina/eina_test_cow.c b/src/tests/eina/eina_test_cow.c index 4f30f6d9df..3b7d042055 100644 --- a/src/tests/eina/eina_test_cow.c +++ b/src/tests/eina/eina_test_cow.c @@ -50,17 +50,17 @@ EFL_START_TEST(eina_cow_bad) Eina_Cow_Test default_value = { 7, 42, NULL }; cow = eina_cow_add("COW Test", sizeof (Eina_Cow_Test), 16, &default_value, EINA_TRUE); - fail_if(cow == NULL); + ck_assert(cow == NULL); cur = eina_cow_alloc(cow); - fail_if(cur == NULL); + ck_assert(cur == NULL); write = eina_cow_write(cow, (const Eina_Cow_Data**) &cur); - fail_if(write == NULL || write == &default_value); + ck_assert(write == NULL || write == &default_value); write->i = 7; eina_cow_done(cow, (const Eina_Cow_Data**) &cur, write, EINA_FALSE); - fail_if(cur->i != 7 || default_value.i != 42); + ck_assert(cur->i != 7 || default_value.i != 42); #ifdef EINA_COW_MAGIC Eina_Bool over_commit = EINA_FALSE; @@ -69,15 +69,15 @@ EFL_START_TEST(eina_cow_bad) eina_log_print_cb_set(_eina_test_log, &over_commit); /* Testing over commit */ eina_cow_done(cow, (const Eina_Cow_Data**) &cur, write, EINA_FALSE); - fail_if(!over_commit); + ck_assert(!over_commit); write = eina_cow_write(cow, (const Eina_Cow_Data**) &cur); - fail_if(write == NULL || write == &default_value); + ck_assert(write == NULL || write == &default_value); eina_log_print_cb_set(_eina_test_log, &over_writing); /* Testing over writing */ write = eina_cow_write(cow, (const Eina_Cow_Data**) &cur); - fail_if(write != NULL || !over_writing); + ck_assert(write != NULL || !over_writing); #else (void) _eina_test_log; #endif @@ -97,35 +97,35 @@ EFL_START_TEST(eina_cow) Eina_Cow_Test default_value = { 42, 0, NULL }; cow = eina_cow_add("COW Test", sizeof (Eina_Cow_Test), 16, &default_value, EINA_TRUE); - fail_if(cow == NULL); + ck_assert(cow == NULL); prev = eina_cow_alloc(cow); cur = eina_cow_alloc(cow); - fail_if(prev == NULL || cur == NULL); + ck_assert(prev == NULL || cur == NULL); write = eina_cow_write(cow, (const Eina_Cow_Data**) &cur); - fail_if(write == NULL || write == &default_value); + ck_assert(write == NULL || write == &default_value); write->i = 7; eina_cow_done(cow, (const Eina_Cow_Data**) &cur, write, EINA_TRUE); - fail_if(cur->i != 7 || prev->i != 0); + ck_assert(cur->i != 7 || prev->i != 0); eina_cow_memcpy(cow, (const Eina_Cow_Data**) &prev, (const Eina_Cow_Data*) cur); - fail_if(cur->i != 7 || prev->i != 7); - fail_if(default_value.i != 0); + ck_assert(cur->i != 7 || prev->i != 7); + ck_assert(default_value.i != 0); write = eina_cow_write(cow, (const Eina_Cow_Data**) &cur); - fail_if(write == NULL || write == &default_value); + ck_assert(write == NULL || write == &default_value); write->i = 42; write->c = 5; eina_cow_done(cow, (const Eina_Cow_Data**) &cur, write, EINA_TRUE); - fail_if(cur->i != 42 || cur->c != 5 || + ck_assert(cur->i != 42 || cur->c != 5 || prev->i != 7 || prev->c != 42 || default_value.c != 42 || default_value.i != 0); - fail_if(eina_cow_gc(cow) == EINA_FALSE); + ck_assert(eina_cow_gc(cow) == EINA_FALSE); write = eina_cow_write(cow, (const Eina_Cow_Data**) &cur); write->i = 7; write->c = 42; @@ -134,9 +134,9 @@ EFL_START_TEST(eina_cow) write = eina_cow_write(cow, (const Eina_Cow_Data**) &prev); eina_cow_done(cow, (const Eina_Cow_Data**) &prev, write, EINA_TRUE); - fail_if(eina_cow_gc(cow) == EINA_FALSE); - fail_if(eina_cow_gc(cow) == EINA_FALSE); - fail_if(cur != prev); + ck_assert(eina_cow_gc(cow) == EINA_FALSE); + ck_assert(eina_cow_gc(cow) == EINA_FALSE); + ck_assert(cur != prev); eina_cow_free(cow, (const Eina_Cow_Data**) &cur); eina_cow_free(cow, (const Eina_Cow_Data**) &prev); diff --git a/src/tests/eina/eina_test_crc.c b/src/tests/eina/eina_test_crc.c index d187073e1e..aab219bf54 100644 --- a/src/tests/eina/eina_test_crc.c +++ b/src/tests/eina/eina_test_crc.c @@ -36,12 +36,12 @@ EFL_START_TEST(eina_crc_simple) for (i = 0; i < sizeof(data) / sizeof(data[0]); ++i) { ret = eina_crc(data[i], strlen(data[i]), seed, EINA_TRUE); - fail_if(ret != result[i]); + ck_assert(ret != result[i]); } ret = eina_crc(s1, strlen(s1), 0xffffffff, EINA_TRUE); ret = eina_crc(s2, strlen(s2), ret, EINA_FALSE); - fail_if(ret != result[0]); + ck_assert(ret != result[0]); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_error.c b/src/tests/eina/eina_test_error.c index 729f71e103..c39af9db76 100644 --- a/src/tests/eina/eina_test_error.c +++ b/src/tests/eina/eina_test_error.c @@ -76,11 +76,11 @@ EFL_START_TEST(eina_error_errno) setenv("EINA_ERROR_LEVEL", "1", 0); test = eina_error_msg_register(TEST_TEXT); - fail_if(!eina_error_msg_get(test)); - fail_if(strcmp(eina_error_msg_get(test), TEST_TEXT) != 0); + ck_assert(!eina_error_msg_get(test)); + ck_assert(strcmp(eina_error_msg_get(test), TEST_TEXT) != 0); eina_error_set(test); - fail_if(eina_error_get() != test); + ck_assert(eina_error_get() != test); eina_error_set(EBADF); ck_assert_int_eq(eina_error_get(), EBADF); @@ -102,11 +102,11 @@ EFL_START_TEST(eina_error_test_find) ck_assert_int_ne(test, 0); str = eina_error_msg_get(test); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, TEST_TEXT TEST_TEXT); eina_error_set(test); - fail_if(eina_error_get() != test); + ck_assert(eina_error_get() != test); r = eina_error_find(TEST_TEXT TEST_TEXT); ck_assert_int_eq(r, test); @@ -123,13 +123,13 @@ EFL_START_TEST(eina_error_test_modify) ck_assert_int_ne(test, 0); str = eina_error_msg_get(test); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "Some Test Error"); eina_error_set(test); - fail_if(eina_error_get() != test); + ck_assert(eina_error_get() != test); - fail_unless(eina_error_msg_modify(test, "ABCDE")); + ck_assert(eina_error_msg_modify(test, "ABCDE")); r = eina_error_find("ABCDE"); ck_assert_int_eq(r, test); @@ -138,10 +138,10 @@ EFL_START_TEST(eina_error_test_modify) ck_assert_int_ne(test, 0); str = eina_error_msg_get(test); - fail_unless(str != NULL); - fail_unless(str == smsg); + ck_assert(str != NULL); + ck_assert(str == smsg); - fail_unless(eina_error_msg_modify(test, "Change that!")); + ck_assert(eina_error_msg_modify(test, "Change that!")); r = eina_error_find("Change that!"); ck_assert_int_eq(r, test); @@ -190,12 +190,12 @@ EFL_START_TEST(eina_error_test_failures) TEST_MAGIC_SAFETY("eina_error_msg_register", "safety check failed: msg == NULL"); ck_assert_int_eq(eina_error_msg_register(NULL), 0); - fail_unless(ctx.did); + ck_assert(ctx.did); TEST_MAGIC_SAFETY("eina_error_msg_static_register", "safety check failed: msg == NULL"); ck_assert_int_eq(eina_error_msg_static_register(NULL), 0); - fail_unless(ctx.did); + ck_assert(ctx.did); TEST_MAGIC_SAFETY("eina_error_msg_modify", "safety check failed: EINA_ERROR_REGISTERED_CHECK(error) is false"); @@ -209,7 +209,7 @@ EFL_START_TEST(eina_error_test_failures) "safety check failed: msg == NULL"); ck_assert_int_eq(eina_error_msg_modify(ENOMEM, NULL), EINA_FALSE); - fail_unless(ctx.did); + ck_assert(ctx.did); local_error = eina_error_msg_static_register("Local error for test"); ck_assert_int_ne(local_error, 0); @@ -218,7 +218,7 @@ EFL_START_TEST(eina_error_test_failures) "safety check failed: msg == NULL"); ck_assert_int_eq(eina_error_msg_modify(local_error, NULL), EINA_FALSE); - fail_unless(ctx.did); + ck_assert(ctx.did); ck_assert_str_eq(eina_error_msg_get(ENOMEM), #if defined(_WIN32) || defined(__sun) @@ -230,12 +230,12 @@ EFL_START_TEST(eina_error_test_failures) TEST_MAGIC_SAFETY("eina_error_find", "safety check failed: msg == NULL"); ck_assert_int_eq(eina_error_find(NULL), 0); - fail_unless(ctx.did); + ck_assert(ctx.did); ck_assert_int_eq(eina_error_find("Non-existent Error..."), 0); - fail_if(eina_error_msg_get(0)); - fail_if(eina_error_msg_get(4096)); + ck_assert(eina_error_msg_get(0)); + ck_assert(eina_error_msg_get(4096)); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); diff --git a/src/tests/eina/eina_test_file.c b/src/tests/eina/eina_test_file.c index 3e12206094..a7fe907dac 100644 --- a/src/tests/eina/eina_test_file.c +++ b/src/tests/eina/eina_test_file.c @@ -107,8 +107,8 @@ EFL_START_TEST(eina_file_split_simple) TEST_MAGIC_SAFETY("eina_file_split", "safety check failed: path == NULL"); ea = eina_file_split(NULL); - fail_if(ea); - fail_unless(ctx.did); + ck_assert(ea); + ck_assert(ctx.did); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); #undef TEST_MAGIC_SAFETY @@ -120,13 +120,13 @@ EFL_START_TEST(eina_file_split_simple) ea = eina_file_split(strdup("/this/is/a/small/test")); #endif - fail_if(!ea); - fail_if(eina_array_count(ea) != 5); - fail_if(strcmp(eina_array_data_get(ea, 0), "this")); - fail_if(strcmp(eina_array_data_get(ea, 1), "is")); - fail_if(strcmp(eina_array_data_get(ea, 2), "a")); - fail_if(strcmp(eina_array_data_get(ea, 3), "small")); - fail_if(strcmp(eina_array_data_get(ea, 4), "test")); + ck_assert(!ea); + ck_assert(eina_array_count(ea) != 5); + ck_assert(strcmp(eina_array_data_get(ea, 0), "this")); + ck_assert(strcmp(eina_array_data_get(ea, 1), "is")); + ck_assert(strcmp(eina_array_data_get(ea, 2), "a")); + ck_assert(strcmp(eina_array_data_get(ea, 3), "small")); + ck_assert(strcmp(eina_array_data_get(ea, 4), "test")); eina_array_free(ea); @@ -138,14 +138,14 @@ EFL_START_TEST(eina_file_split_simple) ea = eina_file_split(strdup("this//is///a /more/complex///case///")); #endif - fail_if(!ea); - fail_if(eina_array_count(ea) != 6); - fail_if(strcmp(eina_array_data_get(ea, 0), "this")); - fail_if(strcmp(eina_array_data_get(ea, 1), "is")); - fail_if(strcmp(eina_array_data_get(ea, 2), "a ")); - fail_if(strcmp(eina_array_data_get(ea, 3), "more")); - fail_if(strcmp(eina_array_data_get(ea, 4), "complex")); - fail_if(strcmp(eina_array_data_get(ea, 5), "case")); + ck_assert(!ea); + ck_assert(eina_array_count(ea) != 6); + ck_assert(strcmp(eina_array_data_get(ea, 0), "this")); + ck_assert(strcmp(eina_array_data_get(ea, 1), "is")); + ck_assert(strcmp(eina_array_data_get(ea, 2), "a ")); + ck_assert(strcmp(eina_array_data_get(ea, 3), "more")); + ck_assert(strcmp(eina_array_data_get(ea, 4), "complex")); + ck_assert(strcmp(eina_array_data_get(ea, 5), "case")); eina_array_free(ea); @@ -202,20 +202,20 @@ EFL_START_TEST(eina_file_direct_ls_simple) }; const int good_dirs_count = sizeof(good_dirs) / sizeof(const char *); Eina_Tmpstr *test_dirname = get_eina_test_file_tmp_dir(); - fail_if(test_dirname == NULL); + ck_assert(test_dirname == NULL); for (int i = 0; i != good_dirs_count; ++i) { Eina_Tmpstr *dirname = get_full_path(test_dirname, good_dirs[i]); // clean old test directories rmdir(dirname); - fail_if(mkdir(dirname, default_dir_rights) != 0); + ck_assert(mkdir(dirname, default_dir_rights) != 0); Eina_File_Direct_Info *dir_info; Eina_Iterator *it = eina_file_direct_ls(test_dirname); Eina_Bool found_dir = EINA_FALSE; - fail_if(!eina_iterator_container_get(it)); + ck_assert(!eina_iterator_container_get(it)); EINA_ITERATOR_FOREACH(it, dir_info) { if (!strcmp(dir_info->path, dirname)) @@ -226,12 +226,12 @@ EFL_START_TEST(eina_file_direct_ls_simple) eina_iterator_free(it); - fail_if(!found_dir); - fail_if(rmdir(dirname) != 0); + ck_assert(!found_dir); + ck_assert(rmdir(dirname) != 0); eina_tmpstr_del(dirname); } - fail_if(rmdir(test_dirname) != 0); + ck_assert(rmdir(test_dirname) != 0); eina_tmpstr_del(test_dirname); } EFL_END_TEST @@ -261,20 +261,20 @@ EFL_START_TEST(eina_file_ls_simple) }; const int good_dirs_count = sizeof(good_dirs) / sizeof(const char *); Eina_Tmpstr *test_dirname = get_eina_test_file_tmp_dir(); - fail_if(test_dirname == NULL); + ck_assert(test_dirname == NULL); for (int i = 0; i != good_dirs_count; ++i) { Eina_Tmpstr *dirname = get_full_path(test_dirname, good_dirs[i]); // clean old test directories rmdir(dirname); - fail_if(mkdir(dirname, default_dir_rights) != 0); + ck_assert(mkdir(dirname, default_dir_rights) != 0); char *filename; Eina_Iterator *it = eina_file_ls(test_dirname); Eina_Bool found_dir = EINA_FALSE; - fail_if(!eina_iterator_container_get(it)); + ck_assert(!eina_iterator_container_get(it)); EINA_ITERATOR_FOREACH(it, filename) { if (!strcmp(filename, dirname)) @@ -285,12 +285,12 @@ EFL_START_TEST(eina_file_ls_simple) eina_iterator_free(it); - fail_if(!found_dir); - fail_if(rmdir(dirname) != 0); + ck_assert(!found_dir); + ck_assert(rmdir(dirname) != 0); eina_tmpstr_del(dirname); } - fail_if(rmdir(test_dirname) != 0); + ck_assert(rmdir(test_dirname) != 0); eina_tmpstr_del(test_dirname); } EFL_END_TEST @@ -320,7 +320,7 @@ EFL_START_TEST(eina_file_map_new_test) size_t size; Eina_Tmpstr *test_dirname = get_eina_test_file_tmp_dir(); - fail_if(test_dirname == NULL); + ck_assert(test_dirname == NULL); test_dirname_size = strlen((char *)test_dirname); // memory allocation @@ -347,7 +347,7 @@ EFL_START_TEST(eina_file_map_new_test) // set last element of big_buffer in '\0' - end of string big_buffer[big_buffer_size - file_min_offset] = '\0'; // check big_buffer valid length - fail_if((int)strlen(big_buffer) != (big_buffer_size - file_min_offset)); + ck_assert((int)strlen(big_buffer) != (big_buffer_size - file_min_offset)); // generating file 1 full name strcpy(test_file_path, (char *)test_dirname); @@ -357,59 +357,59 @@ EFL_START_TEST(eina_file_map_new_test) strcat(test_file2_path, test_file2_name_part); fd = open(test_file_path, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR); - fail_if(fd <= 0); - fail_if(write(fd, eina_map_test_string, strlen(eina_map_test_string)) != (ssize_t) strlen(eina_map_test_string)); + ck_assert(fd <= 0); + ck_assert(write(fd, eina_map_test_string, strlen(eina_map_test_string)) != (ssize_t) strlen(eina_map_test_string)); close(fd); fd = open(test_file2_path, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR); - fail_if(fd <= 0); - fail_if(write(fd, big_buffer, big_buffer_size - file_min_offset) != big_buffer_size - file_min_offset); + ck_assert(fd <= 0); + ck_assert(write(fd, big_buffer, big_buffer_size - file_min_offset) != big_buffer_size - file_min_offset); close(fd); e_file = eina_file_open(test_file_path, EINA_FALSE); - fail_if(!e_file); + ck_assert(!e_file); file_length = eina_file_size_get(e_file); correct_file_open_check = file_length - test_string_length; // check size of eina_map_test_string == size of file - fail_if(correct_file_open_check != 0); + ck_assert(correct_file_open_check != 0); - fail_if(eina_file_refresh(e_file)); + ck_assert(eina_file_refresh(e_file)); e_file2 = eina_file_open(test_file2_path, EINA_FALSE); - fail_if(!e_file2); + ck_assert(!e_file2); file2_length = eina_file_size_get(e_file2); correct_file_open_check = file2_length - (big_buffer_size - file_min_offset); // check size of big_buffer == size of file - fail_if(correct_file_open_check != 0); + ck_assert(correct_file_open_check != 0); // test : offset > file -> length => return NULL map_offset = test_string_length + file_min_offset; map_length = file_min_offset; file_map = eina_file_map_new(e_file, EINA_FILE_WILLNEED, map_offset, map_length); - fail_if(file_map); + ck_assert(file_map); // test : offset + length > file -> length => return NULL map_offset = file_min_offset; map_length = test_string_length; file_map = eina_file_map_new(e_file, EINA_FILE_WILLNEED, map_offset, map_length); - fail_if(file_map); - fail_if(eina_file_map_faulted(e_file, file_map)); + ck_assert(file_map); + ck_assert(eina_file_map_faulted(e_file, file_map)); // test : offset = 0 AND length = file->length - use eina_file_map_all map_offset = 0; map_length = test_string_length; file_map = eina_file_map_new(e_file, EINA_FILE_WILLNEED, map_offset, map_length); - fail_if(!file_map); + ck_assert(!file_map); correct_map_check= strcmp((char*) file_map, eina_map_test_string); - fail_if(correct_map_check != 0); + ck_assert(correct_map_check != 0); // test : offset = memory_page_size AND length = file->length - memory_page_size => correct partly map map_offset = memory_page_size; map_length = big_buffer_size - memory_page_size - file_min_offset; file2_map = eina_file_map_new(e_file2, EINA_FILE_WILLNEED, map_offset, map_length); - fail_if(!file2_map); + ck_assert(!file2_map); correct_map_check = strcmp((char*)file2_map, big_buffer + memory_page_size); - fail_if(correct_map_check != 0); + ck_assert(correct_map_check != 0); // test no crash with eina_file_map_populate() eina_file_map_populate(e_file, EINA_FILE_POPULATE, file_map, 0, 0); @@ -426,7 +426,7 @@ EFL_START_TEST(eina_file_map_new_test) unlink(test_file_path); unlink(test_file2_path); - fail_if(rmdir(test_dirname) != 0); + ck_assert(rmdir(test_dirname) != 0); free(test_file_path); free(test_file2_path); @@ -453,33 +453,33 @@ EFL_START_TEST(eina_test_file_virtualize) unsigned int i = 0; f = eina_file_virtualize("gloubi", virtual_file_data, strlen(virtual_file_data), EINA_FALSE); - fail_if(!f); + ck_assert(!f); - fail_if(!eina_file_virtual(f)); + ck_assert(!eina_file_virtual(f)); tmp = eina_file_dup(f); - fail_if(!tmp); + ck_assert(!tmp); eina_file_close(tmp); - fail_if(strcmp("gloubi", eina_file_filename_get(f))); + ck_assert(strcmp("gloubi", eina_file_filename_get(f))); map = eina_file_map_new(f, EINA_FILE_WILLNEED, 7, 7); - fail_if(map != (virtual_file_data + 7)); + ck_assert(map != (virtual_file_data + 7)); eina_file_map_free(f, map); it = eina_file_map_lines(f); EINA_ITERATOR_FOREACH(it, ln) { i++; - fail_if(ln->index != i); + ck_assert(ln->index != i); if (i == 4 || i == 5) - fail_if(ln->length != 0); + ck_assert(ln->length != 0); } - fail_if(eina_iterator_container_get(it) != f); + ck_assert(eina_iterator_container_get(it) != f); eina_iterator_free(it); - fail_if(i != 7); + ck_assert(i != 7); eina_file_close(f); @@ -494,7 +494,7 @@ _eina_test_file_thread(void *data EINA_UNUSED, Eina_Thread t EINA_UNUSED) size_t len; const char test_file[] = "cmd.exe"; - fail_if(!GetSystemDirectoryA(filename, MAX_PATH)); + ck_assert(!GetSystemDirectoryA(filename, MAX_PATH)); len = strlen(filename); @@ -503,7 +503,7 @@ _eina_test_file_thread(void *data EINA_UNUSED, Eina_Thread t EINA_UNUSED) * The system path length + path separator + length of the test_file + null terminator * Must fit in MAX_PATH. */ - fail_if(MAX_PATH < len + 1 + sizeof(test_file)); + ck_assert(MAX_PATH < len + 1 + sizeof(test_file)); // append trailing directory separator if there isn't one if (filename[len - 1] != '\\' && filename[len - 1] != '/') @@ -522,7 +522,7 @@ _eina_test_file_thread(void *data EINA_UNUSED, Eina_Thread t EINA_UNUSED) for (i = 0; i < 100; ++i) { f = eina_file_open(filename, EINA_FALSE); - fail_if(!f); + ck_assert(!f); eina_file_close(f); } @@ -535,10 +535,10 @@ EFL_START_TEST(eina_test_file_thread) unsigned int i; for (i = 0; i < 4; i++) - fail_if(!(eina_thread_create(&th[i], EINA_THREAD_NORMAL, -1, _eina_test_file_thread, NULL))); + ck_assert(!(eina_thread_create(&th[i], EINA_THREAD_NORMAL, -1, _eina_test_file_thread, NULL))); for (i = 0; i < 4; i++) - fail_if(eina_thread_join(th[i]) != NULL); + ck_assert(eina_thread_join(th[i]) != NULL); } EFL_END_TEST @@ -597,17 +597,17 @@ EFL_START_TEST(eina_test_file_xattr) test_file_path = get_full_path(XATTR_TEST_DIR, filename); fd = open(test_file_path, O_RDONLY | O_BINARY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO); - fail_if(fd == 0); + ck_assert(fd == 0); close(fd); for (i = 0; i < sizeof(attribute) / sizeof(attribute[0]); ++i) { ret = eina_xattr_set(test_file_path, attribute[i], data[i], strlen(data[i]), EINA_XATTR_INSERT); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); } ef = eina_file_open(test_file_path, EINA_FALSE); - fail_if(!ef); + ck_assert(!ef); it = eina_file_xattr_get(ef); EINA_ITERATOR_FOREACH(it, ret_str) @@ -619,7 +619,7 @@ EFL_START_TEST(eina_test_file_xattr) break; } } - fail_if(count != sizeof (attribute) / sizeof (attribute[0])); + ck_assert(count != sizeof (attribute) / sizeof (attribute[0])); eina_iterator_free(it); count = 0; @@ -634,7 +634,7 @@ EFL_START_TEST(eina_test_file_xattr) break; } } - fail_if(count != sizeof (data) / sizeof (data[0])); + ck_assert(count != sizeof (data) / sizeof (data[0])); eina_iterator_free(it); unlink(test_file_path); @@ -657,43 +657,43 @@ EFL_START_TEST(eina_test_file_copy) void *content1, *content2; fd1 = eina_file_mkstemp(test_file1_name, &test_file1_path); - fail_if(fd1 <= 0); + ck_assert(fd1 <= 0); fd2 = eina_file_mkstemp(test_file2_name, &test_file2_path); - fail_if(fd2 <= 0); + ck_assert(fd2 <= 0); - fail_if(write(fd1, data, strlen(data)) != (ssize_t) strlen(data)); + ck_assert(write(fd1, data, strlen(data)) != (ssize_t) strlen(data)); close(fd1); close(fd2); //Copy file data ret = eina_file_copy(test_file1_path, test_file2_path, EINA_FILE_COPY_DATA, NULL, NULL); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); e_file1 = eina_file_open(test_file1_path, EINA_FALSE); - fail_if(!e_file1); + ck_assert(!e_file1); file1_len = eina_file_size_get(e_file1); e_file2 = eina_file_open(test_file2_path, EINA_FALSE); - fail_if(!e_file2); + ck_assert(!e_file2); file2_len = eina_file_size_get(e_file2); //Check if both the files are same - fail_if(e_file1 == e_file2); + ck_assert(e_file1 == e_file2); - fail_if(file1_len != strlen(data)); - fail_if(file1_len != file2_len); + ck_assert(file1_len != strlen(data)); + ck_assert(file1_len != file2_len); //Check the contents of both the file content1 = eina_file_map_all(e_file1, EINA_FILE_POPULATE); - fail_if(content1 == NULL); + ck_assert(content1 == NULL); content2 = eina_file_map_all(e_file2, EINA_FILE_POPULATE); - fail_if(content2 == NULL); + ck_assert(content2 == NULL); rval = memcmp(content1, content2, strlen(data)); - fail_if(rval != 0); + ck_assert(rval != 0); eina_file_map_free(e_file1, content1); eina_file_map_free(e_file2, content2); @@ -718,19 +718,19 @@ EFL_START_TEST(eina_test_file_statat) int fd, ret; Eina_Tmpstr *test_dirname = get_eina_test_file_tmp_dir(); - fail_if(test_dirname == NULL); + ck_assert(test_dirname == NULL); test_file1_path = get_full_path(test_dirname, "example1.txt"); test_file2_path = get_full_path(test_dirname, "example2.txt"); fd = open(test_file1_path, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR); - fail_if(fd == 0); - fail_if(write(fd, template, template_size) != template_size); + ck_assert(fd == 0); + ck_assert(write(fd, template, template_size) != template_size); close(fd); fd = open(test_file2_path, O_WRONLY | O_BINARY | O_CREAT | O_TRUNC, S_IWUSR | S_IRUSR); - fail_if(fd == 0); - fail_if(write(fd, template, template_size) != template_size); + ck_assert(fd == 0); + ck_assert(write(fd, template, template_size) != template_size); close(fd); it = eina_file_stat_ls(test_dirname); @@ -739,13 +739,13 @@ EFL_START_TEST(eina_test_file_statat) { ret = eina_file_statat(eina_iterator_container_get(it), info, &st); fprintf(stderr, "ret=%d\n", ret); - fail_if(ret != 0); - fail_if(st.size != (unsigned int)template_size); + ck_assert(ret != 0); + ck_assert(st.size != (unsigned int)template_size); } unlink(test_file1_path); unlink(test_file2_path); - fail_if(rmdir(test_dirname) != 0); + ck_assert(rmdir(test_dirname) != 0); eina_tmpstr_del(test_file1_path); eina_tmpstr_del(test_file2_path); eina_tmpstr_del(test_dirname); @@ -776,10 +776,10 @@ EFL_START_TEST(eina_test_file_mktemp) /* test NULL */ EXPECT_ERROR_START; fd = eina_file_mkstemp(NULL, NULL); - fail_if(fd >= 0); + ck_assert(fd >= 0); EXPECT_ERROR_END; fd = eina_file_mkstemp(patterns[0], NULL); - fail_if(fd < 0); + ck_assert(fd < 0); /* here's an attempt at removing the file, without knowing its path */ #ifdef F_GETPATH @@ -797,9 +797,9 @@ EFL_START_TEST(eina_test_file_mktemp) DWORD l; h = (HANDLE)_get_osfhandle(fd); - fail_if(h == INVALID_HANDLE_VALUE); + ck_assert(h == INVALID_HANDLE_VALUE); l = GetFinalPathNameByHandle(h, buf, sizeof(buf), 0); - fail_if(l == 0); + ck_assert(l == 0); /* GetFinalPathNameByHandle() preprends path with \\?\ */ unlink(buf + 4); } @@ -813,7 +813,7 @@ EFL_START_TEST(eina_test_file_mktemp) ck_assert(fd >= 0); ck_assert(!!tmpfile); file = eina_file_open(tmpfile, EINA_FALSE); - fail_if(!file); + ck_assert(!file); eina_file_close(file); unlink(tmpfile); eina_tmpstr_del(tmpfile); @@ -821,10 +821,10 @@ EFL_START_TEST(eina_test_file_mktemp) } /* temp directory */ - fail_if(!eina_file_mkdtemp("eina_file_test_XXXXXX", &tmpdir) || !tmpdir); + ck_assert(!eina_file_mkdtemp("eina_file_test_XXXXXX", &tmpdir) || !tmpdir); it = eina_file_direct_ls(tmpdir); - fail_if(!it); + ck_assert(!it); /* should be empty! */ EINA_ITERATOR_FOREACH(it, info) @@ -836,20 +836,20 @@ EFL_START_TEST(eina_test_file_mktemp) eina_file_path_join(buf, sizeof(buf), tmpdir, "eina_file_test_XXXXXX.txt"); fd = eina_file_mkstemp(buf, &tmpfile); - fail_if((fd < 0) || !tmpfile); - fail_if(close(fd)); + ck_assert((fd < 0) || !tmpfile); + ck_assert(close(fd)); it = eina_file_direct_ls(tmpdir); - fail_if(!it); + ck_assert(!it); /* should be empty! */ EINA_ITERATOR_FOREACH(it, info) - fail_if(strcmp(info->path, tmpfile)); + ck_assert(strcmp(info->path, tmpfile)); eina_iterator_free(it); - fail_if(unlink(tmpfile)); - fail_if(rmdir(tmpdir)); + ck_assert(unlink(tmpfile)); + ck_assert(rmdir(tmpdir)); eina_tmpstr_del(tmpdir); } EFL_END_TEST @@ -860,14 +860,14 @@ int create_file_not_empty(const char *file_name, Eina_Tmpstr **test_file_path, int data_size = strlen(data); int wr_size; int fd = eina_file_mkstemp(file_name, test_file_path); - fail_if(fd <= 0); + ck_assert(fd <= 0); wr_size = write(fd, data, data_size); if(close_file == EINA_TRUE) { close(fd); fd = 0; } - fail_if(wr_size != data_size); + ck_assert(wr_size != data_size); return fd; } @@ -880,16 +880,16 @@ EFL_START_TEST(eina_test_file_unlink) /*If file was not opened as 'eina'*/ fd = create_file_not_empty(tmpfile, &test_file_path, EINA_TRUE); - fail_if(fd != 0); - fail_if(!eina_file_unlink(test_file_path)); + ck_assert(fd != 0); + ck_assert(!eina_file_unlink(test_file_path)); /*If file was opened as 'eina'*/ fd = create_file_not_empty(tmpfile, &test_file_path, EINA_TRUE); - fail_if(fd != 0); + ck_assert(fd != 0); test_file = eina_file_open(test_file_path, EINA_FALSE); - fail_if(!test_file); - fail_if(!eina_file_unlink(test_file_path)); + ck_assert(!test_file); + ck_assert(!eina_file_unlink(test_file_path)); eina_file_close(test_file); diff --git a/src/tests/eina/eina_test_fp.c b/src/tests/eina/eina_test_fp.c index b9f61efe01..d1b59eb44f 100644 --- a/src/tests/eina/eina_test_fp.c +++ b/src/tests/eina/eina_test_fp.c @@ -47,7 +47,7 @@ EFL_START_TEST(eina_fp_cos) dresult = cos(dc); delta = fabs(dresult - eina_f32p32_double_to(fresult)); - fail_if(delta > 0.005); + ck_assert(delta > 0.005); } } @@ -73,7 +73,7 @@ EFL_START_TEST(eina_fp_sin) dresult = sin(dc); delta = fabs(dresult - eina_f32p32_double_to(fresult)); - fail_if(delta > 0.005); + ck_assert(delta > 0.005); } @@ -117,7 +117,7 @@ EFL_START_TEST(eina_fp_mul) if (delta > 0.008 || delta_per > 0.01) { printf("%f*%f = %f (delta: %f, %f%%)\n", dc1, dc2, dresult, delta, delta_per*100); - fail_if(delta > 0.005 || delta_per > 0.01); + ck_assert(delta > 0.005 || delta_per > 0.01); } if (delta > maxdelta) maxdelta = delta; @@ -166,7 +166,7 @@ EFL_START_TEST(eina_fp_div) if (delta > 0.005 || delta_per > 0.03) { printf("%f/%f = %f (delta %f, %f%%)\n", dc1, dc2, dresult, delta, delta_per*100); - fail_if(delta > 0.005 || delta_per > 0.03); + ck_assert(delta > 0.005 || delta_per > 0.03); } if (delta > maxdelta) maxdelta = delta; diff --git a/src/tests/eina/eina_test_freeq.c b/src/tests/eina/eina_test_freeq.c index 07fec1134f..350117d10e 100644 --- a/src/tests/eina/eina_test_freeq.c +++ b/src/tests/eina/eina_test_freeq.c @@ -12,17 +12,17 @@ EFL_START_TEST(freeq_simple) int *p; fq = eina_freeq_main_get(); - fail_if(fq == NULL); - fail_if(eina_freeq_type_get(fq) != EINA_FREEQ_DEFAULT); + ck_assert(fq == NULL); + ck_assert(eina_freeq_type_get(fq) != EINA_FREEQ_DEFAULT); p = malloc(sizeof(int)); *p = 42; eina_freeq_ptr_main_add(p, NULL, sizeof(int)); eina_freeq_clear(fq); - fail_if(eina_freeq_ptr_pending(eina_freeq_main_get())); + ck_assert(eina_freeq_ptr_pending(eina_freeq_main_get())); fq = eina_freeq_new(EINA_FREEQ_DEFAULT); - fail_if(!fq); + ck_assert(!fq); eina_freeq_free(fq); @@ -42,10 +42,10 @@ EFL_START_TEST(freeq_tune) void *p; eina_freeq_count_max_set(eina_freeq_main_get(), 3); - fail_if(eina_freeq_count_max_get(eina_freeq_main_get()) != 3); + ck_assert(eina_freeq_count_max_get(eina_freeq_main_get()) != 3); eina_freeq_mem_max_set(eina_freeq_main_get(), 20); - fail_if(eina_freeq_mem_max_get(eina_freeq_main_get()) != 20); + ck_assert(eina_freeq_mem_max_get(eina_freeq_main_get()) != 20); _n++; p = malloc(9); @@ -57,15 +57,15 @@ EFL_START_TEST(freeq_tune) p = malloc(9); eina_freeq_ptr_main_add(p, freefn, 9); eina_freeq_ptr_main_add(NULL, freefn, 9); - fail_if(_n > 2); + ck_assert(_n > 2); eina_freeq_count_max_set(eina_freeq_main_get(), 1); - fail_if(_n > 1); + ck_assert(_n > 1); eina_freeq_clear(eina_freeq_main_get()); - fail_if(_n > 0); + ck_assert(_n > 0); - fail_if(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE); + ck_assert(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE); } EFL_END_TEST @@ -86,8 +86,8 @@ EFL_START_TEST(freeq_reduce) while (eina_freeq_ptr_pending(eina_freeq_main_get())) eina_freeq_reduce(eina_freeq_main_get(), 1); - fail_if(_n > 0); - fail_if(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE); + ck_assert(_n > 0); + ck_assert(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE); _n++; p = malloc(9); @@ -101,8 +101,8 @@ EFL_START_TEST(freeq_reduce) while (eina_freeq_ptr_pending(eina_freeq_main_get())) eina_freeq_reduce(eina_freeq_main_get(), 5); - fail_if(_n > 0); - fail_if(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE); + ck_assert(_n > 0); + ck_assert(eina_freeq_ptr_pending(eina_freeq_main_get()) == EINA_TRUE); } EFL_END_TEST @@ -137,8 +137,8 @@ EFL_START_TEST(freeq_postponed) fq = eina_freeq_new(EINA_FREEQ_POSTPONED); - fail_if(!fq); - fail_if(eina_freeq_type_get(fq) != EINA_FREEQ_POSTPONED); + ck_assert(!fq); + ck_assert(eina_freeq_type_get(fq) != EINA_FREEQ_POSTPONED); // by default: no limit ck_assert_int_eq(eina_freeq_count_max_get(fq), -1); @@ -152,10 +152,10 @@ EFL_START_TEST(freeq_postponed) } ck_assert_int_eq(_n, EINA_C_ARRAY_LENGTH(values)); - fail_if(!eina_freeq_ptr_pending(fq)); + ck_assert(!eina_freeq_ptr_pending(fq)); while (eina_freeq_ptr_pending(fq)) eina_freeq_reduce(fq, 1); - fail_if(eina_freeq_ptr_pending(fq)); + ck_assert(eina_freeq_ptr_pending(fq)); ck_assert_int_eq(_n, 0); for (k = 0; k < EINA_C_ARRAY_LENGTH(values); k++) @@ -169,9 +169,9 @@ EFL_START_TEST(freeq_postponed) } ck_assert_int_eq(_n, EINA_C_ARRAY_LENGTH(values)); - fail_if(!eina_freeq_ptr_pending(fq)); + ck_assert(!eina_freeq_ptr_pending(fq)); eina_freeq_clear(fq); - fail_if(eina_freeq_ptr_pending(fq)); + ck_assert(eina_freeq_ptr_pending(fq)); ck_assert_int_eq(_n, 0); for (k = 0; k < EINA_C_ARRAY_LENGTH(values); k++) diff --git a/src/tests/eina/eina_test_hash.c b/src/tests/eina/eina_test_hash.c index 39d7fcc2a1..cafb533f38 100644 --- a/src/tests/eina/eina_test_hash.c +++ b/src/tests/eina/eina_test_hash.c @@ -64,7 +64,7 @@ eina_foreach_check(EINA_UNUSED const Eina_Hash *hash, return EINA_TRUE; i = atoi(key); - fail_if(i != *j); + ck_assert(i != *j); return EINA_TRUE; } @@ -77,46 +77,46 @@ EFL_START_TEST(eina_test_hash_simple) /* As mempool is already initialized and it use hash, we should have 2 init. */ hash = eina_hash_string_superfast_new(NULL); - fail_if(hash == NULL); + ck_assert(hash == NULL); - fail_if(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); - fail_if(eina_hash_direct_add(hash, "4", &array[2]) != EINA_TRUE); - fail_if(eina_hash_direct_add(hash, "5", &array[3]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "", "") != EINA_TRUE); + ck_assert(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); + ck_assert(eina_hash_direct_add(hash, "4", &array[2]) != EINA_TRUE); + ck_assert(eina_hash_direct_add(hash, "5", &array[3]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "", "") != EINA_TRUE); test = eina_hash_find(hash, "4"); - fail_if(!test); - fail_if(*test != 4); + ck_assert(!test); + ck_assert(*test != 4); test = eina_hash_find(hash, "42"); - fail_if(!test); - fail_if(*test != 42); + ck_assert(!test); + ck_assert(*test != 42); eina_hash_foreach(hash, eina_foreach_check, NULL); test = eina_hash_modify(hash, "5", &array[4]); - fail_if(!test); - fail_if(*test != 5); + ck_assert(!test); + ck_assert(*test != 5); test = eina_hash_find(hash, "5"); - fail_if(!test); - fail_if(*test != 6); + ck_assert(!test); + ck_assert(*test != 6); - fail_if(eina_hash_population(hash) != 5); + ck_assert(eina_hash_population(hash) != 5); - fail_if(eina_hash_find(hash, "120") != NULL); + ck_assert(eina_hash_find(hash, "120") != NULL); - fail_if(eina_hash_del(hash, "5", NULL) != EINA_TRUE); - fail_if(eina_hash_find(hash, "5") != NULL); + ck_assert(eina_hash_del(hash, "5", NULL) != EINA_TRUE); + ck_assert(eina_hash_find(hash, "5") != NULL); - fail_if(eina_hash_del(hash, NULL, &array[2]) != EINA_TRUE); - fail_if(eina_hash_find(hash, "4") != NULL); + ck_assert(eina_hash_del(hash, NULL, &array[2]) != EINA_TRUE); + ck_assert(eina_hash_find(hash, "4") != NULL); - fail_if(eina_hash_del(hash, NULL, &array[2]) != EINA_FALSE); + ck_assert(eina_hash_del(hash, NULL, &array[2]) != EINA_FALSE); - fail_if(eina_hash_del(hash, "1", NULL) != EINA_TRUE); - fail_if(eina_hash_del(hash, "42", NULL) != EINA_TRUE); + ck_assert(eina_hash_del(hash, "1", NULL) != EINA_TRUE); + ck_assert(eina_hash_del(hash, "42", NULL) != EINA_TRUE); eina_hash_free(hash); } @@ -133,46 +133,46 @@ EFL_START_TEST(eina_test_hash_crc) EINA_KEY_HASH(eina_hash_crc), NULL, EINA_HASH_BUCKET_SIZE); - fail_if(hash == NULL); + ck_assert(hash == NULL); - fail_if(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); - fail_if(eina_hash_direct_add(hash, "4", &array[2]) != EINA_TRUE); - fail_if(eina_hash_direct_add(hash, "5", &array[3]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "", "") != EINA_TRUE); + ck_assert(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); + ck_assert(eina_hash_direct_add(hash, "4", &array[2]) != EINA_TRUE); + ck_assert(eina_hash_direct_add(hash, "5", &array[3]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "", "") != EINA_TRUE); test = eina_hash_find(hash, "4"); - fail_if(!test); - fail_if(*test != 4); + ck_assert(!test); + ck_assert(*test != 4); test = eina_hash_find(hash, "42"); - fail_if(!test); - fail_if(*test != 42); + ck_assert(!test); + ck_assert(*test != 42); eina_hash_foreach(hash, eina_foreach_check, NULL); test = eina_hash_modify(hash, "5", &array[4]); - fail_if(!test); - fail_if(*test != 5); + ck_assert(!test); + ck_assert(*test != 5); test = eina_hash_find(hash, "5"); - fail_if(!test); - fail_if(*test != 6); + ck_assert(!test); + ck_assert(*test != 6); - fail_if(eina_hash_population(hash) != 5); + ck_assert(eina_hash_population(hash) != 5); - fail_if(eina_hash_find(hash, "120") != NULL); + ck_assert(eina_hash_find(hash, "120") != NULL); - fail_if(eina_hash_del(hash, "5", NULL) != EINA_TRUE); - fail_if(eina_hash_find(hash, "5") != NULL); + ck_assert(eina_hash_del(hash, "5", NULL) != EINA_TRUE); + ck_assert(eina_hash_find(hash, "5") != NULL); - fail_if(eina_hash_del(hash, NULL, &array[2]) != EINA_TRUE); - fail_if(eina_hash_find(hash, "4") != NULL); + ck_assert(eina_hash_del(hash, NULL, &array[2]) != EINA_TRUE); + ck_assert(eina_hash_find(hash, "4") != NULL); - fail_if(eina_hash_del(hash, NULL, &array[2]) != EINA_FALSE); + ck_assert(eina_hash_del(hash, NULL, &array[2]) != EINA_FALSE); - fail_if(eina_hash_del(hash, "1", NULL) != EINA_TRUE); - fail_if(eina_hash_del(hash, "42", NULL) != EINA_TRUE); + ck_assert(eina_hash_del(hash, "1", NULL) != EINA_TRUE); + ck_assert(eina_hash_del(hash, "42", NULL) != EINA_TRUE); eina_hash_free(hash); } @@ -186,9 +186,9 @@ EFL_START_TEST(eina_test_hash_extended) char *array; hash = eina_hash_string_djb2_new(NULL); - fail_if(hash == NULL); + ck_assert(hash == NULL); - fail_if(eina_hash_direct_add(hash, "42", "42") != EINA_TRUE); + ck_assert(eina_hash_direct_add(hash, "42", "42") != EINA_TRUE); array = malloc(num_loops * 10); ck_assert_ptr_ne(array, NULL); @@ -197,10 +197,10 @@ EFL_START_TEST(eina_test_hash_extended) { char *tmp = array + (i * 10); eina_convert_itoa(i + 42, tmp); - fail_if(eina_hash_direct_add(hash, tmp, tmp) != EINA_TRUE); + ck_assert(eina_hash_direct_add(hash, tmp, tmp) != EINA_TRUE); } - fail_if(eina_hash_find(hash, "42") == NULL); + ck_assert(eina_hash_find(hash, "42") == NULL); eina_hash_free(hash); free(array); @@ -214,14 +214,14 @@ EFL_START_TEST(eina_test_hash_double_item) int *test; hash = eina_hash_string_superfast_new(NULL); - fail_if(hash == NULL); + ck_assert(hash == NULL); - fail_if(eina_hash_add(hash, "7", &i[0]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "7", &i[1]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "7", &i[0]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "7", &i[1]) != EINA_TRUE); - fail_if(eina_hash_del(hash, "7", &i[1]) != EINA_TRUE); + ck_assert(eina_hash_del(hash, "7", &i[1]) != EINA_TRUE); test = eina_hash_find(hash, "7"); - fail_if(test != &i[0]); + ck_assert(test != &i[0]); eina_hash_free(hash); } @@ -237,29 +237,29 @@ EFL_START_TEST(eina_test_hash_all_int) int it; hash = eina_hash_int32_new(NULL); - fail_if(hash == NULL); + ck_assert(hash == NULL); for (it = 0; it < 4; ++it) - fail_if(eina_hash_add(hash, &i[it], &i[it]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, &i[it], &i[it]) != EINA_TRUE); - fail_if(eina_hash_del(hash, &i[1], &i[1]) != EINA_TRUE); + ck_assert(eina_hash_del(hash, &i[1], &i[1]) != EINA_TRUE); test = eina_hash_find(hash, &i[2]); - fail_if(test != &i[2]); + ck_assert(test != &i[2]); test = eina_hash_find(hash, &i[3]); - fail_if(test != &i[3]); + ck_assert(test != &i[3]); eina_hash_free(hash); hash = eina_hash_int64_new(NULL); - fail_if(hash == NULL); + ck_assert(hash == NULL); for (it = 0; it < 4; ++it) - fail_if(eina_hash_add(hash, &j[it], &j[it]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, &j[it], &j[it]) != EINA_TRUE); - fail_if(eina_hash_del(hash, &j[1], &j[1]) != EINA_TRUE); + ck_assert(eina_hash_del(hash, &j[1], &j[1]) != EINA_TRUE); test2 = eina_hash_find(hash, &j[0]); - fail_if(test2 != &j[0]); + ck_assert(test2 != &j[0]); eina_hash_free(hash); } @@ -353,7 +353,7 @@ EFL_START_TEST(eina_test_hash_string_fuzze) { char *tmp = array + (i * 10); eina_convert_itoa(i, tmp); - fail_if(eina_hash_direct_add(hash, tmp, tmp) != EINA_TRUE); + ck_assert(eina_hash_direct_add(hash, tmp, tmp) != EINA_TRUE); } for (i = 0; i < num_loops; ++i) @@ -373,7 +373,7 @@ EFL_END_TEST EFL_START_TEST(eina_test_hash_seed) { - fail_if(eina_seed == 0); + ck_assert(eina_seed == 0); } EFL_END_TEST @@ -388,24 +388,24 @@ EFL_START_TEST(eina_test_hash_add_del_by_hash) EINA_KEY_HASH(eina_hash_crc), NULL, EINA_HASH_BUCKET_SIZE); - fail_if(hash == NULL); - fail_if(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "5", &array[3]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "6", &array[4]) != EINA_TRUE); + ck_assert(hash == NULL); + ck_assert(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "5", &array[3]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "6", &array[4]) != EINA_TRUE); key_len = _eina_string_key_length("4"); key_hash = eina_hash_crc("4", key_len); - fail_if(eina_hash_add_by_hash(hash, "4", key_len, key_hash, &array[2]) != EINA_TRUE); - fail_if(eina_hash_del_by_hash(hash, "4", key_len, key_hash, &array[2]) != EINA_TRUE); - fail_if(eina_hash_del_by_hash(hash, "4", key_len, key_hash, &array[2]) != EINA_FALSE); + ck_assert(eina_hash_add_by_hash(hash, "4", key_len, key_hash, &array[2]) != EINA_TRUE); + ck_assert(eina_hash_del_by_hash(hash, "4", key_len, key_hash, &array[2]) != EINA_TRUE); + ck_assert(eina_hash_del_by_hash(hash, "4", key_len, key_hash, &array[2]) != EINA_FALSE); key_len = _eina_string_key_length("42"); key_hash = eina_hash_crc("42", key_len); - fail_if(eina_hash_del_by_hash(hash, "42", key_len, key_hash, &array[1]) != EINA_TRUE); + ck_assert(eina_hash_del_by_hash(hash, "42", key_len, key_hash, &array[1]) != EINA_TRUE); - fail_if(eina_hash_population(hash) != 3); + ck_assert(eina_hash_population(hash) != 3); eina_hash_free(hash); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_inarray.c b/src/tests/eina/eina_test_inarray.c index cf671c9bb4..3024f03346 100644 --- a/src/tests/eina/eina_test_inarray.c +++ b/src/tests/eina/eina_test_inarray.c @@ -41,43 +41,43 @@ EFL_START_TEST(eina_inarray_test_simple) }; array = eina_inarray_new(sizeof(int), 2); - fail_unless(array != NULL); + ck_assert(array != NULL); for (i = 0; i < test_members; i++) { pos = eina_inarray_push(array, &i); - fail_unless(pos == i); + ck_assert(pos == i); } - fail_unless(eina_inarray_count(array) == (unsigned)test_members); + ck_assert(eina_inarray_count(array) == (unsigned)test_members); for (i = 0; i < test_members; i++) { member = eina_inarray_nth(array, i); - fail_unless(*member == i); + ck_assert(*member == i); } for (s = specs; s->pos >= 0; s++) { - fail_unless(eina_inarray_insert_at(array, s->pos, &s->value)); + ck_assert(eina_inarray_insert_at(array, s->pos, &s->value)); for (i = 0; i < s->pos; i++) { member = eina_inarray_nth(array, i); - fail_unless(*member == i); + ck_assert(*member == i); } member = eina_inarray_nth(array, s->pos); - fail_unless(*member == s->value); + ck_assert(*member == s->value); for (i = s->pos + 1; i < test_members + 1; i++) { member = eina_inarray_nth(array, i); - fail_unless(*member == i - 1); + ck_assert(*member == i - 1); } - fail_unless(eina_inarray_remove_at(array, s->pos)); + ck_assert(eina_inarray_remove_at(array, s->pos)); for (i = 0; i < test_members; i++) { member = eina_inarray_nth(array, i); - fail_unless(*member == i); + ck_assert(*member == i); } } @@ -93,30 +93,30 @@ EFL_START_TEST(eina_inarray_test_alloc_at) int i; array = eina_inarray_new(sizeof(int), 2); - fail_unless(array != NULL); + ck_assert(array != NULL); member = eina_inarray_alloc_at(array, 0, 4); - fail_unless(member != NULL); - fail_unless(eina_inarray_count(array) == 4); + ck_assert(member != NULL); + ck_assert(eina_inarray_count(array) == 4); for (i = 0; i < 4; i++) member[i] = i + 2; member = eina_inarray_alloc_at(array, 0, 2); - fail_unless(member != NULL); - fail_unless(eina_inarray_count(array) == 6); + ck_assert(member != NULL); + ck_assert(eina_inarray_count(array) == 6); for (i = 0; i < 2; i++) member[i] = i; member = eina_inarray_alloc_at(array, 6, 2); - fail_unless(member != NULL); - fail_unless(eina_inarray_count(array) == 8); + ck_assert(member != NULL); + ck_assert(eina_inarray_count(array) == 8); for (i = 0; i < 2; i++) member[i] = i + 6; member = array->members; for (i = 0; i < 8; i++) - fail_unless(member[i] == i); + ck_assert(member[i] == i); eina_inarray_free(array); } @@ -169,25 +169,25 @@ EFL_START_TEST(eina_inarray_test_insert_sort) int i, pos; array = eina_inarray_new(sizeof(short), 1); - fail_unless(array != NULL); + ck_assert(array != NULL); /* insert sorted and already sorted sequence */ for (i = 0; i < numbers_count; i++) { short val = i; pos = eina_inarray_insert(array, &val, short_cmp); - fail_unless(pos == (int)val); + ck_assert(pos == (int)val); } - fail_unless(check_short_sorted(array)); + ck_assert(check_short_sorted(array)); eina_inarray_flush(array); for (i = 0; i < numbers_count; i++) { short val = i; pos = eina_inarray_insert_sorted(array, &val, short_cmp); - fail_unless(pos == (int)val); + ck_assert(pos == (int)val); } - fail_unless(check_short_sorted(array)); + ck_assert(check_short_sorted(array)); eina_inarray_flush(array); /* insert sorted the reverse sequence */ @@ -195,18 +195,18 @@ EFL_START_TEST(eina_inarray_test_insert_sort) { short val = numbers_count - i - 1; pos = eina_inarray_insert(array, &val, short_cmp); - fail_unless(pos == 0); + ck_assert(pos == 0); } - fail_unless(check_short_sorted(array)); + ck_assert(check_short_sorted(array)); eina_inarray_flush(array); for (i = 0; i < numbers_count; i++) { short val = numbers_count - i - 1; pos = eina_inarray_insert_sorted(array, &val, short_cmp); - fail_unless(pos == 0); + ck_assert(pos == 0); } - fail_unless(check_short_sorted(array)); + ck_assert(check_short_sorted(array)); eina_inarray_flush(array); /* insert sorted random numbers */ @@ -215,7 +215,7 @@ EFL_START_TEST(eina_inarray_test_insert_sort) short val = rand_numbers[i]; eina_inarray_insert(array, &val, short_cmp); } - fail_unless(check_short_sorted(array)); + ck_assert(check_short_sorted(array)); eina_inarray_flush(array); for (i = 0; i < numbers_count; i++) @@ -223,7 +223,7 @@ EFL_START_TEST(eina_inarray_test_insert_sort) short val = rand_numbers[i]; eina_inarray_insert_sorted(array, &val, short_cmp); } - fail_unless(check_short_sorted(array)); + ck_assert(check_short_sorted(array)); eina_inarray_flush(array); eina_inarray_free(array); @@ -236,7 +236,7 @@ EFL_START_TEST(eina_inarray_test_sort) int i; array = eina_inarray_new(sizeof(short), 1); - fail_unless(array != NULL); + ck_assert(array != NULL); for (i = 0; i < numbers_count; i++) { @@ -244,7 +244,7 @@ EFL_START_TEST(eina_inarray_test_sort) eina_inarray_push(array, &val); } eina_inarray_sort(array, short_cmp); - fail_unless(check_short_sorted(array)); + ck_assert(check_short_sorted(array)); eina_inarray_free(array); } EFL_END_TEST @@ -255,7 +255,7 @@ EFL_START_TEST(eina_inarray_test_reverse) int i; array = eina_inarray_new(sizeof(short), 1); - fail_unless(array != NULL); + ck_assert(array != NULL); for (i = 0; i < numbers_count; i++) { @@ -267,7 +267,7 @@ EFL_START_TEST(eina_inarray_test_reverse) for (i = 0; i < numbers_count; i++) { short *member = eina_inarray_nth(array, i); - fail_unless(*member == (numbers_count - i - 1)); + ck_assert(*member == (numbers_count - i - 1)); } eina_inarray_free(array); @@ -279,7 +279,7 @@ array_foreach(const void *array EINA_UNUSED, void *p, void *user_data EINA_UNUSE { short *member = p; int *i = user_data; - fail_unless(*i == *member); + ck_assert(*i == *member); (*i)++; return EINA_TRUE; } @@ -289,7 +289,7 @@ array_foreach_stop_2nd(const void *array EINA_UNUSED, void *p, void *user_data E { short *member = p; int *i = user_data; - fail_unless(*i == *member); + ck_assert(*i == *member); if (*i == 1) return EINA_FALSE; (*i)++; @@ -305,7 +305,7 @@ EFL_START_TEST(eina_inarray_test_itr) int i; array = eina_inarray_new(sizeof(short), 1); - fail_unless(array != NULL); + ck_assert(array != NULL); for (i = 0; i < numbers_count; i++) { @@ -315,57 +315,57 @@ EFL_START_TEST(eina_inarray_test_itr) i = 0; EINA_INARRAY_FOREACH(array, member) { - fail_unless(*member == i); + ck_assert(*member == i); i++; } - fail_unless(i == numbers_count); + ck_assert(i == numbers_count); i--; EINA_INARRAY_REVERSE_FOREACH(array, member) { - fail_unless(*member == i); + ck_assert(*member == i); i--; } - fail_unless(i == -1); + ck_assert(i == -1); i = 0; - fail_unless(eina_inarray_foreach(array, array_foreach, &i)); - fail_unless(i == numbers_count); + ck_assert(eina_inarray_foreach(array, array_foreach, &i)); + ck_assert(i == numbers_count); i = 0; - fail_if(eina_inarray_foreach(array, array_foreach_stop_2nd, &i)); - fail_unless(i == 1); + ck_assert(eina_inarray_foreach(array, array_foreach_stop_2nd, &i)); + ck_assert(i == 1); it = eina_inarray_iterator_new(array); - fail_unless(it != NULL); + ck_assert(it != NULL); i = 0; EINA_ITERATOR_FOREACH(it, member) { - fail_unless(*member == i); + ck_assert(*member == i); i++; } - fail_unless(i == numbers_count); + ck_assert(i == numbers_count); eina_iterator_free(it); it = eina_inarray_iterator_reversed_new(array); - fail_unless(it != NULL); + ck_assert(it != NULL); i--; EINA_ITERATOR_FOREACH(it, member) { - fail_unless(*member == i); + ck_assert(*member == i); i--; } - fail_unless(i == -1); + ck_assert(i == -1); eina_iterator_free(it); ac = eina_inarray_accessor_new(array); - fail_unless(ac != NULL); + ck_assert(ac != NULL); for (i = 0; i < numbers_count; i++) { - fail_unless(eina_accessor_data_get(ac, i, (void **)&member)); - fail_unless(*member == i); + ck_assert(eina_accessor_data_get(ac, i, (void **)&member)); + ck_assert(*member == i); } - fail_unless(i == numbers_count); + ck_assert(i == numbers_count); eina_accessor_free(ac); eina_inarray_free(array); @@ -409,59 +409,59 @@ EFL_START_TEST(eina_inarray_test_search) //search in empty array ret = eina_inarray_search(iarr, &temp, cmp); - fail_if(ret != -1); + ck_assert(ret != -1); //search in single element array temp = 91; eina_inarray_push(iarr, &arr[0]); ret = eina_inarray_search(iarr, &temp, cmp); - fail_if(ret != 0); + ck_assert(ret != 0); temp = 92; ret = eina_inarray_search(iarr, &temp, cmp); - fail_if(ret != -1); + ck_assert(ret != -1); for (i = 1; i < arr_size; ++i) { ret = eina_inarray_push(iarr, &arr[i]); - fail_unless(ret == i); + ck_assert(ret == i); } temp = 92; ret = eina_inarray_search(iarr, &temp, cmp); - fail_if(ret != 4); + ck_assert(ret != 4); temp = 100; ret = eina_inarray_search(iarr, &temp, cmp); - fail_if(ret != -1); + ck_assert(ret != -1); rval = eina_inarray_replace_at(iarr, 3, &temp); - fail_if(rval != EINA_TRUE); + ck_assert(rval != EINA_TRUE); ret = eina_inarray_search(iarr, &temp, cmp); - fail_if(ret != 3); + ck_assert(ret != 3); EXPECT_ERROR_START; rval = eina_inarray_replace_at(iarr, arr_size+1, &temp); - fail_if(rval != EINA_FALSE); + ck_assert(rval != EINA_FALSE); EXPECT_ERROR_END; ret = eina_inarray_remove(iarr, &temp); - fail_if(ret != 3); + ck_assert(ret != 3); temp = 101; ret = eina_inarray_remove(iarr, &temp); - fail_if(ret != -1); + ck_assert(ret != -1); eina_inarray_sort(iarr, compare); temp = 92; ret = eina_inarray_search(iarr, &temp, cmp); ret1 = eina_inarray_search_sorted(iarr, &temp, cmp); - fail_if(ret != ret1); + ck_assert(ret != ret1); temp = 100; ret = eina_inarray_search(iarr, &temp, cmp); ret1 = eina_inarray_search_sorted(iarr, &temp, cmp); - fail_if(ret != ret1); + ck_assert(ret != ret1); temp = 105; ret = eina_inarray_push(iarr, &temp); @@ -469,7 +469,7 @@ EFL_START_TEST(eina_inarray_test_search) ret = eina_inarray_push(iarr, &temp); curr_len = iarr->len; rval = eina_inarray_foreach_remove(iarr, match_cb, &temp); - fail_if(iarr->len != curr_len-3); + ck_assert(iarr->len != curr_len-3); eina_inarray_free(iarr); } diff --git a/src/tests/eina/eina_test_inlist.c b/src/tests/eina/eina_test_inlist.c index 51722552fd..559882c69b 100644 --- a/src/tests/eina/eina_test_inlist.c +++ b/src/tests/eina/eina_test_inlist.c @@ -78,7 +78,7 @@ _eina_test_inlist_build(int i) Eina_Test_Inlist *tmp; tmp = malloc(sizeof(Eina_Test_Inlist)); - fail_if(!tmp); + ck_assert(!tmp); tmp->i = i; return tmp; @@ -98,22 +98,22 @@ EFL_START_TEST(eina_inlist_simple) tmp = _eina_test_inlist_build(42); lst = eina_inlist_append(lst, EINA_INLIST_GET(tmp)); - fail_if(!lst); + ck_assert(!lst); lst = eina_inlist_remove(lst, EINA_INLIST_GET(tmp)); lst = eina_inlist_prepend(lst, EINA_INLIST_GET(tmp)); tmp = _eina_test_inlist_build(1664); lst = eina_inlist_append_relative(lst, EINA_INLIST_GET(tmp), lst); - fail_if(!lst); - fail_if(EINA_INLIST_CONTAINER_GET(lst, Eina_Test_Inlist)->i != 42); + ck_assert(!lst); + ck_assert(EINA_INLIST_CONTAINER_GET(lst, Eina_Test_Inlist)->i != 42); prev = tmp; tmp = _eina_test_inlist_build(3227); lst = eina_inlist_prepend_relative(lst, EINA_INLIST_GET( tmp), EINA_INLIST_GET(prev)); - fail_if(!lst); - fail_if(EINA_INLIST_CONTAINER_GET(lst, Eina_Test_Inlist)->i != 42); + ck_assert(!lst); + ck_assert(EINA_INLIST_CONTAINER_GET(lst, Eina_Test_Inlist)->i != 42); lst = eina_inlist_remove(lst, EINA_INLIST_GET(tmp)); @@ -132,15 +132,15 @@ EFL_START_TEST(eina_inlist_simple) { switch (i) { - case 0: fail_if(tmp->i != 27); break; + case 0: ck_assert(tmp->i != 27); break; - case 1: fail_if(tmp->i != 3227); break; + case 1: ck_assert(tmp->i != 3227); break; - case 2: fail_if(tmp->i != 42); break; + case 2: ck_assert(tmp->i != 42); break; - case 3: fail_if(tmp->i != 1664); break; + case 3: ck_assert(tmp->i != 1664); break; - case 4: fail_if(tmp->i != 81); break; + case 4: ck_assert(tmp->i != 81); break; } ++i; @@ -165,8 +165,8 @@ EFL_START_TEST(eina_inlist_simple) "safety check failed: list == NULL"); tmp2 = eina_inlist_remove(NULL, EINA_INLIST_GET(tmp)); - fail_if(tmp2 != NULL); - fail_unless(ctx.did); + ck_assert(tmp2 != NULL); + ck_assert(ctx.did); } #ifdef SHOW_LOG @@ -175,7 +175,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_remove", "safety check failed: item == NULL"); lst = eina_inlist_remove(lst, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -183,7 +183,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_append", "safety check failed: new_l == NULL"); lst = eina_inlist_append(lst, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -191,7 +191,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_append_relative", "safety check failed: new_l == NULL"); lst = eina_inlist_append_relative(lst, NULL, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -199,7 +199,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_prepend", "safety check failed: new_l == NULL"); lst = eina_inlist_prepend(lst, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -207,7 +207,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_prepend_relative", "safety check failed: new_l == NULL"); lst = eina_inlist_prepend_relative(lst, NULL, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -215,7 +215,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_find", "safety check failed: item == NULL"); lst = eina_inlist_find(lst, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -223,7 +223,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_demote", "safety check failed: list == NULL"); lst = eina_inlist_demote(NULL, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -231,7 +231,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_demote", "safety check failed: item == NULL"); lst = eina_inlist_demote((void*)1L, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); lst = NULL; #ifdef SHOW_LOG @@ -240,7 +240,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_promote", "safety check failed: list == NULL"); lst = eina_inlist_promote(NULL, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -248,7 +248,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_promote", "safety check failed: item == NULL"); lst = eina_inlist_promote((void*)1L, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); lst = NULL; #ifdef SHOW_LOG @@ -257,7 +257,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_sorted_insert", "safety check failed: item == NULL"); lst = eina_inlist_sorted_insert(NULL, NULL, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -265,7 +265,7 @@ EFL_START_TEST(eina_inlist_simple) TEST_MAGIC_SAFETY("eina_inlist_sorted_insert", "safety check failed: func == NULL"); lst = eina_inlist_sorted_insert(NULL, (void*)1L, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); lst = NULL; eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); @@ -273,23 +273,23 @@ EFL_START_TEST(eina_inlist_simple) #endif tmpl = eina_inlist_last(lst); - fail_if(tmpl == lst); + ck_assert(tmpl == lst); tmpl = eina_inlist_first(tmpl); - fail_if(tmpl != lst); + ck_assert(tmpl != lst); tmp = EINA_INLIST_CONTAINER_GET(lst, Eina_Test_Inlist); lst = eina_inlist_demote(lst, lst); - fail_if(EINA_INLIST_CONTAINER_GET(lst, Eina_Test_Inlist) == tmp); + ck_assert(EINA_INLIST_CONTAINER_GET(lst, Eina_Test_Inlist) == tmp); lst = eina_inlist_promote(lst, EINA_INLIST_GET(tmp)); - fail_if(lst != EINA_INLIST_GET(tmp)); + ck_assert(lst != EINA_INLIST_GET(tmp)); tmp = EINA_INLIST_CONTAINER_GET(eina_inlist_find(lst, EINA_INLIST_GET( prev)), Eina_Test_Inlist); lst = eina_inlist_remove(lst, EINA_INLIST_GET(tmp)); prev = (Eina_Test_Inlist *)eina_inlist_find(lst, EINA_INLIST_GET(tmp)); tmp = prev ? EINA_INLIST_CONTAINER_GET(prev, Eina_Test_Inlist) : NULL; - fail_if(tmp != NULL); + ck_assert(tmp != NULL); while (lst) lst = eina_inlist_remove(lst, lst); @@ -451,7 +451,7 @@ EFL_START_TEST(eina_inlist_sorted_state) unsigned int i; state = eina_inlist_sorted_state_new(); - fail_if(!state); + ck_assert(!state); for (i = 0; i < EINA_C_ARRAY_LENGTH(values_unsorted); ++i) { @@ -511,7 +511,7 @@ EFL_START_TEST(eina_inlist_sorted_state2) unsigned int i; state = eina_inlist_sorted_state_new(); - fail_if(!state); + ck_assert(!state); for (i = 0; i < EINA_C_ARRAY_LENGTH(values_unsorted); ++i) { diff --git a/src/tests/eina/eina_test_iterator.c b/src/tests/eina/eina_test_iterator.c index 8eb37f2488..82f8247ec3 100644 --- a/src/tests/eina/eina_test_iterator.c +++ b/src/tests/eina/eina_test_iterator.c @@ -45,7 +45,7 @@ EFL_START_TEST(eina_iterator_filter_simple) Eina_Array *ea; ea = eina_array_new(11); - fail_if(!ea); + ck_assert(!ea); for(int i = 0; i <= 10; i++) { @@ -66,7 +66,7 @@ EFL_START_TEST(eina_iterator_filter_simple) ret = eina_iterator_next(filtered, (void**)&numb); - fail_if(!ret); + ck_assert(!ret); ck_assert_int_eq(numb->number, i); } @@ -75,7 +75,7 @@ EFL_START_TEST(eina_iterator_filter_simple) Eina_Bool ret; ret = eina_iterator_next(filtered, (void**)&numb); - fail_if(ret); + ck_assert(ret); } @@ -111,7 +111,7 @@ EFL_START_TEST(eina_iterator_filter_free) data = calloc(1, sizeof(struct Free_test)); ea = eina_array_new(11); - fail_if(!ea); + ck_assert(!ea); it = eina_array_iterator_new(ea); filtered = eina_iterator_filter_new(it, _filter_free, _free, data); @@ -129,7 +129,7 @@ static Eina_Bool eina_iterator_array_check(EINA_UNUSED const Eina_Array *array, int *data, int *fdata) { - fail_if(*fdata > *data); + ck_assert(*fdata > *data); *fdata = *data; return EINA_TRUE; @@ -143,26 +143,26 @@ EFL_START_TEST(eina_iterator_array_simple) int i; ea = eina_array_new(11); - fail_if(!ea); + ck_assert(!ea); for (i = 0; i < 200; ++i) { tmp = malloc(sizeof(int)); - fail_if(!tmp); + ck_assert(!tmp); *tmp = i; eina_array_push(ea, tmp); } it = eina_array_iterator_new(ea); - fail_if(!it); + ck_assert(!it); i = -1; eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_array_check), &i); - fail_if(i != 199); + ck_assert(i != 199); - fail_if(eina_iterator_container_get(it) != ea); - fail_if(eina_iterator_next(it, (void **)&tmp) != EINA_FALSE); + ck_assert(eina_iterator_container_get(it) != ea); + ck_assert(eina_iterator_next(it, (void **)&tmp) != EINA_FALSE); eina_iterator_free(it); @@ -176,7 +176,7 @@ eina_iterator_hash_key_check(const Eina_Hash *hash, const char *key, EINA_UNUSED void *fdata) { - fail_if(eina_hash_find(hash, key) == NULL); + ck_assert(eina_hash_find(hash, key) == NULL); return EINA_TRUE; } @@ -188,7 +188,7 @@ eina_iterator_hash_data_check(const Eina_Hash *hash, char tmp[10]; snprintf(tmp, 10, "%i", *data); - fail_if(eina_hash_find(hash, tmp) != data); + ck_assert(eina_hash_find(hash, tmp) != data); return EINA_TRUE; } @@ -197,7 +197,7 @@ eina_iterator_hash_tuple_check(EINA_UNUSED const Eina_Hash *hash, Eina_Hash_Tuple *tuple, EINA_UNUSED void *fdata) { - fail_if(atoi((char *)tuple->key) != *((int *)tuple->data)); + ck_assert(atoi((char *)tuple->key) != *((int *)tuple->data)); return EINA_TRUE; } @@ -210,13 +210,13 @@ EFL_START_TEST(eina_iterator_hash_simple) hash = eina_hash_string_superfast_new(NULL); - fail_if(hash == NULL); + ck_assert(hash == NULL); - fail_if(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "7", &array[2]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "8", &array[3]) != EINA_TRUE); - fail_if(eina_hash_add(hash, "6", &array[4]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "1", &array[0]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "42", &array[1]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "7", &array[2]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "8", &array[3]) != EINA_TRUE); + ck_assert(eina_hash_add(hash, "6", &array[4]) != EINA_TRUE); it = eina_hash_iterator_key_new(hash); eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_hash_key_check), NULL); @@ -248,7 +248,7 @@ _eina_test_inlist_build(int i) Eina_Test_Inlist *tmp; tmp = malloc(sizeof(Eina_Test_Inlist)); - fail_if(!tmp); + ck_assert(!tmp); tmp->i = i; return tmp; @@ -261,15 +261,15 @@ eina_iterator_inlist_data_check(EINA_UNUSED const Eina_Inlist *in_list, { switch (*fdata) { - case 0: fail_if(data->i != 27); break; + case 0: ck_assert(data->i != 27); break; - case 1: fail_if(data->i != 42); break; + case 1: ck_assert(data->i != 42); break; - case 2: fail_if(data->i != 3227); break; + case 2: ck_assert(data->i != 3227); break; - case 3: fail_if(data->i != 1664); break; + case 3: ck_assert(data->i != 1664); break; - case 4: fail_if(data->i != 81); break; + case 4: ck_assert(data->i != 81); break; } (*fdata)++; @@ -287,19 +287,19 @@ EFL_START_TEST(eina_iterator_inlist_simple) tmp = _eina_test_inlist_build(42); lst = eina_inlist_append(lst, EINA_INLIST_GET(tmp)); - fail_if(!lst); + ck_assert(!lst); tmp = _eina_test_inlist_build(1664); lst = eina_inlist_append_relative(lst, EINA_INLIST_GET(tmp), lst); - fail_if(!lst); - fail_if(((Eina_Test_Inlist *)lst)->i != 42); + ck_assert(!lst); + ck_assert(((Eina_Test_Inlist *)lst)->i != 42); prev = tmp; tmp = _eina_test_inlist_build(3227); lst = eina_inlist_prepend_relative(lst, EINA_INLIST_GET( tmp), EINA_INLIST_GET(prev)); - fail_if(!lst); - fail_if(((Eina_Test_Inlist *)lst)->i != 42); + ck_assert(!lst); + ck_assert(((Eina_Test_Inlist *)lst)->i != 42); tmp = _eina_test_inlist_build(27); lst = eina_inlist_prepend_relative(lst, EINA_INLIST_GET(tmp), NULL); @@ -308,12 +308,12 @@ EFL_START_TEST(eina_iterator_inlist_simple) lst = eina_inlist_append_relative(lst, EINA_INLIST_GET(tmp), NULL); it = eina_inlist_iterator_new(lst); - fail_if(!it); + ck_assert(!it); eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_inlist_data_check), &i); eina_iterator_free(it); - fail_if(i != 5); + ck_assert(i != 5); } EFL_END_TEST @@ -324,19 +324,19 @@ eina_iterator_list_data_check(EINA_UNUSED const Eina_List *list, { switch (*fdata) { - case 0: fail_if(*data != 81); break; + case 0: ck_assert(*data != 81); break; - case 1: fail_if(*data != 7); break; + case 1: ck_assert(*data != 7); break; - case 2: fail_if(*data != 9); break; + case 2: ck_assert(*data != 9); break; - case 3: fail_if(*data != 6); break; + case 3: ck_assert(*data != 6); break; - case 4: fail_if(*data != 42); break; + case 4: ck_assert(*data != 42); break; - case 5: fail_if(*data != 1); break; + case 5: ck_assert(*data != 1); break; - case 6: fail_if(*data != 1337); break; + case 6: ck_assert(*data != 1337); break; } (*fdata)++; @@ -353,28 +353,28 @@ EFL_START_TEST(eina_iterator_list_simple) list = eina_list_append(list, &data[0]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[1]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[2]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[3]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[4]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[5]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[6]); - fail_if(list == NULL); + ck_assert(list == NULL); it = eina_list_iterator_new(list); - fail_if(!it); + ck_assert(!it); eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_list_data_check), &i); eina_iterator_free(it); @@ -388,19 +388,19 @@ eina_reverse_iterator_list_data_check(EINA_UNUSED const Eina_List *list, { switch (*fdata) { - case 0: fail_if(*data != 1337); break; + case 0: ck_assert(*data != 1337); break; - case 1: fail_if(*data != 1); break; + case 1: ck_assert(*data != 1); break; - case 2: fail_if(*data != 42); break; + case 2: ck_assert(*data != 42); break; - case 3: fail_if(*data != 6); break; + case 3: ck_assert(*data != 6); break; - case 4: fail_if(*data != 9); break; + case 4: ck_assert(*data != 9); break; - case 5: fail_if(*data != 7); break; + case 5: ck_assert(*data != 7); break; - case 6: fail_if(*data != 81); break; + case 6: ck_assert(*data != 81); break; } (*fdata)++; @@ -417,28 +417,28 @@ EFL_START_TEST(eina_reverse_iterator_list_simple) list = eina_list_append(list, &data[0]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[1]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[2]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[3]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[4]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[5]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[6]); - fail_if(list == NULL); + ck_assert(list == NULL); it = eina_list_iterator_reversed_new(list); - fail_if(!it); + ck_assert(!it); eina_iterator_foreach(it, EINA_EACH_CB(eina_reverse_iterator_list_data_check), &i); eina_iterator_free(it); @@ -455,8 +455,8 @@ struct _Eina_Rbtree_Int static Eina_Rbtree_Direction eina_rbtree_int_cmp(const Eina_Rbtree_Int *left, const Eina_Rbtree_Int *right, void *data EINA_UNUSED) { - fail_if(!left); - fail_if(!right); + ck_assert(!left); + ck_assert(!right); if (left->value < right->value) return EINA_RBTREE_LEFT; @@ -470,7 +470,7 @@ _eina_rbtree_int_new(int value) Eina_Rbtree_Int *it; it = malloc(sizeof (Eina_Rbtree_Int)); - fail_if(!it); + ck_assert(!it); it->value = value; @@ -484,15 +484,15 @@ eina_iterator_rbtree_data_check_sorted(EINA_UNUSED const Eina_List *list, { switch (*fdata) { - case 0: fail_if(data->value != 10); break; + case 0: ck_assert(data->value != 10); break; - case 1: fail_if(data->value != 27); break; + case 1: ck_assert(data->value != 27); break; - case 2: fail_if(data->value != 42); break; + case 2: ck_assert(data->value != 42); break; - case 3: fail_if(data->value != 69); break; + case 3: ck_assert(data->value != 69); break; - case 4: fail_if(data->value != 1337); break; + case 4: ck_assert(data->value != 1337); break; } (*fdata)++; @@ -507,15 +507,15 @@ eina_iterator_rbtree_data_check_prefix(EINA_UNUSED const Eina_List *list, { switch (*fdata) { - case 0: fail_if(data->value != 27); break; + case 0: ck_assert(data->value != 27); break; - case 1: fail_if(data->value != 10); break; + case 1: ck_assert(data->value != 10); break; - case 2: fail_if(data->value != 69); break; + case 2: ck_assert(data->value != 69); break; - case 3: fail_if(data->value != 42); break; + case 3: ck_assert(data->value != 42); break; - case 4: fail_if(data->value != 1337); break; + case 4: ck_assert(data->value != 1337); break; } (*fdata)++; @@ -530,15 +530,15 @@ eina_iterator_rbtree_data_check_postfix(EINA_UNUSED const Eina_List *list, { switch (*fdata) { - case 0: fail_if(data->value != 10); break; + case 0: ck_assert(data->value != 10); break; - case 1: fail_if(data->value != 42); break; + case 1: ck_assert(data->value != 42); break; - case 2: fail_if(data->value != 1337); break; + case 2: ck_assert(data->value != 1337); break; - case 3: fail_if(data->value != 69); break; + case 3: ck_assert(data->value != 69); break; - case 4: fail_if(data->value != 27); break; + case 4: ck_assert(data->value != 27); break; } (*fdata)++; @@ -556,35 +556,35 @@ EFL_START_TEST(eina_iterator_rbtree_simple) _eina_rbtree_int_new(10), EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp), NULL); - fail_if(!root); + ck_assert(!root); root = eina_rbtree_inline_insert(root, _eina_rbtree_int_new(1337), EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp), NULL); - fail_if(!root); + ck_assert(!root); root = eina_rbtree_inline_insert(root, _eina_rbtree_int_new(27), EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp), NULL); - fail_if(!root); + ck_assert(!root); root = eina_rbtree_inline_insert(root, _eina_rbtree_int_new(69), EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp), NULL); - fail_if(!root); + ck_assert(!root); root = eina_rbtree_inline_insert(root, _eina_rbtree_int_new(42), EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp), NULL); - fail_if(!root); + ck_assert(!root); i = 0; it = eina_rbtree_iterator_prefix(root); - fail_if(!it); + ck_assert(!it); eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_rbtree_data_check_prefix), @@ -594,7 +594,7 @@ EFL_START_TEST(eina_iterator_rbtree_simple) /* This will return the item sorted. */ i = 0; it = eina_rbtree_iterator_infix(root); - fail_if(!it); + ck_assert(!it); eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_rbtree_data_check_sorted), @@ -603,7 +603,7 @@ EFL_START_TEST(eina_iterator_rbtree_simple) i = 0; it = eina_rbtree_iterator_postfix(root); - fail_if(!it); + ck_assert(!it); eina_iterator_foreach(it, EINA_EACH_CB(eina_iterator_rbtree_data_check_postfix), @@ -622,10 +622,10 @@ EFL_START_TEST(eina_iterator_carray_length) it = EINA_C_ARRAY_ITERATOR_NEW(array); EINA_ITERATOR_FOREACH(it, i) { - fail_if(i != j * j); + ck_assert(i != j * j); j++; } - fail_if(j < EINA_C_ARRAY_LENGTH(array)); + ck_assert(j < EINA_C_ARRAY_LENGTH(array)); eina_iterator_free(it); } EFL_END_TEST @@ -644,10 +644,10 @@ EFL_START_TEST(eina_iterator_multi) EINA_C_ARRAY_ITERATOR_NEW(array3)); EINA_ITERATOR_FOREACH(it, i) { - fail_if(i != j * j); + ck_assert(i != j * j); j++; } - fail_if(j < EINA_C_ARRAY_LENGTH(array1) + ck_assert(j < EINA_C_ARRAY_LENGTH(array1) + EINA_C_ARRAY_LENGTH(array2) + EINA_C_ARRAY_LENGTH(array3)); eina_iterator_free(it); diff --git a/src/tests/eina/eina_test_lalloc.c b/src/tests/eina/eina_test_lalloc.c index 6e5fd4799e..e8bbf2c4dd 100644 --- a/src/tests/eina/eina_test_lalloc.c +++ b/src/tests/eina/eina_test_lalloc.c @@ -64,22 +64,26 @@ EFL_START_TEST(eina_lalloc_simple) int i; elat = calloc(1, sizeof (Eina_Lazy_Allocator_Test)); - fail_if(!elat); + ck_assert(!elat); test = eina_lalloc_new(elat, EINA_LALLOC_ALLOC( _test_alloc), EINA_LALLOC_FREE(_test_free), 10); - fail_if(!test); + ck_assert(!test); for (i = 0; i < 10; ++i) - fail_if(eina_lalloc_element_add(test) != EINA_TRUE); - fail_if(eina_lalloc_element_add(test) != EINA_FALSE); - fail_if(eina_lalloc_elements_add(test, 5) != EINA_TRUE); + { + ck_assert(eina_lalloc_element_add(test) != EINA_TRUE); + ck_assert(eina_lalloc_element_add(test) != EINA_FALSE); + ck_assert(eina_lalloc_elements_add(test, 5) != EINA_TRUE); + } + for (i = 0; i < 21; ++i) - fail_if(eina_lalloc_element_add(test) != EINA_TRUE); + { + ck_assert(eina_lalloc_element_add(test) != EINA_TRUE); + ck_assert(eina_lalloc_elements_add(test, 50) != EINA_FALSE); + } - fail_if(eina_lalloc_elements_add(test, 50) != EINA_FALSE); - - eina_lalloc_free(test); + eina_lalloc_free(test); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_list.c b/src/tests/eina/eina_test_list.c index e663064666..25cf209d84 100644 --- a/src/tests/eina/eina_test_list.c +++ b/src/tests/eina/eina_test_list.c @@ -69,85 +69,85 @@ EFL_START_TEST(eina_test_list_simple) list = eina_list_append(list, &data[0]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend(list, &data[1]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[2]); - fail_if(list == NULL); + ck_assert(list == NULL); i = eina_list_data_idx(list, &data[1]); - fail_if(i != 0); + ck_assert(i != 0); i = eina_list_data_idx(list, &data[2]); - fail_if(i != 2); + ck_assert(i != 2); i = eina_list_data_idx(list, &data[3]); - fail_if(i != -1); + ck_assert(i != -1); list = eina_list_demote_list(list, eina_list_nth_list(list, 1)); test1 = eina_list_nth(list, 2); - fail_if(test1 == NULL); - fail_if(*test1 != 6); + ck_assert(test1 == NULL); + ck_assert(*test1 != 6); list = eina_list_remove(list, &data[0]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_remove(list, &data[0]); - fail_if(list == NULL); + ck_assert(list == NULL); tmp = eina_list_data_find_list(list, &data[2]); - fail_if(tmp == NULL); + ck_assert(tmp == NULL); list = eina_list_append_relative_list(list, &data[3], tmp); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend_relative_list(list, &data[4], tmp); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_promote_list(list, tmp); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append_relative(list, &data[5], &data[2]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend_relative(list, &data[6], &data[2]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_remove_list(list, tmp); - fail_if(list == NULL); + ck_assert(list == NULL); - fail_if(eina_list_data_find_list(list, &data[2]) != NULL); - fail_if(eina_list_data_find(list, &data[2]) != NULL); - fail_if(eina_list_data_find(list, &data[5]) != &data[5]); + ck_assert(eina_list_data_find_list(list, &data[2]) != NULL); + ck_assert(eina_list_data_find(list, &data[2]) != NULL); + ck_assert(eina_list_data_find(list, &data[5]) != &data[5]); - fail_if(eina_list_count(list) != 5); - fail_if(eina_list_nth(list, 4) != &data[3]); - fail_if(eina_list_nth(list, 10) != NULL); - fail_if(eina_list_nth_list(list, 10) != NULL); + ck_assert(eina_list_count(list) != 5); + ck_assert(eina_list_nth(list, 4) != &data[3]); + ck_assert(eina_list_nth(list, 10) != NULL); + ck_assert(eina_list_nth_list(list, 10) != NULL); for (tmp = list, i = 0; tmp != NULL; tmp = eina_list_next(tmp), ++i) - { - int *d = eina_list_data_get(tmp); - fail_if(d == NULL); - fail_if(*d != result[i]); - } + { + int *d = eina_list_data_get(tmp); + ck_assert(d == NULL); + ck_assert(*d != result[i]); + } list = eina_list_reverse(list); for (tmp = list; tmp != NULL; tmp = eina_list_next(tmp), --i) - { - int *d = eina_list_data_get(tmp); - fail_if(d == NULL); - fail_if(*d != result[i - 1]); - } + { + int *d = eina_list_data_get(tmp); + ck_assert(d == NULL); + ck_assert(*d != result[i - 1]); + } list = eina_list_append_relative(list, &data[7], &data[7]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_prepend_relative(list, &data[8], &data[8]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_sort(list, 2, eina_int_cmp); @@ -157,9 +157,9 @@ EFL_START_TEST(eina_test_list_simple) test2 = eina_list_nth(list, 1); test3 = eina_list_nth(list, 2); - fail_if(test1 == NULL || test2 == NULL || test3 == NULL); - fail_if(*test1 > *test2); - fail_if(*test3 == *test2); + ck_assert(test1 == NULL || test2 == NULL || test3 == NULL); + ck_assert(*test1 > *test2); + ck_assert(*test3 == *test2); list = eina_list_sort(list, 5, eina_int_cmp); @@ -167,52 +167,52 @@ EFL_START_TEST(eina_test_list_simple) test2 = eina_list_nth(list, 4); test3 = eina_list_nth(list, 5); - fail_if(test1 == NULL || test2 == NULL || test3 == NULL); - fail_if(*test1 > *test2); - fail_if(*test3 > *test2); + ck_assert(test1 == NULL || test2 == NULL || test3 == NULL); + ck_assert(*test1 > *test2); + ck_assert(*test3 > *test2); list = eina_list_append(list, &data[8]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_append(list, &data[7]); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_sort(list, -1, eina_int_cmp); test1 = eina_list_nth(list, 0); for (tmp = list; tmp != NULL; tmp = eina_list_next(tmp)) - { - int *d = eina_list_data_get(tmp); - fail_if(*test1 > *d); + { + int *d = eina_list_data_get(tmp); + ck_assert(*test1 > *d); - test1 = d; - } + test1 = d; + } test3 = eina_list_nth(list, 5); - fail_if(test3 == NULL); + ck_assert(test3 == NULL); list = eina_list_promote_list(list, list); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_promote_list(list, eina_list_last(list)); - fail_if(list == NULL); + ck_assert(list == NULL); test1 = eina_list_nth(list, 0); test2 = eina_list_nth(list, 1); list = eina_list_promote_list(eina_list_next(list), list); - fail_if(list == NULL); - fail_if(eina_list_data_get(list) != test1); - fail_if(eina_list_data_get(eina_list_next(list)) != test2); + ck_assert(list == NULL); + ck_assert(eina_list_data_get(list) != test1); + ck_assert(eina_list_data_get(eina_list_next(list)) != test2); list = eina_list_remove_list(list, list); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_remove_list(list, eina_list_last(list)); - fail_if(list == NULL); + ck_assert(list == NULL); list = eina_list_free(list); - fail_if(list != NULL); + ck_assert(list != NULL); } EFL_END_TEST @@ -227,44 +227,48 @@ EFL_START_TEST(eina_test_list_merge) int data[] = { 6, 9, 42, 1, 7, 9, 81, 1664, 1337, 3, 21, 10, 0, 5, 2008 }; int i; - l1 = eina_list_append(NULL, &data[0]); l1 = eina_list_append(l1, &data[1]); l1 = eina_list_append(l1, &data[2]); l1 = eina_list_append(l1, &data[3]); - fail_if(l1 == NULL); + ck_assert(l1 == NULL); l2 = eina_list_append(NULL, &data[4]); l2 = eina_list_append(l2, &data[5]); - fail_if(l2 == NULL); + ck_assert(l2 == NULL); l1 = eina_list_merge(l1, l2); - fail_if(l1 == NULL); - fail_if(eina_list_count(l1) != 6); + ck_assert(l1 == NULL); + ck_assert(eina_list_count(l1) != 6); + for (i = 0, l2 = l1; ((l2 != NULL) && (i < 6)); ++i, l2 = l2->next) - fail_if(l2->data != &data[i]); - fail_if(i != 6); - fail_if(l2 != NULL); - - eina_list_free(l1); + { + ck_assert(l2->data != &data[i]); + ck_assert(i != 6); + ck_assert(l2 != NULL); + } + eina_list_free(l1); l1 = eina_list_append(NULL, &data[0]); l1 = eina_list_append(l1, &data[1]); - fail_if(l1 == NULL); + ck_assert(l1 == NULL); l2 = eina_list_append(NULL, &data[2]); l2 = eina_list_append(l2, &data[3]); l2 = eina_list_append(l2, &data[4]); l2 = eina_list_append(l2, &data[5]); - fail_if(l2 == NULL); + ck_assert(l2 == NULL); l1 = eina_list_merge(l1, l2); - fail_if(l1 == NULL); - fail_if(eina_list_count(l1) != 6); + ck_assert(l1 == NULL); + ck_assert(eina_list_count(l1) != 6); + for (i = 0, l2 = l1; ((l2 != NULL) && (i < 6)); ++i, l2 = l2->next) - fail_if(l2->data != &data[i]); - fail_if(i != 6); - fail_if(l2 != NULL); + { + ck_assert(l2->data != &data[i]); + ck_assert(i != 6); + ck_assert(l2 != NULL); + } l3 = eina_list_append(NULL, &data[6]); l3 = eina_list_append(l3, &data[7]); @@ -284,18 +288,18 @@ EFL_START_TEST(eina_test_list_merge) l5 = eina_list_sort(l5, -1, eina_int_cmp); l1 = eina_list_sorted_merge(l1, l3, eina_int_cmp); - fail_if(l1 == NULL); - fail_if(eina_list_count(l1) != 9); + ck_assert(l1 == NULL); + ck_assert(eina_list_count(l1) != 9); l1 = eina_list_sorted_merge(l1, l4, eina_int_cmp); - fail_if(l1 == NULL); - fail_if(eina_list_count(l1) != 12); + ck_assert(l1 == NULL); + ck_assert(eina_list_count(l1) != 12); l1 = eina_list_sorted_merge(l1, l5, eina_int_cmp); - fail_if(l1 == NULL); - fail_if(eina_list_count(l1) != 15); + ck_assert(l1 == NULL); + ck_assert(eina_list_count(l1) != 15); - fail_if(!eina_list_sorted_check(l1)); + ck_assert(!eina_list_sorted_check(l1)); } EFL_END_TEST @@ -316,29 +320,29 @@ EFL_START_TEST(eina_test_list_sorted_insert) for (i = 0; i < count; i++) l1 = eina_list_sorted_insert(l1, eina_int_cmp, data + i); - fail_if(l1 == NULL); - fail_if(!eina_list_sorted_check(l1)); + ck_assert(l1 == NULL); + ck_assert(!eina_list_sorted_check(l1)); res = eina_list_search_sorted(l1, eina_int_cmp, &data[7]); - fail_if(*res != 1664); + ck_assert(*res != 1664); res = eina_list_search_sorted(l1, eina_int_cmp, &val); - fail_if(res != NULL); + ck_assert(res != NULL); l2 = NULL; EINA_LIST_FOREACH(l1, itr, d) l2 = eina_list_sorted_insert(l2, eina_int_cmp, d); - fail_if(l2 == NULL); - fail_if(!eina_list_sorted_check(l2)); + ck_assert(l2 == NULL); + ck_assert(!eina_list_sorted_check(l2)); eina_list_free(l2); l2 = NULL; EINA_LIST_REVERSE_FOREACH(l1, itr, d) l2 = eina_list_sorted_insert(l2, eina_int_cmp, d); - fail_if(l2 == NULL); - fail_if(!eina_list_sorted_check(l2)); + ck_assert(l2 == NULL); + ck_assert(!eina_list_sorted_check(l2)); eina_list_free(l2); eina_list_free(l1); @@ -347,10 +351,9 @@ EFL_START_TEST(eina_test_list_sorted_insert) for (i = 0; i < count; i++) l1 = eina_list_sorted_insert(l1, eina_int_cmp, data2 + i); - fail_if(l1 == NULL); - fail_if(!eina_list_sorted_check(l1)); + ck_assert(l1 == NULL); + ck_assert(!eina_list_sorted_check(l1)); eina_list_free(l1); - } EFL_END_TEST @@ -360,7 +363,6 @@ EFL_START_TEST(eina_test_list_split) Eina_List *list = NULL; unsigned int i; - list = eina_list_append(list, "tigh"); list = eina_list_append(list, "adar"); list = eina_list_append(list, "baltar"); @@ -370,17 +372,17 @@ EFL_START_TEST(eina_test_list_split) list = eina_list_append(list, "baltar"); list = eina_list_append(list, "roslin"); - fail_if(list == NULL); - fail_if(eina_list_count(list) != 8); + ck_assert(list == NULL); + ck_assert(eina_list_count(list) != 8); for ( i = 0; i < 200; i++) { left = eina_list_split_list(list, eina_list_nth_list(list, i % 2), &right); if (i % 2 == 0) - fail_if(eina_list_count(left) == 1 && eina_list_count(right) + eina_list_count(left) == i + 7); + ck_assert(eina_list_count(left) == 1 && eina_list_count(right) + eina_list_count(left) == i + 7); else - fail_if(eina_list_count(left) == 2 && eina_list_count(right) + eina_list_count(left) == i + 7); + ck_assert(eina_list_count(left) == 2 && eina_list_count(right) + eina_list_count(left) == i + 7); list = eina_list_merge(left, right); list = eina_list_append(list, "roslin"); @@ -400,7 +402,6 @@ EFL_START_TEST(eina_test_list_shuffle) Eina_List *item = NULL; Eina_List *copy, *cl; - for(i = 0; i < SHUFFLE_SZ; i++) { n[i] = i; @@ -434,38 +435,37 @@ EFL_START_TEST(eina_test_list_clone) for(i = 0; i < DATA_SIZE; i++) - { - n[i] = i; - list = eina_list_append(list, &n[i]); - } + { + n[i] = i; + list = eina_list_append(list, &n[i]); + } clist = eina_list_clone(list); - fail_if(clist == NULL); + ck_assert(clist == NULL); for(i = 0; i < DATA_SIZE; i++) - { - fail_if(eina_list_nth(list, i) != eina_list_nth(clist, i)); - } + { + ck_assert(eina_list_nth(list, i) != eina_list_nth(clist, i)); + } rclist = eina_list_reverse_clone(list); - fail_if(rclist == NULL); + ck_assert(rclist == NULL); for(i = 0; i < DATA_SIZE; i++) - { - d = eina_list_nth(list, i); - rd = eina_list_nth(rclist, (DATA_SIZE - 1 - i)); - fail_if(d != rd); - } + { + d = eina_list_nth(list, i); + rd = eina_list_nth(rclist, (DATA_SIZE - 1 - i)); + ck_assert(d != rd); + } list = eina_list_free(list); - fail_if(list != NULL); + ck_assert(list != NULL); clist = eina_list_free(clist); - fail_if(clist != NULL); + ck_assert(clist != NULL); rclist = eina_list_free(rclist); - fail_if(rclist != NULL); - + ck_assert(rclist != NULL); } EFL_END_TEST @@ -477,33 +477,31 @@ EFL_START_TEST(eina_test_list_move) int data2[] = {6, 7, 8, 9, 10}; int i, *list_data; - for (i = 0; i < 5; i++) { list1 = eina_list_append(list1, &data1[i]); list2 = eina_list_append(list2, &data2[i]); } - fail_if(eina_list_count(list1) != 5); - fail_if(eina_list_count(list2) != 5); + ck_assert(eina_list_count(list1) != 5); + ck_assert(eina_list_count(list2) != 5); ret = eina_list_move(&list1, &list2, &data2[4]); - fail_if(ret != EINA_TRUE); - fail_if(eina_list_count(list1) != 6); - fail_if(eina_list_count(list2) != 4); + ck_assert(ret != EINA_TRUE); + ck_assert(eina_list_count(list1) != 6); + ck_assert(eina_list_count(list2) != 4); list_data = eina_list_nth(list1, 5); - fail_if(*list_data != 10); + ck_assert(*list_data != 10); ret = eina_list_move_list(&list1, &list2, eina_list_nth_list(list2, 1)); - fail_if(ret != EINA_TRUE); - fail_if(eina_list_count(list1) != 7); - fail_if(eina_list_count(list2) != 3); + ck_assert(ret != EINA_TRUE); + ck_assert(eina_list_count(list1) != 7); + ck_assert(eina_list_count(list2) != 3); list_data = eina_list_nth(list1, 6); - fail_if(*list_data != 7); + ck_assert(*list_data != 7); eina_list_free(list1); eina_list_free(list2); - } EFL_END_TEST diff --git a/src/tests/eina/eina_test_lock.c b/src/tests/eina/eina_test_lock.c index bbf036b203..b40586cc4b 100644 --- a/src/tests/eina/eina_test_lock.c +++ b/src/tests/eina/eina_test_lock.c @@ -87,14 +87,14 @@ _eina_test_lock_thread(void *data, Eina_Thread t) { unsigned int i; - fail_if(!eina_thread_equal(t, thread)); - fail_if(strcmp("test", data)); + ck_assert(!eina_thread_equal(t, thread)); + ck_assert(strcmp("test", data)); for (i = 0; i < 150; i++) { - fail_if(eina_spinlock_take(&spin) != EINA_LOCK_SUCCEED); + ck_assert(eina_spinlock_take(&spin) != EINA_LOCK_SUCCEED); counter++; - fail_if(eina_spinlock_release(&spin) != EINA_LOCK_SUCCEED); + ck_assert(eina_spinlock_release(&spin) != EINA_LOCK_SUCCEED); } return data; @@ -106,23 +106,23 @@ EFL_START_TEST(eina_test_spinlock) counter = 0; - fail_if(!eina_spinlock_new(&spin)); + ck_assert(!eina_spinlock_new(&spin)); - fail_if(!eina_thread_create(&thread, EINA_THREAD_NORMAL, -1, _eina_test_lock_thread, "test")); + ck_assert(!eina_thread_create(&thread, EINA_THREAD_NORMAL, -1, _eina_test_lock_thread, "test")); for (i = 0; i < 150; i++) { - fail_if(eina_spinlock_take(&spin) != EINA_LOCK_SUCCEED); + ck_assert(eina_spinlock_take(&spin) != EINA_LOCK_SUCCEED); counter++; - fail_if(eina_spinlock_release(&spin) != EINA_LOCK_SUCCEED); + ck_assert(eina_spinlock_release(&spin) != EINA_LOCK_SUCCEED); } - fail_if(strcmp("test", eina_thread_join(thread))); + ck_assert(strcmp("test", eina_thread_join(thread))); - fail_if(counter != 300); + ck_assert(counter != 300); - fail_if(eina_spinlock_take_try(&spin) != EINA_LOCK_SUCCEED); - fail_if(eina_spinlock_release(&spin) != EINA_LOCK_SUCCEED); + ck_assert(eina_spinlock_take_try(&spin) != EINA_LOCK_SUCCEED); + ck_assert(eina_spinlock_release(&spin) != EINA_LOCK_SUCCEED); eina_spinlock_free(&spin); @@ -154,13 +154,13 @@ _eina_test_tls_thread(void *data EINA_UNUSED, Eina_Thread t EINA_UNUSED) int *ptr; ptr = eina_tls_get(key); - fail_if(ptr != NULL); + ck_assert(ptr != NULL); - fail_if(!eina_tls_set(key, _eina_test_tls_alloc(24))); + ck_assert(!eina_tls_set(key, _eina_test_tls_alloc(24))); ptr = eina_tls_get(key); - fail_if(ptr == NULL); - fail_if(*ptr != 24); + ck_assert(ptr == NULL); + ck_assert(*ptr != 24); return NULL; } @@ -168,18 +168,18 @@ _eina_test_tls_thread(void *data EINA_UNUSED, Eina_Thread t EINA_UNUSED) EFL_START_TEST(eina_test_tls) { - fail_if(!eina_tls_cb_new(&key, _eina_test_tls_free)); + ck_assert(!eina_tls_cb_new(&key, _eina_test_tls_free)); - fail_if(!eina_tls_set(key, _eina_test_tls_alloc(42))); + ck_assert(!eina_tls_set(key, _eina_test_tls_alloc(42))); - fail_if(!eina_thread_create(&thread, EINA_THREAD_NORMAL, -1, _eina_test_tls_thread, NULL)); + ck_assert(!eina_thread_create(&thread, EINA_THREAD_NORMAL, -1, _eina_test_tls_thread, NULL)); eina_thread_join(thread); - fail_if(_eina_tls_free_count != 1); + ck_assert(_eina_tls_free_count != 1); int *ptr = eina_tls_get(key); - fail_if(eina_tls_get(key) == NULL); - fail_if(*ptr != 42); + ck_assert(eina_tls_get(key) == NULL); + ck_assert(*ptr != 42); eina_tls_free(key); @@ -194,20 +194,20 @@ static Eina_RWLock mutex; static void * _eina_test_rwlock_thread(void *data EINA_UNUSED, Eina_Thread t EINA_UNUSED) { - fail_if(!eina_barrier_wait(&barrier)); - fail_if(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); - fail_if(!eina_condition_broadcast(&cond)); - fail_if(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(!eina_barrier_wait(&barrier)); + ck_assert(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(!eina_condition_broadcast(&cond)); + ck_assert(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); - fail_if(eina_rwlock_take_write(&mutex) != EINA_LOCK_SUCCEED); + ck_assert(eina_rwlock_take_write(&mutex) != EINA_LOCK_SUCCEED); counter = 7200; - fail_if(eina_rwlock_release(&mutex) != EINA_LOCK_SUCCEED); + ck_assert(eina_rwlock_release(&mutex) != EINA_LOCK_SUCCEED); - fail_if(!eina_barrier_wait(&barrier)); + ck_assert(!eina_barrier_wait(&barrier)); - fail_if(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); - fail_if(!eina_condition_broadcast(&cond)); - fail_if(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(!eina_condition_broadcast(&cond)); + ck_assert(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); return NULL; } @@ -218,46 +218,46 @@ EFL_START_TEST(eina_test_rwlock) long delay; - fail_if(!eina_rwlock_new(&mutex)); - fail_if(!eina_lock_new(&mtcond)); - fail_if(!eina_condition_new(&cond, &mtcond)); - fail_if(!eina_barrier_new(&barrier, 2)); + ck_assert(!eina_rwlock_new(&mutex)); + ck_assert(!eina_lock_new(&mtcond)); + ck_assert(!eina_condition_new(&cond, &mtcond)); + ck_assert(!eina_barrier_new(&barrier, 2)); counter = 42; eina_lock_debug(&mtcond); - fail_if(eina_rwlock_take_read(&mutex) != EINA_LOCK_SUCCEED); - fail_if(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(eina_rwlock_take_read(&mutex) != EINA_LOCK_SUCCEED); + ck_assert(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); - fail_if(!eina_thread_create(&thread, EINA_THREAD_NORMAL, -1, _eina_test_rwlock_thread, NULL)); + ck_assert(!eina_thread_create(&thread, EINA_THREAD_NORMAL, -1, _eina_test_rwlock_thread, NULL)); - fail_if(!eina_barrier_wait(&barrier)); - fail_if(!eina_condition_wait(&cond)); - fail_if(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(!eina_barrier_wait(&barrier)); + ck_assert(!eina_condition_wait(&cond)); + ck_assert(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); - fail_if(counter != 42); - fail_if(eina_rwlock_release(&mutex) != EINA_LOCK_SUCCEED); + ck_assert(counter != 42); + ck_assert(eina_rwlock_release(&mutex) != EINA_LOCK_SUCCEED); - fail_if(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); - fail_if(!eina_barrier_wait(&barrier)); + ck_assert(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(!eina_barrier_wait(&barrier)); - fail_if(!eina_condition_wait(&cond)); - fail_if(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(!eina_condition_wait(&cond)); + ck_assert(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); - fail_if(eina_rwlock_take_read(&mutex) != EINA_LOCK_SUCCEED); - fail_if(counter != 7200); - fail_if(eina_rwlock_release(&mutex) != EINA_LOCK_SUCCEED); + ck_assert(eina_rwlock_take_read(&mutex) != EINA_LOCK_SUCCEED); + ck_assert(counter != 7200); + ck_assert(eina_rwlock_release(&mutex) != EINA_LOCK_SUCCEED); - fail_if(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(eina_lock_take(&mtcond) != EINA_LOCK_SUCCEED); clock_gettime(CLOCK_REALTIME, &ts); eina_condition_timedwait(&cond, 0.050); clock_gettime(CLOCK_REALTIME, &ts2); delay = (ts2.tv_sec - ts.tv_sec) * 1000L + (ts2.tv_nsec - ts.tv_nsec) / 1000000L; - fail_if(delay < 50); - fail_if(delay > 200); - fail_if(eina_error_get() != ETIMEDOUT); - fail_if(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); + ck_assert(delay < 50); + ck_assert(delay > 200); + ck_assert(eina_error_get() != ETIMEDOUT); + ck_assert(eina_lock_release(&mtcond) != EINA_LOCK_SUCCEED); eina_thread_join(thread); diff --git a/src/tests/eina/eina_test_log.c b/src/tests/eina/eina_test_log.c index 624bbbe75d..9e99eb79af 100644 --- a/src/tests/eina/eina_test_log.c +++ b/src/tests/eina/eina_test_log.c @@ -127,35 +127,35 @@ EFL_START_TEST(eina_log_macro) { TEST_LOG_CTX(EINA_LOG_LEVEL_CRITICAL, "Critical message"); EINA_LOG_CRIT("Critical message"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_ERR <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_ERR, "An error"); EINA_LOG_ERR("An error"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_WARN <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_WARN, "A warning"); EINA_LOG_WARN("A warning"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_INFO <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_INFO, "An info"); EINA_LOG_INFO("An info"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_DBG <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_DBG, "A debug"); EINA_LOG_DBG("A debug"); - fail_unless(ctx.did); + ck_assert(ctx.did); } #undef TEST_LOG_CTX @@ -179,7 +179,7 @@ EFL_START_TEST(eina_log_domains_macros) eina_log_print_cb_set(_eina_test_log_domain, &ctx); int d = eina_log_domain_register("MyDomain", EINA_COLOR_GREEN); - fail_if(d < 0); + ck_assert(d < 0); /* make specific domain permissive */ eina_log_domain_level_set("MyDomain", EINA_LOG_LEVEL_DBG); @@ -202,35 +202,35 @@ EFL_START_TEST(eina_log_domains_macros) { TEST_LOG_CTX(EINA_LOG_LEVEL_CRITICAL, "A critical message"); EINA_LOG_DOM_CRIT(d, "A critical message"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_ERR <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_ERR, "An error"); EINA_LOG_DOM_ERR(d, "An error"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_WARN <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_WARN, "A warning"); EINA_LOG_DOM_WARN(d, "A warning"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_INFO <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_INFO, "An info"); EINA_LOG_DOM_INFO(d, "An info"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (EINA_LOG_LEVEL_DBG <= maxlevel) { TEST_LOG_CTX(EINA_LOG_LEVEL_DBG, "A debug"); EINA_LOG_DOM_DBG(d, "A debug"); - fail_unless(ctx.did); + ck_assert(ctx.did); } #undef TEST_LOG_CTX @@ -250,7 +250,7 @@ EFL_START_TEST(eina_log_domains_registry) for (i = 0; i < 50; i++) { d[i] = eina_log_domain_register("Test", EINA_COLOR_GREEN); - fail_if(d[i] < 0); + ck_assert(d[i] < 0); } for (i = 0; i < 50; i++) @@ -261,7 +261,7 @@ EFL_END_TEST EFL_START_TEST(eina_log_domains_slot_reuse) { - fail_if(!eina_threads_init()); + ck_assert(!eina_threads_init()); // Create 9 domains int idx[9]; @@ -270,7 +270,7 @@ EFL_START_TEST(eina_log_domains_slot_reuse) for (i = 0; i < 9; i++) { idx[i] = eina_log_domain_register("Test1", EINA_COLOR_GREEN); - fail_if(idx[i] < 0); + ck_assert(idx[i] < 0); } // Slot 0 by default contains the global logger. The above code created @@ -288,7 +288,7 @@ EFL_START_TEST(eina_log_domains_slot_reuse) int new = eina_log_domain_register("Test Slot", EINA_COLOR_GREEN); // Check for slot reuse - fail_if(new != removed); + ck_assert(new != removed); eina_threads_shutdown(); } @@ -299,10 +299,10 @@ EFL_START_TEST(eina_log_level_indexes) struct log_ctx ctx; int maxlevel; - fail_if(!eina_threads_init()); + ck_assert(!eina_threads_init()); int d = eina_log_domain_register("Levels", EINA_COLOR_GREEN); - fail_if(d < 0); + ck_assert(d < 0); eina_log_print_cb_set(_eina_test_log_domain, &ctx); @@ -326,7 +326,7 @@ EFL_START_TEST(eina_log_level_indexes) eina_log_domain_level_set("Levels", -1); TEST_LOG_CTX(-1, "Negative index message"); EINA_LOG(d, -1, "Negative index message"); - fail_unless(ctx.did); + ck_assert(ctx.did); } if (-2 <= maxlevel) @@ -334,7 +334,7 @@ EFL_START_TEST(eina_log_level_indexes) eina_log_domain_level_set("Levels", -2); TEST_LOG_CTX(-1, "Negative index message"); EINA_LOG(d, -1, "Negative index message"); - fail_if(ctx.did); + ck_assert(ctx.did); } #ifdef EINA_LOG_LEVEL_MAXIMUM if (6 <= maxlevel) @@ -343,7 +343,7 @@ EFL_START_TEST(eina_log_level_indexes) eina_log_domain_level_set("Levels", 6); TEST_LOG_CTX(6, "Higher level debug"); EINA_LOG(d, 6, "Higher level debug"); - fail_unless(ctx.did); + ck_assert(ctx.did); } #endif if (5 <= maxlevel) @@ -351,7 +351,7 @@ EFL_START_TEST(eina_log_level_indexes) eina_log_domain_level_set("Levels", 5); TEST_LOG_CTX(6, "Higher level debug"); EINA_LOG(d, 6, "Higher level debug"); - fail_if(ctx.did); + ck_assert(ctx.did); } #undef TEST_LOG_CTX @@ -373,7 +373,7 @@ EFL_START_TEST(eina_log_customize) #define test_set_get(func, val) \ eina_log_ ## func ## _set(val); \ - fail_if(eina_log_ ## func ## _get() != val) + ck_assert(eina_log_ ## func ## _get() != val) test_set_get(level, -1234); test_set_get(level, 4567); @@ -390,19 +390,19 @@ EFL_START_TEST(eina_log_customize) test_set_get(abort_on_critical_level, -1234); test_set_get(abort_on_critical_level, 4567); - fail_if(eina_log_domain_level_get(TEST_DOM) != eina_log_level_get()); + ck_assert(eina_log_domain_level_get(TEST_DOM) != eina_log_level_get()); eina_log_domain_level_set(TEST_DOM, -123); - fail_if(eina_log_domain_level_get(TEST_DOM) != -123); + ck_assert(eina_log_domain_level_get(TEST_DOM) != -123); eina_log_domain_level_set(TEST_DOM, 890); - fail_if(eina_log_domain_level_get(TEST_DOM) != 890); + ck_assert(eina_log_domain_level_get(TEST_DOM) != 890); d = eina_log_domain_register(TEST_DOM, EINA_COLOR_GREEN); - fail_if(d < 0); + ck_assert(d < 0); - fail_if(eina_log_domain_level_get(TEST_DOM) != 890); - fail_if(eina_log_domain_registered_level_get(d) != 890); + ck_assert(eina_log_domain_level_get(TEST_DOM) != 890); + ck_assert(eina_log_domain_registered_level_get(d) != 890); eina_log_domain_unregister(d); @@ -420,8 +420,8 @@ EFL_START_TEST(eina_log_customize) ctx.msg = "safety check failed: _log_domains[domain].deleted is true"; ctx.fnc = "eina_log_domain_registered_level_get"; ctx.did = EINA_FALSE; - fail_if(eina_log_domain_registered_level_get(d) != EINA_LOG_LEVEL_UNKNOWN); - fail_unless(ctx.did); + ck_assert(eina_log_domain_registered_level_get(d) != EINA_LOG_LEVEL_UNKNOWN); + ck_assert(ctx.did); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); #else @@ -441,7 +441,7 @@ EFL_START_TEST(eina_log_level_name) #define tst(level, str) \ eina_log_level_name_get(level, name); \ - fail_if(strcmp(name, str) != 0) + ck_assert(strcmp(name, str) != 0) tst(0, "CRI"); tst(1, "ERR"); diff --git a/src/tests/eina/eina_test_magic.c b/src/tests/eina/eina_test_magic.c index e4f9005b03..99c5fa71cb 100644 --- a/src/tests/eina/eina_test_magic.c +++ b/src/tests/eina/eina_test_magic.c @@ -122,7 +122,7 @@ EFL_START_TEST(eina_magic_simple) TEST_MAGIC_SAFETY("eina_magic_string_set", "safety check failed: magic_name == NULL"); eina_magic_string_set(EINA_MAGIC_TEST2, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #ifdef SHOW_LOG fprintf(stderr, "you should have a safety check failure below:\n"); @@ -130,19 +130,19 @@ EFL_START_TEST(eina_magic_simple) TEST_MAGIC_SAFETY("eina_magic_string_set", "safety check failed: magic_name == NULL"); eina_magic_string_set(EINA_MAGIC_TEST2, NULL); - fail_unless(ctx.did); + ck_assert(ctx.did); #endif eina_magic_string_set(EINA_MAGIC_TEST2, EINA_MAGIC_STRING); - fail_if(eina_magic_string_get(EINA_MAGIC_TEST) == NULL); - fail_if(strcmp(eina_magic_string_get( + ck_assert(eina_magic_string_get(EINA_MAGIC_TEST) == NULL); + ck_assert(strcmp(eina_magic_string_get( EINA_MAGIC_TEST), EINA_MAGIC_STRING) != 0); eina_log_print_cb_set(_eina_test_magic_print_cb, &ctx); #ifdef EINA_MAGIC_DEBUG - fail_if(EINA_MAGIC_CHECK(ems, EINA_MAGIC_TEST)); + ck_assert(EINA_MAGIC_CHECK(ems, EINA_MAGIC_TEST)); #ifdef SHOW_LOG fprintf(stderr, "you should see 'Input handle pointer is NULL' below\n"); #endif @@ -151,13 +151,13 @@ EFL_START_TEST(eina_magic_simple) " Input handle pointer is NULL.\n" "\n"); EINA_MAGIC_FAIL(ems, EINA_MAGIC_TEST); - fail_unless(ctx.did); + ck_assert(ctx.did); ems = malloc(sizeof (Eina_Magic_Struct)); - fail_if(!ems); + ck_assert(!ems); EINA_MAGIC_SET(ems, EINA_MAGIC_TEST); - fail_if(!EINA_MAGIC_CHECK(ems, EINA_MAGIC_TEST)); + ck_assert(!EINA_MAGIC_CHECK(ems, EINA_MAGIC_TEST)); EINA_MAGIC_SET(ems, EINA_MAGIC_NONE); #ifdef SHOW_LOG @@ -170,7 +170,7 @@ EFL_START_TEST(eina_magic_simple) "\n"); ctx.expected_level = EINA_LOG_LEVEL_CRITICAL; EINA_MAGIC_FAIL(ems, EINA_MAGIC_TEST); - fail_unless(ctx.did); + ck_assert(ctx.did); EINA_MAGIC_SET(ems, 42424242); #ifdef SHOW_LOG @@ -184,7 +184,7 @@ EFL_START_TEST(eina_magic_simple) "\n"); ctx.expected_level = EINA_LOG_LEVEL_CRITICAL; EINA_MAGIC_FAIL(ems, EINA_MAGIC_TEST); - fail_unless(ctx.did); + ck_assert(ctx.did); #endif eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); diff --git a/src/tests/eina/eina_test_main.c b/src/tests/eina/eina_test_main.c index e70cdd038f..0509f7fa86 100644 --- a/src/tests/eina/eina_test_main.c +++ b/src/tests/eina/eina_test_main.c @@ -33,7 +33,7 @@ EFL_END_TEST EFL_START_TEST(eina_cpu) { - fail_if(eina_cpu_count() <= 0); + ck_assert(eina_cpu_count() <= 0); eina_cpu_features_get(); @@ -42,7 +42,7 @@ EFL_END_TEST EFL_START_TEST(eina_hamster) { - fail_if(eina_hamster_count() <= 0); + ck_assert(eina_hamster_count() <= 0); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_matrix.c b/src/tests/eina/eina_test_matrix.c index a0812ac12c..6676412005 100644 --- a/src/tests/eina/eina_test_matrix.c +++ b/src/tests/eina/eina_test_matrix.c @@ -39,18 +39,18 @@ EFL_START_TEST(eina_matrix2) eina_matrix2_values_set(&m, 1, 0, 0, 1); - fail_if(eina_matrix2_type_get(&m) != EINA_MATRIX_TYPE_IDENTITY); + ck_assert(eina_matrix2_type_get(&m) != EINA_MATRIX_TYPE_IDENTITY); eina_matrix2_inverse(&n, &m); - fail_if(eina_matrix2_type_get(&n) != EINA_MATRIX_TYPE_IDENTITY); + ck_assert(eina_matrix2_type_get(&n) != EINA_MATRIX_TYPE_IDENTITY); eina_matrix2_values_get(&m, &xx, &xy, &yx, &yy); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yy, 1)); - fail_if(!EINA_DBL_EQ(xy, yx) || + ck_assert(!EINA_DBL_EQ(xy, yx) || !EINA_DBL_EQ(xy, 0)); } @@ -69,23 +69,23 @@ EFL_START_TEST(eina_matrix2_operation) eina_matrix2_values_get(&m1, &xx, &xy, &yx, &yy); - fail_if((xx - (-0.4) > DBL_EPSILON) || (xy - 0.6 > DBL_EPSILON) || + ck_assert((xx - (-0.4) > DBL_EPSILON) || (xy - 0.6 > DBL_EPSILON) || (yx - 0.6 > DBL_EPSILON) || (yy - (-0.4) > DBL_EPSILON)); eina_matrix2_identity(&m1); eina_matrix2_values_get(&m1, &xx, &xy, &yx, &yy); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yy, 1)); - fail_if(!EINA_DBL_EQ(xy, yx) || + ck_assert(!EINA_DBL_EQ(xy, yx) || !EINA_DBL_EQ(xy, 0)); eina_matrix2_array_set(&m1, arr); eina_matrix2_values_get(&m1, &xx, &xy, &yx, &yy); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yx, xy) || !EINA_DBL_EQ(xy, 1)); @@ -93,7 +93,7 @@ EFL_START_TEST(eina_matrix2_operation) eina_matrix2_values_get(&m2, &xx, &xy, &yx, &yy); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yx, xy) || !EINA_DBL_EQ(xy, 1)); @@ -104,7 +104,7 @@ EFL_START_TEST(eina_matrix2_operation) eina_matrix2_values_get(&m3, &xx, &xy, &yx, &yy); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yx, xy) || !EINA_DBL_EQ(xy, 5)); @@ -112,7 +112,7 @@ EFL_START_TEST(eina_matrix2_operation) eina_matrix2_values_get(&m3, &xx, &xy, &yx, &yy); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yx, xy) || !EINA_DBL_EQ(xy, 5)); @@ -134,13 +134,13 @@ EFL_START_TEST(eina_matrix4) 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1); - fail_if(eina_matrix4_type_get(&m) != EINA_MATRIX_TYPE_IDENTITY); + ck_assert(eina_matrix4_type_get(&m) != EINA_MATRIX_TYPE_IDENTITY); - fail_if(!eina_matrix4_normalized(&n, &m)); - fail_if(eina_matrix4_type_get(&n) != EINA_MATRIX_TYPE_IDENTITY); + ck_assert(!eina_matrix4_normalized(&n, &m)); + ck_assert(eina_matrix4_type_get(&n) != EINA_MATRIX_TYPE_IDENTITY); - fail_if(!eina_matrix4_inverse(&n, &m)); - fail_if(eina_matrix4_type_get(&n) != EINA_MATRIX_TYPE_IDENTITY); + ck_assert(!eina_matrix4_inverse(&n, &m)); + ck_assert(eina_matrix4_type_get(&n) != EINA_MATRIX_TYPE_IDENTITY); eina_matrix4_values_get(&m, &xx, &xy, &xz, &xw, @@ -148,11 +148,11 @@ EFL_START_TEST(eina_matrix4) &zx, &zy, &zz, &zw, &wx, &wy, &wz, &ww); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yy, zz) || !EINA_DBL_EQ(zz, ww) || !EINA_DBL_EQ(ww, 1)); - fail_if(!EINA_DBL_EQ(xy, xz) || + ck_assert(!EINA_DBL_EQ(xy, xz) || !EINA_DBL_EQ(xz, xw) || !EINA_DBL_EQ(xw, yx) || !EINA_DBL_EQ(yx, yz) || @@ -172,7 +172,7 @@ EFL_START_TEST(eina_matrix4) 13, 14, 15, 16); eina_matrix4_transpose(&n, &m); - fail_if(!EINA_DBL_EQ(n.xx, 1) || + ck_assert(!EINA_DBL_EQ(n.xx, 1) || !EINA_DBL_EQ(n.xy, 5) || !EINA_DBL_EQ(n.xz, 9) || !EINA_DBL_EQ(n.xw, 13) || @@ -228,7 +228,7 @@ EFL_START_TEST(eina_matrix4_operation) 0, 0, 0, 2, 0, 2, 0, 0); det = eina_matrix4_determinant(&m); - fail_if(!EINA_DBL_EQ(det, -16)); + ck_assert(!EINA_DBL_EQ(det, -16)); eina_matrix4_inverse(&m1, &m); eina_matrix4_values_get(&m1, @@ -341,7 +341,7 @@ EFL_START_TEST(eina_matrix4_operation) &zx, &zy, &zz, &zw, &wx, &wy, &wz, &ww); - fail_if(!MATRIX4_CMP(xx, xy, xz, xw, + ck_assert(!MATRIX4_CMP(xx, xy, xz, xw, yx, yy, yz, yw, zx, zy, zz, zw, wx, wy, wz, ww, @@ -356,7 +356,7 @@ EFL_START_TEST(eina_matrix4_operation) &yx, &yy, &yz, &yw, &zx, &zy, &zz, &zw, &wx, &wy, &wz, &ww); - fail_if(!MATRIX4_CMP(xx, xy, xz, xw, + ck_assert(!MATRIX4_CMP(xx, xy, xz, xw, yx, yy, yz, yw, zx, zy, zz, zw, wx, wy, wz, ww, @@ -372,7 +372,7 @@ EFL_START_TEST(eina_matrix4_operation) &yx, &yy, &yz, &yw, &zx, &zy, &zz, &zw, &wx, &wy, &wz, &ww); - fail_if(!MATRIX4_CMP(xx, xy, xz, xw, + ck_assert(!MATRIX4_CMP(xx, xy, xz, xw, yx, yy, yz, yw, zx, zy, zz, zw, wx, wy, wz, ww, @@ -388,7 +388,7 @@ EFL_START_TEST(eina_matrix4_operation) &yx, &yy, &yz, &yw, &zx, &zy, &zz, &zw, &wx, &wy, &wz, &ww); - fail_if(!MATRIX4_CMP(xx, xy, xz, xw, + ck_assert(!MATRIX4_CMP(xx, xy, xz, xw, yx, yy, yz, yw, zx, zy, zz, zw, wx, wy, wz, ww, @@ -404,7 +404,7 @@ EFL_START_TEST(eina_matrix4_operation) &yx, &yy, &yz, &yw, &zx, &zy, &zz, &zw, &wx, &wy, &wz, &ww); - fail_if(!MATRIX4_CMP(xx, xy, xz, xw, + ck_assert(!MATRIX4_CMP(xx, xy, xz, xw, yx, yy, yz, yw, zx, zy, zz, zw, wx, wy, wz, ww, @@ -426,7 +426,7 @@ EFL_START_TEST(eina_matrix4_operation) &yx, &yy, &yz, &yw, &zx, &zy, &zz, &zw, &wx, &wy, &wz, &ww); - fail_if(!MATRIX4_CMP(xx, xy, xz, xw, + ck_assert(!MATRIX4_CMP(xx, xy, xz, xw, yx, yy, yz, yw, zx, zy, zz, zw, wx, wy, wz, ww, @@ -451,7 +451,7 @@ EFL_START_TEST(eina_matrix4_2_3) eina_matrix3_matrix4_to(&m4, &m3); eina_matrix4_matrix3_to(&m3b, &m4); - fail_if(memcmp(&m3, &m3b, sizeof (Eina_Matrix3)) != 0); + ck_assert(memcmp(&m3, &m3b, sizeof (Eina_Matrix3)) != 0); } EFL_END_TEST @@ -479,27 +479,27 @@ EFL_START_TEST(eina_matrix3) 1, 1, 1, 0, 1, 0, 0, 0, 1); - fail_if(eina_matrix3_type_get(&m) != EINA_MATRIX_TYPE_IDENTITY); + ck_assert(eina_matrix3_type_get(&m) != EINA_MATRIX_TYPE_IDENTITY); eina_matrix3_values_get(&m, &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yy, zz) || !EINA_DBL_EQ(zz, 1)); - fail_if(!EINA_DBL_EQ(xy, xz) || + ck_assert(!EINA_DBL_EQ(xy, xz) || !EINA_DBL_EQ(yx, yz) || !EINA_DBL_EQ(zx, zy) || !EINA_DBL_EQ(zy, 0)); ret = eina_matrix3_equal(&m, &m1); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret = eina_matrix3_equal(&m1, &m2); - fail_if(ret != EINA_FALSE); + ck_assert(ret != EINA_FALSE); } EFL_END_TEST @@ -554,7 +554,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 1, 0, tx, @@ -571,7 +571,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, tx, 0, 0, @@ -599,11 +599,11 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!EINA_DBL_EQ(xx, yy) || + ck_assert(!EINA_DBL_EQ(xx, yy) || !EINA_DBL_EQ(yy, zz) || !EINA_DBL_EQ(zz, 1)); - fail_if(!EINA_DBL_EQ(xy, xz) || + ck_assert(!EINA_DBL_EQ(xy, xz) || !EINA_DBL_EQ(yx, yz) || !EINA_DBL_EQ(zx, zy) || !EINA_DBL_EQ(zy, 0)); @@ -613,7 +613,7 @@ EFL_START_TEST(eina_matrix3_operations) 2, 1, 1, 1, 2, 2); ret = eina_matrix3_determinant(&m1); - fail_if(!EINA_DBL_EQ(ret, -3)); + ck_assert(!EINA_DBL_EQ(ret, -3)); eina_matrix3_values_set(&m1, 3, 3, 3, @@ -641,7 +641,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, -0.5, 0.5, 0.0, @@ -657,7 +657,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 1, 4, 7, @@ -673,7 +673,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 24, 5, -4, @@ -685,7 +685,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 24, -12, -2, @@ -705,7 +705,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 12, 12, 12, @@ -721,7 +721,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 12, 12, 12, @@ -733,7 +733,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 2, 2, 2, @@ -745,7 +745,7 @@ EFL_START_TEST(eina_matrix3_operations) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(!MATRIX3_CMP(xx, xy, xz, + ck_assert(!MATRIX3_CMP(xx, xy, xz, yx, yy, yz, zx, zy, zz, 1, 1, 1, @@ -791,11 +791,11 @@ EFL_START_TEST(eina_matrix3_f16p16) &xx, &xy, &xz, &yx, &yy, &yz, &zx, &zy, &zz); - fail_if(xx != yy || + ck_assert(xx != yy || yy != zz || zz != 65536); - fail_if(xy != xz || + ck_assert(xy != xz || yx != yz || zx != zy || zy != 0); @@ -806,11 +806,11 @@ EFL_START_TEST(eina_matrix3_f16p16) 7, 8, 9); eina_matrix3_matrix3_f16p16_to(&m2, &m1); eina_matrix3_f16p16_identity(&m1); - fail_if(m1.xx != m1.yy || + ck_assert(m1.xx != m1.yy || m1.yy != m1.zz || m1.zz != 65536); - fail_if(m1.xy != m1.xz || + ck_assert(m1.xy != m1.xz || m1.yx != m1.yz || m1.zx != m1.zy || m1.zy != 0); @@ -849,13 +849,13 @@ EFL_START_TEST(eina_matrix3_map_transform) eina_matrix3_point_transform(&m, x, y, &x1, &y1); - fail_if(!EINA_DBL_EQ(x1, 3) || + ck_assert(!EINA_DBL_EQ(x1, 3) || !EINA_DBL_EQ(y1, 2)); EINA_RECTANGLE_SET(&r, 0, 0, 3, 4); eina_matrix3_rectangle_transform(&m, &r, &q); - fail_if(!EINA_DBL_EQ(q.x0, 0) || + ck_assert(!EINA_DBL_EQ(q.x0, 0) || !EINA_DBL_EQ(q.y0, 0) || !EINA_DBL_EQ(q.x1, 0) || !EINA_DBL_EQ(q.y1, 3) || @@ -870,9 +870,9 @@ EFL_START_TEST(eina_matrix3_map_transform) 3.0, 3.0, 0.0, 3.0); ret = eina_matrix3_square_quad_map(&m, &q); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); - fail_if(!MATRIX3_CMP(m.xx, m.xy, m.xz, + ck_assert(!MATRIX3_CMP(m.xx, m.xy, m.xz, m.yx, m.yy, m.yz, m.zx, m.zy, m.zz, 3, 0, 0, @@ -880,9 +880,9 @@ EFL_START_TEST(eina_matrix3_map_transform) 0, 0, 1)); ret = eina_matrix3_quad_square_map(&m, &q); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); - fail_if(!EINA_DBL_EQ(q.x0, 0) || + ck_assert(!EINA_DBL_EQ(q.x0, 0) || !EINA_DBL_EQ(q.y0, 0) || !EINA_DBL_EQ(q.x1, 3) || !EINA_DBL_EQ(q.y1, 0) || @@ -914,7 +914,7 @@ EFL_START_TEST(eina_normal3_test) &zx, &zy, &zz ); - fail_if((fabs(xy) - 1.0) > DBL_EPSILON || + ck_assert((fabs(xy) - 1.0) > DBL_EPSILON || (fabs(yx) - 1.0) > DBL_EPSILON || (fabs(yz) - 1.0) > DBL_EPSILON || (fabs(zy) - 1.0) > DBL_EPSILON @@ -931,7 +931,7 @@ EFL_START_TEST(eina_normal3_test) &yx, &yy, &yz, &zx, &zy, &zz ); - fail_if((fabs(xy)) > DBL_EPSILON || + ck_assert((fabs(xy)) > DBL_EPSILON || (fabs(yx)) > DBL_EPSILON || (fabs(yz)) > DBL_EPSILON || (fabs(zy)) > DBL_EPSILON diff --git a/src/tests/eina/eina_test_matrixsparse.c b/src/tests/eina/eina_test_matrixsparse.c index d2ad4c602f..6263db15cb 100644 --- a/src/tests/eina/eina_test_matrixsparse.c +++ b/src/tests/eina/eina_test_matrixsparse.c @@ -29,7 +29,7 @@ static void matrixsparse_initialize(Eina_Matrixsparse *matrix, if (data[i][j] != 0) { r = eina_matrixsparse_data_idx_set(matrix, i, j, &data[i][j]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); } } @@ -48,12 +48,12 @@ static void matrixsparse_check(Eina_Matrixsparse *matrix, if (data[i][j] != 0) { test1 = eina_matrixsparse_data_idx_get(matrix, i, j); - fail_if(test1 == NULL || *test1 != data[i][j]); + ck_assert(test1 == NULL || *test1 != data[i][j]); } else { test1 = eina_matrixsparse_data_idx_get(matrix, i, j); - fail_if(test1 != NULL); + ck_assert(test1 != NULL); } } } @@ -108,95 +108,95 @@ EFL_START_TEST(eina_test_simple) matrix = eina_matrixsparse_new(MAX_ROWS, MAX_COLS, eina_matrixsparse_free_cell_cb, data); - fail_if(matrix == NULL); + ck_assert(matrix == NULL); r = eina_matrixsparse_cell_idx_get(matrix, 3, 5, &cell); - fail_if(r == EINA_FALSE); - fail_if(cell != NULL); + ck_assert(r == EINA_FALSE); + ck_assert(cell != NULL); matrixsparse_initialize(matrix, data, MAX_ROWS, MAX_COLS); /* data fetching */ test1 = eina_matrixsparse_data_idx_get(matrix, 3, 0); - fail_if(test1 == NULL); - fail_if(*test1 != data[3][0]); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[3][0]); test1 = eina_matrixsparse_data_idx_get(matrix, 3, 5); - fail_if(test1 == NULL); - fail_if(*test1 != data[3][5]); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[3][5]); test1 = eina_matrixsparse_data_idx_get(matrix, 3, 6); - fail_if(test1 == NULL); - fail_if(*test1 != data[3][6]); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[3][6]); test1 = eina_matrixsparse_data_idx_get(matrix, 3, 1); - fail_if(test1 != NULL); + ck_assert(test1 != NULL); r = eina_matrixsparse_cell_idx_get(matrix, 3, 5, &cell); - fail_if(r == EINA_FALSE); - fail_if(cell == NULL); + ck_assert(r == EINA_FALSE); + ck_assert(cell == NULL); test1 = eina_matrixsparse_cell_data_get(cell); - fail_if(test1 == NULL); - fail_if(*test1 != data[3][5]); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[3][5]); r = eina_matrixsparse_cell_position_get(cell, &row, &col); - fail_if(r == EINA_FALSE); - fail_if(row != 3 || col != 5); + ck_assert(r == EINA_FALSE); + ck_assert(row != 3 || col != 5); test1 = eina_matrixsparse_data_idx_get(matrix, 4, 3); - fail_if(test1 == NULL); - fail_if(*test1 != data[4][3]); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[4][3]); test1 = eina_matrixsparse_data_idx_get(matrix, 1, 3); - fail_if(test1 == NULL); - fail_if(*test1 != data[1][3]); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[1][3]); /* data changing */ r = eina_matrixsparse_data_idx_set(matrix, 1, 9, &data[1][9]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_replace(matrix, 4, 3, &value, (void **)&test1); - fail_if(r == EINA_FALSE); - fail_if(test1 == NULL); - fail_if(*test1 != data[4][3]); + ck_assert(r == EINA_FALSE); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[4][3]); data[4][3] = value; test1 = eina_matrixsparse_data_idx_get(matrix, 4, 3); - fail_if(test1 == NULL || *test1 != value); + ck_assert(test1 == NULL || *test1 != value); r = eina_matrixsparse_cell_data_replace(cell, &value2, (void **)&test1); - fail_if(r == EINA_FALSE); - fail_if(test1 == NULL); - fail_if(*test1 != data[3][5]); + ck_assert(r == EINA_FALSE); + ck_assert(test1 == NULL); + ck_assert(*test1 != data[3][5]); data[3][5] = value2; test1 = eina_matrixsparse_data_idx_get(matrix, 3, 5); - fail_if(test1 == NULL); - fail_if(*test1 != value2); + ck_assert(test1 == NULL); + ck_assert(*test1 != value2); r = eina_matrixsparse_cell_idx_get(matrix, 4, 2, &cell); - fail_if(r == EINA_FALSE || cell == NULL); + ck_assert(r == EINA_FALSE || cell == NULL); r = eina_matrixsparse_cell_data_set(cell, &value3); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[4][2] = value3; test1 = eina_matrixsparse_data_idx_get(matrix, 4, 2); - fail_if(test1 == NULL || *test1 != value3); + ck_assert(test1 == NULL || *test1 != value3); r = eina_matrixsparse_data_idx_replace(matrix, 6, 5, &value4, (void **)&test1); - fail_if(r == EINA_FALSE || test1 != NULL); + ck_assert(r == EINA_FALSE || test1 != NULL); data[6][5] = value4; /* cell deletion */ r = eina_matrixsparse_row_idx_clear(matrix, 4); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[4][6] = 0; data[4][8] = 0; data[4][2] = 0; @@ -204,17 +204,17 @@ EFL_START_TEST(eina_test_simple) data[4][7] = 0; test1 = eina_matrixsparse_data_idx_get(matrix, 4, 3); - fail_if(test1 != NULL); + ck_assert(test1 != NULL); test1 = eina_matrixsparse_data_idx_get(matrix, 4, 8); - fail_if(test1 != NULL); + ck_assert(test1 != NULL); test1 = eina_matrixsparse_data_idx_get(matrix, 5, 3); - fail_if(!test1); - fail_if(*test1 != data[5][3]); + ck_assert(!test1); + ck_assert(*test1 != data[5][3]); r = eina_matrixsparse_column_idx_clear(matrix, 3); - fail_if(r != EINA_TRUE); + ck_assert(r != EINA_TRUE); data[0][3] = 0; data[1][3] = 0; data[4][3] = 0; @@ -223,45 +223,45 @@ EFL_START_TEST(eina_test_simple) data[7][3] = 0; r = eina_matrixsparse_cell_idx_clear(matrix, 3, 5); - fail_if(r != EINA_TRUE); + ck_assert(r != EINA_TRUE); data[3][5] = 0; r = eina_matrixsparse_cell_idx_clear(matrix, 3, 9); - fail_if(r != EINA_TRUE); + ck_assert(r != EINA_TRUE); data[3][9] = 0; r = eina_matrixsparse_cell_idx_clear(matrix, 4, 3); - fail_if(r != EINA_TRUE); + ck_assert(r != EINA_TRUE); data[4][3] = 0; r = eina_matrixsparse_cell_idx_get(matrix, 3, 7, &cell); - fail_if(r == EINA_FALSE); - fail_if(cell == NULL); + ck_assert(r == EINA_FALSE); + ck_assert(cell == NULL); r = eina_matrixsparse_cell_clear(cell); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[3][7] = 0; r = eina_matrixsparse_cell_idx_get(matrix, 2, 7, &cell); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_cell_idx_clear(matrix, 2, 8); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[2][8] = 0; r = eina_matrixsparse_cell_idx_clear(matrix, 2, 7); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[2][7] = 0; r = eina_matrixsparse_cell_idx_get(matrix, 7, 7, &cell); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_row_idx_clear(matrix, 8); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[8][8] = 0; r = eina_matrixsparse_row_idx_clear(matrix, 7); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[7][3] = 0; data[7][7] = 0; @@ -287,7 +287,7 @@ EFL_START_TEST(eina_test_resize) matrix = eina_matrixsparse_new(MAX_ROWS, MAX_COLS, eina_matrixsparse_free_cell_cb, data); - fail_if(matrix == NULL); + ck_assert(matrix == NULL); /* cell insertion */ data[0][5] = 5; @@ -322,10 +322,10 @@ EFL_START_TEST(eina_test_resize) matrixsparse_initialize(matrix, data, MAX_ROWS, MAX_COLS); eina_matrixsparse_size_get(matrix, &nrows, &ncols); - fail_if(nrows != MAX_ROWS || ncols != MAX_COLS); + ck_assert(nrows != MAX_ROWS || ncols != MAX_COLS); r = eina_matrixsparse_size_set(matrix, nrows - 2, ncols - 2); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[1][9] = 0; data[1][8] = 0; data[2][8] = 0; @@ -335,7 +335,7 @@ EFL_START_TEST(eina_test_resize) matrixsparse_check(matrix, data, MAX_ROWS, MAX_COLS); r = eina_matrixsparse_size_set(matrix, 5, 1); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[0][5] = 0; data[1][3] = 0; data[1][6] = 0; @@ -358,21 +358,21 @@ EFL_START_TEST(eina_test_resize) matrixsparse_check(matrix, data, MAX_ROWS, MAX_COLS); r = eina_matrixsparse_size_set(matrix, 1, 1); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[3][0] = 0; data[1][0] = 0; matrixsparse_check(matrix, data, MAX_ROWS, MAX_COLS); r = eina_matrixsparse_size_set(matrix, 5, 4); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 4, 2, &data[4][2]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[4][2] = 42; matrixsparse_check(matrix, data, MAX_ROWS, MAX_COLS); r = eina_matrixsparse_size_set(matrix, 5, 1); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); data[4][2] = 0; matrixsparse_check(matrix, data, MAX_ROWS, MAX_COLS); @@ -407,69 +407,69 @@ EFL_START_TEST(eina_test_iterators) matrix = eina_matrixsparse_new(MAX_ROWS, MAX_COLS, eina_matrixsparse_free_cell_cb, data); - fail_if(matrix == NULL); + ck_assert(matrix == NULL); r = eina_matrixsparse_data_idx_set(matrix, 3, 5, &data[3][5]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 3, 6, &data[3][6]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 3, 7, &data[3][7]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 3, 9, &data[3][9]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 3, 0, &data[3][0]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 4, 6, &data[4][6]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 4, 8, &data[4][8]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 4, 2, &data[4][2]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 4, 3, &data[4][3]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 4, 7, &data[4][7]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 6, 4, &data[6][4]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 5, 3, &data[5][3]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 6, 3, &data[6][3]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 7, 3, &data[7][3]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 0, 3, &data[0][3]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 1, 3, &data[1][3]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 1, 6, &data[1][6]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_matrixsparse_data_idx_set(matrix, 1, 9, &data[1][9]); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); it = eina_matrixsparse_iterator_new(matrix); - fail_if(it == NULL); + ck_assert(it == NULL); EINA_ITERATOR_FOREACH(it, cell) { - fail_if(cell == NULL); + ck_assert(cell == NULL); r = eina_matrixsparse_cell_position_get(cell, &row, &col); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); test1 = eina_matrixsparse_cell_data_get(cell); - fail_if(test1 == NULL || *test1 != data[row][col]); + ck_assert(test1 == NULL || *test1 != data[row][col]); } eina_iterator_free(it); it = eina_matrixsparse_iterator_complete_new(matrix); - fail_if(it == NULL); + ck_assert(it == NULL); EINA_ITERATOR_FOREACH(it, cell) { - fail_if(cell == NULL); + ck_assert(cell == NULL); r = eina_matrixsparse_cell_position_get(cell, &row, &col); - fail_if(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); test1 = eina_matrixsparse_cell_data_get(cell); if (test1) - fail_if(*test1 != data[row][col]); + ck_assert(*test1 != data[row][col]); } eina_iterator_free(it); diff --git a/src/tests/eina/eina_test_mempool.c b/src/tests/eina/eina_test_mempool.c index c36bab1717..f90e8bdfa8 100644 --- a/src/tests/eina/eina_test_mempool.c +++ b/src/tests/eina/eina_test_mempool.c @@ -33,25 +33,25 @@ _eina_mempool_test(Eina_Mempool *mp, int *ptr; int i; - fail_if(!mp); + ck_assert(!mp); for (i = 0; i < 512; ++i) { tbl[i] = eina_mempool_malloc(mp, sizeof (int)); - fail_if(!tbl[i]); + ck_assert(!tbl[i]); if (accurate_from) - fail_if(eina_mempool_from(mp, tbl[i]) != EINA_TRUE); + ck_assert(eina_mempool_from(mp, tbl[i]) != EINA_TRUE); *tbl[i] = i; } for (i = 0; i < 512; ++i) - fail_if(*tbl[i] != i); + ck_assert(*tbl[i] != i); for (i = 0; i < 256; ++i) { eina_mempool_free(mp, tbl[i]); if (accurate_from) - fail_if(eina_mempool_from(mp, tbl[i]) != EINA_FALSE); + ck_assert(eina_mempool_from(mp, tbl[i]) != EINA_FALSE); } it = eina_mempool_iterator_new(mp); @@ -69,9 +69,9 @@ _eina_mempool_test(Eina_Mempool *mp, } if (with_realloc) - fail_if(eina_mempool_realloc(mp, tbl[500], 25) == NULL); + ck_assert(eina_mempool_realloc(mp, tbl[500], 25) == NULL); else - fail_if(eina_mempool_realloc(mp, tbl[500], 25) != NULL); + ck_assert(eina_mempool_realloc(mp, tbl[500], 25) != NULL); if (with_gc) { diff --git a/src/tests/eina/eina_test_module.c b/src/tests/eina/eina_test_module.c index 44b2389e73..f211465f93 100644 --- a/src/tests/eina/eina_test_module.c +++ b/src/tests/eina/eina_test_module.c @@ -32,14 +32,14 @@ static Eina_Bool list_cb(Eina_Module *m, void *data EINA_UNUSED) const char *file; /* the reference count */ - fail_if(!eina_module_load(m)); + ck_assert(!eina_module_load(m)); /* get */ sym = eina_module_symbol_get(m, "dummy_symbol"); - fail_if(!sym); - fail_if(*sym != 0xbad); + ck_assert(!sym); + ck_assert(*sym != 0xbad); file = eina_module_file_get(m); - fail_if(!file); - fail_if(eina_module_unload(m)); + ck_assert(!file); + ck_assert(eina_module_unload(m)); return EINA_TRUE; } @@ -57,7 +57,7 @@ EFL_START_TEST(eina_module_load_unload) EINA_TRUE, &list_cb, NULL); - fail_if(!_modules); + ck_assert(!_modules); eina_module_list_load(_modules); eina_module_list_unload(_modules); eina_module_list_free(_modules); @@ -76,8 +76,8 @@ EFL_START_TEST(eina_module_find_test) EINA_TRUE, &list_cb, NULL); - fail_if(!_modules); - fail_if(eina_module_find(_modules, NULL) != NULL); + ck_assert(!_modules); + ck_assert(eina_module_find(_modules, NULL) != NULL); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_quadtree.c b/src/tests/eina/eina_test_quadtree.c index 175154de23..ac7fa1980f 100644 --- a/src/tests/eina/eina_test_quadtree.c +++ b/src/tests/eina/eina_test_quadtree.c @@ -99,13 +99,13 @@ EFL_START_TEST(eina_quadtree_collision) _eina_quadtree_rectangle_vert, _eina_quadtree_rectangle_hort); - fail_if(!q); + ck_assert(!q); for (i = 0; objects[i].r.w != 0 && objects[i].r.h != 0; ++i) { objects[i].item = eina_quadtree_add(q, &objects[i].r); - fail_if(!objects[i].item); - fail_if(!eina_quadtree_show(objects[i].item)); + ck_assert(!objects[i].item); + ck_assert(!eina_quadtree_show(objects[i].item)); } eina_quadtree_resize(q, 640, 480); @@ -128,12 +128,12 @@ EFL_START_TEST(eina_quadtree_collision) if (&objects[tests[i].result[k]].r == r) break; } - fail_if(k == tests[i].count); + ck_assert(k == tests[i].count); head = head->next; count++; } - fail_if(count != tests[i].count); + ck_assert(count != tests[i].count); } for (i = 0; i < (int)(sizeof (hidden) / sizeof (int)); ++i) @@ -150,12 +150,12 @@ EFL_START_TEST(eina_quadtree_collision) { r = eina_quadtree_object(head); - fail_if(r != &objects[tests[1].result[show[count]]].r); + ck_assert(r != &objects[tests[1].result[show[count]]].r); head = head->next; count++; } - fail_if(count != 3); + ck_assert(count != 3); eina_quadtree_cycle(q); eina_quadtree_show(objects[4].item); @@ -180,7 +180,7 @@ EFL_START_TEST(eina_quadtree_collision) head = head->next; count++; } - fail_if(count != 1); + ck_assert(count != 1); eina_quadtree_free(q); diff --git a/src/tests/eina/eina_test_quaternion.c b/src/tests/eina/eina_test_quaternion.c index 72360ec22c..55be0d8612 100644 --- a/src/tests/eina/eina_test_quaternion.c +++ b/src/tests/eina/eina_test_quaternion.c @@ -98,7 +98,7 @@ EFL_START_TEST(eina_test_quaternion_norm) double result = eina_quaternion_norm(&q); - fail_if(!EINA_FLT_EQ(result, sqrt(51))); + ck_assert(!EINA_FLT_EQ(result, sqrt(51))); } EFL_END_TEST @@ -113,8 +113,8 @@ EFL_START_TEST(eina_test_quaternion_conjugate) eina_quaternion_conjugate(&t1, &q1); eina_quaternion_conjugate(&t2, &q2); - fail_if(!eina_quaternion_cmp(&t1, &r1)); - fail_if(!eina_quaternion_cmp(&t2, &r2)); + ck_assert(!eina_quaternion_cmp(&t1, &r1)); + ck_assert(!eina_quaternion_cmp(&t2, &r2)); } EFL_END_TEST @@ -133,10 +133,10 @@ EFL_START_TEST(eina_test_quaternion_matrix) eina_quaternion_rotation_matrix3_get(&tm, &q); - fail_if(!eina_matrix3_cmp(&tm, &m)); + ck_assert(!eina_matrix3_cmp(&tm, &m)); eina_matrix3_quaternion_get(&tq, &m); - fail_if(!eina_quaternion_cmp(&tq, &q) && !eina_quaternion_cmp(&tq, &q1)); + ck_assert(!eina_quaternion_cmp(&tq, &q) && !eina_quaternion_cmp(&tq, &q1)); } EFL_END_TEST @@ -151,7 +151,7 @@ EFL_START_TEST(eina_test_quaternion_op) eina_quaternion_negative(&neg, &q); eina_quaternion_add(&r, &q, &neg); - fail_if(!eina_quaternion_cmp(&z, &r)); + ck_assert(!eina_quaternion_cmp(&z, &r)); } EFL_END_TEST @@ -167,32 +167,32 @@ EFL_START_TEST(eina_test_quaternion_f16p16) eina_quaternion_f16p16_set(&p, x, y, z, w); - fail_if(!eina_quaternion_cmp(&p, &q)); + ck_assert(!eina_quaternion_cmp(&p, &q)); res = eina_quaternion_f16p16_norm(&r); - fail_if(res != 131070); + ck_assert(res != 131070); eina_quaternion_f16p16_negative(&s, &r); - fail_if(s.x != s.y || + ck_assert(s.x != s.y || s.y != s.z || s.z != s.w || s.w != -65536); eina_quaternion_f16p16_add(&t, &s, &r); - fail_if(t.x != t.y || + ck_assert(t.x != t.y || t.y != t.z || t.z != t.w || t.w != 0); res = 1; eina_quaternion_f16p16_scale(&t, &r, res); - fail_if(t.x != t.y || + ck_assert(t.x != t.y || t.y != t.z || t.z != t.w || t.w != 65536); eina_quaternion_f16p16_conjugate(&t, &r); - fail_if(t.x != -65536 || + ck_assert(t.x != -65536 || t.y != -65536 || t.z != -65536 || t.w != 65536); @@ -202,10 +202,10 @@ EFL_START_TEST(eina_test_quaternion_f16p16) s.z = 65536; s.w = 65536; res = eina_quaternion_f16p16_dot(&s, &r); - fail_if(res != 262144); + ck_assert(res != 262144); eina_quaternion_f16p16_mul(&t, &s, &r); - fail_if(t.x != 131072 || + ck_assert(t.x != 131072 || t.y != 131072 || t.z != 131072 || t.w != 0); @@ -220,7 +220,7 @@ EFL_START_TEST(eina_test_quaternion_dot) res = eina_quaternion_dot(&q, &r); - fail_if(!EINA_DBL_EQ(res, 59)); + ck_assert(!EINA_DBL_EQ(res, 59)); } EFL_END_TEST @@ -233,7 +233,7 @@ EFL_START_TEST(eina_test_quaternion_scale) eina_quaternion_scale(&r, &q, scale); - fail_if(!eina_quaternion_cmp(&r, &res)); + ck_assert(!eina_quaternion_cmp(&r, &res)); } EFL_END_TEST @@ -245,7 +245,7 @@ EFL_START_TEST(eina_test_quaternion_set) eina_quaternion_set(&q, 1, 3, 4, 5); - fail_if(!eina_quaternion_cmp(&q, &r)); + ck_assert(!eina_quaternion_cmp(&q, &r)); } EFL_END_TEST @@ -258,7 +258,7 @@ EFL_START_TEST(eina_test_quaternion_mul) eina_quaternion_mul(&r, &p, &q); - fail_if(!eina_quaternion_cmp(&r, &res)); + ck_assert(!eina_quaternion_cmp(&r, &res)); } EFL_END_TEST @@ -280,7 +280,7 @@ EFL_START_TEST(eina_test_matrix_recompose) &scale, &skew); - fail_if(eina_matrix4_type_get(&m4) != EINA_MATRIX_TYPE_IDENTITY); + ck_assert(eina_matrix4_type_get(&m4) != EINA_MATRIX_TYPE_IDENTITY); } EFL_END_TEST @@ -292,7 +292,7 @@ EFL_START_TEST(eina_test_quaternion_normalized) eina_quaternion_normalized(&res, &p); - fail_if(!eina_quaternion_cmp(&q, &res)); + ck_assert(!eina_quaternion_cmp(&q, &res)); } EFL_END_TEST @@ -316,7 +316,7 @@ EFL_START_TEST(eina_test_matrix_quaternion) eina_matrix3_scale(&m3, 4, 5); eina_matrix3_matrix4_to(&m4, &m3); - fail_if(!eina_matrix4_quaternion_to(&rotation, + ck_assert(!eina_matrix4_quaternion_to(&rotation, &perspective, &translation, &scale, @@ -332,13 +332,13 @@ EFL_START_TEST(eina_test_matrix_quaternion) eina_matrix4_matrix3_to(&m3r, &m4r); - fail_if(!eina_point_3d_cmp(&scale, &rsc)); - fail_if(!eina_point_3d_cmp(&translation, &rt)); - fail_if(!eina_quaternion_cmp(&perspective, &rp)); - fail_if(!eina_quaternion_cmp(&rotation, &rr)); + ck_assert(!eina_point_3d_cmp(&scale, &rsc)); + ck_assert(!eina_point_3d_cmp(&translation, &rt)); + ck_assert(!eina_quaternion_cmp(&perspective, &rp)); + ck_assert(!eina_quaternion_cmp(&rotation, &rr)); // Disable this test for the moment as it seems a rounding issue - // fail_if(!eina_matrix3_cmp(&m3r, &m3)); + // ck_assert(!eina_matrix3_cmp(&m3r, &m3)); } EFL_END_TEST @@ -353,19 +353,19 @@ EFL_START_TEST(eina_test_quaternion_f16p16_lerp) eina_quaternion_f16p16_lerp(&r, &p, &q, 65536); - fail_if(!eina_quaternion_f16p16_cmp(&r, &res1)); + ck_assert(!eina_quaternion_f16p16_cmp(&r, &res1)); eina_quaternion_f16p16_lerp(&r, &p, &q, 0); - fail_if(!eina_quaternion_f16p16_cmp(&r, &res2)); + ck_assert(!eina_quaternion_f16p16_cmp(&r, &res2)); eina_quaternion_f16p16_slerp(&r, &p, &q, 0); - fail_if(!eina_quaternion_f16p16_cmp(&r, &res2)); + ck_assert(!eina_quaternion_f16p16_cmp(&r, &res2)); eina_quaternion_f16p16_slerp(&r, &p, &q, 65536); - fail_if(!eina_quaternion_f16p16_cmp(&r, &res1)); + ck_assert(!eina_quaternion_f16p16_cmp(&r, &res1)); eina_quaternion_f16p16_nlerp(&r, &p, &q, 0); - fail_if(!eina_quaternion_f16p16_cmp(&r, &res2)); + ck_assert(!eina_quaternion_f16p16_cmp(&r, &res2)); eina_quaternion_f16p16_nlerp(&r, &p, &q, 65536); - fail_if(!eina_quaternion_f16p16_cmp(&r, &res1)); + ck_assert(!eina_quaternion_f16p16_cmp(&r, &res1)); } EFL_END_TEST @@ -378,28 +378,28 @@ EFL_START_TEST(eina_test_quaternion_lerp) eina_quaternion_lerp(&rr, &rp, &rq, 0.5); - fail_if(!eina_quaternion_cmp(&rr, &res)); + ck_assert(!eina_quaternion_cmp(&rr, &res)); eina_quaternion_set(&rp, 1, 1, 1, 0); eina_quaternion_set(&rq, 0, 1, 1, 0); eina_quaternion_set(&res, 0.5, 1.0, 1.0, 0.0); eina_quaternion_lerp(&rr, &rp, &rq, 0.5); - fail_if(!eina_quaternion_cmp(&rr, &res)); + ck_assert(!eina_quaternion_cmp(&rr, &res)); eina_quaternion_set(&rp, 0, 0, 1, 0); eina_quaternion_set(&rq, 1, 1, 1, 0); eina_quaternion_set(&res, 0.5, 0.5, 1.0, 0.0); eina_quaternion_slerp(&rr, &rp, &rq, 0.5); - fail_if(!eina_quaternion_cmp(&rr, &res)); + ck_assert(!eina_quaternion_cmp(&rr, &res)); eina_quaternion_set(&rp, 0, 0, 0, 0); eina_quaternion_set(&rq, 1, 1, 1, 0); eina_quaternion_set(&res, 1.0, 1.0, 1.0, 0.0); eina_quaternion_nlerp(&rr, &rp, &rq, 1.0); - fail_if(!eina_quaternion_cmp(&rr, &res)); + ck_assert(!eina_quaternion_cmp(&rr, &res)); } EFL_END_TEST @@ -415,12 +415,12 @@ EFL_START_TEST(eina_test_quaternion_f16p16_rotate_matrix) eina_quaternion_f16p16_rotate(&r, &c, &q); - fail_if(r.x != res.x || + ck_assert(r.x != res.x || r.y != res.y || r.z != res.z); eina_quaternion_f16p16_rotation_matrix3_get(&m, &q); - fail_if(!eina_matrix3_f16p16_cmp(&m, &mres)); + ck_assert(!eina_matrix3_f16p16_cmp(&m, &mres)); } EFL_END_TEST @@ -434,11 +434,11 @@ EFL_START_TEST(eina_test_quaternion_rotate) eina_quaternion_rotate(&r, &c, &q); - fail_if(!eina_point_3d_cmp(&r, &res)); + ck_assert(!eina_point_3d_cmp(&r, &res)); eina_quaternion_set(&q, 1, 1, 0, 0); eina_quaternion_rotate(&r, &c, &q); - fail_if(!eina_point_3d_cmp(&r, &res1)); + ck_assert(!eina_point_3d_cmp(&r, &res1)); } EFL_END_TEST @@ -453,32 +453,32 @@ EFL_START_TEST(eina_test_quaternion_operations) Eina_Matrix4 m; eina_quaternion_inverse(&out, &in); - fail_if((out.x + 0.2 > DBL_EPSILON) || (out.y + 0.2 > DBL_EPSILON) || + ck_assert((out.x + 0.2 > DBL_EPSILON) || (out.y + 0.2 > DBL_EPSILON) || (out.z + 0.1 > DBL_EPSILON) || (out.w - 0.1 > DBL_EPSILON)); eina_quaternion_array_set(&out, v); - fail_if((!EINA_DBL_EQ(out.x, 0)) || (!EINA_DBL_EQ(out.y, 1)) || + ck_assert((!EINA_DBL_EQ(out.x, 0)) || (!EINA_DBL_EQ(out.y, 1)) || (!EINA_DBL_EQ(out.z, 2)) || (!EINA_DBL_EQ(out.w, 3))); eina_quaternion_copy(&out, &in); - fail_if((!EINA_DBL_EQ(out.x, 2)) || (!EINA_DBL_EQ(out.y, 2)) || + ck_assert((!EINA_DBL_EQ(out.x, 2)) || (!EINA_DBL_EQ(out.y, 2)) || (!EINA_DBL_EQ(out.z, 1)) || (!EINA_DBL_EQ(out.w, 1))); eina_quaternion_homogeneous_regulate(&out, &in2); - fail_if((!EINA_DBL_EQ(out.x, 1)) || (!EINA_DBL_EQ(out.y, 1)) || + ck_assert((!EINA_DBL_EQ(out.x, 1)) || (!EINA_DBL_EQ(out.y, 1)) || (!EINA_DBL_EQ(out.z, 1)) || (!EINA_DBL_EQ(out.w, 1))); eina_quaternion_subtract(&out, &in2, &in); - fail_if((!EINA_DBL_EQ(out.x, 3)) || (!EINA_DBL_EQ(out.y, 3)) || + ck_assert((!EINA_DBL_EQ(out.x, 3)) || (!EINA_DBL_EQ(out.y, 3)) || (!EINA_DBL_EQ(out.z, 4)) || (!EINA_DBL_EQ(out.w, 4))); - fail_if(!EINA_DBL_EQ(eina_quaternion_length_get(&in2), 10)); - fail_if(!EINA_DBL_EQ(eina_quaternion_length_square_get(&in), 10)); - fail_if((eina_quaternion_distance_get(&in2, &in) - sqrt(50)) > DBL_EPSILON); - fail_if(!EINA_DBL_EQ(eina_quaternion_distance_square_get(&in2, &in), 50)); + ck_assert(!EINA_DBL_EQ(eina_quaternion_length_get(&in2), 10)); + ck_assert(!EINA_DBL_EQ(eina_quaternion_length_square_get(&in), 10)); + ck_assert((eina_quaternion_distance_get(&in2, &in) - sqrt(50)) > DBL_EPSILON); + ck_assert(!EINA_DBL_EQ(eina_quaternion_distance_square_get(&in2, &in), 50)); angle = eina_quaternion_angle_plains(&in, &in2); - fail_if(angle - 0.963 > DBL_EPSILON); + ck_assert(angle - 0.963 > DBL_EPSILON); eina_matrix4_values_set(&m, 1, 0, 0, 0, @@ -486,7 +486,7 @@ EFL_START_TEST(eina_test_quaternion_operations) 0, 0, 1, 0, 0, 0, 0, 1); eina_quaternion_transform(&out, &in, &m); - fail_if((fabs(out.x) - 2.0) > DBL_EPSILON || + ck_assert((fabs(out.x) - 2.0) > DBL_EPSILON || (fabs(out.y) - 2.0) > DBL_EPSILON || (fabs(out.z) - 1.0) > DBL_EPSILON || (fabs(out.w) - 1.0) > DBL_EPSILON @@ -498,7 +498,7 @@ EFL_START_TEST(eina_test_quaternion_operations) 0, 0, 1, 0, 0, 0, 0, 1); eina_quaternion_transform(&out, &in, &m); - fail_if((fabs(out.x) - 1.0) > DBL_EPSILON || + ck_assert((fabs(out.x) - 1.0) > DBL_EPSILON || (fabs(out.y) - 1.0) > DBL_EPSILON || (fabs(out.z) - 1.0) > DBL_EPSILON || (fabs(out.w) - 1.0) > DBL_EPSILON diff --git a/src/tests/eina/eina_test_rbtree.c b/src/tests/eina/eina_test_rbtree.c index 3a800b695a..f3b81f455a 100644 --- a/src/tests/eina/eina_test_rbtree.c +++ b/src/tests/eina/eina_test_rbtree.c @@ -226,7 +226,7 @@ _eina_rbtree_black_height(Eina_Rbtree *tree, Eina_Rbtree_Cmp_Node_Cb cmp) right = tree->son[EINA_RBTREE_RIGHT]; /* Consecutive red links. */ - fail_if(_eina_rbtree_is_red(tree) && + ck_assert(_eina_rbtree_is_red(tree) && (_eina_rbtree_is_red(left) || _eina_rbtree_is_red(right))); left_height = _eina_rbtree_black_height(left, cmp); @@ -236,20 +236,20 @@ _eina_rbtree_black_height(Eina_Rbtree *tree, Eina_Rbtree_Cmp_Node_Cb cmp) if (left) { dir = cmp(tree, left, NULL); - fail_if(dir != EINA_RBTREE_LEFT); + ck_assert(dir != EINA_RBTREE_LEFT); } if (right) { dir = cmp(tree, right, NULL); - fail_if(dir != EINA_RBTREE_RIGHT); + ck_assert(dir != EINA_RBTREE_RIGHT); } /* Check black height */ if (left_height != right_height) fprintf(stderr, "%i != %i\n", left_height, right_height); - fail_if(left_height != right_height); + ck_assert(left_height != right_height); return _eina_rbtree_is_red(tree) ? left_height : left_height + 1; } @@ -266,8 +266,8 @@ eina_rbtree_int_cmp(const Eina_Rbtree_Int *left, const Eina_Rbtree_Int *right, EINA_UNUSED void *data) { - fail_if(!left); - fail_if(!right); + ck_assert(!left); + ck_assert(!right); if (left->value < right->value) return EINA_RBTREE_LEFT; @@ -281,7 +281,7 @@ eina_rbtree_int_key(const Eina_Rbtree_Int *node, EINA_UNUSED int length, EINA_UNUSED void *data) { - fail_if(!node); + ck_assert(!node); return node->value - *key; } @@ -351,7 +351,7 @@ EFL_START_TEST(eina_rbtree_lookup) EINA_RBTREE_CMP_KEY_CB( eina_rbtree_int_key), NULL); - fail_if(!item); + ck_assert(!item); i = 42; item = @@ -361,7 +361,7 @@ EFL_START_TEST(eina_rbtree_lookup) EINA_RBTREE_CMP_KEY_CB( eina_rbtree_int_key), NULL); - fail_if(item); + ck_assert(item); free(mem); } EFL_END_TEST @@ -380,7 +380,7 @@ EFL_START_TEST(eina_rbtree_remove) mem = _eina_rbtree_int_init(num_nodes); ea = eina_array_new(num_nodes); - fail_if(!ea); + ck_assert(!ea); for (i = 0; i < num_nodes; ++i) @@ -410,7 +410,7 @@ EFL_START_TEST(eina_rbtree_remove) EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp)); } - fail_if(root != NULL); + ck_assert(root != NULL); eina_array_free(ea); free(mem); } @@ -435,7 +435,7 @@ EFL_START_TEST(eina_rbtree_simple_remove) _eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp)); - fail_if(root == NULL); + ck_assert(root == NULL); i = 69; lookup = eina_rbtree_inline_lookup(root, @@ -445,7 +445,7 @@ EFL_START_TEST(eina_rbtree_simple_remove) eina_rbtree_int_key), NULL); _eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp)); - fail_if(lookup == NULL); + ck_assert(lookup == NULL); root = eina_rbtree_inline_remove(root, lookup, EINA_RBTREE_CMP_NODE_CB( @@ -475,7 +475,7 @@ EFL_START_TEST(eina_rbtree_simple_remove2) _eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp)); - fail_if(root == NULL); + ck_assert(root == NULL); i = 69; lookup = eina_rbtree_inline_lookup(root, @@ -485,7 +485,7 @@ EFL_START_TEST(eina_rbtree_simple_remove2) eina_rbtree_int_key), NULL); _eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp)); - fail_if(lookup == NULL); + ck_assert(lookup == NULL); root = eina_rbtree_inline_remove(root, lookup, EINA_RBTREE_CMP_NODE_CB( @@ -528,7 +528,7 @@ EFL_START_TEST(eina_rbtree_simple_remove3) _eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp)); - fail_if(root == NULL); + ck_assert(root == NULL); i = 1113497590; lookup = eina_rbtree_inline_lookup(root, @@ -538,7 +538,7 @@ EFL_START_TEST(eina_rbtree_simple_remove3) eina_rbtree_int_key), NULL); _eina_rbtree_black_height(root, EINA_RBTREE_CMP_NODE_CB(eina_rbtree_int_cmp)); - fail_if(lookup == NULL); + ck_assert(lookup == NULL); root = eina_rbtree_inline_remove(root, lookup, EINA_RBTREE_CMP_NODE_CB( diff --git a/src/tests/eina/eina_test_rectangle.c b/src/tests/eina/eina_test_rectangle.c index b38cc75639..c2d0bbb89a 100644 --- a/src/tests/eina/eina_test_rectangle.c +++ b/src/tests/eina/eina_test_rectangle.c @@ -37,34 +37,34 @@ EFL_START_TEST(eina_rectangle_pool) pool = eina_rectangle_pool_new(256, 256); - fail_if(pool == NULL); + ck_assert(pool == NULL); eina_rectangle_pool_data_set(pool, rects); - fail_if(eina_rectangle_pool_data_get(pool) != rects); + ck_assert(eina_rectangle_pool_data_get(pool) != rects); - fail_if(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); + ck_assert(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); for (x = 0; x < 8; x++) for (y = 0; y < 8; y++) { rects[x][y] = eina_rectangle_pool_request(pool, 32, 32); - fail_if(rects[x][y] == NULL); + ck_assert(rects[x][y] == NULL); } - fail_if(eina_rectangle_pool_count(pool) != 64); + ck_assert(eina_rectangle_pool_count(pool) != 64); - fail_if(eina_rectangle_pool_get(rects[0][0]) != pool); + ck_assert(eina_rectangle_pool_get(rects[0][0]) != pool); - fail_if(eina_rectangle_pool_geometry_get(pool, &w, &h) != EINA_TRUE); - fail_if(w != 256 || h != 256); + ck_assert(eina_rectangle_pool_geometry_get(pool, &w, &h) != EINA_TRUE); + ck_assert(w != 256 || h != 256); - fail_if(eina_rectangle_pool_request(pool, 32, 32) != NULL); - fail_if(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); + ck_assert(eina_rectangle_pool_request(pool, 32, 32) != NULL); + ck_assert(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); for (x = 0; x < 8; x++) eina_rectangle_pool_release(rects[0][x]); - fail_if(eina_rectangle_pool_request(pool, 16, 16) == NULL); + ck_assert(eina_rectangle_pool_request(pool, 16, 16) == NULL); eina_rectangle_pool_free(pool); @@ -82,31 +82,31 @@ EFL_START_TEST(eina_rectangle_pool_skyline) pool = eina_rectangle_pool_new(256, 256); - fail_if(pool == NULL); + ck_assert(pool == NULL); eina_rectangle_pool_packing_set(pool, Eina_Packing_Bottom_Left_Skyline_Improved); eina_rectangle_pool_data_set(pool, rects); - fail_if(eina_rectangle_pool_data_get(pool) != rects); + ck_assert(eina_rectangle_pool_data_get(pool) != rects); - fail_if(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); + ck_assert(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); for (x = 0; x < 8; x++) for (y = 0; y < 8; y++) { rects[x][y] = eina_rectangle_pool_request(pool, 32, 32); - fail_if(rects[x][y] == NULL); + ck_assert(rects[x][y] == NULL); } - fail_if(eina_rectangle_pool_count(pool) != 64); + ck_assert(eina_rectangle_pool_count(pool) != 64); - fail_if(eina_rectangle_pool_get(rects[0][0]) != pool); + ck_assert(eina_rectangle_pool_get(rects[0][0]) != pool); - fail_if(eina_rectangle_pool_geometry_get(pool, &w, &h) != EINA_TRUE); - fail_if(w != 256 || h != 256); + ck_assert(eina_rectangle_pool_geometry_get(pool, &w, &h) != EINA_TRUE); + ck_assert(w != 256 || h != 256); - fail_if(eina_rectangle_pool_request(pool, 32, 32) != NULL); - fail_if(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); + ck_assert(eina_rectangle_pool_request(pool, 32, 32) != NULL); + ck_assert(eina_rectangle_pool_request(pool, 1024, 1024) != NULL); for (x = 0; x < 8; x++) eina_rectangle_pool_release(rects[0][x]); @@ -133,56 +133,56 @@ EFL_START_TEST(eina_rectangle_union_intersect) rd = r1; - fail_if(eina_rectangle_intersection(&rd, &r3)); - fail_if(!eina_rectangle_intersection(&rd, &r2)); + ck_assert(eina_rectangle_intersection(&rd, &r3)); + ck_assert(!eina_rectangle_intersection(&rd, &r2)); - fail_if(rd.x != r2.x + ck_assert(rd.x != r2.x || rd.y != r2.y || rd.w != r2.w || rd.h != r2.h); rd = r1; - fail_if(!eina_rectangle_intersection(&rd, &r4)); + ck_assert(!eina_rectangle_intersection(&rd, &r4)); - fail_if(rd.x != 30 + ck_assert(rd.x != 30 || rd.y != 30 || rd.w != 30 || rd.h != 30); rd = r1; eina_rectangle_union(&rd, &r2); - fail_if(rd.x != r1.x + ck_assert(rd.x != r1.x || rd.y != r1.y || rd.w != r1.w || rd.h != r1.h); rd = r6; - fail_if(eina_rectangle_intersection(&rd, &r5)); + ck_assert(eina_rectangle_intersection(&rd, &r5)); rd = r7; - fail_if(eina_rectangle_intersection(&rd, &r3)); + ck_assert(eina_rectangle_intersection(&rd, &r3)); rd = r8; - fail_if(eina_rectangle_intersection(&rd, &r3)); + ck_assert(eina_rectangle_intersection(&rd, &r3)); rd = r1; eina_rectangle_union(&rd, &r3); - fail_if(rd.x != 0 + ck_assert(rd.x != 0 || rd.y != 0 || rd.w != 60 || rd.h != 60); rd = r3; eina_rectangle_union(&rd, &r4); - fail_if(rd.x != 0 + ck_assert(rd.x != 0 || rd.y != 0 || rd.w != 80 || rd.h != 80); rd = r5; eina_rectangle_union(&rd, &r6); - fail_if(rd.x != 10 + ck_assert(rd.x != 10 || rd.y != 10 || rd.w != 20 || rd.h != 20); diff --git a/src/tests/eina/eina_test_sched.c b/src/tests/eina/eina_test_sched.c index c054236e70..4ca34fdd56 100644 --- a/src/tests/eina/eina_test_sched.c +++ b/src/tests/eina/eina_test_sched.c @@ -61,7 +61,7 @@ EFL_START_TEST(eina_test_sched_prio_drop) r = eina_thread_create(&tid, EINA_THREAD_NORMAL, -1, _thread_run, NULL); - fail_unless(r); + ck_assert(r); niceval2 = getpriority(PRIO_PROCESS, 0); /* niceness of main thread should not have changed */ diff --git a/src/tests/eina/eina_test_simple_xml_parser.c b/src/tests/eina/eina_test_simple_xml_parser.c index 5f41d2b038..c95ce47a98 100644 --- a/src/tests/eina/eina_test_simple_xml_parser.c +++ b/src/tests/eina/eina_test_simple_xml_parser.c @@ -92,7 +92,7 @@ EFL_START_TEST(eina_simple_xml_parser_null_node_dump) { char *out = eina_simple_xml_node_dump(NULL, " "); - fail_if(out != NULL); + ck_assert(out != NULL); } EFL_END_TEST @@ -104,9 +104,9 @@ EFL_START_TEST(eina_simple_xml_parser_childs_count) "I'm a child."; const int sz = strlen(buf); Eina_Simple_XML_Node_Root *root = eina_simple_xml_node_load(buf, sz, EINA_TRUE); - fail_if(root == NULL); - fail_if(root->children == NULL); - fail_if(eina_inlist_count(root->children) != 2); + ck_assert(root == NULL); + ck_assert(root->children == NULL); + ck_assert(eina_inlist_count(root->children) != 2); eina_simple_xml_node_root_free(root); } @@ -142,73 +142,73 @@ eina_simple_xml_parser_parse_with_custom_callback_tag_cb(void *data, { if (!strncmp("gpx ", content, strlen("gpx "))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_begin); + ck_assert(*parse_current_state != simple_xml_parser_current_state_begin); *parse_current_state = simple_xml_parser_current_state_gpx; } else if (!strncmp("metadata>", content, strlen("metadata>"))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_gpx); + ck_assert(*parse_current_state != simple_xml_parser_current_state_gpx); *parse_current_state = simple_xml_parser_current_state_metadata; } else if (!strncmp("link ", content, strlen("link "))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_metadata); + ck_assert(*parse_current_state != simple_xml_parser_current_state_metadata); *parse_current_state = simple_xml_parser_current_state_link; } else if (!strncmp("text>", content, strlen("text>"))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_link); + ck_assert(*parse_current_state != simple_xml_parser_current_state_link); *parse_current_state = simple_xml_parser_current_state_text; } else if (!strncmp("time>", content, strlen("time>"))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_text); + ck_assert(*parse_current_state != simple_xml_parser_current_state_text); *parse_current_state = simple_xml_parser_current_state_time; } else if (!strncmp("trk>", content, strlen("trk>"))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_time); + ck_assert(*parse_current_state != simple_xml_parser_current_state_time); *parse_current_state = simple_xml_parser_current_state_trk; } else if (!strncmp("name>", content, strlen("name>"))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_trk); + ck_assert(*parse_current_state != simple_xml_parser_current_state_trk); *parse_current_state = simple_xml_parser_current_state_name; } else if (!strncmp("trkseg>", content, strlen("trkseg>"))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_name); + ck_assert(*parse_current_state != simple_xml_parser_current_state_name); *parse_current_state = simple_xml_parser_current_state_trkseg; } else { - fail_if(*parse_current_state != simple_xml_parser_current_state_trkpt); + ck_assert(*parse_current_state != simple_xml_parser_current_state_trkpt); } } else if (type == EINA_SIMPLE_XML_OPEN_EMPTY) { if (!strncmp("trkpt ", content, strlen("trkpt "))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_trkseg && + ck_assert(*parse_current_state != simple_xml_parser_current_state_trkseg && *parse_current_state != simple_xml_parser_current_state_trkpt); *parse_current_state = simple_xml_parser_current_state_trkpt; } } else if (type == EINA_SIMPLE_XML_COMMENT) { - fail_if(*parse_current_state != simple_xml_parser_current_state_trkpt); + ck_assert(*parse_current_state != simple_xml_parser_current_state_trkpt); *parse_current_state = simple_xml_parser_current_state_comment; } else if (type == EINA_SIMPLE_XML_CDATA) { - fail_if(*parse_current_state != simple_xml_parser_current_state_comment); + ck_assert(*parse_current_state != simple_xml_parser_current_state_comment); *parse_current_state = simple_xml_parser_current_state_cdata; } else if (type == EINA_SIMPLE_XML_CLOSE) { if (!strncmp("gpx", content, strlen("gpx"))) { - fail_if(*parse_current_state != simple_xml_parser_current_state_cdata); + ck_assert(*parse_current_state != simple_xml_parser_current_state_cdata); *parse_current_state = simple_xml_parser_current_state_end; } } @@ -245,7 +245,7 @@ EFL_START_TEST(eina_simple_xml_parser_parse_with_custom_callback) EINA_TRUE, eina_simple_xml_parser_parse_with_custom_callback_tag_cb, &parse_current_state); - fail_if(parse_current_state != simple_xml_parser_current_state_end); + ck_assert(parse_current_state != simple_xml_parser_current_state_end); } free(buf); } diff --git a/src/tests/eina/eina_test_slice.c b/src/tests/eina/eina_test_slice.c index 1c16054d06..9b83d9cfea 100644 --- a/src/tests/eina/eina_test_slice.c +++ b/src/tests/eina/eina_test_slice.c @@ -35,15 +35,15 @@ EFL_START_TEST(eina_test_slice_init) EINA_RW_SLICE_DECLARE(d, 512); - fail_unless(a.len == sizeof("hello world") - 1); - fail_unless(strcmp(a.mem, "hello world") == 0); + ck_assert(a.len == sizeof("hello world") - 1); + ck_assert(strcmp(a.mem, "hello world") == 0); - fail_unless(b.len == sizeof(buf)); + ck_assert(b.len == sizeof(buf)); - fail_unless(c.len == strlen("hi there")); - fail_unless(strcmp(c.mem, "hi there") == 0); + ck_assert(c.len == strlen("hi there")); + ck_assert(strcmp(c.mem, "hi there") == 0); - fail_unless(d.len == 512); + ck_assert(d.len == 512); } EFL_END_TEST @@ -58,77 +58,77 @@ EFL_START_TEST(eina_test_slice_ro) char *str; dup = eina_slice_dup(slice); - fail_unless(dup.len == slice.len); - fail_unless(dup.mem != slice.mem); - fail_unless(eina_slice_compare(eina_rw_slice_slice_get(dup), slice) == 0); + ck_assert(dup.len == slice.len); + ck_assert(dup.mem != slice.mem); + ck_assert(eina_slice_compare(eina_rw_slice_slice_get(dup), slice) == 0); free(dup.mem); str = eina_slice_strdup(slice); - fail_unless(str != NULL); - fail_unless(strcmp(str, "hi there") == 0); + ck_assert(str != NULL); + ck_assert(strcmp(str, "hi there") == 0); free(str); a = eina_slice_seek(slice, strlen("hi "), SEEK_SET); - fail_unless(a.mem == slice.bytes + strlen("hi ")); - fail_unless(a.len == slice.len - strlen("hi ")); + ck_assert(a.mem == slice.bytes + strlen("hi ")); + ck_assert(a.len == slice.len - strlen("hi ")); a = eina_slice_seek(slice, 0, SEEK_SET); - fail_unless(a.mem == slice.bytes + 0); - fail_unless(a.len == slice.len); + ck_assert(a.mem == slice.bytes + 0); + ck_assert(a.len == slice.len); a = eina_slice_seek(slice, -1, SEEK_END); - fail_unless(a.mem == slice.bytes + slice.len - 1); - fail_unless(a.len == 1); + ck_assert(a.mem == slice.bytes + slice.len - 1); + ck_assert(a.len == 1); a = eina_slice_seek(slice, 0, SEEK_END); - fail_unless(a.mem == eina_slice_end_get(slice)); - fail_unless(a.len == 0); + ck_assert(a.mem == eina_slice_end_get(slice)); + ck_assert(a.len == 0); p = eina_slice_end_get(slice); - fail_unless(p == slice.bytes + slice.len); + ck_assert(p == slice.bytes + slice.len); slice = (Eina_Slice)EINA_SLICE_STR_LITERAL("HELLO WORLD"); slice.len = strlen("hi there"); /* crop... */ p = eina_slice_strchr(slice, ' '); - fail_unless(p == slice.bytes + 5); /* 5 = index of ' ' in HELLO WORLD.. */ + ck_assert(p == slice.bytes + 5); /* 5 = index of ' ' in HELLO WORLD.. */ p = eina_slice_strchr(slice, '!'); - fail_unless(p == NULL); + ck_assert(p == NULL); needle = (Eina_Slice)EINA_SLICE_STR_LITERAL(" W"); p = eina_slice_find(slice, needle); - fail_unless(p == slice.bytes + 5); /* 5 = index of ' W' in HELLO WORLD..*/ + ck_assert(p == slice.bytes + 5); /* 5 = index of ' W' in HELLO WORLD..*/ needle = (Eina_Slice)EINA_SLICE_STR_LITERAL("LO"); p = eina_slice_find(slice, needle); - fail_unless(p == slice.bytes + 3); /* 3 = index of 'LO' in HELLO WORLD..*/ + ck_assert(p == slice.bytes + 3); /* 3 = index of 'LO' in HELLO WORLD..*/ needle = (Eina_Slice)EINA_SLICE_STR_LITERAL("HELLO"); p = eina_slice_find(slice, needle); - fail_unless(p == slice.mem); + ck_assert(p == slice.mem); needle = (Eina_Slice)EINA_SLICE_STR_LITERAL("WORLD"); /* would go out of boundaries */ p = eina_slice_find(slice, needle); - fail_unless(p == NULL); + ck_assert(p == NULL); r = eina_slice_startswith(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("HEL")); - fail_unless(r == EINA_TRUE); + ck_assert(r == EINA_TRUE); r = eina_slice_startswith(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("WORLD")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_slice_startswith(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_slice_endswith(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("WO")); - fail_unless(r == EINA_TRUE); + ck_assert(r == EINA_TRUE); r = eina_slice_endswith(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("WORLD")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_slice_endswith(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); } EFL_END_TEST @@ -146,87 +146,87 @@ EFL_START_TEST(eina_test_slice_rw) rw_slice.len--; /* do not account \0 (now 0xff) */ ro_slice = eina_rw_slice_slice_get(rw_slice); - fail_unless(rw_slice.len == ro_slice.len); - fail_unless(rw_slice.mem == ro_slice.mem); + ck_assert(rw_slice.len == ro_slice.len); + ck_assert(rw_slice.mem == ro_slice.mem); a = eina_slice_dup(ro_slice); - fail_unless(a.len == ro_slice.len); - fail_unless(a.mem != ro_slice.mem); - fail_unless(eina_rw_slice_compare(a, rw_slice) == 0); + ck_assert(a.len == ro_slice.len); + ck_assert(a.mem != ro_slice.mem); + ck_assert(eina_rw_slice_compare(a, rw_slice) == 0); free(a.mem); str = eina_rw_slice_strdup(rw_slice); - fail_unless(str != NULL); - fail_unless(strcmp(str, "hi there") == 0); + ck_assert(str != NULL); + ck_assert(strcmp(str, "hi there") == 0); free(str); a = eina_rw_slice_seek(rw_slice, strlen("hi "), SEEK_SET); - fail_unless(a.mem == rw_slice.bytes + strlen("hi ")); - fail_unless(a.len == rw_slice.len - strlen("hi ")); + ck_assert(a.mem == rw_slice.bytes + strlen("hi ")); + ck_assert(a.len == rw_slice.len - strlen("hi ")); a = eina_rw_slice_seek(rw_slice, 0, SEEK_SET); - fail_unless(a.mem == rw_slice.bytes + 0); - fail_unless(a.len == rw_slice.len); + ck_assert(a.mem == rw_slice.bytes + 0); + ck_assert(a.len == rw_slice.len); a = eina_rw_slice_seek(rw_slice, -1, SEEK_END); - fail_unless(a.mem == rw_slice.bytes + rw_slice.len - 1); - fail_unless(a.len == 1); + ck_assert(a.mem == rw_slice.bytes + rw_slice.len - 1); + ck_assert(a.len == 1); a = eina_rw_slice_seek(rw_slice, 0, SEEK_END); - fail_unless(a.mem == eina_rw_slice_end_get(rw_slice)); - fail_unless(a.len == 0); + ck_assert(a.mem == eina_rw_slice_end_get(rw_slice)); + ck_assert(a.len == 0); p = eina_rw_slice_end_get(rw_slice); - fail_unless(p == rw_slice.bytes + rw_slice.len); + ck_assert(p == rw_slice.bytes + rw_slice.len); ro_slice = (Eina_Slice)EINA_SLICE_STR_LITERAL("HELLO WORLD, big string to be cropped"); a = eina_rw_slice_copy(rw_slice, ro_slice); - fail_unless(a.mem == rw_slice.mem); - fail_unless(a.len == rw_slice.len); - fail_unless(strncmp(a.mem, "HELLO WO", a.len) == 0); + ck_assert(a.mem == rw_slice.mem); + ck_assert(a.len == rw_slice.len); + ck_assert(strncmp(a.mem, "HELLO WO", a.len) == 0); p = eina_rw_slice_strchr(rw_slice, ' '); - fail_unless(p == rw_slice.bytes + 5); /* 5 = index of ' ' in HELLO WORLD.. */ + ck_assert(p == rw_slice.bytes + 5); /* 5 = index of ' ' in HELLO WORLD.. */ p = eina_rw_slice_strchr(rw_slice, '!'); - fail_unless(p == NULL); + ck_assert(p == NULL); ro_slice = (Eina_Slice)EINA_SLICE_STR_LITERAL(" W"); p = eina_rw_slice_find(rw_slice, ro_slice); - fail_unless(p == rw_slice.bytes + 5); /* 5 = index of ' W' in HELLO WORLD..*/ + ck_assert(p == rw_slice.bytes + 5); /* 5 = index of ' W' in HELLO WORLD..*/ ro_slice = (Eina_Slice)EINA_SLICE_STR_LITERAL("LO"); p = eina_rw_slice_find(rw_slice, ro_slice); - fail_unless(p == rw_slice.bytes + 3); /* 3 = index of 'LO' in HELLO WORLD..*/ + ck_assert(p == rw_slice.bytes + 3); /* 3 = index of 'LO' in HELLO WORLD..*/ ro_slice = (Eina_Slice)EINA_SLICE_STR_LITERAL("HELLO"); p = eina_rw_slice_find(rw_slice, ro_slice); - fail_unless(p == rw_slice.mem); + ck_assert(p == rw_slice.mem); ro_slice = (Eina_Slice)EINA_SLICE_STR_LITERAL("WORLD"); /* would go out of boundaries */ p = eina_rw_slice_find(rw_slice, ro_slice); - fail_unless(p == NULL); + ck_assert(p == NULL); - fail_unless(buf[sizeof(buf) - 1] == 0xff); + ck_assert(buf[sizeof(buf) - 1] == 0xff); r = eina_rw_slice_startswith(rw_slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("HEL")); - fail_unless(r == EINA_TRUE); + ck_assert(r == EINA_TRUE); r = eina_rw_slice_startswith(rw_slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("WORLD")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_rw_slice_startswith(rw_slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_rw_slice_endswith(rw_slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("WO")); - fail_unless(r == EINA_TRUE); + ck_assert(r == EINA_TRUE); r = eina_rw_slice_endswith(rw_slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("WORLD")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); r = eina_rw_slice_endswith(rw_slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("")); - fail_unless(r == EINA_FALSE); + ck_assert(r == EINA_FALSE); } EFL_END_TEST @@ -238,10 +238,10 @@ EFL_START_TEST(eina_test_slice_print) snprintf(a, sizeof(a), EINA_SLICE_FMT, EINA_SLICE_PRINT(slice)); snprintf(b, sizeof(b), "%p+%zu", slice.mem, slice.len); - fail_unless(strcmp(a, b) == 0); + ck_assert(strcmp(a, b) == 0); snprintf(a, sizeof(a), EINA_SLICE_STR_FMT, EINA_SLICE_STR_PRINT(slice)); - fail_unless(strcmp(a, "Hello") == 0); + ck_assert(strcmp(a, "Hello") == 0); } EFL_END_TEST @@ -251,50 +251,50 @@ EFL_START_TEST(eina_test_slice_find) const char *p; p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("a")); - fail_if(p == NULL); + ck_assert(p == NULL); ck_assert_str_eq(p, (const char *)slice.bytes); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("ab")); - fail_if(p == NULL); + ck_assert(p == NULL); ck_assert_str_eq(p, (const char *)slice.bytes); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("abc")); - fail_if(p == NULL); + ck_assert(p == NULL); ck_assert_str_eq(p, (const char *)slice.bytes); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("f")); - fail_if(p == NULL); + ck_assert(p == NULL); ck_assert_str_eq(p, (const char *)slice.bytes + strlen("abcde")); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("ef")); - fail_if(p == NULL); + ck_assert(p == NULL); ck_assert_str_eq(p, (const char *)slice.bytes + strlen("abcd")); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("def")); - fail_if(p == NULL); + ck_assert(p == NULL); ck_assert_str_eq(p, (const char *)slice.bytes + strlen("abc")); p = eina_slice_find(slice, slice); - fail_if(p == NULL); + ck_assert(p == NULL); ck_assert_str_eq(p, (const char *)slice.bytes); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("x")); - fail_unless(p == NULL); + ck_assert(p == NULL); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("xyz")); - fail_unless(p == NULL); + ck_assert(p == NULL); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("xa")); - fail_unless(p == NULL); + ck_assert(p == NULL); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("xb")); - fail_unless(p == NULL); + ck_assert(p == NULL); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("abcdefgh")); - fail_unless(p == NULL); + ck_assert(p == NULL); p = eina_slice_find(slice, (Eina_Slice)EINA_SLICE_STR_LITERAL("")); - fail_unless(p == NULL); + ck_assert(p == NULL); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_slstr.c b/src/tests/eina/eina_test_slstr.c index 170fc28210..21dfb8aaed 100644 --- a/src/tests/eina/eina_test_slstr.c +++ b/src/tests/eina/eina_test_slstr.c @@ -61,7 +61,7 @@ EFL_START_TEST(slstr_stringshare) str = _slstr_stringshare(); ss = eina_stringshare_add("Hello world 3"); - fail_if(ss != str); + ck_assert(ss != str); } EFL_END_TEST @@ -168,7 +168,7 @@ EFL_START_TEST(slstr_thread) for (k = 0; k < threads; k++) - fail_if(!eina_thread_create(&th[k], EINA_THREAD_NORMAL, -1, _thread_cb, NULL)); + ck_assert(!eina_thread_create(&th[k], EINA_THREAD_NORMAL, -1, _thread_cb, NULL)); for (k = 0; k < threads; k++) eina_thread_join(th[k]); diff --git a/src/tests/eina/eina_test_str.c b/src/tests/eina/eina_test_str.c index d461448c9c..890ea06c24 100644 --- a/src/tests/eina/eina_test_str.c +++ b/src/tests/eina/eina_test_str.c @@ -33,84 +33,84 @@ EFL_START_TEST(str_simple) const char *escape_ret = "\\ a\\\\x\\'"; - fail_if(!eina_str_has_prefix("", "")); + ck_assert(!eina_str_has_prefix("", "")); - fail_if(!eina_str_has_prefix("x", "x")); - fail_if(!eina_str_has_prefix("xab", "x")); - fail_if(!eina_str_has_prefix("xab", "xab")); + ck_assert(!eina_str_has_prefix("x", "x")); + ck_assert(!eina_str_has_prefix("xab", "x")); + ck_assert(!eina_str_has_prefix("xab", "xab")); - fail_if(eina_str_has_prefix("x", "xab")); - fail_if(eina_str_has_prefix("xab", "xyz")); - fail_if(eina_str_has_prefix("", "x")); - fail_if(eina_str_has_prefix("X", "x")); - fail_if(eina_str_has_prefix("xAb", "X")); - fail_if(eina_str_has_prefix("xAb", "xab")); + ck_assert(eina_str_has_prefix("x", "xab")); + ck_assert(eina_str_has_prefix("xab", "xyz")); + ck_assert(eina_str_has_prefix("", "x")); + ck_assert(eina_str_has_prefix("X", "x")); + ck_assert(eina_str_has_prefix("xAb", "X")); + ck_assert(eina_str_has_prefix("xAb", "xab")); - fail_if(!eina_str_has_suffix("", "")); + ck_assert(!eina_str_has_suffix("", "")); - fail_if(!eina_str_has_suffix("x", "x")); - fail_if(!eina_str_has_suffix("abx", "x")); - fail_if(!eina_str_has_suffix("xab", "xab")); + ck_assert(!eina_str_has_suffix("x", "x")); + ck_assert(!eina_str_has_suffix("abx", "x")); + ck_assert(!eina_str_has_suffix("xab", "xab")); - fail_if(eina_str_has_suffix("x", "xab")); - fail_if(eina_str_has_suffix("xab", "xyz")); - fail_if(eina_str_has_suffix("", "x")); - fail_if(eina_str_has_suffix("X", "x")); - fail_if(eina_str_has_suffix("aBx", "X")); - fail_if(eina_str_has_suffix("xaB", "Xab")); + ck_assert(eina_str_has_suffix("x", "xab")); + ck_assert(eina_str_has_suffix("xab", "xyz")); + ck_assert(eina_str_has_suffix("", "x")); + ck_assert(eina_str_has_suffix("X", "x")); + ck_assert(eina_str_has_suffix("aBx", "X")); + ck_assert(eina_str_has_suffix("xaB", "Xab")); - fail_if(!eina_str_has_extension("", "")); + ck_assert(!eina_str_has_extension("", "")); - fail_if(!eina_str_has_extension("x", "x")); - fail_if(!eina_str_has_extension("abx", "x")); - fail_if(!eina_str_has_extension("xab", "xab")); - fail_if(!eina_str_has_extension("x", "X")); - fail_if(!eina_str_has_extension("abx", "X")); - fail_if(!eina_str_has_extension("xab", "Xab")); - fail_if(!eina_str_has_extension("X", "X")); - fail_if(!eina_str_has_extension("aBx", "X")); - fail_if(!eina_str_has_extension("xaB", "Xab")); + ck_assert(!eina_str_has_extension("x", "x")); + ck_assert(!eina_str_has_extension("abx", "x")); + ck_assert(!eina_str_has_extension("xab", "xab")); + ck_assert(!eina_str_has_extension("x", "X")); + ck_assert(!eina_str_has_extension("abx", "X")); + ck_assert(!eina_str_has_extension("xab", "Xab")); + ck_assert(!eina_str_has_extension("X", "X")); + ck_assert(!eina_str_has_extension("aBx", "X")); + ck_assert(!eina_str_has_extension("xaB", "Xab")); - fail_if(eina_str_has_extension("x", "xab")); - fail_if(eina_str_has_extension("xab", "xyz")); - fail_if(eina_str_has_extension("", "x")); - fail_if(eina_str_has_extension("x", "xAb")); - fail_if(eina_str_has_extension("xab", "xYz")); - fail_if(eina_str_has_extension("", "x")); + ck_assert(eina_str_has_extension("x", "xab")); + ck_assert(eina_str_has_extension("xab", "xyz")); + ck_assert(eina_str_has_extension("", "x")); + ck_assert(eina_str_has_extension("x", "xAb")); + ck_assert(eina_str_has_extension("xab", "xYz")); + ck_assert(eina_str_has_extension("", "x")); - fail_if(eina_streq("xab", NULL)); - fail_if(eina_streq(NULL, "xab")); - fail_if(eina_streq("x", "xab")); - fail_if(eina_streq("xab", "XAB")); - fail_if(eina_streq("x", "x ")); - fail_if(!eina_streq("xab", "xab")); + ck_assert(eina_streq("xab", NULL)); + ck_assert(eina_streq(NULL, "xab")); + ck_assert(eina_streq("x", "xab")); + ck_assert(eina_streq("xab", "XAB")); + ck_assert(eina_streq("x", "x ")); + ck_assert(!eina_streq("xab", "xab")); - fail_if(eina_strlen_bounded("abc", 4) != strlen("abc")); - fail_if(eina_strlen_bounded("abc", 2) != (size_t)-1); + ck_assert(eina_strlen_bounded("abc", 4) != strlen("abc")); + ck_assert(eina_strlen_bounded("abc", 2) != (size_t)-1); str = malloc(sizeof(char) * 4); strcpy(str, "bSd"); eina_str_tolower(&str); - fail_if(strcmp(str, "bsd") != 0); + ck_assert(strcmp(str, "bsd") != 0); eina_str_toupper(&str); - fail_if(strcmp(str, "BSD") != 0); + ck_assert(strcmp(str, "BSD") != 0); free(str); str = malloc(sizeof(char) * 8); strcpy(str, " a\\x'"); ret = eina_str_escape(str); - fail_if(strlen(ret) != strlen(escape_ret)); + ck_assert(strlen(ret) != strlen(escape_ret)); for (i = 0; i <= strlen(ret); i++) - fail_if(ret[i] != escape_ret[i]); + ck_assert(ret[i] != escape_ret[i]); free(str); free(ret); str = malloc(sizeof(char) * 4); strcpy(str, "a\t "); ret = eina_str_escape(str); - fail_if(!eina_streq(ret, "a\\t\\ ")); + ck_assert(!eina_streq(ret, "a\\t\\ ")); free(str); free(ret); @@ -125,55 +125,55 @@ EFL_START_TEST(str_split) result = eina_str_split_full(NULL, ":", 1, &elements); - fail_if(result != NULL); - fail_if(elements != 0); + ck_assert(result != NULL); + ck_assert(elements != 0); result = eina_str_split_full("nomatch", NULL, 1, &elements); - fail_if(result != NULL); - fail_if(elements != 0); + ck_assert(result != NULL); + ck_assert(elements != 0); result = eina_str_split_full("match:match", ":", 1, &elements); - fail_if(result == NULL); - fail_if(elements != 1); - fail_if(strcmp(result[0], "match:match") != 0); + ck_assert(result == NULL); + ck_assert(elements != 1); + ck_assert(strcmp(result[0], "match:match") != 0); free(result[0]); free(result); result = eina_str_split_full("match:match:nomatch:nomatch", ":", 3, &elements); - fail_if(result == NULL); - fail_if(elements != 3); - fail_if(strcmp(result[0], "match") != 0); - fail_if(strcmp(result[1], "match") != 0); - fail_if(strcmp(result[2], "nomatch:nomatch") != 0); + ck_assert(result == NULL); + ck_assert(elements != 3); + ck_assert(strcmp(result[0], "match") != 0); + ck_assert(strcmp(result[1], "match") != 0); + ck_assert(strcmp(result[2], "nomatch:nomatch") != 0); free(result[0]); free(result); result = eina_str_split_full("nomatch", "", -1, &elements); - fail_if(result != NULL); - fail_if(elements != 0); + ck_assert(result != NULL); + ck_assert(elements != 0); result = eina_str_split_full("nomatch", "x", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 1); - fail_if(strcmp(result[0], "nomatch") != 0); - fail_if(result[1]); + ck_assert(result == NULL); + ck_assert(elements != 1); + ck_assert(strcmp(result[0], "nomatch") != 0); + ck_assert(result[1]); free(result[0]); free(result); result = eina_str_split_full("nomatch", "xyz", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 1); - fail_if(strcmp(result[0], "nomatch") != 0); - fail_if(result[1]); + ck_assert(result == NULL); + ck_assert(elements != 1); + ck_assert(strcmp(result[0], "nomatch") != 0); + ck_assert(result[1]); free(result[0]); free(result); result = eina_str_split_full("match:match:match", ":", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 3); + ck_assert(result == NULL); + ck_assert(elements != 3); for (elements = 0; elements < 3 - 1; elements++) - fail_if(strcmp(result[elements], "match") != 0); - fail_if(result[3]); + ck_assert(strcmp(result[elements], "match") != 0); + ck_assert(result[3]); free(result[0]); free(result); @@ -183,65 +183,65 @@ EFL_START_TEST(str_split) strcat(str, "ma:"); strcat(str, "ma"); result = eina_str_split_full(str, ":", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 301); + ck_assert(result == NULL); + ck_assert(elements != 301); free(result[0]); free(result); free(str); result = eina_str_split_full("a:b:c", ":", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 3); - fail_if(strcmp(result[0], "a") != 0); - fail_if(strcmp(result[1], "b") != 0); - fail_if(strcmp(result[2], "c") != 0); - fail_if(result[3]); + ck_assert(result == NULL); + ck_assert(elements != 3); + ck_assert(strcmp(result[0], "a") != 0); + ck_assert(strcmp(result[1], "b") != 0); + ck_assert(strcmp(result[2], "c") != 0); + ck_assert(result[3]); free(result[0]); free(result); result = eina_str_split_full("a:b:", ":", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 3); - fail_if(strcmp(result[0], "a") != 0); - fail_if(strcmp(result[1], "b") != 0); - fail_if(strcmp(result[2], "") != 0); - fail_if(result[3]); + ck_assert(result == NULL); + ck_assert(elements != 3); + ck_assert(strcmp(result[0], "a") != 0); + ck_assert(strcmp(result[1], "b") != 0); + ck_assert(strcmp(result[2], "") != 0); + ck_assert(result[3]); free(result[0]); free(result); result = eina_str_split_full(":b:c", ":", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 3); - fail_if(strcmp(result[0], "") != 0); - fail_if(strcmp(result[1], "b") != 0); - fail_if(strcmp(result[2], "c") != 0); - fail_if(result[3]); + ck_assert(result == NULL); + ck_assert(elements != 3); + ck_assert(strcmp(result[0], "") != 0); + ck_assert(strcmp(result[1], "b") != 0); + ck_assert(strcmp(result[2], "c") != 0); + ck_assert(result[3]); free(result[0]); free(result); result = eina_str_split_full(":", ":", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 2); - fail_if(strcmp(result[0], "") != 0); - fail_if(strcmp(result[1], "") != 0); - fail_if(result[2]); + ck_assert(result == NULL); + ck_assert(elements != 2); + ck_assert(strcmp(result[0], "") != 0); + ck_assert(strcmp(result[1], "") != 0); + ck_assert(result[2]); free(result[0]); free(result); result = eina_str_split_full("a", "!!!!!!!!!", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 1); - fail_if(strcmp(result[0], "a") != 0); - fail_if(result[1]); + ck_assert(result == NULL); + ck_assert(elements != 1); + ck_assert(strcmp(result[0], "a") != 0); + ck_assert(result[1]); free(result[0]); free(result); result = eina_str_split_full("aaba", "ab", -1, &elements); - fail_if(result == NULL); - fail_if(elements != 2); - fail_if(strcmp(result[0], "a") != 0); - fail_if(strcmp(result[1], "a") != 0); - fail_if(result[2]); + ck_assert(result == NULL); + ck_assert(elements != 2); + ck_assert(strcmp(result[0], "a") != 0); + ck_assert(strcmp(result[1], "a") != 0); + ck_assert(result[2]); free(result[0]); free(result); @@ -258,32 +258,32 @@ EFL_START_TEST(str_lcat_lcpy) dst[0] = '\0'; ret = eina_strlcat(dst, "cat1", ds); - fail_if(ret != 4); - fail_if(strcmp(dst, "cat1") != 0); + ck_assert(ret != 4); + ck_assert(strcmp(dst, "cat1") != 0); ret = eina_strlcat(dst, NULL, ds); - fail_if(ret != 4); - fail_if(strcmp(dst, "cat1") != 0); + ck_assert(ret != 4); + ck_assert(strcmp(dst, "cat1") != 0); ret = eina_strlcat(dst, "cat234", ds); - fail_if(ret != (ds - 1 + 2)); - fail_if(strcmp(dst, "cat1cat2") != 0); + ck_assert(ret != (ds - 1 + 2)); + ck_assert(strcmp(dst, "cat1cat2") != 0); ret = eina_strlcat(dst, "cat3", ds); - fail_if(ret != (ds - 1 + 4)); - fail_if(strcmp(dst, "cat1cat2") != 0); + ck_assert(ret != (ds - 1 + 4)); + ck_assert(strcmp(dst, "cat1cat2") != 0); ret = eina_strlcat(dst, "cat3", ds - 1); - fail_if(ret != (ds - 1 + 4)); - fail_if(strcmp(dst, "cat1cat2") != 0); + ck_assert(ret != (ds - 1 + 4)); + ck_assert(strcmp(dst, "cat1cat2") != 0); ret = eina_strlcpy(dst, "copycopy", ds); - fail_if(ret != 8); - fail_if(strcmp(dst, "copycopy") != 0); + ck_assert(ret != 8); + ck_assert(strcmp(dst, "copycopy") != 0); ret = eina_strlcpy(dst, "copy2copy2", ds); - fail_if(ret != 10); - fail_if(strcmp(dst, "copy2cop") != 0); + ck_assert(ret != 10); + ck_assert(strcmp(dst, "copy2cop") != 0); } EFL_END_TEST @@ -298,20 +298,20 @@ EFL_START_TEST(str_join_len) dst[0] = '\0'; ret = eina_str_join_len(dst, ds, '#', "ab", 2, "cde", 3); - fail_if(ret != 6); - fail_if(strcmp(dst, "ab#cde") != 0); + ck_assert(ret != 6); + ck_assert(strcmp(dst, "ab#cde") != 0); ret = eina_str_join_len(dst, ds, '#', "abcdefghi", 9, "cde", 3); - fail_if(ret != 13); - fail_if(strcmp(dst, "abcdefgh") != 0); + ck_assert(ret != 13); + ck_assert(strcmp(dst, "abcdefgh") != 0); ret = eina_str_join_len(dst, ds, '#', "abcdefgh", 8, "cde", 3); - fail_if(ret != 12); - fail_if(strcmp(dst, "abcdefgh") != 0); + ck_assert(ret != 12); + ck_assert(strcmp(dst, "abcdefgh") != 0); ret = eina_str_join_len(dst, ds, '#', "abcd", 4, "efgh", 4); - fail_if(ret != 9); - fail_if(strcmp(dst, "abcd#efg") != 0); + ck_assert(ret != 9); + ck_assert(strcmp(dst, "abcd#efg") != 0); } EFL_END_TEST @@ -332,14 +332,14 @@ EFL_START_TEST(str_memdup) t1.d = 123.456; t2 = (struct temp *)eina_memdup((unsigned char *)&t1, sizeof(struct temp), EINA_TRUE); - fail_if(t2->i != t1.i); - fail_if(strcmp(t2->s,t1.s) != 0); - fail_if(!EINA_FLT_EQ(t2->d, t1.d)); + ck_assert(t2->i != t1.i); + ck_assert(strcmp(t2->s,t1.s) != 0); + ck_assert(!EINA_FLT_EQ(t2->d, t1.d)); free(t2); memcpy(buf, "aaabbb", 6); temp_buf = eina_memdup(buf, 6, EINA_TRUE); - fail_if(strcmp((char *) temp_buf, "aaabbb") != 0); + ck_assert(strcmp((char *) temp_buf, "aaabbb") != 0); free(temp_buf); } @@ -355,7 +355,7 @@ EFL_START_TEST(str_strftime) info = localtime(&curr_time); buf = eina_strftime("%I:%M%p", info); - fail_if(buf == NULL); + ck_assert(buf == NULL); free(buf); } @@ -372,17 +372,17 @@ EFL_START_TEST(str_convert) ret = eina_str_convert("UTF-8", "UTF-16LE", utf8); - fail_if(ret == NULL); + ck_assert(ret == NULL); for( i=0; i<24; i++) - fail_if(ret[i] != utf16[i]); + ck_assert(ret[i] != utf16[i]); free(ret); ret = eina_str_convert_len("UTF-8", "UTF-16LE", utf8, 24, &ret_sz); - fail_if(ret == NULL); - fail_if(ret_sz != 24); + ck_assert(ret == NULL); + ck_assert(ret_sz != 24); for( i=0; i<24; i++) - fail_if(ret[i] != utf16[i]); + ck_assert(ret[i] != utf16[i]); free(ret); } diff --git a/src/tests/eina/eina_test_strbuf.c b/src/tests/eina/eina_test_strbuf.c index ac99992a31..9ba2a09667 100644 --- a/src/tests/eina/eina_test_strbuf.c +++ b/src/tests/eina/eina_test_strbuf.c @@ -36,39 +36,39 @@ EFL_START_TEST(eina_test_strbuf_simple) "This test should be so long that it is longer than the initial size of strbuf" buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_strbuf_append(buf, TEST_TEXT); - fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); eina_strbuf_append(buf, TEST_TEXT); - fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); txt = eina_strbuf_string_steal(buf); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(txt, TEST_TEXT TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(txt, TEST_TEXT TEST_TEXT)); free(txt); - fail_if(eina_strbuf_length_get(buf) != 0); - fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); + ck_assert(eina_strbuf_length_get(buf) != 0); + ck_assert(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); eina_strbuf_append(buf, TEST_TEXT); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); eina_strbuf_reset(buf); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(eina_strbuf_length_get(buf) != 0); - fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(eina_strbuf_length_get(buf) != 0); + ck_assert(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); ro_slice = eina_strbuf_slice_get(buf); - fail_if(ro_slice.len != eina_strbuf_length_get(buf)); - fail_if(ro_slice.mem != eina_strbuf_string_get(buf)); + ck_assert(ro_slice.len != eina_strbuf_length_get(buf)); + ck_assert(ro_slice.mem != eina_strbuf_string_get(buf)); rw_slice = eina_strbuf_rw_slice_get(buf); - fail_if(rw_slice.len != eina_strbuf_length_get(buf)); - fail_if(rw_slice.mem != eina_strbuf_string_get(buf)); + ck_assert(rw_slice.len != eina_strbuf_length_get(buf)); + ck_assert(rw_slice.mem != eina_strbuf_string_get(buf)); eina_strbuf_string_free(buf); - fail_if(eina_strbuf_length_get(buf)); + ck_assert(eina_strbuf_length_get(buf)); eina_strbuf_append(buf, TEST_TEXT); - fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); + ck_assert(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); eina_strbuf_free(buf); @@ -86,39 +86,39 @@ EFL_START_TEST(eina_test_strbuf_manage_simple) txt = strdup(TEST_TEXT); buf = eina_strbuf_manage_new(txt); - fail_if(!buf); + ck_assert(!buf); - fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); eina_strbuf_append(buf, TEST_TEXT); - fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); txt = eina_strbuf_string_steal(buf); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(txt, TEST_TEXT TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(txt, TEST_TEXT TEST_TEXT)); free(txt); - fail_if(eina_strbuf_length_get(buf) != 0); - fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); + ck_assert(eina_strbuf_length_get(buf) != 0); + ck_assert(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); eina_strbuf_append(buf, TEST_TEXT); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); eina_strbuf_reset(buf); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(eina_strbuf_length_get(buf) != 0); - fail_if(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(eina_strbuf_length_get(buf) != 0); + ck_assert(!strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); eina_strbuf_free(buf); buf = eina_strbuf_manage_read_only_new_length(TEST_TEXT, strlen(TEST_TEXT)); - fail_if(!buf); + ck_assert(!buf); - fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); eina_strbuf_append(buf, TEST_TEXT); - fail_if(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), TEST_TEXT TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); txt = eina_strbuf_string_steal(buf); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(txt, TEST_TEXT TEST_TEXT)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(txt, TEST_TEXT TEST_TEXT)); free(txt); #undef TEST_TEXT @@ -130,35 +130,35 @@ EFL_START_TEST(eina_test_strbuf_remove) Eina_Strbuf *buf; buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_strbuf_append(buf, "123 456 789 abc"); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); eina_strbuf_remove(buf, 0, 4); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "456 789 abc")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "456 789 abc")); eina_strbuf_remove(buf, 8, 1000); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "456 789 ")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "456 789 ")); eina_strbuf_remove(buf, 7, eina_strbuf_length_get(buf)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "456 789")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "456 789")); eina_strbuf_remove(buf, 2, 4); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "45789")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "45789")); eina_strbuf_remove(buf, 4, 1); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "45789")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "45789")); eina_strbuf_remove(buf, 0, eina_strbuf_length_get(buf)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "")); #define TEST_TEXT \ "This test should be so long that it is longer than the initial size of strbuf" eina_strbuf_append(buf, TEST_TEXT TEST_TEXT); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); eina_strbuf_remove(buf, 0, eina_strbuf_length_get(buf) - 1); - fail_if(strcmp(eina_strbuf_string_get(buf), "f")); + ck_assert(strcmp(eina_strbuf_string_get(buf), "f")); #undef TEST_TEXT eina_strbuf_free(buf); @@ -173,41 +173,41 @@ EFL_START_TEST(eina_test_strbuf_append) ro_slice.len -= strlen("ELSE"); buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_strbuf_append(buf, "abc"); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "abc")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "abc")); eina_strbuf_reset(buf); eina_strbuf_append_escaped(buf, "abc"); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "abc")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "abc")); eina_strbuf_reset(buf); eina_strbuf_append_escaped(buf, "abc '\\"); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "abc\\ \\'\\\\")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "abc\\ \\'\\\\")); eina_strbuf_reset(buf); eina_strbuf_append_n(buf, "abc", 2); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "ab")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "ab")); eina_strbuf_reset(buf); eina_strbuf_append_char(buf, 'a'); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "a")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "a")); eina_strbuf_reset(buf); eina_strbuf_append_length(buf, "something", strlen("something")); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "something")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "something")); eina_strbuf_reset(buf); eina_strbuf_append_slice(buf, ro_slice); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "something")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "something")); eina_strbuf_reset(buf); eina_strbuf_free(buf); @@ -222,40 +222,40 @@ EFL_START_TEST(eina_test_strbuf_insert) ro_slice.len = 2; buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_strbuf_insert(buf, "abc", 10); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "abc")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "abc")); eina_strbuf_insert(buf, "123", 0); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "123abc")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "123abc")); eina_strbuf_insert(buf, "xyz", eina_strbuf_length_get(buf)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "123abcxyz")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "123abcxyz")); eina_strbuf_insert(buf, "xyz", 1); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "1xyz23abcxyz")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "1xyz23abcxyz")); eina_strbuf_insert_n(buf, "ABCDEF", 2, 1); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "1ABxyz23abcxyz")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "1ABxyz23abcxyz")); eina_strbuf_insert_slice(buf, ro_slice, 3); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "1ABEIxyz23abcxyz")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "1ABEIxyz23abcxyz")); eina_strbuf_insert_escaped(buf, "678", 3); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strncmp(eina_strbuf_string_get(buf) + 3, "678", 3)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strncmp(eina_strbuf_string_get(buf) + 3, "678", 3)); eina_strbuf_insert_escaped(buf, "089 '\\", 9); - fail_if(strlen(eina_strbuf_string_get( + ck_assert(strlen(eina_strbuf_string_get( buf)) != eina_strbuf_length_get(buf)); - fail_if(strncmp(eina_strbuf_string_get(buf) + 9, + ck_assert(strncmp(eina_strbuf_string_get(buf) + 9, "089\\ \\'\\\\", strlen("089\\ \\'\\\\"))); eina_strbuf_reset(buf); @@ -269,53 +269,53 @@ EFL_START_TEST(eina_test_strbuf_replace) Eina_Strbuf *buf; buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); eina_strbuf_append(buf, "aaa"); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "aaa")); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "aaa")); - fail_if(!eina_strbuf_replace(buf, "a", "b", 1)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "baa")); + ck_assert(!eina_strbuf_replace(buf, "a", "b", 1)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "baa")); - fail_if(eina_strbuf_replace_all(buf, "a", "b") != 2); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "bbb")); + ck_assert(eina_strbuf_replace_all(buf, "a", "b") != 2); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "bbb")); - fail_if(!eina_strbuf_replace(buf, "b", "cc", 2)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "bccb")); + ck_assert(!eina_strbuf_replace(buf, "b", "cc", 2)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "bccb")); - fail_if(eina_strbuf_replace_all(buf, "c", "aa") != 2); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab")); + ck_assert(eina_strbuf_replace_all(buf, "c", "aa") != 2); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "baaaab")); - fail_if(eina_strbuf_replace(buf, "c", "aa", 0)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab")); + ck_assert(eina_strbuf_replace(buf, "c", "aa", 0)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "baaaab")); - fail_if(eina_strbuf_replace(buf, "c", "aa", 2)); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab")); + ck_assert(eina_strbuf_replace(buf, "c", "aa", 2)); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "baaaab")); - fail_if(eina_strbuf_replace_all(buf, "c", "aa") != 0); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "baaaab")); + ck_assert(eina_strbuf_replace_all(buf, "c", "aa") != 0); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "baaaab")); - fail_if(eina_strbuf_replace_last(buf, "a", "x") == 0); - fail_if(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); - fail_if(strcmp(eina_strbuf_string_get(buf), "baaaxb")); + ck_assert(eina_strbuf_replace_last(buf, "a", "x") == 0); + ck_assert(strlen(eina_strbuf_string_get(buf)) != eina_strbuf_length_get(buf)); + ck_assert(strcmp(eina_strbuf_string_get(buf), "baaaxb")); - fail_if(eina_strbuf_replace_first(buf, "a", "b") == 0); - fail_if(strcmp(eina_strbuf_string_get(buf), "bbaaxb")); + ck_assert(eina_strbuf_replace_first(buf, "a", "b") == 0); + ck_assert(strcmp(eina_strbuf_string_get(buf), "bbaaxb")); eina_strbuf_free(buf); buf = eina_strbuf_manage_read_only_new_length("baaaab",6); - fail_if(!buf); - fail_if(eina_strbuf_replace_first(buf, "a", "b") == 0); - fail_if(strcmp(eina_strbuf_string_get(buf), "bbaaab")); + ck_assert(!buf); + ck_assert(eina_strbuf_replace_first(buf, "a", "b") == 0); + ck_assert(strcmp(eina_strbuf_string_get(buf), "bbaaab")); eina_strbuf_free(buf); } @@ -333,51 +333,51 @@ EFL_START_TEST(eina_test_strbuf_realloc) pattern[i] = '\0'; buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); sz = 0; eina_strbuf_append_length(buf, pattern, 1); - fail_if(eina_strbuf_length_get(buf) != sz + 1); - fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 1)); + ck_assert(eina_strbuf_length_get(buf) != sz + 1); + ck_assert(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 1)); sz += 1; eina_strbuf_append_length(buf, pattern, 32); - fail_if(eina_strbuf_length_get(buf) != sz + 32); - fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 32)); + ck_assert(eina_strbuf_length_get(buf) != sz + 32); + ck_assert(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 32)); sz += 32; eina_strbuf_append_length(buf, pattern, 64); - fail_if(eina_strbuf_length_get(buf) != sz + 64); - fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 64)); + ck_assert(eina_strbuf_length_get(buf) != sz + 64); + ck_assert(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 64)); sz += 64; eina_strbuf_append_length(buf, pattern, 128); - fail_if(eina_strbuf_length_get(buf) != sz + 128); - fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 128)); + ck_assert(eina_strbuf_length_get(buf) != sz + 128); + ck_assert(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 128)); sz += 128; eina_strbuf_append_length(buf, pattern, 4096); - fail_if(eina_strbuf_length_get(buf) != sz + 4096); - fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 4096)); + ck_assert(eina_strbuf_length_get(buf) != sz + 4096); + ck_assert(memcmp(eina_strbuf_string_get(buf) + sz, pattern, 4096)); sz += 4096; eina_strbuf_append_length(buf, pattern, sizeof(pattern) - 1); - fail_if(eina_strbuf_length_get(buf) != sz + sizeof(pattern) - 1); - fail_if(memcmp(eina_strbuf_string_get(buf) + sz, pattern, sizeof(pattern) - + ck_assert(eina_strbuf_length_get(buf) != sz + sizeof(pattern) - 1); + ck_assert(memcmp(eina_strbuf_string_get(buf) + sz, pattern, sizeof(pattern) - 1)); sz += sizeof(pattern) - 1; eina_strbuf_remove(buf, 1024, 1024 + 1234); - fail_if(eina_strbuf_length_get(buf) != sz - 1234); + ck_assert(eina_strbuf_length_get(buf) != sz - 1234); sz -= 1234; eina_strbuf_remove(buf, 0, 0 + 8192); - fail_if(eina_strbuf_length_get(buf) != sz - 8192); + ck_assert(eina_strbuf_length_get(buf) != sz - 8192); sz -= 8192; eina_strbuf_remove(buf, 0, 0 + 32); - fail_if(eina_strbuf_length_get(buf) != sz - 32); + ck_assert(eina_strbuf_length_get(buf) != sz - 32); eina_strbuf_free(buf); } @@ -392,7 +392,7 @@ EFL_START_TEST(eina_test_strbuf_append_realloc) size_t i, target_pattern_size; buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); for (i = 0; i < runs; i++) { @@ -423,7 +423,7 @@ EFL_START_TEST(eina_test_strbuf_prepend_realloc) size_t i, target_pattern_size; buf = eina_strbuf_new(); - fail_if(!buf); + ck_assert(!buf); for (i = 0; i < runs; i++) { @@ -451,39 +451,39 @@ EFL_START_TEST(eina_test_strbuf_trim) const char *str; buf = eina_strbuf_new(); - fail_unless(buf != NULL); + ck_assert(buf != NULL); eina_strbuf_append(buf, " string "); eina_strbuf_trim(buf); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "string") != 0); + ck_assert(str == NULL || strcmp(str, "string") != 0); eina_strbuf_reset(buf); eina_strbuf_append(buf, " string "); eina_strbuf_ltrim(buf); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "string ") != 0); + ck_assert(str == NULL || strcmp(str, "string ") != 0); eina_strbuf_rtrim(buf); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "string") != 0); + ck_assert(str == NULL || strcmp(str, "string") != 0); eina_strbuf_reset(buf); eina_strbuf_append(buf, " "); eina_strbuf_trim(buf); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "") != 0); + ck_assert(str == NULL || strcmp(str, "") != 0); eina_strbuf_reset(buf); eina_strbuf_append(buf, " "); eina_strbuf_rtrim(buf); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "") != 0); + ck_assert(str == NULL || strcmp(str, "") != 0); eina_strbuf_reset(buf); eina_strbuf_append(buf, " "); eina_strbuf_ltrim(buf); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "") != 0); + ck_assert(str == NULL || strcmp(str, "") != 0); eina_strbuf_reset(buf); eina_strbuf_free(buf); @@ -496,21 +496,21 @@ EFL_START_TEST(eina_test_strbuf_tolower) const char *str; buf = eina_strbuf_new(); - fail_unless(buf != NULL); + ck_assert(buf != NULL); eina_strbuf_append(buf, "UPPER"); eina_strbuf_tolower(buf); str = eina_strbuf_string_get(buf); - fail_unless(str && !strcmp(str, "upper")); + ck_assert(str && !strcmp(str, "upper")); eina_strbuf_tolower(buf); str = eina_strbuf_string_get(buf); - fail_unless(str && !strcmp(str, "upper")); + ck_assert(str && !strcmp(str, "upper")); eina_strbuf_append(buf, "1@ "); eina_strbuf_tolower(buf); str = eina_strbuf_string_get(buf); - fail_unless(str && !strcmp(str, "upper1@ ")); + ck_assert(str && !strcmp(str, "upper1@ ")); eina_strbuf_free(buf); } @@ -522,36 +522,36 @@ EFL_START_TEST(eina_test_strbuf_substr_get) const char *str; buf = eina_strbuf_new(); - fail_unless(buf != NULL); + ck_assert(buf != NULL); eina_strbuf_append(buf, "string"); substr = eina_strbuf_substr_get(buf, 2, 3); str = eina_strbuf_string_get(substr); - fail_unless(str && !strcmp(str, "rin")); + ck_assert(str && !strcmp(str, "rin")); eina_strbuf_free(substr); substr = eina_strbuf_substr_get(buf, 0, 6); str = eina_strbuf_string_get(substr); - fail_unless(str && !strcmp(str, "string")); + ck_assert(str && !strcmp(str, "string")); eina_strbuf_free(substr); substr = eina_strbuf_substr_get(buf, 6, 0); str = eina_strbuf_string_get(substr); - fail_unless(str && !strcmp(str, "")); + ck_assert(str && !strcmp(str, "")); eina_strbuf_free(substr); substr = eina_strbuf_substr_get(buf, 6, 1); str = eina_strbuf_string_get(substr); - fail_if(str); + ck_assert(str); eina_strbuf_free(substr); substr = eina_strbuf_substr_get(buf, 0, 7); str = eina_strbuf_string_get(substr); - fail_if(str); + ck_assert(str); eina_strbuf_free(substr); substr = eina_strbuf_substr_get(NULL, 0, 7); - fail_if(substr); + ck_assert(substr); eina_strbuf_free(buf); } @@ -587,26 +587,26 @@ EFL_START_TEST(eina_test_strbuf_prepend_print) const char *str; buf = eina_strbuf_new(); - fail_unless(buf != NULL); + ck_assert(buf != NULL); ret = eina_strbuf_prepend_printf(buf, "%s", "string"); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "string") != 0); + ck_assert(str == NULL || strcmp(str, "string") != 0); ret = eina_strbuf_prepend_printf(buf, "This is %d ", 1); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "This is 1 string") != 0); + ck_assert(str == NULL || strcmp(str, "This is 1 string") != 0); ret = eina_strbuf_prepend_printf(buf, "%s ", "hello"); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, "hello This is 1 string") != 0); + ck_assert(str == NULL || strcmp(str, "hello This is 1 string") != 0); eina_strbuf_reset(buf); str = test_prepend(buf, "This", "is", "test", "string"); - fail_if(str == NULL || strcmp(str, "This is test string") != 0); + ck_assert(str == NULL || strcmp(str, "This is test string") != 0); eina_strbuf_free(buf); } @@ -643,7 +643,7 @@ EFL_START_TEST(eina_test_strbuf_strftime_test) buf = eina_strbuf_new(); eina_strbuf_append_strftime(buf, "%I:%M%p", info); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, cbuf) != 0); + ck_assert(str == NULL || strcmp(str, cbuf) != 0); eina_strbuf_reset(buf); eina_strbuf_append(buf, "Hours: Minutes"); @@ -651,7 +651,7 @@ EFL_START_TEST(eina_test_strbuf_strftime_test) eina_strbuf_insert_strftime(buf, "%M ", info, 10); strftime(cbuf, 32, "%I Hours: %M Minutes", info); str = eina_strbuf_string_get(buf); - fail_if(str == NULL || strcmp(str, cbuf) != 0); + ck_assert(str == NULL || strcmp(str, cbuf) != 0); eina_strbuf_free(buf); } diff --git a/src/tests/eina/eina_test_stringshare.c b/src/tests/eina/eina_test_stringshare.c index d8ea004938..7e7422e81d 100644 --- a/src/tests/eina/eina_test_stringshare.c +++ b/src/tests/eina/eina_test_stringshare.c @@ -43,20 +43,20 @@ EINA_TEST_START(eina_stringshare_simple) t0 = eina_stringshare_add(TEST0); t1 = eina_stringshare_add(TEST1); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(strcmp(t0, TEST0) != 0); - fail_if(strcmp(t1, TEST1) != 0); - fail_if((int)strlen(TEST0) != eina_stringshare_strlen(t0)); - fail_if((int)strlen(TEST1) != eina_stringshare_strlen(t1)); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(strcmp(t0, TEST0) != 0); + ck_assert(strcmp(t1, TEST1) != 0); + ck_assert((int)strlen(TEST0) != eina_stringshare_strlen(t0)); + ck_assert((int)strlen(TEST1) != eina_stringshare_strlen(t1)); t0 = eina_stringshare_ref(t0); - fail_if(t0 == NULL); - fail_if((int)strlen(TEST0) != eina_stringshare_strlen(t0)); + ck_assert(t0 == NULL); + ck_assert((int)strlen(TEST0) != eina_stringshare_strlen(t0)); slice = eina_stringshare_slice_get(t0); - fail_if(slice.mem != t0); - fail_if(slice.len != strlen(TEST0)); + ck_assert(slice.mem != t0); + ck_assert(slice.len != strlen(TEST0)); eina_stringshare_del(t0); eina_stringshare_del(t0); @@ -73,22 +73,22 @@ EINA_TEST_START(eina_stringshare_simple_refplace) t0 = eina_stringshare_add(TEST0); t1 = eina_stringshare_add(TEST1); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(strcmp(t0, TEST0) != 0); - fail_if(strcmp(t1, TEST1) != 0); - fail_if((int)strlen(TEST0) != eina_stringshare_strlen(t0)); - fail_if((int)strlen(TEST1) != eina_stringshare_strlen(t1)); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(strcmp(t0, TEST0) != 0); + ck_assert(strcmp(t1, TEST1) != 0); + ck_assert((int)strlen(TEST0) != eina_stringshare_strlen(t0)); + ck_assert((int)strlen(TEST1) != eina_stringshare_strlen(t1)); - fail_if(eina_stringshare_refplace(&t0, t0)); - fail_if(t0 == NULL); - fail_if((int)strlen(TEST0) != eina_stringshare_strlen(t0)); + ck_assert(eina_stringshare_refplace(&t0, t0)); + ck_assert(t0 == NULL); + ck_assert((int)strlen(TEST0) != eina_stringshare_strlen(t0)); slice = eina_stringshare_slice_get(t0); - fail_if(slice.mem != t0); - fail_if(slice.len != strlen(TEST0)); + ck_assert(slice.mem != t0); + ck_assert(slice.len != strlen(TEST0)); - fail_if(!eina_stringshare_refplace(&t1, t0)); + ck_assert(!eina_stringshare_refplace(&t1, t0)); eina_stringshare_del(t0); eina_stringshare_del(t1); @@ -115,12 +115,12 @@ EINA_TEST_START(eina_stringshare_small) t0 = eina_stringshare_add(buf); t1 = eina_stringshare_add(buf); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(t0 != t1); - fail_if(strcmp(t0, buf) != 0); - fail_if((int)strlen(buf) != eina_stringshare_strlen(t0)); - fail_if((int)strlen(buf) != eina_stringshare_strlen(t1)); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(t0 != t1); + ck_assert(strcmp(t0, buf) != 0); + ck_assert((int)strlen(buf) != eina_stringshare_strlen(t0)); + ck_assert((int)strlen(buf) != eina_stringshare_strlen(t1)); eina_stringshare_ref(t0); eina_stringshare_del(t0); @@ -139,12 +139,12 @@ EINA_TEST_START(eina_stringshare_test_share) t0 = eina_stringshare_add(TEST0); t1 = eina_stringshare_add(TEST0); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(strcmp(t0, TEST0) != 0); - fail_if(strcmp(t1, TEST0) != 0); - fail_if(t0 != t1); - fail_if((int)strlen(t0) != eina_stringshare_strlen(t0)); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(strcmp(t0, TEST0) != 0); + ck_assert(strcmp(t1, TEST0) != 0); + ck_assert(t0 != t1); + ck_assert((int)strlen(t0) != eina_stringshare_strlen(t0)); eina_stringshare_del(t0); eina_stringshare_del(t1); @@ -162,7 +162,7 @@ EINA_TEST_START(eina_stringshare_putstuff) eina_convert_xtoa(i, build + 7); tmp = eina_stringshare_add(build); - fail_if(tmp != eina_stringshare_add(build)); + ck_assert(tmp != eina_stringshare_add(build)); } } EINA_TEST_END @@ -174,7 +174,7 @@ EINA_TEST_START(eina_stringshare_collision) int i; ea = eina_array_new(256); - fail_if(!ea); + ck_assert(!ea); for (i = 0; i < 10000; ++i) { @@ -183,7 +183,7 @@ EINA_TEST_START(eina_stringshare_collision) if (rand() > RAND_MAX / 2) { const char *r = eina_stringshare_add(buffer); - fail_if(r == NULL); + ck_assert(r == NULL); } } @@ -194,9 +194,9 @@ EINA_TEST_START(eina_stringshare_collision) eina_convert_itoa(60000 - i, buffer); eina_array_push(ea, (void *)eina_stringshare_add(buffer)); r = eina_stringshare_add(buffer); - fail_if(r == NULL); + ck_assert(r == NULL); r = eina_stringshare_add(buffer); - fail_if(r == NULL); + ck_assert(r == NULL); } for (i = 0; i < 200; ++i) @@ -215,24 +215,24 @@ EINA_TEST_START(eina_stringshare_print) const char *t2; const char *t3; - fail_if(eina_stringshare_printf(0) != NULL); - fail_if(eina_stringshare_printf("%s", "") == NULL); - fail_if(strlen(eina_stringshare_printf("%s", "")) > 0); - fail_if(eina_stringshare_nprintf(0, "%s", "") == NULL); - fail_if(strlen(eina_stringshare_nprintf(0, "%s", "")) > 0); + ck_assert(eina_stringshare_printf(0) != NULL); + ck_assert(eina_stringshare_printf("%s", "") == NULL); + ck_assert(strlen(eina_stringshare_printf("%s", "")) > 0); + ck_assert(eina_stringshare_nprintf(0, "%s", "") == NULL); + ck_assert(strlen(eina_stringshare_nprintf(0, "%s", "")) > 0); t1 = eina_stringshare_printf("x%sy", TEST1); t2 = my_vprintf("x%sy", TEST1); t3 = eina_stringshare_nprintf(10, "x%sy", TEST1); - fail_if(t1 == NULL); - fail_if(t2 == NULL); - fail_if(t3 == NULL); - fail_if(strcmp(t1, "x"TEST1"y") != 0); - fail_if(strcmp(t2, "x"TEST1"y") != 0); - fail_if(strcmp(t3, "x"TEST1"y") != 0); - fail_if(((int)strlen(TEST1) + 2) != eina_stringshare_strlen(t1)); - fail_if(((int)strlen(TEST1) + 2) != eina_stringshare_strlen(t2)); - fail_if(8 != eina_stringshare_strlen(t3)); + ck_assert(t1 == NULL); + ck_assert(t2 == NULL); + ck_assert(t3 == NULL); + ck_assert(strcmp(t1, "x"TEST1"y") != 0); + ck_assert(strcmp(t2, "x"TEST1"y") != 0); + ck_assert(strcmp(t3, "x"TEST1"y") != 0); + ck_assert(((int)strlen(TEST1) + 2) != eina_stringshare_strlen(t1)); + ck_assert(((int)strlen(TEST1) + 2) != eina_stringshare_strlen(t2)); + ck_assert(8 != eina_stringshare_strlen(t3)); eina_stringshare_del(t1); eina_stringshare_del(t2); eina_stringshare_del(t3); diff --git a/src/tests/eina/eina_test_tiler.c b/src/tests/eina/eina_test_tiler.c index e2f1adb86e..c755945eef 100644 --- a/src/tests/eina/eina_test_tiler.c +++ b/src/tests/eina/eina_test_tiler.c @@ -40,7 +40,7 @@ check_iterator(Eina_Iterator *it, struct test_rect *cur_test) struct Eina_Tile_Grid_Info *tile; EINA_ITERATOR_FOREACH(it, tile) { - fail_if(cur_test[i].col != tile->col || + ck_assert(cur_test[i].col != tile->col || cur_test[i].row != tile->row || cur_test[i].x != tile->rect.x || cur_test[i].y != tile->rect.y || @@ -50,7 +50,7 @@ check_iterator(Eina_Iterator *it, struct test_rect *cur_test) i++; } - fail_if(i == 0); + ck_assert(i == 0); } EFL_START_TEST(eina_test_tile_grid_slicer_iterator) @@ -139,42 +139,42 @@ EFL_START_TEST(eina_test_tiler_all) tl = eina_tiler_new(1, 1); eina_tiler_area_size_get(tl, &width, &height); - fail_if(width != 1 && height != 1); + ck_assert(width != 1 && height != 1); width = 640; height = 480; eina_tiler_area_size_set(tl, width, height); eina_tiler_area_size_get(tl, &width, &height); - fail_if(width != 640 && height != 480); + ck_assert(width != 640 && height != 480); eina_tiler_tile_size_set(tl, 32, 32); EINA_RECTANGLE_SET(&r, 50, 50, 20, 20); - fail_if(!eina_tiler_rect_add(tl, &r)); + ck_assert(!eina_tiler_rect_add(tl, &r)); EINA_RECTANGLE_SET(&r, -10, -10, 5, 5); - fail_if(eina_tiler_rect_add(tl, &r)); + ck_assert(eina_tiler_rect_add(tl, &r)); EINA_RECTANGLE_SET(&r, 40, 40, 20, 20); eina_tiler_rect_del(tl, &r); it = eina_tiler_iterator_new(tl); - fail_if(!it); + ck_assert(!it); EINA_ITERATOR_FOREACH(it, rp) { - fail_if(rp->w <= 0); - fail_if(rp->h <= 0); - fail_if(rp->x < 0 || rp->x + rp->w > 640); - fail_if(rp->y < 0 || rp->y + rp->h > 480); + ck_assert(rp->w <= 0); + ck_assert(rp->h <= 0); + ck_assert(rp->x < 0 || rp->x + rp->w > 640); + ck_assert(rp->y < 0 || rp->y + rp->h > 480); ++i; } - fail_if(eina_iterator_container_get(it) != tl); + ck_assert(eina_iterator_container_get(it) != tl); eina_iterator_free(it); - fail_if(i == 0); + ck_assert(i == 0); eina_tiler_clear(tl); @@ -193,36 +193,36 @@ EFL_START_TEST(eina_test_tiler_stable) tl = eina_tiler_new(640, 480); - fail_if(!tl); + ck_assert(!tl); eina_tiler_tile_size_set(tl, 1, 1); EINA_RECTANGLE_SET(&r, 50, 50, 20, 20); - fail_if(!eina_tiler_rect_add(tl, &r)); + ck_assert(!eina_tiler_rect_add(tl, &r)); EINA_RECTANGLE_SET(&r, 40, 40, 20, 20); eina_tiler_rect_del(tl, &r); EINA_RECTANGLE_SET(&r, 50, 50, 20, 20); - fail_if(!eina_tiler_rect_add(tl, &r)); + ck_assert(!eina_tiler_rect_add(tl, &r)); EINA_RECTANGLE_SET(&r, 40, 40, 20, 20); eina_tiler_rect_del(tl, &r); it = eina_tiler_iterator_new(tl); - fail_if(!it); + ck_assert(!it); EINA_ITERATOR_FOREACH(it, rp) { EINA_RECTANGLE_SET(&r, 40, 40, 20, 20); - fail_if(eina_rectangle_intersection(&r, rp)); + ck_assert(eina_rectangle_intersection(&r, rp)); EINA_RECTANGLE_SET(&r, 50, 50, 20, 20); - fail_if(!eina_rectangles_intersect(&r, rp)); + ck_assert(!eina_rectangles_intersect(&r, rp)); ++i; } - fail_if(i != 2); + ck_assert(i != 2); eina_iterator_free(it); @@ -240,10 +240,10 @@ EFL_START_TEST(eina_test_tiler_calculation) t1 = eina_tiler_new(500, 500); - fail_if(!t1); + ck_assert(!t1); t2 = eina_tiler_new(500, 500); - fail_if(!t2); + ck_assert(!t2); eina_tiler_tile_size_set(t1, 1, 1); eina_tiler_tile_size_set(t2, 1, 1); @@ -254,85 +254,85 @@ EFL_START_TEST(eina_test_tiler_calculation) EINA_RECTANGLE_SET(&r2, 100, 100, 300, 300); eina_tiler_rect_add(t2, &r2); - fail_if(!eina_tiler_union(t1, t2)); + ck_assert(!eina_tiler_union(t1, t2)); itr = eina_tiler_iterator_new(t1); EINA_ITERATOR_FOREACH(itr, rp) { - fail_if(rp->w != 500); - fail_if(rp->h != 500); - fail_if(rp->x != 0); - fail_if(rp->y != 0); + ck_assert(rp->w != 500); + ck_assert(rp->h != 500); + ck_assert(rp->x != 0); + ck_assert(rp->y != 0); ++i; } eina_iterator_free(itr); eina_tiler_clear(t1); - fail_if(i != 1); + ck_assert(i != 1); eina_tiler_rect_add(t1, &r1); - fail_if(!eina_tiler_subtract(t1, t2)); + ck_assert(!eina_tiler_subtract(t1, t2)); i = 0; itr = eina_tiler_iterator_new(t1); EINA_ITERATOR_FOREACH(itr, rp) { - fail_if(!eina_rectangles_intersect(&r1, rp)); - fail_if(eina_rectangles_intersect(&r2, rp)); + ck_assert(!eina_rectangles_intersect(&r1, rp)); + ck_assert(eina_rectangles_intersect(&r2, rp)); - fail_if(rp->w <= 0); - fail_if(rp->h <= 0); - fail_if(rp->x < 0 || rp->x + rp->w > 500); - fail_if(rp->y < 0 || rp->y + rp->h > 500); + ck_assert(rp->w <= 0); + ck_assert(rp->h <= 0); + ck_assert(rp->x < 0 || rp->x + rp->w > 500); + ck_assert(rp->y < 0 || rp->y + rp->h > 500); ++i; } eina_iterator_free(itr); eina_tiler_clear(t1); - fail_if(i != 4); + ck_assert(i != 4); EINA_RECTANGLE_SET(&r3, 0, 0, 50, 50); eina_tiler_rect_add(t1, &r3); t = eina_tiler_intersection(t1, t2); - fail_if(t); + ck_assert(t); eina_tiler_clear(t1); eina_tiler_rect_add(t1, &r1); t = eina_tiler_intersection(t1, t2); - fail_if(!t); + ck_assert(!t); i = 0; itr = eina_tiler_iterator_new(t); EINA_ITERATOR_FOREACH(itr, rp) { - fail_if(!eina_rectangles_intersect(&r1, rp)); - fail_if(!eina_rectangles_intersect(&r2, rp)); + ck_assert(!eina_rectangles_intersect(&r1, rp)); + ck_assert(!eina_rectangles_intersect(&r2, rp)); - fail_if(rp->w <= 0); - fail_if(rp->h <= 0); - fail_if(rp->x < 0 || rp->x + rp->w > 500); - fail_if(rp->y < 0 || rp->y + rp->h > 500); + ck_assert(rp->w <= 0); + ck_assert(rp->h <= 0); + ck_assert(rp->x < 0 || rp->x + rp->w > 500); + ck_assert(rp->y < 0 || rp->y + rp->h > 500); ++i; } eina_iterator_free(itr); eina_tiler_clear(t); - fail_if(i != 1); + ck_assert(i != 1); eina_tiler_rect_add(t, &r1); - fail_if(!eina_tiler_equal(t, t1)); - fail_if(!eina_tiler_equal(t1, t)); + ck_assert(!eina_tiler_equal(t, t1)); + ck_assert(!eina_tiler_equal(t1, t)); EINA_RECTANGLE_SET(&r1, 0, 0, 250, 250); eina_tiler_rect_del(t, &r1); - fail_if(eina_tiler_equal(t1, t)); + ck_assert(eina_tiler_equal(t1, t)); eina_tiler_free(t); eina_tiler_free(t1); @@ -349,21 +349,21 @@ EFL_START_TEST(eina_test_tiler_size) Eina_Bool rects = EINA_FALSE; t = eina_tiler_new(131070, 131070); - fail_if(!t); + ck_assert(!t); eina_tiler_tile_size_set(t, 1, 1); - fail_if(!eina_tiler_rect_add(t, &(Eina_Rectangle){0, 0, 131070, 131070})); + ck_assert(!eina_tiler_rect_add(t, &(Eina_Rectangle){0, 0, 131070, 131070})); it = eina_tiler_iterator_new(t); - fail_if(!it); + ck_assert(!it); EINA_ITERATOR_FOREACH(it, r) { rects = EINA_TRUE; - fail_if(r->x); - fail_if(r->y); - fail_if(r->w != 131070); - fail_if(r->h != 131070); + ck_assert(r->x); + ck_assert(r->y); + ck_assert(r->w != 131070); + ck_assert(r->h != 131070); } - fail_if(!rects); + ck_assert(!rects); eina_iterator_free(it); eina_tiler_free(t); } diff --git a/src/tests/eina/eina_test_tmpstr.c b/src/tests/eina/eina_test_tmpstr.c index 33e7db709f..aa319696e2 100644 --- a/src/tests/eina/eina_test_tmpstr.c +++ b/src/tests/eina/eina_test_tmpstr.c @@ -39,7 +39,7 @@ EFL_START_TEST(tmpstr_simple) snprintf(buf, max_str_len, "Tmp string %d", (i + 1)); tmp_strings[i] = eina_tmpstr_add(buf); - fail_if(strcmp(buf, tmp_strings[i])); + ck_assert(strcmp(buf, tmp_strings[i])); } // Delete these tmp strings @@ -47,7 +47,7 @@ EFL_START_TEST(tmpstr_simple) { snprintf(buf, max_str_len, "Tmp string %d", (cnt_tmp_strings - i - 1 + 1)); - fail_if(strcmp(buf, tmp_strings[cnt_tmp_strings - i - 1])); + ck_assert(strcmp(buf, tmp_strings[cnt_tmp_strings - i - 1])); eina_tmpstr_del(tmp_strings[cnt_tmp_strings - i - 1]); tmp_strings[cnt_tmp_strings - i - 1] = 0; @@ -73,7 +73,7 @@ EFL_START_TEST(tmpstr_simple_len) snprintf(buf, max_str_len, "Tmp string %d", (i + 1)); tmp_strings[i] = eina_tmpstr_add_length(buf, (max_str_len + 1)); - fail_if(strcmp(buf, tmp_strings[i])); + ck_assert(strcmp(buf, tmp_strings[i])); } // Delete these tmp strings @@ -81,7 +81,7 @@ EFL_START_TEST(tmpstr_simple_len) { snprintf(buf, max_str_len, "Tmp string %d", (cnt_tmp_strings - i - 1 + 1)); - fail_if(strcmp(buf, tmp_strings[cnt_tmp_strings - i - 1])); + ck_assert(strcmp(buf, tmp_strings[cnt_tmp_strings - i - 1])); eina_tmpstr_del(tmp_strings[cnt_tmp_strings - i - 1]); tmp_strings[cnt_tmp_strings - i - 1] = 0; @@ -99,7 +99,7 @@ EFL_START_TEST(tmpstr_manage) char *buf = malloc(7); strcpy(buf, "tmpstr"); Eina_Tmpstr *tstr1 = eina_tmpstr_manage_new(buf); - fail_if(strcmp(buf, tstr1)); + ck_assert(strcmp(buf, tstr1)); eina_tmpstr_del(tstr1); } @@ -111,7 +111,7 @@ EFL_START_TEST(tmpstr_manage_len) char *buf = malloc(10); strcpy(buf, "tmpstr"); Eina_Tmpstr *tstr1 = eina_tmpstr_manage_new_length(buf, 7); - fail_if(strcmp(buf, tstr1)); + ck_assert(strcmp(buf, tstr1)); eina_tmpstr_del(tstr1); } diff --git a/src/tests/eina/eina_test_trash.c b/src/tests/eina/eina_test_trash.c index ce736e2976..5c3e997d1a 100644 --- a/src/tests/eina/eina_test_trash.c +++ b/src/tests/eina/eina_test_trash.c @@ -34,38 +34,38 @@ EFL_START_TEST(trash_simple) trash = calloc(1, sizeof(Eina_Trash)); - fail_if(trash == NULL); + ck_assert(trash == NULL); eina_trash_init(&trash); for (i = 1; i < 51; ++i) { array = eina_array_new(1); - fail_if(!array); + ck_assert(!array); eina_array_push(array, &inp_int); eina_trash_push(&trash, array); array = eina_array_new(1); - fail_if(!array); + ck_assert(!array); eina_array_push(array, &inp_char); eina_trash_push(&trash, array); } data = eina_trash_pop(&trash); - fail_if(!data); - fail_if(*((char *)eina_array_data_get(data, 0)) != inp_char); + ck_assert(!data); + ck_assert(*((char *)eina_array_data_get(data, 0)) != inp_char); data = eina_trash_pop(&trash); - fail_if(!data); - fail_if(*((int *)eina_array_data_get(data, 0)) != inp_int); + ck_assert(!data); + ck_assert(*((int *)eina_array_data_get(data, 0)) != inp_int); free(data); i = 0; EINA_TRASH_CLEAN(&trash, data) { - fail_if(!data); + ck_assert(!data); free(data); ++i; } - fail_if(i != 98); + ck_assert(i != 98); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_ustr.c b/src/tests/eina/eina_test_ustr.c index 308059bda9..588bb16e2d 100644 --- a/src/tests/eina/eina_test_ustr.c +++ b/src/tests/eina/eina_test_ustr.c @@ -76,25 +76,25 @@ EFL_START_TEST(eina_unicode_strcmp_test) { /* 1 & 2 */ - fail_if(eina_unicode_strcmp(STR1,STR2) == 0); - fail_if(eina_unicode_strcmp(STR1,STR2) < 1); + ck_assert(eina_unicode_strcmp(STR1,STR2) == 0); + ck_assert(eina_unicode_strcmp(STR1,STR2) < 1); /* 1 & 3 */ - fail_if(eina_unicode_strcmp(STR1, STR3) != 0); + ck_assert(eina_unicode_strcmp(STR1, STR3) != 0); /* 1 & 4 */ - fail_if(eina_unicode_strcmp(STR1, STR4) == 0); - fail_if(eina_unicode_strcmp(STR1, STR4) > 1); + ck_assert(eina_unicode_strcmp(STR1, STR4) == 0); + ck_assert(eina_unicode_strcmp(STR1, STR4) > 1); /* 1 & empty */ - fail_if(eina_unicode_strcmp(STR1, EMPTYSTR) < 1); + ck_assert(eina_unicode_strcmp(STR1, EMPTYSTR) < 1); /* Self tests */ - fail_if(eina_unicode_strcmp(STR1, STR1) != 0); - fail_if(eina_unicode_strcmp(STR2, STR2) != 0); - fail_if(eina_unicode_strcmp(STR3, STR3) != 0); - fail_if(eina_unicode_strcmp(STR4, STR4) != 0); - fail_if(eina_unicode_strcmp(EMPTYSTR, EMPTYSTR) != 0); + ck_assert(eina_unicode_strcmp(STR1, STR1) != 0); + ck_assert(eina_unicode_strcmp(STR2, STR2) != 0); + ck_assert(eina_unicode_strcmp(STR3, STR3) != 0); + ck_assert(eina_unicode_strcmp(STR4, STR4) != 0); + ck_assert(eina_unicode_strcmp(EMPTYSTR, EMPTYSTR) != 0); } EFL_END_TEST @@ -106,29 +106,29 @@ EFL_START_TEST(eina_unicode_strcpy_test) rv = eina_unicode_strcpy(buf,STR1); - fail_if(rv != buf); - fail_if(eina_unicode_strcmp(buf,STR1) != 0); + ck_assert(rv != buf); + ck_assert(eina_unicode_strcmp(buf,STR1) != 0); rv = eina_unicode_strcpy(buf,STR2); - fail_if(rv != buf); - fail_if(eina_unicode_strcmp(buf,STR2) != 0); + ck_assert(rv != buf); + ck_assert(eina_unicode_strcmp(buf,STR2) != 0); /* Now a shorter string */ rv = eina_unicode_strcpy(buf,STR2); - fail_if(rv != buf); - fail_if(eina_unicode_strcmp(buf,STR2) != 0); + ck_assert(rv != buf); + ck_assert(eina_unicode_strcmp(buf,STR2) != 0); /* Really short string */ rv = eina_unicode_strcpy(buf,STR4); - fail_if(rv != buf); - fail_if(eina_unicode_strcmp(buf,STR4) != 0); - fail_if(buf[2] != 'n'); /* check old buf is there */ + ck_assert(rv != buf); + ck_assert(eina_unicode_strcmp(buf,STR4) != 0); + ck_assert(buf[2] != 'n'); /* check old buf is there */ buf[1] = '7'; rv = eina_unicode_strcpy(buf,EMPTYSTR); - fail_if(rv != buf); - fail_if(buf[0] != 0); - fail_if(buf[1] != '7'); + ck_assert(rv != buf); + ck_assert(buf[0] != 0); + ck_assert(buf[1] != '7'); } EFL_END_TEST @@ -140,24 +140,24 @@ EFL_START_TEST(eina_unicode_strncpy_test) rv = eina_unicode_strncpy(buf,STR1,9); - fail_if(rv != buf); - fail_if(eina_unicode_strcmp(buf,STR1) != 0); + ck_assert(rv != buf); + ck_assert(eina_unicode_strcmp(buf,STR1) != 0); buf[1] = '7'; rv = eina_unicode_strncpy(buf,STR1,1); - fail_if(rv != buf); - fail_if(buf[1] != '7'); - fail_if(buf[0] != STR1[0]); + ck_assert(rv != buf); + ck_assert(buf[1] != '7'); + ck_assert(buf[0] != STR1[0]); buf[9] = '7'; rv = eina_unicode_strncpy(buf, STR4, 10); - fail_if(rv != buf); - fail_if(eina_unicode_strcmp(buf,STR4) != 0); - fail_if(buf[9] != 0); + ck_assert(rv != buf); + ck_assert(eina_unicode_strcmp(buf,STR4) != 0); + ck_assert(buf[9] != 0); buf[0] = '7'; eina_unicode_strncpy(buf, STR1, 0); - fail_if(buf[0] != '7'); + ck_assert(buf[0] != '7'); #ifdef EINA_SAFETY_CHECKS { @@ -178,8 +178,8 @@ EFL_START_TEST(eina_unicode_strncpy_test) TEST_MAGIC_SAFETY("eina_unicode_strncpy", "safety check failed: source == NULL"); rv = eina_unicode_strncpy(buf, NULL, 0); - fail_if(buf[0] != '7'); - fail_unless(ctx.did); + ck_assert(buf[0] != '7'); + ck_assert(ctx.did); /* Hopefully won't segfault */ #ifdef SHOW_LOG @@ -188,8 +188,8 @@ EFL_START_TEST(eina_unicode_strncpy_test) TEST_MAGIC_SAFETY("eina_unicode_strncpy", "safety check failed: dest == NULL"); rv = eina_unicode_strncpy(NULL, STR1, 0); - fail_if(rv != NULL); - fail_unless(ctx.did); + ck_assert(rv != NULL); + ck_assert(ctx.did); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); #undef TEST_MAGIC_SAFETY @@ -205,11 +205,11 @@ EFL_START_TEST(eina_ustr_strlen_test) { - fail_if(eina_unicode_strlen(STR1) != 8); - fail_if(eina_unicode_strlen(STR2) != 9); - fail_if(eina_unicode_strlen(STR3) != 8); - fail_if(eina_unicode_strlen(STR4) != 1); - fail_if(eina_unicode_strlen(EMPTYSTR) != 0); + ck_assert(eina_unicode_strlen(STR1) != 8); + ck_assert(eina_unicode_strlen(STR2) != 9); + ck_assert(eina_unicode_strlen(STR3) != 8); + ck_assert(eina_unicode_strlen(STR4) != 1); + ck_assert(eina_unicode_strlen(EMPTYSTR) != 0); #ifdef EINA_SAFETY_CHECKS { @@ -227,8 +227,8 @@ EFL_START_TEST(eina_ustr_strlen_test) #endif TEST_MAGIC_SAFETY("eina_unicode_strlen", "safety check failed: ustr == NULL"); - fail_if(eina_unicode_strlen(NULL)); - fail_unless(ctx.did); + ck_assert(eina_unicode_strlen(NULL)); + ck_assert(ctx.did); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); #undef TEST_MAGIC_SAFETY @@ -242,17 +242,17 @@ EFL_START_TEST(eina_unicode_strnlen_test) { /* Strlen style tests*/ - fail_if(eina_unicode_strnlen(STR1,10) != 8); - fail_if(eina_unicode_strnlen(STR2,10) != 9); - fail_if(eina_unicode_strnlen(STR3,10) != 8); - fail_if(eina_unicode_strnlen(STR4,10) != 1); - fail_if(eina_unicode_strnlen(EMPTYSTR,10) != 0); + ck_assert(eina_unicode_strnlen(STR1,10) != 8); + ck_assert(eina_unicode_strnlen(STR2,10) != 9); + ck_assert(eina_unicode_strnlen(STR3,10) != 8); + ck_assert(eina_unicode_strnlen(STR4,10) != 1); + ck_assert(eina_unicode_strnlen(EMPTYSTR,10) != 0); /* Too short tests */ - fail_if(eina_unicode_strnlen(STR1,3) != 3); - fail_if(eina_unicode_strnlen(STR2,3) != 3); - fail_if(eina_unicode_strnlen(STR3,3) != 3); - fail_if(eina_unicode_strnlen(EMPTYSTR,1) != 0); + ck_assert(eina_unicode_strnlen(STR1,3) != 3); + ck_assert(eina_unicode_strnlen(STR2,3) != 3); + ck_assert(eina_unicode_strnlen(STR3,3) != 3); + ck_assert(eina_unicode_strnlen(EMPTYSTR,1) != 0); #ifdef EINA_SAFETY_CHECKS { @@ -270,8 +270,8 @@ EFL_START_TEST(eina_unicode_strnlen_test) #endif TEST_MAGIC_SAFETY("eina_unicode_strnlen", "safety check failed: ustr == NULL"); - fail_if(eina_unicode_strnlen(NULL,0) != 0); - fail_unless(ctx.did); + ck_assert(eina_unicode_strnlen(NULL,0) != 0); + ck_assert(ctx.did); eina_log_print_cb_set(eina_log_print_cb_stderr, NULL); #undef TEST_MAGIC_SAFETY @@ -287,14 +287,14 @@ EFL_START_TEST(eina_unicode_strdup_test) buf = eina_unicode_strdup(STR1); - fail_if(!buf); - fail_if(eina_unicode_strlen(buf) != eina_unicode_strlen(STR1)); - fail_if(eina_unicode_strcmp(buf, STR1)); + ck_assert(!buf); + ck_assert(eina_unicode_strlen(buf) != eina_unicode_strlen(STR1)); + ck_assert(eina_unicode_strcmp(buf, STR1)); free(buf); buf = eina_unicode_strdup(EMPTYSTR); - fail_if(!buf); - fail_if(buf[0] != 0); + ck_assert(!buf); + ck_assert(buf[0] != 0); free(buf); } EFL_END_TEST @@ -306,19 +306,19 @@ EFL_START_TEST(eina_unicode_strstr_test) buf = eina_unicode_strstr(STR1,on); - fail_if(!buf); - fail_if(buf != STR1 + 6); - fail_if(eina_unicode_strcmp(buf,on) != 0); + ck_assert(!buf); + ck_assert(buf != STR1 + 6); + ck_assert(eina_unicode_strcmp(buf,on) != 0); buf = eina_unicode_strstr(STR2,on); - fail_if(buf); + ck_assert(buf); buf = eina_unicode_strstr(EMPTYSTR, on); - fail_if(buf); + ck_assert(buf); buf = eina_unicode_strstr(STR1, EMPTYSTR); - fail_if(!buf); - fail_if(buf != STR1); + ck_assert(!buf); + ck_assert(buf != STR1); } EFL_END_TEST @@ -338,9 +338,9 @@ EFL_START_TEST(eina_unicode_escape_test) for (i = 0; i < sizeof(str)/sizeof(str[0]); ++i) { buf = eina_unicode_escape(str[i]); - fail_if(!buf); - fail_if(eina_unicode_strlen(buf) != eina_unicode_strlen(result_str[i])); - fail_if(eina_unicode_strcmp(buf, result_str[i]) != 0); + ck_assert(!buf); + ck_assert(eina_unicode_strlen(buf) != eina_unicode_strlen(result_str[i])); + ck_assert(eina_unicode_strcmp(buf, result_str[i]) != 0); free(buf); } @@ -355,80 +355,80 @@ EFL_START_TEST(eina_unicode_utf8) /* Valid utf-8 cases */ /* First possible sequence of a certain length */ ind = 0; - fail_if((eina_unicode_utf8_next_get("\x00", &ind) != 0x00) || + ck_assert((eina_unicode_utf8_next_get("\x00", &ind) != 0x00) || (ind != 0)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\x01", &ind) != 0x01) || + ck_assert((eina_unicode_utf8_next_get("\x01", &ind) != 0x01) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xC2\x80", &ind) != 0x80) || + ck_assert((eina_unicode_utf8_next_get("\xC2\x80", &ind) != 0x80) || (ind != 2)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xE0\xA0\x80", &ind) != 0x800) || + ck_assert((eina_unicode_utf8_next_get("\xE0\xA0\x80", &ind) != 0x800) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF0\x90\x80\x80", &ind) != 0x10000) || + ck_assert((eina_unicode_utf8_next_get("\xF0\x90\x80\x80", &ind) != 0x10000) || (ind != 4)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF8\x88\x80\x80\x80", &ind) != 0x200000) || (ind != 5)); + ck_assert((eina_unicode_utf8_next_get("\xF8\x88\x80\x80\x80", &ind) != 0x200000) || (ind != 5)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xFC\x84\x80\x80\x80\x80", &ind) != 0x4000000) || (ind != 6)); + ck_assert((eina_unicode_utf8_next_get("\xFC\x84\x80\x80\x80\x80", &ind) != 0x4000000) || (ind != 6)); /* Last possible sequence of a certain length */ ind = 0; - fail_if((eina_unicode_utf8_next_get("\x7F", &ind) != 0x7F) || + ck_assert((eina_unicode_utf8_next_get("\x7F", &ind) != 0x7F) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xDF\xBF", &ind) != 0x7FF) || + ck_assert((eina_unicode_utf8_next_get("\xDF\xBF", &ind) != 0x7FF) || (ind != 2)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xEF\xBF\xBF", &ind) != 0xFFFF) || + ck_assert((eina_unicode_utf8_next_get("\xEF\xBF\xBF", &ind) != 0xFFFF) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF7\xBF\xBF\xBF", &ind) != 0x1FFFFF) || + ck_assert((eina_unicode_utf8_next_get("\xF7\xBF\xBF\xBF", &ind) != 0x1FFFFF) || (ind != 4)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xFB\xBF\xBF\xBF\xBF", &ind) != 0x3FFFFFF) || (ind != 5)); + ck_assert((eina_unicode_utf8_next_get("\xFB\xBF\xBF\xBF\xBF", &ind) != 0x3FFFFFF) || (ind != 5)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xFD\xBF\xBF\xBF\xBF\xBF", &ind) != 0x7FFFFFFF) || (ind != 6)); + ck_assert((eina_unicode_utf8_next_get("\xFD\xBF\xBF\xBF\xBF\xBF", &ind) != 0x7FFFFFFF) || (ind != 6)); /* Other boundary conditions */ ind = 0; - fail_if((eina_unicode_utf8_next_get("\xED\x9F\xBF", &ind) != 0xD7FF) || + ck_assert((eina_unicode_utf8_next_get("\xED\x9F\xBF", &ind) != 0xD7FF) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xEE\x80\x80", &ind) != 0xE000) || + ck_assert((eina_unicode_utf8_next_get("\xEE\x80\x80", &ind) != 0xE000) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xEF\xBF\xBD", &ind) != 0xFFFD) || + ck_assert((eina_unicode_utf8_next_get("\xEF\xBF\xBD", &ind) != 0xFFFD) || (ind != 3)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF4\x8F\xBF\xBF", &ind) != 0x10FFFF) || + ck_assert((eina_unicode_utf8_next_get("\xF4\x8F\xBF\xBF", &ind) != 0x10FFFF) || (ind != 4)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF4\x90\x80\x80", &ind) != 0x110000) || + ck_assert((eina_unicode_utf8_next_get("\xF4\x90\x80\x80", &ind) != 0x110000) || (ind != 4)); /* Error cases */ /* Standalone continuation bytes */ ind = 0; - fail_if((eina_unicode_utf8_next_get("\x80", &ind) != 0xDC80) || + ck_assert((eina_unicode_utf8_next_get("\x80", &ind) != 0xDC80) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xBF", &ind) != 0xDCBF) || + ck_assert((eina_unicode_utf8_next_get("\xBF", &ind) != 0xDCBF) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\x80\xBF", &ind) != 0xDC80) || + ck_assert((eina_unicode_utf8_next_get("\x80\xBF", &ind) != 0xDC80) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xBF\x80", &ind) != 0xDCBF) || + ck_assert((eina_unicode_utf8_next_get("\xBF\x80", &ind) != 0xDCBF) || (ind != 1)); /* All possible continuation bytes */ for (ch = 0x80 ; ch <= 0xBF ; ch++) { char buf[] = {ch, 0}; ind = 0; - fail_if((eina_unicode_utf8_next_get(buf, &ind) != (0xDC00 | ch)) || + ck_assert((eina_unicode_utf8_next_get(buf, &ind) != (0xDC00 | ch)) || (ind != 1)); } @@ -446,9 +446,9 @@ EFL_START_TEST(eina_unicode_utf8) ind = 0; \ for (i = 0, ch = start ; ch <= end ; ch++) \ { \ - fail_if((eina_unicode_utf8_next_get(buf, &ind) != (0xDC00 | ch)) || \ + ck_assert((eina_unicode_utf8_next_get(buf, &ind) != (0xDC00 | ch)) || \ (ind != ++i)); \ - fail_if((eina_unicode_utf8_next_get(buf, &ind) != 0x20) || \ + ck_assert((eina_unicode_utf8_next_get(buf, &ind) != 0x20) || \ (ind != ++i)); \ } \ } \ @@ -482,13 +482,13 @@ EFL_START_TEST(eina_unicode_utf8) } \ buf[j] = 0; \ ind = 0; \ - fail_if( \ + ck_assert( \ (eina_unicode_utf8_next_get(buf, &ind) != (0xDC00 | first))); \ while ((val = eina_unicode_utf8_next_get(buf, &ind))) \ { \ - fail_if(val != (0xDC00 | conti)); \ + ck_assert(val != (0xDC00 | conti)); \ } \ - fail_if(ind != i); \ + ck_assert(ind != i); \ } \ } \ while (0) @@ -507,54 +507,54 @@ EFL_START_TEST(eina_unicode_utf8) /* Impossible bytes */ ind = 0; - fail_if((eina_unicode_utf8_next_get("\xFE", &ind) != 0xDCFE) || + ck_assert((eina_unicode_utf8_next_get("\xFE", &ind) != 0xDCFE) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xFF", &ind) != 0xDCFF) || + ck_assert((eina_unicode_utf8_next_get("\xFF", &ind) != 0xDCFF) || (ind != 1)); /* Overlong sequences */ ind = 0; - fail_if((eina_unicode_utf8_next_get("\xC0\xAF", &ind) != 0xDCC0) || + ck_assert((eina_unicode_utf8_next_get("\xC0\xAF", &ind) != 0xDCC0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xE0\x80\xAF", &ind) != 0xDCE0) || + ck_assert((eina_unicode_utf8_next_get("\xE0\x80\xAF", &ind) != 0xDCE0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF0\x80\x80\xAF", &ind) != 0xDCF0) || + ck_assert((eina_unicode_utf8_next_get("\xF0\x80\x80\xAF", &ind) != 0xDCF0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF8\x80\x80\x80\xAF", &ind) != 0xDCF8) || + ck_assert((eina_unicode_utf8_next_get("\xF8\x80\x80\x80\xAF", &ind) != 0xDCF8) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xFC\x80\x80\x80\x80\xAF", &ind) != 0xDCFC) || + ck_assert((eina_unicode_utf8_next_get("\xFC\x80\x80\x80\x80\xAF", &ind) != 0xDCFC) || (ind != 1)); /* Maximum overlong sequences */ ind = 0; - fail_if((eina_unicode_utf8_next_get("\xC1\xBF", &ind) != 0xDCC1) || + ck_assert((eina_unicode_utf8_next_get("\xC1\xBF", &ind) != 0xDCC1) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xE0\x9F\xBF", &ind) != 0xDCE0) || + ck_assert((eina_unicode_utf8_next_get("\xE0\x9F\xBF", &ind) != 0xDCE0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF0\x8F\xBF\xBF", &ind) != 0xDCF0) || + ck_assert((eina_unicode_utf8_next_get("\xF0\x8F\xBF\xBF", &ind) != 0xDCF0) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xF8\x87\xBF\xBF\xBF", &ind) != 0xDCF8) || + ck_assert((eina_unicode_utf8_next_get("\xF8\x87\xBF\xBF\xBF", &ind) != 0xDCF8) || (ind != 1)); ind = 0; - fail_if((eina_unicode_utf8_next_get("\xFC\x83\xBF\xBF\xBF\xBF", &ind) != 0xDCFC) || + ck_assert((eina_unicode_utf8_next_get("\xFC\x83\xBF\xBF\xBF\xBF", &ind) != 0xDCFC) || (ind != 1)); /* Add some more error cases here */ /* Just to cover prev/len. General utf-8 parsing was covered above */ - fail_if(eina_unicode_utf8_get_len("\xF4\x90\x80\x80\xF4\x8F\xBF\xBF") != 2); + ck_assert(eina_unicode_utf8_get_len("\xF4\x90\x80\x80\xF4\x8F\xBF\xBF") != 2); ind = 0; - fail_if((eina_unicode_utf8_get_prev("\xED\x9F\xBF", &ind) != 0xD7FF) || + ck_assert((eina_unicode_utf8_get_prev("\xED\x9F\xBF", &ind) != 0xD7FF) || (ind != 0)); ind = 3; - fail_if((eina_unicode_utf8_get_prev("\xED\x9F\xBF", &ind) != 0x00) || + ck_assert((eina_unicode_utf8_get_prev("\xED\x9F\xBF", &ind) != 0x00) || (ind != 0)); } @@ -576,11 +576,11 @@ EFL_START_TEST(eina_unicode_utf8_conversion) uni_out = eina_unicode_utf8_to_unicode(c_in, &len); - fail_if((len != 9) || eina_unicode_strcmp(uni_in, uni_out)); + ck_assert((len != 9) || eina_unicode_strcmp(uni_in, uni_out)); free(uni_out); c_out = eina_unicode_unicode_to_utf8(uni_in, &len); - fail_if((len != 24) || strcmp(c_in, c_out)); + ck_assert((len != 24) || strcmp(c_in, c_out)); free(c_out); /* Range conversion */ diff --git a/src/tests/eina/eina_test_ustringshare.c b/src/tests/eina/eina_test_ustringshare.c index 9e9dd3ab8e..a7b509b365 100644 --- a/src/tests/eina/eina_test_ustringshare.c +++ b/src/tests/eina/eina_test_ustringshare.c @@ -41,16 +41,16 @@ EFL_START_TEST(eina_ustringshare_simple) t0 = eina_ustringshare_add(TEST0); t1 = eina_ustringshare_add(TEST1); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(eina_unicode_strcmp(t0, TEST0) != 0); - fail_if(eina_unicode_strcmp(t1, TEST1) != 0); - fail_if((int)eina_unicode_strlen(TEST0) != eina_ustringshare_strlen(t0)); - fail_if((int)eina_unicode_strlen(TEST1) != eina_ustringshare_strlen(t1)); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(eina_unicode_strcmp(t0, TEST0) != 0); + ck_assert(eina_unicode_strcmp(t1, TEST1) != 0); + ck_assert((int)eina_unicode_strlen(TEST0) != eina_ustringshare_strlen(t0)); + ck_assert((int)eina_unicode_strlen(TEST1) != eina_ustringshare_strlen(t1)); t0 = eina_ustringshare_ref(t0); - fail_if(t0 == NULL); - fail_if((int)strlen((char*)TEST0) != eina_stringshare_strlen((const char*)t0)); + ck_assert(t0 == NULL); + ck_assert((int)strlen((char*)TEST0) != eina_stringshare_strlen((const char*)t0)); eina_ustringshare_del(t0); eina_ustringshare_del(t0); @@ -69,13 +69,13 @@ EFL_START_TEST(eina_ustringshare_test_share) t0 = eina_ustringshare_add(TEST0); t1 = eina_ustringshare_add(TEST0); - fail_if(t0 == NULL); - fail_if(t1 == NULL); - fail_if(eina_unicode_strcmp(t0, TEST0) != 0); - fail_if(eina_unicode_strcmp(t1, TEST0) != 0); - fail_if(t0 != t1); - fail_if((int)eina_unicode_strlen(TEST0) != eina_ustringshare_strlen(t0)); - fail_if((int)eina_unicode_strlen(TEST0) != eina_ustringshare_strlen(t1)); + ck_assert(t0 == NULL); + ck_assert(t1 == NULL); + ck_assert(eina_unicode_strcmp(t0, TEST0) != 0); + ck_assert(eina_unicode_strcmp(t1, TEST0) != 0); + ck_assert(t0 != t1); + ck_assert((int)eina_unicode_strlen(TEST0) != eina_ustringshare_strlen(t0)); + ck_assert((int)eina_unicode_strlen(TEST0) != eina_ustringshare_strlen(t1)); eina_ustringshare_del(t0); eina_ustringshare_del(t1); @@ -98,8 +98,8 @@ EFL_START_TEST(eina_ustringshare_putstuff) build[7] = i; build[8] = 0; tmp = eina_ustringshare_add(build); - fail_if(tmp != eina_ustringshare_add(build)); - fail_if((int)eina_unicode_strlen(build) != eina_ustringshare_strlen(tmp)); + ck_assert(tmp != eina_ustringshare_add(build)); + ck_assert((int)eina_unicode_strlen(build) != eina_ustringshare_strlen(tmp)); } } diff --git a/src/tests/eina/eina_test_value.c b/src/tests/eina/eina_test_value.c index 7d9e27e29a..897c711823 100644 --- a/src/tests/eina/eina_test_value.c +++ b/src/tests/eina/eina_test_value.c @@ -49,139 +49,139 @@ EFL_START_TEST(eina_value_test_simple) value = eina_value_new(EINA_VALUE_TYPE_CHAR); - fail_unless(value != NULL); - fail_unless(eina_value_set(value, 'x')); - fail_unless(eina_value_get(value, &c)); - fail_unless(c == 'x'); - fail_unless(eina_value_char_get(value, &c)); - fail_if(eina_value_double_get(value, &d)); - fail_unless(eina_value_int64_convert(value, &i64)); - fail_unless(i64 == 'x'); - fail_unless(c == 'x'); + ck_assert(value != NULL); + ck_assert(eina_value_set(value, 'x')); + ck_assert(eina_value_get(value, &c)); + ck_assert(c == 'x'); + ck_assert(eina_value_char_get(value, &c)); + ck_assert(eina_value_double_get(value, &d)); + ck_assert(eina_value_int64_convert(value, &i64)); + ck_assert(i64 == 'x'); + ck_assert(c == 'x'); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_set(value, 300)); - fail_unless(eina_value_get(value, &s)); - fail_unless(s == 300); - fail_unless(eina_value_short_get(value, &s)); - fail_if(eina_value_char_get(value, &c)); - fail_unless(eina_value_int_convert(value, &i)); - fail_unless(i == 300); - fail_unless(s == 300); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_set(value, 300)); + ck_assert(eina_value_get(value, &s)); + ck_assert(s == 300); + ck_assert(eina_value_short_get(value, &s)); + ck_assert(eina_value_char_get(value, &c)); + ck_assert(eina_value_int_convert(value, &i)); + ck_assert(i == 300); + ck_assert(s == 300); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_set(value, -12345)); - fail_unless(eina_value_get(value, &i)); - fail_unless(i == -12345); - fail_unless(eina_value_int_get(value, &i)); - fail_if(eina_value_short_get(value, &s)); - fail_unless(eina_value_long_convert(value, &l)); - fail_unless(l == -12345); - fail_unless(i == -12345); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_set(value, -12345)); + ck_assert(eina_value_get(value, &i)); + ck_assert(i == -12345); + ck_assert(eina_value_int_get(value, &i)); + ck_assert(eina_value_short_get(value, &s)); + ck_assert(eina_value_long_convert(value, &l)); + ck_assert(l == -12345); + ck_assert(i == -12345); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_set(value, 0xb33f)); - fail_unless(eina_value_get(value, &l)); - fail_unless(l == 0xb33f); - fail_unless(eina_value_long_get(value, &l)); - fail_if(eina_value_int_get(value, &i)); - fail_unless(eina_value_int_convert(value, &i)); - fail_unless(i == 0xb33f); - fail_unless(l == 0xb33f); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_set(value, 0xb33f)); + ck_assert(eina_value_get(value, &l)); + ck_assert(l == 0xb33f); + ck_assert(eina_value_long_get(value, &l)); + ck_assert(eina_value_int_get(value, &i)); + ck_assert(eina_value_int_convert(value, &i)); + ck_assert(i == 0xb33f); + ck_assert(l == 0xb33f); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_set(value, 0x0011223344556677)); - fail_unless(eina_value_get(value, &i64)); - fail_unless(i64 == 0x0011223344556677); - fail_unless(eina_value_int64_get(value, &i64)); - fail_if(eina_value_long_get(value, &l)); - fail_unless(eina_value_long_convert(value, &l)); - fail_unless(l == (long)0x0011223344556677); - fail_unless(i64 == 0x0011223344556677); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_set(value, 0x0011223344556677)); + ck_assert(eina_value_get(value, &i64)); + ck_assert(i64 == 0x0011223344556677); + ck_assert(eina_value_int64_get(value, &i64)); + ck_assert(eina_value_long_get(value, &l)); + ck_assert(eina_value_long_convert(value, &l)); + ck_assert(l == (long)0x0011223344556677); + ck_assert(i64 == 0x0011223344556677); eina_value_flush(value); /* unsigned: */ - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_set(value, 200)); - fail_unless(eina_value_get(value, &uc)); - fail_unless(uc == 200); - fail_unless(eina_value_uchar_get(value, &uc)); - fail_if(eina_value_int64_get(value, &i64)); - fail_unless(eina_value_uint64_convert(value, &u64)); - fail_unless(u64 == 200); - fail_unless(uc == 200); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_set(value, 200)); + ck_assert(eina_value_get(value, &uc)); + ck_assert(uc == 200); + ck_assert(eina_value_uchar_get(value, &uc)); + ck_assert(eina_value_int64_get(value, &i64)); + ck_assert(eina_value_uint64_convert(value, &u64)); + ck_assert(u64 == 200); + ck_assert(uc == 200); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_set(value, 65535)); - fail_unless(eina_value_get(value, &us)); - fail_unless(us == 65535); - fail_unless(eina_value_ushort_get(value, &us)); - fail_if(eina_value_uchar_get(value, &uc)); - fail_unless(eina_value_uint_convert(value, &ui)); - fail_unless(ui == 65535); - fail_unless(us == 65535); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_set(value, 65535)); + ck_assert(eina_value_get(value, &us)); + ck_assert(us == 65535); + ck_assert(eina_value_ushort_get(value, &us)); + ck_assert(eina_value_uchar_get(value, &uc)); + ck_assert(eina_value_uint_convert(value, &ui)); + ck_assert(ui == 65535); + ck_assert(us == 65535); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_set(value, 4000000000U)); - fail_unless(eina_value_get(value, &ui)); - fail_unless(ui == 4000000000U); - fail_unless(eina_value_uint_get(value, &ui)); - fail_if(eina_value_ushort_get(value, &us)); - fail_unless(eina_value_ulong_convert(value, &ul)); - fail_unless(ul == 4000000000U); - fail_unless(ui == 4000000000U); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_set(value, 4000000000U)); + ck_assert(eina_value_get(value, &ui)); + ck_assert(ui == 4000000000U); + ck_assert(eina_value_uint_get(value, &ui)); + ck_assert(eina_value_ushort_get(value, &us)); + ck_assert(eina_value_ulong_convert(value, &ul)); + ck_assert(ul == 4000000000U); + ck_assert(ui == 4000000000U); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_set(value, 3000000001UL)); - fail_unless(eina_value_get(value, &ul)); - fail_unless(ul == 3000000001UL); - fail_unless(eina_value_ulong_get(value, &ul)); - fail_if(eina_value_uint_get(value, &ui)); - fail_unless(eina_value_uint64_convert(value, &u64)); - fail_unless(u64 == 3000000001UL); - fail_unless(ul == 3000000001UL); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_set(value, 3000000001UL)); + ck_assert(eina_value_get(value, &ul)); + ck_assert(ul == 3000000001UL); + ck_assert(eina_value_ulong_get(value, &ul)); + ck_assert(eina_value_uint_get(value, &ui)); + ck_assert(eina_value_uint64_convert(value, &u64)); + ck_assert(u64 == 3000000001UL); + ck_assert(ul == 3000000001UL); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_set(value, 0x1122334455667788)); - fail_unless(eina_value_get(value, &u64)); - fail_unless(u64 == 0x1122334455667788); - fail_unless(eina_value_uint64_get(value, &u64)); - fail_if(eina_value_ulong_get(value, &ul)); - fail_unless(eina_value_ulong_convert(value, &ul)); - fail_unless(ul == (unsigned long)0x1122334455667788); - fail_unless(u64 == 0x1122334455667788); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_set(value, 0x1122334455667788)); + ck_assert(eina_value_get(value, &u64)); + ck_assert(u64 == 0x1122334455667788); + ck_assert(eina_value_uint64_get(value, &u64)); + ck_assert(eina_value_ulong_get(value, &ul)); + ck_assert(eina_value_ulong_convert(value, &ul)); + ck_assert(ul == (unsigned long)0x1122334455667788); + ck_assert(u64 == 0x1122334455667788); eina_value_flush(value); /* floating point */ - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_set(value, 0.1234)); - fail_unless(eina_value_get(value, &f)); - fail_unless(CHECK_FP(0.1234, f)); - fail_unless(eina_value_float_get(value, &f)); - fail_if(eina_value_uint64_get(value, &u64)); - fail_unless(eina_value_double_convert(value, &d)); - fail_unless(CHECK_FP(0.1234, d)); - fail_unless(CHECK_FP(0.1234, f)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_set(value, 0.1234)); + ck_assert(eina_value_get(value, &f)); + ck_assert(CHECK_FP(0.1234, f)); + ck_assert(eina_value_float_get(value, &f)); + ck_assert(eina_value_uint64_get(value, &u64)); + ck_assert(eina_value_double_convert(value, &d)); + ck_assert(CHECK_FP(0.1234, d)); + ck_assert(CHECK_FP(0.1234, f)); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_set(value, 34567.8)); - fail_unless(eina_value_get(value, &d)); - fail_unless(CHECK_FP(34567.8, d)); - fail_unless(eina_value_double_get(value, &d)); - fail_if(eina_value_float_get(value, &f)); - fail_unless(eina_value_float_convert(value, &f)); - fail_unless(CHECK_FP(34567.8, d)); - fail_unless(CHECK_FP(34567.8, f)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_set(value, 34567.8)); + ck_assert(eina_value_get(value, &d)); + ck_assert(CHECK_FP(34567.8, d)); + ck_assert(eina_value_double_get(value, &d)); + ck_assert(eina_value_float_get(value, &f)); + ck_assert(eina_value_float_convert(value, &f)); + ck_assert(CHECK_FP(34567.8, d)); + ck_assert(CHECK_FP(34567.8, f)); eina_value_flush(value); eina_value_free(value); @@ -194,296 +194,296 @@ EFL_START_TEST(eina_value_test_compare) a = eina_value_new(EINA_VALUE_TYPE_CHAR); - fail_unless(a != NULL); + ck_assert(a != NULL); b = eina_value_new(EINA_VALUE_TYPE_CHAR); - fail_unless(b != NULL); + ck_assert(b != NULL); - fail_unless(eina_value_set(a, 123)); - fail_unless(eina_value_set(b, 123)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, -10)); - fail_unless(eina_value_set(b, 123)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 123)); - fail_unless(eina_value_set(b, 10)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_set(a, 123)); + ck_assert(eina_value_set(b, 123)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, -10)); + ck_assert(eina_value_set(b, 123)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 123)); + ck_assert(eina_value_set(b, 10)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_set(a, 1230)); - fail_unless(eina_value_set(b, 1230)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, -100)); - fail_unless(eina_value_set(b, 1230)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 1230)); - fail_unless(eina_value_set(b, -100)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_set(a, 1230)); + ck_assert(eina_value_set(b, 1230)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, -100)); + ck_assert(eina_value_set(b, 1230)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 1230)); + ck_assert(eina_value_set(b, -100)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_set(a, 300000)); - fail_unless(eina_value_set(b, 300000)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, -100)); - fail_unless(eina_value_set(b, 300000)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 300000)); - fail_unless(eina_value_set(b, -100)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_set(a, 300000)); + ck_assert(eina_value_set(b, 300000)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, -100)); + ck_assert(eina_value_set(b, 300000)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 300000)); + ck_assert(eina_value_set(b, -100)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_set(a, 300000L)); - fail_unless(eina_value_set(b, 300000L)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, -100L)); - fail_unless(eina_value_set(b, 300000L)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 300000L)); - fail_unless(eina_value_set(b, -100L)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_set(a, 300000L)); + ck_assert(eina_value_set(b, 300000L)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, -100L)); + ck_assert(eina_value_set(b, 300000L)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 300000L)); + ck_assert(eina_value_set(b, -100L)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_set(a, (int64_t)800000)); - fail_unless(eina_value_set(b, (int64_t)800000)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, (int64_t)-100)); - fail_unless(eina_value_set(b, (int64_t)8000000)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, (int64_t)8000000)); - fail_unless(eina_value_set(b, (int64_t)-100)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_set(a, (int64_t)800000)); + ck_assert(eina_value_set(b, (int64_t)800000)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, (int64_t)-100)); + ck_assert(eina_value_set(b, (int64_t)8000000)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, (int64_t)8000000)); + ck_assert(eina_value_set(b, (int64_t)-100)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_set(a, 123)); - fail_unless(eina_value_set(b, 123)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, 10)); - fail_unless(eina_value_set(b, 123)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 123)); - fail_unless(eina_value_set(b, 10)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_set(a, 123)); + ck_assert(eina_value_set(b, 123)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, 10)); + ck_assert(eina_value_set(b, 123)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 123)); + ck_assert(eina_value_set(b, 10)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_set(a, 1230)); - fail_unless(eina_value_set(b, 1230)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, 100)); - fail_unless(eina_value_set(b, 1230)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 1230)); - fail_unless(eina_value_set(b, 100)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_set(a, 1230)); + ck_assert(eina_value_set(b, 1230)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, 100)); + ck_assert(eina_value_set(b, 1230)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 1230)); + ck_assert(eina_value_set(b, 100)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_set(a, 300000)); - fail_unless(eina_value_set(b, 300000)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, 100)); - fail_unless(eina_value_set(b, 300000)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 300000)); - fail_unless(eina_value_set(b, 100)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_set(a, 300000)); + ck_assert(eina_value_set(b, 300000)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, 100)); + ck_assert(eina_value_set(b, 300000)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 300000)); + ck_assert(eina_value_set(b, 100)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_set(a, 300000UL)); - fail_unless(eina_value_set(b, 300000UL)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, 100UL)); - fail_unless(eina_value_set(b, 300000UL)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, 300000UL)); - fail_unless(eina_value_set(b, 100UL)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_set(a, 300000UL)); + ck_assert(eina_value_set(b, 300000UL)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, 100UL)); + ck_assert(eina_value_set(b, 300000UL)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, 300000UL)); + ck_assert(eina_value_set(b, 100UL)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_set(a, (uint64_t)8000000)); - fail_unless(eina_value_set(b, (uint64_t)8000000)); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, (uint64_t)100)); - fail_unless(eina_value_set(b, (uint64_t)8000000)); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, (uint64_t)8000000)); - fail_unless(eina_value_set(b, (uint64_t)100)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_set(a, (uint64_t)8000000)); + ck_assert(eina_value_set(b, (uint64_t)8000000)); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, (uint64_t)100)); + ck_assert(eina_value_set(b, (uint64_t)8000000)); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, (uint64_t)8000000)); + ck_assert(eina_value_set(b, (uint64_t)100)); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_setup(a, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_setup(b, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_set(a, "aaa")); - fail_unless(eina_value_set(b, "aaa")); - fail_unless(eina_value_compare(a, b) == 0); - fail_unless(eina_value_set(a, "abc")); - fail_unless(eina_value_set(b, "acd")); - fail_unless(eina_value_compare(a, b) < 0); - fail_unless(eina_value_set(a, "acd")); - fail_unless(eina_value_set(b, "abc")); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_setup(a, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(b, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_set(a, "aaa")); + ck_assert(eina_value_set(b, "aaa")); + ck_assert(eina_value_compare(a, b) == 0); + ck_assert(eina_value_set(a, "abc")); + ck_assert(eina_value_set(b, "acd")); + ck_assert(eina_value_compare(a, b) < 0); + ck_assert(eina_value_set(a, "acd")); + ck_assert(eina_value_set(b, "abc")); + ck_assert(eina_value_compare(a, b) > 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_array_setup(a, EINA_VALUE_TYPE_CHAR, 0)); - fail_unless(eina_value_array_setup(b, EINA_VALUE_TYPE_CHAR, 0)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_array_setup(a, EINA_VALUE_TYPE_CHAR, 0)); + ck_assert(eina_value_array_setup(b, EINA_VALUE_TYPE_CHAR, 0)); + ck_assert(eina_value_compare(a, b) == 0); - fail_unless(eina_value_array_append(a, 1)); - fail_unless(eina_value_array_append(a, 2)); - fail_unless(eina_value_array_append(a, 3)); + ck_assert(eina_value_array_append(a, 1)); + ck_assert(eina_value_array_append(a, 2)); + ck_assert(eina_value_array_append(a, 3)); - fail_unless(eina_value_array_append(b, 1)); - fail_unless(eina_value_array_append(b, 2)); - fail_unless(eina_value_array_append(b, 3)); + ck_assert(eina_value_array_append(b, 1)); + ck_assert(eina_value_array_append(b, 2)); + ck_assert(eina_value_array_append(b, 3)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_compare(a, b) == 0); - fail_unless(eina_value_array_set(a, 0, 0)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_array_set(a, 0, 0)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_array_set(a, 0, 10)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_array_set(a, 0, 10)); + ck_assert(eina_value_compare(a, b) > 0); - fail_unless(eina_value_array_set(a, 0, 1)); + ck_assert(eina_value_array_set(a, 0, 1)); - fail_unless(eina_value_array_set(b, 0, 0)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_array_set(b, 0, 0)); + ck_assert(eina_value_compare(a, b) > 0); - fail_unless(eina_value_array_set(b, 0, 10)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_array_set(b, 0, 10)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_array_set(b, 0, 1)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_array_set(b, 0, 1)); + ck_assert(eina_value_compare(a, b) == 0); /* bigger arrays are greater */ - fail_unless(eina_value_array_append(b, 0)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_array_append(b, 0)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_array_append(a, 0)); - fail_unless(eina_value_array_append(a, 0)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_array_append(a, 0)); + ck_assert(eina_value_array_append(a, 0)); + ck_assert(eina_value_compare(a, b) > 0); /* bigger arrays are greater, unless an element says otherwise */ - fail_unless(eina_value_array_set(b, 0, 10)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_array_set(b, 0, 10)); + ck_assert(eina_value_compare(a, b) < 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_list_setup(a, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_list_setup(b, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_list_setup(a, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_list_setup(b, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_compare(a, b) == 0); - fail_unless(eina_value_list_append(a, 1)); - fail_unless(eina_value_list_append(a, 2)); - fail_unless(eina_value_list_append(a, 3)); + ck_assert(eina_value_list_append(a, 1)); + ck_assert(eina_value_list_append(a, 2)); + ck_assert(eina_value_list_append(a, 3)); - fail_unless(eina_value_list_append(b, 1)); - fail_unless(eina_value_list_append(b, 2)); - fail_unless(eina_value_list_append(b, 3)); + ck_assert(eina_value_list_append(b, 1)); + ck_assert(eina_value_list_append(b, 2)); + ck_assert(eina_value_list_append(b, 3)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_compare(a, b) == 0); - fail_unless(eina_value_list_set(a, 0, 0)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_list_set(a, 0, 0)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_list_set(a, 0, 10)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_list_set(a, 0, 10)); + ck_assert(eina_value_compare(a, b) > 0); - fail_unless(eina_value_list_set(a, 0, 1)); + ck_assert(eina_value_list_set(a, 0, 1)); - fail_unless(eina_value_list_set(b, 0, 0)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_list_set(b, 0, 0)); + ck_assert(eina_value_compare(a, b) > 0); - fail_unless(eina_value_list_set(b, 0, 10)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_list_set(b, 0, 10)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_list_set(b, 0, 1)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_list_set(b, 0, 1)); + ck_assert(eina_value_compare(a, b) == 0); /* bigger lists are greater */ - fail_unless(eina_value_list_append(b, 0)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_list_append(b, 0)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_list_append(a, 0)); - fail_unless(eina_value_list_append(a, 0)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_list_append(a, 0)); + ck_assert(eina_value_list_append(a, 0)); + ck_assert(eina_value_compare(a, b) > 0); /* bigger lists are greater, unless an element says otherwise */ - fail_unless(eina_value_list_set(b, 0, 10)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_list_set(b, 0, 10)); + ck_assert(eina_value_compare(a, b) < 0); eina_value_flush(a); eina_value_flush(b); - fail_unless(eina_value_hash_setup(a, EINA_VALUE_TYPE_CHAR, 0)); - fail_unless(eina_value_hash_setup(b, EINA_VALUE_TYPE_CHAR, 0)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_hash_setup(a, EINA_VALUE_TYPE_CHAR, 0)); + ck_assert(eina_value_hash_setup(b, EINA_VALUE_TYPE_CHAR, 0)); + ck_assert(eina_value_compare(a, b) == 0); - fail_unless(eina_value_hash_set(a, "abc", 1)); - fail_unless(eina_value_hash_set(a, "xyz", 2)); - fail_unless(eina_value_hash_set(a, "hello", 3)); + ck_assert(eina_value_hash_set(a, "abc", 1)); + ck_assert(eina_value_hash_set(a, "xyz", 2)); + ck_assert(eina_value_hash_set(a, "hello", 3)); - fail_unless(eina_value_hash_set(b, "abc", 1)); - fail_unless(eina_value_hash_set(b, "xyz", 2)); - fail_unless(eina_value_hash_set(b, "hello", 3)); + ck_assert(eina_value_hash_set(b, "abc", 1)); + ck_assert(eina_value_hash_set(b, "xyz", 2)); + ck_assert(eina_value_hash_set(b, "hello", 3)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_compare(a, b) == 0); - fail_unless(eina_value_hash_set(a, "abc", 0)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_hash_set(a, "abc", 0)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_hash_set(a, "abc", 10)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_hash_set(a, "abc", 10)); + ck_assert(eina_value_compare(a, b) > 0); - fail_unless(eina_value_hash_set(a, "abc", 1)); + ck_assert(eina_value_hash_set(a, "abc", 1)); - fail_unless(eina_value_hash_set(b, "abc", 0)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_hash_set(b, "abc", 0)); + ck_assert(eina_value_compare(a, b) > 0); - fail_unless(eina_value_hash_set(b, "abc", 10)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_hash_set(b, "abc", 10)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_hash_set(b, "abc", 1)); - fail_unless(eina_value_compare(a, b) == 0); + ck_assert(eina_value_hash_set(b, "abc", 1)); + ck_assert(eina_value_compare(a, b) == 0); /* bigger hashs are greater */ - fail_unless(eina_value_hash_set(b,"newkey", 0)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_hash_set(b,"newkey", 0)); + ck_assert(eina_value_compare(a, b) < 0); - fail_unless(eina_value_hash_set(a, "newkey", 0)); - fail_unless(eina_value_hash_set(a, "onemorenewkey", 0)); - fail_unless(eina_value_compare(a, b) > 0); + ck_assert(eina_value_hash_set(a, "newkey", 0)); + ck_assert(eina_value_hash_set(a, "onemorenewkey", 0)); + ck_assert(eina_value_compare(a, b) > 0); /* bigger hashs are greater, unless an element says otherwise */ - fail_unless(eina_value_hash_set(b, "abc", 10)); - fail_unless(eina_value_compare(a, b) < 0); + ck_assert(eina_value_hash_set(b, "abc", 10)); + ck_assert(eina_value_compare(a, b) < 0); eina_value_free(a); eina_value_free(b); @@ -497,20 +497,20 @@ EFL_START_TEST(eina_value_test_string) value = eina_value_new(EINA_VALUE_TYPE_STRING); - fail_unless(value != NULL); - fail_unless(eina_value_set(value, "hello world!")); - fail_unless(eina_value_get(value, &s)); + ck_assert(value != NULL); + ck_assert(eina_value_set(value, "hello world!")); + ck_assert(eina_value_get(value, &s)); ck_assert_str_eq(s, "hello world!"); - fail_unless(eina_value_set(value, "eina-value")); - fail_unless(eina_value_get(value, &s)); + ck_assert(eina_value_set(value, "eina-value")); + ck_assert(eina_value_get(value, &s)); ck_assert_str_eq(s, "eina-value"); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_set(value, "profusion")); - fail_unless(eina_value_get(value, &s)); + ck_assert(eina_value_set(value, "profusion")); + ck_assert(eina_value_get(value, &s)); ck_assert_str_eq(s, "profusion"); eina_value_free(value); @@ -536,110 +536,110 @@ EFL_START_TEST(eina_value_test_pvariant) value = eina_value_new(EINA_VALUE_TYPE_CHAR); - fail_unless(value != NULL); + ck_assert(value != NULL); in_c = 'x'; - fail_unless(eina_value_pset(value, &in_c)); - fail_unless(eina_value_pget(value, &c)); - fail_unless(c == 'x'); + ck_assert(eina_value_pset(value, &in_c)); + ck_assert(eina_value_pget(value, &c)); + ck_assert(c == 'x'); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_SHORT)); in_s = 300; - fail_unless(eina_value_pset(value, &in_s)); - fail_unless(eina_value_pget(value, &s)); - fail_unless(s == 300); + ck_assert(eina_value_pset(value, &in_s)); + ck_assert(eina_value_pget(value, &s)); + ck_assert(s == 300); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_INT)); in_i = -12345; - fail_unless(eina_value_pset(value, &in_i)); - fail_unless(eina_value_pget(value, &i)); - fail_unless(i == -12345); + ck_assert(eina_value_pset(value, &in_i)); + ck_assert(eina_value_pget(value, &i)); + ck_assert(i == -12345); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_LONG)); in_l = 0xb33f; - fail_unless(eina_value_pset(value, &in_l)); - fail_unless(eina_value_pget(value, &l)); - fail_unless(l == 0xb33f); + ck_assert(eina_value_pset(value, &in_l)); + ck_assert(eina_value_pget(value, &l)); + ck_assert(l == 0xb33f); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_INT64)); in_i64 = 0x0011223344556677; - fail_unless(eina_value_pset(value, &in_i64)); - fail_unless(eina_value_pget(value, &i64)); - fail_unless(i64 == 0x0011223344556677); + ck_assert(eina_value_pset(value, &in_i64)); + ck_assert(eina_value_pget(value, &i64)); + ck_assert(i64 == 0x0011223344556677); eina_value_flush(value); /* unsigned: */ - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UCHAR)); in_uc = 200; - fail_unless(eina_value_pset(value, &in_uc)); - fail_unless(eina_value_pget(value, &uc)); - fail_unless(uc == 200); + ck_assert(eina_value_pset(value, &in_uc)); + ck_assert(eina_value_pget(value, &uc)); + ck_assert(uc == 200); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_USHORT)); in_us = 65535; - fail_unless(eina_value_pset(value, &in_us)); - fail_unless(eina_value_pget(value, &us)); - fail_unless(us == 65535); + ck_assert(eina_value_pset(value, &in_us)); + ck_assert(eina_value_pget(value, &us)); + ck_assert(us == 65535); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UINT)); in_ui = 4000000000U; - fail_unless(eina_value_pset(value, &in_ui)); - fail_unless(eina_value_pget(value, &ui)); - fail_unless(ui == 4000000000U); + ck_assert(eina_value_pset(value, &in_ui)); + ck_assert(eina_value_pget(value, &ui)); + ck_assert(ui == 4000000000U); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); in_ul = 3000000001UL; - fail_unless(eina_value_pset(value, &in_ul)); - fail_unless(eina_value_pget(value, &ul)); - fail_unless(ul == 3000000001UL); + ck_assert(eina_value_pset(value, &in_ul)); + ck_assert(eina_value_pget(value, &ul)); + ck_assert(ul == 3000000001UL); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UINT64)); in_u64 = 0x1122334455667788; - fail_unless(eina_value_pset(value, &in_u64)); - fail_unless(eina_value_pget(value, &u64)); - fail_unless(u64 == 0x1122334455667788); + ck_assert(eina_value_pset(value, &in_u64)); + ck_assert(eina_value_pget(value, &u64)); + ck_assert(u64 == 0x1122334455667788); eina_value_flush(value); /* floating point */ - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_FLOAT)); in_f = 0.1234; - fail_unless(eina_value_pset(value, &in_f)); - fail_unless(eina_value_pget(value, &f)); - fail_unless(CHECK_FP(0.1234, f)); + ck_assert(eina_value_pset(value, &in_f)); + ck_assert(eina_value_pget(value, &f)); + ck_assert(CHECK_FP(0.1234, f)); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_DOUBLE)); in_d = 34567.8; - fail_unless(eina_value_pset(value, &in_d)); - fail_unless(eina_value_pget(value, &d)); - fail_unless(CHECK_FP(34567.8, d)); + ck_assert(eina_value_pset(value, &in_d)); + ck_assert(eina_value_pget(value, &d)); + ck_assert(CHECK_FP(34567.8, d)); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); in_str = "hello world!"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "hello world!"); in_str = "eina-value"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "eina-value"); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); in_str = "profusion"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "profusion"); eina_value_free(value); @@ -667,181 +667,181 @@ EFL_START_TEST(eina_value_test_to_string) value = eina_value_new(EINA_VALUE_TYPE_CHAR); - fail_unless(value != NULL); + ck_assert(value != NULL); in_c = 'x'; - fail_unless(eina_value_pset(value, &in_c)); - fail_unless(eina_value_pget(value, &c)); - fail_unless(c == 'x'); + ck_assert(eina_value_pset(value, &in_c)); + ck_assert(eina_value_pget(value, &c)); + ck_assert(c == 'x'); snprintf(buf, sizeof(buf), "%hhd", in_c); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_SHORT)); in_s = 300; - fail_unless(eina_value_pset(value, &in_s)); - fail_unless(eina_value_pget(value, &s)); - fail_unless(s == 300); + ck_assert(eina_value_pset(value, &in_s)); + ck_assert(eina_value_pget(value, &s)); + ck_assert(s == 300); snprintf(buf, sizeof(buf), "%hd", in_s); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_INT)); in_i = -12345; - fail_unless(eina_value_pset(value, &in_i)); - fail_unless(eina_value_pget(value, &i)); - fail_unless(i == -12345); + ck_assert(eina_value_pset(value, &in_i)); + ck_assert(eina_value_pget(value, &i)); + ck_assert(i == -12345); snprintf(buf, sizeof(buf), "%d", in_i); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_LONG)); in_l = 0xb33f; - fail_unless(eina_value_pset(value, &in_l)); - fail_unless(eina_value_pget(value, &l)); - fail_unless(l == 0xb33f); + ck_assert(eina_value_pset(value, &in_l)); + ck_assert(eina_value_pget(value, &l)); + ck_assert(l == 0xb33f); snprintf(buf, sizeof(buf), "%ld", in_l); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_INT64)); in_i64 = 0x0011223344556677; - fail_unless(eina_value_pset(value, &in_i64)); - fail_unless(eina_value_pget(value, &i64)); - fail_unless(i64 == 0x0011223344556677); + ck_assert(eina_value_pset(value, &in_i64)); + ck_assert(eina_value_pget(value, &i64)); + ck_assert(i64 == 0x0011223344556677); snprintf(buf, sizeof(buf), "%"PRId64, in_i64); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); /* unsigned: */ - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UCHAR)); in_uc = 200; - fail_unless(eina_value_pset(value, &in_uc)); - fail_unless(eina_value_pget(value, &uc)); - fail_unless(uc == 200); + ck_assert(eina_value_pset(value, &in_uc)); + ck_assert(eina_value_pget(value, &uc)); + ck_assert(uc == 200); snprintf(buf, sizeof(buf), "%hhu", in_uc); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_USHORT)); in_us = 65535; - fail_unless(eina_value_pset(value, &in_us)); - fail_unless(eina_value_pget(value, &us)); - fail_unless(us == 65535); + ck_assert(eina_value_pset(value, &in_us)); + ck_assert(eina_value_pget(value, &us)); + ck_assert(us == 65535); snprintf(buf, sizeof(buf), "%hu", in_us); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UINT)); in_ui = 4000000000U; - fail_unless(eina_value_pset(value, &in_ui)); - fail_unless(eina_value_pget(value, &ui)); - fail_unless(ui == 4000000000U); + ck_assert(eina_value_pset(value, &in_ui)); + ck_assert(eina_value_pget(value, &ui)); + ck_assert(ui == 4000000000U); snprintf(buf, sizeof(buf), "%u", in_ui); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); in_ul = 3000000001UL; - fail_unless(eina_value_pset(value, &in_ul)); - fail_unless(eina_value_pget(value, &ul)); - fail_unless(ul == 3000000001UL); + ck_assert(eina_value_pset(value, &in_ul)); + ck_assert(eina_value_pget(value, &ul)); + ck_assert(ul == 3000000001UL); snprintf(buf, sizeof(buf), "%lu", in_ul); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_UINT64)); in_u64 = 0x1122334455667788; - fail_unless(eina_value_pset(value, &in_u64)); - fail_unless(eina_value_pget(value, &u64)); - fail_unless(u64 == 0x1122334455667788); + ck_assert(eina_value_pset(value, &in_u64)); + ck_assert(eina_value_pget(value, &u64)); + ck_assert(u64 == 0x1122334455667788); snprintf(buf, sizeof(buf), "%"PRIu64, in_u64); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); free(out); eina_value_flush(value); /* floating point */ - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_FLOAT)); in_f = 0.1234; - fail_unless(eina_value_pset(value, &in_f)); - fail_unless(eina_value_pget(value, &f)); - fail_unless(CHECK_FP(0.1234, f)); + ck_assert(eina_value_pset(value, &in_f)); + ck_assert(eina_value_pget(value, &f)); + ck_assert(CHECK_FP(0.1234, f)); snprintf(buf, sizeof(buf), "%g", in_f); out = eina_value_to_string(value); - fail_unless(out != NULL); - fail_unless(strncmp(buf, out, 6) == 0); /* stupid float... */ + ck_assert(out != NULL); + ck_assert(strncmp(buf, out, 6) == 0); /* stupid float... */ free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_DOUBLE)); in_d = 34567.8; - fail_unless(eina_value_pset(value, &in_d)); - fail_unless(eina_value_pget(value, &d)); - fail_unless(CHECK_FP(34567.8, d)); + ck_assert(eina_value_pset(value, &in_d)); + ck_assert(eina_value_pget(value, &d)); + ck_assert(CHECK_FP(34567.8, d)); snprintf(buf, sizeof(buf), "%g", in_d); out = eina_value_to_string(value); - fail_unless(out != NULL); - fail_unless(strncmp(buf, out, 7) == 0); /* stupid double... */ + ck_assert(out != NULL); + ck_assert(strncmp(buf, out, 7) == 0); /* stupid double... */ free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); in_str = "hello world!"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "hello world!"); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(in_str, out); free(out); in_str = "eina-value"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "eina-value"); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(in_str, out); free(out); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); in_str = "profusion"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "profusion"); out = eina_value_to_string(value); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(in_str, out); free(out); @@ -860,50 +860,50 @@ EFL_START_TEST(eina_value_test_to_binbuf) value = eina_value_new(EINA_VALUE_TYPE_CHAR); - fail_unless(value != NULL); + ck_assert(value != NULL); in_c = 'x'; - fail_unless(eina_value_pset(value, &in_c)); - fail_unless(eina_value_pget(value, &c)); - fail_unless(c == 'x'); + ck_assert(eina_value_pset(value, &in_c)); + ck_assert(eina_value_pget(value, &c)); + ck_assert(c == 'x'); snprintf(buf, sizeof(buf), "%c", in_c); bin = eina_value_to_binbuf(value); out = (char *) eina_binbuf_string_get(bin); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(buf, out); eina_binbuf_free(bin); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); in_str = "hello world!"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "hello world!"); bin = eina_value_to_binbuf(value); out = (char *) eina_binbuf_string_get(bin); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(in_str, out); eina_binbuf_free(bin); in_str = "eina-value"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "eina-value"); bin = eina_value_to_binbuf(value); out = (char *) eina_binbuf_string_get(bin); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(in_str, out); eina_binbuf_free(bin); eina_value_flush(value); - fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); in_str = "profusion"; - fail_unless(eina_value_pset(value, &in_str)); - fail_unless(eina_value_pget(value, &str)); + ck_assert(eina_value_pset(value, &in_str)); + ck_assert(eina_value_pget(value, &str)); ck_assert_str_eq(str, "profusion"); bin = eina_value_to_binbuf(value); out = (char *) eina_binbuf_string_get(bin); - fail_unless(out != NULL); + ck_assert(out != NULL); ck_assert_str_eq(in_str, out); eina_binbuf_free(bin); @@ -930,110 +930,110 @@ EFL_START_TEST(eina_value_test_convert_char) value = eina_value_new(EINA_VALUE_TYPE_CHAR); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_set(value, 123)); + ck_assert(eina_value_set(value, 123)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &uc)); - fail_unless(uc == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &uc)); + ck_assert(uc == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &us)); - fail_unless(us == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &us)); + ck_assert(us == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &c)); - fail_unless(c == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &c)); + ck_assert(c == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &s)); - fail_unless(s == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &s)); + ck_assert(s == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == 123); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == 123); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, 123)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, 123)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, 123)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, 123)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "123"); eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_set(value, -123)); + ck_assert(eina_value_set(value, -123)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1059,94 +1059,94 @@ EFL_START_TEST(eina_value_test_convert_uchar) value = eina_value_new(EINA_VALUE_TYPE_UCHAR); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_set(value, 31)); + ck_assert(eina_value_set(value, 31)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &uc)); - fail_unless(uc == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &uc)); + ck_assert(uc == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &us)); - fail_unless(us == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &us)); + ck_assert(us == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &c)); - fail_unless(c == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &c)); + ck_assert(c == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &s)); - fail_unless(s == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &s)); + ck_assert(s == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == 31); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == 31); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, 31)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, 31)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, 31)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, 31)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "31"); eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_set(value, 200)); + ck_assert(eina_value_set(value, 200)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1170,114 +1170,114 @@ EFL_START_TEST(eina_value_test_convert_short) value = eina_value_new(EINA_VALUE_TYPE_SHORT); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_set(value, 12345)); + ck_assert(eina_value_set(value, 12345)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &us)); - fail_unless(us == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &us)); + ck_assert(us == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &s)); - fail_unless(s == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &s)); + ck_assert(s == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == 12345); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == 12345); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, 12345)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, 12345)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, 12345)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, 12345)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "12345"); eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); // check negative value - fail_unless(eina_value_set(value, -12345)); + ck_assert(eina_value_set(value, -12345)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1300,85 +1300,85 @@ EFL_START_TEST(eina_value_test_convert_ushort) value = eina_value_new(EINA_VALUE_TYPE_USHORT); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_set(value, 54321)); + ck_assert(eina_value_set(value, 54321)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &us)); - fail_unless(us == 54321); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &us)); + ck_assert(us == 54321); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == 54321); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == 54321); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == 54321); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == 54321); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == 54321); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == 54321); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == 54321); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == 54321); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == 54321); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == 54321); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == 54321); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == 54321); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, 54321)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, 54321)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, 54321)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, 54321)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "54321"); eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1400,114 +1400,114 @@ EFL_START_TEST(eina_value_test_convert_int) value = eina_value_new(EINA_VALUE_TYPE_INT); - fail_unless(value != NULL); + ck_assert(value != NULL); const int max_positive_signed_4_bytes = 0x7FFFFFFF; - fail_unless(eina_value_set(value, max_positive_signed_4_bytes)); + ck_assert(eina_value_set(value, max_positive_signed_4_bytes)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == (unsigned int)max_positive_signed_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == (unsigned int)max_positive_signed_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == (unsigned long)max_positive_signed_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == (unsigned long)max_positive_signed_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == (uint64_t)max_positive_signed_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == (uint64_t)max_positive_signed_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == max_positive_signed_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == max_positive_signed_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == max_positive_signed_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == max_positive_signed_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == max_positive_signed_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == max_positive_signed_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, max_positive_signed_4_bytes)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, max_positive_signed_4_bytes)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, max_positive_signed_4_bytes)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, max_positive_signed_4_bytes)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "2147483647"); // "2147483647" == 0x7FFFFFFF eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); // check negative value - fail_unless(eina_value_set(value, -1234567890)); + ck_assert(eina_value_set(value, -1234567890)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); // value should be positive - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1526,73 +1526,73 @@ EFL_START_TEST(eina_value_test_convert_uint) value = eina_value_new(EINA_VALUE_TYPE_UINT); - fail_unless(value != NULL); + ck_assert(value != NULL); const unsigned int max_positive_unsigned_4_bytes = 0xFFFFFFFF; - fail_unless(eina_value_set(value, max_positive_unsigned_4_bytes)); + ck_assert(eina_value_set(value, max_positive_unsigned_4_bytes)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == max_positive_unsigned_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == max_positive_unsigned_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == max_positive_unsigned_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == max_positive_unsigned_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == max_positive_unsigned_4_bytes); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == max_positive_unsigned_4_bytes); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, max_positive_unsigned_4_bytes)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, max_positive_unsigned_4_bytes)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, max_positive_unsigned_4_bytes)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, max_positive_unsigned_4_bytes)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "4294967295"); // 4294967295 == 0xFFFFFFFF eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); // value too big - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1618,130 +1618,130 @@ EFL_START_TEST(eina_value_test_convert_long) value = eina_value_new(EINA_VALUE_TYPE_LONG); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_set(value, 32l)); + ck_assert(eina_value_set(value, 32l)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &uc)); - fail_unless(uc == 32); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &uc)); + ck_assert(uc == 32); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &us)); - fail_unless(us == 32); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &us)); + ck_assert(us == 32); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == 32); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == 32); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == 32ul); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == 32ul); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == 32ull); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == 32ull); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &c)); - fail_unless(c == 32); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &c)); + ck_assert(c == 32); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &s)); - fail_unless(s == 32); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &s)); + ck_assert(s == 32); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == 32); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == 32); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == 32l); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == 32l); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == 32ll); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == 32ll); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, 32)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, 32)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, 32)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, 32)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "32"); eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_set(value, 128l)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 128l)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, 256l)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 256l)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, 32768l)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 32768l)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, 65536l)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 65536l)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, -32l)); + ck_assert(eina_value_set(value, -32l)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1767,108 +1767,108 @@ EFL_START_TEST(eina_value_test_convert_ulong) value = eina_value_new(EINA_VALUE_TYPE_ULONG); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_set(value, 42ul)); + ck_assert(eina_value_set(value, 42ul)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &uc)); - fail_unless(uc == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &uc)); + ck_assert(uc == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &us)); - fail_unless(us == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &us)); + ck_assert(us == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == 42ul); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == 42ul); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(u64 == 42ull); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(u64 == 42ull); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &c)); - fail_unless(c == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &c)); + ck_assert(c == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &s)); - fail_unless(s == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &s)); + ck_assert(s == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == 42l); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == 42l); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == 42ll); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == 42ll); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, 42)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, 42)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, 42)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, 42)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "42"); eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_set(value, 128ul)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 128ul)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, 256ul)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 256ul)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, 32768ul)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 32768ul)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, 65536ul)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, 65536ul)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -1897,150 +1897,150 @@ EFL_START_TEST(eina_value_test_convert_float) value = eina_value_new(EINA_VALUE_TYPE_FLOAT); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_set(value, 42.354645)); + ck_assert(eina_value_set(value, 42.354645)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &uc)); - fail_unless(uc == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &uc)); + ck_assert(uc == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &us)); - fail_unless(us == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &us)); + ck_assert(us == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ui)); - fail_unless(ui == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ui)); + ck_assert(ui == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &ul)); - fail_unless(ul == 42ul); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_ULONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &ul)); + ck_assert(ul == 42ul); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &u64)); - fail_unless(ul == 42ull); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &u64)); + ck_assert(ul == 42ull); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &c)); - fail_unless(c == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &c)); + ck_assert(c == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &s)); - fail_unless(s == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &s)); + ck_assert(s == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i)); - fail_unless(i == 42); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i)); + ck_assert(i == 42); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &l)); - fail_unless(l == 42l); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_LONG)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &l)); + ck_assert(l == 42l); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &i64)); - fail_unless(i64 == 42ll); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_INT64)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &i64)); + ck_assert(i64 == 42ll); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, max_float_value)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, max_float_value)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &str)); - fail_unless(str != NULL); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &str)); + ck_assert(str != NULL); ck_assert_str_eq(str, "42.354645"); eina_value_flush(&conv); - fail_unless(eina_value_set(value, max_float_value)); + ck_assert(eina_value_set(value, max_float_value)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, max_float_value)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, max_float_value)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, min_float_value)); + ck_assert(eina_value_set(value, min_float_value)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, min_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, min_float_value)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, min_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, min_float_value)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, -max_float_value)); + ck_assert(eina_value_set(value, -max_float_value)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &f)); - fail_unless(CHECK_FP(f, -max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_FLOAT)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &f)); + ck_assert(CHECK_FP(f, -max_float_value)); eina_value_flush(&conv); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); - fail_unless(eina_value_convert(value, &conv)); - fail_unless(eina_value_get(&conv, &d)); - fail_unless(CHECK_FP(d, -max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_DOUBLE)); + ck_assert(eina_value_convert(value, &conv)); + ck_assert(eina_value_get(&conv, &d)); + ck_assert(CHECK_FP(d, -max_float_value)); eina_value_flush(&conv); /* negative tests */ - fail_unless(eina_value_set(value, -max_float_value)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, -max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, -max_float_value)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, -max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, -max_float_value)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, -max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_SHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); - fail_unless(eina_value_set(value, -max_float_value)); - fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); - fail_if(eina_value_convert(value, &conv)); + ck_assert(eina_value_set(value, -max_float_value)); + ck_assert(eina_value_setup(&conv, EINA_VALUE_TYPE_USHORT)); + ck_assert(eina_value_convert(value, &conv)); eina_value_flush(&conv); eina_value_free(value); @@ -2059,100 +2059,100 @@ EFL_START_TEST(eina_value_test_array) value = eina_value_array_new(EINA_VALUE_TYPE_CHAR, 0); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_array_append(value, 'k')); - fail_unless(eina_value_array_append(value, '-')); - fail_unless(eina_value_array_append(value, 's')); + ck_assert(eina_value_array_append(value, 'k')); + ck_assert(eina_value_array_append(value, '-')); + ck_assert(eina_value_array_append(value, 's')); - fail_unless(eina_value_array_get(value, 0, &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_array_get(value, 1, &c)); - fail_unless(c == '-'); - fail_unless(eina_value_array_get(value, 2, &c)); - fail_unless(c == 's'); + ck_assert(eina_value_array_get(value, 0, &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_array_get(value, 1, &c)); + ck_assert(c == '-'); + ck_assert(eina_value_array_get(value, 2, &c)); + ck_assert(c == 's'); - fail_unless(eina_value_array_insert(value, 0, '!')); - fail_unless(eina_value_array_get(value, 0, &c)); - fail_unless(c == '!'); - fail_unless(eina_value_array_get(value, 1, &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_array_get(value, 2, &c)); - fail_unless(c == '-'); - fail_unless(eina_value_array_get(value, 3, &c)); - fail_unless(c == 's'); + ck_assert(eina_value_array_insert(value, 0, '!')); + ck_assert(eina_value_array_get(value, 0, &c)); + ck_assert(c == '!'); + ck_assert(eina_value_array_get(value, 1, &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_array_get(value, 2, &c)); + ck_assert(c == '-'); + ck_assert(eina_value_array_get(value, 3, &c)); + ck_assert(c == 's'); - fail_unless(eina_value_array_set(value, 0, '*')); - fail_unless(eina_value_array_get(value, 0, &c)); - fail_unless(c == '*'); - fail_unless(eina_value_array_get(value, 1, &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_array_get(value, 2, &c)); - fail_unless(c == '-'); - fail_unless(eina_value_array_get(value, 3, &c)); - fail_unless(c == 's'); + ck_assert(eina_value_array_set(value, 0, '*')); + ck_assert(eina_value_array_get(value, 0, &c)); + ck_assert(c == '*'); + ck_assert(eina_value_array_get(value, 1, &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_array_get(value, 2, &c)); + ck_assert(c == '-'); + ck_assert(eina_value_array_get(value, 3, &c)); + ck_assert(c == 's'); snprintf(buf, sizeof(buf), "[%d, %d, %d, %d]", (int) '*', (int) 'k', (int) '-', (int) 's'); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, buf); free(str); eina_value_flush(value); - fail_unless(eina_value_array_setup(value, EINA_VALUE_TYPE_STRINGSHARE, 2)); + ck_assert(eina_value_array_setup(value, EINA_VALUE_TYPE_STRINGSHARE, 2)); - fail_unless(eina_value_array_append(value, "Enlightenment.org")); - fail_unless(eina_value_array_append(value, "X11")); - fail_unless(eina_value_array_append(value, "Pants")); - fail_unless(eina_value_array_append(value, "on!!!")); - fail_unless(eina_value_array_append(value, "k-s")); + ck_assert(eina_value_array_append(value, "Enlightenment.org")); + ck_assert(eina_value_array_append(value, "X11")); + ck_assert(eina_value_array_append(value, "Pants")); + ck_assert(eina_value_array_append(value, "on!!!")); + ck_assert(eina_value_array_append(value, "k-s")); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "[Enlightenment.org, X11, Pants, on!!!, k-s]"); free(str); eina_value_flush(value); - fail_unless(eina_value_array_setup(value, EINA_VALUE_TYPE_CHAR, 0)); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_array_setup(value, EINA_VALUE_TYPE_CHAR, 0)); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_set(&other, 100)); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 100); + ck_assert(eina_value_set(&other, 100)); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 100); - fail_unless(eina_value_convert(&other, value)); + ck_assert(eina_value_convert(&other, value)); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "[100]"); free(str); - fail_unless(eina_value_array_set(value, 0, 33)); - fail_unless(eina_value_convert(value, &other)); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 33); + ck_assert(eina_value_array_set(value, 0, 33)); + ck_assert(eina_value_convert(value, &other)); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 33); inarray = eina_inarray_new(sizeof(char), 0); - fail_unless(inarray != NULL); + ck_assert(inarray != NULL); c = 11; - fail_unless(eina_inarray_push(inarray, &c) >= 0); + ck_assert(eina_inarray_push(inarray, &c) >= 0); c = 21; - fail_unless(eina_inarray_push(inarray, &c) >= 0); + ck_assert(eina_inarray_push(inarray, &c) >= 0); c = 31; - fail_unless(eina_inarray_push(inarray, &c) >= 0); + ck_assert(eina_inarray_push(inarray, &c) >= 0); desc.subtype = EINA_VALUE_TYPE_CHAR; desc.step = 0; desc.array = inarray; - fail_unless(eina_value_set(value, desc)); /* manually configure */ + ck_assert(eina_value_set(value, desc)); /* manually configure */ eina_inarray_free(inarray); - fail_unless(eina_value_array_get(value, 0, &c)); - fail_unless(c == 11); - fail_unless(eina_value_array_get(value, 1, &c)); - fail_unless(c == 21); - fail_unless(eina_value_array_get(value, 2, &c)); - fail_unless(c == 31); + ck_assert(eina_value_array_get(value, 0, &c)); + ck_assert(c == 11); + ck_assert(eina_value_array_get(value, 1, &c)); + ck_assert(c == 21); + ck_assert(eina_value_array_get(value, 2, &c)); + ck_assert(c == 31); eina_value_free(value); } @@ -2166,33 +2166,33 @@ EFL_START_TEST(eina_value_test_list_insert) char buf[1024]; value = eina_value_list_new(EINA_VALUE_TYPE_CHAR); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_list_count(value) == 0); - fail_unless(!eina_value_list_insert(value, 1, '-')); - fail_unless(!eina_value_list_insert(value, 10, 'j')); - fail_unless(eina_value_list_count(value) == 0); + ck_assert(eina_value_list_count(value) == 0); + ck_assert(!eina_value_list_insert(value, 1, '-')); + ck_assert(!eina_value_list_insert(value, 10, 'j')); + ck_assert(eina_value_list_count(value) == 0); - fail_unless(eina_value_list_insert(value, 0, 'k')); - fail_unless(eina_value_list_insert(value, 1, '-')); - fail_unless(eina_value_list_insert(value, 0, 's')); - fail_unless(eina_value_list_insert(value, 1, 'j')); - fail_unless(eina_value_list_count(value) == 4); + ck_assert(eina_value_list_insert(value, 0, 'k')); + ck_assert(eina_value_list_insert(value, 1, '-')); + ck_assert(eina_value_list_insert(value, 0, 's')); + ck_assert(eina_value_list_insert(value, 1, 'j')); + ck_assert(eina_value_list_count(value) == 4); - fail_unless(eina_value_list_get(value, 0, &c)); - fail_unless(c == 's'); - fail_unless(eina_value_list_get(value, 1, &c)); - fail_unless(c == 'j'); - fail_unless(eina_value_list_get(value, 2, &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_list_get(value, 3, &c)); - fail_unless(c == '-'); + ck_assert(eina_value_list_get(value, 0, &c)); + ck_assert(c == 's'); + ck_assert(eina_value_list_get(value, 1, &c)); + ck_assert(c == 'j'); + ck_assert(eina_value_list_get(value, 2, &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_list_get(value, 3, &c)); + ck_assert(c == '-'); snprintf(buf, sizeof(buf), "[%d, %d, %d, %d]", (int) 's', (int) 'j', (int) 'k', (int) '-'); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, buf); free(str); @@ -2211,97 +2211,97 @@ EFL_START_TEST(eina_value_test_list) value = eina_value_list_new(EINA_VALUE_TYPE_CHAR); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_list_append(value, 'k')); - fail_unless(eina_value_list_append(value, '-')); - fail_unless(eina_value_list_append(value, 's')); + ck_assert(eina_value_list_append(value, 'k')); + ck_assert(eina_value_list_append(value, '-')); + ck_assert(eina_value_list_append(value, 's')); - fail_unless(eina_value_list_get(value, 0, &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_list_get(value, 1, &c)); - fail_unless(c == '-'); - fail_unless(eina_value_list_get(value, 2, &c)); - fail_unless(c == 's'); + ck_assert(eina_value_list_get(value, 0, &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_list_get(value, 1, &c)); + ck_assert(c == '-'); + ck_assert(eina_value_list_get(value, 2, &c)); + ck_assert(c == 's'); - fail_unless(eina_value_list_insert(value, 0, '!')); - fail_unless(eina_value_list_get(value, 0, &c)); - fail_unless(c == '!'); - fail_unless(eina_value_list_get(value, 1, &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_list_get(value, 2, &c)); - fail_unless(c == '-'); - fail_unless(eina_value_list_get(value, 3, &c)); - fail_unless(c == 's'); + ck_assert(eina_value_list_insert(value, 0, '!')); + ck_assert(eina_value_list_get(value, 0, &c)); + ck_assert(c == '!'); + ck_assert(eina_value_list_get(value, 1, &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_list_get(value, 2, &c)); + ck_assert(c == '-'); + ck_assert(eina_value_list_get(value, 3, &c)); + ck_assert(c == 's'); - fail_unless(eina_value_list_set(value, 0, '*')); - fail_unless(eina_value_list_get(value, 0, &c)); - fail_unless(c == '*'); - fail_unless(eina_value_list_get(value, 1, &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_list_get(value, 2, &c)); - fail_unless(c == '-'); - fail_unless(eina_value_list_get(value, 3, &c)); - fail_unless(c == 's'); + ck_assert(eina_value_list_set(value, 0, '*')); + ck_assert(eina_value_list_get(value, 0, &c)); + ck_assert(c == '*'); + ck_assert(eina_value_list_get(value, 1, &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_list_get(value, 2, &c)); + ck_assert(c == '-'); + ck_assert(eina_value_list_get(value, 3, &c)); + ck_assert(c == 's'); snprintf(buf, sizeof(buf), "[%d, %d, %d, %d]", (int) '*', (int) 'k', (int) '-', (int) 's'); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, buf); free(str); eina_value_flush(value); - fail_unless(eina_value_list_setup(value, EINA_VALUE_TYPE_STRINGSHARE)); + ck_assert(eina_value_list_setup(value, EINA_VALUE_TYPE_STRINGSHARE)); - fail_unless(eina_value_list_append(value, "Enlightenment.org")); - fail_unless(eina_value_list_append(value, "X11")); - fail_unless(eina_value_list_append(value, "Pants")); - fail_unless(eina_value_list_append(value, "on!!!")); - fail_unless(eina_value_list_append(value, "k-s")); + ck_assert(eina_value_list_append(value, "Enlightenment.org")); + ck_assert(eina_value_list_append(value, "X11")); + ck_assert(eina_value_list_append(value, "Pants")); + ck_assert(eina_value_list_append(value, "on!!!")); + ck_assert(eina_value_list_append(value, "k-s")); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "[Enlightenment.org, X11, Pants, on!!!, k-s]"); free(str); eina_value_flush(value); - fail_unless(eina_value_list_setup(value, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_list_setup(value, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_set(&other, 100)); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 100); + ck_assert(eina_value_set(&other, 100)); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 100); - fail_unless(eina_value_convert(&other, value)); + ck_assert(eina_value_convert(&other, value)); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "[100]"); free(str); - fail_unless(eina_value_list_set(value, 0, 33)); - fail_unless(eina_value_convert(value, &other)); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 33); + ck_assert(eina_value_list_set(value, 0, 33)); + ck_assert(eina_value_convert(value, &other)); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 33); desc.subtype = EINA_VALUE_TYPE_STRING; desc.list = NULL; desc.list = eina_list_append(desc.list, "hello"); desc.list = eina_list_append(desc.list, "world"); desc.list = eina_list_append(desc.list, "eina"); - fail_unless(eina_list_count(desc.list) == 3); - fail_unless(eina_value_set(value, desc)); + ck_assert(eina_list_count(desc.list) == 3); + ck_assert(eina_value_set(value, desc)); eina_list_free(desc.list); - fail_unless(eina_value_list_get(value, 0, &s)); - fail_unless(s != NULL); + ck_assert(eina_value_list_get(value, 0, &s)); + ck_assert(s != NULL); ck_assert_str_eq(s, "hello"); - fail_unless(eina_value_list_get(value, 1, &s)); - fail_unless(s != NULL); + ck_assert(eina_value_list_get(value, 1, &s)); + ck_assert(s != NULL); ck_assert_str_eq(s, "world"); - fail_unless(eina_value_list_get(value, 2, &s)); - fail_unless(s != NULL); + ck_assert(eina_value_list_get(value, 2, &s)); + ck_assert(s != NULL); ck_assert_str_eq(s, "eina"); eina_value_free(value); @@ -2320,106 +2320,106 @@ EFL_START_TEST(eina_value_test_hash) value = eina_value_hash_new(EINA_VALUE_TYPE_CHAR, 0); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_hash_set(value, "first", 'k')); - fail_unless(eina_value_hash_set(value, "second", '-')); - fail_unless(eina_value_hash_set(value, "third", 's')); + ck_assert(eina_value_hash_set(value, "first", 'k')); + ck_assert(eina_value_hash_set(value, "second", '-')); + ck_assert(eina_value_hash_set(value, "third", 's')); - fail_unless(eina_value_hash_get(value, "first", &c)); - fail_unless(c == 'k'); - fail_unless(eina_value_hash_get(value, "second", &c)); - fail_unless(c == '-'); - fail_unless(eina_value_hash_get(value, "third", &c)); - fail_unless(c == 's'); + ck_assert(eina_value_hash_get(value, "first", &c)); + ck_assert(c == 'k'); + ck_assert(eina_value_hash_get(value, "second", &c)); + ck_assert(c == '-'); + ck_assert(eina_value_hash_get(value, "third", &c)); + ck_assert(c == 's'); - fail_unless(eina_value_hash_set(value, "first", '!')); - fail_unless(eina_value_hash_get(value, "first", &c)); - fail_unless(c == '!'); - fail_unless(eina_value_hash_get(value, "second", &c)); - fail_unless(c == '-'); - fail_unless(eina_value_hash_get(value, "third", &c)); - fail_unless(c == 's'); + ck_assert(eina_value_hash_set(value, "first", '!')); + ck_assert(eina_value_hash_get(value, "first", &c)); + ck_assert(c == '!'); + ck_assert(eina_value_hash_get(value, "second", &c)); + ck_assert(c == '-'); + ck_assert(eina_value_hash_get(value, "third", &c)); + ck_assert(c == 's'); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); snprintf(buf, sizeof(buf), "first: %d", (int) '!'); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); snprintf(buf, sizeof(buf), "second: %d", (int) '-'); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); snprintf(buf, sizeof(buf), "third: %d", (int) 's'); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); free(str); eina_value_flush(value); - fail_unless(eina_value_hash_setup(value, EINA_VALUE_TYPE_STRINGSHARE, 0)); + ck_assert(eina_value_hash_setup(value, EINA_VALUE_TYPE_STRINGSHARE, 0)); - fail_unless(eina_value_hash_set(value, "a", "Enlightenment.org")); - fail_unless(eina_value_hash_set(value, "b", "X11")); - fail_unless(eina_value_hash_set(value, "c", "Pants")); - fail_unless(eina_value_hash_set(value, "d", "on!!!")); - fail_unless(eina_value_hash_set(value, "e", "k-s")); + ck_assert(eina_value_hash_set(value, "a", "Enlightenment.org")); + ck_assert(eina_value_hash_set(value, "b", "X11")); + ck_assert(eina_value_hash_set(value, "c", "Pants")); + ck_assert(eina_value_hash_set(value, "d", "on!!!")); + ck_assert(eina_value_hash_set(value, "e", "k-s")); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); eina_strlcpy(buf, "a: Enlightenment.org", sizeof(buf)); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); eina_strlcpy(buf, "b: X11", sizeof(buf)); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); eina_strlcpy(buf, "c: Pants", sizeof(buf)); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); eina_strlcpy(buf, "d: on!!!", sizeof(buf)); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); eina_strlcpy(buf, "e: k-s", sizeof(buf)); - fail_unless(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); + ck_assert_msg(strstr(str, buf) != NULL, "Couldn't find '%s' in '%s'", buf, str); free(str); eina_value_flush(value); - fail_unless(eina_value_hash_setup(value, EINA_VALUE_TYPE_CHAR, 0)); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_hash_setup(value, EINA_VALUE_TYPE_CHAR, 0)); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_set(&other, 100)); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 100); + ck_assert(eina_value_set(&other, 100)); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 100); - fail_unless(eina_value_hash_set(value, "first", 33)); - fail_unless(eina_value_convert(value, &other)); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 33); + ck_assert(eina_value_hash_set(value, "first", 33)); + ck_assert(eina_value_convert(value, &other)); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 33); desc.subtype = EINA_VALUE_TYPE_STRING; desc.buckets_power_size = 0; desc.hash = eina_hash_string_small_new(NULL); - fail_unless(desc.hash != NULL); + ck_assert(desc.hash != NULL); /* watch out hash pointer is to a size of subtype->value_size! */ ptr = malloc(sizeof(char *)); *ptr = "there"; - fail_unless(eina_hash_add(desc.hash, "hi", ptr)); + ck_assert(eina_hash_add(desc.hash, "hi", ptr)); ptr = malloc(sizeof(char *)); *ptr = "y"; - fail_unless(eina_hash_add(desc.hash, "x", ptr)); - fail_unless(eina_value_set(value, desc)); + ck_assert(eina_hash_add(desc.hash, "x", ptr)); + ck_assert(eina_value_set(value, desc)); free(eina_hash_find(desc.hash, "hi")); free(eina_hash_find(desc.hash, "x")); eina_hash_free(desc.hash); - fail_unless(eina_value_hash_get(value, "hi", &s)); - fail_unless(s != NULL); + ck_assert(eina_value_hash_get(value, "hi", &s)); + ck_assert(s != NULL); ck_assert_str_eq(s, "there"); - fail_unless(eina_value_hash_get(value, "x", &s)); - fail_unless(s != NULL); + ck_assert(eina_value_hash_get(value, "x", &s)); + ck_assert(s != NULL); ck_assert_str_eq(s, "y"); eina_value_free(value); @@ -2438,68 +2438,68 @@ EFL_START_TEST(eina_value_test_timeval) value = eina_value_new(EINA_VALUE_TYPE_TIMEVAL); - fail_unless(value != NULL); + ck_assert(value != NULL); itv.tv_sec = 1; itv.tv_usec = 123; - fail_unless(eina_value_set(value, itv)); - fail_unless(eina_value_get(value, &otv)); - fail_unless(itv.tv_sec == otv.tv_sec); - fail_unless(itv.tv_usec == otv.tv_usec); + ck_assert(eina_value_set(value, itv)); + ck_assert(eina_value_get(value, &otv)); + ck_assert(itv.tv_sec == otv.tv_sec); + ck_assert(itv.tv_usec == otv.tv_usec); itv.tv_sec = 3; itv.tv_usec = -1; - fail_unless(eina_value_set(value, itv)); - fail_unless(eina_value_get(value, &otv)); + ck_assert(eina_value_set(value, itv)); + ck_assert(eina_value_get(value, &otv)); itv.tv_sec = 2; itv.tv_usec = 999999; - fail_unless(itv.tv_sec == otv.tv_sec); - fail_unless(itv.tv_usec == otv.tv_usec); + ck_assert(itv.tv_sec == otv.tv_sec); + ck_assert(itv.tv_usec == otv.tv_usec); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); - fail_unless(eina_value_convert(value, &other)); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 2); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_CHAR)); + ck_assert(eina_value_convert(value, &other)); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 2); eina_value_flush(&other); itv.tv_sec = 12345; itv.tv_usec = 6789; - fail_unless(eina_value_set(value, itv)); + ck_assert(eina_value_set(value, itv)); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); t = itv.tv_sec; strftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S", localtime(&(t))); ck_assert_str_eq(str, buf); free(str); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_TIMEVAL)); - fail_unless(eina_value_set(&other, itv)); - fail_unless(eina_value_compare(value, &other) == 0); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_TIMEVAL)); + ck_assert(eina_value_set(&other, itv)); + ck_assert(eina_value_compare(value, &other) == 0); itv.tv_sec++; - fail_unless(eina_value_set(&other, itv)); - fail_unless(eina_value_compare(value, &other) < 0); + ck_assert(eina_value_set(&other, itv)); + ck_assert(eina_value_compare(value, &other) < 0); itv.tv_sec -= 2; - fail_unless(eina_value_set(&other, itv)); - fail_unless(eina_value_compare(value, &other) > 0); + ck_assert(eina_value_set(&other, itv)); + ck_assert(eina_value_compare(value, &other) > 0); itv.tv_sec++; - fail_unless(eina_value_set(&other, itv)); - fail_unless(eina_value_compare(value, &other) == 0); + ck_assert(eina_value_set(&other, itv)); + ck_assert(eina_value_compare(value, &other) == 0); itv.tv_usec++; - fail_unless(eina_value_set(&other, itv)); - fail_unless(eina_value_compare(value, &other) < 0); + ck_assert(eina_value_set(&other, itv)); + ck_assert(eina_value_compare(value, &other) < 0); itv.tv_usec -= 2; - fail_unless(eina_value_set(&other, itv)); - fail_unless(eina_value_compare(value, &other) > 0); + ck_assert(eina_value_set(&other, itv)); + ck_assert(eina_value_compare(value, &other) > 0); itv.tv_usec++; - fail_unless(eina_value_set(&other, itv)); - fail_unless(eina_value_compare(value, &other) == 0); + ck_assert(eina_value_set(&other, itv)); + ck_assert(eina_value_compare(value, &other) == 0); eina_value_flush(&other); @@ -2519,73 +2519,73 @@ EFL_START_TEST(eina_value_test_blob) value = eina_value_new(EINA_VALUE_TYPE_BLOB); - fail_unless(value != NULL); + ck_assert(value != NULL); in.ops = NULL; in.memory = blob; in.size = sizeof(blob); - fail_unless(eina_value_set(value, in)); - fail_unless(eina_value_get(value, &out)); - fail_unless(out.memory == blob); - fail_unless(out.size == sizeof(blob)); - fail_unless(memcmp(in.memory, out.memory, in.size) == 0); + ck_assert(eina_value_set(value, in)); + ck_assert(eina_value_get(value, &out)); + ck_assert(out.memory == blob); + ck_assert(out.size == sizeof(blob)); + ck_assert(memcmp(in.memory, out.memory, in.size) == 0); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "BLOB(10, [01 02 03 04 05 06 07 08 09 0a])"); free(str); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_INT)); - fail_unless(eina_value_set(&other, i)); - fail_unless(eina_value_convert(&other, value)); - fail_unless(eina_value_get(value, &out)); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_INT)); + ck_assert(eina_value_set(&other, i)); + ck_assert(eina_value_convert(&other, value)); + ck_assert(eina_value_get(value, &out)); - fail_unless(out.memory != NULL); - fail_unless(out.size == sizeof(int)); - fail_unless(memcmp(&i, out.memory, sizeof(int)) == 0); + ck_assert(out.memory != NULL); + ck_assert(out.size == sizeof(int)); + ck_assert(memcmp(&i, out.memory, sizeof(int)) == 0); eina_value_flush(&other); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_STRING)); - fail_unless(eina_value_set(&other, "hi there!")); - fail_unless(eina_value_convert(&other, value)); - fail_unless(eina_value_get(value, &out)); - fail_unless(out.memory != NULL); - fail_unless(out.size == sizeof("hi there!")); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_STRING)); + ck_assert(eina_value_set(&other, "hi there!")); + ck_assert(eina_value_convert(&other, value)); + ck_assert(eina_value_get(value, &out)); + ck_assert(out.memory != NULL); + ck_assert(out.size == sizeof("hi there!")); ck_assert_str_eq(out.memory, "hi there!"); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "BLOB(10, [68 69 20 74 68 65 72 65 21 00])"); free(str); eina_value_flush(&other); - fail_unless(eina_value_array_setup(&other, EINA_VALUE_TYPE_CHAR, 0)); - fail_unless(eina_value_array_append(&other, 0xa)); - fail_unless(eina_value_array_append(&other, 0xb)); - fail_unless(eina_value_array_append(&other, 0xc)); - fail_unless(eina_value_convert(&other, value)); - fail_unless(eina_value_get(value, &out)); - fail_unless(out.memory != NULL); - fail_unless(out.size == 3); + ck_assert(eina_value_array_setup(&other, EINA_VALUE_TYPE_CHAR, 0)); + ck_assert(eina_value_array_append(&other, 0xa)); + ck_assert(eina_value_array_append(&other, 0xb)); + ck_assert(eina_value_array_append(&other, 0xc)); + ck_assert(eina_value_convert(&other, value)); + ck_assert(eina_value_get(value, &out)); + ck_assert(out.memory != NULL); + ck_assert(out.size == 3); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "BLOB(3, [0a 0b 0c])"); free(str); eina_value_flush(&other); - fail_unless(eina_value_setup(&other, EINA_VALUE_TYPE_BLOB)); - fail_unless(eina_value_set(&other, in)); - fail_unless(eina_value_convert(value, &other)); - fail_unless(eina_value_get(&other, &out)); - fail_unless(out.memory != NULL); - fail_unless(out.size == 3); + ck_assert(eina_value_setup(&other, EINA_VALUE_TYPE_BLOB)); + ck_assert(eina_value_set(&other, in)); + ck_assert(eina_value_convert(value, &other)); + ck_assert(eina_value_get(&other, &out)); + ck_assert(out.memory != NULL); + ck_assert(out.size == 3); str = eina_value_to_string(&other); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "BLOB(3, [0a 0b 0c])"); free(str); @@ -2652,125 +2652,125 @@ EFL_START_TEST(eina_value_test_struct) value = eina_value_struct_new(&myst_desc); - fail_unless(value != NULL); + ck_assert(value != NULL); - fail_unless(eina_value_struct_set(value, "i", 5678)); - fail_unless(eina_value_struct_set(value, "c", 0xf)); + ck_assert(eina_value_struct_set(value, "i", 5678)); + ck_assert(eina_value_struct_set(value, "c", 0xf)); - fail_unless(eina_value_struct_get(value, "i", &i)); - fail_unless(i == 5678); - fail_unless(eina_value_struct_get(value, "c", &c)); - fail_unless(c == 0xf); + ck_assert(eina_value_struct_get(value, "i", &i)); + ck_assert(i == 5678); + ck_assert(eina_value_struct_get(value, "c", &c)); + ck_assert(c == 0xf); - fail_unless(eina_value_struct_member_value_get + ck_assert(eina_value_struct_member_value_get (value, myst_members + 0, &other)); - fail_unless(other.type == EINA_VALUE_TYPE_INT); - fail_unless(eina_value_get(&other, &i)); - fail_unless(i == 5678); + ck_assert(other.type == EINA_VALUE_TYPE_INT); + ck_assert(eina_value_get(&other, &i)); + ck_assert(i == 5678); eina_value_flush(&other); - fail_unless(eina_value_struct_member_value_get + ck_assert(eina_value_struct_member_value_get (value, myst_members + 1, &other)); - fail_unless(other.type == EINA_VALUE_TYPE_CHAR); - fail_unless(eina_value_get(&other, &c)); - fail_unless(c == 0xf); + ck_assert(other.type == EINA_VALUE_TYPE_CHAR); + ck_assert(eina_value_get(&other, &c)); + ck_assert(c == 0xf); eina_value_flush(&other); str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "{i: 5678, c: 15}"); free(str); - fail_if(eina_value_struct_get(value, "x", 1234)); + ck_assert(eina_value_struct_get(value, "x", 1234)); i = 0x11223344; - fail_unless(eina_value_struct_pset(value, "i", &i)); + ck_assert(eina_value_struct_pset(value, "i", &i)); i = -1; - fail_unless(eina_value_struct_pget(value, "i", &i)); - fail_unless(i == 0x11223344); + ck_assert(eina_value_struct_pget(value, "i", &i)); + ck_assert(i == 0x11223344); - fail_unless(eina_value_copy(value, &other)); + ck_assert(eina_value_copy(value, &other)); str = eina_value_to_string(&other); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "{i: 287454020, c: 15}"); free(str); eina_value_flush(&other); - fail_unless(eina_value_struct_setup(&other, &mybigst_desc)); - fail_unless(eina_value_struct_set(&other, "a", 1) ); - fail_unless(eina_value_struct_set(&other, "b", 2)); - fail_unless(eina_value_struct_set(&other, "c", 3)); - fail_unless(eina_value_struct_set(&other, "d", 4)); - fail_unless(eina_value_struct_set(&other, "e", 5)); - fail_unless(eina_value_struct_set(&other, "f", 6)); - fail_unless(eina_value_struct_set(&other, "g", 7)); - fail_unless(eina_value_struct_set(&other, "h", 8)); - fail_unless(eina_value_struct_set(&other, "i", 9)); - fail_unless(eina_value_struct_set(&other, "j", 10)); - fail_unless(eina_value_struct_set(&other, "k", 12)); - fail_unless(eina_value_struct_set(&other, "l", 13)); - fail_unless(eina_value_struct_set(&other, "m", 14)); - fail_unless(eina_value_struct_set(&other, "n", 15)); - fail_unless(eina_value_struct_set(&other, "o", 16)); - fail_unless(eina_value_struct_set(&other, "p", 17)); - fail_unless(eina_value_struct_set(&other, "q", 18)); - fail_unless(eina_value_struct_set(&other, "r", 19)); - fail_unless(eina_value_struct_set(&other, "s", 20)); - fail_unless(eina_value_struct_set(&other, "t", 21)); - fail_unless(eina_value_struct_set(&other, "u", 22)); - fail_unless(eina_value_struct_set(&other, "v", 23)); - fail_unless(eina_value_struct_set(&other, "x", 24)); + ck_assert(eina_value_struct_setup(&other, &mybigst_desc)); + ck_assert(eina_value_struct_set(&other, "a", 1) ); + ck_assert(eina_value_struct_set(&other, "b", 2)); + ck_assert(eina_value_struct_set(&other, "c", 3)); + ck_assert(eina_value_struct_set(&other, "d", 4)); + ck_assert(eina_value_struct_set(&other, "e", 5)); + ck_assert(eina_value_struct_set(&other, "f", 6)); + ck_assert(eina_value_struct_set(&other, "g", 7)); + ck_assert(eina_value_struct_set(&other, "h", 8)); + ck_assert(eina_value_struct_set(&other, "i", 9)); + ck_assert(eina_value_struct_set(&other, "j", 10)); + ck_assert(eina_value_struct_set(&other, "k", 12)); + ck_assert(eina_value_struct_set(&other, "l", 13)); + ck_assert(eina_value_struct_set(&other, "m", 14)); + ck_assert(eina_value_struct_set(&other, "n", 15)); + ck_assert(eina_value_struct_set(&other, "o", 16)); + ck_assert(eina_value_struct_set(&other, "p", 17)); + ck_assert(eina_value_struct_set(&other, "q", 18)); + ck_assert(eina_value_struct_set(&other, "r", 19)); + ck_assert(eina_value_struct_set(&other, "s", 20)); + ck_assert(eina_value_struct_set(&other, "t", 21)); + ck_assert(eina_value_struct_set(&other, "u", 22)); + ck_assert(eina_value_struct_set(&other, "v", 23)); + ck_assert(eina_value_struct_set(&other, "x", 24)); - fail_unless(eina_value_struct_get(&other, "a", &i)); - fail_unless(i == 1); - fail_unless(eina_value_struct_get(&other, "b", &i)); - fail_unless(i == 2); - fail_unless(eina_value_struct_get(&other, "c", &i)); - fail_unless(i == 3); - fail_unless(eina_value_struct_get(&other, "d", &i)); - fail_unless(i == 4); - fail_unless(eina_value_struct_get(&other, "e", &i)); - fail_unless(i == 5); - fail_unless(eina_value_struct_get(&other, "f", &i)); - fail_unless(i == 6); - fail_unless(eina_value_struct_get(&other, "g", &i)); - fail_unless(i == 7); - fail_unless(eina_value_struct_get(&other, "h", &i)); - fail_unless(i == 8); - fail_unless(eina_value_struct_get(&other, "i", &i)); - fail_unless(i == 9); - fail_unless(eina_value_struct_get(&other, "j", &i)); - fail_unless(i == 10); - fail_unless(eina_value_struct_get(&other, "k", &i)); - fail_unless(i == 12); - fail_unless(eina_value_struct_get(&other, "l", &i)); - fail_unless(i == 13); - fail_unless(eina_value_struct_get(&other, "m", &i)); - fail_unless(i == 14); - fail_unless(eina_value_struct_get(&other, "n", &i)); - fail_unless(i == 15); - fail_unless(eina_value_struct_get(&other, "o", &i)); - fail_unless(i == 16); - fail_unless(eina_value_struct_get(&other, "p", &i)); - fail_unless(i == 17); - fail_unless(eina_value_struct_get(&other, "q", &i)); - fail_unless(i == 18); - fail_unless(eina_value_struct_get(&other, "r", &i)); - fail_unless(i == 19); - fail_unless(eina_value_struct_get(&other, "s", &i)); - fail_unless(i == 20); - fail_unless(eina_value_struct_get(&other, "t", &i)); - fail_unless(i == 21); - fail_unless(eina_value_struct_get(&other, "u", &i)); - fail_unless(i == 22); - fail_unless(eina_value_struct_get(&other, "v", &i)); - fail_unless(i == 23); - fail_unless(eina_value_struct_get(&other, "x", &i)); - fail_unless(i == 24); + ck_assert(eina_value_struct_get(&other, "a", &i)); + ck_assert(i == 1); + ck_assert(eina_value_struct_get(&other, "b", &i)); + ck_assert(i == 2); + ck_assert(eina_value_struct_get(&other, "c", &i)); + ck_assert(i == 3); + ck_assert(eina_value_struct_get(&other, "d", &i)); + ck_assert(i == 4); + ck_assert(eina_value_struct_get(&other, "e", &i)); + ck_assert(i == 5); + ck_assert(eina_value_struct_get(&other, "f", &i)); + ck_assert(i == 6); + ck_assert(eina_value_struct_get(&other, "g", &i)); + ck_assert(i == 7); + ck_assert(eina_value_struct_get(&other, "h", &i)); + ck_assert(i == 8); + ck_assert(eina_value_struct_get(&other, "i", &i)); + ck_assert(i == 9); + ck_assert(eina_value_struct_get(&other, "j", &i)); + ck_assert(i == 10); + ck_assert(eina_value_struct_get(&other, "k", &i)); + ck_assert(i == 12); + ck_assert(eina_value_struct_get(&other, "l", &i)); + ck_assert(i == 13); + ck_assert(eina_value_struct_get(&other, "m", &i)); + ck_assert(i == 14); + ck_assert(eina_value_struct_get(&other, "n", &i)); + ck_assert(i == 15); + ck_assert(eina_value_struct_get(&other, "o", &i)); + ck_assert(i == 16); + ck_assert(eina_value_struct_get(&other, "p", &i)); + ck_assert(i == 17); + ck_assert(eina_value_struct_get(&other, "q", &i)); + ck_assert(i == 18); + ck_assert(eina_value_struct_get(&other, "r", &i)); + ck_assert(i == 19); + ck_assert(eina_value_struct_get(&other, "s", &i)); + ck_assert(i == 20); + ck_assert(eina_value_struct_get(&other, "t", &i)); + ck_assert(i == 21); + ck_assert(eina_value_struct_get(&other, "u", &i)); + ck_assert(i == 22); + ck_assert(eina_value_struct_get(&other, "v", &i)); + ck_assert(i == 23); + ck_assert(eina_value_struct_get(&other, "x", &i)); + ck_assert(i == 24); str = eina_value_to_string(&other); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "{a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7, h: 8, i: 9, j: 10, k: 12, l: 13, m: 14, n: 15, o: 16, p: 17, q: 18, r: 19, s: 20, t: 21, u: 22, v: 23, x: 24}"); free(str); @@ -2804,7 +2804,7 @@ EFL_START_TEST(eina_value_test_array_of_struct) value = eina_value_array_new(EINA_VALUE_TYPE_STRUCT, 0); - fail_unless(value != NULL); + ck_assert(value != NULL); for (i = 0; i < 10; i++) { @@ -2820,11 +2820,11 @@ EFL_START_TEST(eina_value_test_array_of_struct) desc.desc = &myst_desc; desc.memory = &st; - fail_unless(eina_value_array_append(value, desc)); + ck_assert(eina_value_array_append(value, desc)); } str = eina_value_to_string(value); - fail_unless(str != NULL); + ck_assert(str != NULL); ck_assert_str_eq(str, "[" "{a: 0, b: 0, c: 0, s: item00}, " "{a: 1, b: 10, c: 100, s: item01}, " @@ -2954,31 +2954,31 @@ EFL_START_TEST(eina_value_test_optional_struct_members) ck_assert_ptr_ne(NULL, value); int64_t expected_a = 0x1234567887654321ll; - fail_unless(eina_value_struct_set(value, "a", expected_a)); + ck_assert(eina_value_struct_set(value, "a", expected_a)); int64_t actual_a; - fail_unless(eina_value_struct_get(value, "a", &actual_a)); + ck_assert(eina_value_struct_get(value, "a", &actual_a)); ck_assert_int_eq(expected_a, actual_a); int64_t expected_b = 0xEEDCBA9889ABCDEFll; - fail_unless(eina_value_struct_set(value, "b", expected_b)); + ck_assert(eina_value_struct_set(value, "b", expected_b)); int64_t actual_b; - fail_unless(eina_value_struct_get(value, "b", &actual_b)); + ck_assert(eina_value_struct_get(value, "b", &actual_b)); ck_assert_int_eq(expected_b, actual_b); Eina_Value expected_value; - fail_unless(eina_value_setup(&expected_value, EINA_VALUE_TYPE_OPTIONAL)); + ck_assert(eina_value_setup(&expected_value, EINA_VALUE_TYPE_OPTIONAL)); const char* str = "Hello world!"; - fail_unless(eina_value_optional_pset(&expected_value, EINA_VALUE_TYPE_STRING, &str)); - fail_unless(eina_value_struct_value_set(value, "text", &expected_value)); + ck_assert(eina_value_optional_pset(&expected_value, EINA_VALUE_TYPE_STRING, &str)); + ck_assert(eina_value_struct_value_set(value, "text", &expected_value)); Eina_Value actual_value; - fail_unless(eina_value_struct_value_get(value, "text", &actual_value)); - fail_unless(eina_value_compare(&expected_value, &actual_value) == 0); + ck_assert(eina_value_struct_value_get(value, "text", &actual_value)); + ck_assert(eina_value_compare(&expected_value, &actual_value) == 0); // tests if the value have been overriden - fail_unless(eina_value_struct_get(value, "a", &actual_a)); + ck_assert(eina_value_struct_get(value, "a", &actual_a)); ck_assert_int_eq(expected_a, actual_a); - fail_unless(eina_value_struct_get(value, "b", &actual_b)); + ck_assert(eina_value_struct_get(value, "b", &actual_b)); ck_assert_int_eq(expected_b, actual_b); eina_value_flush(&actual_value); @@ -2997,24 +2997,24 @@ EFL_START_TEST(eina_value_test_value) const char *str; - fail_if(!eina_value_setup(&composed, EINA_VALUE_TYPE_VALUE)); - fail_if(!eina_value_setup(&v, EINA_VALUE_TYPE_INT)); - fail_if(!eina_value_set(&v, ivalue)); - fail_if(!eina_value_set(&composed, v)); + ck_assert(!eina_value_setup(&composed, EINA_VALUE_TYPE_VALUE)); + ck_assert(!eina_value_setup(&v, EINA_VALUE_TYPE_INT)); + ck_assert(!eina_value_set(&v, ivalue)); + ck_assert(!eina_value_set(&composed, v)); - fail_if(!eina_value_get(&composed, &v)); - fail_if(!eina_value_get(&v, &i)); - fail_if(i != ivalue); + ck_assert(!eina_value_get(&composed, &v)); + ck_assert(!eina_value_get(&v, &i)); + ck_assert(i != ivalue); eina_value_flush(&v); - fail_if(!eina_value_setup(&v, EINA_VALUE_TYPE_STRING)); - fail_if(!eina_value_convert(&composed, &v)); - fail_if(!eina_value_get(&v, &str)); + ck_assert(!eina_value_setup(&v, EINA_VALUE_TYPE_STRING)); + ck_assert(!eina_value_convert(&composed, &v)); + ck_assert(!eina_value_get(&v, &str)); ck_assert_str_eq(str, "3500"); eina_value_flush(&v); - fail_if(!eina_value_copy(&composed, &v)); - fail_if(eina_value_compare(&composed, &v)); + ck_assert(!eina_value_copy(&composed, &v)); + ck_assert(eina_value_compare(&composed, &v)); eina_value_flush(&v); eina_value_flush(&composed); @@ -3027,23 +3027,23 @@ EFL_START_TEST(eina_value_test_value_string) const char *msg = "A string", *str; - fail_if(!eina_value_setup(&composed, EINA_VALUE_TYPE_VALUE)); - fail_if(!eina_value_setup(&v, EINA_VALUE_TYPE_STRING)); - fail_if(!eina_value_set(&v, msg)); - fail_if(!eina_value_set(&composed, v)); + ck_assert(!eina_value_setup(&composed, EINA_VALUE_TYPE_VALUE)); + ck_assert(!eina_value_setup(&v, EINA_VALUE_TYPE_STRING)); + ck_assert(!eina_value_set(&v, msg)); + ck_assert(!eina_value_set(&composed, v)); eina_value_flush(&v); - fail_if(!eina_value_copy(&composed, &v)); - fail_if(eina_value_compare(&composed, &v)); + ck_assert(!eina_value_copy(&composed, &v)); + ck_assert(eina_value_compare(&composed, &v)); - fail_if(!eina_value_get(&composed, &str_v)); - fail_if(!eina_value_get(&str_v, &str)); + ck_assert(!eina_value_get(&composed, &str_v)); + ck_assert(!eina_value_get(&str_v, &str)); ck_assert_str_eq(str, msg); eina_value_flush(&str_v); str = NULL; - fail_if(!eina_value_get(&v, &str_v)); - fail_if(!eina_value_get(&str_v, &str)); + ck_assert(!eina_value_get(&v, &str_v)); + ck_assert(!eina_value_get(&str_v, &str)); ck_assert_str_eq(str, msg); eina_value_flush(&str_v); diff --git a/src/tests/eina/eina_test_vector.c b/src/tests/eina/eina_test_vector.c index e4afa8bc9a..989fab3d67 100644 --- a/src/tests/eina/eina_test_vector.c +++ b/src/tests/eina/eina_test_vector.c @@ -42,54 +42,54 @@ EFL_START_TEST(eina_test_vector2_operations) eina_vector2_set(&v1, x, y); - fail_if(!EINA_DBL_EQ(v1.x, 1) || !EINA_DBL_EQ(v1.y, 2)); + ck_assert(!EINA_DBL_EQ(v1.x, 1) || !EINA_DBL_EQ(v1.y, 2)); eina_vector2_array_set(&v2, arr); - fail_if(!EINA_DBL_EQ(v2.x, 5) || !EINA_DBL_EQ(v2.y, 5)); + ck_assert(!EINA_DBL_EQ(v2.x, 5) || !EINA_DBL_EQ(v2.y, 5)); eina_vector2_copy(&v1, &v2); - fail_if(!EINA_DBL_EQ(v1.x, 5) || !EINA_DBL_EQ(v1.y, 5)); + ck_assert(!EINA_DBL_EQ(v1.x, 5) || !EINA_DBL_EQ(v1.y, 5)); eina_vector2_negate(&v1, &v2); - fail_if(!EINA_DBL_EQ(v1.x, -5) || !EINA_DBL_EQ(v1.y, -5)); + ck_assert(!EINA_DBL_EQ(v1.x, -5) || !EINA_DBL_EQ(v1.y, -5)); eina_vector2_set(&v1, x, y); eina_vector2_add(&v3, &v1, &v2); - fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 7)); + ck_assert(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 7)); eina_vector2_subtract(&v3, &v2, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 3)); + ck_assert(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 3)); eina_vector2_scale(&v3, &v1, y); - fail_if(!EINA_DBL_EQ(v3.x, 2) || !EINA_DBL_EQ(v3.y, 4)); + ck_assert(!EINA_DBL_EQ(v3.x, 2) || !EINA_DBL_EQ(v3.y, 4)); res = eina_vector2_dot_product(&v1, &v2); - fail_if(!EINA_DBL_EQ(res, 15)); + ck_assert(!EINA_DBL_EQ(res, 15)); res = eina_vector2_length_get(&v2); - fail_if((res - sqrt(50)) > DBL_EPSILON); + ck_assert((res - sqrt(50)) > DBL_EPSILON); res = eina_vector2_length_square_get(&v2); - fail_if(!EINA_DBL_EQ(res, 50)); + ck_assert(!EINA_DBL_EQ(res, 50)); res = eina_vector2_distance_get(&v2, &v1); - fail_if((res - sqrt(25)) > DBL_EPSILON); + ck_assert((res - sqrt(25)) > DBL_EPSILON); res = eina_vector2_distance_square_get(&v2, &v1); - fail_if(!EINA_DBL_EQ(res, 25)); + ck_assert(!EINA_DBL_EQ(res, 25)); eina_vector2_normalize(&v3, &v2); - fail_if((v3.x - v2.x / sqrt(50)) > DBL_EPSILON || + ck_assert((v3.x - v2.x / sqrt(50)) > DBL_EPSILON || (v3.y - v2.y / sqrt(50)) > DBL_EPSILON); eina_matrix2_values_set(&m2, 2, 2, 2, 2); eina_vector2_transform(&v3, &m2, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 6)); + ck_assert(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 6)); eina_vector2_transform(&v3, &m2, &v3); - fail_if(!EINA_DBL_EQ(v3.x, 24) || !EINA_DBL_EQ(v3.y, 24)); + ck_assert(!EINA_DBL_EQ(v3.x, 24) || !EINA_DBL_EQ(v3.y, 24)); eina_matrix3_values_set(&m3, 2, 2, 2, @@ -97,14 +97,14 @@ EFL_START_TEST(eina_test_vector2_operations) 2, 2, 2); eina_vector2_homogeneous_position_transform(&v3, &m3, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 1) || !EINA_DBL_EQ(v3.y, 1)); + ck_assert(!EINA_DBL_EQ(v3.x, 1) || !EINA_DBL_EQ(v3.y, 1)); eina_vector2_homogeneous_direction_transform(&v3, &m3, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 6)); + ck_assert(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 6)); eina_vector2_homogeneous_direction_transform(&v3, &m3, &v3); - fail_if(!EINA_DBL_EQ(v3.x, 24) || !EINA_DBL_EQ(v3.y, 24)); + ck_assert(!EINA_DBL_EQ(v3.x, 24) || !EINA_DBL_EQ(v3.y, 24)); } EFL_END_TEST @@ -126,69 +126,69 @@ EFL_START_TEST(eina_test_vector3_operations) eina_vector3_set(&v1, x, y, z); - fail_if(!EINA_DBL_EQ(v1.x, 1) || !EINA_DBL_EQ(v1.y, 2) || !EINA_DBL_EQ(v1.z, 3)); + ck_assert(!EINA_DBL_EQ(v1.x, 1) || !EINA_DBL_EQ(v1.y, 2) || !EINA_DBL_EQ(v1.z, 3)); eina_vector3_array_set(&v2, arr); - fail_if(!EINA_DBL_EQ(v2.x, 5) || !EINA_DBL_EQ(v2.y, 5) || !EINA_DBL_EQ(v2.z, 5)); + ck_assert(!EINA_DBL_EQ(v2.x, 5) || !EINA_DBL_EQ(v2.y, 5) || !EINA_DBL_EQ(v2.z, 5)); eina_vector3_copy(&v1, &v2); - fail_if(!EINA_DBL_EQ(v1.x, 5) || !EINA_DBL_EQ(v1.y, 5) || !EINA_DBL_EQ(v1.z, 5)); + ck_assert(!EINA_DBL_EQ(v1.x, 5) || !EINA_DBL_EQ(v1.y, 5) || !EINA_DBL_EQ(v1.z, 5)); eina_vector3_negate(&v1, &v2); - fail_if(!EINA_DBL_EQ(v1.x, -5) || !EINA_DBL_EQ(v1.y, -5) || !EINA_DBL_EQ(v1.z, -5)); + ck_assert(!EINA_DBL_EQ(v1.x, -5) || !EINA_DBL_EQ(v1.y, -5) || !EINA_DBL_EQ(v1.z, -5)); eina_vector3_set(&v1, x, y, z); eina_vector3_add(&v3, &v1, &v2); - fail_if(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 7) || !EINA_DBL_EQ(v3.z, 8)); + ck_assert(!EINA_DBL_EQ(v3.x, 6) || !EINA_DBL_EQ(v3.y, 7) || !EINA_DBL_EQ(v3.z, 8)); eina_vector3_subtract(&v3, &v2, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 3) || !EINA_DBL_EQ(v3.z, 2)); + ck_assert(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 3) || !EINA_DBL_EQ(v3.z, 2)); eina_vector3_scale(&v3, &v1, y); - fail_if(!EINA_DBL_EQ(v3.x, 2) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, 6)); + ck_assert(!EINA_DBL_EQ(v3.x, 2) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, 6)); eina_vector3_multiply(&v3, &v2, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 5) || !EINA_DBL_EQ(v3.y, 10) || !EINA_DBL_EQ(v3.z, 15)); + ck_assert(!EINA_DBL_EQ(v3.x, 5) || !EINA_DBL_EQ(v3.y, 10) || !EINA_DBL_EQ(v3.z, 15)); res = eina_vector3_dot_product(&v1, &v2); - fail_if(!EINA_DBL_EQ(res, 30)); + ck_assert(!EINA_DBL_EQ(res, 30)); eina_vector3_cross_product(&v3, &v1, &v2); - fail_if(!EINA_DBL_EQ(v3.x, -5) || !EINA_DBL_EQ(v3.y, 10) || !EINA_DBL_EQ(v3.z, -5)); + ck_assert(!EINA_DBL_EQ(v3.x, -5) || !EINA_DBL_EQ(v3.y, 10) || !EINA_DBL_EQ(v3.z, -5)); eina_vector3_cross_product(&v3, &v1, &v3); - fail_if(!EINA_DBL_EQ(v3.x, -40) || !EINA_DBL_EQ(v3.y, -10) || !EINA_DBL_EQ(v3.z, 20)); + ck_assert(!EINA_DBL_EQ(v3.x, -40) || !EINA_DBL_EQ(v3.y, -10) || !EINA_DBL_EQ(v3.z, 20)); res = eina_vector3_length_get(&v2); - fail_if((res - sqrt(75)) > DBL_EPSILON); + ck_assert((res - sqrt(75)) > DBL_EPSILON); res = eina_vector3_length_square_get(&v2); - fail_if(!EINA_DBL_EQ(res, 75)); + ck_assert(!EINA_DBL_EQ(res, 75)); res = eina_vector3_distance_get(&v2, &v1); - fail_if((res - sqrt(29)) > (DBL_EPSILON * 2.0)); + ck_assert((res - sqrt(29)) > (DBL_EPSILON * 2.0)); res = eina_vector3_distance_square_get(&v2, &v1); - fail_if(!EINA_DBL_EQ(res, 29)); + ck_assert(!EINA_DBL_EQ(res, 29)); eina_vector3_normalize(&v3, &v2); - fail_if((v3.x - v2.x / sqrt(75)) > DBL_EPSILON || + ck_assert((v3.x - v2.x / sqrt(75)) > DBL_EPSILON || (v3.y - v2.y / sqrt(75)) > DBL_EPSILON || (v3.z - v2.z / sqrt(75)) > DBL_EPSILON); res = eina_vector3_angle_get(&v1, &v2); - fail_if((res - (30 / (sqrt(14) * sqrt(75)))) > DBL_EPSILON); + ck_assert((res - (30 / (sqrt(14) * sqrt(75)))) > DBL_EPSILON); eina_matrix3_values_set(&m3, 2, 2, 2, 2, 2, 2, 2, 2, 2); eina_vector3_transform(&v3, &m3, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 12) || !EINA_DBL_EQ(v3.y, 12) || !EINA_DBL_EQ(v3.z, 12)); + ck_assert(!EINA_DBL_EQ(v3.x, 12) || !EINA_DBL_EQ(v3.y, 12) || !EINA_DBL_EQ(v3.z, 12)); eina_vector3_transform(&v3, &m3, &v3); - fail_if(!EINA_DBL_EQ(v3.x, 72) || !EINA_DBL_EQ(v3.y, 72) || !EINA_DBL_EQ(v3.z, 72)); + ck_assert(!EINA_DBL_EQ(v3.x, 72) || !EINA_DBL_EQ(v3.y, 72) || !EINA_DBL_EQ(v3.z, 72)); eina_matrix4_values_set(&m4, 2, 2, 2, 2, @@ -196,44 +196,44 @@ EFL_START_TEST(eina_test_vector3_operations) 2, 2, 2, 2, 2, 2, 2, 2); eina_vector3_homogeneous_position_transform(&v3, &m4, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 1) || !EINA_DBL_EQ(v3.y, 1) || !EINA_DBL_EQ(v3.z, 1)); + ck_assert(!EINA_DBL_EQ(v3.x, 1) || !EINA_DBL_EQ(v3.y, 1) || !EINA_DBL_EQ(v3.z, 1)); eina_quaternion_set(&q, 2, 2, 2, 0); eina_vector3_quaternion_rotate(&v3, &v1, &q); - fail_if(!EINA_DBL_EQ(v3.x, 25) || !EINA_DBL_EQ(v3.y, 2) || !EINA_DBL_EQ(v3.z, -21)); + ck_assert(!EINA_DBL_EQ(v3.x, 25) || !EINA_DBL_EQ(v3.y, 2) || !EINA_DBL_EQ(v3.z, -21)); eina_vector3_orthogonal_projection_on_plane(&v3, &v1, &v2); - fail_if(!EINA_DBL_EQ(v3.x, -1) || !EINA_DBL_EQ(v3.y, 0) || !EINA_DBL_EQ(v3.z, 1)); + ck_assert(!EINA_DBL_EQ(v3.x, -1) || !EINA_DBL_EQ(v3.y, 0) || !EINA_DBL_EQ(v3.z, 1)); eina_vector3_plane_by_points(&q, &v3, &v1, &v2); - fail_if(!EINA_DBL_EQ(q.x, -2) || !EINA_DBL_EQ(q.y, 4) || !EINA_DBL_EQ(q.z, -2) || (q.z > DBL_EPSILON)); + ck_assert(!EINA_DBL_EQ(q.x, -2) || !EINA_DBL_EQ(q.y, 4) || !EINA_DBL_EQ(q.z, -2) || (q.z > DBL_EPSILON)); eina_vector3_homogeneous_direction_set(&v3, &q); - fail_if(!EINA_DBL_EQ(v3.x, -2) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, -2)); + ck_assert(!EINA_DBL_EQ(v3.x, -2) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, -2)); eina_quaternion_set(&q, 2, 2, 2, 0.5); eina_vector3_homogeneous_position_set(&v3, &q); - fail_if(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, 4)); + ck_assert(!EINA_DBL_EQ(v3.x, 4) || !EINA_DBL_EQ(v3.y, 4) || !EINA_DBL_EQ(v3.z, 4)); res2 = eina_vector3_equivalent(&v1, &v2); - fail_if(res2 != EINA_FALSE); + ck_assert(res2 != EINA_FALSE); res2 = eina_vector3_equivalent(&v1, &v1); - fail_if(res2 != EINA_TRUE); + ck_assert(res2 != EINA_TRUE); res2 = eina_vector3_triangle_equivalent(&v1, &v2, &v3, &v2, &v3, &v1); - fail_if(res2 != EINA_FALSE); + ck_assert(res2 != EINA_FALSE); res2 = eina_vector3_triangle_equivalent(&v1, &v2, &v3, &v1, &v2, &v3); - fail_if(res2 != EINA_TRUE); + ck_assert(res2 != EINA_TRUE); eina_vector3_homogeneous_direction_transform(&v3, &m4, &v1); - fail_if(!EINA_DBL_EQ(v3.x, 12) || !EINA_DBL_EQ(v3.y, 12) || !EINA_DBL_EQ(v3.z, 12)); + ck_assert(!EINA_DBL_EQ(v3.x, 12) || !EINA_DBL_EQ(v3.y, 12) || !EINA_DBL_EQ(v3.z, 12)); eina_vector3_homogeneous_direction_transform(&v3, &m4, &v3); - fail_if(!EINA_DBL_EQ(v3.x, 72) || !EINA_DBL_EQ(v3.y, 72) || !EINA_DBL_EQ(v3.z, 72)); + ck_assert(!EINA_DBL_EQ(v3.x, 72) || !EINA_DBL_EQ(v3.y, 72) || !EINA_DBL_EQ(v3.z, 72)); } EFL_END_TEST diff --git a/src/tests/eina/eina_test_xattr.c b/src/tests/eina/eina_test_xattr.c index c3f8aff842..8b8c557a90 100644 --- a/src/tests/eina/eina_test_xattr.c +++ b/src/tests/eina/eina_test_xattr.c @@ -53,40 +53,40 @@ EFL_START_TEST(eina_test_xattr_set) test_file_path = get_file_path(XATTR_TEST_DIR, filename); fd = open(test_file_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO); - fail_if(fd == 0); + ck_assert(fd == 0); ret = eina_xattr_set(test_file_path, attribute1, data1, strlen(data1), EINA_XATTR_INSERT); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret_str = eina_xattr_get(test_file_path, attribute1, &len); - fail_if(ret_str == NULL); - fail_if(len == 0); - fail_if(strcmp(ret_str, data1) != 0); + ck_assert(ret_str == NULL); + ck_assert(len == 0); + ck_assert(strcmp(ret_str, data1) != 0); free(ret_str); ret = eina_xattr_set(test_file_path, attribute1, data1, strlen(data1), EINA_XATTR_CREATED); - fail_if(ret != EINA_FALSE); + ck_assert(ret != EINA_FALSE); ret = eina_xattr_set(test_file_path, attribute1, data2, strlen(data2), EINA_XATTR_REPLACE); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret_str = eina_xattr_get(test_file_path, attribute1, &len); - fail_if(ret_str == NULL); - fail_if(len == 0); - fail_if(strcmp(ret_str, data2) != 0); + ck_assert(ret_str == NULL); + ck_assert(len == 0); + ck_assert(strcmp(ret_str, data2) != 0); free(ret_str); ret = eina_xattr_del(test_file_path, attribute1); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret = eina_xattr_fd_set(fd, attribute1, data1, strlen(data1), EINA_XATTR_CREATED); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret_str = eina_xattr_fd_get(fd, attribute1, &len); - fail_if(ret_str == NULL); - fail_if(len == 0); - fail_if(strcmp(ret_str, data1) != 0); + ck_assert(ret_str == NULL); + ck_assert(len == 0); + ck_assert(strcmp(ret_str, data1) != 0); free(ret_str); ret = eina_xattr_fd_del(fd, attribute1); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); close(fd); unlink(test_file_path); @@ -124,14 +124,14 @@ EFL_START_TEST(eina_test_xattr_list) cp_file_path = get_file_path(XATTR_TEST_DIR, filename_cp); fd = open(test_file_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO); - fail_if(fd == 0); + ck_assert(fd == 0); fd1 = open(cp_file_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO); - fail_if(fd1 == 0); + ck_assert(fd1 == 0); for (i = 0; i < sizeof(attribute) / sizeof(attribute[0]); ++i) { ret = eina_xattr_set(test_file_path, attribute[i], data[i], strlen(data[i]), EINA_XATTR_INSERT); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); } it = eina_xattr_ls(test_file_path); @@ -144,7 +144,7 @@ EFL_START_TEST(eina_test_xattr_list) break ; } } - fail_if(count != sizeof (attribute) / sizeof (attribute[0])); + ck_assert(count != sizeof (attribute) / sizeof (attribute[0])); eina_iterator_free(it); count = 0; @@ -159,7 +159,7 @@ EFL_START_TEST(eina_test_xattr_list) break ; } } - fail_if(count != sizeof (data) / sizeof (data[0])); + ck_assert(count != sizeof (data) / sizeof (data[0])); eina_iterator_free(it); count = 0; @@ -173,7 +173,7 @@ EFL_START_TEST(eina_test_xattr_list) break ; } } - fail_if(count != sizeof (attribute) / sizeof (attribute[0])); + ck_assert(count != sizeof (attribute) / sizeof (attribute[0])); eina_iterator_free(it); count = 0; @@ -188,12 +188,12 @@ EFL_START_TEST(eina_test_xattr_list) break ; } } - fail_if(count != sizeof (data) / sizeof (data[0])); + ck_assert(count != sizeof (data) / sizeof (data[0])); eina_iterator_free(it); /* Test case for eina_xattr_copy and eina_xattr_fd_copy */ ret = eina_xattr_copy(test_file_path, cp_file_path); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); count = 0; it = eina_xattr_value_ls(cp_file_path); @@ -207,17 +207,17 @@ EFL_START_TEST(eina_test_xattr_list) break ; } } - fail_if(count != sizeof (data) / sizeof (data[0])); + ck_assert(count != sizeof (data) / sizeof (data[0])); eina_iterator_free(it); for (i = 0; i < sizeof(attribute) / sizeof(attribute[0]); ++i) { ret = eina_xattr_del(cp_file_path, attribute[i]); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); } ret = eina_xattr_fd_copy(fd, fd1); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); count = 0; it = eina_xattr_value_fd_ls(fd1); @@ -231,7 +231,7 @@ EFL_START_TEST(eina_test_xattr_list) break ; } } - fail_if(count != sizeof (data) / sizeof (data[0])); + ck_assert(count != sizeof (data) / sizeof (data[0])); eina_iterator_free(it); close(fd); @@ -259,26 +259,26 @@ EFL_START_TEST(eina_test_xattr_types) test_file_path = get_file_path(XATTR_TEST_DIR, filename); fd = open(test_file_path, O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU | S_IRWXG | S_IRWXO); - fail_if(fd == 0); + ck_assert(fd == 0); ret = eina_xattr_string_set(test_file_path, str_attr, str_data, EINA_XATTR_INSERT); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret_str = eina_xattr_string_get(test_file_path, str_attr); - fail_if(ret_str == NULL); - fail_if(strcmp(ret_str, str_data) != 0); + ck_assert(ret_str == NULL); + ck_assert(strcmp(ret_str, str_data) != 0); free(ret_str); ret = eina_xattr_int_set(test_file_path, int_attr, int_data, EINA_XATTR_INSERT); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret = eina_xattr_int_get(test_file_path, int_attr, &int_ret); - fail_if(ret != EINA_TRUE); - fail_if(int_data != int_ret); + ck_assert(ret != EINA_TRUE); + ck_assert(int_data != int_ret); ret = eina_xattr_double_set(test_file_path, double_attr, double_data, EINA_XATTR_INSERT); - fail_if(ret != EINA_TRUE); + ck_assert(ret != EINA_TRUE); ret = eina_xattr_double_get(test_file_path, double_attr, &double_ret); - fail_if(ret != EINA_TRUE); - fail_if(!EINA_DBL_EQ(double_data, double_ret)); + ck_assert(ret != EINA_TRUE); + ck_assert(!EINA_DBL_EQ(double_data, double_ret)); close(fd); unlink(test_file_path);