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