From 825a3d837a33f226c879cd02ad15c3fba57e8b2c Mon Sep 17 00:00:00 2001 From: David Walter Seikel Date: Mon, 23 Jan 2012 23:30:42 +1000 Subject: Update the EFL to what I'm actually using, coz I'm using some stuff not yet released. --- libraries/eina/src/tests/Makefile.am | 9 +- libraries/eina/src/tests/Makefile.in | 77 +- libraries/eina/src/tests/cxx_compile_test.cxx | 34 + libraries/eina/src/tests/eina_bench.c | 3 +- libraries/eina/src/tests/eina_bench_hash.c | 2 + libraries/eina/src/tests/eina_bench_quad.c | 2 + libraries/eina/src/tests/eina_bench_stringshare.c | 8 + libraries/eina/src/tests/eina_suite.c | 2 + libraries/eina/src/tests/eina_suite.h | 2 + libraries/eina/src/tests/eina_test_array.c | 6 +- libraries/eina/src/tests/eina_test_binbuf.c | 36 +- libraries/eina/src/tests/eina_test_file.c | 4 +- libraries/eina/src/tests/eina_test_inarray.c | 401 +++++ libraries/eina/src/tests/eina_test_value.c | 1799 +++++++++++++++++++++ libraries/eina/src/tests/evas_list.c | 2 +- libraries/eina/src/tests/evas_mempool.c | 2 +- 16 files changed, 2358 insertions(+), 31 deletions(-) create mode 100644 libraries/eina/src/tests/cxx_compile_test.cxx create mode 100644 libraries/eina/src/tests/eina_test_inarray.c create mode 100644 libraries/eina/src/tests/eina_test_value.c (limited to 'libraries/eina/src/tests') diff --git a/libraries/eina/src/tests/Makefile.am b/libraries/eina/src/tests/Makefile.am index a413e6e..7e05ba9 100644 --- a/libraries/eina/src/tests/Makefile.am +++ b/libraries/eina/src/tests/Makefile.am @@ -28,7 +28,7 @@ endif if EFL_ENABLE_TESTS -check_PROGRAMS = eina_suite +check_PROGRAMS = eina_suite cxx_compile_test eina_suite_SOURCES = \ eina_suite.c \ @@ -38,6 +38,7 @@ eina_test_ustringshare.c\ eina_test_ustr.c \ eina_test_binshare.c \ eina_test_binbuf.c \ +eina_test_inarray.c \ eina_test_array.c \ eina_test_clist.c \ eina_test_error.c \ @@ -64,10 +65,14 @@ eina_test_tiler.c \ eina_test_strbuf.c \ eina_test_str.c \ eina_test_quadtree.c \ -eina_test_simple_xml_parser.c +eina_test_simple_xml_parser.c \ +eina_test_value.c eina_suite_LDADD = @CHECK_LIBS@ $(top_builddir)/src/lib/libeina.la -lm +cxx_compile_test_SOURCES = cxx_compile_test.cxx +cxx_compile_test_LDADD = $(top_builddir)/src/lib/libeina.la + module_dummydir = $(libdir)/eina/test module_dummy_LTLIBRARIES = module_dummy.la diff --git a/libraries/eina/src/tests/Makefile.in b/libraries/eina/src/tests/Makefile.in index b5983b3..c56211a 100644 --- a/libraries/eina/src/tests/Makefile.in +++ b/libraries/eina/src/tests/Makefile.in @@ -37,7 +37,8 @@ build_triplet = @build@ host_triplet = @host@ @EINA_HAVE_GLIB_TRUE@am__append_1 = -DEINA_BENCH_HAVE_GLIB @EINA_ENABLE_BENCHMARK_E17_TRUE@am__append_2 = -DEINA_ENABLE_BENCH_E17 -@EFL_ENABLE_TESTS_TRUE@check_PROGRAMS = eina_suite$(EXEEXT) +@EFL_ENABLE_TESTS_TRUE@check_PROGRAMS = eina_suite$(EXEEXT) \ +@EFL_ENABLE_TESTS_TRUE@ cxx_compile_test$(EXEEXT) @EFL_ENABLE_BENCHMARK_TRUE@bench_PROGRAMS = eina_bench$(EXEEXT) subdir = src/tests DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in @@ -107,6 +108,12 @@ module_dummy_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \ @EFL_ENABLE_TESTS_TRUE@am_module_dummy_la_rpath = -rpath \ @EFL_ENABLE_TESTS_TRUE@ $(module_dummydir) PROGRAMS = $(bench_PROGRAMS) +am__cxx_compile_test_SOURCES_DIST = cxx_compile_test.cxx +@EFL_ENABLE_TESTS_TRUE@am_cxx_compile_test_OBJECTS = \ +@EFL_ENABLE_TESTS_TRUE@ cxx_compile_test.$(OBJEXT) +cxx_compile_test_OBJECTS = $(am_cxx_compile_test_OBJECTS) +@EFL_ENABLE_TESTS_TRUE@cxx_compile_test_DEPENDENCIES = \ +@EFL_ENABLE_TESTS_TRUE@ $(top_builddir)/src/lib/libeina.la am__eina_bench_SOURCES_DIST = eina_bench.c eina_bench_sort.c \ eina_bench_hash.c eina_bench_stringshare.c \ eina_bench_convert.c eina_bench_mempool.c \ @@ -142,16 +149,17 @@ eina_bench_OBJECTS = $(am_eina_bench_OBJECTS) am__eina_suite_SOURCES_DIST = eina_suite.c eina_test_fp.c \ eina_test_stringshare.c eina_test_ustringshare.c \ eina_test_ustr.c eina_test_binshare.c eina_test_binbuf.c \ - eina_test_array.c eina_test_clist.c eina_test_error.c \ - eina_test_sched.c eina_test_log.c eina_test_magic.c \ - eina_test_inlist.c eina_test_main.c eina_test_counter.c \ - eina_test_lalloc.c eina_test_hash.c eina_test_iterator.c \ - eina_test_accessor.c eina_test_module.c eina_test_convert.c \ - eina_test_rbtree.c eina_test_file.c eina_test_benchmark.c \ - eina_test_mempool.c eina_test_rectangle.c eina_test_list.c \ + eina_test_inarray.c eina_test_array.c eina_test_clist.c \ + eina_test_error.c eina_test_sched.c eina_test_log.c \ + eina_test_magic.c eina_test_inlist.c eina_test_main.c \ + eina_test_counter.c eina_test_lalloc.c eina_test_hash.c \ + eina_test_iterator.c eina_test_accessor.c eina_test_module.c \ + eina_test_convert.c eina_test_rbtree.c eina_test_file.c \ + eina_test_benchmark.c eina_test_mempool.c \ + eina_test_rectangle.c eina_test_list.c \ eina_test_matrixsparse.c eina_test_tiler.c eina_test_strbuf.c \ eina_test_str.c eina_test_quadtree.c \ - eina_test_simple_xml_parser.c + eina_test_simple_xml_parser.c eina_test_value.c @EFL_ENABLE_TESTS_TRUE@am_eina_suite_OBJECTS = eina_suite.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_fp.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_stringshare.$(OBJEXT) \ @@ -159,6 +167,7 @@ am__eina_suite_SOURCES_DIST = eina_suite.c eina_test_fp.c \ @EFL_ENABLE_TESTS_TRUE@ eina_test_ustr.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_binshare.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_binbuf.$(OBJEXT) \ +@EFL_ENABLE_TESTS_TRUE@ eina_test_inarray.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_array.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_clist.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_error.$(OBJEXT) \ @@ -185,7 +194,8 @@ am__eina_suite_SOURCES_DIST = eina_suite.c eina_test_fp.c \ @EFL_ENABLE_TESTS_TRUE@ eina_test_strbuf.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_str.$(OBJEXT) \ @EFL_ENABLE_TESTS_TRUE@ eina_test_quadtree.$(OBJEXT) \ -@EFL_ENABLE_TESTS_TRUE@ eina_test_simple_xml_parser.$(OBJEXT) +@EFL_ENABLE_TESTS_TRUE@ eina_test_simple_xml_parser.$(OBJEXT) \ +@EFL_ENABLE_TESTS_TRUE@ eina_test_value.$(OBJEXT) eina_suite_OBJECTS = $(am_eina_suite_OBJECTS) @EFL_ENABLE_TESTS_TRUE@eina_suite_DEPENDENCIES = \ @EFL_ENABLE_TESTS_TRUE@ $(top_builddir)/src/lib/libeina.la @@ -232,10 +242,11 @@ AM_V_GEN = $(am__v_GEN_$(V)) am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) am__v_GEN_0 = @echo " GEN " $@; SOURCES = $(libcity_la_SOURCES) $(module_dummy_la_SOURCES) \ - $(eina_bench_SOURCES) $(nodist_EXTRA_eina_bench_SOURCES) \ - $(eina_suite_SOURCES) + $(cxx_compile_test_SOURCES) $(eina_bench_SOURCES) \ + $(nodist_EXTRA_eina_bench_SOURCES) $(eina_suite_SOURCES) DIST_SOURCES = $(am__libcity_la_SOURCES_DIST) \ $(am__module_dummy_la_SOURCES_DIST) \ + $(am__cxx_compile_test_SOURCES_DIST) \ $(am__eina_bench_SOURCES_DIST) $(am__eina_suite_SOURCES_DIST) ETAGS = etags CTAGS = ctags @@ -282,7 +293,9 @@ EFL_SIMD_FLAGS = @EFL_SIMD_FLAGS@ EGREP = @EGREP@ EINA_CFLAGS = @EINA_CFLAGS@ EINA_CONFIGURE_DEFAULT_MEMPOOL = @EINA_CONFIGURE_DEFAULT_MEMPOOL@ +EINA_CONFIGURE_ENABLE_LOG = @EINA_CONFIGURE_ENABLE_LOG@ EINA_CONFIGURE_HAVE_DEBUG_THREADS = @EINA_CONFIGURE_HAVE_DEBUG_THREADS@ +EINA_CONFIGURE_HAVE_DIRENT_H = @EINA_CONFIGURE_HAVE_DIRENT_H@ EINA_CONFIGURE_HAVE_INTTYPES_H = @EINA_CONFIGURE_HAVE_INTTYPES_H@ EINA_CONFIGURE_HAVE_ON_OFF_THREADS = @EINA_CONFIGURE_HAVE_ON_OFF_THREADS@ EINA_CONFIGURE_HAVE_STDINT_H = @EINA_CONFIGURE_HAVE_STDINT_H@ @@ -334,8 +347,6 @@ PACKAGE_URL = @PACKAGE_URL@ PACKAGE_VERSION = @PACKAGE_VERSION@ PATH_SEPARATOR = @PATH_SEPARATOR@ PKG_CONFIG = @PKG_CONFIG@ -PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@ -PKG_CONFIG_PATH = @PKG_CONFIG_PATH@ RANLIB = @RANLIB@ SED = @SED@ SET_MAKE = @SET_MAKE@ @@ -426,6 +437,7 @@ AM_CPPFLAGS = -I$(top_srcdir)/src/lib -I$(top_srcdir)/src/include \ @EFL_ENABLE_TESTS_TRUE@eina_test_ustr.c \ @EFL_ENABLE_TESTS_TRUE@eina_test_binshare.c \ @EFL_ENABLE_TESTS_TRUE@eina_test_binbuf.c \ +@EFL_ENABLE_TESTS_TRUE@eina_test_inarray.c \ @EFL_ENABLE_TESTS_TRUE@eina_test_array.c \ @EFL_ENABLE_TESTS_TRUE@eina_test_clist.c \ @EFL_ENABLE_TESTS_TRUE@eina_test_error.c \ @@ -452,9 +464,12 @@ AM_CPPFLAGS = -I$(top_srcdir)/src/lib -I$(top_srcdir)/src/include \ @EFL_ENABLE_TESTS_TRUE@eina_test_strbuf.c \ @EFL_ENABLE_TESTS_TRUE@eina_test_str.c \ @EFL_ENABLE_TESTS_TRUE@eina_test_quadtree.c \ -@EFL_ENABLE_TESTS_TRUE@eina_test_simple_xml_parser.c +@EFL_ENABLE_TESTS_TRUE@eina_test_simple_xml_parser.c \ +@EFL_ENABLE_TESTS_TRUE@eina_test_value.c @EFL_ENABLE_TESTS_TRUE@eina_suite_LDADD = @CHECK_LIBS@ $(top_builddir)/src/lib/libeina.la -lm +@EFL_ENABLE_TESTS_TRUE@cxx_compile_test_SOURCES = cxx_compile_test.cxx +@EFL_ENABLE_TESTS_TRUE@cxx_compile_test_LDADD = $(top_builddir)/src/lib/libeina.la @EFL_ENABLE_TESTS_TRUE@module_dummydir = $(libdir)/eina/test @EFL_ENABLE_TESTS_TRUE@module_dummy_LTLIBRARIES = module_dummy.la @EFL_ENABLE_TESTS_TRUE@module_dummy_la_SOURCES = \ @@ -506,7 +521,7 @@ EXTRA_DIST = eina_bench.h \ all: all-am .SUFFIXES: -.SUFFIXES: .c .cc .lo .o .obj +.SUFFIXES: .c .cc .cxx .lo .o .obj $(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) @for dep in $?; do \ case '$(am__configure_deps)' in \ @@ -633,6 +648,9 @@ clean-checkPROGRAMS: list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ echo " rm -f" $$list; \ rm -f $$list +cxx_compile_test$(EXEEXT): $(cxx_compile_test_OBJECTS) $(cxx_compile_test_DEPENDENCIES) + @rm -f cxx_compile_test$(EXEEXT) + $(AM_V_CXXLD)$(CXXLINK) $(cxx_compile_test_OBJECTS) $(cxx_compile_test_LDADD) $(LIBS) eina_bench$(EXEEXT): $(eina_bench_OBJECTS) $(eina_bench_DEPENDENCIES) @rm -f eina_bench$(EXEEXT) $(AM_V_CXXLD)$(CXXLINK) $(eina_bench_OBJECTS) $(eina_bench_LDADD) $(LIBS) @@ -647,6 +665,7 @@ distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/city.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cxx_compile_test.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dummy.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_hash.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_list.Po@am__quote@ @@ -675,6 +694,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_file.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_fp.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_hash.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_inarray.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_inlist.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_iterator.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_lalloc.Po@am__quote@ @@ -696,6 +716,7 @@ distclean-compile: @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_tiler.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_ustr.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_ustringshare.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eina_test_value.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/evas_hash.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/evas_list.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/evas_mempool.Po@am__quote@ @@ -759,6 +780,30 @@ module_dummy_la-eina_test_module_dummy.lo: eina_test_module_dummy.c @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< +.cxx.o: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@am__fastdepCXX_FALSE@ $(AM_V_CXX) @AM_BACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ $< + +.cxx.obj: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@am__fastdepCXX_FALSE@ $(AM_V_CXX) @AM_BACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'` + +.cxx.lo: +@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo +@am__fastdepCXX_FALSE@ $(AM_V_CXX) @AM_BACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCXX_FALSE@ $(LTCXXCOMPILE) -c -o $@ $< + mostlyclean-libtool: -rm -f *.lo diff --git a/libraries/eina/src/tests/cxx_compile_test.cxx b/libraries/eina/src/tests/cxx_compile_test.cxx new file mode 100644 index 0000000..7d8af76 --- /dev/null +++ b/libraries/eina/src/tests/cxx_compile_test.cxx @@ -0,0 +1,34 @@ +/* EINA - EFL data type library + * Copyright (C) 2012 ProFUSION embedded systems + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; + * if not, see . + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include "Eina.h" + +#include +using namespace std; + +int main() +{ + eina_init(); + cout << "Eina compiles with C++!"; + eina_shutdown(); + return 0; +} diff --git a/libraries/eina/src/tests/eina_bench.c b/libraries/eina/src/tests/eina_bench.c index a4eadbe..03aaaf9 100644 --- a/libraries/eina/src/tests/eina_bench.c +++ b/libraries/eina/src/tests/eina_bench.c @@ -73,7 +73,6 @@ int main(int argc, char **argv) { Eina_Benchmark *test; - Eina_Array *ea; unsigned int i; if (argc != 2) @@ -91,7 +90,7 @@ main(int argc, char **argv) etc[i].build(test); - ea = eina_benchmark_run(test); + eina_benchmark_run(test); eina_benchmark_free(test); } diff --git a/libraries/eina/src/tests/eina_bench_hash.c b/libraries/eina/src/tests/eina_bench_hash.c index 5b42318..0429097 100644 --- a/libraries/eina/src/tests/eina_bench_hash.c +++ b/libraries/eina/src/tests/eina_bench_hash.c @@ -139,6 +139,8 @@ eina_bench_lookup_rbtree(int request) EINA_RBTREE_CMP_KEY_CB( _eina_bench_rbtree_key), NULL); + /* Suppress warnings as we really don't want to do anything. */ + (void) tmp; } eina_rbtree_delete(root, EINA_RBTREE_FREE_CB(_eina_bench_rbtree_free), NULL); diff --git a/libraries/eina/src/tests/eina_bench_quad.c b/libraries/eina/src/tests/eina_bench_quad.c index 76d6667..8401fd4 100644 --- a/libraries/eina/src/tests/eina_bench_quad.c +++ b/libraries/eina/src/tests/eina_bench_quad.c @@ -19,6 +19,8 @@ #define WIDTH 720 #define HEIGHT 576 +#include + #include "eina_main.h" #include "eina_mempool.h" #include "eina_rectangle.h" diff --git a/libraries/eina/src/tests/eina_bench_stringshare.c b/libraries/eina/src/tests/eina_bench_stringshare.c index a2c7b38..22d18fa 100644 --- a/libraries/eina/src/tests/eina_bench_stringshare.c +++ b/libraries/eina/src/tests/eina_bench_stringshare.c @@ -64,6 +64,8 @@ eina_bench_stringshare_job(int request) tmp = eina_stringshare_add(build); } + /* Suppress warnings as we really don't want to do anything. */ + (void) tmp; eina_shutdown(); } @@ -125,6 +127,9 @@ eina_bench_evas_job(int request) eina_convert_xtoa(rand() % request, build + 7); tmp = evas_stringshare_add(build); } + + /* Suppress warnings as we really don't want to do anything. */ + (void) tmp; } static void @@ -155,6 +160,9 @@ eina_bench_ecore_job(int request) tmp = ecore_string_instance(build); } + /* Suppress warnings as we really don't want to do anything. */ + (void) tmp; + ecore_string_shutdown(); } diff --git a/libraries/eina/src/tests/eina_suite.c b/libraries/eina/src/tests/eina_suite.c index 9b748fc..648a717 100644 --- a/libraries/eina/src/tests/eina_suite.c +++ b/libraries/eina/src/tests/eina_suite.c @@ -34,6 +34,7 @@ struct _Eina_Test_Case static const Eina_Test_Case etc[] = { { "FixedPoint", eina_test_fp }, + { "Inarray", eina_test_inarray }, { "Array", eina_test_array }, { "Binary Share", eina_test_binshare }, { "String Share", eina_test_stringshare }, @@ -66,6 +67,7 @@ static const Eina_Test_Case etc[] = { { "QuadTree", eina_test_quadtree }, { "Sched", eina_test_sched }, { "Simple Xml Parser", eina_test_simple_xml_parser}, + { "Value", eina_test_value }, { NULL, NULL } }; diff --git a/libraries/eina/src/tests/eina_suite.h b/libraries/eina/src/tests/eina_suite.h index 643d6cc..6eaaec7 100644 --- a/libraries/eina/src/tests/eina_suite.h +++ b/libraries/eina/src/tests/eina_suite.h @@ -24,6 +24,7 @@ void eina_test_stringshare(TCase *tc); void eina_test_ustringshare(TCase *tc); void eina_test_binshare(TCase *tc); +void eina_test_inarray(TCase *tc); void eina_test_array(TCase *tc); void eina_test_log(TCase *tc); void eina_test_error(TCase *tc); @@ -54,5 +55,6 @@ void eina_test_quadtree(TCase *tc); void eina_test_fp(TCase *tc); void eina_test_sched(TCase *tc); void eina_test_simple_xml_parser(TCase *tc); +void eina_test_value(TCase *tc); #endif /* EINA_SUITE_H_ */ diff --git a/libraries/eina/src/tests/eina_test_array.c b/libraries/eina/src/tests/eina_test_array.c index 0b054ea..1929601 100644 --- a/libraries/eina/src/tests/eina_test_array.c +++ b/libraries/eina/src/tests/eina_test_array.c @@ -151,7 +151,7 @@ START_TEST(eina_array_remove_stuff) } fail_if(eina_array_remove(ea, keep_int, NULL) != EINA_TRUE); - fail_if(eina_array_count_get(ea) != 990); + fail_if(eina_array_count(ea) != 990); EINA_ARRAY_ITER_NEXT(ea, i, tmp, it) fail_if(*tmp == 0); @@ -165,7 +165,7 @@ START_TEST(eina_array_remove_stuff) eina_array_remove(ea, keep_int, NULL); // Remove all items - fail_if(eina_array_count_get(ea) != 980); + fail_if(eina_array_count(ea) != 980); EINA_ARRAY_ITER_NEXT(ea, i, tmp, it) { fail_if(*tmp == 0); @@ -174,7 +174,7 @@ START_TEST(eina_array_remove_stuff) eina_array_remove(ea, keep_int, NULL); - fail_if(eina_array_count_get(ea) != 0); + fail_if(eina_array_count(ea) != 0); eina_array_free(ea); diff --git a/libraries/eina/src/tests/eina_test_binbuf.c b/libraries/eina/src/tests/eina_test_binbuf.c index 713e078..d62072e 100644 --- a/libraries/eina/src/tests/eina_test_binbuf.c +++ b/libraries/eina/src/tests/eina_test_binbuf.c @@ -27,8 +27,8 @@ START_TEST(binbuf_simple) { Eina_Binbuf *buf; - char *txt; - const char cbuf[] = "Null in the middle \0 and more text afterwards and \0 anotehr null just there and another one \0 here."; + unsigned char *txt; + const unsigned char cbuf[] = "Null in the middle \0 and more text afterwards and \0 anotehr null just there and another one \0 here."; size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ @@ -69,7 +69,7 @@ END_TEST START_TEST(binbuf_remove) { Eina_Binbuf *buf; - const char cbuf[] = "12\0 456 78\0 abcthis is some more random junk here!"; + const unsigned char cbuf[] = "12\0 456 78\0 abcthis is some more random junk here!"; size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ eina_init(); @@ -98,6 +98,33 @@ START_TEST(binbuf_remove) } END_TEST +START_TEST(binbuf_manage_simple) +{ + Eina_Binbuf *buf; + const char *_cbuf = "12\0 456 78\0 abcthis is some more random junk here!"; + const unsigned char *cbuf = (const unsigned char *) _cbuf; + size_t size = sizeof(cbuf) - 1; /* We don't care about the real NULL */ + unsigned char *alloc_buf = malloc(size); + memcpy(alloc_buf, cbuf, size); + + eina_init(); + + buf = eina_binbuf_manage_new_length(alloc_buf, size); + fail_if(!buf); + + fail_if(memcmp(eina_binbuf_string_get(buf), cbuf, size)); + fail_if(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)); + + eina_binbuf_free(buf); + + eina_shutdown(); +} +END_TEST + START_TEST(binbuf_insert) { #if 0 @@ -154,7 +181,7 @@ END_TEST START_TEST(binbuf_realloc) { Eina_Binbuf *buf; - char pattern[1024 * 16]; + unsigned char pattern[1024 * 16]; unsigned int i; size_t sz; @@ -232,4 +259,5 @@ eina_test_binbuf(TCase *tc) tcase_add_test(tc, binbuf_remove); tcase_add_test(tc, binbuf_insert); tcase_add_test(tc, binbuf_realloc); + tcase_add_test(tc, binbuf_manage_simple); } diff --git a/libraries/eina/src/tests/eina_test_file.c b/libraries/eina/src/tests/eina_test_file.c index aeb5461..55e9976 100644 --- a/libraries/eina/src/tests/eina_test_file.c +++ b/libraries/eina/src/tests/eina_test_file.c @@ -48,7 +48,7 @@ START_TEST(eina_file_split_simple) #endif fail_if(!ea); - fail_if(eina_array_count_get(ea) != 5); + 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")); @@ -66,7 +66,7 @@ START_TEST(eina_file_split_simple) #endif fail_if(!ea); - fail_if(eina_array_count_get(ea) != 6); + 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 ")); diff --git a/libraries/eina/src/tests/eina_test_inarray.c b/libraries/eina/src/tests/eina_test_inarray.c new file mode 100644 index 0000000..22ba763 --- /dev/null +++ b/libraries/eina/src/tests/eina_test_inarray.c @@ -0,0 +1,401 @@ +/* EINA - EFL data type library + * Copyright (C) 2012 ProFUSION embedded systems + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; + * if not, see . + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include + +#include "eina_suite.h" +#include "Eina.h" + +START_TEST(eina_inarray_test_simple) +{ + const int test_members = 5; + Eina_Inarray *array; + int i, pos, *member; + const struct spec { + int pos, value; + } *s, specs[] = { + {test_members, 1234}, + {5, 0x1337}, + {0, 0xbeef}, + {-1, -1} + }; + + eina_init(); + + array = eina_inarray_new(sizeof(int), 2); + fail_unless(array != NULL); + + for (i = 0; i < test_members; i++) + { + pos = eina_inarray_append(array, &i); + fail_unless(pos == i); + } + fail_unless(eina_inarray_count(array) == (unsigned)test_members); + + for (i = 0; i < test_members; i++) + { + member = eina_inarray_nth(array, i); + fail_unless(*member == i); + } + + for (s = specs; s->pos >= 0; s++) + { + fail_unless(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); + } + member = eina_inarray_nth(array, s->pos); + fail_unless(*member == s->value); + for (i = s->pos + 1; i < test_members + 1; i++) + { + member = eina_inarray_nth(array, i); + fail_unless(*member == i - 1); + } + + fail_unless(eina_inarray_remove_at(array, s->pos)); + for (i = 0; i < test_members; i++) + { + member = eina_inarray_nth(array, i); + fail_unless(*member == i); + } + } + + eina_inarray_free(array); + eina_shutdown(); +} +END_TEST + + +START_TEST(eina_inarray_test_alloc_at) +{ + Eina_Inarray *array; + int *member; + int i; + + eina_init(); + + array = eina_inarray_new(sizeof(int), 2); + fail_unless(array != NULL); + + member = eina_inarray_alloc_at(array, 0, 4); + fail_unless(member != NULL); + fail_unless(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); + 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); + for (i = 0; i < 2; i++) + member[i] = i + 6; + + member = array->members; + for (i = 0; i < 8; i++) + fail_unless(member[i] == i); + + eina_inarray_free(array); + eina_shutdown(); +} +END_TEST + +static const short rand_numbers[] = { + 9, 0, 2, 3, 6, 5, 4, 7, 8, 1, 10 +}; +static const int numbers_count = sizeof(rand_numbers)/sizeof(rand_numbers[0]); + +static void +show_sort_array(const Eina_Inarray *array) +{ + int i, len = eina_inarray_count(array); + printf("array with %d members:\n", len); + for (i = 0; i < len; i++) + { + short *member = eina_inarray_nth(array, i); + printf("\tarray[%2d]=%5hd\n", i, *member); + } +} + +static Eina_Bool +check_short_sorted(const Eina_Inarray *array) +{ + int i; + for (i = 0; i < numbers_count; i++) + { + short *member = eina_inarray_nth(array, i); + if (*member != (short)i) + { + show_sort_array(array); + fprintf(stderr, "not sorted at %d: %hd\n", i, *member); + return EINA_FALSE; + } + } + return EINA_TRUE; +} + +static int +short_cmp(const void *pa, const void *pb) +{ + const short *a = pa, *b = pb; + return *a - *b; +} + +START_TEST(eina_inarray_test_insert_sort) +{ + Eina_Inarray *array; + int i, pos; + + eina_init(); + + array = eina_inarray_new(sizeof(short), 1); + fail_unless(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); + } + fail_unless(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); + } + fail_unless(check_short_sorted(array)); + eina_inarray_flush(array); + + /* insert sorted the reverse sequence */ + for (i = 0; i < numbers_count; i++) + { + short val = numbers_count - i - 1; + pos = eina_inarray_insert(array, &val, short_cmp); + fail_unless(pos == 0); + } + fail_unless(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); + } + fail_unless(check_short_sorted(array)); + eina_inarray_flush(array); + + /* insert sorted random numbers */ + for (i = 0; i < numbers_count; i++) + { + short val = rand_numbers[i]; + eina_inarray_insert(array, &val, short_cmp); + } + fail_unless(check_short_sorted(array)); + eina_inarray_flush(array); + + for (i = 0; i < numbers_count; i++) + { + short val = rand_numbers[i]; + eina_inarray_insert_sorted(array, &val, short_cmp); + } + fail_unless(check_short_sorted(array)); + eina_inarray_flush(array); + + eina_inarray_free(array); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_inarray_test_sort) +{ + Eina_Inarray *array; + int i; + + eina_init(); + + array = eina_inarray_new(sizeof(short), 1); + fail_unless(array != NULL); + + for (i = 0; i < numbers_count; i++) + { + short val = rand_numbers[i]; + eina_inarray_append(array, &val); + } + eina_inarray_sort(array, short_cmp); + fail_unless(check_short_sorted(array)); + eina_inarray_free(array); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_inarray_test_reverse) +{ + Eina_Inarray *array; + int i; + + eina_init(); + + array = eina_inarray_new(sizeof(short), 1); + fail_unless(array != NULL); + + for (i = 0; i < numbers_count; i++) + { + short val = i; + eina_inarray_append(array, &val); + } + eina_inarray_reverse(array); + + for (i = 0; i < numbers_count; i++) + { + short *member = eina_inarray_nth(array, i); + fail_unless(*member == (numbers_count - i - 1)); + } + + eina_inarray_free(array); + eina_shutdown(); +} +END_TEST + +static Eina_Bool +array_foreach(const void *array __UNUSED__, void *p, void *user_data __UNUSED__) +{ + short *member = p; + int *i = user_data; + fail_unless(*i == *member); + (*i)++; + return EINA_TRUE; +} + +static Eina_Bool +array_foreach_stop_2nd(const void *array __UNUSED__, void *p, void *user_data __UNUSED__) +{ + short *member = p; + int *i = user_data; + fail_unless(*i == *member); + if (*i == 1) + return EINA_FALSE; + (*i)++; + return EINA_TRUE; +} + +START_TEST(eina_inarray_test_itr) +{ + Eina_Inarray *array; + Eina_Iterator *it; + Eina_Accessor *ac; + short *member; + int i; + + eina_init(); + + array = eina_inarray_new(sizeof(short), 1); + fail_unless(array != NULL); + + for (i = 0; i < numbers_count; i++) + { + short val = i; + eina_inarray_append(array, &val); + } + i = 0; + EINA_INARRAY_FOREACH(array, member) + { + fail_unless(*member == i); + i++; + } + fail_unless(i == numbers_count); + + i--; + EINA_INARRAY_REVERSE_FOREACH(array, member) + { + fail_unless(*member == i); + i--; + } + fail_unless(i == -1); + + i = 0; + fail_unless(eina_inarray_foreach(array, array_foreach, &i)); + fail_unless(i == numbers_count); + + i = 0; + fail_if(eina_inarray_foreach(array, array_foreach_stop_2nd, &i)); + fail_unless(i == 1); + + it = eina_inarray_iterator_new(array); + fail_unless(it != NULL); + i = 0; + EINA_ITERATOR_FOREACH(it, member) + { + fail_unless(*member == i); + i++; + } + fail_unless(i == numbers_count); + eina_iterator_free(it); + + it = eina_inarray_iterator_reversed_new(array); + fail_unless(it != NULL); + i--; + EINA_ITERATOR_FOREACH(it, member) + { + fail_unless(*member == i); + i--; + } + fail_unless(i == -1); + eina_iterator_free(it); + + ac = eina_inarray_accessor_new(array); + fail_unless(ac != NULL); + for (i = 0; i < numbers_count; i++) + { + fail_unless(eina_accessor_data_get(ac, i, (void **)&member)); + fail_unless(*member == i); + } + fail_unless(i == numbers_count); + eina_accessor_free(ac); + + eina_inarray_free(array); + eina_shutdown(); +} +END_TEST + +void +eina_test_inarray(TCase *tc) +{ + tcase_add_test(tc, eina_inarray_test_simple); + tcase_add_test(tc, eina_inarray_test_alloc_at); + tcase_add_test(tc, eina_inarray_test_insert_sort); + tcase_add_test(tc, eina_inarray_test_sort); + tcase_add_test(tc, eina_inarray_test_reverse); + tcase_add_test(tc, eina_inarray_test_itr); +} diff --git a/libraries/eina/src/tests/eina_test_value.c b/libraries/eina/src/tests/eina_test_value.c new file mode 100644 index 0000000..2d04c2f --- /dev/null +++ b/libraries/eina/src/tests/eina_test_value.c @@ -0,0 +1,1799 @@ +/* EINA - EFL data type library + * Copyright (C) 2012 ProFUSION embedded systems + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; + * if not, see . + */ + +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include + +#include "eina_suite.h" +#include "Eina.h" + +#define FP_ERR (0.0000001) +#define CHECK_FP(a, b) ((a - b) < FP_ERR) + +START_TEST(eina_value_test_simple) +{ + Eina_Value *value; + char c; + short s; + int i; + long l; + int64_t i64; + unsigned char uc; + unsigned short us; + unsigned int ui; + unsigned long ul; + uint64_t u64; + float f; + double d; + + eina_init(); + + 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'); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + eina_value_flush(value); + + fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); + fail_unless(eina_value_set(value, 3000000001U)); + fail_unless(eina_value_get(value, &ul)); + fail_unless(ul == 3000000001U); + 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); + 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)); + 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)); + eina_value_flush(value); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_compare) +{ + Eina_Value *a, *b; + + eina_init(); + + a = eina_value_new(EINA_VALUE_TYPE_CHAR); + fail_unless(a != NULL); + b = eina_value_new(EINA_VALUE_TYPE_CHAR); + fail_unless(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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + + fail_unless(eina_value_array_append(a, 1)); + fail_unless(eina_value_array_append(a, 2)); + fail_unless(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)); + + fail_unless(eina_value_compare(a, b) == 0); + + fail_unless(eina_value_array_set(a, 0, 0)); + fail_unless(eina_value_compare(a, b) < 0); + + fail_unless(eina_value_array_set(a, 0, 10)); + fail_unless(eina_value_compare(a, b) > 0); + + fail_unless(eina_value_array_set(a, 0, 1)); + + fail_unless(eina_value_array_set(b, 0, 0)); + fail_unless(eina_value_compare(a, b) > 0); + + fail_unless(eina_value_array_set(b, 0, 10)); + fail_unless(eina_value_compare(a, b) < 0); + + fail_unless(eina_value_array_set(b, 0, 1)); + fail_unless(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); + + fail_unless(eina_value_array_append(a, 0)); + fail_unless(eina_value_array_append(a, 0)); + fail_unless(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); + + 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); + + fail_unless(eina_value_list_append(a, 1)); + fail_unless(eina_value_list_append(a, 2)); + fail_unless(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)); + + fail_unless(eina_value_compare(a, b) == 0); + + fail_unless(eina_value_list_set(a, 0, 0)); + fail_unless(eina_value_compare(a, b) < 0); + + fail_unless(eina_value_list_set(a, 0, 10)); + fail_unless(eina_value_compare(a, b) > 0); + + fail_unless(eina_value_list_set(a, 0, 1)); + + fail_unless(eina_value_list_set(b, 0, 0)); + fail_unless(eina_value_compare(a, b) > 0); + + fail_unless(eina_value_list_set(b, 0, 10)); + fail_unless(eina_value_compare(a, b) < 0); + + fail_unless(eina_value_list_set(b, 0, 1)); + fail_unless(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); + + fail_unless(eina_value_list_append(a, 0)); + fail_unless(eina_value_list_append(a, 0)); + fail_unless(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); + + 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); + + 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)); + + 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)); + + fail_unless(eina_value_compare(a, b) == 0); + + fail_unless(eina_value_hash_set(a, "abc", 0)); + fail_unless(eina_value_compare(a, b) < 0); + + fail_unless(eina_value_hash_set(a, "abc", 10)); + fail_unless(eina_value_compare(a, b) > 0); + + fail_unless(eina_value_hash_set(a, "abc", 1)); + + fail_unless(eina_value_hash_set(b, "abc", 0)); + fail_unless(eina_value_compare(a, b) > 0); + + fail_unless(eina_value_hash_set(b, "abc", 10)); + fail_unless(eina_value_compare(a, b) < 0); + + fail_unless(eina_value_hash_set(b, "abc", 1)); + fail_unless(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); + + 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); + + /* 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); + + eina_value_free(a); + eina_value_free(b); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_string) +{ + Eina_Value *value; + const char *s; + + eina_init(); + + 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)); + fail_unless(strcmp(s, "hello world!") == 0); + + fail_unless(eina_value_set(value, "eina-value")); + fail_unless(eina_value_get(value, &s)); + fail_unless(strcmp(s, "eina-value") == 0); + + eina_value_flush(value); + fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_STRING)); + + fail_unless(eina_value_set(value, "profusion")); + fail_unless(eina_value_get(value, &s)); + fail_unless(strcmp(s, "profusion") == 0); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_pvariant) +{ + Eina_Value *value; + char c, in_c; + short s, in_s; + int i, in_i; + long l, in_l; + int64_t i64, in_i64; + unsigned char uc, in_uc; + unsigned short us, in_us; + unsigned int ui, in_ui; + unsigned long ul, in_ul; + uint64_t u64, in_u64; + float f, in_f; + double d, in_d; + const char *str, *in_str; + + eina_init(); + + value = eina_value_new(EINA_VALUE_TYPE_CHAR); + fail_unless(value != NULL); + in_c = 'x'; + fail_unless(eina_value_pset(value, &in_c)); + fail_unless(eina_value_pget(value, &c)); + fail_unless(c == 'x'); + eina_value_flush(value); + + fail_unless(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); + eina_value_flush(value); + + fail_unless(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); + eina_value_flush(value); + + fail_unless(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); + eina_value_flush(value); + + fail_unless(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); + eina_value_flush(value); + + /* unsigned: */ + + fail_unless(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); + eina_value_flush(value); + + fail_unless(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); + eina_value_flush(value); + + fail_unless(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); + eina_value_flush(value); + + fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); + in_ul = 3000000001U; + fail_unless(eina_value_pset(value, &in_ul)); + fail_unless(eina_value_pget(value, &ul)); + fail_unless(ul == 3000000001U); + eina_value_flush(value); + + fail_unless(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); + eina_value_flush(value); + + /* floating point */ + fail_unless(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)); + eina_value_flush(value); + + fail_unless(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)); + eina_value_flush(value); + + fail_unless(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)); + fail_unless(strcmp(str, "hello world!") == 0); + + in_str = "eina-value"; + fail_unless(eina_value_pset(value, &in_str)); + fail_unless(eina_value_pget(value, &str)); + fail_unless(strcmp(str, "eina-value") == 0); + + eina_value_flush(value); + fail_unless(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)); + fail_unless(strcmp(str, "profusion") == 0); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_to_string) +{ + Eina_Value *value; + char c, in_c; + short s, in_s; + int i, in_i; + long l, in_l; + int64_t i64, in_i64; + unsigned char uc, in_uc; + unsigned short us, in_us; + unsigned int ui, in_ui; + unsigned long ul, in_ul; + uint64_t u64, in_u64; + float f, in_f; + double d, in_d; + const char *str, *in_str; + char *out; + char buf[256]; + + eina_init(); + + value = eina_value_new(EINA_VALUE_TYPE_CHAR); + fail_unless(value != NULL); + in_c = 'x'; + fail_unless(eina_value_pset(value, &in_c)); + fail_unless(eina_value_pget(value, &c)); + fail_unless(c == 'x'); + snprintf(buf, sizeof(buf), "%hhd", in_c); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(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); + snprintf(buf, sizeof(buf), "%hd", in_s); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(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); + snprintf(buf, sizeof(buf), "%d", in_i); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(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); + snprintf(buf, sizeof(buf), "%ld", in_l); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(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); + snprintf(buf, sizeof(buf), "%"PRId64, in_i64); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + /* unsigned: */ + + fail_unless(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); + snprintf(buf, sizeof(buf), "%hhu", in_uc); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(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); + snprintf(buf, sizeof(buf), "%hu", in_us); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(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); + snprintf(buf, sizeof(buf), "%u", in_ui); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(eina_value_setup(value, EINA_VALUE_TYPE_ULONG)); + in_ul = 3000000001U; + fail_unless(eina_value_pset(value, &in_ul)); + fail_unless(eina_value_pget(value, &ul)); + fail_unless(ul == 3000000001U); + snprintf(buf, sizeof(buf), "%lu", in_ul); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + fail_unless(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); + snprintf(buf, sizeof(buf), "%"PRIu64, in_u64); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(buf, out) == 0); + free(out); + eina_value_flush(value); + + /* floating point */ + fail_unless(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)); + 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... */ + free(out); + eina_value_flush(value); + + fail_unless(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)); + 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... */ + free(out); + eina_value_flush(value); + + fail_unless(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)); + fail_unless(strcmp(str, "hello world!") == 0); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(in_str, out) == 0); + free(out); + + in_str = "eina-value"; + fail_unless(eina_value_pset(value, &in_str)); + fail_unless(eina_value_pget(value, &str)); + fail_unless(strcmp(str, "eina-value") == 0); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(in_str, out) == 0); + free(out); + + eina_value_flush(value); + fail_unless(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)); + fail_unless(strcmp(str, "profusion") == 0); + out = eina_value_to_string(value); + fail_unless(out != NULL); + fail_unless(strcmp(in_str, out) == 0); + free(out); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_convert_char) +{ + Eina_Value *value, conv; + char c; + short s; + int i; + long l; + int64_t i64; + unsigned char uc; + unsigned short us; + unsigned int ui; + unsigned long ul; + uint64_t u64; + float f; + double d; + const char *str; + + eina_init(); + + value = eina_value_new(EINA_VALUE_TYPE_CHAR); + fail_unless(value != NULL); + + fail_unless(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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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)); + 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)); + 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); + fail_unless(strcmp(str, "123") == 0); + eina_value_flush(&conv); + + /* negative tests */ + fail_unless(eina_value_set(value, -123)); + + fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UCHAR)); + fail_if(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)); + eina_value_flush(&conv); + + fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT)); + fail_if(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)); + eina_value_flush(&conv); + + fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_UINT64)); + fail_if(eina_value_convert(value, &conv)); + eina_value_flush(&conv); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_convert_uchar) +{ + Eina_Value *value, conv; + char c; + short s; + int i; + long l; + int64_t i64; + unsigned char uc; + unsigned short us; + unsigned int ui; + unsigned long ul; + uint64_t u64; + float f; + double d; + const char *str; + + eina_init(); + + value = eina_value_new(EINA_VALUE_TYPE_UCHAR); + fail_unless(value != NULL); + + fail_unless(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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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); + 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)); + 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)); + 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); + fail_unless(strcmp(str, "31") == 0); + eina_value_flush(&conv); + + /* negative tests */ + fail_unless(eina_value_set(value, 200)); + + fail_unless(eina_value_setup(&conv, EINA_VALUE_TYPE_CHAR)); + fail_if(eina_value_convert(value, &conv)); + eina_value_flush(&conv); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + + +START_TEST(eina_value_test_array) +{ + Eina_Value *value, other; + Eina_Value_Array desc; + Eina_Inarray *inarray; + char c; + char buf[1024]; + char *str; + + eina_init(); + + value = eina_value_array_new(EINA_VALUE_TYPE_CHAR, 0); + fail_unless(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')); + + 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'); + + 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'); + + 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'); + + snprintf(buf, sizeof(buf), "[%hhd, %hhd, %hhd, %hhd]", + '*', 'k', '-', 's'); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, buf) == 0); + free(str); + + eina_value_flush(value); + fail_unless(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")); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "[Enlightenment.org, X11, Pants, on!!!, k-s]") == 0); + 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)); + + fail_unless(eina_value_set(&other, 100)); + fail_unless(eina_value_get(&other, &c)); + fail_unless(c == 100); + + fail_unless(eina_value_convert(&other, value)); + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "[100]") == 0); + 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); + + inarray = eina_inarray_new(sizeof(char), 0); + fail_unless(inarray != NULL); + c = 11; + fail_unless(eina_inarray_append(inarray, &c) >= 0); + c = 21; + fail_unless(eina_inarray_append(inarray, &c) >= 0); + c = 31; + fail_unless(eina_inarray_append(inarray, &c) >= 0); + desc.subtype = EINA_VALUE_TYPE_CHAR; + desc.step = 0; + desc.array = inarray; /* will be adopted and freed by value */ + fail_unless(eina_value_set(value, desc)); /* manually configure */ + 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); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_list) +{ + Eina_Value *value, other; + Eina_Value_List desc; + char c; + char buf[1024]; + char *str; + const char *s; + + eina_init(); + + value = eina_value_list_new(EINA_VALUE_TYPE_CHAR); + fail_unless(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')); + + 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'); + + 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'); + + 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'); + + snprintf(buf, sizeof(buf), "[%hhd, %hhd, %hhd, %hhd]", + '*', 'k', '-', 's'); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, buf) == 0); + free(str); + + eina_value_flush(value); + fail_unless(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")); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "[Enlightenment.org, X11, Pants, on!!!, k-s]") == 0); + 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)); + + fail_unless(eina_value_set(&other, 100)); + fail_unless(eina_value_get(&other, &c)); + fail_unless(c == 100); + + fail_unless(eina_value_convert(&other, value)); + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "[100]") == 0); + 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); + + desc.subtype = EINA_VALUE_TYPE_STRING; + desc.list = NULL; + desc.list = eina_list_append(desc.list, strdup("hello")); + desc.list = eina_list_append(desc.list, strdup("world")); + desc.list = eina_list_append(desc.list, strdup("eina")); + fail_unless(eina_list_count(desc.list) == 3); + fail_unless(eina_value_set(value, desc)); + fail_unless(eina_value_list_get(value, 0, &s)); + fail_unless(s != NULL); + fail_unless(strcmp(s, "hello") == 0); + fail_unless(eina_value_list_get(value, 1, &s)); + fail_unless(s != NULL); + fail_unless(strcmp(s, "world") == 0); + fail_unless(eina_value_list_get(value, 2, &s)); + fail_unless(s != NULL); + fail_unless(strcmp(s, "eina") == 0); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +START_TEST(eina_value_test_hash) +{ + Eina_Value *value, other; + Eina_Value_Hash desc; + char c; + char buf[1024]; + char **ptr; + char *str; + const char *s; + + eina_init(); + + value = eina_value_hash_new(EINA_VALUE_TYPE_CHAR, 0); + fail_unless(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')); + + 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'); + + 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'); + + puts("testing hash to string -- may fail due hash algorithm changes!"); + + /* watchout, this is the order I got -- hash algorithm changes may change + * the order! + */ + snprintf(buf, sizeof(buf), "{first: %hhd, second: %hhd, third: %hhd}", + '!', '-', 's'); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + printf("want: %s\n", buf); + printf("got.: %s\n", str); + fail_unless(strcmp(str, buf) == 0); + free(str); + + eina_value_flush(value); + fail_unless(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")); + + /* watchout, this is the order I got -- hash algorithm changes may change + * the order! + */ + strcpy(buf, "{e: k-s, d: on!!!, a: Enlightenment.org, b: X11, c: Pants}"); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + printf("want: %s\n", buf); + printf("got.: %s\n", str); + fail_unless(strcmp(str, buf) == 0); + 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)); + + fail_unless(eina_value_set(&other, 100)); + fail_unless(eina_value_get(&other, &c)); + fail_unless(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); + + desc.subtype = EINA_VALUE_TYPE_STRING; + desc.buckets_power_size = 0; + desc.hash = eina_hash_string_small_new(NULL); + fail_unless(desc.hash != NULL); + /* watch out hash pointer is to a size of subtype->value_size! */ + ptr = malloc(sizeof(char *)); + *ptr = strdup("there"); + fail_unless(eina_hash_add(desc.hash, "hi", ptr)); + ptr = malloc(sizeof(char *)); + *ptr = strdup("y"); + fail_unless(eina_hash_add(desc.hash, "x", ptr)); + + fail_unless(eina_value_set(value, desc)); + + fail_unless(eina_value_hash_get(value, "hi", &s)); + fail_unless(s != NULL); + fail_unless(strcmp(s, "there") == 0); + + fail_unless(eina_value_hash_get(value, "x", &s)); + fail_unless(s != NULL); + fail_unless(strcmp(s, "y") == 0); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + + +START_TEST(eina_value_test_timeval) +{ + Eina_Value *value, other; + struct timeval itv, otv; + char c; + char *str; + + eina_init(); + + value = eina_value_new(EINA_VALUE_TYPE_TIMEVAL); + fail_unless(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(memcmp(&itv, &otv, sizeof(struct timeval)) == 0); + + itv.tv_sec = 3; + itv.tv_usec = -1; + fail_unless(eina_value_set(value, itv)); + fail_unless(eina_value_get(value, &otv)); + itv.tv_sec = 2; + itv.tv_usec = 999999; + fail_unless(memcmp(&itv, &otv, sizeof(struct timeval)) == 0); + + 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); + eina_value_flush(&other); + + itv.tv_sec = 12345; + itv.tv_usec = 6789; + fail_unless(eina_value_set(value, itv)); + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "12345.006789") == 0); + 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); + + itv.tv_sec++; + fail_unless(eina_value_set(&other, itv)); + fail_unless(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); + + itv.tv_sec++; + fail_unless(eina_value_set(&other, itv)); + fail_unless(eina_value_compare(value, &other) == 0); + + itv.tv_usec++; + fail_unless(eina_value_set(&other, itv)); + fail_unless(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); + + itv.tv_usec++; + fail_unless(eina_value_set(&other, itv)); + fail_unless(eina_value_compare(value, &other) == 0); + + eina_value_flush(&other); + + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + + +START_TEST(eina_value_test_blob) +{ + Eina_Value *value, other; + Eina_Value_Blob in, out; + unsigned char blob[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; + int i = 0x11223344; + char *str; + + eina_init(); + + value = eina_value_new(EINA_VALUE_TYPE_BLOB); + fail_unless(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, &out, sizeof(Eina_Value_Blob)) == 0); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "BLOB(10, [01 02 03 04 05 06 07 08 09 0a])") == 0); + 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)); + + fail_unless(out.memory != NULL); + fail_unless(out.size == sizeof(int)); + fail_unless(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!")); + fail_unless(strcmp(out.memory, "hi there!") == 0); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "BLOB(10, [68 69 20 74 68 65 72 65 21 00])") == 0); + 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); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "BLOB(3, [0a 0b 0c])") == 0); + 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); + + str = eina_value_to_string(&other); + fail_unless(str != NULL); + fail_unless(strcmp(str, "BLOB(3, [0a 0b 0c])") == 0); + free(str); + + eina_value_flush(&other); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + + +START_TEST(eina_value_test_struct) +{ + struct mybigst { + int a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, x; + }; + const Eina_Value_Struct_Member mybigst_members[] = { + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, a), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, b), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, c), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, d), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, e), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, f), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, g), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, h), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, i), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, j), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, k), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, l), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, m), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, n), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, o), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, p), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, q), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, r), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, s), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, t), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, u), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, v), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct mybigst, x), + EINA_VALUE_STRUCT_MEMBER_SENTINEL + }; + const Eina_Value_Struct_Desc mybigst_desc = { + EINA_VALUE_STRUCT_DESC_VERSION, + EINA_VALUE_STRUCT_OPERATIONS_BINSEARCH, + mybigst_members, 23, sizeof(struct mybigst) + }; + struct myst { + int i; + char c; + }; + const Eina_Value_Struct_Member myst_members[] = { + {"i", EINA_VALUE_TYPE_INT, 0}, + {"c", EINA_VALUE_TYPE_CHAR, 4}, + {NULL, NULL, 0} + }; + const Eina_Value_Struct_Desc myst_desc = { + EINA_VALUE_STRUCT_DESC_VERSION, + NULL, myst_members, 2, sizeof(struct myst) + }; + Eina_Value *value, other; + int i; + char c; + char *str; + + eina_init(); + + value = eina_value_struct_new(&myst_desc); + fail_unless(value != NULL); + + fail_unless(eina_value_struct_set(value, "i", 5678)); + fail_unless(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); + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "{i: 5678, c: 15}") == 0); + free(str); + + fail_if(eina_value_struct_get(value, "x", 1234)); + + i = 0x11223344; + fail_unless(eina_value_struct_pset(value, "i", &i)); + i = -1; + fail_unless(eina_value_struct_pget(value, "i", &i)); + fail_unless(i == 0x11223344); + + fail_unless(eina_value_copy(value, &other)); + str = eina_value_to_string(&other); + fail_unless(str != NULL); + fail_unless(strcmp(str, "{i: 287454020, c: 15}") == 0); + 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)); + + 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); + + str = eina_value_to_string(&other); + fail_unless(str != NULL); + fail_unless(strcmp(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}") == 0); + free(str); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + + +START_TEST(eina_value_test_array_of_struct) +{ + struct myst { + int a, b, c; + const char *s; + }; + const Eina_Value_Struct_Member myst_members[] = { + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct myst, a), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct myst, b), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_INT, struct myst, c), + EINA_VALUE_STRUCT_MEMBER(EINA_VALUE_TYPE_STRING, struct myst, s), + EINA_VALUE_STRUCT_MEMBER_SENTINEL + }; + const Eina_Value_Struct_Desc myst_desc = { + EINA_VALUE_STRUCT_DESC_VERSION, + EINA_VALUE_STRUCT_OPERATIONS_BINSEARCH, + myst_members, 4, sizeof(struct myst) + }; + Eina_Value *value; + char *str; + int i; + + eina_init(); + + value = eina_value_array_new(EINA_VALUE_TYPE_STRUCT, 0); + fail_unless(value != NULL); + + for (i = 0; i < 10; i++) + { + Eina_Value_Struct desc; + struct myst *st; + char buf[64]; + + snprintf(buf, sizeof(buf), "item%02d", i); + st = malloc(sizeof(struct myst)); + fail_unless(st != NULL); + st->a = i; + st->b = i * 10; + st->c = i * 100; + st->s = strdup(buf); + fail_unless(st->s != NULL); + + desc.desc = &myst_desc; + desc.memory = st; + fail_unless(eina_value_array_append(value, desc)); + } + + str = eina_value_to_string(value); + fail_unless(str != NULL); + fail_unless(strcmp(str, "[" + "{a: 0, b: 0, c: 0, s: item00}, " + "{a: 1, b: 10, c: 100, s: item01}, " + "{a: 2, b: 20, c: 200, s: item02}, " + "{a: 3, b: 30, c: 300, s: item03}, " + "{a: 4, b: 40, c: 400, s: item04}, " + "{a: 5, b: 50, c: 500, s: item05}, " + "{a: 6, b: 60, c: 600, s: item06}, " + "{a: 7, b: 70, c: 700, s: item07}, " + "{a: 8, b: 80, c: 800, s: item08}, " + "{a: 9, b: 90, c: 900, s: item09}" + "]") == 0); + free(str); + + eina_value_free(value); + eina_shutdown(); +} +END_TEST + +void +eina_test_value(TCase *tc) +{ + tcase_add_test(tc, eina_value_test_simple); + tcase_add_test(tc, eina_value_test_string); + tcase_add_test(tc, eina_value_test_pvariant); + tcase_add_test(tc, eina_value_test_compare); + tcase_add_test(tc, eina_value_test_to_string); + tcase_add_test(tc, eina_value_test_convert_char); + tcase_add_test(tc, eina_value_test_convert_uchar); + // TODO: other converters... + tcase_add_test(tc, eina_value_test_array); + tcase_add_test(tc, eina_value_test_list); + tcase_add_test(tc, eina_value_test_hash); + tcase_add_test(tc, eina_value_test_timeval); + tcase_add_test(tc, eina_value_test_blob); + tcase_add_test(tc, eina_value_test_struct); + tcase_add_test(tc, eina_value_test_array_of_struct); +} diff --git a/libraries/eina/src/tests/evas_list.c b/libraries/eina/src/tests/evas_list.c index 55e301f..3df15ed 100644 --- a/libraries/eina/src/tests/evas_list.c +++ b/libraries/eina/src/tests/evas_list.c @@ -962,7 +962,7 @@ evas_list_sort(Evas_List *list, int size, int (*func)(void *, void *)) Evas_List *last; unsigned int list_number; unsigned int middle; - int list_size; + unsigned int list_size; if (!list || !func) return NULL; diff --git a/libraries/eina/src/tests/evas_mempool.c b/libraries/eina/src/tests/evas_mempool.c index fbc48fa..7098214 100644 --- a/libraries/eina/src/tests/evas_mempool.c +++ b/libraries/eina/src/tests/evas_mempool.c @@ -56,7 +56,7 @@ _evas_mp_pool_free(Pool *p) } void * -evas_mempool_malloc(Evas_Mempool *pool, int size) +evas_mempool_malloc(Evas_Mempool *pool, int size __UNUSED__) { #ifdef NOPOOL return malloc(size); -- cgit v1.1