908c2adc54
- rz_bits_leading_zeros - rz_json_eq - rz_json_string_eq - RZ_STR_EQ - RZ_STR_NE - rz_vector_clone_into - sdb_diff_eq
1340 lines
54 KiB
C
1340 lines
54 KiB
C
// SPDX-FileCopyrightText: 2020 thestr4ng3r <info@florianmaerkl.de>
|
|
// SPDX-FileCopyrightText: 2020 Yaroslav Stavnichiy <yarosla@gmail.com>
|
|
// SPDX-License-Identifier: LGPL-3.0-only
|
|
/* rz_json based on nxjson by Yaroslav Stavnichiy */
|
|
|
|
#include <rz_util/rz_json.h>
|
|
#include <rz_util/rz_strbuf.h>
|
|
#include "minunit.h"
|
|
|
|
typedef struct json_test_t {
|
|
const char *json;
|
|
int (*check)(RzJson *j);
|
|
} JsonTest;
|
|
|
|
static int check_expected_0(RzJson *j) {
|
|
RzJson *child_0, *child_1, *child_2;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 16, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "some-int", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 195, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "array1", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_0->children.count, 7, "array size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_1->num.u_value, 3, "integer value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_1->num.dbl_value < (5.1 + 1.0e-13) && child_1->num.dbl_value > (5.1 - 1.0e-13));
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_1->num.u_value, -7, "integer value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "nine", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_1->num.u_value, 1, "boolean value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_1->num.u_value, 0, "boolean value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "last", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "array2", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_0->children.count, 2, "array size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "/*", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "*/", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "some-bool", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_0->num.u_value, 1, "boolean value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "other-bool", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_0->num.u_value, 0, "boolean value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "some-dbl", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (-1.0e-4 + 1.0e-13) && child_0->num.dbl_value > (-1.0e-4 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "some-null", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_NULL, "null type");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "hello", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "world!", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "str1", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "//", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "str2", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\\", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "str3", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "text /*text*/ text", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "str4", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\\text\\", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "str5", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "?text?", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "str\t6\\", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "text\ntext\ttext", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "str7", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "text\xe1\x88\xb4text\xe5\x99\xb8", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "obj", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_0->children.count, 2, "object size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "object child");
|
|
mu_assert_notnull(child_1->key, "object child key not null");
|
|
mu_assert_streq(child_1->key, "KEY", "object child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "VAL", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "object child");
|
|
mu_assert_notnull(child_1->key, "object child key not null");
|
|
mu_assert_streq(child_1->key, "obj", "object child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_1->children.count, 1, "object size");
|
|
child_2 = child_1->children.first;
|
|
mu_assert_notnull(child_2, "object child");
|
|
mu_assert_notnull(child_2->key, "object child key not null");
|
|
mu_assert_streq(child_2->key, "KEY", "object child key");
|
|
mu_assert_eq(child_2->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_2->str_value, "VAL", "string value");
|
|
child_2 = child_2->next;
|
|
mu_assert_null(child_2, "last child null");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_4(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 4, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 1, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 2, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 3, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "last", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_5(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(j->str_value, "string value", "string value");
|
|
mu_assert_streq_free(rz_json_as_string(j, true), "string value", "string as string");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_6(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(j->num.u_value, 1, "boolean value");
|
|
mu_assert_streq_free(rz_json_as_string(j, true), "true", "boolean as string");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_7(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
j->num.dbl_value < (-1.0e-2 + 1.0e-13) && j->num.dbl_value > (-1.0e-2 - 1.0e-13));
|
|
mu_assert_streq_free(rz_json_as_string(j, true), "-0.010000", "double as string");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_8(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_NULL, "null type");
|
|
mu_assert_streq_free(rz_json_as_string(j, true), "null", "null as string");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_9(RzJson *j) {
|
|
RzJson *child_0, *child_1, *child_2, *child_3, *child_4, *child_5;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 1, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "glossary", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_0->children.count, 2, "object size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "object child");
|
|
mu_assert_notnull(child_1->key, "object child key not null");
|
|
mu_assert_streq(child_1->key, "title", "object child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "example glossary", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "object child");
|
|
mu_assert_notnull(child_1->key, "object child key not null");
|
|
mu_assert_streq(child_1->key, "GlossDiv", "object child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_1->children.count, 2, "object size");
|
|
child_2 = child_1->children.first;
|
|
mu_assert_notnull(child_2, "object child");
|
|
mu_assert_notnull(child_2->key, "object child key not null");
|
|
mu_assert_streq(child_2->key, "title", "object child key");
|
|
mu_assert_eq(child_2->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_2->str_value, "S", "string value");
|
|
child_2 = child_2->next;
|
|
mu_assert_notnull(child_2, "object child");
|
|
mu_assert_notnull(child_2->key, "object child key not null");
|
|
mu_assert_streq(child_2->key, "GlossList", "object child key");
|
|
mu_assert_eq(child_2->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_2->children.count, 1, "array size");
|
|
child_3 = child_2->children.first;
|
|
mu_assert_notnull(child_3, "array child");
|
|
mu_assert_null(child_3->key, "array child key");
|
|
mu_assert_eq(child_3->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_3->children.count, 7, "object size");
|
|
child_4 = child_3->children.first;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "ID", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "SGML", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "SortAs", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "SGML", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "GlossTerm", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "Standard Generalized Markup Language", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "Acronym", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "SGML", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "Abbrev", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "ISO 8879:1986", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "GlossDef", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "A meta-markup language, used to create markup languages such as DocBoo"
|
|
"k.",
|
|
"string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "GlossSeeAlso", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_4->children.count, 3, "array size");
|
|
child_5 = child_4->children.first;
|
|
mu_assert_notnull(child_5, "array child");
|
|
mu_assert_null(child_5->key, "array child key");
|
|
mu_assert_eq(child_5->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_5->str_value, "GML", "string value");
|
|
child_5 = child_5->next;
|
|
mu_assert_notnull(child_5, "array child");
|
|
mu_assert_null(child_5->key, "array child key");
|
|
mu_assert_eq(child_5->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_5->str_value, "XML", "string value");
|
|
child_5 = child_5->next;
|
|
mu_assert_notnull(child_5, "array child");
|
|
mu_assert_null(child_5->key, "array child key");
|
|
mu_assert_eq(child_5->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_5->str_value, "markup", "string value");
|
|
child_5 = child_5->next;
|
|
mu_assert_null(child_5, "last child null");
|
|
child_4 = child_4->next;
|
|
mu_assert_null(child_4, "last child null");
|
|
child_3 = child_3->next;
|
|
mu_assert_null(child_3, "last child null");
|
|
child_2 = child_2->next;
|
|
mu_assert_null(child_2, "last child null");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_10(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 3, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "this", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "is", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "really", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "simple", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "json", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "right?", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_11(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(j->num.u_value, 0, "boolean value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_13(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(j->num.u_value, 1221, "integer value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_14(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 0, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_19(RzJson *j) {
|
|
RzJson *child_0, *child_1, *child_2;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 9, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "foo", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "bar", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "baz", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_0->num.u_value, 1, "boolean value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_0->num.u_value, 0, "boolean value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_NULL, "null type");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_0->children.count, 1, "object size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "object child");
|
|
mu_assert_notnull(child_1->key, "object child key not null");
|
|
mu_assert_streq(child_1->key, "key", "object child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "value", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_0->children.count, 4, "array size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_NULL, "null type");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_NULL, "null type");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_NULL, "null type");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_1->children.count, 0, "array size");
|
|
child_2 = child_1->children.first;
|
|
mu_assert_null(child_2, "last child null");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\n\x0d\\", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_22(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(j->str_value, "\xf0\x90\x8c\x82M\xd0\xb0\xe4\xba\x8c\xf0\x90\x8c\x82", "string value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_23(RzJson *j) {
|
|
RzJson *child_0, *child_1, *child_2, *child_3, *child_4, *child_5;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 1, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "glossary", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_0->children.count, 2, "object size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "object child");
|
|
mu_assert_notnull(child_1->key, "object child key not null");
|
|
mu_assert_streq(child_1->key, "title", "object child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "example glossary", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "object child");
|
|
mu_assert_notnull(child_1->key, "object child key not null");
|
|
mu_assert_streq(child_1->key, "GlossDiv", "object child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_1->children.count, 2, "object size");
|
|
child_2 = child_1->children.first;
|
|
mu_assert_notnull(child_2, "object child");
|
|
mu_assert_notnull(child_2->key, "object child key not null");
|
|
mu_assert_streq(child_2->key, "title", "object child key");
|
|
mu_assert_eq(child_2->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_2->str_value, "S", "string value");
|
|
child_2 = child_2->next;
|
|
mu_assert_notnull(child_2, "object child");
|
|
mu_assert_notnull(child_2->key, "object child key not null");
|
|
mu_assert_streq(child_2->key, "GlossList", "object child key");
|
|
mu_assert_eq(child_2->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_2->children.count, 1, "array size");
|
|
child_3 = child_2->children.first;
|
|
mu_assert_notnull(child_3, "array child");
|
|
mu_assert_null(child_3->key, "array child key");
|
|
mu_assert_eq(child_3->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(child_3->children.count, 7, "object size");
|
|
child_4 = child_3->children.first;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "ID", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "SGML", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "SortAs", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "SGML", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "GlossTerm", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "Standard Generalized Markup Language", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "Acronym", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "SGML", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "Abbrev", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "ISO 8879:1986", "string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "GlossDef", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_4->str_value, "A meta-markup language, used to create markup languages such as DocBoo"
|
|
"k.",
|
|
"string value");
|
|
child_4 = child_4->next;
|
|
mu_assert_notnull(child_4, "object child");
|
|
mu_assert_notnull(child_4->key, "object child key not null");
|
|
mu_assert_streq(child_4->key, "GlossSeeAlso", "object child key");
|
|
mu_assert_eq(child_4->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_4->children.count, 3, "array size");
|
|
child_5 = child_4->children.first;
|
|
mu_assert_notnull(child_5, "array child");
|
|
mu_assert_null(child_5->key, "array child key");
|
|
mu_assert_eq(child_5->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_5->str_value, "GML", "string value");
|
|
child_5 = child_5->next;
|
|
mu_assert_notnull(child_5, "array child");
|
|
mu_assert_null(child_5->key, "array child key");
|
|
mu_assert_eq(child_5->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_5->str_value, "XML", "string value");
|
|
child_5 = child_5->next;
|
|
mu_assert_notnull(child_5, "array child");
|
|
mu_assert_null(child_5->key, "array child key");
|
|
mu_assert_eq(child_5->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_5->str_value, "markup", "string value");
|
|
child_5 = child_5->next;
|
|
mu_assert_null(child_5, "last child null");
|
|
child_4 = child_4->next;
|
|
mu_assert_null(child_4, "last child null");
|
|
child_3 = child_3->next;
|
|
mu_assert_null(child_3, "last child null");
|
|
child_2 = child_2->next;
|
|
mu_assert_null(child_2, "last child null");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_24(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 5, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (1.1999999999999999e-4 + 1.0e-13) && child_0->num.dbl_value > (1.1999999999999999e-4 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (6.0e-6 + 1.0e-13) && child_0->num.dbl_value > (6.0e-6 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (6.0e-6 + 1.0e-13) && child_0->num.dbl_value > (6.0e-6 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (1.0e-6 + 1.0e-13) && child_0->num.dbl_value > (1.0e-6 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (1.0e-6 + 1.0e-13) && child_0->num.dbl_value > (1.0e-6 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_25(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 4, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (10.0 + 1.0e-13) && child_0->num.dbl_value > (10.0 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (10.0 + 1.0e-13) && child_0->num.dbl_value > (10.0 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (3.141569 + 1.0e-13) && child_0->num.dbl_value > (3.141569 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
child_0->num.dbl_value < (1000.0 + 1.0e-13) && child_0->num.dbl_value > (1000.0 - 1.0e-13));
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_26(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(j->str_value, "", "string value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_27(RzJson *j) {
|
|
RzJson *child_0, *child_1;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 2, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "some", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "utf-8", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "strings", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(child_0->children.count, 3, "array size");
|
|
child_1 = child_0->children.first;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "\xd0\xad\xd1\x82\xd0\xbe", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "\xd1\x80\xd1\x83\xd1\x81\xd1\x81\xd0\xba\xd0\xb8\xd0\xb9", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_notnull(child_1, "array child");
|
|
mu_assert_null(child_1->key, "array child key");
|
|
mu_assert_eq(child_1->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_1->str_value, "\xd1\x82\xd0\xb5\xd0\xba\xd1\x81\xd1\x82", "string value");
|
|
child_1 = child_1->next;
|
|
mu_assert_null(child_1, "last child null");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_28(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(j->num.u_value, 2009, "integer value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_29(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 1, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "U+10ABCD", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\xf4\x8a\xaf\x8d", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_30(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 11, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 1, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 2, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 3, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 4, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 5, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 6, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 7, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 123456789, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, -123456789, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 2147483647, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, -2147483647, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_31(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 1, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\xd0\x94\xd0\xb0 \xd0\x9c\xd1 \xd0\x95\xd0\xb1\xd0\xb0 \xd0\x9c\xd0\xb0\xd0\xb9\xd0\xba\xd0\xb0\xd1\x82\xd0\xb0", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_32(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 1, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "bad thing", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(child_0->num.u_value, 10, "integer value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_35(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
j->num.dbl_value < (1000.0 + 1.0e-13) && j->num.dbl_value > (1000.0 - 1.0e-13));
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_36(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_DOUBLE, "double type");
|
|
mu_assert("double value",
|
|
j->num.dbl_value < (10.0 + 1.0e-13) && j->num.dbl_value > (10.0 - 1.0e-13));
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_37(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
mu_assert_eq(j->children.count, 3, "object size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "boolean, true", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_0->num.u_value, 1, "boolean value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "boolean, false", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_BOOLEAN, "boolean type");
|
|
mu_assert_eq(child_0->num.u_value, 0, "boolean value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "object child");
|
|
mu_assert_notnull(child_0->key, "object child key not null");
|
|
mu_assert_streq(child_0->key, "null", "object child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_NULL, "null type");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_38(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 1, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\n foo / bar \x0d\x0c\\\xef\xbf\xbf\t\x08\"\\ and you can't escape thi"
|
|
"\\s",
|
|
"string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_39(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 3, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\n foo / bar \x0d\x0c\\\xef\xbf\xbf\t\x08\"\\", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\"and this string has an escape at the beginning", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "and this string has no escapes", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_40(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(j->str_value, "la di dah. this is a string, and I can do this, \n, but not this\n", "string value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_43(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(j->num.u_value, 123, "integer value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_45(RzJson *j) {
|
|
RzJson *child_0;
|
|
mu_assert_eq(j->type, RZ_JSON_ARRAY, "array type");
|
|
mu_assert_eq(j->children.count, 4, "array size");
|
|
child_0 = j->children.first;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\xd0\x94\xd0\xb0", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\xd0\x9c\xd1\x83", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\xd0\x95\xd0\xb1\xd0\xb0", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_notnull(child_0, "array child");
|
|
mu_assert_null(child_0->key, "array child key");
|
|
mu_assert_eq(child_0->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(child_0->str_value, "\xd0\x9c\xd0\xb0\xd0\xb9\xd0\xba\xd0\xb0\xd1\x82\xd0\xb0", "string value");
|
|
child_0 = child_0->next;
|
|
mu_assert_null(child_0, "last child null");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_46(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(j->str_value, "foobar", "string value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_48(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_STRING, "string type");
|
|
mu_assert_streq(j->str_value, "\xd0\x9f\xd1\x80\xd0\xbe\xd0\xb2\xd0\xb5\xd1\x80\xd0\xba\xd0\xb0", "string value");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_57(RzJson *j) {
|
|
const RzJson *nonexist = rz_json_get_path(j, "[0].nonexist");
|
|
mu_assert_null(nonexist, "nonexisting object null");
|
|
|
|
// try a few invalid paths
|
|
mu_assert_null(rz_json_get_path(j, "[].things[0].path"), "invalid path [].things[0].path");
|
|
mu_assert_null(rz_json_get_path(j, "[0].things[0]."), "invalid path [0].things[0].");
|
|
mu_assert_null(rz_json_get_path(j, "[0].things[0]."), "invalid path [0].things[0].");
|
|
|
|
static const char *paths[] = {
|
|
"[0].things[0].path",
|
|
"[0].things[1].path",
|
|
"[0].things[2].path",
|
|
"[1].things[0].path",
|
|
"[1].things[0].child.path",
|
|
"[1].things[1].path",
|
|
"[1].things[1].child.path",
|
|
};
|
|
for (int i = 1; i < sizeof(paths) / sizeof(paths[0]); i++) {
|
|
const char *path = paths[i];
|
|
const RzJson *found = rz_json_get_path(j, path);
|
|
mu_assert_notnull(found, path);
|
|
mu_assert_eq(found->type, RZ_JSON_STRING, "type is string");
|
|
mu_assert_streq(found->str_value, path, "correct object found");
|
|
}
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_58(RzJson *j) {
|
|
char *json_str =
|
|
"{\"some-int\":195,\"array1\":[3,5.100000,-7,\"nine\",true,false,\"last\"],"
|
|
"\"array2\":[\"/*\",\"*/\"],\"some-bool\":true,\"other-bool\":false,"
|
|
"\"some-dbl\":-0.000100,\"some-null\":null,\"hello\":\"world!\","
|
|
"\"str1\":\"//\",\"str2\":\"\\\\\","
|
|
"\"str3\":\"text /*text*/ text\",\"str4\":\"\\\\text\\\\\","
|
|
"\"str5\":\"\\\\?text\\\\?\",\"str\\t6\\\\\":\"text\\ntext\\ttext\","
|
|
"\"obj\":{\"KEY\":\"VAL\",\"obj\":{\"KEY\":\"VAL\"}}}";
|
|
char *jsonstr = rz_json_as_string(j, true);
|
|
mu_assert_streq_free(jsonstr, json_str, "RzJson as string");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_59(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_INTEGER, "integer type");
|
|
mu_assert_eq(j->num.u_value, 42, "integer value");
|
|
mu_assert_streq_free(rz_json_as_string(j, true), "42", "integer as string");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
static int check_expected_60(RzJson *j) {
|
|
mu_assert_eq(j->type, RZ_JSON_OBJECT, "object type");
|
|
const RzJson *kv = rz_json_get_path(j, ".bla");
|
|
mu_assert_streq(kv->str_value, "foo", "string value");
|
|
mu_assert_streq_free(rz_json_as_string(kv, true), "\"bla\":\"foo\"", "key-value as string");
|
|
mu_assert_streq_free(rz_json_as_string(kv, false), "foo", "value as string");
|
|
return MU_PASSED;
|
|
}
|
|
|
|
JsonTest tests[] = {
|
|
{ // 0
|
|
" {\n \"some-int\": 195,\n \"array1\": [ 3, 5.1, -7, \"nin"
|
|
"e\", /*11,*/ true, false, \"last\" ],\n \"array2\":[\"/*\",\"*/\""
|
|
"],\n \"some-bool\": true,\n \"other-bool\": false,\n \""
|
|
"some-dbl\": -1e-4,\n \"some-null\": null,\n \"hello\": \"wor"
|
|
"ld!\",\n \"str1\": \"//\",\n \"str2\": \"\\\\\",\n \"st"
|
|
"r3\": \"text /*text*/ text\",\n \"str4\": \"\\\\text\\\\\",\n "
|
|
" \"str5\": \"\\?text\\?\",\n \"str\\t6\\\\\": \"text\\ntext\\tte"
|
|
"xt\",\n \"str7\": \"text\\u1234text\\u5678\",\n //\"other\":"
|
|
" \"/OTHER/\",\n \"obj\": {\"KEY\":\"VAL\", \"obj\":{\"KEY\":\"VAL"
|
|
"\"}}\n }\n",
|
|
check_expected_0 },
|
|
{ // 1
|
|
"\"unterminated string",
|
|
NULL },
|
|
{ // 2
|
|
"{\"key\":\"val\"",
|
|
NULL },
|
|
{ // 3
|
|
"[ \"unterminated \\string\\\" ]\n",
|
|
NULL },
|
|
{ // 4
|
|
"// array\n[1,2,3,\"last\"]",
|
|
check_expected_4 },
|
|
{ // 5
|
|
"\"string value\"\n",
|
|
check_expected_5 },
|
|
{ // 6
|
|
"true",
|
|
check_expected_6 },
|
|
{ // 7
|
|
"-1e-2",
|
|
check_expected_7 },
|
|
{ // 8
|
|
"null",
|
|
check_expected_8 },
|
|
{ // 9
|
|
"{ \"glossary\": { /* you */ \"title\": /**/ \"example glossary\", /*sh"
|
|
"ould*/\"GlossDiv\": { \"title\": /*never*/\"S\", /*ever*/\"GlossList\""
|
|
": [ { \"ID\": \"SGML\", \"SortAs\": \"SGML\", \"GlossTerm\": \"Standar"
|
|
"d Generalized Markup Language\", \"Acronym\": \"SGML\", \"Abbrev\": \""
|
|
"ISO 8879:1986\", \"GlossDef\": \"A meta-markup language, used to creat"
|
|
"e markup languages such as DocBook.\", /*see*/\"GlossSeeAlso\":/*comin"
|
|
"g*/[/*out*/\"GML\"/*of*/,/*the*/\"XML\"/*parser!*/, \"markup\"] /*hey*"
|
|
"/}/*ho*/]/*hey*/}/*ho*/} } // and the parser won't even get this far,"
|
|
" so chill. /* hah!\n",
|
|
check_expected_9 },
|
|
{ // 10
|
|
"{\n \"this\": \"is\", // ignore this\n \"really\": \"simple\",\n /*"
|
|
" ignore\nthis\ntoo * / \n** //\n(/\n******/\n \"json\": \"right?\"\n}"
|
|
"\n",
|
|
check_expected_10 },
|
|
{ // 11
|
|
"falsex\n",
|
|
check_expected_11 },
|
|
{ // 12
|
|
"{ \"123\":\n",
|
|
NULL },
|
|
{ // 13
|
|
"1221 21\n",
|
|
check_expected_13 },
|
|
{ // 14
|
|
"\n{}\n{}\n",
|
|
check_expected_14 },
|
|
{ // 15
|
|
"[",
|
|
NULL },
|
|
{ // 16
|
|
"{\n",
|
|
NULL },
|
|
{ // 17
|
|
"[ \"foo\", \"bar\"\n",
|
|
NULL },
|
|
{ // 18
|
|
"]\n",
|
|
NULL },
|
|
{ // 19
|
|
"[\"foo\",\n \"bar\", \"baz\",\n true,false,null,{\"key\":\"value\"},\n"
|
|
" [null,null,null,[]],\n \"\\n\\r\\\\\"\n]\n",
|
|
check_expected_19 },
|
|
{ // 20
|
|
"[ 100000000000000000000000000000, -100000000000000000000000000000, \"e"
|
|
"nd\" ]\n",
|
|
NULL },
|
|
{ // 21
|
|
"[\"this\",\"is\",\"what\",\"should\",\"be\",\n \"a happy bit of json\""
|
|
",\n \"but someone, misspelled \\\"true\\\"\", ture,\n \"who says JSON "
|
|
"is easy for humans to generate?\"]\n",
|
|
NULL },
|
|
{ // 22
|
|
"/* This string contains Unicode surrogate \xf0\x90\x8c\x82 both in UTF"
|
|
"-8 and escaped */ \"\xf0\x90\x8c\x82\\u004d\\u0430\\u4e8c\\ud800\\udf0"
|
|
"2\"\n",
|
|
check_expected_22 },
|
|
{ // 23
|
|
"{ \"glossary\": { \"title\": \"example glossary\", \"GlossDiv\": { \"t"
|
|
"itle\": \"S\", \"GlossList\": [ { \"ID\": \"SGML\", \"SortAs\": \"SGML"
|
|
"\", \"GlossTerm\": \"Standard Generalized Markup Language\", \"Acronym"
|
|
"\": \"SGML\", \"Abbrev\": \"ISO 8879:1986\", \"GlossDef\": \"A meta-ma"
|
|
"rkup language, used to create markup languages such as DocBook.\", \"G"
|
|
"lossSeeAlso\": [\"GML\", \"XML\", \"markup\"] } ] } } }\n",
|
|
check_expected_23 },
|
|
{ // 24
|
|
"[0.00011999999999999999, 6E-06, 6E-06, 1E-06, 1E-06]\n",
|
|
check_expected_24 },
|
|
{ // 25
|
|
"[ 0.1e2, 1e1, 3.141569, 10000000000000e-10]\n",
|
|
check_expected_25 },
|
|
{ // 26
|
|
"\"\"\n",
|
|
check_expected_26 },
|
|
{ // 27
|
|
"{\"some\":\"utf-8\", \"strings\":[\"\xd0\xad\xd1\x82\xd0\xbe\",\"\xd1"
|
|
"\x80\xd1\x83\xd1\x81\xd1\x81\xd0\xba\xd0\xb8\xd0\xb9\",\"\xd1\x82\xd0"
|
|
"\xb5\xd0\xba\xd1\x81\xd1\x82\"]}",
|
|
check_expected_27 },
|
|
{ // 28
|
|
"2009-10-20@20:38:21.539575\n",
|
|
check_expected_28 },
|
|
{ // 29
|
|
"{ \"U+10ABCD\": \"\xf4\x8a\xaf\x8d\" }\n\n",
|
|
check_expected_29 },
|
|
{ // 30
|
|
"[ 1,2,3,4,5,6,7,\n 123456789 , -123456789,\n 2147483647, -2147483647"
|
|
" ]\n",
|
|
check_expected_30 },
|
|
{ // 31
|
|
"/* invalid utf-8 */ [\"\xd0\x94\xd0\xb0 \xd0\x9c\xd1 \xd0\x95\xd0\xb1"
|
|
"\xd0\xb0 \xd0\x9c\xd0\xb0\xd0\xb9\xd0\xba\xd0\xb0\xd1\x82\xd0\xb0\"]\n",
|
|
check_expected_31 },
|
|
{ // 32
|
|
"{ \"bad thing\": 010 }\n",
|
|
check_expected_32 },
|
|
{ // 33
|
|
"[\n\t\t\"foo\", true,\n\t\ttrue, \"blue\",\n\t\t\"baby where are you?"
|
|
"\", \"oh boo hoo!\",\n - \n]\n\n",
|
|
NULL },
|
|
{ // 34
|
|
"}\n",
|
|
NULL },
|
|
{ // 35
|
|
"10.e2\n",
|
|
check_expected_35 },
|
|
{ // 36
|
|
"10e\n",
|
|
check_expected_36 },
|
|
{ // 37
|
|
"{\n\t\"boolean, true\": true,\n\t\"boolean, false\": false,\n\t\"null"
|
|
"\": null\n}\n",
|
|
check_expected_37 },
|
|
{ // 38
|
|
"[\"\\n foo \\/ bar \\r\\f\\\\\\uffff\\t\\b\\\"\\\\ and you can't escap"
|
|
"e thi\\s\"]\n",
|
|
check_expected_38 },
|
|
{ // 39
|
|
"[\"\\n foo \\/ bar \\r\\f\\\\\\uffff\\t\\b\\\"\\\\\",\n \"\\\"and this"
|
|
" string has an escape at the beginning\",\n \"and this string has no e"
|
|
"scapes\" ]\n",
|
|
check_expected_39 },
|
|
{ // 40
|
|
"\"la di dah. this is a string, and I can do this, \\n, but not this\n"
|
|
"\"\n",
|
|
check_expected_40 },
|
|
{ // 41
|
|
"/*",
|
|
NULL },
|
|
{ // 42
|
|
"/*abc /",
|
|
NULL },
|
|
{ // 43
|
|
"/*/\\*/ 123",
|
|
check_expected_43 },
|
|
{ // 44
|
|
"/*/ 123",
|
|
NULL },
|
|
{ // 45
|
|
"[\"\\u0414\\u0430\",\n \"\\u041c\\u0443\",\n \"\\u0415\\u0431\\u0430\""
|
|
",\n \"\\u041c\\u0430\\u0439\\u043a\\u0430\\u0442\\u0430\"]\n",
|
|
check_expected_45 },
|
|
{ // 46
|
|
"\"\\u0066\\u006f\\u006f\\u0062\\u0061\\u0072\"\n",
|
|
check_expected_46 },
|
|
{ // 47
|
|
"/* invalid unicode surrogate */ \"\\ud800\"\n",
|
|
NULL },
|
|
{ // 48
|
|
"\"\\u041F\\u0440\\u043E\\u0432\\u0435\\u0440\\u043a\\u0430\"",
|
|
check_expected_48 },
|
|
{ // 49
|
|
"\"\\u04FG\"",
|
|
NULL },
|
|
{ // 50
|
|
"\"\\u0",
|
|
NULL },
|
|
{ // 51
|
|
"\"\\u04\"",
|
|
NULL },
|
|
{ // 52
|
|
"{,}\n",
|
|
NULL },
|
|
{ // 53
|
|
"[,]\n",
|
|
NULL },
|
|
{ // 54
|
|
"[{}{}]\n",
|
|
NULL },
|
|
{ // 55
|
|
"[42,/*nope*/,1337]\n",
|
|
NULL },
|
|
{ // 56
|
|
"{\"hello\":42,/*stuff*/,\"invalid\":123}\n",
|
|
NULL },
|
|
{ // 57
|
|
"["
|
|
"{\"things\": ["
|
|
" {\"path\": \"[0].things[0].path\"},"
|
|
" {\"path\": \"[0].things[1].path\"},"
|
|
" {\"path\": \"[0].things[2].path\"}"
|
|
"]},"
|
|
"{\"things\": ["
|
|
" {\"path\": \"[1].things[0].path\","
|
|
" \"child\": {\"path\": \"[1].things[0].child.path\"}"
|
|
" },"
|
|
" {\"path\": \"[1].things[1].path\","
|
|
" \"child\": {\"path\": \"[1].things[1].child.path\"}"
|
|
" }"
|
|
"]}"
|
|
"]",
|
|
check_expected_57 },
|
|
{ // 58
|
|
" {\n \"some-int\": 195,\n \"array1\": [ 3, 5.1, -7, \"nin"
|
|
"e\", /*11,*/ true, false, \"last\" ],\n \"array2\":[\"/*\",\"*/\""
|
|
"],\n \"some-bool\": true,\n \"other-bool\": false,\n \""
|
|
"some-dbl\": -1e-4,\n \"some-null\": null,\n \"hello\": \"wor"
|
|
"ld!\",\n \"str1\": \"//\",\n \"str2\": \"\\\\\",\n \"st"
|
|
"r3\": \"text /*text*/ text\",\n \"str4\": \"\\\\text\\\\\",\n "
|
|
" \"str5\": \"\\?text\\?\",\n \"str\\t6\\\\\": \"text\\ntext\\tte"
|
|
"xt\",\n //\"other\":"
|
|
" \"/OTHER/\",\n \"obj\": {\"KEY\":\"VAL\", \"obj\":{\"KEY\":\"VAL"
|
|
"\"}}\n }\n",
|
|
check_expected_58 },
|
|
{ // 59
|
|
"42",
|
|
check_expected_59 },
|
|
{ // 60
|
|
"{\n \"bla\": \"foo\"\n}\n",
|
|
check_expected_60 },
|
|
};
|
|
|
|
static int test_json(int test_number, char *input, int (*check)(RzJson *j)) {
|
|
RzJson *json = rz_json_parse(input);
|
|
if (!check) {
|
|
mu_assert_null(json, "parse failure expected");
|
|
} else {
|
|
mu_assert_notnull(json, "parse failed");
|
|
if (!check(json)) {
|
|
return MU_ERR;
|
|
}
|
|
rz_json_free(json);
|
|
}
|
|
mu_end;
|
|
}
|
|
|
|
static int test_json_eq() {
|
|
char *input1 = strdup("{\"foo\": \"bar\"}");
|
|
char *input2 = strdup("{\"foo\": \"bar\"}");
|
|
RzJson *json = rz_json_parse(input1);
|
|
RzJson *json2 = rz_json_parse(input2);
|
|
mu_assert_notnull(json, "parse failed");
|
|
mu_assert_notnull(json2, "parse failed");
|
|
mu_assert("jsons are not equal", rz_json_eq(json, json2));
|
|
free(input1);
|
|
free(input2);
|
|
rz_json_free(json);
|
|
rz_json_free(json2);
|
|
|
|
input1 = strdup("{\"foo\": \"bar\"}");
|
|
input2 = strdup("{\"foo\": \"baz\"}");
|
|
json = rz_json_parse(input1);
|
|
json2 = rz_json_parse(input2);
|
|
mu_assert_notnull(json, "parse failed");
|
|
mu_assert_notnull(json2, "parse failed");
|
|
mu_assert("jsons are equal", !rz_json_eq(json, json2));
|
|
free(input1);
|
|
free(input2);
|
|
rz_json_free(json);
|
|
rz_json_free(json2);
|
|
|
|
mu_assert("invalid JSON is not eq", !rz_json_string_eq("", ""));
|
|
mu_assert("JSON string is eq", rz_json_string_eq("{\"foo\": \"bar\",\n \"x\":1}", "{\"foo\": \"bar\", \"x\": 1}"));
|
|
mu_assert("JSON string is not eq", !rz_json_string_eq("{\"foo\": \"bar\",\n \"x\":1}", "{\"foo\": \"baz\", \"x\": 2}"));
|
|
mu_end;
|
|
}
|
|
|
|
static int all_tests(void) {
|
|
size_t i;
|
|
for (i = 1; i < sizeof(tests) / sizeof(tests[0]); i++) {
|
|
char *input = strdup(tests[i].json);
|
|
char testname[256];
|
|
snprintf(testname, sizeof(testname), "test_json (%u)", (unsigned int)i);
|
|
mu_run_test_named(test_json, testname, i, input, tests[i].check);
|
|
free(input);
|
|
}
|
|
mu_run_test(test_json_eq);
|
|
return tests_passed != tests_run;
|
|
}
|
|
|
|
mu_main(all_tests)
|