* [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers
@ 2015-08-27 10:52 marcandre.lureau
2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau
2015-09-09 20:05 ` [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers Michael Roth
0 siblings, 2 replies; 7+ messages in thread
From: marcandre.lureau @ 2015-08-27 10:52 UTC (permalink / raw)
To: qemu-devel; +Cc: Marc-André Lureau, mdroth
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Add a few functions to interact with qmp via a simple fd.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/libqtest.c | 45 +++++++++++++++++++++++++++++++++++++++++----
tests/libqtest.h | 7 +++++++
2 files changed, 48 insertions(+), 4 deletions(-)
diff --git a/tests/libqtest.c b/tests/libqtest.c
index e5188e0..11e541d 100644
--- a/tests/libqtest.c
+++ b/tests/libqtest.c
@@ -357,7 +357,7 @@ static void qmp_response(JSONMessageParser *parser, QList *tokens)
qmp->response = (QDict *)obj;
}
-QDict *qtest_qmp_receive(QTestState *s)
+QDict *qmp_fd_receive(int fd)
{
QMPResponseParser qmp;
bool log = getenv("QTEST_LOG") != NULL;
@@ -368,7 +368,7 @@ QDict *qtest_qmp_receive(QTestState *s)
ssize_t len;
char c;
- len = read(s->qmp_fd, &c, 1);
+ len = read(fd, &c, 1);
if (len == -1 && errno == EINTR) {
continue;
}
@@ -388,12 +388,17 @@ QDict *qtest_qmp_receive(QTestState *s)
return qmp.response;
}
+QDict *qtest_qmp_receive(QTestState *s)
+{
+ return qmp_fd_receive(s->qmp_fd);
+}
+
/**
* Allow users to send a message without waiting for the reply,
* in the case that they choose to discard all replies up until
* a particular EVENT is received.
*/
-void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
+void qmp_fd_sendv(int fd, const char *fmt, va_list ap)
{
va_list ap_copy;
QObject *qobj;
@@ -417,13 +422,25 @@ void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
fprintf(stderr, "%s", str);
}
/* Send QMP request */
- socket_send(s->qmp_fd, str, size);
+ socket_send(fd, str, size);
QDECREF(qstr);
qobject_decref(qobj);
}
}
+void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
+{
+ qmp_fd_sendv(s->qmp_fd, fmt, ap);
+}
+
+QDict *qmp_fdv(int fd, const char *fmt, va_list ap)
+{
+ qmp_fd_sendv(fd, fmt, ap);
+
+ return qmp_fd_receive(fd);
+}
+
QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap)
{
qtest_async_qmpv(s, fmt, ap);
@@ -432,6 +449,26 @@ QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap)
return qtest_qmp_receive(s);
}
+QDict *qmp_fd(int fd, const char *fmt, ...)
+{
+ va_list ap;
+ QDict *response;
+
+ va_start(ap, fmt);
+ response = qmp_fdv(fd, fmt, ap);
+ va_end(ap);
+ return response;
+}
+
+void qmp_fd_send(int fd, const char *fmt, ...)
+{
+ va_list ap;
+
+ va_start(ap, fmt);
+ qmp_fd_sendv(fd, fmt, ap);
+ va_end(ap);
+}
+
QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
{
va_list ap;
diff --git a/tests/libqtest.h b/tests/libqtest.h
index ec42031..ecd9872 100644
--- a/tests/libqtest.h
+++ b/tests/libqtest.h
@@ -818,4 +818,11 @@ static inline int64_t clock_set(int64_t val)
*/
bool qtest_big_endian(void);
+
+QDict *qmp_fd_receive(int fd);
+void qmp_fd_sendv(int fd, const char *fmt, va_list ap);
+void qmp_fd_send(int fd, const char *fmt, ...);
+QDict *qmp_fdv(int fd, const char *fmt, va_list ap);
+QDict *qmp_fd(int fd, const char *fmt, ...);
+
#endif
--
2.4.3
^ permalink raw reply related [flat|nested] 7+ messages in thread
* [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent
2015-08-27 10:52 [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers marcandre.lureau
@ 2015-08-27 10:52 ` marcandre.lureau
2015-08-27 11:36 ` Marc-André Lureau
2015-09-09 21:53 ` Michael Roth
2015-09-09 20:05 ` [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers Michael Roth
1 sibling, 2 replies; 7+ messages in thread
From: marcandre.lureau @ 2015-08-27 10:52 UTC (permalink / raw)
To: qemu-devel; +Cc: Marc-André Lureau, mdroth
From: Marc-André Lureau <marcandre.lureau@redhat.com>
Add some local guest agent tests (as it is better than nothing).
They can be run inside or outside a VM, when run inside a VM, they will
do a bit more side effects, such as freezing/thawing the FS or changing
the time.
A better test would involve a managed VM (or container), but it might be
better to leave that off to autotest/avocado.
Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
---
tests/Makefile | 3 +
tests/test-qga.c | 686 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 689 insertions(+)
create mode 100644 tests/test-qga.c
diff --git a/tests/Makefile b/tests/Makefile
index 5271123..35671a1 100644
--- a/tests/Makefile
+++ b/tests/Makefile
@@ -76,6 +76,7 @@ check-unit-y += tests/test-write-threshold$(EXESUF)
gcov-files-test-write-threshold-y = block/write-threshold.c
check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF)
check-unit-y += tests/test-crypto-cipher$(EXESUF)
+check-unit-y += tests/test-qga$(EXESUF)
check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
@@ -425,6 +426,8 @@ endif
qtest-obj-y = tests/libqtest.o libqemuutil.a libqemustub.a
$(check-qtest-y): $(qtest-obj-y)
+tests/test-qga: tests/test-qga.o $(qtest-obj-y)
+
.PHONY: check-help
check-help:
@echo "Regression testing targets:"
diff --git a/tests/test-qga.c b/tests/test-qga.c
new file mode 100644
index 0000000..1fb58ec
--- /dev/null
+++ b/tests/test-qga.c
@@ -0,0 +1,686 @@
+#include <locale.h>
+#include <glib.h>
+#include <glib/gstdio.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include "libqtest.h"
+#include "config-host.h"
+
+typedef struct {
+ char *test_dir;
+ GMainLoop *loop;
+ int fd;
+ GPid pid;
+} TestFixture;
+
+static int connect_qga(char *path)
+{
+ int s, ret, len;
+ 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);
+ }
+ } 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
+fixture_setup(TestFixture *fixture, gconstpointer data)
+{
+ const gchar *extra_arg = data;
+ GError *error = NULL;
+ gchar *cwd, *path, *cmd, **argv = NULL;
+
+ fixture->loop = g_main_loop_new(NULL, FALSE);
+
+ fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX");
+ g_assert_nonnull(g_mkdtemp(fixture->test_dir));
+
+ path = g_build_filename(fixture->test_dir, "sock", NULL);
+ cwd = g_get_current_dir();
+ cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s",
+ cwd, G_DIR_SEPARATOR,
+ fixture->test_dir, path,
+ getenv("QTEST_LOG") ? "-v" : "",
+ extra_arg ?: "");
+ g_shell_parse_argv(cmd, NULL, &argv, &error);
+ g_assert_no_error(error);
+
+ g_spawn_async(fixture->test_dir, argv, NULL,
+ 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_strfreev(argv);
+ g_free(cmd);
+ g_free(cwd);
+ g_free(path);
+}
+
+static void
+fixture_tear_down(TestFixture *fixture, gconstpointer data)
+{
+ gchar *tmp;
+
+ 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_free(tmp);
+
+ g_rmdir(fixture->test_dir);
+ g_free(fixture->test_dir);
+}
+
+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;
+ char *s;
+ 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);
+ g_free(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;
+ guint32 v, r = g_random_int();
+ unsigned char c;
+ QDict *ret;
+ gchar *cmd;
+
+ cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited',"
+ " 'arguments': {'id': %u } }", 0xff, r);
+ qmp_fd_send(fixture->fd, cmd);
+ g_free(cmd);
+
+ v = read(fixture->fd, &c, 1);
+ g_assert_cmpint(v, ==, 1);
+ g_assert_cmpint(c, ==, 0xff);
+
+ 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);
+
+ QDECREF(ret);
+}
+
+static void test_qga_sync(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ guint32 v, r = g_random_int();
+ QDict *ret;
+ gchar *cmd;
+
+ cmd = g_strdup_printf("%c{'execute': 'guest-sync',"
+ " 'arguments': {'id': %u } }", 0xff, r);
+ ret = qmp_fd(fixture->fd, cmd);
+ g_free(cmd);
+
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+
+ v = qdict_get_int(ret, "return");
+ g_assert_cmpint(r, ==, v);
+
+ QDECREF(ret);
+}
+
+static void test_qga_ping(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+
+ QDECREF(ret);
+}
+
+static void test_qga_invalid_cmd(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret, *error;
+ 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);
+
+ QDECREF(ret);
+}
+
+static void test_qga_info(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret, *val;
+ 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);
+
+ QDECREF(ret);
+}
+
+static void test_qga_get_vcpus(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ 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);
+ g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
+ g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id"));
+
+ QDECREF(ret);
+}
+
+static void test_qga_get_fsinfo(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ QList *list;
+ const QListEntry *entry;
+
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+
+ /* check there is at least a fs */
+ list = qdict_get_qlist(ret, "return");
+ entry = qlist_first(list);
+ 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"));
+
+ QDECREF(ret);
+}
+
+static void test_qga_get_memory_block_info(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret, *val;
+ int64_t size;
+
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+
+ /* check there is at least some memory */
+ val = qdict_get_qdict(ret, "return");
+ size = qdict_get_int(val, "size");
+ g_assert_cmpint(size, >, 0);
+
+ QDECREF(ret);
+}
+
+static void test_qga_get_memory_blocks(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ QList *list;
+ const QListEntry *entry;
+
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+
+ list = qdict_get_qlist(ret, "return");
+ entry = qlist_first(list);
+ g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index"));
+ g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
+
+ QDECREF(ret);
+}
+
+static void test_qga_network_get_interfaces(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ 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 a cpu */
+ list = qdict_get_qlist(ret, "return");
+ entry = qlist_first(list);
+ g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
+
+ QDECREF(ret);
+}
+
+static void test_qga_file_ops(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ gchar *cmd, *path;
+ const gchar *b64;
+ QDict *ret, *val;
+ int64_t id, count, eof;
+ 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");
+ QDECREF(ret);
+
+ /* write */
+ cmd = g_strdup_printf("{'execute': 'guest-file-write',"
+ " 'arguments': { 'handle': %" G_GINT64_FORMAT ","
+ " 'buf-b64': 'aGVsbG8gd29ybGQK' } }", id);
+ ret = qmp_fd(fixture->fd, cmd);
+ 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, ==, 12);
+ g_assert_cmpint(eof, ==, 0);
+ QDECREF(ret);
+ g_free(cmd);
+
+ /* flush */
+ cmd = g_strdup_printf("{'execute': 'guest-file-flush',"
+ " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
+ id);
+ ret = qmp_fd(fixture->fd, cmd);
+ QDECREF(ret);
+ g_free(cmd);
+
+ /* close */
+ cmd = g_strdup_printf("{'execute': 'guest-file-close',"
+ " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
+ id);
+ ret = qmp_fd(fixture->fd, cmd);
+ QDECREF(ret);
+ g_free(cmd);
+
+ /* check content */
+ path = g_build_filename(fixture->test_dir, "foo", NULL);
+ f = fopen(path, "r");
+ g_assert_nonnull(f);
+ count = fread(tmp, 1, sizeof(tmp), f);
+ g_assert_cmpint(count, ==, 12);
+ tmp[count] = 0;
+ g_assert_cmpstr(tmp, ==, "hello world\n");
+ 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");
+ QDECREF(ret);
+
+ /* read */
+ cmd = g_strdup_printf("{'execute': 'guest-file-read',"
+ " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
+ id);
+ ret = qmp_fd(fixture->fd, cmd);
+ 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, ==, 12);
+ g_assert(eof);
+ g_assert_cmpstr(b64, ==, "aGVsbG8gd29ybGQK");
+
+ QDECREF(ret);
+ g_free(cmd);
+
+ /* read eof */
+ cmd = g_strdup_printf("{'execute': 'guest-file-read',"
+ " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
+ id);
+ ret = qmp_fd(fixture->fd, cmd);
+ 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, ==, "");
+ QDECREF(ret);
+ g_free(cmd);
+
+ /* seek */
+ cmd = g_strdup_printf("{'execute': 'guest-file-seek',"
+ " 'arguments': { 'handle': %" G_GINT64_FORMAT ", "
+ " 'offset': %d, 'whence': %d } }",
+ id, 6, SEEK_SET);
+ ret = qmp_fd(fixture->fd, cmd);
+ 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);
+ QDECREF(ret);
+ g_free(cmd);
+
+ /* partial read */
+ cmd = g_strdup_printf("{'execute': 'guest-file-read',"
+ " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
+ id);
+ ret = qmp_fd(fixture->fd, cmd);
+ 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, ==, 6);
+ g_assert(eof);
+ g_assert_cmpstr(b64, ==, "d29ybGQK");
+
+ QDECREF(ret);
+ g_free(cmd);
+
+ /* close */
+ cmd = g_strdup_printf("{'execute': 'guest-file-close',"
+ " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
+ id);
+ ret = qmp_fd(fixture->fd, cmd);
+ QDECREF(ret);
+ g_free(cmd);
+}
+
+static void test_qga_get_time(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ 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);
+
+ QDECREF(ret);
+}
+
+static void test_qga_set_time(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ int64_t current, time;
+ gchar *cmd;
+
+ /* get current time */
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+ current = qdict_get_int(ret, "return");
+ g_assert_cmpint(current, >, 0);
+ QDECREF(ret);
+
+ /* set some old time */
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time',"
+ " 'arguments': { 'time': 1000 } }");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+ QDECREF(ret);
+
+ /* check old 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 / 1000, <, G_USEC_PER_SEC * 10);
+ QDECREF(ret);
+
+ /* set back current time */
+ cmd = g_strdup_printf("{'execute': 'guest-set-time',"
+ " 'arguments': { 'time': %" G_GINT64_FORMAT " } }",
+ current + time * 1000);
+ ret = qmp_fd(fixture->fd, cmd);
+ g_free(cmd);
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+ QDECREF(ret);
+}
+
+static void test_qga_fstrim(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ QList *list;
+ const QListEntry *entry;
+
+ /* get current time */
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim',"
+ " arguments: { minimum: 4194304 } }");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+ list = qdict_get_qlist(ret, "return");
+ entry = qlist_first(list);
+ g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths"));
+
+ QDECREF(ret);
+}
+
+static void test_qga_blacklist(gconstpointer data)
+{
+ TestFixture fix;
+ QDict *ret, *error;
+ const gchar *class, *desc;
+
+ fixture_setup(&fix, "-b guest-ping,guest-get-time");
+
+ /* check blacklist */
+ 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");
+ g_assert_cmpstr(class, ==, "GenericError");
+ g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
+ QDECREF(ret);
+
+ 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");
+ g_assert_cmpstr(class, ==, "GenericError");
+ g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
+ QDECREF(ret);
+
+ /* check something work */
+ ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
+ qmp_assert_no_error(ret);
+ QDECREF(ret);
+
+ fixture_tear_down(&fix, NULL);
+}
+
+static void test_qga_fsfreeze_status(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ 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");
+
+ QDECREF(ret);
+}
+
+static void test_qga_fsfreeze_and_thaw(gconstpointer fix)
+{
+ const TestFixture *fixture = fix;
+ QDict *ret;
+ const gchar *status;
+
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+ QDECREF(ret);
+
+ 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, ==, "frozen");
+ QDECREF(ret);
+
+ ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}");
+ g_assert_nonnull(ret);
+ qmp_assert_no_error(ret);
+ QDECREF(ret);
+}
+
+static gboolean running_in_virt(const gchar *virt)
+{
+ gchar *virt_what = NULL;
+ gint status;
+ gboolean success;
+
+ success = g_spawn_command_line_sync("virt-what", &virt_what, NULL,
+ &status, NULL);
+
+ success = success && status == 0 && g_strcmp0(virt_what, virt);
+
+ g_free(virt_what);
+
+ return success;
+}
+int main(int argc, char **argv)
+{
+ TestFixture fix;
+ int ret;
+
+ setlocale (LC_ALL, "");
+ g_test_init(&argc, &argv, NULL);
+ fixture_setup(&fix, NULL);
+
+ 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);
+ g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus);
+ 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);
+ g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time);
+ g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd);
+ g_test_add_data_func("/qga/fsfreeze-status", &fix,
+ test_qga_fsfreeze_status);
+
+ g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist);
+
+ if (running_in_virt("kvm")) {
+ g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix,
+ test_qga_fsfreeze_and_thaw);
+ g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time);
+ if (g_test_thorough()) {
+ g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim);
+ }
+ }
+
+ ret = g_test_run();
+
+ fixture_tear_down(&fix, NULL);
+
+ return ret;
+}
--
2.4.3
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent
2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau
@ 2015-08-27 11:36 ` Marc-André Lureau
2015-09-09 17:36 ` Michael Roth
2015-09-09 21:53 ` Michael Roth
1 sibling, 1 reply; 7+ messages in thread
From: Marc-André Lureau @ 2015-08-27 11:36 UTC (permalink / raw)
To: QEMU; +Cc: Marc-André Lureau, Michael Roth
On Thu, Aug 27, 2015 at 12:52 PM, <marcandre.lureau@redhat.com> wrote:
> + success = success && status == 0 && g_strcmp0(virt_what, virt);
this is now:
g_strcmp0(g_strstrip(virt_what), virt) == 0
--
Marc-André Lureau
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent
2015-08-27 11:36 ` Marc-André Lureau
@ 2015-09-09 17:36 ` Michael Roth
0 siblings, 0 replies; 7+ messages in thread
From: Michael Roth @ 2015-09-09 17:36 UTC (permalink / raw)
To: Marc-André Lureau, QEMU; +Cc: Marc-André Lureau
Quoting Marc-André Lureau (2015-08-27 06:36:43)
> On Thu, Aug 27, 2015 at 12:52 PM, <marcandre.lureau@redhat.com> wrote:
> > + success = success && status == 0 && g_strcmp0(virt_what, virt);
>
> this is now:
> g_strcmp0(g_strstrip(virt_what), virt) == 0
Just to be sure, is this the change you intended?
diff --git a/tests/test-qga.c b/tests/test-qga.c
index 1fb58ec..ca4bcb5 100644
--- a/tests/test-qga.c
+++ b/tests/test-qga.c
@@ -634,7 +634,8 @@ static gboolean running_in_virt(const gchar *virt)
success = g_spawn_command_line_sync("virt-what", &virt_what, NULL,
&status, NULL);
- success = success && status == 0 && g_strcmp0(virt_what, virt);
+ success = success && status == 0 &&
+ g_strcmp0(g_strstrip(virt_what), virt) == 0;
g_free(virt_what);
>
> --
> Marc-André Lureau
>
^ permalink raw reply related [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers
2015-08-27 10:52 [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers marcandre.lureau
2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau
@ 2015-09-09 20:05 ` Michael Roth
1 sibling, 0 replies; 7+ messages in thread
From: Michael Roth @ 2015-09-09 20:05 UTC (permalink / raw)
To: marcandre.lureau, qemu-devel
Quoting marcandre.lureau@redhat.com (2015-08-27 05:52:06)
> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> Add a few functions to interact with qmp via a simple fd.
>
> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
Reviewed-by: Michael Roth <mdroth@linux.vnet.ibm.com>
> ---
> tests/libqtest.c | 45 +++++++++++++++++++++++++++++++++++++++++----
> tests/libqtest.h | 7 +++++++
> 2 files changed, 48 insertions(+), 4 deletions(-)
>
> diff --git a/tests/libqtest.c b/tests/libqtest.c
> index e5188e0..11e541d 100644
> --- a/tests/libqtest.c
> +++ b/tests/libqtest.c
> @@ -357,7 +357,7 @@ static void qmp_response(JSONMessageParser *parser, QList *tokens)
> qmp->response = (QDict *)obj;
> }
>
> -QDict *qtest_qmp_receive(QTestState *s)
> +QDict *qmp_fd_receive(int fd)
> {
> QMPResponseParser qmp;
> bool log = getenv("QTEST_LOG") != NULL;
> @@ -368,7 +368,7 @@ QDict *qtest_qmp_receive(QTestState *s)
> ssize_t len;
> char c;
>
> - len = read(s->qmp_fd, &c, 1);
> + len = read(fd, &c, 1);
> if (len == -1 && errno == EINTR) {
> continue;
> }
> @@ -388,12 +388,17 @@ QDict *qtest_qmp_receive(QTestState *s)
> return qmp.response;
> }
>
> +QDict *qtest_qmp_receive(QTestState *s)
> +{
> + return qmp_fd_receive(s->qmp_fd);
> +}
> +
> /**
> * Allow users to send a message without waiting for the reply,
> * in the case that they choose to discard all replies up until
> * a particular EVENT is received.
> */
> -void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
> +void qmp_fd_sendv(int fd, const char *fmt, va_list ap)
> {
> va_list ap_copy;
> QObject *qobj;
> @@ -417,13 +422,25 @@ void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
> fprintf(stderr, "%s", str);
> }
> /* Send QMP request */
> - socket_send(s->qmp_fd, str, size);
> + socket_send(fd, str, size);
>
> QDECREF(qstr);
> qobject_decref(qobj);
> }
> }
>
> +void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
> +{
> + qmp_fd_sendv(s->qmp_fd, fmt, ap);
> +}
> +
> +QDict *qmp_fdv(int fd, const char *fmt, va_list ap)
> +{
> + qmp_fd_sendv(fd, fmt, ap);
> +
> + return qmp_fd_receive(fd);
> +}
> +
> QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap)
> {
> qtest_async_qmpv(s, fmt, ap);
> @@ -432,6 +449,26 @@ QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap)
> return qtest_qmp_receive(s);
> }
>
> +QDict *qmp_fd(int fd, const char *fmt, ...)
> +{
> + va_list ap;
> + QDict *response;
> +
> + va_start(ap, fmt);
> + response = qmp_fdv(fd, fmt, ap);
> + va_end(ap);
> + return response;
> +}
> +
> +void qmp_fd_send(int fd, const char *fmt, ...)
> +{
> + va_list ap;
> +
> + va_start(ap, fmt);
> + qmp_fd_sendv(fd, fmt, ap);
> + va_end(ap);
> +}
> +
> QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
> {
> va_list ap;
> diff --git a/tests/libqtest.h b/tests/libqtest.h
> index ec42031..ecd9872 100644
> --- a/tests/libqtest.h
> +++ b/tests/libqtest.h
> @@ -818,4 +818,11 @@ static inline int64_t clock_set(int64_t val)
> */
> bool qtest_big_endian(void);
>
> +
> +QDict *qmp_fd_receive(int fd);
> +void qmp_fd_sendv(int fd, const char *fmt, va_list ap);
> +void qmp_fd_send(int fd, const char *fmt, ...);
> +QDict *qmp_fdv(int fd, const char *fmt, va_list ap);
> +QDict *qmp_fd(int fd, const char *fmt, ...);
> +
> #endif
> --
> 2.4.3
>
>
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent
2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau
2015-08-27 11:36 ` Marc-André Lureau
@ 2015-09-09 21:53 ` Michael Roth
2015-09-11 17:46 ` Marc-André Lureau
1 sibling, 1 reply; 7+ messages in thread
From: Michael Roth @ 2015-09-09 21:53 UTC (permalink / raw)
To: marcandre.lureau, qemu-devel
Quoting marcandre.lureau@redhat.com (2015-08-27 05:52:07)
> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>
> Add some local guest agent tests (as it is better than nothing).
>
> They can be run inside or outside a VM, when run inside a VM, they will
> do a bit more side effects, such as freezing/thawing the FS or changing
> the time.
>
> A better test would involve a managed VM (or container), but it might be
> better to leave that off to autotest/avocado.
>
> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
> ---
> tests/Makefile | 3 +
> tests/test-qga.c | 686 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 2 files changed, 689 insertions(+)
> create mode 100644 tests/test-qga.c
>
> diff --git a/tests/Makefile b/tests/Makefile
> index 5271123..35671a1 100644
> --- a/tests/Makefile
> +++ b/tests/Makefile
> @@ -76,6 +76,7 @@ check-unit-y += tests/test-write-threshold$(EXESUF)
> gcov-files-test-write-threshold-y = block/write-threshold.c
> check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF)
> check-unit-y += tests/test-crypto-cipher$(EXESUF)
> +check-unit-y += tests/test-qga$(EXESUF)
>
> check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
>
> @@ -425,6 +426,8 @@ endif
> qtest-obj-y = tests/libqtest.o libqemuutil.a libqemustub.a
> $(check-qtest-y): $(qtest-obj-y)
>
> +tests/test-qga: tests/test-qga.o $(qtest-obj-y)
> +
> .PHONY: check-help
> check-help:
> @echo "Regression testing targets:"
> diff --git a/tests/test-qga.c b/tests/test-qga.c
> new file mode 100644
> index 0000000..1fb58ec
> --- /dev/null
> +++ b/tests/test-qga.c
> @@ -0,0 +1,686 @@
> +#include <locale.h>
> +#include <glib.h>
> +#include <glib/gstdio.h>
> +#include <stdio.h>
> +#include <stdlib.h>
> +#include <errno.h>
> +#include <string.h>
> +#include <sys/types.h>
> +#include <sys/socket.h>
> +#include <sys/un.h>
> +#include <unistd.h>
> +
> +#include "libqtest.h"
> +#include "config-host.h"
> +
> +typedef struct {
> + char *test_dir;
> + GMainLoop *loop;
> + int fd;
> + GPid pid;
> +} TestFixture;
> +
> +static int connect_qga(char *path)
> +{
> + int s, ret, len;
> + 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);
> + }
> + } while (ret == -1);
I think we should loop on ECONNREFUSED (or whatever corresponds to
the socket not yet being created/bound), and the usual suspects
like EINTR. If it's anything else I don't think we'd want this to
loop indefinitely.
> +
> + 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
> +fixture_setup(TestFixture *fixture, gconstpointer data)
> +{
> + const gchar *extra_arg = data;
> + GError *error = NULL;
> + gchar *cwd, *path, *cmd, **argv = NULL;
> +
> + fixture->loop = g_main_loop_new(NULL, FALSE);
> +
> + fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX");
> + g_assert_nonnull(g_mkdtemp(fixture->test_dir));
> +
> + path = g_build_filename(fixture->test_dir, "sock", NULL);
> + cwd = g_get_current_dir();
> + cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s",
Would be nice if we could also run qemu-ga.exe for a w32 build with
binfmt set up like some of the other tests, but no idea how we'd get
at it through wine. I guess it would have to be a serial connection
or something...
Probably too environment-specific for a useful unit test. I guess in
the future we could plumb in custom qemu-ga invocation/script that
does some extra setup on the backend (VM/container/wine) and exposes
that via a local socket like we'd get via -chardev.
> + cwd, G_DIR_SEPARATOR,
> + fixture->test_dir, path,
> + getenv("QTEST_LOG") ? "-v" : "",
> + extra_arg ?: "");
> + g_shell_parse_argv(cmd, NULL, &argv, &error);
> + g_assert_no_error(error);
> +
> + g_spawn_async(fixture->test_dir, argv, NULL,
> + 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_strfreev(argv);
> + g_free(cmd);
> + g_free(cwd);
> + g_free(path);
> +}
> +
> +static void
> +fixture_tear_down(TestFixture *fixture, gconstpointer data)
> +{
> + gchar *tmp;
> +
> + 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);
Shouldn't the individual unit tests clean these up? I think a flag
determining whether or not we're running locally (set by default
obviously) would be useful for determining whether it makes sense
for us to clean them up or not.
> +
> + 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_free(tmp);
> +
> + g_rmdir(fixture->test_dir);
> + g_free(fixture->test_dir);
> +}
> +
> +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;
> + char *s;
> + 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);
> + g_free(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;
> + guint32 v, r = g_random_int();
> + unsigned char c;
> + QDict *ret;
> + gchar *cmd;
> +
> + cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited',"
> + " 'arguments': {'id': %u } }", 0xff, r);
> + qmp_fd_send(fixture->fd, cmd);
> + g_free(cmd);
> +
> + v = read(fixture->fd, &c, 1);
> + g_assert_cmpint(v, ==, 1);
> + g_assert_cmpint(c, ==, 0xff);
> +
> + 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);
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_sync(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + guint32 v, r = g_random_int();
> + QDict *ret;
> + gchar *cmd;
> +
> + cmd = g_strdup_printf("%c{'execute': 'guest-sync',"
> + " 'arguments': {'id': %u } }", 0xff, r);
> + ret = qmp_fd(fixture->fd, cmd);
> + g_free(cmd);
> +
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> +
> + v = qdict_get_int(ret, "return");
> + g_assert_cmpint(r, ==, v);
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_ping(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> +
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_invalid_cmd(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret, *error;
> + 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);
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_info(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret, *val;
> + 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);
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_get_vcpus(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + 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);
> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id"));
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_get_fsinfo(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + QList *list;
> + const QListEntry *entry;
> +
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> +
> + /* check there is at least a fs */
> + list = qdict_get_qlist(ret, "return");
> + entry = qlist_first(list);
> + 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"));
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_get_memory_block_info(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret, *val;
> + int64_t size;
> +
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> +
> + /* check there is at least some memory */
> + val = qdict_get_qdict(ret, "return");
> + size = qdict_get_int(val, "size");
> + g_assert_cmpint(size, >, 0);
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_get_memory_blocks(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + QList *list;
> + const QListEntry *entry;
> +
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> +
> + list = qdict_get_qlist(ret, "return");
> + entry = qlist_first(list);
> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index"));
> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_network_get_interfaces(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + 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 a cpu */
copy/paste artifact
> + list = qdict_get_qlist(ret, "return");
> + entry = qlist_first(list);
> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_file_ops(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + gchar *cmd, *path;
> + const gchar *b64;
> + QDict *ret, *val;
> + int64_t id, count, eof;
> + 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");
> + QDECREF(ret);
> +
> + /* write */
> + cmd = g_strdup_printf("{'execute': 'guest-file-write',"
> + " 'arguments': { 'handle': %" G_GINT64_FORMAT ","
> + " 'buf-b64': 'aGVsbG8gd29ybGQK' } }", id);
> + ret = qmp_fd(fixture->fd, cmd);
> + 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, ==, 12);
> + g_assert_cmpint(eof, ==, 0);
> + QDECREF(ret);
> + g_free(cmd);
> +
> + /* flush */
> + cmd = g_strdup_printf("{'execute': 'guest-file-flush',"
> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
> + id);
> + ret = qmp_fd(fixture->fd, cmd);
> + QDECREF(ret);
> + g_free(cmd);
> +
> + /* close */
> + cmd = g_strdup_printf("{'execute': 'guest-file-close',"
> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
> + id);
> + ret = qmp_fd(fixture->fd, cmd);
> + QDECREF(ret);
> + g_free(cmd);
> +
> + /* check content */
> + path = g_build_filename(fixture->test_dir, "foo", NULL);
> + f = fopen(path, "r");
> + g_assert_nonnull(f);
> + count = fread(tmp, 1, sizeof(tmp), f);
> + g_assert_cmpint(count, ==, 12);
> + tmp[count] = 0;
> + g_assert_cmpstr(tmp, ==, "hello world\n");
> + 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");
> + QDECREF(ret);
> +
> + /* read */
> + cmd = g_strdup_printf("{'execute': 'guest-file-read',"
> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
> + id);
> + ret = qmp_fd(fixture->fd, cmd);
> + 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, ==, 12);
> + g_assert(eof);
> + g_assert_cmpstr(b64, ==, "aGVsbG8gd29ybGQK");
> +
> + QDECREF(ret);
> + g_free(cmd);
> +
> + /* read eof */
> + cmd = g_strdup_printf("{'execute': 'guest-file-read',"
> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
> + id);
> + ret = qmp_fd(fixture->fd, cmd);
> + 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, ==, "");
> + QDECREF(ret);
> + g_free(cmd);
> +
> + /* seek */
> + cmd = g_strdup_printf("{'execute': 'guest-file-seek',"
> + " 'arguments': { 'handle': %" G_GINT64_FORMAT ", "
> + " 'offset': %d, 'whence': %d } }",
> + id, 6, SEEK_SET);
> + ret = qmp_fd(fixture->fd, cmd);
> + 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);
> + QDECREF(ret);
> + g_free(cmd);
> +
> + /* partial read */
> + cmd = g_strdup_printf("{'execute': 'guest-file-read',"
> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
> + id);
> + ret = qmp_fd(fixture->fd, cmd);
> + 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, ==, 6);
> + g_assert(eof);
> + g_assert_cmpstr(b64, ==, "d29ybGQK");
> +
> + QDECREF(ret);
> + g_free(cmd);
> +
> + /* close */
> + cmd = g_strdup_printf("{'execute': 'guest-file-close',"
> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
> + id);
> + ret = qmp_fd(fixture->fd, cmd);
I like having a complex test to make sure all the guest-file-* commands
interact properly, but would be good if we could preceed this with
simpler guest-file-* tests that test each command more granularly.
That could be added as a follow-up though, since this is still a good
test to have.
> + QDECREF(ret);
> + g_free(cmd);
> +}
> +
> +static void test_qga_get_time(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + 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);
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_set_time(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + int64_t current, time;
> + gchar *cmd;
> +
> + /* get current time */
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> + current = qdict_get_int(ret, "return");
> + g_assert_cmpint(current, >, 0);
> + QDECREF(ret);
> +
> + /* set some old time */
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time',"
> + " 'arguments': { 'time': 1000 } }");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> + QDECREF(ret);
> +
> + /* check old 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 / 1000, <, G_USEC_PER_SEC * 10);
> + QDECREF(ret);
> +
> + /* set back current time */
> + cmd = g_strdup_printf("{'execute': 'guest-set-time',"
> + " 'arguments': { 'time': %" G_GINT64_FORMAT " } }",
> + current + time * 1000);
> + ret = qmp_fd(fixture->fd, cmd);
Little concerned about playing with host time in our unit tests. Maybe
this sort of test should only be enabled if a flag is set, and turned
of by default?
Ah, I see that's where running_in_virt() comes into play. Nice :)
> + g_free(cmd);
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> + QDECREF(ret);
> +}
> +
> +static void test_qga_fstrim(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + QList *list;
> + const QListEntry *entry;
> +
> + /* get current time */
copy/paste artifact
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim',"
> + " arguments: { minimum: 4194304 } }");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> + list = qdict_get_qlist(ret, "return");
> + entry = qlist_first(list);
> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths"));
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_blacklist(gconstpointer data)
> +{
> + TestFixture fix;
> + QDict *ret, *error;
> + const gchar *class, *desc;
> +
> + fixture_setup(&fix, "-b guest-ping,guest-get-time");
> +
> + /* check blacklist */
> + 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");
> + g_assert_cmpstr(class, ==, "GenericError");
> + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
> + QDECREF(ret);
> +
> + 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");
> + g_assert_cmpstr(class, ==, "GenericError");
> + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
> + QDECREF(ret);
> +
> + /* check something work */
> + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
> + qmp_assert_no_error(ret);
> + QDECREF(ret);
> +
> + fixture_tear_down(&fix, NULL);
> +}
> +
> +static void test_qga_fsfreeze_status(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + 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");
> +
> + QDECREF(ret);
> +}
> +
> +static void test_qga_fsfreeze_and_thaw(gconstpointer fix)
> +{
> + const TestFixture *fixture = fix;
> + QDict *ret;
> + const gchar *status;
> +
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> + QDECREF(ret);
> +
> + 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, ==, "frozen");
> + QDECREF(ret);
> +
> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}");
> + g_assert_nonnull(ret);
> + qmp_assert_no_error(ret);
> + QDECREF(ret);
> +}
> +
> +static gboolean running_in_virt(const gchar *virt)
> +{
> + gchar *virt_what = NULL;
> + gint status;
> + gboolean success;
> +
> + success = g_spawn_command_line_sync("virt-what", &virt_what, NULL,
> + &status, NULL);
> +
> + success = success && status == 0 && g_strcmp0(virt_what, virt);
> +
> + g_free(virt_what);
> +
> + return success;
> +}
> +int main(int argc, char **argv)
> +{
> + TestFixture fix;
> + int ret;
> +
> + setlocale (LC_ALL, "");
> + g_test_init(&argc, &argv, NULL);
> + fixture_setup(&fix, NULL);
> +
> + 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);
> + g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus);
> + 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);
> + g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time);
> + g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd);
> + g_test_add_data_func("/qga/fsfreeze-status", &fix,
> + test_qga_fsfreeze_status);
> +
> + g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist);
> +
> + if (running_in_virt("kvm")) {
> + g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix,
> + test_qga_fsfreeze_and_thaw);
> + g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time);
> + if (g_test_thorough()) {
> + g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim);
> + }
> + }
> +
> + ret = g_test_run();
> +
> + fixture_tear_down(&fix, NULL);
> +
> + return ret;
> +}
> --
> 2.4.3
>
^ permalink raw reply [flat|nested] 7+ messages in thread
* Re: [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent
2015-09-09 21:53 ` Michael Roth
@ 2015-09-11 17:46 ` Marc-André Lureau
0 siblings, 0 replies; 7+ messages in thread
From: Marc-André Lureau @ 2015-09-11 17:46 UTC (permalink / raw)
To: Michael Roth; +Cc: QEMU
Hi
On Wed, Sep 9, 2015 at 11:53 PM, Michael Roth <mdroth@linux.vnet.ibm.com> wrote:
> Quoting marcandre.lureau@redhat.com (2015-08-27 05:52:07)
>> From: Marc-André Lureau <marcandre.lureau@redhat.com>
>>
>> Add some local guest agent tests (as it is better than nothing).
>>
>> They can be run inside or outside a VM, when run inside a VM, they will
>> do a bit more side effects, such as freezing/thawing the FS or changing
>> the time.
>>
>> A better test would involve a managed VM (or container), but it might be
>> better to leave that off to autotest/avocado.
>>
>> Signed-off-by: Marc-André Lureau <marcandre.lureau@redhat.com>
>> ---
>> tests/Makefile | 3 +
>> tests/test-qga.c | 686 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
>> 2 files changed, 689 insertions(+)
>> create mode 100644 tests/test-qga.c
>>
>> diff --git a/tests/Makefile b/tests/Makefile
>> index 5271123..35671a1 100644
>> --- a/tests/Makefile
>> +++ b/tests/Makefile
>> @@ -76,6 +76,7 @@ check-unit-y += tests/test-write-threshold$(EXESUF)
>> gcov-files-test-write-threshold-y = block/write-threshold.c
>> check-unit-$(CONFIG_GNUTLS_HASH) += tests/test-crypto-hash$(EXESUF)
>> check-unit-y += tests/test-crypto-cipher$(EXESUF)
>> +check-unit-y += tests/test-qga$(EXESUF)
>>
>> check-block-$(CONFIG_POSIX) += tests/qemu-iotests-quick.sh
>>
>> @@ -425,6 +426,8 @@ endif
>> qtest-obj-y = tests/libqtest.o libqemuutil.a libqemustub.a
>> $(check-qtest-y): $(qtest-obj-y)
>>
>> +tests/test-qga: tests/test-qga.o $(qtest-obj-y)
>> +
>> .PHONY: check-help
>> check-help:
>> @echo "Regression testing targets:"
>> diff --git a/tests/test-qga.c b/tests/test-qga.c
>> new file mode 100644
>> index 0000000..1fb58ec
>> --- /dev/null
>> +++ b/tests/test-qga.c
>> @@ -0,0 +1,686 @@
>> +#include <locale.h>
>> +#include <glib.h>
>> +#include <glib/gstdio.h>
>> +#include <stdio.h>
>> +#include <stdlib.h>
>> +#include <errno.h>
>> +#include <string.h>
>> +#include <sys/types.h>
>> +#include <sys/socket.h>
>> +#include <sys/un.h>
>> +#include <unistd.h>
>> +
>> +#include "libqtest.h"
>> +#include "config-host.h"
>> +
>> +typedef struct {
>> + char *test_dir;
>> + GMainLoop *loop;
>> + int fd;
>> + GPid pid;
>> +} TestFixture;
>> +
>> +static int connect_qga(char *path)
>> +{
>> + int s, ret, len;
>> + 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);
>> + }
>> + } while (ret == -1);
>
> I think we should loop on ECONNREFUSED (or whatever corresponds to
> the socket not yet being created/bound), and the usual suspects
> like EINTR. If it's anything else I don't think we'd want this to
> loop indefinitely.
You get ENOENT while qga starts. I will just give up after 5 tries instead.
>> +
>> + 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
>> +fixture_setup(TestFixture *fixture, gconstpointer data)
>> +{
>> + const gchar *extra_arg = data;
>> + GError *error = NULL;
>> + gchar *cwd, *path, *cmd, **argv = NULL;
>> +
>> + fixture->loop = g_main_loop_new(NULL, FALSE);
>> +
>> + fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX");
>> + g_assert_nonnull(g_mkdtemp(fixture->test_dir));
>> +
>> + path = g_build_filename(fixture->test_dir, "sock", NULL);
>> + cwd = g_get_current_dir();
>> + cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s",
>
> Would be nice if we could also run qemu-ga.exe for a w32 build with
> binfmt set up like some of the other tests, but no idea how we'd get
> at it through wine. I guess it would have to be a serial connection
> or something...
>
> Probably too environment-specific for a useful unit test. I guess in
> the future we could plumb in custom qemu-ga invocation/script that
> does some extra setup on the backend (VM/container/wine) and exposes
> that via a local socket like we'd get via -chardev.
Perhaps it would be just too much at this point for a make check test,
better to leave that to autotest etc.
At this point, I propose we make it check-unit-$(CONFIG_LINUX).
>
>> + cwd, G_DIR_SEPARATOR,
>> + fixture->test_dir, path,
>> + getenv("QTEST_LOG") ? "-v" : "",
>> + extra_arg ?: "");
>> + g_shell_parse_argv(cmd, NULL, &argv, &error);
>> + g_assert_no_error(error);
>> +
>> + g_spawn_async(fixture->test_dir, argv, NULL,
>> + 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_strfreev(argv);
>> + g_free(cmd);
>> + g_free(cwd);
>> + g_free(path);
>> +}
>> +
>> +static void
>> +fixture_tear_down(TestFixture *fixture, gconstpointer data)
>> +{
>> + gchar *tmp;
>> +
>> + 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);
>
> Shouldn't the individual unit tests clean these up? I think a flag
> determining whether or not we're running locally (set by default
> obviously) would be useful for determining whether it makes sense
> for us to clean them up or not.
I started writing tests using test_add(), so qga would be started for
each tests, but the overhead was unnecessary. So it's just final
cleanup now.
>
>> +
>> + 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_free(tmp);
>> +
>> + g_rmdir(fixture->test_dir);
>> + g_free(fixture->test_dir);
>> +}
>> +
>> +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;
>> + char *s;
>> + 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);
>> + g_free(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;
>> + guint32 v, r = g_random_int();
>> + unsigned char c;
>> + QDict *ret;
>> + gchar *cmd;
>> +
>> + cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited',"
>> + " 'arguments': {'id': %u } }", 0xff, r);
>> + qmp_fd_send(fixture->fd, cmd);
>> + g_free(cmd);
>> +
>> + v = read(fixture->fd, &c, 1);
>> + g_assert_cmpint(v, ==, 1);
>> + g_assert_cmpint(c, ==, 0xff);
>> +
>> + 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);
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_sync(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + guint32 v, r = g_random_int();
>> + QDict *ret;
>> + gchar *cmd;
>> +
>> + cmd = g_strdup_printf("%c{'execute': 'guest-sync',"
>> + " 'arguments': {'id': %u } }", 0xff, r);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + g_free(cmd);
>> +
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> +
>> + v = qdict_get_int(ret, "return");
>> + g_assert_cmpint(r, ==, v);
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_ping(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> +
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_invalid_cmd(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret, *error;
>> + 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);
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_info(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret, *val;
>> + 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);
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_get_vcpus(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + 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);
>> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
>> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id"));
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_get_fsinfo(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + QList *list;
>> + const QListEntry *entry;
>> +
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> +
>> + /* check there is at least a fs */
>> + list = qdict_get_qlist(ret, "return");
>> + entry = qlist_first(list);
>> + 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"));
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_get_memory_block_info(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret, *val;
>> + int64_t size;
>> +
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> +
>> + /* check there is at least some memory */
>> + val = qdict_get_qdict(ret, "return");
>> + size = qdict_get_int(val, "size");
>> + g_assert_cmpint(size, >, 0);
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_get_memory_blocks(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + QList *list;
>> + const QListEntry *entry;
>> +
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> +
>> + list = qdict_get_qlist(ret, "return");
>> + entry = qlist_first(list);
>> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index"));
>> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_network_get_interfaces(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + 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 a cpu */
>
> copy/paste artifact
>
>> + list = qdict_get_qlist(ret, "return");
>> + entry = qlist_first(list);
>> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_file_ops(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + gchar *cmd, *path;
>> + const gchar *b64;
>> + QDict *ret, *val;
>> + int64_t id, count, eof;
>> + 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");
>> + QDECREF(ret);
>> +
>> + /* write */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-write',"
>> + " 'arguments': { 'handle': %" G_GINT64_FORMAT ","
>> + " 'buf-b64': 'aGVsbG8gd29ybGQK' } }", id);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + 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, ==, 12);
>> + g_assert_cmpint(eof, ==, 0);
>> + QDECREF(ret);
>> + g_free(cmd);
>> +
>> + /* flush */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-flush',"
>> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
>> + id);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + QDECREF(ret);
>> + g_free(cmd);
>> +
>> + /* close */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-close',"
>> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
>> + id);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + QDECREF(ret);
>> + g_free(cmd);
>> +
>> + /* check content */
>> + path = g_build_filename(fixture->test_dir, "foo", NULL);
>> + f = fopen(path, "r");
>> + g_assert_nonnull(f);
>> + count = fread(tmp, 1, sizeof(tmp), f);
>> + g_assert_cmpint(count, ==, 12);
>> + tmp[count] = 0;
>> + g_assert_cmpstr(tmp, ==, "hello world\n");
>> + 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");
>> + QDECREF(ret);
>> +
>> + /* read */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-read',"
>> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
>> + id);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + 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, ==, 12);
>> + g_assert(eof);
>> + g_assert_cmpstr(b64, ==, "aGVsbG8gd29ybGQK");
>> +
>> + QDECREF(ret);
>> + g_free(cmd);
>> +
>> + /* read eof */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-read',"
>> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
>> + id);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + 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, ==, "");
>> + QDECREF(ret);
>> + g_free(cmd);
>> +
>> + /* seek */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-seek',"
>> + " 'arguments': { 'handle': %" G_GINT64_FORMAT ", "
>> + " 'offset': %d, 'whence': %d } }",
>> + id, 6, SEEK_SET);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + 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);
>> + QDECREF(ret);
>> + g_free(cmd);
>> +
>> + /* partial read */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-read',"
>> + " 'arguments': { 'handle': %" G_GINT64_FORMAT "} }",
>> + id);
>> + ret = qmp_fd(fixture->fd, cmd);
>> + 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, ==, 6);
>> + g_assert(eof);
>> + g_assert_cmpstr(b64, ==, "d29ybGQK");
>> +
>> + QDECREF(ret);
>> + g_free(cmd);
>> +
>> + /* close */
>> + cmd = g_strdup_printf("{'execute': 'guest-file-close',"
>> + " 'arguments': {'handle': %" G_GINT64_FORMAT "} }",
>> + id);
>> + ret = qmp_fd(fixture->fd, cmd);
>
> I like having a complex test to make sure all the guest-file-* commands
> interact properly, but would be good if we could preceed this with
> simpler guest-file-* tests that test each command more granularly.
>
> That could be added as a follow-up though, since this is still a good
> test to have.
Ok, I'll leave this for now
>
>> + QDECREF(ret);
>> + g_free(cmd);
>> +}
>> +
>> +static void test_qga_get_time(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + 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);
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_set_time(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + int64_t current, time;
>> + gchar *cmd;
>> +
>> + /* get current time */
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> + current = qdict_get_int(ret, "return");
>> + g_assert_cmpint(current, >, 0);
>> + QDECREF(ret);
>> +
>> + /* set some old time */
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time',"
>> + " 'arguments': { 'time': 1000 } }");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> + QDECREF(ret);
>> +
>> + /* check old 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 / 1000, <, G_USEC_PER_SEC * 10);
>> + QDECREF(ret);
>> +
>> + /* set back current time */
>> + cmd = g_strdup_printf("{'execute': 'guest-set-time',"
>> + " 'arguments': { 'time': %" G_GINT64_FORMAT " } }",
>> + current + time * 1000);
>> + ret = qmp_fd(fixture->fd, cmd);
>
> Little concerned about playing with host time in our unit tests. Maybe
> this sort of test should only be enabled if a flag is set, and turned
> of by default?
>
> Ah, I see that's where running_in_virt() comes into play. Nice :)
Yes, but what are the odds to run the qga test on kvm guest with root
privileges? so I think it's fairly safe and still useful.
>
>> + g_free(cmd);
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_fstrim(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + QList *list;
>> + const QListEntry *entry;
>> +
>> + /* get current time */
>
> copy/paste artifact
correct, removed
>
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim',"
>> + " arguments: { minimum: 4194304 } }");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> + list = qdict_get_qlist(ret, "return");
>> + entry = qlist_first(list);
>> + g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths"));
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_blacklist(gconstpointer data)
>> +{
>> + TestFixture fix;
>> + QDict *ret, *error;
>> + const gchar *class, *desc;
>> +
>> + fixture_setup(&fix, "-b guest-ping,guest-get-time");
>> +
>> + /* check blacklist */
>> + 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");
>> + g_assert_cmpstr(class, ==, "GenericError");
>> + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
>> + QDECREF(ret);
>> +
>> + 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");
>> + g_assert_cmpstr(class, ==, "GenericError");
>> + g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
>> + QDECREF(ret);
>> +
>> + /* check something work */
>> + ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
>> + qmp_assert_no_error(ret);
>> + QDECREF(ret);
>> +
>> + fixture_tear_down(&fix, NULL);
>> +}
>> +
>> +static void test_qga_fsfreeze_status(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + 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");
>> +
>> + QDECREF(ret);
>> +}
>> +
>> +static void test_qga_fsfreeze_and_thaw(gconstpointer fix)
>> +{
>> + const TestFixture *fixture = fix;
>> + QDict *ret;
>> + const gchar *status;
>> +
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> + QDECREF(ret);
>> +
>> + 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, ==, "frozen");
>> + QDECREF(ret);
>> +
>> + ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}");
>> + g_assert_nonnull(ret);
>> + qmp_assert_no_error(ret);
>> + QDECREF(ret);
>> +}
>> +
>> +static gboolean running_in_virt(const gchar *virt)
>> +{
>> + gchar *virt_what = NULL;
>> + gint status;
>> + gboolean success;
>> +
>> + success = g_spawn_command_line_sync("virt-what", &virt_what, NULL,
>> + &status, NULL);
>> +
>> + success = success && status == 0 && g_strcmp0(virt_what, virt);
>> +
>> + g_free(virt_what);
>> +
>> + return success;
>> +}
>> +int main(int argc, char **argv)
>> +{
>> + TestFixture fix;
>> + int ret;
>> +
>> + setlocale (LC_ALL, "");
>> + g_test_init(&argc, &argv, NULL);
>> + fixture_setup(&fix, NULL);
>> +
>> + 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);
>> + g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus);
>> + 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);
>> + g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time);
>> + g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd);
>> + g_test_add_data_func("/qga/fsfreeze-status", &fix,
>> + test_qga_fsfreeze_status);
>> +
>> + g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist);
>> +
>> + if (running_in_virt("kvm")) {
>> + g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix,
>> + test_qga_fsfreeze_and_thaw);
>> + g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time);
>> + if (g_test_thorough()) {
>> + g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim);
>> + }
>> + }
>> +
>> + ret = g_test_run();
>> +
>> + fixture_tear_down(&fix, NULL);
>> +
>> + return ret;
>> +}
>> --
>> 2.4.3
>>
>
>
thanks
--
Marc-André Lureau
^ permalink raw reply [flat|nested] 7+ messages in thread
end of thread, other threads:[~2015-09-11 17:46 UTC | newest]
Thread overview: 7+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2015-08-27 10:52 [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers marcandre.lureau
2015-08-27 10:52 ` [Qemu-devel] [PATCH 2/2] tests: add a local test for guest agent marcandre.lureau
2015-08-27 11:36 ` Marc-André Lureau
2015-09-09 17:36 ` Michael Roth
2015-09-09 21:53 ` Michael Roth
2015-09-11 17:46 ` Marc-André Lureau
2015-09-09 20:05 ` [Qemu-devel] [PATCH 1/2] qtest: add a few fd-level qmp helpers Michael Roth
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).