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