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/qapi-visit-introspect.h"
  19 #include "qapi/qobject-input-visitor.h"
  20 #include "test-qapi-visit.h"
  21 #include "qapi/qmp/qbool.h"
  22 #include "qapi/qmp/qdict.h"
  23 #include "qapi/qmp/qnull.h"
  24 #include "qapi/qmp/qnum.h"
  25 #include "qapi/qmp/qstring.h"
  26 #include "qapi/qmp/qjson.h"
  27 #include "test-qapi-introspect.h"
  28 #include "qapi/qapi-introspect.h"
  29
  30 typedef struct TestInputVisitorData {
  31     QObject *obj;
  32     Visitor *qiv;
  33 } TestInputVisitorData;
  34
  35 static void visitor_input_teardown(TestInputVisitorData *data,
  36                                    const void *unused)
  37 {
  38     qobject_unref(data->obj);
  39     data->obj = NULL;
  40
  41     if (data->qiv) {
  42         visit_free(data->qiv);
  43         data->qiv = NULL;
  44     }
  45 }
  46
  47 /* The various test_init functions are provided instead of a test setup
  48    function so that the JSON string used by the tests are kept in the test
  49    functions (and not in main()). */
  50
  51 static Visitor *test_init_internal(TestInputVisitorData *data, bool keyval,
  52                                    QObject *obj)
  53 {
  54     visitor_input_teardown(data, NULL);
  55
  56     data->obj = obj;
  57
  58     if (keyval) {
  59         data->qiv = qobject_input_visitor_new_keyval(data->obj);
  60     } else {
  61         data->qiv = qobject_input_visitor_new(data->obj);
  62     }
  63     g_assert(data->qiv);
  64     return data->qiv;
  65 }
  66
  67 static GCC_FMT_ATTR(3, 4)
  68 Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
  69                                       bool keyval,
  70                                       const char *json_string, ...)
  71 {
  72     Visitor *v;
  73     va_list ap;
  74
  75     va_start(ap, json_string);
  76     v = test_init_internal(data, keyval,
  77                            qobject_from_vjsonf_nofail(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 = test_init_internal(data, false,
  91                            qobject_from_vjsonf_nofail(json_string, ap));
  92     va_end(ap);
  93     return v;
  94 }
  95
  96 /* similar to visitor_input_test_init(), but does not expect a string
  97  * literal/format json_string argument and so can be used for
  98  * programatically generated strings (and we can't pass in programatically
  99  * generated strings via %s format parameters since qobject_from_jsonv()
 100  * will wrap those in double-quotes and treat the entire object as a
 101  * string)
 102  */
 103 static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
 104                                             const char *json_string)
 105 {
 106     return test_init_internal(data, false,
 107                               qobject_from_json(json_string, &error_abort));
 108 }
 109
 110 static void test_visitor_in_int(TestInputVisitorData *data,
 111                                 const void *unused)
 112 {
 113     int64_t res = 0;
 114     double dbl;
 115     int value = -42;
 116     Visitor *v;
 117
 118     v = visitor_input_test_init(data, "%d", value);
 119
 120     visit_type_int(v, NULL, &res, &error_abort);
 121     g_assert_cmpint(res, ==, value);
 122
 123     visit_type_number(v, NULL, &dbl, &error_abort);
 124     g_assert_cmpfloat(dbl, ==, -42.0);
 125 }
 126
 127 static void test_visitor_in_uint(TestInputVisitorData *data,
 128                                 const void *unused)
 129 {
 130     uint64_t res = 0;
 131     int64_t i64;
 132     double dbl;
 133     int value = 42;
 134     Visitor *v;
 135
 136     v = visitor_input_test_init(data, "%d", value);
 137
 138     visit_type_uint64(v, NULL, &res, &error_abort);
 139     g_assert_cmpuint(res, ==, (uint64_t)value);
 140
 141     visit_type_int(v, NULL, &i64, &error_abort);
 142     g_assert_cmpint(i64, ==, value);
 143
 144     visit_type_number(v, NULL, &dbl, &error_abort);
 145     g_assert_cmpfloat(dbl, ==, value);
 146
 147     /* BUG: value between INT64_MIN and -1 accepted modulo 2^64 */
 148     v = visitor_input_test_init(data, "%d", -value);
 149
 150     visit_type_uint64(v, NULL, &res, &error_abort);
 151     g_assert_cmpuint(res, ==, (uint64_t)-value);
 152
 153     v = visitor_input_test_init(data, "18446744073709551574");
 154
 155     visit_type_uint64(v, NULL, &res, &error_abort);
 156     g_assert_cmpuint(res, ==, 18446744073709551574U);
 157
 158     visit_type_number(v, NULL, &dbl, &error_abort);
 159     g_assert_cmpfloat(dbl, ==, 18446744073709552000.0);
 160 }
 161
 162 static void test_visitor_in_int_overflow(TestInputVisitorData *data,
 163                                          const void *unused)
 164 {
 165     int64_t res = 0;
 166     Error *err = NULL;
 167     Visitor *v;
 168
 169     /*
 170      * This will overflow a QNUM_I64, so should be deserialized into a
 171      * QNUM_DOUBLE field instead, leading to an error if we pass it to
 172      * visit_type_int().  Confirm this.
 173      */
 174     v = visitor_input_test_init(data, "%f", DBL_MAX);
 175
 176     visit_type_int(v, NULL, &res, &err);
 177     error_free_or_abort(&err);
 178 }
 179
 180 static void test_visitor_in_int_keyval(TestInputVisitorData *data,
 181                                        const void *unused)
 182 {
 183     int64_t res = 0, value = -42;
 184     Error *err = NULL;
 185     Visitor *v;
 186
 187     v = visitor_input_test_init_full(data, true, "%" PRId64, value);
 188     visit_type_int(v, NULL, &res, &err);
 189     error_free_or_abort(&err);
 190 }
 191
 192 static void test_visitor_in_int_str_keyval(TestInputVisitorData *data,
 193                                            const void *unused)
 194 {
 195     int64_t res = 0, value = -42;
 196     Visitor *v;
 197
 198     v = visitor_input_test_init_full(data, true, "\"-42\"");
 199
 200     visit_type_int(v, NULL, &res, &error_abort);
 201     g_assert_cmpint(res, ==, value);
 202 }
 203
 204 static void test_visitor_in_int_str_fail(TestInputVisitorData *data,
 205                                          const void *unused)
 206 {
 207     int64_t res = 0;
 208     Visitor *v;
 209     Error *err = NULL;
 210
 211     v = visitor_input_test_init(data, "\"-42\"");
 212
 213     visit_type_int(v, NULL, &res, &err);
 214     error_free_or_abort(&err);
 215 }
 216
 217 static void test_visitor_in_bool(TestInputVisitorData *data,
 218                                  const void *unused)
 219 {
 220     bool res = false;
 221     Visitor *v;
 222
 223     v = visitor_input_test_init(data, "true");
 224
 225     visit_type_bool(v, NULL, &res, &error_abort);
 226     g_assert_cmpint(res, ==, true);
 227 }
 228
 229 static void test_visitor_in_bool_keyval(TestInputVisitorData *data,
 230                                         const void *unused)
 231 {
 232     bool res = false;
 233     Error *err = NULL;
 234     Visitor *v;
 235
 236     v = visitor_input_test_init_full(data, true, "true");
 237
 238     visit_type_bool(v, NULL, &res, &err);
 239     error_free_or_abort(&err);
 240 }
 241
 242 static void test_visitor_in_bool_str_keyval(TestInputVisitorData *data,
 243                                             const void *unused)
 244 {
 245     bool res = false;
 246     Visitor *v;
 247
 248     v = visitor_input_test_init_full(data, true, "\"on\"");
 249
 250     visit_type_bool(v, NULL, &res, &error_abort);
 251     g_assert_cmpint(res, ==, true);
 252 }
 253
 254 static void test_visitor_in_bool_str_fail(TestInputVisitorData *data,
 255                                           const void *unused)
 256 {
 257     bool res = false;
 258     Visitor *v;
 259     Error *err = NULL;
 260
 261     v = visitor_input_test_init(data, "\"true\"");
 262
 263     visit_type_bool(v, NULL, &res, &err);
 264     error_free_or_abort(&err);
 265 }
 266
 267 static void test_visitor_in_number(TestInputVisitorData *data,
 268                                    const void *unused)
 269 {
 270     double res = 0, value = 3.14;
 271     Visitor *v;
 272
 273     v = visitor_input_test_init(data, "%f", value);
 274
 275     visit_type_number(v, NULL, &res, &error_abort);
 276     g_assert_cmpfloat(res, ==, value);
 277 }
 278
 279 static void test_visitor_in_large_number(TestInputVisitorData *data,
 280                                          const void *unused)
 281 {
 282     Error *err = NULL;
 283     double res = 0;
 284     int64_t i64;
 285     uint64_t u64;
 286     Visitor *v;
 287
 288     v = visitor_input_test_init(data, "-18446744073709551616"); /* -2^64 */
 289
 290     visit_type_number(v, NULL, &res, &error_abort);
 291     g_assert_cmpfloat(res, ==, -18446744073709552e3);
 292
 293     visit_type_int(v, NULL, &i64, &err);
 294     error_free_or_abort(&err);
 295
 296     visit_type_uint64(v, NULL, &u64, &err);
 297     error_free_or_abort(&err);
 298 }
 299
 300 static void test_visitor_in_number_keyval(TestInputVisitorData *data,
 301                                           const void *unused)
 302 {
 303     double res = 0, value = 3.14;
 304     Error *err = NULL;
 305     Visitor *v;
 306
 307     v = visitor_input_test_init_full(data, true, "%f", value);
 308
 309     visit_type_number(v, NULL, &res, &err);
 310     error_free_or_abort(&err);
 311 }
 312
 313 static void test_visitor_in_number_str_keyval(TestInputVisitorData *data,
 314                                               const void *unused)
 315 {
 316     double res = 0, value = 3.14;
 317     Visitor *v;
 318     Error *err = NULL;
 319
 320     v = visitor_input_test_init_full(data, true, "\"3.14\"");
 321
 322     visit_type_number(v, NULL, &res, &error_abort);
 323     g_assert_cmpfloat(res, ==, value);
 324
 325     v = visitor_input_test_init_full(data, true, "\"inf\"");
 326
 327     visit_type_number(v, NULL, &res, &err);
 328     error_free_or_abort(&err);
 329 }
 330
 331 static void test_visitor_in_number_str_fail(TestInputVisitorData *data,
 332                                             const void *unused)
 333 {
 334     double res = 0;
 335     Visitor *v;
 336     Error *err = NULL;
 337
 338     v = visitor_input_test_init(data, "\"3.14\"");
 339
 340     visit_type_number(v, NULL, &res, &err);
 341     error_free_or_abort(&err);
 342 }
 343
 344 static void test_visitor_in_size_str_keyval(TestInputVisitorData *data,
 345                                             const void *unused)
 346 {
 347     uint64_t res, value = 500 * 1024 * 1024;
 348     Visitor *v;
 349
 350     v = visitor_input_test_init_full(data, true, "\"500M\"");
 351
 352     visit_type_size(v, NULL, &res, &error_abort);
 353     g_assert_cmpfloat(res, ==, value);
 354 }
 355
 356 static void test_visitor_in_size_str_fail(TestInputVisitorData *data,
 357                                           const void *unused)
 358 {
 359     uint64_t res = 0;
 360     Visitor *v;
 361     Error *err = NULL;
 362
 363     v = visitor_input_test_init(data, "\"500M\"");
 364
 365     visit_type_size(v, NULL, &res, &err);
 366     error_free_or_abort(&err);
 367 }
 368
 369 static void test_visitor_in_string(TestInputVisitorData *data,
 370                                    const void *unused)
 371 {
 372     char *res = NULL, *value = (char *) "Q E M U";
 373     Visitor *v;
 374
 375     v = visitor_input_test_init(data, "%s", value);
 376
 377     visit_type_str(v, NULL, &res, &error_abort);
 378     g_assert_cmpstr(res, ==, value);
 379
 380     g_free(res);
 381 }
 382
 383 static void test_visitor_in_enum(TestInputVisitorData *data,
 384                                  const void *unused)
 385 {
 386     Visitor *v;
 387     EnumOne i;
 388
 389     for (i = 0; i < ENUM_ONE__MAX; i++) {
 390         EnumOne res = -1;
 391
 392         v = visitor_input_test_init(data, "%s", EnumOne_str(i));
 393
 394         visit_type_EnumOne(v, NULL, &res, &error_abort);
 395         g_assert_cmpint(i, ==, res);
 396     }
 397 }
 398
 399
 400 static void test_visitor_in_struct(TestInputVisitorData *data,
 401                                    const void *unused)
 402 {
 403     TestStruct *p = NULL;
 404     Visitor *v;
 405
 406     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 407
 408     visit_type_TestStruct(v, NULL, &p, &error_abort);
 409     g_assert_cmpint(p->integer, ==, -42);
 410     g_assert(p->boolean == true);
 411     g_assert_cmpstr(p->string, ==, "foo");
 412
 413     g_free(p->string);
 414     g_free(p);
 415 }
 416
 417 static void test_visitor_in_struct_nested(TestInputVisitorData *data,
 418                                           const void *unused)
 419 {
 420     g_autoptr(UserDefTwo) udp = NULL;
 421     Visitor *v;
 422
 423     v = visitor_input_test_init(data, "{ 'string0': 'string0', "
 424                                 "'dict1': { 'string1': 'string1', "
 425                                 "'dict2': { 'userdef': { 'integer': 42, "
 426                                 "'string': 'string' }, 'string': 'string2'}}}");
 427
 428     visit_type_UserDefTwo(v, NULL, &udp, &error_abort);
 429
 430     g_assert_cmpstr(udp->string0, ==, "string0");
 431     g_assert_cmpstr(udp->dict1->string1, ==, "string1");
 432     g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
 433     g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
 434     g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
 435     g_assert(udp->dict1->has_dict3 == false);
 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_unref(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_unref(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     qobject_unref(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     g_autoptr(UserDefFlatUnion) tmp = NULL;
 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
 566 static void test_visitor_in_alternate(TestInputVisitorData *data,
 567                                       const void *unused)
 568 {
 569     Visitor *v;
 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, "null");
 586     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 587     g_assert_cmpint(tmp->type, ==, QTYPE_QNULL);
 588     qapi_free_UserDefAlternate(tmp);
 589
 590     v = visitor_input_test_init(data, "{'integer':1, 'string':'str', "
 591                                 "'enum1':'value1', 'boolean':true}");
 592     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 593     g_assert_cmpint(tmp->type, ==, QTYPE_QDICT);
 594     g_assert_cmpint(tmp->u.udfu.integer, ==, 1);
 595     g_assert_cmpstr(tmp->u.udfu.string, ==, "str");
 596     g_assert_cmpint(tmp->u.udfu.enum1, ==, ENUM_ONE_VALUE1);
 597     g_assert_cmpint(tmp->u.udfu.u.value1.boolean, ==, true);
 598     g_assert_cmpint(tmp->u.udfu.u.value1.has_a_b, ==, false);
 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_list_union_integer_helper(TestInputVisitorData *data,
 686                                            const void *unused,
 687                                            UserDefListUnionKind kind)
 688 {
 689     g_autoptr(UserDefListUnion) 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                            UserDefListUnionKind_str(kind),
 703                            gstr_list->str);
 704     v = visitor_input_test_init_raw(data,  gstr_union->str);
 705
 706     visit_type_UserDefListUnion(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_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_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_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_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_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_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_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_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_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 }
 782
 783 static void test_visitor_in_list_union_int(TestInputVisitorData *data,
 784                                            const void *unused)
 785 {
 786     test_list_union_integer_helper(data, unused,
 787                                    USER_DEF_LIST_UNION_KIND_INTEGER);
 788 }
 789
 790 static void test_visitor_in_list_union_int8(TestInputVisitorData *data,
 791                                             const void *unused)
 792 {
 793     test_list_union_integer_helper(data, unused,
 794                                    USER_DEF_LIST_UNION_KIND_S8);
 795 }
 796
 797 static void test_visitor_in_list_union_int16(TestInputVisitorData *data,
 798                                              const void *unused)
 799 {
 800     test_list_union_integer_helper(data, unused,
 801                                    USER_DEF_LIST_UNION_KIND_S16);
 802 }
 803
 804 static void test_visitor_in_list_union_int32(TestInputVisitorData *data,
 805                                              const void *unused)
 806 {
 807     test_list_union_integer_helper(data, unused,
 808                                    USER_DEF_LIST_UNION_KIND_S32);
 809 }
 810
 811 static void test_visitor_in_list_union_int64(TestInputVisitorData *data,
 812                                              const void *unused)
 813 {
 814     test_list_union_integer_helper(data, unused,
 815                                    USER_DEF_LIST_UNION_KIND_S64);
 816 }
 817
 818 static void test_visitor_in_list_union_uint8(TestInputVisitorData *data,
 819                                              const void *unused)
 820 {
 821     test_list_union_integer_helper(data, unused,
 822                                    USER_DEF_LIST_UNION_KIND_U8);
 823 }
 824
 825 static void test_visitor_in_list_union_uint16(TestInputVisitorData *data,
 826                                               const void *unused)
 827 {
 828     test_list_union_integer_helper(data, unused,
 829                                    USER_DEF_LIST_UNION_KIND_U16);
 830 }
 831
 832 static void test_visitor_in_list_union_uint32(TestInputVisitorData *data,
 833                                               const void *unused)
 834 {
 835     test_list_union_integer_helper(data, unused,
 836                                    USER_DEF_LIST_UNION_KIND_U32);
 837 }
 838
 839 static void test_visitor_in_list_union_uint64(TestInputVisitorData *data,
 840                                               const void *unused)
 841 {
 842     test_list_union_integer_helper(data, unused,
 843                                    USER_DEF_LIST_UNION_KIND_U64);
 844 }
 845
 846 static void test_visitor_in_list_union_bool(TestInputVisitorData *data,
 847                                             const void *unused)
 848 {
 849     g_autoptr(UserDefListUnion) cvalue = NULL;
 850     boolList *elem = NULL;
 851     Visitor *v;
 852     GString *gstr_list = g_string_new("");
 853     GString *gstr_union = g_string_new("");
 854     int i;
 855
 856     for (i = 0; i < 32; i++) {
 857         g_string_append_printf(gstr_list, "%s",
 858                                (i % 3 == 0) ? "true" : "false");
 859         if (i != 31) {
 860             g_string_append(gstr_list, ", ");
 861         }
 862     }
 863     g_string_append_printf(gstr_union,  "{ 'type': 'boolean', 'data': [ %s ] }",
 864                            gstr_list->str);
 865     v = visitor_input_test_init_raw(data,  gstr_union->str);
 866
 867     visit_type_UserDefListUnion(v, NULL, &cvalue, &error_abort);
 868     g_assert(cvalue != NULL);
 869     g_assert_cmpint(cvalue->type, ==, USER_DEF_LIST_UNION_KIND_BOOLEAN);
 870
 871     for (i = 0, elem = cvalue->u.boolean.data; elem; elem = elem->next, i++) {
 872         g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0);
 873     }
 874
 875     g_string_free(gstr_union, true);
 876     g_string_free(gstr_list, true);
 877 }
 878
 879 static void test_visitor_in_list_union_string(TestInputVisitorData *data,
 880                                               const void *unused)
 881 {
 882     g_autoptr(UserDefListUnion) cvalue = NULL;
 883     strList *elem = NULL;
 884     Visitor *v;
 885     GString *gstr_list = g_string_new("");
 886     GString *gstr_union = g_string_new("");
 887     int i;
 888
 889     for (i = 0; i < 32; i++) {
 890         g_string_append_printf(gstr_list, "'%d'", i);
 891         if (i != 31) {
 892             g_string_append(gstr_list, ", ");
 893         }
 894     }
 895     g_string_append_printf(gstr_union,  "{ 'type': 'string', 'data': [ %s ] }",
 896                            gstr_list->str);
 897     v = visitor_input_test_init_raw(data,  gstr_union->str);
 898
 899     visit_type_UserDefListUnion(v, NULL, &cvalue, &error_abort);
 900     g_assert(cvalue != NULL);
 901     g_assert_cmpint(cvalue->type, ==, USER_DEF_LIST_UNION_KIND_STRING);
 902
 903     for (i = 0, elem = cvalue->u.string.data; elem; elem = elem->next, i++) {
 904         gchar str[8];
 905         sprintf(str, "%d", i);
 906         g_assert_cmpstr(elem->value, ==, str);
 907     }
 908
 909     g_string_free(gstr_union, true);
 910     g_string_free(gstr_list, true);
 911 }
 912
 913 #define DOUBLE_STR_MAX 16
 914
 915 static void test_visitor_in_list_union_number(TestInputVisitorData *data,
 916                                               const void *unused)
 917 {
 918     g_autoptr(UserDefListUnion) cvalue = NULL;
 919     numberList *elem = NULL;
 920     Visitor *v;
 921     GString *gstr_list = g_string_new("");
 922     GString *gstr_union = g_string_new("");
 923     int i;
 924
 925     for (i = 0; i < 32; i++) {
 926         g_string_append_printf(gstr_list, "%f", (double)i / 3);
 927         if (i != 31) {
 928             g_string_append(gstr_list, ", ");
 929         }
 930     }
 931     g_string_append_printf(gstr_union,  "{ 'type': 'number', 'data': [ %s ] }",
 932                            gstr_list->str);
 933     v = visitor_input_test_init_raw(data,  gstr_union->str);
 934
 935     visit_type_UserDefListUnion(v, NULL, &cvalue, &error_abort);
 936     g_assert(cvalue != NULL);
 937     g_assert_cmpint(cvalue->type, ==, USER_DEF_LIST_UNION_KIND_NUMBER);
 938
 939     for (i = 0, elem = cvalue->u.number.data; elem; elem = elem->next, i++) {
 940         GString *double_expected = g_string_new("");
 941         GString *double_actual = g_string_new("");
 942
 943         g_string_printf(double_expected, "%.6f", (double)i / 3);
 944         g_string_printf(double_actual, "%.6f", elem->value);
 945         g_assert_cmpstr(double_expected->str, ==, double_actual->str);
 946
 947         g_string_free(double_expected, true);
 948         g_string_free(double_actual, true);
 949     }
 950
 951     g_string_free(gstr_union, true);
 952     g_string_free(gstr_list, true);
 953 }
 954
 955 static void input_visitor_test_add(const char *testpath,
 956                                    const void *user_data,
 957                                    void (*test_func)(TestInputVisitorData *data,
 958                                                      const void *user_data))
 959 {
 960     g_test_add(testpath, TestInputVisitorData, user_data, NULL, test_func,
 961                visitor_input_teardown);
 962 }
 963
 964 static void test_visitor_in_errors(TestInputVisitorData *data,
 965                                    const void *unused)
 966 {
 967     TestStruct *p = NULL;
 968     Error *err = NULL;
 969     Visitor *v;
 970     strList *q = NULL;
 971     UserDefTwo *r = NULL;
 972     WrapAlternate *s = NULL;
 973
 974     v = visitor_input_test_init(data, "{ 'integer': false, 'boolean': 'foo', "
 975                                 "'string': -42 }");
 976
 977     visit_type_TestStruct(v, NULL, &p, &err);
 978     error_free_or_abort(&err);
 979     g_assert(!p);
 980
 981     v = visitor_input_test_init(data, "[ '1', '2', false, '3' ]");
 982     visit_type_strList(v, NULL, &q, &err);
 983     error_free_or_abort(&err);
 984     assert(!q);
 985
 986     v = visitor_input_test_init(data, "{ 'str':'hi' }");
 987     visit_type_UserDefTwo(v, NULL, &r, &err);
 988     error_free_or_abort(&err);
 989     assert(!r);
 990
 991     v = visitor_input_test_init(data, "{ }");
 992     visit_type_WrapAlternate(v, NULL, &s, &err);
 993     error_free_or_abort(&err);
 994     assert(!s);
 995 }
 996
 997 static void test_visitor_in_wrong_type(TestInputVisitorData *data,
 998                                        const void *unused)
 999 {
1000     TestStruct *p = NULL;
1001     Visitor *v;
1002     strList *q = NULL;
1003     int64_t i;
1004     Error *err = NULL;
1005
1006     /* Make sure arrays and structs cannot be confused */
1007
1008     v = visitor_input_test_init(data, "[]");
1009     visit_type_TestStruct(v, NULL, &p, &err);
1010     error_free_or_abort(&err);
1011     g_assert(!p);
1012
1013     v = visitor_input_test_init(data, "{}");
1014     visit_type_strList(v, NULL, &q, &err);
1015     error_free_or_abort(&err);
1016     assert(!q);
1017
1018     /* Make sure primitives and struct cannot be confused */
1019
1020     v = visitor_input_test_init(data, "1");
1021     visit_type_TestStruct(v, NULL, &p, &err);
1022     error_free_or_abort(&err);
1023     g_assert(!p);
1024
1025     v = visitor_input_test_init(data, "{}");
1026     visit_type_int(v, NULL, &i, &err);
1027     error_free_or_abort(&err);
1028
1029     /* Make sure primitives and arrays cannot be confused */
1030
1031     v = visitor_input_test_init(data, "1");
1032     visit_type_strList(v, NULL, &q, &err);
1033     error_free_or_abort(&err);
1034     assert(!q);
1035
1036     v = visitor_input_test_init(data, "[]");
1037     visit_type_int(v, NULL, &i, &err);
1038     error_free_or_abort(&err);
1039 }
1040
1041 static void test_visitor_in_fail_struct(TestInputVisitorData *data,
1042                                         const void *unused)
1043 {
1044     TestStruct *p = NULL;
1045     Error *err = NULL;
1046     Visitor *v;
1047
1048     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo', 'extra': 42 }");
1049
1050     visit_type_TestStruct(v, NULL, &p, &err);
1051     error_free_or_abort(&err);
1052     g_assert(!p);
1053 }
1054
1055 static void test_visitor_in_fail_struct_nested(TestInputVisitorData *data,
1056                                                const void *unused)
1057 {
1058     UserDefTwo *udp = NULL;
1059     Error *err = NULL;
1060     Visitor *v;
1061
1062     v = visitor_input_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string', 'extra': [42, 23, {'foo':'bar'}] }, 'string2': 'string2'}}}");
1063
1064     visit_type_UserDefTwo(v, NULL, &udp, &err);
1065     error_free_or_abort(&err);
1066     g_assert(!udp);
1067 }
1068
1069 static void test_visitor_in_fail_struct_in_list(TestInputVisitorData *data,
1070                                                 const void *unused)
1071 {
1072     UserDefOneList *head = NULL;
1073     Error *err = NULL;
1074     Visitor *v;
1075
1076     v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44, 'extra': 'ggg' } ]");
1077
1078     visit_type_UserDefOneList(v, NULL, &head, &err);
1079     error_free_or_abort(&err);
1080     g_assert(!head);
1081 }
1082
1083 static void test_visitor_in_fail_struct_missing(TestInputVisitorData *data,
1084                                                 const void *unused)
1085 {
1086     Error *err = NULL;
1087     Visitor *v;
1088     QObject *any;
1089     QNull *null;
1090     GenericAlternate *alt;
1091     bool present;
1092     int en;
1093     int64_t i64;
1094     uint32_t u32;
1095     int8_t i8;
1096     char *str;
1097     double dbl;
1098
1099     v = visitor_input_test_init(data, "{ 'sub': [ {} ] }");
1100     visit_start_struct(v, NULL, NULL, 0, &error_abort);
1101     visit_start_struct(v, "struct", NULL, 0, &err);
1102     error_free_or_abort(&err);
1103     visit_start_list(v, "list", NULL, 0, &err);
1104     error_free_or_abort(&err);
1105     visit_start_alternate(v, "alternate", &alt, sizeof(*alt), &err);
1106     error_free_or_abort(&err);
1107     visit_optional(v, "optional", &present);
1108     g_assert(!present);
1109     visit_type_enum(v, "enum", &en, &EnumOne_lookup, &err);
1110     error_free_or_abort(&err);
1111     visit_type_int(v, "i64", &i64, &err);
1112     error_free_or_abort(&err);
1113     visit_type_uint32(v, "u32", &u32, &err);
1114     error_free_or_abort(&err);
1115     visit_type_int8(v, "i8", &i8, &err);
1116     error_free_or_abort(&err);
1117     visit_type_str(v, "i8", &str, &err);
1118     error_free_or_abort(&err);
1119     visit_type_number(v, "dbl", &dbl, &err);
1120     error_free_or_abort(&err);
1121     visit_type_any(v, "any", &any, &err);
1122     error_free_or_abort(&err);
1123     visit_type_null(v, "null", &null, &err);
1124     error_free_or_abort(&err);
1125     visit_start_list(v, "sub", NULL, 0, &error_abort);
1126     visit_start_struct(v, NULL, NULL, 0, &error_abort);
1127     visit_type_int(v, "i64", &i64, &err);
1128     error_free_or_abort(&err);
1129     visit_end_struct(v, NULL);
1130     visit_end_list(v, NULL);
1131     visit_end_struct(v, NULL);
1132 }
1133
1134 static void test_visitor_in_fail_list(TestInputVisitorData *data,
1135                                       const void *unused)
1136 {
1137     int64_t i64 = -1;
1138     Error *err = NULL;
1139     Visitor *v;
1140
1141     /* Unvisited list tail */
1142
1143     v = visitor_input_test_init(data, "[ 1, 2, 3 ]");
1144
1145     visit_start_list(v, NULL, NULL, 0, &error_abort);
1146     visit_type_int(v, NULL, &i64, &error_abort);
1147     g_assert_cmpint(i64, ==, 1);
1148     visit_type_int(v, NULL, &i64, &error_abort);
1149     g_assert_cmpint(i64, ==, 2);
1150     visit_check_list(v, &err);
1151     error_free_or_abort(&err);
1152     visit_end_list(v, NULL);
1153
1154     /* Visit beyond end of list */
1155     v = visitor_input_test_init(data, "[]");
1156
1157     visit_start_list(v, NULL, NULL, 0, &error_abort);
1158     visit_type_int(v, NULL, &i64, &err);
1159     error_free_or_abort(&err);
1160     visit_end_list(v, NULL);
1161 }
1162
1163 static void test_visitor_in_fail_list_nested(TestInputVisitorData *data,
1164                                              const void *unused)
1165 {
1166     int64_t i64 = -1;
1167     Error *err = NULL;
1168     Visitor *v;
1169
1170     /* Unvisited nested list tail */
1171
1172     v = visitor_input_test_init(data, "[ 0, [ 1, 2, 3 ] ]");
1173
1174     visit_start_list(v, NULL, NULL, 0, &error_abort);
1175     visit_type_int(v, NULL, &i64, &error_abort);
1176     g_assert_cmpint(i64, ==, 0);
1177     visit_start_list(v, NULL, NULL, 0, &error_abort);
1178     visit_type_int(v, NULL, &i64, &error_abort);
1179     g_assert_cmpint(i64, ==, 1);
1180     visit_check_list(v, &err);
1181     error_free_or_abort(&err);
1182     visit_end_list(v, NULL);
1183     visit_check_list(v, &error_abort);
1184     visit_end_list(v, NULL);
1185 }
1186
1187 static void test_visitor_in_fail_union_list(TestInputVisitorData *data,
1188                                             const void *unused)
1189 {
1190     UserDefListUnion *tmp = NULL;
1191     Error *err = NULL;
1192     Visitor *v;
1193
1194     v = visitor_input_test_init(data,
1195                                 "{ 'type': 'integer', 'data' : [ 'string' ] }");
1196
1197     visit_type_UserDefListUnion(v, NULL, &tmp, &err);
1198     error_free_or_abort(&err);
1199     g_assert(!tmp);
1200 }
1201
1202 static void test_visitor_in_fail_union_flat(TestInputVisitorData *data,
1203                                             const void *unused)
1204 {
1205     UserDefFlatUnion *tmp = NULL;
1206     Error *err = NULL;
1207     Visitor *v;
1208
1209     v = visitor_input_test_init(data, "{ 'string': 'c', 'integer': 41, 'boolean': true }");
1210
1211     visit_type_UserDefFlatUnion(v, NULL, &tmp, &err);
1212     error_free_or_abort(&err);
1213     g_assert(!tmp);
1214 }
1215
1216 static void test_visitor_in_fail_union_flat_no_discrim(TestInputVisitorData *data,
1217                                                        const void *unused)
1218 {
1219     UserDefFlatUnion2 *tmp = NULL;
1220     Error *err = NULL;
1221     Visitor *v;
1222
1223     /* test situation where discriminator field ('enum1' here) is missing */
1224     v = visitor_input_test_init(data, "{ 'integer': 42, 'string': 'c', 'string1': 'd', 'string2': 'e' }");
1225
1226     visit_type_UserDefFlatUnion2(v, NULL, &tmp, &err);
1227     error_free_or_abort(&err);
1228     g_assert(!tmp);
1229 }
1230
1231 static void test_visitor_in_fail_alternate(TestInputVisitorData *data,
1232                                            const void *unused)
1233 {
1234     UserDefAlternate *tmp;
1235     Visitor *v;
1236     Error *err = NULL;
1237
1238     v = visitor_input_test_init(data, "3.14");
1239
1240     visit_type_UserDefAlternate(v, NULL, &tmp, &err);
1241     error_free_or_abort(&err);
1242     g_assert(!tmp);
1243 }
1244
1245 static void do_test_visitor_in_qmp_introspect(TestInputVisitorData *data,
1246                                               const QLitObject *qlit)
1247 {
1248     g_autoptr(SchemaInfoList) schema = NULL;
1249     QObject *obj = qobject_from_qlit(qlit);
1250     Visitor *v;
1251
1252     v = qobject_input_visitor_new(obj);
1253
1254     visit_type_SchemaInfoList(v, NULL, &schema, &error_abort);
1255     g_assert(schema);
1256
1257     qobject_unref(obj);
1258     visit_free(v);
1259 }
1260
1261 static void test_visitor_in_qmp_introspect(TestInputVisitorData *data,
1262                                            const void *unused)
1263 {
1264     do_test_visitor_in_qmp_introspect(data, &test_qmp_schema_qlit);
1265 }
1266
1267 int main(int argc, char **argv)
1268 {
1269     g_test_init(&argc, &argv, NULL);
1270
1271     input_visitor_test_add("/visitor/input/int",
1272                            NULL, test_visitor_in_int);
1273     input_visitor_test_add("/visitor/input/uint",
1274                            NULL, test_visitor_in_uint);
1275     input_visitor_test_add("/visitor/input/int_overflow",
1276                            NULL, test_visitor_in_int_overflow);
1277     input_visitor_test_add("/visitor/input/int_keyval",
1278                            NULL, test_visitor_in_int_keyval);
1279     input_visitor_test_add("/visitor/input/int_str_keyval",
1280                            NULL, test_visitor_in_int_str_keyval);
1281     input_visitor_test_add("/visitor/input/int_str_fail",
1282                            NULL, test_visitor_in_int_str_fail);
1283     input_visitor_test_add("/visitor/input/bool",
1284                            NULL, test_visitor_in_bool);
1285     input_visitor_test_add("/visitor/input/bool_keyval",
1286                            NULL, test_visitor_in_bool_keyval);
1287     input_visitor_test_add("/visitor/input/bool_str_keyval",
1288                            NULL, test_visitor_in_bool_str_keyval);
1289     input_visitor_test_add("/visitor/input/bool_str_fail",
1290                            NULL, test_visitor_in_bool_str_fail);
1291     input_visitor_test_add("/visitor/input/number",
1292                            NULL, test_visitor_in_number);
1293     input_visitor_test_add("/visitor/input/large_number",
1294                            NULL, test_visitor_in_large_number);
1295     input_visitor_test_add("/visitor/input/number_keyval",
1296                            NULL, test_visitor_in_number_keyval);
1297     input_visitor_test_add("/visitor/input/number_str_keyval",
1298                            NULL, test_visitor_in_number_str_keyval);
1299     input_visitor_test_add("/visitor/input/number_str_fail",
1300                            NULL, test_visitor_in_number_str_fail);
1301     input_visitor_test_add("/visitor/input/size_str_keyval",
1302                            NULL, test_visitor_in_size_str_keyval);
1303     input_visitor_test_add("/visitor/input/size_str_fail",
1304                            NULL, test_visitor_in_size_str_fail);
1305     input_visitor_test_add("/visitor/input/string",
1306                            NULL, test_visitor_in_string);
1307     input_visitor_test_add("/visitor/input/enum",
1308                            NULL, test_visitor_in_enum);
1309     input_visitor_test_add("/visitor/input/struct",
1310                            NULL, test_visitor_in_struct);
1311     input_visitor_test_add("/visitor/input/struct-nested",
1312                            NULL, test_visitor_in_struct_nested);
1313     input_visitor_test_add("/visitor/input/list",
1314                            NULL, test_visitor_in_list);
1315     input_visitor_test_add("/visitor/input/any",
1316                            NULL, test_visitor_in_any);
1317     input_visitor_test_add("/visitor/input/null",
1318                            NULL, test_visitor_in_null);
1319     input_visitor_test_add("/visitor/input/union-flat",
1320                            NULL, test_visitor_in_union_flat);
1321     input_visitor_test_add("/visitor/input/alternate",
1322                            NULL, test_visitor_in_alternate);
1323     input_visitor_test_add("/visitor/input/errors",
1324                            NULL, test_visitor_in_errors);
1325     input_visitor_test_add("/visitor/input/wrong-type",
1326                            NULL, test_visitor_in_wrong_type);
1327     input_visitor_test_add("/visitor/input/alternate-number",
1328                            NULL, test_visitor_in_alternate_number);
1329     input_visitor_test_add("/visitor/input/list_union/int",
1330                            NULL, test_visitor_in_list_union_int);
1331     input_visitor_test_add("/visitor/input/list_union/int8",
1332                            NULL, test_visitor_in_list_union_int8);
1333     input_visitor_test_add("/visitor/input/list_union/int16",
1334                            NULL, test_visitor_in_list_union_int16);
1335     input_visitor_test_add("/visitor/input/list_union/int32",
1336                            NULL, test_visitor_in_list_union_int32);
1337     input_visitor_test_add("/visitor/input/list_union/int64",
1338                            NULL, test_visitor_in_list_union_int64);
1339     input_visitor_test_add("/visitor/input/list_union/uint8",
1340                            NULL, test_visitor_in_list_union_uint8);
1341     input_visitor_test_add("/visitor/input/list_union/uint16",
1342                            NULL, test_visitor_in_list_union_uint16);
1343     input_visitor_test_add("/visitor/input/list_union/uint32",
1344                            NULL, test_visitor_in_list_union_uint32);
1345     input_visitor_test_add("/visitor/input/list_union/uint64",
1346                            NULL, test_visitor_in_list_union_uint64);
1347     input_visitor_test_add("/visitor/input/list_union/bool",
1348                            NULL, test_visitor_in_list_union_bool);
1349     input_visitor_test_add("/visitor/input/list_union/str",
1350                            NULL, test_visitor_in_list_union_string);
1351     input_visitor_test_add("/visitor/input/list_union/number",
1352                            NULL, test_visitor_in_list_union_number);
1353     input_visitor_test_add("/visitor/input/fail/struct",
1354                            NULL, test_visitor_in_fail_struct);
1355     input_visitor_test_add("/visitor/input/fail/struct-nested",
1356                            NULL, test_visitor_in_fail_struct_nested);
1357     input_visitor_test_add("/visitor/input/fail/struct-in-list",
1358                            NULL, test_visitor_in_fail_struct_in_list);
1359     input_visitor_test_add("/visitor/input/fail/struct-missing",
1360                            NULL, test_visitor_in_fail_struct_missing);
1361     input_visitor_test_add("/visitor/input/fail/list",
1362                            NULL, test_visitor_in_fail_list);
1363     input_visitor_test_add("/visitor/input/fail/list-nested",
1364                            NULL, test_visitor_in_fail_list_nested);
1365     input_visitor_test_add("/visitor/input/fail/union-flat",
1366                            NULL, test_visitor_in_fail_union_flat);
1367     input_visitor_test_add("/visitor/input/fail/union-flat-no-discriminator",
1368                            NULL, test_visitor_in_fail_union_flat_no_discrim);
1369     input_visitor_test_add("/visitor/input/fail/alternate",
1370                            NULL, test_visitor_in_fail_alternate);
1371     input_visitor_test_add("/visitor/input/fail/union-list",
1372                            NULL, test_visitor_in_fail_union_list);
1373     input_visitor_test_add("/visitor/input/qapi-introspect",
1374                            NULL, test_visitor_in_qmp_introspect);
1375
1376     g_test_run();
1377
1378     return 0;
1379 }