1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 /* This will be 's' or 'h' depending on whether the guest kernel
35 * names IDE devices /dev/sd* or /dev/hd*.
37 static char devchar = 's';
39 static void print_error (guestfs_h *g, void *data, const char *msg)
42 fprintf (stderr, "%s\n", msg);
45 static void print_strings (char * const * const argv)
49 for (argc = 0; argv[argc] != NULL; ++argc)
50 printf ("\t%s\n", argv[argc]);
54 static void print_table (char * const * const argv)
58 for (i = 0; argv[i] != NULL; i += 2)
59 printf ("%s: %s\n", argv[i], argv[i+1]);
63 static void no_test_warnings (void)
65 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
129 static int test_find_0 (void)
131 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
133 char device[] = "/dev/sda";
137 r = guestfs_blockdev_setrw (g, device);
144 r = guestfs_umount_all (g);
151 r = guestfs_lvm_remove_all (g);
156 char device[] = "/dev/sda";
158 char lines_0[] = ",";
165 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
170 char fstype[] = "ext2";
171 char device[] = "/dev/sda1";
175 r = guestfs_mkfs (g, fstype, device);
180 char device[] = "/dev/sda1";
182 char mountpoint[] = "/";
185 r = guestfs_mount (g, device, mountpoint);
189 /* TestOutputList for find (0) */
191 char directory[] = "/";
195 r = guestfs_find (g, directory);
199 fprintf (stderr, "test_find_0: short list returned from command\n");
204 char expected[] = "lost+found";
205 if (strcmp (r[0], expected) != 0) {
206 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
211 fprintf (stderr, "test_find_0: extra elements returned from command\n");
215 for (i = 0; r[i] != NULL; ++i)
222 static int test_find_1 (void)
224 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
226 char device[] = "/dev/sda";
230 r = guestfs_blockdev_setrw (g, device);
237 r = guestfs_umount_all (g);
244 r = guestfs_lvm_remove_all (g);
249 char device[] = "/dev/sda";
251 char lines_0[] = ",";
258 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
263 char fstype[] = "ext2";
264 char device[] = "/dev/sda1";
268 r = guestfs_mkfs (g, fstype, device);
273 char device[] = "/dev/sda1";
275 char mountpoint[] = "/";
278 r = guestfs_mount (g, device, mountpoint);
282 /* TestOutputList for find (1) */
287 r = guestfs_touch (g, path);
295 r = guestfs_mkdir (g, path);
300 char path[] = "/b/c";
303 r = guestfs_touch (g, path);
308 char directory[] = "/";
312 r = guestfs_find (g, directory);
316 fprintf (stderr, "test_find_1: short list returned from command\n");
321 char expected[] = "a";
322 if (strcmp (r[0], expected) != 0) {
323 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
328 fprintf (stderr, "test_find_1: short list returned from command\n");
333 char expected[] = "b";
334 if (strcmp (r[1], expected) != 0) {
335 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
340 fprintf (stderr, "test_find_1: short list returned from command\n");
345 char expected[] = "b/c";
346 if (strcmp (r[2], expected) != 0) {
347 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
352 fprintf (stderr, "test_find_1: short list returned from command\n");
357 char expected[] = "lost+found";
358 if (strcmp (r[3], expected) != 0) {
359 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
364 fprintf (stderr, "test_find_1: extra elements returned from command\n");
368 for (i = 0; r[i] != NULL; ++i)
375 static int test_find_2 (void)
377 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
379 char device[] = "/dev/sda";
383 r = guestfs_blockdev_setrw (g, device);
390 r = guestfs_umount_all (g);
397 r = guestfs_lvm_remove_all (g);
402 char device[] = "/dev/sda";
404 char lines_0[] = ",";
411 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
416 char fstype[] = "ext2";
417 char device[] = "/dev/sda1";
421 r = guestfs_mkfs (g, fstype, device);
426 char device[] = "/dev/sda1";
428 char mountpoint[] = "/";
431 r = guestfs_mount (g, device, mountpoint);
435 /* TestOutputList for find (2) */
437 char path[] = "/a/b/c";
440 r = guestfs_mkdir_p (g, path);
445 char path[] = "/a/b/c/d";
448 r = guestfs_touch (g, path);
453 char directory[] = "/a/b/";
457 r = guestfs_find (g, directory);
461 fprintf (stderr, "test_find_2: short list returned from command\n");
466 char expected[] = "c";
467 if (strcmp (r[0], expected) != 0) {
468 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
473 fprintf (stderr, "test_find_2: short list returned from command\n");
478 char expected[] = "c/d";
479 if (strcmp (r[1], expected) != 0) {
480 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
485 fprintf (stderr, "test_find_2: extra elements returned from command\n");
489 for (i = 0; r[i] != NULL; ++i)
496 static int test_lvresize_0 (void)
498 /* InitNone|InitEmpty for test_lvresize_0 */
500 char device[] = "/dev/sda";
504 r = guestfs_blockdev_setrw (g, device);
511 r = guestfs_umount_all (g);
518 r = guestfs_lvm_remove_all (g);
522 /* TestOutput for lvresize (0) */
523 char expected[] = "test content";
525 char device[] = "/dev/sda";
527 char lines_0[] = ",";
534 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
539 char device[] = "/dev/sda1";
543 r = guestfs_pvcreate (g, device);
548 char volgroup[] = "VG";
549 char physvols_0[] = "/dev/sda1";
550 physvols_0[5] = devchar;
557 r = guestfs_vgcreate (g, volgroup, physvols);
562 char logvol[] = "LV";
563 char volgroup[] = "VG";
566 r = guestfs_lvcreate (g, logvol, volgroup, 10);
571 char fstype[] = "ext2";
572 char device[] = "/dev/VG/LV";
575 r = guestfs_mkfs (g, fstype, device);
580 char device[] = "/dev/VG/LV";
581 char mountpoint[] = "/";
584 r = guestfs_mount (g, device, mountpoint);
589 char path[] = "/new";
590 char content[] = "test content";
593 r = guestfs_write_file (g, path, content, 0);
598 char pathordevice[] = "/";
601 r = guestfs_umount (g, pathordevice);
606 char device[] = "/dev/VG/LV";
609 r = guestfs_lvresize (g, device, 20);
614 char device[] = "/dev/VG/LV";
617 r = guestfs_resize2fs (g, device);
622 char device[] = "/dev/VG/LV";
623 char mountpoint[] = "/";
626 r = guestfs_mount (g, device, mountpoint);
631 char path[] = "/new";
634 r = guestfs_cat (g, path);
637 if (strcmp (r, expected) != 0) {
638 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
646 static int test_zerofree_0 (void)
648 /* InitNone|InitEmpty for test_zerofree_0 */
650 char device[] = "/dev/sda";
654 r = guestfs_blockdev_setrw (g, device);
661 r = guestfs_umount_all (g);
668 r = guestfs_lvm_remove_all (g);
672 /* TestOutput for zerofree (0) */
673 char expected[] = "test file";
675 char device[] = "/dev/sda";
677 char lines_0[] = ",";
684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
689 char fstype[] = "ext3";
690 char device[] = "/dev/sda1";
694 r = guestfs_mkfs (g, fstype, device);
699 char device[] = "/dev/sda1";
701 char mountpoint[] = "/";
704 r = guestfs_mount (g, device, mountpoint);
709 char path[] = "/new";
710 char content[] = "test file";
713 r = guestfs_write_file (g, path, content, 0);
718 char pathordevice[] = "/dev/sda1";
719 pathordevice[5] = devchar;
722 r = guestfs_umount (g, pathordevice);
727 char device[] = "/dev/sda1";
731 r = guestfs_zerofree (g, device);
736 char device[] = "/dev/sda1";
738 char mountpoint[] = "/";
741 r = guestfs_mount (g, device, mountpoint);
746 char path[] = "/new";
749 r = guestfs_cat (g, path);
752 if (strcmp (r, expected) != 0) {
753 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
761 static int test_hexdump_0 (void)
763 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
765 char device[] = "/dev/sda";
769 r = guestfs_blockdev_setrw (g, device);
776 r = guestfs_umount_all (g);
783 r = guestfs_lvm_remove_all (g);
788 char device[] = "/dev/sda";
790 char lines_0[] = ",";
797 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
802 char fstype[] = "ext2";
803 char device[] = "/dev/sda1";
807 r = guestfs_mkfs (g, fstype, device);
812 char device[] = "/dev/sda1";
814 char mountpoint[] = "/";
817 r = guestfs_mount (g, device, mountpoint);
821 /* TestOutput for hexdump (0) */
822 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
824 char path[] = "/new";
825 char content[] = "hello\nworld\n";
828 r = guestfs_write_file (g, path, content, 12);
833 char path[] = "/new";
836 r = guestfs_hexdump (g, path);
839 if (strcmp (r, expected) != 0) {
840 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
848 static int test_strings_e_0 (void)
850 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
852 char device[] = "/dev/sda";
856 r = guestfs_blockdev_setrw (g, device);
863 r = guestfs_umount_all (g);
870 r = guestfs_lvm_remove_all (g);
875 char device[] = "/dev/sda";
877 char lines_0[] = ",";
884 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
889 char fstype[] = "ext2";
890 char device[] = "/dev/sda1";
894 r = guestfs_mkfs (g, fstype, device);
899 char device[] = "/dev/sda1";
901 char mountpoint[] = "/";
904 r = guestfs_mount (g, device, mountpoint);
908 /* TestOutputList for strings_e (0) */
910 char path[] = "/new";
911 char content[] = "hello\nworld\n";
914 r = guestfs_write_file (g, path, content, 0);
919 char encoding[] = "b";
920 char path[] = "/new";
924 r = guestfs_strings_e (g, encoding, path);
928 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
932 for (i = 0; r[i] != NULL; ++i)
939 static int test_strings_e_1 (void)
941 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
945 static int test_strings_0 (void)
947 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
949 char device[] = "/dev/sda";
953 r = guestfs_blockdev_setrw (g, device);
960 r = guestfs_umount_all (g);
967 r = guestfs_lvm_remove_all (g);
972 char device[] = "/dev/sda";
974 char lines_0[] = ",";
981 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
986 char fstype[] = "ext2";
987 char device[] = "/dev/sda1";
991 r = guestfs_mkfs (g, fstype, device);
996 char device[] = "/dev/sda1";
998 char mountpoint[] = "/";
1001 r = guestfs_mount (g, device, mountpoint);
1005 /* TestOutputList for strings (0) */
1007 char path[] = "/new";
1008 char content[] = "hello\nworld\n";
1011 r = guestfs_write_file (g, path, content, 0);
1016 char path[] = "/new";
1020 r = guestfs_strings (g, path);
1024 fprintf (stderr, "test_strings_0: short list returned from command\n");
1029 char expected[] = "hello";
1030 if (strcmp (r[0], expected) != 0) {
1031 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1036 fprintf (stderr, "test_strings_0: short list returned from command\n");
1041 char expected[] = "world";
1042 if (strcmp (r[1], expected) != 0) {
1043 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1048 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1052 for (i = 0; r[i] != NULL; ++i)
1059 static int test_strings_1 (void)
1061 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1063 char device[] = "/dev/sda";
1064 device[5] = devchar;
1067 r = guestfs_blockdev_setrw (g, device);
1074 r = guestfs_umount_all (g);
1081 r = guestfs_lvm_remove_all (g);
1086 char device[] = "/dev/sda";
1087 device[5] = devchar;
1088 char lines_0[] = ",";
1095 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1100 char fstype[] = "ext2";
1101 char device[] = "/dev/sda1";
1102 device[5] = devchar;
1105 r = guestfs_mkfs (g, fstype, device);
1110 char device[] = "/dev/sda1";
1111 device[5] = devchar;
1112 char mountpoint[] = "/";
1115 r = guestfs_mount (g, device, mountpoint);
1119 /* TestOutputList for strings (1) */
1121 char path[] = "/new";
1124 r = guestfs_touch (g, path);
1129 char path[] = "/new";
1133 r = guestfs_strings (g, path);
1137 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1141 for (i = 0; r[i] != NULL; ++i)
1148 static int test_equal_0 (void)
1150 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1152 char device[] = "/dev/sda";
1153 device[5] = devchar;
1156 r = guestfs_blockdev_setrw (g, device);
1163 r = guestfs_umount_all (g);
1170 r = guestfs_lvm_remove_all (g);
1175 char device[] = "/dev/sda";
1176 device[5] = devchar;
1177 char lines_0[] = ",";
1184 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1189 char fstype[] = "ext2";
1190 char device[] = "/dev/sda1";
1191 device[5] = devchar;
1194 r = guestfs_mkfs (g, fstype, device);
1199 char device[] = "/dev/sda1";
1200 device[5] = devchar;
1201 char mountpoint[] = "/";
1204 r = guestfs_mount (g, device, mountpoint);
1208 /* TestOutputTrue for equal (0) */
1210 char path[] = "/file1";
1211 char content[] = "contents of a file";
1214 r = guestfs_write_file (g, path, content, 0);
1219 char src[] = "/file1";
1220 char dest[] = "/file2";
1223 r = guestfs_cp (g, src, dest);
1228 char file1[] = "/file1";
1229 char file2[] = "/file2";
1232 r = guestfs_equal (g, file1, file2);
1236 fprintf (stderr, "test_equal_0: expected true, got false\n");
1243 static int test_equal_1 (void)
1245 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1247 char device[] = "/dev/sda";
1248 device[5] = devchar;
1251 r = guestfs_blockdev_setrw (g, device);
1258 r = guestfs_umount_all (g);
1265 r = guestfs_lvm_remove_all (g);
1270 char device[] = "/dev/sda";
1271 device[5] = devchar;
1272 char lines_0[] = ",";
1279 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1284 char fstype[] = "ext2";
1285 char device[] = "/dev/sda1";
1286 device[5] = devchar;
1289 r = guestfs_mkfs (g, fstype, device);
1294 char device[] = "/dev/sda1";
1295 device[5] = devchar;
1296 char mountpoint[] = "/";
1299 r = guestfs_mount (g, device, mountpoint);
1303 /* TestOutputFalse for equal (1) */
1305 char path[] = "/file1";
1306 char content[] = "contents of a file";
1309 r = guestfs_write_file (g, path, content, 0);
1314 char path[] = "/file2";
1315 char content[] = "contents of another file";
1318 r = guestfs_write_file (g, path, content, 0);
1323 char file1[] = "/file1";
1324 char file2[] = "/file2";
1327 r = guestfs_equal (g, file1, file2);
1331 fprintf (stderr, "test_equal_1: expected false, got true\n");
1338 static int test_equal_2 (void)
1340 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1342 char device[] = "/dev/sda";
1343 device[5] = devchar;
1346 r = guestfs_blockdev_setrw (g, device);
1353 r = guestfs_umount_all (g);
1360 r = guestfs_lvm_remove_all (g);
1365 char device[] = "/dev/sda";
1366 device[5] = devchar;
1367 char lines_0[] = ",";
1374 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1379 char fstype[] = "ext2";
1380 char device[] = "/dev/sda1";
1381 device[5] = devchar;
1384 r = guestfs_mkfs (g, fstype, device);
1389 char device[] = "/dev/sda1";
1390 device[5] = devchar;
1391 char mountpoint[] = "/";
1394 r = guestfs_mount (g, device, mountpoint);
1398 /* TestLastFail for equal (2) */
1400 char file1[] = "/file1";
1401 char file2[] = "/file2";
1404 r = guestfs_equal (g, file1, file2);
1411 static int test_ping_daemon_0 (void)
1413 /* InitNone|InitEmpty for test_ping_daemon_0 */
1415 char device[] = "/dev/sda";
1416 device[5] = devchar;
1419 r = guestfs_blockdev_setrw (g, device);
1426 r = guestfs_umount_all (g);
1433 r = guestfs_lvm_remove_all (g);
1437 /* TestRun for ping_daemon (0) */
1441 r = guestfs_ping_daemon (g);
1448 static int test_dmesg_0 (void)
1450 /* InitNone|InitEmpty for test_dmesg_0 */
1452 char device[] = "/dev/sda";
1453 device[5] = devchar;
1456 r = guestfs_blockdev_setrw (g, device);
1463 r = guestfs_umount_all (g);
1470 r = guestfs_lvm_remove_all (g);
1474 /* TestRun for dmesg (0) */
1478 r = guestfs_dmesg (g);
1486 static int test_drop_caches_0 (void)
1488 /* InitNone|InitEmpty for test_drop_caches_0 */
1490 char device[] = "/dev/sda";
1491 device[5] = devchar;
1494 r = guestfs_blockdev_setrw (g, device);
1501 r = guestfs_umount_all (g);
1508 r = guestfs_lvm_remove_all (g);
1512 /* TestRun for drop_caches (0) */
1516 r = guestfs_drop_caches (g, 3);
1523 static int test_mv_0 (void)
1525 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1527 char device[] = "/dev/sda";
1528 device[5] = devchar;
1531 r = guestfs_blockdev_setrw (g, device);
1538 r = guestfs_umount_all (g);
1545 r = guestfs_lvm_remove_all (g);
1550 char device[] = "/dev/sda";
1551 device[5] = devchar;
1552 char lines_0[] = ",";
1559 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1564 char fstype[] = "ext2";
1565 char device[] = "/dev/sda1";
1566 device[5] = devchar;
1569 r = guestfs_mkfs (g, fstype, device);
1574 char device[] = "/dev/sda1";
1575 device[5] = devchar;
1576 char mountpoint[] = "/";
1579 r = guestfs_mount (g, device, mountpoint);
1583 /* TestOutput for mv (0) */
1584 char expected[] = "file content";
1586 char path[] = "/old";
1587 char content[] = "file content";
1590 r = guestfs_write_file (g, path, content, 0);
1595 char src[] = "/old";
1596 char dest[] = "/new";
1599 r = guestfs_mv (g, src, dest);
1604 char path[] = "/new";
1607 r = guestfs_cat (g, path);
1610 if (strcmp (r, expected) != 0) {
1611 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1619 static int test_mv_1 (void)
1621 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1623 char device[] = "/dev/sda";
1624 device[5] = devchar;
1627 r = guestfs_blockdev_setrw (g, device);
1634 r = guestfs_umount_all (g);
1641 r = guestfs_lvm_remove_all (g);
1646 char device[] = "/dev/sda";
1647 device[5] = devchar;
1648 char lines_0[] = ",";
1655 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1660 char fstype[] = "ext2";
1661 char device[] = "/dev/sda1";
1662 device[5] = devchar;
1665 r = guestfs_mkfs (g, fstype, device);
1670 char device[] = "/dev/sda1";
1671 device[5] = devchar;
1672 char mountpoint[] = "/";
1675 r = guestfs_mount (g, device, mountpoint);
1679 /* TestOutputFalse for mv (1) */
1681 char path[] = "/old";
1682 char content[] = "file content";
1685 r = guestfs_write_file (g, path, content, 0);
1690 char src[] = "/old";
1691 char dest[] = "/new";
1694 r = guestfs_mv (g, src, dest);
1699 char path[] = "/old";
1702 r = guestfs_is_file (g, path);
1706 fprintf (stderr, "test_mv_1: expected false, got true\n");
1713 static int test_cp_a_0 (void)
1715 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1717 char device[] = "/dev/sda";
1718 device[5] = devchar;
1721 r = guestfs_blockdev_setrw (g, device);
1728 r = guestfs_umount_all (g);
1735 r = guestfs_lvm_remove_all (g);
1740 char device[] = "/dev/sda";
1741 device[5] = devchar;
1742 char lines_0[] = ",";
1749 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1754 char fstype[] = "ext2";
1755 char device[] = "/dev/sda1";
1756 device[5] = devchar;
1759 r = guestfs_mkfs (g, fstype, device);
1764 char device[] = "/dev/sda1";
1765 device[5] = devchar;
1766 char mountpoint[] = "/";
1769 r = guestfs_mount (g, device, mountpoint);
1773 /* TestOutput for cp_a (0) */
1774 char expected[] = "file content";
1776 char path[] = "/olddir";
1779 r = guestfs_mkdir (g, path);
1784 char path[] = "/newdir";
1787 r = guestfs_mkdir (g, path);
1792 char path[] = "/olddir/file";
1793 char content[] = "file content";
1796 r = guestfs_write_file (g, path, content, 0);
1801 char src[] = "/olddir";
1802 char dest[] = "/newdir";
1805 r = guestfs_cp_a (g, src, dest);
1810 char path[] = "/newdir/olddir/file";
1813 r = guestfs_cat (g, path);
1816 if (strcmp (r, expected) != 0) {
1817 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1825 static int test_cp_0 (void)
1827 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1829 char device[] = "/dev/sda";
1830 device[5] = devchar;
1833 r = guestfs_blockdev_setrw (g, device);
1840 r = guestfs_umount_all (g);
1847 r = guestfs_lvm_remove_all (g);
1852 char device[] = "/dev/sda";
1853 device[5] = devchar;
1854 char lines_0[] = ",";
1861 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1866 char fstype[] = "ext2";
1867 char device[] = "/dev/sda1";
1868 device[5] = devchar;
1871 r = guestfs_mkfs (g, fstype, device);
1876 char device[] = "/dev/sda1";
1877 device[5] = devchar;
1878 char mountpoint[] = "/";
1881 r = guestfs_mount (g, device, mountpoint);
1885 /* TestOutput for cp (0) */
1886 char expected[] = "file content";
1888 char path[] = "/old";
1889 char content[] = "file content";
1892 r = guestfs_write_file (g, path, content, 0);
1897 char src[] = "/old";
1898 char dest[] = "/new";
1901 r = guestfs_cp (g, src, dest);
1906 char path[] = "/new";
1909 r = guestfs_cat (g, path);
1912 if (strcmp (r, expected) != 0) {
1913 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1921 static int test_cp_1 (void)
1923 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1925 char device[] = "/dev/sda";
1926 device[5] = devchar;
1929 r = guestfs_blockdev_setrw (g, device);
1936 r = guestfs_umount_all (g);
1943 r = guestfs_lvm_remove_all (g);
1948 char device[] = "/dev/sda";
1949 device[5] = devchar;
1950 char lines_0[] = ",";
1957 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1962 char fstype[] = "ext2";
1963 char device[] = "/dev/sda1";
1964 device[5] = devchar;
1967 r = guestfs_mkfs (g, fstype, device);
1972 char device[] = "/dev/sda1";
1973 device[5] = devchar;
1974 char mountpoint[] = "/";
1977 r = guestfs_mount (g, device, mountpoint);
1981 /* TestOutputTrue for cp (1) */
1983 char path[] = "/old";
1984 char content[] = "file content";
1987 r = guestfs_write_file (g, path, content, 0);
1992 char src[] = "/old";
1993 char dest[] = "/new";
1996 r = guestfs_cp (g, src, dest);
2001 char path[] = "/old";
2004 r = guestfs_is_file (g, path);
2008 fprintf (stderr, "test_cp_1: expected true, got false\n");
2015 static int test_cp_2 (void)
2017 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2019 char device[] = "/dev/sda";
2020 device[5] = devchar;
2023 r = guestfs_blockdev_setrw (g, device);
2030 r = guestfs_umount_all (g);
2037 r = guestfs_lvm_remove_all (g);
2042 char device[] = "/dev/sda";
2043 device[5] = devchar;
2044 char lines_0[] = ",";
2051 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2056 char fstype[] = "ext2";
2057 char device[] = "/dev/sda1";
2058 device[5] = devchar;
2061 r = guestfs_mkfs (g, fstype, device);
2066 char device[] = "/dev/sda1";
2067 device[5] = devchar;
2068 char mountpoint[] = "/";
2071 r = guestfs_mount (g, device, mountpoint);
2075 /* TestOutput for cp (2) */
2076 char expected[] = "file content";
2078 char path[] = "/old";
2079 char content[] = "file content";
2082 r = guestfs_write_file (g, path, content, 0);
2087 char path[] = "/dir";
2090 r = guestfs_mkdir (g, path);
2095 char src[] = "/old";
2096 char dest[] = "/dir/new";
2099 r = guestfs_cp (g, src, dest);
2104 char path[] = "/dir/new";
2107 r = guestfs_cat (g, path);
2110 if (strcmp (r, expected) != 0) {
2111 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2119 static int test_grub_install_0 (void)
2121 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2123 char device[] = "/dev/sda";
2124 device[5] = devchar;
2127 r = guestfs_blockdev_setrw (g, device);
2134 r = guestfs_umount_all (g);
2141 r = guestfs_lvm_remove_all (g);
2146 char device[] = "/dev/sda";
2147 device[5] = devchar;
2148 char lines_0[] = ",";
2155 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2160 char fstype[] = "ext2";
2161 char device[] = "/dev/sda1";
2162 device[5] = devchar;
2165 r = guestfs_mkfs (g, fstype, device);
2170 char device[] = "/dev/sda1";
2171 device[5] = devchar;
2172 char mountpoint[] = "/";
2175 r = guestfs_mount (g, device, mountpoint);
2179 /* TestOutputTrue for grub_install (0) */
2182 char device[] = "/dev/sda1";
2183 device[5] = devchar;
2186 r = guestfs_grub_install (g, root, device);
2191 char path[] = "/boot";
2194 r = guestfs_is_dir (g, path);
2198 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2205 static int test_zero_0 (void)
2207 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2209 char device[] = "/dev/sda";
2210 device[5] = devchar;
2213 r = guestfs_blockdev_setrw (g, device);
2220 r = guestfs_umount_all (g);
2227 r = guestfs_lvm_remove_all (g);
2232 char device[] = "/dev/sda";
2233 device[5] = devchar;
2234 char lines_0[] = ",";
2241 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2246 char fstype[] = "ext2";
2247 char device[] = "/dev/sda1";
2248 device[5] = devchar;
2251 r = guestfs_mkfs (g, fstype, device);
2256 char device[] = "/dev/sda1";
2257 device[5] = devchar;
2258 char mountpoint[] = "/";
2261 r = guestfs_mount (g, device, mountpoint);
2265 /* TestOutput for zero (0) */
2266 char expected[] = "data";
2268 char pathordevice[] = "/dev/sda1";
2269 pathordevice[5] = devchar;
2272 r = guestfs_umount (g, pathordevice);
2277 char device[] = "/dev/sda1";
2278 device[5] = devchar;
2281 r = guestfs_zero (g, device);
2286 char path[] = "/dev/sda1";
2290 r = guestfs_file (g, path);
2293 if (strcmp (r, expected) != 0) {
2294 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2302 static int test_fsck_0 (void)
2304 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2306 char device[] = "/dev/sda";
2307 device[5] = devchar;
2310 r = guestfs_blockdev_setrw (g, device);
2317 r = guestfs_umount_all (g);
2324 r = guestfs_lvm_remove_all (g);
2329 char device[] = "/dev/sda";
2330 device[5] = devchar;
2331 char lines_0[] = ",";
2338 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2343 char fstype[] = "ext2";
2344 char device[] = "/dev/sda1";
2345 device[5] = devchar;
2348 r = guestfs_mkfs (g, fstype, device);
2353 char device[] = "/dev/sda1";
2354 device[5] = devchar;
2355 char mountpoint[] = "/";
2358 r = guestfs_mount (g, device, mountpoint);
2362 /* TestOutputInt for fsck (0) */
2364 char pathordevice[] = "/dev/sda1";
2365 pathordevice[5] = devchar;
2368 r = guestfs_umount (g, pathordevice);
2373 char fstype[] = "ext2";
2374 char device[] = "/dev/sda1";
2375 device[5] = devchar;
2378 r = guestfs_fsck (g, fstype, device);
2382 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2389 static int test_fsck_1 (void)
2391 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2393 char device[] = "/dev/sda";
2394 device[5] = devchar;
2397 r = guestfs_blockdev_setrw (g, device);
2404 r = guestfs_umount_all (g);
2411 r = guestfs_lvm_remove_all (g);
2416 char device[] = "/dev/sda";
2417 device[5] = devchar;
2418 char lines_0[] = ",";
2425 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2430 char fstype[] = "ext2";
2431 char device[] = "/dev/sda1";
2432 device[5] = devchar;
2435 r = guestfs_mkfs (g, fstype, device);
2440 char device[] = "/dev/sda1";
2441 device[5] = devchar;
2442 char mountpoint[] = "/";
2445 r = guestfs_mount (g, device, mountpoint);
2449 /* TestOutputInt for fsck (1) */
2451 char pathordevice[] = "/dev/sda1";
2452 pathordevice[5] = devchar;
2455 r = guestfs_umount (g, pathordevice);
2460 char device[] = "/dev/sda1";
2461 device[5] = devchar;
2464 r = guestfs_zero (g, device);
2469 char fstype[] = "ext2";
2470 char device[] = "/dev/sda1";
2471 device[5] = devchar;
2474 r = guestfs_fsck (g, fstype, device);
2478 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
2485 static int test_set_e2uuid_0 (void)
2487 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2489 char device[] = "/dev/sda";
2490 device[5] = devchar;
2493 r = guestfs_blockdev_setrw (g, device);
2500 r = guestfs_umount_all (g);
2507 r = guestfs_lvm_remove_all (g);
2512 char device[] = "/dev/sda";
2513 device[5] = devchar;
2514 char lines_0[] = ",";
2521 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2526 char fstype[] = "ext2";
2527 char device[] = "/dev/sda1";
2528 device[5] = devchar;
2531 r = guestfs_mkfs (g, fstype, device);
2536 char device[] = "/dev/sda1";
2537 device[5] = devchar;
2538 char mountpoint[] = "/";
2541 r = guestfs_mount (g, device, mountpoint);
2545 /* TestOutput for set_e2uuid (0) */
2546 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2548 char device[] = "/dev/sda1";
2549 device[5] = devchar;
2550 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2553 r = guestfs_set_e2uuid (g, device, uuid);
2558 char device[] = "/dev/sda1";
2559 device[5] = devchar;
2562 r = guestfs_get_e2uuid (g, device);
2565 if (strcmp (r, expected) != 0) {
2566 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2574 static int test_set_e2uuid_1 (void)
2576 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2578 char device[] = "/dev/sda";
2579 device[5] = devchar;
2582 r = guestfs_blockdev_setrw (g, device);
2589 r = guestfs_umount_all (g);
2596 r = guestfs_lvm_remove_all (g);
2601 char device[] = "/dev/sda";
2602 device[5] = devchar;
2603 char lines_0[] = ",";
2610 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2615 char fstype[] = "ext2";
2616 char device[] = "/dev/sda1";
2617 device[5] = devchar;
2620 r = guestfs_mkfs (g, fstype, device);
2625 char device[] = "/dev/sda1";
2626 device[5] = devchar;
2627 char mountpoint[] = "/";
2630 r = guestfs_mount (g, device, mountpoint);
2634 /* TestOutput for set_e2uuid (1) */
2635 char expected[] = "";
2637 char device[] = "/dev/sda1";
2638 device[5] = devchar;
2639 char uuid[] = "clear";
2642 r = guestfs_set_e2uuid (g, device, uuid);
2647 char device[] = "/dev/sda1";
2648 device[5] = devchar;
2651 r = guestfs_get_e2uuid (g, device);
2654 if (strcmp (r, expected) != 0) {
2655 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2663 static int test_set_e2uuid_2 (void)
2665 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2667 char device[] = "/dev/sda";
2668 device[5] = devchar;
2671 r = guestfs_blockdev_setrw (g, device);
2678 r = guestfs_umount_all (g);
2685 r = guestfs_lvm_remove_all (g);
2690 char device[] = "/dev/sda";
2691 device[5] = devchar;
2692 char lines_0[] = ",";
2699 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2704 char fstype[] = "ext2";
2705 char device[] = "/dev/sda1";
2706 device[5] = devchar;
2709 r = guestfs_mkfs (g, fstype, device);
2714 char device[] = "/dev/sda1";
2715 device[5] = devchar;
2716 char mountpoint[] = "/";
2719 r = guestfs_mount (g, device, mountpoint);
2723 /* TestRun for set_e2uuid (2) */
2725 char device[] = "/dev/sda1";
2726 device[5] = devchar;
2727 char uuid[] = "random";
2730 r = guestfs_set_e2uuid (g, device, uuid);
2737 static int test_set_e2uuid_3 (void)
2739 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2741 char device[] = "/dev/sda";
2742 device[5] = devchar;
2745 r = guestfs_blockdev_setrw (g, device);
2752 r = guestfs_umount_all (g);
2759 r = guestfs_lvm_remove_all (g);
2764 char device[] = "/dev/sda";
2765 device[5] = devchar;
2766 char lines_0[] = ",";
2773 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2778 char fstype[] = "ext2";
2779 char device[] = "/dev/sda1";
2780 device[5] = devchar;
2783 r = guestfs_mkfs (g, fstype, device);
2788 char device[] = "/dev/sda1";
2789 device[5] = devchar;
2790 char mountpoint[] = "/";
2793 r = guestfs_mount (g, device, mountpoint);
2797 /* TestRun for set_e2uuid (3) */
2799 char device[] = "/dev/sda1";
2800 device[5] = devchar;
2801 char uuid[] = "time";
2804 r = guestfs_set_e2uuid (g, device, uuid);
2811 static int test_set_e2label_0 (void)
2813 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2815 char device[] = "/dev/sda";
2816 device[5] = devchar;
2819 r = guestfs_blockdev_setrw (g, device);
2826 r = guestfs_umount_all (g);
2833 r = guestfs_lvm_remove_all (g);
2838 char device[] = "/dev/sda";
2839 device[5] = devchar;
2840 char lines_0[] = ",";
2847 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2852 char fstype[] = "ext2";
2853 char device[] = "/dev/sda1";
2854 device[5] = devchar;
2857 r = guestfs_mkfs (g, fstype, device);
2862 char device[] = "/dev/sda1";
2863 device[5] = devchar;
2864 char mountpoint[] = "/";
2867 r = guestfs_mount (g, device, mountpoint);
2871 /* TestOutput for set_e2label (0) */
2872 char expected[] = "testlabel";
2874 char device[] = "/dev/sda1";
2875 device[5] = devchar;
2876 char label[] = "testlabel";
2879 r = guestfs_set_e2label (g, device, label);
2884 char device[] = "/dev/sda1";
2885 device[5] = devchar;
2888 r = guestfs_get_e2label (g, device);
2891 if (strcmp (r, expected) != 0) {
2892 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2900 static int test_pvremove_0 (void)
2902 /* InitNone|InitEmpty for test_pvremove_0 */
2904 char device[] = "/dev/sda";
2905 device[5] = devchar;
2908 r = guestfs_blockdev_setrw (g, device);
2915 r = guestfs_umount_all (g);
2922 r = guestfs_lvm_remove_all (g);
2926 /* TestOutputList for pvremove (0) */
2928 char device[] = "/dev/sda";
2929 device[5] = devchar;
2932 r = guestfs_pvcreate (g, device);
2937 char volgroup[] = "VG";
2938 char physvols_0[] = "/dev/sda";
2939 physvols_0[5] = devchar;
2940 char *physvols[] = {
2946 r = guestfs_vgcreate (g, volgroup, physvols);
2951 char logvol[] = "LV1";
2952 char volgroup[] = "VG";
2955 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2960 char logvol[] = "LV2";
2961 char volgroup[] = "VG";
2964 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2969 char vgname[] = "VG";
2972 r = guestfs_vgremove (g, vgname);
2977 char device[] = "/dev/sda";
2978 device[5] = devchar;
2981 r = guestfs_pvremove (g, device);
2989 r = guestfs_lvs (g);
2993 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2997 for (i = 0; r[i] != NULL; ++i)
3004 static int test_pvremove_1 (void)
3006 /* InitNone|InitEmpty for test_pvremove_1 */
3008 char device[] = "/dev/sda";
3009 device[5] = devchar;
3012 r = guestfs_blockdev_setrw (g, device);
3019 r = guestfs_umount_all (g);
3026 r = guestfs_lvm_remove_all (g);
3030 /* TestOutputList for pvremove (1) */
3032 char device[] = "/dev/sda";
3033 device[5] = devchar;
3036 r = guestfs_pvcreate (g, device);
3041 char volgroup[] = "VG";
3042 char physvols_0[] = "/dev/sda";
3043 physvols_0[5] = devchar;
3044 char *physvols[] = {
3050 r = guestfs_vgcreate (g, volgroup, physvols);
3055 char logvol[] = "LV1";
3056 char volgroup[] = "VG";
3059 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3064 char logvol[] = "LV2";
3065 char volgroup[] = "VG";
3068 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3073 char vgname[] = "VG";
3076 r = guestfs_vgremove (g, vgname);
3081 char device[] = "/dev/sda";
3082 device[5] = devchar;
3085 r = guestfs_pvremove (g, device);
3093 r = guestfs_vgs (g);
3097 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3101 for (i = 0; r[i] != NULL; ++i)
3108 static int test_pvremove_2 (void)
3110 /* InitNone|InitEmpty for test_pvremove_2 */
3112 char device[] = "/dev/sda";
3113 device[5] = devchar;
3116 r = guestfs_blockdev_setrw (g, device);
3123 r = guestfs_umount_all (g);
3130 r = guestfs_lvm_remove_all (g);
3134 /* TestOutputList for pvremove (2) */
3136 char device[] = "/dev/sda";
3137 device[5] = devchar;
3140 r = guestfs_pvcreate (g, device);
3145 char volgroup[] = "VG";
3146 char physvols_0[] = "/dev/sda";
3147 physvols_0[5] = devchar;
3148 char *physvols[] = {
3154 r = guestfs_vgcreate (g, volgroup, physvols);
3159 char logvol[] = "LV1";
3160 char volgroup[] = "VG";
3163 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3168 char logvol[] = "LV2";
3169 char volgroup[] = "VG";
3172 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3177 char vgname[] = "VG";
3180 r = guestfs_vgremove (g, vgname);
3185 char device[] = "/dev/sda";
3186 device[5] = devchar;
3189 r = guestfs_pvremove (g, device);
3197 r = guestfs_pvs (g);
3201 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3205 for (i = 0; r[i] != NULL; ++i)
3212 static int test_vgremove_0 (void)
3214 /* InitNone|InitEmpty for test_vgremove_0 */
3216 char device[] = "/dev/sda";
3217 device[5] = devchar;
3220 r = guestfs_blockdev_setrw (g, device);
3227 r = guestfs_umount_all (g);
3234 r = guestfs_lvm_remove_all (g);
3238 /* TestOutputList for vgremove (0) */
3240 char device[] = "/dev/sda";
3241 device[5] = devchar;
3244 r = guestfs_pvcreate (g, device);
3249 char volgroup[] = "VG";
3250 char physvols_0[] = "/dev/sda";
3251 physvols_0[5] = devchar;
3252 char *physvols[] = {
3258 r = guestfs_vgcreate (g, volgroup, physvols);
3263 char logvol[] = "LV1";
3264 char volgroup[] = "VG";
3267 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3272 char logvol[] = "LV2";
3273 char volgroup[] = "VG";
3276 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3281 char vgname[] = "VG";
3284 r = guestfs_vgremove (g, vgname);
3292 r = guestfs_lvs (g);
3296 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3300 for (i = 0; r[i] != NULL; ++i)
3307 static int test_vgremove_1 (void)
3309 /* InitNone|InitEmpty for test_vgremove_1 */
3311 char device[] = "/dev/sda";
3312 device[5] = devchar;
3315 r = guestfs_blockdev_setrw (g, device);
3322 r = guestfs_umount_all (g);
3329 r = guestfs_lvm_remove_all (g);
3333 /* TestOutputList for vgremove (1) */
3335 char device[] = "/dev/sda";
3336 device[5] = devchar;
3339 r = guestfs_pvcreate (g, device);
3344 char volgroup[] = "VG";
3345 char physvols_0[] = "/dev/sda";
3346 physvols_0[5] = devchar;
3347 char *physvols[] = {
3353 r = guestfs_vgcreate (g, volgroup, physvols);
3358 char logvol[] = "LV1";
3359 char volgroup[] = "VG";
3362 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3367 char logvol[] = "LV2";
3368 char volgroup[] = "VG";
3371 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3376 char vgname[] = "VG";
3379 r = guestfs_vgremove (g, vgname);
3387 r = guestfs_vgs (g);
3391 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3395 for (i = 0; r[i] != NULL; ++i)
3402 static int test_lvremove_0 (void)
3404 /* InitNone|InitEmpty for test_lvremove_0 */
3406 char device[] = "/dev/sda";
3407 device[5] = devchar;
3410 r = guestfs_blockdev_setrw (g, device);
3417 r = guestfs_umount_all (g);
3424 r = guestfs_lvm_remove_all (g);
3428 /* TestOutputList for lvremove (0) */
3430 char device[] = "/dev/sda";
3431 device[5] = devchar;
3434 r = guestfs_pvcreate (g, device);
3439 char volgroup[] = "VG";
3440 char physvols_0[] = "/dev/sda";
3441 physvols_0[5] = devchar;
3442 char *physvols[] = {
3448 r = guestfs_vgcreate (g, volgroup, physvols);
3453 char logvol[] = "LV1";
3454 char volgroup[] = "VG";
3457 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3462 char logvol[] = "LV2";
3463 char volgroup[] = "VG";
3466 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3471 char device[] = "/dev/VG/LV1";
3474 r = guestfs_lvremove (g, device);
3482 r = guestfs_lvs (g);
3486 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3491 char expected[] = "/dev/VG/LV2";
3492 if (strcmp (r[0], expected) != 0) {
3493 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3498 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3502 for (i = 0; r[i] != NULL; ++i)
3509 static int test_lvremove_1 (void)
3511 /* InitNone|InitEmpty for test_lvremove_1 */
3513 char device[] = "/dev/sda";
3514 device[5] = devchar;
3517 r = guestfs_blockdev_setrw (g, device);
3524 r = guestfs_umount_all (g);
3531 r = guestfs_lvm_remove_all (g);
3535 /* TestOutputList for lvremove (1) */
3537 char device[] = "/dev/sda";
3538 device[5] = devchar;
3541 r = guestfs_pvcreate (g, device);
3546 char volgroup[] = "VG";
3547 char physvols_0[] = "/dev/sda";
3548 physvols_0[5] = devchar;
3549 char *physvols[] = {
3555 r = guestfs_vgcreate (g, volgroup, physvols);
3560 char logvol[] = "LV1";
3561 char volgroup[] = "VG";
3564 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3569 char logvol[] = "LV2";
3570 char volgroup[] = "VG";
3573 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3578 char device[] = "/dev/VG";
3581 r = guestfs_lvremove (g, device);
3589 r = guestfs_lvs (g);
3593 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3597 for (i = 0; r[i] != NULL; ++i)
3604 static int test_lvremove_2 (void)
3606 /* InitNone|InitEmpty for test_lvremove_2 */
3608 char device[] = "/dev/sda";
3609 device[5] = devchar;
3612 r = guestfs_blockdev_setrw (g, device);
3619 r = guestfs_umount_all (g);
3626 r = guestfs_lvm_remove_all (g);
3630 /* TestOutputList for lvremove (2) */
3632 char device[] = "/dev/sda";
3633 device[5] = devchar;
3636 r = guestfs_pvcreate (g, device);
3641 char volgroup[] = "VG";
3642 char physvols_0[] = "/dev/sda";
3643 physvols_0[5] = devchar;
3644 char *physvols[] = {
3650 r = guestfs_vgcreate (g, volgroup, physvols);
3655 char logvol[] = "LV1";
3656 char volgroup[] = "VG";
3659 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3664 char logvol[] = "LV2";
3665 char volgroup[] = "VG";
3668 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3673 char device[] = "/dev/VG";
3676 r = guestfs_lvremove (g, device);
3684 r = guestfs_vgs (g);
3688 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3693 char expected[] = "VG";
3694 if (strcmp (r[0], expected) != 0) {
3695 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3700 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3704 for (i = 0; r[i] != NULL; ++i)
3711 static int test_mount_ro_0 (void)
3713 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3715 char device[] = "/dev/sda";
3716 device[5] = devchar;
3719 r = guestfs_blockdev_setrw (g, device);
3726 r = guestfs_umount_all (g);
3733 r = guestfs_lvm_remove_all (g);
3738 char device[] = "/dev/sda";
3739 device[5] = devchar;
3740 char lines_0[] = ",";
3747 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3752 char fstype[] = "ext2";
3753 char device[] = "/dev/sda1";
3754 device[5] = devchar;
3757 r = guestfs_mkfs (g, fstype, device);
3762 char device[] = "/dev/sda1";
3763 device[5] = devchar;
3764 char mountpoint[] = "/";
3767 r = guestfs_mount (g, device, mountpoint);
3771 /* TestLastFail for mount_ro (0) */
3773 char pathordevice[] = "/";
3776 r = guestfs_umount (g, pathordevice);
3781 char device[] = "/dev/sda1";
3782 device[5] = devchar;
3783 char mountpoint[] = "/";
3786 r = guestfs_mount_ro (g, device, mountpoint);
3791 char path[] = "/new";
3794 r = guestfs_touch (g, path);
3801 static int test_mount_ro_1 (void)
3803 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3805 char device[] = "/dev/sda";
3806 device[5] = devchar;
3809 r = guestfs_blockdev_setrw (g, device);
3816 r = guestfs_umount_all (g);
3823 r = guestfs_lvm_remove_all (g);
3828 char device[] = "/dev/sda";
3829 device[5] = devchar;
3830 char lines_0[] = ",";
3837 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3842 char fstype[] = "ext2";
3843 char device[] = "/dev/sda1";
3844 device[5] = devchar;
3847 r = guestfs_mkfs (g, fstype, device);
3852 char device[] = "/dev/sda1";
3853 device[5] = devchar;
3854 char mountpoint[] = "/";
3857 r = guestfs_mount (g, device, mountpoint);
3861 /* TestOutput for mount_ro (1) */
3862 char expected[] = "data";
3864 char path[] = "/new";
3865 char content[] = "data";
3868 r = guestfs_write_file (g, path, content, 0);
3873 char pathordevice[] = "/";
3876 r = guestfs_umount (g, pathordevice);
3881 char device[] = "/dev/sda1";
3882 device[5] = devchar;
3883 char mountpoint[] = "/";
3886 r = guestfs_mount_ro (g, device, mountpoint);
3891 char path[] = "/new";
3894 r = guestfs_cat (g, path);
3897 if (strcmp (r, expected) != 0) {
3898 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3906 static int test_tgz_in_0 (void)
3908 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
3910 char device[] = "/dev/sda";
3911 device[5] = devchar;
3914 r = guestfs_blockdev_setrw (g, device);
3921 r = guestfs_umount_all (g);
3928 r = guestfs_lvm_remove_all (g);
3933 char device[] = "/dev/sda";
3934 device[5] = devchar;
3935 char lines_0[] = ",";
3942 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3947 char fstype[] = "ext2";
3948 char device[] = "/dev/sda1";
3949 device[5] = devchar;
3952 r = guestfs_mkfs (g, fstype, device);
3957 char device[] = "/dev/sda1";
3958 device[5] = devchar;
3959 char mountpoint[] = "/";
3962 r = guestfs_mount (g, device, mountpoint);
3966 /* TestOutput for tgz_in (0) */
3967 char expected[] = "hello\n";
3969 char directory[] = "/";
3972 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3977 char path[] = "/hello";
3980 r = guestfs_cat (g, path);
3983 if (strcmp (r, expected) != 0) {
3984 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3992 static int test_tar_in_0 (void)
3994 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
3996 char device[] = "/dev/sda";
3997 device[5] = devchar;
4000 r = guestfs_blockdev_setrw (g, device);
4007 r = guestfs_umount_all (g);
4014 r = guestfs_lvm_remove_all (g);
4019 char device[] = "/dev/sda";
4020 device[5] = devchar;
4021 char lines_0[] = ",";
4028 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4033 char fstype[] = "ext2";
4034 char device[] = "/dev/sda1";
4035 device[5] = devchar;
4038 r = guestfs_mkfs (g, fstype, device);
4043 char device[] = "/dev/sda1";
4044 device[5] = devchar;
4045 char mountpoint[] = "/";
4048 r = guestfs_mount (g, device, mountpoint);
4052 /* TestOutput for tar_in (0) */
4053 char expected[] = "hello\n";
4055 char directory[] = "/";
4058 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
4063 char path[] = "/hello";
4066 r = guestfs_cat (g, path);
4069 if (strcmp (r, expected) != 0) {
4070 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4078 static int test_checksum_0 (void)
4080 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4082 char device[] = "/dev/sda";
4083 device[5] = devchar;
4086 r = guestfs_blockdev_setrw (g, device);
4093 r = guestfs_umount_all (g);
4100 r = guestfs_lvm_remove_all (g);
4105 char device[] = "/dev/sda";
4106 device[5] = devchar;
4107 char lines_0[] = ",";
4114 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4119 char fstype[] = "ext2";
4120 char device[] = "/dev/sda1";
4121 device[5] = devchar;
4124 r = guestfs_mkfs (g, fstype, device);
4129 char device[] = "/dev/sda1";
4130 device[5] = devchar;
4131 char mountpoint[] = "/";
4134 r = guestfs_mount (g, device, mountpoint);
4138 /* TestOutput for checksum (0) */
4139 char expected[] = "935282863";
4141 char path[] = "/new";
4142 char content[] = "test\n";
4145 r = guestfs_write_file (g, path, content, 0);
4150 char csumtype[] = "crc";
4151 char path[] = "/new";
4154 r = guestfs_checksum (g, csumtype, path);
4157 if (strcmp (r, expected) != 0) {
4158 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
4166 static int test_checksum_1 (void)
4168 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
4170 char device[] = "/dev/sda";
4171 device[5] = devchar;
4174 r = guestfs_blockdev_setrw (g, device);
4181 r = guestfs_umount_all (g);
4188 r = guestfs_lvm_remove_all (g);
4193 char device[] = "/dev/sda";
4194 device[5] = devchar;
4195 char lines_0[] = ",";
4202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4207 char fstype[] = "ext2";
4208 char device[] = "/dev/sda1";
4209 device[5] = devchar;
4212 r = guestfs_mkfs (g, fstype, device);
4217 char device[] = "/dev/sda1";
4218 device[5] = devchar;
4219 char mountpoint[] = "/";
4222 r = guestfs_mount (g, device, mountpoint);
4226 /* TestLastFail for checksum (1) */
4228 char csumtype[] = "crc";
4229 char path[] = "/new";
4232 r = guestfs_checksum (g, csumtype, path);
4240 static int test_checksum_2 (void)
4242 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
4244 char device[] = "/dev/sda";
4245 device[5] = devchar;
4248 r = guestfs_blockdev_setrw (g, device);
4255 r = guestfs_umount_all (g);
4262 r = guestfs_lvm_remove_all (g);
4267 char device[] = "/dev/sda";
4268 device[5] = devchar;
4269 char lines_0[] = ",";
4276 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4281 char fstype[] = "ext2";
4282 char device[] = "/dev/sda1";
4283 device[5] = devchar;
4286 r = guestfs_mkfs (g, fstype, device);
4291 char device[] = "/dev/sda1";
4292 device[5] = devchar;
4293 char mountpoint[] = "/";
4296 r = guestfs_mount (g, device, mountpoint);
4300 /* TestOutput for checksum (2) */
4301 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
4303 char path[] = "/new";
4304 char content[] = "test\n";
4307 r = guestfs_write_file (g, path, content, 0);
4312 char csumtype[] = "md5";
4313 char path[] = "/new";
4316 r = guestfs_checksum (g, csumtype, path);
4319 if (strcmp (r, expected) != 0) {
4320 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
4328 static int test_checksum_3 (void)
4330 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
4332 char device[] = "/dev/sda";
4333 device[5] = devchar;
4336 r = guestfs_blockdev_setrw (g, device);
4343 r = guestfs_umount_all (g);
4350 r = guestfs_lvm_remove_all (g);
4355 char device[] = "/dev/sda";
4356 device[5] = devchar;
4357 char lines_0[] = ",";
4364 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4369 char fstype[] = "ext2";
4370 char device[] = "/dev/sda1";
4371 device[5] = devchar;
4374 r = guestfs_mkfs (g, fstype, device);
4379 char device[] = "/dev/sda1";
4380 device[5] = devchar;
4381 char mountpoint[] = "/";
4384 r = guestfs_mount (g, device, mountpoint);
4388 /* TestOutput for checksum (3) */
4389 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4391 char path[] = "/new";
4392 char content[] = "test\n";
4395 r = guestfs_write_file (g, path, content, 0);
4400 char csumtype[] = "sha1";
4401 char path[] = "/new";
4404 r = guestfs_checksum (g, csumtype, path);
4407 if (strcmp (r, expected) != 0) {
4408 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4416 static int test_checksum_4 (void)
4418 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4420 char device[] = "/dev/sda";
4421 device[5] = devchar;
4424 r = guestfs_blockdev_setrw (g, device);
4431 r = guestfs_umount_all (g);
4438 r = guestfs_lvm_remove_all (g);
4443 char device[] = "/dev/sda";
4444 device[5] = devchar;
4445 char lines_0[] = ",";
4452 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4457 char fstype[] = "ext2";
4458 char device[] = "/dev/sda1";
4459 device[5] = devchar;
4462 r = guestfs_mkfs (g, fstype, device);
4467 char device[] = "/dev/sda1";
4468 device[5] = devchar;
4469 char mountpoint[] = "/";
4472 r = guestfs_mount (g, device, mountpoint);
4476 /* TestOutput for checksum (4) */
4477 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4479 char path[] = "/new";
4480 char content[] = "test\n";
4483 r = guestfs_write_file (g, path, content, 0);
4488 char csumtype[] = "sha224";
4489 char path[] = "/new";
4492 r = guestfs_checksum (g, csumtype, path);
4495 if (strcmp (r, expected) != 0) {
4496 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4504 static int test_checksum_5 (void)
4506 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4508 char device[] = "/dev/sda";
4509 device[5] = devchar;
4512 r = guestfs_blockdev_setrw (g, device);
4519 r = guestfs_umount_all (g);
4526 r = guestfs_lvm_remove_all (g);
4531 char device[] = "/dev/sda";
4532 device[5] = devchar;
4533 char lines_0[] = ",";
4540 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4545 char fstype[] = "ext2";
4546 char device[] = "/dev/sda1";
4547 device[5] = devchar;
4550 r = guestfs_mkfs (g, fstype, device);
4555 char device[] = "/dev/sda1";
4556 device[5] = devchar;
4557 char mountpoint[] = "/";
4560 r = guestfs_mount (g, device, mountpoint);
4564 /* TestOutput for checksum (5) */
4565 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4567 char path[] = "/new";
4568 char content[] = "test\n";
4571 r = guestfs_write_file (g, path, content, 0);
4576 char csumtype[] = "sha256";
4577 char path[] = "/new";
4580 r = guestfs_checksum (g, csumtype, path);
4583 if (strcmp (r, expected) != 0) {
4584 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4592 static int test_checksum_6 (void)
4594 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4596 char device[] = "/dev/sda";
4597 device[5] = devchar;
4600 r = guestfs_blockdev_setrw (g, device);
4607 r = guestfs_umount_all (g);
4614 r = guestfs_lvm_remove_all (g);
4619 char device[] = "/dev/sda";
4620 device[5] = devchar;
4621 char lines_0[] = ",";
4628 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4633 char fstype[] = "ext2";
4634 char device[] = "/dev/sda1";
4635 device[5] = devchar;
4638 r = guestfs_mkfs (g, fstype, device);
4643 char device[] = "/dev/sda1";
4644 device[5] = devchar;
4645 char mountpoint[] = "/";
4648 r = guestfs_mount (g, device, mountpoint);
4652 /* TestOutput for checksum (6) */
4653 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4655 char path[] = "/new";
4656 char content[] = "test\n";
4659 r = guestfs_write_file (g, path, content, 0);
4664 char csumtype[] = "sha384";
4665 char path[] = "/new";
4668 r = guestfs_checksum (g, csumtype, path);
4671 if (strcmp (r, expected) != 0) {
4672 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4680 static int test_checksum_7 (void)
4682 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4684 char device[] = "/dev/sda";
4685 device[5] = devchar;
4688 r = guestfs_blockdev_setrw (g, device);
4695 r = guestfs_umount_all (g);
4702 r = guestfs_lvm_remove_all (g);
4707 char device[] = "/dev/sda";
4708 device[5] = devchar;
4709 char lines_0[] = ",";
4716 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4721 char fstype[] = "ext2";
4722 char device[] = "/dev/sda1";
4723 device[5] = devchar;
4726 r = guestfs_mkfs (g, fstype, device);
4731 char device[] = "/dev/sda1";
4732 device[5] = devchar;
4733 char mountpoint[] = "/";
4736 r = guestfs_mount (g, device, mountpoint);
4740 /* TestOutput for checksum (7) */
4741 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4743 char path[] = "/new";
4744 char content[] = "test\n";
4747 r = guestfs_write_file (g, path, content, 0);
4752 char csumtype[] = "sha512";
4753 char path[] = "/new";
4756 r = guestfs_checksum (g, csumtype, path);
4759 if (strcmp (r, expected) != 0) {
4760 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4768 static int test_download_0 (void)
4770 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4772 char device[] = "/dev/sda";
4773 device[5] = devchar;
4776 r = guestfs_blockdev_setrw (g, device);
4783 r = guestfs_umount_all (g);
4790 r = guestfs_lvm_remove_all (g);
4795 char device[] = "/dev/sda";
4796 device[5] = devchar;
4797 char lines_0[] = ",";
4804 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4809 char fstype[] = "ext2";
4810 char device[] = "/dev/sda1";
4811 device[5] = devchar;
4814 r = guestfs_mkfs (g, fstype, device);
4819 char device[] = "/dev/sda1";
4820 device[5] = devchar;
4821 char mountpoint[] = "/";
4824 r = guestfs_mount (g, device, mountpoint);
4828 /* TestOutput for download (0) */
4829 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4831 char remotefilename[] = "/COPYING.LIB";
4834 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4839 char remotefilename[] = "/COPYING.LIB";
4842 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4847 char remotefilename[] = "/upload";
4850 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4855 char csumtype[] = "md5";
4856 char path[] = "/upload";
4859 r = guestfs_checksum (g, csumtype, path);
4862 if (strcmp (r, expected) != 0) {
4863 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4871 static int test_upload_0 (void)
4873 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
4875 char device[] = "/dev/sda";
4876 device[5] = devchar;
4879 r = guestfs_blockdev_setrw (g, device);
4886 r = guestfs_umount_all (g);
4893 r = guestfs_lvm_remove_all (g);
4898 char device[] = "/dev/sda";
4899 device[5] = devchar;
4900 char lines_0[] = ",";
4907 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4912 char fstype[] = "ext2";
4913 char device[] = "/dev/sda1";
4914 device[5] = devchar;
4917 r = guestfs_mkfs (g, fstype, device);
4922 char device[] = "/dev/sda1";
4923 device[5] = devchar;
4924 char mountpoint[] = "/";
4927 r = guestfs_mount (g, device, mountpoint);
4931 /* TestOutput for upload (0) */
4932 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4934 char remotefilename[] = "/COPYING.LIB";
4937 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4942 char csumtype[] = "md5";
4943 char path[] = "/COPYING.LIB";
4946 r = guestfs_checksum (g, csumtype, path);
4949 if (strcmp (r, expected) != 0) {
4950 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4958 static int test_blockdev_rereadpt_0 (void)
4960 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
4962 char device[] = "/dev/sda";
4963 device[5] = devchar;
4966 r = guestfs_blockdev_setrw (g, device);
4973 r = guestfs_umount_all (g);
4980 r = guestfs_lvm_remove_all (g);
4984 /* TestRun for blockdev_rereadpt (0) */
4986 char device[] = "/dev/sda";
4987 device[5] = devchar;
4990 r = guestfs_blockdev_rereadpt (g, device);
4997 static int test_blockdev_flushbufs_0 (void)
4999 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
5001 char device[] = "/dev/sda";
5002 device[5] = devchar;
5005 r = guestfs_blockdev_setrw (g, device);
5012 r = guestfs_umount_all (g);
5019 r = guestfs_lvm_remove_all (g);
5023 /* TestRun for blockdev_flushbufs (0) */
5025 char device[] = "/dev/sda";
5026 device[5] = devchar;
5029 r = guestfs_blockdev_flushbufs (g, device);
5036 static int test_blockdev_getsize64_0 (void)
5038 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
5040 char device[] = "/dev/sda";
5041 device[5] = devchar;
5044 r = guestfs_blockdev_setrw (g, device);
5051 r = guestfs_umount_all (g);
5058 r = guestfs_lvm_remove_all (g);
5062 /* TestOutputInt for blockdev_getsize64 (0) */
5064 char device[] = "/dev/sda";
5065 device[5] = devchar;
5068 r = guestfs_blockdev_getsize64 (g, device);
5071 if (r != 524288000) {
5072 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
5079 static int test_blockdev_getsz_0 (void)
5081 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
5083 char device[] = "/dev/sda";
5084 device[5] = devchar;
5087 r = guestfs_blockdev_setrw (g, device);
5094 r = guestfs_umount_all (g);
5101 r = guestfs_lvm_remove_all (g);
5105 /* TestOutputInt for blockdev_getsz (0) */
5107 char device[] = "/dev/sda";
5108 device[5] = devchar;
5111 r = guestfs_blockdev_getsz (g, device);
5115 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
5122 static int test_blockdev_getbsz_0 (void)
5124 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
5126 char device[] = "/dev/sda";
5127 device[5] = devchar;
5130 r = guestfs_blockdev_setrw (g, device);
5137 r = guestfs_umount_all (g);
5144 r = guestfs_lvm_remove_all (g);
5148 /* TestOutputInt for blockdev_getbsz (0) */
5150 char device[] = "/dev/sda";
5151 device[5] = devchar;
5154 r = guestfs_blockdev_getbsz (g, device);
5158 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
5165 static int test_blockdev_getss_0 (void)
5167 /* InitNone|InitEmpty for test_blockdev_getss_0 */
5169 char device[] = "/dev/sda";
5170 device[5] = devchar;
5173 r = guestfs_blockdev_setrw (g, device);
5180 r = guestfs_umount_all (g);
5187 r = guestfs_lvm_remove_all (g);
5191 /* TestOutputInt for blockdev_getss (0) */
5193 char device[] = "/dev/sda";
5194 device[5] = devchar;
5197 r = guestfs_blockdev_getss (g, device);
5201 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
5208 static int test_blockdev_getro_0 (void)
5210 /* InitNone|InitEmpty for test_blockdev_getro_0 */
5212 char device[] = "/dev/sda";
5213 device[5] = devchar;
5216 r = guestfs_blockdev_setrw (g, device);
5223 r = guestfs_umount_all (g);
5230 r = guestfs_lvm_remove_all (g);
5234 /* TestOutputTrue for blockdev_getro (0) */
5236 char device[] = "/dev/sda";
5237 device[5] = devchar;
5240 r = guestfs_blockdev_setro (g, device);
5245 char device[] = "/dev/sda";
5246 device[5] = devchar;
5249 r = guestfs_blockdev_getro (g, device);
5253 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
5260 static int test_blockdev_setrw_0 (void)
5262 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
5264 char device[] = "/dev/sda";
5265 device[5] = devchar;
5268 r = guestfs_blockdev_setrw (g, device);
5275 r = guestfs_umount_all (g);
5282 r = guestfs_lvm_remove_all (g);
5286 /* TestOutputFalse for blockdev_setrw (0) */
5288 char device[] = "/dev/sda";
5289 device[5] = devchar;
5292 r = guestfs_blockdev_setrw (g, device);
5297 char device[] = "/dev/sda";
5298 device[5] = devchar;
5301 r = guestfs_blockdev_getro (g, device);
5305 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
5312 static int test_blockdev_setro_0 (void)
5314 /* InitNone|InitEmpty for test_blockdev_setro_0 */
5316 char device[] = "/dev/sda";
5317 device[5] = devchar;
5320 r = guestfs_blockdev_setrw (g, device);
5327 r = guestfs_umount_all (g);
5334 r = guestfs_lvm_remove_all (g);
5338 /* TestOutputTrue for blockdev_setro (0) */
5340 char device[] = "/dev/sda";
5341 device[5] = devchar;
5344 r = guestfs_blockdev_setro (g, device);
5349 char device[] = "/dev/sda";
5350 device[5] = devchar;
5353 r = guestfs_blockdev_getro (g, device);
5357 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
5364 static int test_statvfs_0 (void)
5366 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
5368 char device[] = "/dev/sda";
5369 device[5] = devchar;
5372 r = guestfs_blockdev_setrw (g, device);
5379 r = guestfs_umount_all (g);
5386 r = guestfs_lvm_remove_all (g);
5391 char device[] = "/dev/sda";
5392 device[5] = devchar;
5393 char lines_0[] = ",";
5400 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5405 char fstype[] = "ext2";
5406 char device[] = "/dev/sda1";
5407 device[5] = devchar;
5410 r = guestfs_mkfs (g, fstype, device);
5415 char device[] = "/dev/sda1";
5416 device[5] = devchar;
5417 char mountpoint[] = "/";
5420 r = guestfs_mount (g, device, mountpoint);
5424 /* TestOutputStruct for statvfs (0) */
5427 struct guestfs_statvfs *r;
5429 r = guestfs_statvfs (g, path);
5432 if (r->bfree != 487702) {
5433 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5437 if (r->blocks != 490020) {
5438 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5442 if (r->bsize != 1024) {
5443 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5452 static int test_lstat_0 (void)
5454 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5456 char device[] = "/dev/sda";
5457 device[5] = devchar;
5460 r = guestfs_blockdev_setrw (g, device);
5467 r = guestfs_umount_all (g);
5474 r = guestfs_lvm_remove_all (g);
5479 char device[] = "/dev/sda";
5480 device[5] = devchar;
5481 char lines_0[] = ",";
5488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5493 char fstype[] = "ext2";
5494 char device[] = "/dev/sda1";
5495 device[5] = devchar;
5498 r = guestfs_mkfs (g, fstype, device);
5503 char device[] = "/dev/sda1";
5504 device[5] = devchar;
5505 char mountpoint[] = "/";
5508 r = guestfs_mount (g, device, mountpoint);
5512 /* TestOutputStruct for lstat (0) */
5514 char path[] = "/new";
5517 r = guestfs_touch (g, path);
5522 char path[] = "/new";
5523 struct guestfs_stat *r;
5525 r = guestfs_lstat (g, path);
5529 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5538 static int test_stat_0 (void)
5540 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5542 char device[] = "/dev/sda";
5543 device[5] = devchar;
5546 r = guestfs_blockdev_setrw (g, device);
5553 r = guestfs_umount_all (g);
5560 r = guestfs_lvm_remove_all (g);
5565 char device[] = "/dev/sda";
5566 device[5] = devchar;
5567 char lines_0[] = ",";
5574 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5579 char fstype[] = "ext2";
5580 char device[] = "/dev/sda1";
5581 device[5] = devchar;
5584 r = guestfs_mkfs (g, fstype, device);
5589 char device[] = "/dev/sda1";
5590 device[5] = devchar;
5591 char mountpoint[] = "/";
5594 r = guestfs_mount (g, device, mountpoint);
5598 /* TestOutputStruct for stat (0) */
5600 char path[] = "/new";
5603 r = guestfs_touch (g, path);
5608 char path[] = "/new";
5609 struct guestfs_stat *r;
5611 r = guestfs_stat (g, path);
5615 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5624 static int test_command_lines_0_prereq (void)
5626 const char *str = getenv ("SKIP_TEST_COMMAND");
5627 return str && strcmp (str, "1") == 0;
5630 static int test_command_lines_0 (void)
5632 if (! test_command_lines_0_prereq ()) {
5633 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5635 char device[] = "/dev/sda";
5636 device[5] = devchar;
5639 r = guestfs_blockdev_setrw (g, device);
5646 r = guestfs_umount_all (g);
5653 r = guestfs_lvm_remove_all (g);
5658 char device[] = "/dev/sda";
5659 device[5] = devchar;
5660 char lines_0[] = ",";
5667 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5672 char fstype[] = "ext2";
5673 char device[] = "/dev/sda1";
5674 device[5] = devchar;
5677 r = guestfs_mkfs (g, fstype, device);
5682 char device[] = "/dev/sda1";
5683 device[5] = devchar;
5684 char mountpoint[] = "/";
5687 r = guestfs_mount (g, device, mountpoint);
5691 /* TestOutputList for command_lines (0) */
5693 char remotefilename[] = "/test-command";
5696 r = guestfs_upload (g, "test-command", remotefilename);
5701 char path[] = "/test-command";
5704 r = guestfs_chmod (g, 493, path);
5709 char arguments_0[] = "/test-command";
5710 char arguments_1[] = "1";
5711 char *arguments[] = {
5719 r = guestfs_command_lines (g, arguments);
5723 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5728 char expected[] = "Result1";
5729 if (strcmp (r[0], expected) != 0) {
5730 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5735 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5739 for (i = 0; r[i] != NULL; ++i)
5744 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5748 static int test_command_lines_1_prereq (void)
5750 const char *str = getenv ("SKIP_TEST_COMMAND");
5751 return str && strcmp (str, "1") == 0;
5754 static int test_command_lines_1 (void)
5756 if (! test_command_lines_1_prereq ()) {
5757 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5759 char device[] = "/dev/sda";
5760 device[5] = devchar;
5763 r = guestfs_blockdev_setrw (g, device);
5770 r = guestfs_umount_all (g);
5777 r = guestfs_lvm_remove_all (g);
5782 char device[] = "/dev/sda";
5783 device[5] = devchar;
5784 char lines_0[] = ",";
5791 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5796 char fstype[] = "ext2";
5797 char device[] = "/dev/sda1";
5798 device[5] = devchar;
5801 r = guestfs_mkfs (g, fstype, device);
5806 char device[] = "/dev/sda1";
5807 device[5] = devchar;
5808 char mountpoint[] = "/";
5811 r = guestfs_mount (g, device, mountpoint);
5815 /* TestOutputList for command_lines (1) */
5817 char remotefilename[] = "/test-command";
5820 r = guestfs_upload (g, "test-command", remotefilename);
5825 char path[] = "/test-command";
5828 r = guestfs_chmod (g, 493, path);
5833 char arguments_0[] = "/test-command";
5834 char arguments_1[] = "2";
5835 char *arguments[] = {
5843 r = guestfs_command_lines (g, arguments);
5847 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5852 char expected[] = "Result2";
5853 if (strcmp (r[0], expected) != 0) {
5854 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5859 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5863 for (i = 0; r[i] != NULL; ++i)
5868 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5872 static int test_command_lines_2_prereq (void)
5874 const char *str = getenv ("SKIP_TEST_COMMAND");
5875 return str && strcmp (str, "1") == 0;
5878 static int test_command_lines_2 (void)
5880 if (! test_command_lines_2_prereq ()) {
5881 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
5883 char device[] = "/dev/sda";
5884 device[5] = devchar;
5887 r = guestfs_blockdev_setrw (g, device);
5894 r = guestfs_umount_all (g);
5901 r = guestfs_lvm_remove_all (g);
5906 char device[] = "/dev/sda";
5907 device[5] = devchar;
5908 char lines_0[] = ",";
5915 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5920 char fstype[] = "ext2";
5921 char device[] = "/dev/sda1";
5922 device[5] = devchar;
5925 r = guestfs_mkfs (g, fstype, device);
5930 char device[] = "/dev/sda1";
5931 device[5] = devchar;
5932 char mountpoint[] = "/";
5935 r = guestfs_mount (g, device, mountpoint);
5939 /* TestOutputList for command_lines (2) */
5941 char remotefilename[] = "/test-command";
5944 r = guestfs_upload (g, "test-command", remotefilename);
5949 char path[] = "/test-command";
5952 r = guestfs_chmod (g, 493, path);
5957 char arguments_0[] = "/test-command";
5958 char arguments_1[] = "3";
5959 char *arguments[] = {
5967 r = guestfs_command_lines (g, arguments);
5971 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5976 char expected[] = "";
5977 if (strcmp (r[0], expected) != 0) {
5978 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5983 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5988 char expected[] = "Result3";
5989 if (strcmp (r[1], expected) != 0) {
5990 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5995 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5999 for (i = 0; r[i] != NULL; ++i)
6004 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
6008 static int test_command_lines_3_prereq (void)
6010 const char *str = getenv ("SKIP_TEST_COMMAND");
6011 return str && strcmp (str, "1") == 0;
6014 static int test_command_lines_3 (void)
6016 if (! test_command_lines_3_prereq ()) {
6017 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
6019 char device[] = "/dev/sda";
6020 device[5] = devchar;
6023 r = guestfs_blockdev_setrw (g, device);
6030 r = guestfs_umount_all (g);
6037 r = guestfs_lvm_remove_all (g);
6042 char device[] = "/dev/sda";
6043 device[5] = devchar;
6044 char lines_0[] = ",";
6051 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6056 char fstype[] = "ext2";
6057 char device[] = "/dev/sda1";
6058 device[5] = devchar;
6061 r = guestfs_mkfs (g, fstype, device);
6066 char device[] = "/dev/sda1";
6067 device[5] = devchar;
6068 char mountpoint[] = "/";
6071 r = guestfs_mount (g, device, mountpoint);
6075 /* TestOutputList for command_lines (3) */
6077 char remotefilename[] = "/test-command";
6080 r = guestfs_upload (g, "test-command", remotefilename);
6085 char path[] = "/test-command";
6088 r = guestfs_chmod (g, 493, path);
6093 char arguments_0[] = "/test-command";
6094 char arguments_1[] = "4";
6095 char *arguments[] = {
6103 r = guestfs_command_lines (g, arguments);
6107 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6112 char expected[] = "";
6113 if (strcmp (r[0], expected) != 0) {
6114 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6119 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
6124 char expected[] = "Result4";
6125 if (strcmp (r[1], expected) != 0) {
6126 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6131 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
6135 for (i = 0; r[i] != NULL; ++i)
6140 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
6144 static int test_command_lines_4_prereq (void)
6146 const char *str = getenv ("SKIP_TEST_COMMAND");
6147 return str && strcmp (str, "1") == 0;
6150 static int test_command_lines_4 (void)
6152 if (! test_command_lines_4_prereq ()) {
6153 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
6155 char device[] = "/dev/sda";
6156 device[5] = devchar;
6159 r = guestfs_blockdev_setrw (g, device);
6166 r = guestfs_umount_all (g);
6173 r = guestfs_lvm_remove_all (g);
6178 char device[] = "/dev/sda";
6179 device[5] = devchar;
6180 char lines_0[] = ",";
6187 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6192 char fstype[] = "ext2";
6193 char device[] = "/dev/sda1";
6194 device[5] = devchar;
6197 r = guestfs_mkfs (g, fstype, device);
6202 char device[] = "/dev/sda1";
6203 device[5] = devchar;
6204 char mountpoint[] = "/";
6207 r = guestfs_mount (g, device, mountpoint);
6211 /* TestOutputList for command_lines (4) */
6213 char remotefilename[] = "/test-command";
6216 r = guestfs_upload (g, "test-command", remotefilename);
6221 char path[] = "/test-command";
6224 r = guestfs_chmod (g, 493, path);
6229 char arguments_0[] = "/test-command";
6230 char arguments_1[] = "5";
6231 char *arguments[] = {
6239 r = guestfs_command_lines (g, arguments);
6243 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6248 char expected[] = "";
6249 if (strcmp (r[0], expected) != 0) {
6250 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6255 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6260 char expected[] = "Result5";
6261 if (strcmp (r[1], expected) != 0) {
6262 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6267 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
6272 char expected[] = "";
6273 if (strcmp (r[2], expected) != 0) {
6274 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6279 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
6283 for (i = 0; r[i] != NULL; ++i)
6288 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
6292 static int test_command_lines_5_prereq (void)
6294 const char *str = getenv ("SKIP_TEST_COMMAND");
6295 return str && strcmp (str, "1") == 0;
6298 static int test_command_lines_5 (void)
6300 if (! test_command_lines_5_prereq ()) {
6301 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
6303 char device[] = "/dev/sda";
6304 device[5] = devchar;
6307 r = guestfs_blockdev_setrw (g, device);
6314 r = guestfs_umount_all (g);
6321 r = guestfs_lvm_remove_all (g);
6326 char device[] = "/dev/sda";
6327 device[5] = devchar;
6328 char lines_0[] = ",";
6335 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6340 char fstype[] = "ext2";
6341 char device[] = "/dev/sda1";
6342 device[5] = devchar;
6345 r = guestfs_mkfs (g, fstype, device);
6350 char device[] = "/dev/sda1";
6351 device[5] = devchar;
6352 char mountpoint[] = "/";
6355 r = guestfs_mount (g, device, mountpoint);
6359 /* TestOutputList for command_lines (5) */
6361 char remotefilename[] = "/test-command";
6364 r = guestfs_upload (g, "test-command", remotefilename);
6369 char path[] = "/test-command";
6372 r = guestfs_chmod (g, 493, path);
6377 char arguments_0[] = "/test-command";
6378 char arguments_1[] = "6";
6379 char *arguments[] = {
6387 r = guestfs_command_lines (g, arguments);
6391 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6396 char expected[] = "";
6397 if (strcmp (r[0], expected) != 0) {
6398 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6403 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6408 char expected[] = "";
6409 if (strcmp (r[1], expected) != 0) {
6410 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6415 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6420 char expected[] = "Result6";
6421 if (strcmp (r[2], expected) != 0) {
6422 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6427 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6432 char expected[] = "";
6433 if (strcmp (r[3], expected) != 0) {
6434 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6439 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6443 for (i = 0; r[i] != NULL; ++i)
6448 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6452 static int test_command_lines_6_prereq (void)
6454 const char *str = getenv ("SKIP_TEST_COMMAND");
6455 return str && strcmp (str, "1") == 0;
6458 static int test_command_lines_6 (void)
6460 if (! test_command_lines_6_prereq ()) {
6461 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6463 char device[] = "/dev/sda";
6464 device[5] = devchar;
6467 r = guestfs_blockdev_setrw (g, device);
6474 r = guestfs_umount_all (g);
6481 r = guestfs_lvm_remove_all (g);
6486 char device[] = "/dev/sda";
6487 device[5] = devchar;
6488 char lines_0[] = ",";
6495 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6500 char fstype[] = "ext2";
6501 char device[] = "/dev/sda1";
6502 device[5] = devchar;
6505 r = guestfs_mkfs (g, fstype, device);
6510 char device[] = "/dev/sda1";
6511 device[5] = devchar;
6512 char mountpoint[] = "/";
6515 r = guestfs_mount (g, device, mountpoint);
6519 /* TestOutputList for command_lines (6) */
6521 char remotefilename[] = "/test-command";
6524 r = guestfs_upload (g, "test-command", remotefilename);
6529 char path[] = "/test-command";
6532 r = guestfs_chmod (g, 493, path);
6537 char arguments_0[] = "/test-command";
6538 char arguments_1[] = "7";
6539 char *arguments[] = {
6547 r = guestfs_command_lines (g, arguments);
6551 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6555 for (i = 0; r[i] != NULL; ++i)
6560 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6564 static int test_command_lines_7_prereq (void)
6566 const char *str = getenv ("SKIP_TEST_COMMAND");
6567 return str && strcmp (str, "1") == 0;
6570 static int test_command_lines_7 (void)
6572 if (! test_command_lines_7_prereq ()) {
6573 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6575 char device[] = "/dev/sda";
6576 device[5] = devchar;
6579 r = guestfs_blockdev_setrw (g, device);
6586 r = guestfs_umount_all (g);
6593 r = guestfs_lvm_remove_all (g);
6598 char device[] = "/dev/sda";
6599 device[5] = devchar;
6600 char lines_0[] = ",";
6607 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6612 char fstype[] = "ext2";
6613 char device[] = "/dev/sda1";
6614 device[5] = devchar;
6617 r = guestfs_mkfs (g, fstype, device);
6622 char device[] = "/dev/sda1";
6623 device[5] = devchar;
6624 char mountpoint[] = "/";
6627 r = guestfs_mount (g, device, mountpoint);
6631 /* TestOutputList for command_lines (7) */
6633 char remotefilename[] = "/test-command";
6636 r = guestfs_upload (g, "test-command", remotefilename);
6641 char path[] = "/test-command";
6644 r = guestfs_chmod (g, 493, path);
6649 char arguments_0[] = "/test-command";
6650 char arguments_1[] = "8";
6651 char *arguments[] = {
6659 r = guestfs_command_lines (g, arguments);
6663 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6668 char expected[] = "";
6669 if (strcmp (r[0], expected) != 0) {
6670 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6675 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6679 for (i = 0; r[i] != NULL; ++i)
6684 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6688 static int test_command_lines_8_prereq (void)
6690 const char *str = getenv ("SKIP_TEST_COMMAND");
6691 return str && strcmp (str, "1") == 0;
6694 static int test_command_lines_8 (void)
6696 if (! test_command_lines_8_prereq ()) {
6697 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6699 char device[] = "/dev/sda";
6700 device[5] = devchar;
6703 r = guestfs_blockdev_setrw (g, device);
6710 r = guestfs_umount_all (g);
6717 r = guestfs_lvm_remove_all (g);
6722 char device[] = "/dev/sda";
6723 device[5] = devchar;
6724 char lines_0[] = ",";
6731 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6736 char fstype[] = "ext2";
6737 char device[] = "/dev/sda1";
6738 device[5] = devchar;
6741 r = guestfs_mkfs (g, fstype, device);
6746 char device[] = "/dev/sda1";
6747 device[5] = devchar;
6748 char mountpoint[] = "/";
6751 r = guestfs_mount (g, device, mountpoint);
6755 /* TestOutputList for command_lines (8) */
6757 char remotefilename[] = "/test-command";
6760 r = guestfs_upload (g, "test-command", remotefilename);
6765 char path[] = "/test-command";
6768 r = guestfs_chmod (g, 493, path);
6773 char arguments_0[] = "/test-command";
6774 char arguments_1[] = "9";
6775 char *arguments[] = {
6783 r = guestfs_command_lines (g, arguments);
6787 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6792 char expected[] = "";
6793 if (strcmp (r[0], expected) != 0) {
6794 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6799 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6804 char expected[] = "";
6805 if (strcmp (r[1], expected) != 0) {
6806 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6811 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6815 for (i = 0; r[i] != NULL; ++i)
6820 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6824 static int test_command_lines_9_prereq (void)
6826 const char *str = getenv ("SKIP_TEST_COMMAND");
6827 return str && strcmp (str, "1") == 0;
6830 static int test_command_lines_9 (void)
6832 if (! test_command_lines_9_prereq ()) {
6833 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6835 char device[] = "/dev/sda";
6836 device[5] = devchar;
6839 r = guestfs_blockdev_setrw (g, device);
6846 r = guestfs_umount_all (g);
6853 r = guestfs_lvm_remove_all (g);
6858 char device[] = "/dev/sda";
6859 device[5] = devchar;
6860 char lines_0[] = ",";
6867 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6872 char fstype[] = "ext2";
6873 char device[] = "/dev/sda1";
6874 device[5] = devchar;
6877 r = guestfs_mkfs (g, fstype, device);
6882 char device[] = "/dev/sda1";
6883 device[5] = devchar;
6884 char mountpoint[] = "/";
6887 r = guestfs_mount (g, device, mountpoint);
6891 /* TestOutputList for command_lines (9) */
6893 char remotefilename[] = "/test-command";
6896 r = guestfs_upload (g, "test-command", remotefilename);
6901 char path[] = "/test-command";
6904 r = guestfs_chmod (g, 493, path);
6909 char arguments_0[] = "/test-command";
6910 char arguments_1[] = "10";
6911 char *arguments[] = {
6919 r = guestfs_command_lines (g, arguments);
6923 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6928 char expected[] = "Result10-1";
6929 if (strcmp (r[0], expected) != 0) {
6930 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6935 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6940 char expected[] = "Result10-2";
6941 if (strcmp (r[1], expected) != 0) {
6942 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6947 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6951 for (i = 0; r[i] != NULL; ++i)
6956 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6960 static int test_command_lines_10_prereq (void)
6962 const char *str = getenv ("SKIP_TEST_COMMAND");
6963 return str && strcmp (str, "1") == 0;
6966 static int test_command_lines_10 (void)
6968 if (! test_command_lines_10_prereq ()) {
6969 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
6971 char device[] = "/dev/sda";
6972 device[5] = devchar;
6975 r = guestfs_blockdev_setrw (g, device);
6982 r = guestfs_umount_all (g);
6989 r = guestfs_lvm_remove_all (g);
6994 char device[] = "/dev/sda";
6995 device[5] = devchar;
6996 char lines_0[] = ",";
7003 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7008 char fstype[] = "ext2";
7009 char device[] = "/dev/sda1";
7010 device[5] = devchar;
7013 r = guestfs_mkfs (g, fstype, device);
7018 char device[] = "/dev/sda1";
7019 device[5] = devchar;
7020 char mountpoint[] = "/";
7023 r = guestfs_mount (g, device, mountpoint);
7027 /* TestOutputList for command_lines (10) */
7029 char remotefilename[] = "/test-command";
7032 r = guestfs_upload (g, "test-command", remotefilename);
7037 char path[] = "/test-command";
7040 r = guestfs_chmod (g, 493, path);
7045 char arguments_0[] = "/test-command";
7046 char arguments_1[] = "11";
7047 char *arguments[] = {
7055 r = guestfs_command_lines (g, arguments);
7059 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7064 char expected[] = "Result11-1";
7065 if (strcmp (r[0], expected) != 0) {
7066 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7071 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
7076 char expected[] = "Result11-2";
7077 if (strcmp (r[1], expected) != 0) {
7078 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7083 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
7087 for (i = 0; r[i] != NULL; ++i)
7092 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
7096 static int test_command_0_prereq (void)
7098 const char *str = getenv ("SKIP_TEST_COMMAND");
7099 return str && strcmp (str, "1") == 0;
7102 static int test_command_0 (void)
7104 if (! test_command_0_prereq ()) {
7105 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
7107 char device[] = "/dev/sda";
7108 device[5] = devchar;
7111 r = guestfs_blockdev_setrw (g, device);
7118 r = guestfs_umount_all (g);
7125 r = guestfs_lvm_remove_all (g);
7130 char device[] = "/dev/sda";
7131 device[5] = devchar;
7132 char lines_0[] = ",";
7139 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7144 char fstype[] = "ext2";
7145 char device[] = "/dev/sda1";
7146 device[5] = devchar;
7149 r = guestfs_mkfs (g, fstype, device);
7154 char device[] = "/dev/sda1";
7155 device[5] = devchar;
7156 char mountpoint[] = "/";
7159 r = guestfs_mount (g, device, mountpoint);
7163 /* TestOutput for command (0) */
7164 char expected[] = "Result1";
7166 char remotefilename[] = "/test-command";
7169 r = guestfs_upload (g, "test-command", remotefilename);
7174 char path[] = "/test-command";
7177 r = guestfs_chmod (g, 493, path);
7182 char arguments_0[] = "/test-command";
7183 char arguments_1[] = "1";
7184 char *arguments[] = {
7191 r = guestfs_command (g, arguments);
7194 if (strcmp (r, expected) != 0) {
7195 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
7201 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
7205 static int test_command_1_prereq (void)
7207 const char *str = getenv ("SKIP_TEST_COMMAND");
7208 return str && strcmp (str, "1") == 0;
7211 static int test_command_1 (void)
7213 if (! test_command_1_prereq ()) {
7214 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
7216 char device[] = "/dev/sda";
7217 device[5] = devchar;
7220 r = guestfs_blockdev_setrw (g, device);
7227 r = guestfs_umount_all (g);
7234 r = guestfs_lvm_remove_all (g);
7239 char device[] = "/dev/sda";
7240 device[5] = devchar;
7241 char lines_0[] = ",";
7248 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7253 char fstype[] = "ext2";
7254 char device[] = "/dev/sda1";
7255 device[5] = devchar;
7258 r = guestfs_mkfs (g, fstype, device);
7263 char device[] = "/dev/sda1";
7264 device[5] = devchar;
7265 char mountpoint[] = "/";
7268 r = guestfs_mount (g, device, mountpoint);
7272 /* TestOutput for command (1) */
7273 char expected[] = "Result2\n";
7275 char remotefilename[] = "/test-command";
7278 r = guestfs_upload (g, "test-command", remotefilename);
7283 char path[] = "/test-command";
7286 r = guestfs_chmod (g, 493, path);
7291 char arguments_0[] = "/test-command";
7292 char arguments_1[] = "2";
7293 char *arguments[] = {
7300 r = guestfs_command (g, arguments);
7303 if (strcmp (r, expected) != 0) {
7304 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
7310 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
7314 static int test_command_2_prereq (void)
7316 const char *str = getenv ("SKIP_TEST_COMMAND");
7317 return str && strcmp (str, "1") == 0;
7320 static int test_command_2 (void)
7322 if (! test_command_2_prereq ()) {
7323 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
7325 char device[] = "/dev/sda";
7326 device[5] = devchar;
7329 r = guestfs_blockdev_setrw (g, device);
7336 r = guestfs_umount_all (g);
7343 r = guestfs_lvm_remove_all (g);
7348 char device[] = "/dev/sda";
7349 device[5] = devchar;
7350 char lines_0[] = ",";
7357 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7362 char fstype[] = "ext2";
7363 char device[] = "/dev/sda1";
7364 device[5] = devchar;
7367 r = guestfs_mkfs (g, fstype, device);
7372 char device[] = "/dev/sda1";
7373 device[5] = devchar;
7374 char mountpoint[] = "/";
7377 r = guestfs_mount (g, device, mountpoint);
7381 /* TestOutput for command (2) */
7382 char expected[] = "\nResult3";
7384 char remotefilename[] = "/test-command";
7387 r = guestfs_upload (g, "test-command", remotefilename);
7392 char path[] = "/test-command";
7395 r = guestfs_chmod (g, 493, path);
7400 char arguments_0[] = "/test-command";
7401 char arguments_1[] = "3";
7402 char *arguments[] = {
7409 r = guestfs_command (g, arguments);
7412 if (strcmp (r, expected) != 0) {
7413 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7419 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7423 static int test_command_3_prereq (void)
7425 const char *str = getenv ("SKIP_TEST_COMMAND");
7426 return str && strcmp (str, "1") == 0;
7429 static int test_command_3 (void)
7431 if (! test_command_3_prereq ()) {
7432 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7434 char device[] = "/dev/sda";
7435 device[5] = devchar;
7438 r = guestfs_blockdev_setrw (g, device);
7445 r = guestfs_umount_all (g);
7452 r = guestfs_lvm_remove_all (g);
7457 char device[] = "/dev/sda";
7458 device[5] = devchar;
7459 char lines_0[] = ",";
7466 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7471 char fstype[] = "ext2";
7472 char device[] = "/dev/sda1";
7473 device[5] = devchar;
7476 r = guestfs_mkfs (g, fstype, device);
7481 char device[] = "/dev/sda1";
7482 device[5] = devchar;
7483 char mountpoint[] = "/";
7486 r = guestfs_mount (g, device, mountpoint);
7490 /* TestOutput for command (3) */
7491 char expected[] = "\nResult4\n";
7493 char remotefilename[] = "/test-command";
7496 r = guestfs_upload (g, "test-command", remotefilename);
7501 char path[] = "/test-command";
7504 r = guestfs_chmod (g, 493, path);
7509 char arguments_0[] = "/test-command";
7510 char arguments_1[] = "4";
7511 char *arguments[] = {
7518 r = guestfs_command (g, arguments);
7521 if (strcmp (r, expected) != 0) {
7522 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7528 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7532 static int test_command_4_prereq (void)
7534 const char *str = getenv ("SKIP_TEST_COMMAND");
7535 return str && strcmp (str, "1") == 0;
7538 static int test_command_4 (void)
7540 if (! test_command_4_prereq ()) {
7541 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7543 char device[] = "/dev/sda";
7544 device[5] = devchar;
7547 r = guestfs_blockdev_setrw (g, device);
7554 r = guestfs_umount_all (g);
7561 r = guestfs_lvm_remove_all (g);
7566 char device[] = "/dev/sda";
7567 device[5] = devchar;
7568 char lines_0[] = ",";
7575 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7580 char fstype[] = "ext2";
7581 char device[] = "/dev/sda1";
7582 device[5] = devchar;
7585 r = guestfs_mkfs (g, fstype, device);
7590 char device[] = "/dev/sda1";
7591 device[5] = devchar;
7592 char mountpoint[] = "/";
7595 r = guestfs_mount (g, device, mountpoint);
7599 /* TestOutput for command (4) */
7600 char expected[] = "\nResult5\n\n";
7602 char remotefilename[] = "/test-command";
7605 r = guestfs_upload (g, "test-command", remotefilename);
7610 char path[] = "/test-command";
7613 r = guestfs_chmod (g, 493, path);
7618 char arguments_0[] = "/test-command";
7619 char arguments_1[] = "5";
7620 char *arguments[] = {
7627 r = guestfs_command (g, arguments);
7630 if (strcmp (r, expected) != 0) {
7631 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7637 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7641 static int test_command_5_prereq (void)
7643 const char *str = getenv ("SKIP_TEST_COMMAND");
7644 return str && strcmp (str, "1") == 0;
7647 static int test_command_5 (void)
7649 if (! test_command_5_prereq ()) {
7650 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7652 char device[] = "/dev/sda";
7653 device[5] = devchar;
7656 r = guestfs_blockdev_setrw (g, device);
7663 r = guestfs_umount_all (g);
7670 r = guestfs_lvm_remove_all (g);
7675 char device[] = "/dev/sda";
7676 device[5] = devchar;
7677 char lines_0[] = ",";
7684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7689 char fstype[] = "ext2";
7690 char device[] = "/dev/sda1";
7691 device[5] = devchar;
7694 r = guestfs_mkfs (g, fstype, device);
7699 char device[] = "/dev/sda1";
7700 device[5] = devchar;
7701 char mountpoint[] = "/";
7704 r = guestfs_mount (g, device, mountpoint);
7708 /* TestOutput for command (5) */
7709 char expected[] = "\n\nResult6\n\n";
7711 char remotefilename[] = "/test-command";
7714 r = guestfs_upload (g, "test-command", remotefilename);
7719 char path[] = "/test-command";
7722 r = guestfs_chmod (g, 493, path);
7727 char arguments_0[] = "/test-command";
7728 char arguments_1[] = "6";
7729 char *arguments[] = {
7736 r = guestfs_command (g, arguments);
7739 if (strcmp (r, expected) != 0) {
7740 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7746 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7750 static int test_command_6_prereq (void)
7752 const char *str = getenv ("SKIP_TEST_COMMAND");
7753 return str && strcmp (str, "1") == 0;
7756 static int test_command_6 (void)
7758 if (! test_command_6_prereq ()) {
7759 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7761 char device[] = "/dev/sda";
7762 device[5] = devchar;
7765 r = guestfs_blockdev_setrw (g, device);
7772 r = guestfs_umount_all (g);
7779 r = guestfs_lvm_remove_all (g);
7784 char device[] = "/dev/sda";
7785 device[5] = devchar;
7786 char lines_0[] = ",";
7793 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7798 char fstype[] = "ext2";
7799 char device[] = "/dev/sda1";
7800 device[5] = devchar;
7803 r = guestfs_mkfs (g, fstype, device);
7808 char device[] = "/dev/sda1";
7809 device[5] = devchar;
7810 char mountpoint[] = "/";
7813 r = guestfs_mount (g, device, mountpoint);
7817 /* TestOutput for command (6) */
7818 char expected[] = "";
7820 char remotefilename[] = "/test-command";
7823 r = guestfs_upload (g, "test-command", remotefilename);
7828 char path[] = "/test-command";
7831 r = guestfs_chmod (g, 493, path);
7836 char arguments_0[] = "/test-command";
7837 char arguments_1[] = "7";
7838 char *arguments[] = {
7845 r = guestfs_command (g, arguments);
7848 if (strcmp (r, expected) != 0) {
7849 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7855 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7859 static int test_command_7_prereq (void)
7861 const char *str = getenv ("SKIP_TEST_COMMAND");
7862 return str && strcmp (str, "1") == 0;
7865 static int test_command_7 (void)
7867 if (! test_command_7_prereq ()) {
7868 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7870 char device[] = "/dev/sda";
7871 device[5] = devchar;
7874 r = guestfs_blockdev_setrw (g, device);
7881 r = guestfs_umount_all (g);
7888 r = guestfs_lvm_remove_all (g);
7893 char device[] = "/dev/sda";
7894 device[5] = devchar;
7895 char lines_0[] = ",";
7902 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7907 char fstype[] = "ext2";
7908 char device[] = "/dev/sda1";
7909 device[5] = devchar;
7912 r = guestfs_mkfs (g, fstype, device);
7917 char device[] = "/dev/sda1";
7918 device[5] = devchar;
7919 char mountpoint[] = "/";
7922 r = guestfs_mount (g, device, mountpoint);
7926 /* TestOutput for command (7) */
7927 char expected[] = "\n";
7929 char remotefilename[] = "/test-command";
7932 r = guestfs_upload (g, "test-command", remotefilename);
7937 char path[] = "/test-command";
7940 r = guestfs_chmod (g, 493, path);
7945 char arguments_0[] = "/test-command";
7946 char arguments_1[] = "8";
7947 char *arguments[] = {
7954 r = guestfs_command (g, arguments);
7957 if (strcmp (r, expected) != 0) {
7958 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7964 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7968 static int test_command_8_prereq (void)
7970 const char *str = getenv ("SKIP_TEST_COMMAND");
7971 return str && strcmp (str, "1") == 0;
7974 static int test_command_8 (void)
7976 if (! test_command_8_prereq ()) {
7977 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
7979 char device[] = "/dev/sda";
7980 device[5] = devchar;
7983 r = guestfs_blockdev_setrw (g, device);
7990 r = guestfs_umount_all (g);
7997 r = guestfs_lvm_remove_all (g);
8002 char device[] = "/dev/sda";
8003 device[5] = devchar;
8004 char lines_0[] = ",";
8011 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8016 char fstype[] = "ext2";
8017 char device[] = "/dev/sda1";
8018 device[5] = devchar;
8021 r = guestfs_mkfs (g, fstype, device);
8026 char device[] = "/dev/sda1";
8027 device[5] = devchar;
8028 char mountpoint[] = "/";
8031 r = guestfs_mount (g, device, mountpoint);
8035 /* TestOutput for command (8) */
8036 char expected[] = "\n\n";
8038 char remotefilename[] = "/test-command";
8041 r = guestfs_upload (g, "test-command", remotefilename);
8046 char path[] = "/test-command";
8049 r = guestfs_chmod (g, 493, path);
8054 char arguments_0[] = "/test-command";
8055 char arguments_1[] = "9";
8056 char *arguments[] = {
8063 r = guestfs_command (g, arguments);
8066 if (strcmp (r, expected) != 0) {
8067 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
8073 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
8077 static int test_command_9_prereq (void)
8079 const char *str = getenv ("SKIP_TEST_COMMAND");
8080 return str && strcmp (str, "1") == 0;
8083 static int test_command_9 (void)
8085 if (! test_command_9_prereq ()) {
8086 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
8088 char device[] = "/dev/sda";
8089 device[5] = devchar;
8092 r = guestfs_blockdev_setrw (g, device);
8099 r = guestfs_umount_all (g);
8106 r = guestfs_lvm_remove_all (g);
8111 char device[] = "/dev/sda";
8112 device[5] = devchar;
8113 char lines_0[] = ",";
8120 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8125 char fstype[] = "ext2";
8126 char device[] = "/dev/sda1";
8127 device[5] = devchar;
8130 r = guestfs_mkfs (g, fstype, device);
8135 char device[] = "/dev/sda1";
8136 device[5] = devchar;
8137 char mountpoint[] = "/";
8140 r = guestfs_mount (g, device, mountpoint);
8144 /* TestOutput for command (9) */
8145 char expected[] = "Result10-1\nResult10-2\n";
8147 char remotefilename[] = "/test-command";
8150 r = guestfs_upload (g, "test-command", remotefilename);
8155 char path[] = "/test-command";
8158 r = guestfs_chmod (g, 493, path);
8163 char arguments_0[] = "/test-command";
8164 char arguments_1[] = "10";
8165 char *arguments[] = {
8172 r = guestfs_command (g, arguments);
8175 if (strcmp (r, expected) != 0) {
8176 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
8182 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
8186 static int test_command_10_prereq (void)
8188 const char *str = getenv ("SKIP_TEST_COMMAND");
8189 return str && strcmp (str, "1") == 0;
8192 static int test_command_10 (void)
8194 if (! test_command_10_prereq ()) {
8195 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
8197 char device[] = "/dev/sda";
8198 device[5] = devchar;
8201 r = guestfs_blockdev_setrw (g, device);
8208 r = guestfs_umount_all (g);
8215 r = guestfs_lvm_remove_all (g);
8220 char device[] = "/dev/sda";
8221 device[5] = devchar;
8222 char lines_0[] = ",";
8229 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8234 char fstype[] = "ext2";
8235 char device[] = "/dev/sda1";
8236 device[5] = devchar;
8239 r = guestfs_mkfs (g, fstype, device);
8244 char device[] = "/dev/sda1";
8245 device[5] = devchar;
8246 char mountpoint[] = "/";
8249 r = guestfs_mount (g, device, mountpoint);
8253 /* TestOutput for command (10) */
8254 char expected[] = "Result11-1\nResult11-2";
8256 char remotefilename[] = "/test-command";
8259 r = guestfs_upload (g, "test-command", remotefilename);
8264 char path[] = "/test-command";
8267 r = guestfs_chmod (g, 493, path);
8272 char arguments_0[] = "/test-command";
8273 char arguments_1[] = "11";
8274 char *arguments[] = {
8281 r = guestfs_command (g, arguments);
8284 if (strcmp (r, expected) != 0) {
8285 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
8291 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
8295 static int test_command_11_prereq (void)
8297 const char *str = getenv ("SKIP_TEST_COMMAND");
8298 return str && strcmp (str, "1") == 0;
8301 static int test_command_11 (void)
8303 if (! test_command_11_prereq ()) {
8304 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
8306 char device[] = "/dev/sda";
8307 device[5] = devchar;
8310 r = guestfs_blockdev_setrw (g, device);
8317 r = guestfs_umount_all (g);
8324 r = guestfs_lvm_remove_all (g);
8329 char device[] = "/dev/sda";
8330 device[5] = devchar;
8331 char lines_0[] = ",";
8338 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8343 char fstype[] = "ext2";
8344 char device[] = "/dev/sda1";
8345 device[5] = devchar;
8348 r = guestfs_mkfs (g, fstype, device);
8353 char device[] = "/dev/sda1";
8354 device[5] = devchar;
8355 char mountpoint[] = "/";
8358 r = guestfs_mount (g, device, mountpoint);
8362 /* TestLastFail for command (11) */
8364 char remotefilename[] = "/test-command";
8367 r = guestfs_upload (g, "test-command", remotefilename);
8372 char path[] = "/test-command";
8375 r = guestfs_chmod (g, 493, path);
8380 char arguments_0[] = "/test-command";
8381 char *arguments[] = {
8387 r = guestfs_command (g, arguments);
8393 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8397 static int test_file_0 (void)
8399 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8401 char device[] = "/dev/sda";
8402 device[5] = devchar;
8405 r = guestfs_blockdev_setrw (g, device);
8412 r = guestfs_umount_all (g);
8419 r = guestfs_lvm_remove_all (g);
8424 char device[] = "/dev/sda";
8425 device[5] = devchar;
8426 char lines_0[] = ",";
8433 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8438 char fstype[] = "ext2";
8439 char device[] = "/dev/sda1";
8440 device[5] = devchar;
8443 r = guestfs_mkfs (g, fstype, device);
8448 char device[] = "/dev/sda1";
8449 device[5] = devchar;
8450 char mountpoint[] = "/";
8453 r = guestfs_mount (g, device, mountpoint);
8457 /* TestOutput for file (0) */
8458 char expected[] = "empty";
8460 char path[] = "/new";
8463 r = guestfs_touch (g, path);
8468 char path[] = "/new";
8471 r = guestfs_file (g, path);
8474 if (strcmp (r, expected) != 0) {
8475 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8483 static int test_file_1 (void)
8485 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8487 char device[] = "/dev/sda";
8488 device[5] = devchar;
8491 r = guestfs_blockdev_setrw (g, device);
8498 r = guestfs_umount_all (g);
8505 r = guestfs_lvm_remove_all (g);
8510 char device[] = "/dev/sda";
8511 device[5] = devchar;
8512 char lines_0[] = ",";
8519 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8524 char fstype[] = "ext2";
8525 char device[] = "/dev/sda1";
8526 device[5] = devchar;
8529 r = guestfs_mkfs (g, fstype, device);
8534 char device[] = "/dev/sda1";
8535 device[5] = devchar;
8536 char mountpoint[] = "/";
8539 r = guestfs_mount (g, device, mountpoint);
8543 /* TestOutput for file (1) */
8544 char expected[] = "ASCII text";
8546 char path[] = "/new";
8547 char content[] = "some content\n";
8550 r = guestfs_write_file (g, path, content, 0);
8555 char path[] = "/new";
8558 r = guestfs_file (g, path);
8561 if (strcmp (r, expected) != 0) {
8562 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8570 static int test_file_2 (void)
8572 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8574 char device[] = "/dev/sda";
8575 device[5] = devchar;
8578 r = guestfs_blockdev_setrw (g, device);
8585 r = guestfs_umount_all (g);
8592 r = guestfs_lvm_remove_all (g);
8597 char device[] = "/dev/sda";
8598 device[5] = devchar;
8599 char lines_0[] = ",";
8606 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8611 char fstype[] = "ext2";
8612 char device[] = "/dev/sda1";
8613 device[5] = devchar;
8616 r = guestfs_mkfs (g, fstype, device);
8621 char device[] = "/dev/sda1";
8622 device[5] = devchar;
8623 char mountpoint[] = "/";
8626 r = guestfs_mount (g, device, mountpoint);
8630 /* TestLastFail for file (2) */
8632 char path[] = "/nofile";
8635 r = guestfs_file (g, path);
8643 static int test_umount_all_0 (void)
8645 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8647 char device[] = "/dev/sda";
8648 device[5] = devchar;
8651 r = guestfs_blockdev_setrw (g, device);
8658 r = guestfs_umount_all (g);
8665 r = guestfs_lvm_remove_all (g);
8670 char device[] = "/dev/sda";
8671 device[5] = devchar;
8672 char lines_0[] = ",";
8679 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8684 char fstype[] = "ext2";
8685 char device[] = "/dev/sda1";
8686 device[5] = devchar;
8689 r = guestfs_mkfs (g, fstype, device);
8694 char device[] = "/dev/sda1";
8695 device[5] = devchar;
8696 char mountpoint[] = "/";
8699 r = guestfs_mount (g, device, mountpoint);
8703 /* TestOutputList for umount_all (0) */
8707 r = guestfs_umount_all (g);
8715 r = guestfs_mounts (g);
8719 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8723 for (i = 0; r[i] != NULL; ++i)
8730 static int test_umount_all_1 (void)
8732 /* InitNone|InitEmpty for test_umount_all_1 */
8734 char device[] = "/dev/sda";
8735 device[5] = devchar;
8738 r = guestfs_blockdev_setrw (g, device);
8745 r = guestfs_umount_all (g);
8752 r = guestfs_lvm_remove_all (g);
8756 /* TestOutputList for umount_all (1) */
8758 char device[] = "/dev/sda";
8759 device[5] = devchar;
8760 char lines_0[] = ",10";
8761 char lines_1[] = ",20";
8762 char lines_2[] = ",";
8771 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8776 char fstype[] = "ext2";
8777 char device[] = "/dev/sda1";
8778 device[5] = devchar;
8781 r = guestfs_mkfs (g, fstype, device);
8786 char fstype[] = "ext2";
8787 char device[] = "/dev/sda2";
8788 device[5] = devchar;
8791 r = guestfs_mkfs (g, fstype, device);
8796 char fstype[] = "ext2";
8797 char device[] = "/dev/sda3";
8798 device[5] = devchar;
8801 r = guestfs_mkfs (g, fstype, device);
8806 char device[] = "/dev/sda1";
8807 device[5] = devchar;
8808 char mountpoint[] = "/";
8811 r = guestfs_mount (g, device, mountpoint);
8816 char path[] = "/mp1";
8819 r = guestfs_mkdir (g, path);
8824 char device[] = "/dev/sda2";
8825 device[5] = devchar;
8826 char mountpoint[] = "/mp1";
8829 r = guestfs_mount (g, device, mountpoint);
8834 char path[] = "/mp1/mp2";
8837 r = guestfs_mkdir (g, path);
8842 char device[] = "/dev/sda3";
8843 device[5] = devchar;
8844 char mountpoint[] = "/mp1/mp2";
8847 r = guestfs_mount (g, device, mountpoint);
8852 char path[] = "/mp1/mp2/mp3";
8855 r = guestfs_mkdir (g, path);
8862 r = guestfs_umount_all (g);
8870 r = guestfs_mounts (g);
8874 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8878 for (i = 0; r[i] != NULL; ++i)
8885 static int test_mounts_0 (void)
8887 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
8889 char device[] = "/dev/sda";
8890 device[5] = devchar;
8893 r = guestfs_blockdev_setrw (g, device);
8900 r = guestfs_umount_all (g);
8907 r = guestfs_lvm_remove_all (g);
8912 char device[] = "/dev/sda";
8913 device[5] = devchar;
8914 char lines_0[] = ",";
8921 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8926 char fstype[] = "ext2";
8927 char device[] = "/dev/sda1";
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);
8945 /* TestOutputList for mounts (0) */
8950 r = guestfs_mounts (g);
8954 fprintf (stderr, "test_mounts_0: short list returned from command\n");
8959 char expected[] = "/dev/sda1";
8960 expected[5] = devchar;
8961 if (strcmp (r[0], expected) != 0) {
8962 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8967 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8971 for (i = 0; r[i] != NULL; ++i)
8978 static int test_umount_0 (void)
8980 /* InitNone|InitEmpty for test_umount_0 */
8982 char device[] = "/dev/sda";
8983 device[5] = devchar;
8986 r = guestfs_blockdev_setrw (g, device);
8993 r = guestfs_umount_all (g);
9000 r = guestfs_lvm_remove_all (g);
9004 /* TestOutputList for umount (0) */
9006 char device[] = "/dev/sda";
9007 device[5] = devchar;
9008 char lines_0[] = ",";
9015 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9020 char fstype[] = "ext2";
9021 char device[] = "/dev/sda1";
9022 device[5] = devchar;
9025 r = guestfs_mkfs (g, fstype, device);
9030 char device[] = "/dev/sda1";
9031 device[5] = devchar;
9032 char mountpoint[] = "/";
9035 r = guestfs_mount (g, device, mountpoint);
9043 r = guestfs_mounts (g);
9047 fprintf (stderr, "test_umount_0: short list returned from command\n");
9052 char expected[] = "/dev/sda1";
9053 expected[5] = devchar;
9054 if (strcmp (r[0], expected) != 0) {
9055 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9060 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
9064 for (i = 0; r[i] != NULL; ++i)
9071 static int test_umount_1 (void)
9073 /* InitNone|InitEmpty for test_umount_1 */
9075 char device[] = "/dev/sda";
9076 device[5] = devchar;
9079 r = guestfs_blockdev_setrw (g, device);
9086 r = guestfs_umount_all (g);
9093 r = guestfs_lvm_remove_all (g);
9097 /* TestOutputList for umount (1) */
9099 char device[] = "/dev/sda";
9100 device[5] = devchar;
9101 char lines_0[] = ",";
9108 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9113 char fstype[] = "ext2";
9114 char device[] = "/dev/sda1";
9115 device[5] = devchar;
9118 r = guestfs_mkfs (g, fstype, device);
9123 char device[] = "/dev/sda1";
9124 device[5] = devchar;
9125 char mountpoint[] = "/";
9128 r = guestfs_mount (g, device, mountpoint);
9133 char pathordevice[] = "/";
9136 r = guestfs_umount (g, pathordevice);
9144 r = guestfs_mounts (g);
9148 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
9152 for (i = 0; r[i] != NULL; ++i)
9159 static int test_write_file_0 (void)
9161 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
9163 char device[] = "/dev/sda";
9164 device[5] = devchar;
9167 r = guestfs_blockdev_setrw (g, device);
9174 r = guestfs_umount_all (g);
9181 r = guestfs_lvm_remove_all (g);
9186 char device[] = "/dev/sda";
9187 device[5] = devchar;
9188 char lines_0[] = ",";
9195 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9200 char fstype[] = "ext2";
9201 char device[] = "/dev/sda1";
9202 device[5] = devchar;
9205 r = guestfs_mkfs (g, fstype, device);
9210 char device[] = "/dev/sda1";
9211 device[5] = devchar;
9212 char mountpoint[] = "/";
9215 r = guestfs_mount (g, device, mountpoint);
9219 /* TestOutput for write_file (0) */
9220 char expected[] = "new file contents";
9222 char path[] = "/new";
9223 char content[] = "new file contents";
9226 r = guestfs_write_file (g, path, content, 0);
9231 char path[] = "/new";
9234 r = guestfs_cat (g, path);
9237 if (strcmp (r, expected) != 0) {
9238 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9246 static int test_write_file_1 (void)
9248 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
9250 char device[] = "/dev/sda";
9251 device[5] = devchar;
9254 r = guestfs_blockdev_setrw (g, device);
9261 r = guestfs_umount_all (g);
9268 r = guestfs_lvm_remove_all (g);
9273 char device[] = "/dev/sda";
9274 device[5] = devchar;
9275 char lines_0[] = ",";
9282 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9287 char fstype[] = "ext2";
9288 char device[] = "/dev/sda1";
9289 device[5] = devchar;
9292 r = guestfs_mkfs (g, fstype, device);
9297 char device[] = "/dev/sda1";
9298 device[5] = devchar;
9299 char mountpoint[] = "/";
9302 r = guestfs_mount (g, device, mountpoint);
9306 /* TestOutput for write_file (1) */
9307 char expected[] = "\nnew file contents\n";
9309 char path[] = "/new";
9310 char content[] = "\nnew file contents\n";
9313 r = guestfs_write_file (g, path, content, 0);
9318 char path[] = "/new";
9321 r = guestfs_cat (g, path);
9324 if (strcmp (r, expected) != 0) {
9325 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9333 static int test_write_file_2 (void)
9335 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
9337 char device[] = "/dev/sda";
9338 device[5] = devchar;
9341 r = guestfs_blockdev_setrw (g, device);
9348 r = guestfs_umount_all (g);
9355 r = guestfs_lvm_remove_all (g);
9360 char device[] = "/dev/sda";
9361 device[5] = devchar;
9362 char lines_0[] = ",";
9369 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9374 char fstype[] = "ext2";
9375 char device[] = "/dev/sda1";
9376 device[5] = devchar;
9379 r = guestfs_mkfs (g, fstype, device);
9384 char device[] = "/dev/sda1";
9385 device[5] = devchar;
9386 char mountpoint[] = "/";
9389 r = guestfs_mount (g, device, mountpoint);
9393 /* TestOutput for write_file (2) */
9394 char expected[] = "\n\n";
9396 char path[] = "/new";
9397 char content[] = "\n\n";
9400 r = guestfs_write_file (g, path, content, 0);
9405 char path[] = "/new";
9408 r = guestfs_cat (g, path);
9411 if (strcmp (r, expected) != 0) {
9412 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9420 static int test_write_file_3 (void)
9422 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9424 char device[] = "/dev/sda";
9425 device[5] = devchar;
9428 r = guestfs_blockdev_setrw (g, device);
9435 r = guestfs_umount_all (g);
9442 r = guestfs_lvm_remove_all (g);
9447 char device[] = "/dev/sda";
9448 device[5] = devchar;
9449 char lines_0[] = ",";
9456 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9461 char fstype[] = "ext2";
9462 char device[] = "/dev/sda1";
9463 device[5] = devchar;
9466 r = guestfs_mkfs (g, fstype, device);
9471 char device[] = "/dev/sda1";
9472 device[5] = devchar;
9473 char mountpoint[] = "/";
9476 r = guestfs_mount (g, device, mountpoint);
9480 /* TestOutput for write_file (3) */
9481 char expected[] = "";
9483 char path[] = "/new";
9484 char content[] = "";
9487 r = guestfs_write_file (g, path, content, 0);
9492 char path[] = "/new";
9495 r = guestfs_cat (g, path);
9498 if (strcmp (r, expected) != 0) {
9499 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9507 static int test_write_file_4 (void)
9509 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9511 char device[] = "/dev/sda";
9512 device[5] = devchar;
9515 r = guestfs_blockdev_setrw (g, device);
9522 r = guestfs_umount_all (g);
9529 r = guestfs_lvm_remove_all (g);
9534 char device[] = "/dev/sda";
9535 device[5] = devchar;
9536 char lines_0[] = ",";
9543 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9548 char fstype[] = "ext2";
9549 char device[] = "/dev/sda1";
9550 device[5] = devchar;
9553 r = guestfs_mkfs (g, fstype, device);
9558 char device[] = "/dev/sda1";
9559 device[5] = devchar;
9560 char mountpoint[] = "/";
9563 r = guestfs_mount (g, device, mountpoint);
9567 /* TestOutput for write_file (4) */
9568 char expected[] = "\n\n\n";
9570 char path[] = "/new";
9571 char content[] = "\n\n\n";
9574 r = guestfs_write_file (g, path, content, 0);
9579 char path[] = "/new";
9582 r = guestfs_cat (g, path);
9585 if (strcmp (r, expected) != 0) {
9586 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9594 static int test_write_file_5 (void)
9596 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9598 char device[] = "/dev/sda";
9599 device[5] = devchar;
9602 r = guestfs_blockdev_setrw (g, device);
9609 r = guestfs_umount_all (g);
9616 r = guestfs_lvm_remove_all (g);
9621 char device[] = "/dev/sda";
9622 device[5] = devchar;
9623 char lines_0[] = ",";
9630 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9635 char fstype[] = "ext2";
9636 char device[] = "/dev/sda1";
9637 device[5] = devchar;
9640 r = guestfs_mkfs (g, fstype, device);
9645 char device[] = "/dev/sda1";
9646 device[5] = devchar;
9647 char mountpoint[] = "/";
9650 r = guestfs_mount (g, device, mountpoint);
9654 /* TestOutput for write_file (5) */
9655 char expected[] = "\n";
9657 char path[] = "/new";
9658 char content[] = "\n";
9661 r = guestfs_write_file (g, path, content, 0);
9666 char path[] = "/new";
9669 r = guestfs_cat (g, path);
9672 if (strcmp (r, expected) != 0) {
9673 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9681 static int test_mkfs_0 (void)
9683 /* InitNone|InitEmpty for test_mkfs_0 */
9685 char device[] = "/dev/sda";
9686 device[5] = devchar;
9689 r = guestfs_blockdev_setrw (g, device);
9696 r = guestfs_umount_all (g);
9703 r = guestfs_lvm_remove_all (g);
9707 /* TestOutput for mkfs (0) */
9708 char expected[] = "new file contents";
9710 char device[] = "/dev/sda";
9711 device[5] = devchar;
9712 char lines_0[] = ",";
9719 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9724 char fstype[] = "ext2";
9725 char device[] = "/dev/sda1";
9726 device[5] = devchar;
9729 r = guestfs_mkfs (g, fstype, device);
9734 char device[] = "/dev/sda1";
9735 device[5] = devchar;
9736 char mountpoint[] = "/";
9739 r = guestfs_mount (g, device, mountpoint);
9744 char path[] = "/new";
9745 char content[] = "new file contents";
9748 r = guestfs_write_file (g, path, content, 0);
9753 char path[] = "/new";
9756 r = guestfs_cat (g, path);
9759 if (strcmp (r, expected) != 0) {
9760 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9768 static int test_lvcreate_0 (void)
9770 /* InitNone|InitEmpty for test_lvcreate_0 */
9772 char device[] = "/dev/sda";
9773 device[5] = devchar;
9776 r = guestfs_blockdev_setrw (g, device);
9783 r = guestfs_umount_all (g);
9790 r = guestfs_lvm_remove_all (g);
9794 /* TestOutputList for lvcreate (0) */
9796 char device[] = "/dev/sda";
9797 device[5] = devchar;
9798 char lines_0[] = ",10";
9799 char lines_1[] = ",20";
9800 char lines_2[] = ",";
9809 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9814 char device[] = "/dev/sda1";
9815 device[5] = devchar;
9818 r = guestfs_pvcreate (g, device);
9823 char device[] = "/dev/sda2";
9824 device[5] = devchar;
9827 r = guestfs_pvcreate (g, device);
9832 char device[] = "/dev/sda3";
9833 device[5] = devchar;
9836 r = guestfs_pvcreate (g, device);
9841 char volgroup[] = "VG1";
9842 char physvols_0[] = "/dev/sda1";
9843 physvols_0[5] = devchar;
9844 char physvols_1[] = "/dev/sda2";
9845 physvols_1[5] = devchar;
9846 char *physvols[] = {
9853 r = guestfs_vgcreate (g, volgroup, physvols);
9858 char volgroup[] = "VG2";
9859 char physvols_0[] = "/dev/sda3";
9860 physvols_0[5] = devchar;
9861 char *physvols[] = {
9867 r = guestfs_vgcreate (g, volgroup, physvols);
9872 char logvol[] = "LV1";
9873 char volgroup[] = "VG1";
9876 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9881 char logvol[] = "LV2";
9882 char volgroup[] = "VG1";
9885 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9890 char logvol[] = "LV3";
9891 char volgroup[] = "VG2";
9894 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9899 char logvol[] = "LV4";
9900 char volgroup[] = "VG2";
9903 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9908 char logvol[] = "LV5";
9909 char volgroup[] = "VG2";
9912 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9920 r = guestfs_lvs (g);
9924 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9929 char expected[] = "/dev/VG1/LV1";
9930 if (strcmp (r[0], expected) != 0) {
9931 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9936 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9941 char expected[] = "/dev/VG1/LV2";
9942 if (strcmp (r[1], expected) != 0) {
9943 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9948 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9953 char expected[] = "/dev/VG2/LV3";
9954 if (strcmp (r[2], expected) != 0) {
9955 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9960 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9965 char expected[] = "/dev/VG2/LV4";
9966 if (strcmp (r[3], expected) != 0) {
9967 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9972 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9977 char expected[] = "/dev/VG2/LV5";
9978 if (strcmp (r[4], expected) != 0) {
9979 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9984 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9988 for (i = 0; r[i] != NULL; ++i)
9995 static int test_vgcreate_0 (void)
9997 /* InitNone|InitEmpty for test_vgcreate_0 */
9999 char device[] = "/dev/sda";
10000 device[5] = devchar;
10002 suppress_error = 0;
10003 r = guestfs_blockdev_setrw (g, device);
10009 suppress_error = 0;
10010 r = guestfs_umount_all (g);
10016 suppress_error = 0;
10017 r = guestfs_lvm_remove_all (g);
10021 /* TestOutputList for vgcreate (0) */
10023 char device[] = "/dev/sda";
10024 device[5] = devchar;
10025 char lines_0[] = ",10";
10026 char lines_1[] = ",20";
10027 char lines_2[] = ",";
10035 suppress_error = 0;
10036 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10041 char device[] = "/dev/sda1";
10042 device[5] = devchar;
10044 suppress_error = 0;
10045 r = guestfs_pvcreate (g, device);
10050 char device[] = "/dev/sda2";
10051 device[5] = devchar;
10053 suppress_error = 0;
10054 r = guestfs_pvcreate (g, device);
10059 char device[] = "/dev/sda3";
10060 device[5] = devchar;
10062 suppress_error = 0;
10063 r = guestfs_pvcreate (g, device);
10068 char volgroup[] = "VG1";
10069 char physvols_0[] = "/dev/sda1";
10070 physvols_0[5] = devchar;
10071 char physvols_1[] = "/dev/sda2";
10072 physvols_1[5] = devchar;
10073 char *physvols[] = {
10079 suppress_error = 0;
10080 r = guestfs_vgcreate (g, volgroup, physvols);
10085 char volgroup[] = "VG2";
10086 char physvols_0[] = "/dev/sda3";
10087 physvols_0[5] = devchar;
10088 char *physvols[] = {
10093 suppress_error = 0;
10094 r = guestfs_vgcreate (g, volgroup, physvols);
10101 suppress_error = 0;
10102 r = guestfs_vgs (g);
10106 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10111 char expected[] = "VG1";
10112 if (strcmp (r[0], expected) != 0) {
10113 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10118 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
10123 char expected[] = "VG2";
10124 if (strcmp (r[1], expected) != 0) {
10125 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10129 if (r[2] != NULL) {
10130 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
10134 for (i = 0; r[i] != NULL; ++i)
10141 static int test_pvcreate_0 (void)
10143 /* InitNone|InitEmpty for test_pvcreate_0 */
10145 char device[] = "/dev/sda";
10146 device[5] = devchar;
10148 suppress_error = 0;
10149 r = guestfs_blockdev_setrw (g, device);
10155 suppress_error = 0;
10156 r = guestfs_umount_all (g);
10162 suppress_error = 0;
10163 r = guestfs_lvm_remove_all (g);
10167 /* TestOutputList for pvcreate (0) */
10169 char device[] = "/dev/sda";
10170 device[5] = devchar;
10171 char lines_0[] = ",10";
10172 char lines_1[] = ",20";
10173 char lines_2[] = ",";
10181 suppress_error = 0;
10182 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10187 char device[] = "/dev/sda1";
10188 device[5] = devchar;
10190 suppress_error = 0;
10191 r = guestfs_pvcreate (g, device);
10196 char device[] = "/dev/sda2";
10197 device[5] = devchar;
10199 suppress_error = 0;
10200 r = guestfs_pvcreate (g, device);
10205 char device[] = "/dev/sda3";
10206 device[5] = devchar;
10208 suppress_error = 0;
10209 r = guestfs_pvcreate (g, device);
10216 suppress_error = 0;
10217 r = guestfs_pvs (g);
10221 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10226 char expected[] = "/dev/sda1";
10227 expected[5] = devchar;
10228 if (strcmp (r[0], expected) != 0) {
10229 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10234 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10239 char expected[] = "/dev/sda2";
10240 expected[5] = devchar;
10241 if (strcmp (r[1], expected) != 0) {
10242 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10247 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
10252 char expected[] = "/dev/sda3";
10253 expected[5] = devchar;
10254 if (strcmp (r[2], expected) != 0) {
10255 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10259 if (r[3] != NULL) {
10260 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
10264 for (i = 0; r[i] != NULL; ++i)
10271 static int test_is_dir_0 (void)
10273 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
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);
10298 char device[] = "/dev/sda";
10299 device[5] = devchar;
10300 char lines_0[] = ",";
10306 suppress_error = 0;
10307 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10312 char fstype[] = "ext2";
10313 char device[] = "/dev/sda1";
10314 device[5] = devchar;
10316 suppress_error = 0;
10317 r = guestfs_mkfs (g, fstype, device);
10322 char device[] = "/dev/sda1";
10323 device[5] = devchar;
10324 char mountpoint[] = "/";
10326 suppress_error = 0;
10327 r = guestfs_mount (g, device, mountpoint);
10331 /* TestOutputFalse for is_dir (0) */
10333 char path[] = "/new";
10335 suppress_error = 0;
10336 r = guestfs_touch (g, path);
10341 char path[] = "/new";
10343 suppress_error = 0;
10344 r = guestfs_is_dir (g, path);
10348 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
10355 static int test_is_dir_1 (void)
10357 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
10359 char device[] = "/dev/sda";
10360 device[5] = devchar;
10362 suppress_error = 0;
10363 r = guestfs_blockdev_setrw (g, device);
10369 suppress_error = 0;
10370 r = guestfs_umount_all (g);
10376 suppress_error = 0;
10377 r = guestfs_lvm_remove_all (g);
10382 char device[] = "/dev/sda";
10383 device[5] = devchar;
10384 char lines_0[] = ",";
10390 suppress_error = 0;
10391 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10396 char fstype[] = "ext2";
10397 char device[] = "/dev/sda1";
10398 device[5] = devchar;
10400 suppress_error = 0;
10401 r = guestfs_mkfs (g, fstype, device);
10406 char device[] = "/dev/sda1";
10407 device[5] = devchar;
10408 char mountpoint[] = "/";
10410 suppress_error = 0;
10411 r = guestfs_mount (g, device, mountpoint);
10415 /* TestOutputTrue for is_dir (1) */
10417 char path[] = "/new";
10419 suppress_error = 0;
10420 r = guestfs_mkdir (g, path);
10425 char path[] = "/new";
10427 suppress_error = 0;
10428 r = guestfs_is_dir (g, path);
10432 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10439 static int test_is_file_0 (void)
10441 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10443 char device[] = "/dev/sda";
10444 device[5] = devchar;
10446 suppress_error = 0;
10447 r = guestfs_blockdev_setrw (g, device);
10453 suppress_error = 0;
10454 r = guestfs_umount_all (g);
10460 suppress_error = 0;
10461 r = guestfs_lvm_remove_all (g);
10466 char device[] = "/dev/sda";
10467 device[5] = devchar;
10468 char lines_0[] = ",";
10474 suppress_error = 0;
10475 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10480 char fstype[] = "ext2";
10481 char device[] = "/dev/sda1";
10482 device[5] = devchar;
10484 suppress_error = 0;
10485 r = guestfs_mkfs (g, fstype, device);
10490 char device[] = "/dev/sda1";
10491 device[5] = devchar;
10492 char mountpoint[] = "/";
10494 suppress_error = 0;
10495 r = guestfs_mount (g, device, mountpoint);
10499 /* TestOutputTrue for is_file (0) */
10501 char path[] = "/new";
10503 suppress_error = 0;
10504 r = guestfs_touch (g, path);
10509 char path[] = "/new";
10511 suppress_error = 0;
10512 r = guestfs_is_file (g, path);
10516 fprintf (stderr, "test_is_file_0: expected true, got false\n");
10523 static int test_is_file_1 (void)
10525 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10527 char device[] = "/dev/sda";
10528 device[5] = devchar;
10530 suppress_error = 0;
10531 r = guestfs_blockdev_setrw (g, device);
10537 suppress_error = 0;
10538 r = guestfs_umount_all (g);
10544 suppress_error = 0;
10545 r = guestfs_lvm_remove_all (g);
10550 char device[] = "/dev/sda";
10551 device[5] = devchar;
10552 char lines_0[] = ",";
10558 suppress_error = 0;
10559 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10564 char fstype[] = "ext2";
10565 char device[] = "/dev/sda1";
10566 device[5] = devchar;
10568 suppress_error = 0;
10569 r = guestfs_mkfs (g, fstype, device);
10574 char device[] = "/dev/sda1";
10575 device[5] = devchar;
10576 char mountpoint[] = "/";
10578 suppress_error = 0;
10579 r = guestfs_mount (g, device, mountpoint);
10583 /* TestOutputFalse for is_file (1) */
10585 char path[] = "/new";
10587 suppress_error = 0;
10588 r = guestfs_mkdir (g, path);
10593 char path[] = "/new";
10595 suppress_error = 0;
10596 r = guestfs_is_file (g, path);
10600 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10607 static int test_exists_0 (void)
10609 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10611 char device[] = "/dev/sda";
10612 device[5] = devchar;
10614 suppress_error = 0;
10615 r = guestfs_blockdev_setrw (g, device);
10621 suppress_error = 0;
10622 r = guestfs_umount_all (g);
10628 suppress_error = 0;
10629 r = guestfs_lvm_remove_all (g);
10634 char device[] = "/dev/sda";
10635 device[5] = devchar;
10636 char lines_0[] = ",";
10642 suppress_error = 0;
10643 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10648 char fstype[] = "ext2";
10649 char device[] = "/dev/sda1";
10650 device[5] = devchar;
10652 suppress_error = 0;
10653 r = guestfs_mkfs (g, fstype, device);
10658 char device[] = "/dev/sda1";
10659 device[5] = devchar;
10660 char mountpoint[] = "/";
10662 suppress_error = 0;
10663 r = guestfs_mount (g, device, mountpoint);
10667 /* TestOutputTrue for exists (0) */
10669 char path[] = "/new";
10671 suppress_error = 0;
10672 r = guestfs_touch (g, path);
10677 char path[] = "/new";
10679 suppress_error = 0;
10680 r = guestfs_exists (g, path);
10684 fprintf (stderr, "test_exists_0: expected true, got false\n");
10691 static int test_exists_1 (void)
10693 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10695 char device[] = "/dev/sda";
10696 device[5] = devchar;
10698 suppress_error = 0;
10699 r = guestfs_blockdev_setrw (g, device);
10705 suppress_error = 0;
10706 r = guestfs_umount_all (g);
10712 suppress_error = 0;
10713 r = guestfs_lvm_remove_all (g);
10718 char device[] = "/dev/sda";
10719 device[5] = devchar;
10720 char lines_0[] = ",";
10726 suppress_error = 0;
10727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10732 char fstype[] = "ext2";
10733 char device[] = "/dev/sda1";
10734 device[5] = devchar;
10736 suppress_error = 0;
10737 r = guestfs_mkfs (g, fstype, device);
10742 char device[] = "/dev/sda1";
10743 device[5] = devchar;
10744 char mountpoint[] = "/";
10746 suppress_error = 0;
10747 r = guestfs_mount (g, device, mountpoint);
10751 /* TestOutputTrue for exists (1) */
10753 char path[] = "/new";
10755 suppress_error = 0;
10756 r = guestfs_mkdir (g, path);
10761 char path[] = "/new";
10763 suppress_error = 0;
10764 r = guestfs_exists (g, path);
10768 fprintf (stderr, "test_exists_1: expected true, got false\n");
10775 static int test_mkdir_p_0 (void)
10777 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10779 char device[] = "/dev/sda";
10780 device[5] = devchar;
10782 suppress_error = 0;
10783 r = guestfs_blockdev_setrw (g, device);
10789 suppress_error = 0;
10790 r = guestfs_umount_all (g);
10796 suppress_error = 0;
10797 r = guestfs_lvm_remove_all (g);
10802 char device[] = "/dev/sda";
10803 device[5] = devchar;
10804 char lines_0[] = ",";
10810 suppress_error = 0;
10811 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10816 char fstype[] = "ext2";
10817 char device[] = "/dev/sda1";
10818 device[5] = devchar;
10820 suppress_error = 0;
10821 r = guestfs_mkfs (g, fstype, device);
10826 char device[] = "/dev/sda1";
10827 device[5] = devchar;
10828 char mountpoint[] = "/";
10830 suppress_error = 0;
10831 r = guestfs_mount (g, device, mountpoint);
10835 /* TestOutputTrue for mkdir_p (0) */
10837 char path[] = "/new/foo/bar";
10839 suppress_error = 0;
10840 r = guestfs_mkdir_p (g, path);
10845 char path[] = "/new/foo/bar";
10847 suppress_error = 0;
10848 r = guestfs_is_dir (g, path);
10852 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10859 static int test_mkdir_p_1 (void)
10861 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10863 char device[] = "/dev/sda";
10864 device[5] = devchar;
10866 suppress_error = 0;
10867 r = guestfs_blockdev_setrw (g, device);
10873 suppress_error = 0;
10874 r = guestfs_umount_all (g);
10880 suppress_error = 0;
10881 r = guestfs_lvm_remove_all (g);
10886 char device[] = "/dev/sda";
10887 device[5] = devchar;
10888 char lines_0[] = ",";
10894 suppress_error = 0;
10895 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10900 char fstype[] = "ext2";
10901 char device[] = "/dev/sda1";
10902 device[5] = devchar;
10904 suppress_error = 0;
10905 r = guestfs_mkfs (g, fstype, device);
10910 char device[] = "/dev/sda1";
10911 device[5] = devchar;
10912 char mountpoint[] = "/";
10914 suppress_error = 0;
10915 r = guestfs_mount (g, device, mountpoint);
10919 /* TestOutputTrue for mkdir_p (1) */
10921 char path[] = "/new/foo/bar";
10923 suppress_error = 0;
10924 r = guestfs_mkdir_p (g, path);
10929 char path[] = "/new/foo";
10931 suppress_error = 0;
10932 r = guestfs_is_dir (g, path);
10936 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10943 static int test_mkdir_p_2 (void)
10945 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
10947 char device[] = "/dev/sda";
10948 device[5] = devchar;
10950 suppress_error = 0;
10951 r = guestfs_blockdev_setrw (g, device);
10957 suppress_error = 0;
10958 r = guestfs_umount_all (g);
10964 suppress_error = 0;
10965 r = guestfs_lvm_remove_all (g);
10970 char device[] = "/dev/sda";
10971 device[5] = devchar;
10972 char lines_0[] = ",";
10978 suppress_error = 0;
10979 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10984 char fstype[] = "ext2";
10985 char device[] = "/dev/sda1";
10986 device[5] = devchar;
10988 suppress_error = 0;
10989 r = guestfs_mkfs (g, fstype, device);
10994 char device[] = "/dev/sda1";
10995 device[5] = devchar;
10996 char mountpoint[] = "/";
10998 suppress_error = 0;
10999 r = guestfs_mount (g, device, mountpoint);
11003 /* TestOutputTrue for mkdir_p (2) */
11005 char path[] = "/new/foo/bar";
11007 suppress_error = 0;
11008 r = guestfs_mkdir_p (g, path);
11013 char path[] = "/new";
11015 suppress_error = 0;
11016 r = guestfs_is_dir (g, path);
11020 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
11027 static int test_mkdir_0 (void)
11029 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
11031 char device[] = "/dev/sda";
11032 device[5] = devchar;
11034 suppress_error = 0;
11035 r = guestfs_blockdev_setrw (g, device);
11041 suppress_error = 0;
11042 r = guestfs_umount_all (g);
11048 suppress_error = 0;
11049 r = guestfs_lvm_remove_all (g);
11054 char device[] = "/dev/sda";
11055 device[5] = devchar;
11056 char lines_0[] = ",";
11062 suppress_error = 0;
11063 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11068 char fstype[] = "ext2";
11069 char device[] = "/dev/sda1";
11070 device[5] = devchar;
11072 suppress_error = 0;
11073 r = guestfs_mkfs (g, fstype, device);
11078 char device[] = "/dev/sda1";
11079 device[5] = devchar;
11080 char mountpoint[] = "/";
11082 suppress_error = 0;
11083 r = guestfs_mount (g, device, mountpoint);
11087 /* TestOutputTrue for mkdir (0) */
11089 char path[] = "/new";
11091 suppress_error = 0;
11092 r = guestfs_mkdir (g, path);
11097 char path[] = "/new";
11099 suppress_error = 0;
11100 r = guestfs_is_dir (g, path);
11104 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
11111 static int test_mkdir_1 (void)
11113 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
11115 char device[] = "/dev/sda";
11116 device[5] = devchar;
11118 suppress_error = 0;
11119 r = guestfs_blockdev_setrw (g, device);
11125 suppress_error = 0;
11126 r = guestfs_umount_all (g);
11132 suppress_error = 0;
11133 r = guestfs_lvm_remove_all (g);
11138 char device[] = "/dev/sda";
11139 device[5] = devchar;
11140 char lines_0[] = ",";
11146 suppress_error = 0;
11147 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11152 char fstype[] = "ext2";
11153 char device[] = "/dev/sda1";
11154 device[5] = devchar;
11156 suppress_error = 0;
11157 r = guestfs_mkfs (g, fstype, device);
11162 char device[] = "/dev/sda1";
11163 device[5] = devchar;
11164 char mountpoint[] = "/";
11166 suppress_error = 0;
11167 r = guestfs_mount (g, device, mountpoint);
11171 /* TestLastFail for mkdir (1) */
11173 char path[] = "/new/foo/bar";
11175 suppress_error = 1;
11176 r = guestfs_mkdir (g, path);
11183 static int test_rm_rf_0 (void)
11185 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
11187 char device[] = "/dev/sda";
11188 device[5] = devchar;
11190 suppress_error = 0;
11191 r = guestfs_blockdev_setrw (g, device);
11197 suppress_error = 0;
11198 r = guestfs_umount_all (g);
11204 suppress_error = 0;
11205 r = guestfs_lvm_remove_all (g);
11210 char device[] = "/dev/sda";
11211 device[5] = devchar;
11212 char lines_0[] = ",";
11218 suppress_error = 0;
11219 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11224 char fstype[] = "ext2";
11225 char device[] = "/dev/sda1";
11226 device[5] = devchar;
11228 suppress_error = 0;
11229 r = guestfs_mkfs (g, fstype, device);
11234 char device[] = "/dev/sda1";
11235 device[5] = devchar;
11236 char mountpoint[] = "/";
11238 suppress_error = 0;
11239 r = guestfs_mount (g, device, mountpoint);
11243 /* TestOutputFalse for rm_rf (0) */
11245 char path[] = "/new";
11247 suppress_error = 0;
11248 r = guestfs_mkdir (g, path);
11253 char path[] = "/new/foo";
11255 suppress_error = 0;
11256 r = guestfs_mkdir (g, path);
11261 char path[] = "/new/foo/bar";
11263 suppress_error = 0;
11264 r = guestfs_touch (g, path);
11269 char path[] = "/new";
11271 suppress_error = 0;
11272 r = guestfs_rm_rf (g, path);
11277 char path[] = "/new";
11279 suppress_error = 0;
11280 r = guestfs_exists (g, path);
11284 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
11291 static int test_rmdir_0 (void)
11293 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
11295 char device[] = "/dev/sda";
11296 device[5] = devchar;
11298 suppress_error = 0;
11299 r = guestfs_blockdev_setrw (g, device);
11305 suppress_error = 0;
11306 r = guestfs_umount_all (g);
11312 suppress_error = 0;
11313 r = guestfs_lvm_remove_all (g);
11318 char device[] = "/dev/sda";
11319 device[5] = devchar;
11320 char lines_0[] = ",";
11326 suppress_error = 0;
11327 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11332 char fstype[] = "ext2";
11333 char device[] = "/dev/sda1";
11334 device[5] = devchar;
11336 suppress_error = 0;
11337 r = guestfs_mkfs (g, fstype, device);
11342 char device[] = "/dev/sda1";
11343 device[5] = devchar;
11344 char mountpoint[] = "/";
11346 suppress_error = 0;
11347 r = guestfs_mount (g, device, mountpoint);
11351 /* TestRun for rmdir (0) */
11353 char path[] = "/new";
11355 suppress_error = 0;
11356 r = guestfs_mkdir (g, path);
11361 char path[] = "/new";
11363 suppress_error = 0;
11364 r = guestfs_rmdir (g, path);
11371 static int test_rmdir_1 (void)
11373 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11375 char device[] = "/dev/sda";
11376 device[5] = devchar;
11378 suppress_error = 0;
11379 r = guestfs_blockdev_setrw (g, device);
11385 suppress_error = 0;
11386 r = guestfs_umount_all (g);
11392 suppress_error = 0;
11393 r = guestfs_lvm_remove_all (g);
11398 char device[] = "/dev/sda";
11399 device[5] = devchar;
11400 char lines_0[] = ",";
11406 suppress_error = 0;
11407 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11412 char fstype[] = "ext2";
11413 char device[] = "/dev/sda1";
11414 device[5] = devchar;
11416 suppress_error = 0;
11417 r = guestfs_mkfs (g, fstype, device);
11422 char device[] = "/dev/sda1";
11423 device[5] = devchar;
11424 char mountpoint[] = "/";
11426 suppress_error = 0;
11427 r = guestfs_mount (g, device, mountpoint);
11431 /* TestLastFail for rmdir (1) */
11433 char path[] = "/new";
11435 suppress_error = 1;
11436 r = guestfs_rmdir (g, path);
11443 static int test_rmdir_2 (void)
11445 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11447 char device[] = "/dev/sda";
11448 device[5] = devchar;
11450 suppress_error = 0;
11451 r = guestfs_blockdev_setrw (g, device);
11457 suppress_error = 0;
11458 r = guestfs_umount_all (g);
11464 suppress_error = 0;
11465 r = guestfs_lvm_remove_all (g);
11470 char device[] = "/dev/sda";
11471 device[5] = devchar;
11472 char lines_0[] = ",";
11478 suppress_error = 0;
11479 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11484 char fstype[] = "ext2";
11485 char device[] = "/dev/sda1";
11486 device[5] = devchar;
11488 suppress_error = 0;
11489 r = guestfs_mkfs (g, fstype, device);
11494 char device[] = "/dev/sda1";
11495 device[5] = devchar;
11496 char mountpoint[] = "/";
11498 suppress_error = 0;
11499 r = guestfs_mount (g, device, mountpoint);
11503 /* TestLastFail for rmdir (2) */
11505 char path[] = "/new";
11507 suppress_error = 0;
11508 r = guestfs_touch (g, path);
11513 char path[] = "/new";
11515 suppress_error = 1;
11516 r = guestfs_rmdir (g, path);
11523 static int test_rm_0 (void)
11525 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11527 char device[] = "/dev/sda";
11528 device[5] = devchar;
11530 suppress_error = 0;
11531 r = guestfs_blockdev_setrw (g, device);
11537 suppress_error = 0;
11538 r = guestfs_umount_all (g);
11544 suppress_error = 0;
11545 r = guestfs_lvm_remove_all (g);
11550 char device[] = "/dev/sda";
11551 device[5] = devchar;
11552 char lines_0[] = ",";
11558 suppress_error = 0;
11559 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11564 char fstype[] = "ext2";
11565 char device[] = "/dev/sda1";
11566 device[5] = devchar;
11568 suppress_error = 0;
11569 r = guestfs_mkfs (g, fstype, device);
11574 char device[] = "/dev/sda1";
11575 device[5] = devchar;
11576 char mountpoint[] = "/";
11578 suppress_error = 0;
11579 r = guestfs_mount (g, device, mountpoint);
11583 /* TestRun for rm (0) */
11585 char path[] = "/new";
11587 suppress_error = 0;
11588 r = guestfs_touch (g, path);
11593 char path[] = "/new";
11595 suppress_error = 0;
11596 r = guestfs_rm (g, path);
11603 static int test_rm_1 (void)
11605 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11607 char device[] = "/dev/sda";
11608 device[5] = devchar;
11610 suppress_error = 0;
11611 r = guestfs_blockdev_setrw (g, device);
11617 suppress_error = 0;
11618 r = guestfs_umount_all (g);
11624 suppress_error = 0;
11625 r = guestfs_lvm_remove_all (g);
11630 char device[] = "/dev/sda";
11631 device[5] = devchar;
11632 char lines_0[] = ",";
11638 suppress_error = 0;
11639 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11644 char fstype[] = "ext2";
11645 char device[] = "/dev/sda1";
11646 device[5] = devchar;
11648 suppress_error = 0;
11649 r = guestfs_mkfs (g, fstype, device);
11654 char device[] = "/dev/sda1";
11655 device[5] = devchar;
11656 char mountpoint[] = "/";
11658 suppress_error = 0;
11659 r = guestfs_mount (g, device, mountpoint);
11663 /* TestLastFail for rm (1) */
11665 char path[] = "/new";
11667 suppress_error = 1;
11668 r = guestfs_rm (g, path);
11675 static int test_rm_2 (void)
11677 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11679 char device[] = "/dev/sda";
11680 device[5] = devchar;
11682 suppress_error = 0;
11683 r = guestfs_blockdev_setrw (g, device);
11689 suppress_error = 0;
11690 r = guestfs_umount_all (g);
11696 suppress_error = 0;
11697 r = guestfs_lvm_remove_all (g);
11702 char device[] = "/dev/sda";
11703 device[5] = devchar;
11704 char lines_0[] = ",";
11710 suppress_error = 0;
11711 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11716 char fstype[] = "ext2";
11717 char device[] = "/dev/sda1";
11718 device[5] = devchar;
11720 suppress_error = 0;
11721 r = guestfs_mkfs (g, fstype, device);
11726 char device[] = "/dev/sda1";
11727 device[5] = devchar;
11728 char mountpoint[] = "/";
11730 suppress_error = 0;
11731 r = guestfs_mount (g, device, mountpoint);
11735 /* TestLastFail for rm (2) */
11737 char path[] = "/new";
11739 suppress_error = 0;
11740 r = guestfs_mkdir (g, path);
11745 char path[] = "/new";
11747 suppress_error = 1;
11748 r = guestfs_rm (g, path);
11755 static int test_read_lines_0 (void)
11757 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11759 char device[] = "/dev/sda";
11760 device[5] = devchar;
11762 suppress_error = 0;
11763 r = guestfs_blockdev_setrw (g, device);
11769 suppress_error = 0;
11770 r = guestfs_umount_all (g);
11776 suppress_error = 0;
11777 r = guestfs_lvm_remove_all (g);
11782 char device[] = "/dev/sda";
11783 device[5] = devchar;
11784 char lines_0[] = ",";
11790 suppress_error = 0;
11791 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11796 char fstype[] = "ext2";
11797 char device[] = "/dev/sda1";
11798 device[5] = devchar;
11800 suppress_error = 0;
11801 r = guestfs_mkfs (g, fstype, device);
11806 char device[] = "/dev/sda1";
11807 device[5] = devchar;
11808 char mountpoint[] = "/";
11810 suppress_error = 0;
11811 r = guestfs_mount (g, device, mountpoint);
11815 /* TestOutputList for read_lines (0) */
11817 char path[] = "/new";
11818 char content[] = "line1\r\nline2\nline3";
11820 suppress_error = 0;
11821 r = guestfs_write_file (g, path, content, 0);
11826 char path[] = "/new";
11829 suppress_error = 0;
11830 r = guestfs_read_lines (g, path);
11834 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11839 char expected[] = "line1";
11840 if (strcmp (r[0], expected) != 0) {
11841 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11846 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11851 char expected[] = "line2";
11852 if (strcmp (r[1], expected) != 0) {
11853 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11858 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11863 char expected[] = "line3";
11864 if (strcmp (r[2], expected) != 0) {
11865 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11869 if (r[3] != NULL) {
11870 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11874 for (i = 0; r[i] != NULL; ++i)
11881 static int test_read_lines_1 (void)
11883 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
11885 char device[] = "/dev/sda";
11886 device[5] = devchar;
11888 suppress_error = 0;
11889 r = guestfs_blockdev_setrw (g, device);
11895 suppress_error = 0;
11896 r = guestfs_umount_all (g);
11902 suppress_error = 0;
11903 r = guestfs_lvm_remove_all (g);
11908 char device[] = "/dev/sda";
11909 device[5] = devchar;
11910 char lines_0[] = ",";
11916 suppress_error = 0;
11917 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11922 char fstype[] = "ext2";
11923 char device[] = "/dev/sda1";
11924 device[5] = devchar;
11926 suppress_error = 0;
11927 r = guestfs_mkfs (g, fstype, device);
11932 char device[] = "/dev/sda1";
11933 device[5] = devchar;
11934 char mountpoint[] = "/";
11936 suppress_error = 0;
11937 r = guestfs_mount (g, device, mountpoint);
11941 /* TestOutputList for read_lines (1) */
11943 char path[] = "/new";
11944 char content[] = "";
11946 suppress_error = 0;
11947 r = guestfs_write_file (g, path, content, 0);
11952 char path[] = "/new";
11955 suppress_error = 0;
11956 r = guestfs_read_lines (g, path);
11959 if (r[0] != NULL) {
11960 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11964 for (i = 0; r[i] != NULL; ++i)
11971 static int test_lvs_0 (void)
11973 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
11975 char device[] = "/dev/sda";
11976 device[5] = devchar;
11978 suppress_error = 0;
11979 r = guestfs_blockdev_setrw (g, device);
11985 suppress_error = 0;
11986 r = guestfs_umount_all (g);
11992 suppress_error = 0;
11993 r = guestfs_lvm_remove_all (g);
11998 char device[] = "/dev/sda";
11999 device[5] = devchar;
12000 char lines_0[] = ",";
12006 suppress_error = 0;
12007 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12012 char device[] = "/dev/sda1";
12013 device[5] = devchar;
12015 suppress_error = 0;
12016 r = guestfs_pvcreate (g, device);
12021 char volgroup[] = "VG";
12022 char physvols_0[] = "/dev/sda1";
12023 physvols_0[5] = devchar;
12024 char *physvols[] = {
12029 suppress_error = 0;
12030 r = guestfs_vgcreate (g, volgroup, physvols);
12035 char logvol[] = "LV";
12036 char volgroup[] = "VG";
12038 suppress_error = 0;
12039 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12044 char fstype[] = "ext2";
12045 char device[] = "/dev/VG/LV";
12047 suppress_error = 0;
12048 r = guestfs_mkfs (g, fstype, device);
12053 char device[] = "/dev/VG/LV";
12054 char mountpoint[] = "/";
12056 suppress_error = 0;
12057 r = guestfs_mount (g, device, mountpoint);
12061 /* TestOutputList for lvs (0) */
12065 suppress_error = 0;
12066 r = guestfs_lvs (g);
12070 fprintf (stderr, "test_lvs_0: short list returned from command\n");
12075 char expected[] = "/dev/VG/LV";
12076 if (strcmp (r[0], expected) != 0) {
12077 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12081 if (r[1] != NULL) {
12082 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
12086 for (i = 0; r[i] != NULL; ++i)
12093 static int test_lvs_1 (void)
12095 /* InitNone|InitEmpty for test_lvs_1 */
12097 char device[] = "/dev/sda";
12098 device[5] = devchar;
12100 suppress_error = 0;
12101 r = guestfs_blockdev_setrw (g, device);
12107 suppress_error = 0;
12108 r = guestfs_umount_all (g);
12114 suppress_error = 0;
12115 r = guestfs_lvm_remove_all (g);
12119 /* TestOutputList for lvs (1) */
12121 char device[] = "/dev/sda";
12122 device[5] = devchar;
12123 char lines_0[] = ",10";
12124 char lines_1[] = ",20";
12125 char lines_2[] = ",";
12133 suppress_error = 0;
12134 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12139 char device[] = "/dev/sda1";
12140 device[5] = devchar;
12142 suppress_error = 0;
12143 r = guestfs_pvcreate (g, device);
12148 char device[] = "/dev/sda2";
12149 device[5] = devchar;
12151 suppress_error = 0;
12152 r = guestfs_pvcreate (g, device);
12157 char device[] = "/dev/sda3";
12158 device[5] = devchar;
12160 suppress_error = 0;
12161 r = guestfs_pvcreate (g, device);
12166 char volgroup[] = "VG1";
12167 char physvols_0[] = "/dev/sda1";
12168 physvols_0[5] = devchar;
12169 char physvols_1[] = "/dev/sda2";
12170 physvols_1[5] = devchar;
12171 char *physvols[] = {
12177 suppress_error = 0;
12178 r = guestfs_vgcreate (g, volgroup, physvols);
12183 char volgroup[] = "VG2";
12184 char physvols_0[] = "/dev/sda3";
12185 physvols_0[5] = devchar;
12186 char *physvols[] = {
12191 suppress_error = 0;
12192 r = guestfs_vgcreate (g, volgroup, physvols);
12197 char logvol[] = "LV1";
12198 char volgroup[] = "VG1";
12200 suppress_error = 0;
12201 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12206 char logvol[] = "LV2";
12207 char volgroup[] = "VG1";
12209 suppress_error = 0;
12210 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12215 char logvol[] = "LV3";
12216 char volgroup[] = "VG2";
12218 suppress_error = 0;
12219 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12226 suppress_error = 0;
12227 r = guestfs_lvs (g);
12231 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12236 char expected[] = "/dev/VG1/LV1";
12237 if (strcmp (r[0], expected) != 0) {
12238 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12243 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12248 char expected[] = "/dev/VG1/LV2";
12249 if (strcmp (r[1], expected) != 0) {
12250 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12255 fprintf (stderr, "test_lvs_1: short list returned from command\n");
12260 char expected[] = "/dev/VG2/LV3";
12261 if (strcmp (r[2], expected) != 0) {
12262 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12266 if (r[3] != NULL) {
12267 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
12271 for (i = 0; r[i] != NULL; ++i)
12278 static int test_vgs_0 (void)
12280 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
12282 char device[] = "/dev/sda";
12283 device[5] = devchar;
12285 suppress_error = 0;
12286 r = guestfs_blockdev_setrw (g, device);
12292 suppress_error = 0;
12293 r = guestfs_umount_all (g);
12299 suppress_error = 0;
12300 r = guestfs_lvm_remove_all (g);
12305 char device[] = "/dev/sda";
12306 device[5] = devchar;
12307 char lines_0[] = ",";
12313 suppress_error = 0;
12314 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12319 char device[] = "/dev/sda1";
12320 device[5] = devchar;
12322 suppress_error = 0;
12323 r = guestfs_pvcreate (g, device);
12328 char volgroup[] = "VG";
12329 char physvols_0[] = "/dev/sda1";
12330 physvols_0[5] = devchar;
12331 char *physvols[] = {
12336 suppress_error = 0;
12337 r = guestfs_vgcreate (g, volgroup, physvols);
12342 char logvol[] = "LV";
12343 char volgroup[] = "VG";
12345 suppress_error = 0;
12346 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12351 char fstype[] = "ext2";
12352 char device[] = "/dev/VG/LV";
12354 suppress_error = 0;
12355 r = guestfs_mkfs (g, fstype, device);
12360 char device[] = "/dev/VG/LV";
12361 char mountpoint[] = "/";
12363 suppress_error = 0;
12364 r = guestfs_mount (g, device, mountpoint);
12368 /* TestOutputList for vgs (0) */
12372 suppress_error = 0;
12373 r = guestfs_vgs (g);
12377 fprintf (stderr, "test_vgs_0: short list returned from command\n");
12382 char expected[] = "VG";
12383 if (strcmp (r[0], expected) != 0) {
12384 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12388 if (r[1] != NULL) {
12389 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12393 for (i = 0; r[i] != NULL; ++i)
12400 static int test_vgs_1 (void)
12402 /* InitNone|InitEmpty for test_vgs_1 */
12404 char device[] = "/dev/sda";
12405 device[5] = devchar;
12407 suppress_error = 0;
12408 r = guestfs_blockdev_setrw (g, device);
12414 suppress_error = 0;
12415 r = guestfs_umount_all (g);
12421 suppress_error = 0;
12422 r = guestfs_lvm_remove_all (g);
12426 /* TestOutputList for vgs (1) */
12428 char device[] = "/dev/sda";
12429 device[5] = devchar;
12430 char lines_0[] = ",10";
12431 char lines_1[] = ",20";
12432 char lines_2[] = ",";
12440 suppress_error = 0;
12441 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12446 char device[] = "/dev/sda1";
12447 device[5] = devchar;
12449 suppress_error = 0;
12450 r = guestfs_pvcreate (g, device);
12455 char device[] = "/dev/sda2";
12456 device[5] = devchar;
12458 suppress_error = 0;
12459 r = guestfs_pvcreate (g, device);
12464 char device[] = "/dev/sda3";
12465 device[5] = devchar;
12467 suppress_error = 0;
12468 r = guestfs_pvcreate (g, device);
12473 char volgroup[] = "VG1";
12474 char physvols_0[] = "/dev/sda1";
12475 physvols_0[5] = devchar;
12476 char physvols_1[] = "/dev/sda2";
12477 physvols_1[5] = devchar;
12478 char *physvols[] = {
12484 suppress_error = 0;
12485 r = guestfs_vgcreate (g, volgroup, physvols);
12490 char volgroup[] = "VG2";
12491 char physvols_0[] = "/dev/sda3";
12492 physvols_0[5] = devchar;
12493 char *physvols[] = {
12498 suppress_error = 0;
12499 r = guestfs_vgcreate (g, volgroup, physvols);
12506 suppress_error = 0;
12507 r = guestfs_vgs (g);
12511 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12516 char expected[] = "VG1";
12517 if (strcmp (r[0], expected) != 0) {
12518 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12523 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12528 char expected[] = "VG2";
12529 if (strcmp (r[1], expected) != 0) {
12530 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12534 if (r[2] != NULL) {
12535 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12539 for (i = 0; r[i] != NULL; ++i)
12546 static int test_pvs_0 (void)
12548 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12550 char device[] = "/dev/sda";
12551 device[5] = devchar;
12553 suppress_error = 0;
12554 r = guestfs_blockdev_setrw (g, device);
12560 suppress_error = 0;
12561 r = guestfs_umount_all (g);
12567 suppress_error = 0;
12568 r = guestfs_lvm_remove_all (g);
12573 char device[] = "/dev/sda";
12574 device[5] = devchar;
12575 char lines_0[] = ",";
12581 suppress_error = 0;
12582 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12587 char device[] = "/dev/sda1";
12588 device[5] = devchar;
12590 suppress_error = 0;
12591 r = guestfs_pvcreate (g, device);
12596 char volgroup[] = "VG";
12597 char physvols_0[] = "/dev/sda1";
12598 physvols_0[5] = devchar;
12599 char *physvols[] = {
12604 suppress_error = 0;
12605 r = guestfs_vgcreate (g, volgroup, physvols);
12610 char logvol[] = "LV";
12611 char volgroup[] = "VG";
12613 suppress_error = 0;
12614 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12619 char fstype[] = "ext2";
12620 char device[] = "/dev/VG/LV";
12622 suppress_error = 0;
12623 r = guestfs_mkfs (g, fstype, device);
12628 char device[] = "/dev/VG/LV";
12629 char mountpoint[] = "/";
12631 suppress_error = 0;
12632 r = guestfs_mount (g, device, mountpoint);
12636 /* TestOutputList for pvs (0) */
12640 suppress_error = 0;
12641 r = guestfs_pvs (g);
12645 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12650 char expected[] = "/dev/sda1";
12651 expected[5] = devchar;
12652 if (strcmp (r[0], expected) != 0) {
12653 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12657 if (r[1] != NULL) {
12658 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12662 for (i = 0; r[i] != NULL; ++i)
12669 static int test_pvs_1 (void)
12671 /* InitNone|InitEmpty for test_pvs_1 */
12673 char device[] = "/dev/sda";
12674 device[5] = devchar;
12676 suppress_error = 0;
12677 r = guestfs_blockdev_setrw (g, device);
12683 suppress_error = 0;
12684 r = guestfs_umount_all (g);
12690 suppress_error = 0;
12691 r = guestfs_lvm_remove_all (g);
12695 /* TestOutputList for pvs (1) */
12697 char device[] = "/dev/sda";
12698 device[5] = devchar;
12699 char lines_0[] = ",10";
12700 char lines_1[] = ",20";
12701 char lines_2[] = ",";
12709 suppress_error = 0;
12710 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12715 char device[] = "/dev/sda1";
12716 device[5] = devchar;
12718 suppress_error = 0;
12719 r = guestfs_pvcreate (g, device);
12724 char device[] = "/dev/sda2";
12725 device[5] = devchar;
12727 suppress_error = 0;
12728 r = guestfs_pvcreate (g, device);
12733 char device[] = "/dev/sda3";
12734 device[5] = devchar;
12736 suppress_error = 0;
12737 r = guestfs_pvcreate (g, device);
12744 suppress_error = 0;
12745 r = guestfs_pvs (g);
12749 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12754 char expected[] = "/dev/sda1";
12755 expected[5] = devchar;
12756 if (strcmp (r[0], expected) != 0) {
12757 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12762 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12767 char expected[] = "/dev/sda2";
12768 expected[5] = devchar;
12769 if (strcmp (r[1], expected) != 0) {
12770 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12775 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12780 char expected[] = "/dev/sda3";
12781 expected[5] = devchar;
12782 if (strcmp (r[2], expected) != 0) {
12783 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12787 if (r[3] != NULL) {
12788 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12792 for (i = 0; r[i] != NULL; ++i)
12799 static int test_list_partitions_0 (void)
12801 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
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);
12826 char device[] = "/dev/sda";
12827 device[5] = devchar;
12828 char lines_0[] = ",";
12834 suppress_error = 0;
12835 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12840 char fstype[] = "ext2";
12841 char device[] = "/dev/sda1";
12842 device[5] = devchar;
12844 suppress_error = 0;
12845 r = guestfs_mkfs (g, fstype, device);
12850 char device[] = "/dev/sda1";
12851 device[5] = devchar;
12852 char mountpoint[] = "/";
12854 suppress_error = 0;
12855 r = guestfs_mount (g, device, mountpoint);
12859 /* TestOutputList for list_partitions (0) */
12863 suppress_error = 0;
12864 r = guestfs_list_partitions (g);
12868 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12873 char expected[] = "/dev/sda1";
12874 expected[5] = devchar;
12875 if (strcmp (r[0], expected) != 0) {
12876 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12880 if (r[1] != NULL) {
12881 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12885 for (i = 0; r[i] != NULL; ++i)
12892 static int test_list_partitions_1 (void)
12894 /* InitNone|InitEmpty for test_list_partitions_1 */
12896 char device[] = "/dev/sda";
12897 device[5] = devchar;
12899 suppress_error = 0;
12900 r = guestfs_blockdev_setrw (g, device);
12906 suppress_error = 0;
12907 r = guestfs_umount_all (g);
12913 suppress_error = 0;
12914 r = guestfs_lvm_remove_all (g);
12918 /* TestOutputList for list_partitions (1) */
12920 char device[] = "/dev/sda";
12921 device[5] = devchar;
12922 char lines_0[] = ",10";
12923 char lines_1[] = ",20";
12924 char lines_2[] = ",";
12932 suppress_error = 0;
12933 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12940 suppress_error = 0;
12941 r = guestfs_list_partitions (g);
12945 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12950 char expected[] = "/dev/sda1";
12951 expected[5] = devchar;
12952 if (strcmp (r[0], expected) != 0) {
12953 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12958 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12963 char expected[] = "/dev/sda2";
12964 expected[5] = devchar;
12965 if (strcmp (r[1], expected) != 0) {
12966 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12971 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12976 char expected[] = "/dev/sda3";
12977 expected[5] = devchar;
12978 if (strcmp (r[2], expected) != 0) {
12979 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12983 if (r[3] != NULL) {
12984 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12988 for (i = 0; r[i] != NULL; ++i)
12995 static int test_list_devices_0 (void)
12997 /* InitNone|InitEmpty for test_list_devices_0 */
12999 char device[] = "/dev/sda";
13000 device[5] = devchar;
13002 suppress_error = 0;
13003 r = guestfs_blockdev_setrw (g, device);
13009 suppress_error = 0;
13010 r = guestfs_umount_all (g);
13016 suppress_error = 0;
13017 r = guestfs_lvm_remove_all (g);
13021 /* TestOutputList for list_devices (0) */
13025 suppress_error = 0;
13026 r = guestfs_list_devices (g);
13030 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13035 char expected[] = "/dev/sda";
13036 expected[5] = devchar;
13037 if (strcmp (r[0], expected) != 0) {
13038 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13043 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13048 char expected[] = "/dev/sdb";
13049 expected[5] = devchar;
13050 if (strcmp (r[1], expected) != 0) {
13051 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13056 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
13061 char expected[] = "/dev/sdc";
13062 expected[5] = devchar;
13063 if (strcmp (r[2], expected) != 0) {
13064 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13068 if (r[3] != NULL) {
13069 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
13073 for (i = 0; r[i] != NULL; ++i)
13080 static int test_ls_0 (void)
13082 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
13084 char device[] = "/dev/sda";
13085 device[5] = devchar;
13087 suppress_error = 0;
13088 r = guestfs_blockdev_setrw (g, device);
13094 suppress_error = 0;
13095 r = guestfs_umount_all (g);
13101 suppress_error = 0;
13102 r = guestfs_lvm_remove_all (g);
13107 char device[] = "/dev/sda";
13108 device[5] = devchar;
13109 char lines_0[] = ",";
13115 suppress_error = 0;
13116 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13121 char fstype[] = "ext2";
13122 char device[] = "/dev/sda1";
13123 device[5] = devchar;
13125 suppress_error = 0;
13126 r = guestfs_mkfs (g, fstype, device);
13131 char device[] = "/dev/sda1";
13132 device[5] = devchar;
13133 char mountpoint[] = "/";
13135 suppress_error = 0;
13136 r = guestfs_mount (g, device, mountpoint);
13140 /* TestOutputList for ls (0) */
13142 char path[] = "/new";
13144 suppress_error = 0;
13145 r = guestfs_touch (g, path);
13150 char path[] = "/newer";
13152 suppress_error = 0;
13153 r = guestfs_touch (g, path);
13158 char path[] = "/newest";
13160 suppress_error = 0;
13161 r = guestfs_touch (g, path);
13166 char directory[] = "/";
13169 suppress_error = 0;
13170 r = guestfs_ls (g, directory);
13174 fprintf (stderr, "test_ls_0: short list returned from command\n");
13179 char expected[] = "lost+found";
13180 if (strcmp (r[0], expected) != 0) {
13181 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13186 fprintf (stderr, "test_ls_0: short list returned from command\n");
13191 char expected[] = "new";
13192 if (strcmp (r[1], expected) != 0) {
13193 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13198 fprintf (stderr, "test_ls_0: short list returned from command\n");
13203 char expected[] = "newer";
13204 if (strcmp (r[2], expected) != 0) {
13205 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13210 fprintf (stderr, "test_ls_0: short list returned from command\n");
13215 char expected[] = "newest";
13216 if (strcmp (r[3], expected) != 0) {
13217 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
13221 if (r[4] != NULL) {
13222 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
13226 for (i = 0; r[i] != NULL; ++i)
13233 static int test_cat_0 (void)
13235 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
13237 char device[] = "/dev/sda";
13238 device[5] = devchar;
13240 suppress_error = 0;
13241 r = guestfs_blockdev_setrw (g, device);
13247 suppress_error = 0;
13248 r = guestfs_umount_all (g);
13254 suppress_error = 0;
13255 r = guestfs_lvm_remove_all (g);
13260 char device[] = "/dev/sda";
13261 device[5] = devchar;
13262 char lines_0[] = ",";
13268 suppress_error = 0;
13269 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13274 char fstype[] = "ext2";
13275 char device[] = "/dev/sda1";
13276 device[5] = devchar;
13278 suppress_error = 0;
13279 r = guestfs_mkfs (g, fstype, device);
13284 char device[] = "/dev/sda1";
13285 device[5] = devchar;
13286 char mountpoint[] = "/";
13288 suppress_error = 0;
13289 r = guestfs_mount (g, device, mountpoint);
13293 /* TestOutput for cat (0) */
13294 char expected[] = "new file contents";
13296 char path[] = "/new";
13297 char content[] = "new file contents";
13299 suppress_error = 0;
13300 r = guestfs_write_file (g, path, content, 0);
13305 char path[] = "/new";
13307 suppress_error = 0;
13308 r = guestfs_cat (g, path);
13311 if (strcmp (r, expected) != 0) {
13312 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
13320 static int test_touch_0 (void)
13322 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
13324 char device[] = "/dev/sda";
13325 device[5] = devchar;
13327 suppress_error = 0;
13328 r = guestfs_blockdev_setrw (g, device);
13334 suppress_error = 0;
13335 r = guestfs_umount_all (g);
13341 suppress_error = 0;
13342 r = guestfs_lvm_remove_all (g);
13347 char device[] = "/dev/sda";
13348 device[5] = devchar;
13349 char lines_0[] = ",";
13355 suppress_error = 0;
13356 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13361 char fstype[] = "ext2";
13362 char device[] = "/dev/sda1";
13363 device[5] = devchar;
13365 suppress_error = 0;
13366 r = guestfs_mkfs (g, fstype, device);
13371 char device[] = "/dev/sda1";
13372 device[5] = devchar;
13373 char mountpoint[] = "/";
13375 suppress_error = 0;
13376 r = guestfs_mount (g, device, mountpoint);
13380 /* TestOutputTrue for touch (0) */
13382 char path[] = "/new";
13384 suppress_error = 0;
13385 r = guestfs_touch (g, path);
13390 char path[] = "/new";
13392 suppress_error = 0;
13393 r = guestfs_exists (g, path);
13397 fprintf (stderr, "test_touch_0: expected true, got false\n");
13404 static int test_sync_0 (void)
13406 /* InitNone|InitEmpty for test_sync_0 */
13408 char device[] = "/dev/sda";
13409 device[5] = devchar;
13411 suppress_error = 0;
13412 r = guestfs_blockdev_setrw (g, device);
13418 suppress_error = 0;
13419 r = guestfs_umount_all (g);
13425 suppress_error = 0;
13426 r = guestfs_lvm_remove_all (g);
13430 /* TestRun for sync (0) */
13433 suppress_error = 0;
13434 r = guestfs_sync (g);
13441 static int test_mount_0 (void)
13443 /* InitNone|InitEmpty for test_mount_0 */
13445 char device[] = "/dev/sda";
13446 device[5] = devchar;
13448 suppress_error = 0;
13449 r = guestfs_blockdev_setrw (g, device);
13455 suppress_error = 0;
13456 r = guestfs_umount_all (g);
13462 suppress_error = 0;
13463 r = guestfs_lvm_remove_all (g);
13467 /* TestOutput for mount (0) */
13468 char expected[] = "new file contents";
13470 char device[] = "/dev/sda";
13471 device[5] = devchar;
13472 char lines_0[] = ",";
13478 suppress_error = 0;
13479 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13484 char fstype[] = "ext2";
13485 char device[] = "/dev/sda1";
13486 device[5] = devchar;
13488 suppress_error = 0;
13489 r = guestfs_mkfs (g, fstype, device);
13494 char device[] = "/dev/sda1";
13495 device[5] = devchar;
13496 char mountpoint[] = "/";
13498 suppress_error = 0;
13499 r = guestfs_mount (g, device, mountpoint);
13504 char path[] = "/new";
13505 char content[] = "new file contents";
13507 suppress_error = 0;
13508 r = guestfs_write_file (g, path, content, 0);
13513 char path[] = "/new";
13515 suppress_error = 0;
13516 r = guestfs_cat (g, path);
13519 if (strcmp (r, expected) != 0) {
13520 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13528 int main (int argc, char *argv[])
13532 const char *srcdir;
13533 const char *filename;
13535 int nr_tests, test_num = 0;
13538 no_test_warnings ();
13540 g = guestfs_create ();
13542 printf ("guestfs_create FAILED\n");
13546 guestfs_set_error_handler (g, print_error, NULL);
13548 srcdir = getenv ("srcdir");
13549 if (!srcdir) srcdir = ".";
13551 guestfs_set_path (g, ".");
13553 filename = "test1.img";
13554 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13559 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13565 if (write (fd, &c, 1) == -1) {
13571 if (close (fd) == -1) {
13576 if (guestfs_add_drive (g, filename) == -1) {
13577 printf ("guestfs_add_drive %s FAILED\n", filename);
13581 filename = "test2.img";
13582 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13587 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13593 if (write (fd, &c, 1) == -1) {
13599 if (close (fd) == -1) {
13604 if (guestfs_add_drive (g, filename) == -1) {
13605 printf ("guestfs_add_drive %s FAILED\n", filename);
13609 filename = "test3.img";
13610 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13615 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13621 if (write (fd, &c, 1) == -1) {
13627 if (close (fd) == -1) {
13632 if (guestfs_add_drive (g, filename) == -1) {
13633 printf ("guestfs_add_drive %s FAILED\n", filename);
13637 if (guestfs_launch (g) == -1) {
13638 printf ("guestfs_launch FAILED\n");
13641 if (guestfs_wait_ready (g) == -1) {
13642 printf ("guestfs_wait_ready FAILED\n");
13646 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13647 * names. This changed between RHEL 5 and RHEL 6 so we have to
13650 devs = guestfs_list_devices (g);
13651 if (devs == NULL || devs[0] == NULL) {
13652 printf ("guestfs_list_devices FAILED\n");
13655 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13657 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13660 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13664 for (i = 0; devs[i] != NULL; ++i)
13671 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
13672 if (test_find_0 () == -1) {
13673 printf ("test_find_0 FAILED\n");
13677 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
13678 if (test_find_1 () == -1) {
13679 printf ("test_find_1 FAILED\n");
13683 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
13684 if (test_find_2 () == -1) {
13685 printf ("test_find_2 FAILED\n");
13689 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13690 if (test_lvresize_0 () == -1) {
13691 printf ("test_lvresize_0 FAILED\n");
13695 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13696 if (test_zerofree_0 () == -1) {
13697 printf ("test_zerofree_0 FAILED\n");
13701 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13702 if (test_hexdump_0 () == -1) {
13703 printf ("test_hexdump_0 FAILED\n");
13707 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13708 if (test_strings_e_0 () == -1) {
13709 printf ("test_strings_e_0 FAILED\n");
13713 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13714 if (test_strings_e_1 () == -1) {
13715 printf ("test_strings_e_1 FAILED\n");
13719 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13720 if (test_strings_0 () == -1) {
13721 printf ("test_strings_0 FAILED\n");
13725 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13726 if (test_strings_1 () == -1) {
13727 printf ("test_strings_1 FAILED\n");
13731 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13732 if (test_equal_0 () == -1) {
13733 printf ("test_equal_0 FAILED\n");
13737 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13738 if (test_equal_1 () == -1) {
13739 printf ("test_equal_1 FAILED\n");
13743 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13744 if (test_equal_2 () == -1) {
13745 printf ("test_equal_2 FAILED\n");
13749 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13750 if (test_ping_daemon_0 () == -1) {
13751 printf ("test_ping_daemon_0 FAILED\n");
13755 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13756 if (test_dmesg_0 () == -1) {
13757 printf ("test_dmesg_0 FAILED\n");
13761 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13762 if (test_drop_caches_0 () == -1) {
13763 printf ("test_drop_caches_0 FAILED\n");
13767 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13768 if (test_mv_0 () == -1) {
13769 printf ("test_mv_0 FAILED\n");
13773 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13774 if (test_mv_1 () == -1) {
13775 printf ("test_mv_1 FAILED\n");
13779 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13780 if (test_cp_a_0 () == -1) {
13781 printf ("test_cp_a_0 FAILED\n");
13785 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13786 if (test_cp_0 () == -1) {
13787 printf ("test_cp_0 FAILED\n");
13791 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13792 if (test_cp_1 () == -1) {
13793 printf ("test_cp_1 FAILED\n");
13797 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13798 if (test_cp_2 () == -1) {
13799 printf ("test_cp_2 FAILED\n");
13803 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13804 if (test_grub_install_0 () == -1) {
13805 printf ("test_grub_install_0 FAILED\n");
13809 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13810 if (test_zero_0 () == -1) {
13811 printf ("test_zero_0 FAILED\n");
13815 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13816 if (test_fsck_0 () == -1) {
13817 printf ("test_fsck_0 FAILED\n");
13821 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13822 if (test_fsck_1 () == -1) {
13823 printf ("test_fsck_1 FAILED\n");
13827 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13828 if (test_set_e2uuid_0 () == -1) {
13829 printf ("test_set_e2uuid_0 FAILED\n");
13833 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13834 if (test_set_e2uuid_1 () == -1) {
13835 printf ("test_set_e2uuid_1 FAILED\n");
13839 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13840 if (test_set_e2uuid_2 () == -1) {
13841 printf ("test_set_e2uuid_2 FAILED\n");
13845 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13846 if (test_set_e2uuid_3 () == -1) {
13847 printf ("test_set_e2uuid_3 FAILED\n");
13851 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13852 if (test_set_e2label_0 () == -1) {
13853 printf ("test_set_e2label_0 FAILED\n");
13857 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13858 if (test_pvremove_0 () == -1) {
13859 printf ("test_pvremove_0 FAILED\n");
13863 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13864 if (test_pvremove_1 () == -1) {
13865 printf ("test_pvremove_1 FAILED\n");
13869 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13870 if (test_pvremove_2 () == -1) {
13871 printf ("test_pvremove_2 FAILED\n");
13875 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13876 if (test_vgremove_0 () == -1) {
13877 printf ("test_vgremove_0 FAILED\n");
13881 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13882 if (test_vgremove_1 () == -1) {
13883 printf ("test_vgremove_1 FAILED\n");
13887 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13888 if (test_lvremove_0 () == -1) {
13889 printf ("test_lvremove_0 FAILED\n");
13893 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13894 if (test_lvremove_1 () == -1) {
13895 printf ("test_lvremove_1 FAILED\n");
13899 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13900 if (test_lvremove_2 () == -1) {
13901 printf ("test_lvremove_2 FAILED\n");
13905 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13906 if (test_mount_ro_0 () == -1) {
13907 printf ("test_mount_ro_0 FAILED\n");
13911 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13912 if (test_mount_ro_1 () == -1) {
13913 printf ("test_mount_ro_1 FAILED\n");
13917 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13918 if (test_tgz_in_0 () == -1) {
13919 printf ("test_tgz_in_0 FAILED\n");
13923 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13924 if (test_tar_in_0 () == -1) {
13925 printf ("test_tar_in_0 FAILED\n");
13929 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13930 if (test_checksum_0 () == -1) {
13931 printf ("test_checksum_0 FAILED\n");
13935 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13936 if (test_checksum_1 () == -1) {
13937 printf ("test_checksum_1 FAILED\n");
13941 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13942 if (test_checksum_2 () == -1) {
13943 printf ("test_checksum_2 FAILED\n");
13947 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13948 if (test_checksum_3 () == -1) {
13949 printf ("test_checksum_3 FAILED\n");
13953 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13954 if (test_checksum_4 () == -1) {
13955 printf ("test_checksum_4 FAILED\n");
13959 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13960 if (test_checksum_5 () == -1) {
13961 printf ("test_checksum_5 FAILED\n");
13965 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13966 if (test_checksum_6 () == -1) {
13967 printf ("test_checksum_6 FAILED\n");
13971 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13972 if (test_checksum_7 () == -1) {
13973 printf ("test_checksum_7 FAILED\n");
13977 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13978 if (test_download_0 () == -1) {
13979 printf ("test_download_0 FAILED\n");
13983 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13984 if (test_upload_0 () == -1) {
13985 printf ("test_upload_0 FAILED\n");
13989 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13990 if (test_blockdev_rereadpt_0 () == -1) {
13991 printf ("test_blockdev_rereadpt_0 FAILED\n");
13995 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13996 if (test_blockdev_flushbufs_0 () == -1) {
13997 printf ("test_blockdev_flushbufs_0 FAILED\n");
14001 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
14002 if (test_blockdev_getsize64_0 () == -1) {
14003 printf ("test_blockdev_getsize64_0 FAILED\n");
14007 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
14008 if (test_blockdev_getsz_0 () == -1) {
14009 printf ("test_blockdev_getsz_0 FAILED\n");
14013 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
14014 if (test_blockdev_getbsz_0 () == -1) {
14015 printf ("test_blockdev_getbsz_0 FAILED\n");
14019 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
14020 if (test_blockdev_getss_0 () == -1) {
14021 printf ("test_blockdev_getss_0 FAILED\n");
14025 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
14026 if (test_blockdev_getro_0 () == -1) {
14027 printf ("test_blockdev_getro_0 FAILED\n");
14031 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
14032 if (test_blockdev_setrw_0 () == -1) {
14033 printf ("test_blockdev_setrw_0 FAILED\n");
14037 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
14038 if (test_blockdev_setro_0 () == -1) {
14039 printf ("test_blockdev_setro_0 FAILED\n");
14043 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
14044 if (test_statvfs_0 () == -1) {
14045 printf ("test_statvfs_0 FAILED\n");
14049 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
14050 if (test_lstat_0 () == -1) {
14051 printf ("test_lstat_0 FAILED\n");
14055 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
14056 if (test_stat_0 () == -1) {
14057 printf ("test_stat_0 FAILED\n");
14061 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
14062 if (test_command_lines_0 () == -1) {
14063 printf ("test_command_lines_0 FAILED\n");
14067 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
14068 if (test_command_lines_1 () == -1) {
14069 printf ("test_command_lines_1 FAILED\n");
14073 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
14074 if (test_command_lines_2 () == -1) {
14075 printf ("test_command_lines_2 FAILED\n");
14079 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
14080 if (test_command_lines_3 () == -1) {
14081 printf ("test_command_lines_3 FAILED\n");
14085 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
14086 if (test_command_lines_4 () == -1) {
14087 printf ("test_command_lines_4 FAILED\n");
14091 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
14092 if (test_command_lines_5 () == -1) {
14093 printf ("test_command_lines_5 FAILED\n");
14097 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
14098 if (test_command_lines_6 () == -1) {
14099 printf ("test_command_lines_6 FAILED\n");
14103 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
14104 if (test_command_lines_7 () == -1) {
14105 printf ("test_command_lines_7 FAILED\n");
14109 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
14110 if (test_command_lines_8 () == -1) {
14111 printf ("test_command_lines_8 FAILED\n");
14115 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
14116 if (test_command_lines_9 () == -1) {
14117 printf ("test_command_lines_9 FAILED\n");
14121 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
14122 if (test_command_lines_10 () == -1) {
14123 printf ("test_command_lines_10 FAILED\n");
14127 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
14128 if (test_command_0 () == -1) {
14129 printf ("test_command_0 FAILED\n");
14133 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
14134 if (test_command_1 () == -1) {
14135 printf ("test_command_1 FAILED\n");
14139 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
14140 if (test_command_2 () == -1) {
14141 printf ("test_command_2 FAILED\n");
14145 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
14146 if (test_command_3 () == -1) {
14147 printf ("test_command_3 FAILED\n");
14151 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
14152 if (test_command_4 () == -1) {
14153 printf ("test_command_4 FAILED\n");
14157 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
14158 if (test_command_5 () == -1) {
14159 printf ("test_command_5 FAILED\n");
14163 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
14164 if (test_command_6 () == -1) {
14165 printf ("test_command_6 FAILED\n");
14169 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
14170 if (test_command_7 () == -1) {
14171 printf ("test_command_7 FAILED\n");
14175 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
14176 if (test_command_8 () == -1) {
14177 printf ("test_command_8 FAILED\n");
14181 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
14182 if (test_command_9 () == -1) {
14183 printf ("test_command_9 FAILED\n");
14187 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
14188 if (test_command_10 () == -1) {
14189 printf ("test_command_10 FAILED\n");
14193 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
14194 if (test_command_11 () == -1) {
14195 printf ("test_command_11 FAILED\n");
14199 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
14200 if (test_file_0 () == -1) {
14201 printf ("test_file_0 FAILED\n");
14205 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
14206 if (test_file_1 () == -1) {
14207 printf ("test_file_1 FAILED\n");
14211 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
14212 if (test_file_2 () == -1) {
14213 printf ("test_file_2 FAILED\n");
14217 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
14218 if (test_umount_all_0 () == -1) {
14219 printf ("test_umount_all_0 FAILED\n");
14223 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
14224 if (test_umount_all_1 () == -1) {
14225 printf ("test_umount_all_1 FAILED\n");
14229 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
14230 if (test_mounts_0 () == -1) {
14231 printf ("test_mounts_0 FAILED\n");
14235 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
14236 if (test_umount_0 () == -1) {
14237 printf ("test_umount_0 FAILED\n");
14241 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
14242 if (test_umount_1 () == -1) {
14243 printf ("test_umount_1 FAILED\n");
14247 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
14248 if (test_write_file_0 () == -1) {
14249 printf ("test_write_file_0 FAILED\n");
14253 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
14254 if (test_write_file_1 () == -1) {
14255 printf ("test_write_file_1 FAILED\n");
14259 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
14260 if (test_write_file_2 () == -1) {
14261 printf ("test_write_file_2 FAILED\n");
14265 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
14266 if (test_write_file_3 () == -1) {
14267 printf ("test_write_file_3 FAILED\n");
14271 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
14272 if (test_write_file_4 () == -1) {
14273 printf ("test_write_file_4 FAILED\n");
14277 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
14278 if (test_write_file_5 () == -1) {
14279 printf ("test_write_file_5 FAILED\n");
14283 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
14284 if (test_mkfs_0 () == -1) {
14285 printf ("test_mkfs_0 FAILED\n");
14289 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
14290 if (test_lvcreate_0 () == -1) {
14291 printf ("test_lvcreate_0 FAILED\n");
14295 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
14296 if (test_vgcreate_0 () == -1) {
14297 printf ("test_vgcreate_0 FAILED\n");
14301 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
14302 if (test_pvcreate_0 () == -1) {
14303 printf ("test_pvcreate_0 FAILED\n");
14307 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
14308 if (test_is_dir_0 () == -1) {
14309 printf ("test_is_dir_0 FAILED\n");
14313 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
14314 if (test_is_dir_1 () == -1) {
14315 printf ("test_is_dir_1 FAILED\n");
14319 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
14320 if (test_is_file_0 () == -1) {
14321 printf ("test_is_file_0 FAILED\n");
14325 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
14326 if (test_is_file_1 () == -1) {
14327 printf ("test_is_file_1 FAILED\n");
14331 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
14332 if (test_exists_0 () == -1) {
14333 printf ("test_exists_0 FAILED\n");
14337 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
14338 if (test_exists_1 () == -1) {
14339 printf ("test_exists_1 FAILED\n");
14343 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
14344 if (test_mkdir_p_0 () == -1) {
14345 printf ("test_mkdir_p_0 FAILED\n");
14349 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
14350 if (test_mkdir_p_1 () == -1) {
14351 printf ("test_mkdir_p_1 FAILED\n");
14355 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
14356 if (test_mkdir_p_2 () == -1) {
14357 printf ("test_mkdir_p_2 FAILED\n");
14361 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
14362 if (test_mkdir_0 () == -1) {
14363 printf ("test_mkdir_0 FAILED\n");
14367 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
14368 if (test_mkdir_1 () == -1) {
14369 printf ("test_mkdir_1 FAILED\n");
14373 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
14374 if (test_rm_rf_0 () == -1) {
14375 printf ("test_rm_rf_0 FAILED\n");
14379 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
14380 if (test_rmdir_0 () == -1) {
14381 printf ("test_rmdir_0 FAILED\n");
14385 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14386 if (test_rmdir_1 () == -1) {
14387 printf ("test_rmdir_1 FAILED\n");
14391 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14392 if (test_rmdir_2 () == -1) {
14393 printf ("test_rmdir_2 FAILED\n");
14397 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14398 if (test_rm_0 () == -1) {
14399 printf ("test_rm_0 FAILED\n");
14403 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14404 if (test_rm_1 () == -1) {
14405 printf ("test_rm_1 FAILED\n");
14409 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14410 if (test_rm_2 () == -1) {
14411 printf ("test_rm_2 FAILED\n");
14415 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14416 if (test_read_lines_0 () == -1) {
14417 printf ("test_read_lines_0 FAILED\n");
14421 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14422 if (test_read_lines_1 () == -1) {
14423 printf ("test_read_lines_1 FAILED\n");
14427 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14428 if (test_lvs_0 () == -1) {
14429 printf ("test_lvs_0 FAILED\n");
14433 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14434 if (test_lvs_1 () == -1) {
14435 printf ("test_lvs_1 FAILED\n");
14439 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14440 if (test_vgs_0 () == -1) {
14441 printf ("test_vgs_0 FAILED\n");
14445 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14446 if (test_vgs_1 () == -1) {
14447 printf ("test_vgs_1 FAILED\n");
14451 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14452 if (test_pvs_0 () == -1) {
14453 printf ("test_pvs_0 FAILED\n");
14457 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14458 if (test_pvs_1 () == -1) {
14459 printf ("test_pvs_1 FAILED\n");
14463 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14464 if (test_list_partitions_0 () == -1) {
14465 printf ("test_list_partitions_0 FAILED\n");
14469 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14470 if (test_list_partitions_1 () == -1) {
14471 printf ("test_list_partitions_1 FAILED\n");
14475 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14476 if (test_list_devices_0 () == -1) {
14477 printf ("test_list_devices_0 FAILED\n");
14481 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14482 if (test_ls_0 () == -1) {
14483 printf ("test_ls_0 FAILED\n");
14487 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14488 if (test_cat_0 () == -1) {
14489 printf ("test_cat_0 FAILED\n");
14493 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14494 if (test_touch_0 () == -1) {
14495 printf ("test_touch_0 FAILED\n");
14499 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14500 if (test_sync_0 () == -1) {
14501 printf ("test_sync_0 FAILED\n");
14505 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14506 if (test_mount_0 () == -1) {
14507 printf ("test_mount_0 FAILED\n");
14512 unlink ("test1.img");
14513 unlink ("test2.img");
14514 unlink ("test3.img");
14517 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);