tests/test-qobject-output-visitor.c

   1 /*
   2  * QObject Output Visitor unit-tests.
   3  *
   4  * Copyright (C) 2011-2016 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 "qemu/osdep.h"
  14
  15 #include "qemu-common.h"
  16 #include "qapi/error.h"
  17 #include "qapi/qobject-output-visitor.h"
  18 #include "test-qapi-visit.h"
  19 #include "qapi/qmp/qbool.h"
  20 #include "qapi/qmp/qdict.h"
  21 #include "qapi/qmp/qlist.h"
  22 #include "qapi/qmp/qnull.h"
  23 #include "qapi/qmp/qnum.h"
  24 #include "qapi/qmp/qstring.h"
  25
  26 typedef struct TestOutputVisitorData {
  27     Visitor *ov;
  28     QObject *obj;
  29 } TestOutputVisitorData;
  30
  31 static void visitor_output_setup(TestOutputVisitorData *data,
  32                                  const void *unused)
  33 {
  34     data->ov = qobject_output_visitor_new(&data->obj);
  35     g_assert(data->ov);
  36 }
  37
  38 static void visitor_output_teardown(TestOutputVisitorData *data,
  39                                     const void *unused)
  40 {
  41     visit_free(data->ov);
  42     data->ov = NULL;
  43     qobject_unref(data->obj);
  44     data->obj = NULL;
  45 }
  46
  47 static QObject *visitor_get(TestOutputVisitorData *data)
  48 {
  49     visit_complete(data->ov, &data->obj);
  50     g_assert(data->obj);
  51     return data->obj;
  52 }
  53
  54 static void visitor_reset(TestOutputVisitorData *data)
  55 {
  56     visitor_output_teardown(data, NULL);
  57     visitor_output_setup(data, NULL);
  58 }
  59
  60 static void test_visitor_out_int(TestOutputVisitorData *data,
  61                                  const void *unused)
  62 {
  63     int64_t value = -42;
  64     int64_t val;
  65     QNum *qnum;
  66
  67     visit_type_int(data->ov, NULL, &value, &error_abort);
  68
  69     qnum = qobject_to(QNum, visitor_get(data));
  70     g_assert(qnum);
  71     g_assert(qnum_get_try_int(qnum, &val));
  72     g_assert_cmpint(val, ==, value);
  73 }
  74
  75 static void test_visitor_out_bool(TestOutputVisitorData *data,
  76                                   const void *unused)
  77 {
  78     bool value = true;
  79     QBool *qbool;
  80
  81     visit_type_bool(data->ov, NULL, &value, &error_abort);
  82
  83     qbool = qobject_to(QBool, visitor_get(data));
  84     g_assert(qbool);
  85     g_assert(qbool_get_bool(qbool) == value);
  86 }
  87
  88 static void test_visitor_out_number(TestOutputVisitorData *data,
  89                                     const void *unused)
  90 {
  91     double value = 3.14;
  92     QNum *qnum;
  93
  94     visit_type_number(data->ov, NULL, &value, &error_abort);
  95
  96     qnum = qobject_to(QNum, visitor_get(data));
  97     g_assert(qnum);
  98     g_assert(qnum_get_double(qnum) == value);
  99 }
 100
 101 static void test_visitor_out_string(TestOutputVisitorData *data,
 102                                     const void *unused)
 103 {
 104     char *string = (char *) "Q E M U";
 105     QString *qstr;
 106
 107     visit_type_str(data->ov, NULL, &string, &error_abort);
 108
 109     qstr = qobject_to(QString, visitor_get(data));
 110     g_assert(qstr);
 111     g_assert_cmpstr(qstring_get_str(qstr), ==, string);
 112 }
 113
 114 static void test_visitor_out_no_string(TestOutputVisitorData *data,
 115                                        const void *unused)
 116 {
 117     char *string = NULL;
 118     QString *qstr;
 119
 120     /* A null string should return "" */
 121     visit_type_str(data->ov, NULL, &string, &error_abort);
 122
 123     qstr = qobject_to(QString, visitor_get(data));
 124     g_assert(qstr);
 125     g_assert_cmpstr(qstring_get_str(qstr), ==, "");
 126 }
 127
 128 static void test_visitor_out_enum(TestOutputVisitorData *data,
 129                                   const void *unused)
 130 {
 131     EnumOne i;
 132     QString *qstr;
 133
 134     for (i = 0; i < ENUM_ONE__MAX; i++) {
 135         visit_type_EnumOne(data->ov, "unused", &i, &error_abort);
 136
 137         qstr = qobject_to(QString, visitor_get(data));
 138         g_assert(qstr);
 139         g_assert_cmpstr(qstring_get_str(qstr), ==, EnumOne_str(i));
 140         visitor_reset(data);
 141     }
 142 }
 143
 144 static void test_visitor_out_struct(TestOutputVisitorData *data,
 145                                     const void *unused)
 146 {
 147     TestStruct test_struct = { .integer = 42,
 148                                .boolean = false,
 149                                .string = (char *) "foo"};
 150     TestStruct *p = &test_struct;
 151     QDict *qdict;
 152
 153     visit_type_TestStruct(data->ov, NULL, &p, &error_abort);
 154
 155     qdict = qobject_to(QDict, visitor_get(data));
 156     g_assert(qdict);
 157     g_assert_cmpint(qdict_size(qdict), ==, 3);
 158     g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 42);
 159     g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, false);
 160     g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "foo");
 161 }
 162
 163 static void test_visitor_out_struct_nested(TestOutputVisitorData *data,
 164                                            const void *unused)
 165 {
 166     int64_t value = 42;
 167     UserDefTwo *ud2;
 168     QDict *qdict, *dict1, *dict2, *dict3, *userdef;
 169     const char *string = "user def string";
 170     const char *strings[] = { "forty two", "forty three", "forty four",
 171                               "forty five" };
 172
 173     ud2 = g_malloc0(sizeof(*ud2));
 174     ud2->string0 = g_strdup(strings[0]);
 175
 176     ud2->dict1 = g_malloc0(sizeof(*ud2->dict1));
 177     ud2->dict1->string1 = g_strdup(strings[1]);
 178
 179     ud2->dict1->dict2 = g_malloc0(sizeof(*ud2->dict1->dict2));
 180     ud2->dict1->dict2->userdef = g_new0(UserDefOne, 1);
 181     ud2->dict1->dict2->userdef->string = g_strdup(string);
 182     ud2->dict1->dict2->userdef->integer = value;
 183     ud2->dict1->dict2->string = g_strdup(strings[2]);
 184
 185     ud2->dict1->dict3 = g_malloc0(sizeof(*ud2->dict1->dict3));
 186     ud2->dict1->has_dict3 = true;
 187     ud2->dict1->dict3->userdef = g_new0(UserDefOne, 1);
 188     ud2->dict1->dict3->userdef->string = g_strdup(string);
 189     ud2->dict1->dict3->userdef->integer = value;
 190     ud2->dict1->dict3->string = g_strdup(strings[3]);
 191
 192     visit_type_UserDefTwo(data->ov, "unused", &ud2, &error_abort);
 193
 194     qdict = qobject_to(QDict, visitor_get(data));
 195     g_assert(qdict);
 196     g_assert_cmpint(qdict_size(qdict), ==, 2);
 197     g_assert_cmpstr(qdict_get_str(qdict, "string0"), ==, strings[0]);
 198
 199     dict1 = qdict_get_qdict(qdict, "dict1");
 200     g_assert_cmpint(qdict_size(dict1), ==, 3);
 201     g_assert_cmpstr(qdict_get_str(dict1, "string1"), ==, strings[1]);
 202
 203     dict2 = qdict_get_qdict(dict1, "dict2");
 204     g_assert_cmpint(qdict_size(dict2), ==, 2);
 205     g_assert_cmpstr(qdict_get_str(dict2, "string"), ==, strings[2]);
 206     userdef = qdict_get_qdict(dict2, "userdef");
 207     g_assert_cmpint(qdict_size(userdef), ==, 2);
 208     g_assert_cmpint(qdict_get_int(userdef, "integer"), ==, value);
 209     g_assert_cmpstr(qdict_get_str(userdef, "string"), ==, string);
 210
 211     dict3 = qdict_get_qdict(dict1, "dict3");
 212     g_assert_cmpint(qdict_size(dict3), ==, 2);
 213     g_assert_cmpstr(qdict_get_str(dict3, "string"), ==, strings[3]);
 214     userdef = qdict_get_qdict(dict3, "userdef");
 215     g_assert_cmpint(qdict_size(userdef), ==, 2);
 216     g_assert_cmpint(qdict_get_int(userdef, "integer"), ==, value);
 217     g_assert_cmpstr(qdict_get_str(userdef, "string"), ==, string);
 218
 219     qapi_free_UserDefTwo(ud2);
 220 }
 221
 222 static void test_visitor_out_list(TestOutputVisitorData *data,
 223                                   const void *unused)
 224 {
 225     const char *value_str = "list value";
 226     TestStruct *value;
 227     TestStructList *head = NULL;
 228     const int max_items = 10;
 229     bool value_bool = true;
 230     int value_int = 10;
 231     QListEntry *entry;
 232     QList *qlist;
 233     int i;
 234
 235     /* Build the list in reverse order... */
 236     for (i = 0; i < max_items; i++) {
 237         value = g_malloc0(sizeof(*value));
 238         value->integer = value_int + (max_items - i - 1);
 239         value->boolean = value_bool;
 240         value->string = g_strdup(value_str);
 241
 242         QAPI_LIST_PREPEND(head, value);
 243     }
 244
 245     visit_type_TestStructList(data->ov, NULL, &head, &error_abort);
 246
 247     qlist = qobject_to(QList, visitor_get(data));
 248     g_assert(qlist);
 249     g_assert(!qlist_empty(qlist));
 250
 251     /* ...and ensure that the visitor sees it in order */
 252     i = 0;
 253     QLIST_FOREACH_ENTRY(qlist, entry) {
 254         QDict *qdict;
 255
 256         qdict = qobject_to(QDict, entry->value);
 257         g_assert(qdict);
 258         g_assert_cmpint(qdict_size(qdict), ==, 3);
 259         g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, value_int + i);
 260         g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, value_bool);
 261         g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, value_str);
 262         i++;
 263     }
 264     g_assert_cmpint(i, ==, max_items);
 265
 266     qapi_free_TestStructList(head);
 267 }
 268
 269 static void test_visitor_out_list_qapi_free(TestOutputVisitorData *data,
 270                                             const void *unused)
 271 {
 272     UserDefTwo *value;
 273     UserDefTwoList *head = NULL;
 274     const char string[] = "foo bar";
 275     int i, max_count = 1024;
 276
 277     for (i = 0; i < max_count; i++) {
 278         value = g_malloc0(sizeof(*value));
 279
 280         value->string0 = g_strdup(string);
 281         value->dict1 = g_new0(UserDefTwoDict, 1);
 282         value->dict1->string1 = g_strdup(string);
 283         value->dict1->dict2 = g_new0(UserDefTwoDictDict, 1);
 284         value->dict1->dict2->userdef = g_new0(UserDefOne, 1);
 285         value->dict1->dict2->userdef->string = g_strdup(string);
 286         value->dict1->dict2->userdef->integer = 42;
 287         value->dict1->dict2->string = g_strdup(string);
 288         value->dict1->has_dict3 = false;
 289
 290         QAPI_LIST_PREPEND(head, value);
 291     }
 292
 293     qapi_free_UserDefTwoList(head);
 294 }
 295
 296 static void test_visitor_out_any(TestOutputVisitorData *data,
 297                                  const void *unused)
 298 {
 299     QObject *qobj;
 300     QNum *qnum;
 301     QBool *qbool;
 302     QString *qstring;
 303     QDict *qdict;
 304     int64_t val;
 305
 306     qobj = QOBJECT(qnum_from_int(-42));
 307     visit_type_any(data->ov, NULL, &qobj, &error_abort);
 308     qnum = qobject_to(QNum, visitor_get(data));
 309     g_assert(qnum);
 310     g_assert(qnum_get_try_int(qnum, &val));
 311     g_assert_cmpint(val, ==, -42);
 312     qobject_unref(qobj);
 313
 314     visitor_reset(data);
 315     qdict = qdict_new();
 316     qdict_put_int(qdict, "integer", -42);
 317     qdict_put_bool(qdict, "boolean", true);
 318     qdict_put_str(qdict, "string", "foo");
 319     qobj = QOBJECT(qdict);
 320     visit_type_any(data->ov, NULL, &qobj, &error_abort);
 321     qobject_unref(qobj);
 322     qdict = qobject_to(QDict, visitor_get(data));
 323     g_assert(qdict);
 324     qnum = qobject_to(QNum, qdict_get(qdict, "integer"));
 325     g_assert(qnum);
 326     g_assert(qnum_get_try_int(qnum, &val));
 327     g_assert_cmpint(val, ==, -42);
 328     qbool = qobject_to(QBool, qdict_get(qdict, "boolean"));
 329     g_assert(qbool);
 330     g_assert(qbool_get_bool(qbool) == true);
 331     qstring = qobject_to(QString, qdict_get(qdict, "string"));
 332     g_assert(qstring);
 333     g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
 334 }
 335
 336 static void test_visitor_out_union_flat(TestOutputVisitorData *data,
 337                                         const void *unused)
 338 {
 339     QDict *qdict;
 340
 341     UserDefFlatUnion *tmp = g_malloc0(sizeof(UserDefFlatUnion));
 342     tmp->enum1 = ENUM_ONE_VALUE1;
 343     tmp->string = g_strdup("str");
 344     tmp->integer = 41;
 345     tmp->u.value1.boolean = true;
 346
 347     visit_type_UserDefFlatUnion(data->ov, NULL, &tmp, &error_abort);
 348     qdict = qobject_to(QDict, visitor_get(data));
 349     g_assert(qdict);
 350     g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value1");
 351     g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "str");
 352     g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 41);
 353     g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, true);
 354
 355     qapi_free_UserDefFlatUnion(tmp);
 356 }
 357
 358 static void test_visitor_out_alternate(TestOutputVisitorData *data,
 359                                        const void *unused)
 360 {
 361     UserDefAlternate *tmp;
 362     QNum *qnum;
 363     QString *qstr;
 364     QDict *qdict;
 365     int64_t val;
 366
 367     tmp = g_new0(UserDefAlternate, 1);
 368     tmp->type = QTYPE_QNUM;
 369     tmp->u.i = 42;
 370
 371     visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
 372     qnum = qobject_to(QNum, visitor_get(data));
 373     g_assert(qnum);
 374     g_assert(qnum_get_try_int(qnum, &val));
 375     g_assert_cmpint(val, ==, 42);
 376
 377     qapi_free_UserDefAlternate(tmp);
 378
 379     visitor_reset(data);
 380     tmp = g_new0(UserDefAlternate, 1);
 381     tmp->type = QTYPE_QSTRING;
 382     tmp->u.e = ENUM_ONE_VALUE1;
 383
 384     visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
 385     qstr = qobject_to(QString, visitor_get(data));
 386     g_assert(qstr);
 387     g_assert_cmpstr(qstring_get_str(qstr), ==, "value1");
 388
 389     qapi_free_UserDefAlternate(tmp);
 390
 391     visitor_reset(data);
 392     tmp = g_new0(UserDefAlternate, 1);
 393     tmp->type = QTYPE_QNULL;
 394     tmp->u.n = qnull();
 395
 396     visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
 397     g_assert_cmpint(qobject_type(visitor_get(data)), ==, QTYPE_QNULL);
 398
 399     qapi_free_UserDefAlternate(tmp);
 400
 401     visitor_reset(data);
 402     tmp = g_new0(UserDefAlternate, 1);
 403     tmp->type = QTYPE_QDICT;
 404     tmp->u.udfu.integer = 1;
 405     tmp->u.udfu.string = g_strdup("str");
 406     tmp->u.udfu.enum1 = ENUM_ONE_VALUE1;
 407     tmp->u.udfu.u.value1.boolean = true;
 408
 409     visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort);
 410     qdict = qobject_to(QDict, visitor_get(data));
 411     g_assert(qdict);
 412     g_assert_cmpint(qdict_size(qdict), ==, 4);
 413     g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 1);
 414     g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "str");
 415     g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value1");
 416     g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, true);
 417
 418     qapi_free_UserDefAlternate(tmp);
 419 }
 420
 421 static void test_visitor_out_null(TestOutputVisitorData *data,
 422                                   const void *unused)
 423 {
 424     QNull *null = NULL;
 425     QDict *qdict;
 426     QObject *nil;
 427
 428     visit_start_struct(data->ov, NULL, NULL, 0, &error_abort);
 429     visit_type_null(data->ov, "a", &null, &error_abort);
 430     visit_check_struct(data->ov, &error_abort);
 431     visit_end_struct(data->ov, NULL);
 432     qdict = qobject_to(QDict, visitor_get(data));
 433     g_assert(qdict);
 434     g_assert_cmpint(qdict_size(qdict), ==, 1);
 435     nil = qdict_get(qdict, "a");
 436     g_assert(nil);
 437     g_assert(qobject_type(nil) == QTYPE_QNULL);
 438 }
 439
 440 static void init_list_union(UserDefListUnion *cvalue)
 441 {
 442     int i;
 443     switch (cvalue->type) {
 444     case USER_DEF_LIST_UNION_KIND_INTEGER: {
 445         intList **tail = &cvalue->u.integer.data;
 446         for (i = 0; i < 32; i++) {
 447             QAPI_LIST_APPEND(tail, i);
 448         }
 449         break;
 450     }
 451     case USER_DEF_LIST_UNION_KIND_S8: {
 452         int8List **tail = &cvalue->u.s8.data;
 453         for (i = 0; i < 32; i++) {
 454             QAPI_LIST_APPEND(tail, i);
 455         }
 456         break;
 457     }
 458     case USER_DEF_LIST_UNION_KIND_S16: {
 459         int16List **tail = &cvalue->u.s16.data;
 460         for (i = 0; i < 32; i++) {
 461             QAPI_LIST_APPEND(tail, i);
 462         }
 463         break;
 464     }
 465     case USER_DEF_LIST_UNION_KIND_S32: {
 466         int32List **tail = &cvalue->u.s32.data;
 467         for (i = 0; i < 32; i++) {
 468             QAPI_LIST_APPEND(tail, i);
 469         }
 470         break;
 471     }
 472     case USER_DEF_LIST_UNION_KIND_S64: {
 473         int64List **tail = &cvalue->u.s64.data;
 474         for (i = 0; i < 32; i++) {
 475             QAPI_LIST_APPEND(tail, i);
 476         }
 477         break;
 478     }
 479     case USER_DEF_LIST_UNION_KIND_U8: {
 480         uint8List **tail = &cvalue->u.u8.data;
 481         for (i = 0; i < 32; i++) {
 482             QAPI_LIST_APPEND(tail, i);
 483         }
 484         break;
 485     }
 486     case USER_DEF_LIST_UNION_KIND_U16: {
 487         uint16List **tail = &cvalue->u.u16.data;
 488         for (i = 0; i < 32; i++) {
 489             QAPI_LIST_APPEND(tail, i);
 490         }
 491         break;
 492     }
 493     case USER_DEF_LIST_UNION_KIND_U32: {
 494         uint32List **tail = &cvalue->u.u32.data;
 495         for (i = 0; i < 32; i++) {
 496             QAPI_LIST_APPEND(tail, i);
 497         }
 498         break;
 499     }
 500     case USER_DEF_LIST_UNION_KIND_U64: {
 501         uint64List **tail = &cvalue->u.u64.data;
 502         for (i = 0; i < 32; i++) {
 503             QAPI_LIST_APPEND(tail, i);
 504         }
 505         break;
 506     }
 507     case USER_DEF_LIST_UNION_KIND_BOOLEAN: {
 508         boolList **tail = &cvalue->u.boolean.data;
 509         for (i = 0; i < 32; i++) {
 510             QAPI_LIST_APPEND(tail, QEMU_IS_ALIGNED(i, 3));
 511         }
 512         break;
 513     }
 514     case USER_DEF_LIST_UNION_KIND_STRING: {
 515         strList **tail = &cvalue->u.string.data;
 516         for (i = 0; i < 32; i++) {
 517             QAPI_LIST_APPEND(tail, g_strdup_printf("%d", i));
 518         }
 519         break;
 520     }
 521     case USER_DEF_LIST_UNION_KIND_NUMBER: {
 522         numberList **tail = &cvalue->u.number.data;
 523         for (i = 0; i < 32; i++) {
 524             QAPI_LIST_APPEND(tail, (double)i / 3);
 525         }
 526         break;
 527     }
 528     default:
 529         g_assert_not_reached();
 530     }
 531 }
 532
 533 static void check_list_union(QObject *qobj,
 534                              UserDefListUnionKind kind)
 535 {
 536     QDict *qdict;
 537     QList *qlist;
 538     int i;
 539
 540     qdict = qobject_to(QDict, qobj);
 541     g_assert(qdict);
 542     g_assert(qdict_haskey(qdict, "data"));
 543     qlist = qlist_copy(qobject_to(QList, qdict_get(qdict, "data")));
 544
 545     switch (kind) {
 546     case USER_DEF_LIST_UNION_KIND_U8:
 547     case USER_DEF_LIST_UNION_KIND_U16:
 548     case USER_DEF_LIST_UNION_KIND_U32:
 549     case USER_DEF_LIST_UNION_KIND_U64:
 550         for (i = 0; i < 32; i++) {
 551             QObject *tmp;
 552             QNum *qvalue;
 553             uint64_t val;
 554
 555             tmp = qlist_peek(qlist);
 556             g_assert(tmp);
 557             qvalue = qobject_to(QNum, tmp);
 558             g_assert(qnum_get_try_uint(qvalue, &val));
 559             g_assert_cmpint(val, ==, i);
 560             qobject_unref(qlist_pop(qlist));
 561         }
 562         break;
 563
 564     case USER_DEF_LIST_UNION_KIND_S8:
 565     case USER_DEF_LIST_UNION_KIND_S16:
 566     case USER_DEF_LIST_UNION_KIND_S32:
 567     case USER_DEF_LIST_UNION_KIND_S64:
 568         /*
 569          * All integer elements in JSON arrays get stored into QNums
 570          * when we convert to QObjects, so we can check them all in
 571          * the same fashion, so simply fall through here.
 572          */
 573     case USER_DEF_LIST_UNION_KIND_INTEGER:
 574         for (i = 0; i < 32; i++) {
 575             QObject *tmp;
 576             QNum *qvalue;
 577             int64_t val;
 578
 579             tmp = qlist_peek(qlist);
 580             g_assert(tmp);
 581             qvalue = qobject_to(QNum, tmp);
 582             g_assert(qnum_get_try_int(qvalue, &val));
 583             g_assert_cmpint(val, ==, i);
 584             qobject_unref(qlist_pop(qlist));
 585         }
 586         break;
 587     case USER_DEF_LIST_UNION_KIND_BOOLEAN:
 588         for (i = 0; i < 32; i++) {
 589             QObject *tmp;
 590             QBool *qvalue;
 591             tmp = qlist_peek(qlist);
 592             g_assert(tmp);
 593             qvalue = qobject_to(QBool, tmp);
 594             g_assert_cmpint(qbool_get_bool(qvalue), ==, i % 3 == 0);
 595             qobject_unref(qlist_pop(qlist));
 596         }
 597         break;
 598     case USER_DEF_LIST_UNION_KIND_STRING:
 599         for (i = 0; i < 32; i++) {
 600             QObject *tmp;
 601             QString *qvalue;
 602             gchar str[8];
 603             tmp = qlist_peek(qlist);
 604             g_assert(tmp);
 605             qvalue = qobject_to(QString, tmp);
 606             sprintf(str, "%d", i);
 607             g_assert_cmpstr(qstring_get_str(qvalue), ==, str);
 608             qobject_unref(qlist_pop(qlist));
 609         }
 610         break;
 611     case USER_DEF_LIST_UNION_KIND_NUMBER:
 612         for (i = 0; i < 32; i++) {
 613             QObject *tmp;
 614             QNum *qvalue;
 615             GString *double_expected = g_string_new("");
 616             GString *double_actual = g_string_new("");
 617
 618             tmp = qlist_peek(qlist);
 619             g_assert(tmp);
 620             qvalue = qobject_to(QNum, tmp);
 621             g_string_printf(double_expected, "%.6f", (double)i / 3);
 622             g_string_printf(double_actual, "%.6f", qnum_get_double(qvalue));
 623             g_assert_cmpstr(double_actual->str, ==, double_expected->str);
 624
 625             qobject_unref(qlist_pop(qlist));
 626             g_string_free(double_expected, true);
 627             g_string_free(double_actual, true);
 628         }
 629         break;
 630     default:
 631         g_assert_not_reached();
 632     }
 633     qobject_unref(qlist);
 634 }
 635
 636 static void test_list_union(TestOutputVisitorData *data,
 637                             const void *unused,
 638                             UserDefListUnionKind kind)
 639 {
 640     UserDefListUnion *cvalue = g_new0(UserDefListUnion, 1);
 641     QObject *obj;
 642
 643     cvalue->type = kind;
 644     init_list_union(cvalue);
 645
 646     visit_type_UserDefListUnion(data->ov, NULL, &cvalue, &error_abort);
 647
 648     obj = visitor_get(data);
 649     check_list_union(obj, cvalue->type);
 650     qapi_free_UserDefListUnion(cvalue);
 651 }
 652
 653 static void test_visitor_out_list_union_int(TestOutputVisitorData *data,
 654                                             const void *unused)
 655 {
 656     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_INTEGER);
 657 }
 658
 659 static void test_visitor_out_list_union_int8(TestOutputVisitorData *data,
 660                                              const void *unused)
 661 {
 662     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S8);
 663 }
 664
 665 static void test_visitor_out_list_union_int16(TestOutputVisitorData *data,
 666                                               const void *unused)
 667 {
 668     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S16);
 669 }
 670
 671 static void test_visitor_out_list_union_int32(TestOutputVisitorData *data,
 672                                               const void *unused)
 673 {
 674     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S32);
 675 }
 676
 677 static void test_visitor_out_list_union_int64(TestOutputVisitorData *data,
 678                                               const void *unused)
 679 {
 680     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_S64);
 681 }
 682
 683 static void test_visitor_out_list_union_uint8(TestOutputVisitorData *data,
 684                                               const void *unused)
 685 {
 686     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U8);
 687 }
 688
 689 static void test_visitor_out_list_union_uint16(TestOutputVisitorData *data,
 690                                                const void *unused)
 691 {
 692     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U16);
 693 }
 694
 695 static void test_visitor_out_list_union_uint32(TestOutputVisitorData *data,
 696                                                const void *unused)
 697 {
 698     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U32);
 699 }
 700
 701 static void test_visitor_out_list_union_uint64(TestOutputVisitorData *data,
 702                                                const void *unused)
 703 {
 704     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_U64);
 705 }
 706
 707 static void test_visitor_out_list_union_bool(TestOutputVisitorData *data,
 708                                              const void *unused)
 709 {
 710     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_BOOLEAN);
 711 }
 712
 713 static void test_visitor_out_list_union_str(TestOutputVisitorData *data,
 714                                             const void *unused)
 715 {
 716     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_STRING);
 717 }
 718
 719 static void test_visitor_out_list_union_number(TestOutputVisitorData *data,
 720                                                const void *unused)
 721 {
 722     test_list_union(data, unused, USER_DEF_LIST_UNION_KIND_NUMBER);
 723 }
 724
 725 static void output_visitor_test_add(const char *testpath,
 726                                     TestOutputVisitorData *data,
 727                                     void (*test_func)(TestOutputVisitorData *data, const void *user_data))
 728 {
 729     g_test_add(testpath, TestOutputVisitorData, data, visitor_output_setup,
 730                test_func, visitor_output_teardown);
 731 }
 732
 733 int main(int argc, char **argv)
 734 {
 735     TestOutputVisitorData out_visitor_data;
 736
 737     g_test_init(&argc, &argv, NULL);
 738
 739     output_visitor_test_add("/visitor/output/int",
 740                             &out_visitor_data, test_visitor_out_int);
 741     output_visitor_test_add("/visitor/output/bool",
 742                             &out_visitor_data, test_visitor_out_bool);
 743     output_visitor_test_add("/visitor/output/number",
 744                             &out_visitor_data, test_visitor_out_number);
 745     output_visitor_test_add("/visitor/output/string",
 746                             &out_visitor_data, test_visitor_out_string);
 747     output_visitor_test_add("/visitor/output/no-string",
 748                             &out_visitor_data, test_visitor_out_no_string);
 749     output_visitor_test_add("/visitor/output/enum",
 750                             &out_visitor_data, test_visitor_out_enum);
 751     output_visitor_test_add("/visitor/output/struct",
 752                             &out_visitor_data, test_visitor_out_struct);
 753     output_visitor_test_add("/visitor/output/struct-nested",
 754                             &out_visitor_data, test_visitor_out_struct_nested);
 755     output_visitor_test_add("/visitor/output/list",
 756                             &out_visitor_data, test_visitor_out_list);
 757     output_visitor_test_add("/visitor/output/any",
 758                             &out_visitor_data, test_visitor_out_any);
 759     output_visitor_test_add("/visitor/output/list-qapi-free",
 760                             &out_visitor_data, test_visitor_out_list_qapi_free);
 761     output_visitor_test_add("/visitor/output/union-flat",
 762                             &out_visitor_data, test_visitor_out_union_flat);
 763     output_visitor_test_add("/visitor/output/alternate",
 764                             &out_visitor_data, test_visitor_out_alternate);
 765     output_visitor_test_add("/visitor/output/null",
 766                             &out_visitor_data, test_visitor_out_null);
 767     output_visitor_test_add("/visitor/output/list_union/int",
 768                             &out_visitor_data,
 769                             test_visitor_out_list_union_int);
 770     output_visitor_test_add("/visitor/output/list_union/int8",
 771                             &out_visitor_data,
 772                             test_visitor_out_list_union_int8);
 773     output_visitor_test_add("/visitor/output/list_union/int16",
 774                             &out_visitor_data,
 775                             test_visitor_out_list_union_int16);
 776     output_visitor_test_add("/visitor/output/list_union/int32",
 777                             &out_visitor_data,
 778                             test_visitor_out_list_union_int32);
 779     output_visitor_test_add("/visitor/output/list_union/int64",
 780                             &out_visitor_data,
 781                             test_visitor_out_list_union_int64);
 782     output_visitor_test_add("/visitor/output/list_union/uint8",
 783                             &out_visitor_data,
 784                             test_visitor_out_list_union_uint8);
 785     output_visitor_test_add("/visitor/output/list_union/uint16",
 786                             &out_visitor_data,
 787                             test_visitor_out_list_union_uint16);
 788     output_visitor_test_add("/visitor/output/list_union/uint32",
 789                             &out_visitor_data,
 790                             test_visitor_out_list_union_uint32);
 791     output_visitor_test_add("/visitor/output/list_union/uint64",
 792                             &out_visitor_data,
 793                             test_visitor_out_list_union_uint64);
 794     output_visitor_test_add("/visitor/output/list_union/bool",
 795                             &out_visitor_data,
 796                             test_visitor_out_list_union_bool);
 797     output_visitor_test_add("/visitor/output/list_union/string",
 798                             &out_visitor_data,
 799                             test_visitor_out_list_union_str);
 800     output_visitor_test_add("/visitor/output/list_union/number",
 801                             &out_visitor_data,
 802                             test_visitor_out_list_union_number);
 803
 804     g_test_run();
 805
 806     return 0;
 807 }