1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 /* This will be 's' or 'h' depending on whether the guest kernel
35 * names IDE devices /dev/sd* or /dev/hd*.
37 static char devchar = 's';
39 static void print_error (guestfs_h *g, void *data, const char *msg)
42 fprintf (stderr, "%s\n", msg);
45 static void print_strings (char * const * const argv)
49 for (argc = 0; argv[argc] != NULL; ++argc)
50 printf ("\t%s\n", argv[argc]);
54 static void print_table (char * const * const argv)
58 for (i = 0; argv[i] != NULL; i += 2)
59 printf ("%s: %s\n", argv[i], argv[i+1]);
63 static void no_test_warnings (void)
65 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
128 static int test_zerofree_0 (void)
130 /* TestOutput for zerofree (0) */
131 char expected[] = "test file";
133 char device[] = "/dev/sda";
135 char lines_0[] = ",";
142 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
147 char fstype[] = "ext3";
148 char device[] = "/dev/sda1";
152 r = guestfs_mkfs (g, fstype, device);
157 char device[] = "/dev/sda1";
159 char mountpoint[] = "/";
162 r = guestfs_mount (g, device, mountpoint);
167 char path[] = "/new";
168 char content[] = "test file";
171 r = guestfs_write_file (g, path, content, 0);
176 char pathordevice[] = "/dev/sda1";
177 pathordevice[5] = devchar;
180 r = guestfs_umount (g, pathordevice);
185 char device[] = "/dev/sda1";
189 r = guestfs_zerofree (g, device);
194 char device[] = "/dev/sda1";
196 char mountpoint[] = "/";
199 r = guestfs_mount (g, device, mountpoint);
204 char path[] = "/new";
207 r = guestfs_cat (g, path);
210 if (strcmp (r, expected) != 0) {
211 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
219 static int test_hexdump_0 (void)
221 /* InitBasicFS for hexdump (0): create ext2 on /dev/sda1 */
223 char device[] = "/dev/sda";
227 r = guestfs_blockdev_setrw (g, device);
234 r = guestfs_umount_all (g);
241 r = guestfs_lvm_remove_all (g);
246 char device[] = "/dev/sda";
248 char lines_0[] = ",";
255 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
260 char fstype[] = "ext2";
261 char device[] = "/dev/sda1";
265 r = guestfs_mkfs (g, fstype, device);
270 char device[] = "/dev/sda1";
272 char mountpoint[] = "/";
275 r = guestfs_mount (g, device, mountpoint);
279 /* TestOutput for hexdump (0) */
280 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
282 char path[] = "/new";
283 char content[] = "hello\nworld\n";
286 r = guestfs_write_file (g, path, content, 12);
291 char path[] = "/new";
294 r = guestfs_hexdump (g, path);
297 if (strcmp (r, expected) != 0) {
298 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
306 static int test_strings_e_0 (void)
308 /* InitBasicFS for strings_e (0): create ext2 on /dev/sda1 */
310 char device[] = "/dev/sda";
314 r = guestfs_blockdev_setrw (g, device);
321 r = guestfs_umount_all (g);
328 r = guestfs_lvm_remove_all (g);
333 char device[] = "/dev/sda";
335 char lines_0[] = ",";
342 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
347 char fstype[] = "ext2";
348 char device[] = "/dev/sda1";
352 r = guestfs_mkfs (g, fstype, device);
357 char device[] = "/dev/sda1";
359 char mountpoint[] = "/";
362 r = guestfs_mount (g, device, mountpoint);
366 /* TestOutputList for strings_e (0) */
368 char path[] = "/new";
369 char content[] = "hello\nworld\n";
372 r = guestfs_write_file (g, path, content, 0);
377 char encoding[] = "b";
378 char path[] = "/new";
382 r = guestfs_strings_e (g, encoding, path);
386 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
390 for (i = 0; r[i] != NULL; ++i)
397 static int test_strings_e_1 (void)
399 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
403 static int test_strings_0 (void)
405 /* InitBasicFS for strings (0): create ext2 on /dev/sda1 */
407 char device[] = "/dev/sda";
411 r = guestfs_blockdev_setrw (g, device);
418 r = guestfs_umount_all (g);
425 r = guestfs_lvm_remove_all (g);
430 char device[] = "/dev/sda";
432 char lines_0[] = ",";
439 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
444 char fstype[] = "ext2";
445 char device[] = "/dev/sda1";
449 r = guestfs_mkfs (g, fstype, device);
454 char device[] = "/dev/sda1";
456 char mountpoint[] = "/";
459 r = guestfs_mount (g, device, mountpoint);
463 /* TestOutputList for strings (0) */
465 char path[] = "/new";
466 char content[] = "hello\nworld\n";
469 r = guestfs_write_file (g, path, content, 0);
474 char path[] = "/new";
478 r = guestfs_strings (g, path);
482 fprintf (stderr, "test_strings_0: short list returned from command\n");
487 char expected[] = "hello";
488 if (strcmp (r[0], expected) != 0) {
489 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
494 fprintf (stderr, "test_strings_0: short list returned from command\n");
499 char expected[] = "world";
500 if (strcmp (r[1], expected) != 0) {
501 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
506 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
510 for (i = 0; r[i] != NULL; ++i)
517 static int test_strings_1 (void)
519 /* InitBasicFS for strings (1): create ext2 on /dev/sda1 */
521 char device[] = "/dev/sda";
525 r = guestfs_blockdev_setrw (g, device);
532 r = guestfs_umount_all (g);
539 r = guestfs_lvm_remove_all (g);
544 char device[] = "/dev/sda";
546 char lines_0[] = ",";
553 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
558 char fstype[] = "ext2";
559 char device[] = "/dev/sda1";
563 r = guestfs_mkfs (g, fstype, device);
568 char device[] = "/dev/sda1";
570 char mountpoint[] = "/";
573 r = guestfs_mount (g, device, mountpoint);
577 /* TestOutputList for strings (1) */
579 char path[] = "/new";
582 r = guestfs_touch (g, path);
587 char path[] = "/new";
591 r = guestfs_strings (g, path);
595 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
599 for (i = 0; r[i] != NULL; ++i)
606 static int test_equal_0 (void)
608 /* InitBasicFS for equal (0): create ext2 on /dev/sda1 */
610 char device[] = "/dev/sda";
614 r = guestfs_blockdev_setrw (g, device);
621 r = guestfs_umount_all (g);
628 r = guestfs_lvm_remove_all (g);
633 char device[] = "/dev/sda";
635 char lines_0[] = ",";
642 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
647 char fstype[] = "ext2";
648 char device[] = "/dev/sda1";
652 r = guestfs_mkfs (g, fstype, device);
657 char device[] = "/dev/sda1";
659 char mountpoint[] = "/";
662 r = guestfs_mount (g, device, mountpoint);
666 /* TestOutputTrue for equal (0) */
668 char path[] = "/file1";
669 char content[] = "contents of a file";
672 r = guestfs_write_file (g, path, content, 0);
677 char src[] = "/file1";
678 char dest[] = "/file2";
681 r = guestfs_cp (g, src, dest);
686 char file1[] = "/file1";
687 char file2[] = "/file2";
690 r = guestfs_equal (g, file1, file2);
694 fprintf (stderr, "test_equal_0: expected true, got false\n");
701 static int test_equal_1 (void)
703 /* InitBasicFS for equal (1): create ext2 on /dev/sda1 */
705 char device[] = "/dev/sda";
709 r = guestfs_blockdev_setrw (g, device);
716 r = guestfs_umount_all (g);
723 r = guestfs_lvm_remove_all (g);
728 char device[] = "/dev/sda";
730 char lines_0[] = ",";
737 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
742 char fstype[] = "ext2";
743 char device[] = "/dev/sda1";
747 r = guestfs_mkfs (g, fstype, device);
752 char device[] = "/dev/sda1";
754 char mountpoint[] = "/";
757 r = guestfs_mount (g, device, mountpoint);
761 /* TestOutputFalse for equal (1) */
763 char path[] = "/file1";
764 char content[] = "contents of a file";
767 r = guestfs_write_file (g, path, content, 0);
772 char path[] = "/file2";
773 char content[] = "contents of another file";
776 r = guestfs_write_file (g, path, content, 0);
781 char file1[] = "/file1";
782 char file2[] = "/file2";
785 r = guestfs_equal (g, file1, file2);
789 fprintf (stderr, "test_equal_1: expected false, got true\n");
796 static int test_equal_2 (void)
798 /* InitBasicFS for equal (2): create ext2 on /dev/sda1 */
800 char device[] = "/dev/sda";
804 r = guestfs_blockdev_setrw (g, device);
811 r = guestfs_umount_all (g);
818 r = guestfs_lvm_remove_all (g);
823 char device[] = "/dev/sda";
825 char lines_0[] = ",";
832 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
837 char fstype[] = "ext2";
838 char device[] = "/dev/sda1";
842 r = guestfs_mkfs (g, fstype, device);
847 char device[] = "/dev/sda1";
849 char mountpoint[] = "/";
852 r = guestfs_mount (g, device, mountpoint);
856 /* TestLastFail for equal (2) */
858 char file1[] = "/file1";
859 char file2[] = "/file2";
862 r = guestfs_equal (g, file1, file2);
869 static int test_ping_daemon_0 (void)
871 /* InitEmpty for ping_daemon (0) */
873 char device[] = "/dev/sda";
877 r = guestfs_blockdev_setrw (g, device);
884 r = guestfs_umount_all (g);
891 r = guestfs_lvm_remove_all (g);
895 /* TestRun for ping_daemon (0) */
899 r = guestfs_ping_daemon (g);
906 static int test_dmesg_0 (void)
908 /* InitEmpty for dmesg (0) */
910 char device[] = "/dev/sda";
914 r = guestfs_blockdev_setrw (g, device);
921 r = guestfs_umount_all (g);
928 r = guestfs_lvm_remove_all (g);
932 /* TestRun for dmesg (0) */
936 r = guestfs_dmesg (g);
944 static int test_drop_caches_0 (void)
946 /* InitEmpty for drop_caches (0) */
948 char device[] = "/dev/sda";
952 r = guestfs_blockdev_setrw (g, device);
959 r = guestfs_umount_all (g);
966 r = guestfs_lvm_remove_all (g);
970 /* TestRun for drop_caches (0) */
974 r = guestfs_drop_caches (g, 3);
981 static int test_mv_0 (void)
983 /* InitBasicFS for mv (0): create ext2 on /dev/sda1 */
985 char device[] = "/dev/sda";
989 r = guestfs_blockdev_setrw (g, device);
996 r = guestfs_umount_all (g);
1003 r = guestfs_lvm_remove_all (g);
1008 char device[] = "/dev/sda";
1009 device[5] = devchar;
1010 char lines_0[] = ",";
1017 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1022 char fstype[] = "ext2";
1023 char device[] = "/dev/sda1";
1024 device[5] = devchar;
1027 r = guestfs_mkfs (g, fstype, device);
1032 char device[] = "/dev/sda1";
1033 device[5] = devchar;
1034 char mountpoint[] = "/";
1037 r = guestfs_mount (g, device, mountpoint);
1041 /* TestOutput for mv (0) */
1042 char expected[] = "file content";
1044 char path[] = "/old";
1045 char content[] = "file content";
1048 r = guestfs_write_file (g, path, content, 0);
1053 char src[] = "/old";
1054 char dest[] = "/new";
1057 r = guestfs_mv (g, src, dest);
1062 char path[] = "/new";
1065 r = guestfs_cat (g, path);
1068 if (strcmp (r, expected) != 0) {
1069 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1077 static int test_mv_1 (void)
1079 /* InitBasicFS for mv (1): create ext2 on /dev/sda1 */
1081 char device[] = "/dev/sda";
1082 device[5] = devchar;
1085 r = guestfs_blockdev_setrw (g, device);
1092 r = guestfs_umount_all (g);
1099 r = guestfs_lvm_remove_all (g);
1104 char device[] = "/dev/sda";
1105 device[5] = devchar;
1106 char lines_0[] = ",";
1113 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1118 char fstype[] = "ext2";
1119 char device[] = "/dev/sda1";
1120 device[5] = devchar;
1123 r = guestfs_mkfs (g, fstype, device);
1128 char device[] = "/dev/sda1";
1129 device[5] = devchar;
1130 char mountpoint[] = "/";
1133 r = guestfs_mount (g, device, mountpoint);
1137 /* TestOutputFalse for mv (1) */
1139 char path[] = "/old";
1140 char content[] = "file content";
1143 r = guestfs_write_file (g, path, content, 0);
1148 char src[] = "/old";
1149 char dest[] = "/new";
1152 r = guestfs_mv (g, src, dest);
1157 char path[] = "/old";
1160 r = guestfs_is_file (g, path);
1164 fprintf (stderr, "test_mv_1: expected false, got true\n");
1171 static int test_cp_a_0 (void)
1173 /* InitBasicFS for cp_a (0): create ext2 on /dev/sda1 */
1175 char device[] = "/dev/sda";
1176 device[5] = devchar;
1179 r = guestfs_blockdev_setrw (g, device);
1186 r = guestfs_umount_all (g);
1193 r = guestfs_lvm_remove_all (g);
1198 char device[] = "/dev/sda";
1199 device[5] = devchar;
1200 char lines_0[] = ",";
1207 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1212 char fstype[] = "ext2";
1213 char device[] = "/dev/sda1";
1214 device[5] = devchar;
1217 r = guestfs_mkfs (g, fstype, device);
1222 char device[] = "/dev/sda1";
1223 device[5] = devchar;
1224 char mountpoint[] = "/";
1227 r = guestfs_mount (g, device, mountpoint);
1231 /* TestOutput for cp_a (0) */
1232 char expected[] = "file content";
1234 char path[] = "/olddir";
1237 r = guestfs_mkdir (g, path);
1242 char path[] = "/newdir";
1245 r = guestfs_mkdir (g, path);
1250 char path[] = "/olddir/file";
1251 char content[] = "file content";
1254 r = guestfs_write_file (g, path, content, 0);
1259 char src[] = "/olddir";
1260 char dest[] = "/newdir";
1263 r = guestfs_cp_a (g, src, dest);
1268 char path[] = "/newdir/olddir/file";
1271 r = guestfs_cat (g, path);
1274 if (strcmp (r, expected) != 0) {
1275 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1283 static int test_cp_0 (void)
1285 /* InitBasicFS for cp (0): create ext2 on /dev/sda1 */
1287 char device[] = "/dev/sda";
1288 device[5] = devchar;
1291 r = guestfs_blockdev_setrw (g, device);
1298 r = guestfs_umount_all (g);
1305 r = guestfs_lvm_remove_all (g);
1310 char device[] = "/dev/sda";
1311 device[5] = devchar;
1312 char lines_0[] = ",";
1319 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1324 char fstype[] = "ext2";
1325 char device[] = "/dev/sda1";
1326 device[5] = devchar;
1329 r = guestfs_mkfs (g, fstype, device);
1334 char device[] = "/dev/sda1";
1335 device[5] = devchar;
1336 char mountpoint[] = "/";
1339 r = guestfs_mount (g, device, mountpoint);
1343 /* TestOutput for cp (0) */
1344 char expected[] = "file content";
1346 char path[] = "/old";
1347 char content[] = "file content";
1350 r = guestfs_write_file (g, path, content, 0);
1355 char src[] = "/old";
1356 char dest[] = "/new";
1359 r = guestfs_cp (g, src, dest);
1364 char path[] = "/new";
1367 r = guestfs_cat (g, path);
1370 if (strcmp (r, expected) != 0) {
1371 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1379 static int test_cp_1 (void)
1381 /* InitBasicFS for cp (1): create ext2 on /dev/sda1 */
1383 char device[] = "/dev/sda";
1384 device[5] = devchar;
1387 r = guestfs_blockdev_setrw (g, device);
1394 r = guestfs_umount_all (g);
1401 r = guestfs_lvm_remove_all (g);
1406 char device[] = "/dev/sda";
1407 device[5] = devchar;
1408 char lines_0[] = ",";
1415 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1420 char fstype[] = "ext2";
1421 char device[] = "/dev/sda1";
1422 device[5] = devchar;
1425 r = guestfs_mkfs (g, fstype, device);
1430 char device[] = "/dev/sda1";
1431 device[5] = devchar;
1432 char mountpoint[] = "/";
1435 r = guestfs_mount (g, device, mountpoint);
1439 /* TestOutputTrue for cp (1) */
1441 char path[] = "/old";
1442 char content[] = "file content";
1445 r = guestfs_write_file (g, path, content, 0);
1450 char src[] = "/old";
1451 char dest[] = "/new";
1454 r = guestfs_cp (g, src, dest);
1459 char path[] = "/old";
1462 r = guestfs_is_file (g, path);
1466 fprintf (stderr, "test_cp_1: expected true, got false\n");
1473 static int test_cp_2 (void)
1475 /* InitBasicFS for cp (2): create ext2 on /dev/sda1 */
1477 char device[] = "/dev/sda";
1478 device[5] = devchar;
1481 r = guestfs_blockdev_setrw (g, device);
1488 r = guestfs_umount_all (g);
1495 r = guestfs_lvm_remove_all (g);
1500 char device[] = "/dev/sda";
1501 device[5] = devchar;
1502 char lines_0[] = ",";
1509 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1514 char fstype[] = "ext2";
1515 char device[] = "/dev/sda1";
1516 device[5] = devchar;
1519 r = guestfs_mkfs (g, fstype, device);
1524 char device[] = "/dev/sda1";
1525 device[5] = devchar;
1526 char mountpoint[] = "/";
1529 r = guestfs_mount (g, device, mountpoint);
1533 /* TestOutput for cp (2) */
1534 char expected[] = "file content";
1536 char path[] = "/old";
1537 char content[] = "file content";
1540 r = guestfs_write_file (g, path, content, 0);
1545 char path[] = "/dir";
1548 r = guestfs_mkdir (g, path);
1553 char src[] = "/old";
1554 char dest[] = "/dir/new";
1557 r = guestfs_cp (g, src, dest);
1562 char path[] = "/dir/new";
1565 r = guestfs_cat (g, path);
1568 if (strcmp (r, expected) != 0) {
1569 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
1577 static int test_grub_install_0 (void)
1579 /* InitBasicFS for grub_install (0): create ext2 on /dev/sda1 */
1581 char device[] = "/dev/sda";
1582 device[5] = devchar;
1585 r = guestfs_blockdev_setrw (g, device);
1592 r = guestfs_umount_all (g);
1599 r = guestfs_lvm_remove_all (g);
1604 char device[] = "/dev/sda";
1605 device[5] = devchar;
1606 char lines_0[] = ",";
1613 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1618 char fstype[] = "ext2";
1619 char device[] = "/dev/sda1";
1620 device[5] = devchar;
1623 r = guestfs_mkfs (g, fstype, device);
1628 char device[] = "/dev/sda1";
1629 device[5] = devchar;
1630 char mountpoint[] = "/";
1633 r = guestfs_mount (g, device, mountpoint);
1637 /* TestOutputTrue for grub_install (0) */
1640 char device[] = "/dev/sda1";
1641 device[5] = devchar;
1644 r = guestfs_grub_install (g, root, device);
1649 char path[] = "/boot";
1652 r = guestfs_is_dir (g, path);
1656 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
1663 static int test_zero_0 (void)
1665 /* InitBasicFS for zero (0): create ext2 on /dev/sda1 */
1667 char device[] = "/dev/sda";
1668 device[5] = devchar;
1671 r = guestfs_blockdev_setrw (g, device);
1678 r = guestfs_umount_all (g);
1685 r = guestfs_lvm_remove_all (g);
1690 char device[] = "/dev/sda";
1691 device[5] = devchar;
1692 char lines_0[] = ",";
1699 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1704 char fstype[] = "ext2";
1705 char device[] = "/dev/sda1";
1706 device[5] = devchar;
1709 r = guestfs_mkfs (g, fstype, device);
1714 char device[] = "/dev/sda1";
1715 device[5] = devchar;
1716 char mountpoint[] = "/";
1719 r = guestfs_mount (g, device, mountpoint);
1723 /* TestOutput for zero (0) */
1724 char expected[] = "data";
1726 char pathordevice[] = "/dev/sda1";
1727 pathordevice[5] = devchar;
1730 r = guestfs_umount (g, pathordevice);
1735 char device[] = "/dev/sda1";
1736 device[5] = devchar;
1739 r = guestfs_zero (g, device);
1744 char path[] = "/dev/sda1";
1748 r = guestfs_file (g, path);
1751 if (strcmp (r, expected) != 0) {
1752 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
1760 static int test_fsck_0 (void)
1762 /* InitBasicFS for fsck (0): create ext2 on /dev/sda1 */
1764 char device[] = "/dev/sda";
1765 device[5] = devchar;
1768 r = guestfs_blockdev_setrw (g, device);
1775 r = guestfs_umount_all (g);
1782 r = guestfs_lvm_remove_all (g);
1787 char device[] = "/dev/sda";
1788 device[5] = devchar;
1789 char lines_0[] = ",";
1796 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1801 char fstype[] = "ext2";
1802 char device[] = "/dev/sda1";
1803 device[5] = devchar;
1806 r = guestfs_mkfs (g, fstype, device);
1811 char device[] = "/dev/sda1";
1812 device[5] = devchar;
1813 char mountpoint[] = "/";
1816 r = guestfs_mount (g, device, mountpoint);
1820 /* TestOutputInt for fsck (0) */
1822 char pathordevice[] = "/dev/sda1";
1823 pathordevice[5] = devchar;
1826 r = guestfs_umount (g, pathordevice);
1831 char fstype[] = "ext2";
1832 char device[] = "/dev/sda1";
1833 device[5] = devchar;
1836 r = guestfs_fsck (g, fstype, device);
1840 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
1847 static int test_fsck_1 (void)
1849 /* InitBasicFS for fsck (1): create ext2 on /dev/sda1 */
1851 char device[] = "/dev/sda";
1852 device[5] = devchar;
1855 r = guestfs_blockdev_setrw (g, device);
1862 r = guestfs_umount_all (g);
1869 r = guestfs_lvm_remove_all (g);
1874 char device[] = "/dev/sda";
1875 device[5] = devchar;
1876 char lines_0[] = ",";
1883 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1888 char fstype[] = "ext2";
1889 char device[] = "/dev/sda1";
1890 device[5] = devchar;
1893 r = guestfs_mkfs (g, fstype, device);
1898 char device[] = "/dev/sda1";
1899 device[5] = devchar;
1900 char mountpoint[] = "/";
1903 r = guestfs_mount (g, device, mountpoint);
1907 /* TestOutputInt for fsck (1) */
1909 char pathordevice[] = "/dev/sda1";
1910 pathordevice[5] = devchar;
1913 r = guestfs_umount (g, pathordevice);
1918 char device[] = "/dev/sda1";
1919 device[5] = devchar;
1922 r = guestfs_zero (g, device);
1927 char fstype[] = "ext2";
1928 char device[] = "/dev/sda1";
1929 device[5] = devchar;
1932 r = guestfs_fsck (g, fstype, device);
1936 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
1943 static int test_set_e2uuid_0 (void)
1945 /* InitBasicFS for set_e2uuid (0): create ext2 on /dev/sda1 */
1947 char device[] = "/dev/sda";
1948 device[5] = devchar;
1951 r = guestfs_blockdev_setrw (g, device);
1958 r = guestfs_umount_all (g);
1965 r = guestfs_lvm_remove_all (g);
1970 char device[] = "/dev/sda";
1971 device[5] = devchar;
1972 char lines_0[] = ",";
1979 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1984 char fstype[] = "ext2";
1985 char device[] = "/dev/sda1";
1986 device[5] = devchar;
1989 r = guestfs_mkfs (g, fstype, device);
1994 char device[] = "/dev/sda1";
1995 device[5] = devchar;
1996 char mountpoint[] = "/";
1999 r = guestfs_mount (g, device, mountpoint);
2003 /* TestOutput for set_e2uuid (0) */
2004 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2006 char device[] = "/dev/sda1";
2007 device[5] = devchar;
2008 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2011 r = guestfs_set_e2uuid (g, device, uuid);
2016 char device[] = "/dev/sda1";
2017 device[5] = devchar;
2020 r = guestfs_get_e2uuid (g, device);
2023 if (strcmp (r, expected) != 0) {
2024 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2032 static int test_set_e2uuid_1 (void)
2034 /* InitBasicFS for set_e2uuid (1): create ext2 on /dev/sda1 */
2036 char device[] = "/dev/sda";
2037 device[5] = devchar;
2040 r = guestfs_blockdev_setrw (g, device);
2047 r = guestfs_umount_all (g);
2054 r = guestfs_lvm_remove_all (g);
2059 char device[] = "/dev/sda";
2060 device[5] = devchar;
2061 char lines_0[] = ",";
2068 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2073 char fstype[] = "ext2";
2074 char device[] = "/dev/sda1";
2075 device[5] = devchar;
2078 r = guestfs_mkfs (g, fstype, device);
2083 char device[] = "/dev/sda1";
2084 device[5] = devchar;
2085 char mountpoint[] = "/";
2088 r = guestfs_mount (g, device, mountpoint);
2092 /* TestOutput for set_e2uuid (1) */
2093 char expected[] = "";
2095 char device[] = "/dev/sda1";
2096 device[5] = devchar;
2097 char uuid[] = "clear";
2100 r = guestfs_set_e2uuid (g, device, uuid);
2105 char device[] = "/dev/sda1";
2106 device[5] = devchar;
2109 r = guestfs_get_e2uuid (g, device);
2112 if (strcmp (r, expected) != 0) {
2113 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2121 static int test_set_e2uuid_2 (void)
2123 /* InitBasicFS for set_e2uuid (2): create ext2 on /dev/sda1 */
2125 char device[] = "/dev/sda";
2126 device[5] = devchar;
2129 r = guestfs_blockdev_setrw (g, device);
2136 r = guestfs_umount_all (g);
2143 r = guestfs_lvm_remove_all (g);
2148 char device[] = "/dev/sda";
2149 device[5] = devchar;
2150 char lines_0[] = ",";
2157 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2162 char fstype[] = "ext2";
2163 char device[] = "/dev/sda1";
2164 device[5] = devchar;
2167 r = guestfs_mkfs (g, fstype, device);
2172 char device[] = "/dev/sda1";
2173 device[5] = devchar;
2174 char mountpoint[] = "/";
2177 r = guestfs_mount (g, device, mountpoint);
2181 /* TestRun for set_e2uuid (2) */
2183 char device[] = "/dev/sda1";
2184 device[5] = devchar;
2185 char uuid[] = "random";
2188 r = guestfs_set_e2uuid (g, device, uuid);
2195 static int test_set_e2uuid_3 (void)
2197 /* InitBasicFS for set_e2uuid (3): create ext2 on /dev/sda1 */
2199 char device[] = "/dev/sda";
2200 device[5] = devchar;
2203 r = guestfs_blockdev_setrw (g, device);
2210 r = guestfs_umount_all (g);
2217 r = guestfs_lvm_remove_all (g);
2222 char device[] = "/dev/sda";
2223 device[5] = devchar;
2224 char lines_0[] = ",";
2231 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2236 char fstype[] = "ext2";
2237 char device[] = "/dev/sda1";
2238 device[5] = devchar;
2241 r = guestfs_mkfs (g, fstype, device);
2246 char device[] = "/dev/sda1";
2247 device[5] = devchar;
2248 char mountpoint[] = "/";
2251 r = guestfs_mount (g, device, mountpoint);
2255 /* TestRun for set_e2uuid (3) */
2257 char device[] = "/dev/sda1";
2258 device[5] = devchar;
2259 char uuid[] = "time";
2262 r = guestfs_set_e2uuid (g, device, uuid);
2269 static int test_set_e2label_0 (void)
2271 /* InitBasicFS for set_e2label (0): create ext2 on /dev/sda1 */
2273 char device[] = "/dev/sda";
2274 device[5] = devchar;
2277 r = guestfs_blockdev_setrw (g, device);
2284 r = guestfs_umount_all (g);
2291 r = guestfs_lvm_remove_all (g);
2296 char device[] = "/dev/sda";
2297 device[5] = devchar;
2298 char lines_0[] = ",";
2305 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2310 char fstype[] = "ext2";
2311 char device[] = "/dev/sda1";
2312 device[5] = devchar;
2315 r = guestfs_mkfs (g, fstype, device);
2320 char device[] = "/dev/sda1";
2321 device[5] = devchar;
2322 char mountpoint[] = "/";
2325 r = guestfs_mount (g, device, mountpoint);
2329 /* TestOutput for set_e2label (0) */
2330 char expected[] = "testlabel";
2332 char device[] = "/dev/sda1";
2333 device[5] = devchar;
2334 char label[] = "testlabel";
2337 r = guestfs_set_e2label (g, device, label);
2342 char device[] = "/dev/sda1";
2343 device[5] = devchar;
2346 r = guestfs_get_e2label (g, device);
2349 if (strcmp (r, expected) != 0) {
2350 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2358 static int test_pvremove_0 (void)
2360 /* InitEmpty for pvremove (0) */
2362 char device[] = "/dev/sda";
2363 device[5] = devchar;
2366 r = guestfs_blockdev_setrw (g, device);
2373 r = guestfs_umount_all (g);
2380 r = guestfs_lvm_remove_all (g);
2384 /* TestOutputList for pvremove (0) */
2386 char device[] = "/dev/sda";
2387 device[5] = devchar;
2390 r = guestfs_pvcreate (g, device);
2395 char volgroup[] = "VG";
2396 char physvols_0[] = "/dev/sda";
2397 physvols_0[5] = devchar;
2398 char *physvols[] = {
2404 r = guestfs_vgcreate (g, volgroup, physvols);
2409 char logvol[] = "LV1";
2410 char volgroup[] = "VG";
2413 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2418 char logvol[] = "LV2";
2419 char volgroup[] = "VG";
2422 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2427 char vgname[] = "VG";
2430 r = guestfs_vgremove (g, vgname);
2435 char device[] = "/dev/sda";
2436 device[5] = devchar;
2439 r = guestfs_pvremove (g, device);
2447 r = guestfs_lvs (g);
2451 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2455 for (i = 0; r[i] != NULL; ++i)
2462 static int test_pvremove_1 (void)
2464 /* InitEmpty for pvremove (1) */
2466 char device[] = "/dev/sda";
2467 device[5] = devchar;
2470 r = guestfs_blockdev_setrw (g, device);
2477 r = guestfs_umount_all (g);
2484 r = guestfs_lvm_remove_all (g);
2488 /* TestOutputList for pvremove (1) */
2490 char device[] = "/dev/sda";
2491 device[5] = devchar;
2494 r = guestfs_pvcreate (g, device);
2499 char volgroup[] = "VG";
2500 char physvols_0[] = "/dev/sda";
2501 physvols_0[5] = devchar;
2502 char *physvols[] = {
2508 r = guestfs_vgcreate (g, volgroup, physvols);
2513 char logvol[] = "LV1";
2514 char volgroup[] = "VG";
2517 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2522 char logvol[] = "LV2";
2523 char volgroup[] = "VG";
2526 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2531 char vgname[] = "VG";
2534 r = guestfs_vgremove (g, vgname);
2539 char device[] = "/dev/sda";
2540 device[5] = devchar;
2543 r = guestfs_pvremove (g, device);
2551 r = guestfs_vgs (g);
2555 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
2559 for (i = 0; r[i] != NULL; ++i)
2566 static int test_pvremove_2 (void)
2568 /* InitEmpty for pvremove (2) */
2570 char device[] = "/dev/sda";
2571 device[5] = devchar;
2574 r = guestfs_blockdev_setrw (g, device);
2581 r = guestfs_umount_all (g);
2588 r = guestfs_lvm_remove_all (g);
2592 /* TestOutputList for pvremove (2) */
2594 char device[] = "/dev/sda";
2595 device[5] = devchar;
2598 r = guestfs_pvcreate (g, device);
2603 char volgroup[] = "VG";
2604 char physvols_0[] = "/dev/sda";
2605 physvols_0[5] = devchar;
2606 char *physvols[] = {
2612 r = guestfs_vgcreate (g, volgroup, physvols);
2617 char logvol[] = "LV1";
2618 char volgroup[] = "VG";
2621 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2626 char logvol[] = "LV2";
2627 char volgroup[] = "VG";
2630 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2635 char vgname[] = "VG";
2638 r = guestfs_vgremove (g, vgname);
2643 char device[] = "/dev/sda";
2644 device[5] = devchar;
2647 r = guestfs_pvremove (g, device);
2655 r = guestfs_pvs (g);
2659 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
2663 for (i = 0; r[i] != NULL; ++i)
2670 static int test_vgremove_0 (void)
2672 /* InitEmpty for vgremove (0) */
2674 char device[] = "/dev/sda";
2675 device[5] = devchar;
2678 r = guestfs_blockdev_setrw (g, device);
2685 r = guestfs_umount_all (g);
2692 r = guestfs_lvm_remove_all (g);
2696 /* TestOutputList for vgremove (0) */
2698 char device[] = "/dev/sda";
2699 device[5] = devchar;
2702 r = guestfs_pvcreate (g, device);
2707 char volgroup[] = "VG";
2708 char physvols_0[] = "/dev/sda";
2709 physvols_0[5] = devchar;
2710 char *physvols[] = {
2716 r = guestfs_vgcreate (g, volgroup, physvols);
2721 char logvol[] = "LV1";
2722 char volgroup[] = "VG";
2725 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2730 char logvol[] = "LV2";
2731 char volgroup[] = "VG";
2734 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2739 char vgname[] = "VG";
2742 r = guestfs_vgremove (g, vgname);
2750 r = guestfs_lvs (g);
2754 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
2758 for (i = 0; r[i] != NULL; ++i)
2765 static int test_vgremove_1 (void)
2767 /* InitEmpty for vgremove (1) */
2769 char device[] = "/dev/sda";
2770 device[5] = devchar;
2773 r = guestfs_blockdev_setrw (g, device);
2780 r = guestfs_umount_all (g);
2787 r = guestfs_lvm_remove_all (g);
2791 /* TestOutputList for vgremove (1) */
2793 char device[] = "/dev/sda";
2794 device[5] = devchar;
2797 r = guestfs_pvcreate (g, device);
2802 char volgroup[] = "VG";
2803 char physvols_0[] = "/dev/sda";
2804 physvols_0[5] = devchar;
2805 char *physvols[] = {
2811 r = guestfs_vgcreate (g, volgroup, physvols);
2816 char logvol[] = "LV1";
2817 char volgroup[] = "VG";
2820 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2825 char logvol[] = "LV2";
2826 char volgroup[] = "VG";
2829 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2834 char vgname[] = "VG";
2837 r = guestfs_vgremove (g, vgname);
2845 r = guestfs_vgs (g);
2849 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
2853 for (i = 0; r[i] != NULL; ++i)
2860 static int test_lvremove_0 (void)
2862 /* InitEmpty for lvremove (0) */
2864 char device[] = "/dev/sda";
2865 device[5] = devchar;
2868 r = guestfs_blockdev_setrw (g, device);
2875 r = guestfs_umount_all (g);
2882 r = guestfs_lvm_remove_all (g);
2886 /* TestOutputList for lvremove (0) */
2888 char device[] = "/dev/sda";
2889 device[5] = devchar;
2892 r = guestfs_pvcreate (g, device);
2897 char volgroup[] = "VG";
2898 char physvols_0[] = "/dev/sda";
2899 physvols_0[5] = devchar;
2900 char *physvols[] = {
2906 r = guestfs_vgcreate (g, volgroup, physvols);
2911 char logvol[] = "LV1";
2912 char volgroup[] = "VG";
2915 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2920 char logvol[] = "LV2";
2921 char volgroup[] = "VG";
2924 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2929 char device[] = "/dev/VG/LV1";
2932 r = guestfs_lvremove (g, device);
2940 r = guestfs_lvs (g);
2944 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
2949 char expected[] = "/dev/VG/LV2";
2950 if (strcmp (r[0], expected) != 0) {
2951 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2956 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
2960 for (i = 0; r[i] != NULL; ++i)
2967 static int test_lvremove_1 (void)
2969 /* InitEmpty for lvremove (1) */
2971 char device[] = "/dev/sda";
2972 device[5] = devchar;
2975 r = guestfs_blockdev_setrw (g, device);
2982 r = guestfs_umount_all (g);
2989 r = guestfs_lvm_remove_all (g);
2993 /* TestOutputList for lvremove (1) */
2995 char device[] = "/dev/sda";
2996 device[5] = devchar;
2999 r = guestfs_pvcreate (g, device);
3004 char volgroup[] = "VG";
3005 char physvols_0[] = "/dev/sda";
3006 physvols_0[5] = devchar;
3007 char *physvols[] = {
3013 r = guestfs_vgcreate (g, volgroup, physvols);
3018 char logvol[] = "LV1";
3019 char volgroup[] = "VG";
3022 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3027 char logvol[] = "LV2";
3028 char volgroup[] = "VG";
3031 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3036 char device[] = "/dev/VG";
3039 r = guestfs_lvremove (g, device);
3047 r = guestfs_lvs (g);
3051 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3055 for (i = 0; r[i] != NULL; ++i)
3062 static int test_lvremove_2 (void)
3064 /* InitEmpty for lvremove (2) */
3066 char device[] = "/dev/sda";
3067 device[5] = devchar;
3070 r = guestfs_blockdev_setrw (g, device);
3077 r = guestfs_umount_all (g);
3084 r = guestfs_lvm_remove_all (g);
3088 /* TestOutputList for lvremove (2) */
3090 char device[] = "/dev/sda";
3091 device[5] = devchar;
3094 r = guestfs_pvcreate (g, device);
3099 char volgroup[] = "VG";
3100 char physvols_0[] = "/dev/sda";
3101 physvols_0[5] = devchar;
3102 char *physvols[] = {
3108 r = guestfs_vgcreate (g, volgroup, physvols);
3113 char logvol[] = "LV1";
3114 char volgroup[] = "VG";
3117 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3122 char logvol[] = "LV2";
3123 char volgroup[] = "VG";
3126 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3131 char device[] = "/dev/VG";
3134 r = guestfs_lvremove (g, device);
3142 r = guestfs_vgs (g);
3146 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3151 char expected[] = "VG";
3152 if (strcmp (r[0], expected) != 0) {
3153 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3158 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3162 for (i = 0; r[i] != NULL; ++i)
3169 static int test_mount_ro_0 (void)
3171 /* InitBasicFS for mount_ro (0): create ext2 on /dev/sda1 */
3173 char device[] = "/dev/sda";
3174 device[5] = devchar;
3177 r = guestfs_blockdev_setrw (g, device);
3184 r = guestfs_umount_all (g);
3191 r = guestfs_lvm_remove_all (g);
3196 char device[] = "/dev/sda";
3197 device[5] = devchar;
3198 char lines_0[] = ",";
3205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3210 char fstype[] = "ext2";
3211 char device[] = "/dev/sda1";
3212 device[5] = devchar;
3215 r = guestfs_mkfs (g, fstype, device);
3220 char device[] = "/dev/sda1";
3221 device[5] = devchar;
3222 char mountpoint[] = "/";
3225 r = guestfs_mount (g, device, mountpoint);
3229 /* TestLastFail for mount_ro (0) */
3231 char pathordevice[] = "/";
3234 r = guestfs_umount (g, pathordevice);
3239 char device[] = "/dev/sda1";
3240 device[5] = devchar;
3241 char mountpoint[] = "/";
3244 r = guestfs_mount_ro (g, device, mountpoint);
3249 char path[] = "/new";
3252 r = guestfs_touch (g, path);
3259 static int test_mount_ro_1 (void)
3261 /* InitBasicFS for mount_ro (1): create ext2 on /dev/sda1 */
3263 char device[] = "/dev/sda";
3264 device[5] = devchar;
3267 r = guestfs_blockdev_setrw (g, device);
3274 r = guestfs_umount_all (g);
3281 r = guestfs_lvm_remove_all (g);
3286 char device[] = "/dev/sda";
3287 device[5] = devchar;
3288 char lines_0[] = ",";
3295 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3300 char fstype[] = "ext2";
3301 char device[] = "/dev/sda1";
3302 device[5] = devchar;
3305 r = guestfs_mkfs (g, fstype, device);
3310 char device[] = "/dev/sda1";
3311 device[5] = devchar;
3312 char mountpoint[] = "/";
3315 r = guestfs_mount (g, device, mountpoint);
3319 /* TestOutput for mount_ro (1) */
3320 char expected[] = "data";
3322 char path[] = "/new";
3323 char content[] = "data";
3326 r = guestfs_write_file (g, path, content, 0);
3331 char pathordevice[] = "/";
3334 r = guestfs_umount (g, pathordevice);
3339 char device[] = "/dev/sda1";
3340 device[5] = devchar;
3341 char mountpoint[] = "/";
3344 r = guestfs_mount_ro (g, device, mountpoint);
3349 char path[] = "/new";
3352 r = guestfs_cat (g, path);
3355 if (strcmp (r, expected) != 0) {
3356 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3364 static int test_tgz_in_0 (void)
3366 /* InitBasicFS for tgz_in (0): create ext2 on /dev/sda1 */
3368 char device[] = "/dev/sda";
3369 device[5] = devchar;
3372 r = guestfs_blockdev_setrw (g, device);
3379 r = guestfs_umount_all (g);
3386 r = guestfs_lvm_remove_all (g);
3391 char device[] = "/dev/sda";
3392 device[5] = devchar;
3393 char lines_0[] = ",";
3400 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3405 char fstype[] = "ext2";
3406 char device[] = "/dev/sda1";
3407 device[5] = devchar;
3410 r = guestfs_mkfs (g, fstype, device);
3415 char device[] = "/dev/sda1";
3416 device[5] = devchar;
3417 char mountpoint[] = "/";
3420 r = guestfs_mount (g, device, mountpoint);
3424 /* TestOutput for tgz_in (0) */
3425 char expected[] = "hello\n";
3427 char directory[] = "/";
3430 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3435 char path[] = "/hello";
3438 r = guestfs_cat (g, path);
3441 if (strcmp (r, expected) != 0) {
3442 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3450 static int test_tar_in_0 (void)
3452 /* InitBasicFS for tar_in (0): create ext2 on /dev/sda1 */
3454 char device[] = "/dev/sda";
3455 device[5] = devchar;
3458 r = guestfs_blockdev_setrw (g, device);
3465 r = guestfs_umount_all (g);
3472 r = guestfs_lvm_remove_all (g);
3477 char device[] = "/dev/sda";
3478 device[5] = devchar;
3479 char lines_0[] = ",";
3486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3491 char fstype[] = "ext2";
3492 char device[] = "/dev/sda1";
3493 device[5] = devchar;
3496 r = guestfs_mkfs (g, fstype, device);
3501 char device[] = "/dev/sda1";
3502 device[5] = devchar;
3503 char mountpoint[] = "/";
3506 r = guestfs_mount (g, device, mountpoint);
3510 /* TestOutput for tar_in (0) */
3511 char expected[] = "hello\n";
3513 char directory[] = "/";
3516 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
3521 char path[] = "/hello";
3524 r = guestfs_cat (g, path);
3527 if (strcmp (r, expected) != 0) {
3528 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3536 static int test_checksum_0 (void)
3538 /* InitBasicFS for checksum (0): create ext2 on /dev/sda1 */
3540 char device[] = "/dev/sda";
3541 device[5] = devchar;
3544 r = guestfs_blockdev_setrw (g, device);
3551 r = guestfs_umount_all (g);
3558 r = guestfs_lvm_remove_all (g);
3563 char device[] = "/dev/sda";
3564 device[5] = devchar;
3565 char lines_0[] = ",";
3572 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3577 char fstype[] = "ext2";
3578 char device[] = "/dev/sda1";
3579 device[5] = devchar;
3582 r = guestfs_mkfs (g, fstype, device);
3587 char device[] = "/dev/sda1";
3588 device[5] = devchar;
3589 char mountpoint[] = "/";
3592 r = guestfs_mount (g, device, mountpoint);
3596 /* TestOutput for checksum (0) */
3597 char expected[] = "935282863";
3599 char path[] = "/new";
3600 char content[] = "test\n";
3603 r = guestfs_write_file (g, path, content, 0);
3608 char csumtype[] = "crc";
3609 char path[] = "/new";
3612 r = guestfs_checksum (g, csumtype, path);
3615 if (strcmp (r, expected) != 0) {
3616 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
3624 static int test_checksum_1 (void)
3626 /* InitBasicFS for checksum (1): create ext2 on /dev/sda1 */
3628 char device[] = "/dev/sda";
3629 device[5] = devchar;
3632 r = guestfs_blockdev_setrw (g, device);
3639 r = guestfs_umount_all (g);
3646 r = guestfs_lvm_remove_all (g);
3651 char device[] = "/dev/sda";
3652 device[5] = devchar;
3653 char lines_0[] = ",";
3660 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3665 char fstype[] = "ext2";
3666 char device[] = "/dev/sda1";
3667 device[5] = devchar;
3670 r = guestfs_mkfs (g, fstype, device);
3675 char device[] = "/dev/sda1";
3676 device[5] = devchar;
3677 char mountpoint[] = "/";
3680 r = guestfs_mount (g, device, mountpoint);
3684 /* TestLastFail for checksum (1) */
3686 char csumtype[] = "crc";
3687 char path[] = "/new";
3690 r = guestfs_checksum (g, csumtype, path);
3698 static int test_checksum_2 (void)
3700 /* InitBasicFS for checksum (2): create ext2 on /dev/sda1 */
3702 char device[] = "/dev/sda";
3703 device[5] = devchar;
3706 r = guestfs_blockdev_setrw (g, device);
3713 r = guestfs_umount_all (g);
3720 r = guestfs_lvm_remove_all (g);
3725 char device[] = "/dev/sda";
3726 device[5] = devchar;
3727 char lines_0[] = ",";
3734 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3739 char fstype[] = "ext2";
3740 char device[] = "/dev/sda1";
3741 device[5] = devchar;
3744 r = guestfs_mkfs (g, fstype, device);
3749 char device[] = "/dev/sda1";
3750 device[5] = devchar;
3751 char mountpoint[] = "/";
3754 r = guestfs_mount (g, device, mountpoint);
3758 /* TestOutput for checksum (2) */
3759 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
3761 char path[] = "/new";
3762 char content[] = "test\n";
3765 r = guestfs_write_file (g, path, content, 0);
3770 char csumtype[] = "md5";
3771 char path[] = "/new";
3774 r = guestfs_checksum (g, csumtype, path);
3777 if (strcmp (r, expected) != 0) {
3778 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
3786 static int test_checksum_3 (void)
3788 /* InitBasicFS for checksum (3): create ext2 on /dev/sda1 */
3790 char device[] = "/dev/sda";
3791 device[5] = devchar;
3794 r = guestfs_blockdev_setrw (g, device);
3801 r = guestfs_umount_all (g);
3808 r = guestfs_lvm_remove_all (g);
3813 char device[] = "/dev/sda";
3814 device[5] = devchar;
3815 char lines_0[] = ",";
3822 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3827 char fstype[] = "ext2";
3828 char device[] = "/dev/sda1";
3829 device[5] = devchar;
3832 r = guestfs_mkfs (g, fstype, device);
3837 char device[] = "/dev/sda1";
3838 device[5] = devchar;
3839 char mountpoint[] = "/";
3842 r = guestfs_mount (g, device, mountpoint);
3846 /* TestOutput for checksum (3) */
3847 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
3849 char path[] = "/new";
3850 char content[] = "test\n";
3853 r = guestfs_write_file (g, path, content, 0);
3858 char csumtype[] = "sha1";
3859 char path[] = "/new";
3862 r = guestfs_checksum (g, csumtype, path);
3865 if (strcmp (r, expected) != 0) {
3866 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
3874 static int test_checksum_4 (void)
3876 /* InitBasicFS for checksum (4): create ext2 on /dev/sda1 */
3878 char device[] = "/dev/sda";
3879 device[5] = devchar;
3882 r = guestfs_blockdev_setrw (g, device);
3889 r = guestfs_umount_all (g);
3896 r = guestfs_lvm_remove_all (g);
3901 char device[] = "/dev/sda";
3902 device[5] = devchar;
3903 char lines_0[] = ",";
3910 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3915 char fstype[] = "ext2";
3916 char device[] = "/dev/sda1";
3917 device[5] = devchar;
3920 r = guestfs_mkfs (g, fstype, device);
3925 char device[] = "/dev/sda1";
3926 device[5] = devchar;
3927 char mountpoint[] = "/";
3930 r = guestfs_mount (g, device, mountpoint);
3934 /* TestOutput for checksum (4) */
3935 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
3937 char path[] = "/new";
3938 char content[] = "test\n";
3941 r = guestfs_write_file (g, path, content, 0);
3946 char csumtype[] = "sha224";
3947 char path[] = "/new";
3950 r = guestfs_checksum (g, csumtype, path);
3953 if (strcmp (r, expected) != 0) {
3954 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
3962 static int test_checksum_5 (void)
3964 /* InitBasicFS for checksum (5): create ext2 on /dev/sda1 */
3966 char device[] = "/dev/sda";
3967 device[5] = devchar;
3970 r = guestfs_blockdev_setrw (g, device);
3977 r = guestfs_umount_all (g);
3984 r = guestfs_lvm_remove_all (g);
3989 char device[] = "/dev/sda";
3990 device[5] = devchar;
3991 char lines_0[] = ",";
3998 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4003 char fstype[] = "ext2";
4004 char device[] = "/dev/sda1";
4005 device[5] = devchar;
4008 r = guestfs_mkfs (g, fstype, device);
4013 char device[] = "/dev/sda1";
4014 device[5] = devchar;
4015 char mountpoint[] = "/";
4018 r = guestfs_mount (g, device, mountpoint);
4022 /* TestOutput for checksum (5) */
4023 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4025 char path[] = "/new";
4026 char content[] = "test\n";
4029 r = guestfs_write_file (g, path, content, 0);
4034 char csumtype[] = "sha256";
4035 char path[] = "/new";
4038 r = guestfs_checksum (g, csumtype, path);
4041 if (strcmp (r, expected) != 0) {
4042 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4050 static int test_checksum_6 (void)
4052 /* InitBasicFS for checksum (6): create ext2 on /dev/sda1 */
4054 char device[] = "/dev/sda";
4055 device[5] = devchar;
4058 r = guestfs_blockdev_setrw (g, device);
4065 r = guestfs_umount_all (g);
4072 r = guestfs_lvm_remove_all (g);
4077 char device[] = "/dev/sda";
4078 device[5] = devchar;
4079 char lines_0[] = ",";
4086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4091 char fstype[] = "ext2";
4092 char device[] = "/dev/sda1";
4093 device[5] = devchar;
4096 r = guestfs_mkfs (g, fstype, device);
4101 char device[] = "/dev/sda1";
4102 device[5] = devchar;
4103 char mountpoint[] = "/";
4106 r = guestfs_mount (g, device, mountpoint);
4110 /* TestOutput for checksum (6) */
4111 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4113 char path[] = "/new";
4114 char content[] = "test\n";
4117 r = guestfs_write_file (g, path, content, 0);
4122 char csumtype[] = "sha384";
4123 char path[] = "/new";
4126 r = guestfs_checksum (g, csumtype, path);
4129 if (strcmp (r, expected) != 0) {
4130 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4138 static int test_checksum_7 (void)
4140 /* InitBasicFS for checksum (7): create ext2 on /dev/sda1 */
4142 char device[] = "/dev/sda";
4143 device[5] = devchar;
4146 r = guestfs_blockdev_setrw (g, device);
4153 r = guestfs_umount_all (g);
4160 r = guestfs_lvm_remove_all (g);
4165 char device[] = "/dev/sda";
4166 device[5] = devchar;
4167 char lines_0[] = ",";
4174 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4179 char fstype[] = "ext2";
4180 char device[] = "/dev/sda1";
4181 device[5] = devchar;
4184 r = guestfs_mkfs (g, fstype, device);
4189 char device[] = "/dev/sda1";
4190 device[5] = devchar;
4191 char mountpoint[] = "/";
4194 r = guestfs_mount (g, device, mountpoint);
4198 /* TestOutput for checksum (7) */
4199 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4201 char path[] = "/new";
4202 char content[] = "test\n";
4205 r = guestfs_write_file (g, path, content, 0);
4210 char csumtype[] = "sha512";
4211 char path[] = "/new";
4214 r = guestfs_checksum (g, csumtype, path);
4217 if (strcmp (r, expected) != 0) {
4218 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4226 static int test_download_0 (void)
4228 /* InitBasicFS for download (0): create ext2 on /dev/sda1 */
4230 char device[] = "/dev/sda";
4231 device[5] = devchar;
4234 r = guestfs_blockdev_setrw (g, device);
4241 r = guestfs_umount_all (g);
4248 r = guestfs_lvm_remove_all (g);
4253 char device[] = "/dev/sda";
4254 device[5] = devchar;
4255 char lines_0[] = ",";
4262 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4267 char fstype[] = "ext2";
4268 char device[] = "/dev/sda1";
4269 device[5] = devchar;
4272 r = guestfs_mkfs (g, fstype, device);
4277 char device[] = "/dev/sda1";
4278 device[5] = devchar;
4279 char mountpoint[] = "/";
4282 r = guestfs_mount (g, device, mountpoint);
4286 /* TestOutput for download (0) */
4287 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4289 char remotefilename[] = "/COPYING.LIB";
4292 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4297 char remotefilename[] = "/COPYING.LIB";
4300 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4305 char remotefilename[] = "/upload";
4308 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4313 char csumtype[] = "md5";
4314 char path[] = "/upload";
4317 r = guestfs_checksum (g, csumtype, path);
4320 if (strcmp (r, expected) != 0) {
4321 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4329 static int test_upload_0 (void)
4331 /* InitBasicFS for upload (0): create ext2 on /dev/sda1 */
4333 char device[] = "/dev/sda";
4334 device[5] = devchar;
4337 r = guestfs_blockdev_setrw (g, device);
4344 r = guestfs_umount_all (g);
4351 r = guestfs_lvm_remove_all (g);
4356 char device[] = "/dev/sda";
4357 device[5] = devchar;
4358 char lines_0[] = ",";
4365 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4370 char fstype[] = "ext2";
4371 char device[] = "/dev/sda1";
4372 device[5] = devchar;
4375 r = guestfs_mkfs (g, fstype, device);
4380 char device[] = "/dev/sda1";
4381 device[5] = devchar;
4382 char mountpoint[] = "/";
4385 r = guestfs_mount (g, device, mountpoint);
4389 /* TestOutput for upload (0) */
4390 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4392 char remotefilename[] = "/COPYING.LIB";
4395 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4400 char csumtype[] = "md5";
4401 char path[] = "/COPYING.LIB";
4404 r = guestfs_checksum (g, csumtype, path);
4407 if (strcmp (r, expected) != 0) {
4408 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4416 static int test_blockdev_rereadpt_0 (void)
4418 /* InitEmpty for blockdev_rereadpt (0) */
4420 char device[] = "/dev/sda";
4421 device[5] = devchar;
4424 r = guestfs_blockdev_setrw (g, device);
4431 r = guestfs_umount_all (g);
4438 r = guestfs_lvm_remove_all (g);
4442 /* TestRun for blockdev_rereadpt (0) */
4444 char device[] = "/dev/sda";
4445 device[5] = devchar;
4448 r = guestfs_blockdev_rereadpt (g, device);
4455 static int test_blockdev_flushbufs_0 (void)
4457 /* InitEmpty for blockdev_flushbufs (0) */
4459 char device[] = "/dev/sda";
4460 device[5] = devchar;
4463 r = guestfs_blockdev_setrw (g, device);
4470 r = guestfs_umount_all (g);
4477 r = guestfs_lvm_remove_all (g);
4481 /* TestRun for blockdev_flushbufs (0) */
4483 char device[] = "/dev/sda";
4484 device[5] = devchar;
4487 r = guestfs_blockdev_flushbufs (g, device);
4494 static int test_blockdev_getsize64_0 (void)
4496 /* InitEmpty for blockdev_getsize64 (0) */
4498 char device[] = "/dev/sda";
4499 device[5] = devchar;
4502 r = guestfs_blockdev_setrw (g, device);
4509 r = guestfs_umount_all (g);
4516 r = guestfs_lvm_remove_all (g);
4520 /* TestOutputInt for blockdev_getsize64 (0) */
4522 char device[] = "/dev/sda";
4523 device[5] = devchar;
4526 r = guestfs_blockdev_getsize64 (g, device);
4529 if (r != 524288000) {
4530 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
4537 static int test_blockdev_getsz_0 (void)
4539 /* InitEmpty for blockdev_getsz (0) */
4541 char device[] = "/dev/sda";
4542 device[5] = devchar;
4545 r = guestfs_blockdev_setrw (g, device);
4552 r = guestfs_umount_all (g);
4559 r = guestfs_lvm_remove_all (g);
4563 /* TestOutputInt for blockdev_getsz (0) */
4565 char device[] = "/dev/sda";
4566 device[5] = devchar;
4569 r = guestfs_blockdev_getsz (g, device);
4573 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
4580 static int test_blockdev_getbsz_0 (void)
4582 /* InitEmpty for blockdev_getbsz (0) */
4584 char device[] = "/dev/sda";
4585 device[5] = devchar;
4588 r = guestfs_blockdev_setrw (g, device);
4595 r = guestfs_umount_all (g);
4602 r = guestfs_lvm_remove_all (g);
4606 /* TestOutputInt for blockdev_getbsz (0) */
4608 char device[] = "/dev/sda";
4609 device[5] = devchar;
4612 r = guestfs_blockdev_getbsz (g, device);
4616 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
4623 static int test_blockdev_getss_0 (void)
4625 /* InitEmpty for blockdev_getss (0) */
4627 char device[] = "/dev/sda";
4628 device[5] = devchar;
4631 r = guestfs_blockdev_setrw (g, device);
4638 r = guestfs_umount_all (g);
4645 r = guestfs_lvm_remove_all (g);
4649 /* TestOutputInt for blockdev_getss (0) */
4651 char device[] = "/dev/sda";
4652 device[5] = devchar;
4655 r = guestfs_blockdev_getss (g, device);
4659 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
4666 static int test_blockdev_getro_0 (void)
4668 /* InitEmpty for blockdev_getro (0) */
4670 char device[] = "/dev/sda";
4671 device[5] = devchar;
4674 r = guestfs_blockdev_setrw (g, device);
4681 r = guestfs_umount_all (g);
4688 r = guestfs_lvm_remove_all (g);
4692 /* TestOutputTrue for blockdev_getro (0) */
4694 char device[] = "/dev/sda";
4695 device[5] = devchar;
4698 r = guestfs_blockdev_setro (g, device);
4703 char device[] = "/dev/sda";
4704 device[5] = devchar;
4707 r = guestfs_blockdev_getro (g, device);
4711 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
4718 static int test_blockdev_setrw_0 (void)
4720 /* InitEmpty for blockdev_setrw (0) */
4722 char device[] = "/dev/sda";
4723 device[5] = devchar;
4726 r = guestfs_blockdev_setrw (g, device);
4733 r = guestfs_umount_all (g);
4740 r = guestfs_lvm_remove_all (g);
4744 /* TestOutputFalse for blockdev_setrw (0) */
4746 char device[] = "/dev/sda";
4747 device[5] = devchar;
4750 r = guestfs_blockdev_setrw (g, device);
4755 char device[] = "/dev/sda";
4756 device[5] = devchar;
4759 r = guestfs_blockdev_getro (g, device);
4763 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
4770 static int test_blockdev_setro_0 (void)
4772 /* InitEmpty for blockdev_setro (0) */
4774 char device[] = "/dev/sda";
4775 device[5] = devchar;
4778 r = guestfs_blockdev_setrw (g, device);
4785 r = guestfs_umount_all (g);
4792 r = guestfs_lvm_remove_all (g);
4796 /* TestOutputTrue for blockdev_setro (0) */
4798 char device[] = "/dev/sda";
4799 device[5] = devchar;
4802 r = guestfs_blockdev_setro (g, device);
4807 char device[] = "/dev/sda";
4808 device[5] = devchar;
4811 r = guestfs_blockdev_getro (g, device);
4815 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
4822 static int test_statvfs_0 (void)
4824 /* InitBasicFS for statvfs (0): create ext2 on /dev/sda1 */
4826 char device[] = "/dev/sda";
4827 device[5] = devchar;
4830 r = guestfs_blockdev_setrw (g, device);
4837 r = guestfs_umount_all (g);
4844 r = guestfs_lvm_remove_all (g);
4849 char device[] = "/dev/sda";
4850 device[5] = devchar;
4851 char lines_0[] = ",";
4858 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4863 char fstype[] = "ext2";
4864 char device[] = "/dev/sda1";
4865 device[5] = devchar;
4868 r = guestfs_mkfs (g, fstype, device);
4873 char device[] = "/dev/sda1";
4874 device[5] = devchar;
4875 char mountpoint[] = "/";
4878 r = guestfs_mount (g, device, mountpoint);
4882 /* TestOutputStruct for statvfs (0) */
4885 struct guestfs_statvfs *r;
4887 r = guestfs_statvfs (g, path);
4890 if (r->bfree != 487702) {
4891 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
4895 if (r->blocks != 490020) {
4896 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
4900 if (r->bsize != 1024) {
4901 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
4910 static int test_lstat_0 (void)
4912 /* InitBasicFS for lstat (0): create ext2 on /dev/sda1 */
4914 char device[] = "/dev/sda";
4915 device[5] = devchar;
4918 r = guestfs_blockdev_setrw (g, device);
4925 r = guestfs_umount_all (g);
4932 r = guestfs_lvm_remove_all (g);
4937 char device[] = "/dev/sda";
4938 device[5] = devchar;
4939 char lines_0[] = ",";
4946 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4951 char fstype[] = "ext2";
4952 char device[] = "/dev/sda1";
4953 device[5] = devchar;
4956 r = guestfs_mkfs (g, fstype, device);
4961 char device[] = "/dev/sda1";
4962 device[5] = devchar;
4963 char mountpoint[] = "/";
4966 r = guestfs_mount (g, device, mountpoint);
4970 /* TestOutputStruct for lstat (0) */
4972 char path[] = "/new";
4975 r = guestfs_touch (g, path);
4980 char path[] = "/new";
4981 struct guestfs_stat *r;
4983 r = guestfs_lstat (g, path);
4987 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
4996 static int test_stat_0 (void)
4998 /* InitBasicFS for stat (0): create ext2 on /dev/sda1 */
5000 char device[] = "/dev/sda";
5001 device[5] = devchar;
5004 r = guestfs_blockdev_setrw (g, device);
5011 r = guestfs_umount_all (g);
5018 r = guestfs_lvm_remove_all (g);
5023 char device[] = "/dev/sda";
5024 device[5] = devchar;
5025 char lines_0[] = ",";
5032 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5037 char fstype[] = "ext2";
5038 char device[] = "/dev/sda1";
5039 device[5] = devchar;
5042 r = guestfs_mkfs (g, fstype, device);
5047 char device[] = "/dev/sda1";
5048 device[5] = devchar;
5049 char mountpoint[] = "/";
5052 r = guestfs_mount (g, device, mountpoint);
5056 /* TestOutputStruct for stat (0) */
5058 char path[] = "/new";
5061 r = guestfs_touch (g, path);
5066 char path[] = "/new";
5067 struct guestfs_stat *r;
5069 r = guestfs_stat (g, path);
5073 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5082 static int test_command_lines_0_prereq (void)
5084 const char *str = getenv ("SKIP_TEST_COMMAND");
5085 return str && strcmp (str, "1") == 0;
5088 static int test_command_lines_0 (void)
5090 if (! test_command_lines_0_prereq ()) {
5091 /* InitBasicFS for command_lines (0): create ext2 on /dev/sda1 */
5093 char device[] = "/dev/sda";
5094 device[5] = devchar;
5097 r = guestfs_blockdev_setrw (g, device);
5104 r = guestfs_umount_all (g);
5111 r = guestfs_lvm_remove_all (g);
5116 char device[] = "/dev/sda";
5117 device[5] = devchar;
5118 char lines_0[] = ",";
5125 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5130 char fstype[] = "ext2";
5131 char device[] = "/dev/sda1";
5132 device[5] = devchar;
5135 r = guestfs_mkfs (g, fstype, device);
5140 char device[] = "/dev/sda1";
5141 device[5] = devchar;
5142 char mountpoint[] = "/";
5145 r = guestfs_mount (g, device, mountpoint);
5149 /* TestOutputList for command_lines (0) */
5151 char remotefilename[] = "/test-command";
5154 r = guestfs_upload (g, "test-command", remotefilename);
5159 char path[] = "/test-command";
5162 r = guestfs_chmod (g, 493, path);
5167 char arguments_0[] = "/test-command";
5168 char arguments_1[] = "1";
5169 char *arguments[] = {
5177 r = guestfs_command_lines (g, arguments);
5181 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5186 char expected[] = "Result1";
5187 if (strcmp (r[0], expected) != 0) {
5188 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5193 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5197 for (i = 0; r[i] != NULL; ++i)
5202 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5206 static int test_command_lines_1_prereq (void)
5208 const char *str = getenv ("SKIP_TEST_COMMAND");
5209 return str && strcmp (str, "1") == 0;
5212 static int test_command_lines_1 (void)
5214 if (! test_command_lines_1_prereq ()) {
5215 /* InitBasicFS for command_lines (1): create ext2 on /dev/sda1 */
5217 char device[] = "/dev/sda";
5218 device[5] = devchar;
5221 r = guestfs_blockdev_setrw (g, device);
5228 r = guestfs_umount_all (g);
5235 r = guestfs_lvm_remove_all (g);
5240 char device[] = "/dev/sda";
5241 device[5] = devchar;
5242 char lines_0[] = ",";
5249 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5254 char fstype[] = "ext2";
5255 char device[] = "/dev/sda1";
5256 device[5] = devchar;
5259 r = guestfs_mkfs (g, fstype, device);
5264 char device[] = "/dev/sda1";
5265 device[5] = devchar;
5266 char mountpoint[] = "/";
5269 r = guestfs_mount (g, device, mountpoint);
5273 /* TestOutputList for command_lines (1) */
5275 char remotefilename[] = "/test-command";
5278 r = guestfs_upload (g, "test-command", remotefilename);
5283 char path[] = "/test-command";
5286 r = guestfs_chmod (g, 493, path);
5291 char arguments_0[] = "/test-command";
5292 char arguments_1[] = "2";
5293 char *arguments[] = {
5301 r = guestfs_command_lines (g, arguments);
5305 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5310 char expected[] = "Result2";
5311 if (strcmp (r[0], expected) != 0) {
5312 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5317 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5321 for (i = 0; r[i] != NULL; ++i)
5326 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5330 static int test_command_lines_2_prereq (void)
5332 const char *str = getenv ("SKIP_TEST_COMMAND");
5333 return str && strcmp (str, "1") == 0;
5336 static int test_command_lines_2 (void)
5338 if (! test_command_lines_2_prereq ()) {
5339 /* InitBasicFS for command_lines (2): create ext2 on /dev/sda1 */
5341 char device[] = "/dev/sda";
5342 device[5] = devchar;
5345 r = guestfs_blockdev_setrw (g, device);
5352 r = guestfs_umount_all (g);
5359 r = guestfs_lvm_remove_all (g);
5364 char device[] = "/dev/sda";
5365 device[5] = devchar;
5366 char lines_0[] = ",";
5373 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5378 char fstype[] = "ext2";
5379 char device[] = "/dev/sda1";
5380 device[5] = devchar;
5383 r = guestfs_mkfs (g, fstype, device);
5388 char device[] = "/dev/sda1";
5389 device[5] = devchar;
5390 char mountpoint[] = "/";
5393 r = guestfs_mount (g, device, mountpoint);
5397 /* TestOutputList for command_lines (2) */
5399 char remotefilename[] = "/test-command";
5402 r = guestfs_upload (g, "test-command", remotefilename);
5407 char path[] = "/test-command";
5410 r = guestfs_chmod (g, 493, path);
5415 char arguments_0[] = "/test-command";
5416 char arguments_1[] = "3";
5417 char *arguments[] = {
5425 r = guestfs_command_lines (g, arguments);
5429 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5434 char expected[] = "";
5435 if (strcmp (r[0], expected) != 0) {
5436 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5441 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5446 char expected[] = "Result3";
5447 if (strcmp (r[1], expected) != 0) {
5448 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5453 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5457 for (i = 0; r[i] != NULL; ++i)
5462 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
5466 static int test_command_lines_3_prereq (void)
5468 const char *str = getenv ("SKIP_TEST_COMMAND");
5469 return str && strcmp (str, "1") == 0;
5472 static int test_command_lines_3 (void)
5474 if (! test_command_lines_3_prereq ()) {
5475 /* InitBasicFS for command_lines (3): create ext2 on /dev/sda1 */
5477 char device[] = "/dev/sda";
5478 device[5] = devchar;
5481 r = guestfs_blockdev_setrw (g, device);
5488 r = guestfs_umount_all (g);
5495 r = guestfs_lvm_remove_all (g);
5500 char device[] = "/dev/sda";
5501 device[5] = devchar;
5502 char lines_0[] = ",";
5509 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5514 char fstype[] = "ext2";
5515 char device[] = "/dev/sda1";
5516 device[5] = devchar;
5519 r = guestfs_mkfs (g, fstype, device);
5524 char device[] = "/dev/sda1";
5525 device[5] = devchar;
5526 char mountpoint[] = "/";
5529 r = guestfs_mount (g, device, mountpoint);
5533 /* TestOutputList for command_lines (3) */
5535 char remotefilename[] = "/test-command";
5538 r = guestfs_upload (g, "test-command", remotefilename);
5543 char path[] = "/test-command";
5546 r = guestfs_chmod (g, 493, path);
5551 char arguments_0[] = "/test-command";
5552 char arguments_1[] = "4";
5553 char *arguments[] = {
5561 r = guestfs_command_lines (g, arguments);
5565 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5570 char expected[] = "";
5571 if (strcmp (r[0], expected) != 0) {
5572 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5577 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5582 char expected[] = "Result4";
5583 if (strcmp (r[1], expected) != 0) {
5584 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5589 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
5593 for (i = 0; r[i] != NULL; ++i)
5598 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
5602 static int test_command_lines_4_prereq (void)
5604 const char *str = getenv ("SKIP_TEST_COMMAND");
5605 return str && strcmp (str, "1") == 0;
5608 static int test_command_lines_4 (void)
5610 if (! test_command_lines_4_prereq ()) {
5611 /* InitBasicFS for command_lines (4): create ext2 on /dev/sda1 */
5613 char device[] = "/dev/sda";
5614 device[5] = devchar;
5617 r = guestfs_blockdev_setrw (g, device);
5624 r = guestfs_umount_all (g);
5631 r = guestfs_lvm_remove_all (g);
5636 char device[] = "/dev/sda";
5637 device[5] = devchar;
5638 char lines_0[] = ",";
5645 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5650 char fstype[] = "ext2";
5651 char device[] = "/dev/sda1";
5652 device[5] = devchar;
5655 r = guestfs_mkfs (g, fstype, device);
5660 char device[] = "/dev/sda1";
5661 device[5] = devchar;
5662 char mountpoint[] = "/";
5665 r = guestfs_mount (g, device, mountpoint);
5669 /* TestOutputList for command_lines (4) */
5671 char remotefilename[] = "/test-command";
5674 r = guestfs_upload (g, "test-command", remotefilename);
5679 char path[] = "/test-command";
5682 r = guestfs_chmod (g, 493, path);
5687 char arguments_0[] = "/test-command";
5688 char arguments_1[] = "5";
5689 char *arguments[] = {
5697 r = guestfs_command_lines (g, arguments);
5701 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5706 char expected[] = "";
5707 if (strcmp (r[0], expected) != 0) {
5708 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5713 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5718 char expected[] = "Result5";
5719 if (strcmp (r[1], expected) != 0) {
5720 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5725 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5730 char expected[] = "";
5731 if (strcmp (r[2], expected) != 0) {
5732 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5737 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
5741 for (i = 0; r[i] != NULL; ++i)
5746 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
5750 static int test_command_lines_5_prereq (void)
5752 const char *str = getenv ("SKIP_TEST_COMMAND");
5753 return str && strcmp (str, "1") == 0;
5756 static int test_command_lines_5 (void)
5758 if (! test_command_lines_5_prereq ()) {
5759 /* InitBasicFS for command_lines (5): create ext2 on /dev/sda1 */
5761 char device[] = "/dev/sda";
5762 device[5] = devchar;
5765 r = guestfs_blockdev_setrw (g, device);
5772 r = guestfs_umount_all (g);
5779 r = guestfs_lvm_remove_all (g);
5784 char device[] = "/dev/sda";
5785 device[5] = devchar;
5786 char lines_0[] = ",";
5793 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5798 char fstype[] = "ext2";
5799 char device[] = "/dev/sda1";
5800 device[5] = devchar;
5803 r = guestfs_mkfs (g, fstype, device);
5808 char device[] = "/dev/sda1";
5809 device[5] = devchar;
5810 char mountpoint[] = "/";
5813 r = guestfs_mount (g, device, mountpoint);
5817 /* TestOutputList for command_lines (5) */
5819 char remotefilename[] = "/test-command";
5822 r = guestfs_upload (g, "test-command", remotefilename);
5827 char path[] = "/test-command";
5830 r = guestfs_chmod (g, 493, path);
5835 char arguments_0[] = "/test-command";
5836 char arguments_1[] = "6";
5837 char *arguments[] = {
5845 r = guestfs_command_lines (g, arguments);
5849 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5854 char expected[] = "";
5855 if (strcmp (r[0], expected) != 0) {
5856 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5861 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5866 char expected[] = "";
5867 if (strcmp (r[1], expected) != 0) {
5868 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5873 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5878 char expected[] = "Result6";
5879 if (strcmp (r[2], expected) != 0) {
5880 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5885 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
5890 char expected[] = "";
5891 if (strcmp (r[3], expected) != 0) {
5892 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
5897 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
5901 for (i = 0; r[i] != NULL; ++i)
5906 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
5910 static int test_command_lines_6_prereq (void)
5912 const char *str = getenv ("SKIP_TEST_COMMAND");
5913 return str && strcmp (str, "1") == 0;
5916 static int test_command_lines_6 (void)
5918 if (! test_command_lines_6_prereq ()) {
5919 /* InitBasicFS for command_lines (6): create ext2 on /dev/sda1 */
5921 char device[] = "/dev/sda";
5922 device[5] = devchar;
5925 r = guestfs_blockdev_setrw (g, device);
5932 r = guestfs_umount_all (g);
5939 r = guestfs_lvm_remove_all (g);
5944 char device[] = "/dev/sda";
5945 device[5] = devchar;
5946 char lines_0[] = ",";
5953 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5958 char fstype[] = "ext2";
5959 char device[] = "/dev/sda1";
5960 device[5] = devchar;
5963 r = guestfs_mkfs (g, fstype, device);
5968 char device[] = "/dev/sda1";
5969 device[5] = devchar;
5970 char mountpoint[] = "/";
5973 r = guestfs_mount (g, device, mountpoint);
5977 /* TestOutputList for command_lines (6) */
5979 char remotefilename[] = "/test-command";
5982 r = guestfs_upload (g, "test-command", remotefilename);
5987 char path[] = "/test-command";
5990 r = guestfs_chmod (g, 493, path);
5995 char arguments_0[] = "/test-command";
5996 char arguments_1[] = "7";
5997 char *arguments[] = {
6005 r = guestfs_command_lines (g, arguments);
6009 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6013 for (i = 0; r[i] != NULL; ++i)
6018 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6022 static int test_command_lines_7_prereq (void)
6024 const char *str = getenv ("SKIP_TEST_COMMAND");
6025 return str && strcmp (str, "1") == 0;
6028 static int test_command_lines_7 (void)
6030 if (! test_command_lines_7_prereq ()) {
6031 /* InitBasicFS for command_lines (7): create ext2 on /dev/sda1 */
6033 char device[] = "/dev/sda";
6034 device[5] = devchar;
6037 r = guestfs_blockdev_setrw (g, device);
6044 r = guestfs_umount_all (g);
6051 r = guestfs_lvm_remove_all (g);
6056 char device[] = "/dev/sda";
6057 device[5] = devchar;
6058 char lines_0[] = ",";
6065 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6070 char fstype[] = "ext2";
6071 char device[] = "/dev/sda1";
6072 device[5] = devchar;
6075 r = guestfs_mkfs (g, fstype, device);
6080 char device[] = "/dev/sda1";
6081 device[5] = devchar;
6082 char mountpoint[] = "/";
6085 r = guestfs_mount (g, device, mountpoint);
6089 /* TestOutputList for command_lines (7) */
6091 char remotefilename[] = "/test-command";
6094 r = guestfs_upload (g, "test-command", remotefilename);
6099 char path[] = "/test-command";
6102 r = guestfs_chmod (g, 493, path);
6107 char arguments_0[] = "/test-command";
6108 char arguments_1[] = "8";
6109 char *arguments[] = {
6117 r = guestfs_command_lines (g, arguments);
6121 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6126 char expected[] = "";
6127 if (strcmp (r[0], expected) != 0) {
6128 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6133 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6137 for (i = 0; r[i] != NULL; ++i)
6142 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6146 static int test_command_lines_8_prereq (void)
6148 const char *str = getenv ("SKIP_TEST_COMMAND");
6149 return str && strcmp (str, "1") == 0;
6152 static int test_command_lines_8 (void)
6154 if (! test_command_lines_8_prereq ()) {
6155 /* InitBasicFS for command_lines (8): create ext2 on /dev/sda1 */
6157 char device[] = "/dev/sda";
6158 device[5] = devchar;
6161 r = guestfs_blockdev_setrw (g, device);
6168 r = guestfs_umount_all (g);
6175 r = guestfs_lvm_remove_all (g);
6180 char device[] = "/dev/sda";
6181 device[5] = devchar;
6182 char lines_0[] = ",";
6189 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6194 char fstype[] = "ext2";
6195 char device[] = "/dev/sda1";
6196 device[5] = devchar;
6199 r = guestfs_mkfs (g, fstype, device);
6204 char device[] = "/dev/sda1";
6205 device[5] = devchar;
6206 char mountpoint[] = "/";
6209 r = guestfs_mount (g, device, mountpoint);
6213 /* TestOutputList for command_lines (8) */
6215 char remotefilename[] = "/test-command";
6218 r = guestfs_upload (g, "test-command", remotefilename);
6223 char path[] = "/test-command";
6226 r = guestfs_chmod (g, 493, path);
6231 char arguments_0[] = "/test-command";
6232 char arguments_1[] = "9";
6233 char *arguments[] = {
6241 r = guestfs_command_lines (g, arguments);
6245 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6250 char expected[] = "";
6251 if (strcmp (r[0], expected) != 0) {
6252 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6257 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6262 char expected[] = "";
6263 if (strcmp (r[1], expected) != 0) {
6264 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6269 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6273 for (i = 0; r[i] != NULL; ++i)
6278 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6282 static int test_command_lines_9_prereq (void)
6284 const char *str = getenv ("SKIP_TEST_COMMAND");
6285 return str && strcmp (str, "1") == 0;
6288 static int test_command_lines_9 (void)
6290 if (! test_command_lines_9_prereq ()) {
6291 /* InitBasicFS for command_lines (9): create ext2 on /dev/sda1 */
6293 char device[] = "/dev/sda";
6294 device[5] = devchar;
6297 r = guestfs_blockdev_setrw (g, device);
6304 r = guestfs_umount_all (g);
6311 r = guestfs_lvm_remove_all (g);
6316 char device[] = "/dev/sda";
6317 device[5] = devchar;
6318 char lines_0[] = ",";
6325 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6330 char fstype[] = "ext2";
6331 char device[] = "/dev/sda1";
6332 device[5] = devchar;
6335 r = guestfs_mkfs (g, fstype, device);
6340 char device[] = "/dev/sda1";
6341 device[5] = devchar;
6342 char mountpoint[] = "/";
6345 r = guestfs_mount (g, device, mountpoint);
6349 /* TestOutputList for command_lines (9) */
6351 char remotefilename[] = "/test-command";
6354 r = guestfs_upload (g, "test-command", remotefilename);
6359 char path[] = "/test-command";
6362 r = guestfs_chmod (g, 493, path);
6367 char arguments_0[] = "/test-command";
6368 char arguments_1[] = "10";
6369 char *arguments[] = {
6377 r = guestfs_command_lines (g, arguments);
6381 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6386 char expected[] = "Result10-1";
6387 if (strcmp (r[0], expected) != 0) {
6388 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6393 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6398 char expected[] = "Result10-2";
6399 if (strcmp (r[1], expected) != 0) {
6400 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6405 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6409 for (i = 0; r[i] != NULL; ++i)
6414 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6418 static int test_command_lines_10_prereq (void)
6420 const char *str = getenv ("SKIP_TEST_COMMAND");
6421 return str && strcmp (str, "1") == 0;
6424 static int test_command_lines_10 (void)
6426 if (! test_command_lines_10_prereq ()) {
6427 /* InitBasicFS for command_lines (10): create ext2 on /dev/sda1 */
6429 char device[] = "/dev/sda";
6430 device[5] = devchar;
6433 r = guestfs_blockdev_setrw (g, device);
6440 r = guestfs_umount_all (g);
6447 r = guestfs_lvm_remove_all (g);
6452 char device[] = "/dev/sda";
6453 device[5] = devchar;
6454 char lines_0[] = ",";
6461 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6466 char fstype[] = "ext2";
6467 char device[] = "/dev/sda1";
6468 device[5] = devchar;
6471 r = guestfs_mkfs (g, fstype, device);
6476 char device[] = "/dev/sda1";
6477 device[5] = devchar;
6478 char mountpoint[] = "/";
6481 r = guestfs_mount (g, device, mountpoint);
6485 /* TestOutputList for command_lines (10) */
6487 char remotefilename[] = "/test-command";
6490 r = guestfs_upload (g, "test-command", remotefilename);
6495 char path[] = "/test-command";
6498 r = guestfs_chmod (g, 493, path);
6503 char arguments_0[] = "/test-command";
6504 char arguments_1[] = "11";
6505 char *arguments[] = {
6513 r = guestfs_command_lines (g, arguments);
6517 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6522 char expected[] = "Result11-1";
6523 if (strcmp (r[0], expected) != 0) {
6524 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6529 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6534 char expected[] = "Result11-2";
6535 if (strcmp (r[1], expected) != 0) {
6536 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6541 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
6545 for (i = 0; r[i] != NULL; ++i)
6550 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
6554 static int test_command_0_prereq (void)
6556 const char *str = getenv ("SKIP_TEST_COMMAND");
6557 return str && strcmp (str, "1") == 0;
6560 static int test_command_0 (void)
6562 if (! test_command_0_prereq ()) {
6563 /* InitBasicFS for command (0): create ext2 on /dev/sda1 */
6565 char device[] = "/dev/sda";
6566 device[5] = devchar;
6569 r = guestfs_blockdev_setrw (g, device);
6576 r = guestfs_umount_all (g);
6583 r = guestfs_lvm_remove_all (g);
6588 char device[] = "/dev/sda";
6589 device[5] = devchar;
6590 char lines_0[] = ",";
6597 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6602 char fstype[] = "ext2";
6603 char device[] = "/dev/sda1";
6604 device[5] = devchar;
6607 r = guestfs_mkfs (g, fstype, device);
6612 char device[] = "/dev/sda1";
6613 device[5] = devchar;
6614 char mountpoint[] = "/";
6617 r = guestfs_mount (g, device, mountpoint);
6621 /* TestOutput for command (0) */
6622 char expected[] = "Result1";
6624 char remotefilename[] = "/test-command";
6627 r = guestfs_upload (g, "test-command", remotefilename);
6632 char path[] = "/test-command";
6635 r = guestfs_chmod (g, 493, path);
6640 char arguments_0[] = "/test-command";
6641 char arguments_1[] = "1";
6642 char *arguments[] = {
6649 r = guestfs_command (g, arguments);
6652 if (strcmp (r, expected) != 0) {
6653 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
6659 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
6663 static int test_command_1_prereq (void)
6665 const char *str = getenv ("SKIP_TEST_COMMAND");
6666 return str && strcmp (str, "1") == 0;
6669 static int test_command_1 (void)
6671 if (! test_command_1_prereq ()) {
6672 /* InitBasicFS for command (1): create ext2 on /dev/sda1 */
6674 char device[] = "/dev/sda";
6675 device[5] = devchar;
6678 r = guestfs_blockdev_setrw (g, device);
6685 r = guestfs_umount_all (g);
6692 r = guestfs_lvm_remove_all (g);
6697 char device[] = "/dev/sda";
6698 device[5] = devchar;
6699 char lines_0[] = ",";
6706 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6711 char fstype[] = "ext2";
6712 char device[] = "/dev/sda1";
6713 device[5] = devchar;
6716 r = guestfs_mkfs (g, fstype, device);
6721 char device[] = "/dev/sda1";
6722 device[5] = devchar;
6723 char mountpoint[] = "/";
6726 r = guestfs_mount (g, device, mountpoint);
6730 /* TestOutput for command (1) */
6731 char expected[] = "Result2\n";
6733 char remotefilename[] = "/test-command";
6736 r = guestfs_upload (g, "test-command", remotefilename);
6741 char path[] = "/test-command";
6744 r = guestfs_chmod (g, 493, path);
6749 char arguments_0[] = "/test-command";
6750 char arguments_1[] = "2";
6751 char *arguments[] = {
6758 r = guestfs_command (g, arguments);
6761 if (strcmp (r, expected) != 0) {
6762 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
6768 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
6772 static int test_command_2_prereq (void)
6774 const char *str = getenv ("SKIP_TEST_COMMAND");
6775 return str && strcmp (str, "1") == 0;
6778 static int test_command_2 (void)
6780 if (! test_command_2_prereq ()) {
6781 /* InitBasicFS for command (2): create ext2 on /dev/sda1 */
6783 char device[] = "/dev/sda";
6784 device[5] = devchar;
6787 r = guestfs_blockdev_setrw (g, device);
6794 r = guestfs_umount_all (g);
6801 r = guestfs_lvm_remove_all (g);
6806 char device[] = "/dev/sda";
6807 device[5] = devchar;
6808 char lines_0[] = ",";
6815 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6820 char fstype[] = "ext2";
6821 char device[] = "/dev/sda1";
6822 device[5] = devchar;
6825 r = guestfs_mkfs (g, fstype, device);
6830 char device[] = "/dev/sda1";
6831 device[5] = devchar;
6832 char mountpoint[] = "/";
6835 r = guestfs_mount (g, device, mountpoint);
6839 /* TestOutput for command (2) */
6840 char expected[] = "\nResult3";
6842 char remotefilename[] = "/test-command";
6845 r = guestfs_upload (g, "test-command", remotefilename);
6850 char path[] = "/test-command";
6853 r = guestfs_chmod (g, 493, path);
6858 char arguments_0[] = "/test-command";
6859 char arguments_1[] = "3";
6860 char *arguments[] = {
6867 r = guestfs_command (g, arguments);
6870 if (strcmp (r, expected) != 0) {
6871 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
6877 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
6881 static int test_command_3_prereq (void)
6883 const char *str = getenv ("SKIP_TEST_COMMAND");
6884 return str && strcmp (str, "1") == 0;
6887 static int test_command_3 (void)
6889 if (! test_command_3_prereq ()) {
6890 /* InitBasicFS for command (3): create ext2 on /dev/sda1 */
6892 char device[] = "/dev/sda";
6893 device[5] = devchar;
6896 r = guestfs_blockdev_setrw (g, device);
6903 r = guestfs_umount_all (g);
6910 r = guestfs_lvm_remove_all (g);
6915 char device[] = "/dev/sda";
6916 device[5] = devchar;
6917 char lines_0[] = ",";
6924 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6929 char fstype[] = "ext2";
6930 char device[] = "/dev/sda1";
6931 device[5] = devchar;
6934 r = guestfs_mkfs (g, fstype, device);
6939 char device[] = "/dev/sda1";
6940 device[5] = devchar;
6941 char mountpoint[] = "/";
6944 r = guestfs_mount (g, device, mountpoint);
6948 /* TestOutput for command (3) */
6949 char expected[] = "\nResult4\n";
6951 char remotefilename[] = "/test-command";
6954 r = guestfs_upload (g, "test-command", remotefilename);
6959 char path[] = "/test-command";
6962 r = guestfs_chmod (g, 493, path);
6967 char arguments_0[] = "/test-command";
6968 char arguments_1[] = "4";
6969 char *arguments[] = {
6976 r = guestfs_command (g, arguments);
6979 if (strcmp (r, expected) != 0) {
6980 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
6986 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
6990 static int test_command_4_prereq (void)
6992 const char *str = getenv ("SKIP_TEST_COMMAND");
6993 return str && strcmp (str, "1") == 0;
6996 static int test_command_4 (void)
6998 if (! test_command_4_prereq ()) {
6999 /* InitBasicFS for command (4): create ext2 on /dev/sda1 */
7001 char device[] = "/dev/sda";
7002 device[5] = devchar;
7005 r = guestfs_blockdev_setrw (g, device);
7012 r = guestfs_umount_all (g);
7019 r = guestfs_lvm_remove_all (g);
7024 char device[] = "/dev/sda";
7025 device[5] = devchar;
7026 char lines_0[] = ",";
7033 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7038 char fstype[] = "ext2";
7039 char device[] = "/dev/sda1";
7040 device[5] = devchar;
7043 r = guestfs_mkfs (g, fstype, device);
7048 char device[] = "/dev/sda1";
7049 device[5] = devchar;
7050 char mountpoint[] = "/";
7053 r = guestfs_mount (g, device, mountpoint);
7057 /* TestOutput for command (4) */
7058 char expected[] = "\nResult5\n\n";
7060 char remotefilename[] = "/test-command";
7063 r = guestfs_upload (g, "test-command", remotefilename);
7068 char path[] = "/test-command";
7071 r = guestfs_chmod (g, 493, path);
7076 char arguments_0[] = "/test-command";
7077 char arguments_1[] = "5";
7078 char *arguments[] = {
7085 r = guestfs_command (g, arguments);
7088 if (strcmp (r, expected) != 0) {
7089 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7095 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7099 static int test_command_5_prereq (void)
7101 const char *str = getenv ("SKIP_TEST_COMMAND");
7102 return str && strcmp (str, "1") == 0;
7105 static int test_command_5 (void)
7107 if (! test_command_5_prereq ()) {
7108 /* InitBasicFS for command (5): create ext2 on /dev/sda1 */
7110 char device[] = "/dev/sda";
7111 device[5] = devchar;
7114 r = guestfs_blockdev_setrw (g, device);
7121 r = guestfs_umount_all (g);
7128 r = guestfs_lvm_remove_all (g);
7133 char device[] = "/dev/sda";
7134 device[5] = devchar;
7135 char lines_0[] = ",";
7142 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7147 char fstype[] = "ext2";
7148 char device[] = "/dev/sda1";
7149 device[5] = devchar;
7152 r = guestfs_mkfs (g, fstype, device);
7157 char device[] = "/dev/sda1";
7158 device[5] = devchar;
7159 char mountpoint[] = "/";
7162 r = guestfs_mount (g, device, mountpoint);
7166 /* TestOutput for command (5) */
7167 char expected[] = "\n\nResult6\n\n";
7169 char remotefilename[] = "/test-command";
7172 r = guestfs_upload (g, "test-command", remotefilename);
7177 char path[] = "/test-command";
7180 r = guestfs_chmod (g, 493, path);
7185 char arguments_0[] = "/test-command";
7186 char arguments_1[] = "6";
7187 char *arguments[] = {
7194 r = guestfs_command (g, arguments);
7197 if (strcmp (r, expected) != 0) {
7198 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7204 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7208 static int test_command_6_prereq (void)
7210 const char *str = getenv ("SKIP_TEST_COMMAND");
7211 return str && strcmp (str, "1") == 0;
7214 static int test_command_6 (void)
7216 if (! test_command_6_prereq ()) {
7217 /* InitBasicFS for command (6): create ext2 on /dev/sda1 */
7219 char device[] = "/dev/sda";
7220 device[5] = devchar;
7223 r = guestfs_blockdev_setrw (g, device);
7230 r = guestfs_umount_all (g);
7237 r = guestfs_lvm_remove_all (g);
7242 char device[] = "/dev/sda";
7243 device[5] = devchar;
7244 char lines_0[] = ",";
7251 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7256 char fstype[] = "ext2";
7257 char device[] = "/dev/sda1";
7258 device[5] = devchar;
7261 r = guestfs_mkfs (g, fstype, device);
7266 char device[] = "/dev/sda1";
7267 device[5] = devchar;
7268 char mountpoint[] = "/";
7271 r = guestfs_mount (g, device, mountpoint);
7275 /* TestOutput for command (6) */
7276 char expected[] = "";
7278 char remotefilename[] = "/test-command";
7281 r = guestfs_upload (g, "test-command", remotefilename);
7286 char path[] = "/test-command";
7289 r = guestfs_chmod (g, 493, path);
7294 char arguments_0[] = "/test-command";
7295 char arguments_1[] = "7";
7296 char *arguments[] = {
7303 r = guestfs_command (g, arguments);
7306 if (strcmp (r, expected) != 0) {
7307 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7313 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7317 static int test_command_7_prereq (void)
7319 const char *str = getenv ("SKIP_TEST_COMMAND");
7320 return str && strcmp (str, "1") == 0;
7323 static int test_command_7 (void)
7325 if (! test_command_7_prereq ()) {
7326 /* InitBasicFS for command (7): create ext2 on /dev/sda1 */
7328 char device[] = "/dev/sda";
7329 device[5] = devchar;
7332 r = guestfs_blockdev_setrw (g, device);
7339 r = guestfs_umount_all (g);
7346 r = guestfs_lvm_remove_all (g);
7351 char device[] = "/dev/sda";
7352 device[5] = devchar;
7353 char lines_0[] = ",";
7360 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7365 char fstype[] = "ext2";
7366 char device[] = "/dev/sda1";
7367 device[5] = devchar;
7370 r = guestfs_mkfs (g, fstype, device);
7375 char device[] = "/dev/sda1";
7376 device[5] = devchar;
7377 char mountpoint[] = "/";
7380 r = guestfs_mount (g, device, mountpoint);
7384 /* TestOutput for command (7) */
7385 char expected[] = "\n";
7387 char remotefilename[] = "/test-command";
7390 r = guestfs_upload (g, "test-command", remotefilename);
7395 char path[] = "/test-command";
7398 r = guestfs_chmod (g, 493, path);
7403 char arguments_0[] = "/test-command";
7404 char arguments_1[] = "8";
7405 char *arguments[] = {
7412 r = guestfs_command (g, arguments);
7415 if (strcmp (r, expected) != 0) {
7416 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7422 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7426 static int test_command_8_prereq (void)
7428 const char *str = getenv ("SKIP_TEST_COMMAND");
7429 return str && strcmp (str, "1") == 0;
7432 static int test_command_8 (void)
7434 if (! test_command_8_prereq ()) {
7435 /* InitBasicFS for command (8): create ext2 on /dev/sda1 */
7437 char device[] = "/dev/sda";
7438 device[5] = devchar;
7441 r = guestfs_blockdev_setrw (g, device);
7448 r = guestfs_umount_all (g);
7455 r = guestfs_lvm_remove_all (g);
7460 char device[] = "/dev/sda";
7461 device[5] = devchar;
7462 char lines_0[] = ",";
7469 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7474 char fstype[] = "ext2";
7475 char device[] = "/dev/sda1";
7476 device[5] = devchar;
7479 r = guestfs_mkfs (g, fstype, device);
7484 char device[] = "/dev/sda1";
7485 device[5] = devchar;
7486 char mountpoint[] = "/";
7489 r = guestfs_mount (g, device, mountpoint);
7493 /* TestOutput for command (8) */
7494 char expected[] = "\n\n";
7496 char remotefilename[] = "/test-command";
7499 r = guestfs_upload (g, "test-command", remotefilename);
7504 char path[] = "/test-command";
7507 r = guestfs_chmod (g, 493, path);
7512 char arguments_0[] = "/test-command";
7513 char arguments_1[] = "9";
7514 char *arguments[] = {
7521 r = guestfs_command (g, arguments);
7524 if (strcmp (r, expected) != 0) {
7525 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
7531 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
7535 static int test_command_9_prereq (void)
7537 const char *str = getenv ("SKIP_TEST_COMMAND");
7538 return str && strcmp (str, "1") == 0;
7541 static int test_command_9 (void)
7543 if (! test_command_9_prereq ()) {
7544 /* InitBasicFS for command (9): create ext2 on /dev/sda1 */
7546 char device[] = "/dev/sda";
7547 device[5] = devchar;
7550 r = guestfs_blockdev_setrw (g, device);
7557 r = guestfs_umount_all (g);
7564 r = guestfs_lvm_remove_all (g);
7569 char device[] = "/dev/sda";
7570 device[5] = devchar;
7571 char lines_0[] = ",";
7578 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7583 char fstype[] = "ext2";
7584 char device[] = "/dev/sda1";
7585 device[5] = devchar;
7588 r = guestfs_mkfs (g, fstype, device);
7593 char device[] = "/dev/sda1";
7594 device[5] = devchar;
7595 char mountpoint[] = "/";
7598 r = guestfs_mount (g, device, mountpoint);
7602 /* TestOutput for command (9) */
7603 char expected[] = "Result10-1\nResult10-2\n";
7605 char remotefilename[] = "/test-command";
7608 r = guestfs_upload (g, "test-command", remotefilename);
7613 char path[] = "/test-command";
7616 r = guestfs_chmod (g, 493, path);
7621 char arguments_0[] = "/test-command";
7622 char arguments_1[] = "10";
7623 char *arguments[] = {
7630 r = guestfs_command (g, arguments);
7633 if (strcmp (r, expected) != 0) {
7634 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
7640 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
7644 static int test_command_10_prereq (void)
7646 const char *str = getenv ("SKIP_TEST_COMMAND");
7647 return str && strcmp (str, "1") == 0;
7650 static int test_command_10 (void)
7652 if (! test_command_10_prereq ()) {
7653 /* InitBasicFS for command (10): create ext2 on /dev/sda1 */
7655 char device[] = "/dev/sda";
7656 device[5] = devchar;
7659 r = guestfs_blockdev_setrw (g, device);
7666 r = guestfs_umount_all (g);
7673 r = guestfs_lvm_remove_all (g);
7678 char device[] = "/dev/sda";
7679 device[5] = devchar;
7680 char lines_0[] = ",";
7687 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7692 char fstype[] = "ext2";
7693 char device[] = "/dev/sda1";
7694 device[5] = devchar;
7697 r = guestfs_mkfs (g, fstype, device);
7702 char device[] = "/dev/sda1";
7703 device[5] = devchar;
7704 char mountpoint[] = "/";
7707 r = guestfs_mount (g, device, mountpoint);
7711 /* TestOutput for command (10) */
7712 char expected[] = "Result11-1\nResult11-2";
7714 char remotefilename[] = "/test-command";
7717 r = guestfs_upload (g, "test-command", remotefilename);
7722 char path[] = "/test-command";
7725 r = guestfs_chmod (g, 493, path);
7730 char arguments_0[] = "/test-command";
7731 char arguments_1[] = "11";
7732 char *arguments[] = {
7739 r = guestfs_command (g, arguments);
7742 if (strcmp (r, expected) != 0) {
7743 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
7749 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
7753 static int test_command_11_prereq (void)
7755 const char *str = getenv ("SKIP_TEST_COMMAND");
7756 return str && strcmp (str, "1") == 0;
7759 static int test_command_11 (void)
7761 if (! test_command_11_prereq ()) {
7762 /* InitBasicFS for command (11): create ext2 on /dev/sda1 */
7764 char device[] = "/dev/sda";
7765 device[5] = devchar;
7768 r = guestfs_blockdev_setrw (g, device);
7775 r = guestfs_umount_all (g);
7782 r = guestfs_lvm_remove_all (g);
7787 char device[] = "/dev/sda";
7788 device[5] = devchar;
7789 char lines_0[] = ",";
7796 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7801 char fstype[] = "ext2";
7802 char device[] = "/dev/sda1";
7803 device[5] = devchar;
7806 r = guestfs_mkfs (g, fstype, device);
7811 char device[] = "/dev/sda1";
7812 device[5] = devchar;
7813 char mountpoint[] = "/";
7816 r = guestfs_mount (g, device, mountpoint);
7820 /* TestLastFail for command (11) */
7822 char remotefilename[] = "/test-command";
7825 r = guestfs_upload (g, "test-command", remotefilename);
7830 char path[] = "/test-command";
7833 r = guestfs_chmod (g, 493, path);
7838 char arguments_0[] = "/test-command";
7839 char *arguments[] = {
7845 r = guestfs_command (g, arguments);
7851 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
7855 static int test_file_0 (void)
7857 /* InitBasicFS for file (0): create ext2 on /dev/sda1 */
7859 char device[] = "/dev/sda";
7860 device[5] = devchar;
7863 r = guestfs_blockdev_setrw (g, device);
7870 r = guestfs_umount_all (g);
7877 r = guestfs_lvm_remove_all (g);
7882 char device[] = "/dev/sda";
7883 device[5] = devchar;
7884 char lines_0[] = ",";
7891 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7896 char fstype[] = "ext2";
7897 char device[] = "/dev/sda1";
7898 device[5] = devchar;
7901 r = guestfs_mkfs (g, fstype, device);
7906 char device[] = "/dev/sda1";
7907 device[5] = devchar;
7908 char mountpoint[] = "/";
7911 r = guestfs_mount (g, device, mountpoint);
7915 /* TestOutput for file (0) */
7916 char expected[] = "empty";
7918 char path[] = "/new";
7921 r = guestfs_touch (g, path);
7926 char path[] = "/new";
7929 r = guestfs_file (g, path);
7932 if (strcmp (r, expected) != 0) {
7933 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
7941 static int test_file_1 (void)
7943 /* InitBasicFS for file (1): create ext2 on /dev/sda1 */
7945 char device[] = "/dev/sda";
7946 device[5] = devchar;
7949 r = guestfs_blockdev_setrw (g, device);
7956 r = guestfs_umount_all (g);
7963 r = guestfs_lvm_remove_all (g);
7968 char device[] = "/dev/sda";
7969 device[5] = devchar;
7970 char lines_0[] = ",";
7977 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7982 char fstype[] = "ext2";
7983 char device[] = "/dev/sda1";
7984 device[5] = devchar;
7987 r = guestfs_mkfs (g, fstype, device);
7992 char device[] = "/dev/sda1";
7993 device[5] = devchar;
7994 char mountpoint[] = "/";
7997 r = guestfs_mount (g, device, mountpoint);
8001 /* TestOutput for file (1) */
8002 char expected[] = "ASCII text";
8004 char path[] = "/new";
8005 char content[] = "some content\n";
8008 r = guestfs_write_file (g, path, content, 0);
8013 char path[] = "/new";
8016 r = guestfs_file (g, path);
8019 if (strcmp (r, expected) != 0) {
8020 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8028 static int test_file_2 (void)
8030 /* InitBasicFS for file (2): create ext2 on /dev/sda1 */
8032 char device[] = "/dev/sda";
8033 device[5] = devchar;
8036 r = guestfs_blockdev_setrw (g, device);
8043 r = guestfs_umount_all (g);
8050 r = guestfs_lvm_remove_all (g);
8055 char device[] = "/dev/sda";
8056 device[5] = devchar;
8057 char lines_0[] = ",";
8064 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8069 char fstype[] = "ext2";
8070 char device[] = "/dev/sda1";
8071 device[5] = devchar;
8074 r = guestfs_mkfs (g, fstype, device);
8079 char device[] = "/dev/sda1";
8080 device[5] = devchar;
8081 char mountpoint[] = "/";
8084 r = guestfs_mount (g, device, mountpoint);
8088 /* TestLastFail for file (2) */
8090 char path[] = "/nofile";
8093 r = guestfs_file (g, path);
8101 static int test_umount_all_0 (void)
8103 /* InitBasicFS for umount_all (0): create ext2 on /dev/sda1 */
8105 char device[] = "/dev/sda";
8106 device[5] = devchar;
8109 r = guestfs_blockdev_setrw (g, device);
8116 r = guestfs_umount_all (g);
8123 r = guestfs_lvm_remove_all (g);
8128 char device[] = "/dev/sda";
8129 device[5] = devchar;
8130 char lines_0[] = ",";
8137 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8142 char fstype[] = "ext2";
8143 char device[] = "/dev/sda1";
8144 device[5] = devchar;
8147 r = guestfs_mkfs (g, fstype, device);
8152 char device[] = "/dev/sda1";
8153 device[5] = devchar;
8154 char mountpoint[] = "/";
8157 r = guestfs_mount (g, device, mountpoint);
8161 /* TestOutputList for umount_all (0) */
8165 r = guestfs_umount_all (g);
8173 r = guestfs_mounts (g);
8177 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8181 for (i = 0; r[i] != NULL; ++i)
8188 static int test_umount_all_1 (void)
8190 /* InitEmpty for umount_all (1) */
8192 char device[] = "/dev/sda";
8193 device[5] = devchar;
8196 r = guestfs_blockdev_setrw (g, device);
8203 r = guestfs_umount_all (g);
8210 r = guestfs_lvm_remove_all (g);
8214 /* TestOutputList for umount_all (1) */
8216 char device[] = "/dev/sda";
8217 device[5] = devchar;
8218 char lines_0[] = ",10";
8219 char lines_1[] = ",20";
8220 char lines_2[] = ",";
8229 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8234 char fstype[] = "ext2";
8235 char device[] = "/dev/sda1";
8236 device[5] = devchar;
8239 r = guestfs_mkfs (g, fstype, device);
8244 char fstype[] = "ext2";
8245 char device[] = "/dev/sda2";
8246 device[5] = devchar;
8249 r = guestfs_mkfs (g, fstype, device);
8254 char fstype[] = "ext2";
8255 char device[] = "/dev/sda3";
8256 device[5] = devchar;
8259 r = guestfs_mkfs (g, fstype, device);
8264 char device[] = "/dev/sda1";
8265 device[5] = devchar;
8266 char mountpoint[] = "/";
8269 r = guestfs_mount (g, device, mountpoint);
8274 char path[] = "/mp1";
8277 r = guestfs_mkdir (g, path);
8282 char device[] = "/dev/sda2";
8283 device[5] = devchar;
8284 char mountpoint[] = "/mp1";
8287 r = guestfs_mount (g, device, mountpoint);
8292 char path[] = "/mp1/mp2";
8295 r = guestfs_mkdir (g, path);
8300 char device[] = "/dev/sda3";
8301 device[5] = devchar;
8302 char mountpoint[] = "/mp1/mp2";
8305 r = guestfs_mount (g, device, mountpoint);
8310 char path[] = "/mp1/mp2/mp3";
8313 r = guestfs_mkdir (g, path);
8320 r = guestfs_umount_all (g);
8328 r = guestfs_mounts (g);
8332 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8336 for (i = 0; r[i] != NULL; ++i)
8343 static int test_mounts_0 (void)
8345 /* InitBasicFS for mounts (0): create ext2 on /dev/sda1 */
8347 char device[] = "/dev/sda";
8348 device[5] = devchar;
8351 r = guestfs_blockdev_setrw (g, device);
8358 r = guestfs_umount_all (g);
8365 r = guestfs_lvm_remove_all (g);
8370 char device[] = "/dev/sda";
8371 device[5] = devchar;
8372 char lines_0[] = ",";
8379 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8384 char fstype[] = "ext2";
8385 char device[] = "/dev/sda1";
8386 device[5] = devchar;
8389 r = guestfs_mkfs (g, fstype, device);
8394 char device[] = "/dev/sda1";
8395 device[5] = devchar;
8396 char mountpoint[] = "/";
8399 r = guestfs_mount (g, device, mountpoint);
8403 /* TestOutputList for mounts (0) */
8408 r = guestfs_mounts (g);
8412 fprintf (stderr, "test_mounts_0: short list returned from command\n");
8417 char expected[] = "/dev/sda1";
8418 expected[5] = devchar;
8419 if (strcmp (r[0], expected) != 0) {
8420 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8425 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8429 for (i = 0; r[i] != NULL; ++i)
8436 static int test_umount_0 (void)
8438 /* InitEmpty for umount (0) */
8440 char device[] = "/dev/sda";
8441 device[5] = devchar;
8444 r = guestfs_blockdev_setrw (g, device);
8451 r = guestfs_umount_all (g);
8458 r = guestfs_lvm_remove_all (g);
8462 /* TestOutputList for umount (0) */
8464 char device[] = "/dev/sda";
8465 device[5] = devchar;
8466 char lines_0[] = ",";
8473 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8478 char fstype[] = "ext2";
8479 char device[] = "/dev/sda1";
8480 device[5] = devchar;
8483 r = guestfs_mkfs (g, fstype, device);
8488 char device[] = "/dev/sda1";
8489 device[5] = devchar;
8490 char mountpoint[] = "/";
8493 r = guestfs_mount (g, device, mountpoint);
8501 r = guestfs_mounts (g);
8505 fprintf (stderr, "test_umount_0: short list returned from command\n");
8510 char expected[] = "/dev/sda1";
8511 expected[5] = devchar;
8512 if (strcmp (r[0], expected) != 0) {
8513 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8518 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
8522 for (i = 0; r[i] != NULL; ++i)
8529 static int test_umount_1 (void)
8531 /* InitEmpty for umount (1) */
8533 char device[] = "/dev/sda";
8534 device[5] = devchar;
8537 r = guestfs_blockdev_setrw (g, device);
8544 r = guestfs_umount_all (g);
8551 r = guestfs_lvm_remove_all (g);
8555 /* TestOutputList for umount (1) */
8557 char device[] = "/dev/sda";
8558 device[5] = devchar;
8559 char lines_0[] = ",";
8566 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8571 char fstype[] = "ext2";
8572 char device[] = "/dev/sda1";
8573 device[5] = devchar;
8576 r = guestfs_mkfs (g, fstype, device);
8581 char device[] = "/dev/sda1";
8582 device[5] = devchar;
8583 char mountpoint[] = "/";
8586 r = guestfs_mount (g, device, mountpoint);
8591 char pathordevice[] = "/";
8594 r = guestfs_umount (g, pathordevice);
8602 r = guestfs_mounts (g);
8606 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
8610 for (i = 0; r[i] != NULL; ++i)
8617 static int test_write_file_0 (void)
8619 /* InitBasicFS for write_file (0): create ext2 on /dev/sda1 */
8621 char device[] = "/dev/sda";
8622 device[5] = devchar;
8625 r = guestfs_blockdev_setrw (g, device);
8632 r = guestfs_umount_all (g);
8639 r = guestfs_lvm_remove_all (g);
8644 char device[] = "/dev/sda";
8645 device[5] = devchar;
8646 char lines_0[] = ",";
8653 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8658 char fstype[] = "ext2";
8659 char device[] = "/dev/sda1";
8660 device[5] = devchar;
8663 r = guestfs_mkfs (g, fstype, device);
8668 char device[] = "/dev/sda1";
8669 device[5] = devchar;
8670 char mountpoint[] = "/";
8673 r = guestfs_mount (g, device, mountpoint);
8677 /* TestOutput for write_file (0) */
8678 char expected[] = "new file contents";
8680 char path[] = "/new";
8681 char content[] = "new file contents";
8684 r = guestfs_write_file (g, path, content, 0);
8689 char path[] = "/new";
8692 r = guestfs_cat (g, path);
8695 if (strcmp (r, expected) != 0) {
8696 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8704 static int test_write_file_1 (void)
8706 /* InitBasicFS for write_file (1): create ext2 on /dev/sda1 */
8708 char device[] = "/dev/sda";
8709 device[5] = devchar;
8712 r = guestfs_blockdev_setrw (g, device);
8719 r = guestfs_umount_all (g);
8726 r = guestfs_lvm_remove_all (g);
8731 char device[] = "/dev/sda";
8732 device[5] = devchar;
8733 char lines_0[] = ",";
8740 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8745 char fstype[] = "ext2";
8746 char device[] = "/dev/sda1";
8747 device[5] = devchar;
8750 r = guestfs_mkfs (g, fstype, device);
8755 char device[] = "/dev/sda1";
8756 device[5] = devchar;
8757 char mountpoint[] = "/";
8760 r = guestfs_mount (g, device, mountpoint);
8764 /* TestOutput for write_file (1) */
8765 char expected[] = "\nnew file contents\n";
8767 char path[] = "/new";
8768 char content[] = "\nnew file contents\n";
8771 r = guestfs_write_file (g, path, content, 0);
8776 char path[] = "/new";
8779 r = guestfs_cat (g, path);
8782 if (strcmp (r, expected) != 0) {
8783 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8791 static int test_write_file_2 (void)
8793 /* InitBasicFS for write_file (2): create ext2 on /dev/sda1 */
8795 char device[] = "/dev/sda";
8796 device[5] = devchar;
8799 r = guestfs_blockdev_setrw (g, device);
8806 r = guestfs_umount_all (g);
8813 r = guestfs_lvm_remove_all (g);
8818 char device[] = "/dev/sda";
8819 device[5] = devchar;
8820 char lines_0[] = ",";
8827 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8832 char fstype[] = "ext2";
8833 char device[] = "/dev/sda1";
8834 device[5] = devchar;
8837 r = guestfs_mkfs (g, fstype, device);
8842 char device[] = "/dev/sda1";
8843 device[5] = devchar;
8844 char mountpoint[] = "/";
8847 r = guestfs_mount (g, device, mountpoint);
8851 /* TestOutput for write_file (2) */
8852 char expected[] = "\n\n";
8854 char path[] = "/new";
8855 char content[] = "\n\n";
8858 r = guestfs_write_file (g, path, content, 0);
8863 char path[] = "/new";
8866 r = guestfs_cat (g, path);
8869 if (strcmp (r, expected) != 0) {
8870 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
8878 static int test_write_file_3 (void)
8880 /* InitBasicFS for write_file (3): create ext2 on /dev/sda1 */
8882 char device[] = "/dev/sda";
8883 device[5] = devchar;
8886 r = guestfs_blockdev_setrw (g, device);
8893 r = guestfs_umount_all (g);
8900 r = guestfs_lvm_remove_all (g);
8905 char device[] = "/dev/sda";
8906 device[5] = devchar;
8907 char lines_0[] = ",";
8914 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8919 char fstype[] = "ext2";
8920 char device[] = "/dev/sda1";
8921 device[5] = devchar;
8924 r = guestfs_mkfs (g, fstype, device);
8929 char device[] = "/dev/sda1";
8930 device[5] = devchar;
8931 char mountpoint[] = "/";
8934 r = guestfs_mount (g, device, mountpoint);
8938 /* TestOutput for write_file (3) */
8939 char expected[] = "";
8941 char path[] = "/new";
8942 char content[] = "";
8945 r = guestfs_write_file (g, path, content, 0);
8950 char path[] = "/new";
8953 r = guestfs_cat (g, path);
8956 if (strcmp (r, expected) != 0) {
8957 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
8965 static int test_write_file_4 (void)
8967 /* InitBasicFS for write_file (4): create ext2 on /dev/sda1 */
8969 char device[] = "/dev/sda";
8970 device[5] = devchar;
8973 r = guestfs_blockdev_setrw (g, device);
8980 r = guestfs_umount_all (g);
8987 r = guestfs_lvm_remove_all (g);
8992 char device[] = "/dev/sda";
8993 device[5] = devchar;
8994 char lines_0[] = ",";
9001 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9006 char fstype[] = "ext2";
9007 char device[] = "/dev/sda1";
9008 device[5] = devchar;
9011 r = guestfs_mkfs (g, fstype, device);
9016 char device[] = "/dev/sda1";
9017 device[5] = devchar;
9018 char mountpoint[] = "/";
9021 r = guestfs_mount (g, device, mountpoint);
9025 /* TestOutput for write_file (4) */
9026 char expected[] = "\n\n\n";
9028 char path[] = "/new";
9029 char content[] = "\n\n\n";
9032 r = guestfs_write_file (g, path, content, 0);
9037 char path[] = "/new";
9040 r = guestfs_cat (g, path);
9043 if (strcmp (r, expected) != 0) {
9044 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9052 static int test_write_file_5 (void)
9054 /* InitBasicFS for write_file (5): create ext2 on /dev/sda1 */
9056 char device[] = "/dev/sda";
9057 device[5] = devchar;
9060 r = guestfs_blockdev_setrw (g, device);
9067 r = guestfs_umount_all (g);
9074 r = guestfs_lvm_remove_all (g);
9079 char device[] = "/dev/sda";
9080 device[5] = devchar;
9081 char lines_0[] = ",";
9088 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9093 char fstype[] = "ext2";
9094 char device[] = "/dev/sda1";
9095 device[5] = devchar;
9098 r = guestfs_mkfs (g, fstype, device);
9103 char device[] = "/dev/sda1";
9104 device[5] = devchar;
9105 char mountpoint[] = "/";
9108 r = guestfs_mount (g, device, mountpoint);
9112 /* TestOutput for write_file (5) */
9113 char expected[] = "\n";
9115 char path[] = "/new";
9116 char content[] = "\n";
9119 r = guestfs_write_file (g, path, content, 0);
9124 char path[] = "/new";
9127 r = guestfs_cat (g, path);
9130 if (strcmp (r, expected) != 0) {
9131 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9139 static int test_mkfs_0 (void)
9141 /* InitEmpty for mkfs (0) */
9143 char device[] = "/dev/sda";
9144 device[5] = devchar;
9147 r = guestfs_blockdev_setrw (g, device);
9154 r = guestfs_umount_all (g);
9161 r = guestfs_lvm_remove_all (g);
9165 /* TestOutput for mkfs (0) */
9166 char expected[] = "new file contents";
9168 char device[] = "/dev/sda";
9169 device[5] = devchar;
9170 char lines_0[] = ",";
9177 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9182 char fstype[] = "ext2";
9183 char device[] = "/dev/sda1";
9184 device[5] = devchar;
9187 r = guestfs_mkfs (g, fstype, device);
9192 char device[] = "/dev/sda1";
9193 device[5] = devchar;
9194 char mountpoint[] = "/";
9197 r = guestfs_mount (g, device, mountpoint);
9202 char path[] = "/new";
9203 char content[] = "new file contents";
9206 r = guestfs_write_file (g, path, content, 0);
9211 char path[] = "/new";
9214 r = guestfs_cat (g, path);
9217 if (strcmp (r, expected) != 0) {
9218 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9226 static int test_lvcreate_0 (void)
9228 /* InitEmpty for lvcreate (0) */
9230 char device[] = "/dev/sda";
9231 device[5] = devchar;
9234 r = guestfs_blockdev_setrw (g, device);
9241 r = guestfs_umount_all (g);
9248 r = guestfs_lvm_remove_all (g);
9252 /* TestOutputList for lvcreate (0) */
9254 char device[] = "/dev/sda";
9255 device[5] = devchar;
9256 char lines_0[] = ",10";
9257 char lines_1[] = ",20";
9258 char lines_2[] = ",";
9267 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9272 char device[] = "/dev/sda1";
9273 device[5] = devchar;
9276 r = guestfs_pvcreate (g, device);
9281 char device[] = "/dev/sda2";
9282 device[5] = devchar;
9285 r = guestfs_pvcreate (g, device);
9290 char device[] = "/dev/sda3";
9291 device[5] = devchar;
9294 r = guestfs_pvcreate (g, device);
9299 char volgroup[] = "VG1";
9300 char physvols_0[] = "/dev/sda1";
9301 physvols_0[5] = devchar;
9302 char physvols_1[] = "/dev/sda2";
9303 physvols_1[5] = devchar;
9304 char *physvols[] = {
9311 r = guestfs_vgcreate (g, volgroup, physvols);
9316 char volgroup[] = "VG2";
9317 char physvols_0[] = "/dev/sda3";
9318 physvols_0[5] = devchar;
9319 char *physvols[] = {
9325 r = guestfs_vgcreate (g, volgroup, physvols);
9330 char logvol[] = "LV1";
9331 char volgroup[] = "VG1";
9334 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9339 char logvol[] = "LV2";
9340 char volgroup[] = "VG1";
9343 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9348 char logvol[] = "LV3";
9349 char volgroup[] = "VG2";
9352 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9357 char logvol[] = "LV4";
9358 char volgroup[] = "VG2";
9361 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9366 char logvol[] = "LV5";
9367 char volgroup[] = "VG2";
9370 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9378 r = guestfs_lvs (g);
9382 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9387 char expected[] = "/dev/VG1/LV1";
9388 if (strcmp (r[0], expected) != 0) {
9389 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9394 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9399 char expected[] = "/dev/VG1/LV2";
9400 if (strcmp (r[1], expected) != 0) {
9401 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9406 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9411 char expected[] = "/dev/VG2/LV3";
9412 if (strcmp (r[2], expected) != 0) {
9413 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9418 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9423 char expected[] = "/dev/VG2/LV4";
9424 if (strcmp (r[3], expected) != 0) {
9425 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9430 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9435 char expected[] = "/dev/VG2/LV5";
9436 if (strcmp (r[4], expected) != 0) {
9437 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9442 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9446 for (i = 0; r[i] != NULL; ++i)
9453 static int test_vgcreate_0 (void)
9455 /* InitEmpty for vgcreate (0) */
9457 char device[] = "/dev/sda";
9458 device[5] = devchar;
9461 r = guestfs_blockdev_setrw (g, device);
9468 r = guestfs_umount_all (g);
9475 r = guestfs_lvm_remove_all (g);
9479 /* TestOutputList for vgcreate (0) */
9481 char device[] = "/dev/sda";
9482 device[5] = devchar;
9483 char lines_0[] = ",10";
9484 char lines_1[] = ",20";
9485 char lines_2[] = ",";
9494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9499 char device[] = "/dev/sda1";
9500 device[5] = devchar;
9503 r = guestfs_pvcreate (g, device);
9508 char device[] = "/dev/sda2";
9509 device[5] = devchar;
9512 r = guestfs_pvcreate (g, device);
9517 char device[] = "/dev/sda3";
9518 device[5] = devchar;
9521 r = guestfs_pvcreate (g, device);
9526 char volgroup[] = "VG1";
9527 char physvols_0[] = "/dev/sda1";
9528 physvols_0[5] = devchar;
9529 char physvols_1[] = "/dev/sda2";
9530 physvols_1[5] = devchar;
9531 char *physvols[] = {
9538 r = guestfs_vgcreate (g, volgroup, physvols);
9543 char volgroup[] = "VG2";
9544 char physvols_0[] = "/dev/sda3";
9545 physvols_0[5] = devchar;
9546 char *physvols[] = {
9552 r = guestfs_vgcreate (g, volgroup, physvols);
9560 r = guestfs_vgs (g);
9564 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9569 char expected[] = "VG1";
9570 if (strcmp (r[0], expected) != 0) {
9571 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9576 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9581 char expected[] = "VG2";
9582 if (strcmp (r[1], expected) != 0) {
9583 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9588 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
9592 for (i = 0; r[i] != NULL; ++i)
9599 static int test_pvcreate_0 (void)
9601 /* InitEmpty for pvcreate (0) */
9603 char device[] = "/dev/sda";
9604 device[5] = devchar;
9607 r = guestfs_blockdev_setrw (g, device);
9614 r = guestfs_umount_all (g);
9621 r = guestfs_lvm_remove_all (g);
9625 /* TestOutputList for pvcreate (0) */
9627 char device[] = "/dev/sda";
9628 device[5] = devchar;
9629 char lines_0[] = ",10";
9630 char lines_1[] = ",20";
9631 char lines_2[] = ",";
9640 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9645 char device[] = "/dev/sda1";
9646 device[5] = devchar;
9649 r = guestfs_pvcreate (g, device);
9654 char device[] = "/dev/sda2";
9655 device[5] = devchar;
9658 r = guestfs_pvcreate (g, device);
9663 char device[] = "/dev/sda3";
9664 device[5] = devchar;
9667 r = guestfs_pvcreate (g, device);
9675 r = guestfs_pvs (g);
9679 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9684 char expected[] = "/dev/sda1";
9685 expected[5] = devchar;
9686 if (strcmp (r[0], expected) != 0) {
9687 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9692 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9697 char expected[] = "/dev/sda2";
9698 expected[5] = devchar;
9699 if (strcmp (r[1], expected) != 0) {
9700 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9705 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9710 char expected[] = "/dev/sda3";
9711 expected[5] = devchar;
9712 if (strcmp (r[2], expected) != 0) {
9713 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9718 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
9722 for (i = 0; r[i] != NULL; ++i)
9729 static int test_is_dir_0 (void)
9731 /* InitBasicFS for is_dir (0): create ext2 on /dev/sda1 */
9733 char device[] = "/dev/sda";
9734 device[5] = devchar;
9737 r = guestfs_blockdev_setrw (g, device);
9744 r = guestfs_umount_all (g);
9751 r = guestfs_lvm_remove_all (g);
9756 char device[] = "/dev/sda";
9757 device[5] = devchar;
9758 char lines_0[] = ",";
9765 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9770 char fstype[] = "ext2";
9771 char device[] = "/dev/sda1";
9772 device[5] = devchar;
9775 r = guestfs_mkfs (g, fstype, device);
9780 char device[] = "/dev/sda1";
9781 device[5] = devchar;
9782 char mountpoint[] = "/";
9785 r = guestfs_mount (g, device, mountpoint);
9789 /* TestOutputFalse for is_dir (0) */
9791 char path[] = "/new";
9794 r = guestfs_touch (g, path);
9799 char path[] = "/new";
9802 r = guestfs_is_dir (g, path);
9806 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
9813 static int test_is_dir_1 (void)
9815 /* InitBasicFS for is_dir (1): create ext2 on /dev/sda1 */
9817 char device[] = "/dev/sda";
9818 device[5] = devchar;
9821 r = guestfs_blockdev_setrw (g, device);
9828 r = guestfs_umount_all (g);
9835 r = guestfs_lvm_remove_all (g);
9840 char device[] = "/dev/sda";
9841 device[5] = devchar;
9842 char lines_0[] = ",";
9849 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9854 char fstype[] = "ext2";
9855 char device[] = "/dev/sda1";
9856 device[5] = devchar;
9859 r = guestfs_mkfs (g, fstype, device);
9864 char device[] = "/dev/sda1";
9865 device[5] = devchar;
9866 char mountpoint[] = "/";
9869 r = guestfs_mount (g, device, mountpoint);
9873 /* TestOutputTrue for is_dir (1) */
9875 char path[] = "/new";
9878 r = guestfs_mkdir (g, path);
9883 char path[] = "/new";
9886 r = guestfs_is_dir (g, path);
9890 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
9897 static int test_is_file_0 (void)
9899 /* InitBasicFS for is_file (0): create ext2 on /dev/sda1 */
9901 char device[] = "/dev/sda";
9902 device[5] = devchar;
9905 r = guestfs_blockdev_setrw (g, device);
9912 r = guestfs_umount_all (g);
9919 r = guestfs_lvm_remove_all (g);
9924 char device[] = "/dev/sda";
9925 device[5] = devchar;
9926 char lines_0[] = ",";
9933 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9938 char fstype[] = "ext2";
9939 char device[] = "/dev/sda1";
9940 device[5] = devchar;
9943 r = guestfs_mkfs (g, fstype, device);
9948 char device[] = "/dev/sda1";
9949 device[5] = devchar;
9950 char mountpoint[] = "/";
9953 r = guestfs_mount (g, device, mountpoint);
9957 /* TestOutputTrue for is_file (0) */
9959 char path[] = "/new";
9962 r = guestfs_touch (g, path);
9967 char path[] = "/new";
9970 r = guestfs_is_file (g, path);
9974 fprintf (stderr, "test_is_file_0: expected true, got false\n");
9981 static int test_is_file_1 (void)
9983 /* InitBasicFS for is_file (1): create ext2 on /dev/sda1 */
9985 char device[] = "/dev/sda";
9986 device[5] = devchar;
9989 r = guestfs_blockdev_setrw (g, device);
9996 r = guestfs_umount_all (g);
10002 suppress_error = 0;
10003 r = guestfs_lvm_remove_all (g);
10008 char device[] = "/dev/sda";
10009 device[5] = devchar;
10010 char lines_0[] = ",";
10016 suppress_error = 0;
10017 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10022 char fstype[] = "ext2";
10023 char device[] = "/dev/sda1";
10024 device[5] = devchar;
10026 suppress_error = 0;
10027 r = guestfs_mkfs (g, fstype, device);
10032 char device[] = "/dev/sda1";
10033 device[5] = devchar;
10034 char mountpoint[] = "/";
10036 suppress_error = 0;
10037 r = guestfs_mount (g, device, mountpoint);
10041 /* TestOutputFalse for is_file (1) */
10043 char path[] = "/new";
10045 suppress_error = 0;
10046 r = guestfs_mkdir (g, path);
10051 char path[] = "/new";
10053 suppress_error = 0;
10054 r = guestfs_is_file (g, path);
10058 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10065 static int test_exists_0 (void)
10067 /* InitBasicFS for exists (0): create ext2 on /dev/sda1 */
10069 char device[] = "/dev/sda";
10070 device[5] = devchar;
10072 suppress_error = 0;
10073 r = guestfs_blockdev_setrw (g, device);
10079 suppress_error = 0;
10080 r = guestfs_umount_all (g);
10086 suppress_error = 0;
10087 r = guestfs_lvm_remove_all (g);
10092 char device[] = "/dev/sda";
10093 device[5] = devchar;
10094 char lines_0[] = ",";
10100 suppress_error = 0;
10101 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10106 char fstype[] = "ext2";
10107 char device[] = "/dev/sda1";
10108 device[5] = devchar;
10110 suppress_error = 0;
10111 r = guestfs_mkfs (g, fstype, device);
10116 char device[] = "/dev/sda1";
10117 device[5] = devchar;
10118 char mountpoint[] = "/";
10120 suppress_error = 0;
10121 r = guestfs_mount (g, device, mountpoint);
10125 /* TestOutputTrue for exists (0) */
10127 char path[] = "/new";
10129 suppress_error = 0;
10130 r = guestfs_touch (g, path);
10135 char path[] = "/new";
10137 suppress_error = 0;
10138 r = guestfs_exists (g, path);
10142 fprintf (stderr, "test_exists_0: expected true, got false\n");
10149 static int test_exists_1 (void)
10151 /* InitBasicFS for exists (1): create ext2 on /dev/sda1 */
10153 char device[] = "/dev/sda";
10154 device[5] = devchar;
10156 suppress_error = 0;
10157 r = guestfs_blockdev_setrw (g, device);
10163 suppress_error = 0;
10164 r = guestfs_umount_all (g);
10170 suppress_error = 0;
10171 r = guestfs_lvm_remove_all (g);
10176 char device[] = "/dev/sda";
10177 device[5] = devchar;
10178 char lines_0[] = ",";
10184 suppress_error = 0;
10185 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10190 char fstype[] = "ext2";
10191 char device[] = "/dev/sda1";
10192 device[5] = devchar;
10194 suppress_error = 0;
10195 r = guestfs_mkfs (g, fstype, device);
10200 char device[] = "/dev/sda1";
10201 device[5] = devchar;
10202 char mountpoint[] = "/";
10204 suppress_error = 0;
10205 r = guestfs_mount (g, device, mountpoint);
10209 /* TestOutputTrue for exists (1) */
10211 char path[] = "/new";
10213 suppress_error = 0;
10214 r = guestfs_mkdir (g, path);
10219 char path[] = "/new";
10221 suppress_error = 0;
10222 r = guestfs_exists (g, path);
10226 fprintf (stderr, "test_exists_1: expected true, got false\n");
10233 static int test_mkdir_p_0 (void)
10235 /* InitBasicFS for mkdir_p (0): create ext2 on /dev/sda1 */
10237 char device[] = "/dev/sda";
10238 device[5] = devchar;
10240 suppress_error = 0;
10241 r = guestfs_blockdev_setrw (g, device);
10247 suppress_error = 0;
10248 r = guestfs_umount_all (g);
10254 suppress_error = 0;
10255 r = guestfs_lvm_remove_all (g);
10260 char device[] = "/dev/sda";
10261 device[5] = devchar;
10262 char lines_0[] = ",";
10268 suppress_error = 0;
10269 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10274 char fstype[] = "ext2";
10275 char device[] = "/dev/sda1";
10276 device[5] = devchar;
10278 suppress_error = 0;
10279 r = guestfs_mkfs (g, fstype, device);
10284 char device[] = "/dev/sda1";
10285 device[5] = devchar;
10286 char mountpoint[] = "/";
10288 suppress_error = 0;
10289 r = guestfs_mount (g, device, mountpoint);
10293 /* TestOutputTrue for mkdir_p (0) */
10295 char path[] = "/new/foo/bar";
10297 suppress_error = 0;
10298 r = guestfs_mkdir_p (g, path);
10303 char path[] = "/new/foo/bar";
10305 suppress_error = 0;
10306 r = guestfs_is_dir (g, path);
10310 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10317 static int test_mkdir_p_1 (void)
10319 /* InitBasicFS for mkdir_p (1): create ext2 on /dev/sda1 */
10321 char device[] = "/dev/sda";
10322 device[5] = devchar;
10324 suppress_error = 0;
10325 r = guestfs_blockdev_setrw (g, device);
10331 suppress_error = 0;
10332 r = guestfs_umount_all (g);
10338 suppress_error = 0;
10339 r = guestfs_lvm_remove_all (g);
10344 char device[] = "/dev/sda";
10345 device[5] = devchar;
10346 char lines_0[] = ",";
10352 suppress_error = 0;
10353 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10358 char fstype[] = "ext2";
10359 char device[] = "/dev/sda1";
10360 device[5] = devchar;
10362 suppress_error = 0;
10363 r = guestfs_mkfs (g, fstype, device);
10368 char device[] = "/dev/sda1";
10369 device[5] = devchar;
10370 char mountpoint[] = "/";
10372 suppress_error = 0;
10373 r = guestfs_mount (g, device, mountpoint);
10377 /* TestOutputTrue for mkdir_p (1) */
10379 char path[] = "/new/foo/bar";
10381 suppress_error = 0;
10382 r = guestfs_mkdir_p (g, path);
10387 char path[] = "/new/foo";
10389 suppress_error = 0;
10390 r = guestfs_is_dir (g, path);
10394 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10401 static int test_mkdir_p_2 (void)
10403 /* InitBasicFS for mkdir_p (2): create ext2 on /dev/sda1 */
10405 char device[] = "/dev/sda";
10406 device[5] = devchar;
10408 suppress_error = 0;
10409 r = guestfs_blockdev_setrw (g, device);
10415 suppress_error = 0;
10416 r = guestfs_umount_all (g);
10422 suppress_error = 0;
10423 r = guestfs_lvm_remove_all (g);
10428 char device[] = "/dev/sda";
10429 device[5] = devchar;
10430 char lines_0[] = ",";
10436 suppress_error = 0;
10437 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10442 char fstype[] = "ext2";
10443 char device[] = "/dev/sda1";
10444 device[5] = devchar;
10446 suppress_error = 0;
10447 r = guestfs_mkfs (g, fstype, device);
10452 char device[] = "/dev/sda1";
10453 device[5] = devchar;
10454 char mountpoint[] = "/";
10456 suppress_error = 0;
10457 r = guestfs_mount (g, device, mountpoint);
10461 /* TestOutputTrue for mkdir_p (2) */
10463 char path[] = "/new/foo/bar";
10465 suppress_error = 0;
10466 r = guestfs_mkdir_p (g, path);
10471 char path[] = "/new";
10473 suppress_error = 0;
10474 r = guestfs_is_dir (g, path);
10478 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
10485 static int test_mkdir_0 (void)
10487 /* InitBasicFS for mkdir (0): create ext2 on /dev/sda1 */
10489 char device[] = "/dev/sda";
10490 device[5] = devchar;
10492 suppress_error = 0;
10493 r = guestfs_blockdev_setrw (g, device);
10499 suppress_error = 0;
10500 r = guestfs_umount_all (g);
10506 suppress_error = 0;
10507 r = guestfs_lvm_remove_all (g);
10512 char device[] = "/dev/sda";
10513 device[5] = devchar;
10514 char lines_0[] = ",";
10520 suppress_error = 0;
10521 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10526 char fstype[] = "ext2";
10527 char device[] = "/dev/sda1";
10528 device[5] = devchar;
10530 suppress_error = 0;
10531 r = guestfs_mkfs (g, fstype, device);
10536 char device[] = "/dev/sda1";
10537 device[5] = devchar;
10538 char mountpoint[] = "/";
10540 suppress_error = 0;
10541 r = guestfs_mount (g, device, mountpoint);
10545 /* TestOutputTrue for mkdir (0) */
10547 char path[] = "/new";
10549 suppress_error = 0;
10550 r = guestfs_mkdir (g, path);
10555 char path[] = "/new";
10557 suppress_error = 0;
10558 r = guestfs_is_dir (g, path);
10562 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
10569 static int test_mkdir_1 (void)
10571 /* InitBasicFS for mkdir (1): create ext2 on /dev/sda1 */
10573 char device[] = "/dev/sda";
10574 device[5] = devchar;
10576 suppress_error = 0;
10577 r = guestfs_blockdev_setrw (g, device);
10583 suppress_error = 0;
10584 r = guestfs_umount_all (g);
10590 suppress_error = 0;
10591 r = guestfs_lvm_remove_all (g);
10596 char device[] = "/dev/sda";
10597 device[5] = devchar;
10598 char lines_0[] = ",";
10604 suppress_error = 0;
10605 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10610 char fstype[] = "ext2";
10611 char device[] = "/dev/sda1";
10612 device[5] = devchar;
10614 suppress_error = 0;
10615 r = guestfs_mkfs (g, fstype, device);
10620 char device[] = "/dev/sda1";
10621 device[5] = devchar;
10622 char mountpoint[] = "/";
10624 suppress_error = 0;
10625 r = guestfs_mount (g, device, mountpoint);
10629 /* TestLastFail for mkdir (1) */
10631 char path[] = "/new/foo/bar";
10633 suppress_error = 1;
10634 r = guestfs_mkdir (g, path);
10641 static int test_rm_rf_0 (void)
10643 /* InitBasicFS for rm_rf (0): create ext2 on /dev/sda1 */
10645 char device[] = "/dev/sda";
10646 device[5] = devchar;
10648 suppress_error = 0;
10649 r = guestfs_blockdev_setrw (g, device);
10655 suppress_error = 0;
10656 r = guestfs_umount_all (g);
10662 suppress_error = 0;
10663 r = guestfs_lvm_remove_all (g);
10668 char device[] = "/dev/sda";
10669 device[5] = devchar;
10670 char lines_0[] = ",";
10676 suppress_error = 0;
10677 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10682 char fstype[] = "ext2";
10683 char device[] = "/dev/sda1";
10684 device[5] = devchar;
10686 suppress_error = 0;
10687 r = guestfs_mkfs (g, fstype, device);
10692 char device[] = "/dev/sda1";
10693 device[5] = devchar;
10694 char mountpoint[] = "/";
10696 suppress_error = 0;
10697 r = guestfs_mount (g, device, mountpoint);
10701 /* TestOutputFalse for rm_rf (0) */
10703 char path[] = "/new";
10705 suppress_error = 0;
10706 r = guestfs_mkdir (g, path);
10711 char path[] = "/new/foo";
10713 suppress_error = 0;
10714 r = guestfs_mkdir (g, path);
10719 char path[] = "/new/foo/bar";
10721 suppress_error = 0;
10722 r = guestfs_touch (g, path);
10727 char path[] = "/new";
10729 suppress_error = 0;
10730 r = guestfs_rm_rf (g, path);
10735 char path[] = "/new";
10737 suppress_error = 0;
10738 r = guestfs_exists (g, path);
10742 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
10749 static int test_rmdir_0 (void)
10751 /* InitBasicFS for rmdir (0): create ext2 on /dev/sda1 */
10753 char device[] = "/dev/sda";
10754 device[5] = devchar;
10756 suppress_error = 0;
10757 r = guestfs_blockdev_setrw (g, device);
10763 suppress_error = 0;
10764 r = guestfs_umount_all (g);
10770 suppress_error = 0;
10771 r = guestfs_lvm_remove_all (g);
10776 char device[] = "/dev/sda";
10777 device[5] = devchar;
10778 char lines_0[] = ",";
10784 suppress_error = 0;
10785 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10790 char fstype[] = "ext2";
10791 char device[] = "/dev/sda1";
10792 device[5] = devchar;
10794 suppress_error = 0;
10795 r = guestfs_mkfs (g, fstype, device);
10800 char device[] = "/dev/sda1";
10801 device[5] = devchar;
10802 char mountpoint[] = "/";
10804 suppress_error = 0;
10805 r = guestfs_mount (g, device, mountpoint);
10809 /* TestRun for rmdir (0) */
10811 char path[] = "/new";
10813 suppress_error = 0;
10814 r = guestfs_mkdir (g, path);
10819 char path[] = "/new";
10821 suppress_error = 0;
10822 r = guestfs_rmdir (g, path);
10829 static int test_rmdir_1 (void)
10831 /* InitBasicFS for rmdir (1): create ext2 on /dev/sda1 */
10833 char device[] = "/dev/sda";
10834 device[5] = devchar;
10836 suppress_error = 0;
10837 r = guestfs_blockdev_setrw (g, device);
10843 suppress_error = 0;
10844 r = guestfs_umount_all (g);
10850 suppress_error = 0;
10851 r = guestfs_lvm_remove_all (g);
10856 char device[] = "/dev/sda";
10857 device[5] = devchar;
10858 char lines_0[] = ",";
10864 suppress_error = 0;
10865 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10870 char fstype[] = "ext2";
10871 char device[] = "/dev/sda1";
10872 device[5] = devchar;
10874 suppress_error = 0;
10875 r = guestfs_mkfs (g, fstype, device);
10880 char device[] = "/dev/sda1";
10881 device[5] = devchar;
10882 char mountpoint[] = "/";
10884 suppress_error = 0;
10885 r = guestfs_mount (g, device, mountpoint);
10889 /* TestLastFail for rmdir (1) */
10891 char path[] = "/new";
10893 suppress_error = 1;
10894 r = guestfs_rmdir (g, path);
10901 static int test_rmdir_2 (void)
10903 /* InitBasicFS for rmdir (2): create ext2 on /dev/sda1 */
10905 char device[] = "/dev/sda";
10906 device[5] = devchar;
10908 suppress_error = 0;
10909 r = guestfs_blockdev_setrw (g, device);
10915 suppress_error = 0;
10916 r = guestfs_umount_all (g);
10922 suppress_error = 0;
10923 r = guestfs_lvm_remove_all (g);
10928 char device[] = "/dev/sda";
10929 device[5] = devchar;
10930 char lines_0[] = ",";
10936 suppress_error = 0;
10937 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10942 char fstype[] = "ext2";
10943 char device[] = "/dev/sda1";
10944 device[5] = devchar;
10946 suppress_error = 0;
10947 r = guestfs_mkfs (g, fstype, device);
10952 char device[] = "/dev/sda1";
10953 device[5] = devchar;
10954 char mountpoint[] = "/";
10956 suppress_error = 0;
10957 r = guestfs_mount (g, device, mountpoint);
10961 /* TestLastFail for rmdir (2) */
10963 char path[] = "/new";
10965 suppress_error = 0;
10966 r = guestfs_touch (g, path);
10971 char path[] = "/new";
10973 suppress_error = 1;
10974 r = guestfs_rmdir (g, path);
10981 static int test_rm_0 (void)
10983 /* InitBasicFS for rm (0): create ext2 on /dev/sda1 */
10985 char device[] = "/dev/sda";
10986 device[5] = devchar;
10988 suppress_error = 0;
10989 r = guestfs_blockdev_setrw (g, device);
10995 suppress_error = 0;
10996 r = guestfs_umount_all (g);
11002 suppress_error = 0;
11003 r = guestfs_lvm_remove_all (g);
11008 char device[] = "/dev/sda";
11009 device[5] = devchar;
11010 char lines_0[] = ",";
11016 suppress_error = 0;
11017 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11022 char fstype[] = "ext2";
11023 char device[] = "/dev/sda1";
11024 device[5] = devchar;
11026 suppress_error = 0;
11027 r = guestfs_mkfs (g, fstype, device);
11032 char device[] = "/dev/sda1";
11033 device[5] = devchar;
11034 char mountpoint[] = "/";
11036 suppress_error = 0;
11037 r = guestfs_mount (g, device, mountpoint);
11041 /* TestRun for rm (0) */
11043 char path[] = "/new";
11045 suppress_error = 0;
11046 r = guestfs_touch (g, path);
11051 char path[] = "/new";
11053 suppress_error = 0;
11054 r = guestfs_rm (g, path);
11061 static int test_rm_1 (void)
11063 /* InitBasicFS for rm (1): create ext2 on /dev/sda1 */
11065 char device[] = "/dev/sda";
11066 device[5] = devchar;
11068 suppress_error = 0;
11069 r = guestfs_blockdev_setrw (g, device);
11075 suppress_error = 0;
11076 r = guestfs_umount_all (g);
11082 suppress_error = 0;
11083 r = guestfs_lvm_remove_all (g);
11088 char device[] = "/dev/sda";
11089 device[5] = devchar;
11090 char lines_0[] = ",";
11096 suppress_error = 0;
11097 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11102 char fstype[] = "ext2";
11103 char device[] = "/dev/sda1";
11104 device[5] = devchar;
11106 suppress_error = 0;
11107 r = guestfs_mkfs (g, fstype, device);
11112 char device[] = "/dev/sda1";
11113 device[5] = devchar;
11114 char mountpoint[] = "/";
11116 suppress_error = 0;
11117 r = guestfs_mount (g, device, mountpoint);
11121 /* TestLastFail for rm (1) */
11123 char path[] = "/new";
11125 suppress_error = 1;
11126 r = guestfs_rm (g, path);
11133 static int test_rm_2 (void)
11135 /* InitBasicFS for rm (2): create ext2 on /dev/sda1 */
11137 char device[] = "/dev/sda";
11138 device[5] = devchar;
11140 suppress_error = 0;
11141 r = guestfs_blockdev_setrw (g, device);
11147 suppress_error = 0;
11148 r = guestfs_umount_all (g);
11154 suppress_error = 0;
11155 r = guestfs_lvm_remove_all (g);
11160 char device[] = "/dev/sda";
11161 device[5] = devchar;
11162 char lines_0[] = ",";
11168 suppress_error = 0;
11169 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11174 char fstype[] = "ext2";
11175 char device[] = "/dev/sda1";
11176 device[5] = devchar;
11178 suppress_error = 0;
11179 r = guestfs_mkfs (g, fstype, device);
11184 char device[] = "/dev/sda1";
11185 device[5] = devchar;
11186 char mountpoint[] = "/";
11188 suppress_error = 0;
11189 r = guestfs_mount (g, device, mountpoint);
11193 /* TestLastFail for rm (2) */
11195 char path[] = "/new";
11197 suppress_error = 0;
11198 r = guestfs_mkdir (g, path);
11203 char path[] = "/new";
11205 suppress_error = 1;
11206 r = guestfs_rm (g, path);
11213 static int test_read_lines_0 (void)
11215 /* InitBasicFS for read_lines (0): create ext2 on /dev/sda1 */
11217 char device[] = "/dev/sda";
11218 device[5] = devchar;
11220 suppress_error = 0;
11221 r = guestfs_blockdev_setrw (g, device);
11227 suppress_error = 0;
11228 r = guestfs_umount_all (g);
11234 suppress_error = 0;
11235 r = guestfs_lvm_remove_all (g);
11240 char device[] = "/dev/sda";
11241 device[5] = devchar;
11242 char lines_0[] = ",";
11248 suppress_error = 0;
11249 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11254 char fstype[] = "ext2";
11255 char device[] = "/dev/sda1";
11256 device[5] = devchar;
11258 suppress_error = 0;
11259 r = guestfs_mkfs (g, fstype, device);
11264 char device[] = "/dev/sda1";
11265 device[5] = devchar;
11266 char mountpoint[] = "/";
11268 suppress_error = 0;
11269 r = guestfs_mount (g, device, mountpoint);
11273 /* TestOutputList for read_lines (0) */
11275 char path[] = "/new";
11276 char content[] = "line1\r\nline2\nline3";
11278 suppress_error = 0;
11279 r = guestfs_write_file (g, path, content, 0);
11284 char path[] = "/new";
11287 suppress_error = 0;
11288 r = guestfs_read_lines (g, path);
11292 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11297 char expected[] = "line1";
11298 if (strcmp (r[0], expected) != 0) {
11299 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11304 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11309 char expected[] = "line2";
11310 if (strcmp (r[1], expected) != 0) {
11311 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11316 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11321 char expected[] = "line3";
11322 if (strcmp (r[2], expected) != 0) {
11323 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11327 if (r[3] != NULL) {
11328 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11332 for (i = 0; r[i] != NULL; ++i)
11339 static int test_read_lines_1 (void)
11341 /* InitBasicFS for read_lines (1): create ext2 on /dev/sda1 */
11343 char device[] = "/dev/sda";
11344 device[5] = devchar;
11346 suppress_error = 0;
11347 r = guestfs_blockdev_setrw (g, device);
11353 suppress_error = 0;
11354 r = guestfs_umount_all (g);
11360 suppress_error = 0;
11361 r = guestfs_lvm_remove_all (g);
11366 char device[] = "/dev/sda";
11367 device[5] = devchar;
11368 char lines_0[] = ",";
11374 suppress_error = 0;
11375 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11380 char fstype[] = "ext2";
11381 char device[] = "/dev/sda1";
11382 device[5] = devchar;
11384 suppress_error = 0;
11385 r = guestfs_mkfs (g, fstype, device);
11390 char device[] = "/dev/sda1";
11391 device[5] = devchar;
11392 char mountpoint[] = "/";
11394 suppress_error = 0;
11395 r = guestfs_mount (g, device, mountpoint);
11399 /* TestOutputList for read_lines (1) */
11401 char path[] = "/new";
11402 char content[] = "";
11404 suppress_error = 0;
11405 r = guestfs_write_file (g, path, content, 0);
11410 char path[] = "/new";
11413 suppress_error = 0;
11414 r = guestfs_read_lines (g, path);
11417 if (r[0] != NULL) {
11418 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11422 for (i = 0; r[i] != NULL; ++i)
11429 static int test_lvs_0 (void)
11431 /* InitBasicFSonLVM for lvs (0): create ext2 on /dev/VG/LV */
11433 char device[] = "/dev/sda";
11434 device[5] = devchar;
11436 suppress_error = 0;
11437 r = guestfs_blockdev_setrw (g, device);
11443 suppress_error = 0;
11444 r = guestfs_umount_all (g);
11450 suppress_error = 0;
11451 r = guestfs_lvm_remove_all (g);
11456 char device[] = "/dev/sda";
11457 device[5] = devchar;
11458 char lines_0[] = ",";
11464 suppress_error = 0;
11465 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11470 char device[] = "/dev/sda1";
11471 device[5] = devchar;
11473 suppress_error = 0;
11474 r = guestfs_pvcreate (g, device);
11479 char volgroup[] = "VG";
11480 char physvols_0[] = "/dev/sda1";
11481 physvols_0[5] = devchar;
11482 char *physvols[] = {
11487 suppress_error = 0;
11488 r = guestfs_vgcreate (g, volgroup, physvols);
11493 char logvol[] = "LV";
11494 char volgroup[] = "VG";
11496 suppress_error = 0;
11497 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11502 char fstype[] = "ext2";
11503 char device[] = "/dev/VG/LV";
11505 suppress_error = 0;
11506 r = guestfs_mkfs (g, fstype, device);
11511 char device[] = "/dev/VG/LV";
11512 char mountpoint[] = "/";
11514 suppress_error = 0;
11515 r = guestfs_mount (g, device, mountpoint);
11519 /* TestOutputList for lvs (0) */
11523 suppress_error = 0;
11524 r = guestfs_lvs (g);
11528 fprintf (stderr, "test_lvs_0: short list returned from command\n");
11533 char expected[] = "/dev/VG/LV";
11534 if (strcmp (r[0], expected) != 0) {
11535 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11539 if (r[1] != NULL) {
11540 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
11544 for (i = 0; r[i] != NULL; ++i)
11551 static int test_lvs_1 (void)
11553 /* InitEmpty for lvs (1) */
11555 char device[] = "/dev/sda";
11556 device[5] = devchar;
11558 suppress_error = 0;
11559 r = guestfs_blockdev_setrw (g, device);
11565 suppress_error = 0;
11566 r = guestfs_umount_all (g);
11572 suppress_error = 0;
11573 r = guestfs_lvm_remove_all (g);
11577 /* TestOutputList for lvs (1) */
11579 char device[] = "/dev/sda";
11580 device[5] = devchar;
11581 char lines_0[] = ",10";
11582 char lines_1[] = ",20";
11583 char lines_2[] = ",";
11591 suppress_error = 0;
11592 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11597 char device[] = "/dev/sda1";
11598 device[5] = devchar;
11600 suppress_error = 0;
11601 r = guestfs_pvcreate (g, device);
11606 char device[] = "/dev/sda2";
11607 device[5] = devchar;
11609 suppress_error = 0;
11610 r = guestfs_pvcreate (g, device);
11615 char device[] = "/dev/sda3";
11616 device[5] = devchar;
11618 suppress_error = 0;
11619 r = guestfs_pvcreate (g, device);
11624 char volgroup[] = "VG1";
11625 char physvols_0[] = "/dev/sda1";
11626 physvols_0[5] = devchar;
11627 char physvols_1[] = "/dev/sda2";
11628 physvols_1[5] = devchar;
11629 char *physvols[] = {
11635 suppress_error = 0;
11636 r = guestfs_vgcreate (g, volgroup, physvols);
11641 char volgroup[] = "VG2";
11642 char physvols_0[] = "/dev/sda3";
11643 physvols_0[5] = devchar;
11644 char *physvols[] = {
11649 suppress_error = 0;
11650 r = guestfs_vgcreate (g, volgroup, physvols);
11655 char logvol[] = "LV1";
11656 char volgroup[] = "VG1";
11658 suppress_error = 0;
11659 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11664 char logvol[] = "LV2";
11665 char volgroup[] = "VG1";
11667 suppress_error = 0;
11668 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11673 char logvol[] = "LV3";
11674 char volgroup[] = "VG2";
11676 suppress_error = 0;
11677 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11684 suppress_error = 0;
11685 r = guestfs_lvs (g);
11689 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11694 char expected[] = "/dev/VG1/LV1";
11695 if (strcmp (r[0], expected) != 0) {
11696 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11701 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11706 char expected[] = "/dev/VG1/LV2";
11707 if (strcmp (r[1], expected) != 0) {
11708 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11713 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11718 char expected[] = "/dev/VG2/LV3";
11719 if (strcmp (r[2], expected) != 0) {
11720 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11724 if (r[3] != NULL) {
11725 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
11729 for (i = 0; r[i] != NULL; ++i)
11736 static int test_vgs_0 (void)
11738 /* InitBasicFSonLVM for vgs (0): create ext2 on /dev/VG/LV */
11740 char device[] = "/dev/sda";
11741 device[5] = devchar;
11743 suppress_error = 0;
11744 r = guestfs_blockdev_setrw (g, device);
11750 suppress_error = 0;
11751 r = guestfs_umount_all (g);
11757 suppress_error = 0;
11758 r = guestfs_lvm_remove_all (g);
11763 char device[] = "/dev/sda";
11764 device[5] = devchar;
11765 char lines_0[] = ",";
11771 suppress_error = 0;
11772 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11777 char device[] = "/dev/sda1";
11778 device[5] = devchar;
11780 suppress_error = 0;
11781 r = guestfs_pvcreate (g, device);
11786 char volgroup[] = "VG";
11787 char physvols_0[] = "/dev/sda1";
11788 physvols_0[5] = devchar;
11789 char *physvols[] = {
11794 suppress_error = 0;
11795 r = guestfs_vgcreate (g, volgroup, physvols);
11800 char logvol[] = "LV";
11801 char volgroup[] = "VG";
11803 suppress_error = 0;
11804 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11809 char fstype[] = "ext2";
11810 char device[] = "/dev/VG/LV";
11812 suppress_error = 0;
11813 r = guestfs_mkfs (g, fstype, device);
11818 char device[] = "/dev/VG/LV";
11819 char mountpoint[] = "/";
11821 suppress_error = 0;
11822 r = guestfs_mount (g, device, mountpoint);
11826 /* TestOutputList for vgs (0) */
11830 suppress_error = 0;
11831 r = guestfs_vgs (g);
11835 fprintf (stderr, "test_vgs_0: short list returned from command\n");
11840 char expected[] = "VG";
11841 if (strcmp (r[0], expected) != 0) {
11842 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11846 if (r[1] != NULL) {
11847 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
11851 for (i = 0; r[i] != NULL; ++i)
11858 static int test_vgs_1 (void)
11860 /* InitEmpty for vgs (1) */
11862 char device[] = "/dev/sda";
11863 device[5] = devchar;
11865 suppress_error = 0;
11866 r = guestfs_blockdev_setrw (g, device);
11872 suppress_error = 0;
11873 r = guestfs_umount_all (g);
11879 suppress_error = 0;
11880 r = guestfs_lvm_remove_all (g);
11884 /* TestOutputList for vgs (1) */
11886 char device[] = "/dev/sda";
11887 device[5] = devchar;
11888 char lines_0[] = ",10";
11889 char lines_1[] = ",20";
11890 char lines_2[] = ",";
11898 suppress_error = 0;
11899 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11904 char device[] = "/dev/sda1";
11905 device[5] = devchar;
11907 suppress_error = 0;
11908 r = guestfs_pvcreate (g, device);
11913 char device[] = "/dev/sda2";
11914 device[5] = devchar;
11916 suppress_error = 0;
11917 r = guestfs_pvcreate (g, device);
11922 char device[] = "/dev/sda3";
11923 device[5] = devchar;
11925 suppress_error = 0;
11926 r = guestfs_pvcreate (g, device);
11931 char volgroup[] = "VG1";
11932 char physvols_0[] = "/dev/sda1";
11933 physvols_0[5] = devchar;
11934 char physvols_1[] = "/dev/sda2";
11935 physvols_1[5] = devchar;
11936 char *physvols[] = {
11942 suppress_error = 0;
11943 r = guestfs_vgcreate (g, volgroup, physvols);
11948 char volgroup[] = "VG2";
11949 char physvols_0[] = "/dev/sda3";
11950 physvols_0[5] = devchar;
11951 char *physvols[] = {
11956 suppress_error = 0;
11957 r = guestfs_vgcreate (g, volgroup, physvols);
11964 suppress_error = 0;
11965 r = guestfs_vgs (g);
11969 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11974 char expected[] = "VG1";
11975 if (strcmp (r[0], expected) != 0) {
11976 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11981 fprintf (stderr, "test_vgs_1: short list returned from command\n");
11986 char expected[] = "VG2";
11987 if (strcmp (r[1], expected) != 0) {
11988 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11992 if (r[2] != NULL) {
11993 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
11997 for (i = 0; r[i] != NULL; ++i)
12004 static int test_pvs_0 (void)
12006 /* InitBasicFSonLVM for pvs (0): create ext2 on /dev/VG/LV */
12008 char device[] = "/dev/sda";
12009 device[5] = devchar;
12011 suppress_error = 0;
12012 r = guestfs_blockdev_setrw (g, device);
12018 suppress_error = 0;
12019 r = guestfs_umount_all (g);
12025 suppress_error = 0;
12026 r = guestfs_lvm_remove_all (g);
12031 char device[] = "/dev/sda";
12032 device[5] = devchar;
12033 char lines_0[] = ",";
12039 suppress_error = 0;
12040 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12045 char device[] = "/dev/sda1";
12046 device[5] = devchar;
12048 suppress_error = 0;
12049 r = guestfs_pvcreate (g, device);
12054 char volgroup[] = "VG";
12055 char physvols_0[] = "/dev/sda1";
12056 physvols_0[5] = devchar;
12057 char *physvols[] = {
12062 suppress_error = 0;
12063 r = guestfs_vgcreate (g, volgroup, physvols);
12068 char logvol[] = "LV";
12069 char volgroup[] = "VG";
12071 suppress_error = 0;
12072 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12077 char fstype[] = "ext2";
12078 char device[] = "/dev/VG/LV";
12080 suppress_error = 0;
12081 r = guestfs_mkfs (g, fstype, device);
12086 char device[] = "/dev/VG/LV";
12087 char mountpoint[] = "/";
12089 suppress_error = 0;
12090 r = guestfs_mount (g, device, mountpoint);
12094 /* TestOutputList for pvs (0) */
12098 suppress_error = 0;
12099 r = guestfs_pvs (g);
12103 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12108 char expected[] = "/dev/sda1";
12109 expected[5] = devchar;
12110 if (strcmp (r[0], expected) != 0) {
12111 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12115 if (r[1] != NULL) {
12116 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12120 for (i = 0; r[i] != NULL; ++i)
12127 static int test_pvs_1 (void)
12129 /* InitEmpty for pvs (1) */
12131 char device[] = "/dev/sda";
12132 device[5] = devchar;
12134 suppress_error = 0;
12135 r = guestfs_blockdev_setrw (g, device);
12141 suppress_error = 0;
12142 r = guestfs_umount_all (g);
12148 suppress_error = 0;
12149 r = guestfs_lvm_remove_all (g);
12153 /* TestOutputList for pvs (1) */
12155 char device[] = "/dev/sda";
12156 device[5] = devchar;
12157 char lines_0[] = ",10";
12158 char lines_1[] = ",20";
12159 char lines_2[] = ",";
12167 suppress_error = 0;
12168 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12173 char device[] = "/dev/sda1";
12174 device[5] = devchar;
12176 suppress_error = 0;
12177 r = guestfs_pvcreate (g, device);
12182 char device[] = "/dev/sda2";
12183 device[5] = devchar;
12185 suppress_error = 0;
12186 r = guestfs_pvcreate (g, device);
12191 char device[] = "/dev/sda3";
12192 device[5] = devchar;
12194 suppress_error = 0;
12195 r = guestfs_pvcreate (g, device);
12202 suppress_error = 0;
12203 r = guestfs_pvs (g);
12207 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12212 char expected[] = "/dev/sda1";
12213 expected[5] = devchar;
12214 if (strcmp (r[0], expected) != 0) {
12215 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12220 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12225 char expected[] = "/dev/sda2";
12226 expected[5] = devchar;
12227 if (strcmp (r[1], expected) != 0) {
12228 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12233 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12238 char expected[] = "/dev/sda3";
12239 expected[5] = devchar;
12240 if (strcmp (r[2], expected) != 0) {
12241 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12245 if (r[3] != NULL) {
12246 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12250 for (i = 0; r[i] != NULL; ++i)
12257 static int test_list_partitions_0 (void)
12259 /* InitBasicFS for list_partitions (0): create ext2 on /dev/sda1 */
12261 char device[] = "/dev/sda";
12262 device[5] = devchar;
12264 suppress_error = 0;
12265 r = guestfs_blockdev_setrw (g, device);
12271 suppress_error = 0;
12272 r = guestfs_umount_all (g);
12278 suppress_error = 0;
12279 r = guestfs_lvm_remove_all (g);
12284 char device[] = "/dev/sda";
12285 device[5] = devchar;
12286 char lines_0[] = ",";
12292 suppress_error = 0;
12293 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12298 char fstype[] = "ext2";
12299 char device[] = "/dev/sda1";
12300 device[5] = devchar;
12302 suppress_error = 0;
12303 r = guestfs_mkfs (g, fstype, device);
12308 char device[] = "/dev/sda1";
12309 device[5] = devchar;
12310 char mountpoint[] = "/";
12312 suppress_error = 0;
12313 r = guestfs_mount (g, device, mountpoint);
12317 /* TestOutputList for list_partitions (0) */
12321 suppress_error = 0;
12322 r = guestfs_list_partitions (g);
12326 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12331 char expected[] = "/dev/sda1";
12332 expected[5] = devchar;
12333 if (strcmp (r[0], expected) != 0) {
12334 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12338 if (r[1] != NULL) {
12339 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12343 for (i = 0; r[i] != NULL; ++i)
12350 static int test_list_partitions_1 (void)
12352 /* InitEmpty for list_partitions (1) */
12354 char device[] = "/dev/sda";
12355 device[5] = devchar;
12357 suppress_error = 0;
12358 r = guestfs_blockdev_setrw (g, device);
12364 suppress_error = 0;
12365 r = guestfs_umount_all (g);
12371 suppress_error = 0;
12372 r = guestfs_lvm_remove_all (g);
12376 /* TestOutputList for list_partitions (1) */
12378 char device[] = "/dev/sda";
12379 device[5] = devchar;
12380 char lines_0[] = ",10";
12381 char lines_1[] = ",20";
12382 char lines_2[] = ",";
12390 suppress_error = 0;
12391 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12398 suppress_error = 0;
12399 r = guestfs_list_partitions (g);
12403 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12408 char expected[] = "/dev/sda1";
12409 expected[5] = devchar;
12410 if (strcmp (r[0], expected) != 0) {
12411 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12416 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12421 char expected[] = "/dev/sda2";
12422 expected[5] = devchar;
12423 if (strcmp (r[1], expected) != 0) {
12424 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12429 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12434 char expected[] = "/dev/sda3";
12435 expected[5] = devchar;
12436 if (strcmp (r[2], expected) != 0) {
12437 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12441 if (r[3] != NULL) {
12442 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12446 for (i = 0; r[i] != NULL; ++i)
12453 static int test_list_devices_0 (void)
12455 /* InitEmpty for list_devices (0) */
12457 char device[] = "/dev/sda";
12458 device[5] = devchar;
12460 suppress_error = 0;
12461 r = guestfs_blockdev_setrw (g, device);
12467 suppress_error = 0;
12468 r = guestfs_umount_all (g);
12474 suppress_error = 0;
12475 r = guestfs_lvm_remove_all (g);
12479 /* TestOutputList for list_devices (0) */
12483 suppress_error = 0;
12484 r = guestfs_list_devices (g);
12488 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12493 char expected[] = "/dev/sda";
12494 expected[5] = devchar;
12495 if (strcmp (r[0], expected) != 0) {
12496 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12501 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12506 char expected[] = "/dev/sdb";
12507 expected[5] = devchar;
12508 if (strcmp (r[1], expected) != 0) {
12509 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12514 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12519 char expected[] = "/dev/sdc";
12520 expected[5] = devchar;
12521 if (strcmp (r[2], expected) != 0) {
12522 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12526 if (r[3] != NULL) {
12527 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
12531 for (i = 0; r[i] != NULL; ++i)
12538 static int test_ls_0 (void)
12540 /* InitBasicFS for ls (0): create ext2 on /dev/sda1 */
12542 char device[] = "/dev/sda";
12543 device[5] = devchar;
12545 suppress_error = 0;
12546 r = guestfs_blockdev_setrw (g, device);
12552 suppress_error = 0;
12553 r = guestfs_umount_all (g);
12559 suppress_error = 0;
12560 r = guestfs_lvm_remove_all (g);
12565 char device[] = "/dev/sda";
12566 device[5] = devchar;
12567 char lines_0[] = ",";
12573 suppress_error = 0;
12574 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12579 char fstype[] = "ext2";
12580 char device[] = "/dev/sda1";
12581 device[5] = devchar;
12583 suppress_error = 0;
12584 r = guestfs_mkfs (g, fstype, device);
12589 char device[] = "/dev/sda1";
12590 device[5] = devchar;
12591 char mountpoint[] = "/";
12593 suppress_error = 0;
12594 r = guestfs_mount (g, device, mountpoint);
12598 /* TestOutputList for ls (0) */
12600 char path[] = "/new";
12602 suppress_error = 0;
12603 r = guestfs_touch (g, path);
12608 char path[] = "/newer";
12610 suppress_error = 0;
12611 r = guestfs_touch (g, path);
12616 char path[] = "/newest";
12618 suppress_error = 0;
12619 r = guestfs_touch (g, path);
12624 char directory[] = "/";
12627 suppress_error = 0;
12628 r = guestfs_ls (g, directory);
12632 fprintf (stderr, "test_ls_0: short list returned from command\n");
12637 char expected[] = "lost+found";
12638 if (strcmp (r[0], expected) != 0) {
12639 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12644 fprintf (stderr, "test_ls_0: short list returned from command\n");
12649 char expected[] = "new";
12650 if (strcmp (r[1], expected) != 0) {
12651 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12656 fprintf (stderr, "test_ls_0: short list returned from command\n");
12661 char expected[] = "newer";
12662 if (strcmp (r[2], expected) != 0) {
12663 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12668 fprintf (stderr, "test_ls_0: short list returned from command\n");
12673 char expected[] = "newest";
12674 if (strcmp (r[3], expected) != 0) {
12675 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12679 if (r[4] != NULL) {
12680 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
12684 for (i = 0; r[i] != NULL; ++i)
12691 static int test_cat_0 (void)
12693 /* InitBasicFS for cat (0): create ext2 on /dev/sda1 */
12695 char device[] = "/dev/sda";
12696 device[5] = devchar;
12698 suppress_error = 0;
12699 r = guestfs_blockdev_setrw (g, device);
12705 suppress_error = 0;
12706 r = guestfs_umount_all (g);
12712 suppress_error = 0;
12713 r = guestfs_lvm_remove_all (g);
12718 char device[] = "/dev/sda";
12719 device[5] = devchar;
12720 char lines_0[] = ",";
12726 suppress_error = 0;
12727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12732 char fstype[] = "ext2";
12733 char device[] = "/dev/sda1";
12734 device[5] = devchar;
12736 suppress_error = 0;
12737 r = guestfs_mkfs (g, fstype, device);
12742 char device[] = "/dev/sda1";
12743 device[5] = devchar;
12744 char mountpoint[] = "/";
12746 suppress_error = 0;
12747 r = guestfs_mount (g, device, mountpoint);
12751 /* TestOutput for cat (0) */
12752 char expected[] = "new file contents";
12754 char path[] = "/new";
12755 char content[] = "new file contents";
12757 suppress_error = 0;
12758 r = guestfs_write_file (g, path, content, 0);
12763 char path[] = "/new";
12765 suppress_error = 0;
12766 r = guestfs_cat (g, path);
12769 if (strcmp (r, expected) != 0) {
12770 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
12778 static int test_touch_0 (void)
12780 /* InitBasicFS for touch (0): create ext2 on /dev/sda1 */
12782 char device[] = "/dev/sda";
12783 device[5] = devchar;
12785 suppress_error = 0;
12786 r = guestfs_blockdev_setrw (g, device);
12792 suppress_error = 0;
12793 r = guestfs_umount_all (g);
12799 suppress_error = 0;
12800 r = guestfs_lvm_remove_all (g);
12805 char device[] = "/dev/sda";
12806 device[5] = devchar;
12807 char lines_0[] = ",";
12813 suppress_error = 0;
12814 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12819 char fstype[] = "ext2";
12820 char device[] = "/dev/sda1";
12821 device[5] = devchar;
12823 suppress_error = 0;
12824 r = guestfs_mkfs (g, fstype, device);
12829 char device[] = "/dev/sda1";
12830 device[5] = devchar;
12831 char mountpoint[] = "/";
12833 suppress_error = 0;
12834 r = guestfs_mount (g, device, mountpoint);
12838 /* TestOutputTrue for touch (0) */
12840 char path[] = "/new";
12842 suppress_error = 0;
12843 r = guestfs_touch (g, path);
12848 char path[] = "/new";
12850 suppress_error = 0;
12851 r = guestfs_exists (g, path);
12855 fprintf (stderr, "test_touch_0: expected true, got false\n");
12862 static int test_sync_0 (void)
12864 /* InitEmpty for sync (0) */
12866 char device[] = "/dev/sda";
12867 device[5] = devchar;
12869 suppress_error = 0;
12870 r = guestfs_blockdev_setrw (g, device);
12876 suppress_error = 0;
12877 r = guestfs_umount_all (g);
12883 suppress_error = 0;
12884 r = guestfs_lvm_remove_all (g);
12888 /* TestRun for sync (0) */
12891 suppress_error = 0;
12892 r = guestfs_sync (g);
12899 static int test_mount_0 (void)
12901 /* InitEmpty for mount (0) */
12903 char device[] = "/dev/sda";
12904 device[5] = devchar;
12906 suppress_error = 0;
12907 r = guestfs_blockdev_setrw (g, device);
12913 suppress_error = 0;
12914 r = guestfs_umount_all (g);
12920 suppress_error = 0;
12921 r = guestfs_lvm_remove_all (g);
12925 /* TestOutput for mount (0) */
12926 char expected[] = "new file contents";
12928 char device[] = "/dev/sda";
12929 device[5] = devchar;
12930 char lines_0[] = ",";
12936 suppress_error = 0;
12937 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12942 char fstype[] = "ext2";
12943 char device[] = "/dev/sda1";
12944 device[5] = devchar;
12946 suppress_error = 0;
12947 r = guestfs_mkfs (g, fstype, device);
12952 char device[] = "/dev/sda1";
12953 device[5] = devchar;
12954 char mountpoint[] = "/";
12956 suppress_error = 0;
12957 r = guestfs_mount (g, device, mountpoint);
12962 char path[] = "/new";
12963 char content[] = "new file contents";
12965 suppress_error = 0;
12966 r = guestfs_write_file (g, path, content, 0);
12971 char path[] = "/new";
12973 suppress_error = 0;
12974 r = guestfs_cat (g, path);
12977 if (strcmp (r, expected) != 0) {
12978 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
12986 int main (int argc, char *argv[])
12990 const char *srcdir;
12991 const char *filename;
12993 int nr_tests, test_num = 0;
12996 no_test_warnings ();
12998 g = guestfs_create ();
13000 printf ("guestfs_create FAILED\n");
13004 guestfs_set_error_handler (g, print_error, NULL);
13006 srcdir = getenv ("srcdir");
13007 if (!srcdir) srcdir = ".";
13009 guestfs_set_path (g, ".");
13011 filename = "test1.img";
13012 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13017 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13023 if (write (fd, &c, 1) == -1) {
13029 if (close (fd) == -1) {
13034 if (guestfs_add_drive (g, filename) == -1) {
13035 printf ("guestfs_add_drive %s FAILED\n", filename);
13039 filename = "test2.img";
13040 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13045 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13051 if (write (fd, &c, 1) == -1) {
13057 if (close (fd) == -1) {
13062 if (guestfs_add_drive (g, filename) == -1) {
13063 printf ("guestfs_add_drive %s FAILED\n", filename);
13067 filename = "test3.img";
13068 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13073 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13079 if (write (fd, &c, 1) == -1) {
13085 if (close (fd) == -1) {
13090 if (guestfs_add_drive (g, filename) == -1) {
13091 printf ("guestfs_add_drive %s FAILED\n", filename);
13095 if (guestfs_launch (g) == -1) {
13096 printf ("guestfs_launch FAILED\n");
13099 if (guestfs_wait_ready (g) == -1) {
13100 printf ("guestfs_wait_ready FAILED\n");
13104 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13105 * names. This changed between RHEL 5 and RHEL 6 so we have to
13108 devs = guestfs_list_devices (g);
13109 if (devs == NULL || devs[0] == NULL) {
13110 printf ("guestfs_list_devices FAILED\n");
13113 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13115 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13118 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13122 for (i = 0; devs[i] != NULL; ++i)
13129 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13130 if (test_zerofree_0 () == -1) {
13131 printf ("test_zerofree_0 FAILED\n");
13135 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13136 if (test_hexdump_0 () == -1) {
13137 printf ("test_hexdump_0 FAILED\n");
13141 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13142 if (test_strings_e_0 () == -1) {
13143 printf ("test_strings_e_0 FAILED\n");
13147 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13148 if (test_strings_e_1 () == -1) {
13149 printf ("test_strings_e_1 FAILED\n");
13153 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13154 if (test_strings_0 () == -1) {
13155 printf ("test_strings_0 FAILED\n");
13159 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13160 if (test_strings_1 () == -1) {
13161 printf ("test_strings_1 FAILED\n");
13165 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13166 if (test_equal_0 () == -1) {
13167 printf ("test_equal_0 FAILED\n");
13171 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13172 if (test_equal_1 () == -1) {
13173 printf ("test_equal_1 FAILED\n");
13177 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13178 if (test_equal_2 () == -1) {
13179 printf ("test_equal_2 FAILED\n");
13183 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13184 if (test_ping_daemon_0 () == -1) {
13185 printf ("test_ping_daemon_0 FAILED\n");
13189 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13190 if (test_dmesg_0 () == -1) {
13191 printf ("test_dmesg_0 FAILED\n");
13195 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13196 if (test_drop_caches_0 () == -1) {
13197 printf ("test_drop_caches_0 FAILED\n");
13201 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13202 if (test_mv_0 () == -1) {
13203 printf ("test_mv_0 FAILED\n");
13207 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13208 if (test_mv_1 () == -1) {
13209 printf ("test_mv_1 FAILED\n");
13213 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13214 if (test_cp_a_0 () == -1) {
13215 printf ("test_cp_a_0 FAILED\n");
13219 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13220 if (test_cp_0 () == -1) {
13221 printf ("test_cp_0 FAILED\n");
13225 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13226 if (test_cp_1 () == -1) {
13227 printf ("test_cp_1 FAILED\n");
13231 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13232 if (test_cp_2 () == -1) {
13233 printf ("test_cp_2 FAILED\n");
13237 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13238 if (test_grub_install_0 () == -1) {
13239 printf ("test_grub_install_0 FAILED\n");
13243 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13244 if (test_zero_0 () == -1) {
13245 printf ("test_zero_0 FAILED\n");
13249 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13250 if (test_fsck_0 () == -1) {
13251 printf ("test_fsck_0 FAILED\n");
13255 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13256 if (test_fsck_1 () == -1) {
13257 printf ("test_fsck_1 FAILED\n");
13261 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13262 if (test_set_e2uuid_0 () == -1) {
13263 printf ("test_set_e2uuid_0 FAILED\n");
13267 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13268 if (test_set_e2uuid_1 () == -1) {
13269 printf ("test_set_e2uuid_1 FAILED\n");
13273 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13274 if (test_set_e2uuid_2 () == -1) {
13275 printf ("test_set_e2uuid_2 FAILED\n");
13279 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13280 if (test_set_e2uuid_3 () == -1) {
13281 printf ("test_set_e2uuid_3 FAILED\n");
13285 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13286 if (test_set_e2label_0 () == -1) {
13287 printf ("test_set_e2label_0 FAILED\n");
13291 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13292 if (test_pvremove_0 () == -1) {
13293 printf ("test_pvremove_0 FAILED\n");
13297 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13298 if (test_pvremove_1 () == -1) {
13299 printf ("test_pvremove_1 FAILED\n");
13303 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13304 if (test_pvremove_2 () == -1) {
13305 printf ("test_pvremove_2 FAILED\n");
13309 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13310 if (test_vgremove_0 () == -1) {
13311 printf ("test_vgremove_0 FAILED\n");
13315 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13316 if (test_vgremove_1 () == -1) {
13317 printf ("test_vgremove_1 FAILED\n");
13321 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13322 if (test_lvremove_0 () == -1) {
13323 printf ("test_lvremove_0 FAILED\n");
13327 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13328 if (test_lvremove_1 () == -1) {
13329 printf ("test_lvremove_1 FAILED\n");
13333 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13334 if (test_lvremove_2 () == -1) {
13335 printf ("test_lvremove_2 FAILED\n");
13339 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13340 if (test_mount_ro_0 () == -1) {
13341 printf ("test_mount_ro_0 FAILED\n");
13345 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13346 if (test_mount_ro_1 () == -1) {
13347 printf ("test_mount_ro_1 FAILED\n");
13351 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13352 if (test_tgz_in_0 () == -1) {
13353 printf ("test_tgz_in_0 FAILED\n");
13357 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13358 if (test_tar_in_0 () == -1) {
13359 printf ("test_tar_in_0 FAILED\n");
13363 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13364 if (test_checksum_0 () == -1) {
13365 printf ("test_checksum_0 FAILED\n");
13369 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13370 if (test_checksum_1 () == -1) {
13371 printf ("test_checksum_1 FAILED\n");
13375 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13376 if (test_checksum_2 () == -1) {
13377 printf ("test_checksum_2 FAILED\n");
13381 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13382 if (test_checksum_3 () == -1) {
13383 printf ("test_checksum_3 FAILED\n");
13387 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13388 if (test_checksum_4 () == -1) {
13389 printf ("test_checksum_4 FAILED\n");
13393 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13394 if (test_checksum_5 () == -1) {
13395 printf ("test_checksum_5 FAILED\n");
13399 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13400 if (test_checksum_6 () == -1) {
13401 printf ("test_checksum_6 FAILED\n");
13405 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13406 if (test_checksum_7 () == -1) {
13407 printf ("test_checksum_7 FAILED\n");
13411 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13412 if (test_download_0 () == -1) {
13413 printf ("test_download_0 FAILED\n");
13417 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13418 if (test_upload_0 () == -1) {
13419 printf ("test_upload_0 FAILED\n");
13423 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13424 if (test_blockdev_rereadpt_0 () == -1) {
13425 printf ("test_blockdev_rereadpt_0 FAILED\n");
13429 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13430 if (test_blockdev_flushbufs_0 () == -1) {
13431 printf ("test_blockdev_flushbufs_0 FAILED\n");
13435 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
13436 if (test_blockdev_getsize64_0 () == -1) {
13437 printf ("test_blockdev_getsize64_0 FAILED\n");
13441 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
13442 if (test_blockdev_getsz_0 () == -1) {
13443 printf ("test_blockdev_getsz_0 FAILED\n");
13447 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
13448 if (test_blockdev_getbsz_0 () == -1) {
13449 printf ("test_blockdev_getbsz_0 FAILED\n");
13453 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
13454 if (test_blockdev_getss_0 () == -1) {
13455 printf ("test_blockdev_getss_0 FAILED\n");
13459 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
13460 if (test_blockdev_getro_0 () == -1) {
13461 printf ("test_blockdev_getro_0 FAILED\n");
13465 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
13466 if (test_blockdev_setrw_0 () == -1) {
13467 printf ("test_blockdev_setrw_0 FAILED\n");
13471 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
13472 if (test_blockdev_setro_0 () == -1) {
13473 printf ("test_blockdev_setro_0 FAILED\n");
13477 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
13478 if (test_statvfs_0 () == -1) {
13479 printf ("test_statvfs_0 FAILED\n");
13483 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
13484 if (test_lstat_0 () == -1) {
13485 printf ("test_lstat_0 FAILED\n");
13489 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
13490 if (test_stat_0 () == -1) {
13491 printf ("test_stat_0 FAILED\n");
13495 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
13496 if (test_command_lines_0 () == -1) {
13497 printf ("test_command_lines_0 FAILED\n");
13501 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
13502 if (test_command_lines_1 () == -1) {
13503 printf ("test_command_lines_1 FAILED\n");
13507 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
13508 if (test_command_lines_2 () == -1) {
13509 printf ("test_command_lines_2 FAILED\n");
13513 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
13514 if (test_command_lines_3 () == -1) {
13515 printf ("test_command_lines_3 FAILED\n");
13519 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
13520 if (test_command_lines_4 () == -1) {
13521 printf ("test_command_lines_4 FAILED\n");
13525 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
13526 if (test_command_lines_5 () == -1) {
13527 printf ("test_command_lines_5 FAILED\n");
13531 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
13532 if (test_command_lines_6 () == -1) {
13533 printf ("test_command_lines_6 FAILED\n");
13537 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
13538 if (test_command_lines_7 () == -1) {
13539 printf ("test_command_lines_7 FAILED\n");
13543 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
13544 if (test_command_lines_8 () == -1) {
13545 printf ("test_command_lines_8 FAILED\n");
13549 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
13550 if (test_command_lines_9 () == -1) {
13551 printf ("test_command_lines_9 FAILED\n");
13555 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
13556 if (test_command_lines_10 () == -1) {
13557 printf ("test_command_lines_10 FAILED\n");
13561 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
13562 if (test_command_0 () == -1) {
13563 printf ("test_command_0 FAILED\n");
13567 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
13568 if (test_command_1 () == -1) {
13569 printf ("test_command_1 FAILED\n");
13573 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
13574 if (test_command_2 () == -1) {
13575 printf ("test_command_2 FAILED\n");
13579 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
13580 if (test_command_3 () == -1) {
13581 printf ("test_command_3 FAILED\n");
13585 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
13586 if (test_command_4 () == -1) {
13587 printf ("test_command_4 FAILED\n");
13591 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
13592 if (test_command_5 () == -1) {
13593 printf ("test_command_5 FAILED\n");
13597 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
13598 if (test_command_6 () == -1) {
13599 printf ("test_command_6 FAILED\n");
13603 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
13604 if (test_command_7 () == -1) {
13605 printf ("test_command_7 FAILED\n");
13609 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
13610 if (test_command_8 () == -1) {
13611 printf ("test_command_8 FAILED\n");
13615 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
13616 if (test_command_9 () == -1) {
13617 printf ("test_command_9 FAILED\n");
13621 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
13622 if (test_command_10 () == -1) {
13623 printf ("test_command_10 FAILED\n");
13627 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
13628 if (test_command_11 () == -1) {
13629 printf ("test_command_11 FAILED\n");
13633 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
13634 if (test_file_0 () == -1) {
13635 printf ("test_file_0 FAILED\n");
13639 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
13640 if (test_file_1 () == -1) {
13641 printf ("test_file_1 FAILED\n");
13645 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
13646 if (test_file_2 () == -1) {
13647 printf ("test_file_2 FAILED\n");
13651 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
13652 if (test_umount_all_0 () == -1) {
13653 printf ("test_umount_all_0 FAILED\n");
13657 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
13658 if (test_umount_all_1 () == -1) {
13659 printf ("test_umount_all_1 FAILED\n");
13663 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
13664 if (test_mounts_0 () == -1) {
13665 printf ("test_mounts_0 FAILED\n");
13669 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
13670 if (test_umount_0 () == -1) {
13671 printf ("test_umount_0 FAILED\n");
13675 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
13676 if (test_umount_1 () == -1) {
13677 printf ("test_umount_1 FAILED\n");
13681 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
13682 if (test_write_file_0 () == -1) {
13683 printf ("test_write_file_0 FAILED\n");
13687 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
13688 if (test_write_file_1 () == -1) {
13689 printf ("test_write_file_1 FAILED\n");
13693 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
13694 if (test_write_file_2 () == -1) {
13695 printf ("test_write_file_2 FAILED\n");
13699 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
13700 if (test_write_file_3 () == -1) {
13701 printf ("test_write_file_3 FAILED\n");
13705 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
13706 if (test_write_file_4 () == -1) {
13707 printf ("test_write_file_4 FAILED\n");
13711 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
13712 if (test_write_file_5 () == -1) {
13713 printf ("test_write_file_5 FAILED\n");
13717 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
13718 if (test_mkfs_0 () == -1) {
13719 printf ("test_mkfs_0 FAILED\n");
13723 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
13724 if (test_lvcreate_0 () == -1) {
13725 printf ("test_lvcreate_0 FAILED\n");
13729 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
13730 if (test_vgcreate_0 () == -1) {
13731 printf ("test_vgcreate_0 FAILED\n");
13735 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
13736 if (test_pvcreate_0 () == -1) {
13737 printf ("test_pvcreate_0 FAILED\n");
13741 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
13742 if (test_is_dir_0 () == -1) {
13743 printf ("test_is_dir_0 FAILED\n");
13747 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
13748 if (test_is_dir_1 () == -1) {
13749 printf ("test_is_dir_1 FAILED\n");
13753 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
13754 if (test_is_file_0 () == -1) {
13755 printf ("test_is_file_0 FAILED\n");
13759 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
13760 if (test_is_file_1 () == -1) {
13761 printf ("test_is_file_1 FAILED\n");
13765 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
13766 if (test_exists_0 () == -1) {
13767 printf ("test_exists_0 FAILED\n");
13771 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
13772 if (test_exists_1 () == -1) {
13773 printf ("test_exists_1 FAILED\n");
13777 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
13778 if (test_mkdir_p_0 () == -1) {
13779 printf ("test_mkdir_p_0 FAILED\n");
13783 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
13784 if (test_mkdir_p_1 () == -1) {
13785 printf ("test_mkdir_p_1 FAILED\n");
13789 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
13790 if (test_mkdir_p_2 () == -1) {
13791 printf ("test_mkdir_p_2 FAILED\n");
13795 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
13796 if (test_mkdir_0 () == -1) {
13797 printf ("test_mkdir_0 FAILED\n");
13801 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
13802 if (test_mkdir_1 () == -1) {
13803 printf ("test_mkdir_1 FAILED\n");
13807 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
13808 if (test_rm_rf_0 () == -1) {
13809 printf ("test_rm_rf_0 FAILED\n");
13813 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
13814 if (test_rmdir_0 () == -1) {
13815 printf ("test_rmdir_0 FAILED\n");
13819 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
13820 if (test_rmdir_1 () == -1) {
13821 printf ("test_rmdir_1 FAILED\n");
13825 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
13826 if (test_rmdir_2 () == -1) {
13827 printf ("test_rmdir_2 FAILED\n");
13831 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
13832 if (test_rm_0 () == -1) {
13833 printf ("test_rm_0 FAILED\n");
13837 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
13838 if (test_rm_1 () == -1) {
13839 printf ("test_rm_1 FAILED\n");
13843 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
13844 if (test_rm_2 () == -1) {
13845 printf ("test_rm_2 FAILED\n");
13849 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
13850 if (test_read_lines_0 () == -1) {
13851 printf ("test_read_lines_0 FAILED\n");
13855 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
13856 if (test_read_lines_1 () == -1) {
13857 printf ("test_read_lines_1 FAILED\n");
13861 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
13862 if (test_lvs_0 () == -1) {
13863 printf ("test_lvs_0 FAILED\n");
13867 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
13868 if (test_lvs_1 () == -1) {
13869 printf ("test_lvs_1 FAILED\n");
13873 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
13874 if (test_vgs_0 () == -1) {
13875 printf ("test_vgs_0 FAILED\n");
13879 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
13880 if (test_vgs_1 () == -1) {
13881 printf ("test_vgs_1 FAILED\n");
13885 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
13886 if (test_pvs_0 () == -1) {
13887 printf ("test_pvs_0 FAILED\n");
13891 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
13892 if (test_pvs_1 () == -1) {
13893 printf ("test_pvs_1 FAILED\n");
13897 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
13898 if (test_list_partitions_0 () == -1) {
13899 printf ("test_list_partitions_0 FAILED\n");
13903 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
13904 if (test_list_partitions_1 () == -1) {
13905 printf ("test_list_partitions_1 FAILED\n");
13909 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
13910 if (test_list_devices_0 () == -1) {
13911 printf ("test_list_devices_0 FAILED\n");
13915 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
13916 if (test_ls_0 () == -1) {
13917 printf ("test_ls_0 FAILED\n");
13921 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
13922 if (test_cat_0 () == -1) {
13923 printf ("test_cat_0 FAILED\n");
13927 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
13928 if (test_touch_0 () == -1) {
13929 printf ("test_touch_0 FAILED\n");
13933 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
13934 if (test_sync_0 () == -1) {
13935 printf ("test_sync_0 FAILED\n");
13939 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
13940 if (test_mount_0 () == -1) {
13941 printf ("test_mount_0 FAILED\n");
13946 unlink ("test1.img");
13947 unlink ("test2.img");
13948 unlink ("test3.img");
13951 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);