*
* Authors:
* Luiz Capitulino <lcapitulino@redhat.com>
+ * Paolo Bonzini <pbonzini@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 "qemu-common.h"
#include "qapi/error.h"
+#include "qapi/qapi-visit-introspect.h"
#include "qapi/qobject-input-visitor.h"
-#include "test-qapi-types.h"
#include "test-qapi-visit.h"
-#include "qapi/qmp/types.h"
+#include "qapi/qmp/qbool.h"
+#include "qapi/qmp/qdict.h"
+#include "qapi/qmp/qnull.h"
+#include "qapi/qmp/qnum.h"
+#include "qapi/qmp/qstring.h"
#include "qapi/qmp/qjson.h"
+#include "test-qapi-introspect.h"
+#include "qapi/qapi-introspect.h"
typedef struct TestInputVisitorData {
QObject *obj;
static void visitor_input_teardown(TestInputVisitorData *data,
const void *unused)
{
- qobject_decref(data->obj);
+ qobject_unref(data->obj);
data->obj = NULL;
if (data->qiv) {
function so that the JSON string used by the tests are kept in the test
functions (and not in main()). */
static Visitor *visitor_input_test_init_internal(TestInputVisitorData *data,
+ bool keyval,
const char *json_string,
va_list *ap)
{
visitor_input_teardown(data, NULL);
- data->obj = qobject_from_jsonv(json_string, ap);
+ data->obj = qobject_from_jsonv(json_string, ap, &error_abort);
g_assert(data->obj);
- data->qiv = qobject_input_visitor_new(data->obj, false);
+ if (keyval) {
+ data->qiv = qobject_input_visitor_new_keyval(data->obj);
+ } else {
+ data->qiv = qobject_input_visitor_new(data->obj);
+ }
g_assert(data->qiv);
return data->qiv;
}
+static GCC_FMT_ATTR(3, 4)
+Visitor *visitor_input_test_init_full(TestInputVisitorData *data,
+ bool keyval,
+ const char *json_string, ...)
+{
+ Visitor *v;
+ va_list ap;
+
+ va_start(ap, json_string);
+ v = visitor_input_test_init_internal(data, keyval, json_string, &ap);
+ va_end(ap);
+ return v;
+}
+
static GCC_FMT_ATTR(2, 3)
Visitor *visitor_input_test_init(TestInputVisitorData *data,
const char *json_string, ...)
va_list ap;
va_start(ap, json_string);
- v = visitor_input_test_init_internal(data, json_string, &ap);
+ v = visitor_input_test_init_internal(data, false, json_string, &ap);
va_end(ap);
return v;
}
static Visitor *visitor_input_test_init_raw(TestInputVisitorData *data,
const char *json_string)
{
- return visitor_input_test_init_internal(data, json_string, NULL);
+ return visitor_input_test_init_internal(data, false, json_string, NULL);
}
static void test_visitor_in_int(TestInputVisitorData *data,
const void *unused)
{
int64_t res = 0;
+ double dbl;
int value = -42;
Visitor *v;
visit_type_int(v, NULL, &res, &error_abort);
g_assert_cmpint(res, ==, value);
+
+ visit_type_number(v, NULL, &dbl, &error_abort);
+ g_assert_cmpfloat(dbl, ==, -42.0);
+}
+
+static void test_visitor_in_uint(TestInputVisitorData *data,
+ const void *unused)
+{
+ uint64_t res = 0;
+ int64_t i64;
+ double dbl;
+ int value = 42;
+ Visitor *v;
+
+ v = visitor_input_test_init(data, "%d", value);
+
+ visit_type_uint64(v, NULL, &res, &error_abort);
+ g_assert_cmpuint(res, ==, (uint64_t)value);
+
+ visit_type_int(v, NULL, &i64, &error_abort);
+ g_assert_cmpint(i64, ==, value);
+
+ visit_type_number(v, NULL, &dbl, &error_abort);
+ g_assert_cmpfloat(dbl, ==, value);
+
+ /* BUG: value between INT64_MIN and -1 accepted modulo 2^64 */
+ v = visitor_input_test_init(data, "%d", -value);
+
+ visit_type_uint64(v, NULL, &res, &error_abort);
+ g_assert_cmpuint(res, ==, (uint64_t)-value);
+
+ v = visitor_input_test_init(data, "18446744073709551574");
+
+ visit_type_uint64(v, NULL, &res, &error_abort);
+ g_assert_cmpuint(res, ==, 18446744073709551574U);
+
+ visit_type_number(v, NULL, &dbl, &error_abort);
+ g_assert_cmpfloat(dbl, ==, 18446744073709552000.0);
}
static void test_visitor_in_int_overflow(TestInputVisitorData *data,
Error *err = NULL;
Visitor *v;
- /* this will overflow a Qint/int64, so should be deserialized into
- * a QFloat/double field instead, leading to an error if we pass it
- * to visit_type_int. confirm this.
+ /*
+ * This will overflow a QNUM_I64, so should be deserialized into a
+ * QNUM_DOUBLE field instead, leading to an error if we pass it to
+ * visit_type_int(). Confirm this.
*/
v = visitor_input_test_init(data, "%f", DBL_MAX);
error_free_or_abort(&err);
}
+static void test_visitor_in_int_keyval(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t res = 0, value = -42;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, "%" PRId64, value);
+ visit_type_int(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_int_str_keyval(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t res = 0, value = -42;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, "\"-42\"");
+
+ visit_type_int(v, NULL, &res, &error_abort);
+ g_assert_cmpint(res, ==, value);
+}
+
+static void test_visitor_in_int_str_fail(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t res = 0;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"-42\"");
+
+ visit_type_int(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
static void test_visitor_in_bool(TestInputVisitorData *data,
const void *unused)
{
g_assert_cmpint(res, ==, true);
}
+static void test_visitor_in_bool_keyval(TestInputVisitorData *data,
+ const void *unused)
+{
+ bool res = false;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, "true");
+
+ visit_type_bool(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_bool_str_keyval(TestInputVisitorData *data,
+ const void *unused)
+{
+ bool res = false;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, "\"on\"");
+
+ visit_type_bool(v, NULL, &res, &error_abort);
+ g_assert_cmpint(res, ==, true);
+}
+
+static void test_visitor_in_bool_str_fail(TestInputVisitorData *data,
+ const void *unused)
+{
+ bool res = false;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"true\"");
+
+ visit_type_bool(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
static void test_visitor_in_number(TestInputVisitorData *data,
const void *unused)
{
g_assert_cmpfloat(res, ==, value);
}
+static void test_visitor_in_large_number(TestInputVisitorData *data,
+ const void *unused)
+{
+ Error *err = NULL;
+ double res = 0;
+ int64_t i64;
+ uint64_t u64;
+ Visitor *v;
+
+ v = visitor_input_test_init(data, "-18446744073709551616"); /* -2^64 */
+
+ visit_type_number(v, NULL, &res, &error_abort);
+ g_assert_cmpfloat(res, ==, -18446744073709552e3);
+
+ visit_type_int(v, NULL, &i64, &err);
+ error_free_or_abort(&err);
+
+ visit_type_uint64(v, NULL, &u64, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_number_keyval(TestInputVisitorData *data,
+ const void *unused)
+{
+ double res = 0, value = 3.14;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, "%f", value);
+
+ visit_type_number(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_number_str_keyval(TestInputVisitorData *data,
+ const void *unused)
+{
+ double res = 0, value = 3.14;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init_full(data, true, "\"3.14\"");
+
+ visit_type_number(v, NULL, &res, &error_abort);
+ g_assert_cmpfloat(res, ==, value);
+
+ v = visitor_input_test_init_full(data, true, "\"inf\"");
+
+ visit_type_number(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_number_str_fail(TestInputVisitorData *data,
+ const void *unused)
+{
+ double res = 0;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"3.14\"");
+
+ visit_type_number(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
+static void test_visitor_in_size_str_keyval(TestInputVisitorData *data,
+ const void *unused)
+{
+ uint64_t res, value = 500 * 1024 * 1024;
+ Visitor *v;
+
+ v = visitor_input_test_init_full(data, true, "\"500M\"");
+
+ visit_type_size(v, NULL, &res, &error_abort);
+ g_assert_cmpfloat(res, ==, value);
+}
+
+static void test_visitor_in_size_str_fail(TestInputVisitorData *data,
+ const void *unused)
+{
+ uint64_t res = 0;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "\"500M\"");
+
+ visit_type_size(v, NULL, &res, &err);
+ error_free_or_abort(&err);
+}
+
static void test_visitor_in_string(TestInputVisitorData *data,
const void *unused)
{
Visitor *v;
EnumOne i;
- for (i = 0; EnumOne_lookup[i]; i++) {
+ for (i = 0; i < ENUM_ONE__MAX; i++) {
EnumOne res = -1;
- v = visitor_input_test_init(data, "%s", EnumOne_lookup[i]);
+ v = visitor_input_test_init(data, "%s", EnumOne_str(i));
visit_type_EnumOne(v, NULL, &res, &error_abort);
g_assert_cmpint(i, ==, res);
{
QObject *res = NULL;
Visitor *v;
- QInt *qint;
+ QNum *qnum;
QBool *qbool;
QString *qstring;
QDict *qdict;
QObject *qobj;
+ int64_t val;
v = visitor_input_test_init(data, "-42");
visit_type_any(v, NULL, &res, &error_abort);
- qint = qobject_to_qint(res);
- g_assert(qint);
- g_assert_cmpint(qint_get_int(qint), ==, -42);
- qobject_decref(res);
+ qnum = qobject_to(QNum, res);
+ g_assert(qnum);
+ g_assert(qnum_get_try_int(qnum, &val));
+ g_assert_cmpint(val, ==, -42);
+ qobject_unref(res);
v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
visit_type_any(v, NULL, &res, &error_abort);
- qdict = qobject_to_qdict(res);
+ qdict = qobject_to(QDict, res);
g_assert(qdict && qdict_size(qdict) == 3);
qobj = qdict_get(qdict, "integer");
g_assert(qobj);
- qint = qobject_to_qint(qobj);
- g_assert(qint);
- g_assert_cmpint(qint_get_int(qint), ==, -42);
+ qnum = qobject_to(QNum, qobj);
+ g_assert(qnum);
+ g_assert(qnum_get_try_int(qnum, &val));
+ g_assert_cmpint(val, ==, -42);
qobj = qdict_get(qdict, "boolean");
g_assert(qobj);
- qbool = qobject_to_qbool(qobj);
+ qbool = qobject_to(QBool, qobj);
g_assert(qbool);
g_assert(qbool_get_bool(qbool) == true);
qobj = qdict_get(qdict, "string");
g_assert(qobj);
- qstring = qobject_to_qstring(qobj);
+ qstring = qobject_to(QString, qobj);
g_assert(qstring);
g_assert_cmpstr(qstring_get_str(qstring), ==, "foo");
- qobject_decref(res);
+ qobject_unref(res);
}
static void test_visitor_in_null(TestInputVisitorData *data,
{
Visitor *v;
Error *err = NULL;
+ QNull *null;
char *tmp;
/*
* when input is not null.
*/
- v = visitor_input_test_init(data, "{ 'a': null, 'b': '' }");
+ v = visitor_input_test_init_full(data, false,
+ "{ 'a': null, 'b': '' }");
visit_start_struct(v, NULL, NULL, 0, &error_abort);
- visit_type_null(v, "a", &error_abort);
- visit_type_str(v, "a", &tmp, &err);
- g_assert(!tmp);
+ visit_type_null(v, "a", &null, &error_abort);
+ g_assert(qobject_type(QOBJECT(null)) == QTYPE_QNULL);
+ qobject_unref(null);
+ visit_type_null(v, "b", &null, &err);
error_free_or_abort(&err);
- visit_type_null(v, "b", &err);
+ g_assert(!null);
+ visit_type_str(v, "c", &tmp, &err);
error_free_or_abort(&err);
+ g_assert(!tmp);
visit_check_struct(v, &error_abort);
visit_end_struct(v, NULL);
}
const void *unused)
{
Visitor *v;
- Error *err = NULL;
UserDefAlternate *tmp;
WrapAlternate *wrap;
v = visitor_input_test_init(data, "42");
visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
- g_assert_cmpint(tmp->type, ==, QTYPE_QINT);
+ g_assert_cmpint(tmp->type, ==, QTYPE_QNUM);
g_assert_cmpint(tmp->u.i, ==, 42);
qapi_free_UserDefAlternate(tmp);
- v = visitor_input_test_init(data, "'string'");
+ v = visitor_input_test_init(data, "'value1'");
visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
g_assert_cmpint(tmp->type, ==, QTYPE_QSTRING);
- g_assert_cmpstr(tmp->u.s, ==, "string");
+ g_assert_cmpint(tmp->u.e, ==, ENUM_ONE_VALUE1);
+ qapi_free_UserDefAlternate(tmp);
+
+ v = visitor_input_test_init(data, "null");
+ visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
+ g_assert_cmpint(tmp->type, ==, QTYPE_QNULL);
qapi_free_UserDefAlternate(tmp);
v = visitor_input_test_init(data, "{'integer':1, 'string':'str', "
g_assert_cmpint(tmp->u.udfu.u.value1.has_a_b, ==, false);
qapi_free_UserDefAlternate(tmp);
- v = visitor_input_test_init(data, "false");
- visit_type_UserDefAlternate(v, NULL, &tmp, &err);
- error_free_or_abort(&err);
- qapi_free_UserDefAlternate(tmp);
-
v = visitor_input_test_init(data, "{ 'alt': 42 }");
visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
- g_assert_cmpint(wrap->alt->type, ==, QTYPE_QINT);
+ g_assert_cmpint(wrap->alt->type, ==, QTYPE_QNUM);
g_assert_cmpint(wrap->alt->u.i, ==, 42);
qapi_free_WrapAlternate(wrap);
- v = visitor_input_test_init(data, "{ 'alt': 'string' }");
+ v = visitor_input_test_init(data, "{ 'alt': 'value1' }");
visit_type_WrapAlternate(v, NULL, &wrap, &error_abort);
g_assert_cmpint(wrap->alt->type, ==, QTYPE_QSTRING);
- g_assert_cmpstr(wrap->alt->u.s, ==, "string");
+ g_assert_cmpint(wrap->alt->u.e, ==, ENUM_ONE_VALUE1);
qapi_free_WrapAlternate(wrap);
v = visitor_input_test_init(data, "{ 'alt': {'integer':1, 'string':'str', "
{
Visitor *v;
Error *err = NULL;
- AltStrBool *asb;
- AltStrNum *asn;
- AltNumStr *ans;
- AltStrInt *asi;
- AltIntNum *ain;
- AltNumInt *ani;
+ AltEnumBool *aeb;
+ AltEnumNum *aen;
+ AltNumEnum *ans;
+ AltEnumInt *asi;
/* Parsing an int */
v = visitor_input_test_init(data, "42");
- visit_type_AltStrBool(v, NULL, &asb, &err);
+ visit_type_AltEnumBool(v, NULL, &aeb, &err);
error_free_or_abort(&err);
- qapi_free_AltStrBool(asb);
+ qapi_free_AltEnumBool(aeb);
v = visitor_input_test_init(data, "42");
- visit_type_AltStrNum(v, NULL, &asn, &error_abort);
- g_assert_cmpint(asn->type, ==, QTYPE_QFLOAT);
- g_assert_cmpfloat(asn->u.n, ==, 42);
- qapi_free_AltStrNum(asn);
+ visit_type_AltEnumNum(v, NULL, &aen, &error_abort);
+ g_assert_cmpint(aen->type, ==, QTYPE_QNUM);
+ g_assert_cmpfloat(aen->u.n, ==, 42);
+ qapi_free_AltEnumNum(aen);
v = visitor_input_test_init(data, "42");
- visit_type_AltNumStr(v, NULL, &ans, &error_abort);
- g_assert_cmpint(ans->type, ==, QTYPE_QFLOAT);
+ visit_type_AltNumEnum(v, NULL, &ans, &error_abort);
+ g_assert_cmpint(ans->type, ==, QTYPE_QNUM);
g_assert_cmpfloat(ans->u.n, ==, 42);
- qapi_free_AltNumStr(ans);
+ qapi_free_AltNumEnum(ans);
v = visitor_input_test_init(data, "42");
- visit_type_AltStrInt(v, NULL, &asi, &error_abort);
- g_assert_cmpint(asi->type, ==, QTYPE_QINT);
+ visit_type_AltEnumInt(v, NULL, &asi, &error_abort);
+ g_assert_cmpint(asi->type, ==, QTYPE_QNUM);
g_assert_cmpint(asi->u.i, ==, 42);
- qapi_free_AltStrInt(asi);
-
- v = visitor_input_test_init(data, "42");
- visit_type_AltIntNum(v, NULL, &ain, &error_abort);
- g_assert_cmpint(ain->type, ==, QTYPE_QINT);
- g_assert_cmpint(ain->u.i, ==, 42);
- qapi_free_AltIntNum(ain);
-
- v = visitor_input_test_init(data, "42");
- visit_type_AltNumInt(v, NULL, &ani, &error_abort);
- g_assert_cmpint(ani->type, ==, QTYPE_QINT);
- g_assert_cmpint(ani->u.i, ==, 42);
- qapi_free_AltNumInt(ani);
+ qapi_free_AltEnumInt(asi);
/* Parsing a double */
v = visitor_input_test_init(data, "42.5");
- visit_type_AltStrBool(v, NULL, &asb, &err);
+ visit_type_AltEnumBool(v, NULL, &aeb, &err);
error_free_or_abort(&err);
- qapi_free_AltStrBool(asb);
+ qapi_free_AltEnumBool(aeb);
v = visitor_input_test_init(data, "42.5");
- visit_type_AltStrNum(v, NULL, &asn, &error_abort);
- g_assert_cmpint(asn->type, ==, QTYPE_QFLOAT);
- g_assert_cmpfloat(asn->u.n, ==, 42.5);
- qapi_free_AltStrNum(asn);
+ visit_type_AltEnumNum(v, NULL, &aen, &error_abort);
+ g_assert_cmpint(aen->type, ==, QTYPE_QNUM);
+ g_assert_cmpfloat(aen->u.n, ==, 42.5);
+ qapi_free_AltEnumNum(aen);
v = visitor_input_test_init(data, "42.5");
- visit_type_AltNumStr(v, NULL, &ans, &error_abort);
- g_assert_cmpint(ans->type, ==, QTYPE_QFLOAT);
+ visit_type_AltNumEnum(v, NULL, &ans, &error_abort);
+ g_assert_cmpint(ans->type, ==, QTYPE_QNUM);
g_assert_cmpfloat(ans->u.n, ==, 42.5);
- qapi_free_AltNumStr(ans);
+ qapi_free_AltNumEnum(ans);
v = visitor_input_test_init(data, "42.5");
- visit_type_AltStrInt(v, NULL, &asi, &err);
+ visit_type_AltEnumInt(v, NULL, &asi, &err);
error_free_or_abort(&err);
- qapi_free_AltStrInt(asi);
-
- v = visitor_input_test_init(data, "42.5");
- visit_type_AltIntNum(v, NULL, &ain, &error_abort);
- g_assert_cmpint(ain->type, ==, QTYPE_QFLOAT);
- g_assert_cmpfloat(ain->u.n, ==, 42.5);
- qapi_free_AltIntNum(ain);
-
- v = visitor_input_test_init(data, "42.5");
- visit_type_AltNumInt(v, NULL, &ani, &error_abort);
- g_assert_cmpint(ani->type, ==, QTYPE_QFLOAT);
- g_assert_cmpfloat(ani->u.n, ==, 42.5);
- qapi_free_AltNumInt(ani);
+ qapi_free_AltEnumInt(asi);
}
static void test_native_list_integer_helper(TestInputVisitorData *data,
}
}
g_string_append_printf(gstr_union, "{ 'type': '%s', 'data': [ %s ] }",
- UserDefNativeListUnionKind_lookup[kind],
+ UserDefNativeListUnionKind_str(kind),
gstr_list->str);
v = visitor_input_test_init_raw(data, gstr_union->str);
error_free_or_abort(&err);
}
+static void test_visitor_in_fail_struct(TestInputVisitorData *data,
+ const void *unused)
+{
+ TestStruct *p = NULL;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo', 'extra': 42 }");
+
+ visit_type_TestStruct(v, NULL, &p, &err);
+ error_free_or_abort(&err);
+ g_assert(!p);
+}
+
+static void test_visitor_in_fail_struct_nested(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefTwo *udp = NULL;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string', 'extra': [42, 23, {'foo':'bar'}] }, 'string2': 'string2'}}}");
+
+ visit_type_UserDefTwo(v, NULL, &udp, &err);
+ error_free_or_abort(&err);
+ g_assert(!udp);
+}
+
+static void test_visitor_in_fail_struct_in_list(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefOneList *head = NULL;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44, 'extra': 'ggg' } ]");
+
+ visit_type_UserDefOneList(v, NULL, &head, &err);
+ error_free_or_abort(&err);
+ g_assert(!head);
+}
+
+static void test_visitor_in_fail_struct_missing(TestInputVisitorData *data,
+ const void *unused)
+{
+ Error *err = NULL;
+ Visitor *v;
+ QObject *any;
+ QNull *null;
+ GenericAlternate *alt;
+ bool present;
+ int en;
+ int64_t i64;
+ uint32_t u32;
+ int8_t i8;
+ char *str;
+ double dbl;
+
+ v = visitor_input_test_init(data, "{ 'sub': [ {} ] }");
+ visit_start_struct(v, NULL, NULL, 0, &error_abort);
+ visit_start_struct(v, "struct", NULL, 0, &err);
+ error_free_or_abort(&err);
+ visit_start_list(v, "list", NULL, 0, &err);
+ error_free_or_abort(&err);
+ visit_start_alternate(v, "alternate", &alt, sizeof(*alt), &err);
+ error_free_or_abort(&err);
+ visit_optional(v, "optional", &present);
+ g_assert(!present);
+ visit_type_enum(v, "enum", &en, &EnumOne_lookup, &err);
+ error_free_or_abort(&err);
+ visit_type_int(v, "i64", &i64, &err);
+ error_free_or_abort(&err);
+ visit_type_uint32(v, "u32", &u32, &err);
+ error_free_or_abort(&err);
+ visit_type_int8(v, "i8", &i8, &err);
+ error_free_or_abort(&err);
+ visit_type_str(v, "i8", &str, &err);
+ error_free_or_abort(&err);
+ visit_type_number(v, "dbl", &dbl, &err);
+ error_free_or_abort(&err);
+ visit_type_any(v, "any", &any, &err);
+ error_free_or_abort(&err);
+ visit_type_null(v, "null", &null, &err);
+ error_free_or_abort(&err);
+ visit_start_list(v, "sub", NULL, 0, &error_abort);
+ visit_start_struct(v, NULL, NULL, 0, &error_abort);
+ visit_type_int(v, "i64", &i64, &err);
+ error_free_or_abort(&err);
+ visit_end_struct(v, NULL);
+ visit_end_list(v, NULL);
+ visit_end_struct(v, NULL);
+}
+
+static void test_visitor_in_fail_list(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t i64 = -1;
+ Error *err = NULL;
+ Visitor *v;
+
+ /* Unvisited list tail */
+
+ v = visitor_input_test_init(data, "[ 1, 2, 3 ]");
+
+ visit_start_list(v, NULL, NULL, 0, &error_abort);
+ visit_type_int(v, NULL, &i64, &error_abort);
+ g_assert_cmpint(i64, ==, 1);
+ visit_type_int(v, NULL, &i64, &error_abort);
+ g_assert_cmpint(i64, ==, 2);
+ visit_check_list(v, &err);
+ error_free_or_abort(&err);
+ visit_end_list(v, NULL);
+
+ /* Visit beyond end of list */
+ v = visitor_input_test_init(data, "[]");
+
+ visit_start_list(v, NULL, NULL, 0, &error_abort);
+ visit_type_int(v, NULL, &i64, &err);
+ error_free_or_abort(&err);
+ visit_end_list(v, NULL);
+}
+
+static void test_visitor_in_fail_list_nested(TestInputVisitorData *data,
+ const void *unused)
+{
+ int64_t i64 = -1;
+ Error *err = NULL;
+ Visitor *v;
+
+ /* Unvisited nested list tail */
+
+ v = visitor_input_test_init(data, "[ 0, [ 1, 2, 3 ] ]");
+
+ visit_start_list(v, NULL, NULL, 0, &error_abort);
+ visit_type_int(v, NULL, &i64, &error_abort);
+ g_assert_cmpint(i64, ==, 0);
+ visit_start_list(v, NULL, NULL, 0, &error_abort);
+ visit_type_int(v, NULL, &i64, &error_abort);
+ g_assert_cmpint(i64, ==, 1);
+ visit_check_list(v, &err);
+ error_free_or_abort(&err);
+ visit_end_list(v, NULL);
+ visit_check_list(v, &error_abort);
+ visit_end_list(v, NULL);
+}
+
+static void test_visitor_in_fail_union_native_list(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefNativeListUnion *tmp = NULL;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init(data,
+ "{ 'type': 'integer', 'data' : [ 'string' ] }");
+
+ visit_type_UserDefNativeListUnion(v, NULL, &tmp, &err);
+ error_free_or_abort(&err);
+ g_assert(!tmp);
+}
+
+static void test_visitor_in_fail_union_flat(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefFlatUnion *tmp = NULL;
+ Error *err = NULL;
+ Visitor *v;
+
+ v = visitor_input_test_init(data, "{ 'string': 'c', 'integer': 41, 'boolean': true }");
+
+ visit_type_UserDefFlatUnion(v, NULL, &tmp, &err);
+ error_free_or_abort(&err);
+ g_assert(!tmp);
+}
+
+static void test_visitor_in_fail_union_flat_no_discrim(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefFlatUnion2 *tmp = NULL;
+ Error *err = NULL;
+ Visitor *v;
+
+ /* test situation where discriminator field ('enum1' here) is missing */
+ v = visitor_input_test_init(data, "{ 'integer': 42, 'string': 'c', 'string1': 'd', 'string2': 'e' }");
+
+ visit_type_UserDefFlatUnion2(v, NULL, &tmp, &err);
+ error_free_or_abort(&err);
+ g_assert(!tmp);
+}
+
+static void test_visitor_in_fail_alternate(TestInputVisitorData *data,
+ const void *unused)
+{
+ UserDefAlternate *tmp;
+ Visitor *v;
+ Error *err = NULL;
+
+ v = visitor_input_test_init(data, "3.14");
+
+ visit_type_UserDefAlternate(v, NULL, &tmp, &err);
+ error_free_or_abort(&err);
+ g_assert(!tmp);
+}
+
+static void do_test_visitor_in_qmp_introspect(TestInputVisitorData *data,
+ const QLitObject *qlit)
+{
+ SchemaInfoList *schema = NULL;
+ QObject *obj = qobject_from_qlit(qlit);
+ Visitor *v;
+
+ v = qobject_input_visitor_new(obj);
+
+ visit_type_SchemaInfoList(v, NULL, &schema, &error_abort);
+ g_assert(schema);
+
+ qapi_free_SchemaInfoList(schema);
+ qobject_unref(obj);
+ visit_free(v);
+}
+
+static void test_visitor_in_qmp_introspect(TestInputVisitorData *data,
+ const void *unused)
+{
+ do_test_visitor_in_qmp_introspect(data, &test_qmp_schema_qlit);
+ do_test_visitor_in_qmp_introspect(data, &qmp_schema_qlit);
+}
+
int main(int argc, char **argv)
{
g_test_init(&argc, &argv, NULL);
input_visitor_test_add("/visitor/input/int",
NULL, test_visitor_in_int);
+ input_visitor_test_add("/visitor/input/uint",
+ NULL, test_visitor_in_uint);
input_visitor_test_add("/visitor/input/int_overflow",
NULL, test_visitor_in_int_overflow);
+ input_visitor_test_add("/visitor/input/int_keyval",
+ NULL, test_visitor_in_int_keyval);
+ input_visitor_test_add("/visitor/input/int_str_keyval",
+ NULL, test_visitor_in_int_str_keyval);
+ input_visitor_test_add("/visitor/input/int_str_fail",
+ NULL, test_visitor_in_int_str_fail);
input_visitor_test_add("/visitor/input/bool",
NULL, test_visitor_in_bool);
+ input_visitor_test_add("/visitor/input/bool_keyval",
+ NULL, test_visitor_in_bool_keyval);
+ input_visitor_test_add("/visitor/input/bool_str_keyval",
+ NULL, test_visitor_in_bool_str_keyval);
+ input_visitor_test_add("/visitor/input/bool_str_fail",
+ NULL, test_visitor_in_bool_str_fail);
input_visitor_test_add("/visitor/input/number",
NULL, test_visitor_in_number);
+ input_visitor_test_add("/visitor/input/large_number",
+ NULL, test_visitor_in_large_number);
+ input_visitor_test_add("/visitor/input/number_keyval",
+ NULL, test_visitor_in_number_keyval);
+ input_visitor_test_add("/visitor/input/number_str_keyval",
+ NULL, test_visitor_in_number_str_keyval);
+ input_visitor_test_add("/visitor/input/number_str_fail",
+ NULL, test_visitor_in_number_str_fail);
+ input_visitor_test_add("/visitor/input/size_str_keyval",
+ NULL, test_visitor_in_size_str_keyval);
+ input_visitor_test_add("/visitor/input/size_str_fail",
+ NULL, test_visitor_in_size_str_fail);
input_visitor_test_add("/visitor/input/string",
NULL, test_visitor_in_string);
input_visitor_test_add("/visitor/input/enum",
NULL, test_visitor_in_native_list_string);
input_visitor_test_add("/visitor/input/native_list/number",
NULL, test_visitor_in_native_list_number);
+ input_visitor_test_add("/visitor/input/fail/struct",
+ NULL, test_visitor_in_fail_struct);
+ input_visitor_test_add("/visitor/input/fail/struct-nested",
+ NULL, test_visitor_in_fail_struct_nested);
+ input_visitor_test_add("/visitor/input/fail/struct-in-list",
+ NULL, test_visitor_in_fail_struct_in_list);
+ input_visitor_test_add("/visitor/input/fail/struct-missing",
+ NULL, test_visitor_in_fail_struct_missing);
+ input_visitor_test_add("/visitor/input/fail/list",
+ NULL, test_visitor_in_fail_list);
+ input_visitor_test_add("/visitor/input/fail/list-nested",
+ NULL, test_visitor_in_fail_list_nested);
+ input_visitor_test_add("/visitor/input/fail/union-flat",
+ NULL, test_visitor_in_fail_union_flat);
+ input_visitor_test_add("/visitor/input/fail/union-flat-no-discriminator",
+ NULL, test_visitor_in_fail_union_flat_no_discrim);
+ input_visitor_test_add("/visitor/input/fail/alternate",
+ NULL, test_visitor_in_fail_alternate);
+ input_visitor_test_add("/visitor/input/fail/union-native-list",
+ NULL, test_visitor_in_fail_union_native_list);
+ input_visitor_test_add("/visitor/input/qapi-introspect",
+ NULL, test_visitor_in_qmp_introspect);
g_test_run();
projects / mirror_qemu.git / blobdiff