[qemu.git] / tests / test-qmp-input-visitor.c

/*
 * QMP Input Visitor unit-tests.
 *
 * Copyright (C) 2011 Red Hat Inc.
 *
 * Authors:
 *  Luiz Capitulino <lcapitulino@redhat.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
 * See the COPYING file in the top-level directory.
 */

#include <glib.h>
#include <stdarg.h>

#include "qapi/qmp-input-visitor.h"
#include "test-qapi-types.h"
#include "test-qapi-visit.h"
#include "qemu-objects.h"

typedef struct TestInputVisitorData {
    QObject *obj;
    QmpInputVisitor *qiv;
} TestInputVisitorData;

static void visitor_input_teardown(TestInputVisitorData *data,
                                   const void *unused)
{
    qobject_decref(data->obj);
    data->obj = NULL;

    if (data->qiv) {
        qmp_input_visitor_cleanup(data->qiv);
        data->qiv = NULL;
    }
}

/* This is provided instead of a test setup function so that the JSON
   string used by the tests are kept in the test functions (and not
   int main()) */
static GCC_FMT_ATTR(2, 3)
Visitor *visitor_input_test_init(TestInputVisitorData *data,
                                 const char *json_string, ...)
{
    Visitor *v;
    va_list ap;

    va_start(ap, json_string);
    data->obj = qobject_from_jsonv(json_string, &ap);
    va_end(ap);

    g_assert(data->obj != NULL);

    data->qiv = qmp_input_visitor_new(data->obj);
    g_assert(data->qiv != NULL);

    v = qmp_input_get_visitor(data->qiv);
    g_assert(v != NULL);

    return v;
}

static void test_visitor_in_int(TestInputVisitorData *data,
                                const void *unused)
{
    int64_t res = 0, value = -42;
    Error *errp = NULL;
    Visitor *v;

    v = visitor_input_test_init(data, "%" PRId64, value);

    visit_type_int(v, &res, NULL, &errp);
    g_assert(!error_is_set(&errp));
    g_assert_cmpint(res, ==, value);
}

static void test_visitor_in_bool(TestInputVisitorData *data,
                                 const void *unused)
{
    Error *errp = NULL;
    bool res = false;
    Visitor *v;

    v = visitor_input_test_init(data, "true");

    visit_type_bool(v, &res, NULL, &errp);
    g_assert(!error_is_set(&errp));
    g_assert_cmpint(res, ==, true);
}

static void test_visitor_in_number(TestInputVisitorData *data,
                                   const void *unused)
{
    double res = 0, value = 3.14;
    Error *errp = NULL;
    Visitor *v;

    v = visitor_input_test_init(data, "%f", value);

    visit_type_number(v, &res, NULL, &errp);
    g_assert(!error_is_set(&errp));
    g_assert_cmpfloat(res, ==, value);
}

static void test_visitor_in_string(TestInputVisitorData *data,
                                   const void *unused)
{
    char *res = NULL, *value = (char *) "Q E M U";
    Error *errp = NULL;
    Visitor *v;

    v = visitor_input_test_init(data, "%s", value);

    visit_type_str(v, &res, NULL, &errp);
    g_assert(!error_is_set(&errp));
    g_assert_cmpstr(res, ==, value);

    g_free(res);
}

static void test_visitor_in_enum(TestInputVisitorData *data,
                                 const void *unused)
{
    Error *errp = NULL;
    Visitor *v;
    EnumOne i;

    for (i = 0; EnumOne_lookup[i]; i++) {
        EnumOne res = -1;

        v = visitor_input_test_init(data, "%s", EnumOne_lookup[i]);

        visit_type_EnumOne(v, &res, NULL, &errp);
        g_assert(!error_is_set(&errp));
        g_assert_cmpint(i, ==, res);

        visitor_input_teardown(data, NULL);
    }

    data->obj = NULL;
    data->qiv = NULL;
}

typedef struct TestStruct
{
    int64_t integer;
    bool boolean;
    char *string;
} TestStruct;

