[mirror_qemu.git] / tests / check-qom-proplist.c

/*
 * Copyright (C) 2015 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library.  If not, see
 * <http://www.gnu.org/licenses/>.
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include "qemu/osdep.h"

#include "qapi/error.h"
#include "qom/object.h"
#include "qemu/module.h"
#include "qemu/option.h"
#include "qemu/config-file.h"
#include "qom/object_interfaces.h"


#define TYPE_DUMMY "qemu-dummy"

typedef struct DummyObject DummyObject;
typedef struct DummyObjectClass DummyObjectClass;

#define DUMMY_OBJECT(obj)                               \
    OBJECT_CHECK(DummyObject, (obj), TYPE_DUMMY)

typedef enum DummyAnimal DummyAnimal;

enum DummyAnimal {
    DUMMY_FROG,
    DUMMY_ALLIGATOR,
    DUMMY_PLATYPUS,

    DUMMY_LAST,
};

static const char *const dummy_animal_map[DUMMY_LAST + 1] = {
    [DUMMY_FROG] = "frog",
    [DUMMY_ALLIGATOR] = "alligator",
    [DUMMY_PLATYPUS] = "platypus",
    [DUMMY_LAST] = NULL,
};

struct DummyObject {
    Object parent_obj;

    bool bv;
    DummyAnimal av;
    char *sv;
};

struct DummyObjectClass {
    ObjectClass parent_class;
};


static void dummy_set_bv(Object *obj,
                         bool value,
                         Error **errp)
{
    DummyObject *dobj = DUMMY_OBJECT(obj);

    dobj->bv = value;
}

static bool dummy_get_bv(Object *obj,
                         Error **errp)
{
    DummyObject *dobj = DUMMY_OBJECT(obj);

    return dobj->bv;
}


static void dummy_set_av(Object *obj,
                         int value,
                         Error **errp)
{
    DummyObject *dobj = DUMMY_OBJECT(obj);

    dobj->av = value;
}

static int dummy_get_av(Object *obj,
                        Error **errp)
{
    DummyObject *dobj = DUMMY_OBJECT(obj);

    return dobj->av;
}


static void dummy_set_sv(Object *obj,
                         const char *value,
                         Error **errp)
{
    DummyObject *dobj = DUMMY_OBJECT(obj);

    g_free(dobj->sv);
    dobj->sv = g_strdup(value);
}

static char *dummy_get_sv(Object *obj,
                          Error **errp)
{
    DummyObject *dobj = DUMMY_OBJECT(obj);

    return g_strdup(dobj->sv);
}


static void dummy_init(Object *obj)
{
    object_property_add_bool(obj, "bv",
                             dummy_get_bv,
                             dummy_set_bv,
                             NULL);
}


static void dummy_class_init(ObjectClass *cls, void *data)
{
    object_class_property_add_bool(cls, "bv",
                                   dummy_get_bv,
                                   dummy_set_bv,
                                   NULL);
    object_class_property_add_str(cls, "sv",
                                  dummy_get_sv,
                                  dummy_set_sv,
                                  NULL);
    object_class_property_add_enum(cls, "av",
                                   "DummyAnimal",
                                   dummy_animal_map,
                                   dummy_get_av,
                                   dummy_set_av,
                                   NULL);
}


static void dummy_finalize(Object *obj)
{
    DummyObject *dobj = DUMMY_OBJECT(obj);

    g_free(dobj->sv);
}


static const TypeInfo dummy_info = {
    .name          = TYPE_DUMMY,
    .parent        = TYPE_OBJECT,
    .instance_size = sizeof(DummyObject),
    .instance_init = dummy_init,
    .instance_finalize = dummy_finalize,
    .class_size = sizeof(DummyObjectClass),
    .class_init = dummy_class_init,
    .interfaces = (InterfaceInfo[]) {
        { TYPE_USER_CREATABLE },
        { }
    }
};


/*
 * The following 3 object classes are used to
 * simulate the kind of relationships seen in
 * qdev, which result in complex object
 * property destruction ordering.
 *
 * DummyDev has a 'bus' child to a DummyBus
 * DummyBus has a 'backend' child to a DummyBackend
 * DummyDev has a 'backend' link to DummyBackend
 *
 * When DummyDev is finalized, it unparents the
 * DummyBackend, which unparents the DummyDev
 * which deletes the 'backend' link from DummyDev
 * to DummyBackend. This illustrates that the
 * object_property_del_all() method needs to
 * cope with the list of properties being changed
 * while it iterates over them.
 */
