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");
126 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
129 static int test_find_0 (void)
131 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
133 char device[] = "/dev/sda";
137 r = guestfs_blockdev_setrw (g, device);
144 r = guestfs_umount_all (g);
151 r = guestfs_lvm_remove_all (g);
156 char device[] = "/dev/sda";
158 char lines_0[] = ",";
165 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
170 char fstype[] = "ext2";
171 char device[] = "/dev/sda1";
175 r = guestfs_mkfs (g, fstype, device);
180 char device[] = "/dev/sda1";
182 char mountpoint[] = "/";
185 r = guestfs_mount (g, device, mountpoint);
189 /* TestOutputList for find (0) */
191 char directory[] = "/";
195 r = guestfs_find (g, directory);
199 fprintf (stderr, "test_find_0: short list returned from command\n");
204 char expected[] = "lost+found";
205 if (strcmp (r[0], expected) != 0) {
206 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
211 fprintf (stderr, "test_find_0: extra elements returned from command\n");
215 for (i = 0; r[i] != NULL; ++i)
222 static int test_find_1 (void)
224 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
226 char device[] = "/dev/sda";
230 r = guestfs_blockdev_setrw (g, device);
237 r = guestfs_umount_all (g);
244 r = guestfs_lvm_remove_all (g);
249 char device[] = "/dev/sda";
251 char lines_0[] = ",";
258 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
263 char fstype[] = "ext2";
264 char device[] = "/dev/sda1";
268 r = guestfs_mkfs (g, fstype, device);
273 char device[] = "/dev/sda1";
275 char mountpoint[] = "/";
278 r = guestfs_mount (g, device, mountpoint);
282 /* TestOutputList for find (1) */
287 r = guestfs_touch (g, path);
295 r = guestfs_mkdir (g, path);
300 char path[] = "/b/c";
303 r = guestfs_touch (g, path);
308 char directory[] = "/";
312 r = guestfs_find (g, directory);
316 fprintf (stderr, "test_find_1: short list returned from command\n");
321 char expected[] = "a";
322 if (strcmp (r[0], expected) != 0) {
323 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
328 fprintf (stderr, "test_find_1: short list returned from command\n");
333 char expected[] = "b";
334 if (strcmp (r[1], expected) != 0) {
335 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
340 fprintf (stderr, "test_find_1: short list returned from command\n");
345 char expected[] = "b/c";
346 if (strcmp (r[2], expected) != 0) {
347 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
352 fprintf (stderr, "test_find_1: short list returned from command\n");
357 char expected[] = "lost+found";
358 if (strcmp (r[3], expected) != 0) {
359 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
364 fprintf (stderr, "test_find_1: extra elements returned from command\n");
368 for (i = 0; r[i] != NULL; ++i)
375 static int test_find_2 (void)
377 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
379 char device[] = "/dev/sda";
383 r = guestfs_blockdev_setrw (g, device);
390 r = guestfs_umount_all (g);
397 r = guestfs_lvm_remove_all (g);
402 char device[] = "/dev/sda";
404 char lines_0[] = ",";
411 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
416 char fstype[] = "ext2";
417 char device[] = "/dev/sda1";
421 r = guestfs_mkfs (g, fstype, device);
426 char device[] = "/dev/sda1";
428 char mountpoint[] = "/";
431 r = guestfs_mount (g, device, mountpoint);
435 /* TestOutputList for find (2) */
437 char path[] = "/a/b/c";
440 r = guestfs_mkdir_p (g, path);
445 char path[] = "/a/b/c/d";
448 r = guestfs_touch (g, path);
453 char directory[] = "/a/b/";
457 r = guestfs_find (g, directory);
461 fprintf (stderr, "test_find_2: short list returned from command\n");
466 char expected[] = "c";
467 if (strcmp (r[0], expected) != 0) {
468 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
473 fprintf (stderr, "test_find_2: short list returned from command\n");
478 char expected[] = "c/d";
479 if (strcmp (r[1], expected) != 0) {
480 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
485 fprintf (stderr, "test_find_2: extra elements returned from command\n");
489 for (i = 0; r[i] != NULL; ++i)
496 static int test_lvresize_0 (void)
498 /* InitNone|InitEmpty for test_lvresize_0 */
500 char device[] = "/dev/sda";
504 r = guestfs_blockdev_setrw (g, device);
511 r = guestfs_umount_all (g);
518 r = guestfs_lvm_remove_all (g);
522 /* TestOutput for lvresize (0) */
523 char expected[] = "test content";
525 char device[] = "/dev/sda";
527 char lines_0[] = ",";
534 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
539 char device[] = "/dev/sda1";
543 r = guestfs_pvcreate (g, device);
548 char volgroup[] = "VG";
549 char physvols_0[] = "/dev/sda1";
550 physvols_0[5] = devchar;
557 r = guestfs_vgcreate (g, volgroup, physvols);
562 char logvol[] = "LV";
563 char volgroup[] = "VG";
566 r = guestfs_lvcreate (g, logvol, volgroup, 10);
571 char fstype[] = "ext2";
572 char device[] = "/dev/VG/LV";
575 r = guestfs_mkfs (g, fstype, device);
580 char device[] = "/dev/VG/LV";
581 char mountpoint[] = "/";
584 r = guestfs_mount (g, device, mountpoint);
589 char path[] = "/new";
590 char content[] = "test content";
593 r = guestfs_write_file (g, path, content, 0);
598 char pathordevice[] = "/";
601 r = guestfs_umount (g, pathordevice);
606 char device[] = "/dev/VG/LV";
609 r = guestfs_lvresize (g, device, 20);
614 char device[] = "/dev/VG/LV";
617 r = guestfs_resize2fs (g, device);
622 char device[] = "/dev/VG/LV";
623 char mountpoint[] = "/";
626 r = guestfs_mount (g, device, mountpoint);
631 char path[] = "/new";
634 r = guestfs_cat (g, path);
637 if (strcmp (r, expected) != 0) {
638 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
646 static int test_zerofree_0_prereq (void)
648 const char *str = getenv ("SKIP_ZEROFREE");
649 return str && strcmp (str, "1") == 0;
652 static int test_zerofree_0 (void)
654 if (! test_zerofree_0_prereq ()) {
655 /* InitNone|InitEmpty for test_zerofree_0 */
657 char device[] = "/dev/sda";
661 r = guestfs_blockdev_setrw (g, device);
668 r = guestfs_umount_all (g);
675 r = guestfs_lvm_remove_all (g);
679 /* TestOutput for zerofree (0) */
680 char expected[] = "test file";
682 char device[] = "/dev/sda";
684 char lines_0[] = ",";
691 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
696 char fstype[] = "ext3";
697 char device[] = "/dev/sda1";
701 r = guestfs_mkfs (g, fstype, device);
706 char device[] = "/dev/sda1";
708 char mountpoint[] = "/";
711 r = guestfs_mount (g, device, mountpoint);
716 char path[] = "/new";
717 char content[] = "test file";
720 r = guestfs_write_file (g, path, content, 0);
725 char pathordevice[] = "/dev/sda1";
726 pathordevice[5] = devchar;
729 r = guestfs_umount (g, pathordevice);
734 char device[] = "/dev/sda1";
738 r = guestfs_zerofree (g, device);
743 char device[] = "/dev/sda1";
745 char mountpoint[] = "/";
748 r = guestfs_mount (g, device, mountpoint);
753 char path[] = "/new";
756 r = guestfs_cat (g, path);
759 if (strcmp (r, expected) != 0) {
760 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
766 printf ("%s skipped (reason: test prerequisite)\n", "test_zerofree_0");
770 static int test_hexdump_0 (void)
772 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
774 char device[] = "/dev/sda";
778 r = guestfs_blockdev_setrw (g, device);
785 r = guestfs_umount_all (g);
792 r = guestfs_lvm_remove_all (g);
797 char device[] = "/dev/sda";
799 char lines_0[] = ",";
806 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
811 char fstype[] = "ext2";
812 char device[] = "/dev/sda1";
816 r = guestfs_mkfs (g, fstype, device);
821 char device[] = "/dev/sda1";
823 char mountpoint[] = "/";
826 r = guestfs_mount (g, device, mountpoint);
830 /* TestOutput for hexdump (0) */
831 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
833 char path[] = "/new";
834 char content[] = "hello\nworld\n";
837 r = guestfs_write_file (g, path, content, 12);
842 char path[] = "/new";
845 r = guestfs_hexdump (g, path);
848 if (strcmp (r, expected) != 0) {
849 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
857 static int test_strings_e_0 (void)
859 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
861 char device[] = "/dev/sda";
865 r = guestfs_blockdev_setrw (g, device);
872 r = guestfs_umount_all (g);
879 r = guestfs_lvm_remove_all (g);
884 char device[] = "/dev/sda";
886 char lines_0[] = ",";
893 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
898 char fstype[] = "ext2";
899 char device[] = "/dev/sda1";
903 r = guestfs_mkfs (g, fstype, device);
908 char device[] = "/dev/sda1";
910 char mountpoint[] = "/";
913 r = guestfs_mount (g, device, mountpoint);
917 /* TestOutputList for strings_e (0) */
919 char path[] = "/new";
920 char content[] = "hello\nworld\n";
923 r = guestfs_write_file (g, path, content, 0);
928 char encoding[] = "b";
929 char path[] = "/new";
933 r = guestfs_strings_e (g, encoding, path);
937 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
941 for (i = 0; r[i] != NULL; ++i)
948 static int test_strings_e_1 (void)
950 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
954 static int test_strings_0 (void)
956 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
958 char device[] = "/dev/sda";
962 r = guestfs_blockdev_setrw (g, device);
969 r = guestfs_umount_all (g);
976 r = guestfs_lvm_remove_all (g);
981 char device[] = "/dev/sda";
983 char lines_0[] = ",";
990 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
995 char fstype[] = "ext2";
996 char device[] = "/dev/sda1";
1000 r = guestfs_mkfs (g, fstype, device);
1005 char device[] = "/dev/sda1";
1006 device[5] = devchar;
1007 char mountpoint[] = "/";
1010 r = guestfs_mount (g, device, mountpoint);
1014 /* TestOutputList for strings (0) */
1016 char path[] = "/new";
1017 char content[] = "hello\nworld\n";
1020 r = guestfs_write_file (g, path, content, 0);
1025 char path[] = "/new";
1029 r = guestfs_strings (g, path);
1033 fprintf (stderr, "test_strings_0: short list returned from command\n");
1038 char expected[] = "hello";
1039 if (strcmp (r[0], expected) != 0) {
1040 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1045 fprintf (stderr, "test_strings_0: short list returned from command\n");
1050 char expected[] = "world";
1051 if (strcmp (r[1], expected) != 0) {
1052 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1057 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1061 for (i = 0; r[i] != NULL; ++i)
1068 static int test_strings_1 (void)
1070 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1072 char device[] = "/dev/sda";
1073 device[5] = devchar;
1076 r = guestfs_blockdev_setrw (g, device);
1083 r = guestfs_umount_all (g);
1090 r = guestfs_lvm_remove_all (g);
1095 char device[] = "/dev/sda";
1096 device[5] = devchar;
1097 char lines_0[] = ",";
1104 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1109 char fstype[] = "ext2";
1110 char device[] = "/dev/sda1";
1111 device[5] = devchar;
1114 r = guestfs_mkfs (g, fstype, device);
1119 char device[] = "/dev/sda1";
1120 device[5] = devchar;
1121 char mountpoint[] = "/";
1124 r = guestfs_mount (g, device, mountpoint);
1128 /* TestOutputList for strings (1) */
1130 char path[] = "/new";
1133 r = guestfs_touch (g, path);
1138 char path[] = "/new";
1142 r = guestfs_strings (g, path);
1146 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1150 for (i = 0; r[i] != NULL; ++i)
1157 static int test_equal_0 (void)
1159 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1161 char device[] = "/dev/sda";
1162 device[5] = devchar;
1165 r = guestfs_blockdev_setrw (g, device);
1172 r = guestfs_umount_all (g);
1179 r = guestfs_lvm_remove_all (g);
1184 char device[] = "/dev/sda";
1185 device[5] = devchar;
1186 char lines_0[] = ",";
1193 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1198 char fstype[] = "ext2";
1199 char device[] = "/dev/sda1";
1200 device[5] = devchar;
1203 r = guestfs_mkfs (g, fstype, device);
1208 char device[] = "/dev/sda1";
1209 device[5] = devchar;
1210 char mountpoint[] = "/";
1213 r = guestfs_mount (g, device, mountpoint);
1217 /* TestOutputTrue for equal (0) */
1219 char path[] = "/file1";
1220 char content[] = "contents of a file";
1223 r = guestfs_write_file (g, path, content, 0);
1228 char src[] = "/file1";
1229 char dest[] = "/file2";
1232 r = guestfs_cp (g, src, dest);
1237 char file1[] = "/file1";
1238 char file2[] = "/file2";
1241 r = guestfs_equal (g, file1, file2);
1245 fprintf (stderr, "test_equal_0: expected true, got false\n");
1252 static int test_equal_1 (void)
1254 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1256 char device[] = "/dev/sda";
1257 device[5] = devchar;
1260 r = guestfs_blockdev_setrw (g, device);
1267 r = guestfs_umount_all (g);
1274 r = guestfs_lvm_remove_all (g);
1279 char device[] = "/dev/sda";
1280 device[5] = devchar;
1281 char lines_0[] = ",";
1288 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1293 char fstype[] = "ext2";
1294 char device[] = "/dev/sda1";
1295 device[5] = devchar;
1298 r = guestfs_mkfs (g, fstype, device);
1303 char device[] = "/dev/sda1";
1304 device[5] = devchar;
1305 char mountpoint[] = "/";
1308 r = guestfs_mount (g, device, mountpoint);
1312 /* TestOutputFalse for equal (1) */
1314 char path[] = "/file1";
1315 char content[] = "contents of a file";
1318 r = guestfs_write_file (g, path, content, 0);
1323 char path[] = "/file2";
1324 char content[] = "contents of another file";
1327 r = guestfs_write_file (g, path, content, 0);
1332 char file1[] = "/file1";
1333 char file2[] = "/file2";
1336 r = guestfs_equal (g, file1, file2);
1340 fprintf (stderr, "test_equal_1: expected false, got true\n");
1347 static int test_equal_2 (void)
1349 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1351 char device[] = "/dev/sda";
1352 device[5] = devchar;
1355 r = guestfs_blockdev_setrw (g, device);
1362 r = guestfs_umount_all (g);
1369 r = guestfs_lvm_remove_all (g);
1374 char device[] = "/dev/sda";
1375 device[5] = devchar;
1376 char lines_0[] = ",";
1383 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1388 char fstype[] = "ext2";
1389 char device[] = "/dev/sda1";
1390 device[5] = devchar;
1393 r = guestfs_mkfs (g, fstype, device);
1398 char device[] = "/dev/sda1";
1399 device[5] = devchar;
1400 char mountpoint[] = "/";
1403 r = guestfs_mount (g, device, mountpoint);
1407 /* TestLastFail for equal (2) */
1409 char file1[] = "/file1";
1410 char file2[] = "/file2";
1413 r = guestfs_equal (g, file1, file2);
1420 static int test_ping_daemon_0 (void)
1422 /* InitNone|InitEmpty for test_ping_daemon_0 */
1424 char device[] = "/dev/sda";
1425 device[5] = devchar;
1428 r = guestfs_blockdev_setrw (g, device);
1435 r = guestfs_umount_all (g);
1442 r = guestfs_lvm_remove_all (g);
1446 /* TestRun for ping_daemon (0) */
1450 r = guestfs_ping_daemon (g);
1457 static int test_dmesg_0 (void)
1459 /* InitNone|InitEmpty for test_dmesg_0 */
1461 char device[] = "/dev/sda";
1462 device[5] = devchar;
1465 r = guestfs_blockdev_setrw (g, device);
1472 r = guestfs_umount_all (g);
1479 r = guestfs_lvm_remove_all (g);
1483 /* TestRun for dmesg (0) */
1487 r = guestfs_dmesg (g);
1495 static int test_drop_caches_0 (void)
1497 /* InitNone|InitEmpty for test_drop_caches_0 */
1499 char device[] = "/dev/sda";
1500 device[5] = devchar;
1503 r = guestfs_blockdev_setrw (g, device);
1510 r = guestfs_umount_all (g);
1517 r = guestfs_lvm_remove_all (g);
1521 /* TestRun for drop_caches (0) */
1525 r = guestfs_drop_caches (g, 3);
1532 static int test_mv_0 (void)
1534 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1536 char device[] = "/dev/sda";
1537 device[5] = devchar;
1540 r = guestfs_blockdev_setrw (g, device);
1547 r = guestfs_umount_all (g);
1554 r = guestfs_lvm_remove_all (g);
1559 char device[] = "/dev/sda";
1560 device[5] = devchar;
1561 char lines_0[] = ",";
1568 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1573 char fstype[] = "ext2";
1574 char device[] = "/dev/sda1";
1575 device[5] = devchar;
1578 r = guestfs_mkfs (g, fstype, device);
1583 char device[] = "/dev/sda1";
1584 device[5] = devchar;
1585 char mountpoint[] = "/";
1588 r = guestfs_mount (g, device, mountpoint);
1592 /* TestOutput for mv (0) */
1593 char expected[] = "file content";
1595 char path[] = "/old";
1596 char content[] = "file content";
1599 r = guestfs_write_file (g, path, content, 0);
1604 char src[] = "/old";
1605 char dest[] = "/new";
1608 r = guestfs_mv (g, src, dest);
1613 char path[] = "/new";
1616 r = guestfs_cat (g, path);
1619 if (strcmp (r, expected) != 0) {
1620 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1628 static int test_mv_1 (void)
1630 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1632 char device[] = "/dev/sda";
1633 device[5] = devchar;
1636 r = guestfs_blockdev_setrw (g, device);
1643 r = guestfs_umount_all (g);
1650 r = guestfs_lvm_remove_all (g);
1655 char device[] = "/dev/sda";
1656 device[5] = devchar;
1657 char lines_0[] = ",";
1664 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1669 char fstype[] = "ext2";
1670 char device[] = "/dev/sda1";
1671 device[5] = devchar;
1674 r = guestfs_mkfs (g, fstype, device);
1679 char device[] = "/dev/sda1";
1680 device[5] = devchar;
1681 char mountpoint[] = "/";
1684 r = guestfs_mount (g, device, mountpoint);
1688 /* TestOutputFalse for mv (1) */
1690 char path[] = "/old";
1691 char content[] = "file content";
1694 r = guestfs_write_file (g, path, content, 0);
1699 char src[] = "/old";
1700 char dest[] = "/new";
1703 r = guestfs_mv (g, src, dest);
1708 char path[] = "/old";
1711 r = guestfs_is_file (g, path);
1715 fprintf (stderr, "test_mv_1: expected false, got true\n");
1722 static int test_cp_a_0 (void)
1724 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1726 char device[] = "/dev/sda";
1727 device[5] = devchar;
1730 r = guestfs_blockdev_setrw (g, device);
1737 r = guestfs_umount_all (g);
1744 r = guestfs_lvm_remove_all (g);
1749 char device[] = "/dev/sda";
1750 device[5] = devchar;
1751 char lines_0[] = ",";
1758 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1763 char fstype[] = "ext2";
1764 char device[] = "/dev/sda1";
1765 device[5] = devchar;
1768 r = guestfs_mkfs (g, fstype, device);
1773 char device[] = "/dev/sda1";
1774 device[5] = devchar;
1775 char mountpoint[] = "/";
1778 r = guestfs_mount (g, device, mountpoint);
1782 /* TestOutput for cp_a (0) */
1783 char expected[] = "file content";
1785 char path[] = "/olddir";
1788 r = guestfs_mkdir (g, path);
1793 char path[] = "/newdir";
1796 r = guestfs_mkdir (g, path);
1801 char path[] = "/olddir/file";
1802 char content[] = "file content";
1805 r = guestfs_write_file (g, path, content, 0);
1810 char src[] = "/olddir";
1811 char dest[] = "/newdir";
1814 r = guestfs_cp_a (g, src, dest);
1819 char path[] = "/newdir/olddir/file";
1822 r = guestfs_cat (g, path);
1825 if (strcmp (r, expected) != 0) {
1826 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1834 static int test_cp_0 (void)
1836 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1838 char device[] = "/dev/sda";
1839 device[5] = devchar;
1842 r = guestfs_blockdev_setrw (g, device);
1849 r = guestfs_umount_all (g);
1856 r = guestfs_lvm_remove_all (g);
1861 char device[] = "/dev/sda";
1862 device[5] = devchar;
1863 char lines_0[] = ",";
1870 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1875 char fstype[] = "ext2";
1876 char device[] = "/dev/sda1";
1877 device[5] = devchar;
1880 r = guestfs_mkfs (g, fstype, device);
1885 char device[] = "/dev/sda1";
1886 device[5] = devchar;
1887 char mountpoint[] = "/";
1890 r = guestfs_mount (g, device, mountpoint);
1894 /* TestOutput for cp (0) */
1895 char expected[] = "file content";
1897 char path[] = "/old";
1898 char content[] = "file content";
1901 r = guestfs_write_file (g, path, content, 0);
1906 char src[] = "/old";
1907 char dest[] = "/new";
1910 r = guestfs_cp (g, src, dest);
1915 char path[] = "/new";
1918 r = guestfs_cat (g, path);
1921 if (strcmp (r, expected) != 0) {
1922 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1930 static int test_cp_1 (void)
1932 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1934 char device[] = "/dev/sda";
1935 device[5] = devchar;
1938 r = guestfs_blockdev_setrw (g, device);
1945 r = guestfs_umount_all (g);
1952 r = guestfs_lvm_remove_all (g);
1957 char device[] = "/dev/sda";
1958 device[5] = devchar;
1959 char lines_0[] = ",";
1966 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1971 char fstype[] = "ext2";
1972 char device[] = "/dev/sda1";
1973 device[5] = devchar;
1976 r = guestfs_mkfs (g, fstype, device);
1981 char device[] = "/dev/sda1";
1982 device[5] = devchar;
1983 char mountpoint[] = "/";
1986 r = guestfs_mount (g, device, mountpoint);
1990 /* TestOutputTrue for cp (1) */
1992 char path[] = "/old";
1993 char content[] = "file content";
1996 r = guestfs_write_file (g, path, content, 0);
2001 char src[] = "/old";
2002 char dest[] = "/new";
2005 r = guestfs_cp (g, src, dest);
2010 char path[] = "/old";
2013 r = guestfs_is_file (g, path);
2017 fprintf (stderr, "test_cp_1: expected true, got false\n");
2024 static int test_cp_2 (void)
2026 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2028 char device[] = "/dev/sda";
2029 device[5] = devchar;
2032 r = guestfs_blockdev_setrw (g, device);
2039 r = guestfs_umount_all (g);
2046 r = guestfs_lvm_remove_all (g);
2051 char device[] = "/dev/sda";
2052 device[5] = devchar;
2053 char lines_0[] = ",";
2060 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2065 char fstype[] = "ext2";
2066 char device[] = "/dev/sda1";
2067 device[5] = devchar;
2070 r = guestfs_mkfs (g, fstype, device);
2075 char device[] = "/dev/sda1";
2076 device[5] = devchar;
2077 char mountpoint[] = "/";
2080 r = guestfs_mount (g, device, mountpoint);
2084 /* TestOutput for cp (2) */
2085 char expected[] = "file content";
2087 char path[] = "/old";
2088 char content[] = "file content";
2091 r = guestfs_write_file (g, path, content, 0);
2096 char path[] = "/dir";
2099 r = guestfs_mkdir (g, path);
2104 char src[] = "/old";
2105 char dest[] = "/dir/new";
2108 r = guestfs_cp (g, src, dest);
2113 char path[] = "/dir/new";
2116 r = guestfs_cat (g, path);
2119 if (strcmp (r, expected) != 0) {
2120 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2128 static int test_grub_install_0 (void)
2130 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2132 char device[] = "/dev/sda";
2133 device[5] = devchar;
2136 r = guestfs_blockdev_setrw (g, device);
2143 r = guestfs_umount_all (g);
2150 r = guestfs_lvm_remove_all (g);
2155 char device[] = "/dev/sda";
2156 device[5] = devchar;
2157 char lines_0[] = ",";
2164 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2169 char fstype[] = "ext2";
2170 char device[] = "/dev/sda1";
2171 device[5] = devchar;
2174 r = guestfs_mkfs (g, fstype, device);
2179 char device[] = "/dev/sda1";
2180 device[5] = devchar;
2181 char mountpoint[] = "/";
2184 r = guestfs_mount (g, device, mountpoint);
2188 /* TestOutputTrue for grub_install (0) */
2191 char device[] = "/dev/sda1";
2192 device[5] = devchar;
2195 r = guestfs_grub_install (g, root, device);
2200 char path[] = "/boot";
2203 r = guestfs_is_dir (g, path);
2207 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2214 static int test_zero_0 (void)
2216 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2218 char device[] = "/dev/sda";
2219 device[5] = devchar;
2222 r = guestfs_blockdev_setrw (g, device);
2229 r = guestfs_umount_all (g);
2236 r = guestfs_lvm_remove_all (g);
2241 char device[] = "/dev/sda";
2242 device[5] = devchar;
2243 char lines_0[] = ",";
2250 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2255 char fstype[] = "ext2";
2256 char device[] = "/dev/sda1";
2257 device[5] = devchar;
2260 r = guestfs_mkfs (g, fstype, device);
2265 char device[] = "/dev/sda1";
2266 device[5] = devchar;
2267 char mountpoint[] = "/";
2270 r = guestfs_mount (g, device, mountpoint);
2274 /* TestOutput for zero (0) */
2275 char expected[] = "data";
2277 char pathordevice[] = "/dev/sda1";
2278 pathordevice[5] = devchar;
2281 r = guestfs_umount (g, pathordevice);
2286 char device[] = "/dev/sda1";
2287 device[5] = devchar;
2290 r = guestfs_zero (g, device);
2295 char path[] = "/dev/sda1";
2299 r = guestfs_file (g, path);
2302 if (strcmp (r, expected) != 0) {
2303 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2311 static int test_fsck_0 (void)
2313 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2315 char device[] = "/dev/sda";
2316 device[5] = devchar;
2319 r = guestfs_blockdev_setrw (g, device);
2326 r = guestfs_umount_all (g);
2333 r = guestfs_lvm_remove_all (g);
2338 char device[] = "/dev/sda";
2339 device[5] = devchar;
2340 char lines_0[] = ",";
2347 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2352 char fstype[] = "ext2";
2353 char device[] = "/dev/sda1";
2354 device[5] = devchar;
2357 r = guestfs_mkfs (g, fstype, device);
2362 char device[] = "/dev/sda1";
2363 device[5] = devchar;
2364 char mountpoint[] = "/";
2367 r = guestfs_mount (g, device, mountpoint);
2371 /* TestOutputInt for fsck (0) */
2373 char pathordevice[] = "/dev/sda1";
2374 pathordevice[5] = devchar;
2377 r = guestfs_umount (g, pathordevice);
2382 char fstype[] = "ext2";
2383 char device[] = "/dev/sda1";
2384 device[5] = devchar;
2387 r = guestfs_fsck (g, fstype, device);
2391 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2398 static int test_fsck_1 (void)
2400 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2402 char device[] = "/dev/sda";
2403 device[5] = devchar;
2406 r = guestfs_blockdev_setrw (g, device);
2413 r = guestfs_umount_all (g);
2420 r = guestfs_lvm_remove_all (g);
2425 char device[] = "/dev/sda";
2426 device[5] = devchar;
2427 char lines_0[] = ",";
2434 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2439 char fstype[] = "ext2";
2440 char device[] = "/dev/sda1";
2441 device[5] = devchar;
2444 r = guestfs_mkfs (g, fstype, device);
2449 char device[] = "/dev/sda1";
2450 device[5] = devchar;
2451 char mountpoint[] = "/";
2454 r = guestfs_mount (g, device, mountpoint);
2458 /* TestOutputInt for fsck (1) */
2460 char pathordevice[] = "/dev/sda1";
2461 pathordevice[5] = devchar;
2464 r = guestfs_umount (g, pathordevice);
2469 char device[] = "/dev/sda1";
2470 device[5] = devchar;
2473 r = guestfs_zero (g, device);
2478 char fstype[] = "ext2";
2479 char device[] = "/dev/sda1";
2480 device[5] = devchar;
2483 r = guestfs_fsck (g, fstype, device);
2487 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
2494 static int test_set_e2uuid_0 (void)
2496 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2498 char device[] = "/dev/sda";
2499 device[5] = devchar;
2502 r = guestfs_blockdev_setrw (g, device);
2509 r = guestfs_umount_all (g);
2516 r = guestfs_lvm_remove_all (g);
2521 char device[] = "/dev/sda";
2522 device[5] = devchar;
2523 char lines_0[] = ",";
2530 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2535 char fstype[] = "ext2";
2536 char device[] = "/dev/sda1";
2537 device[5] = devchar;
2540 r = guestfs_mkfs (g, fstype, device);
2545 char device[] = "/dev/sda1";
2546 device[5] = devchar;
2547 char mountpoint[] = "/";
2550 r = guestfs_mount (g, device, mountpoint);
2554 /* TestOutput for set_e2uuid (0) */
2555 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2557 char device[] = "/dev/sda1";
2558 device[5] = devchar;
2559 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2562 r = guestfs_set_e2uuid (g, device, uuid);
2567 char device[] = "/dev/sda1";
2568 device[5] = devchar;
2571 r = guestfs_get_e2uuid (g, device);
2574 if (strcmp (r, expected) != 0) {
2575 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2583 static int test_set_e2uuid_1 (void)
2585 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2587 char device[] = "/dev/sda";
2588 device[5] = devchar;
2591 r = guestfs_blockdev_setrw (g, device);
2598 r = guestfs_umount_all (g);
2605 r = guestfs_lvm_remove_all (g);
2610 char device[] = "/dev/sda";
2611 device[5] = devchar;
2612 char lines_0[] = ",";
2619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2624 char fstype[] = "ext2";
2625 char device[] = "/dev/sda1";
2626 device[5] = devchar;
2629 r = guestfs_mkfs (g, fstype, device);
2634 char device[] = "/dev/sda1";
2635 device[5] = devchar;
2636 char mountpoint[] = "/";
2639 r = guestfs_mount (g, device, mountpoint);
2643 /* TestOutput for set_e2uuid (1) */
2644 char expected[] = "";
2646 char device[] = "/dev/sda1";
2647 device[5] = devchar;
2648 char uuid[] = "clear";
2651 r = guestfs_set_e2uuid (g, device, uuid);
2656 char device[] = "/dev/sda1";
2657 device[5] = devchar;
2660 r = guestfs_get_e2uuid (g, device);
2663 if (strcmp (r, expected) != 0) {
2664 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2672 static int test_set_e2uuid_2 (void)
2674 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2676 char device[] = "/dev/sda";
2677 device[5] = devchar;
2680 r = guestfs_blockdev_setrw (g, device);
2687 r = guestfs_umount_all (g);
2694 r = guestfs_lvm_remove_all (g);
2699 char device[] = "/dev/sda";
2700 device[5] = devchar;
2701 char lines_0[] = ",";
2708 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2713 char fstype[] = "ext2";
2714 char device[] = "/dev/sda1";
2715 device[5] = devchar;
2718 r = guestfs_mkfs (g, fstype, device);
2723 char device[] = "/dev/sda1";
2724 device[5] = devchar;
2725 char mountpoint[] = "/";
2728 r = guestfs_mount (g, device, mountpoint);
2732 /* TestRun for set_e2uuid (2) */
2734 char device[] = "/dev/sda1";
2735 device[5] = devchar;
2736 char uuid[] = "random";
2739 r = guestfs_set_e2uuid (g, device, uuid);
2746 static int test_set_e2uuid_3 (void)
2748 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2750 char device[] = "/dev/sda";
2751 device[5] = devchar;
2754 r = guestfs_blockdev_setrw (g, device);
2761 r = guestfs_umount_all (g);
2768 r = guestfs_lvm_remove_all (g);
2773 char device[] = "/dev/sda";
2774 device[5] = devchar;
2775 char lines_0[] = ",";
2782 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2787 char fstype[] = "ext2";
2788 char device[] = "/dev/sda1";
2789 device[5] = devchar;
2792 r = guestfs_mkfs (g, fstype, device);
2797 char device[] = "/dev/sda1";
2798 device[5] = devchar;
2799 char mountpoint[] = "/";
2802 r = guestfs_mount (g, device, mountpoint);
2806 /* TestRun for set_e2uuid (3) */
2808 char device[] = "/dev/sda1";
2809 device[5] = devchar;
2810 char uuid[] = "time";
2813 r = guestfs_set_e2uuid (g, device, uuid);
2820 static int test_set_e2label_0 (void)
2822 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2824 char device[] = "/dev/sda";
2825 device[5] = devchar;
2828 r = guestfs_blockdev_setrw (g, device);
2835 r = guestfs_umount_all (g);
2842 r = guestfs_lvm_remove_all (g);
2847 char device[] = "/dev/sda";
2848 device[5] = devchar;
2849 char lines_0[] = ",";
2856 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2861 char fstype[] = "ext2";
2862 char device[] = "/dev/sda1";
2863 device[5] = devchar;
2866 r = guestfs_mkfs (g, fstype, device);
2871 char device[] = "/dev/sda1";
2872 device[5] = devchar;
2873 char mountpoint[] = "/";
2876 r = guestfs_mount (g, device, mountpoint);
2880 /* TestOutput for set_e2label (0) */
2881 char expected[] = "testlabel";
2883 char device[] = "/dev/sda1";
2884 device[5] = devchar;
2885 char label[] = "testlabel";
2888 r = guestfs_set_e2label (g, device, label);
2893 char device[] = "/dev/sda1";
2894 device[5] = devchar;
2897 r = guestfs_get_e2label (g, device);
2900 if (strcmp (r, expected) != 0) {
2901 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2909 static int test_pvremove_0 (void)
2911 /* InitNone|InitEmpty for test_pvremove_0 */
2913 char device[] = "/dev/sda";
2914 device[5] = devchar;
2917 r = guestfs_blockdev_setrw (g, device);
2924 r = guestfs_umount_all (g);
2931 r = guestfs_lvm_remove_all (g);
2935 /* TestOutputList for pvremove (0) */
2937 char device[] = "/dev/sda";
2938 device[5] = devchar;
2941 r = guestfs_pvcreate (g, device);
2946 char volgroup[] = "VG";
2947 char physvols_0[] = "/dev/sda";
2948 physvols_0[5] = devchar;
2949 char *physvols[] = {
2955 r = guestfs_vgcreate (g, volgroup, physvols);
2960 char logvol[] = "LV1";
2961 char volgroup[] = "VG";
2964 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2969 char logvol[] = "LV2";
2970 char volgroup[] = "VG";
2973 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2978 char vgname[] = "VG";
2981 r = guestfs_vgremove (g, vgname);
2986 char device[] = "/dev/sda";
2987 device[5] = devchar;
2990 r = guestfs_pvremove (g, device);
2998 r = guestfs_lvs (g);
3002 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3006 for (i = 0; r[i] != NULL; ++i)
3013 static int test_pvremove_1 (void)
3015 /* InitNone|InitEmpty for test_pvremove_1 */
3017 char device[] = "/dev/sda";
3018 device[5] = devchar;
3021 r = guestfs_blockdev_setrw (g, device);
3028 r = guestfs_umount_all (g);
3035 r = guestfs_lvm_remove_all (g);
3039 /* TestOutputList for pvremove (1) */
3041 char device[] = "/dev/sda";
3042 device[5] = devchar;
3045 r = guestfs_pvcreate (g, device);
3050 char volgroup[] = "VG";
3051 char physvols_0[] = "/dev/sda";
3052 physvols_0[5] = devchar;
3053 char *physvols[] = {
3059 r = guestfs_vgcreate (g, volgroup, physvols);
3064 char logvol[] = "LV1";
3065 char volgroup[] = "VG";
3068 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3073 char logvol[] = "LV2";
3074 char volgroup[] = "VG";
3077 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3082 char vgname[] = "VG";
3085 r = guestfs_vgremove (g, vgname);
3090 char device[] = "/dev/sda";
3091 device[5] = devchar;
3094 r = guestfs_pvremove (g, device);
3102 r = guestfs_vgs (g);
3106 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3110 for (i = 0; r[i] != NULL; ++i)
3117 static int test_pvremove_2 (void)
3119 /* InitNone|InitEmpty for test_pvremove_2 */
3121 char device[] = "/dev/sda";
3122 device[5] = devchar;
3125 r = guestfs_blockdev_setrw (g, device);
3132 r = guestfs_umount_all (g);
3139 r = guestfs_lvm_remove_all (g);
3143 /* TestOutputList for pvremove (2) */
3145 char device[] = "/dev/sda";
3146 device[5] = devchar;
3149 r = guestfs_pvcreate (g, device);
3154 char volgroup[] = "VG";
3155 char physvols_0[] = "/dev/sda";
3156 physvols_0[5] = devchar;
3157 char *physvols[] = {
3163 r = guestfs_vgcreate (g, volgroup, physvols);
3168 char logvol[] = "LV1";
3169 char volgroup[] = "VG";
3172 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3177 char logvol[] = "LV2";
3178 char volgroup[] = "VG";
3181 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3186 char vgname[] = "VG";
3189 r = guestfs_vgremove (g, vgname);
3194 char device[] = "/dev/sda";
3195 device[5] = devchar;
3198 r = guestfs_pvremove (g, device);
3206 r = guestfs_pvs (g);
3210 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3214 for (i = 0; r[i] != NULL; ++i)
3221 static int test_vgremove_0 (void)
3223 /* InitNone|InitEmpty for test_vgremove_0 */
3225 char device[] = "/dev/sda";
3226 device[5] = devchar;
3229 r = guestfs_blockdev_setrw (g, device);
3236 r = guestfs_umount_all (g);
3243 r = guestfs_lvm_remove_all (g);
3247 /* TestOutputList for vgremove (0) */
3249 char device[] = "/dev/sda";
3250 device[5] = devchar;
3253 r = guestfs_pvcreate (g, device);
3258 char volgroup[] = "VG";
3259 char physvols_0[] = "/dev/sda";
3260 physvols_0[5] = devchar;
3261 char *physvols[] = {
3267 r = guestfs_vgcreate (g, volgroup, physvols);
3272 char logvol[] = "LV1";
3273 char volgroup[] = "VG";
3276 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3281 char logvol[] = "LV2";
3282 char volgroup[] = "VG";
3285 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3290 char vgname[] = "VG";
3293 r = guestfs_vgremove (g, vgname);
3301 r = guestfs_lvs (g);
3305 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3309 for (i = 0; r[i] != NULL; ++i)
3316 static int test_vgremove_1 (void)
3318 /* InitNone|InitEmpty for test_vgremove_1 */
3320 char device[] = "/dev/sda";
3321 device[5] = devchar;
3324 r = guestfs_blockdev_setrw (g, device);
3331 r = guestfs_umount_all (g);
3338 r = guestfs_lvm_remove_all (g);
3342 /* TestOutputList for vgremove (1) */
3344 char device[] = "/dev/sda";
3345 device[5] = devchar;
3348 r = guestfs_pvcreate (g, device);
3353 char volgroup[] = "VG";
3354 char physvols_0[] = "/dev/sda";
3355 physvols_0[5] = devchar;
3356 char *physvols[] = {
3362 r = guestfs_vgcreate (g, volgroup, physvols);
3367 char logvol[] = "LV1";
3368 char volgroup[] = "VG";
3371 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3376 char logvol[] = "LV2";
3377 char volgroup[] = "VG";
3380 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3385 char vgname[] = "VG";
3388 r = guestfs_vgremove (g, vgname);
3396 r = guestfs_vgs (g);
3400 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3404 for (i = 0; r[i] != NULL; ++i)
3411 static int test_lvremove_0 (void)
3413 /* InitNone|InitEmpty for test_lvremove_0 */
3415 char device[] = "/dev/sda";
3416 device[5] = devchar;
3419 r = guestfs_blockdev_setrw (g, device);
3426 r = guestfs_umount_all (g);
3433 r = guestfs_lvm_remove_all (g);
3437 /* TestOutputList for lvremove (0) */
3439 char device[] = "/dev/sda";
3440 device[5] = devchar;
3443 r = guestfs_pvcreate (g, device);
3448 char volgroup[] = "VG";
3449 char physvols_0[] = "/dev/sda";
3450 physvols_0[5] = devchar;
3451 char *physvols[] = {
3457 r = guestfs_vgcreate (g, volgroup, physvols);
3462 char logvol[] = "LV1";
3463 char volgroup[] = "VG";
3466 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3471 char logvol[] = "LV2";
3472 char volgroup[] = "VG";
3475 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3480 char device[] = "/dev/VG/LV1";
3483 r = guestfs_lvremove (g, device);
3491 r = guestfs_lvs (g);
3495 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3500 char expected[] = "/dev/VG/LV2";
3501 if (strcmp (r[0], expected) != 0) {
3502 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3507 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3511 for (i = 0; r[i] != NULL; ++i)
3518 static int test_lvremove_1 (void)
3520 /* InitNone|InitEmpty for test_lvremove_1 */
3522 char device[] = "/dev/sda";
3523 device[5] = devchar;
3526 r = guestfs_blockdev_setrw (g, device);
3533 r = guestfs_umount_all (g);
3540 r = guestfs_lvm_remove_all (g);
3544 /* TestOutputList for lvremove (1) */
3546 char device[] = "/dev/sda";
3547 device[5] = devchar;
3550 r = guestfs_pvcreate (g, device);
3555 char volgroup[] = "VG";
3556 char physvols_0[] = "/dev/sda";
3557 physvols_0[5] = devchar;
3558 char *physvols[] = {
3564 r = guestfs_vgcreate (g, volgroup, physvols);
3569 char logvol[] = "LV1";
3570 char volgroup[] = "VG";
3573 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3578 char logvol[] = "LV2";
3579 char volgroup[] = "VG";
3582 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3587 char device[] = "/dev/VG";
3590 r = guestfs_lvremove (g, device);
3598 r = guestfs_lvs (g);
3602 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3606 for (i = 0; r[i] != NULL; ++i)
3613 static int test_lvremove_2 (void)
3615 /* InitNone|InitEmpty for test_lvremove_2 */
3617 char device[] = "/dev/sda";
3618 device[5] = devchar;
3621 r = guestfs_blockdev_setrw (g, device);
3628 r = guestfs_umount_all (g);
3635 r = guestfs_lvm_remove_all (g);
3639 /* TestOutputList for lvremove (2) */
3641 char device[] = "/dev/sda";
3642 device[5] = devchar;
3645 r = guestfs_pvcreate (g, device);
3650 char volgroup[] = "VG";
3651 char physvols_0[] = "/dev/sda";
3652 physvols_0[5] = devchar;
3653 char *physvols[] = {
3659 r = guestfs_vgcreate (g, volgroup, physvols);
3664 char logvol[] = "LV1";
3665 char volgroup[] = "VG";
3668 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3673 char logvol[] = "LV2";
3674 char volgroup[] = "VG";
3677 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3682 char device[] = "/dev/VG";
3685 r = guestfs_lvremove (g, device);
3693 r = guestfs_vgs (g);
3697 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3702 char expected[] = "VG";
3703 if (strcmp (r[0], expected) != 0) {
3704 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3709 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3713 for (i = 0; r[i] != NULL; ++i)
3720 static int test_mount_ro_0 (void)
3722 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3724 char device[] = "/dev/sda";
3725 device[5] = devchar;
3728 r = guestfs_blockdev_setrw (g, device);
3735 r = guestfs_umount_all (g);
3742 r = guestfs_lvm_remove_all (g);
3747 char device[] = "/dev/sda";
3748 device[5] = devchar;
3749 char lines_0[] = ",";
3756 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3761 char fstype[] = "ext2";
3762 char device[] = "/dev/sda1";
3763 device[5] = devchar;
3766 r = guestfs_mkfs (g, fstype, device);
3771 char device[] = "/dev/sda1";
3772 device[5] = devchar;
3773 char mountpoint[] = "/";
3776 r = guestfs_mount (g, device, mountpoint);
3780 /* TestLastFail for mount_ro (0) */
3782 char pathordevice[] = "/";
3785 r = guestfs_umount (g, pathordevice);
3790 char device[] = "/dev/sda1";
3791 device[5] = devchar;
3792 char mountpoint[] = "/";
3795 r = guestfs_mount_ro (g, device, mountpoint);
3800 char path[] = "/new";
3803 r = guestfs_touch (g, path);
3810 static int test_mount_ro_1 (void)
3812 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3814 char device[] = "/dev/sda";
3815 device[5] = devchar;
3818 r = guestfs_blockdev_setrw (g, device);
3825 r = guestfs_umount_all (g);
3832 r = guestfs_lvm_remove_all (g);
3837 char device[] = "/dev/sda";
3838 device[5] = devchar;
3839 char lines_0[] = ",";
3846 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3851 char fstype[] = "ext2";
3852 char device[] = "/dev/sda1";
3853 device[5] = devchar;
3856 r = guestfs_mkfs (g, fstype, device);
3861 char device[] = "/dev/sda1";
3862 device[5] = devchar;
3863 char mountpoint[] = "/";
3866 r = guestfs_mount (g, device, mountpoint);
3870 /* TestOutput for mount_ro (1) */
3871 char expected[] = "data";
3873 char path[] = "/new";
3874 char content[] = "data";
3877 r = guestfs_write_file (g, path, content, 0);
3882 char pathordevice[] = "/";
3885 r = guestfs_umount (g, pathordevice);
3890 char device[] = "/dev/sda1";
3891 device[5] = devchar;
3892 char mountpoint[] = "/";
3895 r = guestfs_mount_ro (g, device, mountpoint);
3900 char path[] = "/new";
3903 r = guestfs_cat (g, path);
3906 if (strcmp (r, expected) != 0) {
3907 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3915 static int test_tgz_in_0 (void)
3917 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
3919 char device[] = "/dev/sda";
3920 device[5] = devchar;
3923 r = guestfs_blockdev_setrw (g, device);
3930 r = guestfs_umount_all (g);
3937 r = guestfs_lvm_remove_all (g);
3942 char device[] = "/dev/sda";
3943 device[5] = devchar;
3944 char lines_0[] = ",";
3951 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3956 char fstype[] = "ext2";
3957 char device[] = "/dev/sda1";
3958 device[5] = devchar;
3961 r = guestfs_mkfs (g, fstype, device);
3966 char device[] = "/dev/sda1";
3967 device[5] = devchar;
3968 char mountpoint[] = "/";
3971 r = guestfs_mount (g, device, mountpoint);
3975 /* TestOutput for tgz_in (0) */
3976 char expected[] = "hello\n";
3978 char directory[] = "/";
3981 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3986 char path[] = "/hello";
3989 r = guestfs_cat (g, path);
3992 if (strcmp (r, expected) != 0) {
3993 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4001 static int test_tar_in_0 (void)
4003 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4005 char device[] = "/dev/sda";
4006 device[5] = devchar;
4009 r = guestfs_blockdev_setrw (g, device);
4016 r = guestfs_umount_all (g);
4023 r = guestfs_lvm_remove_all (g);
4028 char device[] = "/dev/sda";
4029 device[5] = devchar;
4030 char lines_0[] = ",";
4037 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4042 char fstype[] = "ext2";
4043 char device[] = "/dev/sda1";
4044 device[5] = devchar;
4047 r = guestfs_mkfs (g, fstype, device);
4052 char device[] = "/dev/sda1";
4053 device[5] = devchar;
4054 char mountpoint[] = "/";
4057 r = guestfs_mount (g, device, mountpoint);
4061 /* TestOutput for tar_in (0) */
4062 char expected[] = "hello\n";
4064 char directory[] = "/";
4067 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4072 char path[] = "/hello";
4075 r = guestfs_cat (g, path);
4078 if (strcmp (r, expected) != 0) {
4079 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4087 static int test_checksum_0 (void)
4089 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4091 char device[] = "/dev/sda";
4092 device[5] = devchar;
4095 r = guestfs_blockdev_setrw (g, device);
4102 r = guestfs_umount_all (g);
4109 r = guestfs_lvm_remove_all (g);
4114 char device[] = "/dev/sda";
4115 device[5] = devchar;
4116 char lines_0[] = ",";
4123 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4128 char fstype[] = "ext2";
4129 char device[] = "/dev/sda1";
4130 device[5] = devchar;
4133 r = guestfs_mkfs (g, fstype, device);
4138 char device[] = "/dev/sda1";
4139 device[5] = devchar;
4140 char mountpoint[] = "/";
4143 r = guestfs_mount (g, device, mountpoint);
4147 /* TestOutput for checksum (0) */
4148 char expected[] = "935282863";
4150 char path[] = "/new";
4151 char content[] = "test\n";
4154 r = guestfs_write_file (g, path, content, 0);
4159 char csumtype[] = "crc";
4160 char path[] = "/new";
4163 r = guestfs_checksum (g, csumtype, path);
4166 if (strcmp (r, expected) != 0) {
4167 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4175 static int test_checksum_1 (void)
4177 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
4179 char device[] = "/dev/sda";
4180 device[5] = devchar;
4183 r = guestfs_blockdev_setrw (g, device);
4190 r = guestfs_umount_all (g);
4197 r = guestfs_lvm_remove_all (g);
4202 char device[] = "/dev/sda";
4203 device[5] = devchar;
4204 char lines_0[] = ",";
4211 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4216 char fstype[] = "ext2";
4217 char device[] = "/dev/sda1";
4218 device[5] = devchar;
4221 r = guestfs_mkfs (g, fstype, device);
4226 char device[] = "/dev/sda1";
4227 device[5] = devchar;
4228 char mountpoint[] = "/";
4231 r = guestfs_mount (g, device, mountpoint);
4235 /* TestLastFail for checksum (1) */
4237 char csumtype[] = "crc";
4238 char path[] = "/new";
4241 r = guestfs_checksum (g, csumtype, path);
4249 static int test_checksum_2 (void)
4251 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
4253 char device[] = "/dev/sda";
4254 device[5] = devchar;
4257 r = guestfs_blockdev_setrw (g, device);
4264 r = guestfs_umount_all (g);
4271 r = guestfs_lvm_remove_all (g);
4276 char device[] = "/dev/sda";
4277 device[5] = devchar;
4278 char lines_0[] = ",";
4285 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4290 char fstype[] = "ext2";
4291 char device[] = "/dev/sda1";
4292 device[5] = devchar;
4295 r = guestfs_mkfs (g, fstype, device);
4300 char device[] = "/dev/sda1";
4301 device[5] = devchar;
4302 char mountpoint[] = "/";
4305 r = guestfs_mount (g, device, mountpoint);
4309 /* TestOutput for checksum (2) */
4310 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
4312 char path[] = "/new";
4313 char content[] = "test\n";
4316 r = guestfs_write_file (g, path, content, 0);
4321 char csumtype[] = "md5";
4322 char path[] = "/new";
4325 r = guestfs_checksum (g, csumtype, path);
4328 if (strcmp (r, expected) != 0) {
4329 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
4337 static int test_checksum_3 (void)
4339 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
4341 char device[] = "/dev/sda";
4342 device[5] = devchar;
4345 r = guestfs_blockdev_setrw (g, device);
4352 r = guestfs_umount_all (g);
4359 r = guestfs_lvm_remove_all (g);
4364 char device[] = "/dev/sda";
4365 device[5] = devchar;
4366 char lines_0[] = ",";
4373 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4378 char fstype[] = "ext2";
4379 char device[] = "/dev/sda1";
4380 device[5] = devchar;
4383 r = guestfs_mkfs (g, fstype, device);
4388 char device[] = "/dev/sda1";
4389 device[5] = devchar;
4390 char mountpoint[] = "/";
4393 r = guestfs_mount (g, device, mountpoint);
4397 /* TestOutput for checksum (3) */
4398 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4400 char path[] = "/new";
4401 char content[] = "test\n";
4404 r = guestfs_write_file (g, path, content, 0);
4409 char csumtype[] = "sha1";
4410 char path[] = "/new";
4413 r = guestfs_checksum (g, csumtype, path);
4416 if (strcmp (r, expected) != 0) {
4417 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4425 static int test_checksum_4 (void)
4427 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4429 char device[] = "/dev/sda";
4430 device[5] = devchar;
4433 r = guestfs_blockdev_setrw (g, device);
4440 r = guestfs_umount_all (g);
4447 r = guestfs_lvm_remove_all (g);
4452 char device[] = "/dev/sda";
4453 device[5] = devchar;
4454 char lines_0[] = ",";
4461 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4466 char fstype[] = "ext2";
4467 char device[] = "/dev/sda1";
4468 device[5] = devchar;
4471 r = guestfs_mkfs (g, fstype, device);
4476 char device[] = "/dev/sda1";
4477 device[5] = devchar;
4478 char mountpoint[] = "/";
4481 r = guestfs_mount (g, device, mountpoint);
4485 /* TestOutput for checksum (4) */
4486 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4488 char path[] = "/new";
4489 char content[] = "test\n";
4492 r = guestfs_write_file (g, path, content, 0);
4497 char csumtype[] = "sha224";
4498 char path[] = "/new";
4501 r = guestfs_checksum (g, csumtype, path);
4504 if (strcmp (r, expected) != 0) {
4505 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4513 static int test_checksum_5 (void)
4515 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4517 char device[] = "/dev/sda";
4518 device[5] = devchar;
4521 r = guestfs_blockdev_setrw (g, device);
4528 r = guestfs_umount_all (g);
4535 r = guestfs_lvm_remove_all (g);
4540 char device[] = "/dev/sda";
4541 device[5] = devchar;
4542 char lines_0[] = ",";
4549 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4554 char fstype[] = "ext2";
4555 char device[] = "/dev/sda1";
4556 device[5] = devchar;
4559 r = guestfs_mkfs (g, fstype, device);
4564 char device[] = "/dev/sda1";
4565 device[5] = devchar;
4566 char mountpoint[] = "/";
4569 r = guestfs_mount (g, device, mountpoint);
4573 /* TestOutput for checksum (5) */
4574 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4576 char path[] = "/new";
4577 char content[] = "test\n";
4580 r = guestfs_write_file (g, path, content, 0);
4585 char csumtype[] = "sha256";
4586 char path[] = "/new";
4589 r = guestfs_checksum (g, csumtype, path);
4592 if (strcmp (r, expected) != 0) {
4593 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4601 static int test_checksum_6 (void)
4603 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4605 char device[] = "/dev/sda";
4606 device[5] = devchar;
4609 r = guestfs_blockdev_setrw (g, device);
4616 r = guestfs_umount_all (g);
4623 r = guestfs_lvm_remove_all (g);
4628 char device[] = "/dev/sda";
4629 device[5] = devchar;
4630 char lines_0[] = ",";
4637 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4642 char fstype[] = "ext2";
4643 char device[] = "/dev/sda1";
4644 device[5] = devchar;
4647 r = guestfs_mkfs (g, fstype, device);
4652 char device[] = "/dev/sda1";
4653 device[5] = devchar;
4654 char mountpoint[] = "/";
4657 r = guestfs_mount (g, device, mountpoint);
4661 /* TestOutput for checksum (6) */
4662 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4664 char path[] = "/new";
4665 char content[] = "test\n";
4668 r = guestfs_write_file (g, path, content, 0);
4673 char csumtype[] = "sha384";
4674 char path[] = "/new";
4677 r = guestfs_checksum (g, csumtype, path);
4680 if (strcmp (r, expected) != 0) {
4681 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4689 static int test_checksum_7 (void)
4691 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4693 char device[] = "/dev/sda";
4694 device[5] = devchar;
4697 r = guestfs_blockdev_setrw (g, device);
4704 r = guestfs_umount_all (g);
4711 r = guestfs_lvm_remove_all (g);
4716 char device[] = "/dev/sda";
4717 device[5] = devchar;
4718 char lines_0[] = ",";
4725 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4730 char fstype[] = "ext2";
4731 char device[] = "/dev/sda1";
4732 device[5] = devchar;
4735 r = guestfs_mkfs (g, fstype, device);
4740 char device[] = "/dev/sda1";
4741 device[5] = devchar;
4742 char mountpoint[] = "/";
4745 r = guestfs_mount (g, device, mountpoint);
4749 /* TestOutput for checksum (7) */
4750 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4752 char path[] = "/new";
4753 char content[] = "test\n";
4756 r = guestfs_write_file (g, path, content, 0);
4761 char csumtype[] = "sha512";
4762 char path[] = "/new";
4765 r = guestfs_checksum (g, csumtype, path);
4768 if (strcmp (r, expected) != 0) {
4769 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4777 static int test_download_0 (void)
4779 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4781 char device[] = "/dev/sda";
4782 device[5] = devchar;
4785 r = guestfs_blockdev_setrw (g, device);
4792 r = guestfs_umount_all (g);
4799 r = guestfs_lvm_remove_all (g);
4804 char device[] = "/dev/sda";
4805 device[5] = devchar;
4806 char lines_0[] = ",";
4813 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4818 char fstype[] = "ext2";
4819 char device[] = "/dev/sda1";
4820 device[5] = devchar;
4823 r = guestfs_mkfs (g, fstype, device);
4828 char device[] = "/dev/sda1";
4829 device[5] = devchar;
4830 char mountpoint[] = "/";
4833 r = guestfs_mount (g, device, mountpoint);
4837 /* TestOutput for download (0) */
4838 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4840 char remotefilename[] = "/COPYING.LIB";
4843 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4848 char remotefilename[] = "/COPYING.LIB";
4851 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4856 char remotefilename[] = "/upload";
4859 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4864 char csumtype[] = "md5";
4865 char path[] = "/upload";
4868 r = guestfs_checksum (g, csumtype, path);
4871 if (strcmp (r, expected) != 0) {
4872 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4880 static int test_upload_0 (void)
4882 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
4884 char device[] = "/dev/sda";
4885 device[5] = devchar;
4888 r = guestfs_blockdev_setrw (g, device);
4895 r = guestfs_umount_all (g);
4902 r = guestfs_lvm_remove_all (g);
4907 char device[] = "/dev/sda";
4908 device[5] = devchar;
4909 char lines_0[] = ",";
4916 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4921 char fstype[] = "ext2";
4922 char device[] = "/dev/sda1";
4923 device[5] = devchar;
4926 r = guestfs_mkfs (g, fstype, device);
4931 char device[] = "/dev/sda1";
4932 device[5] = devchar;
4933 char mountpoint[] = "/";
4936 r = guestfs_mount (g, device, mountpoint);
4940 /* TestOutput for upload (0) */
4941 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4943 char remotefilename[] = "/COPYING.LIB";
4946 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4951 char csumtype[] = "md5";
4952 char path[] = "/COPYING.LIB";
4955 r = guestfs_checksum (g, csumtype, path);
4958 if (strcmp (r, expected) != 0) {
4959 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4967 static int test_blockdev_rereadpt_0 (void)
4969 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
4971 char device[] = "/dev/sda";
4972 device[5] = devchar;
4975 r = guestfs_blockdev_setrw (g, device);
4982 r = guestfs_umount_all (g);
4989 r = guestfs_lvm_remove_all (g);
4993 /* TestRun for blockdev_rereadpt (0) */
4995 char device[] = "/dev/sda";
4996 device[5] = devchar;
4999 r = guestfs_blockdev_rereadpt (g, device);
5006 static int test_blockdev_flushbufs_0 (void)
5008 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
5010 char device[] = "/dev/sda";
5011 device[5] = devchar;
5014 r = guestfs_blockdev_setrw (g, device);
5021 r = guestfs_umount_all (g);
5028 r = guestfs_lvm_remove_all (g);
5032 /* TestRun for blockdev_flushbufs (0) */
5034 char device[] = "/dev/sda";
5035 device[5] = devchar;
5038 r = guestfs_blockdev_flushbufs (g, device);
5045 static int test_blockdev_getsize64_0 (void)
5047 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
5049 char device[] = "/dev/sda";
5050 device[5] = devchar;
5053 r = guestfs_blockdev_setrw (g, device);
5060 r = guestfs_umount_all (g);
5067 r = guestfs_lvm_remove_all (g);
5071 /* TestOutputInt for blockdev_getsize64 (0) */
5073 char device[] = "/dev/sda";
5074 device[5] = devchar;
5077 r = guestfs_blockdev_getsize64 (g, device);
5080 if (r != 524288000) {
5081 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
5088 static int test_blockdev_getsz_0 (void)
5090 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
5092 char device[] = "/dev/sda";
5093 device[5] = devchar;
5096 r = guestfs_blockdev_setrw (g, device);
5103 r = guestfs_umount_all (g);
5110 r = guestfs_lvm_remove_all (g);
5114 /* TestOutputInt for blockdev_getsz (0) */
5116 char device[] = "/dev/sda";
5117 device[5] = devchar;
5120 r = guestfs_blockdev_getsz (g, device);
5124 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
5131 static int test_blockdev_getbsz_0 (void)
5133 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
5135 char device[] = "/dev/sda";
5136 device[5] = devchar;
5139 r = guestfs_blockdev_setrw (g, device);
5146 r = guestfs_umount_all (g);
5153 r = guestfs_lvm_remove_all (g);
5157 /* TestOutputInt for blockdev_getbsz (0) */
5159 char device[] = "/dev/sda";
5160 device[5] = devchar;
5163 r = guestfs_blockdev_getbsz (g, device);
5167 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
5174 static int test_blockdev_getss_0 (void)
5176 /* InitNone|InitEmpty for test_blockdev_getss_0 */
5178 char device[] = "/dev/sda";
5179 device[5] = devchar;
5182 r = guestfs_blockdev_setrw (g, device);
5189 r = guestfs_umount_all (g);
5196 r = guestfs_lvm_remove_all (g);
5200 /* TestOutputInt for blockdev_getss (0) */
5202 char device[] = "/dev/sda";
5203 device[5] = devchar;
5206 r = guestfs_blockdev_getss (g, device);
5210 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
5217 static int test_blockdev_getro_0 (void)
5219 /* InitNone|InitEmpty for test_blockdev_getro_0 */
5221 char device[] = "/dev/sda";
5222 device[5] = devchar;
5225 r = guestfs_blockdev_setrw (g, device);
5232 r = guestfs_umount_all (g);
5239 r = guestfs_lvm_remove_all (g);
5243 /* TestOutputTrue for blockdev_getro (0) */
5245 char device[] = "/dev/sda";
5246 device[5] = devchar;
5249 r = guestfs_blockdev_setro (g, device);
5254 char device[] = "/dev/sda";
5255 device[5] = devchar;
5258 r = guestfs_blockdev_getro (g, device);
5262 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
5269 static int test_blockdev_setrw_0 (void)
5271 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
5273 char device[] = "/dev/sda";
5274 device[5] = devchar;
5277 r = guestfs_blockdev_setrw (g, device);
5284 r = guestfs_umount_all (g);
5291 r = guestfs_lvm_remove_all (g);
5295 /* TestOutputFalse for blockdev_setrw (0) */
5297 char device[] = "/dev/sda";
5298 device[5] = devchar;
5301 r = guestfs_blockdev_setrw (g, device);
5306 char device[] = "/dev/sda";
5307 device[5] = devchar;
5310 r = guestfs_blockdev_getro (g, device);
5314 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
5321 static int test_blockdev_setro_0 (void)
5323 /* InitNone|InitEmpty for test_blockdev_setro_0 */
5325 char device[] = "/dev/sda";
5326 device[5] = devchar;
5329 r = guestfs_blockdev_setrw (g, device);
5336 r = guestfs_umount_all (g);
5343 r = guestfs_lvm_remove_all (g);
5347 /* TestOutputTrue for blockdev_setro (0) */
5349 char device[] = "/dev/sda";
5350 device[5] = devchar;
5353 r = guestfs_blockdev_setro (g, device);
5358 char device[] = "/dev/sda";
5359 device[5] = devchar;
5362 r = guestfs_blockdev_getro (g, device);
5366 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
5373 static int test_statvfs_0 (void)
5375 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5377 char device[] = "/dev/sda";
5378 device[5] = devchar;
5381 r = guestfs_blockdev_setrw (g, device);
5388 r = guestfs_umount_all (g);
5395 r = guestfs_lvm_remove_all (g);
5400 char device[] = "/dev/sda";
5401 device[5] = devchar;
5402 char lines_0[] = ",";
5409 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5414 char fstype[] = "ext2";
5415 char device[] = "/dev/sda1";
5416 device[5] = devchar;
5419 r = guestfs_mkfs (g, fstype, device);
5424 char device[] = "/dev/sda1";
5425 device[5] = devchar;
5426 char mountpoint[] = "/";
5429 r = guestfs_mount (g, device, mountpoint);
5433 /* TestOutputStruct for statvfs (0) */
5436 struct guestfs_statvfs *r;
5438 r = guestfs_statvfs (g, path);
5441 if (r->bfree != 487702) {
5442 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5446 if (r->blocks != 490020) {
5447 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5451 if (r->bsize != 1024) {
5452 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5461 static int test_lstat_0 (void)
5463 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5465 char device[] = "/dev/sda";
5466 device[5] = devchar;
5469 r = guestfs_blockdev_setrw (g, device);
5476 r = guestfs_umount_all (g);
5483 r = guestfs_lvm_remove_all (g);
5488 char device[] = "/dev/sda";
5489 device[5] = devchar;
5490 char lines_0[] = ",";
5497 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5502 char fstype[] = "ext2";
5503 char device[] = "/dev/sda1";
5504 device[5] = devchar;
5507 r = guestfs_mkfs (g, fstype, device);
5512 char device[] = "/dev/sda1";
5513 device[5] = devchar;
5514 char mountpoint[] = "/";
5517 r = guestfs_mount (g, device, mountpoint);
5521 /* TestOutputStruct for lstat (0) */
5523 char path[] = "/new";
5526 r = guestfs_touch (g, path);
5531 char path[] = "/new";
5532 struct guestfs_stat *r;
5534 r = guestfs_lstat (g, path);
5538 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5547 static int test_stat_0 (void)
5549 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5551 char device[] = "/dev/sda";
5552 device[5] = devchar;
5555 r = guestfs_blockdev_setrw (g, device);
5562 r = guestfs_umount_all (g);
5569 r = guestfs_lvm_remove_all (g);
5574 char device[] = "/dev/sda";
5575 device[5] = devchar;
5576 char lines_0[] = ",";
5583 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5588 char fstype[] = "ext2";
5589 char device[] = "/dev/sda1";
5590 device[5] = devchar;
5593 r = guestfs_mkfs (g, fstype, device);
5598 char device[] = "/dev/sda1";
5599 device[5] = devchar;
5600 char mountpoint[] = "/";
5603 r = guestfs_mount (g, device, mountpoint);
5607 /* TestOutputStruct for stat (0) */
5609 char path[] = "/new";
5612 r = guestfs_touch (g, path);
5617 char path[] = "/new";
5618 struct guestfs_stat *r;
5620 r = guestfs_stat (g, path);
5624 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5633 static int test_command_lines_0_prereq (void)
5635 const char *str = getenv ("SKIP_TEST_COMMAND");
5636 return str && strcmp (str, "1") == 0;
5639 static int test_command_lines_0 (void)
5641 if (! test_command_lines_0_prereq ()) {
5642 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5644 char device[] = "/dev/sda";
5645 device[5] = devchar;
5648 r = guestfs_blockdev_setrw (g, device);
5655 r = guestfs_umount_all (g);
5662 r = guestfs_lvm_remove_all (g);
5667 char device[] = "/dev/sda";
5668 device[5] = devchar;
5669 char lines_0[] = ",";
5676 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5681 char fstype[] = "ext2";
5682 char device[] = "/dev/sda1";
5683 device[5] = devchar;
5686 r = guestfs_mkfs (g, fstype, device);
5691 char device[] = "/dev/sda1";
5692 device[5] = devchar;
5693 char mountpoint[] = "/";
5696 r = guestfs_mount (g, device, mountpoint);
5700 /* TestOutputList for command_lines (0) */
5702 char remotefilename[] = "/test-command";
5705 r = guestfs_upload (g, "test-command", remotefilename);
5710 char path[] = "/test-command";
5713 r = guestfs_chmod (g, 493, path);
5718 char arguments_0[] = "/test-command";
5719 char arguments_1[] = "1";
5720 char *arguments[] = {
5728 r = guestfs_command_lines (g, arguments);
5732 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5737 char expected[] = "Result1";
5738 if (strcmp (r[0], expected) != 0) {
5739 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5744 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5748 for (i = 0; r[i] != NULL; ++i)
5753 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5757 static int test_command_lines_1_prereq (void)
5759 const char *str = getenv ("SKIP_TEST_COMMAND");
5760 return str && strcmp (str, "1") == 0;
5763 static int test_command_lines_1 (void)
5765 if (! test_command_lines_1_prereq ()) {
5766 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5768 char device[] = "/dev/sda";
5769 device[5] = devchar;
5772 r = guestfs_blockdev_setrw (g, device);
5779 r = guestfs_umount_all (g);
5786 r = guestfs_lvm_remove_all (g);
5791 char device[] = "/dev/sda";
5792 device[5] = devchar;
5793 char lines_0[] = ",";
5800 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5805 char fstype[] = "ext2";
5806 char device[] = "/dev/sda1";
5807 device[5] = devchar;
5810 r = guestfs_mkfs (g, fstype, device);
5815 char device[] = "/dev/sda1";
5816 device[5] = devchar;
5817 char mountpoint[] = "/";
5820 r = guestfs_mount (g, device, mountpoint);
5824 /* TestOutputList for command_lines (1) */
5826 char remotefilename[] = "/test-command";
5829 r = guestfs_upload (g, "test-command", remotefilename);
5834 char path[] = "/test-command";
5837 r = guestfs_chmod (g, 493, path);
5842 char arguments_0[] = "/test-command";
5843 char arguments_1[] = "2";
5844 char *arguments[] = {
5852 r = guestfs_command_lines (g, arguments);
5856 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5861 char expected[] = "Result2";
5862 if (strcmp (r[0], expected) != 0) {
5863 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5868 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5872 for (i = 0; r[i] != NULL; ++i)
5877 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5881 static int test_command_lines_2_prereq (void)
5883 const char *str = getenv ("SKIP_TEST_COMMAND");
5884 return str && strcmp (str, "1") == 0;
5887 static int test_command_lines_2 (void)
5889 if (! test_command_lines_2_prereq ()) {
5890 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
5892 char device[] = "/dev/sda";
5893 device[5] = devchar;
5896 r = guestfs_blockdev_setrw (g, device);
5903 r = guestfs_umount_all (g);
5910 r = guestfs_lvm_remove_all (g);
5915 char device[] = "/dev/sda";
5916 device[5] = devchar;
5917 char lines_0[] = ",";
5924 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5929 char fstype[] = "ext2";
5930 char device[] = "/dev/sda1";
5931 device[5] = devchar;
5934 r = guestfs_mkfs (g, fstype, device);
5939 char device[] = "/dev/sda1";
5940 device[5] = devchar;
5941 char mountpoint[] = "/";
5944 r = guestfs_mount (g, device, mountpoint);
5948 /* TestOutputList for command_lines (2) */
5950 char remotefilename[] = "/test-command";
5953 r = guestfs_upload (g, "test-command", remotefilename);
5958 char path[] = "/test-command";
5961 r = guestfs_chmod (g, 493, path);
5966 char arguments_0[] = "/test-command";
5967 char arguments_1[] = "3";
5968 char *arguments[] = {
5976 r = guestfs_command_lines (g, arguments);
5980 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5985 char expected[] = "";
5986 if (strcmp (r[0], expected) != 0) {
5987 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5992 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5997 char expected[] = "Result3";
5998 if (strcmp (r[1], expected) != 0) {
5999 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6004 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
6008 for (i = 0; r[i] != NULL; ++i)
6013 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
6017 static int test_command_lines_3_prereq (void)
6019 const char *str = getenv ("SKIP_TEST_COMMAND");
6020 return str && strcmp (str, "1") == 0;
6023 static int test_command_lines_3 (void)
6025 if (! test_command_lines_3_prereq ()) {
6026 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
6028 char device[] = "/dev/sda";
6029 device[5] = devchar;
6032 r = guestfs_blockdev_setrw (g, device);
6039 r = guestfs_umount_all (g);
6046 r = guestfs_lvm_remove_all (g);
6051 char device[] = "/dev/sda";
6052 device[5] = devchar;
6053 char lines_0[] = ",";
6060 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6065 char fstype[] = "ext2";
6066 char device[] = "/dev/sda1";
6067 device[5] = devchar;
6070 r = guestfs_mkfs (g, fstype, device);
6075 char device[] = "/dev/sda1";
6076 device[5] = devchar;
6077 char mountpoint[] = "/";
6080 r = guestfs_mount (g, device, mountpoint);
6084 /* TestOutputList for command_lines (3) */
6086 char remotefilename[] = "/test-command";
6089 r = guestfs_upload (g, "test-command", remotefilename);
6094 char path[] = "/test-command";
6097 r = guestfs_chmod (g, 493, path);
6102 char arguments_0[] = "/test-command";
6103 char arguments_1[] = "4";
6104 char *arguments[] = {
6112 r = guestfs_command_lines (g, arguments);
6116 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6121 char expected[] = "";
6122 if (strcmp (r[0], expected) != 0) {
6123 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6128 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6133 char expected[] = "Result4";
6134 if (strcmp (r[1], expected) != 0) {
6135 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6140 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
6144 for (i = 0; r[i] != NULL; ++i)
6149 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
6153 static int test_command_lines_4_prereq (void)
6155 const char *str = getenv ("SKIP_TEST_COMMAND");
6156 return str && strcmp (str, "1") == 0;
6159 static int test_command_lines_4 (void)
6161 if (! test_command_lines_4_prereq ()) {
6162 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
6164 char device[] = "/dev/sda";
6165 device[5] = devchar;
6168 r = guestfs_blockdev_setrw (g, device);
6175 r = guestfs_umount_all (g);
6182 r = guestfs_lvm_remove_all (g);
6187 char device[] = "/dev/sda";
6188 device[5] = devchar;
6189 char lines_0[] = ",";
6196 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6201 char fstype[] = "ext2";
6202 char device[] = "/dev/sda1";
6203 device[5] = devchar;
6206 r = guestfs_mkfs (g, fstype, device);
6211 char device[] = "/dev/sda1";
6212 device[5] = devchar;
6213 char mountpoint[] = "/";
6216 r = guestfs_mount (g, device, mountpoint);
6220 /* TestOutputList for command_lines (4) */
6222 char remotefilename[] = "/test-command";
6225 r = guestfs_upload (g, "test-command", remotefilename);
6230 char path[] = "/test-command";
6233 r = guestfs_chmod (g, 493, path);
6238 char arguments_0[] = "/test-command";
6239 char arguments_1[] = "5";
6240 char *arguments[] = {
6248 r = guestfs_command_lines (g, arguments);
6252 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6257 char expected[] = "";
6258 if (strcmp (r[0], expected) != 0) {
6259 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6264 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6269 char expected[] = "Result5";
6270 if (strcmp (r[1], expected) != 0) {
6271 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6276 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6281 char expected[] = "";
6282 if (strcmp (r[2], expected) != 0) {
6283 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6288 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
6292 for (i = 0; r[i] != NULL; ++i)
6297 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
6301 static int test_command_lines_5_prereq (void)
6303 const char *str = getenv ("SKIP_TEST_COMMAND");
6304 return str && strcmp (str, "1") == 0;
6307 static int test_command_lines_5 (void)
6309 if (! test_command_lines_5_prereq ()) {
6310 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
6312 char device[] = "/dev/sda";
6313 device[5] = devchar;
6316 r = guestfs_blockdev_setrw (g, device);
6323 r = guestfs_umount_all (g);
6330 r = guestfs_lvm_remove_all (g);
6335 char device[] = "/dev/sda";
6336 device[5] = devchar;
6337 char lines_0[] = ",";
6344 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6349 char fstype[] = "ext2";
6350 char device[] = "/dev/sda1";
6351 device[5] = devchar;
6354 r = guestfs_mkfs (g, fstype, device);
6359 char device[] = "/dev/sda1";
6360 device[5] = devchar;
6361 char mountpoint[] = "/";
6364 r = guestfs_mount (g, device, mountpoint);
6368 /* TestOutputList for command_lines (5) */
6370 char remotefilename[] = "/test-command";
6373 r = guestfs_upload (g, "test-command", remotefilename);
6378 char path[] = "/test-command";
6381 r = guestfs_chmod (g, 493, path);
6386 char arguments_0[] = "/test-command";
6387 char arguments_1[] = "6";
6388 char *arguments[] = {
6396 r = guestfs_command_lines (g, arguments);
6400 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6405 char expected[] = "";
6406 if (strcmp (r[0], expected) != 0) {
6407 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6412 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6417 char expected[] = "";
6418 if (strcmp (r[1], expected) != 0) {
6419 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6424 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6429 char expected[] = "Result6";
6430 if (strcmp (r[2], expected) != 0) {
6431 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6436 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6441 char expected[] = "";
6442 if (strcmp (r[3], expected) != 0) {
6443 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6448 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6452 for (i = 0; r[i] != NULL; ++i)
6457 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6461 static int test_command_lines_6_prereq (void)
6463 const char *str = getenv ("SKIP_TEST_COMMAND");
6464 return str && strcmp (str, "1") == 0;
6467 static int test_command_lines_6 (void)
6469 if (! test_command_lines_6_prereq ()) {
6470 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6472 char device[] = "/dev/sda";
6473 device[5] = devchar;
6476 r = guestfs_blockdev_setrw (g, device);
6483 r = guestfs_umount_all (g);
6490 r = guestfs_lvm_remove_all (g);
6495 char device[] = "/dev/sda";
6496 device[5] = devchar;
6497 char lines_0[] = ",";
6504 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6509 char fstype[] = "ext2";
6510 char device[] = "/dev/sda1";
6511 device[5] = devchar;
6514 r = guestfs_mkfs (g, fstype, device);
6519 char device[] = "/dev/sda1";
6520 device[5] = devchar;
6521 char mountpoint[] = "/";
6524 r = guestfs_mount (g, device, mountpoint);
6528 /* TestOutputList for command_lines (6) */
6530 char remotefilename[] = "/test-command";
6533 r = guestfs_upload (g, "test-command", remotefilename);
6538 char path[] = "/test-command";
6541 r = guestfs_chmod (g, 493, path);
6546 char arguments_0[] = "/test-command";
6547 char arguments_1[] = "7";
6548 char *arguments[] = {
6556 r = guestfs_command_lines (g, arguments);
6560 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6564 for (i = 0; r[i] != NULL; ++i)
6569 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6573 static int test_command_lines_7_prereq (void)
6575 const char *str = getenv ("SKIP_TEST_COMMAND");
6576 return str && strcmp (str, "1") == 0;
6579 static int test_command_lines_7 (void)
6581 if (! test_command_lines_7_prereq ()) {
6582 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6584 char device[] = "/dev/sda";
6585 device[5] = devchar;
6588 r = guestfs_blockdev_setrw (g, device);
6595 r = guestfs_umount_all (g);
6602 r = guestfs_lvm_remove_all (g);
6607 char device[] = "/dev/sda";
6608 device[5] = devchar;
6609 char lines_0[] = ",";
6616 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6621 char fstype[] = "ext2";
6622 char device[] = "/dev/sda1";
6623 device[5] = devchar;
6626 r = guestfs_mkfs (g, fstype, device);
6631 char device[] = "/dev/sda1";
6632 device[5] = devchar;
6633 char mountpoint[] = "/";
6636 r = guestfs_mount (g, device, mountpoint);
6640 /* TestOutputList for command_lines (7) */
6642 char remotefilename[] = "/test-command";
6645 r = guestfs_upload (g, "test-command", remotefilename);
6650 char path[] = "/test-command";
6653 r = guestfs_chmod (g, 493, path);
6658 char arguments_0[] = "/test-command";
6659 char arguments_1[] = "8";
6660 char *arguments[] = {
6668 r = guestfs_command_lines (g, arguments);
6672 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6677 char expected[] = "";
6678 if (strcmp (r[0], expected) != 0) {
6679 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6684 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6688 for (i = 0; r[i] != NULL; ++i)
6693 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6697 static int test_command_lines_8_prereq (void)
6699 const char *str = getenv ("SKIP_TEST_COMMAND");
6700 return str && strcmp (str, "1") == 0;
6703 static int test_command_lines_8 (void)
6705 if (! test_command_lines_8_prereq ()) {
6706 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6708 char device[] = "/dev/sda";
6709 device[5] = devchar;
6712 r = guestfs_blockdev_setrw (g, device);
6719 r = guestfs_umount_all (g);
6726 r = guestfs_lvm_remove_all (g);
6731 char device[] = "/dev/sda";
6732 device[5] = devchar;
6733 char lines_0[] = ",";
6740 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6745 char fstype[] = "ext2";
6746 char device[] = "/dev/sda1";
6747 device[5] = devchar;
6750 r = guestfs_mkfs (g, fstype, device);
6755 char device[] = "/dev/sda1";
6756 device[5] = devchar;
6757 char mountpoint[] = "/";
6760 r = guestfs_mount (g, device, mountpoint);
6764 /* TestOutputList for command_lines (8) */
6766 char remotefilename[] = "/test-command";
6769 r = guestfs_upload (g, "test-command", remotefilename);
6774 char path[] = "/test-command";
6777 r = guestfs_chmod (g, 493, path);
6782 char arguments_0[] = "/test-command";
6783 char arguments_1[] = "9";
6784 char *arguments[] = {
6792 r = guestfs_command_lines (g, arguments);
6796 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6801 char expected[] = "";
6802 if (strcmp (r[0], expected) != 0) {
6803 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6808 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6813 char expected[] = "";
6814 if (strcmp (r[1], expected) != 0) {
6815 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6820 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6824 for (i = 0; r[i] != NULL; ++i)
6829 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6833 static int test_command_lines_9_prereq (void)
6835 const char *str = getenv ("SKIP_TEST_COMMAND");
6836 return str && strcmp (str, "1") == 0;
6839 static int test_command_lines_9 (void)
6841 if (! test_command_lines_9_prereq ()) {
6842 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6844 char device[] = "/dev/sda";
6845 device[5] = devchar;
6848 r = guestfs_blockdev_setrw (g, device);
6855 r = guestfs_umount_all (g);
6862 r = guestfs_lvm_remove_all (g);
6867 char device[] = "/dev/sda";
6868 device[5] = devchar;
6869 char lines_0[] = ",";
6876 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6881 char fstype[] = "ext2";
6882 char device[] = "/dev/sda1";
6883 device[5] = devchar;
6886 r = guestfs_mkfs (g, fstype, device);
6891 char device[] = "/dev/sda1";
6892 device[5] = devchar;
6893 char mountpoint[] = "/";
6896 r = guestfs_mount (g, device, mountpoint);
6900 /* TestOutputList for command_lines (9) */
6902 char remotefilename[] = "/test-command";
6905 r = guestfs_upload (g, "test-command", remotefilename);
6910 char path[] = "/test-command";
6913 r = guestfs_chmod (g, 493, path);
6918 char arguments_0[] = "/test-command";
6919 char arguments_1[] = "10";
6920 char *arguments[] = {
6928 r = guestfs_command_lines (g, arguments);
6932 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6937 char expected[] = "Result10-1";
6938 if (strcmp (r[0], expected) != 0) {
6939 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6944 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6949 char expected[] = "Result10-2";
6950 if (strcmp (r[1], expected) != 0) {
6951 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6956 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6960 for (i = 0; r[i] != NULL; ++i)
6965 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6969 static int test_command_lines_10_prereq (void)
6971 const char *str = getenv ("SKIP_TEST_COMMAND");
6972 return str && strcmp (str, "1") == 0;
6975 static int test_command_lines_10 (void)
6977 if (! test_command_lines_10_prereq ()) {
6978 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
6980 char device[] = "/dev/sda";
6981 device[5] = devchar;
6984 r = guestfs_blockdev_setrw (g, device);
6991 r = guestfs_umount_all (g);
6998 r = guestfs_lvm_remove_all (g);
7003 char device[] = "/dev/sda";
7004 device[5] = devchar;
7005 char lines_0[] = ",";
7012 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7017 char fstype[] = "ext2";
7018 char device[] = "/dev/sda1";
7019 device[5] = devchar;
7022 r = guestfs_mkfs (g, fstype, device);
7027 char device[] = "/dev/sda1";
7028 device[5] = devchar;
7029 char mountpoint[] = "/";
7032 r = guestfs_mount (g, device, mountpoint);
7036 /* TestOutputList for command_lines (10) */
7038 char remotefilename[] = "/test-command";
7041 r = guestfs_upload (g, "test-command", remotefilename);
7046 char path[] = "/test-command";
7049 r = guestfs_chmod (g, 493, path);
7054 char arguments_0[] = "/test-command";
7055 char arguments_1[] = "11";
7056 char *arguments[] = {
7064 r = guestfs_command_lines (g, arguments);
7068 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7073 char expected[] = "Result11-1";
7074 if (strcmp (r[0], expected) != 0) {
7075 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7080 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7085 char expected[] = "Result11-2";
7086 if (strcmp (r[1], expected) != 0) {
7087 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7092 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
7096 for (i = 0; r[i] != NULL; ++i)
7101 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
7105 static int test_command_0_prereq (void)
7107 const char *str = getenv ("SKIP_TEST_COMMAND");
7108 return str && strcmp (str, "1") == 0;
7111 static int test_command_0 (void)
7113 if (! test_command_0_prereq ()) {
7114 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
7116 char device[] = "/dev/sda";
7117 device[5] = devchar;
7120 r = guestfs_blockdev_setrw (g, device);
7127 r = guestfs_umount_all (g);
7134 r = guestfs_lvm_remove_all (g);
7139 char device[] = "/dev/sda";
7140 device[5] = devchar;
7141 char lines_0[] = ",";
7148 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7153 char fstype[] = "ext2";
7154 char device[] = "/dev/sda1";
7155 device[5] = devchar;
7158 r = guestfs_mkfs (g, fstype, device);
7163 char device[] = "/dev/sda1";
7164 device[5] = devchar;
7165 char mountpoint[] = "/";
7168 r = guestfs_mount (g, device, mountpoint);
7172 /* TestOutput for command (0) */
7173 char expected[] = "Result1";
7175 char remotefilename[] = "/test-command";
7178 r = guestfs_upload (g, "test-command", remotefilename);
7183 char path[] = "/test-command";
7186 r = guestfs_chmod (g, 493, path);
7191 char arguments_0[] = "/test-command";
7192 char arguments_1[] = "1";
7193 char *arguments[] = {
7200 r = guestfs_command (g, arguments);
7203 if (strcmp (r, expected) != 0) {
7204 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
7210 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
7214 static int test_command_1_prereq (void)
7216 const char *str = getenv ("SKIP_TEST_COMMAND");
7217 return str && strcmp (str, "1") == 0;
7220 static int test_command_1 (void)
7222 if (! test_command_1_prereq ()) {
7223 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
7225 char device[] = "/dev/sda";
7226 device[5] = devchar;
7229 r = guestfs_blockdev_setrw (g, device);
7236 r = guestfs_umount_all (g);
7243 r = guestfs_lvm_remove_all (g);
7248 char device[] = "/dev/sda";
7249 device[5] = devchar;
7250 char lines_0[] = ",";
7257 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7262 char fstype[] = "ext2";
7263 char device[] = "/dev/sda1";
7264 device[5] = devchar;
7267 r = guestfs_mkfs (g, fstype, device);
7272 char device[] = "/dev/sda1";
7273 device[5] = devchar;
7274 char mountpoint[] = "/";
7277 r = guestfs_mount (g, device, mountpoint);
7281 /* TestOutput for command (1) */
7282 char expected[] = "Result2\n";
7284 char remotefilename[] = "/test-command";
7287 r = guestfs_upload (g, "test-command", remotefilename);
7292 char path[] = "/test-command";
7295 r = guestfs_chmod (g, 493, path);
7300 char arguments_0[] = "/test-command";
7301 char arguments_1[] = "2";
7302 char *arguments[] = {
7309 r = guestfs_command (g, arguments);
7312 if (strcmp (r, expected) != 0) {
7313 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
7319 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
7323 static int test_command_2_prereq (void)
7325 const char *str = getenv ("SKIP_TEST_COMMAND");
7326 return str && strcmp (str, "1") == 0;
7329 static int test_command_2 (void)
7331 if (! test_command_2_prereq ()) {
7332 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
7334 char device[] = "/dev/sda";
7335 device[5] = devchar;
7338 r = guestfs_blockdev_setrw (g, device);
7345 r = guestfs_umount_all (g);
7352 r = guestfs_lvm_remove_all (g);
7357 char device[] = "/dev/sda";
7358 device[5] = devchar;
7359 char lines_0[] = ",";
7366 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7371 char fstype[] = "ext2";
7372 char device[] = "/dev/sda1";
7373 device[5] = devchar;
7376 r = guestfs_mkfs (g, fstype, device);
7381 char device[] = "/dev/sda1";
7382 device[5] = devchar;
7383 char mountpoint[] = "/";
7386 r = guestfs_mount (g, device, mountpoint);
7390 /* TestOutput for command (2) */
7391 char expected[] = "\nResult3";
7393 char remotefilename[] = "/test-command";
7396 r = guestfs_upload (g, "test-command", remotefilename);
7401 char path[] = "/test-command";
7404 r = guestfs_chmod (g, 493, path);
7409 char arguments_0[] = "/test-command";
7410 char arguments_1[] = "3";
7411 char *arguments[] = {
7418 r = guestfs_command (g, arguments);
7421 if (strcmp (r, expected) != 0) {
7422 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7428 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7432 static int test_command_3_prereq (void)
7434 const char *str = getenv ("SKIP_TEST_COMMAND");
7435 return str && strcmp (str, "1") == 0;
7438 static int test_command_3 (void)
7440 if (! test_command_3_prereq ()) {
7441 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7443 char device[] = "/dev/sda";
7444 device[5] = devchar;
7447 r = guestfs_blockdev_setrw (g, device);
7454 r = guestfs_umount_all (g);
7461 r = guestfs_lvm_remove_all (g);
7466 char device[] = "/dev/sda";
7467 device[5] = devchar;
7468 char lines_0[] = ",";
7475 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7480 char fstype[] = "ext2";
7481 char device[] = "/dev/sda1";
7482 device[5] = devchar;
7485 r = guestfs_mkfs (g, fstype, device);
7490 char device[] = "/dev/sda1";
7491 device[5] = devchar;
7492 char mountpoint[] = "/";
7495 r = guestfs_mount (g, device, mountpoint);
7499 /* TestOutput for command (3) */
7500 char expected[] = "\nResult4\n";
7502 char remotefilename[] = "/test-command";
7505 r = guestfs_upload (g, "test-command", remotefilename);
7510 char path[] = "/test-command";
7513 r = guestfs_chmod (g, 493, path);
7518 char arguments_0[] = "/test-command";
7519 char arguments_1[] = "4";
7520 char *arguments[] = {
7527 r = guestfs_command (g, arguments);
7530 if (strcmp (r, expected) != 0) {
7531 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7537 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7541 static int test_command_4_prereq (void)
7543 const char *str = getenv ("SKIP_TEST_COMMAND");
7544 return str && strcmp (str, "1") == 0;
7547 static int test_command_4 (void)
7549 if (! test_command_4_prereq ()) {
7550 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7552 char device[] = "/dev/sda";
7553 device[5] = devchar;
7556 r = guestfs_blockdev_setrw (g, device);
7563 r = guestfs_umount_all (g);
7570 r = guestfs_lvm_remove_all (g);
7575 char device[] = "/dev/sda";
7576 device[5] = devchar;
7577 char lines_0[] = ",";
7584 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7589 char fstype[] = "ext2";
7590 char device[] = "/dev/sda1";
7591 device[5] = devchar;
7594 r = guestfs_mkfs (g, fstype, device);
7599 char device[] = "/dev/sda1";
7600 device[5] = devchar;
7601 char mountpoint[] = "/";
7604 r = guestfs_mount (g, device, mountpoint);
7608 /* TestOutput for command (4) */
7609 char expected[] = "\nResult5\n\n";
7611 char remotefilename[] = "/test-command";
7614 r = guestfs_upload (g, "test-command", remotefilename);
7619 char path[] = "/test-command";
7622 r = guestfs_chmod (g, 493, path);
7627 char arguments_0[] = "/test-command";
7628 char arguments_1[] = "5";
7629 char *arguments[] = {
7636 r = guestfs_command (g, arguments);
7639 if (strcmp (r, expected) != 0) {
7640 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7646 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7650 static int test_command_5_prereq (void)
7652 const char *str = getenv ("SKIP_TEST_COMMAND");
7653 return str && strcmp (str, "1") == 0;
7656 static int test_command_5 (void)
7658 if (! test_command_5_prereq ()) {
7659 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7661 char device[] = "/dev/sda";
7662 device[5] = devchar;
7665 r = guestfs_blockdev_setrw (g, device);
7672 r = guestfs_umount_all (g);
7679 r = guestfs_lvm_remove_all (g);
7684 char device[] = "/dev/sda";
7685 device[5] = devchar;
7686 char lines_0[] = ",";
7693 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7698 char fstype[] = "ext2";
7699 char device[] = "/dev/sda1";
7700 device[5] = devchar;
7703 r = guestfs_mkfs (g, fstype, device);
7708 char device[] = "/dev/sda1";
7709 device[5] = devchar;
7710 char mountpoint[] = "/";
7713 r = guestfs_mount (g, device, mountpoint);
7717 /* TestOutput for command (5) */
7718 char expected[] = "\n\nResult6\n\n";
7720 char remotefilename[] = "/test-command";
7723 r = guestfs_upload (g, "test-command", remotefilename);
7728 char path[] = "/test-command";
7731 r = guestfs_chmod (g, 493, path);
7736 char arguments_0[] = "/test-command";
7737 char arguments_1[] = "6";
7738 char *arguments[] = {
7745 r = guestfs_command (g, arguments);
7748 if (strcmp (r, expected) != 0) {
7749 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7755 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7759 static int test_command_6_prereq (void)
7761 const char *str = getenv ("SKIP_TEST_COMMAND");
7762 return str && strcmp (str, "1") == 0;
7765 static int test_command_6 (void)
7767 if (! test_command_6_prereq ()) {
7768 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7770 char device[] = "/dev/sda";
7771 device[5] = devchar;
7774 r = guestfs_blockdev_setrw (g, device);
7781 r = guestfs_umount_all (g);
7788 r = guestfs_lvm_remove_all (g);
7793 char device[] = "/dev/sda";
7794 device[5] = devchar;
7795 char lines_0[] = ",";
7802 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7807 char fstype[] = "ext2";
7808 char device[] = "/dev/sda1";
7809 device[5] = devchar;
7812 r = guestfs_mkfs (g, fstype, device);
7817 char device[] = "/dev/sda1";
7818 device[5] = devchar;
7819 char mountpoint[] = "/";
7822 r = guestfs_mount (g, device, mountpoint);
7826 /* TestOutput for command (6) */
7827 char expected[] = "";
7829 char remotefilename[] = "/test-command";
7832 r = guestfs_upload (g, "test-command", remotefilename);
7837 char path[] = "/test-command";
7840 r = guestfs_chmod (g, 493, path);
7845 char arguments_0[] = "/test-command";
7846 char arguments_1[] = "7";
7847 char *arguments[] = {
7854 r = guestfs_command (g, arguments);
7857 if (strcmp (r, expected) != 0) {
7858 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7864 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7868 static int test_command_7_prereq (void)
7870 const char *str = getenv ("SKIP_TEST_COMMAND");
7871 return str && strcmp (str, "1") == 0;
7874 static int test_command_7 (void)
7876 if (! test_command_7_prereq ()) {
7877 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7879 char device[] = "/dev/sda";
7880 device[5] = devchar;
7883 r = guestfs_blockdev_setrw (g, device);
7890 r = guestfs_umount_all (g);
7897 r = guestfs_lvm_remove_all (g);
7902 char device[] = "/dev/sda";
7903 device[5] = devchar;
7904 char lines_0[] = ",";
7911 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7916 char fstype[] = "ext2";
7917 char device[] = "/dev/sda1";
7918 device[5] = devchar;
7921 r = guestfs_mkfs (g, fstype, device);
7926 char device[] = "/dev/sda1";
7927 device[5] = devchar;
7928 char mountpoint[] = "/";
7931 r = guestfs_mount (g, device, mountpoint);
7935 /* TestOutput for command (7) */
7936 char expected[] = "\n";
7938 char remotefilename[] = "/test-command";
7941 r = guestfs_upload (g, "test-command", remotefilename);
7946 char path[] = "/test-command";
7949 r = guestfs_chmod (g, 493, path);
7954 char arguments_0[] = "/test-command";
7955 char arguments_1[] = "8";
7956 char *arguments[] = {
7963 r = guestfs_command (g, arguments);
7966 if (strcmp (r, expected) != 0) {
7967 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7973 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7977 static int test_command_8_prereq (void)
7979 const char *str = getenv ("SKIP_TEST_COMMAND");
7980 return str && strcmp (str, "1") == 0;
7983 static int test_command_8 (void)
7985 if (! test_command_8_prereq ()) {
7986 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
7988 char device[] = "/dev/sda";
7989 device[5] = devchar;
7992 r = guestfs_blockdev_setrw (g, device);
7999 r = guestfs_umount_all (g);
8006 r = guestfs_lvm_remove_all (g);
8011 char device[] = "/dev/sda";
8012 device[5] = devchar;
8013 char lines_0[] = ",";
8020 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8025 char fstype[] = "ext2";
8026 char device[] = "/dev/sda1";
8027 device[5] = devchar;
8030 r = guestfs_mkfs (g, fstype, device);
8035 char device[] = "/dev/sda1";
8036 device[5] = devchar;
8037 char mountpoint[] = "/";
8040 r = guestfs_mount (g, device, mountpoint);
8044 /* TestOutput for command (8) */
8045 char expected[] = "\n\n";
8047 char remotefilename[] = "/test-command";
8050 r = guestfs_upload (g, "test-command", remotefilename);
8055 char path[] = "/test-command";
8058 r = guestfs_chmod (g, 493, path);
8063 char arguments_0[] = "/test-command";
8064 char arguments_1[] = "9";
8065 char *arguments[] = {
8072 r = guestfs_command (g, arguments);
8075 if (strcmp (r, expected) != 0) {
8076 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
8082 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
8086 static int test_command_9_prereq (void)
8088 const char *str = getenv ("SKIP_TEST_COMMAND");
8089 return str && strcmp (str, "1") == 0;
8092 static int test_command_9 (void)
8094 if (! test_command_9_prereq ()) {
8095 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
8097 char device[] = "/dev/sda";
8098 device[5] = devchar;
8101 r = guestfs_blockdev_setrw (g, device);
8108 r = guestfs_umount_all (g);
8115 r = guestfs_lvm_remove_all (g);
8120 char device[] = "/dev/sda";
8121 device[5] = devchar;
8122 char lines_0[] = ",";
8129 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8134 char fstype[] = "ext2";
8135 char device[] = "/dev/sda1";
8136 device[5] = devchar;
8139 r = guestfs_mkfs (g, fstype, device);
8144 char device[] = "/dev/sda1";
8145 device[5] = devchar;
8146 char mountpoint[] = "/";
8149 r = guestfs_mount (g, device, mountpoint);
8153 /* TestOutput for command (9) */
8154 char expected[] = "Result10-1\nResult10-2\n";
8156 char remotefilename[] = "/test-command";
8159 r = guestfs_upload (g, "test-command", remotefilename);
8164 char path[] = "/test-command";
8167 r = guestfs_chmod (g, 493, path);
8172 char arguments_0[] = "/test-command";
8173 char arguments_1[] = "10";
8174 char *arguments[] = {
8181 r = guestfs_command (g, arguments);
8184 if (strcmp (r, expected) != 0) {
8185 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
8191 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
8195 static int test_command_10_prereq (void)
8197 const char *str = getenv ("SKIP_TEST_COMMAND");
8198 return str && strcmp (str, "1") == 0;
8201 static int test_command_10 (void)
8203 if (! test_command_10_prereq ()) {
8204 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
8206 char device[] = "/dev/sda";
8207 device[5] = devchar;
8210 r = guestfs_blockdev_setrw (g, device);
8217 r = guestfs_umount_all (g);
8224 r = guestfs_lvm_remove_all (g);
8229 char device[] = "/dev/sda";
8230 device[5] = devchar;
8231 char lines_0[] = ",";
8238 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8243 char fstype[] = "ext2";
8244 char device[] = "/dev/sda1";
8245 device[5] = devchar;
8248 r = guestfs_mkfs (g, fstype, device);
8253 char device[] = "/dev/sda1";
8254 device[5] = devchar;
8255 char mountpoint[] = "/";
8258 r = guestfs_mount (g, device, mountpoint);
8262 /* TestOutput for command (10) */
8263 char expected[] = "Result11-1\nResult11-2";
8265 char remotefilename[] = "/test-command";
8268 r = guestfs_upload (g, "test-command", remotefilename);
8273 char path[] = "/test-command";
8276 r = guestfs_chmod (g, 493, path);
8281 char arguments_0[] = "/test-command";
8282 char arguments_1[] = "11";
8283 char *arguments[] = {
8290 r = guestfs_command (g, arguments);
8293 if (strcmp (r, expected) != 0) {
8294 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
8300 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
8304 static int test_command_11_prereq (void)
8306 const char *str = getenv ("SKIP_TEST_COMMAND");
8307 return str && strcmp (str, "1") == 0;
8310 static int test_command_11 (void)
8312 if (! test_command_11_prereq ()) {
8313 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
8315 char device[] = "/dev/sda";
8316 device[5] = devchar;
8319 r = guestfs_blockdev_setrw (g, device);
8326 r = guestfs_umount_all (g);
8333 r = guestfs_lvm_remove_all (g);
8338 char device[] = "/dev/sda";
8339 device[5] = devchar;
8340 char lines_0[] = ",";
8347 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8352 char fstype[] = "ext2";
8353 char device[] = "/dev/sda1";
8354 device[5] = devchar;
8357 r = guestfs_mkfs (g, fstype, device);
8362 char device[] = "/dev/sda1";
8363 device[5] = devchar;
8364 char mountpoint[] = "/";
8367 r = guestfs_mount (g, device, mountpoint);
8371 /* TestLastFail for command (11) */
8373 char remotefilename[] = "/test-command";
8376 r = guestfs_upload (g, "test-command", remotefilename);
8381 char path[] = "/test-command";
8384 r = guestfs_chmod (g, 493, path);
8389 char arguments_0[] = "/test-command";
8390 char *arguments[] = {
8396 r = guestfs_command (g, arguments);
8402 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8406 static int test_file_0 (void)
8408 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8410 char device[] = "/dev/sda";
8411 device[5] = devchar;
8414 r = guestfs_blockdev_setrw (g, device);
8421 r = guestfs_umount_all (g);
8428 r = guestfs_lvm_remove_all (g);
8433 char device[] = "/dev/sda";
8434 device[5] = devchar;
8435 char lines_0[] = ",";
8442 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8447 char fstype[] = "ext2";
8448 char device[] = "/dev/sda1";
8449 device[5] = devchar;
8452 r = guestfs_mkfs (g, fstype, device);
8457 char device[] = "/dev/sda1";
8458 device[5] = devchar;
8459 char mountpoint[] = "/";
8462 r = guestfs_mount (g, device, mountpoint);
8466 /* TestOutput for file (0) */
8467 char expected[] = "empty";
8469 char path[] = "/new";
8472 r = guestfs_touch (g, path);
8477 char path[] = "/new";
8480 r = guestfs_file (g, path);
8483 if (strcmp (r, expected) != 0) {
8484 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8492 static int test_file_1 (void)
8494 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8496 char device[] = "/dev/sda";
8497 device[5] = devchar;
8500 r = guestfs_blockdev_setrw (g, device);
8507 r = guestfs_umount_all (g);
8514 r = guestfs_lvm_remove_all (g);
8519 char device[] = "/dev/sda";
8520 device[5] = devchar;
8521 char lines_0[] = ",";
8528 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8533 char fstype[] = "ext2";
8534 char device[] = "/dev/sda1";
8535 device[5] = devchar;
8538 r = guestfs_mkfs (g, fstype, device);
8543 char device[] = "/dev/sda1";
8544 device[5] = devchar;
8545 char mountpoint[] = "/";
8548 r = guestfs_mount (g, device, mountpoint);
8552 /* TestOutput for file (1) */
8553 char expected[] = "ASCII text";
8555 char path[] = "/new";
8556 char content[] = "some content\n";
8559 r = guestfs_write_file (g, path, content, 0);
8564 char path[] = "/new";
8567 r = guestfs_file (g, path);
8570 if (strcmp (r, expected) != 0) {
8571 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8579 static int test_file_2 (void)
8581 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8583 char device[] = "/dev/sda";
8584 device[5] = devchar;
8587 r = guestfs_blockdev_setrw (g, device);
8594 r = guestfs_umount_all (g);
8601 r = guestfs_lvm_remove_all (g);
8606 char device[] = "/dev/sda";
8607 device[5] = devchar;
8608 char lines_0[] = ",";
8615 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8620 char fstype[] = "ext2";
8621 char device[] = "/dev/sda1";
8622 device[5] = devchar;
8625 r = guestfs_mkfs (g, fstype, device);
8630 char device[] = "/dev/sda1";
8631 device[5] = devchar;
8632 char mountpoint[] = "/";
8635 r = guestfs_mount (g, device, mountpoint);
8639 /* TestLastFail for file (2) */
8641 char path[] = "/nofile";
8644 r = guestfs_file (g, path);
8652 static int test_umount_all_0 (void)
8654 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8656 char device[] = "/dev/sda";
8657 device[5] = devchar;
8660 r = guestfs_blockdev_setrw (g, device);
8667 r = guestfs_umount_all (g);
8674 r = guestfs_lvm_remove_all (g);
8679 char device[] = "/dev/sda";
8680 device[5] = devchar;
8681 char lines_0[] = ",";
8688 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8693 char fstype[] = "ext2";
8694 char device[] = "/dev/sda1";
8695 device[5] = devchar;
8698 r = guestfs_mkfs (g, fstype, device);
8703 char device[] = "/dev/sda1";
8704 device[5] = devchar;
8705 char mountpoint[] = "/";
8708 r = guestfs_mount (g, device, mountpoint);
8712 /* TestOutputList for umount_all (0) */
8716 r = guestfs_umount_all (g);
8724 r = guestfs_mounts (g);
8728 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8732 for (i = 0; r[i] != NULL; ++i)
8739 static int test_umount_all_1 (void)
8741 /* InitNone|InitEmpty for test_umount_all_1 */
8743 char device[] = "/dev/sda";
8744 device[5] = devchar;
8747 r = guestfs_blockdev_setrw (g, device);
8754 r = guestfs_umount_all (g);
8761 r = guestfs_lvm_remove_all (g);
8765 /* TestOutputList for umount_all (1) */
8767 char device[] = "/dev/sda";
8768 device[5] = devchar;
8769 char lines_0[] = ",10";
8770 char lines_1[] = ",20";
8771 char lines_2[] = ",";
8780 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8785 char fstype[] = "ext2";
8786 char device[] = "/dev/sda1";
8787 device[5] = devchar;
8790 r = guestfs_mkfs (g, fstype, device);
8795 char fstype[] = "ext2";
8796 char device[] = "/dev/sda2";
8797 device[5] = devchar;
8800 r = guestfs_mkfs (g, fstype, device);
8805 char fstype[] = "ext2";
8806 char device[] = "/dev/sda3";
8807 device[5] = devchar;
8810 r = guestfs_mkfs (g, fstype, device);
8815 char device[] = "/dev/sda1";
8816 device[5] = devchar;
8817 char mountpoint[] = "/";
8820 r = guestfs_mount (g, device, mountpoint);
8825 char path[] = "/mp1";
8828 r = guestfs_mkdir (g, path);
8833 char device[] = "/dev/sda2";
8834 device[5] = devchar;
8835 char mountpoint[] = "/mp1";
8838 r = guestfs_mount (g, device, mountpoint);
8843 char path[] = "/mp1/mp2";
8846 r = guestfs_mkdir (g, path);
8851 char device[] = "/dev/sda3";
8852 device[5] = devchar;
8853 char mountpoint[] = "/mp1/mp2";
8856 r = guestfs_mount (g, device, mountpoint);
8861 char path[] = "/mp1/mp2/mp3";
8864 r = guestfs_mkdir (g, path);
8871 r = guestfs_umount_all (g);
8879 r = guestfs_mounts (g);
8883 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8887 for (i = 0; r[i] != NULL; ++i)
8894 static int test_mounts_0 (void)
8896 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
8898 char device[] = "/dev/sda";
8899 device[5] = devchar;
8902 r = guestfs_blockdev_setrw (g, device);
8909 r = guestfs_umount_all (g);
8916 r = guestfs_lvm_remove_all (g);
8921 char device[] = "/dev/sda";
8922 device[5] = devchar;
8923 char lines_0[] = ",";
8930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8935 char fstype[] = "ext2";
8936 char device[] = "/dev/sda1";
8937 device[5] = devchar;
8940 r = guestfs_mkfs (g, fstype, device);
8945 char device[] = "/dev/sda1";
8946 device[5] = devchar;
8947 char mountpoint[] = "/";
8950 r = guestfs_mount (g, device, mountpoint);
8954 /* TestOutputList for mounts (0) */
8959 r = guestfs_mounts (g);
8963 fprintf (stderr, "test_mounts_0: short list returned from command\n");
8968 char expected[] = "/dev/sda1";
8969 expected[5] = devchar;
8970 if (strcmp (r[0], expected) != 0) {
8971 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8976 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8980 for (i = 0; r[i] != NULL; ++i)
8987 static int test_umount_0 (void)
8989 /* InitNone|InitEmpty for test_umount_0 */
8991 char device[] = "/dev/sda";
8992 device[5] = devchar;
8995 r = guestfs_blockdev_setrw (g, device);
9002 r = guestfs_umount_all (g);
9009 r = guestfs_lvm_remove_all (g);
9013 /* TestOutputList for umount (0) */
9015 char device[] = "/dev/sda";
9016 device[5] = devchar;
9017 char lines_0[] = ",";
9024 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9029 char fstype[] = "ext2";
9030 char device[] = "/dev/sda1";
9031 device[5] = devchar;
9034 r = guestfs_mkfs (g, fstype, device);
9039 char device[] = "/dev/sda1";
9040 device[5] = devchar;
9041 char mountpoint[] = "/";
9044 r = guestfs_mount (g, device, mountpoint);
9052 r = guestfs_mounts (g);
9056 fprintf (stderr, "test_umount_0: short list returned from command\n");
9061 char expected[] = "/dev/sda1";
9062 expected[5] = devchar;
9063 if (strcmp (r[0], expected) != 0) {
9064 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9069 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
9073 for (i = 0; r[i] != NULL; ++i)
9080 static int test_umount_1 (void)
9082 /* InitNone|InitEmpty for test_umount_1 */
9084 char device[] = "/dev/sda";
9085 device[5] = devchar;
9088 r = guestfs_blockdev_setrw (g, device);
9095 r = guestfs_umount_all (g);
9102 r = guestfs_lvm_remove_all (g);
9106 /* TestOutputList for umount (1) */
9108 char device[] = "/dev/sda";
9109 device[5] = devchar;
9110 char lines_0[] = ",";
9117 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9122 char fstype[] = "ext2";
9123 char device[] = "/dev/sda1";
9124 device[5] = devchar;
9127 r = guestfs_mkfs (g, fstype, device);
9132 char device[] = "/dev/sda1";
9133 device[5] = devchar;
9134 char mountpoint[] = "/";
9137 r = guestfs_mount (g, device, mountpoint);
9142 char pathordevice[] = "/";
9145 r = guestfs_umount (g, pathordevice);
9153 r = guestfs_mounts (g);
9157 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
9161 for (i = 0; r[i] != NULL; ++i)
9168 static int test_write_file_0 (void)
9170 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
9172 char device[] = "/dev/sda";
9173 device[5] = devchar;
9176 r = guestfs_blockdev_setrw (g, device);
9183 r = guestfs_umount_all (g);
9190 r = guestfs_lvm_remove_all (g);
9195 char device[] = "/dev/sda";
9196 device[5] = devchar;
9197 char lines_0[] = ",";
9204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9209 char fstype[] = "ext2";
9210 char device[] = "/dev/sda1";
9211 device[5] = devchar;
9214 r = guestfs_mkfs (g, fstype, device);
9219 char device[] = "/dev/sda1";
9220 device[5] = devchar;
9221 char mountpoint[] = "/";
9224 r = guestfs_mount (g, device, mountpoint);
9228 /* TestOutput for write_file (0) */
9229 char expected[] = "new file contents";
9231 char path[] = "/new";
9232 char content[] = "new file contents";
9235 r = guestfs_write_file (g, path, content, 0);
9240 char path[] = "/new";
9243 r = guestfs_cat (g, path);
9246 if (strcmp (r, expected) != 0) {
9247 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9255 static int test_write_file_1 (void)
9257 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
9259 char device[] = "/dev/sda";
9260 device[5] = devchar;
9263 r = guestfs_blockdev_setrw (g, device);
9270 r = guestfs_umount_all (g);
9277 r = guestfs_lvm_remove_all (g);
9282 char device[] = "/dev/sda";
9283 device[5] = devchar;
9284 char lines_0[] = ",";
9291 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9296 char fstype[] = "ext2";
9297 char device[] = "/dev/sda1";
9298 device[5] = devchar;
9301 r = guestfs_mkfs (g, fstype, device);
9306 char device[] = "/dev/sda1";
9307 device[5] = devchar;
9308 char mountpoint[] = "/";
9311 r = guestfs_mount (g, device, mountpoint);
9315 /* TestOutput for write_file (1) */
9316 char expected[] = "\nnew file contents\n";
9318 char path[] = "/new";
9319 char content[] = "\nnew file contents\n";
9322 r = guestfs_write_file (g, path, content, 0);
9327 char path[] = "/new";
9330 r = guestfs_cat (g, path);
9333 if (strcmp (r, expected) != 0) {
9334 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9342 static int test_write_file_2 (void)
9344 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
9346 char device[] = "/dev/sda";
9347 device[5] = devchar;
9350 r = guestfs_blockdev_setrw (g, device);
9357 r = guestfs_umount_all (g);
9364 r = guestfs_lvm_remove_all (g);
9369 char device[] = "/dev/sda";
9370 device[5] = devchar;
9371 char lines_0[] = ",";
9378 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9383 char fstype[] = "ext2";
9384 char device[] = "/dev/sda1";
9385 device[5] = devchar;
9388 r = guestfs_mkfs (g, fstype, device);
9393 char device[] = "/dev/sda1";
9394 device[5] = devchar;
9395 char mountpoint[] = "/";
9398 r = guestfs_mount (g, device, mountpoint);
9402 /* TestOutput for write_file (2) */
9403 char expected[] = "\n\n";
9405 char path[] = "/new";
9406 char content[] = "\n\n";
9409 r = guestfs_write_file (g, path, content, 0);
9414 char path[] = "/new";
9417 r = guestfs_cat (g, path);
9420 if (strcmp (r, expected) != 0) {
9421 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9429 static int test_write_file_3 (void)
9431 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9433 char device[] = "/dev/sda";
9434 device[5] = devchar;
9437 r = guestfs_blockdev_setrw (g, device);
9444 r = guestfs_umount_all (g);
9451 r = guestfs_lvm_remove_all (g);
9456 char device[] = "/dev/sda";
9457 device[5] = devchar;
9458 char lines_0[] = ",";
9465 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9470 char fstype[] = "ext2";
9471 char device[] = "/dev/sda1";
9472 device[5] = devchar;
9475 r = guestfs_mkfs (g, fstype, device);
9480 char device[] = "/dev/sda1";
9481 device[5] = devchar;
9482 char mountpoint[] = "/";
9485 r = guestfs_mount (g, device, mountpoint);
9489 /* TestOutput for write_file (3) */
9490 char expected[] = "";
9492 char path[] = "/new";
9493 char content[] = "";
9496 r = guestfs_write_file (g, path, content, 0);
9501 char path[] = "/new";
9504 r = guestfs_cat (g, path);
9507 if (strcmp (r, expected) != 0) {
9508 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9516 static int test_write_file_4 (void)
9518 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9520 char device[] = "/dev/sda";
9521 device[5] = devchar;
9524 r = guestfs_blockdev_setrw (g, device);
9531 r = guestfs_umount_all (g);
9538 r = guestfs_lvm_remove_all (g);
9543 char device[] = "/dev/sda";
9544 device[5] = devchar;
9545 char lines_0[] = ",";
9552 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9557 char fstype[] = "ext2";
9558 char device[] = "/dev/sda1";
9559 device[5] = devchar;
9562 r = guestfs_mkfs (g, fstype, device);
9567 char device[] = "/dev/sda1";
9568 device[5] = devchar;
9569 char mountpoint[] = "/";
9572 r = guestfs_mount (g, device, mountpoint);
9576 /* TestOutput for write_file (4) */
9577 char expected[] = "\n\n\n";
9579 char path[] = "/new";
9580 char content[] = "\n\n\n";
9583 r = guestfs_write_file (g, path, content, 0);
9588 char path[] = "/new";
9591 r = guestfs_cat (g, path);
9594 if (strcmp (r, expected) != 0) {
9595 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9603 static int test_write_file_5 (void)
9605 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9607 char device[] = "/dev/sda";
9608 device[5] = devchar;
9611 r = guestfs_blockdev_setrw (g, device);
9618 r = guestfs_umount_all (g);
9625 r = guestfs_lvm_remove_all (g);
9630 char device[] = "/dev/sda";
9631 device[5] = devchar;
9632 char lines_0[] = ",";
9639 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9644 char fstype[] = "ext2";
9645 char device[] = "/dev/sda1";
9646 device[5] = devchar;
9649 r = guestfs_mkfs (g, fstype, device);
9654 char device[] = "/dev/sda1";
9655 device[5] = devchar;
9656 char mountpoint[] = "/";
9659 r = guestfs_mount (g, device, mountpoint);
9663 /* TestOutput for write_file (5) */
9664 char expected[] = "\n";
9666 char path[] = "/new";
9667 char content[] = "\n";
9670 r = guestfs_write_file (g, path, content, 0);
9675 char path[] = "/new";
9678 r = guestfs_cat (g, path);
9681 if (strcmp (r, expected) != 0) {
9682 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9690 static int test_mkfs_0 (void)
9692 /* InitNone|InitEmpty for test_mkfs_0 */
9694 char device[] = "/dev/sda";
9695 device[5] = devchar;
9698 r = guestfs_blockdev_setrw (g, device);
9705 r = guestfs_umount_all (g);
9712 r = guestfs_lvm_remove_all (g);
9716 /* TestOutput for mkfs (0) */
9717 char expected[] = "new file contents";
9719 char device[] = "/dev/sda";
9720 device[5] = devchar;
9721 char lines_0[] = ",";
9728 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9733 char fstype[] = "ext2";
9734 char device[] = "/dev/sda1";
9735 device[5] = devchar;
9738 r = guestfs_mkfs (g, fstype, device);
9743 char device[] = "/dev/sda1";
9744 device[5] = devchar;
9745 char mountpoint[] = "/";
9748 r = guestfs_mount (g, device, mountpoint);
9753 char path[] = "/new";
9754 char content[] = "new file contents";
9757 r = guestfs_write_file (g, path, content, 0);
9762 char path[] = "/new";
9765 r = guestfs_cat (g, path);
9768 if (strcmp (r, expected) != 0) {
9769 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9777 static int test_lvcreate_0 (void)
9779 /* InitNone|InitEmpty for test_lvcreate_0 */
9781 char device[] = "/dev/sda";
9782 device[5] = devchar;
9785 r = guestfs_blockdev_setrw (g, device);
9792 r = guestfs_umount_all (g);
9799 r = guestfs_lvm_remove_all (g);
9803 /* TestOutputList for lvcreate (0) */
9805 char device[] = "/dev/sda";
9806 device[5] = devchar;
9807 char lines_0[] = ",10";
9808 char lines_1[] = ",20";
9809 char lines_2[] = ",";
9818 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9823 char device[] = "/dev/sda1";
9824 device[5] = devchar;
9827 r = guestfs_pvcreate (g, device);
9832 char device[] = "/dev/sda2";
9833 device[5] = devchar;
9836 r = guestfs_pvcreate (g, device);
9841 char device[] = "/dev/sda3";
9842 device[5] = devchar;
9845 r = guestfs_pvcreate (g, device);
9850 char volgroup[] = "VG1";
9851 char physvols_0[] = "/dev/sda1";
9852 physvols_0[5] = devchar;
9853 char physvols_1[] = "/dev/sda2";
9854 physvols_1[5] = devchar;
9855 char *physvols[] = {
9862 r = guestfs_vgcreate (g, volgroup, physvols);
9867 char volgroup[] = "VG2";
9868 char physvols_0[] = "/dev/sda3";
9869 physvols_0[5] = devchar;
9870 char *physvols[] = {
9876 r = guestfs_vgcreate (g, volgroup, physvols);
9881 char logvol[] = "LV1";
9882 char volgroup[] = "VG1";
9885 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9890 char logvol[] = "LV2";
9891 char volgroup[] = "VG1";
9894 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9899 char logvol[] = "LV3";
9900 char volgroup[] = "VG2";
9903 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9908 char logvol[] = "LV4";
9909 char volgroup[] = "VG2";
9912 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9917 char logvol[] = "LV5";
9918 char volgroup[] = "VG2";
9921 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9929 r = guestfs_lvs (g);
9933 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9938 char expected[] = "/dev/VG1/LV1";
9939 if (strcmp (r[0], expected) != 0) {
9940 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9945 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9950 char expected[] = "/dev/VG1/LV2";
9951 if (strcmp (r[1], expected) != 0) {
9952 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9957 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9962 char expected[] = "/dev/VG2/LV3";
9963 if (strcmp (r[2], expected) != 0) {
9964 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9969 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9974 char expected[] = "/dev/VG2/LV4";
9975 if (strcmp (r[3], expected) != 0) {
9976 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9981 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9986 char expected[] = "/dev/VG2/LV5";
9987 if (strcmp (r[4], expected) != 0) {
9988 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9993 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9997 for (i = 0; r[i] != NULL; ++i)
10004 static int test_vgcreate_0 (void)
10006 /* InitNone|InitEmpty for test_vgcreate_0 */
10008 char device[] = "/dev/sda";
10009 device[5] = devchar;
10011 suppress_error = 0;
10012 r = guestfs_blockdev_setrw (g, device);
10018 suppress_error = 0;
10019 r = guestfs_umount_all (g);
10025 suppress_error = 0;
10026 r = guestfs_lvm_remove_all (g);
10030 /* TestOutputList for vgcreate (0) */
10032 char device[] = "/dev/sda";
10033 device[5] = devchar;
10034 char lines_0[] = ",10";
10035 char lines_1[] = ",20";
10036 char lines_2[] = ",";
10044 suppress_error = 0;
10045 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10050 char device[] = "/dev/sda1";
10051 device[5] = devchar;
10053 suppress_error = 0;
10054 r = guestfs_pvcreate (g, device);
10059 char device[] = "/dev/sda2";
10060 device[5] = devchar;
10062 suppress_error = 0;
10063 r = guestfs_pvcreate (g, device);
10068 char device[] = "/dev/sda3";
10069 device[5] = devchar;
10071 suppress_error = 0;
10072 r = guestfs_pvcreate (g, device);
10077 char volgroup[] = "VG1";
10078 char physvols_0[] = "/dev/sda1";
10079 physvols_0[5] = devchar;
10080 char physvols_1[] = "/dev/sda2";
10081 physvols_1[5] = devchar;
10082 char *physvols[] = {
10088 suppress_error = 0;
10089 r = guestfs_vgcreate (g, volgroup, physvols);
10094 char volgroup[] = "VG2";
10095 char physvols_0[] = "/dev/sda3";
10096 physvols_0[5] = devchar;
10097 char *physvols[] = {
10102 suppress_error = 0;
10103 r = guestfs_vgcreate (g, volgroup, physvols);
10110 suppress_error = 0;
10111 r = guestfs_vgs (g);
10115 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10120 char expected[] = "VG1";
10121 if (strcmp (r[0], expected) != 0) {
10122 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10127 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10132 char expected[] = "VG2";
10133 if (strcmp (r[1], expected) != 0) {
10134 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10138 if (r[2] != NULL) {
10139 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
10143 for (i = 0; r[i] != NULL; ++i)
10150 static int test_pvcreate_0 (void)
10152 /* InitNone|InitEmpty for test_pvcreate_0 */
10154 char device[] = "/dev/sda";
10155 device[5] = devchar;
10157 suppress_error = 0;
10158 r = guestfs_blockdev_setrw (g, device);
10164 suppress_error = 0;
10165 r = guestfs_umount_all (g);
10171 suppress_error = 0;
10172 r = guestfs_lvm_remove_all (g);
10176 /* TestOutputList for pvcreate (0) */
10178 char device[] = "/dev/sda";
10179 device[5] = devchar;
10180 char lines_0[] = ",10";
10181 char lines_1[] = ",20";
10182 char lines_2[] = ",";
10190 suppress_error = 0;
10191 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10196 char device[] = "/dev/sda1";
10197 device[5] = devchar;
10199 suppress_error = 0;
10200 r = guestfs_pvcreate (g, device);
10205 char device[] = "/dev/sda2";
10206 device[5] = devchar;
10208 suppress_error = 0;
10209 r = guestfs_pvcreate (g, device);
10214 char device[] = "/dev/sda3";
10215 device[5] = devchar;
10217 suppress_error = 0;
10218 r = guestfs_pvcreate (g, device);
10225 suppress_error = 0;
10226 r = guestfs_pvs (g);
10230 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10235 char expected[] = "/dev/sda1";
10236 expected[5] = devchar;
10237 if (strcmp (r[0], expected) != 0) {
10238 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10243 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10248 char expected[] = "/dev/sda2";
10249 expected[5] = devchar;
10250 if (strcmp (r[1], expected) != 0) {
10251 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10256 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10261 char expected[] = "/dev/sda3";
10262 expected[5] = devchar;
10263 if (strcmp (r[2], expected) != 0) {
10264 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10268 if (r[3] != NULL) {
10269 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
10273 for (i = 0; r[i] != NULL; ++i)
10280 static int test_is_dir_0 (void)
10282 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
10284 char device[] = "/dev/sda";
10285 device[5] = devchar;
10287 suppress_error = 0;
10288 r = guestfs_blockdev_setrw (g, device);
10294 suppress_error = 0;
10295 r = guestfs_umount_all (g);
10301 suppress_error = 0;
10302 r = guestfs_lvm_remove_all (g);
10307 char device[] = "/dev/sda";
10308 device[5] = devchar;
10309 char lines_0[] = ",";
10315 suppress_error = 0;
10316 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10321 char fstype[] = "ext2";
10322 char device[] = "/dev/sda1";
10323 device[5] = devchar;
10325 suppress_error = 0;
10326 r = guestfs_mkfs (g, fstype, device);
10331 char device[] = "/dev/sda1";
10332 device[5] = devchar;
10333 char mountpoint[] = "/";
10335 suppress_error = 0;
10336 r = guestfs_mount (g, device, mountpoint);
10340 /* TestOutputFalse for is_dir (0) */
10342 char path[] = "/new";
10344 suppress_error = 0;
10345 r = guestfs_touch (g, path);
10350 char path[] = "/new";
10352 suppress_error = 0;
10353 r = guestfs_is_dir (g, path);
10357 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
10364 static int test_is_dir_1 (void)
10366 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
10368 char device[] = "/dev/sda";
10369 device[5] = devchar;
10371 suppress_error = 0;
10372 r = guestfs_blockdev_setrw (g, device);
10378 suppress_error = 0;
10379 r = guestfs_umount_all (g);
10385 suppress_error = 0;
10386 r = guestfs_lvm_remove_all (g);
10391 char device[] = "/dev/sda";
10392 device[5] = devchar;
10393 char lines_0[] = ",";
10399 suppress_error = 0;
10400 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10405 char fstype[] = "ext2";
10406 char device[] = "/dev/sda1";
10407 device[5] = devchar;
10409 suppress_error = 0;
10410 r = guestfs_mkfs (g, fstype, device);
10415 char device[] = "/dev/sda1";
10416 device[5] = devchar;
10417 char mountpoint[] = "/";
10419 suppress_error = 0;
10420 r = guestfs_mount (g, device, mountpoint);
10424 /* TestOutputTrue for is_dir (1) */
10426 char path[] = "/new";
10428 suppress_error = 0;
10429 r = guestfs_mkdir (g, path);
10434 char path[] = "/new";
10436 suppress_error = 0;
10437 r = guestfs_is_dir (g, path);
10441 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10448 static int test_is_file_0 (void)
10450 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10452 char device[] = "/dev/sda";
10453 device[5] = devchar;
10455 suppress_error = 0;
10456 r = guestfs_blockdev_setrw (g, device);
10462 suppress_error = 0;
10463 r = guestfs_umount_all (g);
10469 suppress_error = 0;
10470 r = guestfs_lvm_remove_all (g);
10475 char device[] = "/dev/sda";
10476 device[5] = devchar;
10477 char lines_0[] = ",";
10483 suppress_error = 0;
10484 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10489 char fstype[] = "ext2";
10490 char device[] = "/dev/sda1";
10491 device[5] = devchar;
10493 suppress_error = 0;
10494 r = guestfs_mkfs (g, fstype, device);
10499 char device[] = "/dev/sda1";
10500 device[5] = devchar;
10501 char mountpoint[] = "/";
10503 suppress_error = 0;
10504 r = guestfs_mount (g, device, mountpoint);
10508 /* TestOutputTrue for is_file (0) */
10510 char path[] = "/new";
10512 suppress_error = 0;
10513 r = guestfs_touch (g, path);
10518 char path[] = "/new";
10520 suppress_error = 0;
10521 r = guestfs_is_file (g, path);
10525 fprintf (stderr, "test_is_file_0: expected true, got false\n");
10532 static int test_is_file_1 (void)
10534 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10536 char device[] = "/dev/sda";
10537 device[5] = devchar;
10539 suppress_error = 0;
10540 r = guestfs_blockdev_setrw (g, device);
10546 suppress_error = 0;
10547 r = guestfs_umount_all (g);
10553 suppress_error = 0;
10554 r = guestfs_lvm_remove_all (g);
10559 char device[] = "/dev/sda";
10560 device[5] = devchar;
10561 char lines_0[] = ",";
10567 suppress_error = 0;
10568 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10573 char fstype[] = "ext2";
10574 char device[] = "/dev/sda1";
10575 device[5] = devchar;
10577 suppress_error = 0;
10578 r = guestfs_mkfs (g, fstype, device);
10583 char device[] = "/dev/sda1";
10584 device[5] = devchar;
10585 char mountpoint[] = "/";
10587 suppress_error = 0;
10588 r = guestfs_mount (g, device, mountpoint);
10592 /* TestOutputFalse for is_file (1) */
10594 char path[] = "/new";
10596 suppress_error = 0;
10597 r = guestfs_mkdir (g, path);
10602 char path[] = "/new";
10604 suppress_error = 0;
10605 r = guestfs_is_file (g, path);
10609 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10616 static int test_exists_0 (void)
10618 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10620 char device[] = "/dev/sda";
10621 device[5] = devchar;
10623 suppress_error = 0;
10624 r = guestfs_blockdev_setrw (g, device);
10630 suppress_error = 0;
10631 r = guestfs_umount_all (g);
10637 suppress_error = 0;
10638 r = guestfs_lvm_remove_all (g);
10643 char device[] = "/dev/sda";
10644 device[5] = devchar;
10645 char lines_0[] = ",";
10651 suppress_error = 0;
10652 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10657 char fstype[] = "ext2";
10658 char device[] = "/dev/sda1";
10659 device[5] = devchar;
10661 suppress_error = 0;
10662 r = guestfs_mkfs (g, fstype, device);
10667 char device[] = "/dev/sda1";
10668 device[5] = devchar;
10669 char mountpoint[] = "/";
10671 suppress_error = 0;
10672 r = guestfs_mount (g, device, mountpoint);
10676 /* TestOutputTrue for exists (0) */
10678 char path[] = "/new";
10680 suppress_error = 0;
10681 r = guestfs_touch (g, path);
10686 char path[] = "/new";
10688 suppress_error = 0;
10689 r = guestfs_exists (g, path);
10693 fprintf (stderr, "test_exists_0: expected true, got false\n");
10700 static int test_exists_1 (void)
10702 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10704 char device[] = "/dev/sda";
10705 device[5] = devchar;
10707 suppress_error = 0;
10708 r = guestfs_blockdev_setrw (g, device);
10714 suppress_error = 0;
10715 r = guestfs_umount_all (g);
10721 suppress_error = 0;
10722 r = guestfs_lvm_remove_all (g);
10727 char device[] = "/dev/sda";
10728 device[5] = devchar;
10729 char lines_0[] = ",";
10735 suppress_error = 0;
10736 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10741 char fstype[] = "ext2";
10742 char device[] = "/dev/sda1";
10743 device[5] = devchar;
10745 suppress_error = 0;
10746 r = guestfs_mkfs (g, fstype, device);
10751 char device[] = "/dev/sda1";
10752 device[5] = devchar;
10753 char mountpoint[] = "/";
10755 suppress_error = 0;
10756 r = guestfs_mount (g, device, mountpoint);
10760 /* TestOutputTrue for exists (1) */
10762 char path[] = "/new";
10764 suppress_error = 0;
10765 r = guestfs_mkdir (g, path);
10770 char path[] = "/new";
10772 suppress_error = 0;
10773 r = guestfs_exists (g, path);
10777 fprintf (stderr, "test_exists_1: expected true, got false\n");
10784 static int test_mkdir_p_0 (void)
10786 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10788 char device[] = "/dev/sda";
10789 device[5] = devchar;
10791 suppress_error = 0;
10792 r = guestfs_blockdev_setrw (g, device);
10798 suppress_error = 0;
10799 r = guestfs_umount_all (g);
10805 suppress_error = 0;
10806 r = guestfs_lvm_remove_all (g);
10811 char device[] = "/dev/sda";
10812 device[5] = devchar;
10813 char lines_0[] = ",";
10819 suppress_error = 0;
10820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10825 char fstype[] = "ext2";
10826 char device[] = "/dev/sda1";
10827 device[5] = devchar;
10829 suppress_error = 0;
10830 r = guestfs_mkfs (g, fstype, device);
10835 char device[] = "/dev/sda1";
10836 device[5] = devchar;
10837 char mountpoint[] = "/";
10839 suppress_error = 0;
10840 r = guestfs_mount (g, device, mountpoint);
10844 /* TestOutputTrue for mkdir_p (0) */
10846 char path[] = "/new/foo/bar";
10848 suppress_error = 0;
10849 r = guestfs_mkdir_p (g, path);
10854 char path[] = "/new/foo/bar";
10856 suppress_error = 0;
10857 r = guestfs_is_dir (g, path);
10861 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10868 static int test_mkdir_p_1 (void)
10870 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10872 char device[] = "/dev/sda";
10873 device[5] = devchar;
10875 suppress_error = 0;
10876 r = guestfs_blockdev_setrw (g, device);
10882 suppress_error = 0;
10883 r = guestfs_umount_all (g);
10889 suppress_error = 0;
10890 r = guestfs_lvm_remove_all (g);
10895 char device[] = "/dev/sda";
10896 device[5] = devchar;
10897 char lines_0[] = ",";
10903 suppress_error = 0;
10904 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10909 char fstype[] = "ext2";
10910 char device[] = "/dev/sda1";
10911 device[5] = devchar;
10913 suppress_error = 0;
10914 r = guestfs_mkfs (g, fstype, device);
10919 char device[] = "/dev/sda1";
10920 device[5] = devchar;
10921 char mountpoint[] = "/";
10923 suppress_error = 0;
10924 r = guestfs_mount (g, device, mountpoint);
10928 /* TestOutputTrue for mkdir_p (1) */
10930 char path[] = "/new/foo/bar";
10932 suppress_error = 0;
10933 r = guestfs_mkdir_p (g, path);
10938 char path[] = "/new/foo";
10940 suppress_error = 0;
10941 r = guestfs_is_dir (g, path);
10945 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10952 static int test_mkdir_p_2 (void)
10954 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
10956 char device[] = "/dev/sda";
10957 device[5] = devchar;
10959 suppress_error = 0;
10960 r = guestfs_blockdev_setrw (g, device);
10966 suppress_error = 0;
10967 r = guestfs_umount_all (g);
10973 suppress_error = 0;
10974 r = guestfs_lvm_remove_all (g);
10979 char device[] = "/dev/sda";
10980 device[5] = devchar;
10981 char lines_0[] = ",";
10987 suppress_error = 0;
10988 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10993 char fstype[] = "ext2";
10994 char device[] = "/dev/sda1";
10995 device[5] = devchar;
10997 suppress_error = 0;
10998 r = guestfs_mkfs (g, fstype, device);
11003 char device[] = "/dev/sda1";
11004 device[5] = devchar;
11005 char mountpoint[] = "/";
11007 suppress_error = 0;
11008 r = guestfs_mount (g, device, mountpoint);
11012 /* TestOutputTrue for mkdir_p (2) */
11014 char path[] = "/new/foo/bar";
11016 suppress_error = 0;
11017 r = guestfs_mkdir_p (g, path);
11022 char path[] = "/new";
11024 suppress_error = 0;
11025 r = guestfs_is_dir (g, path);
11029 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
11036 static int test_mkdir_0 (void)
11038 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
11040 char device[] = "/dev/sda";
11041 device[5] = devchar;
11043 suppress_error = 0;
11044 r = guestfs_blockdev_setrw (g, device);
11050 suppress_error = 0;
11051 r = guestfs_umount_all (g);
11057 suppress_error = 0;
11058 r = guestfs_lvm_remove_all (g);
11063 char device[] = "/dev/sda";
11064 device[5] = devchar;
11065 char lines_0[] = ",";
11071 suppress_error = 0;
11072 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11077 char fstype[] = "ext2";
11078 char device[] = "/dev/sda1";
11079 device[5] = devchar;
11081 suppress_error = 0;
11082 r = guestfs_mkfs (g, fstype, device);
11087 char device[] = "/dev/sda1";
11088 device[5] = devchar;
11089 char mountpoint[] = "/";
11091 suppress_error = 0;
11092 r = guestfs_mount (g, device, mountpoint);
11096 /* TestOutputTrue for mkdir (0) */
11098 char path[] = "/new";
11100 suppress_error = 0;
11101 r = guestfs_mkdir (g, path);
11106 char path[] = "/new";
11108 suppress_error = 0;
11109 r = guestfs_is_dir (g, path);
11113 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
11120 static int test_mkdir_1 (void)
11122 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
11124 char device[] = "/dev/sda";
11125 device[5] = devchar;
11127 suppress_error = 0;
11128 r = guestfs_blockdev_setrw (g, device);
11134 suppress_error = 0;
11135 r = guestfs_umount_all (g);
11141 suppress_error = 0;
11142 r = guestfs_lvm_remove_all (g);
11147 char device[] = "/dev/sda";
11148 device[5] = devchar;
11149 char lines_0[] = ",";
11155 suppress_error = 0;
11156 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11161 char fstype[] = "ext2";
11162 char device[] = "/dev/sda1";
11163 device[5] = devchar;
11165 suppress_error = 0;
11166 r = guestfs_mkfs (g, fstype, device);
11171 char device[] = "/dev/sda1";
11172 device[5] = devchar;
11173 char mountpoint[] = "/";
11175 suppress_error = 0;
11176 r = guestfs_mount (g, device, mountpoint);
11180 /* TestLastFail for mkdir (1) */
11182 char path[] = "/new/foo/bar";
11184 suppress_error = 1;
11185 r = guestfs_mkdir (g, path);
11192 static int test_rm_rf_0 (void)
11194 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
11196 char device[] = "/dev/sda";
11197 device[5] = devchar;
11199 suppress_error = 0;
11200 r = guestfs_blockdev_setrw (g, device);
11206 suppress_error = 0;
11207 r = guestfs_umount_all (g);
11213 suppress_error = 0;
11214 r = guestfs_lvm_remove_all (g);
11219 char device[] = "/dev/sda";
11220 device[5] = devchar;
11221 char lines_0[] = ",";
11227 suppress_error = 0;
11228 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11233 char fstype[] = "ext2";
11234 char device[] = "/dev/sda1";
11235 device[5] = devchar;
11237 suppress_error = 0;
11238 r = guestfs_mkfs (g, fstype, device);
11243 char device[] = "/dev/sda1";
11244 device[5] = devchar;
11245 char mountpoint[] = "/";
11247 suppress_error = 0;
11248 r = guestfs_mount (g, device, mountpoint);
11252 /* TestOutputFalse for rm_rf (0) */
11254 char path[] = "/new";
11256 suppress_error = 0;
11257 r = guestfs_mkdir (g, path);
11262 char path[] = "/new/foo";
11264 suppress_error = 0;
11265 r = guestfs_mkdir (g, path);
11270 char path[] = "/new/foo/bar";
11272 suppress_error = 0;
11273 r = guestfs_touch (g, path);
11278 char path[] = "/new";
11280 suppress_error = 0;
11281 r = guestfs_rm_rf (g, path);
11286 char path[] = "/new";
11288 suppress_error = 0;
11289 r = guestfs_exists (g, path);
11293 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
11300 static int test_rmdir_0 (void)
11302 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
11304 char device[] = "/dev/sda";
11305 device[5] = devchar;
11307 suppress_error = 0;
11308 r = guestfs_blockdev_setrw (g, device);
11314 suppress_error = 0;
11315 r = guestfs_umount_all (g);
11321 suppress_error = 0;
11322 r = guestfs_lvm_remove_all (g);
11327 char device[] = "/dev/sda";
11328 device[5] = devchar;
11329 char lines_0[] = ",";
11335 suppress_error = 0;
11336 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11341 char fstype[] = "ext2";
11342 char device[] = "/dev/sda1";
11343 device[5] = devchar;
11345 suppress_error = 0;
11346 r = guestfs_mkfs (g, fstype, device);
11351 char device[] = "/dev/sda1";
11352 device[5] = devchar;
11353 char mountpoint[] = "/";
11355 suppress_error = 0;
11356 r = guestfs_mount (g, device, mountpoint);
11360 /* TestRun for rmdir (0) */
11362 char path[] = "/new";
11364 suppress_error = 0;
11365 r = guestfs_mkdir (g, path);
11370 char path[] = "/new";
11372 suppress_error = 0;
11373 r = guestfs_rmdir (g, path);
11380 static int test_rmdir_1 (void)
11382 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11384 char device[] = "/dev/sda";
11385 device[5] = devchar;
11387 suppress_error = 0;
11388 r = guestfs_blockdev_setrw (g, device);
11394 suppress_error = 0;
11395 r = guestfs_umount_all (g);
11401 suppress_error = 0;
11402 r = guestfs_lvm_remove_all (g);
11407 char device[] = "/dev/sda";
11408 device[5] = devchar;
11409 char lines_0[] = ",";
11415 suppress_error = 0;
11416 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11421 char fstype[] = "ext2";
11422 char device[] = "/dev/sda1";
11423 device[5] = devchar;
11425 suppress_error = 0;
11426 r = guestfs_mkfs (g, fstype, device);
11431 char device[] = "/dev/sda1";
11432 device[5] = devchar;
11433 char mountpoint[] = "/";
11435 suppress_error = 0;
11436 r = guestfs_mount (g, device, mountpoint);
11440 /* TestLastFail for rmdir (1) */
11442 char path[] = "/new";
11444 suppress_error = 1;
11445 r = guestfs_rmdir (g, path);
11452 static int test_rmdir_2 (void)
11454 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11456 char device[] = "/dev/sda";
11457 device[5] = devchar;
11459 suppress_error = 0;
11460 r = guestfs_blockdev_setrw (g, device);
11466 suppress_error = 0;
11467 r = guestfs_umount_all (g);
11473 suppress_error = 0;
11474 r = guestfs_lvm_remove_all (g);
11479 char device[] = "/dev/sda";
11480 device[5] = devchar;
11481 char lines_0[] = ",";
11487 suppress_error = 0;
11488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11493 char fstype[] = "ext2";
11494 char device[] = "/dev/sda1";
11495 device[5] = devchar;
11497 suppress_error = 0;
11498 r = guestfs_mkfs (g, fstype, device);
11503 char device[] = "/dev/sda1";
11504 device[5] = devchar;
11505 char mountpoint[] = "/";
11507 suppress_error = 0;
11508 r = guestfs_mount (g, device, mountpoint);
11512 /* TestLastFail for rmdir (2) */
11514 char path[] = "/new";
11516 suppress_error = 0;
11517 r = guestfs_touch (g, path);
11522 char path[] = "/new";
11524 suppress_error = 1;
11525 r = guestfs_rmdir (g, path);
11532 static int test_rm_0 (void)
11534 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11536 char device[] = "/dev/sda";
11537 device[5] = devchar;
11539 suppress_error = 0;
11540 r = guestfs_blockdev_setrw (g, device);
11546 suppress_error = 0;
11547 r = guestfs_umount_all (g);
11553 suppress_error = 0;
11554 r = guestfs_lvm_remove_all (g);
11559 char device[] = "/dev/sda";
11560 device[5] = devchar;
11561 char lines_0[] = ",";
11567 suppress_error = 0;
11568 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11573 char fstype[] = "ext2";
11574 char device[] = "/dev/sda1";
11575 device[5] = devchar;
11577 suppress_error = 0;
11578 r = guestfs_mkfs (g, fstype, device);
11583 char device[] = "/dev/sda1";
11584 device[5] = devchar;
11585 char mountpoint[] = "/";
11587 suppress_error = 0;
11588 r = guestfs_mount (g, device, mountpoint);
11592 /* TestRun for rm (0) */
11594 char path[] = "/new";
11596 suppress_error = 0;
11597 r = guestfs_touch (g, path);
11602 char path[] = "/new";
11604 suppress_error = 0;
11605 r = guestfs_rm (g, path);
11612 static int test_rm_1 (void)
11614 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11616 char device[] = "/dev/sda";
11617 device[5] = devchar;
11619 suppress_error = 0;
11620 r = guestfs_blockdev_setrw (g, device);
11626 suppress_error = 0;
11627 r = guestfs_umount_all (g);
11633 suppress_error = 0;
11634 r = guestfs_lvm_remove_all (g);
11639 char device[] = "/dev/sda";
11640 device[5] = devchar;
11641 char lines_0[] = ",";
11647 suppress_error = 0;
11648 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11653 char fstype[] = "ext2";
11654 char device[] = "/dev/sda1";
11655 device[5] = devchar;
11657 suppress_error = 0;
11658 r = guestfs_mkfs (g, fstype, device);
11663 char device[] = "/dev/sda1";
11664 device[5] = devchar;
11665 char mountpoint[] = "/";
11667 suppress_error = 0;
11668 r = guestfs_mount (g, device, mountpoint);
11672 /* TestLastFail for rm (1) */
11674 char path[] = "/new";
11676 suppress_error = 1;
11677 r = guestfs_rm (g, path);
11684 static int test_rm_2 (void)
11686 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11688 char device[] = "/dev/sda";
11689 device[5] = devchar;
11691 suppress_error = 0;
11692 r = guestfs_blockdev_setrw (g, device);
11698 suppress_error = 0;
11699 r = guestfs_umount_all (g);
11705 suppress_error = 0;
11706 r = guestfs_lvm_remove_all (g);
11711 char device[] = "/dev/sda";
11712 device[5] = devchar;
11713 char lines_0[] = ",";
11719 suppress_error = 0;
11720 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11725 char fstype[] = "ext2";
11726 char device[] = "/dev/sda1";
11727 device[5] = devchar;
11729 suppress_error = 0;
11730 r = guestfs_mkfs (g, fstype, device);
11735 char device[] = "/dev/sda1";
11736 device[5] = devchar;
11737 char mountpoint[] = "/";
11739 suppress_error = 0;
11740 r = guestfs_mount (g, device, mountpoint);
11744 /* TestLastFail for rm (2) */
11746 char path[] = "/new";
11748 suppress_error = 0;
11749 r = guestfs_mkdir (g, path);
11754 char path[] = "/new";
11756 suppress_error = 1;
11757 r = guestfs_rm (g, path);
11764 static int test_read_lines_0 (void)
11766 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11768 char device[] = "/dev/sda";
11769 device[5] = devchar;
11771 suppress_error = 0;
11772 r = guestfs_blockdev_setrw (g, device);
11778 suppress_error = 0;
11779 r = guestfs_umount_all (g);
11785 suppress_error = 0;
11786 r = guestfs_lvm_remove_all (g);
11791 char device[] = "/dev/sda";
11792 device[5] = devchar;
11793 char lines_0[] = ",";
11799 suppress_error = 0;
11800 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11805 char fstype[] = "ext2";
11806 char device[] = "/dev/sda1";
11807 device[5] = devchar;
11809 suppress_error = 0;
11810 r = guestfs_mkfs (g, fstype, device);
11815 char device[] = "/dev/sda1";
11816 device[5] = devchar;
11817 char mountpoint[] = "/";
11819 suppress_error = 0;
11820 r = guestfs_mount (g, device, mountpoint);
11824 /* TestOutputList for read_lines (0) */
11826 char path[] = "/new";
11827 char content[] = "line1\r\nline2\nline3";
11829 suppress_error = 0;
11830 r = guestfs_write_file (g, path, content, 0);
11835 char path[] = "/new";
11838 suppress_error = 0;
11839 r = guestfs_read_lines (g, path);
11843 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11848 char expected[] = "line1";
11849 if (strcmp (r[0], expected) != 0) {
11850 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11855 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11860 char expected[] = "line2";
11861 if (strcmp (r[1], expected) != 0) {
11862 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11867 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11872 char expected[] = "line3";
11873 if (strcmp (r[2], expected) != 0) {
11874 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11878 if (r[3] != NULL) {
11879 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11883 for (i = 0; r[i] != NULL; ++i)
11890 static int test_read_lines_1 (void)
11892 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
11894 char device[] = "/dev/sda";
11895 device[5] = devchar;
11897 suppress_error = 0;
11898 r = guestfs_blockdev_setrw (g, device);
11904 suppress_error = 0;
11905 r = guestfs_umount_all (g);
11911 suppress_error = 0;
11912 r = guestfs_lvm_remove_all (g);
11917 char device[] = "/dev/sda";
11918 device[5] = devchar;
11919 char lines_0[] = ",";
11925 suppress_error = 0;
11926 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11931 char fstype[] = "ext2";
11932 char device[] = "/dev/sda1";
11933 device[5] = devchar;
11935 suppress_error = 0;
11936 r = guestfs_mkfs (g, fstype, device);
11941 char device[] = "/dev/sda1";
11942 device[5] = devchar;
11943 char mountpoint[] = "/";
11945 suppress_error = 0;
11946 r = guestfs_mount (g, device, mountpoint);
11950 /* TestOutputList for read_lines (1) */
11952 char path[] = "/new";
11953 char content[] = "";
11955 suppress_error = 0;
11956 r = guestfs_write_file (g, path, content, 0);
11961 char path[] = "/new";
11964 suppress_error = 0;
11965 r = guestfs_read_lines (g, path);
11968 if (r[0] != NULL) {
11969 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11973 for (i = 0; r[i] != NULL; ++i)
11980 static int test_lvs_0 (void)
11982 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
11984 char device[] = "/dev/sda";
11985 device[5] = devchar;
11987 suppress_error = 0;
11988 r = guestfs_blockdev_setrw (g, device);
11994 suppress_error = 0;
11995 r = guestfs_umount_all (g);
12001 suppress_error = 0;
12002 r = guestfs_lvm_remove_all (g);
12007 char device[] = "/dev/sda";
12008 device[5] = devchar;
12009 char lines_0[] = ",";
12015 suppress_error = 0;
12016 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12021 char device[] = "/dev/sda1";
12022 device[5] = devchar;
12024 suppress_error = 0;
12025 r = guestfs_pvcreate (g, device);
12030 char volgroup[] = "VG";
12031 char physvols_0[] = "/dev/sda1";
12032 physvols_0[5] = devchar;
12033 char *physvols[] = {
12038 suppress_error = 0;
12039 r = guestfs_vgcreate (g, volgroup, physvols);
12044 char logvol[] = "LV";
12045 char volgroup[] = "VG";
12047 suppress_error = 0;
12048 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12053 char fstype[] = "ext2";
12054 char device[] = "/dev/VG/LV";
12056 suppress_error = 0;
12057 r = guestfs_mkfs (g, fstype, device);
12062 char device[] = "/dev/VG/LV";
12063 char mountpoint[] = "/";
12065 suppress_error = 0;
12066 r = guestfs_mount (g, device, mountpoint);
12070 /* TestOutputList for lvs (0) */
12074 suppress_error = 0;
12075 r = guestfs_lvs (g);
12079 fprintf (stderr, "test_lvs_0: short list returned from command\n");
12084 char expected[] = "/dev/VG/LV";
12085 if (strcmp (r[0], expected) != 0) {
12086 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12090 if (r[1] != NULL) {
12091 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
12095 for (i = 0; r[i] != NULL; ++i)
12102 static int test_lvs_1 (void)
12104 /* InitNone|InitEmpty for test_lvs_1 */
12106 char device[] = "/dev/sda";
12107 device[5] = devchar;
12109 suppress_error = 0;
12110 r = guestfs_blockdev_setrw (g, device);
12116 suppress_error = 0;
12117 r = guestfs_umount_all (g);
12123 suppress_error = 0;
12124 r = guestfs_lvm_remove_all (g);
12128 /* TestOutputList for lvs (1) */
12130 char device[] = "/dev/sda";
12131 device[5] = devchar;
12132 char lines_0[] = ",10";
12133 char lines_1[] = ",20";
12134 char lines_2[] = ",";
12142 suppress_error = 0;
12143 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12148 char device[] = "/dev/sda1";
12149 device[5] = devchar;
12151 suppress_error = 0;
12152 r = guestfs_pvcreate (g, device);
12157 char device[] = "/dev/sda2";
12158 device[5] = devchar;
12160 suppress_error = 0;
12161 r = guestfs_pvcreate (g, device);
12166 char device[] = "/dev/sda3";
12167 device[5] = devchar;
12169 suppress_error = 0;
12170 r = guestfs_pvcreate (g, device);
12175 char volgroup[] = "VG1";
12176 char physvols_0[] = "/dev/sda1";
12177 physvols_0[5] = devchar;
12178 char physvols_1[] = "/dev/sda2";
12179 physvols_1[5] = devchar;
12180 char *physvols[] = {
12186 suppress_error = 0;
12187 r = guestfs_vgcreate (g, volgroup, physvols);
12192 char volgroup[] = "VG2";
12193 char physvols_0[] = "/dev/sda3";
12194 physvols_0[5] = devchar;
12195 char *physvols[] = {
12200 suppress_error = 0;
12201 r = guestfs_vgcreate (g, volgroup, physvols);
12206 char logvol[] = "LV1";
12207 char volgroup[] = "VG1";
12209 suppress_error = 0;
12210 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12215 char logvol[] = "LV2";
12216 char volgroup[] = "VG1";
12218 suppress_error = 0;
12219 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12224 char logvol[] = "LV3";
12225 char volgroup[] = "VG2";
12227 suppress_error = 0;
12228 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12235 suppress_error = 0;
12236 r = guestfs_lvs (g);
12240 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12245 char expected[] = "/dev/VG1/LV1";
12246 if (strcmp (r[0], expected) != 0) {
12247 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12252 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12257 char expected[] = "/dev/VG1/LV2";
12258 if (strcmp (r[1], expected) != 0) {
12259 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12264 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12269 char expected[] = "/dev/VG2/LV3";
12270 if (strcmp (r[2], expected) != 0) {
12271 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12275 if (r[3] != NULL) {
12276 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
12280 for (i = 0; r[i] != NULL; ++i)
12287 static int test_vgs_0 (void)
12289 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
12291 char device[] = "/dev/sda";
12292 device[5] = devchar;
12294 suppress_error = 0;
12295 r = guestfs_blockdev_setrw (g, device);
12301 suppress_error = 0;
12302 r = guestfs_umount_all (g);
12308 suppress_error = 0;
12309 r = guestfs_lvm_remove_all (g);
12314 char device[] = "/dev/sda";
12315 device[5] = devchar;
12316 char lines_0[] = ",";
12322 suppress_error = 0;
12323 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12328 char device[] = "/dev/sda1";
12329 device[5] = devchar;
12331 suppress_error = 0;
12332 r = guestfs_pvcreate (g, device);
12337 char volgroup[] = "VG";
12338 char physvols_0[] = "/dev/sda1";
12339 physvols_0[5] = devchar;
12340 char *physvols[] = {
12345 suppress_error = 0;
12346 r = guestfs_vgcreate (g, volgroup, physvols);
12351 char logvol[] = "LV";
12352 char volgroup[] = "VG";
12354 suppress_error = 0;
12355 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12360 char fstype[] = "ext2";
12361 char device[] = "/dev/VG/LV";
12363 suppress_error = 0;
12364 r = guestfs_mkfs (g, fstype, device);
12369 char device[] = "/dev/VG/LV";
12370 char mountpoint[] = "/";
12372 suppress_error = 0;
12373 r = guestfs_mount (g, device, mountpoint);
12377 /* TestOutputList for vgs (0) */
12381 suppress_error = 0;
12382 r = guestfs_vgs (g);
12386 fprintf (stderr, "test_vgs_0: short list returned from command\n");
12391 char expected[] = "VG";
12392 if (strcmp (r[0], expected) != 0) {
12393 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12397 if (r[1] != NULL) {
12398 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12402 for (i = 0; r[i] != NULL; ++i)
12409 static int test_vgs_1 (void)
12411 /* InitNone|InitEmpty for test_vgs_1 */
12413 char device[] = "/dev/sda";
12414 device[5] = devchar;
12416 suppress_error = 0;
12417 r = guestfs_blockdev_setrw (g, device);
12423 suppress_error = 0;
12424 r = guestfs_umount_all (g);
12430 suppress_error = 0;
12431 r = guestfs_lvm_remove_all (g);
12435 /* TestOutputList for vgs (1) */
12437 char device[] = "/dev/sda";
12438 device[5] = devchar;
12439 char lines_0[] = ",10";
12440 char lines_1[] = ",20";
12441 char lines_2[] = ",";
12449 suppress_error = 0;
12450 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12455 char device[] = "/dev/sda1";
12456 device[5] = devchar;
12458 suppress_error = 0;
12459 r = guestfs_pvcreate (g, device);
12464 char device[] = "/dev/sda2";
12465 device[5] = devchar;
12467 suppress_error = 0;
12468 r = guestfs_pvcreate (g, device);
12473 char device[] = "/dev/sda3";
12474 device[5] = devchar;
12476 suppress_error = 0;
12477 r = guestfs_pvcreate (g, device);
12482 char volgroup[] = "VG1";
12483 char physvols_0[] = "/dev/sda1";
12484 physvols_0[5] = devchar;
12485 char physvols_1[] = "/dev/sda2";
12486 physvols_1[5] = devchar;
12487 char *physvols[] = {
12493 suppress_error = 0;
12494 r = guestfs_vgcreate (g, volgroup, physvols);
12499 char volgroup[] = "VG2";
12500 char physvols_0[] = "/dev/sda3";
12501 physvols_0[5] = devchar;
12502 char *physvols[] = {
12507 suppress_error = 0;
12508 r = guestfs_vgcreate (g, volgroup, physvols);
12515 suppress_error = 0;
12516 r = guestfs_vgs (g);
12520 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12525 char expected[] = "VG1";
12526 if (strcmp (r[0], expected) != 0) {
12527 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12532 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12537 char expected[] = "VG2";
12538 if (strcmp (r[1], expected) != 0) {
12539 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12543 if (r[2] != NULL) {
12544 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12548 for (i = 0; r[i] != NULL; ++i)
12555 static int test_pvs_0 (void)
12557 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12559 char device[] = "/dev/sda";
12560 device[5] = devchar;
12562 suppress_error = 0;
12563 r = guestfs_blockdev_setrw (g, device);
12569 suppress_error = 0;
12570 r = guestfs_umount_all (g);
12576 suppress_error = 0;
12577 r = guestfs_lvm_remove_all (g);
12582 char device[] = "/dev/sda";
12583 device[5] = devchar;
12584 char lines_0[] = ",";
12590 suppress_error = 0;
12591 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12596 char device[] = "/dev/sda1";
12597 device[5] = devchar;
12599 suppress_error = 0;
12600 r = guestfs_pvcreate (g, device);
12605 char volgroup[] = "VG";
12606 char physvols_0[] = "/dev/sda1";
12607 physvols_0[5] = devchar;
12608 char *physvols[] = {
12613 suppress_error = 0;
12614 r = guestfs_vgcreate (g, volgroup, physvols);
12619 char logvol[] = "LV";
12620 char volgroup[] = "VG";
12622 suppress_error = 0;
12623 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12628 char fstype[] = "ext2";
12629 char device[] = "/dev/VG/LV";
12631 suppress_error = 0;
12632 r = guestfs_mkfs (g, fstype, device);
12637 char device[] = "/dev/VG/LV";
12638 char mountpoint[] = "/";
12640 suppress_error = 0;
12641 r = guestfs_mount (g, device, mountpoint);
12645 /* TestOutputList for pvs (0) */
12649 suppress_error = 0;
12650 r = guestfs_pvs (g);
12654 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12659 char expected[] = "/dev/sda1";
12660 expected[5] = devchar;
12661 if (strcmp (r[0], expected) != 0) {
12662 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12666 if (r[1] != NULL) {
12667 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12671 for (i = 0; r[i] != NULL; ++i)
12678 static int test_pvs_1 (void)
12680 /* InitNone|InitEmpty for test_pvs_1 */
12682 char device[] = "/dev/sda";
12683 device[5] = devchar;
12685 suppress_error = 0;
12686 r = guestfs_blockdev_setrw (g, device);
12692 suppress_error = 0;
12693 r = guestfs_umount_all (g);
12699 suppress_error = 0;
12700 r = guestfs_lvm_remove_all (g);
12704 /* TestOutputList for pvs (1) */
12706 char device[] = "/dev/sda";
12707 device[5] = devchar;
12708 char lines_0[] = ",10";
12709 char lines_1[] = ",20";
12710 char lines_2[] = ",";
12718 suppress_error = 0;
12719 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12724 char device[] = "/dev/sda1";
12725 device[5] = devchar;
12727 suppress_error = 0;
12728 r = guestfs_pvcreate (g, device);
12733 char device[] = "/dev/sda2";
12734 device[5] = devchar;
12736 suppress_error = 0;
12737 r = guestfs_pvcreate (g, device);
12742 char device[] = "/dev/sda3";
12743 device[5] = devchar;
12745 suppress_error = 0;
12746 r = guestfs_pvcreate (g, device);
12753 suppress_error = 0;
12754 r = guestfs_pvs (g);
12758 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12763 char expected[] = "/dev/sda1";
12764 expected[5] = devchar;
12765 if (strcmp (r[0], expected) != 0) {
12766 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12771 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12776 char expected[] = "/dev/sda2";
12777 expected[5] = devchar;
12778 if (strcmp (r[1], expected) != 0) {
12779 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12784 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12789 char expected[] = "/dev/sda3";
12790 expected[5] = devchar;
12791 if (strcmp (r[2], expected) != 0) {
12792 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12796 if (r[3] != NULL) {
12797 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12801 for (i = 0; r[i] != NULL; ++i)
12808 static int test_list_partitions_0 (void)
12810 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12812 char device[] = "/dev/sda";
12813 device[5] = devchar;
12815 suppress_error = 0;
12816 r = guestfs_blockdev_setrw (g, device);
12822 suppress_error = 0;
12823 r = guestfs_umount_all (g);
12829 suppress_error = 0;
12830 r = guestfs_lvm_remove_all (g);
12835 char device[] = "/dev/sda";
12836 device[5] = devchar;
12837 char lines_0[] = ",";
12843 suppress_error = 0;
12844 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12849 char fstype[] = "ext2";
12850 char device[] = "/dev/sda1";
12851 device[5] = devchar;
12853 suppress_error = 0;
12854 r = guestfs_mkfs (g, fstype, device);
12859 char device[] = "/dev/sda1";
12860 device[5] = devchar;
12861 char mountpoint[] = "/";
12863 suppress_error = 0;
12864 r = guestfs_mount (g, device, mountpoint);
12868 /* TestOutputList for list_partitions (0) */
12872 suppress_error = 0;
12873 r = guestfs_list_partitions (g);
12877 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12882 char expected[] = "/dev/sda1";
12883 expected[5] = devchar;
12884 if (strcmp (r[0], expected) != 0) {
12885 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12889 if (r[1] != NULL) {
12890 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12894 for (i = 0; r[i] != NULL; ++i)
12901 static int test_list_partitions_1 (void)
12903 /* InitNone|InitEmpty for test_list_partitions_1 */
12905 char device[] = "/dev/sda";
12906 device[5] = devchar;
12908 suppress_error = 0;
12909 r = guestfs_blockdev_setrw (g, device);
12915 suppress_error = 0;
12916 r = guestfs_umount_all (g);
12922 suppress_error = 0;
12923 r = guestfs_lvm_remove_all (g);
12927 /* TestOutputList for list_partitions (1) */
12929 char device[] = "/dev/sda";
12930 device[5] = devchar;
12931 char lines_0[] = ",10";
12932 char lines_1[] = ",20";
12933 char lines_2[] = ",";
12941 suppress_error = 0;
12942 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12949 suppress_error = 0;
12950 r = guestfs_list_partitions (g);
12954 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12959 char expected[] = "/dev/sda1";
12960 expected[5] = devchar;
12961 if (strcmp (r[0], expected) != 0) {
12962 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12967 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12972 char expected[] = "/dev/sda2";
12973 expected[5] = devchar;
12974 if (strcmp (r[1], expected) != 0) {
12975 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12980 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12985 char expected[] = "/dev/sda3";
12986 expected[5] = devchar;
12987 if (strcmp (r[2], expected) != 0) {
12988 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12992 if (r[3] != NULL) {
12993 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12997 for (i = 0; r[i] != NULL; ++i)
13004 static int test_list_devices_0 (void)
13006 /* InitNone|InitEmpty for test_list_devices_0 */
13008 char device[] = "/dev/sda";
13009 device[5] = devchar;
13011 suppress_error = 0;
13012 r = guestfs_blockdev_setrw (g, device);
13018 suppress_error = 0;
13019 r = guestfs_umount_all (g);
13025 suppress_error = 0;
13026 r = guestfs_lvm_remove_all (g);
13030 /* TestOutputList for list_devices (0) */
13034 suppress_error = 0;
13035 r = guestfs_list_devices (g);
13039 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13044 char expected[] = "/dev/sda";
13045 expected[5] = devchar;
13046 if (strcmp (r[0], expected) != 0) {
13047 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13052 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13057 char expected[] = "/dev/sdb";
13058 expected[5] = devchar;
13059 if (strcmp (r[1], expected) != 0) {
13060 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13065 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13070 char expected[] = "/dev/sdc";
13071 expected[5] = devchar;
13072 if (strcmp (r[2], expected) != 0) {
13073 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13077 if (r[3] != NULL) {
13078 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
13082 for (i = 0; r[i] != NULL; ++i)
13089 static int test_ls_0 (void)
13091 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
13093 char device[] = "/dev/sda";
13094 device[5] = devchar;
13096 suppress_error = 0;
13097 r = guestfs_blockdev_setrw (g, device);
13103 suppress_error = 0;
13104 r = guestfs_umount_all (g);
13110 suppress_error = 0;
13111 r = guestfs_lvm_remove_all (g);
13116 char device[] = "/dev/sda";
13117 device[5] = devchar;
13118 char lines_0[] = ",";
13124 suppress_error = 0;
13125 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13130 char fstype[] = "ext2";
13131 char device[] = "/dev/sda1";
13132 device[5] = devchar;
13134 suppress_error = 0;
13135 r = guestfs_mkfs (g, fstype, device);
13140 char device[] = "/dev/sda1";
13141 device[5] = devchar;
13142 char mountpoint[] = "/";
13144 suppress_error = 0;
13145 r = guestfs_mount (g, device, mountpoint);
13149 /* TestOutputList for ls (0) */
13151 char path[] = "/new";
13153 suppress_error = 0;
13154 r = guestfs_touch (g, path);
13159 char path[] = "/newer";
13161 suppress_error = 0;
13162 r = guestfs_touch (g, path);
13167 char path[] = "/newest";
13169 suppress_error = 0;
13170 r = guestfs_touch (g, path);
13175 char directory[] = "/";
13178 suppress_error = 0;
13179 r = guestfs_ls (g, directory);
13183 fprintf (stderr, "test_ls_0: short list returned from command\n");
13188 char expected[] = "lost+found";
13189 if (strcmp (r[0], expected) != 0) {
13190 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13195 fprintf (stderr, "test_ls_0: short list returned from command\n");
13200 char expected[] = "new";
13201 if (strcmp (r[1], expected) != 0) {
13202 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13207 fprintf (stderr, "test_ls_0: short list returned from command\n");
13212 char expected[] = "newer";
13213 if (strcmp (r[2], expected) != 0) {
13214 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13219 fprintf (stderr, "test_ls_0: short list returned from command\n");
13224 char expected[] = "newest";
13225 if (strcmp (r[3], expected) != 0) {
13226 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
13230 if (r[4] != NULL) {
13231 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
13235 for (i = 0; r[i] != NULL; ++i)
13242 static int test_cat_0 (void)
13244 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
13246 char device[] = "/dev/sda";
13247 device[5] = devchar;
13249 suppress_error = 0;
13250 r = guestfs_blockdev_setrw (g, device);
13256 suppress_error = 0;
13257 r = guestfs_umount_all (g);
13263 suppress_error = 0;
13264 r = guestfs_lvm_remove_all (g);
13269 char device[] = "/dev/sda";
13270 device[5] = devchar;
13271 char lines_0[] = ",";
13277 suppress_error = 0;
13278 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13283 char fstype[] = "ext2";
13284 char device[] = "/dev/sda1";
13285 device[5] = devchar;
13287 suppress_error = 0;
13288 r = guestfs_mkfs (g, fstype, device);
13293 char device[] = "/dev/sda1";
13294 device[5] = devchar;
13295 char mountpoint[] = "/";
13297 suppress_error = 0;
13298 r = guestfs_mount (g, device, mountpoint);
13302 /* TestOutput for cat (0) */
13303 char expected[] = "new file contents";
13305 char path[] = "/new";
13306 char content[] = "new file contents";
13308 suppress_error = 0;
13309 r = guestfs_write_file (g, path, content, 0);
13314 char path[] = "/new";
13316 suppress_error = 0;
13317 r = guestfs_cat (g, path);
13320 if (strcmp (r, expected) != 0) {
13321 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
13329 static int test_touch_0 (void)
13331 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
13333 char device[] = "/dev/sda";
13334 device[5] = devchar;
13336 suppress_error = 0;
13337 r = guestfs_blockdev_setrw (g, device);
13343 suppress_error = 0;
13344 r = guestfs_umount_all (g);
13350 suppress_error = 0;
13351 r = guestfs_lvm_remove_all (g);
13356 char device[] = "/dev/sda";
13357 device[5] = devchar;
13358 char lines_0[] = ",";
13364 suppress_error = 0;
13365 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13370 char fstype[] = "ext2";
13371 char device[] = "/dev/sda1";
13372 device[5] = devchar;
13374 suppress_error = 0;
13375 r = guestfs_mkfs (g, fstype, device);
13380 char device[] = "/dev/sda1";
13381 device[5] = devchar;
13382 char mountpoint[] = "/";
13384 suppress_error = 0;
13385 r = guestfs_mount (g, device, mountpoint);
13389 /* TestOutputTrue for touch (0) */
13391 char path[] = "/new";
13393 suppress_error = 0;
13394 r = guestfs_touch (g, path);
13399 char path[] = "/new";
13401 suppress_error = 0;
13402 r = guestfs_exists (g, path);
13406 fprintf (stderr, "test_touch_0: expected true, got false\n");
13413 static int test_sync_0 (void)
13415 /* InitNone|InitEmpty for test_sync_0 */
13417 char device[] = "/dev/sda";
13418 device[5] = devchar;
13420 suppress_error = 0;
13421 r = guestfs_blockdev_setrw (g, device);
13427 suppress_error = 0;
13428 r = guestfs_umount_all (g);
13434 suppress_error = 0;
13435 r = guestfs_lvm_remove_all (g);
13439 /* TestRun for sync (0) */
13442 suppress_error = 0;
13443 r = guestfs_sync (g);
13450 static int test_mount_0 (void)
13452 /* InitNone|InitEmpty for test_mount_0 */
13454 char device[] = "/dev/sda";
13455 device[5] = devchar;
13457 suppress_error = 0;
13458 r = guestfs_blockdev_setrw (g, device);
13464 suppress_error = 0;
13465 r = guestfs_umount_all (g);
13471 suppress_error = 0;
13472 r = guestfs_lvm_remove_all (g);
13476 /* TestOutput for mount (0) */
13477 char expected[] = "new file contents";
13479 char device[] = "/dev/sda";
13480 device[5] = devchar;
13481 char lines_0[] = ",";
13487 suppress_error = 0;
13488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13493 char fstype[] = "ext2";
13494 char device[] = "/dev/sda1";
13495 device[5] = devchar;
13497 suppress_error = 0;
13498 r = guestfs_mkfs (g, fstype, device);
13503 char device[] = "/dev/sda1";
13504 device[5] = devchar;
13505 char mountpoint[] = "/";
13507 suppress_error = 0;
13508 r = guestfs_mount (g, device, mountpoint);
13513 char path[] = "/new";
13514 char content[] = "new file contents";
13516 suppress_error = 0;
13517 r = guestfs_write_file (g, path, content, 0);
13522 char path[] = "/new";
13524 suppress_error = 0;
13525 r = guestfs_cat (g, path);
13528 if (strcmp (r, expected) != 0) {
13529 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13537 int main (int argc, char *argv[])
13541 const char *srcdir;
13542 const char *filename;
13544 int nr_tests, test_num = 0;
13547 no_test_warnings ();
13549 g = guestfs_create ();
13551 printf ("guestfs_create FAILED\n");
13555 guestfs_set_error_handler (g, print_error, NULL);
13557 srcdir = getenv ("srcdir");
13558 if (!srcdir) srcdir = ".";
13560 guestfs_set_path (g, ".");
13562 filename = "test1.img";
13563 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13568 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13574 if (write (fd, &c, 1) == -1) {
13580 if (close (fd) == -1) {
13585 if (guestfs_add_drive (g, filename) == -1) {
13586 printf ("guestfs_add_drive %s FAILED\n", filename);
13590 filename = "test2.img";
13591 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13596 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13602 if (write (fd, &c, 1) == -1) {
13608 if (close (fd) == -1) {
13613 if (guestfs_add_drive (g, filename) == -1) {
13614 printf ("guestfs_add_drive %s FAILED\n", filename);
13618 filename = "test3.img";
13619 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13624 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13630 if (write (fd, &c, 1) == -1) {
13636 if (close (fd) == -1) {
13641 if (guestfs_add_drive (g, filename) == -1) {
13642 printf ("guestfs_add_drive %s FAILED\n", filename);
13646 if (guestfs_launch (g) == -1) {
13647 printf ("guestfs_launch FAILED\n");
13650 if (guestfs_wait_ready (g) == -1) {
13651 printf ("guestfs_wait_ready FAILED\n");
13655 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13656 * names. This changed between RHEL 5 and RHEL 6 so we have to
13659 devs = guestfs_list_devices (g);
13660 if (devs == NULL || devs[0] == NULL) {
13661 printf ("guestfs_list_devices FAILED\n");
13664 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13666 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13669 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13673 for (i = 0; devs[i] != NULL; ++i)
13680 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
13681 if (test_find_0 () == -1) {
13682 printf ("test_find_0 FAILED\n");
13686 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
13687 if (test_find_1 () == -1) {
13688 printf ("test_find_1 FAILED\n");
13692 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
13693 if (test_find_2 () == -1) {
13694 printf ("test_find_2 FAILED\n");
13698 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13699 if (test_lvresize_0 () == -1) {
13700 printf ("test_lvresize_0 FAILED\n");
13704 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13705 if (test_zerofree_0 () == -1) {
13706 printf ("test_zerofree_0 FAILED\n");
13710 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13711 if (test_hexdump_0 () == -1) {
13712 printf ("test_hexdump_0 FAILED\n");
13716 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13717 if (test_strings_e_0 () == -1) {
13718 printf ("test_strings_e_0 FAILED\n");
13722 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13723 if (test_strings_e_1 () == -1) {
13724 printf ("test_strings_e_1 FAILED\n");
13728 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13729 if (test_strings_0 () == -1) {
13730 printf ("test_strings_0 FAILED\n");
13734 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13735 if (test_strings_1 () == -1) {
13736 printf ("test_strings_1 FAILED\n");
13740 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13741 if (test_equal_0 () == -1) {
13742 printf ("test_equal_0 FAILED\n");
13746 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13747 if (test_equal_1 () == -1) {
13748 printf ("test_equal_1 FAILED\n");
13752 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13753 if (test_equal_2 () == -1) {
13754 printf ("test_equal_2 FAILED\n");
13758 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13759 if (test_ping_daemon_0 () == -1) {
13760 printf ("test_ping_daemon_0 FAILED\n");
13764 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13765 if (test_dmesg_0 () == -1) {
13766 printf ("test_dmesg_0 FAILED\n");
13770 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13771 if (test_drop_caches_0 () == -1) {
13772 printf ("test_drop_caches_0 FAILED\n");
13776 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13777 if (test_mv_0 () == -1) {
13778 printf ("test_mv_0 FAILED\n");
13782 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13783 if (test_mv_1 () == -1) {
13784 printf ("test_mv_1 FAILED\n");
13788 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13789 if (test_cp_a_0 () == -1) {
13790 printf ("test_cp_a_0 FAILED\n");
13794 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13795 if (test_cp_0 () == -1) {
13796 printf ("test_cp_0 FAILED\n");
13800 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13801 if (test_cp_1 () == -1) {
13802 printf ("test_cp_1 FAILED\n");
13806 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13807 if (test_cp_2 () == -1) {
13808 printf ("test_cp_2 FAILED\n");
13812 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13813 if (test_grub_install_0 () == -1) {
13814 printf ("test_grub_install_0 FAILED\n");
13818 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13819 if (test_zero_0 () == -1) {
13820 printf ("test_zero_0 FAILED\n");
13824 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13825 if (test_fsck_0 () == -1) {
13826 printf ("test_fsck_0 FAILED\n");
13830 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13831 if (test_fsck_1 () == -1) {
13832 printf ("test_fsck_1 FAILED\n");
13836 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13837 if (test_set_e2uuid_0 () == -1) {
13838 printf ("test_set_e2uuid_0 FAILED\n");
13842 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13843 if (test_set_e2uuid_1 () == -1) {
13844 printf ("test_set_e2uuid_1 FAILED\n");
13848 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13849 if (test_set_e2uuid_2 () == -1) {
13850 printf ("test_set_e2uuid_2 FAILED\n");
13854 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13855 if (test_set_e2uuid_3 () == -1) {
13856 printf ("test_set_e2uuid_3 FAILED\n");
13860 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13861 if (test_set_e2label_0 () == -1) {
13862 printf ("test_set_e2label_0 FAILED\n");
13866 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13867 if (test_pvremove_0 () == -1) {
13868 printf ("test_pvremove_0 FAILED\n");
13872 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13873 if (test_pvremove_1 () == -1) {
13874 printf ("test_pvremove_1 FAILED\n");
13878 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13879 if (test_pvremove_2 () == -1) {
13880 printf ("test_pvremove_2 FAILED\n");
13884 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13885 if (test_vgremove_0 () == -1) {
13886 printf ("test_vgremove_0 FAILED\n");
13890 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13891 if (test_vgremove_1 () == -1) {
13892 printf ("test_vgremove_1 FAILED\n");
13896 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13897 if (test_lvremove_0 () == -1) {
13898 printf ("test_lvremove_0 FAILED\n");
13902 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13903 if (test_lvremove_1 () == -1) {
13904 printf ("test_lvremove_1 FAILED\n");
13908 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13909 if (test_lvremove_2 () == -1) {
13910 printf ("test_lvremove_2 FAILED\n");
13914 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13915 if (test_mount_ro_0 () == -1) {
13916 printf ("test_mount_ro_0 FAILED\n");
13920 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13921 if (test_mount_ro_1 () == -1) {
13922 printf ("test_mount_ro_1 FAILED\n");
13926 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13927 if (test_tgz_in_0 () == -1) {
13928 printf ("test_tgz_in_0 FAILED\n");
13932 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13933 if (test_tar_in_0 () == -1) {
13934 printf ("test_tar_in_0 FAILED\n");
13938 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13939 if (test_checksum_0 () == -1) {
13940 printf ("test_checksum_0 FAILED\n");
13944 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13945 if (test_checksum_1 () == -1) {
13946 printf ("test_checksum_1 FAILED\n");
13950 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13951 if (test_checksum_2 () == -1) {
13952 printf ("test_checksum_2 FAILED\n");
13956 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13957 if (test_checksum_3 () == -1) {
13958 printf ("test_checksum_3 FAILED\n");
13962 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13963 if (test_checksum_4 () == -1) {
13964 printf ("test_checksum_4 FAILED\n");
13968 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13969 if (test_checksum_5 () == -1) {
13970 printf ("test_checksum_5 FAILED\n");
13974 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13975 if (test_checksum_6 () == -1) {
13976 printf ("test_checksum_6 FAILED\n");
13980 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13981 if (test_checksum_7 () == -1) {
13982 printf ("test_checksum_7 FAILED\n");
13986 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13987 if (test_download_0 () == -1) {
13988 printf ("test_download_0 FAILED\n");
13992 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13993 if (test_upload_0 () == -1) {
13994 printf ("test_upload_0 FAILED\n");
13998 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13999 if (test_blockdev_rereadpt_0 () == -1) {
14000 printf ("test_blockdev_rereadpt_0 FAILED\n");
14004 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
14005 if (test_blockdev_flushbufs_0 () == -1) {
14006 printf ("test_blockdev_flushbufs_0 FAILED\n");
14010 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
14011 if (test_blockdev_getsize64_0 () == -1) {
14012 printf ("test_blockdev_getsize64_0 FAILED\n");
14016 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
14017 if (test_blockdev_getsz_0 () == -1) {
14018 printf ("test_blockdev_getsz_0 FAILED\n");
14022 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
14023 if (test_blockdev_getbsz_0 () == -1) {
14024 printf ("test_blockdev_getbsz_0 FAILED\n");
14028 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
14029 if (test_blockdev_getss_0 () == -1) {
14030 printf ("test_blockdev_getss_0 FAILED\n");
14034 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
14035 if (test_blockdev_getro_0 () == -1) {
14036 printf ("test_blockdev_getro_0 FAILED\n");
14040 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
14041 if (test_blockdev_setrw_0 () == -1) {
14042 printf ("test_blockdev_setrw_0 FAILED\n");
14046 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
14047 if (test_blockdev_setro_0 () == -1) {
14048 printf ("test_blockdev_setro_0 FAILED\n");
14052 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
14053 if (test_statvfs_0 () == -1) {
14054 printf ("test_statvfs_0 FAILED\n");
14058 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
14059 if (test_lstat_0 () == -1) {
14060 printf ("test_lstat_0 FAILED\n");
14064 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
14065 if (test_stat_0 () == -1) {
14066 printf ("test_stat_0 FAILED\n");
14070 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
14071 if (test_command_lines_0 () == -1) {
14072 printf ("test_command_lines_0 FAILED\n");
14076 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
14077 if (test_command_lines_1 () == -1) {
14078 printf ("test_command_lines_1 FAILED\n");
14082 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
14083 if (test_command_lines_2 () == -1) {
14084 printf ("test_command_lines_2 FAILED\n");
14088 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
14089 if (test_command_lines_3 () == -1) {
14090 printf ("test_command_lines_3 FAILED\n");
14094 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
14095 if (test_command_lines_4 () == -1) {
14096 printf ("test_command_lines_4 FAILED\n");
14100 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
14101 if (test_command_lines_5 () == -1) {
14102 printf ("test_command_lines_5 FAILED\n");
14106 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
14107 if (test_command_lines_6 () == -1) {
14108 printf ("test_command_lines_6 FAILED\n");
14112 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
14113 if (test_command_lines_7 () == -1) {
14114 printf ("test_command_lines_7 FAILED\n");
14118 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
14119 if (test_command_lines_8 () == -1) {
14120 printf ("test_command_lines_8 FAILED\n");
14124 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
14125 if (test_command_lines_9 () == -1) {
14126 printf ("test_command_lines_9 FAILED\n");
14130 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
14131 if (test_command_lines_10 () == -1) {
14132 printf ("test_command_lines_10 FAILED\n");
14136 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
14137 if (test_command_0 () == -1) {
14138 printf ("test_command_0 FAILED\n");
14142 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
14143 if (test_command_1 () == -1) {
14144 printf ("test_command_1 FAILED\n");
14148 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
14149 if (test_command_2 () == -1) {
14150 printf ("test_command_2 FAILED\n");
14154 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
14155 if (test_command_3 () == -1) {
14156 printf ("test_command_3 FAILED\n");
14160 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
14161 if (test_command_4 () == -1) {
14162 printf ("test_command_4 FAILED\n");
14166 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
14167 if (test_command_5 () == -1) {
14168 printf ("test_command_5 FAILED\n");
14172 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
14173 if (test_command_6 () == -1) {
14174 printf ("test_command_6 FAILED\n");
14178 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
14179 if (test_command_7 () == -1) {
14180 printf ("test_command_7 FAILED\n");
14184 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
14185 if (test_command_8 () == -1) {
14186 printf ("test_command_8 FAILED\n");
14190 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
14191 if (test_command_9 () == -1) {
14192 printf ("test_command_9 FAILED\n");
14196 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
14197 if (test_command_10 () == -1) {
14198 printf ("test_command_10 FAILED\n");
14202 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
14203 if (test_command_11 () == -1) {
14204 printf ("test_command_11 FAILED\n");
14208 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
14209 if (test_file_0 () == -1) {
14210 printf ("test_file_0 FAILED\n");
14214 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
14215 if (test_file_1 () == -1) {
14216 printf ("test_file_1 FAILED\n");
14220 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
14221 if (test_file_2 () == -1) {
14222 printf ("test_file_2 FAILED\n");
14226 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
14227 if (test_umount_all_0 () == -1) {
14228 printf ("test_umount_all_0 FAILED\n");
14232 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
14233 if (test_umount_all_1 () == -1) {
14234 printf ("test_umount_all_1 FAILED\n");
14238 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
14239 if (test_mounts_0 () == -1) {
14240 printf ("test_mounts_0 FAILED\n");
14244 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
14245 if (test_umount_0 () == -1) {
14246 printf ("test_umount_0 FAILED\n");
14250 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
14251 if (test_umount_1 () == -1) {
14252 printf ("test_umount_1 FAILED\n");
14256 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
14257 if (test_write_file_0 () == -1) {
14258 printf ("test_write_file_0 FAILED\n");
14262 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
14263 if (test_write_file_1 () == -1) {
14264 printf ("test_write_file_1 FAILED\n");
14268 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
14269 if (test_write_file_2 () == -1) {
14270 printf ("test_write_file_2 FAILED\n");
14274 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
14275 if (test_write_file_3 () == -1) {
14276 printf ("test_write_file_3 FAILED\n");
14280 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
14281 if (test_write_file_4 () == -1) {
14282 printf ("test_write_file_4 FAILED\n");
14286 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
14287 if (test_write_file_5 () == -1) {
14288 printf ("test_write_file_5 FAILED\n");
14292 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
14293 if (test_mkfs_0 () == -1) {
14294 printf ("test_mkfs_0 FAILED\n");
14298 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
14299 if (test_lvcreate_0 () == -1) {
14300 printf ("test_lvcreate_0 FAILED\n");
14304 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
14305 if (test_vgcreate_0 () == -1) {
14306 printf ("test_vgcreate_0 FAILED\n");
14310 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
14311 if (test_pvcreate_0 () == -1) {
14312 printf ("test_pvcreate_0 FAILED\n");
14316 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
14317 if (test_is_dir_0 () == -1) {
14318 printf ("test_is_dir_0 FAILED\n");
14322 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
14323 if (test_is_dir_1 () == -1) {
14324 printf ("test_is_dir_1 FAILED\n");
14328 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
14329 if (test_is_file_0 () == -1) {
14330 printf ("test_is_file_0 FAILED\n");
14334 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
14335 if (test_is_file_1 () == -1) {
14336 printf ("test_is_file_1 FAILED\n");
14340 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
14341 if (test_exists_0 () == -1) {
14342 printf ("test_exists_0 FAILED\n");
14346 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
14347 if (test_exists_1 () == -1) {
14348 printf ("test_exists_1 FAILED\n");
14352 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
14353 if (test_mkdir_p_0 () == -1) {
14354 printf ("test_mkdir_p_0 FAILED\n");
14358 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
14359 if (test_mkdir_p_1 () == -1) {
14360 printf ("test_mkdir_p_1 FAILED\n");
14364 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
14365 if (test_mkdir_p_2 () == -1) {
14366 printf ("test_mkdir_p_2 FAILED\n");
14370 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
14371 if (test_mkdir_0 () == -1) {
14372 printf ("test_mkdir_0 FAILED\n");
14376 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
14377 if (test_mkdir_1 () == -1) {
14378 printf ("test_mkdir_1 FAILED\n");
14382 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
14383 if (test_rm_rf_0 () == -1) {
14384 printf ("test_rm_rf_0 FAILED\n");
14388 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
14389 if (test_rmdir_0 () == -1) {
14390 printf ("test_rmdir_0 FAILED\n");
14394 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14395 if (test_rmdir_1 () == -1) {
14396 printf ("test_rmdir_1 FAILED\n");
14400 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14401 if (test_rmdir_2 () == -1) {
14402 printf ("test_rmdir_2 FAILED\n");
14406 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14407 if (test_rm_0 () == -1) {
14408 printf ("test_rm_0 FAILED\n");
14412 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14413 if (test_rm_1 () == -1) {
14414 printf ("test_rm_1 FAILED\n");
14418 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14419 if (test_rm_2 () == -1) {
14420 printf ("test_rm_2 FAILED\n");
14424 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14425 if (test_read_lines_0 () == -1) {
14426 printf ("test_read_lines_0 FAILED\n");
14430 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14431 if (test_read_lines_1 () == -1) {
14432 printf ("test_read_lines_1 FAILED\n");
14436 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14437 if (test_lvs_0 () == -1) {
14438 printf ("test_lvs_0 FAILED\n");
14442 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14443 if (test_lvs_1 () == -1) {
14444 printf ("test_lvs_1 FAILED\n");
14448 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14449 if (test_vgs_0 () == -1) {
14450 printf ("test_vgs_0 FAILED\n");
14454 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14455 if (test_vgs_1 () == -1) {
14456 printf ("test_vgs_1 FAILED\n");
14460 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14461 if (test_pvs_0 () == -1) {
14462 printf ("test_pvs_0 FAILED\n");
14466 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14467 if (test_pvs_1 () == -1) {
14468 printf ("test_pvs_1 FAILED\n");
14472 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14473 if (test_list_partitions_0 () == -1) {
14474 printf ("test_list_partitions_0 FAILED\n");
14478 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14479 if (test_list_partitions_1 () == -1) {
14480 printf ("test_list_partitions_1 FAILED\n");
14484 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14485 if (test_list_devices_0 () == -1) {
14486 printf ("test_list_devices_0 FAILED\n");
14490 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14491 if (test_ls_0 () == -1) {
14492 printf ("test_ls_0 FAILED\n");
14496 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14497 if (test_cat_0 () == -1) {
14498 printf ("test_cat_0 FAILED\n");
14502 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14503 if (test_touch_0 () == -1) {
14504 printf ("test_touch_0 FAILED\n");
14508 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14509 if (test_sync_0 () == -1) {
14510 printf ("test_sync_0 FAILED\n");
14514 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14515 if (test_mount_0 () == -1) {
14516 printf ("test_mount_0 FAILED\n");
14521 unlink ("test1.img");
14522 unlink ("test2.img");
14523 unlink ("test3.img");
14526 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);