static void visit_type_TestStruct(Visitor *v, TestStruct **obj,
                                  const char *name, Error **errp)
{
    Error *err = NULL;
    if (!error_is_set(errp)) {
        visit_start_struct(v, (void **)obj, "TestStruct", name, sizeof(TestStruct),
                           &err);
        if (!err) {
            visit_type_int(v, &(*obj)->integer, "integer", &err);
            visit_type_bool(v, &(*obj)->boolean, "boolean", &err);
            visit_type_str(v, &(*obj)->string, "string", &err);

            /* Always call end_struct if start_struct succeeded.  */
            error_propagate(errp, err);
            err = NULL;
            visit_end_struct(v, &err);
        }
        error_propagate(errp, err);
    }
}

static void test_visitor_in_struct(TestInputVisitorData *data,
                                   const void *unused)
{
    TestStruct *p = NULL;
    Error *errp = NULL;
    Visitor *v;

    v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");

    visit_type_TestStruct(v, &p, NULL, &errp);
    g_assert(!error_is_set(&errp));
    g_assert_cmpint(p->integer, ==, -42);
    g_assert(p->boolean == true);
    g_assert_cmpstr(p->string, ==, "foo");

    g_free(p->string);
    g_free(p);
}

static void check_and_free_str(char *str, const char *cmp)
{
    g_assert_cmpstr(str, ==, cmp);
    g_free(str);
}

static void test_visitor_in_struct_nested(TestInputVisitorData *data,
                                          const void *unused)
{
    UserDefNested *udp = NULL;
    Error *errp = NULL;
    Visitor *v;

    v = visitor_input_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string' }, 'string2': 'string2'}}}");

    visit_type_UserDefNested(v, &udp, NULL, &errp);
    g_assert(!error_is_set(&errp));

    check_and_free_str(udp->string0, "string0");
    check_and_free_str(udp->dict1.string1, "string1");
    g_assert_cmpint(udp->dict1.dict2.userdef1->integer, ==, 42);
    check_and_free_str(udp->dict1.dict2.userdef1->string, "string");
    check_and_free_str(udp->dict1.dict2.string2, "string2");
    g_assert(udp->dict1.has_dict3 == false);

    g_free(udp->dict1.dict2.userdef1);
    g_free(udp);
}

static void test_visitor_in_list(TestInputVisitorData *data,
                                 const void *unused)
{
    UserDefOneList *item, *head = NULL;
    Error *errp = NULL;
    Visitor *v;
    int i;

    v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");

    visit_type_UserDefOneList(v, &head, NULL, &errp);
    g_assert(!error_is_set(&errp));
    g_assert(head != NULL);

    for (i = 0, item = head; item; item = item->next, i++) {
        char string[12];

        snprintf(string, sizeof(string), "string%d", i);
        g_assert_cmpstr(item->value->string, ==, string);
        g_assert_cmpint(item->value->integer, ==, 42 + i);
    }

    qapi_free_UserDefOneList(head);
}

static void test_visitor_in_union(TestInputVisitorData *data,
                                  const void *unused)
{
    Visitor *v;
    Error *err = NULL;
    UserDefUnion *tmp;

    v = visitor_input_test_init(data, "{ 'type': 'b', 'data' : { 'integer': 42 } }");

    visit_type_UserDefUnion(v, &tmp, NULL, &err);
    g_assert(err == NULL);
    g_assert_cmpint(tmp->kind, ==, USER_DEF_UNION_KIND_B);
    g_assert_cmpint(tmp->b->integer, ==, 42);
    qapi_free_UserDefUnion(tmp);
}

static void input_visitor_test_add(const char *testpath,
                                   TestInputVisitorData *data,
                                   void (*test_func)(TestInputVisitorData *data, const void *user_data))
{
    g_test_add(testpath, TestInputVisitorData, data, NULL, test_func,
               visitor_input_teardown);
}

static void test_visitor_in_errors(TestInputVisitorData *data,
                                   const void *unused)
{
    TestStruct *p = NULL;
    Error *errp = NULL;
    Visitor *v;

    v = visitor_input_test_init(data, "{ 'integer': false, 'boolean': 'foo', 'string': -42 }");

    visit_type_TestStruct(v, &p, NULL, &errp);
    g_assert(error_is_set(&errp));
    g_assert(p->string == NULL);

    g_free(p->string);
    g_free(p);
}

