decodetree: Drop check for less than 2 patterns in a group

[qemu.git] / tests / check-qjson.c

diff --git a/tests/check-qjson.c b/tests/check-qjson.c
index 1688b2f5c1e437446cac4bb1f181bdd298208e29..07a773e6530b561f2ecac7e127ccb8fd690ad740 100644 (file)
--- a/tests/check-qjson.c
+++ b/tests/check-qjson.c
@@ -63,8 +63,7 @@ static void escaped_string(void)
         { "double byte utf-8 \\u00A2", "double byte utf-8 \xc2\xa2" },
         { "triple byte utf-8 \\u20AC", "triple byte utf-8 \xe2\x82\xac" },
         { "quadruple byte utf-8 \\uD834\\uDD1E", /* U+1D11E */
         { "double byte utf-8 \\u00A2", "double byte utf-8 \xc2\xa2" },
         { "triple byte utf-8 \\u20AC", "triple byte utf-8 \xe2\x82\xac" },
         { "quadruple byte utf-8 \\uD834\\uDD1E", /* U+1D11E */

-          /* bug: want \xF0\x9D\x84\x9E */
-          "quadruple byte utf-8 \xED\xA0\xB4\xED\xB4\x9E", .skip = 1 },
+          "quadruple byte utf-8 \xF0\x9D\x84\x9E" },

         { "\\", NULL },
         { "\\z", NULL },
         { "\\ux", NULL },
         { "\\", NULL },
         { "\\z", NULL },
         { "\\ux", NULL },


@@ -72,35 +71,16 @@ static void escaped_string(void)
         { "\\u12x", NULL },
         { "\\u123x", NULL },
         { "\\u12345", "\341\210\2645" },
         { "\\u12x", NULL },
         { "\\u123x", NULL },
         { "\\u12345", "\341\210\2645" },

-        { "\\u0000x", "x", .skip = 1}, /* bug: want \xC0\x80x */
-        { "unpaired leading surrogate \\uD800",
-          /* bug: not rejected */
-          "unpaired leading surrogate \355\240\200", .skip = 1 },
-        { "unpaired leading surrogate \\uD800\\uCAFE",
-          /* bug: not rejected */
-          "unpaired leading surrogate \355\240\200\354\253\276", .skip = 1 },
-        { "unpaired leading surrogate \\uD800\\uD801\\uDC02",
-          /* bug: not rejected */
-          "unpaired leading surrogate \355\240\200\355\240\201\355\260\202",
-          .skip = 1 },
-        { "unpaired trailing surrogate \\uDC00",
-          /* bug: not rejected */
-          "unpaired trailing surrogate \355\260\200", .skip = 1},
-        { "backward surrogate pair \\uDC00\\uD800",
-          /* bug: not rejected */
-          "backward surrogate pair \355\260\200\355\240\200", .skip = 1},
-        { "noncharacter U+FDD0 \\uFDD0",
-          /* bug: not rejected */
-          "noncharacter U+FDD0 \xEF\xB7\x90", .skip = 1},
-        { "noncharacter U+FDEF \\uFDEF",
-          /* bug: not rejected */
-          "noncharacter U+FDEF \xEF\xB7\xAF", .skip = 1},
-        { "noncharacter U+1FFFE \\uD87F\\uDFFE",
-          /* bug: not rejected */
-          "noncharacter U+1FFFE \xED\xA1\xBF\xED\xBF\xBE", .skip = 1},
-        { "noncharacter U+10FFFF \\uDC3F\\uDFFF",
-          /* bug: not rejected */
-          "noncharacter U+10FFFF \xED\xB0\xBF\xED\xBF\xBF", .skip = 1},
+        { "\\u0000x", "\xC0\x80x" },
+        { "unpaired leading surrogate \\uD800", NULL },
+        { "unpaired leading surrogate \\uD800\\uCAFE", NULL },
+        { "unpaired leading surrogate \\uD800\\uD801\\uDC02", NULL },
+        { "unpaired trailing surrogate \\uDC00", NULL },
+        { "backward surrogate pair \\uDC00\\uD800", NULL },
+        { "noncharacter U+FDD0 \\uFDD0", NULL },
+        { "noncharacter U+FDEF \\uFDEF", NULL },
+        { "noncharacter U+1FFFE \\uD87F\\uDFFE", NULL },
+        { "noncharacter U+10FFFF \\uDC3F\\uDFFF", NULL },

         {}
     };
     int i, j;
         {}
     };
     int i, j;


