1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
6 #include "alloc-util.h"
10 #include "json-internal.h"
12 #include "string-util.h"
17 static void test_tokenizer(const char *data
, ...) {
18 unsigned line
= 0, column
= 0;
22 _cleanup_free_
char *cdata
;
23 assert_se(cdata
= cescape(data
));
24 log_info("/* %s data=\"%s\" */", __func__
, cdata
);
29 unsigned token_line
, token_column
;
30 _cleanup_free_
char *str
= NULL
;
31 JsonValue v
= JSON_VALUE_NULL
;
34 t
= json_tokenize(&data
, &str
, &v
, &token_line
, &token_column
, &state
, &line
, &column
);
39 if (t
== JSON_TOKEN_END
|| t
< 0)
42 else if (t
== JSON_TOKEN_STRING
) {
45 nn
= va_arg(ap
, const char *);
46 assert_se(streq_ptr(nn
, str
));
48 } else if (t
== JSON_TOKEN_REAL
) {
51 d
= va_arg(ap
, double);
53 assert_se(fabsl(d
- v
.real
) < 1e-10 ||
54 fabsl((d
- v
.real
) / v
.real
) < 1e-10);
56 } else if (t
== JSON_TOKEN_INTEGER
) {
59 i
= va_arg(ap
, int64_t);
60 assert_se(i
== v
.integer
);
62 } else if (t
== JSON_TOKEN_UNSIGNED
) {
65 u
= va_arg(ap
, uint64_t);
66 assert_se(u
== v
.unsig
);
68 } else if (t
== JSON_TOKEN_BOOLEAN
) {
72 assert_se(b
== v
.boolean
);
79 typedef void (*Test
)(JsonVariant
*);
81 static void test_variant(const char *data
, Test test
) {
82 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
, *w
= NULL
;
83 _cleanup_free_
char *s
= NULL
;
86 _cleanup_free_
char *cdata
;
87 assert_se(cdata
= cescape(data
));
88 log_info("/* %s data=\"%s\" */", __func__
, cdata
);
90 r
= json_parse(data
, 0, &v
, NULL
, NULL
);
94 r
= json_variant_format(v
, 0, &s
);
97 assert_se((size_t) r
== strlen(s
));
99 log_info("formatted normally: %s\n", s
);
101 r
= json_parse(data
, JSON_PARSE_SENSITIVE
, &w
, NULL
, NULL
);
104 assert_se(json_variant_has_type(v
, json_variant_type(w
)));
105 assert_se(json_variant_has_type(w
, json_variant_type(v
)));
106 assert_se(json_variant_equal(v
, w
));
109 w
= json_variant_unref(w
);
111 r
= json_variant_format(v
, JSON_FORMAT_PRETTY
, &s
);
114 assert_se((size_t) r
== strlen(s
));
116 log_info("formatted prettily:\n%s", s
);
118 r
= json_parse(data
, 0, &w
, NULL
, NULL
);
122 assert_se(json_variant_has_type(v
, json_variant_type(w
)));
123 assert_se(json_variant_has_type(w
, json_variant_type(v
)));
124 assert_se(json_variant_equal(v
, w
));
127 r
= json_variant_format(v
, JSON_FORMAT_COLOR
, &s
);
130 assert_se((size_t) r
== strlen(s
));
131 printf("Normal with color: %s\n", s
);
134 r
= json_variant_format(v
, JSON_FORMAT_COLOR
|JSON_FORMAT_PRETTY
, &s
);
137 assert_se((size_t) r
== strlen(s
));
138 printf("Pretty with color:\n%s\n", s
);
144 static void test_1(JsonVariant
*v
) {
148 log_info("/* %s */", __func__
);
150 /* 3 keys + 3 values */
151 assert_se(json_variant_elements(v
) == 6);
154 p
= json_variant_by_key(v
, "k");
155 assert_se(p
&& json_variant_type(p
) == JSON_VARIANT_STRING
);
158 assert_se(streq(json_variant_string(p
), "v"));
161 p
= json_variant_by_key(v
, "foo");
162 assert_se(p
&& json_variant_type(p
) == JSON_VARIANT_ARRAY
&& json_variant_elements(p
) == 3);
164 /* check foo[0] = 1, foo[1] = 2, foo[2] = 3 */
165 for (i
= 0; i
< 3; ++i
) {
166 q
= json_variant_by_index(p
, i
);
167 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_UNSIGNED
&& json_variant_unsigned(q
) == (i
+1));
168 assert_se(q
&& json_variant_has_type(q
, JSON_VARIANT_INTEGER
) && json_variant_integer(q
) == (i
+1));
172 p
= json_variant_by_key(v
, "bar");
173 assert_se(p
&& json_variant_type(p
) == JSON_VARIANT_OBJECT
&& json_variant_elements(p
) == 2);
176 q
= json_variant_by_key(p
, "zap");
177 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_NULL
);
180 static void test_2(JsonVariant
*v
) {
183 log_info("/* %s */", __func__
);
185 /* 2 keys + 2 values */
186 assert_se(json_variant_elements(v
) == 4);
189 p
= json_variant_by_key(v
, "mutant");
190 assert_se(p
&& json_variant_type(p
) == JSON_VARIANT_ARRAY
&& json_variant_elements(p
) == 4);
193 q
= json_variant_by_index(p
, 0);
194 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_UNSIGNED
&& json_variant_unsigned(q
) == 1);
195 assert_se(q
&& json_variant_has_type(q
, JSON_VARIANT_INTEGER
) && json_variant_integer(q
) == 1);
197 /* mutant[1] == null */
198 q
= json_variant_by_index(p
, 1);
199 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_NULL
);
201 /* mutant[2] == "1" */
202 q
= json_variant_by_index(p
, 2);
203 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_STRING
&& streq(json_variant_string(q
), "1"));
205 /* mutant[3] == JSON_VARIANT_OBJECT */
206 q
= json_variant_by_index(p
, 3);
207 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_OBJECT
&& json_variant_elements(q
) == 2);
210 p
= json_variant_by_key(q
, "1");
211 assert_se(p
&& json_variant_type(p
) == JSON_VARIANT_ARRAY
&& json_variant_elements(p
) == 2);
214 q
= json_variant_by_index(p
, 0);
215 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_UNSIGNED
&& json_variant_unsigned(q
) == 1);
216 assert_se(q
&& json_variant_has_type(q
, JSON_VARIANT_INTEGER
) && json_variant_integer(q
) == 1);
219 q
= json_variant_by_index(p
, 1);
220 assert_se(q
&& json_variant_type(q
) == JSON_VARIANT_STRING
&& streq(json_variant_string(q
), "1"));
222 /* has thisisaverylongproperty */
223 p
= json_variant_by_key(v
, "thisisaverylongproperty");
224 assert_se(p
&& json_variant_type(p
) == JSON_VARIANT_REAL
&& fabsl(json_variant_real(p
) - 1.27) < 0.001);
227 static void test_zeroes(JsonVariant
*v
) {
228 /* Make sure zero is how we expect it. */
229 log_info("/* %s */", __func__
);
231 assert_se(json_variant_elements(v
) == 13);
233 for (size_t i
= 0; i
< json_variant_elements(v
); i
++) {
237 assert_se(w
= json_variant_by_index(v
, i
));
239 assert_se(json_variant_integer(w
) == 0);
240 assert_se(json_variant_unsigned(w
) == 0U);
242 DISABLE_WARNING_FLOAT_EQUAL
;
243 assert_se(json_variant_real(w
) == 0.0L);
246 assert_se(json_variant_is_integer(w
));
247 assert_se(json_variant_is_unsigned(w
));
248 assert_se(json_variant_is_real(w
));
249 assert_se(json_variant_is_number(w
));
251 assert_se(!json_variant_is_negative(w
));
253 assert_se(IN_SET(json_variant_type(w
), JSON_VARIANT_INTEGER
, JSON_VARIANT_UNSIGNED
, JSON_VARIANT_REAL
));
255 for (j
= 0; j
< json_variant_elements(v
); j
++) {
258 assert_se(q
= json_variant_by_index(v
, j
));
260 assert_se(json_variant_equal(w
, q
));
265 static void test_build(void) {
266 log_info("/* %s */", __func__
);
268 _cleanup_(json_variant_unrefp
) JsonVariant
*a
= NULL
, *b
= NULL
;
269 _cleanup_free_
char *s
= NULL
, *t
= NULL
;
271 assert_se(json_build(&a
, JSON_BUILD_STRING("hallo")) >= 0);
272 assert_se(json_build(&b
, JSON_BUILD_LITERAL(" \"hallo\" ")) >= 0);
273 assert_se(json_variant_equal(a
, b
));
275 b
= json_variant_unref(b
);
277 assert_se(json_build(&b
, JSON_BUILD_VARIANT(a
)) >= 0);
278 assert_se(json_variant_equal(a
, b
));
280 b
= json_variant_unref(b
);
281 assert_se(json_build(&b
, JSON_BUILD_STRING("pief")) >= 0);
282 assert_se(!json_variant_equal(a
, b
));
284 a
= json_variant_unref(a
);
285 b
= json_variant_unref(b
);
287 assert_se(json_build(&a
, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("one", JSON_BUILD_INTEGER(7)),
288 JSON_BUILD_PAIR("two", JSON_BUILD_REAL(2.0)),
289 JSON_BUILD_PAIR("three", JSON_BUILD_INTEGER(0)))) >= 0);
291 assert_se(json_build(&b
, JSON_BUILD_OBJECT(JSON_BUILD_PAIR("two", JSON_BUILD_INTEGER(2)),
292 JSON_BUILD_PAIR("three", JSON_BUILD_REAL(0)),
293 JSON_BUILD_PAIR("one", JSON_BUILD_REAL(7)))) >= 0);
295 assert_se(json_variant_equal(a
, b
));
297 a
= json_variant_unref(a
);
298 b
= json_variant_unref(b
);
300 const char* arr_1234
[] = {"one", "two", "three", "four", NULL
};
301 assert_se(json_build(&a
, JSON_BUILD_ARRAY(JSON_BUILD_OBJECT(JSON_BUILD_PAIR("x", JSON_BUILD_BOOLEAN(true)),
302 JSON_BUILD_PAIR("y", JSON_BUILD_OBJECT(JSON_BUILD_PAIR("this", JSON_BUILD_NULL
)))),
303 JSON_BUILD_VARIANT(NULL
),
304 JSON_BUILD_LITERAL(NULL
),
305 JSON_BUILD_STRING(NULL
),
307 JSON_BUILD_INTEGER(77),
308 JSON_BUILD_ARRAY(JSON_BUILD_VARIANT(JSON_VARIANT_STRING_CONST("foobar")),
309 JSON_BUILD_VARIANT(JSON_VARIANT_STRING_CONST("zzz"))),
310 JSON_BUILD_STRV((char**) arr_1234
))) >= 0);
312 assert_se(json_variant_format(a
, 0, &s
) >= 0);
313 log_info("GOT: %s\n", s
);
314 assert_se(json_parse(s
, 0, &b
, NULL
, NULL
) >= 0);
315 assert_se(json_variant_equal(a
, b
));
317 a
= json_variant_unref(a
);
318 b
= json_variant_unref(b
);
320 assert_se(json_build(&a
, JSON_BUILD_REAL(M_PIl
)) >= 0);
323 assert_se(json_variant_format(a
, 0, &s
) >= 0);
324 log_info("GOT: %s\n", s
);
325 assert_se(json_parse(s
, 0, &b
, NULL
, NULL
) >= 0);
326 assert_se(json_variant_format(b
, 0, &t
) >= 0);
327 log_info("GOT: %s\n", t
);
329 assert_se(streq(s
, t
));
331 a
= json_variant_unref(a
);
332 b
= json_variant_unref(b
);
334 assert_se(json_build(&a
, JSON_BUILD_OBJECT(
335 JSON_BUILD_PAIR("x", JSON_BUILD_STRING("y")),
336 JSON_BUILD_PAIR("z", JSON_BUILD_STRING("a")),
337 JSON_BUILD_PAIR("b", JSON_BUILD_STRING("c"))
340 assert_se(json_build(&b
, JSON_BUILD_OBJECT(
341 JSON_BUILD_PAIR("x", JSON_BUILD_STRING("y")),
342 JSON_BUILD_PAIR_CONDITION(false, "p", JSON_BUILD_STRING("q")),
343 JSON_BUILD_PAIR_CONDITION(true, "z", JSON_BUILD_STRING("a")),
344 JSON_BUILD_PAIR_CONDITION(false, "j", JSON_BUILD_ARRAY(JSON_BUILD_STRING("k"), JSON_BUILD_STRING("u"), JSON_BUILD_STRING("i"))),
345 JSON_BUILD_PAIR("b", JSON_BUILD_STRING("c"))
348 assert_se(json_variant_equal(a
, b
));
351 static void test_source(void) {
352 static const char data
[] =
356 "\"foo\" : \"bar\", \n"
357 "\"qüüx\" : [ 1, 2, 3,\n"
360 "\"miep\" : { \"hallo\" : 1 },\n"
368 log_info("/* %s */", __func__
);
370 _cleanup_fclose_
FILE *f
= NULL
;
371 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
;
373 printf("--- original begin ---\n"
375 "--- original end ---\n", data
);
377 assert_se(f
= fmemopen_unlocked((void*) data
, strlen(data
), "r"));
379 assert_se(json_parse_file(f
, "waldo", 0, &v
, NULL
, NULL
) >= 0);
381 printf("--- non-pretty begin ---\n");
382 json_variant_dump(v
, 0, stdout
, NULL
);
383 printf("\n--- non-pretty end ---\n");
385 printf("--- pretty begin ---\n");
386 json_variant_dump(v
, JSON_FORMAT_PRETTY
|JSON_FORMAT_COLOR
|JSON_FORMAT_SOURCE
, stdout
, NULL
);
387 printf("--- pretty end ---\n");
390 static void test_depth(void) {
391 log_info("/* %s */", __func__
);
393 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
;
396 v
= JSON_VARIANT_STRING_CONST("start");
398 /* Let's verify that the maximum depth checks work */
400 for (unsigned i
= 0;; i
++) {
401 _cleanup_(json_variant_unrefp
) JsonVariant
*w
= NULL
;
403 assert_se(i
<= UINT16_MAX
);
405 r
= json_variant_new_array(&w
, &v
, 1);
407 r
= json_variant_new_object(&w
, (JsonVariant
*[]) { JSON_VARIANT_STRING_CONST("key"), v
}, 2);
409 log_info("max depth at %u", i
);
412 #if HAS_FEATURE_MEMORY_SANITIZER
413 /* msan doesn't like the stack nesting to be too deep. Let's quit early. */
415 log_info("quitting early at depth %u", i
);
422 json_variant_unref(v
);
426 json_variant_dump(v
, 0, stdout
, NULL
);
430 static void test_normalize(void) {
431 log_info("/* %s */", __func__
);
433 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
, *w
= NULL
;
434 _cleanup_free_
char *t
= NULL
;
436 assert_se(json_build(&v
, JSON_BUILD_OBJECT(
437 JSON_BUILD_PAIR("b", JSON_BUILD_STRING("x")),
438 JSON_BUILD_PAIR("c", JSON_BUILD_STRING("y")),
439 JSON_BUILD_PAIR("a", JSON_BUILD_STRING("z")))) >= 0);
441 assert_se(!json_variant_is_sorted(v
));
442 assert_se(!json_variant_is_normalized(v
));
444 assert_se(json_variant_format(v
, 0, &t
) >= 0);
445 assert_se(streq(t
, "{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}"));
448 assert_se(json_build(&w
, JSON_BUILD_OBJECT(
449 JSON_BUILD_PAIR("bar", JSON_BUILD_STRING("zzz")),
450 JSON_BUILD_PAIR("foo", JSON_BUILD_VARIANT(v
)))) >= 0);
452 assert_se(json_variant_is_sorted(w
));
453 assert_se(!json_variant_is_normalized(w
));
455 assert_se(json_variant_format(w
, 0, &t
) >= 0);
456 assert_se(streq(t
, "{\"bar\":\"zzz\",\"foo\":{\"b\":\"x\",\"c\":\"y\",\"a\":\"z\"}}"));
459 assert_se(json_variant_sort(&v
) >= 0);
460 assert_se(json_variant_is_sorted(v
));
461 assert_se(json_variant_is_normalized(v
));
463 assert_se(json_variant_format(v
, 0, &t
) >= 0);
464 assert_se(streq(t
, "{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}"));
467 assert_se(json_variant_normalize(&w
) >= 0);
468 assert_se(json_variant_is_sorted(w
));
469 assert_se(json_variant_is_normalized(w
));
471 assert_se(json_variant_format(w
, 0, &t
) >= 0);
472 assert_se(streq(t
, "{\"bar\":\"zzz\",\"foo\":{\"a\":\"z\",\"b\":\"x\",\"c\":\"y\"}}"));
476 static void test_bisect(void) {
477 log_info("/* %s */", __func__
);
479 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
;
481 /* Tests the bisection logic in json_variant_by_key() */
483 for (char c
= 'z'; c
>= 'a'; c
--) {
488 _cleanup_(json_variant_unrefp
) JsonVariant
*w
= NULL
;
489 assert_se(json_variant_new_stringn(&w
, (char[4]) { '<', c
, c
, '>' }, 4) >= 0);
490 assert_se(json_variant_set_field(&v
, (char[2]) { c
, 0 }, w
) >= 0);
493 json_variant_dump(v
, JSON_FORMAT_COLOR
|JSON_FORMAT_PRETTY
, NULL
, NULL
);
495 assert_se(!json_variant_is_sorted(v
));
496 assert_se(!json_variant_is_normalized(v
));
497 assert_se(json_variant_normalize(&v
) >= 0);
498 assert_se(json_variant_is_sorted(v
));
499 assert_se(json_variant_is_normalized(v
));
501 json_variant_dump(v
, JSON_FORMAT_COLOR
|JSON_FORMAT_PRETTY
, NULL
, NULL
);
503 for (char c
= 'a'; c
<= 'z'; c
++) {
507 k
= json_variant_by_key(v
, (char[2]) { c
, 0 });
508 assert_se(!k
== ((c
% 3) == 0));
513 assert_se(json_variant_is_string(k
));
515 z
= (char[5]){ '<', c
, c
, '>', 0};
516 assert_se(streq(json_variant_string(k
), z
));
520 static void test_float_match(JsonVariant
*v
) {
521 const double delta
= 0.0001;
523 assert_se(json_variant_is_array(v
));
524 assert_se(json_variant_elements(v
) == 9);
525 assert_se(fabsl((double) 1.0 - ((double) DBL_MIN
/ json_variant_real(json_variant_by_index(v
, 0)))) <= delta
);
526 assert_se(fabsl((double) 1.0 - ((double) DBL_MAX
/ json_variant_real(json_variant_by_index(v
, 1)))) <= delta
);
527 assert_se(json_variant_is_null(json_variant_by_index(v
, 2))); /* nan is not supported by json → null */
528 assert_se(json_variant_is_null(json_variant_by_index(v
, 3))); /* +inf is not supported by json → null */
529 assert_se(json_variant_is_null(json_variant_by_index(v
, 4))); /* -inf is not supported by json → null */
530 assert_se(json_variant_is_null(json_variant_by_index(v
, 5)) ||
531 fabsl((double) 1.0 - ((double) HUGE_VAL
/ json_variant_real(json_variant_by_index(v
, 5)))) <= delta
); /* HUGE_VAL might be +inf, but might also be something else */
532 assert_se(json_variant_is_real(json_variant_by_index(v
, 6)) &&
533 json_variant_is_integer(json_variant_by_index(v
, 6)) &&
534 json_variant_integer(json_variant_by_index(v
, 6)) == 0);
535 assert_se(json_variant_is_real(json_variant_by_index(v
, 7)) &&
536 json_variant_is_integer(json_variant_by_index(v
, 7)) &&
537 json_variant_integer(json_variant_by_index(v
, 7)) == 10);
538 assert_se(json_variant_is_real(json_variant_by_index(v
, 8)) &&
539 json_variant_is_integer(json_variant_by_index(v
, 8)) &&
540 json_variant_integer(json_variant_by_index(v
, 8)) == -10);
543 static void test_float(void) {
544 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
, *w
= NULL
;
545 _cleanup_free_
char *text
= NULL
;
547 log_info("/* %s */", __func__
);
549 assert_se(json_build(&v
, JSON_BUILD_ARRAY(
550 JSON_BUILD_REAL(DBL_MIN
),
551 JSON_BUILD_REAL(DBL_MAX
),
552 JSON_BUILD_REAL(NAN
),
553 JSON_BUILD_REAL(INFINITY
),
554 JSON_BUILD_REAL(-INFINITY
),
555 JSON_BUILD_REAL(HUGE_VAL
),
558 JSON_BUILD_REAL(-10))) >= 0);
560 json_variant_dump(v
, JSON_FORMAT_COLOR
|JSON_FORMAT_PRETTY
, NULL
, NULL
);
564 assert_se(json_variant_format(v
, 0, &text
) >= 0);
565 assert_se(json_parse(text
, 0, &w
, NULL
, NULL
) >= 0);
567 json_variant_dump(w
, JSON_FORMAT_COLOR
|JSON_FORMAT_PRETTY
, NULL
, NULL
);
572 int main(int argc
, char *argv
[]) {
573 test_setup_logging(LOG_DEBUG
);
575 test_tokenizer("x", -EINVAL
);
576 test_tokenizer("", JSON_TOKEN_END
);
577 test_tokenizer(" ", JSON_TOKEN_END
);
578 test_tokenizer("0", JSON_TOKEN_UNSIGNED
, (uint64_t) 0, JSON_TOKEN_END
);
579 test_tokenizer("-0", JSON_TOKEN_INTEGER
, (int64_t) 0, JSON_TOKEN_END
);
580 test_tokenizer("1234", JSON_TOKEN_UNSIGNED
, (uint64_t) 1234, JSON_TOKEN_END
);
581 test_tokenizer("-1234", JSON_TOKEN_INTEGER
, (int64_t) -1234, JSON_TOKEN_END
);
582 test_tokenizer("18446744073709551615", JSON_TOKEN_UNSIGNED
, (uint64_t) UINT64_MAX
, JSON_TOKEN_END
);
583 test_tokenizer("-9223372036854775808", JSON_TOKEN_INTEGER
, (int64_t) INT64_MIN
, JSON_TOKEN_END
);
584 test_tokenizer("18446744073709551616", JSON_TOKEN_REAL
, (double) 18446744073709551616.0L, JSON_TOKEN_END
);
585 test_tokenizer("-9223372036854775809", JSON_TOKEN_REAL
, (double) -9223372036854775809.0L, JSON_TOKEN_END
);
586 test_tokenizer("-1234", JSON_TOKEN_INTEGER
, (int64_t) -1234, JSON_TOKEN_END
);
587 test_tokenizer("3.141", JSON_TOKEN_REAL
, (double) 3.141, JSON_TOKEN_END
);
588 test_tokenizer("0.0", JSON_TOKEN_REAL
, (double) 0.0, JSON_TOKEN_END
);
589 test_tokenizer("7e3", JSON_TOKEN_REAL
, (double) 7e3
, JSON_TOKEN_END
);
590 test_tokenizer("-7e-3", JSON_TOKEN_REAL
, (double) -7e-3, JSON_TOKEN_END
);
591 test_tokenizer("true", JSON_TOKEN_BOOLEAN
, true, JSON_TOKEN_END
);
592 test_tokenizer("false", JSON_TOKEN_BOOLEAN
, false, JSON_TOKEN_END
);
593 test_tokenizer("null", JSON_TOKEN_NULL
, JSON_TOKEN_END
);
594 test_tokenizer("{}", JSON_TOKEN_OBJECT_OPEN
, JSON_TOKEN_OBJECT_CLOSE
, JSON_TOKEN_END
);
595 test_tokenizer("\t {\n} \n", JSON_TOKEN_OBJECT_OPEN
, JSON_TOKEN_OBJECT_CLOSE
, JSON_TOKEN_END
);
596 test_tokenizer("[]", JSON_TOKEN_ARRAY_OPEN
, JSON_TOKEN_ARRAY_CLOSE
, JSON_TOKEN_END
);
597 test_tokenizer("\t [] \n\n", JSON_TOKEN_ARRAY_OPEN
, JSON_TOKEN_ARRAY_CLOSE
, JSON_TOKEN_END
);
598 test_tokenizer("\"\"", JSON_TOKEN_STRING
, "", JSON_TOKEN_END
);
599 test_tokenizer("\"foo\"", JSON_TOKEN_STRING
, "foo", JSON_TOKEN_END
);
600 test_tokenizer("\"foo\\nfoo\"", JSON_TOKEN_STRING
, "foo\nfoo", JSON_TOKEN_END
);
601 test_tokenizer("{\"foo\" : \"bar\"}", JSON_TOKEN_OBJECT_OPEN
, JSON_TOKEN_STRING
, "foo", JSON_TOKEN_COLON
, JSON_TOKEN_STRING
, "bar", JSON_TOKEN_OBJECT_CLOSE
, JSON_TOKEN_END
);
602 test_tokenizer("{\"foo\" : [true, false]}", JSON_TOKEN_OBJECT_OPEN
, JSON_TOKEN_STRING
, "foo", JSON_TOKEN_COLON
, JSON_TOKEN_ARRAY_OPEN
, JSON_TOKEN_BOOLEAN
, true, JSON_TOKEN_COMMA
, JSON_TOKEN_BOOLEAN
, false, JSON_TOKEN_ARRAY_CLOSE
, JSON_TOKEN_OBJECT_CLOSE
, JSON_TOKEN_END
);
603 test_tokenizer("\"\xef\xbf\xbd\"", JSON_TOKEN_STRING
, "\xef\xbf\xbd", JSON_TOKEN_END
);
604 test_tokenizer("\"\\ufffd\"", JSON_TOKEN_STRING
, "\xef\xbf\xbd", JSON_TOKEN_END
);
605 test_tokenizer("\"\\uf\"", -EINVAL
);
606 test_tokenizer("\"\\ud800a\"", -EINVAL
);
607 test_tokenizer("\"\\udc00\\udc00\"", -EINVAL
);
608 test_tokenizer("\"\\ud801\\udc37\"", JSON_TOKEN_STRING
, "\xf0\x90\x90\xb7", JSON_TOKEN_END
);
610 test_tokenizer("[1, 2, -3]", JSON_TOKEN_ARRAY_OPEN
, JSON_TOKEN_UNSIGNED
, (uint64_t) 1, JSON_TOKEN_COMMA
, JSON_TOKEN_UNSIGNED
, (uint64_t) 2, JSON_TOKEN_COMMA
, JSON_TOKEN_INTEGER
, (int64_t) -3, JSON_TOKEN_ARRAY_CLOSE
, JSON_TOKEN_END
);
612 test_variant("{\"k\": \"v\", \"foo\": [1, 2, 3], \"bar\": {\"zap\": null}}", test_1
);
613 test_variant("{\"mutant\": [1, null, \"1\", {\"1\": [1, \"1\"]}], \"thisisaverylongproperty\": 1.27}", test_2
);
614 test_variant("{\"foo\" : \"\\u0935\\u093f\\u0935\\u0947\\u0915\\u0916\\u094d\\u092f\\u093e\\u0924\\u093f\\u0930\\u0935\\u093f\\u092a\\u094d\\u0932\\u0935\\u093e\\u0020\\u0939\\u093e\\u0928\\u094b\\u092a\\u093e\\u092f\\u0903\\u0964\"}", NULL
);
616 test_variant("[ 0, -0, 0.0, -0.0, 0.000, -0.000, 0e0, -0e0, 0e+0, -0e-0, 0e-0, -0e000, 0e+000 ]", test_zeroes
);