[qemu.git] / tests / test-qemu-opts.c

/*
 * QemuOpts unit-tests.
 *
 * Copyright (C) 2014 Leandro Dorileo <[email protected]>
 *
 * This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
 * See the COPYING.LIB file in the top-level directory.
 */

#include "qapi/error.h"
#include "qapi/qmp/qstring.h"
#include "qemu/config-file.h"

#include <glib.h>
#include <string.h>

static QemuOptsList opts_list_01 = {
    .name = "opts_list_01",
    .head = QTAILQ_HEAD_INITIALIZER(opts_list_01.head),
    .desc = {
        {
            .name = "str1",
            .type = QEMU_OPT_STRING,
        },{
            .name = "str2",
            .type = QEMU_OPT_STRING,
        },{
            .name = "str3",
            .type = QEMU_OPT_STRING,
        },{
            .name = "number1",
            .type = QEMU_OPT_NUMBER,
        },
        { /* end of list */ }
    },
};

static QemuOptsList opts_list_02 = {
    .name = "opts_list_02",
    .head = QTAILQ_HEAD_INITIALIZER(opts_list_02.head),
    .desc = {
        {
            .name = "str1",
            .type = QEMU_OPT_STRING,
        },{
            .name = "bool1",
            .type = QEMU_OPT_BOOL,
        },{
            .name = "str2",
            .type = QEMU_OPT_STRING,
        },{
            .name = "size1",
            .type = QEMU_OPT_SIZE,
        },
        { /* end of list */ }
    },
};

static QemuOptsList opts_list_03 = {
    .name = "opts_list_03",
    .head = QTAILQ_HEAD_INITIALIZER(opts_list_03.head),
    .desc = {
        /* no elements => accept any params */
        { /* end of list */ }
    },
};

static void register_opts(void)
{
    qemu_add_opts(&opts_list_01);
    qemu_add_opts(&opts_list_02);
    qemu_add_opts(&opts_list_03);
}

static void test_find_unknown_opts(void)
{
    QemuOptsList *list;
    Error *err = NULL;

    /* should not return anything, we don't have an "unknown" option */
    list = qemu_find_opts_err("unknown", &err);
    g_assert(list == NULL);
    g_assert(err);
    error_free(err);
}

static void test_qemu_find_opts(void)
{
    QemuOptsList *list;

    /* we have an "opts_list_01" option, should return it */
    list = qemu_find_opts("opts_list_01");
    g_assert(list != NULL);
    g_assert_cmpstr(list->name, ==, "opts_list_01");
}

static void test_qemu_opts_create(void)
{
    QemuOptsList *list;
    QemuOpts *opts;

    list = qemu_find_opts("opts_list_01");
    g_assert(list != NULL);
    g_assert(QTAILQ_EMPTY(&list->head));
    g_assert_cmpstr(list->name, ==, "opts_list_01");

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);

    /* create the opts */
    opts = qemu_opts_create(list, NULL, 0, &error_abort);
    g_assert(opts != NULL);
    g_assert(!QTAILQ_EMPTY(&list->head));

    /* now we've create the opts, must find it */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts != NULL);

    qemu_opts_del(opts);

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);
}

static void test_qemu_opt_get(void)
{
    QemuOptsList *list;
    QemuOpts *opts;
    const char *opt = NULL;

    list = qemu_find_opts("opts_list_01");
    g_assert(list != NULL);
    g_assert(QTAILQ_EMPTY(&list->head));
    g_assert_cmpstr(list->name, ==, "opts_list_01");

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);

    /* create the opts */
    opts = qemu_opts_create(list, NULL, 0, &error_abort);
    g_assert(opts != NULL);
    g_assert(!QTAILQ_EMPTY(&list->head));

    /* haven't set anything to str2 yet */
    opt = qemu_opt_get(opts, "str2");
    g_assert(opt == NULL);

    qemu_opt_set(opts, "str2", "value");

    /* now we have set str2, should know about it */
    opt = qemu_opt_get(opts, "str2");
    g_assert_cmpstr(opt, ==, "value");

    qemu_opt_set(opts, "str2", "value2");

    /* having reset the value, the returned should be the reset one */
    opt = qemu_opt_get(opts, "str2");
    g_assert_cmpstr(opt, ==, "value2");

    qemu_opts_del(opts);

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);
}

