[qemu.git] / tests / test-qdev-global-props.c

/*
 *  Test code for qdev global-properties handling
 *
 *  Copyright (c) 2012 Red Hat Inc.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include "qemu/osdep.h"

#include "hw/qdev.h"
#include "qom/object.h"
#include "qapi/visitor.h"


#define TYPE_STATIC_PROPS "static_prop_type"
#define STATIC_TYPE(obj) \
    OBJECT_CHECK(MyType, (obj), TYPE_STATIC_PROPS)

#define PROP_DEFAULT 100

typedef struct MyType {
    DeviceState parent_obj;

    uint32_t prop1;
    uint32_t prop2;
} MyType;

static Property static_props[] = {
    DEFINE_PROP_UINT32("prop1", MyType, prop1, PROP_DEFAULT),
    DEFINE_PROP_UINT32("prop2", MyType, prop2, PROP_DEFAULT),
    DEFINE_PROP_END_OF_LIST()
};

static void static_prop_class_init(ObjectClass *oc, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(oc);

    dc->realize = NULL;
    dc->props = static_props;
}

static const TypeInfo static_prop_type = {
    .name = TYPE_STATIC_PROPS,
    .parent = TYPE_DEVICE,
    .instance_size = sizeof(MyType),
    .class_init = static_prop_class_init,
};

/* Test simple static property setting to default value */
static void test_static_prop_subprocess(void)
{
    MyType *mt;

    mt = STATIC_TYPE(object_new(TYPE_STATIC_PROPS));
    qdev_init_nofail(DEVICE(mt));

    g_assert_cmpuint(mt->prop1, ==, PROP_DEFAULT);
}

static void test_static_prop(void)
{
    g_test_trap_subprocess("/qdev/properties/static/default/subprocess", 0, 0);
    g_test_trap_assert_passed();
    g_test_trap_assert_stderr("");
    g_test_trap_assert_stdout("");
}

/* Test setting of static property using global properties */
static void test_static_globalprop_subprocess(void)
{
    MyType *mt;
    static GlobalProperty props[] = {
        { TYPE_STATIC_PROPS, "prop1", "200" },
        {}
    };

    qdev_prop_register_global_list(props);

    mt = STATIC_TYPE(object_new(TYPE_STATIC_PROPS));
    qdev_init_nofail(DEVICE(mt));

    g_assert_cmpuint(mt->prop1, ==, 200);
    g_assert_cmpuint(mt->prop2, ==, PROP_DEFAULT);
}

static void test_static_globalprop(void)
{
    g_test_trap_subprocess("/qdev/properties/static/global/subprocess", 0, 0);
    g_test_trap_assert_passed();
    g_test_trap_assert_stderr("");
    g_test_trap_assert_stdout("");
}

#define TYPE_DYNAMIC_PROPS "dynamic-prop-type"
#define DYNAMIC_TYPE(obj) \
    OBJECT_CHECK(MyType, (obj), TYPE_DYNAMIC_PROPS)

#define TYPE_UNUSED_HOTPLUG   "hotplug-type"
#define TYPE_UNUSED_NOHOTPLUG "nohotplug-type"

static void prop1_accessor(Object *obj, Visitor *v, const char *name,
                           void *opaque, Error **errp)
{
    MyType *mt = DYNAMIC_TYPE(obj);

    visit_type_uint32(v, name, &mt->prop1, errp);
}

static void prop2_accessor(Object *obj, Visitor *v, const char *name,
                           void *opaque, Error **errp)
{
    MyType *mt = DYNAMIC_TYPE(obj);

    visit_type_uint32(v, name, &mt->prop2, errp);
}

static void dynamic_instance_init(Object *obj)
{
    object_property_add(obj, "prop1", "uint32", prop1_accessor, prop1_accessor,
                        NULL, NULL, NULL);
    object_property_add(obj, "prop2", "uint32", prop2_accessor, prop2_accessor,
                        NULL, NULL, NULL);
}

static void dynamic_class_init(ObjectClass *oc, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(oc);

    dc->realize = NULL;
}