typedef struct DummyDev DummyDev;
typedef struct DummyDevClass DummyDevClass;
typedef struct DummyBus DummyBus;
typedef struct DummyBusClass DummyBusClass;
typedef struct DummyBackend DummyBackend;
typedef struct DummyBackendClass DummyBackendClass;

#define TYPE_DUMMY_DEV "qemu-dummy-dev"
#define TYPE_DUMMY_BUS "qemu-dummy-bus"
#define TYPE_DUMMY_BACKEND "qemu-dummy-backend"

#define DUMMY_DEV(obj)                               \
    OBJECT_CHECK(DummyDev, (obj), TYPE_DUMMY_DEV)
#define DUMMY_BUS(obj)                               \
    OBJECT_CHECK(DummyBus, (obj), TYPE_DUMMY_BUS)
#define DUMMY_BACKEND(obj)                               \
    OBJECT_CHECK(DummyBackend, (obj), TYPE_DUMMY_BACKEND)

struct DummyDev {
    Object parent_obj;

    DummyBus *bus;
};

struct DummyDevClass {
    ObjectClass parent_class;
};

struct DummyBus {
    Object parent_obj;

    DummyBackend *backend;
};

struct DummyBusClass {
    ObjectClass parent_class;
};

struct DummyBackend {
    Object parent_obj;
};

struct DummyBackendClass {
    ObjectClass parent_class;
};


static void dummy_dev_finalize(Object *obj)
{
    DummyDev *dev = DUMMY_DEV(obj);

    object_unref(OBJECT(dev->bus));
}

static void dummy_dev_init(Object *obj)
{
    DummyDev *dev = DUMMY_DEV(obj);
    DummyBus *bus = DUMMY_BUS(object_new(TYPE_DUMMY_BUS));
    DummyBackend *backend = DUMMY_BACKEND(object_new(TYPE_DUMMY_BACKEND));

    object_property_add_child(obj, "bus", OBJECT(bus), NULL);
    dev->bus = bus;
    object_property_add_child(OBJECT(bus), "backend", OBJECT(backend), NULL);
    bus->backend = backend;

    object_property_add_link(obj, "backend", TYPE_DUMMY_BACKEND,
                             (Object **)&bus->backend, NULL, 0, NULL);
}

static void dummy_dev_unparent(Object *obj)
{
    DummyDev *dev = DUMMY_DEV(obj);
    object_unparent(OBJECT(dev->bus));
}

static void dummy_dev_class_init(ObjectClass *klass, void *opaque)
{
    klass->unparent = dummy_dev_unparent;
}


static void dummy_bus_finalize(Object *obj)
{
    DummyBus *bus = DUMMY_BUS(obj);

    object_unref(OBJECT(bus->backend));
}

static void dummy_bus_init(Object *obj)
{
}

static void dummy_bus_unparent(Object *obj)
{
    DummyBus *bus = DUMMY_BUS(obj);
    object_property_del(obj->parent, "backend", NULL);
    object_unparent(OBJECT(bus->backend));
}

static void dummy_bus_class_init(ObjectClass *klass, void *opaque)
{
    klass->unparent = dummy_bus_unparent;
}

static void dummy_backend_init(Object *obj)
{
}


static const TypeInfo dummy_dev_info = {
    .name          = TYPE_DUMMY_DEV,
    .parent        = TYPE_OBJECT,
    .instance_size = sizeof(DummyDev),
    .instance_init = dummy_dev_init,
    .instance_finalize = dummy_dev_finalize,
    .class_size = sizeof(DummyDevClass),
    .class_init = dummy_dev_class_init,
};

static const TypeInfo dummy_bus_info = {
    .name          = TYPE_DUMMY_BUS,
    .parent        = TYPE_OBJECT,
    .instance_size = sizeof(DummyBus),
    .instance_init = dummy_bus_init,
    .instance_finalize = dummy_bus_finalize,
    .class_size = sizeof(DummyBusClass),
    .class_init = dummy_bus_class_init,
};

static const TypeInfo dummy_backend_info = {
    .name          = TYPE_DUMMY_BACKEND,
    .parent        = TYPE_OBJECT,
    .instance_size = sizeof(DummyBackend),
    .instance_init = dummy_backend_init,
    .class_size = sizeof(DummyBackendClass),
};

static QemuOptsList qemu_object_opts = {
    .name = "object",
    .implied_opt_name = "qom-type",
    .head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
    .desc = {
        { }
    },
};


