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_lvresize_0 (void)
131 /* InitNone|InitEmpty for test_lvresize_0 */
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);
155 /* TestOutput for lvresize (0) */
156 char expected[] = "test content";
158 char device[] = "/dev/sda";
160 char lines_0[] = ",";
167 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
172 char device[] = "/dev/sda1";
176 r = guestfs_pvcreate (g, device);
181 char volgroup[] = "VG";
182 char physvols_0[] = "/dev/sda1";
183 physvols_0[5] = devchar;
190 r = guestfs_vgcreate (g, volgroup, physvols);
195 char logvol[] = "LV";
196 char volgroup[] = "VG";
199 r = guestfs_lvcreate (g, logvol, volgroup, 10);
204 char fstype[] = "ext2";
205 char device[] = "/dev/VG/LV";
208 r = guestfs_mkfs (g, fstype, device);
213 char device[] = "/dev/VG/LV";
214 char mountpoint[] = "/";
217 r = guestfs_mount (g, device, mountpoint);
222 char path[] = "/new";
223 char content[] = "test content";
226 r = guestfs_write_file (g, path, content, 0);
231 char pathordevice[] = "/";
234 r = guestfs_umount (g, pathordevice);
239 char device[] = "/dev/VG/LV";
242 r = guestfs_lvresize (g, device, 20);
247 char device[] = "/dev/VG/LV";
250 r = guestfs_resize2fs (g, device);
255 char device[] = "/dev/VG/LV";
256 char mountpoint[] = "/";
259 r = guestfs_mount (g, device, mountpoint);
264 char path[] = "/new";
267 r = guestfs_cat (g, path);
270 if (strcmp (r, expected) != 0) {
271 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
279 static int test_zerofree_0 (void)
281 /* InitNone|InitEmpty for test_zerofree_0 */
283 char device[] = "/dev/sda";
287 r = guestfs_blockdev_setrw (g, device);
294 r = guestfs_umount_all (g);
301 r = guestfs_lvm_remove_all (g);
305 /* TestOutput for zerofree (0) */
306 char expected[] = "test file";
308 char device[] = "/dev/sda";
310 char lines_0[] = ",";
317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
322 char fstype[] = "ext3";
323 char device[] = "/dev/sda1";
327 r = guestfs_mkfs (g, fstype, device);
332 char device[] = "/dev/sda1";
334 char mountpoint[] = "/";
337 r = guestfs_mount (g, device, mountpoint);
342 char path[] = "/new";
343 char content[] = "test file";
346 r = guestfs_write_file (g, path, content, 0);
351 char pathordevice[] = "/dev/sda1";
352 pathordevice[5] = devchar;
355 r = guestfs_umount (g, pathordevice);
360 char device[] = "/dev/sda1";
364 r = guestfs_zerofree (g, device);
369 char device[] = "/dev/sda1";
371 char mountpoint[] = "/";
374 r = guestfs_mount (g, device, mountpoint);
379 char path[] = "/new";
382 r = guestfs_cat (g, path);
385 if (strcmp (r, expected) != 0) {
386 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
394 static int test_hexdump_0 (void)
396 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
398 char device[] = "/dev/sda";
402 r = guestfs_blockdev_setrw (g, device);
409 r = guestfs_umount_all (g);
416 r = guestfs_lvm_remove_all (g);
421 char device[] = "/dev/sda";
423 char lines_0[] = ",";
430 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
435 char fstype[] = "ext2";
436 char device[] = "/dev/sda1";
440 r = guestfs_mkfs (g, fstype, device);
445 char device[] = "/dev/sda1";
447 char mountpoint[] = "/";
450 r = guestfs_mount (g, device, mountpoint);
454 /* TestOutput for hexdump (0) */
455 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
457 char path[] = "/new";
458 char content[] = "hello\nworld\n";
461 r = guestfs_write_file (g, path, content, 12);
466 char path[] = "/new";
469 r = guestfs_hexdump (g, path);
472 if (strcmp (r, expected) != 0) {
473 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
481 static int test_strings_e_0 (void)
483 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
485 char device[] = "/dev/sda";
489 r = guestfs_blockdev_setrw (g, device);
496 r = guestfs_umount_all (g);
503 r = guestfs_lvm_remove_all (g);
508 char device[] = "/dev/sda";
510 char lines_0[] = ",";
517 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
522 char fstype[] = "ext2";
523 char device[] = "/dev/sda1";
527 r = guestfs_mkfs (g, fstype, device);
532 char device[] = "/dev/sda1";
534 char mountpoint[] = "/";
537 r = guestfs_mount (g, device, mountpoint);
541 /* TestOutputList for strings_e (0) */
543 char path[] = "/new";
544 char content[] = "hello\nworld\n";
547 r = guestfs_write_file (g, path, content, 0);
552 char encoding[] = "b";
553 char path[] = "/new";
557 r = guestfs_strings_e (g, encoding, path);
561 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
565 for (i = 0; r[i] != NULL; ++i)
572 static int test_strings_e_1 (void)
574 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
578 static int test_strings_0 (void)
580 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
582 char device[] = "/dev/sda";
586 r = guestfs_blockdev_setrw (g, device);
593 r = guestfs_umount_all (g);
600 r = guestfs_lvm_remove_all (g);
605 char device[] = "/dev/sda";
607 char lines_0[] = ",";
614 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
619 char fstype[] = "ext2";
620 char device[] = "/dev/sda1";
624 r = guestfs_mkfs (g, fstype, device);
629 char device[] = "/dev/sda1";
631 char mountpoint[] = "/";
634 r = guestfs_mount (g, device, mountpoint);
638 /* TestOutputList for strings (0) */
640 char path[] = "/new";
641 char content[] = "hello\nworld\n";
644 r = guestfs_write_file (g, path, content, 0);
649 char path[] = "/new";
653 r = guestfs_strings (g, path);
657 fprintf (stderr, "test_strings_0: short list returned from command\n");
662 char expected[] = "hello";
663 if (strcmp (r[0], expected) != 0) {
664 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
669 fprintf (stderr, "test_strings_0: short list returned from command\n");
674 char expected[] = "world";
675 if (strcmp (r[1], expected) != 0) {
676 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
681 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
685 for (i = 0; r[i] != NULL; ++i)
692 static int test_strings_1 (void)
694 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
696 char device[] = "/dev/sda";
700 r = guestfs_blockdev_setrw (g, device);
707 r = guestfs_umount_all (g);
714 r = guestfs_lvm_remove_all (g);
719 char device[] = "/dev/sda";
721 char lines_0[] = ",";
728 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
733 char fstype[] = "ext2";
734 char device[] = "/dev/sda1";
738 r = guestfs_mkfs (g, fstype, device);
743 char device[] = "/dev/sda1";
745 char mountpoint[] = "/";
748 r = guestfs_mount (g, device, mountpoint);
752 /* TestOutputList for strings (1) */
754 char path[] = "/new";
757 r = guestfs_touch (g, path);
762 char path[] = "/new";
766 r = guestfs_strings (g, path);
770 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
774 for (i = 0; r[i] != NULL; ++i)
781 static int test_equal_0 (void)
783 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
785 char device[] = "/dev/sda";
789 r = guestfs_blockdev_setrw (g, device);
796 r = guestfs_umount_all (g);
803 r = guestfs_lvm_remove_all (g);
808 char device[] = "/dev/sda";
810 char lines_0[] = ",";
817 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
822 char fstype[] = "ext2";
823 char device[] = "/dev/sda1";
827 r = guestfs_mkfs (g, fstype, device);
832 char device[] = "/dev/sda1";
834 char mountpoint[] = "/";
837 r = guestfs_mount (g, device, mountpoint);
841 /* TestOutputTrue for equal (0) */
843 char path[] = "/file1";
844 char content[] = "contents of a file";
847 r = guestfs_write_file (g, path, content, 0);
852 char src[] = "/file1";
853 char dest[] = "/file2";
856 r = guestfs_cp (g, src, dest);
861 char file1[] = "/file1";
862 char file2[] = "/file2";
865 r = guestfs_equal (g, file1, file2);
869 fprintf (stderr, "test_equal_0: expected true, got false\n");
876 static int test_equal_1 (void)
878 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
880 char device[] = "/dev/sda";
884 r = guestfs_blockdev_setrw (g, device);
891 r = guestfs_umount_all (g);
898 r = guestfs_lvm_remove_all (g);
903 char device[] = "/dev/sda";
905 char lines_0[] = ",";
912 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
917 char fstype[] = "ext2";
918 char device[] = "/dev/sda1";
922 r = guestfs_mkfs (g, fstype, device);
927 char device[] = "/dev/sda1";
929 char mountpoint[] = "/";
932 r = guestfs_mount (g, device, mountpoint);
936 /* TestOutputFalse for equal (1) */
938 char path[] = "/file1";
939 char content[] = "contents of a file";
942 r = guestfs_write_file (g, path, content, 0);
947 char path[] = "/file2";
948 char content[] = "contents of another file";
951 r = guestfs_write_file (g, path, content, 0);
956 char file1[] = "/file1";
957 char file2[] = "/file2";
960 r = guestfs_equal (g, file1, file2);
964 fprintf (stderr, "test_equal_1: expected false, got true\n");
971 static int test_equal_2 (void)
973 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
975 char device[] = "/dev/sda";
979 r = guestfs_blockdev_setrw (g, device);
986 r = guestfs_umount_all (g);
993 r = guestfs_lvm_remove_all (g);
998 char device[] = "/dev/sda";
1000 char lines_0[] = ",";
1007 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1012 char fstype[] = "ext2";
1013 char device[] = "/dev/sda1";
1014 device[5] = devchar;
1017 r = guestfs_mkfs (g, fstype, device);
1022 char device[] = "/dev/sda1";
1023 device[5] = devchar;
1024 char mountpoint[] = "/";
1027 r = guestfs_mount (g, device, mountpoint);
1031 /* TestLastFail for equal (2) */
1033 char file1[] = "/file1";
1034 char file2[] = "/file2";
1037 r = guestfs_equal (g, file1, file2);
1044 static int test_ping_daemon_0 (void)
1046 /* InitNone|InitEmpty for test_ping_daemon_0 */
1048 char device[] = "/dev/sda";
1049 device[5] = devchar;
1052 r = guestfs_blockdev_setrw (g, device);
1059 r = guestfs_umount_all (g);
1066 r = guestfs_lvm_remove_all (g);
1070 /* TestRun for ping_daemon (0) */
1074 r = guestfs_ping_daemon (g);
1081 static int test_dmesg_0 (void)
1083 /* InitNone|InitEmpty for test_dmesg_0 */
1085 char device[] = "/dev/sda";
1086 device[5] = devchar;
1089 r = guestfs_blockdev_setrw (g, device);
1096 r = guestfs_umount_all (g);
1103 r = guestfs_lvm_remove_all (g);
1107 /* TestRun for dmesg (0) */
1111 r = guestfs_dmesg (g);
1119 static int test_drop_caches_0 (void)
1121 /* InitNone|InitEmpty for test_drop_caches_0 */
1123 char device[] = "/dev/sda";
1124 device[5] = devchar;
1127 r = guestfs_blockdev_setrw (g, device);
1134 r = guestfs_umount_all (g);
1141 r = guestfs_lvm_remove_all (g);
1145 /* TestRun for drop_caches (0) */
1149 r = guestfs_drop_caches (g, 3);
1156 static int test_mv_0 (void)
1158 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1160 char device[] = "/dev/sda";
1161 device[5] = devchar;
1164 r = guestfs_blockdev_setrw (g, device);
1171 r = guestfs_umount_all (g);
1178 r = guestfs_lvm_remove_all (g);
1183 char device[] = "/dev/sda";
1184 device[5] = devchar;
1185 char lines_0[] = ",";
1192 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1197 char fstype[] = "ext2";
1198 char device[] = "/dev/sda1";
1199 device[5] = devchar;
1202 r = guestfs_mkfs (g, fstype, device);
1207 char device[] = "/dev/sda1";
1208 device[5] = devchar;
1209 char mountpoint[] = "/";
1212 r = guestfs_mount (g, device, mountpoint);
1216 /* TestOutput for mv (0) */
1217 char expected[] = "file content";
1219 char path[] = "/old";
1220 char content[] = "file content";
1223 r = guestfs_write_file (g, path, content, 0);
1228 char src[] = "/old";
1229 char dest[] = "/new";
1232 r = guestfs_mv (g, src, dest);
1237 char path[] = "/new";
1240 r = guestfs_cat (g, path);
1243 if (strcmp (r, expected) != 0) {
1244 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1252 static int test_mv_1 (void)
1254 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1256 char device[] = "/dev/sda";
1257 device[5] = devchar;
1260 r = guestfs_blockdev_setrw (g, device);
1267 r = guestfs_umount_all (g);
1274 r = guestfs_lvm_remove_all (g);
1279 char device[] = "/dev/sda";
1280 device[5] = devchar;
1281 char lines_0[] = ",";
1288 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1293 char fstype[] = "ext2";
1294 char device[] = "/dev/sda1";
1295 device[5] = devchar;
1298 r = guestfs_mkfs (g, fstype, device);
1303 char device[] = "/dev/sda1";
1304 device[5] = devchar;
1305 char mountpoint[] = "/";
1308 r = guestfs_mount (g, device, mountpoint);
1312 /* TestOutputFalse for mv (1) */
1314 char path[] = "/old";
1315 char content[] = "file content";
1318 r = guestfs_write_file (g, path, content, 0);
1323 char src[] = "/old";
1324 char dest[] = "/new";
1327 r = guestfs_mv (g, src, dest);
1332 char path[] = "/old";
1335 r = guestfs_is_file (g, path);
1339 fprintf (stderr, "test_mv_1: expected false, got true\n");
1346 static int test_cp_a_0 (void)
1348 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
1350 char device[] = "/dev/sda";
1351 device[5] = devchar;
1354 r = guestfs_blockdev_setrw (g, device);
1361 r = guestfs_umount_all (g);
1368 r = guestfs_lvm_remove_all (g);
1373 char device[] = "/dev/sda";
1374 device[5] = devchar;
1375 char lines_0[] = ",";
1382 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1387 char fstype[] = "ext2";
1388 char device[] = "/dev/sda1";
1389 device[5] = devchar;
1392 r = guestfs_mkfs (g, fstype, device);
1397 char device[] = "/dev/sda1";
1398 device[5] = devchar;
1399 char mountpoint[] = "/";
1402 r = guestfs_mount (g, device, mountpoint);
1406 /* TestOutput for cp_a (0) */
1407 char expected[] = "file content";
1409 char path[] = "/olddir";
1412 r = guestfs_mkdir (g, path);
1417 char path[] = "/newdir";
1420 r = guestfs_mkdir (g, path);
1425 char path[] = "/olddir/file";
1426 char content[] = "file content";
1429 r = guestfs_write_file (g, path, content, 0);
1434 char src[] = "/olddir";
1435 char dest[] = "/newdir";
1438 r = guestfs_cp_a (g, src, dest);
1443 char path[] = "/newdir/olddir/file";
1446 r = guestfs_cat (g, path);
1449 if (strcmp (r, expected) != 0) {
1450 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
1458 static int test_cp_0 (void)
1460 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
1462 char device[] = "/dev/sda";
1463 device[5] = devchar;
1466 r = guestfs_blockdev_setrw (g, device);
1473 r = guestfs_umount_all (g);
1480 r = guestfs_lvm_remove_all (g);
1485 char device[] = "/dev/sda";
1486 device[5] = devchar;
1487 char lines_0[] = ",";
1494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1499 char fstype[] = "ext2";
1500 char device[] = "/dev/sda1";
1501 device[5] = devchar;
1504 r = guestfs_mkfs (g, fstype, device);
1509 char device[] = "/dev/sda1";
1510 device[5] = devchar;
1511 char mountpoint[] = "/";
1514 r = guestfs_mount (g, device, mountpoint);
1518 /* TestOutput for cp (0) */
1519 char expected[] = "file content";
1521 char path[] = "/old";
1522 char content[] = "file content";
1525 r = guestfs_write_file (g, path, content, 0);
1530 char src[] = "/old";
1531 char dest[] = "/new";
1534 r = guestfs_cp (g, src, dest);
1539 char path[] = "/new";
1542 r = guestfs_cat (g, path);
1545 if (strcmp (r, expected) != 0) {
1546 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
1554 static int test_cp_1 (void)
1556 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
1558 char device[] = "/dev/sda";
1559 device[5] = devchar;
1562 r = guestfs_blockdev_setrw (g, device);
1569 r = guestfs_umount_all (g);
1576 r = guestfs_lvm_remove_all (g);
1581 char device[] = "/dev/sda";
1582 device[5] = devchar;
1583 char lines_0[] = ",";
1590 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1595 char fstype[] = "ext2";
1596 char device[] = "/dev/sda1";
1597 device[5] = devchar;
1600 r = guestfs_mkfs (g, fstype, device);
1605 char device[] = "/dev/sda1";
1606 device[5] = devchar;
1607 char mountpoint[] = "/";
1610 r = guestfs_mount (g, device, mountpoint);
1614 /* TestOutputTrue for cp (1) */
1616 char path[] = "/old";
1617 char content[] = "file content";
1620 r = guestfs_write_file (g, path, content, 0);
1625 char src[] = "/old";
1626 char dest[] = "/new";
1629 r = guestfs_cp (g, src, dest);
1634 char path[] = "/old";
1637 r = guestfs_is_file (g, path);
1641 fprintf (stderr, "test_cp_1: expected true, got false\n");
1648 static int test_cp_2 (void)
1650 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
1652 char device[] = "/dev/sda";
1653 device[5] = devchar;
1656 r = guestfs_blockdev_setrw (g, device);
1663 r = guestfs_umount_all (g);
1670 r = guestfs_lvm_remove_all (g);
1675 char device[] = "/dev/sda";
1676 device[5] = devchar;
1677 char lines_0[] = ",";
1684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1689 char fstype[] = "ext2";
1690 char device[] = "/dev/sda1";
1691 device[5] = devchar;
1694 r = guestfs_mkfs (g, fstype, device);
1699 char device[] = "/dev/sda1";
1700 device[5] = devchar;
1701 char mountpoint[] = "/";
1704 r = guestfs_mount (g, device, mountpoint);
1708 /* TestOutput for cp (2) */
1709 char expected[] = "file content";
1711 char path[] = "/old";
1712 char content[] = "file content";
1715 r = guestfs_write_file (g, path, content, 0);
1720 char path[] = "/dir";
1723 r = guestfs_mkdir (g, path);
1728 char src[] = "/old";
1729 char dest[] = "/dir/new";
1732 r = guestfs_cp (g, src, dest);
1737 char path[] = "/dir/new";
1740 r = guestfs_cat (g, path);
1743 if (strcmp (r, expected) != 0) {
1744 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
1752 static int test_grub_install_0 (void)
1754 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
1756 char device[] = "/dev/sda";
1757 device[5] = devchar;
1760 r = guestfs_blockdev_setrw (g, device);
1767 r = guestfs_umount_all (g);
1774 r = guestfs_lvm_remove_all (g);
1779 char device[] = "/dev/sda";
1780 device[5] = devchar;
1781 char lines_0[] = ",";
1788 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1793 char fstype[] = "ext2";
1794 char device[] = "/dev/sda1";
1795 device[5] = devchar;
1798 r = guestfs_mkfs (g, fstype, device);
1803 char device[] = "/dev/sda1";
1804 device[5] = devchar;
1805 char mountpoint[] = "/";
1808 r = guestfs_mount (g, device, mountpoint);
1812 /* TestOutputTrue for grub_install (0) */
1815 char device[] = "/dev/sda1";
1816 device[5] = devchar;
1819 r = guestfs_grub_install (g, root, device);
1824 char path[] = "/boot";
1827 r = guestfs_is_dir (g, path);
1831 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
1838 static int test_zero_0 (void)
1840 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
1842 char device[] = "/dev/sda";
1843 device[5] = devchar;
1846 r = guestfs_blockdev_setrw (g, device);
1853 r = guestfs_umount_all (g);
1860 r = guestfs_lvm_remove_all (g);
1865 char device[] = "/dev/sda";
1866 device[5] = devchar;
1867 char lines_0[] = ",";
1874 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1879 char fstype[] = "ext2";
1880 char device[] = "/dev/sda1";
1881 device[5] = devchar;
1884 r = guestfs_mkfs (g, fstype, device);
1889 char device[] = "/dev/sda1";
1890 device[5] = devchar;
1891 char mountpoint[] = "/";
1894 r = guestfs_mount (g, device, mountpoint);
1898 /* TestOutput for zero (0) */
1899 char expected[] = "data";
1901 char pathordevice[] = "/dev/sda1";
1902 pathordevice[5] = devchar;
1905 r = guestfs_umount (g, pathordevice);
1910 char device[] = "/dev/sda1";
1911 device[5] = devchar;
1914 r = guestfs_zero (g, device);
1919 char path[] = "/dev/sda1";
1923 r = guestfs_file (g, path);
1926 if (strcmp (r, expected) != 0) {
1927 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
1935 static int test_fsck_0 (void)
1937 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
1939 char device[] = "/dev/sda";
1940 device[5] = devchar;
1943 r = guestfs_blockdev_setrw (g, device);
1950 r = guestfs_umount_all (g);
1957 r = guestfs_lvm_remove_all (g);
1962 char device[] = "/dev/sda";
1963 device[5] = devchar;
1964 char lines_0[] = ",";
1971 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1976 char fstype[] = "ext2";
1977 char device[] = "/dev/sda1";
1978 device[5] = devchar;
1981 r = guestfs_mkfs (g, fstype, device);
1986 char device[] = "/dev/sda1";
1987 device[5] = devchar;
1988 char mountpoint[] = "/";
1991 r = guestfs_mount (g, device, mountpoint);
1995 /* TestOutputInt for fsck (0) */
1997 char pathordevice[] = "/dev/sda1";
1998 pathordevice[5] = devchar;
2001 r = guestfs_umount (g, pathordevice);
2006 char fstype[] = "ext2";
2007 char device[] = "/dev/sda1";
2008 device[5] = devchar;
2011 r = guestfs_fsck (g, fstype, device);
2015 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2022 static int test_fsck_1 (void)
2024 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2026 char device[] = "/dev/sda";
2027 device[5] = devchar;
2030 r = guestfs_blockdev_setrw (g, device);
2037 r = guestfs_umount_all (g);
2044 r = guestfs_lvm_remove_all (g);
2049 char device[] = "/dev/sda";
2050 device[5] = devchar;
2051 char lines_0[] = ",";
2058 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2063 char fstype[] = "ext2";
2064 char device[] = "/dev/sda1";
2065 device[5] = devchar;
2068 r = guestfs_mkfs (g, fstype, device);
2073 char device[] = "/dev/sda1";
2074 device[5] = devchar;
2075 char mountpoint[] = "/";
2078 r = guestfs_mount (g, device, mountpoint);
2082 /* TestOutputInt for fsck (1) */
2084 char pathordevice[] = "/dev/sda1";
2085 pathordevice[5] = devchar;
2088 r = guestfs_umount (g, pathordevice);
2093 char device[] = "/dev/sda1";
2094 device[5] = devchar;
2097 r = guestfs_zero (g, device);
2102 char fstype[] = "ext2";
2103 char device[] = "/dev/sda1";
2104 device[5] = devchar;
2107 r = guestfs_fsck (g, fstype, device);
2111 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
2118 static int test_set_e2uuid_0 (void)
2120 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2122 char device[] = "/dev/sda";
2123 device[5] = devchar;
2126 r = guestfs_blockdev_setrw (g, device);
2133 r = guestfs_umount_all (g);
2140 r = guestfs_lvm_remove_all (g);
2145 char device[] = "/dev/sda";
2146 device[5] = devchar;
2147 char lines_0[] = ",";
2154 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2159 char fstype[] = "ext2";
2160 char device[] = "/dev/sda1";
2161 device[5] = devchar;
2164 r = guestfs_mkfs (g, fstype, device);
2169 char device[] = "/dev/sda1";
2170 device[5] = devchar;
2171 char mountpoint[] = "/";
2174 r = guestfs_mount (g, device, mountpoint);
2178 /* TestOutput for set_e2uuid (0) */
2179 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2181 char device[] = "/dev/sda1";
2182 device[5] = devchar;
2183 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
2186 r = guestfs_set_e2uuid (g, device, uuid);
2191 char device[] = "/dev/sda1";
2192 device[5] = devchar;
2195 r = guestfs_get_e2uuid (g, device);
2198 if (strcmp (r, expected) != 0) {
2199 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
2207 static int test_set_e2uuid_1 (void)
2209 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
2211 char device[] = "/dev/sda";
2212 device[5] = devchar;
2215 r = guestfs_blockdev_setrw (g, device);
2222 r = guestfs_umount_all (g);
2229 r = guestfs_lvm_remove_all (g);
2234 char device[] = "/dev/sda";
2235 device[5] = devchar;
2236 char lines_0[] = ",";
2243 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2248 char fstype[] = "ext2";
2249 char device[] = "/dev/sda1";
2250 device[5] = devchar;
2253 r = guestfs_mkfs (g, fstype, device);
2258 char device[] = "/dev/sda1";
2259 device[5] = devchar;
2260 char mountpoint[] = "/";
2263 r = guestfs_mount (g, device, mountpoint);
2267 /* TestOutput for set_e2uuid (1) */
2268 char expected[] = "";
2270 char device[] = "/dev/sda1";
2271 device[5] = devchar;
2272 char uuid[] = "clear";
2275 r = guestfs_set_e2uuid (g, device, uuid);
2280 char device[] = "/dev/sda1";
2281 device[5] = devchar;
2284 r = guestfs_get_e2uuid (g, device);
2287 if (strcmp (r, expected) != 0) {
2288 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
2296 static int test_set_e2uuid_2 (void)
2298 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
2300 char device[] = "/dev/sda";
2301 device[5] = devchar;
2304 r = guestfs_blockdev_setrw (g, device);
2311 r = guestfs_umount_all (g);
2318 r = guestfs_lvm_remove_all (g);
2323 char device[] = "/dev/sda";
2324 device[5] = devchar;
2325 char lines_0[] = ",";
2332 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2337 char fstype[] = "ext2";
2338 char device[] = "/dev/sda1";
2339 device[5] = devchar;
2342 r = guestfs_mkfs (g, fstype, device);
2347 char device[] = "/dev/sda1";
2348 device[5] = devchar;
2349 char mountpoint[] = "/";
2352 r = guestfs_mount (g, device, mountpoint);
2356 /* TestRun for set_e2uuid (2) */
2358 char device[] = "/dev/sda1";
2359 device[5] = devchar;
2360 char uuid[] = "random";
2363 r = guestfs_set_e2uuid (g, device, uuid);
2370 static int test_set_e2uuid_3 (void)
2372 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
2374 char device[] = "/dev/sda";
2375 device[5] = devchar;
2378 r = guestfs_blockdev_setrw (g, device);
2385 r = guestfs_umount_all (g);
2392 r = guestfs_lvm_remove_all (g);
2397 char device[] = "/dev/sda";
2398 device[5] = devchar;
2399 char lines_0[] = ",";
2406 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2411 char fstype[] = "ext2";
2412 char device[] = "/dev/sda1";
2413 device[5] = devchar;
2416 r = guestfs_mkfs (g, fstype, device);
2421 char device[] = "/dev/sda1";
2422 device[5] = devchar;
2423 char mountpoint[] = "/";
2426 r = guestfs_mount (g, device, mountpoint);
2430 /* TestRun for set_e2uuid (3) */
2432 char device[] = "/dev/sda1";
2433 device[5] = devchar;
2434 char uuid[] = "time";
2437 r = guestfs_set_e2uuid (g, device, uuid);
2444 static int test_set_e2label_0 (void)
2446 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
2448 char device[] = "/dev/sda";
2449 device[5] = devchar;
2452 r = guestfs_blockdev_setrw (g, device);
2459 r = guestfs_umount_all (g);
2466 r = guestfs_lvm_remove_all (g);
2471 char device[] = "/dev/sda";
2472 device[5] = devchar;
2473 char lines_0[] = ",";
2480 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2485 char fstype[] = "ext2";
2486 char device[] = "/dev/sda1";
2487 device[5] = devchar;
2490 r = guestfs_mkfs (g, fstype, device);
2495 char device[] = "/dev/sda1";
2496 device[5] = devchar;
2497 char mountpoint[] = "/";
2500 r = guestfs_mount (g, device, mountpoint);
2504 /* TestOutput for set_e2label (0) */
2505 char expected[] = "testlabel";
2507 char device[] = "/dev/sda1";
2508 device[5] = devchar;
2509 char label[] = "testlabel";
2512 r = guestfs_set_e2label (g, device, label);
2517 char device[] = "/dev/sda1";
2518 device[5] = devchar;
2521 r = guestfs_get_e2label (g, device);
2524 if (strcmp (r, expected) != 0) {
2525 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
2533 static int test_pvremove_0 (void)
2535 /* InitNone|InitEmpty for test_pvremove_0 */
2537 char device[] = "/dev/sda";
2538 device[5] = devchar;
2541 r = guestfs_blockdev_setrw (g, device);
2548 r = guestfs_umount_all (g);
2555 r = guestfs_lvm_remove_all (g);
2559 /* TestOutputList for pvremove (0) */
2561 char device[] = "/dev/sda";
2562 device[5] = devchar;
2565 r = guestfs_pvcreate (g, device);
2570 char volgroup[] = "VG";
2571 char physvols_0[] = "/dev/sda";
2572 physvols_0[5] = devchar;
2573 char *physvols[] = {
2579 r = guestfs_vgcreate (g, volgroup, physvols);
2584 char logvol[] = "LV1";
2585 char volgroup[] = "VG";
2588 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2593 char logvol[] = "LV2";
2594 char volgroup[] = "VG";
2597 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2602 char vgname[] = "VG";
2605 r = guestfs_vgremove (g, vgname);
2610 char device[] = "/dev/sda";
2611 device[5] = devchar;
2614 r = guestfs_pvremove (g, device);
2622 r = guestfs_lvs (g);
2626 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
2630 for (i = 0; r[i] != NULL; ++i)
2637 static int test_pvremove_1 (void)
2639 /* InitNone|InitEmpty for test_pvremove_1 */
2641 char device[] = "/dev/sda";
2642 device[5] = devchar;
2645 r = guestfs_blockdev_setrw (g, device);
2652 r = guestfs_umount_all (g);
2659 r = guestfs_lvm_remove_all (g);
2663 /* TestOutputList for pvremove (1) */
2665 char device[] = "/dev/sda";
2666 device[5] = devchar;
2669 r = guestfs_pvcreate (g, device);
2674 char volgroup[] = "VG";
2675 char physvols_0[] = "/dev/sda";
2676 physvols_0[5] = devchar;
2677 char *physvols[] = {
2683 r = guestfs_vgcreate (g, volgroup, physvols);
2688 char logvol[] = "LV1";
2689 char volgroup[] = "VG";
2692 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2697 char logvol[] = "LV2";
2698 char volgroup[] = "VG";
2701 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2706 char vgname[] = "VG";
2709 r = guestfs_vgremove (g, vgname);
2714 char device[] = "/dev/sda";
2715 device[5] = devchar;
2718 r = guestfs_pvremove (g, device);
2726 r = guestfs_vgs (g);
2730 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
2734 for (i = 0; r[i] != NULL; ++i)
2741 static int test_pvremove_2 (void)
2743 /* InitNone|InitEmpty for test_pvremove_2 */
2745 char device[] = "/dev/sda";
2746 device[5] = devchar;
2749 r = guestfs_blockdev_setrw (g, device);
2756 r = guestfs_umount_all (g);
2763 r = guestfs_lvm_remove_all (g);
2767 /* TestOutputList for pvremove (2) */
2769 char device[] = "/dev/sda";
2770 device[5] = devchar;
2773 r = guestfs_pvcreate (g, device);
2778 char volgroup[] = "VG";
2779 char physvols_0[] = "/dev/sda";
2780 physvols_0[5] = devchar;
2781 char *physvols[] = {
2787 r = guestfs_vgcreate (g, volgroup, physvols);
2792 char logvol[] = "LV1";
2793 char volgroup[] = "VG";
2796 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2801 char logvol[] = "LV2";
2802 char volgroup[] = "VG";
2805 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2810 char vgname[] = "VG";
2813 r = guestfs_vgremove (g, vgname);
2818 char device[] = "/dev/sda";
2819 device[5] = devchar;
2822 r = guestfs_pvremove (g, device);
2830 r = guestfs_pvs (g);
2834 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
2838 for (i = 0; r[i] != NULL; ++i)
2845 static int test_vgremove_0 (void)
2847 /* InitNone|InitEmpty for test_vgremove_0 */
2849 char device[] = "/dev/sda";
2850 device[5] = devchar;
2853 r = guestfs_blockdev_setrw (g, device);
2860 r = guestfs_umount_all (g);
2867 r = guestfs_lvm_remove_all (g);
2871 /* TestOutputList for vgremove (0) */
2873 char device[] = "/dev/sda";
2874 device[5] = devchar;
2877 r = guestfs_pvcreate (g, device);
2882 char volgroup[] = "VG";
2883 char physvols_0[] = "/dev/sda";
2884 physvols_0[5] = devchar;
2885 char *physvols[] = {
2891 r = guestfs_vgcreate (g, volgroup, physvols);
2896 char logvol[] = "LV1";
2897 char volgroup[] = "VG";
2900 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2905 char logvol[] = "LV2";
2906 char volgroup[] = "VG";
2909 r = guestfs_lvcreate (g, logvol, volgroup, 50);
2914 char vgname[] = "VG";
2917 r = guestfs_vgremove (g, vgname);
2925 r = guestfs_lvs (g);
2929 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
2933 for (i = 0; r[i] != NULL; ++i)
2940 static int test_vgremove_1 (void)
2942 /* InitNone|InitEmpty for test_vgremove_1 */
2944 char device[] = "/dev/sda";
2945 device[5] = devchar;
2948 r = guestfs_blockdev_setrw (g, device);
2955 r = guestfs_umount_all (g);
2962 r = guestfs_lvm_remove_all (g);
2966 /* TestOutputList for vgremove (1) */
2968 char device[] = "/dev/sda";
2969 device[5] = devchar;
2972 r = guestfs_pvcreate (g, device);
2977 char volgroup[] = "VG";
2978 char physvols_0[] = "/dev/sda";
2979 physvols_0[5] = devchar;
2980 char *physvols[] = {
2986 r = guestfs_vgcreate (g, volgroup, physvols);
2991 char logvol[] = "LV1";
2992 char volgroup[] = "VG";
2995 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3000 char logvol[] = "LV2";
3001 char volgroup[] = "VG";
3004 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3009 char vgname[] = "VG";
3012 r = guestfs_vgremove (g, vgname);
3020 r = guestfs_vgs (g);
3024 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
3028 for (i = 0; r[i] != NULL; ++i)
3035 static int test_lvremove_0 (void)
3037 /* InitNone|InitEmpty for test_lvremove_0 */
3039 char device[] = "/dev/sda";
3040 device[5] = devchar;
3043 r = guestfs_blockdev_setrw (g, device);
3050 r = guestfs_umount_all (g);
3057 r = guestfs_lvm_remove_all (g);
3061 /* TestOutputList for lvremove (0) */
3063 char device[] = "/dev/sda";
3064 device[5] = devchar;
3067 r = guestfs_pvcreate (g, device);
3072 char volgroup[] = "VG";
3073 char physvols_0[] = "/dev/sda";
3074 physvols_0[5] = devchar;
3075 char *physvols[] = {
3081 r = guestfs_vgcreate (g, volgroup, physvols);
3086 char logvol[] = "LV1";
3087 char volgroup[] = "VG";
3090 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3095 char logvol[] = "LV2";
3096 char volgroup[] = "VG";
3099 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3104 char device[] = "/dev/VG/LV1";
3107 r = guestfs_lvremove (g, device);
3115 r = guestfs_lvs (g);
3119 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
3124 char expected[] = "/dev/VG/LV2";
3125 if (strcmp (r[0], expected) != 0) {
3126 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3131 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
3135 for (i = 0; r[i] != NULL; ++i)
3142 static int test_lvremove_1 (void)
3144 /* InitNone|InitEmpty for test_lvremove_1 */
3146 char device[] = "/dev/sda";
3147 device[5] = devchar;
3150 r = guestfs_blockdev_setrw (g, device);
3157 r = guestfs_umount_all (g);
3164 r = guestfs_lvm_remove_all (g);
3168 /* TestOutputList for lvremove (1) */
3170 char device[] = "/dev/sda";
3171 device[5] = devchar;
3174 r = guestfs_pvcreate (g, device);
3179 char volgroup[] = "VG";
3180 char physvols_0[] = "/dev/sda";
3181 physvols_0[5] = devchar;
3182 char *physvols[] = {
3188 r = guestfs_vgcreate (g, volgroup, physvols);
3193 char logvol[] = "LV1";
3194 char volgroup[] = "VG";
3197 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3202 char logvol[] = "LV2";
3203 char volgroup[] = "VG";
3206 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3211 char device[] = "/dev/VG";
3214 r = guestfs_lvremove (g, device);
3222 r = guestfs_lvs (g);
3226 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
3230 for (i = 0; r[i] != NULL; ++i)
3237 static int test_lvremove_2 (void)
3239 /* InitNone|InitEmpty for test_lvremove_2 */
3241 char device[] = "/dev/sda";
3242 device[5] = devchar;
3245 r = guestfs_blockdev_setrw (g, device);
3252 r = guestfs_umount_all (g);
3259 r = guestfs_lvm_remove_all (g);
3263 /* TestOutputList for lvremove (2) */
3265 char device[] = "/dev/sda";
3266 device[5] = devchar;
3269 r = guestfs_pvcreate (g, device);
3274 char volgroup[] = "VG";
3275 char physvols_0[] = "/dev/sda";
3276 physvols_0[5] = devchar;
3277 char *physvols[] = {
3283 r = guestfs_vgcreate (g, volgroup, physvols);
3288 char logvol[] = "LV1";
3289 char volgroup[] = "VG";
3292 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3297 char logvol[] = "LV2";
3298 char volgroup[] = "VG";
3301 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3306 char device[] = "/dev/VG";
3309 r = guestfs_lvremove (g, device);
3317 r = guestfs_vgs (g);
3321 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
3326 char expected[] = "VG";
3327 if (strcmp (r[0], expected) != 0) {
3328 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3333 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
3337 for (i = 0; r[i] != NULL; ++i)
3344 static int test_mount_ro_0 (void)
3346 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
3348 char device[] = "/dev/sda";
3349 device[5] = devchar;
3352 r = guestfs_blockdev_setrw (g, device);
3359 r = guestfs_umount_all (g);
3366 r = guestfs_lvm_remove_all (g);
3371 char device[] = "/dev/sda";
3372 device[5] = devchar;
3373 char lines_0[] = ",";
3380 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3385 char fstype[] = "ext2";
3386 char device[] = "/dev/sda1";
3387 device[5] = devchar;
3390 r = guestfs_mkfs (g, fstype, device);
3395 char device[] = "/dev/sda1";
3396 device[5] = devchar;
3397 char mountpoint[] = "/";
3400 r = guestfs_mount (g, device, mountpoint);
3404 /* TestLastFail for mount_ro (0) */
3406 char pathordevice[] = "/";
3409 r = guestfs_umount (g, pathordevice);
3414 char device[] = "/dev/sda1";
3415 device[5] = devchar;
3416 char mountpoint[] = "/";
3419 r = guestfs_mount_ro (g, device, mountpoint);
3424 char path[] = "/new";
3427 r = guestfs_touch (g, path);
3434 static int test_mount_ro_1 (void)
3436 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
3438 char device[] = "/dev/sda";
3439 device[5] = devchar;
3442 r = guestfs_blockdev_setrw (g, device);
3449 r = guestfs_umount_all (g);
3456 r = guestfs_lvm_remove_all (g);
3461 char device[] = "/dev/sda";
3462 device[5] = devchar;
3463 char lines_0[] = ",";
3470 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3475 char fstype[] = "ext2";
3476 char device[] = "/dev/sda1";
3477 device[5] = devchar;
3480 r = guestfs_mkfs (g, fstype, device);
3485 char device[] = "/dev/sda1";
3486 device[5] = devchar;
3487 char mountpoint[] = "/";
3490 r = guestfs_mount (g, device, mountpoint);
3494 /* TestOutput for mount_ro (1) */
3495 char expected[] = "data";
3497 char path[] = "/new";
3498 char content[] = "data";
3501 r = guestfs_write_file (g, path, content, 0);
3506 char pathordevice[] = "/";
3509 r = guestfs_umount (g, pathordevice);
3514 char device[] = "/dev/sda1";
3515 device[5] = devchar;
3516 char mountpoint[] = "/";
3519 r = guestfs_mount_ro (g, device, mountpoint);
3524 char path[] = "/new";
3527 r = guestfs_cat (g, path);
3530 if (strcmp (r, expected) != 0) {
3531 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
3539 static int test_tgz_in_0 (void)
3541 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
3543 char device[] = "/dev/sda";
3544 device[5] = devchar;
3547 r = guestfs_blockdev_setrw (g, device);
3554 r = guestfs_umount_all (g);
3561 r = guestfs_lvm_remove_all (g);
3566 char device[] = "/dev/sda";
3567 device[5] = devchar;
3568 char lines_0[] = ",";
3575 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3580 char fstype[] = "ext2";
3581 char device[] = "/dev/sda1";
3582 device[5] = devchar;
3585 r = guestfs_mkfs (g, fstype, device);
3590 char device[] = "/dev/sda1";
3591 device[5] = devchar;
3592 char mountpoint[] = "/";
3595 r = guestfs_mount (g, device, mountpoint);
3599 /* TestOutput for tgz_in (0) */
3600 char expected[] = "hello\n";
3602 char directory[] = "/";
3605 r = guestfs_tgz_in (g, "images/helloworld.tar.gz", directory);
3610 char path[] = "/hello";
3613 r = guestfs_cat (g, path);
3616 if (strcmp (r, expected) != 0) {
3617 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3625 static int test_tar_in_0 (void)
3627 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
3629 char device[] = "/dev/sda";
3630 device[5] = devchar;
3633 r = guestfs_blockdev_setrw (g, device);
3640 r = guestfs_umount_all (g);
3647 r = guestfs_lvm_remove_all (g);
3652 char device[] = "/dev/sda";
3653 device[5] = devchar;
3654 char lines_0[] = ",";
3661 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3666 char fstype[] = "ext2";
3667 char device[] = "/dev/sda1";
3668 device[5] = devchar;
3671 r = guestfs_mkfs (g, fstype, device);
3676 char device[] = "/dev/sda1";
3677 device[5] = devchar;
3678 char mountpoint[] = "/";
3681 r = guestfs_mount (g, device, mountpoint);
3685 /* TestOutput for tar_in (0) */
3686 char expected[] = "hello\n";
3688 char directory[] = "/";
3691 r = guestfs_tar_in (g, "images/helloworld.tar", directory);
3696 char path[] = "/hello";
3699 r = guestfs_cat (g, path);
3702 if (strcmp (r, expected) != 0) {
3703 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
3711 static int test_checksum_0 (void)
3713 /* InitBasicFS for test_checksum_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 /* TestOutput for checksum (0) */
3772 char expected[] = "935282863";
3774 char path[] = "/new";
3775 char content[] = "test\n";
3778 r = guestfs_write_file (g, path, content, 0);
3783 char csumtype[] = "crc";
3784 char path[] = "/new";
3787 r = guestfs_checksum (g, csumtype, path);
3790 if (strcmp (r, expected) != 0) {
3791 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
3799 static int test_checksum_1 (void)
3801 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
3803 char device[] = "/dev/sda";
3804 device[5] = devchar;
3807 r = guestfs_blockdev_setrw (g, device);
3814 r = guestfs_umount_all (g);
3821 r = guestfs_lvm_remove_all (g);
3826 char device[] = "/dev/sda";
3827 device[5] = devchar;
3828 char lines_0[] = ",";
3835 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3840 char fstype[] = "ext2";
3841 char device[] = "/dev/sda1";
3842 device[5] = devchar;
3845 r = guestfs_mkfs (g, fstype, device);
3850 char device[] = "/dev/sda1";
3851 device[5] = devchar;
3852 char mountpoint[] = "/";
3855 r = guestfs_mount (g, device, mountpoint);
3859 /* TestLastFail for checksum (1) */
3861 char csumtype[] = "crc";
3862 char path[] = "/new";
3865 r = guestfs_checksum (g, csumtype, path);
3873 static int test_checksum_2 (void)
3875 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
3877 char device[] = "/dev/sda";
3878 device[5] = devchar;
3881 r = guestfs_blockdev_setrw (g, device);
3888 r = guestfs_umount_all (g);
3895 r = guestfs_lvm_remove_all (g);
3900 char device[] = "/dev/sda";
3901 device[5] = devchar;
3902 char lines_0[] = ",";
3909 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3914 char fstype[] = "ext2";
3915 char device[] = "/dev/sda1";
3916 device[5] = devchar;
3919 r = guestfs_mkfs (g, fstype, device);
3924 char device[] = "/dev/sda1";
3925 device[5] = devchar;
3926 char mountpoint[] = "/";
3929 r = guestfs_mount (g, device, mountpoint);
3933 /* TestOutput for checksum (2) */
3934 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
3936 char path[] = "/new";
3937 char content[] = "test\n";
3940 r = guestfs_write_file (g, path, content, 0);
3945 char csumtype[] = "md5";
3946 char path[] = "/new";
3949 r = guestfs_checksum (g, csumtype, path);
3952 if (strcmp (r, expected) != 0) {
3953 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
3961 static int test_checksum_3 (void)
3963 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
3965 char device[] = "/dev/sda";
3966 device[5] = devchar;
3969 r = guestfs_blockdev_setrw (g, device);
3976 r = guestfs_umount_all (g);
3983 r = guestfs_lvm_remove_all (g);
3988 char device[] = "/dev/sda";
3989 device[5] = devchar;
3990 char lines_0[] = ",";
3997 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4002 char fstype[] = "ext2";
4003 char device[] = "/dev/sda1";
4004 device[5] = devchar;
4007 r = guestfs_mkfs (g, fstype, device);
4012 char device[] = "/dev/sda1";
4013 device[5] = devchar;
4014 char mountpoint[] = "/";
4017 r = guestfs_mount (g, device, mountpoint);
4021 /* TestOutput for checksum (3) */
4022 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
4024 char path[] = "/new";
4025 char content[] = "test\n";
4028 r = guestfs_write_file (g, path, content, 0);
4033 char csumtype[] = "sha1";
4034 char path[] = "/new";
4037 r = guestfs_checksum (g, csumtype, path);
4040 if (strcmp (r, expected) != 0) {
4041 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
4049 static int test_checksum_4 (void)
4051 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
4053 char device[] = "/dev/sda";
4054 device[5] = devchar;
4057 r = guestfs_blockdev_setrw (g, device);
4064 r = guestfs_umount_all (g);
4071 r = guestfs_lvm_remove_all (g);
4076 char device[] = "/dev/sda";
4077 device[5] = devchar;
4078 char lines_0[] = ",";
4085 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4090 char fstype[] = "ext2";
4091 char device[] = "/dev/sda1";
4092 device[5] = devchar;
4095 r = guestfs_mkfs (g, fstype, device);
4100 char device[] = "/dev/sda1";
4101 device[5] = devchar;
4102 char mountpoint[] = "/";
4105 r = guestfs_mount (g, device, mountpoint);
4109 /* TestOutput for checksum (4) */
4110 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
4112 char path[] = "/new";
4113 char content[] = "test\n";
4116 r = guestfs_write_file (g, path, content, 0);
4121 char csumtype[] = "sha224";
4122 char path[] = "/new";
4125 r = guestfs_checksum (g, csumtype, path);
4128 if (strcmp (r, expected) != 0) {
4129 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
4137 static int test_checksum_5 (void)
4139 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
4141 char device[] = "/dev/sda";
4142 device[5] = devchar;
4145 r = guestfs_blockdev_setrw (g, device);
4152 r = guestfs_umount_all (g);
4159 r = guestfs_lvm_remove_all (g);
4164 char device[] = "/dev/sda";
4165 device[5] = devchar;
4166 char lines_0[] = ",";
4173 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4178 char fstype[] = "ext2";
4179 char device[] = "/dev/sda1";
4180 device[5] = devchar;
4183 r = guestfs_mkfs (g, fstype, device);
4188 char device[] = "/dev/sda1";
4189 device[5] = devchar;
4190 char mountpoint[] = "/";
4193 r = guestfs_mount (g, device, mountpoint);
4197 /* TestOutput for checksum (5) */
4198 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
4200 char path[] = "/new";
4201 char content[] = "test\n";
4204 r = guestfs_write_file (g, path, content, 0);
4209 char csumtype[] = "sha256";
4210 char path[] = "/new";
4213 r = guestfs_checksum (g, csumtype, path);
4216 if (strcmp (r, expected) != 0) {
4217 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
4225 static int test_checksum_6 (void)
4227 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
4229 char device[] = "/dev/sda";
4230 device[5] = devchar;
4233 r = guestfs_blockdev_setrw (g, device);
4240 r = guestfs_umount_all (g);
4247 r = guestfs_lvm_remove_all (g);
4252 char device[] = "/dev/sda";
4253 device[5] = devchar;
4254 char lines_0[] = ",";
4261 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4266 char fstype[] = "ext2";
4267 char device[] = "/dev/sda1";
4268 device[5] = devchar;
4271 r = guestfs_mkfs (g, fstype, device);
4276 char device[] = "/dev/sda1";
4277 device[5] = devchar;
4278 char mountpoint[] = "/";
4281 r = guestfs_mount (g, device, mountpoint);
4285 /* TestOutput for checksum (6) */
4286 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
4288 char path[] = "/new";
4289 char content[] = "test\n";
4292 r = guestfs_write_file (g, path, content, 0);
4297 char csumtype[] = "sha384";
4298 char path[] = "/new";
4301 r = guestfs_checksum (g, csumtype, path);
4304 if (strcmp (r, expected) != 0) {
4305 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
4313 static int test_checksum_7 (void)
4315 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
4317 char device[] = "/dev/sda";
4318 device[5] = devchar;
4321 r = guestfs_blockdev_setrw (g, device);
4328 r = guestfs_umount_all (g);
4335 r = guestfs_lvm_remove_all (g);
4340 char device[] = "/dev/sda";
4341 device[5] = devchar;
4342 char lines_0[] = ",";
4349 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4354 char fstype[] = "ext2";
4355 char device[] = "/dev/sda1";
4356 device[5] = devchar;
4359 r = guestfs_mkfs (g, fstype, device);
4364 char device[] = "/dev/sda1";
4365 device[5] = devchar;
4366 char mountpoint[] = "/";
4369 r = guestfs_mount (g, device, mountpoint);
4373 /* TestOutput for checksum (7) */
4374 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
4376 char path[] = "/new";
4377 char content[] = "test\n";
4380 r = guestfs_write_file (g, path, content, 0);
4385 char csumtype[] = "sha512";
4386 char path[] = "/new";
4389 r = guestfs_checksum (g, csumtype, path);
4392 if (strcmp (r, expected) != 0) {
4393 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
4401 static int test_download_0 (void)
4403 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
4405 char device[] = "/dev/sda";
4406 device[5] = devchar;
4409 r = guestfs_blockdev_setrw (g, device);
4416 r = guestfs_umount_all (g);
4423 r = guestfs_lvm_remove_all (g);
4428 char device[] = "/dev/sda";
4429 device[5] = devchar;
4430 char lines_0[] = ",";
4437 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4442 char fstype[] = "ext2";
4443 char device[] = "/dev/sda1";
4444 device[5] = devchar;
4447 r = guestfs_mkfs (g, fstype, device);
4452 char device[] = "/dev/sda1";
4453 device[5] = devchar;
4454 char mountpoint[] = "/";
4457 r = guestfs_mount (g, device, mountpoint);
4461 /* TestOutput for download (0) */
4462 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4464 char remotefilename[] = "/COPYING.LIB";
4467 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4472 char remotefilename[] = "/COPYING.LIB";
4475 r = guestfs_download (g, remotefilename, "testdownload.tmp");
4480 char remotefilename[] = "/upload";
4483 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
4488 char csumtype[] = "md5";
4489 char path[] = "/upload";
4492 r = guestfs_checksum (g, csumtype, path);
4495 if (strcmp (r, expected) != 0) {
4496 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
4504 static int test_upload_0 (void)
4506 /* InitBasicFS for test_upload_0: 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 upload (0) */
4565 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
4567 char remotefilename[] = "/COPYING.LIB";
4570 r = guestfs_upload (g, "COPYING.LIB", remotefilename);
4575 char csumtype[] = "md5";
4576 char path[] = "/COPYING.LIB";
4579 r = guestfs_checksum (g, csumtype, path);
4582 if (strcmp (r, expected) != 0) {
4583 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
4591 static int test_blockdev_rereadpt_0 (void)
4593 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
4595 char device[] = "/dev/sda";
4596 device[5] = devchar;
4599 r = guestfs_blockdev_setrw (g, device);
4606 r = guestfs_umount_all (g);
4613 r = guestfs_lvm_remove_all (g);
4617 /* TestRun for blockdev_rereadpt (0) */
4619 char device[] = "/dev/sda";
4620 device[5] = devchar;
4623 r = guestfs_blockdev_rereadpt (g, device);
4630 static int test_blockdev_flushbufs_0 (void)
4632 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
4634 char device[] = "/dev/sda";
4635 device[5] = devchar;
4638 r = guestfs_blockdev_setrw (g, device);
4645 r = guestfs_umount_all (g);
4652 r = guestfs_lvm_remove_all (g);
4656 /* TestRun for blockdev_flushbufs (0) */
4658 char device[] = "/dev/sda";
4659 device[5] = devchar;
4662 r = guestfs_blockdev_flushbufs (g, device);
4669 static int test_blockdev_getsize64_0 (void)
4671 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
4673 char device[] = "/dev/sda";
4674 device[5] = devchar;
4677 r = guestfs_blockdev_setrw (g, device);
4684 r = guestfs_umount_all (g);
4691 r = guestfs_lvm_remove_all (g);
4695 /* TestOutputInt for blockdev_getsize64 (0) */
4697 char device[] = "/dev/sda";
4698 device[5] = devchar;
4701 r = guestfs_blockdev_getsize64 (g, device);
4704 if (r != 524288000) {
4705 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
4712 static int test_blockdev_getsz_0 (void)
4714 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
4716 char device[] = "/dev/sda";
4717 device[5] = devchar;
4720 r = guestfs_blockdev_setrw (g, device);
4727 r = guestfs_umount_all (g);
4734 r = guestfs_lvm_remove_all (g);
4738 /* TestOutputInt for blockdev_getsz (0) */
4740 char device[] = "/dev/sda";
4741 device[5] = devchar;
4744 r = guestfs_blockdev_getsz (g, device);
4748 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
4755 static int test_blockdev_getbsz_0 (void)
4757 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
4759 char device[] = "/dev/sda";
4760 device[5] = devchar;
4763 r = guestfs_blockdev_setrw (g, device);
4770 r = guestfs_umount_all (g);
4777 r = guestfs_lvm_remove_all (g);
4781 /* TestOutputInt for blockdev_getbsz (0) */
4783 char device[] = "/dev/sda";
4784 device[5] = devchar;
4787 r = guestfs_blockdev_getbsz (g, device);
4791 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
4798 static int test_blockdev_getss_0 (void)
4800 /* InitNone|InitEmpty for test_blockdev_getss_0 */
4802 char device[] = "/dev/sda";
4803 device[5] = devchar;
4806 r = guestfs_blockdev_setrw (g, device);
4813 r = guestfs_umount_all (g);
4820 r = guestfs_lvm_remove_all (g);
4824 /* TestOutputInt for blockdev_getss (0) */
4826 char device[] = "/dev/sda";
4827 device[5] = devchar;
4830 r = guestfs_blockdev_getss (g, device);
4834 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
4841 static int test_blockdev_getro_0 (void)
4843 /* InitNone|InitEmpty for test_blockdev_getro_0 */
4845 char device[] = "/dev/sda";
4846 device[5] = devchar;
4849 r = guestfs_blockdev_setrw (g, device);
4856 r = guestfs_umount_all (g);
4863 r = guestfs_lvm_remove_all (g);
4867 /* TestOutputTrue for blockdev_getro (0) */
4869 char device[] = "/dev/sda";
4870 device[5] = devchar;
4873 r = guestfs_blockdev_setro (g, device);
4878 char device[] = "/dev/sda";
4879 device[5] = devchar;
4882 r = guestfs_blockdev_getro (g, device);
4886 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
4893 static int test_blockdev_setrw_0 (void)
4895 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
4897 char device[] = "/dev/sda";
4898 device[5] = devchar;
4901 r = guestfs_blockdev_setrw (g, device);
4908 r = guestfs_umount_all (g);
4915 r = guestfs_lvm_remove_all (g);
4919 /* TestOutputFalse for blockdev_setrw (0) */
4921 char device[] = "/dev/sda";
4922 device[5] = devchar;
4925 r = guestfs_blockdev_setrw (g, device);
4930 char device[] = "/dev/sda";
4931 device[5] = devchar;
4934 r = guestfs_blockdev_getro (g, device);
4938 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
4945 static int test_blockdev_setro_0 (void)
4947 /* InitNone|InitEmpty for test_blockdev_setro_0 */
4949 char device[] = "/dev/sda";
4950 device[5] = devchar;
4953 r = guestfs_blockdev_setrw (g, device);
4960 r = guestfs_umount_all (g);
4967 r = guestfs_lvm_remove_all (g);
4971 /* TestOutputTrue for blockdev_setro (0) */
4973 char device[] = "/dev/sda";
4974 device[5] = devchar;
4977 r = guestfs_blockdev_setro (g, device);
4982 char device[] = "/dev/sda";
4983 device[5] = devchar;
4986 r = guestfs_blockdev_getro (g, device);
4990 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
4997 static int test_statvfs_0 (void)
4999 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
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);
5024 char device[] = "/dev/sda";
5025 device[5] = devchar;
5026 char lines_0[] = ",";
5033 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5038 char fstype[] = "ext2";
5039 char device[] = "/dev/sda1";
5040 device[5] = devchar;
5043 r = guestfs_mkfs (g, fstype, device);
5048 char device[] = "/dev/sda1";
5049 device[5] = devchar;
5050 char mountpoint[] = "/";
5053 r = guestfs_mount (g, device, mountpoint);
5057 /* TestOutputStruct for statvfs (0) */
5060 struct guestfs_statvfs *r;
5062 r = guestfs_statvfs (g, path);
5065 if (r->bfree != 487702) {
5066 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
5070 if (r->blocks != 490020) {
5071 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
5075 if (r->bsize != 1024) {
5076 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
5085 static int test_lstat_0 (void)
5087 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
5089 char device[] = "/dev/sda";
5090 device[5] = devchar;
5093 r = guestfs_blockdev_setrw (g, device);
5100 r = guestfs_umount_all (g);
5107 r = guestfs_lvm_remove_all (g);
5112 char device[] = "/dev/sda";
5113 device[5] = devchar;
5114 char lines_0[] = ",";
5121 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5126 char fstype[] = "ext2";
5127 char device[] = "/dev/sda1";
5128 device[5] = devchar;
5131 r = guestfs_mkfs (g, fstype, device);
5136 char device[] = "/dev/sda1";
5137 device[5] = devchar;
5138 char mountpoint[] = "/";
5141 r = guestfs_mount (g, device, mountpoint);
5145 /* TestOutputStruct for lstat (0) */
5147 char path[] = "/new";
5150 r = guestfs_touch (g, path);
5155 char path[] = "/new";
5156 struct guestfs_stat *r;
5158 r = guestfs_lstat (g, path);
5162 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
5171 static int test_stat_0 (void)
5173 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
5175 char device[] = "/dev/sda";
5176 device[5] = devchar;
5179 r = guestfs_blockdev_setrw (g, device);
5186 r = guestfs_umount_all (g);
5193 r = guestfs_lvm_remove_all (g);
5198 char device[] = "/dev/sda";
5199 device[5] = devchar;
5200 char lines_0[] = ",";
5207 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5212 char fstype[] = "ext2";
5213 char device[] = "/dev/sda1";
5214 device[5] = devchar;
5217 r = guestfs_mkfs (g, fstype, device);
5222 char device[] = "/dev/sda1";
5223 device[5] = devchar;
5224 char mountpoint[] = "/";
5227 r = guestfs_mount (g, device, mountpoint);
5231 /* TestOutputStruct for stat (0) */
5233 char path[] = "/new";
5236 r = guestfs_touch (g, path);
5241 char path[] = "/new";
5242 struct guestfs_stat *r;
5244 r = guestfs_stat (g, path);
5248 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
5257 static int test_command_lines_0_prereq (void)
5259 const char *str = getenv ("SKIP_TEST_COMMAND");
5260 return str && strcmp (str, "1") == 0;
5263 static int test_command_lines_0 (void)
5265 if (! test_command_lines_0_prereq ()) {
5266 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
5268 char device[] = "/dev/sda";
5269 device[5] = devchar;
5272 r = guestfs_blockdev_setrw (g, device);
5279 r = guestfs_umount_all (g);
5286 r = guestfs_lvm_remove_all (g);
5291 char device[] = "/dev/sda";
5292 device[5] = devchar;
5293 char lines_0[] = ",";
5300 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5305 char fstype[] = "ext2";
5306 char device[] = "/dev/sda1";
5307 device[5] = devchar;
5310 r = guestfs_mkfs (g, fstype, device);
5315 char device[] = "/dev/sda1";
5316 device[5] = devchar;
5317 char mountpoint[] = "/";
5320 r = guestfs_mount (g, device, mountpoint);
5324 /* TestOutputList for command_lines (0) */
5326 char remotefilename[] = "/test-command";
5329 r = guestfs_upload (g, "test-command", remotefilename);
5334 char path[] = "/test-command";
5337 r = guestfs_chmod (g, 493, path);
5342 char arguments_0[] = "/test-command";
5343 char arguments_1[] = "1";
5344 char *arguments[] = {
5352 r = guestfs_command_lines (g, arguments);
5356 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
5361 char expected[] = "Result1";
5362 if (strcmp (r[0], expected) != 0) {
5363 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5368 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
5372 for (i = 0; r[i] != NULL; ++i)
5377 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_0");
5381 static int test_command_lines_1_prereq (void)
5383 const char *str = getenv ("SKIP_TEST_COMMAND");
5384 return str && strcmp (str, "1") == 0;
5387 static int test_command_lines_1 (void)
5389 if (! test_command_lines_1_prereq ()) {
5390 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
5392 char device[] = "/dev/sda";
5393 device[5] = devchar;
5396 r = guestfs_blockdev_setrw (g, device);
5403 r = guestfs_umount_all (g);
5410 r = guestfs_lvm_remove_all (g);
5415 char device[] = "/dev/sda";
5416 device[5] = devchar;
5417 char lines_0[] = ",";
5424 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5429 char fstype[] = "ext2";
5430 char device[] = "/dev/sda1";
5431 device[5] = devchar;
5434 r = guestfs_mkfs (g, fstype, device);
5439 char device[] = "/dev/sda1";
5440 device[5] = devchar;
5441 char mountpoint[] = "/";
5444 r = guestfs_mount (g, device, mountpoint);
5448 /* TestOutputList for command_lines (1) */
5450 char remotefilename[] = "/test-command";
5453 r = guestfs_upload (g, "test-command", remotefilename);
5458 char path[] = "/test-command";
5461 r = guestfs_chmod (g, 493, path);
5466 char arguments_0[] = "/test-command";
5467 char arguments_1[] = "2";
5468 char *arguments[] = {
5476 r = guestfs_command_lines (g, arguments);
5480 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
5485 char expected[] = "Result2";
5486 if (strcmp (r[0], expected) != 0) {
5487 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5492 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
5496 for (i = 0; r[i] != NULL; ++i)
5501 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_1");
5505 static int test_command_lines_2_prereq (void)
5507 const char *str = getenv ("SKIP_TEST_COMMAND");
5508 return str && strcmp (str, "1") == 0;
5511 static int test_command_lines_2 (void)
5513 if (! test_command_lines_2_prereq ()) {
5514 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
5516 char device[] = "/dev/sda";
5517 device[5] = devchar;
5520 r = guestfs_blockdev_setrw (g, device);
5527 r = guestfs_umount_all (g);
5534 r = guestfs_lvm_remove_all (g);
5539 char device[] = "/dev/sda";
5540 device[5] = devchar;
5541 char lines_0[] = ",";
5548 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5553 char fstype[] = "ext2";
5554 char device[] = "/dev/sda1";
5555 device[5] = devchar;
5558 r = guestfs_mkfs (g, fstype, device);
5563 char device[] = "/dev/sda1";
5564 device[5] = devchar;
5565 char mountpoint[] = "/";
5568 r = guestfs_mount (g, device, mountpoint);
5572 /* TestOutputList for command_lines (2) */
5574 char remotefilename[] = "/test-command";
5577 r = guestfs_upload (g, "test-command", remotefilename);
5582 char path[] = "/test-command";
5585 r = guestfs_chmod (g, 493, path);
5590 char arguments_0[] = "/test-command";
5591 char arguments_1[] = "3";
5592 char *arguments[] = {
5600 r = guestfs_command_lines (g, arguments);
5604 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5609 char expected[] = "";
5610 if (strcmp (r[0], expected) != 0) {
5611 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5616 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
5621 char expected[] = "Result3";
5622 if (strcmp (r[1], expected) != 0) {
5623 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5628 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
5632 for (i = 0; r[i] != NULL; ++i)
5637 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_2");
5641 static int test_command_lines_3_prereq (void)
5643 const char *str = getenv ("SKIP_TEST_COMMAND");
5644 return str && strcmp (str, "1") == 0;
5647 static int test_command_lines_3 (void)
5649 if (! test_command_lines_3_prereq ()) {
5650 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
5652 char device[] = "/dev/sda";
5653 device[5] = devchar;
5656 r = guestfs_blockdev_setrw (g, device);
5663 r = guestfs_umount_all (g);
5670 r = guestfs_lvm_remove_all (g);
5675 char device[] = "/dev/sda";
5676 device[5] = devchar;
5677 char lines_0[] = ",";
5684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5689 char fstype[] = "ext2";
5690 char device[] = "/dev/sda1";
5691 device[5] = devchar;
5694 r = guestfs_mkfs (g, fstype, device);
5699 char device[] = "/dev/sda1";
5700 device[5] = devchar;
5701 char mountpoint[] = "/";
5704 r = guestfs_mount (g, device, mountpoint);
5708 /* TestOutputList for command_lines (3) */
5710 char remotefilename[] = "/test-command";
5713 r = guestfs_upload (g, "test-command", remotefilename);
5718 char path[] = "/test-command";
5721 r = guestfs_chmod (g, 493, path);
5726 char arguments_0[] = "/test-command";
5727 char arguments_1[] = "4";
5728 char *arguments[] = {
5736 r = guestfs_command_lines (g, arguments);
5740 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5745 char expected[] = "";
5746 if (strcmp (r[0], expected) != 0) {
5747 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5752 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
5757 char expected[] = "Result4";
5758 if (strcmp (r[1], expected) != 0) {
5759 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5764 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
5768 for (i = 0; r[i] != NULL; ++i)
5773 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_3");
5777 static int test_command_lines_4_prereq (void)
5779 const char *str = getenv ("SKIP_TEST_COMMAND");
5780 return str && strcmp (str, "1") == 0;
5783 static int test_command_lines_4 (void)
5785 if (! test_command_lines_4_prereq ()) {
5786 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
5788 char device[] = "/dev/sda";
5789 device[5] = devchar;
5792 r = guestfs_blockdev_setrw (g, device);
5799 r = guestfs_umount_all (g);
5806 r = guestfs_lvm_remove_all (g);
5811 char device[] = "/dev/sda";
5812 device[5] = devchar;
5813 char lines_0[] = ",";
5820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5825 char fstype[] = "ext2";
5826 char device[] = "/dev/sda1";
5827 device[5] = devchar;
5830 r = guestfs_mkfs (g, fstype, device);
5835 char device[] = "/dev/sda1";
5836 device[5] = devchar;
5837 char mountpoint[] = "/";
5840 r = guestfs_mount (g, device, mountpoint);
5844 /* TestOutputList for command_lines (4) */
5846 char remotefilename[] = "/test-command";
5849 r = guestfs_upload (g, "test-command", remotefilename);
5854 char path[] = "/test-command";
5857 r = guestfs_chmod (g, 493, path);
5862 char arguments_0[] = "/test-command";
5863 char arguments_1[] = "5";
5864 char *arguments[] = {
5872 r = guestfs_command_lines (g, arguments);
5876 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5881 char expected[] = "";
5882 if (strcmp (r[0], expected) != 0) {
5883 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5888 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5893 char expected[] = "Result5";
5894 if (strcmp (r[1], expected) != 0) {
5895 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
5900 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
5905 char expected[] = "";
5906 if (strcmp (r[2], expected) != 0) {
5907 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
5912 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
5916 for (i = 0; r[i] != NULL; ++i)
5921 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_4");
5925 static int test_command_lines_5_prereq (void)
5927 const char *str = getenv ("SKIP_TEST_COMMAND");
5928 return str && strcmp (str, "1") == 0;
5931 static int test_command_lines_5 (void)
5933 if (! test_command_lines_5_prereq ()) {
5934 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
5936 char device[] = "/dev/sda";
5937 device[5] = devchar;
5940 r = guestfs_blockdev_setrw (g, device);
5947 r = guestfs_umount_all (g);
5954 r = guestfs_lvm_remove_all (g);
5959 char device[] = "/dev/sda";
5960 device[5] = devchar;
5961 char lines_0[] = ",";
5968 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5973 char fstype[] = "ext2";
5974 char device[] = "/dev/sda1";
5975 device[5] = devchar;
5978 r = guestfs_mkfs (g, fstype, device);
5983 char device[] = "/dev/sda1";
5984 device[5] = devchar;
5985 char mountpoint[] = "/";
5988 r = guestfs_mount (g, device, mountpoint);
5992 /* TestOutputList for command_lines (5) */
5994 char remotefilename[] = "/test-command";
5997 r = guestfs_upload (g, "test-command", remotefilename);
6002 char path[] = "/test-command";
6005 r = guestfs_chmod (g, 493, path);
6010 char arguments_0[] = "/test-command";
6011 char arguments_1[] = "6";
6012 char *arguments[] = {
6020 r = guestfs_command_lines (g, arguments);
6024 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6029 char expected[] = "";
6030 if (strcmp (r[0], expected) != 0) {
6031 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6036 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6041 char expected[] = "";
6042 if (strcmp (r[1], expected) != 0) {
6043 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6048 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6053 char expected[] = "Result6";
6054 if (strcmp (r[2], expected) != 0) {
6055 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
6060 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
6065 char expected[] = "";
6066 if (strcmp (r[3], expected) != 0) {
6067 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
6072 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
6076 for (i = 0; r[i] != NULL; ++i)
6081 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_5");
6085 static int test_command_lines_6_prereq (void)
6087 const char *str = getenv ("SKIP_TEST_COMMAND");
6088 return str && strcmp (str, "1") == 0;
6091 static int test_command_lines_6 (void)
6093 if (! test_command_lines_6_prereq ()) {
6094 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
6096 char device[] = "/dev/sda";
6097 device[5] = devchar;
6100 r = guestfs_blockdev_setrw (g, device);
6107 r = guestfs_umount_all (g);
6114 r = guestfs_lvm_remove_all (g);
6119 char device[] = "/dev/sda";
6120 device[5] = devchar;
6121 char lines_0[] = ",";
6128 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6133 char fstype[] = "ext2";
6134 char device[] = "/dev/sda1";
6135 device[5] = devchar;
6138 r = guestfs_mkfs (g, fstype, device);
6143 char device[] = "/dev/sda1";
6144 device[5] = devchar;
6145 char mountpoint[] = "/";
6148 r = guestfs_mount (g, device, mountpoint);
6152 /* TestOutputList for command_lines (6) */
6154 char remotefilename[] = "/test-command";
6157 r = guestfs_upload (g, "test-command", remotefilename);
6162 char path[] = "/test-command";
6165 r = guestfs_chmod (g, 493, path);
6170 char arguments_0[] = "/test-command";
6171 char arguments_1[] = "7";
6172 char *arguments[] = {
6180 r = guestfs_command_lines (g, arguments);
6184 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
6188 for (i = 0; r[i] != NULL; ++i)
6193 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_6");
6197 static int test_command_lines_7_prereq (void)
6199 const char *str = getenv ("SKIP_TEST_COMMAND");
6200 return str && strcmp (str, "1") == 0;
6203 static int test_command_lines_7 (void)
6205 if (! test_command_lines_7_prereq ()) {
6206 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
6208 char device[] = "/dev/sda";
6209 device[5] = devchar;
6212 r = guestfs_blockdev_setrw (g, device);
6219 r = guestfs_umount_all (g);
6226 r = guestfs_lvm_remove_all (g);
6231 char device[] = "/dev/sda";
6232 device[5] = devchar;
6233 char lines_0[] = ",";
6240 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6245 char fstype[] = "ext2";
6246 char device[] = "/dev/sda1";
6247 device[5] = devchar;
6250 r = guestfs_mkfs (g, fstype, device);
6255 char device[] = "/dev/sda1";
6256 device[5] = devchar;
6257 char mountpoint[] = "/";
6260 r = guestfs_mount (g, device, mountpoint);
6264 /* TestOutputList for command_lines (7) */
6266 char remotefilename[] = "/test-command";
6269 r = guestfs_upload (g, "test-command", remotefilename);
6274 char path[] = "/test-command";
6277 r = guestfs_chmod (g, 493, path);
6282 char arguments_0[] = "/test-command";
6283 char arguments_1[] = "8";
6284 char *arguments[] = {
6292 r = guestfs_command_lines (g, arguments);
6296 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
6301 char expected[] = "";
6302 if (strcmp (r[0], expected) != 0) {
6303 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6308 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
6312 for (i = 0; r[i] != NULL; ++i)
6317 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_7");
6321 static int test_command_lines_8_prereq (void)
6323 const char *str = getenv ("SKIP_TEST_COMMAND");
6324 return str && strcmp (str, "1") == 0;
6327 static int test_command_lines_8 (void)
6329 if (! test_command_lines_8_prereq ()) {
6330 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
6332 char device[] = "/dev/sda";
6333 device[5] = devchar;
6336 r = guestfs_blockdev_setrw (g, device);
6343 r = guestfs_umount_all (g);
6350 r = guestfs_lvm_remove_all (g);
6355 char device[] = "/dev/sda";
6356 device[5] = devchar;
6357 char lines_0[] = ",";
6364 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6369 char fstype[] = "ext2";
6370 char device[] = "/dev/sda1";
6371 device[5] = devchar;
6374 r = guestfs_mkfs (g, fstype, device);
6379 char device[] = "/dev/sda1";
6380 device[5] = devchar;
6381 char mountpoint[] = "/";
6384 r = guestfs_mount (g, device, mountpoint);
6388 /* TestOutputList for command_lines (8) */
6390 char remotefilename[] = "/test-command";
6393 r = guestfs_upload (g, "test-command", remotefilename);
6398 char path[] = "/test-command";
6401 r = guestfs_chmod (g, 493, path);
6406 char arguments_0[] = "/test-command";
6407 char arguments_1[] = "9";
6408 char *arguments[] = {
6416 r = guestfs_command_lines (g, arguments);
6420 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6425 char expected[] = "";
6426 if (strcmp (r[0], expected) != 0) {
6427 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6432 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
6437 char expected[] = "";
6438 if (strcmp (r[1], expected) != 0) {
6439 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6444 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
6448 for (i = 0; r[i] != NULL; ++i)
6453 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_8");
6457 static int test_command_lines_9_prereq (void)
6459 const char *str = getenv ("SKIP_TEST_COMMAND");
6460 return str && strcmp (str, "1") == 0;
6463 static int test_command_lines_9 (void)
6465 if (! test_command_lines_9_prereq ()) {
6466 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
6468 char device[] = "/dev/sda";
6469 device[5] = devchar;
6472 r = guestfs_blockdev_setrw (g, device);
6479 r = guestfs_umount_all (g);
6486 r = guestfs_lvm_remove_all (g);
6491 char device[] = "/dev/sda";
6492 device[5] = devchar;
6493 char lines_0[] = ",";
6500 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6505 char fstype[] = "ext2";
6506 char device[] = "/dev/sda1";
6507 device[5] = devchar;
6510 r = guestfs_mkfs (g, fstype, device);
6515 char device[] = "/dev/sda1";
6516 device[5] = devchar;
6517 char mountpoint[] = "/";
6520 r = guestfs_mount (g, device, mountpoint);
6524 /* TestOutputList for command_lines (9) */
6526 char remotefilename[] = "/test-command";
6529 r = guestfs_upload (g, "test-command", remotefilename);
6534 char path[] = "/test-command";
6537 r = guestfs_chmod (g, 493, path);
6542 char arguments_0[] = "/test-command";
6543 char arguments_1[] = "10";
6544 char *arguments[] = {
6552 r = guestfs_command_lines (g, arguments);
6556 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6561 char expected[] = "Result10-1";
6562 if (strcmp (r[0], expected) != 0) {
6563 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6568 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
6573 char expected[] = "Result10-2";
6574 if (strcmp (r[1], expected) != 0) {
6575 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6580 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
6584 for (i = 0; r[i] != NULL; ++i)
6589 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_9");
6593 static int test_command_lines_10_prereq (void)
6595 const char *str = getenv ("SKIP_TEST_COMMAND");
6596 return str && strcmp (str, "1") == 0;
6599 static int test_command_lines_10 (void)
6601 if (! test_command_lines_10_prereq ()) {
6602 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
6604 char device[] = "/dev/sda";
6605 device[5] = devchar;
6608 r = guestfs_blockdev_setrw (g, device);
6615 r = guestfs_umount_all (g);
6622 r = guestfs_lvm_remove_all (g);
6627 char device[] = "/dev/sda";
6628 device[5] = devchar;
6629 char lines_0[] = ",";
6636 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6641 char fstype[] = "ext2";
6642 char device[] = "/dev/sda1";
6643 device[5] = devchar;
6646 r = guestfs_mkfs (g, fstype, device);
6651 char device[] = "/dev/sda1";
6652 device[5] = devchar;
6653 char mountpoint[] = "/";
6656 r = guestfs_mount (g, device, mountpoint);
6660 /* TestOutputList for command_lines (10) */
6662 char remotefilename[] = "/test-command";
6665 r = guestfs_upload (g, "test-command", remotefilename);
6670 char path[] = "/test-command";
6673 r = guestfs_chmod (g, 493, path);
6678 char arguments_0[] = "/test-command";
6679 char arguments_1[] = "11";
6680 char *arguments[] = {
6688 r = guestfs_command_lines (g, arguments);
6692 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6697 char expected[] = "Result11-1";
6698 if (strcmp (r[0], expected) != 0) {
6699 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6704 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
6709 char expected[] = "Result11-2";
6710 if (strcmp (r[1], expected) != 0) {
6711 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
6716 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
6720 for (i = 0; r[i] != NULL; ++i)
6725 printf ("%s skipped (reason: test prerequisite)\n", "test_command_lines_10");
6729 static int test_command_0_prereq (void)
6731 const char *str = getenv ("SKIP_TEST_COMMAND");
6732 return str && strcmp (str, "1") == 0;
6735 static int test_command_0 (void)
6737 if (! test_command_0_prereq ()) {
6738 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
6740 char device[] = "/dev/sda";
6741 device[5] = devchar;
6744 r = guestfs_blockdev_setrw (g, device);
6751 r = guestfs_umount_all (g);
6758 r = guestfs_lvm_remove_all (g);
6763 char device[] = "/dev/sda";
6764 device[5] = devchar;
6765 char lines_0[] = ",";
6772 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6777 char fstype[] = "ext2";
6778 char device[] = "/dev/sda1";
6779 device[5] = devchar;
6782 r = guestfs_mkfs (g, fstype, device);
6787 char device[] = "/dev/sda1";
6788 device[5] = devchar;
6789 char mountpoint[] = "/";
6792 r = guestfs_mount (g, device, mountpoint);
6796 /* TestOutput for command (0) */
6797 char expected[] = "Result1";
6799 char remotefilename[] = "/test-command";
6802 r = guestfs_upload (g, "test-command", remotefilename);
6807 char path[] = "/test-command";
6810 r = guestfs_chmod (g, 493, path);
6815 char arguments_0[] = "/test-command";
6816 char arguments_1[] = "1";
6817 char *arguments[] = {
6824 r = guestfs_command (g, arguments);
6827 if (strcmp (r, expected) != 0) {
6828 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
6834 printf ("%s skipped (reason: test prerequisite)\n", "test_command_0");
6838 static int test_command_1_prereq (void)
6840 const char *str = getenv ("SKIP_TEST_COMMAND");
6841 return str && strcmp (str, "1") == 0;
6844 static int test_command_1 (void)
6846 if (! test_command_1_prereq ()) {
6847 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
6849 char device[] = "/dev/sda";
6850 device[5] = devchar;
6853 r = guestfs_blockdev_setrw (g, device);
6860 r = guestfs_umount_all (g);
6867 r = guestfs_lvm_remove_all (g);
6872 char device[] = "/dev/sda";
6873 device[5] = devchar;
6874 char lines_0[] = ",";
6881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6886 char fstype[] = "ext2";
6887 char device[] = "/dev/sda1";
6888 device[5] = devchar;
6891 r = guestfs_mkfs (g, fstype, device);
6896 char device[] = "/dev/sda1";
6897 device[5] = devchar;
6898 char mountpoint[] = "/";
6901 r = guestfs_mount (g, device, mountpoint);
6905 /* TestOutput for command (1) */
6906 char expected[] = "Result2\n";
6908 char remotefilename[] = "/test-command";
6911 r = guestfs_upload (g, "test-command", remotefilename);
6916 char path[] = "/test-command";
6919 r = guestfs_chmod (g, 493, path);
6924 char arguments_0[] = "/test-command";
6925 char arguments_1[] = "2";
6926 char *arguments[] = {
6933 r = guestfs_command (g, arguments);
6936 if (strcmp (r, expected) != 0) {
6937 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
6943 printf ("%s skipped (reason: test prerequisite)\n", "test_command_1");
6947 static int test_command_2_prereq (void)
6949 const char *str = getenv ("SKIP_TEST_COMMAND");
6950 return str && strcmp (str, "1") == 0;
6953 static int test_command_2 (void)
6955 if (! test_command_2_prereq ()) {
6956 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
6958 char device[] = "/dev/sda";
6959 device[5] = devchar;
6962 r = guestfs_blockdev_setrw (g, device);
6969 r = guestfs_umount_all (g);
6976 r = guestfs_lvm_remove_all (g);
6981 char device[] = "/dev/sda";
6982 device[5] = devchar;
6983 char lines_0[] = ",";
6990 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6995 char fstype[] = "ext2";
6996 char device[] = "/dev/sda1";
6997 device[5] = devchar;
7000 r = guestfs_mkfs (g, fstype, device);
7005 char device[] = "/dev/sda1";
7006 device[5] = devchar;
7007 char mountpoint[] = "/";
7010 r = guestfs_mount (g, device, mountpoint);
7014 /* TestOutput for command (2) */
7015 char expected[] = "\nResult3";
7017 char remotefilename[] = "/test-command";
7020 r = guestfs_upload (g, "test-command", remotefilename);
7025 char path[] = "/test-command";
7028 r = guestfs_chmod (g, 493, path);
7033 char arguments_0[] = "/test-command";
7034 char arguments_1[] = "3";
7035 char *arguments[] = {
7042 r = guestfs_command (g, arguments);
7045 if (strcmp (r, expected) != 0) {
7046 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
7052 printf ("%s skipped (reason: test prerequisite)\n", "test_command_2");
7056 static int test_command_3_prereq (void)
7058 const char *str = getenv ("SKIP_TEST_COMMAND");
7059 return str && strcmp (str, "1") == 0;
7062 static int test_command_3 (void)
7064 if (! test_command_3_prereq ()) {
7065 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
7067 char device[] = "/dev/sda";
7068 device[5] = devchar;
7071 r = guestfs_blockdev_setrw (g, device);
7078 r = guestfs_umount_all (g);
7085 r = guestfs_lvm_remove_all (g);
7090 char device[] = "/dev/sda";
7091 device[5] = devchar;
7092 char lines_0[] = ",";
7099 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7104 char fstype[] = "ext2";
7105 char device[] = "/dev/sda1";
7106 device[5] = devchar;
7109 r = guestfs_mkfs (g, fstype, device);
7114 char device[] = "/dev/sda1";
7115 device[5] = devchar;
7116 char mountpoint[] = "/";
7119 r = guestfs_mount (g, device, mountpoint);
7123 /* TestOutput for command (3) */
7124 char expected[] = "\nResult4\n";
7126 char remotefilename[] = "/test-command";
7129 r = guestfs_upload (g, "test-command", remotefilename);
7134 char path[] = "/test-command";
7137 r = guestfs_chmod (g, 493, path);
7142 char arguments_0[] = "/test-command";
7143 char arguments_1[] = "4";
7144 char *arguments[] = {
7151 r = guestfs_command (g, arguments);
7154 if (strcmp (r, expected) != 0) {
7155 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
7161 printf ("%s skipped (reason: test prerequisite)\n", "test_command_3");
7165 static int test_command_4_prereq (void)
7167 const char *str = getenv ("SKIP_TEST_COMMAND");
7168 return str && strcmp (str, "1") == 0;
7171 static int test_command_4 (void)
7173 if (! test_command_4_prereq ()) {
7174 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
7176 char device[] = "/dev/sda";
7177 device[5] = devchar;
7180 r = guestfs_blockdev_setrw (g, device);
7187 r = guestfs_umount_all (g);
7194 r = guestfs_lvm_remove_all (g);
7199 char device[] = "/dev/sda";
7200 device[5] = devchar;
7201 char lines_0[] = ",";
7208 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7213 char fstype[] = "ext2";
7214 char device[] = "/dev/sda1";
7215 device[5] = devchar;
7218 r = guestfs_mkfs (g, fstype, device);
7223 char device[] = "/dev/sda1";
7224 device[5] = devchar;
7225 char mountpoint[] = "/";
7228 r = guestfs_mount (g, device, mountpoint);
7232 /* TestOutput for command (4) */
7233 char expected[] = "\nResult5\n\n";
7235 char remotefilename[] = "/test-command";
7238 r = guestfs_upload (g, "test-command", remotefilename);
7243 char path[] = "/test-command";
7246 r = guestfs_chmod (g, 493, path);
7251 char arguments_0[] = "/test-command";
7252 char arguments_1[] = "5";
7253 char *arguments[] = {
7260 r = guestfs_command (g, arguments);
7263 if (strcmp (r, expected) != 0) {
7264 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
7270 printf ("%s skipped (reason: test prerequisite)\n", "test_command_4");
7274 static int test_command_5_prereq (void)
7276 const char *str = getenv ("SKIP_TEST_COMMAND");
7277 return str && strcmp (str, "1") == 0;
7280 static int test_command_5 (void)
7282 if (! test_command_5_prereq ()) {
7283 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
7285 char device[] = "/dev/sda";
7286 device[5] = devchar;
7289 r = guestfs_blockdev_setrw (g, device);
7296 r = guestfs_umount_all (g);
7303 r = guestfs_lvm_remove_all (g);
7308 char device[] = "/dev/sda";
7309 device[5] = devchar;
7310 char lines_0[] = ",";
7317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7322 char fstype[] = "ext2";
7323 char device[] = "/dev/sda1";
7324 device[5] = devchar;
7327 r = guestfs_mkfs (g, fstype, device);
7332 char device[] = "/dev/sda1";
7333 device[5] = devchar;
7334 char mountpoint[] = "/";
7337 r = guestfs_mount (g, device, mountpoint);
7341 /* TestOutput for command (5) */
7342 char expected[] = "\n\nResult6\n\n";
7344 char remotefilename[] = "/test-command";
7347 r = guestfs_upload (g, "test-command", remotefilename);
7352 char path[] = "/test-command";
7355 r = guestfs_chmod (g, 493, path);
7360 char arguments_0[] = "/test-command";
7361 char arguments_1[] = "6";
7362 char *arguments[] = {
7369 r = guestfs_command (g, arguments);
7372 if (strcmp (r, expected) != 0) {
7373 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
7379 printf ("%s skipped (reason: test prerequisite)\n", "test_command_5");
7383 static int test_command_6_prereq (void)
7385 const char *str = getenv ("SKIP_TEST_COMMAND");
7386 return str && strcmp (str, "1") == 0;
7389 static int test_command_6 (void)
7391 if (! test_command_6_prereq ()) {
7392 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
7394 char device[] = "/dev/sda";
7395 device[5] = devchar;
7398 r = guestfs_blockdev_setrw (g, device);
7405 r = guestfs_umount_all (g);
7412 r = guestfs_lvm_remove_all (g);
7417 char device[] = "/dev/sda";
7418 device[5] = devchar;
7419 char lines_0[] = ",";
7426 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7431 char fstype[] = "ext2";
7432 char device[] = "/dev/sda1";
7433 device[5] = devchar;
7436 r = guestfs_mkfs (g, fstype, device);
7441 char device[] = "/dev/sda1";
7442 device[5] = devchar;
7443 char mountpoint[] = "/";
7446 r = guestfs_mount (g, device, mountpoint);
7450 /* TestOutput for command (6) */
7451 char expected[] = "";
7453 char remotefilename[] = "/test-command";
7456 r = guestfs_upload (g, "test-command", remotefilename);
7461 char path[] = "/test-command";
7464 r = guestfs_chmod (g, 493, path);
7469 char arguments_0[] = "/test-command";
7470 char arguments_1[] = "7";
7471 char *arguments[] = {
7478 r = guestfs_command (g, arguments);
7481 if (strcmp (r, expected) != 0) {
7482 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
7488 printf ("%s skipped (reason: test prerequisite)\n", "test_command_6");
7492 static int test_command_7_prereq (void)
7494 const char *str = getenv ("SKIP_TEST_COMMAND");
7495 return str && strcmp (str, "1") == 0;
7498 static int test_command_7 (void)
7500 if (! test_command_7_prereq ()) {
7501 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
7503 char device[] = "/dev/sda";
7504 device[5] = devchar;
7507 r = guestfs_blockdev_setrw (g, device);
7514 r = guestfs_umount_all (g);
7521 r = guestfs_lvm_remove_all (g);
7526 char device[] = "/dev/sda";
7527 device[5] = devchar;
7528 char lines_0[] = ",";
7535 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7540 char fstype[] = "ext2";
7541 char device[] = "/dev/sda1";
7542 device[5] = devchar;
7545 r = guestfs_mkfs (g, fstype, device);
7550 char device[] = "/dev/sda1";
7551 device[5] = devchar;
7552 char mountpoint[] = "/";
7555 r = guestfs_mount (g, device, mountpoint);
7559 /* TestOutput for command (7) */
7560 char expected[] = "\n";
7562 char remotefilename[] = "/test-command";
7565 r = guestfs_upload (g, "test-command", remotefilename);
7570 char path[] = "/test-command";
7573 r = guestfs_chmod (g, 493, path);
7578 char arguments_0[] = "/test-command";
7579 char arguments_1[] = "8";
7580 char *arguments[] = {
7587 r = guestfs_command (g, arguments);
7590 if (strcmp (r, expected) != 0) {
7591 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
7597 printf ("%s skipped (reason: test prerequisite)\n", "test_command_7");
7601 static int test_command_8_prereq (void)
7603 const char *str = getenv ("SKIP_TEST_COMMAND");
7604 return str && strcmp (str, "1") == 0;
7607 static int test_command_8 (void)
7609 if (! test_command_8_prereq ()) {
7610 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
7612 char device[] = "/dev/sda";
7613 device[5] = devchar;
7616 r = guestfs_blockdev_setrw (g, device);
7623 r = guestfs_umount_all (g);
7630 r = guestfs_lvm_remove_all (g);
7635 char device[] = "/dev/sda";
7636 device[5] = devchar;
7637 char lines_0[] = ",";
7644 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7649 char fstype[] = "ext2";
7650 char device[] = "/dev/sda1";
7651 device[5] = devchar;
7654 r = guestfs_mkfs (g, fstype, device);
7659 char device[] = "/dev/sda1";
7660 device[5] = devchar;
7661 char mountpoint[] = "/";
7664 r = guestfs_mount (g, device, mountpoint);
7668 /* TestOutput for command (8) */
7669 char expected[] = "\n\n";
7671 char remotefilename[] = "/test-command";
7674 r = guestfs_upload (g, "test-command", remotefilename);
7679 char path[] = "/test-command";
7682 r = guestfs_chmod (g, 493, path);
7687 char arguments_0[] = "/test-command";
7688 char arguments_1[] = "9";
7689 char *arguments[] = {
7696 r = guestfs_command (g, arguments);
7699 if (strcmp (r, expected) != 0) {
7700 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
7706 printf ("%s skipped (reason: test prerequisite)\n", "test_command_8");
7710 static int test_command_9_prereq (void)
7712 const char *str = getenv ("SKIP_TEST_COMMAND");
7713 return str && strcmp (str, "1") == 0;
7716 static int test_command_9 (void)
7718 if (! test_command_9_prereq ()) {
7719 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
7721 char device[] = "/dev/sda";
7722 device[5] = devchar;
7725 r = guestfs_blockdev_setrw (g, device);
7732 r = guestfs_umount_all (g);
7739 r = guestfs_lvm_remove_all (g);
7744 char device[] = "/dev/sda";
7745 device[5] = devchar;
7746 char lines_0[] = ",";
7753 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7758 char fstype[] = "ext2";
7759 char device[] = "/dev/sda1";
7760 device[5] = devchar;
7763 r = guestfs_mkfs (g, fstype, device);
7768 char device[] = "/dev/sda1";
7769 device[5] = devchar;
7770 char mountpoint[] = "/";
7773 r = guestfs_mount (g, device, mountpoint);
7777 /* TestOutput for command (9) */
7778 char expected[] = "Result10-1\nResult10-2\n";
7780 char remotefilename[] = "/test-command";
7783 r = guestfs_upload (g, "test-command", remotefilename);
7788 char path[] = "/test-command";
7791 r = guestfs_chmod (g, 493, path);
7796 char arguments_0[] = "/test-command";
7797 char arguments_1[] = "10";
7798 char *arguments[] = {
7805 r = guestfs_command (g, arguments);
7808 if (strcmp (r, expected) != 0) {
7809 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
7815 printf ("%s skipped (reason: test prerequisite)\n", "test_command_9");
7819 static int test_command_10_prereq (void)
7821 const char *str = getenv ("SKIP_TEST_COMMAND");
7822 return str && strcmp (str, "1") == 0;
7825 static int test_command_10 (void)
7827 if (! test_command_10_prereq ()) {
7828 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
7830 char device[] = "/dev/sda";
7831 device[5] = devchar;
7834 r = guestfs_blockdev_setrw (g, device);
7841 r = guestfs_umount_all (g);
7848 r = guestfs_lvm_remove_all (g);
7853 char device[] = "/dev/sda";
7854 device[5] = devchar;
7855 char lines_0[] = ",";
7862 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7867 char fstype[] = "ext2";
7868 char device[] = "/dev/sda1";
7869 device[5] = devchar;
7872 r = guestfs_mkfs (g, fstype, device);
7877 char device[] = "/dev/sda1";
7878 device[5] = devchar;
7879 char mountpoint[] = "/";
7882 r = guestfs_mount (g, device, mountpoint);
7886 /* TestOutput for command (10) */
7887 char expected[] = "Result11-1\nResult11-2";
7889 char remotefilename[] = "/test-command";
7892 r = guestfs_upload (g, "test-command", remotefilename);
7897 char path[] = "/test-command";
7900 r = guestfs_chmod (g, 493, path);
7905 char arguments_0[] = "/test-command";
7906 char arguments_1[] = "11";
7907 char *arguments[] = {
7914 r = guestfs_command (g, arguments);
7917 if (strcmp (r, expected) != 0) {
7918 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
7924 printf ("%s skipped (reason: test prerequisite)\n", "test_command_10");
7928 static int test_command_11_prereq (void)
7930 const char *str = getenv ("SKIP_TEST_COMMAND");
7931 return str && strcmp (str, "1") == 0;
7934 static int test_command_11 (void)
7936 if (! test_command_11_prereq ()) {
7937 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
7939 char device[] = "/dev/sda";
7940 device[5] = devchar;
7943 r = guestfs_blockdev_setrw (g, device);
7950 r = guestfs_umount_all (g);
7957 r = guestfs_lvm_remove_all (g);
7962 char device[] = "/dev/sda";
7963 device[5] = devchar;
7964 char lines_0[] = ",";
7971 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7976 char fstype[] = "ext2";
7977 char device[] = "/dev/sda1";
7978 device[5] = devchar;
7981 r = guestfs_mkfs (g, fstype, device);
7986 char device[] = "/dev/sda1";
7987 device[5] = devchar;
7988 char mountpoint[] = "/";
7991 r = guestfs_mount (g, device, mountpoint);
7995 /* TestLastFail for command (11) */
7997 char remotefilename[] = "/test-command";
8000 r = guestfs_upload (g, "test-command", remotefilename);
8005 char path[] = "/test-command";
8008 r = guestfs_chmod (g, 493, path);
8013 char arguments_0[] = "/test-command";
8014 char *arguments[] = {
8020 r = guestfs_command (g, arguments);
8026 printf ("%s skipped (reason: test prerequisite)\n", "test_command_11");
8030 static int test_file_0 (void)
8032 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
8034 char device[] = "/dev/sda";
8035 device[5] = devchar;
8038 r = guestfs_blockdev_setrw (g, device);
8045 r = guestfs_umount_all (g);
8052 r = guestfs_lvm_remove_all (g);
8057 char device[] = "/dev/sda";
8058 device[5] = devchar;
8059 char lines_0[] = ",";
8066 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8071 char fstype[] = "ext2";
8072 char device[] = "/dev/sda1";
8073 device[5] = devchar;
8076 r = guestfs_mkfs (g, fstype, device);
8081 char device[] = "/dev/sda1";
8082 device[5] = devchar;
8083 char mountpoint[] = "/";
8086 r = guestfs_mount (g, device, mountpoint);
8090 /* TestOutput for file (0) */
8091 char expected[] = "empty";
8093 char path[] = "/new";
8096 r = guestfs_touch (g, path);
8101 char path[] = "/new";
8104 r = guestfs_file (g, path);
8107 if (strcmp (r, expected) != 0) {
8108 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8116 static int test_file_1 (void)
8118 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
8120 char device[] = "/dev/sda";
8121 device[5] = devchar;
8124 r = guestfs_blockdev_setrw (g, device);
8131 r = guestfs_umount_all (g);
8138 r = guestfs_lvm_remove_all (g);
8143 char device[] = "/dev/sda";
8144 device[5] = devchar;
8145 char lines_0[] = ",";
8152 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8157 char fstype[] = "ext2";
8158 char device[] = "/dev/sda1";
8159 device[5] = devchar;
8162 r = guestfs_mkfs (g, fstype, device);
8167 char device[] = "/dev/sda1";
8168 device[5] = devchar;
8169 char mountpoint[] = "/";
8172 r = guestfs_mount (g, device, mountpoint);
8176 /* TestOutput for file (1) */
8177 char expected[] = "ASCII text";
8179 char path[] = "/new";
8180 char content[] = "some content\n";
8183 r = guestfs_write_file (g, path, content, 0);
8188 char path[] = "/new";
8191 r = guestfs_file (g, path);
8194 if (strcmp (r, expected) != 0) {
8195 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8203 static int test_file_2 (void)
8205 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
8207 char device[] = "/dev/sda";
8208 device[5] = devchar;
8211 r = guestfs_blockdev_setrw (g, device);
8218 r = guestfs_umount_all (g);
8225 r = guestfs_lvm_remove_all (g);
8230 char device[] = "/dev/sda";
8231 device[5] = devchar;
8232 char lines_0[] = ",";
8239 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8244 char fstype[] = "ext2";
8245 char device[] = "/dev/sda1";
8246 device[5] = devchar;
8249 r = guestfs_mkfs (g, fstype, device);
8254 char device[] = "/dev/sda1";
8255 device[5] = devchar;
8256 char mountpoint[] = "/";
8259 r = guestfs_mount (g, device, mountpoint);
8263 /* TestLastFail for file (2) */
8265 char path[] = "/nofile";
8268 r = guestfs_file (g, path);
8276 static int test_umount_all_0 (void)
8278 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
8280 char device[] = "/dev/sda";
8281 device[5] = devchar;
8284 r = guestfs_blockdev_setrw (g, device);
8291 r = guestfs_umount_all (g);
8298 r = guestfs_lvm_remove_all (g);
8303 char device[] = "/dev/sda";
8304 device[5] = devchar;
8305 char lines_0[] = ",";
8312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8317 char fstype[] = "ext2";
8318 char device[] = "/dev/sda1";
8319 device[5] = devchar;
8322 r = guestfs_mkfs (g, fstype, device);
8327 char device[] = "/dev/sda1";
8328 device[5] = devchar;
8329 char mountpoint[] = "/";
8332 r = guestfs_mount (g, device, mountpoint);
8336 /* TestOutputList for umount_all (0) */
8340 r = guestfs_umount_all (g);
8348 r = guestfs_mounts (g);
8352 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
8356 for (i = 0; r[i] != NULL; ++i)
8363 static int test_umount_all_1 (void)
8365 /* InitNone|InitEmpty for test_umount_all_1 */
8367 char device[] = "/dev/sda";
8368 device[5] = devchar;
8371 r = guestfs_blockdev_setrw (g, device);
8378 r = guestfs_umount_all (g);
8385 r = guestfs_lvm_remove_all (g);
8389 /* TestOutputList for umount_all (1) */
8391 char device[] = "/dev/sda";
8392 device[5] = devchar;
8393 char lines_0[] = ",10";
8394 char lines_1[] = ",20";
8395 char lines_2[] = ",";
8404 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8409 char fstype[] = "ext2";
8410 char device[] = "/dev/sda1";
8411 device[5] = devchar;
8414 r = guestfs_mkfs (g, fstype, device);
8419 char fstype[] = "ext2";
8420 char device[] = "/dev/sda2";
8421 device[5] = devchar;
8424 r = guestfs_mkfs (g, fstype, device);
8429 char fstype[] = "ext2";
8430 char device[] = "/dev/sda3";
8431 device[5] = devchar;
8434 r = guestfs_mkfs (g, fstype, device);
8439 char device[] = "/dev/sda1";
8440 device[5] = devchar;
8441 char mountpoint[] = "/";
8444 r = guestfs_mount (g, device, mountpoint);
8449 char path[] = "/mp1";
8452 r = guestfs_mkdir (g, path);
8457 char device[] = "/dev/sda2";
8458 device[5] = devchar;
8459 char mountpoint[] = "/mp1";
8462 r = guestfs_mount (g, device, mountpoint);
8467 char path[] = "/mp1/mp2";
8470 r = guestfs_mkdir (g, path);
8475 char device[] = "/dev/sda3";
8476 device[5] = devchar;
8477 char mountpoint[] = "/mp1/mp2";
8480 r = guestfs_mount (g, device, mountpoint);
8485 char path[] = "/mp1/mp2/mp3";
8488 r = guestfs_mkdir (g, path);
8495 r = guestfs_umount_all (g);
8503 r = guestfs_mounts (g);
8507 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
8511 for (i = 0; r[i] != NULL; ++i)
8518 static int test_mounts_0 (void)
8520 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
8522 char device[] = "/dev/sda";
8523 device[5] = devchar;
8526 r = guestfs_blockdev_setrw (g, device);
8533 r = guestfs_umount_all (g);
8540 r = guestfs_lvm_remove_all (g);
8545 char device[] = "/dev/sda";
8546 device[5] = devchar;
8547 char lines_0[] = ",";
8554 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8559 char fstype[] = "ext2";
8560 char device[] = "/dev/sda1";
8561 device[5] = devchar;
8564 r = guestfs_mkfs (g, fstype, device);
8569 char device[] = "/dev/sda1";
8570 device[5] = devchar;
8571 char mountpoint[] = "/";
8574 r = guestfs_mount (g, device, mountpoint);
8578 /* TestOutputList for mounts (0) */
8583 r = guestfs_mounts (g);
8587 fprintf (stderr, "test_mounts_0: short list returned from command\n");
8592 char expected[] = "/dev/sda1";
8593 expected[5] = devchar;
8594 if (strcmp (r[0], expected) != 0) {
8595 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8600 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
8604 for (i = 0; r[i] != NULL; ++i)
8611 static int test_umount_0 (void)
8613 /* InitNone|InitEmpty for test_umount_0 */
8615 char device[] = "/dev/sda";
8616 device[5] = devchar;
8619 r = guestfs_blockdev_setrw (g, device);
8626 r = guestfs_umount_all (g);
8633 r = guestfs_lvm_remove_all (g);
8637 /* TestOutputList for umount (0) */
8639 char device[] = "/dev/sda";
8640 device[5] = devchar;
8641 char lines_0[] = ",";
8648 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8653 char fstype[] = "ext2";
8654 char device[] = "/dev/sda1";
8655 device[5] = devchar;
8658 r = guestfs_mkfs (g, fstype, device);
8663 char device[] = "/dev/sda1";
8664 device[5] = devchar;
8665 char mountpoint[] = "/";
8668 r = guestfs_mount (g, device, mountpoint);
8676 r = guestfs_mounts (g);
8680 fprintf (stderr, "test_umount_0: short list returned from command\n");
8685 char expected[] = "/dev/sda1";
8686 expected[5] = devchar;
8687 if (strcmp (r[0], expected) != 0) {
8688 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8693 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
8697 for (i = 0; r[i] != NULL; ++i)
8704 static int test_umount_1 (void)
8706 /* InitNone|InitEmpty for test_umount_1 */
8708 char device[] = "/dev/sda";
8709 device[5] = devchar;
8712 r = guestfs_blockdev_setrw (g, device);
8719 r = guestfs_umount_all (g);
8726 r = guestfs_lvm_remove_all (g);
8730 /* TestOutputList for umount (1) */
8732 char device[] = "/dev/sda";
8733 device[5] = devchar;
8734 char lines_0[] = ",";
8741 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8746 char fstype[] = "ext2";
8747 char device[] = "/dev/sda1";
8748 device[5] = devchar;
8751 r = guestfs_mkfs (g, fstype, device);
8756 char device[] = "/dev/sda1";
8757 device[5] = devchar;
8758 char mountpoint[] = "/";
8761 r = guestfs_mount (g, device, mountpoint);
8766 char pathordevice[] = "/";
8769 r = guestfs_umount (g, pathordevice);
8777 r = guestfs_mounts (g);
8781 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
8785 for (i = 0; r[i] != NULL; ++i)
8792 static int test_write_file_0 (void)
8794 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
8796 char device[] = "/dev/sda";
8797 device[5] = devchar;
8800 r = guestfs_blockdev_setrw (g, device);
8807 r = guestfs_umount_all (g);
8814 r = guestfs_lvm_remove_all (g);
8819 char device[] = "/dev/sda";
8820 device[5] = devchar;
8821 char lines_0[] = ",";
8828 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8833 char fstype[] = "ext2";
8834 char device[] = "/dev/sda1";
8835 device[5] = devchar;
8838 r = guestfs_mkfs (g, fstype, device);
8843 char device[] = "/dev/sda1";
8844 device[5] = devchar;
8845 char mountpoint[] = "/";
8848 r = guestfs_mount (g, device, mountpoint);
8852 /* TestOutput for write_file (0) */
8853 char expected[] = "new file contents";
8855 char path[] = "/new";
8856 char content[] = "new file contents";
8859 r = guestfs_write_file (g, path, content, 0);
8864 char path[] = "/new";
8867 r = guestfs_cat (g, path);
8870 if (strcmp (r, expected) != 0) {
8871 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
8879 static int test_write_file_1 (void)
8881 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
8883 char device[] = "/dev/sda";
8884 device[5] = devchar;
8887 r = guestfs_blockdev_setrw (g, device);
8894 r = guestfs_umount_all (g);
8901 r = guestfs_lvm_remove_all (g);
8906 char device[] = "/dev/sda";
8907 device[5] = devchar;
8908 char lines_0[] = ",";
8915 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8920 char fstype[] = "ext2";
8921 char device[] = "/dev/sda1";
8922 device[5] = devchar;
8925 r = guestfs_mkfs (g, fstype, device);
8930 char device[] = "/dev/sda1";
8931 device[5] = devchar;
8932 char mountpoint[] = "/";
8935 r = guestfs_mount (g, device, mountpoint);
8939 /* TestOutput for write_file (1) */
8940 char expected[] = "\nnew file contents\n";
8942 char path[] = "/new";
8943 char content[] = "\nnew file contents\n";
8946 r = guestfs_write_file (g, path, content, 0);
8951 char path[] = "/new";
8954 r = guestfs_cat (g, path);
8957 if (strcmp (r, expected) != 0) {
8958 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
8966 static int test_write_file_2 (void)
8968 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
8970 char device[] = "/dev/sda";
8971 device[5] = devchar;
8974 r = guestfs_blockdev_setrw (g, device);
8981 r = guestfs_umount_all (g);
8988 r = guestfs_lvm_remove_all (g);
8993 char device[] = "/dev/sda";
8994 device[5] = devchar;
8995 char lines_0[] = ",";
9002 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9007 char fstype[] = "ext2";
9008 char device[] = "/dev/sda1";
9009 device[5] = devchar;
9012 r = guestfs_mkfs (g, fstype, device);
9017 char device[] = "/dev/sda1";
9018 device[5] = devchar;
9019 char mountpoint[] = "/";
9022 r = guestfs_mount (g, device, mountpoint);
9026 /* TestOutput for write_file (2) */
9027 char expected[] = "\n\n";
9029 char path[] = "/new";
9030 char content[] = "\n\n";
9033 r = guestfs_write_file (g, path, content, 0);
9038 char path[] = "/new";
9041 r = guestfs_cat (g, path);
9044 if (strcmp (r, expected) != 0) {
9045 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
9053 static int test_write_file_3 (void)
9055 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
9057 char device[] = "/dev/sda";
9058 device[5] = devchar;
9061 r = guestfs_blockdev_setrw (g, device);
9068 r = guestfs_umount_all (g);
9075 r = guestfs_lvm_remove_all (g);
9080 char device[] = "/dev/sda";
9081 device[5] = devchar;
9082 char lines_0[] = ",";
9089 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9094 char fstype[] = "ext2";
9095 char device[] = "/dev/sda1";
9096 device[5] = devchar;
9099 r = guestfs_mkfs (g, fstype, device);
9104 char device[] = "/dev/sda1";
9105 device[5] = devchar;
9106 char mountpoint[] = "/";
9109 r = guestfs_mount (g, device, mountpoint);
9113 /* TestOutput for write_file (3) */
9114 char expected[] = "";
9116 char path[] = "/new";
9117 char content[] = "";
9120 r = guestfs_write_file (g, path, content, 0);
9125 char path[] = "/new";
9128 r = guestfs_cat (g, path);
9131 if (strcmp (r, expected) != 0) {
9132 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
9140 static int test_write_file_4 (void)
9142 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
9144 char device[] = "/dev/sda";
9145 device[5] = devchar;
9148 r = guestfs_blockdev_setrw (g, device);
9155 r = guestfs_umount_all (g);
9162 r = guestfs_lvm_remove_all (g);
9167 char device[] = "/dev/sda";
9168 device[5] = devchar;
9169 char lines_0[] = ",";
9176 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9181 char fstype[] = "ext2";
9182 char device[] = "/dev/sda1";
9183 device[5] = devchar;
9186 r = guestfs_mkfs (g, fstype, device);
9191 char device[] = "/dev/sda1";
9192 device[5] = devchar;
9193 char mountpoint[] = "/";
9196 r = guestfs_mount (g, device, mountpoint);
9200 /* TestOutput for write_file (4) */
9201 char expected[] = "\n\n\n";
9203 char path[] = "/new";
9204 char content[] = "\n\n\n";
9207 r = guestfs_write_file (g, path, content, 0);
9212 char path[] = "/new";
9215 r = guestfs_cat (g, path);
9218 if (strcmp (r, expected) != 0) {
9219 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
9227 static int test_write_file_5 (void)
9229 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
9231 char device[] = "/dev/sda";
9232 device[5] = devchar;
9235 r = guestfs_blockdev_setrw (g, device);
9242 r = guestfs_umount_all (g);
9249 r = guestfs_lvm_remove_all (g);
9254 char device[] = "/dev/sda";
9255 device[5] = devchar;
9256 char lines_0[] = ",";
9263 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9268 char fstype[] = "ext2";
9269 char device[] = "/dev/sda1";
9270 device[5] = devchar;
9273 r = guestfs_mkfs (g, fstype, device);
9278 char device[] = "/dev/sda1";
9279 device[5] = devchar;
9280 char mountpoint[] = "/";
9283 r = guestfs_mount (g, device, mountpoint);
9287 /* TestOutput for write_file (5) */
9288 char expected[] = "\n";
9290 char path[] = "/new";
9291 char content[] = "\n";
9294 r = guestfs_write_file (g, path, content, 0);
9299 char path[] = "/new";
9302 r = guestfs_cat (g, path);
9305 if (strcmp (r, expected) != 0) {
9306 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
9314 static int test_mkfs_0 (void)
9316 /* InitNone|InitEmpty for test_mkfs_0 */
9318 char device[] = "/dev/sda";
9319 device[5] = devchar;
9322 r = guestfs_blockdev_setrw (g, device);
9329 r = guestfs_umount_all (g);
9336 r = guestfs_lvm_remove_all (g);
9340 /* TestOutput for mkfs (0) */
9341 char expected[] = "new file contents";
9343 char device[] = "/dev/sda";
9344 device[5] = devchar;
9345 char lines_0[] = ",";
9352 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9357 char fstype[] = "ext2";
9358 char device[] = "/dev/sda1";
9359 device[5] = devchar;
9362 r = guestfs_mkfs (g, fstype, device);
9367 char device[] = "/dev/sda1";
9368 device[5] = devchar;
9369 char mountpoint[] = "/";
9372 r = guestfs_mount (g, device, mountpoint);
9377 char path[] = "/new";
9378 char content[] = "new file contents";
9381 r = guestfs_write_file (g, path, content, 0);
9386 char path[] = "/new";
9389 r = guestfs_cat (g, path);
9392 if (strcmp (r, expected) != 0) {
9393 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
9401 static int test_lvcreate_0 (void)
9403 /* InitNone|InitEmpty for test_lvcreate_0 */
9405 char device[] = "/dev/sda";
9406 device[5] = devchar;
9409 r = guestfs_blockdev_setrw (g, device);
9416 r = guestfs_umount_all (g);
9423 r = guestfs_lvm_remove_all (g);
9427 /* TestOutputList for lvcreate (0) */
9429 char device[] = "/dev/sda";
9430 device[5] = devchar;
9431 char lines_0[] = ",10";
9432 char lines_1[] = ",20";
9433 char lines_2[] = ",";
9442 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9447 char device[] = "/dev/sda1";
9448 device[5] = devchar;
9451 r = guestfs_pvcreate (g, device);
9456 char device[] = "/dev/sda2";
9457 device[5] = devchar;
9460 r = guestfs_pvcreate (g, device);
9465 char device[] = "/dev/sda3";
9466 device[5] = devchar;
9469 r = guestfs_pvcreate (g, device);
9474 char volgroup[] = "VG1";
9475 char physvols_0[] = "/dev/sda1";
9476 physvols_0[5] = devchar;
9477 char physvols_1[] = "/dev/sda2";
9478 physvols_1[5] = devchar;
9479 char *physvols[] = {
9486 r = guestfs_vgcreate (g, volgroup, physvols);
9491 char volgroup[] = "VG2";
9492 char physvols_0[] = "/dev/sda3";
9493 physvols_0[5] = devchar;
9494 char *physvols[] = {
9500 r = guestfs_vgcreate (g, volgroup, physvols);
9505 char logvol[] = "LV1";
9506 char volgroup[] = "VG1";
9509 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9514 char logvol[] = "LV2";
9515 char volgroup[] = "VG1";
9518 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9523 char logvol[] = "LV3";
9524 char volgroup[] = "VG2";
9527 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9532 char logvol[] = "LV4";
9533 char volgroup[] = "VG2";
9536 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9541 char logvol[] = "LV5";
9542 char volgroup[] = "VG2";
9545 r = guestfs_lvcreate (g, logvol, volgroup, 50);
9553 r = guestfs_lvs (g);
9557 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9562 char expected[] = "/dev/VG1/LV1";
9563 if (strcmp (r[0], expected) != 0) {
9564 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9569 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9574 char expected[] = "/dev/VG1/LV2";
9575 if (strcmp (r[1], expected) != 0) {
9576 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9581 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9586 char expected[] = "/dev/VG2/LV3";
9587 if (strcmp (r[2], expected) != 0) {
9588 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9593 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9598 char expected[] = "/dev/VG2/LV4";
9599 if (strcmp (r[3], expected) != 0) {
9600 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
9605 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
9610 char expected[] = "/dev/VG2/LV5";
9611 if (strcmp (r[4], expected) != 0) {
9612 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
9617 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
9621 for (i = 0; r[i] != NULL; ++i)
9628 static int test_vgcreate_0 (void)
9630 /* InitNone|InitEmpty for test_vgcreate_0 */
9632 char device[] = "/dev/sda";
9633 device[5] = devchar;
9636 r = guestfs_blockdev_setrw (g, device);
9643 r = guestfs_umount_all (g);
9650 r = guestfs_lvm_remove_all (g);
9654 /* TestOutputList for vgcreate (0) */
9656 char device[] = "/dev/sda";
9657 device[5] = devchar;
9658 char lines_0[] = ",10";
9659 char lines_1[] = ",20";
9660 char lines_2[] = ",";
9669 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9674 char device[] = "/dev/sda1";
9675 device[5] = devchar;
9678 r = guestfs_pvcreate (g, device);
9683 char device[] = "/dev/sda2";
9684 device[5] = devchar;
9687 r = guestfs_pvcreate (g, device);
9692 char device[] = "/dev/sda3";
9693 device[5] = devchar;
9696 r = guestfs_pvcreate (g, device);
9701 char volgroup[] = "VG1";
9702 char physvols_0[] = "/dev/sda1";
9703 physvols_0[5] = devchar;
9704 char physvols_1[] = "/dev/sda2";
9705 physvols_1[5] = devchar;
9706 char *physvols[] = {
9713 r = guestfs_vgcreate (g, volgroup, physvols);
9718 char volgroup[] = "VG2";
9719 char physvols_0[] = "/dev/sda3";
9720 physvols_0[5] = devchar;
9721 char *physvols[] = {
9727 r = guestfs_vgcreate (g, volgroup, physvols);
9735 r = guestfs_vgs (g);
9739 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9744 char expected[] = "VG1";
9745 if (strcmp (r[0], expected) != 0) {
9746 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9751 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
9756 char expected[] = "VG2";
9757 if (strcmp (r[1], expected) != 0) {
9758 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9763 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
9767 for (i = 0; r[i] != NULL; ++i)
9774 static int test_pvcreate_0 (void)
9776 /* InitNone|InitEmpty for test_pvcreate_0 */
9778 char device[] = "/dev/sda";
9779 device[5] = devchar;
9782 r = guestfs_blockdev_setrw (g, device);
9789 r = guestfs_umount_all (g);
9796 r = guestfs_lvm_remove_all (g);
9800 /* TestOutputList for pvcreate (0) */
9802 char device[] = "/dev/sda";
9803 device[5] = devchar;
9804 char lines_0[] = ",10";
9805 char lines_1[] = ",20";
9806 char lines_2[] = ",";
9815 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9820 char device[] = "/dev/sda1";
9821 device[5] = devchar;
9824 r = guestfs_pvcreate (g, device);
9829 char device[] = "/dev/sda2";
9830 device[5] = devchar;
9833 r = guestfs_pvcreate (g, device);
9838 char device[] = "/dev/sda3";
9839 device[5] = devchar;
9842 r = guestfs_pvcreate (g, device);
9850 r = guestfs_pvs (g);
9854 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9859 char expected[] = "/dev/sda1";
9860 expected[5] = devchar;
9861 if (strcmp (r[0], expected) != 0) {
9862 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9867 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9872 char expected[] = "/dev/sda2";
9873 expected[5] = devchar;
9874 if (strcmp (r[1], expected) != 0) {
9875 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9880 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
9885 char expected[] = "/dev/sda3";
9886 expected[5] = devchar;
9887 if (strcmp (r[2], expected) != 0) {
9888 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
9893 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
9897 for (i = 0; r[i] != NULL; ++i)
9904 static int test_is_dir_0 (void)
9906 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
9908 char device[] = "/dev/sda";
9909 device[5] = devchar;
9912 r = guestfs_blockdev_setrw (g, device);
9919 r = guestfs_umount_all (g);
9926 r = guestfs_lvm_remove_all (g);
9931 char device[] = "/dev/sda";
9932 device[5] = devchar;
9933 char lines_0[] = ",";
9940 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9945 char fstype[] = "ext2";
9946 char device[] = "/dev/sda1";
9947 device[5] = devchar;
9950 r = guestfs_mkfs (g, fstype, device);
9955 char device[] = "/dev/sda1";
9956 device[5] = devchar;
9957 char mountpoint[] = "/";
9960 r = guestfs_mount (g, device, mountpoint);
9964 /* TestOutputFalse for is_dir (0) */
9966 char path[] = "/new";
9969 r = guestfs_touch (g, path);
9974 char path[] = "/new";
9977 r = guestfs_is_dir (g, path);
9981 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
9988 static int test_is_dir_1 (void)
9990 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
9992 char device[] = "/dev/sda";
9993 device[5] = devchar;
9996 r = guestfs_blockdev_setrw (g, device);
10002 suppress_error = 0;
10003 r = guestfs_umount_all (g);
10009 suppress_error = 0;
10010 r = guestfs_lvm_remove_all (g);
10015 char device[] = "/dev/sda";
10016 device[5] = devchar;
10017 char lines_0[] = ",";
10023 suppress_error = 0;
10024 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10029 char fstype[] = "ext2";
10030 char device[] = "/dev/sda1";
10031 device[5] = devchar;
10033 suppress_error = 0;
10034 r = guestfs_mkfs (g, fstype, device);
10039 char device[] = "/dev/sda1";
10040 device[5] = devchar;
10041 char mountpoint[] = "/";
10043 suppress_error = 0;
10044 r = guestfs_mount (g, device, mountpoint);
10048 /* TestOutputTrue for is_dir (1) */
10050 char path[] = "/new";
10052 suppress_error = 0;
10053 r = guestfs_mkdir (g, path);
10058 char path[] = "/new";
10060 suppress_error = 0;
10061 r = guestfs_is_dir (g, path);
10065 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
10072 static int test_is_file_0 (void)
10074 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
10076 char device[] = "/dev/sda";
10077 device[5] = devchar;
10079 suppress_error = 0;
10080 r = guestfs_blockdev_setrw (g, device);
10086 suppress_error = 0;
10087 r = guestfs_umount_all (g);
10093 suppress_error = 0;
10094 r = guestfs_lvm_remove_all (g);
10099 char device[] = "/dev/sda";
10100 device[5] = devchar;
10101 char lines_0[] = ",";
10107 suppress_error = 0;
10108 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10113 char fstype[] = "ext2";
10114 char device[] = "/dev/sda1";
10115 device[5] = devchar;
10117 suppress_error = 0;
10118 r = guestfs_mkfs (g, fstype, device);
10123 char device[] = "/dev/sda1";
10124 device[5] = devchar;
10125 char mountpoint[] = "/";
10127 suppress_error = 0;
10128 r = guestfs_mount (g, device, mountpoint);
10132 /* TestOutputTrue for is_file (0) */
10134 char path[] = "/new";
10136 suppress_error = 0;
10137 r = guestfs_touch (g, path);
10142 char path[] = "/new";
10144 suppress_error = 0;
10145 r = guestfs_is_file (g, path);
10149 fprintf (stderr, "test_is_file_0: expected true, got false\n");
10156 static int test_is_file_1 (void)
10158 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
10160 char device[] = "/dev/sda";
10161 device[5] = devchar;
10163 suppress_error = 0;
10164 r = guestfs_blockdev_setrw (g, device);
10170 suppress_error = 0;
10171 r = guestfs_umount_all (g);
10177 suppress_error = 0;
10178 r = guestfs_lvm_remove_all (g);
10183 char device[] = "/dev/sda";
10184 device[5] = devchar;
10185 char lines_0[] = ",";
10191 suppress_error = 0;
10192 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10197 char fstype[] = "ext2";
10198 char device[] = "/dev/sda1";
10199 device[5] = devchar;
10201 suppress_error = 0;
10202 r = guestfs_mkfs (g, fstype, device);
10207 char device[] = "/dev/sda1";
10208 device[5] = devchar;
10209 char mountpoint[] = "/";
10211 suppress_error = 0;
10212 r = guestfs_mount (g, device, mountpoint);
10216 /* TestOutputFalse for is_file (1) */
10218 char path[] = "/new";
10220 suppress_error = 0;
10221 r = guestfs_mkdir (g, path);
10226 char path[] = "/new";
10228 suppress_error = 0;
10229 r = guestfs_is_file (g, path);
10233 fprintf (stderr, "test_is_file_1: expected false, got true\n");
10240 static int test_exists_0 (void)
10242 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
10244 char device[] = "/dev/sda";
10245 device[5] = devchar;
10247 suppress_error = 0;
10248 r = guestfs_blockdev_setrw (g, device);
10254 suppress_error = 0;
10255 r = guestfs_umount_all (g);
10261 suppress_error = 0;
10262 r = guestfs_lvm_remove_all (g);
10267 char device[] = "/dev/sda";
10268 device[5] = devchar;
10269 char lines_0[] = ",";
10275 suppress_error = 0;
10276 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10281 char fstype[] = "ext2";
10282 char device[] = "/dev/sda1";
10283 device[5] = devchar;
10285 suppress_error = 0;
10286 r = guestfs_mkfs (g, fstype, device);
10291 char device[] = "/dev/sda1";
10292 device[5] = devchar;
10293 char mountpoint[] = "/";
10295 suppress_error = 0;
10296 r = guestfs_mount (g, device, mountpoint);
10300 /* TestOutputTrue for exists (0) */
10302 char path[] = "/new";
10304 suppress_error = 0;
10305 r = guestfs_touch (g, path);
10310 char path[] = "/new";
10312 suppress_error = 0;
10313 r = guestfs_exists (g, path);
10317 fprintf (stderr, "test_exists_0: expected true, got false\n");
10324 static int test_exists_1 (void)
10326 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
10328 char device[] = "/dev/sda";
10329 device[5] = devchar;
10331 suppress_error = 0;
10332 r = guestfs_blockdev_setrw (g, device);
10338 suppress_error = 0;
10339 r = guestfs_umount_all (g);
10345 suppress_error = 0;
10346 r = guestfs_lvm_remove_all (g);
10351 char device[] = "/dev/sda";
10352 device[5] = devchar;
10353 char lines_0[] = ",";
10359 suppress_error = 0;
10360 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10365 char fstype[] = "ext2";
10366 char device[] = "/dev/sda1";
10367 device[5] = devchar;
10369 suppress_error = 0;
10370 r = guestfs_mkfs (g, fstype, device);
10375 char device[] = "/dev/sda1";
10376 device[5] = devchar;
10377 char mountpoint[] = "/";
10379 suppress_error = 0;
10380 r = guestfs_mount (g, device, mountpoint);
10384 /* TestOutputTrue for exists (1) */
10386 char path[] = "/new";
10388 suppress_error = 0;
10389 r = guestfs_mkdir (g, path);
10394 char path[] = "/new";
10396 suppress_error = 0;
10397 r = guestfs_exists (g, path);
10401 fprintf (stderr, "test_exists_1: expected true, got false\n");
10408 static int test_mkdir_p_0 (void)
10410 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
10412 char device[] = "/dev/sda";
10413 device[5] = devchar;
10415 suppress_error = 0;
10416 r = guestfs_blockdev_setrw (g, device);
10422 suppress_error = 0;
10423 r = guestfs_umount_all (g);
10429 suppress_error = 0;
10430 r = guestfs_lvm_remove_all (g);
10435 char device[] = "/dev/sda";
10436 device[5] = devchar;
10437 char lines_0[] = ",";
10443 suppress_error = 0;
10444 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10449 char fstype[] = "ext2";
10450 char device[] = "/dev/sda1";
10451 device[5] = devchar;
10453 suppress_error = 0;
10454 r = guestfs_mkfs (g, fstype, device);
10459 char device[] = "/dev/sda1";
10460 device[5] = devchar;
10461 char mountpoint[] = "/";
10463 suppress_error = 0;
10464 r = guestfs_mount (g, device, mountpoint);
10468 /* TestOutputTrue for mkdir_p (0) */
10470 char path[] = "/new/foo/bar";
10472 suppress_error = 0;
10473 r = guestfs_mkdir_p (g, path);
10478 char path[] = "/new/foo/bar";
10480 suppress_error = 0;
10481 r = guestfs_is_dir (g, path);
10485 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
10492 static int test_mkdir_p_1 (void)
10494 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
10496 char device[] = "/dev/sda";
10497 device[5] = devchar;
10499 suppress_error = 0;
10500 r = guestfs_blockdev_setrw (g, device);
10506 suppress_error = 0;
10507 r = guestfs_umount_all (g);
10513 suppress_error = 0;
10514 r = guestfs_lvm_remove_all (g);
10519 char device[] = "/dev/sda";
10520 device[5] = devchar;
10521 char lines_0[] = ",";
10527 suppress_error = 0;
10528 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10533 char fstype[] = "ext2";
10534 char device[] = "/dev/sda1";
10535 device[5] = devchar;
10537 suppress_error = 0;
10538 r = guestfs_mkfs (g, fstype, device);
10543 char device[] = "/dev/sda1";
10544 device[5] = devchar;
10545 char mountpoint[] = "/";
10547 suppress_error = 0;
10548 r = guestfs_mount (g, device, mountpoint);
10552 /* TestOutputTrue for mkdir_p (1) */
10554 char path[] = "/new/foo/bar";
10556 suppress_error = 0;
10557 r = guestfs_mkdir_p (g, path);
10562 char path[] = "/new/foo";
10564 suppress_error = 0;
10565 r = guestfs_is_dir (g, path);
10569 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
10576 static int test_mkdir_p_2 (void)
10578 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
10580 char device[] = "/dev/sda";
10581 device[5] = devchar;
10583 suppress_error = 0;
10584 r = guestfs_blockdev_setrw (g, device);
10590 suppress_error = 0;
10591 r = guestfs_umount_all (g);
10597 suppress_error = 0;
10598 r = guestfs_lvm_remove_all (g);
10603 char device[] = "/dev/sda";
10604 device[5] = devchar;
10605 char lines_0[] = ",";
10611 suppress_error = 0;
10612 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10617 char fstype[] = "ext2";
10618 char device[] = "/dev/sda1";
10619 device[5] = devchar;
10621 suppress_error = 0;
10622 r = guestfs_mkfs (g, fstype, device);
10627 char device[] = "/dev/sda1";
10628 device[5] = devchar;
10629 char mountpoint[] = "/";
10631 suppress_error = 0;
10632 r = guestfs_mount (g, device, mountpoint);
10636 /* TestOutputTrue for mkdir_p (2) */
10638 char path[] = "/new/foo/bar";
10640 suppress_error = 0;
10641 r = guestfs_mkdir_p (g, path);
10646 char path[] = "/new";
10648 suppress_error = 0;
10649 r = guestfs_is_dir (g, path);
10653 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
10660 static int test_mkdir_0 (void)
10662 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
10664 char device[] = "/dev/sda";
10665 device[5] = devchar;
10667 suppress_error = 0;
10668 r = guestfs_blockdev_setrw (g, device);
10674 suppress_error = 0;
10675 r = guestfs_umount_all (g);
10681 suppress_error = 0;
10682 r = guestfs_lvm_remove_all (g);
10687 char device[] = "/dev/sda";
10688 device[5] = devchar;
10689 char lines_0[] = ",";
10695 suppress_error = 0;
10696 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10701 char fstype[] = "ext2";
10702 char device[] = "/dev/sda1";
10703 device[5] = devchar;
10705 suppress_error = 0;
10706 r = guestfs_mkfs (g, fstype, device);
10711 char device[] = "/dev/sda1";
10712 device[5] = devchar;
10713 char mountpoint[] = "/";
10715 suppress_error = 0;
10716 r = guestfs_mount (g, device, mountpoint);
10720 /* TestOutputTrue for mkdir (0) */
10722 char path[] = "/new";
10724 suppress_error = 0;
10725 r = guestfs_mkdir (g, path);
10730 char path[] = "/new";
10732 suppress_error = 0;
10733 r = guestfs_is_dir (g, path);
10737 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
10744 static int test_mkdir_1 (void)
10746 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
10748 char device[] = "/dev/sda";
10749 device[5] = devchar;
10751 suppress_error = 0;
10752 r = guestfs_blockdev_setrw (g, device);
10758 suppress_error = 0;
10759 r = guestfs_umount_all (g);
10765 suppress_error = 0;
10766 r = guestfs_lvm_remove_all (g);
10771 char device[] = "/dev/sda";
10772 device[5] = devchar;
10773 char lines_0[] = ",";
10779 suppress_error = 0;
10780 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10785 char fstype[] = "ext2";
10786 char device[] = "/dev/sda1";
10787 device[5] = devchar;
10789 suppress_error = 0;
10790 r = guestfs_mkfs (g, fstype, device);
10795 char device[] = "/dev/sda1";
10796 device[5] = devchar;
10797 char mountpoint[] = "/";
10799 suppress_error = 0;
10800 r = guestfs_mount (g, device, mountpoint);
10804 /* TestLastFail for mkdir (1) */
10806 char path[] = "/new/foo/bar";
10808 suppress_error = 1;
10809 r = guestfs_mkdir (g, path);
10816 static int test_rm_rf_0 (void)
10818 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
10820 char device[] = "/dev/sda";
10821 device[5] = devchar;
10823 suppress_error = 0;
10824 r = guestfs_blockdev_setrw (g, device);
10830 suppress_error = 0;
10831 r = guestfs_umount_all (g);
10837 suppress_error = 0;
10838 r = guestfs_lvm_remove_all (g);
10843 char device[] = "/dev/sda";
10844 device[5] = devchar;
10845 char lines_0[] = ",";
10851 suppress_error = 0;
10852 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10857 char fstype[] = "ext2";
10858 char device[] = "/dev/sda1";
10859 device[5] = devchar;
10861 suppress_error = 0;
10862 r = guestfs_mkfs (g, fstype, device);
10867 char device[] = "/dev/sda1";
10868 device[5] = devchar;
10869 char mountpoint[] = "/";
10871 suppress_error = 0;
10872 r = guestfs_mount (g, device, mountpoint);
10876 /* TestOutputFalse for rm_rf (0) */
10878 char path[] = "/new";
10880 suppress_error = 0;
10881 r = guestfs_mkdir (g, path);
10886 char path[] = "/new/foo";
10888 suppress_error = 0;
10889 r = guestfs_mkdir (g, path);
10894 char path[] = "/new/foo/bar";
10896 suppress_error = 0;
10897 r = guestfs_touch (g, path);
10902 char path[] = "/new";
10904 suppress_error = 0;
10905 r = guestfs_rm_rf (g, path);
10910 char path[] = "/new";
10912 suppress_error = 0;
10913 r = guestfs_exists (g, path);
10917 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
10924 static int test_rmdir_0 (void)
10926 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
10928 char device[] = "/dev/sda";
10929 device[5] = devchar;
10931 suppress_error = 0;
10932 r = guestfs_blockdev_setrw (g, device);
10938 suppress_error = 0;
10939 r = guestfs_umount_all (g);
10945 suppress_error = 0;
10946 r = guestfs_lvm_remove_all (g);
10951 char device[] = "/dev/sda";
10952 device[5] = devchar;
10953 char lines_0[] = ",";
10959 suppress_error = 0;
10960 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10965 char fstype[] = "ext2";
10966 char device[] = "/dev/sda1";
10967 device[5] = devchar;
10969 suppress_error = 0;
10970 r = guestfs_mkfs (g, fstype, device);
10975 char device[] = "/dev/sda1";
10976 device[5] = devchar;
10977 char mountpoint[] = "/";
10979 suppress_error = 0;
10980 r = guestfs_mount (g, device, mountpoint);
10984 /* TestRun for rmdir (0) */
10986 char path[] = "/new";
10988 suppress_error = 0;
10989 r = guestfs_mkdir (g, path);
10994 char path[] = "/new";
10996 suppress_error = 0;
10997 r = guestfs_rmdir (g, path);
11004 static int test_rmdir_1 (void)
11006 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
11008 char device[] = "/dev/sda";
11009 device[5] = devchar;
11011 suppress_error = 0;
11012 r = guestfs_blockdev_setrw (g, device);
11018 suppress_error = 0;
11019 r = guestfs_umount_all (g);
11025 suppress_error = 0;
11026 r = guestfs_lvm_remove_all (g);
11031 char device[] = "/dev/sda";
11032 device[5] = devchar;
11033 char lines_0[] = ",";
11039 suppress_error = 0;
11040 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11045 char fstype[] = "ext2";
11046 char device[] = "/dev/sda1";
11047 device[5] = devchar;
11049 suppress_error = 0;
11050 r = guestfs_mkfs (g, fstype, device);
11055 char device[] = "/dev/sda1";
11056 device[5] = devchar;
11057 char mountpoint[] = "/";
11059 suppress_error = 0;
11060 r = guestfs_mount (g, device, mountpoint);
11064 /* TestLastFail for rmdir (1) */
11066 char path[] = "/new";
11068 suppress_error = 1;
11069 r = guestfs_rmdir (g, path);
11076 static int test_rmdir_2 (void)
11078 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
11080 char device[] = "/dev/sda";
11081 device[5] = devchar;
11083 suppress_error = 0;
11084 r = guestfs_blockdev_setrw (g, device);
11090 suppress_error = 0;
11091 r = guestfs_umount_all (g);
11097 suppress_error = 0;
11098 r = guestfs_lvm_remove_all (g);
11103 char device[] = "/dev/sda";
11104 device[5] = devchar;
11105 char lines_0[] = ",";
11111 suppress_error = 0;
11112 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11117 char fstype[] = "ext2";
11118 char device[] = "/dev/sda1";
11119 device[5] = devchar;
11121 suppress_error = 0;
11122 r = guestfs_mkfs (g, fstype, device);
11127 char device[] = "/dev/sda1";
11128 device[5] = devchar;
11129 char mountpoint[] = "/";
11131 suppress_error = 0;
11132 r = guestfs_mount (g, device, mountpoint);
11136 /* TestLastFail for rmdir (2) */
11138 char path[] = "/new";
11140 suppress_error = 0;
11141 r = guestfs_touch (g, path);
11146 char path[] = "/new";
11148 suppress_error = 1;
11149 r = guestfs_rmdir (g, path);
11156 static int test_rm_0 (void)
11158 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
11160 char device[] = "/dev/sda";
11161 device[5] = devchar;
11163 suppress_error = 0;
11164 r = guestfs_blockdev_setrw (g, device);
11170 suppress_error = 0;
11171 r = guestfs_umount_all (g);
11177 suppress_error = 0;
11178 r = guestfs_lvm_remove_all (g);
11183 char device[] = "/dev/sda";
11184 device[5] = devchar;
11185 char lines_0[] = ",";
11191 suppress_error = 0;
11192 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11197 char fstype[] = "ext2";
11198 char device[] = "/dev/sda1";
11199 device[5] = devchar;
11201 suppress_error = 0;
11202 r = guestfs_mkfs (g, fstype, device);
11207 char device[] = "/dev/sda1";
11208 device[5] = devchar;
11209 char mountpoint[] = "/";
11211 suppress_error = 0;
11212 r = guestfs_mount (g, device, mountpoint);
11216 /* TestRun for rm (0) */
11218 char path[] = "/new";
11220 suppress_error = 0;
11221 r = guestfs_touch (g, path);
11226 char path[] = "/new";
11228 suppress_error = 0;
11229 r = guestfs_rm (g, path);
11236 static int test_rm_1 (void)
11238 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
11240 char device[] = "/dev/sda";
11241 device[5] = devchar;
11243 suppress_error = 0;
11244 r = guestfs_blockdev_setrw (g, device);
11250 suppress_error = 0;
11251 r = guestfs_umount_all (g);
11257 suppress_error = 0;
11258 r = guestfs_lvm_remove_all (g);
11263 char device[] = "/dev/sda";
11264 device[5] = devchar;
11265 char lines_0[] = ",";
11271 suppress_error = 0;
11272 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11277 char fstype[] = "ext2";
11278 char device[] = "/dev/sda1";
11279 device[5] = devchar;
11281 suppress_error = 0;
11282 r = guestfs_mkfs (g, fstype, device);
11287 char device[] = "/dev/sda1";
11288 device[5] = devchar;
11289 char mountpoint[] = "/";
11291 suppress_error = 0;
11292 r = guestfs_mount (g, device, mountpoint);
11296 /* TestLastFail for rm (1) */
11298 char path[] = "/new";
11300 suppress_error = 1;
11301 r = guestfs_rm (g, path);
11308 static int test_rm_2 (void)
11310 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
11312 char device[] = "/dev/sda";
11313 device[5] = devchar;
11315 suppress_error = 0;
11316 r = guestfs_blockdev_setrw (g, device);
11322 suppress_error = 0;
11323 r = guestfs_umount_all (g);
11329 suppress_error = 0;
11330 r = guestfs_lvm_remove_all (g);
11335 char device[] = "/dev/sda";
11336 device[5] = devchar;
11337 char lines_0[] = ",";
11343 suppress_error = 0;
11344 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11349 char fstype[] = "ext2";
11350 char device[] = "/dev/sda1";
11351 device[5] = devchar;
11353 suppress_error = 0;
11354 r = guestfs_mkfs (g, fstype, device);
11359 char device[] = "/dev/sda1";
11360 device[5] = devchar;
11361 char mountpoint[] = "/";
11363 suppress_error = 0;
11364 r = guestfs_mount (g, device, mountpoint);
11368 /* TestLastFail for rm (2) */
11370 char path[] = "/new";
11372 suppress_error = 0;
11373 r = guestfs_mkdir (g, path);
11378 char path[] = "/new";
11380 suppress_error = 1;
11381 r = guestfs_rm (g, path);
11388 static int test_read_lines_0 (void)
11390 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
11392 char device[] = "/dev/sda";
11393 device[5] = devchar;
11395 suppress_error = 0;
11396 r = guestfs_blockdev_setrw (g, device);
11402 suppress_error = 0;
11403 r = guestfs_umount_all (g);
11409 suppress_error = 0;
11410 r = guestfs_lvm_remove_all (g);
11415 char device[] = "/dev/sda";
11416 device[5] = devchar;
11417 char lines_0[] = ",";
11423 suppress_error = 0;
11424 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11429 char fstype[] = "ext2";
11430 char device[] = "/dev/sda1";
11431 device[5] = devchar;
11433 suppress_error = 0;
11434 r = guestfs_mkfs (g, fstype, device);
11439 char device[] = "/dev/sda1";
11440 device[5] = devchar;
11441 char mountpoint[] = "/";
11443 suppress_error = 0;
11444 r = guestfs_mount (g, device, mountpoint);
11448 /* TestOutputList for read_lines (0) */
11450 char path[] = "/new";
11451 char content[] = "line1\r\nline2\nline3";
11453 suppress_error = 0;
11454 r = guestfs_write_file (g, path, content, 0);
11459 char path[] = "/new";
11462 suppress_error = 0;
11463 r = guestfs_read_lines (g, path);
11467 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11472 char expected[] = "line1";
11473 if (strcmp (r[0], expected) != 0) {
11474 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11479 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11484 char expected[] = "line2";
11485 if (strcmp (r[1], expected) != 0) {
11486 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11491 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
11496 char expected[] = "line3";
11497 if (strcmp (r[2], expected) != 0) {
11498 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11502 if (r[3] != NULL) {
11503 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
11507 for (i = 0; r[i] != NULL; ++i)
11514 static int test_read_lines_1 (void)
11516 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
11518 char device[] = "/dev/sda";
11519 device[5] = devchar;
11521 suppress_error = 0;
11522 r = guestfs_blockdev_setrw (g, device);
11528 suppress_error = 0;
11529 r = guestfs_umount_all (g);
11535 suppress_error = 0;
11536 r = guestfs_lvm_remove_all (g);
11541 char device[] = "/dev/sda";
11542 device[5] = devchar;
11543 char lines_0[] = ",";
11549 suppress_error = 0;
11550 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11555 char fstype[] = "ext2";
11556 char device[] = "/dev/sda1";
11557 device[5] = devchar;
11559 suppress_error = 0;
11560 r = guestfs_mkfs (g, fstype, device);
11565 char device[] = "/dev/sda1";
11566 device[5] = devchar;
11567 char mountpoint[] = "/";
11569 suppress_error = 0;
11570 r = guestfs_mount (g, device, mountpoint);
11574 /* TestOutputList for read_lines (1) */
11576 char path[] = "/new";
11577 char content[] = "";
11579 suppress_error = 0;
11580 r = guestfs_write_file (g, path, content, 0);
11585 char path[] = "/new";
11588 suppress_error = 0;
11589 r = guestfs_read_lines (g, path);
11592 if (r[0] != NULL) {
11593 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
11597 for (i = 0; r[i] != NULL; ++i)
11604 static int test_lvs_0 (void)
11606 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
11608 char device[] = "/dev/sda";
11609 device[5] = devchar;
11611 suppress_error = 0;
11612 r = guestfs_blockdev_setrw (g, device);
11618 suppress_error = 0;
11619 r = guestfs_umount_all (g);
11625 suppress_error = 0;
11626 r = guestfs_lvm_remove_all (g);
11631 char device[] = "/dev/sda";
11632 device[5] = devchar;
11633 char lines_0[] = ",";
11639 suppress_error = 0;
11640 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11645 char device[] = "/dev/sda1";
11646 device[5] = devchar;
11648 suppress_error = 0;
11649 r = guestfs_pvcreate (g, device);
11654 char volgroup[] = "VG";
11655 char physvols_0[] = "/dev/sda1";
11656 physvols_0[5] = devchar;
11657 char *physvols[] = {
11662 suppress_error = 0;
11663 r = guestfs_vgcreate (g, volgroup, physvols);
11668 char logvol[] = "LV";
11669 char volgroup[] = "VG";
11671 suppress_error = 0;
11672 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11677 char fstype[] = "ext2";
11678 char device[] = "/dev/VG/LV";
11680 suppress_error = 0;
11681 r = guestfs_mkfs (g, fstype, device);
11686 char device[] = "/dev/VG/LV";
11687 char mountpoint[] = "/";
11689 suppress_error = 0;
11690 r = guestfs_mount (g, device, mountpoint);
11694 /* TestOutputList for lvs (0) */
11698 suppress_error = 0;
11699 r = guestfs_lvs (g);
11703 fprintf (stderr, "test_lvs_0: short list returned from command\n");
11708 char expected[] = "/dev/VG/LV";
11709 if (strcmp (r[0], expected) != 0) {
11710 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11714 if (r[1] != NULL) {
11715 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
11719 for (i = 0; r[i] != NULL; ++i)
11726 static int test_lvs_1 (void)
11728 /* InitNone|InitEmpty for test_lvs_1 */
11730 char device[] = "/dev/sda";
11731 device[5] = devchar;
11733 suppress_error = 0;
11734 r = guestfs_blockdev_setrw (g, device);
11740 suppress_error = 0;
11741 r = guestfs_umount_all (g);
11747 suppress_error = 0;
11748 r = guestfs_lvm_remove_all (g);
11752 /* TestOutputList for lvs (1) */
11754 char device[] = "/dev/sda";
11755 device[5] = devchar;
11756 char lines_0[] = ",10";
11757 char lines_1[] = ",20";
11758 char lines_2[] = ",";
11766 suppress_error = 0;
11767 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11772 char device[] = "/dev/sda1";
11773 device[5] = devchar;
11775 suppress_error = 0;
11776 r = guestfs_pvcreate (g, device);
11781 char device[] = "/dev/sda2";
11782 device[5] = devchar;
11784 suppress_error = 0;
11785 r = guestfs_pvcreate (g, device);
11790 char device[] = "/dev/sda3";
11791 device[5] = devchar;
11793 suppress_error = 0;
11794 r = guestfs_pvcreate (g, device);
11799 char volgroup[] = "VG1";
11800 char physvols_0[] = "/dev/sda1";
11801 physvols_0[5] = devchar;
11802 char physvols_1[] = "/dev/sda2";
11803 physvols_1[5] = devchar;
11804 char *physvols[] = {
11810 suppress_error = 0;
11811 r = guestfs_vgcreate (g, volgroup, physvols);
11816 char volgroup[] = "VG2";
11817 char physvols_0[] = "/dev/sda3";
11818 physvols_0[5] = devchar;
11819 char *physvols[] = {
11824 suppress_error = 0;
11825 r = guestfs_vgcreate (g, volgroup, physvols);
11830 char logvol[] = "LV1";
11831 char volgroup[] = "VG1";
11833 suppress_error = 0;
11834 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11839 char logvol[] = "LV2";
11840 char volgroup[] = "VG1";
11842 suppress_error = 0;
11843 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11848 char logvol[] = "LV3";
11849 char volgroup[] = "VG2";
11851 suppress_error = 0;
11852 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11859 suppress_error = 0;
11860 r = guestfs_lvs (g);
11864 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11869 char expected[] = "/dev/VG1/LV1";
11870 if (strcmp (r[0], expected) != 0) {
11871 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11876 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11881 char expected[] = "/dev/VG1/LV2";
11882 if (strcmp (r[1], expected) != 0) {
11883 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11888 fprintf (stderr, "test_lvs_1: short list returned from command\n");
11893 char expected[] = "/dev/VG2/LV3";
11894 if (strcmp (r[2], expected) != 0) {
11895 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11899 if (r[3] != NULL) {
11900 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
11904 for (i = 0; r[i] != NULL; ++i)
11911 static int test_vgs_0 (void)
11913 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
11915 char device[] = "/dev/sda";
11916 device[5] = devchar;
11918 suppress_error = 0;
11919 r = guestfs_blockdev_setrw (g, device);
11925 suppress_error = 0;
11926 r = guestfs_umount_all (g);
11932 suppress_error = 0;
11933 r = guestfs_lvm_remove_all (g);
11938 char device[] = "/dev/sda";
11939 device[5] = devchar;
11940 char lines_0[] = ",";
11946 suppress_error = 0;
11947 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11952 char device[] = "/dev/sda1";
11953 device[5] = devchar;
11955 suppress_error = 0;
11956 r = guestfs_pvcreate (g, device);
11961 char volgroup[] = "VG";
11962 char physvols_0[] = "/dev/sda1";
11963 physvols_0[5] = devchar;
11964 char *physvols[] = {
11969 suppress_error = 0;
11970 r = guestfs_vgcreate (g, volgroup, physvols);
11975 char logvol[] = "LV";
11976 char volgroup[] = "VG";
11978 suppress_error = 0;
11979 r = guestfs_lvcreate (g, logvol, volgroup, 8);
11984 char fstype[] = "ext2";
11985 char device[] = "/dev/VG/LV";
11987 suppress_error = 0;
11988 r = guestfs_mkfs (g, fstype, device);
11993 char device[] = "/dev/VG/LV";
11994 char mountpoint[] = "/";
11996 suppress_error = 0;
11997 r = guestfs_mount (g, device, mountpoint);
12001 /* TestOutputList for vgs (0) */
12005 suppress_error = 0;
12006 r = guestfs_vgs (g);
12010 fprintf (stderr, "test_vgs_0: short list returned from command\n");
12015 char expected[] = "VG";
12016 if (strcmp (r[0], expected) != 0) {
12017 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12021 if (r[1] != NULL) {
12022 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
12026 for (i = 0; r[i] != NULL; ++i)
12033 static int test_vgs_1 (void)
12035 /* InitNone|InitEmpty for test_vgs_1 */
12037 char device[] = "/dev/sda";
12038 device[5] = devchar;
12040 suppress_error = 0;
12041 r = guestfs_blockdev_setrw (g, device);
12047 suppress_error = 0;
12048 r = guestfs_umount_all (g);
12054 suppress_error = 0;
12055 r = guestfs_lvm_remove_all (g);
12059 /* TestOutputList for vgs (1) */
12061 char device[] = "/dev/sda";
12062 device[5] = devchar;
12063 char lines_0[] = ",10";
12064 char lines_1[] = ",20";
12065 char lines_2[] = ",";
12073 suppress_error = 0;
12074 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12079 char device[] = "/dev/sda1";
12080 device[5] = devchar;
12082 suppress_error = 0;
12083 r = guestfs_pvcreate (g, device);
12088 char device[] = "/dev/sda2";
12089 device[5] = devchar;
12091 suppress_error = 0;
12092 r = guestfs_pvcreate (g, device);
12097 char device[] = "/dev/sda3";
12098 device[5] = devchar;
12100 suppress_error = 0;
12101 r = guestfs_pvcreate (g, device);
12106 char volgroup[] = "VG1";
12107 char physvols_0[] = "/dev/sda1";
12108 physvols_0[5] = devchar;
12109 char physvols_1[] = "/dev/sda2";
12110 physvols_1[5] = devchar;
12111 char *physvols[] = {
12117 suppress_error = 0;
12118 r = guestfs_vgcreate (g, volgroup, physvols);
12123 char volgroup[] = "VG2";
12124 char physvols_0[] = "/dev/sda3";
12125 physvols_0[5] = devchar;
12126 char *physvols[] = {
12131 suppress_error = 0;
12132 r = guestfs_vgcreate (g, volgroup, physvols);
12139 suppress_error = 0;
12140 r = guestfs_vgs (g);
12144 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12149 char expected[] = "VG1";
12150 if (strcmp (r[0], expected) != 0) {
12151 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12156 fprintf (stderr, "test_vgs_1: short list returned from command\n");
12161 char expected[] = "VG2";
12162 if (strcmp (r[1], expected) != 0) {
12163 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12167 if (r[2] != NULL) {
12168 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
12172 for (i = 0; r[i] != NULL; ++i)
12179 static int test_pvs_0 (void)
12181 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
12183 char device[] = "/dev/sda";
12184 device[5] = devchar;
12186 suppress_error = 0;
12187 r = guestfs_blockdev_setrw (g, device);
12193 suppress_error = 0;
12194 r = guestfs_umount_all (g);
12200 suppress_error = 0;
12201 r = guestfs_lvm_remove_all (g);
12206 char device[] = "/dev/sda";
12207 device[5] = devchar;
12208 char lines_0[] = ",";
12214 suppress_error = 0;
12215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12220 char device[] = "/dev/sda1";
12221 device[5] = devchar;
12223 suppress_error = 0;
12224 r = guestfs_pvcreate (g, device);
12229 char volgroup[] = "VG";
12230 char physvols_0[] = "/dev/sda1";
12231 physvols_0[5] = devchar;
12232 char *physvols[] = {
12237 suppress_error = 0;
12238 r = guestfs_vgcreate (g, volgroup, physvols);
12243 char logvol[] = "LV";
12244 char volgroup[] = "VG";
12246 suppress_error = 0;
12247 r = guestfs_lvcreate (g, logvol, volgroup, 8);
12252 char fstype[] = "ext2";
12253 char device[] = "/dev/VG/LV";
12255 suppress_error = 0;
12256 r = guestfs_mkfs (g, fstype, device);
12261 char device[] = "/dev/VG/LV";
12262 char mountpoint[] = "/";
12264 suppress_error = 0;
12265 r = guestfs_mount (g, device, mountpoint);
12269 /* TestOutputList for pvs (0) */
12273 suppress_error = 0;
12274 r = guestfs_pvs (g);
12278 fprintf (stderr, "test_pvs_0: short list returned from command\n");
12283 char expected[] = "/dev/sda1";
12284 expected[5] = devchar;
12285 if (strcmp (r[0], expected) != 0) {
12286 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12290 if (r[1] != NULL) {
12291 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
12295 for (i = 0; r[i] != NULL; ++i)
12302 static int test_pvs_1 (void)
12304 /* InitNone|InitEmpty for test_pvs_1 */
12306 char device[] = "/dev/sda";
12307 device[5] = devchar;
12309 suppress_error = 0;
12310 r = guestfs_blockdev_setrw (g, device);
12316 suppress_error = 0;
12317 r = guestfs_umount_all (g);
12323 suppress_error = 0;
12324 r = guestfs_lvm_remove_all (g);
12328 /* TestOutputList for pvs (1) */
12330 char device[] = "/dev/sda";
12331 device[5] = devchar;
12332 char lines_0[] = ",10";
12333 char lines_1[] = ",20";
12334 char lines_2[] = ",";
12342 suppress_error = 0;
12343 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12348 char device[] = "/dev/sda1";
12349 device[5] = devchar;
12351 suppress_error = 0;
12352 r = guestfs_pvcreate (g, device);
12357 char device[] = "/dev/sda2";
12358 device[5] = devchar;
12360 suppress_error = 0;
12361 r = guestfs_pvcreate (g, device);
12366 char device[] = "/dev/sda3";
12367 device[5] = devchar;
12369 suppress_error = 0;
12370 r = guestfs_pvcreate (g, device);
12377 suppress_error = 0;
12378 r = guestfs_pvs (g);
12382 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12387 char expected[] = "/dev/sda1";
12388 expected[5] = devchar;
12389 if (strcmp (r[0], expected) != 0) {
12390 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12395 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12400 char expected[] = "/dev/sda2";
12401 expected[5] = devchar;
12402 if (strcmp (r[1], expected) != 0) {
12403 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12408 fprintf (stderr, "test_pvs_1: short list returned from command\n");
12413 char expected[] = "/dev/sda3";
12414 expected[5] = devchar;
12415 if (strcmp (r[2], expected) != 0) {
12416 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12420 if (r[3] != NULL) {
12421 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
12425 for (i = 0; r[i] != NULL; ++i)
12432 static int test_list_partitions_0 (void)
12434 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
12436 char device[] = "/dev/sda";
12437 device[5] = devchar;
12439 suppress_error = 0;
12440 r = guestfs_blockdev_setrw (g, device);
12446 suppress_error = 0;
12447 r = guestfs_umount_all (g);
12453 suppress_error = 0;
12454 r = guestfs_lvm_remove_all (g);
12459 char device[] = "/dev/sda";
12460 device[5] = devchar;
12461 char lines_0[] = ",";
12467 suppress_error = 0;
12468 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12473 char fstype[] = "ext2";
12474 char device[] = "/dev/sda1";
12475 device[5] = devchar;
12477 suppress_error = 0;
12478 r = guestfs_mkfs (g, fstype, device);
12483 char device[] = "/dev/sda1";
12484 device[5] = devchar;
12485 char mountpoint[] = "/";
12487 suppress_error = 0;
12488 r = guestfs_mount (g, device, mountpoint);
12492 /* TestOutputList for list_partitions (0) */
12496 suppress_error = 0;
12497 r = guestfs_list_partitions (g);
12501 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
12506 char expected[] = "/dev/sda1";
12507 expected[5] = devchar;
12508 if (strcmp (r[0], expected) != 0) {
12509 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12513 if (r[1] != NULL) {
12514 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
12518 for (i = 0; r[i] != NULL; ++i)
12525 static int test_list_partitions_1 (void)
12527 /* InitNone|InitEmpty for test_list_partitions_1 */
12529 char device[] = "/dev/sda";
12530 device[5] = devchar;
12532 suppress_error = 0;
12533 r = guestfs_blockdev_setrw (g, device);
12539 suppress_error = 0;
12540 r = guestfs_umount_all (g);
12546 suppress_error = 0;
12547 r = guestfs_lvm_remove_all (g);
12551 /* TestOutputList for list_partitions (1) */
12553 char device[] = "/dev/sda";
12554 device[5] = devchar;
12555 char lines_0[] = ",10";
12556 char lines_1[] = ",20";
12557 char lines_2[] = ",";
12565 suppress_error = 0;
12566 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12573 suppress_error = 0;
12574 r = guestfs_list_partitions (g);
12578 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12583 char expected[] = "/dev/sda1";
12584 expected[5] = devchar;
12585 if (strcmp (r[0], expected) != 0) {
12586 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12591 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12596 char expected[] = "/dev/sda2";
12597 expected[5] = devchar;
12598 if (strcmp (r[1], expected) != 0) {
12599 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12604 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
12609 char expected[] = "/dev/sda3";
12610 expected[5] = devchar;
12611 if (strcmp (r[2], expected) != 0) {
12612 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12616 if (r[3] != NULL) {
12617 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
12621 for (i = 0; r[i] != NULL; ++i)
12628 static int test_list_devices_0 (void)
12630 /* InitNone|InitEmpty for test_list_devices_0 */
12632 char device[] = "/dev/sda";
12633 device[5] = devchar;
12635 suppress_error = 0;
12636 r = guestfs_blockdev_setrw (g, device);
12642 suppress_error = 0;
12643 r = guestfs_umount_all (g);
12649 suppress_error = 0;
12650 r = guestfs_lvm_remove_all (g);
12654 /* TestOutputList for list_devices (0) */
12658 suppress_error = 0;
12659 r = guestfs_list_devices (g);
12663 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12668 char expected[] = "/dev/sda";
12669 expected[5] = devchar;
12670 if (strcmp (r[0], expected) != 0) {
12671 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12676 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12681 char expected[] = "/dev/sdb";
12682 expected[5] = devchar;
12683 if (strcmp (r[1], expected) != 0) {
12684 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12689 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
12694 char expected[] = "/dev/sdc";
12695 expected[5] = devchar;
12696 if (strcmp (r[2], expected) != 0) {
12697 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12701 if (r[3] != NULL) {
12702 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
12706 for (i = 0; r[i] != NULL; ++i)
12713 static int test_ls_0 (void)
12715 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
12717 char device[] = "/dev/sda";
12718 device[5] = devchar;
12720 suppress_error = 0;
12721 r = guestfs_blockdev_setrw (g, device);
12727 suppress_error = 0;
12728 r = guestfs_umount_all (g);
12734 suppress_error = 0;
12735 r = guestfs_lvm_remove_all (g);
12740 char device[] = "/dev/sda";
12741 device[5] = devchar;
12742 char lines_0[] = ",";
12748 suppress_error = 0;
12749 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12754 char fstype[] = "ext2";
12755 char device[] = "/dev/sda1";
12756 device[5] = devchar;
12758 suppress_error = 0;
12759 r = guestfs_mkfs (g, fstype, device);
12764 char device[] = "/dev/sda1";
12765 device[5] = devchar;
12766 char mountpoint[] = "/";
12768 suppress_error = 0;
12769 r = guestfs_mount (g, device, mountpoint);
12773 /* TestOutputList for ls (0) */
12775 char path[] = "/new";
12777 suppress_error = 0;
12778 r = guestfs_touch (g, path);
12783 char path[] = "/newer";
12785 suppress_error = 0;
12786 r = guestfs_touch (g, path);
12791 char path[] = "/newest";
12793 suppress_error = 0;
12794 r = guestfs_touch (g, path);
12799 char directory[] = "/";
12802 suppress_error = 0;
12803 r = guestfs_ls (g, directory);
12807 fprintf (stderr, "test_ls_0: short list returned from command\n");
12812 char expected[] = "lost+found";
12813 if (strcmp (r[0], expected) != 0) {
12814 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12819 fprintf (stderr, "test_ls_0: short list returned from command\n");
12824 char expected[] = "new";
12825 if (strcmp (r[1], expected) != 0) {
12826 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12831 fprintf (stderr, "test_ls_0: short list returned from command\n");
12836 char expected[] = "newer";
12837 if (strcmp (r[2], expected) != 0) {
12838 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12843 fprintf (stderr, "test_ls_0: short list returned from command\n");
12848 char expected[] = "newest";
12849 if (strcmp (r[3], expected) != 0) {
12850 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12854 if (r[4] != NULL) {
12855 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
12859 for (i = 0; r[i] != NULL; ++i)
12866 static int test_cat_0 (void)
12868 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
12870 char device[] = "/dev/sda";
12871 device[5] = devchar;
12873 suppress_error = 0;
12874 r = guestfs_blockdev_setrw (g, device);
12880 suppress_error = 0;
12881 r = guestfs_umount_all (g);
12887 suppress_error = 0;
12888 r = guestfs_lvm_remove_all (g);
12893 char device[] = "/dev/sda";
12894 device[5] = devchar;
12895 char lines_0[] = ",";
12901 suppress_error = 0;
12902 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12907 char fstype[] = "ext2";
12908 char device[] = "/dev/sda1";
12909 device[5] = devchar;
12911 suppress_error = 0;
12912 r = guestfs_mkfs (g, fstype, device);
12917 char device[] = "/dev/sda1";
12918 device[5] = devchar;
12919 char mountpoint[] = "/";
12921 suppress_error = 0;
12922 r = guestfs_mount (g, device, mountpoint);
12926 /* TestOutput for cat (0) */
12927 char expected[] = "new file contents";
12929 char path[] = "/new";
12930 char content[] = "new file contents";
12932 suppress_error = 0;
12933 r = guestfs_write_file (g, path, content, 0);
12938 char path[] = "/new";
12940 suppress_error = 0;
12941 r = guestfs_cat (g, path);
12944 if (strcmp (r, expected) != 0) {
12945 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
12953 static int test_touch_0 (void)
12955 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
12957 char device[] = "/dev/sda";
12958 device[5] = devchar;
12960 suppress_error = 0;
12961 r = guestfs_blockdev_setrw (g, device);
12967 suppress_error = 0;
12968 r = guestfs_umount_all (g);
12974 suppress_error = 0;
12975 r = guestfs_lvm_remove_all (g);
12980 char device[] = "/dev/sda";
12981 device[5] = devchar;
12982 char lines_0[] = ",";
12988 suppress_error = 0;
12989 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12994 char fstype[] = "ext2";
12995 char device[] = "/dev/sda1";
12996 device[5] = devchar;
12998 suppress_error = 0;
12999 r = guestfs_mkfs (g, fstype, device);
13004 char device[] = "/dev/sda1";
13005 device[5] = devchar;
13006 char mountpoint[] = "/";
13008 suppress_error = 0;
13009 r = guestfs_mount (g, device, mountpoint);
13013 /* TestOutputTrue for touch (0) */
13015 char path[] = "/new";
13017 suppress_error = 0;
13018 r = guestfs_touch (g, path);
13023 char path[] = "/new";
13025 suppress_error = 0;
13026 r = guestfs_exists (g, path);
13030 fprintf (stderr, "test_touch_0: expected true, got false\n");
13037 static int test_sync_0 (void)
13039 /* InitNone|InitEmpty for test_sync_0 */
13041 char device[] = "/dev/sda";
13042 device[5] = devchar;
13044 suppress_error = 0;
13045 r = guestfs_blockdev_setrw (g, device);
13051 suppress_error = 0;
13052 r = guestfs_umount_all (g);
13058 suppress_error = 0;
13059 r = guestfs_lvm_remove_all (g);
13063 /* TestRun for sync (0) */
13066 suppress_error = 0;
13067 r = guestfs_sync (g);
13074 static int test_mount_0 (void)
13076 /* InitNone|InitEmpty for test_mount_0 */
13078 char device[] = "/dev/sda";
13079 device[5] = devchar;
13081 suppress_error = 0;
13082 r = guestfs_blockdev_setrw (g, device);
13088 suppress_error = 0;
13089 r = guestfs_umount_all (g);
13095 suppress_error = 0;
13096 r = guestfs_lvm_remove_all (g);
13100 /* TestOutput for mount (0) */
13101 char expected[] = "new file contents";
13103 char device[] = "/dev/sda";
13104 device[5] = devchar;
13105 char lines_0[] = ",";
13111 suppress_error = 0;
13112 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13117 char fstype[] = "ext2";
13118 char device[] = "/dev/sda1";
13119 device[5] = devchar;
13121 suppress_error = 0;
13122 r = guestfs_mkfs (g, fstype, device);
13127 char device[] = "/dev/sda1";
13128 device[5] = devchar;
13129 char mountpoint[] = "/";
13131 suppress_error = 0;
13132 r = guestfs_mount (g, device, mountpoint);
13137 char path[] = "/new";
13138 char content[] = "new file contents";
13140 suppress_error = 0;
13141 r = guestfs_write_file (g, path, content, 0);
13146 char path[] = "/new";
13148 suppress_error = 0;
13149 r = guestfs_cat (g, path);
13152 if (strcmp (r, expected) != 0) {
13153 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
13161 int main (int argc, char *argv[])
13165 const char *srcdir;
13166 const char *filename;
13168 int nr_tests, test_num = 0;
13171 no_test_warnings ();
13173 g = guestfs_create ();
13175 printf ("guestfs_create FAILED\n");
13179 guestfs_set_error_handler (g, print_error, NULL);
13181 srcdir = getenv ("srcdir");
13182 if (!srcdir) srcdir = ".";
13184 guestfs_set_path (g, ".");
13186 filename = "test1.img";
13187 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13192 if (lseek (fd, 524288000, SEEK_SET) == -1) {
13198 if (write (fd, &c, 1) == -1) {
13204 if (close (fd) == -1) {
13209 if (guestfs_add_drive (g, filename) == -1) {
13210 printf ("guestfs_add_drive %s FAILED\n", filename);
13214 filename = "test2.img";
13215 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13220 if (lseek (fd, 52428800, SEEK_SET) == -1) {
13226 if (write (fd, &c, 1) == -1) {
13232 if (close (fd) == -1) {
13237 if (guestfs_add_drive (g, filename) == -1) {
13238 printf ("guestfs_add_drive %s FAILED\n", filename);
13242 filename = "test3.img";
13243 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
13248 if (lseek (fd, 10485760, SEEK_SET) == -1) {
13254 if (write (fd, &c, 1) == -1) {
13260 if (close (fd) == -1) {
13265 if (guestfs_add_drive (g, filename) == -1) {
13266 printf ("guestfs_add_drive %s FAILED\n", filename);
13270 if (guestfs_launch (g) == -1) {
13271 printf ("guestfs_launch FAILED\n");
13274 if (guestfs_wait_ready (g) == -1) {
13275 printf ("guestfs_wait_ready FAILED\n");
13279 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
13280 * names. This changed between RHEL 5 and RHEL 6 so we have to
13283 devs = guestfs_list_devices (g);
13284 if (devs == NULL || devs[0] == NULL) {
13285 printf ("guestfs_list_devices FAILED\n");
13288 if (strncmp (devs[0], "/dev/sd", 7) == 0)
13290 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
13293 printf ("guestfs_list_devices returned unexpected string '%s'\n",
13297 for (i = 0; devs[i] != NULL; ++i)
13304 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
13305 if (test_lvresize_0 () == -1) {
13306 printf ("test_lvresize_0 FAILED\n");
13310 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
13311 if (test_zerofree_0 () == -1) {
13312 printf ("test_zerofree_0 FAILED\n");
13316 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
13317 if (test_hexdump_0 () == -1) {
13318 printf ("test_hexdump_0 FAILED\n");
13322 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
13323 if (test_strings_e_0 () == -1) {
13324 printf ("test_strings_e_0 FAILED\n");
13328 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
13329 if (test_strings_e_1 () == -1) {
13330 printf ("test_strings_e_1 FAILED\n");
13334 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
13335 if (test_strings_0 () == -1) {
13336 printf ("test_strings_0 FAILED\n");
13340 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
13341 if (test_strings_1 () == -1) {
13342 printf ("test_strings_1 FAILED\n");
13346 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
13347 if (test_equal_0 () == -1) {
13348 printf ("test_equal_0 FAILED\n");
13352 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
13353 if (test_equal_1 () == -1) {
13354 printf ("test_equal_1 FAILED\n");
13358 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
13359 if (test_equal_2 () == -1) {
13360 printf ("test_equal_2 FAILED\n");
13364 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
13365 if (test_ping_daemon_0 () == -1) {
13366 printf ("test_ping_daemon_0 FAILED\n");
13370 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
13371 if (test_dmesg_0 () == -1) {
13372 printf ("test_dmesg_0 FAILED\n");
13376 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
13377 if (test_drop_caches_0 () == -1) {
13378 printf ("test_drop_caches_0 FAILED\n");
13382 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
13383 if (test_mv_0 () == -1) {
13384 printf ("test_mv_0 FAILED\n");
13388 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
13389 if (test_mv_1 () == -1) {
13390 printf ("test_mv_1 FAILED\n");
13394 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
13395 if (test_cp_a_0 () == -1) {
13396 printf ("test_cp_a_0 FAILED\n");
13400 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
13401 if (test_cp_0 () == -1) {
13402 printf ("test_cp_0 FAILED\n");
13406 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
13407 if (test_cp_1 () == -1) {
13408 printf ("test_cp_1 FAILED\n");
13412 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
13413 if (test_cp_2 () == -1) {
13414 printf ("test_cp_2 FAILED\n");
13418 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
13419 if (test_grub_install_0 () == -1) {
13420 printf ("test_grub_install_0 FAILED\n");
13424 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
13425 if (test_zero_0 () == -1) {
13426 printf ("test_zero_0 FAILED\n");
13430 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
13431 if (test_fsck_0 () == -1) {
13432 printf ("test_fsck_0 FAILED\n");
13436 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
13437 if (test_fsck_1 () == -1) {
13438 printf ("test_fsck_1 FAILED\n");
13442 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
13443 if (test_set_e2uuid_0 () == -1) {
13444 printf ("test_set_e2uuid_0 FAILED\n");
13448 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
13449 if (test_set_e2uuid_1 () == -1) {
13450 printf ("test_set_e2uuid_1 FAILED\n");
13454 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
13455 if (test_set_e2uuid_2 () == -1) {
13456 printf ("test_set_e2uuid_2 FAILED\n");
13460 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
13461 if (test_set_e2uuid_3 () == -1) {
13462 printf ("test_set_e2uuid_3 FAILED\n");
13466 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
13467 if (test_set_e2label_0 () == -1) {
13468 printf ("test_set_e2label_0 FAILED\n");
13472 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
13473 if (test_pvremove_0 () == -1) {
13474 printf ("test_pvremove_0 FAILED\n");
13478 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
13479 if (test_pvremove_1 () == -1) {
13480 printf ("test_pvremove_1 FAILED\n");
13484 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
13485 if (test_pvremove_2 () == -1) {
13486 printf ("test_pvremove_2 FAILED\n");
13490 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
13491 if (test_vgremove_0 () == -1) {
13492 printf ("test_vgremove_0 FAILED\n");
13496 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
13497 if (test_vgremove_1 () == -1) {
13498 printf ("test_vgremove_1 FAILED\n");
13502 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
13503 if (test_lvremove_0 () == -1) {
13504 printf ("test_lvremove_0 FAILED\n");
13508 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
13509 if (test_lvremove_1 () == -1) {
13510 printf ("test_lvremove_1 FAILED\n");
13514 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
13515 if (test_lvremove_2 () == -1) {
13516 printf ("test_lvremove_2 FAILED\n");
13520 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
13521 if (test_mount_ro_0 () == -1) {
13522 printf ("test_mount_ro_0 FAILED\n");
13526 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
13527 if (test_mount_ro_1 () == -1) {
13528 printf ("test_mount_ro_1 FAILED\n");
13532 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
13533 if (test_tgz_in_0 () == -1) {
13534 printf ("test_tgz_in_0 FAILED\n");
13538 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
13539 if (test_tar_in_0 () == -1) {
13540 printf ("test_tar_in_0 FAILED\n");
13544 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
13545 if (test_checksum_0 () == -1) {
13546 printf ("test_checksum_0 FAILED\n");
13550 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
13551 if (test_checksum_1 () == -1) {
13552 printf ("test_checksum_1 FAILED\n");
13556 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
13557 if (test_checksum_2 () == -1) {
13558 printf ("test_checksum_2 FAILED\n");
13562 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
13563 if (test_checksum_3 () == -1) {
13564 printf ("test_checksum_3 FAILED\n");
13568 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
13569 if (test_checksum_4 () == -1) {
13570 printf ("test_checksum_4 FAILED\n");
13574 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
13575 if (test_checksum_5 () == -1) {
13576 printf ("test_checksum_5 FAILED\n");
13580 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
13581 if (test_checksum_6 () == -1) {
13582 printf ("test_checksum_6 FAILED\n");
13586 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
13587 if (test_checksum_7 () == -1) {
13588 printf ("test_checksum_7 FAILED\n");
13592 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
13593 if (test_download_0 () == -1) {
13594 printf ("test_download_0 FAILED\n");
13598 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
13599 if (test_upload_0 () == -1) {
13600 printf ("test_upload_0 FAILED\n");
13604 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
13605 if (test_blockdev_rereadpt_0 () == -1) {
13606 printf ("test_blockdev_rereadpt_0 FAILED\n");
13610 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
13611 if (test_blockdev_flushbufs_0 () == -1) {
13612 printf ("test_blockdev_flushbufs_0 FAILED\n");
13616 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
13617 if (test_blockdev_getsize64_0 () == -1) {
13618 printf ("test_blockdev_getsize64_0 FAILED\n");
13622 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
13623 if (test_blockdev_getsz_0 () == -1) {
13624 printf ("test_blockdev_getsz_0 FAILED\n");
13628 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
13629 if (test_blockdev_getbsz_0 () == -1) {
13630 printf ("test_blockdev_getbsz_0 FAILED\n");
13634 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
13635 if (test_blockdev_getss_0 () == -1) {
13636 printf ("test_blockdev_getss_0 FAILED\n");
13640 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
13641 if (test_blockdev_getro_0 () == -1) {
13642 printf ("test_blockdev_getro_0 FAILED\n");
13646 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
13647 if (test_blockdev_setrw_0 () == -1) {
13648 printf ("test_blockdev_setrw_0 FAILED\n");
13652 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
13653 if (test_blockdev_setro_0 () == -1) {
13654 printf ("test_blockdev_setro_0 FAILED\n");
13658 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
13659 if (test_statvfs_0 () == -1) {
13660 printf ("test_statvfs_0 FAILED\n");
13664 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
13665 if (test_lstat_0 () == -1) {
13666 printf ("test_lstat_0 FAILED\n");
13670 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
13671 if (test_stat_0 () == -1) {
13672 printf ("test_stat_0 FAILED\n");
13676 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
13677 if (test_command_lines_0 () == -1) {
13678 printf ("test_command_lines_0 FAILED\n");
13682 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
13683 if (test_command_lines_1 () == -1) {
13684 printf ("test_command_lines_1 FAILED\n");
13688 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
13689 if (test_command_lines_2 () == -1) {
13690 printf ("test_command_lines_2 FAILED\n");
13694 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
13695 if (test_command_lines_3 () == -1) {
13696 printf ("test_command_lines_3 FAILED\n");
13700 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
13701 if (test_command_lines_4 () == -1) {
13702 printf ("test_command_lines_4 FAILED\n");
13706 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
13707 if (test_command_lines_5 () == -1) {
13708 printf ("test_command_lines_5 FAILED\n");
13712 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
13713 if (test_command_lines_6 () == -1) {
13714 printf ("test_command_lines_6 FAILED\n");
13718 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
13719 if (test_command_lines_7 () == -1) {
13720 printf ("test_command_lines_7 FAILED\n");
13724 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
13725 if (test_command_lines_8 () == -1) {
13726 printf ("test_command_lines_8 FAILED\n");
13730 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
13731 if (test_command_lines_9 () == -1) {
13732 printf ("test_command_lines_9 FAILED\n");
13736 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
13737 if (test_command_lines_10 () == -1) {
13738 printf ("test_command_lines_10 FAILED\n");
13742 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
13743 if (test_command_0 () == -1) {
13744 printf ("test_command_0 FAILED\n");
13748 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
13749 if (test_command_1 () == -1) {
13750 printf ("test_command_1 FAILED\n");
13754 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
13755 if (test_command_2 () == -1) {
13756 printf ("test_command_2 FAILED\n");
13760 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
13761 if (test_command_3 () == -1) {
13762 printf ("test_command_3 FAILED\n");
13766 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
13767 if (test_command_4 () == -1) {
13768 printf ("test_command_4 FAILED\n");
13772 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
13773 if (test_command_5 () == -1) {
13774 printf ("test_command_5 FAILED\n");
13778 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
13779 if (test_command_6 () == -1) {
13780 printf ("test_command_6 FAILED\n");
13784 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
13785 if (test_command_7 () == -1) {
13786 printf ("test_command_7 FAILED\n");
13790 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
13791 if (test_command_8 () == -1) {
13792 printf ("test_command_8 FAILED\n");
13796 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
13797 if (test_command_9 () == -1) {
13798 printf ("test_command_9 FAILED\n");
13802 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
13803 if (test_command_10 () == -1) {
13804 printf ("test_command_10 FAILED\n");
13808 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
13809 if (test_command_11 () == -1) {
13810 printf ("test_command_11 FAILED\n");
13814 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
13815 if (test_file_0 () == -1) {
13816 printf ("test_file_0 FAILED\n");
13820 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
13821 if (test_file_1 () == -1) {
13822 printf ("test_file_1 FAILED\n");
13826 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
13827 if (test_file_2 () == -1) {
13828 printf ("test_file_2 FAILED\n");
13832 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
13833 if (test_umount_all_0 () == -1) {
13834 printf ("test_umount_all_0 FAILED\n");
13838 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
13839 if (test_umount_all_1 () == -1) {
13840 printf ("test_umount_all_1 FAILED\n");
13844 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
13845 if (test_mounts_0 () == -1) {
13846 printf ("test_mounts_0 FAILED\n");
13850 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
13851 if (test_umount_0 () == -1) {
13852 printf ("test_umount_0 FAILED\n");
13856 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
13857 if (test_umount_1 () == -1) {
13858 printf ("test_umount_1 FAILED\n");
13862 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
13863 if (test_write_file_0 () == -1) {
13864 printf ("test_write_file_0 FAILED\n");
13868 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
13869 if (test_write_file_1 () == -1) {
13870 printf ("test_write_file_1 FAILED\n");
13874 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
13875 if (test_write_file_2 () == -1) {
13876 printf ("test_write_file_2 FAILED\n");
13880 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
13881 if (test_write_file_3 () == -1) {
13882 printf ("test_write_file_3 FAILED\n");
13886 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
13887 if (test_write_file_4 () == -1) {
13888 printf ("test_write_file_4 FAILED\n");
13892 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
13893 if (test_write_file_5 () == -1) {
13894 printf ("test_write_file_5 FAILED\n");
13898 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
13899 if (test_mkfs_0 () == -1) {
13900 printf ("test_mkfs_0 FAILED\n");
13904 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
13905 if (test_lvcreate_0 () == -1) {
13906 printf ("test_lvcreate_0 FAILED\n");
13910 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
13911 if (test_vgcreate_0 () == -1) {
13912 printf ("test_vgcreate_0 FAILED\n");
13916 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
13917 if (test_pvcreate_0 () == -1) {
13918 printf ("test_pvcreate_0 FAILED\n");
13922 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
13923 if (test_is_dir_0 () == -1) {
13924 printf ("test_is_dir_0 FAILED\n");
13928 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
13929 if (test_is_dir_1 () == -1) {
13930 printf ("test_is_dir_1 FAILED\n");
13934 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
13935 if (test_is_file_0 () == -1) {
13936 printf ("test_is_file_0 FAILED\n");
13940 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
13941 if (test_is_file_1 () == -1) {
13942 printf ("test_is_file_1 FAILED\n");
13946 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
13947 if (test_exists_0 () == -1) {
13948 printf ("test_exists_0 FAILED\n");
13952 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
13953 if (test_exists_1 () == -1) {
13954 printf ("test_exists_1 FAILED\n");
13958 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
13959 if (test_mkdir_p_0 () == -1) {
13960 printf ("test_mkdir_p_0 FAILED\n");
13964 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
13965 if (test_mkdir_p_1 () == -1) {
13966 printf ("test_mkdir_p_1 FAILED\n");
13970 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
13971 if (test_mkdir_p_2 () == -1) {
13972 printf ("test_mkdir_p_2 FAILED\n");
13976 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
13977 if (test_mkdir_0 () == -1) {
13978 printf ("test_mkdir_0 FAILED\n");
13982 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
13983 if (test_mkdir_1 () == -1) {
13984 printf ("test_mkdir_1 FAILED\n");
13988 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
13989 if (test_rm_rf_0 () == -1) {
13990 printf ("test_rm_rf_0 FAILED\n");
13994 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
13995 if (test_rmdir_0 () == -1) {
13996 printf ("test_rmdir_0 FAILED\n");
14000 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
14001 if (test_rmdir_1 () == -1) {
14002 printf ("test_rmdir_1 FAILED\n");
14006 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
14007 if (test_rmdir_2 () == -1) {
14008 printf ("test_rmdir_2 FAILED\n");
14012 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
14013 if (test_rm_0 () == -1) {
14014 printf ("test_rm_0 FAILED\n");
14018 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
14019 if (test_rm_1 () == -1) {
14020 printf ("test_rm_1 FAILED\n");
14024 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
14025 if (test_rm_2 () == -1) {
14026 printf ("test_rm_2 FAILED\n");
14030 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
14031 if (test_read_lines_0 () == -1) {
14032 printf ("test_read_lines_0 FAILED\n");
14036 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
14037 if (test_read_lines_1 () == -1) {
14038 printf ("test_read_lines_1 FAILED\n");
14042 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
14043 if (test_lvs_0 () == -1) {
14044 printf ("test_lvs_0 FAILED\n");
14048 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
14049 if (test_lvs_1 () == -1) {
14050 printf ("test_lvs_1 FAILED\n");
14054 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
14055 if (test_vgs_0 () == -1) {
14056 printf ("test_vgs_0 FAILED\n");
14060 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
14061 if (test_vgs_1 () == -1) {
14062 printf ("test_vgs_1 FAILED\n");
14066 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
14067 if (test_pvs_0 () == -1) {
14068 printf ("test_pvs_0 FAILED\n");
14072 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
14073 if (test_pvs_1 () == -1) {
14074 printf ("test_pvs_1 FAILED\n");
14078 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
14079 if (test_list_partitions_0 () == -1) {
14080 printf ("test_list_partitions_0 FAILED\n");
14084 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
14085 if (test_list_partitions_1 () == -1) {
14086 printf ("test_list_partitions_1 FAILED\n");
14090 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
14091 if (test_list_devices_0 () == -1) {
14092 printf ("test_list_devices_0 FAILED\n");
14096 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
14097 if (test_ls_0 () == -1) {
14098 printf ("test_ls_0 FAILED\n");
14102 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
14103 if (test_cat_0 () == -1) {
14104 printf ("test_cat_0 FAILED\n");
14108 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
14109 if (test_touch_0 () == -1) {
14110 printf ("test_touch_0 FAILED\n");
14114 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
14115 if (test_sync_0 () == -1) {
14116 printf ("test_sync_0 FAILED\n");
14120 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
14121 if (test_mount_0 () == -1) {
14122 printf ("test_mount_0 FAILED\n");
14127 unlink ("test1.img");
14128 unlink ("test2.img");
14129 unlink ("test3.img");
14132 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);