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