Return to check-qjson.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / tests

Annotation of qemu/tests/check-qjson.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright IBM, Corp. 2009
        !             3:  *
        !             4:  * Authors:
        !             5:  *  Anthony Liguori   <[email protected]>
        !             6:  *
        !             7:  * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
        !             8:  * See the COPYING.LIB file in the top-level directory.
        !             9:  *
        !            10:  */
        !            11: #include <glib.h>
        !            12: 
        !            13: #include "qstring.h"
        !            14: #include "qint.h"
        !            15: #include "qdict.h"
        !            16: #include "qlist.h"
        !            17: #include "qfloat.h"
        !            18: #include "qbool.h"
        !            19: #include "qjson.h"
        !            20: 
        !            21: #include "qemu-common.h"
        !            22: 
        !            23: static void escaped_string(void)
        !            24: {
        !            25:     int i;
        !            26:     struct {
        !            27:         const char *encoded;
        !            28:         const char *decoded;
        !            29:         int skip;
        !            30:     } test_cases[] = {
        !            31:         { "\"\\b\"", "\b" },
        !            32:         { "\"\\f\"", "\f" },
        !            33:         { "\"\\n\"", "\n" },
        !            34:         { "\"\\r\"", "\r" },
        !            35:         { "\"\\t\"", "\t" },
        !            36:         { "\"/\"", "/" },
        !            37:         { "\"\\/\"", "/", .skip = 1 },
        !            38:         { "\"\\\\\"", "\\" },
        !            39:         { "\"\\\"\"", "\"" },
        !            40:         { "\"hello world \\\"embedded string\\\"\"",
        !            41:           "hello world \"embedded string\"" },
        !            42:         { "\"hello world\\nwith new line\"", "hello world\nwith new line" },
        !            43:         { "\"single byte utf-8 \\u0020\"", "single byte utf-8  ", .skip = 1 },
        !            44:         { "\"double byte utf-8 \\u00A2\"", "double byte utf-8 \xc2\xa2" },
        !            45:         { "\"triple byte utf-8 \\u20AC\"", "triple byte utf-8 \xe2\x82\xac" },
        !            46:         {}
        !            47:     };
        !            48: 
        !            49:     for (i = 0; test_cases[i].encoded; i++) {
        !            50:         QObject *obj;
        !            51:         QString *str;
        !            52: 
        !            53:         obj = qobject_from_json(test_cases[i].encoded);
        !            54: 
        !            55:         g_assert(obj != NULL);
        !            56:         g_assert(qobject_type(obj) == QTYPE_QSTRING);
        !            57:         
        !            58:         str = qobject_to_qstring(obj);
        !            59:         g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].decoded);
        !            60: 
        !            61:         if (test_cases[i].skip == 0) {
        !            62:             str = qobject_to_json(obj);
        !            63:             g_assert_cmpstr(qstring_get_str(str), ==, test_cases[i].encoded);
        !            64:             qobject_decref(obj);
        !            65:         }
        !            66: 
        !            67:         QDECREF(str);
        !            68:     }
        !            69: }
        !            70: 
        !            71: static void simple_string(void)
        !            72: {
        !            73:     int i;
        !            74:     struct {
        !            75:         const char *encoded;
        !            76:         const char *decoded;
        !            77:     } test_cases[] = {
        !            78:         { "\"hello world\"", "hello world" },
        !            79:         { "\"the quick brown fox jumped over the fence\"",
        !            80:           "the quick brown fox jumped over the fence" },
        !            81:         {}
        !            82:     };
        !            83: 
        !            84:     for (i = 0; test_cases[i].encoded; i++) {
        !            85:         QObject *obj;
        !            86:         QString *str;
        !            87: 
        !            88:         obj = qobject_from_json(test_cases[i].encoded);
        !            89: 
        !            90:         g_assert(obj != NULL);
        !            91:         g_assert(qobject_type(obj) == QTYPE_QSTRING);
        !            92:         
        !            93:         str = qobject_to_qstring(obj);
        !            94:         g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
        !            95: 
        !            96:         str = qobject_to_json(obj);
        !            97:         g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
        !            98: 
        !            99:         qobject_decref(obj);
        !           100:         
        !           101:         QDECREF(str);
        !           102:     }
        !           103: }
        !           104: 
        !           105: static void single_quote_string(void)
        !           106: {
        !           107:     int i;
        !           108:     struct {
        !           109:         const char *encoded;
        !           110:         const char *decoded;
        !           111:     } test_cases[] = {
        !           112:         { "'hello world'", "hello world" },
        !           113:         { "'the quick brown fox \\' jumped over the fence'",
        !           114:           "the quick brown fox ' jumped over the fence" },
        !           115:         {}
        !           116:     };
        !           117: 
        !           118:     for (i = 0; test_cases[i].encoded; i++) {
        !           119:         QObject *obj;
        !           120:         QString *str;
        !           121: 
        !           122:         obj = qobject_from_json(test_cases[i].encoded);
        !           123: 
        !           124:         g_assert(obj != NULL);
        !           125:         g_assert(qobject_type(obj) == QTYPE_QSTRING);
        !           126:         
        !           127:         str = qobject_to_qstring(obj);
        !           128:         g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
        !           129: 
        !           130:         QDECREF(str);
        !           131:     }
        !           132: }
        !           133: 
        !           134: static void vararg_string(void)
        !           135: {
        !           136:     int i;
        !           137:     struct {
        !           138:         const char *decoded;
        !           139:     } test_cases[] = {
        !           140:         { "hello world" },
        !           141:         { "the quick brown fox jumped over the fence" },
        !           142:         {}
        !           143:     };
        !           144: 
        !           145:     for (i = 0; test_cases[i].decoded; i++) {
        !           146:         QObject *obj;
        !           147:         QString *str;
        !           148: 
        !           149:         obj = qobject_from_jsonf("%s", test_cases[i].decoded);
        !           150: 
        !           151:         g_assert(obj != NULL);
        !           152:         g_assert(qobject_type(obj) == QTYPE_QSTRING);
        !           153:         
        !           154:         str = qobject_to_qstring(obj);
        !           155:         g_assert(strcmp(qstring_get_str(str), test_cases[i].decoded) == 0);
        !           156: 
        !           157:         QDECREF(str);
        !           158:     }
        !           159: }
        !           160: 
        !           161: static void simple_number(void)
        !           162: {
        !           163:     int i;
        !           164:     struct {
        !           165:         const char *encoded;
        !           166:         int64_t decoded;
        !           167:         int skip;
        !           168:     } test_cases[] = {
        !           169:         { "0", 0 },
        !           170:         { "1234", 1234 },
        !           171:         { "1", 1 },
        !           172:         { "-32", -32 },
        !           173:         { "-0", 0, .skip = 1 },
        !           174:         { },
        !           175:     };
        !           176: 
        !           177:     for (i = 0; test_cases[i].encoded; i++) {
        !           178:         QObject *obj;
        !           179:         QInt *qint;
        !           180: 
        !           181:         obj = qobject_from_json(test_cases[i].encoded);
        !           182:         g_assert(obj != NULL);
        !           183:         g_assert(qobject_type(obj) == QTYPE_QINT);
        !           184: 
        !           185:         qint = qobject_to_qint(obj);
        !           186:         g_assert(qint_get_int(qint) == test_cases[i].decoded);
        !           187:         if (test_cases[i].skip == 0) {
        !           188:             QString *str;
        !           189: 
        !           190:             str = qobject_to_json(obj);
        !           191:             g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
        !           192:             QDECREF(str);
        !           193:         }
        !           194: 
        !           195:         QDECREF(qint);
        !           196:     }
        !           197: }
        !           198: 
        !           199: static void float_number(void)
        !           200: {
        !           201:     int i;
        !           202:     struct {
        !           203:         const char *encoded;
        !           204:         double decoded;
        !           205:         int skip;
        !           206:     } test_cases[] = {
        !           207:         { "32.43", 32.43 },
        !           208:         { "0.222", 0.222 },
        !           209:         { "-32.12313", -32.12313 },
        !           210:         { "-32.20e-10", -32.20e-10, .skip = 1 },
        !           211:         { },
        !           212:     };
        !           213: 
        !           214:     for (i = 0; test_cases[i].encoded; i++) {
        !           215:         QObject *obj;
        !           216:         QFloat *qfloat;
        !           217: 
        !           218:         obj = qobject_from_json(test_cases[i].encoded);
        !           219:         g_assert(obj != NULL);
        !           220:         g_assert(qobject_type(obj) == QTYPE_QFLOAT);
        !           221: 
        !           222:         qfloat = qobject_to_qfloat(obj);
        !           223:         g_assert(qfloat_get_double(qfloat) == test_cases[i].decoded);
        !           224: 
        !           225:         if (test_cases[i].skip == 0) {
        !           226:             QString *str;
        !           227: 
        !           228:             str = qobject_to_json(obj);
        !           229:             g_assert(strcmp(qstring_get_str(str), test_cases[i].encoded) == 0);
        !           230:             QDECREF(str);
        !           231:         }
        !           232: 
        !           233:         QDECREF(qfloat);
        !           234:     }
        !           235: }
        !           236: 
        !           237: static void vararg_number(void)
        !           238: {
        !           239:     QObject *obj;
        !           240:     QInt *qint;
        !           241:     QFloat *qfloat;
        !           242:     int value = 0x2342;
        !           243:     int64_t value64 = 0x2342342343LL;
        !           244:     double valuef = 2.323423423;
        !           245: 
        !           246:     obj = qobject_from_jsonf("%d", value);
        !           247:     g_assert(obj != NULL);
        !           248:     g_assert(qobject_type(obj) == QTYPE_QINT);
        !           249: 
        !           250:     qint = qobject_to_qint(obj);
        !           251:     g_assert(qint_get_int(qint) == value);
        !           252: 
        !           253:     QDECREF(qint);
        !           254: 
        !           255:     obj = qobject_from_jsonf("%" PRId64, value64);
        !           256:     g_assert(obj != NULL);
        !           257:     g_assert(qobject_type(obj) == QTYPE_QINT);
        !           258: 
        !           259:     qint = qobject_to_qint(obj);
        !           260:     g_assert(qint_get_int(qint) == value64);
        !           261: 
        !           262:     QDECREF(qint);
        !           263: 
        !           264:     obj = qobject_from_jsonf("%f", valuef);
        !           265:     g_assert(obj != NULL);
        !           266:     g_assert(qobject_type(obj) == QTYPE_QFLOAT);
        !           267: 
        !           268:     qfloat = qobject_to_qfloat(obj);
        !           269:     g_assert(qfloat_get_double(qfloat) == valuef);
        !           270: 
        !           271:     QDECREF(qfloat);
        !           272: }
        !           273: 
        !           274: static void keyword_literal(void)
        !           275: {
        !           276:     QObject *obj;
        !           277:     QBool *qbool;
        !           278:     QString *str;
        !           279: 
        !           280:     obj = qobject_from_json("true");
        !           281:     g_assert(obj != NULL);
        !           282:     g_assert(qobject_type(obj) == QTYPE_QBOOL);
        !           283: 
        !           284:     qbool = qobject_to_qbool(obj);
        !           285:     g_assert(qbool_get_int(qbool) != 0);
        !           286: 
        !           287:     str = qobject_to_json(obj);
        !           288:     g_assert(strcmp(qstring_get_str(str), "true") == 0);
        !           289:     QDECREF(str);
        !           290: 
        !           291:     QDECREF(qbool);
        !           292: 
        !           293:     obj = qobject_from_json("false");
        !           294:     g_assert(obj != NULL);
        !           295:     g_assert(qobject_type(obj) == QTYPE_QBOOL);
        !           296: 
        !           297:     qbool = qobject_to_qbool(obj);
        !           298:     g_assert(qbool_get_int(qbool) == 0);
        !           299: 
        !           300:     str = qobject_to_json(obj);
        !           301:     g_assert(strcmp(qstring_get_str(str), "false") == 0);
        !           302:     QDECREF(str);
        !           303: 
        !           304:     QDECREF(qbool);
        !           305: 
        !           306:     obj = qobject_from_jsonf("%i", false);
        !           307:     g_assert(obj != NULL);
        !           308:     g_assert(qobject_type(obj) == QTYPE_QBOOL);
        !           309: 
        !           310:     qbool = qobject_to_qbool(obj);
        !           311:     g_assert(qbool_get_int(qbool) == 0);
        !           312: 
        !           313:     QDECREF(qbool);
        !           314:     
        !           315:     obj = qobject_from_jsonf("%i", true);
        !           316:     g_assert(obj != NULL);
        !           317:     g_assert(qobject_type(obj) == QTYPE_QBOOL);
        !           318: 
        !           319:     qbool = qobject_to_qbool(obj);
        !           320:     g_assert(qbool_get_int(qbool) != 0);
        !           321: 
        !           322:     QDECREF(qbool);
        !           323: }
        !           324: 
        !           325: typedef struct LiteralQDictEntry LiteralQDictEntry;
        !           326: typedef struct LiteralQObject LiteralQObject;
        !           327: 
        !           328: struct LiteralQObject
        !           329: {
        !           330:     int type;
        !           331:     union {
        !           332:         int64_t qint;
        !           333:         const char *qstr;
        !           334:         LiteralQDictEntry *qdict;
        !           335:         LiteralQObject *qlist;
        !           336:     } value;
        !           337: };
        !           338: 
        !           339: struct LiteralQDictEntry
        !           340: {
        !           341:     const char *key;
        !           342:     LiteralQObject value;
        !           343: };
        !           344: 
        !           345: #define QLIT_QINT(val) (LiteralQObject){.type = QTYPE_QINT, .value.qint = (val)}
        !           346: #define QLIT_QSTR(val) (LiteralQObject){.type = QTYPE_QSTRING, .value.qstr = (val)}
        !           347: #define QLIT_QDICT(val) (LiteralQObject){.type = QTYPE_QDICT, .value.qdict = (val)}
        !           348: #define QLIT_QLIST(val) (LiteralQObject){.type = QTYPE_QLIST, .value.qlist = (val)}
        !           349: 
        !           350: typedef struct QListCompareHelper
        !           351: {
        !           352:     int index;
        !           353:     LiteralQObject *objs;
        !           354:     int result;
        !           355: } QListCompareHelper;
        !           356: 
        !           357: static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs);
        !           358: 
        !           359: static void compare_helper(QObject *obj, void *opaque)
        !           360: {
        !           361:     QListCompareHelper *helper = opaque;
        !           362: 
        !           363:     if (helper->result == 0) {
        !           364:         return;
        !           365:     }
        !           366: 
        !           367:     if (helper->objs[helper->index].type == QTYPE_NONE) {
        !           368:         helper->result = 0;
        !           369:         return;
        !           370:     }
        !           371: 
        !           372:     helper->result = compare_litqobj_to_qobj(&helper->objs[helper->index++], obj);
        !           373: }
        !           374: 
        !           375: static int compare_litqobj_to_qobj(LiteralQObject *lhs, QObject *rhs)
        !           376: {
        !           377:     if (lhs->type != qobject_type(rhs)) {
        !           378:         return 0;
        !           379:     }
        !           380: 
        !           381:     switch (lhs->type) {
        !           382:     case QTYPE_QINT:
        !           383:         return lhs->value.qint == qint_get_int(qobject_to_qint(rhs));
        !           384:     case QTYPE_QSTRING:
        !           385:         return (strcmp(lhs->value.qstr, qstring_get_str(qobject_to_qstring(rhs))) == 0);
        !           386:     case QTYPE_QDICT: {
        !           387:         int i;
        !           388: 
        !           389:         for (i = 0; lhs->value.qdict[i].key; i++) {
        !           390:             QObject *obj = qdict_get(qobject_to_qdict(rhs), lhs->value.qdict[i].key);
        !           391: 
        !           392:             if (!compare_litqobj_to_qobj(&lhs->value.qdict[i].value, obj)) {
        !           393:                 return 0;
        !           394:             }
        !           395:         }
        !           396: 
        !           397:         return 1;
        !           398:     }
        !           399:     case QTYPE_QLIST: {
        !           400:         QListCompareHelper helper;
        !           401: 
        !           402:         helper.index = 0;
        !           403:         helper.objs = lhs->value.qlist;
        !           404:         helper.result = 1;
        !           405:         
        !           406:         qlist_iter(qobject_to_qlist(rhs), compare_helper, &helper);
        !           407: 
        !           408:         return helper.result;
        !           409:     }
        !           410:     default:
        !           411:         break;
        !           412:     }
        !           413: 
        !           414:     return 0;
        !           415: }
        !           416: 
        !           417: static void simple_dict(void)
        !           418: {
        !           419:     int i;
        !           420:     struct {
        !           421:         const char *encoded;
        !           422:         LiteralQObject decoded;
        !           423:     } test_cases[] = {
        !           424:         {
        !           425:             .encoded = "{\"foo\": 42, \"bar\": \"hello world\"}",
        !           426:             .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
        !           427:                         { "foo", QLIT_QINT(42) },
        !           428:                         { "bar", QLIT_QSTR("hello world") },
        !           429:                         { }
        !           430:                     })),
        !           431:         }, {
        !           432:             .encoded = "{}",
        !           433:             .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
        !           434:                         { }
        !           435:                     })),
        !           436:         }, {
        !           437:             .encoded = "{\"foo\": 43}",
        !           438:             .decoded = QLIT_QDICT(((LiteralQDictEntry[]){
        !           439:                         { "foo", QLIT_QINT(43) },
        !           440:                         { }
        !           441:                     })),
        !           442:         },
        !           443:         { }
        !           444:     };
        !           445: 
        !           446:     for (i = 0; test_cases[i].encoded; i++) {
        !           447:         QObject *obj;
        !           448:         QString *str;
        !           449: 
        !           450:         obj = qobject_from_json(test_cases[i].encoded);
        !           451:         g_assert(obj != NULL);
        !           452:         g_assert(qobject_type(obj) == QTYPE_QDICT);
        !           453: 
        !           454:         g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        !           455: 
        !           456:         str = qobject_to_json(obj);
        !           457:         qobject_decref(obj);
        !           458: 
        !           459:         obj = qobject_from_json(qstring_get_str(str));
        !           460:         g_assert(obj != NULL);
        !           461:         g_assert(qobject_type(obj) == QTYPE_QDICT);
        !           462: 
        !           463:         g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        !           464:         qobject_decref(obj);
        !           465:         QDECREF(str);
        !           466:     }
        !           467: }
        !           468: 
        !           469: static void simple_list(void)
        !           470: {
        !           471:     int i;
        !           472:     struct {
        !           473:         const char *encoded;
        !           474:         LiteralQObject decoded;
        !           475:     } test_cases[] = {
        !           476:         {
        !           477:             .encoded = "[43,42]",
        !           478:             .decoded = QLIT_QLIST(((LiteralQObject[]){
        !           479:                         QLIT_QINT(43),
        !           480:                         QLIT_QINT(42),
        !           481:                         { }
        !           482:                     })),
        !           483:         },
        !           484:         {
        !           485:             .encoded = "[43]",
        !           486:             .decoded = QLIT_QLIST(((LiteralQObject[]){
        !           487:                         QLIT_QINT(43),
        !           488:                         { }
        !           489:                     })),
        !           490:         },
        !           491:         {
        !           492:             .encoded = "[]",
        !           493:             .decoded = QLIT_QLIST(((LiteralQObject[]){
        !           494:                         { }
        !           495:                     })),
        !           496:         },
        !           497:         {
        !           498:             .encoded = "[{}]",
        !           499:             .decoded = QLIT_QLIST(((LiteralQObject[]){
        !           500:                         QLIT_QDICT(((LiteralQDictEntry[]){
        !           501:                                     {},
        !           502:                                         })),
        !           503:                         {},
        !           504:                             })),
        !           505:         },
        !           506:         { }
        !           507:     };
        !           508: 
        !           509:     for (i = 0; test_cases[i].encoded; i++) {
        !           510:         QObject *obj;
        !           511:         QString *str;
        !           512: 
        !           513:         obj = qobject_from_json(test_cases[i].encoded);
        !           514:         g_assert(obj != NULL);
        !           515:         g_assert(qobject_type(obj) == QTYPE_QLIST);
        !           516: 
        !           517:         g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        !           518: 
        !           519:         str = qobject_to_json(obj);
        !           520:         qobject_decref(obj);
        !           521: 
        !           522:         obj = qobject_from_json(qstring_get_str(str));
        !           523:         g_assert(obj != NULL);
        !           524:         g_assert(qobject_type(obj) == QTYPE_QLIST);
        !           525: 
        !           526:         g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        !           527:         qobject_decref(obj);
        !           528:         QDECREF(str);
        !           529:     }
        !           530: }
        !           531: 
        !           532: static void simple_whitespace(void)
        !           533: {
        !           534:     int i;
        !           535:     struct {
        !           536:         const char *encoded;
        !           537:         LiteralQObject decoded;
        !           538:     } test_cases[] = {
        !           539:         {
        !           540:             .encoded = " [ 43 , 42 ]",
        !           541:             .decoded = QLIT_QLIST(((LiteralQObject[]){
        !           542:                         QLIT_QINT(43),
        !           543:                         QLIT_QINT(42),
        !           544:                         { }
        !           545:                     })),
        !           546:         },
        !           547:         {
        !           548:             .encoded = " [ 43 , { 'h' : 'b' }, [ ], 42 ]",
        !           549:             .decoded = QLIT_QLIST(((LiteralQObject[]){
        !           550:                         QLIT_QINT(43),
        !           551:                         QLIT_QDICT(((LiteralQDictEntry[]){
        !           552:                                     { "h", QLIT_QSTR("b") },
        !           553:                                     { }})),
        !           554:                         QLIT_QLIST(((LiteralQObject[]){
        !           555:                                     { }})),
        !           556:                         QLIT_QINT(42),
        !           557:                         { }
        !           558:                     })),
        !           559:         },
        !           560:         {
        !           561:             .encoded = " [ 43 , { 'h' : 'b' , 'a' : 32 }, [ ], 42 ]",
        !           562:             .decoded = QLIT_QLIST(((LiteralQObject[]){
        !           563:                         QLIT_QINT(43),
        !           564:                         QLIT_QDICT(((LiteralQDictEntry[]){
        !           565:                                     { "h", QLIT_QSTR("b") },
        !           566:                                     { "a", QLIT_QINT(32) },
        !           567:                                     { }})),
        !           568:                         QLIT_QLIST(((LiteralQObject[]){
        !           569:                                     { }})),
        !           570:                         QLIT_QINT(42),
        !           571:                         { }
        !           572:                     })),
        !           573:         },
        !           574:         { }
        !           575:     };
        !           576: 
        !           577:     for (i = 0; test_cases[i].encoded; i++) {
        !           578:         QObject *obj;
        !           579:         QString *str;
        !           580: 
        !           581:         obj = qobject_from_json(test_cases[i].encoded);
        !           582:         g_assert(obj != NULL);
        !           583:         g_assert(qobject_type(obj) == QTYPE_QLIST);
        !           584: 
        !           585:         g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        !           586: 
        !           587:         str = qobject_to_json(obj);
        !           588:         qobject_decref(obj);
        !           589: 
        !           590:         obj = qobject_from_json(qstring_get_str(str));
        !           591:         g_assert(obj != NULL);
        !           592:         g_assert(qobject_type(obj) == QTYPE_QLIST);
        !           593: 
        !           594:         g_assert(compare_litqobj_to_qobj(&test_cases[i].decoded, obj) == 1);
        !           595: 
        !           596:         qobject_decref(obj);
        !           597:         QDECREF(str);
        !           598:     }
        !           599: }
        !           600: 
        !           601: static void simple_varargs(void)
        !           602: {
        !           603:     QObject *embedded_obj;
        !           604:     QObject *obj;
        !           605:     LiteralQObject decoded = QLIT_QLIST(((LiteralQObject[]){
        !           606:             QLIT_QINT(1),
        !           607:             QLIT_QINT(2),
        !           608:             QLIT_QLIST(((LiteralQObject[]){
        !           609:                         QLIT_QINT(32),
        !           610:                         QLIT_QINT(42),
        !           611:                         {}})),
        !           612:             {}}));
        !           613: 
        !           614:     embedded_obj = qobject_from_json("[32, 42]");
        !           615:     g_assert(embedded_obj != NULL);
        !           616: 
        !           617:     obj = qobject_from_jsonf("[%d, 2, %p]", 1, embedded_obj);
        !           618:     g_assert(obj != NULL);
        !           619: 
        !           620:     g_assert(compare_litqobj_to_qobj(&decoded, obj) == 1);
        !           621: 
        !           622:     qobject_decref(obj);
        !           623: }
        !           624: 
        !           625: static void empty_input(void)
        !           626: {
        !           627:     const char *empty = "";
        !           628: 
        !           629:     QObject *obj = qobject_from_json(empty);
        !           630:     g_assert(obj == NULL);
        !           631: }
        !           632: 
        !           633: static void unterminated_string(void)
        !           634: {
        !           635:     QObject *obj = qobject_from_json("\"abc");
        !           636:     g_assert(obj == NULL);
        !           637: }
        !           638: 
        !           639: static void unterminated_sq_string(void)
        !           640: {
        !           641:     QObject *obj = qobject_from_json("'abc");
        !           642:     g_assert(obj == NULL);
        !           643: }
        !           644: 
        !           645: static void unterminated_escape(void)
        !           646: {
        !           647:     QObject *obj = qobject_from_json("\"abc\\\"");
        !           648:     g_assert(obj == NULL);
        !           649: }
        !           650: 
        !           651: static void unterminated_array(void)
        !           652: {
        !           653:     QObject *obj = qobject_from_json("[32");
        !           654:     g_assert(obj == NULL);
        !           655: }
        !           656: 
        !           657: static void unterminated_array_comma(void)
        !           658: {
        !           659:     QObject *obj = qobject_from_json("[32,");
        !           660:     g_assert(obj == NULL);
        !           661: }
        !           662: 
        !           663: static void invalid_array_comma(void)
        !           664: {
        !           665:     QObject *obj = qobject_from_json("[32,}");
        !           666:     g_assert(obj == NULL);
        !           667: }
        !           668: 
        !           669: static void unterminated_dict(void)
        !           670: {
        !           671:     QObject *obj = qobject_from_json("{'abc':32");
        !           672:     g_assert(obj == NULL);
        !           673: }
        !           674: 
        !           675: static void unterminated_dict_comma(void)
        !           676: {
        !           677:     QObject *obj = qobject_from_json("{'abc':32,");
        !           678:     g_assert(obj == NULL);
        !           679: }
        !           680: 
        !           681: static void invalid_dict_comma(void)
        !           682: {
        !           683:     QObject *obj = qobject_from_json("{'abc':32,}");
        !           684:     g_assert(obj == NULL);
        !           685: }
        !           686: 
        !           687: static void unterminated_literal(void)
        !           688: {
        !           689:     QObject *obj = qobject_from_json("nul");
        !           690:     g_assert(obj == NULL);
        !           691: }
        !           692: 
        !           693: int main(int argc, char **argv)
        !           694: {
        !           695:     g_test_init(&argc, &argv, NULL);
        !           696: 
        !           697:     g_test_add_func("/literals/string/simple", simple_string);
        !           698:     g_test_add_func("/literals/string/escaped", escaped_string);
        !           699:     g_test_add_func("/literals/string/single_quote", single_quote_string);
        !           700:     g_test_add_func("/literals/string/vararg", vararg_string);
        !           701: 
        !           702:     g_test_add_func("/literals/number/simple", simple_number);
        !           703:     g_test_add_func("/literals/number/float", float_number);
        !           704:     g_test_add_func("/literals/number/vararg", vararg_number);
        !           705: 
        !           706:     g_test_add_func("/literals/keyword", keyword_literal);
        !           707: 
        !           708:     g_test_add_func("/dicts/simple_dict", simple_dict);
        !           709:     g_test_add_func("/lists/simple_list", simple_list);
        !           710: 
        !           711:     g_test_add_func("/whitespace/simple_whitespace", simple_whitespace);
        !           712: 
        !           713:     g_test_add_func("/varargs/simple_varargs", simple_varargs);
        !           714: 
        !           715:     g_test_add_func("/errors/empty_input", empty_input);
        !           716:     g_test_add_func("/errors/unterminated/string", unterminated_string);
        !           717:     g_test_add_func("/errors/unterminated/escape", unterminated_escape);
        !           718:     g_test_add_func("/errors/unterminated/sq_string", unterminated_sq_string);
        !           719:     g_test_add_func("/errors/unterminated/array", unterminated_array);
        !           720:     g_test_add_func("/errors/unterminated/array_comma", unterminated_array_comma);
        !           721:     g_test_add_func("/errors/unterminated/dict", unterminated_dict);
        !           722:     g_test_add_func("/errors/unterminated/dict_comma", unterminated_dict_comma);
        !           723:     g_test_add_func("/errors/invalid_array_comma", invalid_array_comma);
        !           724:     g_test_add_func("/errors/invalid_dict_comma", invalid_dict_comma);
        !           725:     g_test_add_func("/errors/unterminated/literal", unterminated_literal);
        !           726: 
        !           727:     return g_test_run();
        !           728: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.