From patchwork Fri Nov 29 08:41:11 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Wayne Xia X-Patchwork-Id: 295181 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from lists.gnu.org (lists.gnu.org [IPv6:2001:4830:134:3::11]) (using TLSv1 with cipher AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 7FF0B2C00B3 for ; Fri, 29 Nov 2013 19:43:45 +1100 (EST) Received: from localhost ([::1]:46105 helo=lists.gnu.org) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1VmJfr-00058H-27 for incoming@patchwork.ozlabs.org; Fri, 29 Nov 2013 03:43:43 -0500 Received: from eggs.gnu.org ([2001:4830:134:3::10]:33633) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1VmJcD-0007sz-1C for qemu-devel@nongnu.org; Fri, 29 Nov 2013 03:40:06 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1VmJc1-0004g2-B9 for qemu-devel@nongnu.org; Fri, 29 Nov 2013 03:39:56 -0500 Received: from e28smtp07.in.ibm.com ([122.248.162.7]:42715) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1VmJc0-0004fD-9Y for qemu-devel@nongnu.org; Fri, 29 Nov 2013 03:39:45 -0500 Received: from /spool/local by e28smtp07.in.ibm.com with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted for from ; Fri, 29 Nov 2013 14:09:41 +0530 Received: from d28dlp03.in.ibm.com (9.184.220.128) by e28smtp07.in.ibm.com (192.168.1.137) with IBM ESMTP SMTP Gateway: Authorized Use Only! Violators will be prosecuted; Fri, 29 Nov 2013 14:09:40 +0530 Received: from d28relay04.in.ibm.com (d28relay04.in.ibm.com [9.184.220.61]) by d28dlp03.in.ibm.com (Postfix) with ESMTP id 09D7B1258054 for ; Fri, 29 Nov 2013 14:10:40 +0530 (IST) Received: from d28av02.in.ibm.com (d28av02.in.ibm.com [9.184.220.64]) by d28relay04.in.ibm.com (8.13.8/8.13.8/NCO v10.0) with ESMTP id rAT8dZtG44499040 for ; Fri, 29 Nov 2013 14:09:35 +0530 Received: from d28av02.in.ibm.com (localhost [127.0.0.1]) by d28av02.in.ibm.com (8.14.4/8.14.4/NCO v10.0 AVout) with ESMTP id rAT8ddgf017948 for ; Fri, 29 Nov 2013 14:09:39 +0530 Received: from RH64wenchao ([9.181.129.59]) by d28av02.in.ibm.com (8.14.4/8.14.4/NCO v10.0 AVin) with ESMTP id rAT8dXZc017535; Fri, 29 Nov 2013 14:09:38 +0530 From: Wenchao Xia To: qemu-devel@nongnu.org Date: Fri, 29 Nov 2013 16:41:11 +0800 Message-Id: <1385714473-7322-8-git-send-email-xiawenc@linux.vnet.ibm.com> X-Mailer: git-send-email 1.7.1 In-Reply-To: <1385714473-7322-1-git-send-email-xiawenc@linux.vnet.ibm.com> References: <1385714473-7322-1-git-send-email-xiawenc@linux.vnet.ibm.com> X-TM-AS-MML: disable X-Content-Scanned: Fidelis XPS MAILER x-cbid: 13112908-8878-0000-0000-000009E0BF61 X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.4.x-2.6.x [generic] X-Received-From: 122.248.162.7 Cc: Wenchao Xia Subject: [Qemu-devel] [PATCH V3 7/9] tests: add cases for inherited struct and union with discriminator 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 Test for inherit and complex union. Signed-off-by: Wenchao Xia --- tests/qapi-schema/qapi-schema-test.json | 27 ++++++ tests/qapi-schema/qapi-schema-test.out | 11 +++ tests/test-qmp-input-visitor.c | 120 +++++++++++++++++++++++++ tests/test-qmp-output-visitor.c | 149 +++++++++++++++++++++++++++++++ 4 files changed, 307 insertions(+), 0 deletions(-) diff --git a/tests/qapi-schema/qapi-schema-test.json b/tests/qapi-schema/qapi-schema-test.json index fe5af75..1e23d21 100644 --- a/tests/qapi-schema/qapi-schema-test.json +++ b/tests/qapi-schema/qapi-schema-test.json @@ -21,8 +21,18 @@ 'dict1': { 'string1': 'str', 'dict2': { 'userdef1': 'UserDefOne', 'string2': 'str' }, '*dict3': { 'userdef2': 'UserDefOne', 'string3': 'str' } } } } +# for testing base +{ 'type': 'UserDefBase', + 'data': { 'string': 'str', 'enum1': 'EnumOne' } } + +{ 'type': 'UserDefInherit', + 'base': 'UserDefBase', + 'data': { 'boolean': 'bool', 'integer': 'int' } } # for testing unions +{ 'type': 'UserDefBase0', + 'data': { 'base-string0': 'str', 'base-enum0': 'EnumOne' } } + { 'type': 'UserDefA', 'data': { 'boolean': 'bool' } } @@ -32,6 +42,23 @@ { 'union': 'UserDefUnion', 'data': { 'a' : 'UserDefA', 'b' : 'UserDefB' } } +{ 'union': 'UserDefBaseUnion', + 'base': 'UserDefBase0', + 'data': { 'a' : 'UserDefA', 'b' : 'UserDefB' } } + +{ 'union': 'UserDefDiscriminatorUnion', + 'base': 'UserDefBase0', + 'discriminator' : 'base-string0', + 'data': { 'a' : 'UserDefA', 'b' : 'UserDefB' } } + +# A complex type +{ 'union': 'UserDefEnumDiscriminatorUnion', + 'base': 'UserDefBase0', + 'discriminator' : 'base-enum0', + 'data': { 'value1' : 'UserDefA', + 'value2' : 'UserDefInherit', + 'value3' : 'UserDefB' } } + # for testing native lists { 'union': 'UserDefNativeListUnion', 'data': { 'integer': ['int'], diff --git a/tests/qapi-schema/qapi-schema-test.out b/tests/qapi-schema/qapi-schema-test.out index ad74cdb..ce174a2 100644 --- a/tests/qapi-schema/qapi-schema-test.out +++ b/tests/qapi-schema/qapi-schema-test.out @@ -3,9 +3,15 @@ OrderedDict([('type', 'UserDefOne'), ('data', OrderedDict([('integer', 'int'), ('string', 'str'), ('*enum1', 'EnumOne')]))]), OrderedDict([('type', 'UserDefTwo'), ('data', OrderedDict([('string', 'str'), ('dict', OrderedDict([('string', 'str'), ('dict', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')])), ('*dict2', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')]))]))]))]), OrderedDict([('type', 'UserDefNested'), ('data', OrderedDict([('string0', 'str'), ('dict1', OrderedDict([('string1', 'str'), ('dict2', OrderedDict([('userdef1', 'UserDefOne'), ('string2', 'str')])), ('*dict3', OrderedDict([('userdef2', 'UserDefOne'), ('string3', 'str')]))]))]))]), + OrderedDict([('type', 'UserDefBase'), ('data', OrderedDict([('string', 'str'), ('enum1', 'EnumOne')]))]), + OrderedDict([('type', 'UserDefInherit'), ('base', 'UserDefBase'), ('data', OrderedDict([('boolean', 'bool'), ('integer', 'int')]))]), + OrderedDict([('type', 'UserDefBase0'), ('data', OrderedDict([('base-string0', 'str'), ('base-enum0', 'EnumOne')]))]), OrderedDict([('type', 'UserDefA'), ('data', OrderedDict([('boolean', 'bool')]))]), OrderedDict([('type', 'UserDefB'), ('data', OrderedDict([('integer', 'int')]))]), OrderedDict([('union', 'UserDefUnion'), ('data', OrderedDict([('a', 'UserDefA'), ('b', 'UserDefB')]))]), + OrderedDict([('union', 'UserDefBaseUnion'), ('base', 'UserDefBase0'), ('data', OrderedDict([('a', 'UserDefA'), ('b', 'UserDefB')]))]), + OrderedDict([('union', 'UserDefDiscriminatorUnion'), ('base', 'UserDefBase0'), ('discriminator', 'base-string0'), ('data', OrderedDict([('a', 'UserDefA'), ('b', 'UserDefB')]))]), + OrderedDict([('union', 'UserDefEnumDiscriminatorUnion'), ('base', 'UserDefBase0'), ('discriminator', 'base-enum0'), ('data', OrderedDict([('value1', 'UserDefA'), ('value2', 'UserDefInherit'), ('value3', 'UserDefB')]))]), OrderedDict([('union', 'UserDefNativeListUnion'), ('data', OrderedDict([('integer', ['int']), ('s8', ['int8']), ('s16', ['int16']), ('s32', ['int32']), ('s64', ['int64']), ('u8', ['uint8']), ('u16', ['uint16']), ('u32', ['uint32']), ('u64', ['uint64']), ('number', ['number']), ('boolean', ['bool']), ('string', ['str'])]))]), OrderedDict([('command', 'user_def_cmd'), ('data', OrderedDict())]), OrderedDict([('command', 'user_def_cmd1'), ('data', OrderedDict([('ud1a', 'UserDefOne')]))]), @@ -13,11 +19,16 @@ OrderedDict([('type', 'UserDefOptions'), ('data', OrderedDict([('*i64', ['int']), ('*u64', ['uint64']), ('*u16', ['uint16']), ('*i64x', 'int'), ('*u64x', 'uint64')]))])] [{'enum_name': 'EnumOne', 'enum_values': ['value1', 'value2', 'value3']}, {'enum_name': 'UserDefUnionKind', 'enum_values': None}, + {'enum_name': 'UserDefBaseUnionKind', 'enum_values': None}, + {'enum_name': 'UserDefDiscriminatorUnionKind', 'enum_values': None}, {'enum_name': 'UserDefNativeListUnionKind', 'enum_values': None}] [OrderedDict([('type', 'NestedEnumsOne'), ('data', OrderedDict([('enum1', 'EnumOne'), ('*enum2', 'EnumOne'), ('enum3', 'EnumOne'), ('*enum4', 'EnumOne')]))]), OrderedDict([('type', 'UserDefOne'), ('data', OrderedDict([('integer', 'int'), ('string', 'str'), ('*enum1', 'EnumOne')]))]), OrderedDict([('type', 'UserDefTwo'), ('data', OrderedDict([('string', 'str'), ('dict', OrderedDict([('string', 'str'), ('dict', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')])), ('*dict2', OrderedDict([('userdef', 'UserDefOne'), ('string', 'str')]))]))]))]), OrderedDict([('type', 'UserDefNested'), ('data', OrderedDict([('string0', 'str'), ('dict1', OrderedDict([('string1', 'str'), ('dict2', OrderedDict([('userdef1', 'UserDefOne'), ('string2', 'str')])), ('*dict3', OrderedDict([('userdef2', 'UserDefOne'), ('string3', 'str')]))]))]))]), + OrderedDict([('type', 'UserDefBase'), ('data', OrderedDict([('string', 'str'), ('enum1', 'EnumOne')]))]), + OrderedDict([('type', 'UserDefInherit'), ('base', 'UserDefBase'), ('data', OrderedDict([('boolean', 'bool'), ('integer', 'int')]))]), + OrderedDict([('type', 'UserDefBase0'), ('data', OrderedDict([('base-string0', 'str'), ('base-enum0', 'EnumOne')]))]), OrderedDict([('type', 'UserDefA'), ('data', OrderedDict([('boolean', 'bool')]))]), OrderedDict([('type', 'UserDefB'), ('data', OrderedDict([('integer', 'int')]))]), OrderedDict([('type', 'UserDefOptions'), ('data', OrderedDict([('*i64', ['int']), ('*u64', ['uint64']), ('*u16', ['uint16']), ('*i64x', 'int'), ('*u64x', 'uint64')]))])] diff --git a/tests/test-qmp-input-visitor.c b/tests/test-qmp-input-visitor.c index 1e1c6fa..0c00115 100644 --- a/tests/test-qmp-input-visitor.c +++ b/tests/test-qmp-input-visitor.c @@ -286,6 +286,31 @@ static void test_visitor_in_list(TestInputVisitorData *data, qapi_free_UserDefOneList(head); } +static void test_visitor_in_inherit(TestInputVisitorData *data, + const void *unused) +{ + Visitor *v; + Error *err = NULL; + UserDefInherit *tmp; + const char *input = + "{ \ + 'integer': 2, \ + 'boolean': false, \ + 'enum1': 'value2', \ + 'string': 'test' \ + }"; + + v = visitor_input_test_init_raw(data, input); + + visit_type_UserDefInherit(v, &tmp, NULL, &err); + g_assert(err == NULL); + g_assert_cmpint(tmp->integer, ==, 2); + g_assert_cmpint(tmp->boolean, ==, false); + g_assert_cmpint(tmp->base->enum1, ==, ENUM_ONE_VALUE2); + g_assert_cmpstr(tmp->base->string, ==, "test"); + qapi_free_UserDefInherit(tmp); +} + static void test_visitor_in_union(TestInputVisitorData *data, const void *unused) { @@ -302,6 +327,91 @@ static void test_visitor_in_union(TestInputVisitorData *data, qapi_free_UserDefUnion(tmp); } +static void test_visitor_in_base_union(TestInputVisitorData *data, + const void *unused) +{ + Visitor *v; + Error *err = NULL; + UserDefBaseUnion *tmp; + const char *input = + "{ \ + 'base-enum0': 'value2', \ + 'base-string0': 'test', \ + 'type': 'b', \ + 'data': { \ + 'integer': 2 \ + } \ + }"; + + v = visitor_input_test_init_raw(data, input); + + visit_type_UserDefBaseUnion(v, &tmp, NULL, &err); + g_assert(err == NULL); + g_assert_cmpint(tmp->base_enum0, ==, ENUM_ONE_VALUE2); + g_assert_cmpstr(tmp->base_string0, ==, "test"); + g_assert_cmpint(tmp->kind, ==, USER_DEF_BASE_UNION_KIND_B); + g_assert_cmpint(tmp->b->integer, ==, 2); + + qapi_free_UserDefBaseUnion(tmp); +} + +static void test_visitor_in_discriminator_union(TestInputVisitorData *data, + const void *unused) +{ + Visitor *v; + Error *err = NULL; + UserDefDiscriminatorUnion *tmp; + const char *input = + "{ \ + 'integer': 2, \ + 'base-enum0': 'value2', \ + 'base-string0': 'b' \ + }"; + + v = visitor_input_test_init_raw(data, input); + + visit_type_UserDefDiscriminatorUnion(v, &tmp, NULL, &err); + g_assert(err == NULL); + g_assert_cmpint(tmp->base_enum0, ==, ENUM_ONE_VALUE2); + g_assert_cmpint(tmp->kind, ==, USER_DEF_DISCRIMINATOR_UNION_KIND_B); + g_assert_cmpint(tmp->b->integer, ==, 2); + + qapi_free_UserDefDiscriminatorUnion(tmp); +} + +static +void test_visitor_in_enum_discriminator_union(TestInputVisitorData *data, + const void *unused) +{ + Visitor *v; + Error *err = NULL; + UserDefEnumDiscriminatorUnion *tmp; + const char *input = + "{ \ + 'boolean': false, \ + 'integer': 2, \ + 'enum1': 'value2', \ + 'string': 'test', \ + 'base-enum0': 'value2', \ + 'base-string0': 'test' \ + }"; + + v = visitor_input_test_init_raw(data, input); + + visit_type_UserDefEnumDiscriminatorUnion(v, &tmp, NULL, &err); + g_assert(err == NULL); + + g_assert_cmpstr(tmp->base_string0, ==, "test"); + g_assert_cmpint(tmp->kind, ==, ENUM_ONE_VALUE2); + + g_assert_cmpint(tmp->value2->boolean, ==, false); + g_assert_cmpint(tmp->value2->integer, ==, 2); + g_assert_cmpint(tmp->value2->base->enum1, ==, ENUM_ONE_VALUE2); + g_assert_cmpstr(tmp->value2->base->string, ==, "test"); + + qapi_free_UserDefEnumDiscriminatorUnion(tmp); +} + static void test_native_list_integer_helper(TestInputVisitorData *data, const void *unused, UserDefNativeListUnionKind kind) @@ -633,8 +743,18 @@ int main(int argc, char **argv) &in_visitor_data, test_visitor_in_struct_nested); input_visitor_test_add("/visitor/input/list", &in_visitor_data, test_visitor_in_list); + input_visitor_test_add("/visitor/input/inherit", + &in_visitor_data, test_visitor_in_inherit); input_visitor_test_add("/visitor/input/union", &in_visitor_data, test_visitor_in_union); + input_visitor_test_add("/visitor/input/base-union", + &in_visitor_data, test_visitor_in_base_union); + input_visitor_test_add("/visitor/input/discriminator-union", + &in_visitor_data, + test_visitor_in_discriminator_union); + input_visitor_test_add("/visitor/input/enum-discriminator-union", + &in_visitor_data, + test_visitor_in_enum_discriminator_union); input_visitor_test_add("/visitor/input/errors", &in_visitor_data, test_visitor_in_errors); input_visitor_test_add("/visitor/input/native_list/int", diff --git a/tests/test-qmp-output-visitor.c b/tests/test-qmp-output-visitor.c index e073d83..aae161a 100644 --- a/tests/test-qmp-output-visitor.c +++ b/tests/test-qmp-output-visitor.c @@ -402,6 +402,38 @@ static void test_visitor_out_list_qapi_free(TestOutputVisitorData *data, qapi_free_UserDefNestedList(head); } +static void test_visitor_out_inherit(TestOutputVisitorData *data, + const void *unused) +{ + QObject *arg; + QDict *qdict; + const char *test_str = "test"; + Error *err = NULL; + + UserDefInherit *tmp = + g_malloc0(sizeof(UserDefInherit)); + tmp->integer = 2; + tmp->boolean = false; + tmp->base = g_malloc0(sizeof(UserDefBase)); + tmp->base->enum1 = ENUM_ONE_VALUE2; + tmp->base->string = g_strdup(test_str); + + visit_type_UserDefInherit(data->ov, &tmp, NULL, &err); + g_assert(err == NULL); + arg = qmp_output_get_qobject(data->qov); + + g_assert(qobject_type(arg) == QTYPE_QDICT); + qdict = qobject_to_qdict(arg); + + g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 2); + g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, false); + g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value2"); + g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, test_str); + + qapi_free_UserDefInherit(tmp); + QDECREF(qdict); +} + static void test_visitor_out_union(TestOutputVisitorData *data, const void *unused) { @@ -434,6 +466,113 @@ static void test_visitor_out_union(TestOutputVisitorData *data, QDECREF(qdict); } +static void test_visitor_out_base_union(TestOutputVisitorData *data, + const void *unused) +{ + QObject *arg; + QDict *qdict, *qdict_sub; + const char *test_str = "test"; + Error *err = NULL; + + UserDefBaseUnion *tmp = + g_malloc0(sizeof(UserDefBaseUnion)); + tmp->base_enum0 = ENUM_ONE_VALUE2; + tmp->base_string0 = g_strdup(test_str); + tmp->kind = USER_DEF_BASE_UNION_KIND_B; + tmp->b = g_malloc0(sizeof(UserDefB)); + tmp->b->integer = 2; + + visit_type_UserDefBaseUnion(data->ov, &tmp, NULL, &err); + g_assert(err == NULL); + arg = qmp_output_get_qobject(data->qov); + + g_assert(qobject_type(arg) == QTYPE_QDICT); + qdict = qobject_to_qdict(arg); + + g_assert_cmpstr(qdict_get_str(qdict, "base-enum0"), ==, "value2"); + g_assert_cmpstr(qdict_get_str(qdict, "base-string0"), ==, test_str); + g_assert_cmpstr(qdict_get_str(qdict, "type"), ==, "b"); + + qdict_sub = qobject_to_qdict(qdict_get(qdict, "data")); + g_assert(qdict_sub); + + g_assert_cmpint(qdict_get_int(qdict_sub, "integer"), ==, 2); + + qapi_free_UserDefBaseUnion(tmp); + QDECREF(qdict); +} + +static void test_visitor_out_discriminator_union(TestOutputVisitorData *data, + const void *unused) +{ + QObject *arg; + QDict *qdict; + + Error *err = NULL; + + UserDefDiscriminatorUnion *tmp = + g_malloc0(sizeof(UserDefDiscriminatorUnion)); + tmp->base_enum0 = ENUM_ONE_VALUE2; + tmp->kind = USER_DEF_DISCRIMINATOR_UNION_KIND_B; + tmp->b = g_malloc0(sizeof(UserDefB)); + tmp->b->integer = 2; + + visit_type_UserDefDiscriminatorUnion(data->ov, &tmp, NULL, &err); + g_assert(err == NULL); + arg = qmp_output_get_qobject(data->qov); + + g_assert(qobject_type(arg) == QTYPE_QDICT); + qdict = qobject_to_qdict(arg); + + g_assert_cmpstr(qdict_get_str(qdict, "base-enum0"), ==, "value2"); + g_assert_cmpstr(qdict_get_str(qdict, "base-string0"), ==, "b"); + g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 2); + + qapi_free_UserDefDiscriminatorUnion(tmp); + QDECREF(qdict); +} + +/* A complex type */ +static +void test_visitor_out_enum_discriminator_union(TestOutputVisitorData *data, + const void *unused) +{ + QObject *arg; + QDict *qdict; + const char *test_str = "test"; + Error *err = NULL; + + UserDefEnumDiscriminatorUnion *tmp = + g_malloc0(sizeof(UserDefEnumDiscriminatorUnion)); + tmp->base_string0 = g_strdup(test_str); + tmp->kind = ENUM_ONE_VALUE2; + tmp->value2 = g_malloc0(sizeof(UserDefInherit)); + tmp->value2->integer = 2; + tmp->value2->boolean = false; + tmp->value2->base = g_malloc0(sizeof(UserDefBase)); + tmp->value2->base->enum1 = ENUM_ONE_VALUE2; + tmp->value2->base->string = g_strdup(test_str); + + visit_type_UserDefEnumDiscriminatorUnion(data->ov, &tmp, NULL, &err); + g_assert(err == NULL); + arg = qmp_output_get_qobject(data->qov); + + g_assert(qobject_type(arg) == QTYPE_QDICT); + qdict = qobject_to_qdict(arg); + + g_assert_cmpstr(qdict_get_str(qdict, "base-enum0"), ==, "value2"); + g_assert_cmpstr(qdict_get_str(qdict, "base-string0"), ==, test_str); + /* check sub type specfic */ + g_assert_cmpint(qdict_get_int(qdict, "integer"), ==, 2); + g_assert_cmpint(qdict_get_bool(qdict, "boolean"), ==, false); + g_assert_cmpstr(qdict_get_str(qdict, "enum1"), ==, "value2"); + g_assert_cmpstr(qdict_get_str(qdict, "string"), ==, test_str); + + qapi_free_UserDefEnumDiscriminatorUnion(tmp); + QDECREF(qdict); + +} + static void init_native_list(UserDefNativeListUnion *cvalue) { int i; @@ -780,8 +919,18 @@ int main(int argc, char **argv) &out_visitor_data, test_visitor_out_list); output_visitor_test_add("/visitor/output/list-qapi-free", &out_visitor_data, test_visitor_out_list_qapi_free); + output_visitor_test_add("/visitor/output/inherit", + &out_visitor_data, test_visitor_out_inherit); output_visitor_test_add("/visitor/output/union", &out_visitor_data, test_visitor_out_union); + output_visitor_test_add("/visitor/output/base-union", + &out_visitor_data, test_visitor_out_base_union); + output_visitor_test_add("/visitor/output/discriminator-union", + &out_visitor_data, + test_visitor_out_discriminator_union); + output_visitor_test_add("/visitor/output/enum-discriminator-union", + &out_visitor_data, + test_visitor_out_enum_discriminator_union); output_visitor_test_add("/visitor/output/native_list/int", &out_visitor_data, test_visitor_out_native_list_int); output_visitor_test_add("/visitor/output/native_list/int8",