tests/test-qmp-input-visitor.c

   1 /*
   2  * QMP Input Visitor unit-tests.
   3  *
   4  * Copyright (C) 2011, 2015 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Luiz Capitulino <lcapitulino@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include <glib.h>
  14 #include <stdarg.h>
  15
  16 #include "qemu-common.h"
  17 #include "qapi/qmp-input-visitor.h"
  18 #include "test-qapi-types.h"
  19 #include "test-qapi-visit.h"
  20 #include "qapi/qmp/types.h"
  21
  22 typedef struct TestInputVisitorData {
  23     QObject *obj;
  24     QmpInputVisitor *qiv;
  25 } TestInputVisitorData;
  26
  27 static void visitor_input_teardown(TestInputVisitorData *data,
  28                                    const void *unused)
  29 {
  30     qobject_decref(data->obj);
  31     data->obj = NULL;
  32
  33     if (data->qiv) {
  34         qmp_input_visitor_cleanup(data->qiv);
  35         data->qiv = NULL;
  36     }
  37 }
  38
  39 /* The various test_init functions are provided instead of a test setup
  40    function so that the JSON string used by the tests are kept in the test
  41    functions (and not in main()). */
  42 static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
  43                                                  const char *json_string,
  44                                                  va_list *ap)
  45 {
  46     Visitor *v;
  47
  48     visitor_input_teardown(data, NULL);
  49
  50     data->obj = qobject_from_jsonv(json_string, ap);
  51     g_assert(data->obj);
  52
  53     data->qiv = qmp_input_visitor_new(data->obj);
  54     g_assert(data->qiv);
  55
  56     v = qmp_input_get_visitor(data->qiv);
  57     g_assert(v);
  58
  59     return v;
  60 }
  61
  62 static GCC_FMT_ATTR(2, 3)
  63 Visitor *visitor_input_test_init(TestInputVisitorData *data,
  64                                  const char *json_string, ...)
  65 {
  66     Visitor *v;
  67     va_list ap;
  68
  69     va_start(ap, json_string);
  70     v = visitor_input_test_init_internal(data, json_string, &ap);
  71     va_end(ap);
  72     return v;
  73 }
  74
  75 /* similar to visitor_input_test_init(), but does not expect a string
  76  * literal/format json_string argument and so can be used for
  77  * programatically generated strings (and we can't pass in programatically
  78  * generated strings via %s format parameters since qobject_from_jsonv()
  79  * will wrap those in double-quotes and treat the entire object as a
  80  * string)
  81  */
  82 static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
  83                                             const char *json_string)
  84 {
  85     return visitor_input_test_init_internal(data, json_string, NULL);
  86 }
  87
  88 static void test_visitor_in_int(TestInputVisitorData *data,
  89                                 const void *unused)
  90 {
  91     int64_t res = 0, value = -42;
  92     Visitor *v;
  93
  94     v = visitor_input_test_init(data, "%" PRId64, value);
  95
  96     visit_type_int(v, &res, NULL, &error_abort);
  97     g_assert_cmpint(res, ==, value);
  98 }
  99
 100 static void test_visitor_in_int_overflow(TestInputVisitorData *data,
 101                                          const void *unused)
 102 {
 103     int64_t res = 0;
 104     Error *err = NULL;
 105     Visitor *v;
 106
 107     /* this will overflow a Qint/int64, so should be deserialized into
 108      * a QFloat/double field instead, leading to an error if we pass it
 109      * to visit_type_int. confirm this.
 110      */
 111     v = visitor_input_test_init(data, "%f", DBL_MAX);
 112
 113     visit_type_int(v, &res, NULL, &err);
 114     error_free_or_abort(&err);
 115 }
 116
 117 static void test_visitor_in_bool(TestInputVisitorData *data,
 118                                  const void *unused)
 119 {
 120     bool res = false;
 121     Visitor *v;
 122
 123     v = visitor_input_test_init(data, "true");
 124
 125     visit_type_bool(v, &res, NULL, &error_abort);
 126     g_assert_cmpint(res, ==, true);
 127 }
 128
 129 static void test_visitor_in_number(TestInputVisitorData *data,
 130                                    const void *unused)
 131 {
 132     double res = 0, value = 3.14;
 133     Visitor *v;
 134
 135     v = visitor_input_test_init(data, "%f", value);
 136
 137     visit_type_number(v, &res, NULL, &error_abort);
 138     g_assert_cmpfloat(res, ==, value);
 139 }
 140
 141 static void test_visitor_in_string(TestInputVisitorData *data,
 142                                    const void *unused)
 143 {
 144     char *res = NULL, *value = (char *) "Q E M U";
 145     Visitor *v;
 146
 147     v = visitor_input_test_init(data, "%s", value);
 148
 149     visit_type_str(v, &res, NULL, &error_abort);
 150     g_assert_cmpstr(res, ==, value);
 151
 152     g_free(res);
 153 }
 154
 155 static void test_visitor_in_enum(TestInputVisitorData *data,
 156                                  const void *unused)
 157 {
 158     Visitor *v;
 159     EnumOne i;
 160
 161     for (i = 0; EnumOne_lookup[i]; i++) {
 162         EnumOne res = -1;
 163
 164         v = visitor_input_test_init(data, "%s", EnumOne_lookup[i]);
 165
 166         visit_type_EnumOne(v, &res, NULL, &error_abort);
 167         g_assert_cmpint(i, ==, res);
 168     }
 169 }
 170
 171
 172 static void test_visitor_in_struct(TestInputVisitorData *data,
 173                                    const void *unused)
 174 {
 175     TestStruct *p = NULL;
 176     Visitor *v;
 177
 178     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 179
 180     visit_type_TestStruct(v, &p, NULL, &error_abort);
 181     g_assert_cmpint(p->integer, ==, -42);
 182     g_assert(p->boolean == true);
 183     g_assert_cmpstr(p->string, ==, "foo");
 184
 185     g_free(p->string);
 186     g_free(p);
 187 }
 188
 189 static void test_visitor_in_struct_nested(TestInputVisitorData *data,
 190                                           const void *unused)
 191 {
 192     UserDefTwo *udp = NULL;
 193     Visitor *v;
 194
 195     v = visitor_input_test_init(data, "{ 'string0': 'string0', "
 196                                 "'dict1': { 'string1': 'string1', "
 197                                 "'dict2': { 'userdef': { 'integer': 42, "
 198                                 "'string': 'string' }, 'string': 'string2'}}}");
 199
 200     visit_type_UserDefTwo(v, &udp, NULL, &error_abort);
 201
 202     g_assert_cmpstr(udp->string0, ==, "string0");
 203     g_assert_cmpstr(udp->dict1->string1, ==, "string1");
 204     g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
 205     g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
 206     g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
 207     g_assert(udp->dict1->has_dict3 == false);
 208
 209     qapi_free_UserDefTwo(udp);
 210 }
 211
 212 static void test_visitor_in_list(TestInputVisitorData *data,
 213                                  const void *unused)
 214 {
 215     UserDefOneList *item, *head = NULL;
 216     Visitor *v;
 217     int i;
 218
 219     v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
 220
 221     visit_type_UserDefOneList(v, &head, NULL, &error_abort);
 222     g_assert(head != NULL);
 223
 224     for (i = 0, item = head; item; item = item->next, i++) {
 225         char string[12];
 226
 227         snprintf(string, sizeof(string), "string%d", i);
 228         g_assert_cmpstr(item->value->string, ==, string);
 229         g_assert_cmpint(item->value->integer, ==, 42 + i);
 230     }
 231
 232     qapi_free_UserDefOneList(head);
 233     head = NULL;
 234
 235     /* An empty list is valid */
 236     v = visitor_input_test_init(data, "[]");
 237     visit_type_UserDefOneList(v, &head, NULL, &error_abort);
 238     g_assert(!head);
 239 }
 240
 241 static void test_visitor_in_any(TestInputVisitorData *data,
 242                                 const void *unused)
 243 {
 244     QObject *res = NULL;
 245     Visitor *v;
 246     QInt *qint;
 247     QBool *qbool;
 248     QString *qstring;
 249     QDict *qdict;
 250     QObject *qobj;
 251
 252     v = visitor_input_test_init(data, "-42");
 253     visit_type_any(v, &res, NULL, &error_abort);
 254     qint = qobject_to_qint(res);
 255     g_assert(qint);
 256     g_assert_cmpint(qint_get_int(qint), ==, -42);
 257     qobject_decref(res);
 258
 259     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 260     visit_type_any(v, &res, NULL, &error_abort);
 261     qdict = qobject_to_qdict(res);
 262     g_assert(qdict && qdict_size(qdict) == 3);
 263     qobj = qdict_get(qdict, "integer");
 264     g_assert(qobj);
 265     qint = qobject_to_qint(qobj);
 266     g_assert(qint);
 267     g_assert_cmpint(qint_get_int(qint), ==, -42);
 268     qobj = qdict_get(qdict, "boolean");
 269     g_assert(qobj);
 270     qbool = qobject_to_qbool(qobj);
 271     g_assert(qbool);
 272     g_assert(qbool_get_bool(qbool) == true);
 273     qobj = qdict_get(qdict, "string");
 274     g_assert(qobj);
 275     qstring = qobject_to_qstring(qobj);
 276     g_assert(qstring);
 277     g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
 278     qobject_decref(res);
 279 }
 280
 281 static void test_visitor_in_union_flat(TestInputVisitorData *data,
 282                                        const void *unused)
 283 {
 284     Visitor *v;
 285     UserDefFlatUnion *tmp;
 286     UserDefUnionBase *base;
 287
 288     v = visitor_input_test_init(data,
 289                                 "{ 'enum1': 'value1', "
 290                                 "'integer': 41, "
 291                                 "'string': 'str', "
 292                                 "'boolean': true }");
 293
 294     visit_type_UserDefFlatUnion(v, &tmp, NULL, &error_abort);
 295     g_assert_cmpint(tmp->enum1, ==, ENUM_ONE_VALUE1);
 296     g_assert_cmpstr(tmp->string, ==, "str");
 297     g_assert_cmpint(tmp->integer, ==, 41);
 298     g_assert_cmpint(tmp->u.value1->boolean, ==, true);
 299
 300     base = qapi_UserDefFlatUnion_base(tmp);
 301     g_assert(&base->enum1 == &tmp->enum1);
 302
 303     qapi_free_UserDefFlatUnion(tmp);
 304 }
 305
 306 static void test_visitor_in_alternate(TestInputVisitorData *data,
 307                                       const void *unused)
 308 {
 309     Visitor *v;
 310     Error *err = NULL;
 311     UserDefAlternate *tmp;
 312
 313     v = visitor_input_test_init(data, "42");
 314     visit_type_UserDefAlternate(v, &tmp, NULL, &error_abort);
 315     g_assert_cmpint(tmp->type, ==, USER_DEF_ALTERNATE_KIND_I);
 316     g_assert_cmpint(tmp->u.i, ==, 42);
 317     qapi_free_UserDefAlternate(tmp);
 318
 319     v = visitor_input_test_init(data, "'string'");
 320     visit_type_UserDefAlternate(v, &tmp, NULL, &error_abort);
 321     g_assert_cmpint(tmp->type, ==, USER_DEF_ALTERNATE_KIND_S);
 322     g_assert_cmpstr(tmp->u.s, ==, "string");
 323     qapi_free_UserDefAlternate(tmp);
 324
 325     v = visitor_input_test_init(data, "false");
 326     visit_type_UserDefAlternate(v, &tmp, NULL, &err);
 327     error_free_or_abort(&err);
 328     qapi_free_UserDefAlternate(tmp);
 329 }
 330
 331 static void test_visitor_in_alternate_number(TestInputVisitorData *data,
 332                                              const void *unused)
 333 {
 334     Visitor *v;
 335     Error *err = NULL;
 336     AltStrBool *asb;
 337     AltStrNum *asn;
 338     AltNumStr *ans;
 339     AltStrInt *asi;
 340     AltIntNum *ain;
 341     AltNumInt *ani;
 342
 343     /* Parsing an int */
 344
 345     v = visitor_input_test_init(data, "42");
 346     visit_type_AltStrBool(v, &asb, NULL, &err);
 347     error_free_or_abort(&err);
 348     qapi_free_AltStrBool(asb);
 349
 350     /* FIXME: Order of alternate should not affect semantics; asn should
 351      * parse the same as ans */
 352     v = visitor_input_test_init(data, "42");
 353     visit_type_AltStrNum(v, &asn, NULL, &err);
 354     /* FIXME g_assert_cmpint(asn->type, == ALT_STR_NUM_KIND_N); */
 355     /* FIXME g_assert_cmpfloat(asn->u.n, ==, 42); */
 356     error_free_or_abort(&err);
 357     qapi_free_AltStrNum(asn);
 358
 359     v = visitor_input_test_init(data, "42");
 360     visit_type_AltNumStr(v, &ans, NULL, &error_abort);
 361     g_assert_cmpint(ans->type, ==, ALT_NUM_STR_KIND_N);
 362     g_assert_cmpfloat(ans->u.n, ==, 42);
 363     qapi_free_AltNumStr(ans);
 364
 365     v = visitor_input_test_init(data, "42");
 366     visit_type_AltStrInt(v, &asi, NULL, &error_abort);
 367     g_assert_cmpint(asi->type, ==, ALT_STR_INT_KIND_I);
 368     g_assert_cmpint(asi->u.i, ==, 42);
 369     qapi_free_AltStrInt(asi);
 370
 371     v = visitor_input_test_init(data, "42");
 372     visit_type_AltIntNum(v, &ain, NULL, &error_abort);
 373     g_assert_cmpint(ain->type, ==, ALT_INT_NUM_KIND_I);
 374     g_assert_cmpint(ain->u.i, ==, 42);
 375     qapi_free_AltIntNum(ain);
 376
 377     v = visitor_input_test_init(data, "42");
 378     visit_type_AltNumInt(v, &ani, NULL, &error_abort);
 379     g_assert_cmpint(ani->type, ==, ALT_NUM_INT_KIND_I);
 380     g_assert_cmpint(ani->u.i, ==, 42);
 381     qapi_free_AltNumInt(ani);
 382
 383     /* Parsing a double */
 384
 385     v = visitor_input_test_init(data, "42.5");
 386     visit_type_AltStrBool(v, &asb, NULL, &err);
 387     error_free_or_abort(&err);
 388     qapi_free_AltStrBool(asb);
 389
 390     v = visitor_input_test_init(data, "42.5");
 391     visit_type_AltStrNum(v, &asn, NULL, &error_abort);
 392     g_assert_cmpint(asn->type, ==, ALT_STR_NUM_KIND_N);
 393     g_assert_cmpfloat(asn->u.n, ==, 42.5);
 394     qapi_free_AltStrNum(asn);
 395
 396     v = visitor_input_test_init(data, "42.5");
 397     visit_type_AltNumStr(v, &ans, NULL, &error_abort);
 398     g_assert_cmpint(ans->type, ==, ALT_NUM_STR_KIND_N);
 399     g_assert_cmpfloat(ans->u.n, ==, 42.5);
 400     qapi_free_AltNumStr(ans);
 401
 402     v = visitor_input_test_init(data, "42.5");
 403     visit_type_AltStrInt(v, &asi, NULL, &err);
 404     error_free_or_abort(&err);
 405     qapi_free_AltStrInt(asi);
 406
 407     v = visitor_input_test_init(data, "42.5");
 408     visit_type_AltIntNum(v, &ain, NULL, &error_abort);
 409     g_assert_cmpint(ain->type, ==, ALT_INT_NUM_KIND_N);
 410     g_assert_cmpfloat(ain->u.n, ==, 42.5);
 411     qapi_free_AltIntNum(ain);
 412
 413     v = visitor_input_test_init(data, "42.5");
 414     visit_type_AltNumInt(v, &ani, NULL, &error_abort);
 415     g_assert_cmpint(ani->type, ==, ALT_NUM_INT_KIND_N);
 416     g_assert_cmpfloat(ani->u.n, ==, 42.5);
 417     qapi_free_AltNumInt(ani);
 418 }
 419
 420 static void test_native_list_integer_helper(TestInputVisitorData *data,
 421                                             const void *unused,
 422                                             UserDefNativeListUnionKind kind)
 423 {
 424     UserDefNativeListUnion *cvalue = NULL;
 425     Visitor *v;
 426     GString *gstr_list = g_string_new("");
 427     GString *gstr_union = g_string_new("");
 428     int i;
 429
 430     for (i = 0; i < 32; i++) {
 431         g_string_append_printf(gstr_list, "%d", i);
 432         if (i != 31) {
 433             g_string_append(gstr_list, ", ");
 434         }
 435     }
 436     g_string_append_printf(gstr_union,  "{ 'type': '%s', 'data': [ %s ] }",
 437                            UserDefNativeListUnionKind_lookup[kind],
 438                            gstr_list->str);
 439     v = visitor_input_test_init_raw(data,  gstr_union->str);
 440
 441     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &error_abort);
 442     g_assert(cvalue != NULL);
 443     g_assert_cmpint(cvalue->type, ==, kind);
 444
 445     switch (kind) {
 446     case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: {
 447         intList *elem = NULL;
 448         for (i = 0, elem = cvalue->u.integer; elem; elem = elem->next, i++) {
 449             g_assert_cmpint(elem->value, ==, i);
 450         }
 451         break;
 452     }
 453     case USER_DEF_NATIVE_LIST_UNION_KIND_S8: {
 454         int8List *elem = NULL;
 455         for (i = 0, elem = cvalue->u.s8; elem; elem = elem->next, i++) {
 456             g_assert_cmpint(elem->value, ==, i);
 457         }
 458         break;
 459     }
 460     case USER_DEF_NATIVE_LIST_UNION_KIND_S16: {
 461         int16List *elem = NULL;
 462         for (i = 0, elem = cvalue->u.s16; elem; elem = elem->next, i++) {
 463             g_assert_cmpint(elem->value, ==, i);
 464         }
 465         break;
 466     }
 467     case USER_DEF_NATIVE_LIST_UNION_KIND_S32: {
 468         int32List *elem = NULL;
 469         for (i = 0, elem = cvalue->u.s32; elem; elem = elem->next, i++) {
 470             g_assert_cmpint(elem->value, ==, i);
 471         }
 472         break;
 473     }
 474     case USER_DEF_NATIVE_LIST_UNION_KIND_S64: {
 475         int64List *elem = NULL;
 476         for (i = 0, elem = cvalue->u.s64; elem; elem = elem->next, i++) {
 477             g_assert_cmpint(elem->value, ==, i);
 478         }
 479         break;
 480     }
 481     case USER_DEF_NATIVE_LIST_UNION_KIND_U8: {
 482         uint8List *elem = NULL;
 483         for (i = 0, elem = cvalue->u.u8; elem; elem = elem->next, i++) {
 484             g_assert_cmpint(elem->value, ==, i);
 485         }
 486         break;
 487     }
 488     case USER_DEF_NATIVE_LIST_UNION_KIND_U16: {
 489         uint16List *elem = NULL;
 490         for (i = 0, elem = cvalue->u.u16; elem; elem = elem->next, i++) {
 491             g_assert_cmpint(elem->value, ==, i);
 492         }
 493         break;
 494     }
 495     case USER_DEF_NATIVE_LIST_UNION_KIND_U32: {
 496         uint32List *elem = NULL;
 497         for (i = 0, elem = cvalue->u.u32; elem; elem = elem->next, i++) {
 498             g_assert_cmpint(elem->value, ==, i);
 499         }
 500         break;
 501     }
 502     case USER_DEF_NATIVE_LIST_UNION_KIND_U64: {
 503         uint64List *elem = NULL;
 504         for (i = 0, elem = cvalue->u.u64; elem; elem = elem->next, i++) {
 505             g_assert_cmpint(elem->value, ==, i);
 506         }
 507         break;
 508     }
 509     default:
 510         g_assert_not_reached();
 511     }
 512
 513     g_string_free(gstr_union, true);
 514     g_string_free(gstr_list, true);
 515     qapi_free_UserDefNativeListUnion(cvalue);
 516 }
 517
 518 static void test_visitor_in_native_list_int(TestInputVisitorData *data,
 519                                             const void *unused)
 520 {
 521     test_native_list_integer_helper(data, unused,
 522                                     USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER);
 523 }
 524
 525 static void test_visitor_in_native_list_int8(TestInputVisitorData *data,
 526                                              const void *unused)
 527 {
 528     test_native_list_integer_helper(data, unused,
 529                                     USER_DEF_NATIVE_LIST_UNION_KIND_S8);
 530 }
 531
 532 static void test_visitor_in_native_list_int16(TestInputVisitorData *data,
 533                                               const void *unused)
 534 {
 535     test_native_list_integer_helper(data, unused,
 536                                     USER_DEF_NATIVE_LIST_UNION_KIND_S16);
 537 }
 538
 539 static void test_visitor_in_native_list_int32(TestInputVisitorData *data,
 540                                               const void *unused)
 541 {
 542     test_native_list_integer_helper(data, unused,
 543                                     USER_DEF_NATIVE_LIST_UNION_KIND_S32);
 544 }
 545
 546 static void test_visitor_in_native_list_int64(TestInputVisitorData *data,
 547                                               const void *unused)
 548 {
 549     test_native_list_integer_helper(data, unused,
 550                                     USER_DEF_NATIVE_LIST_UNION_KIND_S64);
 551 }
 552
 553 static void test_visitor_in_native_list_uint8(TestInputVisitorData *data,
 554                                              const void *unused)
 555 {
 556     test_native_list_integer_helper(data, unused,
 557                                     USER_DEF_NATIVE_LIST_UNION_KIND_U8);
 558 }
 559
 560 static void test_visitor_in_native_list_uint16(TestInputVisitorData *data,
 561                                                const void *unused)
 562 {
 563     test_native_list_integer_helper(data, unused,
 564                                     USER_DEF_NATIVE_LIST_UNION_KIND_U16);
 565 }
 566
 567 static void test_visitor_in_native_list_uint32(TestInputVisitorData *data,
 568                                                const void *unused)
 569 {
 570     test_native_list_integer_helper(data, unused,
 571                                     USER_DEF_NATIVE_LIST_UNION_KIND_U32);
 572 }
 573
 574 static void test_visitor_in_native_list_uint64(TestInputVisitorData *data,
 575                                                const void *unused)
 576 {
 577     test_native_list_integer_helper(data, unused,
 578                                     USER_DEF_NATIVE_LIST_UNION_KIND_U64);
 579 }
 580
 581 static void test_visitor_in_native_list_bool(TestInputVisitorData *data,
 582                                             const void *unused)
 583 {
 584     UserDefNativeListUnion *cvalue = NULL;
 585     boolList *elem = NULL;
 586     Visitor *v;
 587     GString *gstr_list = g_string_new("");
 588     GString *gstr_union = g_string_new("");
 589     int i;
 590
 591     for (i = 0; i < 32; i++) {
 592         g_string_append_printf(gstr_list, "%s",
 593                                (i % 3 == 0) ? "true" : "false");
 594         if (i != 31) {
 595             g_string_append(gstr_list, ", ");
 596         }
 597     }
 598     g_string_append_printf(gstr_union,  "{ 'type': 'boolean', 'data': [ %s ] }",
 599                            gstr_list->str);
 600     v = visitor_input_test_init_raw(data,  gstr_union->str);
 601
 602     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &error_abort);
 603     g_assert(cvalue != NULL);
 604     g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN);
 605
 606     for (i = 0, elem = cvalue->u.boolean; elem; elem = elem->next, i++) {
 607         g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0);
 608     }
 609
 610     g_string_free(gstr_union, true);
 611     g_string_free(gstr_list, true);
 612     qapi_free_UserDefNativeListUnion(cvalue);
 613 }
 614
 615 static void test_visitor_in_native_list_string(TestInputVisitorData *data,
 616                                                const void *unused)
 617 {
 618     UserDefNativeListUnion *cvalue = NULL;
 619     strList *elem = NULL;
 620     Visitor *v;
 621     GString *gstr_list = g_string_new("");
 622     GString *gstr_union = g_string_new("");
 623     int i;
 624
 625     for (i = 0; i < 32; i++) {
 626         g_string_append_printf(gstr_list, "'%d'", i);
 627         if (i != 31) {
 628             g_string_append(gstr_list, ", ");
 629         }
 630     }
 631     g_string_append_printf(gstr_union,  "{ 'type': 'string', 'data': [ %s ] }",
 632                            gstr_list->str);
 633     v = visitor_input_test_init_raw(data,  gstr_union->str);
 634
 635     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &error_abort);
 636     g_assert(cvalue != NULL);
 637     g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_STRING);
 638
 639     for (i = 0, elem = cvalue->u.string; elem; elem = elem->next, i++) {
 640         gchar str[8];
 641         sprintf(str, "%d", i);
 642         g_assert_cmpstr(elem->value, ==, str);
 643     }
 644
 645     g_string_free(gstr_union, true);
 646     g_string_free(gstr_list, true);
 647     qapi_free_UserDefNativeListUnion(cvalue);
 648 }
 649
 650 #define DOUBLE_STR_MAX 16
 651
 652 static void test_visitor_in_native_list_number(TestInputVisitorData *data,
 653                                                const void *unused)
 654 {
 655     UserDefNativeListUnion *cvalue = NULL;
 656     numberList *elem = NULL;
 657     Visitor *v;
 658     GString *gstr_list = g_string_new("");
 659     GString *gstr_union = g_string_new("");
 660     int i;
 661
 662     for (i = 0; i < 32; i++) {
 663         g_string_append_printf(gstr_list, "%f", (double)i / 3);
 664         if (i != 31) {
 665             g_string_append(gstr_list, ", ");
 666         }
 667     }
 668     g_string_append_printf(gstr_union,  "{ 'type': 'number', 'data': [ %s ] }",
 669                            gstr_list->str);
 670     v = visitor_input_test_init_raw(data,  gstr_union->str);
 671
 672     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &error_abort);
 673     g_assert(cvalue != NULL);
 674     g_assert_cmpint(cvalue->type, ==, USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER);
 675
 676     for (i = 0, elem = cvalue->u.number; elem; elem = elem->next, i++) {
 677         GString *double_expected = g_string_new("");
 678         GString *double_actual = g_string_new("");
 679
 680         g_string_printf(double_expected, "%.6f", (double)i / 3);
 681         g_string_printf(double_actual, "%.6f", elem->value);
 682         g_assert_cmpstr(double_expected->str, ==, double_actual->str);
 683
 684         g_string_free(double_expected, true);
 685         g_string_free(double_actual, true);
 686     }
 687
 688     g_string_free(gstr_union, true);
 689     g_string_free(gstr_list, true);
 690     qapi_free_UserDefNativeListUnion(cvalue);
 691 }
 692
 693 static void input_visitor_test_add(const char *testpath,
 694                                    TestInputVisitorData *data,
 695                                    void (*test_func)(TestInputVisitorData *data, const void *user_data))
 696 {
 697     g_test_add(testpath, TestInputVisitorData, data, NULL, test_func,
 698                visitor_input_teardown);
 699 }
 700
 701 static void test_visitor_in_errors(TestInputVisitorData *data,
 702                                    const void *unused)
 703 {
 704     TestStruct *p = NULL;
 705     Error *err = NULL;
 706     Visitor *v;
 707     strList *q = NULL;
 708
 709     v = visitor_input_test_init(data, "{ 'integer': false, 'boolean': 'foo', "
 710                                 "'string': -42 }");
 711
 712     visit_type_TestStruct(v, &p, NULL, &err);
 713     error_free_or_abort(&err);
 714     /* FIXME - a failed parse should not leave a partially-allocated p
 715      * for us to clean up; this could cause callers to leak memory. */
 716     g_assert(p->string == NULL);
 717
 718     g_free(p->string);
 719     g_free(p);
 720
 721     v = visitor_input_test_init(data, "[ '1', '2', false, '3' ]");
 722     visit_type_strList(v, &q, NULL, &err);
 723     error_free_or_abort(&err);
 724     assert(q);
 725     qapi_free_strList(q);
 726 }
 727
 728 static void test_visitor_in_wrong_type(TestInputVisitorData *data,
 729                                        const void *unused)
 730 {
 731     TestStruct *p = NULL;
 732     Visitor *v;
 733     strList *q = NULL;
 734     int64_t i;
 735     Error *err = NULL;
 736
 737     /* Make sure arrays and structs cannot be confused */
 738
 739     v = visitor_input_test_init(data, "[]");
 740     visit_type_TestStruct(v, &p, NULL, &err);
 741     error_free_or_abort(&err);
 742     g_assert(!p);
 743
 744     v = visitor_input_test_init(data, "{}");
 745     visit_type_strList(v, &q, NULL, &err);
 746     error_free_or_abort(&err);
 747     assert(!q);
 748
 749     /* Make sure primitives and struct cannot be confused */
 750
 751     v = visitor_input_test_init(data, "1");
 752     visit_type_TestStruct(v, &p, NULL, &err);
 753     error_free_or_abort(&err);
 754     g_assert(!p);
 755
 756     v = visitor_input_test_init(data, "{}");
 757     visit_type_int(v, &i, NULL, &err);
 758     error_free_or_abort(&err);
 759
 760     /* Make sure primitives and arrays cannot be confused */
 761
 762     v = visitor_input_test_init(data, "1");
 763     visit_type_strList(v, &q, NULL, &err);
 764     error_free_or_abort(&err);
 765     assert(!q);
 766
 767     v = visitor_input_test_init(data, "[]");
 768     visit_type_int(v, &i, NULL, &err);
 769     error_free_or_abort(&err);
 770 }
 771
 772 int main(int argc, char **argv)
 773 {
 774     TestInputVisitorData in_visitor_data;
 775
 776     g_test_init(&argc, &argv, NULL);
 777
 778     input_visitor_test_add("/visitor/input/int",
 779                            &in_visitor_data, test_visitor_in_int);
 780     input_visitor_test_add("/visitor/input/int_overflow",
 781                            &in_visitor_data, test_visitor_in_int_overflow);
 782     input_visitor_test_add("/visitor/input/bool",
 783                            &in_visitor_data, test_visitor_in_bool);
 784     input_visitor_test_add("/visitor/input/number",
 785                            &in_visitor_data, test_visitor_in_number);
 786     input_visitor_test_add("/visitor/input/string",
 787                            &in_visitor_data, test_visitor_in_string);
 788     input_visitor_test_add("/visitor/input/enum",
 789                            &in_visitor_data, test_visitor_in_enum);
 790     input_visitor_test_add("/visitor/input/struct",
 791                            &in_visitor_data, test_visitor_in_struct);
 792     input_visitor_test_add("/visitor/input/struct-nested",
 793                            &in_visitor_data, test_visitor_in_struct_nested);
 794     input_visitor_test_add("/visitor/input/list",
 795                            &in_visitor_data, test_visitor_in_list);
 796     input_visitor_test_add("/visitor/input/any",
 797                            &in_visitor_data, test_visitor_in_any);
 798     input_visitor_test_add("/visitor/input/union-flat",
 799                            &in_visitor_data, test_visitor_in_union_flat);
 800     input_visitor_test_add("/visitor/input/alternate",
 801                            &in_visitor_data, test_visitor_in_alternate);
 802     input_visitor_test_add("/visitor/input/errors",
 803                            &in_visitor_data, test_visitor_in_errors);
 804     input_visitor_test_add("/visitor/input/wrong-type",
 805                            &in_visitor_data, test_visitor_in_wrong_type);
 806     input_visitor_test_add("/visitor/input/alternate-number",
 807                            &in_visitor_data, test_visitor_in_alternate_number);
 808     input_visitor_test_add("/visitor/input/native_list/int",
 809                            &in_visitor_data,
 810                            test_visitor_in_native_list_int);
 811     input_visitor_test_add("/visitor/input/native_list/int8",
 812                            &in_visitor_data,
 813                            test_visitor_in_native_list_int8);
 814     input_visitor_test_add("/visitor/input/native_list/int16",
 815                            &in_visitor_data,
 816                            test_visitor_in_native_list_int16);
 817     input_visitor_test_add("/visitor/input/native_list/int32",
 818                            &in_visitor_data,
 819                            test_visitor_in_native_list_int32);
 820     input_visitor_test_add("/visitor/input/native_list/int64",
 821                            &in_visitor_data,
 822                            test_visitor_in_native_list_int64);
 823     input_visitor_test_add("/visitor/input/native_list/uint8",
 824                            &in_visitor_data,
 825                            test_visitor_in_native_list_uint8);
 826     input_visitor_test_add("/visitor/input/native_list/uint16",
 827                            &in_visitor_data,
 828                            test_visitor_in_native_list_uint16);
 829     input_visitor_test_add("/visitor/input/native_list/uint32",
 830                            &in_visitor_data,
 831                            test_visitor_in_native_list_uint32);
 832     input_visitor_test_add("/visitor/input/native_list/uint64",
 833                            &in_visitor_data,
 834                            test_visitor_in_native_list_uint64);
 835     input_visitor_test_add("/visitor/input/native_list/bool",
 836                            &in_visitor_data, test_visitor_in_native_list_bool);
 837     input_visitor_test_add("/visitor/input/native_list/str",
 838                            &in_visitor_data,
 839                            test_visitor_in_native_list_string);
 840     input_visitor_test_add("/visitor/input/native_list/number",
 841                            &in_visitor_data,
 842                            test_visitor_in_native_list_number);
 843
 844     g_test_run();
 845
 846     return 0;
 847 }