1 #include "qemu/osdep.h"
4 #include <glib/gstdio.h>
5 #include <sys/socket.h>
17 static int connect_qga(char *path)
19 int s, ret, len, i = 0;
20 struct sockaddr_un remote;
22 s = socket(AF_UNIX, SOCK_STREAM, 0);
25 remote.sun_family = AF_UNIX;
27 strcpy(remote.sun_path, path);
28 len = strlen(remote.sun_path) + sizeof(remote.sun_family);
29 ret = connect(s, (struct sockaddr *)&remote, len);
31 g_usleep(G_USEC_PER_SEC);
41 static void qga_watch(GPid pid, gint status, gpointer user_data)
43 TestFixture *fixture = user_data;
45 g_assert_cmpint(status, ==, 0);
46 g_main_loop_quit(fixture->loop);
50 fixture_setup(TestFixture *fixture, gconstpointer data)
52 const gchar *extra_arg = data;
54 gchar *cwd, *path, *cmd, **argv = NULL;
56 fixture->loop = g_main_loop_new(NULL, FALSE);
58 fixture->test_dir = g_strdup("/tmp/qgatest.XXXXXX");
59 g_assert_nonnull(mkdtemp(fixture->test_dir));
61 path = g_build_filename(fixture->test_dir, "sock", NULL);
62 cwd = g_get_current_dir();
63 cmd = g_strdup_printf("%s%cqemu-ga -m unix-listen -t %s -p %s %s %s",
65 fixture->test_dir, path,
66 getenv("QTEST_LOG") ? "-v" : "",
68 g_shell_parse_argv(cmd, NULL, &argv, &error);
69 g_assert_no_error(error);
71 g_spawn_async(fixture->test_dir, argv, NULL,
72 G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
73 NULL, NULL, &fixture->pid, &error);
74 g_assert_no_error(error);
76 g_child_watch_add(fixture->pid, qga_watch, fixture);
78 fixture->fd = connect_qga(path);
79 g_assert_cmpint(fixture->fd, !=, -1);
88 fixture_tear_down(TestFixture *fixture, gconstpointer data)
92 kill(fixture->pid, SIGTERM);
94 g_main_loop_run(fixture->loop);
95 g_main_loop_unref(fixture->loop);
97 g_spawn_close_pid(fixture->pid);
99 tmp = g_build_filename(fixture->test_dir, "foo", NULL);
103 tmp = g_build_filename(fixture->test_dir, "qga.state", NULL);
107 tmp = g_build_filename(fixture->test_dir, "sock", NULL);
111 g_rmdir(fixture->test_dir);
112 g_free(fixture->test_dir);
115 static void qmp_assertion_message_error(const char *domain,
122 const char *class, *desc;
126 error = qdict_get_qdict(dict, "error");
127 class = qdict_get_try_str(error, "class");
128 desc = qdict_get_try_str(error, "desc");
130 s = g_strdup_printf("assertion failed %s: %s %s", expr, class, desc);
131 g_assertion_message(domain, file, line, func, s);
135 #define qmp_assert_no_error(err) do { \
136 if (qdict_haskey(err, "error")) { \
137 qmp_assertion_message_error(G_LOG_DOMAIN, __FILE__, __LINE__, \
138 G_STRFUNC, #err, err); \
142 static void test_qga_sync_delimited(gconstpointer fix)
144 const TestFixture *fixture = fix;
145 guint32 v, r = g_random_int();
150 cmd = g_strdup_printf("%c{'execute': 'guest-sync-delimited',"
151 " 'arguments': {'id': %u } }", 0xff, r);
152 qmp_fd_send(fixture->fd, cmd);
155 v = read(fixture->fd, &c, 1);
156 g_assert_cmpint(v, ==, 1);
157 g_assert_cmpint(c, ==, 0xff);
159 ret = qmp_fd_receive(fixture->fd);
160 g_assert_nonnull(ret);
161 qmp_assert_no_error(ret);
163 v = qdict_get_int(ret, "return");
164 g_assert_cmpint(r, ==, v);
169 static void test_qga_sync(gconstpointer fix)
171 const TestFixture *fixture = fix;
172 guint32 v, r = g_random_int();
176 cmd = g_strdup_printf("%c{'execute': 'guest-sync',"
177 " 'arguments': {'id': %u } }", 0xff, r);
178 ret = qmp_fd(fixture->fd, cmd);
181 g_assert_nonnull(ret);
182 qmp_assert_no_error(ret);
184 v = qdict_get_int(ret, "return");
185 g_assert_cmpint(r, ==, v);
190 static void test_qga_ping(gconstpointer fix)
192 const TestFixture *fixture = fix;
195 ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping'}");
196 g_assert_nonnull(ret);
197 qmp_assert_no_error(ret);
202 static void test_qga_invalid_cmd(gconstpointer fix)
204 const TestFixture *fixture = fix;
206 const gchar *class, *desc;
208 ret = qmp_fd(fixture->fd, "{'execute': 'guest-invalid-cmd'}");
209 g_assert_nonnull(ret);
211 error = qdict_get_qdict(ret, "error");
212 class = qdict_get_try_str(error, "class");
213 desc = qdict_get_try_str(error, "desc");
215 g_assert_cmpstr(class, ==, "CommandNotFound");
216 g_assert_cmpint(strlen(desc), >, 0);
221 static void test_qga_info(gconstpointer fix)
223 const TestFixture *fixture = fix;
225 const gchar *version;
227 ret = qmp_fd(fixture->fd, "{'execute': 'guest-info'}");
228 g_assert_nonnull(ret);
229 qmp_assert_no_error(ret);
231 val = qdict_get_qdict(ret, "return");
232 version = qdict_get_try_str(val, "version");
233 g_assert_cmpstr(version, ==, QEMU_VERSION);
238 static void test_qga_get_vcpus(gconstpointer fix)
240 const TestFixture *fixture = fix;
243 const QListEntry *entry;
245 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-vcpus'}");
246 g_assert_nonnull(ret);
247 qmp_assert_no_error(ret);
249 /* check there is at least a cpu */
250 list = qdict_get_qlist(ret, "return");
251 entry = qlist_first(list);
252 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
253 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "logical-id"));
258 static void test_qga_get_fsinfo(gconstpointer fix)
260 const TestFixture *fixture = fix;
263 const QListEntry *entry;
265 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-fsinfo'}");
266 g_assert_nonnull(ret);
267 qmp_assert_no_error(ret);
269 /* sanity-check the response if there are any filesystems */
270 list = qdict_get_qlist(ret, "return");
271 entry = qlist_first(list);
273 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
274 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "mountpoint"));
275 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "type"));
276 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "disk"));
282 static void test_qga_get_memory_block_info(gconstpointer fix)
284 const TestFixture *fixture = fix;
288 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-block-info'}");
289 g_assert_nonnull(ret);
291 /* some systems might not expose memory block info in sysfs */
292 if (!qdict_haskey(ret, "error")) {
293 /* check there is at least some memory */
294 val = qdict_get_qdict(ret, "return");
295 size = qdict_get_int(val, "size");
296 g_assert_cmpint(size, >, 0);
302 static void test_qga_get_memory_blocks(gconstpointer fix)
304 const TestFixture *fixture = fix;
307 const QListEntry *entry;
309 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-memory-blocks'}");
310 g_assert_nonnull(ret);
312 /* some systems might not expose memory block info in sysfs */
313 if (!qdict_haskey(ret, "error")) {
314 list = qdict_get_qlist(ret, "return");
315 entry = qlist_first(list);
316 /* newer versions of qga may return empty list without error */
318 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "phys-index"));
319 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "online"));
326 static void test_qga_network_get_interfaces(gconstpointer fix)
328 const TestFixture *fixture = fix;
331 const QListEntry *entry;
333 ret = qmp_fd(fixture->fd, "{'execute': 'guest-network-get-interfaces'}");
334 g_assert_nonnull(ret);
335 qmp_assert_no_error(ret);
337 /* check there is at least an interface */
338 list = qdict_get_qlist(ret, "return");
339 entry = qlist_first(list);
340 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "name"));
345 static void test_qga_file_ops(gconstpointer fix)
347 const TestFixture *fixture = fix;
348 const unsigned char helloworld[] = "Hello World!\n";
350 gchar *cmd, *path, *enc;
359 ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
360 " 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
361 g_assert_nonnull(ret);
362 qmp_assert_no_error(ret);
363 id = qdict_get_int(ret, "return");
366 enc = g_base64_encode(helloworld, sizeof(helloworld));
368 cmd = g_strdup_printf("{'execute': 'guest-file-write',"
369 " 'arguments': { 'handle': %" PRId64 ","
370 " 'buf-b64': '%s' } }", id, enc);
371 ret = qmp_fd(fixture->fd, cmd);
372 g_assert_nonnull(ret);
373 qmp_assert_no_error(ret);
375 val = qdict_get_qdict(ret, "return");
376 count = qdict_get_int(val, "count");
377 eof = qdict_get_bool(val, "eof");
378 g_assert_cmpint(count, ==, sizeof(helloworld));
379 g_assert_cmpint(eof, ==, 0);
384 cmd = g_strdup_printf("{'execute': 'guest-file-flush',"
385 " 'arguments': {'handle': %" PRId64 "} }",
387 ret = qmp_fd(fixture->fd, cmd);
392 cmd = g_strdup_printf("{'execute': 'guest-file-close',"
393 " 'arguments': {'handle': %" PRId64 "} }",
395 ret = qmp_fd(fixture->fd, cmd);
400 path = g_build_filename(fixture->test_dir, "foo", NULL);
401 f = fopen(path, "r");
403 count = fread(tmp, 1, sizeof(tmp), f);
404 g_assert_cmpint(count, ==, sizeof(helloworld));
406 g_assert_cmpstr(tmp, ==, (char *)helloworld);
410 ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
411 " 'arguments': { 'path': 'foo', 'mode': 'r' } }");
412 g_assert_nonnull(ret);
413 qmp_assert_no_error(ret);
414 id = qdict_get_int(ret, "return");
418 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
419 " 'arguments': { 'handle': %" PRId64 "} }",
421 ret = qmp_fd(fixture->fd, cmd);
422 val = qdict_get_qdict(ret, "return");
423 count = qdict_get_int(val, "count");
424 eof = qdict_get_bool(val, "eof");
425 b64 = qdict_get_str(val, "buf-b64");
426 g_assert_cmpint(count, ==, sizeof(helloworld));
428 g_assert_cmpstr(b64, ==, enc);
435 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
436 " 'arguments': { 'handle': %" PRId64 "} }",
438 ret = qmp_fd(fixture->fd, cmd);
439 val = qdict_get_qdict(ret, "return");
440 count = qdict_get_int(val, "count");
441 eof = qdict_get_bool(val, "eof");
442 b64 = qdict_get_str(val, "buf-b64");
443 g_assert_cmpint(count, ==, 0);
445 g_assert_cmpstr(b64, ==, "");
450 cmd = g_strdup_printf("{'execute': 'guest-file-seek',"
451 " 'arguments': { 'handle': %" PRId64 ", "
452 " 'offset': %d, 'whence': '%s' } }",
454 ret = qmp_fd(fixture->fd, cmd);
455 qmp_assert_no_error(ret);
456 val = qdict_get_qdict(ret, "return");
457 count = qdict_get_int(val, "position");
458 eof = qdict_get_bool(val, "eof");
459 g_assert_cmpint(count, ==, 6);
465 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
466 " 'arguments': { 'handle': %" PRId64 "} }",
468 ret = qmp_fd(fixture->fd, cmd);
469 val = qdict_get_qdict(ret, "return");
470 count = qdict_get_int(val, "count");
471 eof = qdict_get_bool(val, "eof");
472 b64 = qdict_get_str(val, "buf-b64");
473 g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
475 dec = g_base64_decode(b64, &count);
476 g_assert_cmpint(count, ==, sizeof(helloworld) - 6);
477 g_assert_cmpmem(dec, count, helloworld + 6, sizeof(helloworld) - 6);
484 cmd = g_strdup_printf("{'execute': 'guest-file-close',"
485 " 'arguments': {'handle': %" PRId64 "} }",
487 ret = qmp_fd(fixture->fd, cmd);
492 static void test_qga_file_write_read(gconstpointer fix)
494 const TestFixture *fixture = fix;
495 const unsigned char helloworld[] = "Hello World!\n";
503 ret = qmp_fd(fixture->fd, "{'execute': 'guest-file-open',"
504 " 'arguments': { 'path': 'foo', 'mode': 'w+' } }");
505 g_assert_nonnull(ret);
506 qmp_assert_no_error(ret);
507 id = qdict_get_int(ret, "return");
510 enc = g_base64_encode(helloworld, sizeof(helloworld));
512 cmd = g_strdup_printf("{'execute': 'guest-file-write',"
513 " 'arguments': { 'handle': %" PRId64 ","
514 " 'buf-b64': '%s' } }", id, enc);
515 ret = qmp_fd(fixture->fd, cmd);
516 g_assert_nonnull(ret);
517 qmp_assert_no_error(ret);
519 val = qdict_get_qdict(ret, "return");
520 count = qdict_get_int(val, "count");
521 eof = qdict_get_bool(val, "eof");
522 g_assert_cmpint(count, ==, sizeof(helloworld));
523 g_assert_cmpint(eof, ==, 0);
527 /* read (check implicit flush) */
528 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
529 " 'arguments': { 'handle': %" PRId64 "} }",
531 ret = qmp_fd(fixture->fd, cmd);
532 val = qdict_get_qdict(ret, "return");
533 count = qdict_get_int(val, "count");
534 eof = qdict_get_bool(val, "eof");
535 b64 = qdict_get_str(val, "buf-b64");
536 g_assert_cmpint(count, ==, 0);
538 g_assert_cmpstr(b64, ==, "");
543 cmd = g_strdup_printf("{'execute': 'guest-file-seek',"
544 " 'arguments': { 'handle': %" PRId64 ", "
545 " 'offset': %d, 'whence': '%s' } }",
547 ret = qmp_fd(fixture->fd, cmd);
548 qmp_assert_no_error(ret);
549 val = qdict_get_qdict(ret, "return");
550 count = qdict_get_int(val, "position");
551 eof = qdict_get_bool(val, "eof");
552 g_assert_cmpint(count, ==, 0);
558 cmd = g_strdup_printf("{'execute': 'guest-file-read',"
559 " 'arguments': { 'handle': %" PRId64 "} }",
561 ret = qmp_fd(fixture->fd, cmd);
562 val = qdict_get_qdict(ret, "return");
563 count = qdict_get_int(val, "count");
564 eof = qdict_get_bool(val, "eof");
565 b64 = qdict_get_str(val, "buf-b64");
566 g_assert_cmpint(count, ==, sizeof(helloworld));
568 g_assert_cmpstr(b64, ==, enc);
574 cmd = g_strdup_printf("{'execute': 'guest-file-close',"
575 " 'arguments': {'handle': %" PRId64 "} }",
577 ret = qmp_fd(fixture->fd, cmd);
582 static void test_qga_get_time(gconstpointer fix)
584 const TestFixture *fixture = fix;
588 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
589 g_assert_nonnull(ret);
590 qmp_assert_no_error(ret);
592 time = qdict_get_int(ret, "return");
593 g_assert_cmpint(time, >, 0);
598 static void test_qga_set_time(gconstpointer fix)
600 const TestFixture *fixture = fix;
602 int64_t current, time;
605 /* get current time */
606 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
607 g_assert_nonnull(ret);
608 qmp_assert_no_error(ret);
609 current = qdict_get_int(ret, "return");
610 g_assert_cmpint(current, >, 0);
613 /* set some old time */
614 ret = qmp_fd(fixture->fd, "{'execute': 'guest-set-time',"
615 " 'arguments': { 'time': 1000 } }");
616 g_assert_nonnull(ret);
617 qmp_assert_no_error(ret);
621 ret = qmp_fd(fixture->fd, "{'execute': 'guest-get-time'}");
622 g_assert_nonnull(ret);
623 qmp_assert_no_error(ret);
624 time = qdict_get_int(ret, "return");
625 g_assert_cmpint(time / 1000, <, G_USEC_PER_SEC * 10);
628 /* set back current time */
629 cmd = g_strdup_printf("{'execute': 'guest-set-time',"
630 " 'arguments': { 'time': %" PRId64 " } }",
631 current + time * 1000);
632 ret = qmp_fd(fixture->fd, cmd);
634 g_assert_nonnull(ret);
635 qmp_assert_no_error(ret);
639 static void test_qga_fstrim(gconstpointer fix)
641 const TestFixture *fixture = fix;
644 const QListEntry *entry;
646 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fstrim',"
647 " arguments: { minimum: 4194304 } }");
648 g_assert_nonnull(ret);
649 qmp_assert_no_error(ret);
650 list = qdict_get_qlist(ret, "return");
651 entry = qlist_first(list);
652 g_assert(qdict_haskey(qobject_to_qdict(entry->value), "paths"));
657 static void test_qga_blacklist(gconstpointer data)
661 const gchar *class, *desc;
663 fixture_setup(&fix, "-b guest-ping,guest-get-time");
665 /* check blacklist */
666 ret = qmp_fd(fix.fd, "{'execute': 'guest-ping'}");
667 g_assert_nonnull(ret);
668 error = qdict_get_qdict(ret, "error");
669 class = qdict_get_try_str(error, "class");
670 desc = qdict_get_try_str(error, "desc");
671 g_assert_cmpstr(class, ==, "GenericError");
672 g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
675 ret = qmp_fd(fix.fd, "{'execute': 'guest-get-time'}");
676 g_assert_nonnull(ret);
677 error = qdict_get_qdict(ret, "error");
678 class = qdict_get_try_str(error, "class");
679 desc = qdict_get_try_str(error, "desc");
680 g_assert_cmpstr(class, ==, "GenericError");
681 g_assert_nonnull(g_strstr_len(desc, -1, "has been disabled"));
684 /* check something work */
685 ret = qmp_fd(fix.fd, "{'execute': 'guest-get-fsinfo'}");
686 qmp_assert_no_error(ret);
689 fixture_tear_down(&fix, NULL);
692 static void test_qga_config(gconstpointer data)
694 GError *error = NULL;
695 char *cwd, *cmd, *out, *err, *str, **strv, *conf, **argv = NULL;
700 const char *qga_config =
703 "method=virtio-serial\n"
704 "path=/path/to/org.qemu.guest_agent.0\n"
705 "pidfile=/var/foo/qemu-ga.pid\n"
706 "statedir=/var/state\n"
708 "blacklist=guest-ping;guest-get-time\n";
710 tmp = g_file_open_tmp(NULL, &conf, &error);
711 g_assert_no_error(error);
712 g_assert_cmpint(tmp, >=, 0);
713 g_assert_cmpstr(conf, !=, "");
715 g_file_set_contents(conf, qga_config, -1, &error);
716 g_assert_no_error(error);
718 cwd = g_get_current_dir();
719 cmd = g_strdup_printf("%s%cqemu-ga -D",
720 cwd, G_DIR_SEPARATOR);
721 g_shell_parse_argv(cmd, NULL, &argv, &error);
722 g_assert_no_error(error);
724 env[0] = g_strdup_printf("QGA_CONF=%s", conf);
726 g_spawn_sync(NULL, argv, env, 0,
727 NULL, NULL, &out, &err, &status, &error);
728 g_assert_no_error(error);
729 g_assert_cmpstr(err, ==, "");
730 g_assert_cmpint(status, ==, 0);
732 kf = g_key_file_new();
733 g_key_file_load_from_data(kf, out, -1, G_KEY_FILE_NONE, &error);
734 g_assert_no_error(error);
736 str = g_key_file_get_start_group(kf);
737 g_assert_cmpstr(str, ==, "general");
740 g_assert_false(g_key_file_get_boolean(kf, "general", "daemon", &error));
741 g_assert_no_error(error);
743 str = g_key_file_get_string(kf, "general", "method", &error);
744 g_assert_no_error(error);
745 g_assert_cmpstr(str, ==, "virtio-serial");
748 str = g_key_file_get_string(kf, "general", "path", &error);
749 g_assert_no_error(error);
750 g_assert_cmpstr(str, ==, "/path/to/org.qemu.guest_agent.0");
753 str = g_key_file_get_string(kf, "general", "pidfile", &error);
754 g_assert_no_error(error);
755 g_assert_cmpstr(str, ==, "/var/foo/qemu-ga.pid");
758 str = g_key_file_get_string(kf, "general", "statedir", &error);
759 g_assert_no_error(error);
760 g_assert_cmpstr(str, ==, "/var/state");
763 g_assert_true(g_key_file_get_boolean(kf, "general", "verbose", &error));
764 g_assert_no_error(error);
766 strv = g_key_file_get_string_list(kf, "general", "blacklist", &n, &error);
767 g_assert_cmpint(n, ==, 2);
768 #if GLIB_CHECK_VERSION(2, 44, 0)
769 g_assert_true(g_strv_contains((const char * const *)strv,
771 g_assert_true(g_strv_contains((const char * const *)strv,
774 g_assert_no_error(error);
786 static void test_qga_fsfreeze_status(gconstpointer fix)
788 const TestFixture *fixture = fix;
792 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}");
793 g_assert_nonnull(ret);
794 qmp_assert_no_error(ret);
796 status = qdict_get_try_str(ret, "return");
797 g_assert_cmpstr(status, ==, "thawed");
802 static void test_qga_fsfreeze_and_thaw(gconstpointer fix)
804 const TestFixture *fixture = fix;
808 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-freeze'}");
809 g_assert_nonnull(ret);
810 qmp_assert_no_error(ret);
813 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-status'}");
814 g_assert_nonnull(ret);
815 qmp_assert_no_error(ret);
816 status = qdict_get_try_str(ret, "return");
817 g_assert_cmpstr(status, ==, "frozen");
820 ret = qmp_fd(fixture->fd, "{'execute': 'guest-fsfreeze-thaw'}");
821 g_assert_nonnull(ret);
822 qmp_assert_no_error(ret);
826 int main(int argc, char **argv)
831 setlocale (LC_ALL, "");
832 g_test_init(&argc, &argv, NULL);
833 fixture_setup(&fix, NULL);
835 g_test_add_data_func("/qga/sync-delimited", &fix, test_qga_sync_delimited);
836 g_test_add_data_func("/qga/sync", &fix, test_qga_sync);
837 g_test_add_data_func("/qga/ping", &fix, test_qga_ping);
838 g_test_add_data_func("/qga/info", &fix, test_qga_info);
839 g_test_add_data_func("/qga/network-get-interfaces", &fix,
840 test_qga_network_get_interfaces);
841 g_test_add_data_func("/qga/get-vcpus", &fix, test_qga_get_vcpus);
842 g_test_add_data_func("/qga/get-fsinfo", &fix, test_qga_get_fsinfo);
843 g_test_add_data_func("/qga/get-memory-block-info", &fix,
844 test_qga_get_memory_block_info);
845 g_test_add_data_func("/qga/get-memory-blocks", &fix,
846 test_qga_get_memory_blocks);
847 g_test_add_data_func("/qga/file-ops", &fix, test_qga_file_ops);
848 g_test_add_data_func("/qga/file-write-read", &fix, test_qga_file_write_read);
849 g_test_add_data_func("/qga/get-time", &fix, test_qga_get_time);
850 g_test_add_data_func("/qga/invalid-cmd", &fix, test_qga_invalid_cmd);
851 g_test_add_data_func("/qga/fsfreeze-status", &fix,
852 test_qga_fsfreeze_status);
854 g_test_add_data_func("/qga/blacklist", NULL, test_qga_blacklist);
855 g_test_add_data_func("/qga/config", NULL, test_qga_config);
857 if (g_getenv("QGA_TEST_SIDE_EFFECTING")) {
858 g_test_add_data_func("/qga/fsfreeze-and-thaw", &fix,
859 test_qga_fsfreeze_and_thaw);
860 g_test_add_data_func("/qga/set-time", &fix, test_qga_set_time);
861 g_test_add_data_func("/qga/fstrim", &fix, test_qga_fstrim);
866 fixture_tear_down(&fix, NULL);