]>
Commit | Line | Data |
---|---|---|
422c46a8 AL |
1 | /* |
2 | * Copyright IBM, Corp. 2009 | |
3960c41f | 3 | * Copyright (c) 2013 Red Hat Inc. |
422c46a8 AL |
4 | * |
5 | * Authors: | |
6 | * Anthony Liguori <aliguori@us.ibm.com> | |
d6244e2c | 7 | * Markus Armbruster <armbru@redhat.com> |
422c46a8 AL |
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 | */ | |
ef76dc59 | 13 | #include <glib.h> |
422c46a8 | 14 | |
7b1b5d19 PB |
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" | |
422c46a8 AL |
22 | |
23 | #include "qemu-common.h" | |
24 | ||
ef76dc59 | 25 | static void escaped_string(void) |
422c46a8 AL |
26 | { |
27 | int i; | |
28 | struct { | |
29 | const char *encoded; | |
30 | const char *decoded; | |
6ee59202 | 31 | int skip; |
422c46a8 | 32 | } test_cases[] = { |
d22b0bd7 LC |
33 | { "\"\\b\"", "\b" }, |
34 | { "\"\\f\"", "\f" }, | |
35 | { "\"\\n\"", "\n" }, | |
36 | { "\"\\r\"", "\r" }, | |
37 | { "\"\\t\"", "\t" }, | |
69faeee1 JK |
38 | { "\"/\"", "/" }, |
39 | { "\"\\/\"", "/", .skip = 1 }, | |
d22b0bd7 | 40 | { "\"\\\\\"", "\\" }, |
422c46a8 AL |
41 | { "\"\\\"\"", "\"" }, |
42 | { "\"hello world \\\"embedded string\\\"\"", | |
43 | "hello world \"embedded string\"" }, | |
44 | { "\"hello world\\nwith new line\"", "hello world\nwith new line" }, | |
6ee59202 | 45 | { "\"single byte utf-8 \\u0020\"", "single byte utf-8 ", .skip = 1 }, |
422c46a8 AL |
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 | ||
ef76dc59 AL |
57 | g_assert(obj != NULL); |
58 | g_assert(qobject_type(obj) == QTYPE_QSTRING); | |
422c46a8 AL |
59 | |
60 | str = qobject_to_qstring(obj); | |
ef76dc59 | 61 | g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].decoded); |
422c46a8 | 62 | |
6ee59202 AL |
63 | if (test_cases[i].skip == 0) { |
64 | str = qobject_to_json(obj); | |
ef76dc59 | 65 | g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].encoded); |
6ee59202 AL |
66 | qobject_decref(obj); |
67 | } | |
68 | ||
422c46a8 AL |
69 | QDECREF(str); |
70 | } | |
71 | } | |
422c46a8 | 72 | |
ef76dc59 | 73 | static void simple_string(void) |
422c46a8 AL |
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 | ||
ef76dc59 AL |
92 | g_assert(obj != NULL); |
93 | g_assert(qobject_type(obj) == QTYPE_QSTRING); | |
422c46a8 AL |
94 | |
95 | str = qobject_to_qstring(obj); | |
ef76dc59 | 96 | g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0); |
422c46a8 | 97 | |
6ee59202 | 98 | str = qobject_to_json(obj); |
ef76dc59 | 99 | g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0); |
6ee59202 AL |
100 | |
101 | qobject_decref(obj); | |
102 | ||
422c46a8 AL |
103 | QDECREF(str); |
104 | } | |
105 | } | |
422c46a8 | 106 | |
ef76dc59 | 107 | static void single_quote_string(void) |
422c46a8 AL |
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 | ||
ef76dc59 AL |
126 | g_assert(obj != NULL); |
127 | g_assert(qobject_type(obj) == QTYPE_QSTRING); | |
422c46a8 AL |
128 | |
129 | str = qobject_to_qstring(obj); | |
ef76dc59 | 130 | g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0); |
422c46a8 AL |
131 | |
132 | QDECREF(str); | |
133 | } | |
134 | } | |
422c46a8 | 135 | |
3960c41f MA |
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 | * The JSON formatter replaces some invalid sequences by U+FFFF (a | |
148 | * noncharacter), and goes wonky for others. | |
149 | * | |
150 | * For both directions, we should either reject all invalid | |
151 | * sequences, or minimize overlong sequences and replace all other | |
152 | * invalid sequences by a suitable replacement character. A | |
153 | * common choice for replacement is U+FFFD. | |
154 | * | |
155 | * Problem: we can't easily deal with embedded U+0000. Parsing | |
156 | * the JSON string "this \\u0000" is fun" yields "this \0 is fun", | |
157 | * which gets misinterpreted as NUL-terminated "this ". We should | |
158 | * consider using overlong encoding \xC0\x80 for U+0000 ("modified | |
159 | * UTF-8"). | |
160 | * | |
161 | * Test cases are scraped from Markus Kuhn's UTF-8 decoder | |
162 | * capability and stress test at | |
163 | * http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt | |
164 | */ | |
165 | static const struct { | |
166 | const char *json_in; | |
167 | const char *utf8_out; | |
168 | const char *json_out; /* defaults to @json_in */ | |
169 | const char *utf8_in; /* defaults to @utf8_out */ | |
170 | } test_cases[] = { | |
171 | /* | |
172 | * Bug markers used here: | |
173 | * - bug: not corrected | |
174 | * JSON parser fails to correct invalid sequence(s) | |
175 | * - bug: rejected | |
176 | * JSON parser rejects invalid sequence(s) | |
177 | * We may choose to define this as feature | |
178 | * - bug: want "\"...\"" | |
179 | * JSON formatter produces incorrect result, this is the | |
180 | * correct one, assuming replacement character U+FFFF | |
181 | * - bug: want "..." (no \") | |
182 | * JSON parser produces incorrect result, this is the | |
183 | * correct one, assuming replacement character U+FFFF | |
184 | * We may choose to reject instead of replace | |
185 | * Not marked explicitly, but trivial to find: | |
186 | * - JSON formatter replacing invalid sequence by \\uFFFF is a | |
187 | * bug if we want it to fail for invalid sequences. | |
188 | */ | |
189 | ||
190 | /* 1 Some correct UTF-8 text */ | |
191 | { | |
192 | /* a bit of German */ | |
193 | "\"Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt" | |
194 | " jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.\"", | |
195 | "Falsches \xC3\x9C" "ben von Xylophonmusik qu\xC3\xA4lt" | |
196 | " jeden gr\xC3\xB6\xC3\x9F" "eren Zwerg.", | |
197 | "\"Falsches \\u00DCben von Xylophonmusik qu\\u00E4lt" | |
198 | " jeden gr\\u00F6\\u00DFeren Zwerg.\"", | |
199 | }, | |
200 | { | |
201 | /* a bit of Greek */ | |
202 | "\"\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5\"", | |
203 | "\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5", | |
204 | "\"\\u03BA\\u1F79\\u03C3\\u03BC\\u03B5\"", | |
205 | }, | |
206 | /* 2 Boundary condition test cases */ | |
207 | /* 2.1 First possible sequence of a certain length */ | |
208 | /* 2.1.1 1 byte U+0000 */ | |
209 | { | |
210 | "\"\\u0000\"", | |
211 | "", /* bug: want overlong "\xC0\x80" */ | |
212 | "\"\"", /* bug: want "\"\\u0000\"" */ | |
213 | }, | |
214 | /* 2.1.2 2 bytes U+0080 */ | |
215 | { | |
216 | "\"\xC2\x80\"", | |
217 | "\xC2\x80", | |
218 | "\"\\u0080\"", | |
219 | }, | |
220 | /* 2.1.3 3 bytes U+0800 */ | |
221 | { | |
222 | "\"\xE0\xA0\x80\"", | |
223 | "\xE0\xA0\x80", | |
224 | "\"\\u0800\"", | |
225 | }, | |
226 | /* 2.1.4 4 bytes U+10000 */ | |
227 | { | |
228 | "\"\xF0\x90\x80\x80\"", | |
229 | "\xF0\x90\x80\x80", | |
230 | "\"\\u0400\\uFFFF\"", /* bug: want "\"\\uD800\\uDC00\"" */ | |
231 | }, | |
232 | /* 2.1.5 5 bytes U+200000 */ | |
233 | { | |
234 | "\"\xF8\x88\x80\x80\x80\"", | |
235 | NULL, /* bug: rejected */ | |
236 | "\"\\u8200\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
237 | "\xF8\x88\x80\x80\x80", | |
238 | }, | |
239 | /* 2.1.6 6 bytes U+4000000 */ | |
240 | { | |
241 | "\"\xFC\x84\x80\x80\x80\x80\"", | |
242 | NULL, /* bug: rejected */ | |
243 | "\"\\uC100\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
244 | "\xFC\x84\x80\x80\x80\x80", | |
245 | }, | |
246 | /* 2.2 Last possible sequence of a certain length */ | |
247 | /* 2.2.1 1 byte U+007F */ | |
248 | { | |
249 | "\"\x7F\"", | |
250 | "\x7F", | |
251 | "\"\177\"", | |
252 | }, | |
253 | /* 2.2.2 2 bytes U+07FF */ | |
254 | { | |
255 | "\"\xDF\xBF\"", | |
256 | "\xDF\xBF", | |
257 | "\"\\u07FF\"", | |
258 | }, | |
259 | /* 2.2.3 3 bytes U+FFFF */ | |
260 | { | |
261 | "\"\xEF\xBF\xBF\"", | |
262 | "\xEF\xBF\xBF", | |
263 | "\"\\uFFFF\"", | |
264 | }, | |
265 | /* 2.2.4 4 bytes U+1FFFFF */ | |
266 | { | |
267 | "\"\xF7\xBF\xBF\xBF\"", | |
268 | NULL, /* bug: rejected */ | |
269 | "\"\\u7FFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\uBFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\uDFFF\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
284 | "\xFD\xBF\xBF\xBF\xBF\xBF", | |
285 | }, | |
286 | /* 2.3 Other boundary conditions */ | |
287 | { | |
d6244e2c | 288 | /* last one before surrogate range: U+D7FF */ |
3960c41f MA |
289 | "\"\xED\x9F\xBF\"", |
290 | "\xED\x9F\xBF", | |
291 | "\"\\uD7FF\"", | |
292 | }, | |
293 | { | |
d6244e2c | 294 | /* first one after surrogate range: U+E000 */ |
3960c41f MA |
295 | "\"\xEE\x80\x80\"", |
296 | "\xEE\x80\x80", | |
297 | "\"\\uE000\"", | |
298 | }, | |
299 | { | |
d6244e2c | 300 | /* last one in BMP: U+FFFD */ |
3960c41f MA |
301 | "\"\xEF\xBF\xBD\"", |
302 | "\xEF\xBF\xBD", | |
303 | "\"\\uFFFD\"", | |
304 | }, | |
305 | { | |
d6244e2c | 306 | /* last one in last plane: U+10FFFF */ |
3960c41f MA |
307 | "\"\xF4\x8F\xBF\xBF\"", |
308 | "\xF4\x8F\xBF\xBF", | |
309 | "\"\\u43FF\\uFFFF\"", /* bug: want "\"\\uDBFF\\uDFFF\"" */ | |
310 | }, | |
311 | { | |
d6244e2c | 312 | /* first one beyond Unicode range: U+110000 */ |
3960c41f MA |
313 | "\"\xF4\x90\x80\x80\"", |
314 | "\xF4\x90\x80\x80", | |
315 | "\"\\u4400\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\uFFFF\"", | |
324 | }, | |
325 | /* 3.1.2 Last continuation byte */ | |
326 | { | |
327 | "\"\xBF\"", | |
328 | "\xBF", /* bug: not corrected */ | |
329 | "\"\\uFFFF\"", | |
330 | }, | |
331 | /* 3.1.3 2 continuation bytes */ | |
332 | { | |
333 | "\"\x80\xBF\"", | |
334 | "\x80\xBF", /* bug: not corrected */ | |
335 | "\"\\uFFFF\\uFFFF\"", | |
336 | }, | |
337 | /* 3.1.4 3 continuation bytes */ | |
338 | { | |
339 | "\"\x80\xBF\x80\"", | |
340 | "\x80\xBF\x80", /* bug: not corrected */ | |
341 | "\"\\uFFFF\\uFFFF\\uFFFF\"", | |
342 | }, | |
343 | /* 3.1.5 4 continuation bytes */ | |
344 | { | |
345 | "\"\x80\xBF\x80\xBF\"", | |
346 | "\x80\xBF\x80\xBF", /* bug: not corrected */ | |
347 | "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"", | |
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 | "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"", | |
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 | "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"", | |
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 | "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"", | |
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 | "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
387 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
388 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
389 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
390 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
391 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
392 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
393 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"" | |
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 | "\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF " | |
404 | "\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF " | |
405 | "\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF " | |
406 | "\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"", | |
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 | "\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF " | |
420 | "\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"", | |
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 | "\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \\uFFFF \"", | |
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 | "\"\\uFFFF \\uFFFF \\uFFFF \\uFFFF \"", | |
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 | "\"\\uFFFF \\uFFFF \"", | |
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 | "\"\\uFFFF\"", | |
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 | "\"\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\u0000\"", /* bug: want "\"\\uFFFF\"" */ | |
462 | }, | |
463 | /* 3.3.4 5-byte sequence with last byte missing (U+0000) */ | |
464 | { | |
d6244e2c | 465 | "\"\xF8\x80\x80\x80\"", |
3960c41f MA |
466 | NULL, /* bug: rejected */ |
467 | "\"\\u8000\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\uC000\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\uFFFF\"", | |
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 | "\"\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
488 | }, | |
489 | /* 3.3.8 4-byte sequence with last byte missing (U+1FFFFF) */ | |
490 | { | |
491 | "\"\xF7\xBF\xBF\"", | |
492 | NULL, /* bug: rejected */ | |
493 | "\"\\u7FFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\uBFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
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 | "\"\\uDFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"", */ | |
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 | /* bug: want "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF" | |
516 | "\\uFFFF\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"" */ | |
517 | "\"\\u0020\\uFFFF\\u0000\\u8000\\uFFFF\\uC000\\uFFFF\\uFFFF" | |
518 | "\\u07EF\\uFFFF\\u7FFF\\uBFFF\\uFFFF\\uDFFF\\uFFFF\\uFFFF\"", | |
519 | "\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80" | |
520 | "\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF", | |
521 | }, | |
522 | /* 3.5 Impossible bytes */ | |
523 | { | |
524 | "\"\xFE\"", | |
525 | NULL, /* bug: rejected */ | |
526 | "\"\\uFFFF\"", | |
527 | "\xFE", | |
528 | }, | |
529 | { | |
530 | "\"\xFF\"", | |
531 | NULL, /* bug: rejected */ | |
532 | "\"\\uFFFF\"", | |
533 | "\xFF", | |
534 | }, | |
535 | { | |
536 | "\"\xFE\xFE\xFF\xFF\"", | |
537 | NULL, /* bug: rejected */ | |
538 | /* bug: want "\"\\uFFFF\\uFFFF\\uFFFF\\uFFFF\"" */ | |
539 | "\"\\uEFBF\\uFFFF\"", | |
540 | "\xFE\xFE\xFF\xFF", | |
541 | }, | |
542 | /* 4 Overlong sequences */ | |
543 | /* 4.1 Overlong '/' */ | |
544 | { | |
545 | "\"\xC0\xAF\"", | |
546 | NULL, /* bug: rejected */ | |
547 | "\"\\u002F\"", /* bug: want "\"/\"" */ | |
548 | "\xC0\xAF", | |
549 | }, | |
550 | { | |
551 | "\"\xE0\x80\xAF\"", | |
552 | "\xE0\x80\xAF", /* bug: not corrected */ | |
553 | "\"\\u002F\"", /* bug: want "\"/\"" */ | |
554 | }, | |
555 | { | |
556 | "\"\xF0\x80\x80\xAF\"", | |
557 | "\xF0\x80\x80\xAF", /* bug: not corrected */ | |
558 | "\"\\u0000\\uFFFF\"" /* bug: want "\"/\"" */ | |
559 | }, | |
560 | { | |
561 | "\"\xF8\x80\x80\x80\xAF\"", | |
562 | NULL, /* bug: rejected */ | |
563 | "\"\\u8000\\uFFFF\\uFFFF\"", /* bug: want "\"/\"" */ | |
564 | "\xF8\x80\x80\x80\xAF", | |
565 | }, | |
566 | { | |
567 | "\"\xFC\x80\x80\x80\x80\xAF\"", | |
568 | NULL, /* bug: rejected */ | |
569 | "\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"/\"" */ | |
570 | "\xFC\x80\x80\x80\x80\xAF", | |
571 | }, | |
d6244e2c MA |
572 | /* |
573 | * 4.2 Maximum overlong sequences | |
574 | * Highest Unicode value that is still resulting in an | |
575 | * overlong sequence if represented with the given number of | |
576 | * bytes. This is a boundary test for safe UTF-8 decoders. | |
577 | */ | |
3960c41f MA |
578 | { |
579 | /* \U+007F */ | |
580 | "\"\xC1\xBF\"", | |
581 | NULL, /* bug: rejected */ | |
582 | "\"\\u007F\"", /* bug: want "\"\177\"" */ | |
583 | "\xC1\xBF", | |
584 | }, | |
585 | { | |
586 | /* \U+07FF */ | |
587 | "\"\xE0\x9F\xBF\"", | |
588 | "\xE0\x9F\xBF", /* bug: not corrected */ | |
589 | "\"\\u07FF\"", | |
590 | }, | |
591 | { | |
592 | /* \U+FFFF */ | |
593 | "\"\xF0\x8F\xBF\xBF\"", | |
594 | "\xF0\x8F\xBF\xBF", /* bug: not corrected */ | |
595 | "\"\\u03FF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
596 | }, | |
597 | { | |
598 | /* \U+1FFFFF */ | |
599 | "\"\xF8\x87\xBF\xBF\xBF\"", | |
600 | NULL, /* bug: rejected */ | |
601 | "\"\\u81FF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
602 | "\xF8\x87\xBF\xBF\xBF", | |
603 | }, | |
604 | { | |
605 | /* \U+3FFFFFF */ | |
606 | "\"\xFC\x83\xBF\xBF\xBF\xBF\"", | |
607 | NULL, /* bug: rejected */ | |
608 | "\"\\uC0FF\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
609 | "\xFC\x83\xBF\xBF\xBF\xBF", | |
610 | }, | |
611 | /* 4.3 Overlong representation of the NUL character */ | |
612 | { | |
613 | /* \U+0000 */ | |
614 | "\"\xC0\x80\"", | |
615 | NULL, /* bug: rejected */ | |
616 | "\"\\u0000\"", | |
617 | "\xC0\x80", | |
618 | }, | |
619 | { | |
620 | /* \U+0000 */ | |
621 | "\"\xE0\x80\x80\"", | |
622 | "\xE0\x80\x80", /* bug: not corrected */ | |
623 | "\"\\u0000\"", | |
624 | }, | |
625 | { | |
626 | /* \U+0000 */ | |
627 | "\"\xF0\x80\x80\x80\"", | |
628 | "\xF0\x80\x80\x80", /* bug: not corrected */ | |
629 | "\"\\u0000\\uFFFF\"", /* bug: want "\"\\u0000\"" */ | |
630 | }, | |
631 | { | |
632 | /* \U+0000 */ | |
633 | "\"\xF8\x80\x80\x80\x80\"", | |
634 | NULL, /* bug: rejected */ | |
635 | "\"\\u8000\\uFFFF\\uFFFF\"", /* bug: want "\"\\u0000\"" */ | |
636 | "\xF8\x80\x80\x80\x80", | |
637 | }, | |
638 | { | |
639 | /* \U+0000 */ | |
640 | "\"\xFC\x80\x80\x80\x80\x80\"", | |
641 | NULL, /* bug: rejected */ | |
642 | "\"\\uC000\\uFFFF\\uFFFF\\uFFFF\"", /* bug: want "\"\\u0000\"" */ | |
643 | "\xFC\x80\x80\x80\x80\x80", | |
644 | }, | |
645 | /* 5 Illegal code positions */ | |
646 | /* 5.1 Single UTF-16 surrogates */ | |
647 | { | |
648 | /* \U+D800 */ | |
649 | "\"\xED\xA0\x80\"", | |
650 | "\xED\xA0\x80", /* bug: not corrected */ | |
651 | "\"\\uD800\"", /* bug: want "\"\\uFFFF\"" */ | |
652 | }, | |
653 | { | |
654 | /* \U+DB7F */ | |
655 | "\"\xED\xAD\xBF\"", | |
656 | "\xED\xAD\xBF", /* bug: not corrected */ | |
657 | "\"\\uDB7F\"", /* bug: want "\"\\uFFFF\"" */ | |
658 | }, | |
659 | { | |
660 | /* \U+DB80 */ | |
661 | "\"\xED\xAE\x80\"", | |
662 | "\xED\xAE\x80", /* bug: not corrected */ | |
663 | "\"\\uDB80\"", /* bug: want "\"\\uFFFF\"" */ | |
664 | }, | |
665 | { | |
666 | /* \U+DBFF */ | |
667 | "\"\xED\xAF\xBF\"", | |
668 | "\xED\xAF\xBF", /* bug: not corrected */ | |
669 | "\"\\uDBFF\"", /* bug: want "\"\\uFFFF\"" */ | |
670 | }, | |
671 | { | |
672 | /* \U+DC00 */ | |
673 | "\"\xED\xB0\x80\"", | |
674 | "\xED\xB0\x80", /* bug: not corrected */ | |
675 | "\"\\uDC00\"", /* bug: want "\"\\uFFFF\"" */ | |
676 | }, | |
677 | { | |
678 | /* \U+DF80 */ | |
679 | "\"\xED\xBE\x80\"", | |
680 | "\xED\xBE\x80", /* bug: not corrected */ | |
681 | "\"\\uDF80\"", /* bug: want "\"\\uFFFF\"" */ | |
682 | }, | |
683 | { | |
684 | /* \U+DFFF */ | |
685 | "\"\xED\xBF\xBF\"", | |
686 | "\xED\xBF\xBF", /* bug: not corrected */ | |
687 | "\"\\uDFFF\"", /* bug: want "\"\\uFFFF\"" */ | |
688 | }, | |
689 | /* 5.2 Paired UTF-16 surrogates */ | |
690 | { | |
691 | /* \U+D800\U+DC00 */ | |
692 | "\"\xED\xA0\x80\xED\xB0\x80\"", | |
693 | "\xED\xA0\x80\xED\xB0\x80", /* bug: not corrected */ | |
694 | "\"\\uD800\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
695 | }, | |
696 | { | |
697 | /* \U+D800\U+DFFF */ | |
698 | "\"\xED\xA0\x80\xED\xBF\xBF\"", | |
699 | "\xED\xA0\x80\xED\xBF\xBF", /* bug: not corrected */ | |
700 | "\"\\uD800\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
701 | }, | |
702 | { | |
703 | /* \U+DB7F\U+DC00 */ | |
704 | "\"\xED\xAD\xBF\xED\xB0\x80\"", | |
705 | "\xED\xAD\xBF\xED\xB0\x80", /* bug: not corrected */ | |
706 | "\"\\uDB7F\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
707 | }, | |
708 | { | |
709 | /* \U+DB7F\U+DFFF */ | |
710 | "\"\xED\xAD\xBF\xED\xBF\xBF\"", | |
711 | "\xED\xAD\xBF\xED\xBF\xBF", /* bug: not corrected */ | |
712 | "\"\\uDB7F\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
713 | }, | |
714 | { | |
715 | /* \U+DB80\U+DC00 */ | |
716 | "\"\xED\xAE\x80\xED\xB0\x80\"", | |
717 | "\xED\xAE\x80\xED\xB0\x80", /* bug: not corrected */ | |
718 | "\"\\uDB80\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
719 | }, | |
720 | { | |
721 | /* \U+DB80\U+DFFF */ | |
722 | "\"\xED\xAE\x80\xED\xBF\xBF\"", | |
723 | "\xED\xAE\x80\xED\xBF\xBF", /* bug: not corrected */ | |
724 | "\"\\uDB80\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
725 | }, | |
726 | { | |
727 | /* \U+DBFF\U+DC00 */ | |
728 | "\"\xED\xAF\xBF\xED\xB0\x80\"", | |
729 | "\xED\xAF\xBF\xED\xB0\x80", /* bug: not corrected */ | |
730 | "\"\\uDBFF\\uDC00\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
731 | }, | |
732 | { | |
733 | /* \U+DBFF\U+DFFF */ | |
734 | "\"\xED\xAF\xBF\xED\xBF\xBF\"", | |
735 | "\xED\xAF\xBF\xED\xBF\xBF", /* bug: not corrected */ | |
736 | "\"\\uDBFF\\uDFFF\"", /* bug: want "\"\\uFFFF\\uFFFF\"" */ | |
737 | }, | |
738 | /* 5.3 Other illegal code positions */ | |
739 | { | |
740 | /* \U+FFFE */ | |
741 | "\"\xEF\xBF\xBE\"", | |
742 | "\xEF\xBF\xBE", /* bug: not corrected */ | |
743 | "\"\\uFFFE\"", /* bug: not corrected */ | |
744 | }, | |
745 | { | |
746 | /* \U+FFFF */ | |
747 | "\"\xEF\xBF\xBF\"", | |
748 | "\xEF\xBF\xBF", /* bug: not corrected */ | |
749 | "\"\\uFFFF\"", /* bug: not corrected */ | |
750 | }, | |
751 | {} | |
752 | }; | |
753 | int i; | |
754 | QObject *obj; | |
755 | QString *str; | |
756 | const char *json_in, *utf8_out, *utf8_in, *json_out; | |
757 | ||
758 | for (i = 0; test_cases[i].json_in; i++) { | |
759 | json_in = test_cases[i].json_in; | |
760 | utf8_out = test_cases[i].utf8_out; | |
761 | utf8_in = test_cases[i].utf8_in ?: test_cases[i].utf8_out; | |
762 | json_out = test_cases[i].json_out ?: test_cases[i].json_in; | |
763 | ||
764 | obj = qobject_from_json(json_in); | |
765 | if (utf8_out) { | |
766 | g_assert(obj); | |
767 | g_assert(qobject_type(obj) == QTYPE_QSTRING); | |
768 | str = qobject_to_qstring(obj); | |
769 | g_assert_cmpstr(qstring_get_str(str), ==, utf8_out); | |
770 | } else { | |
771 | g_assert(!obj); | |
772 | } | |
773 | qobject_decref(obj); | |
774 | ||
775 | obj = QOBJECT(qstring_from_str(utf8_in)); | |
776 | str = qobject_to_json(obj); | |
777 | if (json_out) { | |
778 | g_assert(str); | |
779 | g_assert_cmpstr(qstring_get_str(str), ==, json_out); | |
780 | } else { | |
781 | g_assert(!str); | |
782 | } | |
783 | QDECREF(str); | |
784 | qobject_decref(obj); | |
785 | ||
786 | /* | |
787 | * Disabled, because json_out currently contains the crap | |
788 | * qobject_to_json() produces. | |
789 | * FIXME Enable once these bugs have been fixed. | |
790 | */ | |
791 | if (0 && json_out != json_in) { | |
792 | obj = qobject_from_json(json_out); | |
793 | g_assert(obj); | |
794 | g_assert(qobject_type(obj) == QTYPE_QSTRING); | |
795 | str = qobject_to_qstring(obj); | |
796 | g_assert_cmpstr(qstring_get_str(str), ==, utf8_out); | |
797 | } | |
798 | } | |
799 | } | |
800 | ||
ef76dc59 | 801 | static void vararg_string(void) |
422c46a8 AL |
802 | { |
803 | int i; | |
804 | struct { | |
805 | const char *decoded; | |
806 | } test_cases[] = { | |
807 | { "hello world" }, | |
808 | { "the quick brown fox jumped over the fence" }, | |
809 | {} | |
810 | }; | |
811 | ||
812 | for (i = 0; test_cases[i].decoded; i++) { | |
813 | QObject *obj; | |
814 | QString *str; | |
815 | ||
816 | obj = qobject_from_jsonf("%s", test_cases[i].decoded); | |
817 | ||
ef76dc59 AL |
818 | g_assert(obj != NULL); |
819 | g_assert(qobject_type(obj) == QTYPE_QSTRING); | |
422c46a8 AL |
820 | |
821 | str = qobject_to_qstring(obj); | |
ef76dc59 | 822 | g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0); |
422c46a8 AL |
823 | |
824 | QDECREF(str); | |
825 | } | |
826 | } | |
422c46a8 | 827 | |
ef76dc59 | 828 | static void simple_number(void) |
422c46a8 AL |
829 | { |
830 | int i; | |
831 | struct { | |
832 | const char *encoded; | |
833 | int64_t decoded; | |
6ee59202 | 834 | int skip; |
422c46a8 AL |
835 | } test_cases[] = { |
836 | { "0", 0 }, | |
837 | { "1234", 1234 }, | |
838 | { "1", 1 }, | |
839 | { "-32", -32 }, | |
6ee59202 | 840 | { "-0", 0, .skip = 1 }, |
422c46a8 AL |
841 | { }, |
842 | }; | |
843 | ||
844 | for (i = 0; test_cases[i].encoded; i++) { | |
845 | QObject *obj; | |
846 | QInt *qint; | |
847 | ||
848 | obj = qobject_from_json(test_cases[i].encoded); | |
ef76dc59 AL |
849 | g_assert(obj != NULL); |
850 | g_assert(qobject_type(obj) == QTYPE_QINT); | |
422c46a8 AL |
851 | |
852 | qint = qobject_to_qint(obj); | |
ef76dc59 | 853 | g_assert(qint_get_int(qint) == test_cases[i].decoded); |
6ee59202 AL |
854 | if (test_cases[i].skip == 0) { |
855 | QString *str; | |
856 | ||
857 | str = qobject_to_json(obj); | |
ef76dc59 | 858 | g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0); |
6ee59202 AL |
859 | QDECREF(str); |
860 | } | |
422c46a8 AL |
861 | |
862 | QDECREF(qint); | |
863 | } | |
864 | } | |
422c46a8 | 865 | |
ef76dc59 | 866 | static void float_number(void) |
422c46a8 AL |
867 | { |
868 | int i; | |
869 | struct { | |
870 | const char *encoded; | |
871 | double decoded; | |
6ee59202 | 872 | int skip; |
422c46a8 AL |
873 | } test_cases[] = { |
874 | { "32.43", 32.43 }, | |
875 | { "0.222", 0.222 }, | |
876 | { "-32.12313", -32.12313 }, | |
6ee59202 | 877 | { "-32.20e-10", -32.20e-10, .skip = 1 }, |
422c46a8 AL |
878 | { }, |
879 | }; | |
880 | ||
881 | for (i = 0; test_cases[i].encoded; i++) { | |
882 | QObject *obj; | |
883 | QFloat *qfloat; | |
884 | ||
885 | obj = qobject_from_json(test_cases[i].encoded); | |
ef76dc59 AL |
886 | g_assert(obj != NULL); |
887 | g_assert(qobject_type(obj) == QTYPE_QFLOAT); | |
422c46a8 AL |
888 | |
889 | qfloat = qobject_to_qfloat(obj); | |
ef76dc59 | 890 | g_assert(qfloat_get_double(qfloat) == test_cases[i].decoded); |
422c46a8 | 891 | |
6ee59202 AL |
892 | if (test_cases[i].skip == 0) { |
893 | QString *str; | |
894 | ||
895 | str = qobject_to_json(obj); | |
ef76dc59 | 896 | g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0); |
6ee59202 AL |
897 | QDECREF(str); |
898 | } | |
899 | ||
422c46a8 AL |
900 | QDECREF(qfloat); |
901 | } | |
902 | } | |
422c46a8 | 903 | |
ef76dc59 | 904 | static void vararg_number(void) |
422c46a8 AL |
905 | { |
906 | QObject *obj; | |
907 | QInt *qint; | |
908 | QFloat *qfloat; | |
909 | int value = 0x2342; | |
910 | int64_t value64 = 0x2342342343LL; | |
911 | double valuef = 2.323423423; | |
912 | ||
913 | obj = qobject_from_jsonf("%d", value); | |
ef76dc59 AL |
914 | g_assert(obj != NULL); |
915 | g_assert(qobject_type(obj) == QTYPE_QINT); | |
422c46a8 AL |
916 | |
917 | qint = qobject_to_qint(obj); | |
ef76dc59 | 918 | g_assert(qint_get_int(qint) == value); |
422c46a8 AL |
919 | |
920 | QDECREF(qint); | |
921 | ||
922 | obj = qobject_from_jsonf("%" PRId64, value64); | |
ef76dc59 AL |
923 | g_assert(obj != NULL); |
924 | g_assert(qobject_type(obj) == QTYPE_QINT); | |
422c46a8 AL |
925 | |
926 | qint = qobject_to_qint(obj); | |
ef76dc59 | 927 | g_assert(qint_get_int(qint) == value64); |
422c46a8 AL |
928 | |
929 | QDECREF(qint); | |
930 | ||
931 | obj = qobject_from_jsonf("%f", valuef); | |
ef76dc59 AL |
932 | g_assert(obj != NULL); |
933 | g_assert(qobject_type(obj) == QTYPE_QFLOAT); | |
422c46a8 AL |
934 | |
935 | qfloat = qobject_to_qfloat(obj); | |
ef76dc59 | 936 | g_assert(qfloat_get_double(qfloat) == valuef); |
422c46a8 AL |
937 | |
938 | QDECREF(qfloat); | |
939 | } | |
422c46a8 | 940 | |
ef76dc59 | 941 | static void keyword_literal(void) |
422c46a8 AL |
942 | { |
943 | QObject *obj; | |
944 | QBool *qbool; | |
6ee59202 | 945 | QString *str; |
422c46a8 AL |
946 | |
947 | obj = qobject_from_json("true"); | |
ef76dc59 AL |
948 | g_assert(obj != NULL); |
949 | g_assert(qobject_type(obj) == QTYPE_QBOOL); | |
422c46a8 AL |
950 | |
951 | qbool = qobject_to_qbool(obj); | |
ef76dc59 | 952 | g_assert(qbool_get_int(qbool) != 0); |
422c46a8 | 953 | |
6ee59202 | 954 | str = qobject_to_json(obj); |
ef76dc59 | 955 | g_assert(strcmp(qstring_get_str(str), "true") == 0); |
6ee59202 AL |
956 | QDECREF(str); |
957 | ||
422c46a8 AL |
958 | QDECREF(qbool); |
959 | ||
960 | obj = qobject_from_json("false"); | |
ef76dc59 AL |
961 | g_assert(obj != NULL); |
962 | g_assert(qobject_type(obj) == QTYPE_QBOOL); | |
422c46a8 AL |
963 | |
964 | qbool = qobject_to_qbool(obj); | |
ef76dc59 | 965 | g_assert(qbool_get_int(qbool) == 0); |
422c46a8 | 966 | |
6ee59202 | 967 | str = qobject_to_json(obj); |
ef76dc59 | 968 | g_assert(strcmp(qstring_get_str(str), "false") == 0); |
6ee59202 AL |
969 | QDECREF(str); |
970 | ||
422c46a8 AL |
971 | QDECREF(qbool); |
972 | ||
973 | obj = qobject_from_jsonf("%i", false); | |
ef76dc59 AL |
974 | g_assert(obj != NULL); |
975 | g_assert(qobject_type(obj) == QTYPE_QBOOL); | |
422c46a8 AL |
976 | |
977 | qbool = qobject_to_qbool(obj); | |
ef76dc59 | 978 | g_assert(qbool_get_int(qbool) == 0); |
422c46a8 AL |
979 | |
980 | QDECREF(qbool); | |
981 | ||
982 | obj = qobject_from_jsonf("%i", true); | |
ef76dc59 AL |
983 | g_assert(obj != NULL); |
984 | g_assert(qobject_type(obj) == QTYPE_QBOOL); | |
422c46a8 AL |
985 | |
986 | qbool = qobject_to_qbool(obj); | |
ef76dc59 | 987 | g_assert(qbool_get_int(qbool) != 0); |
422c46a8 AL |
988 | |
989 | QDECREF(qbool); | |
990 | } | |
422c46a8 AL |
991 | |
992 | typedef struct LiteralQDictEntry LiteralQDictEntry; | |
993 | typedef struct LiteralQObject LiteralQObject; | |
994 | ||
995 | struct LiteralQObject | |
996 | { | |
997 | int type; | |
998 | union { | |
999 | int64_t qint; | |
1000 | const char *qstr; | |
1001 | LiteralQDictEntry *qdict; | |
1002 | LiteralQObject *qlist; | |
1003 | } value; | |
1004 | }; | |
1005 | ||
1006 | struct LiteralQDictEntry | |
1007 | { | |
1008 | const char *key; | |
1009 | LiteralQObject value; | |
1010 | }; | |
1011 | ||
1012 | #define QLIT_QINT(val) (LiteralQObject){.type = QTYPE_QINT, .value.qint = (val)} | |
1013 | #define QLIT_QSTR(val) (LiteralQObject){.type = QTYPE_QSTRING, .value.qstr = (val)} | |
1014 | #define QLIT_QDICT(val) (LiteralQObject){.type = QTYPE_QDICT, .value.qdict = (val)} | |
1015 | #define QLIT_QLIST(val) (LiteralQObject){.type = QTYPE_QLIST, .value.qlist = (val)} | |
1016 | ||
1017 | typedef struct QListCompareHelper | |
1018 | { | |
1019 | int index; | |
1020 | LiteralQObject *objs; | |
1021 | int result; | |
1022 | } QListCompareHelper; | |
1023 | ||
1024 | static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs); | |
1025 | ||
1026 | static void compare_helper(QObject *obj, void *opaque) | |
1027 | { | |
1028 | QListCompareHelper *helper = opaque; | |
1029 | ||
1030 | if (helper->result == 0) { | |
1031 | return; | |
1032 | } | |
1033 | ||
1034 | if (helper->objs[helper->index].type == QTYPE_NONE) { | |
1035 | helper->result = 0; | |
1036 | return; | |
1037 | } | |
1038 | ||
1039 | helper->result = compare_litqobj_to_qobj(&helper->objs[helper->index++], obj); | |
1040 | } | |
1041 | ||
1042 | static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs) | |
1043 | { | |
1044 | if (lhs->type != qobject_type(rhs)) { | |
1045 | return 0; | |
1046 | } | |
1047 | ||
1048 | switch (lhs->type) { | |
1049 | case QTYPE_QINT: | |
1050 | return lhs->value.qint == qint_get_int(qobject_to_qint(rhs)); | |
1051 | case QTYPE_QSTRING: | |
1052 | return (strcmp(lhs->value.qstr, qstring_get_str(qobject_to_qstring(rhs))) == 0); | |
1053 | case QTYPE_QDICT: { | |
1054 | int i; | |
1055 | ||
1056 | for (i = 0; lhs->value.qdict[i].key; i++) { | |
1057 | QObject *obj = qdict_get(qobject_to_qdict(rhs), lhs->value.qdict[i].key); | |
1058 | ||
1059 | if (!compare_litqobj_to_qobj(&lhs->value.qdict[i].value, obj)) { | |
1060 | return 0; | |
1061 | } | |
1062 | } | |
1063 | ||
1064 | return 1; | |
1065 | } | |
1066 | case QTYPE_QLIST: { | |
1067 | QListCompareHelper helper; | |
1068 | ||
1069 | helper.index = 0; | |
1070 | helper.objs = lhs->value.qlist; | |
1071 | helper.result = 1; | |
1072 | ||
1073 | qlist_iter(qobject_to_qlist(rhs), compare_helper, &helper); | |
1074 | ||
1075 | return helper.result; | |
1076 | } | |
1077 | default: | |
1078 | break; | |
1079 | } | |
1080 | ||
1081 | return 0; | |
1082 | } | |
1083 | ||
ef76dc59 | 1084 | static void simple_dict(void) |
422c46a8 AL |
1085 | { |
1086 | int i; | |
1087 | struct { | |
1088 | const char *encoded; | |
1089 | LiteralQObject decoded; | |
1090 | } test_cases[] = { | |
1091 | { | |
6ee59202 | 1092 | .encoded = "{\"foo\": 42, \"bar\": \"hello world\"}", |
422c46a8 AL |
1093 | .decoded = QLIT_QDICT(((LiteralQDictEntry[]){ |
1094 | { "foo", QLIT_QINT(42) }, | |
1095 | { "bar", QLIT_QSTR("hello world") }, | |
1096 | { } | |
1097 | })), | |
1098 | }, { | |
1099 | .encoded = "{}", | |
1100 | .decoded = QLIT_QDICT(((LiteralQDictEntry[]){ | |
1101 | { } | |
1102 | })), | |
1103 | }, { | |
6ee59202 | 1104 | .encoded = "{\"foo\": 43}", |
422c46a8 AL |
1105 | .decoded = QLIT_QDICT(((LiteralQDictEntry[]){ |
1106 | { "foo", QLIT_QINT(43) }, | |
1107 | { } | |
1108 | })), | |
1109 | }, | |
1110 | { } | |
1111 | }; | |
1112 | ||
1113 | for (i = 0; test_cases[i].encoded; i++) { | |
1114 | QObject *obj; | |
6ee59202 | 1115 | QString *str; |
422c46a8 AL |
1116 | |
1117 | obj = qobject_from_json(test_cases[i].encoded); | |
ef76dc59 AL |
1118 | g_assert(obj != NULL); |
1119 | g_assert(qobject_type(obj) == QTYPE_QDICT); | |
422c46a8 | 1120 | |
ef76dc59 | 1121 | g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1); |
422c46a8 | 1122 | |
6ee59202 AL |
1123 | str = qobject_to_json(obj); |
1124 | qobject_decref(obj); | |
1125 | ||
1126 | obj = qobject_from_json(qstring_get_str(str)); | |
ef76dc59 AL |
1127 | g_assert(obj != NULL); |
1128 | g_assert(qobject_type(obj) == QTYPE_QDICT); | |
6ee59202 | 1129 | |
ef76dc59 | 1130 | g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1); |
422c46a8 | 1131 | qobject_decref(obj); |
6ee59202 | 1132 | QDECREF(str); |
422c46a8 AL |
1133 | } |
1134 | } | |
422c46a8 | 1135 | |
7109edfe MR |
1136 | /* |
1137 | * this generates json of the form: | |
1138 | * a(0,m) = [0, 1, ..., m-1] | |
1139 | * a(n,m) = { | |
1140 | * 'key0': a(0,m), | |
1141 | * 'key1': a(1,m), | |
1142 | * ... | |
1143 | * 'key(n-1)': a(n-1,m) | |
1144 | * } | |
1145 | */ | |
1146 | static void gen_test_json(GString *gstr, int nest_level_max, | |
1147 | int elem_count) | |
1148 | { | |
1149 | int i; | |
1150 | ||
1151 | g_assert(gstr); | |
1152 | if (nest_level_max == 0) { | |
1153 | g_string_append(gstr, "["); | |
1154 | for (i = 0; i < elem_count; i++) { | |
1155 | g_string_append_printf(gstr, "%d", i); | |
1156 | if (i < elem_count - 1) { | |
1157 | g_string_append_printf(gstr, ", "); | |
1158 | } | |
1159 | } | |
1160 | g_string_append(gstr, "]"); | |
1161 | return; | |
1162 | } | |
1163 | ||
1164 | g_string_append(gstr, "{"); | |
1165 | for (i = 0; i < nest_level_max; i++) { | |
1166 | g_string_append_printf(gstr, "'key%d': ", i); | |
1167 | gen_test_json(gstr, i, elem_count); | |
1168 | if (i < nest_level_max - 1) { | |
1169 | g_string_append(gstr, ","); | |
1170 | } | |
1171 | } | |
1172 | g_string_append(gstr, "}"); | |
1173 | } | |
1174 | ||
1175 | static void large_dict(void) | |
1176 | { | |
1177 | GString *gstr = g_string_new(""); | |
1178 | QObject *obj; | |
1179 | ||
1180 | gen_test_json(gstr, 10, 100); | |
1181 | obj = qobject_from_json(gstr->str); | |
1182 | g_assert(obj != NULL); | |
1183 | ||
1184 | qobject_decref(obj); | |
1185 | g_string_free(gstr, true); | |
1186 | } | |
1187 | ||
ef76dc59 | 1188 | static void simple_list(void) |
422c46a8 AL |
1189 | { |
1190 | int i; | |
1191 | struct { | |
1192 | const char *encoded; | |
1193 | LiteralQObject decoded; | |
1194 | } test_cases[] = { | |
1195 | { | |
1196 | .encoded = "[43,42]", | |
1197 | .decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1198 | QLIT_QINT(43), | |
1199 | QLIT_QINT(42), | |
1200 | { } | |
1201 | })), | |
1202 | }, | |
1203 | { | |
1204 | .encoded = "[43]", | |
1205 | .decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1206 | QLIT_QINT(43), | |
1207 | { } | |
1208 | })), | |
1209 | }, | |
1210 | { | |
1211 | .encoded = "[]", | |
1212 | .decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1213 | { } | |
1214 | })), | |
1215 | }, | |
1216 | { | |
1217 | .encoded = "[{}]", | |
1218 | .decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1219 | QLIT_QDICT(((LiteralQDictEntry[]){ | |
1220 | {}, | |
1221 | })), | |
1222 | {}, | |
1223 | })), | |
1224 | }, | |
1225 | { } | |
1226 | }; | |
1227 | ||
1228 | for (i = 0; test_cases[i].encoded; i++) { | |
1229 | QObject *obj; | |
6ee59202 | 1230 | QString *str; |
422c46a8 AL |
1231 | |
1232 | obj = qobject_from_json(test_cases[i].encoded); | |
ef76dc59 AL |
1233 | g_assert(obj != NULL); |
1234 | g_assert(qobject_type(obj) == QTYPE_QLIST); | |
422c46a8 | 1235 | |
ef76dc59 | 1236 | g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1); |
422c46a8 | 1237 | |
6ee59202 AL |
1238 | str = qobject_to_json(obj); |
1239 | qobject_decref(obj); | |
1240 | ||
1241 | obj = qobject_from_json(qstring_get_str(str)); | |
ef76dc59 AL |
1242 | g_assert(obj != NULL); |
1243 | g_assert(qobject_type(obj) == QTYPE_QLIST); | |
6ee59202 | 1244 | |
ef76dc59 | 1245 | g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1); |
422c46a8 | 1246 | qobject_decref(obj); |
6ee59202 | 1247 | QDECREF(str); |
422c46a8 AL |
1248 | } |
1249 | } | |
422c46a8 | 1250 | |
ef76dc59 | 1251 | static void simple_whitespace(void) |
422c46a8 AL |
1252 | { |
1253 | int i; | |
1254 | struct { | |
1255 | const char *encoded; | |
1256 | LiteralQObject decoded; | |
1257 | } test_cases[] = { | |
1258 | { | |
1259 | .encoded = " [ 43 , 42 ]", | |
1260 | .decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1261 | QLIT_QINT(43), | |
1262 | QLIT_QINT(42), | |
1263 | { } | |
1264 | })), | |
1265 | }, | |
1266 | { | |
1267 | .encoded = " [ 43 , { 'h' : 'b' }, [ ], 42 ]", | |
1268 | .decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1269 | QLIT_QINT(43), | |
1270 | QLIT_QDICT(((LiteralQDictEntry[]){ | |
1271 | { "h", QLIT_QSTR("b") }, | |
1272 | { }})), | |
1273 | QLIT_QLIST(((LiteralQObject[]){ | |
1274 | { }})), | |
1275 | QLIT_QINT(42), | |
1276 | { } | |
1277 | })), | |
1278 | }, | |
1279 | { | |
1280 | .encoded = " [ 43 , { 'h' : 'b' , 'a' : 32 }, [ ], 42 ]", | |
1281 | .decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1282 | QLIT_QINT(43), | |
1283 | QLIT_QDICT(((LiteralQDictEntry[]){ | |
1284 | { "h", QLIT_QSTR("b") }, | |
1285 | { "a", QLIT_QINT(32) }, | |
1286 | { }})), | |
1287 | QLIT_QLIST(((LiteralQObject[]){ | |
1288 | { }})), | |
1289 | QLIT_QINT(42), | |
1290 | { } | |
1291 | })), | |
1292 | }, | |
1293 | { } | |
1294 | }; | |
1295 | ||
1296 | for (i = 0; test_cases[i].encoded; i++) { | |
1297 | QObject *obj; | |
6ee59202 | 1298 | QString *str; |
422c46a8 AL |
1299 | |
1300 | obj = qobject_from_json(test_cases[i].encoded); | |
ef76dc59 AL |
1301 | g_assert(obj != NULL); |
1302 | g_assert(qobject_type(obj) == QTYPE_QLIST); | |
422c46a8 | 1303 | |
ef76dc59 | 1304 | g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1); |
422c46a8 | 1305 | |
6ee59202 | 1306 | str = qobject_to_json(obj); |
422c46a8 | 1307 | qobject_decref(obj); |
6ee59202 AL |
1308 | |
1309 | obj = qobject_from_json(qstring_get_str(str)); | |
ef76dc59 AL |
1310 | g_assert(obj != NULL); |
1311 | g_assert(qobject_type(obj) == QTYPE_QLIST); | |
6ee59202 | 1312 | |
ef76dc59 | 1313 | g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1); |
6ee59202 AL |
1314 | |
1315 | qobject_decref(obj); | |
1316 | QDECREF(str); | |
422c46a8 AL |
1317 | } |
1318 | } | |
422c46a8 | 1319 | |
ef76dc59 | 1320 | static void simple_varargs(void) |
422c46a8 AL |
1321 | { |
1322 | QObject *embedded_obj; | |
1323 | QObject *obj; | |
1324 | LiteralQObject decoded = QLIT_QLIST(((LiteralQObject[]){ | |
1325 | QLIT_QINT(1), | |
1326 | QLIT_QINT(2), | |
1327 | QLIT_QLIST(((LiteralQObject[]){ | |
1328 | QLIT_QINT(32), | |
1329 | QLIT_QINT(42), | |
1330 | {}})), | |
1331 | {}})); | |
1332 | ||
1333 | embedded_obj = qobject_from_json("[32, 42]"); | |
ef76dc59 | 1334 | g_assert(embedded_obj != NULL); |
422c46a8 AL |
1335 | |
1336 | obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj); | |
ef76dc59 | 1337 | g_assert(obj != NULL); |
422c46a8 | 1338 | |
ef76dc59 | 1339 | g_assert(compare_litqobj_to_qobj(&decoded, obj) == 1); |
422c46a8 AL |
1340 | |
1341 | qobject_decref(obj); | |
1342 | } | |
422c46a8 | 1343 | |
ef76dc59 | 1344 | static void empty_input(void) |
7f8fca7c | 1345 | { |
e7a06af8 JK |
1346 | const char *empty = ""; |
1347 | ||
1348 | QObject *obj = qobject_from_json(empty); | |
ef76dc59 | 1349 | g_assert(obj == NULL); |
7f8fca7c | 1350 | } |
7f8fca7c | 1351 | |
ef76dc59 | 1352 | static void unterminated_string(void) |
7f8fca7c PB |
1353 | { |
1354 | QObject *obj = qobject_from_json("\"abc"); | |
ef76dc59 | 1355 | g_assert(obj == NULL); |
7f8fca7c | 1356 | } |
7f8fca7c | 1357 | |
ef76dc59 | 1358 | static void unterminated_sq_string(void) |
7f8fca7c PB |
1359 | { |
1360 | QObject *obj = qobject_from_json("'abc"); | |
ef76dc59 | 1361 | g_assert(obj == NULL); |
7f8fca7c | 1362 | } |
7f8fca7c | 1363 | |
ef76dc59 | 1364 | static void unterminated_escape(void) |
7f8fca7c PB |
1365 | { |
1366 | QObject *obj = qobject_from_json("\"abc\\\""); | |
ef76dc59 | 1367 | g_assert(obj == NULL); |
7f8fca7c | 1368 | } |
7f8fca7c | 1369 | |
ef76dc59 | 1370 | static void unterminated_array(void) |
7f8fca7c PB |
1371 | { |
1372 | QObject *obj = qobject_from_json("[32"); | |
ef76dc59 | 1373 | g_assert(obj == NULL); |
7f8fca7c | 1374 | } |
7f8fca7c | 1375 | |
ef76dc59 | 1376 | static void unterminated_array_comma(void) |
7f8fca7c PB |
1377 | { |
1378 | QObject *obj = qobject_from_json("[32,"); | |
ef76dc59 | 1379 | g_assert(obj == NULL); |
7f8fca7c | 1380 | } |
7f8fca7c | 1381 | |
ef76dc59 | 1382 | static void invalid_array_comma(void) |
7f8fca7c PB |
1383 | { |
1384 | QObject *obj = qobject_from_json("[32,}"); | |
ef76dc59 | 1385 | g_assert(obj == NULL); |
7f8fca7c | 1386 | } |
7f8fca7c | 1387 | |
ef76dc59 | 1388 | static void unterminated_dict(void) |
7f8fca7c PB |
1389 | { |
1390 | QObject *obj = qobject_from_json("{'abc':32"); | |
ef76dc59 | 1391 | g_assert(obj == NULL); |
7f8fca7c | 1392 | } |
7f8fca7c | 1393 | |
ef76dc59 | 1394 | static void unterminated_dict_comma(void) |
7f8fca7c PB |
1395 | { |
1396 | QObject *obj = qobject_from_json("{'abc':32,"); | |
ef76dc59 | 1397 | g_assert(obj == NULL); |
7f8fca7c | 1398 | } |
7f8fca7c | 1399 | |
ef76dc59 | 1400 | static void invalid_dict_comma(void) |
7f8fca7c PB |
1401 | { |
1402 | QObject *obj = qobject_from_json("{'abc':32,}"); | |
ef76dc59 | 1403 | g_assert(obj == NULL); |
7f8fca7c | 1404 | } |
7f8fca7c | 1405 | |
ef76dc59 | 1406 | static void unterminated_literal(void) |
7f8fca7c PB |
1407 | { |
1408 | QObject *obj = qobject_from_json("nul"); | |
ef76dc59 | 1409 | g_assert(obj == NULL); |
7f8fca7c | 1410 | } |
7f8fca7c | 1411 | |
ef76dc59 | 1412 | int main(int argc, char **argv) |
422c46a8 | 1413 | { |
ef76dc59 AL |
1414 | g_test_init(&argc, &argv, NULL); |
1415 | ||
1416 | g_test_add_func("/literals/string/simple", simple_string); | |
1417 | g_test_add_func("/literals/string/escaped", escaped_string); | |
3960c41f | 1418 | g_test_add_func("/literals/string/utf8", utf8_string); |
ef76dc59 AL |
1419 | g_test_add_func("/literals/string/single_quote", single_quote_string); |
1420 | g_test_add_func("/literals/string/vararg", vararg_string); | |
1421 | ||
1422 | g_test_add_func("/literals/number/simple", simple_number); | |
1423 | g_test_add_func("/literals/number/float", float_number); | |
1424 | g_test_add_func("/literals/number/vararg", vararg_number); | |
1425 | ||
1426 | g_test_add_func("/literals/keyword", keyword_literal); | |
1427 | ||
1428 | g_test_add_func("/dicts/simple_dict", simple_dict); | |
7109edfe | 1429 | g_test_add_func("/dicts/large_dict", large_dict); |
ef76dc59 AL |
1430 | g_test_add_func("/lists/simple_list", simple_list); |
1431 | ||
1432 | g_test_add_func("/whitespace/simple_whitespace", simple_whitespace); | |
1433 | ||
1434 | g_test_add_func("/varargs/simple_varargs", simple_varargs); | |
1435 | ||
1436 | g_test_add_func("/errors/empty_input", empty_input); | |
1437 | g_test_add_func("/errors/unterminated/string", unterminated_string); | |
1438 | g_test_add_func("/errors/unterminated/escape", unterminated_escape); | |
1439 | g_test_add_func("/errors/unterminated/sq_string", unterminated_sq_string); | |
1440 | g_test_add_func("/errors/unterminated/array", unterminated_array); | |
1441 | g_test_add_func("/errors/unterminated/array_comma", unterminated_array_comma); | |
1442 | g_test_add_func("/errors/unterminated/dict", unterminated_dict); | |
1443 | g_test_add_func("/errors/unterminated/dict_comma", unterminated_dict_comma); | |
1444 | g_test_add_func("/errors/invalid_array_comma", invalid_array_comma); | |
ef76dc59 AL |
1445 | g_test_add_func("/errors/invalid_dict_comma", invalid_dict_comma); |
1446 | g_test_add_func("/errors/unterminated/literal", unterminated_literal); | |
7f8fca7c | 1447 | |
ef76dc59 | 1448 | return g_test_run(); |
422c46a8 | 1449 | } |