int main(int argc, char **argv)
{
    TestInputVisitorData in_visitor_data;

    g_test_init(&argc, &argv, NULL);

    input_visitor_test_add("/visitor/input/int",
                           &in_visitor_data, test_visitor_in_int);
    input_visitor_test_add("/visitor/input/bool",
                           &in_visitor_data, test_visitor_in_bool);
    input_visitor_test_add("/visitor/input/number",
                           &in_visitor_data, test_visitor_in_number);
    input_visitor_test_add("/visitor/input/string",
                            &in_visitor_data, test_visitor_in_string);
    input_visitor_test_add("/visitor/input/enum",
                            &in_visitor_data, test_visitor_in_enum);
    input_visitor_test_add("/visitor/input/struct",
                            &in_visitor_data, test_visitor_in_struct);
    input_visitor_test_add("/visitor/input/struct-nested",
                            &in_visitor_data, test_visitor_in_struct_nested);
    input_visitor_test_add("/visitor/input/list",
                            &in_visitor_data, test_visitor_in_list);
    input_visitor_test_add("/visitor/input/union",
                            &in_visitor_data, test_visitor_in_union);
    input_visitor_test_add("/visitor/input/errors",
                            &in_visitor_data, test_visitor_in_errors);

    g_test_run();

    return 0;
}
Commit	Line	Data
d88f5fd1 LC	1	/*
	2	* QMP Input Visitor unit-tests.
	3	*
	4	* Copyright (C) 2011 Red Hat Inc.
	5	*
	6	* Authors:
	7	* Luiz Capitulino <lcapitulino@redhat.com>
	8	*
	9	* This work is licensed under the terms of the GNU GPL, version 2 or later.
	10	* See the COPYING file in the top-level directory.
	11	*/
	12
	13	#include <glib.h>
	14	#include <stdarg.h>
	15
	16	#include "qapi/qmp-input-visitor.h"
	17	#include "test-qapi-types.h"
	18	#include "test-qapi-visit.h"
	19	#include "qemu-objects.h"
	20
	21	typedef struct TestInputVisitorData {
	22	QObject *obj;
	23	QmpInputVisitor *qiv;
	24	} TestInputVisitorData;
	25
	26	static void visitor_input_teardown(TestInputVisitorData *data,
	27	const void *unused)
	28	{
	29	qobject_decref(data->obj);
	30	data->obj = NULL;
	31
	32	if (data->qiv) {
	33	qmp_input_visitor_cleanup(data->qiv);
	34	data->qiv = NULL;
	35	}
	36	}
	37
	38	/* This is provided instead of a test setup function so that the JSON
	39	string used by the tests are kept in the test functions (and not
	40	int main()) */
aba2107a SW	41	static GCC_FMT_ATTR(2, 3)
	42	Visitor visitor_input_test_init(TestInputVisitorData data,
	43	const char *json_string, ...)
