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