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