test-qobject-output-visitor.c (19176B)
1 /* 2 * QObject Output Visitor unit-tests. 3 * 4 * Copyright (C) 2011-2016 Red Hat Inc. 5 * 6 * Authors: 7 * Luiz Capitulino <lcapitulino@redhat.com> 8 * 9 * This work is licensed under the terms of the GNU GPL, version 2 or later. 10 * See the COPYING file in the top-level directory. 11 */ 12 13 #include "qemu/osdep.h" 14 15 #include "qapi/error.h" 16 #include "qapi/qobject-output-visitor.h" 17 #include "test-qapi-visit.h" 18 #include "qapi/qmp/qbool.h" 19 #include "qapi/qmp/qdict.h" 20 #include "qapi/qmp/qlist.h" 21 #include "qapi/qmp/qnull.h" 22 #include "qapi/qmp/qnum.h" 23 #include "qapi/qmp/qstring.h" 24 25 typedef struct TestOutputVisitorData { 26 Visitor *ov; 27 QObject *obj; 28 } TestOutputVisitorData; 29 30 static void visitor_output_setup(TestOutputVisitorData *data, 31 const void *unused) 32 { 33 data->ov = qobject_output_visitor_new(&data->obj); 34 g_assert(data->ov); 35 } 36 37 static void visitor_output_teardown(TestOutputVisitorData *data, 38 const void *unused) 39 { 40 visit_free(data->ov); 41 data->ov = NULL; 42 qobject_unref(data->obj); 43 data->obj = NULL; 44 } 45 46 static QObject *visitor_get(TestOutputVisitorData *data) 47 { 48 visit_complete(data->ov, &data->obj); 49 g_assert(data->obj); 50 return data->obj; 51 } 52 53 static void visitor_reset(TestOutputVisitorData *data) 54 { 55 visitor_output_teardown(data, NULL); 56 visitor_output_setup(data, NULL); 57 } 58 59 static void test_visitor_out_int(TestOutputVisitorData *data, 60 const void *unused) 61 { 62 int64_t value = -42; 63 int64_t val; 64 QNum *qnum; 65 66 visit_type_int(data->ov, NULL, &value, &error_abort); 67 68 qnum = qobject_to(QNum, visitor_get(data)); 69 g_assert(qnum); 70 g_assert(qnum_get_try_int(qnum, &val)); 71 g_assert_cmpint(val, ==, value); 72 } 73 74 static void test_visitor_out_bool(TestOutputVisitorData *data, 75 const void *unused) 76 { 77 bool value = true; 78 QBool *qbool; 79 80 visit_type_bool(data->ov, NULL, &value, &error_abort); 81 82 qbool = qobject_to(QBool, visitor_get(data)); 83 g_assert(qbool); 84 g_assert(qbool_get_bool(qbool) == value); 85 } 86 87 static void test_visitor_out_number(TestOutputVisitorData *data, 88 const void *unused) 89 { 90 double value = 3.14; 91 QNum *qnum; 92 93 visit_type_number(data->ov, NULL, &value, &error_abort); 94 95 qnum = qobject_to(QNum, visitor_get(data)); 96 g_assert(qnum); 97 g_assert(qnum_get_double(qnum) == value); 98 } 99 100 static void test_visitor_out_string(TestOutputVisitorData *data, 101 const void *unused) 102 { 103 char *string = (char *) "Q E M U"; 104 QString *qstr; 105 106 visit_type_str(data->ov, NULL, &string, &error_abort); 107 108 qstr = qobject_to(QString, visitor_get(data)); 109 g_assert(qstr); 110 g_assert_cmpstr(qstring_get_str(qstr), ==, string); 111 } 112 113 static void test_visitor_out_no_string(TestOutputVisitorData *data, 114 const void *unused) 115 { 116 char *string = NULL; 117 QString *qstr; 118 119 /* A null string should return "" */ 120 visit_type_str(data->ov, NULL, &string, &error_abort); 121 122 qstr = qobject_to(QString, visitor_get(data)); 123 g_assert(qstr); 124 g_assert_cmpstr(qstring_get_str(qstr), ==, ""); 125 } 126 127 static void test_visitor_out_enum(TestOutputVisitorData *data, 128 const void *unused) 129 { 130 EnumOne i; 131 QString *qstr; 132 133 for (i = 0; i < ENUM_ONE__MAX; i++) { 134 visit_type_EnumOne(data->ov, "unused", &i, &error_abort); 135 136 qstr = qobject_to(QString, visitor_get(data)); 137 g_assert(qstr); 138 g_assert_cmpstr(qstring_get_str(qstr), ==, EnumOne_str(i)); 139 visitor_reset(data); 140 } 141 } 142 143 static void test_visitor_out_struct(TestOutputVisitorData *data, 144 const void *unused) 145 { 146 TestStruct test_struct = { .integer = 42, 147 .boolean = false, 148 .string = (char *) "foo"}; 149 TestStruct *p = &test_struct; 150 QDict *qdict; 151 152 visit_type_TestStruct(data->ov, NULL, &p, &error_abort); 153 154 qdict = qobject_to(QDict, visitor_get(data)); 155 g_assert(qdict); 156 g_assert_cmpint(qdict_size(qdict), ==, 3); 157 g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 42); 158 g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, false); 159 g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "foo"); 160 } 161 162 static void test_visitor_out_struct_nested(TestOutputVisitorData *data, 163 const void *unused) 164 { 165 int64_t value = 42; 166 UserDefTwo *ud2; 167 QDict *qdict, *dict1, *dict2, *dict3, *userdef; 168 const char *string = "user def string"; 169 const char *strings[] = { "forty two", "forty three", "forty four", 170 "forty five" }; 171 172 ud2 = g_malloc0(sizeof(*ud2)); 173 ud2->string0 = g_strdup(strings[0]); 174 175 ud2->dict1 = g_malloc0(sizeof(*ud2->dict1)); 176 ud2->dict1->string1 = g_strdup(strings[1]); 177 178 ud2->dict1->dict2 = g_malloc0(sizeof(*ud2->dict1->dict2)); 179 ud2->dict1->dict2->userdef = g_new0(UserDefOne, 1); 180 ud2->dict1->dict2->userdef->string = g_strdup(string); 181 ud2->dict1->dict2->userdef->integer = value; 182 ud2->dict1->dict2->string = g_strdup(strings[2]); 183 184 ud2->dict1->dict3 = g_malloc0(sizeof(*ud2->dict1->dict3)); 185 ud2->dict1->has_dict3 = true; 186 ud2->dict1->dict3->userdef = g_new0(UserDefOne, 1); 187 ud2->dict1->dict3->userdef->string = g_strdup(string); 188 ud2->dict1->dict3->userdef->integer = value; 189 ud2->dict1->dict3->string = g_strdup(strings[3]); 190 191 visit_type_UserDefTwo(data->ov, "unused", &ud2, &error_abort); 192 193 qdict = qobject_to(QDict, visitor_get(data)); 194 g_assert(qdict); 195 g_assert_cmpint(qdict_size(qdict), ==, 2); 196 g_assert_cmpstr(qdict_get_str(qdict, "string0"), ==, strings[0]); 197 198 dict1 = qdict_get_qdict(qdict, "dict1"); 199 g_assert_cmpint(qdict_size(dict1), ==, 3); 200 g_assert_cmpstr(qdict_get_str(dict1, "string1"), ==, strings[1]); 201 202 dict2 = qdict_get_qdict(dict1, "dict2"); 203 g_assert_cmpint(qdict_size(dict2), ==, 2); 204 g_assert_cmpstr(qdict_get_str(dict2, "string"), ==, strings[2]); 205 userdef = qdict_get_qdict(dict2, "userdef"); 206 g_assert_cmpint(qdict_size(userdef), ==, 2); 207 g_assert_cmpint(qdict_get_int(userdef, "integer"), ==, value); 208 g_assert_cmpstr(qdict_get_str(userdef, "string"), ==, string); 209 210 dict3 = qdict_get_qdict(dict1, "dict3"); 211 g_assert_cmpint(qdict_size(dict3), ==, 2); 212 g_assert_cmpstr(qdict_get_str(dict3, "string"), ==, strings[3]); 213 userdef = qdict_get_qdict(dict3, "userdef"); 214 g_assert_cmpint(qdict_size(userdef), ==, 2); 215 g_assert_cmpint(qdict_get_int(userdef, "integer"), ==, value); 216 g_assert_cmpstr(qdict_get_str(userdef, "string"), ==, string); 217 218 qapi_free_UserDefTwo(ud2); 219 } 220 221 static void test_visitor_out_list(TestOutputVisitorData *data, 222 const void *unused) 223 { 224 const char *value_str = "list value"; 225 TestStruct *value; 226 TestStructList *head = NULL; 227 const int max_items = 10; 228 bool value_bool = true; 229 int value_int = 10; 230 QListEntry *entry; 231 QList *qlist; 232 int i; 233 234 /* Build the list in reverse order... */ 235 for (i = 0; i < max_items; i++) { 236 value = g_malloc0(sizeof(*value)); 237 value->integer = value_int + (max_items - i - 1); 238 value->boolean = value_bool; 239 value->string = g_strdup(value_str); 240 241 QAPI_LIST_PREPEND(head, value); 242 } 243 244 visit_type_TestStructList(data->ov, NULL, &head, &error_abort); 245 246 qlist = qobject_to(QList, visitor_get(data)); 247 g_assert(qlist); 248 g_assert(!qlist_empty(qlist)); 249 250 /* ...and ensure that the visitor sees it in order */ 251 i = 0; 252 QLIST_FOREACH_ENTRY(qlist, entry) { 253 QDict *qdict; 254 255 qdict = qobject_to(QDict, entry->value); 256 g_assert(qdict); 257 g_assert_cmpint(qdict_size(qdict), ==, 3); 258 g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, value_int + i); 259 g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, value_bool); 260 g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, value_str); 261 i++; 262 } 263 g_assert_cmpint(i, ==, max_items); 264 265 qapi_free_TestStructList(head); 266 } 267 268 static void test_visitor_out_list_qapi_free(TestOutputVisitorData *data, 269 const void *unused) 270 { 271 UserDefTwo *value; 272 UserDefTwoList *head = NULL; 273 const char string[] = "foo bar"; 274 int i, max_count = 1024; 275 276 for (i = 0; i < max_count; i++) { 277 value = g_malloc0(sizeof(*value)); 278 279 value->string0 = g_strdup(string); 280 value->dict1 = g_new0(UserDefTwoDict, 1); 281 value->dict1->string1 = g_strdup(string); 282 value->dict1->dict2 = g_new0(UserDefTwoDictDict, 1); 283 value->dict1->dict2->userdef = g_new0(UserDefOne, 1); 284 value->dict1->dict2->userdef->string = g_strdup(string); 285 value->dict1->dict2->userdef->integer = 42; 286 value->dict1->dict2->string = g_strdup(string); 287 value->dict1->has_dict3 = false; 288 289 QAPI_LIST_PREPEND(head, value); 290 } 291 292 qapi_free_UserDefTwoList(head); 293 } 294 295 static void test_visitor_out_any(TestOutputVisitorData *data, 296 const void *unused) 297 { 298 QObject *qobj; 299 QNum *qnum; 300 QBool *qbool; 301 QString *qstring; 302 QDict *qdict; 303 int64_t val; 304 305 qobj = QOBJECT(qnum_from_int(-42)); 306 visit_type_any(data->ov, NULL, &qobj, &error_abort); 307 qnum = qobject_to(QNum, visitor_get(data)); 308 g_assert(qnum); 309 g_assert(qnum_get_try_int(qnum, &val)); 310 g_assert_cmpint(val, ==, -42); 311 qobject_unref(qobj); 312 313 visitor_reset(data); 314 qdict = qdict_new(); 315 qdict_put_int(qdict, "integer", -42); 316 qdict_put_bool(qdict, "boolean", true); 317 qdict_put_str(qdict, "string", "foo"); 318 qobj = QOBJECT(qdict); 319 visit_type_any(data->ov, NULL, &qobj, &error_abort); 320 qobject_unref(qobj); 321 qdict = qobject_to(QDict, visitor_get(data)); 322 g_assert(qdict); 323 qnum = qobject_to(QNum, qdict_get(qdict, "integer")); 324 g_assert(qnum); 325 g_assert(qnum_get_try_int(qnum, &val)); 326 g_assert_cmpint(val, ==, -42); 327 qbool = qobject_to(QBool, qdict_get(qdict, "boolean")); 328 g_assert(qbool); 329 g_assert(qbool_get_bool(qbool) == true); 330 qstring = qobject_to(QString, qdict_get(qdict, "string")); 331 g_assert(qstring); 332 g_assert_cmpstr(qstring_get_str(qstring), ==, "foo"); 333 } 334 335 static void test_visitor_out_union_flat(TestOutputVisitorData *data, 336 const void *unused) 337 { 338 QDict *qdict; 339 340 UserDefFlatUnion *tmp = g_new0(UserDefFlatUnion, 1); 341 tmp->enum1 = ENUM_ONE_VALUE1; 342 tmp->string = g_strdup("str"); 343 tmp->integer = 41; 344 tmp->u.value1.boolean = true; 345 346 visit_type_UserDefFlatUnion(data->ov, NULL, &tmp, &error_abort); 347 qdict = qobject_to(QDict, visitor_get(data)); 348 g_assert(qdict); 349 g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value1"); 350 g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "str"); 351 g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 41); 352 g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, true); 353 354 qapi_free_UserDefFlatUnion(tmp); 355 } 356 357 static void test_visitor_out_alternate(TestOutputVisitorData *data, 358 const void *unused) 359 { 360 UserDefAlternate *tmp; 361 QNum *qnum; 362 QString *qstr; 363 QDict *qdict; 364 int64_t val; 365 366 tmp = g_new0(UserDefAlternate, 1); 367 tmp->type = QTYPE_QNUM; 368 tmp->u.i = 42; 369 370 visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort); 371 qnum = qobject_to(QNum, visitor_get(data)); 372 g_assert(qnum); 373 g_assert(qnum_get_try_int(qnum, &val)); 374 g_assert_cmpint(val, ==, 42); 375 376 qapi_free_UserDefAlternate(tmp); 377 378 visitor_reset(data); 379 tmp = g_new0(UserDefAlternate, 1); 380 tmp->type = QTYPE_QSTRING; 381 tmp->u.e = ENUM_ONE_VALUE1; 382 383 visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort); 384 qstr = qobject_to(QString, visitor_get(data)); 385 g_assert(qstr); 386 g_assert_cmpstr(qstring_get_str(qstr), ==, "value1"); 387 388 qapi_free_UserDefAlternate(tmp); 389 390 visitor_reset(data); 391 tmp = g_new0(UserDefAlternate, 1); 392 tmp->type = QTYPE_QNULL; 393 tmp->u.n = qnull(); 394 395 visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort); 396 g_assert_cmpint(qobject_type(visitor_get(data)), ==, QTYPE_QNULL); 397 398 qapi_free_UserDefAlternate(tmp); 399 400 visitor_reset(data); 401 tmp = g_new0(UserDefAlternate, 1); 402 tmp->type = QTYPE_QDICT; 403 tmp->u.udfu.integer = 1; 404 tmp->u.udfu.string = g_strdup("str"); 405 tmp->u.udfu.enum1 = ENUM_ONE_VALUE1; 406 tmp->u.udfu.u.value1.boolean = true; 407 408 visit_type_UserDefAlternate(data->ov, NULL, &tmp, &error_abort); 409 qdict = qobject_to(QDict, visitor_get(data)); 410 g_assert(qdict); 411 g_assert_cmpint(qdict_size(qdict), ==, 4); 412 g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 1); 413 g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, "str"); 414 g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value1"); 415 g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, true); 416 417 qapi_free_UserDefAlternate(tmp); 418 } 419 420 static void test_visitor_out_null(TestOutputVisitorData *data, 421 const void *unused) 422 { 423 QNull *null = NULL; 424 QDict *qdict; 425 QObject *nil; 426 427 visit_start_struct(data->ov, NULL, NULL, 0, &error_abort); 428 visit_type_null(data->ov, "a", &null, &error_abort); 429 visit_check_struct(data->ov, &error_abort); 430 visit_end_struct(data->ov, NULL); 431 qdict = qobject_to(QDict, visitor_get(data)); 432 g_assert(qdict); 433 g_assert_cmpint(qdict_size(qdict), ==, 1); 434 nil = qdict_get(qdict, "a"); 435 g_assert(nil); 436 g_assert(qobject_type(nil) == QTYPE_QNULL); 437 } 438 439 static void test_visitor_out_list_struct(TestOutputVisitorData *data, 440 const void *unused) 441 { 442 const char *int_member[] = { 443 "integer", "s8", "s16", "s32", "s64", "u8", "u16", "u32", "u64" }; 444 g_autoptr(ArrayStruct) arrs = g_new0(ArrayStruct, 1); 445 int i, j; 446 QDict *qdict; 447 QList *qlist; 448 QListEntry *e; 449 450 for (i = 31; i >= 0; i--) { 451 QAPI_LIST_PREPEND(arrs->integer, i); 452 } 453 454 for (i = 31; i >= 0; i--) { 455 QAPI_LIST_PREPEND(arrs->s8, i); 456 } 457 458 for (i = 31; i >= 0; i--) { 459 QAPI_LIST_PREPEND(arrs->s16, i); 460 } 461 462 for (i = 31; i >= 0; i--) { 463 QAPI_LIST_PREPEND(arrs->s32, i); 464 } 465 466 for (i = 31; i >= 0; i--) { 467 QAPI_LIST_PREPEND(arrs->s64, i); 468 } 469 470 for (i = 31; i >= 0; i--) { 471 QAPI_LIST_PREPEND(arrs->u8, i); 472 } 473 474 for (i = 31; i >= 0; i--) { 475 QAPI_LIST_PREPEND(arrs->u16, i); 476 } 477 478 for (i = 31; i >= 0; i--) { 479 QAPI_LIST_PREPEND(arrs->u32, i); 480 } 481 482 for (i = 31; i >= 0; i--) { 483 QAPI_LIST_PREPEND(arrs->u64, i); 484 } 485 486 for (i = 31; i >= 0; i--) { 487 QAPI_LIST_PREPEND(arrs->number, (double)i / 3); 488 } 489 490 for (i = 31; i >= 0; i--) { 491 QAPI_LIST_PREPEND(arrs->boolean, QEMU_IS_ALIGNED(i, 3)); 492 } 493 494 for (i = 31; i >= 0; i--) { 495 QAPI_LIST_PREPEND(arrs->string, g_strdup_printf("%d", i)); 496 } 497 498 visit_type_ArrayStruct(data->ov, NULL, &arrs, &error_abort); 499 500 qdict = qobject_to(QDict, visitor_get(data)); 501 g_assert(qdict); 502 503 for (i = 0; i < G_N_ELEMENTS(int_member); i++) { 504 qlist = qdict_get_qlist(qdict, int_member[i]); 505 g_assert(qlist); 506 j = 0; 507 QLIST_FOREACH_ENTRY(qlist, e) { 508 QNum *qvalue = qobject_to(QNum, qlist_entry_obj(e)); 509 g_assert(qvalue); 510 g_assert_cmpint(qnum_get_int(qvalue), ==, j); 511 j++; 512 } 513 } 514 515 qlist = qdict_get_qlist(qdict, "number"); 516 g_assert(qlist); 517 i = 0; 518 QLIST_FOREACH_ENTRY(qlist, e) { 519 QNum *qvalue = qobject_to(QNum, qlist_entry_obj(e)); 520 char expected[32], actual[32]; 521 522 g_assert(qvalue); 523 sprintf(expected, "%.6f", (double)i / 3); 524 sprintf(actual, "%.6f", qnum_get_double(qvalue)); 525 g_assert_cmpstr(actual, ==, expected); 526 i++; 527 } 528 529 qlist = qdict_get_qlist(qdict, "boolean"); 530 g_assert(qlist); 531 i = 0; 532 QLIST_FOREACH_ENTRY(qlist, e) { 533 QBool *qvalue = qobject_to(QBool, qlist_entry_obj(e)); 534 g_assert(qvalue); 535 g_assert_cmpint(qbool_get_bool(qvalue), ==, i % 3 == 0); 536 i++; 537 } 538 539 qlist = qdict_get_qlist(qdict, "string"); 540 g_assert(qlist); 541 i = 0; 542 QLIST_FOREACH_ENTRY(qlist, e) { 543 QString *qvalue = qobject_to(QString, qlist_entry_obj(e)); 544 char expected[32]; 545 546 g_assert(qvalue); 547 sprintf(expected, "%d", i); 548 g_assert_cmpstr(qstring_get_str(qvalue), ==, expected); 549 i++; 550 } 551 } 552 553 static void output_visitor_test_add(const char *testpath, 554 TestOutputVisitorData *data, 555 void (*test_func)(TestOutputVisitorData *data, const void *user_data)) 556 { 557 g_test_add(testpath, TestOutputVisitorData, data, visitor_output_setup, 558 test_func, visitor_output_teardown); 559 } 560 561 int main(int argc, char **argv) 562 { 563 TestOutputVisitorData out_visitor_data; 564 565 g_test_init(&argc, &argv, NULL); 566 567 output_visitor_test_add("/visitor/output/int", 568 &out_visitor_data, test_visitor_out_int); 569 output_visitor_test_add("/visitor/output/bool", 570 &out_visitor_data, test_visitor_out_bool); 571 output_visitor_test_add("/visitor/output/number", 572 &out_visitor_data, test_visitor_out_number); 573 output_visitor_test_add("/visitor/output/string", 574 &out_visitor_data, test_visitor_out_string); 575 output_visitor_test_add("/visitor/output/no-string", 576 &out_visitor_data, test_visitor_out_no_string); 577 output_visitor_test_add("/visitor/output/enum", 578 &out_visitor_data, test_visitor_out_enum); 579 output_visitor_test_add("/visitor/output/struct", 580 &out_visitor_data, test_visitor_out_struct); 581 output_visitor_test_add("/visitor/output/struct-nested", 582 &out_visitor_data, test_visitor_out_struct_nested); 583 output_visitor_test_add("/visitor/output/list", 584 &out_visitor_data, test_visitor_out_list); 585 output_visitor_test_add("/visitor/output/any", 586 &out_visitor_data, test_visitor_out_any); 587 output_visitor_test_add("/visitor/output/list-qapi-free", 588 &out_visitor_data, test_visitor_out_list_qapi_free); 589 output_visitor_test_add("/visitor/output/union-flat", 590 &out_visitor_data, test_visitor_out_union_flat); 591 output_visitor_test_add("/visitor/output/alternate", 592 &out_visitor_data, test_visitor_out_alternate); 593 output_visitor_test_add("/visitor/output/null", 594 &out_visitor_data, test_visitor_out_null); 595 output_visitor_test_add("/visitor/output/list_struct", 596 &out_visitor_data, test_visitor_out_list_struct); 597 598 g_test_run(); 599 600 return 0; 601 }