static void test_dummy_createv(void)
{
    Error *err = NULL;
    Object *parent = object_get_objects_root();
    DummyObject *dobj = DUMMY_OBJECT(
        object_new_with_props(TYPE_DUMMY,
                              parent,
                              "dummy0",
                              &err,
                              "bv", "yes",
                              "sv", "Hiss hiss hiss",
                              "av", "platypus",
                              NULL));

    g_assert(err == NULL);
    g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
    g_assert(dobj->bv == true);
    g_assert(dobj->av == DUMMY_PLATYPUS);

    g_assert(object_resolve_path_component(parent, "dummy0")
             == OBJECT(dobj));

    object_unparent(OBJECT(dobj));
}


static Object *new_helper(Error **errp,
                          Object *parent,
                          ...)
{
    va_list vargs;
    Object *obj;

    va_start(vargs, parent);
    obj = object_new_with_propv(TYPE_DUMMY,
                                parent,
                                "dummy0",
                                errp,
                                vargs);
    va_end(vargs);
    return obj;
}

static void test_dummy_createlist(void)
{
    Error *err = NULL;
    Object *parent = object_get_objects_root();
    DummyObject *dobj = DUMMY_OBJECT(
        new_helper(&err,
                   parent,
                   "bv", "yes",
                   "sv", "Hiss hiss hiss",
                   "av", "platypus",
                   NULL));

    g_assert(err == NULL);
    g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
    g_assert(dobj->bv == true);
    g_assert(dobj->av == DUMMY_PLATYPUS);

    g_assert(object_resolve_path_component(parent, "dummy0")
             == OBJECT(dobj));

    object_unparent(OBJECT(dobj));
}

static void test_dummy_createcmdl(void)
{
    QemuOpts *opts;
    DummyObject *dobj;
    Error *err = NULL;
    const char *params = TYPE_DUMMY \
                         ",id=dev0," \
                         "bv=yes,sv=Hiss hiss hiss,av=platypus";

    qemu_add_opts(&qemu_object_opts);
    opts = qemu_opts_parse(&qemu_object_opts, params, true, &err);
    g_assert(err == NULL);
    g_assert(opts);

    dobj = DUMMY_OBJECT(user_creatable_add_opts(opts, &err));
    g_assert(err == NULL);
    g_assert(dobj);
    g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
    g_assert(dobj->bv == true);
    g_assert(dobj->av == DUMMY_PLATYPUS);

    user_creatable_del("dev0", &err);
    g_assert(err == NULL);
    error_free(err);

    /*
     * cmdline-parsing via qemu_opts_parse() results in a QemuOpts entry
     * corresponding to the Object's ID to be added to the QemuOptsList
     * for objects. To avoid having this entry conflict with future
     * Objects using the same ID (which can happen in cases where
     * qemu_opts_parse() is used to parse the object params, such as
     * with hmp_object_add() at the time of this comment), we need to
     * check for this in user_creatable_del() and remove the QemuOpts if
     * it is present.
     *
     * FIXME: add an assert to verify that the QemuOpts is cleaned up
     * once the corresponding cleanup code is added.
     */
}

static void test_dummy_badenum(void)
{
    Error *err = NULL;
    Object *parent = object_get_objects_root();
    Object *dobj =
        object_new_with_props(TYPE_DUMMY,
                              parent,
                              "dummy0",
                              &err,
                              "bv", "yes",
                              "sv", "Hiss hiss hiss",
                              "av", "yeti",
                              NULL);

    g_assert(dobj == NULL);
    g_assert(err != NULL);
    g_assert_cmpstr(error_get_pretty(err), ==,
                    "Invalid parameter 'yeti'");

    g_assert(object_resolve_path_component(parent, "dummy0")
             == NULL);

    error_free(err);
}


static void test_dummy_getenum(void)
{
    Error *err = NULL;
    int val;
    Object *parent = object_get_objects_root();
    DummyObject *dobj = DUMMY_OBJECT(
        object_new_with_props(TYPE_DUMMY,
                         parent,
                         "dummy0",
                         &err,
                         "av", "platypus",
                         NULL));

    g_assert(err == NULL);
    g_assert(dobj->av == DUMMY_PLATYPUS);

    val = object_property_get_enum(OBJECT(dobj),
                                   "av",
                                   "DummyAnimal",
                                   &err);
    g_assert(err == NULL);
    g_assert(val == DUMMY_PLATYPUS);

    /* A bad enum type name */
    val = object_property_get_enum(OBJECT(dobj),
                                   "av",
                                   "BadAnimal",
                                   &err);
    g_assert(err != NULL);
    error_free(err);
    err = NULL;

    /* A non-enum property name */
    val = object_property_get_enum(OBJECT(dobj),
                                   "iv",
                                   "DummyAnimal",
                                   &err);
    g_assert(err != NULL);
    error_free(err);

    object_unparent(OBJECT(dobj));
}


