2016-02-08 19:08:51 +01:00
|
|
|
#include "qemu/osdep.h"
|
2015-10-02 14:58:18 +02:00
|
|
|
#include <locale.h>
|
|
|
|
#include <glib/gstdio.h>
|
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/un.h>
|
|
|
|
|
2022-03-30 11:39:05 +02:00
|
|
|
#include "../qtest/libqtest.h"
|
2018-02-01 12:18:39 +01:00
|
|
|
#include "qapi/qmp/qdict.h"
|
2018-02-01 12:18:38 +01:00
|
|
|
#include "qapi/qmp/qlist.h"
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
char *test_dir;
|
|
|
|
GMainLoop *loop;
|
|
|
|
int fd;
|
|
|
|
GPid pid;
|
|
|
|
} TestFixture;
|
|
|
|
|
|
|
|
static int connect_qga(char *path)
|
|
|
|
{
|
|
|
|
int s, ret, len, i = 0;
|
|
|
|
struct sockaddr_un remote;
|
|
|
|
|
|
|
|
s = socket(AF_UNIX, SOCK_STREAM, 0);
|
|
|
|
g_assert(s != -1);
|
|
|
|
|
|
|
|
remote.sun_family = AF_UNIX;
|
|
|
|
do {
|
|
|
|
strcpy(remote.sun_path, path);
|
|
|
|
len = strlen(remote.sun_path) + sizeof(remote.sun_family);
|
|
|
|
ret = connect(s, (struct sockaddr *)&remote, len);
|
|
|
|
if (ret == -1) {
|
|
|
|
g_usleep(G_USEC_PER_SEC);
|
|
|
|
}
|
|
|
|
if (i++ == 10) {
|
2022-09-05 13:01:27 +02:00
|
|
|
close(s);
|
2015-10-02 14:58:18 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
} while (ret == -1);
|
|
|
|
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void qga_watch(GPid pid, gint status, gpointer user_data)
|
|
|
|
{
|
|
|
|
TestFixture *fixture = user_data;
|
|
|
|
|
|
|
|
g_assert_cmpint(status, ==, 0);
|
|
|
|
g_main_loop_quit(fixture->loop);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2017-07-14 16:28:57 +02:00
|
|
|
fixture_setup(TestFixture *fixture, gconstpointer data, gchar **envp)
|
2015-10-02 14:58:18 +02:00
|
|
|
{
|
|
|
|
const gchar *extra_arg = data;
|
|
|
|
GError *error = NULL;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autofree char *cwd = NULL;
|
|
|
|
g_autofree char *path = NULL;
|
|
|
|
g_autofree char *cmd = NULL;
|
|
|
|
g_auto(GStrv) argv = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
fixture->loop = g_main_loop_new(NULL, FALSE);
|
|
|
|
|
2022-09-25 13:30:01 +02:00
|
|
|
fixture->test_dir = g_strdup_printf("%s/qgatest.XXXXXX", g_get_tmp_dir());
|
2022-08-24 11:39:40 +02:00
|
|
|
g_assert_nonnull(g_mkdtemp(fixture->test_dir));
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
path = g_build_filename(fixture->test_dir, "sock", NULL);
|
|
|
|
cwd = g_get_current_dir();
|
2019-07-18 13:19:02 +02:00
|
|
|
cmd = g_strdup_printf("%s%cqga%cqemu-ga -m unix-listen -t %s -p %s %s %s",
|
|
|
|
cwd, G_DIR_SEPARATOR, G_DIR_SEPARATOR,
|
2015-10-02 14:58:18 +02:00
|
|
|
fixture->test_dir, path,
|
|
|
|
getenv("QTEST_LOG") ? "-v" : "",
|
|
|
|
extra_arg ?: "");
|
|
|
|
g_shell_parse_argv(cmd, NULL, &argv, &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
|
2017-07-14 16:28:57 +02:00
|
|
|
g_spawn_async(fixture->test_dir, argv, envp,
|
2015-10-02 14:58:18 +02:00
|
|
|
G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
|
|
|
|
NULL, NULL, &fixture->pid, &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
|
|
|
|
g_child_watch_add(fixture->pid, qga_watch, fixture);
|
|
|
|
|
|
|
|
fixture->fd = connect_qga(path);
|
|
|
|
g_assert_cmpint(fixture->fd, !=, -1);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
fixture_tear_down(TestFixture *fixture, gconstpointer data)
|
|
|
|
{
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autofree char *tmp = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
kill(fixture->pid, SIGTERM);
|
|
|
|
|
|
|
|
g_main_loop_run(fixture->loop);
|
|
|
|
g_main_loop_unref(fixture->loop);
|
|
|
|
|
|
|
|
g_spawn_close_pid(fixture->pid);
|
|
|
|
|
|
|
|
tmp = g_build_filename(fixture->test_dir, "foo", NULL);
|
|
|
|
g_unlink(tmp);
|
|
|
|
g_free(tmp);
|
|
|
|
|
|
|
|
tmp = g_build_filename(fixture->test_dir, "qga.state", NULL);
|
|
|
|
g_unlink(tmp);
|
|
|
|
g_free(tmp);
|
|
|
|
|
|
|
|
tmp = g_build_filename(fixture->test_dir, "sock", NULL);
|
|
|
|
g_unlink(tmp);
|
|
|
|
|
|
|
|
g_rmdir(fixture->test_dir);
|
|
|
|
g_free(fixture->test_dir);
|
2020-11-25 11:24:03 +01:00
|
|
|
close(fixture->fd);
|
2015-10-02 14:58:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void qmp_assertion_message_error(const char *domain,
|
|
|
|
const char *file,
|
|
|
|
int line,
|
|
|
|
const char *func,
|
|
|
|
const char *expr,
|
|
|
|
QDict *dict)
|
|
|
|
{
|
|
|
|
const char *class, *desc;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autofree char *s = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
QDict *error;
|
|
|
|
|
|
|
|
error = qdict_get_qdict(dict, "error");
|
|
|
|
class = qdict_get_try_str(error, "class");
|
|
|
|
desc = qdict_get_try_str(error, "desc");
|
|
|
|
|
|
|
|
s = g_strdup_printf("assertion failed %s: %s %s", expr, class, desc);
|
|
|
|
g_assertion_message(domain, file, line, func, s);
|
|
|
|
}
|
|
|
|
|
|
|
|
#define qmp_assert_no_error(err) do { \
|
|
|
|
if (qdict_haskey(err, "error")) { \
|
|
|
|
qmp_assertion_message_error(G_LOG_DOMAIN, __FILE__, __LINE__, \
|
|
|
|
G_STRFUNC, #err, err); \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
static void test_qga_sync_delimited(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2019-12-12 02:17:58 +01:00
|
|
|
guint32 v, r = g_test_rand_int();
|
2015-10-02 14:58:18 +02:00
|
|
|
unsigned char c;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
|
2018-08-23 18:39:34 +02:00
|
|
|
qmp_fd_send_raw(fixture->fd, "\xff");
|
2018-08-06 08:53:33 +02:00
|
|
|
qmp_fd_send(fixture->fd,
|
2018-08-23 18:39:34 +02:00
|
|
|
"{'execute': 'guest-sync-delimited',"
|
2018-08-06 08:53:33 +02:00
|
|
|
" 'arguments': {'id': %u } }",
|
|
|
|
r);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
test-qga: Actually test 0xff sync bytes
Commit 62c39b3 introduced test-qga, and at face value, appears
to be testing the 'guest-sync' behavior that is recommended for
guests in sending 0xff to QGA to force the parser to reset. But
this aspect of the test has never actually done anything: the
qmp_fd() call chain converts its string argument into QObject,
then converts that QObject back to the actual string that is
sent over the wire - and the conversion process silently drops
the 0xff byte from the string sent to QGA, thus never resetting
the QGA parser.
An upcoming patch will get rid of the wasteful round trip
through QObject, at which point the string in test-qga will be
directly sent over the wire.
But fixing qmp_fd() to actually send 0xff over the wire is not
all we have to do - the actual QMP parser loudly complains that
0xff is not valid JSON, and sends an error message _prior_ to
actually parsing the 'guest-sync' or 'guest-sync-delimited'
command. With 'guest-sync', we cannot easily tell if this error
message is a result of our command - which is WHY we invented
the 'guest-sync-delimited' command. So for the testsuite, fix
things to only check 0xff behavior on 'guest-sync-delimited',
and to loop until we've consumed all garbage prior to the
requested delimiter, which is compatible with the documented actions
that a real QGA client is supposed to do.
Ideally, we'd fix the QGA JSON parser to silently ignore 0xff
rather than sending an error message back, at which point we
could enhance this test for 'guest-sync' as well as for
'guest-sync-delimited'. But for the sake of this patch, our
testing of 'guest-sync' is no worse than it was pre-patch,
because we have never been sending 0xff over the wire in the
first place.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20170427215821.19397-11-eblake@redhat.com>
Reviewed-by: Michael Roth <mdroth@linux.vnet.ibm.com>
[Additional comment squashed in, along with matching commit message
update]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2017-04-27 23:58:21 +02:00
|
|
|
/*
|
|
|
|
* Read and ignore garbage until resynchronized.
|
|
|
|
*
|
|
|
|
* Note that the full reset sequence would involve checking the
|
|
|
|
* response of guest-sync-delimited and repeating the loop if
|
|
|
|
* 'id' field of the response does not match the 'id' field of
|
|
|
|
* the request. Testing this fully would require inserting
|
|
|
|
* garbage in the response stream and is left as a future test
|
|
|
|
* to implement.
|
|
|
|
*
|
|
|
|
* TODO: The server shouldn't emit so much garbage (among other
|
|
|
|
* things, it loudly complains about the client's \xff being
|
|
|
|
* invalid JSON, even though it is a documented part of the
|
|
|
|
* handshake.
|
|
|
|
*/
|
|
|
|
do {
|
|
|
|
v = read(fixture->fd, &c, 1);
|
|
|
|
g_assert_cmpint(v, ==, 1);
|
|
|
|
} while (c != 0xff);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
ret = qmp_fd_receive(fixture->fd);
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
v = qdict_get_int(ret, "return");
|
|
|
|
g_assert_cmpint(r, ==, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_sync(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2019-12-12 02:17:58 +01:00
|
|
|
guint32 v, r = g_test_rand_int();
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
|
test-qga: Actually test 0xff sync bytes
Commit 62c39b3 introduced test-qga, and at face value, appears
to be testing the 'guest-sync' behavior that is recommended for
guests in sending 0xff to QGA to force the parser to reset. But
this aspect of the test has never actually done anything: the
qmp_fd() call chain converts its string argument into QObject,
then converts that QObject back to the actual string that is
sent over the wire - and the conversion process silently drops
the 0xff byte from the string sent to QGA, thus never resetting
the QGA parser.
An upcoming patch will get rid of the wasteful round trip
through QObject, at which point the string in test-qga will be
directly sent over the wire.
But fixing qmp_fd() to actually send 0xff over the wire is not
all we have to do - the actual QMP parser loudly complains that
0xff is not valid JSON, and sends an error message _prior_ to
actually parsing the 'guest-sync' or 'guest-sync-delimited'
command. With 'guest-sync', we cannot easily tell if this error
message is a result of our command - which is WHY we invented
the 'guest-sync-delimited' command. So for the testsuite, fix
things to only check 0xff behavior on 'guest-sync-delimited',
and to loop until we've consumed all garbage prior to the
requested delimiter, which is compatible with the documented actions
that a real QGA client is supposed to do.
Ideally, we'd fix the QGA JSON parser to silently ignore 0xff
rather than sending an error message back, at which point we
could enhance this test for 'guest-sync' as well as for
'guest-sync-delimited'. But for the sake of this patch, our
testing of 'guest-sync' is no worse than it was pre-patch,
because we have never been sending 0xff over the wire in the
first place.
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Markus Armbruster <armbru@redhat.com>
Message-Id: <20170427215821.19397-11-eblake@redhat.com>
Reviewed-by: Michael Roth <mdroth@linux.vnet.ibm.com>
[Additional comment squashed in, along with matching commit message
update]
Signed-off-by: Markus Armbruster <armbru@redhat.com>
2017-04-27 23:58:21 +02:00
|
|
|
/*
|
|
|
|
* TODO guest-sync is inherently limited: we cannot distinguish
|
|
|
|
* failure caused by reacting to garbage on the wire prior to this
|
|
|
|
* command, from failure of this actual command. Clients are
|
|
|
|
* supposed to be able to send a raw '\xff' byte to at least
|
|
|
|
* re-synchronize the server's parser prior to this command, but
|
|
|
|
* we are not in a position to test that here because (at least
|
|
|
|
* for now) it causes the server to issue an error message about
|
|
|
|
* invalid JSON. Testing of '\xff' handling is done in
|
|
|
|
* guest-sync-delimited instead.
|
|
|
|
*/
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-sync', 'arguments': {'id': %u } }",
|
|
|
|
r);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
v = qdict_get_int(ret, "return");
|
|
|
|
g_assert_cmpint(r, ==, v);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_ping(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
}
|
|
|
|
|
2019-02-20 16:42:53 +01:00
|
|
|
static void test_qga_id(gconstpointer fix)
|
2018-07-03 10:53:34 +02:00
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2018-07-03 10:53:34 +02:00
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping', 'id': 1}");
|
|
|
|
g_assert_nonnull(ret);
|
2019-02-20 16:42:53 +01:00
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
g_assert_cmpint(qdict_get_int(ret, "id"), ==, 1);
|
2018-07-03 10:53:34 +02:00
|
|
|
}
|
|
|
|
|
2018-07-03 10:53:36 +02:00
|
|
|
static void test_qga_invalid_oob(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2018-08-30 17:58:07 +02:00
|
|
|
QDict *ret;
|
2018-07-03 10:53:36 +02:00
|
|
|
|
qmp: Redo how the client requests out-of-band execution
Commit cf869d53172 "qmp: support out-of-band (oob) execution" added a
general mechanism for command-independent arguments just for an
out-of-band flag:
The "control" key is introduced to store this extra flag. "control"
field is used to store arguments that are shared by all the commands,
rather than command specific arguments. Let "run-oob" be the first.
However, it failed to reject unknown members of "control". For
instance, in QMP command
{"execute": "query-name", "id": 42, "control": {"crap": true}}
"crap" gets silently ignored.
Instead of fixing this, revert the general "control" mechanism
(because YAGNI), and do it the way I initially proposed, with key
"exec-oob". Simpler code, simpler interface.
An out-of-band command
{"execute": "migrate-pause", "id": 42, "control": {"run-oob": true}}
becomes
{"exec-oob": "migrate-pause", "id": 42}
Signed-off-by: Markus Armbruster <armbru@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Message-Id: <20180703085358.13941-13-armbru@redhat.com>
[Commit message typo fixed]
2018-07-03 10:53:38 +02:00
|
|
|
ret = qmp_fd(fixture->fd, "{'exec-oob': 'guest-ping'}");
|
2018-07-03 10:53:36 +02:00
|
|
|
g_assert_nonnull(ret);
|
|
|
|
|
2020-09-02 13:57:33 +02:00
|
|
|
qmp_expect_error_and_unref(ret, "GenericError");
|
2018-07-03 10:53:36 +02:00
|
|
|
}
|
|
|
|
|
2016-09-12 11:19:09 +02:00
|
|
|
static void test_qga_invalid_args(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *error;
|
2016-09-12 11:19:09 +02:00
|
|
|
const gchar *class, *desc;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping', "
|
|
|
|
"'arguments': {'foo': 42 }}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
|
|
|
|
error = qdict_get_qdict(ret, "error");
|
|
|
|
class = qdict_get_try_str(error, "class");
|
|
|
|
desc = qdict_get_try_str(error, "desc");
|
|
|
|
|
|
|
|
g_assert_cmpstr(class, ==, "GenericError");
|
2017-03-03 13:32:31 +01:00
|
|
|
g_assert_cmpstr(desc, ==, "Parameter 'foo' is unexpected");
|
2016-09-12 11:19:09 +02:00
|
|
|
}
|
|
|
|
|
2015-10-02 14:58:18 +02:00
|
|
|
static void test_qga_invalid_cmd(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *error;
|
2015-10-02 14:58:18 +02:00
|
|
|
const gchar *class, *desc;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-invalid-cmd'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
|
|
|
|
error = qdict_get_qdict(ret, "error");
|
|
|
|
class = qdict_get_try_str(error, "class");
|
|
|
|
desc = qdict_get_try_str(error, "desc");
|
|
|
|
|
|
|
|
g_assert_cmpstr(class, ==, "CommandNotFound");
|
|
|
|
g_assert_cmpint(strlen(desc), >, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_info(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
2015-10-02 14:58:18 +02:00
|
|
|
const gchar *version;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-info'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
version = qdict_get_try_str(val, "version");
|
|
|
|
g_assert_cmpstr(version, ==, QEMU_VERSION);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_get_vcpus(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
QList *list;
|
|
|
|
const QListEntry *entry;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
/* check there is at least a cpu */
|
|
|
|
list = qdict_get_qlist(ret, "return");
|
|
|
|
entry = qlist_first(list);
|
2018-02-24 16:40:29 +01:00
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
|
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "logical-id"));
|
2015-10-02 14:58:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_get_fsinfo(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
QList *list;
|
|
|
|
const QListEntry *entry;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
2015-10-20 18:17:36 +02:00
|
|
|
/* sanity-check the response if there are any filesystems */
|
2015-10-02 14:58:18 +02:00
|
|
|
list = qdict_get_qlist(ret, "return");
|
|
|
|
entry = qlist_first(list);
|
2015-10-20 18:17:36 +02:00
|
|
|
if (entry) {
|
2018-02-24 16:40:29 +01:00
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
|
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "mountpoint"));
|
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "type"));
|
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "disk"));
|
2015-10-20 18:17:36 +02:00
|
|
|
}
|
2015-10-02 14:58:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_get_memory_block_info(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
2015-10-02 14:58:18 +02:00
|
|
|
int64_t size;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
|
|
|
|
/* some systems might not expose memory block info in sysfs */
|
|
|
|
if (!qdict_haskey(ret, "error")) {
|
|
|
|
/* check there is at least some memory */
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
size = qdict_get_int(val, "size");
|
|
|
|
g_assert_cmpint(size, >, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_get_memory_blocks(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
QList *list;
|
|
|
|
const QListEntry *entry;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
|
|
|
|
/* some systems might not expose memory block info in sysfs */
|
|
|
|
if (!qdict_haskey(ret, "error")) {
|
|
|
|
list = qdict_get_qlist(ret, "return");
|
|
|
|
entry = qlist_first(list);
|
|
|
|
/* newer versions of qga may return empty list without error */
|
|
|
|
if (entry) {
|
2018-02-24 16:40:29 +01:00
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value),
|
|
|
|
"phys-index"));
|
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "online"));
|
2015-10-02 14:58:18 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_network_get_interfaces(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
QList *list;
|
|
|
|
const QListEntry *entry;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-network-get-interfaces'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
/* check there is at least an interface */
|
|
|
|
list = qdict_get_qlist(ret, "return");
|
|
|
|
entry = qlist_first(list);
|
2018-02-24 16:40:29 +01:00
|
|
|
g_assert(qdict_haskey(qobject_to(QDict, entry->value), "name"));
|
2015-10-02 14:58:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_file_ops(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2015-11-25 13:59:12 +01:00
|
|
|
const unsigned char helloworld[] = "Hello World!\n";
|
2015-10-02 14:58:18 +02:00
|
|
|
const char *b64;
|
2018-08-06 08:53:33 +02:00
|
|
|
gchar *path, *enc;
|
2015-11-25 13:59:12 +01:00
|
|
|
unsigned char *dec;
|
2015-10-02 14:58:18 +02:00
|
|
|
QDict *ret, *val;
|
|
|
|
int64_t id, eof;
|
|
|
|
gsize count;
|
|
|
|
FILE *f;
|
|
|
|
char tmp[100];
|
|
|
|
|
|
|
|
/* open */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
|
|
|
|
" 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
id = qdict_get_int(ret, "return");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
enc = g_base64_encode(helloworld, sizeof(helloworld));
|
|
|
|
/* write */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-write',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 ", 'buf-b64': %s } }",
|
|
|
|
id, enc);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "count");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
g_assert_cmpint(count, ==, sizeof(helloworld));
|
|
|
|
g_assert_cmpint(eof, ==, 0);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* flush */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-flush',"
|
|
|
|
" 'arguments': {'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* close */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-close',"
|
|
|
|
" 'arguments': {'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* check content */
|
|
|
|
path = g_build_filename(fixture->test_dir, "foo", NULL);
|
|
|
|
f = fopen(path, "r");
|
2016-07-15 18:00:18 +02:00
|
|
|
g_free(path);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_assert_nonnull(f);
|
|
|
|
count = fread(tmp, 1, sizeof(tmp), f);
|
|
|
|
g_assert_cmpint(count, ==, sizeof(helloworld));
|
|
|
|
tmp[count] = 0;
|
|
|
|
g_assert_cmpstr(tmp, ==, (char *)helloworld);
|
|
|
|
fclose(f);
|
|
|
|
|
|
|
|
/* open */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
|
|
|
|
" 'arguments': { 'path': 'foo', 'mode': 'r' } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
id = qdict_get_int(ret, "return");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* read */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-read',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2015-10-02 14:58:18 +02:00
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "count");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
b64 = qdict_get_str(val, "buf-b64");
|
|
|
|
g_assert_cmpint(count, ==, sizeof(helloworld));
|
|
|
|
g_assert(eof);
|
|
|
|
g_assert_cmpstr(b64, ==, enc);
|
|
|
|
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_free(enc);
|
|
|
|
|
|
|
|
/* read eof */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-read',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2015-10-02 14:58:18 +02:00
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "count");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
b64 = qdict_get_str(val, "buf-b64");
|
|
|
|
g_assert_cmpint(count, ==, 0);
|
|
|
|
g_assert(eof);
|
|
|
|
g_assert_cmpstr(b64, ==, "");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* seek */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-seek',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 ", "
|
|
|
|
" 'offset': %d, 'whence': %s } }",
|
|
|
|
id, 6, "set");
|
2015-10-02 14:58:18 +02:00
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "position");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
g_assert_cmpint(count, ==, 6);
|
|
|
|
g_assert(!eof);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* partial read */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-read',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2015-10-02 14:58:18 +02:00
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "count");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
b64 = qdict_get_str(val, "buf-b64");
|
|
|
|
g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
|
|
|
|
g_assert(eof);
|
|
|
|
dec = g_base64_decode(b64, &count);
|
|
|
|
g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
|
|
|
|
g_assert_cmpmem(dec, count, helloworld + 6, sizeof(helloworld) - 6);
|
|
|
|
g_free(dec);
|
|
|
|
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* close */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-close',"
|
|
|
|
" 'arguments': {'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
}
|
|
|
|
|
2015-11-25 13:59:12 +01:00
|
|
|
static void test_qga_file_write_read(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
|
|
|
const unsigned char helloworld[] = "Hello World!\n";
|
|
|
|
const char *b64;
|
2018-08-06 08:53:33 +02:00
|
|
|
gchar *enc;
|
2015-11-25 13:59:12 +01:00
|
|
|
QDict *ret, *val;
|
|
|
|
int64_t id, eof;
|
|
|
|
gsize count;
|
|
|
|
|
|
|
|
/* open */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
|
|
|
|
" 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
id = qdict_get_int(ret, "return");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-11-25 13:59:12 +01:00
|
|
|
|
|
|
|
enc = g_base64_encode(helloworld, sizeof(helloworld));
|
|
|
|
/* write */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-write',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 ","
|
|
|
|
" 'buf-b64': %s } }", id, enc);
|
2015-11-25 13:59:12 +01:00
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "count");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
g_assert_cmpint(count, ==, sizeof(helloworld));
|
|
|
|
g_assert_cmpint(eof, ==, 0);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-11-25 13:59:12 +01:00
|
|
|
|
|
|
|
/* read (check implicit flush) */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-read',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2015-11-25 13:59:12 +01:00
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "count");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
b64 = qdict_get_str(val, "buf-b64");
|
|
|
|
g_assert_cmpint(count, ==, 0);
|
|
|
|
g_assert(eof);
|
|
|
|
g_assert_cmpstr(b64, ==, "");
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-11-25 13:59:12 +01:00
|
|
|
|
|
|
|
/* seek to 0 */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-seek',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 ", "
|
|
|
|
" 'offset': %d, 'whence': %s } }",
|
|
|
|
id, 0, "set");
|
2015-11-25 13:59:12 +01:00
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "position");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
g_assert_cmpint(count, ==, 0);
|
|
|
|
g_assert(!eof);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-11-25 13:59:12 +01:00
|
|
|
|
|
|
|
/* read */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-read',"
|
|
|
|
" 'arguments': { 'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2015-11-25 13:59:12 +01:00
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
count = qdict_get_int(val, "count");
|
|
|
|
eof = qdict_get_bool(val, "eof");
|
|
|
|
b64 = qdict_get_str(val, "buf-b64");
|
|
|
|
g_assert_cmpint(count, ==, sizeof(helloworld));
|
|
|
|
g_assert(eof);
|
|
|
|
g_assert_cmpstr(b64, ==, enc);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-11-25 13:59:12 +01:00
|
|
|
g_free(enc);
|
|
|
|
|
|
|
|
/* close */
|
2018-08-06 08:53:33 +02:00
|
|
|
ret = qmp_fd(fixture->fd,
|
|
|
|
"{'execute': 'guest-file-close',"
|
|
|
|
" 'arguments': {'handle': %" PRId64 "} }",
|
|
|
|
id);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-11-25 13:59:12 +01:00
|
|
|
}
|
|
|
|
|
2015-10-02 14:58:18 +02:00
|
|
|
static void test_qga_get_time(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
int64_t time;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
time = qdict_get_int(ret, "return");
|
|
|
|
g_assert_cmpint(time, >, 0);
|
|
|
|
}
|
|
|
|
|
2022-07-27 10:39:13 +02:00
|
|
|
static void test_qga_blockedrpcs(gconstpointer data)
|
2015-10-02 14:58:18 +02:00
|
|
|
{
|
|
|
|
TestFixture fix;
|
|
|
|
QDict *ret, *error;
|
|
|
|
const gchar *class, *desc;
|
|
|
|
|
2017-07-14 16:28:57 +02:00
|
|
|
fixture_setup(&fix, "-b guest-ping,guest-get-time", NULL);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
2022-07-27 10:39:13 +02:00
|
|
|
/* check blocked RPCs */
|
2015-10-02 14:58:18 +02:00
|
|
|
ret = qmp_fd(fix.fd, "{'execute': 'guest-ping'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
error = qdict_get_qdict(ret, "error");
|
|
|
|
class = qdict_get_try_str(error, "class");
|
|
|
|
desc = qdict_get_try_str(error, "desc");
|
2019-08-30 15:29:45 +02:00
|
|
|
g_assert_cmpstr(class, ==, "CommandNotFound");
|
2015-10-02 14:58:18 +02:00
|
|
|
g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
error = qdict_get_qdict(ret, "error");
|
|
|
|
class = qdict_get_try_str(error, "class");
|
|
|
|
desc = qdict_get_try_str(error, "desc");
|
2019-08-30 15:29:45 +02:00
|
|
|
g_assert_cmpstr(class, ==, "CommandNotFound");
|
2015-10-02 14:58:18 +02:00
|
|
|
g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
/* check something work */
|
|
|
|
ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
|
|
|
|
qmp_assert_no_error(ret);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
fixture_tear_down(&fix, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_config(gconstpointer data)
|
|
|
|
{
|
|
|
|
GError *error = NULL;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autofree char *out = NULL;
|
|
|
|
g_autofree char *err = NULL;
|
|
|
|
g_autofree char *cwd = NULL;
|
|
|
|
g_autofree char *cmd = NULL;
|
|
|
|
g_auto(GStrv) argv = NULL;
|
|
|
|
g_auto(GStrv) strv = NULL;
|
|
|
|
g_autoptr(GKeyFile) kf = NULL;
|
|
|
|
char *str;
|
2015-10-02 14:58:18 +02:00
|
|
|
char *env[2];
|
2016-06-15 13:06:01 +02:00
|
|
|
int status;
|
2015-10-02 14:58:18 +02:00
|
|
|
gsize n;
|
|
|
|
|
|
|
|
cwd = g_get_current_dir();
|
2019-07-18 13:19:02 +02:00
|
|
|
cmd = g_strdup_printf("%s%cqga%cqemu-ga -D",
|
|
|
|
cwd, G_DIR_SEPARATOR, G_DIR_SEPARATOR);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_shell_parse_argv(cmd, NULL, &argv, &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
|
2016-06-15 13:06:01 +02:00
|
|
|
env[0] = g_strdup_printf("QGA_CONF=tests%cdata%ctest-qga-config",
|
|
|
|
G_DIR_SEPARATOR, G_DIR_SEPARATOR);
|
2015-10-02 14:58:18 +02:00
|
|
|
env[1] = NULL;
|
|
|
|
g_spawn_sync(NULL, argv, env, 0,
|
|
|
|
NULL, NULL, &out, &err, &status, &error);
|
2016-07-15 18:00:18 +02:00
|
|
|
|
2015-10-02 14:58:18 +02:00
|
|
|
g_assert_no_error(error);
|
|
|
|
g_assert_cmpstr(err, ==, "");
|
|
|
|
g_assert_cmpint(status, ==, 0);
|
|
|
|
|
|
|
|
kf = g_key_file_new();
|
|
|
|
g_key_file_load_from_data(kf, out, -1, G_KEY_FILE_NONE, &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
|
|
|
|
str = g_key_file_get_start_group(kf);
|
|
|
|
g_assert_cmpstr(str, ==, "general");
|
|
|
|
g_free(str);
|
|
|
|
|
|
|
|
g_assert_false(g_key_file_get_boolean(kf, "general", "daemon", &error));
|
|
|
|
g_assert_no_error(error);
|
|
|
|
|
|
|
|
str = g_key_file_get_string(kf, "general", "method", &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
g_assert_cmpstr(str, ==, "virtio-serial");
|
|
|
|
g_free(str);
|
|
|
|
|
|
|
|
str = g_key_file_get_string(kf, "general", "path", &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
g_assert_cmpstr(str, ==, "/path/to/org.qemu.guest_agent.0");
|
|
|
|
g_free(str);
|
|
|
|
|
|
|
|
str = g_key_file_get_string(kf, "general", "pidfile", &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
g_assert_cmpstr(str, ==, "/var/foo/qemu-ga.pid");
|
|
|
|
g_free(str);
|
|
|
|
|
|
|
|
str = g_key_file_get_string(kf, "general", "statedir", &error);
|
|
|
|
g_assert_no_error(error);
|
|
|
|
g_assert_cmpstr(str, ==, "/var/state");
|
|
|
|
g_free(str);
|
|
|
|
|
|
|
|
g_assert_true(g_key_file_get_boolean(kf, "general", "verbose", &error));
|
|
|
|
g_assert_no_error(error);
|
|
|
|
|
2022-07-27 11:21:33 +02:00
|
|
|
strv = g_key_file_get_string_list(kf, "general", "block-rpcs", &n, &error);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_assert_cmpint(n, ==, 2);
|
|
|
|
g_assert_true(g_strv_contains((const char * const *)strv,
|
|
|
|
"guest-ping"));
|
|
|
|
g_assert_true(g_strv_contains((const char * const *)strv,
|
|
|
|
"guest-get-time"));
|
|
|
|
g_assert_no_error(error);
|
|
|
|
|
|
|
|
g_free(env[0]);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_fsfreeze_status(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2015-10-02 14:58:18 +02:00
|
|
|
const gchar *status;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
status = qdict_get_try_str(ret, "return");
|
|
|
|
g_assert_cmpstr(status, ==, "thawed");
|
|
|
|
}
|
|
|
|
|
2023-03-23 01:19:28 +01:00
|
|
|
static QDict *wait_for_guest_exec_completion(int fd, int64_t pid)
|
|
|
|
{
|
|
|
|
QDict *ret = NULL;
|
|
|
|
int64_t now;
|
|
|
|
bool exited;
|
|
|
|
QDict *val;
|
|
|
|
|
|
|
|
now = g_get_monotonic_time();
|
|
|
|
do {
|
|
|
|
ret = qmp_fd(fd,
|
|
|
|
"{'execute': 'guest-exec-status',"
|
|
|
|
" 'arguments': { 'pid': %" PRId64 " } }", pid);
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
exited = qdict_get_bool(val, "exited");
|
|
|
|
if (!exited) {
|
|
|
|
qobject_unref(ret);
|
|
|
|
}
|
|
|
|
} while (!exited &&
|
|
|
|
g_get_monotonic_time() < now + 5 * G_TIME_SPAN_SECOND);
|
|
|
|
g_assert(exited);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2016-06-03 14:27:50 +02:00
|
|
|
static void test_qga_guest_exec(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
2016-06-03 14:27:50 +02:00
|
|
|
const gchar *out;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autofree guchar *decoded = NULL;
|
2023-03-23 01:19:28 +01:00
|
|
|
int64_t pid, exitcode;
|
2016-06-03 14:27:50 +02:00
|
|
|
gsize len;
|
|
|
|
|
|
|
|
/* exec 'echo foo bar' */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec', 'arguments': {"
|
|
|
|
" 'path': '/bin/echo', 'arg': [ '-n', '\" test_str \"' ],"
|
|
|
|
" 'capture-output': true } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
pid = qdict_get_int(val, "pid");
|
|
|
|
g_assert_cmpint(pid, >, 0);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2016-06-03 14:27:50 +02:00
|
|
|
|
2023-03-23 01:19:28 +01:00
|
|
|
ret = wait_for_guest_exec_completion(fixture->fd, pid);
|
2016-06-03 14:27:50 +02:00
|
|
|
|
|
|
|
/* check stdout */
|
2023-03-23 01:19:28 +01:00
|
|
|
val = qdict_get_qdict(ret, "return");
|
2016-06-03 14:27:50 +02:00
|
|
|
exitcode = qdict_get_int(val, "exitcode");
|
|
|
|
g_assert_cmpint(exitcode, ==, 0);
|
|
|
|
out = qdict_get_str(val, "out-data");
|
|
|
|
decoded = g_base64_decode(out, &len);
|
|
|
|
g_assert_cmpint(len, ==, 12);
|
|
|
|
g_assert_cmpstr((char *)decoded, ==, "\" test_str \"");
|
|
|
|
}
|
|
|
|
|
2023-03-23 01:19:28 +01:00
|
|
|
#if defined(G_OS_WIN32)
|
|
|
|
static void test_qga_guest_exec_separated(gconstpointer fix)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
static void test_qga_guest_exec_merged(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
|
|
|
const gchar *class, *desc;
|
|
|
|
g_autofree guchar *decoded = NULL;
|
|
|
|
|
|
|
|
/* exec 'echo foo bar' */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec', 'arguments': {"
|
|
|
|
" 'path': 'echo',"
|
|
|
|
" 'arg': [ 'execution never reaches here' ],"
|
|
|
|
" 'capture-output': 'merged' } }");
|
|
|
|
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
val = qdict_get_qdict(ret, "error");
|
|
|
|
g_assert_nonnull(val);
|
|
|
|
class = qdict_get_str(val, "class");
|
|
|
|
desc = qdict_get_str(val, "desc");
|
|
|
|
g_assert_cmpstr(class, ==, "GenericError");
|
|
|
|
g_assert_cmpint(strlen(desc), >, 0);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static void test_qga_guest_exec_separated(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
|
|
|
const gchar *out, *err;
|
|
|
|
g_autofree guchar *out_decoded = NULL;
|
|
|
|
g_autofree guchar *err_decoded = NULL;
|
|
|
|
int64_t pid, exitcode;
|
|
|
|
gsize len;
|
|
|
|
|
|
|
|
/* exec 'echo foo bar' */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec', 'arguments': {"
|
|
|
|
" 'path': '/bin/bash',"
|
|
|
|
" 'arg': [ '-c', 'for i in $(seq 4); do if (( $i %% 2 )); then echo stdout; else echo stderr 1>&2; fi; done;' ],"
|
|
|
|
" 'capture-output': 'separated' } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
pid = qdict_get_int(val, "pid");
|
|
|
|
g_assert_cmpint(pid, >, 0);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
ret = wait_for_guest_exec_completion(fixture->fd, pid);
|
|
|
|
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
exitcode = qdict_get_int(val, "exitcode");
|
|
|
|
g_assert_cmpint(exitcode, ==, 0);
|
|
|
|
|
|
|
|
/* check stdout */
|
|
|
|
out = qdict_get_str(val, "out-data");
|
|
|
|
out_decoded = g_base64_decode(out, &len);
|
|
|
|
g_assert_cmpint(len, ==, 14);
|
|
|
|
g_assert_cmpstr((char *)out_decoded, ==, "stdout\nstdout\n");
|
|
|
|
|
|
|
|
/* check stderr */
|
|
|
|
err = qdict_get_try_str(val, "err-data");
|
|
|
|
err_decoded = g_base64_decode(err, &len);
|
|
|
|
g_assert_cmpint(len, ==, 14);
|
|
|
|
g_assert_cmpstr((char *)err_decoded, ==, "stderr\nstderr\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_guest_exec_merged(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
|
|
|
const gchar *out, *err;
|
|
|
|
g_autofree guchar *decoded = NULL;
|
|
|
|
int64_t pid, exitcode;
|
|
|
|
gsize len;
|
|
|
|
|
|
|
|
/* exec 'echo foo bar' */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec', 'arguments': {"
|
|
|
|
" 'path': '/bin/bash',"
|
|
|
|
" 'arg': [ '-c', 'for i in $(seq 4); do if (( $i %% 2 )); then echo stdout; else echo stderr 1>&2; fi; done;' ],"
|
|
|
|
" 'capture-output': 'merged' } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
pid = qdict_get_int(val, "pid");
|
|
|
|
g_assert_cmpint(pid, >, 0);
|
|
|
|
qobject_unref(ret);
|
|
|
|
|
|
|
|
ret = wait_for_guest_exec_completion(fixture->fd, pid);
|
|
|
|
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
exitcode = qdict_get_int(val, "exitcode");
|
|
|
|
g_assert_cmpint(exitcode, ==, 0);
|
|
|
|
|
|
|
|
/* check stdout */
|
|
|
|
out = qdict_get_str(val, "out-data");
|
|
|
|
decoded = g_base64_decode(out, &len);
|
|
|
|
g_assert_cmpint(len, ==, 28);
|
|
|
|
g_assert_cmpstr((char *)decoded, ==, "stdout\nstderr\nstdout\nstderr\n");
|
|
|
|
|
|
|
|
/* check stderr */
|
|
|
|
err = qdict_get_try_str(val, "err-data");
|
|
|
|
g_assert_null(err);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2016-06-03 14:27:50 +02:00
|
|
|
static void test_qga_guest_exec_invalid(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *error;
|
2016-06-03 14:27:50 +02:00
|
|
|
const gchar *class, *desc;
|
|
|
|
|
|
|
|
/* invalid command */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec', 'arguments': {"
|
|
|
|
" 'path': '/bin/invalid-cmd42' } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
error = qdict_get_qdict(ret, "error");
|
|
|
|
g_assert_nonnull(error);
|
|
|
|
class = qdict_get_str(error, "class");
|
|
|
|
desc = qdict_get_str(error, "desc");
|
|
|
|
g_assert_cmpstr(class, ==, "GenericError");
|
|
|
|
g_assert_cmpint(strlen(desc), >, 0);
|
2018-04-19 17:01:43 +02:00
|
|
|
qobject_unref(ret);
|
2016-06-03 14:27:50 +02:00
|
|
|
|
|
|
|
/* invalid pid */
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-exec-status',"
|
|
|
|
" 'arguments': { 'pid': 0 } }");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
error = qdict_get_qdict(ret, "error");
|
|
|
|
g_assert_nonnull(error);
|
|
|
|
class = qdict_get_str(error, "class");
|
|
|
|
desc = qdict_get_str(error, "desc");
|
|
|
|
g_assert_cmpstr(class, ==, "GenericError");
|
|
|
|
g_assert_cmpint(strlen(desc), >, 0);
|
|
|
|
}
|
|
|
|
|
2018-04-20 20:04:34 +02:00
|
|
|
static void test_qga_guest_get_host_name(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
2018-04-20 20:04:34 +02:00
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-host-name'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
g_assert(qdict_haskey(val, "host-name"));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_guest_get_timezone(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
|
|
|
QDict *val;
|
2018-04-20 20:04:34 +02:00
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-timezone'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
/* Make sure there's at least offset */
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
g_assert(qdict_haskey(val, "offset"));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void test_qga_guest_get_users(gconstpointer fix)
|
|
|
|
{
|
|
|
|
const TestFixture *fixture = fix;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2018-04-20 20:04:34 +02:00
|
|
|
QList *val;
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-users'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
/* There is not much to test here */
|
|
|
|
val = qdict_get_qlist(ret, "return");
|
|
|
|
g_assert_nonnull(val);
|
|
|
|
}
|
|
|
|
|
2017-07-14 16:28:58 +02:00
|
|
|
static void test_qga_guest_get_osinfo(gconstpointer data)
|
|
|
|
{
|
|
|
|
TestFixture fixture;
|
|
|
|
const gchar *str;
|
2022-05-25 16:41:40 +02:00
|
|
|
g_autoptr(QDict) ret = NULL;
|
2022-05-25 16:41:35 +02:00
|
|
|
char *env[2];
|
|
|
|
QDict *val;
|
2017-07-14 16:28:58 +02:00
|
|
|
|
|
|
|
env[0] = g_strdup_printf(
|
2022-05-25 16:41:35 +02:00
|
|
|
"QGA_OS_RELEASE=%s%c..%cdata%ctest-qga-os-release",
|
|
|
|
g_test_get_dir(G_TEST_DIST), G_DIR_SEPARATOR, G_DIR_SEPARATOR, G_DIR_SEPARATOR);
|
2017-07-14 16:28:58 +02:00
|
|
|
env[1] = NULL;
|
|
|
|
fixture_setup(&fixture, NULL, env);
|
|
|
|
|
|
|
|
ret = qmp_fd(fixture.fd, "{'execute': 'guest-get-osinfo'}");
|
|
|
|
g_assert_nonnull(ret);
|
|
|
|
qmp_assert_no_error(ret);
|
|
|
|
|
|
|
|
val = qdict_get_qdict(ret, "return");
|
|
|
|
|
|
|
|
str = qdict_get_try_str(val, "id");
|
|
|
|
g_assert_nonnull(str);
|
|
|
|
g_assert_cmpstr(str, ==, "qemu-ga-test");
|
|
|
|
|
|
|
|
str = qdict_get_try_str(val, "name");
|
|
|
|
g_assert_nonnull(str);
|
|
|
|
g_assert_cmpstr(str, ==, "QEMU-GA");
|
|
|
|
|
|
|
|
str = qdict_get_try_str(val, "pretty-name");
|
|
|
|
g_assert_nonnull(str);
|
|
|
|
g_assert_cmpstr(str, ==, "QEMU Guest Agent test");
|
|
|
|
|
|
|
|
str = qdict_get_try_str(val, "version");
|
|
|
|
g_assert_nonnull(str);
|
|
|
|
g_assert_cmpstr(str, ==, "Test 1");
|
|
|
|
|
|
|
|
str = qdict_get_try_str(val, "version-id");
|
|
|
|
g_assert_nonnull(str);
|
|
|
|
g_assert_cmpstr(str, ==, "1");
|
|
|
|
|
|
|
|
str = qdict_get_try_str(val, "variant");
|
|
|
|
g_assert_nonnull(str);
|
|
|
|
g_assert_cmpstr(str, ==, "Unit test \"'$`\\ and \\\\ etc.");
|
|
|
|
|
|
|
|
str = qdict_get_try_str(val, "variant-id");
|
|
|
|
g_assert_nonnull(str);
|
|
|
|
g_assert_cmpstr(str, ==, "unit-test");
|
|
|
|
|
|
|
|
g_free(env[0]);
|
|
|
|
fixture_tear_down(&fixture, NULL);
|
|
|
|
}
|
|
|
|
|
2015-10-02 14:58:18 +02:00
|
|
|
int main(int argc, char **argv)
|
|
|
|
{
|
|
|
|
TestFixture fix;
|
|
|
|
int ret;
|
|
|
|
|
2022-04-20 15:26:12 +02:00
|
|
|
#ifdef QEMU_SANITIZE_THREAD
|
|
|
|
{
|
|
|
|
g_test_skip("tsan enabled, https://github.com/google/sanitizers/issues/1116");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2015-10-02 14:58:18 +02:00
|
|
|
setlocale (LC_ALL, "");
|
|
|
|
g_test_init(&argc, &argv, NULL);
|
2017-07-14 16:28:57 +02:00
|
|
|
fixture_setup(&fix, NULL, NULL);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
g_test_add_data_func("/qga/sync-delimited", &fix, test_qga_sync_delimited);
|
|
|
|
g_test_add_data_func("/qga/sync", &fix, test_qga_sync);
|
|
|
|
g_test_add_data_func("/qga/ping", &fix, test_qga_ping);
|
|
|
|
g_test_add_data_func("/qga/info", &fix, test_qga_info);
|
|
|
|
g_test_add_data_func("/qga/network-get-interfaces", &fix,
|
|
|
|
test_qga_network_get_interfaces);
|
2017-03-02 20:44:37 +01:00
|
|
|
if (!access("/sys/devices/system/cpu/cpu0", F_OK)) {
|
|
|
|
g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus);
|
|
|
|
}
|
2015-10-02 14:58:18 +02:00
|
|
|
g_test_add_data_func("/qga/get-fsinfo", &fix, test_qga_get_fsinfo);
|
|
|
|
g_test_add_data_func("/qga/get-memory-block-info", &fix,
|
|
|
|
test_qga_get_memory_block_info);
|
|
|
|
g_test_add_data_func("/qga/get-memory-blocks", &fix,
|
|
|
|
test_qga_get_memory_blocks);
|
|
|
|
g_test_add_data_func("/qga/file-ops", &fix, test_qga_file_ops);
|
2015-11-25 13:59:12 +01:00
|
|
|
g_test_add_data_func("/qga/file-write-read", &fix, test_qga_file_write_read);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time);
|
2019-02-20 16:42:53 +01:00
|
|
|
g_test_add_data_func("/qga/id", &fix, test_qga_id);
|
2018-07-03 10:53:36 +02:00
|
|
|
g_test_add_data_func("/qga/invalid-oob", &fix, test_qga_invalid_oob);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd);
|
2016-09-12 11:19:09 +02:00
|
|
|
g_test_add_data_func("/qga/invalid-args", &fix, test_qga_invalid_args);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_test_add_data_func("/qga/fsfreeze-status", &fix,
|
|
|
|
test_qga_fsfreeze_status);
|
|
|
|
|
2022-07-27 10:39:13 +02:00
|
|
|
g_test_add_data_func("/qga/blockedrpcs", NULL, test_qga_blockedrpcs);
|
2015-10-02 14:58:18 +02:00
|
|
|
g_test_add_data_func("/qga/config", NULL, test_qga_config);
|
2016-06-03 14:27:50 +02:00
|
|
|
g_test_add_data_func("/qga/guest-exec", &fix, test_qga_guest_exec);
|
2023-03-23 01:19:28 +01:00
|
|
|
g_test_add_data_func("/qga/guest-exec-separated", &fix,
|
|
|
|
test_qga_guest_exec_separated);
|
|
|
|
g_test_add_data_func("/qga/guest-exec-merged", &fix,
|
|
|
|
test_qga_guest_exec_merged);
|
2016-06-03 14:27:50 +02:00
|
|
|
g_test_add_data_func("/qga/guest-exec-invalid", &fix,
|
|
|
|
test_qga_guest_exec_invalid);
|
2017-07-14 16:28:58 +02:00
|
|
|
g_test_add_data_func("/qga/guest-get-osinfo", &fix,
|
|
|
|
test_qga_guest_get_osinfo);
|
2018-04-20 20:04:34 +02:00
|
|
|
g_test_add_data_func("/qga/guest-get-host-name", &fix,
|
|
|
|
test_qga_guest_get_host_name);
|
|
|
|
g_test_add_data_func("/qga/guest-get-timezone", &fix,
|
|
|
|
test_qga_guest_get_timezone);
|
|
|
|
g_test_add_data_func("/qga/guest-get-users", &fix,
|
|
|
|
test_qga_guest_get_users);
|
2015-10-02 14:58:18 +02:00
|
|
|
|
|
|
|
ret = g_test_run();
|
|
|
|
|
|
|
|
fixture_tear_down(&fix, NULL);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|