static const TypeInfo dynamic_prop_type = {
    .name = TYPE_DYNAMIC_PROPS,
    .parent = TYPE_DEVICE,
    .instance_size = sizeof(MyType),
    .instance_init = dynamic_instance_init,
    .class_init = dynamic_class_init,
};

static void hotplug_class_init(ObjectClass *oc, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(oc);

    dc->realize = NULL;
    dc->hotpluggable = true;
}

static const TypeInfo hotplug_type = {
    .name = TYPE_UNUSED_HOTPLUG,
    .parent = TYPE_DEVICE,
    .instance_size = sizeof(MyType),
    .instance_init = dynamic_instance_init,
    .class_init = hotplug_class_init,
};

static void nohotplug_class_init(ObjectClass *oc, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(oc);

    dc->realize = NULL;
    dc->hotpluggable = false;
}

static const TypeInfo nohotplug_type = {
    .name = TYPE_UNUSED_NOHOTPLUG,
    .parent = TYPE_DEVICE,
    .instance_size = sizeof(MyType),
    .instance_init = dynamic_instance_init,
    .class_init = nohotplug_class_init,
};

#define TYPE_NONDEVICE "nondevice-type"

static const TypeInfo nondevice_type = {
    .name = TYPE_NONDEVICE,
    .parent = TYPE_OBJECT,
};

/* Test setting of dynamic properties using global properties */
static void test_dynamic_globalprop_subprocess(void)
{
    MyType *mt;
    static GlobalProperty props[] = {
        { TYPE_DYNAMIC_PROPS, "prop1", "101", true },
        { TYPE_DYNAMIC_PROPS, "prop2", "102", true },
        { TYPE_DYNAMIC_PROPS"-bad", "prop3", "103", true },
        { TYPE_UNUSED_HOTPLUG, "prop4", "104", true },
        { TYPE_UNUSED_NOHOTPLUG, "prop5", "105", true },
        { TYPE_NONDEVICE, "prop6", "106", true },
        {}
    };
    int all_used;

    qdev_prop_register_global_list(props);

    mt = DYNAMIC_TYPE(object_new(TYPE_DYNAMIC_PROPS));
    qdev_init_nofail(DEVICE(mt));

    g_assert_cmpuint(mt->prop1, ==, 101);
    g_assert_cmpuint(mt->prop2, ==, 102);
    all_used = qdev_prop_check_globals();
    g_assert_cmpuint(all_used, ==, 1);
    g_assert(props[0].used);
    g_assert(props[1].used);
    g_assert(!props[2].used);
    g_assert(!props[3].used);
    g_assert(!props[4].used);
    g_assert(!props[5].used);
}

static void test_dynamic_globalprop(void)
{
    g_test_trap_subprocess("/qdev/properties/dynamic/global/subprocess", 0, 0);
    g_test_trap_assert_passed();
    g_test_trap_assert_stderr_unmatched("*prop1*");
    g_test_trap_assert_stderr_unmatched("*prop2*");
    g_test_trap_assert_stderr("*Warning: global dynamic-prop-type-bad.prop3 has invalid class name\n*");
    g_test_trap_assert_stderr_unmatched("*prop4*");
    g_test_trap_assert_stderr("*Warning: global nohotplug-type.prop5=105 not used\n*");
    g_test_trap_assert_stderr("*Warning: global nondevice-type.prop6 has invalid class name\n*");
    g_test_trap_assert_stdout("");
}

