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