1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 /* This will be 's' or 'h' depending on whether the guest kernel
35 * names IDE devices /dev/sd* or /dev/hd*.
37 static char devchar = 's';
39 static void print_error (guestfs_h *g, void *data, const char *msg)
42 fprintf (stderr, "%s\n", msg);
45 static void print_strings (char * const * const argv)
49 for (argc = 0; argv[argc] != NULL; ++argc)
50 printf ("\t%s\n", argv[argc]);
54 static void print_table (char * const * const argv)
58 for (i = 0; argv[i] != NULL; i += 2)
59 printf ("%s: %s\n", argv[i], argv[i+1]);
63 static void no_test_warnings (void)
65 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
121 static int test_zerofree_0 (void)
123 /* TestOutput for zerofree (0) */
124 char expected[] = "test file";
126 char device[] = "/dev/sda";
128 char lines_0[] = ",";
135 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
140 char fstype[] = "ext3";
141 char device[] = "/dev/sda1";
145 r = guestfs_mkfs (g, fstype, device);
150 char device[] = "/dev/sda1";
152 char mountpoint[] = "/";
155 r = guestfs_mount (g, device, mountpoint);
160 char path[] = "/new";
161 char content[] = "test file";
164 r = guestfs_write_file (g, path, content, 0);
169 char pathordevice[] = "/dev/sda1";
170 pathordevice[5] = devchar;
173 r = guestfs_umount (g, pathordevice);
178 char device[] = "/dev/sda1";
182 r = guestfs_zerofree (g, device);
187 char device[] = "/dev/sda1";
189 char mountpoint[] = "/";
192 r = guestfs_mount (g, device, mountpoint);
197 char path[] = "/new";
200 r = guestfs_cat (g, path);
203 if (strcmp (r, expected) != 0) {
204 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
212 static int test_hexdump_0 (void)
214 /* InitBasicFS for hexdump (0): create ext2 on /dev/sda1 */
216 char device[] = "/dev/sda";
220 r = guestfs_blockdev_setrw (g, device);
227 r = guestfs_umount_all (g);
234 r = guestfs_lvm_remove_all (g);
239 char device[] = "/dev/sda";
241 char lines_0[] = ",";
248 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
253 char fstype[] = "ext2";
254 char device[] = "/dev/sda1";
258 r = guestfs_mkfs (g, fstype, device);
263 char device[] = "/dev/sda1";
265 char mountpoint[] = "/";
268 r = guestfs_mount (g, device, mountpoint);
272 /* TestOutput for hexdump (0) */
273 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
275 char path[] = "/new";
276 char content[] = "hello\nworld\n";
279 r = guestfs_write_file (g, path, content, 12);
284 char path[] = "/new";
287 r = guestfs_hexdump (g, path);
290 if (strcmp (r, expected) != 0) {
291 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
299 static int test_strings_e_0 (void)
301 /* InitBasicFS for strings_e (0): create ext2 on /dev/sda1 */
303 char device[] = "/dev/sda";
307 r = guestfs_blockdev_setrw (g, device);
314 r = guestfs_umount_all (g);
321 r = guestfs_lvm_remove_all (g);
326 char device[] = "/dev/sda";
328 char lines_0[] = ",";
335 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
340 char fstype[] = "ext2";
341 char device[] = "/dev/sda1";
345 r = guestfs_mkfs (g, fstype, device);
350 char device[] = "/dev/sda1";
352 char mountpoint[] = "/";
355 r = guestfs_mount (g, device, mountpoint);
359 /* TestOutputList for strings_e (0) */
361 char path[] = "/new";
362 char content[] = "hello\nworld\n";
365 r = guestfs_write_file (g, path, content, 0);
370 char encoding[] = "b";
371 char path[] = "/new";
375 r = guestfs_strings_e (g, encoding, path);
379 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
383 for (i = 0; r[i] != NULL; ++i)
390 static int test_strings_e_1 (void)
392 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
396 static int test_strings_0 (void)
398 /* InitBasicFS for strings (0): create ext2 on /dev/sda1 */
400 char device[] = "/dev/sda";
404 r = guestfs_blockdev_setrw (g, device);
411 r = guestfs_umount_all (g);
418 r = guestfs_lvm_remove_all (g);
423 char device[] = "/dev/sda";
425 char lines_0[] = ",";
432 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
437 char fstype[] = "ext2";
438 char device[] = "/dev/sda1";
442 r = guestfs_mkfs (g, fstype, device);
447 char device[] = "/dev/sda1";
449 char mountpoint[] = "/";
452 r = guestfs_mount (g, device, mountpoint);
456 /* TestOutputList for strings (0) */
458 char path[] = "/new";
459 char content[] = "hello\nworld\n";
462 r = guestfs_write_file (g, path, content, 0);
467 char path[] = "/new";
471 r = guestfs_strings (g, path);
475 fprintf (stderr, "test_strings_0: short list returned from command\n");
480 char expected[] = "hello";
481 if (strcmp (r[0], expected) != 0) {
482 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
487 fprintf (stderr, "test_strings_0: short list returned from command\n");
492 char expected[] = "world";
493 if (strcmp (r[1], expected) != 0) {
494 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
499 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
503 for (i = 0; r[i] != NULL; ++i)
510 static int test_strings_1 (void)
512 /* InitBasicFS for strings (1): create ext2 on /dev/sda1 */
514 char device[] = "/dev/sda";
518 r = guestfs_blockdev_setrw (g, device);
525 r = guestfs_umount_all (g);
532 r = guestfs_lvm_remove_all (g);
537 char device[] = "/dev/sda";
539 char lines_0[] = ",";
546 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
551 char fstype[] = "ext2";
552 char device[] = "/dev/sda1";
556 r = guestfs_mkfs (g, fstype, device);
561 char device[] = "/dev/sda1";
563 char mountpoint[] = "/";
566 r = guestfs_mount (g, device, mountpoint);
570 /* TestOutputList for strings (1) */
572 char path[] = "/new";
575 r = guestfs_touch (g, path);
580 char path[] = "/new";
584 r = guestfs_strings (g, path);
588 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
592 for (i = 0; r[i] != NULL; ++i)
599 static int test_equal_0 (void)
601 /* InitBasicFS for equal (0): create ext2 on /dev/sda1 */
603 char device[] = "/dev/sda";
607 r = guestfs_blockdev_setrw (g, device);
614 r = guestfs_umount_all (g);
621 r = guestfs_lvm_remove_all (g);
626 char device[] = "/dev/sda";
628 char lines_0[] = ",";
635 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
640 char fstype[] = "ext2";
641 char device[] = "/dev/sda1";
645 r = guestfs_mkfs (g, fstype, device);
650 char device[] = "/dev/sda1";
652 char mountpoint[] = "/";
655 r = guestfs_mount (g, device, mountpoint);
659 /* TestOutputTrue for equal (0) */
661 char path[] = "/file1";
662 char content[] = "contents of a file";
665 r = guestfs_write_file (g, path, content, 0);
670 char src[] = "/file1";
671 char dest[] = "/file2";
674 r = guestfs_cp (g, src, dest);
679 char file1[] = "/file1";
680 char file2[] = "/file2";
683 r = guestfs_equal (g, file1, file2);
687 fprintf (stderr, "test_equal_0: expected true, got false\n");
694 static int test_equal_1 (void)
696 /* InitBasicFS for equal (1): create ext2 on /dev/sda1 */
698 char device[] = "/dev/sda";
702 r = guestfs_blockdev_setrw (g, device);
709 r = guestfs_umount_all (g);
716 r = guestfs_lvm_remove_all (g);
721 char device[] = "/dev/sda";
723 char lines_0[] = ",";
730 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
735 char fstype[] = "ext2";
736 char device[] = "/dev/sda1";
740 r = guestfs_mkfs (g, fstype, device);
745 char device[] = "/dev/sda1";
747 char mountpoint[] = "/";
750 r = guestfs_mount (g, device, mountpoint);
754 /* TestOutputFalse for equal (1) */
756 char path[] = "/file1";
757 char content[] = "contents of a file";
760 r = guestfs_write_file (g, path, content, 0);
765 char path[] = "/file2";
766 char content[] = "contents of another file";
769 r = guestfs_write_file (g, path, content, 0);
774 char file1[] = "/file1";
775 char file2[] = "/file2";
778 r = guestfs_equal (g, file1, file2);
782 fprintf (stderr, "test_equal_1: expected false, got true\n");
789 static int test_equal_2 (void)
791 /* InitBasicFS for equal (2): create ext2 on /dev/sda1 */
793 char device[] = "/dev/sda";
797 r = guestfs_blockdev_setrw (g, device);
804 r = guestfs_umount_all (g);
811 r = guestfs_lvm_remove_all (g);
816 char device[] = "/dev/sda";
818 char lines_0[] = ",";
825 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
830 char fstype[] = "ext2";
831 char device[] = "/dev/sda1";
835 r = guestfs_mkfs (g, fstype, device);
840 char device[] = "/dev/sda1";
842 char mountpoint[] = "/";
845 r = guestfs_mount (g, device, mountpoint);
849 /* TestLastFail for equal (2) */
851 char file1[] = "/file1";
852 char file2[] = "/file2";
855 r = guestfs_equal (g, file1, file2);
862 static int test_ping_daemon_0 (void)
864 /* InitEmpty for ping_daemon (0) */
866 char device[] = "/dev/sda";
870 r = guestfs_blockdev_setrw (g, device);
877 r = guestfs_umount_all (g);
884 r = guestfs_lvm_remove_all (g);
888 /* TestRun for ping_daemon (0) */
892 r = guestfs_ping_daemon (g);
899 static int test_dmesg_0 (void)
901 /* InitEmpty for dmesg (0) */
903 char device[] = "/dev/sda";
907 r = guestfs_blockdev_setrw (g, device);
914 r = guestfs_umount_all (g);
921 r = guestfs_lvm_remove_all (g);
925 /* TestRun for dmesg (0) */
929 r = guestfs_dmesg (g);
937 static int test_drop_caches_0 (void)
939 /* InitEmpty for drop_caches (0) */
941 char device[] = "/dev/sda";
945 r = guestfs_blockdev_setrw (g, device);
952 r = guestfs_umount_all (g);
959 r = guestfs_lvm_remove_all (g);
963 /* TestRun for drop_caches (0) */
967 r = guestfs_drop_caches (g, 3);
974 static int test_mv_0 (void)
976 /* InitBasicFS for mv (0): create ext2 on /dev/sda1 */
978 char device[] = "/dev/sda";
982 r = guestfs_blockdev_setrw (g, device);
989 r = guestfs_umount_all (g);
996 r = guestfs_lvm_remove_all (g);
1001 char device[] = "/dev/sda";
1002 device[5] = devchar;
1003 char lines_0[] = ",";
1010 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1015 char fstype[] = "ext2";
1016 char device[] = "/dev/sda1";
1017 device[5] = devchar;
1020 r = guestfs_mkfs (g, fstype, device);
1025 char device[] = "/dev/sda1";
1026 device[5] = devchar;
1027 char mountpoint[] = "/";
1030 r = guestfs_mount (g, device, mountpoint);
1034 /* TestOutput for mv (0) */
1035 char expected[] = "file content";
1037 char path[] = "/old";
1038 char content[] = "file content";
1041 r = guestfs_write_file (g, path, content, 0);
1046 char src[] = "/old";
1047 char dest[] = "/new";
1050 r = guestfs_mv (g, src, dest);
1055 char path[] = "/new";
1058 r = guestfs_cat (g, path);
1061 if (strcmp (r, expected) != 0) {
1062 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1070 static int test_mv_1 (void)
1072 /* InitBasicFS for mv (1): create ext2 on /dev/sda1 */
1074 char device[] = "/dev/sda";
1075 device[5] = devchar;
1078 r = guestfs_blockdev_setrw (g, device);
1085 r = guestfs_umount_all (g);
1092 r = guestfs_lvm_remove_all (g);
1097 char device[] = "/dev/sda";
1098 device[5] = devchar;
1099 char lines_0[] = ",";
1106 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1111 char fstype[] = "ext2";
1112 char device[] = "/dev/sda1";
1113 device[5] = devchar;
1116 r = guestfs_mkfs (g, fstype, device);
1121 char device[] = "/dev/sda1";
1122 device[5] = devchar;
1123 char mountpoint[] = "/";
1126 r = guestfs_mount (g, device, mountpoint);
1130 /* TestOutputFalse for mv (1) */
1132 char path[] = "/old";
1133 char content[] = "file content";
1136 r = guestfs_write_file (g, path, content, 0);
1141 char src[] = "/old";
1142 char dest[] = "/new";
1145 r = guestfs_mv (g, src, dest);
1150 char path[] = "/old";
1153 r = guestfs_is_file (g, path);
1157 fprintf (stderr, "test_mv_1: expected false, got true\n");
1164 static int test_cp_a_0 (void)
1166 /* InitBasicFS for cp_a (0): create ext2 on /dev/sda1 */
1168 char device[] = "/dev/sda";
1169 device[5] = devchar;
1172 r = guestfs_blockdev_setrw (g, device);
1179 r = guestfs_umount_all (g);
1186 r = guestfs_lvm_remove_all (g);
1191 char device[] = "/dev/sda";
1192 device[5] = devchar;
1193 char lines_0[] = ",";
1200 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1205 char fstype[] = "ext2";
1206 char device[] = "/dev/sda1";
1207 device[5] = devchar;
1210 r = guestfs_mkfs (g, fstype, device);
1215 char device[] = "/dev/sda1";
1216 device[5] = devchar;
1217 char mountpoint[] = "/";
1220 r = guestfs_mount (g, device, mountpoint);
1224 /* TestOutput for cp_a (0) */
1225 char expected[] = "file content";
1227 char path[] = "/olddir";
1230 r = guestfs_mkdir (g, path);
1235 char path[] = "/newdir";
1238 r = guestfs_mkdir (g, path);
1243 char path[] = "/olddir/file";
1244 char content[] = "file content";
1247 r = guestfs_write_file (g, path, content, 0);
1252 char src[] = "/olddir";
1253 char dest[] = "/newdir";
1256 r = guestfs_cp_a (g, src, dest);
1261 char path[] = "/newdir/olddir/file";
1264 r = guestfs_cat (g, path);
1267 if (strcmp (r, expected) != 0) {
1268 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1276 static int test_cp_0 (void)
1278 /* InitBasicFS for cp (0): create ext2 on /dev/sda1 */
1280 char device[] = "/dev/sda";
1281 device[5] = devchar;
1284 r = guestfs_blockdev_setrw (g, device);
1291 r = guestfs_umount_all (g);
1298 r = guestfs_lvm_remove_all (g);
1303 char device[] = "/dev/sda";
1304 device[5] = devchar;
1305 char lines_0[] = ",";
1312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1317 char fstype[] = "ext2";
1318 char device[] = "/dev/sda1";
1319 device[5] = devchar;
1322 r = guestfs_mkfs (g, fstype, device);
1327 char device[] = "/dev/sda1";
1328 device[5] = devchar;
1329 char mountpoint[] = "/";
1332 r = guestfs_mount (g, device, mountpoint);
1336 /* TestOutput for cp (0) */
1337 char expected[] = "file content";
1339 char path[] = "/old";
1340 char content[] = "file content";
1343 r = guestfs_write_file (g, path, content, 0);
1348 char src[] = "/old";
1349 char dest[] = "/new";
1352 r = guestfs_cp (g, src, dest);
1357 char path[] = "/new";
1360 r = guestfs_cat (g, path);
1363 if (strcmp (r, expected) != 0) {
1364 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1372 static int test_cp_1 (void)
1374 /* InitBasicFS for cp (1): create ext2 on /dev/sda1 */
1376 char device[] = "/dev/sda";
1377 device[5] = devchar;
1380 r = guestfs_blockdev_setrw (g, device);
1387 r = guestfs_umount_all (g);
1394 r = guestfs_lvm_remove_all (g);
1399 char device[] = "/dev/sda";
1400 device[5] = devchar;
1401 char lines_0[] = ",";
1408 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1413 char fstype[] = "ext2";
1414 char device[] = "/dev/sda1";
1415 device[5] = devchar;
1418 r = guestfs_mkfs (g, fstype, device);
1423 char device[] = "/dev/sda1";
1424 device[5] = devchar;
1425 char mountpoint[] = "/";
1428 r = guestfs_mount (g, device, mountpoint);
1432 /* TestOutputTrue for cp (1) */
1434 char path[] = "/old";
1435 char content[] = "file content";
1438 r = guestfs_write_file (g, path, content, 0);
1443 char src[] = "/old";
1444 char dest[] = "/new";
1447 r = guestfs_cp (g, src, dest);
1452 char path[] = "/old";
1455 r = guestfs_is_file (g, path);
1459 fprintf (stderr, "test_cp_1: expected true, got false\n");
1466 static int test_cp_2 (void)
1468 /* InitBasicFS for cp (2): create ext2 on /dev/sda1 */
1470 char device[] = "/dev/sda";
1471 device[5] = devchar;
1474 r = guestfs_blockdev_setrw (g, device);
1481 r = guestfs_umount_all (g);
1488 r = guestfs_lvm_remove_all (g);
1493 char device[] = "/dev/sda";
1494 device[5] = devchar;
1495 char lines_0[] = ",";
1502 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1507 char fstype[] = "ext2";
1508 char device[] = "/dev/sda1";
1509 device[5] = devchar;
1512 r = guestfs_mkfs (g, fstype, device);
1517 char device[] = "/dev/sda1";
1518 device[5] = devchar;
1519 char mountpoint[] = "/";
1522 r = guestfs_mount (g, device, mountpoint);
1526 /* TestOutput for cp (2) */
1527 char expected[] = "file content";
1529 char path[] = "/old";
1530 char content[] = "file content";
1533 r = guestfs_write_file (g, path, content, 0);
1538 char path[] = "/dir";
1541 r = guestfs_mkdir (g, path);
1546 char src[] = "/old";
1547 char dest[] = "/dir/new";
1550 r = guestfs_cp (g, src, dest);
1555 char path[] = "/dir/new";
1558 r = guestfs_cat (g, path);
1561 if (strcmp (r, expected) != 0) {
1562 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
1570 static int test_grub_install_0 (void)
1572 /* InitBasicFS for grub_install (0): create ext2 on /dev/sda1 */
1574 char device[] = "/dev/sda";
1575 device[5] = devchar;
1578 r = guestfs_blockdev_setrw (g, device);
1585 r = guestfs_umount_all (g);
1592 r = guestfs_lvm_remove_all (g);
1597 char device[] = "/dev/sda";
1598 device[5] = devchar;
1599 char lines_0[] = ",";
1606 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1611 char fstype[] = "ext2";
1612 char device[] = "/dev/sda1";
1613 device[5] = devchar;
1616 r = guestfs_mkfs (g, fstype, device);
1621 char device[] = "/dev/sda1";
1622 device[5] = devchar;
1623 char mountpoint[] = "/";
1626 r = guestfs_mount (g, device, mountpoint);
1630 /* TestOutputTrue for grub_install (0) */
1633 char device[] = "/dev/sda1";
1634 device[5] = devchar;
1637 r = guestfs_grub_install (g, root, device);
1642 char path[] = "/boot";
1645 r = guestfs_is_dir (g, path);
1649 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
1656 static int test_zero_0 (void)
1658 /* InitBasicFS for zero (0): create ext2 on /dev/sda1 */
1660 char device[] = "/dev/sda";
1661 device[5] = devchar;
1664 r = guestfs_blockdev_setrw (g, device);
1671 r = guestfs_umount_all (g);
1678 r = guestfs_lvm_remove_all (g);
1683 char device[] = "/dev/sda";
1684 device[5] = devchar;
1685 char lines_0[] = ",";
1692 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1697 char fstype[] = "ext2";
1698 char device[] = "/dev/sda1";
1699 device[5] = devchar;
1702 r = guestfs_mkfs (g, fstype, device);
1707 char device[] = "/dev/sda1";
1708 device[5] = devchar;
1709 char mountpoint[] = "/";
1712 r = guestfs_mount (g, device, mountpoint);
1716 /* TestOutput for zero (0) */
1717 char expected[] = "data";
1719 char pathordevice[] = "/dev/sda1";
1720 pathordevice[5] = devchar;
1723 r = guestfs_umount (g, pathordevice);
1728 char device[] = "/dev/sda1";
1729 device[5] = devchar;
1732 r = guestfs_zero (g, device);
1737 char path[] = "/dev/sda1";
1741 r = guestfs_file (g, path);
1744 if (strcmp (r, expected) != 0) {
1745 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
1753 static int test_fsck_0 (void)
1755 /* InitBasicFS for fsck (0): create ext2 on /dev/sda1 */
1757 char device[] = "/dev/sda";
1758 device[5] = devchar;
1761 r = guestfs_blockdev_setrw (g, device);
1768 r = guestfs_umount_all (g);
1775 r = guestfs_lvm_remove_all (g);
1780 char device[] = "/dev/sda";
1781 device[5] = devchar;
1782 char lines_0[] = ",";
1789 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1794 char fstype[] = "ext2";
1795 char device[] = "/dev/sda1";
1796 device[5] = devchar;
1799 r = guestfs_mkfs (g, fstype, device);
1804 char device[] = "/dev/sda1";
1805 device[5] = devchar;
1806 char mountpoint[] = "/";
1809 r = guestfs_mount (g, device, mountpoint);
1813 /* TestOutputInt for fsck (0) */
1815 char pathordevice[] = "/dev/sda1";
1816 pathordevice[5] = devchar;
1819 r = guestfs_umount (g, pathordevice);
1824 char fstype[] = "ext2";
1825 char device[] = "/dev/sda1";
1826 device[5] = devchar;
1829 r = guestfs_fsck (g, fstype, device);
1833 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
1840 static int test_fsck_1 (void)
1842 /* InitBasicFS for fsck (1): create ext2 on /dev/sda1 */
1844 char device[] = "/dev/sda";
1845 device[5] = devchar;
1848 r = guestfs_blockdev_setrw (g, device);
1855 r = guestfs_umount_all (g);
1862 r = guestfs_lvm_remove_all (g);
1867 char device[] = "/dev/sda";
1868 device[5] = devchar;
1869 char lines_0[] = ",";
1876 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1881 char fstype[] = "ext2";
1882 char device[] = "/dev/sda1";
1883 device[5] = devchar;
1886 r = guestfs_mkfs (g, fstype, device);
1891 char device[] = "/dev/sda1";
1892 device[5] = devchar;
1893 char mountpoint[] = "/";
1896 r = guestfs_mount (g, device, mountpoint);
1900 /* TestOutputInt for fsck (1) */
1902 char pathordevice[] = "/dev/sda1";
1903 pathordevice[5] = devchar;
1906 r = guestfs_umount (g, pathordevice);
1911 char device[] = "/dev/sda1";
1912 device[5] = devchar;
1915 r = guestfs_zero (g, device);
1920 char fstype[] = "ext2";
1921 char device[] = "/dev/sda1";
1922 device[5] = devchar;
1925 r = guestfs_fsck (g, fstype, device);
1929 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
1936 static int test_set_e2uuid_0 (void)
1938 /* InitBasicFS for set_e2uuid (0): create ext2 on /dev/sda1 */
1940 char device[] = "/dev/sda";
1941 device[5] = devchar;
1944 r = guestfs_blockdev_setrw (g, device);
1951 r = guestfs_umount_all (g);
1958 r = guestfs_lvm_remove_all (g);
1963 char device[] = "/dev/sda";
1964 device[5] = devchar;
1965 char lines_0[] = ",";
1972 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1977 char fstype[] = "ext2";
1978 char device[] = "/dev/sda1";
1979 device[5] = devchar;
1982 r = guestfs_mkfs (g, fstype, device);
1987 char device[] = "/dev/sda1";
1988 device[5] = devchar;
1989 char mountpoint[] = "/";
1992 r = guestfs_mount (g, device, mountpoint);
1996 /* TestOutput for set_e2uuid (0) */
1997 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
1999 char device[] = "/dev/sda1";
2000 device[5] = devchar;
2001 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2004 r = guestfs_set_e2uuid (g, device, uuid);
2009 char device[] = "/dev/sda1";
2010 device[5] = devchar;
2013 r = guestfs_get_e2uuid (g, device);
2016 if (strcmp (r, expected) != 0) {
2017 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2025 static int test_set_e2uuid_1 (void)
2027 /* InitBasicFS for set_e2uuid (1): create ext2 on /dev/sda1 */
2029 char device[] = "/dev/sda";
2030 device[5] = devchar;
2033 r = guestfs_blockdev_setrw (g, device);
2040 r = guestfs_umount_all (g);
2047 r = guestfs_lvm_remove_all (g);
2052 char device[] = "/dev/sda";
2053 device[5] = devchar;
2054 char lines_0[] = ",";
2061 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2066 char fstype[] = "ext2";
2067 char device[] = "/dev/sda1";
2068 device[5] = devchar;
2071 r = guestfs_mkfs (g, fstype, device);
2076 char device[] = "/dev/sda1";
2077 device[5] = devchar;
2078 char mountpoint[] = "/";
2081 r = guestfs_mount (g, device, mountpoint);
2085 /* TestOutput for set_e2uuid (1) */
2086 char expected[] = "";
2088 char device[] = "/dev/sda1";
2089 device[5] = devchar;
2090 char uuid[] = "clear";
2093 r = guestfs_set_e2uuid (g, device, uuid);
2098 char device[] = "/dev/sda1";
2099 device[5] = devchar;
2102 r = guestfs_get_e2uuid (g, device);
2105 if (strcmp (r, expected) != 0) {
2106 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2114 static int test_set_e2uuid_2 (void)
2116 /* InitBasicFS for set_e2uuid (2): create ext2 on /dev/sda1 */
2118 char device[] = "/dev/sda";
2119 device[5] = devchar;
2122 r = guestfs_blockdev_setrw (g, device);
2129 r = guestfs_umount_all (g);
2136 r = guestfs_lvm_remove_all (g);
2141 char device[] = "/dev/sda";
2142 device[5] = devchar;
2143 char lines_0[] = ",";
2150 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2155 char fstype[] = "ext2";
2156 char device[] = "/dev/sda1";
2157 device[5] = devchar;
2160 r = guestfs_mkfs (g, fstype, device);
2165 char device[] = "/dev/sda1";
2166 device[5] = devchar;
2167 char mountpoint[] = "/";
2170 r = guestfs_mount (g, device, mountpoint);
2174 /* TestRun for set_e2uuid (2) */
2176 char device[] = "/dev/sda1";
2177 device[5] = devchar;
2178 char uuid[] = "random";
2181 r = guestfs_set_e2uuid (g, device, uuid);
2188 static int test_set_e2uuid_3 (void)
2190 /* InitBasicFS for set_e2uuid (3): create ext2 on /dev/sda1 */
2192 char device[] = "/dev/sda";
2193 device[5] = devchar;
2196 r = guestfs_blockdev_setrw (g, device);
2203 r = guestfs_umount_all (g);
2210 r = guestfs_lvm_remove_all (g);
2215 char device[] = "/dev/sda";
2216 device[5] = devchar;
2217 char lines_0[] = ",";
2224 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2229 char fstype[] = "ext2";
2230 char device[] = "/dev/sda1";
2231 device[5] = devchar;
2234 r = guestfs_mkfs (g, fstype, device);
2239 char device[] = "/dev/sda1";
2240 device[5] = devchar;
2241 char mountpoint[] = "/";
2244 r = guestfs_mount (g, device, mountpoint);
2248 /* TestRun for set_e2uuid (3) */
2250 char device[] = "/dev/sda1";
2251 device[5] = devchar;
2252 char uuid[] = "time";
2255 r = guestfs_set_e2uuid (g, device, uuid);
2262 static int test_set_e2label_0 (void)
2264 /* InitBasicFS for set_e2label (0): create ext2 on /dev/sda1 */
2266 char device[] = "/dev/sda";
2267 device[5] = devchar;
2270 r = guestfs_blockdev_setrw (g, device);
2277 r = guestfs_umount_all (g);
2284 r = guestfs_lvm_remove_all (g);
2289 char device[] = "/dev/sda";
2290 device[5] = devchar;
2291 char lines_0[] = ",";
2298 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2303 char fstype[] = "ext2";
2304 char device[] = "/dev/sda1";
2305 device[5] = devchar;
2308 r = guestfs_mkfs (g, fstype, device);
2313 char device[] = "/dev/sda1";
2314 device[5] = devchar;
2315 char mountpoint[] = "/";
2318 r = guestfs_mount (g, device, mountpoint);
2322 /* TestOutput for set_e2label (0) */
2323 char expected[] = "testlabel";
2325 char device[] = "/dev/sda1";
2326 device[5] = devchar;
2327 char label[] = "testlabel";
2330 r = guestfs_set_e2label (g, device, label);
2335 char device[] = "/dev/sda1";
2336 device[5] = devchar;
2339 r = guestfs_get_e2label (g, device);
2342 if (strcmp (r, expected) != 0) {
2343 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2351 static int test_pvremove_0 (void)
2353 /* InitEmpty for pvremove (0) */
2355 char device[] = "/dev/sda";
2356 device[5] = devchar;
2359 r = guestfs_blockdev_setrw (g, device);
2366 r = guestfs_umount_all (g);
2373 r = guestfs_lvm_remove_all (g);
2377 /* TestOutputList for pvremove (0) */
2379 char device[] = "/dev/sda";
2380 device[5] = devchar;
2383 r = guestfs_pvcreate (g, device);
2388 char volgroup[] = "VG";
2389 char physvols_0[] = "/dev/sda";
2390 physvols_0[5] = devchar;
2391 char *physvols[] = {
2397 r = guestfs_vgcreate (g, volgroup, physvols);
2402 char logvol[] = "LV1";
2403 char volgroup[] = "VG";
2406 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2411 char logvol[] = "LV2";
2412 char volgroup[] = "VG";
2415 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2420 char vgname[] = "VG";
2423 r = guestfs_vgremove (g, vgname);
2428 char device[] = "/dev/sda";
2429 device[5] = devchar;
2432 r = guestfs_pvremove (g, device);
2440 r = guestfs_lvs (g);
2444 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2448 for (i = 0; r[i] != NULL; ++i)
2455 static int test_pvremove_1 (void)
2457 /* InitEmpty for pvremove (1) */
2459 char device[] = "/dev/sda";
2460 device[5] = devchar;
2463 r = guestfs_blockdev_setrw (g, device);
2470 r = guestfs_umount_all (g);
2477 r = guestfs_lvm_remove_all (g);
2481 /* TestOutputList for pvremove (1) */
2483 char device[] = "/dev/sda";
2484 device[5] = devchar;
2487 r = guestfs_pvcreate (g, device);
2492 char volgroup[] = "VG";
2493 char physvols_0[] = "/dev/sda";
2494 physvols_0[5] = devchar;
2495 char *physvols[] = {
2501 r = guestfs_vgcreate (g, volgroup, physvols);
2506 char logvol[] = "LV1";
2507 char volgroup[] = "VG";
2510 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2515 char logvol[] = "LV2";
2516 char volgroup[] = "VG";
2519 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2524 char vgname[] = "VG";
2527 r = guestfs_vgremove (g, vgname);
2532 char device[] = "/dev/sda";
2533 device[5] = devchar;
2536 r = guestfs_pvremove (g, device);
2544 r = guestfs_vgs (g);
2548 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
2552 for (i = 0; r[i] != NULL; ++i)
2559 static int test_pvremove_2 (void)
2561 /* InitEmpty for pvremove (2) */
2563 char device[] = "/dev/sda";
2564 device[5] = devchar;
2567 r = guestfs_blockdev_setrw (g, device);
2574 r = guestfs_umount_all (g);
2581 r = guestfs_lvm_remove_all (g);
2585 /* TestOutputList for pvremove (2) */
2587 char device[] = "/dev/sda";
2588 device[5] = devchar;
2591 r = guestfs_pvcreate (g, device);
2596 char volgroup[] = "VG";
2597 char physvols_0[] = "/dev/sda";
2598 physvols_0[5] = devchar;
2599 char *physvols[] = {
2605 r = guestfs_vgcreate (g, volgroup, physvols);
2610 char logvol[] = "LV1";
2611 char volgroup[] = "VG";
2614 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2619 char logvol[] = "LV2";
2620 char volgroup[] = "VG";
2623 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2628 char vgname[] = "VG";
2631 r = guestfs_vgremove (g, vgname);
2636 char device[] = "/dev/sda";
2637 device[5] = devchar;
2640 r = guestfs_pvremove (g, device);
2648 r = guestfs_pvs (g);
2652 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
2656 for (i = 0; r[i] != NULL; ++i)
2663 static int test_vgremove_0 (void)
2665 /* InitEmpty for vgremove (0) */
2667 char device[] = "/dev/sda";
2668 device[5] = devchar;
2671 r = guestfs_blockdev_setrw (g, device);
2678 r = guestfs_umount_all (g);
2685 r = guestfs_lvm_remove_all (g);
2689 /* TestOutputList for vgremove (0) */
2691 char device[] = "/dev/sda";
2692 device[5] = devchar;
2695 r = guestfs_pvcreate (g, device);
2700 char volgroup[] = "VG";
2701 char physvols_0[] = "/dev/sda";
2702 physvols_0[5] = devchar;
2703 char *physvols[] = {
2709 r = guestfs_vgcreate (g, volgroup, physvols);
2714 char logvol[] = "LV1";
2715 char volgroup[] = "VG";
2718 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2723 char logvol[] = "LV2";
2724 char volgroup[] = "VG";
2727 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2732 char vgname[] = "VG";
2735 r = guestfs_vgremove (g, vgname);
2743 r = guestfs_lvs (g);
2747 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
2751 for (i = 0; r[i] != NULL; ++i)
2758 static int test_vgremove_1 (void)
2760 /* InitEmpty for vgremove (1) */
2762 char device[] = "/dev/sda";
2763 device[5] = devchar;
2766 r = guestfs_blockdev_setrw (g, device);
2773 r = guestfs_umount_all (g);
2780 r = guestfs_lvm_remove_all (g);
2784 /* TestOutputList for vgremove (1) */
2786 char device[] = "/dev/sda";
2787 device[5] = devchar;
2790 r = guestfs_pvcreate (g, device);
2795 char volgroup[] = "VG";
2796 char physvols_0[] = "/dev/sda";
2797 physvols_0[5] = devchar;
2798 char *physvols[] = {
2804 r = guestfs_vgcreate (g, volgroup, physvols);
2809 char logvol[] = "LV1";
2810 char volgroup[] = "VG";
2813 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2818 char logvol[] = "LV2";
2819 char volgroup[] = "VG";
2822 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2827 char vgname[] = "VG";
2830 r = guestfs_vgremove (g, vgname);
2838 r = guestfs_vgs (g);
2842 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
2846 for (i = 0; r[i] != NULL; ++i)
2853 static int test_lvremove_0 (void)
2855 /* InitEmpty for lvremove (0) */
2857 char device[] = "/dev/sda";
2858 device[5] = devchar;
2861 r = guestfs_blockdev_setrw (g, device);
2868 r = guestfs_umount_all (g);
2875 r = guestfs_lvm_remove_all (g);
2879 /* TestOutputList for lvremove (0) */
2881 char device[] = "/dev/sda";
2882 device[5] = devchar;
2885 r = guestfs_pvcreate (g, device);
2890 char volgroup[] = "VG";
2891 char physvols_0[] = "/dev/sda";
2892 physvols_0[5] = devchar;
2893 char *physvols[] = {
2899 r = guestfs_vgcreate (g, volgroup, physvols);
2904 char logvol[] = "LV1";
2905 char volgroup[] = "VG";
2908 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2913 char logvol[] = "LV2";
2914 char volgroup[] = "VG";
2917 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2922 char device[] = "/dev/VG/LV1";
2925 r = guestfs_lvremove (g, device);
2933 r = guestfs_lvs (g);
2937 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
2942 char expected[] = "/dev/VG/LV2";
2943 if (strcmp (r[0], expected) != 0) {
2944 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2949 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
2953 for (i = 0; r[i] != NULL; ++i)
2960 static int test_lvremove_1 (void)
2962 /* InitEmpty for lvremove (1) */
2964 char device[] = "/dev/sda";
2965 device[5] = devchar;
2968 r = guestfs_blockdev_setrw (g, device);
2975 r = guestfs_umount_all (g);
2982 r = guestfs_lvm_remove_all (g);
2986 /* TestOutputList for lvremove (1) */
2988 char device[] = "/dev/sda";
2989 device[5] = devchar;
2992 r = guestfs_pvcreate (g, device);
2997 char volgroup[] = "VG";
2998 char physvols_0[] = "/dev/sda";
2999 physvols_0[5] = devchar;
3000 char *physvols[] = {
3006 r = guestfs_vgcreate (g, volgroup, physvols);
3011 char logvol[] = "LV1";
3012 char volgroup[] = "VG";
3015 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3020 char logvol[] = "LV2";
3021 char volgroup[] = "VG";
3024 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3029 char device[] = "/dev/VG";
3032 r = guestfs_lvremove (g, device);
3040 r = guestfs_lvs (g);
3044 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3048 for (i = 0; r[i] != NULL; ++i)
3055 static int test_lvremove_2 (void)
3057 /* InitEmpty for lvremove (2) */
3059 char device[] = "/dev/sda";
3060 device[5] = devchar;
3063 r = guestfs_blockdev_setrw (g, device);
3070 r = guestfs_umount_all (g);
3077 r = guestfs_lvm_remove_all (g);
3081 /* TestOutputList for lvremove (2) */
3083 char device[] = "/dev/sda";
3084 device[5] = devchar;
3087 r = guestfs_pvcreate (g, device);
3092 char volgroup[] = "VG";
3093 char physvols_0[] = "/dev/sda";
3094 physvols_0[5] = devchar;
3095 char *physvols[] = {
3101 r = guestfs_vgcreate (g, volgroup, physvols);
3106 char logvol[] = "LV1";
3107 char volgroup[] = "VG";
3110 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3115 char logvol[] = "LV2";
3116 char volgroup[] = "VG";
3119 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3124 char device[] = "/dev/VG";
3127 r = guestfs_lvremove (g, device);
3135 r = guestfs_vgs (g);
3139 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3144 char expected[] = "VG";
3145 if (strcmp (r[0], expected) != 0) {
3146 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3151 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3155 for (i = 0; r[i] != NULL; ++i)
3162 static int test_mount_ro_0 (void)
3164 /* InitBasicFS for mount_ro (0): create ext2 on /dev/sda1 */
3166 char device[] = "/dev/sda";
3167 device[5] = devchar;
3170 r = guestfs_blockdev_setrw (g, device);
3177 r = guestfs_umount_all (g);
3184 r = guestfs_lvm_remove_all (g);
3189 char device[] = "/dev/sda";
3190 device[5] = devchar;
3191 char lines_0[] = ",";
3198 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3203 char fstype[] = "ext2";
3204 char device[] = "/dev/sda1";
3205 device[5] = devchar;
3208 r = guestfs_mkfs (g, fstype, device);
3213 char device[] = "/dev/sda1";
3214 device[5] = devchar;
3215 char mountpoint[] = "/";
3218 r = guestfs_mount (g, device, mountpoint);
3222 /* TestLastFail for mount_ro (0) */
3224 char pathordevice[] = "/";
3227 r = guestfs_umount (g, pathordevice);
3232 char device[] = "/dev/sda1";
3233 device[5] = devchar;
3234 char mountpoint[] = "/";
3237 r = guestfs_mount_ro (g, device, mountpoint);
3242 char path[] = "/new";
3245 r = guestfs_touch (g, path);
3252 static int test_mount_ro_1 (void)
3254 /* InitBasicFS for mount_ro (1): create ext2 on /dev/sda1 */
3256 char device[] = "/dev/sda";
3257 device[5] = devchar;
3260 r = guestfs_blockdev_setrw (g, device);
3267 r = guestfs_umount_all (g);
3274 r = guestfs_lvm_remove_all (g);
3279 char device[] = "/dev/sda";
3280 device[5] = devchar;
3281 char lines_0[] = ",";
3288 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3293 char fstype[] = "ext2";
3294 char device[] = "/dev/sda1";
3295 device[5] = devchar;
3298 r = guestfs_mkfs (g, fstype, device);
3303 char device[] = "/dev/sda1";
3304 device[5] = devchar;
3305 char mountpoint[] = "/";
3308 r = guestfs_mount (g, device, mountpoint);
3312 /* TestOutput for mount_ro (1) */
3313 char expected[] = "data";
3315 char path[] = "/new";
3316 char content[] = "data";
3319 r = guestfs_write_file (g, path, content, 0);
3324 char pathordevice[] = "/";
3327 r = guestfs_umount (g, pathordevice);
3332 char device[] = "/dev/sda1";
3333 device[5] = devchar;
3334 char mountpoint[] = "/";
3337 r = guestfs_mount_ro (g, device, mountpoint);
3342 char path[] = "/new";
3345 r = guestfs_cat (g, path);
3348 if (strcmp (r, expected) != 0) {
3349 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3357 static int test_tgz_in_0 (void)
3359 /* InitBasicFS for tgz_in (0): create ext2 on /dev/sda1 */
3361 char device[] = "/dev/sda";
3362 device[5] = devchar;
3365 r = guestfs_blockdev_setrw (g, device);
3372 r = guestfs_umount_all (g);
3379 r = guestfs_lvm_remove_all (g);
3384 char device[] = "/dev/sda";
3385 device[5] = devchar;
3386 char lines_0[] = ",";
3393 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3398 char fstype[] = "ext2";
3399 char device[] = "/dev/sda1";
3400 device[5] = devchar;
3403 r = guestfs_mkfs (g, fstype, device);
3408 char device[] = "/dev/sda1";
3409 device[5] = devchar;
3410 char mountpoint[] = "/";
3413 r = guestfs_mount (g, device, mountpoint);
3417 /* TestOutput for tgz_in (0) */
3418 char expected[] = "hello\n";
3420 char directory[] = "/";
3423 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3428 char path[] = "/hello";
3431 r = guestfs_cat (g, path);
3434 if (strcmp (r, expected) != 0) {
3435 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3443 static int test_tar_in_0 (void)
3445 /* InitBasicFS for tar_in (0): create ext2 on /dev/sda1 */
3447 char device[] = "/dev/sda";
3448 device[5] = devchar;
3451 r = guestfs_blockdev_setrw (g, device);
3458 r = guestfs_umount_all (g);
3465 r = guestfs_lvm_remove_all (g);
3470 char device[] = "/dev/sda";
3471 device[5] = devchar;
3472 char lines_0[] = ",";
3479 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3484 char fstype[] = "ext2";
3485 char device[] = "/dev/sda1";
3486 device[5] = devchar;
3489 r = guestfs_mkfs (g, fstype, device);
3494 char device[] = "/dev/sda1";
3495 device[5] = devchar;
3496 char mountpoint[] = "/";
3499 r = guestfs_mount (g, device, mountpoint);
3503 /* TestOutput for tar_in (0) */
3504 char expected[] = "hello\n";
3506 char directory[] = "/";
3509 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
3514 char path[] = "/hello";
3517 r = guestfs_cat (g, path);
3520 if (strcmp (r, expected) != 0) {
3521 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3529 static int test_checksum_0 (void)
3531 /* InitBasicFS for checksum (0): create ext2 on /dev/sda1 */
3533 char device[] = "/dev/sda";
3534 device[5] = devchar;
3537 r = guestfs_blockdev_setrw (g, device);
3544 r = guestfs_umount_all (g);
3551 r = guestfs_lvm_remove_all (g);
3556 char device[] = "/dev/sda";
3557 device[5] = devchar;
3558 char lines_0[] = ",";
3565 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3570 char fstype[] = "ext2";
3571 char device[] = "/dev/sda1";
3572 device[5] = devchar;
3575 r = guestfs_mkfs (g, fstype, device);
3580 char device[] = "/dev/sda1";
3581 device[5] = devchar;
3582 char mountpoint[] = "/";
3585 r = guestfs_mount (g, device, mountpoint);
3589 /* TestOutput for checksum (0) */
3590 char expected[] = "935282863";
3592 char path[] = "/new";
3593 char content[] = "test\n";
3596 r = guestfs_write_file (g, path, content, 0);
3601 char csumtype[] = "crc";
3602 char path[] = "/new";
3605 r = guestfs_checksum (g, csumtype, path);
3608 if (strcmp (r, expected) != 0) {
3609 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
3617 static int test_checksum_1 (void)
3619 /* InitBasicFS for checksum (1): create ext2 on /dev/sda1 */
3621 char device[] = "/dev/sda";
3622 device[5] = devchar;
3625 r = guestfs_blockdev_setrw (g, device);
3632 r = guestfs_umount_all (g);
3639 r = guestfs_lvm_remove_all (g);
3644 char device[] = "/dev/sda";
3645 device[5] = devchar;
3646 char lines_0[] = ",";
3653 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3658 char fstype[] = "ext2";
3659 char device[] = "/dev/sda1";
3660 device[5] = devchar;
3663 r = guestfs_mkfs (g, fstype, device);
3668 char device[] = "/dev/sda1";
3669 device[5] = devchar;
3670 char mountpoint[] = "/";
3673 r = guestfs_mount (g, device, mountpoint);
3677 /* TestLastFail for checksum (1) */
3679 char csumtype[] = "crc";
3680 char path[] = "/new";
3683 r = guestfs_checksum (g, csumtype, path);
3691 static int test_checksum_2 (void)
3693 /* InitBasicFS for checksum (2): create ext2 on /dev/sda1 */
3695 char device[] = "/dev/sda";
3696 device[5] = devchar;
3699 r = guestfs_blockdev_setrw (g, device);
3706 r = guestfs_umount_all (g);
3713 r = guestfs_lvm_remove_all (g);
3718 char device[] = "/dev/sda";
3719 device[5] = devchar;
3720 char lines_0[] = ",";
3727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3732 char fstype[] = "ext2";
3733 char device[] = "/dev/sda1";
3734 device[5] = devchar;
3737 r = guestfs_mkfs (g, fstype, device);
3742 char device[] = "/dev/sda1";
3743 device[5] = devchar;
3744 char mountpoint[] = "/";
3747 r = guestfs_mount (g, device, mountpoint);
3751 /* TestOutput for checksum (2) */
3752 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
3754 char path[] = "/new";
3755 char content[] = "test\n";
3758 r = guestfs_write_file (g, path, content, 0);
3763 char csumtype[] = "md5";
3764 char path[] = "/new";
3767 r = guestfs_checksum (g, csumtype, path);
3770 if (strcmp (r, expected) != 0) {
3771 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
3779 static int test_checksum_3 (void)
3781 /* InitBasicFS for checksum (3): create ext2 on /dev/sda1 */
3783 char device[] = "/dev/sda";
3784 device[5] = devchar;
3787 r = guestfs_blockdev_setrw (g, device);
3794 r = guestfs_umount_all (g);
3801 r = guestfs_lvm_remove_all (g);
3806 char device[] = "/dev/sda";
3807 device[5] = devchar;
3808 char lines_0[] = ",";
3815 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3820 char fstype[] = "ext2";
3821 char device[] = "/dev/sda1";
3822 device[5] = devchar;
3825 r = guestfs_mkfs (g, fstype, device);
3830 char device[] = "/dev/sda1";
3831 device[5] = devchar;
3832 char mountpoint[] = "/";
3835 r = guestfs_mount (g, device, mountpoint);
3839 /* TestOutput for checksum (3) */
3840 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
3842 char path[] = "/new";
3843 char content[] = "test\n";
3846 r = guestfs_write_file (g, path, content, 0);
3851 char csumtype[] = "sha1";
3852 char path[] = "/new";
3855 r = guestfs_checksum (g, csumtype, path);
3858 if (strcmp (r, expected) != 0) {
3859 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
3867 static int test_checksum_4 (void)
3869 /* InitBasicFS for checksum (4): create ext2 on /dev/sda1 */
3871 char device[] = "/dev/sda";
3872 device[5] = devchar;
3875 r = guestfs_blockdev_setrw (g, device);
3882 r = guestfs_umount_all (g);
3889 r = guestfs_lvm_remove_all (g);
3894 char device[] = "/dev/sda";
3895 device[5] = devchar;
3896 char lines_0[] = ",";
3903 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3908 char fstype[] = "ext2";
3909 char device[] = "/dev/sda1";
3910 device[5] = devchar;
3913 r = guestfs_mkfs (g, fstype, device);
3918 char device[] = "/dev/sda1";
3919 device[5] = devchar;
3920 char mountpoint[] = "/";
3923 r = guestfs_mount (g, device, mountpoint);
3927 /* TestOutput for checksum (4) */
3928 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
3930 char path[] = "/new";
3931 char content[] = "test\n";
3934 r = guestfs_write_file (g, path, content, 0);
3939 char csumtype[] = "sha224";
3940 char path[] = "/new";
3943 r = guestfs_checksum (g, csumtype, path);
3946 if (strcmp (r, expected) != 0) {
3947 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
3955 static int test_checksum_5 (void)
3957 /* InitBasicFS for checksum (5): create ext2 on /dev/sda1 */
3959 char device[] = "/dev/sda";
3960 device[5] = devchar;
3963 r = guestfs_blockdev_setrw (g, device);
3970 r = guestfs_umount_all (g);
3977 r = guestfs_lvm_remove_all (g);
3982 char device[] = "/dev/sda";
3983 device[5] = devchar;
3984 char lines_0[] = ",";
3991 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3996 char fstype[] = "ext2";
3997 char device[] = "/dev/sda1";
3998 device[5] = devchar;
4001 r = guestfs_mkfs (g, fstype, device);
4006 char device[] = "/dev/sda1";
4007 device[5] = devchar;
4008 char mountpoint[] = "/";
4011 r = guestfs_mount (g, device, mountpoint);
4015 /* TestOutput for checksum (5) */
4016 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4018 char path[] = "/new";
4019 char content[] = "test\n";
4022 r = guestfs_write_file (g, path, content, 0);
4027 char csumtype[] = "sha256";
4028 char path[] = "/new";
4031 r = guestfs_checksum (g, csumtype, path);
4034 if (strcmp (r, expected) != 0) {
4035 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4043 static int test_checksum_6 (void)
4045 /* InitBasicFS for checksum (6): create ext2 on /dev/sda1 */
4047 char device[] = "/dev/sda";
4048 device[5] = devchar;
4051 r = guestfs_blockdev_setrw (g, device);
4058 r = guestfs_umount_all (g);
4065 r = guestfs_lvm_remove_all (g);
4070 char device[] = "/dev/sda";
4071 device[5] = devchar;
4072 char lines_0[] = ",";
4079 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4084 char fstype[] = "ext2";
4085 char device[] = "/dev/sda1";
4086 device[5] = devchar;
4089 r = guestfs_mkfs (g, fstype, device);
4094 char device[] = "/dev/sda1";
4095 device[5] = devchar;
4096 char mountpoint[] = "/";
4099 r = guestfs_mount (g, device, mountpoint);
4103 /* TestOutput for checksum (6) */
4104 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4106 char path[] = "/new";
4107 char content[] = "test\n";
4110 r = guestfs_write_file (g, path, content, 0);
4115 char csumtype[] = "sha384";
4116 char path[] = "/new";
4119 r = guestfs_checksum (g, csumtype, path);
4122 if (strcmp (r, expected) != 0) {
4123 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4131 static int test_checksum_7 (void)
4133 /* InitBasicFS for checksum (7): create ext2 on /dev/sda1 */
4135 char device[] = "/dev/sda";
4136 device[5] = devchar;
4139 r = guestfs_blockdev_setrw (g, device);
4146 r = guestfs_umount_all (g);
4153 r = guestfs_lvm_remove_all (g);
4158 char device[] = "/dev/sda";
4159 device[5] = devchar;
4160 char lines_0[] = ",";
4167 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4172 char fstype[] = "ext2";
4173 char device[] = "/dev/sda1";
4174 device[5] = devchar;
4177 r = guestfs_mkfs (g, fstype, device);
4182 char device[] = "/dev/sda1";
4183 device[5] = devchar;
4184 char mountpoint[] = "/";
4187 r = guestfs_mount (g, device, mountpoint);
4191 /* TestOutput for checksum (7) */
4192 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4194 char path[] = "/new";
4195 char content[] = "test\n";
4198 r = guestfs_write_file (g, path, content, 0);
4203 char csumtype[] = "sha512";
4204 char path[] = "/new";
4207 r = guestfs_checksum (g, csumtype, path);
4210 if (strcmp (r, expected) != 0) {
4211 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4219 static int test_download_0 (void)
4221 /* InitBasicFS for download (0): create ext2 on /dev/sda1 */
4223 char device[] = "/dev/sda";
4224 device[5] = devchar;
4227 r = guestfs_blockdev_setrw (g, device);
4234 r = guestfs_umount_all (g);
4241 r = guestfs_lvm_remove_all (g);
4246 char device[] = "/dev/sda";
4247 device[5] = devchar;
4248 char lines_0[] = ",";
4255 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4260 char fstype[] = "ext2";
4261 char device[] = "/dev/sda1";
4262 device[5] = devchar;
4265 r = guestfs_mkfs (g, fstype, device);
4270 char device[] = "/dev/sda1";
4271 device[5] = devchar;
4272 char mountpoint[] = "/";
4275 r = guestfs_mount (g, device, mountpoint);
4279 /* TestOutput for download (0) */
4280 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4282 char remotefilename[] = "/COPYING.LIB";
4285 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4290 char remotefilename[] = "/COPYING.LIB";
4293 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4298 char remotefilename[] = "/upload";
4301 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4306 char csumtype[] = "md5";
4307 char path[] = "/upload";
4310 r = guestfs_checksum (g, csumtype, path);
4313 if (strcmp (r, expected) != 0) {
4314 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4322 static int test_upload_0 (void)
4324 /* InitBasicFS for upload (0): create ext2 on /dev/sda1 */
4326 char device[] = "/dev/sda";
4327 device[5] = devchar;
4330 r = guestfs_blockdev_setrw (g, device);
4337 r = guestfs_umount_all (g);
4344 r = guestfs_lvm_remove_all (g);
4349 char device[] = "/dev/sda";
4350 device[5] = devchar;
4351 char lines_0[] = ",";
4358 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4363 char fstype[] = "ext2";
4364 char device[] = "/dev/sda1";
4365 device[5] = devchar;
4368 r = guestfs_mkfs (g, fstype, device);
4373 char device[] = "/dev/sda1";
4374 device[5] = devchar;
4375 char mountpoint[] = "/";
4378 r = guestfs_mount (g, device, mountpoint);
4382 /* TestOutput for upload (0) */
4383 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4385 char remotefilename[] = "/COPYING.LIB";
4388 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4393 char csumtype[] = "md5";
4394 char path[] = "/COPYING.LIB";
4397 r = guestfs_checksum (g, csumtype, path);
4400 if (strcmp (r, expected) != 0) {
4401 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4409 static int test_blockdev_rereadpt_0 (void)
4411 /* InitEmpty for blockdev_rereadpt (0) */
4413 char device[] = "/dev/sda";
4414 device[5] = devchar;
4417 r = guestfs_blockdev_setrw (g, device);
4424 r = guestfs_umount_all (g);
4431 r = guestfs_lvm_remove_all (g);
4435 /* TestRun for blockdev_rereadpt (0) */
4437 char device[] = "/dev/sda";
4438 device[5] = devchar;
4441 r = guestfs_blockdev_rereadpt (g, device);
4448 static int test_blockdev_flushbufs_0 (void)
4450 /* InitEmpty for blockdev_flushbufs (0) */
4452 char device[] = "/dev/sda";
4453 device[5] = devchar;
4456 r = guestfs_blockdev_setrw (g, device);
4463 r = guestfs_umount_all (g);
4470 r = guestfs_lvm_remove_all (g);
4474 /* TestRun for blockdev_flushbufs (0) */
4476 char device[] = "/dev/sda";
4477 device[5] = devchar;
4480 r = guestfs_blockdev_flushbufs (g, device);
4487 static int test_blockdev_getsize64_0 (void)
4489 /* InitEmpty for blockdev_getsize64 (0) */
4491 char device[] = "/dev/sda";
4492 device[5] = devchar;
4495 r = guestfs_blockdev_setrw (g, device);
4502 r = guestfs_umount_all (g);
4509 r = guestfs_lvm_remove_all (g);
4513 /* TestOutputInt for blockdev_getsize64 (0) */
4515 char device[] = "/dev/sda";
4516 device[5] = devchar;
4519 r = guestfs_blockdev_getsize64 (g, device);
4522 if (r != 524288000) {
4523 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
4530 static int test_blockdev_getsz_0 (void)
4532 /* InitEmpty for blockdev_getsz (0) */
4534 char device[] = "/dev/sda";
4535 device[5] = devchar;
4538 r = guestfs_blockdev_setrw (g, device);
4545 r = guestfs_umount_all (g);
4552 r = guestfs_lvm_remove_all (g);
4556 /* TestOutputInt for blockdev_getsz (0) */
4558 char device[] = "/dev/sda";
4559 device[5] = devchar;
4562 r = guestfs_blockdev_getsz (g, device);
4566 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
4573 static int test_blockdev_getbsz_0 (void)
4575 /* InitEmpty for blockdev_getbsz (0) */
4577 char device[] = "/dev/sda";
4578 device[5] = devchar;
4581 r = guestfs_blockdev_setrw (g, device);
4588 r = guestfs_umount_all (g);
4595 r = guestfs_lvm_remove_all (g);
4599 /* TestOutputInt for blockdev_getbsz (0) */
4601 char device[] = "/dev/sda";
4602 device[5] = devchar;
4605 r = guestfs_blockdev_getbsz (g, device);
4609 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
4616 static int test_blockdev_getss_0 (void)
4618 /* InitEmpty for blockdev_getss (0) */
4620 char device[] = "/dev/sda";
4621 device[5] = devchar;
4624 r = guestfs_blockdev_setrw (g, device);
4631 r = guestfs_umount_all (g);
4638 r = guestfs_lvm_remove_all (g);
4642 /* TestOutputInt for blockdev_getss (0) */
4644 char device[] = "/dev/sda";
4645 device[5] = devchar;
4648 r = guestfs_blockdev_getss (g, device);
4652 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
4659 static int test_blockdev_getro_0 (void)
4661 /* InitEmpty for blockdev_getro (0) */
4663 char device[] = "/dev/sda";
4664 device[5] = devchar;
4667 r = guestfs_blockdev_setrw (g, device);
4674 r = guestfs_umount_all (g);
4681 r = guestfs_lvm_remove_all (g);
4685 /* TestOutputTrue for blockdev_getro (0) */
4687 char device[] = "/dev/sda";
4688 device[5] = devchar;
4691 r = guestfs_blockdev_setro (g, device);
4696 char device[] = "/dev/sda";
4697 device[5] = devchar;
4700 r = guestfs_blockdev_getro (g, device);
4704 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
4711 static int test_blockdev_setrw_0 (void)
4713 /* InitEmpty for blockdev_setrw (0) */
4715 char device[] = "/dev/sda";
4716 device[5] = devchar;
4719 r = guestfs_blockdev_setrw (g, device);
4726 r = guestfs_umount_all (g);
4733 r = guestfs_lvm_remove_all (g);
4737 /* TestOutputFalse for blockdev_setrw (0) */
4739 char device[] = "/dev/sda";
4740 device[5] = devchar;
4743 r = guestfs_blockdev_setrw (g, device);
4748 char device[] = "/dev/sda";
4749 device[5] = devchar;
4752 r = guestfs_blockdev_getro (g, device);
4756 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
4763 static int test_blockdev_setro_0 (void)
4765 /* InitEmpty for blockdev_setro (0) */
4767 char device[] = "/dev/sda";
4768 device[5] = devchar;
4771 r = guestfs_blockdev_setrw (g, device);
4778 r = guestfs_umount_all (g);
4785 r = guestfs_lvm_remove_all (g);
4789 /* TestOutputTrue for blockdev_setro (0) */
4791 char device[] = "/dev/sda";
4792 device[5] = devchar;
4795 r = guestfs_blockdev_setro (g, device);
4800 char device[] = "/dev/sda";
4801 device[5] = devchar;
4804 r = guestfs_blockdev_getro (g, device);
4808 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
4815 static int test_statvfs_0 (void)
4817 /* InitBasicFS for statvfs (0): create ext2 on /dev/sda1 */
4819 char device[] = "/dev/sda";
4820 device[5] = devchar;
4823 r = guestfs_blockdev_setrw (g, device);
4830 r = guestfs_umount_all (g);
4837 r = guestfs_lvm_remove_all (g);
4842 char device[] = "/dev/sda";
4843 device[5] = devchar;
4844 char lines_0[] = ",";
4851 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4856 char fstype[] = "ext2";
4857 char device[] = "/dev/sda1";
4858 device[5] = devchar;
4861 r = guestfs_mkfs (g, fstype, device);
4866 char device[] = "/dev/sda1";
4867 device[5] = devchar;
4868 char mountpoint[] = "/";
4871 r = guestfs_mount (g, device, mountpoint);
4875 /* TestOutputStruct for statvfs (0) */
4878 struct guestfs_statvfs *r;
4880 r = guestfs_statvfs (g, path);
4883 if (r->bfree != 487702) {
4884 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
4888 if (r->blocks != 490020) {
4889 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
4893 if (r->bsize != 1024) {
4894 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
4903 static int test_lstat_0 (void)
4905 /* InitBasicFS for lstat (0): create ext2 on /dev/sda1 */
4907 char device[] = "/dev/sda";
4908 device[5] = devchar;
4911 r = guestfs_blockdev_setrw (g, device);
4918 r = guestfs_umount_all (g);
4925 r = guestfs_lvm_remove_all (g);
4930 char device[] = "/dev/sda";
4931 device[5] = devchar;
4932 char lines_0[] = ",";
4939 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4944 char fstype[] = "ext2";
4945 char device[] = "/dev/sda1";
4946 device[5] = devchar;
4949 r = guestfs_mkfs (g, fstype, device);
4954 char device[] = "/dev/sda1";
4955 device[5] = devchar;
4956 char mountpoint[] = "/";
4959 r = guestfs_mount (g, device, mountpoint);
4963 /* TestOutputStruct for lstat (0) */
4965 char path[] = "/new";
4968 r = guestfs_touch (g, path);
4973 char path[] = "/new";
4974 struct guestfs_stat *r;
4976 r = guestfs_lstat (g, path);
4980 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
4989 static int test_stat_0 (void)
4991 /* InitBasicFS for stat (0): create ext2 on /dev/sda1 */
4993 char device[] = "/dev/sda";
4994 device[5] = devchar;
4997 r = guestfs_blockdev_setrw (g, device);
5004 r = guestfs_umount_all (g);
5011 r = guestfs_lvm_remove_all (g);
5016 char device[] = "/dev/sda";
5017 device[5] = devchar;
5018 char lines_0[] = ",";
5025 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5030 char fstype[] = "ext2";
5031 char device[] = "/dev/sda1";
5032 device[5] = devchar;
5035 r = guestfs_mkfs (g, fstype, device);
5040 char device[] = "/dev/sda1";
5041 device[5] = devchar;
5042 char mountpoint[] = "/";
5045 r = guestfs_mount (g, device, mountpoint);
5049 /* TestOutputStruct for stat (0) */
5051 char path[] = "/new";
5054 r = guestfs_touch (g, path);
5059 char path[] = "/new";
5060 struct guestfs_stat *r;
5062 r = guestfs_stat (g, path);
5066 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5075 static int test_command_lines_0_prereq (void)
5077 const char *str = getenv ("SKIP_TEST_COMMAND");
5078 return str && strcmp (str, "1") == 0;
5081 static int test_command_lines_0 (void)
5083 if (! test_command_lines_0_prereq ()) {
5084 /* InitBasicFS for command_lines (0): create ext2 on /dev/sda1 */
5086 char device[] = "/dev/sda";
5087 device[5] = devchar;
5090 r = guestfs_blockdev_setrw (g, device);
5097 r = guestfs_umount_all (g);
5104 r = guestfs_lvm_remove_all (g);
5109 char device[] = "/dev/sda";
5110 device[5] = devchar;
5111 char lines_0[] = ",";
5118 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5123 char fstype[] = "ext2";
5124 char device[] = "/dev/sda1";
5125 device[5] = devchar;
5128 r = guestfs_mkfs (g, fstype, device);
5133 char device[] = "/dev/sda1";
5134 device[5] = devchar;
5135 char mountpoint[] = "/";
5138 r = guestfs_mount (g, device, mountpoint);
5142 /* TestOutputList for command_lines (0) */
5144 char remotefilename[] = "/test-command";
5147 r = guestfs_upload (g, "test-command", remotefilename);
5152 char path[] = "/test-command";
5155 r = guestfs_chmod (g, 493, path);
5160 char arguments_0[] = "/test-command";
5161 char arguments_1[] = "1";
5162 char *arguments[] = {
5170 r = guestfs_command_lines (g, arguments);
5174 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5179 char expected[] = "Result1";
5180 if (strcmp (r[0], expected) != 0) {
5181 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5186 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5190 for (i = 0; r[i] != NULL; ++i)
5195 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5199 static int test_command_lines_1_prereq (void)
5201 const char *str = getenv ("SKIP_TEST_COMMAND");
5202 return str && strcmp (str, "1") == 0;
5205 static int test_command_lines_1 (void)
5207 if (! test_command_lines_1_prereq ()) {
5208 /* InitBasicFS for command_lines (1): create ext2 on /dev/sda1 */
5210 char device[] = "/dev/sda";
5211 device[5] = devchar;
5214 r = guestfs_blockdev_setrw (g, device);
5221 r = guestfs_umount_all (g);
5228 r = guestfs_lvm_remove_all (g);
5233 char device[] = "/dev/sda";
5234 device[5] = devchar;
5235 char lines_0[] = ",";
5242 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5247 char fstype[] = "ext2";
5248 char device[] = "/dev/sda1";
5249 device[5] = devchar;
5252 r = guestfs_mkfs (g, fstype, device);
5257 char device[] = "/dev/sda1";
5258 device[5] = devchar;
5259 char mountpoint[] = "/";
5262 r = guestfs_mount (g, device, mountpoint);
5266 /* TestOutputList for command_lines (1) */
5268 char remotefilename[] = "/test-command";
5271 r = guestfs_upload (g, "test-command", remotefilename);
5276 char path[] = "/test-command";
5279 r = guestfs_chmod (g, 493, path);
5284 char arguments_0[] = "/test-command";
5285 char arguments_1[] = "2";
5286 char *arguments[] = {
5294 r = guestfs_command_lines (g, arguments);
5298 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5303 char expected[] = "Result2";
5304 if (strcmp (r[0], expected) != 0) {
5305 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5310 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5314 for (i = 0; r[i] != NULL; ++i)
5319 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5323 static int test_command_lines_2_prereq (void)
5325 const char *str = getenv ("SKIP_TEST_COMMAND");
5326 return str && strcmp (str, "1") == 0;
5329 static int test_command_lines_2 (void)
5331 if (! test_command_lines_2_prereq ()) {
5332 /* InitBasicFS for command_lines (2): create ext2 on /dev/sda1 */
5334 char device[] = "/dev/sda";
5335 device[5] = devchar;
5338 r = guestfs_blockdev_setrw (g, device);
5345 r = guestfs_umount_all (g);
5352 r = guestfs_lvm_remove_all (g);
5357 char device[] = "/dev/sda";
5358 device[5] = devchar;
5359 char lines_0[] = ",";
5366 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5371 char fstype[] = "ext2";
5372 char device[] = "/dev/sda1";
5373 device[5] = devchar;
5376 r = guestfs_mkfs (g, fstype, device);
5381 char device[] = "/dev/sda1";
5382 device[5] = devchar;
5383 char mountpoint[] = "/";
5386 r = guestfs_mount (g, device, mountpoint);
5390 /* TestOutputList for command_lines (2) */
5392 char remotefilename[] = "/test-command";
5395 r = guestfs_upload (g, "test-command", remotefilename);
5400 char path[] = "/test-command";
5403 r = guestfs_chmod (g, 493, path);
5408 char arguments_0[] = "/test-command";
5409 char arguments_1[] = "3";
5410 char *arguments[] = {
5418 r = guestfs_command_lines (g, arguments);
5422 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5427 char expected[] = "";
5428 if (strcmp (r[0], expected) != 0) {
5429 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5434 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5439 char expected[] = "Result3";
5440 if (strcmp (r[1], expected) != 0) {
5441 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5446 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5450 for (i = 0; r[i] != NULL; ++i)
5455 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
5459 static int test_command_lines_3_prereq (void)
5461 const char *str = getenv ("SKIP_TEST_COMMAND");
5462 return str && strcmp (str, "1") == 0;
5465 static int test_command_lines_3 (void)
5467 if (! test_command_lines_3_prereq ()) {
5468 /* InitBasicFS for command_lines (3): create ext2 on /dev/sda1 */
5470 char device[] = "/dev/sda";
5471 device[5] = devchar;
5474 r = guestfs_blockdev_setrw (g, device);
5481 r = guestfs_umount_all (g);
5488 r = guestfs_lvm_remove_all (g);
5493 char device[] = "/dev/sda";
5494 device[5] = devchar;
5495 char lines_0[] = ",";
5502 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5507 char fstype[] = "ext2";
5508 char device[] = "/dev/sda1";
5509 device[5] = devchar;
5512 r = guestfs_mkfs (g, fstype, device);
5517 char device[] = "/dev/sda1";
5518 device[5] = devchar;
5519 char mountpoint[] = "/";
5522 r = guestfs_mount (g, device, mountpoint);
5526 /* TestOutputList for command_lines (3) */
5528 char remotefilename[] = "/test-command";
5531 r = guestfs_upload (g, "test-command", remotefilename);
5536 char path[] = "/test-command";
5539 r = guestfs_chmod (g, 493, path);
5544 char arguments_0[] = "/test-command";
5545 char arguments_1[] = "4";
5546 char *arguments[] = {
5554 r = guestfs_command_lines (g, arguments);
5558 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5563 char expected[] = "";
5564 if (strcmp (r[0], expected) != 0) {
5565 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5570 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5575 char expected[] = "Result4";
5576 if (strcmp (r[1], expected) != 0) {
5577 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5582 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
5586 for (i = 0; r[i] != NULL; ++i)
5591 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
5595 static int test_command_lines_4_prereq (void)
5597 const char *str = getenv ("SKIP_TEST_COMMAND");
5598 return str && strcmp (str, "1") == 0;
5601 static int test_command_lines_4 (void)
5603 if (! test_command_lines_4_prereq ()) {
5604 /* InitBasicFS for command_lines (4): create ext2 on /dev/sda1 */
5606 char device[] = "/dev/sda";
5607 device[5] = devchar;
5610 r = guestfs_blockdev_setrw (g, device);
5617 r = guestfs_umount_all (g);
5624 r = guestfs_lvm_remove_all (g);
5629 char device[] = "/dev/sda";
5630 device[5] = devchar;
5631 char lines_0[] = ",";
5638 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5643 char fstype[] = "ext2";
5644 char device[] = "/dev/sda1";
5645 device[5] = devchar;
5648 r = guestfs_mkfs (g, fstype, device);
5653 char device[] = "/dev/sda1";
5654 device[5] = devchar;
5655 char mountpoint[] = "/";
5658 r = guestfs_mount (g, device, mountpoint);
5662 /* TestOutputList for command_lines (4) */
5664 char remotefilename[] = "/test-command";
5667 r = guestfs_upload (g, "test-command", remotefilename);
5672 char path[] = "/test-command";
5675 r = guestfs_chmod (g, 493, path);
5680 char arguments_0[] = "/test-command";
5681 char arguments_1[] = "5";
5682 char *arguments[] = {
5690 r = guestfs_command_lines (g, arguments);
5694 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5699 char expected[] = "";
5700 if (strcmp (r[0], expected) != 0) {
5701 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5706 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5711 char expected[] = "Result5";
5712 if (strcmp (r[1], expected) != 0) {
5713 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5718 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5723 char expected[] = "";
5724 if (strcmp (r[2], expected) != 0) {
5725 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5730 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
5734 for (i = 0; r[i] != NULL; ++i)
5739 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
5743 static int test_command_lines_5_prereq (void)
5745 const char *str = getenv ("SKIP_TEST_COMMAND");
5746 return str && strcmp (str, "1") == 0;
5749 static int test_command_lines_5 (void)
5751 if (! test_command_lines_5_prereq ()) {
5752 /* InitBasicFS for command_lines (5): create ext2 on /dev/sda1 */
5754 char device[] = "/dev/sda";
5755 device[5] = devchar;
5758 r = guestfs_blockdev_setrw (g, device);
5765 r = guestfs_umount_all (g);
5772 r = guestfs_lvm_remove_all (g);
5777 char device[] = "/dev/sda";
5778 device[5] = devchar;
5779 char lines_0[] = ",";
5786 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5791 char fstype[] = "ext2";
5792 char device[] = "/dev/sda1";
5793 device[5] = devchar;
5796 r = guestfs_mkfs (g, fstype, device);
5801 char device[] = "/dev/sda1";
5802 device[5] = devchar;
5803 char mountpoint[] = "/";
5806 r = guestfs_mount (g, device, mountpoint);
5810 /* TestOutputList for command_lines (5) */
5812 char remotefilename[] = "/test-command";
5815 r = guestfs_upload (g, "test-command", remotefilename);
5820 char path[] = "/test-command";
5823 r = guestfs_chmod (g, 493, path);
5828 char arguments_0[] = "/test-command";
5829 char arguments_1[] = "6";
5830 char *arguments[] = {
5838 r = guestfs_command_lines (g, arguments);
5842 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5847 char expected[] = "";
5848 if (strcmp (r[0], expected) != 0) {
5849 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5854 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5859 char expected[] = "";
5860 if (strcmp (r[1], expected) != 0) {
5861 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5866 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5871 char expected[] = "Result6";
5872 if (strcmp (r[2], expected) != 0) {
5873 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5878 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5883 char expected[] = "";
5884 if (strcmp (r[3], expected) != 0) {
5885 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
5890 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
5894 for (i = 0; r[i] != NULL; ++i)
5899 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
5903 static int test_command_lines_6_prereq (void)
5905 const char *str = getenv ("SKIP_TEST_COMMAND");
5906 return str && strcmp (str, "1") == 0;
5909 static int test_command_lines_6 (void)
5911 if (! test_command_lines_6_prereq ()) {
5912 /* InitBasicFS for command_lines (6): create ext2 on /dev/sda1 */
5914 char device[] = "/dev/sda";
5915 device[5] = devchar;
5918 r = guestfs_blockdev_setrw (g, device);
5925 r = guestfs_umount_all (g);
5932 r = guestfs_lvm_remove_all (g);
5937 char device[] = "/dev/sda";
5938 device[5] = devchar;
5939 char lines_0[] = ",";
5946 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5951 char fstype[] = "ext2";
5952 char device[] = "/dev/sda1";
5953 device[5] = devchar;
5956 r = guestfs_mkfs (g, fstype, device);
5961 char device[] = "/dev/sda1";
5962 device[5] = devchar;
5963 char mountpoint[] = "/";
5966 r = guestfs_mount (g, device, mountpoint);
5970 /* TestOutputList for command_lines (6) */
5972 char remotefilename[] = "/test-command";
5975 r = guestfs_upload (g, "test-command", remotefilename);
5980 char path[] = "/test-command";
5983 r = guestfs_chmod (g, 493, path);
5988 char arguments_0[] = "/test-command";
5989 char arguments_1[] = "7";
5990 char *arguments[] = {
5998 r = guestfs_command_lines (g, arguments);
6002 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6006 for (i = 0; r[i] != NULL; ++i)
6011 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6015 static int test_command_lines_7_prereq (void)
6017 const char *str = getenv ("SKIP_TEST_COMMAND");
6018 return str && strcmp (str, "1") == 0;
6021 static int test_command_lines_7 (void)
6023 if (! test_command_lines_7_prereq ()) {
6024 /* InitBasicFS for command_lines (7): create ext2 on /dev/sda1 */
6026 char device[] = "/dev/sda";
6027 device[5] = devchar;
6030 r = guestfs_blockdev_setrw (g, device);
6037 r = guestfs_umount_all (g);
6044 r = guestfs_lvm_remove_all (g);
6049 char device[] = "/dev/sda";
6050 device[5] = devchar;
6051 char lines_0[] = ",";
6058 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6063 char fstype[] = "ext2";
6064 char device[] = "/dev/sda1";
6065 device[5] = devchar;
6068 r = guestfs_mkfs (g, fstype, device);
6073 char device[] = "/dev/sda1";
6074 device[5] = devchar;
6075 char mountpoint[] = "/";
6078 r = guestfs_mount (g, device, mountpoint);
6082 /* TestOutputList for command_lines (7) */
6084 char remotefilename[] = "/test-command";
6087 r = guestfs_upload (g, "test-command", remotefilename);
6092 char path[] = "/test-command";
6095 r = guestfs_chmod (g, 493, path);
6100 char arguments_0[] = "/test-command";
6101 char arguments_1[] = "8";
6102 char *arguments[] = {
6110 r = guestfs_command_lines (g, arguments);
6114 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6119 char expected[] = "";
6120 if (strcmp (r[0], expected) != 0) {
6121 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6126 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6130 for (i = 0; r[i] != NULL; ++i)
6135 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6139 static int test_command_lines_8_prereq (void)
6141 const char *str = getenv ("SKIP_TEST_COMMAND");
6142 return str && strcmp (str, "1") == 0;
6145 static int test_command_lines_8 (void)
6147 if (! test_command_lines_8_prereq ()) {
6148 /* InitBasicFS for command_lines (8): create ext2 on /dev/sda1 */
6150 char device[] = "/dev/sda";
6151 device[5] = devchar;
6154 r = guestfs_blockdev_setrw (g, device);
6161 r = guestfs_umount_all (g);
6168 r = guestfs_lvm_remove_all (g);
6173 char device[] = "/dev/sda";
6174 device[5] = devchar;
6175 char lines_0[] = ",";
6182 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6187 char fstype[] = "ext2";
6188 char device[] = "/dev/sda1";
6189 device[5] = devchar;
6192 r = guestfs_mkfs (g, fstype, device);
6197 char device[] = "/dev/sda1";
6198 device[5] = devchar;
6199 char mountpoint[] = "/";
6202 r = guestfs_mount (g, device, mountpoint);
6206 /* TestOutputList for command_lines (8) */
6208 char remotefilename[] = "/test-command";
6211 r = guestfs_upload (g, "test-command", remotefilename);
6216 char path[] = "/test-command";
6219 r = guestfs_chmod (g, 493, path);
6224 char arguments_0[] = "/test-command";
6225 char arguments_1[] = "9";
6226 char *arguments[] = {
6234 r = guestfs_command_lines (g, arguments);
6238 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6243 char expected[] = "";
6244 if (strcmp (r[0], expected) != 0) {
6245 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6250 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6255 char expected[] = "";
6256 if (strcmp (r[1], expected) != 0) {
6257 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6262 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6266 for (i = 0; r[i] != NULL; ++i)
6271 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6275 static int test_command_lines_9_prereq (void)
6277 const char *str = getenv ("SKIP_TEST_COMMAND");
6278 return str && strcmp (str, "1") == 0;
6281 static int test_command_lines_9 (void)
6283 if (! test_command_lines_9_prereq ()) {
6284 /* InitBasicFS for command_lines (9): create ext2 on /dev/sda1 */
6286 char device[] = "/dev/sda";
6287 device[5] = devchar;
6290 r = guestfs_blockdev_setrw (g, device);
6297 r = guestfs_umount_all (g);
6304 r = guestfs_lvm_remove_all (g);
6309 char device[] = "/dev/sda";
6310 device[5] = devchar;
6311 char lines_0[] = ",";
6318 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6323 char fstype[] = "ext2";
6324 char device[] = "/dev/sda1";
6325 device[5] = devchar;
6328 r = guestfs_mkfs (g, fstype, device);
6333 char device[] = "/dev/sda1";
6334 device[5] = devchar;
6335 char mountpoint[] = "/";
6338 r = guestfs_mount (g, device, mountpoint);
6342 /* TestOutputList for command_lines (9) */
6344 char remotefilename[] = "/test-command";
6347 r = guestfs_upload (g, "test-command", remotefilename);
6352 char path[] = "/test-command";
6355 r = guestfs_chmod (g, 493, path);
6360 char arguments_0[] = "/test-command";
6361 char arguments_1[] = "10";
6362 char *arguments[] = {
6370 r = guestfs_command_lines (g, arguments);
6374 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6379 char expected[] = "Result10-1";
6380 if (strcmp (r[0], expected) != 0) {
6381 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6386 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6391 char expected[] = "Result10-2";
6392 if (strcmp (r[1], expected) != 0) {
6393 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6398 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6402 for (i = 0; r[i] != NULL; ++i)
6407 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6411 static int test_command_lines_10_prereq (void)
6413 const char *str = getenv ("SKIP_TEST_COMMAND");
6414 return str && strcmp (str, "1") == 0;
6417 static int test_command_lines_10 (void)
6419 if (! test_command_lines_10_prereq ()) {
6420 /* InitBasicFS for command_lines (10): create ext2 on /dev/sda1 */
6422 char device[] = "/dev/sda";
6423 device[5] = devchar;
6426 r = guestfs_blockdev_setrw (g, device);
6433 r = guestfs_umount_all (g);
6440 r = guestfs_lvm_remove_all (g);
6445 char device[] = "/dev/sda";
6446 device[5] = devchar;
6447 char lines_0[] = ",";
6454 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6459 char fstype[] = "ext2";
6460 char device[] = "/dev/sda1";
6461 device[5] = devchar;
6464 r = guestfs_mkfs (g, fstype, device);
6469 char device[] = "/dev/sda1";
6470 device[5] = devchar;
6471 char mountpoint[] = "/";
6474 r = guestfs_mount (g, device, mountpoint);
6478 /* TestOutputList for command_lines (10) */
6480 char remotefilename[] = "/test-command";
6483 r = guestfs_upload (g, "test-command", remotefilename);
6488 char path[] = "/test-command";
6491 r = guestfs_chmod (g, 493, path);
6496 char arguments_0[] = "/test-command";
6497 char arguments_1[] = "11";
6498 char *arguments[] = {
6506 r = guestfs_command_lines (g, arguments);
6510 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6515 char expected[] = "Result11-1";
6516 if (strcmp (r[0], expected) != 0) {
6517 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6522 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6527 char expected[] = "Result11-2";
6528 if (strcmp (r[1], expected) != 0) {
6529 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6534 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
6538 for (i = 0; r[i] != NULL; ++i)
6543 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
6547 static int test_command_0_prereq (void)
6549 const char *str = getenv ("SKIP_TEST_COMMAND");
6550 return str && strcmp (str, "1") == 0;
6553 static int test_command_0 (void)
6555 if (! test_command_0_prereq ()) {
6556 /* InitBasicFS for command (0): create ext2 on /dev/sda1 */
6558 char device[] = "/dev/sda";
6559 device[5] = devchar;
6562 r = guestfs_blockdev_setrw (g, device);
6569 r = guestfs_umount_all (g);
6576 r = guestfs_lvm_remove_all (g);
6581 char device[] = "/dev/sda";
6582 device[5] = devchar;
6583 char lines_0[] = ",";
6590 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6595 char fstype[] = "ext2";
6596 char device[] = "/dev/sda1";
6597 device[5] = devchar;
6600 r = guestfs_mkfs (g, fstype, device);
6605 char device[] = "/dev/sda1";
6606 device[5] = devchar;
6607 char mountpoint[] = "/";
6610 r = guestfs_mount (g, device, mountpoint);
6614 /* TestOutput for command (0) */
6615 char expected[] = "Result1";
6617 char remotefilename[] = "/test-command";
6620 r = guestfs_upload (g, "test-command", remotefilename);
6625 char path[] = "/test-command";
6628 r = guestfs_chmod (g, 493, path);
6633 char arguments_0[] = "/test-command";
6634 char arguments_1[] = "1";
6635 char *arguments[] = {
6642 r = guestfs_command (g, arguments);
6645 if (strcmp (r, expected) != 0) {
6646 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
6652 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
6656 static int test_command_1_prereq (void)
6658 const char *str = getenv ("SKIP_TEST_COMMAND");
6659 return str && strcmp (str, "1") == 0;
6662 static int test_command_1 (void)
6664 if (! test_command_1_prereq ()) {
6665 /* InitBasicFS for command (1): create ext2 on /dev/sda1 */
6667 char device[] = "/dev/sda";
6668 device[5] = devchar;
6671 r = guestfs_blockdev_setrw (g, device);
6678 r = guestfs_umount_all (g);
6685 r = guestfs_lvm_remove_all (g);
6690 char device[] = "/dev/sda";
6691 device[5] = devchar;
6692 char lines_0[] = ",";
6699 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6704 char fstype[] = "ext2";
6705 char device[] = "/dev/sda1";
6706 device[5] = devchar;
6709 r = guestfs_mkfs (g, fstype, device);
6714 char device[] = "/dev/sda1";
6715 device[5] = devchar;
6716 char mountpoint[] = "/";
6719 r = guestfs_mount (g, device, mountpoint);
6723 /* TestOutput for command (1) */
6724 char expected[] = "Result2\n";
6726 char remotefilename[] = "/test-command";
6729 r = guestfs_upload (g, "test-command", remotefilename);
6734 char path[] = "/test-command";
6737 r = guestfs_chmod (g, 493, path);
6742 char arguments_0[] = "/test-command";
6743 char arguments_1[] = "2";
6744 char *arguments[] = {
6751 r = guestfs_command (g, arguments);
6754 if (strcmp (r, expected) != 0) {
6755 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
6761 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
6765 static int test_command_2_prereq (void)
6767 const char *str = getenv ("SKIP_TEST_COMMAND");
6768 return str && strcmp (str, "1") == 0;
6771 static int test_command_2 (void)
6773 if (! test_command_2_prereq ()) {
6774 /* InitBasicFS for command (2): create ext2 on /dev/sda1 */
6776 char device[] = "/dev/sda";
6777 device[5] = devchar;
6780 r = guestfs_blockdev_setrw (g, device);
6787 r = guestfs_umount_all (g);
6794 r = guestfs_lvm_remove_all (g);
6799 char device[] = "/dev/sda";
6800 device[5] = devchar;
6801 char lines_0[] = ",";
6808 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6813 char fstype[] = "ext2";
6814 char device[] = "/dev/sda1";
6815 device[5] = devchar;
6818 r = guestfs_mkfs (g, fstype, device);
6823 char device[] = "/dev/sda1";
6824 device[5] = devchar;
6825 char mountpoint[] = "/";
6828 r = guestfs_mount (g, device, mountpoint);
6832 /* TestOutput for command (2) */
6833 char expected[] = "\nResult3";
6835 char remotefilename[] = "/test-command";
6838 r = guestfs_upload (g, "test-command", remotefilename);
6843 char path[] = "/test-command";
6846 r = guestfs_chmod (g, 493, path);
6851 char arguments_0[] = "/test-command";
6852 char arguments_1[] = "3";
6853 char *arguments[] = {
6860 r = guestfs_command (g, arguments);
6863 if (strcmp (r, expected) != 0) {
6864 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
6870 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
6874 static int test_command_3_prereq (void)
6876 const char *str = getenv ("SKIP_TEST_COMMAND");
6877 return str && strcmp (str, "1") == 0;
6880 static int test_command_3 (void)
6882 if (! test_command_3_prereq ()) {
6883 /* InitBasicFS for command (3): create ext2 on /dev/sda1 */
6885 char device[] = "/dev/sda";
6886 device[5] = devchar;
6889 r = guestfs_blockdev_setrw (g, device);
6896 r = guestfs_umount_all (g);
6903 r = guestfs_lvm_remove_all (g);
6908 char device[] = "/dev/sda";
6909 device[5] = devchar;
6910 char lines_0[] = ",";
6917 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6922 char fstype[] = "ext2";
6923 char device[] = "/dev/sda1";
6924 device[5] = devchar;
6927 r = guestfs_mkfs (g, fstype, device);
6932 char device[] = "/dev/sda1";
6933 device[5] = devchar;
6934 char mountpoint[] = "/";
6937 r = guestfs_mount (g, device, mountpoint);
6941 /* TestOutput for command (3) */
6942 char expected[] = "\nResult4\n";
6944 char remotefilename[] = "/test-command";
6947 r = guestfs_upload (g, "test-command", remotefilename);
6952 char path[] = "/test-command";
6955 r = guestfs_chmod (g, 493, path);
6960 char arguments_0[] = "/test-command";
6961 char arguments_1[] = "4";
6962 char *arguments[] = {
6969 r = guestfs_command (g, arguments);
6972 if (strcmp (r, expected) != 0) {
6973 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
6979 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
6983 static int test_command_4_prereq (void)
6985 const char *str = getenv ("SKIP_TEST_COMMAND");
6986 return str && strcmp (str, "1") == 0;
6989 static int test_command_4 (void)
6991 if (! test_command_4_prereq ()) {
6992 /* InitBasicFS for command (4): create ext2 on /dev/sda1 */
6994 char device[] = "/dev/sda";
6995 device[5] = devchar;
6998 r = guestfs_blockdev_setrw (g, device);
7005 r = guestfs_umount_all (g);
7012 r = guestfs_lvm_remove_all (g);
7017 char device[] = "/dev/sda";
7018 device[5] = devchar;
7019 char lines_0[] = ",";
7026 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7031 char fstype[] = "ext2";
7032 char device[] = "/dev/sda1";
7033 device[5] = devchar;
7036 r = guestfs_mkfs (g, fstype, device);
7041 char device[] = "/dev/sda1";
7042 device[5] = devchar;
7043 char mountpoint[] = "/";
7046 r = guestfs_mount (g, device, mountpoint);
7050 /* TestOutput for command (4) */
7051 char expected[] = "\nResult5\n\n";
7053 char remotefilename[] = "/test-command";
7056 r = guestfs_upload (g, "test-command", remotefilename);
7061 char path[] = "/test-command";
7064 r = guestfs_chmod (g, 493, path);
7069 char arguments_0[] = "/test-command";
7070 char arguments_1[] = "5";
7071 char *arguments[] = {
7078 r = guestfs_command (g, arguments);
7081 if (strcmp (r, expected) != 0) {
7082 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7088 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7092 static int test_command_5_prereq (void)
7094 const char *str = getenv ("SKIP_TEST_COMMAND");
7095 return str && strcmp (str, "1") == 0;
7098 static int test_command_5 (void)
7100 if (! test_command_5_prereq ()) {
7101 /* InitBasicFS for command (5): create ext2 on /dev/sda1 */
7103 char device[] = "/dev/sda";
7104 device[5] = devchar;
7107 r = guestfs_blockdev_setrw (g, device);
7114 r = guestfs_umount_all (g);
7121 r = guestfs_lvm_remove_all (g);
7126 char device[] = "/dev/sda";
7127 device[5] = devchar;
7128 char lines_0[] = ",";
7135 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7140 char fstype[] = "ext2";
7141 char device[] = "/dev/sda1";
7142 device[5] = devchar;
7145 r = guestfs_mkfs (g, fstype, device);
7150 char device[] = "/dev/sda1";
7151 device[5] = devchar;
7152 char mountpoint[] = "/";
7155 r = guestfs_mount (g, device, mountpoint);
7159 /* TestOutput for command (5) */
7160 char expected[] = "\n\nResult6\n\n";
7162 char remotefilename[] = "/test-command";
7165 r = guestfs_upload (g, "test-command", remotefilename);
7170 char path[] = "/test-command";
7173 r = guestfs_chmod (g, 493, path);
7178 char arguments_0[] = "/test-command";
7179 char arguments_1[] = "6";
7180 char *arguments[] = {
7187 r = guestfs_command (g, arguments);
7190 if (strcmp (r, expected) != 0) {
7191 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7197 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7201 static int test_command_6_prereq (void)
7203 const char *str = getenv ("SKIP_TEST_COMMAND");
7204 return str && strcmp (str, "1") == 0;
7207 static int test_command_6 (void)
7209 if (! test_command_6_prereq ()) {
7210 /* InitBasicFS for command (6): create ext2 on /dev/sda1 */
7212 char device[] = "/dev/sda";
7213 device[5] = devchar;
7216 r = guestfs_blockdev_setrw (g, device);
7223 r = guestfs_umount_all (g);
7230 r = guestfs_lvm_remove_all (g);
7235 char device[] = "/dev/sda";
7236 device[5] = devchar;
7237 char lines_0[] = ",";
7244 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7249 char fstype[] = "ext2";
7250 char device[] = "/dev/sda1";
7251 device[5] = devchar;
7254 r = guestfs_mkfs (g, fstype, device);
7259 char device[] = "/dev/sda1";
7260 device[5] = devchar;
7261 char mountpoint[] = "/";
7264 r = guestfs_mount (g, device, mountpoint);
7268 /* TestOutput for command (6) */
7269 char expected[] = "";
7271 char remotefilename[] = "/test-command";
7274 r = guestfs_upload (g, "test-command", remotefilename);
7279 char path[] = "/test-command";
7282 r = guestfs_chmod (g, 493, path);
7287 char arguments_0[] = "/test-command";
7288 char arguments_1[] = "7";
7289 char *arguments[] = {
7296 r = guestfs_command (g, arguments);
7299 if (strcmp (r, expected) != 0) {
7300 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7306 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7310 static int test_command_7_prereq (void)
7312 const char *str = getenv ("SKIP_TEST_COMMAND");
7313 return str && strcmp (str, "1") == 0;
7316 static int test_command_7 (void)
7318 if (! test_command_7_prereq ()) {
7319 /* InitBasicFS for command (7): create ext2 on /dev/sda1 */
7321 char device[] = "/dev/sda";
7322 device[5] = devchar;
7325 r = guestfs_blockdev_setrw (g, device);
7332 r = guestfs_umount_all (g);
7339 r = guestfs_lvm_remove_all (g);
7344 char device[] = "/dev/sda";
7345 device[5] = devchar;
7346 char lines_0[] = ",";
7353 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7358 char fstype[] = "ext2";
7359 char device[] = "/dev/sda1";
7360 device[5] = devchar;
7363 r = guestfs_mkfs (g, fstype, device);
7368 char device[] = "/dev/sda1";
7369 device[5] = devchar;
7370 char mountpoint[] = "/";
7373 r = guestfs_mount (g, device, mountpoint);
7377 /* TestOutput for command (7) */
7378 char expected[] = "\n";
7380 char remotefilename[] = "/test-command";
7383 r = guestfs_upload (g, "test-command", remotefilename);
7388 char path[] = "/test-command";
7391 r = guestfs_chmod (g, 493, path);
7396 char arguments_0[] = "/test-command";
7397 char arguments_1[] = "8";
7398 char *arguments[] = {
7405 r = guestfs_command (g, arguments);
7408 if (strcmp (r, expected) != 0) {
7409 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7415 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7419 static int test_command_8_prereq (void)
7421 const char *str = getenv ("SKIP_TEST_COMMAND");
7422 return str && strcmp (str, "1") == 0;
7425 static int test_command_8 (void)
7427 if (! test_command_8_prereq ()) {
7428 /* InitBasicFS for command (8): create ext2 on /dev/sda1 */
7430 char device[] = "/dev/sda";
7431 device[5] = devchar;
7434 r = guestfs_blockdev_setrw (g, device);
7441 r = guestfs_umount_all (g);
7448 r = guestfs_lvm_remove_all (g);
7453 char device[] = "/dev/sda";
7454 device[5] = devchar;
7455 char lines_0[] = ",";
7462 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7467 char fstype[] = "ext2";
7468 char device[] = "/dev/sda1";
7469 device[5] = devchar;
7472 r = guestfs_mkfs (g, fstype, device);
7477 char device[] = "/dev/sda1";
7478 device[5] = devchar;
7479 char mountpoint[] = "/";
7482 r = guestfs_mount (g, device, mountpoint);
7486 /* TestOutput for command (8) */
7487 char expected[] = "\n\n";
7489 char remotefilename[] = "/test-command";
7492 r = guestfs_upload (g, "test-command", remotefilename);
7497 char path[] = "/test-command";
7500 r = guestfs_chmod (g, 493, path);
7505 char arguments_0[] = "/test-command";
7506 char arguments_1[] = "9";
7507 char *arguments[] = {
7514 r = guestfs_command (g, arguments);
7517 if (strcmp (r, expected) != 0) {
7518 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
7524 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
7528 static int test_command_9_prereq (void)
7530 const char *str = getenv ("SKIP_TEST_COMMAND");
7531 return str && strcmp (str, "1") == 0;
7534 static int test_command_9 (void)
7536 if (! test_command_9_prereq ()) {
7537 /* InitBasicFS for command (9): create ext2 on /dev/sda1 */
7539 char device[] = "/dev/sda";
7540 device[5] = devchar;
7543 r = guestfs_blockdev_setrw (g, device);
7550 r = guestfs_umount_all (g);
7557 r = guestfs_lvm_remove_all (g);
7562 char device[] = "/dev/sda";
7563 device[5] = devchar;
7564 char lines_0[] = ",";
7571 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7576 char fstype[] = "ext2";
7577 char device[] = "/dev/sda1";
7578 device[5] = devchar;
7581 r = guestfs_mkfs (g, fstype, device);
7586 char device[] = "/dev/sda1";
7587 device[5] = devchar;
7588 char mountpoint[] = "/";
7591 r = guestfs_mount (g, device, mountpoint);
7595 /* TestOutput for command (9) */
7596 char expected[] = "Result10-1\nResult10-2\n";
7598 char remotefilename[] = "/test-command";
7601 r = guestfs_upload (g, "test-command", remotefilename);
7606 char path[] = "/test-command";
7609 r = guestfs_chmod (g, 493, path);
7614 char arguments_0[] = "/test-command";
7615 char arguments_1[] = "10";
7616 char *arguments[] = {
7623 r = guestfs_command (g, arguments);
7626 if (strcmp (r, expected) != 0) {
7627 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
7633 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
7637 static int test_command_10_prereq (void)
7639 const char *str = getenv ("SKIP_TEST_COMMAND");
7640 return str && strcmp (str, "1") == 0;
7643 static int test_command_10 (void)
7645 if (! test_command_10_prereq ()) {
7646 /* InitBasicFS for command (10): create ext2 on /dev/sda1 */
7648 char device[] = "/dev/sda";
7649 device[5] = devchar;
7652 r = guestfs_blockdev_setrw (g, device);
7659 r = guestfs_umount_all (g);
7666 r = guestfs_lvm_remove_all (g);
7671 char device[] = "/dev/sda";
7672 device[5] = devchar;
7673 char lines_0[] = ",";
7680 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7685 char fstype[] = "ext2";
7686 char device[] = "/dev/sda1";
7687 device[5] = devchar;
7690 r = guestfs_mkfs (g, fstype, device);
7695 char device[] = "/dev/sda1";
7696 device[5] = devchar;
7697 char mountpoint[] = "/";
7700 r = guestfs_mount (g, device, mountpoint);
7704 /* TestOutput for command (10) */
7705 char expected[] = "Result11-1\nResult11-2";
7707 char remotefilename[] = "/test-command";
7710 r = guestfs_upload (g, "test-command", remotefilename);
7715 char path[] = "/test-command";
7718 r = guestfs_chmod (g, 493, path);
7723 char arguments_0[] = "/test-command";
7724 char arguments_1[] = "11";
7725 char *arguments[] = {
7732 r = guestfs_command (g, arguments);
7735 if (strcmp (r, expected) != 0) {
7736 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
7742 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
7746 static int test_command_11_prereq (void)
7748 const char *str = getenv ("SKIP_TEST_COMMAND");
7749 return str && strcmp (str, "1") == 0;
7752 static int test_command_11 (void)
7754 if (! test_command_11_prereq ()) {
7755 /* InitBasicFS for command (11): create ext2 on /dev/sda1 */
7757 char device[] = "/dev/sda";
7758 device[5] = devchar;
7761 r = guestfs_blockdev_setrw (g, device);
7768 r = guestfs_umount_all (g);
7775 r = guestfs_lvm_remove_all (g);
7780 char device[] = "/dev/sda";
7781 device[5] = devchar;
7782 char lines_0[] = ",";
7789 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7794 char fstype[] = "ext2";
7795 char device[] = "/dev/sda1";
7796 device[5] = devchar;
7799 r = guestfs_mkfs (g, fstype, device);
7804 char device[] = "/dev/sda1";
7805 device[5] = devchar;
7806 char mountpoint[] = "/";
7809 r = guestfs_mount (g, device, mountpoint);
7813 /* TestLastFail for command (11) */
7815 char remotefilename[] = "/test-command";
7818 r = guestfs_upload (g, "test-command", remotefilename);
7823 char path[] = "/test-command";
7826 r = guestfs_chmod (g, 493, path);
7831 char arguments_0[] = "/test-command";
7832 char *arguments[] = {
7838 r = guestfs_command (g, arguments);
7844 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
7848 static int test_file_0 (void)
7850 /* InitBasicFS for file (0): create ext2 on /dev/sda1 */
7852 char device[] = "/dev/sda";
7853 device[5] = devchar;
7856 r = guestfs_blockdev_setrw (g, device);
7863 r = guestfs_umount_all (g);
7870 r = guestfs_lvm_remove_all (g);
7875 char device[] = "/dev/sda";
7876 device[5] = devchar;
7877 char lines_0[] = ",";
7884 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7889 char fstype[] = "ext2";
7890 char device[] = "/dev/sda1";
7891 device[5] = devchar;
7894 r = guestfs_mkfs (g, fstype, device);
7899 char device[] = "/dev/sda1";
7900 device[5] = devchar;
7901 char mountpoint[] = "/";
7904 r = guestfs_mount (g, device, mountpoint);
7908 /* TestOutput for file (0) */
7909 char expected[] = "empty";
7911 char path[] = "/new";
7914 r = guestfs_touch (g, path);
7919 char path[] = "/new";
7922 r = guestfs_file (g, path);
7925 if (strcmp (r, expected) != 0) {
7926 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
7934 static int test_file_1 (void)
7936 /* InitBasicFS for file (1): create ext2 on /dev/sda1 */
7938 char device[] = "/dev/sda";
7939 device[5] = devchar;
7942 r = guestfs_blockdev_setrw (g, device);
7949 r = guestfs_umount_all (g);
7956 r = guestfs_lvm_remove_all (g);
7961 char device[] = "/dev/sda";
7962 device[5] = devchar;
7963 char lines_0[] = ",";
7970 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7975 char fstype[] = "ext2";
7976 char device[] = "/dev/sda1";
7977 device[5] = devchar;
7980 r = guestfs_mkfs (g, fstype, device);
7985 char device[] = "/dev/sda1";
7986 device[5] = devchar;
7987 char mountpoint[] = "/";
7990 r = guestfs_mount (g, device, mountpoint);
7994 /* TestOutput for file (1) */
7995 char expected[] = "ASCII text";
7997 char path[] = "/new";
7998 char content[] = "some content\n";
8001 r = guestfs_write_file (g, path, content, 0);
8006 char path[] = "/new";
8009 r = guestfs_file (g, path);
8012 if (strcmp (r, expected) != 0) {
8013 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8021 static int test_file_2 (void)
8023 /* InitBasicFS for file (2): create ext2 on /dev/sda1 */
8025 char device[] = "/dev/sda";
8026 device[5] = devchar;
8029 r = guestfs_blockdev_setrw (g, device);
8036 r = guestfs_umount_all (g);
8043 r = guestfs_lvm_remove_all (g);
8048 char device[] = "/dev/sda";
8049 device[5] = devchar;
8050 char lines_0[] = ",";
8057 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8062 char fstype[] = "ext2";
8063 char device[] = "/dev/sda1";
8064 device[5] = devchar;
8067 r = guestfs_mkfs (g, fstype, device);
8072 char device[] = "/dev/sda1";
8073 device[5] = devchar;
8074 char mountpoint[] = "/";
8077 r = guestfs_mount (g, device, mountpoint);
8081 /* TestLastFail for file (2) */
8083 char path[] = "/nofile";
8086 r = guestfs_file (g, path);
8094 static int test_umount_all_0 (void)
8096 /* InitBasicFS for umount_all (0): create ext2 on /dev/sda1 */
8098 char device[] = "/dev/sda";
8099 device[5] = devchar;
8102 r = guestfs_blockdev_setrw (g, device);
8109 r = guestfs_umount_all (g);
8116 r = guestfs_lvm_remove_all (g);
8121 char device[] = "/dev/sda";
8122 device[5] = devchar;
8123 char lines_0[] = ",";
8130 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8135 char fstype[] = "ext2";
8136 char device[] = "/dev/sda1";
8137 device[5] = devchar;
8140 r = guestfs_mkfs (g, fstype, device);
8145 char device[] = "/dev/sda1";
8146 device[5] = devchar;
8147 char mountpoint[] = "/";
8150 r = guestfs_mount (g, device, mountpoint);
8154 /* TestOutputList for umount_all (0) */
8158 r = guestfs_umount_all (g);
8166 r = guestfs_mounts (g);
8170 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8174 for (i = 0; r[i] != NULL; ++i)
8181 static int test_umount_all_1 (void)
8183 /* InitEmpty for umount_all (1) */
8185 char device[] = "/dev/sda";
8186 device[5] = devchar;
8189 r = guestfs_blockdev_setrw (g, device);
8196 r = guestfs_umount_all (g);
8203 r = guestfs_lvm_remove_all (g);
8207 /* TestOutputList for umount_all (1) */
8209 char device[] = "/dev/sda";
8210 device[5] = devchar;
8211 char lines_0[] = ",10";
8212 char lines_1[] = ",20";
8213 char lines_2[] = ",";
8222 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8227 char fstype[] = "ext2";
8228 char device[] = "/dev/sda1";
8229 device[5] = devchar;
8232 r = guestfs_mkfs (g, fstype, device);
8237 char fstype[] = "ext2";
8238 char device[] = "/dev/sda2";
8239 device[5] = devchar;
8242 r = guestfs_mkfs (g, fstype, device);
8247 char fstype[] = "ext2";
8248 char device[] = "/dev/sda3";
8249 device[5] = devchar;
8252 r = guestfs_mkfs (g, fstype, device);
8257 char device[] = "/dev/sda1";
8258 device[5] = devchar;
8259 char mountpoint[] = "/";
8262 r = guestfs_mount (g, device, mountpoint);
8267 char path[] = "/mp1";
8270 r = guestfs_mkdir (g, path);
8275 char device[] = "/dev/sda2";
8276 device[5] = devchar;
8277 char mountpoint[] = "/mp1";
8280 r = guestfs_mount (g, device, mountpoint);
8285 char path[] = "/mp1/mp2";
8288 r = guestfs_mkdir (g, path);
8293 char device[] = "/dev/sda3";
8294 device[5] = devchar;
8295 char mountpoint[] = "/mp1/mp2";
8298 r = guestfs_mount (g, device, mountpoint);
8303 char path[] = "/mp1/mp2/mp3";
8306 r = guestfs_mkdir (g, path);
8313 r = guestfs_umount_all (g);
8321 r = guestfs_mounts (g);
8325 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8329 for (i = 0; r[i] != NULL; ++i)
8336 static int test_mounts_0 (void)
8338 /* InitBasicFS for mounts (0): create ext2 on /dev/sda1 */
8340 char device[] = "/dev/sda";
8341 device[5] = devchar;
8344 r = guestfs_blockdev_setrw (g, device);
8351 r = guestfs_umount_all (g);
8358 r = guestfs_lvm_remove_all (g);
8363 char device[] = "/dev/sda";
8364 device[5] = devchar;
8365 char lines_0[] = ",";
8372 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8377 char fstype[] = "ext2";
8378 char device[] = "/dev/sda1";
8379 device[5] = devchar;
8382 r = guestfs_mkfs (g, fstype, device);
8387 char device[] = "/dev/sda1";
8388 device[5] = devchar;
8389 char mountpoint[] = "/";
8392 r = guestfs_mount (g, device, mountpoint);
8396 /* TestOutputList for mounts (0) */
8401 r = guestfs_mounts (g);
8405 fprintf (stderr, "test_mounts_0: short list returned from command\n");
8410 char expected[] = "/dev/sda1";
8411 expected[5] = devchar;
8412 if (strcmp (r[0], expected) != 0) {
8413 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8418 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8422 for (i = 0; r[i] != NULL; ++i)
8429 static int test_umount_0 (void)
8431 /* InitEmpty for umount (0) */
8433 char device[] = "/dev/sda";
8434 device[5] = devchar;
8437 r = guestfs_blockdev_setrw (g, device);
8444 r = guestfs_umount_all (g);
8451 r = guestfs_lvm_remove_all (g);
8455 /* TestOutputList for umount (0) */
8457 char device[] = "/dev/sda";
8458 device[5] = devchar;
8459 char lines_0[] = ",";
8466 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8471 char fstype[] = "ext2";
8472 char device[] = "/dev/sda1";
8473 device[5] = devchar;
8476 r = guestfs_mkfs (g, fstype, device);
8481 char device[] = "/dev/sda1";
8482 device[5] = devchar;
8483 char mountpoint[] = "/";
8486 r = guestfs_mount (g, device, mountpoint);
8494 r = guestfs_mounts (g);
8498 fprintf (stderr, "test_umount_0: short list returned from command\n");
8503 char expected[] = "/dev/sda1";
8504 expected[5] = devchar;
8505 if (strcmp (r[0], expected) != 0) {
8506 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8511 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
8515 for (i = 0; r[i] != NULL; ++i)
8522 static int test_umount_1 (void)
8524 /* InitEmpty for umount (1) */
8526 char device[] = "/dev/sda";
8527 device[5] = devchar;
8530 r = guestfs_blockdev_setrw (g, device);
8537 r = guestfs_umount_all (g);
8544 r = guestfs_lvm_remove_all (g);
8548 /* TestOutputList for umount (1) */
8550 char device[] = "/dev/sda";
8551 device[5] = devchar;
8552 char lines_0[] = ",";
8559 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8564 char fstype[] = "ext2";
8565 char device[] = "/dev/sda1";
8566 device[5] = devchar;
8569 r = guestfs_mkfs (g, fstype, device);
8574 char device[] = "/dev/sda1";
8575 device[5] = devchar;
8576 char mountpoint[] = "/";
8579 r = guestfs_mount (g, device, mountpoint);
8584 char pathordevice[] = "/";
8587 r = guestfs_umount (g, pathordevice);
8595 r = guestfs_mounts (g);
8599 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
8603 for (i = 0; r[i] != NULL; ++i)
8610 static int test_write_file_0 (void)
8612 /* InitBasicFS for write_file (0): create ext2 on /dev/sda1 */
8614 char device[] = "/dev/sda";
8615 device[5] = devchar;
8618 r = guestfs_blockdev_setrw (g, device);
8625 r = guestfs_umount_all (g);
8632 r = guestfs_lvm_remove_all (g);
8637 char device[] = "/dev/sda";
8638 device[5] = devchar;
8639 char lines_0[] = ",";
8646 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8651 char fstype[] = "ext2";
8652 char device[] = "/dev/sda1";
8653 device[5] = devchar;
8656 r = guestfs_mkfs (g, fstype, device);
8661 char device[] = "/dev/sda1";
8662 device[5] = devchar;
8663 char mountpoint[] = "/";
8666 r = guestfs_mount (g, device, mountpoint);
8670 /* TestOutput for write_file (0) */
8671 char expected[] = "new file contents";
8673 char path[] = "/new";
8674 char content[] = "new file contents";
8677 r = guestfs_write_file (g, path, content, 0);
8682 char path[] = "/new";
8685 r = guestfs_cat (g, path);
8688 if (strcmp (r, expected) != 0) {
8689 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8697 static int test_write_file_1 (void)
8699 /* InitBasicFS for write_file (1): create ext2 on /dev/sda1 */
8701 char device[] = "/dev/sda";
8702 device[5] = devchar;
8705 r = guestfs_blockdev_setrw (g, device);
8712 r = guestfs_umount_all (g);
8719 r = guestfs_lvm_remove_all (g);
8724 char device[] = "/dev/sda";
8725 device[5] = devchar;
8726 char lines_0[] = ",";
8733 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8738 char fstype[] = "ext2";
8739 char device[] = "/dev/sda1";
8740 device[5] = devchar;
8743 r = guestfs_mkfs (g, fstype, device);
8748 char device[] = "/dev/sda1";
8749 device[5] = devchar;
8750 char mountpoint[] = "/";
8753 r = guestfs_mount (g, device, mountpoint);
8757 /* TestOutput for write_file (1) */
8758 char expected[] = "\nnew file contents\n";
8760 char path[] = "/new";
8761 char content[] = "\nnew file contents\n";
8764 r = guestfs_write_file (g, path, content, 0);
8769 char path[] = "/new";
8772 r = guestfs_cat (g, path);
8775 if (strcmp (r, expected) != 0) {
8776 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8784 static int test_write_file_2 (void)
8786 /* InitBasicFS for write_file (2): create ext2 on /dev/sda1 */
8788 char device[] = "/dev/sda";
8789 device[5] = devchar;
8792 r = guestfs_blockdev_setrw (g, device);
8799 r = guestfs_umount_all (g);
8806 r = guestfs_lvm_remove_all (g);
8811 char device[] = "/dev/sda";
8812 device[5] = devchar;
8813 char lines_0[] = ",";
8820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8825 char fstype[] = "ext2";
8826 char device[] = "/dev/sda1";
8827 device[5] = devchar;
8830 r = guestfs_mkfs (g, fstype, device);
8835 char device[] = "/dev/sda1";
8836 device[5] = devchar;
8837 char mountpoint[] = "/";
8840 r = guestfs_mount (g, device, mountpoint);
8844 /* TestOutput for write_file (2) */
8845 char expected[] = "\n\n";
8847 char path[] = "/new";
8848 char content[] = "\n\n";
8851 r = guestfs_write_file (g, path, content, 0);
8856 char path[] = "/new";
8859 r = guestfs_cat (g, path);
8862 if (strcmp (r, expected) != 0) {
8863 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
8871 static int test_write_file_3 (void)
8873 /* InitBasicFS for write_file (3): create ext2 on /dev/sda1 */
8875 char device[] = "/dev/sda";
8876 device[5] = devchar;
8879 r = guestfs_blockdev_setrw (g, device);
8886 r = guestfs_umount_all (g);
8893 r = guestfs_lvm_remove_all (g);
8898 char device[] = "/dev/sda";
8899 device[5] = devchar;
8900 char lines_0[] = ",";
8907 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8912 char fstype[] = "ext2";
8913 char device[] = "/dev/sda1";
8914 device[5] = devchar;
8917 r = guestfs_mkfs (g, fstype, device);
8922 char device[] = "/dev/sda1";
8923 device[5] = devchar;
8924 char mountpoint[] = "/";
8927 r = guestfs_mount (g, device, mountpoint);
8931 /* TestOutput for write_file (3) */
8932 char expected[] = "";
8934 char path[] = "/new";
8935 char content[] = "";
8938 r = guestfs_write_file (g, path, content, 0);
8943 char path[] = "/new";
8946 r = guestfs_cat (g, path);
8949 if (strcmp (r, expected) != 0) {
8950 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
8958 static int test_write_file_4 (void)
8960 /* InitBasicFS for write_file (4): create ext2 on /dev/sda1 */
8962 char device[] = "/dev/sda";
8963 device[5] = devchar;
8966 r = guestfs_blockdev_setrw (g, device);
8973 r = guestfs_umount_all (g);
8980 r = guestfs_lvm_remove_all (g);
8985 char device[] = "/dev/sda";
8986 device[5] = devchar;
8987 char lines_0[] = ",";
8994 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8999 char fstype[] = "ext2";
9000 char device[] = "/dev/sda1";
9001 device[5] = devchar;
9004 r = guestfs_mkfs (g, fstype, device);
9009 char device[] = "/dev/sda1";
9010 device[5] = devchar;
9011 char mountpoint[] = "/";
9014 r = guestfs_mount (g, device, mountpoint);
9018 /* TestOutput for write_file (4) */
9019 char expected[] = "\n\n\n";
9021 char path[] = "/new";
9022 char content[] = "\n\n\n";
9025 r = guestfs_write_file (g, path, content, 0);
9030 char path[] = "/new";
9033 r = guestfs_cat (g, path);
9036 if (strcmp (r, expected) != 0) {
9037 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9045 static int test_write_file_5 (void)
9047 /* InitBasicFS for write_file (5): create ext2 on /dev/sda1 */
9049 char device[] = "/dev/sda";
9050 device[5] = devchar;
9053 r = guestfs_blockdev_setrw (g, device);
9060 r = guestfs_umount_all (g);
9067 r = guestfs_lvm_remove_all (g);
9072 char device[] = "/dev/sda";
9073 device[5] = devchar;
9074 char lines_0[] = ",";
9081 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9086 char fstype[] = "ext2";
9087 char device[] = "/dev/sda1";
9088 device[5] = devchar;
9091 r = guestfs_mkfs (g, fstype, device);
9096 char device[] = "/dev/sda1";
9097 device[5] = devchar;
9098 char mountpoint[] = "/";
9101 r = guestfs_mount (g, device, mountpoint);
9105 /* TestOutput for write_file (5) */
9106 char expected[] = "\n";
9108 char path[] = "/new";
9109 char content[] = "\n";
9112 r = guestfs_write_file (g, path, content, 0);
9117 char path[] = "/new";
9120 r = guestfs_cat (g, path);
9123 if (strcmp (r, expected) != 0) {
9124 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9132 static int test_mkfs_0 (void)
9134 /* InitEmpty for mkfs (0) */
9136 char device[] = "/dev/sda";
9137 device[5] = devchar;
9140 r = guestfs_blockdev_setrw (g, device);
9147 r = guestfs_umount_all (g);
9154 r = guestfs_lvm_remove_all (g);
9158 /* TestOutput for mkfs (0) */
9159 char expected[] = "new file contents";
9161 char device[] = "/dev/sda";
9162 device[5] = devchar;
9163 char lines_0[] = ",";
9170 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9175 char fstype[] = "ext2";
9176 char device[] = "/dev/sda1";
9177 device[5] = devchar;
9180 r = guestfs_mkfs (g, fstype, device);
9185 char device[] = "/dev/sda1";
9186 device[5] = devchar;
9187 char mountpoint[] = "/";
9190 r = guestfs_mount (g, device, mountpoint);
9195 char path[] = "/new";
9196 char content[] = "new file contents";
9199 r = guestfs_write_file (g, path, content, 0);
9204 char path[] = "/new";
9207 r = guestfs_cat (g, path);
9210 if (strcmp (r, expected) != 0) {
9211 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9219 static int test_lvcreate_0 (void)
9221 /* InitEmpty for lvcreate (0) */
9223 char device[] = "/dev/sda";
9224 device[5] = devchar;
9227 r = guestfs_blockdev_setrw (g, device);
9234 r = guestfs_umount_all (g);
9241 r = guestfs_lvm_remove_all (g);
9245 /* TestOutputList for lvcreate (0) */
9247 char device[] = "/dev/sda";
9248 device[5] = devchar;
9249 char lines_0[] = ",10";
9250 char lines_1[] = ",20";
9251 char lines_2[] = ",";
9260 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9265 char device[] = "/dev/sda1";
9266 device[5] = devchar;
9269 r = guestfs_pvcreate (g, device);
9274 char device[] = "/dev/sda2";
9275 device[5] = devchar;
9278 r = guestfs_pvcreate (g, device);
9283 char device[] = "/dev/sda3";
9284 device[5] = devchar;
9287 r = guestfs_pvcreate (g, device);
9292 char volgroup[] = "VG1";
9293 char physvols_0[] = "/dev/sda1";
9294 physvols_0[5] = devchar;
9295 char physvols_1[] = "/dev/sda2";
9296 physvols_1[5] = devchar;
9297 char *physvols[] = {
9304 r = guestfs_vgcreate (g, volgroup, physvols);
9309 char volgroup[] = "VG2";
9310 char physvols_0[] = "/dev/sda3";
9311 physvols_0[5] = devchar;
9312 char *physvols[] = {
9318 r = guestfs_vgcreate (g, volgroup, physvols);
9323 char logvol[] = "LV1";
9324 char volgroup[] = "VG1";
9327 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9332 char logvol[] = "LV2";
9333 char volgroup[] = "VG1";
9336 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9341 char logvol[] = "LV3";
9342 char volgroup[] = "VG2";
9345 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9350 char logvol[] = "LV4";
9351 char volgroup[] = "VG2";
9354 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9359 char logvol[] = "LV5";
9360 char volgroup[] = "VG2";
9363 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9371 r = guestfs_lvs (g);
9375 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9380 char expected[] = "/dev/VG1/LV1";
9381 if (strcmp (r[0], expected) != 0) {
9382 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9387 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9392 char expected[] = "/dev/VG1/LV2";
9393 if (strcmp (r[1], expected) != 0) {
9394 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9399 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9404 char expected[] = "/dev/VG2/LV3";
9405 if (strcmp (r[2], expected) != 0) {
9406 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9411 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9416 char expected[] = "/dev/VG2/LV4";
9417 if (strcmp (r[3], expected) != 0) {
9418 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9423 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9428 char expected[] = "/dev/VG2/LV5";
9429 if (strcmp (r[4], expected) != 0) {
9430 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9435 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9439 for (i = 0; r[i] != NULL; ++i)
9446 static int test_vgcreate_0 (void)
9448 /* InitEmpty for vgcreate (0) */
9450 char device[] = "/dev/sda";
9451 device[5] = devchar;
9454 r = guestfs_blockdev_setrw (g, device);
9461 r = guestfs_umount_all (g);
9468 r = guestfs_lvm_remove_all (g);
9472 /* TestOutputList for vgcreate (0) */
9474 char device[] = "/dev/sda";
9475 device[5] = devchar;
9476 char lines_0[] = ",10";
9477 char lines_1[] = ",20";
9478 char lines_2[] = ",";
9487 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9492 char device[] = "/dev/sda1";
9493 device[5] = devchar;
9496 r = guestfs_pvcreate (g, device);
9501 char device[] = "/dev/sda2";
9502 device[5] = devchar;
9505 r = guestfs_pvcreate (g, device);
9510 char device[] = "/dev/sda3";
9511 device[5] = devchar;
9514 r = guestfs_pvcreate (g, device);
9519 char volgroup[] = "VG1";
9520 char physvols_0[] = "/dev/sda1";
9521 physvols_0[5] = devchar;
9522 char physvols_1[] = "/dev/sda2";
9523 physvols_1[5] = devchar;
9524 char *physvols[] = {
9531 r = guestfs_vgcreate (g, volgroup, physvols);
9536 char volgroup[] = "VG2";
9537 char physvols_0[] = "/dev/sda3";
9538 physvols_0[5] = devchar;
9539 char *physvols[] = {
9545 r = guestfs_vgcreate (g, volgroup, physvols);
9553 r = guestfs_vgs (g);
9557 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9562 char expected[] = "VG1";
9563 if (strcmp (r[0], expected) != 0) {
9564 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9569 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9574 char expected[] = "VG2";
9575 if (strcmp (r[1], expected) != 0) {
9576 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9581 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
9585 for (i = 0; r[i] != NULL; ++i)
9592 static int test_pvcreate_0 (void)
9594 /* InitEmpty for pvcreate (0) */
9596 char device[] = "/dev/sda";
9597 device[5] = devchar;
9600 r = guestfs_blockdev_setrw (g, device);
9607 r = guestfs_umount_all (g);
9614 r = guestfs_lvm_remove_all (g);
9618 /* TestOutputList for pvcreate (0) */
9620 char device[] = "/dev/sda";
9621 device[5] = devchar;
9622 char lines_0[] = ",10";
9623 char lines_1[] = ",20";
9624 char lines_2[] = ",";
9633 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9638 char device[] = "/dev/sda1";
9639 device[5] = devchar;
9642 r = guestfs_pvcreate (g, device);
9647 char device[] = "/dev/sda2";
9648 device[5] = devchar;
9651 r = guestfs_pvcreate (g, device);
9656 char device[] = "/dev/sda3";
9657 device[5] = devchar;
9660 r = guestfs_pvcreate (g, device);
9668 r = guestfs_pvs (g);
9672 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9677 char expected[] = "/dev/sda1";
9678 expected[5] = devchar;
9679 if (strcmp (r[0], expected) != 0) {
9680 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9685 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9690 char expected[] = "/dev/sda2";
9691 expected[5] = devchar;
9692 if (strcmp (r[1], expected) != 0) {
9693 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9698 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9703 char expected[] = "/dev/sda3";
9704 expected[5] = devchar;
9705 if (strcmp (r[2], expected) != 0) {
9706 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9711 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
9715 for (i = 0; r[i] != NULL; ++i)
9722 static int test_is_dir_0 (void)
9724 /* InitBasicFS for is_dir (0): create ext2 on /dev/sda1 */
9726 char device[] = "/dev/sda";
9727 device[5] = devchar;
9730 r = guestfs_blockdev_setrw (g, device);
9737 r = guestfs_umount_all (g);
9744 r = guestfs_lvm_remove_all (g);
9749 char device[] = "/dev/sda";
9750 device[5] = devchar;
9751 char lines_0[] = ",";
9758 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9763 char fstype[] = "ext2";
9764 char device[] = "/dev/sda1";
9765 device[5] = devchar;
9768 r = guestfs_mkfs (g, fstype, device);
9773 char device[] = "/dev/sda1";
9774 device[5] = devchar;
9775 char mountpoint[] = "/";
9778 r = guestfs_mount (g, device, mountpoint);
9782 /* TestOutputFalse for is_dir (0) */
9784 char path[] = "/new";
9787 r = guestfs_touch (g, path);
9792 char path[] = "/new";
9795 r = guestfs_is_dir (g, path);
9799 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
9806 static int test_is_dir_1 (void)
9808 /* InitBasicFS for is_dir (1): create ext2 on /dev/sda1 */
9810 char device[] = "/dev/sda";
9811 device[5] = devchar;
9814 r = guestfs_blockdev_setrw (g, device);
9821 r = guestfs_umount_all (g);
9828 r = guestfs_lvm_remove_all (g);
9833 char device[] = "/dev/sda";
9834 device[5] = devchar;
9835 char lines_0[] = ",";
9842 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9847 char fstype[] = "ext2";
9848 char device[] = "/dev/sda1";
9849 device[5] = devchar;
9852 r = guestfs_mkfs (g, fstype, device);
9857 char device[] = "/dev/sda1";
9858 device[5] = devchar;
9859 char mountpoint[] = "/";
9862 r = guestfs_mount (g, device, mountpoint);
9866 /* TestOutputTrue for is_dir (1) */
9868 char path[] = "/new";
9871 r = guestfs_mkdir (g, path);
9876 char path[] = "/new";
9879 r = guestfs_is_dir (g, path);
9883 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
9890 static int test_is_file_0 (void)
9892 /* InitBasicFS for is_file (0): create ext2 on /dev/sda1 */
9894 char device[] = "/dev/sda";
9895 device[5] = devchar;
9898 r = guestfs_blockdev_setrw (g, device);
9905 r = guestfs_umount_all (g);
9912 r = guestfs_lvm_remove_all (g);
9917 char device[] = "/dev/sda";
9918 device[5] = devchar;
9919 char lines_0[] = ",";
9926 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9931 char fstype[] = "ext2";
9932 char device[] = "/dev/sda1";
9933 device[5] = devchar;
9936 r = guestfs_mkfs (g, fstype, device);
9941 char device[] = "/dev/sda1";
9942 device[5] = devchar;
9943 char mountpoint[] = "/";
9946 r = guestfs_mount (g, device, mountpoint);
9950 /* TestOutputTrue for is_file (0) */
9952 char path[] = "/new";
9955 r = guestfs_touch (g, path);
9960 char path[] = "/new";
9963 r = guestfs_is_file (g, path);
9967 fprintf (stderr, "test_is_file_0: expected true, got false\n");
9974 static int test_is_file_1 (void)
9976 /* InitBasicFS for is_file (1): create ext2 on /dev/sda1 */
9978 char device[] = "/dev/sda";
9979 device[5] = devchar;
9982 r = guestfs_blockdev_setrw (g, device);
9989 r = guestfs_umount_all (g);
9996 r = guestfs_lvm_remove_all (g);
10001 char device[] = "/dev/sda";
10002 device[5] = devchar;
10003 char lines_0[] = ",";
10009 suppress_error = 0;
10010 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10015 char fstype[] = "ext2";
10016 char device[] = "/dev/sda1";
10017 device[5] = devchar;
10019 suppress_error = 0;
10020 r = guestfs_mkfs (g, fstype, device);
10025 char device[] = "/dev/sda1";
10026 device[5] = devchar;
10027 char mountpoint[] = "/";
10029 suppress_error = 0;
10030 r = guestfs_mount (g, device, mountpoint);
10034 /* TestOutputFalse for is_file (1) */
10036 char path[] = "/new";
10038 suppress_error = 0;
10039 r = guestfs_mkdir (g, path);
10044 char path[] = "/new";
10046 suppress_error = 0;
10047 r = guestfs_is_file (g, path);
10051 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10058 static int test_exists_0 (void)
10060 /* InitBasicFS for exists (0): create ext2 on /dev/sda1 */
10062 char device[] = "/dev/sda";
10063 device[5] = devchar;
10065 suppress_error = 0;
10066 r = guestfs_blockdev_setrw (g, device);
10072 suppress_error = 0;
10073 r = guestfs_umount_all (g);
10079 suppress_error = 0;
10080 r = guestfs_lvm_remove_all (g);
10085 char device[] = "/dev/sda";
10086 device[5] = devchar;
10087 char lines_0[] = ",";
10093 suppress_error = 0;
10094 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10099 char fstype[] = "ext2";
10100 char device[] = "/dev/sda1";
10101 device[5] = devchar;
10103 suppress_error = 0;
10104 r = guestfs_mkfs (g, fstype, device);
10109 char device[] = "/dev/sda1";
10110 device[5] = devchar;
10111 char mountpoint[] = "/";
10113 suppress_error = 0;
10114 r = guestfs_mount (g, device, mountpoint);
10118 /* TestOutputTrue for exists (0) */
10120 char path[] = "/new";
10122 suppress_error = 0;
10123 r = guestfs_touch (g, path);
10128 char path[] = "/new";
10130 suppress_error = 0;
10131 r = guestfs_exists (g, path);
10135 fprintf (stderr, "test_exists_0: expected true, got false\n");
10142 static int test_exists_1 (void)
10144 /* InitBasicFS for exists (1): create ext2 on /dev/sda1 */
10146 char device[] = "/dev/sda";
10147 device[5] = devchar;
10149 suppress_error = 0;
10150 r = guestfs_blockdev_setrw (g, device);
10156 suppress_error = 0;
10157 r = guestfs_umount_all (g);
10163 suppress_error = 0;
10164 r = guestfs_lvm_remove_all (g);
10169 char device[] = "/dev/sda";
10170 device[5] = devchar;
10171 char lines_0[] = ",";
10177 suppress_error = 0;
10178 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10183 char fstype[] = "ext2";
10184 char device[] = "/dev/sda1";
10185 device[5] = devchar;
10187 suppress_error = 0;
10188 r = guestfs_mkfs (g, fstype, device);
10193 char device[] = "/dev/sda1";
10194 device[5] = devchar;
10195 char mountpoint[] = "/";
10197 suppress_error = 0;
10198 r = guestfs_mount (g, device, mountpoint);
10202 /* TestOutputTrue for exists (1) */
10204 char path[] = "/new";
10206 suppress_error = 0;
10207 r = guestfs_mkdir (g, path);
10212 char path[] = "/new";
10214 suppress_error = 0;
10215 r = guestfs_exists (g, path);
10219 fprintf (stderr, "test_exists_1: expected true, got false\n");
10226 static int test_mkdir_p_0 (void)
10228 /* InitBasicFS for mkdir_p (0): create ext2 on /dev/sda1 */
10230 char device[] = "/dev/sda";
10231 device[5] = devchar;
10233 suppress_error = 0;
10234 r = guestfs_blockdev_setrw (g, device);
10240 suppress_error = 0;
10241 r = guestfs_umount_all (g);
10247 suppress_error = 0;
10248 r = guestfs_lvm_remove_all (g);
10253 char device[] = "/dev/sda";
10254 device[5] = devchar;
10255 char lines_0[] = ",";
10261 suppress_error = 0;
10262 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10267 char fstype[] = "ext2";
10268 char device[] = "/dev/sda1";
10269 device[5] = devchar;
10271 suppress_error = 0;
10272 r = guestfs_mkfs (g, fstype, device);
10277 char device[] = "/dev/sda1";
10278 device[5] = devchar;
10279 char mountpoint[] = "/";
10281 suppress_error = 0;
10282 r = guestfs_mount (g, device, mountpoint);
10286 /* TestOutputTrue for mkdir_p (0) */
10288 char path[] = "/new/foo/bar";
10290 suppress_error = 0;
10291 r = guestfs_mkdir_p (g, path);
10296 char path[] = "/new/foo/bar";
10298 suppress_error = 0;
10299 r = guestfs_is_dir (g, path);
10303 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10310 static int test_mkdir_p_1 (void)
10312 /* InitBasicFS for mkdir_p (1): create ext2 on /dev/sda1 */
10314 char device[] = "/dev/sda";
10315 device[5] = devchar;
10317 suppress_error = 0;
10318 r = guestfs_blockdev_setrw (g, device);
10324 suppress_error = 0;
10325 r = guestfs_umount_all (g);
10331 suppress_error = 0;
10332 r = guestfs_lvm_remove_all (g);
10337 char device[] = "/dev/sda";
10338 device[5] = devchar;
10339 char lines_0[] = ",";
10345 suppress_error = 0;
10346 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10351 char fstype[] = "ext2";
10352 char device[] = "/dev/sda1";
10353 device[5] = devchar;
10355 suppress_error = 0;
10356 r = guestfs_mkfs (g, fstype, device);
10361 char device[] = "/dev/sda1";
10362 device[5] = devchar;
10363 char mountpoint[] = "/";
10365 suppress_error = 0;
10366 r = guestfs_mount (g, device, mountpoint);
10370 /* TestOutputTrue for mkdir_p (1) */
10372 char path[] = "/new/foo/bar";
10374 suppress_error = 0;
10375 r = guestfs_mkdir_p (g, path);
10380 char path[] = "/new/foo";
10382 suppress_error = 0;
10383 r = guestfs_is_dir (g, path);
10387 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10394 static int test_mkdir_p_2 (void)
10396 /* InitBasicFS for mkdir_p (2): create ext2 on /dev/sda1 */
10398 char device[] = "/dev/sda";
10399 device[5] = devchar;
10401 suppress_error = 0;
10402 r = guestfs_blockdev_setrw (g, device);
10408 suppress_error = 0;
10409 r = guestfs_umount_all (g);
10415 suppress_error = 0;
10416 r = guestfs_lvm_remove_all (g);
10421 char device[] = "/dev/sda";
10422 device[5] = devchar;
10423 char lines_0[] = ",";
10429 suppress_error = 0;
10430 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10435 char fstype[] = "ext2";
10436 char device[] = "/dev/sda1";
10437 device[5] = devchar;
10439 suppress_error = 0;
10440 r = guestfs_mkfs (g, fstype, device);
10445 char device[] = "/dev/sda1";
10446 device[5] = devchar;
10447 char mountpoint[] = "/";
10449 suppress_error = 0;
10450 r = guestfs_mount (g, device, mountpoint);
10454 /* TestOutputTrue for mkdir_p (2) */
10456 char path[] = "/new/foo/bar";
10458 suppress_error = 0;
10459 r = guestfs_mkdir_p (g, path);
10464 char path[] = "/new";
10466 suppress_error = 0;
10467 r = guestfs_is_dir (g, path);
10471 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
10478 static int test_mkdir_0 (void)
10480 /* InitBasicFS for mkdir (0): create ext2 on /dev/sda1 */
10482 char device[] = "/dev/sda";
10483 device[5] = devchar;
10485 suppress_error = 0;
10486 r = guestfs_blockdev_setrw (g, device);
10492 suppress_error = 0;
10493 r = guestfs_umount_all (g);
10499 suppress_error = 0;
10500 r = guestfs_lvm_remove_all (g);
10505 char device[] = "/dev/sda";
10506 device[5] = devchar;
10507 char lines_0[] = ",";
10513 suppress_error = 0;
10514 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10519 char fstype[] = "ext2";
10520 char device[] = "/dev/sda1";
10521 device[5] = devchar;
10523 suppress_error = 0;
10524 r = guestfs_mkfs (g, fstype, device);
10529 char device[] = "/dev/sda1";
10530 device[5] = devchar;
10531 char mountpoint[] = "/";
10533 suppress_error = 0;
10534 r = guestfs_mount (g, device, mountpoint);
10538 /* TestOutputTrue for mkdir (0) */
10540 char path[] = "/new";
10542 suppress_error = 0;
10543 r = guestfs_mkdir (g, path);
10548 char path[] = "/new";
10550 suppress_error = 0;
10551 r = guestfs_is_dir (g, path);
10555 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
10562 static int test_mkdir_1 (void)
10564 /* InitBasicFS for mkdir (1): create ext2 on /dev/sda1 */
10566 char device[] = "/dev/sda";
10567 device[5] = devchar;
10569 suppress_error = 0;
10570 r = guestfs_blockdev_setrw (g, device);
10576 suppress_error = 0;
10577 r = guestfs_umount_all (g);
10583 suppress_error = 0;
10584 r = guestfs_lvm_remove_all (g);
10589 char device[] = "/dev/sda";
10590 device[5] = devchar;
10591 char lines_0[] = ",";
10597 suppress_error = 0;
10598 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10603 char fstype[] = "ext2";
10604 char device[] = "/dev/sda1";
10605 device[5] = devchar;
10607 suppress_error = 0;
10608 r = guestfs_mkfs (g, fstype, device);
10613 char device[] = "/dev/sda1";
10614 device[5] = devchar;
10615 char mountpoint[] = "/";
10617 suppress_error = 0;
10618 r = guestfs_mount (g, device, mountpoint);
10622 /* TestLastFail for mkdir (1) */
10624 char path[] = "/new/foo/bar";
10626 suppress_error = 1;
10627 r = guestfs_mkdir (g, path);
10634 static int test_rm_rf_0 (void)
10636 /* InitBasicFS for rm_rf (0): create ext2 on /dev/sda1 */
10638 char device[] = "/dev/sda";
10639 device[5] = devchar;
10641 suppress_error = 0;
10642 r = guestfs_blockdev_setrw (g, device);
10648 suppress_error = 0;
10649 r = guestfs_umount_all (g);
10655 suppress_error = 0;
10656 r = guestfs_lvm_remove_all (g);
10661 char device[] = "/dev/sda";
10662 device[5] = devchar;
10663 char lines_0[] = ",";
10669 suppress_error = 0;
10670 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10675 char fstype[] = "ext2";
10676 char device[] = "/dev/sda1";
10677 device[5] = devchar;
10679 suppress_error = 0;
10680 r = guestfs_mkfs (g, fstype, device);
10685 char device[] = "/dev/sda1";
10686 device[5] = devchar;
10687 char mountpoint[] = "/";
10689 suppress_error = 0;
10690 r = guestfs_mount (g, device, mountpoint);
10694 /* TestOutputFalse for rm_rf (0) */
10696 char path[] = "/new";
10698 suppress_error = 0;
10699 r = guestfs_mkdir (g, path);
10704 char path[] = "/new/foo";
10706 suppress_error = 0;
10707 r = guestfs_mkdir (g, path);
10712 char path[] = "/new/foo/bar";
10714 suppress_error = 0;
10715 r = guestfs_touch (g, path);
10720 char path[] = "/new";
10722 suppress_error = 0;
10723 r = guestfs_rm_rf (g, path);
10728 char path[] = "/new";
10730 suppress_error = 0;
10731 r = guestfs_exists (g, path);
10735 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
10742 static int test_rmdir_0 (void)
10744 /* InitBasicFS for rmdir (0): create ext2 on /dev/sda1 */
10746 char device[] = "/dev/sda";
10747 device[5] = devchar;
10749 suppress_error = 0;
10750 r = guestfs_blockdev_setrw (g, device);
10756 suppress_error = 0;
10757 r = guestfs_umount_all (g);
10763 suppress_error = 0;
10764 r = guestfs_lvm_remove_all (g);
10769 char device[] = "/dev/sda";
10770 device[5] = devchar;
10771 char lines_0[] = ",";
10777 suppress_error = 0;
10778 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10783 char fstype[] = "ext2";
10784 char device[] = "/dev/sda1";
10785 device[5] = devchar;
10787 suppress_error = 0;
10788 r = guestfs_mkfs (g, fstype, device);
10793 char device[] = "/dev/sda1";
10794 device[5] = devchar;
10795 char mountpoint[] = "/";
10797 suppress_error = 0;
10798 r = guestfs_mount (g, device, mountpoint);
10802 /* TestRun for rmdir (0) */
10804 char path[] = "/new";
10806 suppress_error = 0;
10807 r = guestfs_mkdir (g, path);
10812 char path[] = "/new";
10814 suppress_error = 0;
10815 r = guestfs_rmdir (g, path);
10822 static int test_rmdir_1 (void)
10824 /* InitBasicFS for rmdir (1): create ext2 on /dev/sda1 */
10826 char device[] = "/dev/sda";
10827 device[5] = devchar;
10829 suppress_error = 0;
10830 r = guestfs_blockdev_setrw (g, device);
10836 suppress_error = 0;
10837 r = guestfs_umount_all (g);
10843 suppress_error = 0;
10844 r = guestfs_lvm_remove_all (g);
10849 char device[] = "/dev/sda";
10850 device[5] = devchar;
10851 char lines_0[] = ",";
10857 suppress_error = 0;
10858 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10863 char fstype[] = "ext2";
10864 char device[] = "/dev/sda1";
10865 device[5] = devchar;
10867 suppress_error = 0;
10868 r = guestfs_mkfs (g, fstype, device);
10873 char device[] = "/dev/sda1";
10874 device[5] = devchar;
10875 char mountpoint[] = "/";
10877 suppress_error = 0;
10878 r = guestfs_mount (g, device, mountpoint);
10882 /* TestLastFail for rmdir (1) */
10884 char path[] = "/new";
10886 suppress_error = 1;
10887 r = guestfs_rmdir (g, path);
10894 static int test_rmdir_2 (void)
10896 /* InitBasicFS for rmdir (2): create ext2 on /dev/sda1 */
10898 char device[] = "/dev/sda";
10899 device[5] = devchar;
10901 suppress_error = 0;
10902 r = guestfs_blockdev_setrw (g, device);
10908 suppress_error = 0;
10909 r = guestfs_umount_all (g);
10915 suppress_error = 0;
10916 r = guestfs_lvm_remove_all (g);
10921 char device[] = "/dev/sda";
10922 device[5] = devchar;
10923 char lines_0[] = ",";
10929 suppress_error = 0;
10930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10935 char fstype[] = "ext2";
10936 char device[] = "/dev/sda1";
10937 device[5] = devchar;
10939 suppress_error = 0;
10940 r = guestfs_mkfs (g, fstype, device);
10945 char device[] = "/dev/sda1";
10946 device[5] = devchar;
10947 char mountpoint[] = "/";
10949 suppress_error = 0;
10950 r = guestfs_mount (g, device, mountpoint);
10954 /* TestLastFail for rmdir (2) */
10956 char path[] = "/new";
10958 suppress_error = 0;
10959 r = guestfs_touch (g, path);
10964 char path[] = "/new";
10966 suppress_error = 1;
10967 r = guestfs_rmdir (g, path);
10974 static int test_rm_0 (void)
10976 /* InitBasicFS for rm (0): create ext2 on /dev/sda1 */
10978 char device[] = "/dev/sda";
10979 device[5] = devchar;
10981 suppress_error = 0;
10982 r = guestfs_blockdev_setrw (g, device);
10988 suppress_error = 0;
10989 r = guestfs_umount_all (g);
10995 suppress_error = 0;
10996 r = guestfs_lvm_remove_all (g);
11001 char device[] = "/dev/sda";
11002 device[5] = devchar;
11003 char lines_0[] = ",";
11009 suppress_error = 0;
11010 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11015 char fstype[] = "ext2";
11016 char device[] = "/dev/sda1";
11017 device[5] = devchar;
11019 suppress_error = 0;
11020 r = guestfs_mkfs (g, fstype, device);
11025 char device[] = "/dev/sda1";
11026 device[5] = devchar;
11027 char mountpoint[] = "/";
11029 suppress_error = 0;
11030 r = guestfs_mount (g, device, mountpoint);
11034 /* TestRun for rm (0) */
11036 char path[] = "/new";
11038 suppress_error = 0;
11039 r = guestfs_touch (g, path);
11044 char path[] = "/new";
11046 suppress_error = 0;
11047 r = guestfs_rm (g, path);
11054 static int test_rm_1 (void)
11056 /* InitBasicFS for rm (1): create ext2 on /dev/sda1 */
11058 char device[] = "/dev/sda";
11059 device[5] = devchar;
11061 suppress_error = 0;
11062 r = guestfs_blockdev_setrw (g, device);
11068 suppress_error = 0;
11069 r = guestfs_umount_all (g);
11075 suppress_error = 0;
11076 r = guestfs_lvm_remove_all (g);
11081 char device[] = "/dev/sda";
11082 device[5] = devchar;
11083 char lines_0[] = ",";
11089 suppress_error = 0;
11090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11095 char fstype[] = "ext2";
11096 char device[] = "/dev/sda1";
11097 device[5] = devchar;
11099 suppress_error = 0;
11100 r = guestfs_mkfs (g, fstype, device);
11105 char device[] = "/dev/sda1";
11106 device[5] = devchar;
11107 char mountpoint[] = "/";
11109 suppress_error = 0;
11110 r = guestfs_mount (g, device, mountpoint);
11114 /* TestLastFail for rm (1) */
11116 char path[] = "/new";
11118 suppress_error = 1;
11119 r = guestfs_rm (g, path);
11126 static int test_rm_2 (void)
11128 /* InitBasicFS for rm (2): create ext2 on /dev/sda1 */
11130 char device[] = "/dev/sda";
11131 device[5] = devchar;
11133 suppress_error = 0;
11134 r = guestfs_blockdev_setrw (g, device);
11140 suppress_error = 0;
11141 r = guestfs_umount_all (g);
11147 suppress_error = 0;
11148 r = guestfs_lvm_remove_all (g);
11153 char device[] = "/dev/sda";
11154 device[5] = devchar;
11155 char lines_0[] = ",";
11161 suppress_error = 0;
11162 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11167 char fstype[] = "ext2";
11168 char device[] = "/dev/sda1";
11169 device[5] = devchar;
11171 suppress_error = 0;
11172 r = guestfs_mkfs (g, fstype, device);
11177 char device[] = "/dev/sda1";
11178 device[5] = devchar;
11179 char mountpoint[] = "/";
11181 suppress_error = 0;
11182 r = guestfs_mount (g, device, mountpoint);
11186 /* TestLastFail for rm (2) */
11188 char path[] = "/new";
11190 suppress_error = 0;
11191 r = guestfs_mkdir (g, path);
11196 char path[] = "/new";
11198 suppress_error = 1;
11199 r = guestfs_rm (g, path);
11206 static int test_read_lines_0 (void)
11208 /* InitBasicFS for read_lines (0): create ext2 on /dev/sda1 */
11210 char device[] = "/dev/sda";
11211 device[5] = devchar;
11213 suppress_error = 0;
11214 r = guestfs_blockdev_setrw (g, device);
11220 suppress_error = 0;
11221 r = guestfs_umount_all (g);
11227 suppress_error = 0;
11228 r = guestfs_lvm_remove_all (g);
11233 char device[] = "/dev/sda";
11234 device[5] = devchar;
11235 char lines_0[] = ",";
11241 suppress_error = 0;
11242 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11247 char fstype[] = "ext2";
11248 char device[] = "/dev/sda1";
11249 device[5] = devchar;
11251 suppress_error = 0;
11252 r = guestfs_mkfs (g, fstype, device);
11257 char device[] = "/dev/sda1";
11258 device[5] = devchar;
11259 char mountpoint[] = "/";
11261 suppress_error = 0;
11262 r = guestfs_mount (g, device, mountpoint);
11266 /* TestOutputList for read_lines (0) */
11268 char path[] = "/new";
11269 char content[] = "line1\r\nline2\nline3";
11271 suppress_error = 0;
11272 r = guestfs_write_file (g, path, content, 0);
11277 char path[] = "/new";
11280 suppress_error = 0;
11281 r = guestfs_read_lines (g, path);
11285 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11290 char expected[] = "line1";
11291 if (strcmp (r[0], expected) != 0) {
11292 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11297 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11302 char expected[] = "line2";
11303 if (strcmp (r[1], expected) != 0) {
11304 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11309 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11314 char expected[] = "line3";
11315 if (strcmp (r[2], expected) != 0) {
11316 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11320 if (r[3] != NULL) {
11321 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11325 for (i = 0; r[i] != NULL; ++i)
11332 static int test_read_lines_1 (void)
11334 /* InitBasicFS for read_lines (1): create ext2 on /dev/sda1 */
11336 char device[] = "/dev/sda";
11337 device[5] = devchar;
11339 suppress_error = 0;
11340 r = guestfs_blockdev_setrw (g, device);
11346 suppress_error = 0;
11347 r = guestfs_umount_all (g);
11353 suppress_error = 0;
11354 r = guestfs_lvm_remove_all (g);
11359 char device[] = "/dev/sda";
11360 device[5] = devchar;
11361 char lines_0[] = ",";
11367 suppress_error = 0;
11368 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11373 char fstype[] = "ext2";
11374 char device[] = "/dev/sda1";
11375 device[5] = devchar;
11377 suppress_error = 0;
11378 r = guestfs_mkfs (g, fstype, device);
11383 char device[] = "/dev/sda1";
11384 device[5] = devchar;
11385 char mountpoint[] = "/";
11387 suppress_error = 0;
11388 r = guestfs_mount (g, device, mountpoint);
11392 /* TestOutputList for read_lines (1) */
11394 char path[] = "/new";
11395 char content[] = "";
11397 suppress_error = 0;
11398 r = guestfs_write_file (g, path, content, 0);
11403 char path[] = "/new";
11406 suppress_error = 0;
11407 r = guestfs_read_lines (g, path);
11410 if (r[0] != NULL) {
11411 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11415 for (i = 0; r[i] != NULL; ++i)
11422 static int test_lvs_0 (void)
11424 /* InitBasicFSonLVM for lvs (0): create ext2 on /dev/VG/LV */
11426 char device[] = "/dev/sda";
11427 device[5] = devchar;
11429 suppress_error = 0;
11430 r = guestfs_blockdev_setrw (g, device);
11436 suppress_error = 0;
11437 r = guestfs_umount_all (g);
11443 suppress_error = 0;
11444 r = guestfs_lvm_remove_all (g);
11449 char device[] = "/dev/sda";
11450 device[5] = devchar;
11451 char lines_0[] = ",";
11457 suppress_error = 0;
11458 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11463 char device[] = "/dev/sda1";
11464 device[5] = devchar;
11466 suppress_error = 0;
11467 r = guestfs_pvcreate (g, device);
11472 char volgroup[] = "VG";
11473 char physvols_0[] = "/dev/sda1";
11474 physvols_0[5] = devchar;
11475 char *physvols[] = {
11480 suppress_error = 0;
11481 r = guestfs_vgcreate (g, volgroup, physvols);
11486 char logvol[] = "LV";
11487 char volgroup[] = "VG";
11489 suppress_error = 0;
11490 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11495 char fstype[] = "ext2";
11496 char device[] = "/dev/VG/LV";
11498 suppress_error = 0;
11499 r = guestfs_mkfs (g, fstype, device);
11504 char device[] = "/dev/VG/LV";
11505 char mountpoint[] = "/";
11507 suppress_error = 0;
11508 r = guestfs_mount (g, device, mountpoint);
11512 /* TestOutputList for lvs (0) */
11516 suppress_error = 0;
11517 r = guestfs_lvs (g);
11521 fprintf (stderr, "test_lvs_0: short list returned from command\n");
11526 char expected[] = "/dev/VG/LV";
11527 if (strcmp (r[0], expected) != 0) {
11528 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11532 if (r[1] != NULL) {
11533 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
11537 for (i = 0; r[i] != NULL; ++i)
11544 static int test_lvs_1 (void)
11546 /* InitEmpty for lvs (1) */
11548 char device[] = "/dev/sda";
11549 device[5] = devchar;
11551 suppress_error = 0;
11552 r = guestfs_blockdev_setrw (g, device);
11558 suppress_error = 0;
11559 r = guestfs_umount_all (g);
11565 suppress_error = 0;
11566 r = guestfs_lvm_remove_all (g);
11570 /* TestOutputList for lvs (1) */
11572 char device[] = "/dev/sda";
11573 device[5] = devchar;
11574 char lines_0[] = ",10";
11575 char lines_1[] = ",20";
11576 char lines_2[] = ",";
11584 suppress_error = 0;
11585 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11590 char device[] = "/dev/sda1";
11591 device[5] = devchar;
11593 suppress_error = 0;
11594 r = guestfs_pvcreate (g, device);
11599 char device[] = "/dev/sda2";
11600 device[5] = devchar;
11602 suppress_error = 0;
11603 r = guestfs_pvcreate (g, device);
11608 char device[] = "/dev/sda3";
11609 device[5] = devchar;
11611 suppress_error = 0;
11612 r = guestfs_pvcreate (g, device);
11617 char volgroup[] = "VG1";
11618 char physvols_0[] = "/dev/sda1";
11619 physvols_0[5] = devchar;
11620 char physvols_1[] = "/dev/sda2";
11621 physvols_1[5] = devchar;
11622 char *physvols[] = {
11628 suppress_error = 0;
11629 r = guestfs_vgcreate (g, volgroup, physvols);
11634 char volgroup[] = "VG2";
11635 char physvols_0[] = "/dev/sda3";
11636 physvols_0[5] = devchar;
11637 char *physvols[] = {
11642 suppress_error = 0;
11643 r = guestfs_vgcreate (g, volgroup, physvols);
11648 char logvol[] = "LV1";
11649 char volgroup[] = "VG1";
11651 suppress_error = 0;
11652 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11657 char logvol[] = "LV2";
11658 char volgroup[] = "VG1";
11660 suppress_error = 0;
11661 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11666 char logvol[] = "LV3";
11667 char volgroup[] = "VG2";
11669 suppress_error = 0;
11670 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11677 suppress_error = 0;
11678 r = guestfs_lvs (g);
11682 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11687 char expected[] = "/dev/VG1/LV1";
11688 if (strcmp (r[0], expected) != 0) {
11689 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11694 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11699 char expected[] = "/dev/VG1/LV2";
11700 if (strcmp (r[1], expected) != 0) {
11701 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11706 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11711 char expected[] = "/dev/VG2/LV3";
11712 if (strcmp (r[2], expected) != 0) {
11713 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11717 if (r[3] != NULL) {
11718 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
11722 for (i = 0; r[i] != NULL; ++i)
11729 static int test_vgs_0 (void)
11731 /* InitBasicFSonLVM for vgs (0): create ext2 on /dev/VG/LV */
11733 char device[] = "/dev/sda";
11734 device[5] = devchar;
11736 suppress_error = 0;
11737 r = guestfs_blockdev_setrw (g, device);
11743 suppress_error = 0;
11744 r = guestfs_umount_all (g);
11750 suppress_error = 0;
11751 r = guestfs_lvm_remove_all (g);
11756 char device[] = "/dev/sda";
11757 device[5] = devchar;
11758 char lines_0[] = ",";
11764 suppress_error = 0;
11765 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11770 char device[] = "/dev/sda1";
11771 device[5] = devchar;
11773 suppress_error = 0;
11774 r = guestfs_pvcreate (g, device);
11779 char volgroup[] = "VG";
11780 char physvols_0[] = "/dev/sda1";
11781 physvols_0[5] = devchar;
11782 char *physvols[] = {
11787 suppress_error = 0;
11788 r = guestfs_vgcreate (g, volgroup, physvols);
11793 char logvol[] = "LV";
11794 char volgroup[] = "VG";
11796 suppress_error = 0;
11797 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11802 char fstype[] = "ext2";
11803 char device[] = "/dev/VG/LV";
11805 suppress_error = 0;
11806 r = guestfs_mkfs (g, fstype, device);
11811 char device[] = "/dev/VG/LV";
11812 char mountpoint[] = "/";
11814 suppress_error = 0;
11815 r = guestfs_mount (g, device, mountpoint);
11819 /* TestOutputList for vgs (0) */
11823 suppress_error = 0;
11824 r = guestfs_vgs (g);
11828 fprintf (stderr, "test_vgs_0: short list returned from command\n");
11833 char expected[] = "VG";
11834 if (strcmp (r[0], expected) != 0) {
11835 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11839 if (r[1] != NULL) {
11840 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
11844 for (i = 0; r[i] != NULL; ++i)
11851 static int test_vgs_1 (void)
11853 /* InitEmpty for vgs (1) */
11855 char device[] = "/dev/sda";
11856 device[5] = devchar;
11858 suppress_error = 0;
11859 r = guestfs_blockdev_setrw (g, device);
11865 suppress_error = 0;
11866 r = guestfs_umount_all (g);
11872 suppress_error = 0;
11873 r = guestfs_lvm_remove_all (g);
11877 /* TestOutputList for vgs (1) */
11879 char device[] = "/dev/sda";
11880 device[5] = devchar;
11881 char lines_0[] = ",10";
11882 char lines_1[] = ",20";
11883 char lines_2[] = ",";
11891 suppress_error = 0;
11892 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11897 char device[] = "/dev/sda1";
11898 device[5] = devchar;
11900 suppress_error = 0;
11901 r = guestfs_pvcreate (g, device);
11906 char device[] = "/dev/sda2";
11907 device[5] = devchar;
11909 suppress_error = 0;
11910 r = guestfs_pvcreate (g, device);
11915 char device[] = "/dev/sda3";
11916 device[5] = devchar;
11918 suppress_error = 0;
11919 r = guestfs_pvcreate (g, device);
11924 char volgroup[] = "VG1";
11925 char physvols_0[] = "/dev/sda1";
11926 physvols_0[5] = devchar;
11927 char physvols_1[] = "/dev/sda2";
11928 physvols_1[5] = devchar;
11929 char *physvols[] = {
11935 suppress_error = 0;
11936 r = guestfs_vgcreate (g, volgroup, physvols);
11941 char volgroup[] = "VG2";
11942 char physvols_0[] = "/dev/sda3";
11943 physvols_0[5] = devchar;
11944 char *physvols[] = {
11949 suppress_error = 0;
11950 r = guestfs_vgcreate (g, volgroup, physvols);
11957 suppress_error = 0;
11958 r = guestfs_vgs (g);
11962 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11967 char expected[] = "VG1";
11968 if (strcmp (r[0], expected) != 0) {
11969 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11974 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11979 char expected[] = "VG2";
11980 if (strcmp (r[1], expected) != 0) {
11981 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11985 if (r[2] != NULL) {
11986 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
11990 for (i = 0; r[i] != NULL; ++i)
11997 static int test_pvs_0 (void)
11999 /* InitBasicFSonLVM for pvs (0): create ext2 on /dev/VG/LV */
12001 char device[] = "/dev/sda";
12002 device[5] = devchar;
12004 suppress_error = 0;
12005 r = guestfs_blockdev_setrw (g, device);
12011 suppress_error = 0;
12012 r = guestfs_umount_all (g);
12018 suppress_error = 0;
12019 r = guestfs_lvm_remove_all (g);
12024 char device[] = "/dev/sda";
12025 device[5] = devchar;
12026 char lines_0[] = ",";
12032 suppress_error = 0;
12033 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12038 char device[] = "/dev/sda1";
12039 device[5] = devchar;
12041 suppress_error = 0;
12042 r = guestfs_pvcreate (g, device);
12047 char volgroup[] = "VG";
12048 char physvols_0[] = "/dev/sda1";
12049 physvols_0[5] = devchar;
12050 char *physvols[] = {
12055 suppress_error = 0;
12056 r = guestfs_vgcreate (g, volgroup, physvols);
12061 char logvol[] = "LV";
12062 char volgroup[] = "VG";
12064 suppress_error = 0;
12065 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12070 char fstype[] = "ext2";
12071 char device[] = "/dev/VG/LV";
12073 suppress_error = 0;
12074 r = guestfs_mkfs (g, fstype, device);
12079 char device[] = "/dev/VG/LV";
12080 char mountpoint[] = "/";
12082 suppress_error = 0;
12083 r = guestfs_mount (g, device, mountpoint);
12087 /* TestOutputList for pvs (0) */
12091 suppress_error = 0;
12092 r = guestfs_pvs (g);
12096 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12101 char expected[] = "/dev/sda1";
12102 expected[5] = devchar;
12103 if (strcmp (r[0], expected) != 0) {
12104 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12108 if (r[1] != NULL) {
12109 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12113 for (i = 0; r[i] != NULL; ++i)
12120 static int test_pvs_1 (void)
12122 /* InitEmpty for pvs (1) */
12124 char device[] = "/dev/sda";
12125 device[5] = devchar;
12127 suppress_error = 0;
12128 r = guestfs_blockdev_setrw (g, device);
12134 suppress_error = 0;
12135 r = guestfs_umount_all (g);
12141 suppress_error = 0;
12142 r = guestfs_lvm_remove_all (g);
12146 /* TestOutputList for pvs (1) */
12148 char device[] = "/dev/sda";
12149 device[5] = devchar;
12150 char lines_0[] = ",10";
12151 char lines_1[] = ",20";
12152 char lines_2[] = ",";
12160 suppress_error = 0;
12161 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12166 char device[] = "/dev/sda1";
12167 device[5] = devchar;
12169 suppress_error = 0;
12170 r = guestfs_pvcreate (g, device);
12175 char device[] = "/dev/sda2";
12176 device[5] = devchar;
12178 suppress_error = 0;
12179 r = guestfs_pvcreate (g, device);
12184 char device[] = "/dev/sda3";
12185 device[5] = devchar;
12187 suppress_error = 0;
12188 r = guestfs_pvcreate (g, device);
12195 suppress_error = 0;
12196 r = guestfs_pvs (g);
12200 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12205 char expected[] = "/dev/sda1";
12206 expected[5] = devchar;
12207 if (strcmp (r[0], expected) != 0) {
12208 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12213 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12218 char expected[] = "/dev/sda2";
12219 expected[5] = devchar;
12220 if (strcmp (r[1], expected) != 0) {
12221 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12226 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12231 char expected[] = "/dev/sda3";
12232 expected[5] = devchar;
12233 if (strcmp (r[2], expected) != 0) {
12234 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12238 if (r[3] != NULL) {
12239 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12243 for (i = 0; r[i] != NULL; ++i)
12250 static int test_list_partitions_0 (void)
12252 /* InitBasicFS for list_partitions (0): create ext2 on /dev/sda1 */
12254 char device[] = "/dev/sda";
12255 device[5] = devchar;
12257 suppress_error = 0;
12258 r = guestfs_blockdev_setrw (g, device);
12264 suppress_error = 0;
12265 r = guestfs_umount_all (g);
12271 suppress_error = 0;
12272 r = guestfs_lvm_remove_all (g);
12277 char device[] = "/dev/sda";
12278 device[5] = devchar;
12279 char lines_0[] = ",";
12285 suppress_error = 0;
12286 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12291 char fstype[] = "ext2";
12292 char device[] = "/dev/sda1";
12293 device[5] = devchar;
12295 suppress_error = 0;
12296 r = guestfs_mkfs (g, fstype, device);
12301 char device[] = "/dev/sda1";
12302 device[5] = devchar;
12303 char mountpoint[] = "/";
12305 suppress_error = 0;
12306 r = guestfs_mount (g, device, mountpoint);
12310 /* TestOutputList for list_partitions (0) */
12314 suppress_error = 0;
12315 r = guestfs_list_partitions (g);
12319 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12324 char expected[] = "/dev/sda1";
12325 expected[5] = devchar;
12326 if (strcmp (r[0], expected) != 0) {
12327 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12331 if (r[1] != NULL) {
12332 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12336 for (i = 0; r[i] != NULL; ++i)
12343 static int test_list_partitions_1 (void)
12345 /* InitEmpty for list_partitions (1) */
12347 char device[] = "/dev/sda";
12348 device[5] = devchar;
12350 suppress_error = 0;
12351 r = guestfs_blockdev_setrw (g, device);
12357 suppress_error = 0;
12358 r = guestfs_umount_all (g);
12364 suppress_error = 0;
12365 r = guestfs_lvm_remove_all (g);
12369 /* TestOutputList for list_partitions (1) */
12371 char device[] = "/dev/sda";
12372 device[5] = devchar;
12373 char lines_0[] = ",10";
12374 char lines_1[] = ",20";
12375 char lines_2[] = ",";
12383 suppress_error = 0;
12384 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12391 suppress_error = 0;
12392 r = guestfs_list_partitions (g);
12396 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12401 char expected[] = "/dev/sda1";
12402 expected[5] = devchar;
12403 if (strcmp (r[0], expected) != 0) {
12404 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12409 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12414 char expected[] = "/dev/sda2";
12415 expected[5] = devchar;
12416 if (strcmp (r[1], expected) != 0) {
12417 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12422 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12427 char expected[] = "/dev/sda3";
12428 expected[5] = devchar;
12429 if (strcmp (r[2], expected) != 0) {
12430 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12434 if (r[3] != NULL) {
12435 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12439 for (i = 0; r[i] != NULL; ++i)
12446 static int test_list_devices_0 (void)
12448 /* InitEmpty for list_devices (0) */
12450 char device[] = "/dev/sda";
12451 device[5] = devchar;
12453 suppress_error = 0;
12454 r = guestfs_blockdev_setrw (g, device);
12460 suppress_error = 0;
12461 r = guestfs_umount_all (g);
12467 suppress_error = 0;
12468 r = guestfs_lvm_remove_all (g);
12472 /* TestOutputList for list_devices (0) */
12476 suppress_error = 0;
12477 r = guestfs_list_devices (g);
12481 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12486 char expected[] = "/dev/sda";
12487 expected[5] = devchar;
12488 if (strcmp (r[0], expected) != 0) {
12489 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12494 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12499 char expected[] = "/dev/sdb";
12500 expected[5] = devchar;
12501 if (strcmp (r[1], expected) != 0) {
12502 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12507 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12512 char expected[] = "/dev/sdc";
12513 expected[5] = devchar;
12514 if (strcmp (r[2], expected) != 0) {
12515 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12519 if (r[3] != NULL) {
12520 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
12524 for (i = 0; r[i] != NULL; ++i)
12531 static int test_ls_0 (void)
12533 /* InitBasicFS for ls (0): create ext2 on /dev/sda1 */
12535 char device[] = "/dev/sda";
12536 device[5] = devchar;
12538 suppress_error = 0;
12539 r = guestfs_blockdev_setrw (g, device);
12545 suppress_error = 0;
12546 r = guestfs_umount_all (g);
12552 suppress_error = 0;
12553 r = guestfs_lvm_remove_all (g);
12558 char device[] = "/dev/sda";
12559 device[5] = devchar;
12560 char lines_0[] = ",";
12566 suppress_error = 0;
12567 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12572 char fstype[] = "ext2";
12573 char device[] = "/dev/sda1";
12574 device[5] = devchar;
12576 suppress_error = 0;
12577 r = guestfs_mkfs (g, fstype, device);
12582 char device[] = "/dev/sda1";
12583 device[5] = devchar;
12584 char mountpoint[] = "/";
12586 suppress_error = 0;
12587 r = guestfs_mount (g, device, mountpoint);
12591 /* TestOutputList for ls (0) */
12593 char path[] = "/new";
12595 suppress_error = 0;
12596 r = guestfs_touch (g, path);
12601 char path[] = "/newer";
12603 suppress_error = 0;
12604 r = guestfs_touch (g, path);
12609 char path[] = "/newest";
12611 suppress_error = 0;
12612 r = guestfs_touch (g, path);
12617 char directory[] = "/";
12620 suppress_error = 0;
12621 r = guestfs_ls (g, directory);
12625 fprintf (stderr, "test_ls_0: short list returned from command\n");
12630 char expected[] = "lost+found";
12631 if (strcmp (r[0], expected) != 0) {
12632 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12637 fprintf (stderr, "test_ls_0: short list returned from command\n");
12642 char expected[] = "new";
12643 if (strcmp (r[1], expected) != 0) {
12644 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12649 fprintf (stderr, "test_ls_0: short list returned from command\n");
12654 char expected[] = "newer";
12655 if (strcmp (r[2], expected) != 0) {
12656 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12661 fprintf (stderr, "test_ls_0: short list returned from command\n");
12666 char expected[] = "newest";
12667 if (strcmp (r[3], expected) != 0) {
12668 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12672 if (r[4] != NULL) {
12673 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
12677 for (i = 0; r[i] != NULL; ++i)
12684 static int test_cat_0 (void)
12686 /* InitBasicFS for cat (0): create ext2 on /dev/sda1 */
12688 char device[] = "/dev/sda";
12689 device[5] = devchar;
12691 suppress_error = 0;
12692 r = guestfs_blockdev_setrw (g, device);
12698 suppress_error = 0;
12699 r = guestfs_umount_all (g);
12705 suppress_error = 0;
12706 r = guestfs_lvm_remove_all (g);
12711 char device[] = "/dev/sda";
12712 device[5] = devchar;
12713 char lines_0[] = ",";
12719 suppress_error = 0;
12720 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12725 char fstype[] = "ext2";
12726 char device[] = "/dev/sda1";
12727 device[5] = devchar;
12729 suppress_error = 0;
12730 r = guestfs_mkfs (g, fstype, device);
12735 char device[] = "/dev/sda1";
12736 device[5] = devchar;
12737 char mountpoint[] = "/";
12739 suppress_error = 0;
12740 r = guestfs_mount (g, device, mountpoint);
12744 /* TestOutput for cat (0) */
12745 char expected[] = "new file contents";
12747 char path[] = "/new";
12748 char content[] = "new file contents";
12750 suppress_error = 0;
12751 r = guestfs_write_file (g, path, content, 0);
12756 char path[] = "/new";
12758 suppress_error = 0;
12759 r = guestfs_cat (g, path);
12762 if (strcmp (r, expected) != 0) {
12763 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
12771 static int test_touch_0 (void)
12773 /* InitBasicFS for touch (0): create ext2 on /dev/sda1 */
12775 char device[] = "/dev/sda";
12776 device[5] = devchar;
12778 suppress_error = 0;
12779 r = guestfs_blockdev_setrw (g, device);
12785 suppress_error = 0;
12786 r = guestfs_umount_all (g);
12792 suppress_error = 0;
12793 r = guestfs_lvm_remove_all (g);
12798 char device[] = "/dev/sda";
12799 device[5] = devchar;
12800 char lines_0[] = ",";
12806 suppress_error = 0;
12807 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12812 char fstype[] = "ext2";
12813 char device[] = "/dev/sda1";
12814 device[5] = devchar;
12816 suppress_error = 0;
12817 r = guestfs_mkfs (g, fstype, device);
12822 char device[] = "/dev/sda1";
12823 device[5] = devchar;
12824 char mountpoint[] = "/";
12826 suppress_error = 0;
12827 r = guestfs_mount (g, device, mountpoint);
12831 /* TestOutputTrue for touch (0) */
12833 char path[] = "/new";
12835 suppress_error = 0;
12836 r = guestfs_touch (g, path);
12841 char path[] = "/new";
12843 suppress_error = 0;
12844 r = guestfs_exists (g, path);
12848 fprintf (stderr, "test_touch_0: expected true, got false\n");
12855 static int test_sync_0 (void)
12857 /* InitEmpty for sync (0) */
12859 char device[] = "/dev/sda";
12860 device[5] = devchar;
12862 suppress_error = 0;
12863 r = guestfs_blockdev_setrw (g, device);
12869 suppress_error = 0;
12870 r = guestfs_umount_all (g);
12876 suppress_error = 0;
12877 r = guestfs_lvm_remove_all (g);
12881 /* TestRun for sync (0) */
12884 suppress_error = 0;
12885 r = guestfs_sync (g);
12892 static int test_mount_0 (void)
12894 /* InitEmpty for mount (0) */
12896 char device[] = "/dev/sda";
12897 device[5] = devchar;
12899 suppress_error = 0;
12900 r = guestfs_blockdev_setrw (g, device);
12906 suppress_error = 0;
12907 r = guestfs_umount_all (g);
12913 suppress_error = 0;
12914 r = guestfs_lvm_remove_all (g);
12918 /* TestOutput for mount (0) */
12919 char expected[] = "new file contents";
12921 char device[] = "/dev/sda";
12922 device[5] = devchar;
12923 char lines_0[] = ",";
12929 suppress_error = 0;
12930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12935 char fstype[] = "ext2";
12936 char device[] = "/dev/sda1";
12937 device[5] = devchar;
12939 suppress_error = 0;
12940 r = guestfs_mkfs (g, fstype, device);
12945 char device[] = "/dev/sda1";
12946 device[5] = devchar;
12947 char mountpoint[] = "/";
12949 suppress_error = 0;
12950 r = guestfs_mount (g, device, mountpoint);
12955 char path[] = "/new";
12956 char content[] = "new file contents";
12958 suppress_error = 0;
12959 r = guestfs_write_file (g, path, content, 0);
12964 char path[] = "/new";
12966 suppress_error = 0;
12967 r = guestfs_cat (g, path);
12970 if (strcmp (r, expected) != 0) {
12971 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
12979 int main (int argc, char *argv[])
12983 const char *srcdir;
12984 const char *filename;
12986 int nr_tests, test_num = 0;
12989 no_test_warnings ();
12991 g = guestfs_create ();
12993 printf ("guestfs_create FAILED\n");
12997 guestfs_set_error_handler (g, print_error, NULL);
12999 srcdir = getenv ("srcdir");
13000 if (!srcdir) srcdir = ".";
13002 guestfs_set_path (g, ".");
13004 filename = "test1.img";
13005 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13010 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13016 if (write (fd, &c, 1) == -1) {
13022 if (close (fd) == -1) {
13027 if (guestfs_add_drive (g, filename) == -1) {
13028 printf ("guestfs_add_drive %s FAILED\n", filename);
13032 filename = "test2.img";
13033 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13038 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13044 if (write (fd, &c, 1) == -1) {
13050 if (close (fd) == -1) {
13055 if (guestfs_add_drive (g, filename) == -1) {
13056 printf ("guestfs_add_drive %s FAILED\n", filename);
13060 filename = "test3.img";
13061 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13066 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13072 if (write (fd, &c, 1) == -1) {
13078 if (close (fd) == -1) {
13083 if (guestfs_add_drive (g, filename) == -1) {
13084 printf ("guestfs_add_drive %s FAILED\n", filename);
13088 if (guestfs_launch (g) == -1) {
13089 printf ("guestfs_launch FAILED\n");
13092 if (guestfs_wait_ready (g) == -1) {
13093 printf ("guestfs_wait_ready FAILED\n");
13097 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13098 * names. This changed between RHEL 5 and RHEL 6 so we have to
13101 devs = guestfs_list_devices (g);
13102 if (devs == NULL || devs[0] == NULL) {
13103 printf ("guestfs_list_devices FAILED\n");
13106 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13108 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13111 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13115 for (i = 0; devs[i] != NULL; ++i)
13122 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13123 if (test_zerofree_0 () == -1) {
13124 printf ("test_zerofree_0 FAILED\n");
13128 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13129 if (test_hexdump_0 () == -1) {
13130 printf ("test_hexdump_0 FAILED\n");
13134 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13135 if (test_strings_e_0 () == -1) {
13136 printf ("test_strings_e_0 FAILED\n");
13140 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13141 if (test_strings_e_1 () == -1) {
13142 printf ("test_strings_e_1 FAILED\n");
13146 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13147 if (test_strings_0 () == -1) {
13148 printf ("test_strings_0 FAILED\n");
13152 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13153 if (test_strings_1 () == -1) {
13154 printf ("test_strings_1 FAILED\n");
13158 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13159 if (test_equal_0 () == -1) {
13160 printf ("test_equal_0 FAILED\n");
13164 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13165 if (test_equal_1 () == -1) {
13166 printf ("test_equal_1 FAILED\n");
13170 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13171 if (test_equal_2 () == -1) {
13172 printf ("test_equal_2 FAILED\n");
13176 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13177 if (test_ping_daemon_0 () == -1) {
13178 printf ("test_ping_daemon_0 FAILED\n");
13182 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13183 if (test_dmesg_0 () == -1) {
13184 printf ("test_dmesg_0 FAILED\n");
13188 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13189 if (test_drop_caches_0 () == -1) {
13190 printf ("test_drop_caches_0 FAILED\n");
13194 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13195 if (test_mv_0 () == -1) {
13196 printf ("test_mv_0 FAILED\n");
13200 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13201 if (test_mv_1 () == -1) {
13202 printf ("test_mv_1 FAILED\n");
13206 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13207 if (test_cp_a_0 () == -1) {
13208 printf ("test_cp_a_0 FAILED\n");
13212 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13213 if (test_cp_0 () == -1) {
13214 printf ("test_cp_0 FAILED\n");
13218 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13219 if (test_cp_1 () == -1) {
13220 printf ("test_cp_1 FAILED\n");
13224 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13225 if (test_cp_2 () == -1) {
13226 printf ("test_cp_2 FAILED\n");
13230 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13231 if (test_grub_install_0 () == -1) {
13232 printf ("test_grub_install_0 FAILED\n");
13236 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13237 if (test_zero_0 () == -1) {
13238 printf ("test_zero_0 FAILED\n");
13242 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13243 if (test_fsck_0 () == -1) {
13244 printf ("test_fsck_0 FAILED\n");
13248 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13249 if (test_fsck_1 () == -1) {
13250 printf ("test_fsck_1 FAILED\n");
13254 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13255 if (test_set_e2uuid_0 () == -1) {
13256 printf ("test_set_e2uuid_0 FAILED\n");
13260 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13261 if (test_set_e2uuid_1 () == -1) {
13262 printf ("test_set_e2uuid_1 FAILED\n");
13266 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13267 if (test_set_e2uuid_2 () == -1) {
13268 printf ("test_set_e2uuid_2 FAILED\n");
13272 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13273 if (test_set_e2uuid_3 () == -1) {
13274 printf ("test_set_e2uuid_3 FAILED\n");
13278 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13279 if (test_set_e2label_0 () == -1) {
13280 printf ("test_set_e2label_0 FAILED\n");
13284 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13285 if (test_pvremove_0 () == -1) {
13286 printf ("test_pvremove_0 FAILED\n");
13290 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13291 if (test_pvremove_1 () == -1) {
13292 printf ("test_pvremove_1 FAILED\n");
13296 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13297 if (test_pvremove_2 () == -1) {
13298 printf ("test_pvremove_2 FAILED\n");
13302 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13303 if (test_vgremove_0 () == -1) {
13304 printf ("test_vgremove_0 FAILED\n");
13308 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13309 if (test_vgremove_1 () == -1) {
13310 printf ("test_vgremove_1 FAILED\n");
13314 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13315 if (test_lvremove_0 () == -1) {
13316 printf ("test_lvremove_0 FAILED\n");
13320 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13321 if (test_lvremove_1 () == -1) {
13322 printf ("test_lvremove_1 FAILED\n");
13326 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13327 if (test_lvremove_2 () == -1) {
13328 printf ("test_lvremove_2 FAILED\n");
13332 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13333 if (test_mount_ro_0 () == -1) {
13334 printf ("test_mount_ro_0 FAILED\n");
13338 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13339 if (test_mount_ro_1 () == -1) {
13340 printf ("test_mount_ro_1 FAILED\n");
13344 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13345 if (test_tgz_in_0 () == -1) {
13346 printf ("test_tgz_in_0 FAILED\n");
13350 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13351 if (test_tar_in_0 () == -1) {
13352 printf ("test_tar_in_0 FAILED\n");
13356 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13357 if (test_checksum_0 () == -1) {
13358 printf ("test_checksum_0 FAILED\n");
13362 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13363 if (test_checksum_1 () == -1) {
13364 printf ("test_checksum_1 FAILED\n");
13368 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13369 if (test_checksum_2 () == -1) {
13370 printf ("test_checksum_2 FAILED\n");
13374 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13375 if (test_checksum_3 () == -1) {
13376 printf ("test_checksum_3 FAILED\n");
13380 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13381 if (test_checksum_4 () == -1) {
13382 printf ("test_checksum_4 FAILED\n");
13386 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13387 if (test_checksum_5 () == -1) {
13388 printf ("test_checksum_5 FAILED\n");
13392 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13393 if (test_checksum_6 () == -1) {
13394 printf ("test_checksum_6 FAILED\n");
13398 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13399 if (test_checksum_7 () == -1) {
13400 printf ("test_checksum_7 FAILED\n");
13404 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13405 if (test_download_0 () == -1) {
13406 printf ("test_download_0 FAILED\n");
13410 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13411 if (test_upload_0 () == -1) {
13412 printf ("test_upload_0 FAILED\n");
13416 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13417 if (test_blockdev_rereadpt_0 () == -1) {
13418 printf ("test_blockdev_rereadpt_0 FAILED\n");
13422 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13423 if (test_blockdev_flushbufs_0 () == -1) {
13424 printf ("test_blockdev_flushbufs_0 FAILED\n");
13428 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
13429 if (test_blockdev_getsize64_0 () == -1) {
13430 printf ("test_blockdev_getsize64_0 FAILED\n");
13434 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
13435 if (test_blockdev_getsz_0 () == -1) {
13436 printf ("test_blockdev_getsz_0 FAILED\n");
13440 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
13441 if (test_blockdev_getbsz_0 () == -1) {
13442 printf ("test_blockdev_getbsz_0 FAILED\n");
13446 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
13447 if (test_blockdev_getss_0 () == -1) {
13448 printf ("test_blockdev_getss_0 FAILED\n");
13452 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
13453 if (test_blockdev_getro_0 () == -1) {
13454 printf ("test_blockdev_getro_0 FAILED\n");
13458 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
13459 if (test_blockdev_setrw_0 () == -1) {
13460 printf ("test_blockdev_setrw_0 FAILED\n");
13464 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
13465 if (test_blockdev_setro_0 () == -1) {
13466 printf ("test_blockdev_setro_0 FAILED\n");
13470 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
13471 if (test_statvfs_0 () == -1) {
13472 printf ("test_statvfs_0 FAILED\n");
13476 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
13477 if (test_lstat_0 () == -1) {
13478 printf ("test_lstat_0 FAILED\n");
13482 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
13483 if (test_stat_0 () == -1) {
13484 printf ("test_stat_0 FAILED\n");
13488 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
13489 if (test_command_lines_0 () == -1) {
13490 printf ("test_command_lines_0 FAILED\n");
13494 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
13495 if (test_command_lines_1 () == -1) {
13496 printf ("test_command_lines_1 FAILED\n");
13500 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
13501 if (test_command_lines_2 () == -1) {
13502 printf ("test_command_lines_2 FAILED\n");
13506 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
13507 if (test_command_lines_3 () == -1) {
13508 printf ("test_command_lines_3 FAILED\n");
13512 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
13513 if (test_command_lines_4 () == -1) {
13514 printf ("test_command_lines_4 FAILED\n");
13518 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
13519 if (test_command_lines_5 () == -1) {
13520 printf ("test_command_lines_5 FAILED\n");
13524 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
13525 if (test_command_lines_6 () == -1) {
13526 printf ("test_command_lines_6 FAILED\n");
13530 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
13531 if (test_command_lines_7 () == -1) {
13532 printf ("test_command_lines_7 FAILED\n");
13536 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
13537 if (test_command_lines_8 () == -1) {
13538 printf ("test_command_lines_8 FAILED\n");
13542 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
13543 if (test_command_lines_9 () == -1) {
13544 printf ("test_command_lines_9 FAILED\n");
13548 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
13549 if (test_command_lines_10 () == -1) {
13550 printf ("test_command_lines_10 FAILED\n");
13554 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
13555 if (test_command_0 () == -1) {
13556 printf ("test_command_0 FAILED\n");
13560 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
13561 if (test_command_1 () == -1) {
13562 printf ("test_command_1 FAILED\n");
13566 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
13567 if (test_command_2 () == -1) {
13568 printf ("test_command_2 FAILED\n");
13572 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
13573 if (test_command_3 () == -1) {
13574 printf ("test_command_3 FAILED\n");
13578 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
13579 if (test_command_4 () == -1) {
13580 printf ("test_command_4 FAILED\n");
13584 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
13585 if (test_command_5 () == -1) {
13586 printf ("test_command_5 FAILED\n");
13590 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
13591 if (test_command_6 () == -1) {
13592 printf ("test_command_6 FAILED\n");
13596 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
13597 if (test_command_7 () == -1) {
13598 printf ("test_command_7 FAILED\n");
13602 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
13603 if (test_command_8 () == -1) {
13604 printf ("test_command_8 FAILED\n");
13608 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
13609 if (test_command_9 () == -1) {
13610 printf ("test_command_9 FAILED\n");
13614 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
13615 if (test_command_10 () == -1) {
13616 printf ("test_command_10 FAILED\n");
13620 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
13621 if (test_command_11 () == -1) {
13622 printf ("test_command_11 FAILED\n");
13626 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
13627 if (test_file_0 () == -1) {
13628 printf ("test_file_0 FAILED\n");
13632 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
13633 if (test_file_1 () == -1) {
13634 printf ("test_file_1 FAILED\n");
13638 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
13639 if (test_file_2 () == -1) {
13640 printf ("test_file_2 FAILED\n");
13644 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
13645 if (test_umount_all_0 () == -1) {
13646 printf ("test_umount_all_0 FAILED\n");
13650 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
13651 if (test_umount_all_1 () == -1) {
13652 printf ("test_umount_all_1 FAILED\n");
13656 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
13657 if (test_mounts_0 () == -1) {
13658 printf ("test_mounts_0 FAILED\n");
13662 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
13663 if (test_umount_0 () == -1) {
13664 printf ("test_umount_0 FAILED\n");
13668 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
13669 if (test_umount_1 () == -1) {
13670 printf ("test_umount_1 FAILED\n");
13674 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
13675 if (test_write_file_0 () == -1) {
13676 printf ("test_write_file_0 FAILED\n");
13680 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
13681 if (test_write_file_1 () == -1) {
13682 printf ("test_write_file_1 FAILED\n");
13686 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
13687 if (test_write_file_2 () == -1) {
13688 printf ("test_write_file_2 FAILED\n");
13692 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
13693 if (test_write_file_3 () == -1) {
13694 printf ("test_write_file_3 FAILED\n");
13698 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
13699 if (test_write_file_4 () == -1) {
13700 printf ("test_write_file_4 FAILED\n");
13704 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
13705 if (test_write_file_5 () == -1) {
13706 printf ("test_write_file_5 FAILED\n");
13710 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
13711 if (test_mkfs_0 () == -1) {
13712 printf ("test_mkfs_0 FAILED\n");
13716 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
13717 if (test_lvcreate_0 () == -1) {
13718 printf ("test_lvcreate_0 FAILED\n");
13722 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
13723 if (test_vgcreate_0 () == -1) {
13724 printf ("test_vgcreate_0 FAILED\n");
13728 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
13729 if (test_pvcreate_0 () == -1) {
13730 printf ("test_pvcreate_0 FAILED\n");
13734 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
13735 if (test_is_dir_0 () == -1) {
13736 printf ("test_is_dir_0 FAILED\n");
13740 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
13741 if (test_is_dir_1 () == -1) {
13742 printf ("test_is_dir_1 FAILED\n");
13746 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
13747 if (test_is_file_0 () == -1) {
13748 printf ("test_is_file_0 FAILED\n");
13752 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
13753 if (test_is_file_1 () == -1) {
13754 printf ("test_is_file_1 FAILED\n");
13758 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
13759 if (test_exists_0 () == -1) {
13760 printf ("test_exists_0 FAILED\n");
13764 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
13765 if (test_exists_1 () == -1) {
13766 printf ("test_exists_1 FAILED\n");
13770 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
13771 if (test_mkdir_p_0 () == -1) {
13772 printf ("test_mkdir_p_0 FAILED\n");
13776 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
13777 if (test_mkdir_p_1 () == -1) {
13778 printf ("test_mkdir_p_1 FAILED\n");
13782 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
13783 if (test_mkdir_p_2 () == -1) {
13784 printf ("test_mkdir_p_2 FAILED\n");
13788 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
13789 if (test_mkdir_0 () == -1) {
13790 printf ("test_mkdir_0 FAILED\n");
13794 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
13795 if (test_mkdir_1 () == -1) {
13796 printf ("test_mkdir_1 FAILED\n");
13800 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
13801 if (test_rm_rf_0 () == -1) {
13802 printf ("test_rm_rf_0 FAILED\n");
13806 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
13807 if (test_rmdir_0 () == -1) {
13808 printf ("test_rmdir_0 FAILED\n");
13812 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
13813 if (test_rmdir_1 () == -1) {
13814 printf ("test_rmdir_1 FAILED\n");
13818 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
13819 if (test_rmdir_2 () == -1) {
13820 printf ("test_rmdir_2 FAILED\n");
13824 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
13825 if (test_rm_0 () == -1) {
13826 printf ("test_rm_0 FAILED\n");
13830 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
13831 if (test_rm_1 () == -1) {
13832 printf ("test_rm_1 FAILED\n");
13836 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
13837 if (test_rm_2 () == -1) {
13838 printf ("test_rm_2 FAILED\n");
13842 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
13843 if (test_read_lines_0 () == -1) {
13844 printf ("test_read_lines_0 FAILED\n");
13848 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
13849 if (test_read_lines_1 () == -1) {
13850 printf ("test_read_lines_1 FAILED\n");
13854 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
13855 if (test_lvs_0 () == -1) {
13856 printf ("test_lvs_0 FAILED\n");
13860 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
13861 if (test_lvs_1 () == -1) {
13862 printf ("test_lvs_1 FAILED\n");
13866 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
13867 if (test_vgs_0 () == -1) {
13868 printf ("test_vgs_0 FAILED\n");
13872 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
13873 if (test_vgs_1 () == -1) {
13874 printf ("test_vgs_1 FAILED\n");
13878 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
13879 if (test_pvs_0 () == -1) {
13880 printf ("test_pvs_0 FAILED\n");
13884 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
13885 if (test_pvs_1 () == -1) {
13886 printf ("test_pvs_1 FAILED\n");
13890 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
13891 if (test_list_partitions_0 () == -1) {
13892 printf ("test_list_partitions_0 FAILED\n");
13896 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
13897 if (test_list_partitions_1 () == -1) {
13898 printf ("test_list_partitions_1 FAILED\n");
13902 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
13903 if (test_list_devices_0 () == -1) {
13904 printf ("test_list_devices_0 FAILED\n");
13908 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
13909 if (test_ls_0 () == -1) {
13910 printf ("test_ls_0 FAILED\n");
13914 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
13915 if (test_cat_0 () == -1) {
13916 printf ("test_cat_0 FAILED\n");
13920 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
13921 if (test_touch_0 () == -1) {
13922 printf ("test_touch_0 FAILED\n");
13926 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
13927 if (test_sync_0 () == -1) {
13928 printf ("test_sync_0 FAILED\n");
13932 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
13933 if (test_mount_0 () == -1) {
13934 printf ("test_mount_0 FAILED\n");
13939 unlink ("test1.img");
13940 unlink ("test2.img");
13941 unlink ("test3.img");
13944 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);