static void test_dummy_iterator(void)
{
    Object *parent = object_get_objects_root();
    DummyObject *dobj = DUMMY_OBJECT(
        object_new_with_props(TYPE_DUMMY,
                              parent,
                              "dummy0",
                              &error_abort,
                              "bv", "yes",
                              "sv", "Hiss hiss hiss",
                              "av", "platypus",
                              NULL));

    ObjectProperty *prop;
    ObjectPropertyIterator iter;
    bool seenbv = false, seensv = false, seenav = false, seentype;

    object_property_iter_init(&iter, OBJECT(dobj));
    while ((prop = object_property_iter_next(&iter))) {
        if (g_str_equal(prop->name, "bv")) {
            seenbv = true;
        } else if (g_str_equal(prop->name, "sv")) {
            seensv = true;
        } else if (g_str_equal(prop->name, "av")) {
            seenav = true;
        } else if (g_str_equal(prop->name, "type")) {
            /* This prop comes from the base Object class */
            seentype = true;
        } else {
            g_printerr("Found prop '%s'\n", prop->name);
            g_assert_not_reached();
        }
    }
    g_assert(seenbv);
    g_assert(seenav);
    g_assert(seensv);
    g_assert(seentype);

    object_unparent(OBJECT(dobj));
}


static void test_dummy_delchild(void)
{
    Object *parent = object_get_objects_root();
    DummyDev *dev = DUMMY_DEV(
        object_new_with_props(TYPE_DUMMY_DEV,
                              parent,
                              "dev0",
                              &error_abort,
                              NULL));

    object_unparent(OBJECT(dev));
}

int main(int argc, char **argv)
{
    g_test_init(&argc, &argv, NULL);

    module_call_init(MODULE_INIT_QOM);
    type_register_static(&dummy_info);
    type_register_static(&dummy_dev_info);
    type_register_static(&dummy_bus_info);
    type_register_static(&dummy_backend_info);

    g_test_add_func("/qom/proplist/createlist", test_dummy_createlist);
    g_test_add_func("/qom/proplist/createv", test_dummy_createv);
    g_test_add_func("/qom/proplist/createcmdline", test_dummy_createcmdl);
    g_test_add_func("/qom/proplist/badenum", test_dummy_badenum);
    g_test_add_func("/qom/proplist/getenum", test_dummy_getenum);
    g_test_add_func("/qom/proplist/iterator", test_dummy_iterator);
    g_test_add_func("/qom/proplist/delchild", test_dummy_delchild);

    return g_test_run();
}
Commit	Line	Data
a31bdae5 DB	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
681c28a3	21	#include "qemu/osdep.h"
a31bdae5	22
da34e65c	23	#include "qapi/error.h"
a31bdae5 DB	24	#include "qom/object.h"
a31bdae5 DB	25	#include "qemu/module.h"
a1af255f MR	26	#include "qemu/option.h"
	27	#include "qemu/config-file.h"
	28	#include "qom/object_interfaces.h"
a31bdae5 DB	29
	30
	31	#define TYPE_DUMMY "qemu-dummy"
	32
	33	typedef struct DummyObject DummyObject;
	34	typedef struct DummyObjectClass DummyObjectClass;
	35
	36	#define DUMMY_OBJECT(obj) \
	37	OBJECT_CHECK(DummyObject, (obj), TYPE_DUMMY)
	38
a8e3fbed DB	39	typedef enum DummyAnimal DummyAnimal;
	40
	41	enum DummyAnimal {
	42	DUMMY_FROG,
	43	DUMMY_ALLIGATOR,
	44	DUMMY_PLATYPUS,
	45
	46	DUMMY_LAST,
	47	};
	48
	49	static const char *const dummy_animal_map[DUMMY_LAST + 1] = {
	50	[DUMMY_FROG] = "frog",
	51	[DUMMY_ALLIGATOR] = "alligator",
	52	[DUMMY_PLATYPUS] = "platypus",
	53	[DUMMY_LAST] = NULL,
	54	};
	55
a31bdae5 DB	56	struct DummyObject {
	57	Object parent_obj;
	58
	59	bool bv;
a8e3fbed	60	DummyAnimal av;
a31bdae5 DB	61	char *sv;
	62	};
	63
	64	struct DummyObjectClass {
	65	ObjectClass parent_class;
	66	};
	67
	68
	69	static void dummy_set_bv(Object *obj,
	70	bool value,
	71	Error **errp)
	72	{
	73	DummyObject *dobj = DUMMY_OBJECT(obj);
	74
	75	dobj->bv = value;
	76	}
	77
	78	static bool dummy_get_bv(Object *obj,
	79	Error **errp)
	80	{
	81	DummyObject *dobj = DUMMY_OBJECT(obj);
	82
	83	return dobj->bv;
	84	}
	85
	86
