From patchwork Mon Mar 5 19:10:29 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Michael Roth X-Patchwork-Id: 144755 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [208.118.235.17]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 104E9B6F9F for ; Tue, 6 Mar 2012 06:11:50 +1100 (EST) Received: from localhost ([::1]:47854 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1S4dJz-0007ph-OY for incoming@patchwork.ozlabs.org; Mon, 05 Mar 2012 14:11:47 -0500 Received: from eggs.gnu.org ([208.118.235.92]:53328) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1S4dJ9-0006A4-I6 for qemu-devel@nongnu.org; Mon, 05 Mar 2012 14:10:58 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1S4dJ6-0000OH-3A for qemu-devel@nongnu.org; Mon, 05 Mar 2012 14:10:55 -0500 Received: from mail-pz0-f46.google.com ([209.85.210.46]:36826) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1S4dJ5-0000O2-KK for qemu-devel@nongnu.org; Mon, 05 Mar 2012 14:10:52 -0500 Received: by dajr28 with SMTP id r28so6798479daj.33 for ; Mon, 05 Mar 2012 11:10:49 -0800 (PST) Received-SPF: pass (google.com: domain of flukshun@gmail.com designates 10.68.225.164 as permitted sender) client-ip=10.68.225.164; Authentication-Results: mr.google.com; spf=pass (google.com: domain of flukshun@gmail.com designates 10.68.225.164 as permitted sender) smtp.mail=flukshun@gmail.com; dkim=pass header.i=flukshun@gmail.com Received: from mr.google.com ([10.68.225.164]) by 10.68.225.164 with SMTP id rl4mr52155961pbc.117.1330974649696 (num_hops = 1); Mon, 05 Mar 2012 11:10:49 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=sender:from:to:cc:subject:date:message-id:x-mailer:in-reply-to :references; bh=4WOp8z4AhHD43u9XTANSenhAwsGhb+4lp6oTQRHKxaw=; b=G3Fxlcqja+KEJ2cCAo6JRBqgusPfc8HxkIIQV5CBpG0W+OLXOtjifDgzMy+2xpdkxS U03z9Ts9Eo8K/9pW1WcLqOs02/CvtoCs3ewsQcBYQQFF9oAbk7J+uxRhJgD5/ghdM+Qf RlUxzoLk17pKx0yDnbLkMUGewFACOgrc4US9Yh5/JmkdIcV7XU7AfrxLk9OWoVnplTYV TzAwA/VfKrMZlSvphbBgrCtAZ5L7fZBlCplPnCJIhPhcCaH1eR54weh2vTX80bmVP+FG nZzyH88VTRlsn69echO6A+t+IoGoJTjjqo3jiTisKcfDOXhomRzMfAVmzoB7ZutNq89I tDWQ== Received: by 10.68.225.164 with SMTP id rl4mr44678217pbc.117.1330974649620; Mon, 05 Mar 2012 11:10:49 -0800 (PST) Received: from localhost.localdomain ([32.97.110.59]) by mx.google.com with ESMTPS id f7sm5117780pbr.3.2012.03.05.11.10.47 (version=TLSv1/SSLv3 cipher=OTHER); Mon, 05 Mar 2012 11:10:48 -0800 (PST) From: Michael Roth To: qemu-devel@nongnu.org Date: Mon, 5 Mar 2012 13:10:29 -0600 Message-Id: <1330974634-7527-3-git-send-email-mdroth@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1330974634-7527-1-git-send-email-mdroth@linux.vnet.ibm.com> References: <1330974634-7527-1-git-send-email-mdroth@linux.vnet.ibm.com> X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 209.85.210.46 Cc: pbonzini@redhat.com, aliguori@us.ibm.com, afaerber@suse.de Subject: [Qemu-devel] [PATCH v3 2/7] qapi: unit tests for visitor-based serialization X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Sender: qemu-devel-bounces+incoming=patchwork.ozlabs.org@nongnu.org Currently we test our visitors individually, and seperately for input vs. output. This is useful for validating internal representations against the native C types and vice-versa, and other visitor-specific testing, but it doesn't cover the potential use-case of using visitor pairs for serialization/deserialization very well, and makes it hard to easily extend the coverage for different C types / boundary conditions. To cover that we add a set of unit tests that takes a number of native C values, passes them into an output visitor, extracts the values with an input visitor, then compares the result to the original. Plugging in new visitors to the test harness only requires a user to implement the SerializeOps interface and add it to a list. Signed-off-by: Michael Roth --- test-visitor-serialization.c | 744 ++++++++++++++++++++++++++++++++++++++++++ tests/Makefile | 6 +- 2 files changed, 749 insertions(+), 1 deletions(-) create mode 100644 test-visitor-serialization.c diff --git a/test-visitor-serialization.c b/test-visitor-serialization.c new file mode 100644 index 0000000..6ef57d0 --- /dev/null +++ b/test-visitor-serialization.c @@ -0,0 +1,744 @@ +/* + * Unit-tests for visitor-based serialization + * + * Copyright IBM, Corp. 2012 + * + * Authors: + * Michael Roth + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include +#include +#include +#include +#include "test-qapi-types.h" +#include "test-qapi-visit.h" +#include "qemu-objects.h" +#include "qapi/qmp-input-visitor.h" +#include "qapi/qmp-output-visitor.h" + +typedef struct PrimitiveType { + union { + const char *string; + bool boolean; + double number; + int64_t integer; + uint8_t u8; + uint16_t u16; + uint32_t u32; + uint64_t u64; + int8_t s8; + int16_t s16; + int32_t s32; + int64_t s64; + intmax_t max; + } value; + enum { + PTYPE_STRING = 0, + PTYPE_BOOLEAN, + PTYPE_NUMBER, + PTYPE_INTEGER, + PTYPE_U8, + PTYPE_U16, + PTYPE_U32, + PTYPE_U64, + PTYPE_S8, + PTYPE_S16, + PTYPE_S32, + PTYPE_S64, + PTYPE_EOL, + } type; + const char *description; +} PrimitiveType; + +/* test helpers */ + +static void visit_primitive_type(Visitor *v, void **native, Error **errp) +{ + PrimitiveType *pt = *native; + switch(pt->type) { + case PTYPE_STRING: + visit_type_str(v, (char **)&pt->value.string, NULL, errp); + break; + case PTYPE_BOOLEAN: + visit_type_bool(v, &pt->value.boolean, NULL, errp); + break; + case PTYPE_NUMBER: + visit_type_number(v, &pt->value.number, NULL, errp); + break; + case PTYPE_INTEGER: + visit_type_int(v, &pt->value.integer, NULL, errp); + break; + case PTYPE_U8: + visit_type_uint8(v, &pt->value.u8, NULL, errp); + break; + case PTYPE_U16: + visit_type_uint16(v, &pt->value.u16, NULL, errp); + break; + case PTYPE_U32: + visit_type_uint32(v, &pt->value.u32, NULL, errp); + break; + case PTYPE_U64: + visit_type_uint64(v, &pt->value.u64, NULL, errp); + break; + case PTYPE_S8: + visit_type_int8(v, &pt->value.s8, NULL, errp); + break; + case PTYPE_S16: + visit_type_int16(v, &pt->value.s16, NULL, errp); + break; + case PTYPE_S32: + visit_type_int32(v, &pt->value.s32, NULL, errp); + break; + case PTYPE_S64: + visit_type_int64(v, &pt->value.s64, NULL, errp); + break; + case PTYPE_EOL: + g_assert(false); + } +} + +typedef struct TestStruct +{ + int64_t integer; + bool boolean; + char *string; +} TestStruct; + +static void visit_type_TestStruct(Visitor *v, TestStruct **obj, + const char *name, Error **errp) +{ + visit_start_struct(v, (void **)obj, NULL, name, sizeof(TestStruct), errp); + + visit_type_int(v, &(*obj)->integer, "integer", errp); + visit_type_bool(v, &(*obj)->boolean, "boolean", errp); + visit_type_str(v, &(*obj)->string, "string", errp); + + visit_end_struct(v, errp); +} + +static TestStruct *struct_create(void) +{ + TestStruct *ts = g_malloc0(sizeof(*ts)); + ts->integer = -42; + ts->boolean = true; + ts->string = strdup("test string"); + return ts; +} + +static void struct_compare(TestStruct *ts1, TestStruct *ts2) +{ + g_assert(ts1); + g_assert(ts2); + g_assert_cmpint(ts1->integer, ==, ts2->integer); + g_assert(ts1->boolean == ts2->boolean); + g_assert_cmpstr(ts1->string, ==, ts2->string); +} + +static void struct_cleanup(TestStruct *ts) +{ + g_free(ts->string); + g_free(ts); +} + +static void visit_struct(Visitor *v, void **native, Error **errp) +{ + visit_type_TestStruct(v, (TestStruct **)native, NULL, errp); +} + +static UserDefNested *nested_struct_create(void) +{ + UserDefNested *udnp = g_malloc0(sizeof(*udnp)); + udnp->string0 = strdup("test_string0"); + udnp->dict1.string1 = strdup("test_string1"); + udnp->dict1.dict2.userdef1 = g_malloc0(sizeof(UserDefOne)); + udnp->dict1.dict2.userdef1->integer = 42; + udnp->dict1.dict2.userdef1->string = strdup("test_string"); + udnp->dict1.dict2.string2 = strdup("test_string2"); + udnp->dict1.has_dict3 = true; + udnp->dict1.dict3.userdef2 = g_malloc0(sizeof(UserDefOne)); + udnp->dict1.dict3.userdef2->integer = 43; + udnp->dict1.dict3.userdef2->string = strdup("test_string"); + udnp->dict1.dict3.string3 = strdup("test_string3"); + return udnp; +} + +static void nested_struct_compare(UserDefNested *udnp1, UserDefNested *udnp2) +{ + g_assert(udnp1); + g_assert(udnp2); + g_assert_cmpstr(udnp1->string0, ==, udnp2->string0); + g_assert_cmpstr(udnp1->dict1.string1, ==, udnp2->dict1.string1); + g_assert_cmpint(udnp1->dict1.dict2.userdef1->integer, ==, + udnp2->dict1.dict2.userdef1->integer); + g_assert_cmpstr(udnp1->dict1.dict2.userdef1->string, ==, + udnp2->dict1.dict2.userdef1->string); + g_assert_cmpstr(udnp1->dict1.dict2.string2, ==, udnp2->dict1.dict2.string2); + g_assert(udnp1->dict1.has_dict3 == udnp2->dict1.has_dict3); + g_assert_cmpint(udnp1->dict1.dict3.userdef2->integer, ==, + udnp2->dict1.dict3.userdef2->integer); + g_assert_cmpstr(udnp1->dict1.dict3.userdef2->string, ==, + udnp2->dict1.dict3.userdef2->string); + g_assert_cmpstr(udnp1->dict1.dict3.string3, ==, udnp2->dict1.dict3.string3); +} + +static void nested_struct_cleanup(UserDefNested *udnp) +{ + qapi_free_UserDefNested(udnp); +} + +static void visit_nested_struct(Visitor *v, void **native, Error **errp) +{ + visit_type_UserDefNested(v, (UserDefNested **)native, NULL, errp); +} + +static void visit_nested_struct_list(Visitor *v, void **native, Error **errp) +{ + visit_type_UserDefNestedList(v, (UserDefNestedList **)native, NULL, errp); +} + +/* test cases */ + +typedef void (*VisitorFunc)(Visitor *v, void **native, Error **errp); + +typedef enum VisitorCapabilities { + VCAP_PRIMITIVES = 1, + VCAP_STRUCTURES = 2, + VCAP_LISTS = 4, +} VisitorCapabilities; + +typedef struct SerializeOps { + void (*serialize)(void *native_in, void **datap, + VisitorFunc visit, Error **errp); + void (*deserialize)(void **native_out, void *datap, + VisitorFunc visit, Error **errp); + void (*cleanup)(void *datap); + const char *type; + VisitorCapabilities caps; +} SerializeOps; + +typedef struct TestArgs { + const SerializeOps *ops; + void *test_data; +} TestArgs; + +#define FLOAT_STRING_PRECISION 6 /* corresponding to n in %.nf formatting */ +static gsize calc_float_string_storage(double value) +{ + int whole_value = value; + gsize i = 0; + do { + i++; + } while (whole_value /= 10); + return i + 2 + FLOAT_STRING_PRECISION; +} + +static void test_primitives(gconstpointer opaque) +{ + TestArgs *args = (TestArgs *) opaque; + const SerializeOps *ops = args->ops; + PrimitiveType *pt = args->test_data; + PrimitiveType *pt_copy = g_malloc0(sizeof(*pt_copy)); + Error *err = NULL; + void *serialize_data; + char *double1, *double2; + + pt_copy->type = pt->type; + ops->serialize(pt, &serialize_data, visit_primitive_type, &err); + ops->deserialize((void **)&pt_copy, serialize_data, visit_primitive_type, &err); + + g_assert(err == NULL); + g_assert(pt_copy != NULL); + if (pt->type == PTYPE_STRING) { + g_assert_cmpstr(pt->value.string, ==, pt_copy->value.string); + } else if (pt->type == PTYPE_NUMBER) { + /* we serialize with %f for our reference visitors, so rather than fuzzy + * floating math to test "equality", just compare the formatted values + */ + double1 = g_malloc0(calc_float_string_storage(pt->value.number)); + double2 = g_malloc0(calc_float_string_storage(pt_copy->value.number)); + g_assert_cmpstr(double1, ==, double2); + g_free(double1); + g_free(double2); + } else if (pt->type == PTYPE_BOOLEAN) { + g_assert_cmpint(!!pt->value.max, ==, !!pt->value.max); + } else { + g_assert_cmpint(pt->value.max, ==, pt_copy->value.max); + } + + ops->cleanup(serialize_data); + g_free(args); +} + +static void test_struct(gconstpointer opaque) +{ + TestArgs *args = (TestArgs *) opaque; + const SerializeOps *ops = args->ops; + TestStruct *ts = struct_create(); + TestStruct *ts_copy = NULL; + Error *err = NULL; + void *serialize_data; + + ops->serialize(ts, &serialize_data, visit_struct, &err); + ops->deserialize((void **)&ts_copy, serialize_data, visit_struct, &err); + + g_assert(err == NULL); + struct_compare(ts, ts_copy); + + struct_cleanup(ts); + struct_cleanup(ts_copy); + + ops->cleanup(serialize_data); + g_free(args); +} + +static void test_nested_struct(gconstpointer opaque) +{ + TestArgs *args = (TestArgs *) opaque; + const SerializeOps *ops = args->ops; + UserDefNested *udnp = nested_struct_create(); + UserDefNested *udnp_copy = NULL; + Error *err = NULL; + void *serialize_data; + + ops->serialize(udnp, &serialize_data, visit_nested_struct, &err); + ops->deserialize((void **)&udnp_copy, serialize_data, visit_nested_struct, &err); + + g_assert(err == NULL); + nested_struct_compare(udnp, udnp_copy); + + nested_struct_cleanup(udnp); + nested_struct_cleanup(udnp_copy); + + ops->cleanup(serialize_data); + g_free(args); +} + +static void test_nested_struct_list(gconstpointer opaque) +{ + TestArgs *args = (TestArgs *) opaque; + const SerializeOps *ops = args->ops; + UserDefNestedList *listp = NULL, *tmp, *tmp_copy, *listp_copy = NULL; + Error *err = NULL; + void *serialize_data; + int i = 0; + + for (i = 0; i < 8; i++) { + tmp = g_malloc0(sizeof(UserDefNestedList)); + tmp->value = nested_struct_create(); + tmp->next = listp; + listp = tmp; + } + + ops->serialize(listp, &serialize_data, visit_nested_struct_list, &err); + ops->deserialize((void **)&listp_copy, serialize_data, + visit_nested_struct_list, &err); + + g_assert(err == NULL); + + tmp = listp; + tmp_copy = listp_copy; + while (listp_copy) { + g_assert(listp); + nested_struct_compare(listp->value, listp_copy->value); + listp = listp->next; + listp_copy = listp_copy->next; + } + + qapi_free_UserDefNestedList(tmp); + qapi_free_UserDefNestedList(tmp_copy); + + ops->cleanup(serialize_data); + g_free(args); +} + +PrimitiveType pt_values[] = { + /* string tests */ + { + .description = "string_empty", + .type = PTYPE_STRING, + .value.string = "", + }, + { + .description = "string_whitespace", + .type = PTYPE_STRING, + .value.string = "a b c\td", + }, + { + .description = "string_newlines", + .type = PTYPE_STRING, + .value.string = "a\nb\n", + }, + { + .description = "string_commas", + .type = PTYPE_STRING, + .value.string = "a,b, c,d", + }, + { + .description = "string_single_quoted", + .type = PTYPE_STRING, + .value.string = "'a b',cd", + }, + { + .description = "string_double_quoted", + .type = PTYPE_STRING, + .value.string = "\"a b\",cd", + }, + /* boolean tests */ + { + .description = "boolean_true1", + .type = PTYPE_BOOLEAN, + .value.boolean = true, + }, + { + .description = "boolean_true2", + .type = PTYPE_BOOLEAN, + .value.boolean = 8, + }, + { + .description = "boolean_true3", + .type = PTYPE_BOOLEAN, + .value.boolean = -1, + }, + { + .description = "boolean_false1", + .type = PTYPE_BOOLEAN, + .value.boolean = false, + }, + { + .description = "boolean_false2", + .type = PTYPE_BOOLEAN, + .value.boolean = 0, + }, + /* number tests (double) */ + /* note: we format these to %.6f before comparing, since that's how + * we serialize them and it doesn't make sense to check precision + * beyond that. + */ + { + .description = "number_sanity1", + .type = PTYPE_NUMBER, + .value.number = -1, + }, + { + .description = "number_sanity2", + .type = PTYPE_NUMBER, + .value.number = 3.14159265, + }, + { + .description = "number_min", + .type = PTYPE_NUMBER, + .value.number = DBL_MIN, + }, + { + .description = "number_max", + .type = PTYPE_NUMBER, + .value.number = DBL_MAX, + }, + /* integer tests (int64) */ + { + .description = "integer_sanity1", + .type = PTYPE_INTEGER, + .value.integer = -1, + }, + { + .description = "integer_sanity2", + .type = PTYPE_INTEGER, + .value.integer = INT64_MAX / 2 + 1, + }, + { + .description = "integer_min", + .type = PTYPE_INTEGER, + .value.integer = INT64_MIN, + }, + { + .description = "integer_max", + .type = PTYPE_INTEGER, + .value.integer = INT64_MAX, + }, + /* uint8 tests */ + { + .description = "uint8_sanity1", + .type = PTYPE_U8, + .value.u8 = 1, + }, + { + .description = "uint8_sanity2", + .type = PTYPE_U8, + .value.u8 = UINT8_MAX / 2 + 1, + }, + { + .description = "uint8_min", + .type = PTYPE_U8, + .value.u8 = 0, + }, + { + .description = "uint8_max", + .type = PTYPE_U8, + .value.u8 = UINT8_MAX, + }, + /* uint16 tests */ + { + .description = "uint16_sanity1", + .type = PTYPE_U16, + .value.u16 = 1, + }, + { + .description = "uint16_sanity2", + .type = PTYPE_U16, + .value.u16 = UINT16_MAX / 2 + 1, + }, + { + .description = "uint16_min", + .type = PTYPE_U16, + .value.u16 = 0, + }, + { + .description = "uint16_max", + .type = PTYPE_U16, + .value.u16 = UINT16_MAX, + }, + /* uint32 tests */ + { + .description = "uint32_sanity1", + .type = PTYPE_U32, + .value.u32 = 1, + }, + { + .description = "uint32_sanity2", + .type = PTYPE_U32, + .value.u32 = UINT32_MAX / 2 + 1, + }, + { + .description = "uint32_min", + .type = PTYPE_U32, + .value.u32 = 0, + }, + { + .description = "uint32_max", + .type = PTYPE_U32, + .value.u32 = UINT32_MAX, + }, + /* uint64 tests */ + { + .description = "uint64_sanity1", + .type = PTYPE_U64, + .value.u64 = 1, + }, + { + .description = "uint64_sanity2", + .type = PTYPE_U64, + .value.u64 = UINT64_MAX / 2 + 1, + }, + { + .description = "uint64_min", + .type = PTYPE_U64, + .value.u64 = 0, + }, + { + .description = "uint64_max", + .type = PTYPE_U64, + .value.u64 = UINT64_MAX, + }, + /* int8 tests */ + { + .description = "int8_sanity1", + .type = PTYPE_S8, + .value.s8 = -1, + }, + { + .description = "int8_sanity2", + .type = PTYPE_S8, + .value.s8 = INT8_MAX / 2 + 1, + }, + { + .description = "int8_min", + .type = PTYPE_S8, + .value.s8 = INT8_MIN, + }, + { + .description = "int8_max", + .type = PTYPE_S8, + .value.s8 = INT8_MAX, + }, + /* int16 tests */ + { + .description = "int16_sanity1", + .type = PTYPE_S16, + .value.s16 = -1, + }, + { + .description = "int16_sanity2", + .type = PTYPE_S16, + .value.s16 = INT16_MAX / 2 + 1, + }, + { + .description = "int16_min", + .type = PTYPE_S16, + .value.s16 = INT16_MIN, + }, + { + .description = "int16_max", + .type = PTYPE_S16, + .value.s16 = INT16_MAX, + }, + /* int32 tests */ + { + .description = "int32_sanity1", + .type = PTYPE_S32, + .value.s32 = -1, + }, + { + .description = "int32_sanity2", + .type = PTYPE_S32, + .value.s32 = INT32_MAX / 2 + 1, + }, + { + .description = "int32_min", + .type = PTYPE_S32, + .value.s32 = INT32_MIN, + }, + { + .description = "int32_max", + .type = PTYPE_S32, + .value.s32 = INT32_MAX, + }, + /* int64 tests */ + { + .description = "int64_sanity1", + .type = PTYPE_S64, + .value.s64 = -1, + }, + { + .description = "int64_sanity2", + .type = PTYPE_S64, + .value.s64 = INT64_MAX / 2 + 1, + }, + { + .description = "int64_min", + .type = PTYPE_S64, + .value.s64 = INT64_MIN, + }, + { + .description = "int64_max", + .type = PTYPE_S64, + .value.s64 = INT64_MAX, + }, + { .type = PTYPE_EOL } +}; + +/* visitor-specific op implementations */ + +typedef struct QmpSerializeData { + QmpOutputVisitor *qov; + QmpInputVisitor *qiv; +} QmpSerializeData; + +static void qmp_serialize(void *native_in, void **datap, + VisitorFunc visit, Error **errp) +{ + QmpSerializeData *d = g_malloc0(sizeof(*d)); + + d->qov = qmp_output_visitor_new(); + visit(qmp_output_get_visitor(d->qov), &native_in, errp); + *datap = d; +} + +static void qmp_deserialize(void **native_out, void *datap, + VisitorFunc visit, Error **errp) +{ + QmpSerializeData *d = datap; + QString *output_json = qobject_to_json(qmp_output_get_qobject(d->qov)); + QObject *obj = qobject_from_json(qstring_get_str(output_json)); + + QDECREF(output_json); + d->qiv = qmp_input_visitor_new(obj); + visit(qmp_input_get_visitor(d->qiv), native_out, errp); +} + +static void qmp_cleanup(void *datap) +{ + QmpSerializeData *d = datap; + qmp_output_visitor_cleanup(d->qov); + qmp_input_visitor_cleanup(d->qiv); +} + +/* visitor registration, test harness */ + +/* note: to function interchangeably as a serialization mechanism your + * visitor test implementation should pass the test cases for all visitor + * capabilities: primitives, structures, and lists + */ +static const SerializeOps visitors[] = { + { + .type = "QMP", + .serialize = qmp_serialize, + .deserialize = qmp_deserialize, + .cleanup = qmp_cleanup, + .caps = VCAP_PRIMITIVES | VCAP_STRUCTURES | VCAP_LISTS + }, + { NULL } +}; + +static void add_visitor_type(const SerializeOps *ops) +{ + char testname_prefix[128]; + char testname[128]; + TestArgs *args; + int i = 0; + + sprintf(testname_prefix, "/visitor/serialization/%s", ops->type); + + if (ops->caps & VCAP_PRIMITIVES) { + while (pt_values[i].type != PTYPE_EOL) { + sprintf(testname, "%s/primitives/%s", testname_prefix, + pt_values[i].description); + args = g_malloc0(sizeof(*args)); + args->ops = ops; + args->test_data = &pt_values[i]; + g_test_add_data_func(testname, args, test_primitives); + i++; + } + } + + if (ops->caps & VCAP_STRUCTURES) { + sprintf(testname, "%s/struct", testname_prefix); + args = g_malloc0(sizeof(*args)); + args->ops = ops; + args->test_data = NULL; + g_test_add_data_func(testname, args, test_struct); + + sprintf(testname, "%s/nested_struct", testname_prefix); + args = g_malloc0(sizeof(*args)); + args->ops = ops; + args->test_data = NULL; + g_test_add_data_func(testname, args, test_nested_struct); + } + + if (ops->caps & VCAP_LISTS) { + sprintf(testname, "%s/nested_struct_list", testname_prefix); + args = g_malloc0(sizeof(*args)); + args->ops = ops; + args->test_data = NULL; + g_test_add_data_func(testname, args, test_nested_struct_list); + } +} + +int main(int argc, char **argv) +{ + int i = 0; + + g_test_init(&argc, &argv, NULL); + + while (visitors[i].type != NULL) { + add_visitor_type(&visitors[i]); + i++; + } + + g_test_run(); + + return 0; +} diff --git a/tests/Makefile b/tests/Makefile index 74b29dc..55f3f04 100644 --- a/tests/Makefile +++ b/tests/Makefile @@ -1,6 +1,7 @@ CHECKS = check-qdict check-qfloat check-qint check-qstring check-qlist CHECKS += check-qjson test-qmp-output-visitor test-qmp-input-visitor CHECKS += test-string-input-visitor test-string-output-visitor test-coroutine +CHECKS += test-visitor-serialization check-qint.o check-qstring.o check-qdict.o check-qlist.o check-qfloat.o check-qjson.o test-coroutine.o: $(GENERATED_HEADERS) @@ -14,7 +15,7 @@ test-coroutine: test-coroutine.o qemu-timer-common.o async.o $(coroutine-obj-y) test-qmp-input-visitor.o test-qmp-output-visitor.o \ test-string-input-visitor.o test-string-output-visitor.o \ - test-qmp-commands.o qemu-ga$(EXESUF): QEMU_CFLAGS += -I $(qapi-dir) + test-qmp-commands.o qemu-ga$(EXESUF) test-visitor-serialization: QEMU_CFLAGS += -I $(qapi-dir) $(qapi-dir)/test-qapi-types.c $(qapi-dir)/test-qapi-types.h :\ $(SRC_PATH)/qapi-schema-test.json $(SRC_PATH)/scripts/qapi-types.py @@ -42,6 +43,9 @@ test-qmp-input-visitor: test-qmp-input-visitor.o $(qobject-obj-y) $(qapi-obj-y) test-qmp-commands.o: $(addprefix $(qapi-dir)/, test-qapi-types.c test-qapi-types.h test-qapi-visit.c test-qapi-visit.h test-qmp-marshal.c test-qmp-commands.h) $(qapi-obj-y) test-qmp-commands: test-qmp-commands.o $(qobject-obj-y) $(qapi-obj-y) $(tools-obj-y) $(qapi-dir)/test-qapi-visit.o $(qapi-dir)/test-qapi-types.o $(qapi-dir)/test-qmp-marshal.o module.o +test-visitor-serialization.o: $(addprefix $(qapi-dir)/, test-qapi-types.c test-qapi-types.h test-qapi-visit.c test-qapi-visit.h) $(qapi-obj-y) +test-visitor-serialization$(EXESUF): test-visitor-serialization.o $(qobject-obj-y) $(qapi-obj-y) $(tools-obj-y) $(qapi-dir)/test-qapi-visit.o $(qapi-dir)/test-qapi-types.o + .PHONY: check check: $(CHECKS) $(call quiet-command, gtester $(CHECKS), " CHECK")