1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21#include <glib.h>
22
23#include "qom/object.h"
24#include "qemu/module.h"
25
26
27#define TYPE_DUMMY "qemu-dummy"
28
29typedef struct DummyObject DummyObject;
30typedef struct DummyObjectClass DummyObjectClass;
31
32#define DUMMY_OBJECT(obj) \
33 OBJECT_CHECK(DummyObject, (obj), TYPE_DUMMY)
34
35typedef enum DummyAnimal DummyAnimal;
36
37enum DummyAnimal {
38 DUMMY_FROG,
39 DUMMY_ALLIGATOR,
40 DUMMY_PLATYPUS,
41
42 DUMMY_LAST,
43};
44
45static const char *const dummy_animal_map[DUMMY_LAST + 1] = {
46 [DUMMY_FROG] = "frog",
47 [DUMMY_ALLIGATOR] = "alligator",
48 [DUMMY_PLATYPUS] = "platypus",
49 [DUMMY_LAST] = NULL,
50};
51
52struct DummyObject {
53 Object parent_obj;
54
55 bool bv;
56 DummyAnimal av;
57 char *sv;
58};
59
60struct DummyObjectClass {
61 ObjectClass parent_class;
62};
63
64
65static void dummy_set_bv(Object *obj,
66 bool value,
67 Error **errp)
68{
69 DummyObject *dobj = DUMMY_OBJECT(obj);
70
71 dobj->bv = value;
72}
73
74static bool dummy_get_bv(Object *obj,
75 Error **errp)
76{
77 DummyObject *dobj = DUMMY_OBJECT(obj);
78
79 return dobj->bv;
80}
81
82
83static void dummy_set_av(Object *obj,
84 int value,
85 Error **errp)
86{
87 DummyObject *dobj = DUMMY_OBJECT(obj);
88
89 dobj->av = value;
90}
91
92static int dummy_get_av(Object *obj,
93 Error **errp)
94{
95 DummyObject *dobj = DUMMY_OBJECT(obj);
96
97 return dobj->av;
98}
99
100
101static void dummy_set_sv(Object *obj,
102 const char *value,
103 Error **errp)
104{
105 DummyObject *dobj = DUMMY_OBJECT(obj);
106
107 g_free(dobj->sv);
108 dobj->sv = g_strdup(value);
109}
110
111static char *dummy_get_sv(Object *obj,
112 Error **errp)
113{
114 DummyObject *dobj = DUMMY_OBJECT(obj);
115
116 return g_strdup(dobj->sv);
117}
118
119
120static void dummy_init(Object *obj)
121{
122 object_property_add_bool(obj, "bv",
123 dummy_get_bv,
124 dummy_set_bv,
125 NULL);
126 object_property_add_str(obj, "sv",
127 dummy_get_sv,
128 dummy_set_sv,
129 NULL);
130 object_property_add_enum(obj, "av",
131 "DummyAnimal",
132 dummy_animal_map,
133 dummy_get_av,
134 dummy_set_av,
135 NULL);
136}
137
138static void dummy_finalize(Object *obj)
139{
140 DummyObject *dobj = DUMMY_OBJECT(obj);
141
142 g_free(dobj->sv);
143}
144
145
146static const TypeInfo dummy_info = {
147 .name = TYPE_DUMMY,
148 .parent = TYPE_OBJECT,
149 .instance_size = sizeof(DummyObject),
150 .instance_init = dummy_init,
151 .instance_finalize = dummy_finalize,
152 .class_size = sizeof(DummyObjectClass),
153};
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174typedef struct DummyDev DummyDev;
175typedef struct DummyDevClass DummyDevClass;
176typedef struct DummyBus DummyBus;
177typedef struct DummyBusClass DummyBusClass;
178typedef struct DummyBackend DummyBackend;
179typedef struct DummyBackendClass DummyBackendClass;
180
181#define TYPE_DUMMY_DEV "qemu-dummy-dev"
182#define TYPE_DUMMY_BUS "qemu-dummy-bus"
183#define TYPE_DUMMY_BACKEND "qemu-dummy-backend"
184
185#define DUMMY_DEV(obj) \
186 OBJECT_CHECK(DummyDev, (obj), TYPE_DUMMY_DEV)
187#define DUMMY_BUS(obj) \
188 OBJECT_CHECK(DummyBus, (obj), TYPE_DUMMY_BUS)
189#define DUMMY_BACKEND(obj) \
190 OBJECT_CHECK(DummyBackend, (obj), TYPE_DUMMY_BACKEND)
191
192struct DummyDev {
193 Object parent_obj;
194
195 DummyBus *bus;
196};
197
198struct DummyDevClass {
199 ObjectClass parent_class;
200};
201
202struct DummyBus {
203 Object parent_obj;
204
205 DummyBackend *backend;
206};
207
208struct DummyBusClass {
209 ObjectClass parent_class;
210};
211
212struct DummyBackend {
213 Object parent_obj;
214};
215
216struct DummyBackendClass {
217 ObjectClass parent_class;
218};
219
220
221static void dummy_dev_init(Object *obj)
222{
223 DummyDev *dev = DUMMY_DEV(obj);
224 DummyBus *bus = DUMMY_BUS(object_new(TYPE_DUMMY_BUS));
225 DummyBackend *backend = DUMMY_BACKEND(object_new(TYPE_DUMMY_BACKEND));
226
227 object_property_add_child(obj, "bus", OBJECT(bus), NULL);
228 dev->bus = bus;
229 object_property_add_child(OBJECT(bus), "backend", OBJECT(backend), NULL);
230 bus->backend = backend;
231
232 object_property_add_link(obj, "backend", TYPE_DUMMY_BACKEND,
233 (Object **)&bus->backend, NULL, 0, NULL);
234}
235
236static void dummy_dev_unparent(Object *obj)
237{
238 DummyDev *dev = DUMMY_DEV(obj);
239 object_unparent(OBJECT(dev->bus));
240}
241
242static void dummy_dev_class_init(ObjectClass *klass, void *opaque)
243{
244 klass->unparent = dummy_dev_unparent;
245}
246
247
248static void dummy_bus_init(Object *obj)
249{
250}
251
252static void dummy_bus_unparent(Object *obj)
253{
254 DummyBus *bus = DUMMY_BUS(obj);
255 object_property_del(obj->parent, "backend", NULL);
256 object_unparent(OBJECT(bus->backend));
257}
258
259static void dummy_bus_class_init(ObjectClass *klass, void *opaque)
260{
261 klass->unparent = dummy_bus_unparent;
262}
263
264static void dummy_backend_init(Object *obj)
265{
266}
267
268
269static const TypeInfo dummy_dev_info = {
270 .name = TYPE_DUMMY_DEV,
271 .parent = TYPE_OBJECT,
272 .instance_size = sizeof(DummyDev),
273 .instance_init = dummy_dev_init,
274 .class_size = sizeof(DummyDevClass),
275 .class_init = dummy_dev_class_init,
276};
277
278static const TypeInfo dummy_bus_info = {
279 .name = TYPE_DUMMY_BUS,
280 .parent = TYPE_OBJECT,
281 .instance_size = sizeof(DummyBus),
282 .instance_init = dummy_bus_init,
283 .class_size = sizeof(DummyBusClass),
284 .class_init = dummy_bus_class_init,
285};
286
287static const TypeInfo dummy_backend_info = {
288 .name = TYPE_DUMMY_BACKEND,
289 .parent = TYPE_OBJECT,
290 .instance_size = sizeof(DummyBackend),
291 .instance_init = dummy_backend_init,
292 .class_size = sizeof(DummyBackendClass),
293};
294
295
296
297static void test_dummy_createv(void)
298{
299 Error *err = NULL;
300 Object *parent = object_get_objects_root();
301 DummyObject *dobj = DUMMY_OBJECT(
302 object_new_with_props(TYPE_DUMMY,
303 parent,
304 "dummy0",
305 &err,
306 "bv", "yes",
307 "sv", "Hiss hiss hiss",
308 "av", "platypus",
309 NULL));
310
311 g_assert(err == NULL);
312 g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
313 g_assert(dobj->bv == true);
314 g_assert(dobj->av == DUMMY_PLATYPUS);
315
316 g_assert(object_resolve_path_component(parent, "dummy0")
317 == OBJECT(dobj));
318
319 object_unparent(OBJECT(dobj));
320}
321
322
323static Object *new_helper(Error **errp,
324 Object *parent,
325 ...)
326{
327 va_list vargs;
328 Object *obj;
329
330 va_start(vargs, parent);
331 obj = object_new_with_propv(TYPE_DUMMY,
332 parent,
333 "dummy0",
334 errp,
335 vargs);
336 va_end(vargs);
337 return obj;
338}
339
340static void test_dummy_createlist(void)
341{
342 Error *err = NULL;
343 Object *parent = object_get_objects_root();
344 DummyObject *dobj = DUMMY_OBJECT(
345 new_helper(&err,
346 parent,
347 "bv", "yes",
348 "sv", "Hiss hiss hiss",
349 "av", "platypus",
350 NULL));
351
352 g_assert(err == NULL);
353 g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
354 g_assert(dobj->bv == true);
355 g_assert(dobj->av == DUMMY_PLATYPUS);
356
357 g_assert(object_resolve_path_component(parent, "dummy0")
358 == OBJECT(dobj));
359
360 object_unparent(OBJECT(dobj));
361}
362
363static void test_dummy_badenum(void)
364{
365 Error *err = NULL;
366 Object *parent = object_get_objects_root();
367 Object *dobj =
368 object_new_with_props(TYPE_DUMMY,
369 parent,
370 "dummy0",
371 &err,
372 "bv", "yes",
373 "sv", "Hiss hiss hiss",
374 "av", "yeti",
375 NULL);
376
377 g_assert(dobj == NULL);
378 g_assert(err != NULL);
379 g_assert_cmpstr(error_get_pretty(err), ==,
380 "Invalid parameter 'yeti'");
381
382 g_assert(object_resolve_path_component(parent, "dummy0")
383 == NULL);
384
385 error_free(err);
386}
387
388
389static void test_dummy_getenum(void)
390{
391 Error *err = NULL;
392 int val;
393 Object *parent = object_get_objects_root();
394 DummyObject *dobj = DUMMY_OBJECT(
395 object_new_with_props(TYPE_DUMMY,
396 parent,
397 "dummy0",
398 &err,
399 "av", "platypus",
400 NULL));
401
402 g_assert(err == NULL);
403 g_assert(dobj->av == DUMMY_PLATYPUS);
404
405 val = object_property_get_enum(OBJECT(dobj),
406 "av",
407 "DummyAnimal",
408 &err);
409 g_assert(err == NULL);
410 g_assert(val == DUMMY_PLATYPUS);
411
412
413 val = object_property_get_enum(OBJECT(dobj),
414 "av",
415 "BadAnimal",
416 &err);
417 g_assert(err != NULL);
418 error_free(err);
419 err = NULL;
420
421
422 val = object_property_get_enum(OBJECT(dobj),
423 "iv",
424 "DummyAnimal",
425 &err);
426 g_assert(err != NULL);
427 error_free(err);
428
429 object_unparent(OBJECT(dobj));
430}
431
432
433static void test_dummy_iterator(void)
434{
435 Object *parent = object_get_objects_root();
436 DummyObject *dobj = DUMMY_OBJECT(
437 object_new_with_props(TYPE_DUMMY,
438 parent,
439 "dummy0",
440 &error_abort,
441 "bv", "yes",
442 "sv", "Hiss hiss hiss",
443 "av", "platypus",
444 NULL));
445
446 ObjectProperty *prop;
447 ObjectPropertyIterator *iter;
448 bool seenbv = false, seensv = false, seenav = false, seentype;
449
450 iter = object_property_iter_init(OBJECT(dobj));
451 while ((prop = object_property_iter_next(iter))) {
452 if (g_str_equal(prop->name, "bv")) {
453 seenbv = true;
454 } else if (g_str_equal(prop->name, "sv")) {
455 seensv = true;
456 } else if (g_str_equal(prop->name, "av")) {
457 seenav = true;
458 } else if (g_str_equal(prop->name, "type")) {
459
460 seentype = true;
461 } else {
462 g_printerr("Found prop '%s'\n", prop->name);
463 g_assert_not_reached();
464 }
465 }
466 object_property_iter_free(iter);
467 g_assert(seenbv);
468 g_assert(seenav);
469 g_assert(seensv);
470 g_assert(seentype);
471
472 object_unparent(OBJECT(dobj));
473}
474
475
476static void test_dummy_delchild(void)
477{
478 Object *parent = object_get_objects_root();
479 DummyDev *dev = DUMMY_DEV(
480 object_new_with_props(TYPE_DUMMY_DEV,
481 parent,
482 "dev0",
483 &error_abort,
484 NULL));
485
486 object_unparent(OBJECT(dev));
487}
488
489int main(int argc, char **argv)
490{
491 g_test_init(&argc, &argv, NULL);
492
493 module_call_init(MODULE_INIT_QOM);
494 type_register_static(&dummy_info);
495 type_register_static(&dummy_dev_info);
496 type_register_static(&dummy_bus_info);
497 type_register_static(&dummy_backend_info);
498
499 g_test_add_func("/qom/proplist/createlist", test_dummy_createlist);
500 g_test_add_func("/qom/proplist/createv", test_dummy_createv);
501 g_test_add_func("/qom/proplist/badenum", test_dummy_badenum);
502 g_test_add_func("/qom/proplist/getenum", test_dummy_getenum);
503 g_test_add_func("/qom/proplist/iterator", test_dummy_iterator);
504 g_test_add_func("/qom/proplist/delchild", test_dummy_delchild);
505
506 return g_test_run();
507}
508