[qemu.git] / check-qjson.c

/*
 * Copyright IBM, Corp. 2009
 *
 * Authors:
 *  Anthony Liguori   <[email protected]>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 *
 */
#include <check.h>

#include "qstring.h"
#include "qint.h"
#include "qdict.h"
#include "qlist.h"
#include "qfloat.h"
#include "qbool.h"
#include "qjson.h"

#include "qemu-common.h"

START_TEST(escaped_string)
{
    int i;
    struct {
        const char *encoded;
        const char *decoded;
        int skip;
    } test_cases[] = {
        { "\"\\b\"", "\b" },
        { "\"\\f\"", "\f" },
        { "\"\\n\"", "\n" },
        { "\"\\r\"", "\r" },
        { "\"\\t\"", "\t" },
        { "\"/\"", "/" },
        { "\"\\/\"", "/", .skip = 1 },
        { "\"\\\\\"", "\\" },
        { "\"\\\"\"", "\"" },
        { "\"hello world \\\"embedded string\\\"\"",
          "hello world \"embedded string\"" },
        { "\"hello world\\nwith new line\"", "hello world\nwith new line" },
        { "\"single byte utf-8 \\u0020\"", "single byte utf-8  ", .skip = 1 },
        { "\"double byte utf-8 \\u00A2\"", "double byte utf-8 \xc2\xa2" },
        { "\"triple byte utf-8 \\u20AC\"", "triple byte utf-8 \xe2\x82\xac" },
        {}
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QString *str;

        obj = qobject_from_json(test_cases[i].encoded);

        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QSTRING);
        
        str = qobject_to_qstring(obj);
        fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0,
                    "%s != %s\n", qstring_get_str(str), test_cases[i].decoded);

        if (test_cases[i].skip == 0) {
            str = qobject_to_json(obj);
            fail_unless(strcmp(qstring_get_str(str),test_cases[i].encoded) == 0,
                        "%s != %s\n", qstring_get_str(str),
                                      test_cases[i].encoded);

            qobject_decref(obj);
        }

        QDECREF(str);
    }
}
END_TEST

START_TEST(simple_string)
{
    int i;
    struct {
        const char *encoded;
        const char *decoded;
    } test_cases[] = {
        { "\"hello world\"", "hello world" },
        { "\"the quick brown fox jumped over the fence\"",
          "the quick brown fox jumped over the fence" },
        {}
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QString *str;

        obj = qobject_from_json(test_cases[i].encoded);

        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QSTRING);
        
        str = qobject_to_qstring(obj);
        fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);

        str = qobject_to_json(obj);
        fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);

        qobject_decref(obj);
        
        QDECREF(str);
    }
}
END_TEST

START_TEST(single_quote_string)
{
    int i;
    struct {
        const char *encoded;
        const char *decoded;
    } test_cases[] = {
        { "'hello world'", "hello world" },
        { "'the quick brown fox \\' jumped over the fence'",
          "the quick brown fox ' jumped over the fence" },
        {}
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QString *str;

        obj = qobject_from_json(test_cases[i].encoded);

        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QSTRING);
        
        str = qobject_to_qstring(obj);
        fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);

        QDECREF(str);
    }
}
END_TEST

START_TEST(vararg_string)
{
    int i;
    struct {
        const char *decoded;
    } test_cases[] = {
        { "hello world" },
        { "the quick brown fox jumped over the fence" },
        {}
    };

    for (i = 0; test_cases[i].decoded; i++) {
        QObject *obj;
        QString *str;

        obj = qobject_from_jsonf("%s", test_cases[i].decoded);

        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QSTRING);
        
        str = qobject_to_qstring(obj);
        fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);

        QDECREF(str);
    }
}
END_TEST

START_TEST(simple_number)
{
    int i;
    struct {
        const char *encoded;
        int64_t decoded;
        int skip;
    } test_cases[] = {
        { "0", 0 },
        { "1234", 1234 },
        { "1", 1 },
        { "-32", -32 },
        { "-0", 0, .skip = 1 },
        { },
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QInt *qint;

        obj = qobject_from_json(test_cases[i].encoded);
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QINT);

        qint = qobject_to_qint(obj);
        fail_unless(qint_get_int(qint) == test_cases[i].decoded);
        if (test_cases[i].skip == 0) {
            QString *str;

            str = qobject_to_json(obj);
            fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
            QDECREF(str);
        }

        QDECREF(qint);
    }
}
END_TEST

START_TEST(float_number)
{
    int i;
    struct {
        const char *encoded;
        double decoded;
        int skip;
    } test_cases[] = {
        { "32.43", 32.43 },
        { "0.222", 0.222 },
        { "-32.12313", -32.12313 },
        { "-32.20e-10", -32.20e-10, .skip = 1 },
        { },
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QFloat *qfloat;

        obj = qobject_from_json(test_cases[i].encoded);
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QFLOAT);

        qfloat = qobject_to_qfloat(obj);
        fail_unless(qfloat_get_double(qfloat) == test_cases[i].decoded);

        if (test_cases[i].skip == 0) {
            QString *str;

            str = qobject_to_json(obj);
            fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
            QDECREF(str);
        }

        QDECREF(qfloat);
    }
}
END_TEST

START_TEST(vararg_number)
{
    QObject *obj;
    QInt *qint;
    QFloat *qfloat;
    int value = 0x2342;
    int64_t value64 = 0x2342342343LL;
    double valuef = 2.323423423;

    obj = qobject_from_jsonf("%d", value);
    fail_unless(obj != NULL);
    fail_unless(qobject_type(obj) == QTYPE_QINT);

    qint = qobject_to_qint(obj);
    fail_unless(qint_get_int(qint) == value);

    QDECREF(qint);

    obj = qobject_from_jsonf("%" PRId64, value64);
    fail_unless(obj != NULL);
    fail_unless(qobject_type(obj) == QTYPE_QINT);

    qint = qobject_to_qint(obj);
    fail_unless(qint_get_int(qint) == value64);

    QDECREF(qint);

    obj = qobject_from_jsonf("%f", valuef);
    fail_unless(obj != NULL);
    fail_unless(qobject_type(obj) == QTYPE_QFLOAT);

    qfloat = qobject_to_qfloat(obj);
    fail_unless(qfloat_get_double(qfloat) == valuef);

    QDECREF(qfloat);
}
END_TEST