/* Test setting of dynamic properties using user_provided=false properties */
static void test_dynamic_globalprop_nouser_subprocess(void)
{
    MyType *mt;
    static GlobalProperty props[] = {
        { TYPE_DYNAMIC_PROPS, "prop1", "101" },
        { TYPE_DYNAMIC_PROPS, "prop2", "102" },
        { TYPE_DYNAMIC_PROPS"-bad", "prop3", "103" },
        { TYPE_UNUSED_HOTPLUG, "prop4", "104" },
        { TYPE_UNUSED_NOHOTPLUG, "prop5", "105" },
        { TYPE_NONDEVICE, "prop6", "106" },
        {}
    };
    int all_used;

    qdev_prop_register_global_list(props);

    mt = DYNAMIC_TYPE(object_new(TYPE_DYNAMIC_PROPS));
    qdev_init_nofail(DEVICE(mt));

    g_assert_cmpuint(mt->prop1, ==, 101);
    g_assert_cmpuint(mt->prop2, ==, 102);
    all_used = qdev_prop_check_globals();
    g_assert_cmpuint(all_used, ==, 0);
    g_assert(props[0].used);
    g_assert(props[1].used);
    g_assert(!props[2].used);
    g_assert(!props[3].used);
    g_assert(!props[4].used);
    g_assert(!props[5].used);
}

static void test_dynamic_globalprop_nouser(void)
{
    g_test_trap_subprocess("/qdev/properties/dynamic/global/nouser/subprocess", 0, 0);
    g_test_trap_assert_passed();
    g_test_trap_assert_stderr("");
    g_test_trap_assert_stdout("");
}

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

    module_call_init(MODULE_INIT_QOM);
    type_register_static(&static_prop_type);
    type_register_static(&dynamic_prop_type);
    type_register_static(&hotplug_type);
    type_register_static(&nohotplug_type);
    type_register_static(&nondevice_type);

    g_test_add_func("/qdev/properties/static/default/subprocess",
                    test_static_prop_subprocess);
    g_test_add_func("/qdev/properties/static/default",
                    test_static_prop);

    g_test_add_func("/qdev/properties/static/global/subprocess",
                    test_static_globalprop_subprocess);
    g_test_add_func("/qdev/properties/static/global",
                    test_static_globalprop);

    g_test_add_func("/qdev/properties/dynamic/global/subprocess",
                    test_dynamic_globalprop_subprocess);
    g_test_add_func("/qdev/properties/dynamic/global",
                    test_dynamic_globalprop);

    g_test_add_func("/qdev/properties/dynamic/global/nouser/subprocess",
                    test_dynamic_globalprop_nouser_subprocess);
    g_test_add_func("/qdev/properties/dynamic/global/nouser",
                    test_dynamic_globalprop_nouser);

    g_test_run();

    return 0;
}
Commit	Line	Data
747b0cb4 EH	1	/*
	2	* Test code for qdev global-properties handling
	3	*
	4	* Copyright (c) 2012 Red Hat Inc.
	5	*
	6	* Permission is hereby granted, free of charge, to any person obtaining a copy
	7	* of this software and associated documentation files (the "Software"), to deal
	8	* in the Software without restriction, including without limitation the rights
	9	* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	10	* copies of the Software, and to permit persons to whom the Software is
	11	* furnished to do so, subject to the following conditions:
	12	*
	13	* The above copyright notice and this permission notice shall be included in
	14	* all copies or substantial portions of the Software.
	15	*
	16	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	17	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	18	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	19	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	20	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	21	* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	22	* THE SOFTWARE.
	23	*/
	24
681c28a3	25	#include "qemu/osdep.h"
747b0cb4 EH	26
747b0cb4 EH	27	#include "hw/qdev.h"
99a0b036 EH	28	#include "qom/object.h"
99a0b036 EH	29	#include "qapi/visitor.h"
747b0cb4 EH	30
	31
	32	#define TYPE_STATIC_PROPS "static_prop_type"
	33	#define STATIC_TYPE(obj) \
	34	OBJECT_CHECK(MyType, (obj), TYPE_STATIC_PROPS)
	35
	36	#define PROP_DEFAULT 100
	37
	38	typedef struct MyType {
	39	DeviceState parent_obj;
	40
	41	uint32_t prop1;
	42	uint32_t prop2;
	43	} MyType;
	44
	45	static Property static_props[] = {
	46	DEFINE_PROP_UINT32("prop1", MyType, prop1, PROP_DEFAULT),
	47	DEFINE_PROP_UINT32("prop2", MyType, prop2, PROP_DEFAULT),
	48	DEFINE_PROP_END_OF_LIST()
	49	};
	50
	51	static void static_prop_class_init(ObjectClass oc, void data)
	52	{
	53	DeviceClass *dc = DEVICE_CLASS(oc);
	54
	55	dc->realize = NULL;
	56	dc->props = static_props;
	57	}
	58
	59	static const TypeInfo static_prop_type = {
	60	.name = TYPE_STATIC_PROPS,
	61	.parent = TYPE_DEVICE,
	62	.instance_size = sizeof(MyType),
	63	.class_init = static_prop_class_init,
	64	};
	65
	66	/* Test simple static property setting to default value */
