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