START_TEST(keyword_literal)
{
    QObject *obj;
    QBool *qbool;
    QString *str;

    obj = qobject_from_json("true");
    fail_unless(obj != NULL);
    fail_unless(qobject_type(obj) == QTYPE_QBOOL);

    qbool = qobject_to_qbool(obj);
    fail_unless(qbool_get_int(qbool) != 0);

    str = qobject_to_json(obj);
    fail_unless(strcmp(qstring_get_str(str), "true") == 0);
    QDECREF(str);

    QDECREF(qbool);

    obj = qobject_from_json("false");
    fail_unless(obj != NULL);
    fail_unless(qobject_type(obj) == QTYPE_QBOOL);

    qbool = qobject_to_qbool(obj);
    fail_unless(qbool_get_int(qbool) == 0);

    str = qobject_to_json(obj);
    fail_unless(strcmp(qstring_get_str(str), "false") == 0);
    QDECREF(str);

    QDECREF(qbool);

    obj = qobject_from_jsonf("%i", false);
    fail_unless(obj != NULL);
    fail_unless(qobject_type(obj) == QTYPE_QBOOL);

    qbool = qobject_to_qbool(obj);
    fail_unless(qbool_get_int(qbool) == 0);

    QDECREF(qbool);
    
    obj = qobject_from_jsonf("%i", true);
    fail_unless(obj != NULL);
    fail_unless(qobject_type(obj) == QTYPE_QBOOL);

    qbool = qobject_to_qbool(obj);
    fail_unless(qbool_get_int(qbool) != 0);

    QDECREF(qbool);
}
END_TEST

typedef struct LiteralQDictEntry LiteralQDictEntry;
typedef struct LiteralQObject LiteralQObject;

struct LiteralQObject
{
    int type;
    union {
        int64_t qint;
        const char *qstr;
        LiteralQDictEntry *qdict;
        LiteralQObject *qlist;
    } value;
};

struct LiteralQDictEntry
{
    const char *key;
    LiteralQObject value;
};

#define QLIT_QINT(val) (LiteralQObject){.type = QTYPE_QINT, .value.qint = (val)}
#define QLIT_QSTR(val) (LiteralQObject){.type = QTYPE_QSTRING, .value.qstr = (val)}
#define QLIT_QDICT(val) (LiteralQObject){.type = QTYPE_QDICT, .value.qdict = (val)}
#define QLIT_QLIST(val) (LiteralQObject){.type = QTYPE_QLIST, .value.qlist = (val)}

typedef struct QListCompareHelper
{
    int index;
    LiteralQObject *objs;
    int result;
} QListCompareHelper;

static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs);

static void compare_helper(QObject *obj, void *opaque)
{
    QListCompareHelper *helper = opaque;

    if (helper->result == 0) {
        return;
    }

    if (helper->objs[helper->index].type == QTYPE_NONE) {
        helper->result = 0;
        return;
    }

    helper->result = compare_litqobj_to_qobj(&helper->objs[helper->index++], obj);
}

static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs)
{
    if (lhs->type != qobject_type(rhs)) {
        return 0;
    }

    switch (lhs->type) {
    case QTYPE_QINT:
        return lhs->value.qint == qint_get_int(qobject_to_qint(rhs));
    case QTYPE_QSTRING:
        return (strcmp(lhs->value.qstr, qstring_get_str(qobject_to_qstring(rhs))) == 0);
    case QTYPE_QDICT: {
        int i;

        for (i = 0; lhs->value.qdict[i].key; i++) {
            QObject *obj = qdict_get(qobject_to_qdict(rhs), lhs->value.qdict[i].key);

            if (!compare_litqobj_to_qobj(&lhs->value.qdict[i].value, obj)) {
                return 0;
            }
        }

        return 1;
    }
    case QTYPE_QLIST: {
        QListCompareHelper helper;

        helper.index = 0;
        helper.objs = lhs->value.qlist;
        helper.result = 1;
        
        qlist_iter(qobject_to_qlist(rhs), compare_helper, &helper);

        return helper.result;
    }
    default:
        break;
    }

    return 0;
}

START_TEST(simple_dict)
{
    int i;
    struct {
        const char *encoded;
        LiteralQObject decoded;
    } test_cases[] = {
        {
            .encoded = "{\"foo\": 42, \"bar\": \"hello world\"}",
            .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
                        { "foo", QLIT_QINT(42) },
                        { "bar", QLIT_QSTR("hello world") },
                        { }
                    })),
        }, {
            .encoded = "{}",
            .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
                        { }
                    })),
        }, {
            .encoded = "{\"foo\": 43}",
            .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
                        { "foo", QLIT_QINT(43) },
                        { }
                    })),
        },
        { }
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QString *str;

        obj = qobject_from_json(test_cases[i].encoded);
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QDICT);

        fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);

        str = qobject_to_json(obj);
        qobject_decref(obj);

        obj = qobject_from_json(qstring_get_str(str));
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QDICT);

        fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        qobject_decref(obj);
        QDECREF(str);
    }
}
END_TEST

