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