2177801a	67	static void test_static_prop_subprocess(void)
747b0cb4 EH	68	{
	69	MyType *mt;
	70
	71	mt = STATIC_TYPE(object_new(TYPE_STATIC_PROPS));
	72	qdev_init_nofail(DEVICE(mt));
	73
	74	g_assert_cmpuint(mt->prop1, ==, PROP_DEFAULT);
	75	}
	76
2177801a EH	77	static void test_static_prop(void)
	78	{
	79	g_test_trap_subprocess("/qdev/properties/static/default/subprocess", 0, 0);
	80	g_test_trap_assert_passed();
	81	g_test_trap_assert_stderr("");
	82	g_test_trap_assert_stdout("");
	83	}
	84
747b0cb4	85	/* Test setting of static property using global properties */
2177801a	86	static void test_static_globalprop_subprocess(void)
747b0cb4 EH	87	{
	88	MyType *mt;
	89	static GlobalProperty props[] = {
	90	{ TYPE_STATIC_PROPS, "prop1", "200" },
	91	{}
	92	};
	93
	94	qdev_prop_register_global_list(props);
	95
	96	mt = STATIC_TYPE(object_new(TYPE_STATIC_PROPS));
	97	qdev_init_nofail(DEVICE(mt));
	98
	99	g_assert_cmpuint(mt->prop1, ==, 200);
	100	g_assert_cmpuint(mt->prop2, ==, PROP_DEFAULT);
	101	}
	102
2177801a EH	103	static void test_static_globalprop(void)
	104	{
	105	g_test_trap_subprocess("/qdev/properties/static/global/subprocess", 0, 0);
	106	g_test_trap_assert_passed();
	107	g_test_trap_assert_stderr("");
	108	g_test_trap_assert_stdout("");
	109	}
	110
99a0b036 EH	111	#define TYPE_DYNAMIC_PROPS "dynamic-prop-type"
	112	#define DYNAMIC_TYPE(obj) \
	113	OBJECT_CHECK(MyType, (obj), TYPE_DYNAMIC_PROPS)
	114
08ac80cd EH	115	#define TYPE_UNUSED_HOTPLUG "hotplug-type"
	116	#define TYPE_UNUSED_NOHOTPLUG "nohotplug-type"
	117
d7bce999 EB	118	static void prop1_accessor(Object obj, Visitor v, const char *name,
d7bce999 EB	119	void opaque, Error *errp)
99a0b036 EH	120	{
	121	MyType *mt = DYNAMIC_TYPE(obj);
	122
51e72bc1	123	visit_type_uint32(v, name, &mt->prop1, errp);
99a0b036 EH	124	}
99a0b036 EH	125
d7bce999 EB	126	static void prop2_accessor(Object obj, Visitor v, const char *name,
d7bce999 EB	127	void opaque, Error *errp)
99a0b036 EH	128	{
	129	MyType *mt = DYNAMIC_TYPE(obj);
	130
51e72bc1	131	visit_type_uint32(v, name, &mt->prop2, errp);
99a0b036 EH	132	}
	133
	134	static void dynamic_instance_init(Object *obj)
	135	{
	136	object_property_add(obj, "prop1", "uint32", prop1_accessor, prop1_accessor,
	137	NULL, NULL, NULL);
	138	object_property_add(obj, "prop2", "uint32", prop2_accessor, prop2_accessor,
	139	NULL, NULL, NULL);
	140	}
	141
	142	static void dynamic_class_init(ObjectClass oc, void data)
	143	{
	144	DeviceClass *dc = DEVICE_CLASS(oc);
	145
	146	dc->realize = NULL;
	147	}
	148
	149
	150	static const TypeInfo dynamic_prop_type = {
	151	.name = TYPE_DYNAMIC_PROPS,
	152	.parent = TYPE_DEVICE,
	153	.instance_size = sizeof(MyType),
	154	.instance_init = dynamic_instance_init,
	155	.class_init = dynamic_class_init,
	156	};
	157