@@ -152,25 +132,6 @@ static void string_with_quotes(void)
 static void utf8_string(void)
 {
     /*
 static void utf8_string(void)
 {
     /*

-     * FIXME Current behavior for invalid UTF-8 sequences is
-     * incorrect.  This test expects current, incorrect results.
-     * They're all marked "bug:" below, and are to be replaced by
-     * correct ones as the bugs get fixed.
-     *
-     * The JSON parser rejects some invalid sequences, but accepts
-     * others without correcting the problem.
-     *
-     * We should either reject all invalid sequences, or minimize
-     * overlong sequences and replace all other invalid sequences by a
-     * suitable replacement character.  A common choice for
-     * replacement is U+FFFD.
-     *
-     * Problem: we can't easily deal with embedded U+0000.  Parsing
-     * the JSON string "this \\u0000" is fun" yields "this \0 is fun",
-     * which gets misinterpreted as NUL-terminated "this ".  We should
-     * consider using overlong encoding \xC0\x80 for U+0000 ("modified
-     * UTF-8").
-     *

      * Most test cases are scraped from Markus Kuhn's UTF-8 decoder
      * capability and stress test at
      * http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
      * Most test cases are scraped from Markus Kuhn's UTF-8 decoder
      * capability and stress test at
      * http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt


@@ -183,15 +144,6 @@ static void utf8_string(void)
         /* Expected unparse output, defaults to @json_in */
         const char *json_out;
     } test_cases[] = {
         /* Expected unparse output, defaults to @json_in */
         const char *json_out;
     } test_cases[] = {

-        /*
-         * Bug markers used here:
-         * - bug: not corrected
-         *   JSON parser fails to correct invalid sequence(s)
-         * - bug: rejected
-         *   JSON parser rejects invalid sequence(s)
-         *   We may choose to define this as feature
-         */
-

         /* 0  Control characters */
         {
             /*
         /* 0  Control characters */
         {
             /*


@@ -202,11 +154,7 @@ static void utf8_string(void)
             "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
             "\x10\x11\x12\x13\x14\x15\x16\x17"
             "\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
             "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
             "\x10\x11\x12\x13\x14\x15\x16\x17"
             "\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",

-            /* bug: not corrected (valid UTF-8, but invalid JSON) */
-            "\x01\x02\x03\x04\x05\x06\x07"
-            "\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F"
-            "\x10\x11\x12\x13\x14\x15\x16\x17"
-            "\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F",
+            NULL,

             "\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007"
             "\\b\\t\\n\\u000B\\f\\r\\u000E\\u000F"
             "\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017"
             "\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007"
             "\\b\\t\\n\\u000B\\f\\r\\u000E\\u000F"
             "\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017"


@@ -227,6 +175,11 @@ static void utf8_string(void)
             "\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
             "\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
             "\\u03BA\\u1F79\\u03C3\\u03BC\\u03B5",
             "\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
             "\xCE\xBA\xE1\xBD\xB9\xCF\x83\xCE\xBC\xCE\xB5",
             "\\u03BA\\u1F79\\u03C3\\u03BC\\u03B5",

+        },
+            /* '%' character when not interpolating */
+        {
+            "100%",
+            "100%",

         },
         /* 2  Boundary condition test cases */
         /* 2.1  First possible sequence of a certain length */
         },
         /* 2  Boundary condition test cases */
         /* 2.1  First possible sequence of a certain length */


@@ -261,13 +214,13 @@ static void utf8_string(void)
         /* 2.1.5  5 bytes U+200000 */
         {
             "\xF8\x88\x80\x80\x80",
         /* 2.1.5  5 bytes U+200000 */
         {
             "\xF8\x88\x80\x80\x80",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 2.1.6  6 bytes U+4000000 */
         {
             "\xFC\x84\x80\x80\x80\x80",
             "\\uFFFD",
         },
         /* 2.1.6  6 bytes U+4000000 */
         {
             "\xFC\x84\x80\x80\x80\x80",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 2.2  Last possible sequence of a certain length */
             "\\uFFFD",
         },
         /* 2.2  Last possible sequence of a certain length */


@@ -300,19 +253,19 @@ static void utf8_string(void)
         /* 2.2.4  4 bytes U+1FFFFF */
         {
             "\xF7\xBF\xBF\xBF",
         /* 2.2.4  4 bytes U+1FFFFF */
         {
             "\xF7\xBF\xBF\xBF",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 2.2.5  5 bytes U+3FFFFFF */
         {
             "\xFB\xBF\xBF\xBF\xBF",
             "\\uFFFD",
         },
         /* 2.2.5  5 bytes U+3FFFFFF */
         {
             "\xFB\xBF\xBF\xBF\xBF",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 2.2.6  6 bytes U+7FFFFFFF */
         {
             "\xFD\xBF\xBF\xBF\xBF\xBF",
             "\\uFFFD",
         },
         /* 2.2.6  6 bytes U+7FFFFFFF */
         {
             "\xFD\xBF\xBF\xBF\xBF\xBF",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 2.3  Other boundary conditions */
             "\\uFFFD",
         },
         /* 2.3  Other boundary conditions */


@@ -343,7 +296,7 @@ static void utf8_string(void)
         {
             /* first one beyond Unicode range: U+110000 */
             "\xF4\x90\x80\x80",
         {
             /* first one beyond Unicode range: U+110000 */
             "\xF4\x90\x80\x80",

-            "\xF4\x90\x80\x80",
+            NULL,

             "\\uFFFD",
         },
         /* 3  Malformed sequences */
             "\\uFFFD",
         },
         /* 3  Malformed sequences */


@@ -351,49 +304,49 @@ static void utf8_string(void)
         /* 3.1.1  First continuation byte */
         {
             "\x80",
         /* 3.1.1  First continuation byte */
         {
             "\x80",

-            "\x80",             /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.1.2  Last continuation byte */
         {
             "\xBF",
             "\\uFFFD",
         },
         /* 3.1.2  Last continuation byte */
         {
             "\xBF",

-            "\xBF",             /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.1.3  2 continuation bytes */
         {
             "\x80\xBF",
             "\\uFFFD",
         },
         /* 3.1.3  2 continuation bytes */
         {
             "\x80\xBF",

-            "\x80\xBF",         /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         /* 3.1.4  3 continuation bytes */
         {
             "\x80\xBF\x80",
             "\\uFFFD\\uFFFD",
         },
         /* 3.1.4  3 continuation bytes */
         {
             "\x80\xBF\x80",

-            "\x80\xBF\x80",     /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.5  4 continuation bytes */
         {
             "\x80\xBF\x80\xBF",
             "\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.5  4 continuation bytes */
         {
             "\x80\xBF\x80\xBF",

-            "\x80\xBF\x80\xBF", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.6  5 continuation bytes */
         {
             "\x80\xBF\x80\xBF\x80",
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.6  5 continuation bytes */
         {
             "\x80\xBF\x80\xBF\x80",

-            "\x80\xBF\x80\xBF\x80", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.7  6 continuation bytes */
         {
             "\x80\xBF\x80\xBF\x80\xBF",
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.7  6 continuation bytes */
         {
             "\x80\xBF\x80\xBF\x80\xBF",

-            "\x80\xBF\x80\xBF\x80\xBF", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.8  7 continuation bytes */
         {
             "\x80\xBF\x80\xBF\x80\xBF\x80",
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.8  7 continuation bytes */
         {
             "\x80\xBF\x80\xBF\x80\xBF\x80",

-            "\x80\xBF\x80\xBF\x80\xBF\x80", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.9  Sequence of all 64 possible continuation bytes */
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.1.9  Sequence of all 64 possible continuation bytes */


@@ -406,16 +359,7 @@ static void utf8_string(void)
             "\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
             "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
             "\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
             "\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
             "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
             "\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",

-             /* bug: not corrected */
-            "\x80\x81\x82\x83\x84\x85\x86\x87"
-            "\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F"
-            "\x90\x91\x92\x93\x94\x95\x96\x97"
-            "\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F"
-            "\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7"
-            "\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF"
-            "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7"
-            "\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
-            "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"


@@ -423,6 +367,7 @@ static void utf8_string(void)
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"

+            "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",

         },
         /* 3.2  Lonely start characters */
         /* 3.2.1  All 32 first bytes of 2-byte sequences, followed by space */
         },
         /* 3.2  Lonely start characters */
         /* 3.2.1  All 32 first bytes of 2-byte sequences, followed by space */


@@ -431,7 +376,7 @@ static void utf8_string(void)
             "\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
             "\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
             "\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
             "\xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF "
             "\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 "
             "\xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",

-            NULL,               /* bug: rejected (partly, see FIXME below) */
+            NULL,

             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "


@@ -441,140 +386,138 @@ static void utf8_string(void)
         {
             "\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
             "\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
         {
             "\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
             "\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",

-            /* bug: not corrected */
-            "\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 "
-            "\xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
+            NULL,

             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD ",
         },
         /* 3.2.3  All 8 first bytes of 4-byte sequences, followed by space */
         {
             "\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD "
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD ",
         },
         /* 3.2.3  All 8 first bytes of 4-byte sequences, followed by space */
         {
             "\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",

-            NULL,               /* bug: rejected (partly, see FIXME below) */
+            NULL,

             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD ",
         },
         /* 3.2.4  All 4 first bytes of 5-byte sequences, followed by space */
         {
             "\xF8 \xF9 \xFA \xFB ",
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD \\uFFFD ",
         },
         /* 3.2.4  All 4 first bytes of 5-byte sequences, followed by space */
         {
             "\xF8 \xF9 \xFA \xFB ",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD ",
         },
         /* 3.2.5  All 2 first bytes of 6-byte sequences, followed by space */
         {
             "\xFC \xFD ",
             "\\uFFFD \\uFFFD \\uFFFD \\uFFFD ",
         },
         /* 3.2.5  All 2 first bytes of 6-byte sequences, followed by space */
         {
             "\xFC \xFD ",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD \\uFFFD ",
         },
         /* 3.3  Sequences with last continuation byte missing */
         /* 3.3.1  2-byte sequence with last byte missing (U+0000) */
         {
             "\xC0",
             "\\uFFFD \\uFFFD ",
         },
         /* 3.3  Sequences with last continuation byte missing */
         /* 3.3.1  2-byte sequence with last byte missing (U+0000) */
         {
             "\xC0",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.2  3-byte sequence with last byte missing (U+0000) */
         {
             "\xE0\x80",
             "\\uFFFD",
         },
         /* 3.3.2  3-byte sequence with last byte missing (U+0000) */
         {
             "\xE0\x80",

-            "\xE0\x80",           /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.3  4-byte sequence with last byte missing (U+0000) */
         {
             "\xF0\x80\x80",
             "\\uFFFD",
         },
         /* 3.3.3  4-byte sequence with last byte missing (U+0000) */
         {
             "\xF0\x80\x80",

-            "\xF0\x80\x80",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.4  5-byte sequence with last byte missing (U+0000) */
         {
             "\xF8\x80\x80\x80",
             "\\uFFFD",
         },
         /* 3.3.4  5-byte sequence with last byte missing (U+0000) */
         {
             "\xF8\x80\x80\x80",

-            NULL,                   /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.5  6-byte sequence with last byte missing (U+0000) */
         {
             "\xFC\x80\x80\x80\x80",
             "\\uFFFD",
         },
         /* 3.3.5  6-byte sequence with last byte missing (U+0000) */
         {
             "\xFC\x80\x80\x80\x80",

-            NULL,                        /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.6  2-byte sequence with last byte missing (U+07FF) */
         {
             "\xDF",
             "\\uFFFD",
         },
         /* 3.3.6  2-byte sequence with last byte missing (U+07FF) */
         {
             "\xDF",

-            "\xDF",             /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.7  3-byte sequence with last byte missing (U+FFFF) */
         {
             "\xEF\xBF",
             "\\uFFFD",
         },
         /* 3.3.7  3-byte sequence with last byte missing (U+FFFF) */
         {
             "\xEF\xBF",

-            "\xEF\xBF",           /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.8  4-byte sequence with last byte missing (U+1FFFFF) */
         {
             "\xF7\xBF\xBF",
             "\\uFFFD",
         },
         /* 3.3.8  4-byte sequence with last byte missing (U+1FFFFF) */
         {
             "\xF7\xBF\xBF",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.9  5-byte sequence with last byte missing (U+3FFFFFF) */
         {
             "\xFB\xBF\xBF\xBF",
             "\\uFFFD",
         },
         /* 3.3.9  5-byte sequence with last byte missing (U+3FFFFFF) */
         {
             "\xFB\xBF\xBF\xBF",

-            NULL,                 /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.3.10  6-byte sequence with last byte missing (U+7FFFFFFF) */
         {
             "\xFD\xBF\xBF\xBF\xBF",
             "\\uFFFD",
         },
         /* 3.3.10  6-byte sequence with last byte missing (U+7FFFFFFF) */
         {
             "\xFD\xBF\xBF\xBF\xBF",

-            NULL,                        /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 3.4  Concatenation of incomplete sequences */
         {
             "\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
             "\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF",
             "\\uFFFD",
         },
         /* 3.4  Concatenation of incomplete sequences */
         {
             "\xC0\xE0\x80\xF0\x80\x80\xF8\x80\x80\x80\xFC\x80\x80\x80\x80"
             "\xDF\xEF\xBF\xF7\xBF\xBF\xFB\xBF\xBF\xBF\xFD\xBF\xBF\xBF\xBF",

-            NULL,               /* bug: rejected (partly, see FIXME below) */
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.5  Impossible bytes */
         {
             "\xFE",
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 3.5  Impossible bytes */
         {
             "\xFE",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         {
             "\xFF",
             "\\uFFFD",
         },
         {
             "\xFF",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         {
             "\xFE\xFE\xFF\xFF",
             "\\uFFFD",
         },
         {
             "\xFE\xFE\xFF\xFF",

-            NULL,                 /* bug: rejected */
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 4  Overlong sequences */
         /* 4.1  Overlong '/' */
         {
             "\xC0\xAF",
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD",
         },
         /* 4  Overlong sequences */
         /* 4.1  Overlong '/' */
         {
             "\xC0\xAF",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         {
             "\xE0\x80\xAF",
             "\\uFFFD",
         },
         {
             "\xE0\x80\xAF",

-            "\xE0\x80\xAF",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             "\xF0\x80\x80\xAF",
             "\\uFFFD",
         },
         {
             "\xF0\x80\x80\xAF",

-            "\xF0\x80\x80\xAF",  /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             "\xF8\x80\x80\x80\xAF",
             "\\uFFFD",
         },
         {
             "\xF8\x80\x80\x80\xAF",

-            NULL,                        /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         {
             "\xFC\x80\x80\x80\x80\xAF",
             "\\uFFFD",
         },
         {
             "\xFC\x80\x80\x80\x80\xAF",

-            NULL,                               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /*
             "\\uFFFD",
         },
         /*


@@ -586,13 +529,13 @@ static void utf8_string(void)
         {
             /* \U+007F */
             "\xC1\xBF",
         {
             /* \U+007F */
             "\xC1\xBF",

-            NULL,               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+07FF */
             "\xE0\x9F\xBF",
             "\\uFFFD",
         },
         {
             /* \U+07FF */
             "\xE0\x9F\xBF",

-            "\xE0\x9F\xBF",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             "\\uFFFD",
         },
         {


@@ -603,50 +546,50 @@ static void utf8_string(void)
              * also 2.2.3
              */
             "\xF0\x8F\xBF\xBC",
              * also 2.2.3
              */
             "\xF0\x8F\xBF\xBC",

-            "\xF0\x8F\xBF\xBC",   /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+1FFFFF */
             "\xF8\x87\xBF\xBF\xBF",
             "\\uFFFD",
         },
         {
             /* \U+1FFFFF */
             "\xF8\x87\xBF\xBF\xBF",

-            NULL,                        /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+3FFFFFF */
             "\xFC\x83\xBF\xBF\xBF\xBF",
             "\\uFFFD",
         },
         {
             /* \U+3FFFFFF */
             "\xFC\x83\xBF\xBF\xBF\xBF",

-            NULL,                               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 4.3  Overlong representation of the NUL character */
         {
             /* \U+0000 */
             "\xC0\x80",
             "\\uFFFD",
         },
         /* 4.3  Overlong representation of the NUL character */
         {
             /* \U+0000 */
             "\xC0\x80",

-            NULL,               /* bug: rejected */
+            "\xC0\x80",

             "\\u0000",
         },
         {
             /* \U+0000 */
             "\xE0\x80\x80",
             "\\u0000",
         },
         {
             /* \U+0000 */
             "\xE0\x80\x80",

-            "\xE0\x80\x80",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+0000 */
             "\xF0\x80\x80\x80",
             "\\uFFFD",
         },
         {
             /* \U+0000 */
             "\xF0\x80\x80\x80",

-            "\xF0\x80\x80\x80",   /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+0000 */
             "\xF8\x80\x80\x80\x80",
             "\\uFFFD",
         },
         {
             /* \U+0000 */
             "\xF8\x80\x80\x80\x80",

-            NULL,                        /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+0000 */
             "\xFC\x80\x80\x80\x80\x80",
             "\\uFFFD",
         },
         {
             /* \U+0000 */
             "\xFC\x80\x80\x80\x80\x80",

-            NULL,                               /* bug: rejected */
+            NULL,

             "\\uFFFD",
         },
         /* 5  Illegal code positions */
             "\\uFFFD",
         },
         /* 5  Illegal code positions */


@@ -654,92 +597,92 @@ static void utf8_string(void)
         {
             /* \U+D800 */
             "\xED\xA0\x80",
         {
             /* \U+D800 */
             "\xED\xA0\x80",

-            "\xED\xA0\x80",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+DB7F */
             "\xED\xAD\xBF",
             "\\uFFFD",
         },
         {
             /* \U+DB7F */
             "\xED\xAD\xBF",

-            "\xED\xAD\xBF",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+DB80 */
             "\xED\xAE\x80",
             "\\uFFFD",
         },
         {
             /* \U+DB80 */
             "\xED\xAE\x80",

-            "\xED\xAE\x80",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+DBFF */
             "\xED\xAF\xBF",
             "\\uFFFD",
         },
         {
             /* \U+DBFF */
             "\xED\xAF\xBF",

-            "\xED\xAF\xBF",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+DC00 */
             "\xED\xB0\x80",
             "\\uFFFD",
         },
         {
             /* \U+DC00 */
             "\xED\xB0\x80",

-            "\xED\xB0\x80",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+DF80 */
             "\xED\xBE\x80",
             "\\uFFFD",
         },
         {
             /* \U+DF80 */
             "\xED\xBE\x80",

-            "\xED\xBE\x80",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+DFFF */
             "\xED\xBF\xBF",
             "\\uFFFD",
         },
         {
             /* \U+DFFF */
             "\xED\xBF\xBF",

-            "\xED\xBF\xBF",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* 5.2  Paired UTF-16 surrogates */
         {
             /* \U+D800\U+DC00 */
             "\xED\xA0\x80\xED\xB0\x80",
             "\\uFFFD",
         },
         /* 5.2  Paired UTF-16 surrogates */
         {
             /* \U+D800\U+DC00 */
             "\xED\xA0\x80\xED\xB0\x80",

-            "\xED\xA0\x80\xED\xB0\x80", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+D800\U+DFFF */
             "\xED\xA0\x80\xED\xBF\xBF",
             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+D800\U+DFFF */
             "\xED\xA0\x80\xED\xBF\xBF",

-            "\xED\xA0\x80\xED\xBF\xBF", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB7F\U+DC00 */
             "\xED\xAD\xBF\xED\xB0\x80",
             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB7F\U+DC00 */
             "\xED\xAD\xBF\xED\xB0\x80",

-            "\xED\xAD\xBF\xED\xB0\x80", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB7F\U+DFFF */
             "\xED\xAD\xBF\xED\xBF\xBF",
             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB7F\U+DFFF */
             "\xED\xAD\xBF\xED\xBF\xBF",

-            "\xED\xAD\xBF\xED\xBF\xBF", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB80\U+DC00 */
             "\xED\xAE\x80\xED\xB0\x80",
             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB80\U+DC00 */
             "\xED\xAE\x80\xED\xB0\x80",

-            "\xED\xAE\x80\xED\xB0\x80", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB80\U+DFFF */
             "\xED\xAE\x80\xED\xBF\xBF",
             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DB80\U+DFFF */
             "\xED\xAE\x80\xED\xBF\xBF",

-            "\xED\xAE\x80\xED\xBF\xBF", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DBFF\U+DC00 */
             "\xED\xAF\xBF\xED\xB0\x80",
             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DBFF\U+DC00 */
             "\xED\xAF\xBF\xED\xB0\x80",

-            "\xED\xAF\xBF\xED\xB0\x80", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DBFF\U+DFFF */
             "\xED\xAF\xBF\xED\xBF\xBF",
             "\\uFFFD\\uFFFD",
         },
         {
             /* \U+DBFF\U+DFFF */
             "\xED\xAF\xBF\xED\xBF\xBF",

-            "\xED\xAF\xBF\xED\xBF\xBF", /* bug: not corrected */
+            NULL,

             "\\uFFFD\\uFFFD",
         },
         /* 5.3  Other illegal code positions */
             "\\uFFFD\\uFFFD",
         },
         /* 5.3  Other illegal code positions */


@@ -747,25 +690,25 @@ static void utf8_string(void)
         {
             /* \U+FFFE */
             "\xEF\xBF\xBE",
         {
             /* \U+FFFE */
             "\xEF\xBF\xBE",

-            "\xEF\xBF\xBE",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* \U+FFFF */
             "\xEF\xBF\xBF",
             "\\uFFFD",
         },
         {
             /* \U+FFFF */
             "\xEF\xBF\xBF",

-            "\xEF\xBF\xBF",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* U+FDD0 */
             "\xEF\xB7\x90",
             "\\uFFFD",
         },
         {
             /* U+FDD0 */
             "\xEF\xB7\x90",

-            "\xEF\xB7\x90",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         {
             /* U+FDEF */
             "\xEF\xB7\xAF",
             "\\uFFFD",
         },
         {
             /* U+FDEF */
             "\xEF\xB7\xAF",

-            "\xEF\xB7\xAF",     /* bug: not corrected */
+            NULL,

             "\\uFFFD",
         },
         /* Plane 1 .. 16 noncharacters */
             "\\uFFFD",
         },
         /* Plane 1 .. 16 noncharacters */


@@ -787,23 +730,7 @@ static void utf8_string(void)
             "\xF3\xAF\xBF\xBE\xF3\xAF\xBF\xBF"
             "\xF3\xBF\xBF\xBE\xF3\xBF\xBF\xBF"
             "\xF4\x8F\xBF\xBE\xF4\x8F\xBF\xBF",
             "\xF3\xAF\xBF\xBE\xF3\xAF\xBF\xBF"
             "\xF3\xBF\xBF\xBE\xF3\xBF\xBF\xBF"
             "\xF4\x8F\xBF\xBE\xF4\x8F\xBF\xBF",

-            /* bug: not corrected */
-            "\xF0\x9F\xBF\xBE\xF0\x9F\xBF\xBF"
-            "\xF0\xAF\xBF\xBE\xF0\xAF\xBF\xBF"
-            "\xF0\xBF\xBF\xBE\xF0\xBF\xBF\xBF"
-            "\xF1\x8F\xBF\xBE\xF1\x8F\xBF\xBF"
-            "\xF1\x9F\xBF\xBE\xF1\x9F\xBF\xBF"
-            "\xF1\xAF\xBF\xBE\xF1\xAF\xBF\xBF"
-            "\xF1\xBF\xBF\xBE\xF1\xBF\xBF\xBF"
-            "\xF2\x8F\xBF\xBE\xF2\x8F\xBF\xBF"
-            "\xF2\x9F\xBF\xBE\xF2\x9F\xBF\xBF"
-            "\xF2\xAF\xBF\xBE\xF2\xAF\xBF\xBF"
-            "\xF2\xBF\xBF\xBE\xF2\xBF\xBF\xBF"
-            "\xF3\x8F\xBF\xBE\xF3\x8F\xBF\xBF"
-            "\xF3\x9F\xBF\xBE\xF3\x9F\xBF\xBF"
-            "\xF3\xAF\xBF\xBE\xF3\xAF\xBF\xBF"
-            "\xF3\xBF\xBF\xBE\xF3\xBF\xBF\xBF"
-            "\xF4\x8F\xBF\xBE\xF4\x8F\xBF\xBF",
+            NULL,

             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"
             "\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD\\uFFFD"


@@ -840,16 +767,8 @@ static void utf8_string(void)
                     if (*end == ' ') {
                         end++;
                     }
                     if (*end == ' ') {
                         end++;
                     }

-                    in = strndup(tail, end - tail);
+                    in = g_strndup(tail, end - tail);

                     str = from_json_str(in, j, NULL);
                     str = from_json_str(in, j, NULL);

-                    /*
-                     * FIXME JSON parser accepts invalid sequence
-                     * starting with \xC2..\xF4
-                     */
-                    if (*in >= '\xC2' && *in <= '\xF4') {
-                        g_free(str);
-                        str = NULL;
-                    }

                     g_assert(!str);
                     g_free(in);
                 }
                     g_assert(!str);
                     g_free(in);
                 }


@@ -862,15 +781,11 @@ static void utf8_string(void)
             qobject_unref(str);
             g_free(jstr);
 
             qobject_unref(str);
             g_free(jstr);
 

-            /*
-             * Parse @json_out right back
-             * Disabled, because qobject_from_json() is buggy, and I can't
-             * be bothered to add the expected incorrect results.
-             * FIXME Enable once these bugs have been fixed.
-             */
-            if (0 && json_out != json_in) {
+            /* Parse @json_out right back, unless it has replacements */
+            if (!strstr(json_out, "\\uFFFD")) {

                 str = from_json_str(json_out, j, &error_abort);
                 str = from_json_str(json_out, j, &error_abort);

-                g_assert_cmpstr(qstring_get_try_str(str), ==, utf8_out);
+                g_assert_cmpstr(qstring_get_try_str(str), ==, utf8_in);
+                qobject_unref(str);

             }
         }
     }
             }
         }
     }


@@ -1036,9 +951,11 @@ static void keyword_literal(void)
 static void interpolation_valid(void)
 {
     long long value_lld = 0x123456789abcdefLL;
 static void interpolation_valid(void)
 {
     long long value_lld = 0x123456789abcdefLL;

+    int64_t value_d64 = value_lld;

     long value_ld = (long)value_lld;
     int value_d = (int)value_lld;
     unsigned long long value_llu = 0xfedcba9876543210ULL;
     long value_ld = (long)value_lld;
     int value_d = (int)value_lld;
     unsigned long long value_llu = 0xfedcba9876543210ULL;

+    uint64_t value_u64 = value_llu;

     unsigned long value_lu = (unsigned long)value_llu;
     unsigned value_u = (unsigned)value_llu;
     double value_f = 2.323423423;
     unsigned long value_lu = (unsigned long)value_llu;
     unsigned value_u = (unsigned)value_llu;
     double value_f = 2.323423423;


@@ -1076,6 +993,10 @@ static void interpolation_valid(void)
     g_assert_cmpint(qnum_get_int(qnum), ==, value_lld);
     qobject_unref(qnum);
 
     g_assert_cmpint(qnum_get_int(qnum), ==, value_lld);
     qobject_unref(qnum);
 

+    qnum = qobject_to(QNum, qobject_from_jsonf_nofail("%" PRId64, value_d64));
+    g_assert_cmpint(qnum_get_int(qnum), ==, value_lld);
+    qobject_unref(qnum);
+

     qnum = qobject_to(QNum, qobject_from_jsonf_nofail("%u", value_u));
     g_assert_cmpuint(qnum_get_uint(qnum), ==, value_u);
     qobject_unref(qnum);
     qnum = qobject_to(QNum, qobject_from_jsonf_nofail("%u", value_u));
     g_assert_cmpuint(qnum_get_uint(qnum), ==, value_u);
     qobject_unref(qnum);


@@ -1088,6 +1009,10 @@ static void interpolation_valid(void)
     g_assert_cmpuint(qnum_get_uint(qnum), ==, value_llu);
     qobject_unref(qnum);
 
     g_assert_cmpuint(qnum_get_uint(qnum), ==, value_llu);
     qobject_unref(qnum);
 

+    qnum = qobject_to(QNum, qobject_from_jsonf_nofail("%" PRIu64, value_u64));
+    g_assert_cmpuint(qnum_get_uint(qnum), ==, value_llu);
+    qobject_unref(qnum);
+

     qnum = qobject_to(QNum, qobject_from_jsonf_nofail("%f", value_f));
     g_assert(qnum_get_double(qnum) == value_f);
     qobject_unref(qnum);
     qnum = qobject_to(QNum, qobject_from_jsonf_nofail("%f", value_f));
     g_assert(qnum_get_double(qnum) == value_f);
     qobject_unref(qnum);


@@ -1112,20 +1037,19 @@ static void interpolation_unknown(void)
     }
     g_test_trap_subprocess(NULL, 0, 0);
     g_test_trap_assert_failed();
     }
     g_test_trap_subprocess(NULL, 0, 0);
     g_test_trap_assert_failed();

+    g_test_trap_assert_stderr("*Unexpected error*"
+                              "invalid interpolation '%x'*");

 }
 
 static void interpolation_string(void)
 {
 }
 
 static void interpolation_string(void)
 {

-    QLitObject decoded = QLIT_QLIST(((QLitObject[]){
-            QLIT_QSTR("%s"),
-            QLIT_QSTR("eins"),
-            {}}));
-    QObject *qobj;
-
-    /* Dangerous misfeature: % is silently ignored in strings */
-    qobj = qobject_from_jsonf_nofail("['%s', %s]", "eins", "zwei");
-    g_assert(qlit_equal_qobject(&decoded, qobj));
-    qobject_unref(qobj);
+    if (g_test_subprocess()) {
+        qobject_from_jsonf_nofail("['%s', %s]", "eins", "zwei");
+    }
+    g_test_trap_subprocess(NULL, 0, 0);
+    g_test_trap_assert_failed();
+    g_test_trap_assert_stderr("*Unexpected error*"
+                              "can't interpolate into string*");

 }
 
 static void simple_dict(void)
 }
 
 static void simple_dict(void)


@@ -1352,7 +1276,7 @@ static void simple_interpolation(void)
     QObject *obj;
     QLitObject decoded = QLIT_QLIST(((QLitObject[]){
             QLIT_QNUM(1),
     QObject *obj;
     QLitObject decoded = QLIT_QLIST(((QLitObject[]){
             QLIT_QNUM(1),

-            QLIT_QNUM(2),
+            QLIT_QSTR("100%"),

             QLIT_QLIST(((QLitObject[]){
                         QLIT_QNUM(32),
                         QLIT_QNUM(42),
             QLIT_QLIST(((QLitObject[]){
                         QLIT_QNUM(32),
                         QLIT_QNUM(42),


@@ -1362,7 +1286,7 @@ static void simple_interpolation(void)
     embedded_obj = qobject_from_json("[32, 42]", &error_abort);
     g_assert(embedded_obj != NULL);
 
     embedded_obj = qobject_from_json("[32, 42]", &error_abort);
     g_assert(embedded_obj != NULL);
 

-    obj = qobject_from_jsonf_nofail("[%d, 2, %p]", 1, embedded_obj);
+    obj = qobject_from_jsonf_nofail("[%d, '100%%', %p]", 1, embedded_obj);

     g_assert(qlit_equal_qobject(&decoded, obj));
 
     qobject_unref(obj);
     g_assert(qlit_equal_qobject(&decoded, obj));
 
     qobject_unref(obj);


@@ -1370,13 +1294,21 @@ static void simple_interpolation(void)
 
 static void empty_input(void)
 {
 
 static void empty_input(void)
 {

-    QObject *obj = qobject_from_json("", &error_abort);
+    Error *err = NULL;
+    QObject *obj;
+
+    obj = qobject_from_json("", &err);
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
 static void blank_input(void)
 {
     g_assert(obj == NULL);
 }
 
 static void blank_input(void)
 {

-    QObject *obj = qobject_from_json("\n ", &error_abort);
+    Error *err = NULL;
+    QObject *obj;
+
+    obj = qobject_from_json("\n ", &err);
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1387,11 +1319,11 @@ static void junk_input(void)
     QObject *obj;
 
     obj = qobject_from_json("@", &err);
     QObject *obj;
 
     obj = qobject_from_json("@", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 
     obj = qobject_from_json("{\x01", &err);
     g_assert(obj == NULL);
 
     obj = qobject_from_json("{\x01", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 
     obj = qobject_from_json("[0\xFF]", &err);
     g_assert(obj == NULL);
 
     obj = qobject_from_json("[0\xFF]", &err);


@@ -1399,11 +1331,11 @@ static void junk_input(void)
     g_assert(obj == NULL);
 
     obj = qobject_from_json("00", &err);
     g_assert(obj == NULL);
 
     obj = qobject_from_json("00", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 
     obj = qobject_from_json("[1e", &err);
     g_assert(obj == NULL);
 
     obj = qobject_from_json("[1e", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 
     obj = qobject_from_json("truer", &err);
     g_assert(obj == NULL);
 
     obj = qobject_from_json("truer", &err);


@@ -1415,7 +1347,7 @@ static void unterminated_string(void)
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("\"abc", &err);
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("\"abc", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1423,7 +1355,7 @@ static void unterminated_sq_string(void)
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("'abc", &err);
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("'abc", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1431,7 +1363,7 @@ static void unterminated_escape(void)
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("\"abc\\\"", &err);
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("\"abc\\\"", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1439,7 +1371,7 @@ static void unterminated_array(void)
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("[32", &err);
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("[32", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1447,7 +1379,7 @@ static void unterminated_array_comma(void)
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("[32,", &err);
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("[32,", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1463,7 +1395,7 @@ static void unterminated_dict(void)
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("{'abc':32", &err);
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("{'abc':32", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1471,7 +1403,7 @@ static void unterminated_dict_comma(void)
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("{'abc':32,", &err);
 {
     Error *err = NULL;
     QObject *obj = qobject_from_json("{'abc':32,", &err);

-    g_assert(!err);             /* BUG */
+    error_free_or_abort(&err);

     g_assert(obj == NULL);
 }
 
     g_assert(obj == NULL);
 }
 


@@ -1522,18 +1454,13 @@ static void multiple_values(void)
     Error *err = NULL;
     QObject *obj;
 
     Error *err = NULL;
     QObject *obj;
 

-    /* BUG this leaks the syntax tree for "false" */

     obj = qobject_from_json("false true", &err);
     obj = qobject_from_json("false true", &err);

-    g_assert(qbool_get_bool(qobject_to(QBool, obj)));
-    g_assert(!err);
-    qobject_unref(obj);
+    error_free_or_abort(&err);
+    g_assert(obj == NULL);

 
 

-    /* BUG simultaneously succeeds and fails */
-    /* BUG calls json_parser_parse() with errp pointing to non-null */

     obj = qobject_from_json("} true", &err);
     obj = qobject_from_json("} true", &err);

-    g_assert(qbool_get_bool(qobject_to(QBool, obj)));

     error_free_or_abort(&err);
     error_free_or_abort(&err);

-    qobject_unref(obj);
+    g_assert(obj == NULL);

 }
 
 int main(int argc, char **argv)
 }
 
 int main(int argc, char **argv)