a8e3fbed DB	87	static void dummy_set_av(Object *obj,
	88	int value,
	89	Error **errp)
	90	{
	91	DummyObject *dobj = DUMMY_OBJECT(obj);
	92
	93	dobj->av = value;
	94	}
	95
	96	static int dummy_get_av(Object *obj,
	97	Error **errp)
	98	{
	99	DummyObject *dobj = DUMMY_OBJECT(obj);
	100
	101	return dobj->av;
	102	}
	103
	104
a31bdae5 DB	105	static void dummy_set_sv(Object *obj,
	106	const char *value,
	107	Error **errp)
	108	{
	109	DummyObject *dobj = DUMMY_OBJECT(obj);
	110
	111	g_free(dobj->sv);
	112	dobj->sv = g_strdup(value);
	113	}
	114
	115	static char dummy_get_sv(Object obj,
	116	Error **errp)
	117	{
	118	DummyObject *dobj = DUMMY_OBJECT(obj);
	119
	120	return g_strdup(dobj->sv);
	121	}
	122
	123
	124	static void dummy_init(Object *obj)
	125	{
	126	object_property_add_bool(obj, "bv",
	127	dummy_get_bv,
	128	dummy_set_bv,
	129	NULL);
a31bdae5 DB	130	}
a31bdae5 DB	131
16bf7f52 DB	132
	133	static void dummy_class_init(ObjectClass cls, void data)
	134	{
	135	object_class_property_add_bool(cls, "bv",
	136	dummy_get_bv,
	137	dummy_set_bv,
	138	NULL);
	139	object_class_property_add_str(cls, "sv",
	140	dummy_get_sv,
	141	dummy_set_sv,
	142	NULL);
	143	object_class_property_add_enum(cls, "av",
	144	"DummyAnimal",
	145	dummy_animal_map,
	146	dummy_get_av,
	147	dummy_set_av,
	148	NULL);
	149	}
	150
	151
a31bdae5 DB	152	static void dummy_finalize(Object *obj)
	153	{
	154	DummyObject *dobj = DUMMY_OBJECT(obj);
	155
	156	g_free(dobj->sv);
	157	}
	158
	159
	160	static const TypeInfo dummy_info = {
	161	.name = TYPE_DUMMY,
	162	.parent = TYPE_OBJECT,
	163	.instance_size = sizeof(DummyObject),
	164	.instance_init = dummy_init,
	165	.instance_finalize = dummy_finalize,
	166	.class_size = sizeof(DummyObjectClass),
16bf7f52	167	.class_init = dummy_class_init,
a1af255f MR	168	.interfaces = (InterfaceInfo[]) {
	169	{ TYPE_USER_CREATABLE },
	170	{ }
	171	}
a31bdae5 DB	172	};
a31bdae5 DB	173
8c4d156c DB	174
	175	/*
	176	* The following 3 object classes are used to
	177	* simulate the kind of relationships seen in
	178	* qdev, which result in complex object
	179	* property destruction ordering.
	180	*
	181	* DummyDev has a 'bus' child to a DummyBus
	182	* DummyBus has a 'backend' child to a DummyBackend
	183	* DummyDev has a 'backend' link to DummyBackend
	184	*
	185	* When DummyDev is finalized, it unparents the
	186	* DummyBackend, which unparents the DummyDev
	187	* which deletes the 'backend' link from DummyDev
	188	* to DummyBackend. This illustrates that the
	189	* object_property_del_all() method needs to
	190	* cope with the list of properties being changed
	191	* while it iterates over them.
	192	*/
	193	typedef struct DummyDev DummyDev;
	194	typedef struct DummyDevClass DummyDevClass;
	195	typedef struct DummyBus DummyBus;
	196	typedef struct DummyBusClass DummyBusClass;
	197	typedef struct DummyBackend DummyBackend;
	198	typedef struct DummyBackendClass DummyBackendClass;
	199
	200	#define TYPE_DUMMY_DEV "qemu-dummy-dev"
	201	#define TYPE_DUMMY_BUS "qemu-dummy-bus"
	202	#define TYPE_DUMMY_BACKEND "qemu-dummy-backend"
	203
	204	#define DUMMY_DEV(obj) \
	205	OBJECT_CHECK(DummyDev, (obj), TYPE_DUMMY_DEV)
	206	#define DUMMY_BUS(obj) \
	207	OBJECT_CHECK(DummyBus, (obj), TYPE_DUMMY_BUS)
	208	#define DUMMY_BACKEND(obj) \
	209	OBJECT_CHECK(DummyBackend, (obj), TYPE_DUMMY_BACKEND)
	210
	211	struct DummyDev {
	212	Object parent_obj;
	213
	214	DummyBus *bus;
	215	};
	216
	217	struct DummyDevClass {
	218	ObjectClass parent_class;
	219	};
	220
	221	struct DummyBus {
	222	Object parent_obj;
	223
	224	DummyBackend *backend;
	225	};
	226
	227	struct DummyBusClass {
	228	ObjectClass parent_class;
	229	};
	230
	231	struct DummyBackend {
	232	Object parent_obj;
	233	};
	234
	235	struct DummyBackendClass {
	236	ObjectClass parent_class;
	237	};