08ac80cd EH	158	static void hotplug_class_init(ObjectClass oc, void data)
	159	{
	160	DeviceClass *dc = DEVICE_CLASS(oc);
	161
	162	dc->realize = NULL;
	163	dc->hotpluggable = true;
	164	}
	165
	166	static const TypeInfo hotplug_type = {
	167	.name = TYPE_UNUSED_HOTPLUG,
	168	.parent = TYPE_DEVICE,
	169	.instance_size = sizeof(MyType),
	170	.instance_init = dynamic_instance_init,
	171	.class_init = hotplug_class_init,
	172	};
	173
	174	static void nohotplug_class_init(ObjectClass oc, void data)
	175	{
	176	DeviceClass *dc = DEVICE_CLASS(oc);
	177
	178	dc->realize = NULL;
	179	dc->hotpluggable = false;
	180	}
	181
	182	static const TypeInfo nohotplug_type = {
	183	.name = TYPE_UNUSED_NOHOTPLUG,
	184	.parent = TYPE_DEVICE,
	185	.instance_size = sizeof(MyType),
	186	.instance_init = dynamic_instance_init,
	187	.class_init = nohotplug_class_init,
	188	};
	189
	190	#define TYPE_NONDEVICE "nondevice-type"
	191
	192	static const TypeInfo nondevice_type = {
	193	.name = TYPE_NONDEVICE,
	194	.parent = TYPE_OBJECT,
	195	};
	196
