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 static void print_error (guestfs_h *g, void *data, const char *msg)
37 fprintf (stderr, "%s\n", msg);
40 static void print_strings (char * const * const argv)
44 for (argc = 0; argv[argc] != NULL; ++argc)
45 printf ("\t%s\n", argv[argc]);
49 static void print_table (char * const * const argv)
53 for (i = 0; argv[i] != NULL; i += 2)
54 printf ("%s: %s\n", argv[i], argv[i+1]);
58 static void no_test_warnings (void)
60 fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
61 fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
62 fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
63 fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
64 fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
65 fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_set_memsize\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_get_memsize\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
155 fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
156 fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
157 fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
158 fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
161 static int test_mkswap_U_0_skip (void)
165 str = getenv ("TEST_ONLY");
167 return strstr (str, "mkswap_U") == NULL;
168 str = getenv ("SKIP_TEST_MKSWAP_U_0");
169 if (str && strcmp (str, "1") == 0) return 1;
170 str = getenv ("SKIP_TEST_MKSWAP_U");
171 if (str && strcmp (str, "1") == 0) return 1;
175 static int test_mkswap_U_0 (void)
177 if (test_mkswap_U_0_skip ()) {
178 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_U_0");
182 /* InitNone|InitEmpty for test_mkswap_U_0 */
184 char device[] = "/dev/sda";
187 r = guestfs_blockdev_setrw (g, device);
194 r = guestfs_umount_all (g);
201 r = guestfs_lvm_remove_all (g);
205 /* TestRun for mkswap_U (0) */
207 char device[] = "/dev/sda";
208 char lines_0[] = ",";
215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
220 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
221 char device[] = "/dev/sda1";
224 r = guestfs_mkswap_U (g, uuid, device);
231 static int test_mkswap_L_0_skip (void)
235 str = getenv ("TEST_ONLY");
237 return strstr (str, "mkswap_L") == NULL;
238 str = getenv ("SKIP_TEST_MKSWAP_L_0");
239 if (str && strcmp (str, "1") == 0) return 1;
240 str = getenv ("SKIP_TEST_MKSWAP_L");
241 if (str && strcmp (str, "1") == 0) return 1;
245 static int test_mkswap_L_0 (void)
247 if (test_mkswap_L_0_skip ()) {
248 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_L_0");
252 /* InitNone|InitEmpty for test_mkswap_L_0 */
254 char device[] = "/dev/sda";
257 r = guestfs_blockdev_setrw (g, device);
264 r = guestfs_umount_all (g);
271 r = guestfs_lvm_remove_all (g);
275 /* TestRun for mkswap_L (0) */
277 char device[] = "/dev/sda";
278 char lines_0[] = ",";
285 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
290 char label[] = "hello";
291 char device[] = "/dev/sda1";
294 r = guestfs_mkswap_L (g, label, device);
301 static int test_mkswap_0_skip (void)
305 str = getenv ("TEST_ONLY");
307 return strstr (str, "mkswap") == NULL;
308 str = getenv ("SKIP_TEST_MKSWAP_0");
309 if (str && strcmp (str, "1") == 0) return 1;
310 str = getenv ("SKIP_TEST_MKSWAP");
311 if (str && strcmp (str, "1") == 0) return 1;
315 static int test_mkswap_0 (void)
317 if (test_mkswap_0_skip ()) {
318 printf ("%s skipped (reason: environment variable set)\n", "test_mkswap_0");
322 /* InitNone|InitEmpty for test_mkswap_0 */
324 char device[] = "/dev/sda";
327 r = guestfs_blockdev_setrw (g, device);
334 r = guestfs_umount_all (g);
341 r = guestfs_lvm_remove_all (g);
345 /* TestRun for mkswap (0) */
347 char device[] = "/dev/sda";
348 char lines_0[] = ",";
355 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
360 char device[] = "/dev/sda1";
363 r = guestfs_mkswap (g, device);
370 static int test_initrd_list_0_skip (void)
374 str = getenv ("TEST_ONLY");
376 return strstr (str, "initrd_list") == NULL;
377 str = getenv ("SKIP_TEST_INITRD_LIST_0");
378 if (str && strcmp (str, "1") == 0) return 1;
379 str = getenv ("SKIP_TEST_INITRD_LIST");
380 if (str && strcmp (str, "1") == 0) return 1;
384 static int test_initrd_list_0 (void)
386 if (test_initrd_list_0_skip ()) {
387 printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
391 /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
393 char device[] = "/dev/sda";
396 r = guestfs_blockdev_setrw (g, device);
403 r = guestfs_umount_all (g);
410 r = guestfs_lvm_remove_all (g);
415 char device[] = "/dev/sda";
416 char lines_0[] = ",";
423 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
428 char fstype[] = "ext2";
429 char device[] = "/dev/sda1";
432 r = guestfs_mkfs (g, fstype, device);
437 char device[] = "/dev/sda1";
438 char mountpoint[] = "/";
441 r = guestfs_mount (g, device, mountpoint);
445 /* TestOutputList for initrd_list (0) */
447 char options[] = "ro";
448 char vfstype[] = "squashfs";
449 char device[] = "/dev/sdd";
450 char mountpoint[] = "/";
453 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
458 char path[] = "/initrd";
462 r = guestfs_initrd_list (g, path);
466 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
471 char expected[] = "empty";
472 if (strcmp (r[0], expected) != 0) {
473 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
478 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
483 char expected[] = "known-1";
484 if (strcmp (r[1], expected) != 0) {
485 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
490 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
495 char expected[] = "known-2";
496 if (strcmp (r[2], expected) != 0) {
497 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
502 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
507 char expected[] = "known-3";
508 if (strcmp (r[3], expected) != 0) {
509 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
514 fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
518 for (i = 0; r[i] != NULL; ++i)
525 static int test_du_0_skip (void)
529 str = getenv ("TEST_ONLY");
531 return strstr (str, "du") == NULL;
532 str = getenv ("SKIP_TEST_DU_0");
533 if (str && strcmp (str, "1") == 0) return 1;
534 str = getenv ("SKIP_TEST_DU");
535 if (str && strcmp (str, "1") == 0) return 1;
539 static int test_du_0 (void)
541 if (test_du_0_skip ()) {
542 printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
546 /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
548 char device[] = "/dev/sda";
551 r = guestfs_blockdev_setrw (g, device);
558 r = guestfs_umount_all (g);
565 r = guestfs_lvm_remove_all (g);
570 char device[] = "/dev/sda";
571 char lines_0[] = ",";
578 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
583 char fstype[] = "ext2";
584 char device[] = "/dev/sda1";
587 r = guestfs_mkfs (g, fstype, device);
592 char device[] = "/dev/sda1";
593 char mountpoint[] = "/";
596 r = guestfs_mount (g, device, mountpoint);
600 /* TestOutputInt for du (0) */
605 r = guestfs_mkdir (g, path);
613 r = guestfs_du (g, path);
617 fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r);
624 static int test_tail_n_0_skip (void)
628 str = getenv ("TEST_ONLY");
630 return strstr (str, "tail_n") == NULL;
631 str = getenv ("SKIP_TEST_TAIL_N_0");
632 if (str && strcmp (str, "1") == 0) return 1;
633 str = getenv ("SKIP_TEST_TAIL_N");
634 if (str && strcmp (str, "1") == 0) return 1;
638 static int test_tail_n_0 (void)
640 if (test_tail_n_0_skip ()) {
641 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
645 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
647 char device[] = "/dev/sda";
650 r = guestfs_blockdev_setrw (g, device);
657 r = guestfs_umount_all (g);
664 r = guestfs_lvm_remove_all (g);
669 char device[] = "/dev/sda";
670 char lines_0[] = ",";
677 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
682 char fstype[] = "ext2";
683 char device[] = "/dev/sda1";
686 r = guestfs_mkfs (g, fstype, device);
691 char device[] = "/dev/sda1";
692 char mountpoint[] = "/";
695 r = guestfs_mount (g, device, mountpoint);
699 /* TestOutputList for tail_n (0) */
701 char options[] = "ro";
702 char vfstype[] = "squashfs";
703 char device[] = "/dev/sdd";
704 char mountpoint[] = "/";
707 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
712 char path[] = "/10klines";
716 r = guestfs_tail_n (g, 3, path);
720 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
725 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
726 if (strcmp (r[0], expected) != 0) {
727 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
732 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
737 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
738 if (strcmp (r[1], expected) != 0) {
739 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
744 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
749 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
750 if (strcmp (r[2], expected) != 0) {
751 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
756 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
760 for (i = 0; r[i] != NULL; ++i)
767 static int test_tail_n_1_skip (void)
771 str = getenv ("TEST_ONLY");
773 return strstr (str, "tail_n") == NULL;
774 str = getenv ("SKIP_TEST_TAIL_N_1");
775 if (str && strcmp (str, "1") == 0) return 1;
776 str = getenv ("SKIP_TEST_TAIL_N");
777 if (str && strcmp (str, "1") == 0) return 1;
781 static int test_tail_n_1 (void)
783 if (test_tail_n_1_skip ()) {
784 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
788 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
790 char device[] = "/dev/sda";
793 r = guestfs_blockdev_setrw (g, device);
800 r = guestfs_umount_all (g);
807 r = guestfs_lvm_remove_all (g);
812 char device[] = "/dev/sda";
813 char lines_0[] = ",";
820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
825 char fstype[] = "ext2";
826 char device[] = "/dev/sda1";
829 r = guestfs_mkfs (g, fstype, device);
834 char device[] = "/dev/sda1";
835 char mountpoint[] = "/";
838 r = guestfs_mount (g, device, mountpoint);
842 /* TestOutputList for tail_n (1) */
844 char options[] = "ro";
845 char vfstype[] = "squashfs";
846 char device[] = "/dev/sdd";
847 char mountpoint[] = "/";
850 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
855 char path[] = "/10klines";
859 r = guestfs_tail_n (g, -9998, path);
863 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
868 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
869 if (strcmp (r[0], expected) != 0) {
870 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
875 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
880 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
881 if (strcmp (r[1], expected) != 0) {
882 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
887 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
892 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
893 if (strcmp (r[2], expected) != 0) {
894 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
899 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
903 for (i = 0; r[i] != NULL; ++i)
910 static int test_tail_n_2_skip (void)
914 str = getenv ("TEST_ONLY");
916 return strstr (str, "tail_n") == NULL;
917 str = getenv ("SKIP_TEST_TAIL_N_2");
918 if (str && strcmp (str, "1") == 0) return 1;
919 str = getenv ("SKIP_TEST_TAIL_N");
920 if (str && strcmp (str, "1") == 0) return 1;
924 static int test_tail_n_2 (void)
926 if (test_tail_n_2_skip ()) {
927 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
931 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
933 char device[] = "/dev/sda";
936 r = guestfs_blockdev_setrw (g, device);
943 r = guestfs_umount_all (g);
950 r = guestfs_lvm_remove_all (g);
955 char device[] = "/dev/sda";
956 char lines_0[] = ",";
963 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
968 char fstype[] = "ext2";
969 char device[] = "/dev/sda1";
972 r = guestfs_mkfs (g, fstype, device);
977 char device[] = "/dev/sda1";
978 char mountpoint[] = "/";
981 r = guestfs_mount (g, device, mountpoint);
985 /* TestOutputList for tail_n (2) */
987 char options[] = "ro";
988 char vfstype[] = "squashfs";
989 char device[] = "/dev/sdd";
990 char mountpoint[] = "/";
993 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
998 char path[] = "/10klines";
1002 r = guestfs_tail_n (g, 0, path);
1006 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
1010 for (i = 0; r[i] != NULL; ++i)
1017 static int test_tail_0_skip (void)
1021 str = getenv ("TEST_ONLY");
1023 return strstr (str, "tail") == NULL;
1024 str = getenv ("SKIP_TEST_TAIL_0");
1025 if (str && strcmp (str, "1") == 0) return 1;
1026 str = getenv ("SKIP_TEST_TAIL");
1027 if (str && strcmp (str, "1") == 0) return 1;
1031 static int test_tail_0 (void)
1033 if (test_tail_0_skip ()) {
1034 printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
1038 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
1040 char device[] = "/dev/sda";
1043 r = guestfs_blockdev_setrw (g, device);
1050 r = guestfs_umount_all (g);
1057 r = guestfs_lvm_remove_all (g);
1062 char device[] = "/dev/sda";
1063 char lines_0[] = ",";
1070 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1075 char fstype[] = "ext2";
1076 char device[] = "/dev/sda1";
1079 r = guestfs_mkfs (g, fstype, device);
1084 char device[] = "/dev/sda1";
1085 char mountpoint[] = "/";
1088 r = guestfs_mount (g, device, mountpoint);
1092 /* TestOutputList for tail (0) */
1094 char options[] = "ro";
1095 char vfstype[] = "squashfs";
1096 char device[] = "/dev/sdd";
1097 char mountpoint[] = "/";
1100 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1105 char path[] = "/10klines";
1109 r = guestfs_tail (g, path);
1113 fprintf (stderr, "test_tail_0: short list returned from command\n");
1118 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
1119 if (strcmp (r[0], expected) != 0) {
1120 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1125 fprintf (stderr, "test_tail_0: short list returned from command\n");
1130 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
1131 if (strcmp (r[1], expected) != 0) {
1132 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1137 fprintf (stderr, "test_tail_0: short list returned from command\n");
1142 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
1143 if (strcmp (r[2], expected) != 0) {
1144 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1149 fprintf (stderr, "test_tail_0: short list returned from command\n");
1154 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
1155 if (strcmp (r[3], expected) != 0) {
1156 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1161 fprintf (stderr, "test_tail_0: short list returned from command\n");
1166 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
1167 if (strcmp (r[4], expected) != 0) {
1168 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1173 fprintf (stderr, "test_tail_0: short list returned from command\n");
1178 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
1179 if (strcmp (r[5], expected) != 0) {
1180 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1185 fprintf (stderr, "test_tail_0: short list returned from command\n");
1190 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
1191 if (strcmp (r[6], expected) != 0) {
1192 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1197 fprintf (stderr, "test_tail_0: short list returned from command\n");
1202 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
1203 if (strcmp (r[7], expected) != 0) {
1204 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1209 fprintf (stderr, "test_tail_0: short list returned from command\n");
1214 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1215 if (strcmp (r[8], expected) != 0) {
1216 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1221 fprintf (stderr, "test_tail_0: short list returned from command\n");
1226 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1227 if (strcmp (r[9], expected) != 0) {
1228 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1232 if (r[10] != NULL) {
1233 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1237 for (i = 0; r[i] != NULL; ++i)
1244 static int test_head_n_0_skip (void)
1248 str = getenv ("TEST_ONLY");
1250 return strstr (str, "head_n") == NULL;
1251 str = getenv ("SKIP_TEST_HEAD_N_0");
1252 if (str && strcmp (str, "1") == 0) return 1;
1253 str = getenv ("SKIP_TEST_HEAD_N");
1254 if (str && strcmp (str, "1") == 0) return 1;
1258 static int test_head_n_0 (void)
1260 if (test_head_n_0_skip ()) {
1261 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1265 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1267 char device[] = "/dev/sda";
1270 r = guestfs_blockdev_setrw (g, device);
1277 r = guestfs_umount_all (g);
1284 r = guestfs_lvm_remove_all (g);
1289 char device[] = "/dev/sda";
1290 char lines_0[] = ",";
1297 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1302 char fstype[] = "ext2";
1303 char device[] = "/dev/sda1";
1306 r = guestfs_mkfs (g, fstype, device);
1311 char device[] = "/dev/sda1";
1312 char mountpoint[] = "/";
1315 r = guestfs_mount (g, device, mountpoint);
1319 /* TestOutputList for head_n (0) */
1321 char options[] = "ro";
1322 char vfstype[] = "squashfs";
1323 char device[] = "/dev/sdd";
1324 char mountpoint[] = "/";
1327 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1332 char path[] = "/10klines";
1336 r = guestfs_head_n (g, 3, path);
1340 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1345 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1346 if (strcmp (r[0], expected) != 0) {
1347 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1352 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1357 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1358 if (strcmp (r[1], expected) != 0) {
1359 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1364 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1369 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1370 if (strcmp (r[2], expected) != 0) {
1371 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1376 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1380 for (i = 0; r[i] != NULL; ++i)
1387 static int test_head_n_1_skip (void)
1391 str = getenv ("TEST_ONLY");
1393 return strstr (str, "head_n") == NULL;
1394 str = getenv ("SKIP_TEST_HEAD_N_1");
1395 if (str && strcmp (str, "1") == 0) return 1;
1396 str = getenv ("SKIP_TEST_HEAD_N");
1397 if (str && strcmp (str, "1") == 0) return 1;
1401 static int test_head_n_1 (void)
1403 if (test_head_n_1_skip ()) {
1404 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1408 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1410 char device[] = "/dev/sda";
1413 r = guestfs_blockdev_setrw (g, device);
1420 r = guestfs_umount_all (g);
1427 r = guestfs_lvm_remove_all (g);
1432 char device[] = "/dev/sda";
1433 char lines_0[] = ",";
1440 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1445 char fstype[] = "ext2";
1446 char device[] = "/dev/sda1";
1449 r = guestfs_mkfs (g, fstype, device);
1454 char device[] = "/dev/sda1";
1455 char mountpoint[] = "/";
1458 r = guestfs_mount (g, device, mountpoint);
1462 /* TestOutputList for head_n (1) */
1464 char options[] = "ro";
1465 char vfstype[] = "squashfs";
1466 char device[] = "/dev/sdd";
1467 char mountpoint[] = "/";
1470 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1475 char path[] = "/10klines";
1479 r = guestfs_head_n (g, -9997, path);
1483 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1488 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1489 if (strcmp (r[0], expected) != 0) {
1490 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1495 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1500 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1501 if (strcmp (r[1], expected) != 0) {
1502 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1507 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1512 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1513 if (strcmp (r[2], expected) != 0) {
1514 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1519 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1523 for (i = 0; r[i] != NULL; ++i)
1530 static int test_head_n_2_skip (void)
1534 str = getenv ("TEST_ONLY");
1536 return strstr (str, "head_n") == NULL;
1537 str = getenv ("SKIP_TEST_HEAD_N_2");
1538 if (str && strcmp (str, "1") == 0) return 1;
1539 str = getenv ("SKIP_TEST_HEAD_N");
1540 if (str && strcmp (str, "1") == 0) return 1;
1544 static int test_head_n_2 (void)
1546 if (test_head_n_2_skip ()) {
1547 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1551 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1553 char device[] = "/dev/sda";
1556 r = guestfs_blockdev_setrw (g, device);
1563 r = guestfs_umount_all (g);
1570 r = guestfs_lvm_remove_all (g);
1575 char device[] = "/dev/sda";
1576 char lines_0[] = ",";
1583 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1588 char fstype[] = "ext2";
1589 char device[] = "/dev/sda1";
1592 r = guestfs_mkfs (g, fstype, device);
1597 char device[] = "/dev/sda1";
1598 char mountpoint[] = "/";
1601 r = guestfs_mount (g, device, mountpoint);
1605 /* TestOutputList for head_n (2) */
1607 char options[] = "ro";
1608 char vfstype[] = "squashfs";
1609 char device[] = "/dev/sdd";
1610 char mountpoint[] = "/";
1613 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1618 char path[] = "/10klines";
1622 r = guestfs_head_n (g, 0, path);
1626 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1630 for (i = 0; r[i] != NULL; ++i)
1637 static int test_head_0_skip (void)
1641 str = getenv ("TEST_ONLY");
1643 return strstr (str, "head") == NULL;
1644 str = getenv ("SKIP_TEST_HEAD_0");
1645 if (str && strcmp (str, "1") == 0) return 1;
1646 str = getenv ("SKIP_TEST_HEAD");
1647 if (str && strcmp (str, "1") == 0) return 1;
1651 static int test_head_0 (void)
1653 if (test_head_0_skip ()) {
1654 printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1658 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1660 char device[] = "/dev/sda";
1663 r = guestfs_blockdev_setrw (g, device);
1670 r = guestfs_umount_all (g);
1677 r = guestfs_lvm_remove_all (g);
1682 char device[] = "/dev/sda";
1683 char lines_0[] = ",";
1690 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1695 char fstype[] = "ext2";
1696 char device[] = "/dev/sda1";
1699 r = guestfs_mkfs (g, fstype, device);
1704 char device[] = "/dev/sda1";
1705 char mountpoint[] = "/";
1708 r = guestfs_mount (g, device, mountpoint);
1712 /* TestOutputList for head (0) */
1714 char options[] = "ro";
1715 char vfstype[] = "squashfs";
1716 char device[] = "/dev/sdd";
1717 char mountpoint[] = "/";
1720 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1725 char path[] = "/10klines";
1729 r = guestfs_head (g, path);
1733 fprintf (stderr, "test_head_0: short list returned from command\n");
1738 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1739 if (strcmp (r[0], expected) != 0) {
1740 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1745 fprintf (stderr, "test_head_0: short list returned from command\n");
1750 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1751 if (strcmp (r[1], expected) != 0) {
1752 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1757 fprintf (stderr, "test_head_0: short list returned from command\n");
1762 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1763 if (strcmp (r[2], expected) != 0) {
1764 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1769 fprintf (stderr, "test_head_0: short list returned from command\n");
1774 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1775 if (strcmp (r[3], expected) != 0) {
1776 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1781 fprintf (stderr, "test_head_0: short list returned from command\n");
1786 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1787 if (strcmp (r[4], expected) != 0) {
1788 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1793 fprintf (stderr, "test_head_0: short list returned from command\n");
1798 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1799 if (strcmp (r[5], expected) != 0) {
1800 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1805 fprintf (stderr, "test_head_0: short list returned from command\n");
1810 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1811 if (strcmp (r[6], expected) != 0) {
1812 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1817 fprintf (stderr, "test_head_0: short list returned from command\n");
1822 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1823 if (strcmp (r[7], expected) != 0) {
1824 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1829 fprintf (stderr, "test_head_0: short list returned from command\n");
1834 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1835 if (strcmp (r[8], expected) != 0) {
1836 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1841 fprintf (stderr, "test_head_0: short list returned from command\n");
1846 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1847 if (strcmp (r[9], expected) != 0) {
1848 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1852 if (r[10] != NULL) {
1853 fprintf (stderr, "test_head_0: extra elements returned from command\n");
1857 for (i = 0; r[i] != NULL; ++i)
1864 static int test_wc_c_0_skip (void)
1868 str = getenv ("TEST_ONLY");
1870 return strstr (str, "wc_c") == NULL;
1871 str = getenv ("SKIP_TEST_WC_C_0");
1872 if (str && strcmp (str, "1") == 0) return 1;
1873 str = getenv ("SKIP_TEST_WC_C");
1874 if (str && strcmp (str, "1") == 0) return 1;
1878 static int test_wc_c_0 (void)
1880 if (test_wc_c_0_skip ()) {
1881 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1885 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1887 char device[] = "/dev/sda";
1890 r = guestfs_blockdev_setrw (g, device);
1897 r = guestfs_umount_all (g);
1904 r = guestfs_lvm_remove_all (g);
1909 char device[] = "/dev/sda";
1910 char lines_0[] = ",";
1917 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1922 char fstype[] = "ext2";
1923 char device[] = "/dev/sda1";
1926 r = guestfs_mkfs (g, fstype, device);
1931 char device[] = "/dev/sda1";
1932 char mountpoint[] = "/";
1935 r = guestfs_mount (g, device, mountpoint);
1939 /* TestOutputInt for wc_c (0) */
1941 char options[] = "ro";
1942 char vfstype[] = "squashfs";
1943 char device[] = "/dev/sdd";
1944 char mountpoint[] = "/";
1947 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1952 char path[] = "/100kallspaces";
1955 r = guestfs_wc_c (g, path);
1959 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
1966 static int test_wc_w_0_skip (void)
1970 str = getenv ("TEST_ONLY");
1972 return strstr (str, "wc_w") == NULL;
1973 str = getenv ("SKIP_TEST_WC_W_0");
1974 if (str && strcmp (str, "1") == 0) return 1;
1975 str = getenv ("SKIP_TEST_WC_W");
1976 if (str && strcmp (str, "1") == 0) return 1;
1980 static int test_wc_w_0 (void)
1982 if (test_wc_w_0_skip ()) {
1983 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1987 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1989 char device[] = "/dev/sda";
1992 r = guestfs_blockdev_setrw (g, device);
1999 r = guestfs_umount_all (g);
2006 r = guestfs_lvm_remove_all (g);
2011 char device[] = "/dev/sda";
2012 char lines_0[] = ",";
2019 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2024 char fstype[] = "ext2";
2025 char device[] = "/dev/sda1";
2028 r = guestfs_mkfs (g, fstype, device);
2033 char device[] = "/dev/sda1";
2034 char mountpoint[] = "/";
2037 r = guestfs_mount (g, device, mountpoint);
2041 /* TestOutputInt for wc_w (0) */
2043 char options[] = "ro";
2044 char vfstype[] = "squashfs";
2045 char device[] = "/dev/sdd";
2046 char mountpoint[] = "/";
2049 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2054 char path[] = "/10klines";
2057 r = guestfs_wc_w (g, path);
2061 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
2068 static int test_wc_l_0_skip (void)
2072 str = getenv ("TEST_ONLY");
2074 return strstr (str, "wc_l") == NULL;
2075 str = getenv ("SKIP_TEST_WC_L_0");
2076 if (str && strcmp (str, "1") == 0) return 1;
2077 str = getenv ("SKIP_TEST_WC_L");
2078 if (str && strcmp (str, "1") == 0) return 1;
2082 static int test_wc_l_0 (void)
2084 if (test_wc_l_0_skip ()) {
2085 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
2089 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
2091 char device[] = "/dev/sda";
2094 r = guestfs_blockdev_setrw (g, device);
2101 r = guestfs_umount_all (g);
2108 r = guestfs_lvm_remove_all (g);
2113 char device[] = "/dev/sda";
2114 char lines_0[] = ",";
2121 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2126 char fstype[] = "ext2";
2127 char device[] = "/dev/sda1";
2130 r = guestfs_mkfs (g, fstype, device);
2135 char device[] = "/dev/sda1";
2136 char mountpoint[] = "/";
2139 r = guestfs_mount (g, device, mountpoint);
2143 /* TestOutputInt for wc_l (0) */
2145 char options[] = "ro";
2146 char vfstype[] = "squashfs";
2147 char device[] = "/dev/sdd";
2148 char mountpoint[] = "/";
2151 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2156 char path[] = "/10klines";
2159 r = guestfs_wc_l (g, path);
2163 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
2170 static int test_mkdtemp_0_skip (void)
2174 str = getenv ("TEST_ONLY");
2176 return strstr (str, "mkdtemp") == NULL;
2177 str = getenv ("SKIP_TEST_MKDTEMP_0");
2178 if (str && strcmp (str, "1") == 0) return 1;
2179 str = getenv ("SKIP_TEST_MKDTEMP");
2180 if (str && strcmp (str, "1") == 0) return 1;
2184 static int test_mkdtemp_0 (void)
2186 if (test_mkdtemp_0_skip ()) {
2187 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
2191 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
2193 char device[] = "/dev/sda";
2196 r = guestfs_blockdev_setrw (g, device);
2203 r = guestfs_umount_all (g);
2210 r = guestfs_lvm_remove_all (g);
2215 char device[] = "/dev/sda";
2216 char lines_0[] = ",";
2223 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2228 char fstype[] = "ext2";
2229 char device[] = "/dev/sda1";
2232 r = guestfs_mkfs (g, fstype, device);
2237 char device[] = "/dev/sda1";
2238 char mountpoint[] = "/";
2241 r = guestfs_mount (g, device, mountpoint);
2245 /* TestRun for mkdtemp (0) */
2247 char path[] = "/tmp";
2250 r = guestfs_mkdir (g, path);
2255 char template[] = "/tmp/tmpXXXXXX";
2258 r = guestfs_mkdtemp (g, template);
2266 static int test_scrub_file_0_skip (void)
2270 str = getenv ("TEST_ONLY");
2272 return strstr (str, "scrub_file") == NULL;
2273 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2274 if (str && strcmp (str, "1") == 0) return 1;
2275 str = getenv ("SKIP_TEST_SCRUB_FILE");
2276 if (str && strcmp (str, "1") == 0) return 1;
2280 static int test_scrub_file_0 (void)
2282 if (test_scrub_file_0_skip ()) {
2283 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2287 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2289 char device[] = "/dev/sda";
2292 r = guestfs_blockdev_setrw (g, device);
2299 r = guestfs_umount_all (g);
2306 r = guestfs_lvm_remove_all (g);
2311 char device[] = "/dev/sda";
2312 char lines_0[] = ",";
2319 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2324 char fstype[] = "ext2";
2325 char device[] = "/dev/sda1";
2328 r = guestfs_mkfs (g, fstype, device);
2333 char device[] = "/dev/sda1";
2334 char mountpoint[] = "/";
2337 r = guestfs_mount (g, device, mountpoint);
2341 /* TestRun for scrub_file (0) */
2343 char path[] = "/file";
2344 char content[] = "content";
2347 r = guestfs_write_file (g, path, content, 0);
2352 char file[] = "/file";
2355 r = guestfs_scrub_file (g, file);
2362 static int test_scrub_device_0_skip (void)
2366 str = getenv ("TEST_ONLY");
2368 return strstr (str, "scrub_device") == NULL;
2369 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2370 if (str && strcmp (str, "1") == 0) return 1;
2371 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2372 if (str && strcmp (str, "1") == 0) return 1;
2376 static int test_scrub_device_0 (void)
2378 if (test_scrub_device_0_skip ()) {
2379 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2383 /* InitNone|InitEmpty for test_scrub_device_0 */
2385 char device[] = "/dev/sda";
2388 r = guestfs_blockdev_setrw (g, device);
2395 r = guestfs_umount_all (g);
2402 r = guestfs_lvm_remove_all (g);
2406 /* TestRun for scrub_device (0) */
2408 char device[] = "/dev/sdc";
2411 r = guestfs_scrub_device (g, device);
2418 static int test_glob_expand_0_skip (void)
2422 str = getenv ("TEST_ONLY");
2424 return strstr (str, "glob_expand") == NULL;
2425 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2426 if (str && strcmp (str, "1") == 0) return 1;
2427 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2428 if (str && strcmp (str, "1") == 0) return 1;
2432 static int test_glob_expand_0 (void)
2434 if (test_glob_expand_0_skip ()) {
2435 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2439 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2441 char device[] = "/dev/sda";
2444 r = guestfs_blockdev_setrw (g, device);
2451 r = guestfs_umount_all (g);
2458 r = guestfs_lvm_remove_all (g);
2463 char device[] = "/dev/sda";
2464 char lines_0[] = ",";
2471 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2476 char fstype[] = "ext2";
2477 char device[] = "/dev/sda1";
2480 r = guestfs_mkfs (g, fstype, device);
2485 char device[] = "/dev/sda1";
2486 char mountpoint[] = "/";
2489 r = guestfs_mount (g, device, mountpoint);
2493 /* TestOutputList for glob_expand (0) */
2495 char path[] = "/a/b/c";
2498 r = guestfs_mkdir_p (g, path);
2503 char path[] = "/a/b/c/d";
2506 r = guestfs_touch (g, path);
2511 char path[] = "/a/b/c/e";
2514 r = guestfs_touch (g, path);
2519 char pattern[] = "/a/b/c/*";
2523 r = guestfs_glob_expand (g, pattern);
2527 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2532 char expected[] = "/a/b/c/d";
2533 if (strcmp (r[0], expected) != 0) {
2534 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2539 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2544 char expected[] = "/a/b/c/e";
2545 if (strcmp (r[1], expected) != 0) {
2546 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2551 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2555 for (i = 0; r[i] != NULL; ++i)
2562 static int test_glob_expand_1_skip (void)
2566 str = getenv ("TEST_ONLY");
2568 return strstr (str, "glob_expand") == NULL;
2569 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2570 if (str && strcmp (str, "1") == 0) return 1;
2571 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2572 if (str && strcmp (str, "1") == 0) return 1;
2576 static int test_glob_expand_1 (void)
2578 if (test_glob_expand_1_skip ()) {
2579 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2583 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2585 char device[] = "/dev/sda";
2588 r = guestfs_blockdev_setrw (g, device);
2595 r = guestfs_umount_all (g);
2602 r = guestfs_lvm_remove_all (g);
2607 char device[] = "/dev/sda";
2608 char lines_0[] = ",";
2615 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2620 char fstype[] = "ext2";
2621 char device[] = "/dev/sda1";
2624 r = guestfs_mkfs (g, fstype, device);
2629 char device[] = "/dev/sda1";
2630 char mountpoint[] = "/";
2633 r = guestfs_mount (g, device, mountpoint);
2637 /* TestOutputList for glob_expand (1) */
2639 char path[] = "/a/b/c";
2642 r = guestfs_mkdir_p (g, path);
2647 char path[] = "/a/b/c/d";
2650 r = guestfs_touch (g, path);
2655 char path[] = "/a/b/c/e";
2658 r = guestfs_touch (g, path);
2663 char pattern[] = "/a/*/c/*";
2667 r = guestfs_glob_expand (g, pattern);
2671 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2676 char expected[] = "/a/b/c/d";
2677 if (strcmp (r[0], expected) != 0) {
2678 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2683 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2688 char expected[] = "/a/b/c/e";
2689 if (strcmp (r[1], expected) != 0) {
2690 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2695 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2699 for (i = 0; r[i] != NULL; ++i)
2706 static int test_glob_expand_2_skip (void)
2710 str = getenv ("TEST_ONLY");
2712 return strstr (str, "glob_expand") == NULL;
2713 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2714 if (str && strcmp (str, "1") == 0) return 1;
2715 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2716 if (str && strcmp (str, "1") == 0) return 1;
2720 static int test_glob_expand_2 (void)
2722 if (test_glob_expand_2_skip ()) {
2723 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2727 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2729 char device[] = "/dev/sda";
2732 r = guestfs_blockdev_setrw (g, device);
2739 r = guestfs_umount_all (g);
2746 r = guestfs_lvm_remove_all (g);
2751 char device[] = "/dev/sda";
2752 char lines_0[] = ",";
2759 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2764 char fstype[] = "ext2";
2765 char device[] = "/dev/sda1";
2768 r = guestfs_mkfs (g, fstype, device);
2773 char device[] = "/dev/sda1";
2774 char mountpoint[] = "/";
2777 r = guestfs_mount (g, device, mountpoint);
2781 /* TestOutputList for glob_expand (2) */
2783 char path[] = "/a/b/c";
2786 r = guestfs_mkdir_p (g, path);
2791 char path[] = "/a/b/c/d";
2794 r = guestfs_touch (g, path);
2799 char path[] = "/a/b/c/e";
2802 r = guestfs_touch (g, path);
2807 char pattern[] = "/a/*/x/*";
2811 r = guestfs_glob_expand (g, pattern);
2815 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2819 for (i = 0; r[i] != NULL; ++i)
2826 static int test_ntfs_3g_probe_0_skip (void)
2830 str = getenv ("TEST_ONLY");
2832 return strstr (str, "ntfs_3g_probe") == NULL;
2833 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2834 if (str && strcmp (str, "1") == 0) return 1;
2835 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2836 if (str && strcmp (str, "1") == 0) return 1;
2840 static int test_ntfs_3g_probe_0 (void)
2842 if (test_ntfs_3g_probe_0_skip ()) {
2843 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2847 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2849 char device[] = "/dev/sda";
2852 r = guestfs_blockdev_setrw (g, device);
2859 r = guestfs_umount_all (g);
2866 r = guestfs_lvm_remove_all (g);
2870 /* TestOutputInt for ntfs_3g_probe (0) */
2872 char device[] = "/dev/sda";
2873 char lines_0[] = ",";
2880 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2885 char fstype[] = "ntfs";
2886 char device[] = "/dev/sda1";
2889 r = guestfs_mkfs (g, fstype, device);
2894 char device[] = "/dev/sda1";
2897 r = guestfs_ntfs_3g_probe (g, 1, device);
2901 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
2908 static int test_ntfs_3g_probe_1_skip (void)
2912 str = getenv ("TEST_ONLY");
2914 return strstr (str, "ntfs_3g_probe") == NULL;
2915 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2916 if (str && strcmp (str, "1") == 0) return 1;
2917 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2918 if (str && strcmp (str, "1") == 0) return 1;
2922 static int test_ntfs_3g_probe_1 (void)
2924 if (test_ntfs_3g_probe_1_skip ()) {
2925 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2929 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2931 char device[] = "/dev/sda";
2934 r = guestfs_blockdev_setrw (g, device);
2941 r = guestfs_umount_all (g);
2948 r = guestfs_lvm_remove_all (g);
2952 /* TestOutputInt for ntfs_3g_probe (1) */
2954 char device[] = "/dev/sda";
2955 char lines_0[] = ",";
2962 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2967 char fstype[] = "ext2";
2968 char device[] = "/dev/sda1";
2971 r = guestfs_mkfs (g, fstype, device);
2976 char device[] = "/dev/sda1";
2979 r = guestfs_ntfs_3g_probe (g, 1, device);
2983 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
2990 static int test_sleep_0_skip (void)
2994 str = getenv ("TEST_ONLY");
2996 return strstr (str, "sleep") == NULL;
2997 str = getenv ("SKIP_TEST_SLEEP_0");
2998 if (str && strcmp (str, "1") == 0) return 1;
2999 str = getenv ("SKIP_TEST_SLEEP");
3000 if (str && strcmp (str, "1") == 0) return 1;
3004 static int test_sleep_0 (void)
3006 if (test_sleep_0_skip ()) {
3007 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
3011 /* InitNone|InitEmpty for test_sleep_0 */
3013 char device[] = "/dev/sda";
3016 r = guestfs_blockdev_setrw (g, device);
3023 r = guestfs_umount_all (g);
3030 r = guestfs_lvm_remove_all (g);
3034 /* TestRun for sleep (0) */
3038 r = guestfs_sleep (g, 1);
3045 static int test_find_0_skip (void)
3049 str = getenv ("TEST_ONLY");
3051 return strstr (str, "find") == NULL;
3052 str = getenv ("SKIP_TEST_FIND_0");
3053 if (str && strcmp (str, "1") == 0) return 1;
3054 str = getenv ("SKIP_TEST_FIND");
3055 if (str && strcmp (str, "1") == 0) return 1;
3059 static int test_find_0 (void)
3061 if (test_find_0_skip ()) {
3062 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
3066 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
3068 char device[] = "/dev/sda";
3071 r = guestfs_blockdev_setrw (g, device);
3078 r = guestfs_umount_all (g);
3085 r = guestfs_lvm_remove_all (g);
3090 char device[] = "/dev/sda";
3091 char lines_0[] = ",";
3098 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3103 char fstype[] = "ext2";
3104 char device[] = "/dev/sda1";
3107 r = guestfs_mkfs (g, fstype, device);
3112 char device[] = "/dev/sda1";
3113 char mountpoint[] = "/";
3116 r = guestfs_mount (g, device, mountpoint);
3120 /* TestOutputList for find (0) */
3122 char directory[] = "/";
3126 r = guestfs_find (g, directory);
3130 fprintf (stderr, "test_find_0: short list returned from command\n");
3135 char expected[] = "lost+found";
3136 if (strcmp (r[0], expected) != 0) {
3137 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3142 fprintf (stderr, "test_find_0: extra elements returned from command\n");
3146 for (i = 0; r[i] != NULL; ++i)
3153 static int test_find_1_skip (void)
3157 str = getenv ("TEST_ONLY");
3159 return strstr (str, "find") == NULL;
3160 str = getenv ("SKIP_TEST_FIND_1");
3161 if (str && strcmp (str, "1") == 0) return 1;
3162 str = getenv ("SKIP_TEST_FIND");
3163 if (str && strcmp (str, "1") == 0) return 1;
3167 static int test_find_1 (void)
3169 if (test_find_1_skip ()) {
3170 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
3174 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
3176 char device[] = "/dev/sda";
3179 r = guestfs_blockdev_setrw (g, device);
3186 r = guestfs_umount_all (g);
3193 r = guestfs_lvm_remove_all (g);
3198 char device[] = "/dev/sda";
3199 char lines_0[] = ",";
3206 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3211 char fstype[] = "ext2";
3212 char device[] = "/dev/sda1";
3215 r = guestfs_mkfs (g, fstype, device);
3220 char device[] = "/dev/sda1";
3221 char mountpoint[] = "/";
3224 r = guestfs_mount (g, device, mountpoint);
3228 /* TestOutputList for find (1) */
3233 r = guestfs_touch (g, path);
3241 r = guestfs_mkdir (g, path);
3246 char path[] = "/b/c";
3249 r = guestfs_touch (g, path);
3254 char directory[] = "/";
3258 r = guestfs_find (g, directory);
3262 fprintf (stderr, "test_find_1: short list returned from command\n");
3267 char expected[] = "a";
3268 if (strcmp (r[0], expected) != 0) {
3269 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3274 fprintf (stderr, "test_find_1: short list returned from command\n");
3279 char expected[] = "b";
3280 if (strcmp (r[1], expected) != 0) {
3281 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3286 fprintf (stderr, "test_find_1: short list returned from command\n");
3291 char expected[] = "b/c";
3292 if (strcmp (r[2], expected) != 0) {
3293 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3298 fprintf (stderr, "test_find_1: short list returned from command\n");
3303 char expected[] = "lost+found";
3304 if (strcmp (r[3], expected) != 0) {
3305 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3310 fprintf (stderr, "test_find_1: extra elements returned from command\n");
3314 for (i = 0; r[i] != NULL; ++i)
3321 static int test_find_2_skip (void)
3325 str = getenv ("TEST_ONLY");
3327 return strstr (str, "find") == NULL;
3328 str = getenv ("SKIP_TEST_FIND_2");
3329 if (str && strcmp (str, "1") == 0) return 1;
3330 str = getenv ("SKIP_TEST_FIND");
3331 if (str && strcmp (str, "1") == 0) return 1;
3335 static int test_find_2 (void)
3337 if (test_find_2_skip ()) {
3338 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3342 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3344 char device[] = "/dev/sda";
3347 r = guestfs_blockdev_setrw (g, device);
3354 r = guestfs_umount_all (g);
3361 r = guestfs_lvm_remove_all (g);
3366 char device[] = "/dev/sda";
3367 char lines_0[] = ",";
3374 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3379 char fstype[] = "ext2";
3380 char device[] = "/dev/sda1";
3383 r = guestfs_mkfs (g, fstype, device);
3388 char device[] = "/dev/sda1";
3389 char mountpoint[] = "/";
3392 r = guestfs_mount (g, device, mountpoint);
3396 /* TestOutputList for find (2) */
3398 char path[] = "/a/b/c";
3401 r = guestfs_mkdir_p (g, path);
3406 char path[] = "/a/b/c/d";
3409 r = guestfs_touch (g, path);
3414 char directory[] = "/a/b/";
3418 r = guestfs_find (g, directory);
3422 fprintf (stderr, "test_find_2: short list returned from command\n");
3427 char expected[] = "c";
3428 if (strcmp (r[0], expected) != 0) {
3429 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3434 fprintf (stderr, "test_find_2: short list returned from command\n");
3439 char expected[] = "c/d";
3440 if (strcmp (r[1], expected) != 0) {
3441 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3446 fprintf (stderr, "test_find_2: extra elements returned from command\n");
3450 for (i = 0; r[i] != NULL; ++i)
3457 static int test_lvresize_0_skip (void)
3461 str = getenv ("TEST_ONLY");
3463 return strstr (str, "lvresize") == NULL;
3464 str = getenv ("SKIP_TEST_LVRESIZE_0");
3465 if (str && strcmp (str, "1") == 0) return 1;
3466 str = getenv ("SKIP_TEST_LVRESIZE");
3467 if (str && strcmp (str, "1") == 0) return 1;
3471 static int test_lvresize_0 (void)
3473 if (test_lvresize_0_skip ()) {
3474 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3478 /* InitNone|InitEmpty for test_lvresize_0 */
3480 char device[] = "/dev/sda";
3483 r = guestfs_blockdev_setrw (g, device);
3490 r = guestfs_umount_all (g);
3497 r = guestfs_lvm_remove_all (g);
3501 /* TestOutput for lvresize (0) */
3502 char expected[] = "test content";
3504 char device[] = "/dev/sda";
3505 char lines_0[] = ",";
3512 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3517 char device[] = "/dev/sda1";
3520 r = guestfs_pvcreate (g, device);
3525 char volgroup[] = "VG";
3526 char physvols_0[] = "/dev/sda1";
3527 char *physvols[] = {
3533 r = guestfs_vgcreate (g, volgroup, physvols);
3538 char logvol[] = "LV";
3539 char volgroup[] = "VG";
3542 r = guestfs_lvcreate (g, logvol, volgroup, 10);
3547 char fstype[] = "ext2";
3548 char device[] = "/dev/VG/LV";
3551 r = guestfs_mkfs (g, fstype, device);
3556 char device[] = "/dev/VG/LV";
3557 char mountpoint[] = "/";
3560 r = guestfs_mount (g, device, mountpoint);
3565 char path[] = "/new";
3566 char content[] = "test content";
3569 r = guestfs_write_file (g, path, content, 0);
3574 char pathordevice[] = "/";
3577 r = guestfs_umount (g, pathordevice);
3582 char device[] = "/dev/VG/LV";
3585 r = guestfs_lvresize (g, device, 20);
3590 char device[] = "/dev/VG/LV";
3593 r = guestfs_e2fsck_f (g, device);
3598 char device[] = "/dev/VG/LV";
3601 r = guestfs_resize2fs (g, device);
3606 char device[] = "/dev/VG/LV";
3607 char mountpoint[] = "/";
3610 r = guestfs_mount (g, device, mountpoint);
3615 char path[] = "/new";
3618 r = guestfs_cat (g, path);
3621 if (strcmp (r, expected) != 0) {
3622 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3630 static int test_zerofree_0_skip (void)
3634 str = getenv ("TEST_ONLY");
3636 return strstr (str, "zerofree") == NULL;
3637 str = getenv ("SKIP_TEST_ZEROFREE_0");
3638 if (str && strcmp (str, "1") == 0) return 1;
3639 str = getenv ("SKIP_TEST_ZEROFREE");
3640 if (str && strcmp (str, "1") == 0) return 1;
3644 static int test_zerofree_0 (void)
3646 if (test_zerofree_0_skip ()) {
3647 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3651 /* InitNone|InitEmpty for test_zerofree_0 */
3653 char device[] = "/dev/sda";
3656 r = guestfs_blockdev_setrw (g, device);
3663 r = guestfs_umount_all (g);
3670 r = guestfs_lvm_remove_all (g);
3674 /* TestOutput for zerofree (0) */
3675 char expected[] = "test file";
3677 char device[] = "/dev/sda";
3678 char lines_0[] = ",";
3685 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3690 char fstype[] = "ext3";
3691 char device[] = "/dev/sda1";
3694 r = guestfs_mkfs (g, fstype, device);
3699 char device[] = "/dev/sda1";
3700 char mountpoint[] = "/";
3703 r = guestfs_mount (g, device, mountpoint);
3708 char path[] = "/new";
3709 char content[] = "test file";
3712 r = guestfs_write_file (g, path, content, 0);
3717 char pathordevice[] = "/dev/sda1";
3720 r = guestfs_umount (g, pathordevice);
3725 char device[] = "/dev/sda1";
3728 r = guestfs_zerofree (g, device);
3733 char device[] = "/dev/sda1";
3734 char mountpoint[] = "/";
3737 r = guestfs_mount (g, device, mountpoint);
3742 char path[] = "/new";
3745 r = guestfs_cat (g, path);
3748 if (strcmp (r, expected) != 0) {
3749 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3757 static int test_hexdump_0_skip (void)
3761 str = getenv ("TEST_ONLY");
3763 return strstr (str, "hexdump") == NULL;
3764 str = getenv ("SKIP_TEST_HEXDUMP_0");
3765 if (str && strcmp (str, "1") == 0) return 1;
3766 str = getenv ("SKIP_TEST_HEXDUMP");
3767 if (str && strcmp (str, "1") == 0) return 1;
3771 static int test_hexdump_0 (void)
3773 if (test_hexdump_0_skip ()) {
3774 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3778 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3780 char device[] = "/dev/sda";
3783 r = guestfs_blockdev_setrw (g, device);
3790 r = guestfs_umount_all (g);
3797 r = guestfs_lvm_remove_all (g);
3802 char device[] = "/dev/sda";
3803 char lines_0[] = ",";
3810 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3815 char fstype[] = "ext2";
3816 char device[] = "/dev/sda1";
3819 r = guestfs_mkfs (g, fstype, device);
3824 char device[] = "/dev/sda1";
3825 char mountpoint[] = "/";
3828 r = guestfs_mount (g, device, mountpoint);
3832 /* TestOutput for hexdump (0) */
3833 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
3835 char path[] = "/new";
3836 char content[] = "hello\nworld\n";
3839 r = guestfs_write_file (g, path, content, 12);
3844 char path[] = "/new";
3847 r = guestfs_hexdump (g, path);
3850 if (strcmp (r, expected) != 0) {
3851 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3859 static int test_hexdump_1_skip (void)
3863 str = getenv ("TEST_ONLY");
3865 return strstr (str, "hexdump") == NULL;
3866 str = getenv ("SKIP_TEST_HEXDUMP_1");
3867 if (str && strcmp (str, "1") == 0) return 1;
3868 str = getenv ("SKIP_TEST_HEXDUMP");
3869 if (str && strcmp (str, "1") == 0) return 1;
3873 static int test_hexdump_1 (void)
3875 if (test_hexdump_1_skip ()) {
3876 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3880 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3882 char device[] = "/dev/sda";
3885 r = guestfs_blockdev_setrw (g, device);
3892 r = guestfs_umount_all (g);
3899 r = guestfs_lvm_remove_all (g);
3904 char device[] = "/dev/sda";
3905 char lines_0[] = ",";
3912 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3917 char fstype[] = "ext2";
3918 char device[] = "/dev/sda1";
3921 r = guestfs_mkfs (g, fstype, device);
3926 char device[] = "/dev/sda1";
3927 char mountpoint[] = "/";
3930 r = guestfs_mount (g, device, mountpoint);
3934 /* TestRun for hexdump (1) */
3936 char options[] = "ro";
3937 char vfstype[] = "squashfs";
3938 char device[] = "/dev/sdd";
3939 char mountpoint[] = "/";
3942 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3947 char path[] = "/100krandom";
3950 r = guestfs_hexdump (g, path);
3958 static int test_strings_e_0_skip (void)
3962 str = getenv ("TEST_ONLY");
3964 return strstr (str, "strings_e") == NULL;
3965 str = getenv ("SKIP_TEST_STRINGS_E_0");
3966 if (str && strcmp (str, "1") == 0) return 1;
3967 str = getenv ("SKIP_TEST_STRINGS_E");
3968 if (str && strcmp (str, "1") == 0) return 1;
3972 static int test_strings_e_0 (void)
3974 if (test_strings_e_0_skip ()) {
3975 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3979 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3981 char device[] = "/dev/sda";
3984 r = guestfs_blockdev_setrw (g, device);
3991 r = guestfs_umount_all (g);
3998 r = guestfs_lvm_remove_all (g);
4003 char device[] = "/dev/sda";
4004 char lines_0[] = ",";
4011 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4016 char fstype[] = "ext2";
4017 char device[] = "/dev/sda1";
4020 r = guestfs_mkfs (g, fstype, device);
4025 char device[] = "/dev/sda1";
4026 char mountpoint[] = "/";
4029 r = guestfs_mount (g, device, mountpoint);
4033 /* TestOutputList for strings_e (0) */
4035 char path[] = "/new";
4036 char content[] = "hello\nworld\n";
4039 r = guestfs_write_file (g, path, content, 0);
4044 char encoding[] = "b";
4045 char path[] = "/new";
4049 r = guestfs_strings_e (g, encoding, path);
4053 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
4057 for (i = 0; r[i] != NULL; ++i)
4064 static int test_strings_e_1_skip (void)
4068 str = getenv ("TEST_ONLY");
4070 return strstr (str, "strings_e") == NULL;
4071 str = getenv ("SKIP_TEST_STRINGS_E_1");
4072 if (str && strcmp (str, "1") == 0) return 1;
4073 str = getenv ("SKIP_TEST_STRINGS_E");
4074 if (str && strcmp (str, "1") == 0) return 1;
4078 static int test_strings_e_1 (void)
4080 if (test_strings_e_1_skip ()) {
4081 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
4085 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
4089 static int test_strings_0_skip (void)
4093 str = getenv ("TEST_ONLY");
4095 return strstr (str, "strings") == NULL;
4096 str = getenv ("SKIP_TEST_STRINGS_0");
4097 if (str && strcmp (str, "1") == 0) return 1;
4098 str = getenv ("SKIP_TEST_STRINGS");
4099 if (str && strcmp (str, "1") == 0) return 1;
4103 static int test_strings_0 (void)
4105 if (test_strings_0_skip ()) {
4106 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
4110 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
4112 char device[] = "/dev/sda";
4115 r = guestfs_blockdev_setrw (g, device);
4122 r = guestfs_umount_all (g);
4129 r = guestfs_lvm_remove_all (g);
4134 char device[] = "/dev/sda";
4135 char lines_0[] = ",";
4142 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4147 char fstype[] = "ext2";
4148 char device[] = "/dev/sda1";
4151 r = guestfs_mkfs (g, fstype, device);
4156 char device[] = "/dev/sda1";
4157 char mountpoint[] = "/";
4160 r = guestfs_mount (g, device, mountpoint);
4164 /* TestOutputList for strings (0) */
4166 char path[] = "/new";
4167 char content[] = "hello\nworld\n";
4170 r = guestfs_write_file (g, path, content, 0);
4175 char path[] = "/new";
4179 r = guestfs_strings (g, path);
4183 fprintf (stderr, "test_strings_0: short list returned from command\n");
4188 char expected[] = "hello";
4189 if (strcmp (r[0], expected) != 0) {
4190 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4195 fprintf (stderr, "test_strings_0: short list returned from command\n");
4200 char expected[] = "world";
4201 if (strcmp (r[1], expected) != 0) {
4202 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
4207 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4211 for (i = 0; r[i] != NULL; ++i)
4218 static int test_strings_1_skip (void)
4222 str = getenv ("TEST_ONLY");
4224 return strstr (str, "strings") == NULL;
4225 str = getenv ("SKIP_TEST_STRINGS_1");
4226 if (str && strcmp (str, "1") == 0) return 1;
4227 str = getenv ("SKIP_TEST_STRINGS");
4228 if (str && strcmp (str, "1") == 0) return 1;
4232 static int test_strings_1 (void)
4234 if (test_strings_1_skip ()) {
4235 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4239 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4241 char device[] = "/dev/sda";
4244 r = guestfs_blockdev_setrw (g, device);
4251 r = guestfs_umount_all (g);
4258 r = guestfs_lvm_remove_all (g);
4263 char device[] = "/dev/sda";
4264 char lines_0[] = ",";
4271 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4276 char fstype[] = "ext2";
4277 char device[] = "/dev/sda1";
4280 r = guestfs_mkfs (g, fstype, device);
4285 char device[] = "/dev/sda1";
4286 char mountpoint[] = "/";
4289 r = guestfs_mount (g, device, mountpoint);
4293 /* TestOutputList for strings (1) */
4295 char path[] = "/new";
4298 r = guestfs_touch (g, path);
4303 char path[] = "/new";
4307 r = guestfs_strings (g, path);
4311 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4315 for (i = 0; r[i] != NULL; ++i)
4322 static int test_equal_0_skip (void)
4326 str = getenv ("TEST_ONLY");
4328 return strstr (str, "equal") == NULL;
4329 str = getenv ("SKIP_TEST_EQUAL_0");
4330 if (str && strcmp (str, "1") == 0) return 1;
4331 str = getenv ("SKIP_TEST_EQUAL");
4332 if (str && strcmp (str, "1") == 0) return 1;
4336 static int test_equal_0 (void)
4338 if (test_equal_0_skip ()) {
4339 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4343 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4345 char device[] = "/dev/sda";
4348 r = guestfs_blockdev_setrw (g, device);
4355 r = guestfs_umount_all (g);
4362 r = guestfs_lvm_remove_all (g);
4367 char device[] = "/dev/sda";
4368 char lines_0[] = ",";
4375 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4380 char fstype[] = "ext2";
4381 char device[] = "/dev/sda1";
4384 r = guestfs_mkfs (g, fstype, device);
4389 char device[] = "/dev/sda1";
4390 char mountpoint[] = "/";
4393 r = guestfs_mount (g, device, mountpoint);
4397 /* TestOutputTrue for equal (0) */
4399 char path[] = "/file1";
4400 char content[] = "contents of a file";
4403 r = guestfs_write_file (g, path, content, 0);
4408 char src[] = "/file1";
4409 char dest[] = "/file2";
4412 r = guestfs_cp (g, src, dest);
4417 char file1[] = "/file1";
4418 char file2[] = "/file2";
4421 r = guestfs_equal (g, file1, file2);
4425 fprintf (stderr, "test_equal_0: expected true, got false\n");
4432 static int test_equal_1_skip (void)
4436 str = getenv ("TEST_ONLY");
4438 return strstr (str, "equal") == NULL;
4439 str = getenv ("SKIP_TEST_EQUAL_1");
4440 if (str && strcmp (str, "1") == 0) return 1;
4441 str = getenv ("SKIP_TEST_EQUAL");
4442 if (str && strcmp (str, "1") == 0) return 1;
4446 static int test_equal_1 (void)
4448 if (test_equal_1_skip ()) {
4449 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4453 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4455 char device[] = "/dev/sda";
4458 r = guestfs_blockdev_setrw (g, device);
4465 r = guestfs_umount_all (g);
4472 r = guestfs_lvm_remove_all (g);
4477 char device[] = "/dev/sda";
4478 char lines_0[] = ",";
4485 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4490 char fstype[] = "ext2";
4491 char device[] = "/dev/sda1";
4494 r = guestfs_mkfs (g, fstype, device);
4499 char device[] = "/dev/sda1";
4500 char mountpoint[] = "/";
4503 r = guestfs_mount (g, device, mountpoint);
4507 /* TestOutputFalse for equal (1) */
4509 char path[] = "/file1";
4510 char content[] = "contents of a file";
4513 r = guestfs_write_file (g, path, content, 0);
4518 char path[] = "/file2";
4519 char content[] = "contents of another file";
4522 r = guestfs_write_file (g, path, content, 0);
4527 char file1[] = "/file1";
4528 char file2[] = "/file2";
4531 r = guestfs_equal (g, file1, file2);
4535 fprintf (stderr, "test_equal_1: expected false, got true\n");
4542 static int test_equal_2_skip (void)
4546 str = getenv ("TEST_ONLY");
4548 return strstr (str, "equal") == NULL;
4549 str = getenv ("SKIP_TEST_EQUAL_2");
4550 if (str && strcmp (str, "1") == 0) return 1;
4551 str = getenv ("SKIP_TEST_EQUAL");
4552 if (str && strcmp (str, "1") == 0) return 1;
4556 static int test_equal_2 (void)
4558 if (test_equal_2_skip ()) {
4559 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4563 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4565 char device[] = "/dev/sda";
4568 r = guestfs_blockdev_setrw (g, device);
4575 r = guestfs_umount_all (g);
4582 r = guestfs_lvm_remove_all (g);
4587 char device[] = "/dev/sda";
4588 char lines_0[] = ",";
4595 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4600 char fstype[] = "ext2";
4601 char device[] = "/dev/sda1";
4604 r = guestfs_mkfs (g, fstype, device);
4609 char device[] = "/dev/sda1";
4610 char mountpoint[] = "/";
4613 r = guestfs_mount (g, device, mountpoint);
4617 /* TestLastFail for equal (2) */
4619 char file1[] = "/file1";
4620 char file2[] = "/file2";
4623 r = guestfs_equal (g, file1, file2);
4630 static int test_ping_daemon_0_skip (void)
4634 str = getenv ("TEST_ONLY");
4636 return strstr (str, "ping_daemon") == NULL;
4637 str = getenv ("SKIP_TEST_PING_DAEMON_0");
4638 if (str && strcmp (str, "1") == 0) return 1;
4639 str = getenv ("SKIP_TEST_PING_DAEMON");
4640 if (str && strcmp (str, "1") == 0) return 1;
4644 static int test_ping_daemon_0 (void)
4646 if (test_ping_daemon_0_skip ()) {
4647 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4651 /* InitNone|InitEmpty for test_ping_daemon_0 */
4653 char device[] = "/dev/sda";
4656 r = guestfs_blockdev_setrw (g, device);
4663 r = guestfs_umount_all (g);
4670 r = guestfs_lvm_remove_all (g);
4674 /* TestRun for ping_daemon (0) */
4678 r = guestfs_ping_daemon (g);
4685 static int test_dmesg_0_skip (void)
4689 str = getenv ("TEST_ONLY");
4691 return strstr (str, "dmesg") == NULL;
4692 str = getenv ("SKIP_TEST_DMESG_0");
4693 if (str && strcmp (str, "1") == 0) return 1;
4694 str = getenv ("SKIP_TEST_DMESG");
4695 if (str && strcmp (str, "1") == 0) return 1;
4699 static int test_dmesg_0 (void)
4701 if (test_dmesg_0_skip ()) {
4702 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4706 /* InitNone|InitEmpty for test_dmesg_0 */
4708 char device[] = "/dev/sda";
4711 r = guestfs_blockdev_setrw (g, device);
4718 r = guestfs_umount_all (g);
4725 r = guestfs_lvm_remove_all (g);
4729 /* TestRun for dmesg (0) */
4733 r = guestfs_dmesg (g);
4741 static int test_drop_caches_0_skip (void)
4745 str = getenv ("TEST_ONLY");
4747 return strstr (str, "drop_caches") == NULL;
4748 str = getenv ("SKIP_TEST_DROP_CACHES_0");
4749 if (str && strcmp (str, "1") == 0) return 1;
4750 str = getenv ("SKIP_TEST_DROP_CACHES");
4751 if (str && strcmp (str, "1") == 0) return 1;
4755 static int test_drop_caches_0 (void)
4757 if (test_drop_caches_0_skip ()) {
4758 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4762 /* InitNone|InitEmpty for test_drop_caches_0 */
4764 char device[] = "/dev/sda";
4767 r = guestfs_blockdev_setrw (g, device);
4774 r = guestfs_umount_all (g);
4781 r = guestfs_lvm_remove_all (g);
4785 /* TestRun for drop_caches (0) */
4789 r = guestfs_drop_caches (g, 3);
4796 static int test_mv_0_skip (void)
4800 str = getenv ("TEST_ONLY");
4802 return strstr (str, "mv") == NULL;
4803 str = getenv ("SKIP_TEST_MV_0");
4804 if (str && strcmp (str, "1") == 0) return 1;
4805 str = getenv ("SKIP_TEST_MV");
4806 if (str && strcmp (str, "1") == 0) return 1;
4810 static int test_mv_0 (void)
4812 if (test_mv_0_skip ()) {
4813 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4817 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4819 char device[] = "/dev/sda";
4822 r = guestfs_blockdev_setrw (g, device);
4829 r = guestfs_umount_all (g);
4836 r = guestfs_lvm_remove_all (g);
4841 char device[] = "/dev/sda";
4842 char lines_0[] = ",";
4849 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4854 char fstype[] = "ext2";
4855 char device[] = "/dev/sda1";
4858 r = guestfs_mkfs (g, fstype, device);
4863 char device[] = "/dev/sda1";
4864 char mountpoint[] = "/";
4867 r = guestfs_mount (g, device, mountpoint);
4871 /* TestOutput for mv (0) */
4872 char expected[] = "file content";
4874 char path[] = "/old";
4875 char content[] = "file content";
4878 r = guestfs_write_file (g, path, content, 0);
4883 char src[] = "/old";
4884 char dest[] = "/new";
4887 r = guestfs_mv (g, src, dest);
4892 char path[] = "/new";
4895 r = guestfs_cat (g, path);
4898 if (strcmp (r, expected) != 0) {
4899 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4907 static int test_mv_1_skip (void)
4911 str = getenv ("TEST_ONLY");
4913 return strstr (str, "mv") == NULL;
4914 str = getenv ("SKIP_TEST_MV_1");
4915 if (str && strcmp (str, "1") == 0) return 1;
4916 str = getenv ("SKIP_TEST_MV");
4917 if (str && strcmp (str, "1") == 0) return 1;
4921 static int test_mv_1 (void)
4923 if (test_mv_1_skip ()) {
4924 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4928 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4930 char device[] = "/dev/sda";
4933 r = guestfs_blockdev_setrw (g, device);
4940 r = guestfs_umount_all (g);
4947 r = guestfs_lvm_remove_all (g);
4952 char device[] = "/dev/sda";
4953 char lines_0[] = ",";
4960 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4965 char fstype[] = "ext2";
4966 char device[] = "/dev/sda1";
4969 r = guestfs_mkfs (g, fstype, device);
4974 char device[] = "/dev/sda1";
4975 char mountpoint[] = "/";
4978 r = guestfs_mount (g, device, mountpoint);
4982 /* TestOutputFalse for mv (1) */
4984 char path[] = "/old";
4985 char content[] = "file content";
4988 r = guestfs_write_file (g, path, content, 0);
4993 char src[] = "/old";
4994 char dest[] = "/new";
4997 r = guestfs_mv (g, src, dest);
5002 char path[] = "/old";
5005 r = guestfs_is_file (g, path);
5009 fprintf (stderr, "test_mv_1: expected false, got true\n");
5016 static int test_cp_a_0_skip (void)
5020 str = getenv ("TEST_ONLY");
5022 return strstr (str, "cp_a") == NULL;
5023 str = getenv ("SKIP_TEST_CP_A_0");
5024 if (str && strcmp (str, "1") == 0) return 1;
5025 str = getenv ("SKIP_TEST_CP_A");
5026 if (str && strcmp (str, "1") == 0) return 1;
5030 static int test_cp_a_0 (void)
5032 if (test_cp_a_0_skip ()) {
5033 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
5037 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
5039 char device[] = "/dev/sda";
5042 r = guestfs_blockdev_setrw (g, device);
5049 r = guestfs_umount_all (g);
5056 r = guestfs_lvm_remove_all (g);
5061 char device[] = "/dev/sda";
5062 char lines_0[] = ",";
5069 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5074 char fstype[] = "ext2";
5075 char device[] = "/dev/sda1";
5078 r = guestfs_mkfs (g, fstype, device);
5083 char device[] = "/dev/sda1";
5084 char mountpoint[] = "/";
5087 r = guestfs_mount (g, device, mountpoint);
5091 /* TestOutput for cp_a (0) */
5092 char expected[] = "file content";
5094 char path[] = "/olddir";
5097 r = guestfs_mkdir (g, path);
5102 char path[] = "/newdir";
5105 r = guestfs_mkdir (g, path);
5110 char path[] = "/olddir/file";
5111 char content[] = "file content";
5114 r = guestfs_write_file (g, path, content, 0);
5119 char src[] = "/olddir";
5120 char dest[] = "/newdir";
5123 r = guestfs_cp_a (g, src, dest);
5128 char path[] = "/newdir/olddir/file";
5131 r = guestfs_cat (g, path);
5134 if (strcmp (r, expected) != 0) {
5135 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
5143 static int test_cp_0_skip (void)
5147 str = getenv ("TEST_ONLY");
5149 return strstr (str, "cp") == NULL;
5150 str = getenv ("SKIP_TEST_CP_0");
5151 if (str && strcmp (str, "1") == 0) return 1;
5152 str = getenv ("SKIP_TEST_CP");
5153 if (str && strcmp (str, "1") == 0) return 1;
5157 static int test_cp_0 (void)
5159 if (test_cp_0_skip ()) {
5160 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
5164 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
5166 char device[] = "/dev/sda";
5169 r = guestfs_blockdev_setrw (g, device);
5176 r = guestfs_umount_all (g);
5183 r = guestfs_lvm_remove_all (g);
5188 char device[] = "/dev/sda";
5189 char lines_0[] = ",";
5196 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5201 char fstype[] = "ext2";
5202 char device[] = "/dev/sda1";
5205 r = guestfs_mkfs (g, fstype, device);
5210 char device[] = "/dev/sda1";
5211 char mountpoint[] = "/";
5214 r = guestfs_mount (g, device, mountpoint);
5218 /* TestOutput for cp (0) */
5219 char expected[] = "file content";
5221 char path[] = "/old";
5222 char content[] = "file content";
5225 r = guestfs_write_file (g, path, content, 0);
5230 char src[] = "/old";
5231 char dest[] = "/new";
5234 r = guestfs_cp (g, src, dest);
5239 char path[] = "/new";
5242 r = guestfs_cat (g, path);
5245 if (strcmp (r, expected) != 0) {
5246 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5254 static int test_cp_1_skip (void)
5258 str = getenv ("TEST_ONLY");
5260 return strstr (str, "cp") == NULL;
5261 str = getenv ("SKIP_TEST_CP_1");
5262 if (str && strcmp (str, "1") == 0) return 1;
5263 str = getenv ("SKIP_TEST_CP");
5264 if (str && strcmp (str, "1") == 0) return 1;
5268 static int test_cp_1 (void)
5270 if (test_cp_1_skip ()) {
5271 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5275 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5277 char device[] = "/dev/sda";
5280 r = guestfs_blockdev_setrw (g, device);
5287 r = guestfs_umount_all (g);
5294 r = guestfs_lvm_remove_all (g);
5299 char device[] = "/dev/sda";
5300 char lines_0[] = ",";
5307 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5312 char fstype[] = "ext2";
5313 char device[] = "/dev/sda1";
5316 r = guestfs_mkfs (g, fstype, device);
5321 char device[] = "/dev/sda1";
5322 char mountpoint[] = "/";
5325 r = guestfs_mount (g, device, mountpoint);
5329 /* TestOutputTrue for cp (1) */
5331 char path[] = "/old";
5332 char content[] = "file content";
5335 r = guestfs_write_file (g, path, content, 0);
5340 char src[] = "/old";
5341 char dest[] = "/new";
5344 r = guestfs_cp (g, src, dest);
5349 char path[] = "/old";
5352 r = guestfs_is_file (g, path);
5356 fprintf (stderr, "test_cp_1: expected true, got false\n");
5363 static int test_cp_2_skip (void)
5367 str = getenv ("TEST_ONLY");
5369 return strstr (str, "cp") == NULL;
5370 str = getenv ("SKIP_TEST_CP_2");
5371 if (str && strcmp (str, "1") == 0) return 1;
5372 str = getenv ("SKIP_TEST_CP");
5373 if (str && strcmp (str, "1") == 0) return 1;
5377 static int test_cp_2 (void)
5379 if (test_cp_2_skip ()) {
5380 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5384 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5386 char device[] = "/dev/sda";
5389 r = guestfs_blockdev_setrw (g, device);
5396 r = guestfs_umount_all (g);
5403 r = guestfs_lvm_remove_all (g);
5408 char device[] = "/dev/sda";
5409 char lines_0[] = ",";
5416 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5421 char fstype[] = "ext2";
5422 char device[] = "/dev/sda1";
5425 r = guestfs_mkfs (g, fstype, device);
5430 char device[] = "/dev/sda1";
5431 char mountpoint[] = "/";
5434 r = guestfs_mount (g, device, mountpoint);
5438 /* TestOutput for cp (2) */
5439 char expected[] = "file content";
5441 char path[] = "/old";
5442 char content[] = "file content";
5445 r = guestfs_write_file (g, path, content, 0);
5450 char path[] = "/dir";
5453 r = guestfs_mkdir (g, path);
5458 char src[] = "/old";
5459 char dest[] = "/dir/new";
5462 r = guestfs_cp (g, src, dest);
5467 char path[] = "/dir/new";
5470 r = guestfs_cat (g, path);
5473 if (strcmp (r, expected) != 0) {
5474 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5482 static int test_grub_install_0_skip (void)
5486 str = getenv ("TEST_ONLY");
5488 return strstr (str, "grub_install") == NULL;
5489 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5490 if (str && strcmp (str, "1") == 0) return 1;
5491 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5492 if (str && strcmp (str, "1") == 0) return 1;
5496 static int test_grub_install_0 (void)
5498 if (test_grub_install_0_skip ()) {
5499 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5503 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5505 char device[] = "/dev/sda";
5508 r = guestfs_blockdev_setrw (g, device);
5515 r = guestfs_umount_all (g);
5522 r = guestfs_lvm_remove_all (g);
5527 char device[] = "/dev/sda";
5528 char lines_0[] = ",";
5535 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5540 char fstype[] = "ext2";
5541 char device[] = "/dev/sda1";
5544 r = guestfs_mkfs (g, fstype, device);
5549 char device[] = "/dev/sda1";
5550 char mountpoint[] = "/";
5553 r = guestfs_mount (g, device, mountpoint);
5557 /* TestOutputTrue for grub_install (0) */
5560 char device[] = "/dev/sda1";
5563 r = guestfs_grub_install (g, root, device);
5568 char path[] = "/boot";
5571 r = guestfs_is_dir (g, path);
5575 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5582 static int test_zero_0_skip (void)
5586 str = getenv ("TEST_ONLY");
5588 return strstr (str, "zero") == NULL;
5589 str = getenv ("SKIP_TEST_ZERO_0");
5590 if (str && strcmp (str, "1") == 0) return 1;
5591 str = getenv ("SKIP_TEST_ZERO");
5592 if (str && strcmp (str, "1") == 0) return 1;
5596 static int test_zero_0 (void)
5598 if (test_zero_0_skip ()) {
5599 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5603 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5605 char device[] = "/dev/sda";
5608 r = guestfs_blockdev_setrw (g, device);
5615 r = guestfs_umount_all (g);
5622 r = guestfs_lvm_remove_all (g);
5627 char device[] = "/dev/sda";
5628 char lines_0[] = ",";
5635 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5640 char fstype[] = "ext2";
5641 char device[] = "/dev/sda1";
5644 r = guestfs_mkfs (g, fstype, device);
5649 char device[] = "/dev/sda1";
5650 char mountpoint[] = "/";
5653 r = guestfs_mount (g, device, mountpoint);
5657 /* TestOutput for zero (0) */
5658 char expected[] = "data";
5660 char pathordevice[] = "/dev/sda1";
5663 r = guestfs_umount (g, pathordevice);
5668 char device[] = "/dev/sda1";
5671 r = guestfs_zero (g, device);
5676 char path[] = "/dev/sda1";
5679 r = guestfs_file (g, path);
5682 if (strcmp (r, expected) != 0) {
5683 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5691 static int test_fsck_0_skip (void)
5695 str = getenv ("TEST_ONLY");
5697 return strstr (str, "fsck") == NULL;
5698 str = getenv ("SKIP_TEST_FSCK_0");
5699 if (str && strcmp (str, "1") == 0) return 1;
5700 str = getenv ("SKIP_TEST_FSCK");
5701 if (str && strcmp (str, "1") == 0) return 1;
5705 static int test_fsck_0 (void)
5707 if (test_fsck_0_skip ()) {
5708 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5712 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5714 char device[] = "/dev/sda";
5717 r = guestfs_blockdev_setrw (g, device);
5724 r = guestfs_umount_all (g);
5731 r = guestfs_lvm_remove_all (g);
5736 char device[] = "/dev/sda";
5737 char lines_0[] = ",";
5744 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5749 char fstype[] = "ext2";
5750 char device[] = "/dev/sda1";
5753 r = guestfs_mkfs (g, fstype, device);
5758 char device[] = "/dev/sda1";
5759 char mountpoint[] = "/";
5762 r = guestfs_mount (g, device, mountpoint);
5766 /* TestOutputInt for fsck (0) */
5768 char pathordevice[] = "/dev/sda1";
5771 r = guestfs_umount (g, pathordevice);
5776 char fstype[] = "ext2";
5777 char device[] = "/dev/sda1";
5780 r = guestfs_fsck (g, fstype, device);
5784 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
5791 static int test_fsck_1_skip (void)
5795 str = getenv ("TEST_ONLY");
5797 return strstr (str, "fsck") == NULL;
5798 str = getenv ("SKIP_TEST_FSCK_1");
5799 if (str && strcmp (str, "1") == 0) return 1;
5800 str = getenv ("SKIP_TEST_FSCK");
5801 if (str && strcmp (str, "1") == 0) return 1;
5805 static int test_fsck_1 (void)
5807 if (test_fsck_1_skip ()) {
5808 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5812 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5814 char device[] = "/dev/sda";
5817 r = guestfs_blockdev_setrw (g, device);
5824 r = guestfs_umount_all (g);
5831 r = guestfs_lvm_remove_all (g);
5836 char device[] = "/dev/sda";
5837 char lines_0[] = ",";
5844 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5849 char fstype[] = "ext2";
5850 char device[] = "/dev/sda1";
5853 r = guestfs_mkfs (g, fstype, device);
5858 char device[] = "/dev/sda1";
5859 char mountpoint[] = "/";
5862 r = guestfs_mount (g, device, mountpoint);
5866 /* TestOutputInt for fsck (1) */
5868 char pathordevice[] = "/dev/sda1";
5871 r = guestfs_umount (g, pathordevice);
5876 char device[] = "/dev/sda1";
5879 r = guestfs_zero (g, device);
5884 char fstype[] = "ext2";
5885 char device[] = "/dev/sda1";
5888 r = guestfs_fsck (g, fstype, device);
5892 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
5899 static int test_set_e2uuid_0_skip (void)
5903 str = getenv ("TEST_ONLY");
5905 return strstr (str, "set_e2uuid") == NULL;
5906 str = getenv ("SKIP_TEST_SET_E2UUID_0");
5907 if (str && strcmp (str, "1") == 0) return 1;
5908 str = getenv ("SKIP_TEST_SET_E2UUID");
5909 if (str && strcmp (str, "1") == 0) return 1;
5913 static int test_set_e2uuid_0 (void)
5915 if (test_set_e2uuid_0_skip ()) {
5916 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5920 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5922 char device[] = "/dev/sda";
5925 r = guestfs_blockdev_setrw (g, device);
5932 r = guestfs_umount_all (g);
5939 r = guestfs_lvm_remove_all (g);
5944 char device[] = "/dev/sda";
5945 char lines_0[] = ",";
5952 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5957 char fstype[] = "ext2";
5958 char device[] = "/dev/sda1";
5961 r = guestfs_mkfs (g, fstype, device);
5966 char device[] = "/dev/sda1";
5967 char mountpoint[] = "/";
5970 r = guestfs_mount (g, device, mountpoint);
5974 /* TestOutput for set_e2uuid (0) */
5975 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5977 char device[] = "/dev/sda1";
5978 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5981 r = guestfs_set_e2uuid (g, device, uuid);
5986 char device[] = "/dev/sda1";
5989 r = guestfs_get_e2uuid (g, device);
5992 if (strcmp (r, expected) != 0) {
5993 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
6001 static int test_set_e2uuid_1_skip (void)
6005 str = getenv ("TEST_ONLY");
6007 return strstr (str, "set_e2uuid") == NULL;
6008 str = getenv ("SKIP_TEST_SET_E2UUID_1");
6009 if (str && strcmp (str, "1") == 0) return 1;
6010 str = getenv ("SKIP_TEST_SET_E2UUID");
6011 if (str && strcmp (str, "1") == 0) return 1;
6015 static int test_set_e2uuid_1 (void)
6017 if (test_set_e2uuid_1_skip ()) {
6018 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
6022 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
6024 char device[] = "/dev/sda";
6027 r = guestfs_blockdev_setrw (g, device);
6034 r = guestfs_umount_all (g);
6041 r = guestfs_lvm_remove_all (g);
6046 char device[] = "/dev/sda";
6047 char lines_0[] = ",";
6054 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6059 char fstype[] = "ext2";
6060 char device[] = "/dev/sda1";
6063 r = guestfs_mkfs (g, fstype, device);
6068 char device[] = "/dev/sda1";
6069 char mountpoint[] = "/";
6072 r = guestfs_mount (g, device, mountpoint);
6076 /* TestOutput for set_e2uuid (1) */
6077 char expected[] = "";
6079 char device[] = "/dev/sda1";
6080 char uuid[] = "clear";
6083 r = guestfs_set_e2uuid (g, device, uuid);
6088 char device[] = "/dev/sda1";
6091 r = guestfs_get_e2uuid (g, device);
6094 if (strcmp (r, expected) != 0) {
6095 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
6103 static int test_set_e2uuid_2_skip (void)
6107 str = getenv ("TEST_ONLY");
6109 return strstr (str, "set_e2uuid") == NULL;
6110 str = getenv ("SKIP_TEST_SET_E2UUID_2");
6111 if (str && strcmp (str, "1") == 0) return 1;
6112 str = getenv ("SKIP_TEST_SET_E2UUID");
6113 if (str && strcmp (str, "1") == 0) return 1;
6117 static int test_set_e2uuid_2 (void)
6119 if (test_set_e2uuid_2_skip ()) {
6120 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
6124 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
6126 char device[] = "/dev/sda";
6129 r = guestfs_blockdev_setrw (g, device);
6136 r = guestfs_umount_all (g);
6143 r = guestfs_lvm_remove_all (g);
6148 char device[] = "/dev/sda";
6149 char lines_0[] = ",";
6156 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6161 char fstype[] = "ext2";
6162 char device[] = "/dev/sda1";
6165 r = guestfs_mkfs (g, fstype, device);
6170 char device[] = "/dev/sda1";
6171 char mountpoint[] = "/";
6174 r = guestfs_mount (g, device, mountpoint);
6178 /* TestRun for set_e2uuid (2) */
6180 char device[] = "/dev/sda1";
6181 char uuid[] = "random";
6184 r = guestfs_set_e2uuid (g, device, uuid);
6191 static int test_set_e2uuid_3_skip (void)
6195 str = getenv ("TEST_ONLY");
6197 return strstr (str, "set_e2uuid") == NULL;
6198 str = getenv ("SKIP_TEST_SET_E2UUID_3");
6199 if (str && strcmp (str, "1") == 0) return 1;
6200 str = getenv ("SKIP_TEST_SET_E2UUID");
6201 if (str && strcmp (str, "1") == 0) return 1;
6205 static int test_set_e2uuid_3 (void)
6207 if (test_set_e2uuid_3_skip ()) {
6208 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6212 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6214 char device[] = "/dev/sda";
6217 r = guestfs_blockdev_setrw (g, device);
6224 r = guestfs_umount_all (g);
6231 r = guestfs_lvm_remove_all (g);
6236 char device[] = "/dev/sda";
6237 char lines_0[] = ",";
6244 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6249 char fstype[] = "ext2";
6250 char device[] = "/dev/sda1";
6253 r = guestfs_mkfs (g, fstype, device);
6258 char device[] = "/dev/sda1";
6259 char mountpoint[] = "/";
6262 r = guestfs_mount (g, device, mountpoint);
6266 /* TestRun for set_e2uuid (3) */
6268 char device[] = "/dev/sda1";
6269 char uuid[] = "time";
6272 r = guestfs_set_e2uuid (g, device, uuid);
6279 static int test_set_e2label_0_skip (void)
6283 str = getenv ("TEST_ONLY");
6285 return strstr (str, "set_e2label") == NULL;
6286 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6287 if (str && strcmp (str, "1") == 0) return 1;
6288 str = getenv ("SKIP_TEST_SET_E2LABEL");
6289 if (str && strcmp (str, "1") == 0) return 1;
6293 static int test_set_e2label_0 (void)
6295 if (test_set_e2label_0_skip ()) {
6296 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6300 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6302 char device[] = "/dev/sda";
6305 r = guestfs_blockdev_setrw (g, device);
6312 r = guestfs_umount_all (g);
6319 r = guestfs_lvm_remove_all (g);
6324 char device[] = "/dev/sda";
6325 char lines_0[] = ",";
6332 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6337 char fstype[] = "ext2";
6338 char device[] = "/dev/sda1";
6341 r = guestfs_mkfs (g, fstype, device);
6346 char device[] = "/dev/sda1";
6347 char mountpoint[] = "/";
6350 r = guestfs_mount (g, device, mountpoint);
6354 /* TestOutput for set_e2label (0) */
6355 char expected[] = "testlabel";
6357 char device[] = "/dev/sda1";
6358 char label[] = "testlabel";
6361 r = guestfs_set_e2label (g, device, label);
6366 char device[] = "/dev/sda1";
6369 r = guestfs_get_e2label (g, device);
6372 if (strcmp (r, expected) != 0) {
6373 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6381 static int test_pvremove_0_skip (void)
6385 str = getenv ("TEST_ONLY");
6387 return strstr (str, "pvremove") == NULL;
6388 str = getenv ("SKIP_TEST_PVREMOVE_0");
6389 if (str && strcmp (str, "1") == 0) return 1;
6390 str = getenv ("SKIP_TEST_PVREMOVE");
6391 if (str && strcmp (str, "1") == 0) return 1;
6395 static int test_pvremove_0 (void)
6397 if (test_pvremove_0_skip ()) {
6398 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6402 /* InitNone|InitEmpty for test_pvremove_0 */
6404 char device[] = "/dev/sda";
6407 r = guestfs_blockdev_setrw (g, device);
6414 r = guestfs_umount_all (g);
6421 r = guestfs_lvm_remove_all (g);
6425 /* TestOutputListOfDevices for pvremove (0) */
6427 char device[] = "/dev/sda";
6428 char lines_0[] = ",";
6435 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6440 char device[] = "/dev/sda1";
6443 r = guestfs_pvcreate (g, device);
6448 char volgroup[] = "VG";
6449 char physvols_0[] = "/dev/sda1";
6450 char *physvols[] = {
6456 r = guestfs_vgcreate (g, volgroup, physvols);
6461 char logvol[] = "LV1";
6462 char volgroup[] = "VG";
6465 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6470 char logvol[] = "LV2";
6471 char volgroup[] = "VG";
6474 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6479 char vgname[] = "VG";
6482 r = guestfs_vgremove (g, vgname);
6487 char device[] = "/dev/sda1";
6490 r = guestfs_pvremove (g, device);
6498 r = guestfs_lvs (g);
6502 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6506 for (i = 0; r[i] != NULL; ++i)
6513 static int test_pvremove_1_skip (void)
6517 str = getenv ("TEST_ONLY");
6519 return strstr (str, "pvremove") == NULL;
6520 str = getenv ("SKIP_TEST_PVREMOVE_1");
6521 if (str && strcmp (str, "1") == 0) return 1;
6522 str = getenv ("SKIP_TEST_PVREMOVE");
6523 if (str && strcmp (str, "1") == 0) return 1;
6527 static int test_pvremove_1 (void)
6529 if (test_pvremove_1_skip ()) {
6530 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6534 /* InitNone|InitEmpty for test_pvremove_1 */
6536 char device[] = "/dev/sda";
6539 r = guestfs_blockdev_setrw (g, device);
6546 r = guestfs_umount_all (g);
6553 r = guestfs_lvm_remove_all (g);
6557 /* TestOutputListOfDevices for pvremove (1) */
6559 char device[] = "/dev/sda";
6560 char lines_0[] = ",";
6567 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6572 char device[] = "/dev/sda1";
6575 r = guestfs_pvcreate (g, device);
6580 char volgroup[] = "VG";
6581 char physvols_0[] = "/dev/sda1";
6582 char *physvols[] = {
6588 r = guestfs_vgcreate (g, volgroup, physvols);
6593 char logvol[] = "LV1";
6594 char volgroup[] = "VG";
6597 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6602 char logvol[] = "LV2";
6603 char volgroup[] = "VG";
6606 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6611 char vgname[] = "VG";
6614 r = guestfs_vgremove (g, vgname);
6619 char device[] = "/dev/sda1";
6622 r = guestfs_pvremove (g, device);
6630 r = guestfs_vgs (g);
6634 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6638 for (i = 0; r[i] != NULL; ++i)
6645 static int test_pvremove_2_skip (void)
6649 str = getenv ("TEST_ONLY");
6651 return strstr (str, "pvremove") == NULL;
6652 str = getenv ("SKIP_TEST_PVREMOVE_2");
6653 if (str && strcmp (str, "1") == 0) return 1;
6654 str = getenv ("SKIP_TEST_PVREMOVE");
6655 if (str && strcmp (str, "1") == 0) return 1;
6659 static int test_pvremove_2 (void)
6661 if (test_pvremove_2_skip ()) {
6662 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6666 /* InitNone|InitEmpty for test_pvremove_2 */
6668 char device[] = "/dev/sda";
6671 r = guestfs_blockdev_setrw (g, device);
6678 r = guestfs_umount_all (g);
6685 r = guestfs_lvm_remove_all (g);
6689 /* TestOutputListOfDevices for pvremove (2) */
6691 char device[] = "/dev/sda";
6692 char lines_0[] = ",";
6699 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6704 char device[] = "/dev/sda1";
6707 r = guestfs_pvcreate (g, device);
6712 char volgroup[] = "VG";
6713 char physvols_0[] = "/dev/sda1";
6714 char *physvols[] = {
6720 r = guestfs_vgcreate (g, volgroup, physvols);
6725 char logvol[] = "LV1";
6726 char volgroup[] = "VG";
6729 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6734 char logvol[] = "LV2";
6735 char volgroup[] = "VG";
6738 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6743 char vgname[] = "VG";
6746 r = guestfs_vgremove (g, vgname);
6751 char device[] = "/dev/sda1";
6754 r = guestfs_pvremove (g, device);
6762 r = guestfs_pvs (g);
6766 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6770 for (i = 0; r[i] != NULL; ++i)
6777 static int test_vgremove_0_skip (void)
6781 str = getenv ("TEST_ONLY");
6783 return strstr (str, "vgremove") == NULL;
6784 str = getenv ("SKIP_TEST_VGREMOVE_0");
6785 if (str && strcmp (str, "1") == 0) return 1;
6786 str = getenv ("SKIP_TEST_VGREMOVE");
6787 if (str && strcmp (str, "1") == 0) return 1;
6791 static int test_vgremove_0 (void)
6793 if (test_vgremove_0_skip ()) {
6794 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6798 /* InitNone|InitEmpty for test_vgremove_0 */
6800 char device[] = "/dev/sda";
6803 r = guestfs_blockdev_setrw (g, device);
6810 r = guestfs_umount_all (g);
6817 r = guestfs_lvm_remove_all (g);
6821 /* TestOutputList for vgremove (0) */
6823 char device[] = "/dev/sda";
6824 char lines_0[] = ",";
6831 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6836 char device[] = "/dev/sda1";
6839 r = guestfs_pvcreate (g, device);
6844 char volgroup[] = "VG";
6845 char physvols_0[] = "/dev/sda1";
6846 char *physvols[] = {
6852 r = guestfs_vgcreate (g, volgroup, physvols);
6857 char logvol[] = "LV1";
6858 char volgroup[] = "VG";
6861 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6866 char logvol[] = "LV2";
6867 char volgroup[] = "VG";
6870 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6875 char vgname[] = "VG";
6878 r = guestfs_vgremove (g, vgname);
6886 r = guestfs_lvs (g);
6890 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6894 for (i = 0; r[i] != NULL; ++i)
6901 static int test_vgremove_1_skip (void)
6905 str = getenv ("TEST_ONLY");
6907 return strstr (str, "vgremove") == NULL;
6908 str = getenv ("SKIP_TEST_VGREMOVE_1");
6909 if (str && strcmp (str, "1") == 0) return 1;
6910 str = getenv ("SKIP_TEST_VGREMOVE");
6911 if (str && strcmp (str, "1") == 0) return 1;
6915 static int test_vgremove_1 (void)
6917 if (test_vgremove_1_skip ()) {
6918 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6922 /* InitNone|InitEmpty for test_vgremove_1 */
6924 char device[] = "/dev/sda";
6927 r = guestfs_blockdev_setrw (g, device);
6934 r = guestfs_umount_all (g);
6941 r = guestfs_lvm_remove_all (g);
6945 /* TestOutputList for vgremove (1) */
6947 char device[] = "/dev/sda";
6948 char lines_0[] = ",";
6955 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6960 char device[] = "/dev/sda1";
6963 r = guestfs_pvcreate (g, device);
6968 char volgroup[] = "VG";
6969 char physvols_0[] = "/dev/sda1";
6970 char *physvols[] = {
6976 r = guestfs_vgcreate (g, volgroup, physvols);
6981 char logvol[] = "LV1";
6982 char volgroup[] = "VG";
6985 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6990 char logvol[] = "LV2";
6991 char volgroup[] = "VG";
6994 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6999 char vgname[] = "VG";
7002 r = guestfs_vgremove (g, vgname);
7010 r = guestfs_vgs (g);
7014 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
7018 for (i = 0; r[i] != NULL; ++i)
7025 static int test_lvremove_0_skip (void)
7029 str = getenv ("TEST_ONLY");
7031 return strstr (str, "lvremove") == NULL;
7032 str = getenv ("SKIP_TEST_LVREMOVE_0");
7033 if (str && strcmp (str, "1") == 0) return 1;
7034 str = getenv ("SKIP_TEST_LVREMOVE");
7035 if (str && strcmp (str, "1") == 0) return 1;
7039 static int test_lvremove_0 (void)
7041 if (test_lvremove_0_skip ()) {
7042 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
7046 /* InitNone|InitEmpty for test_lvremove_0 */
7048 char device[] = "/dev/sda";
7051 r = guestfs_blockdev_setrw (g, device);
7058 r = guestfs_umount_all (g);
7065 r = guestfs_lvm_remove_all (g);
7069 /* TestOutputList for lvremove (0) */
7071 char device[] = "/dev/sda";
7072 char lines_0[] = ",";
7079 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7084 char device[] = "/dev/sda1";
7087 r = guestfs_pvcreate (g, device);
7092 char volgroup[] = "VG";
7093 char physvols_0[] = "/dev/sda1";
7094 char *physvols[] = {
7100 r = guestfs_vgcreate (g, volgroup, physvols);
7105 char logvol[] = "LV1";
7106 char volgroup[] = "VG";
7109 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7114 char logvol[] = "LV2";
7115 char volgroup[] = "VG";
7118 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7123 char device[] = "/dev/VG/LV1";
7126 r = guestfs_lvremove (g, device);
7134 r = guestfs_lvs (g);
7138 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
7143 char expected[] = "/dev/VG/LV2";
7144 if (strcmp (r[0], expected) != 0) {
7145 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7150 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
7154 for (i = 0; r[i] != NULL; ++i)
7161 static int test_lvremove_1_skip (void)
7165 str = getenv ("TEST_ONLY");
7167 return strstr (str, "lvremove") == NULL;
7168 str = getenv ("SKIP_TEST_LVREMOVE_1");
7169 if (str && strcmp (str, "1") == 0) return 1;
7170 str = getenv ("SKIP_TEST_LVREMOVE");
7171 if (str && strcmp (str, "1") == 0) return 1;
7175 static int test_lvremove_1 (void)
7177 if (test_lvremove_1_skip ()) {
7178 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
7182 /* InitNone|InitEmpty for test_lvremove_1 */
7184 char device[] = "/dev/sda";
7187 r = guestfs_blockdev_setrw (g, device);
7194 r = guestfs_umount_all (g);
7201 r = guestfs_lvm_remove_all (g);
7205 /* TestOutputList for lvremove (1) */
7207 char device[] = "/dev/sda";
7208 char lines_0[] = ",";
7215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7220 char device[] = "/dev/sda1";
7223 r = guestfs_pvcreate (g, device);
7228 char volgroup[] = "VG";
7229 char physvols_0[] = "/dev/sda1";
7230 char *physvols[] = {
7236 r = guestfs_vgcreate (g, volgroup, physvols);
7241 char logvol[] = "LV1";
7242 char volgroup[] = "VG";
7245 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7250 char logvol[] = "LV2";
7251 char volgroup[] = "VG";
7254 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7259 char device[] = "/dev/VG";
7262 r = guestfs_lvremove (g, device);
7270 r = guestfs_lvs (g);
7274 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7278 for (i = 0; r[i] != NULL; ++i)
7285 static int test_lvremove_2_skip (void)
7289 str = getenv ("TEST_ONLY");
7291 return strstr (str, "lvremove") == NULL;
7292 str = getenv ("SKIP_TEST_LVREMOVE_2");
7293 if (str && strcmp (str, "1") == 0) return 1;
7294 str = getenv ("SKIP_TEST_LVREMOVE");
7295 if (str && strcmp (str, "1") == 0) return 1;
7299 static int test_lvremove_2 (void)
7301 if (test_lvremove_2_skip ()) {
7302 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7306 /* InitNone|InitEmpty for test_lvremove_2 */
7308 char device[] = "/dev/sda";
7311 r = guestfs_blockdev_setrw (g, device);
7318 r = guestfs_umount_all (g);
7325 r = guestfs_lvm_remove_all (g);
7329 /* TestOutputList for lvremove (2) */
7331 char device[] = "/dev/sda";
7332 char lines_0[] = ",";
7339 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7344 char device[] = "/dev/sda1";
7347 r = guestfs_pvcreate (g, device);
7352 char volgroup[] = "VG";
7353 char physvols_0[] = "/dev/sda1";
7354 char *physvols[] = {
7360 r = guestfs_vgcreate (g, volgroup, physvols);
7365 char logvol[] = "LV1";
7366 char volgroup[] = "VG";
7369 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7374 char logvol[] = "LV2";
7375 char volgroup[] = "VG";
7378 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7383 char device[] = "/dev/VG";
7386 r = guestfs_lvremove (g, device);
7394 r = guestfs_vgs (g);
7398 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7403 char expected[] = "VG";
7404 if (strcmp (r[0], expected) != 0) {
7405 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7410 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7414 for (i = 0; r[i] != NULL; ++i)
7421 static int test_mount_ro_0_skip (void)
7425 str = getenv ("TEST_ONLY");
7427 return strstr (str, "mount_ro") == NULL;
7428 str = getenv ("SKIP_TEST_MOUNT_RO_0");
7429 if (str && strcmp (str, "1") == 0) return 1;
7430 str = getenv ("SKIP_TEST_MOUNT_RO");
7431 if (str && strcmp (str, "1") == 0) return 1;
7435 static int test_mount_ro_0 (void)
7437 if (test_mount_ro_0_skip ()) {
7438 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7442 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7444 char device[] = "/dev/sda";
7447 r = guestfs_blockdev_setrw (g, device);
7454 r = guestfs_umount_all (g);
7461 r = guestfs_lvm_remove_all (g);
7466 char device[] = "/dev/sda";
7467 char lines_0[] = ",";
7474 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7479 char fstype[] = "ext2";
7480 char device[] = "/dev/sda1";
7483 r = guestfs_mkfs (g, fstype, device);
7488 char device[] = "/dev/sda1";
7489 char mountpoint[] = "/";
7492 r = guestfs_mount (g, device, mountpoint);
7496 /* TestLastFail for mount_ro (0) */
7498 char pathordevice[] = "/";
7501 r = guestfs_umount (g, pathordevice);
7506 char device[] = "/dev/sda1";
7507 char mountpoint[] = "/";
7510 r = guestfs_mount_ro (g, device, mountpoint);
7515 char path[] = "/new";
7518 r = guestfs_touch (g, path);
7525 static int test_mount_ro_1_skip (void)
7529 str = getenv ("TEST_ONLY");
7531 return strstr (str, "mount_ro") == NULL;
7532 str = getenv ("SKIP_TEST_MOUNT_RO_1");
7533 if (str && strcmp (str, "1") == 0) return 1;
7534 str = getenv ("SKIP_TEST_MOUNT_RO");
7535 if (str && strcmp (str, "1") == 0) return 1;
7539 static int test_mount_ro_1 (void)
7541 if (test_mount_ro_1_skip ()) {
7542 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7546 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7548 char device[] = "/dev/sda";
7551 r = guestfs_blockdev_setrw (g, device);
7558 r = guestfs_umount_all (g);
7565 r = guestfs_lvm_remove_all (g);
7570 char device[] = "/dev/sda";
7571 char lines_0[] = ",";
7578 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7583 char fstype[] = "ext2";
7584 char device[] = "/dev/sda1";
7587 r = guestfs_mkfs (g, fstype, device);
7592 char device[] = "/dev/sda1";
7593 char mountpoint[] = "/";
7596 r = guestfs_mount (g, device, mountpoint);
7600 /* TestOutput for mount_ro (1) */
7601 char expected[] = "data";
7603 char path[] = "/new";
7604 char content[] = "data";
7607 r = guestfs_write_file (g, path, content, 0);
7612 char pathordevice[] = "/";
7615 r = guestfs_umount (g, pathordevice);
7620 char device[] = "/dev/sda1";
7621 char mountpoint[] = "/";
7624 r = guestfs_mount_ro (g, device, mountpoint);
7629 char path[] = "/new";
7632 r = guestfs_cat (g, path);
7635 if (strcmp (r, expected) != 0) {
7636 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7644 static int test_tgz_in_0_skip (void)
7648 str = getenv ("TEST_ONLY");
7650 return strstr (str, "tgz_in") == NULL;
7651 str = getenv ("SKIP_TEST_TGZ_IN_0");
7652 if (str && strcmp (str, "1") == 0) return 1;
7653 str = getenv ("SKIP_TEST_TGZ_IN");
7654 if (str && strcmp (str, "1") == 0) return 1;
7658 static int test_tgz_in_0 (void)
7660 if (test_tgz_in_0_skip ()) {
7661 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7665 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7667 char device[] = "/dev/sda";
7670 r = guestfs_blockdev_setrw (g, device);
7677 r = guestfs_umount_all (g);
7684 r = guestfs_lvm_remove_all (g);
7689 char device[] = "/dev/sda";
7690 char lines_0[] = ",";
7697 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7702 char fstype[] = "ext2";
7703 char device[] = "/dev/sda1";
7706 r = guestfs_mkfs (g, fstype, device);
7711 char device[] = "/dev/sda1";
7712 char mountpoint[] = "/";
7715 r = guestfs_mount (g, device, mountpoint);
7719 /* TestOutput for tgz_in (0) */
7720 char expected[] = "hello\n";
7722 char directory[] = "/";
7725 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7730 char path[] = "/hello";
7733 r = guestfs_cat (g, path);
7736 if (strcmp (r, expected) != 0) {
7737 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7745 static int test_tar_in_0_skip (void)
7749 str = getenv ("TEST_ONLY");
7751 return strstr (str, "tar_in") == NULL;
7752 str = getenv ("SKIP_TEST_TAR_IN_0");
7753 if (str && strcmp (str, "1") == 0) return 1;
7754 str = getenv ("SKIP_TEST_TAR_IN");
7755 if (str && strcmp (str, "1") == 0) return 1;
7759 static int test_tar_in_0 (void)
7761 if (test_tar_in_0_skip ()) {
7762 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7766 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7768 char device[] = "/dev/sda";
7771 r = guestfs_blockdev_setrw (g, device);
7778 r = guestfs_umount_all (g);
7785 r = guestfs_lvm_remove_all (g);
7790 char device[] = "/dev/sda";
7791 char lines_0[] = ",";
7798 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7803 char fstype[] = "ext2";
7804 char device[] = "/dev/sda1";
7807 r = guestfs_mkfs (g, fstype, device);
7812 char device[] = "/dev/sda1";
7813 char mountpoint[] = "/";
7816 r = guestfs_mount (g, device, mountpoint);
7820 /* TestOutput for tar_in (0) */
7821 char expected[] = "hello\n";
7823 char directory[] = "/";
7826 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7831 char path[] = "/hello";
7834 r = guestfs_cat (g, path);
7837 if (strcmp (r, expected) != 0) {
7838 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7846 static int test_checksum_0_skip (void)
7850 str = getenv ("TEST_ONLY");
7852 return strstr (str, "checksum") == NULL;
7853 str = getenv ("SKIP_TEST_CHECKSUM_0");
7854 if (str && strcmp (str, "1") == 0) return 1;
7855 str = getenv ("SKIP_TEST_CHECKSUM");
7856 if (str && strcmp (str, "1") == 0) return 1;
7860 static int test_checksum_0 (void)
7862 if (test_checksum_0_skip ()) {
7863 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7867 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7869 char device[] = "/dev/sda";
7872 r = guestfs_blockdev_setrw (g, device);
7879 r = guestfs_umount_all (g);
7886 r = guestfs_lvm_remove_all (g);
7891 char device[] = "/dev/sda";
7892 char lines_0[] = ",";
7899 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7904 char fstype[] = "ext2";
7905 char device[] = "/dev/sda1";
7908 r = guestfs_mkfs (g, fstype, device);
7913 char device[] = "/dev/sda1";
7914 char mountpoint[] = "/";
7917 r = guestfs_mount (g, device, mountpoint);
7921 /* TestOutput for checksum (0) */
7922 char expected[] = "935282863";
7924 char path[] = "/new";
7925 char content[] = "test\n";
7928 r = guestfs_write_file (g, path, content, 0);
7933 char csumtype[] = "crc";
7934 char path[] = "/new";
7937 r = guestfs_checksum (g, csumtype, path);
7940 if (strcmp (r, expected) != 0) {
7941 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7949 static int test_checksum_1_skip (void)
7953 str = getenv ("TEST_ONLY");
7955 return strstr (str, "checksum") == NULL;
7956 str = getenv ("SKIP_TEST_CHECKSUM_1");
7957 if (str && strcmp (str, "1") == 0) return 1;
7958 str = getenv ("SKIP_TEST_CHECKSUM");
7959 if (str && strcmp (str, "1") == 0) return 1;
7963 static int test_checksum_1 (void)
7965 if (test_checksum_1_skip ()) {
7966 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7970 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7972 char device[] = "/dev/sda";
7975 r = guestfs_blockdev_setrw (g, device);
7982 r = guestfs_umount_all (g);
7989 r = guestfs_lvm_remove_all (g);
7994 char device[] = "/dev/sda";
7995 char lines_0[] = ",";
8002 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8007 char fstype[] = "ext2";
8008 char device[] = "/dev/sda1";
8011 r = guestfs_mkfs (g, fstype, device);
8016 char device[] = "/dev/sda1";
8017 char mountpoint[] = "/";
8020 r = guestfs_mount (g, device, mountpoint);
8024 /* TestLastFail for checksum (1) */
8026 char csumtype[] = "crc";
8027 char path[] = "/new";
8030 r = guestfs_checksum (g, csumtype, path);
8038 static int test_checksum_2_skip (void)
8042 str = getenv ("TEST_ONLY");
8044 return strstr (str, "checksum") == NULL;
8045 str = getenv ("SKIP_TEST_CHECKSUM_2");
8046 if (str && strcmp (str, "1") == 0) return 1;
8047 str = getenv ("SKIP_TEST_CHECKSUM");
8048 if (str && strcmp (str, "1") == 0) return 1;
8052 static int test_checksum_2 (void)
8054 if (test_checksum_2_skip ()) {
8055 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
8059 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
8061 char device[] = "/dev/sda";
8064 r = guestfs_blockdev_setrw (g, device);
8071 r = guestfs_umount_all (g);
8078 r = guestfs_lvm_remove_all (g);
8083 char device[] = "/dev/sda";
8084 char lines_0[] = ",";
8091 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8096 char fstype[] = "ext2";
8097 char device[] = "/dev/sda1";
8100 r = guestfs_mkfs (g, fstype, device);
8105 char device[] = "/dev/sda1";
8106 char mountpoint[] = "/";
8109 r = guestfs_mount (g, device, mountpoint);
8113 /* TestOutput for checksum (2) */
8114 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
8116 char path[] = "/new";
8117 char content[] = "test\n";
8120 r = guestfs_write_file (g, path, content, 0);
8125 char csumtype[] = "md5";
8126 char path[] = "/new";
8129 r = guestfs_checksum (g, csumtype, path);
8132 if (strcmp (r, expected) != 0) {
8133 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
8141 static int test_checksum_3_skip (void)
8145 str = getenv ("TEST_ONLY");
8147 return strstr (str, "checksum") == NULL;
8148 str = getenv ("SKIP_TEST_CHECKSUM_3");
8149 if (str && strcmp (str, "1") == 0) return 1;
8150 str = getenv ("SKIP_TEST_CHECKSUM");
8151 if (str && strcmp (str, "1") == 0) return 1;
8155 static int test_checksum_3 (void)
8157 if (test_checksum_3_skip ()) {
8158 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
8162 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
8164 char device[] = "/dev/sda";
8167 r = guestfs_blockdev_setrw (g, device);
8174 r = guestfs_umount_all (g);
8181 r = guestfs_lvm_remove_all (g);
8186 char device[] = "/dev/sda";
8187 char lines_0[] = ",";
8194 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8199 char fstype[] = "ext2";
8200 char device[] = "/dev/sda1";
8203 r = guestfs_mkfs (g, fstype, device);
8208 char device[] = "/dev/sda1";
8209 char mountpoint[] = "/";
8212 r = guestfs_mount (g, device, mountpoint);
8216 /* TestOutput for checksum (3) */
8217 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8219 char path[] = "/new";
8220 char content[] = "test\n";
8223 r = guestfs_write_file (g, path, content, 0);
8228 char csumtype[] = "sha1";
8229 char path[] = "/new";
8232 r = guestfs_checksum (g, csumtype, path);
8235 if (strcmp (r, expected) != 0) {
8236 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8244 static int test_checksum_4_skip (void)
8248 str = getenv ("TEST_ONLY");
8250 return strstr (str, "checksum") == NULL;
8251 str = getenv ("SKIP_TEST_CHECKSUM_4");
8252 if (str && strcmp (str, "1") == 0) return 1;
8253 str = getenv ("SKIP_TEST_CHECKSUM");
8254 if (str && strcmp (str, "1") == 0) return 1;
8258 static int test_checksum_4 (void)
8260 if (test_checksum_4_skip ()) {
8261 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8265 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8267 char device[] = "/dev/sda";
8270 r = guestfs_blockdev_setrw (g, device);
8277 r = guestfs_umount_all (g);
8284 r = guestfs_lvm_remove_all (g);
8289 char device[] = "/dev/sda";
8290 char lines_0[] = ",";
8297 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8302 char fstype[] = "ext2";
8303 char device[] = "/dev/sda1";
8306 r = guestfs_mkfs (g, fstype, device);
8311 char device[] = "/dev/sda1";
8312 char mountpoint[] = "/";
8315 r = guestfs_mount (g, device, mountpoint);
8319 /* TestOutput for checksum (4) */
8320 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8322 char path[] = "/new";
8323 char content[] = "test\n";
8326 r = guestfs_write_file (g, path, content, 0);
8331 char csumtype[] = "sha224";
8332 char path[] = "/new";
8335 r = guestfs_checksum (g, csumtype, path);
8338 if (strcmp (r, expected) != 0) {
8339 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8347 static int test_checksum_5_skip (void)
8351 str = getenv ("TEST_ONLY");
8353 return strstr (str, "checksum") == NULL;
8354 str = getenv ("SKIP_TEST_CHECKSUM_5");
8355 if (str && strcmp (str, "1") == 0) return 1;
8356 str = getenv ("SKIP_TEST_CHECKSUM");
8357 if (str && strcmp (str, "1") == 0) return 1;
8361 static int test_checksum_5 (void)
8363 if (test_checksum_5_skip ()) {
8364 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8368 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8370 char device[] = "/dev/sda";
8373 r = guestfs_blockdev_setrw (g, device);
8380 r = guestfs_umount_all (g);
8387 r = guestfs_lvm_remove_all (g);
8392 char device[] = "/dev/sda";
8393 char lines_0[] = ",";
8400 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8405 char fstype[] = "ext2";
8406 char device[] = "/dev/sda1";
8409 r = guestfs_mkfs (g, fstype, device);
8414 char device[] = "/dev/sda1";
8415 char mountpoint[] = "/";
8418 r = guestfs_mount (g, device, mountpoint);
8422 /* TestOutput for checksum (5) */
8423 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8425 char path[] = "/new";
8426 char content[] = "test\n";
8429 r = guestfs_write_file (g, path, content, 0);
8434 char csumtype[] = "sha256";
8435 char path[] = "/new";
8438 r = guestfs_checksum (g, csumtype, path);
8441 if (strcmp (r, expected) != 0) {
8442 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8450 static int test_checksum_6_skip (void)
8454 str = getenv ("TEST_ONLY");
8456 return strstr (str, "checksum") == NULL;
8457 str = getenv ("SKIP_TEST_CHECKSUM_6");
8458 if (str && strcmp (str, "1") == 0) return 1;
8459 str = getenv ("SKIP_TEST_CHECKSUM");
8460 if (str && strcmp (str, "1") == 0) return 1;
8464 static int test_checksum_6 (void)
8466 if (test_checksum_6_skip ()) {
8467 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8471 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8473 char device[] = "/dev/sda";
8476 r = guestfs_blockdev_setrw (g, device);
8483 r = guestfs_umount_all (g);
8490 r = guestfs_lvm_remove_all (g);
8495 char device[] = "/dev/sda";
8496 char lines_0[] = ",";
8503 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8508 char fstype[] = "ext2";
8509 char device[] = "/dev/sda1";
8512 r = guestfs_mkfs (g, fstype, device);
8517 char device[] = "/dev/sda1";
8518 char mountpoint[] = "/";
8521 r = guestfs_mount (g, device, mountpoint);
8525 /* TestOutput for checksum (6) */
8526 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8528 char path[] = "/new";
8529 char content[] = "test\n";
8532 r = guestfs_write_file (g, path, content, 0);
8537 char csumtype[] = "sha384";
8538 char path[] = "/new";
8541 r = guestfs_checksum (g, csumtype, path);
8544 if (strcmp (r, expected) != 0) {
8545 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8553 static int test_checksum_7_skip (void)
8557 str = getenv ("TEST_ONLY");
8559 return strstr (str, "checksum") == NULL;
8560 str = getenv ("SKIP_TEST_CHECKSUM_7");
8561 if (str && strcmp (str, "1") == 0) return 1;
8562 str = getenv ("SKIP_TEST_CHECKSUM");
8563 if (str && strcmp (str, "1") == 0) return 1;
8567 static int test_checksum_7 (void)
8569 if (test_checksum_7_skip ()) {
8570 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8574 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8576 char device[] = "/dev/sda";
8579 r = guestfs_blockdev_setrw (g, device);
8586 r = guestfs_umount_all (g);
8593 r = guestfs_lvm_remove_all (g);
8598 char device[] = "/dev/sda";
8599 char lines_0[] = ",";
8606 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8611 char fstype[] = "ext2";
8612 char device[] = "/dev/sda1";
8615 r = guestfs_mkfs (g, fstype, device);
8620 char device[] = "/dev/sda1";
8621 char mountpoint[] = "/";
8624 r = guestfs_mount (g, device, mountpoint);
8628 /* TestOutput for checksum (7) */
8629 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8631 char path[] = "/new";
8632 char content[] = "test\n";
8635 r = guestfs_write_file (g, path, content, 0);
8640 char csumtype[] = "sha512";
8641 char path[] = "/new";
8644 r = guestfs_checksum (g, csumtype, path);
8647 if (strcmp (r, expected) != 0) {
8648 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8656 static int test_checksum_8_skip (void)
8660 str = getenv ("TEST_ONLY");
8662 return strstr (str, "checksum") == NULL;
8663 str = getenv ("SKIP_TEST_CHECKSUM_8");
8664 if (str && strcmp (str, "1") == 0) return 1;
8665 str = getenv ("SKIP_TEST_CHECKSUM");
8666 if (str && strcmp (str, "1") == 0) return 1;
8670 static int test_checksum_8 (void)
8672 if (test_checksum_8_skip ()) {
8673 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8677 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8679 char device[] = "/dev/sda";
8682 r = guestfs_blockdev_setrw (g, device);
8689 r = guestfs_umount_all (g);
8696 r = guestfs_lvm_remove_all (g);
8701 char device[] = "/dev/sda";
8702 char lines_0[] = ",";
8709 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8714 char fstype[] = "ext2";
8715 char device[] = "/dev/sda1";
8718 r = guestfs_mkfs (g, fstype, device);
8723 char device[] = "/dev/sda1";
8724 char mountpoint[] = "/";
8727 r = guestfs_mount (g, device, mountpoint);
8731 /* TestOutput for checksum (8) */
8732 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8734 char options[] = "ro";
8735 char vfstype[] = "squashfs";
8736 char device[] = "/dev/sdd";
8737 char mountpoint[] = "/";
8740 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8745 char csumtype[] = "md5";
8746 char path[] = "/known-3";
8749 r = guestfs_checksum (g, csumtype, path);
8752 if (strcmp (r, expected) != 0) {
8753 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8761 static int test_download_0_skip (void)
8765 str = getenv ("TEST_ONLY");
8767 return strstr (str, "download") == NULL;
8768 str = getenv ("SKIP_TEST_DOWNLOAD_0");
8769 if (str && strcmp (str, "1") == 0) return 1;
8770 str = getenv ("SKIP_TEST_DOWNLOAD");
8771 if (str && strcmp (str, "1") == 0) return 1;
8775 static int test_download_0 (void)
8777 if (test_download_0_skip ()) {
8778 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8782 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8784 char device[] = "/dev/sda";
8787 r = guestfs_blockdev_setrw (g, device);
8794 r = guestfs_umount_all (g);
8801 r = guestfs_lvm_remove_all (g);
8806 char device[] = "/dev/sda";
8807 char lines_0[] = ",";
8814 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8819 char fstype[] = "ext2";
8820 char device[] = "/dev/sda1";
8823 r = guestfs_mkfs (g, fstype, device);
8828 char device[] = "/dev/sda1";
8829 char mountpoint[] = "/";
8832 r = guestfs_mount (g, device, mountpoint);
8836 /* TestOutput for download (0) */
8837 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8839 char remotefilename[] = "/COPYING.LIB";
8842 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8847 char remotefilename[] = "/COPYING.LIB";
8850 r = guestfs_download (g, remotefilename, "testdownload.tmp");
8855 char remotefilename[] = "/upload";
8858 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8863 char csumtype[] = "md5";
8864 char path[] = "/upload";
8867 r = guestfs_checksum (g, csumtype, path);
8870 if (strcmp (r, expected) != 0) {
8871 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8879 static int test_upload_0_skip (void)
8883 str = getenv ("TEST_ONLY");
8885 return strstr (str, "upload") == NULL;
8886 str = getenv ("SKIP_TEST_UPLOAD_0");
8887 if (str && strcmp (str, "1") == 0) return 1;
8888 str = getenv ("SKIP_TEST_UPLOAD");
8889 if (str && strcmp (str, "1") == 0) return 1;
8893 static int test_upload_0 (void)
8895 if (test_upload_0_skip ()) {
8896 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8900 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8902 char device[] = "/dev/sda";
8905 r = guestfs_blockdev_setrw (g, device);
8912 r = guestfs_umount_all (g);
8919 r = guestfs_lvm_remove_all (g);
8924 char device[] = "/dev/sda";
8925 char lines_0[] = ",";
8932 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8937 char fstype[] = "ext2";
8938 char device[] = "/dev/sda1";
8941 r = guestfs_mkfs (g, fstype, device);
8946 char device[] = "/dev/sda1";
8947 char mountpoint[] = "/";
8950 r = guestfs_mount (g, device, mountpoint);
8954 /* TestOutput for upload (0) */
8955 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8957 char remotefilename[] = "/COPYING.LIB";
8960 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8965 char csumtype[] = "md5";
8966 char path[] = "/COPYING.LIB";
8969 r = guestfs_checksum (g, csumtype, path);
8972 if (strcmp (r, expected) != 0) {
8973 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8981 static int test_blockdev_rereadpt_0_skip (void)
8985 str = getenv ("TEST_ONLY");
8987 return strstr (str, "blockdev_rereadpt") == NULL;
8988 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8989 if (str && strcmp (str, "1") == 0) return 1;
8990 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8991 if (str && strcmp (str, "1") == 0) return 1;
8995 static int test_blockdev_rereadpt_0 (void)
8997 if (test_blockdev_rereadpt_0_skip ()) {
8998 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
9002 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
9004 char device[] = "/dev/sda";
9007 r = guestfs_blockdev_setrw (g, device);
9014 r = guestfs_umount_all (g);
9021 r = guestfs_lvm_remove_all (g);
9025 /* TestRun for blockdev_rereadpt (0) */
9027 char device[] = "/dev/sda";
9030 r = guestfs_blockdev_rereadpt (g, device);
9037 static int test_blockdev_flushbufs_0_skip (void)
9041 str = getenv ("TEST_ONLY");
9043 return strstr (str, "blockdev_flushbufs") == NULL;
9044 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
9045 if (str && strcmp (str, "1") == 0) return 1;
9046 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
9047 if (str && strcmp (str, "1") == 0) return 1;
9051 static int test_blockdev_flushbufs_0 (void)
9053 if (test_blockdev_flushbufs_0_skip ()) {
9054 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
9058 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
9060 char device[] = "/dev/sda";
9063 r = guestfs_blockdev_setrw (g, device);
9070 r = guestfs_umount_all (g);
9077 r = guestfs_lvm_remove_all (g);
9081 /* TestRun for blockdev_flushbufs (0) */
9083 char device[] = "/dev/sda";
9086 r = guestfs_blockdev_flushbufs (g, device);
9093 static int test_blockdev_getsize64_0_skip (void)
9097 str = getenv ("TEST_ONLY");
9099 return strstr (str, "blockdev_getsize64") == NULL;
9100 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
9101 if (str && strcmp (str, "1") == 0) return 1;
9102 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
9103 if (str && strcmp (str, "1") == 0) return 1;
9107 static int test_blockdev_getsize64_0 (void)
9109 if (test_blockdev_getsize64_0_skip ()) {
9110 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
9114 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
9116 char device[] = "/dev/sda";
9119 r = guestfs_blockdev_setrw (g, device);
9126 r = guestfs_umount_all (g);
9133 r = guestfs_lvm_remove_all (g);
9137 /* TestOutputInt for blockdev_getsize64 (0) */
9139 char device[] = "/dev/sda";
9142 r = guestfs_blockdev_getsize64 (g, device);
9145 if (r != 524288000) {
9146 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
9153 static int test_blockdev_getsz_0_skip (void)
9157 str = getenv ("TEST_ONLY");
9159 return strstr (str, "blockdev_getsz") == NULL;
9160 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
9161 if (str && strcmp (str, "1") == 0) return 1;
9162 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
9163 if (str && strcmp (str, "1") == 0) return 1;
9167 static int test_blockdev_getsz_0 (void)
9169 if (test_blockdev_getsz_0_skip ()) {
9170 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
9174 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
9176 char device[] = "/dev/sda";
9179 r = guestfs_blockdev_setrw (g, device);
9186 r = guestfs_umount_all (g);
9193 r = guestfs_lvm_remove_all (g);
9197 /* TestOutputInt for blockdev_getsz (0) */
9199 char device[] = "/dev/sda";
9202 r = guestfs_blockdev_getsz (g, device);
9206 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
9213 static int test_blockdev_getbsz_0_skip (void)
9217 str = getenv ("TEST_ONLY");
9219 return strstr (str, "blockdev_getbsz") == NULL;
9220 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9221 if (str && strcmp (str, "1") == 0) return 1;
9222 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9223 if (str && strcmp (str, "1") == 0) return 1;
9227 static int test_blockdev_getbsz_0 (void)
9229 if (test_blockdev_getbsz_0_skip ()) {
9230 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9234 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9236 char device[] = "/dev/sda";
9239 r = guestfs_blockdev_setrw (g, device);
9246 r = guestfs_umount_all (g);
9253 r = guestfs_lvm_remove_all (g);
9257 /* TestOutputInt for blockdev_getbsz (0) */
9259 char device[] = "/dev/sda";
9262 r = guestfs_blockdev_getbsz (g, device);
9266 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
9273 static int test_blockdev_getss_0_skip (void)
9277 str = getenv ("TEST_ONLY");
9279 return strstr (str, "blockdev_getss") == NULL;
9280 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9281 if (str && strcmp (str, "1") == 0) return 1;
9282 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9283 if (str && strcmp (str, "1") == 0) return 1;
9287 static int test_blockdev_getss_0 (void)
9289 if (test_blockdev_getss_0_skip ()) {
9290 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9294 /* InitNone|InitEmpty for test_blockdev_getss_0 */
9296 char device[] = "/dev/sda";
9299 r = guestfs_blockdev_setrw (g, device);
9306 r = guestfs_umount_all (g);
9313 r = guestfs_lvm_remove_all (g);
9317 /* TestOutputInt for blockdev_getss (0) */
9319 char device[] = "/dev/sda";
9322 r = guestfs_blockdev_getss (g, device);
9326 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
9333 static int test_blockdev_getro_0_skip (void)
9337 str = getenv ("TEST_ONLY");
9339 return strstr (str, "blockdev_getro") == NULL;
9340 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9341 if (str && strcmp (str, "1") == 0) return 1;
9342 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9343 if (str && strcmp (str, "1") == 0) return 1;
9347 static int test_blockdev_getro_0 (void)
9349 if (test_blockdev_getro_0_skip ()) {
9350 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9354 /* InitNone|InitEmpty for test_blockdev_getro_0 */
9356 char device[] = "/dev/sda";
9359 r = guestfs_blockdev_setrw (g, device);
9366 r = guestfs_umount_all (g);
9373 r = guestfs_lvm_remove_all (g);
9377 /* TestOutputTrue for blockdev_getro (0) */
9379 char device[] = "/dev/sda";
9382 r = guestfs_blockdev_setro (g, device);
9387 char device[] = "/dev/sda";
9390 r = guestfs_blockdev_getro (g, device);
9394 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9401 static int test_blockdev_setrw_0_skip (void)
9405 str = getenv ("TEST_ONLY");
9407 return strstr (str, "blockdev_setrw") == NULL;
9408 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9409 if (str && strcmp (str, "1") == 0) return 1;
9410 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9411 if (str && strcmp (str, "1") == 0) return 1;
9415 static int test_blockdev_setrw_0 (void)
9417 if (test_blockdev_setrw_0_skip ()) {
9418 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9422 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9424 char device[] = "/dev/sda";
9427 r = guestfs_blockdev_setrw (g, device);
9434 r = guestfs_umount_all (g);
9441 r = guestfs_lvm_remove_all (g);
9445 /* TestOutputFalse for blockdev_setrw (0) */
9447 char device[] = "/dev/sda";
9450 r = guestfs_blockdev_setrw (g, device);
9455 char device[] = "/dev/sda";
9458 r = guestfs_blockdev_getro (g, device);
9462 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9469 static int test_blockdev_setro_0_skip (void)
9473 str = getenv ("TEST_ONLY");
9475 return strstr (str, "blockdev_setro") == NULL;
9476 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9477 if (str && strcmp (str, "1") == 0) return 1;
9478 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9479 if (str && strcmp (str, "1") == 0) return 1;
9483 static int test_blockdev_setro_0 (void)
9485 if (test_blockdev_setro_0_skip ()) {
9486 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9490 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9492 char device[] = "/dev/sda";
9495 r = guestfs_blockdev_setrw (g, device);
9502 r = guestfs_umount_all (g);
9509 r = guestfs_lvm_remove_all (g);
9513 /* TestOutputTrue for blockdev_setro (0) */
9515 char device[] = "/dev/sda";
9518 r = guestfs_blockdev_setro (g, device);
9523 char device[] = "/dev/sda";
9526 r = guestfs_blockdev_getro (g, device);
9530 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9537 static int test_statvfs_0_skip (void)
9541 str = getenv ("TEST_ONLY");
9543 return strstr (str, "statvfs") == NULL;
9544 str = getenv ("SKIP_TEST_STATVFS_0");
9545 if (str && strcmp (str, "1") == 0) return 1;
9546 str = getenv ("SKIP_TEST_STATVFS");
9547 if (str && strcmp (str, "1") == 0) return 1;
9551 static int test_statvfs_0 (void)
9553 if (test_statvfs_0_skip ()) {
9554 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9558 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9560 char device[] = "/dev/sda";
9563 r = guestfs_blockdev_setrw (g, device);
9570 r = guestfs_umount_all (g);
9577 r = guestfs_lvm_remove_all (g);
9582 char device[] = "/dev/sda";
9583 char lines_0[] = ",";
9590 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9595 char fstype[] = "ext2";
9596 char device[] = "/dev/sda1";
9599 r = guestfs_mkfs (g, fstype, device);
9604 char device[] = "/dev/sda1";
9605 char mountpoint[] = "/";
9608 r = guestfs_mount (g, device, mountpoint);
9612 /* TestOutputStruct for statvfs (0) */
9615 struct guestfs_statvfs *r;
9617 r = guestfs_statvfs (g, path);
9620 if (r->bfree != 487702) {
9621 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9625 if (r->blocks != 490020) {
9626 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9630 if (r->bsize != 1024) {
9631 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9640 static int test_lstat_0_skip (void)
9644 str = getenv ("TEST_ONLY");
9646 return strstr (str, "lstat") == NULL;
9647 str = getenv ("SKIP_TEST_LSTAT_0");
9648 if (str && strcmp (str, "1") == 0) return 1;
9649 str = getenv ("SKIP_TEST_LSTAT");
9650 if (str && strcmp (str, "1") == 0) return 1;
9654 static int test_lstat_0 (void)
9656 if (test_lstat_0_skip ()) {
9657 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9661 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9663 char device[] = "/dev/sda";
9666 r = guestfs_blockdev_setrw (g, device);
9673 r = guestfs_umount_all (g);
9680 r = guestfs_lvm_remove_all (g);
9685 char device[] = "/dev/sda";
9686 char lines_0[] = ",";
9693 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9698 char fstype[] = "ext2";
9699 char device[] = "/dev/sda1";
9702 r = guestfs_mkfs (g, fstype, device);
9707 char device[] = "/dev/sda1";
9708 char mountpoint[] = "/";
9711 r = guestfs_mount (g, device, mountpoint);
9715 /* TestOutputStruct for lstat (0) */
9717 char path[] = "/new";
9720 r = guestfs_touch (g, path);
9725 char path[] = "/new";
9726 struct guestfs_stat *r;
9728 r = guestfs_lstat (g, path);
9732 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9741 static int test_stat_0_skip (void)
9745 str = getenv ("TEST_ONLY");
9747 return strstr (str, "stat") == NULL;
9748 str = getenv ("SKIP_TEST_STAT_0");
9749 if (str && strcmp (str, "1") == 0) return 1;
9750 str = getenv ("SKIP_TEST_STAT");
9751 if (str && strcmp (str, "1") == 0) return 1;
9755 static int test_stat_0 (void)
9757 if (test_stat_0_skip ()) {
9758 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9762 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9764 char device[] = "/dev/sda";
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 char lines_0[] = ",";
9794 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9799 char fstype[] = "ext2";
9800 char device[] = "/dev/sda1";
9803 r = guestfs_mkfs (g, fstype, device);
9808 char device[] = "/dev/sda1";
9809 char mountpoint[] = "/";
9812 r = guestfs_mount (g, device, mountpoint);
9816 /* TestOutputStruct for stat (0) */
9818 char path[] = "/new";
9821 r = guestfs_touch (g, path);
9826 char path[] = "/new";
9827 struct guestfs_stat *r;
9829 r = guestfs_stat (g, path);
9833 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9842 static int test_command_lines_0_skip (void)
9846 str = getenv ("TEST_ONLY");
9848 return strstr (str, "command_lines") == NULL;
9849 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9850 if (str && strcmp (str, "1") == 0) return 1;
9851 str = getenv ("SKIP_TEST_COMMAND_LINES");
9852 if (str && strcmp (str, "1") == 0) return 1;
9856 static int test_command_lines_0 (void)
9858 if (test_command_lines_0_skip ()) {
9859 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9863 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9865 char device[] = "/dev/sda";
9868 r = guestfs_blockdev_setrw (g, device);
9875 r = guestfs_umount_all (g);
9882 r = guestfs_lvm_remove_all (g);
9887 char device[] = "/dev/sda";
9888 char lines_0[] = ",";
9895 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9900 char fstype[] = "ext2";
9901 char device[] = "/dev/sda1";
9904 r = guestfs_mkfs (g, fstype, device);
9909 char device[] = "/dev/sda1";
9910 char mountpoint[] = "/";
9913 r = guestfs_mount (g, device, mountpoint);
9917 /* TestOutputList for command_lines (0) */
9919 char remotefilename[] = "/test-command";
9922 r = guestfs_upload (g, "test-command", remotefilename);
9927 char path[] = "/test-command";
9930 r = guestfs_chmod (g, 493, path);
9935 char arguments_0[] = "/test-command";
9936 char arguments_1[] = "1";
9937 char *arguments[] = {
9945 r = guestfs_command_lines (g, arguments);
9949 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9954 char expected[] = "Result1";
9955 if (strcmp (r[0], expected) != 0) {
9956 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9961 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9965 for (i = 0; r[i] != NULL; ++i)
9972 static int test_command_lines_1_skip (void)
9976 str = getenv ("TEST_ONLY");
9978 return strstr (str, "command_lines") == NULL;
9979 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9980 if (str && strcmp (str, "1") == 0) return 1;
9981 str = getenv ("SKIP_TEST_COMMAND_LINES");
9982 if (str && strcmp (str, "1") == 0) return 1;
9986 static int test_command_lines_1 (void)
9988 if (test_command_lines_1_skip ()) {
9989 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9993 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9995 char device[] = "/dev/sda";
9998 r = guestfs_blockdev_setrw (g, device);
10004 suppress_error = 0;
10005 r = guestfs_umount_all (g);
10011 suppress_error = 0;
10012 r = guestfs_lvm_remove_all (g);
10017 char device[] = "/dev/sda";
10018 char lines_0[] = ",";
10024 suppress_error = 0;
10025 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10030 char fstype[] = "ext2";
10031 char device[] = "/dev/sda1";
10033 suppress_error = 0;
10034 r = guestfs_mkfs (g, fstype, device);
10039 char device[] = "/dev/sda1";
10040 char mountpoint[] = "/";
10042 suppress_error = 0;
10043 r = guestfs_mount (g, device, mountpoint);
10047 /* TestOutputList for command_lines (1) */
10049 char remotefilename[] = "/test-command";
10051 suppress_error = 0;
10052 r = guestfs_upload (g, "test-command", remotefilename);
10057 char path[] = "/test-command";
10059 suppress_error = 0;
10060 r = guestfs_chmod (g, 493, path);
10065 char arguments_0[] = "/test-command";
10066 char arguments_1[] = "2";
10067 char *arguments[] = {
10074 suppress_error = 0;
10075 r = guestfs_command_lines (g, arguments);
10079 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
10084 char expected[] = "Result2";
10085 if (strcmp (r[0], expected) != 0) {
10086 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10090 if (r[1] != NULL) {
10091 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
10095 for (i = 0; r[i] != NULL; ++i)
10102 static int test_command_lines_2_skip (void)
10106 str = getenv ("TEST_ONLY");
10108 return strstr (str, "command_lines") == NULL;
10109 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
10110 if (str && strcmp (str, "1") == 0) return 1;
10111 str = getenv ("SKIP_TEST_COMMAND_LINES");
10112 if (str && strcmp (str, "1") == 0) return 1;
10116 static int test_command_lines_2 (void)
10118 if (test_command_lines_2_skip ()) {
10119 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
10123 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
10125 char device[] = "/dev/sda";
10127 suppress_error = 0;
10128 r = guestfs_blockdev_setrw (g, device);
10134 suppress_error = 0;
10135 r = guestfs_umount_all (g);
10141 suppress_error = 0;
10142 r = guestfs_lvm_remove_all (g);
10147 char device[] = "/dev/sda";
10148 char lines_0[] = ",";
10154 suppress_error = 0;
10155 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10160 char fstype[] = "ext2";
10161 char device[] = "/dev/sda1";
10163 suppress_error = 0;
10164 r = guestfs_mkfs (g, fstype, device);
10169 char device[] = "/dev/sda1";
10170 char mountpoint[] = "/";
10172 suppress_error = 0;
10173 r = guestfs_mount (g, device, mountpoint);
10177 /* TestOutputList for command_lines (2) */
10179 char remotefilename[] = "/test-command";
10181 suppress_error = 0;
10182 r = guestfs_upload (g, "test-command", remotefilename);
10187 char path[] = "/test-command";
10189 suppress_error = 0;
10190 r = guestfs_chmod (g, 493, path);
10195 char arguments_0[] = "/test-command";
10196 char arguments_1[] = "3";
10197 char *arguments[] = {
10204 suppress_error = 0;
10205 r = guestfs_command_lines (g, arguments);
10209 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10214 char expected[] = "";
10215 if (strcmp (r[0], expected) != 0) {
10216 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10221 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10226 char expected[] = "Result3";
10227 if (strcmp (r[1], expected) != 0) {
10228 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10232 if (r[2] != NULL) {
10233 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10237 for (i = 0; r[i] != NULL; ++i)
10244 static int test_command_lines_3_skip (void)
10248 str = getenv ("TEST_ONLY");
10250 return strstr (str, "command_lines") == NULL;
10251 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10252 if (str && strcmp (str, "1") == 0) return 1;
10253 str = getenv ("SKIP_TEST_COMMAND_LINES");
10254 if (str && strcmp (str, "1") == 0) return 1;
10258 static int test_command_lines_3 (void)
10260 if (test_command_lines_3_skip ()) {
10261 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10265 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10267 char device[] = "/dev/sda";
10269 suppress_error = 0;
10270 r = guestfs_blockdev_setrw (g, device);
10276 suppress_error = 0;
10277 r = guestfs_umount_all (g);
10283 suppress_error = 0;
10284 r = guestfs_lvm_remove_all (g);
10289 char device[] = "/dev/sda";
10290 char lines_0[] = ",";
10296 suppress_error = 0;
10297 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10302 char fstype[] = "ext2";
10303 char device[] = "/dev/sda1";
10305 suppress_error = 0;
10306 r = guestfs_mkfs (g, fstype, device);
10311 char device[] = "/dev/sda1";
10312 char mountpoint[] = "/";
10314 suppress_error = 0;
10315 r = guestfs_mount (g, device, mountpoint);
10319 /* TestOutputList for command_lines (3) */
10321 char remotefilename[] = "/test-command";
10323 suppress_error = 0;
10324 r = guestfs_upload (g, "test-command", remotefilename);
10329 char path[] = "/test-command";
10331 suppress_error = 0;
10332 r = guestfs_chmod (g, 493, path);
10337 char arguments_0[] = "/test-command";
10338 char arguments_1[] = "4";
10339 char *arguments[] = {
10346 suppress_error = 0;
10347 r = guestfs_command_lines (g, arguments);
10351 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10356 char expected[] = "";
10357 if (strcmp (r[0], expected) != 0) {
10358 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10363 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10368 char expected[] = "Result4";
10369 if (strcmp (r[1], expected) != 0) {
10370 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10374 if (r[2] != NULL) {
10375 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10379 for (i = 0; r[i] != NULL; ++i)
10386 static int test_command_lines_4_skip (void)
10390 str = getenv ("TEST_ONLY");
10392 return strstr (str, "command_lines") == NULL;
10393 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10394 if (str && strcmp (str, "1") == 0) return 1;
10395 str = getenv ("SKIP_TEST_COMMAND_LINES");
10396 if (str && strcmp (str, "1") == 0) return 1;
10400 static int test_command_lines_4 (void)
10402 if (test_command_lines_4_skip ()) {
10403 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10407 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10409 char device[] = "/dev/sda";
10411 suppress_error = 0;
10412 r = guestfs_blockdev_setrw (g, device);
10418 suppress_error = 0;
10419 r = guestfs_umount_all (g);
10425 suppress_error = 0;
10426 r = guestfs_lvm_remove_all (g);
10431 char device[] = "/dev/sda";
10432 char lines_0[] = ",";
10438 suppress_error = 0;
10439 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10444 char fstype[] = "ext2";
10445 char device[] = "/dev/sda1";
10447 suppress_error = 0;
10448 r = guestfs_mkfs (g, fstype, device);
10453 char device[] = "/dev/sda1";
10454 char mountpoint[] = "/";
10456 suppress_error = 0;
10457 r = guestfs_mount (g, device, mountpoint);
10461 /* TestOutputList for command_lines (4) */
10463 char remotefilename[] = "/test-command";
10465 suppress_error = 0;
10466 r = guestfs_upload (g, "test-command", remotefilename);
10471 char path[] = "/test-command";
10473 suppress_error = 0;
10474 r = guestfs_chmod (g, 493, path);
10479 char arguments_0[] = "/test-command";
10480 char arguments_1[] = "5";
10481 char *arguments[] = {
10488 suppress_error = 0;
10489 r = guestfs_command_lines (g, arguments);
10493 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10498 char expected[] = "";
10499 if (strcmp (r[0], expected) != 0) {
10500 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10505 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10510 char expected[] = "Result5";
10511 if (strcmp (r[1], expected) != 0) {
10512 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10517 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10522 char expected[] = "";
10523 if (strcmp (r[2], expected) != 0) {
10524 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10528 if (r[3] != NULL) {
10529 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10533 for (i = 0; r[i] != NULL; ++i)
10540 static int test_command_lines_5_skip (void)
10544 str = getenv ("TEST_ONLY");
10546 return strstr (str, "command_lines") == NULL;
10547 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10548 if (str && strcmp (str, "1") == 0) return 1;
10549 str = getenv ("SKIP_TEST_COMMAND_LINES");
10550 if (str && strcmp (str, "1") == 0) return 1;
10554 static int test_command_lines_5 (void)
10556 if (test_command_lines_5_skip ()) {
10557 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10561 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10563 char device[] = "/dev/sda";
10565 suppress_error = 0;
10566 r = guestfs_blockdev_setrw (g, device);
10572 suppress_error = 0;
10573 r = guestfs_umount_all (g);
10579 suppress_error = 0;
10580 r = guestfs_lvm_remove_all (g);
10585 char device[] = "/dev/sda";
10586 char lines_0[] = ",";
10592 suppress_error = 0;
10593 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10598 char fstype[] = "ext2";
10599 char device[] = "/dev/sda1";
10601 suppress_error = 0;
10602 r = guestfs_mkfs (g, fstype, device);
10607 char device[] = "/dev/sda1";
10608 char mountpoint[] = "/";
10610 suppress_error = 0;
10611 r = guestfs_mount (g, device, mountpoint);
10615 /* TestOutputList for command_lines (5) */
10617 char remotefilename[] = "/test-command";
10619 suppress_error = 0;
10620 r = guestfs_upload (g, "test-command", remotefilename);
10625 char path[] = "/test-command";
10627 suppress_error = 0;
10628 r = guestfs_chmod (g, 493, path);
10633 char arguments_0[] = "/test-command";
10634 char arguments_1[] = "6";
10635 char *arguments[] = {
10642 suppress_error = 0;
10643 r = guestfs_command_lines (g, arguments);
10647 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10652 char expected[] = "";
10653 if (strcmp (r[0], expected) != 0) {
10654 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10659 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10664 char expected[] = "";
10665 if (strcmp (r[1], expected) != 0) {
10666 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10671 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10676 char expected[] = "Result6";
10677 if (strcmp (r[2], expected) != 0) {
10678 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10683 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10688 char expected[] = "";
10689 if (strcmp (r[3], expected) != 0) {
10690 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10694 if (r[4] != NULL) {
10695 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10699 for (i = 0; r[i] != NULL; ++i)
10706 static int test_command_lines_6_skip (void)
10710 str = getenv ("TEST_ONLY");
10712 return strstr (str, "command_lines") == NULL;
10713 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10714 if (str && strcmp (str, "1") == 0) return 1;
10715 str = getenv ("SKIP_TEST_COMMAND_LINES");
10716 if (str && strcmp (str, "1") == 0) return 1;
10720 static int test_command_lines_6 (void)
10722 if (test_command_lines_6_skip ()) {
10723 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10727 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10729 char device[] = "/dev/sda";
10731 suppress_error = 0;
10732 r = guestfs_blockdev_setrw (g, device);
10738 suppress_error = 0;
10739 r = guestfs_umount_all (g);
10745 suppress_error = 0;
10746 r = guestfs_lvm_remove_all (g);
10751 char device[] = "/dev/sda";
10752 char lines_0[] = ",";
10758 suppress_error = 0;
10759 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10764 char fstype[] = "ext2";
10765 char device[] = "/dev/sda1";
10767 suppress_error = 0;
10768 r = guestfs_mkfs (g, fstype, device);
10773 char device[] = "/dev/sda1";
10774 char mountpoint[] = "/";
10776 suppress_error = 0;
10777 r = guestfs_mount (g, device, mountpoint);
10781 /* TestOutputList for command_lines (6) */
10783 char remotefilename[] = "/test-command";
10785 suppress_error = 0;
10786 r = guestfs_upload (g, "test-command", remotefilename);
10791 char path[] = "/test-command";
10793 suppress_error = 0;
10794 r = guestfs_chmod (g, 493, path);
10799 char arguments_0[] = "/test-command";
10800 char arguments_1[] = "7";
10801 char *arguments[] = {
10808 suppress_error = 0;
10809 r = guestfs_command_lines (g, arguments);
10812 if (r[0] != NULL) {
10813 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10817 for (i = 0; r[i] != NULL; ++i)
10824 static int test_command_lines_7_skip (void)
10828 str = getenv ("TEST_ONLY");
10830 return strstr (str, "command_lines") == NULL;
10831 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10832 if (str && strcmp (str, "1") == 0) return 1;
10833 str = getenv ("SKIP_TEST_COMMAND_LINES");
10834 if (str && strcmp (str, "1") == 0) return 1;
10838 static int test_command_lines_7 (void)
10840 if (test_command_lines_7_skip ()) {
10841 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10845 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10847 char device[] = "/dev/sda";
10849 suppress_error = 0;
10850 r = guestfs_blockdev_setrw (g, device);
10856 suppress_error = 0;
10857 r = guestfs_umount_all (g);
10863 suppress_error = 0;
10864 r = guestfs_lvm_remove_all (g);
10869 char device[] = "/dev/sda";
10870 char lines_0[] = ",";
10876 suppress_error = 0;
10877 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10882 char fstype[] = "ext2";
10883 char device[] = "/dev/sda1";
10885 suppress_error = 0;
10886 r = guestfs_mkfs (g, fstype, device);
10891 char device[] = "/dev/sda1";
10892 char mountpoint[] = "/";
10894 suppress_error = 0;
10895 r = guestfs_mount (g, device, mountpoint);
10899 /* TestOutputList for command_lines (7) */
10901 char remotefilename[] = "/test-command";
10903 suppress_error = 0;
10904 r = guestfs_upload (g, "test-command", remotefilename);
10909 char path[] = "/test-command";
10911 suppress_error = 0;
10912 r = guestfs_chmod (g, 493, path);
10917 char arguments_0[] = "/test-command";
10918 char arguments_1[] = "8";
10919 char *arguments[] = {
10926 suppress_error = 0;
10927 r = guestfs_command_lines (g, arguments);
10931 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10936 char expected[] = "";
10937 if (strcmp (r[0], expected) != 0) {
10938 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10942 if (r[1] != NULL) {
10943 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10947 for (i = 0; r[i] != NULL; ++i)
10954 static int test_command_lines_8_skip (void)
10958 str = getenv ("TEST_ONLY");
10960 return strstr (str, "command_lines") == NULL;
10961 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10962 if (str && strcmp (str, "1") == 0) return 1;
10963 str = getenv ("SKIP_TEST_COMMAND_LINES");
10964 if (str && strcmp (str, "1") == 0) return 1;
10968 static int test_command_lines_8 (void)
10970 if (test_command_lines_8_skip ()) {
10971 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10975 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10977 char device[] = "/dev/sda";
10979 suppress_error = 0;
10980 r = guestfs_blockdev_setrw (g, device);
10986 suppress_error = 0;
10987 r = guestfs_umount_all (g);
10993 suppress_error = 0;
10994 r = guestfs_lvm_remove_all (g);
10999 char device[] = "/dev/sda";
11000 char lines_0[] = ",";
11006 suppress_error = 0;
11007 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11012 char fstype[] = "ext2";
11013 char device[] = "/dev/sda1";
11015 suppress_error = 0;
11016 r = guestfs_mkfs (g, fstype, device);
11021 char device[] = "/dev/sda1";
11022 char mountpoint[] = "/";
11024 suppress_error = 0;
11025 r = guestfs_mount (g, device, mountpoint);
11029 /* TestOutputList for command_lines (8) */
11031 char remotefilename[] = "/test-command";
11033 suppress_error = 0;
11034 r = guestfs_upload (g, "test-command", remotefilename);
11039 char path[] = "/test-command";
11041 suppress_error = 0;
11042 r = guestfs_chmod (g, 493, path);
11047 char arguments_0[] = "/test-command";
11048 char arguments_1[] = "9";
11049 char *arguments[] = {
11056 suppress_error = 0;
11057 r = guestfs_command_lines (g, arguments);
11061 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11066 char expected[] = "";
11067 if (strcmp (r[0], expected) != 0) {
11068 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11073 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
11078 char expected[] = "";
11079 if (strcmp (r[1], expected) != 0) {
11080 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11084 if (r[2] != NULL) {
11085 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
11089 for (i = 0; r[i] != NULL; ++i)
11096 static int test_command_lines_9_skip (void)
11100 str = getenv ("TEST_ONLY");
11102 return strstr (str, "command_lines") == NULL;
11103 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
11104 if (str && strcmp (str, "1") == 0) return 1;
11105 str = getenv ("SKIP_TEST_COMMAND_LINES");
11106 if (str && strcmp (str, "1") == 0) return 1;
11110 static int test_command_lines_9 (void)
11112 if (test_command_lines_9_skip ()) {
11113 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
11117 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
11119 char device[] = "/dev/sda";
11121 suppress_error = 0;
11122 r = guestfs_blockdev_setrw (g, device);
11128 suppress_error = 0;
11129 r = guestfs_umount_all (g);
11135 suppress_error = 0;
11136 r = guestfs_lvm_remove_all (g);
11141 char device[] = "/dev/sda";
11142 char lines_0[] = ",";
11148 suppress_error = 0;
11149 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11154 char fstype[] = "ext2";
11155 char device[] = "/dev/sda1";
11157 suppress_error = 0;
11158 r = guestfs_mkfs (g, fstype, device);
11163 char device[] = "/dev/sda1";
11164 char mountpoint[] = "/";
11166 suppress_error = 0;
11167 r = guestfs_mount (g, device, mountpoint);
11171 /* TestOutputList for command_lines (9) */
11173 char remotefilename[] = "/test-command";
11175 suppress_error = 0;
11176 r = guestfs_upload (g, "test-command", remotefilename);
11181 char path[] = "/test-command";
11183 suppress_error = 0;
11184 r = guestfs_chmod (g, 493, path);
11189 char arguments_0[] = "/test-command";
11190 char arguments_1[] = "10";
11191 char *arguments[] = {
11198 suppress_error = 0;
11199 r = guestfs_command_lines (g, arguments);
11203 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11208 char expected[] = "Result10-1";
11209 if (strcmp (r[0], expected) != 0) {
11210 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11215 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11220 char expected[] = "Result10-2";
11221 if (strcmp (r[1], expected) != 0) {
11222 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11226 if (r[2] != NULL) {
11227 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11231 for (i = 0; r[i] != NULL; ++i)
11238 static int test_command_lines_10_skip (void)
11242 str = getenv ("TEST_ONLY");
11244 return strstr (str, "command_lines") == NULL;
11245 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11246 if (str && strcmp (str, "1") == 0) return 1;
11247 str = getenv ("SKIP_TEST_COMMAND_LINES");
11248 if (str && strcmp (str, "1") == 0) return 1;
11252 static int test_command_lines_10 (void)
11254 if (test_command_lines_10_skip ()) {
11255 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11259 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11261 char device[] = "/dev/sda";
11263 suppress_error = 0;
11264 r = guestfs_blockdev_setrw (g, device);
11270 suppress_error = 0;
11271 r = guestfs_umount_all (g);
11277 suppress_error = 0;
11278 r = guestfs_lvm_remove_all (g);
11283 char device[] = "/dev/sda";
11284 char lines_0[] = ",";
11290 suppress_error = 0;
11291 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11296 char fstype[] = "ext2";
11297 char device[] = "/dev/sda1";
11299 suppress_error = 0;
11300 r = guestfs_mkfs (g, fstype, device);
11305 char device[] = "/dev/sda1";
11306 char mountpoint[] = "/";
11308 suppress_error = 0;
11309 r = guestfs_mount (g, device, mountpoint);
11313 /* TestOutputList for command_lines (10) */
11315 char remotefilename[] = "/test-command";
11317 suppress_error = 0;
11318 r = guestfs_upload (g, "test-command", remotefilename);
11323 char path[] = "/test-command";
11325 suppress_error = 0;
11326 r = guestfs_chmod (g, 493, path);
11331 char arguments_0[] = "/test-command";
11332 char arguments_1[] = "11";
11333 char *arguments[] = {
11340 suppress_error = 0;
11341 r = guestfs_command_lines (g, arguments);
11345 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11350 char expected[] = "Result11-1";
11351 if (strcmp (r[0], expected) != 0) {
11352 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11357 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11362 char expected[] = "Result11-2";
11363 if (strcmp (r[1], expected) != 0) {
11364 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11368 if (r[2] != NULL) {
11369 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11373 for (i = 0; r[i] != NULL; ++i)
11380 static int test_command_0_skip (void)
11384 str = getenv ("TEST_ONLY");
11386 return strstr (str, "command") == NULL;
11387 str = getenv ("SKIP_TEST_COMMAND_0");
11388 if (str && strcmp (str, "1") == 0) return 1;
11389 str = getenv ("SKIP_TEST_COMMAND");
11390 if (str && strcmp (str, "1") == 0) return 1;
11394 static int test_command_0 (void)
11396 if (test_command_0_skip ()) {
11397 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11401 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11403 char device[] = "/dev/sda";
11405 suppress_error = 0;
11406 r = guestfs_blockdev_setrw (g, device);
11412 suppress_error = 0;
11413 r = guestfs_umount_all (g);
11419 suppress_error = 0;
11420 r = guestfs_lvm_remove_all (g);
11425 char device[] = "/dev/sda";
11426 char lines_0[] = ",";
11432 suppress_error = 0;
11433 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11438 char fstype[] = "ext2";
11439 char device[] = "/dev/sda1";
11441 suppress_error = 0;
11442 r = guestfs_mkfs (g, fstype, device);
11447 char device[] = "/dev/sda1";
11448 char mountpoint[] = "/";
11450 suppress_error = 0;
11451 r = guestfs_mount (g, device, mountpoint);
11455 /* TestOutput for command (0) */
11456 char expected[] = "Result1";
11458 char remotefilename[] = "/test-command";
11460 suppress_error = 0;
11461 r = guestfs_upload (g, "test-command", remotefilename);
11466 char path[] = "/test-command";
11468 suppress_error = 0;
11469 r = guestfs_chmod (g, 493, path);
11474 char arguments_0[] = "/test-command";
11475 char arguments_1[] = "1";
11476 char *arguments[] = {
11482 suppress_error = 0;
11483 r = guestfs_command (g, arguments);
11486 if (strcmp (r, expected) != 0) {
11487 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11495 static int test_command_1_skip (void)
11499 str = getenv ("TEST_ONLY");
11501 return strstr (str, "command") == NULL;
11502 str = getenv ("SKIP_TEST_COMMAND_1");
11503 if (str && strcmp (str, "1") == 0) return 1;
11504 str = getenv ("SKIP_TEST_COMMAND");
11505 if (str && strcmp (str, "1") == 0) return 1;
11509 static int test_command_1 (void)
11511 if (test_command_1_skip ()) {
11512 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11516 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11518 char device[] = "/dev/sda";
11520 suppress_error = 0;
11521 r = guestfs_blockdev_setrw (g, device);
11527 suppress_error = 0;
11528 r = guestfs_umount_all (g);
11534 suppress_error = 0;
11535 r = guestfs_lvm_remove_all (g);
11540 char device[] = "/dev/sda";
11541 char lines_0[] = ",";
11547 suppress_error = 0;
11548 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11553 char fstype[] = "ext2";
11554 char device[] = "/dev/sda1";
11556 suppress_error = 0;
11557 r = guestfs_mkfs (g, fstype, device);
11562 char device[] = "/dev/sda1";
11563 char mountpoint[] = "/";
11565 suppress_error = 0;
11566 r = guestfs_mount (g, device, mountpoint);
11570 /* TestOutput for command (1) */
11571 char expected[] = "Result2\n";
11573 char remotefilename[] = "/test-command";
11575 suppress_error = 0;
11576 r = guestfs_upload (g, "test-command", remotefilename);
11581 char path[] = "/test-command";
11583 suppress_error = 0;
11584 r = guestfs_chmod (g, 493, path);
11589 char arguments_0[] = "/test-command";
11590 char arguments_1[] = "2";
11591 char *arguments[] = {
11597 suppress_error = 0;
11598 r = guestfs_command (g, arguments);
11601 if (strcmp (r, expected) != 0) {
11602 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11610 static int test_command_2_skip (void)
11614 str = getenv ("TEST_ONLY");
11616 return strstr (str, "command") == NULL;
11617 str = getenv ("SKIP_TEST_COMMAND_2");
11618 if (str && strcmp (str, "1") == 0) return 1;
11619 str = getenv ("SKIP_TEST_COMMAND");
11620 if (str && strcmp (str, "1") == 0) return 1;
11624 static int test_command_2 (void)
11626 if (test_command_2_skip ()) {
11627 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11631 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11633 char device[] = "/dev/sda";
11635 suppress_error = 0;
11636 r = guestfs_blockdev_setrw (g, device);
11642 suppress_error = 0;
11643 r = guestfs_umount_all (g);
11649 suppress_error = 0;
11650 r = guestfs_lvm_remove_all (g);
11655 char device[] = "/dev/sda";
11656 char lines_0[] = ",";
11662 suppress_error = 0;
11663 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11668 char fstype[] = "ext2";
11669 char device[] = "/dev/sda1";
11671 suppress_error = 0;
11672 r = guestfs_mkfs (g, fstype, device);
11677 char device[] = "/dev/sda1";
11678 char mountpoint[] = "/";
11680 suppress_error = 0;
11681 r = guestfs_mount (g, device, mountpoint);
11685 /* TestOutput for command (2) */
11686 char expected[] = "\nResult3";
11688 char remotefilename[] = "/test-command";
11690 suppress_error = 0;
11691 r = guestfs_upload (g, "test-command", remotefilename);
11696 char path[] = "/test-command";
11698 suppress_error = 0;
11699 r = guestfs_chmod (g, 493, path);
11704 char arguments_0[] = "/test-command";
11705 char arguments_1[] = "3";
11706 char *arguments[] = {
11712 suppress_error = 0;
11713 r = guestfs_command (g, arguments);
11716 if (strcmp (r, expected) != 0) {
11717 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11725 static int test_command_3_skip (void)
11729 str = getenv ("TEST_ONLY");
11731 return strstr (str, "command") == NULL;
11732 str = getenv ("SKIP_TEST_COMMAND_3");
11733 if (str && strcmp (str, "1") == 0) return 1;
11734 str = getenv ("SKIP_TEST_COMMAND");
11735 if (str && strcmp (str, "1") == 0) return 1;
11739 static int test_command_3 (void)
11741 if (test_command_3_skip ()) {
11742 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11746 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11748 char device[] = "/dev/sda";
11750 suppress_error = 0;
11751 r = guestfs_blockdev_setrw (g, device);
11757 suppress_error = 0;
11758 r = guestfs_umount_all (g);
11764 suppress_error = 0;
11765 r = guestfs_lvm_remove_all (g);
11770 char device[] = "/dev/sda";
11771 char lines_0[] = ",";
11777 suppress_error = 0;
11778 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11783 char fstype[] = "ext2";
11784 char device[] = "/dev/sda1";
11786 suppress_error = 0;
11787 r = guestfs_mkfs (g, fstype, device);
11792 char device[] = "/dev/sda1";
11793 char mountpoint[] = "/";
11795 suppress_error = 0;
11796 r = guestfs_mount (g, device, mountpoint);
11800 /* TestOutput for command (3) */
11801 char expected[] = "\nResult4\n";
11803 char remotefilename[] = "/test-command";
11805 suppress_error = 0;
11806 r = guestfs_upload (g, "test-command", remotefilename);
11811 char path[] = "/test-command";
11813 suppress_error = 0;
11814 r = guestfs_chmod (g, 493, path);
11819 char arguments_0[] = "/test-command";
11820 char arguments_1[] = "4";
11821 char *arguments[] = {
11827 suppress_error = 0;
11828 r = guestfs_command (g, arguments);
11831 if (strcmp (r, expected) != 0) {
11832 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11840 static int test_command_4_skip (void)
11844 str = getenv ("TEST_ONLY");
11846 return strstr (str, "command") == NULL;
11847 str = getenv ("SKIP_TEST_COMMAND_4");
11848 if (str && strcmp (str, "1") == 0) return 1;
11849 str = getenv ("SKIP_TEST_COMMAND");
11850 if (str && strcmp (str, "1") == 0) return 1;
11854 static int test_command_4 (void)
11856 if (test_command_4_skip ()) {
11857 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11861 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11863 char device[] = "/dev/sda";
11865 suppress_error = 0;
11866 r = guestfs_blockdev_setrw (g, device);
11872 suppress_error = 0;
11873 r = guestfs_umount_all (g);
11879 suppress_error = 0;
11880 r = guestfs_lvm_remove_all (g);
11885 char device[] = "/dev/sda";
11886 char lines_0[] = ",";
11892 suppress_error = 0;
11893 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11898 char fstype[] = "ext2";
11899 char device[] = "/dev/sda1";
11901 suppress_error = 0;
11902 r = guestfs_mkfs (g, fstype, device);
11907 char device[] = "/dev/sda1";
11908 char mountpoint[] = "/";
11910 suppress_error = 0;
11911 r = guestfs_mount (g, device, mountpoint);
11915 /* TestOutput for command (4) */
11916 char expected[] = "\nResult5\n\n";
11918 char remotefilename[] = "/test-command";
11920 suppress_error = 0;
11921 r = guestfs_upload (g, "test-command", remotefilename);
11926 char path[] = "/test-command";
11928 suppress_error = 0;
11929 r = guestfs_chmod (g, 493, path);
11934 char arguments_0[] = "/test-command";
11935 char arguments_1[] = "5";
11936 char *arguments[] = {
11942 suppress_error = 0;
11943 r = guestfs_command (g, arguments);
11946 if (strcmp (r, expected) != 0) {
11947 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11955 static int test_command_5_skip (void)
11959 str = getenv ("TEST_ONLY");
11961 return strstr (str, "command") == NULL;
11962 str = getenv ("SKIP_TEST_COMMAND_5");
11963 if (str && strcmp (str, "1") == 0) return 1;
11964 str = getenv ("SKIP_TEST_COMMAND");
11965 if (str && strcmp (str, "1") == 0) return 1;
11969 static int test_command_5 (void)
11971 if (test_command_5_skip ()) {
11972 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11976 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11978 char device[] = "/dev/sda";
11980 suppress_error = 0;
11981 r = guestfs_blockdev_setrw (g, device);
11987 suppress_error = 0;
11988 r = guestfs_umount_all (g);
11994 suppress_error = 0;
11995 r = guestfs_lvm_remove_all (g);
12000 char device[] = "/dev/sda";
12001 char lines_0[] = ",";
12007 suppress_error = 0;
12008 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12013 char fstype[] = "ext2";
12014 char device[] = "/dev/sda1";
12016 suppress_error = 0;
12017 r = guestfs_mkfs (g, fstype, device);
12022 char device[] = "/dev/sda1";
12023 char mountpoint[] = "/";
12025 suppress_error = 0;
12026 r = guestfs_mount (g, device, mountpoint);
12030 /* TestOutput for command (5) */
12031 char expected[] = "\n\nResult6\n\n";
12033 char remotefilename[] = "/test-command";
12035 suppress_error = 0;
12036 r = guestfs_upload (g, "test-command", remotefilename);
12041 char path[] = "/test-command";
12043 suppress_error = 0;
12044 r = guestfs_chmod (g, 493, path);
12049 char arguments_0[] = "/test-command";
12050 char arguments_1[] = "6";
12051 char *arguments[] = {
12057 suppress_error = 0;
12058 r = guestfs_command (g, arguments);
12061 if (strcmp (r, expected) != 0) {
12062 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
12070 static int test_command_6_skip (void)
12074 str = getenv ("TEST_ONLY");
12076 return strstr (str, "command") == NULL;
12077 str = getenv ("SKIP_TEST_COMMAND_6");
12078 if (str && strcmp (str, "1") == 0) return 1;
12079 str = getenv ("SKIP_TEST_COMMAND");
12080 if (str && strcmp (str, "1") == 0) return 1;
12084 static int test_command_6 (void)
12086 if (test_command_6_skip ()) {
12087 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
12091 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
12093 char device[] = "/dev/sda";
12095 suppress_error = 0;
12096 r = guestfs_blockdev_setrw (g, device);
12102 suppress_error = 0;
12103 r = guestfs_umount_all (g);
12109 suppress_error = 0;
12110 r = guestfs_lvm_remove_all (g);
12115 char device[] = "/dev/sda";
12116 char lines_0[] = ",";
12122 suppress_error = 0;
12123 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12128 char fstype[] = "ext2";
12129 char device[] = "/dev/sda1";
12131 suppress_error = 0;
12132 r = guestfs_mkfs (g, fstype, device);
12137 char device[] = "/dev/sda1";
12138 char mountpoint[] = "/";
12140 suppress_error = 0;
12141 r = guestfs_mount (g, device, mountpoint);
12145 /* TestOutput for command (6) */
12146 char expected[] = "";
12148 char remotefilename[] = "/test-command";
12150 suppress_error = 0;
12151 r = guestfs_upload (g, "test-command", remotefilename);
12156 char path[] = "/test-command";
12158 suppress_error = 0;
12159 r = guestfs_chmod (g, 493, path);
12164 char arguments_0[] = "/test-command";
12165 char arguments_1[] = "7";
12166 char *arguments[] = {
12172 suppress_error = 0;
12173 r = guestfs_command (g, arguments);
12176 if (strcmp (r, expected) != 0) {
12177 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
12185 static int test_command_7_skip (void)
12189 str = getenv ("TEST_ONLY");
12191 return strstr (str, "command") == NULL;
12192 str = getenv ("SKIP_TEST_COMMAND_7");
12193 if (str && strcmp (str, "1") == 0) return 1;
12194 str = getenv ("SKIP_TEST_COMMAND");
12195 if (str && strcmp (str, "1") == 0) return 1;
12199 static int test_command_7 (void)
12201 if (test_command_7_skip ()) {
12202 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
12206 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
12208 char device[] = "/dev/sda";
12210 suppress_error = 0;
12211 r = guestfs_blockdev_setrw (g, device);
12217 suppress_error = 0;
12218 r = guestfs_umount_all (g);
12224 suppress_error = 0;
12225 r = guestfs_lvm_remove_all (g);
12230 char device[] = "/dev/sda";
12231 char lines_0[] = ",";
12237 suppress_error = 0;
12238 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12243 char fstype[] = "ext2";
12244 char device[] = "/dev/sda1";
12246 suppress_error = 0;
12247 r = guestfs_mkfs (g, fstype, device);
12252 char device[] = "/dev/sda1";
12253 char mountpoint[] = "/";
12255 suppress_error = 0;
12256 r = guestfs_mount (g, device, mountpoint);
12260 /* TestOutput for command (7) */
12261 char expected[] = "\n";
12263 char remotefilename[] = "/test-command";
12265 suppress_error = 0;
12266 r = guestfs_upload (g, "test-command", remotefilename);
12271 char path[] = "/test-command";
12273 suppress_error = 0;
12274 r = guestfs_chmod (g, 493, path);
12279 char arguments_0[] = "/test-command";
12280 char arguments_1[] = "8";
12281 char *arguments[] = {
12287 suppress_error = 0;
12288 r = guestfs_command (g, arguments);
12291 if (strcmp (r, expected) != 0) {
12292 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12300 static int test_command_8_skip (void)
12304 str = getenv ("TEST_ONLY");
12306 return strstr (str, "command") == NULL;
12307 str = getenv ("SKIP_TEST_COMMAND_8");
12308 if (str && strcmp (str, "1") == 0) return 1;
12309 str = getenv ("SKIP_TEST_COMMAND");
12310 if (str && strcmp (str, "1") == 0) return 1;
12314 static int test_command_8 (void)
12316 if (test_command_8_skip ()) {
12317 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12321 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12323 char device[] = "/dev/sda";
12325 suppress_error = 0;
12326 r = guestfs_blockdev_setrw (g, device);
12332 suppress_error = 0;
12333 r = guestfs_umount_all (g);
12339 suppress_error = 0;
12340 r = guestfs_lvm_remove_all (g);
12345 char device[] = "/dev/sda";
12346 char lines_0[] = ",";
12352 suppress_error = 0;
12353 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12358 char fstype[] = "ext2";
12359 char device[] = "/dev/sda1";
12361 suppress_error = 0;
12362 r = guestfs_mkfs (g, fstype, device);
12367 char device[] = "/dev/sda1";
12368 char mountpoint[] = "/";
12370 suppress_error = 0;
12371 r = guestfs_mount (g, device, mountpoint);
12375 /* TestOutput for command (8) */
12376 char expected[] = "\n\n";
12378 char remotefilename[] = "/test-command";
12380 suppress_error = 0;
12381 r = guestfs_upload (g, "test-command", remotefilename);
12386 char path[] = "/test-command";
12388 suppress_error = 0;
12389 r = guestfs_chmod (g, 493, path);
12394 char arguments_0[] = "/test-command";
12395 char arguments_1[] = "9";
12396 char *arguments[] = {
12402 suppress_error = 0;
12403 r = guestfs_command (g, arguments);
12406 if (strcmp (r, expected) != 0) {
12407 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12415 static int test_command_9_skip (void)
12419 str = getenv ("TEST_ONLY");
12421 return strstr (str, "command") == NULL;
12422 str = getenv ("SKIP_TEST_COMMAND_9");
12423 if (str && strcmp (str, "1") == 0) return 1;
12424 str = getenv ("SKIP_TEST_COMMAND");
12425 if (str && strcmp (str, "1") == 0) return 1;
12429 static int test_command_9 (void)
12431 if (test_command_9_skip ()) {
12432 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12436 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12438 char device[] = "/dev/sda";
12440 suppress_error = 0;
12441 r = guestfs_blockdev_setrw (g, device);
12447 suppress_error = 0;
12448 r = guestfs_umount_all (g);
12454 suppress_error = 0;
12455 r = guestfs_lvm_remove_all (g);
12460 char device[] = "/dev/sda";
12461 char lines_0[] = ",";
12467 suppress_error = 0;
12468 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12473 char fstype[] = "ext2";
12474 char device[] = "/dev/sda1";
12476 suppress_error = 0;
12477 r = guestfs_mkfs (g, fstype, device);
12482 char device[] = "/dev/sda1";
12483 char mountpoint[] = "/";
12485 suppress_error = 0;
12486 r = guestfs_mount (g, device, mountpoint);
12490 /* TestOutput for command (9) */
12491 char expected[] = "Result10-1\nResult10-2\n";
12493 char remotefilename[] = "/test-command";
12495 suppress_error = 0;
12496 r = guestfs_upload (g, "test-command", remotefilename);
12501 char path[] = "/test-command";
12503 suppress_error = 0;
12504 r = guestfs_chmod (g, 493, path);
12509 char arguments_0[] = "/test-command";
12510 char arguments_1[] = "10";
12511 char *arguments[] = {
12517 suppress_error = 0;
12518 r = guestfs_command (g, arguments);
12521 if (strcmp (r, expected) != 0) {
12522 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12530 static int test_command_10_skip (void)
12534 str = getenv ("TEST_ONLY");
12536 return strstr (str, "command") == NULL;
12537 str = getenv ("SKIP_TEST_COMMAND_10");
12538 if (str && strcmp (str, "1") == 0) return 1;
12539 str = getenv ("SKIP_TEST_COMMAND");
12540 if (str && strcmp (str, "1") == 0) return 1;
12544 static int test_command_10 (void)
12546 if (test_command_10_skip ()) {
12547 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12551 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12553 char device[] = "/dev/sda";
12555 suppress_error = 0;
12556 r = guestfs_blockdev_setrw (g, device);
12562 suppress_error = 0;
12563 r = guestfs_umount_all (g);
12569 suppress_error = 0;
12570 r = guestfs_lvm_remove_all (g);
12575 char device[] = "/dev/sda";
12576 char lines_0[] = ",";
12582 suppress_error = 0;
12583 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12588 char fstype[] = "ext2";
12589 char device[] = "/dev/sda1";
12591 suppress_error = 0;
12592 r = guestfs_mkfs (g, fstype, device);
12597 char device[] = "/dev/sda1";
12598 char mountpoint[] = "/";
12600 suppress_error = 0;
12601 r = guestfs_mount (g, device, mountpoint);
12605 /* TestOutput for command (10) */
12606 char expected[] = "Result11-1\nResult11-2";
12608 char remotefilename[] = "/test-command";
12610 suppress_error = 0;
12611 r = guestfs_upload (g, "test-command", remotefilename);
12616 char path[] = "/test-command";
12618 suppress_error = 0;
12619 r = guestfs_chmod (g, 493, path);
12624 char arguments_0[] = "/test-command";
12625 char arguments_1[] = "11";
12626 char *arguments[] = {
12632 suppress_error = 0;
12633 r = guestfs_command (g, arguments);
12636 if (strcmp (r, expected) != 0) {
12637 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12645 static int test_command_11_skip (void)
12649 str = getenv ("TEST_ONLY");
12651 return strstr (str, "command") == NULL;
12652 str = getenv ("SKIP_TEST_COMMAND_11");
12653 if (str && strcmp (str, "1") == 0) return 1;
12654 str = getenv ("SKIP_TEST_COMMAND");
12655 if (str && strcmp (str, "1") == 0) return 1;
12659 static int test_command_11 (void)
12661 if (test_command_11_skip ()) {
12662 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12666 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12668 char device[] = "/dev/sda";
12670 suppress_error = 0;
12671 r = guestfs_blockdev_setrw (g, device);
12677 suppress_error = 0;
12678 r = guestfs_umount_all (g);
12684 suppress_error = 0;
12685 r = guestfs_lvm_remove_all (g);
12690 char device[] = "/dev/sda";
12691 char lines_0[] = ",";
12697 suppress_error = 0;
12698 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12703 char fstype[] = "ext2";
12704 char device[] = "/dev/sda1";
12706 suppress_error = 0;
12707 r = guestfs_mkfs (g, fstype, device);
12712 char device[] = "/dev/sda1";
12713 char mountpoint[] = "/";
12715 suppress_error = 0;
12716 r = guestfs_mount (g, device, mountpoint);
12720 /* TestLastFail for command (11) */
12722 char remotefilename[] = "/test-command";
12724 suppress_error = 0;
12725 r = guestfs_upload (g, "test-command", remotefilename);
12730 char path[] = "/test-command";
12732 suppress_error = 0;
12733 r = guestfs_chmod (g, 493, path);
12738 char arguments_0[] = "/test-command";
12739 char *arguments[] = {
12744 suppress_error = 1;
12745 r = guestfs_command (g, arguments);
12753 static int test_file_0_skip (void)
12757 str = getenv ("TEST_ONLY");
12759 return strstr (str, "file") == NULL;
12760 str = getenv ("SKIP_TEST_FILE_0");
12761 if (str && strcmp (str, "1") == 0) return 1;
12762 str = getenv ("SKIP_TEST_FILE");
12763 if (str && strcmp (str, "1") == 0) return 1;
12767 static int test_file_0 (void)
12769 if (test_file_0_skip ()) {
12770 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12774 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12776 char device[] = "/dev/sda";
12778 suppress_error = 0;
12779 r = guestfs_blockdev_setrw (g, device);
12785 suppress_error = 0;
12786 r = guestfs_umount_all (g);
12792 suppress_error = 0;
12793 r = guestfs_lvm_remove_all (g);
12798 char device[] = "/dev/sda";
12799 char lines_0[] = ",";
12805 suppress_error = 0;
12806 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12811 char fstype[] = "ext2";
12812 char device[] = "/dev/sda1";
12814 suppress_error = 0;
12815 r = guestfs_mkfs (g, fstype, device);
12820 char device[] = "/dev/sda1";
12821 char mountpoint[] = "/";
12823 suppress_error = 0;
12824 r = guestfs_mount (g, device, mountpoint);
12828 /* TestOutput for file (0) */
12829 char expected[] = "empty";
12831 char path[] = "/new";
12833 suppress_error = 0;
12834 r = guestfs_touch (g, path);
12839 char path[] = "/new";
12841 suppress_error = 0;
12842 r = guestfs_file (g, path);
12845 if (strcmp (r, expected) != 0) {
12846 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12854 static int test_file_1_skip (void)
12858 str = getenv ("TEST_ONLY");
12860 return strstr (str, "file") == NULL;
12861 str = getenv ("SKIP_TEST_FILE_1");
12862 if (str && strcmp (str, "1") == 0) return 1;
12863 str = getenv ("SKIP_TEST_FILE");
12864 if (str && strcmp (str, "1") == 0) return 1;
12868 static int test_file_1 (void)
12870 if (test_file_1_skip ()) {
12871 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12875 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12877 char device[] = "/dev/sda";
12879 suppress_error = 0;
12880 r = guestfs_blockdev_setrw (g, device);
12886 suppress_error = 0;
12887 r = guestfs_umount_all (g);
12893 suppress_error = 0;
12894 r = guestfs_lvm_remove_all (g);
12899 char device[] = "/dev/sda";
12900 char lines_0[] = ",";
12906 suppress_error = 0;
12907 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12912 char fstype[] = "ext2";
12913 char device[] = "/dev/sda1";
12915 suppress_error = 0;
12916 r = guestfs_mkfs (g, fstype, device);
12921 char device[] = "/dev/sda1";
12922 char mountpoint[] = "/";
12924 suppress_error = 0;
12925 r = guestfs_mount (g, device, mountpoint);
12929 /* TestOutput for file (1) */
12930 char expected[] = "ASCII text";
12932 char path[] = "/new";
12933 char content[] = "some content\n";
12935 suppress_error = 0;
12936 r = guestfs_write_file (g, path, content, 0);
12941 char path[] = "/new";
12943 suppress_error = 0;
12944 r = guestfs_file (g, path);
12947 if (strcmp (r, expected) != 0) {
12948 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12956 static int test_file_2_skip (void)
12960 str = getenv ("TEST_ONLY");
12962 return strstr (str, "file") == NULL;
12963 str = getenv ("SKIP_TEST_FILE_2");
12964 if (str && strcmp (str, "1") == 0) return 1;
12965 str = getenv ("SKIP_TEST_FILE");
12966 if (str && strcmp (str, "1") == 0) return 1;
12970 static int test_file_2 (void)
12972 if (test_file_2_skip ()) {
12973 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12977 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12979 char device[] = "/dev/sda";
12981 suppress_error = 0;
12982 r = guestfs_blockdev_setrw (g, device);
12988 suppress_error = 0;
12989 r = guestfs_umount_all (g);
12995 suppress_error = 0;
12996 r = guestfs_lvm_remove_all (g);
13001 char device[] = "/dev/sda";
13002 char lines_0[] = ",";
13008 suppress_error = 0;
13009 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13014 char fstype[] = "ext2";
13015 char device[] = "/dev/sda1";
13017 suppress_error = 0;
13018 r = guestfs_mkfs (g, fstype, device);
13023 char device[] = "/dev/sda1";
13024 char mountpoint[] = "/";
13026 suppress_error = 0;
13027 r = guestfs_mount (g, device, mountpoint);
13031 /* TestLastFail for file (2) */
13033 char path[] = "/nofile";
13035 suppress_error = 1;
13036 r = guestfs_file (g, path);
13044 static int test_umount_all_0_skip (void)
13048 str = getenv ("TEST_ONLY");
13050 return strstr (str, "umount_all") == NULL;
13051 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
13052 if (str && strcmp (str, "1") == 0) return 1;
13053 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13054 if (str && strcmp (str, "1") == 0) return 1;
13058 static int test_umount_all_0 (void)
13060 if (test_umount_all_0_skip ()) {
13061 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
13065 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
13067 char device[] = "/dev/sda";
13069 suppress_error = 0;
13070 r = guestfs_blockdev_setrw (g, device);
13076 suppress_error = 0;
13077 r = guestfs_umount_all (g);
13083 suppress_error = 0;
13084 r = guestfs_lvm_remove_all (g);
13089 char device[] = "/dev/sda";
13090 char lines_0[] = ",";
13096 suppress_error = 0;
13097 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13102 char fstype[] = "ext2";
13103 char device[] = "/dev/sda1";
13105 suppress_error = 0;
13106 r = guestfs_mkfs (g, fstype, device);
13111 char device[] = "/dev/sda1";
13112 char mountpoint[] = "/";
13114 suppress_error = 0;
13115 r = guestfs_mount (g, device, mountpoint);
13119 /* TestOutputList for umount_all (0) */
13122 suppress_error = 0;
13123 r = guestfs_umount_all (g);
13130 suppress_error = 0;
13131 r = guestfs_mounts (g);
13134 if (r[0] != NULL) {
13135 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
13139 for (i = 0; r[i] != NULL; ++i)
13146 static int test_umount_all_1_skip (void)
13150 str = getenv ("TEST_ONLY");
13152 return strstr (str, "umount_all") == NULL;
13153 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
13154 if (str && strcmp (str, "1") == 0) return 1;
13155 str = getenv ("SKIP_TEST_UMOUNT_ALL");
13156 if (str && strcmp (str, "1") == 0) return 1;
13160 static int test_umount_all_1 (void)
13162 if (test_umount_all_1_skip ()) {
13163 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
13167 /* InitNone|InitEmpty for test_umount_all_1 */
13169 char device[] = "/dev/sda";
13171 suppress_error = 0;
13172 r = guestfs_blockdev_setrw (g, device);
13178 suppress_error = 0;
13179 r = guestfs_umount_all (g);
13185 suppress_error = 0;
13186 r = guestfs_lvm_remove_all (g);
13190 /* TestOutputList for umount_all (1) */
13192 char device[] = "/dev/sda";
13193 char lines_0[] = ",10";
13194 char lines_1[] = ",20";
13195 char lines_2[] = ",";
13203 suppress_error = 0;
13204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13209 char fstype[] = "ext2";
13210 char device[] = "/dev/sda1";
13212 suppress_error = 0;
13213 r = guestfs_mkfs (g, fstype, device);
13218 char fstype[] = "ext2";
13219 char device[] = "/dev/sda2";
13221 suppress_error = 0;
13222 r = guestfs_mkfs (g, fstype, device);
13227 char fstype[] = "ext2";
13228 char device[] = "/dev/sda3";
13230 suppress_error = 0;
13231 r = guestfs_mkfs (g, fstype, device);
13236 char device[] = "/dev/sda1";
13237 char mountpoint[] = "/";
13239 suppress_error = 0;
13240 r = guestfs_mount (g, device, mountpoint);
13245 char path[] = "/mp1";
13247 suppress_error = 0;
13248 r = guestfs_mkdir (g, path);
13253 char device[] = "/dev/sda2";
13254 char mountpoint[] = "/mp1";
13256 suppress_error = 0;
13257 r = guestfs_mount (g, device, mountpoint);
13262 char path[] = "/mp1/mp2";
13264 suppress_error = 0;
13265 r = guestfs_mkdir (g, path);
13270 char device[] = "/dev/sda3";
13271 char mountpoint[] = "/mp1/mp2";
13273 suppress_error = 0;
13274 r = guestfs_mount (g, device, mountpoint);
13279 char path[] = "/mp1/mp2/mp3";
13281 suppress_error = 0;
13282 r = guestfs_mkdir (g, path);
13288 suppress_error = 0;
13289 r = guestfs_umount_all (g);
13296 suppress_error = 0;
13297 r = guestfs_mounts (g);
13300 if (r[0] != NULL) {
13301 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13305 for (i = 0; r[i] != NULL; ++i)
13312 static int test_mounts_0_skip (void)
13316 str = getenv ("TEST_ONLY");
13318 return strstr (str, "mounts") == NULL;
13319 str = getenv ("SKIP_TEST_MOUNTS_0");
13320 if (str && strcmp (str, "1") == 0) return 1;
13321 str = getenv ("SKIP_TEST_MOUNTS");
13322 if (str && strcmp (str, "1") == 0) return 1;
13326 static int test_mounts_0 (void)
13328 if (test_mounts_0_skip ()) {
13329 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13333 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13335 char device[] = "/dev/sda";
13337 suppress_error = 0;
13338 r = guestfs_blockdev_setrw (g, device);
13344 suppress_error = 0;
13345 r = guestfs_umount_all (g);
13351 suppress_error = 0;
13352 r = guestfs_lvm_remove_all (g);
13357 char device[] = "/dev/sda";
13358 char lines_0[] = ",";
13364 suppress_error = 0;
13365 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13370 char fstype[] = "ext2";
13371 char device[] = "/dev/sda1";
13373 suppress_error = 0;
13374 r = guestfs_mkfs (g, fstype, device);
13379 char device[] = "/dev/sda1";
13380 char mountpoint[] = "/";
13382 suppress_error = 0;
13383 r = guestfs_mount (g, device, mountpoint);
13387 /* TestOutputListOfDevices for mounts (0) */
13391 suppress_error = 0;
13392 r = guestfs_mounts (g);
13396 fprintf (stderr, "test_mounts_0: short list returned from command\n");
13401 char expected[] = "/dev/sda1";
13403 if (strcmp (r[0], expected) != 0) {
13404 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13408 if (r[1] != NULL) {
13409 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13413 for (i = 0; r[i] != NULL; ++i)
13420 static int test_umount_0_skip (void)
13424 str = getenv ("TEST_ONLY");
13426 return strstr (str, "umount") == NULL;
13427 str = getenv ("SKIP_TEST_UMOUNT_0");
13428 if (str && strcmp (str, "1") == 0) return 1;
13429 str = getenv ("SKIP_TEST_UMOUNT");
13430 if (str && strcmp (str, "1") == 0) return 1;
13434 static int test_umount_0 (void)
13436 if (test_umount_0_skip ()) {
13437 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13441 /* InitNone|InitEmpty for test_umount_0 */
13443 char device[] = "/dev/sda";
13445 suppress_error = 0;
13446 r = guestfs_blockdev_setrw (g, device);
13452 suppress_error = 0;
13453 r = guestfs_umount_all (g);
13459 suppress_error = 0;
13460 r = guestfs_lvm_remove_all (g);
13464 /* TestOutputListOfDevices for umount (0) */
13466 char device[] = "/dev/sda";
13467 char lines_0[] = ",";
13473 suppress_error = 0;
13474 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13479 char fstype[] = "ext2";
13480 char device[] = "/dev/sda1";
13482 suppress_error = 0;
13483 r = guestfs_mkfs (g, fstype, device);
13488 char device[] = "/dev/sda1";
13489 char mountpoint[] = "/";
13491 suppress_error = 0;
13492 r = guestfs_mount (g, device, mountpoint);
13499 suppress_error = 0;
13500 r = guestfs_mounts (g);
13504 fprintf (stderr, "test_umount_0: short list returned from command\n");
13509 char expected[] = "/dev/sda1";
13511 if (strcmp (r[0], expected) != 0) {
13512 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13516 if (r[1] != NULL) {
13517 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13521 for (i = 0; r[i] != NULL; ++i)
13528 static int test_umount_1_skip (void)
13532 str = getenv ("TEST_ONLY");
13534 return strstr (str, "umount") == NULL;
13535 str = getenv ("SKIP_TEST_UMOUNT_1");
13536 if (str && strcmp (str, "1") == 0) return 1;
13537 str = getenv ("SKIP_TEST_UMOUNT");
13538 if (str && strcmp (str, "1") == 0) return 1;
13542 static int test_umount_1 (void)
13544 if (test_umount_1_skip ()) {
13545 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13549 /* InitNone|InitEmpty for test_umount_1 */
13551 char device[] = "/dev/sda";
13553 suppress_error = 0;
13554 r = guestfs_blockdev_setrw (g, device);
13560 suppress_error = 0;
13561 r = guestfs_umount_all (g);
13567 suppress_error = 0;
13568 r = guestfs_lvm_remove_all (g);
13572 /* TestOutputList for umount (1) */
13574 char device[] = "/dev/sda";
13575 char lines_0[] = ",";
13581 suppress_error = 0;
13582 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13587 char fstype[] = "ext2";
13588 char device[] = "/dev/sda1";
13590 suppress_error = 0;
13591 r = guestfs_mkfs (g, fstype, device);
13596 char device[] = "/dev/sda1";
13597 char mountpoint[] = "/";
13599 suppress_error = 0;
13600 r = guestfs_mount (g, device, mountpoint);
13605 char pathordevice[] = "/";
13607 suppress_error = 0;
13608 r = guestfs_umount (g, pathordevice);
13615 suppress_error = 0;
13616 r = guestfs_mounts (g);
13619 if (r[0] != NULL) {
13620 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13624 for (i = 0; r[i] != NULL; ++i)
13631 static int test_write_file_0_skip (void)
13635 str = getenv ("TEST_ONLY");
13637 return strstr (str, "write_file") == NULL;
13638 str = getenv ("SKIP_TEST_WRITE_FILE_0");
13639 if (str && strcmp (str, "1") == 0) return 1;
13640 str = getenv ("SKIP_TEST_WRITE_FILE");
13641 if (str && strcmp (str, "1") == 0) return 1;
13645 static int test_write_file_0 (void)
13647 if (test_write_file_0_skip ()) {
13648 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13652 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13654 char device[] = "/dev/sda";
13656 suppress_error = 0;
13657 r = guestfs_blockdev_setrw (g, device);
13663 suppress_error = 0;
13664 r = guestfs_umount_all (g);
13670 suppress_error = 0;
13671 r = guestfs_lvm_remove_all (g);
13676 char device[] = "/dev/sda";
13677 char lines_0[] = ",";
13683 suppress_error = 0;
13684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13689 char fstype[] = "ext2";
13690 char device[] = "/dev/sda1";
13692 suppress_error = 0;
13693 r = guestfs_mkfs (g, fstype, device);
13698 char device[] = "/dev/sda1";
13699 char mountpoint[] = "/";
13701 suppress_error = 0;
13702 r = guestfs_mount (g, device, mountpoint);
13706 /* TestOutput for write_file (0) */
13707 char expected[] = "new file contents";
13709 char path[] = "/new";
13710 char content[] = "new file contents";
13712 suppress_error = 0;
13713 r = guestfs_write_file (g, path, content, 0);
13718 char path[] = "/new";
13720 suppress_error = 0;
13721 r = guestfs_cat (g, path);
13724 if (strcmp (r, expected) != 0) {
13725 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13733 static int test_write_file_1_skip (void)
13737 str = getenv ("TEST_ONLY");
13739 return strstr (str, "write_file") == NULL;
13740 str = getenv ("SKIP_TEST_WRITE_FILE_1");
13741 if (str && strcmp (str, "1") == 0) return 1;
13742 str = getenv ("SKIP_TEST_WRITE_FILE");
13743 if (str && strcmp (str, "1") == 0) return 1;
13747 static int test_write_file_1 (void)
13749 if (test_write_file_1_skip ()) {
13750 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13754 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13756 char device[] = "/dev/sda";
13758 suppress_error = 0;
13759 r = guestfs_blockdev_setrw (g, device);
13765 suppress_error = 0;
13766 r = guestfs_umount_all (g);
13772 suppress_error = 0;
13773 r = guestfs_lvm_remove_all (g);
13778 char device[] = "/dev/sda";
13779 char lines_0[] = ",";
13785 suppress_error = 0;
13786 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13791 char fstype[] = "ext2";
13792 char device[] = "/dev/sda1";
13794 suppress_error = 0;
13795 r = guestfs_mkfs (g, fstype, device);
13800 char device[] = "/dev/sda1";
13801 char mountpoint[] = "/";
13803 suppress_error = 0;
13804 r = guestfs_mount (g, device, mountpoint);
13808 /* TestOutput for write_file (1) */
13809 char expected[] = "\nnew file contents\n";
13811 char path[] = "/new";
13812 char content[] = "\nnew file contents\n";
13814 suppress_error = 0;
13815 r = guestfs_write_file (g, path, content, 0);
13820 char path[] = "/new";
13822 suppress_error = 0;
13823 r = guestfs_cat (g, path);
13826 if (strcmp (r, expected) != 0) {
13827 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13835 static int test_write_file_2_skip (void)
13839 str = getenv ("TEST_ONLY");
13841 return strstr (str, "write_file") == NULL;
13842 str = getenv ("SKIP_TEST_WRITE_FILE_2");
13843 if (str && strcmp (str, "1") == 0) return 1;
13844 str = getenv ("SKIP_TEST_WRITE_FILE");
13845 if (str && strcmp (str, "1") == 0) return 1;
13849 static int test_write_file_2 (void)
13851 if (test_write_file_2_skip ()) {
13852 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13856 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13858 char device[] = "/dev/sda";
13860 suppress_error = 0;
13861 r = guestfs_blockdev_setrw (g, device);
13867 suppress_error = 0;
13868 r = guestfs_umount_all (g);
13874 suppress_error = 0;
13875 r = guestfs_lvm_remove_all (g);
13880 char device[] = "/dev/sda";
13881 char lines_0[] = ",";
13887 suppress_error = 0;
13888 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13893 char fstype[] = "ext2";
13894 char device[] = "/dev/sda1";
13896 suppress_error = 0;
13897 r = guestfs_mkfs (g, fstype, device);
13902 char device[] = "/dev/sda1";
13903 char mountpoint[] = "/";
13905 suppress_error = 0;
13906 r = guestfs_mount (g, device, mountpoint);
13910 /* TestOutput for write_file (2) */
13911 char expected[] = "\n\n";
13913 char path[] = "/new";
13914 char content[] = "\n\n";
13916 suppress_error = 0;
13917 r = guestfs_write_file (g, path, content, 0);
13922 char path[] = "/new";
13924 suppress_error = 0;
13925 r = guestfs_cat (g, path);
13928 if (strcmp (r, expected) != 0) {
13929 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13937 static int test_write_file_3_skip (void)
13941 str = getenv ("TEST_ONLY");
13943 return strstr (str, "write_file") == NULL;
13944 str = getenv ("SKIP_TEST_WRITE_FILE_3");
13945 if (str && strcmp (str, "1") == 0) return 1;
13946 str = getenv ("SKIP_TEST_WRITE_FILE");
13947 if (str && strcmp (str, "1") == 0) return 1;
13951 static int test_write_file_3 (void)
13953 if (test_write_file_3_skip ()) {
13954 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13958 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13960 char device[] = "/dev/sda";
13962 suppress_error = 0;
13963 r = guestfs_blockdev_setrw (g, device);
13969 suppress_error = 0;
13970 r = guestfs_umount_all (g);
13976 suppress_error = 0;
13977 r = guestfs_lvm_remove_all (g);
13982 char device[] = "/dev/sda";
13983 char lines_0[] = ",";
13989 suppress_error = 0;
13990 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13995 char fstype[] = "ext2";
13996 char device[] = "/dev/sda1";
13998 suppress_error = 0;
13999 r = guestfs_mkfs (g, fstype, device);
14004 char device[] = "/dev/sda1";
14005 char mountpoint[] = "/";
14007 suppress_error = 0;
14008 r = guestfs_mount (g, device, mountpoint);
14012 /* TestOutput for write_file (3) */
14013 char expected[] = "";
14015 char path[] = "/new";
14016 char content[] = "";
14018 suppress_error = 0;
14019 r = guestfs_write_file (g, path, content, 0);
14024 char path[] = "/new";
14026 suppress_error = 0;
14027 r = guestfs_cat (g, path);
14030 if (strcmp (r, expected) != 0) {
14031 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
14039 static int test_write_file_4_skip (void)
14043 str = getenv ("TEST_ONLY");
14045 return strstr (str, "write_file") == NULL;
14046 str = getenv ("SKIP_TEST_WRITE_FILE_4");
14047 if (str && strcmp (str, "1") == 0) return 1;
14048 str = getenv ("SKIP_TEST_WRITE_FILE");
14049 if (str && strcmp (str, "1") == 0) return 1;
14053 static int test_write_file_4 (void)
14055 if (test_write_file_4_skip ()) {
14056 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
14060 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
14062 char device[] = "/dev/sda";
14064 suppress_error = 0;
14065 r = guestfs_blockdev_setrw (g, device);
14071 suppress_error = 0;
14072 r = guestfs_umount_all (g);
14078 suppress_error = 0;
14079 r = guestfs_lvm_remove_all (g);
14084 char device[] = "/dev/sda";
14085 char lines_0[] = ",";
14091 suppress_error = 0;
14092 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14097 char fstype[] = "ext2";
14098 char device[] = "/dev/sda1";
14100 suppress_error = 0;
14101 r = guestfs_mkfs (g, fstype, device);
14106 char device[] = "/dev/sda1";
14107 char mountpoint[] = "/";
14109 suppress_error = 0;
14110 r = guestfs_mount (g, device, mountpoint);
14114 /* TestOutput for write_file (4) */
14115 char expected[] = "\n\n\n";
14117 char path[] = "/new";
14118 char content[] = "\n\n\n";
14120 suppress_error = 0;
14121 r = guestfs_write_file (g, path, content, 0);
14126 char path[] = "/new";
14128 suppress_error = 0;
14129 r = guestfs_cat (g, path);
14132 if (strcmp (r, expected) != 0) {
14133 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
14141 static int test_write_file_5_skip (void)
14145 str = getenv ("TEST_ONLY");
14147 return strstr (str, "write_file") == NULL;
14148 str = getenv ("SKIP_TEST_WRITE_FILE_5");
14149 if (str && strcmp (str, "1") == 0) return 1;
14150 str = getenv ("SKIP_TEST_WRITE_FILE");
14151 if (str && strcmp (str, "1") == 0) return 1;
14155 static int test_write_file_5 (void)
14157 if (test_write_file_5_skip ()) {
14158 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
14162 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
14164 char device[] = "/dev/sda";
14166 suppress_error = 0;
14167 r = guestfs_blockdev_setrw (g, device);
14173 suppress_error = 0;
14174 r = guestfs_umount_all (g);
14180 suppress_error = 0;
14181 r = guestfs_lvm_remove_all (g);
14186 char device[] = "/dev/sda";
14187 char lines_0[] = ",";
14193 suppress_error = 0;
14194 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14199 char fstype[] = "ext2";
14200 char device[] = "/dev/sda1";
14202 suppress_error = 0;
14203 r = guestfs_mkfs (g, fstype, device);
14208 char device[] = "/dev/sda1";
14209 char mountpoint[] = "/";
14211 suppress_error = 0;
14212 r = guestfs_mount (g, device, mountpoint);
14216 /* TestOutput for write_file (5) */
14217 char expected[] = "\n";
14219 char path[] = "/new";
14220 char content[] = "\n";
14222 suppress_error = 0;
14223 r = guestfs_write_file (g, path, content, 0);
14228 char path[] = "/new";
14230 suppress_error = 0;
14231 r = guestfs_cat (g, path);
14234 if (strcmp (r, expected) != 0) {
14235 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14243 static int test_mkfs_0_skip (void)
14247 str = getenv ("TEST_ONLY");
14249 return strstr (str, "mkfs") == NULL;
14250 str = getenv ("SKIP_TEST_MKFS_0");
14251 if (str && strcmp (str, "1") == 0) return 1;
14252 str = getenv ("SKIP_TEST_MKFS");
14253 if (str && strcmp (str, "1") == 0) return 1;
14257 static int test_mkfs_0 (void)
14259 if (test_mkfs_0_skip ()) {
14260 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14264 /* InitNone|InitEmpty for test_mkfs_0 */
14266 char device[] = "/dev/sda";
14268 suppress_error = 0;
14269 r = guestfs_blockdev_setrw (g, device);
14275 suppress_error = 0;
14276 r = guestfs_umount_all (g);
14282 suppress_error = 0;
14283 r = guestfs_lvm_remove_all (g);
14287 /* TestOutput for mkfs (0) */
14288 char expected[] = "new file contents";
14290 char device[] = "/dev/sda";
14291 char lines_0[] = ",";
14297 suppress_error = 0;
14298 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14303 char fstype[] = "ext2";
14304 char device[] = "/dev/sda1";
14306 suppress_error = 0;
14307 r = guestfs_mkfs (g, fstype, device);
14312 char device[] = "/dev/sda1";
14313 char mountpoint[] = "/";
14315 suppress_error = 0;
14316 r = guestfs_mount (g, device, mountpoint);
14321 char path[] = "/new";
14322 char content[] = "new file contents";
14324 suppress_error = 0;
14325 r = guestfs_write_file (g, path, content, 0);
14330 char path[] = "/new";
14332 suppress_error = 0;
14333 r = guestfs_cat (g, path);
14336 if (strcmp (r, expected) != 0) {
14337 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14345 static int test_lvcreate_0_skip (void)
14349 str = getenv ("TEST_ONLY");
14351 return strstr (str, "lvcreate") == NULL;
14352 str = getenv ("SKIP_TEST_LVCREATE_0");
14353 if (str && strcmp (str, "1") == 0) return 1;
14354 str = getenv ("SKIP_TEST_LVCREATE");
14355 if (str && strcmp (str, "1") == 0) return 1;
14359 static int test_lvcreate_0 (void)
14361 if (test_lvcreate_0_skip ()) {
14362 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14366 /* InitNone|InitEmpty for test_lvcreate_0 */
14368 char device[] = "/dev/sda";
14370 suppress_error = 0;
14371 r = guestfs_blockdev_setrw (g, device);
14377 suppress_error = 0;
14378 r = guestfs_umount_all (g);
14384 suppress_error = 0;
14385 r = guestfs_lvm_remove_all (g);
14389 /* TestOutputList for lvcreate (0) */
14391 char device[] = "/dev/sda";
14392 char lines_0[] = ",10";
14393 char lines_1[] = ",20";
14394 char lines_2[] = ",";
14402 suppress_error = 0;
14403 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14408 char device[] = "/dev/sda1";
14410 suppress_error = 0;
14411 r = guestfs_pvcreate (g, device);
14416 char device[] = "/dev/sda2";
14418 suppress_error = 0;
14419 r = guestfs_pvcreate (g, device);
14424 char device[] = "/dev/sda3";
14426 suppress_error = 0;
14427 r = guestfs_pvcreate (g, device);
14432 char volgroup[] = "VG1";
14433 char physvols_0[] = "/dev/sda1";
14434 char physvols_1[] = "/dev/sda2";
14435 char *physvols[] = {
14441 suppress_error = 0;
14442 r = guestfs_vgcreate (g, volgroup, physvols);
14447 char volgroup[] = "VG2";
14448 char physvols_0[] = "/dev/sda3";
14449 char *physvols[] = {
14454 suppress_error = 0;
14455 r = guestfs_vgcreate (g, volgroup, physvols);
14460 char logvol[] = "LV1";
14461 char volgroup[] = "VG1";
14463 suppress_error = 0;
14464 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14469 char logvol[] = "LV2";
14470 char volgroup[] = "VG1";
14472 suppress_error = 0;
14473 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14478 char logvol[] = "LV3";
14479 char volgroup[] = "VG2";
14481 suppress_error = 0;
14482 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14487 char logvol[] = "LV4";
14488 char volgroup[] = "VG2";
14490 suppress_error = 0;
14491 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14496 char logvol[] = "LV5";
14497 char volgroup[] = "VG2";
14499 suppress_error = 0;
14500 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14507 suppress_error = 0;
14508 r = guestfs_lvs (g);
14512 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14517 char expected[] = "/dev/VG1/LV1";
14518 if (strcmp (r[0], expected) != 0) {
14519 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14524 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14529 char expected[] = "/dev/VG1/LV2";
14530 if (strcmp (r[1], expected) != 0) {
14531 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14536 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14541 char expected[] = "/dev/VG2/LV3";
14542 if (strcmp (r[2], expected) != 0) {
14543 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14548 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14553 char expected[] = "/dev/VG2/LV4";
14554 if (strcmp (r[3], expected) != 0) {
14555 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14560 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14565 char expected[] = "/dev/VG2/LV5";
14566 if (strcmp (r[4], expected) != 0) {
14567 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14571 if (r[5] != NULL) {
14572 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14576 for (i = 0; r[i] != NULL; ++i)
14583 static int test_vgcreate_0_skip (void)
14587 str = getenv ("TEST_ONLY");
14589 return strstr (str, "vgcreate") == NULL;
14590 str = getenv ("SKIP_TEST_VGCREATE_0");
14591 if (str && strcmp (str, "1") == 0) return 1;
14592 str = getenv ("SKIP_TEST_VGCREATE");
14593 if (str && strcmp (str, "1") == 0) return 1;
14597 static int test_vgcreate_0 (void)
14599 if (test_vgcreate_0_skip ()) {
14600 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14604 /* InitNone|InitEmpty for test_vgcreate_0 */
14606 char device[] = "/dev/sda";
14608 suppress_error = 0;
14609 r = guestfs_blockdev_setrw (g, device);
14615 suppress_error = 0;
14616 r = guestfs_umount_all (g);
14622 suppress_error = 0;
14623 r = guestfs_lvm_remove_all (g);
14627 /* TestOutputList for vgcreate (0) */
14629 char device[] = "/dev/sda";
14630 char lines_0[] = ",10";
14631 char lines_1[] = ",20";
14632 char lines_2[] = ",";
14640 suppress_error = 0;
14641 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14646 char device[] = "/dev/sda1";
14648 suppress_error = 0;
14649 r = guestfs_pvcreate (g, device);
14654 char device[] = "/dev/sda2";
14656 suppress_error = 0;
14657 r = guestfs_pvcreate (g, device);
14662 char device[] = "/dev/sda3";
14664 suppress_error = 0;
14665 r = guestfs_pvcreate (g, device);
14670 char volgroup[] = "VG1";
14671 char physvols_0[] = "/dev/sda1";
14672 char physvols_1[] = "/dev/sda2";
14673 char *physvols[] = {
14679 suppress_error = 0;
14680 r = guestfs_vgcreate (g, volgroup, physvols);
14685 char volgroup[] = "VG2";
14686 char physvols_0[] = "/dev/sda3";
14687 char *physvols[] = {
14692 suppress_error = 0;
14693 r = guestfs_vgcreate (g, volgroup, physvols);
14700 suppress_error = 0;
14701 r = guestfs_vgs (g);
14705 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14710 char expected[] = "VG1";
14711 if (strcmp (r[0], expected) != 0) {
14712 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14717 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14722 char expected[] = "VG2";
14723 if (strcmp (r[1], expected) != 0) {
14724 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14728 if (r[2] != NULL) {
14729 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14733 for (i = 0; r[i] != NULL; ++i)
14740 static int test_pvcreate_0_skip (void)
14744 str = getenv ("TEST_ONLY");
14746 return strstr (str, "pvcreate") == NULL;
14747 str = getenv ("SKIP_TEST_PVCREATE_0");
14748 if (str && strcmp (str, "1") == 0) return 1;
14749 str = getenv ("SKIP_TEST_PVCREATE");
14750 if (str && strcmp (str, "1") == 0) return 1;
14754 static int test_pvcreate_0 (void)
14756 if (test_pvcreate_0_skip ()) {
14757 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14761 /* InitNone|InitEmpty for test_pvcreate_0 */
14763 char device[] = "/dev/sda";
14765 suppress_error = 0;
14766 r = guestfs_blockdev_setrw (g, device);
14772 suppress_error = 0;
14773 r = guestfs_umount_all (g);
14779 suppress_error = 0;
14780 r = guestfs_lvm_remove_all (g);
14784 /* TestOutputListOfDevices for pvcreate (0) */
14786 char device[] = "/dev/sda";
14787 char lines_0[] = ",10";
14788 char lines_1[] = ",20";
14789 char lines_2[] = ",";
14797 suppress_error = 0;
14798 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14803 char device[] = "/dev/sda1";
14805 suppress_error = 0;
14806 r = guestfs_pvcreate (g, device);
14811 char device[] = "/dev/sda2";
14813 suppress_error = 0;
14814 r = guestfs_pvcreate (g, device);
14819 char device[] = "/dev/sda3";
14821 suppress_error = 0;
14822 r = guestfs_pvcreate (g, device);
14829 suppress_error = 0;
14830 r = guestfs_pvs (g);
14834 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14839 char expected[] = "/dev/sda1";
14841 if (strcmp (r[0], expected) != 0) {
14842 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14847 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14852 char expected[] = "/dev/sda2";
14854 if (strcmp (r[1], expected) != 0) {
14855 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14860 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14865 char expected[] = "/dev/sda3";
14867 if (strcmp (r[2], expected) != 0) {
14868 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14872 if (r[3] != NULL) {
14873 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14877 for (i = 0; r[i] != NULL; ++i)
14884 static int test_is_dir_0_skip (void)
14888 str = getenv ("TEST_ONLY");
14890 return strstr (str, "is_dir") == NULL;
14891 str = getenv ("SKIP_TEST_IS_DIR_0");
14892 if (str && strcmp (str, "1") == 0) return 1;
14893 str = getenv ("SKIP_TEST_IS_DIR");
14894 if (str && strcmp (str, "1") == 0) return 1;
14898 static int test_is_dir_0 (void)
14900 if (test_is_dir_0_skip ()) {
14901 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14905 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14907 char device[] = "/dev/sda";
14909 suppress_error = 0;
14910 r = guestfs_blockdev_setrw (g, device);
14916 suppress_error = 0;
14917 r = guestfs_umount_all (g);
14923 suppress_error = 0;
14924 r = guestfs_lvm_remove_all (g);
14929 char device[] = "/dev/sda";
14930 char lines_0[] = ",";
14936 suppress_error = 0;
14937 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14942 char fstype[] = "ext2";
14943 char device[] = "/dev/sda1";
14945 suppress_error = 0;
14946 r = guestfs_mkfs (g, fstype, device);
14951 char device[] = "/dev/sda1";
14952 char mountpoint[] = "/";
14954 suppress_error = 0;
14955 r = guestfs_mount (g, device, mountpoint);
14959 /* TestOutputFalse for is_dir (0) */
14961 char path[] = "/new";
14963 suppress_error = 0;
14964 r = guestfs_touch (g, path);
14969 char path[] = "/new";
14971 suppress_error = 0;
14972 r = guestfs_is_dir (g, path);
14976 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14983 static int test_is_dir_1_skip (void)
14987 str = getenv ("TEST_ONLY");
14989 return strstr (str, "is_dir") == NULL;
14990 str = getenv ("SKIP_TEST_IS_DIR_1");
14991 if (str && strcmp (str, "1") == 0) return 1;
14992 str = getenv ("SKIP_TEST_IS_DIR");
14993 if (str && strcmp (str, "1") == 0) return 1;
14997 static int test_is_dir_1 (void)
14999 if (test_is_dir_1_skip ()) {
15000 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
15004 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
15006 char device[] = "/dev/sda";
15008 suppress_error = 0;
15009 r = guestfs_blockdev_setrw (g, device);
15015 suppress_error = 0;
15016 r = guestfs_umount_all (g);
15022 suppress_error = 0;
15023 r = guestfs_lvm_remove_all (g);
15028 char device[] = "/dev/sda";
15029 char lines_0[] = ",";
15035 suppress_error = 0;
15036 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15041 char fstype[] = "ext2";
15042 char device[] = "/dev/sda1";
15044 suppress_error = 0;
15045 r = guestfs_mkfs (g, fstype, device);
15050 char device[] = "/dev/sda1";
15051 char mountpoint[] = "/";
15053 suppress_error = 0;
15054 r = guestfs_mount (g, device, mountpoint);
15058 /* TestOutputTrue for is_dir (1) */
15060 char path[] = "/new";
15062 suppress_error = 0;
15063 r = guestfs_mkdir (g, path);
15068 char path[] = "/new";
15070 suppress_error = 0;
15071 r = guestfs_is_dir (g, path);
15075 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
15082 static int test_is_file_0_skip (void)
15086 str = getenv ("TEST_ONLY");
15088 return strstr (str, "is_file") == NULL;
15089 str = getenv ("SKIP_TEST_IS_FILE_0");
15090 if (str && strcmp (str, "1") == 0) return 1;
15091 str = getenv ("SKIP_TEST_IS_FILE");
15092 if (str && strcmp (str, "1") == 0) return 1;
15096 static int test_is_file_0 (void)
15098 if (test_is_file_0_skip ()) {
15099 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
15103 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
15105 char device[] = "/dev/sda";
15107 suppress_error = 0;
15108 r = guestfs_blockdev_setrw (g, device);
15114 suppress_error = 0;
15115 r = guestfs_umount_all (g);
15121 suppress_error = 0;
15122 r = guestfs_lvm_remove_all (g);
15127 char device[] = "/dev/sda";
15128 char lines_0[] = ",";
15134 suppress_error = 0;
15135 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15140 char fstype[] = "ext2";
15141 char device[] = "/dev/sda1";
15143 suppress_error = 0;
15144 r = guestfs_mkfs (g, fstype, device);
15149 char device[] = "/dev/sda1";
15150 char mountpoint[] = "/";
15152 suppress_error = 0;
15153 r = guestfs_mount (g, device, mountpoint);
15157 /* TestOutputTrue for is_file (0) */
15159 char path[] = "/new";
15161 suppress_error = 0;
15162 r = guestfs_touch (g, path);
15167 char path[] = "/new";
15169 suppress_error = 0;
15170 r = guestfs_is_file (g, path);
15174 fprintf (stderr, "test_is_file_0: expected true, got false\n");
15181 static int test_is_file_1_skip (void)
15185 str = getenv ("TEST_ONLY");
15187 return strstr (str, "is_file") == NULL;
15188 str = getenv ("SKIP_TEST_IS_FILE_1");
15189 if (str && strcmp (str, "1") == 0) return 1;
15190 str = getenv ("SKIP_TEST_IS_FILE");
15191 if (str && strcmp (str, "1") == 0) return 1;
15195 static int test_is_file_1 (void)
15197 if (test_is_file_1_skip ()) {
15198 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
15202 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
15204 char device[] = "/dev/sda";
15206 suppress_error = 0;
15207 r = guestfs_blockdev_setrw (g, device);
15213 suppress_error = 0;
15214 r = guestfs_umount_all (g);
15220 suppress_error = 0;
15221 r = guestfs_lvm_remove_all (g);
15226 char device[] = "/dev/sda";
15227 char lines_0[] = ",";
15233 suppress_error = 0;
15234 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15239 char fstype[] = "ext2";
15240 char device[] = "/dev/sda1";
15242 suppress_error = 0;
15243 r = guestfs_mkfs (g, fstype, device);
15248 char device[] = "/dev/sda1";
15249 char mountpoint[] = "/";
15251 suppress_error = 0;
15252 r = guestfs_mount (g, device, mountpoint);
15256 /* TestOutputFalse for is_file (1) */
15258 char path[] = "/new";
15260 suppress_error = 0;
15261 r = guestfs_mkdir (g, path);
15266 char path[] = "/new";
15268 suppress_error = 0;
15269 r = guestfs_is_file (g, path);
15273 fprintf (stderr, "test_is_file_1: expected false, got true\n");
15280 static int test_exists_0_skip (void)
15284 str = getenv ("TEST_ONLY");
15286 return strstr (str, "exists") == NULL;
15287 str = getenv ("SKIP_TEST_EXISTS_0");
15288 if (str && strcmp (str, "1") == 0) return 1;
15289 str = getenv ("SKIP_TEST_EXISTS");
15290 if (str && strcmp (str, "1") == 0) return 1;
15294 static int test_exists_0 (void)
15296 if (test_exists_0_skip ()) {
15297 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15301 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15303 char device[] = "/dev/sda";
15305 suppress_error = 0;
15306 r = guestfs_blockdev_setrw (g, device);
15312 suppress_error = 0;
15313 r = guestfs_umount_all (g);
15319 suppress_error = 0;
15320 r = guestfs_lvm_remove_all (g);
15325 char device[] = "/dev/sda";
15326 char lines_0[] = ",";
15332 suppress_error = 0;
15333 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15338 char fstype[] = "ext2";
15339 char device[] = "/dev/sda1";
15341 suppress_error = 0;
15342 r = guestfs_mkfs (g, fstype, device);
15347 char device[] = "/dev/sda1";
15348 char mountpoint[] = "/";
15350 suppress_error = 0;
15351 r = guestfs_mount (g, device, mountpoint);
15355 /* TestOutputTrue for exists (0) */
15357 char path[] = "/new";
15359 suppress_error = 0;
15360 r = guestfs_touch (g, path);
15365 char path[] = "/new";
15367 suppress_error = 0;
15368 r = guestfs_exists (g, path);
15372 fprintf (stderr, "test_exists_0: expected true, got false\n");
15379 static int test_exists_1_skip (void)
15383 str = getenv ("TEST_ONLY");
15385 return strstr (str, "exists") == NULL;
15386 str = getenv ("SKIP_TEST_EXISTS_1");
15387 if (str && strcmp (str, "1") == 0) return 1;
15388 str = getenv ("SKIP_TEST_EXISTS");
15389 if (str && strcmp (str, "1") == 0) return 1;
15393 static int test_exists_1 (void)
15395 if (test_exists_1_skip ()) {
15396 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15400 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15402 char device[] = "/dev/sda";
15404 suppress_error = 0;
15405 r = guestfs_blockdev_setrw (g, device);
15411 suppress_error = 0;
15412 r = guestfs_umount_all (g);
15418 suppress_error = 0;
15419 r = guestfs_lvm_remove_all (g);
15424 char device[] = "/dev/sda";
15425 char lines_0[] = ",";
15431 suppress_error = 0;
15432 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15437 char fstype[] = "ext2";
15438 char device[] = "/dev/sda1";
15440 suppress_error = 0;
15441 r = guestfs_mkfs (g, fstype, device);
15446 char device[] = "/dev/sda1";
15447 char mountpoint[] = "/";
15449 suppress_error = 0;
15450 r = guestfs_mount (g, device, mountpoint);
15454 /* TestOutputTrue for exists (1) */
15456 char path[] = "/new";
15458 suppress_error = 0;
15459 r = guestfs_mkdir (g, path);
15464 char path[] = "/new";
15466 suppress_error = 0;
15467 r = guestfs_exists (g, path);
15471 fprintf (stderr, "test_exists_1: expected true, got false\n");
15478 static int test_mkdir_p_0_skip (void)
15482 str = getenv ("TEST_ONLY");
15484 return strstr (str, "mkdir_p") == NULL;
15485 str = getenv ("SKIP_TEST_MKDIR_P_0");
15486 if (str && strcmp (str, "1") == 0) return 1;
15487 str = getenv ("SKIP_TEST_MKDIR_P");
15488 if (str && strcmp (str, "1") == 0) return 1;
15492 static int test_mkdir_p_0 (void)
15494 if (test_mkdir_p_0_skip ()) {
15495 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15499 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15501 char device[] = "/dev/sda";
15503 suppress_error = 0;
15504 r = guestfs_blockdev_setrw (g, device);
15510 suppress_error = 0;
15511 r = guestfs_umount_all (g);
15517 suppress_error = 0;
15518 r = guestfs_lvm_remove_all (g);
15523 char device[] = "/dev/sda";
15524 char lines_0[] = ",";
15530 suppress_error = 0;
15531 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15536 char fstype[] = "ext2";
15537 char device[] = "/dev/sda1";
15539 suppress_error = 0;
15540 r = guestfs_mkfs (g, fstype, device);
15545 char device[] = "/dev/sda1";
15546 char mountpoint[] = "/";
15548 suppress_error = 0;
15549 r = guestfs_mount (g, device, mountpoint);
15553 /* TestOutputTrue for mkdir_p (0) */
15555 char path[] = "/new/foo/bar";
15557 suppress_error = 0;
15558 r = guestfs_mkdir_p (g, path);
15563 char path[] = "/new/foo/bar";
15565 suppress_error = 0;
15566 r = guestfs_is_dir (g, path);
15570 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15577 static int test_mkdir_p_1_skip (void)
15581 str = getenv ("TEST_ONLY");
15583 return strstr (str, "mkdir_p") == NULL;
15584 str = getenv ("SKIP_TEST_MKDIR_P_1");
15585 if (str && strcmp (str, "1") == 0) return 1;
15586 str = getenv ("SKIP_TEST_MKDIR_P");
15587 if (str && strcmp (str, "1") == 0) return 1;
15591 static int test_mkdir_p_1 (void)
15593 if (test_mkdir_p_1_skip ()) {
15594 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15598 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15600 char device[] = "/dev/sda";
15602 suppress_error = 0;
15603 r = guestfs_blockdev_setrw (g, device);
15609 suppress_error = 0;
15610 r = guestfs_umount_all (g);
15616 suppress_error = 0;
15617 r = guestfs_lvm_remove_all (g);
15622 char device[] = "/dev/sda";
15623 char lines_0[] = ",";
15629 suppress_error = 0;
15630 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15635 char fstype[] = "ext2";
15636 char device[] = "/dev/sda1";
15638 suppress_error = 0;
15639 r = guestfs_mkfs (g, fstype, device);
15644 char device[] = "/dev/sda1";
15645 char mountpoint[] = "/";
15647 suppress_error = 0;
15648 r = guestfs_mount (g, device, mountpoint);
15652 /* TestOutputTrue for mkdir_p (1) */
15654 char path[] = "/new/foo/bar";
15656 suppress_error = 0;
15657 r = guestfs_mkdir_p (g, path);
15662 char path[] = "/new/foo";
15664 suppress_error = 0;
15665 r = guestfs_is_dir (g, path);
15669 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15676 static int test_mkdir_p_2_skip (void)
15680 str = getenv ("TEST_ONLY");
15682 return strstr (str, "mkdir_p") == NULL;
15683 str = getenv ("SKIP_TEST_MKDIR_P_2");
15684 if (str && strcmp (str, "1") == 0) return 1;
15685 str = getenv ("SKIP_TEST_MKDIR_P");
15686 if (str && strcmp (str, "1") == 0) return 1;
15690 static int test_mkdir_p_2 (void)
15692 if (test_mkdir_p_2_skip ()) {
15693 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15697 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15699 char device[] = "/dev/sda";
15701 suppress_error = 0;
15702 r = guestfs_blockdev_setrw (g, device);
15708 suppress_error = 0;
15709 r = guestfs_umount_all (g);
15715 suppress_error = 0;
15716 r = guestfs_lvm_remove_all (g);
15721 char device[] = "/dev/sda";
15722 char lines_0[] = ",";
15728 suppress_error = 0;
15729 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15734 char fstype[] = "ext2";
15735 char device[] = "/dev/sda1";
15737 suppress_error = 0;
15738 r = guestfs_mkfs (g, fstype, device);
15743 char device[] = "/dev/sda1";
15744 char mountpoint[] = "/";
15746 suppress_error = 0;
15747 r = guestfs_mount (g, device, mountpoint);
15751 /* TestOutputTrue for mkdir_p (2) */
15753 char path[] = "/new/foo/bar";
15755 suppress_error = 0;
15756 r = guestfs_mkdir_p (g, path);
15761 char path[] = "/new";
15763 suppress_error = 0;
15764 r = guestfs_is_dir (g, path);
15768 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15775 static int test_mkdir_p_3_skip (void)
15779 str = getenv ("TEST_ONLY");
15781 return strstr (str, "mkdir_p") == NULL;
15782 str = getenv ("SKIP_TEST_MKDIR_P_3");
15783 if (str && strcmp (str, "1") == 0) return 1;
15784 str = getenv ("SKIP_TEST_MKDIR_P");
15785 if (str && strcmp (str, "1") == 0) return 1;
15789 static int test_mkdir_p_3 (void)
15791 if (test_mkdir_p_3_skip ()) {
15792 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15796 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15798 char device[] = "/dev/sda";
15800 suppress_error = 0;
15801 r = guestfs_blockdev_setrw (g, device);
15807 suppress_error = 0;
15808 r = guestfs_umount_all (g);
15814 suppress_error = 0;
15815 r = guestfs_lvm_remove_all (g);
15820 char device[] = "/dev/sda";
15821 char lines_0[] = ",";
15827 suppress_error = 0;
15828 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15833 char fstype[] = "ext2";
15834 char device[] = "/dev/sda1";
15836 suppress_error = 0;
15837 r = guestfs_mkfs (g, fstype, device);
15842 char device[] = "/dev/sda1";
15843 char mountpoint[] = "/";
15845 suppress_error = 0;
15846 r = guestfs_mount (g, device, mountpoint);
15850 /* TestRun for mkdir_p (3) */
15852 char path[] = "/new";
15854 suppress_error = 0;
15855 r = guestfs_mkdir (g, path);
15860 char path[] = "/new";
15862 suppress_error = 0;
15863 r = guestfs_mkdir_p (g, path);
15870 static int test_mkdir_p_4_skip (void)
15874 str = getenv ("TEST_ONLY");
15876 return strstr (str, "mkdir_p") == NULL;
15877 str = getenv ("SKIP_TEST_MKDIR_P_4");
15878 if (str && strcmp (str, "1") == 0) return 1;
15879 str = getenv ("SKIP_TEST_MKDIR_P");
15880 if (str && strcmp (str, "1") == 0) return 1;
15884 static int test_mkdir_p_4 (void)
15886 if (test_mkdir_p_4_skip ()) {
15887 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15891 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15893 char device[] = "/dev/sda";
15895 suppress_error = 0;
15896 r = guestfs_blockdev_setrw (g, device);
15902 suppress_error = 0;
15903 r = guestfs_umount_all (g);
15909 suppress_error = 0;
15910 r = guestfs_lvm_remove_all (g);
15915 char device[] = "/dev/sda";
15916 char lines_0[] = ",";
15922 suppress_error = 0;
15923 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15928 char fstype[] = "ext2";
15929 char device[] = "/dev/sda1";
15931 suppress_error = 0;
15932 r = guestfs_mkfs (g, fstype, device);
15937 char device[] = "/dev/sda1";
15938 char mountpoint[] = "/";
15940 suppress_error = 0;
15941 r = guestfs_mount (g, device, mountpoint);
15945 /* TestLastFail for mkdir_p (4) */
15947 char path[] = "/new";
15949 suppress_error = 0;
15950 r = guestfs_touch (g, path);
15955 char path[] = "/new";
15957 suppress_error = 1;
15958 r = guestfs_mkdir_p (g, path);
15965 static int test_mkdir_0_skip (void)
15969 str = getenv ("TEST_ONLY");
15971 return strstr (str, "mkdir") == NULL;
15972 str = getenv ("SKIP_TEST_MKDIR_0");
15973 if (str && strcmp (str, "1") == 0) return 1;
15974 str = getenv ("SKIP_TEST_MKDIR");
15975 if (str && strcmp (str, "1") == 0) return 1;
15979 static int test_mkdir_0 (void)
15981 if (test_mkdir_0_skip ()) {
15982 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15986 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15988 char device[] = "/dev/sda";
15990 suppress_error = 0;
15991 r = guestfs_blockdev_setrw (g, device);
15997 suppress_error = 0;
15998 r = guestfs_umount_all (g);
16004 suppress_error = 0;
16005 r = guestfs_lvm_remove_all (g);
16010 char device[] = "/dev/sda";
16011 char lines_0[] = ",";
16017 suppress_error = 0;
16018 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16023 char fstype[] = "ext2";
16024 char device[] = "/dev/sda1";
16026 suppress_error = 0;
16027 r = guestfs_mkfs (g, fstype, device);
16032 char device[] = "/dev/sda1";
16033 char mountpoint[] = "/";
16035 suppress_error = 0;
16036 r = guestfs_mount (g, device, mountpoint);
16040 /* TestOutputTrue for mkdir (0) */
16042 char path[] = "/new";
16044 suppress_error = 0;
16045 r = guestfs_mkdir (g, path);
16050 char path[] = "/new";
16052 suppress_error = 0;
16053 r = guestfs_is_dir (g, path);
16057 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
16064 static int test_mkdir_1_skip (void)
16068 str = getenv ("TEST_ONLY");
16070 return strstr (str, "mkdir") == NULL;
16071 str = getenv ("SKIP_TEST_MKDIR_1");
16072 if (str && strcmp (str, "1") == 0) return 1;
16073 str = getenv ("SKIP_TEST_MKDIR");
16074 if (str && strcmp (str, "1") == 0) return 1;
16078 static int test_mkdir_1 (void)
16080 if (test_mkdir_1_skip ()) {
16081 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
16085 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
16087 char device[] = "/dev/sda";
16089 suppress_error = 0;
16090 r = guestfs_blockdev_setrw (g, device);
16096 suppress_error = 0;
16097 r = guestfs_umount_all (g);
16103 suppress_error = 0;
16104 r = guestfs_lvm_remove_all (g);
16109 char device[] = "/dev/sda";
16110 char lines_0[] = ",";
16116 suppress_error = 0;
16117 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16122 char fstype[] = "ext2";
16123 char device[] = "/dev/sda1";
16125 suppress_error = 0;
16126 r = guestfs_mkfs (g, fstype, device);
16131 char device[] = "/dev/sda1";
16132 char mountpoint[] = "/";
16134 suppress_error = 0;
16135 r = guestfs_mount (g, device, mountpoint);
16139 /* TestLastFail for mkdir (1) */
16141 char path[] = "/new/foo/bar";
16143 suppress_error = 1;
16144 r = guestfs_mkdir (g, path);
16151 static int test_rm_rf_0_skip (void)
16155 str = getenv ("TEST_ONLY");
16157 return strstr (str, "rm_rf") == NULL;
16158 str = getenv ("SKIP_TEST_RM_RF_0");
16159 if (str && strcmp (str, "1") == 0) return 1;
16160 str = getenv ("SKIP_TEST_RM_RF");
16161 if (str && strcmp (str, "1") == 0) return 1;
16165 static int test_rm_rf_0 (void)
16167 if (test_rm_rf_0_skip ()) {
16168 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
16172 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
16174 char device[] = "/dev/sda";
16176 suppress_error = 0;
16177 r = guestfs_blockdev_setrw (g, device);
16183 suppress_error = 0;
16184 r = guestfs_umount_all (g);
16190 suppress_error = 0;
16191 r = guestfs_lvm_remove_all (g);
16196 char device[] = "/dev/sda";
16197 char lines_0[] = ",";
16203 suppress_error = 0;
16204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16209 char fstype[] = "ext2";
16210 char device[] = "/dev/sda1";
16212 suppress_error = 0;
16213 r = guestfs_mkfs (g, fstype, device);
16218 char device[] = "/dev/sda1";
16219 char mountpoint[] = "/";
16221 suppress_error = 0;
16222 r = guestfs_mount (g, device, mountpoint);
16226 /* TestOutputFalse for rm_rf (0) */
16228 char path[] = "/new";
16230 suppress_error = 0;
16231 r = guestfs_mkdir (g, path);
16236 char path[] = "/new/foo";
16238 suppress_error = 0;
16239 r = guestfs_mkdir (g, path);
16244 char path[] = "/new/foo/bar";
16246 suppress_error = 0;
16247 r = guestfs_touch (g, path);
16252 char path[] = "/new";
16254 suppress_error = 0;
16255 r = guestfs_rm_rf (g, path);
16260 char path[] = "/new";
16262 suppress_error = 0;
16263 r = guestfs_exists (g, path);
16267 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16274 static int test_rmdir_0_skip (void)
16278 str = getenv ("TEST_ONLY");
16280 return strstr (str, "rmdir") == NULL;
16281 str = getenv ("SKIP_TEST_RMDIR_0");
16282 if (str && strcmp (str, "1") == 0) return 1;
16283 str = getenv ("SKIP_TEST_RMDIR");
16284 if (str && strcmp (str, "1") == 0) return 1;
16288 static int test_rmdir_0 (void)
16290 if (test_rmdir_0_skip ()) {
16291 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16295 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16297 char device[] = "/dev/sda";
16299 suppress_error = 0;
16300 r = guestfs_blockdev_setrw (g, device);
16306 suppress_error = 0;
16307 r = guestfs_umount_all (g);
16313 suppress_error = 0;
16314 r = guestfs_lvm_remove_all (g);
16319 char device[] = "/dev/sda";
16320 char lines_0[] = ",";
16326 suppress_error = 0;
16327 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16332 char fstype[] = "ext2";
16333 char device[] = "/dev/sda1";
16335 suppress_error = 0;
16336 r = guestfs_mkfs (g, fstype, device);
16341 char device[] = "/dev/sda1";
16342 char mountpoint[] = "/";
16344 suppress_error = 0;
16345 r = guestfs_mount (g, device, mountpoint);
16349 /* TestRun for rmdir (0) */
16351 char path[] = "/new";
16353 suppress_error = 0;
16354 r = guestfs_mkdir (g, path);
16359 char path[] = "/new";
16361 suppress_error = 0;
16362 r = guestfs_rmdir (g, path);
16369 static int test_rmdir_1_skip (void)
16373 str = getenv ("TEST_ONLY");
16375 return strstr (str, "rmdir") == NULL;
16376 str = getenv ("SKIP_TEST_RMDIR_1");
16377 if (str && strcmp (str, "1") == 0) return 1;
16378 str = getenv ("SKIP_TEST_RMDIR");
16379 if (str && strcmp (str, "1") == 0) return 1;
16383 static int test_rmdir_1 (void)
16385 if (test_rmdir_1_skip ()) {
16386 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16390 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16392 char device[] = "/dev/sda";
16394 suppress_error = 0;
16395 r = guestfs_blockdev_setrw (g, device);
16401 suppress_error = 0;
16402 r = guestfs_umount_all (g);
16408 suppress_error = 0;
16409 r = guestfs_lvm_remove_all (g);
16414 char device[] = "/dev/sda";
16415 char lines_0[] = ",";
16421 suppress_error = 0;
16422 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16427 char fstype[] = "ext2";
16428 char device[] = "/dev/sda1";
16430 suppress_error = 0;
16431 r = guestfs_mkfs (g, fstype, device);
16436 char device[] = "/dev/sda1";
16437 char mountpoint[] = "/";
16439 suppress_error = 0;
16440 r = guestfs_mount (g, device, mountpoint);
16444 /* TestLastFail for rmdir (1) */
16446 char path[] = "/new";
16448 suppress_error = 1;
16449 r = guestfs_rmdir (g, path);
16456 static int test_rmdir_2_skip (void)
16460 str = getenv ("TEST_ONLY");
16462 return strstr (str, "rmdir") == NULL;
16463 str = getenv ("SKIP_TEST_RMDIR_2");
16464 if (str && strcmp (str, "1") == 0) return 1;
16465 str = getenv ("SKIP_TEST_RMDIR");
16466 if (str && strcmp (str, "1") == 0) return 1;
16470 static int test_rmdir_2 (void)
16472 if (test_rmdir_2_skip ()) {
16473 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16477 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16479 char device[] = "/dev/sda";
16481 suppress_error = 0;
16482 r = guestfs_blockdev_setrw (g, device);
16488 suppress_error = 0;
16489 r = guestfs_umount_all (g);
16495 suppress_error = 0;
16496 r = guestfs_lvm_remove_all (g);
16501 char device[] = "/dev/sda";
16502 char lines_0[] = ",";
16508 suppress_error = 0;
16509 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16514 char fstype[] = "ext2";
16515 char device[] = "/dev/sda1";
16517 suppress_error = 0;
16518 r = guestfs_mkfs (g, fstype, device);
16523 char device[] = "/dev/sda1";
16524 char mountpoint[] = "/";
16526 suppress_error = 0;
16527 r = guestfs_mount (g, device, mountpoint);
16531 /* TestLastFail for rmdir (2) */
16533 char path[] = "/new";
16535 suppress_error = 0;
16536 r = guestfs_touch (g, path);
16541 char path[] = "/new";
16543 suppress_error = 1;
16544 r = guestfs_rmdir (g, path);
16551 static int test_rm_0_skip (void)
16555 str = getenv ("TEST_ONLY");
16557 return strstr (str, "rm") == NULL;
16558 str = getenv ("SKIP_TEST_RM_0");
16559 if (str && strcmp (str, "1") == 0) return 1;
16560 str = getenv ("SKIP_TEST_RM");
16561 if (str && strcmp (str, "1") == 0) return 1;
16565 static int test_rm_0 (void)
16567 if (test_rm_0_skip ()) {
16568 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16572 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16574 char device[] = "/dev/sda";
16576 suppress_error = 0;
16577 r = guestfs_blockdev_setrw (g, device);
16583 suppress_error = 0;
16584 r = guestfs_umount_all (g);
16590 suppress_error = 0;
16591 r = guestfs_lvm_remove_all (g);
16596 char device[] = "/dev/sda";
16597 char lines_0[] = ",";
16603 suppress_error = 0;
16604 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16609 char fstype[] = "ext2";
16610 char device[] = "/dev/sda1";
16612 suppress_error = 0;
16613 r = guestfs_mkfs (g, fstype, device);
16618 char device[] = "/dev/sda1";
16619 char mountpoint[] = "/";
16621 suppress_error = 0;
16622 r = guestfs_mount (g, device, mountpoint);
16626 /* TestRun for rm (0) */
16628 char path[] = "/new";
16630 suppress_error = 0;
16631 r = guestfs_touch (g, path);
16636 char path[] = "/new";
16638 suppress_error = 0;
16639 r = guestfs_rm (g, path);
16646 static int test_rm_1_skip (void)
16650 str = getenv ("TEST_ONLY");
16652 return strstr (str, "rm") == NULL;
16653 str = getenv ("SKIP_TEST_RM_1");
16654 if (str && strcmp (str, "1") == 0) return 1;
16655 str = getenv ("SKIP_TEST_RM");
16656 if (str && strcmp (str, "1") == 0) return 1;
16660 static int test_rm_1 (void)
16662 if (test_rm_1_skip ()) {
16663 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16667 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16669 char device[] = "/dev/sda";
16671 suppress_error = 0;
16672 r = guestfs_blockdev_setrw (g, device);
16678 suppress_error = 0;
16679 r = guestfs_umount_all (g);
16685 suppress_error = 0;
16686 r = guestfs_lvm_remove_all (g);
16691 char device[] = "/dev/sda";
16692 char lines_0[] = ",";
16698 suppress_error = 0;
16699 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16704 char fstype[] = "ext2";
16705 char device[] = "/dev/sda1";
16707 suppress_error = 0;
16708 r = guestfs_mkfs (g, fstype, device);
16713 char device[] = "/dev/sda1";
16714 char mountpoint[] = "/";
16716 suppress_error = 0;
16717 r = guestfs_mount (g, device, mountpoint);
16721 /* TestLastFail for rm (1) */
16723 char path[] = "/new";
16725 suppress_error = 1;
16726 r = guestfs_rm (g, path);
16733 static int test_rm_2_skip (void)
16737 str = getenv ("TEST_ONLY");
16739 return strstr (str, "rm") == NULL;
16740 str = getenv ("SKIP_TEST_RM_2");
16741 if (str && strcmp (str, "1") == 0) return 1;
16742 str = getenv ("SKIP_TEST_RM");
16743 if (str && strcmp (str, "1") == 0) return 1;
16747 static int test_rm_2 (void)
16749 if (test_rm_2_skip ()) {
16750 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16754 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16756 char device[] = "/dev/sda";
16758 suppress_error = 0;
16759 r = guestfs_blockdev_setrw (g, device);
16765 suppress_error = 0;
16766 r = guestfs_umount_all (g);
16772 suppress_error = 0;
16773 r = guestfs_lvm_remove_all (g);
16778 char device[] = "/dev/sda";
16779 char lines_0[] = ",";
16785 suppress_error = 0;
16786 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16791 char fstype[] = "ext2";
16792 char device[] = "/dev/sda1";
16794 suppress_error = 0;
16795 r = guestfs_mkfs (g, fstype, device);
16800 char device[] = "/dev/sda1";
16801 char mountpoint[] = "/";
16803 suppress_error = 0;
16804 r = guestfs_mount (g, device, mountpoint);
16808 /* TestLastFail for rm (2) */
16810 char path[] = "/new";
16812 suppress_error = 0;
16813 r = guestfs_mkdir (g, path);
16818 char path[] = "/new";
16820 suppress_error = 1;
16821 r = guestfs_rm (g, path);
16828 static int test_read_lines_0_skip (void)
16832 str = getenv ("TEST_ONLY");
16834 return strstr (str, "read_lines") == NULL;
16835 str = getenv ("SKIP_TEST_READ_LINES_0");
16836 if (str && strcmp (str, "1") == 0) return 1;
16837 str = getenv ("SKIP_TEST_READ_LINES");
16838 if (str && strcmp (str, "1") == 0) return 1;
16842 static int test_read_lines_0 (void)
16844 if (test_read_lines_0_skip ()) {
16845 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16849 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16851 char device[] = "/dev/sda";
16853 suppress_error = 0;
16854 r = guestfs_blockdev_setrw (g, device);
16860 suppress_error = 0;
16861 r = guestfs_umount_all (g);
16867 suppress_error = 0;
16868 r = guestfs_lvm_remove_all (g);
16873 char device[] = "/dev/sda";
16874 char lines_0[] = ",";
16880 suppress_error = 0;
16881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16886 char fstype[] = "ext2";
16887 char device[] = "/dev/sda1";
16889 suppress_error = 0;
16890 r = guestfs_mkfs (g, fstype, device);
16895 char device[] = "/dev/sda1";
16896 char mountpoint[] = "/";
16898 suppress_error = 0;
16899 r = guestfs_mount (g, device, mountpoint);
16903 /* TestOutputList for read_lines (0) */
16905 char path[] = "/new";
16906 char content[] = "line1\r\nline2\nline3";
16908 suppress_error = 0;
16909 r = guestfs_write_file (g, path, content, 0);
16914 char path[] = "/new";
16917 suppress_error = 0;
16918 r = guestfs_read_lines (g, path);
16922 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16927 char expected[] = "line1";
16928 if (strcmp (r[0], expected) != 0) {
16929 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16934 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16939 char expected[] = "line2";
16940 if (strcmp (r[1], expected) != 0) {
16941 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16946 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16951 char expected[] = "line3";
16952 if (strcmp (r[2], expected) != 0) {
16953 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16957 if (r[3] != NULL) {
16958 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16962 for (i = 0; r[i] != NULL; ++i)
16969 static int test_read_lines_1_skip (void)
16973 str = getenv ("TEST_ONLY");
16975 return strstr (str, "read_lines") == NULL;
16976 str = getenv ("SKIP_TEST_READ_LINES_1");
16977 if (str && strcmp (str, "1") == 0) return 1;
16978 str = getenv ("SKIP_TEST_READ_LINES");
16979 if (str && strcmp (str, "1") == 0) return 1;
16983 static int test_read_lines_1 (void)
16985 if (test_read_lines_1_skip ()) {
16986 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16990 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16992 char device[] = "/dev/sda";
16994 suppress_error = 0;
16995 r = guestfs_blockdev_setrw (g, device);
17001 suppress_error = 0;
17002 r = guestfs_umount_all (g);
17008 suppress_error = 0;
17009 r = guestfs_lvm_remove_all (g);
17014 char device[] = "/dev/sda";
17015 char lines_0[] = ",";
17021 suppress_error = 0;
17022 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17027 char fstype[] = "ext2";
17028 char device[] = "/dev/sda1";
17030 suppress_error = 0;
17031 r = guestfs_mkfs (g, fstype, device);
17036 char device[] = "/dev/sda1";
17037 char mountpoint[] = "/";
17039 suppress_error = 0;
17040 r = guestfs_mount (g, device, mountpoint);
17044 /* TestOutputList for read_lines (1) */
17046 char path[] = "/new";
17047 char content[] = "";
17049 suppress_error = 0;
17050 r = guestfs_write_file (g, path, content, 0);
17055 char path[] = "/new";
17058 suppress_error = 0;
17059 r = guestfs_read_lines (g, path);
17062 if (r[0] != NULL) {
17063 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
17067 for (i = 0; r[i] != NULL; ++i)
17074 static int test_lvs_0_skip (void)
17078 str = getenv ("TEST_ONLY");
17080 return strstr (str, "lvs") == NULL;
17081 str = getenv ("SKIP_TEST_LVS_0");
17082 if (str && strcmp (str, "1") == 0) return 1;
17083 str = getenv ("SKIP_TEST_LVS");
17084 if (str && strcmp (str, "1") == 0) return 1;
17088 static int test_lvs_0 (void)
17090 if (test_lvs_0_skip ()) {
17091 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
17095 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
17097 char device[] = "/dev/sda";
17099 suppress_error = 0;
17100 r = guestfs_blockdev_setrw (g, device);
17106 suppress_error = 0;
17107 r = guestfs_umount_all (g);
17113 suppress_error = 0;
17114 r = guestfs_lvm_remove_all (g);
17119 char device[] = "/dev/sda";
17120 char lines_0[] = ",";
17126 suppress_error = 0;
17127 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17132 char device[] = "/dev/sda1";
17134 suppress_error = 0;
17135 r = guestfs_pvcreate (g, device);
17140 char volgroup[] = "VG";
17141 char physvols_0[] = "/dev/sda1";
17142 char *physvols[] = {
17147 suppress_error = 0;
17148 r = guestfs_vgcreate (g, volgroup, physvols);
17153 char logvol[] = "LV";
17154 char volgroup[] = "VG";
17156 suppress_error = 0;
17157 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17162 char fstype[] = "ext2";
17163 char device[] = "/dev/VG/LV";
17165 suppress_error = 0;
17166 r = guestfs_mkfs (g, fstype, device);
17171 char device[] = "/dev/VG/LV";
17172 char mountpoint[] = "/";
17174 suppress_error = 0;
17175 r = guestfs_mount (g, device, mountpoint);
17179 /* TestOutputList for lvs (0) */
17183 suppress_error = 0;
17184 r = guestfs_lvs (g);
17188 fprintf (stderr, "test_lvs_0: short list returned from command\n");
17193 char expected[] = "/dev/VG/LV";
17194 if (strcmp (r[0], expected) != 0) {
17195 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17199 if (r[1] != NULL) {
17200 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
17204 for (i = 0; r[i] != NULL; ++i)
17211 static int test_lvs_1_skip (void)
17215 str = getenv ("TEST_ONLY");
17217 return strstr (str, "lvs") == NULL;
17218 str = getenv ("SKIP_TEST_LVS_1");
17219 if (str && strcmp (str, "1") == 0) return 1;
17220 str = getenv ("SKIP_TEST_LVS");
17221 if (str && strcmp (str, "1") == 0) return 1;
17225 static int test_lvs_1 (void)
17227 if (test_lvs_1_skip ()) {
17228 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17232 /* InitNone|InitEmpty for test_lvs_1 */
17234 char device[] = "/dev/sda";
17236 suppress_error = 0;
17237 r = guestfs_blockdev_setrw (g, device);
17243 suppress_error = 0;
17244 r = guestfs_umount_all (g);
17250 suppress_error = 0;
17251 r = guestfs_lvm_remove_all (g);
17255 /* TestOutputList for lvs (1) */
17257 char device[] = "/dev/sda";
17258 char lines_0[] = ",10";
17259 char lines_1[] = ",20";
17260 char lines_2[] = ",";
17268 suppress_error = 0;
17269 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17274 char device[] = "/dev/sda1";
17276 suppress_error = 0;
17277 r = guestfs_pvcreate (g, device);
17282 char device[] = "/dev/sda2";
17284 suppress_error = 0;
17285 r = guestfs_pvcreate (g, device);
17290 char device[] = "/dev/sda3";
17292 suppress_error = 0;
17293 r = guestfs_pvcreate (g, device);
17298 char volgroup[] = "VG1";
17299 char physvols_0[] = "/dev/sda1";
17300 char physvols_1[] = "/dev/sda2";
17301 char *physvols[] = {
17307 suppress_error = 0;
17308 r = guestfs_vgcreate (g, volgroup, physvols);
17313 char volgroup[] = "VG2";
17314 char physvols_0[] = "/dev/sda3";
17315 char *physvols[] = {
17320 suppress_error = 0;
17321 r = guestfs_vgcreate (g, volgroup, physvols);
17326 char logvol[] = "LV1";
17327 char volgroup[] = "VG1";
17329 suppress_error = 0;
17330 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17335 char logvol[] = "LV2";
17336 char volgroup[] = "VG1";
17338 suppress_error = 0;
17339 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17344 char logvol[] = "LV3";
17345 char volgroup[] = "VG2";
17347 suppress_error = 0;
17348 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17355 suppress_error = 0;
17356 r = guestfs_lvs (g);
17360 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17365 char expected[] = "/dev/VG1/LV1";
17366 if (strcmp (r[0], expected) != 0) {
17367 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17372 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17377 char expected[] = "/dev/VG1/LV2";
17378 if (strcmp (r[1], expected) != 0) {
17379 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17384 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17389 char expected[] = "/dev/VG2/LV3";
17390 if (strcmp (r[2], expected) != 0) {
17391 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17395 if (r[3] != NULL) {
17396 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17400 for (i = 0; r[i] != NULL; ++i)
17407 static int test_vgs_0_skip (void)
17411 str = getenv ("TEST_ONLY");
17413 return strstr (str, "vgs") == NULL;
17414 str = getenv ("SKIP_TEST_VGS_0");
17415 if (str && strcmp (str, "1") == 0) return 1;
17416 str = getenv ("SKIP_TEST_VGS");
17417 if (str && strcmp (str, "1") == 0) return 1;
17421 static int test_vgs_0 (void)
17423 if (test_vgs_0_skip ()) {
17424 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17428 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17430 char device[] = "/dev/sda";
17432 suppress_error = 0;
17433 r = guestfs_blockdev_setrw (g, device);
17439 suppress_error = 0;
17440 r = guestfs_umount_all (g);
17446 suppress_error = 0;
17447 r = guestfs_lvm_remove_all (g);
17452 char device[] = "/dev/sda";
17453 char lines_0[] = ",";
17459 suppress_error = 0;
17460 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17465 char device[] = "/dev/sda1";
17467 suppress_error = 0;
17468 r = guestfs_pvcreate (g, device);
17473 char volgroup[] = "VG";
17474 char physvols_0[] = "/dev/sda1";
17475 char *physvols[] = {
17480 suppress_error = 0;
17481 r = guestfs_vgcreate (g, volgroup, physvols);
17486 char logvol[] = "LV";
17487 char volgroup[] = "VG";
17489 suppress_error = 0;
17490 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17495 char fstype[] = "ext2";
17496 char device[] = "/dev/VG/LV";
17498 suppress_error = 0;
17499 r = guestfs_mkfs (g, fstype, device);
17504 char device[] = "/dev/VG/LV";
17505 char mountpoint[] = "/";
17507 suppress_error = 0;
17508 r = guestfs_mount (g, device, mountpoint);
17512 /* TestOutputList for vgs (0) */
17516 suppress_error = 0;
17517 r = guestfs_vgs (g);
17521 fprintf (stderr, "test_vgs_0: short list returned from command\n");
17526 char expected[] = "VG";
17527 if (strcmp (r[0], expected) != 0) {
17528 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17532 if (r[1] != NULL) {
17533 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17537 for (i = 0; r[i] != NULL; ++i)
17544 static int test_vgs_1_skip (void)
17548 str = getenv ("TEST_ONLY");
17550 return strstr (str, "vgs") == NULL;
17551 str = getenv ("SKIP_TEST_VGS_1");
17552 if (str && strcmp (str, "1") == 0) return 1;
17553 str = getenv ("SKIP_TEST_VGS");
17554 if (str && strcmp (str, "1") == 0) return 1;
17558 static int test_vgs_1 (void)
17560 if (test_vgs_1_skip ()) {
17561 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17565 /* InitNone|InitEmpty for test_vgs_1 */
17567 char device[] = "/dev/sda";
17569 suppress_error = 0;
17570 r = guestfs_blockdev_setrw (g, device);
17576 suppress_error = 0;
17577 r = guestfs_umount_all (g);
17583 suppress_error = 0;
17584 r = guestfs_lvm_remove_all (g);
17588 /* TestOutputList for vgs (1) */
17590 char device[] = "/dev/sda";
17591 char lines_0[] = ",10";
17592 char lines_1[] = ",20";
17593 char lines_2[] = ",";
17601 suppress_error = 0;
17602 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17607 char device[] = "/dev/sda1";
17609 suppress_error = 0;
17610 r = guestfs_pvcreate (g, device);
17615 char device[] = "/dev/sda2";
17617 suppress_error = 0;
17618 r = guestfs_pvcreate (g, device);
17623 char device[] = "/dev/sda3";
17625 suppress_error = 0;
17626 r = guestfs_pvcreate (g, device);
17631 char volgroup[] = "VG1";
17632 char physvols_0[] = "/dev/sda1";
17633 char physvols_1[] = "/dev/sda2";
17634 char *physvols[] = {
17640 suppress_error = 0;
17641 r = guestfs_vgcreate (g, volgroup, physvols);
17646 char volgroup[] = "VG2";
17647 char physvols_0[] = "/dev/sda3";
17648 char *physvols[] = {
17653 suppress_error = 0;
17654 r = guestfs_vgcreate (g, volgroup, physvols);
17661 suppress_error = 0;
17662 r = guestfs_vgs (g);
17666 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17671 char expected[] = "VG1";
17672 if (strcmp (r[0], expected) != 0) {
17673 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17678 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17683 char expected[] = "VG2";
17684 if (strcmp (r[1], expected) != 0) {
17685 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17689 if (r[2] != NULL) {
17690 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17694 for (i = 0; r[i] != NULL; ++i)
17701 static int test_pvs_0_skip (void)
17705 str = getenv ("TEST_ONLY");
17707 return strstr (str, "pvs") == NULL;
17708 str = getenv ("SKIP_TEST_PVS_0");
17709 if (str && strcmp (str, "1") == 0) return 1;
17710 str = getenv ("SKIP_TEST_PVS");
17711 if (str && strcmp (str, "1") == 0) return 1;
17715 static int test_pvs_0 (void)
17717 if (test_pvs_0_skip ()) {
17718 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17722 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17724 char device[] = "/dev/sda";
17726 suppress_error = 0;
17727 r = guestfs_blockdev_setrw (g, device);
17733 suppress_error = 0;
17734 r = guestfs_umount_all (g);
17740 suppress_error = 0;
17741 r = guestfs_lvm_remove_all (g);
17746 char device[] = "/dev/sda";
17747 char lines_0[] = ",";
17753 suppress_error = 0;
17754 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17759 char device[] = "/dev/sda1";
17761 suppress_error = 0;
17762 r = guestfs_pvcreate (g, device);
17767 char volgroup[] = "VG";
17768 char physvols_0[] = "/dev/sda1";
17769 char *physvols[] = {
17774 suppress_error = 0;
17775 r = guestfs_vgcreate (g, volgroup, physvols);
17780 char logvol[] = "LV";
17781 char volgroup[] = "VG";
17783 suppress_error = 0;
17784 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17789 char fstype[] = "ext2";
17790 char device[] = "/dev/VG/LV";
17792 suppress_error = 0;
17793 r = guestfs_mkfs (g, fstype, device);
17798 char device[] = "/dev/VG/LV";
17799 char mountpoint[] = "/";
17801 suppress_error = 0;
17802 r = guestfs_mount (g, device, mountpoint);
17806 /* TestOutputListOfDevices for pvs (0) */
17810 suppress_error = 0;
17811 r = guestfs_pvs (g);
17815 fprintf (stderr, "test_pvs_0: short list returned from command\n");
17820 char expected[] = "/dev/sda1";
17822 if (strcmp (r[0], expected) != 0) {
17823 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17827 if (r[1] != NULL) {
17828 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17832 for (i = 0; r[i] != NULL; ++i)
17839 static int test_pvs_1_skip (void)
17843 str = getenv ("TEST_ONLY");
17845 return strstr (str, "pvs") == NULL;
17846 str = getenv ("SKIP_TEST_PVS_1");
17847 if (str && strcmp (str, "1") == 0) return 1;
17848 str = getenv ("SKIP_TEST_PVS");
17849 if (str && strcmp (str, "1") == 0) return 1;
17853 static int test_pvs_1 (void)
17855 if (test_pvs_1_skip ()) {
17856 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17860 /* InitNone|InitEmpty for test_pvs_1 */
17862 char device[] = "/dev/sda";
17864 suppress_error = 0;
17865 r = guestfs_blockdev_setrw (g, device);
17871 suppress_error = 0;
17872 r = guestfs_umount_all (g);
17878 suppress_error = 0;
17879 r = guestfs_lvm_remove_all (g);
17883 /* TestOutputListOfDevices for pvs (1) */
17885 char device[] = "/dev/sda";
17886 char lines_0[] = ",10";
17887 char lines_1[] = ",20";
17888 char lines_2[] = ",";
17896 suppress_error = 0;
17897 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17902 char device[] = "/dev/sda1";
17904 suppress_error = 0;
17905 r = guestfs_pvcreate (g, device);
17910 char device[] = "/dev/sda2";
17912 suppress_error = 0;
17913 r = guestfs_pvcreate (g, device);
17918 char device[] = "/dev/sda3";
17920 suppress_error = 0;
17921 r = guestfs_pvcreate (g, device);
17928 suppress_error = 0;
17929 r = guestfs_pvs (g);
17933 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17938 char expected[] = "/dev/sda1";
17940 if (strcmp (r[0], expected) != 0) {
17941 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17946 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17951 char expected[] = "/dev/sda2";
17953 if (strcmp (r[1], expected) != 0) {
17954 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17959 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17964 char expected[] = "/dev/sda3";
17966 if (strcmp (r[2], expected) != 0) {
17967 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17971 if (r[3] != NULL) {
17972 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17976 for (i = 0; r[i] != NULL; ++i)
17983 static int test_list_partitions_0_skip (void)
17987 str = getenv ("TEST_ONLY");
17989 return strstr (str, "list_partitions") == NULL;
17990 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17991 if (str && strcmp (str, "1") == 0) return 1;
17992 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17993 if (str && strcmp (str, "1") == 0) return 1;
17997 static int test_list_partitions_0 (void)
17999 if (test_list_partitions_0_skip ()) {
18000 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
18004 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
18006 char device[] = "/dev/sda";
18008 suppress_error = 0;
18009 r = guestfs_blockdev_setrw (g, device);
18015 suppress_error = 0;
18016 r = guestfs_umount_all (g);
18022 suppress_error = 0;
18023 r = guestfs_lvm_remove_all (g);
18028 char device[] = "/dev/sda";
18029 char lines_0[] = ",";
18035 suppress_error = 0;
18036 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18041 char fstype[] = "ext2";
18042 char device[] = "/dev/sda1";
18044 suppress_error = 0;
18045 r = guestfs_mkfs (g, fstype, device);
18050 char device[] = "/dev/sda1";
18051 char mountpoint[] = "/";
18053 suppress_error = 0;
18054 r = guestfs_mount (g, device, mountpoint);
18058 /* TestOutputListOfDevices for list_partitions (0) */
18062 suppress_error = 0;
18063 r = guestfs_list_partitions (g);
18067 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
18072 char expected[] = "/dev/sda1";
18074 if (strcmp (r[0], expected) != 0) {
18075 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18079 if (r[1] != NULL) {
18080 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
18084 for (i = 0; r[i] != NULL; ++i)
18091 static int test_list_partitions_1_skip (void)
18095 str = getenv ("TEST_ONLY");
18097 return strstr (str, "list_partitions") == NULL;
18098 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
18099 if (str && strcmp (str, "1") == 0) return 1;
18100 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
18101 if (str && strcmp (str, "1") == 0) return 1;
18105 static int test_list_partitions_1 (void)
18107 if (test_list_partitions_1_skip ()) {
18108 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
18112 /* InitNone|InitEmpty for test_list_partitions_1 */
18114 char device[] = "/dev/sda";
18116 suppress_error = 0;
18117 r = guestfs_blockdev_setrw (g, device);
18123 suppress_error = 0;
18124 r = guestfs_umount_all (g);
18130 suppress_error = 0;
18131 r = guestfs_lvm_remove_all (g);
18135 /* TestOutputListOfDevices for list_partitions (1) */
18137 char device[] = "/dev/sda";
18138 char lines_0[] = ",10";
18139 char lines_1[] = ",20";
18140 char lines_2[] = ",";
18148 suppress_error = 0;
18149 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18156 suppress_error = 0;
18157 r = guestfs_list_partitions (g);
18161 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18166 char expected[] = "/dev/sda1";
18168 if (strcmp (r[0], expected) != 0) {
18169 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18174 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18179 char expected[] = "/dev/sda2";
18181 if (strcmp (r[1], expected) != 0) {
18182 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18187 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
18192 char expected[] = "/dev/sda3";
18194 if (strcmp (r[2], expected) != 0) {
18195 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18199 if (r[3] != NULL) {
18200 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
18204 for (i = 0; r[i] != NULL; ++i)
18211 static int test_list_devices_0_skip (void)
18215 str = getenv ("TEST_ONLY");
18217 return strstr (str, "list_devices") == NULL;
18218 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18219 if (str && strcmp (str, "1") == 0) return 1;
18220 str = getenv ("SKIP_TEST_LIST_DEVICES");
18221 if (str && strcmp (str, "1") == 0) return 1;
18225 static int test_list_devices_0 (void)
18227 if (test_list_devices_0_skip ()) {
18228 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18232 /* InitNone|InitEmpty for test_list_devices_0 */
18234 char device[] = "/dev/sda";
18236 suppress_error = 0;
18237 r = guestfs_blockdev_setrw (g, device);
18243 suppress_error = 0;
18244 r = guestfs_umount_all (g);
18250 suppress_error = 0;
18251 r = guestfs_lvm_remove_all (g);
18255 /* TestOutputListOfDevices for list_devices (0) */
18259 suppress_error = 0;
18260 r = guestfs_list_devices (g);
18264 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18269 char expected[] = "/dev/sda";
18271 if (strcmp (r[0], expected) != 0) {
18272 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18277 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18282 char expected[] = "/dev/sdb";
18284 if (strcmp (r[1], expected) != 0) {
18285 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18290 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18295 char expected[] = "/dev/sdc";
18297 if (strcmp (r[2], expected) != 0) {
18298 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18303 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18308 char expected[] = "/dev/sdd";
18310 if (strcmp (r[3], expected) != 0) {
18311 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18315 if (r[4] != NULL) {
18316 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18320 for (i = 0; r[i] != NULL; ++i)
18327 static int test_ls_0_skip (void)
18331 str = getenv ("TEST_ONLY");
18333 return strstr (str, "ls") == NULL;
18334 str = getenv ("SKIP_TEST_LS_0");
18335 if (str && strcmp (str, "1") == 0) return 1;
18336 str = getenv ("SKIP_TEST_LS");
18337 if (str && strcmp (str, "1") == 0) return 1;
18341 static int test_ls_0 (void)
18343 if (test_ls_0_skip ()) {
18344 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18348 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18350 char device[] = "/dev/sda";
18352 suppress_error = 0;
18353 r = guestfs_blockdev_setrw (g, device);
18359 suppress_error = 0;
18360 r = guestfs_umount_all (g);
18366 suppress_error = 0;
18367 r = guestfs_lvm_remove_all (g);
18372 char device[] = "/dev/sda";
18373 char lines_0[] = ",";
18379 suppress_error = 0;
18380 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18385 char fstype[] = "ext2";
18386 char device[] = "/dev/sda1";
18388 suppress_error = 0;
18389 r = guestfs_mkfs (g, fstype, device);
18394 char device[] = "/dev/sda1";
18395 char mountpoint[] = "/";
18397 suppress_error = 0;
18398 r = guestfs_mount (g, device, mountpoint);
18402 /* TestOutputList for ls (0) */
18404 char path[] = "/new";
18406 suppress_error = 0;
18407 r = guestfs_touch (g, path);
18412 char path[] = "/newer";
18414 suppress_error = 0;
18415 r = guestfs_touch (g, path);
18420 char path[] = "/newest";
18422 suppress_error = 0;
18423 r = guestfs_touch (g, path);
18428 char directory[] = "/";
18431 suppress_error = 0;
18432 r = guestfs_ls (g, directory);
18436 fprintf (stderr, "test_ls_0: short list returned from command\n");
18441 char expected[] = "lost+found";
18442 if (strcmp (r[0], expected) != 0) {
18443 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18448 fprintf (stderr, "test_ls_0: short list returned from command\n");
18453 char expected[] = "new";
18454 if (strcmp (r[1], expected) != 0) {
18455 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18460 fprintf (stderr, "test_ls_0: short list returned from command\n");
18465 char expected[] = "newer";
18466 if (strcmp (r[2], expected) != 0) {
18467 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18472 fprintf (stderr, "test_ls_0: short list returned from command\n");
18477 char expected[] = "newest";
18478 if (strcmp (r[3], expected) != 0) {
18479 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18483 if (r[4] != NULL) {
18484 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18488 for (i = 0; r[i] != NULL; ++i)
18495 static int test_cat_0_skip (void)
18499 str = getenv ("TEST_ONLY");
18501 return strstr (str, "cat") == NULL;
18502 str = getenv ("SKIP_TEST_CAT_0");
18503 if (str && strcmp (str, "1") == 0) return 1;
18504 str = getenv ("SKIP_TEST_CAT");
18505 if (str && strcmp (str, "1") == 0) return 1;
18509 static int test_cat_0 (void)
18511 if (test_cat_0_skip ()) {
18512 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18516 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18518 char device[] = "/dev/sda";
18520 suppress_error = 0;
18521 r = guestfs_blockdev_setrw (g, device);
18527 suppress_error = 0;
18528 r = guestfs_umount_all (g);
18534 suppress_error = 0;
18535 r = guestfs_lvm_remove_all (g);
18540 char device[] = "/dev/sda";
18541 char lines_0[] = ",";
18547 suppress_error = 0;
18548 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18553 char fstype[] = "ext2";
18554 char device[] = "/dev/sda1";
18556 suppress_error = 0;
18557 r = guestfs_mkfs (g, fstype, device);
18562 char device[] = "/dev/sda1";
18563 char mountpoint[] = "/";
18565 suppress_error = 0;
18566 r = guestfs_mount (g, device, mountpoint);
18570 /* TestOutput for cat (0) */
18571 char expected[] = "new file contents";
18573 char path[] = "/new";
18574 char content[] = "new file contents";
18576 suppress_error = 0;
18577 r = guestfs_write_file (g, path, content, 0);
18582 char path[] = "/new";
18584 suppress_error = 0;
18585 r = guestfs_cat (g, path);
18588 if (strcmp (r, expected) != 0) {
18589 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18597 static int test_touch_0_skip (void)
18601 str = getenv ("TEST_ONLY");
18603 return strstr (str, "touch") == NULL;
18604 str = getenv ("SKIP_TEST_TOUCH_0");
18605 if (str && strcmp (str, "1") == 0) return 1;
18606 str = getenv ("SKIP_TEST_TOUCH");
18607 if (str && strcmp (str, "1") == 0) return 1;
18611 static int test_touch_0 (void)
18613 if (test_touch_0_skip ()) {
18614 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18618 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18620 char device[] = "/dev/sda";
18622 suppress_error = 0;
18623 r = guestfs_blockdev_setrw (g, device);
18629 suppress_error = 0;
18630 r = guestfs_umount_all (g);
18636 suppress_error = 0;
18637 r = guestfs_lvm_remove_all (g);
18642 char device[] = "/dev/sda";
18643 char lines_0[] = ",";
18649 suppress_error = 0;
18650 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18655 char fstype[] = "ext2";
18656 char device[] = "/dev/sda1";
18658 suppress_error = 0;
18659 r = guestfs_mkfs (g, fstype, device);
18664 char device[] = "/dev/sda1";
18665 char mountpoint[] = "/";
18667 suppress_error = 0;
18668 r = guestfs_mount (g, device, mountpoint);
18672 /* TestOutputTrue for touch (0) */
18674 char path[] = "/new";
18676 suppress_error = 0;
18677 r = guestfs_touch (g, path);
18682 char path[] = "/new";
18684 suppress_error = 0;
18685 r = guestfs_exists (g, path);
18689 fprintf (stderr, "test_touch_0: expected true, got false\n");
18696 static int test_sync_0_skip (void)
18700 str = getenv ("TEST_ONLY");
18702 return strstr (str, "sync") == NULL;
18703 str = getenv ("SKIP_TEST_SYNC_0");
18704 if (str && strcmp (str, "1") == 0) return 1;
18705 str = getenv ("SKIP_TEST_SYNC");
18706 if (str && strcmp (str, "1") == 0) return 1;
18710 static int test_sync_0 (void)
18712 if (test_sync_0_skip ()) {
18713 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18717 /* InitNone|InitEmpty for test_sync_0 */
18719 char device[] = "/dev/sda";
18721 suppress_error = 0;
18722 r = guestfs_blockdev_setrw (g, device);
18728 suppress_error = 0;
18729 r = guestfs_umount_all (g);
18735 suppress_error = 0;
18736 r = guestfs_lvm_remove_all (g);
18740 /* TestRun for sync (0) */
18743 suppress_error = 0;
18744 r = guestfs_sync (g);
18751 static int test_mount_0_skip (void)
18755 str = getenv ("TEST_ONLY");
18757 return strstr (str, "mount") == NULL;
18758 str = getenv ("SKIP_TEST_MOUNT_0");
18759 if (str && strcmp (str, "1") == 0) return 1;
18760 str = getenv ("SKIP_TEST_MOUNT");
18761 if (str && strcmp (str, "1") == 0) return 1;
18765 static int test_mount_0 (void)
18767 if (test_mount_0_skip ()) {
18768 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18772 /* InitNone|InitEmpty for test_mount_0 */
18774 char device[] = "/dev/sda";
18776 suppress_error = 0;
18777 r = guestfs_blockdev_setrw (g, device);
18783 suppress_error = 0;
18784 r = guestfs_umount_all (g);
18790 suppress_error = 0;
18791 r = guestfs_lvm_remove_all (g);
18795 /* TestOutput for mount (0) */
18796 char expected[] = "new file contents";
18798 char device[] = "/dev/sda";
18799 char lines_0[] = ",";
18805 suppress_error = 0;
18806 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18811 char fstype[] = "ext2";
18812 char device[] = "/dev/sda1";
18814 suppress_error = 0;
18815 r = guestfs_mkfs (g, fstype, device);
18820 char device[] = "/dev/sda1";
18821 char mountpoint[] = "/";
18823 suppress_error = 0;
18824 r = guestfs_mount (g, device, mountpoint);
18829 char path[] = "/new";
18830 char content[] = "new file contents";
18832 suppress_error = 0;
18833 r = guestfs_write_file (g, path, content, 0);
18838 char path[] = "/new";
18840 suppress_error = 0;
18841 r = guestfs_cat (g, path);
18844 if (strcmp (r, expected) != 0) {
18845 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18853 int main (int argc, char *argv[])
18857 const char *filename;
18859 int nr_tests, test_num = 0;
18861 no_test_warnings ();
18863 g = guestfs_create ();
18865 printf ("guestfs_create FAILED\n");
18869 guestfs_set_error_handler (g, print_error, NULL);
18871 guestfs_set_path (g, "../appliance");
18873 filename = "test1.img";
18874 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18879 if (lseek (fd, 524288000, SEEK_SET) == -1) {
18885 if (write (fd, &c, 1) == -1) {
18891 if (close (fd) == -1) {
18896 if (guestfs_add_drive (g, filename) == -1) {
18897 printf ("guestfs_add_drive %s FAILED\n", filename);
18901 filename = "test2.img";
18902 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18907 if (lseek (fd, 52428800, SEEK_SET) == -1) {
18913 if (write (fd, &c, 1) == -1) {
18919 if (close (fd) == -1) {
18924 if (guestfs_add_drive (g, filename) == -1) {
18925 printf ("guestfs_add_drive %s FAILED\n", filename);
18929 filename = "test3.img";
18930 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18935 if (lseek (fd, 10485760, SEEK_SET) == -1) {
18941 if (write (fd, &c, 1) == -1) {
18947 if (close (fd) == -1) {
18952 if (guestfs_add_drive (g, filename) == -1) {
18953 printf ("guestfs_add_drive %s FAILED\n", filename);
18957 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18958 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18962 if (guestfs_launch (g) == -1) {
18963 printf ("guestfs_launch FAILED\n");
18967 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18970 if (guestfs_wait_ready (g) == -1) {
18971 printf ("guestfs_wait_ready FAILED\n");
18975 /* Cancel previous alarm. */
18981 printf ("%3d/%3d test_mkswap_U_0\n", test_num, nr_tests);
18982 if (test_mkswap_U_0 () == -1) {
18983 printf ("test_mkswap_U_0 FAILED\n");
18987 printf ("%3d/%3d test_mkswap_L_0\n", test_num, nr_tests);
18988 if (test_mkswap_L_0 () == -1) {
18989 printf ("test_mkswap_L_0 FAILED\n");
18993 printf ("%3d/%3d test_mkswap_0\n", test_num, nr_tests);
18994 if (test_mkswap_0 () == -1) {
18995 printf ("test_mkswap_0 FAILED\n");
18999 printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
19000 if (test_initrd_list_0 () == -1) {
19001 printf ("test_initrd_list_0 FAILED\n");
19005 printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
19006 if (test_du_0 () == -1) {
19007 printf ("test_du_0 FAILED\n");
19011 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
19012 if (test_tail_n_0 () == -1) {
19013 printf ("test_tail_n_0 FAILED\n");
19017 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
19018 if (test_tail_n_1 () == -1) {
19019 printf ("test_tail_n_1 FAILED\n");
19023 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
19024 if (test_tail_n_2 () == -1) {
19025 printf ("test_tail_n_2 FAILED\n");
19029 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
19030 if (test_tail_0 () == -1) {
19031 printf ("test_tail_0 FAILED\n");
19035 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
19036 if (test_head_n_0 () == -1) {
19037 printf ("test_head_n_0 FAILED\n");
19041 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
19042 if (test_head_n_1 () == -1) {
19043 printf ("test_head_n_1 FAILED\n");
19047 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
19048 if (test_head_n_2 () == -1) {
19049 printf ("test_head_n_2 FAILED\n");
19053 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
19054 if (test_head_0 () == -1) {
19055 printf ("test_head_0 FAILED\n");
19059 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
19060 if (test_wc_c_0 () == -1) {
19061 printf ("test_wc_c_0 FAILED\n");
19065 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
19066 if (test_wc_w_0 () == -1) {
19067 printf ("test_wc_w_0 FAILED\n");
19071 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
19072 if (test_wc_l_0 () == -1) {
19073 printf ("test_wc_l_0 FAILED\n");
19077 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
19078 if (test_mkdtemp_0 () == -1) {
19079 printf ("test_mkdtemp_0 FAILED\n");
19083 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
19084 if (test_scrub_file_0 () == -1) {
19085 printf ("test_scrub_file_0 FAILED\n");
19089 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
19090 if (test_scrub_device_0 () == -1) {
19091 printf ("test_scrub_device_0 FAILED\n");
19095 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
19096 if (test_glob_expand_0 () == -1) {
19097 printf ("test_glob_expand_0 FAILED\n");
19101 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
19102 if (test_glob_expand_1 () == -1) {
19103 printf ("test_glob_expand_1 FAILED\n");
19107 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
19108 if (test_glob_expand_2 () == -1) {
19109 printf ("test_glob_expand_2 FAILED\n");
19113 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
19114 if (test_ntfs_3g_probe_0 () == -1) {
19115 printf ("test_ntfs_3g_probe_0 FAILED\n");
19119 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
19120 if (test_ntfs_3g_probe_1 () == -1) {
19121 printf ("test_ntfs_3g_probe_1 FAILED\n");
19125 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
19126 if (test_sleep_0 () == -1) {
19127 printf ("test_sleep_0 FAILED\n");
19131 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
19132 if (test_find_0 () == -1) {
19133 printf ("test_find_0 FAILED\n");
19137 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
19138 if (test_find_1 () == -1) {
19139 printf ("test_find_1 FAILED\n");
19143 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
19144 if (test_find_2 () == -1) {
19145 printf ("test_find_2 FAILED\n");
19149 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
19150 if (test_lvresize_0 () == -1) {
19151 printf ("test_lvresize_0 FAILED\n");
19155 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
19156 if (test_zerofree_0 () == -1) {
19157 printf ("test_zerofree_0 FAILED\n");
19161 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
19162 if (test_hexdump_0 () == -1) {
19163 printf ("test_hexdump_0 FAILED\n");
19167 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
19168 if (test_hexdump_1 () == -1) {
19169 printf ("test_hexdump_1 FAILED\n");
19173 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
19174 if (test_strings_e_0 () == -1) {
19175 printf ("test_strings_e_0 FAILED\n");
19179 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
19180 if (test_strings_e_1 () == -1) {
19181 printf ("test_strings_e_1 FAILED\n");
19185 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
19186 if (test_strings_0 () == -1) {
19187 printf ("test_strings_0 FAILED\n");
19191 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
19192 if (test_strings_1 () == -1) {
19193 printf ("test_strings_1 FAILED\n");
19197 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
19198 if (test_equal_0 () == -1) {
19199 printf ("test_equal_0 FAILED\n");
19203 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
19204 if (test_equal_1 () == -1) {
19205 printf ("test_equal_1 FAILED\n");
19209 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
19210 if (test_equal_2 () == -1) {
19211 printf ("test_equal_2 FAILED\n");
19215 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
19216 if (test_ping_daemon_0 () == -1) {
19217 printf ("test_ping_daemon_0 FAILED\n");
19221 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
19222 if (test_dmesg_0 () == -1) {
19223 printf ("test_dmesg_0 FAILED\n");
19227 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
19228 if (test_drop_caches_0 () == -1) {
19229 printf ("test_drop_caches_0 FAILED\n");
19233 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19234 if (test_mv_0 () == -1) {
19235 printf ("test_mv_0 FAILED\n");
19239 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19240 if (test_mv_1 () == -1) {
19241 printf ("test_mv_1 FAILED\n");
19245 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19246 if (test_cp_a_0 () == -1) {
19247 printf ("test_cp_a_0 FAILED\n");
19251 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19252 if (test_cp_0 () == -1) {
19253 printf ("test_cp_0 FAILED\n");
19257 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19258 if (test_cp_1 () == -1) {
19259 printf ("test_cp_1 FAILED\n");
19263 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19264 if (test_cp_2 () == -1) {
19265 printf ("test_cp_2 FAILED\n");
19269 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19270 if (test_grub_install_0 () == -1) {
19271 printf ("test_grub_install_0 FAILED\n");
19275 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19276 if (test_zero_0 () == -1) {
19277 printf ("test_zero_0 FAILED\n");
19281 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19282 if (test_fsck_0 () == -1) {
19283 printf ("test_fsck_0 FAILED\n");
19287 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19288 if (test_fsck_1 () == -1) {
19289 printf ("test_fsck_1 FAILED\n");
19293 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19294 if (test_set_e2uuid_0 () == -1) {
19295 printf ("test_set_e2uuid_0 FAILED\n");
19299 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19300 if (test_set_e2uuid_1 () == -1) {
19301 printf ("test_set_e2uuid_1 FAILED\n");
19305 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19306 if (test_set_e2uuid_2 () == -1) {
19307 printf ("test_set_e2uuid_2 FAILED\n");
19311 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19312 if (test_set_e2uuid_3 () == -1) {
19313 printf ("test_set_e2uuid_3 FAILED\n");
19317 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19318 if (test_set_e2label_0 () == -1) {
19319 printf ("test_set_e2label_0 FAILED\n");
19323 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19324 if (test_pvremove_0 () == -1) {
19325 printf ("test_pvremove_0 FAILED\n");
19329 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19330 if (test_pvremove_1 () == -1) {
19331 printf ("test_pvremove_1 FAILED\n");
19335 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19336 if (test_pvremove_2 () == -1) {
19337 printf ("test_pvremove_2 FAILED\n");
19341 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19342 if (test_vgremove_0 () == -1) {
19343 printf ("test_vgremove_0 FAILED\n");
19347 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19348 if (test_vgremove_1 () == -1) {
19349 printf ("test_vgremove_1 FAILED\n");
19353 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19354 if (test_lvremove_0 () == -1) {
19355 printf ("test_lvremove_0 FAILED\n");
19359 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19360 if (test_lvremove_1 () == -1) {
19361 printf ("test_lvremove_1 FAILED\n");
19365 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19366 if (test_lvremove_2 () == -1) {
19367 printf ("test_lvremove_2 FAILED\n");
19371 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19372 if (test_mount_ro_0 () == -1) {
19373 printf ("test_mount_ro_0 FAILED\n");
19377 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19378 if (test_mount_ro_1 () == -1) {
19379 printf ("test_mount_ro_1 FAILED\n");
19383 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19384 if (test_tgz_in_0 () == -1) {
19385 printf ("test_tgz_in_0 FAILED\n");
19389 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19390 if (test_tar_in_0 () == -1) {
19391 printf ("test_tar_in_0 FAILED\n");
19395 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19396 if (test_checksum_0 () == -1) {
19397 printf ("test_checksum_0 FAILED\n");
19401 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19402 if (test_checksum_1 () == -1) {
19403 printf ("test_checksum_1 FAILED\n");
19407 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19408 if (test_checksum_2 () == -1) {
19409 printf ("test_checksum_2 FAILED\n");
19413 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19414 if (test_checksum_3 () == -1) {
19415 printf ("test_checksum_3 FAILED\n");
19419 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19420 if (test_checksum_4 () == -1) {
19421 printf ("test_checksum_4 FAILED\n");
19425 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19426 if (test_checksum_5 () == -1) {
19427 printf ("test_checksum_5 FAILED\n");
19431 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19432 if (test_checksum_6 () == -1) {
19433 printf ("test_checksum_6 FAILED\n");
19437 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19438 if (test_checksum_7 () == -1) {
19439 printf ("test_checksum_7 FAILED\n");
19443 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19444 if (test_checksum_8 () == -1) {
19445 printf ("test_checksum_8 FAILED\n");
19449 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19450 if (test_download_0 () == -1) {
19451 printf ("test_download_0 FAILED\n");
19455 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19456 if (test_upload_0 () == -1) {
19457 printf ("test_upload_0 FAILED\n");
19461 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19462 if (test_blockdev_rereadpt_0 () == -1) {
19463 printf ("test_blockdev_rereadpt_0 FAILED\n");
19467 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19468 if (test_blockdev_flushbufs_0 () == -1) {
19469 printf ("test_blockdev_flushbufs_0 FAILED\n");
19473 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19474 if (test_blockdev_getsize64_0 () == -1) {
19475 printf ("test_blockdev_getsize64_0 FAILED\n");
19479 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19480 if (test_blockdev_getsz_0 () == -1) {
19481 printf ("test_blockdev_getsz_0 FAILED\n");
19485 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19486 if (test_blockdev_getbsz_0 () == -1) {
19487 printf ("test_blockdev_getbsz_0 FAILED\n");
19491 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19492 if (test_blockdev_getss_0 () == -1) {
19493 printf ("test_blockdev_getss_0 FAILED\n");
19497 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19498 if (test_blockdev_getro_0 () == -1) {
19499 printf ("test_blockdev_getro_0 FAILED\n");
19503 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19504 if (test_blockdev_setrw_0 () == -1) {
19505 printf ("test_blockdev_setrw_0 FAILED\n");
19509 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19510 if (test_blockdev_setro_0 () == -1) {
19511 printf ("test_blockdev_setro_0 FAILED\n");
19515 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19516 if (test_statvfs_0 () == -1) {
19517 printf ("test_statvfs_0 FAILED\n");
19521 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19522 if (test_lstat_0 () == -1) {
19523 printf ("test_lstat_0 FAILED\n");
19527 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19528 if (test_stat_0 () == -1) {
19529 printf ("test_stat_0 FAILED\n");
19533 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19534 if (test_command_lines_0 () == -1) {
19535 printf ("test_command_lines_0 FAILED\n");
19539 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19540 if (test_command_lines_1 () == -1) {
19541 printf ("test_command_lines_1 FAILED\n");
19545 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19546 if (test_command_lines_2 () == -1) {
19547 printf ("test_command_lines_2 FAILED\n");
19551 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19552 if (test_command_lines_3 () == -1) {
19553 printf ("test_command_lines_3 FAILED\n");
19557 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19558 if (test_command_lines_4 () == -1) {
19559 printf ("test_command_lines_4 FAILED\n");
19563 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19564 if (test_command_lines_5 () == -1) {
19565 printf ("test_command_lines_5 FAILED\n");
19569 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19570 if (test_command_lines_6 () == -1) {
19571 printf ("test_command_lines_6 FAILED\n");
19575 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19576 if (test_command_lines_7 () == -1) {
19577 printf ("test_command_lines_7 FAILED\n");
19581 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19582 if (test_command_lines_8 () == -1) {
19583 printf ("test_command_lines_8 FAILED\n");
19587 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19588 if (test_command_lines_9 () == -1) {
19589 printf ("test_command_lines_9 FAILED\n");
19593 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19594 if (test_command_lines_10 () == -1) {
19595 printf ("test_command_lines_10 FAILED\n");
19599 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19600 if (test_command_0 () == -1) {
19601 printf ("test_command_0 FAILED\n");
19605 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19606 if (test_command_1 () == -1) {
19607 printf ("test_command_1 FAILED\n");
19611 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19612 if (test_command_2 () == -1) {
19613 printf ("test_command_2 FAILED\n");
19617 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19618 if (test_command_3 () == -1) {
19619 printf ("test_command_3 FAILED\n");
19623 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19624 if (test_command_4 () == -1) {
19625 printf ("test_command_4 FAILED\n");
19629 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19630 if (test_command_5 () == -1) {
19631 printf ("test_command_5 FAILED\n");
19635 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19636 if (test_command_6 () == -1) {
19637 printf ("test_command_6 FAILED\n");
19641 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19642 if (test_command_7 () == -1) {
19643 printf ("test_command_7 FAILED\n");
19647 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19648 if (test_command_8 () == -1) {
19649 printf ("test_command_8 FAILED\n");
19653 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19654 if (test_command_9 () == -1) {
19655 printf ("test_command_9 FAILED\n");
19659 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19660 if (test_command_10 () == -1) {
19661 printf ("test_command_10 FAILED\n");
19665 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19666 if (test_command_11 () == -1) {
19667 printf ("test_command_11 FAILED\n");
19671 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19672 if (test_file_0 () == -1) {
19673 printf ("test_file_0 FAILED\n");
19677 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19678 if (test_file_1 () == -1) {
19679 printf ("test_file_1 FAILED\n");
19683 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19684 if (test_file_2 () == -1) {
19685 printf ("test_file_2 FAILED\n");
19689 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19690 if (test_umount_all_0 () == -1) {
19691 printf ("test_umount_all_0 FAILED\n");
19695 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19696 if (test_umount_all_1 () == -1) {
19697 printf ("test_umount_all_1 FAILED\n");
19701 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19702 if (test_mounts_0 () == -1) {
19703 printf ("test_mounts_0 FAILED\n");
19707 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19708 if (test_umount_0 () == -1) {
19709 printf ("test_umount_0 FAILED\n");
19713 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19714 if (test_umount_1 () == -1) {
19715 printf ("test_umount_1 FAILED\n");
19719 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19720 if (test_write_file_0 () == -1) {
19721 printf ("test_write_file_0 FAILED\n");
19725 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19726 if (test_write_file_1 () == -1) {
19727 printf ("test_write_file_1 FAILED\n");
19731 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19732 if (test_write_file_2 () == -1) {
19733 printf ("test_write_file_2 FAILED\n");
19737 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19738 if (test_write_file_3 () == -1) {
19739 printf ("test_write_file_3 FAILED\n");
19743 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19744 if (test_write_file_4 () == -1) {
19745 printf ("test_write_file_4 FAILED\n");
19749 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19750 if (test_write_file_5 () == -1) {
19751 printf ("test_write_file_5 FAILED\n");
19755 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19756 if (test_mkfs_0 () == -1) {
19757 printf ("test_mkfs_0 FAILED\n");
19761 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19762 if (test_lvcreate_0 () == -1) {
19763 printf ("test_lvcreate_0 FAILED\n");
19767 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19768 if (test_vgcreate_0 () == -1) {
19769 printf ("test_vgcreate_0 FAILED\n");
19773 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19774 if (test_pvcreate_0 () == -1) {
19775 printf ("test_pvcreate_0 FAILED\n");
19779 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19780 if (test_is_dir_0 () == -1) {
19781 printf ("test_is_dir_0 FAILED\n");
19785 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19786 if (test_is_dir_1 () == -1) {
19787 printf ("test_is_dir_1 FAILED\n");
19791 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19792 if (test_is_file_0 () == -1) {
19793 printf ("test_is_file_0 FAILED\n");
19797 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19798 if (test_is_file_1 () == -1) {
19799 printf ("test_is_file_1 FAILED\n");
19803 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19804 if (test_exists_0 () == -1) {
19805 printf ("test_exists_0 FAILED\n");
19809 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19810 if (test_exists_1 () == -1) {
19811 printf ("test_exists_1 FAILED\n");
19815 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19816 if (test_mkdir_p_0 () == -1) {
19817 printf ("test_mkdir_p_0 FAILED\n");
19821 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19822 if (test_mkdir_p_1 () == -1) {
19823 printf ("test_mkdir_p_1 FAILED\n");
19827 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19828 if (test_mkdir_p_2 () == -1) {
19829 printf ("test_mkdir_p_2 FAILED\n");
19833 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19834 if (test_mkdir_p_3 () == -1) {
19835 printf ("test_mkdir_p_3 FAILED\n");
19839 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19840 if (test_mkdir_p_4 () == -1) {
19841 printf ("test_mkdir_p_4 FAILED\n");
19845 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19846 if (test_mkdir_0 () == -1) {
19847 printf ("test_mkdir_0 FAILED\n");
19851 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19852 if (test_mkdir_1 () == -1) {
19853 printf ("test_mkdir_1 FAILED\n");
19857 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19858 if (test_rm_rf_0 () == -1) {
19859 printf ("test_rm_rf_0 FAILED\n");
19863 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19864 if (test_rmdir_0 () == -1) {
19865 printf ("test_rmdir_0 FAILED\n");
19869 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19870 if (test_rmdir_1 () == -1) {
19871 printf ("test_rmdir_1 FAILED\n");
19875 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19876 if (test_rmdir_2 () == -1) {
19877 printf ("test_rmdir_2 FAILED\n");
19881 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19882 if (test_rm_0 () == -1) {
19883 printf ("test_rm_0 FAILED\n");
19887 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19888 if (test_rm_1 () == -1) {
19889 printf ("test_rm_1 FAILED\n");
19893 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19894 if (test_rm_2 () == -1) {
19895 printf ("test_rm_2 FAILED\n");
19899 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19900 if (test_read_lines_0 () == -1) {
19901 printf ("test_read_lines_0 FAILED\n");
19905 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19906 if (test_read_lines_1 () == -1) {
19907 printf ("test_read_lines_1 FAILED\n");
19911 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19912 if (test_lvs_0 () == -1) {
19913 printf ("test_lvs_0 FAILED\n");
19917 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19918 if (test_lvs_1 () == -1) {
19919 printf ("test_lvs_1 FAILED\n");
19923 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19924 if (test_vgs_0 () == -1) {
19925 printf ("test_vgs_0 FAILED\n");
19929 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19930 if (test_vgs_1 () == -1) {
19931 printf ("test_vgs_1 FAILED\n");
19935 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19936 if (test_pvs_0 () == -1) {
19937 printf ("test_pvs_0 FAILED\n");
19941 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19942 if (test_pvs_1 () == -1) {
19943 printf ("test_pvs_1 FAILED\n");
19947 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19948 if (test_list_partitions_0 () == -1) {
19949 printf ("test_list_partitions_0 FAILED\n");
19953 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19954 if (test_list_partitions_1 () == -1) {
19955 printf ("test_list_partitions_1 FAILED\n");
19959 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19960 if (test_list_devices_0 () == -1) {
19961 printf ("test_list_devices_0 FAILED\n");
19965 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19966 if (test_ls_0 () == -1) {
19967 printf ("test_ls_0 FAILED\n");
19971 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19972 if (test_cat_0 () == -1) {
19973 printf ("test_cat_0 FAILED\n");
19977 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19978 if (test_touch_0 () == -1) {
19979 printf ("test_touch_0 FAILED\n");
19983 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19984 if (test_sync_0 () == -1) {
19985 printf ("test_sync_0 FAILED\n");
19989 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19990 if (test_mount_0 () == -1) {
19991 printf ("test_mount_0 FAILED\n");
19996 unlink ("test1.img");
19997 unlink ("test2.img");
19998 unlink ("test3.img");
20001 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);