static void test_qemu_opt_get_bool(void)
{
    QemuOptsList *list;
    QemuOpts *opts;
    bool opt;
    int ret;

    list = qemu_find_opts("opts_list_02");
    g_assert(list != NULL);
    g_assert(QTAILQ_EMPTY(&list->head));
    g_assert_cmpstr(list->name, ==, "opts_list_02");

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);

    /* create the opts */
    opts = qemu_opts_create(list, NULL, 0, &error_abort);
    g_assert(opts != NULL);
    g_assert(!QTAILQ_EMPTY(&list->head));

    /* haven't set anything to bool1 yet, so defval should be returned */
    opt = qemu_opt_get_bool(opts, "bool1", false);
    g_assert(opt == false);

    ret = qemu_opt_set_bool(opts, "bool1", true);
    g_assert(ret == 0);

    /* now we have set bool1, should know about it */
    opt = qemu_opt_get_bool(opts, "bool1", false);
    g_assert(opt == true);

    /* having reset the value, opt should be the reset one not defval */
    ret = qemu_opt_set_bool(opts, "bool1", false);
    g_assert(ret == 0);

    opt = qemu_opt_get_bool(opts, "bool1", true);
    g_assert(opt == false);

    qemu_opts_del(opts);

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);
}

static void test_qemu_opt_get_number(void)
{
    QemuOptsList *list;
    QemuOpts *opts;
    uint64_t opt;
    int ret;

    list = qemu_find_opts("opts_list_01");
    g_assert(list != NULL);
    g_assert(QTAILQ_EMPTY(&list->head));
    g_assert_cmpstr(list->name, ==, "opts_list_01");

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);

    /* create the opts */
    opts = qemu_opts_create(list, NULL, 0, &error_abort);
    g_assert(opts != NULL);
    g_assert(!QTAILQ_EMPTY(&list->head));

    /* haven't set anything to number1 yet, so defval should be returned */
    opt = qemu_opt_get_number(opts, "number1", 5);
    g_assert(opt == 5);

    ret = qemu_opt_set_number(opts, "number1", 10);
    g_assert(ret == 0);

    /* now we have set number1, should know about it */
    opt = qemu_opt_get_number(opts, "number1", 5);
    g_assert(opt == 10);

    /* having reset it, the returned should be the reset one not defval */
    ret = qemu_opt_set_number(opts, "number1", 15);
    g_assert(ret == 0);

    opt = qemu_opt_get_number(opts, "number1", 5);
    g_assert(opt == 15);

    qemu_opts_del(opts);

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);
}

static void test_qemu_opt_get_size(void)
{
    QemuOptsList *list;
    QemuOpts *opts;
    uint64_t opt;
    QDict *dict;

    list = qemu_find_opts("opts_list_02");
    g_assert(list != NULL);
    g_assert(QTAILQ_EMPTY(&list->head));
    g_assert_cmpstr(list->name, ==, "opts_list_02");

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);

    /* create the opts */
    opts = qemu_opts_create(list, NULL, 0, &error_abort);
    g_assert(opts != NULL);
    g_assert(!QTAILQ_EMPTY(&list->head));

    /* haven't set anything to size1 yet, so defval should be returned */
    opt = qemu_opt_get_size(opts, "size1", 5);
    g_assert(opt == 5);

    dict = qdict_new();
    g_assert(dict != NULL);

    qdict_put(dict, "size1", qstring_from_str("10"));

    qemu_opts_absorb_qdict(opts, dict, &error_abort);
    g_assert(error_abort == NULL);

    /* now we have set size1, should know about it */
    opt = qemu_opt_get_size(opts, "size1", 5);
    g_assert(opt == 10);

    /* reset value */
    qdict_put(dict, "size1", qstring_from_str("15"));

    qemu_opts_absorb_qdict(opts, dict, &error_abort);
    g_assert(error_abort == NULL);

    /* test the reset value */
    opt = qemu_opt_get_size(opts, "size1", 5);
    g_assert(opt == 15);

    qdict_del(dict, "size1");
    g_free(dict);

    qemu_opts_del(opts);

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);
}

