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