tests/unit/test-qobject-input-visitor.c

   1 /*
   2  * QObject Input Visitor unit-tests.
   3  *
   4  * Copyright (C) 2011-2016 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Luiz Capitulino <lcapitulino@redhat.com>
   8  *  Paolo Bonzini <pbonzini@redhat.com>
   9  *
  10  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  11  * See the COPYING file in the top-level directory.
  12  */
  13
  14 #include "qemu/osdep.h"
  15
  16 #include "qemu-common.h"
  17 #include "qapi/error.h"
  18 #include "qapi/qapi-visit-introspect.h"
  19 #include "qapi/qobject-input-visitor.h"
  20 #include "test-qapi-visit.h"
  21 #include "qapi/qmp/qbool.h"
  22 #include "qapi/qmp/qdict.h"
  23 #include "qapi/qmp/qnull.h"
  24 #include "qapi/qmp/qnum.h"
  25 #include "qapi/qmp/qstring.h"
  26 #include "qapi/qmp/qjson.h"
  27 #include "test-qapi-introspect.h"
  28 #include "qapi/qapi-introspect.h"
  29
  30 typedef struct TestInputVisitorData {
  31     QObject *obj;
  32     Visitor *qiv;
  33 } TestInputVisitorData;
  34
  35 static void visitor_input_teardown(TestInputVisitorData *data,
  36                                    const void *unused)
  37 {
  38     qobject_unref(data->obj);
  39     data->obj = NULL;
  40
  41     if (data->qiv) {
  42         visit_free(data->qiv);
  43         data->qiv = NULL;
  44     }
  45 }
  46
  47 /* The various test_init functions are provided instead of a test setup
  48    function so that the JSON string used by the tests are kept in the test
  49    functions (and not in main()). */
  50
  51 static Visitor *test_init_internal(TestInputVisitorData *data, bool keyval,
  52                                    QObject *obj)
  53 {
  54     visitor_input_teardown(data, NULL);
  55
  56     data->obj = obj;
  57
  58     if (keyval) {
  59         data->qiv = qobject_input_visitor_new_keyval(data->obj);
  60     } else {
  61         data->qiv = qobject_input_visitor_new(data->obj);
  62     }
  63     g_assert(data->qiv);
  64     return data->qiv;
  65 }
  66
  67 static GCC_FMT_ATTR(3, 4)
  68 Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
  69                                       bool keyval,
  70                                       const char *json_string, ...)
  71 {
  72     Visitor *v;
  73     va_list ap;
  74
  75     va_start(ap, json_string);
  76     v = test_init_internal(data, keyval,
  77                            qobject_from_vjsonf_nofail(json_string, ap));
  78     va_end(ap);
  79     return v;
  80 }
  81
  82 static GCC_FMT_ATTR(2, 3)
  83 Visitor *visitor_input_test_init(TestInputVisitorData *data,
  84                                  const char *json_string, ...)
  85 {
  86     Visitor *v;
  87     va_list ap;
  88
  89     va_start(ap, json_string);
  90     v = test_init_internal(data, false,
  91                            qobject_from_vjsonf_nofail(json_string, ap));
  92     va_end(ap);
  93     return v;
  94 }
  95
  96 /* similar to visitor_input_test_init(), but does not expect a string
  97  * literal/format json_string argument and so can be used for
  98  * programatically generated strings (and we can't pass in programatically
  99  * generated strings via %s format parameters since qobject_from_jsonv()
 100  * will wrap those in double-quotes and treat the entire object as a
 101  * string)
 102  */
 103 static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
 104                                             const char *json_string)
 105 {
 106     return test_init_internal(data, false,
 107                               qobject_from_json(json_string, &error_abort));
 108 }
 109
 110 static void test_visitor_in_int(TestInputVisitorData *data,
 111                                 const void *unused)
 112 {
 113     int64_t res = 0;
 114     double dbl;
 115     int value = -42;
 116     Visitor *v;
 117
 118     v = visitor_input_test_init(data, "%d", value);
 119
 120     visit_type_int(v, NULL, &res, &error_abort);
 121     g_assert_cmpint(res, ==, value);
 122
 123     visit_type_number(v, NULL, &dbl, &error_abort);
 124     g_assert_cmpfloat(dbl, ==, -42.0);
 125 }
 126
 127 static void test_visitor_in_uint(TestInputVisitorData *data,
 128                                 const void *unused)
 129 {
 130     uint64_t res = 0;
 131     int64_t i64;
 132     double dbl;
 133     int value = 42;
 134     Visitor *v;
 135
 136     v = visitor_input_test_init(data, "%d", value);
 137
 138     visit_type_uint64(v, NULL, &res, &error_abort);
 139     g_assert_cmpuint(res, ==, (uint64_t)value);
 140
 141     visit_type_int(v, NULL, &i64, &error_abort);
 142     g_assert_cmpint(i64, ==, value);
 143
 144     visit_type_number(v, NULL, &dbl, &error_abort);
 145     g_assert_cmpfloat(dbl, ==, value);
 146
 147     /* BUG: value between INT64_MIN and -1 accepted modulo 2^64 */
 148     v = visitor_input_test_init(data, "%d", -value);
 149
 150     visit_type_uint64(v, NULL, &res, &error_abort);
 151     g_assert_cmpuint(res, ==, (uint64_t)-value);
 152
 153     v = visitor_input_test_init(data, "18446744073709551574");
 154
 155     visit_type_uint64(v, NULL, &res, &error_abort);
 156     g_assert_cmpuint(res, ==, 18446744073709551574U);
 157
 158     visit_type_number(v, NULL, &dbl, &error_abort);
 159     g_assert_cmpfloat(dbl, ==, 18446744073709552000.0);
 160 }
 161
 162 static void test_visitor_in_int_overflow(TestInputVisitorData *data,
 163                                          const void *unused)
 164 {
 165     int64_t res = 0;
 166     Error *err = NULL;
 167     Visitor *v;
 168
 169     /*
 170      * This will overflow a QNUM_I64, so should be deserialized into a
 171      * QNUM_DOUBLE field instead, leading to an error if we pass it to
 172      * visit_type_int().  Confirm this.
 173      */
 174     v = visitor_input_test_init(data, "%f", DBL_MAX);
 175
 176     visit_type_int(v, NULL, &res, &err);
 177     error_free_or_abort(&err);
 178 }
 179
 180 static void test_visitor_in_int_keyval(TestInputVisitorData *data,
 181                                        const void *unused)
 182 {
 183     int64_t res = 0, value = -42;
 184     Error *err = NULL;
 185     Visitor *v;
 186
 187     v = visitor_input_test_init_full(data, true, "%" PRId64, value);
 188     visit_type_int(v, NULL, &res, &err);
 189     error_free_or_abort(&err);
 190 }
 191
 192 static void test_visitor_in_int_str_keyval(TestInputVisitorData *data,
 193                                            const void *unused)
 194 {
 195     int64_t res = 0, value = -42;
 196     Visitor *v;
 197
 198     v = visitor_input_test_init_full(data, true, "\"-42\"");
 199
 200     visit_type_int(v, NULL, &res, &error_abort);
 201     g_assert_cmpint(res, ==, value);
 202 }
 203
 204 static void test_visitor_in_int_str_fail(TestInputVisitorData *data,
 205                                          const void *unused)
 206 {
 207     int64_t res = 0;
 208     Visitor *v;
 209     Error *err = NULL;
 210
 211     v = visitor_input_test_init(data, "\"-42\"");
 212
 213     visit_type_int(v, NULL, &res, &err);
 214     error_free_or_abort(&err);
 215 }
 216
 217 static void test_visitor_in_bool(TestInputVisitorData *data,
 218                                  const void *unused)
 219 {
 220     bool res = false;
 221     Visitor *v;
 222
 223     v = visitor_input_test_init(data, "true");
 224
 225     visit_type_bool(v, NULL, &res, &error_abort);
 226     g_assert_cmpint(res, ==, true);
 227 }
 228
 229 static void test_visitor_in_bool_keyval(TestInputVisitorData *data,
 230                                         const void *unused)
 231 {
 232     bool res = false;
 233     Error *err = NULL;
 234     Visitor *v;
 235
 236     v = visitor_input_test_init_full(data, true, "true");
 237
 238     visit_type_bool(v, NULL, &res, &err);
 239     error_free_or_abort(&err);
 240 }
 241
 242 static void test_visitor_in_bool_str_keyval(TestInputVisitorData *data,
 243                                             const void *unused)
 244 {
 245     bool res = false;
 246     Visitor *v;
 247
 248     v = visitor_input_test_init_full(data, true, "\"on\"");
 249
 250     visit_type_bool(v, NULL, &res, &error_abort);
 251     g_assert_cmpint(res, ==, true);
 252 }
 253
 254 static void test_visitor_in_bool_str_fail(TestInputVisitorData *data,
 255                                           const void *unused)
 256 {
 257     bool res = false;
 258     Visitor *v;
 259     Error *err = NULL;
 260
 261     v = visitor_input_test_init(data, "\"true\"");
 262
 263     visit_type_bool(v, NULL, &res, &err);
 264     error_free_or_abort(&err);
 265 }
 266
 267 static void test_visitor_in_number(TestInputVisitorData *data,
 268                                    const void *unused)
 269 {
 270     double res = 0, value = 3.14;
 271     Visitor *v;
 272
 273     v = visitor_input_test_init(data, "%f", value);
 274
 275     visit_type_number(v, NULL, &res, &error_abort);
 276     g_assert_cmpfloat(res, ==, value);
 277 }
 278
 279 static void test_visitor_in_large_number(TestInputVisitorData *data,
 280                                          const void *unused)
 281 {
 282     Error *err = NULL;
 283     double res = 0;
 284     int64_t i64;
 285     uint64_t u64;
 286     Visitor *v;
 287
 288     v = visitor_input_test_init(data, "-18446744073709551616"); /* -2^64 */
 289
 290     visit_type_number(v, NULL, &res, &error_abort);
 291     g_assert_cmpfloat(res, ==, -18446744073709552e3);
 292
 293     visit_type_int(v, NULL, &i64, &err);
 294     error_free_or_abort(&err);
 295
 296     visit_type_uint64(v, NULL, &u64, &err);
 297     error_free_or_abort(&err);
 298 }
 299
 300 static void test_visitor_in_number_keyval(TestInputVisitorData *data,
 301                                           const void *unused)
 302 {
 303     double res = 0, value = 3.14;
 304     Error *err = NULL;
 305     Visitor *v;
 306
 307     v = visitor_input_test_init_full(data, true, "%f", value);
 308
 309     visit_type_number(v, NULL, &res, &err);
 310     error_free_or_abort(&err);
 311 }
 312
 313 static void test_visitor_in_number_str_keyval(TestInputVisitorData *data,
 314                                               const void *unused)
 315 {
 316     double res = 0, value = 3.14;
 317     Visitor *v;
 318     Error *err = NULL;
 319
 320     v = visitor_input_test_init_full(data, true, "\"3.14\"");
 321
 322     visit_type_number(v, NULL, &res, &error_abort);
 323     g_assert_cmpfloat(res, ==, value);
 324
 325     v = visitor_input_test_init_full(data, true, "\"inf\"");
 326
 327     visit_type_number(v, NULL, &res, &err);
 328     error_free_or_abort(&err);
 329 }
 330
 331 static void test_visitor_in_number_str_fail(TestInputVisitorData *data,
 332                                             const void *unused)
 333 {
 334     double res = 0;
 335     Visitor *v;
 336     Error *err = NULL;
 337
 338     v = visitor_input_test_init(data, "\"3.14\"");
 339
 340     visit_type_number(v, NULL, &res, &err);
 341     error_free_or_abort(&err);
 342 }
 343
 344 static void test_visitor_in_size_str_keyval(TestInputVisitorData *data,
 345                                             const void *unused)
 346 {
 347     uint64_t res, value = 500 * 1024 * 1024;
 348     Visitor *v;
 349
 350     v = visitor_input_test_init_full(data, true, "\"500M\"");
 351
 352     visit_type_size(v, NULL, &res, &error_abort);
 353     g_assert_cmpfloat(res, ==, value);
 354 }
 355
 356 static void test_visitor_in_size_str_fail(TestInputVisitorData *data,
 357                                           const void *unused)
 358 {
 359     uint64_t res = 0;
 360     Visitor *v;
 361     Error *err = NULL;
 362
 363     v = visitor_input_test_init(data, "\"500M\"");
 364
 365     visit_type_size(v, NULL, &res, &err);
 366     error_free_or_abort(&err);
 367 }
 368
 369 static void test_visitor_in_string(TestInputVisitorData *data,
 370                                    const void *unused)
 371 {
 372     char *res = NULL, *value = (char *) "Q E M U";
 373     Visitor *v;
 374
 375     v = visitor_input_test_init(data, "%s", value);
 376
 377     visit_type_str(v, NULL, &res, &error_abort);
 378     g_assert_cmpstr(res, ==, value);
 379
 380     g_free(res);
 381 }
 382
 383 static void test_visitor_in_enum(TestInputVisitorData *data,
 384                                  const void *unused)
 385 {
 386     Visitor *v;
 387     EnumOne i;
 388
 389     for (i = 0; i < ENUM_ONE__MAX; i++) {
 390         EnumOne res = -1;
 391
 392         v = visitor_input_test_init(data, "%s", EnumOne_str(i));
 393
 394         visit_type_EnumOne(v, NULL, &res, &error_abort);
 395         g_assert_cmpint(i, ==, res);
 396     }
 397 }
 398
 399
 400 static void test_visitor_in_struct(TestInputVisitorData *data,
 401                                    const void *unused)
 402 {
 403     TestStruct *p = NULL;
 404     Visitor *v;
 405
 406     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 407
 408     visit_type_TestStruct(v, NULL, &p, &error_abort);
 409     g_assert_cmpint(p->integer, ==, -42);
 410     g_assert(p->boolean == true);
 411     g_assert_cmpstr(p->string, ==, "foo");
 412
 413     g_free(p->string);
 414     g_free(p);
 415 }
 416
 417 static void test_visitor_in_struct_nested(TestInputVisitorData *data,
 418                                           const void *unused)
 419 {
 420     g_autoptr(UserDefTwo) udp = NULL;
 421     Visitor *v;
 422
 423     v = visitor_input_test_init(data, "{ 'string0': 'string0', "
 424                                 "'dict1': { 'string1': 'string1', "
 425                                 "'dict2': { 'userdef': { 'integer': 42, "
 426                                 "'string': 'string' }, 'string': 'string2'}}}");
 427
 428     visit_type_UserDefTwo(v, NULL, &udp, &error_abort);
 429
 430     g_assert_cmpstr(udp->string0, ==, "string0");
 431     g_assert_cmpstr(udp->dict1->string1, ==, "string1");
 432     g_assert_cmpint(udp->dict1->dict2->userdef->integer, ==, 42);
 433     g_assert_cmpstr(udp->dict1->dict2->userdef->string, ==, "string");
 434     g_assert_cmpstr(udp->dict1->dict2->string, ==, "string2");
 435     g_assert(udp->dict1->has_dict3 == false);
 436 }
 437
 438 static void test_visitor_in_list(TestInputVisitorData *data,
 439                                  const void *unused)
 440 {
 441     UserDefOneList *item, *head = NULL;
 442     Visitor *v;
 443     int i;
 444
 445     v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
 446
 447     visit_type_UserDefOneList(v, NULL, &head, &error_abort);
 448     g_assert(head != NULL);
 449
 450     for (i = 0, item = head; item; item = item->next, i++) {
 451         char string[12];
 452
 453         snprintf(string, sizeof(string), "string%d", i);
 454         g_assert_cmpstr(item->value->string, ==, string);
 455         g_assert_cmpint(item->value->integer, ==, 42 + i);
 456     }
 457
 458     qapi_free_UserDefOneList(head);
 459     head = NULL;
 460
 461     /* An empty list is valid */
 462     v = visitor_input_test_init(data, "[]");
 463     visit_type_UserDefOneList(v, NULL, &head, &error_abort);
 464     g_assert(!head);
 465 }
 466
 467 static void test_visitor_in_list_struct(TestInputVisitorData *data,
 468                                         const void *unused)
 469 {
 470     const char *int_member[] = {
 471         "integer", "s8", "s16", "s32", "s64", "u8", "u16", "u32", "u64" };
 472     g_autoptr(GString) json = g_string_new("");
 473     int i, j;
 474     const char *sep;
 475     g_autoptr(ArrayStruct) arrs = NULL;
 476     Visitor *v;
 477     intList *int_list;
 478     int8List *s8_list;
 479     int16List *s16_list;
 480     int32List *s32_list;
 481     int64List *s64_list;
 482     uint8List *u8_list;
 483     uint16List *u16_list;
 484     uint32List *u32_list;
 485     uint64List *u64_list;
 486     numberList *num_list;
 487     boolList *bool_list;
 488     strList *str_list;
 489
 490     g_string_append_printf(json, "{");
 491
 492     for (i = 0; i < G_N_ELEMENTS(int_member); i++) {
 493         g_string_append_printf(json, "'%s': [", int_member[i]);
 494         sep = "";
 495         for (j = 0; j < 32; j++) {
 496             g_string_append_printf(json, "%s%d", sep, j);
 497             sep = ", ";
 498         }
 499         g_string_append_printf(json, "], ");
 500     }
 501
 502     g_string_append_printf(json, "'number': [");
 503     sep = "";
 504     for (i = 0; i < 32; i++) {
 505         g_string_append_printf(json, "%s%f", sep, (double)i / 3);
 506         sep = ", ";
 507     }
 508     g_string_append_printf(json, "], ");
 509
 510     g_string_append_printf(json, "'boolean': [");
 511     sep = "";
 512     for (i = 0; i < 32; i++) {
 513         g_string_append_printf(json, "%s%s",
 514                                sep, i % 3 == 0 ? "true" : "false");
 515         sep = ", ";
 516     }
 517     g_string_append_printf(json, "], ");
 518
 519     g_string_append_printf(json, "'string': [");
 520     sep = "";
 521     for (i = 0; i < 32; i++) {
 522         g_string_append_printf(json, "%s'%d'", sep, i);
 523         sep = ", ";
 524     }
 525     g_string_append_printf(json, "]");
 526
 527     g_string_append_printf(json, "}");
 528
 529     v = visitor_input_test_init_raw(data, json->str);
 530     visit_type_ArrayStruct(v, NULL, &arrs, &error_abort);
 531
 532     i = 0;
 533     for (int_list = arrs->integer; int_list; int_list = int_list->next) {
 534         g_assert_cmpint(int_list->value, ==, i);
 535         i++;
 536     }
 537
 538     i = 0;
 539     for (s8_list = arrs->s8; s8_list; s8_list = s8_list->next) {
 540         g_assert_cmpint(s8_list->value, ==, i);
 541         i++;
 542     }
 543
 544     i = 0;
 545     for (s16_list = arrs->s16; s16_list; s16_list = s16_list->next) {
 546         g_assert_cmpint(s16_list->value, ==, i);
 547         i++;
 548     }
 549
 550     i = 0;
 551     for (s32_list = arrs->s32; s32_list; s32_list = s32_list->next) {
 552         g_assert_cmpint(s32_list->value, ==, i);
 553         i++;
 554     }
 555
 556     i = 0;
 557     for (s64_list = arrs->s64; s64_list; s64_list = s64_list->next) {
 558         g_assert_cmpint(s64_list->value, ==, i);
 559         i++;
 560     }
 561
 562     i = 0;
 563     for (u8_list = arrs->u8; u8_list; u8_list = u8_list->next) {
 564         g_assert_cmpint(u8_list->value, ==, i);
 565         i++;
 566     }
 567
 568     i = 0;
 569     for (u16_list = arrs->u16; u16_list; u16_list = u16_list->next) {
 570         g_assert_cmpint(u16_list->value, ==, i);
 571         i++;
 572     }
 573
 574     i = 0;
 575     for (u32_list = arrs->u32; u32_list; u32_list = u32_list->next) {
 576         g_assert_cmpint(u32_list->value, ==, i);
 577         i++;
 578     }
 579
 580     i = 0;
 581     for (u64_list = arrs->u64; u64_list; u64_list = u64_list->next) {
 582         g_assert_cmpint(u64_list->value, ==, i);
 583         i++;
 584     }
 585
 586     i = 0;
 587     for (num_list = arrs->number; num_list; num_list = num_list->next) {
 588         char expected[32], actual[32];
 589
 590         sprintf(expected, "%.6f", (double)i / 3);
 591         sprintf(actual, "%.6f", num_list->value);
 592         g_assert_cmpstr(expected, ==, actual);
 593         i++;
 594     }
 595
 596     i = 0;
 597     for (bool_list = arrs->boolean; bool_list; bool_list = bool_list->next) {
 598         g_assert_cmpint(bool_list->value, ==, i % 3 == 0);
 599         i++;
 600     }
 601
 602     i = 0;
 603     for (str_list = arrs->string; str_list; str_list = str_list->next) {
 604         char expected[32];
 605
 606         sprintf(expected, "%d", i);
 607         g_assert_cmpstr(str_list->value, ==, expected);
 608         i++;
 609     }
 610 }
 611
 612 static void test_visitor_in_any(TestInputVisitorData *data,
 613                                 const void *unused)
 614 {
 615     QObject *res = NULL;
 616     Visitor *v;
 617     QNum *qnum;
 618     QBool *qbool;
 619     QString *qstring;
 620     QDict *qdict;
 621     QObject *qobj;
 622     int64_t val;
 623
 624     v = visitor_input_test_init(data, "-42");
 625     visit_type_any(v, NULL, &res, &error_abort);
 626     qnum = qobject_to(QNum, res);
 627     g_assert(qnum);
 628     g_assert(qnum_get_try_int(qnum, &val));
 629     g_assert_cmpint(val, ==, -42);
 630     qobject_unref(res);
 631
 632     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 633     visit_type_any(v, NULL, &res, &error_abort);
 634     qdict = qobject_to(QDict, res);
 635     g_assert(qdict && qdict_size(qdict) == 3);
 636     qobj = qdict_get(qdict, "integer");
 637     g_assert(qobj);
 638     qnum = qobject_to(QNum, qobj);
 639     g_assert(qnum);
 640     g_assert(qnum_get_try_int(qnum, &val));
 641     g_assert_cmpint(val, ==, -42);
 642     qobj = qdict_get(qdict, "boolean");
 643     g_assert(qobj);
 644     qbool = qobject_to(QBool, qobj);
 645     g_assert(qbool);
 646     g_assert(qbool_get_bool(qbool) == true);
 647     qobj = qdict_get(qdict, "string");
 648     g_assert(qobj);
 649     qstring = qobject_to(QString, qobj);
 650     g_assert(qstring);
 651     g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
 652     qobject_unref(res);
 653 }
 654
 655 static void test_visitor_in_null(TestInputVisitorData *data,
 656                                  const void *unused)
 657 {
 658     Visitor *v;
 659     Error *err = NULL;
 660     QNull *null;
 661     char *tmp;
 662
 663     /*
 664      * FIXME: Since QAPI doesn't know the 'null' type yet, we can't
 665      * test visit_type_null() by reading into a QAPI struct then
 666      * checking that it was populated correctly.  The best we can do
 667      * for now is ensure that we consumed null from the input, proven
 668      * by the fact that we can't re-read the key; and that we detect
 669      * when input is not null.
 670      */
 671
 672     v = visitor_input_test_init_full(data, false,
 673                                      "{ 'a': null, 'b': '' }");
 674     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 675     visit_type_null(v, "a", &null, &error_abort);
 676     g_assert(qobject_type(QOBJECT(null)) == QTYPE_QNULL);
 677     qobject_unref(null);
 678     visit_type_null(v, "b", &null, &err);
 679     error_free_or_abort(&err);
 680     g_assert(!null);
 681     visit_type_str(v, "c", &tmp, &err);
 682     error_free_or_abort(&err);
 683     g_assert(!tmp);
 684     visit_check_struct(v, &error_abort);
 685     visit_end_struct(v, NULL);
 686 }
 687
 688 static void test_visitor_in_union_flat(TestInputVisitorData *data,
 689                                        const void *unused)
 690 {
 691     Visitor *v;
 692     g_autoptr(UserDefFlatUnion) tmp = NULL;
 693     UserDefUnionBase *base;
 694
 695     v = visitor_input_test_init(data,
 696                                 "{ 'enum1': 'value1', "
 697                                 "'integer': 41, "
 698                                 "'string': 'str', "
 699                                 "'boolean': true }");
 700
 701     visit_type_UserDefFlatUnion(v, NULL, &tmp, &error_abort);
 702     g_assert_cmpint(tmp->enum1, ==, ENUM_ONE_VALUE1);
 703     g_assert_cmpstr(tmp->string, ==, "str");
 704     g_assert_cmpint(tmp->integer, ==, 41);
 705     g_assert_cmpint(tmp->u.value1.boolean, ==, true);
 706
 707     base = qapi_UserDefFlatUnion_base(tmp);
 708     g_assert(&base->enum1 == &tmp->enum1);
 709 }
 710
 711 static void test_visitor_in_alternate(TestInputVisitorData *data,
 712                                       const void *unused)
 713 {
 714     Visitor *v;
 715     UserDefAlternate *tmp;
 716     WrapAlternate *wrap;
 717
 718     v = visitor_input_test_init(data, "42");
 719     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 720     g_assert_cmpint(tmp->type, ==, QTYPE_QNUM);
 721     g_assert_cmpint(tmp->u.i, ==, 42);
 722     qapi_free_UserDefAlternate(tmp);
 723
 724     v = visitor_input_test_init(data, "'value1'");
 725     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 726     g_assert_cmpint(tmp->type, ==, QTYPE_QSTRING);
 727     g_assert_cmpint(tmp->u.e, ==, ENUM_ONE_VALUE1);
 728     qapi_free_UserDefAlternate(tmp);
 729
 730     v = visitor_input_test_init(data, "null");
 731     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 732     g_assert_cmpint(tmp->type, ==, QTYPE_QNULL);
 733     qapi_free_UserDefAlternate(tmp);
 734
 735     v = visitor_input_test_init(data, "{'integer':1, 'string':'str', "
 736                                 "'enum1':'value1', 'boolean':true}");
 737     visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
 738     g_assert_cmpint(tmp->type, ==, QTYPE_QDICT);
 739     g_assert_cmpint(tmp->u.udfu.integer, ==, 1);
 740     g_assert_cmpstr(tmp->u.udfu.string, ==, "str");
 741     g_assert_cmpint(tmp->u.udfu.enum1, ==, ENUM_ONE_VALUE1);
 742     g_assert_cmpint(tmp->u.udfu.u.value1.boolean, ==, true);
 743     g_assert_cmpint(tmp->u.udfu.u.value1.has_a_b, ==, false);
 744     qapi_free_UserDefAlternate(tmp);
 745
 746     v = visitor_input_test_init(data, "{ 'alt': 42 }");
 747     visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
 748     g_assert_cmpint(wrap->alt->type, ==, QTYPE_QNUM);
 749     g_assert_cmpint(wrap->alt->u.i, ==, 42);
 750     qapi_free_WrapAlternate(wrap);
 751
 752     v = visitor_input_test_init(data, "{ 'alt': 'value1' }");
 753     visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
 754     g_assert_cmpint(wrap->alt->type, ==, QTYPE_QSTRING);
 755     g_assert_cmpint(wrap->alt->u.e, ==, ENUM_ONE_VALUE1);
 756     qapi_free_WrapAlternate(wrap);
 757
 758     v = visitor_input_test_init(data, "{ 'alt': {'integer':1, 'string':'str', "
 759                                 "'enum1':'value1', 'boolean':true} }");
 760     visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
 761     g_assert_cmpint(wrap->alt->type, ==, QTYPE_QDICT);
 762     g_assert_cmpint(wrap->alt->u.udfu.integer, ==, 1);
 763     g_assert_cmpstr(wrap->alt->u.udfu.string, ==, "str");
 764     g_assert_cmpint(wrap->alt->u.udfu.enum1, ==, ENUM_ONE_VALUE1);
 765     g_assert_cmpint(wrap->alt->u.udfu.u.value1.boolean, ==, true);
 766     g_assert_cmpint(wrap->alt->u.udfu.u.value1.has_a_b, ==, false);
 767     qapi_free_WrapAlternate(wrap);
 768 }
 769
 770 static void test_visitor_in_alternate_number(TestInputVisitorData *data,
 771                                              const void *unused)
 772 {
 773     Visitor *v;
 774     Error *err = NULL;
 775     AltEnumBool *aeb;
 776     AltEnumNum *aen;
 777     AltNumEnum *ans;
 778     AltEnumInt *asi;
 779
 780     /* Parsing an int */
 781
 782     v = visitor_input_test_init(data, "42");
 783     visit_type_AltEnumBool(v, NULL, &aeb, &err);
 784     error_free_or_abort(&err);
 785     qapi_free_AltEnumBool(aeb);
 786
 787     v = visitor_input_test_init(data, "42");
 788     visit_type_AltEnumNum(v, NULL, &aen, &error_abort);
 789     g_assert_cmpint(aen->type, ==, QTYPE_QNUM);
 790     g_assert_cmpfloat(aen->u.n, ==, 42);
 791     qapi_free_AltEnumNum(aen);
 792
 793     v = visitor_input_test_init(data, "42");
 794     visit_type_AltNumEnum(v, NULL, &ans, &error_abort);
 795     g_assert_cmpint(ans->type, ==, QTYPE_QNUM);
 796     g_assert_cmpfloat(ans->u.n, ==, 42);
 797     qapi_free_AltNumEnum(ans);
 798
 799     v = visitor_input_test_init(data, "42");
 800     visit_type_AltEnumInt(v, NULL, &asi, &error_abort);
 801     g_assert_cmpint(asi->type, ==, QTYPE_QNUM);
 802     g_assert_cmpint(asi->u.i, ==, 42);
 803     qapi_free_AltEnumInt(asi);
 804
 805     /* Parsing a double */
 806
 807     v = visitor_input_test_init(data, "42.5");
 808     visit_type_AltEnumBool(v, NULL, &aeb, &err);
 809     error_free_or_abort(&err);
 810     qapi_free_AltEnumBool(aeb);
 811
 812     v = visitor_input_test_init(data, "42.5");
 813     visit_type_AltEnumNum(v, NULL, &aen, &error_abort);
 814     g_assert_cmpint(aen->type, ==, QTYPE_QNUM);
 815     g_assert_cmpfloat(aen->u.n, ==, 42.5);
 816     qapi_free_AltEnumNum(aen);
 817
 818     v = visitor_input_test_init(data, "42.5");
 819     visit_type_AltNumEnum(v, NULL, &ans, &error_abort);
 820     g_assert_cmpint(ans->type, ==, QTYPE_QNUM);
 821     g_assert_cmpfloat(ans->u.n, ==, 42.5);
 822     qapi_free_AltNumEnum(ans);
 823
 824     v = visitor_input_test_init(data, "42.5");
 825     visit_type_AltEnumInt(v, NULL, &asi, &err);
 826     error_free_or_abort(&err);
 827     qapi_free_AltEnumInt(asi);
 828 }
 829
 830 static void input_visitor_test_add(const char *testpath,
 831                                    const void *user_data,
 832                                    void (*test_func)(TestInputVisitorData *data,
 833                                                      const void *user_data))
 834 {
 835     g_test_add(testpath, TestInputVisitorData, user_data, NULL, test_func,
 836                visitor_input_teardown);
 837 }
 838
 839 static void test_visitor_in_errors(TestInputVisitorData *data,
 840                                    const void *unused)
 841 {
 842     TestStruct *p = NULL;
 843     Error *err = NULL;
 844     Visitor *v;
 845     strList *q = NULL;
 846     UserDefTwo *r = NULL;
 847     WrapAlternate *s = NULL;
 848
 849     v = visitor_input_test_init(data, "{ 'integer': false, 'boolean': 'foo', "
 850                                 "'string': -42 }");
 851
 852     visit_type_TestStruct(v, NULL, &p, &err);
 853     error_free_or_abort(&err);
 854     g_assert(!p);
 855
 856     v = visitor_input_test_init(data, "[ '1', '2', false, '3' ]");
 857     visit_type_strList(v, NULL, &q, &err);
 858     error_free_or_abort(&err);
 859     assert(!q);
 860
 861     v = visitor_input_test_init(data, "{ 'str':'hi' }");
 862     visit_type_UserDefTwo(v, NULL, &r, &err);
 863     error_free_or_abort(&err);
 864     assert(!r);
 865
 866     v = visitor_input_test_init(data, "{ }");
 867     visit_type_WrapAlternate(v, NULL, &s, &err);
 868     error_free_or_abort(&err);
 869     assert(!s);
 870 }
 871
 872 static void test_visitor_in_wrong_type(TestInputVisitorData *data,
 873                                        const void *unused)
 874 {
 875     TestStruct *p = NULL;
 876     Visitor *v;
 877     strList *q = NULL;
 878     int64_t i;
 879     Error *err = NULL;
 880
 881     /* Make sure arrays and structs cannot be confused */
 882
 883     v = visitor_input_test_init(data, "[]");
 884     visit_type_TestStruct(v, NULL, &p, &err);
 885     error_free_or_abort(&err);
 886     g_assert(!p);
 887
 888     v = visitor_input_test_init(data, "{}");
 889     visit_type_strList(v, NULL, &q, &err);
 890     error_free_or_abort(&err);
 891     assert(!q);
 892
 893     /* Make sure primitives and struct cannot be confused */
 894
 895     v = visitor_input_test_init(data, "1");
 896     visit_type_TestStruct(v, NULL, &p, &err);
 897     error_free_or_abort(&err);
 898     g_assert(!p);
 899
 900     v = visitor_input_test_init(data, "{}");
 901     visit_type_int(v, NULL, &i, &err);
 902     error_free_or_abort(&err);
 903
 904     /* Make sure primitives and arrays cannot be confused */
 905
 906     v = visitor_input_test_init(data, "1");
 907     visit_type_strList(v, NULL, &q, &err);
 908     error_free_or_abort(&err);
 909     assert(!q);
 910
 911     v = visitor_input_test_init(data, "[]");
 912     visit_type_int(v, NULL, &i, &err);
 913     error_free_or_abort(&err);
 914 }
 915
 916 static void test_visitor_in_fail_struct(TestInputVisitorData *data,
 917                                         const void *unused)
 918 {
 919     TestStruct *p = NULL;
 920     Error *err = NULL;
 921     Visitor *v;
 922
 923     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo', 'extra': 42 }");
 924
 925     visit_type_TestStruct(v, NULL, &p, &err);
 926     error_free_or_abort(&err);
 927     g_assert(!p);
 928 }
 929
 930 static void test_visitor_in_fail_struct_nested(TestInputVisitorData *data,
 931                                                const void *unused)
 932 {
 933     UserDefTwo *udp = NULL;
 934     Error *err = NULL;
 935     Visitor *v;
 936
 937     v = visitor_input_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string', 'extra': [42, 23, {'foo':'bar'}] }, 'string2': 'string2'}}}");
 938
 939     visit_type_UserDefTwo(v, NULL, &udp, &err);
 940     error_free_or_abort(&err);
 941     g_assert(!udp);
 942 }
 943
 944 static void test_visitor_in_fail_struct_in_list(TestInputVisitorData *data,
 945                                                 const void *unused)
 946 {
 947     UserDefOneList *head = NULL;
 948     Error *err = NULL;
 949     Visitor *v;
 950
 951     v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44, 'extra': 'ggg' } ]");
 952
 953     visit_type_UserDefOneList(v, NULL, &head, &err);
 954     error_free_or_abort(&err);
 955     g_assert(!head);
 956 }
 957
 958 static void test_visitor_in_fail_struct_missing(TestInputVisitorData *data,
 959                                                 const void *unused)
 960 {
 961     Error *err = NULL;
 962     Visitor *v;
 963     QObject *any;
 964     QNull *null;
 965     GenericAlternate *alt;
 966     bool present;
 967     int en;
 968     int64_t i64;
 969     uint32_t u32;
 970     int8_t i8;
 971     char *str;
 972     double dbl;
 973
 974     v = visitor_input_test_init(data, "{ 'sub': [ {} ] }");
 975     visit_start_struct(v, NULL, NULL, 0, &error_abort);
 976     visit_start_struct(v, "struct", NULL, 0, &err);
 977     error_free_or_abort(&err);
 978     visit_start_list(v, "list", NULL, 0, &err);
 979     error_free_or_abort(&err);
 980     visit_start_alternate(v, "alternate", &alt, sizeof(*alt), &err);
 981     error_free_or_abort(&err);
 982     visit_optional(v, "optional", &present);
 983     g_assert(!present);
 984     visit_type_enum(v, "enum", &en, &EnumOne_lookup, &err);
 985     error_free_or_abort(&err);
 986     visit_type_int(v, "i64", &i64, &err);
 987     error_free_or_abort(&err);
 988     visit_type_uint32(v, "u32", &u32, &err);
 989     error_free_or_abort(&err);
 990     visit_type_int8(v, "i8", &i8, &err);
 991     error_free_or_abort(&err);
 992     visit_type_str(v, "i8", &str, &err);
 993     error_free_or_abort(&err);
 994     visit_type_number(v, "dbl", &dbl, &err);
 995     error_free_or_abort(&err);
 996     visit_type_any(v, "any", &any, &err);
 997     error_free_or_abort(&err);
 998     visit_type_null(v, "null", &null, &err);
 999     error_free_or_abort(&err);
1000     visit_start_list(v, "sub", NULL, 0, &error_abort);
1001     visit_start_struct(v, NULL, NULL, 0, &error_abort);
1002     visit_type_int(v, "i64", &i64, &err);
1003     error_free_or_abort(&err);
1004     visit_end_struct(v, NULL);
1005     visit_end_list(v, NULL);
1006     visit_end_struct(v, NULL);
1007 }
1008
1009 static void test_visitor_in_fail_list(TestInputVisitorData *data,
1010                                       const void *unused)
1011 {
1012     int64_t i64 = -1;
1013     Error *err = NULL;
1014     Visitor *v;
1015
1016     /* Unvisited list tail */
1017
1018     v = visitor_input_test_init(data, "[ 1, 2, 3 ]");
1019
1020     visit_start_list(v, NULL, NULL, 0, &error_abort);
1021     visit_type_int(v, NULL, &i64, &error_abort);
1022     g_assert_cmpint(i64, ==, 1);
1023     visit_type_int(v, NULL, &i64, &error_abort);
1024     g_assert_cmpint(i64, ==, 2);
1025     visit_check_list(v, &err);
1026     error_free_or_abort(&err);
1027     visit_end_list(v, NULL);
1028
1029     /* Visit beyond end of list */
1030     v = visitor_input_test_init(data, "[]");
1031
1032     visit_start_list(v, NULL, NULL, 0, &error_abort);
1033     visit_type_int(v, NULL, &i64, &err);
1034     error_free_or_abort(&err);
1035     visit_end_list(v, NULL);
1036 }
1037
1038 static void test_visitor_in_fail_list_nested(TestInputVisitorData *data,
1039                                              const void *unused)
1040 {
1041     int64_t i64 = -1;
1042     Error *err = NULL;
1043     Visitor *v;
1044
1045     /* Unvisited nested list tail */
1046
1047     v = visitor_input_test_init(data, "[ 0, [ 1, 2, 3 ] ]");
1048
1049     visit_start_list(v, NULL, NULL, 0, &error_abort);
1050     visit_type_int(v, NULL, &i64, &error_abort);
1051     g_assert_cmpint(i64, ==, 0);
1052     visit_start_list(v, NULL, NULL, 0, &error_abort);
1053     visit_type_int(v, NULL, &i64, &error_abort);
1054     g_assert_cmpint(i64, ==, 1);
1055     visit_check_list(v, &err);
1056     error_free_or_abort(&err);
1057     visit_end_list(v, NULL);
1058     visit_check_list(v, &error_abort);
1059     visit_end_list(v, NULL);
1060 }
1061
1062 static void test_visitor_in_fail_union_flat(TestInputVisitorData *data,
1063                                             const void *unused)
1064 {
1065     UserDefFlatUnion *tmp = NULL;
1066     Error *err = NULL;
1067     Visitor *v;
1068
1069     v = visitor_input_test_init(data, "{ 'enum1': 'value2', 'string': 'c', 'integer': 41, 'boolean': true }");
1070
1071     visit_type_UserDefFlatUnion(v, NULL, &tmp, &err);
1072     error_free_or_abort(&err);
1073     g_assert(!tmp);
1074 }
1075
1076 static void test_visitor_in_fail_union_flat_no_discrim(TestInputVisitorData *data,
1077                                                        const void *unused)
1078 {
1079     UserDefFlatUnion2 *tmp = NULL;
1080     Error *err = NULL;
1081     Visitor *v;
1082
1083     /* test situation where discriminator field ('enum1' here) is missing */
1084     v = visitor_input_test_init(data, "{ 'integer': 42, 'string': 'c', 'string1': 'd', 'string2': 'e' }");
1085
1086     visit_type_UserDefFlatUnion2(v, NULL, &tmp, &err);
1087     error_free_or_abort(&err);
1088     g_assert(!tmp);
1089 }
1090
1091 static void test_visitor_in_fail_alternate(TestInputVisitorData *data,
1092                                            const void *unused)
1093 {
1094     UserDefAlternate *tmp;
1095     Visitor *v;
1096     Error *err = NULL;
1097
1098     v = visitor_input_test_init(data, "3.14");
1099
1100     visit_type_UserDefAlternate(v, NULL, &tmp, &err);
1101     error_free_or_abort(&err);
1102     g_assert(!tmp);
1103 }
1104
1105 static void do_test_visitor_in_qmp_introspect(TestInputVisitorData *data,
1106                                               const QLitObject *qlit)
1107 {
1108     g_autoptr(SchemaInfoList) schema = NULL;
1109     QObject *obj = qobject_from_qlit(qlit);
1110     Visitor *v;
1111
1112     v = qobject_input_visitor_new(obj);
1113
1114     visit_type_SchemaInfoList(v, NULL, &schema, &error_abort);
1115     g_assert(schema);
1116
1117     qobject_unref(obj);
1118     visit_free(v);
1119 }
1120
1121 static void test_visitor_in_qmp_introspect(TestInputVisitorData *data,
1122                                            const void *unused)
1123 {
1124     do_test_visitor_in_qmp_introspect(data, &test_qmp_schema_qlit);
1125 }
1126
1127 int main(int argc, char **argv)
1128 {
1129     g_test_init(&argc, &argv, NULL);
1130
1131     input_visitor_test_add("/visitor/input/int",
1132                            NULL, test_visitor_in_int);
1133     input_visitor_test_add("/visitor/input/uint",
1134                            NULL, test_visitor_in_uint);
1135     input_visitor_test_add("/visitor/input/int_overflow",
1136                            NULL, test_visitor_in_int_overflow);
1137     input_visitor_test_add("/visitor/input/int_keyval",
1138                            NULL, test_visitor_in_int_keyval);
1139     input_visitor_test_add("/visitor/input/int_str_keyval",
1140                            NULL, test_visitor_in_int_str_keyval);
1141     input_visitor_test_add("/visitor/input/int_str_fail",
1142                            NULL, test_visitor_in_int_str_fail);
1143     input_visitor_test_add("/visitor/input/bool",
1144                            NULL, test_visitor_in_bool);
1145     input_visitor_test_add("/visitor/input/bool_keyval",
1146                            NULL, test_visitor_in_bool_keyval);
1147     input_visitor_test_add("/visitor/input/bool_str_keyval",
1148                            NULL, test_visitor_in_bool_str_keyval);
1149     input_visitor_test_add("/visitor/input/bool_str_fail",
1150                            NULL, test_visitor_in_bool_str_fail);
1151     input_visitor_test_add("/visitor/input/number",
1152                            NULL, test_visitor_in_number);
1153     input_visitor_test_add("/visitor/input/large_number",
1154                            NULL, test_visitor_in_large_number);
1155     input_visitor_test_add("/visitor/input/number_keyval",
1156                            NULL, test_visitor_in_number_keyval);
1157     input_visitor_test_add("/visitor/input/number_str_keyval",
1158                            NULL, test_visitor_in_number_str_keyval);
1159     input_visitor_test_add("/visitor/input/number_str_fail",
1160                            NULL, test_visitor_in_number_str_fail);
1161     input_visitor_test_add("/visitor/input/size_str_keyval",
1162                            NULL, test_visitor_in_size_str_keyval);
1163     input_visitor_test_add("/visitor/input/size_str_fail",
1164                            NULL, test_visitor_in_size_str_fail);
1165     input_visitor_test_add("/visitor/input/string",
1166                            NULL, test_visitor_in_string);
1167     input_visitor_test_add("/visitor/input/enum",
1168                            NULL, test_visitor_in_enum);
1169     input_visitor_test_add("/visitor/input/struct",
1170                            NULL, test_visitor_in_struct);
1171     input_visitor_test_add("/visitor/input/struct-nested",
1172                            NULL, test_visitor_in_struct_nested);
1173     input_visitor_test_add("/visitor/input/list2",
1174                            NULL, test_visitor_in_list_struct);
1175     input_visitor_test_add("/visitor/input/list",
1176                            NULL, test_visitor_in_list);
1177     input_visitor_test_add("/visitor/input/any",
1178                            NULL, test_visitor_in_any);
1179     input_visitor_test_add("/visitor/input/null",
1180                            NULL, test_visitor_in_null);
1181     input_visitor_test_add("/visitor/input/union-flat",
1182                            NULL, test_visitor_in_union_flat);
1183     input_visitor_test_add("/visitor/input/alternate",
1184                            NULL, test_visitor_in_alternate);
1185     input_visitor_test_add("/visitor/input/errors",
1186                            NULL, test_visitor_in_errors);
1187     input_visitor_test_add("/visitor/input/wrong-type",
1188                            NULL, test_visitor_in_wrong_type);
1189     input_visitor_test_add("/visitor/input/alternate-number",
1190                            NULL, test_visitor_in_alternate_number);
1191     input_visitor_test_add("/visitor/input/fail/struct",
1192                            NULL, test_visitor_in_fail_struct);
1193     input_visitor_test_add("/visitor/input/fail/struct-nested",
1194                            NULL, test_visitor_in_fail_struct_nested);
1195     input_visitor_test_add("/visitor/input/fail/struct-in-list",
1196                            NULL, test_visitor_in_fail_struct_in_list);
1197     input_visitor_test_add("/visitor/input/fail/struct-missing",
1198                            NULL, test_visitor_in_fail_struct_missing);
1199     input_visitor_test_add("/visitor/input/fail/list",
1200                            NULL, test_visitor_in_fail_list);
1201     input_visitor_test_add("/visitor/input/fail/list-nested",
1202                            NULL, test_visitor_in_fail_list_nested);
1203     input_visitor_test_add("/visitor/input/fail/union-flat",
1204                            NULL, test_visitor_in_fail_union_flat);
1205     input_visitor_test_add("/visitor/input/fail/union-flat-no-discriminator",
1206                            NULL, test_visitor_in_fail_union_flat_no_discrim);
1207     input_visitor_test_add("/visitor/input/fail/alternate",
1208                            NULL, test_visitor_in_fail_alternate);
1209     input_visitor_test_add("/visitor/input/qapi-introspect",
1210                            NULL, test_visitor_in_qmp_introspect);
1211
1212     g_test_run();
1213
1214     return 0;
1215 }