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_add_drive_ro\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
155 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
158 static int test_find_0_skip (void)
162 str = getenv ("SKIP_TEST_FIND_0");
163 if (str && strcmp (str, "1") == 0) return 1;
164 str = getenv ("SKIP_TEST_FIND");
165 if (str && strcmp (str, "1") == 0) return 1;
169 static int test_find_0 (void)
171 if (test_find_0_skip ()) {
172 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
176 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
178 char device[] = "/dev/sda";
182 r = guestfs_blockdev_setrw (g, device);
189 r = guestfs_umount_all (g);
196 r = guestfs_lvm_remove_all (g);
201 char device[] = "/dev/sda";
203 char lines_0[] = ",";
210 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
215 char fstype[] = "ext2";
216 char device[] = "/dev/sda1";
220 r = guestfs_mkfs (g, fstype, device);
225 char device[] = "/dev/sda1";
227 char mountpoint[] = "/";
230 r = guestfs_mount (g, device, mountpoint);
234 /* TestOutputList for find (0) */
236 char directory[] = "/";
240 r = guestfs_find (g, directory);
244 fprintf (stderr, "test_find_0: short list returned from command\n");
249 char expected[] = "lost+found";
250 if (strcmp (r[0], expected) != 0) {
251 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
256 fprintf (stderr, "test_find_0: extra elements returned from command\n");
260 for (i = 0; r[i] != NULL; ++i)
267 static int test_find_1_skip (void)
271 str = getenv ("SKIP_TEST_FIND_1");
272 if (str && strcmp (str, "1") == 0) return 1;
273 str = getenv ("SKIP_TEST_FIND");
274 if (str && strcmp (str, "1") == 0) return 1;
278 static int test_find_1 (void)
280 if (test_find_1_skip ()) {
281 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
285 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
287 char device[] = "/dev/sda";
291 r = guestfs_blockdev_setrw (g, device);
298 r = guestfs_umount_all (g);
305 r = guestfs_lvm_remove_all (g);
310 char device[] = "/dev/sda";
312 char lines_0[] = ",";
319 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
324 char fstype[] = "ext2";
325 char device[] = "/dev/sda1";
329 r = guestfs_mkfs (g, fstype, device);
334 char device[] = "/dev/sda1";
336 char mountpoint[] = "/";
339 r = guestfs_mount (g, device, mountpoint);
343 /* TestOutputList for find (1) */
348 r = guestfs_touch (g, path);
356 r = guestfs_mkdir (g, path);
361 char path[] = "/b/c";
364 r = guestfs_touch (g, path);
369 char directory[] = "/";
373 r = guestfs_find (g, directory);
377 fprintf (stderr, "test_find_1: short list returned from command\n");
382 char expected[] = "a";
383 if (strcmp (r[0], expected) != 0) {
384 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
389 fprintf (stderr, "test_find_1: short list returned from command\n");
394 char expected[] = "b";
395 if (strcmp (r[1], expected) != 0) {
396 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
401 fprintf (stderr, "test_find_1: short list returned from command\n");
406 char expected[] = "b/c";
407 if (strcmp (r[2], expected) != 0) {
408 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
413 fprintf (stderr, "test_find_1: short list returned from command\n");
418 char expected[] = "lost+found";
419 if (strcmp (r[3], expected) != 0) {
420 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
425 fprintf (stderr, "test_find_1: extra elements returned from command\n");
429 for (i = 0; r[i] != NULL; ++i)
436 static int test_find_2_skip (void)
440 str = getenv ("SKIP_TEST_FIND_2");
441 if (str && strcmp (str, "1") == 0) return 1;
442 str = getenv ("SKIP_TEST_FIND");
443 if (str && strcmp (str, "1") == 0) return 1;
447 static int test_find_2 (void)
449 if (test_find_2_skip ()) {
450 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
454 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
456 char device[] = "/dev/sda";
460 r = guestfs_blockdev_setrw (g, device);
467 r = guestfs_umount_all (g);
474 r = guestfs_lvm_remove_all (g);
479 char device[] = "/dev/sda";
481 char lines_0[] = ",";
488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
493 char fstype[] = "ext2";
494 char device[] = "/dev/sda1";
498 r = guestfs_mkfs (g, fstype, device);
503 char device[] = "/dev/sda1";
505 char mountpoint[] = "/";
508 r = guestfs_mount (g, device, mountpoint);
512 /* TestOutputList for find (2) */
514 char path[] = "/a/b/c";
517 r = guestfs_mkdir_p (g, path);
522 char path[] = "/a/b/c/d";
525 r = guestfs_touch (g, path);
530 char directory[] = "/a/b/";
534 r = guestfs_find (g, directory);
538 fprintf (stderr, "test_find_2: short list returned from command\n");
543 char expected[] = "c";
544 if (strcmp (r[0], expected) != 0) {
545 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
550 fprintf (stderr, "test_find_2: short list returned from command\n");
555 char expected[] = "c/d";
556 if (strcmp (r[1], expected) != 0) {
557 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
562 fprintf (stderr, "test_find_2: extra elements returned from command\n");
566 for (i = 0; r[i] != NULL; ++i)
573 static int test_lvresize_0_skip (void)
577 str = getenv ("SKIP_TEST_LVRESIZE_0");
578 if (str && strcmp (str, "1") == 0) return 1;
579 str = getenv ("SKIP_TEST_LVRESIZE");
580 if (str && strcmp (str, "1") == 0) return 1;
584 static int test_lvresize_0 (void)
586 if (test_lvresize_0_skip ()) {
587 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
591 /* InitNone|InitEmpty for test_lvresize_0 */
593 char device[] = "/dev/sda";
597 r = guestfs_blockdev_setrw (g, device);
604 r = guestfs_umount_all (g);
611 r = guestfs_lvm_remove_all (g);
615 /* TestOutput for lvresize (0) */
616 char expected[] = "test content";
618 char device[] = "/dev/sda";
620 char lines_0[] = ",";
627 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
632 char device[] = "/dev/sda1";
636 r = guestfs_pvcreate (g, device);
641 char volgroup[] = "VG";
642 char physvols_0[] = "/dev/sda1";
643 physvols_0[5] = devchar;
650 r = guestfs_vgcreate (g, volgroup, physvols);
655 char logvol[] = "LV";
656 char volgroup[] = "VG";
659 r = guestfs_lvcreate (g, logvol, volgroup, 10);
664 char fstype[] = "ext2";
665 char device[] = "/dev/VG/LV";
668 r = guestfs_mkfs (g, fstype, device);
673 char device[] = "/dev/VG/LV";
674 char mountpoint[] = "/";
677 r = guestfs_mount (g, device, mountpoint);
682 char path[] = "/new";
683 char content[] = "test content";
686 r = guestfs_write_file (g, path, content, 0);
691 char pathordevice[] = "/";
694 r = guestfs_umount (g, pathordevice);
699 char device[] = "/dev/VG/LV";
702 r = guestfs_lvresize (g, device, 20);
707 char device[] = "/dev/VG/LV";
710 r = guestfs_e2fsck_f (g, device);
715 char device[] = "/dev/VG/LV";
718 r = guestfs_resize2fs (g, device);
723 char device[] = "/dev/VG/LV";
724 char mountpoint[] = "/";
727 r = guestfs_mount (g, device, mountpoint);
732 char path[] = "/new";
735 r = guestfs_cat (g, path);
738 if (strcmp (r, expected) != 0) {
739 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
747 static int test_zerofree_0_skip (void)
751 str = getenv ("SKIP_TEST_ZEROFREE_0");
752 if (str && strcmp (str, "1") == 0) return 1;
753 str = getenv ("SKIP_TEST_ZEROFREE");
754 if (str && strcmp (str, "1") == 0) return 1;
758 static int test_zerofree_0 (void)
760 if (test_zerofree_0_skip ()) {
761 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
765 /* InitNone|InitEmpty for test_zerofree_0 */
767 char device[] = "/dev/sda";
771 r = guestfs_blockdev_setrw (g, device);
778 r = guestfs_umount_all (g);
785 r = guestfs_lvm_remove_all (g);
789 /* TestOutput for zerofree (0) */
790 char expected[] = "test file";
792 char device[] = "/dev/sda";
794 char lines_0[] = ",";
801 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
806 char fstype[] = "ext3";
807 char device[] = "/dev/sda1";
811 r = guestfs_mkfs (g, fstype, device);
816 char device[] = "/dev/sda1";
818 char mountpoint[] = "/";
821 r = guestfs_mount (g, device, mountpoint);
826 char path[] = "/new";
827 char content[] = "test file";
830 r = guestfs_write_file (g, path, content, 0);
835 char pathordevice[] = "/dev/sda1";
836 pathordevice[5] = devchar;
839 r = guestfs_umount (g, pathordevice);
844 char device[] = "/dev/sda1";
848 r = guestfs_zerofree (g, device);
853 char device[] = "/dev/sda1";
855 char mountpoint[] = "/";
858 r = guestfs_mount (g, device, mountpoint);
863 char path[] = "/new";
866 r = guestfs_cat (g, path);
869 if (strcmp (r, expected) != 0) {
870 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
878 static int test_hexdump_0_skip (void)
882 str = getenv ("SKIP_TEST_HEXDUMP_0");
883 if (str && strcmp (str, "1") == 0) return 1;
884 str = getenv ("SKIP_TEST_HEXDUMP");
885 if (str && strcmp (str, "1") == 0) return 1;
889 static int test_hexdump_0 (void)
891 if (test_hexdump_0_skip ()) {
892 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
896 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
898 char device[] = "/dev/sda";
902 r = guestfs_blockdev_setrw (g, device);
909 r = guestfs_umount_all (g);
916 r = guestfs_lvm_remove_all (g);
921 char device[] = "/dev/sda";
923 char lines_0[] = ",";
930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
935 char fstype[] = "ext2";
936 char device[] = "/dev/sda1";
940 r = guestfs_mkfs (g, fstype, device);
945 char device[] = "/dev/sda1";
947 char mountpoint[] = "/";
950 r = guestfs_mount (g, device, mountpoint);
954 /* TestOutput for hexdump (0) */
955 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
957 char path[] = "/new";
958 char content[] = "hello\nworld\n";
961 r = guestfs_write_file (g, path, content, 12);
966 char path[] = "/new";
969 r = guestfs_hexdump (g, path);
972 if (strcmp (r, expected) != 0) {
973 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
981 static int test_strings_e_0_skip (void)
985 str = getenv ("SKIP_TEST_STRINGS_E_0");
986 if (str && strcmp (str, "1") == 0) return 1;
987 str = getenv ("SKIP_TEST_STRINGS_E");
988 if (str && strcmp (str, "1") == 0) return 1;
992 static int test_strings_e_0 (void)
994 if (test_strings_e_0_skip ()) {
995 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
999 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1001 char device[] = "/dev/sda";
1002 device[5] = devchar;
1005 r = guestfs_blockdev_setrw (g, device);
1012 r = guestfs_umount_all (g);
1019 r = guestfs_lvm_remove_all (g);
1024 char device[] = "/dev/sda";
1025 device[5] = devchar;
1026 char lines_0[] = ",";
1033 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1038 char fstype[] = "ext2";
1039 char device[] = "/dev/sda1";
1040 device[5] = devchar;
1043 r = guestfs_mkfs (g, fstype, device);
1048 char device[] = "/dev/sda1";
1049 device[5] = devchar;
1050 char mountpoint[] = "/";
1053 r = guestfs_mount (g, device, mountpoint);
1057 /* TestOutputList for strings_e (0) */
1059 char path[] = "/new";
1060 char content[] = "hello\nworld\n";
1063 r = guestfs_write_file (g, path, content, 0);
1068 char encoding[] = "b";
1069 char path[] = "/new";
1073 r = guestfs_strings_e (g, encoding, path);
1077 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1081 for (i = 0; r[i] != NULL; ++i)
1088 static int test_strings_e_1_skip (void)
1092 str = getenv ("SKIP_TEST_STRINGS_E_1");
1093 if (str && strcmp (str, "1") == 0) return 1;
1094 str = getenv ("SKIP_TEST_STRINGS_E");
1095 if (str && strcmp (str, "1") == 0) return 1;
1099 static int test_strings_e_1 (void)
1101 if (test_strings_e_1_skip ()) {
1102 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1106 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1110 static int test_strings_0_skip (void)
1114 str = getenv ("SKIP_TEST_STRINGS_0");
1115 if (str && strcmp (str, "1") == 0) return 1;
1116 str = getenv ("SKIP_TEST_STRINGS");
1117 if (str && strcmp (str, "1") == 0) return 1;
1121 static int test_strings_0 (void)
1123 if (test_strings_0_skip ()) {
1124 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1128 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1130 char device[] = "/dev/sda";
1131 device[5] = devchar;
1134 r = guestfs_blockdev_setrw (g, device);
1141 r = guestfs_umount_all (g);
1148 r = guestfs_lvm_remove_all (g);
1153 char device[] = "/dev/sda";
1154 device[5] = devchar;
1155 char lines_0[] = ",";
1162 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1167 char fstype[] = "ext2";
1168 char device[] = "/dev/sda1";
1169 device[5] = devchar;
1172 r = guestfs_mkfs (g, fstype, device);
1177 char device[] = "/dev/sda1";
1178 device[5] = devchar;
1179 char mountpoint[] = "/";
1182 r = guestfs_mount (g, device, mountpoint);
1186 /* TestOutputList for strings (0) */
1188 char path[] = "/new";
1189 char content[] = "hello\nworld\n";
1192 r = guestfs_write_file (g, path, content, 0);
1197 char path[] = "/new";
1201 r = guestfs_strings (g, path);
1205 fprintf (stderr, "test_strings_0: short list returned from command\n");
1210 char expected[] = "hello";
1211 if (strcmp (r[0], expected) != 0) {
1212 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1217 fprintf (stderr, "test_strings_0: short list returned from command\n");
1222 char expected[] = "world";
1223 if (strcmp (r[1], expected) != 0) {
1224 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1229 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1233 for (i = 0; r[i] != NULL; ++i)
1240 static int test_strings_1_skip (void)
1244 str = getenv ("SKIP_TEST_STRINGS_1");
1245 if (str && strcmp (str, "1") == 0) return 1;
1246 str = getenv ("SKIP_TEST_STRINGS");
1247 if (str && strcmp (str, "1") == 0) return 1;
1251 static int test_strings_1 (void)
1253 if (test_strings_1_skip ()) {
1254 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1258 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1260 char device[] = "/dev/sda";
1261 device[5] = devchar;
1264 r = guestfs_blockdev_setrw (g, device);
1271 r = guestfs_umount_all (g);
1278 r = guestfs_lvm_remove_all (g);
1283 char device[] = "/dev/sda";
1284 device[5] = devchar;
1285 char lines_0[] = ",";
1292 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1297 char fstype[] = "ext2";
1298 char device[] = "/dev/sda1";
1299 device[5] = devchar;
1302 r = guestfs_mkfs (g, fstype, device);
1307 char device[] = "/dev/sda1";
1308 device[5] = devchar;
1309 char mountpoint[] = "/";
1312 r = guestfs_mount (g, device, mountpoint);
1316 /* TestOutputList for strings (1) */
1318 char path[] = "/new";
1321 r = guestfs_touch (g, path);
1326 char path[] = "/new";
1330 r = guestfs_strings (g, path);
1334 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1338 for (i = 0; r[i] != NULL; ++i)
1345 static int test_equal_0_skip (void)
1349 str = getenv ("SKIP_TEST_EQUAL_0");
1350 if (str && strcmp (str, "1") == 0) return 1;
1351 str = getenv ("SKIP_TEST_EQUAL");
1352 if (str && strcmp (str, "1") == 0) return 1;
1356 static int test_equal_0 (void)
1358 if (test_equal_0_skip ()) {
1359 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1363 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1365 char device[] = "/dev/sda";
1366 device[5] = devchar;
1369 r = guestfs_blockdev_setrw (g, device);
1376 r = guestfs_umount_all (g);
1383 r = guestfs_lvm_remove_all (g);
1388 char device[] = "/dev/sda";
1389 device[5] = devchar;
1390 char lines_0[] = ",";
1397 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1402 char fstype[] = "ext2";
1403 char device[] = "/dev/sda1";
1404 device[5] = devchar;
1407 r = guestfs_mkfs (g, fstype, device);
1412 char device[] = "/dev/sda1";
1413 device[5] = devchar;
1414 char mountpoint[] = "/";
1417 r = guestfs_mount (g, device, mountpoint);
1421 /* TestOutputTrue for equal (0) */
1423 char path[] = "/file1";
1424 char content[] = "contents of a file";
1427 r = guestfs_write_file (g, path, content, 0);
1432 char src[] = "/file1";
1433 char dest[] = "/file2";
1436 r = guestfs_cp (g, src, dest);
1441 char file1[] = "/file1";
1442 char file2[] = "/file2";
1445 r = guestfs_equal (g, file1, file2);
1449 fprintf (stderr, "test_equal_0: expected true, got false\n");
1456 static int test_equal_1_skip (void)
1460 str = getenv ("SKIP_TEST_EQUAL_1");
1461 if (str && strcmp (str, "1") == 0) return 1;
1462 str = getenv ("SKIP_TEST_EQUAL");
1463 if (str && strcmp (str, "1") == 0) return 1;
1467 static int test_equal_1 (void)
1469 if (test_equal_1_skip ()) {
1470 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
1474 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
1476 char device[] = "/dev/sda";
1477 device[5] = devchar;
1480 r = guestfs_blockdev_setrw (g, device);
1487 r = guestfs_umount_all (g);
1494 r = guestfs_lvm_remove_all (g);
1499 char device[] = "/dev/sda";
1500 device[5] = devchar;
1501 char lines_0[] = ",";
1508 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1513 char fstype[] = "ext2";
1514 char device[] = "/dev/sda1";
1515 device[5] = devchar;
1518 r = guestfs_mkfs (g, fstype, device);
1523 char device[] = "/dev/sda1";
1524 device[5] = devchar;
1525 char mountpoint[] = "/";
1528 r = guestfs_mount (g, device, mountpoint);
1532 /* TestOutputFalse for equal (1) */
1534 char path[] = "/file1";
1535 char content[] = "contents of a file";
1538 r = guestfs_write_file (g, path, content, 0);
1543 char path[] = "/file2";
1544 char content[] = "contents of another file";
1547 r = guestfs_write_file (g, path, content, 0);
1552 char file1[] = "/file1";
1553 char file2[] = "/file2";
1556 r = guestfs_equal (g, file1, file2);
1560 fprintf (stderr, "test_equal_1: expected false, got true\n");
1567 static int test_equal_2_skip (void)
1571 str = getenv ("SKIP_TEST_EQUAL_2");
1572 if (str && strcmp (str, "1") == 0) return 1;
1573 str = getenv ("SKIP_TEST_EQUAL");
1574 if (str && strcmp (str, "1") == 0) return 1;
1578 static int test_equal_2 (void)
1580 if (test_equal_2_skip ()) {
1581 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
1585 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
1587 char device[] = "/dev/sda";
1588 device[5] = devchar;
1591 r = guestfs_blockdev_setrw (g, device);
1598 r = guestfs_umount_all (g);
1605 r = guestfs_lvm_remove_all (g);
1610 char device[] = "/dev/sda";
1611 device[5] = devchar;
1612 char lines_0[] = ",";
1619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1624 char fstype[] = "ext2";
1625 char device[] = "/dev/sda1";
1626 device[5] = devchar;
1629 r = guestfs_mkfs (g, fstype, device);
1634 char device[] = "/dev/sda1";
1635 device[5] = devchar;
1636 char mountpoint[] = "/";
1639 r = guestfs_mount (g, device, mountpoint);
1643 /* TestLastFail for equal (2) */
1645 char file1[] = "/file1";
1646 char file2[] = "/file2";
1649 r = guestfs_equal (g, file1, file2);
1656 static int test_ping_daemon_0_skip (void)
1660 str = getenv ("SKIP_TEST_PING_DAEMON_0");
1661 if (str && strcmp (str, "1") == 0) return 1;
1662 str = getenv ("SKIP_TEST_PING_DAEMON");
1663 if (str && strcmp (str, "1") == 0) return 1;
1667 static int test_ping_daemon_0 (void)
1669 if (test_ping_daemon_0_skip ()) {
1670 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
1674 /* InitNone|InitEmpty for test_ping_daemon_0 */
1676 char device[] = "/dev/sda";
1677 device[5] = devchar;
1680 r = guestfs_blockdev_setrw (g, device);
1687 r = guestfs_umount_all (g);
1694 r = guestfs_lvm_remove_all (g);
1698 /* TestRun for ping_daemon (0) */
1702 r = guestfs_ping_daemon (g);
1709 static int test_dmesg_0_skip (void)
1713 str = getenv ("SKIP_TEST_DMESG_0");
1714 if (str && strcmp (str, "1") == 0) return 1;
1715 str = getenv ("SKIP_TEST_DMESG");
1716 if (str && strcmp (str, "1") == 0) return 1;
1720 static int test_dmesg_0 (void)
1722 if (test_dmesg_0_skip ()) {
1723 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
1727 /* InitNone|InitEmpty for test_dmesg_0 */
1729 char device[] = "/dev/sda";
1730 device[5] = devchar;
1733 r = guestfs_blockdev_setrw (g, device);
1740 r = guestfs_umount_all (g);
1747 r = guestfs_lvm_remove_all (g);
1751 /* TestRun for dmesg (0) */
1755 r = guestfs_dmesg (g);
1763 static int test_drop_caches_0_skip (void)
1767 str = getenv ("SKIP_TEST_DROP_CACHES_0");
1768 if (str && strcmp (str, "1") == 0) return 1;
1769 str = getenv ("SKIP_TEST_DROP_CACHES");
1770 if (str && strcmp (str, "1") == 0) return 1;
1774 static int test_drop_caches_0 (void)
1776 if (test_drop_caches_0_skip ()) {
1777 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
1781 /* InitNone|InitEmpty for test_drop_caches_0 */
1783 char device[] = "/dev/sda";
1784 device[5] = devchar;
1787 r = guestfs_blockdev_setrw (g, device);
1794 r = guestfs_umount_all (g);
1801 r = guestfs_lvm_remove_all (g);
1805 /* TestRun for drop_caches (0) */
1809 r = guestfs_drop_caches (g, 3);
1816 static int test_mv_0_skip (void)
1820 str = getenv ("SKIP_TEST_MV_0");
1821 if (str && strcmp (str, "1") == 0) return 1;
1822 str = getenv ("SKIP_TEST_MV");
1823 if (str && strcmp (str, "1") == 0) return 1;
1827 static int test_mv_0 (void)
1829 if (test_mv_0_skip ()) {
1830 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
1834 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
1836 char device[] = "/dev/sda";
1837 device[5] = devchar;
1840 r = guestfs_blockdev_setrw (g, device);
1847 r = guestfs_umount_all (g);
1854 r = guestfs_lvm_remove_all (g);
1859 char device[] = "/dev/sda";
1860 device[5] = devchar;
1861 char lines_0[] = ",";
1868 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1873 char fstype[] = "ext2";
1874 char device[] = "/dev/sda1";
1875 device[5] = devchar;
1878 r = guestfs_mkfs (g, fstype, device);
1883 char device[] = "/dev/sda1";
1884 device[5] = devchar;
1885 char mountpoint[] = "/";
1888 r = guestfs_mount (g, device, mountpoint);
1892 /* TestOutput for mv (0) */
1893 char expected[] = "file content";
1895 char path[] = "/old";
1896 char content[] = "file content";
1899 r = guestfs_write_file (g, path, content, 0);
1904 char src[] = "/old";
1905 char dest[] = "/new";
1908 r = guestfs_mv (g, src, dest);
1913 char path[] = "/new";
1916 r = guestfs_cat (g, path);
1919 if (strcmp (r, expected) != 0) {
1920 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
1928 static int test_mv_1_skip (void)
1932 str = getenv ("SKIP_TEST_MV_1");
1933 if (str && strcmp (str, "1") == 0) return 1;
1934 str = getenv ("SKIP_TEST_MV");
1935 if (str && strcmp (str, "1") == 0) return 1;
1939 static int test_mv_1 (void)
1941 if (test_mv_1_skip ()) {
1942 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
1946 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
1948 char device[] = "/dev/sda";
1949 device[5] = devchar;
1952 r = guestfs_blockdev_setrw (g, device);
1959 r = guestfs_umount_all (g);
1966 r = guestfs_lvm_remove_all (g);
1971 char device[] = "/dev/sda";
1972 device[5] = devchar;
1973 char lines_0[] = ",";
1980 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1985 char fstype[] = "ext2";
1986 char device[] = "/dev/sda1";
1987 device[5] = devchar;
1990 r = guestfs_mkfs (g, fstype, device);
1995 char device[] = "/dev/sda1";
1996 device[5] = devchar;
1997 char mountpoint[] = "/";
2000 r = guestfs_mount (g, device, mountpoint);
2004 /* TestOutputFalse for mv (1) */
2006 char path[] = "/old";
2007 char content[] = "file content";
2010 r = guestfs_write_file (g, path, content, 0);
2015 char src[] = "/old";
2016 char dest[] = "/new";
2019 r = guestfs_mv (g, src, dest);
2024 char path[] = "/old";
2027 r = guestfs_is_file (g, path);
2031 fprintf (stderr, "test_mv_1: expected false, got true\n");
2038 static int test_cp_a_0_skip (void)
2042 str = getenv ("SKIP_TEST_CP_A_0");
2043 if (str && strcmp (str, "1") == 0) return 1;
2044 str = getenv ("SKIP_TEST_CP_A");
2045 if (str && strcmp (str, "1") == 0) return 1;
2049 static int test_cp_a_0 (void)
2051 if (test_cp_a_0_skip ()) {
2052 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2056 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2058 char device[] = "/dev/sda";
2059 device[5] = devchar;
2062 r = guestfs_blockdev_setrw (g, device);
2069 r = guestfs_umount_all (g);
2076 r = guestfs_lvm_remove_all (g);
2081 char device[] = "/dev/sda";
2082 device[5] = devchar;
2083 char lines_0[] = ",";
2090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2095 char fstype[] = "ext2";
2096 char device[] = "/dev/sda1";
2097 device[5] = devchar;
2100 r = guestfs_mkfs (g, fstype, device);
2105 char device[] = "/dev/sda1";
2106 device[5] = devchar;
2107 char mountpoint[] = "/";
2110 r = guestfs_mount (g, device, mountpoint);
2114 /* TestOutput for cp_a (0) */
2115 char expected[] = "file content";
2117 char path[] = "/olddir";
2120 r = guestfs_mkdir (g, path);
2125 char path[] = "/newdir";
2128 r = guestfs_mkdir (g, path);
2133 char path[] = "/olddir/file";
2134 char content[] = "file content";
2137 r = guestfs_write_file (g, path, content, 0);
2142 char src[] = "/olddir";
2143 char dest[] = "/newdir";
2146 r = guestfs_cp_a (g, src, dest);
2151 char path[] = "/newdir/olddir/file";
2154 r = guestfs_cat (g, path);
2157 if (strcmp (r, expected) != 0) {
2158 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2166 static int test_cp_0_skip (void)
2170 str = getenv ("SKIP_TEST_CP_0");
2171 if (str && strcmp (str, "1") == 0) return 1;
2172 str = getenv ("SKIP_TEST_CP");
2173 if (str && strcmp (str, "1") == 0) return 1;
2177 static int test_cp_0 (void)
2179 if (test_cp_0_skip ()) {
2180 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2184 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2186 char device[] = "/dev/sda";
2187 device[5] = devchar;
2190 r = guestfs_blockdev_setrw (g, device);
2197 r = guestfs_umount_all (g);
2204 r = guestfs_lvm_remove_all (g);
2209 char device[] = "/dev/sda";
2210 device[5] = devchar;
2211 char lines_0[] = ",";
2218 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2223 char fstype[] = "ext2";
2224 char device[] = "/dev/sda1";
2225 device[5] = devchar;
2228 r = guestfs_mkfs (g, fstype, device);
2233 char device[] = "/dev/sda1";
2234 device[5] = devchar;
2235 char mountpoint[] = "/";
2238 r = guestfs_mount (g, device, mountpoint);
2242 /* TestOutput for cp (0) */
2243 char expected[] = "file content";
2245 char path[] = "/old";
2246 char content[] = "file content";
2249 r = guestfs_write_file (g, path, content, 0);
2254 char src[] = "/old";
2255 char dest[] = "/new";
2258 r = guestfs_cp (g, src, dest);
2263 char path[] = "/new";
2266 r = guestfs_cat (g, path);
2269 if (strcmp (r, expected) != 0) {
2270 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2278 static int test_cp_1_skip (void)
2282 str = getenv ("SKIP_TEST_CP_1");
2283 if (str && strcmp (str, "1") == 0) return 1;
2284 str = getenv ("SKIP_TEST_CP");
2285 if (str && strcmp (str, "1") == 0) return 1;
2289 static int test_cp_1 (void)
2291 if (test_cp_1_skip ()) {
2292 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2296 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2298 char device[] = "/dev/sda";
2299 device[5] = devchar;
2302 r = guestfs_blockdev_setrw (g, device);
2309 r = guestfs_umount_all (g);
2316 r = guestfs_lvm_remove_all (g);
2321 char device[] = "/dev/sda";
2322 device[5] = devchar;
2323 char lines_0[] = ",";
2330 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2335 char fstype[] = "ext2";
2336 char device[] = "/dev/sda1";
2337 device[5] = devchar;
2340 r = guestfs_mkfs (g, fstype, device);
2345 char device[] = "/dev/sda1";
2346 device[5] = devchar;
2347 char mountpoint[] = "/";
2350 r = guestfs_mount (g, device, mountpoint);
2354 /* TestOutputTrue for cp (1) */
2356 char path[] = "/old";
2357 char content[] = "file content";
2360 r = guestfs_write_file (g, path, content, 0);
2365 char src[] = "/old";
2366 char dest[] = "/new";
2369 r = guestfs_cp (g, src, dest);
2374 char path[] = "/old";
2377 r = guestfs_is_file (g, path);
2381 fprintf (stderr, "test_cp_1: expected true, got false\n");
2388 static int test_cp_2_skip (void)
2392 str = getenv ("SKIP_TEST_CP_2");
2393 if (str && strcmp (str, "1") == 0) return 1;
2394 str = getenv ("SKIP_TEST_CP");
2395 if (str && strcmp (str, "1") == 0) return 1;
2399 static int test_cp_2 (void)
2401 if (test_cp_2_skip ()) {
2402 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2406 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2408 char device[] = "/dev/sda";
2409 device[5] = devchar;
2412 r = guestfs_blockdev_setrw (g, device);
2419 r = guestfs_umount_all (g);
2426 r = guestfs_lvm_remove_all (g);
2431 char device[] = "/dev/sda";
2432 device[5] = devchar;
2433 char lines_0[] = ",";
2440 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2445 char fstype[] = "ext2";
2446 char device[] = "/dev/sda1";
2447 device[5] = devchar;
2450 r = guestfs_mkfs (g, fstype, device);
2455 char device[] = "/dev/sda1";
2456 device[5] = devchar;
2457 char mountpoint[] = "/";
2460 r = guestfs_mount (g, device, mountpoint);
2464 /* TestOutput for cp (2) */
2465 char expected[] = "file content";
2467 char path[] = "/old";
2468 char content[] = "file content";
2471 r = guestfs_write_file (g, path, content, 0);
2476 char path[] = "/dir";
2479 r = guestfs_mkdir (g, path);
2484 char src[] = "/old";
2485 char dest[] = "/dir/new";
2488 r = guestfs_cp (g, src, dest);
2493 char path[] = "/dir/new";
2496 r = guestfs_cat (g, path);
2499 if (strcmp (r, expected) != 0) {
2500 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
2508 static int test_grub_install_0_skip (void)
2512 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
2513 if (str && strcmp (str, "1") == 0) return 1;
2514 str = getenv ("SKIP_TEST_GRUB_INSTALL");
2515 if (str && strcmp (str, "1") == 0) return 1;
2519 static int test_grub_install_0 (void)
2521 if (test_grub_install_0_skip ()) {
2522 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
2526 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
2528 char device[] = "/dev/sda";
2529 device[5] = devchar;
2532 r = guestfs_blockdev_setrw (g, device);
2539 r = guestfs_umount_all (g);
2546 r = guestfs_lvm_remove_all (g);
2551 char device[] = "/dev/sda";
2552 device[5] = devchar;
2553 char lines_0[] = ",";
2560 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2565 char fstype[] = "ext2";
2566 char device[] = "/dev/sda1";
2567 device[5] = devchar;
2570 r = guestfs_mkfs (g, fstype, device);
2575 char device[] = "/dev/sda1";
2576 device[5] = devchar;
2577 char mountpoint[] = "/";
2580 r = guestfs_mount (g, device, mountpoint);
2584 /* TestOutputTrue for grub_install (0) */
2587 char device[] = "/dev/sda1";
2588 device[5] = devchar;
2591 r = guestfs_grub_install (g, root, device);
2596 char path[] = "/boot";
2599 r = guestfs_is_dir (g, path);
2603 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
2610 static int test_zero_0_skip (void)
2614 str = getenv ("SKIP_TEST_ZERO_0");
2615 if (str && strcmp (str, "1") == 0) return 1;
2616 str = getenv ("SKIP_TEST_ZERO");
2617 if (str && strcmp (str, "1") == 0) return 1;
2621 static int test_zero_0 (void)
2623 if (test_zero_0_skip ()) {
2624 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
2628 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
2630 char device[] = "/dev/sda";
2631 device[5] = devchar;
2634 r = guestfs_blockdev_setrw (g, device);
2641 r = guestfs_umount_all (g);
2648 r = guestfs_lvm_remove_all (g);
2653 char device[] = "/dev/sda";
2654 device[5] = devchar;
2655 char lines_0[] = ",";
2662 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2667 char fstype[] = "ext2";
2668 char device[] = "/dev/sda1";
2669 device[5] = devchar;
2672 r = guestfs_mkfs (g, fstype, device);
2677 char device[] = "/dev/sda1";
2678 device[5] = devchar;
2679 char mountpoint[] = "/";
2682 r = guestfs_mount (g, device, mountpoint);
2686 /* TestOutput for zero (0) */
2687 char expected[] = "data";
2689 char pathordevice[] = "/dev/sda1";
2690 pathordevice[5] = devchar;
2693 r = guestfs_umount (g, pathordevice);
2698 char device[] = "/dev/sda1";
2699 device[5] = devchar;
2702 r = guestfs_zero (g, device);
2707 char path[] = "/dev/sda1";
2711 r = guestfs_file (g, path);
2714 if (strcmp (r, expected) != 0) {
2715 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
2723 static int test_fsck_0_skip (void)
2727 str = getenv ("SKIP_TEST_FSCK_0");
2728 if (str && strcmp (str, "1") == 0) return 1;
2729 str = getenv ("SKIP_TEST_FSCK");
2730 if (str && strcmp (str, "1") == 0) return 1;
2734 static int test_fsck_0 (void)
2736 if (test_fsck_0_skip ()) {
2737 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
2741 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
2743 char device[] = "/dev/sda";
2744 device[5] = devchar;
2747 r = guestfs_blockdev_setrw (g, device);
2754 r = guestfs_umount_all (g);
2761 r = guestfs_lvm_remove_all (g);
2766 char device[] = "/dev/sda";
2767 device[5] = devchar;
2768 char lines_0[] = ",";
2775 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2780 char fstype[] = "ext2";
2781 char device[] = "/dev/sda1";
2782 device[5] = devchar;
2785 r = guestfs_mkfs (g, fstype, device);
2790 char device[] = "/dev/sda1";
2791 device[5] = devchar;
2792 char mountpoint[] = "/";
2795 r = guestfs_mount (g, device, mountpoint);
2799 /* TestOutputInt for fsck (0) */
2801 char pathordevice[] = "/dev/sda1";
2802 pathordevice[5] = devchar;
2805 r = guestfs_umount (g, pathordevice);
2810 char fstype[] = "ext2";
2811 char device[] = "/dev/sda1";
2812 device[5] = devchar;
2815 r = guestfs_fsck (g, fstype, device);
2819 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
2826 static int test_fsck_1_skip (void)
2830 str = getenv ("SKIP_TEST_FSCK_1");
2831 if (str && strcmp (str, "1") == 0) return 1;
2832 str = getenv ("SKIP_TEST_FSCK");
2833 if (str && strcmp (str, "1") == 0) return 1;
2837 static int test_fsck_1 (void)
2839 if (test_fsck_1_skip ()) {
2840 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
2844 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
2846 char device[] = "/dev/sda";
2847 device[5] = devchar;
2850 r = guestfs_blockdev_setrw (g, device);
2857 r = guestfs_umount_all (g);
2864 r = guestfs_lvm_remove_all (g);
2869 char device[] = "/dev/sda";
2870 device[5] = devchar;
2871 char lines_0[] = ",";
2878 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2883 char fstype[] = "ext2";
2884 char device[] = "/dev/sda1";
2885 device[5] = devchar;
2888 r = guestfs_mkfs (g, fstype, device);
2893 char device[] = "/dev/sda1";
2894 device[5] = devchar;
2895 char mountpoint[] = "/";
2898 r = guestfs_mount (g, device, mountpoint);
2902 /* TestOutputInt for fsck (1) */
2904 char pathordevice[] = "/dev/sda1";
2905 pathordevice[5] = devchar;
2908 r = guestfs_umount (g, pathordevice);
2913 char device[] = "/dev/sda1";
2914 device[5] = devchar;
2917 r = guestfs_zero (g, device);
2922 char fstype[] = "ext2";
2923 char device[] = "/dev/sda1";
2924 device[5] = devchar;
2927 r = guestfs_fsck (g, fstype, device);
2931 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
2938 static int test_set_e2uuid_0_skip (void)
2942 str = getenv ("SKIP_TEST_SET_E2UUID_0");
2943 if (str && strcmp (str, "1") == 0) return 1;
2944 str = getenv ("SKIP_TEST_SET_E2UUID");
2945 if (str && strcmp (str, "1") == 0) return 1;
2949 static int test_set_e2uuid_0 (void)
2951 if (test_set_e2uuid_0_skip ()) {
2952 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
2956 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
2958 char device[] = "/dev/sda";
2959 device[5] = devchar;
2962 r = guestfs_blockdev_setrw (g, device);
2969 r = guestfs_umount_all (g);
2976 r = guestfs_lvm_remove_all (g);
2981 char device[] = "/dev/sda";
2982 device[5] = devchar;
2983 char lines_0[] = ",";
2990 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2995 char fstype[] = "ext2";
2996 char device[] = "/dev/sda1";
2997 device[5] = devchar;
3000 r = guestfs_mkfs (g, fstype, device);
3005 char device[] = "/dev/sda1";
3006 device[5] = devchar;
3007 char mountpoint[] = "/";
3010 r = guestfs_mount (g, device, mountpoint);
3014 /* TestOutput for set_e2uuid (0) */
3015 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3017 char device[] = "/dev/sda1";
3018 device[5] = devchar;
3019 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3022 r = guestfs_set_e2uuid (g, device, uuid);
3027 char device[] = "/dev/sda1";
3028 device[5] = devchar;
3031 r = guestfs_get_e2uuid (g, device);
3034 if (strcmp (r, expected) != 0) {
3035 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3043 static int test_set_e2uuid_1_skip (void)
3047 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3048 if (str && strcmp (str, "1") == 0) return 1;
3049 str = getenv ("SKIP_TEST_SET_E2UUID");
3050 if (str && strcmp (str, "1") == 0) return 1;
3054 static int test_set_e2uuid_1 (void)
3056 if (test_set_e2uuid_1_skip ()) {
3057 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3061 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3063 char device[] = "/dev/sda";
3064 device[5] = devchar;
3067 r = guestfs_blockdev_setrw (g, device);
3074 r = guestfs_umount_all (g);
3081 r = guestfs_lvm_remove_all (g);
3086 char device[] = "/dev/sda";
3087 device[5] = devchar;
3088 char lines_0[] = ",";
3095 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3100 char fstype[] = "ext2";
3101 char device[] = "/dev/sda1";
3102 device[5] = devchar;
3105 r = guestfs_mkfs (g, fstype, device);
3110 char device[] = "/dev/sda1";
3111 device[5] = devchar;
3112 char mountpoint[] = "/";
3115 r = guestfs_mount (g, device, mountpoint);
3119 /* TestOutput for set_e2uuid (1) */
3120 char expected[] = "";
3122 char device[] = "/dev/sda1";
3123 device[5] = devchar;
3124 char uuid[] = "clear";
3127 r = guestfs_set_e2uuid (g, device, uuid);
3132 char device[] = "/dev/sda1";
3133 device[5] = devchar;
3136 r = guestfs_get_e2uuid (g, device);
3139 if (strcmp (r, expected) != 0) {
3140 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3148 static int test_set_e2uuid_2_skip (void)
3152 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3153 if (str && strcmp (str, "1") == 0) return 1;
3154 str = getenv ("SKIP_TEST_SET_E2UUID");
3155 if (str && strcmp (str, "1") == 0) return 1;
3159 static int test_set_e2uuid_2 (void)
3161 if (test_set_e2uuid_2_skip ()) {
3162 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3166 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3168 char device[] = "/dev/sda";
3169 device[5] = devchar;
3172 r = guestfs_blockdev_setrw (g, device);
3179 r = guestfs_umount_all (g);
3186 r = guestfs_lvm_remove_all (g);
3191 char device[] = "/dev/sda";
3192 device[5] = devchar;
3193 char lines_0[] = ",";
3200 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3205 char fstype[] = "ext2";
3206 char device[] = "/dev/sda1";
3207 device[5] = devchar;
3210 r = guestfs_mkfs (g, fstype, device);
3215 char device[] = "/dev/sda1";
3216 device[5] = devchar;
3217 char mountpoint[] = "/";
3220 r = guestfs_mount (g, device, mountpoint);
3224 /* TestRun for set_e2uuid (2) */
3226 char device[] = "/dev/sda1";
3227 device[5] = devchar;
3228 char uuid[] = "random";
3231 r = guestfs_set_e2uuid (g, device, uuid);
3238 static int test_set_e2uuid_3_skip (void)
3242 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3243 if (str && strcmp (str, "1") == 0) return 1;
3244 str = getenv ("SKIP_TEST_SET_E2UUID");
3245 if (str && strcmp (str, "1") == 0) return 1;
3249 static int test_set_e2uuid_3 (void)
3251 if (test_set_e2uuid_3_skip ()) {
3252 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3256 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3258 char device[] = "/dev/sda";
3259 device[5] = devchar;
3262 r = guestfs_blockdev_setrw (g, device);
3269 r = guestfs_umount_all (g);
3276 r = guestfs_lvm_remove_all (g);
3281 char device[] = "/dev/sda";
3282 device[5] = devchar;
3283 char lines_0[] = ",";
3290 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3295 char fstype[] = "ext2";
3296 char device[] = "/dev/sda1";
3297 device[5] = devchar;
3300 r = guestfs_mkfs (g, fstype, device);
3305 char device[] = "/dev/sda1";
3306 device[5] = devchar;
3307 char mountpoint[] = "/";
3310 r = guestfs_mount (g, device, mountpoint);
3314 /* TestRun for set_e2uuid (3) */
3316 char device[] = "/dev/sda1";
3317 device[5] = devchar;
3318 char uuid[] = "time";
3321 r = guestfs_set_e2uuid (g, device, uuid);
3328 static int test_set_e2label_0_skip (void)
3332 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3333 if (str && strcmp (str, "1") == 0) return 1;
3334 str = getenv ("SKIP_TEST_SET_E2LABEL");
3335 if (str && strcmp (str, "1") == 0) return 1;
3339 static int test_set_e2label_0 (void)
3341 if (test_set_e2label_0_skip ()) {
3342 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3346 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3348 char device[] = "/dev/sda";
3349 device[5] = devchar;
3352 r = guestfs_blockdev_setrw (g, device);
3359 r = guestfs_umount_all (g);
3366 r = guestfs_lvm_remove_all (g);
3371 char device[] = "/dev/sda";
3372 device[5] = devchar;
3373 char lines_0[] = ",";
3380 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3385 char fstype[] = "ext2";
3386 char device[] = "/dev/sda1";
3387 device[5] = devchar;
3390 r = guestfs_mkfs (g, fstype, device);
3395 char device[] = "/dev/sda1";
3396 device[5] = devchar;
3397 char mountpoint[] = "/";
3400 r = guestfs_mount (g, device, mountpoint);
3404 /* TestOutput for set_e2label (0) */
3405 char expected[] = "testlabel";
3407 char device[] = "/dev/sda1";
3408 device[5] = devchar;
3409 char label[] = "testlabel";
3412 r = guestfs_set_e2label (g, device, label);
3417 char device[] = "/dev/sda1";
3418 device[5] = devchar;
3421 r = guestfs_get_e2label (g, device);
3424 if (strcmp (r, expected) != 0) {
3425 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3433 static int test_pvremove_0_skip (void)
3437 str = getenv ("SKIP_TEST_PVREMOVE_0");
3438 if (str && strcmp (str, "1") == 0) return 1;
3439 str = getenv ("SKIP_TEST_PVREMOVE");
3440 if (str && strcmp (str, "1") == 0) return 1;
3444 static int test_pvremove_0 (void)
3446 if (test_pvremove_0_skip ()) {
3447 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3451 /* InitNone|InitEmpty for test_pvremove_0 */
3453 char device[] = "/dev/sda";
3454 device[5] = devchar;
3457 r = guestfs_blockdev_setrw (g, device);
3464 r = guestfs_umount_all (g);
3471 r = guestfs_lvm_remove_all (g);
3475 /* TestOutputList for pvremove (0) */
3477 char device[] = "/dev/sda";
3478 device[5] = devchar;
3479 char lines_0[] = ",";
3486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3491 char device[] = "/dev/sda1";
3492 device[5] = devchar;
3495 r = guestfs_pvcreate (g, device);
3500 char volgroup[] = "VG";
3501 char physvols_0[] = "/dev/sda1";
3502 physvols_0[5] = devchar;
3503 char *physvols[] = {
3509 r = guestfs_vgcreate (g, volgroup, physvols);
3514 char logvol[] = "LV1";
3515 char volgroup[] = "VG";
3518 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3523 char logvol[] = "LV2";
3524 char volgroup[] = "VG";
3527 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3532 char vgname[] = "VG";
3535 r = guestfs_vgremove (g, vgname);
3540 char device[] = "/dev/sda1";
3541 device[5] = devchar;
3544 r = guestfs_pvremove (g, device);
3552 r = guestfs_lvs (g);
3556 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
3560 for (i = 0; r[i] != NULL; ++i)
3567 static int test_pvremove_1_skip (void)
3571 str = getenv ("SKIP_TEST_PVREMOVE_1");
3572 if (str && strcmp (str, "1") == 0) return 1;
3573 str = getenv ("SKIP_TEST_PVREMOVE");
3574 if (str && strcmp (str, "1") == 0) return 1;
3578 static int test_pvremove_1 (void)
3580 if (test_pvremove_1_skip ()) {
3581 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
3585 /* InitNone|InitEmpty for test_pvremove_1 */
3587 char device[] = "/dev/sda";
3588 device[5] = devchar;
3591 r = guestfs_blockdev_setrw (g, device);
3598 r = guestfs_umount_all (g);
3605 r = guestfs_lvm_remove_all (g);
3609 /* TestOutputList for pvremove (1) */
3611 char device[] = "/dev/sda";
3612 device[5] = devchar;
3613 char lines_0[] = ",";
3620 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3625 char device[] = "/dev/sda1";
3626 device[5] = devchar;
3629 r = guestfs_pvcreate (g, device);
3634 char volgroup[] = "VG";
3635 char physvols_0[] = "/dev/sda1";
3636 physvols_0[5] = devchar;
3637 char *physvols[] = {
3643 r = guestfs_vgcreate (g, volgroup, physvols);
3648 char logvol[] = "LV1";
3649 char volgroup[] = "VG";
3652 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3657 char logvol[] = "LV2";
3658 char volgroup[] = "VG";
3661 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3666 char vgname[] = "VG";
3669 r = guestfs_vgremove (g, vgname);
3674 char device[] = "/dev/sda1";
3675 device[5] = devchar;
3678 r = guestfs_pvremove (g, device);
3686 r = guestfs_vgs (g);
3690 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
3694 for (i = 0; r[i] != NULL; ++i)
3701 static int test_pvremove_2_skip (void)
3705 str = getenv ("SKIP_TEST_PVREMOVE_2");
3706 if (str && strcmp (str, "1") == 0) return 1;
3707 str = getenv ("SKIP_TEST_PVREMOVE");
3708 if (str && strcmp (str, "1") == 0) return 1;
3712 static int test_pvremove_2 (void)
3714 if (test_pvremove_2_skip ()) {
3715 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
3719 /* InitNone|InitEmpty for test_pvremove_2 */
3721 char device[] = "/dev/sda";
3722 device[5] = devchar;
3725 r = guestfs_blockdev_setrw (g, device);
3732 r = guestfs_umount_all (g);
3739 r = guestfs_lvm_remove_all (g);
3743 /* TestOutputList for pvremove (2) */
3745 char device[] = "/dev/sda";
3746 device[5] = devchar;
3747 char lines_0[] = ",";
3754 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3759 char device[] = "/dev/sda1";
3760 device[5] = devchar;
3763 r = guestfs_pvcreate (g, device);
3768 char volgroup[] = "VG";
3769 char physvols_0[] = "/dev/sda1";
3770 physvols_0[5] = devchar;
3771 char *physvols[] = {
3777 r = guestfs_vgcreate (g, volgroup, physvols);
3782 char logvol[] = "LV1";
3783 char volgroup[] = "VG";
3786 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3791 char logvol[] = "LV2";
3792 char volgroup[] = "VG";
3795 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3800 char vgname[] = "VG";
3803 r = guestfs_vgremove (g, vgname);
3808 char device[] = "/dev/sda1";
3809 device[5] = devchar;
3812 r = guestfs_pvremove (g, device);
3820 r = guestfs_pvs (g);
3824 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
3828 for (i = 0; r[i] != NULL; ++i)
3835 static int test_vgremove_0_skip (void)
3839 str = getenv ("SKIP_TEST_VGREMOVE_0");
3840 if (str && strcmp (str, "1") == 0) return 1;
3841 str = getenv ("SKIP_TEST_VGREMOVE");
3842 if (str && strcmp (str, "1") == 0) return 1;
3846 static int test_vgremove_0 (void)
3848 if (test_vgremove_0_skip ()) {
3849 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
3853 /* InitNone|InitEmpty for test_vgremove_0 */
3855 char device[] = "/dev/sda";
3856 device[5] = devchar;
3859 r = guestfs_blockdev_setrw (g, device);
3866 r = guestfs_umount_all (g);
3873 r = guestfs_lvm_remove_all (g);
3877 /* TestOutputList for vgremove (0) */
3879 char device[] = "/dev/sda";
3880 device[5] = devchar;
3881 char lines_0[] = ",";
3888 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3893 char device[] = "/dev/sda1";
3894 device[5] = devchar;
3897 r = guestfs_pvcreate (g, device);
3902 char volgroup[] = "VG";
3903 char physvols_0[] = "/dev/sda1";
3904 physvols_0[5] = devchar;
3905 char *physvols[] = {
3911 r = guestfs_vgcreate (g, volgroup, physvols);
3916 char logvol[] = "LV1";
3917 char volgroup[] = "VG";
3920 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3925 char logvol[] = "LV2";
3926 char volgroup[] = "VG";
3929 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3934 char vgname[] = "VG";
3937 r = guestfs_vgremove (g, vgname);
3945 r = guestfs_lvs (g);
3949 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
3953 for (i = 0; r[i] != NULL; ++i)
3960 static int test_vgremove_1_skip (void)
3964 str = getenv ("SKIP_TEST_VGREMOVE_1");
3965 if (str && strcmp (str, "1") == 0) return 1;
3966 str = getenv ("SKIP_TEST_VGREMOVE");
3967 if (str && strcmp (str, "1") == 0) return 1;
3971 static int test_vgremove_1 (void)
3973 if (test_vgremove_1_skip ()) {
3974 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
3978 /* InitNone|InitEmpty for test_vgremove_1 */
3980 char device[] = "/dev/sda";
3981 device[5] = devchar;
3984 r = guestfs_blockdev_setrw (g, device);
3991 r = guestfs_umount_all (g);
3998 r = guestfs_lvm_remove_all (g);
4002 /* TestOutputList for vgremove (1) */
4004 char device[] = "/dev/sda";
4005 device[5] = devchar;
4006 char lines_0[] = ",";
4013 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4018 char device[] = "/dev/sda1";
4019 device[5] = devchar;
4022 r = guestfs_pvcreate (g, device);
4027 char volgroup[] = "VG";
4028 char physvols_0[] = "/dev/sda1";
4029 physvols_0[5] = devchar;
4030 char *physvols[] = {
4036 r = guestfs_vgcreate (g, volgroup, physvols);
4041 char logvol[] = "LV1";
4042 char volgroup[] = "VG";
4045 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4050 char logvol[] = "LV2";
4051 char volgroup[] = "VG";
4054 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4059 char vgname[] = "VG";
4062 r = guestfs_vgremove (g, vgname);
4070 r = guestfs_vgs (g);
4074 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4078 for (i = 0; r[i] != NULL; ++i)
4085 static int test_lvremove_0_skip (void)
4089 str = getenv ("SKIP_TEST_LVREMOVE_0");
4090 if (str && strcmp (str, "1") == 0) return 1;
4091 str = getenv ("SKIP_TEST_LVREMOVE");
4092 if (str && strcmp (str, "1") == 0) return 1;
4096 static int test_lvremove_0 (void)
4098 if (test_lvremove_0_skip ()) {
4099 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4103 /* InitNone|InitEmpty for test_lvremove_0 */
4105 char device[] = "/dev/sda";
4106 device[5] = devchar;
4109 r = guestfs_blockdev_setrw (g, device);
4116 r = guestfs_umount_all (g);
4123 r = guestfs_lvm_remove_all (g);
4127 /* TestOutputList for lvremove (0) */
4129 char device[] = "/dev/sda";
4130 device[5] = devchar;
4131 char lines_0[] = ",";
4138 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4143 char device[] = "/dev/sda1";
4144 device[5] = devchar;
4147 r = guestfs_pvcreate (g, device);
4152 char volgroup[] = "VG";
4153 char physvols_0[] = "/dev/sda1";
4154 physvols_0[5] = devchar;
4155 char *physvols[] = {
4161 r = guestfs_vgcreate (g, volgroup, physvols);
4166 char logvol[] = "LV1";
4167 char volgroup[] = "VG";
4170 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4175 char logvol[] = "LV2";
4176 char volgroup[] = "VG";
4179 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4184 char device[] = "/dev/VG/LV1";
4187 r = guestfs_lvremove (g, device);
4195 r = guestfs_lvs (g);
4199 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4204 char expected[] = "/dev/VG/LV2";
4205 if (strcmp (r[0], expected) != 0) {
4206 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4211 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4215 for (i = 0; r[i] != NULL; ++i)
4222 static int test_lvremove_1_skip (void)
4226 str = getenv ("SKIP_TEST_LVREMOVE_1");
4227 if (str && strcmp (str, "1") == 0) return 1;
4228 str = getenv ("SKIP_TEST_LVREMOVE");
4229 if (str && strcmp (str, "1") == 0) return 1;
4233 static int test_lvremove_1 (void)
4235 if (test_lvremove_1_skip ()) {
4236 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4240 /* InitNone|InitEmpty for test_lvremove_1 */
4242 char device[] = "/dev/sda";
4243 device[5] = devchar;
4246 r = guestfs_blockdev_setrw (g, device);
4253 r = guestfs_umount_all (g);
4260 r = guestfs_lvm_remove_all (g);
4264 /* TestOutputList for lvremove (1) */
4266 char device[] = "/dev/sda";
4267 device[5] = devchar;
4268 char lines_0[] = ",";
4275 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4280 char device[] = "/dev/sda1";
4281 device[5] = devchar;
4284 r = guestfs_pvcreate (g, device);
4289 char volgroup[] = "VG";
4290 char physvols_0[] = "/dev/sda1";
4291 physvols_0[5] = devchar;
4292 char *physvols[] = {
4298 r = guestfs_vgcreate (g, volgroup, physvols);
4303 char logvol[] = "LV1";
4304 char volgroup[] = "VG";
4307 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4312 char logvol[] = "LV2";
4313 char volgroup[] = "VG";
4316 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4321 char device[] = "/dev/VG";
4324 r = guestfs_lvremove (g, device);
4332 r = guestfs_lvs (g);
4336 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4340 for (i = 0; r[i] != NULL; ++i)
4347 static int test_lvremove_2_skip (void)
4351 str = getenv ("SKIP_TEST_LVREMOVE_2");
4352 if (str && strcmp (str, "1") == 0) return 1;
4353 str = getenv ("SKIP_TEST_LVREMOVE");
4354 if (str && strcmp (str, "1") == 0) return 1;
4358 static int test_lvremove_2 (void)
4360 if (test_lvremove_2_skip ()) {
4361 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4365 /* InitNone|InitEmpty for test_lvremove_2 */
4367 char device[] = "/dev/sda";
4368 device[5] = devchar;
4371 r = guestfs_blockdev_setrw (g, device);
4378 r = guestfs_umount_all (g);
4385 r = guestfs_lvm_remove_all (g);
4389 /* TestOutputList for lvremove (2) */
4391 char device[] = "/dev/sda";
4392 device[5] = devchar;
4393 char lines_0[] = ",";
4400 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4405 char device[] = "/dev/sda1";
4406 device[5] = devchar;
4409 r = guestfs_pvcreate (g, device);
4414 char volgroup[] = "VG";
4415 char physvols_0[] = "/dev/sda1";
4416 physvols_0[5] = devchar;
4417 char *physvols[] = {
4423 r = guestfs_vgcreate (g, volgroup, physvols);
4428 char logvol[] = "LV1";
4429 char volgroup[] = "VG";
4432 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4437 char logvol[] = "LV2";
4438 char volgroup[] = "VG";
4441 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4446 char device[] = "/dev/VG";
4449 r = guestfs_lvremove (g, device);
4457 r = guestfs_vgs (g);
4461 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4466 char expected[] = "VG";
4467 if (strcmp (r[0], expected) != 0) {
4468 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4473 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4477 for (i = 0; r[i] != NULL; ++i)
4484 static int test_mount_ro_0_skip (void)
4488 str = getenv ("SKIP_TEST_MOUNT_RO_0");
4489 if (str && strcmp (str, "1") == 0) return 1;
4490 str = getenv ("SKIP_TEST_MOUNT_RO");
4491 if (str && strcmp (str, "1") == 0) return 1;
4495 static int test_mount_ro_0 (void)
4497 if (test_mount_ro_0_skip ()) {
4498 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4502 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4504 char device[] = "/dev/sda";
4505 device[5] = devchar;
4508 r = guestfs_blockdev_setrw (g, device);
4515 r = guestfs_umount_all (g);
4522 r = guestfs_lvm_remove_all (g);
4527 char device[] = "/dev/sda";
4528 device[5] = devchar;
4529 char lines_0[] = ",";
4536 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4541 char fstype[] = "ext2";
4542 char device[] = "/dev/sda1";
4543 device[5] = devchar;
4546 r = guestfs_mkfs (g, fstype, device);
4551 char device[] = "/dev/sda1";
4552 device[5] = devchar;
4553 char mountpoint[] = "/";
4556 r = guestfs_mount (g, device, mountpoint);
4560 /* TestLastFail for mount_ro (0) */
4562 char pathordevice[] = "/";
4565 r = guestfs_umount (g, pathordevice);
4570 char device[] = "/dev/sda1";
4571 device[5] = devchar;
4572 char mountpoint[] = "/";
4575 r = guestfs_mount_ro (g, device, mountpoint);
4580 char path[] = "/new";
4583 r = guestfs_touch (g, path);
4590 static int test_mount_ro_1_skip (void)
4594 str = getenv ("SKIP_TEST_MOUNT_RO_1");
4595 if (str && strcmp (str, "1") == 0) return 1;
4596 str = getenv ("SKIP_TEST_MOUNT_RO");
4597 if (str && strcmp (str, "1") == 0) return 1;
4601 static int test_mount_ro_1 (void)
4603 if (test_mount_ro_1_skip ()) {
4604 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
4608 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
4610 char device[] = "/dev/sda";
4611 device[5] = devchar;
4614 r = guestfs_blockdev_setrw (g, device);
4621 r = guestfs_umount_all (g);
4628 r = guestfs_lvm_remove_all (g);
4633 char device[] = "/dev/sda";
4634 device[5] = devchar;
4635 char lines_0[] = ",";
4642 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4647 char fstype[] = "ext2";
4648 char device[] = "/dev/sda1";
4649 device[5] = devchar;
4652 r = guestfs_mkfs (g, fstype, device);
4657 char device[] = "/dev/sda1";
4658 device[5] = devchar;
4659 char mountpoint[] = "/";
4662 r = guestfs_mount (g, device, mountpoint);
4666 /* TestOutput for mount_ro (1) */
4667 char expected[] = "data";
4669 char path[] = "/new";
4670 char content[] = "data";
4673 r = guestfs_write_file (g, path, content, 0);
4678 char pathordevice[] = "/";
4681 r = guestfs_umount (g, pathordevice);
4686 char device[] = "/dev/sda1";
4687 device[5] = devchar;
4688 char mountpoint[] = "/";
4691 r = guestfs_mount_ro (g, device, mountpoint);
4696 char path[] = "/new";
4699 r = guestfs_cat (g, path);
4702 if (strcmp (r, expected) != 0) {
4703 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
4711 static int test_tgz_in_0_skip (void)
4715 str = getenv ("SKIP_TEST_TGZ_IN_0");
4716 if (str && strcmp (str, "1") == 0) return 1;
4717 str = getenv ("SKIP_TEST_TGZ_IN");
4718 if (str && strcmp (str, "1") == 0) return 1;
4722 static int test_tgz_in_0 (void)
4724 if (test_tgz_in_0_skip ()) {
4725 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
4729 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
4731 char device[] = "/dev/sda";
4732 device[5] = devchar;
4735 r = guestfs_blockdev_setrw (g, device);
4742 r = guestfs_umount_all (g);
4749 r = guestfs_lvm_remove_all (g);
4754 char device[] = "/dev/sda";
4755 device[5] = devchar;
4756 char lines_0[] = ",";
4763 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4768 char fstype[] = "ext2";
4769 char device[] = "/dev/sda1";
4770 device[5] = devchar;
4773 r = guestfs_mkfs (g, fstype, device);
4778 char device[] = "/dev/sda1";
4779 device[5] = devchar;
4780 char mountpoint[] = "/";
4783 r = guestfs_mount (g, device, mountpoint);
4787 /* TestOutput for tgz_in (0) */
4788 char expected[] = "hello\n";
4790 char directory[] = "/";
4793 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
4798 char path[] = "/hello";
4801 r = guestfs_cat (g, path);
4804 if (strcmp (r, expected) != 0) {
4805 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4813 static int test_tar_in_0_skip (void)
4817 str = getenv ("SKIP_TEST_TAR_IN_0");
4818 if (str && strcmp (str, "1") == 0) return 1;
4819 str = getenv ("SKIP_TEST_TAR_IN");
4820 if (str && strcmp (str, "1") == 0) return 1;
4824 static int test_tar_in_0 (void)
4826 if (test_tar_in_0_skip ()) {
4827 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
4831 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
4833 char device[] = "/dev/sda";
4834 device[5] = devchar;
4837 r = guestfs_blockdev_setrw (g, device);
4844 r = guestfs_umount_all (g);
4851 r = guestfs_lvm_remove_all (g);
4856 char device[] = "/dev/sda";
4857 device[5] = devchar;
4858 char lines_0[] = ",";
4865 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4870 char fstype[] = "ext2";
4871 char device[] = "/dev/sda1";
4872 device[5] = devchar;
4875 r = guestfs_mkfs (g, fstype, device);
4880 char device[] = "/dev/sda1";
4881 device[5] = devchar;
4882 char mountpoint[] = "/";
4885 r = guestfs_mount (g, device, mountpoint);
4889 /* TestOutput for tar_in (0) */
4890 char expected[] = "hello\n";
4892 char directory[] = "/";
4895 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
4900 char path[] = "/hello";
4903 r = guestfs_cat (g, path);
4906 if (strcmp (r, expected) != 0) {
4907 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
4915 static int test_checksum_0_skip (void)
4919 str = getenv ("SKIP_TEST_CHECKSUM_0");
4920 if (str && strcmp (str, "1") == 0) return 1;
4921 str = getenv ("SKIP_TEST_CHECKSUM");
4922 if (str && strcmp (str, "1") == 0) return 1;
4926 static int test_checksum_0 (void)
4928 if (test_checksum_0_skip ()) {
4929 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
4933 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
4935 char device[] = "/dev/sda";
4936 device[5] = devchar;
4939 r = guestfs_blockdev_setrw (g, device);
4946 r = guestfs_umount_all (g);
4953 r = guestfs_lvm_remove_all (g);
4958 char device[] = "/dev/sda";
4959 device[5] = devchar;
4960 char lines_0[] = ",";
4967 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4972 char fstype[] = "ext2";
4973 char device[] = "/dev/sda1";
4974 device[5] = devchar;
4977 r = guestfs_mkfs (g, fstype, device);
4982 char device[] = "/dev/sda1";
4983 device[5] = devchar;
4984 char mountpoint[] = "/";
4987 r = guestfs_mount (g, device, mountpoint);
4991 /* TestOutput for checksum (0) */
4992 char expected[] = "935282863";
4994 char path[] = "/new";
4995 char content[] = "test\n";
4998 r = guestfs_write_file (g, path, content, 0);
5003 char csumtype[] = "crc";
5004 char path[] = "/new";
5007 r = guestfs_checksum (g, csumtype, path);
5010 if (strcmp (r, expected) != 0) {
5011 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5019 static int test_checksum_1_skip (void)
5023 str = getenv ("SKIP_TEST_CHECKSUM_1");
5024 if (str && strcmp (str, "1") == 0) return 1;
5025 str = getenv ("SKIP_TEST_CHECKSUM");
5026 if (str && strcmp (str, "1") == 0) return 1;
5030 static int test_checksum_1 (void)
5032 if (test_checksum_1_skip ()) {
5033 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5037 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5039 char device[] = "/dev/sda";
5040 device[5] = devchar;
5043 r = guestfs_blockdev_setrw (g, device);
5050 r = guestfs_umount_all (g);
5057 r = guestfs_lvm_remove_all (g);
5062 char device[] = "/dev/sda";
5063 device[5] = devchar;
5064 char lines_0[] = ",";
5071 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5076 char fstype[] = "ext2";
5077 char device[] = "/dev/sda1";
5078 device[5] = devchar;
5081 r = guestfs_mkfs (g, fstype, device);
5086 char device[] = "/dev/sda1";
5087 device[5] = devchar;
5088 char mountpoint[] = "/";
5091 r = guestfs_mount (g, device, mountpoint);
5095 /* TestLastFail for checksum (1) */
5097 char csumtype[] = "crc";
5098 char path[] = "/new";
5101 r = guestfs_checksum (g, csumtype, path);
5109 static int test_checksum_2_skip (void)
5113 str = getenv ("SKIP_TEST_CHECKSUM_2");
5114 if (str && strcmp (str, "1") == 0) return 1;
5115 str = getenv ("SKIP_TEST_CHECKSUM");
5116 if (str && strcmp (str, "1") == 0) return 1;
5120 static int test_checksum_2 (void)
5122 if (test_checksum_2_skip ()) {
5123 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5127 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5129 char device[] = "/dev/sda";
5130 device[5] = devchar;
5133 r = guestfs_blockdev_setrw (g, device);
5140 r = guestfs_umount_all (g);
5147 r = guestfs_lvm_remove_all (g);
5152 char device[] = "/dev/sda";
5153 device[5] = devchar;
5154 char lines_0[] = ",";
5161 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5166 char fstype[] = "ext2";
5167 char device[] = "/dev/sda1";
5168 device[5] = devchar;
5171 r = guestfs_mkfs (g, fstype, device);
5176 char device[] = "/dev/sda1";
5177 device[5] = devchar;
5178 char mountpoint[] = "/";
5181 r = guestfs_mount (g, device, mountpoint);
5185 /* TestOutput for checksum (2) */
5186 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5188 char path[] = "/new";
5189 char content[] = "test\n";
5192 r = guestfs_write_file (g, path, content, 0);
5197 char csumtype[] = "md5";
5198 char path[] = "/new";
5201 r = guestfs_checksum (g, csumtype, path);
5204 if (strcmp (r, expected) != 0) {
5205 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5213 static int test_checksum_3_skip (void)
5217 str = getenv ("SKIP_TEST_CHECKSUM_3");
5218 if (str && strcmp (str, "1") == 0) return 1;
5219 str = getenv ("SKIP_TEST_CHECKSUM");
5220 if (str && strcmp (str, "1") == 0) return 1;
5224 static int test_checksum_3 (void)
5226 if (test_checksum_3_skip ()) {
5227 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5231 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5233 char device[] = "/dev/sda";
5234 device[5] = devchar;
5237 r = guestfs_blockdev_setrw (g, device);
5244 r = guestfs_umount_all (g);
5251 r = guestfs_lvm_remove_all (g);
5256 char device[] = "/dev/sda";
5257 device[5] = devchar;
5258 char lines_0[] = ",";
5265 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5270 char fstype[] = "ext2";
5271 char device[] = "/dev/sda1";
5272 device[5] = devchar;
5275 r = guestfs_mkfs (g, fstype, device);
5280 char device[] = "/dev/sda1";
5281 device[5] = devchar;
5282 char mountpoint[] = "/";
5285 r = guestfs_mount (g, device, mountpoint);
5289 /* TestOutput for checksum (3) */
5290 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5292 char path[] = "/new";
5293 char content[] = "test\n";
5296 r = guestfs_write_file (g, path, content, 0);
5301 char csumtype[] = "sha1";
5302 char path[] = "/new";
5305 r = guestfs_checksum (g, csumtype, path);
5308 if (strcmp (r, expected) != 0) {
5309 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5317 static int test_checksum_4_skip (void)
5321 str = getenv ("SKIP_TEST_CHECKSUM_4");
5322 if (str && strcmp (str, "1") == 0) return 1;
5323 str = getenv ("SKIP_TEST_CHECKSUM");
5324 if (str && strcmp (str, "1") == 0) return 1;
5328 static int test_checksum_4 (void)
5330 if (test_checksum_4_skip ()) {
5331 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5335 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5337 char device[] = "/dev/sda";
5338 device[5] = devchar;
5341 r = guestfs_blockdev_setrw (g, device);
5348 r = guestfs_umount_all (g);
5355 r = guestfs_lvm_remove_all (g);
5360 char device[] = "/dev/sda";
5361 device[5] = devchar;
5362 char lines_0[] = ",";
5369 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5374 char fstype[] = "ext2";
5375 char device[] = "/dev/sda1";
5376 device[5] = devchar;
5379 r = guestfs_mkfs (g, fstype, device);
5384 char device[] = "/dev/sda1";
5385 device[5] = devchar;
5386 char mountpoint[] = "/";
5389 r = guestfs_mount (g, device, mountpoint);
5393 /* TestOutput for checksum (4) */
5394 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5396 char path[] = "/new";
5397 char content[] = "test\n";
5400 r = guestfs_write_file (g, path, content, 0);
5405 char csumtype[] = "sha224";
5406 char path[] = "/new";
5409 r = guestfs_checksum (g, csumtype, path);
5412 if (strcmp (r, expected) != 0) {
5413 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5421 static int test_checksum_5_skip (void)
5425 str = getenv ("SKIP_TEST_CHECKSUM_5");
5426 if (str && strcmp (str, "1") == 0) return 1;
5427 str = getenv ("SKIP_TEST_CHECKSUM");
5428 if (str && strcmp (str, "1") == 0) return 1;
5432 static int test_checksum_5 (void)
5434 if (test_checksum_5_skip ()) {
5435 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5439 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5441 char device[] = "/dev/sda";
5442 device[5] = devchar;
5445 r = guestfs_blockdev_setrw (g, device);
5452 r = guestfs_umount_all (g);
5459 r = guestfs_lvm_remove_all (g);
5464 char device[] = "/dev/sda";
5465 device[5] = devchar;
5466 char lines_0[] = ",";
5473 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5478 char fstype[] = "ext2";
5479 char device[] = "/dev/sda1";
5480 device[5] = devchar;
5483 r = guestfs_mkfs (g, fstype, device);
5488 char device[] = "/dev/sda1";
5489 device[5] = devchar;
5490 char mountpoint[] = "/";
5493 r = guestfs_mount (g, device, mountpoint);
5497 /* TestOutput for checksum (5) */
5498 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5500 char path[] = "/new";
5501 char content[] = "test\n";
5504 r = guestfs_write_file (g, path, content, 0);
5509 char csumtype[] = "sha256";
5510 char path[] = "/new";
5513 r = guestfs_checksum (g, csumtype, path);
5516 if (strcmp (r, expected) != 0) {
5517 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5525 static int test_checksum_6_skip (void)
5529 str = getenv ("SKIP_TEST_CHECKSUM_6");
5530 if (str && strcmp (str, "1") == 0) return 1;
5531 str = getenv ("SKIP_TEST_CHECKSUM");
5532 if (str && strcmp (str, "1") == 0) return 1;
5536 static int test_checksum_6 (void)
5538 if (test_checksum_6_skip ()) {
5539 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5543 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5545 char device[] = "/dev/sda";
5546 device[5] = devchar;
5549 r = guestfs_blockdev_setrw (g, device);
5556 r = guestfs_umount_all (g);
5563 r = guestfs_lvm_remove_all (g);
5568 char device[] = "/dev/sda";
5569 device[5] = devchar;
5570 char lines_0[] = ",";
5577 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5582 char fstype[] = "ext2";
5583 char device[] = "/dev/sda1";
5584 device[5] = devchar;
5587 r = guestfs_mkfs (g, fstype, device);
5592 char device[] = "/dev/sda1";
5593 device[5] = devchar;
5594 char mountpoint[] = "/";
5597 r = guestfs_mount (g, device, mountpoint);
5601 /* TestOutput for checksum (6) */
5602 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5604 char path[] = "/new";
5605 char content[] = "test\n";
5608 r = guestfs_write_file (g, path, content, 0);
5613 char csumtype[] = "sha384";
5614 char path[] = "/new";
5617 r = guestfs_checksum (g, csumtype, path);
5620 if (strcmp (r, expected) != 0) {
5621 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
5629 static int test_checksum_7_skip (void)
5633 str = getenv ("SKIP_TEST_CHECKSUM_7");
5634 if (str && strcmp (str, "1") == 0) return 1;
5635 str = getenv ("SKIP_TEST_CHECKSUM");
5636 if (str && strcmp (str, "1") == 0) return 1;
5640 static int test_checksum_7 (void)
5642 if (test_checksum_7_skip ()) {
5643 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
5647 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
5649 char device[] = "/dev/sda";
5650 device[5] = devchar;
5653 r = guestfs_blockdev_setrw (g, device);
5660 r = guestfs_umount_all (g);
5667 r = guestfs_lvm_remove_all (g);
5672 char device[] = "/dev/sda";
5673 device[5] = devchar;
5674 char lines_0[] = ",";
5681 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5686 char fstype[] = "ext2";
5687 char device[] = "/dev/sda1";
5688 device[5] = devchar;
5691 r = guestfs_mkfs (g, fstype, device);
5696 char device[] = "/dev/sda1";
5697 device[5] = devchar;
5698 char mountpoint[] = "/";
5701 r = guestfs_mount (g, device, mountpoint);
5705 /* TestOutput for checksum (7) */
5706 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
5708 char path[] = "/new";
5709 char content[] = "test\n";
5712 r = guestfs_write_file (g, path, content, 0);
5717 char csumtype[] = "sha512";
5718 char path[] = "/new";
5721 r = guestfs_checksum (g, csumtype, path);
5724 if (strcmp (r, expected) != 0) {
5725 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
5733 static int test_checksum_8_skip (void)
5737 str = getenv ("SKIP_TEST_CHECKSUM_8");
5738 if (str && strcmp (str, "1") == 0) return 1;
5739 str = getenv ("SKIP_TEST_CHECKSUM");
5740 if (str && strcmp (str, "1") == 0) return 1;
5744 static int test_checksum_8 (void)
5746 if (test_checksum_8_skip ()) {
5747 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
5751 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
5753 char device[] = "/dev/sda";
5754 device[5] = devchar;
5757 r = guestfs_blockdev_setrw (g, device);
5764 r = guestfs_umount_all (g);
5771 r = guestfs_lvm_remove_all (g);
5776 char device[] = "/dev/sda";
5777 device[5] = devchar;
5778 char lines_0[] = ",";
5785 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5790 char fstype[] = "ext2";
5791 char device[] = "/dev/sda1";
5792 device[5] = devchar;
5795 r = guestfs_mkfs (g, fstype, device);
5800 char device[] = "/dev/sda1";
5801 device[5] = devchar;
5802 char mountpoint[] = "/";
5805 r = guestfs_mount (g, device, mountpoint);
5809 /* TestOutput for checksum (8) */
5810 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
5812 char device[] = "/dev/sdd";
5813 device[5] = devchar;
5814 char mountpoint[] = "/";
5817 r = guestfs_mount (g, device, mountpoint);
5822 char csumtype[] = "md5";
5823 char path[] = "/known-3";
5826 r = guestfs_checksum (g, csumtype, path);
5829 if (strcmp (r, expected) != 0) {
5830 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
5838 static int test_download_0_skip (void)
5842 str = getenv ("SKIP_TEST_DOWNLOAD_0");
5843 if (str && strcmp (str, "1") == 0) return 1;
5844 str = getenv ("SKIP_TEST_DOWNLOAD");
5845 if (str && strcmp (str, "1") == 0) return 1;
5849 static int test_download_0 (void)
5851 if (test_download_0_skip ()) {
5852 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
5856 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
5858 char device[] = "/dev/sda";
5859 device[5] = devchar;
5862 r = guestfs_blockdev_setrw (g, device);
5869 r = guestfs_umount_all (g);
5876 r = guestfs_lvm_remove_all (g);
5881 char device[] = "/dev/sda";
5882 device[5] = devchar;
5883 char lines_0[] = ",";
5890 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5895 char fstype[] = "ext2";
5896 char device[] = "/dev/sda1";
5897 device[5] = devchar;
5900 r = guestfs_mkfs (g, fstype, device);
5905 char device[] = "/dev/sda1";
5906 device[5] = devchar;
5907 char mountpoint[] = "/";
5910 r = guestfs_mount (g, device, mountpoint);
5914 /* TestOutput for download (0) */
5915 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
5917 char remotefilename[] = "/COPYING.LIB";
5920 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
5925 char remotefilename[] = "/COPYING.LIB";
5928 r = guestfs_download (g, remotefilename, "testdownload.tmp");
5933 char remotefilename[] = "/upload";
5936 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
5941 char csumtype[] = "md5";
5942 char path[] = "/upload";
5945 r = guestfs_checksum (g, csumtype, path);
5948 if (strcmp (r, expected) != 0) {
5949 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
5957 static int test_upload_0_skip (void)
5961 str = getenv ("SKIP_TEST_UPLOAD_0");
5962 if (str && strcmp (str, "1") == 0) return 1;
5963 str = getenv ("SKIP_TEST_UPLOAD");
5964 if (str && strcmp (str, "1") == 0) return 1;
5968 static int test_upload_0 (void)
5970 if (test_upload_0_skip ()) {
5971 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
5975 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
5977 char device[] = "/dev/sda";
5978 device[5] = devchar;
5981 r = guestfs_blockdev_setrw (g, device);
5988 r = guestfs_umount_all (g);
5995 r = guestfs_lvm_remove_all (g);
6000 char device[] = "/dev/sda";
6001 device[5] = devchar;
6002 char lines_0[] = ",";
6009 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6014 char fstype[] = "ext2";
6015 char device[] = "/dev/sda1";
6016 device[5] = devchar;
6019 r = guestfs_mkfs (g, fstype, device);
6024 char device[] = "/dev/sda1";
6025 device[5] = devchar;
6026 char mountpoint[] = "/";
6029 r = guestfs_mount (g, device, mountpoint);
6033 /* TestOutput for upload (0) */
6034 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6036 char remotefilename[] = "/COPYING.LIB";
6039 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6044 char csumtype[] = "md5";
6045 char path[] = "/COPYING.LIB";
6048 r = guestfs_checksum (g, csumtype, path);
6051 if (strcmp (r, expected) != 0) {
6052 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6060 static int test_blockdev_rereadpt_0_skip (void)
6064 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6065 if (str && strcmp (str, "1") == 0) return 1;
6066 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6067 if (str && strcmp (str, "1") == 0) return 1;
6071 static int test_blockdev_rereadpt_0 (void)
6073 if (test_blockdev_rereadpt_0_skip ()) {
6074 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6078 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6080 char device[] = "/dev/sda";
6081 device[5] = devchar;
6084 r = guestfs_blockdev_setrw (g, device);
6091 r = guestfs_umount_all (g);
6098 r = guestfs_lvm_remove_all (g);
6102 /* TestRun for blockdev_rereadpt (0) */
6104 char device[] = "/dev/sda";
6105 device[5] = devchar;
6108 r = guestfs_blockdev_rereadpt (g, device);
6115 static int test_blockdev_flushbufs_0_skip (void)
6119 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6120 if (str && strcmp (str, "1") == 0) return 1;
6121 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6122 if (str && strcmp (str, "1") == 0) return 1;
6126 static int test_blockdev_flushbufs_0 (void)
6128 if (test_blockdev_flushbufs_0_skip ()) {
6129 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6133 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6135 char device[] = "/dev/sda";
6136 device[5] = devchar;
6139 r = guestfs_blockdev_setrw (g, device);
6146 r = guestfs_umount_all (g);
6153 r = guestfs_lvm_remove_all (g);
6157 /* TestRun for blockdev_flushbufs (0) */
6159 char device[] = "/dev/sda";
6160 device[5] = devchar;
6163 r = guestfs_blockdev_flushbufs (g, device);
6170 static int test_blockdev_getsize64_0_skip (void)
6174 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6175 if (str && strcmp (str, "1") == 0) return 1;
6176 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6177 if (str && strcmp (str, "1") == 0) return 1;
6181 static int test_blockdev_getsize64_0 (void)
6183 if (test_blockdev_getsize64_0_skip ()) {
6184 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6188 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6190 char device[] = "/dev/sda";
6191 device[5] = devchar;
6194 r = guestfs_blockdev_setrw (g, device);
6201 r = guestfs_umount_all (g);
6208 r = guestfs_lvm_remove_all (g);
6212 /* TestOutputInt for blockdev_getsize64 (0) */
6214 char device[] = "/dev/sda";
6215 device[5] = devchar;
6218 r = guestfs_blockdev_getsize64 (g, device);
6221 if (r != 524288000) {
6222 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6229 static int test_blockdev_getsz_0_skip (void)
6233 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6234 if (str && strcmp (str, "1") == 0) return 1;
6235 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6236 if (str && strcmp (str, "1") == 0) return 1;
6240 static int test_blockdev_getsz_0 (void)
6242 if (test_blockdev_getsz_0_skip ()) {
6243 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6247 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6249 char device[] = "/dev/sda";
6250 device[5] = devchar;
6253 r = guestfs_blockdev_setrw (g, device);
6260 r = guestfs_umount_all (g);
6267 r = guestfs_lvm_remove_all (g);
6271 /* TestOutputInt for blockdev_getsz (0) */
6273 char device[] = "/dev/sda";
6274 device[5] = devchar;
6277 r = guestfs_blockdev_getsz (g, device);
6281 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6288 static int test_blockdev_getbsz_0_skip (void)
6292 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6293 if (str && strcmp (str, "1") == 0) return 1;
6294 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6295 if (str && strcmp (str, "1") == 0) return 1;
6299 static int test_blockdev_getbsz_0 (void)
6301 if (test_blockdev_getbsz_0_skip ()) {
6302 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6306 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6308 char device[] = "/dev/sda";
6309 device[5] = devchar;
6312 r = guestfs_blockdev_setrw (g, device);
6319 r = guestfs_umount_all (g);
6326 r = guestfs_lvm_remove_all (g);
6330 /* TestOutputInt for blockdev_getbsz (0) */
6332 char device[] = "/dev/sda";
6333 device[5] = devchar;
6336 r = guestfs_blockdev_getbsz (g, device);
6340 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6347 static int test_blockdev_getss_0_skip (void)
6351 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6352 if (str && strcmp (str, "1") == 0) return 1;
6353 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6354 if (str && strcmp (str, "1") == 0) return 1;
6358 static int test_blockdev_getss_0 (void)
6360 if (test_blockdev_getss_0_skip ()) {
6361 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6365 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6367 char device[] = "/dev/sda";
6368 device[5] = devchar;
6371 r = guestfs_blockdev_setrw (g, device);
6378 r = guestfs_umount_all (g);
6385 r = guestfs_lvm_remove_all (g);
6389 /* TestOutputInt for blockdev_getss (0) */
6391 char device[] = "/dev/sda";
6392 device[5] = devchar;
6395 r = guestfs_blockdev_getss (g, device);
6399 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6406 static int test_blockdev_getro_0_skip (void)
6410 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6411 if (str && strcmp (str, "1") == 0) return 1;
6412 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6413 if (str && strcmp (str, "1") == 0) return 1;
6417 static int test_blockdev_getro_0 (void)
6419 if (test_blockdev_getro_0_skip ()) {
6420 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6424 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6426 char device[] = "/dev/sda";
6427 device[5] = devchar;
6430 r = guestfs_blockdev_setrw (g, device);
6437 r = guestfs_umount_all (g);
6444 r = guestfs_lvm_remove_all (g);
6448 /* TestOutputTrue for blockdev_getro (0) */
6450 char device[] = "/dev/sda";
6451 device[5] = devchar;
6454 r = guestfs_blockdev_setro (g, device);
6459 char device[] = "/dev/sda";
6460 device[5] = devchar;
6463 r = guestfs_blockdev_getro (g, device);
6467 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6474 static int test_blockdev_setrw_0_skip (void)
6478 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6479 if (str && strcmp (str, "1") == 0) return 1;
6480 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6481 if (str && strcmp (str, "1") == 0) return 1;
6485 static int test_blockdev_setrw_0 (void)
6487 if (test_blockdev_setrw_0_skip ()) {
6488 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6492 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6494 char device[] = "/dev/sda";
6495 device[5] = devchar;
6498 r = guestfs_blockdev_setrw (g, device);
6505 r = guestfs_umount_all (g);
6512 r = guestfs_lvm_remove_all (g);
6516 /* TestOutputFalse for blockdev_setrw (0) */
6518 char device[] = "/dev/sda";
6519 device[5] = devchar;
6522 r = guestfs_blockdev_setrw (g, device);
6527 char device[] = "/dev/sda";
6528 device[5] = devchar;
6531 r = guestfs_blockdev_getro (g, device);
6535 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6542 static int test_blockdev_setro_0_skip (void)
6546 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6547 if (str && strcmp (str, "1") == 0) return 1;
6548 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6549 if (str && strcmp (str, "1") == 0) return 1;
6553 static int test_blockdev_setro_0 (void)
6555 if (test_blockdev_setro_0_skip ()) {
6556 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6560 /* InitNone|InitEmpty for test_blockdev_setro_0 */
6562 char device[] = "/dev/sda";
6563 device[5] = devchar;
6566 r = guestfs_blockdev_setrw (g, device);
6573 r = guestfs_umount_all (g);
6580 r = guestfs_lvm_remove_all (g);
6584 /* TestOutputTrue for blockdev_setro (0) */
6586 char device[] = "/dev/sda";
6587 device[5] = devchar;
6590 r = guestfs_blockdev_setro (g, device);
6595 char device[] = "/dev/sda";
6596 device[5] = devchar;
6599 r = guestfs_blockdev_getro (g, device);
6603 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6610 static int test_statvfs_0_skip (void)
6614 str = getenv ("SKIP_TEST_STATVFS_0");
6615 if (str && strcmp (str, "1") == 0) return 1;
6616 str = getenv ("SKIP_TEST_STATVFS");
6617 if (str && strcmp (str, "1") == 0) return 1;
6621 static int test_statvfs_0 (void)
6623 if (test_statvfs_0_skip ()) {
6624 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6628 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6630 char device[] = "/dev/sda";
6631 device[5] = devchar;
6634 r = guestfs_blockdev_setrw (g, device);
6641 r = guestfs_umount_all (g);
6648 r = guestfs_lvm_remove_all (g);
6653 char device[] = "/dev/sda";
6654 device[5] = devchar;
6655 char lines_0[] = ",";
6662 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6667 char fstype[] = "ext2";
6668 char device[] = "/dev/sda1";
6669 device[5] = devchar;
6672 r = guestfs_mkfs (g, fstype, device);
6677 char device[] = "/dev/sda1";
6678 device[5] = devchar;
6679 char mountpoint[] = "/";
6682 r = guestfs_mount (g, device, mountpoint);
6686 /* TestOutputStruct for statvfs (0) */
6689 struct guestfs_statvfs *r;
6691 r = guestfs_statvfs (g, path);
6694 if (r->bfree != 487702) {
6695 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
6699 if (r->blocks != 490020) {
6700 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
6704 if (r->bsize != 1024) {
6705 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
6714 static int test_lstat_0_skip (void)
6718 str = getenv ("SKIP_TEST_LSTAT_0");
6719 if (str && strcmp (str, "1") == 0) return 1;
6720 str = getenv ("SKIP_TEST_LSTAT");
6721 if (str && strcmp (str, "1") == 0) return 1;
6725 static int test_lstat_0 (void)
6727 if (test_lstat_0_skip ()) {
6728 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
6732 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
6734 char device[] = "/dev/sda";
6735 device[5] = devchar;
6738 r = guestfs_blockdev_setrw (g, device);
6745 r = guestfs_umount_all (g);
6752 r = guestfs_lvm_remove_all (g);
6757 char device[] = "/dev/sda";
6758 device[5] = devchar;
6759 char lines_0[] = ",";
6766 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6771 char fstype[] = "ext2";
6772 char device[] = "/dev/sda1";
6773 device[5] = devchar;
6776 r = guestfs_mkfs (g, fstype, device);
6781 char device[] = "/dev/sda1";
6782 device[5] = devchar;
6783 char mountpoint[] = "/";
6786 r = guestfs_mount (g, device, mountpoint);
6790 /* TestOutputStruct for lstat (0) */
6792 char path[] = "/new";
6795 r = guestfs_touch (g, path);
6800 char path[] = "/new";
6801 struct guestfs_stat *r;
6803 r = guestfs_lstat (g, path);
6807 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
6816 static int test_stat_0_skip (void)
6820 str = getenv ("SKIP_TEST_STAT_0");
6821 if (str && strcmp (str, "1") == 0) return 1;
6822 str = getenv ("SKIP_TEST_STAT");
6823 if (str && strcmp (str, "1") == 0) return 1;
6827 static int test_stat_0 (void)
6829 if (test_stat_0_skip ()) {
6830 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
6834 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
6836 char device[] = "/dev/sda";
6837 device[5] = devchar;
6840 r = guestfs_blockdev_setrw (g, device);
6847 r = guestfs_umount_all (g);
6854 r = guestfs_lvm_remove_all (g);
6859 char device[] = "/dev/sda";
6860 device[5] = devchar;
6861 char lines_0[] = ",";
6868 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6873 char fstype[] = "ext2";
6874 char device[] = "/dev/sda1";
6875 device[5] = devchar;
6878 r = guestfs_mkfs (g, fstype, device);
6883 char device[] = "/dev/sda1";
6884 device[5] = devchar;
6885 char mountpoint[] = "/";
6888 r = guestfs_mount (g, device, mountpoint);
6892 /* TestOutputStruct for stat (0) */
6894 char path[] = "/new";
6897 r = guestfs_touch (g, path);
6902 char path[] = "/new";
6903 struct guestfs_stat *r;
6905 r = guestfs_stat (g, path);
6909 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
6918 static int test_command_lines_0_skip (void)
6922 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
6923 if (str && strcmp (str, "1") == 0) return 1;
6924 str = getenv ("SKIP_TEST_COMMAND_LINES");
6925 if (str && strcmp (str, "1") == 0) return 1;
6929 static int test_command_lines_0 (void)
6931 if (test_command_lines_0_skip ()) {
6932 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
6936 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
6938 char device[] = "/dev/sda";
6939 device[5] = devchar;
6942 r = guestfs_blockdev_setrw (g, device);
6949 r = guestfs_umount_all (g);
6956 r = guestfs_lvm_remove_all (g);
6961 char device[] = "/dev/sda";
6962 device[5] = devchar;
6963 char lines_0[] = ",";
6970 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6975 char fstype[] = "ext2";
6976 char device[] = "/dev/sda1";
6977 device[5] = devchar;
6980 r = guestfs_mkfs (g, fstype, device);
6985 char device[] = "/dev/sda1";
6986 device[5] = devchar;
6987 char mountpoint[] = "/";
6990 r = guestfs_mount (g, device, mountpoint);
6994 /* TestOutputList for command_lines (0) */
6996 char remotefilename[] = "/test-command";
6999 r = guestfs_upload (g, "test-command", remotefilename);
7004 char path[] = "/test-command";
7007 r = guestfs_chmod (g, 493, path);
7012 char arguments_0[] = "/test-command";
7013 char arguments_1[] = "1";
7014 char *arguments[] = {
7022 r = guestfs_command_lines (g, arguments);
7026 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7031 char expected[] = "Result1";
7032 if (strcmp (r[0], expected) != 0) {
7033 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7038 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7042 for (i = 0; r[i] != NULL; ++i)
7049 static int test_command_lines_1_skip (void)
7053 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7054 if (str && strcmp (str, "1") == 0) return 1;
7055 str = getenv ("SKIP_TEST_COMMAND_LINES");
7056 if (str && strcmp (str, "1") == 0) return 1;
7060 static int test_command_lines_1 (void)
7062 if (test_command_lines_1_skip ()) {
7063 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7067 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7069 char device[] = "/dev/sda";
7070 device[5] = devchar;
7073 r = guestfs_blockdev_setrw (g, device);
7080 r = guestfs_umount_all (g);
7087 r = guestfs_lvm_remove_all (g);
7092 char device[] = "/dev/sda";
7093 device[5] = devchar;
7094 char lines_0[] = ",";
7101 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7106 char fstype[] = "ext2";
7107 char device[] = "/dev/sda1";
7108 device[5] = devchar;
7111 r = guestfs_mkfs (g, fstype, device);
7116 char device[] = "/dev/sda1";
7117 device[5] = devchar;
7118 char mountpoint[] = "/";
7121 r = guestfs_mount (g, device, mountpoint);
7125 /* TestOutputList for command_lines (1) */
7127 char remotefilename[] = "/test-command";
7130 r = guestfs_upload (g, "test-command", remotefilename);
7135 char path[] = "/test-command";
7138 r = guestfs_chmod (g, 493, path);
7143 char arguments_0[] = "/test-command";
7144 char arguments_1[] = "2";
7145 char *arguments[] = {
7153 r = guestfs_command_lines (g, arguments);
7157 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7162 char expected[] = "Result2";
7163 if (strcmp (r[0], expected) != 0) {
7164 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7169 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7173 for (i = 0; r[i] != NULL; ++i)
7180 static int test_command_lines_2_skip (void)
7184 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7185 if (str && strcmp (str, "1") == 0) return 1;
7186 str = getenv ("SKIP_TEST_COMMAND_LINES");
7187 if (str && strcmp (str, "1") == 0) return 1;
7191 static int test_command_lines_2 (void)
7193 if (test_command_lines_2_skip ()) {
7194 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7198 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7200 char device[] = "/dev/sda";
7201 device[5] = devchar;
7204 r = guestfs_blockdev_setrw (g, device);
7211 r = guestfs_umount_all (g);
7218 r = guestfs_lvm_remove_all (g);
7223 char device[] = "/dev/sda";
7224 device[5] = devchar;
7225 char lines_0[] = ",";
7232 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7237 char fstype[] = "ext2";
7238 char device[] = "/dev/sda1";
7239 device[5] = devchar;
7242 r = guestfs_mkfs (g, fstype, device);
7247 char device[] = "/dev/sda1";
7248 device[5] = devchar;
7249 char mountpoint[] = "/";
7252 r = guestfs_mount (g, device, mountpoint);
7256 /* TestOutputList for command_lines (2) */
7258 char remotefilename[] = "/test-command";
7261 r = guestfs_upload (g, "test-command", remotefilename);
7266 char path[] = "/test-command";
7269 r = guestfs_chmod (g, 493, path);
7274 char arguments_0[] = "/test-command";
7275 char arguments_1[] = "3";
7276 char *arguments[] = {
7284 r = guestfs_command_lines (g, arguments);
7288 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7293 char expected[] = "";
7294 if (strcmp (r[0], expected) != 0) {
7295 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7300 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7305 char expected[] = "Result3";
7306 if (strcmp (r[1], expected) != 0) {
7307 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7312 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7316 for (i = 0; r[i] != NULL; ++i)
7323 static int test_command_lines_3_skip (void)
7327 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7328 if (str && strcmp (str, "1") == 0) return 1;
7329 str = getenv ("SKIP_TEST_COMMAND_LINES");
7330 if (str && strcmp (str, "1") == 0) return 1;
7334 static int test_command_lines_3 (void)
7336 if (test_command_lines_3_skip ()) {
7337 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7341 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7343 char device[] = "/dev/sda";
7344 device[5] = devchar;
7347 r = guestfs_blockdev_setrw (g, device);
7354 r = guestfs_umount_all (g);
7361 r = guestfs_lvm_remove_all (g);
7366 char device[] = "/dev/sda";
7367 device[5] = devchar;
7368 char lines_0[] = ",";
7375 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7380 char fstype[] = "ext2";
7381 char device[] = "/dev/sda1";
7382 device[5] = devchar;
7385 r = guestfs_mkfs (g, fstype, device);
7390 char device[] = "/dev/sda1";
7391 device[5] = devchar;
7392 char mountpoint[] = "/";
7395 r = guestfs_mount (g, device, mountpoint);
7399 /* TestOutputList for command_lines (3) */
7401 char remotefilename[] = "/test-command";
7404 r = guestfs_upload (g, "test-command", remotefilename);
7409 char path[] = "/test-command";
7412 r = guestfs_chmod (g, 493, path);
7417 char arguments_0[] = "/test-command";
7418 char arguments_1[] = "4";
7419 char *arguments[] = {
7427 r = guestfs_command_lines (g, arguments);
7431 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7436 char expected[] = "";
7437 if (strcmp (r[0], expected) != 0) {
7438 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7443 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7448 char expected[] = "Result4";
7449 if (strcmp (r[1], expected) != 0) {
7450 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7455 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7459 for (i = 0; r[i] != NULL; ++i)
7466 static int test_command_lines_4_skip (void)
7470 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7471 if (str && strcmp (str, "1") == 0) return 1;
7472 str = getenv ("SKIP_TEST_COMMAND_LINES");
7473 if (str && strcmp (str, "1") == 0) return 1;
7477 static int test_command_lines_4 (void)
7479 if (test_command_lines_4_skip ()) {
7480 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7484 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7486 char device[] = "/dev/sda";
7487 device[5] = devchar;
7490 r = guestfs_blockdev_setrw (g, device);
7497 r = guestfs_umount_all (g);
7504 r = guestfs_lvm_remove_all (g);
7509 char device[] = "/dev/sda";
7510 device[5] = devchar;
7511 char lines_0[] = ",";
7518 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7523 char fstype[] = "ext2";
7524 char device[] = "/dev/sda1";
7525 device[5] = devchar;
7528 r = guestfs_mkfs (g, fstype, device);
7533 char device[] = "/dev/sda1";
7534 device[5] = devchar;
7535 char mountpoint[] = "/";
7538 r = guestfs_mount (g, device, mountpoint);
7542 /* TestOutputList for command_lines (4) */
7544 char remotefilename[] = "/test-command";
7547 r = guestfs_upload (g, "test-command", remotefilename);
7552 char path[] = "/test-command";
7555 r = guestfs_chmod (g, 493, path);
7560 char arguments_0[] = "/test-command";
7561 char arguments_1[] = "5";
7562 char *arguments[] = {
7570 r = guestfs_command_lines (g, arguments);
7574 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7579 char expected[] = "";
7580 if (strcmp (r[0], expected) != 0) {
7581 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7586 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7591 char expected[] = "Result5";
7592 if (strcmp (r[1], expected) != 0) {
7593 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7598 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7603 char expected[] = "";
7604 if (strcmp (r[2], expected) != 0) {
7605 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7610 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7614 for (i = 0; r[i] != NULL; ++i)
7621 static int test_command_lines_5_skip (void)
7625 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7626 if (str && strcmp (str, "1") == 0) return 1;
7627 str = getenv ("SKIP_TEST_COMMAND_LINES");
7628 if (str && strcmp (str, "1") == 0) return 1;
7632 static int test_command_lines_5 (void)
7634 if (test_command_lines_5_skip ()) {
7635 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7639 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7641 char device[] = "/dev/sda";
7642 device[5] = devchar;
7645 r = guestfs_blockdev_setrw (g, device);
7652 r = guestfs_umount_all (g);
7659 r = guestfs_lvm_remove_all (g);
7664 char device[] = "/dev/sda";
7665 device[5] = devchar;
7666 char lines_0[] = ",";
7673 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7678 char fstype[] = "ext2";
7679 char device[] = "/dev/sda1";
7680 device[5] = devchar;
7683 r = guestfs_mkfs (g, fstype, device);
7688 char device[] = "/dev/sda1";
7689 device[5] = devchar;
7690 char mountpoint[] = "/";
7693 r = guestfs_mount (g, device, mountpoint);
7697 /* TestOutputList for command_lines (5) */
7699 char remotefilename[] = "/test-command";
7702 r = guestfs_upload (g, "test-command", remotefilename);
7707 char path[] = "/test-command";
7710 r = guestfs_chmod (g, 493, path);
7715 char arguments_0[] = "/test-command";
7716 char arguments_1[] = "6";
7717 char *arguments[] = {
7725 r = guestfs_command_lines (g, arguments);
7729 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7734 char expected[] = "";
7735 if (strcmp (r[0], expected) != 0) {
7736 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7741 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7746 char expected[] = "";
7747 if (strcmp (r[1], expected) != 0) {
7748 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7753 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7758 char expected[] = "Result6";
7759 if (strcmp (r[2], expected) != 0) {
7760 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7765 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
7770 char expected[] = "";
7771 if (strcmp (r[3], expected) != 0) {
7772 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
7777 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
7781 for (i = 0; r[i] != NULL; ++i)
7788 static int test_command_lines_6_skip (void)
7792 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
7793 if (str && strcmp (str, "1") == 0) return 1;
7794 str = getenv ("SKIP_TEST_COMMAND_LINES");
7795 if (str && strcmp (str, "1") == 0) return 1;
7799 static int test_command_lines_6 (void)
7801 if (test_command_lines_6_skip ()) {
7802 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
7806 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
7808 char device[] = "/dev/sda";
7809 device[5] = devchar;
7812 r = guestfs_blockdev_setrw (g, device);
7819 r = guestfs_umount_all (g);
7826 r = guestfs_lvm_remove_all (g);
7831 char device[] = "/dev/sda";
7832 device[5] = devchar;
7833 char lines_0[] = ",";
7840 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7845 char fstype[] = "ext2";
7846 char device[] = "/dev/sda1";
7847 device[5] = devchar;
7850 r = guestfs_mkfs (g, fstype, device);
7855 char device[] = "/dev/sda1";
7856 device[5] = devchar;
7857 char mountpoint[] = "/";
7860 r = guestfs_mount (g, device, mountpoint);
7864 /* TestOutputList for command_lines (6) */
7866 char remotefilename[] = "/test-command";
7869 r = guestfs_upload (g, "test-command", remotefilename);
7874 char path[] = "/test-command";
7877 r = guestfs_chmod (g, 493, path);
7882 char arguments_0[] = "/test-command";
7883 char arguments_1[] = "7";
7884 char *arguments[] = {
7892 r = guestfs_command_lines (g, arguments);
7896 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
7900 for (i = 0; r[i] != NULL; ++i)
7907 static int test_command_lines_7_skip (void)
7911 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
7912 if (str && strcmp (str, "1") == 0) return 1;
7913 str = getenv ("SKIP_TEST_COMMAND_LINES");
7914 if (str && strcmp (str, "1") == 0) return 1;
7918 static int test_command_lines_7 (void)
7920 if (test_command_lines_7_skip ()) {
7921 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
7925 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
7927 char device[] = "/dev/sda";
7928 device[5] = devchar;
7931 r = guestfs_blockdev_setrw (g, device);
7938 r = guestfs_umount_all (g);
7945 r = guestfs_lvm_remove_all (g);
7950 char device[] = "/dev/sda";
7951 device[5] = devchar;
7952 char lines_0[] = ",";
7959 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7964 char fstype[] = "ext2";
7965 char device[] = "/dev/sda1";
7966 device[5] = devchar;
7969 r = guestfs_mkfs (g, fstype, device);
7974 char device[] = "/dev/sda1";
7975 device[5] = devchar;
7976 char mountpoint[] = "/";
7979 r = guestfs_mount (g, device, mountpoint);
7983 /* TestOutputList for command_lines (7) */
7985 char remotefilename[] = "/test-command";
7988 r = guestfs_upload (g, "test-command", remotefilename);
7993 char path[] = "/test-command";
7996 r = guestfs_chmod (g, 493, path);
8001 char arguments_0[] = "/test-command";
8002 char arguments_1[] = "8";
8003 char *arguments[] = {
8011 r = guestfs_command_lines (g, arguments);
8015 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8020 char expected[] = "";
8021 if (strcmp (r[0], expected) != 0) {
8022 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8027 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8031 for (i = 0; r[i] != NULL; ++i)
8038 static int test_command_lines_8_skip (void)
8042 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8043 if (str && strcmp (str, "1") == 0) return 1;
8044 str = getenv ("SKIP_TEST_COMMAND_LINES");
8045 if (str && strcmp (str, "1") == 0) return 1;
8049 static int test_command_lines_8 (void)
8051 if (test_command_lines_8_skip ()) {
8052 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8056 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8058 char device[] = "/dev/sda";
8059 device[5] = devchar;
8062 r = guestfs_blockdev_setrw (g, device);
8069 r = guestfs_umount_all (g);
8076 r = guestfs_lvm_remove_all (g);
8081 char device[] = "/dev/sda";
8082 device[5] = devchar;
8083 char lines_0[] = ",";
8090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8095 char fstype[] = "ext2";
8096 char device[] = "/dev/sda1";
8097 device[5] = devchar;
8100 r = guestfs_mkfs (g, fstype, device);
8105 char device[] = "/dev/sda1";
8106 device[5] = devchar;
8107 char mountpoint[] = "/";
8110 r = guestfs_mount (g, device, mountpoint);
8114 /* TestOutputList for command_lines (8) */
8116 char remotefilename[] = "/test-command";
8119 r = guestfs_upload (g, "test-command", remotefilename);
8124 char path[] = "/test-command";
8127 r = guestfs_chmod (g, 493, path);
8132 char arguments_0[] = "/test-command";
8133 char arguments_1[] = "9";
8134 char *arguments[] = {
8142 r = guestfs_command_lines (g, arguments);
8146 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8151 char expected[] = "";
8152 if (strcmp (r[0], expected) != 0) {
8153 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8158 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8163 char expected[] = "";
8164 if (strcmp (r[1], expected) != 0) {
8165 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8170 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8174 for (i = 0; r[i] != NULL; ++i)
8181 static int test_command_lines_9_skip (void)
8185 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8186 if (str && strcmp (str, "1") == 0) return 1;
8187 str = getenv ("SKIP_TEST_COMMAND_LINES");
8188 if (str && strcmp (str, "1") == 0) return 1;
8192 static int test_command_lines_9 (void)
8194 if (test_command_lines_9_skip ()) {
8195 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8199 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8201 char device[] = "/dev/sda";
8202 device[5] = devchar;
8205 r = guestfs_blockdev_setrw (g, device);
8212 r = guestfs_umount_all (g);
8219 r = guestfs_lvm_remove_all (g);
8224 char device[] = "/dev/sda";
8225 device[5] = devchar;
8226 char lines_0[] = ",";
8233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8238 char fstype[] = "ext2";
8239 char device[] = "/dev/sda1";
8240 device[5] = devchar;
8243 r = guestfs_mkfs (g, fstype, device);
8248 char device[] = "/dev/sda1";
8249 device[5] = devchar;
8250 char mountpoint[] = "/";
8253 r = guestfs_mount (g, device, mountpoint);
8257 /* TestOutputList for command_lines (9) */
8259 char remotefilename[] = "/test-command";
8262 r = guestfs_upload (g, "test-command", remotefilename);
8267 char path[] = "/test-command";
8270 r = guestfs_chmod (g, 493, path);
8275 char arguments_0[] = "/test-command";
8276 char arguments_1[] = "10";
8277 char *arguments[] = {
8285 r = guestfs_command_lines (g, arguments);
8289 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8294 char expected[] = "Result10-1";
8295 if (strcmp (r[0], expected) != 0) {
8296 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8301 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8306 char expected[] = "Result10-2";
8307 if (strcmp (r[1], expected) != 0) {
8308 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8313 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8317 for (i = 0; r[i] != NULL; ++i)
8324 static int test_command_lines_10_skip (void)
8328 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8329 if (str && strcmp (str, "1") == 0) return 1;
8330 str = getenv ("SKIP_TEST_COMMAND_LINES");
8331 if (str && strcmp (str, "1") == 0) return 1;
8335 static int test_command_lines_10 (void)
8337 if (test_command_lines_10_skip ()) {
8338 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8342 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8344 char device[] = "/dev/sda";
8345 device[5] = devchar;
8348 r = guestfs_blockdev_setrw (g, device);
8355 r = guestfs_umount_all (g);
8362 r = guestfs_lvm_remove_all (g);
8367 char device[] = "/dev/sda";
8368 device[5] = devchar;
8369 char lines_0[] = ",";
8376 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8381 char fstype[] = "ext2";
8382 char device[] = "/dev/sda1";
8383 device[5] = devchar;
8386 r = guestfs_mkfs (g, fstype, device);
8391 char device[] = "/dev/sda1";
8392 device[5] = devchar;
8393 char mountpoint[] = "/";
8396 r = guestfs_mount (g, device, mountpoint);
8400 /* TestOutputList for command_lines (10) */
8402 char remotefilename[] = "/test-command";
8405 r = guestfs_upload (g, "test-command", remotefilename);
8410 char path[] = "/test-command";
8413 r = guestfs_chmod (g, 493, path);
8418 char arguments_0[] = "/test-command";
8419 char arguments_1[] = "11";
8420 char *arguments[] = {
8428 r = guestfs_command_lines (g, arguments);
8432 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8437 char expected[] = "Result11-1";
8438 if (strcmp (r[0], expected) != 0) {
8439 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8444 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8449 char expected[] = "Result11-2";
8450 if (strcmp (r[1], expected) != 0) {
8451 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8456 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8460 for (i = 0; r[i] != NULL; ++i)
8467 static int test_command_0_skip (void)
8471 str = getenv ("SKIP_TEST_COMMAND_0");
8472 if (str && strcmp (str, "1") == 0) return 1;
8473 str = getenv ("SKIP_TEST_COMMAND");
8474 if (str && strcmp (str, "1") == 0) return 1;
8478 static int test_command_0 (void)
8480 if (test_command_0_skip ()) {
8481 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8485 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8487 char device[] = "/dev/sda";
8488 device[5] = devchar;
8491 r = guestfs_blockdev_setrw (g, device);
8498 r = guestfs_umount_all (g);
8505 r = guestfs_lvm_remove_all (g);
8510 char device[] = "/dev/sda";
8511 device[5] = devchar;
8512 char lines_0[] = ",";
8519 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8524 char fstype[] = "ext2";
8525 char device[] = "/dev/sda1";
8526 device[5] = devchar;
8529 r = guestfs_mkfs (g, fstype, device);
8534 char device[] = "/dev/sda1";
8535 device[5] = devchar;
8536 char mountpoint[] = "/";
8539 r = guestfs_mount (g, device, mountpoint);
8543 /* TestOutput for command (0) */
8544 char expected[] = "Result1";
8546 char remotefilename[] = "/test-command";
8549 r = guestfs_upload (g, "test-command", remotefilename);
8554 char path[] = "/test-command";
8557 r = guestfs_chmod (g, 493, path);
8562 char arguments_0[] = "/test-command";
8563 char arguments_1[] = "1";
8564 char *arguments[] = {
8571 r = guestfs_command (g, arguments);
8574 if (strcmp (r, expected) != 0) {
8575 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8583 static int test_command_1_skip (void)
8587 str = getenv ("SKIP_TEST_COMMAND_1");
8588 if (str && strcmp (str, "1") == 0) return 1;
8589 str = getenv ("SKIP_TEST_COMMAND");
8590 if (str && strcmp (str, "1") == 0) return 1;
8594 static int test_command_1 (void)
8596 if (test_command_1_skip ()) {
8597 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8601 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8603 char device[] = "/dev/sda";
8604 device[5] = devchar;
8607 r = guestfs_blockdev_setrw (g, device);
8614 r = guestfs_umount_all (g);
8621 r = guestfs_lvm_remove_all (g);
8626 char device[] = "/dev/sda";
8627 device[5] = devchar;
8628 char lines_0[] = ",";
8635 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8640 char fstype[] = "ext2";
8641 char device[] = "/dev/sda1";
8642 device[5] = devchar;
8645 r = guestfs_mkfs (g, fstype, device);
8650 char device[] = "/dev/sda1";
8651 device[5] = devchar;
8652 char mountpoint[] = "/";
8655 r = guestfs_mount (g, device, mountpoint);
8659 /* TestOutput for command (1) */
8660 char expected[] = "Result2\n";
8662 char remotefilename[] = "/test-command";
8665 r = guestfs_upload (g, "test-command", remotefilename);
8670 char path[] = "/test-command";
8673 r = guestfs_chmod (g, 493, path);
8678 char arguments_0[] = "/test-command";
8679 char arguments_1[] = "2";
8680 char *arguments[] = {
8687 r = guestfs_command (g, arguments);
8690 if (strcmp (r, expected) != 0) {
8691 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8699 static int test_command_2_skip (void)
8703 str = getenv ("SKIP_TEST_COMMAND_2");
8704 if (str && strcmp (str, "1") == 0) return 1;
8705 str = getenv ("SKIP_TEST_COMMAND");
8706 if (str && strcmp (str, "1") == 0) return 1;
8710 static int test_command_2 (void)
8712 if (test_command_2_skip ()) {
8713 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
8717 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
8719 char device[] = "/dev/sda";
8720 device[5] = devchar;
8723 r = guestfs_blockdev_setrw (g, device);
8730 r = guestfs_umount_all (g);
8737 r = guestfs_lvm_remove_all (g);
8742 char device[] = "/dev/sda";
8743 device[5] = devchar;
8744 char lines_0[] = ",";
8751 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8756 char fstype[] = "ext2";
8757 char device[] = "/dev/sda1";
8758 device[5] = devchar;
8761 r = guestfs_mkfs (g, fstype, device);
8766 char device[] = "/dev/sda1";
8767 device[5] = devchar;
8768 char mountpoint[] = "/";
8771 r = guestfs_mount (g, device, mountpoint);
8775 /* TestOutput for command (2) */
8776 char expected[] = "\nResult3";
8778 char remotefilename[] = "/test-command";
8781 r = guestfs_upload (g, "test-command", remotefilename);
8786 char path[] = "/test-command";
8789 r = guestfs_chmod (g, 493, path);
8794 char arguments_0[] = "/test-command";
8795 char arguments_1[] = "3";
8796 char *arguments[] = {
8803 r = guestfs_command (g, arguments);
8806 if (strcmp (r, expected) != 0) {
8807 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
8815 static int test_command_3_skip (void)
8819 str = getenv ("SKIP_TEST_COMMAND_3");
8820 if (str && strcmp (str, "1") == 0) return 1;
8821 str = getenv ("SKIP_TEST_COMMAND");
8822 if (str && strcmp (str, "1") == 0) return 1;
8826 static int test_command_3 (void)
8828 if (test_command_3_skip ()) {
8829 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
8833 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
8835 char device[] = "/dev/sda";
8836 device[5] = devchar;
8839 r = guestfs_blockdev_setrw (g, device);
8846 r = guestfs_umount_all (g);
8853 r = guestfs_lvm_remove_all (g);
8858 char device[] = "/dev/sda";
8859 device[5] = devchar;
8860 char lines_0[] = ",";
8867 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8872 char fstype[] = "ext2";
8873 char device[] = "/dev/sda1";
8874 device[5] = devchar;
8877 r = guestfs_mkfs (g, fstype, device);
8882 char device[] = "/dev/sda1";
8883 device[5] = devchar;
8884 char mountpoint[] = "/";
8887 r = guestfs_mount (g, device, mountpoint);
8891 /* TestOutput for command (3) */
8892 char expected[] = "\nResult4\n";
8894 char remotefilename[] = "/test-command";
8897 r = guestfs_upload (g, "test-command", remotefilename);
8902 char path[] = "/test-command";
8905 r = guestfs_chmod (g, 493, path);
8910 char arguments_0[] = "/test-command";
8911 char arguments_1[] = "4";
8912 char *arguments[] = {
8919 r = guestfs_command (g, arguments);
8922 if (strcmp (r, expected) != 0) {
8923 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
8931 static int test_command_4_skip (void)
8935 str = getenv ("SKIP_TEST_COMMAND_4");
8936 if (str && strcmp (str, "1") == 0) return 1;
8937 str = getenv ("SKIP_TEST_COMMAND");
8938 if (str && strcmp (str, "1") == 0) return 1;
8942 static int test_command_4 (void)
8944 if (test_command_4_skip ()) {
8945 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
8949 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
8951 char device[] = "/dev/sda";
8952 device[5] = devchar;
8955 r = guestfs_blockdev_setrw (g, device);
8962 r = guestfs_umount_all (g);
8969 r = guestfs_lvm_remove_all (g);
8974 char device[] = "/dev/sda";
8975 device[5] = devchar;
8976 char lines_0[] = ",";
8983 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8988 char fstype[] = "ext2";
8989 char device[] = "/dev/sda1";
8990 device[5] = devchar;
8993 r = guestfs_mkfs (g, fstype, device);
8998 char device[] = "/dev/sda1";
8999 device[5] = devchar;
9000 char mountpoint[] = "/";
9003 r = guestfs_mount (g, device, mountpoint);
9007 /* TestOutput for command (4) */
9008 char expected[] = "\nResult5\n\n";
9010 char remotefilename[] = "/test-command";
9013 r = guestfs_upload (g, "test-command", remotefilename);
9018 char path[] = "/test-command";
9021 r = guestfs_chmod (g, 493, path);
9026 char arguments_0[] = "/test-command";
9027 char arguments_1[] = "5";
9028 char *arguments[] = {
9035 r = guestfs_command (g, arguments);
9038 if (strcmp (r, expected) != 0) {
9039 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9047 static int test_command_5_skip (void)
9051 str = getenv ("SKIP_TEST_COMMAND_5");
9052 if (str && strcmp (str, "1") == 0) return 1;
9053 str = getenv ("SKIP_TEST_COMMAND");
9054 if (str && strcmp (str, "1") == 0) return 1;
9058 static int test_command_5 (void)
9060 if (test_command_5_skip ()) {
9061 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9065 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9067 char device[] = "/dev/sda";
9068 device[5] = devchar;
9071 r = guestfs_blockdev_setrw (g, device);
9078 r = guestfs_umount_all (g);
9085 r = guestfs_lvm_remove_all (g);
9090 char device[] = "/dev/sda";
9091 device[5] = devchar;
9092 char lines_0[] = ",";
9099 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9104 char fstype[] = "ext2";
9105 char device[] = "/dev/sda1";
9106 device[5] = devchar;
9109 r = guestfs_mkfs (g, fstype, device);
9114 char device[] = "/dev/sda1";
9115 device[5] = devchar;
9116 char mountpoint[] = "/";
9119 r = guestfs_mount (g, device, mountpoint);
9123 /* TestOutput for command (5) */
9124 char expected[] = "\n\nResult6\n\n";
9126 char remotefilename[] = "/test-command";
9129 r = guestfs_upload (g, "test-command", remotefilename);
9134 char path[] = "/test-command";
9137 r = guestfs_chmod (g, 493, path);
9142 char arguments_0[] = "/test-command";
9143 char arguments_1[] = "6";
9144 char *arguments[] = {
9151 r = guestfs_command (g, arguments);
9154 if (strcmp (r, expected) != 0) {
9155 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9163 static int test_command_6_skip (void)
9167 str = getenv ("SKIP_TEST_COMMAND_6");
9168 if (str && strcmp (str, "1") == 0) return 1;
9169 str = getenv ("SKIP_TEST_COMMAND");
9170 if (str && strcmp (str, "1") == 0) return 1;
9174 static int test_command_6 (void)
9176 if (test_command_6_skip ()) {
9177 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9181 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9183 char device[] = "/dev/sda";
9184 device[5] = devchar;
9187 r = guestfs_blockdev_setrw (g, device);
9194 r = guestfs_umount_all (g);
9201 r = guestfs_lvm_remove_all (g);
9206 char device[] = "/dev/sda";
9207 device[5] = devchar;
9208 char lines_0[] = ",";
9215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9220 char fstype[] = "ext2";
9221 char device[] = "/dev/sda1";
9222 device[5] = devchar;
9225 r = guestfs_mkfs (g, fstype, device);
9230 char device[] = "/dev/sda1";
9231 device[5] = devchar;
9232 char mountpoint[] = "/";
9235 r = guestfs_mount (g, device, mountpoint);
9239 /* TestOutput for command (6) */
9240 char expected[] = "";
9242 char remotefilename[] = "/test-command";
9245 r = guestfs_upload (g, "test-command", remotefilename);
9250 char path[] = "/test-command";
9253 r = guestfs_chmod (g, 493, path);
9258 char arguments_0[] = "/test-command";
9259 char arguments_1[] = "7";
9260 char *arguments[] = {
9267 r = guestfs_command (g, arguments);
9270 if (strcmp (r, expected) != 0) {
9271 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9279 static int test_command_7_skip (void)
9283 str = getenv ("SKIP_TEST_COMMAND_7");
9284 if (str && strcmp (str, "1") == 0) return 1;
9285 str = getenv ("SKIP_TEST_COMMAND");
9286 if (str && strcmp (str, "1") == 0) return 1;
9290 static int test_command_7 (void)
9292 if (test_command_7_skip ()) {
9293 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9297 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9299 char device[] = "/dev/sda";
9300 device[5] = devchar;
9303 r = guestfs_blockdev_setrw (g, device);
9310 r = guestfs_umount_all (g);
9317 r = guestfs_lvm_remove_all (g);
9322 char device[] = "/dev/sda";
9323 device[5] = devchar;
9324 char lines_0[] = ",";
9331 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9336 char fstype[] = "ext2";
9337 char device[] = "/dev/sda1";
9338 device[5] = devchar;
9341 r = guestfs_mkfs (g, fstype, device);
9346 char device[] = "/dev/sda1";
9347 device[5] = devchar;
9348 char mountpoint[] = "/";
9351 r = guestfs_mount (g, device, mountpoint);
9355 /* TestOutput for command (7) */
9356 char expected[] = "\n";
9358 char remotefilename[] = "/test-command";
9361 r = guestfs_upload (g, "test-command", remotefilename);
9366 char path[] = "/test-command";
9369 r = guestfs_chmod (g, 493, path);
9374 char arguments_0[] = "/test-command";
9375 char arguments_1[] = "8";
9376 char *arguments[] = {
9383 r = guestfs_command (g, arguments);
9386 if (strcmp (r, expected) != 0) {
9387 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9395 static int test_command_8_skip (void)
9399 str = getenv ("SKIP_TEST_COMMAND_8");
9400 if (str && strcmp (str, "1") == 0) return 1;
9401 str = getenv ("SKIP_TEST_COMMAND");
9402 if (str && strcmp (str, "1") == 0) return 1;
9406 static int test_command_8 (void)
9408 if (test_command_8_skip ()) {
9409 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9413 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9415 char device[] = "/dev/sda";
9416 device[5] = devchar;
9419 r = guestfs_blockdev_setrw (g, device);
9426 r = guestfs_umount_all (g);
9433 r = guestfs_lvm_remove_all (g);
9438 char device[] = "/dev/sda";
9439 device[5] = devchar;
9440 char lines_0[] = ",";
9447 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9452 char fstype[] = "ext2";
9453 char device[] = "/dev/sda1";
9454 device[5] = devchar;
9457 r = guestfs_mkfs (g, fstype, device);
9462 char device[] = "/dev/sda1";
9463 device[5] = devchar;
9464 char mountpoint[] = "/";
9467 r = guestfs_mount (g, device, mountpoint);
9471 /* TestOutput for command (8) */
9472 char expected[] = "\n\n";
9474 char remotefilename[] = "/test-command";
9477 r = guestfs_upload (g, "test-command", remotefilename);
9482 char path[] = "/test-command";
9485 r = guestfs_chmod (g, 493, path);
9490 char arguments_0[] = "/test-command";
9491 char arguments_1[] = "9";
9492 char *arguments[] = {
9499 r = guestfs_command (g, arguments);
9502 if (strcmp (r, expected) != 0) {
9503 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9511 static int test_command_9_skip (void)
9515 str = getenv ("SKIP_TEST_COMMAND_9");
9516 if (str && strcmp (str, "1") == 0) return 1;
9517 str = getenv ("SKIP_TEST_COMMAND");
9518 if (str && strcmp (str, "1") == 0) return 1;
9522 static int test_command_9 (void)
9524 if (test_command_9_skip ()) {
9525 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9529 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9531 char device[] = "/dev/sda";
9532 device[5] = devchar;
9535 r = guestfs_blockdev_setrw (g, device);
9542 r = guestfs_umount_all (g);
9549 r = guestfs_lvm_remove_all (g);
9554 char device[] = "/dev/sda";
9555 device[5] = devchar;
9556 char lines_0[] = ",";
9563 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9568 char fstype[] = "ext2";
9569 char device[] = "/dev/sda1";
9570 device[5] = devchar;
9573 r = guestfs_mkfs (g, fstype, device);
9578 char device[] = "/dev/sda1";
9579 device[5] = devchar;
9580 char mountpoint[] = "/";
9583 r = guestfs_mount (g, device, mountpoint);
9587 /* TestOutput for command (9) */
9588 char expected[] = "Result10-1\nResult10-2\n";
9590 char remotefilename[] = "/test-command";
9593 r = guestfs_upload (g, "test-command", remotefilename);
9598 char path[] = "/test-command";
9601 r = guestfs_chmod (g, 493, path);
9606 char arguments_0[] = "/test-command";
9607 char arguments_1[] = "10";
9608 char *arguments[] = {
9615 r = guestfs_command (g, arguments);
9618 if (strcmp (r, expected) != 0) {
9619 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9627 static int test_command_10_skip (void)
9631 str = getenv ("SKIP_TEST_COMMAND_10");
9632 if (str && strcmp (str, "1") == 0) return 1;
9633 str = getenv ("SKIP_TEST_COMMAND");
9634 if (str && strcmp (str, "1") == 0) return 1;
9638 static int test_command_10 (void)
9640 if (test_command_10_skip ()) {
9641 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9645 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9647 char device[] = "/dev/sda";
9648 device[5] = devchar;
9651 r = guestfs_blockdev_setrw (g, device);
9658 r = guestfs_umount_all (g);
9665 r = guestfs_lvm_remove_all (g);
9670 char device[] = "/dev/sda";
9671 device[5] = devchar;
9672 char lines_0[] = ",";
9679 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9684 char fstype[] = "ext2";
9685 char device[] = "/dev/sda1";
9686 device[5] = devchar;
9689 r = guestfs_mkfs (g, fstype, device);
9694 char device[] = "/dev/sda1";
9695 device[5] = devchar;
9696 char mountpoint[] = "/";
9699 r = guestfs_mount (g, device, mountpoint);
9703 /* TestOutput for command (10) */
9704 char expected[] = "Result11-1\nResult11-2";
9706 char remotefilename[] = "/test-command";
9709 r = guestfs_upload (g, "test-command", remotefilename);
9714 char path[] = "/test-command";
9717 r = guestfs_chmod (g, 493, path);
9722 char arguments_0[] = "/test-command";
9723 char arguments_1[] = "11";
9724 char *arguments[] = {
9731 r = guestfs_command (g, arguments);
9734 if (strcmp (r, expected) != 0) {
9735 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
9743 static int test_command_11_skip (void)
9747 str = getenv ("SKIP_TEST_COMMAND_11");
9748 if (str && strcmp (str, "1") == 0) return 1;
9749 str = getenv ("SKIP_TEST_COMMAND");
9750 if (str && strcmp (str, "1") == 0) return 1;
9754 static int test_command_11 (void)
9756 if (test_command_11_skip ()) {
9757 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
9761 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
9763 char device[] = "/dev/sda";
9764 device[5] = devchar;
9767 r = guestfs_blockdev_setrw (g, device);
9774 r = guestfs_umount_all (g);
9781 r = guestfs_lvm_remove_all (g);
9786 char device[] = "/dev/sda";
9787 device[5] = devchar;
9788 char lines_0[] = ",";
9795 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9800 char fstype[] = "ext2";
9801 char device[] = "/dev/sda1";
9802 device[5] = devchar;
9805 r = guestfs_mkfs (g, fstype, device);
9810 char device[] = "/dev/sda1";
9811 device[5] = devchar;
9812 char mountpoint[] = "/";
9815 r = guestfs_mount (g, device, mountpoint);
9819 /* TestLastFail for command (11) */
9821 char remotefilename[] = "/test-command";
9824 r = guestfs_upload (g, "test-command", remotefilename);
9829 char path[] = "/test-command";
9832 r = guestfs_chmod (g, 493, path);
9837 char arguments_0[] = "/test-command";
9838 char *arguments[] = {
9844 r = guestfs_command (g, arguments);
9852 static int test_file_0_skip (void)
9856 str = getenv ("SKIP_TEST_FILE_0");
9857 if (str && strcmp (str, "1") == 0) return 1;
9858 str = getenv ("SKIP_TEST_FILE");
9859 if (str && strcmp (str, "1") == 0) return 1;
9863 static int test_file_0 (void)
9865 if (test_file_0_skip ()) {
9866 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
9870 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
9872 char device[] = "/dev/sda";
9873 device[5] = devchar;
9876 r = guestfs_blockdev_setrw (g, device);
9883 r = guestfs_umount_all (g);
9890 r = guestfs_lvm_remove_all (g);
9895 char device[] = "/dev/sda";
9896 device[5] = devchar;
9897 char lines_0[] = ",";
9904 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9909 char fstype[] = "ext2";
9910 char device[] = "/dev/sda1";
9911 device[5] = devchar;
9914 r = guestfs_mkfs (g, fstype, device);
9919 char device[] = "/dev/sda1";
9920 device[5] = devchar;
9921 char mountpoint[] = "/";
9924 r = guestfs_mount (g, device, mountpoint);
9928 /* TestOutput for file (0) */
9929 char expected[] = "empty";
9931 char path[] = "/new";
9934 r = guestfs_touch (g, path);
9939 char path[] = "/new";
9942 r = guestfs_file (g, path);
9945 if (strcmp (r, expected) != 0) {
9946 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
9954 static int test_file_1_skip (void)
9958 str = getenv ("SKIP_TEST_FILE_1");
9959 if (str && strcmp (str, "1") == 0) return 1;
9960 str = getenv ("SKIP_TEST_FILE");
9961 if (str && strcmp (str, "1") == 0) return 1;
9965 static int test_file_1 (void)
9967 if (test_file_1_skip ()) {
9968 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
9972 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
9974 char device[] = "/dev/sda";
9975 device[5] = devchar;
9978 r = guestfs_blockdev_setrw (g, device);
9985 r = guestfs_umount_all (g);
9992 r = guestfs_lvm_remove_all (g);
9997 char device[] = "/dev/sda";
9998 device[5] = devchar;
9999 char lines_0[] = ",";
10005 suppress_error = 0;
10006 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10011 char fstype[] = "ext2";
10012 char device[] = "/dev/sda1";
10013 device[5] = devchar;
10015 suppress_error = 0;
10016 r = guestfs_mkfs (g, fstype, device);
10021 char device[] = "/dev/sda1";
10022 device[5] = devchar;
10023 char mountpoint[] = "/";
10025 suppress_error = 0;
10026 r = guestfs_mount (g, device, mountpoint);
10030 /* TestOutput for file (1) */
10031 char expected[] = "ASCII text";
10033 char path[] = "/new";
10034 char content[] = "some content\n";
10036 suppress_error = 0;
10037 r = guestfs_write_file (g, path, content, 0);
10042 char path[] = "/new";
10044 suppress_error = 0;
10045 r = guestfs_file (g, path);
10048 if (strcmp (r, expected) != 0) {
10049 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10057 static int test_file_2_skip (void)
10061 str = getenv ("SKIP_TEST_FILE_2");
10062 if (str && strcmp (str, "1") == 0) return 1;
10063 str = getenv ("SKIP_TEST_FILE");
10064 if (str && strcmp (str, "1") == 0) return 1;
10068 static int test_file_2 (void)
10070 if (test_file_2_skip ()) {
10071 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10075 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10077 char device[] = "/dev/sda";
10078 device[5] = devchar;
10080 suppress_error = 0;
10081 r = guestfs_blockdev_setrw (g, device);
10087 suppress_error = 0;
10088 r = guestfs_umount_all (g);
10094 suppress_error = 0;
10095 r = guestfs_lvm_remove_all (g);
10100 char device[] = "/dev/sda";
10101 device[5] = devchar;
10102 char lines_0[] = ",";
10108 suppress_error = 0;
10109 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10114 char fstype[] = "ext2";
10115 char device[] = "/dev/sda1";
10116 device[5] = devchar;
10118 suppress_error = 0;
10119 r = guestfs_mkfs (g, fstype, device);
10124 char device[] = "/dev/sda1";
10125 device[5] = devchar;
10126 char mountpoint[] = "/";
10128 suppress_error = 0;
10129 r = guestfs_mount (g, device, mountpoint);
10133 /* TestLastFail for file (2) */
10135 char path[] = "/nofile";
10137 suppress_error = 1;
10138 r = guestfs_file (g, path);
10146 static int test_umount_all_0_skip (void)
10150 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10151 if (str && strcmp (str, "1") == 0) return 1;
10152 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10153 if (str && strcmp (str, "1") == 0) return 1;
10157 static int test_umount_all_0 (void)
10159 if (test_umount_all_0_skip ()) {
10160 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10164 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10166 char device[] = "/dev/sda";
10167 device[5] = devchar;
10169 suppress_error = 0;
10170 r = guestfs_blockdev_setrw (g, device);
10176 suppress_error = 0;
10177 r = guestfs_umount_all (g);
10183 suppress_error = 0;
10184 r = guestfs_lvm_remove_all (g);
10189 char device[] = "/dev/sda";
10190 device[5] = devchar;
10191 char lines_0[] = ",";
10197 suppress_error = 0;
10198 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10203 char fstype[] = "ext2";
10204 char device[] = "/dev/sda1";
10205 device[5] = devchar;
10207 suppress_error = 0;
10208 r = guestfs_mkfs (g, fstype, device);
10213 char device[] = "/dev/sda1";
10214 device[5] = devchar;
10215 char mountpoint[] = "/";
10217 suppress_error = 0;
10218 r = guestfs_mount (g, device, mountpoint);
10222 /* TestOutputList for umount_all (0) */
10225 suppress_error = 0;
10226 r = guestfs_umount_all (g);
10233 suppress_error = 0;
10234 r = guestfs_mounts (g);
10237 if (r[0] != NULL) {
10238 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10242 for (i = 0; r[i] != NULL; ++i)
10249 static int test_umount_all_1_skip (void)
10253 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10254 if (str && strcmp (str, "1") == 0) return 1;
10255 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10256 if (str && strcmp (str, "1") == 0) return 1;
10260 static int test_umount_all_1 (void)
10262 if (test_umount_all_1_skip ()) {
10263 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10267 /* InitNone|InitEmpty for test_umount_all_1 */
10269 char device[] = "/dev/sda";
10270 device[5] = devchar;
10272 suppress_error = 0;
10273 r = guestfs_blockdev_setrw (g, device);
10279 suppress_error = 0;
10280 r = guestfs_umount_all (g);
10286 suppress_error = 0;
10287 r = guestfs_lvm_remove_all (g);
10291 /* TestOutputList for umount_all (1) */
10293 char device[] = "/dev/sda";
10294 device[5] = devchar;
10295 char lines_0[] = ",10";
10296 char lines_1[] = ",20";
10297 char lines_2[] = ",";
10305 suppress_error = 0;
10306 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10311 char fstype[] = "ext2";
10312 char device[] = "/dev/sda1";
10313 device[5] = devchar;
10315 suppress_error = 0;
10316 r = guestfs_mkfs (g, fstype, device);
10321 char fstype[] = "ext2";
10322 char device[] = "/dev/sda2";
10323 device[5] = devchar;
10325 suppress_error = 0;
10326 r = guestfs_mkfs (g, fstype, device);
10331 char fstype[] = "ext2";
10332 char device[] = "/dev/sda3";
10333 device[5] = devchar;
10335 suppress_error = 0;
10336 r = guestfs_mkfs (g, fstype, device);
10341 char device[] = "/dev/sda1";
10342 device[5] = devchar;
10343 char mountpoint[] = "/";
10345 suppress_error = 0;
10346 r = guestfs_mount (g, device, mountpoint);
10351 char path[] = "/mp1";
10353 suppress_error = 0;
10354 r = guestfs_mkdir (g, path);
10359 char device[] = "/dev/sda2";
10360 device[5] = devchar;
10361 char mountpoint[] = "/mp1";
10363 suppress_error = 0;
10364 r = guestfs_mount (g, device, mountpoint);
10369 char path[] = "/mp1/mp2";
10371 suppress_error = 0;
10372 r = guestfs_mkdir (g, path);
10377 char device[] = "/dev/sda3";
10378 device[5] = devchar;
10379 char mountpoint[] = "/mp1/mp2";
10381 suppress_error = 0;
10382 r = guestfs_mount (g, device, mountpoint);
10387 char path[] = "/mp1/mp2/mp3";
10389 suppress_error = 0;
10390 r = guestfs_mkdir (g, path);
10396 suppress_error = 0;
10397 r = guestfs_umount_all (g);
10404 suppress_error = 0;
10405 r = guestfs_mounts (g);
10408 if (r[0] != NULL) {
10409 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10413 for (i = 0; r[i] != NULL; ++i)
10420 static int test_mounts_0_skip (void)
10424 str = getenv ("SKIP_TEST_MOUNTS_0");
10425 if (str && strcmp (str, "1") == 0) return 1;
10426 str = getenv ("SKIP_TEST_MOUNTS");
10427 if (str && strcmp (str, "1") == 0) return 1;
10431 static int test_mounts_0 (void)
10433 if (test_mounts_0_skip ()) {
10434 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10438 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10440 char device[] = "/dev/sda";
10441 device[5] = devchar;
10443 suppress_error = 0;
10444 r = guestfs_blockdev_setrw (g, device);
10450 suppress_error = 0;
10451 r = guestfs_umount_all (g);
10457 suppress_error = 0;
10458 r = guestfs_lvm_remove_all (g);
10463 char device[] = "/dev/sda";
10464 device[5] = devchar;
10465 char lines_0[] = ",";
10471 suppress_error = 0;
10472 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10477 char fstype[] = "ext2";
10478 char device[] = "/dev/sda1";
10479 device[5] = devchar;
10481 suppress_error = 0;
10482 r = guestfs_mkfs (g, fstype, device);
10487 char device[] = "/dev/sda1";
10488 device[5] = devchar;
10489 char mountpoint[] = "/";
10491 suppress_error = 0;
10492 r = guestfs_mount (g, device, mountpoint);
10496 /* TestOutputList for mounts (0) */
10500 suppress_error = 0;
10501 r = guestfs_mounts (g);
10505 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10510 char expected[] = "/dev/sda1";
10511 expected[5] = devchar;
10512 if (strcmp (r[0], expected) != 0) {
10513 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10517 if (r[1] != NULL) {
10518 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10522 for (i = 0; r[i] != NULL; ++i)
10529 static int test_umount_0_skip (void)
10533 str = getenv ("SKIP_TEST_UMOUNT_0");
10534 if (str && strcmp (str, "1") == 0) return 1;
10535 str = getenv ("SKIP_TEST_UMOUNT");
10536 if (str && strcmp (str, "1") == 0) return 1;
10540 static int test_umount_0 (void)
10542 if (test_umount_0_skip ()) {
10543 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10547 /* InitNone|InitEmpty for test_umount_0 */
10549 char device[] = "/dev/sda";
10550 device[5] = devchar;
10552 suppress_error = 0;
10553 r = guestfs_blockdev_setrw (g, device);
10559 suppress_error = 0;
10560 r = guestfs_umount_all (g);
10566 suppress_error = 0;
10567 r = guestfs_lvm_remove_all (g);
10571 /* TestOutputList for umount (0) */
10573 char device[] = "/dev/sda";
10574 device[5] = devchar;
10575 char lines_0[] = ",";
10581 suppress_error = 0;
10582 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10587 char fstype[] = "ext2";
10588 char device[] = "/dev/sda1";
10589 device[5] = devchar;
10591 suppress_error = 0;
10592 r = guestfs_mkfs (g, fstype, device);
10597 char device[] = "/dev/sda1";
10598 device[5] = devchar;
10599 char mountpoint[] = "/";
10601 suppress_error = 0;
10602 r = guestfs_mount (g, device, mountpoint);
10609 suppress_error = 0;
10610 r = guestfs_mounts (g);
10614 fprintf (stderr, "test_umount_0: short list returned from command\n");
10619 char expected[] = "/dev/sda1";
10620 expected[5] = devchar;
10621 if (strcmp (r[0], expected) != 0) {
10622 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10626 if (r[1] != NULL) {
10627 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10631 for (i = 0; r[i] != NULL; ++i)
10638 static int test_umount_1_skip (void)
10642 str = getenv ("SKIP_TEST_UMOUNT_1");
10643 if (str && strcmp (str, "1") == 0) return 1;
10644 str = getenv ("SKIP_TEST_UMOUNT");
10645 if (str && strcmp (str, "1") == 0) return 1;
10649 static int test_umount_1 (void)
10651 if (test_umount_1_skip ()) {
10652 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10656 /* InitNone|InitEmpty for test_umount_1 */
10658 char device[] = "/dev/sda";
10659 device[5] = devchar;
10661 suppress_error = 0;
10662 r = guestfs_blockdev_setrw (g, device);
10668 suppress_error = 0;
10669 r = guestfs_umount_all (g);
10675 suppress_error = 0;
10676 r = guestfs_lvm_remove_all (g);
10680 /* TestOutputList for umount (1) */
10682 char device[] = "/dev/sda";
10683 device[5] = devchar;
10684 char lines_0[] = ",";
10690 suppress_error = 0;
10691 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10696 char fstype[] = "ext2";
10697 char device[] = "/dev/sda1";
10698 device[5] = devchar;
10700 suppress_error = 0;
10701 r = guestfs_mkfs (g, fstype, device);
10706 char device[] = "/dev/sda1";
10707 device[5] = devchar;
10708 char mountpoint[] = "/";
10710 suppress_error = 0;
10711 r = guestfs_mount (g, device, mountpoint);
10716 char pathordevice[] = "/";
10718 suppress_error = 0;
10719 r = guestfs_umount (g, pathordevice);
10726 suppress_error = 0;
10727 r = guestfs_mounts (g);
10730 if (r[0] != NULL) {
10731 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10735 for (i = 0; r[i] != NULL; ++i)
10742 static int test_write_file_0_skip (void)
10746 str = getenv ("SKIP_TEST_WRITE_FILE_0");
10747 if (str && strcmp (str, "1") == 0) return 1;
10748 str = getenv ("SKIP_TEST_WRITE_FILE");
10749 if (str && strcmp (str, "1") == 0) return 1;
10753 static int test_write_file_0 (void)
10755 if (test_write_file_0_skip ()) {
10756 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10760 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10762 char device[] = "/dev/sda";
10763 device[5] = devchar;
10765 suppress_error = 0;
10766 r = guestfs_blockdev_setrw (g, device);
10772 suppress_error = 0;
10773 r = guestfs_umount_all (g);
10779 suppress_error = 0;
10780 r = guestfs_lvm_remove_all (g);
10785 char device[] = "/dev/sda";
10786 device[5] = devchar;
10787 char lines_0[] = ",";
10793 suppress_error = 0;
10794 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10799 char fstype[] = "ext2";
10800 char device[] = "/dev/sda1";
10801 device[5] = devchar;
10803 suppress_error = 0;
10804 r = guestfs_mkfs (g, fstype, device);
10809 char device[] = "/dev/sda1";
10810 device[5] = devchar;
10811 char mountpoint[] = "/";
10813 suppress_error = 0;
10814 r = guestfs_mount (g, device, mountpoint);
10818 /* TestOutput for write_file (0) */
10819 char expected[] = "new file contents";
10821 char path[] = "/new";
10822 char content[] = "new file contents";
10824 suppress_error = 0;
10825 r = guestfs_write_file (g, path, content, 0);
10830 char path[] = "/new";
10832 suppress_error = 0;
10833 r = guestfs_cat (g, path);
10836 if (strcmp (r, expected) != 0) {
10837 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10845 static int test_write_file_1_skip (void)
10849 str = getenv ("SKIP_TEST_WRITE_FILE_1");
10850 if (str && strcmp (str, "1") == 0) return 1;
10851 str = getenv ("SKIP_TEST_WRITE_FILE");
10852 if (str && strcmp (str, "1") == 0) return 1;
10856 static int test_write_file_1 (void)
10858 if (test_write_file_1_skip ()) {
10859 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
10863 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
10865 char device[] = "/dev/sda";
10866 device[5] = devchar;
10868 suppress_error = 0;
10869 r = guestfs_blockdev_setrw (g, device);
10875 suppress_error = 0;
10876 r = guestfs_umount_all (g);
10882 suppress_error = 0;
10883 r = guestfs_lvm_remove_all (g);
10888 char device[] = "/dev/sda";
10889 device[5] = devchar;
10890 char lines_0[] = ",";
10896 suppress_error = 0;
10897 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10902 char fstype[] = "ext2";
10903 char device[] = "/dev/sda1";
10904 device[5] = devchar;
10906 suppress_error = 0;
10907 r = guestfs_mkfs (g, fstype, device);
10912 char device[] = "/dev/sda1";
10913 device[5] = devchar;
10914 char mountpoint[] = "/";
10916 suppress_error = 0;
10917 r = guestfs_mount (g, device, mountpoint);
10921 /* TestOutput for write_file (1) */
10922 char expected[] = "\nnew file contents\n";
10924 char path[] = "/new";
10925 char content[] = "\nnew file contents\n";
10927 suppress_error = 0;
10928 r = guestfs_write_file (g, path, content, 0);
10933 char path[] = "/new";
10935 suppress_error = 0;
10936 r = guestfs_cat (g, path);
10939 if (strcmp (r, expected) != 0) {
10940 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10948 static int test_write_file_2_skip (void)
10952 str = getenv ("SKIP_TEST_WRITE_FILE_2");
10953 if (str && strcmp (str, "1") == 0) return 1;
10954 str = getenv ("SKIP_TEST_WRITE_FILE");
10955 if (str && strcmp (str, "1") == 0) return 1;
10959 static int test_write_file_2 (void)
10961 if (test_write_file_2_skip ()) {
10962 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
10966 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
10968 char device[] = "/dev/sda";
10969 device[5] = devchar;
10971 suppress_error = 0;
10972 r = guestfs_blockdev_setrw (g, device);
10978 suppress_error = 0;
10979 r = guestfs_umount_all (g);
10985 suppress_error = 0;
10986 r = guestfs_lvm_remove_all (g);
10991 char device[] = "/dev/sda";
10992 device[5] = devchar;
10993 char lines_0[] = ",";
10999 suppress_error = 0;
11000 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11005 char fstype[] = "ext2";
11006 char device[] = "/dev/sda1";
11007 device[5] = devchar;
11009 suppress_error = 0;
11010 r = guestfs_mkfs (g, fstype, device);
11015 char device[] = "/dev/sda1";
11016 device[5] = devchar;
11017 char mountpoint[] = "/";
11019 suppress_error = 0;
11020 r = guestfs_mount (g, device, mountpoint);
11024 /* TestOutput for write_file (2) */
11025 char expected[] = "\n\n";
11027 char path[] = "/new";
11028 char content[] = "\n\n";
11030 suppress_error = 0;
11031 r = guestfs_write_file (g, path, content, 0);
11036 char path[] = "/new";
11038 suppress_error = 0;
11039 r = guestfs_cat (g, path);
11042 if (strcmp (r, expected) != 0) {
11043 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11051 static int test_write_file_3_skip (void)
11055 str = getenv ("SKIP_TEST_WRITE_FILE_3");
11056 if (str && strcmp (str, "1") == 0) return 1;
11057 str = getenv ("SKIP_TEST_WRITE_FILE");
11058 if (str && strcmp (str, "1") == 0) return 1;
11062 static int test_write_file_3 (void)
11064 if (test_write_file_3_skip ()) {
11065 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11069 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11071 char device[] = "/dev/sda";
11072 device[5] = devchar;
11074 suppress_error = 0;
11075 r = guestfs_blockdev_setrw (g, device);
11081 suppress_error = 0;
11082 r = guestfs_umount_all (g);
11088 suppress_error = 0;
11089 r = guestfs_lvm_remove_all (g);
11094 char device[] = "/dev/sda";
11095 device[5] = devchar;
11096 char lines_0[] = ",";
11102 suppress_error = 0;
11103 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11108 char fstype[] = "ext2";
11109 char device[] = "/dev/sda1";
11110 device[5] = devchar;
11112 suppress_error = 0;
11113 r = guestfs_mkfs (g, fstype, device);
11118 char device[] = "/dev/sda1";
11119 device[5] = devchar;
11120 char mountpoint[] = "/";
11122 suppress_error = 0;
11123 r = guestfs_mount (g, device, mountpoint);
11127 /* TestOutput for write_file (3) */
11128 char expected[] = "";
11130 char path[] = "/new";
11131 char content[] = "";
11133 suppress_error = 0;
11134 r = guestfs_write_file (g, path, content, 0);
11139 char path[] = "/new";
11141 suppress_error = 0;
11142 r = guestfs_cat (g, path);
11145 if (strcmp (r, expected) != 0) {
11146 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11154 static int test_write_file_4_skip (void)
11158 str = getenv ("SKIP_TEST_WRITE_FILE_4");
11159 if (str && strcmp (str, "1") == 0) return 1;
11160 str = getenv ("SKIP_TEST_WRITE_FILE");
11161 if (str && strcmp (str, "1") == 0) return 1;
11165 static int test_write_file_4 (void)
11167 if (test_write_file_4_skip ()) {
11168 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11172 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11174 char device[] = "/dev/sda";
11175 device[5] = devchar;
11177 suppress_error = 0;
11178 r = guestfs_blockdev_setrw (g, device);
11184 suppress_error = 0;
11185 r = guestfs_umount_all (g);
11191 suppress_error = 0;
11192 r = guestfs_lvm_remove_all (g);
11197 char device[] = "/dev/sda";
11198 device[5] = devchar;
11199 char lines_0[] = ",";
11205 suppress_error = 0;
11206 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11211 char fstype[] = "ext2";
11212 char device[] = "/dev/sda1";
11213 device[5] = devchar;
11215 suppress_error = 0;
11216 r = guestfs_mkfs (g, fstype, device);
11221 char device[] = "/dev/sda1";
11222 device[5] = devchar;
11223 char mountpoint[] = "/";
11225 suppress_error = 0;
11226 r = guestfs_mount (g, device, mountpoint);
11230 /* TestOutput for write_file (4) */
11231 char expected[] = "\n\n\n";
11233 char path[] = "/new";
11234 char content[] = "\n\n\n";
11236 suppress_error = 0;
11237 r = guestfs_write_file (g, path, content, 0);
11242 char path[] = "/new";
11244 suppress_error = 0;
11245 r = guestfs_cat (g, path);
11248 if (strcmp (r, expected) != 0) {
11249 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11257 static int test_write_file_5_skip (void)
11261 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11262 if (str && strcmp (str, "1") == 0) return 1;
11263 str = getenv ("SKIP_TEST_WRITE_FILE");
11264 if (str && strcmp (str, "1") == 0) return 1;
11268 static int test_write_file_5 (void)
11270 if (test_write_file_5_skip ()) {
11271 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11275 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11277 char device[] = "/dev/sda";
11278 device[5] = devchar;
11280 suppress_error = 0;
11281 r = guestfs_blockdev_setrw (g, device);
11287 suppress_error = 0;
11288 r = guestfs_umount_all (g);
11294 suppress_error = 0;
11295 r = guestfs_lvm_remove_all (g);
11300 char device[] = "/dev/sda";
11301 device[5] = devchar;
11302 char lines_0[] = ",";
11308 suppress_error = 0;
11309 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11314 char fstype[] = "ext2";
11315 char device[] = "/dev/sda1";
11316 device[5] = devchar;
11318 suppress_error = 0;
11319 r = guestfs_mkfs (g, fstype, device);
11324 char device[] = "/dev/sda1";
11325 device[5] = devchar;
11326 char mountpoint[] = "/";
11328 suppress_error = 0;
11329 r = guestfs_mount (g, device, mountpoint);
11333 /* TestOutput for write_file (5) */
11334 char expected[] = "\n";
11336 char path[] = "/new";
11337 char content[] = "\n";
11339 suppress_error = 0;
11340 r = guestfs_write_file (g, path, content, 0);
11345 char path[] = "/new";
11347 suppress_error = 0;
11348 r = guestfs_cat (g, path);
11351 if (strcmp (r, expected) != 0) {
11352 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11360 static int test_mkfs_0_skip (void)
11364 str = getenv ("SKIP_TEST_MKFS_0");
11365 if (str && strcmp (str, "1") == 0) return 1;
11366 str = getenv ("SKIP_TEST_MKFS");
11367 if (str && strcmp (str, "1") == 0) return 1;
11371 static int test_mkfs_0 (void)
11373 if (test_mkfs_0_skip ()) {
11374 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11378 /* InitNone|InitEmpty for test_mkfs_0 */
11380 char device[] = "/dev/sda";
11381 device[5] = devchar;
11383 suppress_error = 0;
11384 r = guestfs_blockdev_setrw (g, device);
11390 suppress_error = 0;
11391 r = guestfs_umount_all (g);
11397 suppress_error = 0;
11398 r = guestfs_lvm_remove_all (g);
11402 /* TestOutput for mkfs (0) */
11403 char expected[] = "new file contents";
11405 char device[] = "/dev/sda";
11406 device[5] = devchar;
11407 char lines_0[] = ",";
11413 suppress_error = 0;
11414 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11419 char fstype[] = "ext2";
11420 char device[] = "/dev/sda1";
11421 device[5] = devchar;
11423 suppress_error = 0;
11424 r = guestfs_mkfs (g, fstype, device);
11429 char device[] = "/dev/sda1";
11430 device[5] = devchar;
11431 char mountpoint[] = "/";
11433 suppress_error = 0;
11434 r = guestfs_mount (g, device, mountpoint);
11439 char path[] = "/new";
11440 char content[] = "new file contents";
11442 suppress_error = 0;
11443 r = guestfs_write_file (g, path, content, 0);
11448 char path[] = "/new";
11450 suppress_error = 0;
11451 r = guestfs_cat (g, path);
11454 if (strcmp (r, expected) != 0) {
11455 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11463 static int test_lvcreate_0_skip (void)
11467 str = getenv ("SKIP_TEST_LVCREATE_0");
11468 if (str && strcmp (str, "1") == 0) return 1;
11469 str = getenv ("SKIP_TEST_LVCREATE");
11470 if (str && strcmp (str, "1") == 0) return 1;
11474 static int test_lvcreate_0 (void)
11476 if (test_lvcreate_0_skip ()) {
11477 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11481 /* InitNone|InitEmpty for test_lvcreate_0 */
11483 char device[] = "/dev/sda";
11484 device[5] = devchar;
11486 suppress_error = 0;
11487 r = guestfs_blockdev_setrw (g, device);
11493 suppress_error = 0;
11494 r = guestfs_umount_all (g);
11500 suppress_error = 0;
11501 r = guestfs_lvm_remove_all (g);
11505 /* TestOutputList for lvcreate (0) */
11507 char device[] = "/dev/sda";
11508 device[5] = devchar;
11509 char lines_0[] = ",10";
11510 char lines_1[] = ",20";
11511 char lines_2[] = ",";
11519 suppress_error = 0;
11520 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11525 char device[] = "/dev/sda1";
11526 device[5] = devchar;
11528 suppress_error = 0;
11529 r = guestfs_pvcreate (g, device);
11534 char device[] = "/dev/sda2";
11535 device[5] = devchar;
11537 suppress_error = 0;
11538 r = guestfs_pvcreate (g, device);
11543 char device[] = "/dev/sda3";
11544 device[5] = devchar;
11546 suppress_error = 0;
11547 r = guestfs_pvcreate (g, device);
11552 char volgroup[] = "VG1";
11553 char physvols_0[] = "/dev/sda1";
11554 physvols_0[5] = devchar;
11555 char physvols_1[] = "/dev/sda2";
11556 physvols_1[5] = devchar;
11557 char *physvols[] = {
11563 suppress_error = 0;
11564 r = guestfs_vgcreate (g, volgroup, physvols);
11569 char volgroup[] = "VG2";
11570 char physvols_0[] = "/dev/sda3";
11571 physvols_0[5] = devchar;
11572 char *physvols[] = {
11577 suppress_error = 0;
11578 r = guestfs_vgcreate (g, volgroup, physvols);
11583 char logvol[] = "LV1";
11584 char volgroup[] = "VG1";
11586 suppress_error = 0;
11587 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11592 char logvol[] = "LV2";
11593 char volgroup[] = "VG1";
11595 suppress_error = 0;
11596 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11601 char logvol[] = "LV3";
11602 char volgroup[] = "VG2";
11604 suppress_error = 0;
11605 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11610 char logvol[] = "LV4";
11611 char volgroup[] = "VG2";
11613 suppress_error = 0;
11614 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11619 char logvol[] = "LV5";
11620 char volgroup[] = "VG2";
11622 suppress_error = 0;
11623 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11630 suppress_error = 0;
11631 r = guestfs_lvs (g);
11635 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11640 char expected[] = "/dev/VG1/LV1";
11641 if (strcmp (r[0], expected) != 0) {
11642 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11647 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11652 char expected[] = "/dev/VG1/LV2";
11653 if (strcmp (r[1], expected) != 0) {
11654 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11659 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11664 char expected[] = "/dev/VG2/LV3";
11665 if (strcmp (r[2], expected) != 0) {
11666 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11671 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11676 char expected[] = "/dev/VG2/LV4";
11677 if (strcmp (r[3], expected) != 0) {
11678 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11683 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11688 char expected[] = "/dev/VG2/LV5";
11689 if (strcmp (r[4], expected) != 0) {
11690 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11694 if (r[5] != NULL) {
11695 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11699 for (i = 0; r[i] != NULL; ++i)
11706 static int test_vgcreate_0_skip (void)
11710 str = getenv ("SKIP_TEST_VGCREATE_0");
11711 if (str && strcmp (str, "1") == 0) return 1;
11712 str = getenv ("SKIP_TEST_VGCREATE");
11713 if (str && strcmp (str, "1") == 0) return 1;
11717 static int test_vgcreate_0 (void)
11719 if (test_vgcreate_0_skip ()) {
11720 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11724 /* InitNone|InitEmpty for test_vgcreate_0 */
11726 char device[] = "/dev/sda";
11727 device[5] = devchar;
11729 suppress_error = 0;
11730 r = guestfs_blockdev_setrw (g, device);
11736 suppress_error = 0;
11737 r = guestfs_umount_all (g);
11743 suppress_error = 0;
11744 r = guestfs_lvm_remove_all (g);
11748 /* TestOutputList for vgcreate (0) */
11750 char device[] = "/dev/sda";
11751 device[5] = devchar;
11752 char lines_0[] = ",10";
11753 char lines_1[] = ",20";
11754 char lines_2[] = ",";
11762 suppress_error = 0;
11763 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11768 char device[] = "/dev/sda1";
11769 device[5] = devchar;
11771 suppress_error = 0;
11772 r = guestfs_pvcreate (g, device);
11777 char device[] = "/dev/sda2";
11778 device[5] = devchar;
11780 suppress_error = 0;
11781 r = guestfs_pvcreate (g, device);
11786 char device[] = "/dev/sda3";
11787 device[5] = devchar;
11789 suppress_error = 0;
11790 r = guestfs_pvcreate (g, device);
11795 char volgroup[] = "VG1";
11796 char physvols_0[] = "/dev/sda1";
11797 physvols_0[5] = devchar;
11798 char physvols_1[] = "/dev/sda2";
11799 physvols_1[5] = devchar;
11800 char *physvols[] = {
11806 suppress_error = 0;
11807 r = guestfs_vgcreate (g, volgroup, physvols);
11812 char volgroup[] = "VG2";
11813 char physvols_0[] = "/dev/sda3";
11814 physvols_0[5] = devchar;
11815 char *physvols[] = {
11820 suppress_error = 0;
11821 r = guestfs_vgcreate (g, volgroup, physvols);
11828 suppress_error = 0;
11829 r = guestfs_vgs (g);
11833 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11838 char expected[] = "VG1";
11839 if (strcmp (r[0], expected) != 0) {
11840 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11845 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
11850 char expected[] = "VG2";
11851 if (strcmp (r[1], expected) != 0) {
11852 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11856 if (r[2] != NULL) {
11857 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
11861 for (i = 0; r[i] != NULL; ++i)
11868 static int test_pvcreate_0_skip (void)
11872 str = getenv ("SKIP_TEST_PVCREATE_0");
11873 if (str && strcmp (str, "1") == 0) return 1;
11874 str = getenv ("SKIP_TEST_PVCREATE");
11875 if (str && strcmp (str, "1") == 0) return 1;
11879 static int test_pvcreate_0 (void)
11881 if (test_pvcreate_0_skip ()) {
11882 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
11886 /* InitNone|InitEmpty for test_pvcreate_0 */
11888 char device[] = "/dev/sda";
11889 device[5] = devchar;
11891 suppress_error = 0;
11892 r = guestfs_blockdev_setrw (g, device);
11898 suppress_error = 0;
11899 r = guestfs_umount_all (g);
11905 suppress_error = 0;
11906 r = guestfs_lvm_remove_all (g);
11910 /* TestOutputList for pvcreate (0) */
11912 char device[] = "/dev/sda";
11913 device[5] = devchar;
11914 char lines_0[] = ",10";
11915 char lines_1[] = ",20";
11916 char lines_2[] = ",";
11924 suppress_error = 0;
11925 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11930 char device[] = "/dev/sda1";
11931 device[5] = devchar;
11933 suppress_error = 0;
11934 r = guestfs_pvcreate (g, device);
11939 char device[] = "/dev/sda2";
11940 device[5] = devchar;
11942 suppress_error = 0;
11943 r = guestfs_pvcreate (g, device);
11948 char device[] = "/dev/sda3";
11949 device[5] = devchar;
11951 suppress_error = 0;
11952 r = guestfs_pvcreate (g, device);
11959 suppress_error = 0;
11960 r = guestfs_pvs (g);
11964 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11969 char expected[] = "/dev/sda1";
11970 expected[5] = devchar;
11971 if (strcmp (r[0], expected) != 0) {
11972 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11977 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11982 char expected[] = "/dev/sda2";
11983 expected[5] = devchar;
11984 if (strcmp (r[1], expected) != 0) {
11985 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11990 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
11995 char expected[] = "/dev/sda3";
11996 expected[5] = devchar;
11997 if (strcmp (r[2], expected) != 0) {
11998 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12002 if (r[3] != NULL) {
12003 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12007 for (i = 0; r[i] != NULL; ++i)
12014 static int test_is_dir_0_skip (void)
12018 str = getenv ("SKIP_TEST_IS_DIR_0");
12019 if (str && strcmp (str, "1") == 0) return 1;
12020 str = getenv ("SKIP_TEST_IS_DIR");
12021 if (str && strcmp (str, "1") == 0) return 1;
12025 static int test_is_dir_0 (void)
12027 if (test_is_dir_0_skip ()) {
12028 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12032 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12034 char device[] = "/dev/sda";
12035 device[5] = devchar;
12037 suppress_error = 0;
12038 r = guestfs_blockdev_setrw (g, device);
12044 suppress_error = 0;
12045 r = guestfs_umount_all (g);
12051 suppress_error = 0;
12052 r = guestfs_lvm_remove_all (g);
12057 char device[] = "/dev/sda";
12058 device[5] = devchar;
12059 char lines_0[] = ",";
12065 suppress_error = 0;
12066 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12071 char fstype[] = "ext2";
12072 char device[] = "/dev/sda1";
12073 device[5] = devchar;
12075 suppress_error = 0;
12076 r = guestfs_mkfs (g, fstype, device);
12081 char device[] = "/dev/sda1";
12082 device[5] = devchar;
12083 char mountpoint[] = "/";
12085 suppress_error = 0;
12086 r = guestfs_mount (g, device, mountpoint);
12090 /* TestOutputFalse for is_dir (0) */
12092 char path[] = "/new";
12094 suppress_error = 0;
12095 r = guestfs_touch (g, path);
12100 char path[] = "/new";
12102 suppress_error = 0;
12103 r = guestfs_is_dir (g, path);
12107 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12114 static int test_is_dir_1_skip (void)
12118 str = getenv ("SKIP_TEST_IS_DIR_1");
12119 if (str && strcmp (str, "1") == 0) return 1;
12120 str = getenv ("SKIP_TEST_IS_DIR");
12121 if (str && strcmp (str, "1") == 0) return 1;
12125 static int test_is_dir_1 (void)
12127 if (test_is_dir_1_skip ()) {
12128 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12132 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12134 char device[] = "/dev/sda";
12135 device[5] = devchar;
12137 suppress_error = 0;
12138 r = guestfs_blockdev_setrw (g, device);
12144 suppress_error = 0;
12145 r = guestfs_umount_all (g);
12151 suppress_error = 0;
12152 r = guestfs_lvm_remove_all (g);
12157 char device[] = "/dev/sda";
12158 device[5] = devchar;
12159 char lines_0[] = ",";
12165 suppress_error = 0;
12166 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12171 char fstype[] = "ext2";
12172 char device[] = "/dev/sda1";
12173 device[5] = devchar;
12175 suppress_error = 0;
12176 r = guestfs_mkfs (g, fstype, device);
12181 char device[] = "/dev/sda1";
12182 device[5] = devchar;
12183 char mountpoint[] = "/";
12185 suppress_error = 0;
12186 r = guestfs_mount (g, device, mountpoint);
12190 /* TestOutputTrue for is_dir (1) */
12192 char path[] = "/new";
12194 suppress_error = 0;
12195 r = guestfs_mkdir (g, path);
12200 char path[] = "/new";
12202 suppress_error = 0;
12203 r = guestfs_is_dir (g, path);
12207 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12214 static int test_is_file_0_skip (void)
12218 str = getenv ("SKIP_TEST_IS_FILE_0");
12219 if (str && strcmp (str, "1") == 0) return 1;
12220 str = getenv ("SKIP_TEST_IS_FILE");
12221 if (str && strcmp (str, "1") == 0) return 1;
12225 static int test_is_file_0 (void)
12227 if (test_is_file_0_skip ()) {
12228 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12232 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12234 char device[] = "/dev/sda";
12235 device[5] = devchar;
12237 suppress_error = 0;
12238 r = guestfs_blockdev_setrw (g, device);
12244 suppress_error = 0;
12245 r = guestfs_umount_all (g);
12251 suppress_error = 0;
12252 r = guestfs_lvm_remove_all (g);
12257 char device[] = "/dev/sda";
12258 device[5] = devchar;
12259 char lines_0[] = ",";
12265 suppress_error = 0;
12266 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12271 char fstype[] = "ext2";
12272 char device[] = "/dev/sda1";
12273 device[5] = devchar;
12275 suppress_error = 0;
12276 r = guestfs_mkfs (g, fstype, device);
12281 char device[] = "/dev/sda1";
12282 device[5] = devchar;
12283 char mountpoint[] = "/";
12285 suppress_error = 0;
12286 r = guestfs_mount (g, device, mountpoint);
12290 /* TestOutputTrue for is_file (0) */
12292 char path[] = "/new";
12294 suppress_error = 0;
12295 r = guestfs_touch (g, path);
12300 char path[] = "/new";
12302 suppress_error = 0;
12303 r = guestfs_is_file (g, path);
12307 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12314 static int test_is_file_1_skip (void)
12318 str = getenv ("SKIP_TEST_IS_FILE_1");
12319 if (str && strcmp (str, "1") == 0) return 1;
12320 str = getenv ("SKIP_TEST_IS_FILE");
12321 if (str && strcmp (str, "1") == 0) return 1;
12325 static int test_is_file_1 (void)
12327 if (test_is_file_1_skip ()) {
12328 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12332 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12334 char device[] = "/dev/sda";
12335 device[5] = devchar;
12337 suppress_error = 0;
12338 r = guestfs_blockdev_setrw (g, device);
12344 suppress_error = 0;
12345 r = guestfs_umount_all (g);
12351 suppress_error = 0;
12352 r = guestfs_lvm_remove_all (g);
12357 char device[] = "/dev/sda";
12358 device[5] = devchar;
12359 char lines_0[] = ",";
12365 suppress_error = 0;
12366 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12371 char fstype[] = "ext2";
12372 char device[] = "/dev/sda1";
12373 device[5] = devchar;
12375 suppress_error = 0;
12376 r = guestfs_mkfs (g, fstype, device);
12381 char device[] = "/dev/sda1";
12382 device[5] = devchar;
12383 char mountpoint[] = "/";
12385 suppress_error = 0;
12386 r = guestfs_mount (g, device, mountpoint);
12390 /* TestOutputFalse for is_file (1) */
12392 char path[] = "/new";
12394 suppress_error = 0;
12395 r = guestfs_mkdir (g, path);
12400 char path[] = "/new";
12402 suppress_error = 0;
12403 r = guestfs_is_file (g, path);
12407 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12414 static int test_exists_0_skip (void)
12418 str = getenv ("SKIP_TEST_EXISTS_0");
12419 if (str && strcmp (str, "1") == 0) return 1;
12420 str = getenv ("SKIP_TEST_EXISTS");
12421 if (str && strcmp (str, "1") == 0) return 1;
12425 static int test_exists_0 (void)
12427 if (test_exists_0_skip ()) {
12428 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12432 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12434 char device[] = "/dev/sda";
12435 device[5] = devchar;
12437 suppress_error = 0;
12438 r = guestfs_blockdev_setrw (g, device);
12444 suppress_error = 0;
12445 r = guestfs_umount_all (g);
12451 suppress_error = 0;
12452 r = guestfs_lvm_remove_all (g);
12457 char device[] = "/dev/sda";
12458 device[5] = devchar;
12459 char lines_0[] = ",";
12465 suppress_error = 0;
12466 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12471 char fstype[] = "ext2";
12472 char device[] = "/dev/sda1";
12473 device[5] = devchar;
12475 suppress_error = 0;
12476 r = guestfs_mkfs (g, fstype, device);
12481 char device[] = "/dev/sda1";
12482 device[5] = devchar;
12483 char mountpoint[] = "/";
12485 suppress_error = 0;
12486 r = guestfs_mount (g, device, mountpoint);
12490 /* TestOutputTrue for exists (0) */
12492 char path[] = "/new";
12494 suppress_error = 0;
12495 r = guestfs_touch (g, path);
12500 char path[] = "/new";
12502 suppress_error = 0;
12503 r = guestfs_exists (g, path);
12507 fprintf (stderr, "test_exists_0: expected true, got false\n");
12514 static int test_exists_1_skip (void)
12518 str = getenv ("SKIP_TEST_EXISTS_1");
12519 if (str && strcmp (str, "1") == 0) return 1;
12520 str = getenv ("SKIP_TEST_EXISTS");
12521 if (str && strcmp (str, "1") == 0) return 1;
12525 static int test_exists_1 (void)
12527 if (test_exists_1_skip ()) {
12528 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12532 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12534 char device[] = "/dev/sda";
12535 device[5] = devchar;
12537 suppress_error = 0;
12538 r = guestfs_blockdev_setrw (g, device);
12544 suppress_error = 0;
12545 r = guestfs_umount_all (g);
12551 suppress_error = 0;
12552 r = guestfs_lvm_remove_all (g);
12557 char device[] = "/dev/sda";
12558 device[5] = devchar;
12559 char lines_0[] = ",";
12565 suppress_error = 0;
12566 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12571 char fstype[] = "ext2";
12572 char device[] = "/dev/sda1";
12573 device[5] = devchar;
12575 suppress_error = 0;
12576 r = guestfs_mkfs (g, fstype, device);
12581 char device[] = "/dev/sda1";
12582 device[5] = devchar;
12583 char mountpoint[] = "/";
12585 suppress_error = 0;
12586 r = guestfs_mount (g, device, mountpoint);
12590 /* TestOutputTrue for exists (1) */
12592 char path[] = "/new";
12594 suppress_error = 0;
12595 r = guestfs_mkdir (g, path);
12600 char path[] = "/new";
12602 suppress_error = 0;
12603 r = guestfs_exists (g, path);
12607 fprintf (stderr, "test_exists_1: expected true, got false\n");
12614 static int test_mkdir_p_0_skip (void)
12618 str = getenv ("SKIP_TEST_MKDIR_P_0");
12619 if (str && strcmp (str, "1") == 0) return 1;
12620 str = getenv ("SKIP_TEST_MKDIR_P");
12621 if (str && strcmp (str, "1") == 0) return 1;
12625 static int test_mkdir_p_0 (void)
12627 if (test_mkdir_p_0_skip ()) {
12628 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12632 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12634 char device[] = "/dev/sda";
12635 device[5] = devchar;
12637 suppress_error = 0;
12638 r = guestfs_blockdev_setrw (g, device);
12644 suppress_error = 0;
12645 r = guestfs_umount_all (g);
12651 suppress_error = 0;
12652 r = guestfs_lvm_remove_all (g);
12657 char device[] = "/dev/sda";
12658 device[5] = devchar;
12659 char lines_0[] = ",";
12665 suppress_error = 0;
12666 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12671 char fstype[] = "ext2";
12672 char device[] = "/dev/sda1";
12673 device[5] = devchar;
12675 suppress_error = 0;
12676 r = guestfs_mkfs (g, fstype, device);
12681 char device[] = "/dev/sda1";
12682 device[5] = devchar;
12683 char mountpoint[] = "/";
12685 suppress_error = 0;
12686 r = guestfs_mount (g, device, mountpoint);
12690 /* TestOutputTrue for mkdir_p (0) */
12692 char path[] = "/new/foo/bar";
12694 suppress_error = 0;
12695 r = guestfs_mkdir_p (g, path);
12700 char path[] = "/new/foo/bar";
12702 suppress_error = 0;
12703 r = guestfs_is_dir (g, path);
12707 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12714 static int test_mkdir_p_1_skip (void)
12718 str = getenv ("SKIP_TEST_MKDIR_P_1");
12719 if (str && strcmp (str, "1") == 0) return 1;
12720 str = getenv ("SKIP_TEST_MKDIR_P");
12721 if (str && strcmp (str, "1") == 0) return 1;
12725 static int test_mkdir_p_1 (void)
12727 if (test_mkdir_p_1_skip ()) {
12728 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12732 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12734 char device[] = "/dev/sda";
12735 device[5] = devchar;
12737 suppress_error = 0;
12738 r = guestfs_blockdev_setrw (g, device);
12744 suppress_error = 0;
12745 r = guestfs_umount_all (g);
12751 suppress_error = 0;
12752 r = guestfs_lvm_remove_all (g);
12757 char device[] = "/dev/sda";
12758 device[5] = devchar;
12759 char lines_0[] = ",";
12765 suppress_error = 0;
12766 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12771 char fstype[] = "ext2";
12772 char device[] = "/dev/sda1";
12773 device[5] = devchar;
12775 suppress_error = 0;
12776 r = guestfs_mkfs (g, fstype, device);
12781 char device[] = "/dev/sda1";
12782 device[5] = devchar;
12783 char mountpoint[] = "/";
12785 suppress_error = 0;
12786 r = guestfs_mount (g, device, mountpoint);
12790 /* TestOutputTrue for mkdir_p (1) */
12792 char path[] = "/new/foo/bar";
12794 suppress_error = 0;
12795 r = guestfs_mkdir_p (g, path);
12800 char path[] = "/new/foo";
12802 suppress_error = 0;
12803 r = guestfs_is_dir (g, path);
12807 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12814 static int test_mkdir_p_2_skip (void)
12818 str = getenv ("SKIP_TEST_MKDIR_P_2");
12819 if (str && strcmp (str, "1") == 0) return 1;
12820 str = getenv ("SKIP_TEST_MKDIR_P");
12821 if (str && strcmp (str, "1") == 0) return 1;
12825 static int test_mkdir_p_2 (void)
12827 if (test_mkdir_p_2_skip ()) {
12828 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12832 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12834 char device[] = "/dev/sda";
12835 device[5] = devchar;
12837 suppress_error = 0;
12838 r = guestfs_blockdev_setrw (g, device);
12844 suppress_error = 0;
12845 r = guestfs_umount_all (g);
12851 suppress_error = 0;
12852 r = guestfs_lvm_remove_all (g);
12857 char device[] = "/dev/sda";
12858 device[5] = devchar;
12859 char lines_0[] = ",";
12865 suppress_error = 0;
12866 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12871 char fstype[] = "ext2";
12872 char device[] = "/dev/sda1";
12873 device[5] = devchar;
12875 suppress_error = 0;
12876 r = guestfs_mkfs (g, fstype, device);
12881 char device[] = "/dev/sda1";
12882 device[5] = devchar;
12883 char mountpoint[] = "/";
12885 suppress_error = 0;
12886 r = guestfs_mount (g, device, mountpoint);
12890 /* TestOutputTrue for mkdir_p (2) */
12892 char path[] = "/new/foo/bar";
12894 suppress_error = 0;
12895 r = guestfs_mkdir_p (g, path);
12900 char path[] = "/new";
12902 suppress_error = 0;
12903 r = guestfs_is_dir (g, path);
12907 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
12914 static int test_mkdir_p_3_skip (void)
12918 str = getenv ("SKIP_TEST_MKDIR_P_3");
12919 if (str && strcmp (str, "1") == 0) return 1;
12920 str = getenv ("SKIP_TEST_MKDIR_P");
12921 if (str && strcmp (str, "1") == 0) return 1;
12925 static int test_mkdir_p_3 (void)
12927 if (test_mkdir_p_3_skip ()) {
12928 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
12932 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
12934 char device[] = "/dev/sda";
12935 device[5] = devchar;
12937 suppress_error = 0;
12938 r = guestfs_blockdev_setrw (g, device);
12944 suppress_error = 0;
12945 r = guestfs_umount_all (g);
12951 suppress_error = 0;
12952 r = guestfs_lvm_remove_all (g);
12957 char device[] = "/dev/sda";
12958 device[5] = devchar;
12959 char lines_0[] = ",";
12965 suppress_error = 0;
12966 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12971 char fstype[] = "ext2";
12972 char device[] = "/dev/sda1";
12973 device[5] = devchar;
12975 suppress_error = 0;
12976 r = guestfs_mkfs (g, fstype, device);
12981 char device[] = "/dev/sda1";
12982 device[5] = devchar;
12983 char mountpoint[] = "/";
12985 suppress_error = 0;
12986 r = guestfs_mount (g, device, mountpoint);
12990 /* TestRun for mkdir_p (3) */
12992 char path[] = "/new";
12994 suppress_error = 0;
12995 r = guestfs_mkdir (g, path);
13000 char path[] = "/new";
13002 suppress_error = 0;
13003 r = guestfs_mkdir_p (g, path);
13010 static int test_mkdir_p_4_skip (void)
13014 str = getenv ("SKIP_TEST_MKDIR_P_4");
13015 if (str && strcmp (str, "1") == 0) return 1;
13016 str = getenv ("SKIP_TEST_MKDIR_P");
13017 if (str && strcmp (str, "1") == 0) return 1;
13021 static int test_mkdir_p_4 (void)
13023 if (test_mkdir_p_4_skip ()) {
13024 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13028 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13030 char device[] = "/dev/sda";
13031 device[5] = devchar;
13033 suppress_error = 0;
13034 r = guestfs_blockdev_setrw (g, device);
13040 suppress_error = 0;
13041 r = guestfs_umount_all (g);
13047 suppress_error = 0;
13048 r = guestfs_lvm_remove_all (g);
13053 char device[] = "/dev/sda";
13054 device[5] = devchar;
13055 char lines_0[] = ",";
13061 suppress_error = 0;
13062 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13067 char fstype[] = "ext2";
13068 char device[] = "/dev/sda1";
13069 device[5] = devchar;
13071 suppress_error = 0;
13072 r = guestfs_mkfs (g, fstype, device);
13077 char device[] = "/dev/sda1";
13078 device[5] = devchar;
13079 char mountpoint[] = "/";
13081 suppress_error = 0;
13082 r = guestfs_mount (g, device, mountpoint);
13086 /* TestLastFail for mkdir_p (4) */
13088 char path[] = "/new";
13090 suppress_error = 0;
13091 r = guestfs_touch (g, path);
13096 char path[] = "/new";
13098 suppress_error = 1;
13099 r = guestfs_mkdir_p (g, path);
13106 static int test_mkdir_0_skip (void)
13110 str = getenv ("SKIP_TEST_MKDIR_0");
13111 if (str && strcmp (str, "1") == 0) return 1;
13112 str = getenv ("SKIP_TEST_MKDIR");
13113 if (str && strcmp (str, "1") == 0) return 1;
13117 static int test_mkdir_0 (void)
13119 if (test_mkdir_0_skip ()) {
13120 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13124 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13126 char device[] = "/dev/sda";
13127 device[5] = devchar;
13129 suppress_error = 0;
13130 r = guestfs_blockdev_setrw (g, device);
13136 suppress_error = 0;
13137 r = guestfs_umount_all (g);
13143 suppress_error = 0;
13144 r = guestfs_lvm_remove_all (g);
13149 char device[] = "/dev/sda";
13150 device[5] = devchar;
13151 char lines_0[] = ",";
13157 suppress_error = 0;
13158 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13163 char fstype[] = "ext2";
13164 char device[] = "/dev/sda1";
13165 device[5] = devchar;
13167 suppress_error = 0;
13168 r = guestfs_mkfs (g, fstype, device);
13173 char device[] = "/dev/sda1";
13174 device[5] = devchar;
13175 char mountpoint[] = "/";
13177 suppress_error = 0;
13178 r = guestfs_mount (g, device, mountpoint);
13182 /* TestOutputTrue for mkdir (0) */
13184 char path[] = "/new";
13186 suppress_error = 0;
13187 r = guestfs_mkdir (g, path);
13192 char path[] = "/new";
13194 suppress_error = 0;
13195 r = guestfs_is_dir (g, path);
13199 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13206 static int test_mkdir_1_skip (void)
13210 str = getenv ("SKIP_TEST_MKDIR_1");
13211 if (str && strcmp (str, "1") == 0) return 1;
13212 str = getenv ("SKIP_TEST_MKDIR");
13213 if (str && strcmp (str, "1") == 0) return 1;
13217 static int test_mkdir_1 (void)
13219 if (test_mkdir_1_skip ()) {
13220 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13224 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13226 char device[] = "/dev/sda";
13227 device[5] = devchar;
13229 suppress_error = 0;
13230 r = guestfs_blockdev_setrw (g, device);
13236 suppress_error = 0;
13237 r = guestfs_umount_all (g);
13243 suppress_error = 0;
13244 r = guestfs_lvm_remove_all (g);
13249 char device[] = "/dev/sda";
13250 device[5] = devchar;
13251 char lines_0[] = ",";
13257 suppress_error = 0;
13258 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13263 char fstype[] = "ext2";
13264 char device[] = "/dev/sda1";
13265 device[5] = devchar;
13267 suppress_error = 0;
13268 r = guestfs_mkfs (g, fstype, device);
13273 char device[] = "/dev/sda1";
13274 device[5] = devchar;
13275 char mountpoint[] = "/";
13277 suppress_error = 0;
13278 r = guestfs_mount (g, device, mountpoint);
13282 /* TestLastFail for mkdir (1) */
13284 char path[] = "/new/foo/bar";
13286 suppress_error = 1;
13287 r = guestfs_mkdir (g, path);
13294 static int test_rm_rf_0_skip (void)
13298 str = getenv ("SKIP_TEST_RM_RF_0");
13299 if (str && strcmp (str, "1") == 0) return 1;
13300 str = getenv ("SKIP_TEST_RM_RF");
13301 if (str && strcmp (str, "1") == 0) return 1;
13305 static int test_rm_rf_0 (void)
13307 if (test_rm_rf_0_skip ()) {
13308 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13312 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13314 char device[] = "/dev/sda";
13315 device[5] = devchar;
13317 suppress_error = 0;
13318 r = guestfs_blockdev_setrw (g, device);
13324 suppress_error = 0;
13325 r = guestfs_umount_all (g);
13331 suppress_error = 0;
13332 r = guestfs_lvm_remove_all (g);
13337 char device[] = "/dev/sda";
13338 device[5] = devchar;
13339 char lines_0[] = ",";
13345 suppress_error = 0;
13346 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13351 char fstype[] = "ext2";
13352 char device[] = "/dev/sda1";
13353 device[5] = devchar;
13355 suppress_error = 0;
13356 r = guestfs_mkfs (g, fstype, device);
13361 char device[] = "/dev/sda1";
13362 device[5] = devchar;
13363 char mountpoint[] = "/";
13365 suppress_error = 0;
13366 r = guestfs_mount (g, device, mountpoint);
13370 /* TestOutputFalse for rm_rf (0) */
13372 char path[] = "/new";
13374 suppress_error = 0;
13375 r = guestfs_mkdir (g, path);
13380 char path[] = "/new/foo";
13382 suppress_error = 0;
13383 r = guestfs_mkdir (g, path);
13388 char path[] = "/new/foo/bar";
13390 suppress_error = 0;
13391 r = guestfs_touch (g, path);
13396 char path[] = "/new";
13398 suppress_error = 0;
13399 r = guestfs_rm_rf (g, path);
13404 char path[] = "/new";
13406 suppress_error = 0;
13407 r = guestfs_exists (g, path);
13411 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13418 static int test_rmdir_0_skip (void)
13422 str = getenv ("SKIP_TEST_RMDIR_0");
13423 if (str && strcmp (str, "1") == 0) return 1;
13424 str = getenv ("SKIP_TEST_RMDIR");
13425 if (str && strcmp (str, "1") == 0) return 1;
13429 static int test_rmdir_0 (void)
13431 if (test_rmdir_0_skip ()) {
13432 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13436 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13438 char device[] = "/dev/sda";
13439 device[5] = devchar;
13441 suppress_error = 0;
13442 r = guestfs_blockdev_setrw (g, device);
13448 suppress_error = 0;
13449 r = guestfs_umount_all (g);
13455 suppress_error = 0;
13456 r = guestfs_lvm_remove_all (g);
13461 char device[] = "/dev/sda";
13462 device[5] = devchar;
13463 char lines_0[] = ",";
13469 suppress_error = 0;
13470 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13475 char fstype[] = "ext2";
13476 char device[] = "/dev/sda1";
13477 device[5] = devchar;
13479 suppress_error = 0;
13480 r = guestfs_mkfs (g, fstype, device);
13485 char device[] = "/dev/sda1";
13486 device[5] = devchar;
13487 char mountpoint[] = "/";
13489 suppress_error = 0;
13490 r = guestfs_mount (g, device, mountpoint);
13494 /* TestRun for rmdir (0) */
13496 char path[] = "/new";
13498 suppress_error = 0;
13499 r = guestfs_mkdir (g, path);
13504 char path[] = "/new";
13506 suppress_error = 0;
13507 r = guestfs_rmdir (g, path);
13514 static int test_rmdir_1_skip (void)
13518 str = getenv ("SKIP_TEST_RMDIR_1");
13519 if (str && strcmp (str, "1") == 0) return 1;
13520 str = getenv ("SKIP_TEST_RMDIR");
13521 if (str && strcmp (str, "1") == 0) return 1;
13525 static int test_rmdir_1 (void)
13527 if (test_rmdir_1_skip ()) {
13528 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13532 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13534 char device[] = "/dev/sda";
13535 device[5] = devchar;
13537 suppress_error = 0;
13538 r = guestfs_blockdev_setrw (g, device);
13544 suppress_error = 0;
13545 r = guestfs_umount_all (g);
13551 suppress_error = 0;
13552 r = guestfs_lvm_remove_all (g);
13557 char device[] = "/dev/sda";
13558 device[5] = devchar;
13559 char lines_0[] = ",";
13565 suppress_error = 0;
13566 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13571 char fstype[] = "ext2";
13572 char device[] = "/dev/sda1";
13573 device[5] = devchar;
13575 suppress_error = 0;
13576 r = guestfs_mkfs (g, fstype, device);
13581 char device[] = "/dev/sda1";
13582 device[5] = devchar;
13583 char mountpoint[] = "/";
13585 suppress_error = 0;
13586 r = guestfs_mount (g, device, mountpoint);
13590 /* TestLastFail for rmdir (1) */
13592 char path[] = "/new";
13594 suppress_error = 1;
13595 r = guestfs_rmdir (g, path);
13602 static int test_rmdir_2_skip (void)
13606 str = getenv ("SKIP_TEST_RMDIR_2");
13607 if (str && strcmp (str, "1") == 0) return 1;
13608 str = getenv ("SKIP_TEST_RMDIR");
13609 if (str && strcmp (str, "1") == 0) return 1;
13613 static int test_rmdir_2 (void)
13615 if (test_rmdir_2_skip ()) {
13616 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13620 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13622 char device[] = "/dev/sda";
13623 device[5] = devchar;
13625 suppress_error = 0;
13626 r = guestfs_blockdev_setrw (g, device);
13632 suppress_error = 0;
13633 r = guestfs_umount_all (g);
13639 suppress_error = 0;
13640 r = guestfs_lvm_remove_all (g);
13645 char device[] = "/dev/sda";
13646 device[5] = devchar;
13647 char lines_0[] = ",";
13653 suppress_error = 0;
13654 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13659 char fstype[] = "ext2";
13660 char device[] = "/dev/sda1";
13661 device[5] = devchar;
13663 suppress_error = 0;
13664 r = guestfs_mkfs (g, fstype, device);
13669 char device[] = "/dev/sda1";
13670 device[5] = devchar;
13671 char mountpoint[] = "/";
13673 suppress_error = 0;
13674 r = guestfs_mount (g, device, mountpoint);
13678 /* TestLastFail for rmdir (2) */
13680 char path[] = "/new";
13682 suppress_error = 0;
13683 r = guestfs_touch (g, path);
13688 char path[] = "/new";
13690 suppress_error = 1;
13691 r = guestfs_rmdir (g, path);
13698 static int test_rm_0_skip (void)
13702 str = getenv ("SKIP_TEST_RM_0");
13703 if (str && strcmp (str, "1") == 0) return 1;
13704 str = getenv ("SKIP_TEST_RM");
13705 if (str && strcmp (str, "1") == 0) return 1;
13709 static int test_rm_0 (void)
13711 if (test_rm_0_skip ()) {
13712 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13716 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13718 char device[] = "/dev/sda";
13719 device[5] = devchar;
13721 suppress_error = 0;
13722 r = guestfs_blockdev_setrw (g, device);
13728 suppress_error = 0;
13729 r = guestfs_umount_all (g);
13735 suppress_error = 0;
13736 r = guestfs_lvm_remove_all (g);
13741 char device[] = "/dev/sda";
13742 device[5] = devchar;
13743 char lines_0[] = ",";
13749 suppress_error = 0;
13750 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13755 char fstype[] = "ext2";
13756 char device[] = "/dev/sda1";
13757 device[5] = devchar;
13759 suppress_error = 0;
13760 r = guestfs_mkfs (g, fstype, device);
13765 char device[] = "/dev/sda1";
13766 device[5] = devchar;
13767 char mountpoint[] = "/";
13769 suppress_error = 0;
13770 r = guestfs_mount (g, device, mountpoint);
13774 /* TestRun for rm (0) */
13776 char path[] = "/new";
13778 suppress_error = 0;
13779 r = guestfs_touch (g, path);
13784 char path[] = "/new";
13786 suppress_error = 0;
13787 r = guestfs_rm (g, path);
13794 static int test_rm_1_skip (void)
13798 str = getenv ("SKIP_TEST_RM_1");
13799 if (str && strcmp (str, "1") == 0) return 1;
13800 str = getenv ("SKIP_TEST_RM");
13801 if (str && strcmp (str, "1") == 0) return 1;
13805 static int test_rm_1 (void)
13807 if (test_rm_1_skip ()) {
13808 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13812 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13814 char device[] = "/dev/sda";
13815 device[5] = devchar;
13817 suppress_error = 0;
13818 r = guestfs_blockdev_setrw (g, device);
13824 suppress_error = 0;
13825 r = guestfs_umount_all (g);
13831 suppress_error = 0;
13832 r = guestfs_lvm_remove_all (g);
13837 char device[] = "/dev/sda";
13838 device[5] = devchar;
13839 char lines_0[] = ",";
13845 suppress_error = 0;
13846 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13851 char fstype[] = "ext2";
13852 char device[] = "/dev/sda1";
13853 device[5] = devchar;
13855 suppress_error = 0;
13856 r = guestfs_mkfs (g, fstype, device);
13861 char device[] = "/dev/sda1";
13862 device[5] = devchar;
13863 char mountpoint[] = "/";
13865 suppress_error = 0;
13866 r = guestfs_mount (g, device, mountpoint);
13870 /* TestLastFail for rm (1) */
13872 char path[] = "/new";
13874 suppress_error = 1;
13875 r = guestfs_rm (g, path);
13882 static int test_rm_2_skip (void)
13886 str = getenv ("SKIP_TEST_RM_2");
13887 if (str && strcmp (str, "1") == 0) return 1;
13888 str = getenv ("SKIP_TEST_RM");
13889 if (str && strcmp (str, "1") == 0) return 1;
13893 static int test_rm_2 (void)
13895 if (test_rm_2_skip ()) {
13896 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13900 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13902 char device[] = "/dev/sda";
13903 device[5] = devchar;
13905 suppress_error = 0;
13906 r = guestfs_blockdev_setrw (g, device);
13912 suppress_error = 0;
13913 r = guestfs_umount_all (g);
13919 suppress_error = 0;
13920 r = guestfs_lvm_remove_all (g);
13925 char device[] = "/dev/sda";
13926 device[5] = devchar;
13927 char lines_0[] = ",";
13933 suppress_error = 0;
13934 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13939 char fstype[] = "ext2";
13940 char device[] = "/dev/sda1";
13941 device[5] = devchar;
13943 suppress_error = 0;
13944 r = guestfs_mkfs (g, fstype, device);
13949 char device[] = "/dev/sda1";
13950 device[5] = devchar;
13951 char mountpoint[] = "/";
13953 suppress_error = 0;
13954 r = guestfs_mount (g, device, mountpoint);
13958 /* TestLastFail for rm (2) */
13960 char path[] = "/new";
13962 suppress_error = 0;
13963 r = guestfs_mkdir (g, path);
13968 char path[] = "/new";
13970 suppress_error = 1;
13971 r = guestfs_rm (g, path);
13978 static int test_read_lines_0_skip (void)
13982 str = getenv ("SKIP_TEST_READ_LINES_0");
13983 if (str && strcmp (str, "1") == 0) return 1;
13984 str = getenv ("SKIP_TEST_READ_LINES");
13985 if (str && strcmp (str, "1") == 0) return 1;
13989 static int test_read_lines_0 (void)
13991 if (test_read_lines_0_skip ()) {
13992 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
13996 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
13998 char device[] = "/dev/sda";
13999 device[5] = devchar;
14001 suppress_error = 0;
14002 r = guestfs_blockdev_setrw (g, device);
14008 suppress_error = 0;
14009 r = guestfs_umount_all (g);
14015 suppress_error = 0;
14016 r = guestfs_lvm_remove_all (g);
14021 char device[] = "/dev/sda";
14022 device[5] = devchar;
14023 char lines_0[] = ",";
14029 suppress_error = 0;
14030 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14035 char fstype[] = "ext2";
14036 char device[] = "/dev/sda1";
14037 device[5] = devchar;
14039 suppress_error = 0;
14040 r = guestfs_mkfs (g, fstype, device);
14045 char device[] = "/dev/sda1";
14046 device[5] = devchar;
14047 char mountpoint[] = "/";
14049 suppress_error = 0;
14050 r = guestfs_mount (g, device, mountpoint);
14054 /* TestOutputList for read_lines (0) */
14056 char path[] = "/new";
14057 char content[] = "line1\r\nline2\nline3";
14059 suppress_error = 0;
14060 r = guestfs_write_file (g, path, content, 0);
14065 char path[] = "/new";
14068 suppress_error = 0;
14069 r = guestfs_read_lines (g, path);
14073 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14078 char expected[] = "line1";
14079 if (strcmp (r[0], expected) != 0) {
14080 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14085 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14090 char expected[] = "line2";
14091 if (strcmp (r[1], expected) != 0) {
14092 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14097 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14102 char expected[] = "line3";
14103 if (strcmp (r[2], expected) != 0) {
14104 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14108 if (r[3] != NULL) {
14109 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14113 for (i = 0; r[i] != NULL; ++i)
14120 static int test_read_lines_1_skip (void)
14124 str = getenv ("SKIP_TEST_READ_LINES_1");
14125 if (str && strcmp (str, "1") == 0) return 1;
14126 str = getenv ("SKIP_TEST_READ_LINES");
14127 if (str && strcmp (str, "1") == 0) return 1;
14131 static int test_read_lines_1 (void)
14133 if (test_read_lines_1_skip ()) {
14134 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14138 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
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 fstype[] = "ext2";
14178 char device[] = "/dev/sda1";
14179 device[5] = devchar;
14181 suppress_error = 0;
14182 r = guestfs_mkfs (g, fstype, device);
14187 char device[] = "/dev/sda1";
14188 device[5] = devchar;
14189 char mountpoint[] = "/";
14191 suppress_error = 0;
14192 r = guestfs_mount (g, device, mountpoint);
14196 /* TestOutputList for read_lines (1) */
14198 char path[] = "/new";
14199 char content[] = "";
14201 suppress_error = 0;
14202 r = guestfs_write_file (g, path, content, 0);
14207 char path[] = "/new";
14210 suppress_error = 0;
14211 r = guestfs_read_lines (g, path);
14214 if (r[0] != NULL) {
14215 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14219 for (i = 0; r[i] != NULL; ++i)
14226 static int test_lvs_0_skip (void)
14230 str = getenv ("SKIP_TEST_LVS_0");
14231 if (str && strcmp (str, "1") == 0) return 1;
14232 str = getenv ("SKIP_TEST_LVS");
14233 if (str && strcmp (str, "1") == 0) return 1;
14237 static int test_lvs_0 (void)
14239 if (test_lvs_0_skip ()) {
14240 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14244 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14246 char device[] = "/dev/sda";
14247 device[5] = devchar;
14249 suppress_error = 0;
14250 r = guestfs_blockdev_setrw (g, device);
14256 suppress_error = 0;
14257 r = guestfs_umount_all (g);
14263 suppress_error = 0;
14264 r = guestfs_lvm_remove_all (g);
14269 char device[] = "/dev/sda";
14270 device[5] = devchar;
14271 char lines_0[] = ",";
14277 suppress_error = 0;
14278 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14283 char device[] = "/dev/sda1";
14284 device[5] = devchar;
14286 suppress_error = 0;
14287 r = guestfs_pvcreate (g, device);
14292 char volgroup[] = "VG";
14293 char physvols_0[] = "/dev/sda1";
14294 physvols_0[5] = devchar;
14295 char *physvols[] = {
14300 suppress_error = 0;
14301 r = guestfs_vgcreate (g, volgroup, physvols);
14306 char logvol[] = "LV";
14307 char volgroup[] = "VG";
14309 suppress_error = 0;
14310 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14315 char fstype[] = "ext2";
14316 char device[] = "/dev/VG/LV";
14318 suppress_error = 0;
14319 r = guestfs_mkfs (g, fstype, device);
14324 char device[] = "/dev/VG/LV";
14325 char mountpoint[] = "/";
14327 suppress_error = 0;
14328 r = guestfs_mount (g, device, mountpoint);
14332 /* TestOutputList for lvs (0) */
14336 suppress_error = 0;
14337 r = guestfs_lvs (g);
14341 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14346 char expected[] = "/dev/VG/LV";
14347 if (strcmp (r[0], expected) != 0) {
14348 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14352 if (r[1] != NULL) {
14353 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14357 for (i = 0; r[i] != NULL; ++i)
14364 static int test_lvs_1_skip (void)
14368 str = getenv ("SKIP_TEST_LVS_1");
14369 if (str && strcmp (str, "1") == 0) return 1;
14370 str = getenv ("SKIP_TEST_LVS");
14371 if (str && strcmp (str, "1") == 0) return 1;
14375 static int test_lvs_1 (void)
14377 if (test_lvs_1_skip ()) {
14378 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14382 /* InitNone|InitEmpty for test_lvs_1 */
14384 char device[] = "/dev/sda";
14385 device[5] = devchar;
14387 suppress_error = 0;
14388 r = guestfs_blockdev_setrw (g, device);
14394 suppress_error = 0;
14395 r = guestfs_umount_all (g);
14401 suppress_error = 0;
14402 r = guestfs_lvm_remove_all (g);
14406 /* TestOutputList for lvs (1) */
14408 char device[] = "/dev/sda";
14409 device[5] = devchar;
14410 char lines_0[] = ",10";
14411 char lines_1[] = ",20";
14412 char lines_2[] = ",";
14420 suppress_error = 0;
14421 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14426 char device[] = "/dev/sda1";
14427 device[5] = devchar;
14429 suppress_error = 0;
14430 r = guestfs_pvcreate (g, device);
14435 char device[] = "/dev/sda2";
14436 device[5] = devchar;
14438 suppress_error = 0;
14439 r = guestfs_pvcreate (g, device);
14444 char device[] = "/dev/sda3";
14445 device[5] = devchar;
14447 suppress_error = 0;
14448 r = guestfs_pvcreate (g, device);
14453 char volgroup[] = "VG1";
14454 char physvols_0[] = "/dev/sda1";
14455 physvols_0[5] = devchar;
14456 char physvols_1[] = "/dev/sda2";
14457 physvols_1[5] = devchar;
14458 char *physvols[] = {
14464 suppress_error = 0;
14465 r = guestfs_vgcreate (g, volgroup, physvols);
14470 char volgroup[] = "VG2";
14471 char physvols_0[] = "/dev/sda3";
14472 physvols_0[5] = devchar;
14473 char *physvols[] = {
14478 suppress_error = 0;
14479 r = guestfs_vgcreate (g, volgroup, physvols);
14484 char logvol[] = "LV1";
14485 char volgroup[] = "VG1";
14487 suppress_error = 0;
14488 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14493 char logvol[] = "LV2";
14494 char volgroup[] = "VG1";
14496 suppress_error = 0;
14497 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14502 char logvol[] = "LV3";
14503 char volgroup[] = "VG2";
14505 suppress_error = 0;
14506 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14513 suppress_error = 0;
14514 r = guestfs_lvs (g);
14518 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14523 char expected[] = "/dev/VG1/LV1";
14524 if (strcmp (r[0], expected) != 0) {
14525 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14530 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14535 char expected[] = "/dev/VG1/LV2";
14536 if (strcmp (r[1], expected) != 0) {
14537 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14542 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14547 char expected[] = "/dev/VG2/LV3";
14548 if (strcmp (r[2], expected) != 0) {
14549 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14553 if (r[3] != NULL) {
14554 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14558 for (i = 0; r[i] != NULL; ++i)
14565 static int test_vgs_0_skip (void)
14569 str = getenv ("SKIP_TEST_VGS_0");
14570 if (str && strcmp (str, "1") == 0) return 1;
14571 str = getenv ("SKIP_TEST_VGS");
14572 if (str && strcmp (str, "1") == 0) return 1;
14576 static int test_vgs_0 (void)
14578 if (test_vgs_0_skip ()) {
14579 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14583 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14585 char device[] = "/dev/sda";
14586 device[5] = devchar;
14588 suppress_error = 0;
14589 r = guestfs_blockdev_setrw (g, device);
14595 suppress_error = 0;
14596 r = guestfs_umount_all (g);
14602 suppress_error = 0;
14603 r = guestfs_lvm_remove_all (g);
14608 char device[] = "/dev/sda";
14609 device[5] = devchar;
14610 char lines_0[] = ",";
14616 suppress_error = 0;
14617 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14622 char device[] = "/dev/sda1";
14623 device[5] = devchar;
14625 suppress_error = 0;
14626 r = guestfs_pvcreate (g, device);
14631 char volgroup[] = "VG";
14632 char physvols_0[] = "/dev/sda1";
14633 physvols_0[5] = devchar;
14634 char *physvols[] = {
14639 suppress_error = 0;
14640 r = guestfs_vgcreate (g, volgroup, physvols);
14645 char logvol[] = "LV";
14646 char volgroup[] = "VG";
14648 suppress_error = 0;
14649 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14654 char fstype[] = "ext2";
14655 char device[] = "/dev/VG/LV";
14657 suppress_error = 0;
14658 r = guestfs_mkfs (g, fstype, device);
14663 char device[] = "/dev/VG/LV";
14664 char mountpoint[] = "/";
14666 suppress_error = 0;
14667 r = guestfs_mount (g, device, mountpoint);
14671 /* TestOutputList for vgs (0) */
14675 suppress_error = 0;
14676 r = guestfs_vgs (g);
14680 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14685 char expected[] = "VG";
14686 if (strcmp (r[0], expected) != 0) {
14687 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14691 if (r[1] != NULL) {
14692 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14696 for (i = 0; r[i] != NULL; ++i)
14703 static int test_vgs_1_skip (void)
14707 str = getenv ("SKIP_TEST_VGS_1");
14708 if (str && strcmp (str, "1") == 0) return 1;
14709 str = getenv ("SKIP_TEST_VGS");
14710 if (str && strcmp (str, "1") == 0) return 1;
14714 static int test_vgs_1 (void)
14716 if (test_vgs_1_skip ()) {
14717 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14721 /* InitNone|InitEmpty for test_vgs_1 */
14723 char device[] = "/dev/sda";
14724 device[5] = devchar;
14726 suppress_error = 0;
14727 r = guestfs_blockdev_setrw (g, device);
14733 suppress_error = 0;
14734 r = guestfs_umount_all (g);
14740 suppress_error = 0;
14741 r = guestfs_lvm_remove_all (g);
14745 /* TestOutputList for vgs (1) */
14747 char device[] = "/dev/sda";
14748 device[5] = devchar;
14749 char lines_0[] = ",10";
14750 char lines_1[] = ",20";
14751 char lines_2[] = ",";
14759 suppress_error = 0;
14760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14765 char device[] = "/dev/sda1";
14766 device[5] = devchar;
14768 suppress_error = 0;
14769 r = guestfs_pvcreate (g, device);
14774 char device[] = "/dev/sda2";
14775 device[5] = devchar;
14777 suppress_error = 0;
14778 r = guestfs_pvcreate (g, device);
14783 char device[] = "/dev/sda3";
14784 device[5] = devchar;
14786 suppress_error = 0;
14787 r = guestfs_pvcreate (g, device);
14792 char volgroup[] = "VG1";
14793 char physvols_0[] = "/dev/sda1";
14794 physvols_0[5] = devchar;
14795 char physvols_1[] = "/dev/sda2";
14796 physvols_1[5] = devchar;
14797 char *physvols[] = {
14803 suppress_error = 0;
14804 r = guestfs_vgcreate (g, volgroup, physvols);
14809 char volgroup[] = "VG2";
14810 char physvols_0[] = "/dev/sda3";
14811 physvols_0[5] = devchar;
14812 char *physvols[] = {
14817 suppress_error = 0;
14818 r = guestfs_vgcreate (g, volgroup, physvols);
14825 suppress_error = 0;
14826 r = guestfs_vgs (g);
14830 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14835 char expected[] = "VG1";
14836 if (strcmp (r[0], expected) != 0) {
14837 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14842 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14847 char expected[] = "VG2";
14848 if (strcmp (r[1], expected) != 0) {
14849 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14853 if (r[2] != NULL) {
14854 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14858 for (i = 0; r[i] != NULL; ++i)
14865 static int test_pvs_0_skip (void)
14869 str = getenv ("SKIP_TEST_PVS_0");
14870 if (str && strcmp (str, "1") == 0) return 1;
14871 str = getenv ("SKIP_TEST_PVS");
14872 if (str && strcmp (str, "1") == 0) return 1;
14876 static int test_pvs_0 (void)
14878 if (test_pvs_0_skip ()) {
14879 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14883 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14885 char device[] = "/dev/sda";
14886 device[5] = devchar;
14888 suppress_error = 0;
14889 r = guestfs_blockdev_setrw (g, device);
14895 suppress_error = 0;
14896 r = guestfs_umount_all (g);
14902 suppress_error = 0;
14903 r = guestfs_lvm_remove_all (g);
14908 char device[] = "/dev/sda";
14909 device[5] = devchar;
14910 char lines_0[] = ",";
14916 suppress_error = 0;
14917 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14922 char device[] = "/dev/sda1";
14923 device[5] = devchar;
14925 suppress_error = 0;
14926 r = guestfs_pvcreate (g, device);
14931 char volgroup[] = "VG";
14932 char physvols_0[] = "/dev/sda1";
14933 physvols_0[5] = devchar;
14934 char *physvols[] = {
14939 suppress_error = 0;
14940 r = guestfs_vgcreate (g, volgroup, physvols);
14945 char logvol[] = "LV";
14946 char volgroup[] = "VG";
14948 suppress_error = 0;
14949 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14954 char fstype[] = "ext2";
14955 char device[] = "/dev/VG/LV";
14957 suppress_error = 0;
14958 r = guestfs_mkfs (g, fstype, device);
14963 char device[] = "/dev/VG/LV";
14964 char mountpoint[] = "/";
14966 suppress_error = 0;
14967 r = guestfs_mount (g, device, mountpoint);
14971 /* TestOutputList for pvs (0) */
14975 suppress_error = 0;
14976 r = guestfs_pvs (g);
14980 fprintf (stderr, "test_pvs_0: short list returned from command\n");
14985 char expected[] = "/dev/sda1";
14986 expected[5] = devchar;
14987 if (strcmp (r[0], expected) != 0) {
14988 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14992 if (r[1] != NULL) {
14993 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
14997 for (i = 0; r[i] != NULL; ++i)
15004 static int test_pvs_1_skip (void)
15008 str = getenv ("SKIP_TEST_PVS_1");
15009 if (str && strcmp (str, "1") == 0) return 1;
15010 str = getenv ("SKIP_TEST_PVS");
15011 if (str && strcmp (str, "1") == 0) return 1;
15015 static int test_pvs_1 (void)
15017 if (test_pvs_1_skip ()) {
15018 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15022 /* InitNone|InitEmpty for test_pvs_1 */
15024 char device[] = "/dev/sda";
15025 device[5] = devchar;
15027 suppress_error = 0;
15028 r = guestfs_blockdev_setrw (g, device);
15034 suppress_error = 0;
15035 r = guestfs_umount_all (g);
15041 suppress_error = 0;
15042 r = guestfs_lvm_remove_all (g);
15046 /* TestOutputList for pvs (1) */
15048 char device[] = "/dev/sda";
15049 device[5] = devchar;
15050 char lines_0[] = ",10";
15051 char lines_1[] = ",20";
15052 char lines_2[] = ",";
15060 suppress_error = 0;
15061 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15066 char device[] = "/dev/sda1";
15067 device[5] = devchar;
15069 suppress_error = 0;
15070 r = guestfs_pvcreate (g, device);
15075 char device[] = "/dev/sda2";
15076 device[5] = devchar;
15078 suppress_error = 0;
15079 r = guestfs_pvcreate (g, device);
15084 char device[] = "/dev/sda3";
15085 device[5] = devchar;
15087 suppress_error = 0;
15088 r = guestfs_pvcreate (g, device);
15095 suppress_error = 0;
15096 r = guestfs_pvs (g);
15100 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15105 char expected[] = "/dev/sda1";
15106 expected[5] = devchar;
15107 if (strcmp (r[0], expected) != 0) {
15108 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15113 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15118 char expected[] = "/dev/sda2";
15119 expected[5] = devchar;
15120 if (strcmp (r[1], expected) != 0) {
15121 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15126 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15131 char expected[] = "/dev/sda3";
15132 expected[5] = devchar;
15133 if (strcmp (r[2], expected) != 0) {
15134 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15138 if (r[3] != NULL) {
15139 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15143 for (i = 0; r[i] != NULL; ++i)
15150 static int test_list_partitions_0_skip (void)
15154 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15155 if (str && strcmp (str, "1") == 0) return 1;
15156 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15157 if (str && strcmp (str, "1") == 0) return 1;
15161 static int test_list_partitions_0 (void)
15163 if (test_list_partitions_0_skip ()) {
15164 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15168 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15170 char device[] = "/dev/sda";
15171 device[5] = devchar;
15173 suppress_error = 0;
15174 r = guestfs_blockdev_setrw (g, device);
15180 suppress_error = 0;
15181 r = guestfs_umount_all (g);
15187 suppress_error = 0;
15188 r = guestfs_lvm_remove_all (g);
15193 char device[] = "/dev/sda";
15194 device[5] = devchar;
15195 char lines_0[] = ",";
15201 suppress_error = 0;
15202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15207 char fstype[] = "ext2";
15208 char device[] = "/dev/sda1";
15209 device[5] = devchar;
15211 suppress_error = 0;
15212 r = guestfs_mkfs (g, fstype, device);
15217 char device[] = "/dev/sda1";
15218 device[5] = devchar;
15219 char mountpoint[] = "/";
15221 suppress_error = 0;
15222 r = guestfs_mount (g, device, mountpoint);
15226 /* TestOutputList for list_partitions (0) */
15230 suppress_error = 0;
15231 r = guestfs_list_partitions (g);
15235 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15240 char expected[] = "/dev/sda1";
15241 expected[5] = devchar;
15242 if (strcmp (r[0], expected) != 0) {
15243 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15247 if (r[1] != NULL) {
15248 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15252 for (i = 0; r[i] != NULL; ++i)
15259 static int test_list_partitions_1_skip (void)
15263 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15264 if (str && strcmp (str, "1") == 0) return 1;
15265 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15266 if (str && strcmp (str, "1") == 0) return 1;
15270 static int test_list_partitions_1 (void)
15272 if (test_list_partitions_1_skip ()) {
15273 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15277 /* InitNone|InitEmpty for test_list_partitions_1 */
15279 char device[] = "/dev/sda";
15280 device[5] = devchar;
15282 suppress_error = 0;
15283 r = guestfs_blockdev_setrw (g, device);
15289 suppress_error = 0;
15290 r = guestfs_umount_all (g);
15296 suppress_error = 0;
15297 r = guestfs_lvm_remove_all (g);
15301 /* TestOutputList for list_partitions (1) */
15303 char device[] = "/dev/sda";
15304 device[5] = devchar;
15305 char lines_0[] = ",10";
15306 char lines_1[] = ",20";
15307 char lines_2[] = ",";
15315 suppress_error = 0;
15316 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15323 suppress_error = 0;
15324 r = guestfs_list_partitions (g);
15328 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15333 char expected[] = "/dev/sda1";
15334 expected[5] = devchar;
15335 if (strcmp (r[0], expected) != 0) {
15336 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15341 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15346 char expected[] = "/dev/sda2";
15347 expected[5] = devchar;
15348 if (strcmp (r[1], expected) != 0) {
15349 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15354 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15359 char expected[] = "/dev/sda3";
15360 expected[5] = devchar;
15361 if (strcmp (r[2], expected) != 0) {
15362 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15366 if (r[3] != NULL) {
15367 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15371 for (i = 0; r[i] != NULL; ++i)
15378 static int test_list_devices_0_skip (void)
15382 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15383 if (str && strcmp (str, "1") == 0) return 1;
15384 str = getenv ("SKIP_TEST_LIST_DEVICES");
15385 if (str && strcmp (str, "1") == 0) return 1;
15389 static int test_list_devices_0 (void)
15391 if (test_list_devices_0_skip ()) {
15392 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15396 /* InitNone|InitEmpty for test_list_devices_0 */
15398 char device[] = "/dev/sda";
15399 device[5] = devchar;
15401 suppress_error = 0;
15402 r = guestfs_blockdev_setrw (g, device);
15408 suppress_error = 0;
15409 r = guestfs_umount_all (g);
15415 suppress_error = 0;
15416 r = guestfs_lvm_remove_all (g);
15420 /* TestOutputList for list_devices (0) */
15424 suppress_error = 0;
15425 r = guestfs_list_devices (g);
15429 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15434 char expected[] = "/dev/sda";
15435 expected[5] = devchar;
15436 if (strcmp (r[0], expected) != 0) {
15437 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15442 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15447 char expected[] = "/dev/sdb";
15448 expected[5] = devchar;
15449 if (strcmp (r[1], expected) != 0) {
15450 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15455 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15460 char expected[] = "/dev/sdc";
15461 expected[5] = devchar;
15462 if (strcmp (r[2], expected) != 0) {
15463 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15468 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15473 char expected[] = "/dev/sdd";
15474 expected[5] = devchar;
15475 if (strcmp (r[3], expected) != 0) {
15476 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15480 if (r[4] != NULL) {
15481 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15485 for (i = 0; r[i] != NULL; ++i)
15492 static int test_ls_0_skip (void)
15496 str = getenv ("SKIP_TEST_LS_0");
15497 if (str && strcmp (str, "1") == 0) return 1;
15498 str = getenv ("SKIP_TEST_LS");
15499 if (str && strcmp (str, "1") == 0) return 1;
15503 static int test_ls_0 (void)
15505 if (test_ls_0_skip ()) {
15506 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15510 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15512 char device[] = "/dev/sda";
15513 device[5] = devchar;
15515 suppress_error = 0;
15516 r = guestfs_blockdev_setrw (g, device);
15522 suppress_error = 0;
15523 r = guestfs_umount_all (g);
15529 suppress_error = 0;
15530 r = guestfs_lvm_remove_all (g);
15535 char device[] = "/dev/sda";
15536 device[5] = devchar;
15537 char lines_0[] = ",";
15543 suppress_error = 0;
15544 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15549 char fstype[] = "ext2";
15550 char device[] = "/dev/sda1";
15551 device[5] = devchar;
15553 suppress_error = 0;
15554 r = guestfs_mkfs (g, fstype, device);
15559 char device[] = "/dev/sda1";
15560 device[5] = devchar;
15561 char mountpoint[] = "/";
15563 suppress_error = 0;
15564 r = guestfs_mount (g, device, mountpoint);
15568 /* TestOutputList for ls (0) */
15570 char path[] = "/new";
15572 suppress_error = 0;
15573 r = guestfs_touch (g, path);
15578 char path[] = "/newer";
15580 suppress_error = 0;
15581 r = guestfs_touch (g, path);
15586 char path[] = "/newest";
15588 suppress_error = 0;
15589 r = guestfs_touch (g, path);
15594 char directory[] = "/";
15597 suppress_error = 0;
15598 r = guestfs_ls (g, directory);
15602 fprintf (stderr, "test_ls_0: short list returned from command\n");
15607 char expected[] = "lost+found";
15608 if (strcmp (r[0], expected) != 0) {
15609 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15614 fprintf (stderr, "test_ls_0: short list returned from command\n");
15619 char expected[] = "new";
15620 if (strcmp (r[1], expected) != 0) {
15621 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15626 fprintf (stderr, "test_ls_0: short list returned from command\n");
15631 char expected[] = "newer";
15632 if (strcmp (r[2], expected) != 0) {
15633 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15638 fprintf (stderr, "test_ls_0: short list returned from command\n");
15643 char expected[] = "newest";
15644 if (strcmp (r[3], expected) != 0) {
15645 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15649 if (r[4] != NULL) {
15650 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15654 for (i = 0; r[i] != NULL; ++i)
15661 static int test_cat_0_skip (void)
15665 str = getenv ("SKIP_TEST_CAT_0");
15666 if (str && strcmp (str, "1") == 0) return 1;
15667 str = getenv ("SKIP_TEST_CAT");
15668 if (str && strcmp (str, "1") == 0) return 1;
15672 static int test_cat_0 (void)
15674 if (test_cat_0_skip ()) {
15675 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15679 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15681 char device[] = "/dev/sda";
15682 device[5] = devchar;
15684 suppress_error = 0;
15685 r = guestfs_blockdev_setrw (g, device);
15691 suppress_error = 0;
15692 r = guestfs_umount_all (g);
15698 suppress_error = 0;
15699 r = guestfs_lvm_remove_all (g);
15704 char device[] = "/dev/sda";
15705 device[5] = devchar;
15706 char lines_0[] = ",";
15712 suppress_error = 0;
15713 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15718 char fstype[] = "ext2";
15719 char device[] = "/dev/sda1";
15720 device[5] = devchar;
15722 suppress_error = 0;
15723 r = guestfs_mkfs (g, fstype, device);
15728 char device[] = "/dev/sda1";
15729 device[5] = devchar;
15730 char mountpoint[] = "/";
15732 suppress_error = 0;
15733 r = guestfs_mount (g, device, mountpoint);
15737 /* TestOutput for cat (0) */
15738 char expected[] = "new file contents";
15740 char path[] = "/new";
15741 char content[] = "new file contents";
15743 suppress_error = 0;
15744 r = guestfs_write_file (g, path, content, 0);
15749 char path[] = "/new";
15751 suppress_error = 0;
15752 r = guestfs_cat (g, path);
15755 if (strcmp (r, expected) != 0) {
15756 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15764 static int test_touch_0_skip (void)
15768 str = getenv ("SKIP_TEST_TOUCH_0");
15769 if (str && strcmp (str, "1") == 0) return 1;
15770 str = getenv ("SKIP_TEST_TOUCH");
15771 if (str && strcmp (str, "1") == 0) return 1;
15775 static int test_touch_0 (void)
15777 if (test_touch_0_skip ()) {
15778 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15782 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15784 char device[] = "/dev/sda";
15785 device[5] = devchar;
15787 suppress_error = 0;
15788 r = guestfs_blockdev_setrw (g, device);
15794 suppress_error = 0;
15795 r = guestfs_umount_all (g);
15801 suppress_error = 0;
15802 r = guestfs_lvm_remove_all (g);
15807 char device[] = "/dev/sda";
15808 device[5] = devchar;
15809 char lines_0[] = ",";
15815 suppress_error = 0;
15816 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15821 char fstype[] = "ext2";
15822 char device[] = "/dev/sda1";
15823 device[5] = devchar;
15825 suppress_error = 0;
15826 r = guestfs_mkfs (g, fstype, device);
15831 char device[] = "/dev/sda1";
15832 device[5] = devchar;
15833 char mountpoint[] = "/";
15835 suppress_error = 0;
15836 r = guestfs_mount (g, device, mountpoint);
15840 /* TestOutputTrue for touch (0) */
15842 char path[] = "/new";
15844 suppress_error = 0;
15845 r = guestfs_touch (g, path);
15850 char path[] = "/new";
15852 suppress_error = 0;
15853 r = guestfs_exists (g, path);
15857 fprintf (stderr, "test_touch_0: expected true, got false\n");
15864 static int test_sync_0_skip (void)
15868 str = getenv ("SKIP_TEST_SYNC_0");
15869 if (str && strcmp (str, "1") == 0) return 1;
15870 str = getenv ("SKIP_TEST_SYNC");
15871 if (str && strcmp (str, "1") == 0) return 1;
15875 static int test_sync_0 (void)
15877 if (test_sync_0_skip ()) {
15878 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15882 /* InitNone|InitEmpty for test_sync_0 */
15884 char device[] = "/dev/sda";
15885 device[5] = devchar;
15887 suppress_error = 0;
15888 r = guestfs_blockdev_setrw (g, device);
15894 suppress_error = 0;
15895 r = guestfs_umount_all (g);
15901 suppress_error = 0;
15902 r = guestfs_lvm_remove_all (g);
15906 /* TestRun for sync (0) */
15909 suppress_error = 0;
15910 r = guestfs_sync (g);
15917 static int test_mount_0_skip (void)
15921 str = getenv ("SKIP_TEST_MOUNT_0");
15922 if (str && strcmp (str, "1") == 0) return 1;
15923 str = getenv ("SKIP_TEST_MOUNT");
15924 if (str && strcmp (str, "1") == 0) return 1;
15928 static int test_mount_0 (void)
15930 if (test_mount_0_skip ()) {
15931 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15935 /* InitNone|InitEmpty for test_mount_0 */
15937 char device[] = "/dev/sda";
15938 device[5] = devchar;
15940 suppress_error = 0;
15941 r = guestfs_blockdev_setrw (g, device);
15947 suppress_error = 0;
15948 r = guestfs_umount_all (g);
15954 suppress_error = 0;
15955 r = guestfs_lvm_remove_all (g);
15959 /* TestOutput for mount (0) */
15960 char expected[] = "new file contents";
15962 char device[] = "/dev/sda";
15963 device[5] = devchar;
15964 char lines_0[] = ",";
15970 suppress_error = 0;
15971 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15976 char fstype[] = "ext2";
15977 char device[] = "/dev/sda1";
15978 device[5] = devchar;
15980 suppress_error = 0;
15981 r = guestfs_mkfs (g, fstype, device);
15986 char device[] = "/dev/sda1";
15987 device[5] = devchar;
15988 char mountpoint[] = "/";
15990 suppress_error = 0;
15991 r = guestfs_mount (g, device, mountpoint);
15996 char path[] = "/new";
15997 char content[] = "new file contents";
15999 suppress_error = 0;
16000 r = guestfs_write_file (g, path, content, 0);
16005 char path[] = "/new";
16007 suppress_error = 0;
16008 r = guestfs_cat (g, path);
16011 if (strcmp (r, expected) != 0) {
16012 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16020 int main (int argc, char *argv[])
16024 const char *filename;
16026 int nr_tests, test_num = 0;
16029 no_test_warnings ();
16031 g = guestfs_create ();
16033 printf ("guestfs_create FAILED\n");
16037 guestfs_set_error_handler (g, print_error, NULL);
16039 guestfs_set_path (g, "../appliance");
16041 filename = "test1.img";
16042 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16047 if (lseek (fd, 524288000, SEEK_SET) == -1) {
16053 if (write (fd, &c, 1) == -1) {
16059 if (close (fd) == -1) {
16064 if (guestfs_add_drive (g, filename) == -1) {
16065 printf ("guestfs_add_drive %s FAILED\n", filename);
16069 filename = "test2.img";
16070 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16075 if (lseek (fd, 52428800, SEEK_SET) == -1) {
16081 if (write (fd, &c, 1) == -1) {
16087 if (close (fd) == -1) {
16092 if (guestfs_add_drive (g, filename) == -1) {
16093 printf ("guestfs_add_drive %s FAILED\n", filename);
16097 filename = "test3.img";
16098 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16103 if (lseek (fd, 10485760, SEEK_SET) == -1) {
16109 if (write (fd, &c, 1) == -1) {
16115 if (close (fd) == -1) {
16120 if (guestfs_add_drive (g, filename) == -1) {
16121 printf ("guestfs_add_drive %s FAILED\n", filename);
16125 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16126 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16130 if (guestfs_launch (g) == -1) {
16131 printf ("guestfs_launch FAILED\n");
16134 if (guestfs_wait_ready (g) == -1) {
16135 printf ("guestfs_wait_ready FAILED\n");
16139 /* Detect if the appliance uses /dev/sd* or /dev/hd* in device
16140 * names. This changed between RHEL 5 and RHEL 6 so we have to
16143 devs = guestfs_list_devices (g);
16144 if (devs == NULL || devs[0] == NULL) {
16145 printf ("guestfs_list_devices FAILED\n");
16148 if (strncmp (devs[0], "/dev/sd", 7) == 0)
16150 else if (strncmp (devs[0], "/dev/hd", 7) == 0)
16153 printf ("guestfs_list_devices returned unexpected string '%s'\n",
16157 for (i = 0; devs[i] != NULL; ++i)
16164 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16165 if (test_find_0 () == -1) {
16166 printf ("test_find_0 FAILED\n");
16170 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16171 if (test_find_1 () == -1) {
16172 printf ("test_find_1 FAILED\n");
16176 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16177 if (test_find_2 () == -1) {
16178 printf ("test_find_2 FAILED\n");
16182 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16183 if (test_lvresize_0 () == -1) {
16184 printf ("test_lvresize_0 FAILED\n");
16188 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16189 if (test_zerofree_0 () == -1) {
16190 printf ("test_zerofree_0 FAILED\n");
16194 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16195 if (test_hexdump_0 () == -1) {
16196 printf ("test_hexdump_0 FAILED\n");
16200 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16201 if (test_strings_e_0 () == -1) {
16202 printf ("test_strings_e_0 FAILED\n");
16206 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16207 if (test_strings_e_1 () == -1) {
16208 printf ("test_strings_e_1 FAILED\n");
16212 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16213 if (test_strings_0 () == -1) {
16214 printf ("test_strings_0 FAILED\n");
16218 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16219 if (test_strings_1 () == -1) {
16220 printf ("test_strings_1 FAILED\n");
16224 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16225 if (test_equal_0 () == -1) {
16226 printf ("test_equal_0 FAILED\n");
16230 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16231 if (test_equal_1 () == -1) {
16232 printf ("test_equal_1 FAILED\n");
16236 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16237 if (test_equal_2 () == -1) {
16238 printf ("test_equal_2 FAILED\n");
16242 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16243 if (test_ping_daemon_0 () == -1) {
16244 printf ("test_ping_daemon_0 FAILED\n");
16248 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16249 if (test_dmesg_0 () == -1) {
16250 printf ("test_dmesg_0 FAILED\n");
16254 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16255 if (test_drop_caches_0 () == -1) {
16256 printf ("test_drop_caches_0 FAILED\n");
16260 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16261 if (test_mv_0 () == -1) {
16262 printf ("test_mv_0 FAILED\n");
16266 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16267 if (test_mv_1 () == -1) {
16268 printf ("test_mv_1 FAILED\n");
16272 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16273 if (test_cp_a_0 () == -1) {
16274 printf ("test_cp_a_0 FAILED\n");
16278 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16279 if (test_cp_0 () == -1) {
16280 printf ("test_cp_0 FAILED\n");
16284 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16285 if (test_cp_1 () == -1) {
16286 printf ("test_cp_1 FAILED\n");
16290 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16291 if (test_cp_2 () == -1) {
16292 printf ("test_cp_2 FAILED\n");
16296 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16297 if (test_grub_install_0 () == -1) {
16298 printf ("test_grub_install_0 FAILED\n");
16302 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16303 if (test_zero_0 () == -1) {
16304 printf ("test_zero_0 FAILED\n");
16308 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16309 if (test_fsck_0 () == -1) {
16310 printf ("test_fsck_0 FAILED\n");
16314 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16315 if (test_fsck_1 () == -1) {
16316 printf ("test_fsck_1 FAILED\n");
16320 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16321 if (test_set_e2uuid_0 () == -1) {
16322 printf ("test_set_e2uuid_0 FAILED\n");
16326 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16327 if (test_set_e2uuid_1 () == -1) {
16328 printf ("test_set_e2uuid_1 FAILED\n");
16332 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16333 if (test_set_e2uuid_2 () == -1) {
16334 printf ("test_set_e2uuid_2 FAILED\n");
16338 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16339 if (test_set_e2uuid_3 () == -1) {
16340 printf ("test_set_e2uuid_3 FAILED\n");
16344 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16345 if (test_set_e2label_0 () == -1) {
16346 printf ("test_set_e2label_0 FAILED\n");
16350 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16351 if (test_pvremove_0 () == -1) {
16352 printf ("test_pvremove_0 FAILED\n");
16356 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16357 if (test_pvremove_1 () == -1) {
16358 printf ("test_pvremove_1 FAILED\n");
16362 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16363 if (test_pvremove_2 () == -1) {
16364 printf ("test_pvremove_2 FAILED\n");
16368 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16369 if (test_vgremove_0 () == -1) {
16370 printf ("test_vgremove_0 FAILED\n");
16374 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16375 if (test_vgremove_1 () == -1) {
16376 printf ("test_vgremove_1 FAILED\n");
16380 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16381 if (test_lvremove_0 () == -1) {
16382 printf ("test_lvremove_0 FAILED\n");
16386 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16387 if (test_lvremove_1 () == -1) {
16388 printf ("test_lvremove_1 FAILED\n");
16392 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16393 if (test_lvremove_2 () == -1) {
16394 printf ("test_lvremove_2 FAILED\n");
16398 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16399 if (test_mount_ro_0 () == -1) {
16400 printf ("test_mount_ro_0 FAILED\n");
16404 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16405 if (test_mount_ro_1 () == -1) {
16406 printf ("test_mount_ro_1 FAILED\n");
16410 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16411 if (test_tgz_in_0 () == -1) {
16412 printf ("test_tgz_in_0 FAILED\n");
16416 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16417 if (test_tar_in_0 () == -1) {
16418 printf ("test_tar_in_0 FAILED\n");
16422 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16423 if (test_checksum_0 () == -1) {
16424 printf ("test_checksum_0 FAILED\n");
16428 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16429 if (test_checksum_1 () == -1) {
16430 printf ("test_checksum_1 FAILED\n");
16434 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16435 if (test_checksum_2 () == -1) {
16436 printf ("test_checksum_2 FAILED\n");
16440 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16441 if (test_checksum_3 () == -1) {
16442 printf ("test_checksum_3 FAILED\n");
16446 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16447 if (test_checksum_4 () == -1) {
16448 printf ("test_checksum_4 FAILED\n");
16452 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16453 if (test_checksum_5 () == -1) {
16454 printf ("test_checksum_5 FAILED\n");
16458 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16459 if (test_checksum_6 () == -1) {
16460 printf ("test_checksum_6 FAILED\n");
16464 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16465 if (test_checksum_7 () == -1) {
16466 printf ("test_checksum_7 FAILED\n");
16470 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16471 if (test_checksum_8 () == -1) {
16472 printf ("test_checksum_8 FAILED\n");
16476 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16477 if (test_download_0 () == -1) {
16478 printf ("test_download_0 FAILED\n");
16482 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16483 if (test_upload_0 () == -1) {
16484 printf ("test_upload_0 FAILED\n");
16488 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16489 if (test_blockdev_rereadpt_0 () == -1) {
16490 printf ("test_blockdev_rereadpt_0 FAILED\n");
16494 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16495 if (test_blockdev_flushbufs_0 () == -1) {
16496 printf ("test_blockdev_flushbufs_0 FAILED\n");
16500 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16501 if (test_blockdev_getsize64_0 () == -1) {
16502 printf ("test_blockdev_getsize64_0 FAILED\n");
16506 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16507 if (test_blockdev_getsz_0 () == -1) {
16508 printf ("test_blockdev_getsz_0 FAILED\n");
16512 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16513 if (test_blockdev_getbsz_0 () == -1) {
16514 printf ("test_blockdev_getbsz_0 FAILED\n");
16518 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16519 if (test_blockdev_getss_0 () == -1) {
16520 printf ("test_blockdev_getss_0 FAILED\n");
16524 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16525 if (test_blockdev_getro_0 () == -1) {
16526 printf ("test_blockdev_getro_0 FAILED\n");
16530 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16531 if (test_blockdev_setrw_0 () == -1) {
16532 printf ("test_blockdev_setrw_0 FAILED\n");
16536 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16537 if (test_blockdev_setro_0 () == -1) {
16538 printf ("test_blockdev_setro_0 FAILED\n");
16542 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16543 if (test_statvfs_0 () == -1) {
16544 printf ("test_statvfs_0 FAILED\n");
16548 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16549 if (test_lstat_0 () == -1) {
16550 printf ("test_lstat_0 FAILED\n");
16554 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16555 if (test_stat_0 () == -1) {
16556 printf ("test_stat_0 FAILED\n");
16560 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16561 if (test_command_lines_0 () == -1) {
16562 printf ("test_command_lines_0 FAILED\n");
16566 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16567 if (test_command_lines_1 () == -1) {
16568 printf ("test_command_lines_1 FAILED\n");
16572 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16573 if (test_command_lines_2 () == -1) {
16574 printf ("test_command_lines_2 FAILED\n");
16578 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16579 if (test_command_lines_3 () == -1) {
16580 printf ("test_command_lines_3 FAILED\n");
16584 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16585 if (test_command_lines_4 () == -1) {
16586 printf ("test_command_lines_4 FAILED\n");
16590 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16591 if (test_command_lines_5 () == -1) {
16592 printf ("test_command_lines_5 FAILED\n");
16596 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16597 if (test_command_lines_6 () == -1) {
16598 printf ("test_command_lines_6 FAILED\n");
16602 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16603 if (test_command_lines_7 () == -1) {
16604 printf ("test_command_lines_7 FAILED\n");
16608 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16609 if (test_command_lines_8 () == -1) {
16610 printf ("test_command_lines_8 FAILED\n");
16614 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16615 if (test_command_lines_9 () == -1) {
16616 printf ("test_command_lines_9 FAILED\n");
16620 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16621 if (test_command_lines_10 () == -1) {
16622 printf ("test_command_lines_10 FAILED\n");
16626 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16627 if (test_command_0 () == -1) {
16628 printf ("test_command_0 FAILED\n");
16632 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16633 if (test_command_1 () == -1) {
16634 printf ("test_command_1 FAILED\n");
16638 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16639 if (test_command_2 () == -1) {
16640 printf ("test_command_2 FAILED\n");
16644 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16645 if (test_command_3 () == -1) {
16646 printf ("test_command_3 FAILED\n");
16650 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16651 if (test_command_4 () == -1) {
16652 printf ("test_command_4 FAILED\n");
16656 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16657 if (test_command_5 () == -1) {
16658 printf ("test_command_5 FAILED\n");
16662 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16663 if (test_command_6 () == -1) {
16664 printf ("test_command_6 FAILED\n");
16668 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16669 if (test_command_7 () == -1) {
16670 printf ("test_command_7 FAILED\n");
16674 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16675 if (test_command_8 () == -1) {
16676 printf ("test_command_8 FAILED\n");
16680 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16681 if (test_command_9 () == -1) {
16682 printf ("test_command_9 FAILED\n");
16686 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16687 if (test_command_10 () == -1) {
16688 printf ("test_command_10 FAILED\n");
16692 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16693 if (test_command_11 () == -1) {
16694 printf ("test_command_11 FAILED\n");
16698 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16699 if (test_file_0 () == -1) {
16700 printf ("test_file_0 FAILED\n");
16704 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16705 if (test_file_1 () == -1) {
16706 printf ("test_file_1 FAILED\n");
16710 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16711 if (test_file_2 () == -1) {
16712 printf ("test_file_2 FAILED\n");
16716 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16717 if (test_umount_all_0 () == -1) {
16718 printf ("test_umount_all_0 FAILED\n");
16722 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16723 if (test_umount_all_1 () == -1) {
16724 printf ("test_umount_all_1 FAILED\n");
16728 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16729 if (test_mounts_0 () == -1) {
16730 printf ("test_mounts_0 FAILED\n");
16734 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16735 if (test_umount_0 () == -1) {
16736 printf ("test_umount_0 FAILED\n");
16740 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16741 if (test_umount_1 () == -1) {
16742 printf ("test_umount_1 FAILED\n");
16746 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16747 if (test_write_file_0 () == -1) {
16748 printf ("test_write_file_0 FAILED\n");
16752 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16753 if (test_write_file_1 () == -1) {
16754 printf ("test_write_file_1 FAILED\n");
16758 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16759 if (test_write_file_2 () == -1) {
16760 printf ("test_write_file_2 FAILED\n");
16764 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16765 if (test_write_file_3 () == -1) {
16766 printf ("test_write_file_3 FAILED\n");
16770 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16771 if (test_write_file_4 () == -1) {
16772 printf ("test_write_file_4 FAILED\n");
16776 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16777 if (test_write_file_5 () == -1) {
16778 printf ("test_write_file_5 FAILED\n");
16782 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16783 if (test_mkfs_0 () == -1) {
16784 printf ("test_mkfs_0 FAILED\n");
16788 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16789 if (test_lvcreate_0 () == -1) {
16790 printf ("test_lvcreate_0 FAILED\n");
16794 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16795 if (test_vgcreate_0 () == -1) {
16796 printf ("test_vgcreate_0 FAILED\n");
16800 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16801 if (test_pvcreate_0 () == -1) {
16802 printf ("test_pvcreate_0 FAILED\n");
16806 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16807 if (test_is_dir_0 () == -1) {
16808 printf ("test_is_dir_0 FAILED\n");
16812 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16813 if (test_is_dir_1 () == -1) {
16814 printf ("test_is_dir_1 FAILED\n");
16818 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16819 if (test_is_file_0 () == -1) {
16820 printf ("test_is_file_0 FAILED\n");
16824 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16825 if (test_is_file_1 () == -1) {
16826 printf ("test_is_file_1 FAILED\n");
16830 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16831 if (test_exists_0 () == -1) {
16832 printf ("test_exists_0 FAILED\n");
16836 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16837 if (test_exists_1 () == -1) {
16838 printf ("test_exists_1 FAILED\n");
16842 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16843 if (test_mkdir_p_0 () == -1) {
16844 printf ("test_mkdir_p_0 FAILED\n");
16848 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16849 if (test_mkdir_p_1 () == -1) {
16850 printf ("test_mkdir_p_1 FAILED\n");
16854 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16855 if (test_mkdir_p_2 () == -1) {
16856 printf ("test_mkdir_p_2 FAILED\n");
16860 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16861 if (test_mkdir_p_3 () == -1) {
16862 printf ("test_mkdir_p_3 FAILED\n");
16866 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16867 if (test_mkdir_p_4 () == -1) {
16868 printf ("test_mkdir_p_4 FAILED\n");
16872 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16873 if (test_mkdir_0 () == -1) {
16874 printf ("test_mkdir_0 FAILED\n");
16878 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16879 if (test_mkdir_1 () == -1) {
16880 printf ("test_mkdir_1 FAILED\n");
16884 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16885 if (test_rm_rf_0 () == -1) {
16886 printf ("test_rm_rf_0 FAILED\n");
16890 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16891 if (test_rmdir_0 () == -1) {
16892 printf ("test_rmdir_0 FAILED\n");
16896 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16897 if (test_rmdir_1 () == -1) {
16898 printf ("test_rmdir_1 FAILED\n");
16902 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16903 if (test_rmdir_2 () == -1) {
16904 printf ("test_rmdir_2 FAILED\n");
16908 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16909 if (test_rm_0 () == -1) {
16910 printf ("test_rm_0 FAILED\n");
16914 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16915 if (test_rm_1 () == -1) {
16916 printf ("test_rm_1 FAILED\n");
16920 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16921 if (test_rm_2 () == -1) {
16922 printf ("test_rm_2 FAILED\n");
16926 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16927 if (test_read_lines_0 () == -1) {
16928 printf ("test_read_lines_0 FAILED\n");
16932 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16933 if (test_read_lines_1 () == -1) {
16934 printf ("test_read_lines_1 FAILED\n");
16938 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16939 if (test_lvs_0 () == -1) {
16940 printf ("test_lvs_0 FAILED\n");
16944 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16945 if (test_lvs_1 () == -1) {
16946 printf ("test_lvs_1 FAILED\n");
16950 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16951 if (test_vgs_0 () == -1) {
16952 printf ("test_vgs_0 FAILED\n");
16956 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
16957 if (test_vgs_1 () == -1) {
16958 printf ("test_vgs_1 FAILED\n");
16962 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
16963 if (test_pvs_0 () == -1) {
16964 printf ("test_pvs_0 FAILED\n");
16968 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
16969 if (test_pvs_1 () == -1) {
16970 printf ("test_pvs_1 FAILED\n");
16974 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
16975 if (test_list_partitions_0 () == -1) {
16976 printf ("test_list_partitions_0 FAILED\n");
16980 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
16981 if (test_list_partitions_1 () == -1) {
16982 printf ("test_list_partitions_1 FAILED\n");
16986 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
16987 if (test_list_devices_0 () == -1) {
16988 printf ("test_list_devices_0 FAILED\n");
16992 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
16993 if (test_ls_0 () == -1) {
16994 printf ("test_ls_0 FAILED\n");
16998 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
16999 if (test_cat_0 () == -1) {
17000 printf ("test_cat_0 FAILED\n");
17004 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17005 if (test_touch_0 () == -1) {
17006 printf ("test_touch_0 FAILED\n");
17010 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17011 if (test_sync_0 () == -1) {
17012 printf ("test_sync_0 FAILED\n");
17016 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17017 if (test_mount_0 () == -1) {
17018 printf ("test_mount_0 FAILED\n");
17023 unlink ("test1.img");
17024 unlink ("test2.img");
17025 unlink ("test3.img");
17028 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);