Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Device introspection test cases |
| 3 | * |
| 4 | * Copyright (c) 2015 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 | /* |
| 14 | * Covers QMP device-list-properties and HMP device_add help. We |
| 15 | * currently don't check that their output makes sense, only that QEMU |
| 16 | * survives. Useful since we've had an astounding number of crash |
| 17 | * bugs around here. |
| 18 | */ |
| 19 | |
Peter Maydell | 681c28a | 2016-02-08 18:08:51 +0000 | [diff] [blame] | 20 | #include "qemu/osdep.h" |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 21 | #include "qemu-common.h" |
| 22 | #include "qapi/qmp/qstring.h" |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 23 | #include "qapi/qmp/qdict.h" |
Markus Armbruster | 47e6b29 | 2018-02-01 12:18:38 +0100 | [diff] [blame] | 24 | #include "qapi/qmp/qlist.h" |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 25 | #include "libqtest.h" |
| 26 | |
| 27 | const char common_args[] = "-nodefaults -machine none"; |
| 28 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 29 | static QList *qom_list_types(QTestState * qts, const char *implements, |
| 30 | bool abstract) |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 31 | { |
| 32 | QDict *resp; |
| 33 | QList *ret; |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 34 | QDict *args = qdict_new(); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 35 | |
Eric Blake | 46f5ac2 | 2017-04-27 16:58:17 -0500 | [diff] [blame] | 36 | qdict_put_bool(args, "abstract", abstract); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 37 | if (implements) { |
Eric Blake | 46f5ac2 | 2017-04-27 16:58:17 -0500 | [diff] [blame] | 38 | qdict_put_str(args, "implements", implements); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 39 | } |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 40 | resp = qtest_qmp(qts, "{'execute': 'qom-list-types', 'arguments': %p }", |
| 41 | args); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 42 | g_assert(qdict_haskey(resp, "return")); |
| 43 | ret = qdict_get_qlist(resp, "return"); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 44 | qobject_ref(ret); |
| 45 | qobject_unref(resp); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 46 | return ret; |
| 47 | } |
| 48 | |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 49 | /* Build a name -> ObjectTypeInfo index from a ObjectTypeInfo list */ |
| 50 | static QDict *qom_type_index(QList *types) |
| 51 | { |
| 52 | QDict *index = qdict_new(); |
| 53 | QListEntry *e; |
| 54 | |
| 55 | QLIST_FOREACH_ENTRY(types, e) { |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 56 | QDict *d = qobject_to(QDict, qlist_entry_obj(e)); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 57 | const char *name = qdict_get_str(d, "name"); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 58 | qobject_ref(d); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 59 | qdict_put(index, name, d); |
| 60 | } |
| 61 | return index; |
| 62 | } |
| 63 | |
| 64 | /* Check if @parent is present in the parent chain of @type */ |
| 65 | static bool qom_has_parent(QDict *index, const char *type, const char *parent) |
| 66 | { |
| 67 | while (type) { |
| 68 | QDict *d = qdict_get_qdict(index, type); |
| 69 | const char *p = d && qdict_haskey(d, "parent") ? |
| 70 | qdict_get_str(d, "parent") : |
| 71 | NULL; |
| 72 | |
| 73 | if (!strcmp(type, parent)) { |
| 74 | return true; |
| 75 | } |
| 76 | |
| 77 | type = p; |
| 78 | } |
| 79 | |
| 80 | return false; |
| 81 | } |
| 82 | |
Eduardo Habkost | dbb2a60 | 2017-07-07 09:22:13 -0300 | [diff] [blame] | 83 | /* Find an entry on a list returned by qom-list-types */ |
| 84 | static QDict *type_list_find(QList *types, const char *name) |
| 85 | { |
| 86 | QListEntry *e; |
| 87 | |
| 88 | QLIST_FOREACH_ENTRY(types, e) { |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 89 | QDict *d = qobject_to(QDict, qlist_entry_obj(e)); |
Eduardo Habkost | dbb2a60 | 2017-07-07 09:22:13 -0300 | [diff] [blame] | 90 | const char *ename = qdict_get_str(d, "name"); |
| 91 | if (!strcmp(ename, name)) { |
| 92 | return d; |
| 93 | } |
| 94 | } |
| 95 | |
| 96 | return NULL; |
| 97 | } |
| 98 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 99 | static QList *device_type_list(QTestState *qts, bool abstract) |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 100 | { |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 101 | return qom_list_types(qts, "device", abstract); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 102 | } |
| 103 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 104 | static void test_one_device(QTestState *qts, const char *type) |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 105 | { |
| 106 | QDict *resp; |
Thomas Huth | d068521 | 2018-08-16 13:35:56 +0200 | [diff] [blame] | 107 | char *help; |
| 108 | char *qom_tree_start, *qom_tree_end; |
| 109 | char *qtree_start, *qtree_end; |
| 110 | |
| 111 | g_test_message("Testing device '%s'", type); |
| 112 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 113 | qom_tree_start = qtest_hmp(qts, "info qom-tree"); |
| 114 | qtree_start = qtest_hmp(qts, "info qtree"); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 115 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 116 | resp = qtest_qmp(qts, "{'execute': 'device-list-properties'," |
| 117 | " 'arguments': {'typename': %s}}", |
Markus Armbruster | edb1523 | 2015-10-01 10:59:57 +0200 | [diff] [blame] | 118 | type); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 119 | qobject_unref(resp); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 120 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 121 | help = qtest_hmp(qts, "device_add \"%s,help\"", type); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 122 | g_free(help); |
| 123 | |
| 124 | /* |
| 125 | * Some devices leave dangling pointers in QOM behind. |
Thomas Huth | d068521 | 2018-08-16 13:35:56 +0200 | [diff] [blame] | 126 | * "info qom-tree" or "info qtree" have a good chance at crashing then. |
| 127 | * Also make sure that the tree did not change. |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 128 | */ |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 129 | qom_tree_end = qtest_hmp(qts, "info qom-tree"); |
Thomas Huth | d068521 | 2018-08-16 13:35:56 +0200 | [diff] [blame] | 130 | g_assert_cmpstr(qom_tree_start, ==, qom_tree_end); |
| 131 | g_free(qom_tree_start); |
| 132 | g_free(qom_tree_end); |
| 133 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 134 | qtree_end = qtest_hmp(qts, "info qtree"); |
Thomas Huth | d068521 | 2018-08-16 13:35:56 +0200 | [diff] [blame] | 135 | g_assert_cmpstr(qtree_start, ==, qtree_end); |
| 136 | g_free(qtree_start); |
| 137 | g_free(qtree_end); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 138 | } |
| 139 | |
| 140 | static void test_device_intro_list(void) |
| 141 | { |
| 142 | QList *types; |
| 143 | char *help; |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 144 | QTestState *qts; |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 145 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 146 | qts = qtest_init(common_args); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 147 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 148 | types = device_type_list(qts, true); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 149 | qobject_unref(types); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 150 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 151 | help = qtest_hmp(qts, "device_add help"); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 152 | g_free(help); |
| 153 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 154 | qtest_quit(qts); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 155 | } |
| 156 | |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 157 | /* |
| 158 | * Ensure all entries returned by qom-list-types implements=<parent> |
| 159 | * have <parent> as a parent. |
| 160 | */ |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 161 | static void test_qom_list_parents(QTestState *qts, const char *parent) |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 162 | { |
| 163 | QList *types; |
| 164 | QListEntry *e; |
| 165 | QDict *index; |
| 166 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 167 | types = qom_list_types(qts, parent, true); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 168 | index = qom_type_index(types); |
| 169 | |
| 170 | QLIST_FOREACH_ENTRY(types, e) { |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 171 | QDict *d = qobject_to(QDict, qlist_entry_obj(e)); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 172 | const char *name = qdict_get_str(d, "name"); |
| 173 | |
| 174 | g_assert(qom_has_parent(index, name, parent)); |
| 175 | } |
| 176 | |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 177 | qobject_unref(types); |
| 178 | qobject_unref(index); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 179 | } |
| 180 | |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 181 | static void test_qom_list_fields(void) |
| 182 | { |
| 183 | QList *all_types; |
| 184 | QList *non_abstract; |
| 185 | QListEntry *e; |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 186 | QTestState *qts; |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 187 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 188 | qts = qtest_init(common_args); |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 189 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 190 | all_types = qom_list_types(qts, NULL, true); |
| 191 | non_abstract = qom_list_types(qts, NULL, false); |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 192 | |
| 193 | QLIST_FOREACH_ENTRY(all_types, e) { |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 194 | QDict *d = qobject_to(QDict, qlist_entry_obj(e)); |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 195 | const char *name = qdict_get_str(d, "name"); |
| 196 | bool abstract = qdict_haskey(d, "abstract") ? |
| 197 | qdict_get_bool(d, "abstract") : |
| 198 | false; |
| 199 | bool expected_abstract = !type_list_find(non_abstract, name); |
| 200 | |
| 201 | g_assert(abstract == expected_abstract); |
| 202 | } |
| 203 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 204 | test_qom_list_parents(qts, "object"); |
| 205 | test_qom_list_parents(qts, "device"); |
| 206 | test_qom_list_parents(qts, "sys-bus-device"); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 207 | |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 208 | qobject_unref(all_types); |
| 209 | qobject_unref(non_abstract); |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 210 | qtest_quit(qts); |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 211 | } |
| 212 | |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 213 | static void test_device_intro_none(void) |
| 214 | { |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 215 | QTestState *qts = qtest_init(common_args); |
| 216 | |
| 217 | test_one_device(qts, "nonexistent"); |
| 218 | qtest_quit(qts); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | static void test_device_intro_abstract(void) |
| 222 | { |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 223 | QTestState *qts = qtest_init(common_args); |
| 224 | |
| 225 | test_one_device(qts, "device"); |
| 226 | qtest_quit(qts); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 227 | } |
| 228 | |
Thomas Huth | 410573a | 2018-08-16 13:35:57 +0200 | [diff] [blame] | 229 | static void test_device_intro_concrete(const void *args) |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 230 | { |
| 231 | QList *types; |
| 232 | QListEntry *entry; |
| 233 | const char *type; |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 234 | QTestState *qts; |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 235 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 236 | qts = qtest_init(args); |
| 237 | types = device_type_list(qts, false); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 238 | |
| 239 | QLIST_FOREACH_ENTRY(types, entry) { |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 240 | type = qdict_get_try_str(qobject_to(QDict, qlist_entry_obj(entry)), |
| 241 | "name"); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 242 | g_assert(type); |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 243 | test_one_device(qts, type); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 244 | } |
| 245 | |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 246 | qobject_unref(types); |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 247 | qtest_quit(qts); |
Thomas Huth | 410573a | 2018-08-16 13:35:57 +0200 | [diff] [blame] | 248 | g_free((void *)args); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 249 | } |
| 250 | |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 251 | static void test_abstract_interfaces(void) |
| 252 | { |
| 253 | QList *all_types; |
Eduardo Habkost | dbb2a60 | 2017-07-07 09:22:13 -0300 | [diff] [blame] | 254 | QListEntry *e; |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 255 | QDict *index; |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 256 | QTestState *qts; |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 257 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 258 | qts = qtest_init(common_args); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 259 | |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 260 | all_types = qom_list_types(qts, "interface", true); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 261 | index = qom_type_index(all_types); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 262 | |
Eduardo Habkost | dbb2a60 | 2017-07-07 09:22:13 -0300 | [diff] [blame] | 263 | QLIST_FOREACH_ENTRY(all_types, e) { |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 264 | QDict *d = qobject_to(QDict, qlist_entry_obj(e)); |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 265 | const char *name = qdict_get_str(d, "name"); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 266 | |
Eduardo Habkost | f86285c | 2017-07-07 09:22:15 -0300 | [diff] [blame] | 267 | /* |
| 268 | * qom-list-types implements=interface returns all types |
| 269 | * that implement _any_ interface (not just interface |
| 270 | * types), so skip the ones that don't have "interface" |
| 271 | * on the parent type chain. |
| 272 | */ |
| 273 | if (!qom_has_parent(index, name, "interface")) { |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 274 | /* Not an interface type */ |
| 275 | continue; |
| 276 | } |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 277 | |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 278 | g_assert(qdict_haskey(d, "abstract") && qdict_get_bool(d, "abstract")); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 279 | } |
| 280 | |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 281 | qobject_unref(all_types); |
| 282 | qobject_unref(index); |
Thomas Huth | 39fb795 | 2019-05-15 19:43:27 +0200 | [diff] [blame] | 283 | qtest_quit(qts); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 284 | } |
| 285 | |
Thomas Huth | 410573a | 2018-08-16 13:35:57 +0200 | [diff] [blame] | 286 | static void add_machine_test_case(const char *mname) |
| 287 | { |
| 288 | char *path, *args; |
| 289 | |
| 290 | /* Ignore blacklisted machines */ |
| 291 | if (g_str_equal("xenfv", mname) || g_str_equal("xenpv", mname)) { |
| 292 | return; |
| 293 | } |
| 294 | |
| 295 | path = g_strdup_printf("device/introspect/concrete/defaults/%s", mname); |
| 296 | args = g_strdup_printf("-M %s", mname); |
| 297 | qtest_add_data_func(path, args, test_device_intro_concrete); |
| 298 | g_free(path); |
| 299 | |
| 300 | path = g_strdup_printf("device/introspect/concrete/nodefaults/%s", mname); |
| 301 | args = g_strdup_printf("-nodefaults -M %s", mname); |
| 302 | qtest_add_data_func(path, args, test_device_intro_concrete); |
| 303 | g_free(path); |
| 304 | } |
| 305 | |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 306 | int main(int argc, char **argv) |
| 307 | { |
| 308 | g_test_init(&argc, &argv, NULL); |
| 309 | |
| 310 | qtest_add_func("device/introspect/list", test_device_intro_list); |
Eduardo Habkost | 87467ea | 2017-07-07 09:22:14 -0300 | [diff] [blame] | 311 | qtest_add_func("device/introspect/list-fields", test_qom_list_fields); |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 312 | qtest_add_func("device/introspect/none", test_device_intro_none); |
| 313 | qtest_add_func("device/introspect/abstract", test_device_intro_abstract); |
Eduardo Habkost | 1c6d75d | 2016-12-12 16:31:01 -0200 | [diff] [blame] | 314 | qtest_add_func("device/introspect/abstract-interfaces", test_abstract_interfaces); |
Thomas Huth | 410573a | 2018-08-16 13:35:57 +0200 | [diff] [blame] | 315 | if (g_test_quick()) { |
| 316 | qtest_add_data_func("device/introspect/concrete/defaults/none", |
| 317 | g_strdup(common_args), test_device_intro_concrete); |
| 318 | } else { |
| 319 | qtest_cb_for_every_machine(add_machine_test_case, true); |
| 320 | } |
Markus Armbruster | 2d1abb8 | 2015-10-01 10:59:56 +0200 | [diff] [blame] | 321 | |
| 322 | return g_test_run(); |
| 323 | } |