[qemu.git] / check-qjson.c

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