tests/unit/test-qobject-input-visitor.c

   1 /*
   2  * QObject Input Visitor unit-tests.
   3  *
   4  * Copyright (C) 2011-2016 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Luiz Capitulino <lcapitulino@redhat.com>
   8  *  Paolo Bonzini <pbonzini@redhat.com>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  11  * See the COPYING file in the top-level directory.
  12  */
  13
  14 #include "qemu/osdep.h"
  15
  16 #include "qapi/error.h"
  17 #include "qapi/qapi-visit-introspect.h"
  18 #include "qapi/qobject-input-visitor.h"
  19 #include "test-qapi-visit.h"
  20 #include "qapi/qmp/qbool.h"
  21 #include "qapi/qmp/qdict.h"
  22 #include "qapi/qmp/qnull.h"
  23 #include "qapi/qmp/qnum.h"
  24 #include "qapi/qmp/qstring.h"
  25 #include "qapi/qmp/qjson.h"
  26 #include "test-qapi-introspect.h"
  27 #include "qapi/qapi-introspect.h"
  28
  29 typedef struct TestInputVisitorData {
  30     QObject *obj;
  31     Visitor *qiv;
  32 } TestInputVisitorData;
  33
  34 static void visitor_input_teardown(TestInputVisitorData *data,
  35                                    const void *unused)
  36 {
  37     qobject_unref(data->obj);
  38     data->obj = NULL;
  39
  40     if (data->qiv) {
  41         visit_free(data->qiv);
  42         data->qiv = NULL;
  43     }
  44 }
  45
  46 /* The various test_init functions are provided instead of a test setup
  47    function so that the JSON string used by the tests are kept in the test
  48    functions (and not in main()). */
  49
  50 static Visitor *test_init_internal(TestInputVisitorData *data, bool keyval,
  51                                    QObject *obj)
  52 {
  53     visitor_input_teardown(data, NULL);
  54
  55     data->obj = obj;
  56
  57     if (keyval) {
  58         data->qiv = qobject_input_visitor_new_keyval(data->obj);
  59     } else {
  60         data->qiv = qobject_input_visitor_new(data->obj);
  61     }
  62     g_assert(data->qiv);
  63     return data->qiv;
  64 }
  65
  66 static G_GNUC_PRINTF(3, 4)
  67 Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
  68                                       bool keyval,
  69                                       const char *json_string, ...)
  70 {
  71     Visitor *v;
  72     va_list ap;
  73
  74     va_start(ap, json_string);
  75     v = test_init_internal(data, keyval,
  76                            qobject_from_vjsonf_nofail(json_string, ap));
  77     va_end(ap);
  78     return v;
  79 }
  80
  81 static G_GNUC_PRINTF(2, 3)
  82 Visitor *visitor_input_test_init(TestInputVisitorData *data,
  83                                  const char *json_string, ...)
  84 {
  85     Visitor *v;
  86     va_list ap;
  87
  88     va_start(ap, json_string);
  89     v = test_init_internal(data, false,
  90                            qobject_from_vjsonf_nofail(json_string, ap));
  91     va_end(ap);
  92     return v;
  93 }
  94
  95 /* similar to visitor_input_test_init(), but does not expect a string
  96  * literal/format json_string argument and so can be used for
  97  * programmatically generated strings (and we can't pass in programmatically
  98  * generated strings via %s format parameters since qobject_from_jsonv()
  99  * will wrap those in double-quotes and treat the entire object as a
 100  * string)
 101  */
 102 static G_GNUC_PRINTF(2, 0)
 103 Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
 104                                      const char *json_string)
 105 {
 106     return test_init_internal(data, false,
 107                               qobject_from_json(json_string, &error_abort));
 108 }
 109
 110 static void test_visitor_in_int(TestInputVisitorData *data,
 111                                 const void *unused)
 112 {
 113     int64_t res = 0;
 114     double dbl;
 115     int value = -42;
 116     Visitor *v;
 117
 118     v = visitor_input_test_init(data, "%d", value);
 119
 120     visit_type_int(v, NULL, &res, &error_abort);
 121     g_assert_cmpint(res, ==, value);
 122
 123     visit_type_number(v, NULL, &dbl, &error_abort);
 124     g_assert_cmpfloat(dbl, ==, -42.0);
 125 }
 126
 127 static void test_visitor_in_uint(TestInputVisitorData *data,
 128                                 const void *unused)
 129 {
 130     uint64_t res = 0;
 131     int64_t i64;
 132     double dbl;
 133     int value = 42;
 134     Visitor *v;
 135
 136     v = visitor_input_test_init(data, "%d", value);
 137
 138     visit_type_uint64(v, NULL, &res, &error_abort);
 139     g_assert_cmpuint(res, ==, (uint64_t)value);
 140
 141     visit_type_int(v, NULL, &i64, &error_abort);
 142     g_assert_cmpint(i64, ==, value);
 143
 144     visit_type_number(v, NULL, &dbl, &error_abort);
 145     g_assert_cmpfloat(dbl, ==, value);
 146
 147     /* BUG: value between INT64_MIN and -1 accepted modulo 2^64 */
 148     v = visitor_input_test_init(data, "%d", -value);
 149
 150     visit_type_uint64(v, NULL, &res, &error_abort);
 151     g_assert_cmpuint(res, ==, (uint64_t)-value);
 152
 153     v = visitor_input_test_init(data, "18446744073709551574");
 154
 155     visit_type_uint64(v, NULL, &res, &error_abort);
 156     g_assert_cmpuint(res, ==, 18446744073709551574U);
 157
 158     visit_type_number(v, NULL, &dbl, &error_abort);
 159     g_assert_cmpfloat(dbl, ==, 18446744073709552000.0);
 160 }
 161
 162 static void test_visitor_in_int_overflow(TestInputVisitorData *data,
 163                                          const void *unused)
 164 {
 165     int64_t res = 0;
 166     Error *err = NULL;
 167     Visitor *v;
 168
 169     /*
 170      * This will overflow a QNUM_I64, so should be deserialized into a
 171      * QNUM_DOUBLE field instead, leading to an error if we pass it to
 172      * visit_type_int().  Confirm this.
 173      */
 174     v = visitor_input_test_init(data, "%f", DBL_MAX);
 175
 176     visit_type_int(v, NULL, &res, &err);
 177     error_free_or_abort(&err);
 178 }
 179
 180 static void test_visitor_in_int_keyval(TestInputVisitorData *data,
 181                                        const void *unused)
 182 {
 183     int64_t res = 0, value = -42;
 184     Error *err = NULL;
 185     Visitor *v;
 186
 187     v = visitor_input_test_init_full(data, true, "%" PRId64, value);
 188     visit_type_int(v, NULL, &res, &err);
 189     error_free_or_abort(&err);
 190 }
 191
 192 static void test_visitor_in_int_str_keyval(TestInputVisitorData *data,
 193                                            const void *unused)
 194 {
 195     int64_t res = 0, value = -42;
 196     Visitor *v;
 197
 198     v = visitor_input_test_init_full(data, true, "\"-42\"");
 199
 200     visit_type_int(v, NULL, &res, &error_abort);
 201     g_assert_cmpint(res, ==, value);
 202 }
 203
 204 static void test_visitor_in_int_str_fail(TestInputVisitorData *data,
 205                                          const void *unused)
 206 {
 207     int64_t res = 0;
 208     Visitor *v;
 209     Error *err = NULL;
 210
 211     v = visitor_input_test_init(data, "\"-42\"");
 212
 213     visit_type_int(v, NULL, &res, &err);
 214     error_free_or_abort(&err);
 215 }
 216
 217 static void test_visitor_in_bool(TestInputVisitorData *data,
 218                                  const void *unused)
 219 {
 220     bool res = false;
 221     Visitor *v;
 222
 223     v = visitor_input_test_init(data, "true");
 224
 225     visit_type_bool(v, NULL, &res, &error_abort);
 226     g_assert_cmpint(res, ==, true);
 227 }
 228
 229 static void test_visitor_in_bool_keyval(TestInputVisitorData *data,
 230                                         const void *unused)
 231 {
 232     bool res = false;
 233     Error *err = NULL;
 234     Visitor *v;
 235
 236     v = visitor_input_test_init_full(data, true, "true");
 237
 238     visit_type_bool(v, NULL, &res, &err);
 239     error_free_or_abort(&err);
 240 }
 241
 242 static void test_visitor_in_bool_str_keyval(TestInputVisitorData *data,
 243                                             const void *unused)
 244 {
 245     bool res = false;
 246     Visitor *v;
 247
 248     v = visitor_input_test_init_full(data, true, "\"on\"");
 249
 250     visit_type_bool(v, NULL, &res, &error_abort);
 251     g_assert_cmpint(res, ==, true);
 252 }
 253
 254 static void test_visitor_in_bool_str_fail(TestInputVisitorData *data,
 255                                           const void *unused)
 256 {
 257     bool res = false;
 258     Visitor *v;
 259     Error *err = NULL;
 260
 261     v = visitor_input_test_init(data, "\"true\"");
 262
 263     visit_type_bool(v, NULL, &res, &err);
 264     error_free_or_abort(&err);
 265 }
 266
 267 static void test_visitor_in_number(TestInputVisitorData *data,
 268                                    const void *unused)
 269 {
 270     double res = 0, value = 3.14;
 271     Visitor *v;
 272
 273     v = visitor_input_test_init(data, "%f", value);
 274
 275     visit_type_number(v, NULL, &res, &error_abort);
 276     g_assert_cmpfloat(res, ==, value);
 277 }
 278
 279 static void test_visitor_in_large_number(TestInputVisitorData *data,
 280                                          const void *unused)
 281 {
 282     Error *err = NULL;
 283     double res = 0;
 284     int64_t i64;
 285     uint64_t u64;
 286     Visitor *v;
 287
 288     v = visitor_input_test_init(data, "-18446744073709551616"); /* -2^64 */
 289
 290     visit_type_number(v, NULL, &res, &error_abort);
 291     g_assert_cmpfloat(res, ==, -18446744073709552e3);
 292
 293     visit_type_int(v, NULL, &i64, &err);
 294     error_free_or_abort(&err);
 295
 296     visit_type_uint64(v, NULL, &u64, &err);
 297     error_free_or_abort(&err);
 298 }
 299
 300 static void test_visitor_in_number_keyval(TestInputVisitorData *data,
 301                                           const void *unused)
 302 {
 303     double res = 0, value = 3.14;
 304     Error *err = NULL;
 305     Visitor *v;
 306
 307     v = visitor_input_test_init_full(data, true, "%f", value);
 308
 309     visit_type_number(v, NULL, &res, &err);
 310     error_free_or_abort(&err);
 311 }
 312
 313 static void test_visitor_in_number_str_keyval(TestInputVisitorData *data,
 314                                               const void *unused)
 315 {
 316     double res = 0, value = 3.14;
 317     Visitor *v;
 318     Error *err = NULL;
 319
 320     v = visitor_input_test_init_full(data, true, "\"3.14\"");
 321
 322     visit_type_number(v, NULL, &res, &error_abort);
 323     g_assert_cmpfloat(res, ==, value);
 324
 325     v = visitor_input_test_init_full(data, true, "\"inf\"");
 326
 327     visit_type_number(v, NULL, &res, &err);
 328     error_free_or_abort(&err);
 329 }
 330
 331 static void test_visitor_in_number_str_fail(TestInputVisitorData *data,
 332                                             const void *unused)
 333 {
 334     double res = 0;
 335     Visitor *v;
 336     Error *err = NULL;
 337
 338     v = visitor_input_test_init(data, "\"3.14\"");
 339
 340     visit_type_number(v, NULL, &res, &err);
 341     error_free_or_abort(&err);
 342 }
 343
 344 static void test_visitor_in_size_str_keyval(TestInputVisitorData *data,
 345                                             const void *unused)
 346 {
 347     uint64_t res, value = 500 * 1024 * 1024;
 348     Visitor *v;
 349
 350     v = visitor_input_test_init_full(data, true, "\"500M\"");
 351
 352     visit_type_size(v, NULL, &res, &error_abort);
 353     g_assert_cmpfloat(res, ==, value);
 354 }
 355
 356 static void test_visitor_in_size_str_fail(TestInputVisitorData *data,
 357                                           const void *unused)
 358 {
 359     uint64_t res = 0;
 360     Visitor *v;
 361     Error *err = NULL;
 362
 363     v = visitor_input_test_init(data, "\"500M\"");
 364
 365     visit_type_size(v, NULL, &res, &err);
 366     error_free_or_abort(&err);
 367 }
 368
 369 static void test_visitor_in_string(TestInputVisitorData *data,
 370                                    const void *unused)
 371 {
 372     char *res = NULL, *value = (char *) "Q E M U";
 373     Visitor *v;
 374
 375     v = visitor_input_test_init(data, "%s", value);
 376
 377     visit_type_str(v, NULL, &res, &error_abort);
 378     g_assert_cmpstr(res, ==, value);
 379
 380     g_free(res);
 381 }
 382
 383 static void test_visitor_in_enum(TestInputVisitorData *data,
 384                                  const void *unused)
 385 {
 386     Visitor *v;
 387     EnumOne i;
 388
 389     for (i = 0; i < ENUM_ONE__MAX; i++) {
 390         EnumOne res = -1;
 391
 392         v = visitor_input_test_init(data, "%s", EnumOne_str(i));
 393
 394         visit_type_EnumOne(v, NULL, &res, &error_abort);
 395         g_assert_cmpint(i, ==, res);
 396     }
 397 }
 398
 399
 400 static void test_visitor_in_struct(TestInputVisitorData *data,
 401                                    const void *unused)
 402 {
 403     TestStruct *p = NULL;
 404     Visitor *v;
 405
 406     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 407
 408     visit_type_TestStruct(v, NULL, &p, &error_abort);
 409     g_assert_cmpint(p->integer, ==, -42);
 410     g_assert(p->boolean == true);
 411     g_assert_cmpstr(p->string, ==, "foo");
 412
 413     g_free(p->string);
 414     g_free(p);
 415 }
 416
 417 static void test_visitor_in_struct_nested(TestInputVisitorData *data,
 418                                           const void *unused)
 419 {
 420     g_autoptr(UserDefTwo) udp = NULL;
 421     Visitor *v;
 422
 423     v = visitor_input_test_init(data, "{ 'string0': 'string0', "
 424                                 "'dict1': { 'string1': 'string1', "
 425                                 "'dict2': { 'userdef': { 'integer': 42, "
 426                                 "'string': 'string' }, 'string': 'string2'}}}");
 427
 428     visit_type_UserDefTwo(v, NULL, &udp, &error_abort);
 429
 430     g_assert_cmpstr(udp->string0, ==, "string0");
 431     g_assert_cmpstr(udp->dict1->string1, ==, "string1");
 432     g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
 433     g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
 434     g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
 435     g_assert(!udp->dict1->dict3);
 436 }
 437
 438 static void test_visitor_in_list(TestInputVisitorData *data,
 439                                  const void *unused)
 440 {
 441     UserDefOneList *item, *head = NULL;
 442     Visitor *v;
 443     int i;
 444
 445     v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
 446
 447     visit_type_UserDefOneList(v, NULL, &head, &error_abort);
 448     g_assert(head != NULL);
 449
 450     for (i = 0, item = head; item; item = item->next, i++) {
 451         g_autofree char *string = g_strdup_printf("string%d", i);
 452
 453         g_assert_cmpstr(item->value->string, ==, string);
 454         g_assert_cmpint(item->value->integer, ==, 42 + i);
 455     }
 456
 457     qapi_free_UserDefOneList(head);
 458     head = NULL;
 459
 460     /* An empty list is valid */
 461     v = visitor_input_test_init(data, "[]");
 462     visit_type_UserDefOneList(v, NULL, &head, &error_abort);
 463     g_assert(!head);
 464 }
 465
 466 static void test_visitor_in_list_struct(TestInputVisitorData *data,
 467                                         const void *unused)
 468 {
 469     const char *int_member[] = {
 470         "integer", "s8", "s16", "s32", "s64", "u8", "u16", "u32", "u64" };
 471     g_autoptr(GString) json = g_string_new("");
 472     int i, j;
 473     const char *sep;
 474     g_autoptr(ArrayStruct) arrs = NULL;
 475     Visitor *v;
 476     intList *int_list;
 477     int8List *s8_list;
 478     int16List *s16_list;
 479     int32List *s32_list;
 480     int64List *s64_list;
 481     uint8List *u8_list;
 482     uint16List *u16_list;
 483     uint32List *u32_list;
 484     uint64List *u64_list;
 485     numberList *num_list;
 486     boolList *bool_list;
 487     strList *str_list;
 488
 489     g_string_append_printf(json, "{");
 490
 491     for (i = 0; i < G_N_ELEMENTS(int_member); i++) {
 492         g_string_append_printf(json, "'%s': [", int_member[i]);
 493         sep = "";
 494         for (j = 0; j < 32; j++) {
 495             g_string_append_printf(json, "%s%d", sep, j);
 496             sep = ", ";
 497         }
 498         g_string_append_printf(json, "], ");
 499     }
 500
 501     g_string_append_printf(json, "'number': [");
 502     sep = "";
 503     for (i = 0; i < 32; i++) {
 504         g_string_append_printf(json, "%s%f", sep, (double)i / 3);
 505         sep = ", ";
 506     }
 507     g_string_append_printf(json, "], ");
 508
 509     g_string_append_printf(json, "'boolean': [");
 510     sep = "";
 511     for (i = 0; i < 32; i++) {
 512         g_string_append_printf(json, "%s%s",
 513                                sep, i % 3 == 0 ? "true" : "false");
 514         sep = ", ";
 515     }
 516     g_string_append_printf(json, "], ");
 517
 518     g_string_append_printf(json, "'string': [");
 519     sep = "";
 520     for (i = 0; i < 32; i++) {
 521         g_string_append_printf(json, "%s'%d'", sep, i);
 522         sep = ", ";
 523     }
 524     g_string_append_printf(json, "]");
 525
 526     g_string_append_printf(json, "}");
 527
 528     v = visitor_input_test_init_raw(data, json->str);
 529     visit_type_ArrayStruct(v, NULL, &arrs, &error_abort);
 530
 531     i = 0;
 532     for (int_list = arrs->integer; int_list; int_list = int_list->next) {
 533         g_assert_cmpint(int_list->value, ==, i);
 534         i++;
 535     }
 536
 537     i = 0;
 538     for (s8_list = arrs->s8; s8_list; s8_list = s8_list->next) {
 539         g_assert_cmpint(s8_list->value, ==, i);
 540         i++;
 541     }
 542
 543     i = 0;
 544     for (s16_list = arrs->s16; s16_list; s16_list = s16_list->next) {
 545         g_assert_cmpint(s16_list->value, ==, i);
 546         i++;
 547     }
 548
 549     i = 0;
 550     for (s32_list = arrs->s32; s32_list; s32_list = s32_list->next) {
 551         g_assert_cmpint(s32_list->value, ==, i);
 552         i++;
 553     }
 554
 555     i = 0;
 556     for (s64_list = arrs->s64; s64_list; s64_list = s64_list->next) {
 557         g_assert_cmpint(s64_list->value, ==, i);
 558         i++;
 559     }
 560
 561     i = 0;
 562     for (u8_list = arrs->u8; u8_list; u8_list = u8_list->next) {
 563         g_assert_cmpint(u8_list->value, ==, i);
 564         i++;
 565     }
 566
 567     i = 0;
 568     for (u16_list = arrs->u16; u16_list; u16_list = u16_list->next) {
 569         g_assert_cmpint(u16_list->value, ==, i);
 570         i++;
 571     }
 572
 573     i = 0;
 574     for (u32_list = arrs->u32; u32_list; u32_list = u32_list->next) {
 575         g_assert_cmpint(u32_list->value, ==, i);
 576         i++;
 577     }
 578
 579     i = 0;
 580     for (u64_list = arrs->u64; u64_list; u64_list = u64_list->next) {
 581         g_assert_cmpint(u64_list->value, ==, i);
 582         i++;
 583     }
 584
 585     i = 0;
 586     for (num_list = arrs->number; num_list; num_list = num_list->next) {
 587         char expected[32], actual[32];
 588
 589         sprintf(expected, "%.6f", (double)i / 3);
 590         sprintf(actual, "%.6f", num_list->value);
 591         g_assert_cmpstr(expected, ==, actual);
 592         i++;
 593     }
 594
 595     i = 0;
 596     for (bool_list = arrs->boolean; bool_list; bool_list = bool_list->next) {
 597         g_assert_cmpint(bool_list->value, ==, i % 3 == 0);
 598         i++;
 599     }
 600
 601     i = 0;
 602     for (str_list = arrs->string; str_list; str_list = str_list->next) {
 603         char expected[32];
 604
 605         sprintf(expected, "%d", i);
 606         g_assert_cmpstr(str_list->value, ==, expected);
 607         i++;
 608     }
 609 }
 610
 611 static void test_visitor_in_any(TestInputVisitorData *data,
 612                                 const void *unused)
 613 {
 614     QObject *res = NULL;
 615     Visitor *v;
 616     QNum *qnum;
 617     QBool *qbool;
 618     QString *qstring;
 619     QDict *qdict;
 620     QObject *qobj;
 621     int64_t val;
 622
 623     v = visitor_input_test_init(data, "-42");
 624     visit_type_any(v, NULL, &res, &error_abort);
 625     qnum = qobject_to(QNum, res);
 626     g_assert(qnum);
 627     g_assert(qnum_get_try_int(qnum, &val));
 628     g_assert_cmpint(val, ==, -42);
 629     qobject_unref(res);
 630
 631     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 632     visit_type_any(v, NULL, &res, &error_abort);
 633     qdict = qobject_to(QDict, res);
 634     g_assert(qdict && qdict_size(qdict) == 3);
 635     qobj = qdict_get(qdict, "integer");
 636     g_assert(qobj);
 637     qnum = qobject_to(QNum, qobj);
 638     g_assert(qnum);
 639     g_assert(qnum_get_try_int(qnum, &val));
 640     g_assert_cmpint(val, ==, -42);
 641     qobj = qdict_get(qdict, "boolean");
 642     g_assert(qobj);
 643     qbool = qobject_to(QBool, qobj);
 644     g_assert(qbool);
 645     g_assert(qbool_get_bool(qbool) == true);
 646     qobj = qdict_get(qdict, "string");
 647     g_assert(qobj);
 648     qstring = qobject_to(QString, qobj);
 649     g_assert(qstring);
 650     g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
 651     qobject_unref(res);
 652 }
 653
 654 static void test_visitor_in_null(TestInputVisitorData *data,
 655                                  const void *unused)
 656 {
 657     Visitor *v;
 658     Error *err = NULL;
 659     QNull *null;
 660     char *tmp;
 661
 662     /*
 663      * FIXME: Since QAPI doesn't know the 'null' type yet, we can't
 664      * test visit_type_null() by reading into a QAPI struct then
 665      * checking that it was populated correctly.  The best we can do
 666      * for now is ensure that we consumed null from the input, proven
 667      * by the fact that we can't re-read the key; and that we detect
 668      * when input is not null.
 669      */
 670
 671     v = visitor_input_test_init_full(data, false,
 672                                      "{ 'a': null, 'b': '' }");
 673     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 674     visit_type_null(v, "a", &null, &error_abort);
 675     g_assert(qobject_type(QOBJECT(null)) == QTYPE_QNULL);
 676     qobject_unref(null);
 677     visit_type_null(v, "b", &null, &err);
 678     error_free_or_abort(&err);
 679     g_assert(!null);
 680     visit_type_str(v, "c", &tmp, &err);
 681     error_free_or_abort(&err);
 682     g_assert(!tmp);
 683     visit_check_struct(v, &error_abort);
 684     visit_end_struct(v, NULL);
 685 }
 686
 687 static void test_visitor_in_union_flat(TestInputVisitorData *data,
 688                                        const void *unused)
 689 {
 690     Visitor *v;
 691     g_autoptr(UserDefFlatUnion) tmp = NULL;
 692     UserDefUnionBase *base;
 693
 694     v = visitor_input_test_init(data,
 695                                 "{ 'enum1': 'value1', "
 696                                 "'integer': 41, "
 697                                 "'string': 'str', "
 698                                 "'boolean': true }");
 699
 700     visit_type_UserDefFlatUnion(v, NULL, &tmp, &error_abort);
 701     g_assert_cmpint(tmp->enum1, ==, ENUM_ONE_VALUE1);
 702     g_assert_cmpstr(tmp->string, ==, "str");
 703     g_assert_cmpint(tmp->integer, ==, 41);
 704     g_assert_cmpint(tmp->u.value1.boolean, ==, true);
 705
 706     base = qapi_UserDefFlatUnion_base(tmp);
 707     g_assert(&base->enum1 == &tmp->enum1);
 708 }
 709
 710 static void test_visitor_in_union_in_union(TestInputVisitorData *data,
 711                                            const void *unused)
 712 {
 713     Visitor *v;
 714     g_autoptr(TestUnionInUnion) tmp = NULL;
 715
 716     v = visitor_input_test_init(data,
 717                                 "{ 'type': 'value-a', "
 718                                 "  'type-a': 'value-a1', "
 719                                 "  'integer': 2, "
 720                                 "  'name': 'fish' }");
 721
 722     visit_type_TestUnionInUnion(v, NULL, &tmp, &error_abort);
 723     g_assert_cmpint(tmp->type, ==, TEST_UNION_ENUM_VALUE_A);
 724     g_assert_cmpint(tmp->u.value_a.type_a, ==, TEST_UNION_ENUMA_VALUE_A1);
 725     g_assert_cmpint(tmp->u.value_a.u.value_a1.integer, ==, 2);
 726     g_assert_cmpint(strcmp(tmp->u.value_a.u.value_a1.name, "fish"), ==, 0);
 727
 728     qapi_free_TestUnionInUnion(tmp);
 729
 730     v = visitor_input_test_init(data,
 731                                 "{ 'type': 'value-a', "
 732                                 "  'type-a': 'value-a2', "
 733                                 "  'integer': 1729, "
 734                                 "  'size': 87539319 }");
 735
 736     visit_type_TestUnionInUnion(v, NULL, &tmp, &error_abort);
 737     g_assert_cmpint(tmp->type, ==, TEST_UNION_ENUM_VALUE_A);
 738     g_assert_cmpint(tmp->u.value_a.type_a, ==, TEST_UNION_ENUMA_VALUE_A2);
 739     g_assert_cmpint(tmp->u.value_a.u.value_a2.integer, ==, 1729);
 740     g_assert_cmpint(tmp->u.value_a.u.value_a2.size, ==, 87539319);
 741
 742     qapi_free_TestUnionInUnion(tmp);
 743
 744     v = visitor_input_test_init(data,
 745                                 "{ 'type': 'value-b', "
 746                                 "  'integer': 1729, "
 747                                 "  'onoff': true }");
 748
 749     visit_type_TestUnionInUnion(v, NULL, &tmp, &error_abort);
 750     g_assert_cmpint(tmp->type, ==, TEST_UNION_ENUM_VALUE_B);
 751     g_assert_cmpint(tmp->u.value_b.integer, ==, 1729);
 752     g_assert_cmpint(tmp->u.value_b.onoff, ==, true);
 753 }
 754
 755 static void test_visitor_in_alternate(TestInputVisitorData *data,
 756                                       const void *unused)
 757 {
 758     Visitor *v;
 759     UserDefAlternate *tmp;
 760     WrapAlternate *wrap;
 761
 762     v = visitor_input_test_init(data, "42");
 763     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 764     g_assert_cmpint(tmp->type, ==, QTYPE_QNUM);
 765     g_assert_cmpint(tmp->u.i, ==, 42);
 766     qapi_free_UserDefAlternate(tmp);
 767
 768     v = visitor_input_test_init(data, "'value1'");
 769     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 770     g_assert_cmpint(tmp->type, ==, QTYPE_QSTRING);
 771     g_assert_cmpint(tmp->u.e, ==, ENUM_ONE_VALUE1);
 772     qapi_free_UserDefAlternate(tmp);
 773
 774     v = visitor_input_test_init(data, "null");
 775     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 776     g_assert_cmpint(tmp->type, ==, QTYPE_QNULL);
 777     qapi_free_UserDefAlternate(tmp);
 778
 779     v = visitor_input_test_init(data, "{'integer':1, 'string':'str', "
 780                                 "'enum1':'value1', 'boolean':true}");
 781     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 782     g_assert_cmpint(tmp->type, ==, QTYPE_QDICT);
 783     g_assert_cmpint(tmp->u.udfu.integer, ==, 1);
 784     g_assert_cmpstr(tmp->u.udfu.string, ==, "str");
 785     g_assert_cmpint(tmp->u.udfu.enum1, ==, ENUM_ONE_VALUE1);
 786     g_assert_cmpint(tmp->u.udfu.u.value1.boolean, ==, true);
 787     g_assert_cmpint(tmp->u.udfu.u.value1.has_a_b, ==, false);
 788     qapi_free_UserDefAlternate(tmp);
 789
 790     v = visitor_input_test_init(data, "{ 'alt': 42 }");
 791     visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
 792     g_assert_cmpint(wrap->alt->type, ==, QTYPE_QNUM);
 793     g_assert_cmpint(wrap->alt->u.i, ==, 42);
 794     qapi_free_WrapAlternate(wrap);
 795
 796     v = visitor_input_test_init(data, "{ 'alt': 'value1' }");
 797     visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
 798     g_assert_cmpint(wrap->alt->type, ==, QTYPE_QSTRING);
 799     g_assert_cmpint(wrap->alt->u.e, ==, ENUM_ONE_VALUE1);
 800     qapi_free_WrapAlternate(wrap);
 801
 802     v = visitor_input_test_init(data, "{ 'alt': {'integer':1, 'string':'str', "
 803                                 "'enum1':'value1', 'boolean':true} }");
 804     visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
 805     g_assert_cmpint(wrap->alt->type, ==, QTYPE_QDICT);
 806     g_assert_cmpint(wrap->alt->u.udfu.integer, ==, 1);
 807     g_assert_cmpstr(wrap->alt->u.udfu.string, ==, "str");
 808     g_assert_cmpint(wrap->alt->u.udfu.enum1, ==, ENUM_ONE_VALUE1);
 809     g_assert_cmpint(wrap->alt->u.udfu.u.value1.boolean, ==, true);
 810     g_assert_cmpint(wrap->alt->u.udfu.u.value1.has_a_b, ==, false);
 811     qapi_free_WrapAlternate(wrap);
 812 }
 813
 814 static void test_visitor_in_alternate_number(TestInputVisitorData *data,
 815                                              const void *unused)
 816 {
 817     Visitor *v;
 818     Error *err = NULL;
 819     AltEnumBool *aeb;
 820     AltEnumNum *aen;
 821     AltNumEnum *ans;
 822     AltEnumInt *asi;
 823     AltListInt *ali;
 824
 825     /* Parsing an int */
 826
 827     v = visitor_input_test_init(data, "42");
 828     visit_type_AltEnumBool(v, NULL, &aeb, &err);
 829     error_free_or_abort(&err);
 830     qapi_free_AltEnumBool(aeb);
 831
 832     v = visitor_input_test_init(data, "42");
 833     visit_type_AltEnumNum(v, NULL, &aen, &error_abort);
 834     g_assert_cmpint(aen->type, ==, QTYPE_QNUM);
 835     g_assert_cmpfloat(aen->u.n, ==, 42);
 836     qapi_free_AltEnumNum(aen);
 837
 838     v = visitor_input_test_init(data, "42");
 839     visit_type_AltNumEnum(v, NULL, &ans, &error_abort);
 840     g_assert_cmpint(ans->type, ==, QTYPE_QNUM);
 841     g_assert_cmpfloat(ans->u.n, ==, 42);
 842     qapi_free_AltNumEnum(ans);
 843
 844     v = visitor_input_test_init(data, "42");
 845     visit_type_AltEnumInt(v, NULL, &asi, &error_abort);
 846     g_assert_cmpint(asi->type, ==, QTYPE_QNUM);
 847     g_assert_cmpint(asi->u.i, ==, 42);
 848     qapi_free_AltEnumInt(asi);
 849
 850     v = visitor_input_test_init(data, "42");
 851     visit_type_AltListInt(v, NULL, &ali, &error_abort);
 852     g_assert_cmpint(ali->type, ==, QTYPE_QNUM);
 853     g_assert_cmpint(ali->u.i, ==, 42);
 854     qapi_free_AltListInt(ali);
 855
 856     /* Parsing a double */
 857
 858     v = visitor_input_test_init(data, "42.5");
 859     visit_type_AltEnumBool(v, NULL, &aeb, &err);
 860     error_free_or_abort(&err);
 861     qapi_free_AltEnumBool(aeb);
 862
 863     v = visitor_input_test_init(data, "42.5");
 864     visit_type_AltEnumNum(v, NULL, &aen, &error_abort);
 865     g_assert_cmpint(aen->type, ==, QTYPE_QNUM);
 866     g_assert_cmpfloat(aen->u.n, ==, 42.5);
 867     qapi_free_AltEnumNum(aen);
 868
 869     v = visitor_input_test_init(data, "42.5");
 870     visit_type_AltNumEnum(v, NULL, &ans, &error_abort);
 871     g_assert_cmpint(ans->type, ==, QTYPE_QNUM);
 872     g_assert_cmpfloat(ans->u.n, ==, 42.5);
 873     qapi_free_AltNumEnum(ans);
 874
 875     v = visitor_input_test_init(data, "42.5");
 876     visit_type_AltEnumInt(v, NULL, &asi, &err);
 877     error_free_or_abort(&err);
 878     qapi_free_AltEnumInt(asi);
 879 }
 880
 881 static void test_visitor_in_alternate_list(TestInputVisitorData *data,
 882                                  const void *unused)
 883 {
 884     intList *item;
 885     Visitor *v;
 886     AltListInt *ali;
 887     int i;
 888
 889     v = visitor_input_test_init(data, "[ 42, 43, 44 ]");
 890     visit_type_AltListInt(v, NULL, &ali, &error_abort);
 891     g_assert(ali != NULL);
 892
 893     g_assert_cmpint(ali->type, ==, QTYPE_QLIST);
 894     for (i = 0, item = ali->u.l; item; item = item->next, i++) {
 895         g_assert_cmpint(item->value, ==, 42 + i);
 896     }
 897
 898     qapi_free_AltListInt(ali);
 899     ali = NULL;
 900
 901     /* An empty list is valid */
 902     v = visitor_input_test_init(data, "[]");
 903     visit_type_AltListInt(v, NULL, &ali, &error_abort);
 904     g_assert(ali != NULL);
 905
 906     g_assert_cmpint(ali->type, ==, QTYPE_QLIST);
 907     g_assert(!ali->u.l);
 908     qapi_free_AltListInt(ali);
 909     ali = NULL;
 910 }
 911
 912 static void input_visitor_test_add(const char *testpath,
 913                                    const void *user_data,
 914                                    void (*test_func)(TestInputVisitorData *data,
 915                                                      const void *user_data))
 916 {
 917     g_test_add(testpath, TestInputVisitorData, user_data, NULL, test_func,
 918                visitor_input_teardown);
 919 }
 920
 921 static void test_visitor_in_errors(TestInputVisitorData *data,
 922                                    const void *unused)
 923 {
 924     TestStruct *p = NULL;
 925     Error *err = NULL;
 926     Visitor *v;
 927     strList *q = NULL;
 928     UserDefTwo *r = NULL;
 929     WrapAlternate *s = NULL;
 930
 931     v = visitor_input_test_init(data, "{ 'integer': false, 'boolean': 'foo', "
 932                                 "'string': -42 }");
 933
 934     visit_type_TestStruct(v, NULL, &p, &err);
 935     error_free_or_abort(&err);
 936     g_assert(!p);
 937
 938     v = visitor_input_test_init(data, "[ '1', '2', false, '3' ]");
 939     visit_type_strList(v, NULL, &q, &err);
 940     error_free_or_abort(&err);
 941     assert(!q);
 942
 943     v = visitor_input_test_init(data, "{ 'str':'hi' }");
 944     visit_type_UserDefTwo(v, NULL, &r, &err);
 945     error_free_or_abort(&err);
 946     assert(!r);
 947
 948     v = visitor_input_test_init(data, "{ }");
 949     visit_type_WrapAlternate(v, NULL, &s, &err);
 950     error_free_or_abort(&err);
 951     assert(!s);
 952 }
 953
 954 static void test_visitor_in_wrong_type(TestInputVisitorData *data,
 955                                        const void *unused)
 956 {
 957     TestStruct *p = NULL;
 958     Visitor *v;
 959     strList *q = NULL;
 960     int64_t i;
 961     Error *err = NULL;
 962
 963     /* Make sure arrays and structs cannot be confused */
 964
 965     v = visitor_input_test_init(data, "[]");
 966     visit_type_TestStruct(v, NULL, &p, &err);
 967     error_free_or_abort(&err);
 968     g_assert(!p);
 969
 970     v = visitor_input_test_init(data, "{}");
 971     visit_type_strList(v, NULL, &q, &err);
 972     error_free_or_abort(&err);
 973     assert(!q);
 974
 975     /* Make sure primitives and struct cannot be confused */
 976
 977     v = visitor_input_test_init(data, "1");
 978     visit_type_TestStruct(v, NULL, &p, &err);
 979     error_free_or_abort(&err);
 980     g_assert(!p);
 981
 982     v = visitor_input_test_init(data, "{}");
 983     visit_type_int(v, NULL, &i, &err);
 984     error_free_or_abort(&err);
 985
 986     /* Make sure primitives and arrays cannot be confused */
 987
 988     v = visitor_input_test_init(data, "1");
 989     visit_type_strList(v, NULL, &q, &err);
 990     error_free_or_abort(&err);
 991     assert(!q);
 992
 993     v = visitor_input_test_init(data, "[]");
 994     visit_type_int(v, NULL, &i, &err);
 995     error_free_or_abort(&err);
 996 }
 997
 998 static void test_visitor_in_fail_struct(TestInputVisitorData *data,
 999                                         const void *unused)