238
239
3972a488 MAL	240	static void dummy_dev_finalize(Object *obj)
	241	{
	242	DummyDev *dev = DUMMY_DEV(obj);
	243
	244	object_unref(OBJECT(dev->bus));
	245	}
	246
8c4d156c DB	247	static void dummy_dev_init(Object *obj)
	248	{
	249	DummyDev *dev = DUMMY_DEV(obj);
	250	DummyBus *bus = DUMMY_BUS(object_new(TYPE_DUMMY_BUS));
	251	DummyBackend *backend = DUMMY_BACKEND(object_new(TYPE_DUMMY_BACKEND));
	252
	253	object_property_add_child(obj, "bus", OBJECT(bus), NULL);
	254	dev->bus = bus;
	255	object_property_add_child(OBJECT(bus), "backend", OBJECT(backend), NULL);
	256	bus->backend = backend;
	257
	258	object_property_add_link(obj, "backend", TYPE_DUMMY_BACKEND,
	259	(Object **)&bus->backend, NULL, 0, NULL);
	260	}
	261
	262	static void dummy_dev_unparent(Object *obj)
	263	{
	264	DummyDev *dev = DUMMY_DEV(obj);
	265	object_unparent(OBJECT(dev->bus));
	266	}
	267
	268	static void dummy_dev_class_init(ObjectClass klass, void opaque)
	269	{
	270	klass->unparent = dummy_dev_unparent;
	271	}
	272
	273
3972a488 MAL	274	static void dummy_bus_finalize(Object *obj)
	275	{
	276	DummyBus *bus = DUMMY_BUS(obj);
	277
	278	object_unref(OBJECT(bus->backend));
	279	}
	280
8c4d156c DB	281	static void dummy_bus_init(Object *obj)
	282	{
	283	}
	284
	285	static void dummy_bus_unparent(Object *obj)
	286	{
	287	DummyBus *bus = DUMMY_BUS(obj);
	288	object_property_del(obj->parent, "backend", NULL);
	289	object_unparent(OBJECT(bus->backend));
	290	}
	291
	292	static void dummy_bus_class_init(ObjectClass klass, void opaque)
	293	{
	294	klass->unparent = dummy_bus_unparent;
	295	}
	296
	297	static void dummy_backend_init(Object *obj)
	298	{
	299	}
	300
	301
	302	static const TypeInfo dummy_dev_info = {
	303	.name = TYPE_DUMMY_DEV,
	304	.parent = TYPE_OBJECT,
	305	.instance_size = sizeof(DummyDev),
	306	.instance_init = dummy_dev_init,
3972a488	307	.instance_finalize = dummy_dev_finalize,
8c4d156c DB	308	.class_size = sizeof(DummyDevClass),
	309	.class_init = dummy_dev_class_init,
	310	};
	311
	312	static const TypeInfo dummy_bus_info = {
	313	.name = TYPE_DUMMY_BUS,
	314	.parent = TYPE_OBJECT,
	315	.instance_size = sizeof(DummyBus),
	316	.instance_init = dummy_bus_init,
3972a488	317	.instance_finalize = dummy_bus_finalize,
8c4d156c DB	318	.class_size = sizeof(DummyBusClass),
	319	.class_init = dummy_bus_class_init,
	320	};
	321
	322	static const TypeInfo dummy_backend_info = {
	323	.name = TYPE_DUMMY_BACKEND,
	324	.parent = TYPE_OBJECT,
	325	.instance_size = sizeof(DummyBackend),
	326	.instance_init = dummy_backend_init,
	327	.class_size = sizeof(DummyBackendClass),
	328	};
	329
a1af255f MR	330	static QemuOptsList qemu_object_opts = {
	331	.name = "object",
	332	.implied_opt_name = "qom-type",
	333	.head = QTAILQ_HEAD_INITIALIZER(qemu_object_opts.head),
	334	.desc = {
	335	{ }
	336	},
	337	};
