2012-03-22 12:51:10 +01:00
|
|
|
/*
|
|
|
|
* QMP Input Visitor unit-tests (strict mode).
|
|
|
|
*
|
|
|
|
* Copyright (C) 2011-2012 Red Hat Inc.
|
|
|
|
*
|
|
|
|
* 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 <glib.h>
|
|
|
|
#include <stdarg.h>
|
|
|
|
|
2012-12-06 11:22:34 +01:00
|
|
|
#include "qemu-common.h"
|
2012-03-22 12:51:10 +01:00
|
|
|
#include "qapi/qmp-input-visitor.h"
|
|
|
|
#include "test-qapi-types.h"
|
|
|
|
#include "test-qapi-visit.h"
|
2012-12-17 18:19:43 +01:00
|
|
|
#include "qapi/qmp/types.h"
|
2012-03-22 12:51:10 +01:00
|
|
|
|
|
|
|
typedef struct TestInputVisitorData {
|
|
|
|
QObject *obj;
|
|
|
|
QmpInputVisitor *qiv;
|
|
|
|
} TestInputVisitorData;
|
|
|
|
|
|
|
|
static void validate_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 *validate_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_strict(data->obj);
|
|
|
|
g_assert(data->qiv != NULL);
|
|
|
|
|
|
|
|
v = qmp_input_get_visitor(data->qiv);
|
|
|
|
g_assert(v != NULL);
|
|
|
|
|
|
|
|
return v;
|
|
|
|
}
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
2014-05-07 09:53:53 +02:00
|
|
|
Error *err = NULL;
|
|
|
|
|
2012-03-22 12:51:10 +01:00
|
|
|
visit_start_struct(v, (void **)obj, "TestStruct", name, sizeof(TestStruct),
|
2014-05-07 09:53:53 +02:00
|
|
|
&err);
|
|
|
|
if (err) {
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
visit_type_int(v, &(*obj)->integer, "integer", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
2014-05-07 09:53:53 +02:00
|
|
|
visit_type_bool(v, &(*obj)->boolean, "boolean", &err);
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
if (err) {
|
|
|
|
goto out_end;
|
|
|
|
}
|
2014-05-07 09:53:53 +02:00
|
|
|
visit_type_str(v, &(*obj)->string, "string", &err);
|
2012-03-22 12:51:10 +01:00
|
|
|
|
qapi: Replace uncommon use of the error API by the common one
We commonly use the error API like this:
err = NULL;
foo(..., &err);
if (err) {
goto out;
}
bar(..., &err);
Every error source is checked separately. The second function is only
called when the first one succeeds. Both functions are free to pass
their argument to error_set(). Because error_set() asserts no error
has been set, this effectively means they must not be called with an
error set.
The qapi-generated code uses the error API differently:
// *errp was initialized to NULL somewhere up the call chain
frob(..., errp);
gnat(..., errp);
Errors accumulate in *errp: first error wins, subsequent errors get
dropped. To make this work, the second function does nothing when
called with an error set. Requires non-null errp, or else the second
function can't see the first one fail.
This usage has also bled into visitor tests, and two device model
object property getters rtc_get_date() and balloon_stats_get_all().
With the "accumulate" technique, you need fewer error checks in
callers, and buy that with an error check in every callee. Can be
nice.
However, mixing the two techniques is confusing. You can't use the
"accumulate" technique with functions designed for the "check
separately" technique. You can use the "check separately" technique
with functions designed for the "accumulate" technique, but then
error_set() can't catch you setting an error more than once.
Standardize on the "check separately" technique for now, because it's
overwhelmingly prevalent.
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Luiz Capitulino <lcapitulino@redhat.com>
2014-05-07 09:53:54 +02:00
|
|
|
out_end:
|
|
|
|
error_propagate(errp, err);
|
|
|
|
err = NULL;
|
2014-05-07 09:53:53 +02:00
|
|
|
visit_end_struct(v, &err);
|
|
|
|
out:
|
|
|
|
error_propagate(errp, err);
|
2012-03-22 12:51:10 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_validate_struct(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
TestStruct *p = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = validate_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo' }");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_TestStruct(v, &p, NULL, &err);
|
|
|
|
g_assert(!err);
|
2012-03-22 12:51:10 +01:00
|
|
|
g_free(p->string);
|
|
|
|
g_free(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_validate_struct_nested(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefNested *udp = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = validate_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string' }, 'string2': 'string2'}}}");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefNested(v, &udp, NULL, &err);
|
|
|
|
g_assert(!err);
|
2012-03-22 12:51:10 +01:00
|
|
|
qapi_free_UserDefNested(udp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_validate_list(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefOneList *head = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = validate_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefOneList(v, &head, NULL, &err);
|
|
|
|
g_assert(!err);
|
2012-03-22 12:51:10 +01:00
|
|
|
qapi_free_UserDefOneList(head);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_validate_union(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefUnion *tmp = NULL;
|
|
|
|
Visitor *v;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
|
2014-03-01 08:40:32 +01:00
|
|
|
v = validate_test_init(data, "{ 'type': 'b', 'integer': 41, 'data' : { 'integer': 42 } }");
|
2012-03-22 12:51:10 +01:00
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefUnion(v, &tmp, NULL, &err);
|
|
|
|
g_assert(!err);
|
2012-03-22 12:51:10 +01:00
|
|
|
qapi_free_UserDefUnion(tmp);
|
|
|
|
}
|
|
|
|
|
2014-03-01 08:40:33 +01:00
|
|
|
static void test_validate_union_flat(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefFlatUnion *tmp = NULL;
|
|
|
|
Visitor *v;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2014-03-01 08:40:33 +01:00
|
|
|
|
2014-03-05 03:44:39 +01:00
|
|
|
v = validate_test_init(data,
|
|
|
|
"{ 'enum1': 'value1', "
|
|
|
|
"'string': 'str', "
|
|
|
|
"'boolean': true }");
|
2014-03-01 08:40:33 +01:00
|
|
|
/* TODO when generator bug is fixed, add 'integer': 41 */
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefFlatUnion(v, &tmp, NULL, &err);
|
|
|
|
g_assert(!err);
|
2014-03-01 08:40:33 +01:00
|
|
|
qapi_free_UserDefFlatUnion(tmp);
|
|
|
|
}
|
|
|
|
|
2014-03-01 08:40:30 +01:00
|
|
|
static void test_validate_union_anon(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefAnonUnion *tmp = NULL;
|
|
|
|
Visitor *v;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2014-03-01 08:40:30 +01:00
|
|
|
|
|
|
|
v = validate_test_init(data, "42");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefAnonUnion(v, &tmp, NULL, &err);
|
|
|
|
g_assert(!err);
|
2014-03-01 08:40:30 +01:00
|
|
|
qapi_free_UserDefAnonUnion(tmp);
|
|
|
|
}
|
|
|
|
|
2012-03-22 12:51:10 +01:00
|
|
|
static void test_validate_fail_struct(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
TestStruct *p = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = validate_test_init(data, "{ 'integer': -42, 'boolean': true, 'string': 'foo', 'extra': 42 }");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_TestStruct(v, &p, NULL, &err);
|
|
|
|
g_assert(err);
|
2012-03-22 12:51:10 +01:00
|
|
|
if (p) {
|
|
|
|
g_free(p->string);
|
|
|
|
}
|
|
|
|
g_free(p);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_validate_fail_struct_nested(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefNested *udp = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = validate_test_init(data, "{ 'string0': 'string0', 'dict1': { 'string1': 'string1', 'dict2': { 'userdef1': { 'integer': 42, 'string': 'string', 'extra': [42, 23, {'foo':'bar'}] }, 'string2': 'string2'}}}");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefNested(v, &udp, NULL, &err);
|
|
|
|
g_assert(err);
|
2012-03-22 12:51:10 +01:00
|
|
|
qapi_free_UserDefNested(udp);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_validate_fail_list(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefOneList *head = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = validate_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44, 'extra': 'ggg' } ]");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefOneList(v, &head, NULL, &err);
|
|
|
|
g_assert(err);
|
2012-03-22 12:51:10 +01:00
|
|
|
qapi_free_UserDefOneList(head);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_validate_fail_union(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefUnion *tmp = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2012-03-22 12:51:10 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
2014-03-01 08:40:32 +01:00
|
|
|
v = validate_test_init(data, "{ 'type': 'b', 'data' : { 'integer': 42 } }");
|
2012-03-22 12:51:10 +01:00
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefUnion(v, &tmp, NULL, &err);
|
|
|
|
g_assert(err);
|
2012-03-22 12:51:10 +01:00
|
|
|
qapi_free_UserDefUnion(tmp);
|
|
|
|
}
|
|
|
|
|
2014-03-01 08:40:33 +01:00
|
|
|
static void test_validate_fail_union_flat(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefFlatUnion *tmp = NULL;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2014-03-01 08:40:33 +01:00
|
|
|
Visitor *v;
|
|
|
|
|
|
|
|
v = validate_test_init(data, "{ 'string': 'c', 'integer': 41, 'boolean': true }");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefFlatUnion(v, &tmp, NULL, &err);
|
|
|
|
g_assert(err);
|
2014-03-01 08:40:33 +01:00
|
|
|
qapi_free_UserDefFlatUnion(tmp);
|
|
|
|
}
|
|
|
|
|
2014-09-18 22:36:42 +02:00
|
|
|
static void test_validate_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 = validate_test_init(data, "{ 'string': 'c', 'string1': 'd', 'string2': 'e' }");
|
|
|
|
|
|
|
|
visit_type_UserDefFlatUnion2(v, &tmp, NULL, &err);
|
|
|
|
g_assert(err);
|
|
|
|
qapi_free_UserDefFlatUnion2(tmp);
|
|
|
|
}
|
|
|
|
|
2014-03-01 08:40:30 +01:00
|
|
|
static void test_validate_fail_union_anon(TestInputVisitorData *data,
|
|
|
|
const void *unused)
|
|
|
|
{
|
|
|
|
UserDefAnonUnion *tmp = NULL;
|
|
|
|
Visitor *v;
|
2014-05-02 13:26:29 +02:00
|
|
|
Error *err = NULL;
|
2014-03-01 08:40:30 +01:00
|
|
|
|
|
|
|
v = validate_test_init(data, "3.14");
|
|
|
|
|
2014-05-02 13:26:29 +02:00
|
|
|
visit_type_UserDefAnonUnion(v, &tmp, NULL, &err);
|
|
|
|
g_assert(err);
|
2014-03-01 08:40:30 +01:00
|
|
|
qapi_free_UserDefAnonUnion(tmp);
|
|
|
|
}
|
|
|
|
|
2012-03-22 12:51:10 +01:00
|
|
|
static void validate_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,
|
|
|
|
validate_teardown);
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
TestInputVisitorData testdata;
|
|
|
|
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
|
|
|
|
|
|
|
validate_test_add("/visitor/input-strict/pass/struct",
|
|
|
|
&testdata, test_validate_struct);
|
|
|
|
validate_test_add("/visitor/input-strict/pass/struct-nested",
|
|
|
|
&testdata, test_validate_struct_nested);
|
|
|
|
validate_test_add("/visitor/input-strict/pass/list",
|
|
|
|
&testdata, test_validate_list);
|
|
|
|
validate_test_add("/visitor/input-strict/pass/union",
|
|
|
|
&testdata, test_validate_union);
|
2014-03-01 08:40:33 +01:00
|
|
|
validate_test_add("/visitor/input-strict/pass/union-flat",
|
|
|
|
&testdata, test_validate_union_flat);
|
2014-03-01 08:40:30 +01:00
|
|
|
validate_test_add("/visitor/input-strict/pass/union-anon",
|
|
|
|
&testdata, test_validate_union_anon);
|
2012-03-22 12:51:10 +01:00
|
|
|
validate_test_add("/visitor/input-strict/fail/struct",
|
|
|
|
&testdata, test_validate_fail_struct);
|
|
|
|
validate_test_add("/visitor/input-strict/fail/struct-nested",
|
|
|
|
&testdata, test_validate_fail_struct_nested);
|
|
|
|
validate_test_add("/visitor/input-strict/fail/list",
|
|
|
|
&testdata, test_validate_fail_list);
|
|
|
|
validate_test_add("/visitor/input-strict/fail/union",
|
|
|
|
&testdata, test_validate_fail_union);
|
2014-03-01 08:40:33 +01:00
|
|
|
validate_test_add("/visitor/input-strict/fail/union-flat",
|
|
|
|
&testdata, test_validate_fail_union_flat);
|
2014-09-18 22:36:42 +02:00
|
|
|
validate_test_add("/visitor/input-strict/fail/union-flat-no-discriminator",
|
|
|
|
&testdata, test_validate_fail_union_flat_no_discrim);
|
2014-03-01 08:40:30 +01:00
|
|
|
validate_test_add("/visitor/input-strict/fail/union-anon",
|
|
|
|
&testdata, test_validate_fail_union_anon);
|
2012-03-22 12:51:10 +01:00
|
|
|
|
|
|
|
g_test_run();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|