tests/unit/check-qom-proplist.c

   1 /*
   2  * Copyright (C) 2015 Red Hat, Inc.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library.  If not, see
  16  * <http://www.gnu.org/licenses/>.
  17  *
  18  * Author: Daniel P. Berrange <berrange@redhat.com>
  19  */
  20
  21 #include "qemu/osdep.h"
  22
  23 #include "qapi/error.h"
  24 #include "qapi/qobject-input-visitor.h"
  25 #include "qapi/qmp/qdict.h"
  26 #include "qapi/qmp/qobject.h"
  27 #include "qom/object.h"
  28 #include "qemu/module.h"
  29 #include "qemu/option.h"
  30 #include "qemu/config-file.h"
  31 #include "qom/object_interfaces.h"
  32
  33
  34 #define TYPE_DUMMY "qemu-dummy"
  35
  36 typedef struct DummyObject DummyObject;
  37 typedef struct DummyObjectClass DummyObjectClass;
  38
  39 DECLARE_INSTANCE_CHECKER(DummyObject, DUMMY_OBJECT,
  40                          TYPE_DUMMY)
  41
  42 typedef enum DummyAnimal DummyAnimal;
  43
  44 enum DummyAnimal {
  45     DUMMY_FROG,
  46     DUMMY_ALLIGATOR,
  47     DUMMY_PLATYPUS,
  48
  49     DUMMY_LAST,
  50 };
  51
  52 const QEnumLookup dummy_animal_map = {
  53     .array = (const char *const[]) {
  54         [DUMMY_FROG] = "frog",
  55         [DUMMY_ALLIGATOR] = "alligator",
  56         [DUMMY_PLATYPUS] = "platypus",
  57     },
  58     .size = DUMMY_LAST
  59 };
  60
  61 struct DummyObject {
  62     Object parent_obj;
  63
  64     bool bv;
  65     DummyAnimal av;
  66     char *sv;
  67 };
  68
  69 struct DummyObjectClass {
  70     ObjectClass parent_class;
  71 };
  72
  73
  74 static void dummy_set_bv(Object *obj,
  75                          bool value,
  76                          Error **errp)
  77 {
  78     DummyObject *dobj = DUMMY_OBJECT(obj);
  79
  80     dobj->bv = value;
  81 }
  82
  83 static bool dummy_get_bv(Object *obj,
  84                          Error **errp)
  85 {
  86     DummyObject *dobj = DUMMY_OBJECT(obj);
  87
  88     return dobj->bv;
  89 }
  90
  91
  92 static void dummy_set_av(Object *obj,
  93                          int value,
  94                          Error **errp)
  95 {
  96     DummyObject *dobj = DUMMY_OBJECT(obj);
  97
  98     dobj->av = value;
  99 }
 100
 101 static int dummy_get_av(Object *obj,
 102                         Error **errp)
 103 {
 104     DummyObject *dobj = DUMMY_OBJECT(obj);
 105
 106     return dobj->av;
 107 }
 108
 109
 110 static void dummy_set_sv(Object *obj,
 111                          const char *value,
 112                          Error **errp)
 113 {
 114     DummyObject *dobj = DUMMY_OBJECT(obj);
 115
 116     g_free(dobj->sv);
 117     dobj->sv = g_strdup(value);
 118 }
 119
 120 static char *dummy_get_sv(Object *obj,
 121                           Error **errp)
 122 {
 123     DummyObject *dobj = DUMMY_OBJECT(obj);
 124
 125     return g_strdup(dobj->sv);
 126 }
 127
 128
 129 static void dummy_init(Object *obj)
 130 {
 131     object_property_add_bool(obj, "bv",
 132                              dummy_get_bv,
 133                              dummy_set_bv);
 134 }
 135
 136
 137 static void dummy_class_init(ObjectClass *cls, void *data)
 138 {
 139     object_class_property_add_str(cls, "sv",
 140                                   dummy_get_sv,
 141                                   dummy_set_sv);
 142     object_class_property_add_enum(cls, "av",
 143                                    "DummyAnimal",
 144                                    &dummy_animal_map,
 145                                    dummy_get_av,
 146                                    dummy_set_av);
 147 }
 148
 149
 150 static void dummy_finalize(Object *obj)
 151 {
 152     DummyObject *dobj = DUMMY_OBJECT(obj);
 153
 154     g_free(dobj->sv);
 155 }
 156
 157
 158 static const TypeInfo dummy_info = {
 159     .name          = TYPE_DUMMY,
 160     .parent        = TYPE_OBJECT,
 161     .instance_size = sizeof(DummyObject),
 162     .instance_init = dummy_init,
 163     .instance_finalize = dummy_finalize,
 164     .class_size = sizeof(DummyObjectClass),
 165     .class_init = dummy_class_init,
 166     .interfaces = (InterfaceInfo[]) {
 167         { TYPE_USER_CREATABLE },
 168         { }
 169     }
 170 };
 171
 172
 173 /*
 174  * The following 3 object classes are used to
 175  * simulate the kind of relationships seen in
 176  * qdev, which result in complex object
 177  * property destruction ordering.
 178  *
 179  * DummyDev has a 'bus' child to a DummyBus
 180  * DummyBus has a 'backend' child to a DummyBackend
 181  * DummyDev has a 'backend' link to DummyBackend
 182  *
 183  * When DummyDev is finalized, it unparents the
 184  * DummyBackend, which unparents the DummyDev
 185  * which deletes the 'backend' link from DummyDev
 186  * to DummyBackend. This illustrates that the
 187  * object_property_del_all() method needs to
 188  * cope with the list of properties being changed
 189  * while it iterates over them.
 190  */
 191 typedef struct DummyDev DummyDev;
 192 typedef struct DummyDevClass DummyDevClass;
 193 typedef struct DummyBus DummyBus;
 194 typedef struct DummyBusClass DummyBusClass;
 195 typedef struct DummyBackend DummyBackend;
 196 typedef struct DummyBackendClass DummyBackendClass;
 197
 198 #define TYPE_DUMMY_DEV "qemu-dummy-dev"
 199 #define TYPE_DUMMY_BUS "qemu-dummy-bus"
 200 #define TYPE_DUMMY_BACKEND "qemu-dummy-backend"
 201
 202 DECLARE_INSTANCE_CHECKER(DummyDev, DUMMY_DEV,
 203                          TYPE_DUMMY_DEV)
 204 DECLARE_INSTANCE_CHECKER(DummyBus, DUMMY_BUS,
 205                          TYPE_DUMMY_BUS)
 206 DECLARE_INSTANCE_CHECKER(DummyBackend, DUMMY_BACKEND,
 207                          TYPE_DUMMY_BACKEND)
 208
 209 struct DummyDev {
 210     Object parent_obj;
 211
 212     DummyBus *bus;
 213 };
 214
 215 struct DummyDevClass {
 216     ObjectClass parent_class;
 217 };
 218
 219 struct DummyBus {
 220     Object parent_obj;
 221
 222     DummyBackend *backend;
 223 };
 224
 225 struct DummyBusClass {
 226     ObjectClass parent_class;
 227 };
 228
 229 struct DummyBackend {
 230     Object parent_obj;
 231 };
 232
 233 struct DummyBackendClass {
 234     ObjectClass parent_class;
 235 };
 236
 237
 238 static void dummy_dev_finalize(Object *obj)
 239 {
 240     DummyDev *dev = DUMMY_DEV(obj);
 241
 242     object_unref(OBJECT(dev->bus));
 243 }
 244
 245 static void dummy_dev_init(Object *obj)
 246 {
 247     DummyDev *dev = DUMMY_DEV(obj);
 248     DummyBus *bus = DUMMY_BUS(object_new(TYPE_DUMMY_BUS));
 249     DummyBackend *backend = DUMMY_BACKEND(object_new(TYPE_DUMMY_BACKEND));
 250
 251     object_property_add_child(obj, "bus", OBJECT(bus));
 252     dev->bus = bus;
 253     object_property_add_child(OBJECT(bus), "backend", OBJECT(backend));
 254     bus->backend = backend;
 255
 256     object_property_add_link(obj, "backend", TYPE_DUMMY_BACKEND,
 257                              (Object **)&bus->backend, NULL, 0);
 258 }
 259
 260 static void dummy_dev_unparent(Object *obj)
 261 {
 262     DummyDev *dev = DUMMY_DEV(obj);
 263     object_unparent(OBJECT(dev->bus));
 264 }
 265
 266 static void dummy_dev_class_init(ObjectClass *klass, void *opaque)
 267 {
 268     klass->unparent = dummy_dev_unparent;
 269 }
 270
 271
 272 static void dummy_bus_finalize(Object *obj)
 273 {
 274     DummyBus *bus = DUMMY_BUS(obj);
 275
 276     object_unref(OBJECT(bus->backend));
 277 }
 278
 279 static void dummy_bus_init(Object *obj)
 280 {
 281 }
 282
 283 static void dummy_bus_unparent(Object *obj)
 284 {
 285     DummyBus *bus = DUMMY_BUS(obj);
 286     object_property_del(obj->parent, "backend");
 287     object_unparent(OBJECT(bus->backend));
 288 }
 289
 290 static void dummy_bus_class_init(ObjectClass *klass, void *opaque)
 291 {
 292     klass->unparent = dummy_bus_unparent;
 293 }
 294
 295 static void dummy_backend_init(Object *obj)
 296 {
 297 }
 298
 299
 300 static const TypeInfo dummy_dev_info = {
 301     .name          = TYPE_DUMMY_DEV,
 302     .parent        = TYPE_OBJECT,
 303     .instance_size = sizeof(DummyDev),
 304     .instance_init = dummy_dev_init,
 305     .instance_finalize = dummy_dev_finalize,
 306     .class_size = sizeof(DummyDevClass),
 307     .class_init = dummy_dev_class_init,
 308 };
 309
 310 static const TypeInfo dummy_bus_info = {
 311     .name          = TYPE_DUMMY_BUS,
 312     .parent        = TYPE_OBJECT,
 313     .instance_size = sizeof(DummyBus),
 314     .instance_init = dummy_bus_init,
 315     .instance_finalize = dummy_bus_finalize,
 316     .class_size = sizeof(DummyBusClass),
 317     .class_init = dummy_bus_class_init,
 318 };
 319
 320 static const TypeInfo dummy_backend_info = {
 321     .name          = TYPE_DUMMY_BACKEND,
 322     .parent        = TYPE_OBJECT,
 323     .instance_size = sizeof(DummyBackend),
 324     .instance_init = dummy_backend_init,
 325     .class_size = sizeof(DummyBackendClass),
 326 };
 327
 328 static QemuOptsList qemu_object_opts = {
 329     .name = "object",
 330     .implied_opt_name = "qom-type",
 331     .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
 332     .desc = {
 333         { }
 334     },
 335 };
 336
 337
 338 static void test_dummy_createv(void)
 339 {
 340     Error *err = NULL;
 341     Object *parent = object_get_objects_root();
 342     DummyObject *dobj = DUMMY_OBJECT(
 343         object_new_with_props(TYPE_DUMMY,
 344                               parent,
 345                               "dummy0",
 346                               &err,
 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
 363
 364 static Object *new_helper(Error **errp,
 365                           Object *parent,
 366                           ...)
 367 {
 368     va_list vargs;
 369     Object *obj;
 370
 371     va_start(vargs, parent);
 372     obj = object_new_with_propv(TYPE_DUMMY,
 373                                 parent,
 374                                 "dummy0",
 375                                 errp,
 376                                 vargs);
 377     va_end(vargs);
 378     return obj;
 379 }
 380
 381 static void test_dummy_createlist(void)
 382 {
 383     Error *err = NULL;
 384     Object *parent = object_get_objects_root();
 385     DummyObject *dobj = DUMMY_OBJECT(
 386         new_helper(&err,
 387                    parent,
 388                    "bv", "yes",
 389                    "sv", "Hiss hiss hiss",
 390                    "av", "platypus",
 391                    NULL));
 392
 393     g_assert(err == NULL);
 394     g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
 395     g_assert(dobj->bv == true);
 396     g_assert(dobj->av == DUMMY_PLATYPUS);
 397
 398     g_assert(object_resolve_path_component(parent, "dummy0")
 399              == OBJECT(dobj));
 400
 401     object_unparent(OBJECT(dobj));
 402 }
 403
 404 static bool test_create_obj(QDict *qdict, Error **errp)
 405 {
 406     Visitor *v = qobject_input_visitor_new_keyval(QOBJECT(qdict));
 407     Object *obj = user_creatable_add_type(TYPE_DUMMY, "dev0", qdict, v, errp);
 408
 409     visit_free(v);
 410     object_unref(obj);
 411     return !!obj;
 412 }
 413
 414 static void test_dummy_createcmdl(void)
 415 {
 416     QDict *qdict;
 417     DummyObject *dobj;
 418     Error *err = NULL;
 419     bool created, help;
 420     const char *params = "bv=yes,sv=Hiss hiss hiss,av=platypus";
 421
 422     /* Needed for user_creatable_del.  */
 423     qemu_add_opts(&qemu_object_opts);
 424
 425     qdict = keyval_parse(params, "qom-type", &help, &err);
 426     g_assert(err == NULL);
 427     g_assert(qdict);
 428     g_assert(!help);
 429
 430     created = test_create_obj(qdict, &err);
 431     g_assert(created);
 432     g_assert(err == NULL);
 433     qobject_unref(qdict);
 434
 435     dobj = DUMMY_OBJECT(object_resolve_path_component(object_get_objects_root(),
 436                                                       "dev0"));
 437     g_assert(dobj);
 438     g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
 439     g_assert(dobj->bv == true);
 440     g_assert(dobj->av == DUMMY_PLATYPUS);
 441
 442     qdict = keyval_parse(params, "qom-type", &help, &err);
 443     created = test_create_obj(qdict, &err);
 444     g_assert(!created);
 445     g_assert(err);
 446     g_assert(object_resolve_path_component(object_get_objects_root(), "dev0")
 447              == OBJECT(dobj));
 448     qobject_unref(qdict);
 449     error_free(err);
 450     err = NULL;
 451
 452     qdict = keyval_parse(params, "qom-type", &help, &err);
 453     user_creatable_del("dev0", &error_abort);
 454     g_assert(object_resolve_path_component(object_get_objects_root(), "dev0")
 455              == NULL);
 456
 457     created = test_create_obj(qdict, &err);
 458     g_assert(created);
 459     g_assert(err == NULL);
 460     qobject_unref(qdict);
 461
 462     dobj = DUMMY_OBJECT(object_resolve_path_component(object_get_objects_root(),
 463                                                       "dev0"));
 464     g_assert(dobj);
 465     g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
 466     g_assert(dobj->bv == true);
 467     g_assert(dobj->av == DUMMY_PLATYPUS);
 468     g_assert(object_resolve_path_component(object_get_objects_root(), "dev0")
 469              == OBJECT(dobj));
 470
 471     object_unparent(OBJECT(dobj));
 472 }
 473
 474 static void test_dummy_badenum(void)
 475 {
 476     Error *err = NULL;
 477     Object *parent = object_get_objects_root();
 478     Object *dobj =
 479         object_new_with_props(TYPE_DUMMY,
 480                               parent,
 481                               "dummy0",
 482                               &err,
 483                               "bv", "yes",
 484                               "sv", "Hiss hiss hiss",
 485                               "av", "yeti",
 486                               NULL);
 487
 488     g_assert(dobj == NULL);
 489     g_assert(err != NULL);
 490     g_assert_cmpstr(error_get_pretty(err), ==,
 491                     "Invalid parameter 'yeti'");
 492
 493     g_assert(object_resolve_path_component(parent, "dummy0")
 494              == NULL);
 495
 496     error_free(err);
 497 }
 498
 499
 500 static void test_dummy_getenum(void)
 501 {
 502     Error *err = NULL;
 503     int val;
 504     Object *parent = object_get_objects_root();
 505     DummyObject *dobj = DUMMY_OBJECT(
 506         object_new_with_props(TYPE_DUMMY,
 507                          parent,
 508                          "dummy0",
 509                          &err,
 510                          "av", "platypus",
 511                          NULL));
 512
 513     g_assert(err == NULL);
 514     g_assert(dobj->av == DUMMY_PLATYPUS);
 515
 516     val = object_property_get_enum(OBJECT(dobj),
 517                                    "av",
 518                                    "DummyAnimal",
 519                                    &error_abort);
 520     g_assert(val == DUMMY_PLATYPUS);
 521
 522     /* A bad enum type name */
 523     val = object_property_get_enum(OBJECT(dobj),
 524                                    "av",
 525                                    "BadAnimal",
 526                                    &err);
 527     g_assert(val == -1);
 528     error_free_or_abort(&err);
 529
 530     /* A non-enum property name */
 531     val = object_property_get_enum(OBJECT(dobj),
 532                                    "iv",
 533                                    "DummyAnimal",
 534                                    &err);
 535     g_assert(val == -1);
 536     error_free_or_abort(&err);
 537
 538     object_unparent(OBJECT(dobj));
 539 }
 540
 541
 542 static void test_dummy_prop_iterator(ObjectPropertyIterator *iter,
 543                                      const char *expected[], int n)
 544 {
 545     ObjectProperty *prop;
 546     int i;
 547
 548     while ((prop = object_property_iter_next(iter))) {
 549         for (i = 0; i < n; i++) {
 550             if (!g_strcmp0(prop->name, expected[i])) {
 551                 break;
 552             }
 553         }
 554         g_assert(i < n);
 555         expected[i] = NULL;
 556     }
 557
 558     for (i = 0; i < n; i++) {
 559         g_assert(!expected[i]);
 560     }
 561 }
 562
 563 static void test_dummy_iterator(void)
 564 {
 565     const char *expected[] = {
 566         "type",                 /* inherited from TYPE_OBJECT */
 567         "sv", "av",             /* class properties */
 568         "bv"};                  /* instance property */
 569     Object *parent = object_get_objects_root();
 570     DummyObject *dobj = DUMMY_OBJECT(
 571         object_new_with_props(TYPE_DUMMY,
 572                               parent,
 573                               "dummy0",
 574                               &error_abort,
 575                               "bv", "yes",
 576                               "sv", "Hiss hiss hiss",
 577                               "av", "platypus",
 578                               NULL));
 579     ObjectPropertyIterator iter;
 580
 581     object_property_iter_init(&iter, OBJECT(dobj));
 582     test_dummy_prop_iterator(&iter, expected, ARRAY_SIZE(expected));
 583     object_unparent(OBJECT(dobj));
 584 }
 585
 586 static void test_dummy_class_iterator(void)
 587 {
 588     const char *expected[] = { "type", "av", "sv" };
 589     ObjectPropertyIterator iter;
 590     ObjectClass *klass = object_class_by_name(TYPE_DUMMY);
 591
 592     object_class_property_iter_init(&iter, klass);
 593     test_dummy_prop_iterator(&iter, expected, ARRAY_SIZE(expected));
 594 }
 595
 596 static void test_dummy_delchild(void)
 597 {
 598     Object *parent = object_get_objects_root();
 599     DummyDev *dev = DUMMY_DEV(
 600         object_new_with_props(TYPE_DUMMY_DEV,
 601                               parent,
 602                               "dev0",
 603                               &error_abort,
 604                               NULL));
 605
 606     object_unparent(OBJECT(dev));
 607 }
 608
 609 static void test_qom_partial_path(void)
 610 {
 611     Object *root  = object_get_objects_root();
 612     Object *cont1 = container_get(root, "/cont1");
 613     Object *obj1  = object_new(TYPE_DUMMY);
 614     Object *obj2a = object_new(TYPE_DUMMY);
 615     Object *obj2b = object_new(TYPE_DUMMY);
 616     bool ambiguous;
 617
 618     /* Objects created:
 619      * /cont1
 620      * /cont1/obj1
 621      * /cont1/obj2 (obj2a)
 622      * /obj2 (obj2b)
 623      */
 624     object_property_add_child(cont1, "obj1", obj1);
 625     object_unref(obj1);
 626     object_property_add_child(cont1, "obj2", obj2a);
 627     object_unref(obj2a);
 628     object_property_add_child(root,  "obj2", obj2b);
 629     object_unref(obj2b);
 630
 631     ambiguous = false;
 632     g_assert(!object_resolve_path_type("", TYPE_DUMMY, &ambiguous));
 633     g_assert(ambiguous);
 634     g_assert(!object_resolve_path_type("", TYPE_DUMMY, NULL));
 635
 636     ambiguous = false;
 637     g_assert(!object_resolve_path("obj2", &ambiguous));
 638     g_assert(ambiguous);
 639     g_assert(!object_resolve_path("obj2", NULL));
 640
 641     ambiguous = false;
 642     g_assert(object_resolve_path("obj1", &ambiguous) == obj1);
 643     g_assert(!ambiguous);
 644     g_assert(object_resolve_path("obj1", NULL) == obj1);
 645
 646     object_unparent(obj2b);
 647     object_unparent(cont1);
 648 }
 649
 650 int main(int argc, char **argv)
 651 {
 652     g_test_init(&argc, &argv, NULL);
 653
 654     module_call_init(MODULE_INIT_QOM);
 655     type_register_static(&dummy_info);
 656     type_register_static(&dummy_dev_info);
 657     type_register_static(&dummy_bus_info);
 658     type_register_static(&dummy_backend_info);
 659
 660     g_test_add_func("/qom/proplist/createlist", test_dummy_createlist);
 661     g_test_add_func("/qom/proplist/createv", test_dummy_createv);
 662     g_test_add_func("/qom/proplist/createcmdline", test_dummy_createcmdl);
 663     g_test_add_func("/qom/proplist/badenum", test_dummy_badenum);
 664     g_test_add_func("/qom/proplist/getenum", test_dummy_getenum);
 665     g_test_add_func("/qom/proplist/iterator", test_dummy_iterator);
 666     g_test_add_func("/qom/proplist/class_iterator", test_dummy_class_iterator);
 667     g_test_add_func("/qom/proplist/delchild", test_dummy_delchild);
 668     g_test_add_func("/qom/resolve/partial", test_qom_partial_path);
 669
 670     return g_test_run();
 671 }