static void test_qemu_opt_unset(void)
{
    QemuOpts *opts;
    const char *value;
    int ret;

    /* dynamically initialized (parsed) opts */
    opts = qemu_opts_parse(&opts_list_03, "key=value", 0);
    g_assert(opts != NULL);

    /* check default/parsed value */
    value = qemu_opt_get(opts, "key");
    g_assert_cmpstr(value, ==, "value");

    /* reset it to value2 */
    qemu_opt_set(opts, "key", "value2");

    value = qemu_opt_get(opts, "key");
    g_assert_cmpstr(value, ==, "value2");

    /* unset, valid only for "accept any" */
    ret = qemu_opt_unset(opts, "key");
    g_assert(ret == 0);

    /* after reset the value should be the parsed/default one */
    value = qemu_opt_get(opts, "key");
    g_assert_cmpstr(value, ==, "value");

    qemu_opts_del(opts);
}

static void test_qemu_opts_reset(void)
{
    QemuOptsList *list;
    QemuOpts *opts;
    uint64_t opt;
    int ret;

    list = qemu_find_opts("opts_list_01");
    g_assert(list != NULL);
    g_assert(QTAILQ_EMPTY(&list->head));
    g_assert_cmpstr(list->name, ==, "opts_list_01");

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);

    /* create the opts */
    opts = qemu_opts_create(list, NULL, 0, &error_abort);
    g_assert(opts != NULL);
    g_assert(!QTAILQ_EMPTY(&list->head));

    /* haven't set anything to number1 yet, so defval should be returned */
    opt = qemu_opt_get_number(opts, "number1", 5);
    g_assert(opt == 5);

    ret = qemu_opt_set_number(opts, "number1", 10);
    g_assert(ret == 0);

    /* now we have set number1, should know about it */
    opt = qemu_opt_get_number(opts, "number1", 5);
    g_assert(opt == 10);

    qemu_opts_reset(list);

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);
}

static void test_qemu_opts_set(void)
{
    QemuOptsList *list;
    QemuOpts *opts;
    int ret;
    const char *opt;

    list = qemu_find_opts("opts_list_01");
    g_assert(list != NULL);
    g_assert(QTAILQ_EMPTY(&list->head));
    g_assert_cmpstr(list->name, ==, "opts_list_01");

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);

    /* implicitly create opts and set str3 value */
    ret = qemu_opts_set(list, NULL, "str3", "value");
    g_assert(ret == 0);
    g_assert(!QTAILQ_EMPTY(&list->head));

    /* get the just created opts */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts != NULL);

    /* check the str3 value */
    opt = qemu_opt_get(opts, "str3");
    g_assert_cmpstr(opt, ==, "value");

    qemu_opts_del(opts);

    /* should not find anything at this point */
    opts = qemu_opts_find(list, NULL);
    g_assert(opts == NULL);
}

