1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 /* This will be 's' or 'h' depending on whether the guest kernel
35 * names IDE devices /dev/sd* or /dev/hd*.
37 static char devchar = 's';
39 static void print_error (guestfs_h *g, void *data, const char *msg)
42 fprintf (stderr, "%s\n", msg);
45 static void print_strings (char * const * const argv)
49 for (argc = 0; argv[argc] != NULL; ++argc)
50 printf ("\t%s\n", argv[argc]);
54 static void print_table (char * const * const argv)
58 for (i = 0; argv[i] != NULL; i += 2)
59 printf ("%s: %s\n", argv[i], argv[i+1]);
63 static void no_test_warnings (void)
65 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
121 static int test_hexdump_0 (void)
123 /* InitBasicFS for hexdump (0): create ext2 on /dev/sda1 */
125 char device[] = "/dev/sda";
129 r = guestfs_blockdev_setrw (g, device);
136 r = guestfs_umount_all (g);
143 r = guestfs_lvm_remove_all (g);
148 char device[] = "/dev/sda";
150 char lines_0[] = ",";
157 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
162 char fstype[] = "ext2";
163 char device[] = "/dev/sda1";
167 r = guestfs_mkfs (g, fstype, device);
172 char device[] = "/dev/sda1";
174 char mountpoint[] = "/";
177 r = guestfs_mount (g, device, mountpoint);
181 /* TestOutput for hexdump (0) */
182 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
184 char path[] = "/new";
185 char content[] = "hello\nworld\n";
188 r = guestfs_write_file (g, path, content, 12);
193 char path[] = "/new";
196 r = guestfs_hexdump (g, path);
199 if (strcmp (r, expected) != 0) {
200 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
208 static int test_strings_e_0 (void)
210 /* InitBasicFS for strings_e (0): create ext2 on /dev/sda1 */
212 char device[] = "/dev/sda";
216 r = guestfs_blockdev_setrw (g, device);
223 r = guestfs_umount_all (g);
230 r = guestfs_lvm_remove_all (g);
235 char device[] = "/dev/sda";
237 char lines_0[] = ",";
244 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
249 char fstype[] = "ext2";
250 char device[] = "/dev/sda1";
254 r = guestfs_mkfs (g, fstype, device);
259 char device[] = "/dev/sda1";
261 char mountpoint[] = "/";
264 r = guestfs_mount (g, device, mountpoint);
268 /* TestOutputList for strings_e (0) */
270 char path[] = "/new";
271 char content[] = "hello\nworld\n";
274 r = guestfs_write_file (g, path, content, 0);
279 char encoding[] = "b";
280 char path[] = "/new";
284 r = guestfs_strings_e (g, encoding, path);
288 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
292 for (i = 0; r[i] != NULL; ++i)
299 static int test_strings_e_1 (void)
301 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
305 static int test_strings_0 (void)
307 /* InitBasicFS for strings (0): create ext2 on /dev/sda1 */
309 char device[] = "/dev/sda";
313 r = guestfs_blockdev_setrw (g, device);
320 r = guestfs_umount_all (g);
327 r = guestfs_lvm_remove_all (g);
332 char device[] = "/dev/sda";
334 char lines_0[] = ",";
341 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
346 char fstype[] = "ext2";
347 char device[] = "/dev/sda1";
351 r = guestfs_mkfs (g, fstype, device);
356 char device[] = "/dev/sda1";
358 char mountpoint[] = "/";
361 r = guestfs_mount (g, device, mountpoint);
365 /* TestOutputList for strings (0) */
367 char path[] = "/new";
368 char content[] = "hello\nworld\n";
371 r = guestfs_write_file (g, path, content, 0);
376 char path[] = "/new";
380 r = guestfs_strings (g, path);
384 fprintf (stderr, "test_strings_0: short list returned from command\n");
389 char expected[] = "hello";
390 if (strcmp (r[0], expected) != 0) {
391 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
396 fprintf (stderr, "test_strings_0: short list returned from command\n");
401 char expected[] = "world";
402 if (strcmp (r[1], expected) != 0) {
403 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
408 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
412 for (i = 0; r[i] != NULL; ++i)
419 static int test_strings_1 (void)
421 /* InitBasicFS for strings (1): create ext2 on /dev/sda1 */
423 char device[] = "/dev/sda";
427 r = guestfs_blockdev_setrw (g, device);
434 r = guestfs_umount_all (g);
441 r = guestfs_lvm_remove_all (g);
446 char device[] = "/dev/sda";
448 char lines_0[] = ",";
455 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
460 char fstype[] = "ext2";
461 char device[] = "/dev/sda1";
465 r = guestfs_mkfs (g, fstype, device);
470 char device[] = "/dev/sda1";
472 char mountpoint[] = "/";
475 r = guestfs_mount (g, device, mountpoint);
479 /* TestOutputList for strings (1) */
481 char path[] = "/new";
484 r = guestfs_touch (g, path);
489 char path[] = "/new";
493 r = guestfs_strings (g, path);
497 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
501 for (i = 0; r[i] != NULL; ++i)
508 static int test_equal_0 (void)
510 /* InitBasicFS for equal (0): create ext2 on /dev/sda1 */
512 char device[] = "/dev/sda";
516 r = guestfs_blockdev_setrw (g, device);
523 r = guestfs_umount_all (g);
530 r = guestfs_lvm_remove_all (g);
535 char device[] = "/dev/sda";
537 char lines_0[] = ",";
544 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
549 char fstype[] = "ext2";
550 char device[] = "/dev/sda1";
554 r = guestfs_mkfs (g, fstype, device);
559 char device[] = "/dev/sda1";
561 char mountpoint[] = "/";
564 r = guestfs_mount (g, device, mountpoint);
568 /* TestOutputTrue for equal (0) */
570 char path[] = "/file1";
571 char content[] = "contents of a file";
574 r = guestfs_write_file (g, path, content, 0);
579 char src[] = "/file1";
580 char dest[] = "/file2";
583 r = guestfs_cp (g, src, dest);
588 char file1[] = "/file1";
589 char file2[] = "/file2";
592 r = guestfs_equal (g, file1, file2);
596 fprintf (stderr, "test_equal_0: expected true, got false\n");
603 static int test_equal_1 (void)
605 /* InitBasicFS for equal (1): create ext2 on /dev/sda1 */
607 char device[] = "/dev/sda";
611 r = guestfs_blockdev_setrw (g, device);
618 r = guestfs_umount_all (g);
625 r = guestfs_lvm_remove_all (g);
630 char device[] = "/dev/sda";
632 char lines_0[] = ",";
639 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
644 char fstype[] = "ext2";
645 char device[] = "/dev/sda1";
649 r = guestfs_mkfs (g, fstype, device);
654 char device[] = "/dev/sda1";
656 char mountpoint[] = "/";
659 r = guestfs_mount (g, device, mountpoint);
663 /* TestOutputFalse for equal (1) */
665 char path[] = "/file1";
666 char content[] = "contents of a file";
669 r = guestfs_write_file (g, path, content, 0);
674 char path[] = "/file2";
675 char content[] = "contents of another file";
678 r = guestfs_write_file (g, path, content, 0);
683 char file1[] = "/file1";
684 char file2[] = "/file2";
687 r = guestfs_equal (g, file1, file2);
691 fprintf (stderr, "test_equal_1: expected false, got true\n");
698 static int test_equal_2 (void)
700 /* InitBasicFS for equal (2): create ext2 on /dev/sda1 */
702 char device[] = "/dev/sda";
706 r = guestfs_blockdev_setrw (g, device);
713 r = guestfs_umount_all (g);
720 r = guestfs_lvm_remove_all (g);
725 char device[] = "/dev/sda";
727 char lines_0[] = ",";
734 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
739 char fstype[] = "ext2";
740 char device[] = "/dev/sda1";
744 r = guestfs_mkfs (g, fstype, device);
749 char device[] = "/dev/sda1";
751 char mountpoint[] = "/";
754 r = guestfs_mount (g, device, mountpoint);
758 /* TestLastFail for equal (2) */
760 char file1[] = "/file1";
761 char file2[] = "/file2";
764 r = guestfs_equal (g, file1, file2);
771 static int test_ping_daemon_0 (void)
773 /* InitEmpty for ping_daemon (0) */
775 char device[] = "/dev/sda";
779 r = guestfs_blockdev_setrw (g, device);
786 r = guestfs_umount_all (g);
793 r = guestfs_lvm_remove_all (g);
797 /* TestRun for ping_daemon (0) */
801 r = guestfs_ping_daemon (g);
808 static int test_dmesg_0 (void)
810 /* InitEmpty for dmesg (0) */
812 char device[] = "/dev/sda";
816 r = guestfs_blockdev_setrw (g, device);
823 r = guestfs_umount_all (g);
830 r = guestfs_lvm_remove_all (g);
834 /* TestRun for dmesg (0) */
838 r = guestfs_dmesg (g);
846 static int test_drop_caches_0 (void)
848 /* InitEmpty for drop_caches (0) */
850 char device[] = "/dev/sda";
854 r = guestfs_blockdev_setrw (g, device);
861 r = guestfs_umount_all (g);
868 r = guestfs_lvm_remove_all (g);
872 /* TestRun for drop_caches (0) */
876 r = guestfs_drop_caches (g, 3);
883 static int test_mv_0 (void)
885 /* InitBasicFS for mv (0): create ext2 on /dev/sda1 */
887 char device[] = "/dev/sda";
891 r = guestfs_blockdev_setrw (g, device);
898 r = guestfs_umount_all (g);
905 r = guestfs_lvm_remove_all (g);
910 char device[] = "/dev/sda";
912 char lines_0[] = ",";
919 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
924 char fstype[] = "ext2";
925 char device[] = "/dev/sda1";
929 r = guestfs_mkfs (g, fstype, device);
934 char device[] = "/dev/sda1";
936 char mountpoint[] = "/";
939 r = guestfs_mount (g, device, mountpoint);
943 /* TestOutput for mv (0) */
944 char expected[] = "file content";
946 char path[] = "/old";
947 char content[] = "file content";
950 r = guestfs_write_file (g, path, content, 0);
956 char dest[] = "/new";
959 r = guestfs_mv (g, src, dest);
964 char path[] = "/new";
967 r = guestfs_cat (g, path);
970 if (strcmp (r, expected) != 0) {
971 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
979 static int test_mv_1 (void)
981 /* InitBasicFS for mv (1): 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 /* TestOutputFalse for mv (1) */
1041 char path[] = "/old";
1042 char content[] = "file content";
1045 r = guestfs_write_file (g, path, content, 0);
1050 char src[] = "/old";
1051 char dest[] = "/new";
1054 r = guestfs_mv (g, src, dest);
1059 char path[] = "/old";
1062 r = guestfs_is_file (g, path);
1066 fprintf (stderr, "test_mv_1: expected false, got true\n");
1073 static int test_cp_a_0 (void)
1075 /* InitBasicFS for cp_a (0): create ext2 on /dev/sda1 */
1077 char device[] = "/dev/sda";
1078 device[5] = devchar;
1081 r = guestfs_blockdev_setrw (g, device);
1088 r = guestfs_umount_all (g);
1095 r = guestfs_lvm_remove_all (g);
1100 char device[] = "/dev/sda";
1101 device[5] = devchar;
1102 char lines_0[] = ",";
1109 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1114 char fstype[] = "ext2";
1115 char device[] = "/dev/sda1";
1116 device[5] = devchar;
1119 r = guestfs_mkfs (g, fstype, device);
1124 char device[] = "/dev/sda1";
1125 device[5] = devchar;
1126 char mountpoint[] = "/";
1129 r = guestfs_mount (g, device, mountpoint);
1133 /* TestOutput for cp_a (0) */
1134 char expected[] = "file content";
1136 char path[] = "/olddir";
1139 r = guestfs_mkdir (g, path);
1144 char path[] = "/newdir";
1147 r = guestfs_mkdir (g, path);
1152 char path[] = "/olddir/file";
1153 char content[] = "file content";
1156 r = guestfs_write_file (g, path, content, 0);
1161 char src[] = "/olddir";
1162 char dest[] = "/newdir";
1165 r = guestfs_cp_a (g, src, dest);
1170 char path[] = "/newdir/olddir/file";
1173 r = guestfs_cat (g, path);
1176 if (strcmp (r, expected) != 0) {
1177 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1185 static int test_cp_0 (void)
1187 /* InitBasicFS for cp (0): create ext2 on /dev/sda1 */
1189 char device[] = "/dev/sda";
1190 device[5] = devchar;
1193 r = guestfs_blockdev_setrw (g, device);
1200 r = guestfs_umount_all (g);
1207 r = guestfs_lvm_remove_all (g);
1212 char device[] = "/dev/sda";
1213 device[5] = devchar;
1214 char lines_0[] = ",";
1221 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1226 char fstype[] = "ext2";
1227 char device[] = "/dev/sda1";
1228 device[5] = devchar;
1231 r = guestfs_mkfs (g, fstype, device);
1236 char device[] = "/dev/sda1";
1237 device[5] = devchar;
1238 char mountpoint[] = "/";
1241 r = guestfs_mount (g, device, mountpoint);
1245 /* TestOutput for cp (0) */
1246 char expected[] = "file content";
1248 char path[] = "/old";
1249 char content[] = "file content";
1252 r = guestfs_write_file (g, path, content, 0);
1257 char src[] = "/old";
1258 char dest[] = "/new";
1261 r = guestfs_cp (g, src, dest);
1266 char path[] = "/new";
1269 r = guestfs_cat (g, path);
1272 if (strcmp (r, expected) != 0) {
1273 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1281 static int test_cp_1 (void)
1283 /* InitBasicFS for cp (1): 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 /* TestOutputTrue for cp (1) */
1343 char path[] = "/old";
1344 char content[] = "file content";
1347 r = guestfs_write_file (g, path, content, 0);
1352 char src[] = "/old";
1353 char dest[] = "/new";
1356 r = guestfs_cp (g, src, dest);
1361 char path[] = "/old";
1364 r = guestfs_is_file (g, path);
1368 fprintf (stderr, "test_cp_1: expected true, got false\n");
1375 static int test_cp_2 (void)
1377 /* InitBasicFS for cp (2): create ext2 on /dev/sda1 */
1379 char device[] = "/dev/sda";
1380 device[5] = devchar;
1383 r = guestfs_blockdev_setrw (g, device);
1390 r = guestfs_umount_all (g);
1397 r = guestfs_lvm_remove_all (g);
1402 char device[] = "/dev/sda";
1403 device[5] = devchar;
1404 char lines_0[] = ",";
1411 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1416 char fstype[] = "ext2";
1417 char device[] = "/dev/sda1";
1418 device[5] = devchar;
1421 r = guestfs_mkfs (g, fstype, device);
1426 char device[] = "/dev/sda1";
1427 device[5] = devchar;
1428 char mountpoint[] = "/";
1431 r = guestfs_mount (g, device, mountpoint);
1435 /* TestOutput for cp (2) */
1436 char expected[] = "file content";
1438 char path[] = "/old";
1439 char content[] = "file content";
1442 r = guestfs_write_file (g, path, content, 0);
1447 char path[] = "/dir";
1450 r = guestfs_mkdir (g, path);
1455 char src[] = "/old";
1456 char dest[] = "/dir/new";
1459 r = guestfs_cp (g, src, dest);
1464 char path[] = "/dir/new";
1467 r = guestfs_cat (g, path);
1470 if (strcmp (r, expected) != 0) {
1471 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
1479 static int test_grub_install_0 (void)
1481 /* InitBasicFS for grub_install (0): create ext2 on /dev/sda1 */
1483 char device[] = "/dev/sda";
1484 device[5] = devchar;
1487 r = guestfs_blockdev_setrw (g, device);
1494 r = guestfs_umount_all (g);
1501 r = guestfs_lvm_remove_all (g);
1506 char device[] = "/dev/sda";
1507 device[5] = devchar;
1508 char lines_0[] = ",";
1515 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1520 char fstype[] = "ext2";
1521 char device[] = "/dev/sda1";
1522 device[5] = devchar;
1525 r = guestfs_mkfs (g, fstype, device);
1530 char device[] = "/dev/sda1";
1531 device[5] = devchar;
1532 char mountpoint[] = "/";
1535 r = guestfs_mount (g, device, mountpoint);
1539 /* TestOutputTrue for grub_install (0) */
1542 char device[] = "/dev/sda1";
1543 device[5] = devchar;
1546 r = guestfs_grub_install (g, root, device);
1551 char path[] = "/boot";
1554 r = guestfs_is_dir (g, path);
1558 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
1565 static int test_zero_0 (void)
1567 /* InitBasicFS for zero (0): create ext2 on /dev/sda1 */
1569 char device[] = "/dev/sda";
1570 device[5] = devchar;
1573 r = guestfs_blockdev_setrw (g, device);
1580 r = guestfs_umount_all (g);
1587 r = guestfs_lvm_remove_all (g);
1592 char device[] = "/dev/sda";
1593 device[5] = devchar;
1594 char lines_0[] = ",";
1601 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1606 char fstype[] = "ext2";
1607 char device[] = "/dev/sda1";
1608 device[5] = devchar;
1611 r = guestfs_mkfs (g, fstype, device);
1616 char device[] = "/dev/sda1";
1617 device[5] = devchar;
1618 char mountpoint[] = "/";
1621 r = guestfs_mount (g, device, mountpoint);
1625 /* TestOutput for zero (0) */
1626 char expected[] = "data";
1628 char pathordevice[] = "/dev/sda1";
1629 pathordevice[5] = devchar;
1632 r = guestfs_umount (g, pathordevice);
1637 char device[] = "/dev/sda1";
1638 device[5] = devchar;
1641 r = guestfs_zero (g, device);
1646 char path[] = "/dev/sda1";
1650 r = guestfs_file (g, path);
1653 if (strcmp (r, expected) != 0) {
1654 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
1662 static int test_fsck_0 (void)
1664 /* InitBasicFS for fsck (0): create ext2 on /dev/sda1 */
1666 char device[] = "/dev/sda";
1667 device[5] = devchar;
1670 r = guestfs_blockdev_setrw (g, device);
1677 r = guestfs_umount_all (g);
1684 r = guestfs_lvm_remove_all (g);
1689 char device[] = "/dev/sda";
1690 device[5] = devchar;
1691 char lines_0[] = ",";
1698 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1703 char fstype[] = "ext2";
1704 char device[] = "/dev/sda1";
1705 device[5] = devchar;
1708 r = guestfs_mkfs (g, fstype, device);
1713 char device[] = "/dev/sda1";
1714 device[5] = devchar;
1715 char mountpoint[] = "/";
1718 r = guestfs_mount (g, device, mountpoint);
1722 /* TestOutputInt for fsck (0) */
1724 char pathordevice[] = "/dev/sda1";
1725 pathordevice[5] = devchar;
1728 r = guestfs_umount (g, pathordevice);
1733 char fstype[] = "ext2";
1734 char device[] = "/dev/sda1";
1735 device[5] = devchar;
1738 r = guestfs_fsck (g, fstype, device);
1742 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
1749 static int test_fsck_1 (void)
1751 /* InitBasicFS for fsck (1): create ext2 on /dev/sda1 */
1753 char device[] = "/dev/sda";
1754 device[5] = devchar;
1757 r = guestfs_blockdev_setrw (g, device);
1764 r = guestfs_umount_all (g);
1771 r = guestfs_lvm_remove_all (g);
1776 char device[] = "/dev/sda";
1777 device[5] = devchar;
1778 char lines_0[] = ",";
1785 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1790 char fstype[] = "ext2";
1791 char device[] = "/dev/sda1";
1792 device[5] = devchar;
1795 r = guestfs_mkfs (g, fstype, device);
1800 char device[] = "/dev/sda1";
1801 device[5] = devchar;
1802 char mountpoint[] = "/";
1805 r = guestfs_mount (g, device, mountpoint);
1809 /* TestOutputInt for fsck (1) */
1811 char pathordevice[] = "/dev/sda1";
1812 pathordevice[5] = devchar;
1815 r = guestfs_umount (g, pathordevice);
1820 char device[] = "/dev/sda1";
1821 device[5] = devchar;
1824 r = guestfs_zero (g, device);
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_1: expected 8 but got %d\n", (int) r);
1845 static int test_set_e2uuid_0 (void)
1847 /* InitBasicFS for set_e2uuid (0): 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 /* TestOutput for set_e2uuid (0) */
1906 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
1908 char device[] = "/dev/sda1";
1909 device[5] = devchar;
1910 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
1913 r = guestfs_set_e2uuid (g, device, uuid);
1918 char device[] = "/dev/sda1";
1919 device[5] = devchar;
1922 r = guestfs_get_e2uuid (g, device);
1925 if (strcmp (r, expected) != 0) {
1926 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
1934 static int test_set_e2uuid_1 (void)
1936 /* InitBasicFS for set_e2uuid (1): create ext2 on /dev/sda1 */
1938 char device[] = "/dev/sda";
1939 device[5] = devchar;
1942 r = guestfs_blockdev_setrw (g, device);
1949 r = guestfs_umount_all (g);
1956 r = guestfs_lvm_remove_all (g);
1961 char device[] = "/dev/sda";
1962 device[5] = devchar;
1963 char lines_0[] = ",";
1970 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1975 char fstype[] = "ext2";
1976 char device[] = "/dev/sda1";
1977 device[5] = devchar;
1980 r = guestfs_mkfs (g, fstype, device);
1985 char device[] = "/dev/sda1";
1986 device[5] = devchar;
1987 char mountpoint[] = "/";
1990 r = guestfs_mount (g, device, mountpoint);
1994 /* TestOutput for set_e2uuid (1) */
1995 char expected[] = "";
1997 char device[] = "/dev/sda1";
1998 device[5] = devchar;
1999 char uuid[] = "clear";
2002 r = guestfs_set_e2uuid (g, device, uuid);
2007 char device[] = "/dev/sda1";
2008 device[5] = devchar;
2011 r = guestfs_get_e2uuid (g, device);
2014 if (strcmp (r, expected) != 0) {
2015 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2023 static int test_set_e2uuid_2 (void)
2025 /* InitBasicFS for set_e2uuid (2): create ext2 on /dev/sda1 */
2027 char device[] = "/dev/sda";
2028 device[5] = devchar;
2031 r = guestfs_blockdev_setrw (g, device);
2038 r = guestfs_umount_all (g);
2045 r = guestfs_lvm_remove_all (g);
2050 char device[] = "/dev/sda";
2051 device[5] = devchar;
2052 char lines_0[] = ",";
2059 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2064 char fstype[] = "ext2";
2065 char device[] = "/dev/sda1";
2066 device[5] = devchar;
2069 r = guestfs_mkfs (g, fstype, device);
2074 char device[] = "/dev/sda1";
2075 device[5] = devchar;
2076 char mountpoint[] = "/";
2079 r = guestfs_mount (g, device, mountpoint);
2083 /* TestRun for set_e2uuid (2) */
2085 char device[] = "/dev/sda1";
2086 device[5] = devchar;
2087 char uuid[] = "random";
2090 r = guestfs_set_e2uuid (g, device, uuid);
2097 static int test_set_e2uuid_3 (void)
2099 /* InitBasicFS for set_e2uuid (3): create ext2 on /dev/sda1 */
2101 char device[] = "/dev/sda";
2102 device[5] = devchar;
2105 r = guestfs_blockdev_setrw (g, device);
2112 r = guestfs_umount_all (g);
2119 r = guestfs_lvm_remove_all (g);
2124 char device[] = "/dev/sda";
2125 device[5] = devchar;
2126 char lines_0[] = ",";
2133 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2138 char fstype[] = "ext2";
2139 char device[] = "/dev/sda1";
2140 device[5] = devchar;
2143 r = guestfs_mkfs (g, fstype, device);
2148 char device[] = "/dev/sda1";
2149 device[5] = devchar;
2150 char mountpoint[] = "/";
2153 r = guestfs_mount (g, device, mountpoint);
2157 /* TestRun for set_e2uuid (3) */
2159 char device[] = "/dev/sda1";
2160 device[5] = devchar;
2161 char uuid[] = "time";
2164 r = guestfs_set_e2uuid (g, device, uuid);
2171 static int test_set_e2label_0 (void)
2173 /* InitBasicFS for set_e2label (0): create ext2 on /dev/sda1 */
2175 char device[] = "/dev/sda";
2176 device[5] = devchar;
2179 r = guestfs_blockdev_setrw (g, device);
2186 r = guestfs_umount_all (g);
2193 r = guestfs_lvm_remove_all (g);
2198 char device[] = "/dev/sda";
2199 device[5] = devchar;
2200 char lines_0[] = ",";
2207 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2212 char fstype[] = "ext2";
2213 char device[] = "/dev/sda1";
2214 device[5] = devchar;
2217 r = guestfs_mkfs (g, fstype, device);
2222 char device[] = "/dev/sda1";
2223 device[5] = devchar;
2224 char mountpoint[] = "/";
2227 r = guestfs_mount (g, device, mountpoint);
2231 /* TestOutput for set_e2label (0) */
2232 char expected[] = "testlabel";
2234 char device[] = "/dev/sda1";
2235 device[5] = devchar;
2236 char label[] = "testlabel";
2239 r = guestfs_set_e2label (g, device, label);
2244 char device[] = "/dev/sda1";
2245 device[5] = devchar;
2248 r = guestfs_get_e2label (g, device);
2251 if (strcmp (r, expected) != 0) {
2252 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2260 static int test_pvremove_0 (void)
2262 /* InitEmpty for pvremove (0) */
2264 char device[] = "/dev/sda";
2265 device[5] = devchar;
2268 r = guestfs_blockdev_setrw (g, device);
2275 r = guestfs_umount_all (g);
2282 r = guestfs_lvm_remove_all (g);
2286 /* TestOutputList for pvremove (0) */
2288 char device[] = "/dev/sda";
2289 device[5] = devchar;
2292 r = guestfs_pvcreate (g, device);
2297 char volgroup[] = "VG";
2298 char physvols_0[] = "/dev/sda";
2299 physvols_0[5] = devchar;
2300 char *physvols[] = {
2306 r = guestfs_vgcreate (g, volgroup, physvols);
2311 char logvol[] = "LV1";
2312 char volgroup[] = "VG";
2315 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2320 char logvol[] = "LV2";
2321 char volgroup[] = "VG";
2324 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2329 char vgname[] = "VG";
2332 r = guestfs_vgremove (g, vgname);
2337 char device[] = "/dev/sda";
2338 device[5] = devchar;
2341 r = guestfs_pvremove (g, device);
2349 r = guestfs_lvs (g);
2353 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2357 for (i = 0; r[i] != NULL; ++i)
2364 static int test_pvremove_1 (void)
2366 /* InitEmpty for pvremove (1) */
2368 char device[] = "/dev/sda";
2369 device[5] = devchar;
2372 r = guestfs_blockdev_setrw (g, device);
2379 r = guestfs_umount_all (g);
2386 r = guestfs_lvm_remove_all (g);
2390 /* TestOutputList for pvremove (1) */
2392 char device[] = "/dev/sda";
2393 device[5] = devchar;
2396 r = guestfs_pvcreate (g, device);
2401 char volgroup[] = "VG";
2402 char physvols_0[] = "/dev/sda";
2403 physvols_0[5] = devchar;
2404 char *physvols[] = {
2410 r = guestfs_vgcreate (g, volgroup, physvols);
2415 char logvol[] = "LV1";
2416 char volgroup[] = "VG";
2419 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2424 char logvol[] = "LV2";
2425 char volgroup[] = "VG";
2428 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2433 char vgname[] = "VG";
2436 r = guestfs_vgremove (g, vgname);
2441 char device[] = "/dev/sda";
2442 device[5] = devchar;
2445 r = guestfs_pvremove (g, device);
2453 r = guestfs_vgs (g);
2457 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
2461 for (i = 0; r[i] != NULL; ++i)
2468 static int test_pvremove_2 (void)
2470 /* InitEmpty for pvremove (2) */
2472 char device[] = "/dev/sda";
2473 device[5] = devchar;
2476 r = guestfs_blockdev_setrw (g, device);
2483 r = guestfs_umount_all (g);
2490 r = guestfs_lvm_remove_all (g);
2494 /* TestOutputList for pvremove (2) */
2496 char device[] = "/dev/sda";
2497 device[5] = devchar;
2500 r = guestfs_pvcreate (g, device);
2505 char volgroup[] = "VG";
2506 char physvols_0[] = "/dev/sda";
2507 physvols_0[5] = devchar;
2508 char *physvols[] = {
2514 r = guestfs_vgcreate (g, volgroup, physvols);
2519 char logvol[] = "LV1";
2520 char volgroup[] = "VG";
2523 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2528 char logvol[] = "LV2";
2529 char volgroup[] = "VG";
2532 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2537 char vgname[] = "VG";
2540 r = guestfs_vgremove (g, vgname);
2545 char device[] = "/dev/sda";
2546 device[5] = devchar;
2549 r = guestfs_pvremove (g, device);
2557 r = guestfs_pvs (g);
2561 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
2565 for (i = 0; r[i] != NULL; ++i)
2572 static int test_vgremove_0 (void)
2574 /* InitEmpty for vgremove (0) */
2576 char device[] = "/dev/sda";
2577 device[5] = devchar;
2580 r = guestfs_blockdev_setrw (g, device);
2587 r = guestfs_umount_all (g);
2594 r = guestfs_lvm_remove_all (g);
2598 /* TestOutputList for vgremove (0) */
2600 char device[] = "/dev/sda";
2601 device[5] = devchar;
2604 r = guestfs_pvcreate (g, device);
2609 char volgroup[] = "VG";
2610 char physvols_0[] = "/dev/sda";
2611 physvols_0[5] = devchar;
2612 char *physvols[] = {
2618 r = guestfs_vgcreate (g, volgroup, physvols);
2623 char logvol[] = "LV1";
2624 char volgroup[] = "VG";
2627 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2632 char logvol[] = "LV2";
2633 char volgroup[] = "VG";
2636 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2641 char vgname[] = "VG";
2644 r = guestfs_vgremove (g, vgname);
2652 r = guestfs_lvs (g);
2656 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
2660 for (i = 0; r[i] != NULL; ++i)
2667 static int test_vgremove_1 (void)
2669 /* InitEmpty for vgremove (1) */
2671 char device[] = "/dev/sda";
2672 device[5] = devchar;
2675 r = guestfs_blockdev_setrw (g, device);
2682 r = guestfs_umount_all (g);
2689 r = guestfs_lvm_remove_all (g);
2693 /* TestOutputList for vgremove (1) */
2695 char device[] = "/dev/sda";
2696 device[5] = devchar;
2699 r = guestfs_pvcreate (g, device);
2704 char volgroup[] = "VG";
2705 char physvols_0[] = "/dev/sda";
2706 physvols_0[5] = devchar;
2707 char *physvols[] = {
2713 r = guestfs_vgcreate (g, volgroup, physvols);
2718 char logvol[] = "LV1";
2719 char volgroup[] = "VG";
2722 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2727 char logvol[] = "LV2";
2728 char volgroup[] = "VG";
2731 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2736 char vgname[] = "VG";
2739 r = guestfs_vgremove (g, vgname);
2747 r = guestfs_vgs (g);
2751 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
2755 for (i = 0; r[i] != NULL; ++i)
2762 static int test_lvremove_0 (void)
2764 /* InitEmpty for lvremove (0) */
2766 char device[] = "/dev/sda";
2767 device[5] = devchar;
2770 r = guestfs_blockdev_setrw (g, device);
2777 r = guestfs_umount_all (g);
2784 r = guestfs_lvm_remove_all (g);
2788 /* TestOutputList for lvremove (0) */
2790 char device[] = "/dev/sda";
2791 device[5] = devchar;
2794 r = guestfs_pvcreate (g, device);
2799 char volgroup[] = "VG";
2800 char physvols_0[] = "/dev/sda";
2801 physvols_0[5] = devchar;
2802 char *physvols[] = {
2808 r = guestfs_vgcreate (g, volgroup, physvols);
2813 char logvol[] = "LV1";
2814 char volgroup[] = "VG";
2817 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2822 char logvol[] = "LV2";
2823 char volgroup[] = "VG";
2826 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2831 char device[] = "/dev/VG/LV1";
2834 r = guestfs_lvremove (g, device);
2842 r = guestfs_lvs (g);
2846 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
2851 char expected[] = "/dev/VG/LV2";
2852 if (strcmp (r[0], expected) != 0) {
2853 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2858 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
2862 for (i = 0; r[i] != NULL; ++i)
2869 static int test_lvremove_1 (void)
2871 /* InitEmpty for lvremove (1) */
2873 char device[] = "/dev/sda";
2874 device[5] = devchar;
2877 r = guestfs_blockdev_setrw (g, device);
2884 r = guestfs_umount_all (g);
2891 r = guestfs_lvm_remove_all (g);
2895 /* TestOutputList for lvremove (1) */
2897 char device[] = "/dev/sda";
2898 device[5] = devchar;
2901 r = guestfs_pvcreate (g, device);
2906 char volgroup[] = "VG";
2907 char physvols_0[] = "/dev/sda";
2908 physvols_0[5] = devchar;
2909 char *physvols[] = {
2915 r = guestfs_vgcreate (g, volgroup, physvols);
2920 char logvol[] = "LV1";
2921 char volgroup[] = "VG";
2924 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2929 char logvol[] = "LV2";
2930 char volgroup[] = "VG";
2933 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2938 char device[] = "/dev/VG";
2941 r = guestfs_lvremove (g, device);
2949 r = guestfs_lvs (g);
2953 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
2957 for (i = 0; r[i] != NULL; ++i)
2964 static int test_lvremove_2 (void)
2966 /* InitEmpty for lvremove (2) */
2968 char device[] = "/dev/sda";
2969 device[5] = devchar;
2972 r = guestfs_blockdev_setrw (g, device);
2979 r = guestfs_umount_all (g);
2986 r = guestfs_lvm_remove_all (g);
2990 /* TestOutputList for lvremove (2) */
2992 char device[] = "/dev/sda";
2993 device[5] = devchar;
2996 r = guestfs_pvcreate (g, device);
3001 char volgroup[] = "VG";
3002 char physvols_0[] = "/dev/sda";
3003 physvols_0[5] = devchar;
3004 char *physvols[] = {
3010 r = guestfs_vgcreate (g, volgroup, physvols);
3015 char logvol[] = "LV1";
3016 char volgroup[] = "VG";
3019 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3024 char logvol[] = "LV2";
3025 char volgroup[] = "VG";
3028 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3033 char device[] = "/dev/VG";
3036 r = guestfs_lvremove (g, device);
3044 r = guestfs_vgs (g);
3048 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3053 char expected[] = "VG";
3054 if (strcmp (r[0], expected) != 0) {
3055 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3060 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3064 for (i = 0; r[i] != NULL; ++i)
3071 static int test_mount_ro_0 (void)
3073 /* InitBasicFS for mount_ro (0): create ext2 on /dev/sda1 */
3075 char device[] = "/dev/sda";
3076 device[5] = devchar;
3079 r = guestfs_blockdev_setrw (g, device);
3086 r = guestfs_umount_all (g);
3093 r = guestfs_lvm_remove_all (g);
3098 char device[] = "/dev/sda";
3099 device[5] = devchar;
3100 char lines_0[] = ",";
3107 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3112 char fstype[] = "ext2";
3113 char device[] = "/dev/sda1";
3114 device[5] = devchar;
3117 r = guestfs_mkfs (g, fstype, device);
3122 char device[] = "/dev/sda1";
3123 device[5] = devchar;
3124 char mountpoint[] = "/";
3127 r = guestfs_mount (g, device, mountpoint);
3131 /* TestLastFail for mount_ro (0) */
3133 char pathordevice[] = "/";
3136 r = guestfs_umount (g, pathordevice);
3141 char device[] = "/dev/sda1";
3142 device[5] = devchar;
3143 char mountpoint[] = "/";
3146 r = guestfs_mount_ro (g, device, mountpoint);
3151 char path[] = "/new";
3154 r = guestfs_touch (g, path);
3161 static int test_mount_ro_1 (void)
3163 /* InitBasicFS for mount_ro (1): create ext2 on /dev/sda1 */
3165 char device[] = "/dev/sda";
3166 device[5] = devchar;
3169 r = guestfs_blockdev_setrw (g, device);
3176 r = guestfs_umount_all (g);
3183 r = guestfs_lvm_remove_all (g);
3188 char device[] = "/dev/sda";
3189 device[5] = devchar;
3190 char lines_0[] = ",";
3197 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3202 char fstype[] = "ext2";
3203 char device[] = "/dev/sda1";
3204 device[5] = devchar;
3207 r = guestfs_mkfs (g, fstype, device);
3212 char device[] = "/dev/sda1";
3213 device[5] = devchar;
3214 char mountpoint[] = "/";
3217 r = guestfs_mount (g, device, mountpoint);
3221 /* TestOutput for mount_ro (1) */
3222 char expected[] = "data";
3224 char path[] = "/new";
3225 char content[] = "data";
3228 r = guestfs_write_file (g, path, content, 0);
3233 char pathordevice[] = "/";
3236 r = guestfs_umount (g, pathordevice);
3241 char device[] = "/dev/sda1";
3242 device[5] = devchar;
3243 char mountpoint[] = "/";
3246 r = guestfs_mount_ro (g, device, mountpoint);
3251 char path[] = "/new";
3254 r = guestfs_cat (g, path);
3257 if (strcmp (r, expected) != 0) {
3258 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3266 static int test_tgz_in_0 (void)
3268 /* InitBasicFS for tgz_in (0): create ext2 on /dev/sda1 */
3270 char device[] = "/dev/sda";
3271 device[5] = devchar;
3274 r = guestfs_blockdev_setrw (g, device);
3281 r = guestfs_umount_all (g);
3288 r = guestfs_lvm_remove_all (g);
3293 char device[] = "/dev/sda";
3294 device[5] = devchar;
3295 char lines_0[] = ",";
3302 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3307 char fstype[] = "ext2";
3308 char device[] = "/dev/sda1";
3309 device[5] = devchar;
3312 r = guestfs_mkfs (g, fstype, device);
3317 char device[] = "/dev/sda1";
3318 device[5] = devchar;
3319 char mountpoint[] = "/";
3322 r = guestfs_mount (g, device, mountpoint);
3326 /* TestOutput for tgz_in (0) */
3327 char expected[] = "hello\n";
3329 char directory[] = "/";
3332 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3337 char path[] = "/hello";
3340 r = guestfs_cat (g, path);
3343 if (strcmp (r, expected) != 0) {
3344 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3352 static int test_tar_in_0 (void)
3354 /* InitBasicFS for tar_in (0): create ext2 on /dev/sda1 */
3356 char device[] = "/dev/sda";
3357 device[5] = devchar;
3360 r = guestfs_blockdev_setrw (g, device);
3367 r = guestfs_umount_all (g);
3374 r = guestfs_lvm_remove_all (g);
3379 char device[] = "/dev/sda";
3380 device[5] = devchar;
3381 char lines_0[] = ",";
3388 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3393 char fstype[] = "ext2";
3394 char device[] = "/dev/sda1";
3395 device[5] = devchar;
3398 r = guestfs_mkfs (g, fstype, device);
3403 char device[] = "/dev/sda1";
3404 device[5] = devchar;
3405 char mountpoint[] = "/";
3408 r = guestfs_mount (g, device, mountpoint);
3412 /* TestOutput for tar_in (0) */
3413 char expected[] = "hello\n";
3415 char directory[] = "/";
3418 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
3423 char path[] = "/hello";
3426 r = guestfs_cat (g, path);
3429 if (strcmp (r, expected) != 0) {
3430 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3438 static int test_checksum_0 (void)
3440 /* InitBasicFS for checksum (0): create ext2 on /dev/sda1 */
3442 char device[] = "/dev/sda";
3443 device[5] = devchar;
3446 r = guestfs_blockdev_setrw (g, device);
3453 r = guestfs_umount_all (g);
3460 r = guestfs_lvm_remove_all (g);
3465 char device[] = "/dev/sda";
3466 device[5] = devchar;
3467 char lines_0[] = ",";
3474 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3479 char fstype[] = "ext2";
3480 char device[] = "/dev/sda1";
3481 device[5] = devchar;
3484 r = guestfs_mkfs (g, fstype, device);
3489 char device[] = "/dev/sda1";
3490 device[5] = devchar;
3491 char mountpoint[] = "/";
3494 r = guestfs_mount (g, device, mountpoint);
3498 /* TestOutput for checksum (0) */
3499 char expected[] = "935282863";
3501 char path[] = "/new";
3502 char content[] = "test\n";
3505 r = guestfs_write_file (g, path, content, 0);
3510 char csumtype[] = "crc";
3511 char path[] = "/new";
3514 r = guestfs_checksum (g, csumtype, path);
3517 if (strcmp (r, expected) != 0) {
3518 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
3526 static int test_checksum_1 (void)
3528 /* InitBasicFS for checksum (1): create ext2 on /dev/sda1 */
3530 char device[] = "/dev/sda";
3531 device[5] = devchar;
3534 r = guestfs_blockdev_setrw (g, device);
3541 r = guestfs_umount_all (g);
3548 r = guestfs_lvm_remove_all (g);
3553 char device[] = "/dev/sda";
3554 device[5] = devchar;
3555 char lines_0[] = ",";
3562 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3567 char fstype[] = "ext2";
3568 char device[] = "/dev/sda1";
3569 device[5] = devchar;
3572 r = guestfs_mkfs (g, fstype, device);
3577 char device[] = "/dev/sda1";
3578 device[5] = devchar;
3579 char mountpoint[] = "/";
3582 r = guestfs_mount (g, device, mountpoint);
3586 /* TestLastFail for checksum (1) */
3588 char csumtype[] = "crc";
3589 char path[] = "/new";
3592 r = guestfs_checksum (g, csumtype, path);
3600 static int test_checksum_2 (void)
3602 /* InitBasicFS for checksum (2): create ext2 on /dev/sda1 */
3604 char device[] = "/dev/sda";
3605 device[5] = devchar;
3608 r = guestfs_blockdev_setrw (g, device);
3615 r = guestfs_umount_all (g);
3622 r = guestfs_lvm_remove_all (g);
3627 char device[] = "/dev/sda";
3628 device[5] = devchar;
3629 char lines_0[] = ",";
3636 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3641 char fstype[] = "ext2";
3642 char device[] = "/dev/sda1";
3643 device[5] = devchar;
3646 r = guestfs_mkfs (g, fstype, device);
3651 char device[] = "/dev/sda1";
3652 device[5] = devchar;
3653 char mountpoint[] = "/";
3656 r = guestfs_mount (g, device, mountpoint);
3660 /* TestOutput for checksum (2) */
3661 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
3663 char path[] = "/new";
3664 char content[] = "test\n";
3667 r = guestfs_write_file (g, path, content, 0);
3672 char csumtype[] = "md5";
3673 char path[] = "/new";
3676 r = guestfs_checksum (g, csumtype, path);
3679 if (strcmp (r, expected) != 0) {
3680 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
3688 static int test_checksum_3 (void)
3690 /* InitBasicFS for checksum (3): create ext2 on /dev/sda1 */
3692 char device[] = "/dev/sda";
3693 device[5] = devchar;
3696 r = guestfs_blockdev_setrw (g, device);
3703 r = guestfs_umount_all (g);
3710 r = guestfs_lvm_remove_all (g);
3715 char device[] = "/dev/sda";
3716 device[5] = devchar;
3717 char lines_0[] = ",";
3724 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3729 char fstype[] = "ext2";
3730 char device[] = "/dev/sda1";
3731 device[5] = devchar;
3734 r = guestfs_mkfs (g, fstype, device);
3739 char device[] = "/dev/sda1";
3740 device[5] = devchar;
3741 char mountpoint[] = "/";
3744 r = guestfs_mount (g, device, mountpoint);
3748 /* TestOutput for checksum (3) */
3749 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
3751 char path[] = "/new";
3752 char content[] = "test\n";
3755 r = guestfs_write_file (g, path, content, 0);
3760 char csumtype[] = "sha1";
3761 char path[] = "/new";
3764 r = guestfs_checksum (g, csumtype, path);
3767 if (strcmp (r, expected) != 0) {
3768 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
3776 static int test_checksum_4 (void)
3778 /* InitBasicFS for checksum (4): create ext2 on /dev/sda1 */
3780 char device[] = "/dev/sda";
3781 device[5] = devchar;
3784 r = guestfs_blockdev_setrw (g, device);
3791 r = guestfs_umount_all (g);
3798 r = guestfs_lvm_remove_all (g);
3803 char device[] = "/dev/sda";
3804 device[5] = devchar;
3805 char lines_0[] = ",";
3812 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3817 char fstype[] = "ext2";
3818 char device[] = "/dev/sda1";
3819 device[5] = devchar;
3822 r = guestfs_mkfs (g, fstype, device);
3827 char device[] = "/dev/sda1";
3828 device[5] = devchar;
3829 char mountpoint[] = "/";
3832 r = guestfs_mount (g, device, mountpoint);
3836 /* TestOutput for checksum (4) */
3837 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
3839 char path[] = "/new";
3840 char content[] = "test\n";
3843 r = guestfs_write_file (g, path, content, 0);
3848 char csumtype[] = "sha224";
3849 char path[] = "/new";
3852 r = guestfs_checksum (g, csumtype, path);
3855 if (strcmp (r, expected) != 0) {
3856 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
3864 static int test_checksum_5 (void)
3866 /* InitBasicFS for checksum (5): create ext2 on /dev/sda1 */
3868 char device[] = "/dev/sda";
3869 device[5] = devchar;
3872 r = guestfs_blockdev_setrw (g, device);
3879 r = guestfs_umount_all (g);
3886 r = guestfs_lvm_remove_all (g);
3891 char device[] = "/dev/sda";
3892 device[5] = devchar;
3893 char lines_0[] = ",";
3900 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3905 char fstype[] = "ext2";
3906 char device[] = "/dev/sda1";
3907 device[5] = devchar;
3910 r = guestfs_mkfs (g, fstype, device);
3915 char device[] = "/dev/sda1";
3916 device[5] = devchar;
3917 char mountpoint[] = "/";
3920 r = guestfs_mount (g, device, mountpoint);
3924 /* TestOutput for checksum (5) */
3925 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
3927 char path[] = "/new";
3928 char content[] = "test\n";
3931 r = guestfs_write_file (g, path, content, 0);
3936 char csumtype[] = "sha256";
3937 char path[] = "/new";
3940 r = guestfs_checksum (g, csumtype, path);
3943 if (strcmp (r, expected) != 0) {
3944 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
3952 static int test_checksum_6 (void)
3954 /* InitBasicFS for checksum (6): create ext2 on /dev/sda1 */
3956 char device[] = "/dev/sda";
3957 device[5] = devchar;
3960 r = guestfs_blockdev_setrw (g, device);
3967 r = guestfs_umount_all (g);
3974 r = guestfs_lvm_remove_all (g);
3979 char device[] = "/dev/sda";
3980 device[5] = devchar;
3981 char lines_0[] = ",";
3988 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3993 char fstype[] = "ext2";
3994 char device[] = "/dev/sda1";
3995 device[5] = devchar;
3998 r = guestfs_mkfs (g, fstype, device);
4003 char device[] = "/dev/sda1";
4004 device[5] = devchar;
4005 char mountpoint[] = "/";
4008 r = guestfs_mount (g, device, mountpoint);
4012 /* TestOutput for checksum (6) */
4013 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4015 char path[] = "/new";
4016 char content[] = "test\n";
4019 r = guestfs_write_file (g, path, content, 0);
4024 char csumtype[] = "sha384";
4025 char path[] = "/new";
4028 r = guestfs_checksum (g, csumtype, path);
4031 if (strcmp (r, expected) != 0) {
4032 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4040 static int test_checksum_7 (void)
4042 /* InitBasicFS for checksum (7): create ext2 on /dev/sda1 */
4044 char device[] = "/dev/sda";
4045 device[5] = devchar;
4048 r = guestfs_blockdev_setrw (g, device);
4055 r = guestfs_umount_all (g);
4062 r = guestfs_lvm_remove_all (g);
4067 char device[] = "/dev/sda";
4068 device[5] = devchar;
4069 char lines_0[] = ",";
4076 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4081 char fstype[] = "ext2";
4082 char device[] = "/dev/sda1";
4083 device[5] = devchar;
4086 r = guestfs_mkfs (g, fstype, device);
4091 char device[] = "/dev/sda1";
4092 device[5] = devchar;
4093 char mountpoint[] = "/";
4096 r = guestfs_mount (g, device, mountpoint);
4100 /* TestOutput for checksum (7) */
4101 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4103 char path[] = "/new";
4104 char content[] = "test\n";
4107 r = guestfs_write_file (g, path, content, 0);
4112 char csumtype[] = "sha512";
4113 char path[] = "/new";
4116 r = guestfs_checksum (g, csumtype, path);
4119 if (strcmp (r, expected) != 0) {
4120 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4128 static int test_download_0 (void)
4130 /* InitBasicFS for download (0): create ext2 on /dev/sda1 */
4132 char device[] = "/dev/sda";
4133 device[5] = devchar;
4136 r = guestfs_blockdev_setrw (g, device);
4143 r = guestfs_umount_all (g);
4150 r = guestfs_lvm_remove_all (g);
4155 char device[] = "/dev/sda";
4156 device[5] = devchar;
4157 char lines_0[] = ",";
4164 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4169 char fstype[] = "ext2";
4170 char device[] = "/dev/sda1";
4171 device[5] = devchar;
4174 r = guestfs_mkfs (g, fstype, device);
4179 char device[] = "/dev/sda1";
4180 device[5] = devchar;
4181 char mountpoint[] = "/";
4184 r = guestfs_mount (g, device, mountpoint);
4188 /* TestOutput for download (0) */
4189 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4191 char remotefilename[] = "/COPYING.LIB";
4194 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4199 char remotefilename[] = "/COPYING.LIB";
4202 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4207 char remotefilename[] = "/upload";
4210 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4215 char csumtype[] = "md5";
4216 char path[] = "/upload";
4219 r = guestfs_checksum (g, csumtype, path);
4222 if (strcmp (r, expected) != 0) {
4223 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4231 static int test_upload_0 (void)
4233 /* InitBasicFS for upload (0): create ext2 on /dev/sda1 */
4235 char device[] = "/dev/sda";
4236 device[5] = devchar;
4239 r = guestfs_blockdev_setrw (g, device);
4246 r = guestfs_umount_all (g);
4253 r = guestfs_lvm_remove_all (g);
4258 char device[] = "/dev/sda";
4259 device[5] = devchar;
4260 char lines_0[] = ",";
4267 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4272 char fstype[] = "ext2";
4273 char device[] = "/dev/sda1";
4274 device[5] = devchar;
4277 r = guestfs_mkfs (g, fstype, device);
4282 char device[] = "/dev/sda1";
4283 device[5] = devchar;
4284 char mountpoint[] = "/";
4287 r = guestfs_mount (g, device, mountpoint);
4291 /* TestOutput for upload (0) */
4292 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4294 char remotefilename[] = "/COPYING.LIB";
4297 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4302 char csumtype[] = "md5";
4303 char path[] = "/COPYING.LIB";
4306 r = guestfs_checksum (g, csumtype, path);
4309 if (strcmp (r, expected) != 0) {
4310 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4318 static int test_blockdev_rereadpt_0 (void)
4320 /* InitEmpty for blockdev_rereadpt (0) */
4322 char device[] = "/dev/sda";
4323 device[5] = devchar;
4326 r = guestfs_blockdev_setrw (g, device);
4333 r = guestfs_umount_all (g);
4340 r = guestfs_lvm_remove_all (g);
4344 /* TestRun for blockdev_rereadpt (0) */
4346 char device[] = "/dev/sda";
4347 device[5] = devchar;
4350 r = guestfs_blockdev_rereadpt (g, device);
4357 static int test_blockdev_flushbufs_0 (void)
4359 /* InitEmpty for blockdev_flushbufs (0) */
4361 char device[] = "/dev/sda";
4362 device[5] = devchar;
4365 r = guestfs_blockdev_setrw (g, device);
4372 r = guestfs_umount_all (g);
4379 r = guestfs_lvm_remove_all (g);
4383 /* TestRun for blockdev_flushbufs (0) */
4385 char device[] = "/dev/sda";
4386 device[5] = devchar;
4389 r = guestfs_blockdev_flushbufs (g, device);
4396 static int test_blockdev_getsize64_0 (void)
4398 /* InitEmpty for blockdev_getsize64 (0) */
4400 char device[] = "/dev/sda";
4401 device[5] = devchar;
4404 r = guestfs_blockdev_setrw (g, device);
4411 r = guestfs_umount_all (g);
4418 r = guestfs_lvm_remove_all (g);
4422 /* TestOutputInt for blockdev_getsize64 (0) */
4424 char device[] = "/dev/sda";
4425 device[5] = devchar;
4428 r = guestfs_blockdev_getsize64 (g, device);
4431 if (r != 524288000) {
4432 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
4439 static int test_blockdev_getsz_0 (void)
4441 /* InitEmpty for blockdev_getsz (0) */
4443 char device[] = "/dev/sda";
4444 device[5] = devchar;
4447 r = guestfs_blockdev_setrw (g, device);
4454 r = guestfs_umount_all (g);
4461 r = guestfs_lvm_remove_all (g);
4465 /* TestOutputInt for blockdev_getsz (0) */
4467 char device[] = "/dev/sda";
4468 device[5] = devchar;
4471 r = guestfs_blockdev_getsz (g, device);
4475 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
4482 static int test_blockdev_getbsz_0 (void)
4484 /* InitEmpty for blockdev_getbsz (0) */
4486 char device[] = "/dev/sda";
4487 device[5] = devchar;
4490 r = guestfs_blockdev_setrw (g, device);
4497 r = guestfs_umount_all (g);
4504 r = guestfs_lvm_remove_all (g);
4508 /* TestOutputInt for blockdev_getbsz (0) */
4510 char device[] = "/dev/sda";
4511 device[5] = devchar;
4514 r = guestfs_blockdev_getbsz (g, device);
4518 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
4525 static int test_blockdev_getss_0 (void)
4527 /* InitEmpty for blockdev_getss (0) */
4529 char device[] = "/dev/sda";
4530 device[5] = devchar;
4533 r = guestfs_blockdev_setrw (g, device);
4540 r = guestfs_umount_all (g);
4547 r = guestfs_lvm_remove_all (g);
4551 /* TestOutputInt for blockdev_getss (0) */
4553 char device[] = "/dev/sda";
4554 device[5] = devchar;
4557 r = guestfs_blockdev_getss (g, device);
4561 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
4568 static int test_blockdev_getro_0 (void)
4570 /* InitEmpty for blockdev_getro (0) */
4572 char device[] = "/dev/sda";
4573 device[5] = devchar;
4576 r = guestfs_blockdev_setrw (g, device);
4583 r = guestfs_umount_all (g);
4590 r = guestfs_lvm_remove_all (g);
4594 /* TestOutputTrue for blockdev_getro (0) */
4596 char device[] = "/dev/sda";
4597 device[5] = devchar;
4600 r = guestfs_blockdev_setro (g, device);
4605 char device[] = "/dev/sda";
4606 device[5] = devchar;
4609 r = guestfs_blockdev_getro (g, device);
4613 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
4620 static int test_blockdev_setrw_0 (void)
4622 /* InitEmpty for blockdev_setrw (0) */
4624 char device[] = "/dev/sda";
4625 device[5] = devchar;
4628 r = guestfs_blockdev_setrw (g, device);
4635 r = guestfs_umount_all (g);
4642 r = guestfs_lvm_remove_all (g);
4646 /* TestOutputFalse for blockdev_setrw (0) */
4648 char device[] = "/dev/sda";
4649 device[5] = devchar;
4652 r = guestfs_blockdev_setrw (g, device);
4657 char device[] = "/dev/sda";
4658 device[5] = devchar;
4661 r = guestfs_blockdev_getro (g, device);
4665 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
4672 static int test_blockdev_setro_0 (void)
4674 /* InitEmpty for blockdev_setro (0) */
4676 char device[] = "/dev/sda";
4677 device[5] = devchar;
4680 r = guestfs_blockdev_setrw (g, device);
4687 r = guestfs_umount_all (g);
4694 r = guestfs_lvm_remove_all (g);
4698 /* TestOutputTrue for blockdev_setro (0) */
4700 char device[] = "/dev/sda";
4701 device[5] = devchar;
4704 r = guestfs_blockdev_setro (g, device);
4709 char device[] = "/dev/sda";
4710 device[5] = devchar;
4713 r = guestfs_blockdev_getro (g, device);
4717 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
4724 static int test_statvfs_0 (void)
4726 /* InitBasicFS for statvfs (0): create ext2 on /dev/sda1 */
4728 char device[] = "/dev/sda";
4729 device[5] = devchar;
4732 r = guestfs_blockdev_setrw (g, device);
4739 r = guestfs_umount_all (g);
4746 r = guestfs_lvm_remove_all (g);
4751 char device[] = "/dev/sda";
4752 device[5] = devchar;
4753 char lines_0[] = ",";
4760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4765 char fstype[] = "ext2";
4766 char device[] = "/dev/sda1";
4767 device[5] = devchar;
4770 r = guestfs_mkfs (g, fstype, device);
4775 char device[] = "/dev/sda1";
4776 device[5] = devchar;
4777 char mountpoint[] = "/";
4780 r = guestfs_mount (g, device, mountpoint);
4784 /* TestOutputStruct for statvfs (0) */
4787 struct guestfs_statvfs *r;
4789 r = guestfs_statvfs (g, path);
4792 if (r->bfree != 487702) {
4793 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
4797 if (r->blocks != 490020) {
4798 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
4802 if (r->bsize != 1024) {
4803 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
4812 static int test_lstat_0 (void)
4814 /* InitBasicFS for lstat (0): create ext2 on /dev/sda1 */
4816 char device[] = "/dev/sda";
4817 device[5] = devchar;
4820 r = guestfs_blockdev_setrw (g, device);
4827 r = guestfs_umount_all (g);
4834 r = guestfs_lvm_remove_all (g);
4839 char device[] = "/dev/sda";
4840 device[5] = devchar;
4841 char lines_0[] = ",";
4848 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4853 char fstype[] = "ext2";
4854 char device[] = "/dev/sda1";
4855 device[5] = devchar;
4858 r = guestfs_mkfs (g, fstype, device);
4863 char device[] = "/dev/sda1";
4864 device[5] = devchar;
4865 char mountpoint[] = "/";
4868 r = guestfs_mount (g, device, mountpoint);
4872 /* TestOutputStruct for lstat (0) */
4874 char path[] = "/new";
4877 r = guestfs_touch (g, path);
4882 char path[] = "/new";
4883 struct guestfs_stat *r;
4885 r = guestfs_lstat (g, path);
4889 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
4898 static int test_stat_0 (void)
4900 /* InitBasicFS for stat (0): create ext2 on /dev/sda1 */
4902 char device[] = "/dev/sda";
4903 device[5] = devchar;
4906 r = guestfs_blockdev_setrw (g, device);
4913 r = guestfs_umount_all (g);
4920 r = guestfs_lvm_remove_all (g);
4925 char device[] = "/dev/sda";
4926 device[5] = devchar;
4927 char lines_0[] = ",";
4934 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4939 char fstype[] = "ext2";
4940 char device[] = "/dev/sda1";
4941 device[5] = devchar;
4944 r = guestfs_mkfs (g, fstype, device);
4949 char device[] = "/dev/sda1";
4950 device[5] = devchar;
4951 char mountpoint[] = "/";
4954 r = guestfs_mount (g, device, mountpoint);
4958 /* TestOutputStruct for stat (0) */
4960 char path[] = "/new";
4963 r = guestfs_touch (g, path);
4968 char path[] = "/new";
4969 struct guestfs_stat *r;
4971 r = guestfs_stat (g, path);
4975 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
4984 static int test_command_lines_0_prereq (void)
4986 const char *str = getenv ("SKIP_TEST_COMMAND");
4987 return str && strcmp (str, "1") == 0;
4990 static int test_command_lines_0 (void)
4992 if (! test_command_lines_0_prereq ()) {
4993 /* InitBasicFS for command_lines (0): create ext2 on /dev/sda1 */
4995 char device[] = "/dev/sda";
4996 device[5] = devchar;
4999 r = guestfs_blockdev_setrw (g, device);
5006 r = guestfs_umount_all (g);
5013 r = guestfs_lvm_remove_all (g);
5018 char device[] = "/dev/sda";
5019 device[5] = devchar;
5020 char lines_0[] = ",";
5027 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5032 char fstype[] = "ext2";
5033 char device[] = "/dev/sda1";
5034 device[5] = devchar;
5037 r = guestfs_mkfs (g, fstype, device);
5042 char device[] = "/dev/sda1";
5043 device[5] = devchar;
5044 char mountpoint[] = "/";
5047 r = guestfs_mount (g, device, mountpoint);
5051 /* TestOutputList for command_lines (0) */
5053 char remotefilename[] = "/test-command";
5056 r = guestfs_upload (g, "test-command", remotefilename);
5061 char path[] = "/test-command";
5064 r = guestfs_chmod (g, 493, path);
5069 char arguments_0[] = "/test-command";
5070 char arguments_1[] = "1";
5071 char *arguments[] = {
5079 r = guestfs_command_lines (g, arguments);
5083 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5088 char expected[] = "Result1";
5089 if (strcmp (r[0], expected) != 0) {
5090 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5095 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5099 for (i = 0; r[i] != NULL; ++i)
5104 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_0");
5108 static int test_command_lines_1_prereq (void)
5110 const char *str = getenv ("SKIP_TEST_COMMAND");
5111 return str && strcmp (str, "1") == 0;
5114 static int test_command_lines_1 (void)
5116 if (! test_command_lines_1_prereq ()) {
5117 /* InitBasicFS for command_lines (1): create ext2 on /dev/sda1 */
5119 char device[] = "/dev/sda";
5120 device[5] = devchar;
5123 r = guestfs_blockdev_setrw (g, device);
5130 r = guestfs_umount_all (g);
5137 r = guestfs_lvm_remove_all (g);
5142 char device[] = "/dev/sda";
5143 device[5] = devchar;
5144 char lines_0[] = ",";
5151 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5156 char fstype[] = "ext2";
5157 char device[] = "/dev/sda1";
5158 device[5] = devchar;
5161 r = guestfs_mkfs (g, fstype, device);
5166 char device[] = "/dev/sda1";
5167 device[5] = devchar;
5168 char mountpoint[] = "/";
5171 r = guestfs_mount (g, device, mountpoint);
5175 /* TestOutputList for command_lines (1) */
5177 char remotefilename[] = "/test-command";
5180 r = guestfs_upload (g, "test-command", remotefilename);
5185 char path[] = "/test-command";
5188 r = guestfs_chmod (g, 493, path);
5193 char arguments_0[] = "/test-command";
5194 char arguments_1[] = "2";
5195 char *arguments[] = {
5203 r = guestfs_command_lines (g, arguments);
5207 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5212 char expected[] = "Result2";
5213 if (strcmp (r[0], expected) != 0) {
5214 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5219 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5223 for (i = 0; r[i] != NULL; ++i)
5228 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_1");
5232 static int test_command_lines_2_prereq (void)
5234 const char *str = getenv ("SKIP_TEST_COMMAND");
5235 return str && strcmp (str, "1") == 0;
5238 static int test_command_lines_2 (void)
5240 if (! test_command_lines_2_prereq ()) {
5241 /* InitBasicFS for command_lines (2): create ext2 on /dev/sda1 */
5243 char device[] = "/dev/sda";
5244 device[5] = devchar;
5247 r = guestfs_blockdev_setrw (g, device);
5254 r = guestfs_umount_all (g);
5261 r = guestfs_lvm_remove_all (g);
5266 char device[] = "/dev/sda";
5267 device[5] = devchar;
5268 char lines_0[] = ",";
5275 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5280 char fstype[] = "ext2";
5281 char device[] = "/dev/sda1";
5282 device[5] = devchar;
5285 r = guestfs_mkfs (g, fstype, device);
5290 char device[] = "/dev/sda1";
5291 device[5] = devchar;
5292 char mountpoint[] = "/";
5295 r = guestfs_mount (g, device, mountpoint);
5299 /* TestOutputList for command_lines (2) */
5301 char remotefilename[] = "/test-command";
5304 r = guestfs_upload (g, "test-command", remotefilename);
5309 char path[] = "/test-command";
5312 r = guestfs_chmod (g, 493, path);
5317 char arguments_0[] = "/test-command";
5318 char arguments_1[] = "3";
5319 char *arguments[] = {
5327 r = guestfs_command_lines (g, arguments);
5331 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5336 char expected[] = "";
5337 if (strcmp (r[0], expected) != 0) {
5338 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5343 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5348 char expected[] = "Result3";
5349 if (strcmp (r[1], expected) != 0) {
5350 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5355 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5359 for (i = 0; r[i] != NULL; ++i)
5364 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_2");
5368 static int test_command_lines_3_prereq (void)
5370 const char *str = getenv ("SKIP_TEST_COMMAND");
5371 return str && strcmp (str, "1") == 0;
5374 static int test_command_lines_3 (void)
5376 if (! test_command_lines_3_prereq ()) {
5377 /* InitBasicFS for command_lines (3): create ext2 on /dev/sda1 */
5379 char device[] = "/dev/sda";
5380 device[5] = devchar;
5383 r = guestfs_blockdev_setrw (g, device);
5390 r = guestfs_umount_all (g);
5397 r = guestfs_lvm_remove_all (g);
5402 char device[] = "/dev/sda";
5403 device[5] = devchar;
5404 char lines_0[] = ",";
5411 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5416 char fstype[] = "ext2";
5417 char device[] = "/dev/sda1";
5418 device[5] = devchar;
5421 r = guestfs_mkfs (g, fstype, device);
5426 char device[] = "/dev/sda1";
5427 device[5] = devchar;
5428 char mountpoint[] = "/";
5431 r = guestfs_mount (g, device, mountpoint);
5435 /* TestOutputList for command_lines (3) */
5437 char remotefilename[] = "/test-command";
5440 r = guestfs_upload (g, "test-command", remotefilename);
5445 char path[] = "/test-command";
5448 r = guestfs_chmod (g, 493, path);
5453 char arguments_0[] = "/test-command";
5454 char arguments_1[] = "4";
5455 char *arguments[] = {
5463 r = guestfs_command_lines (g, arguments);
5467 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5472 char expected[] = "";
5473 if (strcmp (r[0], expected) != 0) {
5474 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5479 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5484 char expected[] = "Result4";
5485 if (strcmp (r[1], expected) != 0) {
5486 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5491 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
5495 for (i = 0; r[i] != NULL; ++i)
5500 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_3");
5504 static int test_command_lines_4_prereq (void)
5506 const char *str = getenv ("SKIP_TEST_COMMAND");
5507 return str && strcmp (str, "1") == 0;
5510 static int test_command_lines_4 (void)
5512 if (! test_command_lines_4_prereq ()) {
5513 /* InitBasicFS for command_lines (4): create ext2 on /dev/sda1 */
5515 char device[] = "/dev/sda";
5516 device[5] = devchar;
5519 r = guestfs_blockdev_setrw (g, device);
5526 r = guestfs_umount_all (g);
5533 r = guestfs_lvm_remove_all (g);
5538 char device[] = "/dev/sda";
5539 device[5] = devchar;
5540 char lines_0[] = ",";
5547 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5552 char fstype[] = "ext2";
5553 char device[] = "/dev/sda1";
5554 device[5] = devchar;
5557 r = guestfs_mkfs (g, fstype, device);
5562 char device[] = "/dev/sda1";
5563 device[5] = devchar;
5564 char mountpoint[] = "/";
5567 r = guestfs_mount (g, device, mountpoint);
5571 /* TestOutputList for command_lines (4) */
5573 char remotefilename[] = "/test-command";
5576 r = guestfs_upload (g, "test-command", remotefilename);
5581 char path[] = "/test-command";
5584 r = guestfs_chmod (g, 493, path);
5589 char arguments_0[] = "/test-command";
5590 char arguments_1[] = "5";
5591 char *arguments[] = {
5599 r = guestfs_command_lines (g, arguments);
5603 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5608 char expected[] = "";
5609 if (strcmp (r[0], expected) != 0) {
5610 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5615 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5620 char expected[] = "Result5";
5621 if (strcmp (r[1], expected) != 0) {
5622 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5627 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5632 char expected[] = "";
5633 if (strcmp (r[2], expected) != 0) {
5634 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5639 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
5643 for (i = 0; r[i] != NULL; ++i)
5648 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_4");
5652 static int test_command_lines_5_prereq (void)
5654 const char *str = getenv ("SKIP_TEST_COMMAND");
5655 return str && strcmp (str, "1") == 0;
5658 static int test_command_lines_5 (void)
5660 if (! test_command_lines_5_prereq ()) {
5661 /* InitBasicFS for command_lines (5): create ext2 on /dev/sda1 */
5663 char device[] = "/dev/sda";
5664 device[5] = devchar;
5667 r = guestfs_blockdev_setrw (g, device);
5674 r = guestfs_umount_all (g);
5681 r = guestfs_lvm_remove_all (g);
5686 char device[] = "/dev/sda";
5687 device[5] = devchar;
5688 char lines_0[] = ",";
5695 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5700 char fstype[] = "ext2";
5701 char device[] = "/dev/sda1";
5702 device[5] = devchar;
5705 r = guestfs_mkfs (g, fstype, device);
5710 char device[] = "/dev/sda1";
5711 device[5] = devchar;
5712 char mountpoint[] = "/";
5715 r = guestfs_mount (g, device, mountpoint);
5719 /* TestOutputList for command_lines (5) */
5721 char remotefilename[] = "/test-command";
5724 r = guestfs_upload (g, "test-command", remotefilename);
5729 char path[] = "/test-command";
5732 r = guestfs_chmod (g, 493, path);
5737 char arguments_0[] = "/test-command";
5738 char arguments_1[] = "6";
5739 char *arguments[] = {
5747 r = guestfs_command_lines (g, arguments);
5751 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5756 char expected[] = "";
5757 if (strcmp (r[0], expected) != 0) {
5758 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5763 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5768 char expected[] = "";
5769 if (strcmp (r[1], expected) != 0) {
5770 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5775 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5780 char expected[] = "Result6";
5781 if (strcmp (r[2], expected) != 0) {
5782 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5787 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5792 char expected[] = "";
5793 if (strcmp (r[3], expected) != 0) {
5794 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
5799 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
5803 for (i = 0; r[i] != NULL; ++i)
5808 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_5");
5812 static int test_command_lines_6_prereq (void)
5814 const char *str = getenv ("SKIP_TEST_COMMAND");
5815 return str && strcmp (str, "1") == 0;
5818 static int test_command_lines_6 (void)
5820 if (! test_command_lines_6_prereq ()) {
5821 /* InitBasicFS for command_lines (6): create ext2 on /dev/sda1 */
5823 char device[] = "/dev/sda";
5824 device[5] = devchar;
5827 r = guestfs_blockdev_setrw (g, device);
5834 r = guestfs_umount_all (g);
5841 r = guestfs_lvm_remove_all (g);
5846 char device[] = "/dev/sda";
5847 device[5] = devchar;
5848 char lines_0[] = ",";
5855 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5860 char fstype[] = "ext2";
5861 char device[] = "/dev/sda1";
5862 device[5] = devchar;
5865 r = guestfs_mkfs (g, fstype, device);
5870 char device[] = "/dev/sda1";
5871 device[5] = devchar;
5872 char mountpoint[] = "/";
5875 r = guestfs_mount (g, device, mountpoint);
5879 /* TestOutputList for command_lines (6) */
5881 char remotefilename[] = "/test-command";
5884 r = guestfs_upload (g, "test-command", remotefilename);
5889 char path[] = "/test-command";
5892 r = guestfs_chmod (g, 493, path);
5897 char arguments_0[] = "/test-command";
5898 char arguments_1[] = "7";
5899 char *arguments[] = {
5907 r = guestfs_command_lines (g, arguments);
5911 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
5915 for (i = 0; r[i] != NULL; ++i)
5920 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_6");
5924 static int test_command_lines_7_prereq (void)
5926 const char *str = getenv ("SKIP_TEST_COMMAND");
5927 return str && strcmp (str, "1") == 0;
5930 static int test_command_lines_7 (void)
5932 if (! test_command_lines_7_prereq ()) {
5933 /* InitBasicFS for command_lines (7): create ext2 on /dev/sda1 */
5935 char device[] = "/dev/sda";
5936 device[5] = devchar;
5939 r = guestfs_blockdev_setrw (g, device);
5946 r = guestfs_umount_all (g);
5953 r = guestfs_lvm_remove_all (g);
5958 char device[] = "/dev/sda";
5959 device[5] = devchar;
5960 char lines_0[] = ",";
5967 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5972 char fstype[] = "ext2";
5973 char device[] = "/dev/sda1";
5974 device[5] = devchar;
5977 r = guestfs_mkfs (g, fstype, device);
5982 char device[] = "/dev/sda1";
5983 device[5] = devchar;
5984 char mountpoint[] = "/";
5987 r = guestfs_mount (g, device, mountpoint);
5991 /* TestOutputList for command_lines (7) */
5993 char remotefilename[] = "/test-command";
5996 r = guestfs_upload (g, "test-command", remotefilename);
6001 char path[] = "/test-command";
6004 r = guestfs_chmod (g, 493, path);
6009 char arguments_0[] = "/test-command";
6010 char arguments_1[] = "8";
6011 char *arguments[] = {
6019 r = guestfs_command_lines (g, arguments);
6023 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6028 char expected[] = "";
6029 if (strcmp (r[0], expected) != 0) {
6030 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6035 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6039 for (i = 0; r[i] != NULL; ++i)
6044 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_7");
6048 static int test_command_lines_8_prereq (void)
6050 const char *str = getenv ("SKIP_TEST_COMMAND");
6051 return str && strcmp (str, "1") == 0;
6054 static int test_command_lines_8 (void)
6056 if (! test_command_lines_8_prereq ()) {
6057 /* InitBasicFS for command_lines (8): create ext2 on /dev/sda1 */
6059 char device[] = "/dev/sda";
6060 device[5] = devchar;
6063 r = guestfs_blockdev_setrw (g, device);
6070 r = guestfs_umount_all (g);
6077 r = guestfs_lvm_remove_all (g);
6082 char device[] = "/dev/sda";
6083 device[5] = devchar;
6084 char lines_0[] = ",";
6091 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6096 char fstype[] = "ext2";
6097 char device[] = "/dev/sda1";
6098 device[5] = devchar;
6101 r = guestfs_mkfs (g, fstype, device);
6106 char device[] = "/dev/sda1";
6107 device[5] = devchar;
6108 char mountpoint[] = "/";
6111 r = guestfs_mount (g, device, mountpoint);
6115 /* TestOutputList for command_lines (8) */
6117 char remotefilename[] = "/test-command";
6120 r = guestfs_upload (g, "test-command", remotefilename);
6125 char path[] = "/test-command";
6128 r = guestfs_chmod (g, 493, path);
6133 char arguments_0[] = "/test-command";
6134 char arguments_1[] = "9";
6135 char *arguments[] = {
6143 r = guestfs_command_lines (g, arguments);
6147 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6152 char expected[] = "";
6153 if (strcmp (r[0], expected) != 0) {
6154 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6159 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6164 char expected[] = "";
6165 if (strcmp (r[1], expected) != 0) {
6166 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6171 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6175 for (i = 0; r[i] != NULL; ++i)
6180 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_8");
6184 static int test_command_lines_9_prereq (void)
6186 const char *str = getenv ("SKIP_TEST_COMMAND");
6187 return str && strcmp (str, "1") == 0;
6190 static int test_command_lines_9 (void)
6192 if (! test_command_lines_9_prereq ()) {
6193 /* InitBasicFS for command_lines (9): create ext2 on /dev/sda1 */
6195 char device[] = "/dev/sda";
6196 device[5] = devchar;
6199 r = guestfs_blockdev_setrw (g, device);
6206 r = guestfs_umount_all (g);
6213 r = guestfs_lvm_remove_all (g);
6218 char device[] = "/dev/sda";
6219 device[5] = devchar;
6220 char lines_0[] = ",";
6227 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6232 char fstype[] = "ext2";
6233 char device[] = "/dev/sda1";
6234 device[5] = devchar;
6237 r = guestfs_mkfs (g, fstype, device);
6242 char device[] = "/dev/sda1";
6243 device[5] = devchar;
6244 char mountpoint[] = "/";
6247 r = guestfs_mount (g, device, mountpoint);
6251 /* TestOutputList for command_lines (9) */
6253 char remotefilename[] = "/test-command";
6256 r = guestfs_upload (g, "test-command", remotefilename);
6261 char path[] = "/test-command";
6264 r = guestfs_chmod (g, 493, path);
6269 char arguments_0[] = "/test-command";
6270 char arguments_1[] = "10";
6271 char *arguments[] = {
6279 r = guestfs_command_lines (g, arguments);
6283 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6288 char expected[] = "Result10-1";
6289 if (strcmp (r[0], expected) != 0) {
6290 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6295 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6300 char expected[] = "Result10-2";
6301 if (strcmp (r[1], expected) != 0) {
6302 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6307 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6311 for (i = 0; r[i] != NULL; ++i)
6316 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_9");
6320 static int test_command_lines_10_prereq (void)
6322 const char *str = getenv ("SKIP_TEST_COMMAND");
6323 return str && strcmp (str, "1") == 0;
6326 static int test_command_lines_10 (void)
6328 if (! test_command_lines_10_prereq ()) {
6329 /* InitBasicFS for command_lines (10): create ext2 on /dev/sda1 */
6331 char device[] = "/dev/sda";
6332 device[5] = devchar;
6335 r = guestfs_blockdev_setrw (g, device);
6342 r = guestfs_umount_all (g);
6349 r = guestfs_lvm_remove_all (g);
6354 char device[] = "/dev/sda";
6355 device[5] = devchar;
6356 char lines_0[] = ",";
6363 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6368 char fstype[] = "ext2";
6369 char device[] = "/dev/sda1";
6370 device[5] = devchar;
6373 r = guestfs_mkfs (g, fstype, device);
6378 char device[] = "/dev/sda1";
6379 device[5] = devchar;
6380 char mountpoint[] = "/";
6383 r = guestfs_mount (g, device, mountpoint);
6387 /* TestOutputList for command_lines (10) */
6389 char remotefilename[] = "/test-command";
6392 r = guestfs_upload (g, "test-command", remotefilename);
6397 char path[] = "/test-command";
6400 r = guestfs_chmod (g, 493, path);
6405 char arguments_0[] = "/test-command";
6406 char arguments_1[] = "11";
6407 char *arguments[] = {
6415 r = guestfs_command_lines (g, arguments);
6419 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6424 char expected[] = "Result11-1";
6425 if (strcmp (r[0], expected) != 0) {
6426 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6431 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6436 char expected[] = "Result11-2";
6437 if (strcmp (r[1], expected) != 0) {
6438 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6443 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
6447 for (i = 0; r[i] != NULL; ++i)
6452 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_lines_10");
6456 static int test_command_0_prereq (void)
6458 const char *str = getenv ("SKIP_TEST_COMMAND");
6459 return str && strcmp (str, "1") == 0;
6462 static int test_command_0 (void)
6464 if (! test_command_0_prereq ()) {
6465 /* InitBasicFS for command (0): create ext2 on /dev/sda1 */
6467 char device[] = "/dev/sda";
6468 device[5] = devchar;
6471 r = guestfs_blockdev_setrw (g, device);
6478 r = guestfs_umount_all (g);
6485 r = guestfs_lvm_remove_all (g);
6490 char device[] = "/dev/sda";
6491 device[5] = devchar;
6492 char lines_0[] = ",";
6499 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6504 char fstype[] = "ext2";
6505 char device[] = "/dev/sda1";
6506 device[5] = devchar;
6509 r = guestfs_mkfs (g, fstype, device);
6514 char device[] = "/dev/sda1";
6515 device[5] = devchar;
6516 char mountpoint[] = "/";
6519 r = guestfs_mount (g, device, mountpoint);
6523 /* TestOutput for command (0) */
6524 char expected[] = "Result1";
6526 char remotefilename[] = "/test-command";
6529 r = guestfs_upload (g, "test-command", remotefilename);
6534 char path[] = "/test-command";
6537 r = guestfs_chmod (g, 493, path);
6542 char arguments_0[] = "/test-command";
6543 char arguments_1[] = "1";
6544 char *arguments[] = {
6551 r = guestfs_command (g, arguments);
6554 if (strcmp (r, expected) != 0) {
6555 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
6561 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_0");
6565 static int test_command_1_prereq (void)
6567 const char *str = getenv ("SKIP_TEST_COMMAND");
6568 return str && strcmp (str, "1") == 0;
6571 static int test_command_1 (void)
6573 if (! test_command_1_prereq ()) {
6574 /* InitBasicFS for command (1): create ext2 on /dev/sda1 */
6576 char device[] = "/dev/sda";
6577 device[5] = devchar;
6580 r = guestfs_blockdev_setrw (g, device);
6587 r = guestfs_umount_all (g);
6594 r = guestfs_lvm_remove_all (g);
6599 char device[] = "/dev/sda";
6600 device[5] = devchar;
6601 char lines_0[] = ",";
6608 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6613 char fstype[] = "ext2";
6614 char device[] = "/dev/sda1";
6615 device[5] = devchar;
6618 r = guestfs_mkfs (g, fstype, device);
6623 char device[] = "/dev/sda1";
6624 device[5] = devchar;
6625 char mountpoint[] = "/";
6628 r = guestfs_mount (g, device, mountpoint);
6632 /* TestOutput for command (1) */
6633 char expected[] = "Result2\n";
6635 char remotefilename[] = "/test-command";
6638 r = guestfs_upload (g, "test-command", remotefilename);
6643 char path[] = "/test-command";
6646 r = guestfs_chmod (g, 493, path);
6651 char arguments_0[] = "/test-command";
6652 char arguments_1[] = "2";
6653 char *arguments[] = {
6660 r = guestfs_command (g, arguments);
6663 if (strcmp (r, expected) != 0) {
6664 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
6670 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_1");
6674 static int test_command_2_prereq (void)
6676 const char *str = getenv ("SKIP_TEST_COMMAND");
6677 return str && strcmp (str, "1") == 0;
6680 static int test_command_2 (void)
6682 if (! test_command_2_prereq ()) {
6683 /* InitBasicFS for command (2): create ext2 on /dev/sda1 */
6685 char device[] = "/dev/sda";
6686 device[5] = devchar;
6689 r = guestfs_blockdev_setrw (g, device);
6696 r = guestfs_umount_all (g);
6703 r = guestfs_lvm_remove_all (g);
6708 char device[] = "/dev/sda";
6709 device[5] = devchar;
6710 char lines_0[] = ",";
6717 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6722 char fstype[] = "ext2";
6723 char device[] = "/dev/sda1";
6724 device[5] = devchar;
6727 r = guestfs_mkfs (g, fstype, device);
6732 char device[] = "/dev/sda1";
6733 device[5] = devchar;
6734 char mountpoint[] = "/";
6737 r = guestfs_mount (g, device, mountpoint);
6741 /* TestOutput for command (2) */
6742 char expected[] = "\nResult3";
6744 char remotefilename[] = "/test-command";
6747 r = guestfs_upload (g, "test-command", remotefilename);
6752 char path[] = "/test-command";
6755 r = guestfs_chmod (g, 493, path);
6760 char arguments_0[] = "/test-command";
6761 char arguments_1[] = "3";
6762 char *arguments[] = {
6769 r = guestfs_command (g, arguments);
6772 if (strcmp (r, expected) != 0) {
6773 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
6779 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_2");
6783 static int test_command_3_prereq (void)
6785 const char *str = getenv ("SKIP_TEST_COMMAND");
6786 return str && strcmp (str, "1") == 0;
6789 static int test_command_3 (void)
6791 if (! test_command_3_prereq ()) {
6792 /* InitBasicFS for command (3): create ext2 on /dev/sda1 */
6794 char device[] = "/dev/sda";
6795 device[5] = devchar;
6798 r = guestfs_blockdev_setrw (g, device);
6805 r = guestfs_umount_all (g);
6812 r = guestfs_lvm_remove_all (g);
6817 char device[] = "/dev/sda";
6818 device[5] = devchar;
6819 char lines_0[] = ",";
6826 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6831 char fstype[] = "ext2";
6832 char device[] = "/dev/sda1";
6833 device[5] = devchar;
6836 r = guestfs_mkfs (g, fstype, device);
6841 char device[] = "/dev/sda1";
6842 device[5] = devchar;
6843 char mountpoint[] = "/";
6846 r = guestfs_mount (g, device, mountpoint);
6850 /* TestOutput for command (3) */
6851 char expected[] = "\nResult4\n";
6853 char remotefilename[] = "/test-command";
6856 r = guestfs_upload (g, "test-command", remotefilename);
6861 char path[] = "/test-command";
6864 r = guestfs_chmod (g, 493, path);
6869 char arguments_0[] = "/test-command";
6870 char arguments_1[] = "4";
6871 char *arguments[] = {
6878 r = guestfs_command (g, arguments);
6881 if (strcmp (r, expected) != 0) {
6882 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
6888 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_3");
6892 static int test_command_4_prereq (void)
6894 const char *str = getenv ("SKIP_TEST_COMMAND");
6895 return str && strcmp (str, "1") == 0;
6898 static int test_command_4 (void)
6900 if (! test_command_4_prereq ()) {
6901 /* InitBasicFS for command (4): create ext2 on /dev/sda1 */
6903 char device[] = "/dev/sda";
6904 device[5] = devchar;
6907 r = guestfs_blockdev_setrw (g, device);
6914 r = guestfs_umount_all (g);
6921 r = guestfs_lvm_remove_all (g);
6926 char device[] = "/dev/sda";
6927 device[5] = devchar;
6928 char lines_0[] = ",";
6935 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6940 char fstype[] = "ext2";
6941 char device[] = "/dev/sda1";
6942 device[5] = devchar;
6945 r = guestfs_mkfs (g, fstype, device);
6950 char device[] = "/dev/sda1";
6951 device[5] = devchar;
6952 char mountpoint[] = "/";
6955 r = guestfs_mount (g, device, mountpoint);
6959 /* TestOutput for command (4) */
6960 char expected[] = "\nResult5\n\n";
6962 char remotefilename[] = "/test-command";
6965 r = guestfs_upload (g, "test-command", remotefilename);
6970 char path[] = "/test-command";
6973 r = guestfs_chmod (g, 493, path);
6978 char arguments_0[] = "/test-command";
6979 char arguments_1[] = "5";
6980 char *arguments[] = {
6987 r = guestfs_command (g, arguments);
6990 if (strcmp (r, expected) != 0) {
6991 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
6997 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_4");
7001 static int test_command_5_prereq (void)
7003 const char *str = getenv ("SKIP_TEST_COMMAND");
7004 return str && strcmp (str, "1") == 0;
7007 static int test_command_5 (void)
7009 if (! test_command_5_prereq ()) {
7010 /* InitBasicFS for command (5): create ext2 on /dev/sda1 */
7012 char device[] = "/dev/sda";
7013 device[5] = devchar;
7016 r = guestfs_blockdev_setrw (g, device);
7023 r = guestfs_umount_all (g);
7030 r = guestfs_lvm_remove_all (g);
7035 char device[] = "/dev/sda";
7036 device[5] = devchar;
7037 char lines_0[] = ",";
7044 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7049 char fstype[] = "ext2";
7050 char device[] = "/dev/sda1";
7051 device[5] = devchar;
7054 r = guestfs_mkfs (g, fstype, device);
7059 char device[] = "/dev/sda1";
7060 device[5] = devchar;
7061 char mountpoint[] = "/";
7064 r = guestfs_mount (g, device, mountpoint);
7068 /* TestOutput for command (5) */
7069 char expected[] = "\n\nResult6\n\n";
7071 char remotefilename[] = "/test-command";
7074 r = guestfs_upload (g, "test-command", remotefilename);
7079 char path[] = "/test-command";
7082 r = guestfs_chmod (g, 493, path);
7087 char arguments_0[] = "/test-command";
7088 char arguments_1[] = "6";
7089 char *arguments[] = {
7096 r = guestfs_command (g, arguments);
7099 if (strcmp (r, expected) != 0) {
7100 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7106 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_5");
7110 static int test_command_6_prereq (void)
7112 const char *str = getenv ("SKIP_TEST_COMMAND");
7113 return str && strcmp (str, "1") == 0;
7116 static int test_command_6 (void)
7118 if (! test_command_6_prereq ()) {
7119 /* InitBasicFS for command (6): create ext2 on /dev/sda1 */
7121 char device[] = "/dev/sda";
7122 device[5] = devchar;
7125 r = guestfs_blockdev_setrw (g, device);
7132 r = guestfs_umount_all (g);
7139 r = guestfs_lvm_remove_all (g);
7144 char device[] = "/dev/sda";
7145 device[5] = devchar;
7146 char lines_0[] = ",";
7153 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7158 char fstype[] = "ext2";
7159 char device[] = "/dev/sda1";
7160 device[5] = devchar;
7163 r = guestfs_mkfs (g, fstype, device);
7168 char device[] = "/dev/sda1";
7169 device[5] = devchar;
7170 char mountpoint[] = "/";
7173 r = guestfs_mount (g, device, mountpoint);
7177 /* TestOutput for command (6) */
7178 char expected[] = "";
7180 char remotefilename[] = "/test-command";
7183 r = guestfs_upload (g, "test-command", remotefilename);
7188 char path[] = "/test-command";
7191 r = guestfs_chmod (g, 493, path);
7196 char arguments_0[] = "/test-command";
7197 char arguments_1[] = "7";
7198 char *arguments[] = {
7205 r = guestfs_command (g, arguments);
7208 if (strcmp (r, expected) != 0) {
7209 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7215 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_6");
7219 static int test_command_7_prereq (void)
7221 const char *str = getenv ("SKIP_TEST_COMMAND");
7222 return str && strcmp (str, "1") == 0;
7225 static int test_command_7 (void)
7227 if (! test_command_7_prereq ()) {
7228 /* InitBasicFS for command (7): create ext2 on /dev/sda1 */
7230 char device[] = "/dev/sda";
7231 device[5] = devchar;
7234 r = guestfs_blockdev_setrw (g, device);
7241 r = guestfs_umount_all (g);
7248 r = guestfs_lvm_remove_all (g);
7253 char device[] = "/dev/sda";
7254 device[5] = devchar;
7255 char lines_0[] = ",";
7262 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7267 char fstype[] = "ext2";
7268 char device[] = "/dev/sda1";
7269 device[5] = devchar;
7272 r = guestfs_mkfs (g, fstype, device);
7277 char device[] = "/dev/sda1";
7278 device[5] = devchar;
7279 char mountpoint[] = "/";
7282 r = guestfs_mount (g, device, mountpoint);
7286 /* TestOutput for command (7) */
7287 char expected[] = "\n";
7289 char remotefilename[] = "/test-command";
7292 r = guestfs_upload (g, "test-command", remotefilename);
7297 char path[] = "/test-command";
7300 r = guestfs_chmod (g, 493, path);
7305 char arguments_0[] = "/test-command";
7306 char arguments_1[] = "8";
7307 char *arguments[] = {
7314 r = guestfs_command (g, arguments);
7317 if (strcmp (r, expected) != 0) {
7318 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7324 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_7");
7328 static int test_command_8_prereq (void)
7330 const char *str = getenv ("SKIP_TEST_COMMAND");
7331 return str && strcmp (str, "1") == 0;
7334 static int test_command_8 (void)
7336 if (! test_command_8_prereq ()) {
7337 /* InitBasicFS for command (8): create ext2 on /dev/sda1 */
7339 char device[] = "/dev/sda";
7340 device[5] = devchar;
7343 r = guestfs_blockdev_setrw (g, device);
7350 r = guestfs_umount_all (g);
7357 r = guestfs_lvm_remove_all (g);
7362 char device[] = "/dev/sda";
7363 device[5] = devchar;
7364 char lines_0[] = ",";
7371 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7376 char fstype[] = "ext2";
7377 char device[] = "/dev/sda1";
7378 device[5] = devchar;
7381 r = guestfs_mkfs (g, fstype, device);
7386 char device[] = "/dev/sda1";
7387 device[5] = devchar;
7388 char mountpoint[] = "/";
7391 r = guestfs_mount (g, device, mountpoint);
7395 /* TestOutput for command (8) */
7396 char expected[] = "\n\n";
7398 char remotefilename[] = "/test-command";
7401 r = guestfs_upload (g, "test-command", remotefilename);
7406 char path[] = "/test-command";
7409 r = guestfs_chmod (g, 493, path);
7414 char arguments_0[] = "/test-command";
7415 char arguments_1[] = "9";
7416 char *arguments[] = {
7423 r = guestfs_command (g, arguments);
7426 if (strcmp (r, expected) != 0) {
7427 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
7433 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_8");
7437 static int test_command_9_prereq (void)
7439 const char *str = getenv ("SKIP_TEST_COMMAND");
7440 return str && strcmp (str, "1") == 0;
7443 static int test_command_9 (void)
7445 if (! test_command_9_prereq ()) {
7446 /* InitBasicFS for command (9): create ext2 on /dev/sda1 */
7448 char device[] = "/dev/sda";
7449 device[5] = devchar;
7452 r = guestfs_blockdev_setrw (g, device);
7459 r = guestfs_umount_all (g);
7466 r = guestfs_lvm_remove_all (g);
7471 char device[] = "/dev/sda";
7472 device[5] = devchar;
7473 char lines_0[] = ",";
7480 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7485 char fstype[] = "ext2";
7486 char device[] = "/dev/sda1";
7487 device[5] = devchar;
7490 r = guestfs_mkfs (g, fstype, device);
7495 char device[] = "/dev/sda1";
7496 device[5] = devchar;
7497 char mountpoint[] = "/";
7500 r = guestfs_mount (g, device, mountpoint);
7504 /* TestOutput for command (9) */
7505 char expected[] = "Result10-1\nResult10-2\n";
7507 char remotefilename[] = "/test-command";
7510 r = guestfs_upload (g, "test-command", remotefilename);
7515 char path[] = "/test-command";
7518 r = guestfs_chmod (g, 493, path);
7523 char arguments_0[] = "/test-command";
7524 char arguments_1[] = "10";
7525 char *arguments[] = {
7532 r = guestfs_command (g, arguments);
7535 if (strcmp (r, expected) != 0) {
7536 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
7542 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_9");
7546 static int test_command_10_prereq (void)
7548 const char *str = getenv ("SKIP_TEST_COMMAND");
7549 return str && strcmp (str, "1") == 0;
7552 static int test_command_10 (void)
7554 if (! test_command_10_prereq ()) {
7555 /* InitBasicFS for command (10): create ext2 on /dev/sda1 */
7557 char device[] = "/dev/sda";
7558 device[5] = devchar;
7561 r = guestfs_blockdev_setrw (g, device);
7568 r = guestfs_umount_all (g);
7575 r = guestfs_lvm_remove_all (g);
7580 char device[] = "/dev/sda";
7581 device[5] = devchar;
7582 char lines_0[] = ",";
7589 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7594 char fstype[] = "ext2";
7595 char device[] = "/dev/sda1";
7596 device[5] = devchar;
7599 r = guestfs_mkfs (g, fstype, device);
7604 char device[] = "/dev/sda1";
7605 device[5] = devchar;
7606 char mountpoint[] = "/";
7609 r = guestfs_mount (g, device, mountpoint);
7613 /* TestOutput for command (10) */
7614 char expected[] = "Result11-1\nResult11-2";
7616 char remotefilename[] = "/test-command";
7619 r = guestfs_upload (g, "test-command", remotefilename);
7624 char path[] = "/test-command";
7627 r = guestfs_chmod (g, 493, path);
7632 char arguments_0[] = "/test-command";
7633 char arguments_1[] = "11";
7634 char *arguments[] = {
7641 r = guestfs_command (g, arguments);
7644 if (strcmp (r, expected) != 0) {
7645 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
7651 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_10");
7655 static int test_command_11_prereq (void)
7657 const char *str = getenv ("SKIP_TEST_COMMAND");
7658 return str && strcmp (str, "1") == 0;
7661 static int test_command_11 (void)
7663 if (! test_command_11_prereq ()) {
7664 /* InitBasicFS for command (11): create ext2 on /dev/sda1 */
7666 char device[] = "/dev/sda";
7667 device[5] = devchar;
7670 r = guestfs_blockdev_setrw (g, device);
7677 r = guestfs_umount_all (g);
7684 r = guestfs_lvm_remove_all (g);
7689 char device[] = "/dev/sda";
7690 device[5] = devchar;
7691 char lines_0[] = ",";
7698 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7703 char fstype[] = "ext2";
7704 char device[] = "/dev/sda1";
7705 device[5] = devchar;
7708 r = guestfs_mkfs (g, fstype, device);
7713 char device[] = "/dev/sda1";
7714 device[5] = devchar;
7715 char mountpoint[] = "/";
7718 r = guestfs_mount (g, device, mountpoint);
7722 /* TestLastFail for command (11) */
7724 char remotefilename[] = "/test-command";
7727 r = guestfs_upload (g, "test-command", remotefilename);
7732 char path[] = "/test-command";
7735 r = guestfs_chmod (g, 493, path);
7740 char arguments_0[] = "/test-command";
7741 char *arguments[] = {
7747 r = guestfs_command (g, arguments);
7753 printf ("%s skippedd (reason: test prerequisite)\n", "test_command_11");
7757 static int test_file_0 (void)
7759 /* InitBasicFS for file (0): create ext2 on /dev/sda1 */
7761 char device[] = "/dev/sda";
7762 device[5] = devchar;
7765 r = guestfs_blockdev_setrw (g, device);
7772 r = guestfs_umount_all (g);
7779 r = guestfs_lvm_remove_all (g);
7784 char device[] = "/dev/sda";
7785 device[5] = devchar;
7786 char lines_0[] = ",";
7793 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7798 char fstype[] = "ext2";
7799 char device[] = "/dev/sda1";
7800 device[5] = devchar;
7803 r = guestfs_mkfs (g, fstype, device);
7808 char device[] = "/dev/sda1";
7809 device[5] = devchar;
7810 char mountpoint[] = "/";
7813 r = guestfs_mount (g, device, mountpoint);
7817 /* TestOutput for file (0) */
7818 char expected[] = "empty";
7820 char path[] = "/new";
7823 r = guestfs_touch (g, path);
7828 char path[] = "/new";
7831 r = guestfs_file (g, path);
7834 if (strcmp (r, expected) != 0) {
7835 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
7843 static int test_file_1 (void)
7845 /* InitBasicFS for file (1): create ext2 on /dev/sda1 */
7847 char device[] = "/dev/sda";
7848 device[5] = devchar;
7851 r = guestfs_blockdev_setrw (g, device);
7858 r = guestfs_umount_all (g);
7865 r = guestfs_lvm_remove_all (g);
7870 char device[] = "/dev/sda";
7871 device[5] = devchar;
7872 char lines_0[] = ",";
7879 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7884 char fstype[] = "ext2";
7885 char device[] = "/dev/sda1";
7886 device[5] = devchar;
7889 r = guestfs_mkfs (g, fstype, device);
7894 char device[] = "/dev/sda1";
7895 device[5] = devchar;
7896 char mountpoint[] = "/";
7899 r = guestfs_mount (g, device, mountpoint);
7903 /* TestOutput for file (1) */
7904 char expected[] = "ASCII text";
7906 char path[] = "/new";
7907 char content[] = "some content\n";
7910 r = guestfs_write_file (g, path, content, 0);
7915 char path[] = "/new";
7918 r = guestfs_file (g, path);
7921 if (strcmp (r, expected) != 0) {
7922 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
7930 static int test_file_2 (void)
7932 /* InitBasicFS for file (2): create ext2 on /dev/sda1 */
7934 char device[] = "/dev/sda";
7935 device[5] = devchar;
7938 r = guestfs_blockdev_setrw (g, device);
7945 r = guestfs_umount_all (g);
7952 r = guestfs_lvm_remove_all (g);
7957 char device[] = "/dev/sda";
7958 device[5] = devchar;
7959 char lines_0[] = ",";
7966 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7971 char fstype[] = "ext2";
7972 char device[] = "/dev/sda1";
7973 device[5] = devchar;
7976 r = guestfs_mkfs (g, fstype, device);
7981 char device[] = "/dev/sda1";
7982 device[5] = devchar;
7983 char mountpoint[] = "/";
7986 r = guestfs_mount (g, device, mountpoint);
7990 /* TestLastFail for file (2) */
7992 char path[] = "/nofile";
7995 r = guestfs_file (g, path);
8003 static int test_umount_all_0 (void)
8005 /* InitBasicFS for umount_all (0): create ext2 on /dev/sda1 */
8007 char device[] = "/dev/sda";
8008 device[5] = devchar;
8011 r = guestfs_blockdev_setrw (g, device);
8018 r = guestfs_umount_all (g);
8025 r = guestfs_lvm_remove_all (g);
8030 char device[] = "/dev/sda";
8031 device[5] = devchar;
8032 char lines_0[] = ",";
8039 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8044 char fstype[] = "ext2";
8045 char device[] = "/dev/sda1";
8046 device[5] = devchar;
8049 r = guestfs_mkfs (g, fstype, device);
8054 char device[] = "/dev/sda1";
8055 device[5] = devchar;
8056 char mountpoint[] = "/";
8059 r = guestfs_mount (g, device, mountpoint);
8063 /* TestOutputList for umount_all (0) */
8067 r = guestfs_umount_all (g);
8075 r = guestfs_mounts (g);
8079 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8083 for (i = 0; r[i] != NULL; ++i)
8090 static int test_umount_all_1 (void)
8092 /* InitEmpty for umount_all (1) */
8094 char device[] = "/dev/sda";
8095 device[5] = devchar;
8098 r = guestfs_blockdev_setrw (g, device);
8105 r = guestfs_umount_all (g);
8112 r = guestfs_lvm_remove_all (g);
8116 /* TestOutputList for umount_all (1) */
8118 char device[] = "/dev/sda";
8119 device[5] = devchar;
8120 char lines_0[] = ",10";
8121 char lines_1[] = ",20";
8122 char lines_2[] = ",";
8131 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8136 char fstype[] = "ext2";
8137 char device[] = "/dev/sda1";
8138 device[5] = devchar;
8141 r = guestfs_mkfs (g, fstype, device);
8146 char fstype[] = "ext2";
8147 char device[] = "/dev/sda2";
8148 device[5] = devchar;
8151 r = guestfs_mkfs (g, fstype, device);
8156 char fstype[] = "ext2";
8157 char device[] = "/dev/sda3";
8158 device[5] = devchar;
8161 r = guestfs_mkfs (g, fstype, device);
8166 char device[] = "/dev/sda1";
8167 device[5] = devchar;
8168 char mountpoint[] = "/";
8171 r = guestfs_mount (g, device, mountpoint);
8176 char path[] = "/mp1";
8179 r = guestfs_mkdir (g, path);
8184 char device[] = "/dev/sda2";
8185 device[5] = devchar;
8186 char mountpoint[] = "/mp1";
8189 r = guestfs_mount (g, device, mountpoint);
8194 char path[] = "/mp1/mp2";
8197 r = guestfs_mkdir (g, path);
8202 char device[] = "/dev/sda3";
8203 device[5] = devchar;
8204 char mountpoint[] = "/mp1/mp2";
8207 r = guestfs_mount (g, device, mountpoint);
8212 char path[] = "/mp1/mp2/mp3";
8215 r = guestfs_mkdir (g, path);
8222 r = guestfs_umount_all (g);
8230 r = guestfs_mounts (g);
8234 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8238 for (i = 0; r[i] != NULL; ++i)
8245 static int test_mounts_0 (void)
8247 /* InitBasicFS for mounts (0): create ext2 on /dev/sda1 */
8249 char device[] = "/dev/sda";
8250 device[5] = devchar;
8253 r = guestfs_blockdev_setrw (g, device);
8260 r = guestfs_umount_all (g);
8267 r = guestfs_lvm_remove_all (g);
8272 char device[] = "/dev/sda";
8273 device[5] = devchar;
8274 char lines_0[] = ",";
8281 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8286 char fstype[] = "ext2";
8287 char device[] = "/dev/sda1";
8288 device[5] = devchar;
8291 r = guestfs_mkfs (g, fstype, device);
8296 char device[] = "/dev/sda1";
8297 device[5] = devchar;
8298 char mountpoint[] = "/";
8301 r = guestfs_mount (g, device, mountpoint);
8305 /* TestOutputList for mounts (0) */
8310 r = guestfs_mounts (g);
8314 fprintf (stderr, "test_mounts_0: short list returned from command\n");
8319 char expected[] = "/dev/sda1";
8320 expected[5] = devchar;
8321 if (strcmp (r[0], expected) != 0) {
8322 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8327 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8331 for (i = 0; r[i] != NULL; ++i)
8338 static int test_umount_0 (void)
8340 /* InitEmpty for umount (0) */
8342 char device[] = "/dev/sda";
8343 device[5] = devchar;
8346 r = guestfs_blockdev_setrw (g, device);
8353 r = guestfs_umount_all (g);
8360 r = guestfs_lvm_remove_all (g);
8364 /* TestOutputList for umount (0) */
8366 char device[] = "/dev/sda";
8367 device[5] = devchar;
8368 char lines_0[] = ",";
8375 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8380 char fstype[] = "ext2";
8381 char device[] = "/dev/sda1";
8382 device[5] = devchar;
8385 r = guestfs_mkfs (g, fstype, device);
8390 char device[] = "/dev/sda1";
8391 device[5] = devchar;
8392 char mountpoint[] = "/";
8395 r = guestfs_mount (g, device, mountpoint);
8403 r = guestfs_mounts (g);
8407 fprintf (stderr, "test_umount_0: short list returned from command\n");
8412 char expected[] = "/dev/sda1";
8413 expected[5] = devchar;
8414 if (strcmp (r[0], expected) != 0) {
8415 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8420 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
8424 for (i = 0; r[i] != NULL; ++i)
8431 static int test_umount_1 (void)
8433 /* InitEmpty for umount (1) */
8435 char device[] = "/dev/sda";
8436 device[5] = devchar;
8439 r = guestfs_blockdev_setrw (g, device);
8446 r = guestfs_umount_all (g);
8453 r = guestfs_lvm_remove_all (g);
8457 /* TestOutputList for umount (1) */
8459 char device[] = "/dev/sda";
8460 device[5] = devchar;
8461 char lines_0[] = ",";
8468 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8473 char fstype[] = "ext2";
8474 char device[] = "/dev/sda1";
8475 device[5] = devchar;
8478 r = guestfs_mkfs (g, fstype, device);
8483 char device[] = "/dev/sda1";
8484 device[5] = devchar;
8485 char mountpoint[] = "/";
8488 r = guestfs_mount (g, device, mountpoint);
8493 char pathordevice[] = "/";
8496 r = guestfs_umount (g, pathordevice);
8504 r = guestfs_mounts (g);
8508 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
8512 for (i = 0; r[i] != NULL; ++i)
8519 static int test_write_file_0 (void)
8521 /* InitBasicFS for write_file (0): create ext2 on /dev/sda1 */
8523 char device[] = "/dev/sda";
8524 device[5] = devchar;
8527 r = guestfs_blockdev_setrw (g, device);
8534 r = guestfs_umount_all (g);
8541 r = guestfs_lvm_remove_all (g);
8546 char device[] = "/dev/sda";
8547 device[5] = devchar;
8548 char lines_0[] = ",";
8555 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8560 char fstype[] = "ext2";
8561 char device[] = "/dev/sda1";
8562 device[5] = devchar;
8565 r = guestfs_mkfs (g, fstype, device);
8570 char device[] = "/dev/sda1";
8571 device[5] = devchar;
8572 char mountpoint[] = "/";
8575 r = guestfs_mount (g, device, mountpoint);
8579 /* TestOutput for write_file (0) */
8580 char expected[] = "new file contents";
8582 char path[] = "/new";
8583 char content[] = "new file contents";
8586 r = guestfs_write_file (g, path, content, 0);
8591 char path[] = "/new";
8594 r = guestfs_cat (g, path);
8597 if (strcmp (r, expected) != 0) {
8598 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8606 static int test_write_file_1 (void)
8608 /* InitBasicFS for write_file (1): create ext2 on /dev/sda1 */
8610 char device[] = "/dev/sda";
8611 device[5] = devchar;
8614 r = guestfs_blockdev_setrw (g, device);
8621 r = guestfs_umount_all (g);
8628 r = guestfs_lvm_remove_all (g);
8633 char device[] = "/dev/sda";
8634 device[5] = devchar;
8635 char lines_0[] = ",";
8642 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8647 char fstype[] = "ext2";
8648 char device[] = "/dev/sda1";
8649 device[5] = devchar;
8652 r = guestfs_mkfs (g, fstype, device);
8657 char device[] = "/dev/sda1";
8658 device[5] = devchar;
8659 char mountpoint[] = "/";
8662 r = guestfs_mount (g, device, mountpoint);
8666 /* TestOutput for write_file (1) */
8667 char expected[] = "\nnew file contents\n";
8669 char path[] = "/new";
8670 char content[] = "\nnew file contents\n";
8673 r = guestfs_write_file (g, path, content, 0);
8678 char path[] = "/new";
8681 r = guestfs_cat (g, path);
8684 if (strcmp (r, expected) != 0) {
8685 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8693 static int test_write_file_2 (void)
8695 /* InitBasicFS for write_file (2): create ext2 on /dev/sda1 */
8697 char device[] = "/dev/sda";
8698 device[5] = devchar;
8701 r = guestfs_blockdev_setrw (g, device);
8708 r = guestfs_umount_all (g);
8715 r = guestfs_lvm_remove_all (g);
8720 char device[] = "/dev/sda";
8721 device[5] = devchar;
8722 char lines_0[] = ",";
8729 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8734 char fstype[] = "ext2";
8735 char device[] = "/dev/sda1";
8736 device[5] = devchar;
8739 r = guestfs_mkfs (g, fstype, device);
8744 char device[] = "/dev/sda1";
8745 device[5] = devchar;
8746 char mountpoint[] = "/";
8749 r = guestfs_mount (g, device, mountpoint);
8753 /* TestOutput for write_file (2) */
8754 char expected[] = "\n\n";
8756 char path[] = "/new";
8757 char content[] = "\n\n";
8760 r = guestfs_write_file (g, path, content, 0);
8765 char path[] = "/new";
8768 r = guestfs_cat (g, path);
8771 if (strcmp (r, expected) != 0) {
8772 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
8780 static int test_write_file_3 (void)
8782 /* InitBasicFS for write_file (3): create ext2 on /dev/sda1 */
8784 char device[] = "/dev/sda";
8785 device[5] = devchar;
8788 r = guestfs_blockdev_setrw (g, device);
8795 r = guestfs_umount_all (g);
8802 r = guestfs_lvm_remove_all (g);
8807 char device[] = "/dev/sda";
8808 device[5] = devchar;
8809 char lines_0[] = ",";
8816 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8821 char fstype[] = "ext2";
8822 char device[] = "/dev/sda1";
8823 device[5] = devchar;
8826 r = guestfs_mkfs (g, fstype, device);
8831 char device[] = "/dev/sda1";
8832 device[5] = devchar;
8833 char mountpoint[] = "/";
8836 r = guestfs_mount (g, device, mountpoint);
8840 /* TestOutput for write_file (3) */
8841 char expected[] = "";
8843 char path[] = "/new";
8844 char content[] = "";
8847 r = guestfs_write_file (g, path, content, 0);
8852 char path[] = "/new";
8855 r = guestfs_cat (g, path);
8858 if (strcmp (r, expected) != 0) {
8859 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
8867 static int test_write_file_4 (void)
8869 /* InitBasicFS for write_file (4): create ext2 on /dev/sda1 */
8871 char device[] = "/dev/sda";
8872 device[5] = devchar;
8875 r = guestfs_blockdev_setrw (g, device);
8882 r = guestfs_umount_all (g);
8889 r = guestfs_lvm_remove_all (g);
8894 char device[] = "/dev/sda";
8895 device[5] = devchar;
8896 char lines_0[] = ",";
8903 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8908 char fstype[] = "ext2";
8909 char device[] = "/dev/sda1";
8910 device[5] = devchar;
8913 r = guestfs_mkfs (g, fstype, device);
8918 char device[] = "/dev/sda1";
8919 device[5] = devchar;
8920 char mountpoint[] = "/";
8923 r = guestfs_mount (g, device, mountpoint);
8927 /* TestOutput for write_file (4) */
8928 char expected[] = "\n\n\n";
8930 char path[] = "/new";
8931 char content[] = "\n\n\n";
8934 r = guestfs_write_file (g, path, content, 0);
8939 char path[] = "/new";
8942 r = guestfs_cat (g, path);
8945 if (strcmp (r, expected) != 0) {
8946 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
8954 static int test_write_file_5 (void)
8956 /* InitBasicFS for write_file (5): create ext2 on /dev/sda1 */
8958 char device[] = "/dev/sda";
8959 device[5] = devchar;
8962 r = guestfs_blockdev_setrw (g, device);
8969 r = guestfs_umount_all (g);
8976 r = guestfs_lvm_remove_all (g);
8981 char device[] = "/dev/sda";
8982 device[5] = devchar;
8983 char lines_0[] = ",";
8990 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8995 char fstype[] = "ext2";
8996 char device[] = "/dev/sda1";
8997 device[5] = devchar;
9000 r = guestfs_mkfs (g, fstype, device);
9005 char device[] = "/dev/sda1";
9006 device[5] = devchar;
9007 char mountpoint[] = "/";
9010 r = guestfs_mount (g, device, mountpoint);
9014 /* TestOutput for write_file (5) */
9015 char expected[] = "\n";
9017 char path[] = "/new";
9018 char content[] = "\n";
9021 r = guestfs_write_file (g, path, content, 0);
9026 char path[] = "/new";
9029 r = guestfs_cat (g, path);
9032 if (strcmp (r, expected) != 0) {
9033 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9041 static int test_mkfs_0 (void)
9043 /* InitEmpty for mkfs (0) */
9045 char device[] = "/dev/sda";
9046 device[5] = devchar;
9049 r = guestfs_blockdev_setrw (g, device);
9056 r = guestfs_umount_all (g);
9063 r = guestfs_lvm_remove_all (g);
9067 /* TestOutput for mkfs (0) */
9068 char expected[] = "new file contents";
9070 char device[] = "/dev/sda";
9071 device[5] = devchar;
9072 char lines_0[] = ",";
9079 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9084 char fstype[] = "ext2";
9085 char device[] = "/dev/sda1";
9086 device[5] = devchar;
9089 r = guestfs_mkfs (g, fstype, device);
9094 char device[] = "/dev/sda1";
9095 device[5] = devchar;
9096 char mountpoint[] = "/";
9099 r = guestfs_mount (g, device, mountpoint);
9104 char path[] = "/new";
9105 char content[] = "new file contents";
9108 r = guestfs_write_file (g, path, content, 0);
9113 char path[] = "/new";
9116 r = guestfs_cat (g, path);
9119 if (strcmp (r, expected) != 0) {
9120 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9128 static int test_lvcreate_0 (void)
9130 /* InitEmpty for lvcreate (0) */
9132 char device[] = "/dev/sda";
9133 device[5] = devchar;
9136 r = guestfs_blockdev_setrw (g, device);
9143 r = guestfs_umount_all (g);
9150 r = guestfs_lvm_remove_all (g);
9154 /* TestOutputList for lvcreate (0) */
9156 char device[] = "/dev/sda";
9157 device[5] = devchar;
9158 char lines_0[] = ",10";
9159 char lines_1[] = ",20";
9160 char lines_2[] = ",";
9169 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9174 char device[] = "/dev/sda1";
9175 device[5] = devchar;
9178 r = guestfs_pvcreate (g, device);
9183 char device[] = "/dev/sda2";
9184 device[5] = devchar;
9187 r = guestfs_pvcreate (g, device);
9192 char device[] = "/dev/sda3";
9193 device[5] = devchar;
9196 r = guestfs_pvcreate (g, device);
9201 char volgroup[] = "VG1";
9202 char physvols_0[] = "/dev/sda1";
9203 physvols_0[5] = devchar;
9204 char physvols_1[] = "/dev/sda2";
9205 physvols_1[5] = devchar;
9206 char *physvols[] = {
9213 r = guestfs_vgcreate (g, volgroup, physvols);
9218 char volgroup[] = "VG2";
9219 char physvols_0[] = "/dev/sda3";
9220 physvols_0[5] = devchar;
9221 char *physvols[] = {
9227 r = guestfs_vgcreate (g, volgroup, physvols);
9232 char logvol[] = "LV1";
9233 char volgroup[] = "VG1";
9236 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9241 char logvol[] = "LV2";
9242 char volgroup[] = "VG1";
9245 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9250 char logvol[] = "LV3";
9251 char volgroup[] = "VG2";
9254 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9259 char logvol[] = "LV4";
9260 char volgroup[] = "VG2";
9263 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9268 char logvol[] = "LV5";
9269 char volgroup[] = "VG2";
9272 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9280 r = guestfs_lvs (g);
9284 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9289 char expected[] = "/dev/VG1/LV1";
9290 if (strcmp (r[0], expected) != 0) {
9291 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9296 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9301 char expected[] = "/dev/VG1/LV2";
9302 if (strcmp (r[1], expected) != 0) {
9303 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9308 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9313 char expected[] = "/dev/VG2/LV3";
9314 if (strcmp (r[2], expected) != 0) {
9315 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9320 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9325 char expected[] = "/dev/VG2/LV4";
9326 if (strcmp (r[3], expected) != 0) {
9327 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9332 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9337 char expected[] = "/dev/VG2/LV5";
9338 if (strcmp (r[4], expected) != 0) {
9339 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9344 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9348 for (i = 0; r[i] != NULL; ++i)
9355 static int test_vgcreate_0 (void)
9357 /* InitEmpty for vgcreate (0) */
9359 char device[] = "/dev/sda";
9360 device[5] = devchar;
9363 r = guestfs_blockdev_setrw (g, device);
9370 r = guestfs_umount_all (g);
9377 r = guestfs_lvm_remove_all (g);
9381 /* TestOutputList for vgcreate (0) */
9383 char device[] = "/dev/sda";
9384 device[5] = devchar;
9385 char lines_0[] = ",10";
9386 char lines_1[] = ",20";
9387 char lines_2[] = ",";
9396 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9401 char device[] = "/dev/sda1";
9402 device[5] = devchar;
9405 r = guestfs_pvcreate (g, device);
9410 char device[] = "/dev/sda2";
9411 device[5] = devchar;
9414 r = guestfs_pvcreate (g, device);
9419 char device[] = "/dev/sda3";
9420 device[5] = devchar;
9423 r = guestfs_pvcreate (g, device);
9428 char volgroup[] = "VG1";
9429 char physvols_0[] = "/dev/sda1";
9430 physvols_0[5] = devchar;
9431 char physvols_1[] = "/dev/sda2";
9432 physvols_1[5] = devchar;
9433 char *physvols[] = {
9440 r = guestfs_vgcreate (g, volgroup, physvols);
9445 char volgroup[] = "VG2";
9446 char physvols_0[] = "/dev/sda3";
9447 physvols_0[5] = devchar;
9448 char *physvols[] = {
9454 r = guestfs_vgcreate (g, volgroup, physvols);
9462 r = guestfs_vgs (g);
9466 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9471 char expected[] = "VG1";
9472 if (strcmp (r[0], expected) != 0) {
9473 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9478 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9483 char expected[] = "VG2";
9484 if (strcmp (r[1], expected) != 0) {
9485 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9490 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
9494 for (i = 0; r[i] != NULL; ++i)
9501 static int test_pvcreate_0 (void)
9503 /* InitEmpty for pvcreate (0) */
9505 char device[] = "/dev/sda";
9506 device[5] = devchar;
9509 r = guestfs_blockdev_setrw (g, device);
9516 r = guestfs_umount_all (g);
9523 r = guestfs_lvm_remove_all (g);
9527 /* TestOutputList for pvcreate (0) */
9529 char device[] = "/dev/sda";
9530 device[5] = devchar;
9531 char lines_0[] = ",10";
9532 char lines_1[] = ",20";
9533 char lines_2[] = ",";
9542 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9547 char device[] = "/dev/sda1";
9548 device[5] = devchar;
9551 r = guestfs_pvcreate (g, device);
9556 char device[] = "/dev/sda2";
9557 device[5] = devchar;
9560 r = guestfs_pvcreate (g, device);
9565 char device[] = "/dev/sda3";
9566 device[5] = devchar;
9569 r = guestfs_pvcreate (g, device);
9577 r = guestfs_pvs (g);
9581 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9586 char expected[] = "/dev/sda1";
9587 expected[5] = devchar;
9588 if (strcmp (r[0], expected) != 0) {
9589 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9594 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9599 char expected[] = "/dev/sda2";
9600 expected[5] = devchar;
9601 if (strcmp (r[1], expected) != 0) {
9602 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9607 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9612 char expected[] = "/dev/sda3";
9613 expected[5] = devchar;
9614 if (strcmp (r[2], expected) != 0) {
9615 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9620 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
9624 for (i = 0; r[i] != NULL; ++i)
9631 static int test_is_dir_0 (void)
9633 /* InitBasicFS for is_dir (0): create ext2 on /dev/sda1 */
9635 char device[] = "/dev/sda";
9636 device[5] = devchar;
9639 r = guestfs_blockdev_setrw (g, device);
9646 r = guestfs_umount_all (g);
9653 r = guestfs_lvm_remove_all (g);
9658 char device[] = "/dev/sda";
9659 device[5] = devchar;
9660 char lines_0[] = ",";
9667 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9672 char fstype[] = "ext2";
9673 char device[] = "/dev/sda1";
9674 device[5] = devchar;
9677 r = guestfs_mkfs (g, fstype, device);
9682 char device[] = "/dev/sda1";
9683 device[5] = devchar;
9684 char mountpoint[] = "/";
9687 r = guestfs_mount (g, device, mountpoint);
9691 /* TestOutputFalse for is_dir (0) */
9693 char path[] = "/new";
9696 r = guestfs_touch (g, path);
9701 char path[] = "/new";
9704 r = guestfs_is_dir (g, path);
9708 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
9715 static int test_is_dir_1 (void)
9717 /* InitBasicFS for is_dir (1): create ext2 on /dev/sda1 */
9719 char device[] = "/dev/sda";
9720 device[5] = devchar;
9723 r = guestfs_blockdev_setrw (g, device);
9730 r = guestfs_umount_all (g);
9737 r = guestfs_lvm_remove_all (g);
9742 char device[] = "/dev/sda";
9743 device[5] = devchar;
9744 char lines_0[] = ",";
9751 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9756 char fstype[] = "ext2";
9757 char device[] = "/dev/sda1";
9758 device[5] = devchar;
9761 r = guestfs_mkfs (g, fstype, device);
9766 char device[] = "/dev/sda1";
9767 device[5] = devchar;
9768 char mountpoint[] = "/";
9771 r = guestfs_mount (g, device, mountpoint);
9775 /* TestOutputTrue for is_dir (1) */
9777 char path[] = "/new";
9780 r = guestfs_mkdir (g, path);
9785 char path[] = "/new";
9788 r = guestfs_is_dir (g, path);
9792 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
9799 static int test_is_file_0 (void)
9801 /* InitBasicFS for is_file (0): create ext2 on /dev/sda1 */
9803 char device[] = "/dev/sda";
9804 device[5] = devchar;
9807 r = guestfs_blockdev_setrw (g, device);
9814 r = guestfs_umount_all (g);
9821 r = guestfs_lvm_remove_all (g);
9826 char device[] = "/dev/sda";
9827 device[5] = devchar;
9828 char lines_0[] = ",";
9835 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9840 char fstype[] = "ext2";
9841 char device[] = "/dev/sda1";
9842 device[5] = devchar;
9845 r = guestfs_mkfs (g, fstype, device);
9850 char device[] = "/dev/sda1";
9851 device[5] = devchar;
9852 char mountpoint[] = "/";
9855 r = guestfs_mount (g, device, mountpoint);
9859 /* TestOutputTrue for is_file (0) */
9861 char path[] = "/new";
9864 r = guestfs_touch (g, path);
9869 char path[] = "/new";
9872 r = guestfs_is_file (g, path);
9876 fprintf (stderr, "test_is_file_0: expected true, got false\n");
9883 static int test_is_file_1 (void)
9885 /* InitBasicFS for is_file (1): create ext2 on /dev/sda1 */
9887 char device[] = "/dev/sda";
9888 device[5] = devchar;
9891 r = guestfs_blockdev_setrw (g, device);
9898 r = guestfs_umount_all (g);
9905 r = guestfs_lvm_remove_all (g);
9910 char device[] = "/dev/sda";
9911 device[5] = devchar;
9912 char lines_0[] = ",";
9919 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9924 char fstype[] = "ext2";
9925 char device[] = "/dev/sda1";
9926 device[5] = devchar;
9929 r = guestfs_mkfs (g, fstype, device);
9934 char device[] = "/dev/sda1";
9935 device[5] = devchar;
9936 char mountpoint[] = "/";
9939 r = guestfs_mount (g, device, mountpoint);
9943 /* TestOutputFalse for is_file (1) */
9945 char path[] = "/new";
9948 r = guestfs_mkdir (g, path);
9953 char path[] = "/new";
9956 r = guestfs_is_file (g, path);
9960 fprintf (stderr, "test_is_file_1: expected false, got true\n");
9967 static int test_exists_0 (void)
9969 /* InitBasicFS for exists (0): create ext2 on /dev/sda1 */
9971 char device[] = "/dev/sda";
9972 device[5] = devchar;
9975 r = guestfs_blockdev_setrw (g, device);
9982 r = guestfs_umount_all (g);
9989 r = guestfs_lvm_remove_all (g);
9994 char device[] = "/dev/sda";
9995 device[5] = devchar;
9996 char lines_0[] = ",";
10002 suppress_error = 0;
10003 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10008 char fstype[] = "ext2";
10009 char device[] = "/dev/sda1";
10010 device[5] = devchar;
10012 suppress_error = 0;
10013 r = guestfs_mkfs (g, fstype, device);
10018 char device[] = "/dev/sda1";
10019 device[5] = devchar;
10020 char mountpoint[] = "/";
10022 suppress_error = 0;
10023 r = guestfs_mount (g, device, mountpoint);
10027 /* TestOutputTrue for exists (0) */
10029 char path[] = "/new";
10031 suppress_error = 0;
10032 r = guestfs_touch (g, path);
10037 char path[] = "/new";
10039 suppress_error = 0;
10040 r = guestfs_exists (g, path);
10044 fprintf (stderr, "test_exists_0: expected true, got false\n");
10051 static int test_exists_1 (void)
10053 /* InitBasicFS for exists (1): create ext2 on /dev/sda1 */
10055 char device[] = "/dev/sda";
10056 device[5] = devchar;
10058 suppress_error = 0;
10059 r = guestfs_blockdev_setrw (g, device);
10065 suppress_error = 0;
10066 r = guestfs_umount_all (g);
10072 suppress_error = 0;
10073 r = guestfs_lvm_remove_all (g);
10078 char device[] = "/dev/sda";
10079 device[5] = devchar;
10080 char lines_0[] = ",";
10086 suppress_error = 0;
10087 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10092 char fstype[] = "ext2";
10093 char device[] = "/dev/sda1";
10094 device[5] = devchar;
10096 suppress_error = 0;
10097 r = guestfs_mkfs (g, fstype, device);
10102 char device[] = "/dev/sda1";
10103 device[5] = devchar;
10104 char mountpoint[] = "/";
10106 suppress_error = 0;
10107 r = guestfs_mount (g, device, mountpoint);
10111 /* TestOutputTrue for exists (1) */
10113 char path[] = "/new";
10115 suppress_error = 0;
10116 r = guestfs_mkdir (g, path);
10121 char path[] = "/new";
10123 suppress_error = 0;
10124 r = guestfs_exists (g, path);
10128 fprintf (stderr, "test_exists_1: expected true, got false\n");
10135 static int test_mkdir_p_0 (void)
10137 /* InitBasicFS for mkdir_p (0): create ext2 on /dev/sda1 */
10139 char device[] = "/dev/sda";
10140 device[5] = devchar;
10142 suppress_error = 0;
10143 r = guestfs_blockdev_setrw (g, device);
10149 suppress_error = 0;
10150 r = guestfs_umount_all (g);
10156 suppress_error = 0;
10157 r = guestfs_lvm_remove_all (g);
10162 char device[] = "/dev/sda";
10163 device[5] = devchar;
10164 char lines_0[] = ",";
10170 suppress_error = 0;
10171 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10176 char fstype[] = "ext2";
10177 char device[] = "/dev/sda1";
10178 device[5] = devchar;
10180 suppress_error = 0;
10181 r = guestfs_mkfs (g, fstype, device);
10186 char device[] = "/dev/sda1";
10187 device[5] = devchar;
10188 char mountpoint[] = "/";
10190 suppress_error = 0;
10191 r = guestfs_mount (g, device, mountpoint);
10195 /* TestOutputTrue for mkdir_p (0) */
10197 char path[] = "/new/foo/bar";
10199 suppress_error = 0;
10200 r = guestfs_mkdir_p (g, path);
10205 char path[] = "/new/foo/bar";
10207 suppress_error = 0;
10208 r = guestfs_is_dir (g, path);
10212 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10219 static int test_mkdir_p_1 (void)
10221 /* InitBasicFS for mkdir_p (1): create ext2 on /dev/sda1 */
10223 char device[] = "/dev/sda";
10224 device[5] = devchar;
10226 suppress_error = 0;
10227 r = guestfs_blockdev_setrw (g, device);
10233 suppress_error = 0;
10234 r = guestfs_umount_all (g);
10240 suppress_error = 0;
10241 r = guestfs_lvm_remove_all (g);
10246 char device[] = "/dev/sda";
10247 device[5] = devchar;
10248 char lines_0[] = ",";
10254 suppress_error = 0;
10255 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10260 char fstype[] = "ext2";
10261 char device[] = "/dev/sda1";
10262 device[5] = devchar;
10264 suppress_error = 0;
10265 r = guestfs_mkfs (g, fstype, device);
10270 char device[] = "/dev/sda1";
10271 device[5] = devchar;
10272 char mountpoint[] = "/";
10274 suppress_error = 0;
10275 r = guestfs_mount (g, device, mountpoint);
10279 /* TestOutputTrue for mkdir_p (1) */
10281 char path[] = "/new/foo/bar";
10283 suppress_error = 0;
10284 r = guestfs_mkdir_p (g, path);
10289 char path[] = "/new/foo";
10291 suppress_error = 0;
10292 r = guestfs_is_dir (g, path);
10296 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10303 static int test_mkdir_p_2 (void)
10305 /* InitBasicFS for mkdir_p (2): create ext2 on /dev/sda1 */
10307 char device[] = "/dev/sda";
10308 device[5] = devchar;
10310 suppress_error = 0;
10311 r = guestfs_blockdev_setrw (g, device);
10317 suppress_error = 0;
10318 r = guestfs_umount_all (g);
10324 suppress_error = 0;
10325 r = guestfs_lvm_remove_all (g);
10330 char device[] = "/dev/sda";
10331 device[5] = devchar;
10332 char lines_0[] = ",";
10338 suppress_error = 0;
10339 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10344 char fstype[] = "ext2";
10345 char device[] = "/dev/sda1";
10346 device[5] = devchar;
10348 suppress_error = 0;
10349 r = guestfs_mkfs (g, fstype, device);
10354 char device[] = "/dev/sda1";
10355 device[5] = devchar;
10356 char mountpoint[] = "/";
10358 suppress_error = 0;
10359 r = guestfs_mount (g, device, mountpoint);
10363 /* TestOutputTrue for mkdir_p (2) */
10365 char path[] = "/new/foo/bar";
10367 suppress_error = 0;
10368 r = guestfs_mkdir_p (g, path);
10373 char path[] = "/new";
10375 suppress_error = 0;
10376 r = guestfs_is_dir (g, path);
10380 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
10387 static int test_mkdir_0 (void)
10389 /* InitBasicFS for mkdir (0): create ext2 on /dev/sda1 */
10391 char device[] = "/dev/sda";
10392 device[5] = devchar;
10394 suppress_error = 0;
10395 r = guestfs_blockdev_setrw (g, device);
10401 suppress_error = 0;
10402 r = guestfs_umount_all (g);
10408 suppress_error = 0;
10409 r = guestfs_lvm_remove_all (g);
10414 char device[] = "/dev/sda";
10415 device[5] = devchar;
10416 char lines_0[] = ",";
10422 suppress_error = 0;
10423 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10428 char fstype[] = "ext2";
10429 char device[] = "/dev/sda1";
10430 device[5] = devchar;
10432 suppress_error = 0;
10433 r = guestfs_mkfs (g, fstype, device);
10438 char device[] = "/dev/sda1";
10439 device[5] = devchar;
10440 char mountpoint[] = "/";
10442 suppress_error = 0;
10443 r = guestfs_mount (g, device, mountpoint);
10447 /* TestOutputTrue for mkdir (0) */
10449 char path[] = "/new";
10451 suppress_error = 0;
10452 r = guestfs_mkdir (g, path);
10457 char path[] = "/new";
10459 suppress_error = 0;
10460 r = guestfs_is_dir (g, path);
10464 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
10471 static int test_mkdir_1 (void)
10473 /* InitBasicFS for mkdir (1): create ext2 on /dev/sda1 */
10475 char device[] = "/dev/sda";
10476 device[5] = devchar;
10478 suppress_error = 0;
10479 r = guestfs_blockdev_setrw (g, device);
10485 suppress_error = 0;
10486 r = guestfs_umount_all (g);
10492 suppress_error = 0;
10493 r = guestfs_lvm_remove_all (g);
10498 char device[] = "/dev/sda";
10499 device[5] = devchar;
10500 char lines_0[] = ",";
10506 suppress_error = 0;
10507 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10512 char fstype[] = "ext2";
10513 char device[] = "/dev/sda1";
10514 device[5] = devchar;
10516 suppress_error = 0;
10517 r = guestfs_mkfs (g, fstype, device);
10522 char device[] = "/dev/sda1";
10523 device[5] = devchar;
10524 char mountpoint[] = "/";
10526 suppress_error = 0;
10527 r = guestfs_mount (g, device, mountpoint);
10531 /* TestLastFail for mkdir (1) */
10533 char path[] = "/new/foo/bar";
10535 suppress_error = 1;
10536 r = guestfs_mkdir (g, path);
10543 static int test_rm_rf_0 (void)
10545 /* InitBasicFS for rm_rf (0): create ext2 on /dev/sda1 */
10547 char device[] = "/dev/sda";
10548 device[5] = devchar;
10550 suppress_error = 0;
10551 r = guestfs_blockdev_setrw (g, device);
10557 suppress_error = 0;
10558 r = guestfs_umount_all (g);
10564 suppress_error = 0;
10565 r = guestfs_lvm_remove_all (g);
10570 char device[] = "/dev/sda";
10571 device[5] = devchar;
10572 char lines_0[] = ",";
10578 suppress_error = 0;
10579 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10584 char fstype[] = "ext2";
10585 char device[] = "/dev/sda1";
10586 device[5] = devchar;
10588 suppress_error = 0;
10589 r = guestfs_mkfs (g, fstype, device);
10594 char device[] = "/dev/sda1";
10595 device[5] = devchar;
10596 char mountpoint[] = "/";
10598 suppress_error = 0;
10599 r = guestfs_mount (g, device, mountpoint);
10603 /* TestOutputFalse for rm_rf (0) */
10605 char path[] = "/new";
10607 suppress_error = 0;
10608 r = guestfs_mkdir (g, path);
10613 char path[] = "/new/foo";
10615 suppress_error = 0;
10616 r = guestfs_mkdir (g, path);
10621 char path[] = "/new/foo/bar";
10623 suppress_error = 0;
10624 r = guestfs_touch (g, path);
10629 char path[] = "/new";
10631 suppress_error = 0;
10632 r = guestfs_rm_rf (g, path);
10637 char path[] = "/new";
10639 suppress_error = 0;
10640 r = guestfs_exists (g, path);
10644 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
10651 static int test_rmdir_0 (void)
10653 /* InitBasicFS for rmdir (0): create ext2 on /dev/sda1 */
10655 char device[] = "/dev/sda";
10656 device[5] = devchar;
10658 suppress_error = 0;
10659 r = guestfs_blockdev_setrw (g, device);
10665 suppress_error = 0;
10666 r = guestfs_umount_all (g);
10672 suppress_error = 0;
10673 r = guestfs_lvm_remove_all (g);
10678 char device[] = "/dev/sda";
10679 device[5] = devchar;
10680 char lines_0[] = ",";
10686 suppress_error = 0;
10687 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10692 char fstype[] = "ext2";
10693 char device[] = "/dev/sda1";
10694 device[5] = devchar;
10696 suppress_error = 0;
10697 r = guestfs_mkfs (g, fstype, device);
10702 char device[] = "/dev/sda1";
10703 device[5] = devchar;
10704 char mountpoint[] = "/";
10706 suppress_error = 0;
10707 r = guestfs_mount (g, device, mountpoint);
10711 /* TestRun for rmdir (0) */
10713 char path[] = "/new";
10715 suppress_error = 0;
10716 r = guestfs_mkdir (g, path);
10721 char path[] = "/new";
10723 suppress_error = 0;
10724 r = guestfs_rmdir (g, path);
10731 static int test_rmdir_1 (void)
10733 /* InitBasicFS for rmdir (1): create ext2 on /dev/sda1 */
10735 char device[] = "/dev/sda";
10736 device[5] = devchar;
10738 suppress_error = 0;
10739 r = guestfs_blockdev_setrw (g, device);
10745 suppress_error = 0;
10746 r = guestfs_umount_all (g);
10752 suppress_error = 0;
10753 r = guestfs_lvm_remove_all (g);
10758 char device[] = "/dev/sda";
10759 device[5] = devchar;
10760 char lines_0[] = ",";
10766 suppress_error = 0;
10767 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10772 char fstype[] = "ext2";
10773 char device[] = "/dev/sda1";
10774 device[5] = devchar;
10776 suppress_error = 0;
10777 r = guestfs_mkfs (g, fstype, device);
10782 char device[] = "/dev/sda1";
10783 device[5] = devchar;
10784 char mountpoint[] = "/";
10786 suppress_error = 0;
10787 r = guestfs_mount (g, device, mountpoint);
10791 /* TestLastFail for rmdir (1) */
10793 char path[] = "/new";
10795 suppress_error = 1;
10796 r = guestfs_rmdir (g, path);
10803 static int test_rmdir_2 (void)
10805 /* InitBasicFS for rmdir (2): create ext2 on /dev/sda1 */
10807 char device[] = "/dev/sda";
10808 device[5] = devchar;
10810 suppress_error = 0;
10811 r = guestfs_blockdev_setrw (g, device);
10817 suppress_error = 0;
10818 r = guestfs_umount_all (g);
10824 suppress_error = 0;
10825 r = guestfs_lvm_remove_all (g);
10830 char device[] = "/dev/sda";
10831 device[5] = devchar;
10832 char lines_0[] = ",";
10838 suppress_error = 0;
10839 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10844 char fstype[] = "ext2";
10845 char device[] = "/dev/sda1";
10846 device[5] = devchar;
10848 suppress_error = 0;
10849 r = guestfs_mkfs (g, fstype, device);
10854 char device[] = "/dev/sda1";
10855 device[5] = devchar;
10856 char mountpoint[] = "/";
10858 suppress_error = 0;
10859 r = guestfs_mount (g, device, mountpoint);
10863 /* TestLastFail for rmdir (2) */
10865 char path[] = "/new";
10867 suppress_error = 0;
10868 r = guestfs_touch (g, path);
10873 char path[] = "/new";
10875 suppress_error = 1;
10876 r = guestfs_rmdir (g, path);
10883 static int test_rm_0 (void)
10885 /* InitBasicFS for rm (0): create ext2 on /dev/sda1 */
10887 char device[] = "/dev/sda";
10888 device[5] = devchar;
10890 suppress_error = 0;
10891 r = guestfs_blockdev_setrw (g, device);
10897 suppress_error = 0;
10898 r = guestfs_umount_all (g);
10904 suppress_error = 0;
10905 r = guestfs_lvm_remove_all (g);
10910 char device[] = "/dev/sda";
10911 device[5] = devchar;
10912 char lines_0[] = ",";
10918 suppress_error = 0;
10919 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10924 char fstype[] = "ext2";
10925 char device[] = "/dev/sda1";
10926 device[5] = devchar;
10928 suppress_error = 0;
10929 r = guestfs_mkfs (g, fstype, device);
10934 char device[] = "/dev/sda1";
10935 device[5] = devchar;
10936 char mountpoint[] = "/";
10938 suppress_error = 0;
10939 r = guestfs_mount (g, device, mountpoint);
10943 /* TestRun for rm (0) */
10945 char path[] = "/new";
10947 suppress_error = 0;
10948 r = guestfs_touch (g, path);
10953 char path[] = "/new";
10955 suppress_error = 0;
10956 r = guestfs_rm (g, path);
10963 static int test_rm_1 (void)
10965 /* InitBasicFS for rm (1): create ext2 on /dev/sda1 */
10967 char device[] = "/dev/sda";
10968 device[5] = devchar;
10970 suppress_error = 0;
10971 r = guestfs_blockdev_setrw (g, device);
10977 suppress_error = 0;
10978 r = guestfs_umount_all (g);
10984 suppress_error = 0;
10985 r = guestfs_lvm_remove_all (g);
10990 char device[] = "/dev/sda";
10991 device[5] = devchar;
10992 char lines_0[] = ",";
10998 suppress_error = 0;
10999 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11004 char fstype[] = "ext2";
11005 char device[] = "/dev/sda1";
11006 device[5] = devchar;
11008 suppress_error = 0;
11009 r = guestfs_mkfs (g, fstype, device);
11014 char device[] = "/dev/sda1";
11015 device[5] = devchar;
11016 char mountpoint[] = "/";
11018 suppress_error = 0;
11019 r = guestfs_mount (g, device, mountpoint);
11023 /* TestLastFail for rm (1) */
11025 char path[] = "/new";
11027 suppress_error = 1;
11028 r = guestfs_rm (g, path);
11035 static int test_rm_2 (void)
11037 /* InitBasicFS for rm (2): create ext2 on /dev/sda1 */
11039 char device[] = "/dev/sda";
11040 device[5] = devchar;
11042 suppress_error = 0;
11043 r = guestfs_blockdev_setrw (g, device);
11049 suppress_error = 0;
11050 r = guestfs_umount_all (g);
11056 suppress_error = 0;
11057 r = guestfs_lvm_remove_all (g);
11062 char device[] = "/dev/sda";
11063 device[5] = devchar;
11064 char lines_0[] = ",";
11070 suppress_error = 0;
11071 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11076 char fstype[] = "ext2";
11077 char device[] = "/dev/sda1";
11078 device[5] = devchar;
11080 suppress_error = 0;
11081 r = guestfs_mkfs (g, fstype, device);
11086 char device[] = "/dev/sda1";
11087 device[5] = devchar;
11088 char mountpoint[] = "/";
11090 suppress_error = 0;
11091 r = guestfs_mount (g, device, mountpoint);
11095 /* TestLastFail for rm (2) */
11097 char path[] = "/new";
11099 suppress_error = 0;
11100 r = guestfs_mkdir (g, path);
11105 char path[] = "/new";
11107 suppress_error = 1;
11108 r = guestfs_rm (g, path);
11115 static int test_read_lines_0 (void)
11117 /* InitBasicFS for read_lines (0): create ext2 on /dev/sda1 */
11119 char device[] = "/dev/sda";
11120 device[5] = devchar;
11122 suppress_error = 0;
11123 r = guestfs_blockdev_setrw (g, device);
11129 suppress_error = 0;
11130 r = guestfs_umount_all (g);
11136 suppress_error = 0;
11137 r = guestfs_lvm_remove_all (g);
11142 char device[] = "/dev/sda";
11143 device[5] = devchar;
11144 char lines_0[] = ",";
11150 suppress_error = 0;
11151 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11156 char fstype[] = "ext2";
11157 char device[] = "/dev/sda1";
11158 device[5] = devchar;
11160 suppress_error = 0;
11161 r = guestfs_mkfs (g, fstype, device);
11166 char device[] = "/dev/sda1";
11167 device[5] = devchar;
11168 char mountpoint[] = "/";
11170 suppress_error = 0;
11171 r = guestfs_mount (g, device, mountpoint);
11175 /* TestOutputList for read_lines (0) */
11177 char path[] = "/new";
11178 char content[] = "line1\r\nline2\nline3";
11180 suppress_error = 0;
11181 r = guestfs_write_file (g, path, content, 0);
11186 char path[] = "/new";
11189 suppress_error = 0;
11190 r = guestfs_read_lines (g, path);
11194 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11199 char expected[] = "line1";
11200 if (strcmp (r[0], expected) != 0) {
11201 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11206 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11211 char expected[] = "line2";
11212 if (strcmp (r[1], expected) != 0) {
11213 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11218 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11223 char expected[] = "line3";
11224 if (strcmp (r[2], expected) != 0) {
11225 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11229 if (r[3] != NULL) {
11230 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11234 for (i = 0; r[i] != NULL; ++i)
11241 static int test_read_lines_1 (void)
11243 /* InitBasicFS for read_lines (1): create ext2 on /dev/sda1 */
11245 char device[] = "/dev/sda";
11246 device[5] = devchar;
11248 suppress_error = 0;
11249 r = guestfs_blockdev_setrw (g, device);
11255 suppress_error = 0;
11256 r = guestfs_umount_all (g);
11262 suppress_error = 0;
11263 r = guestfs_lvm_remove_all (g);
11268 char device[] = "/dev/sda";
11269 device[5] = devchar;
11270 char lines_0[] = ",";
11276 suppress_error = 0;
11277 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11282 char fstype[] = "ext2";
11283 char device[] = "/dev/sda1";
11284 device[5] = devchar;
11286 suppress_error = 0;
11287 r = guestfs_mkfs (g, fstype, device);
11292 char device[] = "/dev/sda1";
11293 device[5] = devchar;
11294 char mountpoint[] = "/";
11296 suppress_error = 0;
11297 r = guestfs_mount (g, device, mountpoint);
11301 /* TestOutputList for read_lines (1) */
11303 char path[] = "/new";
11304 char content[] = "";
11306 suppress_error = 0;
11307 r = guestfs_write_file (g, path, content, 0);
11312 char path[] = "/new";
11315 suppress_error = 0;
11316 r = guestfs_read_lines (g, path);
11319 if (r[0] != NULL) {
11320 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11324 for (i = 0; r[i] != NULL; ++i)
11331 static int test_lvs_0 (void)
11333 /* InitBasicFSonLVM for lvs (0): create ext2 on /dev/VG/LV */
11335 char device[] = "/dev/sda";
11336 device[5] = devchar;
11338 suppress_error = 0;
11339 r = guestfs_blockdev_setrw (g, device);
11345 suppress_error = 0;
11346 r = guestfs_umount_all (g);
11352 suppress_error = 0;
11353 r = guestfs_lvm_remove_all (g);
11358 char device[] = "/dev/sda";
11359 device[5] = devchar;
11360 char lines_0[] = ",";
11366 suppress_error = 0;
11367 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11372 char device[] = "/dev/sda1";
11373 device[5] = devchar;
11375 suppress_error = 0;
11376 r = guestfs_pvcreate (g, device);
11381 char volgroup[] = "VG";
11382 char physvols_0[] = "/dev/sda1";
11383 physvols_0[5] = devchar;
11384 char *physvols[] = {
11389 suppress_error = 0;
11390 r = guestfs_vgcreate (g, volgroup, physvols);
11395 char logvol[] = "LV";
11396 char volgroup[] = "VG";
11398 suppress_error = 0;
11399 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11404 char fstype[] = "ext2";
11405 char device[] = "/dev/VG/LV";
11407 suppress_error = 0;
11408 r = guestfs_mkfs (g, fstype, device);
11413 char device[] = "/dev/VG/LV";
11414 char mountpoint[] = "/";
11416 suppress_error = 0;
11417 r = guestfs_mount (g, device, mountpoint);
11421 /* TestOutputList for lvs (0) */
11425 suppress_error = 0;
11426 r = guestfs_lvs (g);
11430 fprintf (stderr, "test_lvs_0: short list returned from command\n");
11435 char expected[] = "/dev/VG/LV";
11436 if (strcmp (r[0], expected) != 0) {
11437 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11441 if (r[1] != NULL) {
11442 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
11446 for (i = 0; r[i] != NULL; ++i)
11453 static int test_lvs_1 (void)
11455 /* InitEmpty for lvs (1) */
11457 char device[] = "/dev/sda";
11458 device[5] = devchar;
11460 suppress_error = 0;
11461 r = guestfs_blockdev_setrw (g, device);
11467 suppress_error = 0;
11468 r = guestfs_umount_all (g);
11474 suppress_error = 0;
11475 r = guestfs_lvm_remove_all (g);
11479 /* TestOutputList for lvs (1) */
11481 char device[] = "/dev/sda";
11482 device[5] = devchar;
11483 char lines_0[] = ",10";
11484 char lines_1[] = ",20";
11485 char lines_2[] = ",";
11493 suppress_error = 0;
11494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11499 char device[] = "/dev/sda1";
11500 device[5] = devchar;
11502 suppress_error = 0;
11503 r = guestfs_pvcreate (g, device);
11508 char device[] = "/dev/sda2";
11509 device[5] = devchar;
11511 suppress_error = 0;
11512 r = guestfs_pvcreate (g, device);
11517 char device[] = "/dev/sda3";
11518 device[5] = devchar;
11520 suppress_error = 0;
11521 r = guestfs_pvcreate (g, device);
11526 char volgroup[] = "VG1";
11527 char physvols_0[] = "/dev/sda1";
11528 physvols_0[5] = devchar;
11529 char physvols_1[] = "/dev/sda2";
11530 physvols_1[5] = devchar;
11531 char *physvols[] = {
11537 suppress_error = 0;
11538 r = guestfs_vgcreate (g, volgroup, physvols);
11543 char volgroup[] = "VG2";
11544 char physvols_0[] = "/dev/sda3";
11545 physvols_0[5] = devchar;
11546 char *physvols[] = {
11551 suppress_error = 0;
11552 r = guestfs_vgcreate (g, volgroup, physvols);
11557 char logvol[] = "LV1";
11558 char volgroup[] = "VG1";
11560 suppress_error = 0;
11561 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11566 char logvol[] = "LV2";
11567 char volgroup[] = "VG1";
11569 suppress_error = 0;
11570 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11575 char logvol[] = "LV3";
11576 char volgroup[] = "VG2";
11578 suppress_error = 0;
11579 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11586 suppress_error = 0;
11587 r = guestfs_lvs (g);
11591 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11596 char expected[] = "/dev/VG1/LV1";
11597 if (strcmp (r[0], expected) != 0) {
11598 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11603 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11608 char expected[] = "/dev/VG1/LV2";
11609 if (strcmp (r[1], expected) != 0) {
11610 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11615 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11620 char expected[] = "/dev/VG2/LV3";
11621 if (strcmp (r[2], expected) != 0) {
11622 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11626 if (r[3] != NULL) {
11627 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
11631 for (i = 0; r[i] != NULL; ++i)
11638 static int test_vgs_0 (void)
11640 /* InitBasicFSonLVM for vgs (0): create ext2 on /dev/VG/LV */
11642 char device[] = "/dev/sda";
11643 device[5] = devchar;
11645 suppress_error = 0;
11646 r = guestfs_blockdev_setrw (g, device);
11652 suppress_error = 0;
11653 r = guestfs_umount_all (g);
11659 suppress_error = 0;
11660 r = guestfs_lvm_remove_all (g);
11665 char device[] = "/dev/sda";
11666 device[5] = devchar;
11667 char lines_0[] = ",";
11673 suppress_error = 0;
11674 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11679 char device[] = "/dev/sda1";
11680 device[5] = devchar;
11682 suppress_error = 0;
11683 r = guestfs_pvcreate (g, device);
11688 char volgroup[] = "VG";
11689 char physvols_0[] = "/dev/sda1";
11690 physvols_0[5] = devchar;
11691 char *physvols[] = {
11696 suppress_error = 0;
11697 r = guestfs_vgcreate (g, volgroup, physvols);
11702 char logvol[] = "LV";
11703 char volgroup[] = "VG";
11705 suppress_error = 0;
11706 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11711 char fstype[] = "ext2";
11712 char device[] = "/dev/VG/LV";
11714 suppress_error = 0;
11715 r = guestfs_mkfs (g, fstype, device);
11720 char device[] = "/dev/VG/LV";
11721 char mountpoint[] = "/";
11723 suppress_error = 0;
11724 r = guestfs_mount (g, device, mountpoint);
11728 /* TestOutputList for vgs (0) */
11732 suppress_error = 0;
11733 r = guestfs_vgs (g);
11737 fprintf (stderr, "test_vgs_0: short list returned from command\n");
11742 char expected[] = "VG";
11743 if (strcmp (r[0], expected) != 0) {
11744 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11748 if (r[1] != NULL) {
11749 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
11753 for (i = 0; r[i] != NULL; ++i)
11760 static int test_vgs_1 (void)
11762 /* InitEmpty for vgs (1) */
11764 char device[] = "/dev/sda";
11765 device[5] = devchar;
11767 suppress_error = 0;
11768 r = guestfs_blockdev_setrw (g, device);
11774 suppress_error = 0;
11775 r = guestfs_umount_all (g);
11781 suppress_error = 0;
11782 r = guestfs_lvm_remove_all (g);
11786 /* TestOutputList for vgs (1) */
11788 char device[] = "/dev/sda";
11789 device[5] = devchar;
11790 char lines_0[] = ",10";
11791 char lines_1[] = ",20";
11792 char lines_2[] = ",";
11800 suppress_error = 0;
11801 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11806 char device[] = "/dev/sda1";
11807 device[5] = devchar;
11809 suppress_error = 0;
11810 r = guestfs_pvcreate (g, device);
11815 char device[] = "/dev/sda2";
11816 device[5] = devchar;
11818 suppress_error = 0;
11819 r = guestfs_pvcreate (g, device);
11824 char device[] = "/dev/sda3";
11825 device[5] = devchar;
11827 suppress_error = 0;
11828 r = guestfs_pvcreate (g, device);
11833 char volgroup[] = "VG1";
11834 char physvols_0[] = "/dev/sda1";
11835 physvols_0[5] = devchar;
11836 char physvols_1[] = "/dev/sda2";
11837 physvols_1[5] = devchar;
11838 char *physvols[] = {
11844 suppress_error = 0;
11845 r = guestfs_vgcreate (g, volgroup, physvols);
11850 char volgroup[] = "VG2";
11851 char physvols_0[] = "/dev/sda3";
11852 physvols_0[5] = devchar;
11853 char *physvols[] = {
11858 suppress_error = 0;
11859 r = guestfs_vgcreate (g, volgroup, physvols);
11866 suppress_error = 0;
11867 r = guestfs_vgs (g);
11871 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11876 char expected[] = "VG1";
11877 if (strcmp (r[0], expected) != 0) {
11878 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11883 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11888 char expected[] = "VG2";
11889 if (strcmp (r[1], expected) != 0) {
11890 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11894 if (r[2] != NULL) {
11895 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
11899 for (i = 0; r[i] != NULL; ++i)
11906 static int test_pvs_0 (void)
11908 /* InitBasicFSonLVM for pvs (0): create ext2 on /dev/VG/LV */
11910 char device[] = "/dev/sda";
11911 device[5] = devchar;
11913 suppress_error = 0;
11914 r = guestfs_blockdev_setrw (g, device);
11920 suppress_error = 0;
11921 r = guestfs_umount_all (g);
11927 suppress_error = 0;
11928 r = guestfs_lvm_remove_all (g);
11933 char device[] = "/dev/sda";
11934 device[5] = devchar;
11935 char lines_0[] = ",";
11941 suppress_error = 0;
11942 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11947 char device[] = "/dev/sda1";
11948 device[5] = devchar;
11950 suppress_error = 0;
11951 r = guestfs_pvcreate (g, device);
11956 char volgroup[] = "VG";
11957 char physvols_0[] = "/dev/sda1";
11958 physvols_0[5] = devchar;
11959 char *physvols[] = {
11964 suppress_error = 0;
11965 r = guestfs_vgcreate (g, volgroup, physvols);
11970 char logvol[] = "LV";
11971 char volgroup[] = "VG";
11973 suppress_error = 0;
11974 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11979 char fstype[] = "ext2";
11980 char device[] = "/dev/VG/LV";
11982 suppress_error = 0;
11983 r = guestfs_mkfs (g, fstype, device);
11988 char device[] = "/dev/VG/LV";
11989 char mountpoint[] = "/";
11991 suppress_error = 0;
11992 r = guestfs_mount (g, device, mountpoint);
11996 /* TestOutputList for pvs (0) */
12000 suppress_error = 0;
12001 r = guestfs_pvs (g);
12005 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12010 char expected[] = "/dev/sda1";
12011 expected[5] = devchar;
12012 if (strcmp (r[0], expected) != 0) {
12013 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12017 if (r[1] != NULL) {
12018 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12022 for (i = 0; r[i] != NULL; ++i)
12029 static int test_pvs_1 (void)
12031 /* InitEmpty for pvs (1) */
12033 char device[] = "/dev/sda";
12034 device[5] = devchar;
12036 suppress_error = 0;
12037 r = guestfs_blockdev_setrw (g, device);
12043 suppress_error = 0;
12044 r = guestfs_umount_all (g);
12050 suppress_error = 0;
12051 r = guestfs_lvm_remove_all (g);
12055 /* TestOutputList for pvs (1) */
12057 char device[] = "/dev/sda";
12058 device[5] = devchar;
12059 char lines_0[] = ",10";
12060 char lines_1[] = ",20";
12061 char lines_2[] = ",";
12069 suppress_error = 0;
12070 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12075 char device[] = "/dev/sda1";
12076 device[5] = devchar;
12078 suppress_error = 0;
12079 r = guestfs_pvcreate (g, device);
12084 char device[] = "/dev/sda2";
12085 device[5] = devchar;
12087 suppress_error = 0;
12088 r = guestfs_pvcreate (g, device);
12093 char device[] = "/dev/sda3";
12094 device[5] = devchar;
12096 suppress_error = 0;
12097 r = guestfs_pvcreate (g, device);
12104 suppress_error = 0;
12105 r = guestfs_pvs (g);
12109 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12114 char expected[] = "/dev/sda1";
12115 expected[5] = devchar;
12116 if (strcmp (r[0], expected) != 0) {
12117 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12122 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12127 char expected[] = "/dev/sda2";
12128 expected[5] = devchar;
12129 if (strcmp (r[1], expected) != 0) {
12130 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12135 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12140 char expected[] = "/dev/sda3";
12141 expected[5] = devchar;
12142 if (strcmp (r[2], expected) != 0) {
12143 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12147 if (r[3] != NULL) {
12148 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12152 for (i = 0; r[i] != NULL; ++i)
12159 static int test_list_partitions_0 (void)
12161 /* InitBasicFS for list_partitions (0): create ext2 on /dev/sda1 */
12163 char device[] = "/dev/sda";
12164 device[5] = devchar;
12166 suppress_error = 0;
12167 r = guestfs_blockdev_setrw (g, device);
12173 suppress_error = 0;
12174 r = guestfs_umount_all (g);
12180 suppress_error = 0;
12181 r = guestfs_lvm_remove_all (g);
12186 char device[] = "/dev/sda";
12187 device[5] = devchar;
12188 char lines_0[] = ",";
12194 suppress_error = 0;
12195 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12200 char fstype[] = "ext2";
12201 char device[] = "/dev/sda1";
12202 device[5] = devchar;
12204 suppress_error = 0;
12205 r = guestfs_mkfs (g, fstype, device);
12210 char device[] = "/dev/sda1";
12211 device[5] = devchar;
12212 char mountpoint[] = "/";
12214 suppress_error = 0;
12215 r = guestfs_mount (g, device, mountpoint);
12219 /* TestOutputList for list_partitions (0) */
12223 suppress_error = 0;
12224 r = guestfs_list_partitions (g);
12228 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12233 char expected[] = "/dev/sda1";
12234 expected[5] = devchar;
12235 if (strcmp (r[0], expected) != 0) {
12236 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12240 if (r[1] != NULL) {
12241 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12245 for (i = 0; r[i] != NULL; ++i)
12252 static int test_list_partitions_1 (void)
12254 /* InitEmpty for list_partitions (1) */
12256 char device[] = "/dev/sda";
12257 device[5] = devchar;
12259 suppress_error = 0;
12260 r = guestfs_blockdev_setrw (g, device);
12266 suppress_error = 0;
12267 r = guestfs_umount_all (g);
12273 suppress_error = 0;
12274 r = guestfs_lvm_remove_all (g);
12278 /* TestOutputList for list_partitions (1) */
12280 char device[] = "/dev/sda";
12281 device[5] = devchar;
12282 char lines_0[] = ",10";
12283 char lines_1[] = ",20";
12284 char lines_2[] = ",";
12292 suppress_error = 0;
12293 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12300 suppress_error = 0;
12301 r = guestfs_list_partitions (g);
12305 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12310 char expected[] = "/dev/sda1";
12311 expected[5] = devchar;
12312 if (strcmp (r[0], expected) != 0) {
12313 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12318 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12323 char expected[] = "/dev/sda2";
12324 expected[5] = devchar;
12325 if (strcmp (r[1], expected) != 0) {
12326 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12331 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12336 char expected[] = "/dev/sda3";
12337 expected[5] = devchar;
12338 if (strcmp (r[2], expected) != 0) {
12339 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12343 if (r[3] != NULL) {
12344 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12348 for (i = 0; r[i] != NULL; ++i)
12355 static int test_list_devices_0 (void)
12357 /* InitEmpty for list_devices (0) */
12359 char device[] = "/dev/sda";
12360 device[5] = devchar;
12362 suppress_error = 0;
12363 r = guestfs_blockdev_setrw (g, device);
12369 suppress_error = 0;
12370 r = guestfs_umount_all (g);
12376 suppress_error = 0;
12377 r = guestfs_lvm_remove_all (g);
12381 /* TestOutputList for list_devices (0) */
12385 suppress_error = 0;
12386 r = guestfs_list_devices (g);
12390 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12395 char expected[] = "/dev/sda";
12396 expected[5] = devchar;
12397 if (strcmp (r[0], expected) != 0) {
12398 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12403 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12408 char expected[] = "/dev/sdb";
12409 expected[5] = devchar;
12410 if (strcmp (r[1], expected) != 0) {
12411 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12416 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12421 char expected[] = "/dev/sdc";
12422 expected[5] = devchar;
12423 if (strcmp (r[2], expected) != 0) {
12424 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12428 if (r[3] != NULL) {
12429 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
12433 for (i = 0; r[i] != NULL; ++i)
12440 static int test_ls_0 (void)
12442 /* InitBasicFS for ls (0): create ext2 on /dev/sda1 */
12444 char device[] = "/dev/sda";
12445 device[5] = devchar;
12447 suppress_error = 0;
12448 r = guestfs_blockdev_setrw (g, device);
12454 suppress_error = 0;
12455 r = guestfs_umount_all (g);
12461 suppress_error = 0;
12462 r = guestfs_lvm_remove_all (g);
12467 char device[] = "/dev/sda";
12468 device[5] = devchar;
12469 char lines_0[] = ",";
12475 suppress_error = 0;
12476 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12481 char fstype[] = "ext2";
12482 char device[] = "/dev/sda1";
12483 device[5] = devchar;
12485 suppress_error = 0;
12486 r = guestfs_mkfs (g, fstype, device);
12491 char device[] = "/dev/sda1";
12492 device[5] = devchar;
12493 char mountpoint[] = "/";
12495 suppress_error = 0;
12496 r = guestfs_mount (g, device, mountpoint);
12500 /* TestOutputList for ls (0) */
12502 char path[] = "/new";
12504 suppress_error = 0;
12505 r = guestfs_touch (g, path);
12510 char path[] = "/newer";
12512 suppress_error = 0;
12513 r = guestfs_touch (g, path);
12518 char path[] = "/newest";
12520 suppress_error = 0;
12521 r = guestfs_touch (g, path);
12526 char directory[] = "/";
12529 suppress_error = 0;
12530 r = guestfs_ls (g, directory);
12534 fprintf (stderr, "test_ls_0: short list returned from command\n");
12539 char expected[] = "lost+found";
12540 if (strcmp (r[0], expected) != 0) {
12541 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12546 fprintf (stderr, "test_ls_0: short list returned from command\n");
12551 char expected[] = "new";
12552 if (strcmp (r[1], expected) != 0) {
12553 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12558 fprintf (stderr, "test_ls_0: short list returned from command\n");
12563 char expected[] = "newer";
12564 if (strcmp (r[2], expected) != 0) {
12565 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12570 fprintf (stderr, "test_ls_0: short list returned from command\n");
12575 char expected[] = "newest";
12576 if (strcmp (r[3], expected) != 0) {
12577 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12581 if (r[4] != NULL) {
12582 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
12586 for (i = 0; r[i] != NULL; ++i)
12593 static int test_cat_0 (void)
12595 /* InitBasicFS for cat (0): create ext2 on /dev/sda1 */
12597 char device[] = "/dev/sda";
12598 device[5] = devchar;
12600 suppress_error = 0;
12601 r = guestfs_blockdev_setrw (g, device);
12607 suppress_error = 0;
12608 r = guestfs_umount_all (g);
12614 suppress_error = 0;
12615 r = guestfs_lvm_remove_all (g);
12620 char device[] = "/dev/sda";
12621 device[5] = devchar;
12622 char lines_0[] = ",";
12628 suppress_error = 0;
12629 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12634 char fstype[] = "ext2";
12635 char device[] = "/dev/sda1";
12636 device[5] = devchar;
12638 suppress_error = 0;
12639 r = guestfs_mkfs (g, fstype, device);
12644 char device[] = "/dev/sda1";
12645 device[5] = devchar;
12646 char mountpoint[] = "/";
12648 suppress_error = 0;
12649 r = guestfs_mount (g, device, mountpoint);
12653 /* TestOutput for cat (0) */
12654 char expected[] = "new file contents";
12656 char path[] = "/new";
12657 char content[] = "new file contents";
12659 suppress_error = 0;
12660 r = guestfs_write_file (g, path, content, 0);
12665 char path[] = "/new";
12667 suppress_error = 0;
12668 r = guestfs_cat (g, path);
12671 if (strcmp (r, expected) != 0) {
12672 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
12680 static int test_touch_0 (void)
12682 /* InitBasicFS for touch (0): create ext2 on /dev/sda1 */
12684 char device[] = "/dev/sda";
12685 device[5] = devchar;
12687 suppress_error = 0;
12688 r = guestfs_blockdev_setrw (g, device);
12694 suppress_error = 0;
12695 r = guestfs_umount_all (g);
12701 suppress_error = 0;
12702 r = guestfs_lvm_remove_all (g);
12707 char device[] = "/dev/sda";
12708 device[5] = devchar;
12709 char lines_0[] = ",";
12715 suppress_error = 0;
12716 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12721 char fstype[] = "ext2";
12722 char device[] = "/dev/sda1";
12723 device[5] = devchar;
12725 suppress_error = 0;
12726 r = guestfs_mkfs (g, fstype, device);
12731 char device[] = "/dev/sda1";
12732 device[5] = devchar;
12733 char mountpoint[] = "/";
12735 suppress_error = 0;
12736 r = guestfs_mount (g, device, mountpoint);
12740 /* TestOutputTrue for touch (0) */
12742 char path[] = "/new";
12744 suppress_error = 0;
12745 r = guestfs_touch (g, path);
12750 char path[] = "/new";
12752 suppress_error = 0;
12753 r = guestfs_exists (g, path);
12757 fprintf (stderr, "test_touch_0: expected true, got false\n");
12764 static int test_sync_0 (void)
12766 /* InitEmpty for sync (0) */
12768 char device[] = "/dev/sda";
12769 device[5] = devchar;
12771 suppress_error = 0;
12772 r = guestfs_blockdev_setrw (g, device);
12778 suppress_error = 0;
12779 r = guestfs_umount_all (g);
12785 suppress_error = 0;
12786 r = guestfs_lvm_remove_all (g);
12790 /* TestRun for sync (0) */
12793 suppress_error = 0;
12794 r = guestfs_sync (g);
12801 static int test_mount_0 (void)
12803 /* InitEmpty for mount (0) */
12805 char device[] = "/dev/sda";
12806 device[5] = devchar;
12808 suppress_error = 0;
12809 r = guestfs_blockdev_setrw (g, device);
12815 suppress_error = 0;
12816 r = guestfs_umount_all (g);
12822 suppress_error = 0;
12823 r = guestfs_lvm_remove_all (g);
12827 /* TestOutput for mount (0) */
12828 char expected[] = "new file contents";
12830 char device[] = "/dev/sda";
12831 device[5] = devchar;
12832 char lines_0[] = ",";
12838 suppress_error = 0;
12839 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12844 char fstype[] = "ext2";
12845 char device[] = "/dev/sda1";
12846 device[5] = devchar;
12848 suppress_error = 0;
12849 r = guestfs_mkfs (g, fstype, device);
12854 char device[] = "/dev/sda1";
12855 device[5] = devchar;
12856 char mountpoint[] = "/";
12858 suppress_error = 0;
12859 r = guestfs_mount (g, device, mountpoint);
12864 char path[] = "/new";
12865 char content[] = "new file contents";
12867 suppress_error = 0;
12868 r = guestfs_write_file (g, path, content, 0);
12873 char path[] = "/new";
12875 suppress_error = 0;
12876 r = guestfs_cat (g, path);
12879 if (strcmp (r, expected) != 0) {
12880 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
12888 int main (int argc, char *argv[])
12892 const char *srcdir;
12893 const char *filename;
12895 int nr_tests, test_num = 0;
12898 no_test_warnings ();
12900 g = guestfs_create ();
12902 printf ("guestfs_create FAILED\n");
12906 guestfs_set_error_handler (g, print_error, NULL);
12908 srcdir = getenv ("srcdir");
12909 if (!srcdir) srcdir = ".";
12911 guestfs_set_path (g, ".");
12913 filename = "test1.img";
12914 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
12919 if (lseek (fd, 524288000, SEEK_SET) == -1) {
12925 if (write (fd, &c, 1) == -1) {
12931 if (close (fd) == -1) {
12936 if (guestfs_add_drive (g, filename) == -1) {
12937 printf ("guestfs_add_drive %s FAILED\n", filename);
12941 filename = "test2.img";
12942 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
12947 if (lseek (fd, 52428800, SEEK_SET) == -1) {
12953 if (write (fd, &c, 1) == -1) {
12959 if (close (fd) == -1) {
12964 if (guestfs_add_drive (g, filename) == -1) {
12965 printf ("guestfs_add_drive %s FAILED\n", filename);
12969 filename = "test3.img";
12970 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
12975 if (lseek (fd, 10485760, SEEK_SET) == -1) {
12981 if (write (fd, &c, 1) == -1) {
12987 if (close (fd) == -1) {
12992 if (guestfs_add_drive (g, filename) == -1) {
12993 printf ("guestfs_add_drive %s FAILED\n", filename);
12997 if (guestfs_launch (g) == -1) {
12998 printf ("guestfs_launch FAILED\n");
13001 if (guestfs_wait_ready (g) == -1) {
13002 printf ("guestfs_wait_ready FAILED\n");
13006 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13007 * names. This changed between RHEL 5 and RHEL 6 so we have to
13010 devs = guestfs_list_devices (g);
13011 if (devs == NULL || devs[0] == NULL) {
13012 printf ("guestfs_list_devices FAILED\n");
13015 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13017 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13020 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13024 for (i = 0; devs[i] != NULL; ++i)
13031 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13032 if (test_hexdump_0 () == -1) {
13033 printf ("test_hexdump_0 FAILED\n");
13037 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13038 if (test_strings_e_0 () == -1) {
13039 printf ("test_strings_e_0 FAILED\n");
13043 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13044 if (test_strings_e_1 () == -1) {
13045 printf ("test_strings_e_1 FAILED\n");
13049 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13050 if (test_strings_0 () == -1) {
13051 printf ("test_strings_0 FAILED\n");
13055 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13056 if (test_strings_1 () == -1) {
13057 printf ("test_strings_1 FAILED\n");
13061 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13062 if (test_equal_0 () == -1) {
13063 printf ("test_equal_0 FAILED\n");
13067 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13068 if (test_equal_1 () == -1) {
13069 printf ("test_equal_1 FAILED\n");
13073 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13074 if (test_equal_2 () == -1) {
13075 printf ("test_equal_2 FAILED\n");
13079 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13080 if (test_ping_daemon_0 () == -1) {
13081 printf ("test_ping_daemon_0 FAILED\n");
13085 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13086 if (test_dmesg_0 () == -1) {
13087 printf ("test_dmesg_0 FAILED\n");
13091 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13092 if (test_drop_caches_0 () == -1) {
13093 printf ("test_drop_caches_0 FAILED\n");
13097 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13098 if (test_mv_0 () == -1) {
13099 printf ("test_mv_0 FAILED\n");
13103 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13104 if (test_mv_1 () == -1) {
13105 printf ("test_mv_1 FAILED\n");
13109 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13110 if (test_cp_a_0 () == -1) {
13111 printf ("test_cp_a_0 FAILED\n");
13115 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13116 if (test_cp_0 () == -1) {
13117 printf ("test_cp_0 FAILED\n");
13121 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13122 if (test_cp_1 () == -1) {
13123 printf ("test_cp_1 FAILED\n");
13127 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13128 if (test_cp_2 () == -1) {
13129 printf ("test_cp_2 FAILED\n");
13133 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13134 if (test_grub_install_0 () == -1) {
13135 printf ("test_grub_install_0 FAILED\n");
13139 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13140 if (test_zero_0 () == -1) {
13141 printf ("test_zero_0 FAILED\n");
13145 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13146 if (test_fsck_0 () == -1) {
13147 printf ("test_fsck_0 FAILED\n");
13151 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13152 if (test_fsck_1 () == -1) {
13153 printf ("test_fsck_1 FAILED\n");
13157 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13158 if (test_set_e2uuid_0 () == -1) {
13159 printf ("test_set_e2uuid_0 FAILED\n");
13163 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13164 if (test_set_e2uuid_1 () == -1) {
13165 printf ("test_set_e2uuid_1 FAILED\n");
13169 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13170 if (test_set_e2uuid_2 () == -1) {
13171 printf ("test_set_e2uuid_2 FAILED\n");
13175 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13176 if (test_set_e2uuid_3 () == -1) {
13177 printf ("test_set_e2uuid_3 FAILED\n");
13181 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13182 if (test_set_e2label_0 () == -1) {
13183 printf ("test_set_e2label_0 FAILED\n");
13187 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13188 if (test_pvremove_0 () == -1) {
13189 printf ("test_pvremove_0 FAILED\n");
13193 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13194 if (test_pvremove_1 () == -1) {
13195 printf ("test_pvremove_1 FAILED\n");
13199 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13200 if (test_pvremove_2 () == -1) {
13201 printf ("test_pvremove_2 FAILED\n");
13205 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13206 if (test_vgremove_0 () == -1) {
13207 printf ("test_vgremove_0 FAILED\n");
13211 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13212 if (test_vgremove_1 () == -1) {
13213 printf ("test_vgremove_1 FAILED\n");
13217 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13218 if (test_lvremove_0 () == -1) {
13219 printf ("test_lvremove_0 FAILED\n");
13223 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13224 if (test_lvremove_1 () == -1) {
13225 printf ("test_lvremove_1 FAILED\n");
13229 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13230 if (test_lvremove_2 () == -1) {
13231 printf ("test_lvremove_2 FAILED\n");
13235 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13236 if (test_mount_ro_0 () == -1) {
13237 printf ("test_mount_ro_0 FAILED\n");
13241 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13242 if (test_mount_ro_1 () == -1) {
13243 printf ("test_mount_ro_1 FAILED\n");
13247 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13248 if (test_tgz_in_0 () == -1) {
13249 printf ("test_tgz_in_0 FAILED\n");
13253 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13254 if (test_tar_in_0 () == -1) {
13255 printf ("test_tar_in_0 FAILED\n");
13259 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13260 if (test_checksum_0 () == -1) {
13261 printf ("test_checksum_0 FAILED\n");
13265 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13266 if (test_checksum_1 () == -1) {
13267 printf ("test_checksum_1 FAILED\n");
13271 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13272 if (test_checksum_2 () == -1) {
13273 printf ("test_checksum_2 FAILED\n");
13277 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13278 if (test_checksum_3 () == -1) {
13279 printf ("test_checksum_3 FAILED\n");
13283 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13284 if (test_checksum_4 () == -1) {
13285 printf ("test_checksum_4 FAILED\n");
13289 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13290 if (test_checksum_5 () == -1) {
13291 printf ("test_checksum_5 FAILED\n");
13295 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13296 if (test_checksum_6 () == -1) {
13297 printf ("test_checksum_6 FAILED\n");
13301 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13302 if (test_checksum_7 () == -1) {
13303 printf ("test_checksum_7 FAILED\n");
13307 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13308 if (test_download_0 () == -1) {
13309 printf ("test_download_0 FAILED\n");
13313 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13314 if (test_upload_0 () == -1) {
13315 printf ("test_upload_0 FAILED\n");
13319 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13320 if (test_blockdev_rereadpt_0 () == -1) {
13321 printf ("test_blockdev_rereadpt_0 FAILED\n");
13325 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13326 if (test_blockdev_flushbufs_0 () == -1) {
13327 printf ("test_blockdev_flushbufs_0 FAILED\n");
13331 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
13332 if (test_blockdev_getsize64_0 () == -1) {
13333 printf ("test_blockdev_getsize64_0 FAILED\n");
13337 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
13338 if (test_blockdev_getsz_0 () == -1) {
13339 printf ("test_blockdev_getsz_0 FAILED\n");
13343 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
13344 if (test_blockdev_getbsz_0 () == -1) {
13345 printf ("test_blockdev_getbsz_0 FAILED\n");
13349 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
13350 if (test_blockdev_getss_0 () == -1) {
13351 printf ("test_blockdev_getss_0 FAILED\n");
13355 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
13356 if (test_blockdev_getro_0 () == -1) {
13357 printf ("test_blockdev_getro_0 FAILED\n");
13361 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
13362 if (test_blockdev_setrw_0 () == -1) {
13363 printf ("test_blockdev_setrw_0 FAILED\n");
13367 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
13368 if (test_blockdev_setro_0 () == -1) {
13369 printf ("test_blockdev_setro_0 FAILED\n");
13373 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
13374 if (test_statvfs_0 () == -1) {
13375 printf ("test_statvfs_0 FAILED\n");
13379 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
13380 if (test_lstat_0 () == -1) {
13381 printf ("test_lstat_0 FAILED\n");
13385 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
13386 if (test_stat_0 () == -1) {
13387 printf ("test_stat_0 FAILED\n");
13391 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
13392 if (test_command_lines_0 () == -1) {
13393 printf ("test_command_lines_0 FAILED\n");
13397 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
13398 if (test_command_lines_1 () == -1) {
13399 printf ("test_command_lines_1 FAILED\n");
13403 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
13404 if (test_command_lines_2 () == -1) {
13405 printf ("test_command_lines_2 FAILED\n");
13409 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
13410 if (test_command_lines_3 () == -1) {
13411 printf ("test_command_lines_3 FAILED\n");
13415 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
13416 if (test_command_lines_4 () == -1) {
13417 printf ("test_command_lines_4 FAILED\n");
13421 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
13422 if (test_command_lines_5 () == -1) {
13423 printf ("test_command_lines_5 FAILED\n");
13427 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
13428 if (test_command_lines_6 () == -1) {
13429 printf ("test_command_lines_6 FAILED\n");
13433 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
13434 if (test_command_lines_7 () == -1) {
13435 printf ("test_command_lines_7 FAILED\n");
13439 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
13440 if (test_command_lines_8 () == -1) {
13441 printf ("test_command_lines_8 FAILED\n");
13445 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
13446 if (test_command_lines_9 () == -1) {
13447 printf ("test_command_lines_9 FAILED\n");
13451 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
13452 if (test_command_lines_10 () == -1) {
13453 printf ("test_command_lines_10 FAILED\n");
13457 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
13458 if (test_command_0 () == -1) {
13459 printf ("test_command_0 FAILED\n");
13463 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
13464 if (test_command_1 () == -1) {
13465 printf ("test_command_1 FAILED\n");
13469 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
13470 if (test_command_2 () == -1) {
13471 printf ("test_command_2 FAILED\n");
13475 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
13476 if (test_command_3 () == -1) {
13477 printf ("test_command_3 FAILED\n");
13481 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
13482 if (test_command_4 () == -1) {
13483 printf ("test_command_4 FAILED\n");
13487 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
13488 if (test_command_5 () == -1) {
13489 printf ("test_command_5 FAILED\n");
13493 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
13494 if (test_command_6 () == -1) {
13495 printf ("test_command_6 FAILED\n");
13499 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
13500 if (test_command_7 () == -1) {
13501 printf ("test_command_7 FAILED\n");
13505 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
13506 if (test_command_8 () == -1) {
13507 printf ("test_command_8 FAILED\n");
13511 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
13512 if (test_command_9 () == -1) {
13513 printf ("test_command_9 FAILED\n");
13517 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
13518 if (test_command_10 () == -1) {
13519 printf ("test_command_10 FAILED\n");
13523 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
13524 if (test_command_11 () == -1) {
13525 printf ("test_command_11 FAILED\n");
13529 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
13530 if (test_file_0 () == -1) {
13531 printf ("test_file_0 FAILED\n");
13535 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
13536 if (test_file_1 () == -1) {
13537 printf ("test_file_1 FAILED\n");
13541 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
13542 if (test_file_2 () == -1) {
13543 printf ("test_file_2 FAILED\n");
13547 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
13548 if (test_umount_all_0 () == -1) {
13549 printf ("test_umount_all_0 FAILED\n");
13553 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
13554 if (test_umount_all_1 () == -1) {
13555 printf ("test_umount_all_1 FAILED\n");
13559 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
13560 if (test_mounts_0 () == -1) {
13561 printf ("test_mounts_0 FAILED\n");
13565 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
13566 if (test_umount_0 () == -1) {
13567 printf ("test_umount_0 FAILED\n");
13571 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
13572 if (test_umount_1 () == -1) {
13573 printf ("test_umount_1 FAILED\n");
13577 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
13578 if (test_write_file_0 () == -1) {
13579 printf ("test_write_file_0 FAILED\n");
13583 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
13584 if (test_write_file_1 () == -1) {
13585 printf ("test_write_file_1 FAILED\n");
13589 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
13590 if (test_write_file_2 () == -1) {
13591 printf ("test_write_file_2 FAILED\n");
13595 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
13596 if (test_write_file_3 () == -1) {
13597 printf ("test_write_file_3 FAILED\n");
13601 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
13602 if (test_write_file_4 () == -1) {
13603 printf ("test_write_file_4 FAILED\n");
13607 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
13608 if (test_write_file_5 () == -1) {
13609 printf ("test_write_file_5 FAILED\n");
13613 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
13614 if (test_mkfs_0 () == -1) {
13615 printf ("test_mkfs_0 FAILED\n");
13619 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
13620 if (test_lvcreate_0 () == -1) {
13621 printf ("test_lvcreate_0 FAILED\n");
13625 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
13626 if (test_vgcreate_0 () == -1) {
13627 printf ("test_vgcreate_0 FAILED\n");
13631 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
13632 if (test_pvcreate_0 () == -1) {
13633 printf ("test_pvcreate_0 FAILED\n");
13637 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
13638 if (test_is_dir_0 () == -1) {
13639 printf ("test_is_dir_0 FAILED\n");
13643 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
13644 if (test_is_dir_1 () == -1) {
13645 printf ("test_is_dir_1 FAILED\n");
13649 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
13650 if (test_is_file_0 () == -1) {
13651 printf ("test_is_file_0 FAILED\n");
13655 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
13656 if (test_is_file_1 () == -1) {
13657 printf ("test_is_file_1 FAILED\n");
13661 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
13662 if (test_exists_0 () == -1) {
13663 printf ("test_exists_0 FAILED\n");
13667 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
13668 if (test_exists_1 () == -1) {
13669 printf ("test_exists_1 FAILED\n");
13673 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
13674 if (test_mkdir_p_0 () == -1) {
13675 printf ("test_mkdir_p_0 FAILED\n");
13679 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
13680 if (test_mkdir_p_1 () == -1) {
13681 printf ("test_mkdir_p_1 FAILED\n");
13685 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
13686 if (test_mkdir_p_2 () == -1) {
13687 printf ("test_mkdir_p_2 FAILED\n");
13691 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
13692 if (test_mkdir_0 () == -1) {
13693 printf ("test_mkdir_0 FAILED\n");
13697 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
13698 if (test_mkdir_1 () == -1) {
13699 printf ("test_mkdir_1 FAILED\n");
13703 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
13704 if (test_rm_rf_0 () == -1) {
13705 printf ("test_rm_rf_0 FAILED\n");
13709 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
13710 if (test_rmdir_0 () == -1) {
13711 printf ("test_rmdir_0 FAILED\n");
13715 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
13716 if (test_rmdir_1 () == -1) {
13717 printf ("test_rmdir_1 FAILED\n");
13721 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
13722 if (test_rmdir_2 () == -1) {
13723 printf ("test_rmdir_2 FAILED\n");
13727 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
13728 if (test_rm_0 () == -1) {
13729 printf ("test_rm_0 FAILED\n");
13733 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
13734 if (test_rm_1 () == -1) {
13735 printf ("test_rm_1 FAILED\n");
13739 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
13740 if (test_rm_2 () == -1) {
13741 printf ("test_rm_2 FAILED\n");
13745 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
13746 if (test_read_lines_0 () == -1) {
13747 printf ("test_read_lines_0 FAILED\n");
13751 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
13752 if (test_read_lines_1 () == -1) {
13753 printf ("test_read_lines_1 FAILED\n");
13757 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
13758 if (test_lvs_0 () == -1) {
13759 printf ("test_lvs_0 FAILED\n");
13763 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
13764 if (test_lvs_1 () == -1) {
13765 printf ("test_lvs_1 FAILED\n");
13769 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
13770 if (test_vgs_0 () == -1) {
13771 printf ("test_vgs_0 FAILED\n");
13775 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
13776 if (test_vgs_1 () == -1) {
13777 printf ("test_vgs_1 FAILED\n");
13781 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
13782 if (test_pvs_0 () == -1) {
13783 printf ("test_pvs_0 FAILED\n");
13787 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
13788 if (test_pvs_1 () == -1) {
13789 printf ("test_pvs_1 FAILED\n");
13793 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
13794 if (test_list_partitions_0 () == -1) {
13795 printf ("test_list_partitions_0 FAILED\n");
13799 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
13800 if (test_list_partitions_1 () == -1) {
13801 printf ("test_list_partitions_1 FAILED\n");
13805 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
13806 if (test_list_devices_0 () == -1) {
13807 printf ("test_list_devices_0 FAILED\n");
13811 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
13812 if (test_ls_0 () == -1) {
13813 printf ("test_ls_0 FAILED\n");
13817 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
13818 if (test_cat_0 () == -1) {
13819 printf ("test_cat_0 FAILED\n");
13823 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
13824 if (test_touch_0 () == -1) {
13825 printf ("test_touch_0 FAILED\n");
13829 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
13830 if (test_sync_0 () == -1) {
13831 printf ("test_sync_0 FAILED\n");
13835 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
13836 if (test_mount_0 () == -1) {
13837 printf ("test_mount_0 FAILED\n");
13842 unlink ("test1.img");
13843 unlink ("test2.img");
13844 unlink ("test3.img");
13847 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);