70e98b23	197	/* Test setting of dynamic properties using global properties */
2177801a	198	static void test_dynamic_globalprop_subprocess(void)
99a0b036 EH	199	{
	200	MyType *mt;
	201	static GlobalProperty props[] = {
45de8173 EH	202	{ TYPE_DYNAMIC_PROPS, "prop1", "101", true },
45de8173 EH	203	{ TYPE_DYNAMIC_PROPS, "prop2", "102", true },
711e2f1e	204	{ TYPE_DYNAMIC_PROPS"-bad", "prop3", "103", true },
b3ce84fe	205	{ TYPE_UNUSED_HOTPLUG, "prop4", "104", true },
08ac80cd EH	206	{ TYPE_UNUSED_NOHOTPLUG, "prop5", "105", true },
08ac80cd EH	207	{ TYPE_NONDEVICE, "prop6", "106", true },
99a0b036 EH	208	{}
99a0b036 EH	209	};
711e2f1e	210	int all_used;
99a0b036 EH	211
	212	qdev_prop_register_global_list(props);
	213
	214	mt = DYNAMIC_TYPE(object_new(TYPE_DYNAMIC_PROPS));
	215	qdev_init_nofail(DEVICE(mt));
	216
	217	g_assert_cmpuint(mt->prop1, ==, 101);
	218	g_assert_cmpuint(mt->prop2, ==, 102);
d828c430	219	all_used = qdev_prop_check_globals();
711e2f1e	220	g_assert_cmpuint(all_used, ==, 1);
b3ce84fe EH	221	g_assert(props[0].used);
	222	g_assert(props[1].used);
	223	g_assert(!props[2].used);
	224	g_assert(!props[3].used);
	225	g_assert(!props[4].used);
	226	g_assert(!props[5].used);
99a0b036 EH	227	}
99a0b036 EH	228
2177801a EH	229	static void test_dynamic_globalprop(void)
	230	{
	231	g_test_trap_subprocess("/qdev/properties/dynamic/global/subprocess", 0, 0);
	232	g_test_trap_assert_passed();
	233	g_test_trap_assert_stderr_unmatched("prop1");
	234	g_test_trap_assert_stderr_unmatched("prop2");
b3ce84fe	235	g_test_trap_assert_stderr("Warning: global dynamic-prop-type-bad.prop3 has invalid class name\n");
08ac80cd	236	g_test_trap_assert_stderr_unmatched("prop4");
b3ce84fe EH	237	g_test_trap_assert_stderr("Warning: global nohotplug-type.prop5=105 not used\n");
	238	g_test_trap_assert_stderr("Warning: global nondevice-type.prop6 has invalid class name\n");
	239	g_test_trap_assert_stdout("");
	240	}
	241
	242	/* Test setting of dynamic properties using user_provided=false properties */
	243	static void test_dynamic_globalprop_nouser_subprocess(void)
	244	{
	245	MyType *mt;
	246	static GlobalProperty props[] = {
	247	{ TYPE_DYNAMIC_PROPS, "prop1", "101" },
	248	{ TYPE_DYNAMIC_PROPS, "prop2", "102" },
	249	{ TYPE_DYNAMIC_PROPS"-bad", "prop3", "103" },
	250	{ TYPE_UNUSED_HOTPLUG, "prop4", "104" },
	251	{ TYPE_UNUSED_NOHOTPLUG, "prop5", "105" },
	252	{ TYPE_NONDEVICE, "prop6", "106" },
	253	{}
	254	};
	255	int all_used;
	256
	257	qdev_prop_register_global_list(props);
	258
	259	mt = DYNAMIC_TYPE(object_new(TYPE_DYNAMIC_PROPS));
	260	qdev_init_nofail(DEVICE(mt));
	261
	262	g_assert_cmpuint(mt->prop1, ==, 101);
	263	g_assert_cmpuint(mt->prop2, ==, 102);
	264	all_used = qdev_prop_check_globals();
	265	g_assert_cmpuint(all_used, ==, 0);
	266	g_assert(props[0].used);
	267	g_assert(props[1].used);
	268	g_assert(!props[2].used);
	269	g_assert(!props[3].used);
	270	g_assert(!props[4].used);
	271	g_assert(!props[5].used);
	272	}
	273
	274	static void test_dynamic_globalprop_nouser(void)
	275	{
	276	g_test_trap_subprocess("/qdev/properties/dynamic/global/nouser/subprocess", 0, 0);
	277	g_test_trap_assert_passed();
	278	g_test_trap_assert_stderr("");
2177801a EH	279	g_test_trap_assert_stdout("");
	280	}
	281
747b0cb4 EH	282	int main(int argc, char **argv)
	283	{
	284	g_test_init(&argc, &argv, NULL);
	285
	286	module_call_init(MODULE_INIT_QOM);
	287	type_register_static(&static_prop_type);
99a0b036	288	type_register_static(&dynamic_prop_type);
08ac80cd EH	289	type_register_static(&hotplug_type);
	290	type_register_static(&nohotplug_type);
	291	type_register_static(&nondevice_type);
747b0cb4	292
2177801a EH	293	g_test_add_func("/qdev/properties/static/default/subprocess",
	294	test_static_prop_subprocess);
	295	g_test_add_func("/qdev/properties/static/default",
	296	test_static_prop);
	297
	298	g_test_add_func("/qdev/properties/static/global/subprocess",
	299	test_static_globalprop_subprocess);
	300	g_test_add_func("/qdev/properties/static/global",
	301	test_static_globalprop);
	302
	303	g_test_add_func("/qdev/properties/dynamic/global/subprocess",
	304	test_dynamic_globalprop_subprocess);
	305	g_test_add_func("/qdev/properties/dynamic/global",
	306	test_dynamic_globalprop);
747b0cb4	307
b3ce84fe EH	308	g_test_add_func("/qdev/properties/dynamic/global/nouser/subprocess",
	309	test_dynamic_globalprop_nouser_subprocess);
	310	g_test_add_func("/qdev/properties/dynamic/global/nouser",
	311	test_dynamic_globalprop_nouser);
	312
747b0cb4 EH	313	g_test_run();
	314
	315	return 0;
	316	}