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;
2939 char lines_0[] = ",";
2946 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2951 char device[] = "/dev/sda1";
2952 device[5] = devchar;
2955 r = guestfs_pvcreate (g, device);
2960 char volgroup[] = "VG";
2961 char physvols_0[] = "/dev/sda1";
2962 physvols_0[5] = devchar;
2963 char *physvols[] = {
2969 r = guestfs_vgcreate (g, volgroup, physvols);
2974 char logvol[] = "LV1";
2975 char volgroup[] = "VG";
2978 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2983 char logvol[] = "LV2";
2984 char volgroup[] = "VG";
2987 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2992 char vgname[] = "VG";
2995 r = guestfs_vgremove (g, vgname);
3000 char device[] = "/dev/sda1";
3001 device[5] = devchar;
3004 r = guestfs_pvremove (g, device);
3012 r = guestfs_lvs (g);
3016 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3020 for (i = 0; r[i] != NULL; ++i)
3027 static int test_pvremove_1 (void)
3029 /* InitNone|InitEmpty for test_pvremove_1 */
3031 char device[] = "/dev/sda";
3032 device[5] = devchar;
3035 r = guestfs_blockdev_setrw (g, device);
3042 r = guestfs_umount_all (g);
3049 r = guestfs_lvm_remove_all (g);
3053 /* TestOutputList for pvremove (1) */
3055 char device[] = "/dev/sda";
3056 device[5] = devchar;
3057 char lines_0[] = ",";
3064 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3069 char device[] = "/dev/sda1";
3070 device[5] = devchar;
3073 r = guestfs_pvcreate (g, device);
3078 char volgroup[] = "VG";
3079 char physvols_0[] = "/dev/sda1";
3080 physvols_0[5] = devchar;
3081 char *physvols[] = {
3087 r = guestfs_vgcreate (g, volgroup, physvols);
3092 char logvol[] = "LV1";
3093 char volgroup[] = "VG";
3096 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3101 char logvol[] = "LV2";
3102 char volgroup[] = "VG";
3105 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3110 char vgname[] = "VG";
3113 r = guestfs_vgremove (g, vgname);
3118 char device[] = "/dev/sda1";
3119 device[5] = devchar;
3122 r = guestfs_pvremove (g, device);
3130 r = guestfs_vgs (g);
3134 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3138 for (i = 0; r[i] != NULL; ++i)
3145 static int test_pvremove_2 (void)
3147 /* InitNone|InitEmpty for test_pvremove_2 */
3149 char device[] = "/dev/sda";
3150 device[5] = devchar;
3153 r = guestfs_blockdev_setrw (g, device);
3160 r = guestfs_umount_all (g);
3167 r = guestfs_lvm_remove_all (g);
3171 /* TestOutputList for pvremove (2) */
3173 char device[] = "/dev/sda";
3174 device[5] = devchar;
3175 char lines_0[] = ",";
3182 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3187 char device[] = "/dev/sda1";
3188 device[5] = devchar;
3191 r = guestfs_pvcreate (g, device);
3196 char volgroup[] = "VG";
3197 char physvols_0[] = "/dev/sda1";
3198 physvols_0[5] = devchar;
3199 char *physvols[] = {
3205 r = guestfs_vgcreate (g, volgroup, physvols);
3210 char logvol[] = "LV1";
3211 char volgroup[] = "VG";
3214 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3219 char logvol[] = "LV2";
3220 char volgroup[] = "VG";
3223 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3228 char vgname[] = "VG";
3231 r = guestfs_vgremove (g, vgname);
3236 char device[] = "/dev/sda1";
3237 device[5] = devchar;
3240 r = guestfs_pvremove (g, device);
3248 r = guestfs_pvs (g);
3252 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3256 for (i = 0; r[i] != NULL; ++i)
3263 static int test_vgremove_0 (void)
3265 /* InitNone|InitEmpty for test_vgremove_0 */
3267 char device[] = "/dev/sda";
3268 device[5] = devchar;
3271 r = guestfs_blockdev_setrw (g, device);
3278 r = guestfs_umount_all (g);
3285 r = guestfs_lvm_remove_all (g);
3289 /* TestOutputList for vgremove (0) */
3291 char device[] = "/dev/sda";
3292 device[5] = devchar;
3293 char lines_0[] = ",";
3300 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3305 char device[] = "/dev/sda1";
3306 device[5] = devchar;
3309 r = guestfs_pvcreate (g, device);
3314 char volgroup[] = "VG";
3315 char physvols_0[] = "/dev/sda1";
3316 physvols_0[5] = devchar;
3317 char *physvols[] = {
3323 r = guestfs_vgcreate (g, volgroup, physvols);
3328 char logvol[] = "LV1";
3329 char volgroup[] = "VG";
3332 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3337 char logvol[] = "LV2";
3338 char volgroup[] = "VG";
3341 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3346 char vgname[] = "VG";
3349 r = guestfs_vgremove (g, vgname);
3357 r = guestfs_lvs (g);
3361 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3365 for (i = 0; r[i] != NULL; ++i)
3372 static int test_vgremove_1 (void)
3374 /* InitNone|InitEmpty for test_vgremove_1 */
3376 char device[] = "/dev/sda";
3377 device[5] = devchar;
3380 r = guestfs_blockdev_setrw (g, device);
3387 r = guestfs_umount_all (g);
3394 r = guestfs_lvm_remove_all (g);
3398 /* TestOutputList for vgremove (1) */
3400 char device[] = "/dev/sda";
3401 device[5] = devchar;
3402 char lines_0[] = ",";
3409 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3414 char device[] = "/dev/sda1";
3415 device[5] = devchar;
3418 r = guestfs_pvcreate (g, device);
3423 char volgroup[] = "VG";
3424 char physvols_0[] = "/dev/sda1";
3425 physvols_0[5] = devchar;
3426 char *physvols[] = {
3432 r = guestfs_vgcreate (g, volgroup, physvols);
3437 char logvol[] = "LV1";
3438 char volgroup[] = "VG";
3441 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3446 char logvol[] = "LV2";
3447 char volgroup[] = "VG";
3450 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3455 char vgname[] = "VG";
3458 r = guestfs_vgremove (g, vgname);
3466 r = guestfs_vgs (g);
3470 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3474 for (i = 0; r[i] != NULL; ++i)
3481 static int test_lvremove_0 (void)
3483 /* InitNone|InitEmpty for test_lvremove_0 */
3485 char device[] = "/dev/sda";
3486 device[5] = devchar;
3489 r = guestfs_blockdev_setrw (g, device);
3496 r = guestfs_umount_all (g);
3503 r = guestfs_lvm_remove_all (g);
3507 /* TestOutputList for lvremove (0) */
3509 char device[] = "/dev/sda";
3510 device[5] = devchar;
3511 char lines_0[] = ",";
3518 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3523 char device[] = "/dev/sda1";
3524 device[5] = devchar;
3527 r = guestfs_pvcreate (g, device);
3532 char volgroup[] = "VG";
3533 char physvols_0[] = "/dev/sda1";
3534 physvols_0[5] = devchar;
3535 char *physvols[] = {
3541 r = guestfs_vgcreate (g, volgroup, physvols);
3546 char logvol[] = "LV1";
3547 char volgroup[] = "VG";
3550 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3555 char logvol[] = "LV2";
3556 char volgroup[] = "VG";
3559 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3564 char device[] = "/dev/VG/LV1";
3567 r = guestfs_lvremove (g, device);
3575 r = guestfs_lvs (g);
3579 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3584 char expected[] = "/dev/VG/LV2";
3585 if (strcmp (r[0], expected) != 0) {
3586 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3591 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3595 for (i = 0; r[i] != NULL; ++i)
3602 static int test_lvremove_1 (void)
3604 /* InitNone|InitEmpty for test_lvremove_1 */
3606 char device[] = "/dev/sda";
3607 device[5] = devchar;
3610 r = guestfs_blockdev_setrw (g, device);
3617 r = guestfs_umount_all (g);
3624 r = guestfs_lvm_remove_all (g);
3628 /* TestOutputList for lvremove (1) */
3630 char device[] = "/dev/sda";
3631 device[5] = devchar;
3632 char lines_0[] = ",";
3639 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3644 char device[] = "/dev/sda1";
3645 device[5] = devchar;
3648 r = guestfs_pvcreate (g, device);
3653 char volgroup[] = "VG";
3654 char physvols_0[] = "/dev/sda1";
3655 physvols_0[5] = devchar;
3656 char *physvols[] = {
3662 r = guestfs_vgcreate (g, volgroup, physvols);
3667 char logvol[] = "LV1";
3668 char volgroup[] = "VG";
3671 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3676 char logvol[] = "LV2";
3677 char volgroup[] = "VG";
3680 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3685 char device[] = "/dev/VG";
3688 r = guestfs_lvremove (g, device);
3696 r = guestfs_lvs (g);
3700 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3704 for (i = 0; r[i] != NULL; ++i)
3711 static int test_lvremove_2 (void)
3713 /* InitNone|InitEmpty for test_lvremove_2 */
3715 char device[] = "/dev/sda";
3716 device[5] = devchar;
3719 r = guestfs_blockdev_setrw (g, device);
3726 r = guestfs_umount_all (g);
3733 r = guestfs_lvm_remove_all (g);
3737 /* TestOutputList for lvremove (2) */
3739 char device[] = "/dev/sda";
3740 device[5] = devchar;
3741 char lines_0[] = ",";
3748 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3753 char device[] = "/dev/sda1";
3754 device[5] = devchar;
3757 r = guestfs_pvcreate (g, device);
3762 char volgroup[] = "VG";
3763 char physvols_0[] = "/dev/sda1";
3764 physvols_0[5] = devchar;
3765 char *physvols[] = {
3771 r = guestfs_vgcreate (g, volgroup, physvols);
3776 char logvol[] = "LV1";
3777 char volgroup[] = "VG";
3780 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3785 char logvol[] = "LV2";
3786 char volgroup[] = "VG";
3789 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3794 char device[] = "/dev/VG";
3797 r = guestfs_lvremove (g, device);
3805 r = guestfs_vgs (g);
3809 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3814 char expected[] = "VG";
3815 if (strcmp (r[0], expected) != 0) {
3816 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3821 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3825 for (i = 0; r[i] != NULL; ++i)
3832 static int test_mount_ro_0 (void)
3834 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3836 char device[] = "/dev/sda";
3837 device[5] = devchar;
3840 r = guestfs_blockdev_setrw (g, device);
3847 r = guestfs_umount_all (g);
3854 r = guestfs_lvm_remove_all (g);
3859 char device[] = "/dev/sda";
3860 device[5] = devchar;
3861 char lines_0[] = ",";
3868 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3873 char fstype[] = "ext2";
3874 char device[] = "/dev/sda1";
3875 device[5] = devchar;
3878 r = guestfs_mkfs (g, fstype, device);
3883 char device[] = "/dev/sda1";
3884 device[5] = devchar;
3885 char mountpoint[] = "/";
3888 r = guestfs_mount (g, device, mountpoint);
3892 /* TestLastFail for mount_ro (0) */
3894 char pathordevice[] = "/";
3897 r = guestfs_umount (g, pathordevice);
3902 char device[] = "/dev/sda1";
3903 device[5] = devchar;
3904 char mountpoint[] = "/";
3907 r = guestfs_mount_ro (g, device, mountpoint);
3912 char path[] = "/new";
3915 r = guestfs_touch (g, path);
3922 static int test_mount_ro_1 (void)
3924 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3926 char device[] = "/dev/sda";
3927 device[5] = devchar;
3930 r = guestfs_blockdev_setrw (g, device);
3937 r = guestfs_umount_all (g);
3944 r = guestfs_lvm_remove_all (g);
3949 char device[] = "/dev/sda";
3950 device[5] = devchar;
3951 char lines_0[] = ",";
3958 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3963 char fstype[] = "ext2";
3964 char device[] = "/dev/sda1";
3965 device[5] = devchar;
3968 r = guestfs_mkfs (g, fstype, device);
3973 char device[] = "/dev/sda1";
3974 device[5] = devchar;
3975 char mountpoint[] = "/";
3978 r = guestfs_mount (g, device, mountpoint);
3982 /* TestOutput for mount_ro (1) */
3983 char expected[] = "data";
3985 char path[] = "/new";
3986 char content[] = "data";
3989 r = guestfs_write_file (g, path, content, 0);
3994 char pathordevice[] = "/";
3997 r = guestfs_umount (g, pathordevice);
4002 char device[] = "/dev/sda1";
4003 device[5] = devchar;
4004 char mountpoint[] = "/";
4007 r = guestfs_mount_ro (g, device, mountpoint);
4012 char path[] = "/new";
4015 r = guestfs_cat (g, path);
4018 if (strcmp (r, expected) != 0) {
4019 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4027 static int test_tgz_in_0 (void)
4029 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4031 char device[] = "/dev/sda";
4032 device[5] = devchar;
4035 r = guestfs_blockdev_setrw (g, device);
4042 r = guestfs_umount_all (g);
4049 r = guestfs_lvm_remove_all (g);
4054 char device[] = "/dev/sda";
4055 device[5] = devchar;
4056 char lines_0[] = ",";
4063 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4068 char fstype[] = "ext2";
4069 char device[] = "/dev/sda1";
4070 device[5] = devchar;
4073 r = guestfs_mkfs (g, fstype, device);
4078 char device[] = "/dev/sda1";
4079 device[5] = devchar;
4080 char mountpoint[] = "/";
4083 r = guestfs_mount (g, device, mountpoint);
4087 /* TestOutput for tgz_in (0) */
4088 char expected[] = "hello\n";
4090 char directory[] = "/";
4093 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
4098 char path[] = "/hello";
4101 r = guestfs_cat (g, path);
4104 if (strcmp (r, expected) != 0) {
4105 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4113 static int test_tar_in_0 (void)
4115 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4117 char device[] = "/dev/sda";
4118 device[5] = devchar;
4121 r = guestfs_blockdev_setrw (g, device);
4128 r = guestfs_umount_all (g);
4135 r = guestfs_lvm_remove_all (g);
4140 char device[] = "/dev/sda";
4141 device[5] = devchar;
4142 char lines_0[] = ",";
4149 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4154 char fstype[] = "ext2";
4155 char device[] = "/dev/sda1";
4156 device[5] = devchar;
4159 r = guestfs_mkfs (g, fstype, device);
4164 char device[] = "/dev/sda1";
4165 device[5] = devchar;
4166 char mountpoint[] = "/";
4169 r = guestfs_mount (g, device, mountpoint);
4173 /* TestOutput for tar_in (0) */
4174 char expected[] = "hello\n";
4176 char directory[] = "/";
4179 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4184 char path[] = "/hello";
4187 r = guestfs_cat (g, path);
4190 if (strcmp (r, expected) != 0) {
4191 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4199 static int test_checksum_0 (void)
4201 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4203 char device[] = "/dev/sda";
4204 device[5] = devchar;
4207 r = guestfs_blockdev_setrw (g, device);
4214 r = guestfs_umount_all (g);
4221 r = guestfs_lvm_remove_all (g);
4226 char device[] = "/dev/sda";
4227 device[5] = devchar;
4228 char lines_0[] = ",";
4235 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4240 char fstype[] = "ext2";
4241 char device[] = "/dev/sda1";
4242 device[5] = devchar;
4245 r = guestfs_mkfs (g, fstype, device);
4250 char device[] = "/dev/sda1";
4251 device[5] = devchar;
4252 char mountpoint[] = "/";
4255 r = guestfs_mount (g, device, mountpoint);
4259 /* TestOutput for checksum (0) */
4260 char expected[] = "935282863";
4262 char path[] = "/new";
4263 char content[] = "test\n";
4266 r = guestfs_write_file (g, path, content, 0);
4271 char csumtype[] = "crc";
4272 char path[] = "/new";
4275 r = guestfs_checksum (g, csumtype, path);
4278 if (strcmp (r, expected) != 0) {
4279 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4287 static int test_checksum_1 (void)
4289 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
4291 char device[] = "/dev/sda";
4292 device[5] = devchar;
4295 r = guestfs_blockdev_setrw (g, device);
4302 r = guestfs_umount_all (g);
4309 r = guestfs_lvm_remove_all (g);
4314 char device[] = "/dev/sda";
4315 device[5] = devchar;
4316 char lines_0[] = ",";
4323 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4328 char fstype[] = "ext2";
4329 char device[] = "/dev/sda1";
4330 device[5] = devchar;
4333 r = guestfs_mkfs (g, fstype, device);
4338 char device[] = "/dev/sda1";
4339 device[5] = devchar;
4340 char mountpoint[] = "/";
4343 r = guestfs_mount (g, device, mountpoint);
4347 /* TestLastFail for checksum (1) */
4349 char csumtype[] = "crc";
4350 char path[] = "/new";
4353 r = guestfs_checksum (g, csumtype, path);
4361 static int test_checksum_2 (void)
4363 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
4365 char device[] = "/dev/sda";
4366 device[5] = devchar;
4369 r = guestfs_blockdev_setrw (g, device);
4376 r = guestfs_umount_all (g);
4383 r = guestfs_lvm_remove_all (g);
4388 char device[] = "/dev/sda";
4389 device[5] = devchar;
4390 char lines_0[] = ",";
4397 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4402 char fstype[] = "ext2";
4403 char device[] = "/dev/sda1";
4404 device[5] = devchar;
4407 r = guestfs_mkfs (g, fstype, device);
4412 char device[] = "/dev/sda1";
4413 device[5] = devchar;
4414 char mountpoint[] = "/";
4417 r = guestfs_mount (g, device, mountpoint);
4421 /* TestOutput for checksum (2) */
4422 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
4424 char path[] = "/new";
4425 char content[] = "test\n";
4428 r = guestfs_write_file (g, path, content, 0);
4433 char csumtype[] = "md5";
4434 char path[] = "/new";
4437 r = guestfs_checksum (g, csumtype, path);
4440 if (strcmp (r, expected) != 0) {
4441 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
4449 static int test_checksum_3 (void)
4451 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
4453 char device[] = "/dev/sda";
4454 device[5] = devchar;
4457 r = guestfs_blockdev_setrw (g, device);
4464 r = guestfs_umount_all (g);
4471 r = guestfs_lvm_remove_all (g);
4476 char device[] = "/dev/sda";
4477 device[5] = devchar;
4478 char lines_0[] = ",";
4485 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4490 char fstype[] = "ext2";
4491 char device[] = "/dev/sda1";
4492 device[5] = devchar;
4495 r = guestfs_mkfs (g, fstype, device);
4500 char device[] = "/dev/sda1";
4501 device[5] = devchar;
4502 char mountpoint[] = "/";
4505 r = guestfs_mount (g, device, mountpoint);
4509 /* TestOutput for checksum (3) */
4510 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4512 char path[] = "/new";
4513 char content[] = "test\n";
4516 r = guestfs_write_file (g, path, content, 0);
4521 char csumtype[] = "sha1";
4522 char path[] = "/new";
4525 r = guestfs_checksum (g, csumtype, path);
4528 if (strcmp (r, expected) != 0) {
4529 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4537 static int test_checksum_4 (void)
4539 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4541 char device[] = "/dev/sda";
4542 device[5] = devchar;
4545 r = guestfs_blockdev_setrw (g, device);
4552 r = guestfs_umount_all (g);
4559 r = guestfs_lvm_remove_all (g);
4564 char device[] = "/dev/sda";
4565 device[5] = devchar;
4566 char lines_0[] = ",";
4573 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4578 char fstype[] = "ext2";
4579 char device[] = "/dev/sda1";
4580 device[5] = devchar;
4583 r = guestfs_mkfs (g, fstype, device);
4588 char device[] = "/dev/sda1";
4589 device[5] = devchar;
4590 char mountpoint[] = "/";
4593 r = guestfs_mount (g, device, mountpoint);
4597 /* TestOutput for checksum (4) */
4598 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4600 char path[] = "/new";
4601 char content[] = "test\n";
4604 r = guestfs_write_file (g, path, content, 0);
4609 char csumtype[] = "sha224";
4610 char path[] = "/new";
4613 r = guestfs_checksum (g, csumtype, path);
4616 if (strcmp (r, expected) != 0) {
4617 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4625 static int test_checksum_5 (void)
4627 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4629 char device[] = "/dev/sda";
4630 device[5] = devchar;
4633 r = guestfs_blockdev_setrw (g, device);
4640 r = guestfs_umount_all (g);
4647 r = guestfs_lvm_remove_all (g);
4652 char device[] = "/dev/sda";
4653 device[5] = devchar;
4654 char lines_0[] = ",";
4661 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4666 char fstype[] = "ext2";
4667 char device[] = "/dev/sda1";
4668 device[5] = devchar;
4671 r = guestfs_mkfs (g, fstype, device);
4676 char device[] = "/dev/sda1";
4677 device[5] = devchar;
4678 char mountpoint[] = "/";
4681 r = guestfs_mount (g, device, mountpoint);
4685 /* TestOutput for checksum (5) */
4686 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4688 char path[] = "/new";
4689 char content[] = "test\n";
4692 r = guestfs_write_file (g, path, content, 0);
4697 char csumtype[] = "sha256";
4698 char path[] = "/new";
4701 r = guestfs_checksum (g, csumtype, path);
4704 if (strcmp (r, expected) != 0) {
4705 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4713 static int test_checksum_6 (void)
4715 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4717 char device[] = "/dev/sda";
4718 device[5] = devchar;
4721 r = guestfs_blockdev_setrw (g, device);
4728 r = guestfs_umount_all (g);
4735 r = guestfs_lvm_remove_all (g);
4740 char device[] = "/dev/sda";
4741 device[5] = devchar;
4742 char lines_0[] = ",";
4749 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4754 char fstype[] = "ext2";
4755 char device[] = "/dev/sda1";
4756 device[5] = devchar;
4759 r = guestfs_mkfs (g, fstype, device);
4764 char device[] = "/dev/sda1";
4765 device[5] = devchar;
4766 char mountpoint[] = "/";
4769 r = guestfs_mount (g, device, mountpoint);
4773 /* TestOutput for checksum (6) */
4774 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4776 char path[] = "/new";
4777 char content[] = "test\n";
4780 r = guestfs_write_file (g, path, content, 0);
4785 char csumtype[] = "sha384";
4786 char path[] = "/new";
4789 r = guestfs_checksum (g, csumtype, path);
4792 if (strcmp (r, expected) != 0) {
4793 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4801 static int test_checksum_7 (void)
4803 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4805 char device[] = "/dev/sda";
4806 device[5] = devchar;
4809 r = guestfs_blockdev_setrw (g, device);
4816 r = guestfs_umount_all (g);
4823 r = guestfs_lvm_remove_all (g);
4828 char device[] = "/dev/sda";
4829 device[5] = devchar;
4830 char lines_0[] = ",";
4837 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4842 char fstype[] = "ext2";
4843 char device[] = "/dev/sda1";
4844 device[5] = devchar;
4847 r = guestfs_mkfs (g, fstype, device);
4852 char device[] = "/dev/sda1";
4853 device[5] = devchar;
4854 char mountpoint[] = "/";
4857 r = guestfs_mount (g, device, mountpoint);
4861 /* TestOutput for checksum (7) */
4862 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4864 char path[] = "/new";
4865 char content[] = "test\n";
4868 r = guestfs_write_file (g, path, content, 0);
4873 char csumtype[] = "sha512";
4874 char path[] = "/new";
4877 r = guestfs_checksum (g, csumtype, path);
4880 if (strcmp (r, expected) != 0) {
4881 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4889 static int test_download_0 (void)
4891 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4893 char device[] = "/dev/sda";
4894 device[5] = devchar;
4897 r = guestfs_blockdev_setrw (g, device);
4904 r = guestfs_umount_all (g);
4911 r = guestfs_lvm_remove_all (g);
4916 char device[] = "/dev/sda";
4917 device[5] = devchar;
4918 char lines_0[] = ",";
4925 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4930 char fstype[] = "ext2";
4931 char device[] = "/dev/sda1";
4932 device[5] = devchar;
4935 r = guestfs_mkfs (g, fstype, device);
4940 char device[] = "/dev/sda1";
4941 device[5] = devchar;
4942 char mountpoint[] = "/";
4945 r = guestfs_mount (g, device, mountpoint);
4949 /* TestOutput for download (0) */
4950 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4952 char remotefilename[] = "/COPYING.LIB";
4955 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4960 char remotefilename[] = "/COPYING.LIB";
4963 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4968 char remotefilename[] = "/upload";
4971 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4976 char csumtype[] = "md5";
4977 char path[] = "/upload";
4980 r = guestfs_checksum (g, csumtype, path);
4983 if (strcmp (r, expected) != 0) {
4984 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4992 static int test_upload_0 (void)
4994 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
4996 char device[] = "/dev/sda";
4997 device[5] = devchar;
5000 r = guestfs_blockdev_setrw (g, device);
5007 r = guestfs_umount_all (g);
5014 r = guestfs_lvm_remove_all (g);
5019 char device[] = "/dev/sda";
5020 device[5] = devchar;
5021 char lines_0[] = ",";
5028 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5033 char fstype[] = "ext2";
5034 char device[] = "/dev/sda1";
5035 device[5] = devchar;
5038 r = guestfs_mkfs (g, fstype, device);
5043 char device[] = "/dev/sda1";
5044 device[5] = devchar;
5045 char mountpoint[] = "/";
5048 r = guestfs_mount (g, device, mountpoint);
5052 /* TestOutput for upload (0) */
5053 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5055 char remotefilename[] = "/COPYING.LIB";
5058 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5063 char csumtype[] = "md5";
5064 char path[] = "/COPYING.LIB";
5067 r = guestfs_checksum (g, csumtype, path);
5070 if (strcmp (r, expected) != 0) {
5071 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
5079 static int test_blockdev_rereadpt_0 (void)
5081 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
5083 char device[] = "/dev/sda";
5084 device[5] = devchar;
5087 r = guestfs_blockdev_setrw (g, device);
5094 r = guestfs_umount_all (g);
5101 r = guestfs_lvm_remove_all (g);
5105 /* TestRun for blockdev_rereadpt (0) */
5107 char device[] = "/dev/sda";
5108 device[5] = devchar;
5111 r = guestfs_blockdev_rereadpt (g, device);
5118 static int test_blockdev_flushbufs_0 (void)
5120 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
5122 char device[] = "/dev/sda";
5123 device[5] = devchar;
5126 r = guestfs_blockdev_setrw (g, device);
5133 r = guestfs_umount_all (g);
5140 r = guestfs_lvm_remove_all (g);
5144 /* TestRun for blockdev_flushbufs (0) */
5146 char device[] = "/dev/sda";
5147 device[5] = devchar;
5150 r = guestfs_blockdev_flushbufs (g, device);
5157 static int test_blockdev_getsize64_0 (void)
5159 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
5161 char device[] = "/dev/sda";
5162 device[5] = devchar;
5165 r = guestfs_blockdev_setrw (g, device);
5172 r = guestfs_umount_all (g);
5179 r = guestfs_lvm_remove_all (g);
5183 /* TestOutputInt for blockdev_getsize64 (0) */
5185 char device[] = "/dev/sda";
5186 device[5] = devchar;
5189 r = guestfs_blockdev_getsize64 (g, device);
5192 if (r != 524288000) {
5193 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
5200 static int test_blockdev_getsz_0 (void)
5202 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
5204 char device[] = "/dev/sda";
5205 device[5] = devchar;
5208 r = guestfs_blockdev_setrw (g, device);
5215 r = guestfs_umount_all (g);
5222 r = guestfs_lvm_remove_all (g);
5226 /* TestOutputInt for blockdev_getsz (0) */
5228 char device[] = "/dev/sda";
5229 device[5] = devchar;
5232 r = guestfs_blockdev_getsz (g, device);
5236 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
5243 static int test_blockdev_getbsz_0 (void)
5245 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
5247 char device[] = "/dev/sda";
5248 device[5] = devchar;
5251 r = guestfs_blockdev_setrw (g, device);
5258 r = guestfs_umount_all (g);
5265 r = guestfs_lvm_remove_all (g);
5269 /* TestOutputInt for blockdev_getbsz (0) */
5271 char device[] = "/dev/sda";
5272 device[5] = devchar;
5275 r = guestfs_blockdev_getbsz (g, device);
5279 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
5286 static int test_blockdev_getss_0 (void)
5288 /* InitNone|InitEmpty for test_blockdev_getss_0 */
5290 char device[] = "/dev/sda";
5291 device[5] = devchar;
5294 r = guestfs_blockdev_setrw (g, device);
5301 r = guestfs_umount_all (g);
5308 r = guestfs_lvm_remove_all (g);
5312 /* TestOutputInt for blockdev_getss (0) */
5314 char device[] = "/dev/sda";
5315 device[5] = devchar;
5318 r = guestfs_blockdev_getss (g, device);
5322 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
5329 static int test_blockdev_getro_0 (void)
5331 /* InitNone|InitEmpty for test_blockdev_getro_0 */
5333 char device[] = "/dev/sda";
5334 device[5] = devchar;
5337 r = guestfs_blockdev_setrw (g, device);
5344 r = guestfs_umount_all (g);
5351 r = guestfs_lvm_remove_all (g);
5355 /* TestOutputTrue for blockdev_getro (0) */
5357 char device[] = "/dev/sda";
5358 device[5] = devchar;
5361 r = guestfs_blockdev_setro (g, device);
5366 char device[] = "/dev/sda";
5367 device[5] = devchar;
5370 r = guestfs_blockdev_getro (g, device);
5374 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
5381 static int test_blockdev_setrw_0 (void)
5383 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
5385 char device[] = "/dev/sda";
5386 device[5] = devchar;
5389 r = guestfs_blockdev_setrw (g, device);
5396 r = guestfs_umount_all (g);
5403 r = guestfs_lvm_remove_all (g);
5407 /* TestOutputFalse for blockdev_setrw (0) */
5409 char device[] = "/dev/sda";
5410 device[5] = devchar;
5413 r = guestfs_blockdev_setrw (g, device);
5418 char device[] = "/dev/sda";
5419 device[5] = devchar;
5422 r = guestfs_blockdev_getro (g, device);
5426 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
5433 static int test_blockdev_setro_0 (void)
5435 /* InitNone|InitEmpty for test_blockdev_setro_0 */
5437 char device[] = "/dev/sda";
5438 device[5] = devchar;
5441 r = guestfs_blockdev_setrw (g, device);
5448 r = guestfs_umount_all (g);
5455 r = guestfs_lvm_remove_all (g);
5459 /* TestOutputTrue for blockdev_setro (0) */
5461 char device[] = "/dev/sda";
5462 device[5] = devchar;
5465 r = guestfs_blockdev_setro (g, device);
5470 char device[] = "/dev/sda";
5471 device[5] = devchar;
5474 r = guestfs_blockdev_getro (g, device);
5478 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
5485 static int test_statvfs_0 (void)
5487 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5489 char device[] = "/dev/sda";
5490 device[5] = devchar;
5493 r = guestfs_blockdev_setrw (g, device);
5500 r = guestfs_umount_all (g);
5507 r = guestfs_lvm_remove_all (g);
5512 char device[] = "/dev/sda";
5513 device[5] = devchar;
5514 char lines_0[] = ",";
5521 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5526 char fstype[] = "ext2";
5527 char device[] = "/dev/sda1";
5528 device[5] = devchar;
5531 r = guestfs_mkfs (g, fstype, device);
5536 char device[] = "/dev/sda1";
5537 device[5] = devchar;
5538 char mountpoint[] = "/";
5541 r = guestfs_mount (g, device, mountpoint);
5545 /* TestOutputStruct for statvfs (0) */
5548 struct guestfs_statvfs *r;
5550 r = guestfs_statvfs (g, path);
5553 if (r->bfree != 487702) {
5554 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5558 if (r->blocks != 490020) {
5559 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5563 if (r->bsize != 1024) {
5564 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5573 static int test_lstat_0 (void)
5575 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5577 char device[] = "/dev/sda";
5578 device[5] = devchar;
5581 r = guestfs_blockdev_setrw (g, device);
5588 r = guestfs_umount_all (g);
5595 r = guestfs_lvm_remove_all (g);
5600 char device[] = "/dev/sda";
5601 device[5] = devchar;
5602 char lines_0[] = ",";
5609 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5614 char fstype[] = "ext2";
5615 char device[] = "/dev/sda1";
5616 device[5] = devchar;
5619 r = guestfs_mkfs (g, fstype, device);
5624 char device[] = "/dev/sda1";
5625 device[5] = devchar;
5626 char mountpoint[] = "/";
5629 r = guestfs_mount (g, device, mountpoint);
5633 /* TestOutputStruct for lstat (0) */
5635 char path[] = "/new";
5638 r = guestfs_touch (g, path);
5643 char path[] = "/new";
5644 struct guestfs_stat *r;
5646 r = guestfs_lstat (g, path);
5650 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5659 static int test_stat_0 (void)
5661 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5663 char device[] = "/dev/sda";
5664 device[5] = devchar;
5667 r = guestfs_blockdev_setrw (g, device);
5674 r = guestfs_umount_all (g);
5681 r = guestfs_lvm_remove_all (g);
5686 char device[] = "/dev/sda";
5687 device[5] = devchar;
5688 char lines_0[] = ",";
5695 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5700 char fstype[] = "ext2";
5701 char device[] = "/dev/sda1";
5702 device[5] = devchar;
5705 r = guestfs_mkfs (g, fstype, device);
5710 char device[] = "/dev/sda1";
5711 device[5] = devchar;
5712 char mountpoint[] = "/";
5715 r = guestfs_mount (g, device, mountpoint);
5719 /* TestOutputStruct for stat (0) */
5721 char path[] = "/new";
5724 r = guestfs_touch (g, path);
5729 char path[] = "/new";
5730 struct guestfs_stat *r;
5732 r = guestfs_stat (g, path);
5736 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5745 static int test_command_lines_0_prereq (void)
5747 const char *str = getenv ("SKIP_TEST_COMMAND");
5748 return str && strcmp (str, "1") == 0;
5751 static int test_command_lines_0 (void)
5753 if (! test_command_lines_0_prereq ()) {
5754 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5756 char device[] = "/dev/sda";
5757 device[5] = devchar;
5760 r = guestfs_blockdev_setrw (g, device);
5767 r = guestfs_umount_all (g);
5774 r = guestfs_lvm_remove_all (g);
5779 char device[] = "/dev/sda";
5780 device[5] = devchar;
5781 char lines_0[] = ",";
5788 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5793 char fstype[] = "ext2";
5794 char device[] = "/dev/sda1";
5795 device[5] = devchar;
5798 r = guestfs_mkfs (g, fstype, device);
5803 char device[] = "/dev/sda1";
5804 device[5] = devchar;
5805 char mountpoint[] = "/";
5808 r = guestfs_mount (g, device, mountpoint);
5812 /* TestOutputList for command_lines (0) */
5814 char remotefilename[] = "/test-command";
5817 r = guestfs_upload (g, "test-command", remotefilename);
5822 char path[] = "/test-command";
5825 r = guestfs_chmod (g, 493, path);
5830 char arguments_0[] = "/test-command";
5831 char arguments_1[] = "1";
5832 char *arguments[] = {
5840 r = guestfs_command_lines (g, arguments);
5844 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5849 char expected[] = "Result1";
5850 if (strcmp (r[0], expected) != 0) {
5851 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5856 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5860 for (i = 0; r[i] != NULL; ++i)
5865 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5869 static int test_command_lines_1_prereq (void)
5871 const char *str = getenv ("SKIP_TEST_COMMAND");
5872 return str && strcmp (str, "1") == 0;
5875 static int test_command_lines_1 (void)
5877 if (! test_command_lines_1_prereq ()) {
5878 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5880 char device[] = "/dev/sda";
5881 device[5] = devchar;
5884 r = guestfs_blockdev_setrw (g, device);
5891 r = guestfs_umount_all (g);
5898 r = guestfs_lvm_remove_all (g);
5903 char device[] = "/dev/sda";
5904 device[5] = devchar;
5905 char lines_0[] = ",";
5912 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5917 char fstype[] = "ext2";
5918 char device[] = "/dev/sda1";
5919 device[5] = devchar;
5922 r = guestfs_mkfs (g, fstype, device);
5927 char device[] = "/dev/sda1";
5928 device[5] = devchar;
5929 char mountpoint[] = "/";
5932 r = guestfs_mount (g, device, mountpoint);
5936 /* TestOutputList for command_lines (1) */
5938 char remotefilename[] = "/test-command";
5941 r = guestfs_upload (g, "test-command", remotefilename);
5946 char path[] = "/test-command";
5949 r = guestfs_chmod (g, 493, path);
5954 char arguments_0[] = "/test-command";
5955 char arguments_1[] = "2";
5956 char *arguments[] = {
5964 r = guestfs_command_lines (g, arguments);
5968 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5973 char expected[] = "Result2";
5974 if (strcmp (r[0], expected) != 0) {
5975 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5980 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5984 for (i = 0; r[i] != NULL; ++i)
5989 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5993 static int test_command_lines_2_prereq (void)
5995 const char *str = getenv ("SKIP_TEST_COMMAND");
5996 return str && strcmp (str, "1") == 0;
5999 static int test_command_lines_2 (void)
6001 if (! test_command_lines_2_prereq ()) {
6002 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
6004 char device[] = "/dev/sda";
6005 device[5] = devchar;
6008 r = guestfs_blockdev_setrw (g, device);
6015 r = guestfs_umount_all (g);
6022 r = guestfs_lvm_remove_all (g);
6027 char device[] = "/dev/sda";
6028 device[5] = devchar;
6029 char lines_0[] = ",";
6036 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6041 char fstype[] = "ext2";
6042 char device[] = "/dev/sda1";
6043 device[5] = devchar;
6046 r = guestfs_mkfs (g, fstype, device);
6051 char device[] = "/dev/sda1";
6052 device[5] = devchar;
6053 char mountpoint[] = "/";
6056 r = guestfs_mount (g, device, mountpoint);
6060 /* TestOutputList for command_lines (2) */
6062 char remotefilename[] = "/test-command";
6065 r = guestfs_upload (g, "test-command", remotefilename);
6070 char path[] = "/test-command";
6073 r = guestfs_chmod (g, 493, path);
6078 char arguments_0[] = "/test-command";
6079 char arguments_1[] = "3";
6080 char *arguments[] = {
6088 r = guestfs_command_lines (g, arguments);
6092 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6097 char expected[] = "";
6098 if (strcmp (r[0], expected) != 0) {
6099 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6104 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6109 char expected[] = "Result3";
6110 if (strcmp (r[1], expected) != 0) {
6111 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6116 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
6120 for (i = 0; r[i] != NULL; ++i)
6125 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
6129 static int test_command_lines_3_prereq (void)
6131 const char *str = getenv ("SKIP_TEST_COMMAND");
6132 return str && strcmp (str, "1") == 0;
6135 static int test_command_lines_3 (void)
6137 if (! test_command_lines_3_prereq ()) {
6138 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
6140 char device[] = "/dev/sda";
6141 device[5] = devchar;
6144 r = guestfs_blockdev_setrw (g, device);
6151 r = guestfs_umount_all (g);
6158 r = guestfs_lvm_remove_all (g);
6163 char device[] = "/dev/sda";
6164 device[5] = devchar;
6165 char lines_0[] = ",";
6172 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6177 char fstype[] = "ext2";
6178 char device[] = "/dev/sda1";
6179 device[5] = devchar;
6182 r = guestfs_mkfs (g, fstype, device);
6187 char device[] = "/dev/sda1";
6188 device[5] = devchar;
6189 char mountpoint[] = "/";
6192 r = guestfs_mount (g, device, mountpoint);
6196 /* TestOutputList for command_lines (3) */
6198 char remotefilename[] = "/test-command";
6201 r = guestfs_upload (g, "test-command", remotefilename);
6206 char path[] = "/test-command";
6209 r = guestfs_chmod (g, 493, path);
6214 char arguments_0[] = "/test-command";
6215 char arguments_1[] = "4";
6216 char *arguments[] = {
6224 r = guestfs_command_lines (g, arguments);
6228 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6233 char expected[] = "";
6234 if (strcmp (r[0], expected) != 0) {
6235 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6240 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6245 char expected[] = "Result4";
6246 if (strcmp (r[1], expected) != 0) {
6247 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6252 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
6256 for (i = 0; r[i] != NULL; ++i)
6261 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
6265 static int test_command_lines_4_prereq (void)
6267 const char *str = getenv ("SKIP_TEST_COMMAND");
6268 return str && strcmp (str, "1") == 0;
6271 static int test_command_lines_4 (void)
6273 if (! test_command_lines_4_prereq ()) {
6274 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
6276 char device[] = "/dev/sda";
6277 device[5] = devchar;
6280 r = guestfs_blockdev_setrw (g, device);
6287 r = guestfs_umount_all (g);
6294 r = guestfs_lvm_remove_all (g);
6299 char device[] = "/dev/sda";
6300 device[5] = devchar;
6301 char lines_0[] = ",";
6308 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6313 char fstype[] = "ext2";
6314 char device[] = "/dev/sda1";
6315 device[5] = devchar;
6318 r = guestfs_mkfs (g, fstype, device);
6323 char device[] = "/dev/sda1";
6324 device[5] = devchar;
6325 char mountpoint[] = "/";
6328 r = guestfs_mount (g, device, mountpoint);
6332 /* TestOutputList for command_lines (4) */
6334 char remotefilename[] = "/test-command";
6337 r = guestfs_upload (g, "test-command", remotefilename);
6342 char path[] = "/test-command";
6345 r = guestfs_chmod (g, 493, path);
6350 char arguments_0[] = "/test-command";
6351 char arguments_1[] = "5";
6352 char *arguments[] = {
6360 r = guestfs_command_lines (g, arguments);
6364 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6369 char expected[] = "";
6370 if (strcmp (r[0], expected) != 0) {
6371 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6376 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6381 char expected[] = "Result5";
6382 if (strcmp (r[1], expected) != 0) {
6383 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6388 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6393 char expected[] = "";
6394 if (strcmp (r[2], expected) != 0) {
6395 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6400 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
6404 for (i = 0; r[i] != NULL; ++i)
6409 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
6413 static int test_command_lines_5_prereq (void)
6415 const char *str = getenv ("SKIP_TEST_COMMAND");
6416 return str && strcmp (str, "1") == 0;
6419 static int test_command_lines_5 (void)
6421 if (! test_command_lines_5_prereq ()) {
6422 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
6424 char device[] = "/dev/sda";
6425 device[5] = devchar;
6428 r = guestfs_blockdev_setrw (g, device);
6435 r = guestfs_umount_all (g);
6442 r = guestfs_lvm_remove_all (g);
6447 char device[] = "/dev/sda";
6448 device[5] = devchar;
6449 char lines_0[] = ",";
6456 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6461 char fstype[] = "ext2";
6462 char device[] = "/dev/sda1";
6463 device[5] = devchar;
6466 r = guestfs_mkfs (g, fstype, device);
6471 char device[] = "/dev/sda1";
6472 device[5] = devchar;
6473 char mountpoint[] = "/";
6476 r = guestfs_mount (g, device, mountpoint);
6480 /* TestOutputList for command_lines (5) */
6482 char remotefilename[] = "/test-command";
6485 r = guestfs_upload (g, "test-command", remotefilename);
6490 char path[] = "/test-command";
6493 r = guestfs_chmod (g, 493, path);
6498 char arguments_0[] = "/test-command";
6499 char arguments_1[] = "6";
6500 char *arguments[] = {
6508 r = guestfs_command_lines (g, arguments);
6512 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6517 char expected[] = "";
6518 if (strcmp (r[0], expected) != 0) {
6519 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6524 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6529 char expected[] = "";
6530 if (strcmp (r[1], expected) != 0) {
6531 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6536 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6541 char expected[] = "Result6";
6542 if (strcmp (r[2], expected) != 0) {
6543 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6548 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6553 char expected[] = "";
6554 if (strcmp (r[3], expected) != 0) {
6555 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6560 fprintf (stderr, "test_command_lines_5: 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_5");
6573 static int test_command_lines_6_prereq (void)
6575 const char *str = getenv ("SKIP_TEST_COMMAND");
6576 return str && strcmp (str, "1") == 0;
6579 static int test_command_lines_6 (void)
6581 if (! test_command_lines_6_prereq ()) {
6582 /* InitBasicFS for test_command_lines_6: 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 (6) */
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[] = "7";
6660 char *arguments[] = {
6668 r = guestfs_command_lines (g, arguments);
6672 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6676 for (i = 0; r[i] != NULL; ++i)
6681 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6685 static int test_command_lines_7_prereq (void)
6687 const char *str = getenv ("SKIP_TEST_COMMAND");
6688 return str && strcmp (str, "1") == 0;
6691 static int test_command_lines_7 (void)
6693 if (! test_command_lines_7_prereq ()) {
6694 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6696 char device[] = "/dev/sda";
6697 device[5] = devchar;
6700 r = guestfs_blockdev_setrw (g, device);
6707 r = guestfs_umount_all (g);
6714 r = guestfs_lvm_remove_all (g);
6719 char device[] = "/dev/sda";
6720 device[5] = devchar;
6721 char lines_0[] = ",";
6728 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6733 char fstype[] = "ext2";
6734 char device[] = "/dev/sda1";
6735 device[5] = devchar;
6738 r = guestfs_mkfs (g, fstype, device);
6743 char device[] = "/dev/sda1";
6744 device[5] = devchar;
6745 char mountpoint[] = "/";
6748 r = guestfs_mount (g, device, mountpoint);
6752 /* TestOutputList for command_lines (7) */
6754 char remotefilename[] = "/test-command";
6757 r = guestfs_upload (g, "test-command", remotefilename);
6762 char path[] = "/test-command";
6765 r = guestfs_chmod (g, 493, path);
6770 char arguments_0[] = "/test-command";
6771 char arguments_1[] = "8";
6772 char *arguments[] = {
6780 r = guestfs_command_lines (g, arguments);
6784 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6789 char expected[] = "";
6790 if (strcmp (r[0], expected) != 0) {
6791 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6796 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6800 for (i = 0; r[i] != NULL; ++i)
6805 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6809 static int test_command_lines_8_prereq (void)
6811 const char *str = getenv ("SKIP_TEST_COMMAND");
6812 return str && strcmp (str, "1") == 0;
6815 static int test_command_lines_8 (void)
6817 if (! test_command_lines_8_prereq ()) {
6818 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6820 char device[] = "/dev/sda";
6821 device[5] = devchar;
6824 r = guestfs_blockdev_setrw (g, device);
6831 r = guestfs_umount_all (g);
6838 r = guestfs_lvm_remove_all (g);
6843 char device[] = "/dev/sda";
6844 device[5] = devchar;
6845 char lines_0[] = ",";
6852 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6857 char fstype[] = "ext2";
6858 char device[] = "/dev/sda1";
6859 device[5] = devchar;
6862 r = guestfs_mkfs (g, fstype, device);
6867 char device[] = "/dev/sda1";
6868 device[5] = devchar;
6869 char mountpoint[] = "/";
6872 r = guestfs_mount (g, device, mountpoint);
6876 /* TestOutputList for command_lines (8) */
6878 char remotefilename[] = "/test-command";
6881 r = guestfs_upload (g, "test-command", remotefilename);
6886 char path[] = "/test-command";
6889 r = guestfs_chmod (g, 493, path);
6894 char arguments_0[] = "/test-command";
6895 char arguments_1[] = "9";
6896 char *arguments[] = {
6904 r = guestfs_command_lines (g, arguments);
6908 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6913 char expected[] = "";
6914 if (strcmp (r[0], expected) != 0) {
6915 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6920 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6925 char expected[] = "";
6926 if (strcmp (r[1], expected) != 0) {
6927 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6932 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6936 for (i = 0; r[i] != NULL; ++i)
6941 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6945 static int test_command_lines_9_prereq (void)
6947 const char *str = getenv ("SKIP_TEST_COMMAND");
6948 return str && strcmp (str, "1") == 0;
6951 static int test_command_lines_9 (void)
6953 if (! test_command_lines_9_prereq ()) {
6954 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6956 char device[] = "/dev/sda";
6957 device[5] = devchar;
6960 r = guestfs_blockdev_setrw (g, device);
6967 r = guestfs_umount_all (g);
6974 r = guestfs_lvm_remove_all (g);
6979 char device[] = "/dev/sda";
6980 device[5] = devchar;
6981 char lines_0[] = ",";
6988 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6993 char fstype[] = "ext2";
6994 char device[] = "/dev/sda1";
6995 device[5] = devchar;
6998 r = guestfs_mkfs (g, fstype, device);
7003 char device[] = "/dev/sda1";
7004 device[5] = devchar;
7005 char mountpoint[] = "/";
7008 r = guestfs_mount (g, device, mountpoint);
7012 /* TestOutputList for command_lines (9) */
7014 char remotefilename[] = "/test-command";
7017 r = guestfs_upload (g, "test-command", remotefilename);
7022 char path[] = "/test-command";
7025 r = guestfs_chmod (g, 493, path);
7030 char arguments_0[] = "/test-command";
7031 char arguments_1[] = "10";
7032 char *arguments[] = {
7040 r = guestfs_command_lines (g, arguments);
7044 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7049 char expected[] = "Result10-1";
7050 if (strcmp (r[0], expected) != 0) {
7051 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7056 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7061 char expected[] = "Result10-2";
7062 if (strcmp (r[1], expected) != 0) {
7063 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7068 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
7072 for (i = 0; r[i] != NULL; ++i)
7077 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
7081 static int test_command_lines_10_prereq (void)
7083 const char *str = getenv ("SKIP_TEST_COMMAND");
7084 return str && strcmp (str, "1") == 0;
7087 static int test_command_lines_10 (void)
7089 if (! test_command_lines_10_prereq ()) {
7090 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
7092 char device[] = "/dev/sda";
7093 device[5] = devchar;
7096 r = guestfs_blockdev_setrw (g, device);
7103 r = guestfs_umount_all (g);
7110 r = guestfs_lvm_remove_all (g);
7115 char device[] = "/dev/sda";
7116 device[5] = devchar;
7117 char lines_0[] = ",";
7124 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7129 char fstype[] = "ext2";
7130 char device[] = "/dev/sda1";
7131 device[5] = devchar;
7134 r = guestfs_mkfs (g, fstype, device);
7139 char device[] = "/dev/sda1";
7140 device[5] = devchar;
7141 char mountpoint[] = "/";
7144 r = guestfs_mount (g, device, mountpoint);
7148 /* TestOutputList for command_lines (10) */
7150 char remotefilename[] = "/test-command";
7153 r = guestfs_upload (g, "test-command", remotefilename);
7158 char path[] = "/test-command";
7161 r = guestfs_chmod (g, 493, path);
7166 char arguments_0[] = "/test-command";
7167 char arguments_1[] = "11";
7168 char *arguments[] = {
7176 r = guestfs_command_lines (g, arguments);
7180 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7185 char expected[] = "Result11-1";
7186 if (strcmp (r[0], expected) != 0) {
7187 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7192 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7197 char expected[] = "Result11-2";
7198 if (strcmp (r[1], expected) != 0) {
7199 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7204 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
7208 for (i = 0; r[i] != NULL; ++i)
7213 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
7217 static int test_command_0_prereq (void)
7219 const char *str = getenv ("SKIP_TEST_COMMAND");
7220 return str && strcmp (str, "1") == 0;
7223 static int test_command_0 (void)
7225 if (! test_command_0_prereq ()) {
7226 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
7228 char device[] = "/dev/sda";
7229 device[5] = devchar;
7232 r = guestfs_blockdev_setrw (g, device);
7239 r = guestfs_umount_all (g);
7246 r = guestfs_lvm_remove_all (g);
7251 char device[] = "/dev/sda";
7252 device[5] = devchar;
7253 char lines_0[] = ",";
7260 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7265 char fstype[] = "ext2";
7266 char device[] = "/dev/sda1";
7267 device[5] = devchar;
7270 r = guestfs_mkfs (g, fstype, device);
7275 char device[] = "/dev/sda1";
7276 device[5] = devchar;
7277 char mountpoint[] = "/";
7280 r = guestfs_mount (g, device, mountpoint);
7284 /* TestOutput for command (0) */
7285 char expected[] = "Result1";
7287 char remotefilename[] = "/test-command";
7290 r = guestfs_upload (g, "test-command", remotefilename);
7295 char path[] = "/test-command";
7298 r = guestfs_chmod (g, 493, path);
7303 char arguments_0[] = "/test-command";
7304 char arguments_1[] = "1";
7305 char *arguments[] = {
7312 r = guestfs_command (g, arguments);
7315 if (strcmp (r, expected) != 0) {
7316 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
7322 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
7326 static int test_command_1_prereq (void)
7328 const char *str = getenv ("SKIP_TEST_COMMAND");
7329 return str && strcmp (str, "1") == 0;
7332 static int test_command_1 (void)
7334 if (! test_command_1_prereq ()) {
7335 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
7337 char device[] = "/dev/sda";
7338 device[5] = devchar;
7341 r = guestfs_blockdev_setrw (g, device);
7348 r = guestfs_umount_all (g);
7355 r = guestfs_lvm_remove_all (g);
7360 char device[] = "/dev/sda";
7361 device[5] = devchar;
7362 char lines_0[] = ",";
7369 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7374 char fstype[] = "ext2";
7375 char device[] = "/dev/sda1";
7376 device[5] = devchar;
7379 r = guestfs_mkfs (g, fstype, device);
7384 char device[] = "/dev/sda1";
7385 device[5] = devchar;
7386 char mountpoint[] = "/";
7389 r = guestfs_mount (g, device, mountpoint);
7393 /* TestOutput for command (1) */
7394 char expected[] = "Result2\n";
7396 char remotefilename[] = "/test-command";
7399 r = guestfs_upload (g, "test-command", remotefilename);
7404 char path[] = "/test-command";
7407 r = guestfs_chmod (g, 493, path);
7412 char arguments_0[] = "/test-command";
7413 char arguments_1[] = "2";
7414 char *arguments[] = {
7421 r = guestfs_command (g, arguments);
7424 if (strcmp (r, expected) != 0) {
7425 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
7431 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
7435 static int test_command_2_prereq (void)
7437 const char *str = getenv ("SKIP_TEST_COMMAND");
7438 return str && strcmp (str, "1") == 0;
7441 static int test_command_2 (void)
7443 if (! test_command_2_prereq ()) {
7444 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
7446 char device[] = "/dev/sda";
7447 device[5] = devchar;
7450 r = guestfs_blockdev_setrw (g, device);
7457 r = guestfs_umount_all (g);
7464 r = guestfs_lvm_remove_all (g);
7469 char device[] = "/dev/sda";
7470 device[5] = devchar;
7471 char lines_0[] = ",";
7478 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7483 char fstype[] = "ext2";
7484 char device[] = "/dev/sda1";
7485 device[5] = devchar;
7488 r = guestfs_mkfs (g, fstype, device);
7493 char device[] = "/dev/sda1";
7494 device[5] = devchar;
7495 char mountpoint[] = "/";
7498 r = guestfs_mount (g, device, mountpoint);
7502 /* TestOutput for command (2) */
7503 char expected[] = "\nResult3";
7505 char remotefilename[] = "/test-command";
7508 r = guestfs_upload (g, "test-command", remotefilename);
7513 char path[] = "/test-command";
7516 r = guestfs_chmod (g, 493, path);
7521 char arguments_0[] = "/test-command";
7522 char arguments_1[] = "3";
7523 char *arguments[] = {
7530 r = guestfs_command (g, arguments);
7533 if (strcmp (r, expected) != 0) {
7534 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7540 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7544 static int test_command_3_prereq (void)
7546 const char *str = getenv ("SKIP_TEST_COMMAND");
7547 return str && strcmp (str, "1") == 0;
7550 static int test_command_3 (void)
7552 if (! test_command_3_prereq ()) {
7553 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7555 char device[] = "/dev/sda";
7556 device[5] = devchar;
7559 r = guestfs_blockdev_setrw (g, device);
7566 r = guestfs_umount_all (g);
7573 r = guestfs_lvm_remove_all (g);
7578 char device[] = "/dev/sda";
7579 device[5] = devchar;
7580 char lines_0[] = ",";
7587 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7592 char fstype[] = "ext2";
7593 char device[] = "/dev/sda1";
7594 device[5] = devchar;
7597 r = guestfs_mkfs (g, fstype, device);
7602 char device[] = "/dev/sda1";
7603 device[5] = devchar;
7604 char mountpoint[] = "/";
7607 r = guestfs_mount (g, device, mountpoint);
7611 /* TestOutput for command (3) */
7612 char expected[] = "\nResult4\n";
7614 char remotefilename[] = "/test-command";
7617 r = guestfs_upload (g, "test-command", remotefilename);
7622 char path[] = "/test-command";
7625 r = guestfs_chmod (g, 493, path);
7630 char arguments_0[] = "/test-command";
7631 char arguments_1[] = "4";
7632 char *arguments[] = {
7639 r = guestfs_command (g, arguments);
7642 if (strcmp (r, expected) != 0) {
7643 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7649 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7653 static int test_command_4_prereq (void)
7655 const char *str = getenv ("SKIP_TEST_COMMAND");
7656 return str && strcmp (str, "1") == 0;
7659 static int test_command_4 (void)
7661 if (! test_command_4_prereq ()) {
7662 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7664 char device[] = "/dev/sda";
7665 device[5] = devchar;
7668 r = guestfs_blockdev_setrw (g, device);
7675 r = guestfs_umount_all (g);
7682 r = guestfs_lvm_remove_all (g);
7687 char device[] = "/dev/sda";
7688 device[5] = devchar;
7689 char lines_0[] = ",";
7696 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7701 char fstype[] = "ext2";
7702 char device[] = "/dev/sda1";
7703 device[5] = devchar;
7706 r = guestfs_mkfs (g, fstype, device);
7711 char device[] = "/dev/sda1";
7712 device[5] = devchar;
7713 char mountpoint[] = "/";
7716 r = guestfs_mount (g, device, mountpoint);
7720 /* TestOutput for command (4) */
7721 char expected[] = "\nResult5\n\n";
7723 char remotefilename[] = "/test-command";
7726 r = guestfs_upload (g, "test-command", remotefilename);
7731 char path[] = "/test-command";
7734 r = guestfs_chmod (g, 493, path);
7739 char arguments_0[] = "/test-command";
7740 char arguments_1[] = "5";
7741 char *arguments[] = {
7748 r = guestfs_command (g, arguments);
7751 if (strcmp (r, expected) != 0) {
7752 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7758 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7762 static int test_command_5_prereq (void)
7764 const char *str = getenv ("SKIP_TEST_COMMAND");
7765 return str && strcmp (str, "1") == 0;
7768 static int test_command_5 (void)
7770 if (! test_command_5_prereq ()) {
7771 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7773 char device[] = "/dev/sda";
7774 device[5] = devchar;
7777 r = guestfs_blockdev_setrw (g, device);
7784 r = guestfs_umount_all (g);
7791 r = guestfs_lvm_remove_all (g);
7796 char device[] = "/dev/sda";
7797 device[5] = devchar;
7798 char lines_0[] = ",";
7805 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7810 char fstype[] = "ext2";
7811 char device[] = "/dev/sda1";
7812 device[5] = devchar;
7815 r = guestfs_mkfs (g, fstype, device);
7820 char device[] = "/dev/sda1";
7821 device[5] = devchar;
7822 char mountpoint[] = "/";
7825 r = guestfs_mount (g, device, mountpoint);
7829 /* TestOutput for command (5) */
7830 char expected[] = "\n\nResult6\n\n";
7832 char remotefilename[] = "/test-command";
7835 r = guestfs_upload (g, "test-command", remotefilename);
7840 char path[] = "/test-command";
7843 r = guestfs_chmod (g, 493, path);
7848 char arguments_0[] = "/test-command";
7849 char arguments_1[] = "6";
7850 char *arguments[] = {
7857 r = guestfs_command (g, arguments);
7860 if (strcmp (r, expected) != 0) {
7861 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7867 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7871 static int test_command_6_prereq (void)
7873 const char *str = getenv ("SKIP_TEST_COMMAND");
7874 return str && strcmp (str, "1") == 0;
7877 static int test_command_6 (void)
7879 if (! test_command_6_prereq ()) {
7880 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7882 char device[] = "/dev/sda";
7883 device[5] = devchar;
7886 r = guestfs_blockdev_setrw (g, device);
7893 r = guestfs_umount_all (g);
7900 r = guestfs_lvm_remove_all (g);
7905 char device[] = "/dev/sda";
7906 device[5] = devchar;
7907 char lines_0[] = ",";
7914 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7919 char fstype[] = "ext2";
7920 char device[] = "/dev/sda1";
7921 device[5] = devchar;
7924 r = guestfs_mkfs (g, fstype, device);
7929 char device[] = "/dev/sda1";
7930 device[5] = devchar;
7931 char mountpoint[] = "/";
7934 r = guestfs_mount (g, device, mountpoint);
7938 /* TestOutput for command (6) */
7939 char expected[] = "";
7941 char remotefilename[] = "/test-command";
7944 r = guestfs_upload (g, "test-command", remotefilename);
7949 char path[] = "/test-command";
7952 r = guestfs_chmod (g, 493, path);
7957 char arguments_0[] = "/test-command";
7958 char arguments_1[] = "7";
7959 char *arguments[] = {
7966 r = guestfs_command (g, arguments);
7969 if (strcmp (r, expected) != 0) {
7970 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7976 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7980 static int test_command_7_prereq (void)
7982 const char *str = getenv ("SKIP_TEST_COMMAND");
7983 return str && strcmp (str, "1") == 0;
7986 static int test_command_7 (void)
7988 if (! test_command_7_prereq ()) {
7989 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7991 char device[] = "/dev/sda";
7992 device[5] = devchar;
7995 r = guestfs_blockdev_setrw (g, device);
8002 r = guestfs_umount_all (g);
8009 r = guestfs_lvm_remove_all (g);
8014 char device[] = "/dev/sda";
8015 device[5] = devchar;
8016 char lines_0[] = ",";
8023 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8028 char fstype[] = "ext2";
8029 char device[] = "/dev/sda1";
8030 device[5] = devchar;
8033 r = guestfs_mkfs (g, fstype, device);
8038 char device[] = "/dev/sda1";
8039 device[5] = devchar;
8040 char mountpoint[] = "/";
8043 r = guestfs_mount (g, device, mountpoint);
8047 /* TestOutput for command (7) */
8048 char expected[] = "\n";
8050 char remotefilename[] = "/test-command";
8053 r = guestfs_upload (g, "test-command", remotefilename);
8058 char path[] = "/test-command";
8061 r = guestfs_chmod (g, 493, path);
8066 char arguments_0[] = "/test-command";
8067 char arguments_1[] = "8";
8068 char *arguments[] = {
8075 r = guestfs_command (g, arguments);
8078 if (strcmp (r, expected) != 0) {
8079 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
8085 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
8089 static int test_command_8_prereq (void)
8091 const char *str = getenv ("SKIP_TEST_COMMAND");
8092 return str && strcmp (str, "1") == 0;
8095 static int test_command_8 (void)
8097 if (! test_command_8_prereq ()) {
8098 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
8100 char device[] = "/dev/sda";
8101 device[5] = devchar;
8104 r = guestfs_blockdev_setrw (g, device);
8111 r = guestfs_umount_all (g);
8118 r = guestfs_lvm_remove_all (g);
8123 char device[] = "/dev/sda";
8124 device[5] = devchar;
8125 char lines_0[] = ",";
8132 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8137 char fstype[] = "ext2";
8138 char device[] = "/dev/sda1";
8139 device[5] = devchar;
8142 r = guestfs_mkfs (g, fstype, device);
8147 char device[] = "/dev/sda1";
8148 device[5] = devchar;
8149 char mountpoint[] = "/";
8152 r = guestfs_mount (g, device, mountpoint);
8156 /* TestOutput for command (8) */
8157 char expected[] = "\n\n";
8159 char remotefilename[] = "/test-command";
8162 r = guestfs_upload (g, "test-command", remotefilename);
8167 char path[] = "/test-command";
8170 r = guestfs_chmod (g, 493, path);
8175 char arguments_0[] = "/test-command";
8176 char arguments_1[] = "9";
8177 char *arguments[] = {
8184 r = guestfs_command (g, arguments);
8187 if (strcmp (r, expected) != 0) {
8188 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
8194 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
8198 static int test_command_9_prereq (void)
8200 const char *str = getenv ("SKIP_TEST_COMMAND");
8201 return str && strcmp (str, "1") == 0;
8204 static int test_command_9 (void)
8206 if (! test_command_9_prereq ()) {
8207 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
8209 char device[] = "/dev/sda";
8210 device[5] = devchar;
8213 r = guestfs_blockdev_setrw (g, device);
8220 r = guestfs_umount_all (g);
8227 r = guestfs_lvm_remove_all (g);
8232 char device[] = "/dev/sda";
8233 device[5] = devchar;
8234 char lines_0[] = ",";
8241 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8246 char fstype[] = "ext2";
8247 char device[] = "/dev/sda1";
8248 device[5] = devchar;
8251 r = guestfs_mkfs (g, fstype, device);
8256 char device[] = "/dev/sda1";
8257 device[5] = devchar;
8258 char mountpoint[] = "/";
8261 r = guestfs_mount (g, device, mountpoint);
8265 /* TestOutput for command (9) */
8266 char expected[] = "Result10-1\nResult10-2\n";
8268 char remotefilename[] = "/test-command";
8271 r = guestfs_upload (g, "test-command", remotefilename);
8276 char path[] = "/test-command";
8279 r = guestfs_chmod (g, 493, path);
8284 char arguments_0[] = "/test-command";
8285 char arguments_1[] = "10";
8286 char *arguments[] = {
8293 r = guestfs_command (g, arguments);
8296 if (strcmp (r, expected) != 0) {
8297 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
8303 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
8307 static int test_command_10_prereq (void)
8309 const char *str = getenv ("SKIP_TEST_COMMAND");
8310 return str && strcmp (str, "1") == 0;
8313 static int test_command_10 (void)
8315 if (! test_command_10_prereq ()) {
8316 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
8318 char device[] = "/dev/sda";
8319 device[5] = devchar;
8322 r = guestfs_blockdev_setrw (g, device);
8329 r = guestfs_umount_all (g);
8336 r = guestfs_lvm_remove_all (g);
8341 char device[] = "/dev/sda";
8342 device[5] = devchar;
8343 char lines_0[] = ",";
8350 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8355 char fstype[] = "ext2";
8356 char device[] = "/dev/sda1";
8357 device[5] = devchar;
8360 r = guestfs_mkfs (g, fstype, device);
8365 char device[] = "/dev/sda1";
8366 device[5] = devchar;
8367 char mountpoint[] = "/";
8370 r = guestfs_mount (g, device, mountpoint);
8374 /* TestOutput for command (10) */
8375 char expected[] = "Result11-1\nResult11-2";
8377 char remotefilename[] = "/test-command";
8380 r = guestfs_upload (g, "test-command", remotefilename);
8385 char path[] = "/test-command";
8388 r = guestfs_chmod (g, 493, path);
8393 char arguments_0[] = "/test-command";
8394 char arguments_1[] = "11";
8395 char *arguments[] = {
8402 r = guestfs_command (g, arguments);
8405 if (strcmp (r, expected) != 0) {
8406 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
8412 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
8416 static int test_command_11_prereq (void)
8418 const char *str = getenv ("SKIP_TEST_COMMAND");
8419 return str && strcmp (str, "1") == 0;
8422 static int test_command_11 (void)
8424 if (! test_command_11_prereq ()) {
8425 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
8427 char device[] = "/dev/sda";
8428 device[5] = devchar;
8431 r = guestfs_blockdev_setrw (g, device);
8438 r = guestfs_umount_all (g);
8445 r = guestfs_lvm_remove_all (g);
8450 char device[] = "/dev/sda";
8451 device[5] = devchar;
8452 char lines_0[] = ",";
8459 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8464 char fstype[] = "ext2";
8465 char device[] = "/dev/sda1";
8466 device[5] = devchar;
8469 r = guestfs_mkfs (g, fstype, device);
8474 char device[] = "/dev/sda1";
8475 device[5] = devchar;
8476 char mountpoint[] = "/";
8479 r = guestfs_mount (g, device, mountpoint);
8483 /* TestLastFail for command (11) */
8485 char remotefilename[] = "/test-command";
8488 r = guestfs_upload (g, "test-command", remotefilename);
8493 char path[] = "/test-command";
8496 r = guestfs_chmod (g, 493, path);
8501 char arguments_0[] = "/test-command";
8502 char *arguments[] = {
8508 r = guestfs_command (g, arguments);
8514 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8518 static int test_file_0 (void)
8520 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8522 char device[] = "/dev/sda";
8523 device[5] = devchar;
8526 r = guestfs_blockdev_setrw (g, device);
8533 r = guestfs_umount_all (g);
8540 r = guestfs_lvm_remove_all (g);
8545 char device[] = "/dev/sda";
8546 device[5] = devchar;
8547 char lines_0[] = ",";
8554 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8559 char fstype[] = "ext2";
8560 char device[] = "/dev/sda1";
8561 device[5] = devchar;
8564 r = guestfs_mkfs (g, fstype, device);
8569 char device[] = "/dev/sda1";
8570 device[5] = devchar;
8571 char mountpoint[] = "/";
8574 r = guestfs_mount (g, device, mountpoint);
8578 /* TestOutput for file (0) */
8579 char expected[] = "empty";
8581 char path[] = "/new";
8584 r = guestfs_touch (g, path);
8589 char path[] = "/new";
8592 r = guestfs_file (g, path);
8595 if (strcmp (r, expected) != 0) {
8596 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8604 static int test_file_1 (void)
8606 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8608 char device[] = "/dev/sda";
8609 device[5] = devchar;
8612 r = guestfs_blockdev_setrw (g, device);
8619 r = guestfs_umount_all (g);
8626 r = guestfs_lvm_remove_all (g);
8631 char device[] = "/dev/sda";
8632 device[5] = devchar;
8633 char lines_0[] = ",";
8640 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8645 char fstype[] = "ext2";
8646 char device[] = "/dev/sda1";
8647 device[5] = devchar;
8650 r = guestfs_mkfs (g, fstype, device);
8655 char device[] = "/dev/sda1";
8656 device[5] = devchar;
8657 char mountpoint[] = "/";
8660 r = guestfs_mount (g, device, mountpoint);
8664 /* TestOutput for file (1) */
8665 char expected[] = "ASCII text";
8667 char path[] = "/new";
8668 char content[] = "some content\n";
8671 r = guestfs_write_file (g, path, content, 0);
8676 char path[] = "/new";
8679 r = guestfs_file (g, path);
8682 if (strcmp (r, expected) != 0) {
8683 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8691 static int test_file_2 (void)
8693 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8695 char device[] = "/dev/sda";
8696 device[5] = devchar;
8699 r = guestfs_blockdev_setrw (g, device);
8706 r = guestfs_umount_all (g);
8713 r = guestfs_lvm_remove_all (g);
8718 char device[] = "/dev/sda";
8719 device[5] = devchar;
8720 char lines_0[] = ",";
8727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8732 char fstype[] = "ext2";
8733 char device[] = "/dev/sda1";
8734 device[5] = devchar;
8737 r = guestfs_mkfs (g, fstype, device);
8742 char device[] = "/dev/sda1";
8743 device[5] = devchar;
8744 char mountpoint[] = "/";
8747 r = guestfs_mount (g, device, mountpoint);
8751 /* TestLastFail for file (2) */
8753 char path[] = "/nofile";
8756 r = guestfs_file (g, path);
8764 static int test_umount_all_0 (void)
8766 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8768 char device[] = "/dev/sda";
8769 device[5] = devchar;
8772 r = guestfs_blockdev_setrw (g, device);
8779 r = guestfs_umount_all (g);
8786 r = guestfs_lvm_remove_all (g);
8791 char device[] = "/dev/sda";
8792 device[5] = devchar;
8793 char lines_0[] = ",";
8800 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8805 char fstype[] = "ext2";
8806 char device[] = "/dev/sda1";
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);
8824 /* TestOutputList for umount_all (0) */
8828 r = guestfs_umount_all (g);
8836 r = guestfs_mounts (g);
8840 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8844 for (i = 0; r[i] != NULL; ++i)
8851 static int test_umount_all_1 (void)
8853 /* InitNone|InitEmpty for test_umount_all_1 */
8855 char device[] = "/dev/sda";
8856 device[5] = devchar;
8859 r = guestfs_blockdev_setrw (g, device);
8866 r = guestfs_umount_all (g);
8873 r = guestfs_lvm_remove_all (g);
8877 /* TestOutputList for umount_all (1) */
8879 char device[] = "/dev/sda";
8880 device[5] = devchar;
8881 char lines_0[] = ",10";
8882 char lines_1[] = ",20";
8883 char lines_2[] = ",";
8892 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8897 char fstype[] = "ext2";
8898 char device[] = "/dev/sda1";
8899 device[5] = devchar;
8902 r = guestfs_mkfs (g, fstype, device);
8907 char fstype[] = "ext2";
8908 char device[] = "/dev/sda2";
8909 device[5] = devchar;
8912 r = guestfs_mkfs (g, fstype, device);
8917 char fstype[] = "ext2";
8918 char device[] = "/dev/sda3";
8919 device[5] = devchar;
8922 r = guestfs_mkfs (g, fstype, device);
8927 char device[] = "/dev/sda1";
8928 device[5] = devchar;
8929 char mountpoint[] = "/";
8932 r = guestfs_mount (g, device, mountpoint);
8937 char path[] = "/mp1";
8940 r = guestfs_mkdir (g, path);
8945 char device[] = "/dev/sda2";
8946 device[5] = devchar;
8947 char mountpoint[] = "/mp1";
8950 r = guestfs_mount (g, device, mountpoint);
8955 char path[] = "/mp1/mp2";
8958 r = guestfs_mkdir (g, path);
8963 char device[] = "/dev/sda3";
8964 device[5] = devchar;
8965 char mountpoint[] = "/mp1/mp2";
8968 r = guestfs_mount (g, device, mountpoint);
8973 char path[] = "/mp1/mp2/mp3";
8976 r = guestfs_mkdir (g, path);
8983 r = guestfs_umount_all (g);
8991 r = guestfs_mounts (g);
8995 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8999 for (i = 0; r[i] != NULL; ++i)
9006 static int test_mounts_0 (void)
9008 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
9010 char device[] = "/dev/sda";
9011 device[5] = devchar;
9014 r = guestfs_blockdev_setrw (g, device);
9021 r = guestfs_umount_all (g);
9028 r = guestfs_lvm_remove_all (g);
9033 char device[] = "/dev/sda";
9034 device[5] = devchar;
9035 char lines_0[] = ",";
9042 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9047 char fstype[] = "ext2";
9048 char device[] = "/dev/sda1";
9049 device[5] = devchar;
9052 r = guestfs_mkfs (g, fstype, device);
9057 char device[] = "/dev/sda1";
9058 device[5] = devchar;
9059 char mountpoint[] = "/";
9062 r = guestfs_mount (g, device, mountpoint);
9066 /* TestOutputList for mounts (0) */
9071 r = guestfs_mounts (g);
9075 fprintf (stderr, "test_mounts_0: short list returned from command\n");
9080 char expected[] = "/dev/sda1";
9081 expected[5] = devchar;
9082 if (strcmp (r[0], expected) != 0) {
9083 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9088 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
9092 for (i = 0; r[i] != NULL; ++i)
9099 static int test_umount_0 (void)
9101 /* InitNone|InitEmpty for test_umount_0 */
9103 char device[] = "/dev/sda";
9104 device[5] = devchar;
9107 r = guestfs_blockdev_setrw (g, device);
9114 r = guestfs_umount_all (g);
9121 r = guestfs_lvm_remove_all (g);
9125 /* TestOutputList for umount (0) */
9127 char device[] = "/dev/sda";
9128 device[5] = devchar;
9129 char lines_0[] = ",";
9136 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9141 char fstype[] = "ext2";
9142 char device[] = "/dev/sda1";
9143 device[5] = devchar;
9146 r = guestfs_mkfs (g, fstype, device);
9151 char device[] = "/dev/sda1";
9152 device[5] = devchar;
9153 char mountpoint[] = "/";
9156 r = guestfs_mount (g, device, mountpoint);
9164 r = guestfs_mounts (g);
9168 fprintf (stderr, "test_umount_0: short list returned from command\n");
9173 char expected[] = "/dev/sda1";
9174 expected[5] = devchar;
9175 if (strcmp (r[0], expected) != 0) {
9176 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9181 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
9185 for (i = 0; r[i] != NULL; ++i)
9192 static int test_umount_1 (void)
9194 /* InitNone|InitEmpty for test_umount_1 */
9196 char device[] = "/dev/sda";
9197 device[5] = devchar;
9200 r = guestfs_blockdev_setrw (g, device);
9207 r = guestfs_umount_all (g);
9214 r = guestfs_lvm_remove_all (g);
9218 /* TestOutputList for umount (1) */
9220 char device[] = "/dev/sda";
9221 device[5] = devchar;
9222 char lines_0[] = ",";
9229 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9234 char fstype[] = "ext2";
9235 char device[] = "/dev/sda1";
9236 device[5] = devchar;
9239 r = guestfs_mkfs (g, fstype, device);
9244 char device[] = "/dev/sda1";
9245 device[5] = devchar;
9246 char mountpoint[] = "/";
9249 r = guestfs_mount (g, device, mountpoint);
9254 char pathordevice[] = "/";
9257 r = guestfs_umount (g, pathordevice);
9265 r = guestfs_mounts (g);
9269 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
9273 for (i = 0; r[i] != NULL; ++i)
9280 static int test_write_file_0 (void)
9282 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
9284 char device[] = "/dev/sda";
9285 device[5] = devchar;
9288 r = guestfs_blockdev_setrw (g, device);
9295 r = guestfs_umount_all (g);
9302 r = guestfs_lvm_remove_all (g);
9307 char device[] = "/dev/sda";
9308 device[5] = devchar;
9309 char lines_0[] = ",";
9316 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9321 char fstype[] = "ext2";
9322 char device[] = "/dev/sda1";
9323 device[5] = devchar;
9326 r = guestfs_mkfs (g, fstype, device);
9331 char device[] = "/dev/sda1";
9332 device[5] = devchar;
9333 char mountpoint[] = "/";
9336 r = guestfs_mount (g, device, mountpoint);
9340 /* TestOutput for write_file (0) */
9341 char expected[] = "new file contents";
9343 char path[] = "/new";
9344 char content[] = "new file contents";
9347 r = guestfs_write_file (g, path, content, 0);
9352 char path[] = "/new";
9355 r = guestfs_cat (g, path);
9358 if (strcmp (r, expected) != 0) {
9359 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9367 static int test_write_file_1 (void)
9369 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
9371 char device[] = "/dev/sda";
9372 device[5] = devchar;
9375 r = guestfs_blockdev_setrw (g, device);
9382 r = guestfs_umount_all (g);
9389 r = guestfs_lvm_remove_all (g);
9394 char device[] = "/dev/sda";
9395 device[5] = devchar;
9396 char lines_0[] = ",";
9403 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9408 char fstype[] = "ext2";
9409 char device[] = "/dev/sda1";
9410 device[5] = devchar;
9413 r = guestfs_mkfs (g, fstype, device);
9418 char device[] = "/dev/sda1";
9419 device[5] = devchar;
9420 char mountpoint[] = "/";
9423 r = guestfs_mount (g, device, mountpoint);
9427 /* TestOutput for write_file (1) */
9428 char expected[] = "\nnew file contents\n";
9430 char path[] = "/new";
9431 char content[] = "\nnew file contents\n";
9434 r = guestfs_write_file (g, path, content, 0);
9439 char path[] = "/new";
9442 r = guestfs_cat (g, path);
9445 if (strcmp (r, expected) != 0) {
9446 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9454 static int test_write_file_2 (void)
9456 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
9458 char device[] = "/dev/sda";
9459 device[5] = devchar;
9462 r = guestfs_blockdev_setrw (g, device);
9469 r = guestfs_umount_all (g);
9476 r = guestfs_lvm_remove_all (g);
9481 char device[] = "/dev/sda";
9482 device[5] = devchar;
9483 char lines_0[] = ",";
9490 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9495 char fstype[] = "ext2";
9496 char device[] = "/dev/sda1";
9497 device[5] = devchar;
9500 r = guestfs_mkfs (g, fstype, device);
9505 char device[] = "/dev/sda1";
9506 device[5] = devchar;
9507 char mountpoint[] = "/";
9510 r = guestfs_mount (g, device, mountpoint);
9514 /* TestOutput for write_file (2) */
9515 char expected[] = "\n\n";
9517 char path[] = "/new";
9518 char content[] = "\n\n";
9521 r = guestfs_write_file (g, path, content, 0);
9526 char path[] = "/new";
9529 r = guestfs_cat (g, path);
9532 if (strcmp (r, expected) != 0) {
9533 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9541 static int test_write_file_3 (void)
9543 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9545 char device[] = "/dev/sda";
9546 device[5] = devchar;
9549 r = guestfs_blockdev_setrw (g, device);
9556 r = guestfs_umount_all (g);
9563 r = guestfs_lvm_remove_all (g);
9568 char device[] = "/dev/sda";
9569 device[5] = devchar;
9570 char lines_0[] = ",";
9577 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9582 char fstype[] = "ext2";
9583 char device[] = "/dev/sda1";
9584 device[5] = devchar;
9587 r = guestfs_mkfs (g, fstype, device);
9592 char device[] = "/dev/sda1";
9593 device[5] = devchar;
9594 char mountpoint[] = "/";
9597 r = guestfs_mount (g, device, mountpoint);
9601 /* TestOutput for write_file (3) */
9602 char expected[] = "";
9604 char path[] = "/new";
9605 char content[] = "";
9608 r = guestfs_write_file (g, path, content, 0);
9613 char path[] = "/new";
9616 r = guestfs_cat (g, path);
9619 if (strcmp (r, expected) != 0) {
9620 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9628 static int test_write_file_4 (void)
9630 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9632 char device[] = "/dev/sda";
9633 device[5] = devchar;
9636 r = guestfs_blockdev_setrw (g, device);
9643 r = guestfs_umount_all (g);
9650 r = guestfs_lvm_remove_all (g);
9655 char device[] = "/dev/sda";
9656 device[5] = devchar;
9657 char lines_0[] = ",";
9664 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9669 char fstype[] = "ext2";
9670 char device[] = "/dev/sda1";
9671 device[5] = devchar;
9674 r = guestfs_mkfs (g, fstype, device);
9679 char device[] = "/dev/sda1";
9680 device[5] = devchar;
9681 char mountpoint[] = "/";
9684 r = guestfs_mount (g, device, mountpoint);
9688 /* TestOutput for write_file (4) */
9689 char expected[] = "\n\n\n";
9691 char path[] = "/new";
9692 char content[] = "\n\n\n";
9695 r = guestfs_write_file (g, path, content, 0);
9700 char path[] = "/new";
9703 r = guestfs_cat (g, path);
9706 if (strcmp (r, expected) != 0) {
9707 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9715 static int test_write_file_5 (void)
9717 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9719 char device[] = "/dev/sda";
9720 device[5] = devchar;
9723 r = guestfs_blockdev_setrw (g, device);
9730 r = guestfs_umount_all (g);
9737 r = guestfs_lvm_remove_all (g);
9742 char device[] = "/dev/sda";
9743 device[5] = devchar;
9744 char lines_0[] = ",";
9751 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9756 char fstype[] = "ext2";
9757 char device[] = "/dev/sda1";
9758 device[5] = devchar;
9761 r = guestfs_mkfs (g, fstype, device);
9766 char device[] = "/dev/sda1";
9767 device[5] = devchar;
9768 char mountpoint[] = "/";
9771 r = guestfs_mount (g, device, mountpoint);
9775 /* TestOutput for write_file (5) */
9776 char expected[] = "\n";
9778 char path[] = "/new";
9779 char content[] = "\n";
9782 r = guestfs_write_file (g, path, content, 0);
9787 char path[] = "/new";
9790 r = guestfs_cat (g, path);
9793 if (strcmp (r, expected) != 0) {
9794 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9802 static int test_mkfs_0 (void)
9804 /* InitNone|InitEmpty for test_mkfs_0 */
9806 char device[] = "/dev/sda";
9807 device[5] = devchar;
9810 r = guestfs_blockdev_setrw (g, device);
9817 r = guestfs_umount_all (g);
9824 r = guestfs_lvm_remove_all (g);
9828 /* TestOutput for mkfs (0) */
9829 char expected[] = "new file contents";
9831 char device[] = "/dev/sda";
9832 device[5] = devchar;
9833 char lines_0[] = ",";
9840 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9845 char fstype[] = "ext2";
9846 char device[] = "/dev/sda1";
9847 device[5] = devchar;
9850 r = guestfs_mkfs (g, fstype, device);
9855 char device[] = "/dev/sda1";
9856 device[5] = devchar;
9857 char mountpoint[] = "/";
9860 r = guestfs_mount (g, device, mountpoint);
9865 char path[] = "/new";
9866 char content[] = "new file contents";
9869 r = guestfs_write_file (g, path, content, 0);
9874 char path[] = "/new";
9877 r = guestfs_cat (g, path);
9880 if (strcmp (r, expected) != 0) {
9881 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9889 static int test_lvcreate_0 (void)
9891 /* InitNone|InitEmpty for test_lvcreate_0 */
9893 char device[] = "/dev/sda";
9894 device[5] = devchar;
9897 r = guestfs_blockdev_setrw (g, device);
9904 r = guestfs_umount_all (g);
9911 r = guestfs_lvm_remove_all (g);
9915 /* TestOutputList for lvcreate (0) */
9917 char device[] = "/dev/sda";
9918 device[5] = devchar;
9919 char lines_0[] = ",10";
9920 char lines_1[] = ",20";
9921 char lines_2[] = ",";
9930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9935 char device[] = "/dev/sda1";
9936 device[5] = devchar;
9939 r = guestfs_pvcreate (g, device);
9944 char device[] = "/dev/sda2";
9945 device[5] = devchar;
9948 r = guestfs_pvcreate (g, device);
9953 char device[] = "/dev/sda3";
9954 device[5] = devchar;
9957 r = guestfs_pvcreate (g, device);
9962 char volgroup[] = "VG1";
9963 char physvols_0[] = "/dev/sda1";
9964 physvols_0[5] = devchar;
9965 char physvols_1[] = "/dev/sda2";
9966 physvols_1[5] = devchar;
9967 char *physvols[] = {
9974 r = guestfs_vgcreate (g, volgroup, physvols);
9979 char volgroup[] = "VG2";
9980 char physvols_0[] = "/dev/sda3";
9981 physvols_0[5] = devchar;
9982 char *physvols[] = {
9988 r = guestfs_vgcreate (g, volgroup, physvols);
9993 char logvol[] = "LV1";
9994 char volgroup[] = "VG1";
9997 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10002 char logvol[] = "LV2";
10003 char volgroup[] = "VG1";
10005 suppress_error = 0;
10006 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10011 char logvol[] = "LV3";
10012 char volgroup[] = "VG2";
10014 suppress_error = 0;
10015 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10020 char logvol[] = "LV4";
10021 char volgroup[] = "VG2";
10023 suppress_error = 0;
10024 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10029 char logvol[] = "LV5";
10030 char volgroup[] = "VG2";
10032 suppress_error = 0;
10033 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10040 suppress_error = 0;
10041 r = guestfs_lvs (g);
10045 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10050 char expected[] = "/dev/VG1/LV1";
10051 if (strcmp (r[0], expected) != 0) {
10052 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10057 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10062 char expected[] = "/dev/VG1/LV2";
10063 if (strcmp (r[1], expected) != 0) {
10064 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10069 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10074 char expected[] = "/dev/VG2/LV3";
10075 if (strcmp (r[2], expected) != 0) {
10076 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10081 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10086 char expected[] = "/dev/VG2/LV4";
10087 if (strcmp (r[3], expected) != 0) {
10088 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10093 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10098 char expected[] = "/dev/VG2/LV5";
10099 if (strcmp (r[4], expected) != 0) {
10100 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
10104 if (r[5] != NULL) {
10105 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
10109 for (i = 0; r[i] != NULL; ++i)
10116 static int test_vgcreate_0 (void)
10118 /* InitNone|InitEmpty for test_vgcreate_0 */
10120 char device[] = "/dev/sda";
10121 device[5] = devchar;
10123 suppress_error = 0;
10124 r = guestfs_blockdev_setrw (g, device);
10130 suppress_error = 0;
10131 r = guestfs_umount_all (g);
10137 suppress_error = 0;
10138 r = guestfs_lvm_remove_all (g);
10142 /* TestOutputList for vgcreate (0) */
10144 char device[] = "/dev/sda";
10145 device[5] = devchar;
10146 char lines_0[] = ",10";
10147 char lines_1[] = ",20";
10148 char lines_2[] = ",";
10156 suppress_error = 0;
10157 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10162 char device[] = "/dev/sda1";
10163 device[5] = devchar;
10165 suppress_error = 0;
10166 r = guestfs_pvcreate (g, device);
10171 char device[] = "/dev/sda2";
10172 device[5] = devchar;
10174 suppress_error = 0;
10175 r = guestfs_pvcreate (g, device);
10180 char device[] = "/dev/sda3";
10181 device[5] = devchar;
10183 suppress_error = 0;
10184 r = guestfs_pvcreate (g, device);
10189 char volgroup[] = "VG1";
10190 char physvols_0[] = "/dev/sda1";
10191 physvols_0[5] = devchar;
10192 char physvols_1[] = "/dev/sda2";
10193 physvols_1[5] = devchar;
10194 char *physvols[] = {
10200 suppress_error = 0;
10201 r = guestfs_vgcreate (g, volgroup, physvols);
10206 char volgroup[] = "VG2";
10207 char physvols_0[] = "/dev/sda3";
10208 physvols_0[5] = devchar;
10209 char *physvols[] = {
10214 suppress_error = 0;
10215 r = guestfs_vgcreate (g, volgroup, physvols);
10222 suppress_error = 0;
10223 r = guestfs_vgs (g);
10227 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10232 char expected[] = "VG1";
10233 if (strcmp (r[0], expected) != 0) {
10234 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10239 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10244 char expected[] = "VG2";
10245 if (strcmp (r[1], expected) != 0) {
10246 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10250 if (r[2] != NULL) {
10251 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
10255 for (i = 0; r[i] != NULL; ++i)
10262 static int test_pvcreate_0 (void)
10264 /* InitNone|InitEmpty for test_pvcreate_0 */
10266 char device[] = "/dev/sda";
10267 device[5] = devchar;
10269 suppress_error = 0;
10270 r = guestfs_blockdev_setrw (g, device);
10276 suppress_error = 0;
10277 r = guestfs_umount_all (g);
10283 suppress_error = 0;
10284 r = guestfs_lvm_remove_all (g);
10288 /* TestOutputList for pvcreate (0) */
10290 char device[] = "/dev/sda";
10291 device[5] = devchar;
10292 char lines_0[] = ",10";
10293 char lines_1[] = ",20";
10294 char lines_2[] = ",";
10302 suppress_error = 0;
10303 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10308 char device[] = "/dev/sda1";
10309 device[5] = devchar;
10311 suppress_error = 0;
10312 r = guestfs_pvcreate (g, device);
10317 char device[] = "/dev/sda2";
10318 device[5] = devchar;
10320 suppress_error = 0;
10321 r = guestfs_pvcreate (g, device);
10326 char device[] = "/dev/sda3";
10327 device[5] = devchar;
10329 suppress_error = 0;
10330 r = guestfs_pvcreate (g, device);
10337 suppress_error = 0;
10338 r = guestfs_pvs (g);
10342 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10347 char expected[] = "/dev/sda1";
10348 expected[5] = devchar;
10349 if (strcmp (r[0], expected) != 0) {
10350 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10355 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10360 char expected[] = "/dev/sda2";
10361 expected[5] = devchar;
10362 if (strcmp (r[1], expected) != 0) {
10363 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10368 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10373 char expected[] = "/dev/sda3";
10374 expected[5] = devchar;
10375 if (strcmp (r[2], expected) != 0) {
10376 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10380 if (r[3] != NULL) {
10381 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
10385 for (i = 0; r[i] != NULL; ++i)
10392 static int test_is_dir_0 (void)
10394 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
10396 char device[] = "/dev/sda";
10397 device[5] = devchar;
10399 suppress_error = 0;
10400 r = guestfs_blockdev_setrw (g, device);
10406 suppress_error = 0;
10407 r = guestfs_umount_all (g);
10413 suppress_error = 0;
10414 r = guestfs_lvm_remove_all (g);
10419 char device[] = "/dev/sda";
10420 device[5] = devchar;
10421 char lines_0[] = ",";
10427 suppress_error = 0;
10428 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10433 char fstype[] = "ext2";
10434 char device[] = "/dev/sda1";
10435 device[5] = devchar;
10437 suppress_error = 0;
10438 r = guestfs_mkfs (g, fstype, device);
10443 char device[] = "/dev/sda1";
10444 device[5] = devchar;
10445 char mountpoint[] = "/";
10447 suppress_error = 0;
10448 r = guestfs_mount (g, device, mountpoint);
10452 /* TestOutputFalse for is_dir (0) */
10454 char path[] = "/new";
10456 suppress_error = 0;
10457 r = guestfs_touch (g, path);
10462 char path[] = "/new";
10464 suppress_error = 0;
10465 r = guestfs_is_dir (g, path);
10469 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
10476 static int test_is_dir_1 (void)
10478 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
10480 char device[] = "/dev/sda";
10481 device[5] = devchar;
10483 suppress_error = 0;
10484 r = guestfs_blockdev_setrw (g, device);
10490 suppress_error = 0;
10491 r = guestfs_umount_all (g);
10497 suppress_error = 0;
10498 r = guestfs_lvm_remove_all (g);
10503 char device[] = "/dev/sda";
10504 device[5] = devchar;
10505 char lines_0[] = ",";
10511 suppress_error = 0;
10512 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10517 char fstype[] = "ext2";
10518 char device[] = "/dev/sda1";
10519 device[5] = devchar;
10521 suppress_error = 0;
10522 r = guestfs_mkfs (g, fstype, device);
10527 char device[] = "/dev/sda1";
10528 device[5] = devchar;
10529 char mountpoint[] = "/";
10531 suppress_error = 0;
10532 r = guestfs_mount (g, device, mountpoint);
10536 /* TestOutputTrue for is_dir (1) */
10538 char path[] = "/new";
10540 suppress_error = 0;
10541 r = guestfs_mkdir (g, path);
10546 char path[] = "/new";
10548 suppress_error = 0;
10549 r = guestfs_is_dir (g, path);
10553 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10560 static int test_is_file_0 (void)
10562 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10564 char device[] = "/dev/sda";
10565 device[5] = devchar;
10567 suppress_error = 0;
10568 r = guestfs_blockdev_setrw (g, device);
10574 suppress_error = 0;
10575 r = guestfs_umount_all (g);
10581 suppress_error = 0;
10582 r = guestfs_lvm_remove_all (g);
10587 char device[] = "/dev/sda";
10588 device[5] = devchar;
10589 char lines_0[] = ",";
10595 suppress_error = 0;
10596 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10601 char fstype[] = "ext2";
10602 char device[] = "/dev/sda1";
10603 device[5] = devchar;
10605 suppress_error = 0;
10606 r = guestfs_mkfs (g, fstype, device);
10611 char device[] = "/dev/sda1";
10612 device[5] = devchar;
10613 char mountpoint[] = "/";
10615 suppress_error = 0;
10616 r = guestfs_mount (g, device, mountpoint);
10620 /* TestOutputTrue for is_file (0) */
10622 char path[] = "/new";
10624 suppress_error = 0;
10625 r = guestfs_touch (g, path);
10630 char path[] = "/new";
10632 suppress_error = 0;
10633 r = guestfs_is_file (g, path);
10637 fprintf (stderr, "test_is_file_0: expected true, got false\n");
10644 static int test_is_file_1 (void)
10646 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10648 char device[] = "/dev/sda";
10649 device[5] = devchar;
10651 suppress_error = 0;
10652 r = guestfs_blockdev_setrw (g, device);
10658 suppress_error = 0;
10659 r = guestfs_umount_all (g);
10665 suppress_error = 0;
10666 r = guestfs_lvm_remove_all (g);
10671 char device[] = "/dev/sda";
10672 device[5] = devchar;
10673 char lines_0[] = ",";
10679 suppress_error = 0;
10680 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10685 char fstype[] = "ext2";
10686 char device[] = "/dev/sda1";
10687 device[5] = devchar;
10689 suppress_error = 0;
10690 r = guestfs_mkfs (g, fstype, device);
10695 char device[] = "/dev/sda1";
10696 device[5] = devchar;
10697 char mountpoint[] = "/";
10699 suppress_error = 0;
10700 r = guestfs_mount (g, device, mountpoint);
10704 /* TestOutputFalse for is_file (1) */
10706 char path[] = "/new";
10708 suppress_error = 0;
10709 r = guestfs_mkdir (g, path);
10714 char path[] = "/new";
10716 suppress_error = 0;
10717 r = guestfs_is_file (g, path);
10721 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10728 static int test_exists_0 (void)
10730 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10732 char device[] = "/dev/sda";
10733 device[5] = devchar;
10735 suppress_error = 0;
10736 r = guestfs_blockdev_setrw (g, device);
10742 suppress_error = 0;
10743 r = guestfs_umount_all (g);
10749 suppress_error = 0;
10750 r = guestfs_lvm_remove_all (g);
10755 char device[] = "/dev/sda";
10756 device[5] = devchar;
10757 char lines_0[] = ",";
10763 suppress_error = 0;
10764 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10769 char fstype[] = "ext2";
10770 char device[] = "/dev/sda1";
10771 device[5] = devchar;
10773 suppress_error = 0;
10774 r = guestfs_mkfs (g, fstype, device);
10779 char device[] = "/dev/sda1";
10780 device[5] = devchar;
10781 char mountpoint[] = "/";
10783 suppress_error = 0;
10784 r = guestfs_mount (g, device, mountpoint);
10788 /* TestOutputTrue for exists (0) */
10790 char path[] = "/new";
10792 suppress_error = 0;
10793 r = guestfs_touch (g, path);
10798 char path[] = "/new";
10800 suppress_error = 0;
10801 r = guestfs_exists (g, path);
10805 fprintf (stderr, "test_exists_0: expected true, got false\n");
10812 static int test_exists_1 (void)
10814 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10816 char device[] = "/dev/sda";
10817 device[5] = devchar;
10819 suppress_error = 0;
10820 r = guestfs_blockdev_setrw (g, device);
10826 suppress_error = 0;
10827 r = guestfs_umount_all (g);
10833 suppress_error = 0;
10834 r = guestfs_lvm_remove_all (g);
10839 char device[] = "/dev/sda";
10840 device[5] = devchar;
10841 char lines_0[] = ",";
10847 suppress_error = 0;
10848 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10853 char fstype[] = "ext2";
10854 char device[] = "/dev/sda1";
10855 device[5] = devchar;
10857 suppress_error = 0;
10858 r = guestfs_mkfs (g, fstype, device);
10863 char device[] = "/dev/sda1";
10864 device[5] = devchar;
10865 char mountpoint[] = "/";
10867 suppress_error = 0;
10868 r = guestfs_mount (g, device, mountpoint);
10872 /* TestOutputTrue for exists (1) */
10874 char path[] = "/new";
10876 suppress_error = 0;
10877 r = guestfs_mkdir (g, path);
10882 char path[] = "/new";
10884 suppress_error = 0;
10885 r = guestfs_exists (g, path);
10889 fprintf (stderr, "test_exists_1: expected true, got false\n");
10896 static int test_mkdir_p_0 (void)
10898 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10900 char device[] = "/dev/sda";
10901 device[5] = devchar;
10903 suppress_error = 0;
10904 r = guestfs_blockdev_setrw (g, device);
10910 suppress_error = 0;
10911 r = guestfs_umount_all (g);
10917 suppress_error = 0;
10918 r = guestfs_lvm_remove_all (g);
10923 char device[] = "/dev/sda";
10924 device[5] = devchar;
10925 char lines_0[] = ",";
10931 suppress_error = 0;
10932 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10937 char fstype[] = "ext2";
10938 char device[] = "/dev/sda1";
10939 device[5] = devchar;
10941 suppress_error = 0;
10942 r = guestfs_mkfs (g, fstype, device);
10947 char device[] = "/dev/sda1";
10948 device[5] = devchar;
10949 char mountpoint[] = "/";
10951 suppress_error = 0;
10952 r = guestfs_mount (g, device, mountpoint);
10956 /* TestOutputTrue for mkdir_p (0) */
10958 char path[] = "/new/foo/bar";
10960 suppress_error = 0;
10961 r = guestfs_mkdir_p (g, path);
10966 char path[] = "/new/foo/bar";
10968 suppress_error = 0;
10969 r = guestfs_is_dir (g, path);
10973 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10980 static int test_mkdir_p_1 (void)
10982 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10984 char device[] = "/dev/sda";
10985 device[5] = devchar;
10987 suppress_error = 0;
10988 r = guestfs_blockdev_setrw (g, device);
10994 suppress_error = 0;
10995 r = guestfs_umount_all (g);
11001 suppress_error = 0;
11002 r = guestfs_lvm_remove_all (g);
11007 char device[] = "/dev/sda";
11008 device[5] = devchar;
11009 char lines_0[] = ",";
11015 suppress_error = 0;
11016 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11021 char fstype[] = "ext2";
11022 char device[] = "/dev/sda1";
11023 device[5] = devchar;
11025 suppress_error = 0;
11026 r = guestfs_mkfs (g, fstype, device);
11031 char device[] = "/dev/sda1";
11032 device[5] = devchar;
11033 char mountpoint[] = "/";
11035 suppress_error = 0;
11036 r = guestfs_mount (g, device, mountpoint);
11040 /* TestOutputTrue for mkdir_p (1) */
11042 char path[] = "/new/foo/bar";
11044 suppress_error = 0;
11045 r = guestfs_mkdir_p (g, path);
11050 char path[] = "/new/foo";
11052 suppress_error = 0;
11053 r = guestfs_is_dir (g, path);
11057 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
11064 static int test_mkdir_p_2 (void)
11066 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
11068 char device[] = "/dev/sda";
11069 device[5] = devchar;
11071 suppress_error = 0;
11072 r = guestfs_blockdev_setrw (g, device);
11078 suppress_error = 0;
11079 r = guestfs_umount_all (g);
11085 suppress_error = 0;
11086 r = guestfs_lvm_remove_all (g);
11091 char device[] = "/dev/sda";
11092 device[5] = devchar;
11093 char lines_0[] = ",";
11099 suppress_error = 0;
11100 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11105 char fstype[] = "ext2";
11106 char device[] = "/dev/sda1";
11107 device[5] = devchar;
11109 suppress_error = 0;
11110 r = guestfs_mkfs (g, fstype, device);
11115 char device[] = "/dev/sda1";
11116 device[5] = devchar;
11117 char mountpoint[] = "/";
11119 suppress_error = 0;
11120 r = guestfs_mount (g, device, mountpoint);
11124 /* TestOutputTrue for mkdir_p (2) */
11126 char path[] = "/new/foo/bar";
11128 suppress_error = 0;
11129 r = guestfs_mkdir_p (g, path);
11134 char path[] = "/new";
11136 suppress_error = 0;
11137 r = guestfs_is_dir (g, path);
11141 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
11148 static int test_mkdir_0 (void)
11150 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
11152 char device[] = "/dev/sda";
11153 device[5] = devchar;
11155 suppress_error = 0;
11156 r = guestfs_blockdev_setrw (g, device);
11162 suppress_error = 0;
11163 r = guestfs_umount_all (g);
11169 suppress_error = 0;
11170 r = guestfs_lvm_remove_all (g);
11175 char device[] = "/dev/sda";
11176 device[5] = devchar;
11177 char lines_0[] = ",";
11183 suppress_error = 0;
11184 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11189 char fstype[] = "ext2";
11190 char device[] = "/dev/sda1";
11191 device[5] = devchar;
11193 suppress_error = 0;
11194 r = guestfs_mkfs (g, fstype, device);
11199 char device[] = "/dev/sda1";
11200 device[5] = devchar;
11201 char mountpoint[] = "/";
11203 suppress_error = 0;
11204 r = guestfs_mount (g, device, mountpoint);
11208 /* TestOutputTrue for mkdir (0) */
11210 char path[] = "/new";
11212 suppress_error = 0;
11213 r = guestfs_mkdir (g, path);
11218 char path[] = "/new";
11220 suppress_error = 0;
11221 r = guestfs_is_dir (g, path);
11225 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
11232 static int test_mkdir_1 (void)
11234 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
11236 char device[] = "/dev/sda";
11237 device[5] = devchar;
11239 suppress_error = 0;
11240 r = guestfs_blockdev_setrw (g, device);
11246 suppress_error = 0;
11247 r = guestfs_umount_all (g);
11253 suppress_error = 0;
11254 r = guestfs_lvm_remove_all (g);
11259 char device[] = "/dev/sda";
11260 device[5] = devchar;
11261 char lines_0[] = ",";
11267 suppress_error = 0;
11268 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11273 char fstype[] = "ext2";
11274 char device[] = "/dev/sda1";
11275 device[5] = devchar;
11277 suppress_error = 0;
11278 r = guestfs_mkfs (g, fstype, device);
11283 char device[] = "/dev/sda1";
11284 device[5] = devchar;
11285 char mountpoint[] = "/";
11287 suppress_error = 0;
11288 r = guestfs_mount (g, device, mountpoint);
11292 /* TestLastFail for mkdir (1) */
11294 char path[] = "/new/foo/bar";
11296 suppress_error = 1;
11297 r = guestfs_mkdir (g, path);
11304 static int test_rm_rf_0 (void)
11306 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
11308 char device[] = "/dev/sda";
11309 device[5] = devchar;
11311 suppress_error = 0;
11312 r = guestfs_blockdev_setrw (g, device);
11318 suppress_error = 0;
11319 r = guestfs_umount_all (g);
11325 suppress_error = 0;
11326 r = guestfs_lvm_remove_all (g);
11331 char device[] = "/dev/sda";
11332 device[5] = devchar;
11333 char lines_0[] = ",";
11339 suppress_error = 0;
11340 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11345 char fstype[] = "ext2";
11346 char device[] = "/dev/sda1";
11347 device[5] = devchar;
11349 suppress_error = 0;
11350 r = guestfs_mkfs (g, fstype, device);
11355 char device[] = "/dev/sda1";
11356 device[5] = devchar;
11357 char mountpoint[] = "/";
11359 suppress_error = 0;
11360 r = guestfs_mount (g, device, mountpoint);
11364 /* TestOutputFalse for rm_rf (0) */
11366 char path[] = "/new";
11368 suppress_error = 0;
11369 r = guestfs_mkdir (g, path);
11374 char path[] = "/new/foo";
11376 suppress_error = 0;
11377 r = guestfs_mkdir (g, path);
11382 char path[] = "/new/foo/bar";
11384 suppress_error = 0;
11385 r = guestfs_touch (g, path);
11390 char path[] = "/new";
11392 suppress_error = 0;
11393 r = guestfs_rm_rf (g, path);
11398 char path[] = "/new";
11400 suppress_error = 0;
11401 r = guestfs_exists (g, path);
11405 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
11412 static int test_rmdir_0 (void)
11414 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
11416 char device[] = "/dev/sda";
11417 device[5] = devchar;
11419 suppress_error = 0;
11420 r = guestfs_blockdev_setrw (g, device);
11426 suppress_error = 0;
11427 r = guestfs_umount_all (g);
11433 suppress_error = 0;
11434 r = guestfs_lvm_remove_all (g);
11439 char device[] = "/dev/sda";
11440 device[5] = devchar;
11441 char lines_0[] = ",";
11447 suppress_error = 0;
11448 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11453 char fstype[] = "ext2";
11454 char device[] = "/dev/sda1";
11455 device[5] = devchar;
11457 suppress_error = 0;
11458 r = guestfs_mkfs (g, fstype, device);
11463 char device[] = "/dev/sda1";
11464 device[5] = devchar;
11465 char mountpoint[] = "/";
11467 suppress_error = 0;
11468 r = guestfs_mount (g, device, mountpoint);
11472 /* TestRun for rmdir (0) */
11474 char path[] = "/new";
11476 suppress_error = 0;
11477 r = guestfs_mkdir (g, path);
11482 char path[] = "/new";
11484 suppress_error = 0;
11485 r = guestfs_rmdir (g, path);
11492 static int test_rmdir_1 (void)
11494 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11496 char device[] = "/dev/sda";
11497 device[5] = devchar;
11499 suppress_error = 0;
11500 r = guestfs_blockdev_setrw (g, device);
11506 suppress_error = 0;
11507 r = guestfs_umount_all (g);
11513 suppress_error = 0;
11514 r = guestfs_lvm_remove_all (g);
11519 char device[] = "/dev/sda";
11520 device[5] = devchar;
11521 char lines_0[] = ",";
11527 suppress_error = 0;
11528 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11533 char fstype[] = "ext2";
11534 char device[] = "/dev/sda1";
11535 device[5] = devchar;
11537 suppress_error = 0;
11538 r = guestfs_mkfs (g, fstype, device);
11543 char device[] = "/dev/sda1";
11544 device[5] = devchar;
11545 char mountpoint[] = "/";
11547 suppress_error = 0;
11548 r = guestfs_mount (g, device, mountpoint);
11552 /* TestLastFail for rmdir (1) */
11554 char path[] = "/new";
11556 suppress_error = 1;
11557 r = guestfs_rmdir (g, path);
11564 static int test_rmdir_2 (void)
11566 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11568 char device[] = "/dev/sda";
11569 device[5] = devchar;
11571 suppress_error = 0;
11572 r = guestfs_blockdev_setrw (g, device);
11578 suppress_error = 0;
11579 r = guestfs_umount_all (g);
11585 suppress_error = 0;
11586 r = guestfs_lvm_remove_all (g);
11591 char device[] = "/dev/sda";
11592 device[5] = devchar;
11593 char lines_0[] = ",";
11599 suppress_error = 0;
11600 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11605 char fstype[] = "ext2";
11606 char device[] = "/dev/sda1";
11607 device[5] = devchar;
11609 suppress_error = 0;
11610 r = guestfs_mkfs (g, fstype, device);
11615 char device[] = "/dev/sda1";
11616 device[5] = devchar;
11617 char mountpoint[] = "/";
11619 suppress_error = 0;
11620 r = guestfs_mount (g, device, mountpoint);
11624 /* TestLastFail for rmdir (2) */
11626 char path[] = "/new";
11628 suppress_error = 0;
11629 r = guestfs_touch (g, path);
11634 char path[] = "/new";
11636 suppress_error = 1;
11637 r = guestfs_rmdir (g, path);
11644 static int test_rm_0 (void)
11646 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11648 char device[] = "/dev/sda";
11649 device[5] = devchar;
11651 suppress_error = 0;
11652 r = guestfs_blockdev_setrw (g, device);
11658 suppress_error = 0;
11659 r = guestfs_umount_all (g);
11665 suppress_error = 0;
11666 r = guestfs_lvm_remove_all (g);
11671 char device[] = "/dev/sda";
11672 device[5] = devchar;
11673 char lines_0[] = ",";
11679 suppress_error = 0;
11680 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11685 char fstype[] = "ext2";
11686 char device[] = "/dev/sda1";
11687 device[5] = devchar;
11689 suppress_error = 0;
11690 r = guestfs_mkfs (g, fstype, device);
11695 char device[] = "/dev/sda1";
11696 device[5] = devchar;
11697 char mountpoint[] = "/";
11699 suppress_error = 0;
11700 r = guestfs_mount (g, device, mountpoint);
11704 /* TestRun for rm (0) */
11706 char path[] = "/new";
11708 suppress_error = 0;
11709 r = guestfs_touch (g, path);
11714 char path[] = "/new";
11716 suppress_error = 0;
11717 r = guestfs_rm (g, path);
11724 static int test_rm_1 (void)
11726 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11728 char device[] = "/dev/sda";
11729 device[5] = devchar;
11731 suppress_error = 0;
11732 r = guestfs_blockdev_setrw (g, device);
11738 suppress_error = 0;
11739 r = guestfs_umount_all (g);
11745 suppress_error = 0;
11746 r = guestfs_lvm_remove_all (g);
11751 char device[] = "/dev/sda";
11752 device[5] = devchar;
11753 char lines_0[] = ",";
11759 suppress_error = 0;
11760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11765 char fstype[] = "ext2";
11766 char device[] = "/dev/sda1";
11767 device[5] = devchar;
11769 suppress_error = 0;
11770 r = guestfs_mkfs (g, fstype, device);
11775 char device[] = "/dev/sda1";
11776 device[5] = devchar;
11777 char mountpoint[] = "/";
11779 suppress_error = 0;
11780 r = guestfs_mount (g, device, mountpoint);
11784 /* TestLastFail for rm (1) */
11786 char path[] = "/new";
11788 suppress_error = 1;
11789 r = guestfs_rm (g, path);
11796 static int test_rm_2 (void)
11798 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11800 char device[] = "/dev/sda";
11801 device[5] = devchar;
11803 suppress_error = 0;
11804 r = guestfs_blockdev_setrw (g, device);
11810 suppress_error = 0;
11811 r = guestfs_umount_all (g);
11817 suppress_error = 0;
11818 r = guestfs_lvm_remove_all (g);
11823 char device[] = "/dev/sda";
11824 device[5] = devchar;
11825 char lines_0[] = ",";
11831 suppress_error = 0;
11832 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11837 char fstype[] = "ext2";
11838 char device[] = "/dev/sda1";
11839 device[5] = devchar;
11841 suppress_error = 0;
11842 r = guestfs_mkfs (g, fstype, device);
11847 char device[] = "/dev/sda1";
11848 device[5] = devchar;
11849 char mountpoint[] = "/";
11851 suppress_error = 0;
11852 r = guestfs_mount (g, device, mountpoint);
11856 /* TestLastFail for rm (2) */
11858 char path[] = "/new";
11860 suppress_error = 0;
11861 r = guestfs_mkdir (g, path);
11866 char path[] = "/new";
11868 suppress_error = 1;
11869 r = guestfs_rm (g, path);
11876 static int test_read_lines_0 (void)
11878 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11880 char device[] = "/dev/sda";
11881 device[5] = devchar;
11883 suppress_error = 0;
11884 r = guestfs_blockdev_setrw (g, device);
11890 suppress_error = 0;
11891 r = guestfs_umount_all (g);
11897 suppress_error = 0;
11898 r = guestfs_lvm_remove_all (g);
11903 char device[] = "/dev/sda";
11904 device[5] = devchar;
11905 char lines_0[] = ",";
11911 suppress_error = 0;
11912 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11917 char fstype[] = "ext2";
11918 char device[] = "/dev/sda1";
11919 device[5] = devchar;
11921 suppress_error = 0;
11922 r = guestfs_mkfs (g, fstype, device);
11927 char device[] = "/dev/sda1";
11928 device[5] = devchar;
11929 char mountpoint[] = "/";
11931 suppress_error = 0;
11932 r = guestfs_mount (g, device, mountpoint);
11936 /* TestOutputList for read_lines (0) */
11938 char path[] = "/new";
11939 char content[] = "line1\r\nline2\nline3";
11941 suppress_error = 0;
11942 r = guestfs_write_file (g, path, content, 0);
11947 char path[] = "/new";
11950 suppress_error = 0;
11951 r = guestfs_read_lines (g, path);
11955 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11960 char expected[] = "line1";
11961 if (strcmp (r[0], expected) != 0) {
11962 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11967 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11972 char expected[] = "line2";
11973 if (strcmp (r[1], expected) != 0) {
11974 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11979 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11984 char expected[] = "line3";
11985 if (strcmp (r[2], expected) != 0) {
11986 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11990 if (r[3] != NULL) {
11991 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11995 for (i = 0; r[i] != NULL; ++i)
12002 static int test_read_lines_1 (void)
12004 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
12006 char device[] = "/dev/sda";
12007 device[5] = devchar;
12009 suppress_error = 0;
12010 r = guestfs_blockdev_setrw (g, device);
12016 suppress_error = 0;
12017 r = guestfs_umount_all (g);
12023 suppress_error = 0;
12024 r = guestfs_lvm_remove_all (g);
12029 char device[] = "/dev/sda";
12030 device[5] = devchar;
12031 char lines_0[] = ",";
12037 suppress_error = 0;
12038 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12043 char fstype[] = "ext2";
12044 char device[] = "/dev/sda1";
12045 device[5] = devchar;
12047 suppress_error = 0;
12048 r = guestfs_mkfs (g, fstype, device);
12053 char device[] = "/dev/sda1";
12054 device[5] = devchar;
12055 char mountpoint[] = "/";
12057 suppress_error = 0;
12058 r = guestfs_mount (g, device, mountpoint);
12062 /* TestOutputList for read_lines (1) */
12064 char path[] = "/new";
12065 char content[] = "";
12067 suppress_error = 0;
12068 r = guestfs_write_file (g, path, content, 0);
12073 char path[] = "/new";
12076 suppress_error = 0;
12077 r = guestfs_read_lines (g, path);
12080 if (r[0] != NULL) {
12081 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
12085 for (i = 0; r[i] != NULL; ++i)
12092 static int test_lvs_0 (void)
12094 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
12096 char device[] = "/dev/sda";
12097 device[5] = devchar;
12099 suppress_error = 0;
12100 r = guestfs_blockdev_setrw (g, device);
12106 suppress_error = 0;
12107 r = guestfs_umount_all (g);
12113 suppress_error = 0;
12114 r = guestfs_lvm_remove_all (g);
12119 char device[] = "/dev/sda";
12120 device[5] = devchar;
12121 char lines_0[] = ",";
12127 suppress_error = 0;
12128 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12133 char device[] = "/dev/sda1";
12134 device[5] = devchar;
12136 suppress_error = 0;
12137 r = guestfs_pvcreate (g, device);
12142 char volgroup[] = "VG";
12143 char physvols_0[] = "/dev/sda1";
12144 physvols_0[5] = devchar;
12145 char *physvols[] = {
12150 suppress_error = 0;
12151 r = guestfs_vgcreate (g, volgroup, physvols);
12156 char logvol[] = "LV";
12157 char volgroup[] = "VG";
12159 suppress_error = 0;
12160 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12165 char fstype[] = "ext2";
12166 char device[] = "/dev/VG/LV";
12168 suppress_error = 0;
12169 r = guestfs_mkfs (g, fstype, device);
12174 char device[] = "/dev/VG/LV";
12175 char mountpoint[] = "/";
12177 suppress_error = 0;
12178 r = guestfs_mount (g, device, mountpoint);
12182 /* TestOutputList for lvs (0) */
12186 suppress_error = 0;
12187 r = guestfs_lvs (g);
12191 fprintf (stderr, "test_lvs_0: short list returned from command\n");
12196 char expected[] = "/dev/VG/LV";
12197 if (strcmp (r[0], expected) != 0) {
12198 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12202 if (r[1] != NULL) {
12203 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
12207 for (i = 0; r[i] != NULL; ++i)
12214 static int test_lvs_1 (void)
12216 /* InitNone|InitEmpty for test_lvs_1 */
12218 char device[] = "/dev/sda";
12219 device[5] = devchar;
12221 suppress_error = 0;
12222 r = guestfs_blockdev_setrw (g, device);
12228 suppress_error = 0;
12229 r = guestfs_umount_all (g);
12235 suppress_error = 0;
12236 r = guestfs_lvm_remove_all (g);
12240 /* TestOutputList for lvs (1) */
12242 char device[] = "/dev/sda";
12243 device[5] = devchar;
12244 char lines_0[] = ",10";
12245 char lines_1[] = ",20";
12246 char lines_2[] = ",";
12254 suppress_error = 0;
12255 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12260 char device[] = "/dev/sda1";
12261 device[5] = devchar;
12263 suppress_error = 0;
12264 r = guestfs_pvcreate (g, device);
12269 char device[] = "/dev/sda2";
12270 device[5] = devchar;
12272 suppress_error = 0;
12273 r = guestfs_pvcreate (g, device);
12278 char device[] = "/dev/sda3";
12279 device[5] = devchar;
12281 suppress_error = 0;
12282 r = guestfs_pvcreate (g, device);
12287 char volgroup[] = "VG1";
12288 char physvols_0[] = "/dev/sda1";
12289 physvols_0[5] = devchar;
12290 char physvols_1[] = "/dev/sda2";
12291 physvols_1[5] = devchar;
12292 char *physvols[] = {
12298 suppress_error = 0;
12299 r = guestfs_vgcreate (g, volgroup, physvols);
12304 char volgroup[] = "VG2";
12305 char physvols_0[] = "/dev/sda3";
12306 physvols_0[5] = devchar;
12307 char *physvols[] = {
12312 suppress_error = 0;
12313 r = guestfs_vgcreate (g, volgroup, physvols);
12318 char logvol[] = "LV1";
12319 char volgroup[] = "VG1";
12321 suppress_error = 0;
12322 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12327 char logvol[] = "LV2";
12328 char volgroup[] = "VG1";
12330 suppress_error = 0;
12331 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12336 char logvol[] = "LV3";
12337 char volgroup[] = "VG2";
12339 suppress_error = 0;
12340 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12347 suppress_error = 0;
12348 r = guestfs_lvs (g);
12352 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12357 char expected[] = "/dev/VG1/LV1";
12358 if (strcmp (r[0], expected) != 0) {
12359 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12364 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12369 char expected[] = "/dev/VG1/LV2";
12370 if (strcmp (r[1], expected) != 0) {
12371 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12376 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12381 char expected[] = "/dev/VG2/LV3";
12382 if (strcmp (r[2], expected) != 0) {
12383 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12387 if (r[3] != NULL) {
12388 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
12392 for (i = 0; r[i] != NULL; ++i)
12399 static int test_vgs_0 (void)
12401 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
12403 char device[] = "/dev/sda";
12404 device[5] = devchar;
12406 suppress_error = 0;
12407 r = guestfs_blockdev_setrw (g, device);
12413 suppress_error = 0;
12414 r = guestfs_umount_all (g);
12420 suppress_error = 0;
12421 r = guestfs_lvm_remove_all (g);
12426 char device[] = "/dev/sda";
12427 device[5] = devchar;
12428 char lines_0[] = ",";
12434 suppress_error = 0;
12435 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12440 char device[] = "/dev/sda1";
12441 device[5] = devchar;
12443 suppress_error = 0;
12444 r = guestfs_pvcreate (g, device);
12449 char volgroup[] = "VG";
12450 char physvols_0[] = "/dev/sda1";
12451 physvols_0[5] = devchar;
12452 char *physvols[] = {
12457 suppress_error = 0;
12458 r = guestfs_vgcreate (g, volgroup, physvols);
12463 char logvol[] = "LV";
12464 char volgroup[] = "VG";
12466 suppress_error = 0;
12467 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12472 char fstype[] = "ext2";
12473 char device[] = "/dev/VG/LV";
12475 suppress_error = 0;
12476 r = guestfs_mkfs (g, fstype, device);
12481 char device[] = "/dev/VG/LV";
12482 char mountpoint[] = "/";
12484 suppress_error = 0;
12485 r = guestfs_mount (g, device, mountpoint);
12489 /* TestOutputList for vgs (0) */
12493 suppress_error = 0;
12494 r = guestfs_vgs (g);
12498 fprintf (stderr, "test_vgs_0: short list returned from command\n");
12503 char expected[] = "VG";
12504 if (strcmp (r[0], expected) != 0) {
12505 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12509 if (r[1] != NULL) {
12510 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12514 for (i = 0; r[i] != NULL; ++i)
12521 static int test_vgs_1 (void)
12523 /* InitNone|InitEmpty for test_vgs_1 */
12525 char device[] = "/dev/sda";
12526 device[5] = devchar;
12528 suppress_error = 0;
12529 r = guestfs_blockdev_setrw (g, device);
12535 suppress_error = 0;
12536 r = guestfs_umount_all (g);
12542 suppress_error = 0;
12543 r = guestfs_lvm_remove_all (g);
12547 /* TestOutputList for vgs (1) */
12549 char device[] = "/dev/sda";
12550 device[5] = devchar;
12551 char lines_0[] = ",10";
12552 char lines_1[] = ",20";
12553 char lines_2[] = ",";
12561 suppress_error = 0;
12562 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12567 char device[] = "/dev/sda1";
12568 device[5] = devchar;
12570 suppress_error = 0;
12571 r = guestfs_pvcreate (g, device);
12576 char device[] = "/dev/sda2";
12577 device[5] = devchar;
12579 suppress_error = 0;
12580 r = guestfs_pvcreate (g, device);
12585 char device[] = "/dev/sda3";
12586 device[5] = devchar;
12588 suppress_error = 0;
12589 r = guestfs_pvcreate (g, device);
12594 char volgroup[] = "VG1";
12595 char physvols_0[] = "/dev/sda1";
12596 physvols_0[5] = devchar;
12597 char physvols_1[] = "/dev/sda2";
12598 physvols_1[5] = devchar;
12599 char *physvols[] = {
12605 suppress_error = 0;
12606 r = guestfs_vgcreate (g, volgroup, physvols);
12611 char volgroup[] = "VG2";
12612 char physvols_0[] = "/dev/sda3";
12613 physvols_0[5] = devchar;
12614 char *physvols[] = {
12619 suppress_error = 0;
12620 r = guestfs_vgcreate (g, volgroup, physvols);
12627 suppress_error = 0;
12628 r = guestfs_vgs (g);
12632 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12637 char expected[] = "VG1";
12638 if (strcmp (r[0], expected) != 0) {
12639 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12644 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12649 char expected[] = "VG2";
12650 if (strcmp (r[1], expected) != 0) {
12651 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12655 if (r[2] != NULL) {
12656 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12660 for (i = 0; r[i] != NULL; ++i)
12667 static int test_pvs_0 (void)
12669 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12671 char device[] = "/dev/sda";
12672 device[5] = devchar;
12674 suppress_error = 0;
12675 r = guestfs_blockdev_setrw (g, device);
12681 suppress_error = 0;
12682 r = guestfs_umount_all (g);
12688 suppress_error = 0;
12689 r = guestfs_lvm_remove_all (g);
12694 char device[] = "/dev/sda";
12695 device[5] = devchar;
12696 char lines_0[] = ",";
12702 suppress_error = 0;
12703 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12708 char device[] = "/dev/sda1";
12709 device[5] = devchar;
12711 suppress_error = 0;
12712 r = guestfs_pvcreate (g, device);
12717 char volgroup[] = "VG";
12718 char physvols_0[] = "/dev/sda1";
12719 physvols_0[5] = devchar;
12720 char *physvols[] = {
12725 suppress_error = 0;
12726 r = guestfs_vgcreate (g, volgroup, physvols);
12731 char logvol[] = "LV";
12732 char volgroup[] = "VG";
12734 suppress_error = 0;
12735 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12740 char fstype[] = "ext2";
12741 char device[] = "/dev/VG/LV";
12743 suppress_error = 0;
12744 r = guestfs_mkfs (g, fstype, device);
12749 char device[] = "/dev/VG/LV";
12750 char mountpoint[] = "/";
12752 suppress_error = 0;
12753 r = guestfs_mount (g, device, mountpoint);
12757 /* TestOutputList for pvs (0) */
12761 suppress_error = 0;
12762 r = guestfs_pvs (g);
12766 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12771 char expected[] = "/dev/sda1";
12772 expected[5] = devchar;
12773 if (strcmp (r[0], expected) != 0) {
12774 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12778 if (r[1] != NULL) {
12779 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12783 for (i = 0; r[i] != NULL; ++i)
12790 static int test_pvs_1 (void)
12792 /* InitNone|InitEmpty for test_pvs_1 */
12794 char device[] = "/dev/sda";
12795 device[5] = devchar;
12797 suppress_error = 0;
12798 r = guestfs_blockdev_setrw (g, device);
12804 suppress_error = 0;
12805 r = guestfs_umount_all (g);
12811 suppress_error = 0;
12812 r = guestfs_lvm_remove_all (g);
12816 /* TestOutputList for pvs (1) */
12818 char device[] = "/dev/sda";
12819 device[5] = devchar;
12820 char lines_0[] = ",10";
12821 char lines_1[] = ",20";
12822 char lines_2[] = ",";
12830 suppress_error = 0;
12831 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12836 char device[] = "/dev/sda1";
12837 device[5] = devchar;
12839 suppress_error = 0;
12840 r = guestfs_pvcreate (g, device);
12845 char device[] = "/dev/sda2";
12846 device[5] = devchar;
12848 suppress_error = 0;
12849 r = guestfs_pvcreate (g, device);
12854 char device[] = "/dev/sda3";
12855 device[5] = devchar;
12857 suppress_error = 0;
12858 r = guestfs_pvcreate (g, device);
12865 suppress_error = 0;
12866 r = guestfs_pvs (g);
12870 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12875 char expected[] = "/dev/sda1";
12876 expected[5] = devchar;
12877 if (strcmp (r[0], expected) != 0) {
12878 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12883 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12888 char expected[] = "/dev/sda2";
12889 expected[5] = devchar;
12890 if (strcmp (r[1], expected) != 0) {
12891 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12896 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12901 char expected[] = "/dev/sda3";
12902 expected[5] = devchar;
12903 if (strcmp (r[2], expected) != 0) {
12904 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12908 if (r[3] != NULL) {
12909 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12913 for (i = 0; r[i] != NULL; ++i)
12920 static int test_list_partitions_0 (void)
12922 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12924 char device[] = "/dev/sda";
12925 device[5] = devchar;
12927 suppress_error = 0;
12928 r = guestfs_blockdev_setrw (g, device);
12934 suppress_error = 0;
12935 r = guestfs_umount_all (g);
12941 suppress_error = 0;
12942 r = guestfs_lvm_remove_all (g);
12947 char device[] = "/dev/sda";
12948 device[5] = devchar;
12949 char lines_0[] = ",";
12955 suppress_error = 0;
12956 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12961 char fstype[] = "ext2";
12962 char device[] = "/dev/sda1";
12963 device[5] = devchar;
12965 suppress_error = 0;
12966 r = guestfs_mkfs (g, fstype, device);
12971 char device[] = "/dev/sda1";
12972 device[5] = devchar;
12973 char mountpoint[] = "/";
12975 suppress_error = 0;
12976 r = guestfs_mount (g, device, mountpoint);
12980 /* TestOutputList for list_partitions (0) */
12984 suppress_error = 0;
12985 r = guestfs_list_partitions (g);
12989 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12994 char expected[] = "/dev/sda1";
12995 expected[5] = devchar;
12996 if (strcmp (r[0], expected) != 0) {
12997 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13001 if (r[1] != NULL) {
13002 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
13006 for (i = 0; r[i] != NULL; ++i)
13013 static int test_list_partitions_1 (void)
13015 /* InitNone|InitEmpty for test_list_partitions_1 */
13017 char device[] = "/dev/sda";
13018 device[5] = devchar;
13020 suppress_error = 0;
13021 r = guestfs_blockdev_setrw (g, device);
13027 suppress_error = 0;
13028 r = guestfs_umount_all (g);
13034 suppress_error = 0;
13035 r = guestfs_lvm_remove_all (g);
13039 /* TestOutputList for list_partitions (1) */
13041 char device[] = "/dev/sda";
13042 device[5] = devchar;
13043 char lines_0[] = ",10";
13044 char lines_1[] = ",20";
13045 char lines_2[] = ",";
13053 suppress_error = 0;
13054 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13061 suppress_error = 0;
13062 r = guestfs_list_partitions (g);
13066 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13071 char expected[] = "/dev/sda1";
13072 expected[5] = devchar;
13073 if (strcmp (r[0], expected) != 0) {
13074 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13079 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13084 char expected[] = "/dev/sda2";
13085 expected[5] = devchar;
13086 if (strcmp (r[1], expected) != 0) {
13087 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13092 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13097 char expected[] = "/dev/sda3";
13098 expected[5] = devchar;
13099 if (strcmp (r[2], expected) != 0) {
13100 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13104 if (r[3] != NULL) {
13105 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
13109 for (i = 0; r[i] != NULL; ++i)
13116 static int test_list_devices_0 (void)
13118 /* InitNone|InitEmpty for test_list_devices_0 */
13120 char device[] = "/dev/sda";
13121 device[5] = devchar;
13123 suppress_error = 0;
13124 r = guestfs_blockdev_setrw (g, device);
13130 suppress_error = 0;
13131 r = guestfs_umount_all (g);
13137 suppress_error = 0;
13138 r = guestfs_lvm_remove_all (g);
13142 /* TestOutputList for list_devices (0) */
13146 suppress_error = 0;
13147 r = guestfs_list_devices (g);
13151 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13156 char expected[] = "/dev/sda";
13157 expected[5] = devchar;
13158 if (strcmp (r[0], expected) != 0) {
13159 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13164 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13169 char expected[] = "/dev/sdb";
13170 expected[5] = devchar;
13171 if (strcmp (r[1], expected) != 0) {
13172 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13177 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13182 char expected[] = "/dev/sdc";
13183 expected[5] = devchar;
13184 if (strcmp (r[2], expected) != 0) {
13185 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13189 if (r[3] != NULL) {
13190 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
13194 for (i = 0; r[i] != NULL; ++i)
13201 static int test_ls_0 (void)
13203 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
13205 char device[] = "/dev/sda";
13206 device[5] = devchar;
13208 suppress_error = 0;
13209 r = guestfs_blockdev_setrw (g, device);
13215 suppress_error = 0;
13216 r = guestfs_umount_all (g);
13222 suppress_error = 0;
13223 r = guestfs_lvm_remove_all (g);
13228 char device[] = "/dev/sda";
13229 device[5] = devchar;
13230 char lines_0[] = ",";
13236 suppress_error = 0;
13237 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13242 char fstype[] = "ext2";
13243 char device[] = "/dev/sda1";
13244 device[5] = devchar;
13246 suppress_error = 0;
13247 r = guestfs_mkfs (g, fstype, device);
13252 char device[] = "/dev/sda1";
13253 device[5] = devchar;
13254 char mountpoint[] = "/";
13256 suppress_error = 0;
13257 r = guestfs_mount (g, device, mountpoint);
13261 /* TestOutputList for ls (0) */
13263 char path[] = "/new";
13265 suppress_error = 0;
13266 r = guestfs_touch (g, path);
13271 char path[] = "/newer";
13273 suppress_error = 0;
13274 r = guestfs_touch (g, path);
13279 char path[] = "/newest";
13281 suppress_error = 0;
13282 r = guestfs_touch (g, path);
13287 char directory[] = "/";
13290 suppress_error = 0;
13291 r = guestfs_ls (g, directory);
13295 fprintf (stderr, "test_ls_0: short list returned from command\n");
13300 char expected[] = "lost+found";
13301 if (strcmp (r[0], expected) != 0) {
13302 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13307 fprintf (stderr, "test_ls_0: short list returned from command\n");
13312 char expected[] = "new";
13313 if (strcmp (r[1], expected) != 0) {
13314 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13319 fprintf (stderr, "test_ls_0: short list returned from command\n");
13324 char expected[] = "newer";
13325 if (strcmp (r[2], expected) != 0) {
13326 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13331 fprintf (stderr, "test_ls_0: short list returned from command\n");
13336 char expected[] = "newest";
13337 if (strcmp (r[3], expected) != 0) {
13338 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
13342 if (r[4] != NULL) {
13343 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
13347 for (i = 0; r[i] != NULL; ++i)
13354 static int test_cat_0 (void)
13356 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
13358 char device[] = "/dev/sda";
13359 device[5] = devchar;
13361 suppress_error = 0;
13362 r = guestfs_blockdev_setrw (g, device);
13368 suppress_error = 0;
13369 r = guestfs_umount_all (g);
13375 suppress_error = 0;
13376 r = guestfs_lvm_remove_all (g);
13381 char device[] = "/dev/sda";
13382 device[5] = devchar;
13383 char lines_0[] = ",";
13389 suppress_error = 0;
13390 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13395 char fstype[] = "ext2";
13396 char device[] = "/dev/sda1";
13397 device[5] = devchar;
13399 suppress_error = 0;
13400 r = guestfs_mkfs (g, fstype, device);
13405 char device[] = "/dev/sda1";
13406 device[5] = devchar;
13407 char mountpoint[] = "/";
13409 suppress_error = 0;
13410 r = guestfs_mount (g, device, mountpoint);
13414 /* TestOutput for cat (0) */
13415 char expected[] = "new file contents";
13417 char path[] = "/new";
13418 char content[] = "new file contents";
13420 suppress_error = 0;
13421 r = guestfs_write_file (g, path, content, 0);
13426 char path[] = "/new";
13428 suppress_error = 0;
13429 r = guestfs_cat (g, path);
13432 if (strcmp (r, expected) != 0) {
13433 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
13441 static int test_touch_0 (void)
13443 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
13445 char device[] = "/dev/sda";
13446 device[5] = devchar;
13448 suppress_error = 0;
13449 r = guestfs_blockdev_setrw (g, device);
13455 suppress_error = 0;
13456 r = guestfs_umount_all (g);
13462 suppress_error = 0;
13463 r = guestfs_lvm_remove_all (g);
13468 char device[] = "/dev/sda";
13469 device[5] = devchar;
13470 char lines_0[] = ",";
13476 suppress_error = 0;
13477 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13482 char fstype[] = "ext2";
13483 char device[] = "/dev/sda1";
13484 device[5] = devchar;
13486 suppress_error = 0;
13487 r = guestfs_mkfs (g, fstype, device);
13492 char device[] = "/dev/sda1";
13493 device[5] = devchar;
13494 char mountpoint[] = "/";
13496 suppress_error = 0;
13497 r = guestfs_mount (g, device, mountpoint);
13501 /* TestOutputTrue for touch (0) */
13503 char path[] = "/new";
13505 suppress_error = 0;
13506 r = guestfs_touch (g, path);
13511 char path[] = "/new";
13513 suppress_error = 0;
13514 r = guestfs_exists (g, path);
13518 fprintf (stderr, "test_touch_0: expected true, got false\n");
13525 static int test_sync_0 (void)
13527 /* InitNone|InitEmpty for test_sync_0 */
13529 char device[] = "/dev/sda";
13530 device[5] = devchar;
13532 suppress_error = 0;
13533 r = guestfs_blockdev_setrw (g, device);
13539 suppress_error = 0;
13540 r = guestfs_umount_all (g);
13546 suppress_error = 0;
13547 r = guestfs_lvm_remove_all (g);
13551 /* TestRun for sync (0) */
13554 suppress_error = 0;
13555 r = guestfs_sync (g);
13562 static int test_mount_0 (void)
13564 /* InitNone|InitEmpty for test_mount_0 */
13566 char device[] = "/dev/sda";
13567 device[5] = devchar;
13569 suppress_error = 0;
13570 r = guestfs_blockdev_setrw (g, device);
13576 suppress_error = 0;
13577 r = guestfs_umount_all (g);
13583 suppress_error = 0;
13584 r = guestfs_lvm_remove_all (g);
13588 /* TestOutput for mount (0) */
13589 char expected[] = "new file contents";
13591 char device[] = "/dev/sda";
13592 device[5] = devchar;
13593 char lines_0[] = ",";
13599 suppress_error = 0;
13600 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13605 char fstype[] = "ext2";
13606 char device[] = "/dev/sda1";
13607 device[5] = devchar;
13609 suppress_error = 0;
13610 r = guestfs_mkfs (g, fstype, device);
13615 char device[] = "/dev/sda1";
13616 device[5] = devchar;
13617 char mountpoint[] = "/";
13619 suppress_error = 0;
13620 r = guestfs_mount (g, device, mountpoint);
13625 char path[] = "/new";
13626 char content[] = "new file contents";
13628 suppress_error = 0;
13629 r = guestfs_write_file (g, path, content, 0);
13634 char path[] = "/new";
13636 suppress_error = 0;
13637 r = guestfs_cat (g, path);
13640 if (strcmp (r, expected) != 0) {
13641 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13649 int main (int argc, char *argv[])
13653 const char *srcdir;
13654 const char *filename;
13656 int nr_tests, test_num = 0;
13659 no_test_warnings ();
13661 g = guestfs_create ();
13663 printf ("guestfs_create FAILED\n");
13667 guestfs_set_error_handler (g, print_error, NULL);
13669 srcdir = getenv ("srcdir");
13670 if (!srcdir) srcdir = ".";
13672 guestfs_set_path (g, ".");
13674 filename = "test1.img";
13675 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13680 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13686 if (write (fd, &c, 1) == -1) {
13692 if (close (fd) == -1) {
13697 if (guestfs_add_drive (g, filename) == -1) {
13698 printf ("guestfs_add_drive %s FAILED\n", filename);
13702 filename = "test2.img";
13703 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13708 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13714 if (write (fd, &c, 1) == -1) {
13720 if (close (fd) == -1) {
13725 if (guestfs_add_drive (g, filename) == -1) {
13726 printf ("guestfs_add_drive %s FAILED\n", filename);
13730 filename = "test3.img";
13731 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13736 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13742 if (write (fd, &c, 1) == -1) {
13748 if (close (fd) == -1) {
13753 if (guestfs_add_drive (g, filename) == -1) {
13754 printf ("guestfs_add_drive %s FAILED\n", filename);
13758 if (guestfs_launch (g) == -1) {
13759 printf ("guestfs_launch FAILED\n");
13762 if (guestfs_wait_ready (g) == -1) {
13763 printf ("guestfs_wait_ready FAILED\n");
13767 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13768 * names. This changed between RHEL 5 and RHEL 6 so we have to
13771 devs = guestfs_list_devices (g);
13772 if (devs == NULL || devs[0] == NULL) {
13773 printf ("guestfs_list_devices FAILED\n");
13776 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13778 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13781 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13785 for (i = 0; devs[i] != NULL; ++i)
13792 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
13793 if (test_find_0 () == -1) {
13794 printf ("test_find_0 FAILED\n");
13798 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
13799 if (test_find_1 () == -1) {
13800 printf ("test_find_1 FAILED\n");
13804 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
13805 if (test_find_2 () == -1) {
13806 printf ("test_find_2 FAILED\n");
13810 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13811 if (test_lvresize_0 () == -1) {
13812 printf ("test_lvresize_0 FAILED\n");
13816 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13817 if (test_zerofree_0 () == -1) {
13818 printf ("test_zerofree_0 FAILED\n");
13822 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13823 if (test_hexdump_0 () == -1) {
13824 printf ("test_hexdump_0 FAILED\n");
13828 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13829 if (test_strings_e_0 () == -1) {
13830 printf ("test_strings_e_0 FAILED\n");
13834 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13835 if (test_strings_e_1 () == -1) {
13836 printf ("test_strings_e_1 FAILED\n");
13840 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13841 if (test_strings_0 () == -1) {
13842 printf ("test_strings_0 FAILED\n");
13846 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13847 if (test_strings_1 () == -1) {
13848 printf ("test_strings_1 FAILED\n");
13852 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13853 if (test_equal_0 () == -1) {
13854 printf ("test_equal_0 FAILED\n");
13858 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13859 if (test_equal_1 () == -1) {
13860 printf ("test_equal_1 FAILED\n");
13864 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13865 if (test_equal_2 () == -1) {
13866 printf ("test_equal_2 FAILED\n");
13870 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13871 if (test_ping_daemon_0 () == -1) {
13872 printf ("test_ping_daemon_0 FAILED\n");
13876 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13877 if (test_dmesg_0 () == -1) {
13878 printf ("test_dmesg_0 FAILED\n");
13882 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13883 if (test_drop_caches_0 () == -1) {
13884 printf ("test_drop_caches_0 FAILED\n");
13888 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13889 if (test_mv_0 () == -1) {
13890 printf ("test_mv_0 FAILED\n");
13894 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13895 if (test_mv_1 () == -1) {
13896 printf ("test_mv_1 FAILED\n");
13900 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13901 if (test_cp_a_0 () == -1) {
13902 printf ("test_cp_a_0 FAILED\n");
13906 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13907 if (test_cp_0 () == -1) {
13908 printf ("test_cp_0 FAILED\n");
13912 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13913 if (test_cp_1 () == -1) {
13914 printf ("test_cp_1 FAILED\n");
13918 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13919 if (test_cp_2 () == -1) {
13920 printf ("test_cp_2 FAILED\n");
13924 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13925 if (test_grub_install_0 () == -1) {
13926 printf ("test_grub_install_0 FAILED\n");
13930 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13931 if (test_zero_0 () == -1) {
13932 printf ("test_zero_0 FAILED\n");
13936 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13937 if (test_fsck_0 () == -1) {
13938 printf ("test_fsck_0 FAILED\n");
13942 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13943 if (test_fsck_1 () == -1) {
13944 printf ("test_fsck_1 FAILED\n");
13948 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13949 if (test_set_e2uuid_0 () == -1) {
13950 printf ("test_set_e2uuid_0 FAILED\n");
13954 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13955 if (test_set_e2uuid_1 () == -1) {
13956 printf ("test_set_e2uuid_1 FAILED\n");
13960 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13961 if (test_set_e2uuid_2 () == -1) {
13962 printf ("test_set_e2uuid_2 FAILED\n");
13966 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13967 if (test_set_e2uuid_3 () == -1) {
13968 printf ("test_set_e2uuid_3 FAILED\n");
13972 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13973 if (test_set_e2label_0 () == -1) {
13974 printf ("test_set_e2label_0 FAILED\n");
13978 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13979 if (test_pvremove_0 () == -1) {
13980 printf ("test_pvremove_0 FAILED\n");
13984 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13985 if (test_pvremove_1 () == -1) {
13986 printf ("test_pvremove_1 FAILED\n");
13990 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13991 if (test_pvremove_2 () == -1) {
13992 printf ("test_pvremove_2 FAILED\n");
13996 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13997 if (test_vgremove_0 () == -1) {
13998 printf ("test_vgremove_0 FAILED\n");
14002 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
14003 if (test_vgremove_1 () == -1) {
14004 printf ("test_vgremove_1 FAILED\n");
14008 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
14009 if (test_lvremove_0 () == -1) {
14010 printf ("test_lvremove_0 FAILED\n");
14014 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
14015 if (test_lvremove_1 () == -1) {
14016 printf ("test_lvremove_1 FAILED\n");
14020 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
14021 if (test_lvremove_2 () == -1) {
14022 printf ("test_lvremove_2 FAILED\n");
14026 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
14027 if (test_mount_ro_0 () == -1) {
14028 printf ("test_mount_ro_0 FAILED\n");
14032 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
14033 if (test_mount_ro_1 () == -1) {
14034 printf ("test_mount_ro_1 FAILED\n");
14038 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
14039 if (test_tgz_in_0 () == -1) {
14040 printf ("test_tgz_in_0 FAILED\n");
14044 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
14045 if (test_tar_in_0 () == -1) {
14046 printf ("test_tar_in_0 FAILED\n");
14050 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
14051 if (test_checksum_0 () == -1) {
14052 printf ("test_checksum_0 FAILED\n");
14056 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
14057 if (test_checksum_1 () == -1) {
14058 printf ("test_checksum_1 FAILED\n");
14062 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
14063 if (test_checksum_2 () == -1) {
14064 printf ("test_checksum_2 FAILED\n");
14068 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
14069 if (test_checksum_3 () == -1) {
14070 printf ("test_checksum_3 FAILED\n");
14074 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
14075 if (test_checksum_4 () == -1) {
14076 printf ("test_checksum_4 FAILED\n");
14080 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
14081 if (test_checksum_5 () == -1) {
14082 printf ("test_checksum_5 FAILED\n");
14086 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
14087 if (test_checksum_6 () == -1) {
14088 printf ("test_checksum_6 FAILED\n");
14092 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
14093 if (test_checksum_7 () == -1) {
14094 printf ("test_checksum_7 FAILED\n");
14098 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
14099 if (test_download_0 () == -1) {
14100 printf ("test_download_0 FAILED\n");
14104 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
14105 if (test_upload_0 () == -1) {
14106 printf ("test_upload_0 FAILED\n");
14110 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
14111 if (test_blockdev_rereadpt_0 () == -1) {
14112 printf ("test_blockdev_rereadpt_0 FAILED\n");
14116 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
14117 if (test_blockdev_flushbufs_0 () == -1) {
14118 printf ("test_blockdev_flushbufs_0 FAILED\n");
14122 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
14123 if (test_blockdev_getsize64_0 () == -1) {
14124 printf ("test_blockdev_getsize64_0 FAILED\n");
14128 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
14129 if (test_blockdev_getsz_0 () == -1) {
14130 printf ("test_blockdev_getsz_0 FAILED\n");
14134 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
14135 if (test_blockdev_getbsz_0 () == -1) {
14136 printf ("test_blockdev_getbsz_0 FAILED\n");
14140 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
14141 if (test_blockdev_getss_0 () == -1) {
14142 printf ("test_blockdev_getss_0 FAILED\n");
14146 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
14147 if (test_blockdev_getro_0 () == -1) {
14148 printf ("test_blockdev_getro_0 FAILED\n");
14152 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
14153 if (test_blockdev_setrw_0 () == -1) {
14154 printf ("test_blockdev_setrw_0 FAILED\n");
14158 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
14159 if (test_blockdev_setro_0 () == -1) {
14160 printf ("test_blockdev_setro_0 FAILED\n");
14164 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
14165 if (test_statvfs_0 () == -1) {
14166 printf ("test_statvfs_0 FAILED\n");
14170 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
14171 if (test_lstat_0 () == -1) {
14172 printf ("test_lstat_0 FAILED\n");
14176 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
14177 if (test_stat_0 () == -1) {
14178 printf ("test_stat_0 FAILED\n");
14182 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
14183 if (test_command_lines_0 () == -1) {
14184 printf ("test_command_lines_0 FAILED\n");
14188 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
14189 if (test_command_lines_1 () == -1) {
14190 printf ("test_command_lines_1 FAILED\n");
14194 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
14195 if (test_command_lines_2 () == -1) {
14196 printf ("test_command_lines_2 FAILED\n");
14200 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
14201 if (test_command_lines_3 () == -1) {
14202 printf ("test_command_lines_3 FAILED\n");
14206 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
14207 if (test_command_lines_4 () == -1) {
14208 printf ("test_command_lines_4 FAILED\n");
14212 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
14213 if (test_command_lines_5 () == -1) {
14214 printf ("test_command_lines_5 FAILED\n");
14218 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
14219 if (test_command_lines_6 () == -1) {
14220 printf ("test_command_lines_6 FAILED\n");
14224 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
14225 if (test_command_lines_7 () == -1) {
14226 printf ("test_command_lines_7 FAILED\n");
14230 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
14231 if (test_command_lines_8 () == -1) {
14232 printf ("test_command_lines_8 FAILED\n");
14236 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
14237 if (test_command_lines_9 () == -1) {
14238 printf ("test_command_lines_9 FAILED\n");
14242 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
14243 if (test_command_lines_10 () == -1) {
14244 printf ("test_command_lines_10 FAILED\n");
14248 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
14249 if (test_command_0 () == -1) {
14250 printf ("test_command_0 FAILED\n");
14254 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
14255 if (test_command_1 () == -1) {
14256 printf ("test_command_1 FAILED\n");
14260 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
14261 if (test_command_2 () == -1) {
14262 printf ("test_command_2 FAILED\n");
14266 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
14267 if (test_command_3 () == -1) {
14268 printf ("test_command_3 FAILED\n");
14272 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
14273 if (test_command_4 () == -1) {
14274 printf ("test_command_4 FAILED\n");
14278 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
14279 if (test_command_5 () == -1) {
14280 printf ("test_command_5 FAILED\n");
14284 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
14285 if (test_command_6 () == -1) {
14286 printf ("test_command_6 FAILED\n");
14290 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
14291 if (test_command_7 () == -1) {
14292 printf ("test_command_7 FAILED\n");
14296 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
14297 if (test_command_8 () == -1) {
14298 printf ("test_command_8 FAILED\n");
14302 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
14303 if (test_command_9 () == -1) {
14304 printf ("test_command_9 FAILED\n");
14308 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
14309 if (test_command_10 () == -1) {
14310 printf ("test_command_10 FAILED\n");
14314 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
14315 if (test_command_11 () == -1) {
14316 printf ("test_command_11 FAILED\n");
14320 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
14321 if (test_file_0 () == -1) {
14322 printf ("test_file_0 FAILED\n");
14326 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
14327 if (test_file_1 () == -1) {
14328 printf ("test_file_1 FAILED\n");
14332 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
14333 if (test_file_2 () == -1) {
14334 printf ("test_file_2 FAILED\n");
14338 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
14339 if (test_umount_all_0 () == -1) {
14340 printf ("test_umount_all_0 FAILED\n");
14344 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
14345 if (test_umount_all_1 () == -1) {
14346 printf ("test_umount_all_1 FAILED\n");
14350 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
14351 if (test_mounts_0 () == -1) {
14352 printf ("test_mounts_0 FAILED\n");
14356 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
14357 if (test_umount_0 () == -1) {
14358 printf ("test_umount_0 FAILED\n");
14362 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
14363 if (test_umount_1 () == -1) {
14364 printf ("test_umount_1 FAILED\n");
14368 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
14369 if (test_write_file_0 () == -1) {
14370 printf ("test_write_file_0 FAILED\n");
14374 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
14375 if (test_write_file_1 () == -1) {
14376 printf ("test_write_file_1 FAILED\n");
14380 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
14381 if (test_write_file_2 () == -1) {
14382 printf ("test_write_file_2 FAILED\n");
14386 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
14387 if (test_write_file_3 () == -1) {
14388 printf ("test_write_file_3 FAILED\n");
14392 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
14393 if (test_write_file_4 () == -1) {
14394 printf ("test_write_file_4 FAILED\n");
14398 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
14399 if (test_write_file_5 () == -1) {
14400 printf ("test_write_file_5 FAILED\n");
14404 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
14405 if (test_mkfs_0 () == -1) {
14406 printf ("test_mkfs_0 FAILED\n");
14410 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
14411 if (test_lvcreate_0 () == -1) {
14412 printf ("test_lvcreate_0 FAILED\n");
14416 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
14417 if (test_vgcreate_0 () == -1) {
14418 printf ("test_vgcreate_0 FAILED\n");
14422 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
14423 if (test_pvcreate_0 () == -1) {
14424 printf ("test_pvcreate_0 FAILED\n");
14428 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
14429 if (test_is_dir_0 () == -1) {
14430 printf ("test_is_dir_0 FAILED\n");
14434 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
14435 if (test_is_dir_1 () == -1) {
14436 printf ("test_is_dir_1 FAILED\n");
14440 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
14441 if (test_is_file_0 () == -1) {
14442 printf ("test_is_file_0 FAILED\n");
14446 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
14447 if (test_is_file_1 () == -1) {
14448 printf ("test_is_file_1 FAILED\n");
14452 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
14453 if (test_exists_0 () == -1) {
14454 printf ("test_exists_0 FAILED\n");
14458 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
14459 if (test_exists_1 () == -1) {
14460 printf ("test_exists_1 FAILED\n");
14464 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
14465 if (test_mkdir_p_0 () == -1) {
14466 printf ("test_mkdir_p_0 FAILED\n");
14470 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
14471 if (test_mkdir_p_1 () == -1) {
14472 printf ("test_mkdir_p_1 FAILED\n");
14476 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
14477 if (test_mkdir_p_2 () == -1) {
14478 printf ("test_mkdir_p_2 FAILED\n");
14482 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
14483 if (test_mkdir_0 () == -1) {
14484 printf ("test_mkdir_0 FAILED\n");
14488 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
14489 if (test_mkdir_1 () == -1) {
14490 printf ("test_mkdir_1 FAILED\n");
14494 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
14495 if (test_rm_rf_0 () == -1) {
14496 printf ("test_rm_rf_0 FAILED\n");
14500 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
14501 if (test_rmdir_0 () == -1) {
14502 printf ("test_rmdir_0 FAILED\n");
14506 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14507 if (test_rmdir_1 () == -1) {
14508 printf ("test_rmdir_1 FAILED\n");
14512 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14513 if (test_rmdir_2 () == -1) {
14514 printf ("test_rmdir_2 FAILED\n");
14518 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14519 if (test_rm_0 () == -1) {
14520 printf ("test_rm_0 FAILED\n");
14524 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14525 if (test_rm_1 () == -1) {
14526 printf ("test_rm_1 FAILED\n");
14530 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14531 if (test_rm_2 () == -1) {
14532 printf ("test_rm_2 FAILED\n");
14536 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14537 if (test_read_lines_0 () == -1) {
14538 printf ("test_read_lines_0 FAILED\n");
14542 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14543 if (test_read_lines_1 () == -1) {
14544 printf ("test_read_lines_1 FAILED\n");
14548 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14549 if (test_lvs_0 () == -1) {
14550 printf ("test_lvs_0 FAILED\n");
14554 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14555 if (test_lvs_1 () == -1) {
14556 printf ("test_lvs_1 FAILED\n");
14560 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14561 if (test_vgs_0 () == -1) {
14562 printf ("test_vgs_0 FAILED\n");
14566 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14567 if (test_vgs_1 () == -1) {
14568 printf ("test_vgs_1 FAILED\n");
14572 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14573 if (test_pvs_0 () == -1) {
14574 printf ("test_pvs_0 FAILED\n");
14578 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14579 if (test_pvs_1 () == -1) {
14580 printf ("test_pvs_1 FAILED\n");
14584 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14585 if (test_list_partitions_0 () == -1) {
14586 printf ("test_list_partitions_0 FAILED\n");
14590 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14591 if (test_list_partitions_1 () == -1) {
14592 printf ("test_list_partitions_1 FAILED\n");
14596 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14597 if (test_list_devices_0 () == -1) {
14598 printf ("test_list_devices_0 FAILED\n");
14602 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14603 if (test_ls_0 () == -1) {
14604 printf ("test_ls_0 FAILED\n");
14608 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14609 if (test_cat_0 () == -1) {
14610 printf ("test_cat_0 FAILED\n");
14614 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14615 if (test_touch_0 () == -1) {
14616 printf ("test_touch_0 FAILED\n");
14620 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14621 if (test_sync_0 () == -1) {
14622 printf ("test_sync_0 FAILED\n");
14626 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14627 if (test_mount_0 () == -1) {
14628 printf ("test_mount_0 FAILED\n");
14633 unlink ("test1.img");
14634 unlink ("test2.img");
14635 unlink ("test3.img");
14638 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);