8c4d156c DB	338
8c4d156c DB	339
a31bdae5 DB	340	static void test_dummy_createv(void)
	341	{
	342	Error *err = NULL;
	343	Object *parent = object_get_objects_root();
	344	DummyObject *dobj = DUMMY_OBJECT(
	345	object_new_with_props(TYPE_DUMMY,
	346	parent,
	347	"dummy0",
	348	&err,
	349	"bv", "yes",
	350	"sv", "Hiss hiss hiss",
a8e3fbed	351	"av", "platypus",
a31bdae5 DB	352	NULL));
	353
	354	g_assert(err == NULL);
	355	g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
	356	g_assert(dobj->bv == true);
a8e3fbed	357	g_assert(dobj->av == DUMMY_PLATYPUS);
a31bdae5 DB	358
	359	g_assert(object_resolve_path_component(parent, "dummy0")
	360	== OBJECT(dobj));
	361
	362	object_unparent(OBJECT(dobj));
	363	}
	364
	365
	366	static Object new_helper(Error *errp,
	367	Object *parent,
	368	...)
	369	{
	370	va_list vargs;
	371	Object *obj;
	372
	373	va_start(vargs, parent);
	374	obj = object_new_with_propv(TYPE_DUMMY,
	375	parent,
	376	"dummy0",
	377	errp,
	378	vargs);
	379	va_end(vargs);
	380	return obj;
	381	}
	382
	383	static void test_dummy_createlist(void)
	384	{
	385	Error *err = NULL;
	386	Object *parent = object_get_objects_root();
	387	DummyObject *dobj = DUMMY_OBJECT(
	388	new_helper(&err,
	389	parent,
	390	"bv", "yes",
	391	"sv", "Hiss hiss hiss",
a8e3fbed	392	"av", "platypus",
a31bdae5 DB	393	NULL));
	394
	395	g_assert(err == NULL);
	396	g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
	397	g_assert(dobj->bv == true);
a8e3fbed	398	g_assert(dobj->av == DUMMY_PLATYPUS);
a31bdae5 DB	399
	400	g_assert(object_resolve_path_component(parent, "dummy0")
	401	== OBJECT(dobj));
	402
	403	object_unparent(OBJECT(dobj));
	404	}
	405
a1af255f MR	406	static void test_dummy_createcmdl(void)
	407	{
	408	QemuOpts *opts;
	409	DummyObject *dobj;
	410	Error *err = NULL;
	411	const char *params = TYPE_DUMMY \
	412	",id=dev0," \
	413	"bv=yes,sv=Hiss hiss hiss,av=platypus";
	414
	415	qemu_add_opts(&qemu_object_opts);
	416	opts = qemu_opts_parse(&qemu_object_opts, params, true, &err);
	417	g_assert(err == NULL);
	418	g_assert(opts);
	419
	420	dobj = DUMMY_OBJECT(user_creatable_add_opts(opts, &err));
	421	g_assert(err == NULL);
	422	g_assert(dobj);
	423	g_assert_cmpstr(dobj->sv, ==, "Hiss hiss hiss");
	424	g_assert(dobj->bv == true);
	425	g_assert(dobj->av == DUMMY_PLATYPUS);
	426
	427	user_creatable_del("dev0", &err);
	428	g_assert(err == NULL);
	429	error_free(err);
	430
	431	/*
	432	* cmdline-parsing via qemu_opts_parse() results in a QemuOpts entry
	433	* corresponding to the Object's ID to be added to the QemuOptsList
	434	* for objects. To avoid having this entry conflict with future
	435	* Objects using the same ID (which can happen in cases where
	436	* qemu_opts_parse() is used to parse the object params, such as
	437	* with hmp_object_add() at the time of this comment), we need to
	438	* check for this in user_creatable_del() and remove the QemuOpts if
	439	* it is present.
	440	*
	441	* FIXME: add an assert to verify that the QemuOpts is cleaned up
	442	* once the corresponding cleanup code is added.
	443	*/
	444	}
	445
a8e3fbed DB	446	static void test_dummy_badenum(void)
	447	{
	448	Error *err = NULL;
	449	Object *parent = object_get_objects_root();
	450	Object *dobj =
	451	object_new_with_props(TYPE_DUMMY,
	452	parent,
	453	"dummy0",
	454	&err,
	455	"bv", "yes",
	456	"sv", "Hiss hiss hiss",
	457	"av", "yeti",
	458	NULL);
	459
	460	g_assert(dobj == NULL);
	461	g_assert(err != NULL);
	462	g_assert_cmpstr(error_get_pretty(err), ==,
	463	"Invalid parameter 'yeti'");
	464
	465	g_assert(object_resolve_path_component(parent, "dummy0")
	466	== NULL);
	467
	468	error_free(err);
	469	}
	470
	471
