tests/test-qmp-input-visitor.c

   1 /*
   2  * QMP Input Visitor unit-tests.
   3  *
   4  * Copyright (C) 2011 Red Hat Inc.
   5  *
   6  * Authors:
   7  *  Luiz Capitulino <lcapitulino@redhat.com>
   8  *
   9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  10  * See the COPYING file in the top-level directory.
  11  */
  12
  13 #include <glib.h>
  14 #include <stdarg.h>
  15
  16 #include "qemu-common.h"
  17 #include "qapi/qmp-input-visitor.h"
  18 #include "test-qapi-types.h"
  19 #include "test-qapi-visit.h"
  20 #include "qapi/qmp/types.h"
  21
  22 typedef struct TestInputVisitorData {
  23     QObject *obj;
  24     QmpInputVisitor *qiv;
  25 } TestInputVisitorData;
  26
  27 static void visitor_input_teardown(TestInputVisitorData *data,
  28                                    const void *unused)
  29 {
  30     qobject_decref(data->obj);
  31     data->obj = NULL;
  32
  33     if (data->qiv) {
  34         qmp_input_visitor_cleanup(data->qiv);
  35         data->qiv = NULL;
  36     }
  37 }
  38
  39 /* This is provided instead of a test setup function so that the JSON
  40    string used by the tests are kept in the test functions (and not
  41    int main()) */
  42 static GCC_FMT_ATTR(2, 3)
  43 Visitor *visitor_input_test_init(TestInputVisitorData *data,
  44                                  const char *json_string, ...)
  45 {
  46     Visitor *v;
  47     va_list ap;
  48
  49     va_start(ap, json_string);
  50     data->obj = qobject_from_jsonv(json_string, &ap);
  51     va_end(ap);
  52
  53     g_assert(data->obj != NULL);
  54
  55     data->qiv = qmp_input_visitor_new(data->obj);
  56     g_assert(data->qiv != NULL);
  57
  58     v = qmp_input_get_visitor(data->qiv);
  59     g_assert(v != NULL);
  60
  61     return v;
  62 }
  63
  64 /* similar to visitor_input_test_init(), but does not expect a string
  65  * literal/format json_string argument and so can be used for
  66  * programatically generated strings (and we can't pass in programatically
  67  * generated strings via %s format parameters since qobject_from_jsonv()
  68  * will wrap those in double-quotes and treat the entire object as a
  69  * string)
  70  */
  71 static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
  72                                             const char *json_string)
  73 {
  74     Visitor *v;
  75
  76     data->obj = qobject_from_json(json_string);
  77
  78     g_assert(data->obj != NULL);
  79
  80     data->qiv = qmp_input_visitor_new(data->obj);
  81     g_assert(data->qiv != NULL);
  82
  83     v = qmp_input_get_visitor(data->qiv);
  84     g_assert(v != NULL);
  85
  86     return v;
  87 }
  88
  89 static void test_visitor_in_int(TestInputVisitorData *data,
  90                                 const void *unused)
  91 {
  92     int64_t res = 0, value = -42;
  93     Error *err = NULL;
  94     Visitor *v;
  95
  96     v = visitor_input_test_init(data, "%" PRId64, value);
  97
  98     visit_type_int(v, &res, NULL, &err);
  99     g_assert(!err);
 100     g_assert_cmpint(res, ==, value);
 101 }
 102
 103 static void test_visitor_in_int_overflow(TestInputVisitorData *data,
 104                                          const void *unused)
 105 {
 106     int64_t res = 0;
 107     Error *err = NULL;
 108     Visitor *v;
 109
 110     /* this will overflow a Qint/int64, so should be deserialized into
 111      * a QFloat/double field instead, leading to an error if we pass it
 112      * to visit_type_int. confirm this.
 113      */
 114     v = visitor_input_test_init(data, "%f", DBL_MAX);
 115
 116     visit_type_int(v, &res, NULL, &err);
 117     g_assert(err);
 118     error_free(err);
 119 }
 120
 121 static void test_visitor_in_bool(TestInputVisitorData *data,
 122                                  const void *unused)
 123 {
 124     Error *err = NULL;
 125     bool res = false;
 126     Visitor *v;
 127
 128     v = visitor_input_test_init(data, "true");
 129
 130     visit_type_bool(v, &res, NULL, &err);
 131     g_assert(!err);
 132     g_assert_cmpint(res, ==, true);
 133 }
 134
 135 static void test_visitor_in_number(TestInputVisitorData *data,
 136                                    const void *unused)
 137 {
 138     double res = 0, value = 3.14;
 139     Error *err = NULL;
 140     Visitor *v;
 141
 142     v = visitor_input_test_init(data, "%f", value);
 143
 144     visit_type_number(v, &res, NULL, &err);
 145     g_assert(!err);
 146     g_assert_cmpfloat(res, ==, value);
 147 }
 148
 149 static void test_visitor_in_string(TestInputVisitorData *data,
 150                                    const void *unused)
 151 {
 152     char *res = NULL, *value = (char *) "Q E M U";
 153     Error *err = NULL;
 154     Visitor *v;
 155
 156     v = visitor_input_test_init(data, "%s", value);
 157
 158     visit_type_str(v, &res, NULL, &err);
 159     g_assert(!err);
 160     g_assert_cmpstr(res, ==, value);
 161
 162     g_free(res);
 163 }
 164
 165 static void test_visitor_in_enum(TestInputVisitorData *data,
 166                                  const void *unused)
 167 {
 168     Error *err = NULL;
 169     Visitor *v;
 170     EnumOne i;
 171
 172     for (i = 0; EnumOne_lookup[i]; i++) {
 173         EnumOne res = -1;
 174
 175         v = visitor_input_test_init(data, "%s", EnumOne_lookup[i]);
 176
 177         visit_type_EnumOne(v, &res, NULL, &err);
 178         g_assert(!err);
 179         g_assert_cmpint(i, ==, res);
 180
 181         visitor_input_teardown(data, NULL);
 182     }
 183
 184     data->obj = NULL;
 185     data->qiv = NULL;
 186 }
 187
 188 typedef struct TestStruct
 189 {
 190     int64_t integer;
 191     bool boolean;
 192     char *string;
 193 } TestStruct;
 194
 195 static void visit_type_TestStruct(Visitor *v, TestStruct **obj,
 196                                   const char *name, Error **errp)
 197 {
 198     Error *err = NULL;
 199
 200     visit_start_struct(v, (void **)obj, "TestStruct", name, sizeof(TestStruct),
 201                        &err);
 202     if (!err) {
 203         visit_type_int(v, &(*obj)->integer, "integer", &err);
 204         visit_type_bool(v, &(*obj)->boolean, "boolean", &err);
 205         visit_type_str(v, &(*obj)->string, "string", &err);
 206
 207         /* Always call end_struct if start_struct succeeded.  */
 208         error_propagate(errp, err);
 209         err = NULL;
 210         visit_end_struct(v, &err);
 211     }
 212     error_propagate(errp, err);
 213 }
 214
 215 static void test_visitor_in_struct(TestInputVisitorData *data,
 216                                    const void *unused)
 217 {
 218     TestStruct *p = NULL;
 219     Error *err = NULL;
 220     Visitor *v;
 221
 222     v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
 223
 224     visit_type_TestStruct(v, &p, NULL, &err);
 225     g_assert(!err);
 226     g_assert_cmpint(p->integer, ==, -42);
 227     g_assert(p->boolean == true);
 228     g_assert_cmpstr(p->string, ==, "foo");
 229
 230     g_free(p->string);
 231     g_free(p);
 232 }
 233
 234 static void check_and_free_str(char *str, const char *cmp)
 235 {
 236     g_assert_cmpstr(str, ==, cmp);
 237     g_free(str);
 238 }
 239
 240 static void test_visitor_in_struct_nested(TestInputVisitorData *data,
 241                                           const void *unused)
 242 {
 243     UserDefNested *udp = NULL;
 244     Error *err = NULL;
 245     Visitor *v;
 246
 247     v = visitor_input_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string' }, 'string2': 'string2'}}}");
 248
 249     visit_type_UserDefNested(v, &udp, NULL, &err);
 250     g_assert(!err);
 251
 252     check_and_free_str(udp->string0, "string0");
 253     check_and_free_str(udp->dict1.string1, "string1");
 254     g_assert_cmpint(udp->dict1.dict2.userdef1->base->integer, ==, 42);
 255     check_and_free_str(udp->dict1.dict2.userdef1->string, "string");
 256     check_and_free_str(udp->dict1.dict2.string2, "string2");
 257     g_assert(udp->dict1.has_dict3 == false);
 258
 259     g_free(udp->dict1.dict2.userdef1);
 260     g_free(udp);
 261 }
 262
 263 static void test_visitor_in_list(TestInputVisitorData *data,
 264                                  const void *unused)
 265 {
 266     UserDefOneList *item, *head = NULL;
 267     Error *err = NULL;
 268     Visitor *v;
 269     int i;
 270
 271     v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
 272
 273     visit_type_UserDefOneList(v, &head, NULL, &err);
 274     g_assert(!err);
 275     g_assert(head != NULL);
 276
 277     for (i = 0, item = head; item; item = item->next, i++) {
 278         char string[12];
 279
 280         snprintf(string, sizeof(string), "string%d", i);
 281         g_assert_cmpstr(item->value->string, ==, string);
 282         g_assert_cmpint(item->value->base->integer, ==, 42 + i);
 283     }
 284
 285     qapi_free_UserDefOneList(head);
 286 }
 287
 288 static void test_visitor_in_union(TestInputVisitorData *data,
 289                                   const void *unused)
 290 {
 291     Visitor *v;
 292     Error *err = NULL;
 293     UserDefUnion *tmp;
 294
 295     v = visitor_input_test_init(data, "{ 'type': 'b', 'integer': 41, 'data' : { 'integer': 42 } }");
 296
 297     visit_type_UserDefUnion(v, &tmp, NULL, &err);
 298     g_assert(err == NULL);
 299     g_assert_cmpint(tmp->kind, ==, USER_DEF_UNION_KIND_B);
 300     g_assert_cmpint(tmp->integer, ==, 41);
 301     g_assert_cmpint(tmp->b->integer, ==, 42);
 302     qapi_free_UserDefUnion(tmp);
 303 }
 304
 305 static void test_visitor_in_union_flat(TestInputVisitorData *data,
 306                                        const void *unused)
 307 {
 308     Visitor *v;
 309     Error *err = NULL;
 310     UserDefFlatUnion *tmp;
 311
 312     v = visitor_input_test_init(data,
 313                                 "{ 'enum1': 'value1', "
 314                                 "'string': 'str', "
 315                                 "'boolean': true }");
 316     /* TODO when generator bug is fixed, add 'integer': 41 */
 317
 318     visit_type_UserDefFlatUnion(v, &tmp, NULL, &err);
 319     g_assert(err == NULL);
 320     g_assert_cmpint(tmp->kind, ==, ENUM_ONE_VALUE1);
 321     g_assert_cmpstr(tmp->string, ==, "str");
 322     /* TODO g_assert_cmpint(tmp->integer, ==, 41); */
 323     g_assert_cmpint(tmp->value1->boolean, ==, true);
 324     qapi_free_UserDefFlatUnion(tmp);
 325 }
 326
 327 static void test_visitor_in_union_anon(TestInputVisitorData *data,
 328                                        const void *unused)
 329 {
 330     Visitor *v;
 331     Error *err = NULL;
 332     UserDefAnonUnion *tmp;
 333
 334     v = visitor_input_test_init(data, "42");
 335
 336     visit_type_UserDefAnonUnion(v, &tmp, NULL, &err);
 337     g_assert(err == NULL);
 338     g_assert_cmpint(tmp->kind, ==, USER_DEF_ANON_UNION_KIND_I);
 339     g_assert_cmpint(tmp->i, ==, 42);
 340     qapi_free_UserDefAnonUnion(tmp);
 341 }
 342
 343 static void test_native_list_integer_helper(TestInputVisitorData *data,
 344                                             const void *unused,
 345                                             UserDefNativeListUnionKind kind)
 346 {
 347     UserDefNativeListUnion *cvalue = NULL;
 348     Error *err = NULL;
 349     Visitor *v;
 350     GString *gstr_list = g_string_new("");
 351     GString *gstr_union = g_string_new("");
 352     int i;
 353
 354     for (i = 0; i < 32; i++) {
 355         g_string_append_printf(gstr_list, "%d", i);
 356         if (i != 31) {
 357             g_string_append(gstr_list, ", ");
 358         }
 359     }
 360     g_string_append_printf(gstr_union,  "{ 'type': '%s', 'data': [ %s ] }",
 361                            UserDefNativeListUnionKind_lookup[kind],
 362                            gstr_list->str);
 363     v = visitor_input_test_init_raw(data,  gstr_union->str);
 364
 365     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 366     g_assert(err == NULL);
 367     g_assert(cvalue != NULL);
 368     g_assert_cmpint(cvalue->kind, ==, kind);
 369
 370     switch (kind) {
 371     case USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER: {
 372         intList *elem = NULL;
 373         for (i = 0, elem = cvalue->integer; elem; elem = elem->next, i++) {
 374             g_assert_cmpint(elem->value, ==, i);
 375         }
 376         break;
 377     }
 378     case USER_DEF_NATIVE_LIST_UNION_KIND_S8: {
 379         int8List *elem = NULL;
 380         for (i = 0, elem = cvalue->s8; elem; elem = elem->next, i++) {
 381             g_assert_cmpint(elem->value, ==, i);
 382         }
 383         break;
 384     }
 385     case USER_DEF_NATIVE_LIST_UNION_KIND_S16: {
 386         int16List *elem = NULL;
 387         for (i = 0, elem = cvalue->s16; elem; elem = elem->next, i++) {
 388             g_assert_cmpint(elem->value, ==, i);
 389         }
 390         break;
 391     }
 392     case USER_DEF_NATIVE_LIST_UNION_KIND_S32: {
 393         int32List *elem = NULL;
 394         for (i = 0, elem = cvalue->s32; elem; elem = elem->next, i++) {
 395             g_assert_cmpint(elem->value, ==, i);
 396         }
 397         break;
 398     }
 399     case USER_DEF_NATIVE_LIST_UNION_KIND_S64: {
 400         int64List *elem = NULL;
 401         for (i = 0, elem = cvalue->s64; elem; elem = elem->next, i++) {
 402             g_assert_cmpint(elem->value, ==, i);
 403         }
 404         break;
 405     }
 406     case USER_DEF_NATIVE_LIST_UNION_KIND_U8: {
 407         uint8List *elem = NULL;
 408         for (i = 0, elem = cvalue->u8; elem; elem = elem->next, i++) {
 409             g_assert_cmpint(elem->value, ==, i);
 410         }
 411         break;
 412     }
 413     case USER_DEF_NATIVE_LIST_UNION_KIND_U16: {
 414         uint16List *elem = NULL;
 415         for (i = 0, elem = cvalue->u16; elem; elem = elem->next, i++) {
 416             g_assert_cmpint(elem->value, ==, i);
 417         }
 418         break;
 419     }
 420     case USER_DEF_NATIVE_LIST_UNION_KIND_U32: {
 421         uint32List *elem = NULL;
 422         for (i = 0, elem = cvalue->u32; elem; elem = elem->next, i++) {
 423             g_assert_cmpint(elem->value, ==, i);
 424         }
 425         break;
 426     }
 427     case USER_DEF_NATIVE_LIST_UNION_KIND_U64: {
 428         uint64List *elem = NULL;
 429         for (i = 0, elem = cvalue->u64; elem; elem = elem->next, i++) {
 430             g_assert_cmpint(elem->value, ==, i);
 431         }
 432         break;
 433     }
 434     default:
 435         g_assert_not_reached();
 436     }
 437
 438     g_string_free(gstr_union, true);
 439     g_string_free(gstr_list, true);
 440     qapi_free_UserDefNativeListUnion(cvalue);
 441 }
 442
 443 static void test_visitor_in_native_list_int(TestInputVisitorData *data,
 444                                             const void *unused)
 445 {
 446     test_native_list_integer_helper(data, unused,
 447                                     USER_DEF_NATIVE_LIST_UNION_KIND_INTEGER);
 448 }
 449
 450 static void test_visitor_in_native_list_int8(TestInputVisitorData *data,
 451                                              const void *unused)
 452 {
 453     test_native_list_integer_helper(data, unused,
 454                                     USER_DEF_NATIVE_LIST_UNION_KIND_S8);
 455 }
 456
 457 static void test_visitor_in_native_list_int16(TestInputVisitorData *data,
 458                                               const void *unused)
 459 {
 460     test_native_list_integer_helper(data, unused,
 461                                     USER_DEF_NATIVE_LIST_UNION_KIND_S16);
 462 }
 463
 464 static void test_visitor_in_native_list_int32(TestInputVisitorData *data,
 465                                               const void *unused)
 466 {
 467     test_native_list_integer_helper(data, unused,
 468                                     USER_DEF_NATIVE_LIST_UNION_KIND_S32);
 469 }
 470
 471 static void test_visitor_in_native_list_int64(TestInputVisitorData *data,
 472                                               const void *unused)
 473 {
 474     test_native_list_integer_helper(data, unused,
 475                                     USER_DEF_NATIVE_LIST_UNION_KIND_S64);
 476 }
 477
 478 static void test_visitor_in_native_list_uint8(TestInputVisitorData *data,
 479                                              const void *unused)
 480 {
 481     test_native_list_integer_helper(data, unused,
 482                                     USER_DEF_NATIVE_LIST_UNION_KIND_U8);
 483 }
 484
 485 static void test_visitor_in_native_list_uint16(TestInputVisitorData *data,
 486                                                const void *unused)
 487 {
 488     test_native_list_integer_helper(data, unused,
 489                                     USER_DEF_NATIVE_LIST_UNION_KIND_U16);
 490 }
 491
 492 static void test_visitor_in_native_list_uint32(TestInputVisitorData *data,
 493                                                const void *unused)
 494 {
 495     test_native_list_integer_helper(data, unused,
 496                                     USER_DEF_NATIVE_LIST_UNION_KIND_U32);
 497 }
 498
 499 static void test_visitor_in_native_list_uint64(TestInputVisitorData *data,
 500                                                const void *unused)
 501 {
 502     test_native_list_integer_helper(data, unused,
 503                                     USER_DEF_NATIVE_LIST_UNION_KIND_U64);
 504 }
 505
 506 static void test_visitor_in_native_list_bool(TestInputVisitorData *data,
 507                                             const void *unused)
 508 {
 509     UserDefNativeListUnion *cvalue = NULL;
 510     boolList *elem = NULL;
 511     Error *err = NULL;
 512     Visitor *v;
 513     GString *gstr_list = g_string_new("");
 514     GString *gstr_union = g_string_new("");
 515     int i;
 516
 517     for (i = 0; i < 32; i++) {
 518         g_string_append_printf(gstr_list, "%s",
 519                                (i % 3 == 0) ? "true" : "false");
 520         if (i != 31) {
 521             g_string_append(gstr_list, ", ");
 522         }
 523     }
 524     g_string_append_printf(gstr_union,  "{ 'type': 'boolean', 'data': [ %s ] }",
 525                            gstr_list->str);
 526     v = visitor_input_test_init_raw(data,  gstr_union->str);
 527
 528     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 529     g_assert(err == NULL);
 530     g_assert(cvalue != NULL);
 531     g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_BOOLEAN);
 532
 533     for (i = 0, elem = cvalue->boolean; elem; elem = elem->next, i++) {
 534         g_assert_cmpint(elem->value, ==, (i % 3 == 0) ? 1 : 0);
 535     }
 536
 537     g_string_free(gstr_union, true);
 538     g_string_free(gstr_list, true);
 539     qapi_free_UserDefNativeListUnion(cvalue);
 540 }
 541
 542 static void test_visitor_in_native_list_string(TestInputVisitorData *data,
 543                                                const void *unused)
 544 {
 545     UserDefNativeListUnion *cvalue = NULL;
 546     strList *elem = NULL;
 547     Error *err = NULL;
 548     Visitor *v;
 549     GString *gstr_list = g_string_new("");
 550     GString *gstr_union = g_string_new("");
 551     int i;
 552
 553     for (i = 0; i < 32; i++) {
 554         g_string_append_printf(gstr_list, "'%d'", i);
 555         if (i != 31) {
 556             g_string_append(gstr_list, ", ");
 557         }
 558     }
 559     g_string_append_printf(gstr_union,  "{ 'type': 'string', 'data': [ %s ] }",
 560                            gstr_list->str);
 561     v = visitor_input_test_init_raw(data,  gstr_union->str);
 562
 563     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 564     g_assert(err == NULL);
 565     g_assert(cvalue != NULL);
 566     g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_STRING);
 567
 568     for (i = 0, elem = cvalue->string; elem; elem = elem->next, i++) {
 569         gchar str[8];
 570         sprintf(str, "%d", i);
 571         g_assert_cmpstr(elem->value, ==, str);
 572     }
 573
 574     g_string_free(gstr_union, true);
 575     g_string_free(gstr_list, true);
 576     qapi_free_UserDefNativeListUnion(cvalue);
 577 }
 578
 579 #define DOUBLE_STR_MAX 16
 580
 581 static void test_visitor_in_native_list_number(TestInputVisitorData *data,
 582                                                const void *unused)
 583 {
 584     UserDefNativeListUnion *cvalue = NULL;
 585     numberList *elem = NULL;
 586     Error *err = NULL;
 587     Visitor *v;
 588     GString *gstr_list = g_string_new("");
 589     GString *gstr_union = g_string_new("");
 590     int i;
 591
 592     for (i = 0; i < 32; i++) {
 593         g_string_append_printf(gstr_list, "%f", (double)i / 3);
 594         if (i != 31) {
 595             g_string_append(gstr_list, ", ");
 596         }
 597     }
 598     g_string_append_printf(gstr_union,  "{ 'type': 'number', 'data': [ %s ] }",
 599                            gstr_list->str);
 600     v = visitor_input_test_init_raw(data,  gstr_union->str);
 601
 602     visit_type_UserDefNativeListUnion(v, &cvalue, NULL, &err);
 603     g_assert(err == NULL);
 604     g_assert(cvalue != NULL);
 605     g_assert_cmpint(cvalue->kind, ==, USER_DEF_NATIVE_LIST_UNION_KIND_NUMBER);
 606
 607     for (i = 0, elem = cvalue->number; elem; elem = elem->next, i++) {
 608         GString *double_expected = g_string_new("");
 609         GString *double_actual = g_string_new("");
 610
 611         g_string_printf(double_expected, "%.6f", (double)i / 3);
 612         g_string_printf(double_actual, "%.6f", elem->value);
 613         g_assert_cmpstr(double_expected->str, ==, double_actual->str);
 614
 615         g_string_free(double_expected, true);
 616         g_string_free(double_actual, true);
 617     }
 618
 619     g_string_free(gstr_union, true);
 620     g_string_free(gstr_list, true);
 621     qapi_free_UserDefNativeListUnion(cvalue);
 622 }
 623
 624 static void input_visitor_test_add(const char *testpath,
 625                                    TestInputVisitorData *data,
 626                                    void (*test_func)(TestInputVisitorData *data, const void *user_data))
 627 {
 628     g_test_add(testpath, TestInputVisitorData, data, NULL, test_func,
 629                visitor_input_teardown);
 630 }
 631
 632 static void test_visitor_in_errors(TestInputVisitorData *data,
 633                                    const void *unused)
 634 {
 635     TestStruct *p = NULL;
 636     Error *err = NULL;
 637     Visitor *v;
 638
 639     v = visitor_input_test_init(data, "{ 'integer': false, 'boolean': 'foo', 'string': -42 }");
 640
 641     visit_type_TestStruct(v, &p, NULL, &err);
 642     g_assert(err);
 643     g_assert(p->string == NULL);
 644
 645     error_free(err);
 646     g_free(p->string);
 647     g_free(p);
 648 }
 649
 650 int main(int argc, char **argv)
 651 {
 652     TestInputVisitorData in_visitor_data;
 653
 654     g_test_init(&argc, &argv, NULL);
 655
 656     input_visitor_test_add("/visitor/input/int",
 657                            &in_visitor_data, test_visitor_in_int);
 658     input_visitor_test_add("/visitor/input/int_overflow",
 659                            &in_visitor_data, test_visitor_in_int_overflow);
 660     input_visitor_test_add("/visitor/input/bool",
 661                            &in_visitor_data, test_visitor_in_bool);
 662     input_visitor_test_add("/visitor/input/number",
 663                            &in_visitor_data, test_visitor_in_number);
 664     input_visitor_test_add("/visitor/input/string",
 665                             &in_visitor_data, test_visitor_in_string);
 666     input_visitor_test_add("/visitor/input/enum",
 667                             &in_visitor_data, test_visitor_in_enum);
 668     input_visitor_test_add("/visitor/input/struct",
 669                             &in_visitor_data, test_visitor_in_struct);
 670     input_visitor_test_add("/visitor/input/struct-nested",
 671                             &in_visitor_data, test_visitor_in_struct_nested);
 672     input_visitor_test_add("/visitor/input/list",
 673                             &in_visitor_data, test_visitor_in_list);
 674     input_visitor_test_add("/visitor/input/union",
 675                             &in_visitor_data, test_visitor_in_union);
 676     input_visitor_test_add("/visitor/input/union-flat",
 677                             &in_visitor_data, test_visitor_in_union_flat);
 678     input_visitor_test_add("/visitor/input/union-anon",
 679                             &in_visitor_data, test_visitor_in_union_anon);
 680     input_visitor_test_add("/visitor/input/errors",
 681                             &in_visitor_data, test_visitor_in_errors);
 682     input_visitor_test_add("/visitor/input/native_list/int",
 683                             &in_visitor_data,
 684                             test_visitor_in_native_list_int);
 685     input_visitor_test_add("/visitor/input/native_list/int8",
 686                             &in_visitor_data,
 687                             test_visitor_in_native_list_int8);
 688     input_visitor_test_add("/visitor/input/native_list/int16",
 689                             &in_visitor_data,
 690                             test_visitor_in_native_list_int16);
 691     input_visitor_test_add("/visitor/input/native_list/int32",
 692                             &in_visitor_data,
 693                             test_visitor_in_native_list_int32);
 694     input_visitor_test_add("/visitor/input/native_list/int64",
 695                             &in_visitor_data,
 696                             test_visitor_in_native_list_int64);
 697     input_visitor_test_add("/visitor/input/native_list/uint8",
 698                             &in_visitor_data,
 699                             test_visitor_in_native_list_uint8);
 700     input_visitor_test_add("/visitor/input/native_list/uint16",
 701                             &in_visitor_data,
 702                             test_visitor_in_native_list_uint16);
 703     input_visitor_test_add("/visitor/input/native_list/uint32",
 704                             &in_visitor_data,
 705                             test_visitor_in_native_list_uint32);
 706     input_visitor_test_add("/visitor/input/native_list/uint64",
 707                             &in_visitor_data, test_visitor_in_native_list_uint64);
 708     input_visitor_test_add("/visitor/input/native_list/bool",
 709                             &in_visitor_data, test_visitor_in_native_list_bool);
 710     input_visitor_test_add("/visitor/input/native_list/str",
 711                             &in_visitor_data, test_visitor_in_native_list_string);
 712     input_visitor_test_add("/visitor/input/native_list/number",
 713                             &in_visitor_data, test_visitor_in_native_list_number);
 714
 715     g_test_run();
 716
 717     return 0;
 718 }