tests/check-qjson.c

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