a3590dac DB	472	static void test_dummy_getenum(void)
	473	{
	474	Error *err = NULL;
	475	int val;
	476	Object *parent = object_get_objects_root();
	477	DummyObject *dobj = DUMMY_OBJECT(
	478	object_new_with_props(TYPE_DUMMY,
	479	parent,
	480	"dummy0",
	481	&err,
	482	"av", "platypus",
	483	NULL));
	484
	485	g_assert(err == NULL);
	486	g_assert(dobj->av == DUMMY_PLATYPUS);
	487
	488	val = object_property_get_enum(OBJECT(dobj),
	489	"av",
	490	"DummyAnimal",
	491	&err);
	492	g_assert(err == NULL);
	493	g_assert(val == DUMMY_PLATYPUS);
	494
	495	/* A bad enum type name */
	496	val = object_property_get_enum(OBJECT(dobj),
	497	"av",
	498	"BadAnimal",
	499	&err);
	500	g_assert(err != NULL);
	501	error_free(err);
	502	err = NULL;
	503
	504	/* A non-enum property name */
	505	val = object_property_get_enum(OBJECT(dobj),
	506	"iv",
	507	"DummyAnimal",
	508	&err);
	509	g_assert(err != NULL);
	510	error_free(err);
a00c9482 DB	511
	512	object_unparent(OBJECT(dobj));
	513	}
	514
	515
	516	static void test_dummy_iterator(void)
	517	{
	518	Object *parent = object_get_objects_root();
	519	DummyObject *dobj = DUMMY_OBJECT(
	520	object_new_with_props(TYPE_DUMMY,
	521	parent,
	522	"dummy0",
	523	&error_abort,
	524	"bv", "yes",
	525	"sv", "Hiss hiss hiss",
	526	"av", "platypus",
	527	NULL));
	528
	529	ObjectProperty *prop;
7746abd8	530	ObjectPropertyIterator iter;
a00c9482 DB	531	bool seenbv = false, seensv = false, seenav = false, seentype;
a00c9482 DB	532
7746abd8 DB	533	object_property_iter_init(&iter, OBJECT(dobj));
7746abd8 DB	534	while ((prop = object_property_iter_next(&iter))) {
a00c9482 DB	535	if (g_str_equal(prop->name, "bv")) {
	536	seenbv = true;
	537	} else if (g_str_equal(prop->name, "sv")) {
	538	seensv = true;
	539	} else if (g_str_equal(prop->name, "av")) {
	540	seenav = true;
	541	} else if (g_str_equal(prop->name, "type")) {
	542	/* This prop comes from the base Object class */
	543	seentype = true;
	544	} else {
	545	g_printerr("Found prop '%s'\n", prop->name);
	546	g_assert_not_reached();
	547	}
	548	}
a00c9482 DB	549	g_assert(seenbv);
	550	g_assert(seenav);
	551	g_assert(seensv);
	552	g_assert(seentype);
	553
	554	object_unparent(OBJECT(dobj));
a3590dac DB	555	}
	556
	557
8c4d156c DB	558	static void test_dummy_delchild(void)
	559	{
	560	Object *parent = object_get_objects_root();
	561	DummyDev *dev = DUMMY_DEV(
	562	object_new_with_props(TYPE_DUMMY_DEV,
	563	parent,
	564	"dev0",
	565	&error_abort,
	566	NULL));
	567
	568	object_unparent(OBJECT(dev));
	569	}
	570
a31bdae5 DB	571	int main(int argc, char **argv)
	572	{
	573	g_test_init(&argc, &argv, NULL);
	574
	575	module_call_init(MODULE_INIT_QOM);
	576	type_register_static(&dummy_info);
8c4d156c DB	577	type_register_static(&dummy_dev_info);
	578	type_register_static(&dummy_bus_info);
	579	type_register_static(&dummy_backend_info);
a31bdae5 DB	580
	581	g_test_add_func("/qom/proplist/createlist", test_dummy_createlist);
	582	g_test_add_func("/qom/proplist/createv", test_dummy_createv);
a1af255f	583	g_test_add_func("/qom/proplist/createcmdline", test_dummy_createcmdl);
a8e3fbed	584	g_test_add_func("/qom/proplist/badenum", test_dummy_badenum);
a3590dac	585	g_test_add_func("/qom/proplist/getenum", test_dummy_getenum);
a00c9482	586	g_test_add_func("/qom/proplist/iterator", test_dummy_iterator);
8c4d156c	587	g_test_add_func("/qom/proplist/delchild", test_dummy_delchild);
a31bdae5 DB	588
	589	return g_test_run();
	590	}