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_test0\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
157 static int test_find_0_skip (void)
161 str = getenv ("SKIP_TEST_FIND_0");
162 if (str && strcmp (str, "1") == 0) return 1;
163 str = getenv ("SKIP_TEST_FIND");
164 if (str && strcmp (str, "1") == 0) return 1;
168 static int test_find_0 (void)
170 if (test_find_0_skip ()) {
171 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
175 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
177 char device[] = "/dev/sda";
181 r = guestfs_blockdev_setrw (g, device);
188 r = guestfs_umount_all (g);
195 r = guestfs_lvm_remove_all (g);
200 char device[] = "/dev/sda";
202 char lines_0[] = ",";
209 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
214 char fstype[] = "ext2";
215 char device[] = "/dev/sda1";
219 r = guestfs_mkfs (g, fstype, device);
224 char device[] = "/dev/sda1";
226 char mountpoint[] = "/";
229 r = guestfs_mount (g, device, mountpoint);
233 /* TestOutputList for find (0) */
235 char directory[] = "/";
239 r = guestfs_find (g, directory);
243 fprintf (stderr, "test_find_0: short list returned from command\n");
248 char expected[] = "lost+found";
249 if (strcmp (r[0], expected) != 0) {
250 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
255 fprintf (stderr, "test_find_0: extra elements returned from command\n");
259 for (i = 0; r[i] != NULL; ++i)
266 static int test_find_1_skip (void)
270 str = getenv ("SKIP_TEST_FIND_1");
271 if (str && strcmp (str, "1") == 0) return 1;
272 str = getenv ("SKIP_TEST_FIND");
273 if (str && strcmp (str, "1") == 0) return 1;
277 static int test_find_1 (void)
279 if (test_find_1_skip ()) {
280 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
284 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
286 char device[] = "/dev/sda";
290 r = guestfs_blockdev_setrw (g, device);
297 r = guestfs_umount_all (g);
304 r = guestfs_lvm_remove_all (g);
309 char device[] = "/dev/sda";
311 char lines_0[] = ",";
318 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
323 char fstype[] = "ext2";
324 char device[] = "/dev/sda1";
328 r = guestfs_mkfs (g, fstype, device);
333 char device[] = "/dev/sda1";
335 char mountpoint[] = "/";
338 r = guestfs_mount (g, device, mountpoint);
342 /* TestOutputList for find (1) */
347 r = guestfs_touch (g, path);
355 r = guestfs_mkdir (g, path);
360 char path[] = "/b/c";
363 r = guestfs_touch (g, path);
368 char directory[] = "/";
372 r = guestfs_find (g, directory);
376 fprintf (stderr, "test_find_1: short list returned from command\n");
381 char expected[] = "a";
382 if (strcmp (r[0], expected) != 0) {
383 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
388 fprintf (stderr, "test_find_1: short list returned from command\n");
393 char expected[] = "b";
394 if (strcmp (r[1], expected) != 0) {
395 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
400 fprintf (stderr, "test_find_1: short list returned from command\n");
405 char expected[] = "b/c";
406 if (strcmp (r[2], expected) != 0) {
407 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
412 fprintf (stderr, "test_find_1: short list returned from command\n");
417 char expected[] = "lost+found";
418 if (strcmp (r[3], expected) != 0) {
419 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
424 fprintf (stderr, "test_find_1: extra elements returned from command\n");
428 for (i = 0; r[i] != NULL; ++i)
435 static int test_find_2_skip (void)
439 str = getenv ("SKIP_TEST_FIND_2");
440 if (str && strcmp (str, "1") == 0) return 1;
441 str = getenv ("SKIP_TEST_FIND");
442 if (str && strcmp (str, "1") == 0) return 1;
446 static int test_find_2 (void)
448 if (test_find_2_skip ()) {
449 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
453 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
455 char device[] = "/dev/sda";
459 r = guestfs_blockdev_setrw (g, device);
466 r = guestfs_umount_all (g);
473 r = guestfs_lvm_remove_all (g);
478 char device[] = "/dev/sda";
480 char lines_0[] = ",";
487 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
492 char fstype[] = "ext2";
493 char device[] = "/dev/sda1";
497 r = guestfs_mkfs (g, fstype, device);
502 char device[] = "/dev/sda1";
504 char mountpoint[] = "/";
507 r = guestfs_mount (g, device, mountpoint);
511 /* TestOutputList for find (2) */
513 char path[] = "/a/b/c";
516 r = guestfs_mkdir_p (g, path);
521 char path[] = "/a/b/c/d";
524 r = guestfs_touch (g, path);
529 char directory[] = "/a/b/";
533 r = guestfs_find (g, directory);
537 fprintf (stderr, "test_find_2: short list returned from command\n");
542 char expected[] = "c";
543 if (strcmp (r[0], expected) != 0) {
544 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
549 fprintf (stderr, "test_find_2: short list returned from command\n");
554 char expected[] = "c/d";
555 if (strcmp (r[1], expected) != 0) {
556 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
561 fprintf (stderr, "test_find_2: extra elements returned from command\n");
565 for (i = 0; r[i] != NULL; ++i)
572 static int test_lvresize_0_skip (void)
576 str = getenv ("SKIP_TEST_LVRESIZE_0");
577 if (str && strcmp (str, "1") == 0) return 1;
578 str = getenv ("SKIP_TEST_LVRESIZE");
579 if (str && strcmp (str, "1") == 0) return 1;
583 static int test_lvresize_0 (void)
585 if (test_lvresize_0_skip ()) {
586 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
590 /* InitNone|InitEmpty for test_lvresize_0 */
592 char device[] = "/dev/sda";
596 r = guestfs_blockdev_setrw (g, device);
603 r = guestfs_umount_all (g);
610 r = guestfs_lvm_remove_all (g);
614 /* TestOutput for lvresize (0) */
615 char expected[] = "test content";
617 char device[] = "/dev/sda";
619 char lines_0[] = ",";
626 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
631 char device[] = "/dev/sda1";
635 r = guestfs_pvcreate (g, device);
640 char volgroup[] = "VG";
641 char physvols_0[] = "/dev/sda1";
642 physvols_0[5] = devchar;
649 r = guestfs_vgcreate (g, volgroup, physvols);
654 char logvol[] = "LV";
655 char volgroup[] = "VG";
658 r = guestfs_lvcreate (g, logvol, volgroup, 10);
663 char fstype[] = "ext2";
664 char device[] = "/dev/VG/LV";
667 r = guestfs_mkfs (g, fstype, device);
672 char device[] = "/dev/VG/LV";
673 char mountpoint[] = "/";
676 r = guestfs_mount (g, device, mountpoint);
681 char path[] = "/new";
682 char content[] = "test content";
685 r = guestfs_write_file (g, path, content, 0);
690 char pathordevice[] = "/";
693 r = guestfs_umount (g, pathordevice);
698 char device[] = "/dev/VG/LV";
701 r = guestfs_lvresize (g, device, 20);
706 char device[] = "/dev/VG/LV";
709 r = guestfs_e2fsck_f (g, device);
714 char device[] = "/dev/VG/LV";
717 r = guestfs_resize2fs (g, device);
722 char device[] = "/dev/VG/LV";
723 char mountpoint[] = "/";
726 r = guestfs_mount (g, device, mountpoint);
731 char path[] = "/new";
734 r = guestfs_cat (g, path);
737 if (strcmp (r, expected) != 0) {
738 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
746 static int test_zerofree_0_skip (void)
750 str = getenv ("SKIP_TEST_ZEROFREE_0");
751 if (str && strcmp (str, "1") == 0) return 1;
752 str = getenv ("SKIP_TEST_ZEROFREE");
753 if (str && strcmp (str, "1") == 0) return 1;
757 static int test_zerofree_0 (void)
759 if (test_zerofree_0_skip ()) {
760 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
764 /* InitNone|InitEmpty for test_zerofree_0 */
766 char device[] = "/dev/sda";
770 r = guestfs_blockdev_setrw (g, device);
777 r = guestfs_umount_all (g);
784 r = guestfs_lvm_remove_all (g);
788 /* TestOutput for zerofree (0) */
789 char expected[] = "test file";
791 char device[] = "/dev/sda";
793 char lines_0[] = ",";
800 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
805 char fstype[] = "ext3";
806 char device[] = "/dev/sda1";
810 r = guestfs_mkfs (g, fstype, device);
815 char device[] = "/dev/sda1";
817 char mountpoint[] = "/";
820 r = guestfs_mount (g, device, mountpoint);
825 char path[] = "/new";
826 char content[] = "test file";
829 r = guestfs_write_file (g, path, content, 0);
834 char pathordevice[] = "/dev/sda1";
835 pathordevice[5] = devchar;
838 r = guestfs_umount (g, pathordevice);
843 char device[] = "/dev/sda1";
847 r = guestfs_zerofree (g, device);
852 char device[] = "/dev/sda1";
854 char mountpoint[] = "/";
857 r = guestfs_mount (g, device, mountpoint);
862 char path[] = "/new";
865 r = guestfs_cat (g, path);
868 if (strcmp (r, expected) != 0) {
869 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
877 static int test_hexdump_0_skip (void)
881 str = getenv ("SKIP_TEST_HEXDUMP_0");
882 if (str && strcmp (str, "1") == 0) return 1;
883 str = getenv ("SKIP_TEST_HEXDUMP");
884 if (str && strcmp (str, "1") == 0) return 1;
888 static int test_hexdump_0 (void)
890 if (test_hexdump_0_skip ()) {
891 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
895 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
897 char device[] = "/dev/sda";
901 r = guestfs_blockdev_setrw (g, device);
908 r = guestfs_umount_all (g);
915 r = guestfs_lvm_remove_all (g);
920 char device[] = "/dev/sda";
922 char lines_0[] = ",";
929 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
934 char fstype[] = "ext2";
935 char device[] = "/dev/sda1";
939 r = guestfs_mkfs (g, fstype, device);
944 char device[] = "/dev/sda1";
946 char mountpoint[] = "/";
949 r = guestfs_mount (g, device, mountpoint);
953 /* TestOutput for hexdump (0) */
954 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
956 char path[] = "/new";
957 char content[] = "hello\nworld\n";
960 r = guestfs_write_file (g, path, content, 12);
965 char path[] = "/new";
968 r = guestfs_hexdump (g, path);
971 if (strcmp (r, expected) != 0) {
972 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
980 static int test_strings_e_0_skip (void)
984 str = getenv ("SKIP_TEST_STRINGS_E_0");
985 if (str && strcmp (str, "1") == 0) return 1;
986 str = getenv ("SKIP_TEST_STRINGS_E");
987 if (str && strcmp (str, "1") == 0) return 1;
991 static int test_strings_e_0 (void)
993 if (test_strings_e_0_skip ()) {
994 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
998 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1000 char device[] = "/dev/sda";
1001 device[5] = devchar;
1004 r = guestfs_blockdev_setrw (g, device);
1011 r = guestfs_umount_all (g);
1018 r = guestfs_lvm_remove_all (g);
1023 char device[] = "/dev/sda";
1024 device[5] = devchar;
1025 char lines_0[] = ",";
1032 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1037 char fstype[] = "ext2";
1038 char device[] = "/dev/sda1";
1039 device[5] = devchar;
1042 r = guestfs_mkfs (g, fstype, device);
1047 char device[] = "/dev/sda1";
1048 device[5] = devchar;
1049 char mountpoint[] = "/";
1052 r = guestfs_mount (g, device, mountpoint);
1056 /* TestOutputList for strings_e (0) */
1058 char path[] = "/new";
1059 char content[] = "hello\nworld\n";
1062 r = guestfs_write_file (g, path, content, 0);
1067 char encoding[] = "b";
1068 char path[] = "/new";
1072 r = guestfs_strings_e (g, encoding, path);
1076 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1080 for (i = 0; r[i] != NULL; ++i)
1087 static int test_strings_e_1_skip (void)
1091 str = getenv ("SKIP_TEST_STRINGS_E_1");
1092 if (str && strcmp (str, "1") == 0) return 1;
1093 str = getenv ("SKIP_TEST_STRINGS_E");
1094 if (str && strcmp (str, "1") == 0) return 1;
1098 static int test_strings_e_1 (void)
1100 if (test_strings_e_1_skip ()) {
1101 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1105 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1109 static int test_strings_0_skip (void)
1113 str = getenv ("SKIP_TEST_STRINGS_0");
1114 if (str && strcmp (str, "1") == 0) return 1;
1115 str = getenv ("SKIP_TEST_STRINGS");
1116 if (str && strcmp (str, "1") == 0) return 1;
1120 static int test_strings_0 (void)
1122 if (test_strings_0_skip ()) {
1123 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1127 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1129 char device[] = "/dev/sda";
1130 device[5] = devchar;
1133 r = guestfs_blockdev_setrw (g, device);
1140 r = guestfs_umount_all (g);
1147 r = guestfs_lvm_remove_all (g);
1152 char device[] = "/dev/sda";
1153 device[5] = devchar;
1154 char lines_0[] = ",";
1161 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1166 char fstype[] = "ext2";
1167 char device[] = "/dev/sda1";
1168 device[5] = devchar;
1171 r = guestfs_mkfs (g, fstype, device);
1176 char device[] = "/dev/sda1";
1177 device[5] = devchar;
1178 char mountpoint[] = "/";
1181 r = guestfs_mount (g, device, mountpoint);
1185 /* TestOutputList for strings (0) */
1187 char path[] = "/new";
1188 char content[] = "hello\nworld\n";
1191 r = guestfs_write_file (g, path, content, 0);
1196 char path[] = "/new";
1200 r = guestfs_strings (g, path);
1204 fprintf (stderr, "test_strings_0: short list returned from command\n");
1209 char expected[] = "hello";
1210 if (strcmp (r[0], expected) != 0) {
1211 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1216 fprintf (stderr, "test_strings_0: short list returned from command\n");
1221 char expected[] = "world";
1222 if (strcmp (r[1], expected) != 0) {
1223 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1228 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1232 for (i = 0; r[i] != NULL; ++i)
1239 static int test_strings_1_skip (void)
1243 str = getenv ("SKIP_TEST_STRINGS_1");
1244 if (str && strcmp (str, "1") == 0) return 1;
1245 str = getenv ("SKIP_TEST_STRINGS");
1246 if (str && strcmp (str, "1") == 0) return 1;
1250 static int test_strings_1 (void)
1252 if (test_strings_1_skip ()) {
1253 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1257 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1259 char device[] = "/dev/sda";
1260 device[5] = devchar;
1263 r = guestfs_blockdev_setrw (g, device);
1270 r = guestfs_umount_all (g);
1277 r = guestfs_lvm_remove_all (g);
1282 char device[] = "/dev/sda";
1283 device[5] = devchar;
1284 char lines_0[] = ",";
1291 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1296 char fstype[] = "ext2";
1297 char device[] = "/dev/sda1";
1298 device[5] = devchar;
1301 r = guestfs_mkfs (g, fstype, device);
1306 char device[] = "/dev/sda1";
1307 device[5] = devchar;
1308 char mountpoint[] = "/";
1311 r = guestfs_mount (g, device, mountpoint);
1315 /* TestOutputList for strings (1) */
1317 char path[] = "/new";
1320 r = guestfs_touch (g, path);
1325 char path[] = "/new";
1329 r = guestfs_strings (g, path);
1333 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1337 for (i = 0; r[i] != NULL; ++i)
1344 static int test_equal_0_skip (void)
1348 str = getenv ("SKIP_TEST_EQUAL_0");
1349 if (str && strcmp (str, "1") == 0) return 1;
1350 str = getenv ("SKIP_TEST_EQUAL");
1351 if (str && strcmp (str, "1") == 0) return 1;
1355 static int test_equal_0 (void)
1357 if (test_equal_0_skip ()) {
1358 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1362 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1364 char device[] = "/dev/sda";
1365 device[5] = devchar;
1368 r = guestfs_blockdev_setrw (g, device);
1375 r = guestfs_umount_all (g);
1382 r = guestfs_lvm_remove_all (g);
1387 char device[] = "/dev/sda";
1388 device[5] = devchar;
1389 char lines_0[] = ",";
1396 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1401 char fstype[] = "ext2";
1402 char device[] = "/dev/sda1";
1403 device[5] = devchar;
1406 r = guestfs_mkfs (g, fstype, device);
1411 char device[] = "/dev/sda1";
1412 device[5] = devchar;
1413 char mountpoint[] = "/";
1416 r = guestfs_mount (g, device, mountpoint);
1420 /* TestOutputTrue for equal (0) */
1422 char path[] = "/file1";
1423 char content[] = "contents of a file";
1426 r = guestfs_write_file (g, path, content, 0);
1431 char src[] = "/file1";
1432 char dest[] = "/file2";
1435 r = guestfs_cp (g, src, dest);
1440 char file1[] = "/file1";
1441 char file2[] = "/file2";
1444 r = guestfs_equal (g, file1, file2);
1448 fprintf (stderr, "test_equal_0: expected true, got false\n");
1455 static int test_equal_1_skip (void)
1459 str = getenv ("SKIP_TEST_EQUAL_1");
1460 if (str && strcmp (str, "1") == 0) return 1;
1461 str = getenv ("SKIP_TEST_EQUAL");
1462 if (str && strcmp (str, "1") == 0) return 1;
1466 static int test_equal_1 (void)
1468 if (test_equal_1_skip ()) {
1469 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1473 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1475 char device[] = "/dev/sda";
1476 device[5] = devchar;
1479 r = guestfs_blockdev_setrw (g, device);
1486 r = guestfs_umount_all (g);
1493 r = guestfs_lvm_remove_all (g);
1498 char device[] = "/dev/sda";
1499 device[5] = devchar;
1500 char lines_0[] = ",";
1507 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1512 char fstype[] = "ext2";
1513 char device[] = "/dev/sda1";
1514 device[5] = devchar;
1517 r = guestfs_mkfs (g, fstype, device);
1522 char device[] = "/dev/sda1";
1523 device[5] = devchar;
1524 char mountpoint[] = "/";
1527 r = guestfs_mount (g, device, mountpoint);
1531 /* TestOutputFalse for equal (1) */
1533 char path[] = "/file1";
1534 char content[] = "contents of a file";
1537 r = guestfs_write_file (g, path, content, 0);
1542 char path[] = "/file2";
1543 char content[] = "contents of another file";
1546 r = guestfs_write_file (g, path, content, 0);
1551 char file1[] = "/file1";
1552 char file2[] = "/file2";
1555 r = guestfs_equal (g, file1, file2);
1559 fprintf (stderr, "test_equal_1: expected false, got true\n");
1566 static int test_equal_2_skip (void)
1570 str = getenv ("SKIP_TEST_EQUAL_2");
1571 if (str && strcmp (str, "1") == 0) return 1;
1572 str = getenv ("SKIP_TEST_EQUAL");
1573 if (str && strcmp (str, "1") == 0) return 1;
1577 static int test_equal_2 (void)
1579 if (test_equal_2_skip ()) {
1580 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1584 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1586 char device[] = "/dev/sda";
1587 device[5] = devchar;
1590 r = guestfs_blockdev_setrw (g, device);
1597 r = guestfs_umount_all (g);
1604 r = guestfs_lvm_remove_all (g);
1609 char device[] = "/dev/sda";
1610 device[5] = devchar;
1611 char lines_0[] = ",";
1618 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1623 char fstype[] = "ext2";
1624 char device[] = "/dev/sda1";
1625 device[5] = devchar;
1628 r = guestfs_mkfs (g, fstype, device);
1633 char device[] = "/dev/sda1";
1634 device[5] = devchar;
1635 char mountpoint[] = "/";
1638 r = guestfs_mount (g, device, mountpoint);
1642 /* TestLastFail for equal (2) */
1644 char file1[] = "/file1";
1645 char file2[] = "/file2";
1648 r = guestfs_equal (g, file1, file2);
1655 static int test_ping_daemon_0_skip (void)
1659 str = getenv ("SKIP_TEST_PING_DAEMON_0");
1660 if (str && strcmp (str, "1") == 0) return 1;
1661 str = getenv ("SKIP_TEST_PING_DAEMON");
1662 if (str && strcmp (str, "1") == 0) return 1;
1666 static int test_ping_daemon_0 (void)
1668 if (test_ping_daemon_0_skip ()) {
1669 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1673 /* InitNone|InitEmpty for test_ping_daemon_0 */
1675 char device[] = "/dev/sda";
1676 device[5] = devchar;
1679 r = guestfs_blockdev_setrw (g, device);
1686 r = guestfs_umount_all (g);
1693 r = guestfs_lvm_remove_all (g);
1697 /* TestRun for ping_daemon (0) */
1701 r = guestfs_ping_daemon (g);
1708 static int test_dmesg_0_skip (void)
1712 str = getenv ("SKIP_TEST_DMESG_0");
1713 if (str && strcmp (str, "1") == 0) return 1;
1714 str = getenv ("SKIP_TEST_DMESG");
1715 if (str && strcmp (str, "1") == 0) return 1;
1719 static int test_dmesg_0 (void)
1721 if (test_dmesg_0_skip ()) {
1722 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1726 /* InitNone|InitEmpty for test_dmesg_0 */
1728 char device[] = "/dev/sda";
1729 device[5] = devchar;
1732 r = guestfs_blockdev_setrw (g, device);
1739 r = guestfs_umount_all (g);
1746 r = guestfs_lvm_remove_all (g);
1750 /* TestRun for dmesg (0) */
1754 r = guestfs_dmesg (g);
1762 static int test_drop_caches_0_skip (void)
1766 str = getenv ("SKIP_TEST_DROP_CACHES_0");
1767 if (str && strcmp (str, "1") == 0) return 1;
1768 str = getenv ("SKIP_TEST_DROP_CACHES");
1769 if (str && strcmp (str, "1") == 0) return 1;
1773 static int test_drop_caches_0 (void)
1775 if (test_drop_caches_0_skip ()) {
1776 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1780 /* InitNone|InitEmpty for test_drop_caches_0 */
1782 char device[] = "/dev/sda";
1783 device[5] = devchar;
1786 r = guestfs_blockdev_setrw (g, device);
1793 r = guestfs_umount_all (g);
1800 r = guestfs_lvm_remove_all (g);
1804 /* TestRun for drop_caches (0) */
1808 r = guestfs_drop_caches (g, 3);
1815 static int test_mv_0_skip (void)
1819 str = getenv ("SKIP_TEST_MV_0");
1820 if (str && strcmp (str, "1") == 0) return 1;
1821 str = getenv ("SKIP_TEST_MV");
1822 if (str && strcmp (str, "1") == 0) return 1;
1826 static int test_mv_0 (void)
1828 if (test_mv_0_skip ()) {
1829 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1833 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1835 char device[] = "/dev/sda";
1836 device[5] = devchar;
1839 r = guestfs_blockdev_setrw (g, device);
1846 r = guestfs_umount_all (g);
1853 r = guestfs_lvm_remove_all (g);
1858 char device[] = "/dev/sda";
1859 device[5] = devchar;
1860 char lines_0[] = ",";
1867 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1872 char fstype[] = "ext2";
1873 char device[] = "/dev/sda1";
1874 device[5] = devchar;
1877 r = guestfs_mkfs (g, fstype, device);
1882 char device[] = "/dev/sda1";
1883 device[5] = devchar;
1884 char mountpoint[] = "/";
1887 r = guestfs_mount (g, device, mountpoint);
1891 /* TestOutput for mv (0) */
1892 char expected[] = "file content";
1894 char path[] = "/old";
1895 char content[] = "file content";
1898 r = guestfs_write_file (g, path, content, 0);
1903 char src[] = "/old";
1904 char dest[] = "/new";
1907 r = guestfs_mv (g, src, dest);
1912 char path[] = "/new";
1915 r = guestfs_cat (g, path);
1918 if (strcmp (r, expected) != 0) {
1919 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1927 static int test_mv_1_skip (void)
1931 str = getenv ("SKIP_TEST_MV_1");
1932 if (str && strcmp (str, "1") == 0) return 1;
1933 str = getenv ("SKIP_TEST_MV");
1934 if (str && strcmp (str, "1") == 0) return 1;
1938 static int test_mv_1 (void)
1940 if (test_mv_1_skip ()) {
1941 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
1945 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1947 char device[] = "/dev/sda";
1948 device[5] = devchar;
1951 r = guestfs_blockdev_setrw (g, device);
1958 r = guestfs_umount_all (g);
1965 r = guestfs_lvm_remove_all (g);
1970 char device[] = "/dev/sda";
1971 device[5] = devchar;
1972 char lines_0[] = ",";
1979 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1984 char fstype[] = "ext2";
1985 char device[] = "/dev/sda1";
1986 device[5] = devchar;
1989 r = guestfs_mkfs (g, fstype, device);
1994 char device[] = "/dev/sda1";
1995 device[5] = devchar;
1996 char mountpoint[] = "/";
1999 r = guestfs_mount (g, device, mountpoint);
2003 /* TestOutputFalse for mv (1) */
2005 char path[] = "/old";
2006 char content[] = "file content";
2009 r = guestfs_write_file (g, path, content, 0);
2014 char src[] = "/old";
2015 char dest[] = "/new";
2018 r = guestfs_mv (g, src, dest);
2023 char path[] = "/old";
2026 r = guestfs_is_file (g, path);
2030 fprintf (stderr, "test_mv_1: expected false, got true\n");
2037 static int test_cp_a_0_skip (void)
2041 str = getenv ("SKIP_TEST_CP_A_0");
2042 if (str && strcmp (str, "1") == 0) return 1;
2043 str = getenv ("SKIP_TEST_CP_A");
2044 if (str && strcmp (str, "1") == 0) return 1;
2048 static int test_cp_a_0 (void)
2050 if (test_cp_a_0_skip ()) {
2051 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2055 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2057 char device[] = "/dev/sda";
2058 device[5] = devchar;
2061 r = guestfs_blockdev_setrw (g, device);
2068 r = guestfs_umount_all (g);
2075 r = guestfs_lvm_remove_all (g);
2080 char device[] = "/dev/sda";
2081 device[5] = devchar;
2082 char lines_0[] = ",";
2089 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2094 char fstype[] = "ext2";
2095 char device[] = "/dev/sda1";
2096 device[5] = devchar;
2099 r = guestfs_mkfs (g, fstype, device);
2104 char device[] = "/dev/sda1";
2105 device[5] = devchar;
2106 char mountpoint[] = "/";
2109 r = guestfs_mount (g, device, mountpoint);
2113 /* TestOutput for cp_a (0) */
2114 char expected[] = "file content";
2116 char path[] = "/olddir";
2119 r = guestfs_mkdir (g, path);
2124 char path[] = "/newdir";
2127 r = guestfs_mkdir (g, path);
2132 char path[] = "/olddir/file";
2133 char content[] = "file content";
2136 r = guestfs_write_file (g, path, content, 0);
2141 char src[] = "/olddir";
2142 char dest[] = "/newdir";
2145 r = guestfs_cp_a (g, src, dest);
2150 char path[] = "/newdir/olddir/file";
2153 r = guestfs_cat (g, path);
2156 if (strcmp (r, expected) != 0) {
2157 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2165 static int test_cp_0_skip (void)
2169 str = getenv ("SKIP_TEST_CP_0");
2170 if (str && strcmp (str, "1") == 0) return 1;
2171 str = getenv ("SKIP_TEST_CP");
2172 if (str && strcmp (str, "1") == 0) return 1;
2176 static int test_cp_0 (void)
2178 if (test_cp_0_skip ()) {
2179 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2183 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2185 char device[] = "/dev/sda";
2186 device[5] = devchar;
2189 r = guestfs_blockdev_setrw (g, device);
2196 r = guestfs_umount_all (g);
2203 r = guestfs_lvm_remove_all (g);
2208 char device[] = "/dev/sda";
2209 device[5] = devchar;
2210 char lines_0[] = ",";
2217 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2222 char fstype[] = "ext2";
2223 char device[] = "/dev/sda1";
2224 device[5] = devchar;
2227 r = guestfs_mkfs (g, fstype, device);
2232 char device[] = "/dev/sda1";
2233 device[5] = devchar;
2234 char mountpoint[] = "/";
2237 r = guestfs_mount (g, device, mountpoint);
2241 /* TestOutput for cp (0) */
2242 char expected[] = "file content";
2244 char path[] = "/old";
2245 char content[] = "file content";
2248 r = guestfs_write_file (g, path, content, 0);
2253 char src[] = "/old";
2254 char dest[] = "/new";
2257 r = guestfs_cp (g, src, dest);
2262 char path[] = "/new";
2265 r = guestfs_cat (g, path);
2268 if (strcmp (r, expected) != 0) {
2269 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2277 static int test_cp_1_skip (void)
2281 str = getenv ("SKIP_TEST_CP_1");
2282 if (str && strcmp (str, "1") == 0) return 1;
2283 str = getenv ("SKIP_TEST_CP");
2284 if (str && strcmp (str, "1") == 0) return 1;
2288 static int test_cp_1 (void)
2290 if (test_cp_1_skip ()) {
2291 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2295 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2297 char device[] = "/dev/sda";
2298 device[5] = devchar;
2301 r = guestfs_blockdev_setrw (g, device);
2308 r = guestfs_umount_all (g);
2315 r = guestfs_lvm_remove_all (g);
2320 char device[] = "/dev/sda";
2321 device[5] = devchar;
2322 char lines_0[] = ",";
2329 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2334 char fstype[] = "ext2";
2335 char device[] = "/dev/sda1";
2336 device[5] = devchar;
2339 r = guestfs_mkfs (g, fstype, device);
2344 char device[] = "/dev/sda1";
2345 device[5] = devchar;
2346 char mountpoint[] = "/";
2349 r = guestfs_mount (g, device, mountpoint);
2353 /* TestOutputTrue for cp (1) */
2355 char path[] = "/old";
2356 char content[] = "file content";
2359 r = guestfs_write_file (g, path, content, 0);
2364 char src[] = "/old";
2365 char dest[] = "/new";
2368 r = guestfs_cp (g, src, dest);
2373 char path[] = "/old";
2376 r = guestfs_is_file (g, path);
2380 fprintf (stderr, "test_cp_1: expected true, got false\n");
2387 static int test_cp_2_skip (void)
2391 str = getenv ("SKIP_TEST_CP_2");
2392 if (str && strcmp (str, "1") == 0) return 1;
2393 str = getenv ("SKIP_TEST_CP");
2394 if (str && strcmp (str, "1") == 0) return 1;
2398 static int test_cp_2 (void)
2400 if (test_cp_2_skip ()) {
2401 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2405 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2407 char device[] = "/dev/sda";
2408 device[5] = devchar;
2411 r = guestfs_blockdev_setrw (g, device);
2418 r = guestfs_umount_all (g);
2425 r = guestfs_lvm_remove_all (g);
2430 char device[] = "/dev/sda";
2431 device[5] = devchar;
2432 char lines_0[] = ",";
2439 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2444 char fstype[] = "ext2";
2445 char device[] = "/dev/sda1";
2446 device[5] = devchar;
2449 r = guestfs_mkfs (g, fstype, device);
2454 char device[] = "/dev/sda1";
2455 device[5] = devchar;
2456 char mountpoint[] = "/";
2459 r = guestfs_mount (g, device, mountpoint);
2463 /* TestOutput for cp (2) */
2464 char expected[] = "file content";
2466 char path[] = "/old";
2467 char content[] = "file content";
2470 r = guestfs_write_file (g, path, content, 0);
2475 char path[] = "/dir";
2478 r = guestfs_mkdir (g, path);
2483 char src[] = "/old";
2484 char dest[] = "/dir/new";
2487 r = guestfs_cp (g, src, dest);
2492 char path[] = "/dir/new";
2495 r = guestfs_cat (g, path);
2498 if (strcmp (r, expected) != 0) {
2499 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2507 static int test_grub_install_0_skip (void)
2511 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2512 if (str && strcmp (str, "1") == 0) return 1;
2513 str = getenv ("SKIP_TEST_GRUB_INSTALL");
2514 if (str && strcmp (str, "1") == 0) return 1;
2518 static int test_grub_install_0 (void)
2520 if (test_grub_install_0_skip ()) {
2521 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2525 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2527 char device[] = "/dev/sda";
2528 device[5] = devchar;
2531 r = guestfs_blockdev_setrw (g, device);
2538 r = guestfs_umount_all (g);
2545 r = guestfs_lvm_remove_all (g);
2550 char device[] = "/dev/sda";
2551 device[5] = devchar;
2552 char lines_0[] = ",";
2559 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2564 char fstype[] = "ext2";
2565 char device[] = "/dev/sda1";
2566 device[5] = devchar;
2569 r = guestfs_mkfs (g, fstype, device);
2574 char device[] = "/dev/sda1";
2575 device[5] = devchar;
2576 char mountpoint[] = "/";
2579 r = guestfs_mount (g, device, mountpoint);
2583 /* TestOutputTrue for grub_install (0) */
2586 char device[] = "/dev/sda1";
2587 device[5] = devchar;
2590 r = guestfs_grub_install (g, root, device);
2595 char path[] = "/boot";
2598 r = guestfs_is_dir (g, path);
2602 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2609 static int test_zero_0_skip (void)
2613 str = getenv ("SKIP_TEST_ZERO_0");
2614 if (str && strcmp (str, "1") == 0) return 1;
2615 str = getenv ("SKIP_TEST_ZERO");
2616 if (str && strcmp (str, "1") == 0) return 1;
2620 static int test_zero_0 (void)
2622 if (test_zero_0_skip ()) {
2623 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2627 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2629 char device[] = "/dev/sda";
2630 device[5] = devchar;
2633 r = guestfs_blockdev_setrw (g, device);
2640 r = guestfs_umount_all (g);
2647 r = guestfs_lvm_remove_all (g);
2652 char device[] = "/dev/sda";
2653 device[5] = devchar;
2654 char lines_0[] = ",";
2661 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2666 char fstype[] = "ext2";
2667 char device[] = "/dev/sda1";
2668 device[5] = devchar;
2671 r = guestfs_mkfs (g, fstype, device);
2676 char device[] = "/dev/sda1";
2677 device[5] = devchar;
2678 char mountpoint[] = "/";
2681 r = guestfs_mount (g, device, mountpoint);
2685 /* TestOutput for zero (0) */
2686 char expected[] = "data";
2688 char pathordevice[] = "/dev/sda1";
2689 pathordevice[5] = devchar;
2692 r = guestfs_umount (g, pathordevice);
2697 char device[] = "/dev/sda1";
2698 device[5] = devchar;
2701 r = guestfs_zero (g, device);
2706 char path[] = "/dev/sda1";
2710 r = guestfs_file (g, path);
2713 if (strcmp (r, expected) != 0) {
2714 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2722 static int test_fsck_0_skip (void)
2726 str = getenv ("SKIP_TEST_FSCK_0");
2727 if (str && strcmp (str, "1") == 0) return 1;
2728 str = getenv ("SKIP_TEST_FSCK");
2729 if (str && strcmp (str, "1") == 0) return 1;
2733 static int test_fsck_0 (void)
2735 if (test_fsck_0_skip ()) {
2736 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2740 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2742 char device[] = "/dev/sda";
2743 device[5] = devchar;
2746 r = guestfs_blockdev_setrw (g, device);
2753 r = guestfs_umount_all (g);
2760 r = guestfs_lvm_remove_all (g);
2765 char device[] = "/dev/sda";
2766 device[5] = devchar;
2767 char lines_0[] = ",";
2774 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2779 char fstype[] = "ext2";
2780 char device[] = "/dev/sda1";
2781 device[5] = devchar;
2784 r = guestfs_mkfs (g, fstype, device);
2789 char device[] = "/dev/sda1";
2790 device[5] = devchar;
2791 char mountpoint[] = "/";
2794 r = guestfs_mount (g, device, mountpoint);
2798 /* TestOutputInt for fsck (0) */
2800 char pathordevice[] = "/dev/sda1";
2801 pathordevice[5] = devchar;
2804 r = guestfs_umount (g, pathordevice);
2809 char fstype[] = "ext2";
2810 char device[] = "/dev/sda1";
2811 device[5] = devchar;
2814 r = guestfs_fsck (g, fstype, device);
2818 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2825 static int test_fsck_1_skip (void)
2829 str = getenv ("SKIP_TEST_FSCK_1");
2830 if (str && strcmp (str, "1") == 0) return 1;
2831 str = getenv ("SKIP_TEST_FSCK");
2832 if (str && strcmp (str, "1") == 0) return 1;
2836 static int test_fsck_1 (void)
2838 if (test_fsck_1_skip ()) {
2839 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2843 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2845 char device[] = "/dev/sda";
2846 device[5] = devchar;
2849 r = guestfs_blockdev_setrw (g, device);
2856 r = guestfs_umount_all (g);
2863 r = guestfs_lvm_remove_all (g);
2868 char device[] = "/dev/sda";
2869 device[5] = devchar;
2870 char lines_0[] = ",";
2877 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2882 char fstype[] = "ext2";
2883 char device[] = "/dev/sda1";
2884 device[5] = devchar;
2887 r = guestfs_mkfs (g, fstype, device);
2892 char device[] = "/dev/sda1";
2893 device[5] = devchar;
2894 char mountpoint[] = "/";
2897 r = guestfs_mount (g, device, mountpoint);
2901 /* TestOutputInt for fsck (1) */
2903 char pathordevice[] = "/dev/sda1";
2904 pathordevice[5] = devchar;
2907 r = guestfs_umount (g, pathordevice);
2912 char device[] = "/dev/sda1";
2913 device[5] = devchar;
2916 r = guestfs_zero (g, device);
2921 char fstype[] = "ext2";
2922 char device[] = "/dev/sda1";
2923 device[5] = devchar;
2926 r = guestfs_fsck (g, fstype, device);
2930 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
2937 static int test_set_e2uuid_0_skip (void)
2941 str = getenv ("SKIP_TEST_SET_E2UUID_0");
2942 if (str && strcmp (str, "1") == 0) return 1;
2943 str = getenv ("SKIP_TEST_SET_E2UUID");
2944 if (str && strcmp (str, "1") == 0) return 1;
2948 static int test_set_e2uuid_0 (void)
2950 if (test_set_e2uuid_0_skip ()) {
2951 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
2955 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2957 char device[] = "/dev/sda";
2958 device[5] = devchar;
2961 r = guestfs_blockdev_setrw (g, device);
2968 r = guestfs_umount_all (g);
2975 r = guestfs_lvm_remove_all (g);
2980 char device[] = "/dev/sda";
2981 device[5] = devchar;
2982 char lines_0[] = ",";
2989 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2994 char fstype[] = "ext2";
2995 char device[] = "/dev/sda1";
2996 device[5] = devchar;
2999 r = guestfs_mkfs (g, fstype, device);
3004 char device[] = "/dev/sda1";
3005 device[5] = devchar;
3006 char mountpoint[] = "/";
3009 r = guestfs_mount (g, device, mountpoint);
3013 /* TestOutput for set_e2uuid (0) */
3014 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3016 char device[] = "/dev/sda1";
3017 device[5] = devchar;
3018 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3021 r = guestfs_set_e2uuid (g, device, uuid);
3026 char device[] = "/dev/sda1";
3027 device[5] = devchar;
3030 r = guestfs_get_e2uuid (g, device);
3033 if (strcmp (r, expected) != 0) {
3034 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3042 static int test_set_e2uuid_1_skip (void)
3046 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3047 if (str && strcmp (str, "1") == 0) return 1;
3048 str = getenv ("SKIP_TEST_SET_E2UUID");
3049 if (str && strcmp (str, "1") == 0) return 1;
3053 static int test_set_e2uuid_1 (void)
3055 if (test_set_e2uuid_1_skip ()) {
3056 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3060 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3062 char device[] = "/dev/sda";
3063 device[5] = devchar;
3066 r = guestfs_blockdev_setrw (g, device);
3073 r = guestfs_umount_all (g);
3080 r = guestfs_lvm_remove_all (g);
3085 char device[] = "/dev/sda";
3086 device[5] = devchar;
3087 char lines_0[] = ",";
3094 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3099 char fstype[] = "ext2";
3100 char device[] = "/dev/sda1";
3101 device[5] = devchar;
3104 r = guestfs_mkfs (g, fstype, device);
3109 char device[] = "/dev/sda1";
3110 device[5] = devchar;
3111 char mountpoint[] = "/";
3114 r = guestfs_mount (g, device, mountpoint);
3118 /* TestOutput for set_e2uuid (1) */
3119 char expected[] = "";
3121 char device[] = "/dev/sda1";
3122 device[5] = devchar;
3123 char uuid[] = "clear";
3126 r = guestfs_set_e2uuid (g, device, uuid);
3131 char device[] = "/dev/sda1";
3132 device[5] = devchar;
3135 r = guestfs_get_e2uuid (g, device);
3138 if (strcmp (r, expected) != 0) {
3139 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3147 static int test_set_e2uuid_2_skip (void)
3151 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3152 if (str && strcmp (str, "1") == 0) return 1;
3153 str = getenv ("SKIP_TEST_SET_E2UUID");
3154 if (str && strcmp (str, "1") == 0) return 1;
3158 static int test_set_e2uuid_2 (void)
3160 if (test_set_e2uuid_2_skip ()) {
3161 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3165 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3167 char device[] = "/dev/sda";
3168 device[5] = devchar;
3171 r = guestfs_blockdev_setrw (g, device);
3178 r = guestfs_umount_all (g);
3185 r = guestfs_lvm_remove_all (g);
3190 char device[] = "/dev/sda";
3191 device[5] = devchar;
3192 char lines_0[] = ",";
3199 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3204 char fstype[] = "ext2";
3205 char device[] = "/dev/sda1";
3206 device[5] = devchar;
3209 r = guestfs_mkfs (g, fstype, device);
3214 char device[] = "/dev/sda1";
3215 device[5] = devchar;
3216 char mountpoint[] = "/";
3219 r = guestfs_mount (g, device, mountpoint);
3223 /* TestRun for set_e2uuid (2) */
3225 char device[] = "/dev/sda1";
3226 device[5] = devchar;
3227 char uuid[] = "random";
3230 r = guestfs_set_e2uuid (g, device, uuid);
3237 static int test_set_e2uuid_3_skip (void)
3241 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3242 if (str && strcmp (str, "1") == 0) return 1;
3243 str = getenv ("SKIP_TEST_SET_E2UUID");
3244 if (str && strcmp (str, "1") == 0) return 1;
3248 static int test_set_e2uuid_3 (void)
3250 if (test_set_e2uuid_3_skip ()) {
3251 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3255 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3257 char device[] = "/dev/sda";
3258 device[5] = devchar;
3261 r = guestfs_blockdev_setrw (g, device);
3268 r = guestfs_umount_all (g);
3275 r = guestfs_lvm_remove_all (g);
3280 char device[] = "/dev/sda";
3281 device[5] = devchar;
3282 char lines_0[] = ",";
3289 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3294 char fstype[] = "ext2";
3295 char device[] = "/dev/sda1";
3296 device[5] = devchar;
3299 r = guestfs_mkfs (g, fstype, device);
3304 char device[] = "/dev/sda1";
3305 device[5] = devchar;
3306 char mountpoint[] = "/";
3309 r = guestfs_mount (g, device, mountpoint);
3313 /* TestRun for set_e2uuid (3) */
3315 char device[] = "/dev/sda1";
3316 device[5] = devchar;
3317 char uuid[] = "time";
3320 r = guestfs_set_e2uuid (g, device, uuid);
3327 static int test_set_e2label_0_skip (void)
3331 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3332 if (str && strcmp (str, "1") == 0) return 1;
3333 str = getenv ("SKIP_TEST_SET_E2LABEL");
3334 if (str && strcmp (str, "1") == 0) return 1;
3338 static int test_set_e2label_0 (void)
3340 if (test_set_e2label_0_skip ()) {
3341 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3345 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3347 char device[] = "/dev/sda";
3348 device[5] = devchar;
3351 r = guestfs_blockdev_setrw (g, device);
3358 r = guestfs_umount_all (g);
3365 r = guestfs_lvm_remove_all (g);
3370 char device[] = "/dev/sda";
3371 device[5] = devchar;
3372 char lines_0[] = ",";
3379 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3384 char fstype[] = "ext2";
3385 char device[] = "/dev/sda1";
3386 device[5] = devchar;
3389 r = guestfs_mkfs (g, fstype, device);
3394 char device[] = "/dev/sda1";
3395 device[5] = devchar;
3396 char mountpoint[] = "/";
3399 r = guestfs_mount (g, device, mountpoint);
3403 /* TestOutput for set_e2label (0) */
3404 char expected[] = "testlabel";
3406 char device[] = "/dev/sda1";
3407 device[5] = devchar;
3408 char label[] = "testlabel";
3411 r = guestfs_set_e2label (g, device, label);
3416 char device[] = "/dev/sda1";
3417 device[5] = devchar;
3420 r = guestfs_get_e2label (g, device);
3423 if (strcmp (r, expected) != 0) {
3424 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3432 static int test_pvremove_0_skip (void)
3436 str = getenv ("SKIP_TEST_PVREMOVE_0");
3437 if (str && strcmp (str, "1") == 0) return 1;
3438 str = getenv ("SKIP_TEST_PVREMOVE");
3439 if (str && strcmp (str, "1") == 0) return 1;
3443 static int test_pvremove_0 (void)
3445 if (test_pvremove_0_skip ()) {
3446 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3450 /* InitNone|InitEmpty for test_pvremove_0 */
3452 char device[] = "/dev/sda";
3453 device[5] = devchar;
3456 r = guestfs_blockdev_setrw (g, device);
3463 r = guestfs_umount_all (g);
3470 r = guestfs_lvm_remove_all (g);
3474 /* TestOutputList for pvremove (0) */
3476 char device[] = "/dev/sda";
3477 device[5] = devchar;
3478 char lines_0[] = ",";
3485 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3490 char device[] = "/dev/sda1";
3491 device[5] = devchar;
3494 r = guestfs_pvcreate (g, device);
3499 char volgroup[] = "VG";
3500 char physvols_0[] = "/dev/sda1";
3501 physvols_0[5] = devchar;
3502 char *physvols[] = {
3508 r = guestfs_vgcreate (g, volgroup, physvols);
3513 char logvol[] = "LV1";
3514 char volgroup[] = "VG";
3517 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3522 char logvol[] = "LV2";
3523 char volgroup[] = "VG";
3526 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3531 char vgname[] = "VG";
3534 r = guestfs_vgremove (g, vgname);
3539 char device[] = "/dev/sda1";
3540 device[5] = devchar;
3543 r = guestfs_pvremove (g, device);
3551 r = guestfs_lvs (g);
3555 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3559 for (i = 0; r[i] != NULL; ++i)
3566 static int test_pvremove_1_skip (void)
3570 str = getenv ("SKIP_TEST_PVREMOVE_1");
3571 if (str && strcmp (str, "1") == 0) return 1;
3572 str = getenv ("SKIP_TEST_PVREMOVE");
3573 if (str && strcmp (str, "1") == 0) return 1;
3577 static int test_pvremove_1 (void)
3579 if (test_pvremove_1_skip ()) {
3580 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3584 /* InitNone|InitEmpty for test_pvremove_1 */
3586 char device[] = "/dev/sda";
3587 device[5] = devchar;
3590 r = guestfs_blockdev_setrw (g, device);
3597 r = guestfs_umount_all (g);
3604 r = guestfs_lvm_remove_all (g);
3608 /* TestOutputList for pvremove (1) */
3610 char device[] = "/dev/sda";
3611 device[5] = devchar;
3612 char lines_0[] = ",";
3619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3624 char device[] = "/dev/sda1";
3625 device[5] = devchar;
3628 r = guestfs_pvcreate (g, device);
3633 char volgroup[] = "VG";
3634 char physvols_0[] = "/dev/sda1";
3635 physvols_0[5] = devchar;
3636 char *physvols[] = {
3642 r = guestfs_vgcreate (g, volgroup, physvols);
3647 char logvol[] = "LV1";
3648 char volgroup[] = "VG";
3651 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3656 char logvol[] = "LV2";
3657 char volgroup[] = "VG";
3660 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3665 char vgname[] = "VG";
3668 r = guestfs_vgremove (g, vgname);
3673 char device[] = "/dev/sda1";
3674 device[5] = devchar;
3677 r = guestfs_pvremove (g, device);
3685 r = guestfs_vgs (g);
3689 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3693 for (i = 0; r[i] != NULL; ++i)
3700 static int test_pvremove_2_skip (void)
3704 str = getenv ("SKIP_TEST_PVREMOVE_2");
3705 if (str && strcmp (str, "1") == 0) return 1;
3706 str = getenv ("SKIP_TEST_PVREMOVE");
3707 if (str && strcmp (str, "1") == 0) return 1;
3711 static int test_pvremove_2 (void)
3713 if (test_pvremove_2_skip ()) {
3714 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3718 /* InitNone|InitEmpty for test_pvremove_2 */
3720 char device[] = "/dev/sda";
3721 device[5] = devchar;
3724 r = guestfs_blockdev_setrw (g, device);
3731 r = guestfs_umount_all (g);
3738 r = guestfs_lvm_remove_all (g);
3742 /* TestOutputList for pvremove (2) */
3744 char device[] = "/dev/sda";
3745 device[5] = devchar;
3746 char lines_0[] = ",";
3753 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3758 char device[] = "/dev/sda1";
3759 device[5] = devchar;
3762 r = guestfs_pvcreate (g, device);
3767 char volgroup[] = "VG";
3768 char physvols_0[] = "/dev/sda1";
3769 physvols_0[5] = devchar;
3770 char *physvols[] = {
3776 r = guestfs_vgcreate (g, volgroup, physvols);
3781 char logvol[] = "LV1";
3782 char volgroup[] = "VG";
3785 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3790 char logvol[] = "LV2";
3791 char volgroup[] = "VG";
3794 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3799 char vgname[] = "VG";
3802 r = guestfs_vgremove (g, vgname);
3807 char device[] = "/dev/sda1";
3808 device[5] = devchar;
3811 r = guestfs_pvremove (g, device);
3819 r = guestfs_pvs (g);
3823 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3827 for (i = 0; r[i] != NULL; ++i)
3834 static int test_vgremove_0_skip (void)
3838 str = getenv ("SKIP_TEST_VGREMOVE_0");
3839 if (str && strcmp (str, "1") == 0) return 1;
3840 str = getenv ("SKIP_TEST_VGREMOVE");
3841 if (str && strcmp (str, "1") == 0) return 1;
3845 static int test_vgremove_0 (void)
3847 if (test_vgremove_0_skip ()) {
3848 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3852 /* InitNone|InitEmpty for test_vgremove_0 */
3854 char device[] = "/dev/sda";
3855 device[5] = devchar;
3858 r = guestfs_blockdev_setrw (g, device);
3865 r = guestfs_umount_all (g);
3872 r = guestfs_lvm_remove_all (g);
3876 /* TestOutputList for vgremove (0) */
3878 char device[] = "/dev/sda";
3879 device[5] = devchar;
3880 char lines_0[] = ",";
3887 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3892 char device[] = "/dev/sda1";
3893 device[5] = devchar;
3896 r = guestfs_pvcreate (g, device);
3901 char volgroup[] = "VG";
3902 char physvols_0[] = "/dev/sda1";
3903 physvols_0[5] = devchar;
3904 char *physvols[] = {
3910 r = guestfs_vgcreate (g, volgroup, physvols);
3915 char logvol[] = "LV1";
3916 char volgroup[] = "VG";
3919 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3924 char logvol[] = "LV2";
3925 char volgroup[] = "VG";
3928 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3933 char vgname[] = "VG";
3936 r = guestfs_vgremove (g, vgname);
3944 r = guestfs_lvs (g);
3948 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3952 for (i = 0; r[i] != NULL; ++i)
3959 static int test_vgremove_1_skip (void)
3963 str = getenv ("SKIP_TEST_VGREMOVE_1");
3964 if (str && strcmp (str, "1") == 0) return 1;
3965 str = getenv ("SKIP_TEST_VGREMOVE");
3966 if (str && strcmp (str, "1") == 0) return 1;
3970 static int test_vgremove_1 (void)
3972 if (test_vgremove_1_skip ()) {
3973 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
3977 /* InitNone|InitEmpty for test_vgremove_1 */
3979 char device[] = "/dev/sda";
3980 device[5] = devchar;
3983 r = guestfs_blockdev_setrw (g, device);
3990 r = guestfs_umount_all (g);
3997 r = guestfs_lvm_remove_all (g);
4001 /* TestOutputList for vgremove (1) */
4003 char device[] = "/dev/sda";
4004 device[5] = devchar;
4005 char lines_0[] = ",";
4012 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4017 char device[] = "/dev/sda1";
4018 device[5] = devchar;
4021 r = guestfs_pvcreate (g, device);
4026 char volgroup[] = "VG";
4027 char physvols_0[] = "/dev/sda1";
4028 physvols_0[5] = devchar;
4029 char *physvols[] = {
4035 r = guestfs_vgcreate (g, volgroup, physvols);
4040 char logvol[] = "LV1";
4041 char volgroup[] = "VG";
4044 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4049 char logvol[] = "LV2";
4050 char volgroup[] = "VG";
4053 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4058 char vgname[] = "VG";
4061 r = guestfs_vgremove (g, vgname);
4069 r = guestfs_vgs (g);
4073 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4077 for (i = 0; r[i] != NULL; ++i)
4084 static int test_lvremove_0_skip (void)
4088 str = getenv ("SKIP_TEST_LVREMOVE_0");
4089 if (str && strcmp (str, "1") == 0) return 1;
4090 str = getenv ("SKIP_TEST_LVREMOVE");
4091 if (str && strcmp (str, "1") == 0) return 1;
4095 static int test_lvremove_0 (void)
4097 if (test_lvremove_0_skip ()) {
4098 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4102 /* InitNone|InitEmpty for test_lvremove_0 */
4104 char device[] = "/dev/sda";
4105 device[5] = devchar;
4108 r = guestfs_blockdev_setrw (g, device);
4115 r = guestfs_umount_all (g);
4122 r = guestfs_lvm_remove_all (g);
4126 /* TestOutputList for lvremove (0) */
4128 char device[] = "/dev/sda";
4129 device[5] = devchar;
4130 char lines_0[] = ",";
4137 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4142 char device[] = "/dev/sda1";
4143 device[5] = devchar;
4146 r = guestfs_pvcreate (g, device);
4151 char volgroup[] = "VG";
4152 char physvols_0[] = "/dev/sda1";
4153 physvols_0[5] = devchar;
4154 char *physvols[] = {
4160 r = guestfs_vgcreate (g, volgroup, physvols);
4165 char logvol[] = "LV1";
4166 char volgroup[] = "VG";
4169 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4174 char logvol[] = "LV2";
4175 char volgroup[] = "VG";
4178 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4183 char device[] = "/dev/VG/LV1";
4186 r = guestfs_lvremove (g, device);
4194 r = guestfs_lvs (g);
4198 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4203 char expected[] = "/dev/VG/LV2";
4204 if (strcmp (r[0], expected) != 0) {
4205 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4210 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4214 for (i = 0; r[i] != NULL; ++i)
4221 static int test_lvremove_1_skip (void)
4225 str = getenv ("SKIP_TEST_LVREMOVE_1");
4226 if (str && strcmp (str, "1") == 0) return 1;
4227 str = getenv ("SKIP_TEST_LVREMOVE");
4228 if (str && strcmp (str, "1") == 0) return 1;
4232 static int test_lvremove_1 (void)
4234 if (test_lvremove_1_skip ()) {
4235 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4239 /* InitNone|InitEmpty for test_lvremove_1 */
4241 char device[] = "/dev/sda";
4242 device[5] = devchar;
4245 r = guestfs_blockdev_setrw (g, device);
4252 r = guestfs_umount_all (g);
4259 r = guestfs_lvm_remove_all (g);
4263 /* TestOutputList for lvremove (1) */
4265 char device[] = "/dev/sda";
4266 device[5] = devchar;
4267 char lines_0[] = ",";
4274 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4279 char device[] = "/dev/sda1";
4280 device[5] = devchar;
4283 r = guestfs_pvcreate (g, device);
4288 char volgroup[] = "VG";
4289 char physvols_0[] = "/dev/sda1";
4290 physvols_0[5] = devchar;
4291 char *physvols[] = {
4297 r = guestfs_vgcreate (g, volgroup, physvols);
4302 char logvol[] = "LV1";
4303 char volgroup[] = "VG";
4306 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4311 char logvol[] = "LV2";
4312 char volgroup[] = "VG";
4315 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4320 char device[] = "/dev/VG";
4323 r = guestfs_lvremove (g, device);
4331 r = guestfs_lvs (g);
4335 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4339 for (i = 0; r[i] != NULL; ++i)
4346 static int test_lvremove_2_skip (void)
4350 str = getenv ("SKIP_TEST_LVREMOVE_2");
4351 if (str && strcmp (str, "1") == 0) return 1;
4352 str = getenv ("SKIP_TEST_LVREMOVE");
4353 if (str && strcmp (str, "1") == 0) return 1;
4357 static int test_lvremove_2 (void)
4359 if (test_lvremove_2_skip ()) {
4360 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4364 /* InitNone|InitEmpty for test_lvremove_2 */
4366 char device[] = "/dev/sda";
4367 device[5] = devchar;
4370 r = guestfs_blockdev_setrw (g, device);
4377 r = guestfs_umount_all (g);
4384 r = guestfs_lvm_remove_all (g);
4388 /* TestOutputList for lvremove (2) */
4390 char device[] = "/dev/sda";
4391 device[5] = devchar;
4392 char lines_0[] = ",";
4399 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4404 char device[] = "/dev/sda1";
4405 device[5] = devchar;
4408 r = guestfs_pvcreate (g, device);
4413 char volgroup[] = "VG";
4414 char physvols_0[] = "/dev/sda1";
4415 physvols_0[5] = devchar;
4416 char *physvols[] = {
4422 r = guestfs_vgcreate (g, volgroup, physvols);
4427 char logvol[] = "LV1";
4428 char volgroup[] = "VG";
4431 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4436 char logvol[] = "LV2";
4437 char volgroup[] = "VG";
4440 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4445 char device[] = "/dev/VG";
4448 r = guestfs_lvremove (g, device);
4456 r = guestfs_vgs (g);
4460 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4465 char expected[] = "VG";
4466 if (strcmp (r[0], expected) != 0) {
4467 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4472 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4476 for (i = 0; r[i] != NULL; ++i)
4483 static int test_mount_ro_0_skip (void)
4487 str = getenv ("SKIP_TEST_MOUNT_RO_0");
4488 if (str && strcmp (str, "1") == 0) return 1;
4489 str = getenv ("SKIP_TEST_MOUNT_RO");
4490 if (str && strcmp (str, "1") == 0) return 1;
4494 static int test_mount_ro_0 (void)
4496 if (test_mount_ro_0_skip ()) {
4497 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4501 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4503 char device[] = "/dev/sda";
4504 device[5] = devchar;
4507 r = guestfs_blockdev_setrw (g, device);
4514 r = guestfs_umount_all (g);
4521 r = guestfs_lvm_remove_all (g);
4526 char device[] = "/dev/sda";
4527 device[5] = devchar;
4528 char lines_0[] = ",";
4535 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4540 char fstype[] = "ext2";
4541 char device[] = "/dev/sda1";
4542 device[5] = devchar;
4545 r = guestfs_mkfs (g, fstype, device);
4550 char device[] = "/dev/sda1";
4551 device[5] = devchar;
4552 char mountpoint[] = "/";
4555 r = guestfs_mount (g, device, mountpoint);
4559 /* TestLastFail for mount_ro (0) */
4561 char pathordevice[] = "/";
4564 r = guestfs_umount (g, pathordevice);
4569 char device[] = "/dev/sda1";
4570 device[5] = devchar;
4571 char mountpoint[] = "/";
4574 r = guestfs_mount_ro (g, device, mountpoint);
4579 char path[] = "/new";
4582 r = guestfs_touch (g, path);
4589 static int test_mount_ro_1_skip (void)
4593 str = getenv ("SKIP_TEST_MOUNT_RO_1");
4594 if (str && strcmp (str, "1") == 0) return 1;
4595 str = getenv ("SKIP_TEST_MOUNT_RO");
4596 if (str && strcmp (str, "1") == 0) return 1;
4600 static int test_mount_ro_1 (void)
4602 if (test_mount_ro_1_skip ()) {
4603 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4607 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4609 char device[] = "/dev/sda";
4610 device[5] = devchar;
4613 r = guestfs_blockdev_setrw (g, device);
4620 r = guestfs_umount_all (g);
4627 r = guestfs_lvm_remove_all (g);
4632 char device[] = "/dev/sda";
4633 device[5] = devchar;
4634 char lines_0[] = ",";
4641 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4646 char fstype[] = "ext2";
4647 char device[] = "/dev/sda1";
4648 device[5] = devchar;
4651 r = guestfs_mkfs (g, fstype, device);
4656 char device[] = "/dev/sda1";
4657 device[5] = devchar;
4658 char mountpoint[] = "/";
4661 r = guestfs_mount (g, device, mountpoint);
4665 /* TestOutput for mount_ro (1) */
4666 char expected[] = "data";
4668 char path[] = "/new";
4669 char content[] = "data";
4672 r = guestfs_write_file (g, path, content, 0);
4677 char pathordevice[] = "/";
4680 r = guestfs_umount (g, pathordevice);
4685 char device[] = "/dev/sda1";
4686 device[5] = devchar;
4687 char mountpoint[] = "/";
4690 r = guestfs_mount_ro (g, device, mountpoint);
4695 char path[] = "/new";
4698 r = guestfs_cat (g, path);
4701 if (strcmp (r, expected) != 0) {
4702 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4710 static int test_tgz_in_0_skip (void)
4714 str = getenv ("SKIP_TEST_TGZ_IN_0");
4715 if (str && strcmp (str, "1") == 0) return 1;
4716 str = getenv ("SKIP_TEST_TGZ_IN");
4717 if (str && strcmp (str, "1") == 0) return 1;
4721 static int test_tgz_in_0 (void)
4723 if (test_tgz_in_0_skip ()) {
4724 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4728 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4730 char device[] = "/dev/sda";
4731 device[5] = devchar;
4734 r = guestfs_blockdev_setrw (g, device);
4741 r = guestfs_umount_all (g);
4748 r = guestfs_lvm_remove_all (g);
4753 char device[] = "/dev/sda";
4754 device[5] = devchar;
4755 char lines_0[] = ",";
4762 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4767 char fstype[] = "ext2";
4768 char device[] = "/dev/sda1";
4769 device[5] = devchar;
4772 r = guestfs_mkfs (g, fstype, device);
4777 char device[] = "/dev/sda1";
4778 device[5] = devchar;
4779 char mountpoint[] = "/";
4782 r = guestfs_mount (g, device, mountpoint);
4786 /* TestOutput for tgz_in (0) */
4787 char expected[] = "hello\n";
4789 char directory[] = "/";
4792 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4797 char path[] = "/hello";
4800 r = guestfs_cat (g, path);
4803 if (strcmp (r, expected) != 0) {
4804 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4812 static int test_tar_in_0_skip (void)
4816 str = getenv ("SKIP_TEST_TAR_IN_0");
4817 if (str && strcmp (str, "1") == 0) return 1;
4818 str = getenv ("SKIP_TEST_TAR_IN");
4819 if (str && strcmp (str, "1") == 0) return 1;
4823 static int test_tar_in_0 (void)
4825 if (test_tar_in_0_skip ()) {
4826 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4830 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4832 char device[] = "/dev/sda";
4833 device[5] = devchar;
4836 r = guestfs_blockdev_setrw (g, device);
4843 r = guestfs_umount_all (g);
4850 r = guestfs_lvm_remove_all (g);
4855 char device[] = "/dev/sda";
4856 device[5] = devchar;
4857 char lines_0[] = ",";
4864 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4869 char fstype[] = "ext2";
4870 char device[] = "/dev/sda1";
4871 device[5] = devchar;
4874 r = guestfs_mkfs (g, fstype, device);
4879 char device[] = "/dev/sda1";
4880 device[5] = devchar;
4881 char mountpoint[] = "/";
4884 r = guestfs_mount (g, device, mountpoint);
4888 /* TestOutput for tar_in (0) */
4889 char expected[] = "hello\n";
4891 char directory[] = "/";
4894 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4899 char path[] = "/hello";
4902 r = guestfs_cat (g, path);
4905 if (strcmp (r, expected) != 0) {
4906 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4914 static int test_checksum_0_skip (void)
4918 str = getenv ("SKIP_TEST_CHECKSUM_0");
4919 if (str && strcmp (str, "1") == 0) return 1;
4920 str = getenv ("SKIP_TEST_CHECKSUM");
4921 if (str && strcmp (str, "1") == 0) return 1;
4925 static int test_checksum_0 (void)
4927 if (test_checksum_0_skip ()) {
4928 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4932 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4934 char device[] = "/dev/sda";
4935 device[5] = devchar;
4938 r = guestfs_blockdev_setrw (g, device);
4945 r = guestfs_umount_all (g);
4952 r = guestfs_lvm_remove_all (g);
4957 char device[] = "/dev/sda";
4958 device[5] = devchar;
4959 char lines_0[] = ",";
4966 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4971 char fstype[] = "ext2";
4972 char device[] = "/dev/sda1";
4973 device[5] = devchar;
4976 r = guestfs_mkfs (g, fstype, device);
4981 char device[] = "/dev/sda1";
4982 device[5] = devchar;
4983 char mountpoint[] = "/";
4986 r = guestfs_mount (g, device, mountpoint);
4990 /* TestOutput for checksum (0) */
4991 char expected[] = "935282863";
4993 char path[] = "/new";
4994 char content[] = "test\n";
4997 r = guestfs_write_file (g, path, content, 0);
5002 char csumtype[] = "crc";
5003 char path[] = "/new";
5006 r = guestfs_checksum (g, csumtype, path);
5009 if (strcmp (r, expected) != 0) {
5010 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5018 static int test_checksum_1_skip (void)
5022 str = getenv ("SKIP_TEST_CHECKSUM_1");
5023 if (str && strcmp (str, "1") == 0) return 1;
5024 str = getenv ("SKIP_TEST_CHECKSUM");
5025 if (str && strcmp (str, "1") == 0) return 1;
5029 static int test_checksum_1 (void)
5031 if (test_checksum_1_skip ()) {
5032 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5036 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5038 char device[] = "/dev/sda";
5039 device[5] = devchar;
5042 r = guestfs_blockdev_setrw (g, device);
5049 r = guestfs_umount_all (g);
5056 r = guestfs_lvm_remove_all (g);
5061 char device[] = "/dev/sda";
5062 device[5] = devchar;
5063 char lines_0[] = ",";
5070 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5075 char fstype[] = "ext2";
5076 char device[] = "/dev/sda1";
5077 device[5] = devchar;
5080 r = guestfs_mkfs (g, fstype, device);
5085 char device[] = "/dev/sda1";
5086 device[5] = devchar;
5087 char mountpoint[] = "/";
5090 r = guestfs_mount (g, device, mountpoint);
5094 /* TestLastFail for checksum (1) */
5096 char csumtype[] = "crc";
5097 char path[] = "/new";
5100 r = guestfs_checksum (g, csumtype, path);
5108 static int test_checksum_2_skip (void)
5112 str = getenv ("SKIP_TEST_CHECKSUM_2");
5113 if (str && strcmp (str, "1") == 0) return 1;
5114 str = getenv ("SKIP_TEST_CHECKSUM");
5115 if (str && strcmp (str, "1") == 0) return 1;
5119 static int test_checksum_2 (void)
5121 if (test_checksum_2_skip ()) {
5122 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5126 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5128 char device[] = "/dev/sda";
5129 device[5] = devchar;
5132 r = guestfs_blockdev_setrw (g, device);
5139 r = guestfs_umount_all (g);
5146 r = guestfs_lvm_remove_all (g);
5151 char device[] = "/dev/sda";
5152 device[5] = devchar;
5153 char lines_0[] = ",";
5160 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5165 char fstype[] = "ext2";
5166 char device[] = "/dev/sda1";
5167 device[5] = devchar;
5170 r = guestfs_mkfs (g, fstype, device);
5175 char device[] = "/dev/sda1";
5176 device[5] = devchar;
5177 char mountpoint[] = "/";
5180 r = guestfs_mount (g, device, mountpoint);
5184 /* TestOutput for checksum (2) */
5185 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5187 char path[] = "/new";
5188 char content[] = "test\n";
5191 r = guestfs_write_file (g, path, content, 0);
5196 char csumtype[] = "md5";
5197 char path[] = "/new";
5200 r = guestfs_checksum (g, csumtype, path);
5203 if (strcmp (r, expected) != 0) {
5204 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5212 static int test_checksum_3_skip (void)
5216 str = getenv ("SKIP_TEST_CHECKSUM_3");
5217 if (str && strcmp (str, "1") == 0) return 1;
5218 str = getenv ("SKIP_TEST_CHECKSUM");
5219 if (str && strcmp (str, "1") == 0) return 1;
5223 static int test_checksum_3 (void)
5225 if (test_checksum_3_skip ()) {
5226 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5230 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5232 char device[] = "/dev/sda";
5233 device[5] = devchar;
5236 r = guestfs_blockdev_setrw (g, device);
5243 r = guestfs_umount_all (g);
5250 r = guestfs_lvm_remove_all (g);
5255 char device[] = "/dev/sda";
5256 device[5] = devchar;
5257 char lines_0[] = ",";
5264 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5269 char fstype[] = "ext2";
5270 char device[] = "/dev/sda1";
5271 device[5] = devchar;
5274 r = guestfs_mkfs (g, fstype, device);
5279 char device[] = "/dev/sda1";
5280 device[5] = devchar;
5281 char mountpoint[] = "/";
5284 r = guestfs_mount (g, device, mountpoint);
5288 /* TestOutput for checksum (3) */
5289 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5291 char path[] = "/new";
5292 char content[] = "test\n";
5295 r = guestfs_write_file (g, path, content, 0);
5300 char csumtype[] = "sha1";
5301 char path[] = "/new";
5304 r = guestfs_checksum (g, csumtype, path);
5307 if (strcmp (r, expected) != 0) {
5308 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5316 static int test_checksum_4_skip (void)
5320 str = getenv ("SKIP_TEST_CHECKSUM_4");
5321 if (str && strcmp (str, "1") == 0) return 1;
5322 str = getenv ("SKIP_TEST_CHECKSUM");
5323 if (str && strcmp (str, "1") == 0) return 1;
5327 static int test_checksum_4 (void)
5329 if (test_checksum_4_skip ()) {
5330 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5334 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5336 char device[] = "/dev/sda";
5337 device[5] = devchar;
5340 r = guestfs_blockdev_setrw (g, device);
5347 r = guestfs_umount_all (g);
5354 r = guestfs_lvm_remove_all (g);
5359 char device[] = "/dev/sda";
5360 device[5] = devchar;
5361 char lines_0[] = ",";
5368 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5373 char fstype[] = "ext2";
5374 char device[] = "/dev/sda1";
5375 device[5] = devchar;
5378 r = guestfs_mkfs (g, fstype, device);
5383 char device[] = "/dev/sda1";
5384 device[5] = devchar;
5385 char mountpoint[] = "/";
5388 r = guestfs_mount (g, device, mountpoint);
5392 /* TestOutput for checksum (4) */
5393 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5395 char path[] = "/new";
5396 char content[] = "test\n";
5399 r = guestfs_write_file (g, path, content, 0);
5404 char csumtype[] = "sha224";
5405 char path[] = "/new";
5408 r = guestfs_checksum (g, csumtype, path);
5411 if (strcmp (r, expected) != 0) {
5412 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5420 static int test_checksum_5_skip (void)
5424 str = getenv ("SKIP_TEST_CHECKSUM_5");
5425 if (str && strcmp (str, "1") == 0) return 1;
5426 str = getenv ("SKIP_TEST_CHECKSUM");
5427 if (str && strcmp (str, "1") == 0) return 1;
5431 static int test_checksum_5 (void)
5433 if (test_checksum_5_skip ()) {
5434 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5438 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5440 char device[] = "/dev/sda";
5441 device[5] = devchar;
5444 r = guestfs_blockdev_setrw (g, device);
5451 r = guestfs_umount_all (g);
5458 r = guestfs_lvm_remove_all (g);
5463 char device[] = "/dev/sda";
5464 device[5] = devchar;
5465 char lines_0[] = ",";
5472 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5477 char fstype[] = "ext2";
5478 char device[] = "/dev/sda1";
5479 device[5] = devchar;
5482 r = guestfs_mkfs (g, fstype, device);
5487 char device[] = "/dev/sda1";
5488 device[5] = devchar;
5489 char mountpoint[] = "/";
5492 r = guestfs_mount (g, device, mountpoint);
5496 /* TestOutput for checksum (5) */
5497 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5499 char path[] = "/new";
5500 char content[] = "test\n";
5503 r = guestfs_write_file (g, path, content, 0);
5508 char csumtype[] = "sha256";
5509 char path[] = "/new";
5512 r = guestfs_checksum (g, csumtype, path);
5515 if (strcmp (r, expected) != 0) {
5516 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5524 static int test_checksum_6_skip (void)
5528 str = getenv ("SKIP_TEST_CHECKSUM_6");
5529 if (str && strcmp (str, "1") == 0) return 1;
5530 str = getenv ("SKIP_TEST_CHECKSUM");
5531 if (str && strcmp (str, "1") == 0) return 1;
5535 static int test_checksum_6 (void)
5537 if (test_checksum_6_skip ()) {
5538 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5542 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5544 char device[] = "/dev/sda";
5545 device[5] = devchar;
5548 r = guestfs_blockdev_setrw (g, device);
5555 r = guestfs_umount_all (g);
5562 r = guestfs_lvm_remove_all (g);
5567 char device[] = "/dev/sda";
5568 device[5] = devchar;
5569 char lines_0[] = ",";
5576 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5581 char fstype[] = "ext2";
5582 char device[] = "/dev/sda1";
5583 device[5] = devchar;
5586 r = guestfs_mkfs (g, fstype, device);
5591 char device[] = "/dev/sda1";
5592 device[5] = devchar;
5593 char mountpoint[] = "/";
5596 r = guestfs_mount (g, device, mountpoint);
5600 /* TestOutput for checksum (6) */
5601 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5603 char path[] = "/new";
5604 char content[] = "test\n";
5607 r = guestfs_write_file (g, path, content, 0);
5612 char csumtype[] = "sha384";
5613 char path[] = "/new";
5616 r = guestfs_checksum (g, csumtype, path);
5619 if (strcmp (r, expected) != 0) {
5620 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5628 static int test_checksum_7_skip (void)
5632 str = getenv ("SKIP_TEST_CHECKSUM_7");
5633 if (str && strcmp (str, "1") == 0) return 1;
5634 str = getenv ("SKIP_TEST_CHECKSUM");
5635 if (str && strcmp (str, "1") == 0) return 1;
5639 static int test_checksum_7 (void)
5641 if (test_checksum_7_skip ()) {
5642 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5646 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5648 char device[] = "/dev/sda";
5649 device[5] = devchar;
5652 r = guestfs_blockdev_setrw (g, device);
5659 r = guestfs_umount_all (g);
5666 r = guestfs_lvm_remove_all (g);
5671 char device[] = "/dev/sda";
5672 device[5] = devchar;
5673 char lines_0[] = ",";
5680 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5685 char fstype[] = "ext2";
5686 char device[] = "/dev/sda1";
5687 device[5] = devchar;
5690 r = guestfs_mkfs (g, fstype, device);
5695 char device[] = "/dev/sda1";
5696 device[5] = devchar;
5697 char mountpoint[] = "/";
5700 r = guestfs_mount (g, device, mountpoint);
5704 /* TestOutput for checksum (7) */
5705 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5707 char path[] = "/new";
5708 char content[] = "test\n";
5711 r = guestfs_write_file (g, path, content, 0);
5716 char csumtype[] = "sha512";
5717 char path[] = "/new";
5720 r = guestfs_checksum (g, csumtype, path);
5723 if (strcmp (r, expected) != 0) {
5724 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5732 static int test_download_0_skip (void)
5736 str = getenv ("SKIP_TEST_DOWNLOAD_0");
5737 if (str && strcmp (str, "1") == 0) return 1;
5738 str = getenv ("SKIP_TEST_DOWNLOAD");
5739 if (str && strcmp (str, "1") == 0) return 1;
5743 static int test_download_0 (void)
5745 if (test_download_0_skip ()) {
5746 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5750 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5752 char device[] = "/dev/sda";
5753 device[5] = devchar;
5756 r = guestfs_blockdev_setrw (g, device);
5763 r = guestfs_umount_all (g);
5770 r = guestfs_lvm_remove_all (g);
5775 char device[] = "/dev/sda";
5776 device[5] = devchar;
5777 char lines_0[] = ",";
5784 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5789 char fstype[] = "ext2";
5790 char device[] = "/dev/sda1";
5791 device[5] = devchar;
5794 r = guestfs_mkfs (g, fstype, device);
5799 char device[] = "/dev/sda1";
5800 device[5] = devchar;
5801 char mountpoint[] = "/";
5804 r = guestfs_mount (g, device, mountpoint);
5808 /* TestOutput for download (0) */
5809 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5811 char remotefilename[] = "/COPYING.LIB";
5814 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5819 char remotefilename[] = "/COPYING.LIB";
5822 r = guestfs_download (g, remotefilename, "testdownload.tmp");
5827 char remotefilename[] = "/upload";
5830 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5835 char csumtype[] = "md5";
5836 char path[] = "/upload";
5839 r = guestfs_checksum (g, csumtype, path);
5842 if (strcmp (r, expected) != 0) {
5843 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5851 static int test_upload_0_skip (void)
5855 str = getenv ("SKIP_TEST_UPLOAD_0");
5856 if (str && strcmp (str, "1") == 0) return 1;
5857 str = getenv ("SKIP_TEST_UPLOAD");
5858 if (str && strcmp (str, "1") == 0) return 1;
5862 static int test_upload_0 (void)
5864 if (test_upload_0_skip ()) {
5865 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5869 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5871 char device[] = "/dev/sda";
5872 device[5] = devchar;
5875 r = guestfs_blockdev_setrw (g, device);
5882 r = guestfs_umount_all (g);
5889 r = guestfs_lvm_remove_all (g);
5894 char device[] = "/dev/sda";
5895 device[5] = devchar;
5896 char lines_0[] = ",";
5903 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5908 char fstype[] = "ext2";
5909 char device[] = "/dev/sda1";
5910 device[5] = devchar;
5913 r = guestfs_mkfs (g, fstype, device);
5918 char device[] = "/dev/sda1";
5919 device[5] = devchar;
5920 char mountpoint[] = "/";
5923 r = guestfs_mount (g, device, mountpoint);
5927 /* TestOutput for upload (0) */
5928 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5930 char remotefilename[] = "/COPYING.LIB";
5933 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5938 char csumtype[] = "md5";
5939 char path[] = "/COPYING.LIB";
5942 r = guestfs_checksum (g, csumtype, path);
5945 if (strcmp (r, expected) != 0) {
5946 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
5954 static int test_blockdev_rereadpt_0_skip (void)
5958 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
5959 if (str && strcmp (str, "1") == 0) return 1;
5960 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
5961 if (str && strcmp (str, "1") == 0) return 1;
5965 static int test_blockdev_rereadpt_0 (void)
5967 if (test_blockdev_rereadpt_0_skip ()) {
5968 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
5972 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
5974 char device[] = "/dev/sda";
5975 device[5] = devchar;
5978 r = guestfs_blockdev_setrw (g, device);
5985 r = guestfs_umount_all (g);
5992 r = guestfs_lvm_remove_all (g);
5996 /* TestRun for blockdev_rereadpt (0) */
5998 char device[] = "/dev/sda";
5999 device[5] = devchar;
6002 r = guestfs_blockdev_rereadpt (g, device);
6009 static int test_blockdev_flushbufs_0_skip (void)
6013 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6014 if (str && strcmp (str, "1") == 0) return 1;
6015 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6016 if (str && strcmp (str, "1") == 0) return 1;
6020 static int test_blockdev_flushbufs_0 (void)
6022 if (test_blockdev_flushbufs_0_skip ()) {
6023 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6027 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6029 char device[] = "/dev/sda";
6030 device[5] = devchar;
6033 r = guestfs_blockdev_setrw (g, device);
6040 r = guestfs_umount_all (g);
6047 r = guestfs_lvm_remove_all (g);
6051 /* TestRun for blockdev_flushbufs (0) */
6053 char device[] = "/dev/sda";
6054 device[5] = devchar;
6057 r = guestfs_blockdev_flushbufs (g, device);
6064 static int test_blockdev_getsize64_0_skip (void)
6068 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6069 if (str && strcmp (str, "1") == 0) return 1;
6070 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6071 if (str && strcmp (str, "1") == 0) return 1;
6075 static int test_blockdev_getsize64_0 (void)
6077 if (test_blockdev_getsize64_0_skip ()) {
6078 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6082 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6084 char device[] = "/dev/sda";
6085 device[5] = devchar;
6088 r = guestfs_blockdev_setrw (g, device);
6095 r = guestfs_umount_all (g);
6102 r = guestfs_lvm_remove_all (g);
6106 /* TestOutputInt for blockdev_getsize64 (0) */
6108 char device[] = "/dev/sda";
6109 device[5] = devchar;
6112 r = guestfs_blockdev_getsize64 (g, device);
6115 if (r != 524288000) {
6116 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6123 static int test_blockdev_getsz_0_skip (void)
6127 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6128 if (str && strcmp (str, "1") == 0) return 1;
6129 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6130 if (str && strcmp (str, "1") == 0) return 1;
6134 static int test_blockdev_getsz_0 (void)
6136 if (test_blockdev_getsz_0_skip ()) {
6137 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6141 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6143 char device[] = "/dev/sda";
6144 device[5] = devchar;
6147 r = guestfs_blockdev_setrw (g, device);
6154 r = guestfs_umount_all (g);
6161 r = guestfs_lvm_remove_all (g);
6165 /* TestOutputInt for blockdev_getsz (0) */
6167 char device[] = "/dev/sda";
6168 device[5] = devchar;
6171 r = guestfs_blockdev_getsz (g, device);
6175 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6182 static int test_blockdev_getbsz_0_skip (void)
6186 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6187 if (str && strcmp (str, "1") == 0) return 1;
6188 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6189 if (str && strcmp (str, "1") == 0) return 1;
6193 static int test_blockdev_getbsz_0 (void)
6195 if (test_blockdev_getbsz_0_skip ()) {
6196 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6200 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6202 char device[] = "/dev/sda";
6203 device[5] = devchar;
6206 r = guestfs_blockdev_setrw (g, device);
6213 r = guestfs_umount_all (g);
6220 r = guestfs_lvm_remove_all (g);
6224 /* TestOutputInt for blockdev_getbsz (0) */
6226 char device[] = "/dev/sda";
6227 device[5] = devchar;
6230 r = guestfs_blockdev_getbsz (g, device);
6234 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6241 static int test_blockdev_getss_0_skip (void)
6245 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6246 if (str && strcmp (str, "1") == 0) return 1;
6247 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6248 if (str && strcmp (str, "1") == 0) return 1;
6252 static int test_blockdev_getss_0 (void)
6254 if (test_blockdev_getss_0_skip ()) {
6255 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6259 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6261 char device[] = "/dev/sda";
6262 device[5] = devchar;
6265 r = guestfs_blockdev_setrw (g, device);
6272 r = guestfs_umount_all (g);
6279 r = guestfs_lvm_remove_all (g);
6283 /* TestOutputInt for blockdev_getss (0) */
6285 char device[] = "/dev/sda";
6286 device[5] = devchar;
6289 r = guestfs_blockdev_getss (g, device);
6293 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6300 static int test_blockdev_getro_0_skip (void)
6304 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6305 if (str && strcmp (str, "1") == 0) return 1;
6306 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6307 if (str && strcmp (str, "1") == 0) return 1;
6311 static int test_blockdev_getro_0 (void)
6313 if (test_blockdev_getro_0_skip ()) {
6314 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6318 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6320 char device[] = "/dev/sda";
6321 device[5] = devchar;
6324 r = guestfs_blockdev_setrw (g, device);
6331 r = guestfs_umount_all (g);
6338 r = guestfs_lvm_remove_all (g);
6342 /* TestOutputTrue for blockdev_getro (0) */
6344 char device[] = "/dev/sda";
6345 device[5] = devchar;
6348 r = guestfs_blockdev_setro (g, device);
6353 char device[] = "/dev/sda";
6354 device[5] = devchar;
6357 r = guestfs_blockdev_getro (g, device);
6361 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6368 static int test_blockdev_setrw_0_skip (void)
6372 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6373 if (str && strcmp (str, "1") == 0) return 1;
6374 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6375 if (str && strcmp (str, "1") == 0) return 1;
6379 static int test_blockdev_setrw_0 (void)
6381 if (test_blockdev_setrw_0_skip ()) {
6382 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6386 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6388 char device[] = "/dev/sda";
6389 device[5] = devchar;
6392 r = guestfs_blockdev_setrw (g, device);
6399 r = guestfs_umount_all (g);
6406 r = guestfs_lvm_remove_all (g);
6410 /* TestOutputFalse for blockdev_setrw (0) */
6412 char device[] = "/dev/sda";
6413 device[5] = devchar;
6416 r = guestfs_blockdev_setrw (g, device);
6421 char device[] = "/dev/sda";
6422 device[5] = devchar;
6425 r = guestfs_blockdev_getro (g, device);
6429 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6436 static int test_blockdev_setro_0_skip (void)
6440 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6441 if (str && strcmp (str, "1") == 0) return 1;
6442 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6443 if (str && strcmp (str, "1") == 0) return 1;
6447 static int test_blockdev_setro_0 (void)
6449 if (test_blockdev_setro_0_skip ()) {
6450 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6454 /* InitNone|InitEmpty for test_blockdev_setro_0 */
6456 char device[] = "/dev/sda";
6457 device[5] = devchar;
6460 r = guestfs_blockdev_setrw (g, device);
6467 r = guestfs_umount_all (g);
6474 r = guestfs_lvm_remove_all (g);
6478 /* TestOutputTrue for blockdev_setro (0) */
6480 char device[] = "/dev/sda";
6481 device[5] = devchar;
6484 r = guestfs_blockdev_setro (g, device);
6489 char device[] = "/dev/sda";
6490 device[5] = devchar;
6493 r = guestfs_blockdev_getro (g, device);
6497 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6504 static int test_statvfs_0_skip (void)
6508 str = getenv ("SKIP_TEST_STATVFS_0");
6509 if (str && strcmp (str, "1") == 0) return 1;
6510 str = getenv ("SKIP_TEST_STATVFS");
6511 if (str && strcmp (str, "1") == 0) return 1;
6515 static int test_statvfs_0 (void)
6517 if (test_statvfs_0_skip ()) {
6518 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6522 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6524 char device[] = "/dev/sda";
6525 device[5] = devchar;
6528 r = guestfs_blockdev_setrw (g, device);
6535 r = guestfs_umount_all (g);
6542 r = guestfs_lvm_remove_all (g);
6547 char device[] = "/dev/sda";
6548 device[5] = devchar;
6549 char lines_0[] = ",";
6556 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6561 char fstype[] = "ext2";
6562 char device[] = "/dev/sda1";
6563 device[5] = devchar;
6566 r = guestfs_mkfs (g, fstype, device);
6571 char device[] = "/dev/sda1";
6572 device[5] = devchar;
6573 char mountpoint[] = "/";
6576 r = guestfs_mount (g, device, mountpoint);
6580 /* TestOutputStruct for statvfs (0) */
6583 struct guestfs_statvfs *r;
6585 r = guestfs_statvfs (g, path);
6588 if (r->bfree != 487702) {
6589 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6593 if (r->blocks != 490020) {
6594 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6598 if (r->bsize != 1024) {
6599 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6608 static int test_lstat_0_skip (void)
6612 str = getenv ("SKIP_TEST_LSTAT_0");
6613 if (str && strcmp (str, "1") == 0) return 1;
6614 str = getenv ("SKIP_TEST_LSTAT");
6615 if (str && strcmp (str, "1") == 0) return 1;
6619 static int test_lstat_0 (void)
6621 if (test_lstat_0_skip ()) {
6622 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6626 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6628 char device[] = "/dev/sda";
6629 device[5] = devchar;
6632 r = guestfs_blockdev_setrw (g, device);
6639 r = guestfs_umount_all (g);
6646 r = guestfs_lvm_remove_all (g);
6651 char device[] = "/dev/sda";
6652 device[5] = devchar;
6653 char lines_0[] = ",";
6660 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6665 char fstype[] = "ext2";
6666 char device[] = "/dev/sda1";
6667 device[5] = devchar;
6670 r = guestfs_mkfs (g, fstype, device);
6675 char device[] = "/dev/sda1";
6676 device[5] = devchar;
6677 char mountpoint[] = "/";
6680 r = guestfs_mount (g, device, mountpoint);
6684 /* TestOutputStruct for lstat (0) */
6686 char path[] = "/new";
6689 r = guestfs_touch (g, path);
6694 char path[] = "/new";
6695 struct guestfs_stat *r;
6697 r = guestfs_lstat (g, path);
6701 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6710 static int test_stat_0_skip (void)
6714 str = getenv ("SKIP_TEST_STAT_0");
6715 if (str && strcmp (str, "1") == 0) return 1;
6716 str = getenv ("SKIP_TEST_STAT");
6717 if (str && strcmp (str, "1") == 0) return 1;
6721 static int test_stat_0 (void)
6723 if (test_stat_0_skip ()) {
6724 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6728 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6730 char device[] = "/dev/sda";
6731 device[5] = devchar;
6734 r = guestfs_blockdev_setrw (g, device);
6741 r = guestfs_umount_all (g);
6748 r = guestfs_lvm_remove_all (g);
6753 char device[] = "/dev/sda";
6754 device[5] = devchar;
6755 char lines_0[] = ",";
6762 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6767 char fstype[] = "ext2";
6768 char device[] = "/dev/sda1";
6769 device[5] = devchar;
6772 r = guestfs_mkfs (g, fstype, device);
6777 char device[] = "/dev/sda1";
6778 device[5] = devchar;
6779 char mountpoint[] = "/";
6782 r = guestfs_mount (g, device, mountpoint);
6786 /* TestOutputStruct for stat (0) */
6788 char path[] = "/new";
6791 r = guestfs_touch (g, path);
6796 char path[] = "/new";
6797 struct guestfs_stat *r;
6799 r = guestfs_stat (g, path);
6803 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6812 static int test_command_lines_0_skip (void)
6816 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6817 if (str && strcmp (str, "1") == 0) return 1;
6818 str = getenv ("SKIP_TEST_COMMAND_LINES");
6819 if (str && strcmp (str, "1") == 0) return 1;
6823 static int test_command_lines_0 (void)
6825 if (test_command_lines_0_skip ()) {
6826 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6830 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6832 char device[] = "/dev/sda";
6833 device[5] = devchar;
6836 r = guestfs_blockdev_setrw (g, device);
6843 r = guestfs_umount_all (g);
6850 r = guestfs_lvm_remove_all (g);
6855 char device[] = "/dev/sda";
6856 device[5] = devchar;
6857 char lines_0[] = ",";
6864 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6869 char fstype[] = "ext2";
6870 char device[] = "/dev/sda1";
6871 device[5] = devchar;
6874 r = guestfs_mkfs (g, fstype, device);
6879 char device[] = "/dev/sda1";
6880 device[5] = devchar;
6881 char mountpoint[] = "/";
6884 r = guestfs_mount (g, device, mountpoint);
6888 /* TestOutputList for command_lines (0) */
6890 char remotefilename[] = "/test-command";
6893 r = guestfs_upload (g, "test-command", remotefilename);
6898 char path[] = "/test-command";
6901 r = guestfs_chmod (g, 493, path);
6906 char arguments_0[] = "/test-command";
6907 char arguments_1[] = "1";
6908 char *arguments[] = {
6916 r = guestfs_command_lines (g, arguments);
6920 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
6925 char expected[] = "Result1";
6926 if (strcmp (r[0], expected) != 0) {
6927 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6932 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
6936 for (i = 0; r[i] != NULL; ++i)
6943 static int test_command_lines_1_skip (void)
6947 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
6948 if (str && strcmp (str, "1") == 0) return 1;
6949 str = getenv ("SKIP_TEST_COMMAND_LINES");
6950 if (str && strcmp (str, "1") == 0) return 1;
6954 static int test_command_lines_1 (void)
6956 if (test_command_lines_1_skip ()) {
6957 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
6961 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
6963 char device[] = "/dev/sda";
6964 device[5] = devchar;
6967 r = guestfs_blockdev_setrw (g, device);
6974 r = guestfs_umount_all (g);
6981 r = guestfs_lvm_remove_all (g);
6986 char device[] = "/dev/sda";
6987 device[5] = devchar;
6988 char lines_0[] = ",";
6995 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7000 char fstype[] = "ext2";
7001 char device[] = "/dev/sda1";
7002 device[5] = devchar;
7005 r = guestfs_mkfs (g, fstype, device);
7010 char device[] = "/dev/sda1";
7011 device[5] = devchar;
7012 char mountpoint[] = "/";
7015 r = guestfs_mount (g, device, mountpoint);
7019 /* TestOutputList for command_lines (1) */
7021 char remotefilename[] = "/test-command";
7024 r = guestfs_upload (g, "test-command", remotefilename);
7029 char path[] = "/test-command";
7032 r = guestfs_chmod (g, 493, path);
7037 char arguments_0[] = "/test-command";
7038 char arguments_1[] = "2";
7039 char *arguments[] = {
7047 r = guestfs_command_lines (g, arguments);
7051 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7056 char expected[] = "Result2";
7057 if (strcmp (r[0], expected) != 0) {
7058 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7063 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7067 for (i = 0; r[i] != NULL; ++i)
7074 static int test_command_lines_2_skip (void)
7078 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7079 if (str && strcmp (str, "1") == 0) return 1;
7080 str = getenv ("SKIP_TEST_COMMAND_LINES");
7081 if (str && strcmp (str, "1") == 0) return 1;
7085 static int test_command_lines_2 (void)
7087 if (test_command_lines_2_skip ()) {
7088 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7092 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7094 char device[] = "/dev/sda";
7095 device[5] = devchar;
7098 r = guestfs_blockdev_setrw (g, device);
7105 r = guestfs_umount_all (g);
7112 r = guestfs_lvm_remove_all (g);
7117 char device[] = "/dev/sda";
7118 device[5] = devchar;
7119 char lines_0[] = ",";
7126 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7131 char fstype[] = "ext2";
7132 char device[] = "/dev/sda1";
7133 device[5] = devchar;
7136 r = guestfs_mkfs (g, fstype, device);
7141 char device[] = "/dev/sda1";
7142 device[5] = devchar;
7143 char mountpoint[] = "/";
7146 r = guestfs_mount (g, device, mountpoint);
7150 /* TestOutputList for command_lines (2) */
7152 char remotefilename[] = "/test-command";
7155 r = guestfs_upload (g, "test-command", remotefilename);
7160 char path[] = "/test-command";
7163 r = guestfs_chmod (g, 493, path);
7168 char arguments_0[] = "/test-command";
7169 char arguments_1[] = "3";
7170 char *arguments[] = {
7178 r = guestfs_command_lines (g, arguments);
7182 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7187 char expected[] = "";
7188 if (strcmp (r[0], expected) != 0) {
7189 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7194 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7199 char expected[] = "Result3";
7200 if (strcmp (r[1], expected) != 0) {
7201 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7206 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7210 for (i = 0; r[i] != NULL; ++i)
7217 static int test_command_lines_3_skip (void)
7221 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7222 if (str && strcmp (str, "1") == 0) return 1;
7223 str = getenv ("SKIP_TEST_COMMAND_LINES");
7224 if (str && strcmp (str, "1") == 0) return 1;
7228 static int test_command_lines_3 (void)
7230 if (test_command_lines_3_skip ()) {
7231 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7235 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7237 char device[] = "/dev/sda";
7238 device[5] = devchar;
7241 r = guestfs_blockdev_setrw (g, device);
7248 r = guestfs_umount_all (g);
7255 r = guestfs_lvm_remove_all (g);
7260 char device[] = "/dev/sda";
7261 device[5] = devchar;
7262 char lines_0[] = ",";
7269 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7274 char fstype[] = "ext2";
7275 char device[] = "/dev/sda1";
7276 device[5] = devchar;
7279 r = guestfs_mkfs (g, fstype, device);
7284 char device[] = "/dev/sda1";
7285 device[5] = devchar;
7286 char mountpoint[] = "/";
7289 r = guestfs_mount (g, device, mountpoint);
7293 /* TestOutputList for command_lines (3) */
7295 char remotefilename[] = "/test-command";
7298 r = guestfs_upload (g, "test-command", remotefilename);
7303 char path[] = "/test-command";
7306 r = guestfs_chmod (g, 493, path);
7311 char arguments_0[] = "/test-command";
7312 char arguments_1[] = "4";
7313 char *arguments[] = {
7321 r = guestfs_command_lines (g, arguments);
7325 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7330 char expected[] = "";
7331 if (strcmp (r[0], expected) != 0) {
7332 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7337 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7342 char expected[] = "Result4";
7343 if (strcmp (r[1], expected) != 0) {
7344 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7349 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7353 for (i = 0; r[i] != NULL; ++i)
7360 static int test_command_lines_4_skip (void)
7364 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7365 if (str && strcmp (str, "1") == 0) return 1;
7366 str = getenv ("SKIP_TEST_COMMAND_LINES");
7367 if (str && strcmp (str, "1") == 0) return 1;
7371 static int test_command_lines_4 (void)
7373 if (test_command_lines_4_skip ()) {
7374 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7378 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7380 char device[] = "/dev/sda";
7381 device[5] = devchar;
7384 r = guestfs_blockdev_setrw (g, device);
7391 r = guestfs_umount_all (g);
7398 r = guestfs_lvm_remove_all (g);
7403 char device[] = "/dev/sda";
7404 device[5] = devchar;
7405 char lines_0[] = ",";
7412 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7417 char fstype[] = "ext2";
7418 char device[] = "/dev/sda1";
7419 device[5] = devchar;
7422 r = guestfs_mkfs (g, fstype, device);
7427 char device[] = "/dev/sda1";
7428 device[5] = devchar;
7429 char mountpoint[] = "/";
7432 r = guestfs_mount (g, device, mountpoint);
7436 /* TestOutputList for command_lines (4) */
7438 char remotefilename[] = "/test-command";
7441 r = guestfs_upload (g, "test-command", remotefilename);
7446 char path[] = "/test-command";
7449 r = guestfs_chmod (g, 493, path);
7454 char arguments_0[] = "/test-command";
7455 char arguments_1[] = "5";
7456 char *arguments[] = {
7464 r = guestfs_command_lines (g, arguments);
7468 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7473 char expected[] = "";
7474 if (strcmp (r[0], expected) != 0) {
7475 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7480 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7485 char expected[] = "Result5";
7486 if (strcmp (r[1], expected) != 0) {
7487 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7492 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7497 char expected[] = "";
7498 if (strcmp (r[2], expected) != 0) {
7499 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7504 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7508 for (i = 0; r[i] != NULL; ++i)
7515 static int test_command_lines_5_skip (void)
7519 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7520 if (str && strcmp (str, "1") == 0) return 1;
7521 str = getenv ("SKIP_TEST_COMMAND_LINES");
7522 if (str && strcmp (str, "1") == 0) return 1;
7526 static int test_command_lines_5 (void)
7528 if (test_command_lines_5_skip ()) {
7529 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7533 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7535 char device[] = "/dev/sda";
7536 device[5] = devchar;
7539 r = guestfs_blockdev_setrw (g, device);
7546 r = guestfs_umount_all (g);
7553 r = guestfs_lvm_remove_all (g);
7558 char device[] = "/dev/sda";
7559 device[5] = devchar;
7560 char lines_0[] = ",";
7567 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7572 char fstype[] = "ext2";
7573 char device[] = "/dev/sda1";
7574 device[5] = devchar;
7577 r = guestfs_mkfs (g, fstype, device);
7582 char device[] = "/dev/sda1";
7583 device[5] = devchar;
7584 char mountpoint[] = "/";
7587 r = guestfs_mount (g, device, mountpoint);
7591 /* TestOutputList for command_lines (5) */
7593 char remotefilename[] = "/test-command";
7596 r = guestfs_upload (g, "test-command", remotefilename);
7601 char path[] = "/test-command";
7604 r = guestfs_chmod (g, 493, path);
7609 char arguments_0[] = "/test-command";
7610 char arguments_1[] = "6";
7611 char *arguments[] = {
7619 r = guestfs_command_lines (g, arguments);
7623 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7628 char expected[] = "";
7629 if (strcmp (r[0], expected) != 0) {
7630 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7635 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7640 char expected[] = "";
7641 if (strcmp (r[1], expected) != 0) {
7642 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7647 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7652 char expected[] = "Result6";
7653 if (strcmp (r[2], expected) != 0) {
7654 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7659 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7664 char expected[] = "";
7665 if (strcmp (r[3], expected) != 0) {
7666 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7671 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7675 for (i = 0; r[i] != NULL; ++i)
7682 static int test_command_lines_6_skip (void)
7686 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7687 if (str && strcmp (str, "1") == 0) return 1;
7688 str = getenv ("SKIP_TEST_COMMAND_LINES");
7689 if (str && strcmp (str, "1") == 0) return 1;
7693 static int test_command_lines_6 (void)
7695 if (test_command_lines_6_skip ()) {
7696 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7700 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7702 char device[] = "/dev/sda";
7703 device[5] = devchar;
7706 r = guestfs_blockdev_setrw (g, device);
7713 r = guestfs_umount_all (g);
7720 r = guestfs_lvm_remove_all (g);
7725 char device[] = "/dev/sda";
7726 device[5] = devchar;
7727 char lines_0[] = ",";
7734 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7739 char fstype[] = "ext2";
7740 char device[] = "/dev/sda1";
7741 device[5] = devchar;
7744 r = guestfs_mkfs (g, fstype, device);
7749 char device[] = "/dev/sda1";
7750 device[5] = devchar;
7751 char mountpoint[] = "/";
7754 r = guestfs_mount (g, device, mountpoint);
7758 /* TestOutputList for command_lines (6) */
7760 char remotefilename[] = "/test-command";
7763 r = guestfs_upload (g, "test-command", remotefilename);
7768 char path[] = "/test-command";
7771 r = guestfs_chmod (g, 493, path);
7776 char arguments_0[] = "/test-command";
7777 char arguments_1[] = "7";
7778 char *arguments[] = {
7786 r = guestfs_command_lines (g, arguments);
7790 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7794 for (i = 0; r[i] != NULL; ++i)
7801 static int test_command_lines_7_skip (void)
7805 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7806 if (str && strcmp (str, "1") == 0) return 1;
7807 str = getenv ("SKIP_TEST_COMMAND_LINES");
7808 if (str && strcmp (str, "1") == 0) return 1;
7812 static int test_command_lines_7 (void)
7814 if (test_command_lines_7_skip ()) {
7815 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7819 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7821 char device[] = "/dev/sda";
7822 device[5] = devchar;
7825 r = guestfs_blockdev_setrw (g, device);
7832 r = guestfs_umount_all (g);
7839 r = guestfs_lvm_remove_all (g);
7844 char device[] = "/dev/sda";
7845 device[5] = devchar;
7846 char lines_0[] = ",";
7853 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7858 char fstype[] = "ext2";
7859 char device[] = "/dev/sda1";
7860 device[5] = devchar;
7863 r = guestfs_mkfs (g, fstype, device);
7868 char device[] = "/dev/sda1";
7869 device[5] = devchar;
7870 char mountpoint[] = "/";
7873 r = guestfs_mount (g, device, mountpoint);
7877 /* TestOutputList for command_lines (7) */
7879 char remotefilename[] = "/test-command";
7882 r = guestfs_upload (g, "test-command", remotefilename);
7887 char path[] = "/test-command";
7890 r = guestfs_chmod (g, 493, path);
7895 char arguments_0[] = "/test-command";
7896 char arguments_1[] = "8";
7897 char *arguments[] = {
7905 r = guestfs_command_lines (g, arguments);
7909 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
7914 char expected[] = "";
7915 if (strcmp (r[0], expected) != 0) {
7916 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7921 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
7925 for (i = 0; r[i] != NULL; ++i)
7932 static int test_command_lines_8_skip (void)
7936 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
7937 if (str && strcmp (str, "1") == 0) return 1;
7938 str = getenv ("SKIP_TEST_COMMAND_LINES");
7939 if (str && strcmp (str, "1") == 0) return 1;
7943 static int test_command_lines_8 (void)
7945 if (test_command_lines_8_skip ()) {
7946 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
7950 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
7952 char device[] = "/dev/sda";
7953 device[5] = devchar;
7956 r = guestfs_blockdev_setrw (g, device);
7963 r = guestfs_umount_all (g);
7970 r = guestfs_lvm_remove_all (g);
7975 char device[] = "/dev/sda";
7976 device[5] = devchar;
7977 char lines_0[] = ",";
7984 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7989 char fstype[] = "ext2";
7990 char device[] = "/dev/sda1";
7991 device[5] = devchar;
7994 r = guestfs_mkfs (g, fstype, device);
7999 char device[] = "/dev/sda1";
8000 device[5] = devchar;
8001 char mountpoint[] = "/";
8004 r = guestfs_mount (g, device, mountpoint);
8008 /* TestOutputList for command_lines (8) */
8010 char remotefilename[] = "/test-command";
8013 r = guestfs_upload (g, "test-command", remotefilename);
8018 char path[] = "/test-command";
8021 r = guestfs_chmod (g, 493, path);
8026 char arguments_0[] = "/test-command";
8027 char arguments_1[] = "9";
8028 char *arguments[] = {
8036 r = guestfs_command_lines (g, arguments);
8040 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8045 char expected[] = "";
8046 if (strcmp (r[0], expected) != 0) {
8047 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8052 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8057 char expected[] = "";
8058 if (strcmp (r[1], expected) != 0) {
8059 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8064 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8068 for (i = 0; r[i] != NULL; ++i)
8075 static int test_command_lines_9_skip (void)
8079 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8080 if (str && strcmp (str, "1") == 0) return 1;
8081 str = getenv ("SKIP_TEST_COMMAND_LINES");
8082 if (str && strcmp (str, "1") == 0) return 1;
8086 static int test_command_lines_9 (void)
8088 if (test_command_lines_9_skip ()) {
8089 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8093 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8095 char device[] = "/dev/sda";
8096 device[5] = devchar;
8099 r = guestfs_blockdev_setrw (g, device);
8106 r = guestfs_umount_all (g);
8113 r = guestfs_lvm_remove_all (g);
8118 char device[] = "/dev/sda";
8119 device[5] = devchar;
8120 char lines_0[] = ",";
8127 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8132 char fstype[] = "ext2";
8133 char device[] = "/dev/sda1";
8134 device[5] = devchar;
8137 r = guestfs_mkfs (g, fstype, device);
8142 char device[] = "/dev/sda1";
8143 device[5] = devchar;
8144 char mountpoint[] = "/";
8147 r = guestfs_mount (g, device, mountpoint);
8151 /* TestOutputList for command_lines (9) */
8153 char remotefilename[] = "/test-command";
8156 r = guestfs_upload (g, "test-command", remotefilename);
8161 char path[] = "/test-command";
8164 r = guestfs_chmod (g, 493, path);
8169 char arguments_0[] = "/test-command";
8170 char arguments_1[] = "10";
8171 char *arguments[] = {
8179 r = guestfs_command_lines (g, arguments);
8183 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8188 char expected[] = "Result10-1";
8189 if (strcmp (r[0], expected) != 0) {
8190 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8195 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8200 char expected[] = "Result10-2";
8201 if (strcmp (r[1], expected) != 0) {
8202 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8207 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8211 for (i = 0; r[i] != NULL; ++i)
8218 static int test_command_lines_10_skip (void)
8222 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8223 if (str && strcmp (str, "1") == 0) return 1;
8224 str = getenv ("SKIP_TEST_COMMAND_LINES");
8225 if (str && strcmp (str, "1") == 0) return 1;
8229 static int test_command_lines_10 (void)
8231 if (test_command_lines_10_skip ()) {
8232 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8236 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8238 char device[] = "/dev/sda";
8239 device[5] = devchar;
8242 r = guestfs_blockdev_setrw (g, device);
8249 r = guestfs_umount_all (g);
8256 r = guestfs_lvm_remove_all (g);
8261 char device[] = "/dev/sda";
8262 device[5] = devchar;
8263 char lines_0[] = ",";
8270 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8275 char fstype[] = "ext2";
8276 char device[] = "/dev/sda1";
8277 device[5] = devchar;
8280 r = guestfs_mkfs (g, fstype, device);
8285 char device[] = "/dev/sda1";
8286 device[5] = devchar;
8287 char mountpoint[] = "/";
8290 r = guestfs_mount (g, device, mountpoint);
8294 /* TestOutputList for command_lines (10) */
8296 char remotefilename[] = "/test-command";
8299 r = guestfs_upload (g, "test-command", remotefilename);
8304 char path[] = "/test-command";
8307 r = guestfs_chmod (g, 493, path);
8312 char arguments_0[] = "/test-command";
8313 char arguments_1[] = "11";
8314 char *arguments[] = {
8322 r = guestfs_command_lines (g, arguments);
8326 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8331 char expected[] = "Result11-1";
8332 if (strcmp (r[0], expected) != 0) {
8333 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8338 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8343 char expected[] = "Result11-2";
8344 if (strcmp (r[1], expected) != 0) {
8345 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8350 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8354 for (i = 0; r[i] != NULL; ++i)
8361 static int test_command_0_skip (void)
8365 str = getenv ("SKIP_TEST_COMMAND_0");
8366 if (str && strcmp (str, "1") == 0) return 1;
8367 str = getenv ("SKIP_TEST_COMMAND");
8368 if (str && strcmp (str, "1") == 0) return 1;
8372 static int test_command_0 (void)
8374 if (test_command_0_skip ()) {
8375 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8379 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8381 char device[] = "/dev/sda";
8382 device[5] = devchar;
8385 r = guestfs_blockdev_setrw (g, device);
8392 r = guestfs_umount_all (g);
8399 r = guestfs_lvm_remove_all (g);
8404 char device[] = "/dev/sda";
8405 device[5] = devchar;
8406 char lines_0[] = ",";
8413 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8418 char fstype[] = "ext2";
8419 char device[] = "/dev/sda1";
8420 device[5] = devchar;
8423 r = guestfs_mkfs (g, fstype, device);
8428 char device[] = "/dev/sda1";
8429 device[5] = devchar;
8430 char mountpoint[] = "/";
8433 r = guestfs_mount (g, device, mountpoint);
8437 /* TestOutput for command (0) */
8438 char expected[] = "Result1";
8440 char remotefilename[] = "/test-command";
8443 r = guestfs_upload (g, "test-command", remotefilename);
8448 char path[] = "/test-command";
8451 r = guestfs_chmod (g, 493, path);
8456 char arguments_0[] = "/test-command";
8457 char arguments_1[] = "1";
8458 char *arguments[] = {
8465 r = guestfs_command (g, arguments);
8468 if (strcmp (r, expected) != 0) {
8469 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8477 static int test_command_1_skip (void)
8481 str = getenv ("SKIP_TEST_COMMAND_1");
8482 if (str && strcmp (str, "1") == 0) return 1;
8483 str = getenv ("SKIP_TEST_COMMAND");
8484 if (str && strcmp (str, "1") == 0) return 1;
8488 static int test_command_1 (void)
8490 if (test_command_1_skip ()) {
8491 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8495 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8497 char device[] = "/dev/sda";
8498 device[5] = devchar;
8501 r = guestfs_blockdev_setrw (g, device);
8508 r = guestfs_umount_all (g);
8515 r = guestfs_lvm_remove_all (g);
8520 char device[] = "/dev/sda";
8521 device[5] = devchar;
8522 char lines_0[] = ",";
8529 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8534 char fstype[] = "ext2";
8535 char device[] = "/dev/sda1";
8536 device[5] = devchar;
8539 r = guestfs_mkfs (g, fstype, device);
8544 char device[] = "/dev/sda1";
8545 device[5] = devchar;
8546 char mountpoint[] = "/";
8549 r = guestfs_mount (g, device, mountpoint);
8553 /* TestOutput for command (1) */
8554 char expected[] = "Result2\n";
8556 char remotefilename[] = "/test-command";
8559 r = guestfs_upload (g, "test-command", remotefilename);
8564 char path[] = "/test-command";
8567 r = guestfs_chmod (g, 493, path);
8572 char arguments_0[] = "/test-command";
8573 char arguments_1[] = "2";
8574 char *arguments[] = {
8581 r = guestfs_command (g, arguments);
8584 if (strcmp (r, expected) != 0) {
8585 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8593 static int test_command_2_skip (void)
8597 str = getenv ("SKIP_TEST_COMMAND_2");
8598 if (str && strcmp (str, "1") == 0) return 1;
8599 str = getenv ("SKIP_TEST_COMMAND");
8600 if (str && strcmp (str, "1") == 0) return 1;
8604 static int test_command_2 (void)
8606 if (test_command_2_skip ()) {
8607 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8611 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8613 char device[] = "/dev/sda";
8614 device[5] = devchar;
8617 r = guestfs_blockdev_setrw (g, device);
8624 r = guestfs_umount_all (g);
8631 r = guestfs_lvm_remove_all (g);
8636 char device[] = "/dev/sda";
8637 device[5] = devchar;
8638 char lines_0[] = ",";
8645 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8650 char fstype[] = "ext2";
8651 char device[] = "/dev/sda1";
8652 device[5] = devchar;
8655 r = guestfs_mkfs (g, fstype, device);
8660 char device[] = "/dev/sda1";
8661 device[5] = devchar;
8662 char mountpoint[] = "/";
8665 r = guestfs_mount (g, device, mountpoint);
8669 /* TestOutput for command (2) */
8670 char expected[] = "\nResult3";
8672 char remotefilename[] = "/test-command";
8675 r = guestfs_upload (g, "test-command", remotefilename);
8680 char path[] = "/test-command";
8683 r = guestfs_chmod (g, 493, path);
8688 char arguments_0[] = "/test-command";
8689 char arguments_1[] = "3";
8690 char *arguments[] = {
8697 r = guestfs_command (g, arguments);
8700 if (strcmp (r, expected) != 0) {
8701 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8709 static int test_command_3_skip (void)
8713 str = getenv ("SKIP_TEST_COMMAND_3");
8714 if (str && strcmp (str, "1") == 0) return 1;
8715 str = getenv ("SKIP_TEST_COMMAND");
8716 if (str && strcmp (str, "1") == 0) return 1;
8720 static int test_command_3 (void)
8722 if (test_command_3_skip ()) {
8723 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8727 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8729 char device[] = "/dev/sda";
8730 device[5] = devchar;
8733 r = guestfs_blockdev_setrw (g, device);
8740 r = guestfs_umount_all (g);
8747 r = guestfs_lvm_remove_all (g);
8752 char device[] = "/dev/sda";
8753 device[5] = devchar;
8754 char lines_0[] = ",";
8761 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8766 char fstype[] = "ext2";
8767 char device[] = "/dev/sda1";
8768 device[5] = devchar;
8771 r = guestfs_mkfs (g, fstype, device);
8776 char device[] = "/dev/sda1";
8777 device[5] = devchar;
8778 char mountpoint[] = "/";
8781 r = guestfs_mount (g, device, mountpoint);
8785 /* TestOutput for command (3) */
8786 char expected[] = "\nResult4\n";
8788 char remotefilename[] = "/test-command";
8791 r = guestfs_upload (g, "test-command", remotefilename);
8796 char path[] = "/test-command";
8799 r = guestfs_chmod (g, 493, path);
8804 char arguments_0[] = "/test-command";
8805 char arguments_1[] = "4";
8806 char *arguments[] = {
8813 r = guestfs_command (g, arguments);
8816 if (strcmp (r, expected) != 0) {
8817 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8825 static int test_command_4_skip (void)
8829 str = getenv ("SKIP_TEST_COMMAND_4");
8830 if (str && strcmp (str, "1") == 0) return 1;
8831 str = getenv ("SKIP_TEST_COMMAND");
8832 if (str && strcmp (str, "1") == 0) return 1;
8836 static int test_command_4 (void)
8838 if (test_command_4_skip ()) {
8839 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8843 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8845 char device[] = "/dev/sda";
8846 device[5] = devchar;
8849 r = guestfs_blockdev_setrw (g, device);
8856 r = guestfs_umount_all (g);
8863 r = guestfs_lvm_remove_all (g);
8868 char device[] = "/dev/sda";
8869 device[5] = devchar;
8870 char lines_0[] = ",";
8877 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8882 char fstype[] = "ext2";
8883 char device[] = "/dev/sda1";
8884 device[5] = devchar;
8887 r = guestfs_mkfs (g, fstype, device);
8892 char device[] = "/dev/sda1";
8893 device[5] = devchar;
8894 char mountpoint[] = "/";
8897 r = guestfs_mount (g, device, mountpoint);
8901 /* TestOutput for command (4) */
8902 char expected[] = "\nResult5\n\n";
8904 char remotefilename[] = "/test-command";
8907 r = guestfs_upload (g, "test-command", remotefilename);
8912 char path[] = "/test-command";
8915 r = guestfs_chmod (g, 493, path);
8920 char arguments_0[] = "/test-command";
8921 char arguments_1[] = "5";
8922 char *arguments[] = {
8929 r = guestfs_command (g, arguments);
8932 if (strcmp (r, expected) != 0) {
8933 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
8941 static int test_command_5_skip (void)
8945 str = getenv ("SKIP_TEST_COMMAND_5");
8946 if (str && strcmp (str, "1") == 0) return 1;
8947 str = getenv ("SKIP_TEST_COMMAND");
8948 if (str && strcmp (str, "1") == 0) return 1;
8952 static int test_command_5 (void)
8954 if (test_command_5_skip ()) {
8955 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
8959 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
8961 char device[] = "/dev/sda";
8962 device[5] = devchar;
8965 r = guestfs_blockdev_setrw (g, device);
8972 r = guestfs_umount_all (g);
8979 r = guestfs_lvm_remove_all (g);
8984 char device[] = "/dev/sda";
8985 device[5] = devchar;
8986 char lines_0[] = ",";
8993 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8998 char fstype[] = "ext2";
8999 char device[] = "/dev/sda1";
9000 device[5] = devchar;
9003 r = guestfs_mkfs (g, fstype, device);
9008 char device[] = "/dev/sda1";
9009 device[5] = devchar;
9010 char mountpoint[] = "/";
9013 r = guestfs_mount (g, device, mountpoint);
9017 /* TestOutput for command (5) */
9018 char expected[] = "\n\nResult6\n\n";
9020 char remotefilename[] = "/test-command";
9023 r = guestfs_upload (g, "test-command", remotefilename);
9028 char path[] = "/test-command";
9031 r = guestfs_chmod (g, 493, path);
9036 char arguments_0[] = "/test-command";
9037 char arguments_1[] = "6";
9038 char *arguments[] = {
9045 r = guestfs_command (g, arguments);
9048 if (strcmp (r, expected) != 0) {
9049 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9057 static int test_command_6_skip (void)
9061 str = getenv ("SKIP_TEST_COMMAND_6");
9062 if (str && strcmp (str, "1") == 0) return 1;
9063 str = getenv ("SKIP_TEST_COMMAND");
9064 if (str && strcmp (str, "1") == 0) return 1;
9068 static int test_command_6 (void)
9070 if (test_command_6_skip ()) {
9071 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9075 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9077 char device[] = "/dev/sda";
9078 device[5] = devchar;
9081 r = guestfs_blockdev_setrw (g, device);
9088 r = guestfs_umount_all (g);
9095 r = guestfs_lvm_remove_all (g);
9100 char device[] = "/dev/sda";
9101 device[5] = devchar;
9102 char lines_0[] = ",";
9109 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9114 char fstype[] = "ext2";
9115 char device[] = "/dev/sda1";
9116 device[5] = devchar;
9119 r = guestfs_mkfs (g, fstype, device);
9124 char device[] = "/dev/sda1";
9125 device[5] = devchar;
9126 char mountpoint[] = "/";
9129 r = guestfs_mount (g, device, mountpoint);
9133 /* TestOutput for command (6) */
9134 char expected[] = "";
9136 char remotefilename[] = "/test-command";
9139 r = guestfs_upload (g, "test-command", remotefilename);
9144 char path[] = "/test-command";
9147 r = guestfs_chmod (g, 493, path);
9152 char arguments_0[] = "/test-command";
9153 char arguments_1[] = "7";
9154 char *arguments[] = {
9161 r = guestfs_command (g, arguments);
9164 if (strcmp (r, expected) != 0) {
9165 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9173 static int test_command_7_skip (void)
9177 str = getenv ("SKIP_TEST_COMMAND_7");
9178 if (str && strcmp (str, "1") == 0) return 1;
9179 str = getenv ("SKIP_TEST_COMMAND");
9180 if (str && strcmp (str, "1") == 0) return 1;
9184 static int test_command_7 (void)
9186 if (test_command_7_skip ()) {
9187 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9191 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9193 char device[] = "/dev/sda";
9194 device[5] = devchar;
9197 r = guestfs_blockdev_setrw (g, device);
9204 r = guestfs_umount_all (g);
9211 r = guestfs_lvm_remove_all (g);
9216 char device[] = "/dev/sda";
9217 device[5] = devchar;
9218 char lines_0[] = ",";
9225 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9230 char fstype[] = "ext2";
9231 char device[] = "/dev/sda1";
9232 device[5] = devchar;
9235 r = guestfs_mkfs (g, fstype, device);
9240 char device[] = "/dev/sda1";
9241 device[5] = devchar;
9242 char mountpoint[] = "/";
9245 r = guestfs_mount (g, device, mountpoint);
9249 /* TestOutput for command (7) */
9250 char expected[] = "\n";
9252 char remotefilename[] = "/test-command";
9255 r = guestfs_upload (g, "test-command", remotefilename);
9260 char path[] = "/test-command";
9263 r = guestfs_chmod (g, 493, path);
9268 char arguments_0[] = "/test-command";
9269 char arguments_1[] = "8";
9270 char *arguments[] = {
9277 r = guestfs_command (g, arguments);
9280 if (strcmp (r, expected) != 0) {
9281 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9289 static int test_command_8_skip (void)
9293 str = getenv ("SKIP_TEST_COMMAND_8");
9294 if (str && strcmp (str, "1") == 0) return 1;
9295 str = getenv ("SKIP_TEST_COMMAND");
9296 if (str && strcmp (str, "1") == 0) return 1;
9300 static int test_command_8 (void)
9302 if (test_command_8_skip ()) {
9303 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9307 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9309 char device[] = "/dev/sda";
9310 device[5] = devchar;
9313 r = guestfs_blockdev_setrw (g, device);
9320 r = guestfs_umount_all (g);
9327 r = guestfs_lvm_remove_all (g);
9332 char device[] = "/dev/sda";
9333 device[5] = devchar;
9334 char lines_0[] = ",";
9341 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9346 char fstype[] = "ext2";
9347 char device[] = "/dev/sda1";
9348 device[5] = devchar;
9351 r = guestfs_mkfs (g, fstype, device);
9356 char device[] = "/dev/sda1";
9357 device[5] = devchar;
9358 char mountpoint[] = "/";
9361 r = guestfs_mount (g, device, mountpoint);
9365 /* TestOutput for command (8) */
9366 char expected[] = "\n\n";
9368 char remotefilename[] = "/test-command";
9371 r = guestfs_upload (g, "test-command", remotefilename);
9376 char path[] = "/test-command";
9379 r = guestfs_chmod (g, 493, path);
9384 char arguments_0[] = "/test-command";
9385 char arguments_1[] = "9";
9386 char *arguments[] = {
9393 r = guestfs_command (g, arguments);
9396 if (strcmp (r, expected) != 0) {
9397 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9405 static int test_command_9_skip (void)
9409 str = getenv ("SKIP_TEST_COMMAND_9");
9410 if (str && strcmp (str, "1") == 0) return 1;
9411 str = getenv ("SKIP_TEST_COMMAND");
9412 if (str && strcmp (str, "1") == 0) return 1;
9416 static int test_command_9 (void)
9418 if (test_command_9_skip ()) {
9419 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9423 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9425 char device[] = "/dev/sda";
9426 device[5] = devchar;
9429 r = guestfs_blockdev_setrw (g, device);
9436 r = guestfs_umount_all (g);
9443 r = guestfs_lvm_remove_all (g);
9448 char device[] = "/dev/sda";
9449 device[5] = devchar;
9450 char lines_0[] = ",";
9457 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9462 char fstype[] = "ext2";
9463 char device[] = "/dev/sda1";
9464 device[5] = devchar;
9467 r = guestfs_mkfs (g, fstype, device);
9472 char device[] = "/dev/sda1";
9473 device[5] = devchar;
9474 char mountpoint[] = "/";
9477 r = guestfs_mount (g, device, mountpoint);
9481 /* TestOutput for command (9) */
9482 char expected[] = "Result10-1\nResult10-2\n";
9484 char remotefilename[] = "/test-command";
9487 r = guestfs_upload (g, "test-command", remotefilename);
9492 char path[] = "/test-command";
9495 r = guestfs_chmod (g, 493, path);
9500 char arguments_0[] = "/test-command";
9501 char arguments_1[] = "10";
9502 char *arguments[] = {
9509 r = guestfs_command (g, arguments);
9512 if (strcmp (r, expected) != 0) {
9513 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9521 static int test_command_10_skip (void)
9525 str = getenv ("SKIP_TEST_COMMAND_10");
9526 if (str && strcmp (str, "1") == 0) return 1;
9527 str = getenv ("SKIP_TEST_COMMAND");
9528 if (str && strcmp (str, "1") == 0) return 1;
9532 static int test_command_10 (void)
9534 if (test_command_10_skip ()) {
9535 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9539 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9541 char device[] = "/dev/sda";
9542 device[5] = devchar;
9545 r = guestfs_blockdev_setrw (g, device);
9552 r = guestfs_umount_all (g);
9559 r = guestfs_lvm_remove_all (g);
9564 char device[] = "/dev/sda";
9565 device[5] = devchar;
9566 char lines_0[] = ",";
9573 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9578 char fstype[] = "ext2";
9579 char device[] = "/dev/sda1";
9580 device[5] = devchar;
9583 r = guestfs_mkfs (g, fstype, device);
9588 char device[] = "/dev/sda1";
9589 device[5] = devchar;
9590 char mountpoint[] = "/";
9593 r = guestfs_mount (g, device, mountpoint);
9597 /* TestOutput for command (10) */
9598 char expected[] = "Result11-1\nResult11-2";
9600 char remotefilename[] = "/test-command";
9603 r = guestfs_upload (g, "test-command", remotefilename);
9608 char path[] = "/test-command";
9611 r = guestfs_chmod (g, 493, path);
9616 char arguments_0[] = "/test-command";
9617 char arguments_1[] = "11";
9618 char *arguments[] = {
9625 r = guestfs_command (g, arguments);
9628 if (strcmp (r, expected) != 0) {
9629 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9637 static int test_command_11_skip (void)
9641 str = getenv ("SKIP_TEST_COMMAND_11");
9642 if (str && strcmp (str, "1") == 0) return 1;
9643 str = getenv ("SKIP_TEST_COMMAND");
9644 if (str && strcmp (str, "1") == 0) return 1;
9648 static int test_command_11 (void)
9650 if (test_command_11_skip ()) {
9651 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9655 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9657 char device[] = "/dev/sda";
9658 device[5] = devchar;
9661 r = guestfs_blockdev_setrw (g, device);
9668 r = guestfs_umount_all (g);
9675 r = guestfs_lvm_remove_all (g);
9680 char device[] = "/dev/sda";
9681 device[5] = devchar;
9682 char lines_0[] = ",";
9689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9694 char fstype[] = "ext2";
9695 char device[] = "/dev/sda1";
9696 device[5] = devchar;
9699 r = guestfs_mkfs (g, fstype, device);
9704 char device[] = "/dev/sda1";
9705 device[5] = devchar;
9706 char mountpoint[] = "/";
9709 r = guestfs_mount (g, device, mountpoint);
9713 /* TestLastFail for command (11) */
9715 char remotefilename[] = "/test-command";
9718 r = guestfs_upload (g, "test-command", remotefilename);
9723 char path[] = "/test-command";
9726 r = guestfs_chmod (g, 493, path);
9731 char arguments_0[] = "/test-command";
9732 char *arguments[] = {
9738 r = guestfs_command (g, arguments);
9746 static int test_file_0_skip (void)
9750 str = getenv ("SKIP_TEST_FILE_0");
9751 if (str && strcmp (str, "1") == 0) return 1;
9752 str = getenv ("SKIP_TEST_FILE");
9753 if (str && strcmp (str, "1") == 0) return 1;
9757 static int test_file_0 (void)
9759 if (test_file_0_skip ()) {
9760 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9764 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9766 char device[] = "/dev/sda";
9767 device[5] = devchar;
9770 r = guestfs_blockdev_setrw (g, device);
9777 r = guestfs_umount_all (g);
9784 r = guestfs_lvm_remove_all (g);
9789 char device[] = "/dev/sda";
9790 device[5] = devchar;
9791 char lines_0[] = ",";
9798 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9803 char fstype[] = "ext2";
9804 char device[] = "/dev/sda1";
9805 device[5] = devchar;
9808 r = guestfs_mkfs (g, fstype, device);
9813 char device[] = "/dev/sda1";
9814 device[5] = devchar;
9815 char mountpoint[] = "/";
9818 r = guestfs_mount (g, device, mountpoint);
9822 /* TestOutput for file (0) */
9823 char expected[] = "empty";
9825 char path[] = "/new";
9828 r = guestfs_touch (g, path);
9833 char path[] = "/new";
9836 r = guestfs_file (g, path);
9839 if (strcmp (r, expected) != 0) {
9840 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9848 static int test_file_1_skip (void)
9852 str = getenv ("SKIP_TEST_FILE_1");
9853 if (str && strcmp (str, "1") == 0) return 1;
9854 str = getenv ("SKIP_TEST_FILE");
9855 if (str && strcmp (str, "1") == 0) return 1;
9859 static int test_file_1 (void)
9861 if (test_file_1_skip ()) {
9862 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9866 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9868 char device[] = "/dev/sda";
9869 device[5] = devchar;
9872 r = guestfs_blockdev_setrw (g, device);
9879 r = guestfs_umount_all (g);
9886 r = guestfs_lvm_remove_all (g);
9891 char device[] = "/dev/sda";
9892 device[5] = devchar;
9893 char lines_0[] = ",";
9900 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9905 char fstype[] = "ext2";
9906 char device[] = "/dev/sda1";
9907 device[5] = devchar;
9910 r = guestfs_mkfs (g, fstype, device);
9915 char device[] = "/dev/sda1";
9916 device[5] = devchar;
9917 char mountpoint[] = "/";
9920 r = guestfs_mount (g, device, mountpoint);
9924 /* TestOutput for file (1) */
9925 char expected[] = "ASCII text";
9927 char path[] = "/new";
9928 char content[] = "some content\n";
9931 r = guestfs_write_file (g, path, content, 0);
9936 char path[] = "/new";
9939 r = guestfs_file (g, path);
9942 if (strcmp (r, expected) != 0) {
9943 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
9951 static int test_file_2_skip (void)
9955 str = getenv ("SKIP_TEST_FILE_2");
9956 if (str && strcmp (str, "1") == 0) return 1;
9957 str = getenv ("SKIP_TEST_FILE");
9958 if (str && strcmp (str, "1") == 0) return 1;
9962 static int test_file_2 (void)
9964 if (test_file_2_skip ()) {
9965 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
9969 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
9971 char device[] = "/dev/sda";
9972 device[5] = devchar;
9975 r = guestfs_blockdev_setrw (g, device);
9982 r = guestfs_umount_all (g);
9989 r = guestfs_lvm_remove_all (g);
9994 char device[] = "/dev/sda";
9995 device[5] = devchar;
9996 char lines_0[] = ",";
10002 suppress_error = 0;
10003 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10008 char fstype[] = "ext2";
10009 char device[] = "/dev/sda1";
10010 device[5] = devchar;
10012 suppress_error = 0;
10013 r = guestfs_mkfs (g, fstype, device);
10018 char device[] = "/dev/sda1";
10019 device[5] = devchar;
10020 char mountpoint[] = "/";
10022 suppress_error = 0;
10023 r = guestfs_mount (g, device, mountpoint);
10027 /* TestLastFail for file (2) */
10029 char path[] = "/nofile";
10031 suppress_error = 1;
10032 r = guestfs_file (g, path);
10040 static int test_umount_all_0_skip (void)
10044 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10045 if (str && strcmp (str, "1") == 0) return 1;
10046 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10047 if (str && strcmp (str, "1") == 0) return 1;
10051 static int test_umount_all_0 (void)
10053 if (test_umount_all_0_skip ()) {
10054 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10058 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10060 char device[] = "/dev/sda";
10061 device[5] = devchar;
10063 suppress_error = 0;
10064 r = guestfs_blockdev_setrw (g, device);
10070 suppress_error = 0;
10071 r = guestfs_umount_all (g);
10077 suppress_error = 0;
10078 r = guestfs_lvm_remove_all (g);
10083 char device[] = "/dev/sda";
10084 device[5] = devchar;
10085 char lines_0[] = ",";
10091 suppress_error = 0;
10092 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10097 char fstype[] = "ext2";
10098 char device[] = "/dev/sda1";
10099 device[5] = devchar;
10101 suppress_error = 0;
10102 r = guestfs_mkfs (g, fstype, device);
10107 char device[] = "/dev/sda1";
10108 device[5] = devchar;
10109 char mountpoint[] = "/";
10111 suppress_error = 0;
10112 r = guestfs_mount (g, device, mountpoint);
10116 /* TestOutputList for umount_all (0) */
10119 suppress_error = 0;
10120 r = guestfs_umount_all (g);
10127 suppress_error = 0;
10128 r = guestfs_mounts (g);
10131 if (r[0] != NULL) {
10132 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10136 for (i = 0; r[i] != NULL; ++i)
10143 static int test_umount_all_1_skip (void)
10147 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10148 if (str && strcmp (str, "1") == 0) return 1;
10149 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10150 if (str && strcmp (str, "1") == 0) return 1;
10154 static int test_umount_all_1 (void)
10156 if (test_umount_all_1_skip ()) {
10157 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10161 /* InitNone|InitEmpty for test_umount_all_1 */
10163 char device[] = "/dev/sda";
10164 device[5] = devchar;
10166 suppress_error = 0;
10167 r = guestfs_blockdev_setrw (g, device);
10173 suppress_error = 0;
10174 r = guestfs_umount_all (g);
10180 suppress_error = 0;
10181 r = guestfs_lvm_remove_all (g);
10185 /* TestOutputList for umount_all (1) */
10187 char device[] = "/dev/sda";
10188 device[5] = devchar;
10189 char lines_0[] = ",10";
10190 char lines_1[] = ",20";
10191 char lines_2[] = ",";
10199 suppress_error = 0;
10200 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10205 char fstype[] = "ext2";
10206 char device[] = "/dev/sda1";
10207 device[5] = devchar;
10209 suppress_error = 0;
10210 r = guestfs_mkfs (g, fstype, device);
10215 char fstype[] = "ext2";
10216 char device[] = "/dev/sda2";
10217 device[5] = devchar;
10219 suppress_error = 0;
10220 r = guestfs_mkfs (g, fstype, device);
10225 char fstype[] = "ext2";
10226 char device[] = "/dev/sda3";
10227 device[5] = devchar;
10229 suppress_error = 0;
10230 r = guestfs_mkfs (g, fstype, device);
10235 char device[] = "/dev/sda1";
10236 device[5] = devchar;
10237 char mountpoint[] = "/";
10239 suppress_error = 0;
10240 r = guestfs_mount (g, device, mountpoint);
10245 char path[] = "/mp1";
10247 suppress_error = 0;
10248 r = guestfs_mkdir (g, path);
10253 char device[] = "/dev/sda2";
10254 device[5] = devchar;
10255 char mountpoint[] = "/mp1";
10257 suppress_error = 0;
10258 r = guestfs_mount (g, device, mountpoint);
10263 char path[] = "/mp1/mp2";
10265 suppress_error = 0;
10266 r = guestfs_mkdir (g, path);
10271 char device[] = "/dev/sda3";
10272 device[5] = devchar;
10273 char mountpoint[] = "/mp1/mp2";
10275 suppress_error = 0;
10276 r = guestfs_mount (g, device, mountpoint);
10281 char path[] = "/mp1/mp2/mp3";
10283 suppress_error = 0;
10284 r = guestfs_mkdir (g, path);
10290 suppress_error = 0;
10291 r = guestfs_umount_all (g);
10298 suppress_error = 0;
10299 r = guestfs_mounts (g);
10302 if (r[0] != NULL) {
10303 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10307 for (i = 0; r[i] != NULL; ++i)
10314 static int test_mounts_0_skip (void)
10318 str = getenv ("SKIP_TEST_MOUNTS_0");
10319 if (str && strcmp (str, "1") == 0) return 1;
10320 str = getenv ("SKIP_TEST_MOUNTS");
10321 if (str && strcmp (str, "1") == 0) return 1;
10325 static int test_mounts_0 (void)
10327 if (test_mounts_0_skip ()) {
10328 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10332 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10334 char device[] = "/dev/sda";
10335 device[5] = devchar;
10337 suppress_error = 0;
10338 r = guestfs_blockdev_setrw (g, device);
10344 suppress_error = 0;
10345 r = guestfs_umount_all (g);
10351 suppress_error = 0;
10352 r = guestfs_lvm_remove_all (g);
10357 char device[] = "/dev/sda";
10358 device[5] = devchar;
10359 char lines_0[] = ",";
10365 suppress_error = 0;
10366 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10371 char fstype[] = "ext2";
10372 char device[] = "/dev/sda1";
10373 device[5] = devchar;
10375 suppress_error = 0;
10376 r = guestfs_mkfs (g, fstype, device);
10381 char device[] = "/dev/sda1";
10382 device[5] = devchar;
10383 char mountpoint[] = "/";
10385 suppress_error = 0;
10386 r = guestfs_mount (g, device, mountpoint);
10390 /* TestOutputList for mounts (0) */
10394 suppress_error = 0;
10395 r = guestfs_mounts (g);
10399 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10404 char expected[] = "/dev/sda1";
10405 expected[5] = devchar;
10406 if (strcmp (r[0], expected) != 0) {
10407 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10411 if (r[1] != NULL) {
10412 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10416 for (i = 0; r[i] != NULL; ++i)
10423 static int test_umount_0_skip (void)
10427 str = getenv ("SKIP_TEST_UMOUNT_0");
10428 if (str && strcmp (str, "1") == 0) return 1;
10429 str = getenv ("SKIP_TEST_UMOUNT");
10430 if (str && strcmp (str, "1") == 0) return 1;
10434 static int test_umount_0 (void)
10436 if (test_umount_0_skip ()) {
10437 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10441 /* InitNone|InitEmpty for test_umount_0 */
10443 char device[] = "/dev/sda";
10444 device[5] = devchar;
10446 suppress_error = 0;
10447 r = guestfs_blockdev_setrw (g, device);
10453 suppress_error = 0;
10454 r = guestfs_umount_all (g);
10460 suppress_error = 0;
10461 r = guestfs_lvm_remove_all (g);
10465 /* TestOutputList for umount (0) */
10467 char device[] = "/dev/sda";
10468 device[5] = devchar;
10469 char lines_0[] = ",";
10475 suppress_error = 0;
10476 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10481 char fstype[] = "ext2";
10482 char device[] = "/dev/sda1";
10483 device[5] = devchar;
10485 suppress_error = 0;
10486 r = guestfs_mkfs (g, fstype, device);
10491 char device[] = "/dev/sda1";
10492 device[5] = devchar;
10493 char mountpoint[] = "/";
10495 suppress_error = 0;
10496 r = guestfs_mount (g, device, mountpoint);
10503 suppress_error = 0;
10504 r = guestfs_mounts (g);
10508 fprintf (stderr, "test_umount_0: short list returned from command\n");
10513 char expected[] = "/dev/sda1";
10514 expected[5] = devchar;
10515 if (strcmp (r[0], expected) != 0) {
10516 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10520 if (r[1] != NULL) {
10521 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10525 for (i = 0; r[i] != NULL; ++i)
10532 static int test_umount_1_skip (void)
10536 str = getenv ("SKIP_TEST_UMOUNT_1");
10537 if (str && strcmp (str, "1") == 0) return 1;
10538 str = getenv ("SKIP_TEST_UMOUNT");
10539 if (str && strcmp (str, "1") == 0) return 1;
10543 static int test_umount_1 (void)
10545 if (test_umount_1_skip ()) {
10546 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10550 /* InitNone|InitEmpty for test_umount_1 */
10552 char device[] = "/dev/sda";
10553 device[5] = devchar;
10555 suppress_error = 0;
10556 r = guestfs_blockdev_setrw (g, device);
10562 suppress_error = 0;
10563 r = guestfs_umount_all (g);
10569 suppress_error = 0;
10570 r = guestfs_lvm_remove_all (g);
10574 /* TestOutputList for umount (1) */
10576 char device[] = "/dev/sda";
10577 device[5] = devchar;
10578 char lines_0[] = ",";
10584 suppress_error = 0;
10585 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10590 char fstype[] = "ext2";
10591 char device[] = "/dev/sda1";
10592 device[5] = devchar;
10594 suppress_error = 0;
10595 r = guestfs_mkfs (g, fstype, device);
10600 char device[] = "/dev/sda1";
10601 device[5] = devchar;
10602 char mountpoint[] = "/";
10604 suppress_error = 0;
10605 r = guestfs_mount (g, device, mountpoint);
10610 char pathordevice[] = "/";
10612 suppress_error = 0;
10613 r = guestfs_umount (g, pathordevice);
10620 suppress_error = 0;
10621 r = guestfs_mounts (g);
10624 if (r[0] != NULL) {
10625 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10629 for (i = 0; r[i] != NULL; ++i)
10636 static int test_write_file_0_skip (void)
10640 str = getenv ("SKIP_TEST_WRITE_FILE_0");
10641 if (str && strcmp (str, "1") == 0) return 1;
10642 str = getenv ("SKIP_TEST_WRITE_FILE");
10643 if (str && strcmp (str, "1") == 0) return 1;
10647 static int test_write_file_0 (void)
10649 if (test_write_file_0_skip ()) {
10650 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10654 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10656 char device[] = "/dev/sda";
10657 device[5] = devchar;
10659 suppress_error = 0;
10660 r = guestfs_blockdev_setrw (g, device);
10666 suppress_error = 0;
10667 r = guestfs_umount_all (g);
10673 suppress_error = 0;
10674 r = guestfs_lvm_remove_all (g);
10679 char device[] = "/dev/sda";
10680 device[5] = devchar;
10681 char lines_0[] = ",";
10687 suppress_error = 0;
10688 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10693 char fstype[] = "ext2";
10694 char device[] = "/dev/sda1";
10695 device[5] = devchar;
10697 suppress_error = 0;
10698 r = guestfs_mkfs (g, fstype, device);
10703 char device[] = "/dev/sda1";
10704 device[5] = devchar;
10705 char mountpoint[] = "/";
10707 suppress_error = 0;
10708 r = guestfs_mount (g, device, mountpoint);
10712 /* TestOutput for write_file (0) */
10713 char expected[] = "new file contents";
10715 char path[] = "/new";
10716 char content[] = "new file contents";
10718 suppress_error = 0;
10719 r = guestfs_write_file (g, path, content, 0);
10724 char path[] = "/new";
10726 suppress_error = 0;
10727 r = guestfs_cat (g, path);
10730 if (strcmp (r, expected) != 0) {
10731 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10739 static int test_write_file_1_skip (void)
10743 str = getenv ("SKIP_TEST_WRITE_FILE_1");
10744 if (str && strcmp (str, "1") == 0) return 1;
10745 str = getenv ("SKIP_TEST_WRITE_FILE");
10746 if (str && strcmp (str, "1") == 0) return 1;
10750 static int test_write_file_1 (void)
10752 if (test_write_file_1_skip ()) {
10753 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10757 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10759 char device[] = "/dev/sda";
10760 device[5] = devchar;
10762 suppress_error = 0;
10763 r = guestfs_blockdev_setrw (g, device);
10769 suppress_error = 0;
10770 r = guestfs_umount_all (g);
10776 suppress_error = 0;
10777 r = guestfs_lvm_remove_all (g);
10782 char device[] = "/dev/sda";
10783 device[5] = devchar;
10784 char lines_0[] = ",";
10790 suppress_error = 0;
10791 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10796 char fstype[] = "ext2";
10797 char device[] = "/dev/sda1";
10798 device[5] = devchar;
10800 suppress_error = 0;
10801 r = guestfs_mkfs (g, fstype, device);
10806 char device[] = "/dev/sda1";
10807 device[5] = devchar;
10808 char mountpoint[] = "/";
10810 suppress_error = 0;
10811 r = guestfs_mount (g, device, mountpoint);
10815 /* TestOutput for write_file (1) */
10816 char expected[] = "\nnew file contents\n";
10818 char path[] = "/new";
10819 char content[] = "\nnew file contents\n";
10821 suppress_error = 0;
10822 r = guestfs_write_file (g, path, content, 0);
10827 char path[] = "/new";
10829 suppress_error = 0;
10830 r = guestfs_cat (g, path);
10833 if (strcmp (r, expected) != 0) {
10834 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10842 static int test_write_file_2_skip (void)
10846 str = getenv ("SKIP_TEST_WRITE_FILE_2");
10847 if (str && strcmp (str, "1") == 0) return 1;
10848 str = getenv ("SKIP_TEST_WRITE_FILE");
10849 if (str && strcmp (str, "1") == 0) return 1;
10853 static int test_write_file_2 (void)
10855 if (test_write_file_2_skip ()) {
10856 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10860 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10862 char device[] = "/dev/sda";
10863 device[5] = devchar;
10865 suppress_error = 0;
10866 r = guestfs_blockdev_setrw (g, device);
10872 suppress_error = 0;
10873 r = guestfs_umount_all (g);
10879 suppress_error = 0;
10880 r = guestfs_lvm_remove_all (g);
10885 char device[] = "/dev/sda";
10886 device[5] = devchar;
10887 char lines_0[] = ",";
10893 suppress_error = 0;
10894 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10899 char fstype[] = "ext2";
10900 char device[] = "/dev/sda1";
10901 device[5] = devchar;
10903 suppress_error = 0;
10904 r = guestfs_mkfs (g, fstype, device);
10909 char device[] = "/dev/sda1";
10910 device[5] = devchar;
10911 char mountpoint[] = "/";
10913 suppress_error = 0;
10914 r = guestfs_mount (g, device, mountpoint);
10918 /* TestOutput for write_file (2) */
10919 char expected[] = "\n\n";
10921 char path[] = "/new";
10922 char content[] = "\n\n";
10924 suppress_error = 0;
10925 r = guestfs_write_file (g, path, content, 0);
10930 char path[] = "/new";
10932 suppress_error = 0;
10933 r = guestfs_cat (g, path);
10936 if (strcmp (r, expected) != 0) {
10937 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
10945 static int test_write_file_3_skip (void)
10949 str = getenv ("SKIP_TEST_WRITE_FILE_3");
10950 if (str && strcmp (str, "1") == 0) return 1;
10951 str = getenv ("SKIP_TEST_WRITE_FILE");
10952 if (str && strcmp (str, "1") == 0) return 1;
10956 static int test_write_file_3 (void)
10958 if (test_write_file_3_skip ()) {
10959 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
10963 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
10965 char device[] = "/dev/sda";
10966 device[5] = devchar;
10968 suppress_error = 0;
10969 r = guestfs_blockdev_setrw (g, device);
10975 suppress_error = 0;
10976 r = guestfs_umount_all (g);
10982 suppress_error = 0;
10983 r = guestfs_lvm_remove_all (g);
10988 char device[] = "/dev/sda";
10989 device[5] = devchar;
10990 char lines_0[] = ",";
10996 suppress_error = 0;
10997 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11002 char fstype[] = "ext2";
11003 char device[] = "/dev/sda1";
11004 device[5] = devchar;
11006 suppress_error = 0;
11007 r = guestfs_mkfs (g, fstype, device);
11012 char device[] = "/dev/sda1";
11013 device[5] = devchar;
11014 char mountpoint[] = "/";
11016 suppress_error = 0;
11017 r = guestfs_mount (g, device, mountpoint);
11021 /* TestOutput for write_file (3) */
11022 char expected[] = "";
11024 char path[] = "/new";
11025 char content[] = "";
11027 suppress_error = 0;
11028 r = guestfs_write_file (g, path, content, 0);
11033 char path[] = "/new";
11035 suppress_error = 0;
11036 r = guestfs_cat (g, path);
11039 if (strcmp (r, expected) != 0) {
11040 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11048 static int test_write_file_4_skip (void)
11052 str = getenv ("SKIP_TEST_WRITE_FILE_4");
11053 if (str && strcmp (str, "1") == 0) return 1;
11054 str = getenv ("SKIP_TEST_WRITE_FILE");
11055 if (str && strcmp (str, "1") == 0) return 1;
11059 static int test_write_file_4 (void)
11061 if (test_write_file_4_skip ()) {
11062 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11066 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11068 char device[] = "/dev/sda";
11069 device[5] = devchar;
11071 suppress_error = 0;
11072 r = guestfs_blockdev_setrw (g, device);
11078 suppress_error = 0;
11079 r = guestfs_umount_all (g);
11085 suppress_error = 0;
11086 r = guestfs_lvm_remove_all (g);
11091 char device[] = "/dev/sda";
11092 device[5] = devchar;
11093 char lines_0[] = ",";
11099 suppress_error = 0;
11100 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11105 char fstype[] = "ext2";
11106 char device[] = "/dev/sda1";
11107 device[5] = devchar;
11109 suppress_error = 0;
11110 r = guestfs_mkfs (g, fstype, device);
11115 char device[] = "/dev/sda1";
11116 device[5] = devchar;
11117 char mountpoint[] = "/";
11119 suppress_error = 0;
11120 r = guestfs_mount (g, device, mountpoint);
11124 /* TestOutput for write_file (4) */
11125 char expected[] = "\n\n\n";
11127 char path[] = "/new";
11128 char content[] = "\n\n\n";
11130 suppress_error = 0;
11131 r = guestfs_write_file (g, path, content, 0);
11136 char path[] = "/new";
11138 suppress_error = 0;
11139 r = guestfs_cat (g, path);
11142 if (strcmp (r, expected) != 0) {
11143 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11151 static int test_write_file_5_skip (void)
11155 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11156 if (str && strcmp (str, "1") == 0) return 1;
11157 str = getenv ("SKIP_TEST_WRITE_FILE");
11158 if (str && strcmp (str, "1") == 0) return 1;
11162 static int test_write_file_5 (void)
11164 if (test_write_file_5_skip ()) {
11165 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11169 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11171 char device[] = "/dev/sda";
11172 device[5] = devchar;
11174 suppress_error = 0;
11175 r = guestfs_blockdev_setrw (g, device);
11181 suppress_error = 0;
11182 r = guestfs_umount_all (g);
11188 suppress_error = 0;
11189 r = guestfs_lvm_remove_all (g);
11194 char device[] = "/dev/sda";
11195 device[5] = devchar;
11196 char lines_0[] = ",";
11202 suppress_error = 0;
11203 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11208 char fstype[] = "ext2";
11209 char device[] = "/dev/sda1";
11210 device[5] = devchar;
11212 suppress_error = 0;
11213 r = guestfs_mkfs (g, fstype, device);
11218 char device[] = "/dev/sda1";
11219 device[5] = devchar;
11220 char mountpoint[] = "/";
11222 suppress_error = 0;
11223 r = guestfs_mount (g, device, mountpoint);
11227 /* TestOutput for write_file (5) */
11228 char expected[] = "\n";
11230 char path[] = "/new";
11231 char content[] = "\n";
11233 suppress_error = 0;
11234 r = guestfs_write_file (g, path, content, 0);
11239 char path[] = "/new";
11241 suppress_error = 0;
11242 r = guestfs_cat (g, path);
11245 if (strcmp (r, expected) != 0) {
11246 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11254 static int test_mkfs_0_skip (void)
11258 str = getenv ("SKIP_TEST_MKFS_0");
11259 if (str && strcmp (str, "1") == 0) return 1;
11260 str = getenv ("SKIP_TEST_MKFS");
11261 if (str && strcmp (str, "1") == 0) return 1;
11265 static int test_mkfs_0 (void)
11267 if (test_mkfs_0_skip ()) {
11268 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11272 /* InitNone|InitEmpty for test_mkfs_0 */
11274 char device[] = "/dev/sda";
11275 device[5] = devchar;
11277 suppress_error = 0;
11278 r = guestfs_blockdev_setrw (g, device);
11284 suppress_error = 0;
11285 r = guestfs_umount_all (g);
11291 suppress_error = 0;
11292 r = guestfs_lvm_remove_all (g);
11296 /* TestOutput for mkfs (0) */
11297 char expected[] = "new file contents";
11299 char device[] = "/dev/sda";
11300 device[5] = devchar;
11301 char lines_0[] = ",";
11307 suppress_error = 0;
11308 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11313 char fstype[] = "ext2";
11314 char device[] = "/dev/sda1";
11315 device[5] = devchar;
11317 suppress_error = 0;
11318 r = guestfs_mkfs (g, fstype, device);
11323 char device[] = "/dev/sda1";
11324 device[5] = devchar;
11325 char mountpoint[] = "/";
11327 suppress_error = 0;
11328 r = guestfs_mount (g, device, mountpoint);
11333 char path[] = "/new";
11334 char content[] = "new file contents";
11336 suppress_error = 0;
11337 r = guestfs_write_file (g, path, content, 0);
11342 char path[] = "/new";
11344 suppress_error = 0;
11345 r = guestfs_cat (g, path);
11348 if (strcmp (r, expected) != 0) {
11349 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11357 static int test_lvcreate_0_skip (void)
11361 str = getenv ("SKIP_TEST_LVCREATE_0");
11362 if (str && strcmp (str, "1") == 0) return 1;
11363 str = getenv ("SKIP_TEST_LVCREATE");
11364 if (str && strcmp (str, "1") == 0) return 1;
11368 static int test_lvcreate_0 (void)
11370 if (test_lvcreate_0_skip ()) {
11371 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11375 /* InitNone|InitEmpty for test_lvcreate_0 */
11377 char device[] = "/dev/sda";
11378 device[5] = devchar;
11380 suppress_error = 0;
11381 r = guestfs_blockdev_setrw (g, device);
11387 suppress_error = 0;
11388 r = guestfs_umount_all (g);
11394 suppress_error = 0;
11395 r = guestfs_lvm_remove_all (g);
11399 /* TestOutputList for lvcreate (0) */
11401 char device[] = "/dev/sda";
11402 device[5] = devchar;
11403 char lines_0[] = ",10";
11404 char lines_1[] = ",20";
11405 char lines_2[] = ",";
11413 suppress_error = 0;
11414 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11419 char device[] = "/dev/sda1";
11420 device[5] = devchar;
11422 suppress_error = 0;
11423 r = guestfs_pvcreate (g, device);
11428 char device[] = "/dev/sda2";
11429 device[5] = devchar;
11431 suppress_error = 0;
11432 r = guestfs_pvcreate (g, device);
11437 char device[] = "/dev/sda3";
11438 device[5] = devchar;
11440 suppress_error = 0;
11441 r = guestfs_pvcreate (g, device);
11446 char volgroup[] = "VG1";
11447 char physvols_0[] = "/dev/sda1";
11448 physvols_0[5] = devchar;
11449 char physvols_1[] = "/dev/sda2";
11450 physvols_1[5] = devchar;
11451 char *physvols[] = {
11457 suppress_error = 0;
11458 r = guestfs_vgcreate (g, volgroup, physvols);
11463 char volgroup[] = "VG2";
11464 char physvols_0[] = "/dev/sda3";
11465 physvols_0[5] = devchar;
11466 char *physvols[] = {
11471 suppress_error = 0;
11472 r = guestfs_vgcreate (g, volgroup, physvols);
11477 char logvol[] = "LV1";
11478 char volgroup[] = "VG1";
11480 suppress_error = 0;
11481 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11486 char logvol[] = "LV2";
11487 char volgroup[] = "VG1";
11489 suppress_error = 0;
11490 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11495 char logvol[] = "LV3";
11496 char volgroup[] = "VG2";
11498 suppress_error = 0;
11499 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11504 char logvol[] = "LV4";
11505 char volgroup[] = "VG2";
11507 suppress_error = 0;
11508 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11513 char logvol[] = "LV5";
11514 char volgroup[] = "VG2";
11516 suppress_error = 0;
11517 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11524 suppress_error = 0;
11525 r = guestfs_lvs (g);
11529 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11534 char expected[] = "/dev/VG1/LV1";
11535 if (strcmp (r[0], expected) != 0) {
11536 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11541 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11546 char expected[] = "/dev/VG1/LV2";
11547 if (strcmp (r[1], expected) != 0) {
11548 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11553 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11558 char expected[] = "/dev/VG2/LV3";
11559 if (strcmp (r[2], expected) != 0) {
11560 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11565 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11570 char expected[] = "/dev/VG2/LV4";
11571 if (strcmp (r[3], expected) != 0) {
11572 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11577 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11582 char expected[] = "/dev/VG2/LV5";
11583 if (strcmp (r[4], expected) != 0) {
11584 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11588 if (r[5] != NULL) {
11589 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11593 for (i = 0; r[i] != NULL; ++i)
11600 static int test_vgcreate_0_skip (void)
11604 str = getenv ("SKIP_TEST_VGCREATE_0");
11605 if (str && strcmp (str, "1") == 0) return 1;
11606 str = getenv ("SKIP_TEST_VGCREATE");
11607 if (str && strcmp (str, "1") == 0) return 1;
11611 static int test_vgcreate_0 (void)
11613 if (test_vgcreate_0_skip ()) {
11614 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11618 /* InitNone|InitEmpty for test_vgcreate_0 */
11620 char device[] = "/dev/sda";
11621 device[5] = devchar;
11623 suppress_error = 0;
11624 r = guestfs_blockdev_setrw (g, device);
11630 suppress_error = 0;
11631 r = guestfs_umount_all (g);
11637 suppress_error = 0;
11638 r = guestfs_lvm_remove_all (g);
11642 /* TestOutputList for vgcreate (0) */
11644 char device[] = "/dev/sda";
11645 device[5] = devchar;
11646 char lines_0[] = ",10";
11647 char lines_1[] = ",20";
11648 char lines_2[] = ",";
11656 suppress_error = 0;
11657 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11662 char device[] = "/dev/sda1";
11663 device[5] = devchar;
11665 suppress_error = 0;
11666 r = guestfs_pvcreate (g, device);
11671 char device[] = "/dev/sda2";
11672 device[5] = devchar;
11674 suppress_error = 0;
11675 r = guestfs_pvcreate (g, device);
11680 char device[] = "/dev/sda3";
11681 device[5] = devchar;
11683 suppress_error = 0;
11684 r = guestfs_pvcreate (g, device);
11689 char volgroup[] = "VG1";
11690 char physvols_0[] = "/dev/sda1";
11691 physvols_0[5] = devchar;
11692 char physvols_1[] = "/dev/sda2";
11693 physvols_1[5] = devchar;
11694 char *physvols[] = {
11700 suppress_error = 0;
11701 r = guestfs_vgcreate (g, volgroup, physvols);
11706 char volgroup[] = "VG2";
11707 char physvols_0[] = "/dev/sda3";
11708 physvols_0[5] = devchar;
11709 char *physvols[] = {
11714 suppress_error = 0;
11715 r = guestfs_vgcreate (g, volgroup, physvols);
11722 suppress_error = 0;
11723 r = guestfs_vgs (g);
11727 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11732 char expected[] = "VG1";
11733 if (strcmp (r[0], expected) != 0) {
11734 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11739 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11744 char expected[] = "VG2";
11745 if (strcmp (r[1], expected) != 0) {
11746 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11750 if (r[2] != NULL) {
11751 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11755 for (i = 0; r[i] != NULL; ++i)
11762 static int test_pvcreate_0_skip (void)
11766 str = getenv ("SKIP_TEST_PVCREATE_0");
11767 if (str && strcmp (str, "1") == 0) return 1;
11768 str = getenv ("SKIP_TEST_PVCREATE");
11769 if (str && strcmp (str, "1") == 0) return 1;
11773 static int test_pvcreate_0 (void)
11775 if (test_pvcreate_0_skip ()) {
11776 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11780 /* InitNone|InitEmpty for test_pvcreate_0 */
11782 char device[] = "/dev/sda";
11783 device[5] = devchar;
11785 suppress_error = 0;
11786 r = guestfs_blockdev_setrw (g, device);
11792 suppress_error = 0;
11793 r = guestfs_umount_all (g);
11799 suppress_error = 0;
11800 r = guestfs_lvm_remove_all (g);
11804 /* TestOutputList for pvcreate (0) */
11806 char device[] = "/dev/sda";
11807 device[5] = devchar;
11808 char lines_0[] = ",10";
11809 char lines_1[] = ",20";
11810 char lines_2[] = ",";
11818 suppress_error = 0;
11819 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11824 char device[] = "/dev/sda1";
11825 device[5] = devchar;
11827 suppress_error = 0;
11828 r = guestfs_pvcreate (g, device);
11833 char device[] = "/dev/sda2";
11834 device[5] = devchar;
11836 suppress_error = 0;
11837 r = guestfs_pvcreate (g, device);
11842 char device[] = "/dev/sda3";
11843 device[5] = devchar;
11845 suppress_error = 0;
11846 r = guestfs_pvcreate (g, device);
11853 suppress_error = 0;
11854 r = guestfs_pvs (g);
11858 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11863 char expected[] = "/dev/sda1";
11864 expected[5] = devchar;
11865 if (strcmp (r[0], expected) != 0) {
11866 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11871 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11876 char expected[] = "/dev/sda2";
11877 expected[5] = devchar;
11878 if (strcmp (r[1], expected) != 0) {
11879 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11884 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11889 char expected[] = "/dev/sda3";
11890 expected[5] = devchar;
11891 if (strcmp (r[2], expected) != 0) {
11892 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11896 if (r[3] != NULL) {
11897 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
11901 for (i = 0; r[i] != NULL; ++i)
11908 static int test_is_dir_0_skip (void)
11912 str = getenv ("SKIP_TEST_IS_DIR_0");
11913 if (str && strcmp (str, "1") == 0) return 1;
11914 str = getenv ("SKIP_TEST_IS_DIR");
11915 if (str && strcmp (str, "1") == 0) return 1;
11919 static int test_is_dir_0 (void)
11921 if (test_is_dir_0_skip ()) {
11922 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
11926 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
11928 char device[] = "/dev/sda";
11929 device[5] = devchar;
11931 suppress_error = 0;
11932 r = guestfs_blockdev_setrw (g, device);
11938 suppress_error = 0;
11939 r = guestfs_umount_all (g);
11945 suppress_error = 0;
11946 r = guestfs_lvm_remove_all (g);
11951 char device[] = "/dev/sda";
11952 device[5] = devchar;
11953 char lines_0[] = ",";
11959 suppress_error = 0;
11960 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11965 char fstype[] = "ext2";
11966 char device[] = "/dev/sda1";
11967 device[5] = devchar;
11969 suppress_error = 0;
11970 r = guestfs_mkfs (g, fstype, device);
11975 char device[] = "/dev/sda1";
11976 device[5] = devchar;
11977 char mountpoint[] = "/";
11979 suppress_error = 0;
11980 r = guestfs_mount (g, device, mountpoint);
11984 /* TestOutputFalse for is_dir (0) */
11986 char path[] = "/new";
11988 suppress_error = 0;
11989 r = guestfs_touch (g, path);
11994 char path[] = "/new";
11996 suppress_error = 0;
11997 r = guestfs_is_dir (g, path);
12001 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12008 static int test_is_dir_1_skip (void)
12012 str = getenv ("SKIP_TEST_IS_DIR_1");
12013 if (str && strcmp (str, "1") == 0) return 1;
12014 str = getenv ("SKIP_TEST_IS_DIR");
12015 if (str && strcmp (str, "1") == 0) return 1;
12019 static int test_is_dir_1 (void)
12021 if (test_is_dir_1_skip ()) {
12022 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12026 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12028 char device[] = "/dev/sda";
12029 device[5] = devchar;
12031 suppress_error = 0;
12032 r = guestfs_blockdev_setrw (g, device);
12038 suppress_error = 0;
12039 r = guestfs_umount_all (g);
12045 suppress_error = 0;
12046 r = guestfs_lvm_remove_all (g);
12051 char device[] = "/dev/sda";
12052 device[5] = devchar;
12053 char lines_0[] = ",";
12059 suppress_error = 0;
12060 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12065 char fstype[] = "ext2";
12066 char device[] = "/dev/sda1";
12067 device[5] = devchar;
12069 suppress_error = 0;
12070 r = guestfs_mkfs (g, fstype, device);
12075 char device[] = "/dev/sda1";
12076 device[5] = devchar;
12077 char mountpoint[] = "/";
12079 suppress_error = 0;
12080 r = guestfs_mount (g, device, mountpoint);
12084 /* TestOutputTrue for is_dir (1) */
12086 char path[] = "/new";
12088 suppress_error = 0;
12089 r = guestfs_mkdir (g, path);
12094 char path[] = "/new";
12096 suppress_error = 0;
12097 r = guestfs_is_dir (g, path);
12101 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12108 static int test_is_file_0_skip (void)
12112 str = getenv ("SKIP_TEST_IS_FILE_0");
12113 if (str && strcmp (str, "1") == 0) return 1;
12114 str = getenv ("SKIP_TEST_IS_FILE");
12115 if (str && strcmp (str, "1") == 0) return 1;
12119 static int test_is_file_0 (void)
12121 if (test_is_file_0_skip ()) {
12122 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12126 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12128 char device[] = "/dev/sda";
12129 device[5] = devchar;
12131 suppress_error = 0;
12132 r = guestfs_blockdev_setrw (g, device);
12138 suppress_error = 0;
12139 r = guestfs_umount_all (g);
12145 suppress_error = 0;
12146 r = guestfs_lvm_remove_all (g);
12151 char device[] = "/dev/sda";
12152 device[5] = devchar;
12153 char lines_0[] = ",";
12159 suppress_error = 0;
12160 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12165 char fstype[] = "ext2";
12166 char device[] = "/dev/sda1";
12167 device[5] = devchar;
12169 suppress_error = 0;
12170 r = guestfs_mkfs (g, fstype, device);
12175 char device[] = "/dev/sda1";
12176 device[5] = devchar;
12177 char mountpoint[] = "/";
12179 suppress_error = 0;
12180 r = guestfs_mount (g, device, mountpoint);
12184 /* TestOutputTrue for is_file (0) */
12186 char path[] = "/new";
12188 suppress_error = 0;
12189 r = guestfs_touch (g, path);
12194 char path[] = "/new";
12196 suppress_error = 0;
12197 r = guestfs_is_file (g, path);
12201 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12208 static int test_is_file_1_skip (void)
12212 str = getenv ("SKIP_TEST_IS_FILE_1");
12213 if (str && strcmp (str, "1") == 0) return 1;
12214 str = getenv ("SKIP_TEST_IS_FILE");
12215 if (str && strcmp (str, "1") == 0) return 1;
12219 static int test_is_file_1 (void)
12221 if (test_is_file_1_skip ()) {
12222 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12226 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12228 char device[] = "/dev/sda";
12229 device[5] = devchar;
12231 suppress_error = 0;
12232 r = guestfs_blockdev_setrw (g, device);
12238 suppress_error = 0;
12239 r = guestfs_umount_all (g);
12245 suppress_error = 0;
12246 r = guestfs_lvm_remove_all (g);
12251 char device[] = "/dev/sda";
12252 device[5] = devchar;
12253 char lines_0[] = ",";
12259 suppress_error = 0;
12260 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12265 char fstype[] = "ext2";
12266 char device[] = "/dev/sda1";
12267 device[5] = devchar;
12269 suppress_error = 0;
12270 r = guestfs_mkfs (g, fstype, device);
12275 char device[] = "/dev/sda1";
12276 device[5] = devchar;
12277 char mountpoint[] = "/";
12279 suppress_error = 0;
12280 r = guestfs_mount (g, device, mountpoint);
12284 /* TestOutputFalse for is_file (1) */
12286 char path[] = "/new";
12288 suppress_error = 0;
12289 r = guestfs_mkdir (g, path);
12294 char path[] = "/new";
12296 suppress_error = 0;
12297 r = guestfs_is_file (g, path);
12301 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12308 static int test_exists_0_skip (void)
12312 str = getenv ("SKIP_TEST_EXISTS_0");
12313 if (str && strcmp (str, "1") == 0) return 1;
12314 str = getenv ("SKIP_TEST_EXISTS");
12315 if (str && strcmp (str, "1") == 0) return 1;
12319 static int test_exists_0 (void)
12321 if (test_exists_0_skip ()) {
12322 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12326 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12328 char device[] = "/dev/sda";
12329 device[5] = devchar;
12331 suppress_error = 0;
12332 r = guestfs_blockdev_setrw (g, device);
12338 suppress_error = 0;
12339 r = guestfs_umount_all (g);
12345 suppress_error = 0;
12346 r = guestfs_lvm_remove_all (g);
12351 char device[] = "/dev/sda";
12352 device[5] = devchar;
12353 char lines_0[] = ",";
12359 suppress_error = 0;
12360 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12365 char fstype[] = "ext2";
12366 char device[] = "/dev/sda1";
12367 device[5] = devchar;
12369 suppress_error = 0;
12370 r = guestfs_mkfs (g, fstype, device);
12375 char device[] = "/dev/sda1";
12376 device[5] = devchar;
12377 char mountpoint[] = "/";
12379 suppress_error = 0;
12380 r = guestfs_mount (g, device, mountpoint);
12384 /* TestOutputTrue for exists (0) */
12386 char path[] = "/new";
12388 suppress_error = 0;
12389 r = guestfs_touch (g, path);
12394 char path[] = "/new";
12396 suppress_error = 0;
12397 r = guestfs_exists (g, path);
12401 fprintf (stderr, "test_exists_0: expected true, got false\n");
12408 static int test_exists_1_skip (void)
12412 str = getenv ("SKIP_TEST_EXISTS_1");
12413 if (str && strcmp (str, "1") == 0) return 1;
12414 str = getenv ("SKIP_TEST_EXISTS");
12415 if (str && strcmp (str, "1") == 0) return 1;
12419 static int test_exists_1 (void)
12421 if (test_exists_1_skip ()) {
12422 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12426 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12428 char device[] = "/dev/sda";
12429 device[5] = devchar;
12431 suppress_error = 0;
12432 r = guestfs_blockdev_setrw (g, device);
12438 suppress_error = 0;
12439 r = guestfs_umount_all (g);
12445 suppress_error = 0;
12446 r = guestfs_lvm_remove_all (g);
12451 char device[] = "/dev/sda";
12452 device[5] = devchar;
12453 char lines_0[] = ",";
12459 suppress_error = 0;
12460 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12465 char fstype[] = "ext2";
12466 char device[] = "/dev/sda1";
12467 device[5] = devchar;
12469 suppress_error = 0;
12470 r = guestfs_mkfs (g, fstype, device);
12475 char device[] = "/dev/sda1";
12476 device[5] = devchar;
12477 char mountpoint[] = "/";
12479 suppress_error = 0;
12480 r = guestfs_mount (g, device, mountpoint);
12484 /* TestOutputTrue for exists (1) */
12486 char path[] = "/new";
12488 suppress_error = 0;
12489 r = guestfs_mkdir (g, path);
12494 char path[] = "/new";
12496 suppress_error = 0;
12497 r = guestfs_exists (g, path);
12501 fprintf (stderr, "test_exists_1: expected true, got false\n");
12508 static int test_mkdir_p_0_skip (void)
12512 str = getenv ("SKIP_TEST_MKDIR_P_0");
12513 if (str && strcmp (str, "1") == 0) return 1;
12514 str = getenv ("SKIP_TEST_MKDIR_P");
12515 if (str && strcmp (str, "1") == 0) return 1;
12519 static int test_mkdir_p_0 (void)
12521 if (test_mkdir_p_0_skip ()) {
12522 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12526 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12528 char device[] = "/dev/sda";
12529 device[5] = devchar;
12531 suppress_error = 0;
12532 r = guestfs_blockdev_setrw (g, device);
12538 suppress_error = 0;
12539 r = guestfs_umount_all (g);
12545 suppress_error = 0;
12546 r = guestfs_lvm_remove_all (g);
12551 char device[] = "/dev/sda";
12552 device[5] = devchar;
12553 char lines_0[] = ",";
12559 suppress_error = 0;
12560 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12565 char fstype[] = "ext2";
12566 char device[] = "/dev/sda1";
12567 device[5] = devchar;
12569 suppress_error = 0;
12570 r = guestfs_mkfs (g, fstype, device);
12575 char device[] = "/dev/sda1";
12576 device[5] = devchar;
12577 char mountpoint[] = "/";
12579 suppress_error = 0;
12580 r = guestfs_mount (g, device, mountpoint);
12584 /* TestOutputTrue for mkdir_p (0) */
12586 char path[] = "/new/foo/bar";
12588 suppress_error = 0;
12589 r = guestfs_mkdir_p (g, path);
12594 char path[] = "/new/foo/bar";
12596 suppress_error = 0;
12597 r = guestfs_is_dir (g, path);
12601 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12608 static int test_mkdir_p_1_skip (void)
12612 str = getenv ("SKIP_TEST_MKDIR_P_1");
12613 if (str && strcmp (str, "1") == 0) return 1;
12614 str = getenv ("SKIP_TEST_MKDIR_P");
12615 if (str && strcmp (str, "1") == 0) return 1;
12619 static int test_mkdir_p_1 (void)
12621 if (test_mkdir_p_1_skip ()) {
12622 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12626 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12628 char device[] = "/dev/sda";
12629 device[5] = devchar;
12631 suppress_error = 0;
12632 r = guestfs_blockdev_setrw (g, device);
12638 suppress_error = 0;
12639 r = guestfs_umount_all (g);
12645 suppress_error = 0;
12646 r = guestfs_lvm_remove_all (g);
12651 char device[] = "/dev/sda";
12652 device[5] = devchar;
12653 char lines_0[] = ",";
12659 suppress_error = 0;
12660 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12665 char fstype[] = "ext2";
12666 char device[] = "/dev/sda1";
12667 device[5] = devchar;
12669 suppress_error = 0;
12670 r = guestfs_mkfs (g, fstype, device);
12675 char device[] = "/dev/sda1";
12676 device[5] = devchar;
12677 char mountpoint[] = "/";
12679 suppress_error = 0;
12680 r = guestfs_mount (g, device, mountpoint);
12684 /* TestOutputTrue for mkdir_p (1) */
12686 char path[] = "/new/foo/bar";
12688 suppress_error = 0;
12689 r = guestfs_mkdir_p (g, path);
12694 char path[] = "/new/foo";
12696 suppress_error = 0;
12697 r = guestfs_is_dir (g, path);
12701 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12708 static int test_mkdir_p_2_skip (void)
12712 str = getenv ("SKIP_TEST_MKDIR_P_2");
12713 if (str && strcmp (str, "1") == 0) return 1;
12714 str = getenv ("SKIP_TEST_MKDIR_P");
12715 if (str && strcmp (str, "1") == 0) return 1;
12719 static int test_mkdir_p_2 (void)
12721 if (test_mkdir_p_2_skip ()) {
12722 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12726 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12728 char device[] = "/dev/sda";
12729 device[5] = devchar;
12731 suppress_error = 0;
12732 r = guestfs_blockdev_setrw (g, device);
12738 suppress_error = 0;
12739 r = guestfs_umount_all (g);
12745 suppress_error = 0;
12746 r = guestfs_lvm_remove_all (g);
12751 char device[] = "/dev/sda";
12752 device[5] = devchar;
12753 char lines_0[] = ",";
12759 suppress_error = 0;
12760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12765 char fstype[] = "ext2";
12766 char device[] = "/dev/sda1";
12767 device[5] = devchar;
12769 suppress_error = 0;
12770 r = guestfs_mkfs (g, fstype, device);
12775 char device[] = "/dev/sda1";
12776 device[5] = devchar;
12777 char mountpoint[] = "/";
12779 suppress_error = 0;
12780 r = guestfs_mount (g, device, mountpoint);
12784 /* TestOutputTrue for mkdir_p (2) */
12786 char path[] = "/new/foo/bar";
12788 suppress_error = 0;
12789 r = guestfs_mkdir_p (g, path);
12794 char path[] = "/new";
12796 suppress_error = 0;
12797 r = guestfs_is_dir (g, path);
12801 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12808 static int test_mkdir_p_3_skip (void)
12812 str = getenv ("SKIP_TEST_MKDIR_P_3");
12813 if (str && strcmp (str, "1") == 0) return 1;
12814 str = getenv ("SKIP_TEST_MKDIR_P");
12815 if (str && strcmp (str, "1") == 0) return 1;
12819 static int test_mkdir_p_3 (void)
12821 if (test_mkdir_p_3_skip ()) {
12822 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12826 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12828 char device[] = "/dev/sda";
12829 device[5] = devchar;
12831 suppress_error = 0;
12832 r = guestfs_blockdev_setrw (g, device);
12838 suppress_error = 0;
12839 r = guestfs_umount_all (g);
12845 suppress_error = 0;
12846 r = guestfs_lvm_remove_all (g);
12851 char device[] = "/dev/sda";
12852 device[5] = devchar;
12853 char lines_0[] = ",";
12859 suppress_error = 0;
12860 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12865 char fstype[] = "ext2";
12866 char device[] = "/dev/sda1";
12867 device[5] = devchar;
12869 suppress_error = 0;
12870 r = guestfs_mkfs (g, fstype, device);
12875 char device[] = "/dev/sda1";
12876 device[5] = devchar;
12877 char mountpoint[] = "/";
12879 suppress_error = 0;
12880 r = guestfs_mount (g, device, mountpoint);
12884 /* TestRun for mkdir_p (3) */
12886 char path[] = "/new";
12888 suppress_error = 0;
12889 r = guestfs_mkdir (g, path);
12894 char path[] = "/new";
12896 suppress_error = 0;
12897 r = guestfs_mkdir_p (g, path);
12904 static int test_mkdir_p_4_skip (void)
12908 str = getenv ("SKIP_TEST_MKDIR_P_4");
12909 if (str && strcmp (str, "1") == 0) return 1;
12910 str = getenv ("SKIP_TEST_MKDIR_P");
12911 if (str && strcmp (str, "1") == 0) return 1;
12915 static int test_mkdir_p_4 (void)
12917 if (test_mkdir_p_4_skip ()) {
12918 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
12922 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
12924 char device[] = "/dev/sda";
12925 device[5] = devchar;
12927 suppress_error = 0;
12928 r = guestfs_blockdev_setrw (g, device);
12934 suppress_error = 0;
12935 r = guestfs_umount_all (g);
12941 suppress_error = 0;
12942 r = guestfs_lvm_remove_all (g);
12947 char device[] = "/dev/sda";
12948 device[5] = devchar;
12949 char lines_0[] = ",";
12955 suppress_error = 0;
12956 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12961 char fstype[] = "ext2";
12962 char device[] = "/dev/sda1";
12963 device[5] = devchar;
12965 suppress_error = 0;
12966 r = guestfs_mkfs (g, fstype, device);
12971 char device[] = "/dev/sda1";
12972 device[5] = devchar;
12973 char mountpoint[] = "/";
12975 suppress_error = 0;
12976 r = guestfs_mount (g, device, mountpoint);
12980 /* TestLastFail for mkdir_p (4) */
12982 char path[] = "/new";
12984 suppress_error = 0;
12985 r = guestfs_touch (g, path);
12990 char path[] = "/new";
12992 suppress_error = 1;
12993 r = guestfs_mkdir_p (g, path);
13000 static int test_mkdir_0_skip (void)
13004 str = getenv ("SKIP_TEST_MKDIR_0");
13005 if (str && strcmp (str, "1") == 0) return 1;
13006 str = getenv ("SKIP_TEST_MKDIR");
13007 if (str && strcmp (str, "1") == 0) return 1;
13011 static int test_mkdir_0 (void)
13013 if (test_mkdir_0_skip ()) {
13014 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13018 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13020 char device[] = "/dev/sda";
13021 device[5] = devchar;
13023 suppress_error = 0;
13024 r = guestfs_blockdev_setrw (g, device);
13030 suppress_error = 0;
13031 r = guestfs_umount_all (g);
13037 suppress_error = 0;
13038 r = guestfs_lvm_remove_all (g);
13043 char device[] = "/dev/sda";
13044 device[5] = devchar;
13045 char lines_0[] = ",";
13051 suppress_error = 0;
13052 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13057 char fstype[] = "ext2";
13058 char device[] = "/dev/sda1";
13059 device[5] = devchar;
13061 suppress_error = 0;
13062 r = guestfs_mkfs (g, fstype, device);
13067 char device[] = "/dev/sda1";
13068 device[5] = devchar;
13069 char mountpoint[] = "/";
13071 suppress_error = 0;
13072 r = guestfs_mount (g, device, mountpoint);
13076 /* TestOutputTrue for mkdir (0) */
13078 char path[] = "/new";
13080 suppress_error = 0;
13081 r = guestfs_mkdir (g, path);
13086 char path[] = "/new";
13088 suppress_error = 0;
13089 r = guestfs_is_dir (g, path);
13093 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13100 static int test_mkdir_1_skip (void)
13104 str = getenv ("SKIP_TEST_MKDIR_1");
13105 if (str && strcmp (str, "1") == 0) return 1;
13106 str = getenv ("SKIP_TEST_MKDIR");
13107 if (str && strcmp (str, "1") == 0) return 1;
13111 static int test_mkdir_1 (void)
13113 if (test_mkdir_1_skip ()) {
13114 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13118 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13120 char device[] = "/dev/sda";
13121 device[5] = devchar;
13123 suppress_error = 0;
13124 r = guestfs_blockdev_setrw (g, device);
13130 suppress_error = 0;
13131 r = guestfs_umount_all (g);
13137 suppress_error = 0;
13138 r = guestfs_lvm_remove_all (g);
13143 char device[] = "/dev/sda";
13144 device[5] = devchar;
13145 char lines_0[] = ",";
13151 suppress_error = 0;
13152 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13157 char fstype[] = "ext2";
13158 char device[] = "/dev/sda1";
13159 device[5] = devchar;
13161 suppress_error = 0;
13162 r = guestfs_mkfs (g, fstype, device);
13167 char device[] = "/dev/sda1";
13168 device[5] = devchar;
13169 char mountpoint[] = "/";
13171 suppress_error = 0;
13172 r = guestfs_mount (g, device, mountpoint);
13176 /* TestLastFail for mkdir (1) */
13178 char path[] = "/new/foo/bar";
13180 suppress_error = 1;
13181 r = guestfs_mkdir (g, path);
13188 static int test_rm_rf_0_skip (void)
13192 str = getenv ("SKIP_TEST_RM_RF_0");
13193 if (str && strcmp (str, "1") == 0) return 1;
13194 str = getenv ("SKIP_TEST_RM_RF");
13195 if (str && strcmp (str, "1") == 0) return 1;
13199 static int test_rm_rf_0 (void)
13201 if (test_rm_rf_0_skip ()) {
13202 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13206 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13208 char device[] = "/dev/sda";
13209 device[5] = devchar;
13211 suppress_error = 0;
13212 r = guestfs_blockdev_setrw (g, device);
13218 suppress_error = 0;
13219 r = guestfs_umount_all (g);
13225 suppress_error = 0;
13226 r = guestfs_lvm_remove_all (g);
13231 char device[] = "/dev/sda";
13232 device[5] = devchar;
13233 char lines_0[] = ",";
13239 suppress_error = 0;
13240 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13245 char fstype[] = "ext2";
13246 char device[] = "/dev/sda1";
13247 device[5] = devchar;
13249 suppress_error = 0;
13250 r = guestfs_mkfs (g, fstype, device);
13255 char device[] = "/dev/sda1";
13256 device[5] = devchar;
13257 char mountpoint[] = "/";
13259 suppress_error = 0;
13260 r = guestfs_mount (g, device, mountpoint);
13264 /* TestOutputFalse for rm_rf (0) */
13266 char path[] = "/new";
13268 suppress_error = 0;
13269 r = guestfs_mkdir (g, path);
13274 char path[] = "/new/foo";
13276 suppress_error = 0;
13277 r = guestfs_mkdir (g, path);
13282 char path[] = "/new/foo/bar";
13284 suppress_error = 0;
13285 r = guestfs_touch (g, path);
13290 char path[] = "/new";
13292 suppress_error = 0;
13293 r = guestfs_rm_rf (g, path);
13298 char path[] = "/new";
13300 suppress_error = 0;
13301 r = guestfs_exists (g, path);
13305 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13312 static int test_rmdir_0_skip (void)
13316 str = getenv ("SKIP_TEST_RMDIR_0");
13317 if (str && strcmp (str, "1") == 0) return 1;
13318 str = getenv ("SKIP_TEST_RMDIR");
13319 if (str && strcmp (str, "1") == 0) return 1;
13323 static int test_rmdir_0 (void)
13325 if (test_rmdir_0_skip ()) {
13326 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13330 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13332 char device[] = "/dev/sda";
13333 device[5] = devchar;
13335 suppress_error = 0;
13336 r = guestfs_blockdev_setrw (g, device);
13342 suppress_error = 0;
13343 r = guestfs_umount_all (g);
13349 suppress_error = 0;
13350 r = guestfs_lvm_remove_all (g);
13355 char device[] = "/dev/sda";
13356 device[5] = devchar;
13357 char lines_0[] = ",";
13363 suppress_error = 0;
13364 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13369 char fstype[] = "ext2";
13370 char device[] = "/dev/sda1";
13371 device[5] = devchar;
13373 suppress_error = 0;
13374 r = guestfs_mkfs (g, fstype, device);
13379 char device[] = "/dev/sda1";
13380 device[5] = devchar;
13381 char mountpoint[] = "/";
13383 suppress_error = 0;
13384 r = guestfs_mount (g, device, mountpoint);
13388 /* TestRun for rmdir (0) */
13390 char path[] = "/new";
13392 suppress_error = 0;
13393 r = guestfs_mkdir (g, path);
13398 char path[] = "/new";
13400 suppress_error = 0;
13401 r = guestfs_rmdir (g, path);
13408 static int test_rmdir_1_skip (void)
13412 str = getenv ("SKIP_TEST_RMDIR_1");
13413 if (str && strcmp (str, "1") == 0) return 1;
13414 str = getenv ("SKIP_TEST_RMDIR");
13415 if (str && strcmp (str, "1") == 0) return 1;
13419 static int test_rmdir_1 (void)
13421 if (test_rmdir_1_skip ()) {
13422 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13426 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13428 char device[] = "/dev/sda";
13429 device[5] = devchar;
13431 suppress_error = 0;
13432 r = guestfs_blockdev_setrw (g, device);
13438 suppress_error = 0;
13439 r = guestfs_umount_all (g);
13445 suppress_error = 0;
13446 r = guestfs_lvm_remove_all (g);
13451 char device[] = "/dev/sda";
13452 device[5] = devchar;
13453 char lines_0[] = ",";
13459 suppress_error = 0;
13460 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13465 char fstype[] = "ext2";
13466 char device[] = "/dev/sda1";
13467 device[5] = devchar;
13469 suppress_error = 0;
13470 r = guestfs_mkfs (g, fstype, device);
13475 char device[] = "/dev/sda1";
13476 device[5] = devchar;
13477 char mountpoint[] = "/";
13479 suppress_error = 0;
13480 r = guestfs_mount (g, device, mountpoint);
13484 /* TestLastFail for rmdir (1) */
13486 char path[] = "/new";
13488 suppress_error = 1;
13489 r = guestfs_rmdir (g, path);
13496 static int test_rmdir_2_skip (void)
13500 str = getenv ("SKIP_TEST_RMDIR_2");
13501 if (str && strcmp (str, "1") == 0) return 1;
13502 str = getenv ("SKIP_TEST_RMDIR");
13503 if (str && strcmp (str, "1") == 0) return 1;
13507 static int test_rmdir_2 (void)
13509 if (test_rmdir_2_skip ()) {
13510 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13514 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13516 char device[] = "/dev/sda";
13517 device[5] = devchar;
13519 suppress_error = 0;
13520 r = guestfs_blockdev_setrw (g, device);
13526 suppress_error = 0;
13527 r = guestfs_umount_all (g);
13533 suppress_error = 0;
13534 r = guestfs_lvm_remove_all (g);
13539 char device[] = "/dev/sda";
13540 device[5] = devchar;
13541 char lines_0[] = ",";
13547 suppress_error = 0;
13548 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13553 char fstype[] = "ext2";
13554 char device[] = "/dev/sda1";
13555 device[5] = devchar;
13557 suppress_error = 0;
13558 r = guestfs_mkfs (g, fstype, device);
13563 char device[] = "/dev/sda1";
13564 device[5] = devchar;
13565 char mountpoint[] = "/";
13567 suppress_error = 0;
13568 r = guestfs_mount (g, device, mountpoint);
13572 /* TestLastFail for rmdir (2) */
13574 char path[] = "/new";
13576 suppress_error = 0;
13577 r = guestfs_touch (g, path);
13582 char path[] = "/new";
13584 suppress_error = 1;
13585 r = guestfs_rmdir (g, path);
13592 static int test_rm_0_skip (void)
13596 str = getenv ("SKIP_TEST_RM_0");
13597 if (str && strcmp (str, "1") == 0) return 1;
13598 str = getenv ("SKIP_TEST_RM");
13599 if (str && strcmp (str, "1") == 0) return 1;
13603 static int test_rm_0 (void)
13605 if (test_rm_0_skip ()) {
13606 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13610 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13612 char device[] = "/dev/sda";
13613 device[5] = devchar;
13615 suppress_error = 0;
13616 r = guestfs_blockdev_setrw (g, device);
13622 suppress_error = 0;
13623 r = guestfs_umount_all (g);
13629 suppress_error = 0;
13630 r = guestfs_lvm_remove_all (g);
13635 char device[] = "/dev/sda";
13636 device[5] = devchar;
13637 char lines_0[] = ",";
13643 suppress_error = 0;
13644 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13649 char fstype[] = "ext2";
13650 char device[] = "/dev/sda1";
13651 device[5] = devchar;
13653 suppress_error = 0;
13654 r = guestfs_mkfs (g, fstype, device);
13659 char device[] = "/dev/sda1";
13660 device[5] = devchar;
13661 char mountpoint[] = "/";
13663 suppress_error = 0;
13664 r = guestfs_mount (g, device, mountpoint);
13668 /* TestRun for rm (0) */
13670 char path[] = "/new";
13672 suppress_error = 0;
13673 r = guestfs_touch (g, path);
13678 char path[] = "/new";
13680 suppress_error = 0;
13681 r = guestfs_rm (g, path);
13688 static int test_rm_1_skip (void)
13692 str = getenv ("SKIP_TEST_RM_1");
13693 if (str && strcmp (str, "1") == 0) return 1;
13694 str = getenv ("SKIP_TEST_RM");
13695 if (str && strcmp (str, "1") == 0) return 1;
13699 static int test_rm_1 (void)
13701 if (test_rm_1_skip ()) {
13702 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13706 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13708 char device[] = "/dev/sda";
13709 device[5] = devchar;
13711 suppress_error = 0;
13712 r = guestfs_blockdev_setrw (g, device);
13718 suppress_error = 0;
13719 r = guestfs_umount_all (g);
13725 suppress_error = 0;
13726 r = guestfs_lvm_remove_all (g);
13731 char device[] = "/dev/sda";
13732 device[5] = devchar;
13733 char lines_0[] = ",";
13739 suppress_error = 0;
13740 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13745 char fstype[] = "ext2";
13746 char device[] = "/dev/sda1";
13747 device[5] = devchar;
13749 suppress_error = 0;
13750 r = guestfs_mkfs (g, fstype, device);
13755 char device[] = "/dev/sda1";
13756 device[5] = devchar;
13757 char mountpoint[] = "/";
13759 suppress_error = 0;
13760 r = guestfs_mount (g, device, mountpoint);
13764 /* TestLastFail for rm (1) */
13766 char path[] = "/new";
13768 suppress_error = 1;
13769 r = guestfs_rm (g, path);
13776 static int test_rm_2_skip (void)
13780 str = getenv ("SKIP_TEST_RM_2");
13781 if (str && strcmp (str, "1") == 0) return 1;
13782 str = getenv ("SKIP_TEST_RM");
13783 if (str && strcmp (str, "1") == 0) return 1;
13787 static int test_rm_2 (void)
13789 if (test_rm_2_skip ()) {
13790 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13794 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13796 char device[] = "/dev/sda";
13797 device[5] = devchar;
13799 suppress_error = 0;
13800 r = guestfs_blockdev_setrw (g, device);
13806 suppress_error = 0;
13807 r = guestfs_umount_all (g);
13813 suppress_error = 0;
13814 r = guestfs_lvm_remove_all (g);
13819 char device[] = "/dev/sda";
13820 device[5] = devchar;
13821 char lines_0[] = ",";
13827 suppress_error = 0;
13828 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13833 char fstype[] = "ext2";
13834 char device[] = "/dev/sda1";
13835 device[5] = devchar;
13837 suppress_error = 0;
13838 r = guestfs_mkfs (g, fstype, device);
13843 char device[] = "/dev/sda1";
13844 device[5] = devchar;
13845 char mountpoint[] = "/";
13847 suppress_error = 0;
13848 r = guestfs_mount (g, device, mountpoint);
13852 /* TestLastFail for rm (2) */
13854 char path[] = "/new";
13856 suppress_error = 0;
13857 r = guestfs_mkdir (g, path);
13862 char path[] = "/new";
13864 suppress_error = 1;
13865 r = guestfs_rm (g, path);
13872 static int test_read_lines_0_skip (void)
13876 str = getenv ("SKIP_TEST_READ_LINES_0");
13877 if (str && strcmp (str, "1") == 0) return 1;
13878 str = getenv ("SKIP_TEST_READ_LINES");
13879 if (str && strcmp (str, "1") == 0) return 1;
13883 static int test_read_lines_0 (void)
13885 if (test_read_lines_0_skip ()) {
13886 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13890 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13892 char device[] = "/dev/sda";
13893 device[5] = devchar;
13895 suppress_error = 0;
13896 r = guestfs_blockdev_setrw (g, device);
13902 suppress_error = 0;
13903 r = guestfs_umount_all (g);
13909 suppress_error = 0;
13910 r = guestfs_lvm_remove_all (g);
13915 char device[] = "/dev/sda";
13916 device[5] = devchar;
13917 char lines_0[] = ",";
13923 suppress_error = 0;
13924 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13929 char fstype[] = "ext2";
13930 char device[] = "/dev/sda1";
13931 device[5] = devchar;
13933 suppress_error = 0;
13934 r = guestfs_mkfs (g, fstype, device);
13939 char device[] = "/dev/sda1";
13940 device[5] = devchar;
13941 char mountpoint[] = "/";
13943 suppress_error = 0;
13944 r = guestfs_mount (g, device, mountpoint);
13948 /* TestOutputList for read_lines (0) */
13950 char path[] = "/new";
13951 char content[] = "line1\r\nline2\nline3";
13953 suppress_error = 0;
13954 r = guestfs_write_file (g, path, content, 0);
13959 char path[] = "/new";
13962 suppress_error = 0;
13963 r = guestfs_read_lines (g, path);
13967 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13972 char expected[] = "line1";
13973 if (strcmp (r[0], expected) != 0) {
13974 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13979 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13984 char expected[] = "line2";
13985 if (strcmp (r[1], expected) != 0) {
13986 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13991 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
13996 char expected[] = "line3";
13997 if (strcmp (r[2], expected) != 0) {
13998 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14002 if (r[3] != NULL) {
14003 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14007 for (i = 0; r[i] != NULL; ++i)
14014 static int test_read_lines_1_skip (void)
14018 str = getenv ("SKIP_TEST_READ_LINES_1");
14019 if (str && strcmp (str, "1") == 0) return 1;
14020 str = getenv ("SKIP_TEST_READ_LINES");
14021 if (str && strcmp (str, "1") == 0) return 1;
14025 static int test_read_lines_1 (void)
14027 if (test_read_lines_1_skip ()) {
14028 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14032 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14034 char device[] = "/dev/sda";
14035 device[5] = devchar;
14037 suppress_error = 0;
14038 r = guestfs_blockdev_setrw (g, device);
14044 suppress_error = 0;
14045 r = guestfs_umount_all (g);
14051 suppress_error = 0;
14052 r = guestfs_lvm_remove_all (g);
14057 char device[] = "/dev/sda";
14058 device[5] = devchar;
14059 char lines_0[] = ",";
14065 suppress_error = 0;
14066 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14071 char fstype[] = "ext2";
14072 char device[] = "/dev/sda1";
14073 device[5] = devchar;
14075 suppress_error = 0;
14076 r = guestfs_mkfs (g, fstype, device);
14081 char device[] = "/dev/sda1";
14082 device[5] = devchar;
14083 char mountpoint[] = "/";
14085 suppress_error = 0;
14086 r = guestfs_mount (g, device, mountpoint);
14090 /* TestOutputList for read_lines (1) */
14092 char path[] = "/new";
14093 char content[] = "";
14095 suppress_error = 0;
14096 r = guestfs_write_file (g, path, content, 0);
14101 char path[] = "/new";
14104 suppress_error = 0;
14105 r = guestfs_read_lines (g, path);
14108 if (r[0] != NULL) {
14109 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14113 for (i = 0; r[i] != NULL; ++i)
14120 static int test_lvs_0_skip (void)
14124 str = getenv ("SKIP_TEST_LVS_0");
14125 if (str && strcmp (str, "1") == 0) return 1;
14126 str = getenv ("SKIP_TEST_LVS");
14127 if (str && strcmp (str, "1") == 0) return 1;
14131 static int test_lvs_0 (void)
14133 if (test_lvs_0_skip ()) {
14134 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14138 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14140 char device[] = "/dev/sda";
14141 device[5] = devchar;
14143 suppress_error = 0;
14144 r = guestfs_blockdev_setrw (g, device);
14150 suppress_error = 0;
14151 r = guestfs_umount_all (g);
14157 suppress_error = 0;
14158 r = guestfs_lvm_remove_all (g);
14163 char device[] = "/dev/sda";
14164 device[5] = devchar;
14165 char lines_0[] = ",";
14171 suppress_error = 0;
14172 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14177 char device[] = "/dev/sda1";
14178 device[5] = devchar;
14180 suppress_error = 0;
14181 r = guestfs_pvcreate (g, device);
14186 char volgroup[] = "VG";
14187 char physvols_0[] = "/dev/sda1";
14188 physvols_0[5] = devchar;
14189 char *physvols[] = {
14194 suppress_error = 0;
14195 r = guestfs_vgcreate (g, volgroup, physvols);
14200 char logvol[] = "LV";
14201 char volgroup[] = "VG";
14203 suppress_error = 0;
14204 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14209 char fstype[] = "ext2";
14210 char device[] = "/dev/VG/LV";
14212 suppress_error = 0;
14213 r = guestfs_mkfs (g, fstype, device);
14218 char device[] = "/dev/VG/LV";
14219 char mountpoint[] = "/";
14221 suppress_error = 0;
14222 r = guestfs_mount (g, device, mountpoint);
14226 /* TestOutputList for lvs (0) */
14230 suppress_error = 0;
14231 r = guestfs_lvs (g);
14235 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14240 char expected[] = "/dev/VG/LV";
14241 if (strcmp (r[0], expected) != 0) {
14242 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14246 if (r[1] != NULL) {
14247 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14251 for (i = 0; r[i] != NULL; ++i)
14258 static int test_lvs_1_skip (void)
14262 str = getenv ("SKIP_TEST_LVS_1");
14263 if (str && strcmp (str, "1") == 0) return 1;
14264 str = getenv ("SKIP_TEST_LVS");
14265 if (str && strcmp (str, "1") == 0) return 1;
14269 static int test_lvs_1 (void)
14271 if (test_lvs_1_skip ()) {
14272 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14276 /* InitNone|InitEmpty for test_lvs_1 */
14278 char device[] = "/dev/sda";
14279 device[5] = devchar;
14281 suppress_error = 0;
14282 r = guestfs_blockdev_setrw (g, device);
14288 suppress_error = 0;
14289 r = guestfs_umount_all (g);
14295 suppress_error = 0;
14296 r = guestfs_lvm_remove_all (g);
14300 /* TestOutputList for lvs (1) */
14302 char device[] = "/dev/sda";
14303 device[5] = devchar;
14304 char lines_0[] = ",10";
14305 char lines_1[] = ",20";
14306 char lines_2[] = ",";
14314 suppress_error = 0;
14315 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14320 char device[] = "/dev/sda1";
14321 device[5] = devchar;
14323 suppress_error = 0;
14324 r = guestfs_pvcreate (g, device);
14329 char device[] = "/dev/sda2";
14330 device[5] = devchar;
14332 suppress_error = 0;
14333 r = guestfs_pvcreate (g, device);
14338 char device[] = "/dev/sda3";
14339 device[5] = devchar;
14341 suppress_error = 0;
14342 r = guestfs_pvcreate (g, device);
14347 char volgroup[] = "VG1";
14348 char physvols_0[] = "/dev/sda1";
14349 physvols_0[5] = devchar;
14350 char physvols_1[] = "/dev/sda2";
14351 physvols_1[5] = devchar;
14352 char *physvols[] = {
14358 suppress_error = 0;
14359 r = guestfs_vgcreate (g, volgroup, physvols);
14364 char volgroup[] = "VG2";
14365 char physvols_0[] = "/dev/sda3";
14366 physvols_0[5] = devchar;
14367 char *physvols[] = {
14372 suppress_error = 0;
14373 r = guestfs_vgcreate (g, volgroup, physvols);
14378 char logvol[] = "LV1";
14379 char volgroup[] = "VG1";
14381 suppress_error = 0;
14382 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14387 char logvol[] = "LV2";
14388 char volgroup[] = "VG1";
14390 suppress_error = 0;
14391 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14396 char logvol[] = "LV3";
14397 char volgroup[] = "VG2";
14399 suppress_error = 0;
14400 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14407 suppress_error = 0;
14408 r = guestfs_lvs (g);
14412 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14417 char expected[] = "/dev/VG1/LV1";
14418 if (strcmp (r[0], expected) != 0) {
14419 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14424 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14429 char expected[] = "/dev/VG1/LV2";
14430 if (strcmp (r[1], expected) != 0) {
14431 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14436 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14441 char expected[] = "/dev/VG2/LV3";
14442 if (strcmp (r[2], expected) != 0) {
14443 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14447 if (r[3] != NULL) {
14448 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14452 for (i = 0; r[i] != NULL; ++i)
14459 static int test_vgs_0_skip (void)
14463 str = getenv ("SKIP_TEST_VGS_0");
14464 if (str && strcmp (str, "1") == 0) return 1;
14465 str = getenv ("SKIP_TEST_VGS");
14466 if (str && strcmp (str, "1") == 0) return 1;
14470 static int test_vgs_0 (void)
14472 if (test_vgs_0_skip ()) {
14473 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14477 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14479 char device[] = "/dev/sda";
14480 device[5] = devchar;
14482 suppress_error = 0;
14483 r = guestfs_blockdev_setrw (g, device);
14489 suppress_error = 0;
14490 r = guestfs_umount_all (g);
14496 suppress_error = 0;
14497 r = guestfs_lvm_remove_all (g);
14502 char device[] = "/dev/sda";
14503 device[5] = devchar;
14504 char lines_0[] = ",";
14510 suppress_error = 0;
14511 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14516 char device[] = "/dev/sda1";
14517 device[5] = devchar;
14519 suppress_error = 0;
14520 r = guestfs_pvcreate (g, device);
14525 char volgroup[] = "VG";
14526 char physvols_0[] = "/dev/sda1";
14527 physvols_0[5] = devchar;
14528 char *physvols[] = {
14533 suppress_error = 0;
14534 r = guestfs_vgcreate (g, volgroup, physvols);
14539 char logvol[] = "LV";
14540 char volgroup[] = "VG";
14542 suppress_error = 0;
14543 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14548 char fstype[] = "ext2";
14549 char device[] = "/dev/VG/LV";
14551 suppress_error = 0;
14552 r = guestfs_mkfs (g, fstype, device);
14557 char device[] = "/dev/VG/LV";
14558 char mountpoint[] = "/";
14560 suppress_error = 0;
14561 r = guestfs_mount (g, device, mountpoint);
14565 /* TestOutputList for vgs (0) */
14569 suppress_error = 0;
14570 r = guestfs_vgs (g);
14574 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14579 char expected[] = "VG";
14580 if (strcmp (r[0], expected) != 0) {
14581 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14585 if (r[1] != NULL) {
14586 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14590 for (i = 0; r[i] != NULL; ++i)
14597 static int test_vgs_1_skip (void)
14601 str = getenv ("SKIP_TEST_VGS_1");
14602 if (str && strcmp (str, "1") == 0) return 1;
14603 str = getenv ("SKIP_TEST_VGS");
14604 if (str && strcmp (str, "1") == 0) return 1;
14608 static int test_vgs_1 (void)
14610 if (test_vgs_1_skip ()) {
14611 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14615 /* InitNone|InitEmpty for test_vgs_1 */
14617 char device[] = "/dev/sda";
14618 device[5] = devchar;
14620 suppress_error = 0;
14621 r = guestfs_blockdev_setrw (g, device);
14627 suppress_error = 0;
14628 r = guestfs_umount_all (g);
14634 suppress_error = 0;
14635 r = guestfs_lvm_remove_all (g);
14639 /* TestOutputList for vgs (1) */
14641 char device[] = "/dev/sda";
14642 device[5] = devchar;
14643 char lines_0[] = ",10";
14644 char lines_1[] = ",20";
14645 char lines_2[] = ",";
14653 suppress_error = 0;
14654 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14659 char device[] = "/dev/sda1";
14660 device[5] = devchar;
14662 suppress_error = 0;
14663 r = guestfs_pvcreate (g, device);
14668 char device[] = "/dev/sda2";
14669 device[5] = devchar;
14671 suppress_error = 0;
14672 r = guestfs_pvcreate (g, device);
14677 char device[] = "/dev/sda3";
14678 device[5] = devchar;
14680 suppress_error = 0;
14681 r = guestfs_pvcreate (g, device);
14686 char volgroup[] = "VG1";
14687 char physvols_0[] = "/dev/sda1";
14688 physvols_0[5] = devchar;
14689 char physvols_1[] = "/dev/sda2";
14690 physvols_1[5] = devchar;
14691 char *physvols[] = {
14697 suppress_error = 0;
14698 r = guestfs_vgcreate (g, volgroup, physvols);
14703 char volgroup[] = "VG2";
14704 char physvols_0[] = "/dev/sda3";
14705 physvols_0[5] = devchar;
14706 char *physvols[] = {
14711 suppress_error = 0;
14712 r = guestfs_vgcreate (g, volgroup, physvols);
14719 suppress_error = 0;
14720 r = guestfs_vgs (g);
14724 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14729 char expected[] = "VG1";
14730 if (strcmp (r[0], expected) != 0) {
14731 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14736 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14741 char expected[] = "VG2";
14742 if (strcmp (r[1], expected) != 0) {
14743 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14747 if (r[2] != NULL) {
14748 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14752 for (i = 0; r[i] != NULL; ++i)
14759 static int test_pvs_0_skip (void)
14763 str = getenv ("SKIP_TEST_PVS_0");
14764 if (str && strcmp (str, "1") == 0) return 1;
14765 str = getenv ("SKIP_TEST_PVS");
14766 if (str && strcmp (str, "1") == 0) return 1;
14770 static int test_pvs_0 (void)
14772 if (test_pvs_0_skip ()) {
14773 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14777 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14779 char device[] = "/dev/sda";
14780 device[5] = devchar;
14782 suppress_error = 0;
14783 r = guestfs_blockdev_setrw (g, device);
14789 suppress_error = 0;
14790 r = guestfs_umount_all (g);
14796 suppress_error = 0;
14797 r = guestfs_lvm_remove_all (g);
14802 char device[] = "/dev/sda";
14803 device[5] = devchar;
14804 char lines_0[] = ",";
14810 suppress_error = 0;
14811 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14816 char device[] = "/dev/sda1";
14817 device[5] = devchar;
14819 suppress_error = 0;
14820 r = guestfs_pvcreate (g, device);
14825 char volgroup[] = "VG";
14826 char physvols_0[] = "/dev/sda1";
14827 physvols_0[5] = devchar;
14828 char *physvols[] = {
14833 suppress_error = 0;
14834 r = guestfs_vgcreate (g, volgroup, physvols);
14839 char logvol[] = "LV";
14840 char volgroup[] = "VG";
14842 suppress_error = 0;
14843 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14848 char fstype[] = "ext2";
14849 char device[] = "/dev/VG/LV";
14851 suppress_error = 0;
14852 r = guestfs_mkfs (g, fstype, device);
14857 char device[] = "/dev/VG/LV";
14858 char mountpoint[] = "/";
14860 suppress_error = 0;
14861 r = guestfs_mount (g, device, mountpoint);
14865 /* TestOutputList for pvs (0) */
14869 suppress_error = 0;
14870 r = guestfs_pvs (g);
14874 fprintf (stderr, "test_pvs_0: short list returned from command\n");
14879 char expected[] = "/dev/sda1";
14880 expected[5] = devchar;
14881 if (strcmp (r[0], expected) != 0) {
14882 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14886 if (r[1] != NULL) {
14887 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14891 for (i = 0; r[i] != NULL; ++i)
14898 static int test_pvs_1_skip (void)
14902 str = getenv ("SKIP_TEST_PVS_1");
14903 if (str && strcmp (str, "1") == 0) return 1;
14904 str = getenv ("SKIP_TEST_PVS");
14905 if (str && strcmp (str, "1") == 0) return 1;
14909 static int test_pvs_1 (void)
14911 if (test_pvs_1_skip ()) {
14912 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
14916 /* InitNone|InitEmpty for test_pvs_1 */
14918 char device[] = "/dev/sda";
14919 device[5] = devchar;
14921 suppress_error = 0;
14922 r = guestfs_blockdev_setrw (g, device);
14928 suppress_error = 0;
14929 r = guestfs_umount_all (g);
14935 suppress_error = 0;
14936 r = guestfs_lvm_remove_all (g);
14940 /* TestOutputList for pvs (1) */
14942 char device[] = "/dev/sda";
14943 device[5] = devchar;
14944 char lines_0[] = ",10";
14945 char lines_1[] = ",20";
14946 char lines_2[] = ",";
14954 suppress_error = 0;
14955 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14960 char device[] = "/dev/sda1";
14961 device[5] = devchar;
14963 suppress_error = 0;
14964 r = guestfs_pvcreate (g, device);
14969 char device[] = "/dev/sda2";
14970 device[5] = devchar;
14972 suppress_error = 0;
14973 r = guestfs_pvcreate (g, device);
14978 char device[] = "/dev/sda3";
14979 device[5] = devchar;
14981 suppress_error = 0;
14982 r = guestfs_pvcreate (g, device);
14989 suppress_error = 0;
14990 r = guestfs_pvs (g);
14994 fprintf (stderr, "test_pvs_1: short list returned from command\n");
14999 char expected[] = "/dev/sda1";
15000 expected[5] = devchar;
15001 if (strcmp (r[0], expected) != 0) {
15002 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15007 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15012 char expected[] = "/dev/sda2";
15013 expected[5] = devchar;
15014 if (strcmp (r[1], expected) != 0) {
15015 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15020 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15025 char expected[] = "/dev/sda3";
15026 expected[5] = devchar;
15027 if (strcmp (r[2], expected) != 0) {
15028 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15032 if (r[3] != NULL) {
15033 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15037 for (i = 0; r[i] != NULL; ++i)
15044 static int test_list_partitions_0_skip (void)
15048 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15049 if (str && strcmp (str, "1") == 0) return 1;
15050 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15051 if (str && strcmp (str, "1") == 0) return 1;
15055 static int test_list_partitions_0 (void)
15057 if (test_list_partitions_0_skip ()) {
15058 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15062 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15064 char device[] = "/dev/sda";
15065 device[5] = devchar;
15067 suppress_error = 0;
15068 r = guestfs_blockdev_setrw (g, device);
15074 suppress_error = 0;
15075 r = guestfs_umount_all (g);
15081 suppress_error = 0;
15082 r = guestfs_lvm_remove_all (g);
15087 char device[] = "/dev/sda";
15088 device[5] = devchar;
15089 char lines_0[] = ",";
15095 suppress_error = 0;
15096 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15101 char fstype[] = "ext2";
15102 char device[] = "/dev/sda1";
15103 device[5] = devchar;
15105 suppress_error = 0;
15106 r = guestfs_mkfs (g, fstype, device);
15111 char device[] = "/dev/sda1";
15112 device[5] = devchar;
15113 char mountpoint[] = "/";
15115 suppress_error = 0;
15116 r = guestfs_mount (g, device, mountpoint);
15120 /* TestOutputList for list_partitions (0) */
15124 suppress_error = 0;
15125 r = guestfs_list_partitions (g);
15129 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15134 char expected[] = "/dev/sda1";
15135 expected[5] = devchar;
15136 if (strcmp (r[0], expected) != 0) {
15137 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15141 if (r[1] != NULL) {
15142 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15146 for (i = 0; r[i] != NULL; ++i)
15153 static int test_list_partitions_1_skip (void)
15157 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15158 if (str && strcmp (str, "1") == 0) return 1;
15159 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15160 if (str && strcmp (str, "1") == 0) return 1;
15164 static int test_list_partitions_1 (void)
15166 if (test_list_partitions_1_skip ()) {
15167 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15171 /* InitNone|InitEmpty for test_list_partitions_1 */
15173 char device[] = "/dev/sda";
15174 device[5] = devchar;
15176 suppress_error = 0;
15177 r = guestfs_blockdev_setrw (g, device);
15183 suppress_error = 0;
15184 r = guestfs_umount_all (g);
15190 suppress_error = 0;
15191 r = guestfs_lvm_remove_all (g);
15195 /* TestOutputList for list_partitions (1) */
15197 char device[] = "/dev/sda";
15198 device[5] = devchar;
15199 char lines_0[] = ",10";
15200 char lines_1[] = ",20";
15201 char lines_2[] = ",";
15209 suppress_error = 0;
15210 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15217 suppress_error = 0;
15218 r = guestfs_list_partitions (g);
15222 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15227 char expected[] = "/dev/sda1";
15228 expected[5] = devchar;
15229 if (strcmp (r[0], expected) != 0) {
15230 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15235 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15240 char expected[] = "/dev/sda2";
15241 expected[5] = devchar;
15242 if (strcmp (r[1], expected) != 0) {
15243 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15248 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15253 char expected[] = "/dev/sda3";
15254 expected[5] = devchar;
15255 if (strcmp (r[2], expected) != 0) {
15256 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15260 if (r[3] != NULL) {
15261 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15265 for (i = 0; r[i] != NULL; ++i)
15272 static int test_list_devices_0_skip (void)
15276 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15277 if (str && strcmp (str, "1") == 0) return 1;
15278 str = getenv ("SKIP_TEST_LIST_DEVICES");
15279 if (str && strcmp (str, "1") == 0) return 1;
15283 static int test_list_devices_0 (void)
15285 if (test_list_devices_0_skip ()) {
15286 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15290 /* InitNone|InitEmpty for test_list_devices_0 */
15292 char device[] = "/dev/sda";
15293 device[5] = devchar;
15295 suppress_error = 0;
15296 r = guestfs_blockdev_setrw (g, device);
15302 suppress_error = 0;
15303 r = guestfs_umount_all (g);
15309 suppress_error = 0;
15310 r = guestfs_lvm_remove_all (g);
15314 /* TestOutputList for list_devices (0) */
15318 suppress_error = 0;
15319 r = guestfs_list_devices (g);
15323 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15328 char expected[] = "/dev/sda";
15329 expected[5] = devchar;
15330 if (strcmp (r[0], expected) != 0) {
15331 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15336 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15341 char expected[] = "/dev/sdb";
15342 expected[5] = devchar;
15343 if (strcmp (r[1], expected) != 0) {
15344 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15349 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15354 char expected[] = "/dev/sdc";
15355 expected[5] = devchar;
15356 if (strcmp (r[2], expected) != 0) {
15357 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15361 if (r[3] != NULL) {
15362 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15366 for (i = 0; r[i] != NULL; ++i)
15373 static int test_ls_0_skip (void)
15377 str = getenv ("SKIP_TEST_LS_0");
15378 if (str && strcmp (str, "1") == 0) return 1;
15379 str = getenv ("SKIP_TEST_LS");
15380 if (str && strcmp (str, "1") == 0) return 1;
15384 static int test_ls_0 (void)
15386 if (test_ls_0_skip ()) {
15387 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15391 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15393 char device[] = "/dev/sda";
15394 device[5] = devchar;
15396 suppress_error = 0;
15397 r = guestfs_blockdev_setrw (g, device);
15403 suppress_error = 0;
15404 r = guestfs_umount_all (g);
15410 suppress_error = 0;
15411 r = guestfs_lvm_remove_all (g);
15416 char device[] = "/dev/sda";
15417 device[5] = devchar;
15418 char lines_0[] = ",";
15424 suppress_error = 0;
15425 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15430 char fstype[] = "ext2";
15431 char device[] = "/dev/sda1";
15432 device[5] = devchar;
15434 suppress_error = 0;
15435 r = guestfs_mkfs (g, fstype, device);
15440 char device[] = "/dev/sda1";
15441 device[5] = devchar;
15442 char mountpoint[] = "/";
15444 suppress_error = 0;
15445 r = guestfs_mount (g, device, mountpoint);
15449 /* TestOutputList for ls (0) */
15451 char path[] = "/new";
15453 suppress_error = 0;
15454 r = guestfs_touch (g, path);
15459 char path[] = "/newer";
15461 suppress_error = 0;
15462 r = guestfs_touch (g, path);
15467 char path[] = "/newest";
15469 suppress_error = 0;
15470 r = guestfs_touch (g, path);
15475 char directory[] = "/";
15478 suppress_error = 0;
15479 r = guestfs_ls (g, directory);
15483 fprintf (stderr, "test_ls_0: short list returned from command\n");
15488 char expected[] = "lost+found";
15489 if (strcmp (r[0], expected) != 0) {
15490 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15495 fprintf (stderr, "test_ls_0: short list returned from command\n");
15500 char expected[] = "new";
15501 if (strcmp (r[1], expected) != 0) {
15502 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15507 fprintf (stderr, "test_ls_0: short list returned from command\n");
15512 char expected[] = "newer";
15513 if (strcmp (r[2], expected) != 0) {
15514 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15519 fprintf (stderr, "test_ls_0: short list returned from command\n");
15524 char expected[] = "newest";
15525 if (strcmp (r[3], expected) != 0) {
15526 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15530 if (r[4] != NULL) {
15531 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15535 for (i = 0; r[i] != NULL; ++i)
15542 static int test_cat_0_skip (void)
15546 str = getenv ("SKIP_TEST_CAT_0");
15547 if (str && strcmp (str, "1") == 0) return 1;
15548 str = getenv ("SKIP_TEST_CAT");
15549 if (str && strcmp (str, "1") == 0) return 1;
15553 static int test_cat_0 (void)
15555 if (test_cat_0_skip ()) {
15556 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15560 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15562 char device[] = "/dev/sda";
15563 device[5] = devchar;
15565 suppress_error = 0;
15566 r = guestfs_blockdev_setrw (g, device);
15572 suppress_error = 0;
15573 r = guestfs_umount_all (g);
15579 suppress_error = 0;
15580 r = guestfs_lvm_remove_all (g);
15585 char device[] = "/dev/sda";
15586 device[5] = devchar;
15587 char lines_0[] = ",";
15593 suppress_error = 0;
15594 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15599 char fstype[] = "ext2";
15600 char device[] = "/dev/sda1";
15601 device[5] = devchar;
15603 suppress_error = 0;
15604 r = guestfs_mkfs (g, fstype, device);
15609 char device[] = "/dev/sda1";
15610 device[5] = devchar;
15611 char mountpoint[] = "/";
15613 suppress_error = 0;
15614 r = guestfs_mount (g, device, mountpoint);
15618 /* TestOutput for cat (0) */
15619 char expected[] = "new file contents";
15621 char path[] = "/new";
15622 char content[] = "new file contents";
15624 suppress_error = 0;
15625 r = guestfs_write_file (g, path, content, 0);
15630 char path[] = "/new";
15632 suppress_error = 0;
15633 r = guestfs_cat (g, path);
15636 if (strcmp (r, expected) != 0) {
15637 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15645 static int test_touch_0_skip (void)
15649 str = getenv ("SKIP_TEST_TOUCH_0");
15650 if (str && strcmp (str, "1") == 0) return 1;
15651 str = getenv ("SKIP_TEST_TOUCH");
15652 if (str && strcmp (str, "1") == 0) return 1;
15656 static int test_touch_0 (void)
15658 if (test_touch_0_skip ()) {
15659 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15663 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15665 char device[] = "/dev/sda";
15666 device[5] = devchar;
15668 suppress_error = 0;
15669 r = guestfs_blockdev_setrw (g, device);
15675 suppress_error = 0;
15676 r = guestfs_umount_all (g);
15682 suppress_error = 0;
15683 r = guestfs_lvm_remove_all (g);
15688 char device[] = "/dev/sda";
15689 device[5] = devchar;
15690 char lines_0[] = ",";
15696 suppress_error = 0;
15697 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15702 char fstype[] = "ext2";
15703 char device[] = "/dev/sda1";
15704 device[5] = devchar;
15706 suppress_error = 0;
15707 r = guestfs_mkfs (g, fstype, device);
15712 char device[] = "/dev/sda1";
15713 device[5] = devchar;
15714 char mountpoint[] = "/";
15716 suppress_error = 0;
15717 r = guestfs_mount (g, device, mountpoint);
15721 /* TestOutputTrue for touch (0) */
15723 char path[] = "/new";
15725 suppress_error = 0;
15726 r = guestfs_touch (g, path);
15731 char path[] = "/new";
15733 suppress_error = 0;
15734 r = guestfs_exists (g, path);
15738 fprintf (stderr, "test_touch_0: expected true, got false\n");
15745 static int test_sync_0_skip (void)
15749 str = getenv ("SKIP_TEST_SYNC_0");
15750 if (str && strcmp (str, "1") == 0) return 1;
15751 str = getenv ("SKIP_TEST_SYNC");
15752 if (str && strcmp (str, "1") == 0) return 1;
15756 static int test_sync_0 (void)
15758 if (test_sync_0_skip ()) {
15759 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15763 /* InitNone|InitEmpty for test_sync_0 */
15765 char device[] = "/dev/sda";
15766 device[5] = devchar;
15768 suppress_error = 0;
15769 r = guestfs_blockdev_setrw (g, device);
15775 suppress_error = 0;
15776 r = guestfs_umount_all (g);
15782 suppress_error = 0;
15783 r = guestfs_lvm_remove_all (g);
15787 /* TestRun for sync (0) */
15790 suppress_error = 0;
15791 r = guestfs_sync (g);
15798 static int test_mount_0_skip (void)
15802 str = getenv ("SKIP_TEST_MOUNT_0");
15803 if (str && strcmp (str, "1") == 0) return 1;
15804 str = getenv ("SKIP_TEST_MOUNT");
15805 if (str && strcmp (str, "1") == 0) return 1;
15809 static int test_mount_0 (void)
15811 if (test_mount_0_skip ()) {
15812 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15816 /* InitNone|InitEmpty for test_mount_0 */
15818 char device[] = "/dev/sda";
15819 device[5] = devchar;
15821 suppress_error = 0;
15822 r = guestfs_blockdev_setrw (g, device);
15828 suppress_error = 0;
15829 r = guestfs_umount_all (g);
15835 suppress_error = 0;
15836 r = guestfs_lvm_remove_all (g);
15840 /* TestOutput for mount (0) */
15841 char expected[] = "new file contents";
15843 char device[] = "/dev/sda";
15844 device[5] = devchar;
15845 char lines_0[] = ",";
15851 suppress_error = 0;
15852 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15857 char fstype[] = "ext2";
15858 char device[] = "/dev/sda1";
15859 device[5] = devchar;
15861 suppress_error = 0;
15862 r = guestfs_mkfs (g, fstype, device);
15867 char device[] = "/dev/sda1";
15868 device[5] = devchar;
15869 char mountpoint[] = "/";
15871 suppress_error = 0;
15872 r = guestfs_mount (g, device, mountpoint);
15877 char path[] = "/new";
15878 char content[] = "new file contents";
15880 suppress_error = 0;
15881 r = guestfs_write_file (g, path, content, 0);
15886 char path[] = "/new";
15888 suppress_error = 0;
15889 r = guestfs_cat (g, path);
15892 if (strcmp (r, expected) != 0) {
15893 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
15901 int main (int argc, char *argv[])
15905 const char *srcdir;
15906 const char *filename;
15908 int nr_tests, test_num = 0;
15911 no_test_warnings ();
15913 g = guestfs_create ();
15915 printf ("guestfs_create FAILED\n");
15919 guestfs_set_error_handler (g, print_error, NULL);
15921 guestfs_set_path (g, "../appliance");
15923 filename = "test1.img";
15924 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15929 if (lseek (fd, 524288000, SEEK_SET) == -1) {
15935 if (write (fd, &c, 1) == -1) {
15941 if (close (fd) == -1) {
15946 if (guestfs_add_drive (g, filename) == -1) {
15947 printf ("guestfs_add_drive %s FAILED\n", filename);
15951 filename = "test2.img";
15952 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15957 if (lseek (fd, 52428800, SEEK_SET) == -1) {
15963 if (write (fd, &c, 1) == -1) {
15969 if (close (fd) == -1) {
15974 if (guestfs_add_drive (g, filename) == -1) {
15975 printf ("guestfs_add_drive %s FAILED\n", filename);
15979 filename = "test3.img";
15980 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
15985 if (lseek (fd, 10485760, SEEK_SET) == -1) {
15991 if (write (fd, &c, 1) == -1) {
15997 if (close (fd) == -1) {
16002 if (guestfs_add_drive (g, filename) == -1) {
16003 printf ("guestfs_add_drive %s FAILED\n", filename);
16007 if (guestfs_launch (g) == -1) {
16008 printf ("guestfs_launch FAILED\n");
16011 if (guestfs_wait_ready (g) == -1) {
16012 printf ("guestfs_wait_ready FAILED\n");
16016 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
16017 * names. This changed between RHEL 5 and RHEL 6 so we have to
16020 devs = guestfs_list_devices (g);
16021 if (devs == NULL || devs[0] == NULL) {
16022 printf ("guestfs_list_devices FAILED\n");
16025 if (strncmp (devs[0], "/dev/sd", 7) == 0)
16027 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
16030 printf ("guestfs_list_devices returned unexpected string '%s'\n",
16034 for (i = 0; devs[i] != NULL; ++i)
16041 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16042 if (test_find_0 () == -1) {
16043 printf ("test_find_0 FAILED\n");
16047 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16048 if (test_find_1 () == -1) {
16049 printf ("test_find_1 FAILED\n");
16053 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16054 if (test_find_2 () == -1) {
16055 printf ("test_find_2 FAILED\n");
16059 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16060 if (test_lvresize_0 () == -1) {
16061 printf ("test_lvresize_0 FAILED\n");
16065 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16066 if (test_zerofree_0 () == -1) {
16067 printf ("test_zerofree_0 FAILED\n");
16071 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16072 if (test_hexdump_0 () == -1) {
16073 printf ("test_hexdump_0 FAILED\n");
16077 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16078 if (test_strings_e_0 () == -1) {
16079 printf ("test_strings_e_0 FAILED\n");
16083 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16084 if (test_strings_e_1 () == -1) {
16085 printf ("test_strings_e_1 FAILED\n");
16089 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16090 if (test_strings_0 () == -1) {
16091 printf ("test_strings_0 FAILED\n");
16095 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16096 if (test_strings_1 () == -1) {
16097 printf ("test_strings_1 FAILED\n");
16101 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16102 if (test_equal_0 () == -1) {
16103 printf ("test_equal_0 FAILED\n");
16107 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16108 if (test_equal_1 () == -1) {
16109 printf ("test_equal_1 FAILED\n");
16113 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16114 if (test_equal_2 () == -1) {
16115 printf ("test_equal_2 FAILED\n");
16119 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16120 if (test_ping_daemon_0 () == -1) {
16121 printf ("test_ping_daemon_0 FAILED\n");
16125 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16126 if (test_dmesg_0 () == -1) {
16127 printf ("test_dmesg_0 FAILED\n");
16131 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16132 if (test_drop_caches_0 () == -1) {
16133 printf ("test_drop_caches_0 FAILED\n");
16137 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16138 if (test_mv_0 () == -1) {
16139 printf ("test_mv_0 FAILED\n");
16143 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16144 if (test_mv_1 () == -1) {
16145 printf ("test_mv_1 FAILED\n");
16149 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16150 if (test_cp_a_0 () == -1) {
16151 printf ("test_cp_a_0 FAILED\n");
16155 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16156 if (test_cp_0 () == -1) {
16157 printf ("test_cp_0 FAILED\n");
16161 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16162 if (test_cp_1 () == -1) {
16163 printf ("test_cp_1 FAILED\n");
16167 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16168 if (test_cp_2 () == -1) {
16169 printf ("test_cp_2 FAILED\n");
16173 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16174 if (test_grub_install_0 () == -1) {
16175 printf ("test_grub_install_0 FAILED\n");
16179 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16180 if (test_zero_0 () == -1) {
16181 printf ("test_zero_0 FAILED\n");
16185 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16186 if (test_fsck_0 () == -1) {
16187 printf ("test_fsck_0 FAILED\n");
16191 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16192 if (test_fsck_1 () == -1) {
16193 printf ("test_fsck_1 FAILED\n");
16197 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16198 if (test_set_e2uuid_0 () == -1) {
16199 printf ("test_set_e2uuid_0 FAILED\n");
16203 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16204 if (test_set_e2uuid_1 () == -1) {
16205 printf ("test_set_e2uuid_1 FAILED\n");
16209 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16210 if (test_set_e2uuid_2 () == -1) {
16211 printf ("test_set_e2uuid_2 FAILED\n");
16215 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16216 if (test_set_e2uuid_3 () == -1) {
16217 printf ("test_set_e2uuid_3 FAILED\n");
16221 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16222 if (test_set_e2label_0 () == -1) {
16223 printf ("test_set_e2label_0 FAILED\n");
16227 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16228 if (test_pvremove_0 () == -1) {
16229 printf ("test_pvremove_0 FAILED\n");
16233 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16234 if (test_pvremove_1 () == -1) {
16235 printf ("test_pvremove_1 FAILED\n");
16239 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16240 if (test_pvremove_2 () == -1) {
16241 printf ("test_pvremove_2 FAILED\n");
16245 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16246 if (test_vgremove_0 () == -1) {
16247 printf ("test_vgremove_0 FAILED\n");
16251 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16252 if (test_vgremove_1 () == -1) {
16253 printf ("test_vgremove_1 FAILED\n");
16257 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16258 if (test_lvremove_0 () == -1) {
16259 printf ("test_lvremove_0 FAILED\n");
16263 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16264 if (test_lvremove_1 () == -1) {
16265 printf ("test_lvremove_1 FAILED\n");
16269 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16270 if (test_lvremove_2 () == -1) {
16271 printf ("test_lvremove_2 FAILED\n");
16275 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16276 if (test_mount_ro_0 () == -1) {
16277 printf ("test_mount_ro_0 FAILED\n");
16281 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16282 if (test_mount_ro_1 () == -1) {
16283 printf ("test_mount_ro_1 FAILED\n");
16287 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16288 if (test_tgz_in_0 () == -1) {
16289 printf ("test_tgz_in_0 FAILED\n");
16293 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16294 if (test_tar_in_0 () == -1) {
16295 printf ("test_tar_in_0 FAILED\n");
16299 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16300 if (test_checksum_0 () == -1) {
16301 printf ("test_checksum_0 FAILED\n");
16305 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16306 if (test_checksum_1 () == -1) {
16307 printf ("test_checksum_1 FAILED\n");
16311 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16312 if (test_checksum_2 () == -1) {
16313 printf ("test_checksum_2 FAILED\n");
16317 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16318 if (test_checksum_3 () == -1) {
16319 printf ("test_checksum_3 FAILED\n");
16323 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16324 if (test_checksum_4 () == -1) {
16325 printf ("test_checksum_4 FAILED\n");
16329 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16330 if (test_checksum_5 () == -1) {
16331 printf ("test_checksum_5 FAILED\n");
16335 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16336 if (test_checksum_6 () == -1) {
16337 printf ("test_checksum_6 FAILED\n");
16341 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16342 if (test_checksum_7 () == -1) {
16343 printf ("test_checksum_7 FAILED\n");
16347 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16348 if (test_download_0 () == -1) {
16349 printf ("test_download_0 FAILED\n");
16353 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16354 if (test_upload_0 () == -1) {
16355 printf ("test_upload_0 FAILED\n");
16359 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16360 if (test_blockdev_rereadpt_0 () == -1) {
16361 printf ("test_blockdev_rereadpt_0 FAILED\n");
16365 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16366 if (test_blockdev_flushbufs_0 () == -1) {
16367 printf ("test_blockdev_flushbufs_0 FAILED\n");
16371 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16372 if (test_blockdev_getsize64_0 () == -1) {
16373 printf ("test_blockdev_getsize64_0 FAILED\n");
16377 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16378 if (test_blockdev_getsz_0 () == -1) {
16379 printf ("test_blockdev_getsz_0 FAILED\n");
16383 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16384 if (test_blockdev_getbsz_0 () == -1) {
16385 printf ("test_blockdev_getbsz_0 FAILED\n");
16389 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16390 if (test_blockdev_getss_0 () == -1) {
16391 printf ("test_blockdev_getss_0 FAILED\n");
16395 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16396 if (test_blockdev_getro_0 () == -1) {
16397 printf ("test_blockdev_getro_0 FAILED\n");
16401 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16402 if (test_blockdev_setrw_0 () == -1) {
16403 printf ("test_blockdev_setrw_0 FAILED\n");
16407 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16408 if (test_blockdev_setro_0 () == -1) {
16409 printf ("test_blockdev_setro_0 FAILED\n");
16413 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16414 if (test_statvfs_0 () == -1) {
16415 printf ("test_statvfs_0 FAILED\n");
16419 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16420 if (test_lstat_0 () == -1) {
16421 printf ("test_lstat_0 FAILED\n");
16425 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16426 if (test_stat_0 () == -1) {
16427 printf ("test_stat_0 FAILED\n");
16431 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16432 if (test_command_lines_0 () == -1) {
16433 printf ("test_command_lines_0 FAILED\n");
16437 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16438 if (test_command_lines_1 () == -1) {
16439 printf ("test_command_lines_1 FAILED\n");
16443 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16444 if (test_command_lines_2 () == -1) {
16445 printf ("test_command_lines_2 FAILED\n");
16449 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16450 if (test_command_lines_3 () == -1) {
16451 printf ("test_command_lines_3 FAILED\n");
16455 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16456 if (test_command_lines_4 () == -1) {
16457 printf ("test_command_lines_4 FAILED\n");
16461 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16462 if (test_command_lines_5 () == -1) {
16463 printf ("test_command_lines_5 FAILED\n");
16467 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16468 if (test_command_lines_6 () == -1) {
16469 printf ("test_command_lines_6 FAILED\n");
16473 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16474 if (test_command_lines_7 () == -1) {
16475 printf ("test_command_lines_7 FAILED\n");
16479 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16480 if (test_command_lines_8 () == -1) {
16481 printf ("test_command_lines_8 FAILED\n");
16485 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16486 if (test_command_lines_9 () == -1) {
16487 printf ("test_command_lines_9 FAILED\n");
16491 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16492 if (test_command_lines_10 () == -1) {
16493 printf ("test_command_lines_10 FAILED\n");
16497 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16498 if (test_command_0 () == -1) {
16499 printf ("test_command_0 FAILED\n");
16503 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16504 if (test_command_1 () == -1) {
16505 printf ("test_command_1 FAILED\n");
16509 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16510 if (test_command_2 () == -1) {
16511 printf ("test_command_2 FAILED\n");
16515 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16516 if (test_command_3 () == -1) {
16517 printf ("test_command_3 FAILED\n");
16521 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16522 if (test_command_4 () == -1) {
16523 printf ("test_command_4 FAILED\n");
16527 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16528 if (test_command_5 () == -1) {
16529 printf ("test_command_5 FAILED\n");
16533 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16534 if (test_command_6 () == -1) {
16535 printf ("test_command_6 FAILED\n");
16539 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16540 if (test_command_7 () == -1) {
16541 printf ("test_command_7 FAILED\n");
16545 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16546 if (test_command_8 () == -1) {
16547 printf ("test_command_8 FAILED\n");
16551 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16552 if (test_command_9 () == -1) {
16553 printf ("test_command_9 FAILED\n");
16557 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16558 if (test_command_10 () == -1) {
16559 printf ("test_command_10 FAILED\n");
16563 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16564 if (test_command_11 () == -1) {
16565 printf ("test_command_11 FAILED\n");
16569 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16570 if (test_file_0 () == -1) {
16571 printf ("test_file_0 FAILED\n");
16575 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16576 if (test_file_1 () == -1) {
16577 printf ("test_file_1 FAILED\n");
16581 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16582 if (test_file_2 () == -1) {
16583 printf ("test_file_2 FAILED\n");
16587 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16588 if (test_umount_all_0 () == -1) {
16589 printf ("test_umount_all_0 FAILED\n");
16593 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16594 if (test_umount_all_1 () == -1) {
16595 printf ("test_umount_all_1 FAILED\n");
16599 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16600 if (test_mounts_0 () == -1) {
16601 printf ("test_mounts_0 FAILED\n");
16605 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16606 if (test_umount_0 () == -1) {
16607 printf ("test_umount_0 FAILED\n");
16611 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16612 if (test_umount_1 () == -1) {
16613 printf ("test_umount_1 FAILED\n");
16617 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16618 if (test_write_file_0 () == -1) {
16619 printf ("test_write_file_0 FAILED\n");
16623 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16624 if (test_write_file_1 () == -1) {
16625 printf ("test_write_file_1 FAILED\n");
16629 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16630 if (test_write_file_2 () == -1) {
16631 printf ("test_write_file_2 FAILED\n");
16635 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16636 if (test_write_file_3 () == -1) {
16637 printf ("test_write_file_3 FAILED\n");
16641 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16642 if (test_write_file_4 () == -1) {
16643 printf ("test_write_file_4 FAILED\n");
16647 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16648 if (test_write_file_5 () == -1) {
16649 printf ("test_write_file_5 FAILED\n");
16653 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16654 if (test_mkfs_0 () == -1) {
16655 printf ("test_mkfs_0 FAILED\n");
16659 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16660 if (test_lvcreate_0 () == -1) {
16661 printf ("test_lvcreate_0 FAILED\n");
16665 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16666 if (test_vgcreate_0 () == -1) {
16667 printf ("test_vgcreate_0 FAILED\n");
16671 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16672 if (test_pvcreate_0 () == -1) {
16673 printf ("test_pvcreate_0 FAILED\n");
16677 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16678 if (test_is_dir_0 () == -1) {
16679 printf ("test_is_dir_0 FAILED\n");
16683 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16684 if (test_is_dir_1 () == -1) {
16685 printf ("test_is_dir_1 FAILED\n");
16689 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16690 if (test_is_file_0 () == -1) {
16691 printf ("test_is_file_0 FAILED\n");
16695 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16696 if (test_is_file_1 () == -1) {
16697 printf ("test_is_file_1 FAILED\n");
16701 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16702 if (test_exists_0 () == -1) {
16703 printf ("test_exists_0 FAILED\n");
16707 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16708 if (test_exists_1 () == -1) {
16709 printf ("test_exists_1 FAILED\n");
16713 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16714 if (test_mkdir_p_0 () == -1) {
16715 printf ("test_mkdir_p_0 FAILED\n");
16719 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16720 if (test_mkdir_p_1 () == -1) {
16721 printf ("test_mkdir_p_1 FAILED\n");
16725 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16726 if (test_mkdir_p_2 () == -1) {
16727 printf ("test_mkdir_p_2 FAILED\n");
16731 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16732 if (test_mkdir_p_3 () == -1) {
16733 printf ("test_mkdir_p_3 FAILED\n");
16737 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16738 if (test_mkdir_p_4 () == -1) {
16739 printf ("test_mkdir_p_4 FAILED\n");
16743 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16744 if (test_mkdir_0 () == -1) {
16745 printf ("test_mkdir_0 FAILED\n");
16749 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16750 if (test_mkdir_1 () == -1) {
16751 printf ("test_mkdir_1 FAILED\n");
16755 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16756 if (test_rm_rf_0 () == -1) {
16757 printf ("test_rm_rf_0 FAILED\n");
16761 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16762 if (test_rmdir_0 () == -1) {
16763 printf ("test_rmdir_0 FAILED\n");
16767 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16768 if (test_rmdir_1 () == -1) {
16769 printf ("test_rmdir_1 FAILED\n");
16773 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16774 if (test_rmdir_2 () == -1) {
16775 printf ("test_rmdir_2 FAILED\n");
16779 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16780 if (test_rm_0 () == -1) {
16781 printf ("test_rm_0 FAILED\n");
16785 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16786 if (test_rm_1 () == -1) {
16787 printf ("test_rm_1 FAILED\n");
16791 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16792 if (test_rm_2 () == -1) {
16793 printf ("test_rm_2 FAILED\n");
16797 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16798 if (test_read_lines_0 () == -1) {
16799 printf ("test_read_lines_0 FAILED\n");
16803 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16804 if (test_read_lines_1 () == -1) {
16805 printf ("test_read_lines_1 FAILED\n");
16809 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16810 if (test_lvs_0 () == -1) {
16811 printf ("test_lvs_0 FAILED\n");
16815 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16816 if (test_lvs_1 () == -1) {
16817 printf ("test_lvs_1 FAILED\n");
16821 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16822 if (test_vgs_0 () == -1) {
16823 printf ("test_vgs_0 FAILED\n");
16827 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16828 if (test_vgs_1 () == -1) {
16829 printf ("test_vgs_1 FAILED\n");
16833 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16834 if (test_pvs_0 () == -1) {
16835 printf ("test_pvs_0 FAILED\n");
16839 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16840 if (test_pvs_1 () == -1) {
16841 printf ("test_pvs_1 FAILED\n");
16845 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16846 if (test_list_partitions_0 () == -1) {
16847 printf ("test_list_partitions_0 FAILED\n");
16851 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16852 if (test_list_partitions_1 () == -1) {
16853 printf ("test_list_partitions_1 FAILED\n");
16857 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16858 if (test_list_devices_0 () == -1) {
16859 printf ("test_list_devices_0 FAILED\n");
16863 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16864 if (test_ls_0 () == -1) {
16865 printf ("test_ls_0 FAILED\n");
16869 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16870 if (test_cat_0 () == -1) {
16871 printf ("test_cat_0 FAILED\n");
16875 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
16876 if (test_touch_0 () == -1) {
16877 printf ("test_touch_0 FAILED\n");
16881 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
16882 if (test_sync_0 () == -1) {
16883 printf ("test_sync_0 FAILED\n");
16887 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
16888 if (test_mount_0 () == -1) {
16889 printf ("test_mount_0 FAILED\n");
16894 unlink ("test1.img");
16895 unlink ("test2.img");
16896 unlink ("test3.img");
16899 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);