From: seungho Date: Tue, 21 Aug 2012 13:46:30 +0000 (+0900) Subject: new release for RSA X-Git-Tag: 2.0_alpha^0 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;p=external%2Flibjson-glib.git new release for RSA --- diff --git a/TC/_export_env.sh b/TC/_export_env.sh new file mode 100755 index 0000000..72a11ec --- /dev/null +++ b/TC/_export_env.sh @@ -0,0 +1,8 @@ +#!/bin/sh + +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_HOST_PATH # tetware root path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target # tetware target path +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/_export_target_env.sh b/TC/_export_target_env.sh new file mode 100755 index 0000000..5ddaa53 --- /dev/null +++ b/TC/_export_target_env.sh @@ -0,0 +1,7 @@ +#!/bin/sh +. ./config +export TET_INSTALL_PATH=$TET_INSTALL_TARGET_PATH # path to path +export TET_TARGET_PATH=$TET_INSTALL_PATH/tetware-target +export PATH=$TET_TARGET_PATH/bin:$PATH +export LD_LIBRARY_PATH=$TET_TARGET_PATH/lib/tet3:$LD_LIBRARY_PATH +export TET_ROOT=$TET_TARGET_PATH diff --git a/TC/build.sh b/TC/build.sh new file mode 100755 index 0000000..72aad6c --- /dev/null +++ b/TC/build.sh @@ -0,0 +1,16 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/build-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -c -p ./ +tcc -b -j $JOURNAL_RESULT -p ./ +grw -c 7 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/clean.sh b/TC/clean.sh new file mode 100755 index 0000000..29743e0 --- /dev/null +++ b/TC/clean.sh @@ -0,0 +1,11 @@ +#!/bin/sh + +. ./_export_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +RESULT_DIR=results + +tcc -c -p ./ # executing tcc, with clean option (-c) +rm -r $RESULT_DIR +rm -r tet_tmp_dir +rm testcase/tet_captured diff --git a/TC/config b/TC/config new file mode 100755 index 0000000..a30467a --- /dev/null +++ b/TC/config @@ -0,0 +1,2 @@ +TET_INSTALL_HOST_PATH=/home/ivan/xuyun/DTS/TETware +TET_INSTALL_TARGET_PATH=/mnt/nfs/DTS/TETware diff --git a/TC/execute.sh b/TC/execute.sh new file mode 100755 index 0000000..a4f6095 --- /dev/null +++ b/TC/execute.sh @@ -0,0 +1,15 @@ +#!/bin/sh + +. ./_export_target_env.sh # setting environment variables + +export TET_SUITE_ROOT=`pwd` +FILE_NAME_EXTENSION=`date +%s` + +RESULT_DIR=results +HTML_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.html +JOURNAL_RESULT=$RESULT_DIR/exec-tar-result-$FILE_NAME_EXTENSION.journal + +mkdir -p $RESULT_DIR + +tcc -e -j $JOURNAL_RESULT -p ./ +grw -c 3 -f chtml -o $HTML_RESULT $JOURNAL_RESULT diff --git a/TC/tet_scen b/TC/tet_scen new file mode 100755 index 0000000..e486157 --- /dev/null +++ b/TC/tet_scen @@ -0,0 +1,10 @@ +all + ^TEST +##### Scenarios for TEST ##### + +# Test scenario +TEST + :include:/unit/TC_Parser/tslist + :include:/unit/TC_Generator/tslist + :include:/unit/TC_Types/tslist + :include:/unit/TC_Gobject/tslist \ No newline at end of file diff --git a/TC/tetbuild.cfg b/TC/tetbuild.cfg new file mode 100755 index 0000000..1d79cc2 --- /dev/null +++ b/TC/tetbuild.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=False # capture option for build operation checking +TET_BUILD_TOOL=make # build with using make command +TET_BUILD_FILE=-f Makefile # execution file (Makefile) for build +TET_API_COMPLIANT=True # use TET API in Test Case ? +TET_PASS_TC_NAME=True # report passed TC name in Journal file? diff --git a/TC/tetclean.cfg b/TC/tetclean.cfg new file mode 100755 index 0000000..02d7030 --- /dev/null +++ b/TC/tetclean.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capture option +TET_CLEAN_TOOL= make clean # clean tool +TET_CLEAN_FILE= Makefile # file for clean +TET_API_COMPLIANT=True # TET API useage +TET_PASS_TC_NAME=True # showing name , passed TC diff --git a/TC/tetexec.cfg b/TC/tetexec.cfg new file mode 100755 index 0000000..ef3e452 --- /dev/null +++ b/TC/tetexec.cfg @@ -0,0 +1,5 @@ +TET_OUTPUT_CAPTURE=True # capturing execution or not +TET_EXEC_TOOL= # ex) exec : execution tool set up/ Optional +TET_EXEC_FILE= # ex) exectool : execution file/ Optional +TET_API_COMPLIANT=True # Test case or Tool usesTET API? +TET_PASS_TC_NAME=True # showing Passed TC name ? diff --git a/TC/unit/Makefile b/TC/unit/Makefile new file mode 100755 index 0000000..7dad665 --- /dev/null +++ b/TC/unit/Makefile @@ -0,0 +1,24 @@ +testbuildtype=normal +#export testbuildtype + +all: TCParser TC_Generator TC_Types TC_Gobject + echo done + +TCParser: + make -s -C TC_Parser + +TC_Generator: + make -s -C TC_Generator + +TC_Types: + make -s -C TC_Types + +TC_Gobject: + make -s -C TC_Gobject + +clean: + make clean -C TC_Parser + make clean -C TC_Generator + make clean -C TC_Types + make clean -C TC_Gobject + \ No newline at end of file diff --git a/TC/unit/TC_Generator/Makefile b/TC/unit/TC_Generator/Makefile new file mode 100755 index 0000000..d8b57a5 --- /dev/null +++ b/TC/unit/TC_Generator/Makefile @@ -0,0 +1,47 @@ +################################################### +# add your TestCase List Here +# +# e.g., +# TC1 = utc_frameworkName_apiName_func +# TC2 = utc_ApplicationLib_recurGetDayOfWeek_func +TARGETS = utc_libjson_json_generator_new_func \ + utc_libjson_json_generator_to_file_func \ + utc_libjson_json_generator_to_data_func \ + utc_libjson_json_generator_set_root_func +################################################### +# add your Package Config Info Here +# +# e.g., +# PKGS=calendar +PKGS=json-glib-1.0 + +LIBS = `pkg-config --libs $(PKGS)` +LIBS += `pkg-config --libs glib-2.0` +LIBS +=$(TET_ROOT)/lib/tet3/tcm_s.o +LIBS +=-L$(TET_ROOT)/lib/tet3 -ltcm_s +LIBS +=-L$(TET_ROOT)/lib/tet3 -lapi_s + +INCS = -I. `pkg-config --cflags $(PKGS)` +INCS += -I. `pkg-config --cflags glib-2.0` +INCS += -I$(TET_ROOT)/inc/tet3 + + +CFLAGS = $(INCS) +CFLAGS += -D_TETWARE_MODE +CFLAGS += -Wall +LDFLAGS = $(LIBS) + +################################################### +# Modify here +# depending on the Test Case you want to build +# +# e.g., +# TCLIST = $(TC1) $(TC2) +all : $(TARGETS) + +$(TARGETS) : %: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean : + rm -rf $(TARGETS) + diff --git a/TC/unit/TC_Generator/tslist b/TC/unit/TC_Generator/tslist new file mode 100755 index 0000000..43fcfe7 --- /dev/null +++ b/TC/unit/TC_Generator/tslist @@ -0,0 +1,4 @@ +/unit/TC_Generator/utc_libjson_json_generator_new_func +/unit/TC_Generator/utc_libjson_json_generator_to_file_func +/unit/TC_Generator/utc_libjson_json_generator_to_data_func +/unit/TC_Generator/utc_libjson_json_generator_set_root_func \ No newline at end of file diff --git a/TC/unit/TC_Generator/utc_libjson_json_generator_new_func.c b/TC/unit/TC_Generator/utc_libjson_json_generator_new_func.c new file mode 100755 index 0000000..9de43fd --- /dev/null +++ b/TC/unit/TC_Generator/utc_libjson_json_generator_new_func.c @@ -0,0 +1,65 @@ +#include +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_generator_new_func_01(void); +static void utc_libjson_json_generator_new_func_02(void); + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_generator_new_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_new_func_02, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_generator_new() + */ +static void utc_libjson_json_generator_new_func_01(void) +{ + JsonGenerator *gen = NULL; + + gen = json_generator_new(); + dts_check_ne("json_generator_new", gen, NULL); + + g_object_unref (gen); +} + +/** + * @brief Negative test case of ug_init json_generator_new() + */ +static void utc_libjson_json_generator_new_func_02(void) +{ + JsonGenerator *gen = NULL; + + gen = json_generator_new(); + dts_check_ne("json_generator_new", gen, NULL); + dts_check_eq("json_generator_new", JSON_IS_GENERATOR (gen), TRUE); + + g_object_unref (gen); +} + diff --git a/TC/unit/TC_Generator/utc_libjson_json_generator_set_root_func.c b/TC/unit/TC_Generator/utc_libjson_json_generator_set_root_func.c new file mode 100755 index 0000000..4108040 --- /dev/null +++ b/TC/unit/TC_Generator/utc_libjson_json_generator_set_root_func.c @@ -0,0 +1,80 @@ +#include +#include +#include +#include +#include + +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_generator_set_root_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_generator_set_root_func_01, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + g_type_init (); +} + +static void cleanup(void) +{ +} + + +static void utc_libjson_json_generator_set_root_func_01(void) +{ + JsonGenerator *gen = NULL; + JsonParser *parser = NULL; + GError *error = NULL; + + JsonNode *root = NULL; + gchar *data = NULL; + gsize len = 0; + + gen = json_generator_new(); + dts_check_ne("json_generator_set_root", gen, NULL); + + root = json_node_new (JSON_NODE_ARRAY); + json_node_take_array (root, json_array_new ()); + + json_generator_set_root (gen, root); + g_object_set (gen, "pretty", FALSE, NULL); + + data = json_generator_to_data (gen, &len); + json_node_free (root); + g_object_unref (gen); + + parser = json_parser_new (); + g_assert(JSON_IS_PARSER (parser)); + if (!json_parser_load_from_data (parser, data, -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_generator_set_root", root, NULL); + dts_check_eq("json_generator_set_root", JSON_NODE_TYPE(root), JSON_NODE_ARRAY); + } + + dts_pass("json_generator_set_root", "pass"); + + g_free (data); + g_object_unref (parser); + +} + + diff --git a/TC/unit/TC_Generator/utc_libjson_json_generator_to_data_func.c b/TC/unit/TC_Generator/utc_libjson_json_generator_to_data_func.c new file mode 100755 index 0000000..3fa534e --- /dev/null +++ b/TC/unit/TC_Generator/utc_libjson_json_generator_to_data_func.c @@ -0,0 +1,277 @@ +#include +#include +#include +#include +#include + +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_generator_to_data_func_01(void); +static void utc_libjson_json_generator_to_data_func_02(void); +static void utc_libjson_json_generator_to_data_func_03(void); +static void utc_libjson_json_generator_to_data_func_04(void); +static void utc_libjson_json_generator_to_data_func_05(void); +static void utc_libjson_json_generator_to_data_func_06(void); +static void utc_libjson_json_generator_to_data_func_07(void); + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_generator_to_data_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_data_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_data_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_data_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_data_func_05, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_data_func_06, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_data_func_07, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static const gchar *empty_array = "[ ]"; +static const gchar *empty_object = "{ }"; + +static const gchar *simple_array = "[ true, false, null, 42, \"foo\" ]"; +static const gchar *nested_array = "[ true, [ false, null ], 42 ]"; + +static const gchar *simple_object = "{ \"Bool1\" : true, \"Bool2\" : false, \"Null\" : null, \"Int\" : 42, \"String\" : \"foo\" }"; + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + + +/** + * @brief Positive test case of json_generator_to_data() + */ +static void utc_libjson_json_generator_to_data_func_01(void) +{ + gchar *data = NULL; + gsize len = 0; + + data = json_generator_to_data (NULL, &len); + dts_check_eq("json_generator_to_data", len, 0); + dts_check_eq("json_generator_to_data", data, NULL); +} + + +/** + * @brief Positive test case of json_generator_to_data() + */ +static void utc_libjson_json_generator_to_data_func_02(void) +{ + JsonGenerator *gen = NULL; + gchar *data = NULL; + gsize len = 0; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + data = json_generator_to_data (gen, &len); + dts_check_eq("json_generator_to_data", len, 0); + dts_check_eq("json_generator_to_data", data, NULL); + + g_object_unref (gen); +} + +static void utc_libjson_json_generator_to_data_func_03(void) +{ + JsonGenerator *gen = NULL; + JsonNode *root = NULL; + gchar *data = NULL; + gsize len = 0; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + root = json_node_new (JSON_NODE_ARRAY); + json_node_take_array (root, json_array_new ()); + + json_generator_set_root (gen, root); + g_object_set (gen, "pretty", FALSE, NULL); + + data = json_generator_to_data (gen, &len); + dts_check_eq("json_generator_to_data", len, strlen(empty_array)); + dts_check_str_eq("json_generator_to_data", data, empty_array); + + g_free (data); + json_node_free (root); + g_object_unref (gen); + +} + +static void utc_libjson_json_generator_to_data_func_04(void) +{ + JsonGenerator *gen = NULL; + JsonNode *root = NULL; + gchar *data = NULL; + gsize len = 0; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + root = json_node_new (JSON_NODE_OBJECT); + json_node_take_object (root, json_object_new ()); + + json_generator_set_root (gen, root); + g_object_set (gen, "pretty", FALSE, NULL); + + data = json_generator_to_data (gen, &len); + dts_check_eq("json_generator_to_data", len, strlen(empty_object)); + dts_check_str_eq("json_generator_to_data", data, empty_object); + + g_free (data); + json_node_free (root); + g_object_unref (gen); +} + +static void utc_libjson_json_generator_to_data_func_05(void) +{ + JsonGenerator *gen = NULL; + JsonNode *root = NULL; + JsonNode *val = NULL; + JsonArray *array = NULL; + GValue value = { 0, }; + gchar *data = NULL; + gsize len = 0; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + root = json_node_new (JSON_NODE_ARRAY); + array = json_array_sized_new (6); + + val = json_node_new (JSON_NODE_VALUE); + g_value_init (&value, G_TYPE_BOOLEAN); + g_value_set_boolean (&value, TRUE); + json_node_set_value (val, &value); + json_array_add_element (array, val); + g_value_unset (&value); + + val = json_node_new (JSON_NODE_VALUE); + json_node_set_boolean (val, FALSE); + json_array_add_element (array, val); + + val = json_node_new (JSON_NODE_NULL); + json_array_add_element (array, val); + + json_array_add_int_element (array, 42); + + val = json_node_new (JSON_NODE_VALUE); + g_value_init (&value, G_TYPE_STRING); + g_value_set_string (&value, "foo"); + json_node_set_value (val, &value); + json_array_add_element (array, val); + g_value_unset (&value); + + json_node_take_array (root, array); + json_generator_set_root (gen, root); + g_object_set (gen, "pretty", FALSE, NULL); + + data = json_generator_to_data (gen, &len); + dts_check_eq("json_generator_to_data", len, strlen(simple_array)); + dts_check_str_eq("json_generator_to_data", data, simple_array); + + g_free (data); + json_node_free (root); + g_object_unref (gen); +} + +static void utc_libjson_json_generator_to_data_func_06(void) +{ + JsonGenerator *gen = NULL; + JsonNode *root = NULL; + JsonNode *val = NULL; + JsonArray *array = NULL; + JsonArray *nested = NULL; + GValue value = { 0, }; + gchar *data = NULL; + gsize len = 0; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + root = json_node_new (JSON_NODE_ARRAY); + array = json_array_sized_new (3); + + val = json_node_new (JSON_NODE_VALUE); + g_value_init (&value, G_TYPE_BOOLEAN); + g_value_set_boolean (&value, TRUE); + json_node_set_value (val, &value); + json_array_add_element (array, val); + g_value_unset (&value); + + nested = json_array_new (); + json_array_add_boolean_element (nested, FALSE); + json_array_add_null_element (nested); + json_array_add_array_element (array, nested); + + val = json_node_new (JSON_NODE_VALUE); + g_value_init (&value, G_TYPE_INT64); + g_value_set_int64 (&value, 42); + json_node_set_value (val, &value); + json_array_add_element (array, val); + g_value_unset (&value); + + json_node_take_array (root, array); + json_generator_set_root (gen, root); + g_object_set (gen, "pretty", FALSE, NULL); + + data = json_generator_to_data (gen, &len); + dts_check_eq("json_generator_to_data", len, strlen(nested_array)); + dts_check_str_eq("json_generator_to_data", data, nested_array); + + g_free (data); + json_node_free (root); + g_object_unref (gen); +} + +static void utc_libjson_json_generator_to_data_func_07(void) +{ + JsonGenerator *gen = NULL; + JsonNode *root = NULL; + JsonObject *object = NULL; + gchar *data = NULL; + gsize len = 0; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + root = json_node_new (JSON_NODE_OBJECT); + object = json_object_new (); + + json_object_set_boolean_member (object, "Bool1", TRUE); + json_object_set_boolean_member (object, "Bool2", FALSE); + json_object_set_null_member (object, "Null"); + json_object_set_int_member (object, "Int", 42); + json_object_set_string_member (object, "String", "foo"); + + json_node_take_object (root, object); + json_generator_set_root (gen, root); + g_object_set (gen, "pretty", FALSE, NULL); + + data = json_generator_to_data (gen, &len); + dts_check_eq("json_generator_to_data", len, strlen(simple_object)); + dts_check_str_eq("json_generator_to_data", data, simple_object); + + g_free (data); + json_node_free (root); + g_object_unref (gen); +} + + diff --git a/TC/unit/TC_Generator/utc_libjson_json_generator_to_file_func.c b/TC/unit/TC_Generator/utc_libjson_json_generator_to_file_func.c new file mode 100755 index 0000000..badf0ec --- /dev/null +++ b/TC/unit/TC_Generator/utc_libjson_json_generator_to_file_func.c @@ -0,0 +1,109 @@ +#include +#include +#include +#include +#include +#include + +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_generator_to_file_func_01(void); +static void utc_libjson_json_generator_to_file_func_02(void); +static void utc_libjson_json_generator_to_file_func_03(void); +static void utc_libjson_json_generator_to_file_func_04(void); + +static const gchar *test_filename = "gen_test.info"; + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_generator_to_file_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_file_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_file_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_generator_to_file_func_04, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + + +/** + * @brief Positive test case of json_generator_to_file() + */ +static void utc_libjson_json_generator_to_file_func_01(void) +{ + GError *error = NULL; + gboolean ret = FALSE; + + ret = json_generator_to_file (NULL, NULL, &error); + dts_check_eq("json_generator_to_data", ret, FALSE); +} + + +static void utc_libjson_json_generator_to_file_func_02(void) +{ + JsonGenerator *gen = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + ret = json_generator_to_file (gen, NULL, &error); + dts_check_eq("json_generator_to_data", ret, FALSE); + + g_object_unref (gen); +} + +static void utc_libjson_json_generator_to_file_func_03(void) +{ + JsonGenerator *gen = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + ret = json_generator_to_file (gen, "", &error); + dts_check_eq("json_generator_to_data", ret, FALSE); + + g_object_unref (gen); +} + +static void utc_libjson_json_generator_to_file_func_04(void) +{ + JsonGenerator *gen = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + gen = json_generator_new(); + dts_check_ne("json_generator_to_data", gen, NULL); + + g_remove(test_filename); + ret = json_generator_to_file (gen, test_filename, &error); + dts_check_eq("json_generator_to_data", ret, TRUE); + + ret = g_file_test(test_filename, G_FILE_TEST_EXISTS); + dts_check_eq("json_generator_to_data", ret, TRUE); + + g_object_unref (gen); +} + diff --git a/TC/unit/TC_Gobject/Makefile b/TC/unit/TC_Gobject/Makefile new file mode 100755 index 0000000..420b112 --- /dev/null +++ b/TC/unit/TC_Gobject/Makefile @@ -0,0 +1,49 @@ +################################################### +# add your TestCase List Here +# +# e.g., +# TC1 = utc_frameworkName_apiName_func +# TC2 = utc_ApplicationLib_recurGetDayOfWeek_func +TARGETS = utc_libjson_json_serialize_boxed_func \ + utc_libjson_json_serialize_gobject_func \ + utc_libjson_json_serialize_interface_func \ + utc_libjson_json_serialize_simple_func \ + utc_libjson_json_serialize_complex_func \ + utc_libjson_json_serialize_full_func +################################################### +# add your Package Config Info Here +# +# e.g., +# PKGS=calendar +PKGS=json-glib-1.0 + +LIBS = `pkg-config --libs $(PKGS)` +LIBS += `pkg-config --libs glib-2.0` +LIBS +=$(TET_ROOT)/lib/tet3/tcm_s.o +LIBS +=-L$(TET_ROOT)/lib/tet3 -ltcm_s +LIBS +=-L$(TET_ROOT)/lib/tet3 -lapi_s + +INCS = -I. `pkg-config --cflags $(PKGS)` +INCS += -I. `pkg-config --cflags glib-2.0` +INCS += -I$(TET_ROOT)/inc/tet3 + + +CFLAGS = $(INCS) +CFLAGS += -D_TETWARE_MODE +CFLAGS += -Wall +LDFLAGS = $(LIBS) + +################################################### +# Modify here +# depending on the Test Case you want to build +# +# e.g., +# TCLIST = $(TC1) $(TC2) +all : $(TARGETS) + +$(TARGETS) : %: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean : + rm -rf $(TARGETS) + diff --git a/TC/unit/TC_Gobject/tslist b/TC/unit/TC_Gobject/tslist new file mode 100755 index 0000000..c4eee53 --- /dev/null +++ b/TC/unit/TC_Gobject/tslist @@ -0,0 +1,6 @@ +/unit/TC_Gobject/utc_libjson_json_serialize_boxed_func +/unit/TC_Gobject/utc_libjson_json_serialize_gobject_func +/unit/TC_Gobject/utc_libjson_json_serialize_interface_func +/unit/TC_Gobject/utc_libjson_json_serialize_simple_func +/unit/TC_Gobject/utc_libjson_json_serialize_complex_func +/unit/TC_Gobject/utc_libjson_json_serialize_full_func \ No newline at end of file diff --git a/TC/unit/TC_Gobject/utc_libjson_json_serialize_boxed_func.c b/TC/unit/TC_Gobject/utc_libjson_json_serialize_boxed_func.c new file mode 100755 index 0000000..2bc1613 --- /dev/null +++ b/TC/unit/TC_Gobject/utc_libjson_json_serialize_boxed_func.c @@ -0,0 +1,360 @@ +#include +#include +#include +#include +#include + +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_serialize_boxed_func_01(void); +static void utc_libjson_json_serialize_boxed_func_02(void); +static void utc_libjson_json_serialize_boxed_func_03(void); +static void utc_libjson_json_serialize_boxed_func_04(void); +static void utc_libjson_json_serialize_boxed_func_05(void); +static void utc_libjson_json_serialize_boxed_func_06(void); + + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_serialize_boxed_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_boxed_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_boxed_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_boxed_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_boxed_func_05, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_boxed_func_06, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +#define TEST_TYPE_BOXED (test_boxed_get_type ()) +#define TEST_TYPE_OBJECT (test_object_get_type ()) +#define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject)) +#define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass)) +#define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass)) + + +typedef struct _TestBoxed TestBoxed; +typedef struct _TestObject TestObject; +typedef struct _TestObjectClass TestObjectClass; + +struct _TestBoxed +{ + gint foo; + gboolean bar; +}; + +struct _TestObject +{ + GObject parent_instance; + + TestBoxed blah; +}; + +struct _TestObjectClass +{ + GObjectClass parent_class; +}; + +GType test_object_get_type (void); + + +static const gchar *serialize_data = +"{\n" +" \"blah\" : {\n" +" \"foo\" : 42,\n" +" \"bar\" : true\n" +" }\n" +"}"; + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + + +/*** implementation ***/ + +static gpointer +test_boxed_copy (gpointer src) +{ + return g_slice_dup (TestBoxed, src); +} + +static void +test_boxed_free (gpointer boxed) +{ + if (G_LIKELY (boxed != NULL)) + g_slice_free (TestBoxed, boxed); +} + +static JsonNode * +test_boxed_serialize (gconstpointer boxed) +{ + const TestBoxed *test = boxed; + JsonObject *object; + JsonNode *node; + + if (boxed == NULL) + return json_node_new (JSON_NODE_NULL); + + object = json_object_new (); + node = json_node_new (JSON_NODE_OBJECT); + + json_object_set_int_member (object, "foo", test->foo); + json_object_set_boolean_member (object, "bar", test->bar); + + json_node_take_object (node, object); + + if (g_test_verbose ()) + { + g_print ("Serialize: { foo: %" G_GINT64_FORMAT ", bar: %s }\n", + json_object_get_int_member (object, "foo"), + json_object_get_boolean_member (object, "bar") ? "true" : "false"); + } + + return node; +} + +static gpointer +test_boxed_deserialize (JsonNode *node) +{ + JsonObject *object; + TestBoxed *test; + + if (json_node_get_node_type (node) != JSON_NODE_OBJECT) + return NULL; + + object = json_node_get_object (node); + + test = g_slice_new (TestBoxed); + test->foo = json_object_get_int_member (object, "foo"); + test->bar = json_object_get_boolean_member (object, "bar"); + + if (g_test_verbose ()) + { + g_print ("Deserialize: { foo: %d, bar: %s }\n", + test->foo, + test->bar ? "true" : "false"); + } + + return (gpointer)test; +} + +GType +test_boxed_get_type (void) +{ + static GType b_type = 0; + + if (G_UNLIKELY (b_type == 0)) + { + b_type = g_boxed_type_register_static ("TestBoxed", + test_boxed_copy, + test_boxed_free); + + if (g_test_verbose ()) + g_print ("Registering transform functions\n"); + + json_boxed_register_serialize_func (b_type, JSON_NODE_OBJECT, + test_boxed_serialize); + json_boxed_register_deserialize_func (b_type, JSON_NODE_OBJECT, + test_boxed_deserialize); + } + + return b_type; +} + +enum +{ + PROP_0, + PROP_BLAH +}; + +G_DEFINE_TYPE (TestObject, test_object, G_TYPE_OBJECT); + +static void +test_object_finalize (GObject *gobject) +{ + G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject); +} + +static void +test_object_set_property (GObject *gobject, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_BLAH: + { + const TestBoxed *blah = g_value_get_boxed (value); + TEST_OBJECT (gobject)->blah = *blah; + } + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_BLAH: + g_value_set_boxed (value, &(TEST_OBJECT (gobject)->blah)); + break; + + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_class_init (TestObjectClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = test_object_set_property; + gobject_class->get_property = test_object_get_property; + gobject_class->finalize = test_object_finalize; + + g_object_class_install_property (gobject_class, + PROP_BLAH, + g_param_spec_boxed ("blah", "Blah", "Blah", + TEST_TYPE_BOXED, + G_PARAM_READWRITE)); +} + +static void +test_object_init (TestObject *object) +{ + object->blah.foo = 0; + object->blah.bar = FALSE; +} + + +/** + * @brief Positive test case of json_gobject_to_data() + */ +static void utc_libjson_json_serialize_boxed_func_01(void) +{ + TestBoxed boxed = { 42, TRUE }; + GObject *obj = NULL; + gchar *data = NULL; + gsize len = 0; + + obj = g_object_new(TEST_TYPE_OBJECT, "blah", &boxed, NULL); + + data = json_gobject_to_data (obj, &len); + + dts_check_eq("json_serialize_boxed", len, strlen(serialize_data)); + dts_check_str_eq("json_serialize_boxed", data, serialize_data); + + g_free(data); + g_object_unref(obj); +} + +/** + * @brief Negative test case of json_gobject_from_data() + */ +static void utc_libjson_json_serialize_boxed_func_02(void) +{ + GObject *obj = NULL; + + obj = json_gobject_from_data(TEST_TYPE_OBJECT, serialize_data, -1, NULL); + dts_check_eq("json_deserialize_boxed", TEST_IS_OBJECT(obj), TRUE); + dts_check_eq("json_deserialize_boxed", TEST_OBJECT(obj)->blah.foo, 42); + dts_check_eq("json_deserialize_boxed", TEST_OBJECT(obj)->blah.bar, TRUE); + + g_object_unref (obj); +} + +/** +* @brief Negative test case of json_boxed_can_serialize() +*/ +static void utc_libjson_json_serialize_boxed_func_03(void) +{ + gboolean ret = FALSE; + JsonNodeType node_type = JSON_NODE_OBJECT; + ret = json_boxed_can_serialize(TEST_TYPE_BOXED, &node_type); + dts_check_eq("json_boxed_can_serialize", ret, TRUE); +} + +/** +* @brief Negative test case of json_boxed_can_deserialize() +*/ +static void utc_libjson_json_serialize_boxed_func_04(void) +{ + gboolean ret = FALSE; + JsonNodeType node_type = JSON_NODE_OBJECT; + ret = json_boxed_can_deserialize(TEST_TYPE_BOXED, node_type); + dts_check_eq("json_boxed_can_deserialize", ret, TRUE); +} + +/** +* @brief Negative test case of json_boxed_serialize() +*/ +static void utc_libjson_json_serialize_boxed_func_05(void) +{ + TestBoxed boxed = { 42, TRUE }; + GObject *obj = NULL; + JsonNode *node = NULL; + JsonObject *object; + + obj = g_object_new(TEST_TYPE_BOXED, "blah", &boxed, NULL); + node = json_boxed_serialize(TEST_TYPE_BOXED, &boxed); + dts_check_eq("json_boxed_serialize", json_node_get_node_type (node), JSON_NODE_OBJECT); + object = json_node_get_object (node); + dts_check_eq("json_boxed_serialize", json_object_get_int_member(object, "foo"), 42); + dts_check_eq("json_boxed_serialize", json_object_get_boolean_member(object, "bar"), TRUE); + + g_object_unref (obj); + json_node_free (node); +} + +/** +* @brief Negative test case of json_boxed_deserialize() +*/ +static void utc_libjson_json_serialize_boxed_func_06(void) +{ + gpointer *obj = NULL; + JsonObject *object = NULL; + JsonNode *node = NULL; + + object = json_object_new(); + json_object_set_int_member (object, "foo", 42); + json_object_set_boolean_member (object, "bar", TRUE); + node = json_node_new(JSON_NODE_OBJECT); + json_node_take_object (node, object); + + obj = json_boxed_deserialize(TEST_TYPE_BOXED, node); + dts_check_ne("json_boxed_deserialize", obj, NULL); + dts_check_eq("json_boxed_deserialize", ((TestBoxed*)obj)->foo, 42); + dts_check_eq("json_boxed_deserialize", ((TestBoxed*)obj)->bar, TRUE); + + g_object_unref (obj); + json_node_free (node); +} + diff --git a/TC/unit/TC_Gobject/utc_libjson_json_serialize_complex_func.c b/TC/unit/TC_Gobject/utc_libjson_json_serialize_complex_func.c new file mode 100755 index 0000000..999156e --- /dev/null +++ b/TC/unit/TC_Gobject/utc_libjson_json_serialize_complex_func.c @@ -0,0 +1,314 @@ +#include +#include +#include +#include +#include + +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_serialize_complex_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_serialize_complex_func_01, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +#define TEST_TYPE_BOXED (test_boxed_get_type ()) +#define TEST_TYPE_OBJECT (test_object_get_type ()) +#define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject)) +#define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass)) +#define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass)) + +typedef struct _TestBoxed TestBoxed; +typedef struct _TestObject TestObject; +typedef struct _TestObjectClass TestObjectClass; + +struct _TestBoxed +{ + gint foo; + gboolean bar; +}; + +struct _TestObject +{ + GObject parent_instance; + + gint foo; + gboolean bar; + gchar *baz; + TestBoxed blah; +}; + +struct _TestObjectClass +{ + GObjectClass parent_class; +}; + +GType test_object_get_type (void); + + +static void startup(void) +{ + g_type_init (); +} + +static void cleanup(void) +{ +} + + +/*** implementation ***/ + +static TestBoxed * +test_boxed_copy (const TestBoxed *src) +{ + TestBoxed *copy = g_slice_new (TestBoxed); + + *copy = *src; + + return copy; +} + +static void +test_boxed_free (TestBoxed *boxed) +{ + if (G_LIKELY (boxed)) + { + g_slice_free (TestBoxed, boxed); + } +} + +GType +test_boxed_get_type (void) +{ + static GType b_type = 0; + + if (G_UNLIKELY (b_type == 0)) + b_type = g_boxed_type_register_static ("TestBoxed", + (GBoxedCopyFunc) test_boxed_copy, + (GBoxedFreeFunc) test_boxed_free); + + return b_type; +} + +enum +{ + PROP_0, + + PROP_FOO, + PROP_BAR, + PROP_BAZ, + PROP_BLAH +}; + +static JsonSerializableIface *serializable_iface = NULL; + +static void json_serializable_iface_init (gpointer g_iface); + +G_DEFINE_TYPE_WITH_CODE (TestObject, test_object, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE (JSON_TYPE_SERIALIZABLE, + json_serializable_iface_init)); + +static JsonNode * +test_object_serialize_property (JsonSerializable *serializable, + const gchar *name, + const GValue *value, + GParamSpec *pspec) +{ + JsonNode *retval = NULL; + + if (strcmp (name, "blah") == 0) + { + TestBoxed *boxed; + JsonObject *obj; + JsonNode *val; + + retval = json_node_new (JSON_NODE_OBJECT); + obj = json_object_new (); + + boxed = g_value_get_boxed (value); + + val = json_node_new (JSON_NODE_VALUE); + json_node_set_int (val, boxed->foo); + json_object_set_member (obj, "foo", val); + + val = json_node_new (JSON_NODE_VALUE); + json_node_set_boolean (val, boxed->bar); + json_object_set_member (obj, "bar", val); + + json_node_take_object (retval, obj); + } + else + retval = serializable_iface->serialize_property (serializable, + name, + value, pspec); + + return retval; +} + +static void +json_serializable_iface_init (gpointer g_iface) +{ + JsonSerializableIface *iface = g_iface; + + serializable_iface = g_type_default_interface_peek (JSON_TYPE_SERIALIZABLE); + + iface->serialize_property = test_object_serialize_property; +} + +static void +test_object_finalize (GObject *gobject) +{ + g_free (TEST_OBJECT (gobject)->baz); + + G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject); +} + +static void +test_object_set_property (GObject *gobject, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + TEST_OBJECT (gobject)->foo = g_value_get_int (value); + break; + case PROP_BAR: + TEST_OBJECT (gobject)->bar = g_value_get_boolean (value); + break; + case PROP_BAZ: + g_free (TEST_OBJECT (gobject)->baz); + TEST_OBJECT (gobject)->baz = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + g_value_set_int (value, TEST_OBJECT (gobject)->foo); + break; + case PROP_BAR: + g_value_set_boolean (value, TEST_OBJECT (gobject)->bar); + break; + case PROP_BAZ: + g_value_set_string (value, TEST_OBJECT (gobject)->baz); + break; + case PROP_BLAH: + g_value_set_boxed (value, &(TEST_OBJECT (gobject)->blah)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_class_init (TestObjectClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = test_object_set_property; + gobject_class->get_property = test_object_get_property; + gobject_class->finalize = test_object_finalize; + + g_object_class_install_property (gobject_class, + PROP_FOO, + g_param_spec_int ("foo", "Foo", "Foo", + 0, G_MAXINT, 42, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAR, + g_param_spec_boolean ("bar", "Bar", "Bar", + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAZ, + g_param_spec_string ("baz", "Baz", "Baz", + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BLAH, + g_param_spec_boxed ("blah", "Blah", "Blah", + TEST_TYPE_BOXED, + G_PARAM_READABLE)); +} + +static void +test_object_init (TestObject *object) +{ + object->foo = 42; + object->bar = TRUE; + object->baz = g_strdup ("Test"); + + object->blah.foo = object->foo; + object->blah.bar = object->bar; +} + +/** + * @brief Positive test case of json_serialize_complex() + */ +static void utc_libjson_json_serialize_complex_func_01(void) +{ + TestObject *obj = g_object_new (TEST_TYPE_OBJECT, NULL); + JsonParser *parser = json_parser_new (); + GError *error = NULL; + JsonObject *object = NULL; + JsonNode *node = NULL; + gchar *data = NULL; + gsize len = 0; + + data = json_gobject_to_data (G_OBJECT (obj), &len); + + dts_check_gt("json_serialize_complex", len, 0); + + parser = json_parser_new (); + json_parser_load_from_data (parser, data, -1, &error); + dts_check_eq("json_serialize_complex", error, NULL); + + node = json_parser_get_root (parser); + dts_check_eq("json_serialize_complex", json_node_get_node_type(node), JSON_NODE_OBJECT); + + object = json_node_get_object (node); + dts_check_eq("json_serialize_complex", json_object_get_int_member(object, "foo"), 42); + dts_check_eq("json_serialize_complex", json_object_get_boolean_member(object, "bar"), TRUE); + dts_check_str_eq("json_serialize_complex", json_object_get_string_member(object, "baz"), "Test"); + + node = json_object_get_member (object, "blah"); + dts_check_eq("json_serialize_complex", json_node_get_node_type(node), JSON_NODE_OBJECT); + + object = json_node_get_object (node); + dts_check_eq("json_serialize_complex", json_object_get_int_member(object, "foo"), 42); + dts_check_eq("json_serialize_complex", json_object_get_boolean_member(object, "bar"), TRUE); + + g_free (data); + g_object_unref (parser); + g_object_unref (obj); + +} + + diff --git a/TC/unit/TC_Gobject/utc_libjson_json_serialize_full_func.c b/TC/unit/TC_Gobject/utc_libjson_json_serialize_full_func.c new file mode 100755 index 0000000..64358ed --- /dev/null +++ b/TC/unit/TC_Gobject/utc_libjson_json_serialize_full_func.c @@ -0,0 +1,312 @@ +#include +#include +#include +#include +#include + +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_serialize_full_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_serialize_full_func_01, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +#define TEST_TYPE_BOXED (test_boxed_get_type ()) +#define TEST_TYPE_OBJECT (test_object_get_type ()) +#define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject)) +#define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass)) +#define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass)) + +typedef struct _TestBoxed TestBoxed; +typedef struct _TestObject TestObject; +typedef struct _TestObjectClass TestObjectClass; + +struct _TestBoxed +{ + gint foo; + gboolean bar; +}; + +struct _TestObject +{ + GObject parent_instance; + + gint foo; + gboolean bar; + gchar *baz; + TestBoxed blah; +}; + +struct _TestObjectClass +{ + GObjectClass parent_class; +}; + +GType test_object_get_type (void); + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/*** implementation ***/ + +static TestBoxed * +test_boxed_copy (const TestBoxed *src) +{ + TestBoxed *copy = g_slice_new (TestBoxed); + + *copy = *src; + + return copy; +} + +static void +test_boxed_free (TestBoxed *boxed) +{ + if (G_LIKELY (boxed)) + { + g_slice_free (TestBoxed, boxed); + } +} + +GType +test_boxed_get_type (void) +{ + static GType b_type = 0; + + if (G_UNLIKELY (b_type == 0)) + b_type = g_boxed_type_register_static ("TestBoxed", + (GBoxedCopyFunc) test_boxed_copy, + (GBoxedFreeFunc) test_boxed_free); + + return b_type; +} + +enum +{ + PROP_0, + + PROP_FOO, + PROP_BAR, + PROP_BAZ, + PROP_BLAH +}; + +static JsonSerializableIface *serializable_iface = NULL; + +static void json_serializable_iface_init (gpointer g_iface); + +G_DEFINE_TYPE_WITH_CODE (TestObject, test_object, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE (JSON_TYPE_SERIALIZABLE, + json_serializable_iface_init)); + +static JsonNode * +test_object_serialize_property (JsonSerializable *serializable, + const gchar *name, + const GValue *value, + GParamSpec *pspec) +{ + JsonNode *retval = NULL; + + if (strcmp (name, "blah") == 0) + { + TestBoxed *boxed; + JsonObject *obj; + JsonNode *val; + + retval = json_node_new (JSON_NODE_OBJECT); + obj = json_object_new (); + + boxed = g_value_get_boxed (value); + + val = json_node_new (JSON_NODE_VALUE); + json_node_set_int (val, boxed->foo); + json_object_set_member (obj, "foo", val); + + val = json_node_new (JSON_NODE_VALUE); + json_node_set_boolean (val, boxed->bar); + json_object_set_member (obj, "bar", val); + + json_node_take_object (retval, obj); + } + else + retval = serializable_iface->serialize_property (serializable, + name, + value, pspec); + + return retval; +} + +static void +json_serializable_iface_init (gpointer g_iface) +{ + JsonSerializableIface *iface = g_iface; + + serializable_iface = g_type_default_interface_peek (JSON_TYPE_SERIALIZABLE); + + iface->serialize_property = test_object_serialize_property; +} + +static void +test_object_finalize (GObject *gobject) +{ + g_free (TEST_OBJECT (gobject)->baz); + + G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject); +} + +static void +test_object_set_property (GObject *gobject, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + TEST_OBJECT (gobject)->foo = g_value_get_int (value); + break; + case PROP_BAR: + TEST_OBJECT (gobject)->bar = g_value_get_boolean (value); + break; + case PROP_BAZ: + g_free (TEST_OBJECT (gobject)->baz); + TEST_OBJECT (gobject)->baz = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + g_value_set_int (value, TEST_OBJECT (gobject)->foo); + break; + case PROP_BAR: + g_value_set_boolean (value, TEST_OBJECT (gobject)->bar); + break; + case PROP_BAZ: + g_value_set_string (value, TEST_OBJECT (gobject)->baz); + break; + case PROP_BLAH: + g_value_set_boxed (value, &(TEST_OBJECT (gobject)->blah)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_class_init (TestObjectClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = test_object_set_property; + gobject_class->get_property = test_object_get_property; + gobject_class->finalize = test_object_finalize; + + g_object_class_install_property (gobject_class, + PROP_FOO, + g_param_spec_int ("foo", "Foo", "Foo", + 0, G_MAXINT, 42, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAR, + g_param_spec_boolean ("bar", "Bar", "Bar", + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAZ, + g_param_spec_string ("baz", "Baz", "Baz", + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BLAH, + g_param_spec_boxed ("blah", "Blah", "Blah", + TEST_TYPE_BOXED, + G_PARAM_READABLE)); +} + +static void +test_object_init (TestObject *object) +{ + object->foo = 42; + object->bar = TRUE; + object->baz = g_strdup ("Test"); + + object->blah.foo = object->foo; + object->blah.bar = object->bar; +} + +/** + * @brief Positive test case of json_serialize_full() + */ +static void utc_libjson_json_serialize_full_func_01(void) +{ + TestObject *obj = g_object_new(TEST_TYPE_OBJECT, NULL); + JsonParser *parser = json_parser_new(); + GError *error = NULL; + JsonObject *object = NULL; + JsonNode *node = NULL; + gchar *data = NULL; + gsize len = 0; + + data = json_gobject_to_data(G_OBJECT(obj), &len); + + dts_check_gt("json_serialize_full", len, 0); + + parser = json_parser_new (); + json_parser_load_from_data (parser, data, -1, &error); + dts_check_eq("json_serialize_full", error, NULL); + + node = json_parser_get_root (parser); + dts_check_eq("json_serialize_full", json_node_get_node_type(node), JSON_NODE_OBJECT); + + object = json_node_get_object (node); + dts_check_eq("json_serialize_full", json_object_get_int_member(object, "foo"), 42); + dts_check_eq("json_serialize_full", json_object_get_boolean_member(object, "bar"), TRUE); + dts_check_str_eq("json_serialize_full", json_object_get_string_member(object, "baz"), "Test"); + + node = json_object_get_member(object, "blah"); + dts_check_eq("json_serialize_full", json_node_get_node_type(node), JSON_NODE_OBJECT); + + object = json_node_get_object(node); + dts_check_eq("json_serialize_full", json_object_get_int_member(object, "foo"), 42); + dts_check_eq("json_serialize_full", json_object_get_boolean_member(object, "bar"), TRUE); + + g_free(data); + g_object_unref(parser); + g_object_unref(obj); + +} + diff --git a/TC/unit/TC_Gobject/utc_libjson_json_serialize_gobject_func.c b/TC/unit/TC_Gobject/utc_libjson_json_serialize_gobject_func.c new file mode 100755 index 0000000..cbc684e --- /dev/null +++ b/TC/unit/TC_Gobject/utc_libjson_json_serialize_gobject_func.c @@ -0,0 +1,410 @@ + +#include +#include +#include +#include +#include + +#include +#define JSON_DISABLE_DEPRECATED + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_serialize_gobject_func_01(void); +static void utc_libjson_json_serialize_gobject_func_02(void); +static void utc_libjson_json_serialize_gobject_func_03(void); +#ifndef JSON_DISABLE_DEPRECATED +static void utc_libjson_json_serialize_gobject_func_04(void); +static void utc_libjson_json_serialize_gobject_func_05(void); +#endif +static void utc_libjson_json_serialize_gobject_func_06(void); + + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_serialize_gobject_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_gobject_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_gobject_func_03, POSITIVE_TC_IDX }, +#ifndef JSON_DISABLE_DEPRECATED + { utc_libjson_json_serialize_gobject_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_gobject_func_05, POSITIVE_TC_IDX }, +#endif + { utc_libjson_json_serialize_gobject_func_06, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + + +#define TEST_TYPE_BOXED (test_boxed_get_type ()) +#define TEST_TYPE_OBJECT (test_object_get_type ()) +#define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject)) +#define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass)) +#define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass)) + +typedef struct _TestBoxed TestBoxed; +typedef struct _TestObject TestObject; +typedef struct _TestObjectClass TestObjectClass; + +struct _TestBoxed +{ + gint foo; + gboolean bar; +}; + +struct _TestObject +{ + GObject parent_instance; + + gint foo; + gboolean bar; + gchar *baz; + TestBoxed blah; +}; + +struct _TestObjectClass +{ + GObjectClass parent_class; +}; + +GType test_object_get_type (void); + +static const gchar *serialize_data = +"{\n" +" \"blah\" : {\n" +" \"foo\" : 42,\n" +" \"bar\" : true\n" +" }\n" +"}"; + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/*** implementation ***/ + +static TestBoxed * +test_boxed_copy (const TestBoxed *src) +{ + TestBoxed *copy = g_slice_new (TestBoxed); + + *copy = *src; + + return copy; +} + +static void +test_boxed_free (TestBoxed *boxed) +{ + if (G_LIKELY (boxed)) + { + g_slice_free (TestBoxed, boxed); + } +} + +GType +test_boxed_get_type (void) +{ + static GType b_type = 0; + + if (G_UNLIKELY (b_type == 0)) + b_type = g_boxed_type_register_static ("TestBoxed", + (GBoxedCopyFunc) test_boxed_copy, + (GBoxedFreeFunc) test_boxed_free); + + return b_type; +} + +enum +{ + PROP_0, + + PROP_FOO, + PROP_BAR, + PROP_BAZ, + PROP_BLAH +}; + +static JsonSerializableIface *serializable_iface = NULL; + +static void json_serializable_iface_init (gpointer g_iface); + +G_DEFINE_TYPE_WITH_CODE (TestObject, test_object, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE (JSON_TYPE_SERIALIZABLE, + json_serializable_iface_init)); + +static JsonNode * +test_object_serialize_property (JsonSerializable *serializable, + const gchar *name, + const GValue *value, + GParamSpec *pspec) +{ + JsonNode *retval = NULL; + + if (strcmp (name, "blah") == 0) + { + TestBoxed *boxed; + JsonObject *obj; + JsonNode *val; + + retval = json_node_new (JSON_NODE_OBJECT); + obj = json_object_new (); + + boxed = g_value_get_boxed (value); + + val = json_node_new (JSON_NODE_VALUE); + json_node_set_int (val, boxed->foo); + json_object_set_member (obj, "foo", val); + + val = json_node_new (JSON_NODE_VALUE); + json_node_set_boolean (val, boxed->bar); + json_object_set_member (obj, "bar", val); + + json_node_take_object (retval, obj); + } + else + retval = serializable_iface->serialize_property (serializable, + name, + value, pspec); + + return retval; +} + +static void +json_serializable_iface_init (gpointer g_iface) +{ + JsonSerializableIface *iface = g_iface; + + serializable_iface = g_type_default_interface_peek (JSON_TYPE_SERIALIZABLE); + + iface->serialize_property = test_object_serialize_property; +} + +static void +test_object_finalize (GObject *gobject) +{ + g_free (TEST_OBJECT (gobject)->baz); + + G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject); +} + +static void +test_object_set_property (GObject *gobject, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + TEST_OBJECT (gobject)->foo = g_value_get_int (value); + break; + case PROP_BAR: + TEST_OBJECT (gobject)->bar = g_value_get_boolean (value); + break; + case PROP_BAZ: + g_free (TEST_OBJECT (gobject)->baz); + TEST_OBJECT (gobject)->baz = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + g_value_set_int (value, TEST_OBJECT (gobject)->foo); + break; + case PROP_BAR: + g_value_set_boolean (value, TEST_OBJECT (gobject)->bar); + break; + case PROP_BAZ: + g_value_set_string (value, TEST_OBJECT (gobject)->baz); + break; + case PROP_BLAH: + g_value_set_boxed (value, &(TEST_OBJECT (gobject)->blah)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_class_init (TestObjectClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = test_object_set_property; + gobject_class->get_property = test_object_get_property; + gobject_class->finalize = test_object_finalize; + + g_object_class_install_property (gobject_class, + PROP_FOO, + g_param_spec_int ("foo", "Foo", "Foo", + 0, G_MAXINT, 42, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAR, + g_param_spec_boolean ("bar", "Bar", "Bar", + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAZ, + g_param_spec_string ("baz", "Baz", "Baz", + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BLAH, + g_param_spec_boxed ("blah", "Blah", "Blah", + TEST_TYPE_BOXED, + G_PARAM_READABLE)); +} + +static void +test_object_init (TestObject *object) +{ + object->foo = 42; + object->bar = TRUE; + object->baz = g_strdup ("Test"); + + object->blah.foo = object->foo; + object->blah.bar = object->bar; +} + +/** + * @brief Positive test case of json_gobject_to_data() + */ +static void utc_libjson_json_serialize_gobject_func_01(void) +{ + TestObject *obj = g_object_new(TEST_TYPE_OBJECT, "bar", TRUE, NULL); + gchar *data; + gsize len; + + data = json_gobject_to_data(G_OBJECT(obj), &len); + + dts_check_ne("json_gobject_to_data", data, NULL); + dts_check_gt("json_gobject_to_data", len, 0); + dts_check_eq("json_gobject_to_data", len, strlen(data)); + + g_free (data); + g_object_unref (obj); +} + + +/** + * @brief Negative test case of json_gobject_from_data() + */ +static void utc_libjson_json_serialize_gobject_func_02(void) +{ + GObject *obj = NULL; + + obj = json_gobject_from_data(TEST_TYPE_OBJECT, serialize_data, -1, NULL); + dts_check_eq("json_gobject_from_data", TEST_IS_OBJECT(obj), TRUE); + dts_check_eq("json_gobject_from_data", TEST_OBJECT(obj)->blah.foo, 42); + dts_check_eq("json_gobject_from_data", TEST_OBJECT(obj)->blah.bar, TRUE); + + g_object_unref (obj); +} + + +/** +* @brief Negative test case of json_gobject_serialize() +*/ +static void utc_libjson_json_serialize_gobject_func_03(void) +{ + JsonNode *node = NULL; + JsonObject *object = NULL; + GObject *obj = NULL; + + obj = g_object_new(TEST_TYPE_OBJECT, "bar", TRUE, NULL); + node = json_gobject_serialize(obj); + dts_check_eq("json_gobject_serialize", json_node_get_node_type (node), JSON_NODE_OBJECT); + object = json_node_get_object (node); + dts_check_eq("json_gobject_serialize", json_object_get_boolean_member(object, "bar"), TRUE); + + g_object_unref (obj); + json_node_free (node); +} + +#ifndef JSON_DISABLE_DEPRECATED + +/** + * @brief Negative test case of json_construct_gobject() + */ +static void utc_libjson_json_serialize_gobject_func_04(void) +{ + GObject *obj = NULL; + + obj = json_construct_gobject(TEST_TYPE_OBJECT, serialize_data, -1, NULL); + dts_check_eq("json_construct_gobject", TEST_IS_OBJECT(obj), TRUE); + dts_check_eq("json_construct_gobject", TEST_OBJECT(obj)->blah.foo, 42); + dts_check_eq("json_construct_gobject", TEST_OBJECT(obj)->blah.bar, TRUE); + + g_object_unref (obj); +} + + +/** + * @brief Negative test case of json_serialize_gobject() + */ +static void utc_libjson_json_serialize_gobject_func_05(void) +{ + GObject *obj = NULL; + + obj = json_serialize_gobject(TEST_TYPE_OBJECT, serialize_data, -1, NULL); + dts_check_eq("json_serialize_gobject", TEST_IS_OBJECT(obj), TRUE); + dts_check_eq("json_serialize_gobject", TEST_OBJECT(obj)->blah.foo, 42); + dts_check_eq("json_serialize_gobject", TEST_OBJECT(obj)->blah.bar, TRUE); + + g_object_unref (obj); +} +#endif + +/** +* @brief Negative test case of json_gobject_deserialize() +*/ +static void utc_libjson_json_serialize_gobject_func_06(void) +{ + GObject *obj = NULL; + JsonObject *object = NULL; + JsonNode *node = NULL; + + object = json_object_new(); + node = json_node_new(JSON_NODE_OBJECT); + json_object_set_int_member (object, "foo", 42); + json_object_set_boolean_member (object, "bar", TRUE); + json_node_take_object (node, object); + + obj = json_gobject_deserialize(TEST_TYPE_OBJECT, node); + dts_check_eq("json_gobject_deserialize", TEST_IS_OBJECT(obj), TRUE); + dts_check_eq("json_gobject_deserialize", TEST_OBJECT(obj)->foo, 42); + dts_check_eq("json_gobject_deserialize", TEST_OBJECT(obj)->bar, TRUE); + + g_object_unref (obj); + json_object_unref(object); + json_node_free (node); + +} + diff --git a/TC/unit/TC_Gobject/utc_libjson_json_serialize_interface_func.c b/TC/unit/TC_Gobject/utc_libjson_json_serialize_interface_func.c new file mode 100755 index 0000000..f2529ac --- /dev/null +++ b/TC/unit/TC_Gobject/utc_libjson_json_serialize_interface_func.c @@ -0,0 +1,405 @@ +#include +#include +#include +#include +#include + +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_serialize_full_func_01(void); +static void utc_libjson_json_serialize_full_func_02(void); +static void utc_libjson_json_serialize_full_func_03(void); +static void utc_libjson_json_serialize_full_func_04(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_serialize_full_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_full_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_full_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_serialize_full_func_04, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +#define TEST_TYPE_BOXED (test_boxed_get_type ()) +#define TEST_TYPE_OBJECT (test_object_get_type ()) +#define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject)) +#define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass)) +#define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass)) + +typedef struct _TestBoxed TestBoxed; +typedef struct _TestObject TestObject; +typedef struct _TestObjectClass TestObjectClass; + +struct _TestBoxed +{ + gint foo; + gboolean bar; +}; + +struct _TestObject +{ + GObject parent_instance; + + gint foo; + gboolean bar; + gchar *baz; + TestBoxed blah; +}; + +struct _TestObjectClass +{ + GObjectClass parent_class; +}; + + +GType test_object_get_type (void); + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/*** implementation ***/ + +static TestBoxed * +test_boxed_copy (const TestBoxed *src) +{ + TestBoxed *copy = g_slice_new (TestBoxed); + + *copy = *src; + + return copy; +} + +static void +test_boxed_free (TestBoxed *boxed) +{ + if (G_LIKELY (boxed)) + { + g_slice_free (TestBoxed, boxed); + } +} + +GType +test_boxed_get_type (void) +{ + static GType b_type = 0; + + if (G_UNLIKELY (b_type == 0)) + b_type = g_boxed_type_register_static ("TestBoxed", + (GBoxedCopyFunc) test_boxed_copy, + (GBoxedFreeFunc) test_boxed_free); + + return b_type; +} + +enum +{ + PROP_0, + + PROP_FOO, + PROP_BAR, + PROP_BAZ, + PROP_BLAH +}; + +static JsonSerializableIface *serializable_iface = NULL; + +static void json_serializable_iface_init (gpointer g_iface); + +G_DEFINE_TYPE_WITH_CODE (TestObject, test_object, G_TYPE_OBJECT, + G_IMPLEMENT_INTERFACE (JSON_TYPE_SERIALIZABLE, + json_serializable_iface_init)); + +static JsonNode * +test_object_serialize_property (JsonSerializable *serializable, + const gchar *name, + const GValue *value, + GParamSpec *pspec) +{ + JsonNode *retval = NULL; + + if (strcmp (name, "blah") == 0) + { + JsonObject *obj; + + retval = json_node_new (JSON_NODE_OBJECT); + obj = json_object_new (); + + json_object_set_int_member(obj, "foo", g_value_get_int(value)); + json_node_take_object (retval, obj); + } + else + retval = serializable_iface->serialize_property (serializable, + name, + value, pspec); + + return retval; +} + + +static gboolean +test_object_deserialize_property (JsonSerializable *serializable, + const gchar *name, + GValue *value, + GParamSpec *pspec, + JsonNode *node) +{ + gboolean retval = FALSE; + + if (strcmp (name, "blah") == 0) + { + JsonObject *obj; + + obj = json_node_get_object (node); + g_value_set_int (value, json_object_get_int_member(obj, "foo")); + retval = TRUE; + } + else + retval = serializable_iface->deserialize_property (serializable, + name, + value, pspec, node); + return retval; +} + +static void +json_serializable_iface_init (gpointer g_iface) +{ + JsonSerializableIface *iface = g_iface; + + serializable_iface = g_type_default_interface_peek (JSON_TYPE_SERIALIZABLE); + + iface->serialize_property = test_object_serialize_property; + iface->deserialize_property= test_object_deserialize_property; +} + +static void +test_object_finalize (GObject *gobject) +{ + g_free (TEST_OBJECT (gobject)->baz); + + G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject); +} + +static void +test_object_set_property (GObject *gobject, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + TEST_OBJECT (gobject)->foo = g_value_get_int (value); + break; + case PROP_BAR: + TEST_OBJECT (gobject)->bar = g_value_get_boolean (value); + break; + case PROP_BAZ: + g_free (TEST_OBJECT (gobject)->baz); + TEST_OBJECT (gobject)->baz = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + g_value_set_int (value, TEST_OBJECT (gobject)->foo); + break; + case PROP_BAR: + g_value_set_boolean (value, TEST_OBJECT (gobject)->bar); + break; + case PROP_BAZ: + g_value_set_string (value, TEST_OBJECT (gobject)->baz); + break; + case PROP_BLAH: + g_value_set_boxed (value, &(TEST_OBJECT (gobject)->blah)); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_class_init (TestObjectClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = test_object_set_property; + gobject_class->get_property = test_object_get_property; + gobject_class->finalize = test_object_finalize; + + g_object_class_install_property (gobject_class, + PROP_FOO, + g_param_spec_int ("foo", "Foo", "Foo", + 0, G_MAXINT, 42, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAR, + g_param_spec_boolean ("bar", "Bar", "Bar", + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAZ, + g_param_spec_string ("baz", "Baz", "Baz", + NULL, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BLAH, + g_param_spec_boxed ("blah", "Blah", "Blah", + TEST_TYPE_BOXED, + G_PARAM_READABLE)); +} + +static void +test_object_init (TestObject *object) +{ + object->foo = 42; + object->bar = TRUE; + object->baz = g_strdup ("Test"); + + object->blah.foo = object->foo; + object->blah.bar = object->bar; +} + + +static void utc_libjson_json_serialize_full_func_01(void) +{ + GObject *obj = NULL; + JsonSerializableIface *iface = NULL; + JsonSerializable *serializable = NULL; + GValue value = {0}; + GParamSpec pspecs; + JsonNode *node = NULL; + JsonObject *ret_object = NULL; + + obj = g_object_new(TEST_TYPE_OBJECT, "bar", TRUE, NULL); + + serializable = JSON_SERIALIZABLE (obj); + iface = JSON_SERIALIZABLE_GET_IFACE (serializable); + + g_value_init (&value, G_TYPE_INT); + g_value_set_int (&value, 42); + node = json_serializable_serialize_property(serializable, "blah", &value, &pspecs); + + ret_object = json_node_get_object (node); + dts_check_ne("json_serializable_serialize_property", ret_object, NULL); + dts_check_eq("json_serializable_serialize_property", json_object_get_int_member(ret_object, "foo"), 42); + + g_object_unref (obj); + json_node_free (node); +} + + +static void utc_libjson_json_serialize_full_func_02(void) +{ + JsonObject *object = NULL; + JsonNode *node = NULL; + GObject *obj = NULL; + JsonSerializableIface *iface = NULL; + JsonSerializable *serializable = NULL; + GValue value = {0}; + GParamSpec pspecs; + gboolean ret = FALSE; + + object = json_object_new(); + node = json_node_new(JSON_NODE_OBJECT); + json_object_set_int_member (object, "foo", 42); + json_node_take_object (node, object); + + obj = g_object_new(TEST_TYPE_OBJECT, "bar", TRUE, NULL); + + serializable = JSON_SERIALIZABLE (obj); + iface = JSON_SERIALIZABLE_GET_IFACE (serializable); + + g_value_init (&value, G_TYPE_INT); + ret = json_serializable_deserialize_property(serializable, "blah", &value, &pspecs, node); + dts_check_eq("json_serializable_deserialize_property", ret, TRUE); + dts_check_eq("json_serializable_deserialize_property", g_value_get_int (&value), 42); + + g_object_unref (obj); + json_object_unref(object); + json_node_free (node); + +} + +static void utc_libjson_json_serialize_full_func_03(void) +{ + JsonNode *node = NULL; + GObject *obj = NULL; + JsonSerializableIface *iface = NULL; + JsonSerializable *serializable = NULL; + GValue value = {0}; + GParamSpec pspecs; + + obj = g_object_new(TEST_TYPE_OBJECT, "bar", TRUE, NULL); + serializable = JSON_SERIALIZABLE (obj); + iface = JSON_SERIALIZABLE_GET_IFACE (serializable); + + g_value_init (&value, G_TYPE_INT); + g_value_set_int (&value, 42); + + node = json_serializable_default_serialize_property(serializable, "blah", &value, &pspecs); + dts_check_ne("json_serializable_default_serialize_property", node, NULL); + dts_check_eq("json_serializable_default_serialize_property", json_node_get_int(node), 42); + + g_object_unref (obj); + json_node_free (node); + +} + +static void utc_libjson_json_serialize_full_func_04(void) +{ + JsonNode *node = NULL; + GObject *obj = NULL; + JsonSerializableIface *iface = NULL; + JsonSerializable *serializable = NULL; + GValue value = {0}; + GParamSpec pspecs; + gboolean ret = FALSE; + + obj = g_object_new(TEST_TYPE_OBJECT, "bar", TRUE, NULL); + serializable = JSON_SERIALIZABLE (obj); + iface = JSON_SERIALIZABLE_GET_IFACE (serializable); + + node = json_node_new(JSON_NODE_VALUE); + json_node_set_int(node, 42); + + g_value_init (&value, G_TYPE_INT); + ret = json_serializable_default_deserialize_property(serializable, "blah", &value, &pspecs, node); + dts_check_eq("json_serializable_default_deserialize_property", ret, TRUE); + dts_check_eq("json_serializable_default_deserialize_property", g_value_get_int (&value), 42); + + g_object_unref (obj); + json_node_free (node); + +} + diff --git a/TC/unit/TC_Gobject/utc_libjson_json_serialize_simple_func.c b/TC/unit/TC_Gobject/utc_libjson_json_serialize_simple_func.c new file mode 100755 index 0000000..f24d25d --- /dev/null +++ b/TC/unit/TC_Gobject/utc_libjson_json_serialize_simple_func.c @@ -0,0 +1,184 @@ +#include +#include +#include +#include +#include + +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_serialize_simple_func_01(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_serialize_simple_func_01, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +#define TEST_TYPE_OBJECT (test_object_get_type ()) +#define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject)) +#define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), TEST_TYPE_OBJECT, TestObjectClass)) +#define TEST_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), TEST_TYPE_OBJECT)) +#define TEST_OBJECT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), TEST_TYPE_OBJECT, TestObjectClass)) + +typedef struct _TestObject TestObject; +typedef struct _TestObjectClass TestObjectClass; + +struct _TestObject +{ + GObject parent_instance; + + gint foo; + gboolean bar; + gchar *baz; +}; + +struct _TestObjectClass +{ + GObjectClass parent_class; +}; + +GType test_object_get_type (void); + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + + +/*** implementation ***/ + +enum +{ + PROP_0, + + PROP_FOO, + PROP_BAR, + PROP_BAZ +}; + +G_DEFINE_TYPE (TestObject, test_object, G_TYPE_OBJECT); + +static void +test_object_finalize (GObject *gobject) +{ + g_free (TEST_OBJECT (gobject)->baz); + + G_OBJECT_CLASS (test_object_parent_class)->finalize (gobject); +} + +static void +test_object_set_property (GObject *gobject, + guint prop_id, + const GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + TEST_OBJECT (gobject)->foo = g_value_get_int (value); + break; + case PROP_BAR: + TEST_OBJECT (gobject)->bar = g_value_get_boolean (value); + break; + case PROP_BAZ: + g_free (TEST_OBJECT (gobject)->baz); + TEST_OBJECT (gobject)->baz = g_value_dup_string (value); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_get_property (GObject *gobject, + guint prop_id, + GValue *value, + GParamSpec *pspec) +{ + switch (prop_id) + { + case PROP_FOO: + g_value_set_int (value, TEST_OBJECT (gobject)->foo); + break; + case PROP_BAR: + g_value_set_boolean (value, TEST_OBJECT (gobject)->bar); + break; + case PROP_BAZ: + g_value_set_string (value, TEST_OBJECT (gobject)->baz); + break; + default: + G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec); + } +} + +static void +test_object_class_init (TestObjectClass *klass) +{ + GObjectClass *gobject_class = G_OBJECT_CLASS (klass); + + gobject_class->set_property = test_object_set_property; + gobject_class->get_property = test_object_get_property; + gobject_class->finalize = test_object_finalize; + + g_object_class_install_property (gobject_class, + PROP_FOO, + g_param_spec_int ("foo", "Foo", "Foo", + 0, G_MAXINT, 42, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAR, + g_param_spec_boolean ("bar", "Bar", "Bar", + FALSE, + G_PARAM_READWRITE)); + g_object_class_install_property (gobject_class, + PROP_BAZ, + g_param_spec_string ("baz", "Baz", "Baz", + NULL, + G_PARAM_READWRITE)); +} + +static void +test_object_init (TestObject *object) +{ + object->foo = 42; + object->bar = FALSE; + object->baz = g_strdup ("Test"); +} + +/** + * @brief Positive test case of json_serialize_simple() + */ +static void utc_libjson_json_serialize_simple_func_01(void) +{ + TestObject *obj = g_object_new(TEST_TYPE_OBJECT, "bar", TRUE, NULL); + gchar *data; + gsize len; + + data = json_gobject_to_data(G_OBJECT(obj), &len); + + dts_check_ne("json_serialize_simple", data, NULL); + dts_check_gt("json_serialize_simple", len, 0); + dts_check_eq("json_serialize_simple", len, strlen(data)); + + g_free (data); + g_object_unref (obj); +} + + diff --git a/TC/unit/TC_Parser/Makefile b/TC/unit/TC_Parser/Makefile new file mode 100755 index 0000000..cbb3917 --- /dev/null +++ b/TC/unit/TC_Parser/Makefile @@ -0,0 +1,50 @@ +################################################### +# add your TestCase List Here +# +# e.g., +# TC1 = utc_frameworkName_apiName_func +# TC2 = utc_ApplicationLib_recurGetDayOfWeek_func +TARGETS = utc_libjson_json_parser_new_func \ + utc_libjson_json_parser_load_from_file_func \ + utc_libjson_json_parser_load_from_data_func \ + utc_libjson_json_parser_get_root_func \ + utc_libjson_json_parser_get_current_line_func \ + utc_libjson_json_parser_get_current_pos_func \ + utc_libjson_json_parser_has_assignment_func +################################################### +# add your Package Config Info Here +# +# e.g., +# PKGS=calendar +PKGS=json-glib-1.0 + +LIBS = `pkg-config --libs $(PKGS)` +LIBS += `pkg-config --libs glib-2.0` +LIBS +=$(TET_ROOT)/lib/tet3/tcm_s.o +LIBS +=-L$(TET_ROOT)/lib/tet3 -ltcm_s +LIBS +=-L$(TET_ROOT)/lib/tet3 -lapi_s + +INCS = -I. `pkg-config --cflags $(PKGS)` +INCS += -I. `pkg-config --cflags glib-2.0` +INCS += -I$(TET_ROOT)/inc/tet3 + + +CFLAGS = $(INCS) +CFLAGS += -D_TETWARE_MODE +CFLAGS += -Wall +LDFLAGS = $(LIBS) + +################################################### +# Modify here +# depending on the Test Case you want to build +# +# e.g., +# TCLIST = $(TC1) $(TC2) +all : $(TARGETS) + +$(TARGETS) : %: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean : + rm -rf $(TARGETS) + diff --git a/TC/unit/TC_Parser/tslist b/TC/unit/TC_Parser/tslist new file mode 100755 index 0000000..8b271d3 --- /dev/null +++ b/TC/unit/TC_Parser/tslist @@ -0,0 +1,7 @@ +/unit/TC_Parser/utc_libjson_json_parser_new_func +/unit/TC_Parser/utc_libjson_json_parser_load_from_file_func +/unit/TC_Parser/utc_libjson_json_parser_load_from_data_func +/unit/TC_Parser/utc_libjson_json_parser_get_root_func +/unit/TC_Parser/utc_libjson_json_parser_get_current_line_func +/unit/TC_Parser/utc_libjson_json_parser_get_current_pos_func +/unit/TC_Parser/utc_libjson_json_parser_has_assignment_func \ No newline at end of file diff --git a/TC/unit/TC_Parser/utc_libjson_json_parser_get_current_line_func.c b/TC/unit/TC_Parser/utc_libjson_json_parser_get_current_line_func.c new file mode 100755 index 0000000..1115c9b --- /dev/null +++ b/TC/unit/TC_Parser/utc_libjson_json_parser_get_current_line_func.c @@ -0,0 +1,91 @@ +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_parser_get_current_line_func_01(void); +static void utc_libjson_json_parser_get_current_line_func_02(void); +static void utc_libjson_json_parser_get_current_line_func_03(void); + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_parser_get_current_line_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_current_line_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_current_line_func_03, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static const gchar *test_string = "{ \"test\" : 42 }"; + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + + +/** + * @brief Positive test case of json_parser_get_current_line() + */ +static void utc_libjson_json_parser_get_current_line_func_01(void) +{ + int line = 0; + + line = json_parser_get_current_line(NULL); + + dts_check_eq("json_parser_get_current_line", line, 0); + +} + +/** + * @brief Negative test case of ug_init json_parser_get_current_line() + */ +static void utc_libjson_json_parser_get_current_line_func_02(void) +{ + JsonParser *parser = NULL; + int line = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + line = json_parser_get_current_line(parser); + dts_check_eq("json_parser_get_current_line", line, 0); + g_object_unref (parser); +} + + +static void utc_libjson_json_parser_get_current_line_func_03(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + int line = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_string, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + + line = json_parser_get_current_line(parser); + dts_check_eq("json_parser_get_current_line", line, 0); + g_error_free (error); + g_object_unref (parser); +} + + diff --git a/TC/unit/TC_Parser/utc_libjson_json_parser_get_current_pos_func.c b/TC/unit/TC_Parser/utc_libjson_json_parser_get_current_pos_func.c new file mode 100755 index 0000000..65f2c89 --- /dev/null +++ b/TC/unit/TC_Parser/utc_libjson_json_parser_get_current_pos_func.c @@ -0,0 +1,88 @@ +#include +#include +#include +#include +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_parser_get_current_pos_func_01(void); +static void utc_libjson_json_parser_get_current_pos_func_02(void); +static void utc_libjson_json_parser_get_current_pos_func_03(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_parser_get_current_pos_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_current_pos_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_current_pos_func_03, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static const gchar *test_string = "{ \"test\" : 42 }"; + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + + +/** + * @brief Positive test case of json_parser_get_current_pos() + */ +static void utc_libjson_json_parser_get_current_pos_func_01(void) +{ + int pos = 0; + + pos = json_parser_get_current_pos(NULL); + + dts_check_eq("json_parser_get_current_pos", pos, 0); + +} + +static void utc_libjson_json_parser_get_current_pos_func_02(void) +{ + JsonParser *parser = NULL; + int pos = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + pos = json_parser_get_current_pos(parser); + dts_check_eq("json_parser_get_current_pos", pos, 0); + g_object_unref (parser); +} + + +static void utc_libjson_json_parser_get_current_pos_func_03(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + int pos = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_string, -1, &error); + dts_check_eq("json_parser_get_current_pos", ret, TRUE); + + pos = json_parser_get_current_pos(parser); + dts_check_eq("json_parser_get_current_pos", pos, 0); + g_error_free (error); + g_object_unref (parser); +} + + diff --git a/TC/unit/TC_Parser/utc_libjson_json_parser_get_root_func.c b/TC/unit/TC_Parser/utc_libjson_json_parser_get_root_func.c new file mode 100755 index 0000000..0057923 --- /dev/null +++ b/TC/unit/TC_Parser/utc_libjson_json_parser_get_root_func.c @@ -0,0 +1,446 @@ +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_parser_get_root_func_01(void); +static void utc_libjson_json_parser_get_root_func_02(void); +static void utc_libjson_json_parser_get_root_func_03(void); +static void utc_libjson_json_parser_get_root_func_04(void); +static void utc_libjson_json_parser_get_root_func_05(void); +static void utc_libjson_json_parser_get_root_func_06(void); +static void utc_libjson_json_parser_get_root_func_07(void); +static void utc_libjson_json_parser_get_root_func_08(void); +static void utc_libjson_json_parser_get_root_func_09(void); +static void utc_libjson_json_parser_get_root_func_10(void); +static void utc_libjson_json_parser_get_root_func_11(void); + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_parser_get_root_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_05, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_06, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_07, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_08, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_09, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_10, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_get_root_func_11, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static const gchar *test_empty_string = ""; +static const gchar *test_empty_array_string = "[ ]"; +static const gchar *test_empty_object_string = "{ }"; + +static const struct { + const gchar *str; + JsonNodeType type; + GType gtype; +}test_base_values[] = { + { "null", JSON_NODE_NULL, G_TYPE_INVALID }, + { "42", JSON_NODE_VALUE, G_TYPE_INT64 }, + { "true", JSON_NODE_VALUE, G_TYPE_BOOLEAN }, + { "\"string\"", JSON_NODE_VALUE, G_TYPE_STRING }, + { "10.2e3", JSON_NODE_VALUE, G_TYPE_DOUBLE } +}; + +static const struct { + const gchar *str; + gint len; + gint element; + JsonNodeType type; + GType gtype; +}test_simple_arrays[] = { + { "[ true ]", 1, 0, JSON_NODE_VALUE, G_TYPE_BOOLEAN }, + { "[ true, false, null ]", 3, 2, JSON_NODE_NULL, G_TYPE_INVALID }, + { "[ 1, 2, 3.14, \"test\" ]", 4, 3, JSON_NODE_VALUE, G_TYPE_STRING } +}; + +static const gchar *test_nested_arrays[] = { + "[ 42, [ ], null ]", + "[ [ ], [ true, [ true ] ] ]", + "[ [ false, true, 42 ], [ true, false, 3.14 ], \"test\" ]", + "[ true, { } ]", + "[ false, { \"test\" : 42 } ]", + "[ { \"test\" : 42 }, null ]", + "[ true, { \"test\" : 42 }, null ]", + "[ { \"channel\" : \"/meta/connect\" } ]" +}; + +static const struct { + const gchar *str; + gint size; + const gchar *member; + JsonNodeType type; + GType gtype; +}test_simple_objects[] = { + { "{ \"test\" : 42 }", 1, "test", JSON_NODE_VALUE, G_TYPE_INT64 }, + { "{ \"name\" : \"\", \"state\" : 1 }", 2, "name", JSON_NODE_VALUE, G_TYPE_STRING }, + { "{ \"foo\" : \"bar\", \"baz\" : null }", 2, "baz", JSON_NODE_NULL, G_TYPE_INVALID }, + { "{ \"channel\" : \"/meta/connect\" }", 1, "channel", JSON_NODE_VALUE, G_TYPE_STRING } +}; + +static const gchar *test_nested_objects[] = { + "{ \"array\" : [ false, \"foo\" ], \"object\" : { \"foo\" : true } }" +}; + +static const struct { + const gchar *str; + const gchar *var; +}test_assignments[] = { + { "var foo = [ false, false, true ]", "foo" }, + { "var bar = [ true, 42 ];", "bar" }, + { "var baz = { \"foo\" : false }", "baz" } +}; + +static const struct +{ + const gchar *str; + const gchar *member; + const gchar *match; +}test_unicode[] = { + { "{ \"test\" : \"foo \\u00e8\" }", "test", "foo è" } +}; + +static const struct +{ + const gchar *str; +}test_invalid[] = { + { "test" }, + { "[ foo, ]" }, + { "[ true, ]" }, + { "{ \"foo\" : true \"bar\" : false }" }, + { "[ true, [ false, ] ]" }, + { "{ \"foo\" : { \"bar\" : false, } }" }, + { "[ { }, { }, { }, ]" } +}; + +static guint n_test_base_values = G_N_ELEMENTS (test_base_values); +static guint n_test_simple_arrays = G_N_ELEMENTS (test_simple_arrays); +static guint n_test_nested_arrays = G_N_ELEMENTS (test_nested_arrays); +static guint n_test_simple_objects = G_N_ELEMENTS (test_simple_objects); +static guint n_test_nested_objects = G_N_ELEMENTS (test_nested_objects); +static guint n_test_assignments = G_N_ELEMENTS (test_assignments); +static guint n_test_unicode = G_N_ELEMENTS (test_unicode); +static guint n_test_invalid = G_N_ELEMENTS (test_invalid); + +static void startup(void) +{ + g_type_init (); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_parser_get_root() + */ +static void utc_libjson_json_parser_get_root_func_01(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_empty_string, -1, &error); + dts_check_eq("json_parser_get_root", ret, TRUE); + + root = json_parser_get_root (parser); + dts_check_eq("json_parser_get_root", root, NULL); + + g_error_free (error); + g_object_unref (parser); +} + +static void utc_libjson_json_parser_get_root_func_02(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_base_values; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_base_values[i].str, -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + dts_check_eq("json_parser_get_root", JSON_NODE_TYPE(root), test_base_values[i].type); + } + } + dts_pass("json_parser_get_root", "pass"); + g_object_unref (parser); + +} + +static void utc_libjson_json_parser_get_root_func_03(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_empty_array_string, -1, &error); + dts_check_eq("json_parser_get_root", ret, TRUE); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + dts_check_eq("json_parser_get_root", JSON_NODE_TYPE(root), JSON_NODE_ARRAY); + g_error_free (error); + g_object_unref (parser); +} + + +static void utc_libjson_json_parser_get_root_func_04(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_simple_arrays; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_simple_arrays[i].str, -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + dts_check_eq("json_parser_get_root", JSON_NODE_TYPE(root), JSON_NODE_ARRAY); + } + } + dts_pass("json_parser_get_root", "pass"); + g_object_unref (parser); +} + + +static void utc_libjson_json_parser_get_root_func_05(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_nested_arrays; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_nested_arrays[i], -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + dts_check_eq("json_parser_get_root", JSON_NODE_TYPE(root), JSON_NODE_ARRAY); + } + } + dts_pass("json_parser_get_root", "pass"); + g_object_unref (parser); +} + +static void utc_libjson_json_parser_get_root_func_06(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_empty_object_string, -1, &error); + dts_check_eq("json_parser_get_root", ret, TRUE); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + dts_check_eq("json_parser_get_root", JSON_NODE_TYPE(root), JSON_NODE_OBJECT); + g_error_free (error); + g_object_unref (parser); +} + + + +static void utc_libjson_json_parser_get_root_func_07(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_simple_objects; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_simple_objects[i].str, -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + dts_check_eq("json_parser_get_root", JSON_NODE_TYPE(root), JSON_NODE_OBJECT); + } + } + dts_pass("json_parser_get_root", "pass"); + g_object_unref (parser); + +} + +static void utc_libjson_json_parser_get_root_func_08(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_nested_objects; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_nested_objects[i], -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + dts_check_eq("json_parser_get_root", JSON_NODE_TYPE(root), JSON_NODE_OBJECT); + } + } + dts_pass("json_parser_get_root", "pass"); + g_object_unref (parser); + +} + + +static void utc_libjson_json_parser_get_root_func_09(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_assignments; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_assignments[i].str, -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_parser_get_root", root, NULL); + } + } + dts_pass("json_parser_has_assignment", "pass"); + g_object_unref (parser); +} + + +static void utc_libjson_json_parser_get_root_func_10(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_unicode; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_unicode[i].str, -1, &error)) + { + g_error_free (error); + } + else + { + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE (root), JSON_NODE_OBJECT); + } + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); + +} + + +static void utc_libjson_json_parser_get_root_func_11(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_invalid; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_invalid[i].str, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, FALSE); + + dts_check_ne("json_parser_load_from_data", error, NULL); + dts_check_eq("json_parser_load_from_data", error->domain, JSON_PARSER_ERROR); + + g_error_free (error); + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); + +} + + diff --git a/TC/unit/TC_Parser/utc_libjson_json_parser_has_assignment_func.c b/TC/unit/TC_Parser/utc_libjson_json_parser_has_assignment_func.c new file mode 100755 index 0000000..044cead --- /dev/null +++ b/TC/unit/TC_Parser/utc_libjson_json_parser_has_assignment_func.c @@ -0,0 +1,136 @@ +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_parser_has_assignment_func_01(void); +static void utc_libjson_json_parser_has_assignment_func_02(void); +static void utc_libjson_json_parser_has_assignment_func_03(void); +static void utc_libjson_json_parser_has_assignment_func_04(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_parser_has_assignment_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_has_assignment_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_has_assignment_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_has_assignment_func_04, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +static const gchar *test_string = "{ \"test\" : 42 }"; + +static const struct { + const gchar *str; + const gchar *var; +}test_assignments[] = { + { "var foo = [ false, false, true ]", "foo" }, + { "var bar = [ true, 42 ];", "bar" }, + { "var baz = { \"foo\" : false }", "baz" } +}; + +static guint n_test_assignments = G_N_ELEMENTS (test_assignments); + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + + + +/** + * @brief Positive test case of json_parser_has_assignment() + */ +static void utc_libjson_json_parser_has_assignment_func_01(void) +{ + gboolean ret = FALSE; + + ret = json_parser_has_assignment (NULL, NULL); + dts_check_eq("json_parser_has_assignment", ret, FALSE); +} + +/** + * @brief Negative test case of ug_init json_parser_has_assignment() + */ +static void utc_libjson_json_parser_has_assignment_func_02(void) +{ + JsonParser *parser = NULL; + gboolean ret = FALSE; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_has_assignment(parser, NULL); + dts_check_eq("json_parser_has_assignment", ret, FALSE); + g_object_unref (parser); +} + +static void utc_libjson_json_parser_has_assignment_func_03(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + gchar *var = NULL; ; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + if (!json_parser_load_from_data (parser, test_string, -1, &error)) + { + g_error_free (error); + } + else + { + ret = json_parser_has_assignment (parser, &var); + dts_check_eq("json_parser_has_assignment", ret, FALSE); + dts_check_eq("json_parser_has_assignment", var, NULL); + } + g_object_unref (parser); +} + +static void utc_libjson_json_parser_has_assignment_func_04(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + gchar *var = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_assignments; i++) + { + error = NULL; + if (!json_parser_load_from_data (parser, test_assignments[i].str, -1, &error)) + { + g_error_free (error); + } + else + { + ret = json_parser_has_assignment (parser, &var); + dts_check_eq("json_parser_has_assignment", ret, TRUE); + dts_check_ne("json_parser_has_assignment", var, NULL); + dts_check_str_eq ("json_parser_has_assignment", var, test_assignments[i].var); + } + } + dts_pass("json_parser_has_assignment", "pass"); + g_object_unref (parser); +} + diff --git a/TC/unit/TC_Parser/utc_libjson_json_parser_load_from_data_func.c b/TC/unit/TC_Parser/utc_libjson_json_parser_load_from_data_func.c new file mode 100755 index 0000000..cebfbd7 --- /dev/null +++ b/TC/unit/TC_Parser/utc_libjson_json_parser_load_from_data_func.c @@ -0,0 +1,537 @@ +#include +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_parser_load_from_data_func_01(void); +static void utc_libjson_json_parser_load_from_data_func_02(void); +static void utc_libjson_json_parser_load_from_data_func_03(void); +static void utc_libjson_json_parser_load_from_data_func_04(void); +static void utc_libjson_json_parser_load_from_data_func_05(void); +static void utc_libjson_json_parser_load_from_data_func_06(void); +static void utc_libjson_json_parser_load_from_data_func_07(void); +static void utc_libjson_json_parser_load_from_data_func_08(void); +static void utc_libjson_json_parser_load_from_data_func_09(void); +static void utc_libjson_json_parser_load_from_data_func_10(void); +static void utc_libjson_json_parser_load_from_data_func_11(void); +static void utc_libjson_json_parser_load_from_data_func_12(void); + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_parser_load_from_data_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_05, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_06, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_07, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_08, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_09, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_10, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_11, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_data_func_12, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static const gchar *test_empty_string = ""; +static const gchar *test_empty_array_string = "[ ]"; +static const gchar *test_empty_object_string = "{ }"; + +static void +verify_int_value (JsonNode *node) +{ + dts_check_eq("json_parser_load_from_data", 42, json_node_get_int (node)); +} + +static void +verify_boolean_value (JsonNode *node) +{ + dts_check_eq("json_parser_load_from_data", TRUE, json_node_get_boolean (node)); +} + +static void +verify_string_value (JsonNode *node) +{ + dts_check_str_eq("json_parser_load_from_data", "string", json_node_get_string (node)); +} + +static void +verify_double_value (JsonNode *node) +{ + dts_check_eq("json_parser_load_from_data", 10.2e3, json_node_get_double (node)); +} + +static const struct { + const gchar *str; + JsonNodeType type; + GType gtype; + void (* verify_value) (JsonNode *node); +}test_base_values[] = { + { "null", JSON_NODE_NULL, G_TYPE_INVALID, NULL, }, + { "42", JSON_NODE_VALUE, G_TYPE_INT64, verify_int_value }, + { "true", JSON_NODE_VALUE, G_TYPE_BOOLEAN, verify_boolean_value }, + { "\"string\"", JSON_NODE_VALUE, G_TYPE_STRING, verify_string_value }, + { "10.2e3", JSON_NODE_VALUE, G_TYPE_DOUBLE, verify_double_value } +}; + +static const struct { + const gchar *str; + gint len; + gint element; + JsonNodeType type; + GType gtype; +}test_simple_arrays[] = { + { "[ true ]", 1, 0, JSON_NODE_VALUE, G_TYPE_BOOLEAN }, + { "[ true, false, null ]", 3, 2, JSON_NODE_NULL, G_TYPE_INVALID }, + { "[ 1, 2, 3.14, \"test\" ]", 4, 3, JSON_NODE_VALUE, G_TYPE_STRING } +}; + +static const gchar *test_nested_arrays[] = { + "[ 42, [ ], null ]", + "[ [ ], [ true, [ true ] ] ]", + "[ [ false, true, 42 ], [ true, false, 3.14 ], \"test\" ]", + "[ true, { } ]", + "[ false, { \"test\" : 42 } ]", + "[ { \"test\" : 42 }, null ]", + "[ true, { \"test\" : 42 }, null ]", + "[ { \"channel\" : \"/meta/connect\" } ]" +}; + +static const struct { + const gchar *str; + gint size; + const gchar *member; + JsonNodeType type; + GType gtype; +}test_simple_objects[] = { + { "{ \"test\" : 42 }", 1, "test", JSON_NODE_VALUE, G_TYPE_INT64 }, + { "{ \"name\" : \"\", \"state\" : 1 }", 2, "name", JSON_NODE_VALUE, G_TYPE_STRING }, + { "{ \"foo\" : \"bar\", \"baz\" : null }", 2, "baz", JSON_NODE_NULL, G_TYPE_INVALID }, + { "{ \"channel\" : \"/meta/connect\" }", 1, "channel", JSON_NODE_VALUE, G_TYPE_STRING } +}; + +static const gchar *test_nested_objects[] = { + "{ \"array\" : [ false, \"foo\" ], \"object\" : { \"foo\" : true } }" +}; + +static const struct +{ + const gchar *str; + const gchar *member; + const gchar *match; +}test_unicode[] = { + { "{ \"test\" : \"foo \\u00e8\" }", "test", "foo è" } +}; + +static const struct +{ + const gchar *str; +}test_invalid[] = { + { "test" }, + { "[ foo, ]" }, + { "[ true, ]" }, + { "{ \"foo\" : true \"bar\" : false }" }, + { "[ true, [ false, ] ]" }, + { "{ \"foo\" : { \"bar\" : false, } }" }, + { "[ { }, { }, { }, ]" } +}; + +static guint n_test_base_values = G_N_ELEMENTS (test_base_values); +static guint n_test_simple_arrays = G_N_ELEMENTS (test_simple_arrays); +static guint n_test_nested_arrays = G_N_ELEMENTS (test_nested_arrays); +static guint n_test_simple_objects = G_N_ELEMENTS (test_simple_objects); +static guint n_test_nested_objects = G_N_ELEMENTS (test_nested_objects); +static guint n_test_unicode = G_N_ELEMENTS (test_unicode); +static guint n_test_invalid = G_N_ELEMENTS (test_invalid); + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_parser_load_from_data() + */ +static void utc_libjson_json_parser_load_from_data_func_01(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(NULL, NULL, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, FALSE); + g_error_free (error); + g_object_unref (parser); +} + +/** + * @brief Negative test case of ug_init json_parser_load_from_data() + */ +static void utc_libjson_json_parser_load_from_data_func_02(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, NULL, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, FALSE); + g_error_free (error); + g_object_unref (parser); +} + +static void utc_libjson_json_parser_load_from_data_func_03(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_empty_string, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + + root = json_parser_get_root (parser); + dts_check_eq("json_parser_load_from_data", root, NULL); + + g_error_free (error); + g_object_unref (parser); +} + +static void utc_libjson_json_parser_load_from_data_func_04(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_base_values; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_base_values[i].str, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + g_error_free (error); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", json_node_get_parent(root), NULL); + + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE (root), test_base_values[i].type); + dts_check_eq("json_parser_load_from_data", json_node_get_value_type (root), test_base_values[i].gtype); + + if (test_base_values[i].verify_value) + test_base_values[i].verify_value (root); + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); + +} + +static void utc_libjson_json_parser_load_from_data_func_05(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + JsonArray *array = NULL; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_empty_array_string, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE (root), JSON_NODE_ARRAY); + dts_check_eq("json_parser_load_from_data", json_node_get_parent (root), NULL); + + array = json_node_get_array (root); + dts_check_ne("json_parser_load_from_data", array, NULL); + + dts_check_eq("json_parser_load_from_data", json_array_get_length (array), 0); + + g_error_free(error); + g_object_unref(parser); +} + + +static void utc_libjson_json_parser_load_from_data_func_06(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + JsonNode *node = NULL; + JsonArray *array = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_simple_arrays; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_simple_arrays[i].str, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + g_error_free (error); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(root), JSON_NODE_ARRAY); + dts_check_eq("json_parser_load_from_data", json_node_get_parent(root), NULL); + + array = json_node_get_array (root); + dts_check_ne("json_parser_load_from_data", array, NULL); + + dts_check_eq("json_parser_load_from_data", json_array_get_length(array), test_simple_arrays[i].len); + + node = json_array_get_element (array, test_simple_arrays[i].element); + dts_check_ne("json_parser_load_from_data", node, NULL); + dts_check_eq("json_parser_load_from_data", json_node_get_parent(node), root); + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(node), test_simple_arrays[i].type); + dts_check_eq("json_parser_load_from_data", json_node_get_value_type (node), test_simple_arrays[i].gtype); + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); +} + + +static void utc_libjson_json_parser_load_from_data_func_07(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + JsonArray *array = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_nested_arrays; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_nested_arrays[i], -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + g_error_free (error); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(root), JSON_NODE_ARRAY); + dts_check_eq("json_parser_load_from_data", json_node_get_parent(root), NULL); + + array = json_node_get_array (root); + dts_check_ne("json_parser_load_from_data", array, NULL); + + dts_check_gt("json_parser_load_from_data", json_array_get_length(array), 0); + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); +} + +static void utc_libjson_json_parser_load_from_data_func_08(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + JsonObject *object = NULL; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_data(parser, test_empty_object_string, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", json_node_get_parent(root), NULL); + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(root), JSON_NODE_OBJECT); + dts_check_eq("json_parser_load_from_data", json_node_get_parent(root), NULL); + + object = json_node_get_object (root); + dts_check_ne("json_parser_load_from_data", object, NULL); + + dts_check_eq("json_parser_load_from_data", json_object_get_size(object), 0); + + g_error_free (error); + g_object_unref (parser); +} + + + +static void utc_libjson_json_parser_load_from_data_func_09(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + JsonNode *node = NULL; + JsonObject *object = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_simple_objects; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_simple_objects[i].str, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + g_error_free (error); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(root), JSON_NODE_OBJECT); + dts_check_eq("json_parser_load_from_data", json_node_get_parent(root), NULL); + + object = json_node_get_object (root); + dts_check_ne("json_parser_load_from_data",object, NULL); + dts_check_eq("json_parser_load_from_data", json_object_get_size(object), test_simple_objects[i].size); + + node = json_object_get_member (object, test_simple_objects[i].member); + dts_check_ne("json_parser_load_from_data", node, NULL); + dts_check_eq("json_parser_load_from_data", json_node_get_parent(node), root); + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(node), test_simple_objects[i].type); + dts_check_eq("json_parser_load_from_data", json_node_get_value_type(node), test_simple_objects[i].gtype); + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); + +} + +static void utc_libjson_json_parser_load_from_data_func_10(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + JsonObject *object = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_nested_objects; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_nested_objects[i], -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + g_error_free (error); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(root), JSON_NODE_OBJECT); + dts_check_eq("json_parser_load_from_data", json_node_get_parent(root), NULL); + + object = json_node_get_object (root); + dts_check_ne("json_parser_load_from_data", object, NULL); + dts_check_gt("json_parser_load_from_data", json_object_get_size(object), 0); + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); + +} + + +static void utc_libjson_json_parser_load_from_data_func_11(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + JsonNode *root = NULL; + JsonNode *node = NULL; + JsonObject *object = NULL; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_unicode; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_unicode[i].str, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, TRUE); + g_error_free (error); + + root = json_parser_get_root (parser); + dts_check_ne("json_parser_load_from_data", root, NULL); + + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE (root), JSON_NODE_OBJECT); + + object = json_node_get_object (root); + dts_check_ne("json_parser_load_from_data", object, NULL); + dts_check_gt("json_parser_load_from_data", json_object_get_size (object), 0); + + node = json_object_get_member(object, test_unicode[i].member); + dts_check_eq("json_parser_load_from_data", JSON_NODE_TYPE(node), JSON_NODE_VALUE); + dts_check_str_eq("json_parser_load_from_data", json_node_get_string (node), test_unicode[i].match); + dts_check_eq("json_parser_load_from_data", g_utf8_validate(json_node_get_string (node), -1, NULL), TRUE); + + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); +} + + +static void utc_libjson_json_parser_load_from_data_func_12(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + int i = 0; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + for (i = 0; i < n_test_invalid; i++) + { + error = NULL; + ret = json_parser_load_from_data (parser, test_invalid[i].str, -1, &error); + dts_check_eq("json_parser_load_from_data", ret, FALSE); + + dts_check_ne("json_parser_load_from_data", error, NULL); + dts_check_eq("json_parser_load_from_data", error->domain, JSON_PARSER_ERROR); + + g_error_free (error); + } + dts_pass("json_parser_load_from_data", "pass"); + g_object_unref (parser); +} + diff --git a/TC/unit/TC_Parser/utc_libjson_json_parser_load_from_file_func.c b/TC/unit/TC_Parser/utc_libjson_json_parser_load_from_file_func.c new file mode 100755 index 0000000..392b312 --- /dev/null +++ b/TC/unit/TC_Parser/utc_libjson_json_parser_load_from_file_func.c @@ -0,0 +1,94 @@ +#include + +#include +#include +#include +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_parser_load_from_file_func_01(void); +static void utc_libjson_json_parser_load_from_file_func_02(void); +static void utc_libjson_json_parser_load_from_file_func_03(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_parser_load_from_file_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_file_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_load_from_file_func_03, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +static void startup(void) +{ + g_type_init (); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_parser_load_from_file() + */ +static void utc_libjson_json_parser_load_from_file_func_01(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_file(NULL, NULL, &error); + dts_check_eq("json_parser_load_from_file", ret, FALSE); + g_error_free (error); + g_object_unref (parser); +} + +/** + * @brief Negative test case of ug_init json_parser_load_from_file() + */ +static void utc_libjson_json_parser_load_from_file_func_02(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_file(parser, NULL, &error); + dts_check_eq("json_parser_load_from_file", ret, FALSE); + g_error_free (error); + g_object_unref (parser); +} + +/** + * @brief Negative test case of ug_init json_parser_load_from_file() + */ +static void utc_libjson_json_parser_load_from_file_func_03(void) +{ + JsonParser *parser = NULL; + GError *error = NULL; + gboolean ret = FALSE; + + parser = json_parser_new (); + g_assert (JSON_IS_PARSER (parser)); + + ret = json_parser_load_from_file(parser, "", &error); + dts_check_eq("json_parser_load_from_file", ret, FALSE); + g_error_free (error); + g_object_unref (parser); +} + diff --git a/TC/unit/TC_Parser/utc_libjson_json_parser_new_func.c b/TC/unit/TC_Parser/utc_libjson_json_parser_new_func.c new file mode 100755 index 0000000..87964a8 --- /dev/null +++ b/TC/unit/TC_Parser/utc_libjson_json_parser_new_func.c @@ -0,0 +1,60 @@ +#include + +#include +#include +#include +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_parser_new_func_01(void); +static void utc_libjson_json_parser_new_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_parser_new_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_parser_new_func_02, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + g_type_init (); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_parser_new() + */ +static void utc_libjson_json_parser_new_func_01(void) +{ + JsonParser *parser = NULL; + + parser = json_parser_new (); + dts_check_ne("json_parser_new", parser, NULL); + g_object_unref (parser); +} + +/** + * @brief Negative test case of ug_init json_parser_new() + */ +static void utc_libjson_json_parser_new_func_02(void) +{ + JsonParser *parser = NULL; + + parser = json_parser_new(); + + dts_check_eq("json_parser_new", JSON_IS_PARSER(parser), TRUE); + g_object_unref (parser); +} diff --git a/TC/unit/TC_Types/Makefile b/TC/unit/TC_Types/Makefile new file mode 100755 index 0000000..6a7b5df --- /dev/null +++ b/TC/unit/TC_Types/Makefile @@ -0,0 +1,46 @@ +################################################### +# add your TestCase List Here +# +# e.g., +# TC1 = utc_frameworkName_apiName_func +# TC2 = utc_ApplicationLib_recurGetDayOfWeek_func +TARGETS = utc_libjson_json_array_func \ + utc_libjson_json_node_func \ + utc_libjson_json_object_func +################################################### +# add your Package Config Info Here +# +# e.g., +# PKGS=calendar +PKGS=json-glib-1.0 + +LIBS = `pkg-config --libs $(PKGS)` +LIBS += `pkg-config --libs glib-2.0` +LIBS +=$(TET_ROOT)/lib/tet3/tcm_s.o +LIBS +=-L$(TET_ROOT)/lib/tet3 -ltcm_s +LIBS +=-L$(TET_ROOT)/lib/tet3 -lapi_s + +INCS = -I. `pkg-config --cflags $(PKGS)` +INCS += -I. `pkg-config --cflags glib-2.0` +INCS += -I$(TET_ROOT)/inc/tet3 + + +CFLAGS = $(INCS) +CFLAGS += -D_TETWARE_MODE +CFLAGS += -Wall +LDFLAGS = $(LIBS) + +################################################### +# Modify here +# depending on the Test Case you want to build +# +# e.g., +# TCLIST = $(TC1) $(TC2) +all : $(TARGETS) + +$(TARGETS) : %: %.c + $(CC) -o $@ $< $(CFLAGS) $(LDFLAGS) + +clean : + rm -rf $(TARGETS) + diff --git a/TC/unit/TC_Types/tslist b/TC/unit/TC_Types/tslist new file mode 100755 index 0000000..6877eac --- /dev/null +++ b/TC/unit/TC_Types/tslist @@ -0,0 +1,3 @@ +/unit/TC_Types/utc_libjson_json_array_func +/unit/TC_Types/utc_libjson_json_node_func +/unit/TC_Types/utc_libjson_json_object_func \ No newline at end of file diff --git a/TC/unit/TC_Types/utc_libjson_json_array_func.c b/TC/unit/TC_Types/utc_libjson_json_array_func.c new file mode 100755 index 0000000..b733e80 --- /dev/null +++ b/TC/unit/TC_Types/utc_libjson_json_array_func.c @@ -0,0 +1,201 @@ +#include +#include +#include +#include +#include +#include + +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_array_func_01(void); +static void utc_libjson_json_array_func_02(void); +static void utc_libjson_json_array_func_03(void); +static void utc_libjson_json_array_func_04(void); +static void utc_libjson_json_array_func_05(void); +static void utc_libjson_json_array_func_06(void); + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_array_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_array_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_array_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_array_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_array_func_05, POSITIVE_TC_IDX }, + { utc_libjson_json_array_func_06, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + + +typedef struct _TestForeachFixture +{ + gint n_elements; +}TestForeachFixture; + +static const struct { + JsonNodeType element_type; + GType element_gtype; +}type_verify[] = { + { JSON_NODE_VALUE, G_TYPE_INT64 }, + { JSON_NODE_VALUE, G_TYPE_BOOLEAN }, + { JSON_NODE_VALUE, G_TYPE_STRING }, + { JSON_NODE_NULL, G_TYPE_INVALID } +}; + + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_array() + */ +static void utc_libjson_json_array_func_01(void) +{ + JsonArray *array = json_array_new (); + + dts_check_eq("json_array_empty", json_array_get_length (array), 0); + dts_check_eq("json_array_empty", json_array_get_elements (array), NULL); + + json_array_unref (array); +} + +/** + * @brief Negative test case of ug_init json_array() + */ +static void utc_libjson_json_array_func_02(void) +{ + JsonArray *array = json_array_new (); + JsonNode *node = json_node_new (JSON_NODE_NULL); + + dts_check_eq("json_array_add", json_array_get_length (array), 0); + + json_array_add_element (array, node); + dts_check_eq("json_array_add", json_array_get_length (array), 1); + + node = json_array_get_element (array, 0); + dts_check_eq("json_array_add", JSON_NODE_TYPE (node), JSON_NODE_NULL); + + json_array_unref (array); +} + +static void utc_libjson_json_array_func_03(void) +{ + JsonArray *array = json_array_new (); + JsonNode *node = json_node_new (JSON_NODE_NULL); + + json_array_add_element (array, node); + json_array_remove_element (array, 0); + dts_check_eq("json_array_remove", json_array_get_length (array), 0); + + json_array_unref (array); +} + +static void +verify_foreach (JsonArray *array, + guint index_, + JsonNode *element_node, + gpointer user_data) +{ + TestForeachFixture *fixture = user_data; + + dts_check_eq("json_array_foreach_element", json_node_get_node_type(element_node), type_verify[index_].element_type); + dts_check_eq("json_array_foreach_element", json_node_get_value_type(element_node), type_verify[index_].element_gtype); + + fixture->n_elements += 1; +} + + +static void utc_libjson_json_array_func_04(void) +{ + JsonArray *array = json_array_new (); + TestForeachFixture fixture = { 0, }; + + json_array_add_int_element (array, 42); + json_array_add_boolean_element (array, TRUE); + json_array_add_string_element (array, "hello"); + json_array_add_null_element (array); + + json_array_foreach_element (array, verify_foreach, &fixture); + + dts_check_eq("json_array_foreach_element", fixture.n_elements, json_array_get_length (array)); + + json_array_unref (array); +} + +static void utc_libjson_json_array_func_05(void) +{ + JsonArray *array = json_array_sized_new (3); + JsonArray *ret_array = NULL; + + ret_array = json_array_ref(array); + dts_check_eq ("json_object_ref", ret_array, array); + + json_array_unref (array); // for ref + json_array_unref (array); // for new +} + + +static void utc_libjson_json_array_func_06(void) +{ + JsonArray* array = NULL; + JsonArray* array_member = NULL; + JsonObject * object_member = NULL; + JsonArray* ret_array = NULL; + JsonObject * ret_object = NULL; + JsonNode * dup_node = NULL; + + array = json_array_new (); + + json_array_add_int_element (array, 42); + json_array_add_double_element(array, 25.6); + json_array_add_boolean_element(array, TRUE); + json_array_add_string_element(array, "foo"); + json_array_add_null_element(array); + + array_member = json_array_new(); + json_array_add_int_element(array_member, 12); + json_array_add_array_element(array, array_member); + + object_member = json_object_new(); + json_object_set_int_member(object_member, "foo", 89); + json_array_add_object_element(array, object_member); + + dts_check_eq ("json_array_int_member_get_set", json_array_get_int_element (array, 0), 42); + dts_check_eq ("json_array_double_member_get_set", json_array_get_double_element (array, 1), 25.6); + dts_check_eq ("json_array_boolean_member_get_set", json_array_get_boolean_element (array, 2), TRUE); + dts_check_str_eq ("json_array_string_member_get_set", json_array_get_string_element (array, 3),"foo"); + dts_check_eq ("json_array_null_member_get_set", json_array_get_null_element (array, 4), TRUE); + + ret_array = json_array_get_array_element (array, 5); + dts_check_eq ("json_array_array_member_get_set", json_array_get_int_element(ret_array, 0), 12); + + ret_object = json_array_get_object_element (array,6); + dts_check_eq ("json_array_object_member_get_set", json_object_get_int_member (ret_object, "foo"), 89); + + dup_node = json_array_dup_element(array, 0); + dts_check_eq ("json_array_dup_element", json_node_get_int(dup_node), 42); + + json_object_unref(object_member); + json_array_unref(array_member); + json_array_unref(array); +} + + + diff --git a/TC/unit/TC_Types/utc_libjson_json_node_func.c b/TC/unit/TC_Types/utc_libjson_json_node_func.c new file mode 100755 index 0000000..83c8038 --- /dev/null +++ b/TC/unit/TC_Types/utc_libjson_json_node_func.c @@ -0,0 +1,276 @@ +#include +#include +#include +#include +#include +#include + +#include + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_node_func_01(void); +static void utc_libjson_json_node_func_02(void); +static void utc_libjson_json_node_func_03(void); +static void utc_libjson_json_node_func_04(void); +static void utc_libjson_json_node_func_05(void); +static void utc_libjson_json_node_func_06(void); +static void utc_libjson_json_node_func_07(void); +static void utc_libjson_json_node_func_08(void); +static void utc_libjson_json_node_func_09(void); +static void utc_libjson_json_node_func_10(void); +static void utc_libjson_json_node_func_11(void); + + +/* +#define TEST_TYPE_BOXED (test_boxed_get_type ()) +#define TEST_TYPE_OBJECT (test_object_get_type ()) +#define TEST_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), TEST_TYPE_OBJECT, TestObject)) +#define TEST_IS_OBJECT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), TEST_TYPE_OBJECT)) + +*/ +#define JSON_TYPE_NODE (json_node_get_type ()) + +#define TEST_IS_JSONNODE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), JSON_TYPE_NODE)) + +GType json_node_get_type (void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_node_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_05, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_06, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_07, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_08, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_09, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_10, POSITIVE_TC_IDX }, + { utc_libjson_json_node_func_11, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_node() + */ +static void utc_libjson_json_node_func_01(void) +{ + JsonNode *node = json_node_new (JSON_NODE_NULL); + JsonNode *copy = json_node_copy (node); + + dts_check_eq ("json_node_copy_null", json_node_get_node_type (node), json_node_get_node_type (copy)); + dts_check_eq ("json_node_copy_null", json_node_get_value_type (node), json_node_get_value_type (copy)); + dts_check_eq ("json_node_copy_null", json_node_type_name (node), json_node_type_name (copy)); + + json_node_free (copy); + json_node_free (node); +} + +/** + * @brief Negative test case of ug_init json_node() + */ +static void utc_libjson_json_node_func_02(void) +{ + JsonNode *node = json_node_new (JSON_NODE_VALUE); + JsonNode *copy; + + json_node_set_string (node, "hello"); + + copy = json_node_copy (node); + dts_check_eq ("json_node_copy_value", json_node_get_node_type (node), json_node_get_node_type (copy)); + dts_check_str_eq ("json_node_copy_value", json_node_type_name (node), json_node_type_name (copy)); + dts_check_str_eq ("json_node_copy_value", json_node_get_string (node), json_node_get_string (copy)); + + json_node_free (copy); + json_node_free (node); +} + +static void utc_libjson_json_node_func_03(void) +{ + JsonObject *obj = json_object_new (); + JsonNode *node = json_node_new (JSON_NODE_OBJECT); + JsonNode *value = json_node_new (JSON_NODE_VALUE); + JsonNode *copy; + + json_node_set_int (value, 42); + json_object_set_member (obj, "answer", value); + + json_node_take_object (node, obj); + + copy = json_node_copy (node); + + dts_check_eq ("json_node_copy_object", json_node_get_node_type (node), json_node_get_node_type (copy)); + dts_check_eq ("json_node_copy_object", json_node_get_object (node), json_node_get_object (copy)); + + json_node_free (copy); + json_node_free (node); + +} + + +static void utc_libjson_json_node_func_04(void) +{ + JsonNode *node = json_node_new (JSON_NODE_NULL); + + g_assert (JSON_NODE_HOLDS_NULL (node)); + dts_check_eq ("json_node_null", json_node_get_value_type (node), G_TYPE_INVALID); + dts_check_str_eq ("json_node_null", json_node_type_name (node), "NULL"); + + json_node_free (node); +} + +static void utc_libjson_json_node_func_05(void) +{ + JsonNode *node = json_node_new (JSON_NODE_VALUE); + GValue value = { 0, }; + GValue check = { 0, }; + + dts_check_eq ("json_node_value", JSON_NODE_TYPE (node), JSON_NODE_VALUE); + + g_value_init (&value, G_TYPE_INT64); + g_value_set_int64 (&value, 42); + + dts_check_eq ("json_node_value", G_VALUE_TYPE (&value), G_TYPE_INT64); + dts_check_eq ("json_node_value", g_value_get_int64 (&value), 42); + + json_node_set_value (node, &value); + json_node_get_value (node, &check); + + dts_check_eq ("json_node_value", G_VALUE_TYPE (&value), G_VALUE_TYPE (&check)); + dts_check_eq ("json_node_value", g_value_get_int64 (&value), g_value_get_int64 (&check)); + dts_check_eq ("json_node_value", G_VALUE_TYPE (&check), G_TYPE_INT64); + dts_check_eq ("json_node_value", g_value_get_int64 (&check), 42); + + g_value_unset (&value); + g_value_unset (&check); + json_node_free (node); + +} + +static void utc_libjson_json_node_func_06(void) +{ + JsonNode *root = json_node_new (JSON_NODE_OBJECT); + JsonNode *node = json_node_new (JSON_NODE_OBJECT); + JsonObject * object = NULL; + JsonObject * ret_object = NULL; + + json_node_set_parent(node, root); + dts_check_eq("json_node_object", json_node_get_parent(node), root); + + object = json_object_new(); + json_object_set_int_member(object, "foo", 12); + + json_node_set_object(node, object); + ret_object = json_node_get_object(node); + dts_check_ne("json_node_object", ret_object, NULL); + dts_check_eq("json_node_object", json_object_get_int_member(ret_object, "foo"), 12); + + json_node_dup_object(node); + dts_check_eq("json_node_object", json_object_get_int_member(ret_object, "foo"), 12); + + json_object_unref(object); //for json_node_set_object + json_object_unref(object); //for json_node_dup_object + + json_node_free(node); + json_node_free(root); +} + +static void utc_libjson_json_node_func_07(void) +{ + JsonNode *node = json_node_new (JSON_NODE_ARRAY); + JsonArray* array = NULL; + JsonArray * ret_array = NULL; + + array = json_array_new(); + json_array_add_int_element(array, 12); + + json_node_set_array(node, array); + ret_array = json_node_get_array(node); + dts_check_ne("json_node_array", ret_array, NULL); + dts_check_eq("json_node_array", json_array_get_int_element(ret_array, 0), 12); + + json_node_take_array(node, array); + ret_array = json_node_get_array(node); + dts_check_eq("json_node_array", json_array_get_int_element(ret_array, 0), 12); + + json_node_dup_array(node); + ret_array = json_node_get_array(node); + dts_check_eq("json_node_array", json_array_get_int_element(ret_array, 0), 12); + + json_array_unref(array); //for json_node_set_array + json_array_unref(array); //for json_node_dup_array + + json_node_free(node); +} + +static void utc_libjson_json_node_func_08(void) +{ + JsonNode *node = json_node_new (JSON_NODE_VALUE); + char* value = NULL; + + json_node_set_string(node, "foo"); + dts_check_str_eq("json_node_string", json_node_get_string(node), "foo"); + + value = json_node_dup_string(node); + dts_check_str_eq("json_node_string", json_node_get_string(node), "foo"); + + json_node_free(node); +} + +static void utc_libjson_json_node_func_09(void) +{ + JsonNode *node = json_node_new (JSON_NODE_VALUE); + + json_node_set_double(node, 2.3); + dts_check_eq("json_node_double", json_node_get_double(node), 2.3); + + json_node_free(node); +} + +static void utc_libjson_json_node_func_10(void) +{ + JsonNode *node = json_node_new (JSON_NODE_VALUE); + + json_node_set_boolean(node, TRUE); + dts_check_eq("json_node_boolean", json_node_get_boolean(node), TRUE); + + json_node_free(node); +} + + +static void utc_libjson_json_node_func_11(void) +{ + JsonNode *node = NULL; + + //GObject *obj = NULL; + //obj = g_object_new(JSON_TYPE_NODE, "bar", TRUE, NULL); + //dts_check_eq("json_node_get_type", TEST_IS_JSONNODE(obj), TRUE); + //g_object_unref (obj); + + dts_check_eq("json_node_is_null", json_node_is_null(node), TRUE); + + node = json_node_new (JSON_NODE_OBJECT); + dts_check_eq("json_node_is_null", json_node_is_null(node), FALSE); + + json_node_free(node); +} + + diff --git a/TC/unit/TC_Types/utc_libjson_json_object_func.c b/TC/unit/TC_Types/utc_libjson_json_object_func.c new file mode 100755 index 0000000..a7dbf57 --- /dev/null +++ b/TC/unit/TC_Types/utc_libjson_json_object_func.c @@ -0,0 +1,226 @@ +#include +#include +#include +#include +#include +#include + +#include + + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_libjson_json_object_func_01(void); +static void utc_libjson_json_object_func_02(void); +static void utc_libjson_json_object_func_03(void); +static void utc_libjson_json_object_func_04(void); +static void utc_libjson_json_object_func_05(void); +static void utc_libjson_json_object_func_06(void); +static void utc_libjson_json_object_func_07(void); + + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_libjson_json_object_func_01, POSITIVE_TC_IDX }, + { utc_libjson_json_object_func_02, POSITIVE_TC_IDX }, + { utc_libjson_json_object_func_03, POSITIVE_TC_IDX }, + { utc_libjson_json_object_func_04, POSITIVE_TC_IDX }, + { utc_libjson_json_object_func_05, POSITIVE_TC_IDX }, + { utc_libjson_json_object_func_06, POSITIVE_TC_IDX }, + { utc_libjson_json_object_func_07, POSITIVE_TC_IDX }, + { NULL, 0 } +}; + +typedef struct _TestForeachFixture +{ + gint n_members; +}TestForeachFixture; + +static const struct { + const gchar *member_name; + JsonNodeType member_type; + GType member_gtype; +}type_verify[] = { + { "integer", JSON_NODE_VALUE, G_TYPE_INT64 }, + { "boolean", JSON_NODE_VALUE, G_TYPE_BOOLEAN }, + { "string", JSON_NODE_VALUE, G_TYPE_STRING }, + { "null", JSON_NODE_NULL, G_TYPE_INVALID } +}; + +static void startup(void) +{ + g_type_init(); +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of json_object() + */ +static void utc_libjson_json_object_func_01(void) +{ + JsonObject *object = json_object_new (); + + dts_check_eq ("json_object_empty", json_object_get_size (object), 0); + dts_check_eq ("json_object_empty", json_object_get_members (object), NULL); + + json_object_unref (object); +} + +/** + * @brief Negative test case of ug_init json_object() + */ +static void utc_libjson_json_object_func_02(void) +{ + JsonObject *object = json_object_new (); + JsonNode *node = json_node_new (JSON_NODE_NULL); + JsonNode *dup_node = NULL; + + dts_check_eq ("json_object_add_member", json_object_get_size (object), 0); + + json_object_set_member (object, "Null", node); + dts_check_eq ("json_object_add_member", json_object_get_size (object), 1); + + dup_node = json_object_dup_member(object, "Null"); + dts_check_eq ("json_object_add_member", JSON_NODE_TYPE (dup_node), JSON_NODE_NULL); + + node = json_object_get_member (object, "Null"); + dts_check_eq ("json_object_add_member", JSON_NODE_TYPE (node), JSON_NODE_NULL); + + json_object_unref (object); +} + +static void utc_libjson_json_object_func_03(void) +{ + JsonObject *object = json_object_new (); + JsonNode *node = json_node_new (JSON_NODE_NULL); + + json_object_set_member (object, "Null", node); + + json_object_remove_member (object, "Null"); + dts_check_eq ("json_object_remove_member", json_object_get_size (object), 0); + + json_object_unref (object); +} + +static void +verify_foreach (JsonObject *object, + const gchar *member_name, + JsonNode *member_node, + gpointer user_data) +{ + TestForeachFixture *fixture = user_data; + gint i = 0; + + for (i = 0; i < G_N_ELEMENTS (type_verify); i++) + { + if (strcmp (member_name, type_verify[i].member_name) == 0) + { + dts_check_eq ("json_object_foreach_member", json_node_get_node_type (member_node), type_verify[i].member_type); + dts_check_eq ("json_object_foreach_member", json_node_get_value_type (member_node), type_verify[i].member_gtype); + break; + } + } + + fixture->n_members += 1; +} + +static void utc_libjson_json_object_func_04(void) +{ + JsonObject *object = json_object_new (); + TestForeachFixture fixture = { 0, }; + + json_object_set_int_member (object, "integer", 42); + json_object_set_boolean_member (object, "boolean", TRUE); + json_object_set_string_member (object, "string", "hello"); + json_object_set_null_member (object, "null"); + + json_object_foreach_member (object, verify_foreach, &fixture); + + dts_check_eq ("json_object_foreach_member", fixture.n_members, json_object_get_size (object)); + + json_object_unref (object); + +} + +static void utc_libjson_json_object_func_05(void) +{ + JsonObject *object = json_object_new (); + + json_object_set_string_member (object, "string", ""); + dts_check_eq ("json_object_empty_member", json_object_has_member (object, "string"), TRUE); + dts_check_str_eq ("json_object_empty_member", json_object_get_string_member (object, "string"), ""); + + json_object_unref (object); +} + +static void utc_libjson_json_object_func_06(void) +{ + JsonObject *object = json_object_new (); + JsonObject *ret_object = NULL; + + ret_object = json_object_ref(object); + + json_object_unref (object); // for ref + json_object_unref (object); // for new + + dts_check_eq ("json_object_ref", ret_object, object); +} + +static void utc_libjson_json_object_func_07(void) +{ + JsonObject *object = NULL; + JsonArray* array = NULL; + JsonObject * object_member = NULL; + JsonArray* ret_array = NULL; + JsonObject * ret_object_member = NULL; + + object = json_object_new (); + + dts_check_eq ("json_object_int_member_get_set", json_object_get_values(object), NULL); + + json_object_set_int_member (object, "Int", 42); + json_object_set_double_member(object, "Double", 25.6); + json_object_set_boolean_member (object, "Bool1", TRUE); + json_object_set_string_member (object, "String", "foo"); + json_object_set_null_member (object, "Null"); + + array = json_array_new(); + json_array_add_int_element(array, 12); + json_object_set_array_member(object, "Array", array); + + object_member = json_object_new(); + json_object_set_int_member(object_member, "foo", 89); + json_object_set_object_member(object, "Object", object_member); + + dts_check_eq ("json_object_int_member_get_set", json_object_get_int_member (object, "Int"), 42); + dts_check_eq ("json_object_double_member_get_set", json_object_get_double_member (object, "Double"), 25.6); + dts_check_eq ("json_object_boolean_member_get_set", json_object_get_boolean_member (object, "Bool1"), TRUE); + dts_check_str_eq ("json_object_string_member_get_set", json_object_get_string_member (object, "String"),"foo"); + dts_check_eq ("json_object_null_member_get_set", json_object_get_null_member (object, "Null"), TRUE); + + ret_array = json_object_get_array_member (object, "Array"); + dts_check_eq ("json_object_null_member_get_set", json_array_get_int_element(ret_array, 0), 12); + + ret_object_member = json_object_get_object_member (object, "Object"); + dts_check_eq ("json_object_null_member_get_set", json_object_get_int_member (ret_object_member, "foo"), 89); + + dts_check_ne ("json_object_int_member_get_set", json_object_get_values(object), NULL); + + json_object_unref(object_member); + json_array_unref(array); + json_object_unref(object); +} + + + diff --git a/TC/unit/tc_gen.sh b/TC/unit/tc_gen.sh new file mode 100755 index 0000000..54f482d --- /dev/null +++ b/TC/unit/tc_gen.sh @@ -0,0 +1,28 @@ +#!/bin/sh + +TMPSTR=$0 +SCRIPT=${TMPSTR##*/} + +if [ $# -lt 2 ]; then + echo "Usage) $SCRIPT module_name api_name" + exit 1 +fi + +MODULE=$1 +API=$2 +TEMPLATE=utc_MODULE_API_func.c.in +TESTCASE=utc_${MODULE}_${API}_func + +sed -e ' + s^@API@^'"$API"'^g + s^@MODULE@^'"$MODULE"'^g + ' $TEMPLATE > $TESTCASE.c + +if [ ! -e "$TESTCASE.c" ]; then + echo "Failed" + exit 1 +fi +echo "Testcase file is $TESTCASE.c" +echo "Done" +echo "please put \"$TESTCASE\" as Target in Makefile" +echo "please put \"/unit/$TESTCASE\" in tslist" diff --git a/TC/unit/utc_MODULE_API_func.c.in b/TC/unit/utc_MODULE_API_func.c.in new file mode 100755 index 0000000..5edf1b7 --- /dev/null +++ b/TC/unit/utc_MODULE_API_func.c.in @@ -0,0 +1,67 @@ +#include +#include "pkgname.h" + +static void startup(void); +static void cleanup(void); + +void (*tet_startup)(void) = startup; +void (*tet_cleanup)(void) = cleanup; + +static void utc_@MODULE@_@API@_func_01(void); +static void utc_@MODULE@_@API@_func_02(void); + +enum { + POSITIVE_TC_IDX = 0x01, + NEGATIVE_TC_IDX, +}; + +struct tet_testlist tet_testlist[] = { + { utc_@MODULE@_@API@_func_01, POSITIVE_TC_IDX }, + { utc_@MODULE@_@API@_func_02, NEGATIVE_TC_IDX }, +}; + +static int pid; + +static void startup(void) +{ +} + +static void cleanup(void) +{ +} + +/** + * @brief Positive test case of @API@() + */ +static void utc_@MODULE@_@API@_func_01(void) +{ + int r = 0; + char buf[MAX_LOCAL_BUFSZ]; + + r = @API@(...); + + if (r<0) { + tet_infoline("@API@() failed in positive test case"); + tet_result(TET_FAIL); + return; + } + tet_result(TET_PASS); +} + +/** + * @brief Negative test case of ug_init @API@() + */ +static void utc_@MODULE@_@API@_func_02(void) +{ + int r = 0; + char buf[MAX_LOCAL_BUFSZ]; + + r = @API@(...); + + if (r>=0) { + tet_infoline("@API@() failed in negative test case"); + tet_result(TET_FAIL); + return; + } + tet_result(TET_PASS); +} diff --git a/aclocal.m4 b/aclocal.m4 index ccc9417..693d466 100644 --- a/aclocal.m4 +++ b/aclocal.m4 @@ -112,14 +112,14 @@ dnl int main () { - unsigned int major, minor, micro; + int major, minor, micro; char *tmp_version; fclose (fopen ("conf.glibtest", "w")); /* HP/UX 9 (%@#!) writes to sscanf strings */ tmp_version = g_strdup("$min_glib_version"); - if (sscanf(tmp_version, "%u.%u.%u", &major, &minor, µ) != 3) { + if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) { printf("%s, bad version string\n", "$min_glib_version"); exit(1); } @@ -158,9 +158,9 @@ main () } else { - printf("\n*** An old version of GLIB (%u.%u.%u) was found.\n", + printf("\n*** An old version of GLIB (%d.%d.%d) was found.\n", glib_major_version, glib_minor_version, glib_micro_version); - printf("*** You need a version of GLIB newer than %u.%u.%u. The latest version of\n", + printf("*** You need a version of GLIB newer than %d.%d.%d. The latest version of\n", major, minor, micro); printf("*** GLIB is always available from ftp://ftp.gtk.org.\n"); printf("***\n"); @@ -368,7 +368,7 @@ $$1_PKG_ERRORS Consider adjusting the PKG_CONFIG_PATH environment variable if you installed software in a non-standard prefix. -_PKG_TEXT])[]dnl +_PKG_TEXT])dnl ]) elif test $pkg_failed = untried; then AC_MSG_RESULT([no]) @@ -379,7 +379,7 @@ path to pkg-config. _PKG_TEXT -To get pkg-config, see .])[]dnl +To get pkg-config, see .])dnl ]) else $1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS diff --git a/config.guess b/config.guess index 40eaed4..c2246a4 100755 --- a/config.guess +++ b/config.guess @@ -1,10 +1,10 @@ #! /bin/sh # Attempt to guess a canonical system name. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, -# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, -# 2011 Free Software Foundation, Inc. +# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +# Free Software Foundation, Inc. -timestamp='2011-05-11' +timestamp='2009-12-30' # This file is free software; you can redistribute it and/or modify it # under the terms of the GNU General Public License as published by @@ -57,7 +57,7 @@ GNU config.guess ($timestamp) Originally written by Per Bothner. Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, -2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free +2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO @@ -181,7 +181,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in fi ;; *) - os=netbsd + os=netbsd ;; esac # The OS release @@ -224,7 +224,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ;; *5.*) - UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` + UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ;; esac # According to Compaq, /usr/sbin/psrinfo has been available on @@ -270,10 +270,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in # A Xn.n version is an unreleased experimental baselevel. # 1.2 uses "1.2" for uname -r. echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^[PVTX]//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` - # Reset EXIT trap before exiting to avoid spurious non-zero exit code. - exitcode=$? - trap '' 0 - exit $exitcode ;; + exit ;; Alpha\ *:Windows_NT*:*) # How do we know it's Interix rather than the generic POSIX subsystem? # Should we change UNAME_MACHINE based on the output of uname instead @@ -299,7 +296,7 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in echo s390-ibm-zvmoe exit ;; *:OS400:*:*) - echo powerpc-ibm-os400 + echo powerpc-ibm-os400 exit ;; arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) echo arm-acorn-riscix${UNAME_RELEASE} @@ -398,23 +395,23 @@ case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in # MiNT. But MiNT is downward compatible to TOS, so this should # be no problem. atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) - echo m68k-atari-mint${UNAME_RELEASE} + echo m68k-atari-mint${UNAME_RELEASE} exit ;; atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) echo m68k-atari-mint${UNAME_RELEASE} - exit ;; + exit ;; *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) - echo m68k-atari-mint${UNAME_RELEASE} + echo m68k-atari-mint${UNAME_RELEASE} exit ;; milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) - echo m68k-milan-mint${UNAME_RELEASE} - exit ;; + echo m68k-milan-mint${UNAME_RELEASE} + exit ;; hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) - echo m68k-hades-mint${UNAME_RELEASE} - exit ;; + echo m68k-hades-mint${UNAME_RELEASE} + exit ;; *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) - echo m68k-unknown-mint${UNAME_RELEASE} - exit ;; + echo m68k-unknown-mint${UNAME_RELEASE} + exit ;; m68k:machten:*:*) echo m68k-apple-machten${UNAME_RELEASE} exit ;; @@ -484,8 +481,8 @@ EOF echo m88k-motorola-sysv3 exit ;; AViiON:dgux:*:*) - # DG/UX returns AViiON for all architectures - UNAME_PROCESSOR=`/usr/bin/uname -p` + # DG/UX returns AViiON for all architectures + UNAME_PROCESSOR=`/usr/bin/uname -p` if [ $UNAME_PROCESSOR = mc88100 ] || [ $UNAME_PROCESSOR = mc88110 ] then if [ ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx ] || \ @@ -498,7 +495,7 @@ EOF else echo i586-dg-dgux${UNAME_RELEASE} fi - exit ;; + exit ;; M88*:DolphinOS:*:*) # DolphinOS (SVR3) echo m88k-dolphin-sysv3 exit ;; @@ -555,7 +552,7 @@ EOF echo rs6000-ibm-aix3.2 fi exit ;; - *:AIX:*:[4567]) + *:AIX:*:[456]) IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then IBM_ARCH=rs6000 @@ -598,52 +595,52 @@ EOF 9000/[678][0-9][0-9]) if [ -x /usr/bin/getconf ]; then sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` - sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` - case "${sc_cpu_version}" in - 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 - 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 - 532) # CPU_PA_RISC2_0 - case "${sc_kernel_bits}" in - 32) HP_ARCH="hppa2.0n" ;; - 64) HP_ARCH="hppa2.0w" ;; + sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` + case "${sc_cpu_version}" in + 523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0 + 528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1 + 532) # CPU_PA_RISC2_0 + case "${sc_kernel_bits}" in + 32) HP_ARCH="hppa2.0n" ;; + 64) HP_ARCH="hppa2.0w" ;; '') HP_ARCH="hppa2.0" ;; # HP-UX 10.20 - esac ;; - esac + esac ;; + esac fi if [ "${HP_ARCH}" = "" ]; then eval $set_cc_for_build - sed 's/^ //' << EOF >$dummy.c + sed 's/^ //' << EOF >$dummy.c - #define _HPUX_SOURCE - #include - #include + #define _HPUX_SOURCE + #include + #include - int main () - { - #if defined(_SC_KERNEL_BITS) - long bits = sysconf(_SC_KERNEL_BITS); - #endif - long cpu = sysconf (_SC_CPU_VERSION); + int main () + { + #if defined(_SC_KERNEL_BITS) + long bits = sysconf(_SC_KERNEL_BITS); + #endif + long cpu = sysconf (_SC_CPU_VERSION); - switch (cpu) - { - case CPU_PA_RISC1_0: puts ("hppa1.0"); break; - case CPU_PA_RISC1_1: puts ("hppa1.1"); break; - case CPU_PA_RISC2_0: - #if defined(_SC_KERNEL_BITS) - switch (bits) - { - case 64: puts ("hppa2.0w"); break; - case 32: puts ("hppa2.0n"); break; - default: puts ("hppa2.0"); break; - } break; - #else /* !defined(_SC_KERNEL_BITS) */ - puts ("hppa2.0"); break; - #endif - default: puts ("hppa1.0"); break; - } - exit (0); - } + switch (cpu) + { + case CPU_PA_RISC1_0: puts ("hppa1.0"); break; + case CPU_PA_RISC1_1: puts ("hppa1.1"); break; + case CPU_PA_RISC2_0: + #if defined(_SC_KERNEL_BITS) + switch (bits) + { + case 64: puts ("hppa2.0w"); break; + case 32: puts ("hppa2.0n"); break; + default: puts ("hppa2.0"); break; + } break; + #else /* !defined(_SC_KERNEL_BITS) */ + puts ("hppa2.0"); break; + #endif + default: puts ("hppa1.0"); break; + } + exit (0); + } EOF (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy` test -z "$HP_ARCH" && HP_ARCH=hppa @@ -734,22 +731,22 @@ EOF exit ;; C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) echo c1-convex-bsd - exit ;; + exit ;; C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) if getsysinfo -f scalar_acc then echo c32-convex-bsd else echo c2-convex-bsd fi - exit ;; + exit ;; C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) echo c34-convex-bsd - exit ;; + exit ;; C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) echo c38-convex-bsd - exit ;; + exit ;; C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) echo c4-convex-bsd - exit ;; + exit ;; CRAY*Y-MP:*:*:*) echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.[^.]*$/.X/' exit ;; @@ -773,14 +770,14 @@ EOF exit ;; F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'` - FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` - FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` - echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" - exit ;; + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'` + echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + exit ;; 5000:UNIX_System_V:4.*:*) - FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` - FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` - echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" + FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'` + FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'` + echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" exit ;; i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE} @@ -808,14 +805,14 @@ EOF echo ${UNAME_MACHINE}-pc-mingw32 exit ;; i*:windows32*:*) - # uname -m includes "-pc" on this system. - echo ${UNAME_MACHINE}-mingw32 + # uname -m includes "-pc" on this system. + echo ${UNAME_MACHINE}-mingw32 exit ;; i*:PW*:*) echo ${UNAME_MACHINE}-pc-pw32 exit ;; *:Interix*:*) - case ${UNAME_MACHINE} in + case ${UNAME_MACHINE} in x86) echo i586-pc-interix${UNAME_RELEASE} exit ;; @@ -870,7 +867,7 @@ EOF EV6) UNAME_MACHINE=alphaev6 ;; EV67) UNAME_MACHINE=alphaev67 ;; EV68*) UNAME_MACHINE=alphaev68 ;; - esac + esac objdump --private-headers /bin/sh | grep -q ld.so.1 if test "$?" = 0 ; then LIBC="libc1" ; else LIBC="" ; fi echo ${UNAME_MACHINE}-unknown-linux-gnu${LIBC} @@ -882,13 +879,7 @@ EOF then echo ${UNAME_MACHINE}-unknown-linux-gnu else - if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ - | grep -q __ARM_PCS_VFP - then - echo ${UNAME_MACHINE}-unknown-linux-gnueabi - else - echo ${UNAME_MACHINE}-unknown-linux-gnueabihf - fi + echo ${UNAME_MACHINE}-unknown-linux-gnueabi fi exit ;; avr32*:Linux:*:*) @@ -901,7 +892,7 @@ EOF echo crisv32-axis-linux-gnu exit ;; frv:Linux:*:*) - echo frv-unknown-linux-gnu + echo frv-unknown-linux-gnu exit ;; i*86:Linux:*:*) LIBC=gnu @@ -969,7 +960,7 @@ EOF echo ${UNAME_MACHINE}-ibm-linux exit ;; sh64*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu + echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; sh*:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu @@ -977,9 +968,6 @@ EOF sparc:Linux:*:* | sparc64:Linux:*:*) echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; - tile*:Linux:*:*) - echo ${UNAME_MACHINE}-tilera-linux-gnu - exit ;; vax:Linux:*:*) echo ${UNAME_MACHINE}-dec-linux-gnu exit ;; @@ -987,7 +975,7 @@ EOF echo x86_64-unknown-linux-gnu exit ;; xtensa*:Linux:*:*) - echo ${UNAME_MACHINE}-unknown-linux-gnu + echo ${UNAME_MACHINE}-unknown-linux-gnu exit ;; i*86:DYNIX/ptx:4*:*) # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. @@ -996,11 +984,11 @@ EOF echo i386-sequent-sysv4 exit ;; i*86:UNIX_SV:4.2MP:2.*) - # Unixware is an offshoot of SVR4, but it has its own version - # number series starting with 2... - # I am not positive that other SVR4 systems won't match this, + # Unixware is an offshoot of SVR4, but it has its own version + # number series starting with 2... + # I am not positive that other SVR4 systems won't match this, # I just have to hope. -- rms. - # Use sysv4.2uw... so that sysv4* matches it. + # Use sysv4.2uw... so that sysv4* matches it. echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION} exit ;; i*86:OS/2:*:*) @@ -1032,7 +1020,7 @@ EOF fi exit ;; i*86:*:5:[678]*) - # UnixWare 7.x, OpenUNIX and OpenServer 6. + # UnixWare 7.x, OpenUNIX and OpenServer 6. case `/bin/uname -X | grep "^Machine"` in *486*) UNAME_MACHINE=i486 ;; *Pentium) UNAME_MACHINE=i586 ;; @@ -1060,13 +1048,13 @@ EOF exit ;; pc:*:*:*) # Left here for compatibility: - # uname -m prints for DJGPP always 'pc', but it prints nothing about - # the processor, so we play safe by assuming i586. + # uname -m prints for DJGPP always 'pc', but it prints nothing about + # the processor, so we play safe by assuming i586. # Note: whatever this is, it MUST be the same as what config.sub # prints for the "djgpp" host, or else GDB configury will decide that # this is a cross-build. echo i586-pc-msdosdjgpp - exit ;; + exit ;; Intel:Mach:3*:*) echo i386-pc-mach3 exit ;; @@ -1101,8 +1089,8 @@ EOF /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;; 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) - /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ - && { echo i486-ncr-sysv4; exit; } ;; + /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ + && { echo i486-ncr-sysv4; exit; } ;; NCR*:*:4.2:* | MPRAS*:*:4.2:*) OS_REL='.3' test -r /etc/.relid \ @@ -1145,10 +1133,10 @@ EOF echo ns32k-sni-sysv fi exit ;; - PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort - # says - echo i586-unisys-sysv4 - exit ;; + PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort + # says + echo i586-unisys-sysv4 + exit ;; *:UNIX_System_V:4*:FTX*) # From Gerald Hewes . # How about differentiating between stratus architectures? -djm @@ -1174,11 +1162,11 @@ EOF exit ;; R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) if [ -d /usr/nec ]; then - echo mips-nec-sysv${UNAME_RELEASE} + echo mips-nec-sysv${UNAME_RELEASE} else - echo mips-unknown-sysv${UNAME_RELEASE} + echo mips-unknown-sysv${UNAME_RELEASE} fi - exit ;; + exit ;; BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. echo powerpc-be-beos exit ;; @@ -1243,9 +1231,6 @@ EOF *:QNX:*:4*) echo i386-pc-qnx exit ;; - NEO-?:NONSTOP_KERNEL:*:*) - echo neo-tandem-nsk${UNAME_RELEASE} - exit ;; NSE-?:NONSTOP_KERNEL:*:*) echo nse-tandem-nsk${UNAME_RELEASE} exit ;; @@ -1291,13 +1276,13 @@ EOF echo pdp10-unknown-its exit ;; SEI:*:*:SEIUX) - echo mips-sei-seiux${UNAME_RELEASE} + echo mips-sei-seiux${UNAME_RELEASE} exit ;; *:DragonFly:*:*) echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/[-(].*//'` exit ;; *:*VMS:*:*) - UNAME_MACHINE=`(uname -p) 2>/dev/null` + UNAME_MACHINE=`(uname -p) 2>/dev/null` case "${UNAME_MACHINE}" in A*) echo alpha-dec-vms ; exit ;; I*) echo ia64-dec-vms ; exit ;; @@ -1337,11 +1322,11 @@ main () #include printf ("m68k-sony-newsos%s\n", #ifdef NEWSOS4 - "4" + "4" #else - "" + "" #endif - ); exit (0); + ); exit (0); #endif #endif diff --git a/config.sub b/config.sub index 30fdca8..c2d1257 100755 --- a/config.sub +++ b/config.sub @@ -1,10 +1,10 @@ #! /bin/sh # Configuration validation subroutine script. # Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, -# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, -# 2011 Free Software Foundation, Inc. +# 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 +# Free Software Foundation, Inc. -timestamp='2011-03-23' +timestamp='2010-01-22' # This file is (in principle) common to ALL GNU software. # The presence of a machine in this file suggests that SOME GNU software @@ -76,7 +76,7 @@ version="\ GNU config.sub ($timestamp) Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, -2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free +2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO @@ -124,9 +124,8 @@ esac # Here we must recognize all the valid KERNEL-OS combinations. maybe_os=`echo $1 | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` case $maybe_os in - nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ - linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ - knetbsd*-gnu* | netbsd*-gnu* | \ + nto-qnx* | linux-gnu* | linux-dietlibc | linux-newlib* | linux-uclibc* | \ + uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | knetbsd*-gnu* | netbsd*-gnu* | \ kopensolaris*-gnu* | \ storm-chaos* | os2-emx* | rtmk-nova*) os=-$maybe_os @@ -158,8 +157,8 @@ case $os in os= basic_machine=$1 ;; - -bluegene*) - os=-cnk + -bluegene*) + os=-cnk ;; -sim | -cisco | -oki | -wec | -winbond) os= @@ -175,10 +174,10 @@ case $os in os=-chorusos basic_machine=$1 ;; - -chorusrdb) - os=-chorusrdb + -chorusrdb) + os=-chorusrdb basic_machine=$1 - ;; + ;; -hiux*) os=-hiuxwe2 ;; @@ -283,13 +282,11 @@ case $basic_machine in | moxie \ | mt \ | msp430 \ - | nds32 | nds32le | nds32be \ | nios | nios2 \ | ns16k | ns32k \ - | open8 \ | or32 \ | pdp10 | pdp11 | pj | pjl \ - | powerpc | powerpc64 | powerpc64le | powerpcle \ + | powerpc | powerpc64 | powerpc64le | powerpcle | ppcbe \ | pyramid \ | rx \ | score \ @@ -297,24 +294,15 @@ case $basic_machine in | sh64 | sh64le \ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ - | spu \ - | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ + | spu | strongarm \ + | tahoe | thumb | tic4x | tic80 | tron \ | ubicom32 \ | v850 | v850e \ | we32k \ - | x86 | xc16x | xstormy16 | xtensa \ + | x86 | xc16x | xscale | xscalee[bl] | xstormy16 | xtensa \ | z8k | z80) basic_machine=$basic_machine-unknown ;; - c54x) - basic_machine=tic54x-unknown - ;; - c55x) - basic_machine=tic55x-unknown - ;; - c6x) - basic_machine=tic6x-unknown - ;; m6811 | m68hc11 | m6812 | m68hc12 | picochip) # Motorola 68HC11/12. basic_machine=$basic_machine-unknown @@ -326,18 +314,6 @@ case $basic_machine in basic_machine=mt-unknown ;; - strongarm | thumb | xscale) - basic_machine=arm-unknown - ;; - - xscaleeb) - basic_machine=armeb-unknown - ;; - - xscaleel) - basic_machine=armel-unknown - ;; - # We use `pc' rather than `unknown' # because (1) that's what they normally are, and # (2) the word "unknown" tends to confuse beginning users. @@ -358,7 +334,7 @@ case $basic_machine in | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ | avr-* | avr32-* \ | bfin-* | bs2000-* \ - | c[123]* | c30-* | [cjt]90-* | c4x-* \ + | c[123]* | c30-* | [cjt]90-* | c4x-* | c54x-* | c55x-* | c6x-* \ | clipper-* | craynv-* | cydra-* \ | d10v-* | d30v-* | dlx-* \ | elxsi-* \ @@ -392,28 +368,26 @@ case $basic_machine in | mmix-* \ | mt-* \ | msp430-* \ - | nds32-* | nds32le-* | nds32be-* \ | nios-* | nios2-* \ | none-* | np1-* | ns16k-* | ns32k-* \ - | open8-* \ | orion-* \ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ - | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ + | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* | ppcbe-* \ | pyramid-* \ | romp-* | rs6000-* | rx-* \ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ | sparclite-* \ - | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx?-* \ - | tahoe-* \ + | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | strongarm-* | sv1-* | sx?-* \ + | tahoe-* | thumb-* \ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ | tile-* | tilegx-* \ | tron-* \ | ubicom32-* \ | v850-* | v850e-* | vax-* \ | we32k-* \ - | x86-* | x86_64-* | xc16x-* | xps100-* \ + | x86-* | x86_64-* | xc16x-* | xps100-* | xscale-* | xscalee[bl]-* \ | xstormy16-* | xtensa*-* \ | ymp-* \ | z8k-* | z80-*) @@ -438,7 +412,7 @@ case $basic_machine in basic_machine=a29k-amd os=-udi ;; - abacus) + abacus) basic_machine=abacus-unknown ;; adobe68k) @@ -508,20 +482,11 @@ case $basic_machine in basic_machine=powerpc-ibm os=-cnk ;; - c54x-*) - basic_machine=tic54x-`echo $basic_machine | sed 's/^[^-]*-//'` - ;; - c55x-*) - basic_machine=tic55x-`echo $basic_machine | sed 's/^[^-]*-//'` - ;; - c6x-*) - basic_machine=tic6x-`echo $basic_machine | sed 's/^[^-]*-//'` - ;; c90) basic_machine=c90-cray os=-unicos ;; - cegcc) + cegcc) basic_machine=arm-unknown os=-cegcc ;; @@ -553,7 +518,7 @@ case $basic_machine in basic_machine=craynv-cray os=-unicosmp ;; - cr16 | cr16-*) + cr16) basic_machine=cr16-unknown os=-elf ;; @@ -769,7 +734,7 @@ case $basic_machine in basic_machine=ns32k-utek os=-sysv ;; - microblaze) + microblaze) basic_machine=microblaze-xilinx ;; mingw32) @@ -876,12 +841,6 @@ case $basic_machine in np1) basic_machine=np1-gould ;; - neo-tandem) - basic_machine=neo-tandem - ;; - nse-tandem) - basic_machine=nse-tandem - ;; nsr-tandem) basic_machine=nsr-tandem ;; @@ -964,10 +923,9 @@ case $basic_machine in ;; power) basic_machine=power-ibm ;; - ppc | ppcbe) basic_machine=powerpc-unknown + ppc) basic_machine=powerpc-unknown ;; - ppc-* | ppcbe-*) - basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` + ppc-*) basic_machine=powerpc-`echo $basic_machine | sed 's/^[^-]*-//'` ;; ppcle | powerpclittle | ppc-le | powerpc-little) basic_machine=powerpcle-unknown @@ -1061,9 +1019,6 @@ case $basic_machine in basic_machine=i860-stratus os=-sysv4 ;; - strongarm-* | thumb-*) - basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'` - ;; sun2) basic_machine=m68000-sun ;; @@ -1120,8 +1075,20 @@ case $basic_machine in basic_machine=t90-cray os=-unicos ;; - # This must be matched before tile*. - tilegx*) + tic54x | c54x*) + basic_machine=tic54x-unknown + os=-coff + ;; + tic55x | c55x*) + basic_machine=tic55x-unknown + os=-coff + ;; + tic6x | c6x*) + basic_machine=tic6x-unknown + os=-coff + ;; + # This must be matched before tile*. + tilegx*) basic_machine=tilegx-unknown os=-linux-gnu ;; @@ -1196,9 +1163,6 @@ case $basic_machine in xps | xps100) basic_machine=xps100-honeywell ;; - xscale-* | xscalee[bl]-*) - basic_machine=`echo $basic_machine | sed 's/^xscale/arm/'` - ;; ymp) basic_machine=ymp-cray os=-unicos @@ -1296,11 +1260,11 @@ esac if [ x"$os" != x"" ] then case $os in - # First match some system type aliases - # that might get confused with valid system types. + # First match some system type aliases + # that might get confused with valid system types. # -solaris* is a basic system type, with this one exception. - -auroraux) - os=-auroraux + -auroraux) + os=-auroraux ;; -solaris1 | -solaris1.*) os=`echo $os | sed -e 's|solaris1|sunos4|'` @@ -1337,8 +1301,7 @@ case $os in | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ | -chorusos* | -chorusrdb* | -cegcc* \ | -cygwin* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ - | -mingw32* | -linux-gnu* | -linux-android* \ - | -linux-newlib* | -linux-uclibc* \ + | -mingw32* | -linux-gnu* | -linux-newlib* | -linux-uclibc* \ | -uxpv* | -beos* | -mpeix* | -udk* \ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* | -opened* \ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ @@ -1385,7 +1348,7 @@ case $os in -opened*) os=-openedition ;; - -os400*) + -os400*) os=-os400 ;; -wince*) @@ -1434,7 +1397,7 @@ case $os in -sinix*) os=-sysv4 ;; - -tpf*) + -tpf*) os=-tpf ;; -triton*) @@ -1479,8 +1442,8 @@ case $os in -dicos*) os=-dicos ;; - -nacl*) - ;; + -nacl*) + ;; -none) ;; *) @@ -1503,10 +1466,10 @@ else # system, and we'll never get to this point. case $basic_machine in - score-*) + score-*) os=-elf ;; - spu-*) + spu-*) os=-elf ;; *-acorn) @@ -1518,17 +1481,8 @@ case $basic_machine in arm*-semi) os=-aout ;; - c4x-* | tic4x-*) - os=-coff - ;; - tic54x-*) - os=-coff - ;; - tic55x-*) - os=-coff - ;; - tic6x-*) - os=-coff + c4x-* | tic4x-*) + os=-coff ;; # This must come before the *-dec entry. pdp10-*) @@ -1555,7 +1509,7 @@ case $basic_machine in m68*-cisco) os=-aout ;; - mep-*) + mep-*) os=-elf ;; mips*-cisco) @@ -1582,7 +1536,7 @@ case $basic_machine in *-ibm) os=-aix ;; - *-knuth) + *-knuth) os=-mmixware ;; *-wec) diff --git a/configure b/configure index ea06da0..00cc4dd 100755 --- a/configure +++ b/configure @@ -4118,14 +4118,14 @@ else int main () { - unsigned int major, minor, micro; + int major, minor, micro; char *tmp_version; fclose (fopen ("conf.glibtest", "w")); /* HP/UX 9 (%@#!) writes to sscanf strings */ tmp_version = g_strdup("$min_glib_version"); - if (sscanf(tmp_version, "%u.%u.%u", &major, &minor, µ) != 3) { + if (sscanf(tmp_version, "%d.%d.%d", &major, &minor, µ) != 3) { printf("%s, bad version string\n", "$min_glib_version"); exit(1); } @@ -4164,9 +4164,9 @@ main () } else { - printf("\n*** An old version of GLIB (%u.%u.%u) was found.\n", + printf("\n*** An old version of GLIB (%d.%d.%d) was found.\n", glib_major_version, glib_minor_version, glib_micro_version); - printf("*** You need a version of GLIB newer than %u.%u.%u. The latest version of\n", + printf("*** You need a version of GLIB newer than %d.%d.%d. The latest version of\n", major, minor, micro); printf("*** GLIB is always available from ftp://ftp.gtk.org.\n"); printf("***\n"); diff --git a/debian/changelog b/debian/changelog index 9aa430c..60b4164 100644 --- a/debian/changelog +++ b/debian/changelog @@ -1,7 +1,49 @@ -libjson-glib (0.10.4-1slp2-1) unstable; urgency=low +libjson-glib (0.0.1-2slp7) unstable; urgency=low - * Initial Release - * Git: pkgs/l/libjson-glib - * Tag: libjson-glib_0.10.4-1slp2-1 + * Release - -- MyoungJune Park Wed, 07 Dec 2011 14:12:11 +0900 + -- MyoungJune Park Tue, 14 Aug 2012 10:41:45 +0900 + +libjson-glib (0.0.1-2slp6) unstable; urgency=low + + * Fix incorrect macro name + * Git: slp/pkgs/libjson-glib + * Tag: libjson-glib_0.0.1-2slp6 + + -- Junghyun Kim Fri, 29 Jun 2012 13:55:08 +0900 + +libjson-glib (0.0.1-2slp5) unstable; urgency=low + + * spec file is updated + * Git: slp/pkgs/libjson-glib + * Tag: libjson-glib_0.0.1-2slp5 + + -- Taeyoung Kim Wed, 14 Mar 2012 17:23:31 +0900 + +libjson-glib (0.0.1-2slp4) unstable; urgency=low + + * Updated for gcc 4.5 + * Git: slp/pkgs/libjson-glib + * Tag: libjson-glib_0.0.1-2slp4 + + -- Mike McCormack Thu, 17 Mar 2011 16:24:28 +0900 + +libjson-glib (0.0.1-2slp3) unstable; urgency=low + + * Modified git tagging + * Git: 165.213.180.234:/git/slp/pkgs/libjson-glib + * Tag: libjson-glib_0.0.1-2slp3 + + -- Karam Ko Fri, 26 Nov 2010 10:59:21 +0900 + +libjson-glib (0.0.1-2slp2) unstable; urgency=low + + * Modified json-glib-1.0.pc + + -- Karam Ko Fri, 04 Jun 2010 18:13:21 +0900 + +libjson-glib (0.0.1-1slp2) unstable; urgency=low + + * un-modified open source package of the libjson-glib + + -- DoHyun Pyun Mon, 03 May 2010 14:12:11 +0900 diff --git a/debian/control b/debian/control index 9ff0b3c..619300a 100644 --- a/debian/control +++ b/debian/control @@ -1,7 +1,7 @@ Source: libjson-glib Section: libs Priority: extra -Maintainer: MyoungJune Park +Maintainer: Moung June Park Uploaders: Mike McCormack Build-Depends: debhelper (>= 5), autotools-dev, libglib2.0-dev (>= 2.21.3), libgnutls-dev Standards-Version: 0.10.4 diff --git a/debian/copyright b/debian/copyright index a8db27b..95371f4 100644 --- a/debian/copyright +++ b/debian/copyright @@ -1,7 +1,5 @@ - -The original source can always be found at: -http://live.gnome.org/JsonGlib - +AUTHOR, COPYRIGHT AND LICENSING +------------------------------------------------------------------------------- JSON-GLib has been written by Emmanuele Bassi JSON-GLib is released under the terms of the GNU Lesser General Public License, diff --git a/json-glib/json-array.c b/json-glib/json-array.c index 5149aad..7f72e87 100644 --- a/json-glib/json-array.c +++ b/json-glib/json-array.c @@ -113,8 +113,11 @@ json_array_ref (JsonArray *array) g_return_val_if_fail (array != NULL, NULL); g_return_val_if_fail (array->ref_count > 0, NULL); +#if !GLIB_CHECK_VERSION(2, 31, 0) g_atomic_int_exchange_and_add (&array->ref_count, 1); - +#else + g_atomic_int_add (&array->ref_count, 1); +#endif return array; } @@ -332,9 +335,15 @@ json_array_get_boolean_element (JsonArray *array, * * Since: 0.8 */ +#if !GLIB_CHECK_VERSION(2, 31, 0) G_CONST_RETURN gchar * json_array_get_string_element (JsonArray *array, guint index_) +#else +const gchar * +json_array_get_string_element (JsonArray *array, + guint index_) +#endif { JsonNode *node; diff --git a/json-glib/json-node.c b/json-glib/json-node.c index 6a79c4c..8d0cf55 100644 --- a/json-glib/json-node.c +++ b/json-glib/json-node.c @@ -462,8 +462,13 @@ json_node_free (JsonNode *node) * Return value: a string containing the name of the type. The returned string * is owned by the node and should never be modified or freed */ +#if !GLIB_CHECK_VERSION(2, 31, 0) G_CONST_RETURN gchar * json_node_type_name (JsonNode *node) +#else +const gchar * +json_node_type_name (JsonNode *node) +#endif { g_return_val_if_fail (node != NULL, "(null)"); @@ -481,8 +486,13 @@ json_node_type_name (JsonNode *node) return "unknown"; } +#if !GLIB_CHECK_VERSION(2, 31, 0) G_CONST_RETURN gchar * json_node_type_get_name (JsonNodeType node_type) +#else +const gchar * +json_node_type_get_name (JsonNodeType node_type) +#endif { switch (node_type) { @@ -578,8 +588,13 @@ json_node_set_string (JsonNode *node, * * Return value: a string value. */ +#if !GLIB_CHECK_VERSION(2, 31, 0) G_CONST_RETURN gchar * json_node_get_string (JsonNode *node) +#else +const gchar * +json_node_get_string (JsonNode *node) +#endif { g_return_val_if_fail (node != NULL, NULL); diff --git a/json-glib/json-object.c b/json-glib/json-object.c index 1490d7b..43ff15b 100644 --- a/json-glib/json-object.c +++ b/json-glib/json-object.c @@ -98,8 +98,11 @@ json_object_ref (JsonObject *object) g_return_val_if_fail (object != NULL, NULL); g_return_val_if_fail (object->ref_count > 0, NULL); +#if !GLIB_CHECK_VERSION(2, 31, 0) g_atomic_int_exchange_and_add (&object->ref_count, 1); - +#else + g_atomic_int_add (&object->ref_count, 1); +#endif return object; } @@ -643,9 +646,15 @@ json_object_get_null_member (JsonObject *object, * * Since: 0.8 */ +#if !GLIB_CHECK_VERSION(2, 31, 0) G_CONST_RETURN gchar * json_object_get_string_member (JsonObject *object, const gchar *member_name) +#else +const gchar * +json_object_get_string_member (JsonObject *object, + const gchar *member_name) +#endif { JsonNode *node; diff --git a/json-glib/json-scanner.h b/json-glib/json-scanner.h index 49d7b1e..cd76ea4 100644 --- a/json-glib/json-scanner.h +++ b/json-glib/json-scanner.h @@ -34,10 +34,13 @@ #ifndef __JSON_SCANNER_H__ #define __JSON_SCANNER_H__ +#if !GLIB_CHECK_VERSION(2, 31, 0) #include #include #include - +#else +#include +#endif G_BEGIN_DECLS typedef struct _JsonScanner JsonScanner; diff --git a/json-glib/json-types-private.h b/json-glib/json-types-private.h index d0e073e..2b708cc 100644 --- a/json-glib/json-types-private.h +++ b/json-glib/json-types-private.h @@ -59,7 +59,11 @@ struct _JsonObject volatile gint ref_count; }; +#if !GLIB_CHECK_VERSION(2, 31, 0) G_CONST_RETURN gchar *json_node_type_get_name (JsonNodeType node_type); +#else +const gchar *json_node_type_get_name (JsonNodeType node_type); +#endif G_END_DECLS diff --git a/json-glib/json-types.h b/json-glib/json-types.h index 5793179..35e276f 100644 --- a/json-glib/json-types.h +++ b/json-glib/json-types.h @@ -173,6 +173,8 @@ typedef void (* JsonArrayForeach) (JsonArray *array, JsonNode *element_node, gpointer user_data); + + /* * JsonNode */ @@ -185,8 +187,11 @@ GType json_node_get_value_type (JsonNode *node); void json_node_set_parent (JsonNode *node, JsonNode *parent); JsonNode * json_node_get_parent (JsonNode *node); +#if !GLIB_CHECK_VERSION(2,31,0) G_CONST_RETURN gchar *json_node_type_name (JsonNode *node); - +#else +const gchar *json_node_type_name (JsonNode *node); +#endif void json_node_set_object (JsonNode *node, JsonObject *object); void json_node_take_object (JsonNode *node, @@ -205,7 +210,11 @@ void json_node_get_value (JsonNode *node, GValue *value); void json_node_set_string (JsonNode *node, const gchar *value); +#if !GLIB_CHECK_VERSION(2,31,0) G_CONST_RETURN gchar *json_node_get_string (JsonNode *node); +#else +const gchar *json_node_get_string (JsonNode *node); +#endif gchar * json_node_dup_string (JsonNode *node); void json_node_set_int (JsonNode *node, gint64 value); @@ -266,8 +275,13 @@ gdouble json_object_get_double_member (JsonObject *object, const gchar *member_name); gboolean json_object_get_boolean_member (JsonObject *object, const gchar *member_name); +#if !GLIB_CHECK_VERSION(2,31,0) G_CONST_RETURN gchar *json_object_get_string_member (JsonObject *object, const gchar *member_name); +#else +const gchar *json_object_get_string_member (JsonObject *object, + const gchar *member_name); +#endif gboolean json_object_get_null_member (JsonObject *object, const gchar *member_name); JsonArray * json_object_get_array_member (JsonObject *object, @@ -313,8 +327,13 @@ gdouble json_array_get_double_element (JsonArray *array, guint index_); gboolean json_array_get_boolean_element (JsonArray *array, guint index_); +#if !GLIB_CHECK_VERSION(2,31,0) G_CONST_RETURN gchar *json_array_get_string_element (JsonArray *array, guint index_); +#else +const gchar *json_array_get_string_element (JsonArray *array, + guint index_); +#endif gboolean json_array_get_null_element (JsonArray *array, guint index_); JsonArray * json_array_get_array_element (JsonArray *array, diff --git a/json-glib/tests/Makefile.in b/json-glib/tests/Makefile.in index 9597f69..43f21ca 100644 --- a/json-glib/tests/Makefile.in +++ b/json-glib/tests/Makefile.in @@ -272,7 +272,6 @@ INCLUDES = \ AM_CPPFLAGS = $(JSON_DEBUG_CFLAGS) AM_CFLAGS = -g $(JSON_CFLAGS) -AM_LDFLAGS = $(JSON_LIBS) progs_ldadd = $(top_builddir)/json-glib/libjson-glib-1.0.la array_test_SOURCES = array-test.c array_test_LDADD = $(progs_ldadd) diff --git a/json-glib/tests/node-test.c b/json-glib/tests/node-test.c index da979a4..b5ba722 100644 --- a/json-glib/tests/node-test.c +++ b/json-glib/tests/node-test.c @@ -1,7 +1,14 @@ -#include + #include #include +#if !GLIB_CHECK_VERSION (2, 31, 0) +#include +#else +#include +#endif + + static void test_copy_null (void) { diff --git a/packaging/json-glib.spec b/packaging/json-glib.spec index f60d652..a4867df 100644 --- a/packaging/json-glib.spec +++ b/packaging/json-glib.spec @@ -1,11 +1,12 @@ +#sbs-git:slp/pkgs/l/libjson-glib json-glib 0.0.1 982a2ec62fdaecef7bf0d791b9b7be16d398d70b Name: json-glib Summary: JSON Parser for GLib -Version: 0.0.1 +Version: 0.0.1 Release: 1 Group: System/Libraries License: LGPLv2.1 -Source0: libjson-glib_%{version}.tar.gz +Source0: %{name}-%{version}.tar.gz Requires(post): /sbin/ldconfig Requires(postun): /sbin/ldconfig BuildRequires: pkgconfig(gobject-2.0) @@ -35,32 +36,23 @@ Components for the json-glib package (doc) %prep -%setup -q -n lib%{name}-%{version} +%setup -q -n %{name}-%{version} %build -%configure --disable-static +%reconfigure --disable-static make %{?jobs:-j%jobs} %install rm -rf %{buildroot} %make_install - - - %post -p /sbin/ldconfig %postun -p /sbin/ldconfig - - - - - - %files %defattr(-,root,root,-) %doc COPYING