START_TEST(simple_list)
{
    int i;
    struct {
        const char *encoded;
        LiteralQObject decoded;
    } test_cases[] = {
        {
            .encoded = "[43,42]",
            .decoded = QLIT_QLIST(((LiteralQObject[]){
                        QLIT_QINT(43),
                        QLIT_QINT(42),
                        { }
                    })),
        },
        {
            .encoded = "[43]",
            .decoded = QLIT_QLIST(((LiteralQObject[]){
                        QLIT_QINT(43),
                        { }
                    })),
        },
        {
            .encoded = "[]",
            .decoded = QLIT_QLIST(((LiteralQObject[]){
                        { }
                    })),
        },
        {
            .encoded = "[{}]",
            .decoded = QLIT_QLIST(((LiteralQObject[]){
                        QLIT_QDICT(((LiteralQDictEntry[]){
                                    {},
                                        })),
                        {},
                            })),
        },
        { }
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QString *str;

        obj = qobject_from_json(test_cases[i].encoded);
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QLIST);

        fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);

        str = qobject_to_json(obj);
        qobject_decref(obj);

        obj = qobject_from_json(qstring_get_str(str));
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QLIST);

        fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        qobject_decref(obj);
        QDECREF(str);
    }
}
END_TEST

START_TEST(simple_whitespace)
{
    int i;
    struct {
        const char *encoded;
        LiteralQObject decoded;
    } test_cases[] = {
        {
            .encoded = " [ 43 , 42 ]",
            .decoded = QLIT_QLIST(((LiteralQObject[]){
                        QLIT_QINT(43),
                        QLIT_QINT(42),
                        { }
                    })),
        },
        {
            .encoded = " [ 43 , { 'h' : 'b' }, [ ], 42 ]",
            .decoded = QLIT_QLIST(((LiteralQObject[]){
                        QLIT_QINT(43),
                        QLIT_QDICT(((LiteralQDictEntry[]){
                                    { "h", QLIT_QSTR("b") },
                                    { }})),
                        QLIT_QLIST(((LiteralQObject[]){
                                    { }})),
                        QLIT_QINT(42),
                        { }
                    })),
        },
        {
            .encoded = " [ 43 , { 'h' : 'b' , 'a' : 32 }, [ ], 42 ]",
            .decoded = QLIT_QLIST(((LiteralQObject[]){
                        QLIT_QINT(43),
                        QLIT_QDICT(((LiteralQDictEntry[]){
                                    { "h", QLIT_QSTR("b") },
                                    { "a", QLIT_QINT(32) },
                                    { }})),
                        QLIT_QLIST(((LiteralQObject[]){
                                    { }})),
                        QLIT_QINT(42),
                        { }
                    })),
        },
        { }
    };

    for (i = 0; test_cases[i].encoded; i++) {
        QObject *obj;
        QString *str;

        obj = qobject_from_json(test_cases[i].encoded);
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QLIST);

        fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);

        str = qobject_to_json(obj);
        qobject_decref(obj);

        obj = qobject_from_json(qstring_get_str(str));
        fail_unless(obj != NULL);
        fail_unless(qobject_type(obj) == QTYPE_QLIST);

        fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);

        qobject_decref(obj);
        QDECREF(str);
    }
}
END_TEST

START_TEST(simple_varargs)
{
    QObject *embedded_obj;
    QObject *obj;
    LiteralQObject decoded = QLIT_QLIST(((LiteralQObject[]){
            QLIT_QINT(1),
            QLIT_QINT(2),
            QLIT_QLIST(((LiteralQObject[]){
                        QLIT_QINT(32),
                        QLIT_QINT(42),
                        {}})),
            {}}));

    embedded_obj = qobject_from_json("[32, 42]");
    fail_unless(embedded_obj != NULL);

    obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj);
    fail_unless(obj != NULL);

    fail_unless(compare_litqobj_to_qobj(&decoded, obj) == 1);

    qobject_decref(obj);
}
END_TEST

