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