1000 {
1001     TestStruct *p = NULL;
1002     Error *err = NULL;
1003     Visitor *v;
1004
1005     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo', 'extra': 42 }");
1006
1007     visit_type_TestStruct(v, NULL, &p, &err);
1008     error_free_or_abort(&err);
1009     g_assert(!p);
1010 }
1011
1012 static void test_visitor_in_fail_struct_nested(TestInputVisitorData *data,
1013                                                const void *unused)
1014 {
1015     UserDefTwo *udp = NULL;
1016     Error *err = NULL;
1017     Visitor *v;
1018
1019     v = visitor_input_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string', 'extra': [42, 23, {'foo':'bar'}] }, 'string2': 'string2'}}}");
1020
1021     visit_type_UserDefTwo(v, NULL, &udp, &err);
1022     error_free_or_abort(&err);
1023     g_assert(!udp);
1024 }
1025
1026 static void test_visitor_in_fail_struct_in_list(TestInputVisitorData *data,
1027                                                 const void *unused)
1028 {
1029     UserDefOneList *head = NULL;
1030     Error *err = NULL;
1031     Visitor *v;
1032
1033     v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44, 'extra': 'ggg' } ]");
1034
1035     visit_type_UserDefOneList(v, NULL, &head, &err);
1036     error_free_or_abort(&err);
1037     g_assert(!head);
1038 }
1039
1040 static void test_visitor_in_fail_struct_missing(TestInputVisitorData *data,
1041                                                 const void *unused)
1042 {
1043     Error *err = NULL;
1044     Visitor *v;
1045     QObject *any;
1046     QNull *null;
1047     GenericAlternate *alt;
1048     bool present;
1049     int en;
1050     int64_t i64;
1051     uint32_t u32;
1052     int8_t i8;
1053     char *str;
1054     double dbl;
1055
1056     v = visitor_input_test_init(data, "{ 'sub': [ {} ] }");
1057     visit_start_struct(v, NULL, NULL, 0, &error_abort);
1058     visit_start_struct(v, "struct", NULL, 0, &err);
1059     error_free_or_abort(&err);
1060     visit_start_list(v, "list", NULL, 0, &err);
1061     error_free_or_abort(&err);
1062     visit_start_alternate(v, "alternate", &alt, sizeof(*alt), &err);
1063     error_free_or_abort(&err);
1064     visit_optional(v, "optional", &present);
1065     g_assert(!present);
1066     visit_type_enum(v, "enum", &en, &EnumOne_lookup, &err);
1067     error_free_or_abort(&err);
1068     visit_type_int(v, "i64", &i64, &err);
1069     error_free_or_abort(&err);
1070     visit_type_uint32(v, "u32", &u32, &err);
1071     error_free_or_abort(&err);
1072     visit_type_int8(v, "i8", &i8, &err);
1073     error_free_or_abort(&err);
1074     visit_type_str(v, "i8", &str, &err);
1075     error_free_or_abort(&err);
1076     visit_type_number(v, "dbl", &dbl, &err);
1077     error_free_or_abort(&err);
1078     visit_type_any(v, "any", &any, &err);
1079     error_free_or_abort(&err);
1080     visit_type_null(v, "null", &null, &err);
1081     error_free_or_abort(&err);
1082     visit_start_list(v, "sub", NULL, 0, &error_abort);
1083     visit_start_struct(v, NULL, NULL, 0, &error_abort);
1084     visit_type_int(v, "i64", &i64, &err);
1085     error_free_or_abort(&err);
1086     visit_end_struct(v, NULL);
1087     visit_end_list(v, NULL);
1088     visit_end_struct(v, NULL);
1089 }
1090
1091 static void test_visitor_in_fail_list(TestInputVisitorData *data,
1092                                       const void *unused)
1093 {
1094     int64_t i64 = -1;
1095     Error *err = NULL;
1096     Visitor *v;
1097
1098     /* Unvisited list tail */
1099
1100     v = visitor_input_test_init(data, "[ 1, 2, 3 ]");
1101
1102     visit_start_list(v, NULL, NULL, 0, &error_abort);
1103     visit_type_int(v, NULL, &i64, &error_abort);
1104     g_assert_cmpint(i64, ==, 1);
1105     visit_type_int(v, NULL, &i64, &error_abort);
1106     g_assert_cmpint(i64, ==, 2);
1107     visit_check_list(v, &err);
1108     error_free_or_abort(&err);
1109     visit_end_list(v, NULL);
1110
1111     /* Visit beyond end of list */
1112     v = visitor_input_test_init(data, "[]");
1113
1114     visit_start_list(v, NULL, NULL, 0, &error_abort);
1115     visit_type_int(v, NULL, &i64, &err);
1116     error_free_or_abort(&err);
1117     visit_end_list(v, NULL);
1118 }
1119
1120 static void test_visitor_in_fail_list_nested(TestInputVisitorData *data,
1121                                              const void *unused)
1122 {
1123     int64_t i64 = -1;
1124     Error *err = NULL;
1125     Visitor *v;
1126
1127     /* Unvisited nested list tail */
1128
1129     v = visitor_input_test_init(data, "[ 0, [ 1, 2, 3 ] ]");
1130
1131     visit_start_list(v, NULL, NULL, 0, &error_abort);
1132     visit_type_int(v, NULL, &i64, &error_abort);
1133     g_assert_cmpint(i64, ==, 0);
1134     visit_start_list(v, NULL, NULL, 0, &error_abort);
1135     visit_type_int(v, NULL, &i64, &error_abort);
1136     g_assert_cmpint(i64, ==, 1);
1137     visit_check_list(v, &err);
1138     error_free_or_abort(&err);
1139     visit_end_list(v, NULL);
1140     visit_check_list(v, &error_abort);
1141     visit_end_list(v, NULL);
1142 }
1143
1144 static void test_visitor_in_fail_union_flat(TestInputVisitorData *data,
1145                                             const void *unused)
1146 {
1147     UserDefFlatUnion *tmp = NULL;
1148     Error *err = NULL;
1149     Visitor *v;
1150
1151     v = visitor_input_test_init(data, "{ 'enum1': 'value2', 'string': 'c', 'integer': 41, 'boolean': true }");
1152
1153     visit_type_UserDefFlatUnion(v, NULL, &tmp, &err);
1154     error_free_or_abort(&err);
1155     g_assert(!tmp);
1156 }
1157
1158 static void test_visitor_in_fail_union_flat_no_discrim(TestInputVisitorData *data,
1159                                                        const void *unused)
1160 {
1161     UserDefFlatUnion2 *tmp = NULL;
1162     Error *err = NULL;
1163     Visitor *v;
1164
1165     /* test situation where discriminator field ('enum1' here) is missing */
1166     v = visitor_input_test_init(data, "{ 'integer': 42, 'string': 'c', 'string1': 'd', 'string2': 'e' }");
1167
1168     visit_type_UserDefFlatUnion2(v, NULL, &tmp, &err);
1169     error_free_or_abort(&err);
1170     g_assert(!tmp);
1171 }
1172
1173 static void test_visitor_in_fail_alternate(TestInputVisitorData *data,
1174                                            const void *unused)
1175 {
1176     UserDefAlternate *tmp;
1177     Visitor *v;
1178     Error *err = NULL;
1179
1180     v = visitor_input_test_init(data, "3.14");
1181
1182     visit_type_UserDefAlternate(v, NULL, &tmp, &err);
1183     error_free_or_abort(&err);
1184     g_assert(!tmp);
1185 }
1186
1187 static void do_test_visitor_in_qmp_introspect(TestInputVisitorData *data,
1188                                               const QLitObject *qlit)
1189 {
1190     g_autoptr(SchemaInfoList) schema = NULL;
1191     QObject *obj = qobject_from_qlit(qlit);
1192     Visitor *v;
1193
1194     v = qobject_input_visitor_new(obj);
1195
1196     visit_type_SchemaInfoList(v, NULL, &schema, &error_abort);
1197     g_assert(schema);
1198
1199     qobject_unref(obj);
1200     visit_free(v);
1201 }
1202
1203 static void test_visitor_in_qmp_introspect(TestInputVisitorData *data,
1204                                            const void *unused)
1205 {
1206     do_test_visitor_in_qmp_introspect(data, &test_qmp_schema_qlit);
1207 }
1208
1209 int main(int argc, char **argv)
1210 {
1211     g_test_init(&argc, &argv, NULL);
1212
1213     input_visitor_test_add("/visitor/input/int",
1214                            NULL, test_visitor_in_int);
1215     input_visitor_test_add("/visitor/input/uint",
1216                            NULL, test_visitor_in_uint);
1217     input_visitor_test_add("/visitor/input/int_overflow",
1218                            NULL, test_visitor_in_int_overflow);
1219     input_visitor_test_add("/visitor/input/int_keyval",
1220                            NULL, test_visitor_in_int_keyval);
1221     input_visitor_test_add("/visitor/input/int_str_keyval",
1222                            NULL, test_visitor_in_int_str_keyval);
1223     input_visitor_test_add("/visitor/input/int_str_fail",
1224                            NULL, test_visitor_in_int_str_fail);
1225     input_visitor_test_add("/visitor/input/bool",
1226                            NULL, test_visitor_in_bool);
1227     input_visitor_test_add("/visitor/input/bool_keyval",
1228                            NULL, test_visitor_in_bool_keyval);
1229     input_visitor_test_add("/visitor/input/bool_str_keyval",
1230                            NULL, test_visitor_in_bool_str_keyval);
1231     input_visitor_test_add("/visitor/input/bool_str_fail",
1232                            NULL, test_visitor_in_bool_str_fail);
1233     input_visitor_test_add("/visitor/input/number",
1234                            NULL, test_visitor_in_number);
1235     input_visitor_test_add("/visitor/input/large_number",
1236                            NULL, test_visitor_in_large_number);
1237     input_visitor_test_add("/visitor/input/number_keyval",
1238                            NULL, test_visitor_in_number_keyval);
1239     input_visitor_test_add("/visitor/input/number_str_keyval",
1240                            NULL, test_visitor_in_number_str_keyval);
1241     input_visitor_test_add("/visitor/input/number_str_fail",
1242                            NULL, test_visitor_in_number_str_fail);
1243     input_visitor_test_add("/visitor/input/size_str_keyval",
1244                            NULL, test_visitor_in_size_str_keyval);
1245     input_visitor_test_add("/visitor/input/size_str_fail",
1246                            NULL, test_visitor_in_size_str_fail);
1247     input_visitor_test_add("/visitor/input/string",
1248                            NULL, test_visitor_in_string);
1249     input_visitor_test_add("/visitor/input/enum",
1250                            NULL, test_visitor_in_enum);
1251     input_visitor_test_add("/visitor/input/struct",
1252                            NULL, test_visitor_in_struct);
1253     input_visitor_test_add("/visitor/input/struct-nested",
1254                            NULL, test_visitor_in_struct_nested);
1255     input_visitor_test_add("/visitor/input/list2",
1256                            NULL, test_visitor_in_list_struct);
1257     input_visitor_test_add("/visitor/input/list",
1258                            NULL, test_visitor_in_list);
1259     input_visitor_test_add("/visitor/input/any",
1260                            NULL, test_visitor_in_any);
1261     input_visitor_test_add("/visitor/input/null",
1262                            NULL, test_visitor_in_null);
1263     input_visitor_test_add("/visitor/input/union-flat",
1264                            NULL, test_visitor_in_union_flat);
1265     input_visitor_test_add("/visitor/input/union-in-union",
1266                            NULL, test_visitor_in_union_in_union);
1267     input_visitor_test_add("/visitor/input/alternate",
1268                            NULL, test_visitor_in_alternate);
1269     input_visitor_test_add("/visitor/input/errors",
1270                            NULL, test_visitor_in_errors);
1271     input_visitor_test_add("/visitor/input/wrong-type",
1272                            NULL, test_visitor_in_wrong_type);
1273     input_visitor_test_add("/visitor/input/alternate-number",
1274                            NULL, test_visitor_in_alternate_number);
1275     input_visitor_test_add("/visitor/input/alternate-list",
1276                            NULL, test_visitor_in_alternate_list);
1277     input_visitor_test_add("/visitor/input/fail/struct",
1278                            NULL, test_visitor_in_fail_struct);
1279     input_visitor_test_add("/visitor/input/fail/struct-nested",
1280                            NULL, test_visitor_in_fail_struct_nested);
1281     input_visitor_test_add("/visitor/input/fail/struct-in-list",
1282                            NULL, test_visitor_in_fail_struct_in_list);
1283     input_visitor_test_add("/visitor/input/fail/struct-missing",
1284                            NULL, test_visitor_in_fail_struct_missing);
1285     input_visitor_test_add("/visitor/input/fail/list",
1286                            NULL, test_visitor_in_fail_list);
1287     input_visitor_test_add("/visitor/input/fail/list-nested",
1288                            NULL, test_visitor_in_fail_list_nested);
1289     input_visitor_test_add("/visitor/input/fail/union-flat",
1290                            NULL, test_visitor_in_fail_union_flat);
1291     input_visitor_test_add("/visitor/input/fail/union-flat-no-discriminator",
1292                            NULL, test_visitor_in_fail_union_flat_no_discrim);
1293     input_visitor_test_add("/visitor/input/fail/alternate",
1294                            NULL, test_visitor_in_fail_alternate);
1295     input_visitor_test_add("/visitor/input/qapi-introspect",
1296                            NULL, test_visitor_in_qmp_introspect);
1297
1298     g_test_run();
1299
1300     return 0;
1301 }