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