START_TEST(empty_input)
{
    const char *empty = "";

    QObject *obj = qobject_from_json(empty);
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_string)
{
    QObject *obj = qobject_from_json("\"abc");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_sq_string)
{
    QObject *obj = qobject_from_json("'abc");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_escape)
{
    QObject *obj = qobject_from_json("\"abc\\\"");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_array)
{
    QObject *obj = qobject_from_json("[32");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_array_comma)
{
    QObject *obj = qobject_from_json("[32,");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(invalid_array_comma)
{
    QObject *obj = qobject_from_json("[32,}");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_dict)
{
    QObject *obj = qobject_from_json("{'abc':32");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_dict_comma)
{
    QObject *obj = qobject_from_json("{'abc':32,");
    fail_unless(obj == NULL);
}
END_TEST

#if 0
START_TEST(invalid_dict_comma)
{
    QObject *obj = qobject_from_json("{'abc':32,}");
    fail_unless(obj == NULL);
}
END_TEST

START_TEST(unterminated_literal)
{
    QObject *obj = qobject_from_json("nul");
    fail_unless(obj == NULL);
}
END_TEST
#endif

static Suite *qjson_suite(void)
{
    Suite *suite;
    TCase *string_literals, *number_literals, *keyword_literals;
    TCase *dicts, *lists, *whitespace, *varargs, *errors;

    string_literals = tcase_create("String Literals");
    tcase_add_test(string_literals, simple_string);
    tcase_add_test(string_literals, escaped_string);
    tcase_add_test(string_literals, single_quote_string);
    tcase_add_test(string_literals, vararg_string);

    number_literals = tcase_create("Number Literals");
    tcase_add_test(number_literals, simple_number);
    tcase_add_test(number_literals, float_number);
    tcase_add_test(number_literals, vararg_number);

    keyword_literals = tcase_create("Keywords");
    tcase_add_test(keyword_literals, keyword_literal);
    dicts = tcase_create("Objects");
    tcase_add_test(dicts, simple_dict);
    lists = tcase_create("Lists");
    tcase_add_test(lists, simple_list);

    whitespace = tcase_create("Whitespace");
    tcase_add_test(whitespace, simple_whitespace);

    varargs = tcase_create("Varargs");
    tcase_add_test(varargs, simple_varargs);

    errors = tcase_create("Invalid JSON");
    tcase_add_test(errors, empty_input);
    tcase_add_test(errors, unterminated_string);
    tcase_add_test(errors, unterminated_escape);
    tcase_add_test(errors, unterminated_sq_string);
    tcase_add_test(errors, unterminated_array);
    tcase_add_test(errors, unterminated_array_comma);
    tcase_add_test(errors, invalid_array_comma);
    tcase_add_test(errors, unterminated_dict);
    tcase_add_test(errors, unterminated_dict_comma);
#if 0
    /* FIXME: this print parse error messages on stderr.  */
    tcase_add_test(errors, invalid_dict_comma);
    tcase_add_test(errors, unterminated_literal);
#endif

    suite = suite_create("QJSON test-suite");
    suite_add_tcase(suite, string_literals);
    suite_add_tcase(suite, number_literals);
    suite_add_tcase(suite, keyword_literals);
    suite_add_tcase(suite, dicts);
    suite_add_tcase(suite, lists);
    suite_add_tcase(suite, whitespace);
    suite_add_tcase(suite, varargs);
    suite_add_tcase(suite, errors);

    return suite;
}

int main(void)
{
    int nf;
    Suite *s;
    SRunner *sr;

    s = qjson_suite();
    sr = srunner_create(s);
        
    srunner_run_all(sr, CK_NORMAL);
    nf = srunner_ntests_failed(sr);
    srunner_free(sr);
    
    return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}
Commit	Line	Data
422c46a8 AL	1	/*
	2	* Copyright IBM, Corp. 2009
	3	*
	4	* Authors:
	5	* Anthony Liguori <[email protected]>
	6	*
	7	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	8	* See the COPYING.LIB file in the top-level directory.
	9	*
	10	*/
	11	#include <check.h>
422c46a8 AL	12
	13	#include "qstring.h"
	14	#include "qint.h"
	15	#include "qdict.h"
	16	#include "qlist.h"
	17	#include "qfloat.h"
	18	#include "qbool.h"
	19	#include "qjson.h"
	20
	21	#include "qemu-common.h"
	22
	23	START_TEST(escaped_string)
	24	{
	25	int i;
	26	struct {
	27	const char *encoded;
	28	const char *decoded;
6ee59202	29	int skip;
422c46a8	30	} test_cases[] = {
d22b0bd7 LC	31	{ "\"\\b\"", "\b" },
	32	{ "\"\\f\"", "\f" },
	33	{ "\"\\n\"", "\n" },
	34	{ "\"\\r\"", "\r" },
	35	{ "\"\\t\"", "\t" },
69faeee1 JK	36	{ "\"/\"", "/" },
69faeee1 JK	37	{ "\"\\/\"", "/", .skip = 1 },
d22b0bd7	38	{ "\"\\\\\"", "\\" },
422c46a8 AL	39	{ "\"\\\"\"", "\"" },
	40	{ "\"hello world \\\"embedded string\\\"\"",
	41	"hello world \"embedded string\"" },
	42	{ "\"hello world\\nwith new line\"", "hello world\nwith new line" },
6ee59202	43	{ "\"single byte utf-8 \\u0020\"", "single byte utf-8 ", .skip = 1 },
422c46a8 AL	44	{ "\"double byte utf-8 \\u00A2\"", "double byte utf-8 \xc2\xa2" },
	45	{ "\"triple byte utf-8 \\u20AC\"", "triple byte utf-8 \xe2\x82\xac" },
	46	{}
	47	};
	48
	49	for (i = 0; test_cases[i].encoded; i++) {
	50	QObject *obj;
	51	QString *str;
	52
	53	obj = qobject_from_json(test_cases[i].encoded);
	54
	55	fail_unless(obj != NULL);
	56	fail_unless(qobject_type(obj) == QTYPE_QSTRING);
	57
	58	str = qobject_to_qstring(obj);
d22b0bd7 LC	59	fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0,
d22b0bd7 LC	60	"%s != %s\n", qstring_get_str(str), test_cases[i].decoded);
422c46a8	61
6ee59202 AL	62	if (test_cases[i].skip == 0) {
6ee59202 AL	63	str = qobject_to_json(obj);
d22b0bd7 LC	64	fail_unless(strcmp(qstring_get_str(str),test_cases[i].encoded) == 0,
	65	"%s != %s\n", qstring_get_str(str),
	66	test_cases[i].encoded);
6ee59202 AL	67
	68	qobject_decref(obj);
	69	}
	70
422c46a8 AL	71	QDECREF(str);
	72	}
	73	}
	74	END_TEST
	75
	76	START_TEST(simple_string)
	77	{
	78	int i;
	79	struct {
	80	const char *encoded;
	81	const char *decoded;
	82	} test_cases[] = {
	83	{ "\"hello world\"", "hello world" },
	84	{ "\"the quick brown fox jumped over the fence\"",
	85	"the quick brown fox jumped over the fence" },
	86	{}
	87	};
	88
	89	for (i = 0; test_cases[i].encoded; i++) {
	90	QObject *obj;
	91	QString *str;
	92
	93	obj = qobject_from_json(test_cases[i].encoded);
	94
	95	fail_unless(obj != NULL);
	96	fail_unless(qobject_type(obj) == QTYPE_QSTRING);
	97
	98	str = qobject_to_qstring(obj);
	99	fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
	100
6ee59202 AL	101	str = qobject_to_json(obj);
	102	fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
	103
	104	qobject_decref(obj);
	105
422c46a8 AL	106	QDECREF(str);
	107	}
	108	}
	109	END_TEST
	110
	111	START_TEST(single_quote_string)
	112	{
	113	int i;
	114	struct {
	115	const char *encoded;
	116	const char *decoded;
	117	} test_cases[] = {
	118	{ "'hello world'", "hello world" },
	119	{ "'the quick brown fox \\' jumped over the fence'",
	120	"the quick brown fox ' jumped over the fence" },
	121	{}
	122	};
	123
	124	for (i = 0; test_cases[i].encoded; i++) {
	125	QObject *obj;
	126	QString *str;
	127
	128	obj = qobject_from_json(test_cases[i].encoded);
	129
	130	fail_unless(obj != NULL);
	131	fail_unless(qobject_type(obj) == QTYPE_QSTRING);
	132
	133	str = qobject_to_qstring(obj);
	134	fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
	135
	136	QDECREF(str);
	137	}
	138	}
	139	END_TEST
	140
	141	START_TEST(vararg_string)
	142	{
	143	int i;
	144	struct {
	145	const char *decoded;
	146	} test_cases[] = {
	147	{ "hello world" },
	148	{ "the quick brown fox jumped over the fence" },
	149	{}
	150	};
	151
	152	for (i = 0; test_cases[i].decoded; i++) {
	153	QObject *obj;
	154	QString *str;
	155
	156	obj = qobject_from_jsonf("%s", test_cases[i].decoded);
	157
	158	fail_unless(obj != NULL);
	159	fail_unless(qobject_type(obj) == QTYPE_QSTRING);
	160
	161	str = qobject_to_qstring(obj);
	162	fail_unless(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
	163
	164	QDECREF(str);
	165	}
	166	}
	167	END_TEST
	168
	169	START_TEST(simple_number)
170	{
171	int i;
172	struct {
173	const char *encoded;
174	int64_t decoded;
6ee59202	175	int skip;
422c46a8 AL	176	} test_cases[] = {
	177	{ "0", 0 },
	178	{ "1234", 1234 },
	179	{ "1", 1 },
	180	{ "-32", -32 },
6ee59202	181	{ "-0", 0, .skip = 1 },
422c46a8 AL	182	{ },
	183	};
	184
	185	for (i = 0; test_cases[i].encoded; i++) {
	186	QObject *obj;
	187	QInt *qint;
	188
	189	obj = qobject_from_json(test_cases[i].encoded);
	190	fail_unless(obj != NULL);
	191	fail_unless(qobject_type(obj) == QTYPE_QINT);
	192
	193	qint = qobject_to_qint(obj);
	194	fail_unless(qint_get_int(qint) == test_cases[i].decoded);
6ee59202 AL	195	if (test_cases[i].skip == 0) {
	196	QString *str;
	197
	198	str = qobject_to_json(obj);
	199	fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
	200	QDECREF(str);
	201	}
422c46a8 AL	202
	203	QDECREF(qint);
	204	}
	205	}
	206	END_TEST
	207
	208	START_TEST(float_number)
	209	{
	210	int i;
	211	struct {
	212	const char *encoded;
	213	double decoded;
6ee59202	214	int skip;
422c46a8 AL	215	} test_cases[] = {
	216	{ "32.43", 32.43 },
	217	{ "0.222", 0.222 },
	218	{ "-32.12313", -32.12313 },
6ee59202	219	{ "-32.20e-10", -32.20e-10, .skip = 1 },
422c46a8 AL	220	{ },
	221	};
	222
	223	for (i = 0; test_cases[i].encoded; i++) {
	224	QObject *obj;
	225	QFloat *qfloat;
	226
	227	obj = qobject_from_json(test_cases[i].encoded);
	228	fail_unless(obj != NULL);
	229	fail_unless(qobject_type(obj) == QTYPE_QFLOAT);
	230
	231	qfloat = qobject_to_qfloat(obj);
	232	fail_unless(qfloat_get_double(qfloat) == test_cases[i].decoded);
	233
6ee59202 AL	234	if (test_cases[i].skip == 0) {
	235	QString *str;
	236
	237	str = qobject_to_json(obj);
	238	fail_unless(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
	239	QDECREF(str);
	240	}
	241
422c46a8 AL	242	QDECREF(qfloat);
	243	}
	244	}
	245	END_TEST
	246
	247	START_TEST(vararg_number)
	248	{
	249	QObject *obj;
	250	QInt *qint;
	251	QFloat *qfloat;
	252	int value = 0x2342;
	253	int64_t value64 = 0x2342342343LL;
	254	double valuef = 2.323423423;
	255
	256	obj = qobject_from_jsonf("%d", value);
	257	fail_unless(obj != NULL);
	258	fail_unless(qobject_type(obj) == QTYPE_QINT);
	259
	260	qint = qobject_to_qint(obj);
	261	fail_unless(qint_get_int(qint) == value);
	262
	263	QDECREF(qint);
	264
	265	obj = qobject_from_jsonf("%" PRId64, value64);
	266	fail_unless(obj != NULL);
	267	fail_unless(qobject_type(obj) == QTYPE_QINT);
	268
	269	qint = qobject_to_qint(obj);
	270	fail_unless(qint_get_int(qint) == value64);
	271
	272	QDECREF(qint);
	273
	274	obj = qobject_from_jsonf("%f", valuef);
	275	fail_unless(obj != NULL);
	276	fail_unless(qobject_type(obj) == QTYPE_QFLOAT);
	277
	278	qfloat = qobject_to_qfloat(obj);
	279	fail_unless(qfloat_get_double(qfloat) == valuef);
	280
	281	QDECREF(qfloat);
	282	}
	283	END_TEST
	284
	285	START_TEST(keyword_literal)
	286	{
	287	QObject *obj;
	288	QBool *qbool;
6ee59202	289	QString *str;
422c46a8 AL	290
	291	obj = qobject_from_json("true");
	292	fail_unless(obj != NULL);
	293	fail_unless(qobject_type(obj) == QTYPE_QBOOL);
	294
	295	qbool = qobject_to_qbool(obj);
	296	fail_unless(qbool_get_int(qbool) != 0);
	297
6ee59202 AL	298	str = qobject_to_json(obj);
	299	fail_unless(strcmp(qstring_get_str(str), "true") == 0);
	300	QDECREF(str);
	301
422c46a8 AL	302	QDECREF(qbool);
	303
	304	obj = qobject_from_json("false");
	305	fail_unless(obj != NULL);
	306	fail_unless(qobject_type(obj) == QTYPE_QBOOL);
	307
	308	qbool = qobject_to_qbool(obj);
	309	fail_unless(qbool_get_int(qbool) == 0);
	310
6ee59202 AL	311	str = qobject_to_json(obj);
	312	fail_unless(strcmp(qstring_get_str(str), "false") == 0);
	313	QDECREF(str);
	314
422c46a8 AL	315	QDECREF(qbool);
	316
	317	obj = qobject_from_jsonf("%i", false);
	318	fail_unless(obj != NULL);
	319	fail_unless(qobject_type(obj) == QTYPE_QBOOL);
	320
	321	qbool = qobject_to_qbool(obj);
	322	fail_unless(qbool_get_int(qbool) == 0);
	323
	324	QDECREF(qbool);
	325
	326	obj = qobject_from_jsonf("%i", true);
	327	fail_unless(obj != NULL);
	328	fail_unless(qobject_type(obj) == QTYPE_QBOOL);
	329
	330	qbool = qobject_to_qbool(obj);
	331	fail_unless(qbool_get_int(qbool) != 0);
	332
	333	QDECREF(qbool);
	334	}
	335	END_TEST
	336
	337	typedef struct LiteralQDictEntry LiteralQDictEntry;
	338	typedef struct LiteralQObject LiteralQObject;
	339
	340	struct LiteralQObject
	341	{
	342	int type;
	343	union {
	344	int64_t qint;
	345	const char *qstr;
	346	LiteralQDictEntry *qdict;
	347	LiteralQObject *qlist;
	348	} value;
	349	};
	350
	351	struct LiteralQDictEntry
	352	{
	353	const char *key;
	354	LiteralQObject value;
	355	};
	356
	357	#define QLIT_QINT(val) (LiteralQObject){.type = QTYPE_QINT, .value.qint = (val)}
	358	#define QLIT_QSTR(val) (LiteralQObject){.type = QTYPE_QSTRING, .value.qstr = (val)}
	359	#define QLIT_QDICT(val) (LiteralQObject){.type = QTYPE_QDICT, .value.qdict = (val)}
	360	#define QLIT_QLIST(val) (LiteralQObject){.type = QTYPE_QLIST, .value.qlist = (val)}
	361
	362	typedef struct QListCompareHelper
	363	{
	364	int index;
	365	LiteralQObject *objs;
	366	int result;
	367	} QListCompareHelper;
	368
	369	static int compare_litqobj_to_qobj(LiteralQObject lhs, QObject rhs);
	370
	371	static void compare_helper(QObject obj, void opaque)
	372	{
	373	QListCompareHelper *helper = opaque;
	374
	375	if (helper->result == 0) {
	376	return;
	377	}
	378
379	if (helper->objs[helper->index].type == QTYPE_NONE) {
380	helper->result = 0;
381	return;
382	}
383
384	helper->result = compare_litqobj_to_qobj(&helper->objs[helper->index++], obj);
385	}
386
387	static int compare_litqobj_to_qobj(LiteralQObject lhs, QObject rhs)
388	{
389	if (lhs->type != qobject_type(rhs)) {
390	return 0;
391	}
392
393	switch (lhs->type) {
394	case QTYPE_QINT:
395	return lhs->value.qint == qint_get_int(qobject_to_qint(rhs));
396	case QTYPE_QSTRING:
397	return (strcmp(lhs->value.qstr, qstring_get_str(qobject_to_qstring(rhs))) == 0);
398	case QTYPE_QDICT: {
399	int i;
400
401	for (i = 0; lhs->value.qdict[i].key; i++) {
402	QObject *obj = qdict_get(qobject_to_qdict(rhs), lhs->value.qdict[i].key);
403
404	if (!compare_litqobj_to_qobj(&lhs->value.qdict[i].value, obj)) {
405	return 0;
406	}
407	}
408
409	return 1;
410	}
411	case QTYPE_QLIST: {
412	QListCompareHelper helper;
413
414	helper.index = 0;
415	helper.objs = lhs->value.qlist;
416	helper.result = 1;
417
418	qlist_iter(qobject_to_qlist(rhs), compare_helper, &helper);
419
420	return helper.result;
421	}
422	default:
423	break;
424	}
425
426	return 0;
427	}
428
429	START_TEST(simple_dict)
430	{
431	int i;
432	struct {
433	const char *encoded;
434	LiteralQObject decoded;
435	} test_cases[] = {
436	{
6ee59202	437	.encoded = "{\"foo\": 42, \"bar\": \"hello world\"}",
422c46a8 AL	438	.decoded = QLIT_QDICT(((LiteralQDictEntry[]){
	439	{ "foo", QLIT_QINT(42) },
	440	{ "bar", QLIT_QSTR("hello world") },
	441	{ }
	442	})),
	443	}, {
	444	.encoded = "{}",
	445	.decoded = QLIT_QDICT(((LiteralQDictEntry[]){
	446	{ }
	447	})),
	448	}, {
6ee59202	449	.encoded = "{\"foo\": 43}",
422c46a8 AL	450	.decoded = QLIT_QDICT(((LiteralQDictEntry[]){
	451	{ "foo", QLIT_QINT(43) },
	452	{ }
	453	})),
	454	},
	455	{ }
	456	};
	457
	458	for (i = 0; test_cases[i].encoded; i++) {
	459	QObject *obj;
6ee59202	460	QString *str;
422c46a8 AL	461
	462	obj = qobject_from_json(test_cases[i].encoded);
	463	fail_unless(obj != NULL);
	464	fail_unless(qobject_type(obj) == QTYPE_QDICT);
	465
	466	fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
	467
6ee59202 AL	468	str = qobject_to_json(obj);
	469	qobject_decref(obj);
	470
	471	obj = qobject_from_json(qstring_get_str(str));
	472	fail_unless(obj != NULL);
	473	fail_unless(qobject_type(obj) == QTYPE_QDICT);
	474
	475	fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
422c46a8	476	qobject_decref(obj);
6ee59202	477	QDECREF(str);
422c46a8 AL	478	}
	479	}
	480	END_TEST
	481
	482	START_TEST(simple_list)
	483	{
	484	int i;
	485	struct {
	486	const char *encoded;
	487	LiteralQObject decoded;
	488	} test_cases[] = {
	489	{
	490	.encoded = "[43,42]",
	491	.decoded = QLIT_QLIST(((LiteralQObject[]){
	492	QLIT_QINT(43),
	493	QLIT_QINT(42),
	494	{ }
	495	})),
	496	},
	497	{
	498	.encoded = "[43]",
	499	.decoded = QLIT_QLIST(((LiteralQObject[]){
	500	QLIT_QINT(43),
	501	{ }
	502	})),
	503	},
	504	{
	505	.encoded = "[]",
	506	.decoded = QLIT_QLIST(((LiteralQObject[]){
	507	{ }
	508	})),
	509	},
	510	{
	511	.encoded = "[{}]",
	512	.decoded = QLIT_QLIST(((LiteralQObject[]){
	513	QLIT_QDICT(((LiteralQDictEntry[]){
	514	{},
	515	})),
	516	{},
	517	})),
	518	},
	519	{ }
	520	};
	521
	522	for (i = 0; test_cases[i].encoded; i++) {
	523	QObject *obj;
6ee59202	524	QString *str;
422c46a8 AL	525
	526	obj = qobject_from_json(test_cases[i].encoded);
	527	fail_unless(obj != NULL);
	528	fail_unless(qobject_type(obj) == QTYPE_QLIST);
	529
	530	fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
	531
6ee59202 AL	532	str = qobject_to_json(obj);
	533	qobject_decref(obj);
	534
	535	obj = qobject_from_json(qstring_get_str(str));
	536	fail_unless(obj != NULL);
	537	fail_unless(qobject_type(obj) == QTYPE_QLIST);
	538
	539	fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
422c46a8	540	qobject_decref(obj);
6ee59202	541	QDECREF(str);
422c46a8 AL	542	}
	543	}
	544	END_TEST
	545
	546	START_TEST(simple_whitespace)
	547	{
	548	int i;
	549	struct {
	550	const char *encoded;
	551	LiteralQObject decoded;
	552	} test_cases[] = {
	553	{
	554	.encoded = " [ 43 , 42 ]",
	555	.decoded = QLIT_QLIST(((LiteralQObject[]){
	556	QLIT_QINT(43),
	557	QLIT_QINT(42),
	558	{ }
	559	})),
	560	},
	561	{
	562	.encoded = " [ 43 , { 'h' : 'b' }, [ ], 42 ]",
	563	.decoded = QLIT_QLIST(((LiteralQObject[]){
	564	QLIT_QINT(43),
	565	QLIT_QDICT(((LiteralQDictEntry[]){
	566	{ "h", QLIT_QSTR("b") },
	567	{ }})),
	568	QLIT_QLIST(((LiteralQObject[]){
	569	{ }})),
	570	QLIT_QINT(42),
	571	{ }
	572	})),
	573	},
	574	{
	575	.encoded = " [ 43 , { 'h' : 'b' , 'a' : 32 }, [ ], 42 ]",
	576	.decoded = QLIT_QLIST(((LiteralQObject[]){
	577	QLIT_QINT(43),
	578	QLIT_QDICT(((LiteralQDictEntry[]){
	579	{ "h", QLIT_QSTR("b") },
	580	{ "a", QLIT_QINT(32) },
	581	{ }})),
	582	QLIT_QLIST(((LiteralQObject[]){
	583	{ }})),
	584	QLIT_QINT(42),
	585	{ }
	586	})),
	587	},
	588	{ }
	589	};
	590
	591	for (i = 0; test_cases[i].encoded; i++) {
	592	QObject *obj;
6ee59202	593	QString *str;
422c46a8 AL	594
	595	obj = qobject_from_json(test_cases[i].encoded);
	596	fail_unless(obj != NULL);
	597	fail_unless(qobject_type(obj) == QTYPE_QLIST);
	598
	599	fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
	600
6ee59202	601	str = qobject_to_json(obj);
422c46a8	602	qobject_decref(obj);
6ee59202 AL	603
	604	obj = qobject_from_json(qstring_get_str(str));
	605	fail_unless(obj != NULL);
	606	fail_unless(qobject_type(obj) == QTYPE_QLIST);
	607
	608	fail_unless(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
	609
	610	qobject_decref(obj);
	611	QDECREF(str);
422c46a8 AL	612	}
	613	}
	614	END_TEST
	615
	616	START_TEST(simple_varargs)
	617	{
	618	QObject *embedded_obj;
	619	QObject *obj;
	620	LiteralQObject decoded = QLIT_QLIST(((LiteralQObject[]){
	621	QLIT_QINT(1),
	622	QLIT_QINT(2),
	623	QLIT_QLIST(((LiteralQObject[]){
	624	QLIT_QINT(32),
	625	QLIT_QINT(42),
	626	{}})),
	627	{}}));
	628
	629	embedded_obj = qobject_from_json("[32, 42]");
	630	fail_unless(embedded_obj != NULL);
	631
	632	obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj);
	633	fail_unless(obj != NULL);
	634
	635	fail_unless(compare_litqobj_to_qobj(&decoded, obj) == 1);
	636
	637	qobject_decref(obj);
	638	}
	639	END_TEST
	640
7f8fca7c PB	641	START_TEST(empty_input)
7f8fca7c PB	642	{
e7a06af8 JK	643	const char *empty = "";
	644
	645	QObject *obj = qobject_from_json(empty);
7f8fca7c PB	646	fail_unless(obj == NULL);
	647	}
	648	END_TEST
	649
	650	START_TEST(unterminated_string)
	651	{
	652	QObject *obj = qobject_from_json("\"abc");
	653	fail_unless(obj == NULL);
	654	}
	655	END_TEST
	656
	657	START_TEST(unterminated_sq_string)
	658	{
	659	QObject *obj = qobject_from_json("'abc");
	660	fail_unless(obj == NULL);
	661	}
	662	END_TEST
	663
	664	START_TEST(unterminated_escape)
	665	{
	666	QObject *obj = qobject_from_json("\"abc\\\"");
	667	fail_unless(obj == NULL);
	668	}
	669	END_TEST
	670
	671	START_TEST(unterminated_array)
	672	{
	673	QObject *obj = qobject_from_json("[32");
	674	fail_unless(obj == NULL);
	675	}
	676	END_TEST
	677
	678	START_TEST(unterminated_array_comma)
	679	{
	680	QObject *obj = qobject_from_json("[32,");
	681	fail_unless(obj == NULL);
	682	}
	683	END_TEST
	684
	685	START_TEST(invalid_array_comma)
	686	{
	687	QObject *obj = qobject_from_json("[32,}");
	688	fail_unless(obj == NULL);
	689	}
	690	END_TEST
	691
	692	START_TEST(unterminated_dict)
	693	{
	694	QObject *obj = qobject_from_json("{'abc':32");
	695	fail_unless(obj == NULL);
	696	}
	697	END_TEST
	698
	699	START_TEST(unterminated_dict_comma)
	700	{
	701	QObject *obj = qobject_from_json("{'abc':32,");
	702	fail_unless(obj == NULL);
	703	}
	704	END_TEST
	705
	706	#if 0
	707	START_TEST(invalid_dict_comma)
	708	{
	709	QObject *obj = qobject_from_json("{'abc':32,}");
710	fail_unless(obj == NULL);
711	}
712	END_TEST
713
714	START_TEST(unterminated_literal)
715	{
716	QObject *obj = qobject_from_json("nul");
717	fail_unless(obj == NULL);
718	}
719	END_TEST
720	#endif
721
422c46a8 AL	722	static Suite *qjson_suite(void)
	723	{
	724	Suite *suite;
	725	TCase string_literals, number_literals, *keyword_literals;
7f8fca7c	726	TCase dicts, lists, whitespace, varargs, *errors;
422c46a8 AL	727
	728	string_literals = tcase_create("String Literals");
	729	tcase_add_test(string_literals, simple_string);
	730	tcase_add_test(string_literals, escaped_string);
	731	tcase_add_test(string_literals, single_quote_string);
	732	tcase_add_test(string_literals, vararg_string);
	733
	734	number_literals = tcase_create("Number Literals");
	735	tcase_add_test(number_literals, simple_number);
	736	tcase_add_test(number_literals, float_number);
	737	tcase_add_test(number_literals, vararg_number);
	738
	739	keyword_literals = tcase_create("Keywords");
	740	tcase_add_test(keyword_literals, keyword_literal);
	741	dicts = tcase_create("Objects");
	742	tcase_add_test(dicts, simple_dict);
	743	lists = tcase_create("Lists");
	744	tcase_add_test(lists, simple_list);
	745
	746	whitespace = tcase_create("Whitespace");
	747	tcase_add_test(whitespace, simple_whitespace);
	748
	749	varargs = tcase_create("Varargs");
	750	tcase_add_test(varargs, simple_varargs);
	751
7f8fca7c PB	752	errors = tcase_create("Invalid JSON");
	753	tcase_add_test(errors, empty_input);
	754	tcase_add_test(errors, unterminated_string);
	755	tcase_add_test(errors, unterminated_escape);
	756	tcase_add_test(errors, unterminated_sq_string);
	757	tcase_add_test(errors, unterminated_array);
	758	tcase_add_test(errors, unterminated_array_comma);
	759	tcase_add_test(errors, invalid_array_comma);
	760	tcase_add_test(errors, unterminated_dict);
	761	tcase_add_test(errors, unterminated_dict_comma);
	762	#if 0
	763	/* FIXME: this print parse error messages on stderr. */
	764	tcase_add_test(errors, invalid_dict_comma);
	765	tcase_add_test(errors, unterminated_literal);
	766	#endif
	767
422c46a8 AL	768	suite = suite_create("QJSON test-suite");
	769	suite_add_tcase(suite, string_literals);
	770	suite_add_tcase(suite, number_literals);
	771	suite_add_tcase(suite, keyword_literals);
	772	suite_add_tcase(suite, dicts);
	773	suite_add_tcase(suite, lists);
	774	suite_add_tcase(suite, whitespace);
	775	suite_add_tcase(suite, varargs);
7f8fca7c	776	suite_add_tcase(suite, errors);
422c46a8 AL	777
	778	return suite;
	779	}
	780
	781	int main(void)
	782	{
	783	int nf;
	784	Suite *s;
	785	SRunner *sr;
	786
	787	s = qjson_suite();
	788	sr = srunner_create(s);
	789
	790	srunner_run_all(sr, CK_NORMAL);
	791	nf = srunner_ntests_failed(sr);
	792	srunner_free(sr);
	793
	794	return (nf == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
	795	}