int main(int argc, char *argv[])
{
    register_opts();
    g_test_init(&argc, &argv, NULL);
    g_test_add_func("/qemu-opts/find_unknown_opts", test_find_unknown_opts);
    g_test_add_func("/qemu-opts/find_opts", test_qemu_find_opts);
    g_test_add_func("/qemu-opts/opts_create", test_qemu_opts_create);
    g_test_add_func("/qemu-opts/opt_get", test_qemu_opt_get);
    g_test_add_func("/qemu-opts/opt_get_bool", test_qemu_opt_get_bool);
    g_test_add_func("/qemu-opts/opt_get_number", test_qemu_opt_get_number);
    g_test_add_func("/qemu-opts/opt_get_size", test_qemu_opt_get_size);
    g_test_add_func("/qemu-opts/opt_unset", test_qemu_opt_unset);
    g_test_add_func("/qemu-opts/opts_reset", test_qemu_opts_reset);
    g_test_add_func("/qemu-opts/opts_set", test_qemu_opts_set);
    g_test_run();
    return 0;
}
Commit	Line	Data
4ba6fabf LD	1	/*
	2	* QemuOpts unit-tests.
	3	*
	4	* Copyright (C) 2014 Leandro Dorileo <[email protected]>
	5	*
	6	* This work is licensed under the terms of the GNU LGPL, version 2.1 or later.
	7	* See the COPYING.LIB file in the top-level directory.
	8	*/
	9
	10	#include "qapi/error.h"
	11	#include "qapi/qmp/qstring.h"
	12	#include "qemu/config-file.h"
	13
	14	#include <glib.h>
	15	#include <string.h>
	16
	17	static QemuOptsList opts_list_01 = {
	18	.name = "opts_list_01",
	19	.head = QTAILQ_HEAD_INITIALIZER(opts_list_01.head),
	20	.desc = {
	21	{
	22	.name = "str1",
	23	.type = QEMU_OPT_STRING,
	24	},{
	25	.name = "str2",
	26	.type = QEMU_OPT_STRING,
	27	},{
	28	.name = "str3",
	29	.type = QEMU_OPT_STRING,
	30	},{
	31	.name = "number1",
	32	.type = QEMU_OPT_NUMBER,
	33	},
	34	{ /* end of list */ }
	35	},
	36	};
	37
	38	static QemuOptsList opts_list_02 = {
	39	.name = "opts_list_02",
	40	.head = QTAILQ_HEAD_INITIALIZER(opts_list_02.head),
	41	.desc = {
	42	{
	43	.name = "str1",
	44	.type = QEMU_OPT_STRING,
	45	},{
	46	.name = "bool1",
	47	.type = QEMU_OPT_BOOL,
	48	},{
	49	.name = "str2",
	50	.type = QEMU_OPT_STRING,
	51	},{
	52	.name = "size1",
	53	.type = QEMU_OPT_SIZE,
	54	},
	55	{ /* end of list */ }
	56	},
	57	};
	58
