--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+#!/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
--- /dev/null
+TET_INSTALL_HOST_PATH=/home/ivan/xuyun/DTS/TETware
+TET_INSTALL_TARGET_PATH=/mnt/nfs/DTS/TETware
--- /dev/null
+#!/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
--- /dev/null
+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
--- /dev/null
+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?
--- /dev/null
+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
--- /dev/null
+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 ?
--- /dev/null
+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
--- /dev/null
+###################################################
+# 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)
+
--- /dev/null
+/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
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+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);
+}
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+
+#include <json-glib/json-glib.h>
+
+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);
+
+}
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+
+#include <json-glib/json-glib.h>
+
+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);
+}
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+
+#include <json-glib/json-glib.h>
+
+
+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);
+}
+
--- /dev/null
+###################################################
+# 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)
+
--- /dev/null
+/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
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include <json-glib/json-glib.h>
+
+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);
+}
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include <json-glib/json-glib.h>
+
+
+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);
+
+}
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include <json-glib/json-glib.h>
+
+
+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);
+
+}
+
--- /dev/null
+
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include <json-glib/json-glib.h>
+#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);
+
+}
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include <json-glib/json-glib.h>
+
+
+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);
+
+}
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib-object.h>
+
+#include <json-glib/json-glib.h>
+
+
+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);
+}
+
+
--- /dev/null
+###################################################
+# 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)
+
--- /dev/null
+/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
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+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);
+}
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+
+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);
+}
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+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);
+
+}
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+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);
+}
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+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);
+}
+
--- /dev/null
+#include <tet_api.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+
+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);
+}
+
--- /dev/null
+#include <tet_api.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <glib.h>
+#include <json-glib/json-glib.h>
+
+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);
+}
--- /dev/null
+###################################################
+# 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)
+
--- /dev/null
+/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
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+
+#include <json-glib/json-glib.h>
+
+
+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);
+}
+
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+
+#include <json-glib/json-glib.h>
+
+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);
+}
+
+
--- /dev/null
+#include <tet_api.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+
+#include <json-glib/json-glib.h>
+
+
+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);
+}
+
+
+
--- /dev/null
+#!/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"
--- /dev/null
+#include <tet_api.h>
+#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);
+}
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);
}
}
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");
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])
_PKG_TEXT
-To get pkg-config, see <http://pkg-config.freedesktop.org/>.])[]dnl
+To get pkg-config, see <http://pkg-config.freedesktop.org/>.])dnl
])
else
$1[]_CFLAGS=$pkg_cv_[]$1[]_CFLAGS
#! /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
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
fi
;;
*)
- os=netbsd
+ os=netbsd
;;
esac
# The OS release
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
# 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
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}
# 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 ;;
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 ] || \
else
echo i586-dg-dgux${UNAME_RELEASE}
fi
- exit ;;
+ exit ;;
M88*:DolphinOS:*:*) # DolphinOS (SVR3)
echo m88k-dolphin-sysv3
exit ;;
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
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 <stdlib.h>
- #include <unistd.h>
+ #define _HPUX_SOURCE
+ #include <stdlib.h>
+ #include <unistd.h>
- 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
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 ;;
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}
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 ;;
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}
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:*:*)
echo crisv32-axis-linux-gnu
exit ;;
frv:Linux:*:*)
- echo frv-unknown-linux-gnu
+ echo frv-unknown-linux-gnu
exit ;;
i*86:Linux:*:*)
LIBC=gnu
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
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 ;;
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.
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:*:*)
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 ;;
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 ;;
/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 \
echo ns32k-sni-sysv
fi
exit ;;
- PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
- # says <Richard.M.Bartel@ccMail.Census.GOV>
- echo i586-unisys-sysv4
- exit ;;
+ PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+ # says <Richard.M.Bartel@ccMail.Census.GOV>
+ echo i586-unisys-sysv4
+ exit ;;
*:UNIX_System_V:4*:FTX*)
# From Gerald Hewes <hewes@openmarket.com>.
# How about differentiating between stratus architectures? -djm
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 ;;
*: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 ;;
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 ;;
#include <sys/param.h>
printf ("m68k-sony-newsos%s\n",
#ifdef NEWSOS4
- "4"
+ "4"
#else
- ""
+ ""
#endif
- ); exit (0);
+ ); exit (0);
#endif
#endif
#! /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
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
# 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
os=
basic_machine=$1
;;
- -bluegene*)
- os=-cnk
+ -bluegene*)
+ os=-cnk
;;
-sim | -cisco | -oki | -wec | -winbond)
os=
os=-chorusos
basic_machine=$1
;;
- -chorusrdb)
- os=-chorusrdb
+ -chorusrdb)
+ os=-chorusrdb
basic_machine=$1
- ;;
+ ;;
-hiux*)
os=-hiuxwe2
;;
| 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 \
| 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
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.
| 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-* \
| 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-*)
basic_machine=a29k-amd
os=-udi
;;
- abacus)
+ abacus)
basic_machine=abacus-unknown
;;
adobe68k)
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
;;
basic_machine=craynv-cray
os=-unicosmp
;;
- cr16 | cr16-*)
+ cr16)
basic_machine=cr16-unknown
os=-elf
;;
basic_machine=ns32k-utek
os=-sysv
;;
- microblaze)
+ microblaze)
basic_machine=microblaze-xilinx
;;
mingw32)
np1)
basic_machine=np1-gould
;;
- neo-tandem)
- basic_machine=neo-tandem
- ;;
- nse-tandem)
- basic_machine=nse-tandem
- ;;
nsr-tandem)
basic_machine=nsr-tandem
;;
;;
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
basic_machine=i860-stratus
os=-sysv4
;;
- strongarm-* | thumb-*)
- basic_machine=arm-`echo $basic_machine | sed 's/^[^-]*-//'`
- ;;
sun2)
basic_machine=m68000-sun
;;
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
;;
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
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|'`
| -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* \
-opened*)
os=-openedition
;;
- -os400*)
+ -os400*)
os=-os400
;;
-wince*)
-sinix*)
os=-sysv4
;;
- -tpf*)
+ -tpf*)
os=-tpf
;;
-triton*)
-dicos*)
os=-dicos
;;
- -nacl*)
- ;;
+ -nacl*)
+ ;;
-none)
;;
*)
# system, and we'll never get to this point.
case $basic_machine in
- score-*)
+ score-*)
os=-elf
;;
- spu-*)
+ spu-*)
os=-elf
;;
*-acorn)
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-*)
m68*-cisco)
os=-aout
;;
- mep-*)
+ mep-*)
os=-elf
;;
mips*-cisco)
*-ibm)
os=-aix
;;
- *-knuth)
+ *-knuth)
os=-mmixware
;;
*-wec)
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);
}
}
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");
-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 <mj2004.park@samsung.com> Wed, 07 Dec 2011 14:12:11 +0900
+ -- MyoungJune Park <mj2004.park@samsung.com> 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 <jh1114.kim@samsung.com> 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 <ty317.kim@samsung.com> 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 <mj.mccormack@samsung.com> 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 <karam.ko@samsung.com> 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 <karam.ko@samsung.com> 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 <dh79.pyun@samsung.com> Mon, 03 May 2010 14:12:11 +0900
Source: libjson-glib
Section: libs
Priority: extra
-Maintainer: MyoungJune Park <mj2004.park@samsung.com>
+Maintainer: Moung June Park <mj2004.park@samsung.com>
Uploaders: Mike McCormack <mj.mccormack@samsung.com>
Build-Depends: debhelper (>= 5), autotools-dev, libglib2.0-dev (>= 2.21.3), libgnutls-dev
Standards-Version: 0.10.4
-
-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,
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;
}
*
* 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;
* 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)");
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)
{
*
* 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);
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;
}
*
* 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;
#ifndef __JSON_SCANNER_H__
#define __JSON_SCANNER_H__
+#if !GLIB_CHECK_VERSION(2, 31, 0)
#include <glib/gdataset.h>
#include <glib/ghash.h>
#include <glib/gscanner.h>
-
+#else
+#include <glib.h>
+#endif
G_BEGIN_DECLS
typedef struct _JsonScanner JsonScanner;
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
JsonNode *element_node,
gpointer user_data);
+
+
/*
* JsonNode
*/
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,
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);
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,
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,
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)
-#include <glib/gtestutils.h>
+
#include <json-glib/json-glib.h>
#include <string.h>
+#if !GLIB_CHECK_VERSION (2, 31, 0)
+#include <glib/gtestutils.h>
+#else
+#include <glib.h>
+#endif
+
+
static void
test_copy_null (void)
{
+#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)
%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
projects / external / libjson-glib.git / commitdiff