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");
127 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
130 static int test_find_0 (void)
132 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
134 char device[] = "/dev/sda";
138 r = guestfs_blockdev_setrw (g, device);
145 r = guestfs_umount_all (g);
152 r = guestfs_lvm_remove_all (g);
157 char device[] = "/dev/sda";
159 char lines_0[] = ",";
166 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
171 char fstype[] = "ext2";
172 char device[] = "/dev/sda1";
176 r = guestfs_mkfs (g, fstype, device);
181 char device[] = "/dev/sda1";
183 char mountpoint[] = "/";
186 r = guestfs_mount (g, device, mountpoint);
190 /* TestOutputList for find (0) */
192 char directory[] = "/";
196 r = guestfs_find (g, directory);
200 fprintf (stderr, "test_find_0: short list returned from command\n");
205 char expected[] = "lost+found";
206 if (strcmp (r[0], expected) != 0) {
207 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
212 fprintf (stderr, "test_find_0: extra elements returned from command\n");
216 for (i = 0; r[i] != NULL; ++i)
223 static int test_find_1 (void)
225 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
227 char device[] = "/dev/sda";
231 r = guestfs_blockdev_setrw (g, device);
238 r = guestfs_umount_all (g);
245 r = guestfs_lvm_remove_all (g);
250 char device[] = "/dev/sda";
252 char lines_0[] = ",";
259 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
264 char fstype[] = "ext2";
265 char device[] = "/dev/sda1";
269 r = guestfs_mkfs (g, fstype, device);
274 char device[] = "/dev/sda1";
276 char mountpoint[] = "/";
279 r = guestfs_mount (g, device, mountpoint);
283 /* TestOutputList for find (1) */
288 r = guestfs_touch (g, path);
296 r = guestfs_mkdir (g, path);
301 char path[] = "/b/c";
304 r = guestfs_touch (g, path);
309 char directory[] = "/";
313 r = guestfs_find (g, directory);
317 fprintf (stderr, "test_find_1: short list returned from command\n");
322 char expected[] = "a";
323 if (strcmp (r[0], expected) != 0) {
324 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
329 fprintf (stderr, "test_find_1: short list returned from command\n");
334 char expected[] = "b";
335 if (strcmp (r[1], expected) != 0) {
336 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
341 fprintf (stderr, "test_find_1: short list returned from command\n");
346 char expected[] = "b/c";
347 if (strcmp (r[2], expected) != 0) {
348 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
353 fprintf (stderr, "test_find_1: short list returned from command\n");
358 char expected[] = "lost+found";
359 if (strcmp (r[3], expected) != 0) {
360 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
365 fprintf (stderr, "test_find_1: extra elements returned from command\n");
369 for (i = 0; r[i] != NULL; ++i)
376 static int test_find_2 (void)
378 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
380 char device[] = "/dev/sda";
384 r = guestfs_blockdev_setrw (g, device);
391 r = guestfs_umount_all (g);
398 r = guestfs_lvm_remove_all (g);
403 char device[] = "/dev/sda";
405 char lines_0[] = ",";
412 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
417 char fstype[] = "ext2";
418 char device[] = "/dev/sda1";
422 r = guestfs_mkfs (g, fstype, device);
427 char device[] = "/dev/sda1";
429 char mountpoint[] = "/";
432 r = guestfs_mount (g, device, mountpoint);
436 /* TestOutputList for find (2) */
438 char path[] = "/a/b/c";
441 r = guestfs_mkdir_p (g, path);
446 char path[] = "/a/b/c/d";
449 r = guestfs_touch (g, path);
454 char directory[] = "/a/b/";
458 r = guestfs_find (g, directory);
462 fprintf (stderr, "test_find_2: short list returned from command\n");
467 char expected[] = "c";
468 if (strcmp (r[0], expected) != 0) {
469 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
474 fprintf (stderr, "test_find_2: short list returned from command\n");
479 char expected[] = "c/d";
480 if (strcmp (r[1], expected) != 0) {
481 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
486 fprintf (stderr, "test_find_2: extra elements returned from command\n");
490 for (i = 0; r[i] != NULL; ++i)
497 static int test_lvresize_0 (void)
499 /* InitNone|InitEmpty for test_lvresize_0 */
501 char device[] = "/dev/sda";
505 r = guestfs_blockdev_setrw (g, device);
512 r = guestfs_umount_all (g);
519 r = guestfs_lvm_remove_all (g);
523 /* TestOutput for lvresize (0) */
524 char expected[] = "test content";
526 char device[] = "/dev/sda";
528 char lines_0[] = ",";
535 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
540 char device[] = "/dev/sda1";
544 r = guestfs_pvcreate (g, device);
549 char volgroup[] = "VG";
550 char physvols_0[] = "/dev/sda1";
551 physvols_0[5] = devchar;
558 r = guestfs_vgcreate (g, volgroup, physvols);
563 char logvol[] = "LV";
564 char volgroup[] = "VG";
567 r = guestfs_lvcreate (g, logvol, volgroup, 10);
572 char fstype[] = "ext2";
573 char device[] = "/dev/VG/LV";
576 r = guestfs_mkfs (g, fstype, device);
581 char device[] = "/dev/VG/LV";
582 char mountpoint[] = "/";
585 r = guestfs_mount (g, device, mountpoint);
590 char path[] = "/new";
591 char content[] = "test content";
594 r = guestfs_write_file (g, path, content, 0);
599 char pathordevice[] = "/";
602 r = guestfs_umount (g, pathordevice);
607 char device[] = "/dev/VG/LV";
610 r = guestfs_lvresize (g, device, 20);
615 char device[] = "/dev/VG/LV";
618 r = guestfs_e2fsck_f (g, device);
623 char device[] = "/dev/VG/LV";
626 r = guestfs_resize2fs (g, device);
631 char device[] = "/dev/VG/LV";
632 char mountpoint[] = "/";
635 r = guestfs_mount (g, device, mountpoint);
640 char path[] = "/new";
643 r = guestfs_cat (g, path);
646 if (strcmp (r, expected) != 0) {
647 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
655 static int test_zerofree_0_prereq (void)
657 const char *str = getenv ("SKIP_ZEROFREE");
658 return str && strcmp (str, "1") == 0;
661 static int test_zerofree_0 (void)
663 if (! test_zerofree_0_prereq ()) {
664 /* InitNone|InitEmpty for test_zerofree_0 */
666 char device[] = "/dev/sda";
670 r = guestfs_blockdev_setrw (g, device);
677 r = guestfs_umount_all (g);
684 r = guestfs_lvm_remove_all (g);
688 /* TestOutput for zerofree (0) */
689 char expected[] = "test file";
691 char device[] = "/dev/sda";
693 char lines_0[] = ",";
700 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
705 char fstype[] = "ext3";
706 char device[] = "/dev/sda1";
710 r = guestfs_mkfs (g, fstype, device);
715 char device[] = "/dev/sda1";
717 char mountpoint[] = "/";
720 r = guestfs_mount (g, device, mountpoint);
725 char path[] = "/new";
726 char content[] = "test file";
729 r = guestfs_write_file (g, path, content, 0);
734 char pathordevice[] = "/dev/sda1";
735 pathordevice[5] = devchar;
738 r = guestfs_umount (g, pathordevice);
743 char device[] = "/dev/sda1";
747 r = guestfs_zerofree (g, device);
752 char device[] = "/dev/sda1";
754 char mountpoint[] = "/";
757 r = guestfs_mount (g, device, mountpoint);
762 char path[] = "/new";
765 r = guestfs_cat (g, path);
768 if (strcmp (r, expected) != 0) {
769 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
775 printf ("%s skipped (reason: test prerequisite)\n", "test_zerofree_0");
779 static int test_hexdump_0 (void)
781 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
783 char device[] = "/dev/sda";
787 r = guestfs_blockdev_setrw (g, device);
794 r = guestfs_umount_all (g);
801 r = guestfs_lvm_remove_all (g);
806 char device[] = "/dev/sda";
808 char lines_0[] = ",";
815 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
820 char fstype[] = "ext2";
821 char device[] = "/dev/sda1";
825 r = guestfs_mkfs (g, fstype, device);
830 char device[] = "/dev/sda1";
832 char mountpoint[] = "/";
835 r = guestfs_mount (g, device, mountpoint);
839 /* TestOutput for hexdump (0) */
840 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
842 char path[] = "/new";
843 char content[] = "hello\nworld\n";
846 r = guestfs_write_file (g, path, content, 12);
851 char path[] = "/new";
854 r = guestfs_hexdump (g, path);
857 if (strcmp (r, expected) != 0) {
858 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
866 static int test_strings_e_0 (void)
868 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
870 char device[] = "/dev/sda";
874 r = guestfs_blockdev_setrw (g, device);
881 r = guestfs_umount_all (g);
888 r = guestfs_lvm_remove_all (g);
893 char device[] = "/dev/sda";
895 char lines_0[] = ",";
902 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
907 char fstype[] = "ext2";
908 char device[] = "/dev/sda1";
912 r = guestfs_mkfs (g, fstype, device);
917 char device[] = "/dev/sda1";
919 char mountpoint[] = "/";
922 r = guestfs_mount (g, device, mountpoint);
926 /* TestOutputList for strings_e (0) */
928 char path[] = "/new";
929 char content[] = "hello\nworld\n";
932 r = guestfs_write_file (g, path, content, 0);
937 char encoding[] = "b";
938 char path[] = "/new";
942 r = guestfs_strings_e (g, encoding, path);
946 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
950 for (i = 0; r[i] != NULL; ++i)
957 static int test_strings_e_1 (void)
959 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
963 static int test_strings_0 (void)
965 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
967 char device[] = "/dev/sda";
971 r = guestfs_blockdev_setrw (g, device);
978 r = guestfs_umount_all (g);
985 r = guestfs_lvm_remove_all (g);
990 char device[] = "/dev/sda";
992 char lines_0[] = ",";
999 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1004 char fstype[] = "ext2";
1005 char device[] = "/dev/sda1";
1006 device[5] = devchar;
1009 r = guestfs_mkfs (g, fstype, device);
1014 char device[] = "/dev/sda1";
1015 device[5] = devchar;
1016 char mountpoint[] = "/";
1019 r = guestfs_mount (g, device, mountpoint);
1023 /* TestOutputList for strings (0) */
1025 char path[] = "/new";
1026 char content[] = "hello\nworld\n";
1029 r = guestfs_write_file (g, path, content, 0);
1034 char path[] = "/new";
1038 r = guestfs_strings (g, path);
1042 fprintf (stderr, "test_strings_0: short list returned from command\n");
1047 char expected[] = "hello";
1048 if (strcmp (r[0], expected) != 0) {
1049 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1054 fprintf (stderr, "test_strings_0: short list returned from command\n");
1059 char expected[] = "world";
1060 if (strcmp (r[1], expected) != 0) {
1061 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1066 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1070 for (i = 0; r[i] != NULL; ++i)
1077 static int test_strings_1 (void)
1079 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1081 char device[] = "/dev/sda";
1082 device[5] = devchar;
1085 r = guestfs_blockdev_setrw (g, device);
1092 r = guestfs_umount_all (g);
1099 r = guestfs_lvm_remove_all (g);
1104 char device[] = "/dev/sda";
1105 device[5] = devchar;
1106 char lines_0[] = ",";
1113 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1118 char fstype[] = "ext2";
1119 char device[] = "/dev/sda1";
1120 device[5] = devchar;
1123 r = guestfs_mkfs (g, fstype, device);
1128 char device[] = "/dev/sda1";
1129 device[5] = devchar;
1130 char mountpoint[] = "/";
1133 r = guestfs_mount (g, device, mountpoint);
1137 /* TestOutputList for strings (1) */
1139 char path[] = "/new";
1142 r = guestfs_touch (g, path);
1147 char path[] = "/new";
1151 r = guestfs_strings (g, path);
1155 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1159 for (i = 0; r[i] != NULL; ++i)
1166 static int test_equal_0 (void)
1168 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1170 char device[] = "/dev/sda";
1171 device[5] = devchar;
1174 r = guestfs_blockdev_setrw (g, device);
1181 r = guestfs_umount_all (g);
1188 r = guestfs_lvm_remove_all (g);
1193 char device[] = "/dev/sda";
1194 device[5] = devchar;
1195 char lines_0[] = ",";
1202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1207 char fstype[] = "ext2";
1208 char device[] = "/dev/sda1";
1209 device[5] = devchar;
1212 r = guestfs_mkfs (g, fstype, device);
1217 char device[] = "/dev/sda1";
1218 device[5] = devchar;
1219 char mountpoint[] = "/";
1222 r = guestfs_mount (g, device, mountpoint);
1226 /* TestOutputTrue for equal (0) */
1228 char path[] = "/file1";
1229 char content[] = "contents of a file";
1232 r = guestfs_write_file (g, path, content, 0);
1237 char src[] = "/file1";
1238 char dest[] = "/file2";
1241 r = guestfs_cp (g, src, dest);
1246 char file1[] = "/file1";
1247 char file2[] = "/file2";
1250 r = guestfs_equal (g, file1, file2);
1254 fprintf (stderr, "test_equal_0: expected true, got false\n");
1261 static int test_equal_1 (void)
1263 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1265 char device[] = "/dev/sda";
1266 device[5] = devchar;
1269 r = guestfs_blockdev_setrw (g, device);
1276 r = guestfs_umount_all (g);
1283 r = guestfs_lvm_remove_all (g);
1288 char device[] = "/dev/sda";
1289 device[5] = devchar;
1290 char lines_0[] = ",";
1297 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1302 char fstype[] = "ext2";
1303 char device[] = "/dev/sda1";
1304 device[5] = devchar;
1307 r = guestfs_mkfs (g, fstype, device);
1312 char device[] = "/dev/sda1";
1313 device[5] = devchar;
1314 char mountpoint[] = "/";
1317 r = guestfs_mount (g, device, mountpoint);
1321 /* TestOutputFalse for equal (1) */
1323 char path[] = "/file1";
1324 char content[] = "contents of a file";
1327 r = guestfs_write_file (g, path, content, 0);
1332 char path[] = "/file2";
1333 char content[] = "contents of another file";
1336 r = guestfs_write_file (g, path, content, 0);
1341 char file1[] = "/file1";
1342 char file2[] = "/file2";
1345 r = guestfs_equal (g, file1, file2);
1349 fprintf (stderr, "test_equal_1: expected false, got true\n");
1356 static int test_equal_2 (void)
1358 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1360 char device[] = "/dev/sda";
1361 device[5] = devchar;
1364 r = guestfs_blockdev_setrw (g, device);
1371 r = guestfs_umount_all (g);
1378 r = guestfs_lvm_remove_all (g);
1383 char device[] = "/dev/sda";
1384 device[5] = devchar;
1385 char lines_0[] = ",";
1392 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1397 char fstype[] = "ext2";
1398 char device[] = "/dev/sda1";
1399 device[5] = devchar;
1402 r = guestfs_mkfs (g, fstype, device);
1407 char device[] = "/dev/sda1";
1408 device[5] = devchar;
1409 char mountpoint[] = "/";
1412 r = guestfs_mount (g, device, mountpoint);
1416 /* TestLastFail for equal (2) */
1418 char file1[] = "/file1";
1419 char file2[] = "/file2";
1422 r = guestfs_equal (g, file1, file2);
1429 static int test_ping_daemon_0 (void)
1431 /* InitNone|InitEmpty for test_ping_daemon_0 */
1433 char device[] = "/dev/sda";
1434 device[5] = devchar;
1437 r = guestfs_blockdev_setrw (g, device);
1444 r = guestfs_umount_all (g);
1451 r = guestfs_lvm_remove_all (g);
1455 /* TestRun for ping_daemon (0) */
1459 r = guestfs_ping_daemon (g);
1466 static int test_dmesg_0 (void)
1468 /* InitNone|InitEmpty for test_dmesg_0 */
1470 char device[] = "/dev/sda";
1471 device[5] = devchar;
1474 r = guestfs_blockdev_setrw (g, device);
1481 r = guestfs_umount_all (g);
1488 r = guestfs_lvm_remove_all (g);
1492 /* TestRun for dmesg (0) */
1496 r = guestfs_dmesg (g);
1504 static int test_drop_caches_0 (void)
1506 /* InitNone|InitEmpty for test_drop_caches_0 */
1508 char device[] = "/dev/sda";
1509 device[5] = devchar;
1512 r = guestfs_blockdev_setrw (g, device);
1519 r = guestfs_umount_all (g);
1526 r = guestfs_lvm_remove_all (g);
1530 /* TestRun for drop_caches (0) */
1534 r = guestfs_drop_caches (g, 3);
1541 static int test_mv_0 (void)
1543 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1545 char device[] = "/dev/sda";
1546 device[5] = devchar;
1549 r = guestfs_blockdev_setrw (g, device);
1556 r = guestfs_umount_all (g);
1563 r = guestfs_lvm_remove_all (g);
1568 char device[] = "/dev/sda";
1569 device[5] = devchar;
1570 char lines_0[] = ",";
1577 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1582 char fstype[] = "ext2";
1583 char device[] = "/dev/sda1";
1584 device[5] = devchar;
1587 r = guestfs_mkfs (g, fstype, device);
1592 char device[] = "/dev/sda1";
1593 device[5] = devchar;
1594 char mountpoint[] = "/";
1597 r = guestfs_mount (g, device, mountpoint);
1601 /* TestOutput for mv (0) */
1602 char expected[] = "file content";
1604 char path[] = "/old";
1605 char content[] = "file content";
1608 r = guestfs_write_file (g, path, content, 0);
1613 char src[] = "/old";
1614 char dest[] = "/new";
1617 r = guestfs_mv (g, src, dest);
1622 char path[] = "/new";
1625 r = guestfs_cat (g, path);
1628 if (strcmp (r, expected) != 0) {
1629 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1637 static int test_mv_1 (void)
1639 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1641 char device[] = "/dev/sda";
1642 device[5] = devchar;
1645 r = guestfs_blockdev_setrw (g, device);
1652 r = guestfs_umount_all (g);
1659 r = guestfs_lvm_remove_all (g);
1664 char device[] = "/dev/sda";
1665 device[5] = devchar;
1666 char lines_0[] = ",";
1673 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1678 char fstype[] = "ext2";
1679 char device[] = "/dev/sda1";
1680 device[5] = devchar;
1683 r = guestfs_mkfs (g, fstype, device);
1688 char device[] = "/dev/sda1";
1689 device[5] = devchar;
1690 char mountpoint[] = "/";
1693 r = guestfs_mount (g, device, mountpoint);
1697 /* TestOutputFalse for mv (1) */
1699 char path[] = "/old";
1700 char content[] = "file content";
1703 r = guestfs_write_file (g, path, content, 0);
1708 char src[] = "/old";
1709 char dest[] = "/new";
1712 r = guestfs_mv (g, src, dest);
1717 char path[] = "/old";
1720 r = guestfs_is_file (g, path);
1724 fprintf (stderr, "test_mv_1: expected false, got true\n");
1731 static int test_cp_a_0 (void)
1733 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1735 char device[] = "/dev/sda";
1736 device[5] = devchar;
1739 r = guestfs_blockdev_setrw (g, device);
1746 r = guestfs_umount_all (g);
1753 r = guestfs_lvm_remove_all (g);
1758 char device[] = "/dev/sda";
1759 device[5] = devchar;
1760 char lines_0[] = ",";
1767 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1772 char fstype[] = "ext2";
1773 char device[] = "/dev/sda1";
1774 device[5] = devchar;
1777 r = guestfs_mkfs (g, fstype, device);
1782 char device[] = "/dev/sda1";
1783 device[5] = devchar;
1784 char mountpoint[] = "/";
1787 r = guestfs_mount (g, device, mountpoint);
1791 /* TestOutput for cp_a (0) */
1792 char expected[] = "file content";
1794 char path[] = "/olddir";
1797 r = guestfs_mkdir (g, path);
1802 char path[] = "/newdir";
1805 r = guestfs_mkdir (g, path);
1810 char path[] = "/olddir/file";
1811 char content[] = "file content";
1814 r = guestfs_write_file (g, path, content, 0);
1819 char src[] = "/olddir";
1820 char dest[] = "/newdir";
1823 r = guestfs_cp_a (g, src, dest);
1828 char path[] = "/newdir/olddir/file";
1831 r = guestfs_cat (g, path);
1834 if (strcmp (r, expected) != 0) {
1835 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1843 static int test_cp_0 (void)
1845 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1847 char device[] = "/dev/sda";
1848 device[5] = devchar;
1851 r = guestfs_blockdev_setrw (g, device);
1858 r = guestfs_umount_all (g);
1865 r = guestfs_lvm_remove_all (g);
1870 char device[] = "/dev/sda";
1871 device[5] = devchar;
1872 char lines_0[] = ",";
1879 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1884 char fstype[] = "ext2";
1885 char device[] = "/dev/sda1";
1886 device[5] = devchar;
1889 r = guestfs_mkfs (g, fstype, device);
1894 char device[] = "/dev/sda1";
1895 device[5] = devchar;
1896 char mountpoint[] = "/";
1899 r = guestfs_mount (g, device, mountpoint);
1903 /* TestOutput for cp (0) */
1904 char expected[] = "file content";
1906 char path[] = "/old";
1907 char content[] = "file content";
1910 r = guestfs_write_file (g, path, content, 0);
1915 char src[] = "/old";
1916 char dest[] = "/new";
1919 r = guestfs_cp (g, src, dest);
1924 char path[] = "/new";
1927 r = guestfs_cat (g, path);
1930 if (strcmp (r, expected) != 0) {
1931 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1939 static int test_cp_1 (void)
1941 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1943 char device[] = "/dev/sda";
1944 device[5] = devchar;
1947 r = guestfs_blockdev_setrw (g, device);
1954 r = guestfs_umount_all (g);
1961 r = guestfs_lvm_remove_all (g);
1966 char device[] = "/dev/sda";
1967 device[5] = devchar;
1968 char lines_0[] = ",";
1975 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1980 char fstype[] = "ext2";
1981 char device[] = "/dev/sda1";
1982 device[5] = devchar;
1985 r = guestfs_mkfs (g, fstype, device);
1990 char device[] = "/dev/sda1";
1991 device[5] = devchar;
1992 char mountpoint[] = "/";
1995 r = guestfs_mount (g, device, mountpoint);
1999 /* TestOutputTrue for cp (1) */
2001 char path[] = "/old";
2002 char content[] = "file content";
2005 r = guestfs_write_file (g, path, content, 0);
2010 char src[] = "/old";
2011 char dest[] = "/new";
2014 r = guestfs_cp (g, src, dest);
2019 char path[] = "/old";
2022 r = guestfs_is_file (g, path);
2026 fprintf (stderr, "test_cp_1: expected true, got false\n");
2033 static int test_cp_2 (void)
2035 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2037 char device[] = "/dev/sda";
2038 device[5] = devchar;
2041 r = guestfs_blockdev_setrw (g, device);
2048 r = guestfs_umount_all (g);
2055 r = guestfs_lvm_remove_all (g);
2060 char device[] = "/dev/sda";
2061 device[5] = devchar;
2062 char lines_0[] = ",";
2069 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2074 char fstype[] = "ext2";
2075 char device[] = "/dev/sda1";
2076 device[5] = devchar;
2079 r = guestfs_mkfs (g, fstype, device);
2084 char device[] = "/dev/sda1";
2085 device[5] = devchar;
2086 char mountpoint[] = "/";
2089 r = guestfs_mount (g, device, mountpoint);
2093 /* TestOutput for cp (2) */
2094 char expected[] = "file content";
2096 char path[] = "/old";
2097 char content[] = "file content";
2100 r = guestfs_write_file (g, path, content, 0);
2105 char path[] = "/dir";
2108 r = guestfs_mkdir (g, path);
2113 char src[] = "/old";
2114 char dest[] = "/dir/new";
2117 r = guestfs_cp (g, src, dest);
2122 char path[] = "/dir/new";
2125 r = guestfs_cat (g, path);
2128 if (strcmp (r, expected) != 0) {
2129 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2137 static int test_grub_install_0 (void)
2139 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2141 char device[] = "/dev/sda";
2142 device[5] = devchar;
2145 r = guestfs_blockdev_setrw (g, device);
2152 r = guestfs_umount_all (g);
2159 r = guestfs_lvm_remove_all (g);
2164 char device[] = "/dev/sda";
2165 device[5] = devchar;
2166 char lines_0[] = ",";
2173 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2178 char fstype[] = "ext2";
2179 char device[] = "/dev/sda1";
2180 device[5] = devchar;
2183 r = guestfs_mkfs (g, fstype, device);
2188 char device[] = "/dev/sda1";
2189 device[5] = devchar;
2190 char mountpoint[] = "/";
2193 r = guestfs_mount (g, device, mountpoint);
2197 /* TestOutputTrue for grub_install (0) */
2200 char device[] = "/dev/sda1";
2201 device[5] = devchar;
2204 r = guestfs_grub_install (g, root, device);
2209 char path[] = "/boot";
2212 r = guestfs_is_dir (g, path);
2216 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2223 static int test_zero_0 (void)
2225 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2227 char device[] = "/dev/sda";
2228 device[5] = devchar;
2231 r = guestfs_blockdev_setrw (g, device);
2238 r = guestfs_umount_all (g);
2245 r = guestfs_lvm_remove_all (g);
2250 char device[] = "/dev/sda";
2251 device[5] = devchar;
2252 char lines_0[] = ",";
2259 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2264 char fstype[] = "ext2";
2265 char device[] = "/dev/sda1";
2266 device[5] = devchar;
2269 r = guestfs_mkfs (g, fstype, device);
2274 char device[] = "/dev/sda1";
2275 device[5] = devchar;
2276 char mountpoint[] = "/";
2279 r = guestfs_mount (g, device, mountpoint);
2283 /* TestOutput for zero (0) */
2284 char expected[] = "data";
2286 char pathordevice[] = "/dev/sda1";
2287 pathordevice[5] = devchar;
2290 r = guestfs_umount (g, pathordevice);
2295 char device[] = "/dev/sda1";
2296 device[5] = devchar;
2299 r = guestfs_zero (g, device);
2304 char path[] = "/dev/sda1";
2308 r = guestfs_file (g, path);
2311 if (strcmp (r, expected) != 0) {
2312 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2320 static int test_fsck_0 (void)
2322 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2324 char device[] = "/dev/sda";
2325 device[5] = devchar;
2328 r = guestfs_blockdev_setrw (g, device);
2335 r = guestfs_umount_all (g);
2342 r = guestfs_lvm_remove_all (g);
2347 char device[] = "/dev/sda";
2348 device[5] = devchar;
2349 char lines_0[] = ",";
2356 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2361 char fstype[] = "ext2";
2362 char device[] = "/dev/sda1";
2363 device[5] = devchar;
2366 r = guestfs_mkfs (g, fstype, device);
2371 char device[] = "/dev/sda1";
2372 device[5] = devchar;
2373 char mountpoint[] = "/";
2376 r = guestfs_mount (g, device, mountpoint);
2380 /* TestOutputInt for fsck (0) */
2382 char pathordevice[] = "/dev/sda1";
2383 pathordevice[5] = devchar;
2386 r = guestfs_umount (g, pathordevice);
2391 char fstype[] = "ext2";
2392 char device[] = "/dev/sda1";
2393 device[5] = devchar;
2396 r = guestfs_fsck (g, fstype, device);
2400 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2407 static int test_fsck_1 (void)
2409 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2411 char device[] = "/dev/sda";
2412 device[5] = devchar;
2415 r = guestfs_blockdev_setrw (g, device);
2422 r = guestfs_umount_all (g);
2429 r = guestfs_lvm_remove_all (g);
2434 char device[] = "/dev/sda";
2435 device[5] = devchar;
2436 char lines_0[] = ",";
2443 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2448 char fstype[] = "ext2";
2449 char device[] = "/dev/sda1";
2450 device[5] = devchar;
2453 r = guestfs_mkfs (g, fstype, device);
2458 char device[] = "/dev/sda1";
2459 device[5] = devchar;
2460 char mountpoint[] = "/";
2463 r = guestfs_mount (g, device, mountpoint);
2467 /* TestOutputInt for fsck (1) */
2469 char pathordevice[] = "/dev/sda1";
2470 pathordevice[5] = devchar;
2473 r = guestfs_umount (g, pathordevice);
2478 char device[] = "/dev/sda1";
2479 device[5] = devchar;
2482 r = guestfs_zero (g, device);
2487 char fstype[] = "ext2";
2488 char device[] = "/dev/sda1";
2489 device[5] = devchar;
2492 r = guestfs_fsck (g, fstype, device);
2496 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
2503 static int test_set_e2uuid_0 (void)
2505 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2507 char device[] = "/dev/sda";
2508 device[5] = devchar;
2511 r = guestfs_blockdev_setrw (g, device);
2518 r = guestfs_umount_all (g);
2525 r = guestfs_lvm_remove_all (g);
2530 char device[] = "/dev/sda";
2531 device[5] = devchar;
2532 char lines_0[] = ",";
2539 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2544 char fstype[] = "ext2";
2545 char device[] = "/dev/sda1";
2546 device[5] = devchar;
2549 r = guestfs_mkfs (g, fstype, device);
2554 char device[] = "/dev/sda1";
2555 device[5] = devchar;
2556 char mountpoint[] = "/";
2559 r = guestfs_mount (g, device, mountpoint);
2563 /* TestOutput for set_e2uuid (0) */
2564 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2566 char device[] = "/dev/sda1";
2567 device[5] = devchar;
2568 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2571 r = guestfs_set_e2uuid (g, device, uuid);
2576 char device[] = "/dev/sda1";
2577 device[5] = devchar;
2580 r = guestfs_get_e2uuid (g, device);
2583 if (strcmp (r, expected) != 0) {
2584 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2592 static int test_set_e2uuid_1 (void)
2594 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2596 char device[] = "/dev/sda";
2597 device[5] = devchar;
2600 r = guestfs_blockdev_setrw (g, device);
2607 r = guestfs_umount_all (g);
2614 r = guestfs_lvm_remove_all (g);
2619 char device[] = "/dev/sda";
2620 device[5] = devchar;
2621 char lines_0[] = ",";
2628 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2633 char fstype[] = "ext2";
2634 char device[] = "/dev/sda1";
2635 device[5] = devchar;
2638 r = guestfs_mkfs (g, fstype, device);
2643 char device[] = "/dev/sda1";
2644 device[5] = devchar;
2645 char mountpoint[] = "/";
2648 r = guestfs_mount (g, device, mountpoint);
2652 /* TestOutput for set_e2uuid (1) */
2653 char expected[] = "";
2655 char device[] = "/dev/sda1";
2656 device[5] = devchar;
2657 char uuid[] = "clear";
2660 r = guestfs_set_e2uuid (g, device, uuid);
2665 char device[] = "/dev/sda1";
2666 device[5] = devchar;
2669 r = guestfs_get_e2uuid (g, device);
2672 if (strcmp (r, expected) != 0) {
2673 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2681 static int test_set_e2uuid_2 (void)
2683 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2685 char device[] = "/dev/sda";
2686 device[5] = devchar;
2689 r = guestfs_blockdev_setrw (g, device);
2696 r = guestfs_umount_all (g);
2703 r = guestfs_lvm_remove_all (g);
2708 char device[] = "/dev/sda";
2709 device[5] = devchar;
2710 char lines_0[] = ",";
2717 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2722 char fstype[] = "ext2";
2723 char device[] = "/dev/sda1";
2724 device[5] = devchar;
2727 r = guestfs_mkfs (g, fstype, device);
2732 char device[] = "/dev/sda1";
2733 device[5] = devchar;
2734 char mountpoint[] = "/";
2737 r = guestfs_mount (g, device, mountpoint);
2741 /* TestRun for set_e2uuid (2) */
2743 char device[] = "/dev/sda1";
2744 device[5] = devchar;
2745 char uuid[] = "random";
2748 r = guestfs_set_e2uuid (g, device, uuid);
2755 static int test_set_e2uuid_3 (void)
2757 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2759 char device[] = "/dev/sda";
2760 device[5] = devchar;
2763 r = guestfs_blockdev_setrw (g, device);
2770 r = guestfs_umount_all (g);
2777 r = guestfs_lvm_remove_all (g);
2782 char device[] = "/dev/sda";
2783 device[5] = devchar;
2784 char lines_0[] = ",";
2791 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2796 char fstype[] = "ext2";
2797 char device[] = "/dev/sda1";
2798 device[5] = devchar;
2801 r = guestfs_mkfs (g, fstype, device);
2806 char device[] = "/dev/sda1";
2807 device[5] = devchar;
2808 char mountpoint[] = "/";
2811 r = guestfs_mount (g, device, mountpoint);
2815 /* TestRun for set_e2uuid (3) */
2817 char device[] = "/dev/sda1";
2818 device[5] = devchar;
2819 char uuid[] = "time";
2822 r = guestfs_set_e2uuid (g, device, uuid);
2829 static int test_set_e2label_0 (void)
2831 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2833 char device[] = "/dev/sda";
2834 device[5] = devchar;
2837 r = guestfs_blockdev_setrw (g, device);
2844 r = guestfs_umount_all (g);
2851 r = guestfs_lvm_remove_all (g);
2856 char device[] = "/dev/sda";
2857 device[5] = devchar;
2858 char lines_0[] = ",";
2865 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2870 char fstype[] = "ext2";
2871 char device[] = "/dev/sda1";
2872 device[5] = devchar;
2875 r = guestfs_mkfs (g, fstype, device);
2880 char device[] = "/dev/sda1";
2881 device[5] = devchar;
2882 char mountpoint[] = "/";
2885 r = guestfs_mount (g, device, mountpoint);
2889 /* TestOutput for set_e2label (0) */
2890 char expected[] = "testlabel";
2892 char device[] = "/dev/sda1";
2893 device[5] = devchar;
2894 char label[] = "testlabel";
2897 r = guestfs_set_e2label (g, device, label);
2902 char device[] = "/dev/sda1";
2903 device[5] = devchar;
2906 r = guestfs_get_e2label (g, device);
2909 if (strcmp (r, expected) != 0) {
2910 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2918 static int test_pvremove_0 (void)
2920 /* InitNone|InitEmpty for test_pvremove_0 */
2922 char device[] = "/dev/sda";
2923 device[5] = devchar;
2926 r = guestfs_blockdev_setrw (g, device);
2933 r = guestfs_umount_all (g);
2940 r = guestfs_lvm_remove_all (g);
2944 /* TestOutputList for pvremove (0) */
2946 char device[] = "/dev/sda";
2947 device[5] = devchar;
2948 char lines_0[] = ",";
2955 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2960 char device[] = "/dev/sda1";
2961 device[5] = devchar;
2964 r = guestfs_pvcreate (g, device);
2969 char volgroup[] = "VG";
2970 char physvols_0[] = "/dev/sda1";
2971 physvols_0[5] = devchar;
2972 char *physvols[] = {
2978 r = guestfs_vgcreate (g, volgroup, physvols);
2983 char logvol[] = "LV1";
2984 char volgroup[] = "VG";
2987 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2992 char logvol[] = "LV2";
2993 char volgroup[] = "VG";
2996 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3001 char vgname[] = "VG";
3004 r = guestfs_vgremove (g, vgname);
3009 char device[] = "/dev/sda1";
3010 device[5] = devchar;
3013 r = guestfs_pvremove (g, device);
3021 r = guestfs_lvs (g);
3025 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3029 for (i = 0; r[i] != NULL; ++i)
3036 static int test_pvremove_1 (void)
3038 /* InitNone|InitEmpty for test_pvremove_1 */
3040 char device[] = "/dev/sda";
3041 device[5] = devchar;
3044 r = guestfs_blockdev_setrw (g, device);
3051 r = guestfs_umount_all (g);
3058 r = guestfs_lvm_remove_all (g);
3062 /* TestOutputList for pvremove (1) */
3064 char device[] = "/dev/sda";
3065 device[5] = devchar;
3066 char lines_0[] = ",";
3073 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3078 char device[] = "/dev/sda1";
3079 device[5] = devchar;
3082 r = guestfs_pvcreate (g, device);
3087 char volgroup[] = "VG";
3088 char physvols_0[] = "/dev/sda1";
3089 physvols_0[5] = devchar;
3090 char *physvols[] = {
3096 r = guestfs_vgcreate (g, volgroup, physvols);
3101 char logvol[] = "LV1";
3102 char volgroup[] = "VG";
3105 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3110 char logvol[] = "LV2";
3111 char volgroup[] = "VG";
3114 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3119 char vgname[] = "VG";
3122 r = guestfs_vgremove (g, vgname);
3127 char device[] = "/dev/sda1";
3128 device[5] = devchar;
3131 r = guestfs_pvremove (g, device);
3139 r = guestfs_vgs (g);
3143 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3147 for (i = 0; r[i] != NULL; ++i)
3154 static int test_pvremove_2 (void)
3156 /* InitNone|InitEmpty for test_pvremove_2 */
3158 char device[] = "/dev/sda";
3159 device[5] = devchar;
3162 r = guestfs_blockdev_setrw (g, device);
3169 r = guestfs_umount_all (g);
3176 r = guestfs_lvm_remove_all (g);
3180 /* TestOutputList for pvremove (2) */
3182 char device[] = "/dev/sda";
3183 device[5] = devchar;
3184 char lines_0[] = ",";
3191 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3196 char device[] = "/dev/sda1";
3197 device[5] = devchar;
3200 r = guestfs_pvcreate (g, device);
3205 char volgroup[] = "VG";
3206 char physvols_0[] = "/dev/sda1";
3207 physvols_0[5] = devchar;
3208 char *physvols[] = {
3214 r = guestfs_vgcreate (g, volgroup, physvols);
3219 char logvol[] = "LV1";
3220 char volgroup[] = "VG";
3223 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3228 char logvol[] = "LV2";
3229 char volgroup[] = "VG";
3232 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3237 char vgname[] = "VG";
3240 r = guestfs_vgremove (g, vgname);
3245 char device[] = "/dev/sda1";
3246 device[5] = devchar;
3249 r = guestfs_pvremove (g, device);
3257 r = guestfs_pvs (g);
3261 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3265 for (i = 0; r[i] != NULL; ++i)
3272 static int test_vgremove_0 (void)
3274 /* InitNone|InitEmpty for test_vgremove_0 */
3276 char device[] = "/dev/sda";
3277 device[5] = devchar;
3280 r = guestfs_blockdev_setrw (g, device);
3287 r = guestfs_umount_all (g);
3294 r = guestfs_lvm_remove_all (g);
3298 /* TestOutputList for vgremove (0) */
3300 char device[] = "/dev/sda";
3301 device[5] = devchar;
3302 char lines_0[] = ",";
3309 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3314 char device[] = "/dev/sda1";
3315 device[5] = devchar;
3318 r = guestfs_pvcreate (g, device);
3323 char volgroup[] = "VG";
3324 char physvols_0[] = "/dev/sda1";
3325 physvols_0[5] = devchar;
3326 char *physvols[] = {
3332 r = guestfs_vgcreate (g, volgroup, physvols);
3337 char logvol[] = "LV1";
3338 char volgroup[] = "VG";
3341 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3346 char logvol[] = "LV2";
3347 char volgroup[] = "VG";
3350 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3355 char vgname[] = "VG";
3358 r = guestfs_vgremove (g, vgname);
3366 r = guestfs_lvs (g);
3370 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3374 for (i = 0; r[i] != NULL; ++i)
3381 static int test_vgremove_1 (void)
3383 /* InitNone|InitEmpty for test_vgremove_1 */
3385 char device[] = "/dev/sda";
3386 device[5] = devchar;
3389 r = guestfs_blockdev_setrw (g, device);
3396 r = guestfs_umount_all (g);
3403 r = guestfs_lvm_remove_all (g);
3407 /* TestOutputList for vgremove (1) */
3409 char device[] = "/dev/sda";
3410 device[5] = devchar;
3411 char lines_0[] = ",";
3418 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3423 char device[] = "/dev/sda1";
3424 device[5] = devchar;
3427 r = guestfs_pvcreate (g, device);
3432 char volgroup[] = "VG";
3433 char physvols_0[] = "/dev/sda1";
3434 physvols_0[5] = devchar;
3435 char *physvols[] = {
3441 r = guestfs_vgcreate (g, volgroup, physvols);
3446 char logvol[] = "LV1";
3447 char volgroup[] = "VG";
3450 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3455 char logvol[] = "LV2";
3456 char volgroup[] = "VG";
3459 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3464 char vgname[] = "VG";
3467 r = guestfs_vgremove (g, vgname);
3475 r = guestfs_vgs (g);
3479 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3483 for (i = 0; r[i] != NULL; ++i)
3490 static int test_lvremove_0 (void)
3492 /* InitNone|InitEmpty for test_lvremove_0 */
3494 char device[] = "/dev/sda";
3495 device[5] = devchar;
3498 r = guestfs_blockdev_setrw (g, device);
3505 r = guestfs_umount_all (g);
3512 r = guestfs_lvm_remove_all (g);
3516 /* TestOutputList for lvremove (0) */
3518 char device[] = "/dev/sda";
3519 device[5] = devchar;
3520 char lines_0[] = ",";
3527 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3532 char device[] = "/dev/sda1";
3533 device[5] = devchar;
3536 r = guestfs_pvcreate (g, device);
3541 char volgroup[] = "VG";
3542 char physvols_0[] = "/dev/sda1";
3543 physvols_0[5] = devchar;
3544 char *physvols[] = {
3550 r = guestfs_vgcreate (g, volgroup, physvols);
3555 char logvol[] = "LV1";
3556 char volgroup[] = "VG";
3559 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3564 char logvol[] = "LV2";
3565 char volgroup[] = "VG";
3568 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3573 char device[] = "/dev/VG/LV1";
3576 r = guestfs_lvremove (g, device);
3584 r = guestfs_lvs (g);
3588 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3593 char expected[] = "/dev/VG/LV2";
3594 if (strcmp (r[0], expected) != 0) {
3595 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3600 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3604 for (i = 0; r[i] != NULL; ++i)
3611 static int test_lvremove_1 (void)
3613 /* InitNone|InitEmpty for test_lvremove_1 */
3615 char device[] = "/dev/sda";
3616 device[5] = devchar;
3619 r = guestfs_blockdev_setrw (g, device);
3626 r = guestfs_umount_all (g);
3633 r = guestfs_lvm_remove_all (g);
3637 /* TestOutputList for lvremove (1) */
3639 char device[] = "/dev/sda";
3640 device[5] = devchar;
3641 char lines_0[] = ",";
3648 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3653 char device[] = "/dev/sda1";
3654 device[5] = devchar;
3657 r = guestfs_pvcreate (g, device);
3662 char volgroup[] = "VG";
3663 char physvols_0[] = "/dev/sda1";
3664 physvols_0[5] = devchar;
3665 char *physvols[] = {
3671 r = guestfs_vgcreate (g, volgroup, physvols);
3676 char logvol[] = "LV1";
3677 char volgroup[] = "VG";
3680 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3685 char logvol[] = "LV2";
3686 char volgroup[] = "VG";
3689 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3694 char device[] = "/dev/VG";
3697 r = guestfs_lvremove (g, device);
3705 r = guestfs_lvs (g);
3709 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3713 for (i = 0; r[i] != NULL; ++i)
3720 static int test_lvremove_2 (void)
3722 /* InitNone|InitEmpty for test_lvremove_2 */
3724 char device[] = "/dev/sda";
3725 device[5] = devchar;
3728 r = guestfs_blockdev_setrw (g, device);
3735 r = guestfs_umount_all (g);
3742 r = guestfs_lvm_remove_all (g);
3746 /* TestOutputList for lvremove (2) */
3748 char device[] = "/dev/sda";
3749 device[5] = devchar;
3750 char lines_0[] = ",";
3757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3762 char device[] = "/dev/sda1";
3763 device[5] = devchar;
3766 r = guestfs_pvcreate (g, device);
3771 char volgroup[] = "VG";
3772 char physvols_0[] = "/dev/sda1";
3773 physvols_0[5] = devchar;
3774 char *physvols[] = {
3780 r = guestfs_vgcreate (g, volgroup, physvols);
3785 char logvol[] = "LV1";
3786 char volgroup[] = "VG";
3789 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3794 char logvol[] = "LV2";
3795 char volgroup[] = "VG";
3798 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3803 char device[] = "/dev/VG";
3806 r = guestfs_lvremove (g, device);
3814 r = guestfs_vgs (g);
3818 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3823 char expected[] = "VG";
3824 if (strcmp (r[0], expected) != 0) {
3825 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3830 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3834 for (i = 0; r[i] != NULL; ++i)
3841 static int test_mount_ro_0 (void)
3843 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3845 char device[] = "/dev/sda";
3846 device[5] = devchar;
3849 r = guestfs_blockdev_setrw (g, device);
3856 r = guestfs_umount_all (g);
3863 r = guestfs_lvm_remove_all (g);
3868 char device[] = "/dev/sda";
3869 device[5] = devchar;
3870 char lines_0[] = ",";
3877 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3882 char fstype[] = "ext2";
3883 char device[] = "/dev/sda1";
3884 device[5] = devchar;
3887 r = guestfs_mkfs (g, fstype, device);
3892 char device[] = "/dev/sda1";
3893 device[5] = devchar;
3894 char mountpoint[] = "/";
3897 r = guestfs_mount (g, device, mountpoint);
3901 /* TestLastFail for mount_ro (0) */
3903 char pathordevice[] = "/";
3906 r = guestfs_umount (g, pathordevice);
3911 char device[] = "/dev/sda1";
3912 device[5] = devchar;
3913 char mountpoint[] = "/";
3916 r = guestfs_mount_ro (g, device, mountpoint);
3921 char path[] = "/new";
3924 r = guestfs_touch (g, path);
3931 static int test_mount_ro_1 (void)
3933 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3935 char device[] = "/dev/sda";
3936 device[5] = devchar;
3939 r = guestfs_blockdev_setrw (g, device);
3946 r = guestfs_umount_all (g);
3953 r = guestfs_lvm_remove_all (g);
3958 char device[] = "/dev/sda";
3959 device[5] = devchar;
3960 char lines_0[] = ",";
3967 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3972 char fstype[] = "ext2";
3973 char device[] = "/dev/sda1";
3974 device[5] = devchar;
3977 r = guestfs_mkfs (g, fstype, device);
3982 char device[] = "/dev/sda1";
3983 device[5] = devchar;
3984 char mountpoint[] = "/";
3987 r = guestfs_mount (g, device, mountpoint);
3991 /* TestOutput for mount_ro (1) */
3992 char expected[] = "data";
3994 char path[] = "/new";
3995 char content[] = "data";
3998 r = guestfs_write_file (g, path, content, 0);
4003 char pathordevice[] = "/";
4006 r = guestfs_umount (g, pathordevice);
4011 char device[] = "/dev/sda1";
4012 device[5] = devchar;
4013 char mountpoint[] = "/";
4016 r = guestfs_mount_ro (g, device, mountpoint);
4021 char path[] = "/new";
4024 r = guestfs_cat (g, path);
4027 if (strcmp (r, expected) != 0) {
4028 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4036 static int test_tgz_in_0 (void)
4038 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4040 char device[] = "/dev/sda";
4041 device[5] = devchar;
4044 r = guestfs_blockdev_setrw (g, device);
4051 r = guestfs_umount_all (g);
4058 r = guestfs_lvm_remove_all (g);
4063 char device[] = "/dev/sda";
4064 device[5] = devchar;
4065 char lines_0[] = ",";
4072 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4077 char fstype[] = "ext2";
4078 char device[] = "/dev/sda1";
4079 device[5] = devchar;
4082 r = guestfs_mkfs (g, fstype, device);
4087 char device[] = "/dev/sda1";
4088 device[5] = devchar;
4089 char mountpoint[] = "/";
4092 r = guestfs_mount (g, device, mountpoint);
4096 /* TestOutput for tgz_in (0) */
4097 char expected[] = "hello\n";
4099 char directory[] = "/";
4102 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
4107 char path[] = "/hello";
4110 r = guestfs_cat (g, path);
4113 if (strcmp (r, expected) != 0) {
4114 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4122 static int test_tar_in_0 (void)
4124 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4126 char device[] = "/dev/sda";
4127 device[5] = devchar;
4130 r = guestfs_blockdev_setrw (g, device);
4137 r = guestfs_umount_all (g);
4144 r = guestfs_lvm_remove_all (g);
4149 char device[] = "/dev/sda";
4150 device[5] = devchar;
4151 char lines_0[] = ",";
4158 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4163 char fstype[] = "ext2";
4164 char device[] = "/dev/sda1";
4165 device[5] = devchar;
4168 r = guestfs_mkfs (g, fstype, device);
4173 char device[] = "/dev/sda1";
4174 device[5] = devchar;
4175 char mountpoint[] = "/";
4178 r = guestfs_mount (g, device, mountpoint);
4182 /* TestOutput for tar_in (0) */
4183 char expected[] = "hello\n";
4185 char directory[] = "/";
4188 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4193 char path[] = "/hello";
4196 r = guestfs_cat (g, path);
4199 if (strcmp (r, expected) != 0) {
4200 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4208 static int test_checksum_0 (void)
4210 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4212 char device[] = "/dev/sda";
4213 device[5] = devchar;
4216 r = guestfs_blockdev_setrw (g, device);
4223 r = guestfs_umount_all (g);
4230 r = guestfs_lvm_remove_all (g);
4235 char device[] = "/dev/sda";
4236 device[5] = devchar;
4237 char lines_0[] = ",";
4244 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4249 char fstype[] = "ext2";
4250 char device[] = "/dev/sda1";
4251 device[5] = devchar;
4254 r = guestfs_mkfs (g, fstype, device);
4259 char device[] = "/dev/sda1";
4260 device[5] = devchar;
4261 char mountpoint[] = "/";
4264 r = guestfs_mount (g, device, mountpoint);
4268 /* TestOutput for checksum (0) */
4269 char expected[] = "935282863";
4271 char path[] = "/new";
4272 char content[] = "test\n";
4275 r = guestfs_write_file (g, path, content, 0);
4280 char csumtype[] = "crc";
4281 char path[] = "/new";
4284 r = guestfs_checksum (g, csumtype, path);
4287 if (strcmp (r, expected) != 0) {
4288 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4296 static int test_checksum_1 (void)
4298 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
4300 char device[] = "/dev/sda";
4301 device[5] = devchar;
4304 r = guestfs_blockdev_setrw (g, device);
4311 r = guestfs_umount_all (g);
4318 r = guestfs_lvm_remove_all (g);
4323 char device[] = "/dev/sda";
4324 device[5] = devchar;
4325 char lines_0[] = ",";
4332 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4337 char fstype[] = "ext2";
4338 char device[] = "/dev/sda1";
4339 device[5] = devchar;
4342 r = guestfs_mkfs (g, fstype, device);
4347 char device[] = "/dev/sda1";
4348 device[5] = devchar;
4349 char mountpoint[] = "/";
4352 r = guestfs_mount (g, device, mountpoint);
4356 /* TestLastFail for checksum (1) */
4358 char csumtype[] = "crc";
4359 char path[] = "/new";
4362 r = guestfs_checksum (g, csumtype, path);
4370 static int test_checksum_2 (void)
4372 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
4374 char device[] = "/dev/sda";
4375 device[5] = devchar;
4378 r = guestfs_blockdev_setrw (g, device);
4385 r = guestfs_umount_all (g);
4392 r = guestfs_lvm_remove_all (g);
4397 char device[] = "/dev/sda";
4398 device[5] = devchar;
4399 char lines_0[] = ",";
4406 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4411 char fstype[] = "ext2";
4412 char device[] = "/dev/sda1";
4413 device[5] = devchar;
4416 r = guestfs_mkfs (g, fstype, device);
4421 char device[] = "/dev/sda1";
4422 device[5] = devchar;
4423 char mountpoint[] = "/";
4426 r = guestfs_mount (g, device, mountpoint);
4430 /* TestOutput for checksum (2) */
4431 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
4433 char path[] = "/new";
4434 char content[] = "test\n";
4437 r = guestfs_write_file (g, path, content, 0);
4442 char csumtype[] = "md5";
4443 char path[] = "/new";
4446 r = guestfs_checksum (g, csumtype, path);
4449 if (strcmp (r, expected) != 0) {
4450 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
4458 static int test_checksum_3 (void)
4460 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
4462 char device[] = "/dev/sda";
4463 device[5] = devchar;
4466 r = guestfs_blockdev_setrw (g, device);
4473 r = guestfs_umount_all (g);
4480 r = guestfs_lvm_remove_all (g);
4485 char device[] = "/dev/sda";
4486 device[5] = devchar;
4487 char lines_0[] = ",";
4494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4499 char fstype[] = "ext2";
4500 char device[] = "/dev/sda1";
4501 device[5] = devchar;
4504 r = guestfs_mkfs (g, fstype, device);
4509 char device[] = "/dev/sda1";
4510 device[5] = devchar;
4511 char mountpoint[] = "/";
4514 r = guestfs_mount (g, device, mountpoint);
4518 /* TestOutput for checksum (3) */
4519 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4521 char path[] = "/new";
4522 char content[] = "test\n";
4525 r = guestfs_write_file (g, path, content, 0);
4530 char csumtype[] = "sha1";
4531 char path[] = "/new";
4534 r = guestfs_checksum (g, csumtype, path);
4537 if (strcmp (r, expected) != 0) {
4538 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4546 static int test_checksum_4 (void)
4548 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4550 char device[] = "/dev/sda";
4551 device[5] = devchar;
4554 r = guestfs_blockdev_setrw (g, device);
4561 r = guestfs_umount_all (g);
4568 r = guestfs_lvm_remove_all (g);
4573 char device[] = "/dev/sda";
4574 device[5] = devchar;
4575 char lines_0[] = ",";
4582 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4587 char fstype[] = "ext2";
4588 char device[] = "/dev/sda1";
4589 device[5] = devchar;
4592 r = guestfs_mkfs (g, fstype, device);
4597 char device[] = "/dev/sda1";
4598 device[5] = devchar;
4599 char mountpoint[] = "/";
4602 r = guestfs_mount (g, device, mountpoint);
4606 /* TestOutput for checksum (4) */
4607 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4609 char path[] = "/new";
4610 char content[] = "test\n";
4613 r = guestfs_write_file (g, path, content, 0);
4618 char csumtype[] = "sha224";
4619 char path[] = "/new";
4622 r = guestfs_checksum (g, csumtype, path);
4625 if (strcmp (r, expected) != 0) {
4626 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4634 static int test_checksum_5 (void)
4636 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4638 char device[] = "/dev/sda";
4639 device[5] = devchar;
4642 r = guestfs_blockdev_setrw (g, device);
4649 r = guestfs_umount_all (g);
4656 r = guestfs_lvm_remove_all (g);
4661 char device[] = "/dev/sda";
4662 device[5] = devchar;
4663 char lines_0[] = ",";
4670 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4675 char fstype[] = "ext2";
4676 char device[] = "/dev/sda1";
4677 device[5] = devchar;
4680 r = guestfs_mkfs (g, fstype, device);
4685 char device[] = "/dev/sda1";
4686 device[5] = devchar;
4687 char mountpoint[] = "/";
4690 r = guestfs_mount (g, device, mountpoint);
4694 /* TestOutput for checksum (5) */
4695 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4697 char path[] = "/new";
4698 char content[] = "test\n";
4701 r = guestfs_write_file (g, path, content, 0);
4706 char csumtype[] = "sha256";
4707 char path[] = "/new";
4710 r = guestfs_checksum (g, csumtype, path);
4713 if (strcmp (r, expected) != 0) {
4714 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4722 static int test_checksum_6 (void)
4724 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4726 char device[] = "/dev/sda";
4727 device[5] = devchar;
4730 r = guestfs_blockdev_setrw (g, device);
4737 r = guestfs_umount_all (g);
4744 r = guestfs_lvm_remove_all (g);
4749 char device[] = "/dev/sda";
4750 device[5] = devchar;
4751 char lines_0[] = ",";
4758 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4763 char fstype[] = "ext2";
4764 char device[] = "/dev/sda1";
4765 device[5] = devchar;
4768 r = guestfs_mkfs (g, fstype, device);
4773 char device[] = "/dev/sda1";
4774 device[5] = devchar;
4775 char mountpoint[] = "/";
4778 r = guestfs_mount (g, device, mountpoint);
4782 /* TestOutput for checksum (6) */
4783 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4785 char path[] = "/new";
4786 char content[] = "test\n";
4789 r = guestfs_write_file (g, path, content, 0);
4794 char csumtype[] = "sha384";
4795 char path[] = "/new";
4798 r = guestfs_checksum (g, csumtype, path);
4801 if (strcmp (r, expected) != 0) {
4802 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4810 static int test_checksum_7 (void)
4812 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4814 char device[] = "/dev/sda";
4815 device[5] = devchar;
4818 r = guestfs_blockdev_setrw (g, device);
4825 r = guestfs_umount_all (g);
4832 r = guestfs_lvm_remove_all (g);
4837 char device[] = "/dev/sda";
4838 device[5] = devchar;
4839 char lines_0[] = ",";
4846 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4851 char fstype[] = "ext2";
4852 char device[] = "/dev/sda1";
4853 device[5] = devchar;
4856 r = guestfs_mkfs (g, fstype, device);
4861 char device[] = "/dev/sda1";
4862 device[5] = devchar;
4863 char mountpoint[] = "/";
4866 r = guestfs_mount (g, device, mountpoint);
4870 /* TestOutput for checksum (7) */
4871 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4873 char path[] = "/new";
4874 char content[] = "test\n";
4877 r = guestfs_write_file (g, path, content, 0);
4882 char csumtype[] = "sha512";
4883 char path[] = "/new";
4886 r = guestfs_checksum (g, csumtype, path);
4889 if (strcmp (r, expected) != 0) {
4890 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4898 static int test_download_0 (void)
4900 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4902 char device[] = "/dev/sda";
4903 device[5] = devchar;
4906 r = guestfs_blockdev_setrw (g, device);
4913 r = guestfs_umount_all (g);
4920 r = guestfs_lvm_remove_all (g);
4925 char device[] = "/dev/sda";
4926 device[5] = devchar;
4927 char lines_0[] = ",";
4934 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4939 char fstype[] = "ext2";
4940 char device[] = "/dev/sda1";
4941 device[5] = devchar;
4944 r = guestfs_mkfs (g, fstype, device);
4949 char device[] = "/dev/sda1";
4950 device[5] = devchar;
4951 char mountpoint[] = "/";
4954 r = guestfs_mount (g, device, mountpoint);
4958 /* TestOutput for download (0) */
4959 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4961 char remotefilename[] = "/COPYING.LIB";
4964 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4969 char remotefilename[] = "/COPYING.LIB";
4972 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4977 char remotefilename[] = "/upload";
4980 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4985 char csumtype[] = "md5";
4986 char path[] = "/upload";
4989 r = guestfs_checksum (g, csumtype, path);
4992 if (strcmp (r, expected) != 0) {
4993 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5001 static int test_upload_0 (void)
5003 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5005 char device[] = "/dev/sda";
5006 device[5] = devchar;
5009 r = guestfs_blockdev_setrw (g, device);
5016 r = guestfs_umount_all (g);
5023 r = guestfs_lvm_remove_all (g);
5028 char device[] = "/dev/sda";
5029 device[5] = devchar;
5030 char lines_0[] = ",";
5037 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5042 char fstype[] = "ext2";
5043 char device[] = "/dev/sda1";
5044 device[5] = devchar;
5047 r = guestfs_mkfs (g, fstype, device);
5052 char device[] = "/dev/sda1";
5053 device[5] = devchar;
5054 char mountpoint[] = "/";
5057 r = guestfs_mount (g, device, mountpoint);
5061 /* TestOutput for upload (0) */
5062 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5064 char remotefilename[] = "/COPYING.LIB";
5067 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
5072 char csumtype[] = "md5";
5073 char path[] = "/COPYING.LIB";
5076 r = guestfs_checksum (g, csumtype, path);
5079 if (strcmp (r, expected) != 0) {
5080 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
5088 static int test_blockdev_rereadpt_0 (void)
5090 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
5092 char device[] = "/dev/sda";
5093 device[5] = devchar;
5096 r = guestfs_blockdev_setrw (g, device);
5103 r = guestfs_umount_all (g);
5110 r = guestfs_lvm_remove_all (g);
5114 /* TestRun for blockdev_rereadpt (0) */
5116 char device[] = "/dev/sda";
5117 device[5] = devchar;
5120 r = guestfs_blockdev_rereadpt (g, device);
5127 static int test_blockdev_flushbufs_0 (void)
5129 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
5131 char device[] = "/dev/sda";
5132 device[5] = devchar;
5135 r = guestfs_blockdev_setrw (g, device);
5142 r = guestfs_umount_all (g);
5149 r = guestfs_lvm_remove_all (g);
5153 /* TestRun for blockdev_flushbufs (0) */
5155 char device[] = "/dev/sda";
5156 device[5] = devchar;
5159 r = guestfs_blockdev_flushbufs (g, device);
5166 static int test_blockdev_getsize64_0 (void)
5168 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
5170 char device[] = "/dev/sda";
5171 device[5] = devchar;
5174 r = guestfs_blockdev_setrw (g, device);
5181 r = guestfs_umount_all (g);
5188 r = guestfs_lvm_remove_all (g);
5192 /* TestOutputInt for blockdev_getsize64 (0) */
5194 char device[] = "/dev/sda";
5195 device[5] = devchar;
5198 r = guestfs_blockdev_getsize64 (g, device);
5201 if (r != 524288000) {
5202 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
5209 static int test_blockdev_getsz_0 (void)
5211 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
5213 char device[] = "/dev/sda";
5214 device[5] = devchar;
5217 r = guestfs_blockdev_setrw (g, device);
5224 r = guestfs_umount_all (g);
5231 r = guestfs_lvm_remove_all (g);
5235 /* TestOutputInt for blockdev_getsz (0) */
5237 char device[] = "/dev/sda";
5238 device[5] = devchar;
5241 r = guestfs_blockdev_getsz (g, device);
5245 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
5252 static int test_blockdev_getbsz_0 (void)
5254 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
5256 char device[] = "/dev/sda";
5257 device[5] = devchar;
5260 r = guestfs_blockdev_setrw (g, device);
5267 r = guestfs_umount_all (g);
5274 r = guestfs_lvm_remove_all (g);
5278 /* TestOutputInt for blockdev_getbsz (0) */
5280 char device[] = "/dev/sda";
5281 device[5] = devchar;
5284 r = guestfs_blockdev_getbsz (g, device);
5288 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
5295 static int test_blockdev_getss_0 (void)
5297 /* InitNone|InitEmpty for test_blockdev_getss_0 */
5299 char device[] = "/dev/sda";
5300 device[5] = devchar;
5303 r = guestfs_blockdev_setrw (g, device);
5310 r = guestfs_umount_all (g);
5317 r = guestfs_lvm_remove_all (g);
5321 /* TestOutputInt for blockdev_getss (0) */
5323 char device[] = "/dev/sda";
5324 device[5] = devchar;
5327 r = guestfs_blockdev_getss (g, device);
5331 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
5338 static int test_blockdev_getro_0 (void)
5340 /* InitNone|InitEmpty for test_blockdev_getro_0 */
5342 char device[] = "/dev/sda";
5343 device[5] = devchar;
5346 r = guestfs_blockdev_setrw (g, device);
5353 r = guestfs_umount_all (g);
5360 r = guestfs_lvm_remove_all (g);
5364 /* TestOutputTrue for blockdev_getro (0) */
5366 char device[] = "/dev/sda";
5367 device[5] = devchar;
5370 r = guestfs_blockdev_setro (g, device);
5375 char device[] = "/dev/sda";
5376 device[5] = devchar;
5379 r = guestfs_blockdev_getro (g, device);
5383 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
5390 static int test_blockdev_setrw_0 (void)
5392 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
5394 char device[] = "/dev/sda";
5395 device[5] = devchar;
5398 r = guestfs_blockdev_setrw (g, device);
5405 r = guestfs_umount_all (g);
5412 r = guestfs_lvm_remove_all (g);
5416 /* TestOutputFalse for blockdev_setrw (0) */
5418 char device[] = "/dev/sda";
5419 device[5] = devchar;
5422 r = guestfs_blockdev_setrw (g, device);
5427 char device[] = "/dev/sda";
5428 device[5] = devchar;
5431 r = guestfs_blockdev_getro (g, device);
5435 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
5442 static int test_blockdev_setro_0 (void)
5444 /* InitNone|InitEmpty for test_blockdev_setro_0 */
5446 char device[] = "/dev/sda";
5447 device[5] = devchar;
5450 r = guestfs_blockdev_setrw (g, device);
5457 r = guestfs_umount_all (g);
5464 r = guestfs_lvm_remove_all (g);
5468 /* TestOutputTrue for blockdev_setro (0) */
5470 char device[] = "/dev/sda";
5471 device[5] = devchar;
5474 r = guestfs_blockdev_setro (g, device);
5479 char device[] = "/dev/sda";
5480 device[5] = devchar;
5483 r = guestfs_blockdev_getro (g, device);
5487 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
5494 static int test_statvfs_0 (void)
5496 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5498 char device[] = "/dev/sda";
5499 device[5] = devchar;
5502 r = guestfs_blockdev_setrw (g, device);
5509 r = guestfs_umount_all (g);
5516 r = guestfs_lvm_remove_all (g);
5521 char device[] = "/dev/sda";
5522 device[5] = devchar;
5523 char lines_0[] = ",";
5530 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5535 char fstype[] = "ext2";
5536 char device[] = "/dev/sda1";
5537 device[5] = devchar;
5540 r = guestfs_mkfs (g, fstype, device);
5545 char device[] = "/dev/sda1";
5546 device[5] = devchar;
5547 char mountpoint[] = "/";
5550 r = guestfs_mount (g, device, mountpoint);
5554 /* TestOutputStruct for statvfs (0) */
5557 struct guestfs_statvfs *r;
5559 r = guestfs_statvfs (g, path);
5562 if (r->bfree != 487702) {
5563 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5567 if (r->blocks != 490020) {
5568 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5572 if (r->bsize != 1024) {
5573 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5582 static int test_lstat_0 (void)
5584 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5586 char device[] = "/dev/sda";
5587 device[5] = devchar;
5590 r = guestfs_blockdev_setrw (g, device);
5597 r = guestfs_umount_all (g);
5604 r = guestfs_lvm_remove_all (g);
5609 char device[] = "/dev/sda";
5610 device[5] = devchar;
5611 char lines_0[] = ",";
5618 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5623 char fstype[] = "ext2";
5624 char device[] = "/dev/sda1";
5625 device[5] = devchar;
5628 r = guestfs_mkfs (g, fstype, device);
5633 char device[] = "/dev/sda1";
5634 device[5] = devchar;
5635 char mountpoint[] = "/";
5638 r = guestfs_mount (g, device, mountpoint);
5642 /* TestOutputStruct for lstat (0) */
5644 char path[] = "/new";
5647 r = guestfs_touch (g, path);
5652 char path[] = "/new";
5653 struct guestfs_stat *r;
5655 r = guestfs_lstat (g, path);
5659 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5668 static int test_stat_0 (void)
5670 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5672 char device[] = "/dev/sda";
5673 device[5] = devchar;
5676 r = guestfs_blockdev_setrw (g, device);
5683 r = guestfs_umount_all (g);
5690 r = guestfs_lvm_remove_all (g);
5695 char device[] = "/dev/sda";
5696 device[5] = devchar;
5697 char lines_0[] = ",";
5704 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5709 char fstype[] = "ext2";
5710 char device[] = "/dev/sda1";
5711 device[5] = devchar;
5714 r = guestfs_mkfs (g, fstype, device);
5719 char device[] = "/dev/sda1";
5720 device[5] = devchar;
5721 char mountpoint[] = "/";
5724 r = guestfs_mount (g, device, mountpoint);
5728 /* TestOutputStruct for stat (0) */
5730 char path[] = "/new";
5733 r = guestfs_touch (g, path);
5738 char path[] = "/new";
5739 struct guestfs_stat *r;
5741 r = guestfs_stat (g, path);
5745 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5754 static int test_command_lines_0_prereq (void)
5756 const char *str = getenv ("SKIP_TEST_COMMAND");
5757 return str && strcmp (str, "1") == 0;
5760 static int test_command_lines_0 (void)
5762 if (! test_command_lines_0_prereq ()) {
5763 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5765 char device[] = "/dev/sda";
5766 device[5] = devchar;
5769 r = guestfs_blockdev_setrw (g, device);
5776 r = guestfs_umount_all (g);
5783 r = guestfs_lvm_remove_all (g);
5788 char device[] = "/dev/sda";
5789 device[5] = devchar;
5790 char lines_0[] = ",";
5797 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5802 char fstype[] = "ext2";
5803 char device[] = "/dev/sda1";
5804 device[5] = devchar;
5807 r = guestfs_mkfs (g, fstype, device);
5812 char device[] = "/dev/sda1";
5813 device[5] = devchar;
5814 char mountpoint[] = "/";
5817 r = guestfs_mount (g, device, mountpoint);
5821 /* TestOutputList for command_lines (0) */
5823 char remotefilename[] = "/test-command";
5826 r = guestfs_upload (g, "test-command", remotefilename);
5831 char path[] = "/test-command";
5834 r = guestfs_chmod (g, 493, path);
5839 char arguments_0[] = "/test-command";
5840 char arguments_1[] = "1";
5841 char *arguments[] = {
5849 r = guestfs_command_lines (g, arguments);
5853 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5858 char expected[] = "Result1";
5859 if (strcmp (r[0], expected) != 0) {
5860 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5865 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5869 for (i = 0; r[i] != NULL; ++i)
5874 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5878 static int test_command_lines_1_prereq (void)
5880 const char *str = getenv ("SKIP_TEST_COMMAND");
5881 return str && strcmp (str, "1") == 0;
5884 static int test_command_lines_1 (void)
5886 if (! test_command_lines_1_prereq ()) {
5887 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5889 char device[] = "/dev/sda";
5890 device[5] = devchar;
5893 r = guestfs_blockdev_setrw (g, device);
5900 r = guestfs_umount_all (g);
5907 r = guestfs_lvm_remove_all (g);
5912 char device[] = "/dev/sda";
5913 device[5] = devchar;
5914 char lines_0[] = ",";
5921 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5926 char fstype[] = "ext2";
5927 char device[] = "/dev/sda1";
5928 device[5] = devchar;
5931 r = guestfs_mkfs (g, fstype, device);
5936 char device[] = "/dev/sda1";
5937 device[5] = devchar;
5938 char mountpoint[] = "/";
5941 r = guestfs_mount (g, device, mountpoint);
5945 /* TestOutputList for command_lines (1) */
5947 char remotefilename[] = "/test-command";
5950 r = guestfs_upload (g, "test-command", remotefilename);
5955 char path[] = "/test-command";
5958 r = guestfs_chmod (g, 493, path);
5963 char arguments_0[] = "/test-command";
5964 char arguments_1[] = "2";
5965 char *arguments[] = {
5973 r = guestfs_command_lines (g, arguments);
5977 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5982 char expected[] = "Result2";
5983 if (strcmp (r[0], expected) != 0) {
5984 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5989 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5993 for (i = 0; r[i] != NULL; ++i)
5998 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
6002 static int test_command_lines_2_prereq (void)
6004 const char *str = getenv ("SKIP_TEST_COMMAND");
6005 return str && strcmp (str, "1") == 0;
6008 static int test_command_lines_2 (void)
6010 if (! test_command_lines_2_prereq ()) {
6011 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
6013 char device[] = "/dev/sda";
6014 device[5] = devchar;
6017 r = guestfs_blockdev_setrw (g, device);
6024 r = guestfs_umount_all (g);
6031 r = guestfs_lvm_remove_all (g);
6036 char device[] = "/dev/sda";
6037 device[5] = devchar;
6038 char lines_0[] = ",";
6045 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6050 char fstype[] = "ext2";
6051 char device[] = "/dev/sda1";
6052 device[5] = devchar;
6055 r = guestfs_mkfs (g, fstype, device);
6060 char device[] = "/dev/sda1";
6061 device[5] = devchar;
6062 char mountpoint[] = "/";
6065 r = guestfs_mount (g, device, mountpoint);
6069 /* TestOutputList for command_lines (2) */
6071 char remotefilename[] = "/test-command";
6074 r = guestfs_upload (g, "test-command", remotefilename);
6079 char path[] = "/test-command";
6082 r = guestfs_chmod (g, 493, path);
6087 char arguments_0[] = "/test-command";
6088 char arguments_1[] = "3";
6089 char *arguments[] = {
6097 r = guestfs_command_lines (g, arguments);
6101 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6106 char expected[] = "";
6107 if (strcmp (r[0], expected) != 0) {
6108 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6113 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
6118 char expected[] = "Result3";
6119 if (strcmp (r[1], expected) != 0) {
6120 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6125 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
6129 for (i = 0; r[i] != NULL; ++i)
6134 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
6138 static int test_command_lines_3_prereq (void)
6140 const char *str = getenv ("SKIP_TEST_COMMAND");
6141 return str && strcmp (str, "1") == 0;
6144 static int test_command_lines_3 (void)
6146 if (! test_command_lines_3_prereq ()) {
6147 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
6149 char device[] = "/dev/sda";
6150 device[5] = devchar;
6153 r = guestfs_blockdev_setrw (g, device);
6160 r = guestfs_umount_all (g);
6167 r = guestfs_lvm_remove_all (g);
6172 char device[] = "/dev/sda";
6173 device[5] = devchar;
6174 char lines_0[] = ",";
6181 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6186 char fstype[] = "ext2";
6187 char device[] = "/dev/sda1";
6188 device[5] = devchar;
6191 r = guestfs_mkfs (g, fstype, device);
6196 char device[] = "/dev/sda1";
6197 device[5] = devchar;
6198 char mountpoint[] = "/";
6201 r = guestfs_mount (g, device, mountpoint);
6205 /* TestOutputList for command_lines (3) */
6207 char remotefilename[] = "/test-command";
6210 r = guestfs_upload (g, "test-command", remotefilename);
6215 char path[] = "/test-command";
6218 r = guestfs_chmod (g, 493, path);
6223 char arguments_0[] = "/test-command";
6224 char arguments_1[] = "4";
6225 char *arguments[] = {
6233 r = guestfs_command_lines (g, arguments);
6237 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6242 char expected[] = "";
6243 if (strcmp (r[0], expected) != 0) {
6244 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6249 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6254 char expected[] = "Result4";
6255 if (strcmp (r[1], expected) != 0) {
6256 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6261 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
6265 for (i = 0; r[i] != NULL; ++i)
6270 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
6274 static int test_command_lines_4_prereq (void)
6276 const char *str = getenv ("SKIP_TEST_COMMAND");
6277 return str && strcmp (str, "1") == 0;
6280 static int test_command_lines_4 (void)
6282 if (! test_command_lines_4_prereq ()) {
6283 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
6285 char device[] = "/dev/sda";
6286 device[5] = devchar;
6289 r = guestfs_blockdev_setrw (g, device);
6296 r = guestfs_umount_all (g);
6303 r = guestfs_lvm_remove_all (g);
6308 char device[] = "/dev/sda";
6309 device[5] = devchar;
6310 char lines_0[] = ",";
6317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6322 char fstype[] = "ext2";
6323 char device[] = "/dev/sda1";
6324 device[5] = devchar;
6327 r = guestfs_mkfs (g, fstype, device);
6332 char device[] = "/dev/sda1";
6333 device[5] = devchar;
6334 char mountpoint[] = "/";
6337 r = guestfs_mount (g, device, mountpoint);
6341 /* TestOutputList for command_lines (4) */
6343 char remotefilename[] = "/test-command";
6346 r = guestfs_upload (g, "test-command", remotefilename);
6351 char path[] = "/test-command";
6354 r = guestfs_chmod (g, 493, path);
6359 char arguments_0[] = "/test-command";
6360 char arguments_1[] = "5";
6361 char *arguments[] = {
6369 r = guestfs_command_lines (g, arguments);
6373 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6378 char expected[] = "";
6379 if (strcmp (r[0], expected) != 0) {
6380 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6385 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6390 char expected[] = "Result5";
6391 if (strcmp (r[1], expected) != 0) {
6392 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6397 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6402 char expected[] = "";
6403 if (strcmp (r[2], expected) != 0) {
6404 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6409 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
6413 for (i = 0; r[i] != NULL; ++i)
6418 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
6422 static int test_command_lines_5_prereq (void)
6424 const char *str = getenv ("SKIP_TEST_COMMAND");
6425 return str && strcmp (str, "1") == 0;
6428 static int test_command_lines_5 (void)
6430 if (! test_command_lines_5_prereq ()) {
6431 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
6433 char device[] = "/dev/sda";
6434 device[5] = devchar;
6437 r = guestfs_blockdev_setrw (g, device);
6444 r = guestfs_umount_all (g);
6451 r = guestfs_lvm_remove_all (g);
6456 char device[] = "/dev/sda";
6457 device[5] = devchar;
6458 char lines_0[] = ",";
6465 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6470 char fstype[] = "ext2";
6471 char device[] = "/dev/sda1";
6472 device[5] = devchar;
6475 r = guestfs_mkfs (g, fstype, device);
6480 char device[] = "/dev/sda1";
6481 device[5] = devchar;
6482 char mountpoint[] = "/";
6485 r = guestfs_mount (g, device, mountpoint);
6489 /* TestOutputList for command_lines (5) */
6491 char remotefilename[] = "/test-command";
6494 r = guestfs_upload (g, "test-command", remotefilename);
6499 char path[] = "/test-command";
6502 r = guestfs_chmod (g, 493, path);
6507 char arguments_0[] = "/test-command";
6508 char arguments_1[] = "6";
6509 char *arguments[] = {
6517 r = guestfs_command_lines (g, arguments);
6521 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6526 char expected[] = "";
6527 if (strcmp (r[0], expected) != 0) {
6528 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6533 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6538 char expected[] = "";
6539 if (strcmp (r[1], expected) != 0) {
6540 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6545 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6550 char expected[] = "Result6";
6551 if (strcmp (r[2], expected) != 0) {
6552 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6557 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6562 char expected[] = "";
6563 if (strcmp (r[3], expected) != 0) {
6564 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6569 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6573 for (i = 0; r[i] != NULL; ++i)
6578 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6582 static int test_command_lines_6_prereq (void)
6584 const char *str = getenv ("SKIP_TEST_COMMAND");
6585 return str && strcmp (str, "1") == 0;
6588 static int test_command_lines_6 (void)
6590 if (! test_command_lines_6_prereq ()) {
6591 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6593 char device[] = "/dev/sda";
6594 device[5] = devchar;
6597 r = guestfs_blockdev_setrw (g, device);
6604 r = guestfs_umount_all (g);
6611 r = guestfs_lvm_remove_all (g);
6616 char device[] = "/dev/sda";
6617 device[5] = devchar;
6618 char lines_0[] = ",";
6625 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6630 char fstype[] = "ext2";
6631 char device[] = "/dev/sda1";
6632 device[5] = devchar;
6635 r = guestfs_mkfs (g, fstype, device);
6640 char device[] = "/dev/sda1";
6641 device[5] = devchar;
6642 char mountpoint[] = "/";
6645 r = guestfs_mount (g, device, mountpoint);
6649 /* TestOutputList for command_lines (6) */
6651 char remotefilename[] = "/test-command";
6654 r = guestfs_upload (g, "test-command", remotefilename);
6659 char path[] = "/test-command";
6662 r = guestfs_chmod (g, 493, path);
6667 char arguments_0[] = "/test-command";
6668 char arguments_1[] = "7";
6669 char *arguments[] = {
6677 r = guestfs_command_lines (g, arguments);
6681 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6685 for (i = 0; r[i] != NULL; ++i)
6690 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6694 static int test_command_lines_7_prereq (void)
6696 const char *str = getenv ("SKIP_TEST_COMMAND");
6697 return str && strcmp (str, "1") == 0;
6700 static int test_command_lines_7 (void)
6702 if (! test_command_lines_7_prereq ()) {
6703 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6705 char device[] = "/dev/sda";
6706 device[5] = devchar;
6709 r = guestfs_blockdev_setrw (g, device);
6716 r = guestfs_umount_all (g);
6723 r = guestfs_lvm_remove_all (g);
6728 char device[] = "/dev/sda";
6729 device[5] = devchar;
6730 char lines_0[] = ",";
6737 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6742 char fstype[] = "ext2";
6743 char device[] = "/dev/sda1";
6744 device[5] = devchar;
6747 r = guestfs_mkfs (g, fstype, device);
6752 char device[] = "/dev/sda1";
6753 device[5] = devchar;
6754 char mountpoint[] = "/";
6757 r = guestfs_mount (g, device, mountpoint);
6761 /* TestOutputList for command_lines (7) */
6763 char remotefilename[] = "/test-command";
6766 r = guestfs_upload (g, "test-command", remotefilename);
6771 char path[] = "/test-command";
6774 r = guestfs_chmod (g, 493, path);
6779 char arguments_0[] = "/test-command";
6780 char arguments_1[] = "8";
6781 char *arguments[] = {
6789 r = guestfs_command_lines (g, arguments);
6793 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6798 char expected[] = "";
6799 if (strcmp (r[0], expected) != 0) {
6800 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6805 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6809 for (i = 0; r[i] != NULL; ++i)
6814 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6818 static int test_command_lines_8_prereq (void)
6820 const char *str = getenv ("SKIP_TEST_COMMAND");
6821 return str && strcmp (str, "1") == 0;
6824 static int test_command_lines_8 (void)
6826 if (! test_command_lines_8_prereq ()) {
6827 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6829 char device[] = "/dev/sda";
6830 device[5] = devchar;
6833 r = guestfs_blockdev_setrw (g, device);
6840 r = guestfs_umount_all (g);
6847 r = guestfs_lvm_remove_all (g);
6852 char device[] = "/dev/sda";
6853 device[5] = devchar;
6854 char lines_0[] = ",";
6861 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6866 char fstype[] = "ext2";
6867 char device[] = "/dev/sda1";
6868 device[5] = devchar;
6871 r = guestfs_mkfs (g, fstype, device);
6876 char device[] = "/dev/sda1";
6877 device[5] = devchar;
6878 char mountpoint[] = "/";
6881 r = guestfs_mount (g, device, mountpoint);
6885 /* TestOutputList for command_lines (8) */
6887 char remotefilename[] = "/test-command";
6890 r = guestfs_upload (g, "test-command", remotefilename);
6895 char path[] = "/test-command";
6898 r = guestfs_chmod (g, 493, path);
6903 char arguments_0[] = "/test-command";
6904 char arguments_1[] = "9";
6905 char *arguments[] = {
6913 r = guestfs_command_lines (g, arguments);
6917 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6922 char expected[] = "";
6923 if (strcmp (r[0], expected) != 0) {
6924 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6929 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6934 char expected[] = "";
6935 if (strcmp (r[1], expected) != 0) {
6936 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6941 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6945 for (i = 0; r[i] != NULL; ++i)
6950 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6954 static int test_command_lines_9_prereq (void)
6956 const char *str = getenv ("SKIP_TEST_COMMAND");
6957 return str && strcmp (str, "1") == 0;
6960 static int test_command_lines_9 (void)
6962 if (! test_command_lines_9_prereq ()) {
6963 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6965 char device[] = "/dev/sda";
6966 device[5] = devchar;
6969 r = guestfs_blockdev_setrw (g, device);
6976 r = guestfs_umount_all (g);
6983 r = guestfs_lvm_remove_all (g);
6988 char device[] = "/dev/sda";
6989 device[5] = devchar;
6990 char lines_0[] = ",";
6997 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7002 char fstype[] = "ext2";
7003 char device[] = "/dev/sda1";
7004 device[5] = devchar;
7007 r = guestfs_mkfs (g, fstype, device);
7012 char device[] = "/dev/sda1";
7013 device[5] = devchar;
7014 char mountpoint[] = "/";
7017 r = guestfs_mount (g, device, mountpoint);
7021 /* TestOutputList for command_lines (9) */
7023 char remotefilename[] = "/test-command";
7026 r = guestfs_upload (g, "test-command", remotefilename);
7031 char path[] = "/test-command";
7034 r = guestfs_chmod (g, 493, path);
7039 char arguments_0[] = "/test-command";
7040 char arguments_1[] = "10";
7041 char *arguments[] = {
7049 r = guestfs_command_lines (g, arguments);
7053 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7058 char expected[] = "Result10-1";
7059 if (strcmp (r[0], expected) != 0) {
7060 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7065 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
7070 char expected[] = "Result10-2";
7071 if (strcmp (r[1], expected) != 0) {
7072 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7077 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
7081 for (i = 0; r[i] != NULL; ++i)
7086 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
7090 static int test_command_lines_10_prereq (void)
7092 const char *str = getenv ("SKIP_TEST_COMMAND");
7093 return str && strcmp (str, "1") == 0;
7096 static int test_command_lines_10 (void)
7098 if (! test_command_lines_10_prereq ()) {
7099 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
7101 char device[] = "/dev/sda";
7102 device[5] = devchar;
7105 r = guestfs_blockdev_setrw (g, device);
7112 r = guestfs_umount_all (g);
7119 r = guestfs_lvm_remove_all (g);
7124 char device[] = "/dev/sda";
7125 device[5] = devchar;
7126 char lines_0[] = ",";
7133 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7138 char fstype[] = "ext2";
7139 char device[] = "/dev/sda1";
7140 device[5] = devchar;
7143 r = guestfs_mkfs (g, fstype, device);
7148 char device[] = "/dev/sda1";
7149 device[5] = devchar;
7150 char mountpoint[] = "/";
7153 r = guestfs_mount (g, device, mountpoint);
7157 /* TestOutputList for command_lines (10) */
7159 char remotefilename[] = "/test-command";
7162 r = guestfs_upload (g, "test-command", remotefilename);
7167 char path[] = "/test-command";
7170 r = guestfs_chmod (g, 493, path);
7175 char arguments_0[] = "/test-command";
7176 char arguments_1[] = "11";
7177 char *arguments[] = {
7185 r = guestfs_command_lines (g, arguments);
7189 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7194 char expected[] = "Result11-1";
7195 if (strcmp (r[0], expected) != 0) {
7196 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7201 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7206 char expected[] = "Result11-2";
7207 if (strcmp (r[1], expected) != 0) {
7208 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7213 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
7217 for (i = 0; r[i] != NULL; ++i)
7222 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
7226 static int test_command_0_prereq (void)
7228 const char *str = getenv ("SKIP_TEST_COMMAND");
7229 return str && strcmp (str, "1") == 0;
7232 static int test_command_0 (void)
7234 if (! test_command_0_prereq ()) {
7235 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
7237 char device[] = "/dev/sda";
7238 device[5] = devchar;
7241 r = guestfs_blockdev_setrw (g, device);
7248 r = guestfs_umount_all (g);
7255 r = guestfs_lvm_remove_all (g);
7260 char device[] = "/dev/sda";
7261 device[5] = devchar;
7262 char lines_0[] = ",";
7269 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7274 char fstype[] = "ext2";
7275 char device[] = "/dev/sda1";
7276 device[5] = devchar;
7279 r = guestfs_mkfs (g, fstype, device);
7284 char device[] = "/dev/sda1";
7285 device[5] = devchar;
7286 char mountpoint[] = "/";
7289 r = guestfs_mount (g, device, mountpoint);
7293 /* TestOutput for command (0) */
7294 char expected[] = "Result1";
7296 char remotefilename[] = "/test-command";
7299 r = guestfs_upload (g, "test-command", remotefilename);
7304 char path[] = "/test-command";
7307 r = guestfs_chmod (g, 493, path);
7312 char arguments_0[] = "/test-command";
7313 char arguments_1[] = "1";
7314 char *arguments[] = {
7321 r = guestfs_command (g, arguments);
7324 if (strcmp (r, expected) != 0) {
7325 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
7331 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
7335 static int test_command_1_prereq (void)
7337 const char *str = getenv ("SKIP_TEST_COMMAND");
7338 return str && strcmp (str, "1") == 0;
7341 static int test_command_1 (void)
7343 if (! test_command_1_prereq ()) {
7344 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
7346 char device[] = "/dev/sda";
7347 device[5] = devchar;
7350 r = guestfs_blockdev_setrw (g, device);
7357 r = guestfs_umount_all (g);
7364 r = guestfs_lvm_remove_all (g);
7369 char device[] = "/dev/sda";
7370 device[5] = devchar;
7371 char lines_0[] = ",";
7378 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7383 char fstype[] = "ext2";
7384 char device[] = "/dev/sda1";
7385 device[5] = devchar;
7388 r = guestfs_mkfs (g, fstype, device);
7393 char device[] = "/dev/sda1";
7394 device[5] = devchar;
7395 char mountpoint[] = "/";
7398 r = guestfs_mount (g, device, mountpoint);
7402 /* TestOutput for command (1) */
7403 char expected[] = "Result2\n";
7405 char remotefilename[] = "/test-command";
7408 r = guestfs_upload (g, "test-command", remotefilename);
7413 char path[] = "/test-command";
7416 r = guestfs_chmod (g, 493, path);
7421 char arguments_0[] = "/test-command";
7422 char arguments_1[] = "2";
7423 char *arguments[] = {
7430 r = guestfs_command (g, arguments);
7433 if (strcmp (r, expected) != 0) {
7434 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
7440 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
7444 static int test_command_2_prereq (void)
7446 const char *str = getenv ("SKIP_TEST_COMMAND");
7447 return str && strcmp (str, "1") == 0;
7450 static int test_command_2 (void)
7452 if (! test_command_2_prereq ()) {
7453 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
7455 char device[] = "/dev/sda";
7456 device[5] = devchar;
7459 r = guestfs_blockdev_setrw (g, device);
7466 r = guestfs_umount_all (g);
7473 r = guestfs_lvm_remove_all (g);
7478 char device[] = "/dev/sda";
7479 device[5] = devchar;
7480 char lines_0[] = ",";
7487 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7492 char fstype[] = "ext2";
7493 char device[] = "/dev/sda1";
7494 device[5] = devchar;
7497 r = guestfs_mkfs (g, fstype, device);
7502 char device[] = "/dev/sda1";
7503 device[5] = devchar;
7504 char mountpoint[] = "/";
7507 r = guestfs_mount (g, device, mountpoint);
7511 /* TestOutput for command (2) */
7512 char expected[] = "\nResult3";
7514 char remotefilename[] = "/test-command";
7517 r = guestfs_upload (g, "test-command", remotefilename);
7522 char path[] = "/test-command";
7525 r = guestfs_chmod (g, 493, path);
7530 char arguments_0[] = "/test-command";
7531 char arguments_1[] = "3";
7532 char *arguments[] = {
7539 r = guestfs_command (g, arguments);
7542 if (strcmp (r, expected) != 0) {
7543 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7549 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7553 static int test_command_3_prereq (void)
7555 const char *str = getenv ("SKIP_TEST_COMMAND");
7556 return str && strcmp (str, "1") == 0;
7559 static int test_command_3 (void)
7561 if (! test_command_3_prereq ()) {
7562 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7564 char device[] = "/dev/sda";
7565 device[5] = devchar;
7568 r = guestfs_blockdev_setrw (g, device);
7575 r = guestfs_umount_all (g);
7582 r = guestfs_lvm_remove_all (g);
7587 char device[] = "/dev/sda";
7588 device[5] = devchar;
7589 char lines_0[] = ",";
7596 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7601 char fstype[] = "ext2";
7602 char device[] = "/dev/sda1";
7603 device[5] = devchar;
7606 r = guestfs_mkfs (g, fstype, device);
7611 char device[] = "/dev/sda1";
7612 device[5] = devchar;
7613 char mountpoint[] = "/";
7616 r = guestfs_mount (g, device, mountpoint);
7620 /* TestOutput for command (3) */
7621 char expected[] = "\nResult4\n";
7623 char remotefilename[] = "/test-command";
7626 r = guestfs_upload (g, "test-command", remotefilename);
7631 char path[] = "/test-command";
7634 r = guestfs_chmod (g, 493, path);
7639 char arguments_0[] = "/test-command";
7640 char arguments_1[] = "4";
7641 char *arguments[] = {
7648 r = guestfs_command (g, arguments);
7651 if (strcmp (r, expected) != 0) {
7652 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7658 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7662 static int test_command_4_prereq (void)
7664 const char *str = getenv ("SKIP_TEST_COMMAND");
7665 return str && strcmp (str, "1") == 0;
7668 static int test_command_4 (void)
7670 if (! test_command_4_prereq ()) {
7671 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7673 char device[] = "/dev/sda";
7674 device[5] = devchar;
7677 r = guestfs_blockdev_setrw (g, device);
7684 r = guestfs_umount_all (g);
7691 r = guestfs_lvm_remove_all (g);
7696 char device[] = "/dev/sda";
7697 device[5] = devchar;
7698 char lines_0[] = ",";
7705 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7710 char fstype[] = "ext2";
7711 char device[] = "/dev/sda1";
7712 device[5] = devchar;
7715 r = guestfs_mkfs (g, fstype, device);
7720 char device[] = "/dev/sda1";
7721 device[5] = devchar;
7722 char mountpoint[] = "/";
7725 r = guestfs_mount (g, device, mountpoint);
7729 /* TestOutput for command (4) */
7730 char expected[] = "\nResult5\n\n";
7732 char remotefilename[] = "/test-command";
7735 r = guestfs_upload (g, "test-command", remotefilename);
7740 char path[] = "/test-command";
7743 r = guestfs_chmod (g, 493, path);
7748 char arguments_0[] = "/test-command";
7749 char arguments_1[] = "5";
7750 char *arguments[] = {
7757 r = guestfs_command (g, arguments);
7760 if (strcmp (r, expected) != 0) {
7761 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7767 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7771 static int test_command_5_prereq (void)
7773 const char *str = getenv ("SKIP_TEST_COMMAND");
7774 return str && strcmp (str, "1") == 0;
7777 static int test_command_5 (void)
7779 if (! test_command_5_prereq ()) {
7780 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7782 char device[] = "/dev/sda";
7783 device[5] = devchar;
7786 r = guestfs_blockdev_setrw (g, device);
7793 r = guestfs_umount_all (g);
7800 r = guestfs_lvm_remove_all (g);
7805 char device[] = "/dev/sda";
7806 device[5] = devchar;
7807 char lines_0[] = ",";
7814 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7819 char fstype[] = "ext2";
7820 char device[] = "/dev/sda1";
7821 device[5] = devchar;
7824 r = guestfs_mkfs (g, fstype, device);
7829 char device[] = "/dev/sda1";
7830 device[5] = devchar;
7831 char mountpoint[] = "/";
7834 r = guestfs_mount (g, device, mountpoint);
7838 /* TestOutput for command (5) */
7839 char expected[] = "\n\nResult6\n\n";
7841 char remotefilename[] = "/test-command";
7844 r = guestfs_upload (g, "test-command", remotefilename);
7849 char path[] = "/test-command";
7852 r = guestfs_chmod (g, 493, path);
7857 char arguments_0[] = "/test-command";
7858 char arguments_1[] = "6";
7859 char *arguments[] = {
7866 r = guestfs_command (g, arguments);
7869 if (strcmp (r, expected) != 0) {
7870 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7876 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7880 static int test_command_6_prereq (void)
7882 const char *str = getenv ("SKIP_TEST_COMMAND");
7883 return str && strcmp (str, "1") == 0;
7886 static int test_command_6 (void)
7888 if (! test_command_6_prereq ()) {
7889 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7891 char device[] = "/dev/sda";
7892 device[5] = devchar;
7895 r = guestfs_blockdev_setrw (g, device);
7902 r = guestfs_umount_all (g);
7909 r = guestfs_lvm_remove_all (g);
7914 char device[] = "/dev/sda";
7915 device[5] = devchar;
7916 char lines_0[] = ",";
7923 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7928 char fstype[] = "ext2";
7929 char device[] = "/dev/sda1";
7930 device[5] = devchar;
7933 r = guestfs_mkfs (g, fstype, device);
7938 char device[] = "/dev/sda1";
7939 device[5] = devchar;
7940 char mountpoint[] = "/";
7943 r = guestfs_mount (g, device, mountpoint);
7947 /* TestOutput for command (6) */
7948 char expected[] = "";
7950 char remotefilename[] = "/test-command";
7953 r = guestfs_upload (g, "test-command", remotefilename);
7958 char path[] = "/test-command";
7961 r = guestfs_chmod (g, 493, path);
7966 char arguments_0[] = "/test-command";
7967 char arguments_1[] = "7";
7968 char *arguments[] = {
7975 r = guestfs_command (g, arguments);
7978 if (strcmp (r, expected) != 0) {
7979 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7985 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7989 static int test_command_7_prereq (void)
7991 const char *str = getenv ("SKIP_TEST_COMMAND");
7992 return str && strcmp (str, "1") == 0;
7995 static int test_command_7 (void)
7997 if (! test_command_7_prereq ()) {
7998 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
8000 char device[] = "/dev/sda";
8001 device[5] = devchar;
8004 r = guestfs_blockdev_setrw (g, device);
8011 r = guestfs_umount_all (g);
8018 r = guestfs_lvm_remove_all (g);
8023 char device[] = "/dev/sda";
8024 device[5] = devchar;
8025 char lines_0[] = ",";
8032 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8037 char fstype[] = "ext2";
8038 char device[] = "/dev/sda1";
8039 device[5] = devchar;
8042 r = guestfs_mkfs (g, fstype, device);
8047 char device[] = "/dev/sda1";
8048 device[5] = devchar;
8049 char mountpoint[] = "/";
8052 r = guestfs_mount (g, device, mountpoint);
8056 /* TestOutput for command (7) */
8057 char expected[] = "\n";
8059 char remotefilename[] = "/test-command";
8062 r = guestfs_upload (g, "test-command", remotefilename);
8067 char path[] = "/test-command";
8070 r = guestfs_chmod (g, 493, path);
8075 char arguments_0[] = "/test-command";
8076 char arguments_1[] = "8";
8077 char *arguments[] = {
8084 r = guestfs_command (g, arguments);
8087 if (strcmp (r, expected) != 0) {
8088 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
8094 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
8098 static int test_command_8_prereq (void)
8100 const char *str = getenv ("SKIP_TEST_COMMAND");
8101 return str && strcmp (str, "1") == 0;
8104 static int test_command_8 (void)
8106 if (! test_command_8_prereq ()) {
8107 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
8109 char device[] = "/dev/sda";
8110 device[5] = devchar;
8113 r = guestfs_blockdev_setrw (g, device);
8120 r = guestfs_umount_all (g);
8127 r = guestfs_lvm_remove_all (g);
8132 char device[] = "/dev/sda";
8133 device[5] = devchar;
8134 char lines_0[] = ",";
8141 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8146 char fstype[] = "ext2";
8147 char device[] = "/dev/sda1";
8148 device[5] = devchar;
8151 r = guestfs_mkfs (g, fstype, device);
8156 char device[] = "/dev/sda1";
8157 device[5] = devchar;
8158 char mountpoint[] = "/";
8161 r = guestfs_mount (g, device, mountpoint);
8165 /* TestOutput for command (8) */
8166 char expected[] = "\n\n";
8168 char remotefilename[] = "/test-command";
8171 r = guestfs_upload (g, "test-command", remotefilename);
8176 char path[] = "/test-command";
8179 r = guestfs_chmod (g, 493, path);
8184 char arguments_0[] = "/test-command";
8185 char arguments_1[] = "9";
8186 char *arguments[] = {
8193 r = guestfs_command (g, arguments);
8196 if (strcmp (r, expected) != 0) {
8197 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
8203 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
8207 static int test_command_9_prereq (void)
8209 const char *str = getenv ("SKIP_TEST_COMMAND");
8210 return str && strcmp (str, "1") == 0;
8213 static int test_command_9 (void)
8215 if (! test_command_9_prereq ()) {
8216 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
8218 char device[] = "/dev/sda";
8219 device[5] = devchar;
8222 r = guestfs_blockdev_setrw (g, device);
8229 r = guestfs_umount_all (g);
8236 r = guestfs_lvm_remove_all (g);
8241 char device[] = "/dev/sda";
8242 device[5] = devchar;
8243 char lines_0[] = ",";
8250 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8255 char fstype[] = "ext2";
8256 char device[] = "/dev/sda1";
8257 device[5] = devchar;
8260 r = guestfs_mkfs (g, fstype, device);
8265 char device[] = "/dev/sda1";
8266 device[5] = devchar;
8267 char mountpoint[] = "/";
8270 r = guestfs_mount (g, device, mountpoint);
8274 /* TestOutput for command (9) */
8275 char expected[] = "Result10-1\nResult10-2\n";
8277 char remotefilename[] = "/test-command";
8280 r = guestfs_upload (g, "test-command", remotefilename);
8285 char path[] = "/test-command";
8288 r = guestfs_chmod (g, 493, path);
8293 char arguments_0[] = "/test-command";
8294 char arguments_1[] = "10";
8295 char *arguments[] = {
8302 r = guestfs_command (g, arguments);
8305 if (strcmp (r, expected) != 0) {
8306 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
8312 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
8316 static int test_command_10_prereq (void)
8318 const char *str = getenv ("SKIP_TEST_COMMAND");
8319 return str && strcmp (str, "1") == 0;
8322 static int test_command_10 (void)
8324 if (! test_command_10_prereq ()) {
8325 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
8327 char device[] = "/dev/sda";
8328 device[5] = devchar;
8331 r = guestfs_blockdev_setrw (g, device);
8338 r = guestfs_umount_all (g);
8345 r = guestfs_lvm_remove_all (g);
8350 char device[] = "/dev/sda";
8351 device[5] = devchar;
8352 char lines_0[] = ",";
8359 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8364 char fstype[] = "ext2";
8365 char device[] = "/dev/sda1";
8366 device[5] = devchar;
8369 r = guestfs_mkfs (g, fstype, device);
8374 char device[] = "/dev/sda1";
8375 device[5] = devchar;
8376 char mountpoint[] = "/";
8379 r = guestfs_mount (g, device, mountpoint);
8383 /* TestOutput for command (10) */
8384 char expected[] = "Result11-1\nResult11-2";
8386 char remotefilename[] = "/test-command";
8389 r = guestfs_upload (g, "test-command", remotefilename);
8394 char path[] = "/test-command";
8397 r = guestfs_chmod (g, 493, path);
8402 char arguments_0[] = "/test-command";
8403 char arguments_1[] = "11";
8404 char *arguments[] = {
8411 r = guestfs_command (g, arguments);
8414 if (strcmp (r, expected) != 0) {
8415 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
8421 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
8425 static int test_command_11_prereq (void)
8427 const char *str = getenv ("SKIP_TEST_COMMAND");
8428 return str && strcmp (str, "1") == 0;
8431 static int test_command_11 (void)
8433 if (! test_command_11_prereq ()) {
8434 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
8436 char device[] = "/dev/sda";
8437 device[5] = devchar;
8440 r = guestfs_blockdev_setrw (g, device);
8447 r = guestfs_umount_all (g);
8454 r = guestfs_lvm_remove_all (g);
8459 char device[] = "/dev/sda";
8460 device[5] = devchar;
8461 char lines_0[] = ",";
8468 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8473 char fstype[] = "ext2";
8474 char device[] = "/dev/sda1";
8475 device[5] = devchar;
8478 r = guestfs_mkfs (g, fstype, device);
8483 char device[] = "/dev/sda1";
8484 device[5] = devchar;
8485 char mountpoint[] = "/";
8488 r = guestfs_mount (g, device, mountpoint);
8492 /* TestLastFail for command (11) */
8494 char remotefilename[] = "/test-command";
8497 r = guestfs_upload (g, "test-command", remotefilename);
8502 char path[] = "/test-command";
8505 r = guestfs_chmod (g, 493, path);
8510 char arguments_0[] = "/test-command";
8511 char *arguments[] = {
8517 r = guestfs_command (g, arguments);
8523 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8527 static int test_file_0 (void)
8529 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8531 char device[] = "/dev/sda";
8532 device[5] = devchar;
8535 r = guestfs_blockdev_setrw (g, device);
8542 r = guestfs_umount_all (g);
8549 r = guestfs_lvm_remove_all (g);
8554 char device[] = "/dev/sda";
8555 device[5] = devchar;
8556 char lines_0[] = ",";
8563 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8568 char fstype[] = "ext2";
8569 char device[] = "/dev/sda1";
8570 device[5] = devchar;
8573 r = guestfs_mkfs (g, fstype, device);
8578 char device[] = "/dev/sda1";
8579 device[5] = devchar;
8580 char mountpoint[] = "/";
8583 r = guestfs_mount (g, device, mountpoint);
8587 /* TestOutput for file (0) */
8588 char expected[] = "empty";
8590 char path[] = "/new";
8593 r = guestfs_touch (g, path);
8598 char path[] = "/new";
8601 r = guestfs_file (g, path);
8604 if (strcmp (r, expected) != 0) {
8605 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8613 static int test_file_1 (void)
8615 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8617 char device[] = "/dev/sda";
8618 device[5] = devchar;
8621 r = guestfs_blockdev_setrw (g, device);
8628 r = guestfs_umount_all (g);
8635 r = guestfs_lvm_remove_all (g);
8640 char device[] = "/dev/sda";
8641 device[5] = devchar;
8642 char lines_0[] = ",";
8649 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8654 char fstype[] = "ext2";
8655 char device[] = "/dev/sda1";
8656 device[5] = devchar;
8659 r = guestfs_mkfs (g, fstype, device);
8664 char device[] = "/dev/sda1";
8665 device[5] = devchar;
8666 char mountpoint[] = "/";
8669 r = guestfs_mount (g, device, mountpoint);
8673 /* TestOutput for file (1) */
8674 char expected[] = "ASCII text";
8676 char path[] = "/new";
8677 char content[] = "some content\n";
8680 r = guestfs_write_file (g, path, content, 0);
8685 char path[] = "/new";
8688 r = guestfs_file (g, path);
8691 if (strcmp (r, expected) != 0) {
8692 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8700 static int test_file_2 (void)
8702 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8704 char device[] = "/dev/sda";
8705 device[5] = devchar;
8708 r = guestfs_blockdev_setrw (g, device);
8715 r = guestfs_umount_all (g);
8722 r = guestfs_lvm_remove_all (g);
8727 char device[] = "/dev/sda";
8728 device[5] = devchar;
8729 char lines_0[] = ",";
8736 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8741 char fstype[] = "ext2";
8742 char device[] = "/dev/sda1";
8743 device[5] = devchar;
8746 r = guestfs_mkfs (g, fstype, device);
8751 char device[] = "/dev/sda1";
8752 device[5] = devchar;
8753 char mountpoint[] = "/";
8756 r = guestfs_mount (g, device, mountpoint);
8760 /* TestLastFail for file (2) */
8762 char path[] = "/nofile";
8765 r = guestfs_file (g, path);
8773 static int test_umount_all_0 (void)
8775 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8777 char device[] = "/dev/sda";
8778 device[5] = devchar;
8781 r = guestfs_blockdev_setrw (g, device);
8788 r = guestfs_umount_all (g);
8795 r = guestfs_lvm_remove_all (g);
8800 char device[] = "/dev/sda";
8801 device[5] = devchar;
8802 char lines_0[] = ",";
8809 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8814 char fstype[] = "ext2";
8815 char device[] = "/dev/sda1";
8816 device[5] = devchar;
8819 r = guestfs_mkfs (g, fstype, device);
8824 char device[] = "/dev/sda1";
8825 device[5] = devchar;
8826 char mountpoint[] = "/";
8829 r = guestfs_mount (g, device, mountpoint);
8833 /* TestOutputList for umount_all (0) */
8837 r = guestfs_umount_all (g);
8845 r = guestfs_mounts (g);
8849 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8853 for (i = 0; r[i] != NULL; ++i)
8860 static int test_umount_all_1 (void)
8862 /* InitNone|InitEmpty for test_umount_all_1 */
8864 char device[] = "/dev/sda";
8865 device[5] = devchar;
8868 r = guestfs_blockdev_setrw (g, device);
8875 r = guestfs_umount_all (g);
8882 r = guestfs_lvm_remove_all (g);
8886 /* TestOutputList for umount_all (1) */
8888 char device[] = "/dev/sda";
8889 device[5] = devchar;
8890 char lines_0[] = ",10";
8891 char lines_1[] = ",20";
8892 char lines_2[] = ",";
8901 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8906 char fstype[] = "ext2";
8907 char device[] = "/dev/sda1";
8908 device[5] = devchar;
8911 r = guestfs_mkfs (g, fstype, device);
8916 char fstype[] = "ext2";
8917 char device[] = "/dev/sda2";
8918 device[5] = devchar;
8921 r = guestfs_mkfs (g, fstype, device);
8926 char fstype[] = "ext2";
8927 char device[] = "/dev/sda3";
8928 device[5] = devchar;
8931 r = guestfs_mkfs (g, fstype, device);
8936 char device[] = "/dev/sda1";
8937 device[5] = devchar;
8938 char mountpoint[] = "/";
8941 r = guestfs_mount (g, device, mountpoint);
8946 char path[] = "/mp1";
8949 r = guestfs_mkdir (g, path);
8954 char device[] = "/dev/sda2";
8955 device[5] = devchar;
8956 char mountpoint[] = "/mp1";
8959 r = guestfs_mount (g, device, mountpoint);
8964 char path[] = "/mp1/mp2";
8967 r = guestfs_mkdir (g, path);
8972 char device[] = "/dev/sda3";
8973 device[5] = devchar;
8974 char mountpoint[] = "/mp1/mp2";
8977 r = guestfs_mount (g, device, mountpoint);
8982 char path[] = "/mp1/mp2/mp3";
8985 r = guestfs_mkdir (g, path);
8992 r = guestfs_umount_all (g);
9000 r = guestfs_mounts (g);
9004 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
9008 for (i = 0; r[i] != NULL; ++i)
9015 static int test_mounts_0 (void)
9017 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
9019 char device[] = "/dev/sda";
9020 device[5] = devchar;
9023 r = guestfs_blockdev_setrw (g, device);
9030 r = guestfs_umount_all (g);
9037 r = guestfs_lvm_remove_all (g);
9042 char device[] = "/dev/sda";
9043 device[5] = devchar;
9044 char lines_0[] = ",";
9051 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9056 char fstype[] = "ext2";
9057 char device[] = "/dev/sda1";
9058 device[5] = devchar;
9061 r = guestfs_mkfs (g, fstype, device);
9066 char device[] = "/dev/sda1";
9067 device[5] = devchar;
9068 char mountpoint[] = "/";
9071 r = guestfs_mount (g, device, mountpoint);
9075 /* TestOutputList for mounts (0) */
9080 r = guestfs_mounts (g);
9084 fprintf (stderr, "test_mounts_0: short list returned from command\n");
9089 char expected[] = "/dev/sda1";
9090 expected[5] = devchar;
9091 if (strcmp (r[0], expected) != 0) {
9092 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9097 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
9101 for (i = 0; r[i] != NULL; ++i)
9108 static int test_umount_0 (void)
9110 /* InitNone|InitEmpty for test_umount_0 */
9112 char device[] = "/dev/sda";
9113 device[5] = devchar;
9116 r = guestfs_blockdev_setrw (g, device);
9123 r = guestfs_umount_all (g);
9130 r = guestfs_lvm_remove_all (g);
9134 /* TestOutputList for umount (0) */
9136 char device[] = "/dev/sda";
9137 device[5] = devchar;
9138 char lines_0[] = ",";
9145 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9150 char fstype[] = "ext2";
9151 char device[] = "/dev/sda1";
9152 device[5] = devchar;
9155 r = guestfs_mkfs (g, fstype, device);
9160 char device[] = "/dev/sda1";
9161 device[5] = devchar;
9162 char mountpoint[] = "/";
9165 r = guestfs_mount (g, device, mountpoint);
9173 r = guestfs_mounts (g);
9177 fprintf (stderr, "test_umount_0: short list returned from command\n");
9182 char expected[] = "/dev/sda1";
9183 expected[5] = devchar;
9184 if (strcmp (r[0], expected) != 0) {
9185 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9190 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
9194 for (i = 0; r[i] != NULL; ++i)
9201 static int test_umount_1 (void)
9203 /* InitNone|InitEmpty for test_umount_1 */
9205 char device[] = "/dev/sda";
9206 device[5] = devchar;
9209 r = guestfs_blockdev_setrw (g, device);
9216 r = guestfs_umount_all (g);
9223 r = guestfs_lvm_remove_all (g);
9227 /* TestOutputList for umount (1) */
9229 char device[] = "/dev/sda";
9230 device[5] = devchar;
9231 char lines_0[] = ",";
9238 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9243 char fstype[] = "ext2";
9244 char device[] = "/dev/sda1";
9245 device[5] = devchar;
9248 r = guestfs_mkfs (g, fstype, device);
9253 char device[] = "/dev/sda1";
9254 device[5] = devchar;
9255 char mountpoint[] = "/";
9258 r = guestfs_mount (g, device, mountpoint);
9263 char pathordevice[] = "/";
9266 r = guestfs_umount (g, pathordevice);
9274 r = guestfs_mounts (g);
9278 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
9282 for (i = 0; r[i] != NULL; ++i)
9289 static int test_write_file_0 (void)
9291 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
9293 char device[] = "/dev/sda";
9294 device[5] = devchar;
9297 r = guestfs_blockdev_setrw (g, device);
9304 r = guestfs_umount_all (g);
9311 r = guestfs_lvm_remove_all (g);
9316 char device[] = "/dev/sda";
9317 device[5] = devchar;
9318 char lines_0[] = ",";
9325 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9330 char fstype[] = "ext2";
9331 char device[] = "/dev/sda1";
9332 device[5] = devchar;
9335 r = guestfs_mkfs (g, fstype, device);
9340 char device[] = "/dev/sda1";
9341 device[5] = devchar;
9342 char mountpoint[] = "/";
9345 r = guestfs_mount (g, device, mountpoint);
9349 /* TestOutput for write_file (0) */
9350 char expected[] = "new file contents";
9352 char path[] = "/new";
9353 char content[] = "new file contents";
9356 r = guestfs_write_file (g, path, content, 0);
9361 char path[] = "/new";
9364 r = guestfs_cat (g, path);
9367 if (strcmp (r, expected) != 0) {
9368 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9376 static int test_write_file_1 (void)
9378 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
9380 char device[] = "/dev/sda";
9381 device[5] = devchar;
9384 r = guestfs_blockdev_setrw (g, device);
9391 r = guestfs_umount_all (g);
9398 r = guestfs_lvm_remove_all (g);
9403 char device[] = "/dev/sda";
9404 device[5] = devchar;
9405 char lines_0[] = ",";
9412 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9417 char fstype[] = "ext2";
9418 char device[] = "/dev/sda1";
9419 device[5] = devchar;
9422 r = guestfs_mkfs (g, fstype, device);
9427 char device[] = "/dev/sda1";
9428 device[5] = devchar;
9429 char mountpoint[] = "/";
9432 r = guestfs_mount (g, device, mountpoint);
9436 /* TestOutput for write_file (1) */
9437 char expected[] = "\nnew file contents\n";
9439 char path[] = "/new";
9440 char content[] = "\nnew file contents\n";
9443 r = guestfs_write_file (g, path, content, 0);
9448 char path[] = "/new";
9451 r = guestfs_cat (g, path);
9454 if (strcmp (r, expected) != 0) {
9455 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9463 static int test_write_file_2 (void)
9465 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
9467 char device[] = "/dev/sda";
9468 device[5] = devchar;
9471 r = guestfs_blockdev_setrw (g, device);
9478 r = guestfs_umount_all (g);
9485 r = guestfs_lvm_remove_all (g);
9490 char device[] = "/dev/sda";
9491 device[5] = devchar;
9492 char lines_0[] = ",";
9499 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9504 char fstype[] = "ext2";
9505 char device[] = "/dev/sda1";
9506 device[5] = devchar;
9509 r = guestfs_mkfs (g, fstype, device);
9514 char device[] = "/dev/sda1";
9515 device[5] = devchar;
9516 char mountpoint[] = "/";
9519 r = guestfs_mount (g, device, mountpoint);
9523 /* TestOutput for write_file (2) */
9524 char expected[] = "\n\n";
9526 char path[] = "/new";
9527 char content[] = "\n\n";
9530 r = guestfs_write_file (g, path, content, 0);
9535 char path[] = "/new";
9538 r = guestfs_cat (g, path);
9541 if (strcmp (r, expected) != 0) {
9542 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9550 static int test_write_file_3 (void)
9552 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9554 char device[] = "/dev/sda";
9555 device[5] = devchar;
9558 r = guestfs_blockdev_setrw (g, device);
9565 r = guestfs_umount_all (g);
9572 r = guestfs_lvm_remove_all (g);
9577 char device[] = "/dev/sda";
9578 device[5] = devchar;
9579 char lines_0[] = ",";
9586 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9591 char fstype[] = "ext2";
9592 char device[] = "/dev/sda1";
9593 device[5] = devchar;
9596 r = guestfs_mkfs (g, fstype, device);
9601 char device[] = "/dev/sda1";
9602 device[5] = devchar;
9603 char mountpoint[] = "/";
9606 r = guestfs_mount (g, device, mountpoint);
9610 /* TestOutput for write_file (3) */
9611 char expected[] = "";
9613 char path[] = "/new";
9614 char content[] = "";
9617 r = guestfs_write_file (g, path, content, 0);
9622 char path[] = "/new";
9625 r = guestfs_cat (g, path);
9628 if (strcmp (r, expected) != 0) {
9629 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9637 static int test_write_file_4 (void)
9639 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9641 char device[] = "/dev/sda";
9642 device[5] = devchar;
9645 r = guestfs_blockdev_setrw (g, device);
9652 r = guestfs_umount_all (g);
9659 r = guestfs_lvm_remove_all (g);
9664 char device[] = "/dev/sda";
9665 device[5] = devchar;
9666 char lines_0[] = ",";
9673 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9678 char fstype[] = "ext2";
9679 char device[] = "/dev/sda1";
9680 device[5] = devchar;
9683 r = guestfs_mkfs (g, fstype, device);
9688 char device[] = "/dev/sda1";
9689 device[5] = devchar;
9690 char mountpoint[] = "/";
9693 r = guestfs_mount (g, device, mountpoint);
9697 /* TestOutput for write_file (4) */
9698 char expected[] = "\n\n\n";
9700 char path[] = "/new";
9701 char content[] = "\n\n\n";
9704 r = guestfs_write_file (g, path, content, 0);
9709 char path[] = "/new";
9712 r = guestfs_cat (g, path);
9715 if (strcmp (r, expected) != 0) {
9716 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9724 static int test_write_file_5 (void)
9726 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9728 char device[] = "/dev/sda";
9729 device[5] = devchar;
9732 r = guestfs_blockdev_setrw (g, device);
9739 r = guestfs_umount_all (g);
9746 r = guestfs_lvm_remove_all (g);
9751 char device[] = "/dev/sda";
9752 device[5] = devchar;
9753 char lines_0[] = ",";
9760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9765 char fstype[] = "ext2";
9766 char device[] = "/dev/sda1";
9767 device[5] = devchar;
9770 r = guestfs_mkfs (g, fstype, device);
9775 char device[] = "/dev/sda1";
9776 device[5] = devchar;
9777 char mountpoint[] = "/";
9780 r = guestfs_mount (g, device, mountpoint);
9784 /* TestOutput for write_file (5) */
9785 char expected[] = "\n";
9787 char path[] = "/new";
9788 char content[] = "\n";
9791 r = guestfs_write_file (g, path, content, 0);
9796 char path[] = "/new";
9799 r = guestfs_cat (g, path);
9802 if (strcmp (r, expected) != 0) {
9803 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9811 static int test_mkfs_0 (void)
9813 /* InitNone|InitEmpty for test_mkfs_0 */
9815 char device[] = "/dev/sda";
9816 device[5] = devchar;
9819 r = guestfs_blockdev_setrw (g, device);
9826 r = guestfs_umount_all (g);
9833 r = guestfs_lvm_remove_all (g);
9837 /* TestOutput for mkfs (0) */
9838 char expected[] = "new file contents";
9840 char device[] = "/dev/sda";
9841 device[5] = devchar;
9842 char lines_0[] = ",";
9849 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9854 char fstype[] = "ext2";
9855 char device[] = "/dev/sda1";
9856 device[5] = devchar;
9859 r = guestfs_mkfs (g, fstype, device);
9864 char device[] = "/dev/sda1";
9865 device[5] = devchar;
9866 char mountpoint[] = "/";
9869 r = guestfs_mount (g, device, mountpoint);
9874 char path[] = "/new";
9875 char content[] = "new file contents";
9878 r = guestfs_write_file (g, path, content, 0);
9883 char path[] = "/new";
9886 r = guestfs_cat (g, path);
9889 if (strcmp (r, expected) != 0) {
9890 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9898 static int test_lvcreate_0 (void)
9900 /* InitNone|InitEmpty for test_lvcreate_0 */
9902 char device[] = "/dev/sda";
9903 device[5] = devchar;
9906 r = guestfs_blockdev_setrw (g, device);
9913 r = guestfs_umount_all (g);
9920 r = guestfs_lvm_remove_all (g);
9924 /* TestOutputList for lvcreate (0) */
9926 char device[] = "/dev/sda";
9927 device[5] = devchar;
9928 char lines_0[] = ",10";
9929 char lines_1[] = ",20";
9930 char lines_2[] = ",";
9939 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9944 char device[] = "/dev/sda1";
9945 device[5] = devchar;
9948 r = guestfs_pvcreate (g, device);
9953 char device[] = "/dev/sda2";
9954 device[5] = devchar;
9957 r = guestfs_pvcreate (g, device);
9962 char device[] = "/dev/sda3";
9963 device[5] = devchar;
9966 r = guestfs_pvcreate (g, device);
9971 char volgroup[] = "VG1";
9972 char physvols_0[] = "/dev/sda1";
9973 physvols_0[5] = devchar;
9974 char physvols_1[] = "/dev/sda2";
9975 physvols_1[5] = devchar;
9976 char *physvols[] = {
9983 r = guestfs_vgcreate (g, volgroup, physvols);
9988 char volgroup[] = "VG2";
9989 char physvols_0[] = "/dev/sda3";
9990 physvols_0[5] = devchar;
9991 char *physvols[] = {
9997 r = guestfs_vgcreate (g, volgroup, physvols);
10002 char logvol[] = "LV1";
10003 char volgroup[] = "VG1";
10005 suppress_error = 0;
10006 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10011 char logvol[] = "LV2";
10012 char volgroup[] = "VG1";
10014 suppress_error = 0;
10015 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10020 char logvol[] = "LV3";
10021 char volgroup[] = "VG2";
10023 suppress_error = 0;
10024 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10029 char logvol[] = "LV4";
10030 char volgroup[] = "VG2";
10032 suppress_error = 0;
10033 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10038 char logvol[] = "LV5";
10039 char volgroup[] = "VG2";
10041 suppress_error = 0;
10042 r = guestfs_lvcreate (g, logvol, volgroup, 50);
10049 suppress_error = 0;
10050 r = guestfs_lvs (g);
10054 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10059 char expected[] = "/dev/VG1/LV1";
10060 if (strcmp (r[0], expected) != 0) {
10061 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10066 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10071 char expected[] = "/dev/VG1/LV2";
10072 if (strcmp (r[1], expected) != 0) {
10073 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10078 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10083 char expected[] = "/dev/VG2/LV3";
10084 if (strcmp (r[2], expected) != 0) {
10085 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10090 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10095 char expected[] = "/dev/VG2/LV4";
10096 if (strcmp (r[3], expected) != 0) {
10097 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10102 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
10107 char expected[] = "/dev/VG2/LV5";
10108 if (strcmp (r[4], expected) != 0) {
10109 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
10113 if (r[5] != NULL) {
10114 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
10118 for (i = 0; r[i] != NULL; ++i)
10125 static int test_vgcreate_0 (void)
10127 /* InitNone|InitEmpty for test_vgcreate_0 */
10129 char device[] = "/dev/sda";
10130 device[5] = devchar;
10132 suppress_error = 0;
10133 r = guestfs_blockdev_setrw (g, device);
10139 suppress_error = 0;
10140 r = guestfs_umount_all (g);
10146 suppress_error = 0;
10147 r = guestfs_lvm_remove_all (g);
10151 /* TestOutputList for vgcreate (0) */
10153 char device[] = "/dev/sda";
10154 device[5] = devchar;
10155 char lines_0[] = ",10";
10156 char lines_1[] = ",20";
10157 char lines_2[] = ",";
10165 suppress_error = 0;
10166 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10171 char device[] = "/dev/sda1";
10172 device[5] = devchar;
10174 suppress_error = 0;
10175 r = guestfs_pvcreate (g, device);
10180 char device[] = "/dev/sda2";
10181 device[5] = devchar;
10183 suppress_error = 0;
10184 r = guestfs_pvcreate (g, device);
10189 char device[] = "/dev/sda3";
10190 device[5] = devchar;
10192 suppress_error = 0;
10193 r = guestfs_pvcreate (g, device);
10198 char volgroup[] = "VG1";
10199 char physvols_0[] = "/dev/sda1";
10200 physvols_0[5] = devchar;
10201 char physvols_1[] = "/dev/sda2";
10202 physvols_1[5] = devchar;
10203 char *physvols[] = {
10209 suppress_error = 0;
10210 r = guestfs_vgcreate (g, volgroup, physvols);
10215 char volgroup[] = "VG2";
10216 char physvols_0[] = "/dev/sda3";
10217 physvols_0[5] = devchar;
10218 char *physvols[] = {
10223 suppress_error = 0;
10224 r = guestfs_vgcreate (g, volgroup, physvols);
10231 suppress_error = 0;
10232 r = guestfs_vgs (g);
10236 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10241 char expected[] = "VG1";
10242 if (strcmp (r[0], expected) != 0) {
10243 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10248 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10253 char expected[] = "VG2";
10254 if (strcmp (r[1], expected) != 0) {
10255 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10259 if (r[2] != NULL) {
10260 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
10264 for (i = 0; r[i] != NULL; ++i)
10271 static int test_pvcreate_0 (void)
10273 /* InitNone|InitEmpty for test_pvcreate_0 */
10275 char device[] = "/dev/sda";
10276 device[5] = devchar;
10278 suppress_error = 0;
10279 r = guestfs_blockdev_setrw (g, device);
10285 suppress_error = 0;
10286 r = guestfs_umount_all (g);
10292 suppress_error = 0;
10293 r = guestfs_lvm_remove_all (g);
10297 /* TestOutputList for pvcreate (0) */
10299 char device[] = "/dev/sda";
10300 device[5] = devchar;
10301 char lines_0[] = ",10";
10302 char lines_1[] = ",20";
10303 char lines_2[] = ",";
10311 suppress_error = 0;
10312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10317 char device[] = "/dev/sda1";
10318 device[5] = devchar;
10320 suppress_error = 0;
10321 r = guestfs_pvcreate (g, device);
10326 char device[] = "/dev/sda2";
10327 device[5] = devchar;
10329 suppress_error = 0;
10330 r = guestfs_pvcreate (g, device);
10335 char device[] = "/dev/sda3";
10336 device[5] = devchar;
10338 suppress_error = 0;
10339 r = guestfs_pvcreate (g, device);
10346 suppress_error = 0;
10347 r = guestfs_pvs (g);
10351 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10356 char expected[] = "/dev/sda1";
10357 expected[5] = devchar;
10358 if (strcmp (r[0], expected) != 0) {
10359 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10364 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10369 char expected[] = "/dev/sda2";
10370 expected[5] = devchar;
10371 if (strcmp (r[1], expected) != 0) {
10372 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10377 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10382 char expected[] = "/dev/sda3";
10383 expected[5] = devchar;
10384 if (strcmp (r[2], expected) != 0) {
10385 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10389 if (r[3] != NULL) {
10390 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
10394 for (i = 0; r[i] != NULL; ++i)
10401 static int test_is_dir_0 (void)
10403 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
10405 char device[] = "/dev/sda";
10406 device[5] = devchar;
10408 suppress_error = 0;
10409 r = guestfs_blockdev_setrw (g, device);
10415 suppress_error = 0;
10416 r = guestfs_umount_all (g);
10422 suppress_error = 0;
10423 r = guestfs_lvm_remove_all (g);
10428 char device[] = "/dev/sda";
10429 device[5] = devchar;
10430 char lines_0[] = ",";
10436 suppress_error = 0;
10437 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10442 char fstype[] = "ext2";
10443 char device[] = "/dev/sda1";
10444 device[5] = devchar;
10446 suppress_error = 0;
10447 r = guestfs_mkfs (g, fstype, device);
10452 char device[] = "/dev/sda1";
10453 device[5] = devchar;
10454 char mountpoint[] = "/";
10456 suppress_error = 0;
10457 r = guestfs_mount (g, device, mountpoint);
10461 /* TestOutputFalse for is_dir (0) */
10463 char path[] = "/new";
10465 suppress_error = 0;
10466 r = guestfs_touch (g, path);
10471 char path[] = "/new";
10473 suppress_error = 0;
10474 r = guestfs_is_dir (g, path);
10478 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
10485 static int test_is_dir_1 (void)
10487 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
10489 char device[] = "/dev/sda";
10490 device[5] = devchar;
10492 suppress_error = 0;
10493 r = guestfs_blockdev_setrw (g, device);
10499 suppress_error = 0;
10500 r = guestfs_umount_all (g);
10506 suppress_error = 0;
10507 r = guestfs_lvm_remove_all (g);
10512 char device[] = "/dev/sda";
10513 device[5] = devchar;
10514 char lines_0[] = ",";
10520 suppress_error = 0;
10521 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10526 char fstype[] = "ext2";
10527 char device[] = "/dev/sda1";
10528 device[5] = devchar;
10530 suppress_error = 0;
10531 r = guestfs_mkfs (g, fstype, device);
10536 char device[] = "/dev/sda1";
10537 device[5] = devchar;
10538 char mountpoint[] = "/";
10540 suppress_error = 0;
10541 r = guestfs_mount (g, device, mountpoint);
10545 /* TestOutputTrue for is_dir (1) */
10547 char path[] = "/new";
10549 suppress_error = 0;
10550 r = guestfs_mkdir (g, path);
10555 char path[] = "/new";
10557 suppress_error = 0;
10558 r = guestfs_is_dir (g, path);
10562 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10569 static int test_is_file_0 (void)
10571 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10573 char device[] = "/dev/sda";
10574 device[5] = devchar;
10576 suppress_error = 0;
10577 r = guestfs_blockdev_setrw (g, device);
10583 suppress_error = 0;
10584 r = guestfs_umount_all (g);
10590 suppress_error = 0;
10591 r = guestfs_lvm_remove_all (g);
10596 char device[] = "/dev/sda";
10597 device[5] = devchar;
10598 char lines_0[] = ",";
10604 suppress_error = 0;
10605 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10610 char fstype[] = "ext2";
10611 char device[] = "/dev/sda1";
10612 device[5] = devchar;
10614 suppress_error = 0;
10615 r = guestfs_mkfs (g, fstype, device);
10620 char device[] = "/dev/sda1";
10621 device[5] = devchar;
10622 char mountpoint[] = "/";
10624 suppress_error = 0;
10625 r = guestfs_mount (g, device, mountpoint);
10629 /* TestOutputTrue for is_file (0) */
10631 char path[] = "/new";
10633 suppress_error = 0;
10634 r = guestfs_touch (g, path);
10639 char path[] = "/new";
10641 suppress_error = 0;
10642 r = guestfs_is_file (g, path);
10646 fprintf (stderr, "test_is_file_0: expected true, got false\n");
10653 static int test_is_file_1 (void)
10655 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10657 char device[] = "/dev/sda";
10658 device[5] = devchar;
10660 suppress_error = 0;
10661 r = guestfs_blockdev_setrw (g, device);
10667 suppress_error = 0;
10668 r = guestfs_umount_all (g);
10674 suppress_error = 0;
10675 r = guestfs_lvm_remove_all (g);
10680 char device[] = "/dev/sda";
10681 device[5] = devchar;
10682 char lines_0[] = ",";
10688 suppress_error = 0;
10689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10694 char fstype[] = "ext2";
10695 char device[] = "/dev/sda1";
10696 device[5] = devchar;
10698 suppress_error = 0;
10699 r = guestfs_mkfs (g, fstype, device);
10704 char device[] = "/dev/sda1";
10705 device[5] = devchar;
10706 char mountpoint[] = "/";
10708 suppress_error = 0;
10709 r = guestfs_mount (g, device, mountpoint);
10713 /* TestOutputFalse for is_file (1) */
10715 char path[] = "/new";
10717 suppress_error = 0;
10718 r = guestfs_mkdir (g, path);
10723 char path[] = "/new";
10725 suppress_error = 0;
10726 r = guestfs_is_file (g, path);
10730 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10737 static int test_exists_0 (void)
10739 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10741 char device[] = "/dev/sda";
10742 device[5] = devchar;
10744 suppress_error = 0;
10745 r = guestfs_blockdev_setrw (g, device);
10751 suppress_error = 0;
10752 r = guestfs_umount_all (g);
10758 suppress_error = 0;
10759 r = guestfs_lvm_remove_all (g);
10764 char device[] = "/dev/sda";
10765 device[5] = devchar;
10766 char lines_0[] = ",";
10772 suppress_error = 0;
10773 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10778 char fstype[] = "ext2";
10779 char device[] = "/dev/sda1";
10780 device[5] = devchar;
10782 suppress_error = 0;
10783 r = guestfs_mkfs (g, fstype, device);
10788 char device[] = "/dev/sda1";
10789 device[5] = devchar;
10790 char mountpoint[] = "/";
10792 suppress_error = 0;
10793 r = guestfs_mount (g, device, mountpoint);
10797 /* TestOutputTrue for exists (0) */
10799 char path[] = "/new";
10801 suppress_error = 0;
10802 r = guestfs_touch (g, path);
10807 char path[] = "/new";
10809 suppress_error = 0;
10810 r = guestfs_exists (g, path);
10814 fprintf (stderr, "test_exists_0: expected true, got false\n");
10821 static int test_exists_1 (void)
10823 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10825 char device[] = "/dev/sda";
10826 device[5] = devchar;
10828 suppress_error = 0;
10829 r = guestfs_blockdev_setrw (g, device);
10835 suppress_error = 0;
10836 r = guestfs_umount_all (g);
10842 suppress_error = 0;
10843 r = guestfs_lvm_remove_all (g);
10848 char device[] = "/dev/sda";
10849 device[5] = devchar;
10850 char lines_0[] = ",";
10856 suppress_error = 0;
10857 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10862 char fstype[] = "ext2";
10863 char device[] = "/dev/sda1";
10864 device[5] = devchar;
10866 suppress_error = 0;
10867 r = guestfs_mkfs (g, fstype, device);
10872 char device[] = "/dev/sda1";
10873 device[5] = devchar;
10874 char mountpoint[] = "/";
10876 suppress_error = 0;
10877 r = guestfs_mount (g, device, mountpoint);
10881 /* TestOutputTrue for exists (1) */
10883 char path[] = "/new";
10885 suppress_error = 0;
10886 r = guestfs_mkdir (g, path);
10891 char path[] = "/new";
10893 suppress_error = 0;
10894 r = guestfs_exists (g, path);
10898 fprintf (stderr, "test_exists_1: expected true, got false\n");
10905 static int test_mkdir_p_0 (void)
10907 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10909 char device[] = "/dev/sda";
10910 device[5] = devchar;
10912 suppress_error = 0;
10913 r = guestfs_blockdev_setrw (g, device);
10919 suppress_error = 0;
10920 r = guestfs_umount_all (g);
10926 suppress_error = 0;
10927 r = guestfs_lvm_remove_all (g);
10932 char device[] = "/dev/sda";
10933 device[5] = devchar;
10934 char lines_0[] = ",";
10940 suppress_error = 0;
10941 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10946 char fstype[] = "ext2";
10947 char device[] = "/dev/sda1";
10948 device[5] = devchar;
10950 suppress_error = 0;
10951 r = guestfs_mkfs (g, fstype, device);
10956 char device[] = "/dev/sda1";
10957 device[5] = devchar;
10958 char mountpoint[] = "/";
10960 suppress_error = 0;
10961 r = guestfs_mount (g, device, mountpoint);
10965 /* TestOutputTrue for mkdir_p (0) */
10967 char path[] = "/new/foo/bar";
10969 suppress_error = 0;
10970 r = guestfs_mkdir_p (g, path);
10975 char path[] = "/new/foo/bar";
10977 suppress_error = 0;
10978 r = guestfs_is_dir (g, path);
10982 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10989 static int test_mkdir_p_1 (void)
10991 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10993 char device[] = "/dev/sda";
10994 device[5] = devchar;
10996 suppress_error = 0;
10997 r = guestfs_blockdev_setrw (g, device);
11003 suppress_error = 0;
11004 r = guestfs_umount_all (g);
11010 suppress_error = 0;
11011 r = guestfs_lvm_remove_all (g);
11016 char device[] = "/dev/sda";
11017 device[5] = devchar;
11018 char lines_0[] = ",";
11024 suppress_error = 0;
11025 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11030 char fstype[] = "ext2";
11031 char device[] = "/dev/sda1";
11032 device[5] = devchar;
11034 suppress_error = 0;
11035 r = guestfs_mkfs (g, fstype, device);
11040 char device[] = "/dev/sda1";
11041 device[5] = devchar;
11042 char mountpoint[] = "/";
11044 suppress_error = 0;
11045 r = guestfs_mount (g, device, mountpoint);
11049 /* TestOutputTrue for mkdir_p (1) */
11051 char path[] = "/new/foo/bar";
11053 suppress_error = 0;
11054 r = guestfs_mkdir_p (g, path);
11059 char path[] = "/new/foo";
11061 suppress_error = 0;
11062 r = guestfs_is_dir (g, path);
11066 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
11073 static int test_mkdir_p_2 (void)
11075 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
11077 char device[] = "/dev/sda";
11078 device[5] = devchar;
11080 suppress_error = 0;
11081 r = guestfs_blockdev_setrw (g, device);
11087 suppress_error = 0;
11088 r = guestfs_umount_all (g);
11094 suppress_error = 0;
11095 r = guestfs_lvm_remove_all (g);
11100 char device[] = "/dev/sda";
11101 device[5] = devchar;
11102 char lines_0[] = ",";
11108 suppress_error = 0;
11109 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11114 char fstype[] = "ext2";
11115 char device[] = "/dev/sda1";
11116 device[5] = devchar;
11118 suppress_error = 0;
11119 r = guestfs_mkfs (g, fstype, device);
11124 char device[] = "/dev/sda1";
11125 device[5] = devchar;
11126 char mountpoint[] = "/";
11128 suppress_error = 0;
11129 r = guestfs_mount (g, device, mountpoint);
11133 /* TestOutputTrue for mkdir_p (2) */
11135 char path[] = "/new/foo/bar";
11137 suppress_error = 0;
11138 r = guestfs_mkdir_p (g, path);
11143 char path[] = "/new";
11145 suppress_error = 0;
11146 r = guestfs_is_dir (g, path);
11150 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
11157 static int test_mkdir_0 (void)
11159 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
11161 char device[] = "/dev/sda";
11162 device[5] = devchar;
11164 suppress_error = 0;
11165 r = guestfs_blockdev_setrw (g, device);
11171 suppress_error = 0;
11172 r = guestfs_umount_all (g);
11178 suppress_error = 0;
11179 r = guestfs_lvm_remove_all (g);
11184 char device[] = "/dev/sda";
11185 device[5] = devchar;
11186 char lines_0[] = ",";
11192 suppress_error = 0;
11193 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11198 char fstype[] = "ext2";
11199 char device[] = "/dev/sda1";
11200 device[5] = devchar;
11202 suppress_error = 0;
11203 r = guestfs_mkfs (g, fstype, device);
11208 char device[] = "/dev/sda1";
11209 device[5] = devchar;
11210 char mountpoint[] = "/";
11212 suppress_error = 0;
11213 r = guestfs_mount (g, device, mountpoint);
11217 /* TestOutputTrue for mkdir (0) */
11219 char path[] = "/new";
11221 suppress_error = 0;
11222 r = guestfs_mkdir (g, path);
11227 char path[] = "/new";
11229 suppress_error = 0;
11230 r = guestfs_is_dir (g, path);
11234 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
11241 static int test_mkdir_1 (void)
11243 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
11245 char device[] = "/dev/sda";
11246 device[5] = devchar;
11248 suppress_error = 0;
11249 r = guestfs_blockdev_setrw (g, device);
11255 suppress_error = 0;
11256 r = guestfs_umount_all (g);
11262 suppress_error = 0;
11263 r = guestfs_lvm_remove_all (g);
11268 char device[] = "/dev/sda";
11269 device[5] = devchar;
11270 char lines_0[] = ",";
11276 suppress_error = 0;
11277 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11282 char fstype[] = "ext2";
11283 char device[] = "/dev/sda1";
11284 device[5] = devchar;
11286 suppress_error = 0;
11287 r = guestfs_mkfs (g, fstype, device);
11292 char device[] = "/dev/sda1";
11293 device[5] = devchar;
11294 char mountpoint[] = "/";
11296 suppress_error = 0;
11297 r = guestfs_mount (g, device, mountpoint);
11301 /* TestLastFail for mkdir (1) */
11303 char path[] = "/new/foo/bar";
11305 suppress_error = 1;
11306 r = guestfs_mkdir (g, path);
11313 static int test_rm_rf_0 (void)
11315 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
11317 char device[] = "/dev/sda";
11318 device[5] = devchar;
11320 suppress_error = 0;
11321 r = guestfs_blockdev_setrw (g, device);
11327 suppress_error = 0;
11328 r = guestfs_umount_all (g);
11334 suppress_error = 0;
11335 r = guestfs_lvm_remove_all (g);
11340 char device[] = "/dev/sda";
11341 device[5] = devchar;
11342 char lines_0[] = ",";
11348 suppress_error = 0;
11349 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11354 char fstype[] = "ext2";
11355 char device[] = "/dev/sda1";
11356 device[5] = devchar;
11358 suppress_error = 0;
11359 r = guestfs_mkfs (g, fstype, device);
11364 char device[] = "/dev/sda1";
11365 device[5] = devchar;
11366 char mountpoint[] = "/";
11368 suppress_error = 0;
11369 r = guestfs_mount (g, device, mountpoint);
11373 /* TestOutputFalse for rm_rf (0) */
11375 char path[] = "/new";
11377 suppress_error = 0;
11378 r = guestfs_mkdir (g, path);
11383 char path[] = "/new/foo";
11385 suppress_error = 0;
11386 r = guestfs_mkdir (g, path);
11391 char path[] = "/new/foo/bar";
11393 suppress_error = 0;
11394 r = guestfs_touch (g, path);
11399 char path[] = "/new";
11401 suppress_error = 0;
11402 r = guestfs_rm_rf (g, path);
11407 char path[] = "/new";
11409 suppress_error = 0;
11410 r = guestfs_exists (g, path);
11414 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
11421 static int test_rmdir_0 (void)
11423 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
11425 char device[] = "/dev/sda";
11426 device[5] = devchar;
11428 suppress_error = 0;
11429 r = guestfs_blockdev_setrw (g, device);
11435 suppress_error = 0;
11436 r = guestfs_umount_all (g);
11442 suppress_error = 0;
11443 r = guestfs_lvm_remove_all (g);
11448 char device[] = "/dev/sda";
11449 device[5] = devchar;
11450 char lines_0[] = ",";
11456 suppress_error = 0;
11457 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11462 char fstype[] = "ext2";
11463 char device[] = "/dev/sda1";
11464 device[5] = devchar;
11466 suppress_error = 0;
11467 r = guestfs_mkfs (g, fstype, device);
11472 char device[] = "/dev/sda1";
11473 device[5] = devchar;
11474 char mountpoint[] = "/";
11476 suppress_error = 0;
11477 r = guestfs_mount (g, device, mountpoint);
11481 /* TestRun for rmdir (0) */
11483 char path[] = "/new";
11485 suppress_error = 0;
11486 r = guestfs_mkdir (g, path);
11491 char path[] = "/new";
11493 suppress_error = 0;
11494 r = guestfs_rmdir (g, path);
11501 static int test_rmdir_1 (void)
11503 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11505 char device[] = "/dev/sda";
11506 device[5] = devchar;
11508 suppress_error = 0;
11509 r = guestfs_blockdev_setrw (g, device);
11515 suppress_error = 0;
11516 r = guestfs_umount_all (g);
11522 suppress_error = 0;
11523 r = guestfs_lvm_remove_all (g);
11528 char device[] = "/dev/sda";
11529 device[5] = devchar;
11530 char lines_0[] = ",";
11536 suppress_error = 0;
11537 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11542 char fstype[] = "ext2";
11543 char device[] = "/dev/sda1";
11544 device[5] = devchar;
11546 suppress_error = 0;
11547 r = guestfs_mkfs (g, fstype, device);
11552 char device[] = "/dev/sda1";
11553 device[5] = devchar;
11554 char mountpoint[] = "/";
11556 suppress_error = 0;
11557 r = guestfs_mount (g, device, mountpoint);
11561 /* TestLastFail for rmdir (1) */
11563 char path[] = "/new";
11565 suppress_error = 1;
11566 r = guestfs_rmdir (g, path);
11573 static int test_rmdir_2 (void)
11575 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11577 char device[] = "/dev/sda";
11578 device[5] = devchar;
11580 suppress_error = 0;
11581 r = guestfs_blockdev_setrw (g, device);
11587 suppress_error = 0;
11588 r = guestfs_umount_all (g);
11594 suppress_error = 0;
11595 r = guestfs_lvm_remove_all (g);
11600 char device[] = "/dev/sda";
11601 device[5] = devchar;
11602 char lines_0[] = ",";
11608 suppress_error = 0;
11609 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11614 char fstype[] = "ext2";
11615 char device[] = "/dev/sda1";
11616 device[5] = devchar;
11618 suppress_error = 0;
11619 r = guestfs_mkfs (g, fstype, device);
11624 char device[] = "/dev/sda1";
11625 device[5] = devchar;
11626 char mountpoint[] = "/";
11628 suppress_error = 0;
11629 r = guestfs_mount (g, device, mountpoint);
11633 /* TestLastFail for rmdir (2) */
11635 char path[] = "/new";
11637 suppress_error = 0;
11638 r = guestfs_touch (g, path);
11643 char path[] = "/new";
11645 suppress_error = 1;
11646 r = guestfs_rmdir (g, path);
11653 static int test_rm_0 (void)
11655 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11657 char device[] = "/dev/sda";
11658 device[5] = devchar;
11660 suppress_error = 0;
11661 r = guestfs_blockdev_setrw (g, device);
11667 suppress_error = 0;
11668 r = guestfs_umount_all (g);
11674 suppress_error = 0;
11675 r = guestfs_lvm_remove_all (g);
11680 char device[] = "/dev/sda";
11681 device[5] = devchar;
11682 char lines_0[] = ",";
11688 suppress_error = 0;
11689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11694 char fstype[] = "ext2";
11695 char device[] = "/dev/sda1";
11696 device[5] = devchar;
11698 suppress_error = 0;
11699 r = guestfs_mkfs (g, fstype, device);
11704 char device[] = "/dev/sda1";
11705 device[5] = devchar;
11706 char mountpoint[] = "/";
11708 suppress_error = 0;
11709 r = guestfs_mount (g, device, mountpoint);
11713 /* TestRun for rm (0) */
11715 char path[] = "/new";
11717 suppress_error = 0;
11718 r = guestfs_touch (g, path);
11723 char path[] = "/new";
11725 suppress_error = 0;
11726 r = guestfs_rm (g, path);
11733 static int test_rm_1 (void)
11735 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11737 char device[] = "/dev/sda";
11738 device[5] = devchar;
11740 suppress_error = 0;
11741 r = guestfs_blockdev_setrw (g, device);
11747 suppress_error = 0;
11748 r = guestfs_umount_all (g);
11754 suppress_error = 0;
11755 r = guestfs_lvm_remove_all (g);
11760 char device[] = "/dev/sda";
11761 device[5] = devchar;
11762 char lines_0[] = ",";
11768 suppress_error = 0;
11769 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11774 char fstype[] = "ext2";
11775 char device[] = "/dev/sda1";
11776 device[5] = devchar;
11778 suppress_error = 0;
11779 r = guestfs_mkfs (g, fstype, device);
11784 char device[] = "/dev/sda1";
11785 device[5] = devchar;
11786 char mountpoint[] = "/";
11788 suppress_error = 0;
11789 r = guestfs_mount (g, device, mountpoint);
11793 /* TestLastFail for rm (1) */
11795 char path[] = "/new";
11797 suppress_error = 1;
11798 r = guestfs_rm (g, path);
11805 static int test_rm_2 (void)
11807 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11809 char device[] = "/dev/sda";
11810 device[5] = devchar;
11812 suppress_error = 0;
11813 r = guestfs_blockdev_setrw (g, device);
11819 suppress_error = 0;
11820 r = guestfs_umount_all (g);
11826 suppress_error = 0;
11827 r = guestfs_lvm_remove_all (g);
11832 char device[] = "/dev/sda";
11833 device[5] = devchar;
11834 char lines_0[] = ",";
11840 suppress_error = 0;
11841 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11846 char fstype[] = "ext2";
11847 char device[] = "/dev/sda1";
11848 device[5] = devchar;
11850 suppress_error = 0;
11851 r = guestfs_mkfs (g, fstype, device);
11856 char device[] = "/dev/sda1";
11857 device[5] = devchar;
11858 char mountpoint[] = "/";
11860 suppress_error = 0;
11861 r = guestfs_mount (g, device, mountpoint);
11865 /* TestLastFail for rm (2) */
11867 char path[] = "/new";
11869 suppress_error = 0;
11870 r = guestfs_mkdir (g, path);
11875 char path[] = "/new";
11877 suppress_error = 1;
11878 r = guestfs_rm (g, path);
11885 static int test_read_lines_0 (void)
11887 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11889 char device[] = "/dev/sda";
11890 device[5] = devchar;
11892 suppress_error = 0;
11893 r = guestfs_blockdev_setrw (g, device);
11899 suppress_error = 0;
11900 r = guestfs_umount_all (g);
11906 suppress_error = 0;
11907 r = guestfs_lvm_remove_all (g);
11912 char device[] = "/dev/sda";
11913 device[5] = devchar;
11914 char lines_0[] = ",";
11920 suppress_error = 0;
11921 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11926 char fstype[] = "ext2";
11927 char device[] = "/dev/sda1";
11928 device[5] = devchar;
11930 suppress_error = 0;
11931 r = guestfs_mkfs (g, fstype, device);
11936 char device[] = "/dev/sda1";
11937 device[5] = devchar;
11938 char mountpoint[] = "/";
11940 suppress_error = 0;
11941 r = guestfs_mount (g, device, mountpoint);
11945 /* TestOutputList for read_lines (0) */
11947 char path[] = "/new";
11948 char content[] = "line1\r\nline2\nline3";
11950 suppress_error = 0;
11951 r = guestfs_write_file (g, path, content, 0);
11956 char path[] = "/new";
11959 suppress_error = 0;
11960 r = guestfs_read_lines (g, path);
11964 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11969 char expected[] = "line1";
11970 if (strcmp (r[0], expected) != 0) {
11971 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11976 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11981 char expected[] = "line2";
11982 if (strcmp (r[1], expected) != 0) {
11983 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11988 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11993 char expected[] = "line3";
11994 if (strcmp (r[2], expected) != 0) {
11995 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11999 if (r[3] != NULL) {
12000 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
12004 for (i = 0; r[i] != NULL; ++i)
12011 static int test_read_lines_1 (void)
12013 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
12015 char device[] = "/dev/sda";
12016 device[5] = devchar;
12018 suppress_error = 0;
12019 r = guestfs_blockdev_setrw (g, device);
12025 suppress_error = 0;
12026 r = guestfs_umount_all (g);
12032 suppress_error = 0;
12033 r = guestfs_lvm_remove_all (g);
12038 char device[] = "/dev/sda";
12039 device[5] = devchar;
12040 char lines_0[] = ",";
12046 suppress_error = 0;
12047 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12052 char fstype[] = "ext2";
12053 char device[] = "/dev/sda1";
12054 device[5] = devchar;
12056 suppress_error = 0;
12057 r = guestfs_mkfs (g, fstype, device);
12062 char device[] = "/dev/sda1";
12063 device[5] = devchar;
12064 char mountpoint[] = "/";
12066 suppress_error = 0;
12067 r = guestfs_mount (g, device, mountpoint);
12071 /* TestOutputList for read_lines (1) */
12073 char path[] = "/new";
12074 char content[] = "";
12076 suppress_error = 0;
12077 r = guestfs_write_file (g, path, content, 0);
12082 char path[] = "/new";
12085 suppress_error = 0;
12086 r = guestfs_read_lines (g, path);
12089 if (r[0] != NULL) {
12090 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
12094 for (i = 0; r[i] != NULL; ++i)
12101 static int test_lvs_0 (void)
12103 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
12105 char device[] = "/dev/sda";
12106 device[5] = devchar;
12108 suppress_error = 0;
12109 r = guestfs_blockdev_setrw (g, device);
12115 suppress_error = 0;
12116 r = guestfs_umount_all (g);
12122 suppress_error = 0;
12123 r = guestfs_lvm_remove_all (g);
12128 char device[] = "/dev/sda";
12129 device[5] = devchar;
12130 char lines_0[] = ",";
12136 suppress_error = 0;
12137 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12142 char device[] = "/dev/sda1";
12143 device[5] = devchar;
12145 suppress_error = 0;
12146 r = guestfs_pvcreate (g, device);
12151 char volgroup[] = "VG";
12152 char physvols_0[] = "/dev/sda1";
12153 physvols_0[5] = devchar;
12154 char *physvols[] = {
12159 suppress_error = 0;
12160 r = guestfs_vgcreate (g, volgroup, physvols);
12165 char logvol[] = "LV";
12166 char volgroup[] = "VG";
12168 suppress_error = 0;
12169 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12174 char fstype[] = "ext2";
12175 char device[] = "/dev/VG/LV";
12177 suppress_error = 0;
12178 r = guestfs_mkfs (g, fstype, device);
12183 char device[] = "/dev/VG/LV";
12184 char mountpoint[] = "/";
12186 suppress_error = 0;
12187 r = guestfs_mount (g, device, mountpoint);
12191 /* TestOutputList for lvs (0) */
12195 suppress_error = 0;
12196 r = guestfs_lvs (g);
12200 fprintf (stderr, "test_lvs_0: short list returned from command\n");
12205 char expected[] = "/dev/VG/LV";
12206 if (strcmp (r[0], expected) != 0) {
12207 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12211 if (r[1] != NULL) {
12212 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
12216 for (i = 0; r[i] != NULL; ++i)
12223 static int test_lvs_1 (void)
12225 /* InitNone|InitEmpty for test_lvs_1 */
12227 char device[] = "/dev/sda";
12228 device[5] = devchar;
12230 suppress_error = 0;
12231 r = guestfs_blockdev_setrw (g, device);
12237 suppress_error = 0;
12238 r = guestfs_umount_all (g);
12244 suppress_error = 0;
12245 r = guestfs_lvm_remove_all (g);
12249 /* TestOutputList for lvs (1) */
12251 char device[] = "/dev/sda";
12252 device[5] = devchar;
12253 char lines_0[] = ",10";
12254 char lines_1[] = ",20";
12255 char lines_2[] = ",";
12263 suppress_error = 0;
12264 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12269 char device[] = "/dev/sda1";
12270 device[5] = devchar;
12272 suppress_error = 0;
12273 r = guestfs_pvcreate (g, device);
12278 char device[] = "/dev/sda2";
12279 device[5] = devchar;
12281 suppress_error = 0;
12282 r = guestfs_pvcreate (g, device);
12287 char device[] = "/dev/sda3";
12288 device[5] = devchar;
12290 suppress_error = 0;
12291 r = guestfs_pvcreate (g, device);
12296 char volgroup[] = "VG1";
12297 char physvols_0[] = "/dev/sda1";
12298 physvols_0[5] = devchar;
12299 char physvols_1[] = "/dev/sda2";
12300 physvols_1[5] = devchar;
12301 char *physvols[] = {
12307 suppress_error = 0;
12308 r = guestfs_vgcreate (g, volgroup, physvols);
12313 char volgroup[] = "VG2";
12314 char physvols_0[] = "/dev/sda3";
12315 physvols_0[5] = devchar;
12316 char *physvols[] = {
12321 suppress_error = 0;
12322 r = guestfs_vgcreate (g, volgroup, physvols);
12327 char logvol[] = "LV1";
12328 char volgroup[] = "VG1";
12330 suppress_error = 0;
12331 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12336 char logvol[] = "LV2";
12337 char volgroup[] = "VG1";
12339 suppress_error = 0;
12340 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12345 char logvol[] = "LV3";
12346 char volgroup[] = "VG2";
12348 suppress_error = 0;
12349 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12356 suppress_error = 0;
12357 r = guestfs_lvs (g);
12361 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12366 char expected[] = "/dev/VG1/LV1";
12367 if (strcmp (r[0], expected) != 0) {
12368 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12373 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12378 char expected[] = "/dev/VG1/LV2";
12379 if (strcmp (r[1], expected) != 0) {
12380 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12385 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12390 char expected[] = "/dev/VG2/LV3";
12391 if (strcmp (r[2], expected) != 0) {
12392 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12396 if (r[3] != NULL) {
12397 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
12401 for (i = 0; r[i] != NULL; ++i)
12408 static int test_vgs_0 (void)
12410 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
12412 char device[] = "/dev/sda";
12413 device[5] = devchar;
12415 suppress_error = 0;
12416 r = guestfs_blockdev_setrw (g, device);
12422 suppress_error = 0;
12423 r = guestfs_umount_all (g);
12429 suppress_error = 0;
12430 r = guestfs_lvm_remove_all (g);
12435 char device[] = "/dev/sda";
12436 device[5] = devchar;
12437 char lines_0[] = ",";
12443 suppress_error = 0;
12444 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12449 char device[] = "/dev/sda1";
12450 device[5] = devchar;
12452 suppress_error = 0;
12453 r = guestfs_pvcreate (g, device);
12458 char volgroup[] = "VG";
12459 char physvols_0[] = "/dev/sda1";
12460 physvols_0[5] = devchar;
12461 char *physvols[] = {
12466 suppress_error = 0;
12467 r = guestfs_vgcreate (g, volgroup, physvols);
12472 char logvol[] = "LV";
12473 char volgroup[] = "VG";
12475 suppress_error = 0;
12476 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12481 char fstype[] = "ext2";
12482 char device[] = "/dev/VG/LV";
12484 suppress_error = 0;
12485 r = guestfs_mkfs (g, fstype, device);
12490 char device[] = "/dev/VG/LV";
12491 char mountpoint[] = "/";
12493 suppress_error = 0;
12494 r = guestfs_mount (g, device, mountpoint);
12498 /* TestOutputList for vgs (0) */
12502 suppress_error = 0;
12503 r = guestfs_vgs (g);
12507 fprintf (stderr, "test_vgs_0: short list returned from command\n");
12512 char expected[] = "VG";
12513 if (strcmp (r[0], expected) != 0) {
12514 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12518 if (r[1] != NULL) {
12519 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12523 for (i = 0; r[i] != NULL; ++i)
12530 static int test_vgs_1 (void)
12532 /* InitNone|InitEmpty for test_vgs_1 */
12534 char device[] = "/dev/sda";
12535 device[5] = devchar;
12537 suppress_error = 0;
12538 r = guestfs_blockdev_setrw (g, device);
12544 suppress_error = 0;
12545 r = guestfs_umount_all (g);
12551 suppress_error = 0;
12552 r = guestfs_lvm_remove_all (g);
12556 /* TestOutputList for vgs (1) */
12558 char device[] = "/dev/sda";
12559 device[5] = devchar;
12560 char lines_0[] = ",10";
12561 char lines_1[] = ",20";
12562 char lines_2[] = ",";
12570 suppress_error = 0;
12571 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12576 char device[] = "/dev/sda1";
12577 device[5] = devchar;
12579 suppress_error = 0;
12580 r = guestfs_pvcreate (g, device);
12585 char device[] = "/dev/sda2";
12586 device[5] = devchar;
12588 suppress_error = 0;
12589 r = guestfs_pvcreate (g, device);
12594 char device[] = "/dev/sda3";
12595 device[5] = devchar;
12597 suppress_error = 0;
12598 r = guestfs_pvcreate (g, device);
12603 char volgroup[] = "VG1";
12604 char physvols_0[] = "/dev/sda1";
12605 physvols_0[5] = devchar;
12606 char physvols_1[] = "/dev/sda2";
12607 physvols_1[5] = devchar;
12608 char *physvols[] = {
12614 suppress_error = 0;
12615 r = guestfs_vgcreate (g, volgroup, physvols);
12620 char volgroup[] = "VG2";
12621 char physvols_0[] = "/dev/sda3";
12622 physvols_0[5] = devchar;
12623 char *physvols[] = {
12628 suppress_error = 0;
12629 r = guestfs_vgcreate (g, volgroup, physvols);
12636 suppress_error = 0;
12637 r = guestfs_vgs (g);
12641 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12646 char expected[] = "VG1";
12647 if (strcmp (r[0], expected) != 0) {
12648 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12653 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12658 char expected[] = "VG2";
12659 if (strcmp (r[1], expected) != 0) {
12660 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12664 if (r[2] != NULL) {
12665 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12669 for (i = 0; r[i] != NULL; ++i)
12676 static int test_pvs_0 (void)
12678 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12680 char device[] = "/dev/sda";
12681 device[5] = devchar;
12683 suppress_error = 0;
12684 r = guestfs_blockdev_setrw (g, device);
12690 suppress_error = 0;
12691 r = guestfs_umount_all (g);
12697 suppress_error = 0;
12698 r = guestfs_lvm_remove_all (g);
12703 char device[] = "/dev/sda";
12704 device[5] = devchar;
12705 char lines_0[] = ",";
12711 suppress_error = 0;
12712 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12717 char device[] = "/dev/sda1";
12718 device[5] = devchar;
12720 suppress_error = 0;
12721 r = guestfs_pvcreate (g, device);
12726 char volgroup[] = "VG";
12727 char physvols_0[] = "/dev/sda1";
12728 physvols_0[5] = devchar;
12729 char *physvols[] = {
12734 suppress_error = 0;
12735 r = guestfs_vgcreate (g, volgroup, physvols);
12740 char logvol[] = "LV";
12741 char volgroup[] = "VG";
12743 suppress_error = 0;
12744 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12749 char fstype[] = "ext2";
12750 char device[] = "/dev/VG/LV";
12752 suppress_error = 0;
12753 r = guestfs_mkfs (g, fstype, device);
12758 char device[] = "/dev/VG/LV";
12759 char mountpoint[] = "/";
12761 suppress_error = 0;
12762 r = guestfs_mount (g, device, mountpoint);
12766 /* TestOutputList for pvs (0) */
12770 suppress_error = 0;
12771 r = guestfs_pvs (g);
12775 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12780 char expected[] = "/dev/sda1";
12781 expected[5] = devchar;
12782 if (strcmp (r[0], expected) != 0) {
12783 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12787 if (r[1] != NULL) {
12788 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12792 for (i = 0; r[i] != NULL; ++i)
12799 static int test_pvs_1 (void)
12801 /* InitNone|InitEmpty for test_pvs_1 */
12803 char device[] = "/dev/sda";
12804 device[5] = devchar;
12806 suppress_error = 0;
12807 r = guestfs_blockdev_setrw (g, device);
12813 suppress_error = 0;
12814 r = guestfs_umount_all (g);
12820 suppress_error = 0;
12821 r = guestfs_lvm_remove_all (g);
12825 /* TestOutputList for pvs (1) */
12827 char device[] = "/dev/sda";
12828 device[5] = devchar;
12829 char lines_0[] = ",10";
12830 char lines_1[] = ",20";
12831 char lines_2[] = ",";
12839 suppress_error = 0;
12840 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12845 char device[] = "/dev/sda1";
12846 device[5] = devchar;
12848 suppress_error = 0;
12849 r = guestfs_pvcreate (g, device);
12854 char device[] = "/dev/sda2";
12855 device[5] = devchar;
12857 suppress_error = 0;
12858 r = guestfs_pvcreate (g, device);
12863 char device[] = "/dev/sda3";
12864 device[5] = devchar;
12866 suppress_error = 0;
12867 r = guestfs_pvcreate (g, device);
12874 suppress_error = 0;
12875 r = guestfs_pvs (g);
12879 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12884 char expected[] = "/dev/sda1";
12885 expected[5] = devchar;
12886 if (strcmp (r[0], expected) != 0) {
12887 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12892 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12897 char expected[] = "/dev/sda2";
12898 expected[5] = devchar;
12899 if (strcmp (r[1], expected) != 0) {
12900 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12905 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12910 char expected[] = "/dev/sda3";
12911 expected[5] = devchar;
12912 if (strcmp (r[2], expected) != 0) {
12913 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12917 if (r[3] != NULL) {
12918 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12922 for (i = 0; r[i] != NULL; ++i)
12929 static int test_list_partitions_0 (void)
12931 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12933 char device[] = "/dev/sda";
12934 device[5] = devchar;
12936 suppress_error = 0;
12937 r = guestfs_blockdev_setrw (g, device);
12943 suppress_error = 0;
12944 r = guestfs_umount_all (g);
12950 suppress_error = 0;
12951 r = guestfs_lvm_remove_all (g);
12956 char device[] = "/dev/sda";
12957 device[5] = devchar;
12958 char lines_0[] = ",";
12964 suppress_error = 0;
12965 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12970 char fstype[] = "ext2";
12971 char device[] = "/dev/sda1";
12972 device[5] = devchar;
12974 suppress_error = 0;
12975 r = guestfs_mkfs (g, fstype, device);
12980 char device[] = "/dev/sda1";
12981 device[5] = devchar;
12982 char mountpoint[] = "/";
12984 suppress_error = 0;
12985 r = guestfs_mount (g, device, mountpoint);
12989 /* TestOutputList for list_partitions (0) */
12993 suppress_error = 0;
12994 r = guestfs_list_partitions (g);
12998 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
13003 char expected[] = "/dev/sda1";
13004 expected[5] = devchar;
13005 if (strcmp (r[0], expected) != 0) {
13006 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13010 if (r[1] != NULL) {
13011 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
13015 for (i = 0; r[i] != NULL; ++i)
13022 static int test_list_partitions_1 (void)
13024 /* InitNone|InitEmpty for test_list_partitions_1 */
13026 char device[] = "/dev/sda";
13027 device[5] = devchar;
13029 suppress_error = 0;
13030 r = guestfs_blockdev_setrw (g, device);
13036 suppress_error = 0;
13037 r = guestfs_umount_all (g);
13043 suppress_error = 0;
13044 r = guestfs_lvm_remove_all (g);
13048 /* TestOutputList for list_partitions (1) */
13050 char device[] = "/dev/sda";
13051 device[5] = devchar;
13052 char lines_0[] = ",10";
13053 char lines_1[] = ",20";
13054 char lines_2[] = ",";
13062 suppress_error = 0;
13063 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13070 suppress_error = 0;
13071 r = guestfs_list_partitions (g);
13075 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13080 char expected[] = "/dev/sda1";
13081 expected[5] = devchar;
13082 if (strcmp (r[0], expected) != 0) {
13083 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13088 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13093 char expected[] = "/dev/sda2";
13094 expected[5] = devchar;
13095 if (strcmp (r[1], expected) != 0) {
13096 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13101 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
13106 char expected[] = "/dev/sda3";
13107 expected[5] = devchar;
13108 if (strcmp (r[2], expected) != 0) {
13109 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13113 if (r[3] != NULL) {
13114 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
13118 for (i = 0; r[i] != NULL; ++i)
13125 static int test_list_devices_0 (void)
13127 /* InitNone|InitEmpty for test_list_devices_0 */
13129 char device[] = "/dev/sda";
13130 device[5] = devchar;
13132 suppress_error = 0;
13133 r = guestfs_blockdev_setrw (g, device);
13139 suppress_error = 0;
13140 r = guestfs_umount_all (g);
13146 suppress_error = 0;
13147 r = guestfs_lvm_remove_all (g);
13151 /* TestOutputList for list_devices (0) */
13155 suppress_error = 0;
13156 r = guestfs_list_devices (g);
13160 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13165 char expected[] = "/dev/sda";
13166 expected[5] = devchar;
13167 if (strcmp (r[0], expected) != 0) {
13168 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13173 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13178 char expected[] = "/dev/sdb";
13179 expected[5] = devchar;
13180 if (strcmp (r[1], expected) != 0) {
13181 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13186 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13191 char expected[] = "/dev/sdc";
13192 expected[5] = devchar;
13193 if (strcmp (r[2], expected) != 0) {
13194 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13198 if (r[3] != NULL) {
13199 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
13203 for (i = 0; r[i] != NULL; ++i)
13210 static int test_ls_0 (void)
13212 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
13214 char device[] = "/dev/sda";
13215 device[5] = devchar;
13217 suppress_error = 0;
13218 r = guestfs_blockdev_setrw (g, device);
13224 suppress_error = 0;
13225 r = guestfs_umount_all (g);
13231 suppress_error = 0;
13232 r = guestfs_lvm_remove_all (g);
13237 char device[] = "/dev/sda";
13238 device[5] = devchar;
13239 char lines_0[] = ",";
13245 suppress_error = 0;
13246 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13251 char fstype[] = "ext2";
13252 char device[] = "/dev/sda1";
13253 device[5] = devchar;
13255 suppress_error = 0;
13256 r = guestfs_mkfs (g, fstype, device);
13261 char device[] = "/dev/sda1";
13262 device[5] = devchar;
13263 char mountpoint[] = "/";
13265 suppress_error = 0;
13266 r = guestfs_mount (g, device, mountpoint);
13270 /* TestOutputList for ls (0) */
13272 char path[] = "/new";
13274 suppress_error = 0;
13275 r = guestfs_touch (g, path);
13280 char path[] = "/newer";
13282 suppress_error = 0;
13283 r = guestfs_touch (g, path);
13288 char path[] = "/newest";
13290 suppress_error = 0;
13291 r = guestfs_touch (g, path);
13296 char directory[] = "/";
13299 suppress_error = 0;
13300 r = guestfs_ls (g, directory);
13304 fprintf (stderr, "test_ls_0: short list returned from command\n");
13309 char expected[] = "lost+found";
13310 if (strcmp (r[0], expected) != 0) {
13311 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13316 fprintf (stderr, "test_ls_0: short list returned from command\n");
13321 char expected[] = "new";
13322 if (strcmp (r[1], expected) != 0) {
13323 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13328 fprintf (stderr, "test_ls_0: short list returned from command\n");
13333 char expected[] = "newer";
13334 if (strcmp (r[2], expected) != 0) {
13335 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13340 fprintf (stderr, "test_ls_0: short list returned from command\n");
13345 char expected[] = "newest";
13346 if (strcmp (r[3], expected) != 0) {
13347 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
13351 if (r[4] != NULL) {
13352 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
13356 for (i = 0; r[i] != NULL; ++i)
13363 static int test_cat_0 (void)
13365 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
13367 char device[] = "/dev/sda";
13368 device[5] = devchar;
13370 suppress_error = 0;
13371 r = guestfs_blockdev_setrw (g, device);
13377 suppress_error = 0;
13378 r = guestfs_umount_all (g);
13384 suppress_error = 0;
13385 r = guestfs_lvm_remove_all (g);
13390 char device[] = "/dev/sda";
13391 device[5] = devchar;
13392 char lines_0[] = ",";
13398 suppress_error = 0;
13399 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13404 char fstype[] = "ext2";
13405 char device[] = "/dev/sda1";
13406 device[5] = devchar;
13408 suppress_error = 0;
13409 r = guestfs_mkfs (g, fstype, device);
13414 char device[] = "/dev/sda1";
13415 device[5] = devchar;
13416 char mountpoint[] = "/";
13418 suppress_error = 0;
13419 r = guestfs_mount (g, device, mountpoint);
13423 /* TestOutput for cat (0) */
13424 char expected[] = "new file contents";
13426 char path[] = "/new";
13427 char content[] = "new file contents";
13429 suppress_error = 0;
13430 r = guestfs_write_file (g, path, content, 0);
13435 char path[] = "/new";
13437 suppress_error = 0;
13438 r = guestfs_cat (g, path);
13441 if (strcmp (r, expected) != 0) {
13442 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
13450 static int test_touch_0 (void)
13452 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
13454 char device[] = "/dev/sda";
13455 device[5] = devchar;
13457 suppress_error = 0;
13458 r = guestfs_blockdev_setrw (g, device);
13464 suppress_error = 0;
13465 r = guestfs_umount_all (g);
13471 suppress_error = 0;
13472 r = guestfs_lvm_remove_all (g);
13477 char device[] = "/dev/sda";
13478 device[5] = devchar;
13479 char lines_0[] = ",";
13485 suppress_error = 0;
13486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13491 char fstype[] = "ext2";
13492 char device[] = "/dev/sda1";
13493 device[5] = devchar;
13495 suppress_error = 0;
13496 r = guestfs_mkfs (g, fstype, device);
13501 char device[] = "/dev/sda1";
13502 device[5] = devchar;
13503 char mountpoint[] = "/";
13505 suppress_error = 0;
13506 r = guestfs_mount (g, device, mountpoint);
13510 /* TestOutputTrue for touch (0) */
13512 char path[] = "/new";
13514 suppress_error = 0;
13515 r = guestfs_touch (g, path);
13520 char path[] = "/new";
13522 suppress_error = 0;
13523 r = guestfs_exists (g, path);
13527 fprintf (stderr, "test_touch_0: expected true, got false\n");
13534 static int test_sync_0 (void)
13536 /* InitNone|InitEmpty for test_sync_0 */
13538 char device[] = "/dev/sda";
13539 device[5] = devchar;
13541 suppress_error = 0;
13542 r = guestfs_blockdev_setrw (g, device);
13548 suppress_error = 0;
13549 r = guestfs_umount_all (g);
13555 suppress_error = 0;
13556 r = guestfs_lvm_remove_all (g);
13560 /* TestRun for sync (0) */
13563 suppress_error = 0;
13564 r = guestfs_sync (g);
13571 static int test_mount_0 (void)
13573 /* InitNone|InitEmpty for test_mount_0 */
13575 char device[] = "/dev/sda";
13576 device[5] = devchar;
13578 suppress_error = 0;
13579 r = guestfs_blockdev_setrw (g, device);
13585 suppress_error = 0;
13586 r = guestfs_umount_all (g);
13592 suppress_error = 0;
13593 r = guestfs_lvm_remove_all (g);
13597 /* TestOutput for mount (0) */
13598 char expected[] = "new file contents";
13600 char device[] = "/dev/sda";
13601 device[5] = devchar;
13602 char lines_0[] = ",";
13608 suppress_error = 0;
13609 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13614 char fstype[] = "ext2";
13615 char device[] = "/dev/sda1";
13616 device[5] = devchar;
13618 suppress_error = 0;
13619 r = guestfs_mkfs (g, fstype, device);
13624 char device[] = "/dev/sda1";
13625 device[5] = devchar;
13626 char mountpoint[] = "/";
13628 suppress_error = 0;
13629 r = guestfs_mount (g, device, mountpoint);
13634 char path[] = "/new";
13635 char content[] = "new file contents";
13637 suppress_error = 0;
13638 r = guestfs_write_file (g, path, content, 0);
13643 char path[] = "/new";
13645 suppress_error = 0;
13646 r = guestfs_cat (g, path);
13649 if (strcmp (r, expected) != 0) {
13650 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13658 int main (int argc, char *argv[])
13662 const char *srcdir;
13663 const char *filename;
13665 int nr_tests, test_num = 0;
13668 no_test_warnings ();
13670 g = guestfs_create ();
13672 printf ("guestfs_create FAILED\n");
13676 guestfs_set_error_handler (g, print_error, NULL);
13678 srcdir = getenv ("srcdir");
13679 if (!srcdir) srcdir = ".";
13681 guestfs_set_path (g, ".");
13683 filename = "test1.img";
13684 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13689 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13695 if (write (fd, &c, 1) == -1) {
13701 if (close (fd) == -1) {
13706 if (guestfs_add_drive (g, filename) == -1) {
13707 printf ("guestfs_add_drive %s FAILED\n", filename);
13711 filename = "test2.img";
13712 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13717 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13723 if (write (fd, &c, 1) == -1) {
13729 if (close (fd) == -1) {
13734 if (guestfs_add_drive (g, filename) == -1) {
13735 printf ("guestfs_add_drive %s FAILED\n", filename);
13739 filename = "test3.img";
13740 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13745 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13751 if (write (fd, &c, 1) == -1) {
13757 if (close (fd) == -1) {
13762 if (guestfs_add_drive (g, filename) == -1) {
13763 printf ("guestfs_add_drive %s FAILED\n", filename);
13767 if (guestfs_launch (g) == -1) {
13768 printf ("guestfs_launch FAILED\n");
13771 if (guestfs_wait_ready (g) == -1) {
13772 printf ("guestfs_wait_ready FAILED\n");
13776 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13777 * names. This changed between RHEL 5 and RHEL 6 so we have to
13780 devs = guestfs_list_devices (g);
13781 if (devs == NULL || devs[0] == NULL) {
13782 printf ("guestfs_list_devices FAILED\n");
13785 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13787 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13790 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13794 for (i = 0; devs[i] != NULL; ++i)
13801 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
13802 if (test_find_0 () == -1) {
13803 printf ("test_find_0 FAILED\n");
13807 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
13808 if (test_find_1 () == -1) {
13809 printf ("test_find_1 FAILED\n");
13813 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
13814 if (test_find_2 () == -1) {
13815 printf ("test_find_2 FAILED\n");
13819 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13820 if (test_lvresize_0 () == -1) {
13821 printf ("test_lvresize_0 FAILED\n");
13825 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13826 if (test_zerofree_0 () == -1) {
13827 printf ("test_zerofree_0 FAILED\n");
13831 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13832 if (test_hexdump_0 () == -1) {
13833 printf ("test_hexdump_0 FAILED\n");
13837 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13838 if (test_strings_e_0 () == -1) {
13839 printf ("test_strings_e_0 FAILED\n");
13843 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13844 if (test_strings_e_1 () == -1) {
13845 printf ("test_strings_e_1 FAILED\n");
13849 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13850 if (test_strings_0 () == -1) {
13851 printf ("test_strings_0 FAILED\n");
13855 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13856 if (test_strings_1 () == -1) {
13857 printf ("test_strings_1 FAILED\n");
13861 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13862 if (test_equal_0 () == -1) {
13863 printf ("test_equal_0 FAILED\n");
13867 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13868 if (test_equal_1 () == -1) {
13869 printf ("test_equal_1 FAILED\n");
13873 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13874 if (test_equal_2 () == -1) {
13875 printf ("test_equal_2 FAILED\n");
13879 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13880 if (test_ping_daemon_0 () == -1) {
13881 printf ("test_ping_daemon_0 FAILED\n");
13885 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13886 if (test_dmesg_0 () == -1) {
13887 printf ("test_dmesg_0 FAILED\n");
13891 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13892 if (test_drop_caches_0 () == -1) {
13893 printf ("test_drop_caches_0 FAILED\n");
13897 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13898 if (test_mv_0 () == -1) {
13899 printf ("test_mv_0 FAILED\n");
13903 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13904 if (test_mv_1 () == -1) {
13905 printf ("test_mv_1 FAILED\n");
13909 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13910 if (test_cp_a_0 () == -1) {
13911 printf ("test_cp_a_0 FAILED\n");
13915 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13916 if (test_cp_0 () == -1) {
13917 printf ("test_cp_0 FAILED\n");
13921 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13922 if (test_cp_1 () == -1) {
13923 printf ("test_cp_1 FAILED\n");
13927 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13928 if (test_cp_2 () == -1) {
13929 printf ("test_cp_2 FAILED\n");
13933 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13934 if (test_grub_install_0 () == -1) {
13935 printf ("test_grub_install_0 FAILED\n");
13939 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13940 if (test_zero_0 () == -1) {
13941 printf ("test_zero_0 FAILED\n");
13945 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13946 if (test_fsck_0 () == -1) {
13947 printf ("test_fsck_0 FAILED\n");
13951 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13952 if (test_fsck_1 () == -1) {
13953 printf ("test_fsck_1 FAILED\n");
13957 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13958 if (test_set_e2uuid_0 () == -1) {
13959 printf ("test_set_e2uuid_0 FAILED\n");
13963 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13964 if (test_set_e2uuid_1 () == -1) {
13965 printf ("test_set_e2uuid_1 FAILED\n");
13969 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13970 if (test_set_e2uuid_2 () == -1) {
13971 printf ("test_set_e2uuid_2 FAILED\n");
13975 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13976 if (test_set_e2uuid_3 () == -1) {
13977 printf ("test_set_e2uuid_3 FAILED\n");
13981 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13982 if (test_set_e2label_0 () == -1) {
13983 printf ("test_set_e2label_0 FAILED\n");
13987 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13988 if (test_pvremove_0 () == -1) {
13989 printf ("test_pvremove_0 FAILED\n");
13993 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13994 if (test_pvremove_1 () == -1) {
13995 printf ("test_pvremove_1 FAILED\n");
13999 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
14000 if (test_pvremove_2 () == -1) {
14001 printf ("test_pvremove_2 FAILED\n");
14005 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
14006 if (test_vgremove_0 () == -1) {
14007 printf ("test_vgremove_0 FAILED\n");
14011 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
14012 if (test_vgremove_1 () == -1) {
14013 printf ("test_vgremove_1 FAILED\n");
14017 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
14018 if (test_lvremove_0 () == -1) {
14019 printf ("test_lvremove_0 FAILED\n");
14023 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
14024 if (test_lvremove_1 () == -1) {
14025 printf ("test_lvremove_1 FAILED\n");
14029 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
14030 if (test_lvremove_2 () == -1) {
14031 printf ("test_lvremove_2 FAILED\n");
14035 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
14036 if (test_mount_ro_0 () == -1) {
14037 printf ("test_mount_ro_0 FAILED\n");
14041 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
14042 if (test_mount_ro_1 () == -1) {
14043 printf ("test_mount_ro_1 FAILED\n");
14047 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
14048 if (test_tgz_in_0 () == -1) {
14049 printf ("test_tgz_in_0 FAILED\n");
14053 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
14054 if (test_tar_in_0 () == -1) {
14055 printf ("test_tar_in_0 FAILED\n");
14059 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
14060 if (test_checksum_0 () == -1) {
14061 printf ("test_checksum_0 FAILED\n");
14065 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
14066 if (test_checksum_1 () == -1) {
14067 printf ("test_checksum_1 FAILED\n");
14071 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
14072 if (test_checksum_2 () == -1) {
14073 printf ("test_checksum_2 FAILED\n");
14077 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
14078 if (test_checksum_3 () == -1) {
14079 printf ("test_checksum_3 FAILED\n");
14083 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
14084 if (test_checksum_4 () == -1) {
14085 printf ("test_checksum_4 FAILED\n");
14089 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
14090 if (test_checksum_5 () == -1) {
14091 printf ("test_checksum_5 FAILED\n");
14095 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
14096 if (test_checksum_6 () == -1) {
14097 printf ("test_checksum_6 FAILED\n");
14101 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
14102 if (test_checksum_7 () == -1) {
14103 printf ("test_checksum_7 FAILED\n");
14107 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
14108 if (test_download_0 () == -1) {
14109 printf ("test_download_0 FAILED\n");
14113 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
14114 if (test_upload_0 () == -1) {
14115 printf ("test_upload_0 FAILED\n");
14119 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
14120 if (test_blockdev_rereadpt_0 () == -1) {
14121 printf ("test_blockdev_rereadpt_0 FAILED\n");
14125 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
14126 if (test_blockdev_flushbufs_0 () == -1) {
14127 printf ("test_blockdev_flushbufs_0 FAILED\n");
14131 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
14132 if (test_blockdev_getsize64_0 () == -1) {
14133 printf ("test_blockdev_getsize64_0 FAILED\n");
14137 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
14138 if (test_blockdev_getsz_0 () == -1) {
14139 printf ("test_blockdev_getsz_0 FAILED\n");
14143 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
14144 if (test_blockdev_getbsz_0 () == -1) {
14145 printf ("test_blockdev_getbsz_0 FAILED\n");
14149 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
14150 if (test_blockdev_getss_0 () == -1) {
14151 printf ("test_blockdev_getss_0 FAILED\n");
14155 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
14156 if (test_blockdev_getro_0 () == -1) {
14157 printf ("test_blockdev_getro_0 FAILED\n");
14161 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
14162 if (test_blockdev_setrw_0 () == -1) {
14163 printf ("test_blockdev_setrw_0 FAILED\n");
14167 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
14168 if (test_blockdev_setro_0 () == -1) {
14169 printf ("test_blockdev_setro_0 FAILED\n");
14173 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
14174 if (test_statvfs_0 () == -1) {
14175 printf ("test_statvfs_0 FAILED\n");
14179 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
14180 if (test_lstat_0 () == -1) {
14181 printf ("test_lstat_0 FAILED\n");
14185 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
14186 if (test_stat_0 () == -1) {
14187 printf ("test_stat_0 FAILED\n");
14191 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
14192 if (test_command_lines_0 () == -1) {
14193 printf ("test_command_lines_0 FAILED\n");
14197 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
14198 if (test_command_lines_1 () == -1) {
14199 printf ("test_command_lines_1 FAILED\n");
14203 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
14204 if (test_command_lines_2 () == -1) {
14205 printf ("test_command_lines_2 FAILED\n");
14209 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
14210 if (test_command_lines_3 () == -1) {
14211 printf ("test_command_lines_3 FAILED\n");
14215 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
14216 if (test_command_lines_4 () == -1) {
14217 printf ("test_command_lines_4 FAILED\n");
14221 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
14222 if (test_command_lines_5 () == -1) {
14223 printf ("test_command_lines_5 FAILED\n");
14227 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
14228 if (test_command_lines_6 () == -1) {
14229 printf ("test_command_lines_6 FAILED\n");
14233 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
14234 if (test_command_lines_7 () == -1) {
14235 printf ("test_command_lines_7 FAILED\n");
14239 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
14240 if (test_command_lines_8 () == -1) {
14241 printf ("test_command_lines_8 FAILED\n");
14245 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
14246 if (test_command_lines_9 () == -1) {
14247 printf ("test_command_lines_9 FAILED\n");
14251 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
14252 if (test_command_lines_10 () == -1) {
14253 printf ("test_command_lines_10 FAILED\n");
14257 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
14258 if (test_command_0 () == -1) {
14259 printf ("test_command_0 FAILED\n");
14263 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
14264 if (test_command_1 () == -1) {
14265 printf ("test_command_1 FAILED\n");
14269 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
14270 if (test_command_2 () == -1) {
14271 printf ("test_command_2 FAILED\n");
14275 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
14276 if (test_command_3 () == -1) {
14277 printf ("test_command_3 FAILED\n");
14281 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
14282 if (test_command_4 () == -1) {
14283 printf ("test_command_4 FAILED\n");
14287 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
14288 if (test_command_5 () == -1) {
14289 printf ("test_command_5 FAILED\n");
14293 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
14294 if (test_command_6 () == -1) {
14295 printf ("test_command_6 FAILED\n");
14299 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
14300 if (test_command_7 () == -1) {
14301 printf ("test_command_7 FAILED\n");
14305 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
14306 if (test_command_8 () == -1) {
14307 printf ("test_command_8 FAILED\n");
14311 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
14312 if (test_command_9 () == -1) {
14313 printf ("test_command_9 FAILED\n");
14317 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
14318 if (test_command_10 () == -1) {
14319 printf ("test_command_10 FAILED\n");
14323 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
14324 if (test_command_11 () == -1) {
14325 printf ("test_command_11 FAILED\n");
14329 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
14330 if (test_file_0 () == -1) {
14331 printf ("test_file_0 FAILED\n");
14335 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
14336 if (test_file_1 () == -1) {
14337 printf ("test_file_1 FAILED\n");
14341 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
14342 if (test_file_2 () == -1) {
14343 printf ("test_file_2 FAILED\n");
14347 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
14348 if (test_umount_all_0 () == -1) {
14349 printf ("test_umount_all_0 FAILED\n");
14353 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
14354 if (test_umount_all_1 () == -1) {
14355 printf ("test_umount_all_1 FAILED\n");
14359 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
14360 if (test_mounts_0 () == -1) {
14361 printf ("test_mounts_0 FAILED\n");
14365 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
14366 if (test_umount_0 () == -1) {
14367 printf ("test_umount_0 FAILED\n");
14371 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
14372 if (test_umount_1 () == -1) {
14373 printf ("test_umount_1 FAILED\n");
14377 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
14378 if (test_write_file_0 () == -1) {
14379 printf ("test_write_file_0 FAILED\n");
14383 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
14384 if (test_write_file_1 () == -1) {
14385 printf ("test_write_file_1 FAILED\n");
14389 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
14390 if (test_write_file_2 () == -1) {
14391 printf ("test_write_file_2 FAILED\n");
14395 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
14396 if (test_write_file_3 () == -1) {
14397 printf ("test_write_file_3 FAILED\n");
14401 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
14402 if (test_write_file_4 () == -1) {
14403 printf ("test_write_file_4 FAILED\n");
14407 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
14408 if (test_write_file_5 () == -1) {
14409 printf ("test_write_file_5 FAILED\n");
14413 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
14414 if (test_mkfs_0 () == -1) {
14415 printf ("test_mkfs_0 FAILED\n");
14419 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
14420 if (test_lvcreate_0 () == -1) {
14421 printf ("test_lvcreate_0 FAILED\n");
14425 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
14426 if (test_vgcreate_0 () == -1) {
14427 printf ("test_vgcreate_0 FAILED\n");
14431 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
14432 if (test_pvcreate_0 () == -1) {
14433 printf ("test_pvcreate_0 FAILED\n");
14437 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
14438 if (test_is_dir_0 () == -1) {
14439 printf ("test_is_dir_0 FAILED\n");
14443 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
14444 if (test_is_dir_1 () == -1) {
14445 printf ("test_is_dir_1 FAILED\n");
14449 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
14450 if (test_is_file_0 () == -1) {
14451 printf ("test_is_file_0 FAILED\n");
14455 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
14456 if (test_is_file_1 () == -1) {
14457 printf ("test_is_file_1 FAILED\n");
14461 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
14462 if (test_exists_0 () == -1) {
14463 printf ("test_exists_0 FAILED\n");
14467 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
14468 if (test_exists_1 () == -1) {
14469 printf ("test_exists_1 FAILED\n");
14473 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
14474 if (test_mkdir_p_0 () == -1) {
14475 printf ("test_mkdir_p_0 FAILED\n");
14479 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
14480 if (test_mkdir_p_1 () == -1) {
14481 printf ("test_mkdir_p_1 FAILED\n");
14485 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
14486 if (test_mkdir_p_2 () == -1) {
14487 printf ("test_mkdir_p_2 FAILED\n");
14491 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
14492 if (test_mkdir_0 () == -1) {
14493 printf ("test_mkdir_0 FAILED\n");
14497 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
14498 if (test_mkdir_1 () == -1) {
14499 printf ("test_mkdir_1 FAILED\n");
14503 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
14504 if (test_rm_rf_0 () == -1) {
14505 printf ("test_rm_rf_0 FAILED\n");
14509 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
14510 if (test_rmdir_0 () == -1) {
14511 printf ("test_rmdir_0 FAILED\n");
14515 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14516 if (test_rmdir_1 () == -1) {
14517 printf ("test_rmdir_1 FAILED\n");
14521 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14522 if (test_rmdir_2 () == -1) {
14523 printf ("test_rmdir_2 FAILED\n");
14527 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14528 if (test_rm_0 () == -1) {
14529 printf ("test_rm_0 FAILED\n");
14533 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14534 if (test_rm_1 () == -1) {
14535 printf ("test_rm_1 FAILED\n");
14539 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14540 if (test_rm_2 () == -1) {
14541 printf ("test_rm_2 FAILED\n");
14545 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14546 if (test_read_lines_0 () == -1) {
14547 printf ("test_read_lines_0 FAILED\n");
14551 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14552 if (test_read_lines_1 () == -1) {
14553 printf ("test_read_lines_1 FAILED\n");
14557 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14558 if (test_lvs_0 () == -1) {
14559 printf ("test_lvs_0 FAILED\n");
14563 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14564 if (test_lvs_1 () == -1) {
14565 printf ("test_lvs_1 FAILED\n");
14569 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14570 if (test_vgs_0 () == -1) {
14571 printf ("test_vgs_0 FAILED\n");
14575 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14576 if (test_vgs_1 () == -1) {
14577 printf ("test_vgs_1 FAILED\n");
14581 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14582 if (test_pvs_0 () == -1) {
14583 printf ("test_pvs_0 FAILED\n");
14587 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14588 if (test_pvs_1 () == -1) {
14589 printf ("test_pvs_1 FAILED\n");
14593 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14594 if (test_list_partitions_0 () == -1) {
14595 printf ("test_list_partitions_0 FAILED\n");
14599 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14600 if (test_list_partitions_1 () == -1) {
14601 printf ("test_list_partitions_1 FAILED\n");
14605 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14606 if (test_list_devices_0 () == -1) {
14607 printf ("test_list_devices_0 FAILED\n");
14611 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14612 if (test_ls_0 () == -1) {
14613 printf ("test_ls_0 FAILED\n");
14617 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14618 if (test_cat_0 () == -1) {
14619 printf ("test_cat_0 FAILED\n");
14623 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14624 if (test_touch_0 () == -1) {
14625 printf ("test_touch_0 FAILED\n");
14629 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14630 if (test_sync_0 () == -1) {
14631 printf ("test_sync_0 FAILED\n");
14635 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14636 if (test_mount_0 () == -1) {
14637 printf ("test_mount_0 FAILED\n");
14642 unlink ("test1.img");
14643 unlink ("test2.img");
14644 unlink ("test3.img");
14647 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);