748bfb4e	59	static QemuOptsList opts_list_03 = {
4ba6fabf LD	60	.name = "opts_list_03",
	61	.head = QTAILQ_HEAD_INITIALIZER(opts_list_03.head),
	62	.desc = {
	63	/* no elements => accept any params */
	64	{ /* end of list */ }
	65	},
	66	};
	67
	68	static void register_opts(void)
	69	{
	70	qemu_add_opts(&opts_list_01);
	71	qemu_add_opts(&opts_list_02);
	72	qemu_add_opts(&opts_list_03);
	73	}
	74
	75	static void test_find_unknown_opts(void)
	76	{
	77	QemuOptsList *list;
	78	Error *err = NULL;
	79
	80	/* should not return anything, we don't have an "unknown" option */
	81	list = qemu_find_opts_err("unknown", &err);
	82	g_assert(list == NULL);
	83	g_assert(err);
	84	error_free(err);
	85	}
	86
	87	static void test_qemu_find_opts(void)
	88	{
	89	QemuOptsList *list;
	90
	91	/* we have an "opts_list_01" option, should return it */
	92	list = qemu_find_opts("opts_list_01");
	93	g_assert(list != NULL);
	94	g_assert_cmpstr(list->name, ==, "opts_list_01");
	95	}
	96
	97	static void test_qemu_opts_create(void)
	98	{
	99	QemuOptsList *list;
	100	QemuOpts *opts;
	101
	102	list = qemu_find_opts("opts_list_01");
	103	g_assert(list != NULL);
	104	g_assert(QTAILQ_EMPTY(&list->head));
	105	g_assert_cmpstr(list->name, ==, "opts_list_01");
	106
	107	/* should not find anything at this point */
	108	opts = qemu_opts_find(list, NULL);
	109	g_assert(opts == NULL);
	110
	111	/* create the opts */
	112	opts = qemu_opts_create(list, NULL, 0, &error_abort);
	113	g_assert(opts != NULL);
	114	g_assert(!QTAILQ_EMPTY(&list->head));
	115
	116	/* now we've create the opts, must find it */
	117	opts = qemu_opts_find(list, NULL);
	118	g_assert(opts != NULL);
	119
	120	qemu_opts_del(opts);
	121
	122	/* should not find anything at this point */
	123	opts = qemu_opts_find(list, NULL);
124	g_assert(opts == NULL);
125	}
126
127	static void test_qemu_opt_get(void)
128	{
129	QemuOptsList *list;
130	QemuOpts *opts;
131	const char *opt = NULL;
132
133	list = qemu_find_opts("opts_list_01");
134	g_assert(list != NULL);
135	g_assert(QTAILQ_EMPTY(&list->head));
136	g_assert_cmpstr(list->name, ==, "opts_list_01");
137
138	/* should not find anything at this point */
139	opts = qemu_opts_find(list, NULL);
140	g_assert(opts == NULL);
141
142	/* create the opts */
143	opts = qemu_opts_create(list, NULL, 0, &error_abort);
144	g_assert(opts != NULL);
145	g_assert(!QTAILQ_EMPTY(&list->head));
146
147	/* haven't set anything to str2 yet */
148	opt = qemu_opt_get(opts, "str2");
149	g_assert(opt == NULL);
150
151	qemu_opt_set(opts, "str2", "value");
152
153	/* now we have set str2, should know about it */
154	opt = qemu_opt_get(opts, "str2");
155	g_assert_cmpstr(opt, ==, "value");
156
157	qemu_opt_set(opts, "str2", "value2");
158
159	/* having reset the value, the returned should be the reset one */
160	opt = qemu_opt_get(opts, "str2");
161	g_assert_cmpstr(opt, ==, "value2");
162
163	qemu_opts_del(opts);
164
165	/* should not find anything at this point */
166	opts = qemu_opts_find(list, NULL);
167	g_assert(opts == NULL);
168	}
169
170	static void test_qemu_opt_get_bool(void)
171	{
172	QemuOptsList *list;
173	QemuOpts *opts;
174	bool opt;
175	int ret;
176
177	list = qemu_find_opts("opts_list_02");
178	g_assert(list != NULL);
179	g_assert(QTAILQ_EMPTY(&list->head));
180	g_assert_cmpstr(list->name, ==, "opts_list_02");
181
182	/* should not find anything at this point */
183	opts = qemu_opts_find(list, NULL);
184	g_assert(opts == NULL);
185
186	/* create the opts */
187	opts = qemu_opts_create(list, NULL, 0, &error_abort);
188	g_assert(opts != NULL);
189	g_assert(!QTAILQ_EMPTY(&list->head));
190
191	/* haven't set anything to bool1 yet, so defval should be returned */
192	opt = qemu_opt_get_bool(opts, "bool1", false);
193	g_assert(opt == false);
194
195	ret = qemu_opt_set_bool(opts, "bool1", true);
196	g_assert(ret == 0);
197
198	/* now we have set bool1, should know about it */
199	opt = qemu_opt_get_bool(opts, "bool1", false);
200	g_assert(opt == true);
201
202	/* having reset the value, opt should be the reset one not defval */
203	ret = qemu_opt_set_bool(opts, "bool1", false);
204	g_assert(ret == 0);
205
206	opt = qemu_opt_get_bool(opts, "bool1", true);
207	g_assert(opt == false);
208
209	qemu_opts_del(opts);
210
211	/* should not find anything at this point */
212	opts = qemu_opts_find(list, NULL);
213	g_assert(opts == NULL);
214	}
215
216	static void test_qemu_opt_get_number(void)
217	{
218	QemuOptsList *list;
219	QemuOpts *opts;
220	uint64_t opt;
221	int ret;
222
223	list = qemu_find_opts("opts_list_01");
224	g_assert(list != NULL);
225	g_assert(QTAILQ_EMPTY(&list->head));
226	g_assert_cmpstr(list->name, ==, "opts_list_01");
227
228	/* should not find anything at this point */
229	opts = qemu_opts_find(list, NULL);
230	g_assert(opts == NULL);
231
232	/* create the opts */
233	opts = qemu_opts_create(list, NULL, 0, &error_abort);
234	g_assert(opts != NULL);
235	g_assert(!QTAILQ_EMPTY(&list->head));
236
237	/* haven't set anything to number1 yet, so defval should be returned */
238	opt = qemu_opt_get_number(opts, "number1", 5);
239	g_assert(opt == 5);
240
241	ret = qemu_opt_set_number(opts, "number1", 10);
242	g_assert(ret == 0);
243
244	/* now we have set number1, should know about it */
245	opt = qemu_opt_get_number(opts, "number1", 5);
246	g_assert(opt == 10);
247
248	/* having reset it, the returned should be the reset one not defval */
249	ret = qemu_opt_set_number(opts, "number1", 15);
250	g_assert(ret == 0);
251
252	opt = qemu_opt_get_number(opts, "number1", 5);
253	g_assert(opt == 15);
254
255	qemu_opts_del(opts);
256
257	/* should not find anything at this point */
258	opts = qemu_opts_find(list, NULL);
259	g_assert(opts == NULL);
260	}
261
262	static void test_qemu_opt_get_size(void)
263	{
264	QemuOptsList *list;
265	QemuOpts *opts;
266	uint64_t opt;
267	QDict *dict;
268
269	list = qemu_find_opts("opts_list_02");
270	g_assert(list != NULL);
271	g_assert(QTAILQ_EMPTY(&list->head));
272	g_assert_cmpstr(list->name, ==, "opts_list_02");
273
274	/* should not find anything at this point */
275	opts = qemu_opts_find(list, NULL);
276	g_assert(opts == NULL);
277
278	/* create the opts */
279	opts = qemu_opts_create(list, NULL, 0, &error_abort);
280	g_assert(opts != NULL);
281	g_assert(!QTAILQ_EMPTY(&list->head));
282
283	/* haven't set anything to size1 yet, so defval should be returned */
284	opt = qemu_opt_get_size(opts, "size1", 5);
285	g_assert(opt == 5);
286
287	dict = qdict_new();
288	g_assert(dict != NULL);
289
290	qdict_put(dict, "size1", qstring_from_str("10"));
291
292	qemu_opts_absorb_qdict(opts, dict, &error_abort);
293	g_assert(error_abort == NULL);
294
295	/* now we have set size1, should know about it */
296	opt = qemu_opt_get_size(opts, "size1", 5);
297	g_assert(opt == 10);
298
299	/* reset value */
300	qdict_put(dict, "size1", qstring_from_str("15"));
301
302	qemu_opts_absorb_qdict(opts, dict, &error_abort);
303	g_assert(error_abort == NULL);
304
305	/* test the reset value */
306	opt = qemu_opt_get_size(opts, "size1", 5);
307	g_assert(opt == 15);
308
309	qdict_del(dict, "size1");
310	g_free(dict);
311
312	qemu_opts_del(opts);
313
314	/* should not find anything at this point */
315	opts = qemu_opts_find(list, NULL);
316	g_assert(opts == NULL);
317	}
318
319	static void test_qemu_opt_unset(void)
320	{
321	QemuOpts *opts;
322	const char *value;
323	int ret;
324
325	/* dynamically initialized (parsed) opts */
326	opts = qemu_opts_parse(&opts_list_03, "key=value", 0);
327	g_assert(opts != NULL);
328
329	/* check default/parsed value */
330	value = qemu_opt_get(opts, "key");
331	g_assert_cmpstr(value, ==, "value");
332
333	/* reset it to value2 */
334	qemu_opt_set(opts, "key", "value2");
335
336	value = qemu_opt_get(opts, "key");
337	g_assert_cmpstr(value, ==, "value2");
338
339	/* unset, valid only for "accept any" */
340	ret = qemu_opt_unset(opts, "key");
341	g_assert(ret == 0);
342
343	/* after reset the value should be the parsed/default one */
344	value = qemu_opt_get(opts, "key");
345	g_assert_cmpstr(value, ==, "value");
346
347	qemu_opts_del(opts);
348	}
349
350	static void test_qemu_opts_reset(void)
351	{
352	QemuOptsList *list;
353	QemuOpts *opts;
354	uint64_t opt;
355	int ret;
356
357	list = qemu_find_opts("opts_list_01");
358	g_assert(list != NULL);
359	g_assert(QTAILQ_EMPTY(&list->head));
360	g_assert_cmpstr(list->name, ==, "opts_list_01");
361
362	/* should not find anything at this point */
363	opts = qemu_opts_find(list, NULL);
364	g_assert(opts == NULL);
365
366	/* create the opts */
367	opts = qemu_opts_create(list, NULL, 0, &error_abort);
368	g_assert(opts != NULL);
369	g_assert(!QTAILQ_EMPTY(&list->head));
370
371	/* haven't set anything to number1 yet, so defval should be returned */
372	opt = qemu_opt_get_number(opts, "number1", 5);
373	g_assert(opt == 5);
374
375	ret = qemu_opt_set_number(opts, "number1", 10);
376	g_assert(ret == 0);
377
378	/* now we have set number1, should know about it */
379	opt = qemu_opt_get_number(opts, "number1", 5);
380	g_assert(opt == 10);
381
382	qemu_opts_reset(list);
383
384	/* should not find anything at this point */
385	opts = qemu_opts_find(list, NULL);
386	g_assert(opts == NULL);
387	}
388
389	static void test_qemu_opts_set(void)
390	{
391	QemuOptsList *list;
392	QemuOpts *opts;
393	int ret;
394	const char *opt;
395
396	list = qemu_find_opts("opts_list_01");
397	g_assert(list != NULL);
398	g_assert(QTAILQ_EMPTY(&list->head));
399	g_assert_cmpstr(list->name, ==, "opts_list_01");
400
401	/* should not find anything at this point */
402	opts = qemu_opts_find(list, NULL);
403	g_assert(opts == NULL);
404
405	/* implicitly create opts and set str3 value */
406	ret = qemu_opts_set(list, NULL, "str3", "value");
407	g_assert(ret == 0);
408	g_assert(!QTAILQ_EMPTY(&list->head));
409
410	/* get the just created opts */
411	opts = qemu_opts_find(list, NULL);
412	g_assert(opts != NULL);
413
414	/* check the str3 value */
415	opt = qemu_opt_get(opts, "str3");
416	g_assert_cmpstr(opt, ==, "value");
417
418	qemu_opts_del(opts);
419
420	/* should not find anything at this point */
421	opts = qemu_opts_find(list, NULL);
422	g_assert(opts == NULL);
423	}
424
425	int main(int argc, char *argv[])
426	{
427	register_opts();
428	g_test_init(&argc, &argv, NULL);
429	g_test_add_func("/qemu-opts/find_unknown_opts", test_find_unknown_opts);
430	g_test_add_func("/qemu-opts/find_opts", test_qemu_find_opts);
431	g_test_add_func("/qemu-opts/opts_create", test_qemu_opts_create);
432	g_test_add_func("/qemu-opts/opt_get", test_qemu_opt_get);
433	g_test_add_func("/qemu-opts/opt_get_bool", test_qemu_opt_get_bool);
434	g_test_add_func("/qemu-opts/opt_get_number", test_qemu_opt_get_number);
435	g_test_add_func("/qemu-opts/opt_get_size", test_qemu_opt_get_size);
436	g_test_add_func("/qemu-opts/opt_unset", test_qemu_opt_unset);
437	g_test_add_func("/qemu-opts/opts_reset", test_qemu_opts_reset);
438	g_test_add_func("/qemu-opts/opts_set", test_qemu_opts_set);
439	g_test_run();
440	return 0;
441	}