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");
119 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
126 static int test_zerofree_0 (void)
128 /* TestOutput for zerofree (0) */
129 char expected[] = "test file";
131 char device[] = "/dev/sda";
133 char lines_0[] = ",";
140 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
145 char fstype[] = "ext3";
146 char device[] = "/dev/sda1";
150 r = guestfs_mkfs (g, fstype, device);
155 char device[] = "/dev/sda1";
157 char mountpoint[] = "/";
160 r = guestfs_mount (g, device, mountpoint);
165 char path[] = "/new";
166 char content[] = "test file";
169 r = guestfs_write_file (g, path, content, 0);
174 char pathordevice[] = "/dev/sda1";
175 pathordevice[5] = devchar;
178 r = guestfs_umount (g, pathordevice);
183 char device[] = "/dev/sda1";
187 r = guestfs_zerofree (g, device);
192 char device[] = "/dev/sda1";
194 char mountpoint[] = "/";
197 r = guestfs_mount (g, device, mountpoint);
202 char path[] = "/new";
205 r = guestfs_cat (g, path);
208 if (strcmp (r, expected) != 0) {
209 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
217 static int test_hexdump_0 (void)
219 /* InitBasicFS for hexdump (0): create ext2 on /dev/sda1 */
221 char device[] = "/dev/sda";
225 r = guestfs_blockdev_setrw (g, device);
232 r = guestfs_umount_all (g);
239 r = guestfs_lvm_remove_all (g);
244 char device[] = "/dev/sda";
246 char lines_0[] = ",";
253 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
258 char fstype[] = "ext2";
259 char device[] = "/dev/sda1";
263 r = guestfs_mkfs (g, fstype, device);
268 char device[] = "/dev/sda1";
270 char mountpoint[] = "/";
273 r = guestfs_mount (g, device, mountpoint);
277 /* TestOutput for hexdump (0) */
278 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
280 char path[] = "/new";
281 char content[] = "hello\nworld\n";
284 r = guestfs_write_file (g, path, content, 12);
289 char path[] = "/new";
292 r = guestfs_hexdump (g, path);
295 if (strcmp (r, expected) != 0) {
296 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
304 static int test_strings_e_0 (void)
306 /* InitBasicFS for strings_e (0): create ext2 on /dev/sda1 */
308 char device[] = "/dev/sda";
312 r = guestfs_blockdev_setrw (g, device);
319 r = guestfs_umount_all (g);
326 r = guestfs_lvm_remove_all (g);
331 char device[] = "/dev/sda";
333 char lines_0[] = ",";
340 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
345 char fstype[] = "ext2";
346 char device[] = "/dev/sda1";
350 r = guestfs_mkfs (g, fstype, device);
355 char device[] = "/dev/sda1";
357 char mountpoint[] = "/";
360 r = guestfs_mount (g, device, mountpoint);
364 /* TestOutputList for strings_e (0) */
366 char path[] = "/new";
367 char content[] = "hello\nworld\n";
370 r = guestfs_write_file (g, path, content, 0);
375 char encoding[] = "b";
376 char path[] = "/new";
380 r = guestfs_strings_e (g, encoding, path);
384 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
388 for (i = 0; r[i] != NULL; ++i)
395 static int test_strings_e_1 (void)
397 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
401 static int test_strings_0 (void)
403 /* InitBasicFS for strings (0): create ext2 on /dev/sda1 */
405 char device[] = "/dev/sda";
409 r = guestfs_blockdev_setrw (g, device);
416 r = guestfs_umount_all (g);
423 r = guestfs_lvm_remove_all (g);
428 char device[] = "/dev/sda";
430 char lines_0[] = ",";
437 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
442 char fstype[] = "ext2";
443 char device[] = "/dev/sda1";
447 r = guestfs_mkfs (g, fstype, device);
452 char device[] = "/dev/sda1";
454 char mountpoint[] = "/";
457 r = guestfs_mount (g, device, mountpoint);
461 /* TestOutputList for strings (0) */
463 char path[] = "/new";
464 char content[] = "hello\nworld\n";
467 r = guestfs_write_file (g, path, content, 0);
472 char path[] = "/new";
476 r = guestfs_strings (g, path);
480 fprintf (stderr, "test_strings_0: short list returned from command\n");
485 char expected[] = "hello";
486 if (strcmp (r[0], expected) != 0) {
487 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
492 fprintf (stderr, "test_strings_0: short list returned from command\n");
497 char expected[] = "world";
498 if (strcmp (r[1], expected) != 0) {
499 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
504 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
508 for (i = 0; r[i] != NULL; ++i)
515 static int test_strings_1 (void)
517 /* InitBasicFS for strings (1): create ext2 on /dev/sda1 */
519 char device[] = "/dev/sda";
523 r = guestfs_blockdev_setrw (g, device);
530 r = guestfs_umount_all (g);
537 r = guestfs_lvm_remove_all (g);
542 char device[] = "/dev/sda";
544 char lines_0[] = ",";
551 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
556 char fstype[] = "ext2";
557 char device[] = "/dev/sda1";
561 r = guestfs_mkfs (g, fstype, device);
566 char device[] = "/dev/sda1";
568 char mountpoint[] = "/";
571 r = guestfs_mount (g, device, mountpoint);
575 /* TestOutputList for strings (1) */
577 char path[] = "/new";
580 r = guestfs_touch (g, path);
585 char path[] = "/new";
589 r = guestfs_strings (g, path);
593 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
597 for (i = 0; r[i] != NULL; ++i)
604 static int test_equal_0 (void)
606 /* InitBasicFS for equal (0): create ext2 on /dev/sda1 */
608 char device[] = "/dev/sda";
612 r = guestfs_blockdev_setrw (g, device);
619 r = guestfs_umount_all (g);
626 r = guestfs_lvm_remove_all (g);
631 char device[] = "/dev/sda";
633 char lines_0[] = ",";
640 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
645 char fstype[] = "ext2";
646 char device[] = "/dev/sda1";
650 r = guestfs_mkfs (g, fstype, device);
655 char device[] = "/dev/sda1";
657 char mountpoint[] = "/";
660 r = guestfs_mount (g, device, mountpoint);
664 /* TestOutputTrue for equal (0) */
666 char path[] = "/file1";
667 char content[] = "contents of a file";
670 r = guestfs_write_file (g, path, content, 0);
675 char src[] = "/file1";
676 char dest[] = "/file2";
679 r = guestfs_cp (g, src, dest);
684 char file1[] = "/file1";
685 char file2[] = "/file2";
688 r = guestfs_equal (g, file1, file2);
692 fprintf (stderr, "test_equal_0: expected true, got false\n");
699 static int test_equal_1 (void)
701 /* InitBasicFS for equal (1): create ext2 on /dev/sda1 */
703 char device[] = "/dev/sda";
707 r = guestfs_blockdev_setrw (g, device);
714 r = guestfs_umount_all (g);
721 r = guestfs_lvm_remove_all (g);
726 char device[] = "/dev/sda";
728 char lines_0[] = ",";
735 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
740 char fstype[] = "ext2";
741 char device[] = "/dev/sda1";
745 r = guestfs_mkfs (g, fstype, device);
750 char device[] = "/dev/sda1";
752 char mountpoint[] = "/";
755 r = guestfs_mount (g, device, mountpoint);
759 /* TestOutputFalse for equal (1) */
761 char path[] = "/file1";
762 char content[] = "contents of a file";
765 r = guestfs_write_file (g, path, content, 0);
770 char path[] = "/file2";
771 char content[] = "contents of another file";
774 r = guestfs_write_file (g, path, content, 0);
779 char file1[] = "/file1";
780 char file2[] = "/file2";
783 r = guestfs_equal (g, file1, file2);
787 fprintf (stderr, "test_equal_1: expected false, got true\n");
794 static int test_equal_2 (void)
796 /* InitBasicFS for equal (2): create ext2 on /dev/sda1 */
798 char device[] = "/dev/sda";
802 r = guestfs_blockdev_setrw (g, device);
809 r = guestfs_umount_all (g);
816 r = guestfs_lvm_remove_all (g);
821 char device[] = "/dev/sda";
823 char lines_0[] = ",";
830 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
835 char fstype[] = "ext2";
836 char device[] = "/dev/sda1";
840 r = guestfs_mkfs (g, fstype, device);
845 char device[] = "/dev/sda1";
847 char mountpoint[] = "/";
850 r = guestfs_mount (g, device, mountpoint);
854 /* TestLastFail for equal (2) */
856 char file1[] = "/file1";
857 char file2[] = "/file2";
860 r = guestfs_equal (g, file1, file2);
867 static int test_ping_daemon_0 (void)
869 /* InitEmpty for ping_daemon (0) */
871 char device[] = "/dev/sda";
875 r = guestfs_blockdev_setrw (g, device);
882 r = guestfs_umount_all (g);
889 r = guestfs_lvm_remove_all (g);
893 /* TestRun for ping_daemon (0) */
897 r = guestfs_ping_daemon (g);
904 static int test_dmesg_0 (void)
906 /* InitEmpty for dmesg (0) */
908 char device[] = "/dev/sda";
912 r = guestfs_blockdev_setrw (g, device);
919 r = guestfs_umount_all (g);
926 r = guestfs_lvm_remove_all (g);
930 /* TestRun for dmesg (0) */
934 r = guestfs_dmesg (g);
942 static int test_drop_caches_0 (void)
944 /* InitEmpty for drop_caches (0) */
946 char device[] = "/dev/sda";
950 r = guestfs_blockdev_setrw (g, device);
957 r = guestfs_umount_all (g);
964 r = guestfs_lvm_remove_all (g);
968 /* TestRun for drop_caches (0) */
972 r = guestfs_drop_caches (g, 3);
979 static int test_mv_0 (void)
981 /* InitBasicFS for mv (0): create ext2 on /dev/sda1 */
983 char device[] = "/dev/sda";
987 r = guestfs_blockdev_setrw (g, device);
994 r = guestfs_umount_all (g);
1001 r = guestfs_lvm_remove_all (g);
1006 char device[] = "/dev/sda";
1007 device[5] = devchar;
1008 char lines_0[] = ",";
1015 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1020 char fstype[] = "ext2";
1021 char device[] = "/dev/sda1";
1022 device[5] = devchar;
1025 r = guestfs_mkfs (g, fstype, device);
1030 char device[] = "/dev/sda1";
1031 device[5] = devchar;
1032 char mountpoint[] = "/";
1035 r = guestfs_mount (g, device, mountpoint);
1039 /* TestOutput for mv (0) */
1040 char expected[] = "file content";
1042 char path[] = "/old";
1043 char content[] = "file content";
1046 r = guestfs_write_file (g, path, content, 0);
1051 char src[] = "/old";
1052 char dest[] = "/new";
1055 r = guestfs_mv (g, src, dest);
1060 char path[] = "/new";
1063 r = guestfs_cat (g, path);
1066 if (strcmp (r, expected) != 0) {
1067 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1075 static int test_mv_1 (void)
1077 /* InitBasicFS for mv (1): create ext2 on /dev/sda1 */
1079 char device[] = "/dev/sda";
1080 device[5] = devchar;
1083 r = guestfs_blockdev_setrw (g, device);
1090 r = guestfs_umount_all (g);
1097 r = guestfs_lvm_remove_all (g);
1102 char device[] = "/dev/sda";
1103 device[5] = devchar;
1104 char lines_0[] = ",";
1111 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1116 char fstype[] = "ext2";
1117 char device[] = "/dev/sda1";
1118 device[5] = devchar;
1121 r = guestfs_mkfs (g, fstype, device);
1126 char device[] = "/dev/sda1";
1127 device[5] = devchar;
1128 char mountpoint[] = "/";
1131 r = guestfs_mount (g, device, mountpoint);
1135 /* TestOutputFalse for mv (1) */
1137 char path[] = "/old";
1138 char content[] = "file content";
1141 r = guestfs_write_file (g, path, content, 0);
1146 char src[] = "/old";
1147 char dest[] = "/new";
1150 r = guestfs_mv (g, src, dest);
1155 char path[] = "/old";
1158 r = guestfs_is_file (g, path);
1162 fprintf (stderr, "test_mv_1: expected false, got true\n");
1169 static int test_cp_a_0 (void)
1171 /* InitBasicFS for cp_a (0): create ext2 on /dev/sda1 */
1173 char device[] = "/dev/sda";
1174 device[5] = devchar;
1177 r = guestfs_blockdev_setrw (g, device);
1184 r = guestfs_umount_all (g);
1191 r = guestfs_lvm_remove_all (g);
1196 char device[] = "/dev/sda";
1197 device[5] = devchar;
1198 char lines_0[] = ",";
1205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1210 char fstype[] = "ext2";
1211 char device[] = "/dev/sda1";
1212 device[5] = devchar;
1215 r = guestfs_mkfs (g, fstype, device);
1220 char device[] = "/dev/sda1";
1221 device[5] = devchar;
1222 char mountpoint[] = "/";
1225 r = guestfs_mount (g, device, mountpoint);
1229 /* TestOutput for cp_a (0) */
1230 char expected[] = "file content";
1232 char path[] = "/olddir";
1235 r = guestfs_mkdir (g, path);
1240 char path[] = "/newdir";
1243 r = guestfs_mkdir (g, path);
1248 char path[] = "/olddir/file";
1249 char content[] = "file content";
1252 r = guestfs_write_file (g, path, content, 0);
1257 char src[] = "/olddir";
1258 char dest[] = "/newdir";
1261 r = guestfs_cp_a (g, src, dest);
1266 char path[] = "/newdir/olddir/file";
1269 r = guestfs_cat (g, path);
1272 if (strcmp (r, expected) != 0) {
1273 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1281 static int test_cp_0 (void)
1283 /* InitBasicFS for cp (0): create ext2 on /dev/sda1 */
1285 char device[] = "/dev/sda";
1286 device[5] = devchar;
1289 r = guestfs_blockdev_setrw (g, device);
1296 r = guestfs_umount_all (g);
1303 r = guestfs_lvm_remove_all (g);
1308 char device[] = "/dev/sda";
1309 device[5] = devchar;
1310 char lines_0[] = ",";
1317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1322 char fstype[] = "ext2";
1323 char device[] = "/dev/sda1";
1324 device[5] = devchar;
1327 r = guestfs_mkfs (g, fstype, device);
1332 char device[] = "/dev/sda1";
1333 device[5] = devchar;
1334 char mountpoint[] = "/";
1337 r = guestfs_mount (g, device, mountpoint);
1341 /* TestOutput for cp (0) */
1342 char expected[] = "file content";
1344 char path[] = "/old";
1345 char content[] = "file content";
1348 r = guestfs_write_file (g, path, content, 0);
1353 char src[] = "/old";
1354 char dest[] = "/new";
1357 r = guestfs_cp (g, src, dest);
1362 char path[] = "/new";
1365 r = guestfs_cat (g, path);
1368 if (strcmp (r, expected) != 0) {
1369 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1377 static int test_cp_1 (void)
1379 /* InitBasicFS for cp (1): create ext2 on /dev/sda1 */
1381 char device[] = "/dev/sda";
1382 device[5] = devchar;
1385 r = guestfs_blockdev_setrw (g, device);
1392 r = guestfs_umount_all (g);
1399 r = guestfs_lvm_remove_all (g);
1404 char device[] = "/dev/sda";
1405 device[5] = devchar;
1406 char lines_0[] = ",";
1413 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1418 char fstype[] = "ext2";
1419 char device[] = "/dev/sda1";
1420 device[5] = devchar;
1423 r = guestfs_mkfs (g, fstype, device);
1428 char device[] = "/dev/sda1";
1429 device[5] = devchar;
1430 char mountpoint[] = "/";
1433 r = guestfs_mount (g, device, mountpoint);
1437 /* TestOutputTrue for cp (1) */
1439 char path[] = "/old";
1440 char content[] = "file content";
1443 r = guestfs_write_file (g, path, content, 0);
1448 char src[] = "/old";
1449 char dest[] = "/new";
1452 r = guestfs_cp (g, src, dest);
1457 char path[] = "/old";
1460 r = guestfs_is_file (g, path);
1464 fprintf (stderr, "test_cp_1: expected true, got false\n");
1471 static int test_cp_2 (void)
1473 /* InitBasicFS for cp (2): create ext2 on /dev/sda1 */
1475 char device[] = "/dev/sda";
1476 device[5] = devchar;
1479 r = guestfs_blockdev_setrw (g, device);
1486 r = guestfs_umount_all (g);
1493 r = guestfs_lvm_remove_all (g);
1498 char device[] = "/dev/sda";
1499 device[5] = devchar;
1500 char lines_0[] = ",";
1507 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1512 char fstype[] = "ext2";
1513 char device[] = "/dev/sda1";
1514 device[5] = devchar;
1517 r = guestfs_mkfs (g, fstype, device);
1522 char device[] = "/dev/sda1";
1523 device[5] = devchar;
1524 char mountpoint[] = "/";
1527 r = guestfs_mount (g, device, mountpoint);
1531 /* TestOutput for cp (2) */
1532 char expected[] = "file content";
1534 char path[] = "/old";
1535 char content[] = "file content";
1538 r = guestfs_write_file (g, path, content, 0);
1543 char path[] = "/dir";
1546 r = guestfs_mkdir (g, path);
1551 char src[] = "/old";
1552 char dest[] = "/dir/new";
1555 r = guestfs_cp (g, src, dest);
1560 char path[] = "/dir/new";
1563 r = guestfs_cat (g, path);
1566 if (strcmp (r, expected) != 0) {
1567 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
1575 static int test_grub_install_0 (void)
1577 /* InitBasicFS for grub_install (0): create ext2 on /dev/sda1 */
1579 char device[] = "/dev/sda";
1580 device[5] = devchar;
1583 r = guestfs_blockdev_setrw (g, device);
1590 r = guestfs_umount_all (g);
1597 r = guestfs_lvm_remove_all (g);
1602 char device[] = "/dev/sda";
1603 device[5] = devchar;
1604 char lines_0[] = ",";
1611 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1616 char fstype[] = "ext2";
1617 char device[] = "/dev/sda1";
1618 device[5] = devchar;
1621 r = guestfs_mkfs (g, fstype, device);
1626 char device[] = "/dev/sda1";
1627 device[5] = devchar;
1628 char mountpoint[] = "/";
1631 r = guestfs_mount (g, device, mountpoint);
1635 /* TestOutputTrue for grub_install (0) */
1638 char device[] = "/dev/sda1";
1639 device[5] = devchar;
1642 r = guestfs_grub_install (g, root, device);
1647 char path[] = "/boot";
1650 r = guestfs_is_dir (g, path);
1654 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
1661 static int test_zero_0 (void)
1663 /* InitBasicFS for zero (0): create ext2 on /dev/sda1 */
1665 char device[] = "/dev/sda";
1666 device[5] = devchar;
1669 r = guestfs_blockdev_setrw (g, device);
1676 r = guestfs_umount_all (g);
1683 r = guestfs_lvm_remove_all (g);
1688 char device[] = "/dev/sda";
1689 device[5] = devchar;
1690 char lines_0[] = ",";
1697 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1702 char fstype[] = "ext2";
1703 char device[] = "/dev/sda1";
1704 device[5] = devchar;
1707 r = guestfs_mkfs (g, fstype, device);
1712 char device[] = "/dev/sda1";
1713 device[5] = devchar;
1714 char mountpoint[] = "/";
1717 r = guestfs_mount (g, device, mountpoint);
1721 /* TestOutput for zero (0) */
1722 char expected[] = "data";
1724 char pathordevice[] = "/dev/sda1";
1725 pathordevice[5] = devchar;
1728 r = guestfs_umount (g, pathordevice);
1733 char device[] = "/dev/sda1";
1734 device[5] = devchar;
1737 r = guestfs_zero (g, device);
1742 char path[] = "/dev/sda1";
1746 r = guestfs_file (g, path);
1749 if (strcmp (r, expected) != 0) {
1750 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
1758 static int test_fsck_0 (void)
1760 /* InitBasicFS for fsck (0): create ext2 on /dev/sda1 */
1762 char device[] = "/dev/sda";
1763 device[5] = devchar;
1766 r = guestfs_blockdev_setrw (g, device);
1773 r = guestfs_umount_all (g);
1780 r = guestfs_lvm_remove_all (g);
1785 char device[] = "/dev/sda";
1786 device[5] = devchar;
1787 char lines_0[] = ",";
1794 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1799 char fstype[] = "ext2";
1800 char device[] = "/dev/sda1";
1801 device[5] = devchar;
1804 r = guestfs_mkfs (g, fstype, device);
1809 char device[] = "/dev/sda1";
1810 device[5] = devchar;
1811 char mountpoint[] = "/";
1814 r = guestfs_mount (g, device, mountpoint);
1818 /* TestOutputInt for fsck (0) */
1820 char pathordevice[] = "/dev/sda1";
1821 pathordevice[5] = devchar;
1824 r = guestfs_umount (g, pathordevice);
1829 char fstype[] = "ext2";
1830 char device[] = "/dev/sda1";
1831 device[5] = devchar;
1834 r = guestfs_fsck (g, fstype, device);
1838 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
1845 static int test_fsck_1 (void)
1847 /* InitBasicFS for fsck (1): create ext2 on /dev/sda1 */
1849 char device[] = "/dev/sda";
1850 device[5] = devchar;
1853 r = guestfs_blockdev_setrw (g, device);
1860 r = guestfs_umount_all (g);
1867 r = guestfs_lvm_remove_all (g);
1872 char device[] = "/dev/sda";
1873 device[5] = devchar;
1874 char lines_0[] = ",";
1881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1886 char fstype[] = "ext2";
1887 char device[] = "/dev/sda1";
1888 device[5] = devchar;
1891 r = guestfs_mkfs (g, fstype, device);
1896 char device[] = "/dev/sda1";
1897 device[5] = devchar;
1898 char mountpoint[] = "/";
1901 r = guestfs_mount (g, device, mountpoint);
1905 /* TestOutputInt for fsck (1) */
1907 char pathordevice[] = "/dev/sda1";
1908 pathordevice[5] = devchar;
1911 r = guestfs_umount (g, pathordevice);
1916 char device[] = "/dev/sda1";
1917 device[5] = devchar;
1920 r = guestfs_zero (g, device);
1925 char fstype[] = "ext2";
1926 char device[] = "/dev/sda1";
1927 device[5] = devchar;
1930 r = guestfs_fsck (g, fstype, device);
1934 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
1941 static int test_set_e2uuid_0 (void)
1943 /* InitBasicFS for set_e2uuid (0): create ext2 on /dev/sda1 */
1945 char device[] = "/dev/sda";
1946 device[5] = devchar;
1949 r = guestfs_blockdev_setrw (g, device);
1956 r = guestfs_umount_all (g);
1963 r = guestfs_lvm_remove_all (g);
1968 char device[] = "/dev/sda";
1969 device[5] = devchar;
1970 char lines_0[] = ",";
1977 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1982 char fstype[] = "ext2";
1983 char device[] = "/dev/sda1";
1984 device[5] = devchar;
1987 r = guestfs_mkfs (g, fstype, device);
1992 char device[] = "/dev/sda1";
1993 device[5] = devchar;
1994 char mountpoint[] = "/";
1997 r = guestfs_mount (g, device, mountpoint);
2001 /* TestOutput for set_e2uuid (0) */
2002 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2004 char device[] = "/dev/sda1";
2005 device[5] = devchar;
2006 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2009 r = guestfs_set_e2uuid (g, device, uuid);
2014 char device[] = "/dev/sda1";
2015 device[5] = devchar;
2018 r = guestfs_get_e2uuid (g, device);
2021 if (strcmp (r, expected) != 0) {
2022 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2030 static int test_set_e2uuid_1 (void)
2032 /* InitBasicFS for set_e2uuid (1): create ext2 on /dev/sda1 */
2034 char device[] = "/dev/sda";
2035 device[5] = devchar;
2038 r = guestfs_blockdev_setrw (g, device);
2045 r = guestfs_umount_all (g);
2052 r = guestfs_lvm_remove_all (g);
2057 char device[] = "/dev/sda";
2058 device[5] = devchar;
2059 char lines_0[] = ",";
2066 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2071 char fstype[] = "ext2";
2072 char device[] = "/dev/sda1";
2073 device[5] = devchar;
2076 r = guestfs_mkfs (g, fstype, device);
2081 char device[] = "/dev/sda1";
2082 device[5] = devchar;
2083 char mountpoint[] = "/";
2086 r = guestfs_mount (g, device, mountpoint);
2090 /* TestOutput for set_e2uuid (1) */
2091 char expected[] = "";
2093 char device[] = "/dev/sda1";
2094 device[5] = devchar;
2095 char uuid[] = "clear";
2098 r = guestfs_set_e2uuid (g, device, uuid);
2103 char device[] = "/dev/sda1";
2104 device[5] = devchar;
2107 r = guestfs_get_e2uuid (g, device);
2110 if (strcmp (r, expected) != 0) {
2111 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2119 static int test_set_e2uuid_2 (void)
2121 /* InitBasicFS for set_e2uuid (2): create ext2 on /dev/sda1 */
2123 char device[] = "/dev/sda";
2124 device[5] = devchar;
2127 r = guestfs_blockdev_setrw (g, device);
2134 r = guestfs_umount_all (g);
2141 r = guestfs_lvm_remove_all (g);
2146 char device[] = "/dev/sda";
2147 device[5] = devchar;
2148 char lines_0[] = ",";
2155 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2160 char fstype[] = "ext2";
2161 char device[] = "/dev/sda1";
2162 device[5] = devchar;
2165 r = guestfs_mkfs (g, fstype, device);
2170 char device[] = "/dev/sda1";
2171 device[5] = devchar;
2172 char mountpoint[] = "/";
2175 r = guestfs_mount (g, device, mountpoint);
2179 /* TestRun for set_e2uuid (2) */
2181 char device[] = "/dev/sda1";
2182 device[5] = devchar;
2183 char uuid[] = "random";
2186 r = guestfs_set_e2uuid (g, device, uuid);
2193 static int test_set_e2uuid_3 (void)
2195 /* InitBasicFS for set_e2uuid (3): create ext2 on /dev/sda1 */
2197 char device[] = "/dev/sda";
2198 device[5] = devchar;
2201 r = guestfs_blockdev_setrw (g, device);
2208 r = guestfs_umount_all (g);
2215 r = guestfs_lvm_remove_all (g);
2220 char device[] = "/dev/sda";
2221 device[5] = devchar;
2222 char lines_0[] = ",";
2229 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2234 char fstype[] = "ext2";
2235 char device[] = "/dev/sda1";
2236 device[5] = devchar;
2239 r = guestfs_mkfs (g, fstype, device);
2244 char device[] = "/dev/sda1";
2245 device[5] = devchar;
2246 char mountpoint[] = "/";
2249 r = guestfs_mount (g, device, mountpoint);
2253 /* TestRun for set_e2uuid (3) */
2255 char device[] = "/dev/sda1";
2256 device[5] = devchar;
2257 char uuid[] = "time";
2260 r = guestfs_set_e2uuid (g, device, uuid);
2267 static int test_set_e2label_0 (void)
2269 /* InitBasicFS for set_e2label (0): create ext2 on /dev/sda1 */
2271 char device[] = "/dev/sda";
2272 device[5] = devchar;
2275 r = guestfs_blockdev_setrw (g, device);
2282 r = guestfs_umount_all (g);
2289 r = guestfs_lvm_remove_all (g);
2294 char device[] = "/dev/sda";
2295 device[5] = devchar;
2296 char lines_0[] = ",";
2303 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2308 char fstype[] = "ext2";
2309 char device[] = "/dev/sda1";
2310 device[5] = devchar;
2313 r = guestfs_mkfs (g, fstype, device);
2318 char device[] = "/dev/sda1";
2319 device[5] = devchar;
2320 char mountpoint[] = "/";
2323 r = guestfs_mount (g, device, mountpoint);
2327 /* TestOutput for set_e2label (0) */
2328 char expected[] = "testlabel";
2330 char device[] = "/dev/sda1";
2331 device[5] = devchar;
2332 char label[] = "testlabel";
2335 r = guestfs_set_e2label (g, device, label);
2340 char device[] = "/dev/sda1";
2341 device[5] = devchar;
2344 r = guestfs_get_e2label (g, device);
2347 if (strcmp (r, expected) != 0) {
2348 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2356 static int test_pvremove_0 (void)
2358 /* InitEmpty for pvremove (0) */
2360 char device[] = "/dev/sda";
2361 device[5] = devchar;
2364 r = guestfs_blockdev_setrw (g, device);
2371 r = guestfs_umount_all (g);
2378 r = guestfs_lvm_remove_all (g);
2382 /* TestOutputList for pvremove (0) */
2384 char device[] = "/dev/sda";
2385 device[5] = devchar;
2388 r = guestfs_pvcreate (g, device);
2393 char volgroup[] = "VG";
2394 char physvols_0[] = "/dev/sda";
2395 physvols_0[5] = devchar;
2396 char *physvols[] = {
2402 r = guestfs_vgcreate (g, volgroup, physvols);
2407 char logvol[] = "LV1";
2408 char volgroup[] = "VG";
2411 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2416 char logvol[] = "LV2";
2417 char volgroup[] = "VG";
2420 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2425 char vgname[] = "VG";
2428 r = guestfs_vgremove (g, vgname);
2433 char device[] = "/dev/sda";
2434 device[5] = devchar;
2437 r = guestfs_pvremove (g, device);
2445 r = guestfs_lvs (g);
2449 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2453 for (i = 0; r[i] != NULL; ++i)
2460 static int test_pvremove_1 (void)
2462 /* InitEmpty for pvremove (1) */
2464 char device[] = "/dev/sda";
2465 device[5] = devchar;
2468 r = guestfs_blockdev_setrw (g, device);
2475 r = guestfs_umount_all (g);
2482 r = guestfs_lvm_remove_all (g);
2486 /* TestOutputList for pvremove (1) */
2488 char device[] = "/dev/sda";
2489 device[5] = devchar;
2492 r = guestfs_pvcreate (g, device);
2497 char volgroup[] = "VG";
2498 char physvols_0[] = "/dev/sda";
2499 physvols_0[5] = devchar;
2500 char *physvols[] = {
2506 r = guestfs_vgcreate (g, volgroup, physvols);
2511 char logvol[] = "LV1";
2512 char volgroup[] = "VG";
2515 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2520 char logvol[] = "LV2";
2521 char volgroup[] = "VG";
2524 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2529 char vgname[] = "VG";
2532 r = guestfs_vgremove (g, vgname);
2537 char device[] = "/dev/sda";
2538 device[5] = devchar;
2541 r = guestfs_pvremove (g, device);
2549 r = guestfs_vgs (g);
2553 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
2557 for (i = 0; r[i] != NULL; ++i)
2564 static int test_pvremove_2 (void)
2566 /* InitEmpty for pvremove (2) */
2568 char device[] = "/dev/sda";
2569 device[5] = devchar;
2572 r = guestfs_blockdev_setrw (g, device);
2579 r = guestfs_umount_all (g);
2586 r = guestfs_lvm_remove_all (g);
2590 /* TestOutputList for pvremove (2) */
2592 char device[] = "/dev/sda";
2593 device[5] = devchar;
2596 r = guestfs_pvcreate (g, device);
2601 char volgroup[] = "VG";
2602 char physvols_0[] = "/dev/sda";
2603 physvols_0[5] = devchar;
2604 char *physvols[] = {
2610 r = guestfs_vgcreate (g, volgroup, physvols);
2615 char logvol[] = "LV1";
2616 char volgroup[] = "VG";
2619 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2624 char logvol[] = "LV2";
2625 char volgroup[] = "VG";
2628 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2633 char vgname[] = "VG";
2636 r = guestfs_vgremove (g, vgname);
2641 char device[] = "/dev/sda";
2642 device[5] = devchar;
2645 r = guestfs_pvremove (g, device);
2653 r = guestfs_pvs (g);
2657 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
2661 for (i = 0; r[i] != NULL; ++i)
2668 static int test_vgremove_0 (void)
2670 /* InitEmpty for vgremove (0) */
2672 char device[] = "/dev/sda";
2673 device[5] = devchar;
2676 r = guestfs_blockdev_setrw (g, device);
2683 r = guestfs_umount_all (g);
2690 r = guestfs_lvm_remove_all (g);
2694 /* TestOutputList for vgremove (0) */
2696 char device[] = "/dev/sda";
2697 device[5] = devchar;
2700 r = guestfs_pvcreate (g, device);
2705 char volgroup[] = "VG";
2706 char physvols_0[] = "/dev/sda";
2707 physvols_0[5] = devchar;
2708 char *physvols[] = {
2714 r = guestfs_vgcreate (g, volgroup, physvols);
2719 char logvol[] = "LV1";
2720 char volgroup[] = "VG";
2723 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2728 char logvol[] = "LV2";
2729 char volgroup[] = "VG";
2732 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2737 char vgname[] = "VG";
2740 r = guestfs_vgremove (g, vgname);
2748 r = guestfs_lvs (g);
2752 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
2756 for (i = 0; r[i] != NULL; ++i)
2763 static int test_vgremove_1 (void)
2765 /* InitEmpty for vgremove (1) */
2767 char device[] = "/dev/sda";
2768 device[5] = devchar;
2771 r = guestfs_blockdev_setrw (g, device);
2778 r = guestfs_umount_all (g);
2785 r = guestfs_lvm_remove_all (g);
2789 /* TestOutputList for vgremove (1) */
2791 char device[] = "/dev/sda";
2792 device[5] = devchar;
2795 r = guestfs_pvcreate (g, device);
2800 char volgroup[] = "VG";
2801 char physvols_0[] = "/dev/sda";
2802 physvols_0[5] = devchar;
2803 char *physvols[] = {
2809 r = guestfs_vgcreate (g, volgroup, physvols);
2814 char logvol[] = "LV1";
2815 char volgroup[] = "VG";
2818 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2823 char logvol[] = "LV2";
2824 char volgroup[] = "VG";
2827 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2832 char vgname[] = "VG";
2835 r = guestfs_vgremove (g, vgname);
2843 r = guestfs_vgs (g);
2847 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
2851 for (i = 0; r[i] != NULL; ++i)
2858 static int test_lvremove_0 (void)
2860 /* InitEmpty for lvremove (0) */
2862 char device[] = "/dev/sda";
2863 device[5] = devchar;
2866 r = guestfs_blockdev_setrw (g, device);
2873 r = guestfs_umount_all (g);
2880 r = guestfs_lvm_remove_all (g);
2884 /* TestOutputList for lvremove (0) */
2886 char device[] = "/dev/sda";
2887 device[5] = devchar;
2890 r = guestfs_pvcreate (g, device);
2895 char volgroup[] = "VG";
2896 char physvols_0[] = "/dev/sda";
2897 physvols_0[5] = devchar;
2898 char *physvols[] = {
2904 r = guestfs_vgcreate (g, volgroup, physvols);
2909 char logvol[] = "LV1";
2910 char volgroup[] = "VG";
2913 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2918 char logvol[] = "LV2";
2919 char volgroup[] = "VG";
2922 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2927 char device[] = "/dev/VG/LV1";
2930 r = guestfs_lvremove (g, device);
2938 r = guestfs_lvs (g);
2942 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
2947 char expected[] = "/dev/VG/LV2";
2948 if (strcmp (r[0], expected) != 0) {
2949 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2954 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
2958 for (i = 0; r[i] != NULL; ++i)
2965 static int test_lvremove_1 (void)
2967 /* InitEmpty for lvremove (1) */
2969 char device[] = "/dev/sda";
2970 device[5] = devchar;
2973 r = guestfs_blockdev_setrw (g, device);
2980 r = guestfs_umount_all (g);
2987 r = guestfs_lvm_remove_all (g);
2991 /* TestOutputList for lvremove (1) */
2993 char device[] = "/dev/sda";
2994 device[5] = devchar;
2997 r = guestfs_pvcreate (g, device);
3002 char volgroup[] = "VG";
3003 char physvols_0[] = "/dev/sda";
3004 physvols_0[5] = devchar;
3005 char *physvols[] = {
3011 r = guestfs_vgcreate (g, volgroup, physvols);
3016 char logvol[] = "LV1";
3017 char volgroup[] = "VG";
3020 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3025 char logvol[] = "LV2";
3026 char volgroup[] = "VG";
3029 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3034 char device[] = "/dev/VG";
3037 r = guestfs_lvremove (g, device);
3045 r = guestfs_lvs (g);
3049 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3053 for (i = 0; r[i] != NULL; ++i)
3060 static int test_lvremove_2 (void)
3062 /* InitEmpty for lvremove (2) */
3064 char device[] = "/dev/sda";
3065 device[5] = devchar;
3068 r = guestfs_blockdev_setrw (g, device);
3075 r = guestfs_umount_all (g);
3082 r = guestfs_lvm_remove_all (g);
3086 /* TestOutputList for lvremove (2) */
3088 char device[] = "/dev/sda";
3089 device[5] = devchar;
3092 r = guestfs_pvcreate (g, device);
3097 char volgroup[] = "VG";
3098 char physvols_0[] = "/dev/sda";
3099 physvols_0[5] = devchar;
3100 char *physvols[] = {
3106 r = guestfs_vgcreate (g, volgroup, physvols);
3111 char logvol[] = "LV1";
3112 char volgroup[] = "VG";
3115 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3120 char logvol[] = "LV2";
3121 char volgroup[] = "VG";
3124 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3129 char device[] = "/dev/VG";
3132 r = guestfs_lvremove (g, device);
3140 r = guestfs_vgs (g);
3144 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3149 char expected[] = "VG";
3150 if (strcmp (r[0], expected) != 0) {
3151 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3156 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3160 for (i = 0; r[i] != NULL; ++i)
3167 static int test_mount_ro_0 (void)
3169 /* InitBasicFS for mount_ro (0): create ext2 on /dev/sda1 */
3171 char device[] = "/dev/sda";
3172 device[5] = devchar;
3175 r = guestfs_blockdev_setrw (g, device);
3182 r = guestfs_umount_all (g);
3189 r = guestfs_lvm_remove_all (g);
3194 char device[] = "/dev/sda";
3195 device[5] = devchar;
3196 char lines_0[] = ",";
3203 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3208 char fstype[] = "ext2";
3209 char device[] = "/dev/sda1";
3210 device[5] = devchar;
3213 r = guestfs_mkfs (g, fstype, device);
3218 char device[] = "/dev/sda1";
3219 device[5] = devchar;
3220 char mountpoint[] = "/";
3223 r = guestfs_mount (g, device, mountpoint);
3227 /* TestLastFail for mount_ro (0) */
3229 char pathordevice[] = "/";
3232 r = guestfs_umount (g, pathordevice);
3237 char device[] = "/dev/sda1";
3238 device[5] = devchar;
3239 char mountpoint[] = "/";
3242 r = guestfs_mount_ro (g, device, mountpoint);
3247 char path[] = "/new";
3250 r = guestfs_touch (g, path);
3257 static int test_mount_ro_1 (void)
3259 /* InitBasicFS for mount_ro (1): create ext2 on /dev/sda1 */
3261 char device[] = "/dev/sda";
3262 device[5] = devchar;
3265 r = guestfs_blockdev_setrw (g, device);
3272 r = guestfs_umount_all (g);
3279 r = guestfs_lvm_remove_all (g);
3284 char device[] = "/dev/sda";
3285 device[5] = devchar;
3286 char lines_0[] = ",";
3293 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3298 char fstype[] = "ext2";
3299 char device[] = "/dev/sda1";
3300 device[5] = devchar;
3303 r = guestfs_mkfs (g, fstype, device);
3308 char device[] = "/dev/sda1";
3309 device[5] = devchar;
3310 char mountpoint[] = "/";
3313 r = guestfs_mount (g, device, mountpoint);
3317 /* TestOutput for mount_ro (1) */
3318 char expected[] = "data";
3320 char path[] = "/new";
3321 char content[] = "data";
3324 r = guestfs_write_file (g, path, content, 0);
3329 char pathordevice[] = "/";
3332 r = guestfs_umount (g, pathordevice);
3337 char device[] = "/dev/sda1";
3338 device[5] = devchar;
3339 char mountpoint[] = "/";
3342 r = guestfs_mount_ro (g, device, mountpoint);
3347 char path[] = "/new";
3350 r = guestfs_cat (g, path);
3353 if (strcmp (r, expected) != 0) {
3354 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3362 static int test_tgz_in_0 (void)
3364 /* InitBasicFS for tgz_in (0): create ext2 on /dev/sda1 */
3366 char device[] = "/dev/sda";
3367 device[5] = devchar;
3370 r = guestfs_blockdev_setrw (g, device);
3377 r = guestfs_umount_all (g);
3384 r = guestfs_lvm_remove_all (g);
3389 char device[] = "/dev/sda";
3390 device[5] = devchar;
3391 char lines_0[] = ",";
3398 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3403 char fstype[] = "ext2";
3404 char device[] = "/dev/sda1";
3405 device[5] = devchar;
3408 r = guestfs_mkfs (g, fstype, device);
3413 char device[] = "/dev/sda1";
3414 device[5] = devchar;
3415 char mountpoint[] = "/";
3418 r = guestfs_mount (g, device, mountpoint);
3422 /* TestOutput for tgz_in (0) */
3423 char expected[] = "hello\n";
3425 char directory[] = "/";
3428 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3433 char path[] = "/hello";
3436 r = guestfs_cat (g, path);
3439 if (strcmp (r, expected) != 0) {
3440 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3448 static int test_tar_in_0 (void)
3450 /* InitBasicFS for tar_in (0): create ext2 on /dev/sda1 */
3452 char device[] = "/dev/sda";
3453 device[5] = devchar;
3456 r = guestfs_blockdev_setrw (g, device);
3463 r = guestfs_umount_all (g);
3470 r = guestfs_lvm_remove_all (g);
3475 char device[] = "/dev/sda";
3476 device[5] = devchar;
3477 char lines_0[] = ",";
3484 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3489 char fstype[] = "ext2";
3490 char device[] = "/dev/sda1";
3491 device[5] = devchar;
3494 r = guestfs_mkfs (g, fstype, device);
3499 char device[] = "/dev/sda1";
3500 device[5] = devchar;
3501 char mountpoint[] = "/";
3504 r = guestfs_mount (g, device, mountpoint);
3508 /* TestOutput for tar_in (0) */
3509 char expected[] = "hello\n";
3511 char directory[] = "/";
3514 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
3519 char path[] = "/hello";
3522 r = guestfs_cat (g, path);
3525 if (strcmp (r, expected) != 0) {
3526 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3534 static int test_checksum_0 (void)
3536 /* InitBasicFS for checksum (0): create ext2 on /dev/sda1 */
3538 char device[] = "/dev/sda";
3539 device[5] = devchar;
3542 r = guestfs_blockdev_setrw (g, device);
3549 r = guestfs_umount_all (g);
3556 r = guestfs_lvm_remove_all (g);
3561 char device[] = "/dev/sda";
3562 device[5] = devchar;
3563 char lines_0[] = ",";
3570 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3575 char fstype[] = "ext2";
3576 char device[] = "/dev/sda1";
3577 device[5] = devchar;
3580 r = guestfs_mkfs (g, fstype, device);
3585 char device[] = "/dev/sda1";
3586 device[5] = devchar;
3587 char mountpoint[] = "/";
3590 r = guestfs_mount (g, device, mountpoint);
3594 /* TestOutput for checksum (0) */
3595 char expected[] = "935282863";
3597 char path[] = "/new";
3598 char content[] = "test\n";
3601 r = guestfs_write_file (g, path, content, 0);
3606 char csumtype[] = "crc";
3607 char path[] = "/new";
3610 r = guestfs_checksum (g, csumtype, path);
3613 if (strcmp (r, expected) != 0) {
3614 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
3622 static int test_checksum_1 (void)
3624 /* InitBasicFS for checksum (1): create ext2 on /dev/sda1 */
3626 char device[] = "/dev/sda";
3627 device[5] = devchar;
3630 r = guestfs_blockdev_setrw (g, device);
3637 r = guestfs_umount_all (g);
3644 r = guestfs_lvm_remove_all (g);
3649 char device[] = "/dev/sda";
3650 device[5] = devchar;
3651 char lines_0[] = ",";
3658 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3663 char fstype[] = "ext2";
3664 char device[] = "/dev/sda1";
3665 device[5] = devchar;
3668 r = guestfs_mkfs (g, fstype, device);
3673 char device[] = "/dev/sda1";
3674 device[5] = devchar;
3675 char mountpoint[] = "/";
3678 r = guestfs_mount (g, device, mountpoint);
3682 /* TestLastFail for checksum (1) */
3684 char csumtype[] = "crc";
3685 char path[] = "/new";
3688 r = guestfs_checksum (g, csumtype, path);
3696 static int test_checksum_2 (void)
3698 /* InitBasicFS for checksum (2): create ext2 on /dev/sda1 */
3700 char device[] = "/dev/sda";
3701 device[5] = devchar;
3704 r = guestfs_blockdev_setrw (g, device);
3711 r = guestfs_umount_all (g);
3718 r = guestfs_lvm_remove_all (g);
3723 char device[] = "/dev/sda";
3724 device[5] = devchar;
3725 char lines_0[] = ",";
3732 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3737 char fstype[] = "ext2";
3738 char device[] = "/dev/sda1";
3739 device[5] = devchar;
3742 r = guestfs_mkfs (g, fstype, device);
3747 char device[] = "/dev/sda1";
3748 device[5] = devchar;
3749 char mountpoint[] = "/";
3752 r = guestfs_mount (g, device, mountpoint);
3756 /* TestOutput for checksum (2) */
3757 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
3759 char path[] = "/new";
3760 char content[] = "test\n";
3763 r = guestfs_write_file (g, path, content, 0);
3768 char csumtype[] = "md5";
3769 char path[] = "/new";
3772 r = guestfs_checksum (g, csumtype, path);
3775 if (strcmp (r, expected) != 0) {
3776 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
3784 static int test_checksum_3 (void)
3786 /* InitBasicFS for checksum (3): create ext2 on /dev/sda1 */
3788 char device[] = "/dev/sda";
3789 device[5] = devchar;
3792 r = guestfs_blockdev_setrw (g, device);
3799 r = guestfs_umount_all (g);
3806 r = guestfs_lvm_remove_all (g);
3811 char device[] = "/dev/sda";
3812 device[5] = devchar;
3813 char lines_0[] = ",";
3820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3825 char fstype[] = "ext2";
3826 char device[] = "/dev/sda1";
3827 device[5] = devchar;
3830 r = guestfs_mkfs (g, fstype, device);
3835 char device[] = "/dev/sda1";
3836 device[5] = devchar;
3837 char mountpoint[] = "/";
3840 r = guestfs_mount (g, device, mountpoint);
3844 /* TestOutput for checksum (3) */
3845 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
3847 char path[] = "/new";
3848 char content[] = "test\n";
3851 r = guestfs_write_file (g, path, content, 0);
3856 char csumtype[] = "sha1";
3857 char path[] = "/new";
3860 r = guestfs_checksum (g, csumtype, path);
3863 if (strcmp (r, expected) != 0) {
3864 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
3872 static int test_checksum_4 (void)
3874 /* InitBasicFS for checksum (4): create ext2 on /dev/sda1 */
3876 char device[] = "/dev/sda";
3877 device[5] = devchar;
3880 r = guestfs_blockdev_setrw (g, device);
3887 r = guestfs_umount_all (g);
3894 r = guestfs_lvm_remove_all (g);
3899 char device[] = "/dev/sda";
3900 device[5] = devchar;
3901 char lines_0[] = ",";
3908 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3913 char fstype[] = "ext2";
3914 char device[] = "/dev/sda1";
3915 device[5] = devchar;
3918 r = guestfs_mkfs (g, fstype, device);
3923 char device[] = "/dev/sda1";
3924 device[5] = devchar;
3925 char mountpoint[] = "/";
3928 r = guestfs_mount (g, device, mountpoint);
3932 /* TestOutput for checksum (4) */
3933 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
3935 char path[] = "/new";
3936 char content[] = "test\n";
3939 r = guestfs_write_file (g, path, content, 0);
3944 char csumtype[] = "sha224";
3945 char path[] = "/new";
3948 r = guestfs_checksum (g, csumtype, path);
3951 if (strcmp (r, expected) != 0) {
3952 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
3960 static int test_checksum_5 (void)
3962 /* InitBasicFS for checksum (5): create ext2 on /dev/sda1 */
3964 char device[] = "/dev/sda";
3965 device[5] = devchar;
3968 r = guestfs_blockdev_setrw (g, device);
3975 r = guestfs_umount_all (g);
3982 r = guestfs_lvm_remove_all (g);
3987 char device[] = "/dev/sda";
3988 device[5] = devchar;
3989 char lines_0[] = ",";
3996 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4001 char fstype[] = "ext2";
4002 char device[] = "/dev/sda1";
4003 device[5] = devchar;
4006 r = guestfs_mkfs (g, fstype, device);
4011 char device[] = "/dev/sda1";
4012 device[5] = devchar;
4013 char mountpoint[] = "/";
4016 r = guestfs_mount (g, device, mountpoint);
4020 /* TestOutput for checksum (5) */
4021 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4023 char path[] = "/new";
4024 char content[] = "test\n";
4027 r = guestfs_write_file (g, path, content, 0);
4032 char csumtype[] = "sha256";
4033 char path[] = "/new";
4036 r = guestfs_checksum (g, csumtype, path);
4039 if (strcmp (r, expected) != 0) {
4040 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4048 static int test_checksum_6 (void)
4050 /* InitBasicFS for checksum (6): create ext2 on /dev/sda1 */
4052 char device[] = "/dev/sda";
4053 device[5] = devchar;
4056 r = guestfs_blockdev_setrw (g, device);
4063 r = guestfs_umount_all (g);
4070 r = guestfs_lvm_remove_all (g);
4075 char device[] = "/dev/sda";
4076 device[5] = devchar;
4077 char lines_0[] = ",";
4084 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4089 char fstype[] = "ext2";
4090 char device[] = "/dev/sda1";
4091 device[5] = devchar;
4094 r = guestfs_mkfs (g, fstype, device);
4099 char device[] = "/dev/sda1";
4100 device[5] = devchar;
4101 char mountpoint[] = "/";
4104 r = guestfs_mount (g, device, mountpoint);
4108 /* TestOutput for checksum (6) */
4109 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4111 char path[] = "/new";
4112 char content[] = "test\n";
4115 r = guestfs_write_file (g, path, content, 0);
4120 char csumtype[] = "sha384";
4121 char path[] = "/new";
4124 r = guestfs_checksum (g, csumtype, path);
4127 if (strcmp (r, expected) != 0) {
4128 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4136 static int test_checksum_7 (void)
4138 /* InitBasicFS for checksum (7): create ext2 on /dev/sda1 */
4140 char device[] = "/dev/sda";
4141 device[5] = devchar;
4144 r = guestfs_blockdev_setrw (g, device);
4151 r = guestfs_umount_all (g);
4158 r = guestfs_lvm_remove_all (g);
4163 char device[] = "/dev/sda";
4164 device[5] = devchar;
4165 char lines_0[] = ",";
4172 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4177 char fstype[] = "ext2";
4178 char device[] = "/dev/sda1";
4179 device[5] = devchar;
4182 r = guestfs_mkfs (g, fstype, device);
4187 char device[] = "/dev/sda1";
4188 device[5] = devchar;
4189 char mountpoint[] = "/";
4192 r = guestfs_mount (g, device, mountpoint);
4196 /* TestOutput for checksum (7) */
4197 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4199 char path[] = "/new";
4200 char content[] = "test\n";
4203 r = guestfs_write_file (g, path, content, 0);
4208 char csumtype[] = "sha512";
4209 char path[] = "/new";
4212 r = guestfs_checksum (g, csumtype, path);
4215 if (strcmp (r, expected) != 0) {
4216 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4224 static int test_download_0 (void)
4226 /* InitBasicFS for download (0): create ext2 on /dev/sda1 */
4228 char device[] = "/dev/sda";
4229 device[5] = devchar;
4232 r = guestfs_blockdev_setrw (g, device);
4239 r = guestfs_umount_all (g);
4246 r = guestfs_lvm_remove_all (g);
4251 char device[] = "/dev/sda";
4252 device[5] = devchar;
4253 char lines_0[] = ",";
4260 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4265 char fstype[] = "ext2";
4266 char device[] = "/dev/sda1";
4267 device[5] = devchar;
4270 r = guestfs_mkfs (g, fstype, device);
4275 char device[] = "/dev/sda1";
4276 device[5] = devchar;
4277 char mountpoint[] = "/";
4280 r = guestfs_mount (g, device, mountpoint);
4284 /* TestOutput for download (0) */
4285 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4287 char remotefilename[] = "/COPYING.LIB";
4290 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4295 char remotefilename[] = "/COPYING.LIB";
4298 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4303 char remotefilename[] = "/upload";
4306 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4311 char csumtype[] = "md5";
4312 char path[] = "/upload";
4315 r = guestfs_checksum (g, csumtype, path);
4318 if (strcmp (r, expected) != 0) {
4319 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4327 static int test_upload_0 (void)
4329 /* InitBasicFS for upload (0): create ext2 on /dev/sda1 */
4331 char device[] = "/dev/sda";
4332 device[5] = devchar;
4335 r = guestfs_blockdev_setrw (g, device);
4342 r = guestfs_umount_all (g);
4349 r = guestfs_lvm_remove_all (g);
4354 char device[] = "/dev/sda";
4355 device[5] = devchar;
4356 char lines_0[] = ",";
4363 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4368 char fstype[] = "ext2";
4369 char device[] = "/dev/sda1";
4370 device[5] = devchar;
4373 r = guestfs_mkfs (g, fstype, device);
4378 char device[] = "/dev/sda1";
4379 device[5] = devchar;
4380 char mountpoint[] = "/";
4383 r = guestfs_mount (g, device, mountpoint);
4387 /* TestOutput for upload (0) */
4388 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4390 char remotefilename[] = "/COPYING.LIB";
4393 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4398 char csumtype[] = "md5";
4399 char path[] = "/COPYING.LIB";
4402 r = guestfs_checksum (g, csumtype, path);
4405 if (strcmp (r, expected) != 0) {
4406 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4414 static int test_blockdev_rereadpt_0 (void)
4416 /* InitEmpty for blockdev_rereadpt (0) */
4418 char device[] = "/dev/sda";
4419 device[5] = devchar;
4422 r = guestfs_blockdev_setrw (g, device);
4429 r = guestfs_umount_all (g);
4436 r = guestfs_lvm_remove_all (g);
4440 /* TestRun for blockdev_rereadpt (0) */
4442 char device[] = "/dev/sda";
4443 device[5] = devchar;
4446 r = guestfs_blockdev_rereadpt (g, device);
4453 static int test_blockdev_flushbufs_0 (void)
4455 /* InitEmpty for blockdev_flushbufs (0) */
4457 char device[] = "/dev/sda";
4458 device[5] = devchar;
4461 r = guestfs_blockdev_setrw (g, device);
4468 r = guestfs_umount_all (g);
4475 r = guestfs_lvm_remove_all (g);
4479 /* TestRun for blockdev_flushbufs (0) */
4481 char device[] = "/dev/sda";
4482 device[5] = devchar;
4485 r = guestfs_blockdev_flushbufs (g, device);
4492 static int test_blockdev_getsize64_0 (void)
4494 /* InitEmpty for blockdev_getsize64 (0) */
4496 char device[] = "/dev/sda";
4497 device[5] = devchar;
4500 r = guestfs_blockdev_setrw (g, device);
4507 r = guestfs_umount_all (g);
4514 r = guestfs_lvm_remove_all (g);
4518 /* TestOutputInt for blockdev_getsize64 (0) */
4520 char device[] = "/dev/sda";
4521 device[5] = devchar;
4524 r = guestfs_blockdev_getsize64 (g, device);
4527 if (r != 524288000) {
4528 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
4535 static int test_blockdev_getsz_0 (void)
4537 /* InitEmpty for blockdev_getsz (0) */
4539 char device[] = "/dev/sda";
4540 device[5] = devchar;
4543 r = guestfs_blockdev_setrw (g, device);
4550 r = guestfs_umount_all (g);
4557 r = guestfs_lvm_remove_all (g);
4561 /* TestOutputInt for blockdev_getsz (0) */
4563 char device[] = "/dev/sda";
4564 device[5] = devchar;
4567 r = guestfs_blockdev_getsz (g, device);
4571 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
4578 static int test_blockdev_getbsz_0 (void)
4580 /* InitEmpty for blockdev_getbsz (0) */
4582 char device[] = "/dev/sda";
4583 device[5] = devchar;
4586 r = guestfs_blockdev_setrw (g, device);
4593 r = guestfs_umount_all (g);
4600 r = guestfs_lvm_remove_all (g);
4604 /* TestOutputInt for blockdev_getbsz (0) */
4606 char device[] = "/dev/sda";
4607 device[5] = devchar;
4610 r = guestfs_blockdev_getbsz (g, device);
4614 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
4621 static int test_blockdev_getss_0 (void)
4623 /* InitEmpty for blockdev_getss (0) */
4625 char device[] = "/dev/sda";
4626 device[5] = devchar;
4629 r = guestfs_blockdev_setrw (g, device);
4636 r = guestfs_umount_all (g);
4643 r = guestfs_lvm_remove_all (g);
4647 /* TestOutputInt for blockdev_getss (0) */
4649 char device[] = "/dev/sda";
4650 device[5] = devchar;
4653 r = guestfs_blockdev_getss (g, device);
4657 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
4664 static int test_blockdev_getro_0 (void)
4666 /* InitEmpty for blockdev_getro (0) */
4668 char device[] = "/dev/sda";
4669 device[5] = devchar;
4672 r = guestfs_blockdev_setrw (g, device);
4679 r = guestfs_umount_all (g);
4686 r = guestfs_lvm_remove_all (g);
4690 /* TestOutputTrue for blockdev_getro (0) */
4692 char device[] = "/dev/sda";
4693 device[5] = devchar;
4696 r = guestfs_blockdev_setro (g, device);
4701 char device[] = "/dev/sda";
4702 device[5] = devchar;
4705 r = guestfs_blockdev_getro (g, device);
4709 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
4716 static int test_blockdev_setrw_0 (void)
4718 /* InitEmpty for blockdev_setrw (0) */
4720 char device[] = "/dev/sda";
4721 device[5] = devchar;
4724 r = guestfs_blockdev_setrw (g, device);
4731 r = guestfs_umount_all (g);
4738 r = guestfs_lvm_remove_all (g);
4742 /* TestOutputFalse for blockdev_setrw (0) */
4744 char device[] = "/dev/sda";
4745 device[5] = devchar;
4748 r = guestfs_blockdev_setrw (g, device);
4753 char device[] = "/dev/sda";
4754 device[5] = devchar;
4757 r = guestfs_blockdev_getro (g, device);
4761 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
4768 static int test_blockdev_setro_0 (void)
4770 /* InitEmpty for blockdev_setro (0) */
4772 char device[] = "/dev/sda";
4773 device[5] = devchar;
4776 r = guestfs_blockdev_setrw (g, device);
4783 r = guestfs_umount_all (g);
4790 r = guestfs_lvm_remove_all (g);
4794 /* TestOutputTrue for blockdev_setro (0) */
4796 char device[] = "/dev/sda";
4797 device[5] = devchar;
4800 r = guestfs_blockdev_setro (g, device);
4805 char device[] = "/dev/sda";
4806 device[5] = devchar;
4809 r = guestfs_blockdev_getro (g, device);
4813 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
4820 static int test_statvfs_0 (void)
4822 /* InitBasicFS for statvfs (0): create ext2 on /dev/sda1 */
4824 char device[] = "/dev/sda";
4825 device[5] = devchar;
4828 r = guestfs_blockdev_setrw (g, device);
4835 r = guestfs_umount_all (g);
4842 r = guestfs_lvm_remove_all (g);
4847 char device[] = "/dev/sda";
4848 device[5] = devchar;
4849 char lines_0[] = ",";
4856 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4861 char fstype[] = "ext2";
4862 char device[] = "/dev/sda1";
4863 device[5] = devchar;
4866 r = guestfs_mkfs (g, fstype, device);
4871 char device[] = "/dev/sda1";
4872 device[5] = devchar;
4873 char mountpoint[] = "/";
4876 r = guestfs_mount (g, device, mountpoint);
4880 /* TestOutputStruct for statvfs (0) */
4883 struct guestfs_statvfs *r;
4885 r = guestfs_statvfs (g, path);
4888 if (r->bfree != 487702) {
4889 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
4893 if (r->blocks != 490020) {
4894 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
4898 if (r->bsize != 1024) {
4899 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
4908 static int test_lstat_0 (void)
4910 /* InitBasicFS for lstat (0): create ext2 on /dev/sda1 */
4912 char device[] = "/dev/sda";
4913 device[5] = devchar;
4916 r = guestfs_blockdev_setrw (g, device);
4923 r = guestfs_umount_all (g);
4930 r = guestfs_lvm_remove_all (g);
4935 char device[] = "/dev/sda";
4936 device[5] = devchar;
4937 char lines_0[] = ",";
4944 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4949 char fstype[] = "ext2";
4950 char device[] = "/dev/sda1";
4951 device[5] = devchar;
4954 r = guestfs_mkfs (g, fstype, device);
4959 char device[] = "/dev/sda1";
4960 device[5] = devchar;
4961 char mountpoint[] = "/";
4964 r = guestfs_mount (g, device, mountpoint);
4968 /* TestOutputStruct for lstat (0) */
4970 char path[] = "/new";
4973 r = guestfs_touch (g, path);
4978 char path[] = "/new";
4979 struct guestfs_stat *r;
4981 r = guestfs_lstat (g, path);
4985 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
4994 static int test_stat_0 (void)
4996 /* InitBasicFS for stat (0): create ext2 on /dev/sda1 */
4998 char device[] = "/dev/sda";
4999 device[5] = devchar;
5002 r = guestfs_blockdev_setrw (g, device);
5009 r = guestfs_umount_all (g);
5016 r = guestfs_lvm_remove_all (g);
5021 char device[] = "/dev/sda";
5022 device[5] = devchar;
5023 char lines_0[] = ",";
5030 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5035 char fstype[] = "ext2";
5036 char device[] = "/dev/sda1";
5037 device[5] = devchar;
5040 r = guestfs_mkfs (g, fstype, device);
5045 char device[] = "/dev/sda1";
5046 device[5] = devchar;
5047 char mountpoint[] = "/";
5050 r = guestfs_mount (g, device, mountpoint);
5054 /* TestOutputStruct for stat (0) */
5056 char path[] = "/new";
5059 r = guestfs_touch (g, path);
5064 char path[] = "/new";
5065 struct guestfs_stat *r;
5067 r = guestfs_stat (g, path);
5071 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5080 static int test_command_lines_0_prereq (void)
5082 const char *str = getenv ("SKIP_TEST_COMMAND");
5083 return str && strcmp (str, "1") == 0;
5086 static int test_command_lines_0 (void)
5088 if (! test_command_lines_0_prereq ()) {
5089 /* InitBasicFS for command_lines (0): create ext2 on /dev/sda1 */
5091 char device[] = "/dev/sda";
5092 device[5] = devchar;
5095 r = guestfs_blockdev_setrw (g, device);
5102 r = guestfs_umount_all (g);
5109 r = guestfs_lvm_remove_all (g);
5114 char device[] = "/dev/sda";
5115 device[5] = devchar;
5116 char lines_0[] = ",";
5123 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5128 char fstype[] = "ext2";
5129 char device[] = "/dev/sda1";
5130 device[5] = devchar;
5133 r = guestfs_mkfs (g, fstype, device);
5138 char device[] = "/dev/sda1";
5139 device[5] = devchar;
5140 char mountpoint[] = "/";
5143 r = guestfs_mount (g, device, mountpoint);
5147 /* TestOutputList for command_lines (0) */
5149 char remotefilename[] = "/test-command";
5152 r = guestfs_upload (g, "test-command", remotefilename);
5157 char path[] = "/test-command";
5160 r = guestfs_chmod (g, 493, path);
5165 char arguments_0[] = "/test-command";
5166 char arguments_1[] = "1";
5167 char *arguments[] = {
5175 r = guestfs_command_lines (g, arguments);
5179 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5184 char expected[] = "Result1";
5185 if (strcmp (r[0], expected) != 0) {
5186 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5191 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5195 for (i = 0; r[i] != NULL; ++i)
5200 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5204 static int test_command_lines_1_prereq (void)
5206 const char *str = getenv ("SKIP_TEST_COMMAND");
5207 return str && strcmp (str, "1") == 0;
5210 static int test_command_lines_1 (void)
5212 if (! test_command_lines_1_prereq ()) {
5213 /* InitBasicFS for command_lines (1): create ext2 on /dev/sda1 */
5215 char device[] = "/dev/sda";
5216 device[5] = devchar;
5219 r = guestfs_blockdev_setrw (g, device);
5226 r = guestfs_umount_all (g);
5233 r = guestfs_lvm_remove_all (g);
5238 char device[] = "/dev/sda";
5239 device[5] = devchar;
5240 char lines_0[] = ",";
5247 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5252 char fstype[] = "ext2";
5253 char device[] = "/dev/sda1";
5254 device[5] = devchar;
5257 r = guestfs_mkfs (g, fstype, device);
5262 char device[] = "/dev/sda1";
5263 device[5] = devchar;
5264 char mountpoint[] = "/";
5267 r = guestfs_mount (g, device, mountpoint);
5271 /* TestOutputList for command_lines (1) */
5273 char remotefilename[] = "/test-command";
5276 r = guestfs_upload (g, "test-command", remotefilename);
5281 char path[] = "/test-command";
5284 r = guestfs_chmod (g, 493, path);
5289 char arguments_0[] = "/test-command";
5290 char arguments_1[] = "2";
5291 char *arguments[] = {
5299 r = guestfs_command_lines (g, arguments);
5303 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5308 char expected[] = "Result2";
5309 if (strcmp (r[0], expected) != 0) {
5310 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5315 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5319 for (i = 0; r[i] != NULL; ++i)
5324 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5328 static int test_command_lines_2_prereq (void)
5330 const char *str = getenv ("SKIP_TEST_COMMAND");
5331 return str && strcmp (str, "1") == 0;
5334 static int test_command_lines_2 (void)
5336 if (! test_command_lines_2_prereq ()) {
5337 /* InitBasicFS for command_lines (2): create ext2 on /dev/sda1 */
5339 char device[] = "/dev/sda";
5340 device[5] = devchar;
5343 r = guestfs_blockdev_setrw (g, device);
5350 r = guestfs_umount_all (g);
5357 r = guestfs_lvm_remove_all (g);
5362 char device[] = "/dev/sda";
5363 device[5] = devchar;
5364 char lines_0[] = ",";
5371 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5376 char fstype[] = "ext2";
5377 char device[] = "/dev/sda1";
5378 device[5] = devchar;
5381 r = guestfs_mkfs (g, fstype, device);
5386 char device[] = "/dev/sda1";
5387 device[5] = devchar;
5388 char mountpoint[] = "/";
5391 r = guestfs_mount (g, device, mountpoint);
5395 /* TestOutputList for command_lines (2) */
5397 char remotefilename[] = "/test-command";
5400 r = guestfs_upload (g, "test-command", remotefilename);
5405 char path[] = "/test-command";
5408 r = guestfs_chmod (g, 493, path);
5413 char arguments_0[] = "/test-command";
5414 char arguments_1[] = "3";
5415 char *arguments[] = {
5423 r = guestfs_command_lines (g, arguments);
5427 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5432 char expected[] = "";
5433 if (strcmp (r[0], expected) != 0) {
5434 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5439 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5444 char expected[] = "Result3";
5445 if (strcmp (r[1], expected) != 0) {
5446 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5451 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5455 for (i = 0; r[i] != NULL; ++i)
5460 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
5464 static int test_command_lines_3_prereq (void)
5466 const char *str = getenv ("SKIP_TEST_COMMAND");
5467 return str && strcmp (str, "1") == 0;
5470 static int test_command_lines_3 (void)
5472 if (! test_command_lines_3_prereq ()) {
5473 /* InitBasicFS for command_lines (3): create ext2 on /dev/sda1 */
5475 char device[] = "/dev/sda";
5476 device[5] = devchar;
5479 r = guestfs_blockdev_setrw (g, device);
5486 r = guestfs_umount_all (g);
5493 r = guestfs_lvm_remove_all (g);
5498 char device[] = "/dev/sda";
5499 device[5] = devchar;
5500 char lines_0[] = ",";
5507 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5512 char fstype[] = "ext2";
5513 char device[] = "/dev/sda1";
5514 device[5] = devchar;
5517 r = guestfs_mkfs (g, fstype, device);
5522 char device[] = "/dev/sda1";
5523 device[5] = devchar;
5524 char mountpoint[] = "/";
5527 r = guestfs_mount (g, device, mountpoint);
5531 /* TestOutputList for command_lines (3) */
5533 char remotefilename[] = "/test-command";
5536 r = guestfs_upload (g, "test-command", remotefilename);
5541 char path[] = "/test-command";
5544 r = guestfs_chmod (g, 493, path);
5549 char arguments_0[] = "/test-command";
5550 char arguments_1[] = "4";
5551 char *arguments[] = {
5559 r = guestfs_command_lines (g, arguments);
5563 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5568 char expected[] = "";
5569 if (strcmp (r[0], expected) != 0) {
5570 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5575 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5580 char expected[] = "Result4";
5581 if (strcmp (r[1], expected) != 0) {
5582 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5587 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
5591 for (i = 0; r[i] != NULL; ++i)
5596 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
5600 static int test_command_lines_4_prereq (void)
5602 const char *str = getenv ("SKIP_TEST_COMMAND");
5603 return str && strcmp (str, "1") == 0;
5606 static int test_command_lines_4 (void)
5608 if (! test_command_lines_4_prereq ()) {
5609 /* InitBasicFS for command_lines (4): create ext2 on /dev/sda1 */
5611 char device[] = "/dev/sda";
5612 device[5] = devchar;
5615 r = guestfs_blockdev_setrw (g, device);
5622 r = guestfs_umount_all (g);
5629 r = guestfs_lvm_remove_all (g);
5634 char device[] = "/dev/sda";
5635 device[5] = devchar;
5636 char lines_0[] = ",";
5643 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5648 char fstype[] = "ext2";
5649 char device[] = "/dev/sda1";
5650 device[5] = devchar;
5653 r = guestfs_mkfs (g, fstype, device);
5658 char device[] = "/dev/sda1";
5659 device[5] = devchar;
5660 char mountpoint[] = "/";
5663 r = guestfs_mount (g, device, mountpoint);
5667 /* TestOutputList for command_lines (4) */
5669 char remotefilename[] = "/test-command";
5672 r = guestfs_upload (g, "test-command", remotefilename);
5677 char path[] = "/test-command";
5680 r = guestfs_chmod (g, 493, path);
5685 char arguments_0[] = "/test-command";
5686 char arguments_1[] = "5";
5687 char *arguments[] = {
5695 r = guestfs_command_lines (g, arguments);
5699 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5704 char expected[] = "";
5705 if (strcmp (r[0], expected) != 0) {
5706 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5711 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5716 char expected[] = "Result5";
5717 if (strcmp (r[1], expected) != 0) {
5718 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5723 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5728 char expected[] = "";
5729 if (strcmp (r[2], expected) != 0) {
5730 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5735 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
5739 for (i = 0; r[i] != NULL; ++i)
5744 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
5748 static int test_command_lines_5_prereq (void)
5750 const char *str = getenv ("SKIP_TEST_COMMAND");
5751 return str && strcmp (str, "1") == 0;
5754 static int test_command_lines_5 (void)
5756 if (! test_command_lines_5_prereq ()) {
5757 /* InitBasicFS for command_lines (5): create ext2 on /dev/sda1 */
5759 char device[] = "/dev/sda";
5760 device[5] = devchar;
5763 r = guestfs_blockdev_setrw (g, device);
5770 r = guestfs_umount_all (g);
5777 r = guestfs_lvm_remove_all (g);
5782 char device[] = "/dev/sda";
5783 device[5] = devchar;
5784 char lines_0[] = ",";
5791 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5796 char fstype[] = "ext2";
5797 char device[] = "/dev/sda1";
5798 device[5] = devchar;
5801 r = guestfs_mkfs (g, fstype, device);
5806 char device[] = "/dev/sda1";
5807 device[5] = devchar;
5808 char mountpoint[] = "/";
5811 r = guestfs_mount (g, device, mountpoint);
5815 /* TestOutputList for command_lines (5) */
5817 char remotefilename[] = "/test-command";
5820 r = guestfs_upload (g, "test-command", remotefilename);
5825 char path[] = "/test-command";
5828 r = guestfs_chmod (g, 493, path);
5833 char arguments_0[] = "/test-command";
5834 char arguments_1[] = "6";
5835 char *arguments[] = {
5843 r = guestfs_command_lines (g, arguments);
5847 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5852 char expected[] = "";
5853 if (strcmp (r[0], expected) != 0) {
5854 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5859 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5864 char expected[] = "";
5865 if (strcmp (r[1], expected) != 0) {
5866 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5871 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5876 char expected[] = "Result6";
5877 if (strcmp (r[2], expected) != 0) {
5878 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5883 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5888 char expected[] = "";
5889 if (strcmp (r[3], expected) != 0) {
5890 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
5895 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
5899 for (i = 0; r[i] != NULL; ++i)
5904 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
5908 static int test_command_lines_6_prereq (void)
5910 const char *str = getenv ("SKIP_TEST_COMMAND");
5911 return str && strcmp (str, "1") == 0;
5914 static int test_command_lines_6 (void)
5916 if (! test_command_lines_6_prereq ()) {
5917 /* InitBasicFS for command_lines (6): create ext2 on /dev/sda1 */
5919 char device[] = "/dev/sda";
5920 device[5] = devchar;
5923 r = guestfs_blockdev_setrw (g, device);
5930 r = guestfs_umount_all (g);
5937 r = guestfs_lvm_remove_all (g);
5942 char device[] = "/dev/sda";
5943 device[5] = devchar;
5944 char lines_0[] = ",";
5951 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5956 char fstype[] = "ext2";
5957 char device[] = "/dev/sda1";
5958 device[5] = devchar;
5961 r = guestfs_mkfs (g, fstype, device);
5966 char device[] = "/dev/sda1";
5967 device[5] = devchar;
5968 char mountpoint[] = "/";
5971 r = guestfs_mount (g, device, mountpoint);
5975 /* TestOutputList for command_lines (6) */
5977 char remotefilename[] = "/test-command";
5980 r = guestfs_upload (g, "test-command", remotefilename);
5985 char path[] = "/test-command";
5988 r = guestfs_chmod (g, 493, path);
5993 char arguments_0[] = "/test-command";
5994 char arguments_1[] = "7";
5995 char *arguments[] = {
6003 r = guestfs_command_lines (g, arguments);
6007 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6011 for (i = 0; r[i] != NULL; ++i)
6016 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6020 static int test_command_lines_7_prereq (void)
6022 const char *str = getenv ("SKIP_TEST_COMMAND");
6023 return str && strcmp (str, "1") == 0;
6026 static int test_command_lines_7 (void)
6028 if (! test_command_lines_7_prereq ()) {
6029 /* InitBasicFS for command_lines (7): create ext2 on /dev/sda1 */
6031 char device[] = "/dev/sda";
6032 device[5] = devchar;
6035 r = guestfs_blockdev_setrw (g, device);
6042 r = guestfs_umount_all (g);
6049 r = guestfs_lvm_remove_all (g);
6054 char device[] = "/dev/sda";
6055 device[5] = devchar;
6056 char lines_0[] = ",";
6063 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6068 char fstype[] = "ext2";
6069 char device[] = "/dev/sda1";
6070 device[5] = devchar;
6073 r = guestfs_mkfs (g, fstype, device);
6078 char device[] = "/dev/sda1";
6079 device[5] = devchar;
6080 char mountpoint[] = "/";
6083 r = guestfs_mount (g, device, mountpoint);
6087 /* TestOutputList for command_lines (7) */
6089 char remotefilename[] = "/test-command";
6092 r = guestfs_upload (g, "test-command", remotefilename);
6097 char path[] = "/test-command";
6100 r = guestfs_chmod (g, 493, path);
6105 char arguments_0[] = "/test-command";
6106 char arguments_1[] = "8";
6107 char *arguments[] = {
6115 r = guestfs_command_lines (g, arguments);
6119 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6124 char expected[] = "";
6125 if (strcmp (r[0], expected) != 0) {
6126 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6131 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6135 for (i = 0; r[i] != NULL; ++i)
6140 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6144 static int test_command_lines_8_prereq (void)
6146 const char *str = getenv ("SKIP_TEST_COMMAND");
6147 return str && strcmp (str, "1") == 0;
6150 static int test_command_lines_8 (void)
6152 if (! test_command_lines_8_prereq ()) {
6153 /* InitBasicFS for command_lines (8): create ext2 on /dev/sda1 */
6155 char device[] = "/dev/sda";
6156 device[5] = devchar;
6159 r = guestfs_blockdev_setrw (g, device);
6166 r = guestfs_umount_all (g);
6173 r = guestfs_lvm_remove_all (g);
6178 char device[] = "/dev/sda";
6179 device[5] = devchar;
6180 char lines_0[] = ",";
6187 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6192 char fstype[] = "ext2";
6193 char device[] = "/dev/sda1";
6194 device[5] = devchar;
6197 r = guestfs_mkfs (g, fstype, device);
6202 char device[] = "/dev/sda1";
6203 device[5] = devchar;
6204 char mountpoint[] = "/";
6207 r = guestfs_mount (g, device, mountpoint);
6211 /* TestOutputList for command_lines (8) */
6213 char remotefilename[] = "/test-command";
6216 r = guestfs_upload (g, "test-command", remotefilename);
6221 char path[] = "/test-command";
6224 r = guestfs_chmod (g, 493, path);
6229 char arguments_0[] = "/test-command";
6230 char arguments_1[] = "9";
6231 char *arguments[] = {
6239 r = guestfs_command_lines (g, arguments);
6243 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6248 char expected[] = "";
6249 if (strcmp (r[0], expected) != 0) {
6250 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6255 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6260 char expected[] = "";
6261 if (strcmp (r[1], expected) != 0) {
6262 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6267 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6271 for (i = 0; r[i] != NULL; ++i)
6276 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6280 static int test_command_lines_9_prereq (void)
6282 const char *str = getenv ("SKIP_TEST_COMMAND");
6283 return str && strcmp (str, "1") == 0;
6286 static int test_command_lines_9 (void)
6288 if (! test_command_lines_9_prereq ()) {
6289 /* InitBasicFS for command_lines (9): create ext2 on /dev/sda1 */
6291 char device[] = "/dev/sda";
6292 device[5] = devchar;
6295 r = guestfs_blockdev_setrw (g, device);
6302 r = guestfs_umount_all (g);
6309 r = guestfs_lvm_remove_all (g);
6314 char device[] = "/dev/sda";
6315 device[5] = devchar;
6316 char lines_0[] = ",";
6323 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6328 char fstype[] = "ext2";
6329 char device[] = "/dev/sda1";
6330 device[5] = devchar;
6333 r = guestfs_mkfs (g, fstype, device);
6338 char device[] = "/dev/sda1";
6339 device[5] = devchar;
6340 char mountpoint[] = "/";
6343 r = guestfs_mount (g, device, mountpoint);
6347 /* TestOutputList for command_lines (9) */
6349 char remotefilename[] = "/test-command";
6352 r = guestfs_upload (g, "test-command", remotefilename);
6357 char path[] = "/test-command";
6360 r = guestfs_chmod (g, 493, path);
6365 char arguments_0[] = "/test-command";
6366 char arguments_1[] = "10";
6367 char *arguments[] = {
6375 r = guestfs_command_lines (g, arguments);
6379 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6384 char expected[] = "Result10-1";
6385 if (strcmp (r[0], expected) != 0) {
6386 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6391 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6396 char expected[] = "Result10-2";
6397 if (strcmp (r[1], expected) != 0) {
6398 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6403 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6407 for (i = 0; r[i] != NULL; ++i)
6412 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6416 static int test_command_lines_10_prereq (void)
6418 const char *str = getenv ("SKIP_TEST_COMMAND");
6419 return str && strcmp (str, "1") == 0;
6422 static int test_command_lines_10 (void)
6424 if (! test_command_lines_10_prereq ()) {
6425 /* InitBasicFS for command_lines (10): create ext2 on /dev/sda1 */
6427 char device[] = "/dev/sda";
6428 device[5] = devchar;
6431 r = guestfs_blockdev_setrw (g, device);
6438 r = guestfs_umount_all (g);
6445 r = guestfs_lvm_remove_all (g);
6450 char device[] = "/dev/sda";
6451 device[5] = devchar;
6452 char lines_0[] = ",";
6459 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6464 char fstype[] = "ext2";
6465 char device[] = "/dev/sda1";
6466 device[5] = devchar;
6469 r = guestfs_mkfs (g, fstype, device);
6474 char device[] = "/dev/sda1";
6475 device[5] = devchar;
6476 char mountpoint[] = "/";
6479 r = guestfs_mount (g, device, mountpoint);
6483 /* TestOutputList for command_lines (10) */
6485 char remotefilename[] = "/test-command";
6488 r = guestfs_upload (g, "test-command", remotefilename);
6493 char path[] = "/test-command";
6496 r = guestfs_chmod (g, 493, path);
6501 char arguments_0[] = "/test-command";
6502 char arguments_1[] = "11";
6503 char *arguments[] = {
6511 r = guestfs_command_lines (g, arguments);
6515 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6520 char expected[] = "Result11-1";
6521 if (strcmp (r[0], expected) != 0) {
6522 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6527 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6532 char expected[] = "Result11-2";
6533 if (strcmp (r[1], expected) != 0) {
6534 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6539 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
6543 for (i = 0; r[i] != NULL; ++i)
6548 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
6552 static int test_command_0_prereq (void)
6554 const char *str = getenv ("SKIP_TEST_COMMAND");
6555 return str && strcmp (str, "1") == 0;
6558 static int test_command_0 (void)
6560 if (! test_command_0_prereq ()) {
6561 /* InitBasicFS for command (0): create ext2 on /dev/sda1 */
6563 char device[] = "/dev/sda";
6564 device[5] = devchar;
6567 r = guestfs_blockdev_setrw (g, device);
6574 r = guestfs_umount_all (g);
6581 r = guestfs_lvm_remove_all (g);
6586 char device[] = "/dev/sda";
6587 device[5] = devchar;
6588 char lines_0[] = ",";
6595 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6600 char fstype[] = "ext2";
6601 char device[] = "/dev/sda1";
6602 device[5] = devchar;
6605 r = guestfs_mkfs (g, fstype, device);
6610 char device[] = "/dev/sda1";
6611 device[5] = devchar;
6612 char mountpoint[] = "/";
6615 r = guestfs_mount (g, device, mountpoint);
6619 /* TestOutput for command (0) */
6620 char expected[] = "Result1";
6622 char remotefilename[] = "/test-command";
6625 r = guestfs_upload (g, "test-command", remotefilename);
6630 char path[] = "/test-command";
6633 r = guestfs_chmod (g, 493, path);
6638 char arguments_0[] = "/test-command";
6639 char arguments_1[] = "1";
6640 char *arguments[] = {
6647 r = guestfs_command (g, arguments);
6650 if (strcmp (r, expected) != 0) {
6651 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
6657 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
6661 static int test_command_1_prereq (void)
6663 const char *str = getenv ("SKIP_TEST_COMMAND");
6664 return str && strcmp (str, "1") == 0;
6667 static int test_command_1 (void)
6669 if (! test_command_1_prereq ()) {
6670 /* InitBasicFS for command (1): create ext2 on /dev/sda1 */
6672 char device[] = "/dev/sda";
6673 device[5] = devchar;
6676 r = guestfs_blockdev_setrw (g, device);
6683 r = guestfs_umount_all (g);
6690 r = guestfs_lvm_remove_all (g);
6695 char device[] = "/dev/sda";
6696 device[5] = devchar;
6697 char lines_0[] = ",";
6704 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6709 char fstype[] = "ext2";
6710 char device[] = "/dev/sda1";
6711 device[5] = devchar;
6714 r = guestfs_mkfs (g, fstype, device);
6719 char device[] = "/dev/sda1";
6720 device[5] = devchar;
6721 char mountpoint[] = "/";
6724 r = guestfs_mount (g, device, mountpoint);
6728 /* TestOutput for command (1) */
6729 char expected[] = "Result2\n";
6731 char remotefilename[] = "/test-command";
6734 r = guestfs_upload (g, "test-command", remotefilename);
6739 char path[] = "/test-command";
6742 r = guestfs_chmod (g, 493, path);
6747 char arguments_0[] = "/test-command";
6748 char arguments_1[] = "2";
6749 char *arguments[] = {
6756 r = guestfs_command (g, arguments);
6759 if (strcmp (r, expected) != 0) {
6760 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
6766 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
6770 static int test_command_2_prereq (void)
6772 const char *str = getenv ("SKIP_TEST_COMMAND");
6773 return str && strcmp (str, "1") == 0;
6776 static int test_command_2 (void)
6778 if (! test_command_2_prereq ()) {
6779 /* InitBasicFS for command (2): create ext2 on /dev/sda1 */
6781 char device[] = "/dev/sda";
6782 device[5] = devchar;
6785 r = guestfs_blockdev_setrw (g, device);
6792 r = guestfs_umount_all (g);
6799 r = guestfs_lvm_remove_all (g);
6804 char device[] = "/dev/sda";
6805 device[5] = devchar;
6806 char lines_0[] = ",";
6813 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6818 char fstype[] = "ext2";
6819 char device[] = "/dev/sda1";
6820 device[5] = devchar;
6823 r = guestfs_mkfs (g, fstype, device);
6828 char device[] = "/dev/sda1";
6829 device[5] = devchar;
6830 char mountpoint[] = "/";
6833 r = guestfs_mount (g, device, mountpoint);
6837 /* TestOutput for command (2) */
6838 char expected[] = "\nResult3";
6840 char remotefilename[] = "/test-command";
6843 r = guestfs_upload (g, "test-command", remotefilename);
6848 char path[] = "/test-command";
6851 r = guestfs_chmod (g, 493, path);
6856 char arguments_0[] = "/test-command";
6857 char arguments_1[] = "3";
6858 char *arguments[] = {
6865 r = guestfs_command (g, arguments);
6868 if (strcmp (r, expected) != 0) {
6869 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
6875 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
6879 static int test_command_3_prereq (void)
6881 const char *str = getenv ("SKIP_TEST_COMMAND");
6882 return str && strcmp (str, "1") == 0;
6885 static int test_command_3 (void)
6887 if (! test_command_3_prereq ()) {
6888 /* InitBasicFS for command (3): create ext2 on /dev/sda1 */
6890 char device[] = "/dev/sda";
6891 device[5] = devchar;
6894 r = guestfs_blockdev_setrw (g, device);
6901 r = guestfs_umount_all (g);
6908 r = guestfs_lvm_remove_all (g);
6913 char device[] = "/dev/sda";
6914 device[5] = devchar;
6915 char lines_0[] = ",";
6922 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6927 char fstype[] = "ext2";
6928 char device[] = "/dev/sda1";
6929 device[5] = devchar;
6932 r = guestfs_mkfs (g, fstype, device);
6937 char device[] = "/dev/sda1";
6938 device[5] = devchar;
6939 char mountpoint[] = "/";
6942 r = guestfs_mount (g, device, mountpoint);
6946 /* TestOutput for command (3) */
6947 char expected[] = "\nResult4\n";
6949 char remotefilename[] = "/test-command";
6952 r = guestfs_upload (g, "test-command", remotefilename);
6957 char path[] = "/test-command";
6960 r = guestfs_chmod (g, 493, path);
6965 char arguments_0[] = "/test-command";
6966 char arguments_1[] = "4";
6967 char *arguments[] = {
6974 r = guestfs_command (g, arguments);
6977 if (strcmp (r, expected) != 0) {
6978 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
6984 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
6988 static int test_command_4_prereq (void)
6990 const char *str = getenv ("SKIP_TEST_COMMAND");
6991 return str && strcmp (str, "1") == 0;
6994 static int test_command_4 (void)
6996 if (! test_command_4_prereq ()) {
6997 /* InitBasicFS for command (4): create ext2 on /dev/sda1 */
6999 char device[] = "/dev/sda";
7000 device[5] = devchar;
7003 r = guestfs_blockdev_setrw (g, device);
7010 r = guestfs_umount_all (g);
7017 r = guestfs_lvm_remove_all (g);
7022 char device[] = "/dev/sda";
7023 device[5] = devchar;
7024 char lines_0[] = ",";
7031 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7036 char fstype[] = "ext2";
7037 char device[] = "/dev/sda1";
7038 device[5] = devchar;
7041 r = guestfs_mkfs (g, fstype, device);
7046 char device[] = "/dev/sda1";
7047 device[5] = devchar;
7048 char mountpoint[] = "/";
7051 r = guestfs_mount (g, device, mountpoint);
7055 /* TestOutput for command (4) */
7056 char expected[] = "\nResult5\n\n";
7058 char remotefilename[] = "/test-command";
7061 r = guestfs_upload (g, "test-command", remotefilename);
7066 char path[] = "/test-command";
7069 r = guestfs_chmod (g, 493, path);
7074 char arguments_0[] = "/test-command";
7075 char arguments_1[] = "5";
7076 char *arguments[] = {
7083 r = guestfs_command (g, arguments);
7086 if (strcmp (r, expected) != 0) {
7087 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7093 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7097 static int test_command_5_prereq (void)
7099 const char *str = getenv ("SKIP_TEST_COMMAND");
7100 return str && strcmp (str, "1") == 0;
7103 static int test_command_5 (void)
7105 if (! test_command_5_prereq ()) {
7106 /* InitBasicFS for command (5): create ext2 on /dev/sda1 */
7108 char device[] = "/dev/sda";
7109 device[5] = devchar;
7112 r = guestfs_blockdev_setrw (g, device);
7119 r = guestfs_umount_all (g);
7126 r = guestfs_lvm_remove_all (g);
7131 char device[] = "/dev/sda";
7132 device[5] = devchar;
7133 char lines_0[] = ",";
7140 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7145 char fstype[] = "ext2";
7146 char device[] = "/dev/sda1";
7147 device[5] = devchar;
7150 r = guestfs_mkfs (g, fstype, device);
7155 char device[] = "/dev/sda1";
7156 device[5] = devchar;
7157 char mountpoint[] = "/";
7160 r = guestfs_mount (g, device, mountpoint);
7164 /* TestOutput for command (5) */
7165 char expected[] = "\n\nResult6\n\n";
7167 char remotefilename[] = "/test-command";
7170 r = guestfs_upload (g, "test-command", remotefilename);
7175 char path[] = "/test-command";
7178 r = guestfs_chmod (g, 493, path);
7183 char arguments_0[] = "/test-command";
7184 char arguments_1[] = "6";
7185 char *arguments[] = {
7192 r = guestfs_command (g, arguments);
7195 if (strcmp (r, expected) != 0) {
7196 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7202 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7206 static int test_command_6_prereq (void)
7208 const char *str = getenv ("SKIP_TEST_COMMAND");
7209 return str && strcmp (str, "1") == 0;
7212 static int test_command_6 (void)
7214 if (! test_command_6_prereq ()) {
7215 /* InitBasicFS for command (6): create ext2 on /dev/sda1 */
7217 char device[] = "/dev/sda";
7218 device[5] = devchar;
7221 r = guestfs_blockdev_setrw (g, device);
7228 r = guestfs_umount_all (g);
7235 r = guestfs_lvm_remove_all (g);
7240 char device[] = "/dev/sda";
7241 device[5] = devchar;
7242 char lines_0[] = ",";
7249 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7254 char fstype[] = "ext2";
7255 char device[] = "/dev/sda1";
7256 device[5] = devchar;
7259 r = guestfs_mkfs (g, fstype, device);
7264 char device[] = "/dev/sda1";
7265 device[5] = devchar;
7266 char mountpoint[] = "/";
7269 r = guestfs_mount (g, device, mountpoint);
7273 /* TestOutput for command (6) */
7274 char expected[] = "";
7276 char remotefilename[] = "/test-command";
7279 r = guestfs_upload (g, "test-command", remotefilename);
7284 char path[] = "/test-command";
7287 r = guestfs_chmod (g, 493, path);
7292 char arguments_0[] = "/test-command";
7293 char arguments_1[] = "7";
7294 char *arguments[] = {
7301 r = guestfs_command (g, arguments);
7304 if (strcmp (r, expected) != 0) {
7305 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7311 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7315 static int test_command_7_prereq (void)
7317 const char *str = getenv ("SKIP_TEST_COMMAND");
7318 return str && strcmp (str, "1") == 0;
7321 static int test_command_7 (void)
7323 if (! test_command_7_prereq ()) {
7324 /* InitBasicFS for command (7): create ext2 on /dev/sda1 */
7326 char device[] = "/dev/sda";
7327 device[5] = devchar;
7330 r = guestfs_blockdev_setrw (g, device);
7337 r = guestfs_umount_all (g);
7344 r = guestfs_lvm_remove_all (g);
7349 char device[] = "/dev/sda";
7350 device[5] = devchar;
7351 char lines_0[] = ",";
7358 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7363 char fstype[] = "ext2";
7364 char device[] = "/dev/sda1";
7365 device[5] = devchar;
7368 r = guestfs_mkfs (g, fstype, device);
7373 char device[] = "/dev/sda1";
7374 device[5] = devchar;
7375 char mountpoint[] = "/";
7378 r = guestfs_mount (g, device, mountpoint);
7382 /* TestOutput for command (7) */
7383 char expected[] = "\n";
7385 char remotefilename[] = "/test-command";
7388 r = guestfs_upload (g, "test-command", remotefilename);
7393 char path[] = "/test-command";
7396 r = guestfs_chmod (g, 493, path);
7401 char arguments_0[] = "/test-command";
7402 char arguments_1[] = "8";
7403 char *arguments[] = {
7410 r = guestfs_command (g, arguments);
7413 if (strcmp (r, expected) != 0) {
7414 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7420 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7424 static int test_command_8_prereq (void)
7426 const char *str = getenv ("SKIP_TEST_COMMAND");
7427 return str && strcmp (str, "1") == 0;
7430 static int test_command_8 (void)
7432 if (! test_command_8_prereq ()) {
7433 /* InitBasicFS for command (8): create ext2 on /dev/sda1 */
7435 char device[] = "/dev/sda";
7436 device[5] = devchar;
7439 r = guestfs_blockdev_setrw (g, device);
7446 r = guestfs_umount_all (g);
7453 r = guestfs_lvm_remove_all (g);
7458 char device[] = "/dev/sda";
7459 device[5] = devchar;
7460 char lines_0[] = ",";
7467 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7472 char fstype[] = "ext2";
7473 char device[] = "/dev/sda1";
7474 device[5] = devchar;
7477 r = guestfs_mkfs (g, fstype, device);
7482 char device[] = "/dev/sda1";
7483 device[5] = devchar;
7484 char mountpoint[] = "/";
7487 r = guestfs_mount (g, device, mountpoint);
7491 /* TestOutput for command (8) */
7492 char expected[] = "\n\n";
7494 char remotefilename[] = "/test-command";
7497 r = guestfs_upload (g, "test-command", remotefilename);
7502 char path[] = "/test-command";
7505 r = guestfs_chmod (g, 493, path);
7510 char arguments_0[] = "/test-command";
7511 char arguments_1[] = "9";
7512 char *arguments[] = {
7519 r = guestfs_command (g, arguments);
7522 if (strcmp (r, expected) != 0) {
7523 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
7529 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
7533 static int test_command_9_prereq (void)
7535 const char *str = getenv ("SKIP_TEST_COMMAND");
7536 return str && strcmp (str, "1") == 0;
7539 static int test_command_9 (void)
7541 if (! test_command_9_prereq ()) {
7542 /* InitBasicFS for command (9): create ext2 on /dev/sda1 */
7544 char device[] = "/dev/sda";
7545 device[5] = devchar;
7548 r = guestfs_blockdev_setrw (g, device);
7555 r = guestfs_umount_all (g);
7562 r = guestfs_lvm_remove_all (g);
7567 char device[] = "/dev/sda";
7568 device[5] = devchar;
7569 char lines_0[] = ",";
7576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7581 char fstype[] = "ext2";
7582 char device[] = "/dev/sda1";
7583 device[5] = devchar;
7586 r = guestfs_mkfs (g, fstype, device);
7591 char device[] = "/dev/sda1";
7592 device[5] = devchar;
7593 char mountpoint[] = "/";
7596 r = guestfs_mount (g, device, mountpoint);
7600 /* TestOutput for command (9) */
7601 char expected[] = "Result10-1\nResult10-2\n";
7603 char remotefilename[] = "/test-command";
7606 r = guestfs_upload (g, "test-command", remotefilename);
7611 char path[] = "/test-command";
7614 r = guestfs_chmod (g, 493, path);
7619 char arguments_0[] = "/test-command";
7620 char arguments_1[] = "10";
7621 char *arguments[] = {
7628 r = guestfs_command (g, arguments);
7631 if (strcmp (r, expected) != 0) {
7632 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
7638 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
7642 static int test_command_10_prereq (void)
7644 const char *str = getenv ("SKIP_TEST_COMMAND");
7645 return str && strcmp (str, "1") == 0;
7648 static int test_command_10 (void)
7650 if (! test_command_10_prereq ()) {
7651 /* InitBasicFS for command (10): create ext2 on /dev/sda1 */
7653 char device[] = "/dev/sda";
7654 device[5] = devchar;
7657 r = guestfs_blockdev_setrw (g, device);
7664 r = guestfs_umount_all (g);
7671 r = guestfs_lvm_remove_all (g);
7676 char device[] = "/dev/sda";
7677 device[5] = devchar;
7678 char lines_0[] = ",";
7685 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7690 char fstype[] = "ext2";
7691 char device[] = "/dev/sda1";
7692 device[5] = devchar;
7695 r = guestfs_mkfs (g, fstype, device);
7700 char device[] = "/dev/sda1";
7701 device[5] = devchar;
7702 char mountpoint[] = "/";
7705 r = guestfs_mount (g, device, mountpoint);
7709 /* TestOutput for command (10) */
7710 char expected[] = "Result11-1\nResult11-2";
7712 char remotefilename[] = "/test-command";
7715 r = guestfs_upload (g, "test-command", remotefilename);
7720 char path[] = "/test-command";
7723 r = guestfs_chmod (g, 493, path);
7728 char arguments_0[] = "/test-command";
7729 char arguments_1[] = "11";
7730 char *arguments[] = {
7737 r = guestfs_command (g, arguments);
7740 if (strcmp (r, expected) != 0) {
7741 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
7747 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
7751 static int test_command_11_prereq (void)
7753 const char *str = getenv ("SKIP_TEST_COMMAND");
7754 return str && strcmp (str, "1") == 0;
7757 static int test_command_11 (void)
7759 if (! test_command_11_prereq ()) {
7760 /* InitBasicFS for command (11): create ext2 on /dev/sda1 */
7762 char device[] = "/dev/sda";
7763 device[5] = devchar;
7766 r = guestfs_blockdev_setrw (g, device);
7773 r = guestfs_umount_all (g);
7780 r = guestfs_lvm_remove_all (g);
7785 char device[] = "/dev/sda";
7786 device[5] = devchar;
7787 char lines_0[] = ",";
7794 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7799 char fstype[] = "ext2";
7800 char device[] = "/dev/sda1";
7801 device[5] = devchar;
7804 r = guestfs_mkfs (g, fstype, device);
7809 char device[] = "/dev/sda1";
7810 device[5] = devchar;
7811 char mountpoint[] = "/";
7814 r = guestfs_mount (g, device, mountpoint);
7818 /* TestLastFail for command (11) */
7820 char remotefilename[] = "/test-command";
7823 r = guestfs_upload (g, "test-command", remotefilename);
7828 char path[] = "/test-command";
7831 r = guestfs_chmod (g, 493, path);
7836 char arguments_0[] = "/test-command";
7837 char *arguments[] = {
7843 r = guestfs_command (g, arguments);
7849 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
7853 static int test_file_0 (void)
7855 /* InitBasicFS for file (0): create ext2 on /dev/sda1 */
7857 char device[] = "/dev/sda";
7858 device[5] = devchar;
7861 r = guestfs_blockdev_setrw (g, device);
7868 r = guestfs_umount_all (g);
7875 r = guestfs_lvm_remove_all (g);
7880 char device[] = "/dev/sda";
7881 device[5] = devchar;
7882 char lines_0[] = ",";
7889 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7894 char fstype[] = "ext2";
7895 char device[] = "/dev/sda1";
7896 device[5] = devchar;
7899 r = guestfs_mkfs (g, fstype, device);
7904 char device[] = "/dev/sda1";
7905 device[5] = devchar;
7906 char mountpoint[] = "/";
7909 r = guestfs_mount (g, device, mountpoint);
7913 /* TestOutput for file (0) */
7914 char expected[] = "empty";
7916 char path[] = "/new";
7919 r = guestfs_touch (g, path);
7924 char path[] = "/new";
7927 r = guestfs_file (g, path);
7930 if (strcmp (r, expected) != 0) {
7931 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
7939 static int test_file_1 (void)
7941 /* InitBasicFS for file (1): create ext2 on /dev/sda1 */
7943 char device[] = "/dev/sda";
7944 device[5] = devchar;
7947 r = guestfs_blockdev_setrw (g, device);
7954 r = guestfs_umount_all (g);
7961 r = guestfs_lvm_remove_all (g);
7966 char device[] = "/dev/sda";
7967 device[5] = devchar;
7968 char lines_0[] = ",";
7975 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7980 char fstype[] = "ext2";
7981 char device[] = "/dev/sda1";
7982 device[5] = devchar;
7985 r = guestfs_mkfs (g, fstype, device);
7990 char device[] = "/dev/sda1";
7991 device[5] = devchar;
7992 char mountpoint[] = "/";
7995 r = guestfs_mount (g, device, mountpoint);
7999 /* TestOutput for file (1) */
8000 char expected[] = "ASCII text";
8002 char path[] = "/new";
8003 char content[] = "some content\n";
8006 r = guestfs_write_file (g, path, content, 0);
8011 char path[] = "/new";
8014 r = guestfs_file (g, path);
8017 if (strcmp (r, expected) != 0) {
8018 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8026 static int test_file_2 (void)
8028 /* InitBasicFS for file (2): create ext2 on /dev/sda1 */
8030 char device[] = "/dev/sda";
8031 device[5] = devchar;
8034 r = guestfs_blockdev_setrw (g, device);
8041 r = guestfs_umount_all (g);
8048 r = guestfs_lvm_remove_all (g);
8053 char device[] = "/dev/sda";
8054 device[5] = devchar;
8055 char lines_0[] = ",";
8062 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8067 char fstype[] = "ext2";
8068 char device[] = "/dev/sda1";
8069 device[5] = devchar;
8072 r = guestfs_mkfs (g, fstype, device);
8077 char device[] = "/dev/sda1";
8078 device[5] = devchar;
8079 char mountpoint[] = "/";
8082 r = guestfs_mount (g, device, mountpoint);
8086 /* TestLastFail for file (2) */
8088 char path[] = "/nofile";
8091 r = guestfs_file (g, path);
8099 static int test_umount_all_0 (void)
8101 /* InitBasicFS for umount_all (0): create ext2 on /dev/sda1 */
8103 char device[] = "/dev/sda";
8104 device[5] = devchar;
8107 r = guestfs_blockdev_setrw (g, device);
8114 r = guestfs_umount_all (g);
8121 r = guestfs_lvm_remove_all (g);
8126 char device[] = "/dev/sda";
8127 device[5] = devchar;
8128 char lines_0[] = ",";
8135 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8140 char fstype[] = "ext2";
8141 char device[] = "/dev/sda1";
8142 device[5] = devchar;
8145 r = guestfs_mkfs (g, fstype, device);
8150 char device[] = "/dev/sda1";
8151 device[5] = devchar;
8152 char mountpoint[] = "/";
8155 r = guestfs_mount (g, device, mountpoint);
8159 /* TestOutputList for umount_all (0) */
8163 r = guestfs_umount_all (g);
8171 r = guestfs_mounts (g);
8175 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8179 for (i = 0; r[i] != NULL; ++i)
8186 static int test_umount_all_1 (void)
8188 /* InitEmpty for umount_all (1) */
8190 char device[] = "/dev/sda";
8191 device[5] = devchar;
8194 r = guestfs_blockdev_setrw (g, device);
8201 r = guestfs_umount_all (g);
8208 r = guestfs_lvm_remove_all (g);
8212 /* TestOutputList for umount_all (1) */
8214 char device[] = "/dev/sda";
8215 device[5] = devchar;
8216 char lines_0[] = ",10";
8217 char lines_1[] = ",20";
8218 char lines_2[] = ",";
8227 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8232 char fstype[] = "ext2";
8233 char device[] = "/dev/sda1";
8234 device[5] = devchar;
8237 r = guestfs_mkfs (g, fstype, device);
8242 char fstype[] = "ext2";
8243 char device[] = "/dev/sda2";
8244 device[5] = devchar;
8247 r = guestfs_mkfs (g, fstype, device);
8252 char fstype[] = "ext2";
8253 char device[] = "/dev/sda3";
8254 device[5] = devchar;
8257 r = guestfs_mkfs (g, fstype, device);
8262 char device[] = "/dev/sda1";
8263 device[5] = devchar;
8264 char mountpoint[] = "/";
8267 r = guestfs_mount (g, device, mountpoint);
8272 char path[] = "/mp1";
8275 r = guestfs_mkdir (g, path);
8280 char device[] = "/dev/sda2";
8281 device[5] = devchar;
8282 char mountpoint[] = "/mp1";
8285 r = guestfs_mount (g, device, mountpoint);
8290 char path[] = "/mp1/mp2";
8293 r = guestfs_mkdir (g, path);
8298 char device[] = "/dev/sda3";
8299 device[5] = devchar;
8300 char mountpoint[] = "/mp1/mp2";
8303 r = guestfs_mount (g, device, mountpoint);
8308 char path[] = "/mp1/mp2/mp3";
8311 r = guestfs_mkdir (g, path);
8318 r = guestfs_umount_all (g);
8326 r = guestfs_mounts (g);
8330 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8334 for (i = 0; r[i] != NULL; ++i)
8341 static int test_mounts_0 (void)
8343 /* InitBasicFS for mounts (0): create ext2 on /dev/sda1 */
8345 char device[] = "/dev/sda";
8346 device[5] = devchar;
8349 r = guestfs_blockdev_setrw (g, device);
8356 r = guestfs_umount_all (g);
8363 r = guestfs_lvm_remove_all (g);
8368 char device[] = "/dev/sda";
8369 device[5] = devchar;
8370 char lines_0[] = ",";
8377 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8382 char fstype[] = "ext2";
8383 char device[] = "/dev/sda1";
8384 device[5] = devchar;
8387 r = guestfs_mkfs (g, fstype, device);
8392 char device[] = "/dev/sda1";
8393 device[5] = devchar;
8394 char mountpoint[] = "/";
8397 r = guestfs_mount (g, device, mountpoint);
8401 /* TestOutputList for mounts (0) */
8406 r = guestfs_mounts (g);
8410 fprintf (stderr, "test_mounts_0: short list returned from command\n");
8415 char expected[] = "/dev/sda1";
8416 expected[5] = devchar;
8417 if (strcmp (r[0], expected) != 0) {
8418 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8423 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8427 for (i = 0; r[i] != NULL; ++i)
8434 static int test_umount_0 (void)
8436 /* InitEmpty for umount (0) */
8438 char device[] = "/dev/sda";
8439 device[5] = devchar;
8442 r = guestfs_blockdev_setrw (g, device);
8449 r = guestfs_umount_all (g);
8456 r = guestfs_lvm_remove_all (g);
8460 /* TestOutputList for umount (0) */
8462 char device[] = "/dev/sda";
8463 device[5] = devchar;
8464 char lines_0[] = ",";
8471 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8476 char fstype[] = "ext2";
8477 char device[] = "/dev/sda1";
8478 device[5] = devchar;
8481 r = guestfs_mkfs (g, fstype, device);
8486 char device[] = "/dev/sda1";
8487 device[5] = devchar;
8488 char mountpoint[] = "/";
8491 r = guestfs_mount (g, device, mountpoint);
8499 r = guestfs_mounts (g);
8503 fprintf (stderr, "test_umount_0: short list returned from command\n");
8508 char expected[] = "/dev/sda1";
8509 expected[5] = devchar;
8510 if (strcmp (r[0], expected) != 0) {
8511 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8516 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
8520 for (i = 0; r[i] != NULL; ++i)
8527 static int test_umount_1 (void)
8529 /* InitEmpty for umount (1) */
8531 char device[] = "/dev/sda";
8532 device[5] = devchar;
8535 r = guestfs_blockdev_setrw (g, device);
8542 r = guestfs_umount_all (g);
8549 r = guestfs_lvm_remove_all (g);
8553 /* TestOutputList for umount (1) */
8555 char device[] = "/dev/sda";
8556 device[5] = devchar;
8557 char lines_0[] = ",";
8564 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8569 char fstype[] = "ext2";
8570 char device[] = "/dev/sda1";
8571 device[5] = devchar;
8574 r = guestfs_mkfs (g, fstype, device);
8579 char device[] = "/dev/sda1";
8580 device[5] = devchar;
8581 char mountpoint[] = "/";
8584 r = guestfs_mount (g, device, mountpoint);
8589 char pathordevice[] = "/";
8592 r = guestfs_umount (g, pathordevice);
8600 r = guestfs_mounts (g);
8604 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
8608 for (i = 0; r[i] != NULL; ++i)
8615 static int test_write_file_0 (void)
8617 /* InitBasicFS for write_file (0): create ext2 on /dev/sda1 */
8619 char device[] = "/dev/sda";
8620 device[5] = devchar;
8623 r = guestfs_blockdev_setrw (g, device);
8630 r = guestfs_umount_all (g);
8637 r = guestfs_lvm_remove_all (g);
8642 char device[] = "/dev/sda";
8643 device[5] = devchar;
8644 char lines_0[] = ",";
8651 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8656 char fstype[] = "ext2";
8657 char device[] = "/dev/sda1";
8658 device[5] = devchar;
8661 r = guestfs_mkfs (g, fstype, device);
8666 char device[] = "/dev/sda1";
8667 device[5] = devchar;
8668 char mountpoint[] = "/";
8671 r = guestfs_mount (g, device, mountpoint);
8675 /* TestOutput for write_file (0) */
8676 char expected[] = "new file contents";
8678 char path[] = "/new";
8679 char content[] = "new file contents";
8682 r = guestfs_write_file (g, path, content, 0);
8687 char path[] = "/new";
8690 r = guestfs_cat (g, path);
8693 if (strcmp (r, expected) != 0) {
8694 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8702 static int test_write_file_1 (void)
8704 /* InitBasicFS for write_file (1): create ext2 on /dev/sda1 */
8706 char device[] = "/dev/sda";
8707 device[5] = devchar;
8710 r = guestfs_blockdev_setrw (g, device);
8717 r = guestfs_umount_all (g);
8724 r = guestfs_lvm_remove_all (g);
8729 char device[] = "/dev/sda";
8730 device[5] = devchar;
8731 char lines_0[] = ",";
8738 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8743 char fstype[] = "ext2";
8744 char device[] = "/dev/sda1";
8745 device[5] = devchar;
8748 r = guestfs_mkfs (g, fstype, device);
8753 char device[] = "/dev/sda1";
8754 device[5] = devchar;
8755 char mountpoint[] = "/";
8758 r = guestfs_mount (g, device, mountpoint);
8762 /* TestOutput for write_file (1) */
8763 char expected[] = "\nnew file contents\n";
8765 char path[] = "/new";
8766 char content[] = "\nnew file contents\n";
8769 r = guestfs_write_file (g, path, content, 0);
8774 char path[] = "/new";
8777 r = guestfs_cat (g, path);
8780 if (strcmp (r, expected) != 0) {
8781 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8789 static int test_write_file_2 (void)
8791 /* InitBasicFS for write_file (2): create ext2 on /dev/sda1 */
8793 char device[] = "/dev/sda";
8794 device[5] = devchar;
8797 r = guestfs_blockdev_setrw (g, device);
8804 r = guestfs_umount_all (g);
8811 r = guestfs_lvm_remove_all (g);
8816 char device[] = "/dev/sda";
8817 device[5] = devchar;
8818 char lines_0[] = ",";
8825 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8830 char fstype[] = "ext2";
8831 char device[] = "/dev/sda1";
8832 device[5] = devchar;
8835 r = guestfs_mkfs (g, fstype, device);
8840 char device[] = "/dev/sda1";
8841 device[5] = devchar;
8842 char mountpoint[] = "/";
8845 r = guestfs_mount (g, device, mountpoint);
8849 /* TestOutput for write_file (2) */
8850 char expected[] = "\n\n";
8852 char path[] = "/new";
8853 char content[] = "\n\n";
8856 r = guestfs_write_file (g, path, content, 0);
8861 char path[] = "/new";
8864 r = guestfs_cat (g, path);
8867 if (strcmp (r, expected) != 0) {
8868 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
8876 static int test_write_file_3 (void)
8878 /* InitBasicFS for write_file (3): create ext2 on /dev/sda1 */
8880 char device[] = "/dev/sda";
8881 device[5] = devchar;
8884 r = guestfs_blockdev_setrw (g, device);
8891 r = guestfs_umount_all (g);
8898 r = guestfs_lvm_remove_all (g);
8903 char device[] = "/dev/sda";
8904 device[5] = devchar;
8905 char lines_0[] = ",";
8912 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8917 char fstype[] = "ext2";
8918 char device[] = "/dev/sda1";
8919 device[5] = devchar;
8922 r = guestfs_mkfs (g, fstype, device);
8927 char device[] = "/dev/sda1";
8928 device[5] = devchar;
8929 char mountpoint[] = "/";
8932 r = guestfs_mount (g, device, mountpoint);
8936 /* TestOutput for write_file (3) */
8937 char expected[] = "";
8939 char path[] = "/new";
8940 char content[] = "";
8943 r = guestfs_write_file (g, path, content, 0);
8948 char path[] = "/new";
8951 r = guestfs_cat (g, path);
8954 if (strcmp (r, expected) != 0) {
8955 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
8963 static int test_write_file_4 (void)
8965 /* InitBasicFS for write_file (4): create ext2 on /dev/sda1 */
8967 char device[] = "/dev/sda";
8968 device[5] = devchar;
8971 r = guestfs_blockdev_setrw (g, device);
8978 r = guestfs_umount_all (g);
8985 r = guestfs_lvm_remove_all (g);
8990 char device[] = "/dev/sda";
8991 device[5] = devchar;
8992 char lines_0[] = ",";
8999 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9004 char fstype[] = "ext2";
9005 char device[] = "/dev/sda1";
9006 device[5] = devchar;
9009 r = guestfs_mkfs (g, fstype, device);
9014 char device[] = "/dev/sda1";
9015 device[5] = devchar;
9016 char mountpoint[] = "/";
9019 r = guestfs_mount (g, device, mountpoint);
9023 /* TestOutput for write_file (4) */
9024 char expected[] = "\n\n\n";
9026 char path[] = "/new";
9027 char content[] = "\n\n\n";
9030 r = guestfs_write_file (g, path, content, 0);
9035 char path[] = "/new";
9038 r = guestfs_cat (g, path);
9041 if (strcmp (r, expected) != 0) {
9042 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9050 static int test_write_file_5 (void)
9052 /* InitBasicFS for write_file (5): create ext2 on /dev/sda1 */
9054 char device[] = "/dev/sda";
9055 device[5] = devchar;
9058 r = guestfs_blockdev_setrw (g, device);
9065 r = guestfs_umount_all (g);
9072 r = guestfs_lvm_remove_all (g);
9077 char device[] = "/dev/sda";
9078 device[5] = devchar;
9079 char lines_0[] = ",";
9086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9091 char fstype[] = "ext2";
9092 char device[] = "/dev/sda1";
9093 device[5] = devchar;
9096 r = guestfs_mkfs (g, fstype, device);
9101 char device[] = "/dev/sda1";
9102 device[5] = devchar;
9103 char mountpoint[] = "/";
9106 r = guestfs_mount (g, device, mountpoint);
9110 /* TestOutput for write_file (5) */
9111 char expected[] = "\n";
9113 char path[] = "/new";
9114 char content[] = "\n";
9117 r = guestfs_write_file (g, path, content, 0);
9122 char path[] = "/new";
9125 r = guestfs_cat (g, path);
9128 if (strcmp (r, expected) != 0) {
9129 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9137 static int test_mkfs_0 (void)
9139 /* InitEmpty for mkfs (0) */
9141 char device[] = "/dev/sda";
9142 device[5] = devchar;
9145 r = guestfs_blockdev_setrw (g, device);
9152 r = guestfs_umount_all (g);
9159 r = guestfs_lvm_remove_all (g);
9163 /* TestOutput for mkfs (0) */
9164 char expected[] = "new file contents";
9166 char device[] = "/dev/sda";
9167 device[5] = devchar;
9168 char lines_0[] = ",";
9175 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9180 char fstype[] = "ext2";
9181 char device[] = "/dev/sda1";
9182 device[5] = devchar;
9185 r = guestfs_mkfs (g, fstype, device);
9190 char device[] = "/dev/sda1";
9191 device[5] = devchar;
9192 char mountpoint[] = "/";
9195 r = guestfs_mount (g, device, mountpoint);
9200 char path[] = "/new";
9201 char content[] = "new file contents";
9204 r = guestfs_write_file (g, path, content, 0);
9209 char path[] = "/new";
9212 r = guestfs_cat (g, path);
9215 if (strcmp (r, expected) != 0) {
9216 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9224 static int test_lvcreate_0 (void)
9226 /* InitEmpty for lvcreate (0) */
9228 char device[] = "/dev/sda";
9229 device[5] = devchar;
9232 r = guestfs_blockdev_setrw (g, device);
9239 r = guestfs_umount_all (g);
9246 r = guestfs_lvm_remove_all (g);
9250 /* TestOutputList for lvcreate (0) */
9252 char device[] = "/dev/sda";
9253 device[5] = devchar;
9254 char lines_0[] = ",10";
9255 char lines_1[] = ",20";
9256 char lines_2[] = ",";
9265 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9270 char device[] = "/dev/sda1";
9271 device[5] = devchar;
9274 r = guestfs_pvcreate (g, device);
9279 char device[] = "/dev/sda2";
9280 device[5] = devchar;
9283 r = guestfs_pvcreate (g, device);
9288 char device[] = "/dev/sda3";
9289 device[5] = devchar;
9292 r = guestfs_pvcreate (g, device);
9297 char volgroup[] = "VG1";
9298 char physvols_0[] = "/dev/sda1";
9299 physvols_0[5] = devchar;
9300 char physvols_1[] = "/dev/sda2";
9301 physvols_1[5] = devchar;
9302 char *physvols[] = {
9309 r = guestfs_vgcreate (g, volgroup, physvols);
9314 char volgroup[] = "VG2";
9315 char physvols_0[] = "/dev/sda3";
9316 physvols_0[5] = devchar;
9317 char *physvols[] = {
9323 r = guestfs_vgcreate (g, volgroup, physvols);
9328 char logvol[] = "LV1";
9329 char volgroup[] = "VG1";
9332 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9337 char logvol[] = "LV2";
9338 char volgroup[] = "VG1";
9341 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9346 char logvol[] = "LV3";
9347 char volgroup[] = "VG2";
9350 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9355 char logvol[] = "LV4";
9356 char volgroup[] = "VG2";
9359 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9364 char logvol[] = "LV5";
9365 char volgroup[] = "VG2";
9368 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9376 r = guestfs_lvs (g);
9380 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9385 char expected[] = "/dev/VG1/LV1";
9386 if (strcmp (r[0], expected) != 0) {
9387 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9392 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9397 char expected[] = "/dev/VG1/LV2";
9398 if (strcmp (r[1], expected) != 0) {
9399 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9404 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9409 char expected[] = "/dev/VG2/LV3";
9410 if (strcmp (r[2], expected) != 0) {
9411 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9416 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9421 char expected[] = "/dev/VG2/LV4";
9422 if (strcmp (r[3], expected) != 0) {
9423 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9428 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9433 char expected[] = "/dev/VG2/LV5";
9434 if (strcmp (r[4], expected) != 0) {
9435 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9440 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9444 for (i = 0; r[i] != NULL; ++i)
9451 static int test_vgcreate_0 (void)
9453 /* InitEmpty for vgcreate (0) */
9455 char device[] = "/dev/sda";
9456 device[5] = devchar;
9459 r = guestfs_blockdev_setrw (g, device);
9466 r = guestfs_umount_all (g);
9473 r = guestfs_lvm_remove_all (g);
9477 /* TestOutputList for vgcreate (0) */
9479 char device[] = "/dev/sda";
9480 device[5] = devchar;
9481 char lines_0[] = ",10";
9482 char lines_1[] = ",20";
9483 char lines_2[] = ",";
9492 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9497 char device[] = "/dev/sda1";
9498 device[5] = devchar;
9501 r = guestfs_pvcreate (g, device);
9506 char device[] = "/dev/sda2";
9507 device[5] = devchar;
9510 r = guestfs_pvcreate (g, device);
9515 char device[] = "/dev/sda3";
9516 device[5] = devchar;
9519 r = guestfs_pvcreate (g, device);
9524 char volgroup[] = "VG1";
9525 char physvols_0[] = "/dev/sda1";
9526 physvols_0[5] = devchar;
9527 char physvols_1[] = "/dev/sda2";
9528 physvols_1[5] = devchar;
9529 char *physvols[] = {
9536 r = guestfs_vgcreate (g, volgroup, physvols);
9541 char volgroup[] = "VG2";
9542 char physvols_0[] = "/dev/sda3";
9543 physvols_0[5] = devchar;
9544 char *physvols[] = {
9550 r = guestfs_vgcreate (g, volgroup, physvols);
9558 r = guestfs_vgs (g);
9562 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9567 char expected[] = "VG1";
9568 if (strcmp (r[0], expected) != 0) {
9569 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9574 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9579 char expected[] = "VG2";
9580 if (strcmp (r[1], expected) != 0) {
9581 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9586 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
9590 for (i = 0; r[i] != NULL; ++i)
9597 static int test_pvcreate_0 (void)
9599 /* InitEmpty for pvcreate (0) */
9601 char device[] = "/dev/sda";
9602 device[5] = devchar;
9605 r = guestfs_blockdev_setrw (g, device);
9612 r = guestfs_umount_all (g);
9619 r = guestfs_lvm_remove_all (g);
9623 /* TestOutputList for pvcreate (0) */
9625 char device[] = "/dev/sda";
9626 device[5] = devchar;
9627 char lines_0[] = ",10";
9628 char lines_1[] = ",20";
9629 char lines_2[] = ",";
9638 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9643 char device[] = "/dev/sda1";
9644 device[5] = devchar;
9647 r = guestfs_pvcreate (g, device);
9652 char device[] = "/dev/sda2";
9653 device[5] = devchar;
9656 r = guestfs_pvcreate (g, device);
9661 char device[] = "/dev/sda3";
9662 device[5] = devchar;
9665 r = guestfs_pvcreate (g, device);
9673 r = guestfs_pvs (g);
9677 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9682 char expected[] = "/dev/sda1";
9683 expected[5] = devchar;
9684 if (strcmp (r[0], expected) != 0) {
9685 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9690 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9695 char expected[] = "/dev/sda2";
9696 expected[5] = devchar;
9697 if (strcmp (r[1], expected) != 0) {
9698 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9703 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9708 char expected[] = "/dev/sda3";
9709 expected[5] = devchar;
9710 if (strcmp (r[2], expected) != 0) {
9711 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9716 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
9720 for (i = 0; r[i] != NULL; ++i)
9727 static int test_is_dir_0 (void)
9729 /* InitBasicFS for is_dir (0): create ext2 on /dev/sda1 */
9731 char device[] = "/dev/sda";
9732 device[5] = devchar;
9735 r = guestfs_blockdev_setrw (g, device);
9742 r = guestfs_umount_all (g);
9749 r = guestfs_lvm_remove_all (g);
9754 char device[] = "/dev/sda";
9755 device[5] = devchar;
9756 char lines_0[] = ",";
9763 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9768 char fstype[] = "ext2";
9769 char device[] = "/dev/sda1";
9770 device[5] = devchar;
9773 r = guestfs_mkfs (g, fstype, device);
9778 char device[] = "/dev/sda1";
9779 device[5] = devchar;
9780 char mountpoint[] = "/";
9783 r = guestfs_mount (g, device, mountpoint);
9787 /* TestOutputFalse for is_dir (0) */
9789 char path[] = "/new";
9792 r = guestfs_touch (g, path);
9797 char path[] = "/new";
9800 r = guestfs_is_dir (g, path);
9804 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
9811 static int test_is_dir_1 (void)
9813 /* InitBasicFS for is_dir (1): create ext2 on /dev/sda1 */
9815 char device[] = "/dev/sda";
9816 device[5] = devchar;
9819 r = guestfs_blockdev_setrw (g, device);
9826 r = guestfs_umount_all (g);
9833 r = guestfs_lvm_remove_all (g);
9838 char device[] = "/dev/sda";
9839 device[5] = devchar;
9840 char lines_0[] = ",";
9847 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9852 char fstype[] = "ext2";
9853 char device[] = "/dev/sda1";
9854 device[5] = devchar;
9857 r = guestfs_mkfs (g, fstype, device);
9862 char device[] = "/dev/sda1";
9863 device[5] = devchar;
9864 char mountpoint[] = "/";
9867 r = guestfs_mount (g, device, mountpoint);
9871 /* TestOutputTrue for is_dir (1) */
9873 char path[] = "/new";
9876 r = guestfs_mkdir (g, path);
9881 char path[] = "/new";
9884 r = guestfs_is_dir (g, path);
9888 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
9895 static int test_is_file_0 (void)
9897 /* InitBasicFS for is_file (0): create ext2 on /dev/sda1 */
9899 char device[] = "/dev/sda";
9900 device[5] = devchar;
9903 r = guestfs_blockdev_setrw (g, device);
9910 r = guestfs_umount_all (g);
9917 r = guestfs_lvm_remove_all (g);
9922 char device[] = "/dev/sda";
9923 device[5] = devchar;
9924 char lines_0[] = ",";
9931 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9936 char fstype[] = "ext2";
9937 char device[] = "/dev/sda1";
9938 device[5] = devchar;
9941 r = guestfs_mkfs (g, fstype, device);
9946 char device[] = "/dev/sda1";
9947 device[5] = devchar;
9948 char mountpoint[] = "/";
9951 r = guestfs_mount (g, device, mountpoint);
9955 /* TestOutputTrue for is_file (0) */
9957 char path[] = "/new";
9960 r = guestfs_touch (g, path);
9965 char path[] = "/new";
9968 r = guestfs_is_file (g, path);
9972 fprintf (stderr, "test_is_file_0: expected true, got false\n");
9979 static int test_is_file_1 (void)
9981 /* InitBasicFS for is_file (1): create ext2 on /dev/sda1 */
9983 char device[] = "/dev/sda";
9984 device[5] = devchar;
9987 r = guestfs_blockdev_setrw (g, device);
9994 r = guestfs_umount_all (g);
10000 suppress_error = 0;
10001 r = guestfs_lvm_remove_all (g);
10006 char device[] = "/dev/sda";
10007 device[5] = devchar;
10008 char lines_0[] = ",";
10014 suppress_error = 0;
10015 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10020 char fstype[] = "ext2";
10021 char device[] = "/dev/sda1";
10022 device[5] = devchar;
10024 suppress_error = 0;
10025 r = guestfs_mkfs (g, fstype, device);
10030 char device[] = "/dev/sda1";
10031 device[5] = devchar;
10032 char mountpoint[] = "/";
10034 suppress_error = 0;
10035 r = guestfs_mount (g, device, mountpoint);
10039 /* TestOutputFalse for is_file (1) */
10041 char path[] = "/new";
10043 suppress_error = 0;
10044 r = guestfs_mkdir (g, path);
10049 char path[] = "/new";
10051 suppress_error = 0;
10052 r = guestfs_is_file (g, path);
10056 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10063 static int test_exists_0 (void)
10065 /* InitBasicFS for exists (0): create ext2 on /dev/sda1 */
10067 char device[] = "/dev/sda";
10068 device[5] = devchar;
10070 suppress_error = 0;
10071 r = guestfs_blockdev_setrw (g, device);
10077 suppress_error = 0;
10078 r = guestfs_umount_all (g);
10084 suppress_error = 0;
10085 r = guestfs_lvm_remove_all (g);
10090 char device[] = "/dev/sda";
10091 device[5] = devchar;
10092 char lines_0[] = ",";
10098 suppress_error = 0;
10099 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10104 char fstype[] = "ext2";
10105 char device[] = "/dev/sda1";
10106 device[5] = devchar;
10108 suppress_error = 0;
10109 r = guestfs_mkfs (g, fstype, device);
10114 char device[] = "/dev/sda1";
10115 device[5] = devchar;
10116 char mountpoint[] = "/";
10118 suppress_error = 0;
10119 r = guestfs_mount (g, device, mountpoint);
10123 /* TestOutputTrue for exists (0) */
10125 char path[] = "/new";
10127 suppress_error = 0;
10128 r = guestfs_touch (g, path);
10133 char path[] = "/new";
10135 suppress_error = 0;
10136 r = guestfs_exists (g, path);
10140 fprintf (stderr, "test_exists_0: expected true, got false\n");
10147 static int test_exists_1 (void)
10149 /* InitBasicFS for exists (1): create ext2 on /dev/sda1 */
10151 char device[] = "/dev/sda";
10152 device[5] = devchar;
10154 suppress_error = 0;
10155 r = guestfs_blockdev_setrw (g, device);
10161 suppress_error = 0;
10162 r = guestfs_umount_all (g);
10168 suppress_error = 0;
10169 r = guestfs_lvm_remove_all (g);
10174 char device[] = "/dev/sda";
10175 device[5] = devchar;
10176 char lines_0[] = ",";
10182 suppress_error = 0;
10183 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10188 char fstype[] = "ext2";
10189 char device[] = "/dev/sda1";
10190 device[5] = devchar;
10192 suppress_error = 0;
10193 r = guestfs_mkfs (g, fstype, device);
10198 char device[] = "/dev/sda1";
10199 device[5] = devchar;
10200 char mountpoint[] = "/";
10202 suppress_error = 0;
10203 r = guestfs_mount (g, device, mountpoint);
10207 /* TestOutputTrue for exists (1) */
10209 char path[] = "/new";
10211 suppress_error = 0;
10212 r = guestfs_mkdir (g, path);
10217 char path[] = "/new";
10219 suppress_error = 0;
10220 r = guestfs_exists (g, path);
10224 fprintf (stderr, "test_exists_1: expected true, got false\n");
10231 static int test_mkdir_p_0 (void)
10233 /* InitBasicFS for mkdir_p (0): create ext2 on /dev/sda1 */
10235 char device[] = "/dev/sda";
10236 device[5] = devchar;
10238 suppress_error = 0;
10239 r = guestfs_blockdev_setrw (g, device);
10245 suppress_error = 0;
10246 r = guestfs_umount_all (g);
10252 suppress_error = 0;
10253 r = guestfs_lvm_remove_all (g);
10258 char device[] = "/dev/sda";
10259 device[5] = devchar;
10260 char lines_0[] = ",";
10266 suppress_error = 0;
10267 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10272 char fstype[] = "ext2";
10273 char device[] = "/dev/sda1";
10274 device[5] = devchar;
10276 suppress_error = 0;
10277 r = guestfs_mkfs (g, fstype, device);
10282 char device[] = "/dev/sda1";
10283 device[5] = devchar;
10284 char mountpoint[] = "/";
10286 suppress_error = 0;
10287 r = guestfs_mount (g, device, mountpoint);
10291 /* TestOutputTrue for mkdir_p (0) */
10293 char path[] = "/new/foo/bar";
10295 suppress_error = 0;
10296 r = guestfs_mkdir_p (g, path);
10301 char path[] = "/new/foo/bar";
10303 suppress_error = 0;
10304 r = guestfs_is_dir (g, path);
10308 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10315 static int test_mkdir_p_1 (void)
10317 /* InitBasicFS for mkdir_p (1): create ext2 on /dev/sda1 */
10319 char device[] = "/dev/sda";
10320 device[5] = devchar;
10322 suppress_error = 0;
10323 r = guestfs_blockdev_setrw (g, device);
10329 suppress_error = 0;
10330 r = guestfs_umount_all (g);
10336 suppress_error = 0;
10337 r = guestfs_lvm_remove_all (g);
10342 char device[] = "/dev/sda";
10343 device[5] = devchar;
10344 char lines_0[] = ",";
10350 suppress_error = 0;
10351 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10356 char fstype[] = "ext2";
10357 char device[] = "/dev/sda1";
10358 device[5] = devchar;
10360 suppress_error = 0;
10361 r = guestfs_mkfs (g, fstype, device);
10366 char device[] = "/dev/sda1";
10367 device[5] = devchar;
10368 char mountpoint[] = "/";
10370 suppress_error = 0;
10371 r = guestfs_mount (g, device, mountpoint);
10375 /* TestOutputTrue for mkdir_p (1) */
10377 char path[] = "/new/foo/bar";
10379 suppress_error = 0;
10380 r = guestfs_mkdir_p (g, path);
10385 char path[] = "/new/foo";
10387 suppress_error = 0;
10388 r = guestfs_is_dir (g, path);
10392 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10399 static int test_mkdir_p_2 (void)
10401 /* InitBasicFS for mkdir_p (2): create ext2 on /dev/sda1 */
10403 char device[] = "/dev/sda";
10404 device[5] = devchar;
10406 suppress_error = 0;
10407 r = guestfs_blockdev_setrw (g, device);
10413 suppress_error = 0;
10414 r = guestfs_umount_all (g);
10420 suppress_error = 0;
10421 r = guestfs_lvm_remove_all (g);
10426 char device[] = "/dev/sda";
10427 device[5] = devchar;
10428 char lines_0[] = ",";
10434 suppress_error = 0;
10435 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10440 char fstype[] = "ext2";
10441 char device[] = "/dev/sda1";
10442 device[5] = devchar;
10444 suppress_error = 0;
10445 r = guestfs_mkfs (g, fstype, device);
10450 char device[] = "/dev/sda1";
10451 device[5] = devchar;
10452 char mountpoint[] = "/";
10454 suppress_error = 0;
10455 r = guestfs_mount (g, device, mountpoint);
10459 /* TestOutputTrue for mkdir_p (2) */
10461 char path[] = "/new/foo/bar";
10463 suppress_error = 0;
10464 r = guestfs_mkdir_p (g, path);
10469 char path[] = "/new";
10471 suppress_error = 0;
10472 r = guestfs_is_dir (g, path);
10476 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
10483 static int test_mkdir_0 (void)
10485 /* InitBasicFS for mkdir (0): create ext2 on /dev/sda1 */
10487 char device[] = "/dev/sda";
10488 device[5] = devchar;
10490 suppress_error = 0;
10491 r = guestfs_blockdev_setrw (g, device);
10497 suppress_error = 0;
10498 r = guestfs_umount_all (g);
10504 suppress_error = 0;
10505 r = guestfs_lvm_remove_all (g);
10510 char device[] = "/dev/sda";
10511 device[5] = devchar;
10512 char lines_0[] = ",";
10518 suppress_error = 0;
10519 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10524 char fstype[] = "ext2";
10525 char device[] = "/dev/sda1";
10526 device[5] = devchar;
10528 suppress_error = 0;
10529 r = guestfs_mkfs (g, fstype, device);
10534 char device[] = "/dev/sda1";
10535 device[5] = devchar;
10536 char mountpoint[] = "/";
10538 suppress_error = 0;
10539 r = guestfs_mount (g, device, mountpoint);
10543 /* TestOutputTrue for mkdir (0) */
10545 char path[] = "/new";
10547 suppress_error = 0;
10548 r = guestfs_mkdir (g, path);
10553 char path[] = "/new";
10555 suppress_error = 0;
10556 r = guestfs_is_dir (g, path);
10560 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
10567 static int test_mkdir_1 (void)
10569 /* InitBasicFS for mkdir (1): create ext2 on /dev/sda1 */
10571 char device[] = "/dev/sda";
10572 device[5] = devchar;
10574 suppress_error = 0;
10575 r = guestfs_blockdev_setrw (g, device);
10581 suppress_error = 0;
10582 r = guestfs_umount_all (g);
10588 suppress_error = 0;
10589 r = guestfs_lvm_remove_all (g);
10594 char device[] = "/dev/sda";
10595 device[5] = devchar;
10596 char lines_0[] = ",";
10602 suppress_error = 0;
10603 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10608 char fstype[] = "ext2";
10609 char device[] = "/dev/sda1";
10610 device[5] = devchar;
10612 suppress_error = 0;
10613 r = guestfs_mkfs (g, fstype, device);
10618 char device[] = "/dev/sda1";
10619 device[5] = devchar;
10620 char mountpoint[] = "/";
10622 suppress_error = 0;
10623 r = guestfs_mount (g, device, mountpoint);
10627 /* TestLastFail for mkdir (1) */
10629 char path[] = "/new/foo/bar";
10631 suppress_error = 1;
10632 r = guestfs_mkdir (g, path);
10639 static int test_rm_rf_0 (void)
10641 /* InitBasicFS for rm_rf (0): create ext2 on /dev/sda1 */
10643 char device[] = "/dev/sda";
10644 device[5] = devchar;
10646 suppress_error = 0;
10647 r = guestfs_blockdev_setrw (g, device);
10653 suppress_error = 0;
10654 r = guestfs_umount_all (g);
10660 suppress_error = 0;
10661 r = guestfs_lvm_remove_all (g);
10666 char device[] = "/dev/sda";
10667 device[5] = devchar;
10668 char lines_0[] = ",";
10674 suppress_error = 0;
10675 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10680 char fstype[] = "ext2";
10681 char device[] = "/dev/sda1";
10682 device[5] = devchar;
10684 suppress_error = 0;
10685 r = guestfs_mkfs (g, fstype, device);
10690 char device[] = "/dev/sda1";
10691 device[5] = devchar;
10692 char mountpoint[] = "/";
10694 suppress_error = 0;
10695 r = guestfs_mount (g, device, mountpoint);
10699 /* TestOutputFalse for rm_rf (0) */
10701 char path[] = "/new";
10703 suppress_error = 0;
10704 r = guestfs_mkdir (g, path);
10709 char path[] = "/new/foo";
10711 suppress_error = 0;
10712 r = guestfs_mkdir (g, path);
10717 char path[] = "/new/foo/bar";
10719 suppress_error = 0;
10720 r = guestfs_touch (g, path);
10725 char path[] = "/new";
10727 suppress_error = 0;
10728 r = guestfs_rm_rf (g, path);
10733 char path[] = "/new";
10735 suppress_error = 0;
10736 r = guestfs_exists (g, path);
10740 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
10747 static int test_rmdir_0 (void)
10749 /* InitBasicFS for rmdir (0): create ext2 on /dev/sda1 */
10751 char device[] = "/dev/sda";
10752 device[5] = devchar;
10754 suppress_error = 0;
10755 r = guestfs_blockdev_setrw (g, device);
10761 suppress_error = 0;
10762 r = guestfs_umount_all (g);
10768 suppress_error = 0;
10769 r = guestfs_lvm_remove_all (g);
10774 char device[] = "/dev/sda";
10775 device[5] = devchar;
10776 char lines_0[] = ",";
10782 suppress_error = 0;
10783 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10788 char fstype[] = "ext2";
10789 char device[] = "/dev/sda1";
10790 device[5] = devchar;
10792 suppress_error = 0;
10793 r = guestfs_mkfs (g, fstype, device);
10798 char device[] = "/dev/sda1";
10799 device[5] = devchar;
10800 char mountpoint[] = "/";
10802 suppress_error = 0;
10803 r = guestfs_mount (g, device, mountpoint);
10807 /* TestRun for rmdir (0) */
10809 char path[] = "/new";
10811 suppress_error = 0;
10812 r = guestfs_mkdir (g, path);
10817 char path[] = "/new";
10819 suppress_error = 0;
10820 r = guestfs_rmdir (g, path);
10827 static int test_rmdir_1 (void)
10829 /* InitBasicFS for rmdir (1): create ext2 on /dev/sda1 */
10831 char device[] = "/dev/sda";
10832 device[5] = devchar;
10834 suppress_error = 0;
10835 r = guestfs_blockdev_setrw (g, device);
10841 suppress_error = 0;
10842 r = guestfs_umount_all (g);
10848 suppress_error = 0;
10849 r = guestfs_lvm_remove_all (g);
10854 char device[] = "/dev/sda";
10855 device[5] = devchar;
10856 char lines_0[] = ",";
10862 suppress_error = 0;
10863 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10868 char fstype[] = "ext2";
10869 char device[] = "/dev/sda1";
10870 device[5] = devchar;
10872 suppress_error = 0;
10873 r = guestfs_mkfs (g, fstype, device);
10878 char device[] = "/dev/sda1";
10879 device[5] = devchar;
10880 char mountpoint[] = "/";
10882 suppress_error = 0;
10883 r = guestfs_mount (g, device, mountpoint);
10887 /* TestLastFail for rmdir (1) */
10889 char path[] = "/new";
10891 suppress_error = 1;
10892 r = guestfs_rmdir (g, path);
10899 static int test_rmdir_2 (void)
10901 /* InitBasicFS for rmdir (2): create ext2 on /dev/sda1 */
10903 char device[] = "/dev/sda";
10904 device[5] = devchar;
10906 suppress_error = 0;
10907 r = guestfs_blockdev_setrw (g, device);
10913 suppress_error = 0;
10914 r = guestfs_umount_all (g);
10920 suppress_error = 0;
10921 r = guestfs_lvm_remove_all (g);
10926 char device[] = "/dev/sda";
10927 device[5] = devchar;
10928 char lines_0[] = ",";
10934 suppress_error = 0;
10935 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10940 char fstype[] = "ext2";
10941 char device[] = "/dev/sda1";
10942 device[5] = devchar;
10944 suppress_error = 0;
10945 r = guestfs_mkfs (g, fstype, device);
10950 char device[] = "/dev/sda1";
10951 device[5] = devchar;
10952 char mountpoint[] = "/";
10954 suppress_error = 0;
10955 r = guestfs_mount (g, device, mountpoint);
10959 /* TestLastFail for rmdir (2) */
10961 char path[] = "/new";
10963 suppress_error = 0;
10964 r = guestfs_touch (g, path);
10969 char path[] = "/new";
10971 suppress_error = 1;
10972 r = guestfs_rmdir (g, path);
10979 static int test_rm_0 (void)
10981 /* InitBasicFS for rm (0): create ext2 on /dev/sda1 */
10983 char device[] = "/dev/sda";
10984 device[5] = devchar;
10986 suppress_error = 0;
10987 r = guestfs_blockdev_setrw (g, device);
10993 suppress_error = 0;
10994 r = guestfs_umount_all (g);
11000 suppress_error = 0;
11001 r = guestfs_lvm_remove_all (g);
11006 char device[] = "/dev/sda";
11007 device[5] = devchar;
11008 char lines_0[] = ",";
11014 suppress_error = 0;
11015 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11020 char fstype[] = "ext2";
11021 char device[] = "/dev/sda1";
11022 device[5] = devchar;
11024 suppress_error = 0;
11025 r = guestfs_mkfs (g, fstype, device);
11030 char device[] = "/dev/sda1";
11031 device[5] = devchar;
11032 char mountpoint[] = "/";
11034 suppress_error = 0;
11035 r = guestfs_mount (g, device, mountpoint);
11039 /* TestRun for rm (0) */
11041 char path[] = "/new";
11043 suppress_error = 0;
11044 r = guestfs_touch (g, path);
11049 char path[] = "/new";
11051 suppress_error = 0;
11052 r = guestfs_rm (g, path);
11059 static int test_rm_1 (void)
11061 /* InitBasicFS for rm (1): create ext2 on /dev/sda1 */
11063 char device[] = "/dev/sda";
11064 device[5] = devchar;
11066 suppress_error = 0;
11067 r = guestfs_blockdev_setrw (g, device);
11073 suppress_error = 0;
11074 r = guestfs_umount_all (g);
11080 suppress_error = 0;
11081 r = guestfs_lvm_remove_all (g);
11086 char device[] = "/dev/sda";
11087 device[5] = devchar;
11088 char lines_0[] = ",";
11094 suppress_error = 0;
11095 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11100 char fstype[] = "ext2";
11101 char device[] = "/dev/sda1";
11102 device[5] = devchar;
11104 suppress_error = 0;
11105 r = guestfs_mkfs (g, fstype, device);
11110 char device[] = "/dev/sda1";
11111 device[5] = devchar;
11112 char mountpoint[] = "/";
11114 suppress_error = 0;
11115 r = guestfs_mount (g, device, mountpoint);
11119 /* TestLastFail for rm (1) */
11121 char path[] = "/new";
11123 suppress_error = 1;
11124 r = guestfs_rm (g, path);
11131 static int test_rm_2 (void)
11133 /* InitBasicFS for rm (2): create ext2 on /dev/sda1 */
11135 char device[] = "/dev/sda";
11136 device[5] = devchar;
11138 suppress_error = 0;
11139 r = guestfs_blockdev_setrw (g, device);
11145 suppress_error = 0;
11146 r = guestfs_umount_all (g);
11152 suppress_error = 0;
11153 r = guestfs_lvm_remove_all (g);
11158 char device[] = "/dev/sda";
11159 device[5] = devchar;
11160 char lines_0[] = ",";
11166 suppress_error = 0;
11167 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11172 char fstype[] = "ext2";
11173 char device[] = "/dev/sda1";
11174 device[5] = devchar;
11176 suppress_error = 0;
11177 r = guestfs_mkfs (g, fstype, device);
11182 char device[] = "/dev/sda1";
11183 device[5] = devchar;
11184 char mountpoint[] = "/";
11186 suppress_error = 0;
11187 r = guestfs_mount (g, device, mountpoint);
11191 /* TestLastFail for rm (2) */
11193 char path[] = "/new";
11195 suppress_error = 0;
11196 r = guestfs_mkdir (g, path);
11201 char path[] = "/new";
11203 suppress_error = 1;
11204 r = guestfs_rm (g, path);
11211 static int test_read_lines_0 (void)
11213 /* InitBasicFS for read_lines (0): create ext2 on /dev/sda1 */
11215 char device[] = "/dev/sda";
11216 device[5] = devchar;
11218 suppress_error = 0;
11219 r = guestfs_blockdev_setrw (g, device);
11225 suppress_error = 0;
11226 r = guestfs_umount_all (g);
11232 suppress_error = 0;
11233 r = guestfs_lvm_remove_all (g);
11238 char device[] = "/dev/sda";
11239 device[5] = devchar;
11240 char lines_0[] = ",";
11246 suppress_error = 0;
11247 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11252 char fstype[] = "ext2";
11253 char device[] = "/dev/sda1";
11254 device[5] = devchar;
11256 suppress_error = 0;
11257 r = guestfs_mkfs (g, fstype, device);
11262 char device[] = "/dev/sda1";
11263 device[5] = devchar;
11264 char mountpoint[] = "/";
11266 suppress_error = 0;
11267 r = guestfs_mount (g, device, mountpoint);
11271 /* TestOutputList for read_lines (0) */
11273 char path[] = "/new";
11274 char content[] = "line1\r\nline2\nline3";
11276 suppress_error = 0;
11277 r = guestfs_write_file (g, path, content, 0);
11282 char path[] = "/new";
11285 suppress_error = 0;
11286 r = guestfs_read_lines (g, path);
11290 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11295 char expected[] = "line1";
11296 if (strcmp (r[0], expected) != 0) {
11297 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11302 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11307 char expected[] = "line2";
11308 if (strcmp (r[1], expected) != 0) {
11309 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11314 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11319 char expected[] = "line3";
11320 if (strcmp (r[2], expected) != 0) {
11321 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11325 if (r[3] != NULL) {
11326 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11330 for (i = 0; r[i] != NULL; ++i)
11337 static int test_read_lines_1 (void)
11339 /* InitBasicFS for read_lines (1): create ext2 on /dev/sda1 */
11341 char device[] = "/dev/sda";
11342 device[5] = devchar;
11344 suppress_error = 0;
11345 r = guestfs_blockdev_setrw (g, device);
11351 suppress_error = 0;
11352 r = guestfs_umount_all (g);
11358 suppress_error = 0;
11359 r = guestfs_lvm_remove_all (g);
11364 char device[] = "/dev/sda";
11365 device[5] = devchar;
11366 char lines_0[] = ",";
11372 suppress_error = 0;
11373 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11378 char fstype[] = "ext2";
11379 char device[] = "/dev/sda1";
11380 device[5] = devchar;
11382 suppress_error = 0;
11383 r = guestfs_mkfs (g, fstype, device);
11388 char device[] = "/dev/sda1";
11389 device[5] = devchar;
11390 char mountpoint[] = "/";
11392 suppress_error = 0;
11393 r = guestfs_mount (g, device, mountpoint);
11397 /* TestOutputList for read_lines (1) */
11399 char path[] = "/new";
11400 char content[] = "";
11402 suppress_error = 0;
11403 r = guestfs_write_file (g, path, content, 0);
11408 char path[] = "/new";
11411 suppress_error = 0;
11412 r = guestfs_read_lines (g, path);
11415 if (r[0] != NULL) {
11416 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11420 for (i = 0; r[i] != NULL; ++i)
11427 static int test_lvs_0 (void)
11429 /* InitBasicFSonLVM for lvs (0): create ext2 on /dev/VG/LV */
11431 char device[] = "/dev/sda";
11432 device[5] = devchar;
11434 suppress_error = 0;
11435 r = guestfs_blockdev_setrw (g, device);
11441 suppress_error = 0;
11442 r = guestfs_umount_all (g);
11448 suppress_error = 0;
11449 r = guestfs_lvm_remove_all (g);
11454 char device[] = "/dev/sda";
11455 device[5] = devchar;
11456 char lines_0[] = ",";
11462 suppress_error = 0;
11463 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11468 char device[] = "/dev/sda1";
11469 device[5] = devchar;
11471 suppress_error = 0;
11472 r = guestfs_pvcreate (g, device);
11477 char volgroup[] = "VG";
11478 char physvols_0[] = "/dev/sda1";
11479 physvols_0[5] = devchar;
11480 char *physvols[] = {
11485 suppress_error = 0;
11486 r = guestfs_vgcreate (g, volgroup, physvols);
11491 char logvol[] = "LV";
11492 char volgroup[] = "VG";
11494 suppress_error = 0;
11495 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11500 char fstype[] = "ext2";
11501 char device[] = "/dev/VG/LV";
11503 suppress_error = 0;
11504 r = guestfs_mkfs (g, fstype, device);
11509 char device[] = "/dev/VG/LV";
11510 char mountpoint[] = "/";
11512 suppress_error = 0;
11513 r = guestfs_mount (g, device, mountpoint);
11517 /* TestOutputList for lvs (0) */
11521 suppress_error = 0;
11522 r = guestfs_lvs (g);
11526 fprintf (stderr, "test_lvs_0: short list returned from command\n");
11531 char expected[] = "/dev/VG/LV";
11532 if (strcmp (r[0], expected) != 0) {
11533 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11537 if (r[1] != NULL) {
11538 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
11542 for (i = 0; r[i] != NULL; ++i)
11549 static int test_lvs_1 (void)
11551 /* InitEmpty for lvs (1) */
11553 char device[] = "/dev/sda";
11554 device[5] = devchar;
11556 suppress_error = 0;
11557 r = guestfs_blockdev_setrw (g, device);
11563 suppress_error = 0;
11564 r = guestfs_umount_all (g);
11570 suppress_error = 0;
11571 r = guestfs_lvm_remove_all (g);
11575 /* TestOutputList for lvs (1) */
11577 char device[] = "/dev/sda";
11578 device[5] = devchar;
11579 char lines_0[] = ",10";
11580 char lines_1[] = ",20";
11581 char lines_2[] = ",";
11589 suppress_error = 0;
11590 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11595 char device[] = "/dev/sda1";
11596 device[5] = devchar;
11598 suppress_error = 0;
11599 r = guestfs_pvcreate (g, device);
11604 char device[] = "/dev/sda2";
11605 device[5] = devchar;
11607 suppress_error = 0;
11608 r = guestfs_pvcreate (g, device);
11613 char device[] = "/dev/sda3";
11614 device[5] = devchar;
11616 suppress_error = 0;
11617 r = guestfs_pvcreate (g, device);
11622 char volgroup[] = "VG1";
11623 char physvols_0[] = "/dev/sda1";
11624 physvols_0[5] = devchar;
11625 char physvols_1[] = "/dev/sda2";
11626 physvols_1[5] = devchar;
11627 char *physvols[] = {
11633 suppress_error = 0;
11634 r = guestfs_vgcreate (g, volgroup, physvols);
11639 char volgroup[] = "VG2";
11640 char physvols_0[] = "/dev/sda3";
11641 physvols_0[5] = devchar;
11642 char *physvols[] = {
11647 suppress_error = 0;
11648 r = guestfs_vgcreate (g, volgroup, physvols);
11653 char logvol[] = "LV1";
11654 char volgroup[] = "VG1";
11656 suppress_error = 0;
11657 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11662 char logvol[] = "LV2";
11663 char volgroup[] = "VG1";
11665 suppress_error = 0;
11666 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11671 char logvol[] = "LV3";
11672 char volgroup[] = "VG2";
11674 suppress_error = 0;
11675 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11682 suppress_error = 0;
11683 r = guestfs_lvs (g);
11687 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11692 char expected[] = "/dev/VG1/LV1";
11693 if (strcmp (r[0], expected) != 0) {
11694 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11699 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11704 char expected[] = "/dev/VG1/LV2";
11705 if (strcmp (r[1], expected) != 0) {
11706 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11711 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11716 char expected[] = "/dev/VG2/LV3";
11717 if (strcmp (r[2], expected) != 0) {
11718 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11722 if (r[3] != NULL) {
11723 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
11727 for (i = 0; r[i] != NULL; ++i)
11734 static int test_vgs_0 (void)
11736 /* InitBasicFSonLVM for vgs (0): create ext2 on /dev/VG/LV */
11738 char device[] = "/dev/sda";
11739 device[5] = devchar;
11741 suppress_error = 0;
11742 r = guestfs_blockdev_setrw (g, device);
11748 suppress_error = 0;
11749 r = guestfs_umount_all (g);
11755 suppress_error = 0;
11756 r = guestfs_lvm_remove_all (g);
11761 char device[] = "/dev/sda";
11762 device[5] = devchar;
11763 char lines_0[] = ",";
11769 suppress_error = 0;
11770 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11775 char device[] = "/dev/sda1";
11776 device[5] = devchar;
11778 suppress_error = 0;
11779 r = guestfs_pvcreate (g, device);
11784 char volgroup[] = "VG";
11785 char physvols_0[] = "/dev/sda1";
11786 physvols_0[5] = devchar;
11787 char *physvols[] = {
11792 suppress_error = 0;
11793 r = guestfs_vgcreate (g, volgroup, physvols);
11798 char logvol[] = "LV";
11799 char volgroup[] = "VG";
11801 suppress_error = 0;
11802 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11807 char fstype[] = "ext2";
11808 char device[] = "/dev/VG/LV";
11810 suppress_error = 0;
11811 r = guestfs_mkfs (g, fstype, device);
11816 char device[] = "/dev/VG/LV";
11817 char mountpoint[] = "/";
11819 suppress_error = 0;
11820 r = guestfs_mount (g, device, mountpoint);
11824 /* TestOutputList for vgs (0) */
11828 suppress_error = 0;
11829 r = guestfs_vgs (g);
11833 fprintf (stderr, "test_vgs_0: short list returned from command\n");
11838 char expected[] = "VG";
11839 if (strcmp (r[0], expected) != 0) {
11840 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11844 if (r[1] != NULL) {
11845 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
11849 for (i = 0; r[i] != NULL; ++i)
11856 static int test_vgs_1 (void)
11858 /* InitEmpty for vgs (1) */
11860 char device[] = "/dev/sda";
11861 device[5] = devchar;
11863 suppress_error = 0;
11864 r = guestfs_blockdev_setrw (g, device);
11870 suppress_error = 0;
11871 r = guestfs_umount_all (g);
11877 suppress_error = 0;
11878 r = guestfs_lvm_remove_all (g);
11882 /* TestOutputList for vgs (1) */
11884 char device[] = "/dev/sda";
11885 device[5] = devchar;
11886 char lines_0[] = ",10";
11887 char lines_1[] = ",20";
11888 char lines_2[] = ",";
11896 suppress_error = 0;
11897 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11902 char device[] = "/dev/sda1";
11903 device[5] = devchar;
11905 suppress_error = 0;
11906 r = guestfs_pvcreate (g, device);
11911 char device[] = "/dev/sda2";
11912 device[5] = devchar;
11914 suppress_error = 0;
11915 r = guestfs_pvcreate (g, device);
11920 char device[] = "/dev/sda3";
11921 device[5] = devchar;
11923 suppress_error = 0;
11924 r = guestfs_pvcreate (g, device);
11929 char volgroup[] = "VG1";
11930 char physvols_0[] = "/dev/sda1";
11931 physvols_0[5] = devchar;
11932 char physvols_1[] = "/dev/sda2";
11933 physvols_1[5] = devchar;
11934 char *physvols[] = {
11940 suppress_error = 0;
11941 r = guestfs_vgcreate (g, volgroup, physvols);
11946 char volgroup[] = "VG2";
11947 char physvols_0[] = "/dev/sda3";
11948 physvols_0[5] = devchar;
11949 char *physvols[] = {
11954 suppress_error = 0;
11955 r = guestfs_vgcreate (g, volgroup, physvols);
11962 suppress_error = 0;
11963 r = guestfs_vgs (g);
11967 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11972 char expected[] = "VG1";
11973 if (strcmp (r[0], expected) != 0) {
11974 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11979 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11984 char expected[] = "VG2";
11985 if (strcmp (r[1], expected) != 0) {
11986 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11990 if (r[2] != NULL) {
11991 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
11995 for (i = 0; r[i] != NULL; ++i)
12002 static int test_pvs_0 (void)
12004 /* InitBasicFSonLVM for pvs (0): create ext2 on /dev/VG/LV */
12006 char device[] = "/dev/sda";
12007 device[5] = devchar;
12009 suppress_error = 0;
12010 r = guestfs_blockdev_setrw (g, device);
12016 suppress_error = 0;
12017 r = guestfs_umount_all (g);
12023 suppress_error = 0;
12024 r = guestfs_lvm_remove_all (g);
12029 char device[] = "/dev/sda";
12030 device[5] = devchar;
12031 char lines_0[] = ",";
12037 suppress_error = 0;
12038 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12043 char device[] = "/dev/sda1";
12044 device[5] = devchar;
12046 suppress_error = 0;
12047 r = guestfs_pvcreate (g, device);
12052 char volgroup[] = "VG";
12053 char physvols_0[] = "/dev/sda1";
12054 physvols_0[5] = devchar;
12055 char *physvols[] = {
12060 suppress_error = 0;
12061 r = guestfs_vgcreate (g, volgroup, physvols);
12066 char logvol[] = "LV";
12067 char volgroup[] = "VG";
12069 suppress_error = 0;
12070 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12075 char fstype[] = "ext2";
12076 char device[] = "/dev/VG/LV";
12078 suppress_error = 0;
12079 r = guestfs_mkfs (g, fstype, device);
12084 char device[] = "/dev/VG/LV";
12085 char mountpoint[] = "/";
12087 suppress_error = 0;
12088 r = guestfs_mount (g, device, mountpoint);
12092 /* TestOutputList for pvs (0) */
12096 suppress_error = 0;
12097 r = guestfs_pvs (g);
12101 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12106 char expected[] = "/dev/sda1";
12107 expected[5] = devchar;
12108 if (strcmp (r[0], expected) != 0) {
12109 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12113 if (r[1] != NULL) {
12114 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12118 for (i = 0; r[i] != NULL; ++i)
12125 static int test_pvs_1 (void)
12127 /* InitEmpty for pvs (1) */
12129 char device[] = "/dev/sda";
12130 device[5] = devchar;
12132 suppress_error = 0;
12133 r = guestfs_blockdev_setrw (g, device);
12139 suppress_error = 0;
12140 r = guestfs_umount_all (g);
12146 suppress_error = 0;
12147 r = guestfs_lvm_remove_all (g);
12151 /* TestOutputList for pvs (1) */
12153 char device[] = "/dev/sda";
12154 device[5] = devchar;
12155 char lines_0[] = ",10";
12156 char lines_1[] = ",20";
12157 char lines_2[] = ",";
12165 suppress_error = 0;
12166 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12171 char device[] = "/dev/sda1";
12172 device[5] = devchar;
12174 suppress_error = 0;
12175 r = guestfs_pvcreate (g, device);
12180 char device[] = "/dev/sda2";
12181 device[5] = devchar;
12183 suppress_error = 0;
12184 r = guestfs_pvcreate (g, device);
12189 char device[] = "/dev/sda3";
12190 device[5] = devchar;
12192 suppress_error = 0;
12193 r = guestfs_pvcreate (g, device);
12200 suppress_error = 0;
12201 r = guestfs_pvs (g);
12205 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12210 char expected[] = "/dev/sda1";
12211 expected[5] = devchar;
12212 if (strcmp (r[0], expected) != 0) {
12213 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12218 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12223 char expected[] = "/dev/sda2";
12224 expected[5] = devchar;
12225 if (strcmp (r[1], expected) != 0) {
12226 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12231 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12236 char expected[] = "/dev/sda3";
12237 expected[5] = devchar;
12238 if (strcmp (r[2], expected) != 0) {
12239 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12243 if (r[3] != NULL) {
12244 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12248 for (i = 0; r[i] != NULL; ++i)
12255 static int test_list_partitions_0 (void)
12257 /* InitBasicFS for list_partitions (0): create ext2 on /dev/sda1 */
12259 char device[] = "/dev/sda";
12260 device[5] = devchar;
12262 suppress_error = 0;
12263 r = guestfs_blockdev_setrw (g, device);
12269 suppress_error = 0;
12270 r = guestfs_umount_all (g);
12276 suppress_error = 0;
12277 r = guestfs_lvm_remove_all (g);
12282 char device[] = "/dev/sda";
12283 device[5] = devchar;
12284 char lines_0[] = ",";
12290 suppress_error = 0;
12291 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12296 char fstype[] = "ext2";
12297 char device[] = "/dev/sda1";
12298 device[5] = devchar;
12300 suppress_error = 0;
12301 r = guestfs_mkfs (g, fstype, device);
12306 char device[] = "/dev/sda1";
12307 device[5] = devchar;
12308 char mountpoint[] = "/";
12310 suppress_error = 0;
12311 r = guestfs_mount (g, device, mountpoint);
12315 /* TestOutputList for list_partitions (0) */
12319 suppress_error = 0;
12320 r = guestfs_list_partitions (g);
12324 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12329 char expected[] = "/dev/sda1";
12330 expected[5] = devchar;
12331 if (strcmp (r[0], expected) != 0) {
12332 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12336 if (r[1] != NULL) {
12337 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12341 for (i = 0; r[i] != NULL; ++i)
12348 static int test_list_partitions_1 (void)
12350 /* InitEmpty for list_partitions (1) */
12352 char device[] = "/dev/sda";
12353 device[5] = devchar;
12355 suppress_error = 0;
12356 r = guestfs_blockdev_setrw (g, device);
12362 suppress_error = 0;
12363 r = guestfs_umount_all (g);
12369 suppress_error = 0;
12370 r = guestfs_lvm_remove_all (g);
12374 /* TestOutputList for list_partitions (1) */
12376 char device[] = "/dev/sda";
12377 device[5] = devchar;
12378 char lines_0[] = ",10";
12379 char lines_1[] = ",20";
12380 char lines_2[] = ",";
12388 suppress_error = 0;
12389 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12396 suppress_error = 0;
12397 r = guestfs_list_partitions (g);
12401 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12406 char expected[] = "/dev/sda1";
12407 expected[5] = devchar;
12408 if (strcmp (r[0], expected) != 0) {
12409 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12414 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12419 char expected[] = "/dev/sda2";
12420 expected[5] = devchar;
12421 if (strcmp (r[1], expected) != 0) {
12422 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12427 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12432 char expected[] = "/dev/sda3";
12433 expected[5] = devchar;
12434 if (strcmp (r[2], expected) != 0) {
12435 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12439 if (r[3] != NULL) {
12440 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12444 for (i = 0; r[i] != NULL; ++i)
12451 static int test_list_devices_0 (void)
12453 /* InitEmpty for list_devices (0) */
12455 char device[] = "/dev/sda";
12456 device[5] = devchar;
12458 suppress_error = 0;
12459 r = guestfs_blockdev_setrw (g, device);
12465 suppress_error = 0;
12466 r = guestfs_umount_all (g);
12472 suppress_error = 0;
12473 r = guestfs_lvm_remove_all (g);
12477 /* TestOutputList for list_devices (0) */
12481 suppress_error = 0;
12482 r = guestfs_list_devices (g);
12486 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12491 char expected[] = "/dev/sda";
12492 expected[5] = devchar;
12493 if (strcmp (r[0], expected) != 0) {
12494 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12499 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12504 char expected[] = "/dev/sdb";
12505 expected[5] = devchar;
12506 if (strcmp (r[1], expected) != 0) {
12507 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12512 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12517 char expected[] = "/dev/sdc";
12518 expected[5] = devchar;
12519 if (strcmp (r[2], expected) != 0) {
12520 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12524 if (r[3] != NULL) {
12525 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
12529 for (i = 0; r[i] != NULL; ++i)
12536 static int test_ls_0 (void)
12538 /* InitBasicFS for ls (0): create ext2 on /dev/sda1 */
12540 char device[] = "/dev/sda";
12541 device[5] = devchar;
12543 suppress_error = 0;
12544 r = guestfs_blockdev_setrw (g, device);
12550 suppress_error = 0;
12551 r = guestfs_umount_all (g);
12557 suppress_error = 0;
12558 r = guestfs_lvm_remove_all (g);
12563 char device[] = "/dev/sda";
12564 device[5] = devchar;
12565 char lines_0[] = ",";
12571 suppress_error = 0;
12572 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12577 char fstype[] = "ext2";
12578 char device[] = "/dev/sda1";
12579 device[5] = devchar;
12581 suppress_error = 0;
12582 r = guestfs_mkfs (g, fstype, device);
12587 char device[] = "/dev/sda1";
12588 device[5] = devchar;
12589 char mountpoint[] = "/";
12591 suppress_error = 0;
12592 r = guestfs_mount (g, device, mountpoint);
12596 /* TestOutputList for ls (0) */
12598 char path[] = "/new";
12600 suppress_error = 0;
12601 r = guestfs_touch (g, path);
12606 char path[] = "/newer";
12608 suppress_error = 0;
12609 r = guestfs_touch (g, path);
12614 char path[] = "/newest";
12616 suppress_error = 0;
12617 r = guestfs_touch (g, path);
12622 char directory[] = "/";
12625 suppress_error = 0;
12626 r = guestfs_ls (g, directory);
12630 fprintf (stderr, "test_ls_0: short list returned from command\n");
12635 char expected[] = "lost+found";
12636 if (strcmp (r[0], expected) != 0) {
12637 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12642 fprintf (stderr, "test_ls_0: short list returned from command\n");
12647 char expected[] = "new";
12648 if (strcmp (r[1], expected) != 0) {
12649 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12654 fprintf (stderr, "test_ls_0: short list returned from command\n");
12659 char expected[] = "newer";
12660 if (strcmp (r[2], expected) != 0) {
12661 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12666 fprintf (stderr, "test_ls_0: short list returned from command\n");
12671 char expected[] = "newest";
12672 if (strcmp (r[3], expected) != 0) {
12673 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12677 if (r[4] != NULL) {
12678 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
12682 for (i = 0; r[i] != NULL; ++i)
12689 static int test_cat_0 (void)
12691 /* InitBasicFS for cat (0): create ext2 on /dev/sda1 */
12693 char device[] = "/dev/sda";
12694 device[5] = devchar;
12696 suppress_error = 0;
12697 r = guestfs_blockdev_setrw (g, device);
12703 suppress_error = 0;
12704 r = guestfs_umount_all (g);
12710 suppress_error = 0;
12711 r = guestfs_lvm_remove_all (g);
12716 char device[] = "/dev/sda";
12717 device[5] = devchar;
12718 char lines_0[] = ",";
12724 suppress_error = 0;
12725 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12730 char fstype[] = "ext2";
12731 char device[] = "/dev/sda1";
12732 device[5] = devchar;
12734 suppress_error = 0;
12735 r = guestfs_mkfs (g, fstype, device);
12740 char device[] = "/dev/sda1";
12741 device[5] = devchar;
12742 char mountpoint[] = "/";
12744 suppress_error = 0;
12745 r = guestfs_mount (g, device, mountpoint);
12749 /* TestOutput for cat (0) */
12750 char expected[] = "new file contents";
12752 char path[] = "/new";
12753 char content[] = "new file contents";
12755 suppress_error = 0;
12756 r = guestfs_write_file (g, path, content, 0);
12761 char path[] = "/new";
12763 suppress_error = 0;
12764 r = guestfs_cat (g, path);
12767 if (strcmp (r, expected) != 0) {
12768 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
12776 static int test_touch_0 (void)
12778 /* InitBasicFS for touch (0): create ext2 on /dev/sda1 */
12780 char device[] = "/dev/sda";
12781 device[5] = devchar;
12783 suppress_error = 0;
12784 r = guestfs_blockdev_setrw (g, device);
12790 suppress_error = 0;
12791 r = guestfs_umount_all (g);
12797 suppress_error = 0;
12798 r = guestfs_lvm_remove_all (g);
12803 char device[] = "/dev/sda";
12804 device[5] = devchar;
12805 char lines_0[] = ",";
12811 suppress_error = 0;
12812 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12817 char fstype[] = "ext2";
12818 char device[] = "/dev/sda1";
12819 device[5] = devchar;
12821 suppress_error = 0;
12822 r = guestfs_mkfs (g, fstype, device);
12827 char device[] = "/dev/sda1";
12828 device[5] = devchar;
12829 char mountpoint[] = "/";
12831 suppress_error = 0;
12832 r = guestfs_mount (g, device, mountpoint);
12836 /* TestOutputTrue for touch (0) */
12838 char path[] = "/new";
12840 suppress_error = 0;
12841 r = guestfs_touch (g, path);
12846 char path[] = "/new";
12848 suppress_error = 0;
12849 r = guestfs_exists (g, path);
12853 fprintf (stderr, "test_touch_0: expected true, got false\n");
12860 static int test_sync_0 (void)
12862 /* InitEmpty for sync (0) */
12864 char device[] = "/dev/sda";
12865 device[5] = devchar;
12867 suppress_error = 0;
12868 r = guestfs_blockdev_setrw (g, device);
12874 suppress_error = 0;
12875 r = guestfs_umount_all (g);
12881 suppress_error = 0;
12882 r = guestfs_lvm_remove_all (g);
12886 /* TestRun for sync (0) */
12889 suppress_error = 0;
12890 r = guestfs_sync (g);
12897 static int test_mount_0 (void)
12899 /* InitEmpty for mount (0) */
12901 char device[] = "/dev/sda";
12902 device[5] = devchar;
12904 suppress_error = 0;
12905 r = guestfs_blockdev_setrw (g, device);
12911 suppress_error = 0;
12912 r = guestfs_umount_all (g);
12918 suppress_error = 0;
12919 r = guestfs_lvm_remove_all (g);
12923 /* TestOutput for mount (0) */
12924 char expected[] = "new file contents";
12926 char device[] = "/dev/sda";
12927 device[5] = devchar;
12928 char lines_0[] = ",";
12934 suppress_error = 0;
12935 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12940 char fstype[] = "ext2";
12941 char device[] = "/dev/sda1";
12942 device[5] = devchar;
12944 suppress_error = 0;
12945 r = guestfs_mkfs (g, fstype, device);
12950 char device[] = "/dev/sda1";
12951 device[5] = devchar;
12952 char mountpoint[] = "/";
12954 suppress_error = 0;
12955 r = guestfs_mount (g, device, mountpoint);
12960 char path[] = "/new";
12961 char content[] = "new file contents";
12963 suppress_error = 0;
12964 r = guestfs_write_file (g, path, content, 0);
12969 char path[] = "/new";
12971 suppress_error = 0;
12972 r = guestfs_cat (g, path);
12975 if (strcmp (r, expected) != 0) {
12976 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
12984 int main (int argc, char *argv[])
12988 const char *srcdir;
12989 const char *filename;
12991 int nr_tests, test_num = 0;
12994 no_test_warnings ();
12996 g = guestfs_create ();
12998 printf ("guestfs_create FAILED\n");
13002 guestfs_set_error_handler (g, print_error, NULL);
13004 srcdir = getenv ("srcdir");
13005 if (!srcdir) srcdir = ".";
13007 guestfs_set_path (g, ".");
13009 filename = "test1.img";
13010 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13015 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13021 if (write (fd, &c, 1) == -1) {
13027 if (close (fd) == -1) {
13032 if (guestfs_add_drive (g, filename) == -1) {
13033 printf ("guestfs_add_drive %s FAILED\n", filename);
13037 filename = "test2.img";
13038 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13043 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13049 if (write (fd, &c, 1) == -1) {
13055 if (close (fd) == -1) {
13060 if (guestfs_add_drive (g, filename) == -1) {
13061 printf ("guestfs_add_drive %s FAILED\n", filename);
13065 filename = "test3.img";
13066 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13071 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13077 if (write (fd, &c, 1) == -1) {
13083 if (close (fd) == -1) {
13088 if (guestfs_add_drive (g, filename) == -1) {
13089 printf ("guestfs_add_drive %s FAILED\n", filename);
13093 if (guestfs_launch (g) == -1) {
13094 printf ("guestfs_launch FAILED\n");
13097 if (guestfs_wait_ready (g) == -1) {
13098 printf ("guestfs_wait_ready FAILED\n");
13102 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13103 * names. This changed between RHEL 5 and RHEL 6 so we have to
13106 devs = guestfs_list_devices (g);
13107 if (devs == NULL || devs[0] == NULL) {
13108 printf ("guestfs_list_devices FAILED\n");
13111 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13113 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13116 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13120 for (i = 0; devs[i] != NULL; ++i)
13127 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13128 if (test_zerofree_0 () == -1) {
13129 printf ("test_zerofree_0 FAILED\n");
13133 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13134 if (test_hexdump_0 () == -1) {
13135 printf ("test_hexdump_0 FAILED\n");
13139 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13140 if (test_strings_e_0 () == -1) {
13141 printf ("test_strings_e_0 FAILED\n");
13145 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13146 if (test_strings_e_1 () == -1) {
13147 printf ("test_strings_e_1 FAILED\n");
13151 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13152 if (test_strings_0 () == -1) {
13153 printf ("test_strings_0 FAILED\n");
13157 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13158 if (test_strings_1 () == -1) {
13159 printf ("test_strings_1 FAILED\n");
13163 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13164 if (test_equal_0 () == -1) {
13165 printf ("test_equal_0 FAILED\n");
13169 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13170 if (test_equal_1 () == -1) {
13171 printf ("test_equal_1 FAILED\n");
13175 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13176 if (test_equal_2 () == -1) {
13177 printf ("test_equal_2 FAILED\n");
13181 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13182 if (test_ping_daemon_0 () == -1) {
13183 printf ("test_ping_daemon_0 FAILED\n");
13187 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13188 if (test_dmesg_0 () == -1) {
13189 printf ("test_dmesg_0 FAILED\n");
13193 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13194 if (test_drop_caches_0 () == -1) {
13195 printf ("test_drop_caches_0 FAILED\n");
13199 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13200 if (test_mv_0 () == -1) {
13201 printf ("test_mv_0 FAILED\n");
13205 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13206 if (test_mv_1 () == -1) {
13207 printf ("test_mv_1 FAILED\n");
13211 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13212 if (test_cp_a_0 () == -1) {
13213 printf ("test_cp_a_0 FAILED\n");
13217 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13218 if (test_cp_0 () == -1) {
13219 printf ("test_cp_0 FAILED\n");
13223 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13224 if (test_cp_1 () == -1) {
13225 printf ("test_cp_1 FAILED\n");
13229 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13230 if (test_cp_2 () == -1) {
13231 printf ("test_cp_2 FAILED\n");
13235 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13236 if (test_grub_install_0 () == -1) {
13237 printf ("test_grub_install_0 FAILED\n");
13241 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13242 if (test_zero_0 () == -1) {
13243 printf ("test_zero_0 FAILED\n");
13247 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13248 if (test_fsck_0 () == -1) {
13249 printf ("test_fsck_0 FAILED\n");
13253 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13254 if (test_fsck_1 () == -1) {
13255 printf ("test_fsck_1 FAILED\n");
13259 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13260 if (test_set_e2uuid_0 () == -1) {
13261 printf ("test_set_e2uuid_0 FAILED\n");
13265 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13266 if (test_set_e2uuid_1 () == -1) {
13267 printf ("test_set_e2uuid_1 FAILED\n");
13271 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13272 if (test_set_e2uuid_2 () == -1) {
13273 printf ("test_set_e2uuid_2 FAILED\n");
13277 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13278 if (test_set_e2uuid_3 () == -1) {
13279 printf ("test_set_e2uuid_3 FAILED\n");
13283 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13284 if (test_set_e2label_0 () == -1) {
13285 printf ("test_set_e2label_0 FAILED\n");
13289 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13290 if (test_pvremove_0 () == -1) {
13291 printf ("test_pvremove_0 FAILED\n");
13295 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13296 if (test_pvremove_1 () == -1) {
13297 printf ("test_pvremove_1 FAILED\n");
13301 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13302 if (test_pvremove_2 () == -1) {
13303 printf ("test_pvremove_2 FAILED\n");
13307 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13308 if (test_vgremove_0 () == -1) {
13309 printf ("test_vgremove_0 FAILED\n");
13313 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13314 if (test_vgremove_1 () == -1) {
13315 printf ("test_vgremove_1 FAILED\n");
13319 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13320 if (test_lvremove_0 () == -1) {
13321 printf ("test_lvremove_0 FAILED\n");
13325 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13326 if (test_lvremove_1 () == -1) {
13327 printf ("test_lvremove_1 FAILED\n");
13331 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13332 if (test_lvremove_2 () == -1) {
13333 printf ("test_lvremove_2 FAILED\n");
13337 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13338 if (test_mount_ro_0 () == -1) {
13339 printf ("test_mount_ro_0 FAILED\n");
13343 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13344 if (test_mount_ro_1 () == -1) {
13345 printf ("test_mount_ro_1 FAILED\n");
13349 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13350 if (test_tgz_in_0 () == -1) {
13351 printf ("test_tgz_in_0 FAILED\n");
13355 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13356 if (test_tar_in_0 () == -1) {
13357 printf ("test_tar_in_0 FAILED\n");
13361 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13362 if (test_checksum_0 () == -1) {
13363 printf ("test_checksum_0 FAILED\n");
13367 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13368 if (test_checksum_1 () == -1) {
13369 printf ("test_checksum_1 FAILED\n");
13373 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13374 if (test_checksum_2 () == -1) {
13375 printf ("test_checksum_2 FAILED\n");
13379 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13380 if (test_checksum_3 () == -1) {
13381 printf ("test_checksum_3 FAILED\n");
13385 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13386 if (test_checksum_4 () == -1) {
13387 printf ("test_checksum_4 FAILED\n");
13391 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13392 if (test_checksum_5 () == -1) {
13393 printf ("test_checksum_5 FAILED\n");
13397 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13398 if (test_checksum_6 () == -1) {
13399 printf ("test_checksum_6 FAILED\n");
13403 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13404 if (test_checksum_7 () == -1) {
13405 printf ("test_checksum_7 FAILED\n");
13409 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13410 if (test_download_0 () == -1) {
13411 printf ("test_download_0 FAILED\n");
13415 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13416 if (test_upload_0 () == -1) {
13417 printf ("test_upload_0 FAILED\n");
13421 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13422 if (test_blockdev_rereadpt_0 () == -1) {
13423 printf ("test_blockdev_rereadpt_0 FAILED\n");
13427 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13428 if (test_blockdev_flushbufs_0 () == -1) {
13429 printf ("test_blockdev_flushbufs_0 FAILED\n");
13433 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
13434 if (test_blockdev_getsize64_0 () == -1) {
13435 printf ("test_blockdev_getsize64_0 FAILED\n");
13439 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
13440 if (test_blockdev_getsz_0 () == -1) {
13441 printf ("test_blockdev_getsz_0 FAILED\n");
13445 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
13446 if (test_blockdev_getbsz_0 () == -1) {
13447 printf ("test_blockdev_getbsz_0 FAILED\n");
13451 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
13452 if (test_blockdev_getss_0 () == -1) {
13453 printf ("test_blockdev_getss_0 FAILED\n");
13457 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
13458 if (test_blockdev_getro_0 () == -1) {
13459 printf ("test_blockdev_getro_0 FAILED\n");
13463 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
13464 if (test_blockdev_setrw_0 () == -1) {
13465 printf ("test_blockdev_setrw_0 FAILED\n");
13469 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
13470 if (test_blockdev_setro_0 () == -1) {
13471 printf ("test_blockdev_setro_0 FAILED\n");
13475 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
13476 if (test_statvfs_0 () == -1) {
13477 printf ("test_statvfs_0 FAILED\n");
13481 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
13482 if (test_lstat_0 () == -1) {
13483 printf ("test_lstat_0 FAILED\n");
13487 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
13488 if (test_stat_0 () == -1) {
13489 printf ("test_stat_0 FAILED\n");
13493 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
13494 if (test_command_lines_0 () == -1) {
13495 printf ("test_command_lines_0 FAILED\n");
13499 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
13500 if (test_command_lines_1 () == -1) {
13501 printf ("test_command_lines_1 FAILED\n");
13505 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
13506 if (test_command_lines_2 () == -1) {
13507 printf ("test_command_lines_2 FAILED\n");
13511 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
13512 if (test_command_lines_3 () == -1) {
13513 printf ("test_command_lines_3 FAILED\n");
13517 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
13518 if (test_command_lines_4 () == -1) {
13519 printf ("test_command_lines_4 FAILED\n");
13523 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
13524 if (test_command_lines_5 () == -1) {
13525 printf ("test_command_lines_5 FAILED\n");
13529 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
13530 if (test_command_lines_6 () == -1) {
13531 printf ("test_command_lines_6 FAILED\n");
13535 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
13536 if (test_command_lines_7 () == -1) {
13537 printf ("test_command_lines_7 FAILED\n");
13541 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
13542 if (test_command_lines_8 () == -1) {
13543 printf ("test_command_lines_8 FAILED\n");
13547 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
13548 if (test_command_lines_9 () == -1) {
13549 printf ("test_command_lines_9 FAILED\n");
13553 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
13554 if (test_command_lines_10 () == -1) {
13555 printf ("test_command_lines_10 FAILED\n");
13559 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
13560 if (test_command_0 () == -1) {
13561 printf ("test_command_0 FAILED\n");
13565 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
13566 if (test_command_1 () == -1) {
13567 printf ("test_command_1 FAILED\n");
13571 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
13572 if (test_command_2 () == -1) {
13573 printf ("test_command_2 FAILED\n");
13577 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
13578 if (test_command_3 () == -1) {
13579 printf ("test_command_3 FAILED\n");
13583 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
13584 if (test_command_4 () == -1) {
13585 printf ("test_command_4 FAILED\n");
13589 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
13590 if (test_command_5 () == -1) {
13591 printf ("test_command_5 FAILED\n");
13595 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
13596 if (test_command_6 () == -1) {
13597 printf ("test_command_6 FAILED\n");
13601 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
13602 if (test_command_7 () == -1) {
13603 printf ("test_command_7 FAILED\n");
13607 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
13608 if (test_command_8 () == -1) {
13609 printf ("test_command_8 FAILED\n");
13613 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
13614 if (test_command_9 () == -1) {
13615 printf ("test_command_9 FAILED\n");
13619 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
13620 if (test_command_10 () == -1) {
13621 printf ("test_command_10 FAILED\n");
13625 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
13626 if (test_command_11 () == -1) {
13627 printf ("test_command_11 FAILED\n");
13631 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
13632 if (test_file_0 () == -1) {
13633 printf ("test_file_0 FAILED\n");
13637 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
13638 if (test_file_1 () == -1) {
13639 printf ("test_file_1 FAILED\n");
13643 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
13644 if (test_file_2 () == -1) {
13645 printf ("test_file_2 FAILED\n");
13649 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
13650 if (test_umount_all_0 () == -1) {
13651 printf ("test_umount_all_0 FAILED\n");
13655 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
13656 if (test_umount_all_1 () == -1) {
13657 printf ("test_umount_all_1 FAILED\n");
13661 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
13662 if (test_mounts_0 () == -1) {
13663 printf ("test_mounts_0 FAILED\n");
13667 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
13668 if (test_umount_0 () == -1) {
13669 printf ("test_umount_0 FAILED\n");
13673 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
13674 if (test_umount_1 () == -1) {
13675 printf ("test_umount_1 FAILED\n");
13679 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
13680 if (test_write_file_0 () == -1) {
13681 printf ("test_write_file_0 FAILED\n");
13685 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
13686 if (test_write_file_1 () == -1) {
13687 printf ("test_write_file_1 FAILED\n");
13691 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
13692 if (test_write_file_2 () == -1) {
13693 printf ("test_write_file_2 FAILED\n");
13697 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
13698 if (test_write_file_3 () == -1) {
13699 printf ("test_write_file_3 FAILED\n");
13703 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
13704 if (test_write_file_4 () == -1) {
13705 printf ("test_write_file_4 FAILED\n");
13709 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
13710 if (test_write_file_5 () == -1) {
13711 printf ("test_write_file_5 FAILED\n");
13715 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
13716 if (test_mkfs_0 () == -1) {
13717 printf ("test_mkfs_0 FAILED\n");
13721 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
13722 if (test_lvcreate_0 () == -1) {
13723 printf ("test_lvcreate_0 FAILED\n");
13727 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
13728 if (test_vgcreate_0 () == -1) {
13729 printf ("test_vgcreate_0 FAILED\n");
13733 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
13734 if (test_pvcreate_0 () == -1) {
13735 printf ("test_pvcreate_0 FAILED\n");
13739 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
13740 if (test_is_dir_0 () == -1) {
13741 printf ("test_is_dir_0 FAILED\n");
13745 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
13746 if (test_is_dir_1 () == -1) {
13747 printf ("test_is_dir_1 FAILED\n");
13751 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
13752 if (test_is_file_0 () == -1) {
13753 printf ("test_is_file_0 FAILED\n");
13757 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
13758 if (test_is_file_1 () == -1) {
13759 printf ("test_is_file_1 FAILED\n");
13763 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
13764 if (test_exists_0 () == -1) {
13765 printf ("test_exists_0 FAILED\n");
13769 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
13770 if (test_exists_1 () == -1) {
13771 printf ("test_exists_1 FAILED\n");
13775 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
13776 if (test_mkdir_p_0 () == -1) {
13777 printf ("test_mkdir_p_0 FAILED\n");
13781 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
13782 if (test_mkdir_p_1 () == -1) {
13783 printf ("test_mkdir_p_1 FAILED\n");
13787 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
13788 if (test_mkdir_p_2 () == -1) {
13789 printf ("test_mkdir_p_2 FAILED\n");
13793 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
13794 if (test_mkdir_0 () == -1) {
13795 printf ("test_mkdir_0 FAILED\n");
13799 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
13800 if (test_mkdir_1 () == -1) {
13801 printf ("test_mkdir_1 FAILED\n");
13805 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
13806 if (test_rm_rf_0 () == -1) {
13807 printf ("test_rm_rf_0 FAILED\n");
13811 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
13812 if (test_rmdir_0 () == -1) {
13813 printf ("test_rmdir_0 FAILED\n");
13817 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
13818 if (test_rmdir_1 () == -1) {
13819 printf ("test_rmdir_1 FAILED\n");
13823 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
13824 if (test_rmdir_2 () == -1) {
13825 printf ("test_rmdir_2 FAILED\n");
13829 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
13830 if (test_rm_0 () == -1) {
13831 printf ("test_rm_0 FAILED\n");
13835 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
13836 if (test_rm_1 () == -1) {
13837 printf ("test_rm_1 FAILED\n");
13841 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
13842 if (test_rm_2 () == -1) {
13843 printf ("test_rm_2 FAILED\n");
13847 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
13848 if (test_read_lines_0 () == -1) {
13849 printf ("test_read_lines_0 FAILED\n");
13853 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
13854 if (test_read_lines_1 () == -1) {
13855 printf ("test_read_lines_1 FAILED\n");
13859 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
13860 if (test_lvs_0 () == -1) {
13861 printf ("test_lvs_0 FAILED\n");
13865 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
13866 if (test_lvs_1 () == -1) {
13867 printf ("test_lvs_1 FAILED\n");
13871 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
13872 if (test_vgs_0 () == -1) {
13873 printf ("test_vgs_0 FAILED\n");
13877 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
13878 if (test_vgs_1 () == -1) {
13879 printf ("test_vgs_1 FAILED\n");
13883 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
13884 if (test_pvs_0 () == -1) {
13885 printf ("test_pvs_0 FAILED\n");
13889 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
13890 if (test_pvs_1 () == -1) {
13891 printf ("test_pvs_1 FAILED\n");
13895 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
13896 if (test_list_partitions_0 () == -1) {
13897 printf ("test_list_partitions_0 FAILED\n");
13901 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
13902 if (test_list_partitions_1 () == -1) {
13903 printf ("test_list_partitions_1 FAILED\n");
13907 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
13908 if (test_list_devices_0 () == -1) {
13909 printf ("test_list_devices_0 FAILED\n");
13913 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
13914 if (test_ls_0 () == -1) {
13915 printf ("test_ls_0 FAILED\n");
13919 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
13920 if (test_cat_0 () == -1) {
13921 printf ("test_cat_0 FAILED\n");
13925 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
13926 if (test_touch_0 () == -1) {
13927 printf ("test_touch_0 FAILED\n");
13931 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
13932 if (test_sync_0 () == -1) {
13933 printf ("test_sync_0 FAILED\n");
13937 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
13938 if (test_mount_0 () == -1) {
13939 printf ("test_mount_0 FAILED\n");
13944 unlink ("test1.img");
13945 unlink ("test2.img");
13946 unlink ("test3.img");
13949 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);