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