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