1 /* 2 * Unit-tests for visitor-based serialization 3 * 4 * Copyright (C) 2014-2015 Red Hat, Inc. 5 * Copyright IBM, Corp. 2012 6 * 7 * Authors: 8 * Michael Roth <mdroth@linux.vnet.ibm.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 #include <float.h> 16 17 #include "test-qapi-visit.h" 18 #include "qapi/error.h" 19 #include "qapi/qmp/qjson.h" 20 #include "qapi/qmp/qstring.h" 21 #include "qapi/qobject-input-visitor.h" 22 #include "qapi/qobject-output-visitor.h" 23 #include "qapi/string-input-visitor.h" 24 #include "qapi/string-output-visitor.h" 25 #include "qapi/dealloc-visitor.h" 26 27 enum PrimitiveTypeKind { 28 PTYPE_STRING = 0, 29 PTYPE_BOOLEAN, 30 PTYPE_NUMBER, 31 PTYPE_INTEGER, 32 PTYPE_U8, 33 PTYPE_U16, 34 PTYPE_U32, 35 PTYPE_U64, 36 PTYPE_S8, 37 PTYPE_S16, 38 PTYPE_S32, 39 PTYPE_S64, 40 PTYPE_EOL, 41 }; 42 43 typedef struct PrimitiveType { 44 union { 45 const char *string; 46 bool boolean; 47 double number; 48 int64_t integer; 49 uint8_t u8; 50 uint16_t u16; 51 uint32_t u32; 52 uint64_t u64; 53 int8_t s8; 54 int16_t s16; 55 int32_t s32; 56 int64_t s64; 57 } value; 58 enum PrimitiveTypeKind type; 59 const char *description; 60 } PrimitiveType; 61 62 typedef struct PrimitiveList { 63 union { 64 strList *strings; 65 boolList *booleans; 66 numberList *numbers; 67 intList *integers; 68 int8List *s8_integers; 69 int16List *s16_integers; 70 int32List *s32_integers; 71 int64List *s64_integers; 72 uint8List *u8_integers; 73 uint16List *u16_integers; 74 uint32List *u32_integers; 75 uint64List *u64_integers; 76 } value; 77 enum PrimitiveTypeKind type; 78 const char *description; 79 } PrimitiveList; 80 81 /* test helpers */ 82 83 typedef void (*VisitorFunc)(Visitor *v, void **native, Error **errp); 84 85 static void dealloc_helper(void *native_in, VisitorFunc visit, Error **errp) 86 { 87 Visitor *v = qapi_dealloc_visitor_new(); 88 89 visit(v, &native_in, errp); 90 91 visit_free(v); 92 } 93 94 static void visit_primitive_type(Visitor *v, void **native, Error **errp) 95 { 96 PrimitiveType *pt = *native; 97 switch(pt->type) { 98 case PTYPE_STRING: 99 visit_type_str(v, NULL, (char **)&pt->value.string, errp); 100 break; 101 case PTYPE_BOOLEAN: 102 visit_type_bool(v, NULL, &pt->value.boolean, errp); 103 break; 104 case PTYPE_NUMBER: 105 visit_type_number(v, NULL, &pt->value.number, errp); 106 break; 107 case PTYPE_INTEGER: 108 visit_type_int(v, NULL, &pt->value.integer, errp); 109 break; 110 case PTYPE_U8: 111 visit_type_uint8(v, NULL, &pt->value.u8, errp); 112 break; 113 case PTYPE_U16: 114 visit_type_uint16(v, NULL, &pt->value.u16, errp); 115 break; 116 case PTYPE_U32: 117 visit_type_uint32(v, NULL, &pt->value.u32, errp); 118 break; 119 case PTYPE_U64: 120 visit_type_uint64(v, NULL, &pt->value.u64, errp); 121 break; 122 case PTYPE_S8: 123 visit_type_int8(v, NULL, &pt->value.s8, errp); 124 break; 125 case PTYPE_S16: 126 visit_type_int16(v, NULL, &pt->value.s16, errp); 127 break; 128 case PTYPE_S32: 129 visit_type_int32(v, NULL, &pt->value.s32, errp); 130 break; 131 case PTYPE_S64: 132 visit_type_int64(v, NULL, &pt->value.s64, errp); 133 break; 134 case PTYPE_EOL: 135 g_assert_not_reached(); 136 } 137 } 138 139 static void visit_primitive_list(Visitor *v, void **native, Error **errp) 140 { 141 PrimitiveList *pl = *native; 142 switch (pl->type) { 143 case PTYPE_STRING: 144 visit_type_strList(v, NULL, &pl->value.strings, errp); 145 break; 146 case PTYPE_BOOLEAN: 147 visit_type_boolList(v, NULL, &pl->value.booleans, errp); 148 break; 149 case PTYPE_NUMBER: 150 visit_type_numberList(v, NULL, &pl->value.numbers, errp); 151 break; 152 case PTYPE_INTEGER: 153 visit_type_intList(v, NULL, &pl->value.integers, errp); 154 break; 155 case PTYPE_S8: 156 visit_type_int8List(v, NULL, &pl->value.s8_integers, errp); 157 break; 158 case PTYPE_S16: 159 visit_type_int16List(v, NULL, &pl->value.s16_integers, errp); 160 break; 161 case PTYPE_S32: 162 visit_type_int32List(v, NULL, &pl->value.s32_integers, errp); 163 break; 164 case PTYPE_S64: 165 visit_type_int64List(v, NULL, &pl->value.s64_integers, errp); 166 break; 167 case PTYPE_U8: 168 visit_type_uint8List(v, NULL, &pl->value.u8_integers, errp); 169 break; 170 case PTYPE_U16: 171 visit_type_uint16List(v, NULL, &pl->value.u16_integers, errp); 172 break; 173 case PTYPE_U32: 174 visit_type_uint32List(v, NULL, &pl->value.u32_integers, errp); 175 break; 176 case PTYPE_U64: 177 visit_type_uint64List(v, NULL, &pl->value.u64_integers, errp); 178 break; 179 default: 180 g_assert_not_reached(); 181 } 182 } 183 184 185 static TestStruct *struct_create(void) 186 { 187 TestStruct *ts = g_malloc0(sizeof(*ts)); 188 ts->integer = -42; 189 ts->boolean = true; 190 ts->string = strdup("test string"); 191 return ts; 192 } 193 194 static void struct_compare(TestStruct *ts1, TestStruct *ts2) 195 { 196 g_assert(ts1); 197 g_assert(ts2); 198 g_assert_cmpint(ts1->integer, ==, ts2->integer); 199 g_assert(ts1->boolean == ts2->boolean); 200 g_assert_cmpstr(ts1->string, ==, ts2->string); 201 } 202 203 static void struct_cleanup(TestStruct *ts) 204 { 205 g_free(ts->string); 206 g_free(ts); 207 } 208 209 static void visit_struct(Visitor *v, void **native, Error **errp) 210 { 211 visit_type_TestStruct(v, NULL, (TestStruct **)native, errp); 212 } 213 214 static UserDefTwo *nested_struct_create(void) 215 { 216 UserDefTwo *udnp = g_malloc0(sizeof(*udnp)); 217 udnp->string0 = strdup("test_string0"); 218 udnp->dict1 = g_malloc0(sizeof(*udnp->dict1)); 219 udnp->dict1->string1 = strdup("test_string1"); 220 udnp->dict1->dict2 = g_malloc0(sizeof(*udnp->dict1->dict2)); 221 udnp->dict1->dict2->userdef = g_new0(UserDefOne, 1); 222 udnp->dict1->dict2->userdef->integer = 42; 223 udnp->dict1->dict2->userdef->string = strdup("test_string"); 224 udnp->dict1->dict2->string = strdup("test_string2"); 225 udnp->dict1->dict3 = g_malloc0(sizeof(*udnp->dict1->dict3)); 226 udnp->dict1->has_dict3 = true; 227 udnp->dict1->dict3->userdef = g_new0(UserDefOne, 1); 228 udnp->dict1->dict3->userdef->integer = 43; 229 udnp->dict1->dict3->userdef->string = strdup("test_string"); 230 udnp->dict1->dict3->string = strdup("test_string3"); 231 return udnp; 232 } 233 234 static void nested_struct_compare(UserDefTwo *udnp1, UserDefTwo *udnp2) 235 { 236 g_assert(udnp1); 237 g_assert(udnp2); 238 g_assert_cmpstr(udnp1->string0, ==, udnp2->string0); 239 g_assert_cmpstr(udnp1->dict1->string1, ==, udnp2->dict1->string1); 240 g_assert_cmpint(udnp1->dict1->dict2->userdef->integer, ==, 241 udnp2->dict1->dict2->userdef->integer); 242 g_assert_cmpstr(udnp1->dict1->dict2->userdef->string, ==, 243 udnp2->dict1->dict2->userdef->string); 244 g_assert_cmpstr(udnp1->dict1->dict2->string, ==, 245 udnp2->dict1->dict2->string); 246 g_assert(udnp1->dict1->has_dict3 == udnp2->dict1->has_dict3); 247 g_assert_cmpint(udnp1->dict1->dict3->userdef->integer, ==, 248 udnp2->dict1->dict3->userdef->integer); 249 g_assert_cmpstr(udnp1->dict1->dict3->userdef->string, ==, 250 udnp2->dict1->dict3->userdef->string); 251 g_assert_cmpstr(udnp1->dict1->dict3->string, ==, 252 udnp2->dict1->dict3->string); 253 } 254 255 static void nested_struct_cleanup(UserDefTwo *udnp) 256 { 257 qapi_free_UserDefTwo(udnp); 258 } 259 260 static void visit_nested_struct(Visitor *v, void **native, Error **errp) 261 { 262 visit_type_UserDefTwo(v, NULL, (UserDefTwo **)native, errp); 263 } 264 265 static void visit_nested_struct_list(Visitor *v, void **native, Error **errp) 266 { 267 visit_type_UserDefTwoList(v, NULL, (UserDefTwoList **)native, errp); 268 } 269 270 /* test cases */ 271 272 typedef enum VisitorCapabilities { 273 VCAP_PRIMITIVES = 1, 274 VCAP_STRUCTURES = 2, 275 VCAP_LISTS = 4, 276 VCAP_PRIMITIVE_LISTS = 8, 277 } VisitorCapabilities; 278 279 typedef struct SerializeOps { 280 void (*serialize)(void *native_in, void **datap, 281 VisitorFunc visit, Error **errp); 282 void (*deserialize)(void **native_out, void *datap, 283 VisitorFunc visit, Error **errp); 284 void (*cleanup)(void *datap); 285 const char *type; 286 VisitorCapabilities caps; 287 } SerializeOps; 288 289 typedef struct TestArgs { 290 const SerializeOps *ops; 291 void *test_data; 292 } TestArgs; 293 294 static void test_primitives(gconstpointer opaque) 295 { 296 TestArgs *args = (TestArgs *) opaque; 297 const SerializeOps *ops = args->ops; 298 PrimitiveType *pt = args->test_data; 299 PrimitiveType *pt_copy = g_malloc0(sizeof(*pt_copy)); 300 void *serialize_data; 301 302 pt_copy->type = pt->type; 303 ops->serialize(pt, &serialize_data, visit_primitive_type, &error_abort); 304 ops->deserialize((void **)&pt_copy, serialize_data, visit_primitive_type, 305 &error_abort); 306 307 g_assert(pt_copy != NULL); 308 switch (pt->type) { 309 case PTYPE_STRING: 310 g_assert_cmpstr(pt->value.string, ==, pt_copy->value.string); 311 g_free((char *)pt_copy->value.string); 312 break; 313 case PTYPE_BOOLEAN: 314 g_assert_cmpint(pt->value.boolean, ==, pt->value.boolean); 315 break; 316 case PTYPE_NUMBER: 317 g_assert_cmpfloat(pt->value.number, ==, pt_copy->value.number); 318 break; 319 case PTYPE_INTEGER: 320 g_assert_cmpint(pt->value.integer, ==, pt_copy->value.integer); 321 break; 322 case PTYPE_U8: 323 g_assert_cmpuint(pt->value.u8, ==, pt_copy->value.u8); 324 break; 325 case PTYPE_U16: 326 g_assert_cmpuint(pt->value.u16, ==, pt_copy->value.u16); 327 break; 328 case PTYPE_U32: 329 g_assert_cmpuint(pt->value.u32, ==, pt_copy->value.u32); 330 break; 331 case PTYPE_U64: 332 g_assert_cmpuint(pt->value.u64, ==, pt_copy->value.u64); 333 break; 334 case PTYPE_S8: 335 g_assert_cmpint(pt->value.s8, ==, pt_copy->value.s8); 336 break; 337 case PTYPE_S16: 338 g_assert_cmpint(pt->value.s16, ==, pt_copy->value.s16); 339 break; 340 case PTYPE_S32: 341 g_assert_cmpint(pt->value.s32, ==, pt_copy->value.s32); 342 break; 343 case PTYPE_S64: 344 g_assert_cmpint(pt->value.s64, ==, pt_copy->value.s64); 345 break; 346 case PTYPE_EOL: 347 g_assert_not_reached(); 348 } 349 350 ops->cleanup(serialize_data); 351 g_free(args); 352 g_free(pt_copy); 353 } 354 355 static void test_primitive_lists(gconstpointer opaque) 356 { 357 TestArgs *args = (TestArgs *) opaque; 358 const SerializeOps *ops = args->ops; 359 PrimitiveType *pt = args->test_data; 360 PrimitiveList pl = { .value = { NULL } }; 361 PrimitiveList pl_copy = { .value = { NULL } }; 362 PrimitiveList *pl_copy_ptr = &pl_copy; 363 void *serialize_data; 364 void *cur_head = NULL; 365 int i; 366 367 pl.type = pl_copy.type = pt->type; 368 369 /* build up our list of primitive types */ 370 for (i = 0; i < 32; i++) { 371 switch (pl.type) { 372 case PTYPE_STRING: { 373 QAPI_LIST_PREPEND(pl.value.strings, g_strdup(pt->value.string)); 374 break; 375 } 376 case PTYPE_INTEGER: { 377 QAPI_LIST_PREPEND(pl.value.integers, pt->value.integer); 378 break; 379 } 380 case PTYPE_S8: { 381 QAPI_LIST_PREPEND(pl.value.s8_integers, pt->value.s8); 382 break; 383 } 384 case PTYPE_S16: { 385 QAPI_LIST_PREPEND(pl.value.s16_integers, pt->value.s16); 386 break; 387 } 388 case PTYPE_S32: { 389 QAPI_LIST_PREPEND(pl.value.s32_integers, pt->value.s32); 390 break; 391 } 392 case PTYPE_S64: { 393 QAPI_LIST_PREPEND(pl.value.s64_integers, pt->value.s64); 394 break; 395 } 396 case PTYPE_U8: { 397 QAPI_LIST_PREPEND(pl.value.u8_integers, pt->value.u8); 398 break; 399 } 400 case PTYPE_U16: { 401 QAPI_LIST_PREPEND(pl.value.u16_integers, pt->value.u16); 402 break; 403 } 404 case PTYPE_U32: { 405 QAPI_LIST_PREPEND(pl.value.u32_integers, pt->value.u32); 406 break; 407 } 408 case PTYPE_U64: { 409 QAPI_LIST_PREPEND(pl.value.u64_integers, pt->value.u64); 410 break; 411 } 412 case PTYPE_NUMBER: { 413 QAPI_LIST_PREPEND(pl.value.numbers, pt->value.number); 414 break; 415 } 416 case PTYPE_BOOLEAN: { 417 QAPI_LIST_PREPEND(pl.value.booleans, pt->value.boolean); 418 break; 419 } 420 default: 421 g_assert_not_reached(); 422 } 423 } 424 425 ops->serialize((void **)&pl, &serialize_data, visit_primitive_list, 426 &error_abort); 427 ops->deserialize((void **)&pl_copy_ptr, serialize_data, 428 visit_primitive_list, &error_abort); 429 430 i = 0; 431 432 /* compare our deserialized list of primitives to the original */ 433 do { 434 switch (pl_copy.type) { 435 case PTYPE_STRING: { 436 strList *ptr; 437 if (cur_head) { 438 ptr = cur_head; 439 cur_head = ptr->next; 440 } else { 441 cur_head = ptr = pl_copy.value.strings; 442 } 443 g_assert_cmpstr(pt->value.string, ==, ptr->value); 444 break; 445 } 446 case PTYPE_INTEGER: { 447 intList *ptr; 448 if (cur_head) { 449 ptr = cur_head; 450 cur_head = ptr->next; 451 } else { 452 cur_head = ptr = pl_copy.value.integers; 453 } 454 g_assert_cmpint(pt->value.integer, ==, ptr->value); 455 break; 456 } 457 case PTYPE_S8: { 458 int8List *ptr; 459 if (cur_head) { 460 ptr = cur_head; 461 cur_head = ptr->next; 462 } else { 463 cur_head = ptr = pl_copy.value.s8_integers; 464 } 465 g_assert_cmpint(pt->value.s8, ==, ptr->value); 466 break; 467 } 468 case PTYPE_S16: { 469 int16List *ptr; 470 if (cur_head) { 471 ptr = cur_head; 472 cur_head = ptr->next; 473 } else { 474 cur_head = ptr = pl_copy.value.s16_integers; 475 } 476 g_assert_cmpint(pt->value.s16, ==, ptr->value); 477 break; 478 } 479 case PTYPE_S32: { 480 int32List *ptr; 481 if (cur_head) { 482 ptr = cur_head; 483 cur_head = ptr->next; 484 } else { 485 cur_head = ptr = pl_copy.value.s32_integers; 486 } 487 g_assert_cmpint(pt->value.s32, ==, ptr->value); 488 break; 489 } 490 case PTYPE_S64: { 491 int64List *ptr; 492 if (cur_head) { 493 ptr = cur_head; 494 cur_head = ptr->next; 495 } else { 496 cur_head = ptr = pl_copy.value.s64_integers; 497 } 498 g_assert_cmpint(pt->value.s64, ==, ptr->value); 499 break; 500 } 501 case PTYPE_U8: { 502 uint8List *ptr; 503 if (cur_head) { 504 ptr = cur_head; 505 cur_head = ptr->next; 506 } else { 507 cur_head = ptr = pl_copy.value.u8_integers; 508 } 509 g_assert_cmpint(pt->value.u8, ==, ptr->value); 510 break; 511 } 512 case PTYPE_U16: { 513 uint16List *ptr; 514 if (cur_head) { 515 ptr = cur_head; 516 cur_head = ptr->next; 517 } else { 518 cur_head = ptr = pl_copy.value.u16_integers; 519 } 520 g_assert_cmpint(pt->value.u16, ==, ptr->value); 521 break; 522 } 523 case PTYPE_U32: { 524 uint32List *ptr; 525 if (cur_head) { 526 ptr = cur_head; 527 cur_head = ptr->next; 528 } else { 529 cur_head = ptr = pl_copy.value.u32_integers; 530 } 531 g_assert_cmpint(pt->value.u32, ==, ptr->value); 532 break; 533 } 534 case PTYPE_U64: { 535 uint64List *ptr; 536 if (cur_head) { 537 ptr = cur_head; 538 cur_head = ptr->next; 539 } else { 540 cur_head = ptr = pl_copy.value.u64_integers; 541 } 542 g_assert_cmpint(pt->value.u64, ==, ptr->value); 543 break; 544 } 545 case PTYPE_NUMBER: { 546 numberList *ptr; 547 GString *double_expected = g_string_new(""); 548 GString *double_actual = g_string_new(""); 549 if (cur_head) { 550 ptr = cur_head; 551 cur_head = ptr->next; 552 } else { 553 cur_head = ptr = pl_copy.value.numbers; 554 } 555 /* we serialize with %f for our reference visitors, so rather than 556 * fuzzy floating math to test "equality", just compare the 557 * formatted values 558 */ 559 g_string_printf(double_expected, "%.6f", pt->value.number); 560 g_string_printf(double_actual, "%.6f", ptr->value); 561 g_assert_cmpstr(double_actual->str, ==, double_expected->str); 562 g_string_free(double_expected, true); 563 g_string_free(double_actual, true); 564 break; 565 } 566 case PTYPE_BOOLEAN: { 567 boolList *ptr; 568 if (cur_head) { 569 ptr = cur_head; 570 cur_head = ptr->next; 571 } else { 572 cur_head = ptr = pl_copy.value.booleans; 573 } 574 g_assert_cmpint(!!pt->value.boolean, ==, !!ptr->value); 575 break; 576 } 577 default: 578 g_assert_not_reached(); 579 } 580 i++; 581 } while (cur_head); 582 583 g_assert_cmpint(i, ==, 33); 584 585 ops->cleanup(serialize_data); 586 dealloc_helper(&pl, visit_primitive_list, &error_abort); 587 dealloc_helper(&pl_copy, visit_primitive_list, &error_abort); 588 g_free(args); 589 } 590 591 static void test_struct(gconstpointer opaque) 592 { 593 TestArgs *args = (TestArgs *) opaque; 594 const SerializeOps *ops = args->ops; 595 TestStruct *ts = struct_create(); 596 TestStruct *ts_copy = NULL; 597 void *serialize_data; 598 599 ops->serialize(ts, &serialize_data, visit_struct, &error_abort); 600 ops->deserialize((void **)&ts_copy, serialize_data, visit_struct, 601 &error_abort); 602 603 struct_compare(ts, ts_copy); 604 605 struct_cleanup(ts); 606 struct_cleanup(ts_copy); 607 608 ops->cleanup(serialize_data); 609 g_free(args); 610 } 611 612 static void test_nested_struct(gconstpointer opaque) 613 { 614 TestArgs *args = (TestArgs *) opaque; 615 const SerializeOps *ops = args->ops; 616 UserDefTwo *udnp = nested_struct_create(); 617 UserDefTwo *udnp_copy = NULL; 618 void *serialize_data; 619 620 ops->serialize(udnp, &serialize_data, visit_nested_struct, &error_abort); 621 ops->deserialize((void **)&udnp_copy, serialize_data, visit_nested_struct, 622 &error_abort); 623 624 nested_struct_compare(udnp, udnp_copy); 625 626 nested_struct_cleanup(udnp); 627 nested_struct_cleanup(udnp_copy); 628 629 ops->cleanup(serialize_data); 630 g_free(args); 631 } 632 633 static void test_nested_struct_list(gconstpointer opaque) 634 { 635 TestArgs *args = (TestArgs *) opaque; 636 const SerializeOps *ops = args->ops; 637 UserDefTwoList *listp = NULL, *tmp, *tmp_copy, *listp_copy = NULL; 638 void *serialize_data; 639 int i = 0; 640 641 for (i = 0; i < 8; i++) { 642 QAPI_LIST_PREPEND(listp, nested_struct_create()); 643 } 644 645 ops->serialize(listp, &serialize_data, visit_nested_struct_list, 646 &error_abort); 647 ops->deserialize((void **)&listp_copy, serialize_data, 648 visit_nested_struct_list, &error_abort); 649 650 tmp = listp; 651 tmp_copy = listp_copy; 652 while (listp_copy) { 653 g_assert(listp); 654 nested_struct_compare(listp->value, listp_copy->value); 655 listp = listp->next; 656 listp_copy = listp_copy->next; 657 } 658 659 qapi_free_UserDefTwoList(tmp); 660 qapi_free_UserDefTwoList(tmp_copy); 661 662 ops->cleanup(serialize_data); 663 g_free(args); 664 } 665 666 static PrimitiveType pt_values[] = { 667 /* string tests */ 668 { 669 .description = "string_empty", 670 .type = PTYPE_STRING, 671 .value.string = "", 672 }, 673 { 674 .description = "string_whitespace", 675 .type = PTYPE_STRING, 676 .value.string = "a b c\td", 677 }, 678 { 679 .description = "string_newlines", 680 .type = PTYPE_STRING, 681 .value.string = "a\nb\n", 682 }, 683 { 684 .description = "string_commas", 685 .type = PTYPE_STRING, 686 .value.string = "a,b, c,d", 687 }, 688 { 689 .description = "string_single_quoted", 690 .type = PTYPE_STRING, 691 .value.string = "'a b',cd", 692 }, 693 { 694 .description = "string_double_quoted", 695 .type = PTYPE_STRING, 696 .value.string = "\"a b\",cd", 697 }, 698 /* boolean tests */ 699 { 700 .description = "boolean_true1", 701 .type = PTYPE_BOOLEAN, 702 .value.boolean = true, 703 }, 704 { 705 .description = "boolean_true2", 706 .type = PTYPE_BOOLEAN, 707 .value.boolean = 8, 708 }, 709 { 710 .description = "boolean_true3", 711 .type = PTYPE_BOOLEAN, 712 .value.boolean = -1, 713 }, 714 { 715 .description = "boolean_false1", 716 .type = PTYPE_BOOLEAN, 717 .value.boolean = false, 718 }, 719 { 720 .description = "boolean_false2", 721 .type = PTYPE_BOOLEAN, 722 .value.boolean = 0, 723 }, 724 /* number tests (double) */ 725 { 726 .description = "number_sanity1", 727 .type = PTYPE_NUMBER, 728 .value.number = -1, 729 }, 730 { 731 .description = "number_sanity2", 732 .type = PTYPE_NUMBER, 733 .value.number = 3.141593, 734 }, 735 { 736 .description = "number_min", 737 .type = PTYPE_NUMBER, 738 .value.number = DBL_MIN, 739 }, 740 { 741 .description = "number_max", 742 .type = PTYPE_NUMBER, 743 .value.number = DBL_MAX, 744 }, 745 /* integer tests (int64) */ 746 { 747 .description = "integer_sanity1", 748 .type = PTYPE_INTEGER, 749 .value.integer = -1, 750 }, 751 { 752 .description = "integer_sanity2", 753 .type = PTYPE_INTEGER, 754 .value.integer = INT64_MAX / 2 + 1, 755 }, 756 { 757 .description = "integer_min", 758 .type = PTYPE_INTEGER, 759 .value.integer = INT64_MIN, 760 }, 761 { 762 .description = "integer_max", 763 .type = PTYPE_INTEGER, 764 .value.integer = INT64_MAX, 765 }, 766 /* uint8 tests */ 767 { 768 .description = "uint8_sanity1", 769 .type = PTYPE_U8, 770 .value.u8 = 1, 771 }, 772 { 773 .description = "uint8_sanity2", 774 .type = PTYPE_U8, 775 .value.u8 = UINT8_MAX / 2 + 1, 776 }, 777 { 778 .description = "uint8_min", 779 .type = PTYPE_U8, 780 .value.u8 = 0, 781 }, 782 { 783 .description = "uint8_max", 784 .type = PTYPE_U8, 785 .value.u8 = UINT8_MAX, 786 }, 787 /* uint16 tests */ 788 { 789 .description = "uint16_sanity1", 790 .type = PTYPE_U16, 791 .value.u16 = 1, 792 }, 793 { 794 .description = "uint16_sanity2", 795 .type = PTYPE_U16, 796 .value.u16 = UINT16_MAX / 2 + 1, 797 }, 798 { 799 .description = "uint16_min", 800 .type = PTYPE_U16, 801 .value.u16 = 0, 802 }, 803 { 804 .description = "uint16_max", 805 .type = PTYPE_U16, 806 .value.u16 = UINT16_MAX, 807 }, 808 /* uint32 tests */ 809 { 810 .description = "uint32_sanity1", 811 .type = PTYPE_U32, 812 .value.u32 = 1, 813 }, 814 { 815 .description = "uint32_sanity2", 816 .type = PTYPE_U32, 817 .value.u32 = UINT32_MAX / 2 + 1, 818 }, 819 { 820 .description = "uint32_min", 821 .type = PTYPE_U32, 822 .value.u32 = 0, 823 }, 824 { 825 .description = "uint32_max", 826 .type = PTYPE_U32, 827 .value.u32 = UINT32_MAX, 828 }, 829 /* uint64 tests */ 830 { 831 .description = "uint64_sanity1", 832 .type = PTYPE_U64, 833 .value.u64 = 1, 834 }, 835 { 836 .description = "uint64_sanity2", 837 .type = PTYPE_U64, 838 .value.u64 = UINT64_MAX / 2 + 1, 839 }, 840 { 841 .description = "uint64_min", 842 .type = PTYPE_U64, 843 .value.u64 = 0, 844 }, 845 { 846 .description = "uint64_max", 847 .type = PTYPE_U64, 848 .value.u64 = UINT64_MAX, 849 }, 850 /* int8 tests */ 851 { 852 .description = "int8_sanity1", 853 .type = PTYPE_S8, 854 .value.s8 = -1, 855 }, 856 { 857 .description = "int8_sanity2", 858 .type = PTYPE_S8, 859 .value.s8 = INT8_MAX / 2 + 1, 860 }, 861 { 862 .description = "int8_min", 863 .type = PTYPE_S8, 864 .value.s8 = INT8_MIN, 865 }, 866 { 867 .description = "int8_max", 868 .type = PTYPE_S8, 869 .value.s8 = INT8_MAX, 870 }, 871 /* int16 tests */ 872 { 873 .description = "int16_sanity1", 874 .type = PTYPE_S16, 875 .value.s16 = -1, 876 }, 877 { 878 .description = "int16_sanity2", 879 .type = PTYPE_S16, 880 .value.s16 = INT16_MAX / 2 + 1, 881 }, 882 { 883 .description = "int16_min", 884 .type = PTYPE_S16, 885 .value.s16 = INT16_MIN, 886 }, 887 { 888 .description = "int16_max", 889 .type = PTYPE_S16, 890 .value.s16 = INT16_MAX, 891 }, 892 /* int32 tests */ 893 { 894 .description = "int32_sanity1", 895 .type = PTYPE_S32, 896 .value.s32 = -1, 897 }, 898 { 899 .description = "int32_sanity2", 900 .type = PTYPE_S32, 901 .value.s32 = INT32_MAX / 2 + 1, 902 }, 903 { 904 .description = "int32_min", 905 .type = PTYPE_S32, 906 .value.s32 = INT32_MIN, 907 }, 908 { 909 .description = "int32_max", 910 .type = PTYPE_S32, 911 .value.s32 = INT32_MAX, 912 }, 913 /* int64 tests */ 914 { 915 .description = "int64_sanity1", 916 .type = PTYPE_S64, 917 .value.s64 = -1, 918 }, 919 { 920 .description = "int64_sanity2", 921 .type = PTYPE_S64, 922 .value.s64 = INT64_MAX / 2 + 1, 923 }, 924 { 925 .description = "int64_min", 926 .type = PTYPE_S64, 927 .value.s64 = INT64_MIN, 928 }, 929 { 930 .description = "int64_max", 931 .type = PTYPE_S64, 932 .value.s64 = INT64_MAX, 933 }, 934 { .type = PTYPE_EOL } 935 }; 936 937 /* visitor-specific op implementations */ 938 939 typedef struct QmpSerializeData { 940 Visitor *qov; 941 QObject *obj; 942 Visitor *qiv; 943 } QmpSerializeData; 944 945 static void qmp_serialize(void *native_in, void **datap, 946 VisitorFunc visit, Error **errp) 947 { 948 QmpSerializeData *d = g_malloc0(sizeof(*d)); 949 950 d->qov = qobject_output_visitor_new(&d->obj); 951 visit(d->qov, &native_in, errp); 952 *datap = d; 953 } 954 955 static void qmp_deserialize(void **native_out, void *datap, 956 VisitorFunc visit, Error **errp) 957 { 958 QmpSerializeData *d = datap; 959 GString *output_json; 960 QObject *obj_orig, *obj; 961 962 visit_complete(d->qov, &d->obj); 963 obj_orig = d->obj; 964 output_json = qobject_to_json(obj_orig); 965 obj = qobject_from_json(output_json->str, &error_abort); 966 967 g_string_free(output_json, true); 968 d->qiv = qobject_input_visitor_new(obj); 969 qobject_unref(obj_orig); 970 qobject_unref(obj); 971 visit(d->qiv, native_out, errp); 972 } 973 974 static void qmp_cleanup(void *datap) 975 { 976 QmpSerializeData *d = datap; 977 visit_free(d->qov); 978 visit_free(d->qiv); 979 980 g_free(d); 981 } 982 983 typedef struct StringSerializeData { 984 char *string; 985 Visitor *sov; 986 Visitor *siv; 987 } StringSerializeData; 988 989 static void string_serialize(void *native_in, void **datap, 990 VisitorFunc visit, Error **errp) 991 { 992 StringSerializeData *d = g_malloc0(sizeof(*d)); 993 994 d->sov = string_output_visitor_new(false, &d->string); 995 visit(d->sov, &native_in, errp); 996 *datap = d; 997 } 998 999 static void string_deserialize(void **native_out, void *datap, 1000 VisitorFunc visit, Error **errp) 1001 { 1002 StringSerializeData *d = datap; 1003 1004 visit_complete(d->sov, &d->string); 1005 d->siv = string_input_visitor_new(d->string); 1006 visit(d->siv, native_out, errp); 1007 } 1008 1009 static void string_cleanup(void *datap) 1010 { 1011 StringSerializeData *d = datap; 1012 1013 visit_free(d->sov); 1014 visit_free(d->siv); 1015 g_free(d->string); 1016 g_free(d); 1017 } 1018 1019 /* visitor registration, test harness */ 1020 1021 /* note: to function interchangeably as a serialization mechanism your 1022 * visitor test implementation should pass the test cases for all visitor 1023 * capabilities: primitives, structures, and lists 1024 */ 1025 static const SerializeOps visitors[] = { 1026 { 1027 .type = "QMP", 1028 .serialize = qmp_serialize, 1029 .deserialize = qmp_deserialize, 1030 .cleanup = qmp_cleanup, 1031 .caps = VCAP_PRIMITIVES | VCAP_STRUCTURES | VCAP_LISTS | 1032 VCAP_PRIMITIVE_LISTS 1033 }, 1034 { 1035 .type = "String", 1036 .serialize = string_serialize, 1037 .deserialize = string_deserialize, 1038 .cleanup = string_cleanup, 1039 .caps = VCAP_PRIMITIVES 1040 }, 1041 { NULL } 1042 }; 1043 1044 static void add_visitor_type(const SerializeOps *ops) 1045 { 1046 char testname_prefix[32]; 1047 char testname[128]; 1048 TestArgs *args; 1049 int i = 0; 1050 1051 sprintf(testname_prefix, "/visitor/serialization/%s", ops->type); 1052 1053 if (ops->caps & VCAP_PRIMITIVES) { 1054 while (pt_values[i].type != PTYPE_EOL) { 1055 sprintf(testname, "%s/primitives/%s", testname_prefix, 1056 pt_values[i].description); 1057 args = g_malloc0(sizeof(*args)); 1058 args->ops = ops; 1059 args->test_data = &pt_values[i]; 1060 g_test_add_data_func(testname, args, test_primitives); 1061 i++; 1062 } 1063 } 1064 1065 if (ops->caps & VCAP_STRUCTURES) { 1066 sprintf(testname, "%s/struct", testname_prefix); 1067 args = g_malloc0(sizeof(*args)); 1068 args->ops = ops; 1069 args->test_data = NULL; 1070 g_test_add_data_func(testname, args, test_struct); 1071 1072 sprintf(testname, "%s/nested_struct", testname_prefix); 1073 args = g_malloc0(sizeof(*args)); 1074 args->ops = ops; 1075 args->test_data = NULL; 1076 g_test_add_data_func(testname, args, test_nested_struct); 1077 } 1078 1079 if (ops->caps & VCAP_LISTS) { 1080 sprintf(testname, "%s/nested_struct_list", testname_prefix); 1081 args = g_malloc0(sizeof(*args)); 1082 args->ops = ops; 1083 args->test_data = NULL; 1084 g_test_add_data_func(testname, args, test_nested_struct_list); 1085 } 1086 1087 if (ops->caps & VCAP_PRIMITIVE_LISTS) { 1088 i = 0; 1089 while (pt_values[i].type != PTYPE_EOL) { 1090 sprintf(testname, "%s/primitive_list/%s", testname_prefix, 1091 pt_values[i].description); 1092 args = g_malloc0(sizeof(*args)); 1093 args->ops = ops; 1094 args->test_data = &pt_values[i]; 1095 g_test_add_data_func(testname, args, test_primitive_lists); 1096 i++; 1097 } 1098 } 1099 } 1100 1101 int main(int argc, char **argv) 1102 { 1103 int i = 0; 1104 1105 g_test_init(&argc, &argv, NULL); 1106 1107 while (visitors[i].type != NULL) { 1108 add_visitor_type(&visitors[i]); 1109 i++; 1110 } 1111 1112 g_test_run(); 1113 1114 return 0; 1115 } 1116