]>
Commit | Line | Data |
---|---|---|
d93bb9d5 MA |
1 | /* |
2 | * QMP command test cases | |
3 | * | |
4 | * Copyright (c) 2017 Red Hat Inc. | |
5 | * | |
6 | * Authors: | |
7 | * Markus Armbruster <armbru@redhat.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 "qemu/osdep.h" | |
14 | #include "libqtest.h" | |
15 | #include "qapi/error.h" | |
16 | #include "qapi/qapi-visit-introspect.h" | |
17 | #include "qapi/qmp/qdict.h" | |
18 | #include "qapi/qobject-input-visitor.h" | |
19 | ||
20 | const char common_args[] = "-nodefaults -machine none"; | |
21 | ||
22 | /* Query smoke tests */ | |
23 | ||
24 | static int query_error_class(const char *cmd) | |
25 | { | |
26 | static struct { | |
27 | const char *cmd; | |
28 | int err_class; | |
29 | } fails[] = { | |
30 | /* Success depends on build configuration: */ | |
31 | #ifndef CONFIG_SPICE | |
32 | { "query-spice", ERROR_CLASS_COMMAND_NOT_FOUND }, | |
33 | #endif | |
34 | #ifndef CONFIG_VNC | |
35 | { "query-vnc", ERROR_CLASS_GENERIC_ERROR }, | |
36 | { "query-vnc-servers", ERROR_CLASS_GENERIC_ERROR }, | |
37 | #endif | |
38 | #ifndef CONFIG_REPLICATION | |
39 | { "query-xen-replication-status", ERROR_CLASS_COMMAND_NOT_FOUND }, | |
40 | #endif | |
41 | /* Likewise, and require special QEMU command-line arguments: */ | |
42 | { "query-acpi-ospm-status", ERROR_CLASS_GENERIC_ERROR }, | |
43 | { "query-balloon", ERROR_CLASS_DEVICE_NOT_ACTIVE }, | |
44 | { "query-hotpluggable-cpus", ERROR_CLASS_GENERIC_ERROR }, | |
45 | { "query-vm-generation-id", ERROR_CLASS_GENERIC_ERROR }, | |
46 | { NULL, -1 } | |
47 | }; | |
48 | int i; | |
49 | ||
50 | for (i = 0; fails[i].cmd; i++) { | |
51 | if (!strcmp(cmd, fails[i].cmd)) { | |
52 | return fails[i].err_class; | |
53 | } | |
54 | } | |
55 | return -1; | |
56 | } | |
57 | ||
58 | static void test_query(const void *data) | |
59 | { | |
60 | const char *cmd = data; | |
61 | int expected_error_class = query_error_class(cmd); | |
62 | QDict *resp, *error; | |
63 | const char *error_class; | |
da9cd2d0 | 64 | QTestState *qts; |
d93bb9d5 | 65 | |
da9cd2d0 | 66 | qts = qtest_init(common_args); |
d93bb9d5 | 67 | |
da9cd2d0 | 68 | resp = qtest_qmp(qts, "{ 'execute': %s }", cmd); |
d93bb9d5 MA |
69 | error = qdict_get_qdict(resp, "error"); |
70 | error_class = error ? qdict_get_str(error, "class") : NULL; | |
71 | ||
72 | if (expected_error_class < 0) { | |
73 | g_assert(qdict_haskey(resp, "return")); | |
74 | } else { | |
75 | g_assert(error); | |
76 | g_assert_cmpint(qapi_enum_parse(&QapiErrorClass_lookup, error_class, | |
77 | -1, &error_abort), | |
78 | ==, expected_error_class); | |
79 | } | |
80 | qobject_unref(resp); | |
81 | ||
da9cd2d0 | 82 | qtest_quit(qts); |
d93bb9d5 MA |
83 | } |
84 | ||
85 | static bool query_is_blacklisted(const char *cmd) | |
86 | { | |
87 | const char *blacklist[] = { | |
88 | /* Not actually queries: */ | |
89 | "add-fd", | |
90 | /* Success depends on target arch: */ | |
91 | "query-cpu-definitions", /* arm, i386, ppc, s390x */ | |
92 | "query-gic-capabilities", /* arm */ | |
93 | /* Success depends on target-specific build configuration: */ | |
94 | "query-pci", /* CONFIG_PCI */ | |
95 | /* Success depends on launching SEV guest */ | |
96 | "query-sev-launch-measure", | |
97 | /* Success depends on Host or Hypervisor SEV support */ | |
98 | "query-sev", | |
99 | "query-sev-capabilities", | |
100 | NULL | |
101 | }; | |
102 | int i; | |
103 | ||
104 | for (i = 0; blacklist[i]; i++) { | |
105 | if (!strcmp(cmd, blacklist[i])) { | |
106 | return true; | |
107 | } | |
108 | } | |
109 | return false; | |
110 | } | |
111 | ||
112 | typedef struct { | |
113 | SchemaInfoList *list; | |
114 | GHashTable *hash; | |
115 | } QmpSchema; | |
116 | ||
117 | static void qmp_schema_init(QmpSchema *schema) | |
118 | { | |
119 | QDict *resp; | |
120 | Visitor *qiv; | |
121 | SchemaInfoList *tail; | |
da9cd2d0 | 122 | QTestState *qts; |
d93bb9d5 | 123 | |
da9cd2d0 TH |
124 | qts = qtest_init(common_args); |
125 | ||
126 | resp = qtest_qmp(qts, "{ 'execute': 'query-qmp-schema' }"); | |
d93bb9d5 MA |
127 | |
128 | qiv = qobject_input_visitor_new(qdict_get(resp, "return")); | |
129 | visit_type_SchemaInfoList(qiv, NULL, &schema->list, &error_abort); | |
130 | visit_free(qiv); | |
131 | ||
132 | qobject_unref(resp); | |
da9cd2d0 | 133 | qtest_quit(qts); |
d93bb9d5 MA |
134 | |
135 | schema->hash = g_hash_table_new(g_str_hash, g_str_equal); | |
136 | ||
137 | /* Build @schema: hash table mapping entity name to SchemaInfo */ | |
138 | for (tail = schema->list; tail; tail = tail->next) { | |
139 | g_hash_table_insert(schema->hash, tail->value->name, tail->value); | |
140 | } | |
141 | } | |
142 | ||
143 | static SchemaInfo *qmp_schema_lookup(QmpSchema *schema, const char *name) | |
144 | { | |
145 | return g_hash_table_lookup(schema->hash, name); | |
146 | } | |
147 | ||
148 | static void qmp_schema_cleanup(QmpSchema *schema) | |
149 | { | |
150 | qapi_free_SchemaInfoList(schema->list); | |
151 | g_hash_table_destroy(schema->hash); | |
152 | } | |
153 | ||
154 | static bool object_type_has_mandatory_members(SchemaInfo *type) | |
155 | { | |
156 | SchemaInfoObjectMemberList *tail; | |
157 | ||
158 | g_assert(type->meta_type == SCHEMA_META_TYPE_OBJECT); | |
159 | ||
160 | for (tail = type->u.object.members; tail; tail = tail->next) { | |
161 | if (!tail->value->has_q_default) { | |
162 | return true; | |
163 | } | |
164 | } | |
165 | ||
166 | return false; | |
167 | } | |
168 | ||
169 | static void add_query_tests(QmpSchema *schema) | |
170 | { | |
171 | SchemaInfoList *tail; | |
172 | SchemaInfo *si, *arg_type, *ret_type; | |
173 | char *test_name; | |
174 | ||
175 | /* Test the query-like commands */ | |
176 | for (tail = schema->list; tail; tail = tail->next) { | |
177 | si = tail->value; | |
178 | if (si->meta_type != SCHEMA_META_TYPE_COMMAND) { | |
179 | continue; | |
180 | } | |
181 | ||
182 | if (query_is_blacklisted(si->name)) { | |
183 | continue; | |
184 | } | |
185 | ||
186 | arg_type = qmp_schema_lookup(schema, si->u.command.arg_type); | |
187 | if (object_type_has_mandatory_members(arg_type)) { | |
188 | continue; | |
189 | } | |
190 | ||
191 | ret_type = qmp_schema_lookup(schema, si->u.command.ret_type); | |
192 | if (ret_type->meta_type == SCHEMA_META_TYPE_OBJECT | |
193 | && !ret_type->u.object.members) { | |
194 | continue; | |
195 | } | |
196 | ||
197 | test_name = g_strdup_printf("qmp/%s", si->name); | |
198 | qtest_add_data_func(test_name, si->name, test_query); | |
199 | g_free(test_name); | |
200 | } | |
201 | } | |
202 | ||
442b09b8 MAL |
203 | static void test_object_add_without_props(void) |
204 | { | |
205 | QTestState *qts; | |
206 | QDict *resp; | |
207 | ||
208 | qts = qtest_init(common_args); | |
209 | resp = qtest_qmp(qts, "{'execute': 'object-add', 'arguments':" | |
210 | " {'qom-type': 'memory-backend-ram', 'id': 'ram1' } }"); | |
211 | g_assert_nonnull(resp); | |
212 | qmp_assert_error_class(resp, "GenericError"); | |
213 | qtest_quit(qts); | |
214 | } | |
215 | ||
d93bb9d5 MA |
216 | int main(int argc, char *argv[]) |
217 | { | |
218 | QmpSchema schema; | |
219 | int ret; | |
220 | ||
221 | g_test_init(&argc, &argv, NULL); | |
222 | ||
223 | qmp_schema_init(&schema); | |
224 | add_query_tests(&schema); | |
442b09b8 MAL |
225 | |
226 | qtest_add_func("qmp/object-add-without-props", | |
227 | test_object_add_without_props); | |
228 | /* TODO: add coverage of generic object-add failure modes */ | |
229 | ||
d93bb9d5 MA |
230 | ret = g_test_run(); |
231 | ||
232 | qmp_schema_cleanup(&schema); | |
233 | return ret; | |
234 | } |