trap signals for "-serial mon:stdio"
[qemu.git] / tests / check-qjson.c
1 /*
2 * Copyright IBM, Corp. 2009
3 * Copyright (c) 2013 Red Hat Inc.
4 *
5 * Authors:
6 * Anthony Liguori <aliguori@us.ibm.com>
7 * Markus Armbruster <armbru@redhat.com>
8 *
9 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
10 * See the COPYING.LIB file in the top-level directory.
11 *
12 */
13 #include <glib.h>
14
15 #include "qapi/qmp/qstring.h"
16 #include "qapi/qmp/qint.h"
17 #include "qapi/qmp/qdict.h"
18 #include "qapi/qmp/qlist.h"
19 #include "qapi/qmp/qfloat.h"
20 #include "qapi/qmp/qbool.h"
21 #include "qapi/qmp/qjson.h"
22
23 #include "qemu-common.h"
24
25 static void escaped_string(void)
26 {
27 int i;
28 struct {
29 const char *encoded;
30 const char *decoded;
31 int skip;
32 } test_cases[] = {
33 { "\"\\b\"", "\b" },
34 { "\"\\f\"", "\f" },
35 { "\"\\n\"", "\n" },
36 { "\"\\r\"", "\r" },
37 { "\"\\t\"", "\t" },
38 { "\"/\"", "/" },
39 { "\"\\/\"", "/", .skip = 1 },
40 { "\"\\\\\"", "\\" },
41 { "\"\\\"\"", "\"" },
42 { "\"hello world \\\"embedded string\\\"\"",
43 "hello world \"embedded string\"" },
44 { "\"hello world\\nwith new line\"", "hello world\nwith new line" },
45 { "\"single byte utf-8 \\u0020\"", "single byte utf-8 ", .skip = 1 },
46 { "\"double byte utf-8 \\u00A2\"", "double byte utf-8 \xc2\xa2" },
47 { "\"triple byte utf-8 \\u20AC\"", "triple byte utf-8 \xe2\x82\xac" },
48 {}
49 };
50
51 for (i = 0; test_cases[i].encoded; i++) {
52 QObject *obj;
53 QString *str;
54
55 obj = qobject_from_json(test_cases[i].encoded);
56
57 g_assert(obj != NULL);
58 g_assert(qobject_type(obj) == QTYPE_QSTRING);
59
60 str = qobject_to_qstring(obj);
61 g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].decoded);
62
63 if (test_cases[i].skip == 0) {
64 str = qobject_to_json(obj);
65 g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].encoded);
66 qobject_decref(obj);
67 }
68
69 QDECREF(str);
70 }
71 }
72
73 static void simple_string(void)
74 {
75 int i;
76 struct {
77 const char *encoded;
78 const char *decoded;
79 } test_cases[] = {
80 { "\"hello world\"", "hello world" },
81 { "\"the quick brown fox jumped over the fence\"",
82 "the quick brown fox jumped over the fence" },
83 {}
84 };
85
86 for (i = 0; test_cases[i].encoded; i++) {
87 QObject *obj;
88 QString *str;
89
90 obj = qobject_from_json(test_cases[i].encoded);
91
92 g_assert(obj != NULL);
93 g_assert(qobject_type(obj) == QTYPE_QSTRING);
94
95 str = qobject_to_qstring(obj);
96 g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
97
98 str = qobject_to_json(obj);
99 g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
100
101 qobject_decref(obj);
102
103 QDECREF(str);
104 }
105 }
106
107 static void single_quote_string(void)
108 {
109 int i;
110 struct {
111 const char *encoded;
112 const char *decoded;
113 } test_cases[] = {
114 { "'hello world'", "hello world" },
115 { "'the quick brown fox \\' jumped over the fence'",
116 "the quick brown fox ' jumped over the fence" },
117 {}
118 };
119
120 for (i = 0; test_cases[i].encoded; i++) {
121 QObject *obj;
122 QString *str;
123
124 obj = qobject_from_json(test_cases[i].encoded);
125
126 g_assert(obj != NULL);
127 g_assert(qobject_type(obj) == QTYPE_QSTRING);
128
129 str = qobject_to_qstring(obj);
130 g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
131
132 QDECREF(str);
133 }
134 }
135
136 static void utf8_string(void)
137 {
138 /*
139 * FIXME Current behavior for invalid UTF-8 sequences is
140 * incorrect. This test expects current, incorrect results.
141 * They're all marked "bug:" below, and are to be replaced by
142 * correct ones as the bugs get fixed.
143 *
144 * The JSON parser rejects some invalid sequences, but accepts
145 * others without correcting the problem.
146 *
147 * We should either reject all invalid sequences, or minimize
148 * overlong sequences and replace all other invalid sequences by a
149 * suitable replacement character. A common choice for
150 * replacement is U+FFFD.
151 *
152 * Problem: we can't easily deal with embedded U+0000. Parsing
153 * the JSON string "this \\u0000" is fun" yields "this \0 is fun",
154 * which gets misinterpreted as NUL-terminated "this ". We should
155 * consider using overlong encoding \xC0\x80 for U+0000 ("modified
156 * UTF-8").
157 *
158 * Most test cases are scraped from Markus Kuhn's UTF-8 decoder
159 * capability and stress test at
160 * http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
161 */
162 static const struct {
163 const char *json_in;
164 const char *utf8_out;
165 const char *json_out; /* defaults to @json_in */
166 const char *utf8_in; /* defaults to @utf8_out */
167 } test_cases[] = {
168 /*
169 * Bug markers used here:
170 * - bug: not corrected
171 * JSON parser fails to correct invalid sequence(s)
172 * - bug: rejected
173 * JSON parser rejects invalid sequence(s)
174 * We may choose to define this as feature
175 * - bug: want "..."
176 * JSON parser produces incorrect result, this is the
177 * correct one, assuming replacement character U+FFFF
178 * We may choose to reject instead of replace
179 */
180
181 /* 1 Some correct UTF-8 text */
182 {
183 /* a bit of German */
184 "\"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
185 " jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.\"",
186 "Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt"
187 " jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.",
188 "\"Falsches \\u00DCben von Xylophonmusik qu\\u00E4lt"
189 " jeden gr\\u00F6\\u00DFeren Zwerg.\"",
190 },
191 {
192 /* a bit of Greek */
193 "\"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5\"",
194 "\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
195 "\"\\u03BA\\u1F79\\u03C3\\u03BC\\u03B5\"",
196 },
197 /* 2 Boundary condition test cases */
198 /* 2.1 First possible sequence of a certain length */
199 /* 2.1.1 1 byte U+0000 */
200 {
201 "\"\\u0000\"",
202 "", /* bug: want overlong "\xC0\x80" */
203 "\"\\u0000\"",
204 "\xC0\x80",
205 },
206 /* 2.1.2 2 bytes U+0080 */
207 {
208 "\"\xC2\x80\"",
209 "\xC2\x80",
210 "\"\\u0080\"",
211 },
212 /* 2.1.3 3 bytes U+0800 */
213 {
214 "\"\xE0\xA0\x80\"",
215 "\xE0\xA0\x80",
216 "\"\\u0800\"",
217 },
218 /* 2.1.4 4 bytes U+10000 */
219 {
220 "\"\xF0\x90\x80\x80\"",
221 "\xF0\x90\x80\x80",
222 "\"\\uD800\\uDC00\"",
223 },
224 /* 2.1.5 5 bytes U+200000 */
225 {
226 "\"\xF8\x88\x80\x80\x80\"",
227 NULL, /* bug: rejected */
228 "\"\\uFFFD\"",
229 "\xF8\x88\x80\x80\x80",
230 },
231 /* 2.1.6 6 bytes U+4000000 */
232 {
233 "\"\xFC\x84\x80\x80\x80\x80\"",
234 NULL, /* bug: rejected */
235 "\"\\uFFFD\"",
236 "\xFC\x84\x80\x80\x80\x80",
237 },
238 /* 2.2 Last possible sequence of a certain length */
239 /* 2.2.1 1 byte U+007F */
240 {
241 "\"\x7F\"",
242 "\x7F",
243 "\"\\u007F\"",
244 },
245 /* 2.2.2 2 bytes U+07FF */
246 {
247 "\"\xDF\xBF\"",
248 "\xDF\xBF",
249 "\"\\u07FF\"",
250 },
251 /*
252 * 2.2.3 3 bytes U+FFFC
253 * The last possible sequence is actually U+FFFF. But that's
254 * a noncharacter, and already covered by its own test case
255 * under 5.3. Same for U+FFFE. U+FFFD is the last character
256 * in the BMP, and covered under 2.3. Because of U+FFFD's
257 * special role as replacement character, it's worth testing
258 * U+FFFC here.
259 */
260 {
261 "\"\xEF\xBF\xBC\"",
262 "\xEF\xBF\xBC",
263 "\"\\uFFFC\"",
264 },
265 /* 2.2.4 4 bytes U+1FFFFF */
266 {
267 "\"\xF7\xBF\xBF\xBF\"",
268 NULL, /* bug: rejected */
269 "\"\\uFFFD\"",
270 "\xF7\xBF\xBF\xBF",
271 },
272 /* 2.2.5 5 bytes U+3FFFFFF */
273 {
274 "\"\xFB\xBF\xBF\xBF\xBF\"",
275 NULL, /* bug: rejected */
276 "\"\\uFFFD\"",
277 "\xFB\xBF\xBF\xBF\xBF",
278 },
279 /* 2.2.6 6 bytes U+7FFFFFFF */
280 {
281 "\"\xFD\xBF\xBF\xBF\xBF\xBF\"",
282 NULL, /* bug: rejected */
283 "\"\\uFFFD\"",
284 "\xFD\xBF\xBF\xBF\xBF\xBF",
285 },
286 /* 2.3 Other boundary conditions */
287 {
288 /* last one before surrogate range: U+D7FF */
289 "\"\xED\x9F\xBF\"",
290 "\xED\x9F\xBF",
291 "\"\\uD7FF\"",
292 },
293 {
294 /* first one after surrogate range: U+E000 */
295 "\"\xEE\x80\x80\"",
296 "\xEE\x80\x80",
297 "\"\\uE000\"",
298 },
299 {
300 /* last one in BMP: U+FFFD */
301 "\"\xEF\xBF\xBD\"",
302 "\xEF\xBF\xBD",
303 "\"\\uFFFD\"",
304 },
305 {
306 /* last one in last plane: U+10FFFD */
307 "\"\xF4\x8F\xBF\xBD\"",
308 "\xF4\x8F\xBF\xBD",
309 "\"\\uDBFF\\uDFFD\""
310 },
311 {
312 /* first one beyond Unicode range: U+110000 */
313 "\"\xF4\x90\x80\x80\"",
314 "\xF4\x90\x80\x80",
315 "\"\\uFFFD\"",
316 },
317 /* 3 Malformed sequences */
318 /* 3.1 Unexpected continuation bytes */
319 /* 3.1.1 First continuation byte */
320 {
321 "\"\x80\"",
322 "\x80", /* bug: not corrected */
323 "\"\\uFFFD\"",
324 },
325 /* 3.1.2 Last continuation byte */
326 {
327 "\"\xBF\"",
328 "\xBF", /* bug: not corrected */
329 "\"\\uFFFD\"",
330 },
331 /* 3.1.3 2 continuation bytes */
332 {
333 "\"\x80\xBF\"",
334 "\x80\xBF", /* bug: not corrected */
335 "\"\\uFFFD\\uFFFD\"",
336 },
337 /* 3.1.4 3 continuation bytes */
338 {
339 "\"\x80\xBF\x80\"",
340 "\x80\xBF\x80", /* bug: not corrected */
341 "\"\\uFFFD\\uFFFD\\uFFFD\"",
342 },
343 /* 3.1.5 4 continuation bytes */
344 {
345 "\"\x80\xBF\x80\xBF\"",
346 "\x80\xBF\x80\xBF", /* bug: not corrected */
347 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\"",
348 },
349 /* 3.1.6 5 continuation bytes */
350 {
351 "\"\x80\xBF\x80\xBF\x80\"",
352 "\x80\xBF\x80\xBF\x80", /* bug: not corrected */
353 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\"",
354 },
355 /* 3.1.7 6 continuation bytes */
356 {
357 "\"\x80\xBF\x80\xBF\x80\xBF\"",
358 "\x80\xBF\x80\xBF\x80\xBF", /* bug: not corrected */
359 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\"",
360 },
361 /* 3.1.8 7 continuation bytes */
362 {
363 "\"\x80\xBF\x80\xBF\x80\xBF\x80\"",
364 "\x80\xBF\x80\xBF\x80\xBF\x80", /* bug: not corrected */
365 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\"",
366 },
367 /* 3.1.9 Sequence of all 64 possible continuation bytes */
368 {
369 "\"\x80\x81\x82\x83\x84\x85\x86\x87"
370 "\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
371 "\x90\x91\x92\x93\x94\x95\x96\x97"
372 "\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
373 "\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
374 "\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
375 "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
376 "\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\"",
377 /* bug: not corrected */
378 "\x80\x81\x82\x83\x84\x85\x86\x87"
379 "\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
380 "\x90\x91\x92\x93\x94\x95\x96\x97"
381 "\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
382 "\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
383 "\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
384 "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
385 "\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
386 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
387 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
388 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
389 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
390 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
391 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
392 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
393 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\""
394 },
395 /* 3.2 Lonely start characters */
396 /* 3.2.1 All 32 first bytes of 2-byte sequences, followed by space */
397 {
398 "\"\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
399 "\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
400 "\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
401 "\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF \"",
402 NULL, /* bug: rejected */
403 "\"\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
404 "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
405 "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
406 "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \"",
407 "\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 "
408 "\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
409 "\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
410 "\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
411 },
412 /* 3.2.2 All 16 first bytes of 3-byte sequences, followed by space */
413 {
414 "\"\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
415 "\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF \"",
416 /* bug: not corrected */
417 "\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
418 "\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
419 "\"\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
420 "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \"",
421 },
422 /* 3.2.3 All 8 first bytes of 4-byte sequences, followed by space */
423 {
424 "\"\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 \"",
425 NULL, /* bug: rejected */
426 "\"\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \"",
427 "\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
428 },
429 /* 3.2.4 All 4 first bytes of 5-byte sequences, followed by space */
430 {
431 "\"\xF8 \xF9 \xFA \xFB \"",
432 NULL, /* bug: rejected */
433 "\"\\uFFFD \\uFFFD \\uFFFD \\uFFFD \"",
434 "\xF8 \xF9 \xFA \xFB ",
435 },
436 /* 3.2.5 All 2 first bytes of 6-byte sequences, followed by space */
437 {
438 "\"\xFC \xFD \"",
439 NULL, /* bug: rejected */
440 "\"\\uFFFD \\uFFFD \"",
441 "\xFC \xFD ",
442 },
443 /* 3.3 Sequences with last continuation byte missing */
444 /* 3.3.1 2-byte sequence with last byte missing (U+0000) */
445 {
446 "\"\xC0\"",
447 NULL, /* bug: rejected */
448 "\"\\uFFFD\"",
449 "\xC0",
450 },
451 /* 3.3.2 3-byte sequence with last byte missing (U+0000) */
452 {
453 "\"\xE0\x80\"",
454 "\xE0\x80", /* bug: not corrected */
455 "\"\\uFFFD\"",
456 },
457 /* 3.3.3 4-byte sequence with last byte missing (U+0000) */
458 {
459 "\"\xF0\x80\x80\"",
460 "\xF0\x80\x80", /* bug: not corrected */
461 "\"\\uFFFD\"",
462 },
463 /* 3.3.4 5-byte sequence with last byte missing (U+0000) */
464 {
465 "\"\xF8\x80\x80\x80\"",
466 NULL, /* bug: rejected */
467 "\"\\uFFFD\"",
468 "\xF8\x80\x80\x80",
469 },
470 /* 3.3.5 6-byte sequence with last byte missing (U+0000) */
471 {
472 "\"\xFC\x80\x80\x80\x80\"",
473 NULL, /* bug: rejected */
474 "\"\\uFFFD\"",
475 "\xFC\x80\x80\x80\x80",
476 },
477 /* 3.3.6 2-byte sequence with last byte missing (U+07FF) */
478 {
479 "\"\xDF\"",
480 "\xDF", /* bug: not corrected */
481 "\"\\uFFFD\"",
482 },
483 /* 3.3.7 3-byte sequence with last byte missing (U+FFFF) */
484 {
485 "\"\xEF\xBF\"",
486 "\xEF\xBF", /* bug: not corrected */
487 "\"\\uFFFD\"",
488 },
489 /* 3.3.8 4-byte sequence with last byte missing (U+1FFFFF) */
490 {
491 "\"\xF7\xBF\xBF\"",
492 NULL, /* bug: rejected */
493 "\"\\uFFFD\"",
494 "\xF7\xBF\xBF",
495 },
496 /* 3.3.9 5-byte sequence with last byte missing (U+3FFFFFF) */
497 {
498 "\"\xFB\xBF\xBF\xBF\"",
499 NULL, /* bug: rejected */
500 "\"\\uFFFD\"",
501 "\xFB\xBF\xBF\xBF",
502 },
503 /* 3.3.10 6-byte sequence with last byte missing (U+7FFFFFFF) */
504 {
505 "\"\xFD\xBF\xBF\xBF\xBF\"",
506 NULL, /* bug: rejected */
507 "\"\\uFFFD\"",
508 "\xFD\xBF\xBF\xBF\xBF",
509 },
510 /* 3.4 Concatenation of incomplete sequences */
511 {
512 "\"\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
513 "\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF\"",
514 NULL, /* bug: rejected */
515 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
516 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\"",
517 "\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
518 "\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF",
519 },
520 /* 3.5 Impossible bytes */
521 {
522 "\"\xFE\"",
523 NULL, /* bug: rejected */
524 "\"\\uFFFD\"",
525 "\xFE",
526 },
527 {
528 "\"\xFF\"",
529 NULL, /* bug: rejected */
530 "\"\\uFFFD\"",
531 "\xFF",
532 },
533 {
534 "\"\xFE\xFE\xFF\xFF\"",
535 NULL, /* bug: rejected */
536 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\"",
537 "\xFE\xFE\xFF\xFF",
538 },
539 /* 4 Overlong sequences */
540 /* 4.1 Overlong '/' */
541 {
542 "\"\xC0\xAF\"",
543 NULL, /* bug: rejected */
544 "\"\\uFFFD\"",
545 "\xC0\xAF",
546 },
547 {
548 "\"\xE0\x80\xAF\"",
549 "\xE0\x80\xAF", /* bug: not corrected */
550 "\"\\uFFFD\"",
551 },
552 {
553 "\"\xF0\x80\x80\xAF\"",
554 "\xF0\x80\x80\xAF", /* bug: not corrected */
555 "\"\\uFFFD\"",
556 },
557 {
558 "\"\xF8\x80\x80\x80\xAF\"",
559 NULL, /* bug: rejected */
560 "\"\\uFFFD\"",
561 "\xF8\x80\x80\x80\xAF",
562 },
563 {
564 "\"\xFC\x80\x80\x80\x80\xAF\"",
565 NULL, /* bug: rejected */
566 "\"\\uFFFD\"",
567 "\xFC\x80\x80\x80\x80\xAF",
568 },
569 /*
570 * 4.2 Maximum overlong sequences
571 * Highest Unicode value that is still resulting in an
572 * overlong sequence if represented with the given number of
573 * bytes. This is a boundary test for safe UTF-8 decoders.
574 */
575 {
576 /* \U+007F */
577 "\"\xC1\xBF\"",
578 NULL, /* bug: rejected */
579 "\"\\uFFFD\"",
580 "\xC1\xBF",
581 },
582 {
583 /* \U+07FF */
584 "\"\xE0\x9F\xBF\"",
585 "\xE0\x9F\xBF", /* bug: not corrected */
586 "\"\\uFFFD\"",
587 },
588 {
589 /*
590 * \U+FFFC
591 * The actual maximum would be U+FFFF, but that's a
592 * noncharacter. Testing U+FFFC seems more useful. See
593 * also 2.2.3
594 */
595 "\"\xF0\x8F\xBF\xBC\"",
596 "\xF0\x8F\xBF\xBC", /* bug: not corrected */
597 "\"\\uFFFD\"",
598 },
599 {
600 /* \U+1FFFFF */
601 "\"\xF8\x87\xBF\xBF\xBF\"",
602 NULL, /* bug: rejected */
603 "\"\\uFFFD\"",
604 "\xF8\x87\xBF\xBF\xBF",
605 },
606 {
607 /* \U+3FFFFFF */
608 "\"\xFC\x83\xBF\xBF\xBF\xBF\"",
609 NULL, /* bug: rejected */
610 "\"\\uFFFD\"",
611 "\xFC\x83\xBF\xBF\xBF\xBF",
612 },
613 /* 4.3 Overlong representation of the NUL character */
614 {
615 /* \U+0000 */
616 "\"\xC0\x80\"",
617 NULL, /* bug: rejected */
618 "\"\\u0000\"",
619 "\xC0\x80",
620 },
621 {
622 /* \U+0000 */
623 "\"\xE0\x80\x80\"",
624 "\xE0\x80\x80", /* bug: not corrected */
625 "\"\\uFFFD\"",
626 },
627 {
628 /* \U+0000 */
629 "\"\xF0\x80\x80\x80\"",
630 "\xF0\x80\x80\x80", /* bug: not corrected */
631 "\"\\uFFFD\"",
632 },
633 {
634 /* \U+0000 */
635 "\"\xF8\x80\x80\x80\x80\"",
636 NULL, /* bug: rejected */
637 "\"\\uFFFD\"",
638 "\xF8\x80\x80\x80\x80",
639 },
640 {
641 /* \U+0000 */
642 "\"\xFC\x80\x80\x80\x80\x80\"",
643 NULL, /* bug: rejected */
644 "\"\\uFFFD\"",
645 "\xFC\x80\x80\x80\x80\x80",
646 },
647 /* 5 Illegal code positions */
648 /* 5.1 Single UTF-16 surrogates */
649 {
650 /* \U+D800 */
651 "\"\xED\xA0\x80\"",
652 "\xED\xA0\x80", /* bug: not corrected */
653 "\"\\uFFFD\"",
654 },
655 {
656 /* \U+DB7F */
657 "\"\xED\xAD\xBF\"",
658 "\xED\xAD\xBF", /* bug: not corrected */
659 "\"\\uFFFD\"",
660 },
661 {
662 /* \U+DB80 */
663 "\"\xED\xAE\x80\"",
664 "\xED\xAE\x80", /* bug: not corrected */
665 "\"\\uFFFD\"",
666 },
667 {
668 /* \U+DBFF */
669 "\"\xED\xAF\xBF\"",
670 "\xED\xAF\xBF", /* bug: not corrected */
671 "\"\\uFFFD\"",
672 },
673 {
674 /* \U+DC00 */
675 "\"\xED\xB0\x80\"",
676 "\xED\xB0\x80", /* bug: not corrected */
677 "\"\\uFFFD\"",
678 },
679 {
680 /* \U+DF80 */
681 "\"\xED\xBE\x80\"",
682 "\xED\xBE\x80", /* bug: not corrected */
683 "\"\\uFFFD\"",
684 },
685 {
686 /* \U+DFFF */
687 "\"\xED\xBF\xBF\"",
688 "\xED\xBF\xBF", /* bug: not corrected */
689 "\"\\uFFFD\"",
690 },
691 /* 5.2 Paired UTF-16 surrogates */
692 {
693 /* \U+D800\U+DC00 */
694 "\"\xED\xA0\x80\xED\xB0\x80\"",
695 "\xED\xA0\x80\xED\xB0\x80", /* bug: not corrected */
696 "\"\\uFFFD\\uFFFD\"",
697 },
698 {
699 /* \U+D800\U+DFFF */
700 "\"\xED\xA0\x80\xED\xBF\xBF\"",
701 "\xED\xA0\x80\xED\xBF\xBF", /* bug: not corrected */
702 "\"\\uFFFD\\uFFFD\"",
703 },
704 {
705 /* \U+DB7F\U+DC00 */
706 "\"\xED\xAD\xBF\xED\xB0\x80\"",
707 "\xED\xAD\xBF\xED\xB0\x80", /* bug: not corrected */
708 "\"\\uFFFD\\uFFFD\"",
709 },
710 {
711 /* \U+DB7F\U+DFFF */
712 "\"\xED\xAD\xBF\xED\xBF\xBF\"",
713 "\xED\xAD\xBF\xED\xBF\xBF", /* bug: not corrected */
714 "\"\\uFFFD\\uFFFD\"",
715 },
716 {
717 /* \U+DB80\U+DC00 */
718 "\"\xED\xAE\x80\xED\xB0\x80\"",
719 "\xED\xAE\x80\xED\xB0\x80", /* bug: not corrected */
720 "\"\\uFFFD\\uFFFD\"",
721 },
722 {
723 /* \U+DB80\U+DFFF */
724 "\"\xED\xAE\x80\xED\xBF\xBF\"",
725 "\xED\xAE\x80\xED\xBF\xBF", /* bug: not corrected */
726 "\"\\uFFFD\\uFFFD\"",
727 },
728 {
729 /* \U+DBFF\U+DC00 */
730 "\"\xED\xAF\xBF\xED\xB0\x80\"",
731 "\xED\xAF\xBF\xED\xB0\x80", /* bug: not corrected */
732 "\"\\uFFFD\\uFFFD\"",
733 },
734 {
735 /* \U+DBFF\U+DFFF */
736 "\"\xED\xAF\xBF\xED\xBF\xBF\"",
737 "\xED\xAF\xBF\xED\xBF\xBF", /* bug: not corrected */
738 "\"\\uFFFD\\uFFFD\"",
739 },
740 /* 5.3 Other illegal code positions */
741 /* BMP noncharacters */
742 {
743 /* \U+FFFE */
744 "\"\xEF\xBF\xBE\"",
745 "\xEF\xBF\xBE", /* bug: not corrected */
746 "\"\\uFFFD\"",
747 },
748 {
749 /* \U+FFFF */
750 "\"\xEF\xBF\xBF\"",
751 "\xEF\xBF\xBF", /* bug: not corrected */
752 "\"\\uFFFD\"",
753 },
754 {
755 /* U+FDD0 */
756 "\"\xEF\xB7\x90\"",
757 "\xEF\xB7\x90", /* bug: not corrected */
758 "\"\\uFFFD\"",
759 },
760 {
761 /* U+FDEF */
762 "\"\xEF\xB7\xAF\"",
763 "\xEF\xB7\xAF", /* bug: not corrected */
764 "\"\\uFFFD\"",
765 },
766 /* Plane 1 .. 16 noncharacters */
767 {
768 /* U+1FFFE U+1FFFF U+2FFFE U+2FFFF ... U+10FFFE U+10FFFF */
769 "\"\xF0\x9F\xBF\xBE\xF0\x9F\xBF\xBF"
770 "\xF0\xAF\xBF\xBE\xF0\xAF\xBF\xBF"
771 "\xF0\xBF\xBF\xBE\xF0\xBF\xBF\xBF"
772 "\xF1\x8F\xBF\xBE\xF1\x8F\xBF\xBF"
773 "\xF1\x9F\xBF\xBE\xF1\x9F\xBF\xBF"
774 "\xF1\xAF\xBF\xBE\xF1\xAF\xBF\xBF"
775 "\xF1\xBF\xBF\xBE\xF1\xBF\xBF\xBF"
776 "\xF2\x8F\xBF\xBE\xF2\x8F\xBF\xBF"
777 "\xF2\x9F\xBF\xBE\xF2\x9F\xBF\xBF"
778 "\xF2\xAF\xBF\xBE\xF2\xAF\xBF\xBF"
779 "\xF2\xBF\xBF\xBE\xF2\xBF\xBF\xBF"
780 "\xF3\x8F\xBF\xBE\xF3\x8F\xBF\xBF"
781 "\xF3\x9F\xBF\xBE\xF3\x9F\xBF\xBF"
782 "\xF3\xAF\xBF\xBE\xF3\xAF\xBF\xBF"
783 "\xF3\xBF\xBF\xBE\xF3\xBF\xBF\xBF"
784 "\xF4\x8F\xBF\xBE\xF4\x8F\xBF\xBF\"",
785 /* bug: not corrected */
786 "\xF0\x9F\xBF\xBE\xF0\x9F\xBF\xBF"
787 "\xF0\xAF\xBF\xBE\xF0\xAF\xBF\xBF"
788 "\xF0\xBF\xBF\xBE\xF0\xBF\xBF\xBF"
789 "\xF1\x8F\xBF\xBE\xF1\x8F\xBF\xBF"
790 "\xF1\x9F\xBF\xBE\xF1\x9F\xBF\xBF"
791 "\xF1\xAF\xBF\xBE\xF1\xAF\xBF\xBF"
792 "\xF1\xBF\xBF\xBE\xF1\xBF\xBF\xBF"
793 "\xF2\x8F\xBF\xBE\xF2\x8F\xBF\xBF"
794 "\xF2\x9F\xBF\xBE\xF2\x9F\xBF\xBF"
795 "\xF2\xAF\xBF\xBE\xF2\xAF\xBF\xBF"
796 "\xF2\xBF\xBF\xBE\xF2\xBF\xBF\xBF"
797 "\xF3\x8F\xBF\xBE\xF3\x8F\xBF\xBF"
798 "\xF3\x9F\xBF\xBE\xF3\x9F\xBF\xBF"
799 "\xF3\xAF\xBF\xBE\xF3\xAF\xBF\xBF"
800 "\xF3\xBF\xBF\xBE\xF3\xBF\xBF\xBF"
801 "\xF4\x8F\xBF\xBE\xF4\x8F\xBF\xBF",
802 "\"\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
803 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
804 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
805 "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\"",
806 },
807 {}
808 };
809 int i;
810 QObject *obj;
811 QString *str;
812 const char *json_in, *utf8_out, *utf8_in, *json_out;
813
814 for (i = 0; test_cases[i].json_in; i++) {
815 json_in = test_cases[i].json_in;
816 utf8_out = test_cases[i].utf8_out;
817 utf8_in = test_cases[i].utf8_in ?: test_cases[i].utf8_out;
818 json_out = test_cases[i].json_out ?: test_cases[i].json_in;
819
820 obj = qobject_from_json(json_in);
821 if (utf8_out) {
822 g_assert(obj);
823 g_assert(qobject_type(obj) == QTYPE_QSTRING);
824 str = qobject_to_qstring(obj);
825 g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
826 } else {
827 g_assert(!obj);
828 }
829 qobject_decref(obj);
830
831 obj = QOBJECT(qstring_from_str(utf8_in));
832 str = qobject_to_json(obj);
833 if (json_out) {
834 g_assert(str);
835 g_assert_cmpstr(qstring_get_str(str), ==, json_out);
836 } else {
837 g_assert(!str);
838 }
839 QDECREF(str);
840 qobject_decref(obj);
841
842 /*
843 * Disabled, because qobject_from_json() is buggy, and I can't
844 * be bothered to add the expected incorrect results.
845 * FIXME Enable once these bugs have been fixed.
846 */
847 if (0 && json_out != json_in) {
848 obj = qobject_from_json(json_out);
849 g_assert(obj);
850 g_assert(qobject_type(obj) == QTYPE_QSTRING);
851 str = qobject_to_qstring(obj);
852 g_assert_cmpstr(qstring_get_str(str), ==, utf8_out);
853 }
854 }
855 }
856
857 static void vararg_string(void)
858 {
859 int i;
860 struct {
861 const char *decoded;
862 } test_cases[] = {
863 { "hello world" },
864 { "the quick brown fox jumped over the fence" },
865 {}
866 };
867
868 for (i = 0; test_cases[i].decoded; i++) {
869 QObject *obj;
870 QString *str;
871
872 obj = qobject_from_jsonf("%s", test_cases[i].decoded);
873
874 g_assert(obj != NULL);
875 g_assert(qobject_type(obj) == QTYPE_QSTRING);
876
877 str = qobject_to_qstring(obj);
878 g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
879
880 QDECREF(str);
881 }
882 }
883
884 static void simple_number(void)
885 {
886 int i;
887 struct {
888 const char *encoded;
889 int64_t decoded;
890 int skip;
891 } test_cases[] = {
892 { "0", 0 },
893 { "1234", 1234 },
894 { "1", 1 },
895 { "-32", -32 },
896 { "-0", 0, .skip = 1 },
897 { },
898 };
899
900 for (i = 0; test_cases[i].encoded; i++) {
901 QObject *obj;
902 QInt *qint;
903
904 obj = qobject_from_json(test_cases[i].encoded);
905 g_assert(obj != NULL);
906 g_assert(qobject_type(obj) == QTYPE_QINT);
907
908 qint = qobject_to_qint(obj);
909 g_assert(qint_get_int(qint) == test_cases[i].decoded);
910 if (test_cases[i].skip == 0) {
911 QString *str;
912
913 str = qobject_to_json(obj);
914 g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
915 QDECREF(str);
916 }
917
918 QDECREF(qint);
919 }
920 }
921
922 static void float_number(void)
923 {
924 int i;
925 struct {
926 const char *encoded;
927 double decoded;
928 int skip;
929 } test_cases[] = {
930 { "32.43", 32.43 },
931 { "0.222", 0.222 },
932 { "-32.12313", -32.12313 },
933 { "-32.20e-10", -32.20e-10, .skip = 1 },
934 { },
935 };
936
937 for (i = 0; test_cases[i].encoded; i++) {
938 QObject *obj;
939 QFloat *qfloat;
940
941 obj = qobject_from_json(test_cases[i].encoded);
942 g_assert(obj != NULL);
943 g_assert(qobject_type(obj) == QTYPE_QFLOAT);
944
945 qfloat = qobject_to_qfloat(obj);
946 g_assert(qfloat_get_double(qfloat) == test_cases[i].decoded);
947
948 if (test_cases[i].skip == 0) {
949 QString *str;
950
951 str = qobject_to_json(obj);
952 g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
953 QDECREF(str);
954 }
955
956 QDECREF(qfloat);
957 }
958 }
959
960 static void vararg_number(void)
961 {
962 QObject *obj;
963 QInt *qint;
964 QFloat *qfloat;
965 int value = 0x2342;
966 int64_t value64 = 0x2342342343LL;
967 double valuef = 2.323423423;
968
969 obj = qobject_from_jsonf("%d", value);
970 g_assert(obj != NULL);
971 g_assert(qobject_type(obj) == QTYPE_QINT);
972
973 qint = qobject_to_qint(obj);
974 g_assert(qint_get_int(qint) == value);
975
976 QDECREF(qint);
977
978 obj = qobject_from_jsonf("%" PRId64, value64);
979 g_assert(obj != NULL);
980 g_assert(qobject_type(obj) == QTYPE_QINT);
981
982 qint = qobject_to_qint(obj);
983 g_assert(qint_get_int(qint) == value64);
984
985 QDECREF(qint);
986
987 obj = qobject_from_jsonf("%f", valuef);
988 g_assert(obj != NULL);
989 g_assert(qobject_type(obj) == QTYPE_QFLOAT);
990
991 qfloat = qobject_to_qfloat(obj);
992 g_assert(qfloat_get_double(qfloat) == valuef);
993
994 QDECREF(qfloat);
995 }
996
997 static void keyword_literal(void)
998 {
999 QObject *obj;
1000 QBool *qbool;
1001 QString *str;
1002
1003 obj = qobject_from_json("true");
1004 g_assert(obj != NULL);
1005 g_assert(qobject_type(obj) == QTYPE_QBOOL);
1006
1007 qbool = qobject_to_qbool(obj);
1008 g_assert(qbool_get_int(qbool) != 0);
1009
1010 str = qobject_to_json(obj);
1011 g_assert(strcmp(qstring_get_str(str), "true") == 0);
1012 QDECREF(str);
1013
1014 QDECREF(qbool);
1015
1016 obj = qobject_from_json("false");
1017 g_assert(obj != NULL);
1018 g_assert(qobject_type(obj) == QTYPE_QBOOL);
1019
1020 qbool = qobject_to_qbool(obj);
1021 g_assert(qbool_get_int(qbool) == 0);
1022
1023 str = qobject_to_json(obj);
1024 g_assert(strcmp(qstring_get_str(str), "false") == 0);
1025 QDECREF(str);
1026
1027 QDECREF(qbool);
1028
1029 obj = qobject_from_jsonf("%i", false);
1030 g_assert(obj != NULL);
1031 g_assert(qobject_type(obj) == QTYPE_QBOOL);
1032
1033 qbool = qobject_to_qbool(obj);
1034 g_assert(qbool_get_int(qbool) == 0);
1035
1036 QDECREF(qbool);
1037
1038 obj = qobject_from_jsonf("%i", true);
1039 g_assert(obj != NULL);
1040 g_assert(qobject_type(obj) == QTYPE_QBOOL);
1041
1042 qbool = qobject_to_qbool(obj);
1043 g_assert(qbool_get_int(qbool) != 0);
1044
1045 QDECREF(qbool);
1046 }
1047
1048 typedef struct LiteralQDictEntry LiteralQDictEntry;
1049 typedef struct LiteralQObject LiteralQObject;
1050
1051 struct LiteralQObject
1052 {
1053 int type;
1054 union {
1055 int64_t qint;
1056 const char *qstr;
1057 LiteralQDictEntry *qdict;
1058 LiteralQObject *qlist;
1059 } value;
1060 };
1061
1062 struct LiteralQDictEntry
1063 {
1064 const char *key;
1065 LiteralQObject value;
1066 };
1067
1068 #define QLIT_QINT(val) (LiteralQObject){.type = QTYPE_QINT, .value.qint = (val)}
1069 #define QLIT_QSTR(val) (LiteralQObject){.type = QTYPE_QSTRING, .value.qstr = (val)}
1070 #define QLIT_QDICT(val) (LiteralQObject){.type = QTYPE_QDICT, .value.qdict = (val)}
1071 #define QLIT_QLIST(val) (LiteralQObject){.type = QTYPE_QLIST, .value.qlist = (val)}
1072
1073 typedef struct QListCompareHelper
1074 {
1075 int index;
1076 LiteralQObject *objs;
1077 int result;
1078 } QListCompareHelper;
1079
1080 static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs);
1081
1082 static void compare_helper(QObject *obj, void *opaque)
1083 {
1084 QListCompareHelper *helper = opaque;
1085
1086 if (helper->result == 0) {
1087 return;
1088 }
1089
1090 if (helper->objs[helper->index].type == QTYPE_NONE) {
1091 helper->result = 0;
1092 return;
1093 }
1094
1095 helper->result = compare_litqobj_to_qobj(&helper->objs[helper->index++], obj);
1096 }
1097
1098 static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs)
1099 {
1100 if (lhs->type != qobject_type(rhs)) {
1101 return 0;
1102 }
1103
1104 switch (lhs->type) {
1105 case QTYPE_QINT:
1106 return lhs->value.qint == qint_get_int(qobject_to_qint(rhs));
1107 case QTYPE_QSTRING:
1108 return (strcmp(lhs->value.qstr, qstring_get_str(qobject_to_qstring(rhs))) == 0);
1109 case QTYPE_QDICT: {
1110 int i;
1111
1112 for (i = 0; lhs->value.qdict[i].key; i++) {
1113 QObject *obj = qdict_get(qobject_to_qdict(rhs), lhs->value.qdict[i].key);
1114
1115 if (!compare_litqobj_to_qobj(&lhs->value.qdict[i].value, obj)) {
1116 return 0;
1117 }
1118 }
1119
1120 return 1;
1121 }
1122 case QTYPE_QLIST: {
1123 QListCompareHelper helper;
1124
1125 helper.index = 0;
1126 helper.objs = lhs->value.qlist;
1127 helper.result = 1;
1128
1129 qlist_iter(qobject_to_qlist(rhs), compare_helper, &helper);
1130
1131 return helper.result;
1132 }
1133 default:
1134 break;
1135 }
1136
1137 return 0;
1138 }
1139
1140 static void simple_dict(void)
1141 {
1142 int i;
1143 struct {
1144 const char *encoded;
1145 LiteralQObject decoded;
1146 } test_cases[] = {
1147 {
1148 .encoded = "{\"foo\": 42, \"bar\": \"hello world\"}",
1149 .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
1150 { "foo", QLIT_QINT(42) },
1151 { "bar", QLIT_QSTR("hello world") },
1152 { }
1153 })),
1154 }, {
1155 .encoded = "{}",
1156 .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
1157 { }
1158 })),
1159 }, {
1160 .encoded = "{\"foo\": 43}",
1161 .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
1162 { "foo", QLIT_QINT(43) },
1163 { }
1164 })),
1165 },
1166 { }
1167 };
1168
1169 for (i = 0; test_cases[i].encoded; i++) {
1170 QObject *obj;
1171 QString *str;
1172
1173 obj = qobject_from_json(test_cases[i].encoded);
1174 g_assert(obj != NULL);
1175 g_assert(qobject_type(obj) == QTYPE_QDICT);
1176
1177 g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
1178
1179 str = qobject_to_json(obj);
1180 qobject_decref(obj);
1181
1182 obj = qobject_from_json(qstring_get_str(str));
1183 g_assert(obj != NULL);
1184 g_assert(qobject_type(obj) == QTYPE_QDICT);
1185
1186 g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
1187 qobject_decref(obj);
1188 QDECREF(str);
1189 }
1190 }
1191
1192 /*
1193 * this generates json of the form:
1194 * a(0,m) = [0, 1, ..., m-1]
1195 * a(n,m) = {
1196 * 'key0': a(0,m),
1197 * 'key1': a(1,m),
1198 * ...
1199 * 'key(n-1)': a(n-1,m)
1200 * }
1201 */
1202 static void gen_test_json(GString *gstr, int nest_level_max,
1203 int elem_count)
1204 {
1205 int i;
1206
1207 g_assert(gstr);
1208 if (nest_level_max == 0) {
1209 g_string_append(gstr, "[");
1210 for (i = 0; i < elem_count; i++) {
1211 g_string_append_printf(gstr, "%d", i);
1212 if (i < elem_count - 1) {
1213 g_string_append_printf(gstr, ", ");
1214 }
1215 }
1216 g_string_append(gstr, "]");
1217 return;
1218 }
1219
1220 g_string_append(gstr, "{");
1221 for (i = 0; i < nest_level_max; i++) {
1222 g_string_append_printf(gstr, "'key%d': ", i);
1223 gen_test_json(gstr, i, elem_count);
1224 if (i < nest_level_max - 1) {
1225 g_string_append(gstr, ",");
1226 }
1227 }
1228 g_string_append(gstr, "}");
1229 }
1230
1231 static void large_dict(void)
1232 {
1233 GString *gstr = g_string_new("");
1234 QObject *obj;
1235
1236 gen_test_json(gstr, 10, 100);
1237 obj = qobject_from_json(gstr->str);
1238 g_assert(obj != NULL);
1239
1240 qobject_decref(obj);
1241 g_string_free(gstr, true);
1242 }
1243
1244 static void simple_list(void)
1245 {
1246 int i;
1247 struct {
1248 const char *encoded;
1249 LiteralQObject decoded;
1250 } test_cases[] = {
1251 {
1252 .encoded = "[43,42]",
1253 .decoded = QLIT_QLIST(((LiteralQObject[]){
1254 QLIT_QINT(43),
1255 QLIT_QINT(42),
1256 { }
1257 })),
1258 },
1259 {
1260 .encoded = "[43]",
1261 .decoded = QLIT_QLIST(((LiteralQObject[]){
1262 QLIT_QINT(43),
1263 { }
1264 })),
1265 },
1266 {
1267 .encoded = "[]",
1268 .decoded = QLIT_QLIST(((LiteralQObject[]){
1269 { }
1270 })),
1271 },
1272 {
1273 .encoded = "[{}]",
1274 .decoded = QLIT_QLIST(((LiteralQObject[]){
1275 QLIT_QDICT(((LiteralQDictEntry[]){
1276 {},
1277 })),
1278 {},
1279 })),
1280 },
1281 { }
1282 };
1283
1284 for (i = 0; test_cases[i].encoded; i++) {
1285 QObject *obj;
1286 QString *str;
1287
1288 obj = qobject_from_json(test_cases[i].encoded);
1289 g_assert(obj != NULL);
1290 g_assert(qobject_type(obj) == QTYPE_QLIST);
1291
1292 g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
1293
1294 str = qobject_to_json(obj);
1295 qobject_decref(obj);
1296
1297 obj = qobject_from_json(qstring_get_str(str));
1298 g_assert(obj != NULL);
1299 g_assert(qobject_type(obj) == QTYPE_QLIST);
1300
1301 g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
1302 qobject_decref(obj);
1303 QDECREF(str);
1304 }
1305 }
1306
1307 static void simple_whitespace(void)
1308 {
1309 int i;
1310 struct {
1311 const char *encoded;
1312 LiteralQObject decoded;
1313 } test_cases[] = {
1314 {
1315 .encoded = " [ 43 , 42 ]",
1316 .decoded = QLIT_QLIST(((LiteralQObject[]){
1317 QLIT_QINT(43),
1318 QLIT_QINT(42),
1319 { }
1320 })),
1321 },
1322 {
1323 .encoded = " [ 43 , { 'h' : 'b' }, [ ], 42 ]",
1324 .decoded = QLIT_QLIST(((LiteralQObject[]){
1325 QLIT_QINT(43),
1326 QLIT_QDICT(((LiteralQDictEntry[]){
1327 { "h", QLIT_QSTR("b") },
1328 { }})),
1329 QLIT_QLIST(((LiteralQObject[]){
1330 { }})),
1331 QLIT_QINT(42),
1332 { }
1333 })),
1334 },
1335 {
1336 .encoded = " [ 43 , { 'h' : 'b' , 'a' : 32 }, [ ], 42 ]",
1337 .decoded = QLIT_QLIST(((LiteralQObject[]){
1338 QLIT_QINT(43),
1339 QLIT_QDICT(((LiteralQDictEntry[]){
1340 { "h", QLIT_QSTR("b") },
1341 { "a", QLIT_QINT(32) },
1342 { }})),
1343 QLIT_QLIST(((LiteralQObject[]){
1344 { }})),
1345 QLIT_QINT(42),
1346 { }
1347 })),
1348 },
1349 { }
1350 };
1351
1352 for (i = 0; test_cases[i].encoded; i++) {
1353 QObject *obj;
1354 QString *str;
1355
1356 obj = qobject_from_json(test_cases[i].encoded);
1357 g_assert(obj != NULL);
1358 g_assert(qobject_type(obj) == QTYPE_QLIST);
1359
1360 g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
1361
1362 str = qobject_to_json(obj);
1363 qobject_decref(obj);
1364
1365 obj = qobject_from_json(qstring_get_str(str));
1366 g_assert(obj != NULL);
1367 g_assert(qobject_type(obj) == QTYPE_QLIST);
1368
1369 g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
1370
1371 qobject_decref(obj);
1372 QDECREF(str);
1373 }
1374 }
1375
1376 static void simple_varargs(void)
1377 {
1378 QObject *embedded_obj;
1379 QObject *obj;
1380 LiteralQObject decoded = QLIT_QLIST(((LiteralQObject[]){
1381 QLIT_QINT(1),
1382 QLIT_QINT(2),
1383 QLIT_QLIST(((LiteralQObject[]){
1384 QLIT_QINT(32),
1385 QLIT_QINT(42),
1386 {}})),
1387 {}}));
1388
1389 embedded_obj = qobject_from_json("[32, 42]");
1390 g_assert(embedded_obj != NULL);
1391
1392 obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj);
1393 g_assert(obj != NULL);
1394
1395 g_assert(compare_litqobj_to_qobj(&decoded, obj) == 1);
1396
1397 qobject_decref(obj);
1398 }
1399
1400 static void empty_input(void)
1401 {
1402 const char *empty = "";
1403
1404 QObject *obj = qobject_from_json(empty);
1405 g_assert(obj == NULL);
1406 }
1407
1408 static void unterminated_string(void)
1409 {
1410 QObject *obj = qobject_from_json("\"abc");
1411 g_assert(obj == NULL);
1412 }
1413
1414 static void unterminated_sq_string(void)
1415 {
1416 QObject *obj = qobject_from_json("'abc");
1417 g_assert(obj == NULL);
1418 }
1419
1420 static void unterminated_escape(void)
1421 {
1422 QObject *obj = qobject_from_json("\"abc\\\"");
1423 g_assert(obj == NULL);
1424 }
1425
1426 static void unterminated_array(void)
1427 {
1428 QObject *obj = qobject_from_json("[32");
1429 g_assert(obj == NULL);
1430 }
1431
1432 static void unterminated_array_comma(void)
1433 {
1434 QObject *obj = qobject_from_json("[32,");
1435 g_assert(obj == NULL);
1436 }
1437
1438 static void invalid_array_comma(void)
1439 {
1440 QObject *obj = qobject_from_json("[32,}");
1441 g_assert(obj == NULL);
1442 }
1443
1444 static void unterminated_dict(void)
1445 {
1446 QObject *obj = qobject_from_json("{'abc':32");
1447 g_assert(obj == NULL);
1448 }
1449
1450 static void unterminated_dict_comma(void)
1451 {
1452 QObject *obj = qobject_from_json("{'abc':32,");
1453 g_assert(obj == NULL);
1454 }
1455
1456 static void invalid_dict_comma(void)
1457 {
1458 QObject *obj = qobject_from_json("{'abc':32,}");
1459 g_assert(obj == NULL);
1460 }
1461
1462 static void unterminated_literal(void)
1463 {
1464 QObject *obj = qobject_from_json("nul");
1465 g_assert(obj == NULL);
1466 }
1467
1468 int main(int argc, char **argv)
1469 {
1470 g_test_init(&argc, &argv, NULL);
1471
1472 g_test_add_func("/literals/string/simple", simple_string);
1473 g_test_add_func("/literals/string/escaped", escaped_string);
1474 g_test_add_func("/literals/string/utf8", utf8_string);
1475 g_test_add_func("/literals/string/single_quote", single_quote_string);
1476 g_test_add_func("/literals/string/vararg", vararg_string);
1477
1478 g_test_add_func("/literals/number/simple", simple_number);
1479 g_test_add_func("/literals/number/float", float_number);
1480 g_test_add_func("/literals/number/vararg", vararg_number);
1481
1482 g_test_add_func("/literals/keyword", keyword_literal);
1483
1484 g_test_add_func("/dicts/simple_dict", simple_dict);
1485 g_test_add_func("/dicts/large_dict", large_dict);
1486 g_test_add_func("/lists/simple_list", simple_list);
1487
1488 g_test_add_func("/whitespace/simple_whitespace", simple_whitespace);
1489
1490 g_test_add_func("/varargs/simple_varargs", simple_varargs);
1491
1492 g_test_add_func("/errors/empty_input", empty_input);
1493 g_test_add_func("/errors/unterminated/string", unterminated_string);
1494 g_test_add_func("/errors/unterminated/escape", unterminated_escape);
1495 g_test_add_func("/errors/unterminated/sq_string", unterminated_sq_string);
1496 g_test_add_func("/errors/unterminated/array", unterminated_array);
1497 g_test_add_func("/errors/unterminated/array_comma", unterminated_array_comma);
1498 g_test_add_func("/errors/unterminated/dict", unterminated_dict);
1499 g_test_add_func("/errors/unterminated/dict_comma", unterminated_dict_comma);
1500 g_test_add_func("/errors/invalid_array_comma", invalid_array_comma);
1501 g_test_add_func("/errors/invalid_dict_comma", invalid_dict_comma);
1502 g_test_add_func("/errors/unterminated/literal", unterminated_literal);
1503
1504 return g_test_run();
1505 }