d88f5fd1 LC	44	{
	45	Visitor *v;
	46	va_list ap;
	47
	48	va_start(ap, json_string);
	49	data->obj = qobject_from_jsonv(json_string, &ap);
	50	va_end(ap);
	51
	52	g_assert(data->obj != NULL);
	53
	54	data->qiv = qmp_input_visitor_new(data->obj);
	55	g_assert(data->qiv != NULL);
	56
	57	v = qmp_input_get_visitor(data->qiv);
	58	g_assert(v != NULL);
	59
	60	return v;
	61	}
	62
	63	static void test_visitor_in_int(TestInputVisitorData *data,
	64	const void *unused)
	65	{
	66	int64_t res = 0, value = -42;
	67	Error *errp = NULL;
	68	Visitor *v;
	69
aba2107a	70	v = visitor_input_test_init(data, "%" PRId64, value);
d88f5fd1 LC	71
	72	visit_type_int(v, &res, NULL, &errp);
	73	g_assert(!error_is_set(&errp));
	74	g_assert_cmpint(res, ==, value);
	75	}
	76
	77	static void test_visitor_in_bool(TestInputVisitorData *data,
	78	const void *unused)
	79	{
	80	Error *errp = NULL;
	81	bool res = false;
	82	Visitor *v;
	83
	84	v = visitor_input_test_init(data, "true");
	85
	86	visit_type_bool(v, &res, NULL, &errp);
	87	g_assert(!error_is_set(&errp));
	88	g_assert_cmpint(res, ==, true);
	89	}
	90
	91	static void test_visitor_in_number(TestInputVisitorData *data,
	92	const void *unused)
	93	{
	94	double res = 0, value = 3.14;
	95	Error *errp = NULL;
	96	Visitor *v;
	97
	98	v = visitor_input_test_init(data, "%f", value);
	99
	100	visit_type_number(v, &res, NULL, &errp);
	101	g_assert(!error_is_set(&errp));
	102	g_assert_cmpfloat(res, ==, value);
	103	}
	104
	105	static void test_visitor_in_string(TestInputVisitorData *data,
	106	const void *unused)
	107	{
	108	char res = NULL, value = (char *) "Q E M U";
	109	Error *errp = NULL;
	110	Visitor *v;
	111
	112	v = visitor_input_test_init(data, "%s", value);
	113
	114	visit_type_str(v, &res, NULL, &errp);
	115	g_assert(!error_is_set(&errp));
	116	g_assert_cmpstr(res, ==, value);
	117
	118	g_free(res);
	119	}
	120
	121	static void test_visitor_in_enum(TestInputVisitorData *data,
	122	const void *unused)
	123	{
	124	Error *errp = NULL;
	125	Visitor *v;
	126	EnumOne i;
	127
	128	for (i = 0; EnumOne_lookup[i]; i++) {
	129	EnumOne res = -1;
	130
	131	v = visitor_input_test_init(data, "%s", EnumOne_lookup[i]);
	132
	133	visit_type_EnumOne(v, &res, NULL, &errp);
	134	g_assert(!error_is_set(&errp));
135	g_assert_cmpint(i, ==, res);
136
137	visitor_input_teardown(data, NULL);
138	}
139
140	data->obj = NULL;
141	data->qiv = NULL;
142	}
143
144	typedef struct TestStruct
145	{
146	int64_t integer;
147	bool boolean;
148	char *string;
149	} TestStruct;
150
151	static void visit_type_TestStruct(Visitor v, TestStruct *obj,
152	const char name, Error *errp)
153	{
d195325b PB	154	Error *err = NULL;
	155	if (!error_is_set(errp)) {
	156	visit_start_struct(v, (void **)obj, "TestStruct", name, sizeof(TestStruct),
	157	&err);
	158	if (!err) {
	159	visit_type_int(v, &(*obj)->integer, "integer", &err);
	160	visit_type_bool(v, &(*obj)->boolean, "boolean", &err);
	161	visit_type_str(v, &(*obj)->string, "string", &err);
	162
	163	/* Always call end_struct if start_struct succeeded. */
	164	error_propagate(errp, err);
	165	err = NULL;
	166	visit_end_struct(v, &err);
	167	}
	168	error_propagate(errp, err);
	169	}
d88f5fd1 LC	170	}
	171
	172	static void test_visitor_in_struct(TestInputVisitorData *data,
	173	const void *unused)
	174	{
	175	TestStruct *p = NULL;
	176	Error *errp = NULL;
	177	Visitor *v;
	178
	179	v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
	180
	181	visit_type_TestStruct(v, &p, NULL, &errp);
	182	g_assert(!error_is_set(&errp));
	183	g_assert_cmpint(p->integer, ==, -42);
	184	g_assert(p->boolean == true);
	185	g_assert_cmpstr(p->string, ==, "foo");
	186
	187	g_free(p->string);
	188	g_free(p);
	189	}
	190
	191	static void check_and_free_str(char str, const char cmp)
	192	{
	193	g_assert_cmpstr(str, ==, cmp);
	194	g_free(str);
	195	}
	196
	197	static void test_visitor_in_struct_nested(TestInputVisitorData *data,
	198	const void *unused)
	199	{
	200	UserDefNested *udp = NULL;
	201	Error *errp = NULL;
	202	Visitor *v;
	203
	204	v = visitor_input_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string' }, 'string2': 'string2'}}}");
	205
	206	visit_type_UserDefNested(v, &udp, NULL, &errp);
	207	g_assert(!error_is_set(&errp));
	208
	209	check_and_free_str(udp->string0, "string0");
	210	check_and_free_str(udp->dict1.string1, "string1");
	211	g_assert_cmpint(udp->dict1.dict2.userdef1->integer, ==, 42);
	212	check_and_free_str(udp->dict1.dict2.userdef1->string, "string");
	213	check_and_free_str(udp->dict1.dict2.string2, "string2");
	214	g_assert(udp->dict1.has_dict3 == false);
	215
	216	g_free(udp->dict1.dict2.userdef1);
	217	g_free(udp);
	218	}
	219
	220	static void test_visitor_in_list(TestInputVisitorData *data,
	221	const void *unused)
	222	{
	223	UserDefOneList item, head = NULL;
	224	Error *errp = NULL;
	225	Visitor *v;
	226	int i;
	227
	228	v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
	229
	230	visit_type_UserDefOneList(v, &head, NULL, &errp);
	231	g_assert(!error_is_set(&errp));
	232	g_assert(head != NULL);
	233
234	for (i = 0, item = head; item; item = item->next, i++) {
235	char string[12];
236
237	snprintf(string, sizeof(string), "string%d", i);
238	g_assert_cmpstr(item->value->string, ==, string);
239	g_assert_cmpint(item->value->integer, ==, 42 + i);
240	}
241
242	qapi_free_UserDefOneList(head);
243	}
244
dc8fb6df PB	245	static void test_visitor_in_union(TestInputVisitorData *data,
	246	const void *unused)
	247	{
	248	Visitor *v;
	249	Error *err = NULL;
	250	UserDefUnion *tmp;
	251
	252	v = visitor_input_test_init(data, "{ 'type': 'b', 'data' : { 'integer': 42 } }");
	253
	254	visit_type_UserDefUnion(v, &tmp, NULL, &err);
	255	g_assert(err == NULL);
	256	g_assert_cmpint(tmp->kind, ==, USER_DEF_UNION_KIND_B);
	257	g_assert_cmpint(tmp->b->integer, ==, 42);
	258	qapi_free_UserDefUnion(tmp);
	259	}
	260
