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