d88f5fd1 LC	261	static void input_visitor_test_add(const char *testpath,
	262	TestInputVisitorData *data,
	263	void (test_func)(TestInputVisitorData data, const void *user_data))
	264	{
	265	g_test_add(testpath, TestInputVisitorData, data, NULL, test_func,
	266	visitor_input_teardown);
	267	}
	268
3dcf71f6 PB	269	static void test_visitor_in_errors(TestInputVisitorData *data,
	270	const void *unused)
	271	{
	272	TestStruct *p = NULL;
	273	Error *errp = NULL;
	274	Visitor *v;
	275
	276	v = visitor_input_test_init(data, "{ 'integer': false, 'boolean': 'foo', 'string': -42 }");
	277
	278	visit_type_TestStruct(v, &p, NULL, &errp);
	279	g_assert(error_is_set(&errp));
	280	g_assert(p->string == NULL);
	281
	282	g_free(p->string);
	283	g_free(p);
	284	}
	285
d88f5fd1 LC	286	int main(int argc, char **argv)
	287	{
	288	TestInputVisitorData in_visitor_data;
	289
	290	g_test_init(&argc, &argv, NULL);
	291
	292	input_visitor_test_add("/visitor/input/int",
	293	&in_visitor_data, test_visitor_in_int);
	294	input_visitor_test_add("/visitor/input/bool",
	295	&in_visitor_data, test_visitor_in_bool);
	296	input_visitor_test_add("/visitor/input/number",
	297	&in_visitor_data, test_visitor_in_number);
	298	input_visitor_test_add("/visitor/input/string",
	299	&in_visitor_data, test_visitor_in_string);
	300	input_visitor_test_add("/visitor/input/enum",
	301	&in_visitor_data, test_visitor_in_enum);
	302	input_visitor_test_add("/visitor/input/struct",
	303	&in_visitor_data, test_visitor_in_struct);
	304	input_visitor_test_add("/visitor/input/struct-nested",
	305	&in_visitor_data, test_visitor_in_struct_nested);
	306	input_visitor_test_add("/visitor/input/list",
	307	&in_visitor_data, test_visitor_in_list);
dc8fb6df PB	308	input_visitor_test_add("/visitor/input/union",
dc8fb6df PB	309	&in_visitor_data, test_visitor_in_union);
3dcf71f6 PB	310	input_visitor_test_add("/visitor/input/errors",
3dcf71f6 PB	311	&in_visitor_data, test_visitor_in_errors);
d88f5fd1 LC	312
	313	g_test_run();
	314
	315	return 0;
	316	}