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_ll\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
155 fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
156 fprintf (stderr, "warning: \"guestfs_mount_loop\" has no tests\n");
159 static int test_initrd_list_0_skip (void)
163 str = getenv ("TEST_ONLY");
165 return strstr (str, "initrd_list") == NULL;
166 str = getenv ("SKIP_TEST_INITRD_LIST_0");
167 if (str && strcmp (str, "1") == 0) return 1;
168 str = getenv ("SKIP_TEST_INITRD_LIST");
169 if (str && strcmp (str, "1") == 0) return 1;
173 static int test_initrd_list_0 (void)
175 if (test_initrd_list_0_skip ()) {
176 printf ("%s skipped (reason: environment variable set)\n", "test_initrd_list_0");
180 /* InitBasicFS for test_initrd_list_0: create ext2 on /dev/sda1 */
182 char device[] = "/dev/sda";
185 r = guestfs_blockdev_setrw (g, device);
192 r = guestfs_umount_all (g);
199 r = guestfs_lvm_remove_all (g);
204 char device[] = "/dev/sda";
205 char lines_0[] = ",";
212 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
217 char fstype[] = "ext2";
218 char device[] = "/dev/sda1";
221 r = guestfs_mkfs (g, fstype, device);
226 char device[] = "/dev/sda1";
227 char mountpoint[] = "/";
230 r = guestfs_mount (g, device, mountpoint);
234 /* TestOutputList for initrd_list (0) */
236 char options[] = "ro";
237 char vfstype[] = "squashfs";
238 char device[] = "/dev/sdd";
239 char mountpoint[] = "/";
242 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
247 char path[] = "/initrd";
251 r = guestfs_initrd_list (g, path);
255 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
260 char expected[] = "empty";
261 if (strcmp (r[0], expected) != 0) {
262 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
267 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
272 char expected[] = "known-1";
273 if (strcmp (r[1], expected) != 0) {
274 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
279 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
284 char expected[] = "known-2";
285 if (strcmp (r[2], expected) != 0) {
286 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
291 fprintf (stderr, "test_initrd_list_0: short list returned from command\n");
296 char expected[] = "known-3";
297 if (strcmp (r[3], expected) != 0) {
298 fprintf (stderr, "test_initrd_list_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
303 fprintf (stderr, "test_initrd_list_0: extra elements returned from command\n");
307 for (i = 0; r[i] != NULL; ++i)
314 static int test_du_0_skip (void)
318 str = getenv ("TEST_ONLY");
320 return strstr (str, "du") == NULL;
321 str = getenv ("SKIP_TEST_DU_0");
322 if (str && strcmp (str, "1") == 0) return 1;
323 str = getenv ("SKIP_TEST_DU");
324 if (str && strcmp (str, "1") == 0) return 1;
328 static int test_du_0 (void)
330 if (test_du_0_skip ()) {
331 printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
335 /* InitBasicFS for test_du_0: create ext2 on /dev/sda1 */
337 char device[] = "/dev/sda";
340 r = guestfs_blockdev_setrw (g, device);
347 r = guestfs_umount_all (g);
354 r = guestfs_lvm_remove_all (g);
359 char device[] = "/dev/sda";
360 char lines_0[] = ",";
367 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
372 char fstype[] = "ext2";
373 char device[] = "/dev/sda1";
376 r = guestfs_mkfs (g, fstype, device);
381 char device[] = "/dev/sda1";
382 char mountpoint[] = "/";
385 r = guestfs_mount (g, device, mountpoint);
389 /* TestOutputInt for du (0) */
394 r = guestfs_mkdir (g, path);
402 r = guestfs_du (g, path);
406 fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r);
413 static int test_tail_n_0_skip (void)
417 str = getenv ("TEST_ONLY");
419 return strstr (str, "tail_n") == NULL;
420 str = getenv ("SKIP_TEST_TAIL_N_0");
421 if (str && strcmp (str, "1") == 0) return 1;
422 str = getenv ("SKIP_TEST_TAIL_N");
423 if (str && strcmp (str, "1") == 0) return 1;
427 static int test_tail_n_0 (void)
429 if (test_tail_n_0_skip ()) {
430 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
434 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
436 char device[] = "/dev/sda";
439 r = guestfs_blockdev_setrw (g, device);
446 r = guestfs_umount_all (g);
453 r = guestfs_lvm_remove_all (g);
458 char device[] = "/dev/sda";
459 char lines_0[] = ",";
466 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
471 char fstype[] = "ext2";
472 char device[] = "/dev/sda1";
475 r = guestfs_mkfs (g, fstype, device);
480 char device[] = "/dev/sda1";
481 char mountpoint[] = "/";
484 r = guestfs_mount (g, device, mountpoint);
488 /* TestOutputList for tail_n (0) */
490 char options[] = "ro";
491 char vfstype[] = "squashfs";
492 char device[] = "/dev/sdd";
493 char mountpoint[] = "/";
496 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
501 char path[] = "/10klines";
505 r = guestfs_tail_n (g, 3, path);
509 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
514 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
515 if (strcmp (r[0], expected) != 0) {
516 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
521 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
526 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
527 if (strcmp (r[1], expected) != 0) {
528 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
533 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
538 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
539 if (strcmp (r[2], expected) != 0) {
540 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
545 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
549 for (i = 0; r[i] != NULL; ++i)
556 static int test_tail_n_1_skip (void)
560 str = getenv ("TEST_ONLY");
562 return strstr (str, "tail_n") == NULL;
563 str = getenv ("SKIP_TEST_TAIL_N_1");
564 if (str && strcmp (str, "1") == 0) return 1;
565 str = getenv ("SKIP_TEST_TAIL_N");
566 if (str && strcmp (str, "1") == 0) return 1;
570 static int test_tail_n_1 (void)
572 if (test_tail_n_1_skip ()) {
573 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
577 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
579 char device[] = "/dev/sda";
582 r = guestfs_blockdev_setrw (g, device);
589 r = guestfs_umount_all (g);
596 r = guestfs_lvm_remove_all (g);
601 char device[] = "/dev/sda";
602 char lines_0[] = ",";
609 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
614 char fstype[] = "ext2";
615 char device[] = "/dev/sda1";
618 r = guestfs_mkfs (g, fstype, device);
623 char device[] = "/dev/sda1";
624 char mountpoint[] = "/";
627 r = guestfs_mount (g, device, mountpoint);
631 /* TestOutputList for tail_n (1) */
633 char options[] = "ro";
634 char vfstype[] = "squashfs";
635 char device[] = "/dev/sdd";
636 char mountpoint[] = "/";
639 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
644 char path[] = "/10klines";
648 r = guestfs_tail_n (g, -9998, path);
652 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
657 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
658 if (strcmp (r[0], expected) != 0) {
659 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
664 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
669 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
670 if (strcmp (r[1], expected) != 0) {
671 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
676 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
681 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
682 if (strcmp (r[2], expected) != 0) {
683 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
688 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
692 for (i = 0; r[i] != NULL; ++i)
699 static int test_tail_n_2_skip (void)
703 str = getenv ("TEST_ONLY");
705 return strstr (str, "tail_n") == NULL;
706 str = getenv ("SKIP_TEST_TAIL_N_2");
707 if (str && strcmp (str, "1") == 0) return 1;
708 str = getenv ("SKIP_TEST_TAIL_N");
709 if (str && strcmp (str, "1") == 0) return 1;
713 static int test_tail_n_2 (void)
715 if (test_tail_n_2_skip ()) {
716 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
720 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
722 char device[] = "/dev/sda";
725 r = guestfs_blockdev_setrw (g, device);
732 r = guestfs_umount_all (g);
739 r = guestfs_lvm_remove_all (g);
744 char device[] = "/dev/sda";
745 char lines_0[] = ",";
752 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
757 char fstype[] = "ext2";
758 char device[] = "/dev/sda1";
761 r = guestfs_mkfs (g, fstype, device);
766 char device[] = "/dev/sda1";
767 char mountpoint[] = "/";
770 r = guestfs_mount (g, device, mountpoint);
774 /* TestOutputList for tail_n (2) */
776 char options[] = "ro";
777 char vfstype[] = "squashfs";
778 char device[] = "/dev/sdd";
779 char mountpoint[] = "/";
782 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
787 char path[] = "/10klines";
791 r = guestfs_tail_n (g, 0, path);
795 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
799 for (i = 0; r[i] != NULL; ++i)
806 static int test_tail_0_skip (void)
810 str = getenv ("TEST_ONLY");
812 return strstr (str, "tail") == NULL;
813 str = getenv ("SKIP_TEST_TAIL_0");
814 if (str && strcmp (str, "1") == 0) return 1;
815 str = getenv ("SKIP_TEST_TAIL");
816 if (str && strcmp (str, "1") == 0) return 1;
820 static int test_tail_0 (void)
822 if (test_tail_0_skip ()) {
823 printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
827 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
829 char device[] = "/dev/sda";
832 r = guestfs_blockdev_setrw (g, device);
839 r = guestfs_umount_all (g);
846 r = guestfs_lvm_remove_all (g);
851 char device[] = "/dev/sda";
852 char lines_0[] = ",";
859 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
864 char fstype[] = "ext2";
865 char device[] = "/dev/sda1";
868 r = guestfs_mkfs (g, fstype, device);
873 char device[] = "/dev/sda1";
874 char mountpoint[] = "/";
877 r = guestfs_mount (g, device, mountpoint);
881 /* TestOutputList for tail (0) */
883 char options[] = "ro";
884 char vfstype[] = "squashfs";
885 char device[] = "/dev/sdd";
886 char mountpoint[] = "/";
889 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
894 char path[] = "/10klines";
898 r = guestfs_tail (g, path);
902 fprintf (stderr, "test_tail_0: short list returned from command\n");
907 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
908 if (strcmp (r[0], expected) != 0) {
909 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
914 fprintf (stderr, "test_tail_0: short list returned from command\n");
919 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
920 if (strcmp (r[1], expected) != 0) {
921 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
926 fprintf (stderr, "test_tail_0: short list returned from command\n");
931 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
932 if (strcmp (r[2], expected) != 0) {
933 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
938 fprintf (stderr, "test_tail_0: short list returned from command\n");
943 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
944 if (strcmp (r[3], expected) != 0) {
945 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
950 fprintf (stderr, "test_tail_0: short list returned from command\n");
955 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
956 if (strcmp (r[4], expected) != 0) {
957 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
962 fprintf (stderr, "test_tail_0: short list returned from command\n");
967 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
968 if (strcmp (r[5], expected) != 0) {
969 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
974 fprintf (stderr, "test_tail_0: short list returned from command\n");
979 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
980 if (strcmp (r[6], expected) != 0) {
981 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
986 fprintf (stderr, "test_tail_0: short list returned from command\n");
991 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
992 if (strcmp (r[7], expected) != 0) {
993 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
998 fprintf (stderr, "test_tail_0: short list returned from command\n");
1003 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
1004 if (strcmp (r[8], expected) != 0) {
1005 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1010 fprintf (stderr, "test_tail_0: short list returned from command\n");
1015 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
1016 if (strcmp (r[9], expected) != 0) {
1017 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1021 if (r[10] != NULL) {
1022 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
1026 for (i = 0; r[i] != NULL; ++i)
1033 static int test_head_n_0_skip (void)
1037 str = getenv ("TEST_ONLY");
1039 return strstr (str, "head_n") == NULL;
1040 str = getenv ("SKIP_TEST_HEAD_N_0");
1041 if (str && strcmp (str, "1") == 0) return 1;
1042 str = getenv ("SKIP_TEST_HEAD_N");
1043 if (str && strcmp (str, "1") == 0) return 1;
1047 static int test_head_n_0 (void)
1049 if (test_head_n_0_skip ()) {
1050 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
1054 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
1056 char device[] = "/dev/sda";
1059 r = guestfs_blockdev_setrw (g, device);
1066 r = guestfs_umount_all (g);
1073 r = guestfs_lvm_remove_all (g);
1078 char device[] = "/dev/sda";
1079 char lines_0[] = ",";
1086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1091 char fstype[] = "ext2";
1092 char device[] = "/dev/sda1";
1095 r = guestfs_mkfs (g, fstype, device);
1100 char device[] = "/dev/sda1";
1101 char mountpoint[] = "/";
1104 r = guestfs_mount (g, device, mountpoint);
1108 /* TestOutputList for head_n (0) */
1110 char options[] = "ro";
1111 char vfstype[] = "squashfs";
1112 char device[] = "/dev/sdd";
1113 char mountpoint[] = "/";
1116 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1121 char path[] = "/10klines";
1125 r = guestfs_head_n (g, 3, path);
1129 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1134 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1135 if (strcmp (r[0], expected) != 0) {
1136 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1141 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1146 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1147 if (strcmp (r[1], expected) != 0) {
1148 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1153 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1158 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1159 if (strcmp (r[2], expected) != 0) {
1160 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1165 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1169 for (i = 0; r[i] != NULL; ++i)
1176 static int test_head_n_1_skip (void)
1180 str = getenv ("TEST_ONLY");
1182 return strstr (str, "head_n") == NULL;
1183 str = getenv ("SKIP_TEST_HEAD_N_1");
1184 if (str && strcmp (str, "1") == 0) return 1;
1185 str = getenv ("SKIP_TEST_HEAD_N");
1186 if (str && strcmp (str, "1") == 0) return 1;
1190 static int test_head_n_1 (void)
1192 if (test_head_n_1_skip ()) {
1193 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1197 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1199 char device[] = "/dev/sda";
1202 r = guestfs_blockdev_setrw (g, device);
1209 r = guestfs_umount_all (g);
1216 r = guestfs_lvm_remove_all (g);
1221 char device[] = "/dev/sda";
1222 char lines_0[] = ",";
1229 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1234 char fstype[] = "ext2";
1235 char device[] = "/dev/sda1";
1238 r = guestfs_mkfs (g, fstype, device);
1243 char device[] = "/dev/sda1";
1244 char mountpoint[] = "/";
1247 r = guestfs_mount (g, device, mountpoint);
1251 /* TestOutputList for head_n (1) */
1253 char options[] = "ro";
1254 char vfstype[] = "squashfs";
1255 char device[] = "/dev/sdd";
1256 char mountpoint[] = "/";
1259 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1264 char path[] = "/10klines";
1268 r = guestfs_head_n (g, -9997, path);
1272 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1277 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1278 if (strcmp (r[0], expected) != 0) {
1279 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1284 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1289 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1290 if (strcmp (r[1], expected) != 0) {
1291 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1296 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1301 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1302 if (strcmp (r[2], expected) != 0) {
1303 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1308 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1312 for (i = 0; r[i] != NULL; ++i)
1319 static int test_head_n_2_skip (void)
1323 str = getenv ("TEST_ONLY");
1325 return strstr (str, "head_n") == NULL;
1326 str = getenv ("SKIP_TEST_HEAD_N_2");
1327 if (str && strcmp (str, "1") == 0) return 1;
1328 str = getenv ("SKIP_TEST_HEAD_N");
1329 if (str && strcmp (str, "1") == 0) return 1;
1333 static int test_head_n_2 (void)
1335 if (test_head_n_2_skip ()) {
1336 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1340 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1342 char device[] = "/dev/sda";
1345 r = guestfs_blockdev_setrw (g, device);
1352 r = guestfs_umount_all (g);
1359 r = guestfs_lvm_remove_all (g);
1364 char device[] = "/dev/sda";
1365 char lines_0[] = ",";
1372 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1377 char fstype[] = "ext2";
1378 char device[] = "/dev/sda1";
1381 r = guestfs_mkfs (g, fstype, device);
1386 char device[] = "/dev/sda1";
1387 char mountpoint[] = "/";
1390 r = guestfs_mount (g, device, mountpoint);
1394 /* TestOutputList for head_n (2) */
1396 char options[] = "ro";
1397 char vfstype[] = "squashfs";
1398 char device[] = "/dev/sdd";
1399 char mountpoint[] = "/";
1402 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1407 char path[] = "/10klines";
1411 r = guestfs_head_n (g, 0, path);
1415 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1419 for (i = 0; r[i] != NULL; ++i)
1426 static int test_head_0_skip (void)
1430 str = getenv ("TEST_ONLY");
1432 return strstr (str, "head") == NULL;
1433 str = getenv ("SKIP_TEST_HEAD_0");
1434 if (str && strcmp (str, "1") == 0) return 1;
1435 str = getenv ("SKIP_TEST_HEAD");
1436 if (str && strcmp (str, "1") == 0) return 1;
1440 static int test_head_0 (void)
1442 if (test_head_0_skip ()) {
1443 printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1447 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1449 char device[] = "/dev/sda";
1452 r = guestfs_blockdev_setrw (g, device);
1459 r = guestfs_umount_all (g);
1466 r = guestfs_lvm_remove_all (g);
1471 char device[] = "/dev/sda";
1472 char lines_0[] = ",";
1479 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1484 char fstype[] = "ext2";
1485 char device[] = "/dev/sda1";
1488 r = guestfs_mkfs (g, fstype, device);
1493 char device[] = "/dev/sda1";
1494 char mountpoint[] = "/";
1497 r = guestfs_mount (g, device, mountpoint);
1501 /* TestOutputList for head (0) */
1503 char options[] = "ro";
1504 char vfstype[] = "squashfs";
1505 char device[] = "/dev/sdd";
1506 char mountpoint[] = "/";
1509 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1514 char path[] = "/10klines";
1518 r = guestfs_head (g, path);
1522 fprintf (stderr, "test_head_0: short list returned from command\n");
1527 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1528 if (strcmp (r[0], expected) != 0) {
1529 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1534 fprintf (stderr, "test_head_0: short list returned from command\n");
1539 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1540 if (strcmp (r[1], expected) != 0) {
1541 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1546 fprintf (stderr, "test_head_0: short list returned from command\n");
1551 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1552 if (strcmp (r[2], expected) != 0) {
1553 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1558 fprintf (stderr, "test_head_0: short list returned from command\n");
1563 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1564 if (strcmp (r[3], expected) != 0) {
1565 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1570 fprintf (stderr, "test_head_0: short list returned from command\n");
1575 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1576 if (strcmp (r[4], expected) != 0) {
1577 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1582 fprintf (stderr, "test_head_0: short list returned from command\n");
1587 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1588 if (strcmp (r[5], expected) != 0) {
1589 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1594 fprintf (stderr, "test_head_0: short list returned from command\n");
1599 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1600 if (strcmp (r[6], expected) != 0) {
1601 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1606 fprintf (stderr, "test_head_0: short list returned from command\n");
1611 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1612 if (strcmp (r[7], expected) != 0) {
1613 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1618 fprintf (stderr, "test_head_0: short list returned from command\n");
1623 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1624 if (strcmp (r[8], expected) != 0) {
1625 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1630 fprintf (stderr, "test_head_0: short list returned from command\n");
1635 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1636 if (strcmp (r[9], expected) != 0) {
1637 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1641 if (r[10] != NULL) {
1642 fprintf (stderr, "test_head_0: extra elements returned from command\n");
1646 for (i = 0; r[i] != NULL; ++i)
1653 static int test_wc_c_0_skip (void)
1657 str = getenv ("TEST_ONLY");
1659 return strstr (str, "wc_c") == NULL;
1660 str = getenv ("SKIP_TEST_WC_C_0");
1661 if (str && strcmp (str, "1") == 0) return 1;
1662 str = getenv ("SKIP_TEST_WC_C");
1663 if (str && strcmp (str, "1") == 0) return 1;
1667 static int test_wc_c_0 (void)
1669 if (test_wc_c_0_skip ()) {
1670 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1674 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1676 char device[] = "/dev/sda";
1679 r = guestfs_blockdev_setrw (g, device);
1686 r = guestfs_umount_all (g);
1693 r = guestfs_lvm_remove_all (g);
1698 char device[] = "/dev/sda";
1699 char lines_0[] = ",";
1706 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1711 char fstype[] = "ext2";
1712 char device[] = "/dev/sda1";
1715 r = guestfs_mkfs (g, fstype, device);
1720 char device[] = "/dev/sda1";
1721 char mountpoint[] = "/";
1724 r = guestfs_mount (g, device, mountpoint);
1728 /* TestOutputInt for wc_c (0) */
1730 char options[] = "ro";
1731 char vfstype[] = "squashfs";
1732 char device[] = "/dev/sdd";
1733 char mountpoint[] = "/";
1736 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1741 char path[] = "/100kallspaces";
1744 r = guestfs_wc_c (g, path);
1748 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
1755 static int test_wc_w_0_skip (void)
1759 str = getenv ("TEST_ONLY");
1761 return strstr (str, "wc_w") == NULL;
1762 str = getenv ("SKIP_TEST_WC_W_0");
1763 if (str && strcmp (str, "1") == 0) return 1;
1764 str = getenv ("SKIP_TEST_WC_W");
1765 if (str && strcmp (str, "1") == 0) return 1;
1769 static int test_wc_w_0 (void)
1771 if (test_wc_w_0_skip ()) {
1772 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1776 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1778 char device[] = "/dev/sda";
1781 r = guestfs_blockdev_setrw (g, device);
1788 r = guestfs_umount_all (g);
1795 r = guestfs_lvm_remove_all (g);
1800 char device[] = "/dev/sda";
1801 char lines_0[] = ",";
1808 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1813 char fstype[] = "ext2";
1814 char device[] = "/dev/sda1";
1817 r = guestfs_mkfs (g, fstype, device);
1822 char device[] = "/dev/sda1";
1823 char mountpoint[] = "/";
1826 r = guestfs_mount (g, device, mountpoint);
1830 /* TestOutputInt for wc_w (0) */
1832 char options[] = "ro";
1833 char vfstype[] = "squashfs";
1834 char device[] = "/dev/sdd";
1835 char mountpoint[] = "/";
1838 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1843 char path[] = "/10klines";
1846 r = guestfs_wc_w (g, path);
1850 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
1857 static int test_wc_l_0_skip (void)
1861 str = getenv ("TEST_ONLY");
1863 return strstr (str, "wc_l") == NULL;
1864 str = getenv ("SKIP_TEST_WC_L_0");
1865 if (str && strcmp (str, "1") == 0) return 1;
1866 str = getenv ("SKIP_TEST_WC_L");
1867 if (str && strcmp (str, "1") == 0) return 1;
1871 static int test_wc_l_0 (void)
1873 if (test_wc_l_0_skip ()) {
1874 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1878 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1880 char device[] = "/dev/sda";
1883 r = guestfs_blockdev_setrw (g, device);
1890 r = guestfs_umount_all (g);
1897 r = guestfs_lvm_remove_all (g);
1902 char device[] = "/dev/sda";
1903 char lines_0[] = ",";
1910 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1915 char fstype[] = "ext2";
1916 char device[] = "/dev/sda1";
1919 r = guestfs_mkfs (g, fstype, device);
1924 char device[] = "/dev/sda1";
1925 char mountpoint[] = "/";
1928 r = guestfs_mount (g, device, mountpoint);
1932 /* TestOutputInt for wc_l (0) */
1934 char options[] = "ro";
1935 char vfstype[] = "squashfs";
1936 char device[] = "/dev/sdd";
1937 char mountpoint[] = "/";
1940 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1945 char path[] = "/10klines";
1948 r = guestfs_wc_l (g, path);
1952 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
1959 static int test_mkdtemp_0_skip (void)
1963 str = getenv ("TEST_ONLY");
1965 return strstr (str, "mkdtemp") == NULL;
1966 str = getenv ("SKIP_TEST_MKDTEMP_0");
1967 if (str && strcmp (str, "1") == 0) return 1;
1968 str = getenv ("SKIP_TEST_MKDTEMP");
1969 if (str && strcmp (str, "1") == 0) return 1;
1973 static int test_mkdtemp_0 (void)
1975 if (test_mkdtemp_0_skip ()) {
1976 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1980 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1982 char device[] = "/dev/sda";
1985 r = guestfs_blockdev_setrw (g, device);
1992 r = guestfs_umount_all (g);
1999 r = guestfs_lvm_remove_all (g);
2004 char device[] = "/dev/sda";
2005 char lines_0[] = ",";
2012 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2017 char fstype[] = "ext2";
2018 char device[] = "/dev/sda1";
2021 r = guestfs_mkfs (g, fstype, device);
2026 char device[] = "/dev/sda1";
2027 char mountpoint[] = "/";
2030 r = guestfs_mount (g, device, mountpoint);
2034 /* TestRun for mkdtemp (0) */
2036 char path[] = "/tmp";
2039 r = guestfs_mkdir (g, path);
2044 char template[] = "/tmp/tmpXXXXXX";
2047 r = guestfs_mkdtemp (g, template);
2055 static int test_scrub_file_0_skip (void)
2059 str = getenv ("TEST_ONLY");
2061 return strstr (str, "scrub_file") == NULL;
2062 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
2063 if (str && strcmp (str, "1") == 0) return 1;
2064 str = getenv ("SKIP_TEST_SCRUB_FILE");
2065 if (str && strcmp (str, "1") == 0) return 1;
2069 static int test_scrub_file_0 (void)
2071 if (test_scrub_file_0_skip ()) {
2072 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
2076 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
2078 char device[] = "/dev/sda";
2081 r = guestfs_blockdev_setrw (g, device);
2088 r = guestfs_umount_all (g);
2095 r = guestfs_lvm_remove_all (g);
2100 char device[] = "/dev/sda";
2101 char lines_0[] = ",";
2108 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2113 char fstype[] = "ext2";
2114 char device[] = "/dev/sda1";
2117 r = guestfs_mkfs (g, fstype, device);
2122 char device[] = "/dev/sda1";
2123 char mountpoint[] = "/";
2126 r = guestfs_mount (g, device, mountpoint);
2130 /* TestRun for scrub_file (0) */
2132 char path[] = "/file";
2133 char content[] = "content";
2136 r = guestfs_write_file (g, path, content, 0);
2141 char file[] = "/file";
2144 r = guestfs_scrub_file (g, file);
2151 static int test_scrub_device_0_skip (void)
2155 str = getenv ("TEST_ONLY");
2157 return strstr (str, "scrub_device") == NULL;
2158 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2159 if (str && strcmp (str, "1") == 0) return 1;
2160 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2161 if (str && strcmp (str, "1") == 0) return 1;
2165 static int test_scrub_device_0 (void)
2167 if (test_scrub_device_0_skip ()) {
2168 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2172 /* InitNone|InitEmpty for test_scrub_device_0 */
2174 char device[] = "/dev/sda";
2177 r = guestfs_blockdev_setrw (g, device);
2184 r = guestfs_umount_all (g);
2191 r = guestfs_lvm_remove_all (g);
2195 /* TestRun for scrub_device (0) */
2197 char device[] = "/dev/sdc";
2200 r = guestfs_scrub_device (g, device);
2207 static int test_glob_expand_0_skip (void)
2211 str = getenv ("TEST_ONLY");
2213 return strstr (str, "glob_expand") == NULL;
2214 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2215 if (str && strcmp (str, "1") == 0) return 1;
2216 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2217 if (str && strcmp (str, "1") == 0) return 1;
2221 static int test_glob_expand_0 (void)
2223 if (test_glob_expand_0_skip ()) {
2224 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2228 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2230 char device[] = "/dev/sda";
2233 r = guestfs_blockdev_setrw (g, device);
2240 r = guestfs_umount_all (g);
2247 r = guestfs_lvm_remove_all (g);
2252 char device[] = "/dev/sda";
2253 char lines_0[] = ",";
2260 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2265 char fstype[] = "ext2";
2266 char device[] = "/dev/sda1";
2269 r = guestfs_mkfs (g, fstype, device);
2274 char device[] = "/dev/sda1";
2275 char mountpoint[] = "/";
2278 r = guestfs_mount (g, device, mountpoint);
2282 /* TestOutputList for glob_expand (0) */
2284 char path[] = "/a/b/c";
2287 r = guestfs_mkdir_p (g, path);
2292 char path[] = "/a/b/c/d";
2295 r = guestfs_touch (g, path);
2300 char path[] = "/a/b/c/e";
2303 r = guestfs_touch (g, path);
2308 char pattern[] = "/a/b/c/*";
2312 r = guestfs_glob_expand (g, pattern);
2316 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2321 char expected[] = "/a/b/c/d";
2322 if (strcmp (r[0], expected) != 0) {
2323 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2328 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2333 char expected[] = "/a/b/c/e";
2334 if (strcmp (r[1], expected) != 0) {
2335 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2340 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2344 for (i = 0; r[i] != NULL; ++i)
2351 static int test_glob_expand_1_skip (void)
2355 str = getenv ("TEST_ONLY");
2357 return strstr (str, "glob_expand") == NULL;
2358 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2359 if (str && strcmp (str, "1") == 0) return 1;
2360 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2361 if (str && strcmp (str, "1") == 0) return 1;
2365 static int test_glob_expand_1 (void)
2367 if (test_glob_expand_1_skip ()) {
2368 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2372 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2374 char device[] = "/dev/sda";
2377 r = guestfs_blockdev_setrw (g, device);
2384 r = guestfs_umount_all (g);
2391 r = guestfs_lvm_remove_all (g);
2396 char device[] = "/dev/sda";
2397 char lines_0[] = ",";
2404 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2409 char fstype[] = "ext2";
2410 char device[] = "/dev/sda1";
2413 r = guestfs_mkfs (g, fstype, device);
2418 char device[] = "/dev/sda1";
2419 char mountpoint[] = "/";
2422 r = guestfs_mount (g, device, mountpoint);
2426 /* TestOutputList for glob_expand (1) */
2428 char path[] = "/a/b/c";
2431 r = guestfs_mkdir_p (g, path);
2436 char path[] = "/a/b/c/d";
2439 r = guestfs_touch (g, path);
2444 char path[] = "/a/b/c/e";
2447 r = guestfs_touch (g, path);
2452 char pattern[] = "/a/*/c/*";
2456 r = guestfs_glob_expand (g, pattern);
2460 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2465 char expected[] = "/a/b/c/d";
2466 if (strcmp (r[0], expected) != 0) {
2467 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2472 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2477 char expected[] = "/a/b/c/e";
2478 if (strcmp (r[1], expected) != 0) {
2479 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2484 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2488 for (i = 0; r[i] != NULL; ++i)
2495 static int test_glob_expand_2_skip (void)
2499 str = getenv ("TEST_ONLY");
2501 return strstr (str, "glob_expand") == NULL;
2502 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2503 if (str && strcmp (str, "1") == 0) return 1;
2504 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2505 if (str && strcmp (str, "1") == 0) return 1;
2509 static int test_glob_expand_2 (void)
2511 if (test_glob_expand_2_skip ()) {
2512 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2516 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2518 char device[] = "/dev/sda";
2521 r = guestfs_blockdev_setrw (g, device);
2528 r = guestfs_umount_all (g);
2535 r = guestfs_lvm_remove_all (g);
2540 char device[] = "/dev/sda";
2541 char lines_0[] = ",";
2548 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2553 char fstype[] = "ext2";
2554 char device[] = "/dev/sda1";
2557 r = guestfs_mkfs (g, fstype, device);
2562 char device[] = "/dev/sda1";
2563 char mountpoint[] = "/";
2566 r = guestfs_mount (g, device, mountpoint);
2570 /* TestOutputList for glob_expand (2) */
2572 char path[] = "/a/b/c";
2575 r = guestfs_mkdir_p (g, path);
2580 char path[] = "/a/b/c/d";
2583 r = guestfs_touch (g, path);
2588 char path[] = "/a/b/c/e";
2591 r = guestfs_touch (g, path);
2596 char pattern[] = "/a/*/x/*";
2600 r = guestfs_glob_expand (g, pattern);
2604 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2608 for (i = 0; r[i] != NULL; ++i)
2615 static int test_ntfs_3g_probe_0_skip (void)
2619 str = getenv ("TEST_ONLY");
2621 return strstr (str, "ntfs_3g_probe") == NULL;
2622 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2623 if (str && strcmp (str, "1") == 0) return 1;
2624 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2625 if (str && strcmp (str, "1") == 0) return 1;
2629 static int test_ntfs_3g_probe_0 (void)
2631 if (test_ntfs_3g_probe_0_skip ()) {
2632 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2636 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2638 char device[] = "/dev/sda";
2641 r = guestfs_blockdev_setrw (g, device);
2648 r = guestfs_umount_all (g);
2655 r = guestfs_lvm_remove_all (g);
2659 /* TestOutputInt for ntfs_3g_probe (0) */
2661 char device[] = "/dev/sda";
2662 char lines_0[] = ",";
2669 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2674 char fstype[] = "ntfs";
2675 char device[] = "/dev/sda1";
2678 r = guestfs_mkfs (g, fstype, device);
2683 char device[] = "/dev/sda1";
2686 r = guestfs_ntfs_3g_probe (g, 1, device);
2690 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
2697 static int test_ntfs_3g_probe_1_skip (void)
2701 str = getenv ("TEST_ONLY");
2703 return strstr (str, "ntfs_3g_probe") == NULL;
2704 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2705 if (str && strcmp (str, "1") == 0) return 1;
2706 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2707 if (str && strcmp (str, "1") == 0) return 1;
2711 static int test_ntfs_3g_probe_1 (void)
2713 if (test_ntfs_3g_probe_1_skip ()) {
2714 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2718 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2720 char device[] = "/dev/sda";
2723 r = guestfs_blockdev_setrw (g, device);
2730 r = guestfs_umount_all (g);
2737 r = guestfs_lvm_remove_all (g);
2741 /* TestOutputInt for ntfs_3g_probe (1) */
2743 char device[] = "/dev/sda";
2744 char lines_0[] = ",";
2751 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2756 char fstype[] = "ext2";
2757 char device[] = "/dev/sda1";
2760 r = guestfs_mkfs (g, fstype, device);
2765 char device[] = "/dev/sda1";
2768 r = guestfs_ntfs_3g_probe (g, 1, device);
2772 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
2779 static int test_sleep_0_skip (void)
2783 str = getenv ("TEST_ONLY");
2785 return strstr (str, "sleep") == NULL;
2786 str = getenv ("SKIP_TEST_SLEEP_0");
2787 if (str && strcmp (str, "1") == 0) return 1;
2788 str = getenv ("SKIP_TEST_SLEEP");
2789 if (str && strcmp (str, "1") == 0) return 1;
2793 static int test_sleep_0 (void)
2795 if (test_sleep_0_skip ()) {
2796 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2800 /* InitNone|InitEmpty for test_sleep_0 */
2802 char device[] = "/dev/sda";
2805 r = guestfs_blockdev_setrw (g, device);
2812 r = guestfs_umount_all (g);
2819 r = guestfs_lvm_remove_all (g);
2823 /* TestRun for sleep (0) */
2827 r = guestfs_sleep (g, 1);
2834 static int test_find_0_skip (void)
2838 str = getenv ("TEST_ONLY");
2840 return strstr (str, "find") == NULL;
2841 str = getenv ("SKIP_TEST_FIND_0");
2842 if (str && strcmp (str, "1") == 0) return 1;
2843 str = getenv ("SKIP_TEST_FIND");
2844 if (str && strcmp (str, "1") == 0) return 1;
2848 static int test_find_0 (void)
2850 if (test_find_0_skip ()) {
2851 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2855 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2857 char device[] = "/dev/sda";
2860 r = guestfs_blockdev_setrw (g, device);
2867 r = guestfs_umount_all (g);
2874 r = guestfs_lvm_remove_all (g);
2879 char device[] = "/dev/sda";
2880 char lines_0[] = ",";
2887 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2892 char fstype[] = "ext2";
2893 char device[] = "/dev/sda1";
2896 r = guestfs_mkfs (g, fstype, device);
2901 char device[] = "/dev/sda1";
2902 char mountpoint[] = "/";
2905 r = guestfs_mount (g, device, mountpoint);
2909 /* TestOutputList for find (0) */
2911 char directory[] = "/";
2915 r = guestfs_find (g, directory);
2919 fprintf (stderr, "test_find_0: short list returned from command\n");
2924 char expected[] = "lost+found";
2925 if (strcmp (r[0], expected) != 0) {
2926 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2931 fprintf (stderr, "test_find_0: extra elements returned from command\n");
2935 for (i = 0; r[i] != NULL; ++i)
2942 static int test_find_1_skip (void)
2946 str = getenv ("TEST_ONLY");
2948 return strstr (str, "find") == NULL;
2949 str = getenv ("SKIP_TEST_FIND_1");
2950 if (str && strcmp (str, "1") == 0) return 1;
2951 str = getenv ("SKIP_TEST_FIND");
2952 if (str && strcmp (str, "1") == 0) return 1;
2956 static int test_find_1 (void)
2958 if (test_find_1_skip ()) {
2959 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2963 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2965 char device[] = "/dev/sda";
2968 r = guestfs_blockdev_setrw (g, device);
2975 r = guestfs_umount_all (g);
2982 r = guestfs_lvm_remove_all (g);
2987 char device[] = "/dev/sda";
2988 char lines_0[] = ",";
2995 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3000 char fstype[] = "ext2";
3001 char device[] = "/dev/sda1";
3004 r = guestfs_mkfs (g, fstype, device);
3009 char device[] = "/dev/sda1";
3010 char mountpoint[] = "/";
3013 r = guestfs_mount (g, device, mountpoint);
3017 /* TestOutputList for find (1) */
3022 r = guestfs_touch (g, path);
3030 r = guestfs_mkdir (g, path);
3035 char path[] = "/b/c";
3038 r = guestfs_touch (g, path);
3043 char directory[] = "/";
3047 r = guestfs_find (g, directory);
3051 fprintf (stderr, "test_find_1: short list returned from command\n");
3056 char expected[] = "a";
3057 if (strcmp (r[0], expected) != 0) {
3058 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3063 fprintf (stderr, "test_find_1: short list returned from command\n");
3068 char expected[] = "b";
3069 if (strcmp (r[1], expected) != 0) {
3070 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3075 fprintf (stderr, "test_find_1: short list returned from command\n");
3080 char expected[] = "b/c";
3081 if (strcmp (r[2], expected) != 0) {
3082 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
3087 fprintf (stderr, "test_find_1: short list returned from command\n");
3092 char expected[] = "lost+found";
3093 if (strcmp (r[3], expected) != 0) {
3094 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
3099 fprintf (stderr, "test_find_1: extra elements returned from command\n");
3103 for (i = 0; r[i] != NULL; ++i)
3110 static int test_find_2_skip (void)
3114 str = getenv ("TEST_ONLY");
3116 return strstr (str, "find") == NULL;
3117 str = getenv ("SKIP_TEST_FIND_2");
3118 if (str && strcmp (str, "1") == 0) return 1;
3119 str = getenv ("SKIP_TEST_FIND");
3120 if (str && strcmp (str, "1") == 0) return 1;
3124 static int test_find_2 (void)
3126 if (test_find_2_skip ()) {
3127 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
3131 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
3133 char device[] = "/dev/sda";
3136 r = guestfs_blockdev_setrw (g, device);
3143 r = guestfs_umount_all (g);
3150 r = guestfs_lvm_remove_all (g);
3155 char device[] = "/dev/sda";
3156 char lines_0[] = ",";
3163 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3168 char fstype[] = "ext2";
3169 char device[] = "/dev/sda1";
3172 r = guestfs_mkfs (g, fstype, device);
3177 char device[] = "/dev/sda1";
3178 char mountpoint[] = "/";
3181 r = guestfs_mount (g, device, mountpoint);
3185 /* TestOutputList for find (2) */
3187 char path[] = "/a/b/c";
3190 r = guestfs_mkdir_p (g, path);
3195 char path[] = "/a/b/c/d";
3198 r = guestfs_touch (g, path);
3203 char directory[] = "/a/b/";
3207 r = guestfs_find (g, directory);
3211 fprintf (stderr, "test_find_2: short list returned from command\n");
3216 char expected[] = "c";
3217 if (strcmp (r[0], expected) != 0) {
3218 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3223 fprintf (stderr, "test_find_2: short list returned from command\n");
3228 char expected[] = "c/d";
3229 if (strcmp (r[1], expected) != 0) {
3230 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3235 fprintf (stderr, "test_find_2: extra elements returned from command\n");
3239 for (i = 0; r[i] != NULL; ++i)
3246 static int test_lvresize_0_skip (void)
3250 str = getenv ("TEST_ONLY");
3252 return strstr (str, "lvresize") == NULL;
3253 str = getenv ("SKIP_TEST_LVRESIZE_0");
3254 if (str && strcmp (str, "1") == 0) return 1;
3255 str = getenv ("SKIP_TEST_LVRESIZE");
3256 if (str && strcmp (str, "1") == 0) return 1;
3260 static int test_lvresize_0 (void)
3262 if (test_lvresize_0_skip ()) {
3263 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3267 /* InitNone|InitEmpty for test_lvresize_0 */
3269 char device[] = "/dev/sda";
3272 r = guestfs_blockdev_setrw (g, device);
3279 r = guestfs_umount_all (g);
3286 r = guestfs_lvm_remove_all (g);
3290 /* TestOutput for lvresize (0) */
3291 char expected[] = "test content";
3293 char device[] = "/dev/sda";
3294 char lines_0[] = ",";
3301 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3306 char device[] = "/dev/sda1";
3309 r = guestfs_pvcreate (g, device);
3314 char volgroup[] = "VG";
3315 char physvols_0[] = "/dev/sda1";
3316 char *physvols[] = {
3322 r = guestfs_vgcreate (g, volgroup, physvols);
3327 char logvol[] = "LV";
3328 char volgroup[] = "VG";
3331 r = guestfs_lvcreate (g, logvol, volgroup, 10);
3336 char fstype[] = "ext2";
3337 char device[] = "/dev/VG/LV";
3340 r = guestfs_mkfs (g, fstype, device);
3345 char device[] = "/dev/VG/LV";
3346 char mountpoint[] = "/";
3349 r = guestfs_mount (g, device, mountpoint);
3354 char path[] = "/new";
3355 char content[] = "test content";
3358 r = guestfs_write_file (g, path, content, 0);
3363 char pathordevice[] = "/";
3366 r = guestfs_umount (g, pathordevice);
3371 char device[] = "/dev/VG/LV";
3374 r = guestfs_lvresize (g, device, 20);
3379 char device[] = "/dev/VG/LV";
3382 r = guestfs_e2fsck_f (g, device);
3387 char device[] = "/dev/VG/LV";
3390 r = guestfs_resize2fs (g, device);
3395 char device[] = "/dev/VG/LV";
3396 char mountpoint[] = "/";
3399 r = guestfs_mount (g, device, mountpoint);
3404 char path[] = "/new";
3407 r = guestfs_cat (g, path);
3410 if (strcmp (r, expected) != 0) {
3411 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3419 static int test_zerofree_0_skip (void)
3423 str = getenv ("TEST_ONLY");
3425 return strstr (str, "zerofree") == NULL;
3426 str = getenv ("SKIP_TEST_ZEROFREE_0");
3427 if (str && strcmp (str, "1") == 0) return 1;
3428 str = getenv ("SKIP_TEST_ZEROFREE");
3429 if (str && strcmp (str, "1") == 0) return 1;
3433 static int test_zerofree_0 (void)
3435 if (test_zerofree_0_skip ()) {
3436 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3440 /* InitNone|InitEmpty for test_zerofree_0 */
3442 char device[] = "/dev/sda";
3445 r = guestfs_blockdev_setrw (g, device);
3452 r = guestfs_umount_all (g);
3459 r = guestfs_lvm_remove_all (g);
3463 /* TestOutput for zerofree (0) */
3464 char expected[] = "test file";
3466 char device[] = "/dev/sda";
3467 char lines_0[] = ",";
3474 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3479 char fstype[] = "ext3";
3480 char device[] = "/dev/sda1";
3483 r = guestfs_mkfs (g, fstype, device);
3488 char device[] = "/dev/sda1";
3489 char mountpoint[] = "/";
3492 r = guestfs_mount (g, device, mountpoint);
3497 char path[] = "/new";
3498 char content[] = "test file";
3501 r = guestfs_write_file (g, path, content, 0);
3506 char pathordevice[] = "/dev/sda1";
3509 r = guestfs_umount (g, pathordevice);
3514 char device[] = "/dev/sda1";
3517 r = guestfs_zerofree (g, device);
3522 char device[] = "/dev/sda1";
3523 char mountpoint[] = "/";
3526 r = guestfs_mount (g, device, mountpoint);
3531 char path[] = "/new";
3534 r = guestfs_cat (g, path);
3537 if (strcmp (r, expected) != 0) {
3538 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3546 static int test_hexdump_0_skip (void)
3550 str = getenv ("TEST_ONLY");
3552 return strstr (str, "hexdump") == NULL;
3553 str = getenv ("SKIP_TEST_HEXDUMP_0");
3554 if (str && strcmp (str, "1") == 0) return 1;
3555 str = getenv ("SKIP_TEST_HEXDUMP");
3556 if (str && strcmp (str, "1") == 0) return 1;
3560 static int test_hexdump_0 (void)
3562 if (test_hexdump_0_skip ()) {
3563 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3567 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3569 char device[] = "/dev/sda";
3572 r = guestfs_blockdev_setrw (g, device);
3579 r = guestfs_umount_all (g);
3586 r = guestfs_lvm_remove_all (g);
3591 char device[] = "/dev/sda";
3592 char lines_0[] = ",";
3599 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3604 char fstype[] = "ext2";
3605 char device[] = "/dev/sda1";
3608 r = guestfs_mkfs (g, fstype, device);
3613 char device[] = "/dev/sda1";
3614 char mountpoint[] = "/";
3617 r = guestfs_mount (g, device, mountpoint);
3621 /* TestOutput for hexdump (0) */
3622 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
3624 char path[] = "/new";
3625 char content[] = "hello\nworld\n";
3628 r = guestfs_write_file (g, path, content, 12);
3633 char path[] = "/new";
3636 r = guestfs_hexdump (g, path);
3639 if (strcmp (r, expected) != 0) {
3640 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3648 static int test_hexdump_1_skip (void)
3652 str = getenv ("TEST_ONLY");
3654 return strstr (str, "hexdump") == NULL;
3655 str = getenv ("SKIP_TEST_HEXDUMP_1");
3656 if (str && strcmp (str, "1") == 0) return 1;
3657 str = getenv ("SKIP_TEST_HEXDUMP");
3658 if (str && strcmp (str, "1") == 0) return 1;
3662 static int test_hexdump_1 (void)
3664 if (test_hexdump_1_skip ()) {
3665 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3669 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3671 char device[] = "/dev/sda";
3674 r = guestfs_blockdev_setrw (g, device);
3681 r = guestfs_umount_all (g);
3688 r = guestfs_lvm_remove_all (g);
3693 char device[] = "/dev/sda";
3694 char lines_0[] = ",";
3701 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3706 char fstype[] = "ext2";
3707 char device[] = "/dev/sda1";
3710 r = guestfs_mkfs (g, fstype, device);
3715 char device[] = "/dev/sda1";
3716 char mountpoint[] = "/";
3719 r = guestfs_mount (g, device, mountpoint);
3723 /* TestRun for hexdump (1) */
3725 char options[] = "ro";
3726 char vfstype[] = "squashfs";
3727 char device[] = "/dev/sdd";
3728 char mountpoint[] = "/";
3731 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3736 char path[] = "/100krandom";
3739 r = guestfs_hexdump (g, path);
3747 static int test_strings_e_0_skip (void)
3751 str = getenv ("TEST_ONLY");
3753 return strstr (str, "strings_e") == NULL;
3754 str = getenv ("SKIP_TEST_STRINGS_E_0");
3755 if (str && strcmp (str, "1") == 0) return 1;
3756 str = getenv ("SKIP_TEST_STRINGS_E");
3757 if (str && strcmp (str, "1") == 0) return 1;
3761 static int test_strings_e_0 (void)
3763 if (test_strings_e_0_skip ()) {
3764 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3768 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3770 char device[] = "/dev/sda";
3773 r = guestfs_blockdev_setrw (g, device);
3780 r = guestfs_umount_all (g);
3787 r = guestfs_lvm_remove_all (g);
3792 char device[] = "/dev/sda";
3793 char lines_0[] = ",";
3800 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3805 char fstype[] = "ext2";
3806 char device[] = "/dev/sda1";
3809 r = guestfs_mkfs (g, fstype, device);
3814 char device[] = "/dev/sda1";
3815 char mountpoint[] = "/";
3818 r = guestfs_mount (g, device, mountpoint);
3822 /* TestOutputList for strings_e (0) */
3824 char path[] = "/new";
3825 char content[] = "hello\nworld\n";
3828 r = guestfs_write_file (g, path, content, 0);
3833 char encoding[] = "b";
3834 char path[] = "/new";
3838 r = guestfs_strings_e (g, encoding, path);
3842 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3846 for (i = 0; r[i] != NULL; ++i)
3853 static int test_strings_e_1_skip (void)
3857 str = getenv ("TEST_ONLY");
3859 return strstr (str, "strings_e") == NULL;
3860 str = getenv ("SKIP_TEST_STRINGS_E_1");
3861 if (str && strcmp (str, "1") == 0) return 1;
3862 str = getenv ("SKIP_TEST_STRINGS_E");
3863 if (str && strcmp (str, "1") == 0) return 1;
3867 static int test_strings_e_1 (void)
3869 if (test_strings_e_1_skip ()) {
3870 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3874 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3878 static int test_strings_0_skip (void)
3882 str = getenv ("TEST_ONLY");
3884 return strstr (str, "strings") == NULL;
3885 str = getenv ("SKIP_TEST_STRINGS_0");
3886 if (str && strcmp (str, "1") == 0) return 1;
3887 str = getenv ("SKIP_TEST_STRINGS");
3888 if (str && strcmp (str, "1") == 0) return 1;
3892 static int test_strings_0 (void)
3894 if (test_strings_0_skip ()) {
3895 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3899 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3901 char device[] = "/dev/sda";
3904 r = guestfs_blockdev_setrw (g, device);
3911 r = guestfs_umount_all (g);
3918 r = guestfs_lvm_remove_all (g);
3923 char device[] = "/dev/sda";
3924 char lines_0[] = ",";
3931 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3936 char fstype[] = "ext2";
3937 char device[] = "/dev/sda1";
3940 r = guestfs_mkfs (g, fstype, device);
3945 char device[] = "/dev/sda1";
3946 char mountpoint[] = "/";
3949 r = guestfs_mount (g, device, mountpoint);
3953 /* TestOutputList for strings (0) */
3955 char path[] = "/new";
3956 char content[] = "hello\nworld\n";
3959 r = guestfs_write_file (g, path, content, 0);
3964 char path[] = "/new";
3968 r = guestfs_strings (g, path);
3972 fprintf (stderr, "test_strings_0: short list returned from command\n");
3977 char expected[] = "hello";
3978 if (strcmp (r[0], expected) != 0) {
3979 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3984 fprintf (stderr, "test_strings_0: short list returned from command\n");
3989 char expected[] = "world";
3990 if (strcmp (r[1], expected) != 0) {
3991 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3996 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
4000 for (i = 0; r[i] != NULL; ++i)
4007 static int test_strings_1_skip (void)
4011 str = getenv ("TEST_ONLY");
4013 return strstr (str, "strings") == NULL;
4014 str = getenv ("SKIP_TEST_STRINGS_1");
4015 if (str && strcmp (str, "1") == 0) return 1;
4016 str = getenv ("SKIP_TEST_STRINGS");
4017 if (str && strcmp (str, "1") == 0) return 1;
4021 static int test_strings_1 (void)
4023 if (test_strings_1_skip ()) {
4024 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
4028 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
4030 char device[] = "/dev/sda";
4033 r = guestfs_blockdev_setrw (g, device);
4040 r = guestfs_umount_all (g);
4047 r = guestfs_lvm_remove_all (g);
4052 char device[] = "/dev/sda";
4053 char lines_0[] = ",";
4060 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4065 char fstype[] = "ext2";
4066 char device[] = "/dev/sda1";
4069 r = guestfs_mkfs (g, fstype, device);
4074 char device[] = "/dev/sda1";
4075 char mountpoint[] = "/";
4078 r = guestfs_mount (g, device, mountpoint);
4082 /* TestOutputList for strings (1) */
4084 char path[] = "/new";
4087 r = guestfs_touch (g, path);
4092 char path[] = "/new";
4096 r = guestfs_strings (g, path);
4100 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
4104 for (i = 0; r[i] != NULL; ++i)
4111 static int test_equal_0_skip (void)
4115 str = getenv ("TEST_ONLY");
4117 return strstr (str, "equal") == NULL;
4118 str = getenv ("SKIP_TEST_EQUAL_0");
4119 if (str && strcmp (str, "1") == 0) return 1;
4120 str = getenv ("SKIP_TEST_EQUAL");
4121 if (str && strcmp (str, "1") == 0) return 1;
4125 static int test_equal_0 (void)
4127 if (test_equal_0_skip ()) {
4128 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
4132 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
4134 char device[] = "/dev/sda";
4137 r = guestfs_blockdev_setrw (g, device);
4144 r = guestfs_umount_all (g);
4151 r = guestfs_lvm_remove_all (g);
4156 char device[] = "/dev/sda";
4157 char lines_0[] = ",";
4164 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4169 char fstype[] = "ext2";
4170 char device[] = "/dev/sda1";
4173 r = guestfs_mkfs (g, fstype, device);
4178 char device[] = "/dev/sda1";
4179 char mountpoint[] = "/";
4182 r = guestfs_mount (g, device, mountpoint);
4186 /* TestOutputTrue for equal (0) */
4188 char path[] = "/file1";
4189 char content[] = "contents of a file";
4192 r = guestfs_write_file (g, path, content, 0);
4197 char src[] = "/file1";
4198 char dest[] = "/file2";
4201 r = guestfs_cp (g, src, dest);
4206 char file1[] = "/file1";
4207 char file2[] = "/file2";
4210 r = guestfs_equal (g, file1, file2);
4214 fprintf (stderr, "test_equal_0: expected true, got false\n");
4221 static int test_equal_1_skip (void)
4225 str = getenv ("TEST_ONLY");
4227 return strstr (str, "equal") == NULL;
4228 str = getenv ("SKIP_TEST_EQUAL_1");
4229 if (str && strcmp (str, "1") == 0) return 1;
4230 str = getenv ("SKIP_TEST_EQUAL");
4231 if (str && strcmp (str, "1") == 0) return 1;
4235 static int test_equal_1 (void)
4237 if (test_equal_1_skip ()) {
4238 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4242 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4244 char device[] = "/dev/sda";
4247 r = guestfs_blockdev_setrw (g, device);
4254 r = guestfs_umount_all (g);
4261 r = guestfs_lvm_remove_all (g);
4266 char device[] = "/dev/sda";
4267 char lines_0[] = ",";
4274 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4279 char fstype[] = "ext2";
4280 char device[] = "/dev/sda1";
4283 r = guestfs_mkfs (g, fstype, device);
4288 char device[] = "/dev/sda1";
4289 char mountpoint[] = "/";
4292 r = guestfs_mount (g, device, mountpoint);
4296 /* TestOutputFalse for equal (1) */
4298 char path[] = "/file1";
4299 char content[] = "contents of a file";
4302 r = guestfs_write_file (g, path, content, 0);
4307 char path[] = "/file2";
4308 char content[] = "contents of another file";
4311 r = guestfs_write_file (g, path, content, 0);
4316 char file1[] = "/file1";
4317 char file2[] = "/file2";
4320 r = guestfs_equal (g, file1, file2);
4324 fprintf (stderr, "test_equal_1: expected false, got true\n");
4331 static int test_equal_2_skip (void)
4335 str = getenv ("TEST_ONLY");
4337 return strstr (str, "equal") == NULL;
4338 str = getenv ("SKIP_TEST_EQUAL_2");
4339 if (str && strcmp (str, "1") == 0) return 1;
4340 str = getenv ("SKIP_TEST_EQUAL");
4341 if (str && strcmp (str, "1") == 0) return 1;
4345 static int test_equal_2 (void)
4347 if (test_equal_2_skip ()) {
4348 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4352 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4354 char device[] = "/dev/sda";
4357 r = guestfs_blockdev_setrw (g, device);
4364 r = guestfs_umount_all (g);
4371 r = guestfs_lvm_remove_all (g);
4376 char device[] = "/dev/sda";
4377 char lines_0[] = ",";
4384 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4389 char fstype[] = "ext2";
4390 char device[] = "/dev/sda1";
4393 r = guestfs_mkfs (g, fstype, device);
4398 char device[] = "/dev/sda1";
4399 char mountpoint[] = "/";
4402 r = guestfs_mount (g, device, mountpoint);
4406 /* TestLastFail for equal (2) */
4408 char file1[] = "/file1";
4409 char file2[] = "/file2";
4412 r = guestfs_equal (g, file1, file2);
4419 static int test_ping_daemon_0_skip (void)
4423 str = getenv ("TEST_ONLY");
4425 return strstr (str, "ping_daemon") == NULL;
4426 str = getenv ("SKIP_TEST_PING_DAEMON_0");
4427 if (str && strcmp (str, "1") == 0) return 1;
4428 str = getenv ("SKIP_TEST_PING_DAEMON");
4429 if (str && strcmp (str, "1") == 0) return 1;
4433 static int test_ping_daemon_0 (void)
4435 if (test_ping_daemon_0_skip ()) {
4436 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4440 /* InitNone|InitEmpty for test_ping_daemon_0 */
4442 char device[] = "/dev/sda";
4445 r = guestfs_blockdev_setrw (g, device);
4452 r = guestfs_umount_all (g);
4459 r = guestfs_lvm_remove_all (g);
4463 /* TestRun for ping_daemon (0) */
4467 r = guestfs_ping_daemon (g);
4474 static int test_dmesg_0_skip (void)
4478 str = getenv ("TEST_ONLY");
4480 return strstr (str, "dmesg") == NULL;
4481 str = getenv ("SKIP_TEST_DMESG_0");
4482 if (str && strcmp (str, "1") == 0) return 1;
4483 str = getenv ("SKIP_TEST_DMESG");
4484 if (str && strcmp (str, "1") == 0) return 1;
4488 static int test_dmesg_0 (void)
4490 if (test_dmesg_0_skip ()) {
4491 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4495 /* InitNone|InitEmpty for test_dmesg_0 */
4497 char device[] = "/dev/sda";
4500 r = guestfs_blockdev_setrw (g, device);
4507 r = guestfs_umount_all (g);
4514 r = guestfs_lvm_remove_all (g);
4518 /* TestRun for dmesg (0) */
4522 r = guestfs_dmesg (g);
4530 static int test_drop_caches_0_skip (void)
4534 str = getenv ("TEST_ONLY");
4536 return strstr (str, "drop_caches") == NULL;
4537 str = getenv ("SKIP_TEST_DROP_CACHES_0");
4538 if (str && strcmp (str, "1") == 0) return 1;
4539 str = getenv ("SKIP_TEST_DROP_CACHES");
4540 if (str && strcmp (str, "1") == 0) return 1;
4544 static int test_drop_caches_0 (void)
4546 if (test_drop_caches_0_skip ()) {
4547 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4551 /* InitNone|InitEmpty for test_drop_caches_0 */
4553 char device[] = "/dev/sda";
4556 r = guestfs_blockdev_setrw (g, device);
4563 r = guestfs_umount_all (g);
4570 r = guestfs_lvm_remove_all (g);
4574 /* TestRun for drop_caches (0) */
4578 r = guestfs_drop_caches (g, 3);
4585 static int test_mv_0_skip (void)
4589 str = getenv ("TEST_ONLY");
4591 return strstr (str, "mv") == NULL;
4592 str = getenv ("SKIP_TEST_MV_0");
4593 if (str && strcmp (str, "1") == 0) return 1;
4594 str = getenv ("SKIP_TEST_MV");
4595 if (str && strcmp (str, "1") == 0) return 1;
4599 static int test_mv_0 (void)
4601 if (test_mv_0_skip ()) {
4602 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4606 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4608 char device[] = "/dev/sda";
4611 r = guestfs_blockdev_setrw (g, device);
4618 r = guestfs_umount_all (g);
4625 r = guestfs_lvm_remove_all (g);
4630 char device[] = "/dev/sda";
4631 char lines_0[] = ",";
4638 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4643 char fstype[] = "ext2";
4644 char device[] = "/dev/sda1";
4647 r = guestfs_mkfs (g, fstype, device);
4652 char device[] = "/dev/sda1";
4653 char mountpoint[] = "/";
4656 r = guestfs_mount (g, device, mountpoint);
4660 /* TestOutput for mv (0) */
4661 char expected[] = "file content";
4663 char path[] = "/old";
4664 char content[] = "file content";
4667 r = guestfs_write_file (g, path, content, 0);
4672 char src[] = "/old";
4673 char dest[] = "/new";
4676 r = guestfs_mv (g, src, dest);
4681 char path[] = "/new";
4684 r = guestfs_cat (g, path);
4687 if (strcmp (r, expected) != 0) {
4688 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4696 static int test_mv_1_skip (void)
4700 str = getenv ("TEST_ONLY");
4702 return strstr (str, "mv") == NULL;
4703 str = getenv ("SKIP_TEST_MV_1");
4704 if (str && strcmp (str, "1") == 0) return 1;
4705 str = getenv ("SKIP_TEST_MV");
4706 if (str && strcmp (str, "1") == 0) return 1;
4710 static int test_mv_1 (void)
4712 if (test_mv_1_skip ()) {
4713 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4717 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4719 char device[] = "/dev/sda";
4722 r = guestfs_blockdev_setrw (g, device);
4729 r = guestfs_umount_all (g);
4736 r = guestfs_lvm_remove_all (g);
4741 char device[] = "/dev/sda";
4742 char lines_0[] = ",";
4749 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4754 char fstype[] = "ext2";
4755 char device[] = "/dev/sda1";
4758 r = guestfs_mkfs (g, fstype, device);
4763 char device[] = "/dev/sda1";
4764 char mountpoint[] = "/";
4767 r = guestfs_mount (g, device, mountpoint);
4771 /* TestOutputFalse for mv (1) */
4773 char path[] = "/old";
4774 char content[] = "file content";
4777 r = guestfs_write_file (g, path, content, 0);
4782 char src[] = "/old";
4783 char dest[] = "/new";
4786 r = guestfs_mv (g, src, dest);
4791 char path[] = "/old";
4794 r = guestfs_is_file (g, path);
4798 fprintf (stderr, "test_mv_1: expected false, got true\n");
4805 static int test_cp_a_0_skip (void)
4809 str = getenv ("TEST_ONLY");
4811 return strstr (str, "cp_a") == NULL;
4812 str = getenv ("SKIP_TEST_CP_A_0");
4813 if (str && strcmp (str, "1") == 0) return 1;
4814 str = getenv ("SKIP_TEST_CP_A");
4815 if (str && strcmp (str, "1") == 0) return 1;
4819 static int test_cp_a_0 (void)
4821 if (test_cp_a_0_skip ()) {
4822 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4826 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4828 char device[] = "/dev/sda";
4831 r = guestfs_blockdev_setrw (g, device);
4838 r = guestfs_umount_all (g);
4845 r = guestfs_lvm_remove_all (g);
4850 char device[] = "/dev/sda";
4851 char lines_0[] = ",";
4858 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4863 char fstype[] = "ext2";
4864 char device[] = "/dev/sda1";
4867 r = guestfs_mkfs (g, fstype, device);
4872 char device[] = "/dev/sda1";
4873 char mountpoint[] = "/";
4876 r = guestfs_mount (g, device, mountpoint);
4880 /* TestOutput for cp_a (0) */
4881 char expected[] = "file content";
4883 char path[] = "/olddir";
4886 r = guestfs_mkdir (g, path);
4891 char path[] = "/newdir";
4894 r = guestfs_mkdir (g, path);
4899 char path[] = "/olddir/file";
4900 char content[] = "file content";
4903 r = guestfs_write_file (g, path, content, 0);
4908 char src[] = "/olddir";
4909 char dest[] = "/newdir";
4912 r = guestfs_cp_a (g, src, dest);
4917 char path[] = "/newdir/olddir/file";
4920 r = guestfs_cat (g, path);
4923 if (strcmp (r, expected) != 0) {
4924 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4932 static int test_cp_0_skip (void)
4936 str = getenv ("TEST_ONLY");
4938 return strstr (str, "cp") == NULL;
4939 str = getenv ("SKIP_TEST_CP_0");
4940 if (str && strcmp (str, "1") == 0) return 1;
4941 str = getenv ("SKIP_TEST_CP");
4942 if (str && strcmp (str, "1") == 0) return 1;
4946 static int test_cp_0 (void)
4948 if (test_cp_0_skip ()) {
4949 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4953 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4955 char device[] = "/dev/sda";
4958 r = guestfs_blockdev_setrw (g, device);
4965 r = guestfs_umount_all (g);
4972 r = guestfs_lvm_remove_all (g);
4977 char device[] = "/dev/sda";
4978 char lines_0[] = ",";
4985 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4990 char fstype[] = "ext2";
4991 char device[] = "/dev/sda1";
4994 r = guestfs_mkfs (g, fstype, device);
4999 char device[] = "/dev/sda1";
5000 char mountpoint[] = "/";
5003 r = guestfs_mount (g, device, mountpoint);
5007 /* TestOutput for cp (0) */
5008 char expected[] = "file content";
5010 char path[] = "/old";
5011 char content[] = "file content";
5014 r = guestfs_write_file (g, path, content, 0);
5019 char src[] = "/old";
5020 char dest[] = "/new";
5023 r = guestfs_cp (g, src, dest);
5028 char path[] = "/new";
5031 r = guestfs_cat (g, path);
5034 if (strcmp (r, expected) != 0) {
5035 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
5043 static int test_cp_1_skip (void)
5047 str = getenv ("TEST_ONLY");
5049 return strstr (str, "cp") == NULL;
5050 str = getenv ("SKIP_TEST_CP_1");
5051 if (str && strcmp (str, "1") == 0) return 1;
5052 str = getenv ("SKIP_TEST_CP");
5053 if (str && strcmp (str, "1") == 0) return 1;
5057 static int test_cp_1 (void)
5059 if (test_cp_1_skip ()) {
5060 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
5064 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
5066 char device[] = "/dev/sda";
5069 r = guestfs_blockdev_setrw (g, device);
5076 r = guestfs_umount_all (g);
5083 r = guestfs_lvm_remove_all (g);
5088 char device[] = "/dev/sda";
5089 char lines_0[] = ",";
5096 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5101 char fstype[] = "ext2";
5102 char device[] = "/dev/sda1";
5105 r = guestfs_mkfs (g, fstype, device);
5110 char device[] = "/dev/sda1";
5111 char mountpoint[] = "/";
5114 r = guestfs_mount (g, device, mountpoint);
5118 /* TestOutputTrue for cp (1) */
5120 char path[] = "/old";
5121 char content[] = "file content";
5124 r = guestfs_write_file (g, path, content, 0);
5129 char src[] = "/old";
5130 char dest[] = "/new";
5133 r = guestfs_cp (g, src, dest);
5138 char path[] = "/old";
5141 r = guestfs_is_file (g, path);
5145 fprintf (stderr, "test_cp_1: expected true, got false\n");
5152 static int test_cp_2_skip (void)
5156 str = getenv ("TEST_ONLY");
5158 return strstr (str, "cp") == NULL;
5159 str = getenv ("SKIP_TEST_CP_2");
5160 if (str && strcmp (str, "1") == 0) return 1;
5161 str = getenv ("SKIP_TEST_CP");
5162 if (str && strcmp (str, "1") == 0) return 1;
5166 static int test_cp_2 (void)
5168 if (test_cp_2_skip ()) {
5169 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5173 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5175 char device[] = "/dev/sda";
5178 r = guestfs_blockdev_setrw (g, device);
5185 r = guestfs_umount_all (g);
5192 r = guestfs_lvm_remove_all (g);
5197 char device[] = "/dev/sda";
5198 char lines_0[] = ",";
5205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5210 char fstype[] = "ext2";
5211 char device[] = "/dev/sda1";
5214 r = guestfs_mkfs (g, fstype, device);
5219 char device[] = "/dev/sda1";
5220 char mountpoint[] = "/";
5223 r = guestfs_mount (g, device, mountpoint);
5227 /* TestOutput for cp (2) */
5228 char expected[] = "file content";
5230 char path[] = "/old";
5231 char content[] = "file content";
5234 r = guestfs_write_file (g, path, content, 0);
5239 char path[] = "/dir";
5242 r = guestfs_mkdir (g, path);
5247 char src[] = "/old";
5248 char dest[] = "/dir/new";
5251 r = guestfs_cp (g, src, dest);
5256 char path[] = "/dir/new";
5259 r = guestfs_cat (g, path);
5262 if (strcmp (r, expected) != 0) {
5263 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5271 static int test_grub_install_0_skip (void)
5275 str = getenv ("TEST_ONLY");
5277 return strstr (str, "grub_install") == NULL;
5278 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5279 if (str && strcmp (str, "1") == 0) return 1;
5280 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5281 if (str && strcmp (str, "1") == 0) return 1;
5285 static int test_grub_install_0 (void)
5287 if (test_grub_install_0_skip ()) {
5288 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5292 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5294 char device[] = "/dev/sda";
5297 r = guestfs_blockdev_setrw (g, device);
5304 r = guestfs_umount_all (g);
5311 r = guestfs_lvm_remove_all (g);
5316 char device[] = "/dev/sda";
5317 char lines_0[] = ",";
5324 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5329 char fstype[] = "ext2";
5330 char device[] = "/dev/sda1";
5333 r = guestfs_mkfs (g, fstype, device);
5338 char device[] = "/dev/sda1";
5339 char mountpoint[] = "/";
5342 r = guestfs_mount (g, device, mountpoint);
5346 /* TestOutputTrue for grub_install (0) */
5349 char device[] = "/dev/sda1";
5352 r = guestfs_grub_install (g, root, device);
5357 char path[] = "/boot";
5360 r = guestfs_is_dir (g, path);
5364 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5371 static int test_zero_0_skip (void)
5375 str = getenv ("TEST_ONLY");
5377 return strstr (str, "zero") == NULL;
5378 str = getenv ("SKIP_TEST_ZERO_0");
5379 if (str && strcmp (str, "1") == 0) return 1;
5380 str = getenv ("SKIP_TEST_ZERO");
5381 if (str && strcmp (str, "1") == 0) return 1;
5385 static int test_zero_0 (void)
5387 if (test_zero_0_skip ()) {
5388 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5392 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5394 char device[] = "/dev/sda";
5397 r = guestfs_blockdev_setrw (g, device);
5404 r = guestfs_umount_all (g);
5411 r = guestfs_lvm_remove_all (g);
5416 char device[] = "/dev/sda";
5417 char lines_0[] = ",";
5424 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5429 char fstype[] = "ext2";
5430 char device[] = "/dev/sda1";
5433 r = guestfs_mkfs (g, fstype, device);
5438 char device[] = "/dev/sda1";
5439 char mountpoint[] = "/";
5442 r = guestfs_mount (g, device, mountpoint);
5446 /* TestOutput for zero (0) */
5447 char expected[] = "data";
5449 char pathordevice[] = "/dev/sda1";
5452 r = guestfs_umount (g, pathordevice);
5457 char device[] = "/dev/sda1";
5460 r = guestfs_zero (g, device);
5465 char path[] = "/dev/sda1";
5468 r = guestfs_file (g, path);
5471 if (strcmp (r, expected) != 0) {
5472 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5480 static int test_fsck_0_skip (void)
5484 str = getenv ("TEST_ONLY");
5486 return strstr (str, "fsck") == NULL;
5487 str = getenv ("SKIP_TEST_FSCK_0");
5488 if (str && strcmp (str, "1") == 0) return 1;
5489 str = getenv ("SKIP_TEST_FSCK");
5490 if (str && strcmp (str, "1") == 0) return 1;
5494 static int test_fsck_0 (void)
5496 if (test_fsck_0_skip ()) {
5497 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5501 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5503 char device[] = "/dev/sda";
5506 r = guestfs_blockdev_setrw (g, device);
5513 r = guestfs_umount_all (g);
5520 r = guestfs_lvm_remove_all (g);
5525 char device[] = "/dev/sda";
5526 char lines_0[] = ",";
5533 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5538 char fstype[] = "ext2";
5539 char device[] = "/dev/sda1";
5542 r = guestfs_mkfs (g, fstype, device);
5547 char device[] = "/dev/sda1";
5548 char mountpoint[] = "/";
5551 r = guestfs_mount (g, device, mountpoint);
5555 /* TestOutputInt for fsck (0) */
5557 char pathordevice[] = "/dev/sda1";
5560 r = guestfs_umount (g, pathordevice);
5565 char fstype[] = "ext2";
5566 char device[] = "/dev/sda1";
5569 r = guestfs_fsck (g, fstype, device);
5573 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
5580 static int test_fsck_1_skip (void)
5584 str = getenv ("TEST_ONLY");
5586 return strstr (str, "fsck") == NULL;
5587 str = getenv ("SKIP_TEST_FSCK_1");
5588 if (str && strcmp (str, "1") == 0) return 1;
5589 str = getenv ("SKIP_TEST_FSCK");
5590 if (str && strcmp (str, "1") == 0) return 1;
5594 static int test_fsck_1 (void)
5596 if (test_fsck_1_skip ()) {
5597 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5601 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5603 char device[] = "/dev/sda";
5606 r = guestfs_blockdev_setrw (g, device);
5613 r = guestfs_umount_all (g);
5620 r = guestfs_lvm_remove_all (g);
5625 char device[] = "/dev/sda";
5626 char lines_0[] = ",";
5633 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5638 char fstype[] = "ext2";
5639 char device[] = "/dev/sda1";
5642 r = guestfs_mkfs (g, fstype, device);
5647 char device[] = "/dev/sda1";
5648 char mountpoint[] = "/";
5651 r = guestfs_mount (g, device, mountpoint);
5655 /* TestOutputInt for fsck (1) */
5657 char pathordevice[] = "/dev/sda1";
5660 r = guestfs_umount (g, pathordevice);
5665 char device[] = "/dev/sda1";
5668 r = guestfs_zero (g, device);
5673 char fstype[] = "ext2";
5674 char device[] = "/dev/sda1";
5677 r = guestfs_fsck (g, fstype, device);
5681 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
5688 static int test_set_e2uuid_0_skip (void)
5692 str = getenv ("TEST_ONLY");
5694 return strstr (str, "set_e2uuid") == NULL;
5695 str = getenv ("SKIP_TEST_SET_E2UUID_0");
5696 if (str && strcmp (str, "1") == 0) return 1;
5697 str = getenv ("SKIP_TEST_SET_E2UUID");
5698 if (str && strcmp (str, "1") == 0) return 1;
5702 static int test_set_e2uuid_0 (void)
5704 if (test_set_e2uuid_0_skip ()) {
5705 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5709 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5711 char device[] = "/dev/sda";
5714 r = guestfs_blockdev_setrw (g, device);
5721 r = guestfs_umount_all (g);
5728 r = guestfs_lvm_remove_all (g);
5733 char device[] = "/dev/sda";
5734 char lines_0[] = ",";
5741 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5746 char fstype[] = "ext2";
5747 char device[] = "/dev/sda1";
5750 r = guestfs_mkfs (g, fstype, device);
5755 char device[] = "/dev/sda1";
5756 char mountpoint[] = "/";
5759 r = guestfs_mount (g, device, mountpoint);
5763 /* TestOutput for set_e2uuid (0) */
5764 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5766 char device[] = "/dev/sda1";
5767 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5770 r = guestfs_set_e2uuid (g, device, uuid);
5775 char device[] = "/dev/sda1";
5778 r = guestfs_get_e2uuid (g, device);
5781 if (strcmp (r, expected) != 0) {
5782 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5790 static int test_set_e2uuid_1_skip (void)
5794 str = getenv ("TEST_ONLY");
5796 return strstr (str, "set_e2uuid") == NULL;
5797 str = getenv ("SKIP_TEST_SET_E2UUID_1");
5798 if (str && strcmp (str, "1") == 0) return 1;
5799 str = getenv ("SKIP_TEST_SET_E2UUID");
5800 if (str && strcmp (str, "1") == 0) return 1;
5804 static int test_set_e2uuid_1 (void)
5806 if (test_set_e2uuid_1_skip ()) {
5807 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5811 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
5813 char device[] = "/dev/sda";
5816 r = guestfs_blockdev_setrw (g, device);
5823 r = guestfs_umount_all (g);
5830 r = guestfs_lvm_remove_all (g);
5835 char device[] = "/dev/sda";
5836 char lines_0[] = ",";
5843 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5848 char fstype[] = "ext2";
5849 char device[] = "/dev/sda1";
5852 r = guestfs_mkfs (g, fstype, device);
5857 char device[] = "/dev/sda1";
5858 char mountpoint[] = "/";
5861 r = guestfs_mount (g, device, mountpoint);
5865 /* TestOutput for set_e2uuid (1) */
5866 char expected[] = "";
5868 char device[] = "/dev/sda1";
5869 char uuid[] = "clear";
5872 r = guestfs_set_e2uuid (g, device, uuid);
5877 char device[] = "/dev/sda1";
5880 r = guestfs_get_e2uuid (g, device);
5883 if (strcmp (r, expected) != 0) {
5884 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5892 static int test_set_e2uuid_2_skip (void)
5896 str = getenv ("TEST_ONLY");
5898 return strstr (str, "set_e2uuid") == NULL;
5899 str = getenv ("SKIP_TEST_SET_E2UUID_2");
5900 if (str && strcmp (str, "1") == 0) return 1;
5901 str = getenv ("SKIP_TEST_SET_E2UUID");
5902 if (str && strcmp (str, "1") == 0) return 1;
5906 static int test_set_e2uuid_2 (void)
5908 if (test_set_e2uuid_2_skip ()) {
5909 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5913 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5915 char device[] = "/dev/sda";
5918 r = guestfs_blockdev_setrw (g, device);
5925 r = guestfs_umount_all (g);
5932 r = guestfs_lvm_remove_all (g);
5937 char device[] = "/dev/sda";
5938 char lines_0[] = ",";
5945 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5950 char fstype[] = "ext2";
5951 char device[] = "/dev/sda1";
5954 r = guestfs_mkfs (g, fstype, device);
5959 char device[] = "/dev/sda1";
5960 char mountpoint[] = "/";
5963 r = guestfs_mount (g, device, mountpoint);
5967 /* TestRun for set_e2uuid (2) */
5969 char device[] = "/dev/sda1";
5970 char uuid[] = "random";
5973 r = guestfs_set_e2uuid (g, device, uuid);
5980 static int test_set_e2uuid_3_skip (void)
5984 str = getenv ("TEST_ONLY");
5986 return strstr (str, "set_e2uuid") == NULL;
5987 str = getenv ("SKIP_TEST_SET_E2UUID_3");
5988 if (str && strcmp (str, "1") == 0) return 1;
5989 str = getenv ("SKIP_TEST_SET_E2UUID");
5990 if (str && strcmp (str, "1") == 0) return 1;
5994 static int test_set_e2uuid_3 (void)
5996 if (test_set_e2uuid_3_skip ()) {
5997 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
6001 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
6003 char device[] = "/dev/sda";
6006 r = guestfs_blockdev_setrw (g, device);
6013 r = guestfs_umount_all (g);
6020 r = guestfs_lvm_remove_all (g);
6025 char device[] = "/dev/sda";
6026 char lines_0[] = ",";
6033 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6038 char fstype[] = "ext2";
6039 char device[] = "/dev/sda1";
6042 r = guestfs_mkfs (g, fstype, device);
6047 char device[] = "/dev/sda1";
6048 char mountpoint[] = "/";
6051 r = guestfs_mount (g, device, mountpoint);
6055 /* TestRun for set_e2uuid (3) */
6057 char device[] = "/dev/sda1";
6058 char uuid[] = "time";
6061 r = guestfs_set_e2uuid (g, device, uuid);
6068 static int test_set_e2label_0_skip (void)
6072 str = getenv ("TEST_ONLY");
6074 return strstr (str, "set_e2label") == NULL;
6075 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
6076 if (str && strcmp (str, "1") == 0) return 1;
6077 str = getenv ("SKIP_TEST_SET_E2LABEL");
6078 if (str && strcmp (str, "1") == 0) return 1;
6082 static int test_set_e2label_0 (void)
6084 if (test_set_e2label_0_skip ()) {
6085 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
6089 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
6091 char device[] = "/dev/sda";
6094 r = guestfs_blockdev_setrw (g, device);
6101 r = guestfs_umount_all (g);
6108 r = guestfs_lvm_remove_all (g);
6113 char device[] = "/dev/sda";
6114 char lines_0[] = ",";
6121 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6126 char fstype[] = "ext2";
6127 char device[] = "/dev/sda1";
6130 r = guestfs_mkfs (g, fstype, device);
6135 char device[] = "/dev/sda1";
6136 char mountpoint[] = "/";
6139 r = guestfs_mount (g, device, mountpoint);
6143 /* TestOutput for set_e2label (0) */
6144 char expected[] = "testlabel";
6146 char device[] = "/dev/sda1";
6147 char label[] = "testlabel";
6150 r = guestfs_set_e2label (g, device, label);
6155 char device[] = "/dev/sda1";
6158 r = guestfs_get_e2label (g, device);
6161 if (strcmp (r, expected) != 0) {
6162 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6170 static int test_pvremove_0_skip (void)
6174 str = getenv ("TEST_ONLY");
6176 return strstr (str, "pvremove") == NULL;
6177 str = getenv ("SKIP_TEST_PVREMOVE_0");
6178 if (str && strcmp (str, "1") == 0) return 1;
6179 str = getenv ("SKIP_TEST_PVREMOVE");
6180 if (str && strcmp (str, "1") == 0) return 1;
6184 static int test_pvremove_0 (void)
6186 if (test_pvremove_0_skip ()) {
6187 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6191 /* InitNone|InitEmpty for test_pvremove_0 */
6193 char device[] = "/dev/sda";
6196 r = guestfs_blockdev_setrw (g, device);
6203 r = guestfs_umount_all (g);
6210 r = guestfs_lvm_remove_all (g);
6214 /* TestOutputListOfDevices for pvremove (0) */
6216 char device[] = "/dev/sda";
6217 char lines_0[] = ",";
6224 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6229 char device[] = "/dev/sda1";
6232 r = guestfs_pvcreate (g, device);
6237 char volgroup[] = "VG";
6238 char physvols_0[] = "/dev/sda1";
6239 char *physvols[] = {
6245 r = guestfs_vgcreate (g, volgroup, physvols);
6250 char logvol[] = "LV1";
6251 char volgroup[] = "VG";
6254 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6259 char logvol[] = "LV2";
6260 char volgroup[] = "VG";
6263 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6268 char vgname[] = "VG";
6271 r = guestfs_vgremove (g, vgname);
6276 char device[] = "/dev/sda1";
6279 r = guestfs_pvremove (g, device);
6287 r = guestfs_lvs (g);
6291 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6295 for (i = 0; r[i] != NULL; ++i)
6302 static int test_pvremove_1_skip (void)
6306 str = getenv ("TEST_ONLY");
6308 return strstr (str, "pvremove") == NULL;
6309 str = getenv ("SKIP_TEST_PVREMOVE_1");
6310 if (str && strcmp (str, "1") == 0) return 1;
6311 str = getenv ("SKIP_TEST_PVREMOVE");
6312 if (str && strcmp (str, "1") == 0) return 1;
6316 static int test_pvremove_1 (void)
6318 if (test_pvremove_1_skip ()) {
6319 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6323 /* InitNone|InitEmpty for test_pvremove_1 */
6325 char device[] = "/dev/sda";
6328 r = guestfs_blockdev_setrw (g, device);
6335 r = guestfs_umount_all (g);
6342 r = guestfs_lvm_remove_all (g);
6346 /* TestOutputListOfDevices for pvremove (1) */
6348 char device[] = "/dev/sda";
6349 char lines_0[] = ",";
6356 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6361 char device[] = "/dev/sda1";
6364 r = guestfs_pvcreate (g, device);
6369 char volgroup[] = "VG";
6370 char physvols_0[] = "/dev/sda1";
6371 char *physvols[] = {
6377 r = guestfs_vgcreate (g, volgroup, physvols);
6382 char logvol[] = "LV1";
6383 char volgroup[] = "VG";
6386 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6391 char logvol[] = "LV2";
6392 char volgroup[] = "VG";
6395 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6400 char vgname[] = "VG";
6403 r = guestfs_vgremove (g, vgname);
6408 char device[] = "/dev/sda1";
6411 r = guestfs_pvremove (g, device);
6419 r = guestfs_vgs (g);
6423 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6427 for (i = 0; r[i] != NULL; ++i)
6434 static int test_pvremove_2_skip (void)
6438 str = getenv ("TEST_ONLY");
6440 return strstr (str, "pvremove") == NULL;
6441 str = getenv ("SKIP_TEST_PVREMOVE_2");
6442 if (str && strcmp (str, "1") == 0) return 1;
6443 str = getenv ("SKIP_TEST_PVREMOVE");
6444 if (str && strcmp (str, "1") == 0) return 1;
6448 static int test_pvremove_2 (void)
6450 if (test_pvremove_2_skip ()) {
6451 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6455 /* InitNone|InitEmpty for test_pvremove_2 */
6457 char device[] = "/dev/sda";
6460 r = guestfs_blockdev_setrw (g, device);
6467 r = guestfs_umount_all (g);
6474 r = guestfs_lvm_remove_all (g);
6478 /* TestOutputListOfDevices for pvremove (2) */
6480 char device[] = "/dev/sda";
6481 char lines_0[] = ",";
6488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6493 char device[] = "/dev/sda1";
6496 r = guestfs_pvcreate (g, device);
6501 char volgroup[] = "VG";
6502 char physvols_0[] = "/dev/sda1";
6503 char *physvols[] = {
6509 r = guestfs_vgcreate (g, volgroup, physvols);
6514 char logvol[] = "LV1";
6515 char volgroup[] = "VG";
6518 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6523 char logvol[] = "LV2";
6524 char volgroup[] = "VG";
6527 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6532 char vgname[] = "VG";
6535 r = guestfs_vgremove (g, vgname);
6540 char device[] = "/dev/sda1";
6543 r = guestfs_pvremove (g, device);
6551 r = guestfs_pvs (g);
6555 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6559 for (i = 0; r[i] != NULL; ++i)
6566 static int test_vgremove_0_skip (void)
6570 str = getenv ("TEST_ONLY");
6572 return strstr (str, "vgremove") == NULL;
6573 str = getenv ("SKIP_TEST_VGREMOVE_0");
6574 if (str && strcmp (str, "1") == 0) return 1;
6575 str = getenv ("SKIP_TEST_VGREMOVE");
6576 if (str && strcmp (str, "1") == 0) return 1;
6580 static int test_vgremove_0 (void)
6582 if (test_vgremove_0_skip ()) {
6583 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6587 /* InitNone|InitEmpty for test_vgremove_0 */
6589 char device[] = "/dev/sda";
6592 r = guestfs_blockdev_setrw (g, device);
6599 r = guestfs_umount_all (g);
6606 r = guestfs_lvm_remove_all (g);
6610 /* TestOutputList for vgremove (0) */
6612 char device[] = "/dev/sda";
6613 char lines_0[] = ",";
6620 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6625 char device[] = "/dev/sda1";
6628 r = guestfs_pvcreate (g, device);
6633 char volgroup[] = "VG";
6634 char physvols_0[] = "/dev/sda1";
6635 char *physvols[] = {
6641 r = guestfs_vgcreate (g, volgroup, physvols);
6646 char logvol[] = "LV1";
6647 char volgroup[] = "VG";
6650 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6655 char logvol[] = "LV2";
6656 char volgroup[] = "VG";
6659 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6664 char vgname[] = "VG";
6667 r = guestfs_vgremove (g, vgname);
6675 r = guestfs_lvs (g);
6679 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6683 for (i = 0; r[i] != NULL; ++i)
6690 static int test_vgremove_1_skip (void)
6694 str = getenv ("TEST_ONLY");
6696 return strstr (str, "vgremove") == NULL;
6697 str = getenv ("SKIP_TEST_VGREMOVE_1");
6698 if (str && strcmp (str, "1") == 0) return 1;
6699 str = getenv ("SKIP_TEST_VGREMOVE");
6700 if (str && strcmp (str, "1") == 0) return 1;
6704 static int test_vgremove_1 (void)
6706 if (test_vgremove_1_skip ()) {
6707 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6711 /* InitNone|InitEmpty for test_vgremove_1 */
6713 char device[] = "/dev/sda";
6716 r = guestfs_blockdev_setrw (g, device);
6723 r = guestfs_umount_all (g);
6730 r = guestfs_lvm_remove_all (g);
6734 /* TestOutputList for vgremove (1) */
6736 char device[] = "/dev/sda";
6737 char lines_0[] = ",";
6744 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6749 char device[] = "/dev/sda1";
6752 r = guestfs_pvcreate (g, device);
6757 char volgroup[] = "VG";
6758 char physvols_0[] = "/dev/sda1";
6759 char *physvols[] = {
6765 r = guestfs_vgcreate (g, volgroup, physvols);
6770 char logvol[] = "LV1";
6771 char volgroup[] = "VG";
6774 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6779 char logvol[] = "LV2";
6780 char volgroup[] = "VG";
6783 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6788 char vgname[] = "VG";
6791 r = guestfs_vgremove (g, vgname);
6799 r = guestfs_vgs (g);
6803 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6807 for (i = 0; r[i] != NULL; ++i)
6814 static int test_lvremove_0_skip (void)
6818 str = getenv ("TEST_ONLY");
6820 return strstr (str, "lvremove") == NULL;
6821 str = getenv ("SKIP_TEST_LVREMOVE_0");
6822 if (str && strcmp (str, "1") == 0) return 1;
6823 str = getenv ("SKIP_TEST_LVREMOVE");
6824 if (str && strcmp (str, "1") == 0) return 1;
6828 static int test_lvremove_0 (void)
6830 if (test_lvremove_0_skip ()) {
6831 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6835 /* InitNone|InitEmpty for test_lvremove_0 */
6837 char device[] = "/dev/sda";
6840 r = guestfs_blockdev_setrw (g, device);
6847 r = guestfs_umount_all (g);
6854 r = guestfs_lvm_remove_all (g);
6858 /* TestOutputList for lvremove (0) */
6860 char device[] = "/dev/sda";
6861 char lines_0[] = ",";
6868 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6873 char device[] = "/dev/sda1";
6876 r = guestfs_pvcreate (g, device);
6881 char volgroup[] = "VG";
6882 char physvols_0[] = "/dev/sda1";
6883 char *physvols[] = {
6889 r = guestfs_vgcreate (g, volgroup, physvols);
6894 char logvol[] = "LV1";
6895 char volgroup[] = "VG";
6898 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6903 char logvol[] = "LV2";
6904 char volgroup[] = "VG";
6907 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6912 char device[] = "/dev/VG/LV1";
6915 r = guestfs_lvremove (g, device);
6923 r = guestfs_lvs (g);
6927 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6932 char expected[] = "/dev/VG/LV2";
6933 if (strcmp (r[0], expected) != 0) {
6934 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6939 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6943 for (i = 0; r[i] != NULL; ++i)
6950 static int test_lvremove_1_skip (void)
6954 str = getenv ("TEST_ONLY");
6956 return strstr (str, "lvremove") == NULL;
6957 str = getenv ("SKIP_TEST_LVREMOVE_1");
6958 if (str && strcmp (str, "1") == 0) return 1;
6959 str = getenv ("SKIP_TEST_LVREMOVE");
6960 if (str && strcmp (str, "1") == 0) return 1;
6964 static int test_lvremove_1 (void)
6966 if (test_lvremove_1_skip ()) {
6967 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6971 /* InitNone|InitEmpty for test_lvremove_1 */
6973 char device[] = "/dev/sda";
6976 r = guestfs_blockdev_setrw (g, device);
6983 r = guestfs_umount_all (g);
6990 r = guestfs_lvm_remove_all (g);
6994 /* TestOutputList for lvremove (1) */
6996 char device[] = "/dev/sda";
6997 char lines_0[] = ",";
7004 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7009 char device[] = "/dev/sda1";
7012 r = guestfs_pvcreate (g, device);
7017 char volgroup[] = "VG";
7018 char physvols_0[] = "/dev/sda1";
7019 char *physvols[] = {
7025 r = guestfs_vgcreate (g, volgroup, physvols);
7030 char logvol[] = "LV1";
7031 char volgroup[] = "VG";
7034 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7039 char logvol[] = "LV2";
7040 char volgroup[] = "VG";
7043 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7048 char device[] = "/dev/VG";
7051 r = guestfs_lvremove (g, device);
7059 r = guestfs_lvs (g);
7063 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
7067 for (i = 0; r[i] != NULL; ++i)
7074 static int test_lvremove_2_skip (void)
7078 str = getenv ("TEST_ONLY");
7080 return strstr (str, "lvremove") == NULL;
7081 str = getenv ("SKIP_TEST_LVREMOVE_2");
7082 if (str && strcmp (str, "1") == 0) return 1;
7083 str = getenv ("SKIP_TEST_LVREMOVE");
7084 if (str && strcmp (str, "1") == 0) return 1;
7088 static int test_lvremove_2 (void)
7090 if (test_lvremove_2_skip ()) {
7091 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
7095 /* InitNone|InitEmpty for test_lvremove_2 */
7097 char device[] = "/dev/sda";
7100 r = guestfs_blockdev_setrw (g, device);
7107 r = guestfs_umount_all (g);
7114 r = guestfs_lvm_remove_all (g);
7118 /* TestOutputList for lvremove (2) */
7120 char device[] = "/dev/sda";
7121 char lines_0[] = ",";
7128 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7133 char device[] = "/dev/sda1";
7136 r = guestfs_pvcreate (g, device);
7141 char volgroup[] = "VG";
7142 char physvols_0[] = "/dev/sda1";
7143 char *physvols[] = {
7149 r = guestfs_vgcreate (g, volgroup, physvols);
7154 char logvol[] = "LV1";
7155 char volgroup[] = "VG";
7158 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7163 char logvol[] = "LV2";
7164 char volgroup[] = "VG";
7167 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7172 char device[] = "/dev/VG";
7175 r = guestfs_lvremove (g, device);
7183 r = guestfs_vgs (g);
7187 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7192 char expected[] = "VG";
7193 if (strcmp (r[0], expected) != 0) {
7194 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7199 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7203 for (i = 0; r[i] != NULL; ++i)
7210 static int test_mount_ro_0_skip (void)
7214 str = getenv ("TEST_ONLY");
7216 return strstr (str, "mount_ro") == NULL;
7217 str = getenv ("SKIP_TEST_MOUNT_RO_0");
7218 if (str && strcmp (str, "1") == 0) return 1;
7219 str = getenv ("SKIP_TEST_MOUNT_RO");
7220 if (str && strcmp (str, "1") == 0) return 1;
7224 static int test_mount_ro_0 (void)
7226 if (test_mount_ro_0_skip ()) {
7227 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7231 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7233 char device[] = "/dev/sda";
7236 r = guestfs_blockdev_setrw (g, device);
7243 r = guestfs_umount_all (g);
7250 r = guestfs_lvm_remove_all (g);
7255 char device[] = "/dev/sda";
7256 char lines_0[] = ",";
7263 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7268 char fstype[] = "ext2";
7269 char device[] = "/dev/sda1";
7272 r = guestfs_mkfs (g, fstype, device);
7277 char device[] = "/dev/sda1";
7278 char mountpoint[] = "/";
7281 r = guestfs_mount (g, device, mountpoint);
7285 /* TestLastFail for mount_ro (0) */
7287 char pathordevice[] = "/";
7290 r = guestfs_umount (g, pathordevice);
7295 char device[] = "/dev/sda1";
7296 char mountpoint[] = "/";
7299 r = guestfs_mount_ro (g, device, mountpoint);
7304 char path[] = "/new";
7307 r = guestfs_touch (g, path);
7314 static int test_mount_ro_1_skip (void)
7318 str = getenv ("TEST_ONLY");
7320 return strstr (str, "mount_ro") == NULL;
7321 str = getenv ("SKIP_TEST_MOUNT_RO_1");
7322 if (str && strcmp (str, "1") == 0) return 1;
7323 str = getenv ("SKIP_TEST_MOUNT_RO");
7324 if (str && strcmp (str, "1") == 0) return 1;
7328 static int test_mount_ro_1 (void)
7330 if (test_mount_ro_1_skip ()) {
7331 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7335 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7337 char device[] = "/dev/sda";
7340 r = guestfs_blockdev_setrw (g, device);
7347 r = guestfs_umount_all (g);
7354 r = guestfs_lvm_remove_all (g);
7359 char device[] = "/dev/sda";
7360 char lines_0[] = ",";
7367 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7372 char fstype[] = "ext2";
7373 char device[] = "/dev/sda1";
7376 r = guestfs_mkfs (g, fstype, device);
7381 char device[] = "/dev/sda1";
7382 char mountpoint[] = "/";
7385 r = guestfs_mount (g, device, mountpoint);
7389 /* TestOutput for mount_ro (1) */
7390 char expected[] = "data";
7392 char path[] = "/new";
7393 char content[] = "data";
7396 r = guestfs_write_file (g, path, content, 0);
7401 char pathordevice[] = "/";
7404 r = guestfs_umount (g, pathordevice);
7409 char device[] = "/dev/sda1";
7410 char mountpoint[] = "/";
7413 r = guestfs_mount_ro (g, device, mountpoint);
7418 char path[] = "/new";
7421 r = guestfs_cat (g, path);
7424 if (strcmp (r, expected) != 0) {
7425 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7433 static int test_tgz_in_0_skip (void)
7437 str = getenv ("TEST_ONLY");
7439 return strstr (str, "tgz_in") == NULL;
7440 str = getenv ("SKIP_TEST_TGZ_IN_0");
7441 if (str && strcmp (str, "1") == 0) return 1;
7442 str = getenv ("SKIP_TEST_TGZ_IN");
7443 if (str && strcmp (str, "1") == 0) return 1;
7447 static int test_tgz_in_0 (void)
7449 if (test_tgz_in_0_skip ()) {
7450 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7454 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7456 char device[] = "/dev/sda";
7459 r = guestfs_blockdev_setrw (g, device);
7466 r = guestfs_umount_all (g);
7473 r = guestfs_lvm_remove_all (g);
7478 char device[] = "/dev/sda";
7479 char lines_0[] = ",";
7486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7491 char fstype[] = "ext2";
7492 char device[] = "/dev/sda1";
7495 r = guestfs_mkfs (g, fstype, device);
7500 char device[] = "/dev/sda1";
7501 char mountpoint[] = "/";
7504 r = guestfs_mount (g, device, mountpoint);
7508 /* TestOutput for tgz_in (0) */
7509 char expected[] = "hello\n";
7511 char directory[] = "/";
7514 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7519 char path[] = "/hello";
7522 r = guestfs_cat (g, path);
7525 if (strcmp (r, expected) != 0) {
7526 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7534 static int test_tar_in_0_skip (void)
7538 str = getenv ("TEST_ONLY");
7540 return strstr (str, "tar_in") == NULL;
7541 str = getenv ("SKIP_TEST_TAR_IN_0");
7542 if (str && strcmp (str, "1") == 0) return 1;
7543 str = getenv ("SKIP_TEST_TAR_IN");
7544 if (str && strcmp (str, "1") == 0) return 1;
7548 static int test_tar_in_0 (void)
7550 if (test_tar_in_0_skip ()) {
7551 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7555 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7557 char device[] = "/dev/sda";
7560 r = guestfs_blockdev_setrw (g, device);
7567 r = guestfs_umount_all (g);
7574 r = guestfs_lvm_remove_all (g);
7579 char device[] = "/dev/sda";
7580 char lines_0[] = ",";
7587 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7592 char fstype[] = "ext2";
7593 char device[] = "/dev/sda1";
7596 r = guestfs_mkfs (g, fstype, device);
7601 char device[] = "/dev/sda1";
7602 char mountpoint[] = "/";
7605 r = guestfs_mount (g, device, mountpoint);
7609 /* TestOutput for tar_in (0) */
7610 char expected[] = "hello\n";
7612 char directory[] = "/";
7615 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7620 char path[] = "/hello";
7623 r = guestfs_cat (g, path);
7626 if (strcmp (r, expected) != 0) {
7627 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7635 static int test_checksum_0_skip (void)
7639 str = getenv ("TEST_ONLY");
7641 return strstr (str, "checksum") == NULL;
7642 str = getenv ("SKIP_TEST_CHECKSUM_0");
7643 if (str && strcmp (str, "1") == 0) return 1;
7644 str = getenv ("SKIP_TEST_CHECKSUM");
7645 if (str && strcmp (str, "1") == 0) return 1;
7649 static int test_checksum_0 (void)
7651 if (test_checksum_0_skip ()) {
7652 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7656 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7658 char device[] = "/dev/sda";
7661 r = guestfs_blockdev_setrw (g, device);
7668 r = guestfs_umount_all (g);
7675 r = guestfs_lvm_remove_all (g);
7680 char device[] = "/dev/sda";
7681 char lines_0[] = ",";
7688 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7693 char fstype[] = "ext2";
7694 char device[] = "/dev/sda1";
7697 r = guestfs_mkfs (g, fstype, device);
7702 char device[] = "/dev/sda1";
7703 char mountpoint[] = "/";
7706 r = guestfs_mount (g, device, mountpoint);
7710 /* TestOutput for checksum (0) */
7711 char expected[] = "935282863";
7713 char path[] = "/new";
7714 char content[] = "test\n";
7717 r = guestfs_write_file (g, path, content, 0);
7722 char csumtype[] = "crc";
7723 char path[] = "/new";
7726 r = guestfs_checksum (g, csumtype, path);
7729 if (strcmp (r, expected) != 0) {
7730 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7738 static int test_checksum_1_skip (void)
7742 str = getenv ("TEST_ONLY");
7744 return strstr (str, "checksum") == NULL;
7745 str = getenv ("SKIP_TEST_CHECKSUM_1");
7746 if (str && strcmp (str, "1") == 0) return 1;
7747 str = getenv ("SKIP_TEST_CHECKSUM");
7748 if (str && strcmp (str, "1") == 0) return 1;
7752 static int test_checksum_1 (void)
7754 if (test_checksum_1_skip ()) {
7755 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7759 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7761 char device[] = "/dev/sda";
7764 r = guestfs_blockdev_setrw (g, device);
7771 r = guestfs_umount_all (g);
7778 r = guestfs_lvm_remove_all (g);
7783 char device[] = "/dev/sda";
7784 char lines_0[] = ",";
7791 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7796 char fstype[] = "ext2";
7797 char device[] = "/dev/sda1";
7800 r = guestfs_mkfs (g, fstype, device);
7805 char device[] = "/dev/sda1";
7806 char mountpoint[] = "/";
7809 r = guestfs_mount (g, device, mountpoint);
7813 /* TestLastFail for checksum (1) */
7815 char csumtype[] = "crc";
7816 char path[] = "/new";
7819 r = guestfs_checksum (g, csumtype, path);
7827 static int test_checksum_2_skip (void)
7831 str = getenv ("TEST_ONLY");
7833 return strstr (str, "checksum") == NULL;
7834 str = getenv ("SKIP_TEST_CHECKSUM_2");
7835 if (str && strcmp (str, "1") == 0) return 1;
7836 str = getenv ("SKIP_TEST_CHECKSUM");
7837 if (str && strcmp (str, "1") == 0) return 1;
7841 static int test_checksum_2 (void)
7843 if (test_checksum_2_skip ()) {
7844 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7848 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7850 char device[] = "/dev/sda";
7853 r = guestfs_blockdev_setrw (g, device);
7860 r = guestfs_umount_all (g);
7867 r = guestfs_lvm_remove_all (g);
7872 char device[] = "/dev/sda";
7873 char lines_0[] = ",";
7880 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7885 char fstype[] = "ext2";
7886 char device[] = "/dev/sda1";
7889 r = guestfs_mkfs (g, fstype, device);
7894 char device[] = "/dev/sda1";
7895 char mountpoint[] = "/";
7898 r = guestfs_mount (g, device, mountpoint);
7902 /* TestOutput for checksum (2) */
7903 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7905 char path[] = "/new";
7906 char content[] = "test\n";
7909 r = guestfs_write_file (g, path, content, 0);
7914 char csumtype[] = "md5";
7915 char path[] = "/new";
7918 r = guestfs_checksum (g, csumtype, path);
7921 if (strcmp (r, expected) != 0) {
7922 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7930 static int test_checksum_3_skip (void)
7934 str = getenv ("TEST_ONLY");
7936 return strstr (str, "checksum") == NULL;
7937 str = getenv ("SKIP_TEST_CHECKSUM_3");
7938 if (str && strcmp (str, "1") == 0) return 1;
7939 str = getenv ("SKIP_TEST_CHECKSUM");
7940 if (str && strcmp (str, "1") == 0) return 1;
7944 static int test_checksum_3 (void)
7946 if (test_checksum_3_skip ()) {
7947 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7951 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7953 char device[] = "/dev/sda";
7956 r = guestfs_blockdev_setrw (g, device);
7963 r = guestfs_umount_all (g);
7970 r = guestfs_lvm_remove_all (g);
7975 char device[] = "/dev/sda";
7976 char lines_0[] = ",";
7983 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7988 char fstype[] = "ext2";
7989 char device[] = "/dev/sda1";
7992 r = guestfs_mkfs (g, fstype, device);
7997 char device[] = "/dev/sda1";
7998 char mountpoint[] = "/";
8001 r = guestfs_mount (g, device, mountpoint);
8005 /* TestOutput for checksum (3) */
8006 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
8008 char path[] = "/new";
8009 char content[] = "test\n";
8012 r = guestfs_write_file (g, path, content, 0);
8017 char csumtype[] = "sha1";
8018 char path[] = "/new";
8021 r = guestfs_checksum (g, csumtype, path);
8024 if (strcmp (r, expected) != 0) {
8025 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
8033 static int test_checksum_4_skip (void)
8037 str = getenv ("TEST_ONLY");
8039 return strstr (str, "checksum") == NULL;
8040 str = getenv ("SKIP_TEST_CHECKSUM_4");
8041 if (str && strcmp (str, "1") == 0) return 1;
8042 str = getenv ("SKIP_TEST_CHECKSUM");
8043 if (str && strcmp (str, "1") == 0) return 1;
8047 static int test_checksum_4 (void)
8049 if (test_checksum_4_skip ()) {
8050 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
8054 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
8056 char device[] = "/dev/sda";
8059 r = guestfs_blockdev_setrw (g, device);
8066 r = guestfs_umount_all (g);
8073 r = guestfs_lvm_remove_all (g);
8078 char device[] = "/dev/sda";
8079 char lines_0[] = ",";
8086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8091 char fstype[] = "ext2";
8092 char device[] = "/dev/sda1";
8095 r = guestfs_mkfs (g, fstype, device);
8100 char device[] = "/dev/sda1";
8101 char mountpoint[] = "/";
8104 r = guestfs_mount (g, device, mountpoint);
8108 /* TestOutput for checksum (4) */
8109 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
8111 char path[] = "/new";
8112 char content[] = "test\n";
8115 r = guestfs_write_file (g, path, content, 0);
8120 char csumtype[] = "sha224";
8121 char path[] = "/new";
8124 r = guestfs_checksum (g, csumtype, path);
8127 if (strcmp (r, expected) != 0) {
8128 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
8136 static int test_checksum_5_skip (void)
8140 str = getenv ("TEST_ONLY");
8142 return strstr (str, "checksum") == NULL;
8143 str = getenv ("SKIP_TEST_CHECKSUM_5");
8144 if (str && strcmp (str, "1") == 0) return 1;
8145 str = getenv ("SKIP_TEST_CHECKSUM");
8146 if (str && strcmp (str, "1") == 0) return 1;
8150 static int test_checksum_5 (void)
8152 if (test_checksum_5_skip ()) {
8153 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8157 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8159 char device[] = "/dev/sda";
8162 r = guestfs_blockdev_setrw (g, device);
8169 r = guestfs_umount_all (g);
8176 r = guestfs_lvm_remove_all (g);
8181 char device[] = "/dev/sda";
8182 char lines_0[] = ",";
8189 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8194 char fstype[] = "ext2";
8195 char device[] = "/dev/sda1";
8198 r = guestfs_mkfs (g, fstype, device);
8203 char device[] = "/dev/sda1";
8204 char mountpoint[] = "/";
8207 r = guestfs_mount (g, device, mountpoint);
8211 /* TestOutput for checksum (5) */
8212 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8214 char path[] = "/new";
8215 char content[] = "test\n";
8218 r = guestfs_write_file (g, path, content, 0);
8223 char csumtype[] = "sha256";
8224 char path[] = "/new";
8227 r = guestfs_checksum (g, csumtype, path);
8230 if (strcmp (r, expected) != 0) {
8231 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8239 static int test_checksum_6_skip (void)
8243 str = getenv ("TEST_ONLY");
8245 return strstr (str, "checksum") == NULL;
8246 str = getenv ("SKIP_TEST_CHECKSUM_6");
8247 if (str && strcmp (str, "1") == 0) return 1;
8248 str = getenv ("SKIP_TEST_CHECKSUM");
8249 if (str && strcmp (str, "1") == 0) return 1;
8253 static int test_checksum_6 (void)
8255 if (test_checksum_6_skip ()) {
8256 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8260 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8262 char device[] = "/dev/sda";
8265 r = guestfs_blockdev_setrw (g, device);
8272 r = guestfs_umount_all (g);
8279 r = guestfs_lvm_remove_all (g);
8284 char device[] = "/dev/sda";
8285 char lines_0[] = ",";
8292 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8297 char fstype[] = "ext2";
8298 char device[] = "/dev/sda1";
8301 r = guestfs_mkfs (g, fstype, device);
8306 char device[] = "/dev/sda1";
8307 char mountpoint[] = "/";
8310 r = guestfs_mount (g, device, mountpoint);
8314 /* TestOutput for checksum (6) */
8315 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8317 char path[] = "/new";
8318 char content[] = "test\n";
8321 r = guestfs_write_file (g, path, content, 0);
8326 char csumtype[] = "sha384";
8327 char path[] = "/new";
8330 r = guestfs_checksum (g, csumtype, path);
8333 if (strcmp (r, expected) != 0) {
8334 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8342 static int test_checksum_7_skip (void)
8346 str = getenv ("TEST_ONLY");
8348 return strstr (str, "checksum") == NULL;
8349 str = getenv ("SKIP_TEST_CHECKSUM_7");
8350 if (str && strcmp (str, "1") == 0) return 1;
8351 str = getenv ("SKIP_TEST_CHECKSUM");
8352 if (str && strcmp (str, "1") == 0) return 1;
8356 static int test_checksum_7 (void)
8358 if (test_checksum_7_skip ()) {
8359 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8363 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8365 char device[] = "/dev/sda";
8368 r = guestfs_blockdev_setrw (g, device);
8375 r = guestfs_umount_all (g);
8382 r = guestfs_lvm_remove_all (g);
8387 char device[] = "/dev/sda";
8388 char lines_0[] = ",";
8395 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8400 char fstype[] = "ext2";
8401 char device[] = "/dev/sda1";
8404 r = guestfs_mkfs (g, fstype, device);
8409 char device[] = "/dev/sda1";
8410 char mountpoint[] = "/";
8413 r = guestfs_mount (g, device, mountpoint);
8417 /* TestOutput for checksum (7) */
8418 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8420 char path[] = "/new";
8421 char content[] = "test\n";
8424 r = guestfs_write_file (g, path, content, 0);
8429 char csumtype[] = "sha512";
8430 char path[] = "/new";
8433 r = guestfs_checksum (g, csumtype, path);
8436 if (strcmp (r, expected) != 0) {
8437 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8445 static int test_checksum_8_skip (void)
8449 str = getenv ("TEST_ONLY");
8451 return strstr (str, "checksum") == NULL;
8452 str = getenv ("SKIP_TEST_CHECKSUM_8");
8453 if (str && strcmp (str, "1") == 0) return 1;
8454 str = getenv ("SKIP_TEST_CHECKSUM");
8455 if (str && strcmp (str, "1") == 0) return 1;
8459 static int test_checksum_8 (void)
8461 if (test_checksum_8_skip ()) {
8462 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8466 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8468 char device[] = "/dev/sda";
8471 r = guestfs_blockdev_setrw (g, device);
8478 r = guestfs_umount_all (g);
8485 r = guestfs_lvm_remove_all (g);
8490 char device[] = "/dev/sda";
8491 char lines_0[] = ",";
8498 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8503 char fstype[] = "ext2";
8504 char device[] = "/dev/sda1";
8507 r = guestfs_mkfs (g, fstype, device);
8512 char device[] = "/dev/sda1";
8513 char mountpoint[] = "/";
8516 r = guestfs_mount (g, device, mountpoint);
8520 /* TestOutput for checksum (8) */
8521 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8523 char options[] = "ro";
8524 char vfstype[] = "squashfs";
8525 char device[] = "/dev/sdd";
8526 char mountpoint[] = "/";
8529 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8534 char csumtype[] = "md5";
8535 char path[] = "/known-3";
8538 r = guestfs_checksum (g, csumtype, path);
8541 if (strcmp (r, expected) != 0) {
8542 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8550 static int test_download_0_skip (void)
8554 str = getenv ("TEST_ONLY");
8556 return strstr (str, "download") == NULL;
8557 str = getenv ("SKIP_TEST_DOWNLOAD_0");
8558 if (str && strcmp (str, "1") == 0) return 1;
8559 str = getenv ("SKIP_TEST_DOWNLOAD");
8560 if (str && strcmp (str, "1") == 0) return 1;
8564 static int test_download_0 (void)
8566 if (test_download_0_skip ()) {
8567 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8571 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8573 char device[] = "/dev/sda";
8576 r = guestfs_blockdev_setrw (g, device);
8583 r = guestfs_umount_all (g);
8590 r = guestfs_lvm_remove_all (g);
8595 char device[] = "/dev/sda";
8596 char lines_0[] = ",";
8603 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8608 char fstype[] = "ext2";
8609 char device[] = "/dev/sda1";
8612 r = guestfs_mkfs (g, fstype, device);
8617 char device[] = "/dev/sda1";
8618 char mountpoint[] = "/";
8621 r = guestfs_mount (g, device, mountpoint);
8625 /* TestOutput for download (0) */
8626 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8628 char remotefilename[] = "/COPYING.LIB";
8631 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8636 char remotefilename[] = "/COPYING.LIB";
8639 r = guestfs_download (g, remotefilename, "testdownload.tmp");
8644 char remotefilename[] = "/upload";
8647 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8652 char csumtype[] = "md5";
8653 char path[] = "/upload";
8656 r = guestfs_checksum (g, csumtype, path);
8659 if (strcmp (r, expected) != 0) {
8660 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8668 static int test_upload_0_skip (void)
8672 str = getenv ("TEST_ONLY");
8674 return strstr (str, "upload") == NULL;
8675 str = getenv ("SKIP_TEST_UPLOAD_0");
8676 if (str && strcmp (str, "1") == 0) return 1;
8677 str = getenv ("SKIP_TEST_UPLOAD");
8678 if (str && strcmp (str, "1") == 0) return 1;
8682 static int test_upload_0 (void)
8684 if (test_upload_0_skip ()) {
8685 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8689 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8691 char device[] = "/dev/sda";
8694 r = guestfs_blockdev_setrw (g, device);
8701 r = guestfs_umount_all (g);
8708 r = guestfs_lvm_remove_all (g);
8713 char device[] = "/dev/sda";
8714 char lines_0[] = ",";
8721 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8726 char fstype[] = "ext2";
8727 char device[] = "/dev/sda1";
8730 r = guestfs_mkfs (g, fstype, device);
8735 char device[] = "/dev/sda1";
8736 char mountpoint[] = "/";
8739 r = guestfs_mount (g, device, mountpoint);
8743 /* TestOutput for upload (0) */
8744 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8746 char remotefilename[] = "/COPYING.LIB";
8749 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8754 char csumtype[] = "md5";
8755 char path[] = "/COPYING.LIB";
8758 r = guestfs_checksum (g, csumtype, path);
8761 if (strcmp (r, expected) != 0) {
8762 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8770 static int test_blockdev_rereadpt_0_skip (void)
8774 str = getenv ("TEST_ONLY");
8776 return strstr (str, "blockdev_rereadpt") == NULL;
8777 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8778 if (str && strcmp (str, "1") == 0) return 1;
8779 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8780 if (str && strcmp (str, "1") == 0) return 1;
8784 static int test_blockdev_rereadpt_0 (void)
8786 if (test_blockdev_rereadpt_0_skip ()) {
8787 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8791 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8793 char device[] = "/dev/sda";
8796 r = guestfs_blockdev_setrw (g, device);
8803 r = guestfs_umount_all (g);
8810 r = guestfs_lvm_remove_all (g);
8814 /* TestRun for blockdev_rereadpt (0) */
8816 char device[] = "/dev/sda";
8819 r = guestfs_blockdev_rereadpt (g, device);
8826 static int test_blockdev_flushbufs_0_skip (void)
8830 str = getenv ("TEST_ONLY");
8832 return strstr (str, "blockdev_flushbufs") == NULL;
8833 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8834 if (str && strcmp (str, "1") == 0) return 1;
8835 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8836 if (str && strcmp (str, "1") == 0) return 1;
8840 static int test_blockdev_flushbufs_0 (void)
8842 if (test_blockdev_flushbufs_0_skip ()) {
8843 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8847 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8849 char device[] = "/dev/sda";
8852 r = guestfs_blockdev_setrw (g, device);
8859 r = guestfs_umount_all (g);
8866 r = guestfs_lvm_remove_all (g);
8870 /* TestRun for blockdev_flushbufs (0) */
8872 char device[] = "/dev/sda";
8875 r = guestfs_blockdev_flushbufs (g, device);
8882 static int test_blockdev_getsize64_0_skip (void)
8886 str = getenv ("TEST_ONLY");
8888 return strstr (str, "blockdev_getsize64") == NULL;
8889 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8890 if (str && strcmp (str, "1") == 0) return 1;
8891 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8892 if (str && strcmp (str, "1") == 0) return 1;
8896 static int test_blockdev_getsize64_0 (void)
8898 if (test_blockdev_getsize64_0_skip ()) {
8899 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8903 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8905 char device[] = "/dev/sda";
8908 r = guestfs_blockdev_setrw (g, device);
8915 r = guestfs_umount_all (g);
8922 r = guestfs_lvm_remove_all (g);
8926 /* TestOutputInt for blockdev_getsize64 (0) */
8928 char device[] = "/dev/sda";
8931 r = guestfs_blockdev_getsize64 (g, device);
8934 if (r != 524288000) {
8935 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
8942 static int test_blockdev_getsz_0_skip (void)
8946 str = getenv ("TEST_ONLY");
8948 return strstr (str, "blockdev_getsz") == NULL;
8949 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8950 if (str && strcmp (str, "1") == 0) return 1;
8951 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8952 if (str && strcmp (str, "1") == 0) return 1;
8956 static int test_blockdev_getsz_0 (void)
8958 if (test_blockdev_getsz_0_skip ()) {
8959 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8963 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8965 char device[] = "/dev/sda";
8968 r = guestfs_blockdev_setrw (g, device);
8975 r = guestfs_umount_all (g);
8982 r = guestfs_lvm_remove_all (g);
8986 /* TestOutputInt for blockdev_getsz (0) */
8988 char device[] = "/dev/sda";
8991 r = guestfs_blockdev_getsz (g, device);
8995 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
9002 static int test_blockdev_getbsz_0_skip (void)
9006 str = getenv ("TEST_ONLY");
9008 return strstr (str, "blockdev_getbsz") == NULL;
9009 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
9010 if (str && strcmp (str, "1") == 0) return 1;
9011 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
9012 if (str && strcmp (str, "1") == 0) return 1;
9016 static int test_blockdev_getbsz_0 (void)
9018 if (test_blockdev_getbsz_0_skip ()) {
9019 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
9023 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
9025 char device[] = "/dev/sda";
9028 r = guestfs_blockdev_setrw (g, device);
9035 r = guestfs_umount_all (g);
9042 r = guestfs_lvm_remove_all (g);
9046 /* TestOutputInt for blockdev_getbsz (0) */
9048 char device[] = "/dev/sda";
9051 r = guestfs_blockdev_getbsz (g, device);
9055 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
9062 static int test_blockdev_getss_0_skip (void)
9066 str = getenv ("TEST_ONLY");
9068 return strstr (str, "blockdev_getss") == NULL;
9069 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
9070 if (str && strcmp (str, "1") == 0) return 1;
9071 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
9072 if (str && strcmp (str, "1") == 0) return 1;
9076 static int test_blockdev_getss_0 (void)
9078 if (test_blockdev_getss_0_skip ()) {
9079 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
9083 /* InitNone|InitEmpty for test_blockdev_getss_0 */
9085 char device[] = "/dev/sda";
9088 r = guestfs_blockdev_setrw (g, device);
9095 r = guestfs_umount_all (g);
9102 r = guestfs_lvm_remove_all (g);
9106 /* TestOutputInt for blockdev_getss (0) */
9108 char device[] = "/dev/sda";
9111 r = guestfs_blockdev_getss (g, device);
9115 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
9122 static int test_blockdev_getro_0_skip (void)
9126 str = getenv ("TEST_ONLY");
9128 return strstr (str, "blockdev_getro") == NULL;
9129 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
9130 if (str && strcmp (str, "1") == 0) return 1;
9131 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
9132 if (str && strcmp (str, "1") == 0) return 1;
9136 static int test_blockdev_getro_0 (void)
9138 if (test_blockdev_getro_0_skip ()) {
9139 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
9143 /* InitNone|InitEmpty for test_blockdev_getro_0 */
9145 char device[] = "/dev/sda";
9148 r = guestfs_blockdev_setrw (g, device);
9155 r = guestfs_umount_all (g);
9162 r = guestfs_lvm_remove_all (g);
9166 /* TestOutputTrue for blockdev_getro (0) */
9168 char device[] = "/dev/sda";
9171 r = guestfs_blockdev_setro (g, device);
9176 char device[] = "/dev/sda";
9179 r = guestfs_blockdev_getro (g, device);
9183 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9190 static int test_blockdev_setrw_0_skip (void)
9194 str = getenv ("TEST_ONLY");
9196 return strstr (str, "blockdev_setrw") == NULL;
9197 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9198 if (str && strcmp (str, "1") == 0) return 1;
9199 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9200 if (str && strcmp (str, "1") == 0) return 1;
9204 static int test_blockdev_setrw_0 (void)
9206 if (test_blockdev_setrw_0_skip ()) {
9207 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9211 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9213 char device[] = "/dev/sda";
9216 r = guestfs_blockdev_setrw (g, device);
9223 r = guestfs_umount_all (g);
9230 r = guestfs_lvm_remove_all (g);
9234 /* TestOutputFalse for blockdev_setrw (0) */
9236 char device[] = "/dev/sda";
9239 r = guestfs_blockdev_setrw (g, device);
9244 char device[] = "/dev/sda";
9247 r = guestfs_blockdev_getro (g, device);
9251 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9258 static int test_blockdev_setro_0_skip (void)
9262 str = getenv ("TEST_ONLY");
9264 return strstr (str, "blockdev_setro") == NULL;
9265 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9266 if (str && strcmp (str, "1") == 0) return 1;
9267 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9268 if (str && strcmp (str, "1") == 0) return 1;
9272 static int test_blockdev_setro_0 (void)
9274 if (test_blockdev_setro_0_skip ()) {
9275 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9279 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9281 char device[] = "/dev/sda";
9284 r = guestfs_blockdev_setrw (g, device);
9291 r = guestfs_umount_all (g);
9298 r = guestfs_lvm_remove_all (g);
9302 /* TestOutputTrue for blockdev_setro (0) */
9304 char device[] = "/dev/sda";
9307 r = guestfs_blockdev_setro (g, device);
9312 char device[] = "/dev/sda";
9315 r = guestfs_blockdev_getro (g, device);
9319 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9326 static int test_statvfs_0_skip (void)
9330 str = getenv ("TEST_ONLY");
9332 return strstr (str, "statvfs") == NULL;
9333 str = getenv ("SKIP_TEST_STATVFS_0");
9334 if (str && strcmp (str, "1") == 0) return 1;
9335 str = getenv ("SKIP_TEST_STATVFS");
9336 if (str && strcmp (str, "1") == 0) return 1;
9340 static int test_statvfs_0 (void)
9342 if (test_statvfs_0_skip ()) {
9343 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9347 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9349 char device[] = "/dev/sda";
9352 r = guestfs_blockdev_setrw (g, device);
9359 r = guestfs_umount_all (g);
9366 r = guestfs_lvm_remove_all (g);
9371 char device[] = "/dev/sda";
9372 char lines_0[] = ",";
9379 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9384 char fstype[] = "ext2";
9385 char device[] = "/dev/sda1";
9388 r = guestfs_mkfs (g, fstype, device);
9393 char device[] = "/dev/sda1";
9394 char mountpoint[] = "/";
9397 r = guestfs_mount (g, device, mountpoint);
9401 /* TestOutputStruct for statvfs (0) */
9404 struct guestfs_statvfs *r;
9406 r = guestfs_statvfs (g, path);
9409 if (r->bfree != 487702) {
9410 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9414 if (r->blocks != 490020) {
9415 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9419 if (r->bsize != 1024) {
9420 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9429 static int test_lstat_0_skip (void)
9433 str = getenv ("TEST_ONLY");
9435 return strstr (str, "lstat") == NULL;
9436 str = getenv ("SKIP_TEST_LSTAT_0");
9437 if (str && strcmp (str, "1") == 0) return 1;
9438 str = getenv ("SKIP_TEST_LSTAT");
9439 if (str && strcmp (str, "1") == 0) return 1;
9443 static int test_lstat_0 (void)
9445 if (test_lstat_0_skip ()) {
9446 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9450 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9452 char device[] = "/dev/sda";
9455 r = guestfs_blockdev_setrw (g, device);
9462 r = guestfs_umount_all (g);
9469 r = guestfs_lvm_remove_all (g);
9474 char device[] = "/dev/sda";
9475 char lines_0[] = ",";
9482 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9487 char fstype[] = "ext2";
9488 char device[] = "/dev/sda1";
9491 r = guestfs_mkfs (g, fstype, device);
9496 char device[] = "/dev/sda1";
9497 char mountpoint[] = "/";
9500 r = guestfs_mount (g, device, mountpoint);
9504 /* TestOutputStruct for lstat (0) */
9506 char path[] = "/new";
9509 r = guestfs_touch (g, path);
9514 char path[] = "/new";
9515 struct guestfs_stat *r;
9517 r = guestfs_lstat (g, path);
9521 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9530 static int test_stat_0_skip (void)
9534 str = getenv ("TEST_ONLY");
9536 return strstr (str, "stat") == NULL;
9537 str = getenv ("SKIP_TEST_STAT_0");
9538 if (str && strcmp (str, "1") == 0) return 1;
9539 str = getenv ("SKIP_TEST_STAT");
9540 if (str && strcmp (str, "1") == 0) return 1;
9544 static int test_stat_0 (void)
9546 if (test_stat_0_skip ()) {
9547 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9551 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9553 char device[] = "/dev/sda";
9556 r = guestfs_blockdev_setrw (g, device);
9563 r = guestfs_umount_all (g);
9570 r = guestfs_lvm_remove_all (g);
9575 char device[] = "/dev/sda";
9576 char lines_0[] = ",";
9583 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9588 char fstype[] = "ext2";
9589 char device[] = "/dev/sda1";
9592 r = guestfs_mkfs (g, fstype, device);
9597 char device[] = "/dev/sda1";
9598 char mountpoint[] = "/";
9601 r = guestfs_mount (g, device, mountpoint);
9605 /* TestOutputStruct for stat (0) */
9607 char path[] = "/new";
9610 r = guestfs_touch (g, path);
9615 char path[] = "/new";
9616 struct guestfs_stat *r;
9618 r = guestfs_stat (g, path);
9622 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9631 static int test_command_lines_0_skip (void)
9635 str = getenv ("TEST_ONLY");
9637 return strstr (str, "command_lines") == NULL;
9638 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9639 if (str && strcmp (str, "1") == 0) return 1;
9640 str = getenv ("SKIP_TEST_COMMAND_LINES");
9641 if (str && strcmp (str, "1") == 0) return 1;
9645 static int test_command_lines_0 (void)
9647 if (test_command_lines_0_skip ()) {
9648 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9652 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9654 char device[] = "/dev/sda";
9657 r = guestfs_blockdev_setrw (g, device);
9664 r = guestfs_umount_all (g);
9671 r = guestfs_lvm_remove_all (g);
9676 char device[] = "/dev/sda";
9677 char lines_0[] = ",";
9684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9689 char fstype[] = "ext2";
9690 char device[] = "/dev/sda1";
9693 r = guestfs_mkfs (g, fstype, device);
9698 char device[] = "/dev/sda1";
9699 char mountpoint[] = "/";
9702 r = guestfs_mount (g, device, mountpoint);
9706 /* TestOutputList for command_lines (0) */
9708 char remotefilename[] = "/test-command";
9711 r = guestfs_upload (g, "test-command", remotefilename);
9716 char path[] = "/test-command";
9719 r = guestfs_chmod (g, 493, path);
9724 char arguments_0[] = "/test-command";
9725 char arguments_1[] = "1";
9726 char *arguments[] = {
9734 r = guestfs_command_lines (g, arguments);
9738 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9743 char expected[] = "Result1";
9744 if (strcmp (r[0], expected) != 0) {
9745 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9750 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9754 for (i = 0; r[i] != NULL; ++i)
9761 static int test_command_lines_1_skip (void)
9765 str = getenv ("TEST_ONLY");
9767 return strstr (str, "command_lines") == NULL;
9768 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9769 if (str && strcmp (str, "1") == 0) return 1;
9770 str = getenv ("SKIP_TEST_COMMAND_LINES");
9771 if (str && strcmp (str, "1") == 0) return 1;
9775 static int test_command_lines_1 (void)
9777 if (test_command_lines_1_skip ()) {
9778 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9782 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9784 char device[] = "/dev/sda";
9787 r = guestfs_blockdev_setrw (g, device);
9794 r = guestfs_umount_all (g);
9801 r = guestfs_lvm_remove_all (g);
9806 char device[] = "/dev/sda";
9807 char lines_0[] = ",";
9814 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9819 char fstype[] = "ext2";
9820 char device[] = "/dev/sda1";
9823 r = guestfs_mkfs (g, fstype, device);
9828 char device[] = "/dev/sda1";
9829 char mountpoint[] = "/";
9832 r = guestfs_mount (g, device, mountpoint);
9836 /* TestOutputList for command_lines (1) */
9838 char remotefilename[] = "/test-command";
9841 r = guestfs_upload (g, "test-command", remotefilename);
9846 char path[] = "/test-command";
9849 r = guestfs_chmod (g, 493, path);
9854 char arguments_0[] = "/test-command";
9855 char arguments_1[] = "2";
9856 char *arguments[] = {
9864 r = guestfs_command_lines (g, arguments);
9868 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9873 char expected[] = "Result2";
9874 if (strcmp (r[0], expected) != 0) {
9875 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9880 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9884 for (i = 0; r[i] != NULL; ++i)
9891 static int test_command_lines_2_skip (void)
9895 str = getenv ("TEST_ONLY");
9897 return strstr (str, "command_lines") == NULL;
9898 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9899 if (str && strcmp (str, "1") == 0) return 1;
9900 str = getenv ("SKIP_TEST_COMMAND_LINES");
9901 if (str && strcmp (str, "1") == 0) return 1;
9905 static int test_command_lines_2 (void)
9907 if (test_command_lines_2_skip ()) {
9908 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9912 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9914 char device[] = "/dev/sda";
9917 r = guestfs_blockdev_setrw (g, device);
9924 r = guestfs_umount_all (g);
9931 r = guestfs_lvm_remove_all (g);
9936 char device[] = "/dev/sda";
9937 char lines_0[] = ",";
9944 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9949 char fstype[] = "ext2";
9950 char device[] = "/dev/sda1";
9953 r = guestfs_mkfs (g, fstype, device);
9958 char device[] = "/dev/sda1";
9959 char mountpoint[] = "/";
9962 r = guestfs_mount (g, device, mountpoint);
9966 /* TestOutputList for command_lines (2) */
9968 char remotefilename[] = "/test-command";
9971 r = guestfs_upload (g, "test-command", remotefilename);
9976 char path[] = "/test-command";
9979 r = guestfs_chmod (g, 493, path);
9984 char arguments_0[] = "/test-command";
9985 char arguments_1[] = "3";
9986 char *arguments[] = {
9994 r = guestfs_command_lines (g, arguments);
9998 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10003 char expected[] = "";
10004 if (strcmp (r[0], expected) != 0) {
10005 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10010 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
10015 char expected[] = "Result3";
10016 if (strcmp (r[1], expected) != 0) {
10017 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10021 if (r[2] != NULL) {
10022 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
10026 for (i = 0; r[i] != NULL; ++i)
10033 static int test_command_lines_3_skip (void)
10037 str = getenv ("TEST_ONLY");
10039 return strstr (str, "command_lines") == NULL;
10040 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
10041 if (str && strcmp (str, "1") == 0) return 1;
10042 str = getenv ("SKIP_TEST_COMMAND_LINES");
10043 if (str && strcmp (str, "1") == 0) return 1;
10047 static int test_command_lines_3 (void)
10049 if (test_command_lines_3_skip ()) {
10050 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
10054 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
10056 char device[] = "/dev/sda";
10058 suppress_error = 0;
10059 r = guestfs_blockdev_setrw (g, device);
10065 suppress_error = 0;
10066 r = guestfs_umount_all (g);
10072 suppress_error = 0;
10073 r = guestfs_lvm_remove_all (g);
10078 char device[] = "/dev/sda";
10079 char lines_0[] = ",";
10085 suppress_error = 0;
10086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10091 char fstype[] = "ext2";
10092 char device[] = "/dev/sda1";
10094 suppress_error = 0;
10095 r = guestfs_mkfs (g, fstype, device);
10100 char device[] = "/dev/sda1";
10101 char mountpoint[] = "/";
10103 suppress_error = 0;
10104 r = guestfs_mount (g, device, mountpoint);
10108 /* TestOutputList for command_lines (3) */
10110 char remotefilename[] = "/test-command";
10112 suppress_error = 0;
10113 r = guestfs_upload (g, "test-command", remotefilename);
10118 char path[] = "/test-command";
10120 suppress_error = 0;
10121 r = guestfs_chmod (g, 493, path);
10126 char arguments_0[] = "/test-command";
10127 char arguments_1[] = "4";
10128 char *arguments[] = {
10135 suppress_error = 0;
10136 r = guestfs_command_lines (g, arguments);
10140 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10145 char expected[] = "";
10146 if (strcmp (r[0], expected) != 0) {
10147 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10152 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10157 char expected[] = "Result4";
10158 if (strcmp (r[1], expected) != 0) {
10159 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10163 if (r[2] != NULL) {
10164 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10168 for (i = 0; r[i] != NULL; ++i)
10175 static int test_command_lines_4_skip (void)
10179 str = getenv ("TEST_ONLY");
10181 return strstr (str, "command_lines") == NULL;
10182 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10183 if (str && strcmp (str, "1") == 0) return 1;
10184 str = getenv ("SKIP_TEST_COMMAND_LINES");
10185 if (str && strcmp (str, "1") == 0) return 1;
10189 static int test_command_lines_4 (void)
10191 if (test_command_lines_4_skip ()) {
10192 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10196 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10198 char device[] = "/dev/sda";
10200 suppress_error = 0;
10201 r = guestfs_blockdev_setrw (g, device);
10207 suppress_error = 0;
10208 r = guestfs_umount_all (g);
10214 suppress_error = 0;
10215 r = guestfs_lvm_remove_all (g);
10220 char device[] = "/dev/sda";
10221 char lines_0[] = ",";
10227 suppress_error = 0;
10228 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10233 char fstype[] = "ext2";
10234 char device[] = "/dev/sda1";
10236 suppress_error = 0;
10237 r = guestfs_mkfs (g, fstype, device);
10242 char device[] = "/dev/sda1";
10243 char mountpoint[] = "/";
10245 suppress_error = 0;
10246 r = guestfs_mount (g, device, mountpoint);
10250 /* TestOutputList for command_lines (4) */
10252 char remotefilename[] = "/test-command";
10254 suppress_error = 0;
10255 r = guestfs_upload (g, "test-command", remotefilename);
10260 char path[] = "/test-command";
10262 suppress_error = 0;
10263 r = guestfs_chmod (g, 493, path);
10268 char arguments_0[] = "/test-command";
10269 char arguments_1[] = "5";
10270 char *arguments[] = {
10277 suppress_error = 0;
10278 r = guestfs_command_lines (g, arguments);
10282 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10287 char expected[] = "";
10288 if (strcmp (r[0], expected) != 0) {
10289 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10294 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10299 char expected[] = "Result5";
10300 if (strcmp (r[1], expected) != 0) {
10301 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10306 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10311 char expected[] = "";
10312 if (strcmp (r[2], expected) != 0) {
10313 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10317 if (r[3] != NULL) {
10318 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10322 for (i = 0; r[i] != NULL; ++i)
10329 static int test_command_lines_5_skip (void)
10333 str = getenv ("TEST_ONLY");
10335 return strstr (str, "command_lines") == NULL;
10336 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10337 if (str && strcmp (str, "1") == 0) return 1;
10338 str = getenv ("SKIP_TEST_COMMAND_LINES");
10339 if (str && strcmp (str, "1") == 0) return 1;
10343 static int test_command_lines_5 (void)
10345 if (test_command_lines_5_skip ()) {
10346 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10350 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10352 char device[] = "/dev/sda";
10354 suppress_error = 0;
10355 r = guestfs_blockdev_setrw (g, device);
10361 suppress_error = 0;
10362 r = guestfs_umount_all (g);
10368 suppress_error = 0;
10369 r = guestfs_lvm_remove_all (g);
10374 char device[] = "/dev/sda";
10375 char lines_0[] = ",";
10381 suppress_error = 0;
10382 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10387 char fstype[] = "ext2";
10388 char device[] = "/dev/sda1";
10390 suppress_error = 0;
10391 r = guestfs_mkfs (g, fstype, device);
10396 char device[] = "/dev/sda1";
10397 char mountpoint[] = "/";
10399 suppress_error = 0;
10400 r = guestfs_mount (g, device, mountpoint);
10404 /* TestOutputList for command_lines (5) */
10406 char remotefilename[] = "/test-command";
10408 suppress_error = 0;
10409 r = guestfs_upload (g, "test-command", remotefilename);
10414 char path[] = "/test-command";
10416 suppress_error = 0;
10417 r = guestfs_chmod (g, 493, path);
10422 char arguments_0[] = "/test-command";
10423 char arguments_1[] = "6";
10424 char *arguments[] = {
10431 suppress_error = 0;
10432 r = guestfs_command_lines (g, arguments);
10436 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10441 char expected[] = "";
10442 if (strcmp (r[0], expected) != 0) {
10443 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10448 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10453 char expected[] = "";
10454 if (strcmp (r[1], expected) != 0) {
10455 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10460 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10465 char expected[] = "Result6";
10466 if (strcmp (r[2], expected) != 0) {
10467 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10472 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10477 char expected[] = "";
10478 if (strcmp (r[3], expected) != 0) {
10479 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10483 if (r[4] != NULL) {
10484 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10488 for (i = 0; r[i] != NULL; ++i)
10495 static int test_command_lines_6_skip (void)
10499 str = getenv ("TEST_ONLY");
10501 return strstr (str, "command_lines") == NULL;
10502 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10503 if (str && strcmp (str, "1") == 0) return 1;
10504 str = getenv ("SKIP_TEST_COMMAND_LINES");
10505 if (str && strcmp (str, "1") == 0) return 1;
10509 static int test_command_lines_6 (void)
10511 if (test_command_lines_6_skip ()) {
10512 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10516 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10518 char device[] = "/dev/sda";
10520 suppress_error = 0;
10521 r = guestfs_blockdev_setrw (g, device);
10527 suppress_error = 0;
10528 r = guestfs_umount_all (g);
10534 suppress_error = 0;
10535 r = guestfs_lvm_remove_all (g);
10540 char device[] = "/dev/sda";
10541 char lines_0[] = ",";
10547 suppress_error = 0;
10548 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10553 char fstype[] = "ext2";
10554 char device[] = "/dev/sda1";
10556 suppress_error = 0;
10557 r = guestfs_mkfs (g, fstype, device);
10562 char device[] = "/dev/sda1";
10563 char mountpoint[] = "/";
10565 suppress_error = 0;
10566 r = guestfs_mount (g, device, mountpoint);
10570 /* TestOutputList for command_lines (6) */
10572 char remotefilename[] = "/test-command";
10574 suppress_error = 0;
10575 r = guestfs_upload (g, "test-command", remotefilename);
10580 char path[] = "/test-command";
10582 suppress_error = 0;
10583 r = guestfs_chmod (g, 493, path);
10588 char arguments_0[] = "/test-command";
10589 char arguments_1[] = "7";
10590 char *arguments[] = {
10597 suppress_error = 0;
10598 r = guestfs_command_lines (g, arguments);
10601 if (r[0] != NULL) {
10602 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10606 for (i = 0; r[i] != NULL; ++i)
10613 static int test_command_lines_7_skip (void)
10617 str = getenv ("TEST_ONLY");
10619 return strstr (str, "command_lines") == NULL;
10620 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10621 if (str && strcmp (str, "1") == 0) return 1;
10622 str = getenv ("SKIP_TEST_COMMAND_LINES");
10623 if (str && strcmp (str, "1") == 0) return 1;
10627 static int test_command_lines_7 (void)
10629 if (test_command_lines_7_skip ()) {
10630 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10634 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10636 char device[] = "/dev/sda";
10638 suppress_error = 0;
10639 r = guestfs_blockdev_setrw (g, device);
10645 suppress_error = 0;
10646 r = guestfs_umount_all (g);
10652 suppress_error = 0;
10653 r = guestfs_lvm_remove_all (g);
10658 char device[] = "/dev/sda";
10659 char lines_0[] = ",";
10665 suppress_error = 0;
10666 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10671 char fstype[] = "ext2";
10672 char device[] = "/dev/sda1";
10674 suppress_error = 0;
10675 r = guestfs_mkfs (g, fstype, device);
10680 char device[] = "/dev/sda1";
10681 char mountpoint[] = "/";
10683 suppress_error = 0;
10684 r = guestfs_mount (g, device, mountpoint);
10688 /* TestOutputList for command_lines (7) */
10690 char remotefilename[] = "/test-command";
10692 suppress_error = 0;
10693 r = guestfs_upload (g, "test-command", remotefilename);
10698 char path[] = "/test-command";
10700 suppress_error = 0;
10701 r = guestfs_chmod (g, 493, path);
10706 char arguments_0[] = "/test-command";
10707 char arguments_1[] = "8";
10708 char *arguments[] = {
10715 suppress_error = 0;
10716 r = guestfs_command_lines (g, arguments);
10720 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10725 char expected[] = "";
10726 if (strcmp (r[0], expected) != 0) {
10727 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10731 if (r[1] != NULL) {
10732 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10736 for (i = 0; r[i] != NULL; ++i)
10743 static int test_command_lines_8_skip (void)
10747 str = getenv ("TEST_ONLY");
10749 return strstr (str, "command_lines") == NULL;
10750 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10751 if (str && strcmp (str, "1") == 0) return 1;
10752 str = getenv ("SKIP_TEST_COMMAND_LINES");
10753 if (str && strcmp (str, "1") == 0) return 1;
10757 static int test_command_lines_8 (void)
10759 if (test_command_lines_8_skip ()) {
10760 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10764 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10766 char device[] = "/dev/sda";
10768 suppress_error = 0;
10769 r = guestfs_blockdev_setrw (g, device);
10775 suppress_error = 0;
10776 r = guestfs_umount_all (g);
10782 suppress_error = 0;
10783 r = guestfs_lvm_remove_all (g);
10788 char device[] = "/dev/sda";
10789 char lines_0[] = ",";
10795 suppress_error = 0;
10796 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10801 char fstype[] = "ext2";
10802 char device[] = "/dev/sda1";
10804 suppress_error = 0;
10805 r = guestfs_mkfs (g, fstype, device);
10810 char device[] = "/dev/sda1";
10811 char mountpoint[] = "/";
10813 suppress_error = 0;
10814 r = guestfs_mount (g, device, mountpoint);
10818 /* TestOutputList for command_lines (8) */
10820 char remotefilename[] = "/test-command";
10822 suppress_error = 0;
10823 r = guestfs_upload (g, "test-command", remotefilename);
10828 char path[] = "/test-command";
10830 suppress_error = 0;
10831 r = guestfs_chmod (g, 493, path);
10836 char arguments_0[] = "/test-command";
10837 char arguments_1[] = "9";
10838 char *arguments[] = {
10845 suppress_error = 0;
10846 r = guestfs_command_lines (g, arguments);
10850 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10855 char expected[] = "";
10856 if (strcmp (r[0], expected) != 0) {
10857 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10862 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10867 char expected[] = "";
10868 if (strcmp (r[1], expected) != 0) {
10869 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10873 if (r[2] != NULL) {
10874 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10878 for (i = 0; r[i] != NULL; ++i)
10885 static int test_command_lines_9_skip (void)
10889 str = getenv ("TEST_ONLY");
10891 return strstr (str, "command_lines") == NULL;
10892 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10893 if (str && strcmp (str, "1") == 0) return 1;
10894 str = getenv ("SKIP_TEST_COMMAND_LINES");
10895 if (str && strcmp (str, "1") == 0) return 1;
10899 static int test_command_lines_9 (void)
10901 if (test_command_lines_9_skip ()) {
10902 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10906 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10908 char device[] = "/dev/sda";
10910 suppress_error = 0;
10911 r = guestfs_blockdev_setrw (g, device);
10917 suppress_error = 0;
10918 r = guestfs_umount_all (g);
10924 suppress_error = 0;
10925 r = guestfs_lvm_remove_all (g);
10930 char device[] = "/dev/sda";
10931 char lines_0[] = ",";
10937 suppress_error = 0;
10938 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10943 char fstype[] = "ext2";
10944 char device[] = "/dev/sda1";
10946 suppress_error = 0;
10947 r = guestfs_mkfs (g, fstype, device);
10952 char device[] = "/dev/sda1";
10953 char mountpoint[] = "/";
10955 suppress_error = 0;
10956 r = guestfs_mount (g, device, mountpoint);
10960 /* TestOutputList for command_lines (9) */
10962 char remotefilename[] = "/test-command";
10964 suppress_error = 0;
10965 r = guestfs_upload (g, "test-command", remotefilename);
10970 char path[] = "/test-command";
10972 suppress_error = 0;
10973 r = guestfs_chmod (g, 493, path);
10978 char arguments_0[] = "/test-command";
10979 char arguments_1[] = "10";
10980 char *arguments[] = {
10987 suppress_error = 0;
10988 r = guestfs_command_lines (g, arguments);
10992 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10997 char expected[] = "Result10-1";
10998 if (strcmp (r[0], expected) != 0) {
10999 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11004 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
11009 char expected[] = "Result10-2";
11010 if (strcmp (r[1], expected) != 0) {
11011 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11015 if (r[2] != NULL) {
11016 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
11020 for (i = 0; r[i] != NULL; ++i)
11027 static int test_command_lines_10_skip (void)
11031 str = getenv ("TEST_ONLY");
11033 return strstr (str, "command_lines") == NULL;
11034 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
11035 if (str && strcmp (str, "1") == 0) return 1;
11036 str = getenv ("SKIP_TEST_COMMAND_LINES");
11037 if (str && strcmp (str, "1") == 0) return 1;
11041 static int test_command_lines_10 (void)
11043 if (test_command_lines_10_skip ()) {
11044 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
11048 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
11050 char device[] = "/dev/sda";
11052 suppress_error = 0;
11053 r = guestfs_blockdev_setrw (g, device);
11059 suppress_error = 0;
11060 r = guestfs_umount_all (g);
11066 suppress_error = 0;
11067 r = guestfs_lvm_remove_all (g);
11072 char device[] = "/dev/sda";
11073 char lines_0[] = ",";
11079 suppress_error = 0;
11080 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11085 char fstype[] = "ext2";
11086 char device[] = "/dev/sda1";
11088 suppress_error = 0;
11089 r = guestfs_mkfs (g, fstype, device);
11094 char device[] = "/dev/sda1";
11095 char mountpoint[] = "/";
11097 suppress_error = 0;
11098 r = guestfs_mount (g, device, mountpoint);
11102 /* TestOutputList for command_lines (10) */
11104 char remotefilename[] = "/test-command";
11106 suppress_error = 0;
11107 r = guestfs_upload (g, "test-command", remotefilename);
11112 char path[] = "/test-command";
11114 suppress_error = 0;
11115 r = guestfs_chmod (g, 493, path);
11120 char arguments_0[] = "/test-command";
11121 char arguments_1[] = "11";
11122 char *arguments[] = {
11129 suppress_error = 0;
11130 r = guestfs_command_lines (g, arguments);
11134 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11139 char expected[] = "Result11-1";
11140 if (strcmp (r[0], expected) != 0) {
11141 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11146 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
11151 char expected[] = "Result11-2";
11152 if (strcmp (r[1], expected) != 0) {
11153 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11157 if (r[2] != NULL) {
11158 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11162 for (i = 0; r[i] != NULL; ++i)
11169 static int test_command_0_skip (void)
11173 str = getenv ("TEST_ONLY");
11175 return strstr (str, "command") == NULL;
11176 str = getenv ("SKIP_TEST_COMMAND_0");
11177 if (str && strcmp (str, "1") == 0) return 1;
11178 str = getenv ("SKIP_TEST_COMMAND");
11179 if (str && strcmp (str, "1") == 0) return 1;
11183 static int test_command_0 (void)
11185 if (test_command_0_skip ()) {
11186 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11190 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11192 char device[] = "/dev/sda";
11194 suppress_error = 0;
11195 r = guestfs_blockdev_setrw (g, device);
11201 suppress_error = 0;
11202 r = guestfs_umount_all (g);
11208 suppress_error = 0;
11209 r = guestfs_lvm_remove_all (g);
11214 char device[] = "/dev/sda";
11215 char lines_0[] = ",";
11221 suppress_error = 0;
11222 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11227 char fstype[] = "ext2";
11228 char device[] = "/dev/sda1";
11230 suppress_error = 0;
11231 r = guestfs_mkfs (g, fstype, device);
11236 char device[] = "/dev/sda1";
11237 char mountpoint[] = "/";
11239 suppress_error = 0;
11240 r = guestfs_mount (g, device, mountpoint);
11244 /* TestOutput for command (0) */
11245 char expected[] = "Result1";
11247 char remotefilename[] = "/test-command";
11249 suppress_error = 0;
11250 r = guestfs_upload (g, "test-command", remotefilename);
11255 char path[] = "/test-command";
11257 suppress_error = 0;
11258 r = guestfs_chmod (g, 493, path);
11263 char arguments_0[] = "/test-command";
11264 char arguments_1[] = "1";
11265 char *arguments[] = {
11271 suppress_error = 0;
11272 r = guestfs_command (g, arguments);
11275 if (strcmp (r, expected) != 0) {
11276 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11284 static int test_command_1_skip (void)
11288 str = getenv ("TEST_ONLY");
11290 return strstr (str, "command") == NULL;
11291 str = getenv ("SKIP_TEST_COMMAND_1");
11292 if (str && strcmp (str, "1") == 0) return 1;
11293 str = getenv ("SKIP_TEST_COMMAND");
11294 if (str && strcmp (str, "1") == 0) return 1;
11298 static int test_command_1 (void)
11300 if (test_command_1_skip ()) {
11301 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11305 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11307 char device[] = "/dev/sda";
11309 suppress_error = 0;
11310 r = guestfs_blockdev_setrw (g, device);
11316 suppress_error = 0;
11317 r = guestfs_umount_all (g);
11323 suppress_error = 0;
11324 r = guestfs_lvm_remove_all (g);
11329 char device[] = "/dev/sda";
11330 char lines_0[] = ",";
11336 suppress_error = 0;
11337 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11342 char fstype[] = "ext2";
11343 char device[] = "/dev/sda1";
11345 suppress_error = 0;
11346 r = guestfs_mkfs (g, fstype, device);
11351 char device[] = "/dev/sda1";
11352 char mountpoint[] = "/";
11354 suppress_error = 0;
11355 r = guestfs_mount (g, device, mountpoint);
11359 /* TestOutput for command (1) */
11360 char expected[] = "Result2\n";
11362 char remotefilename[] = "/test-command";
11364 suppress_error = 0;
11365 r = guestfs_upload (g, "test-command", remotefilename);
11370 char path[] = "/test-command";
11372 suppress_error = 0;
11373 r = guestfs_chmod (g, 493, path);
11378 char arguments_0[] = "/test-command";
11379 char arguments_1[] = "2";
11380 char *arguments[] = {
11386 suppress_error = 0;
11387 r = guestfs_command (g, arguments);
11390 if (strcmp (r, expected) != 0) {
11391 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11399 static int test_command_2_skip (void)
11403 str = getenv ("TEST_ONLY");
11405 return strstr (str, "command") == NULL;
11406 str = getenv ("SKIP_TEST_COMMAND_2");
11407 if (str && strcmp (str, "1") == 0) return 1;
11408 str = getenv ("SKIP_TEST_COMMAND");
11409 if (str && strcmp (str, "1") == 0) return 1;
11413 static int test_command_2 (void)
11415 if (test_command_2_skip ()) {
11416 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11420 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11422 char device[] = "/dev/sda";
11424 suppress_error = 0;
11425 r = guestfs_blockdev_setrw (g, device);
11431 suppress_error = 0;
11432 r = guestfs_umount_all (g);
11438 suppress_error = 0;
11439 r = guestfs_lvm_remove_all (g);
11444 char device[] = "/dev/sda";
11445 char lines_0[] = ",";
11451 suppress_error = 0;
11452 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11457 char fstype[] = "ext2";
11458 char device[] = "/dev/sda1";
11460 suppress_error = 0;
11461 r = guestfs_mkfs (g, fstype, device);
11466 char device[] = "/dev/sda1";
11467 char mountpoint[] = "/";
11469 suppress_error = 0;
11470 r = guestfs_mount (g, device, mountpoint);
11474 /* TestOutput for command (2) */
11475 char expected[] = "\nResult3";
11477 char remotefilename[] = "/test-command";
11479 suppress_error = 0;
11480 r = guestfs_upload (g, "test-command", remotefilename);
11485 char path[] = "/test-command";
11487 suppress_error = 0;
11488 r = guestfs_chmod (g, 493, path);
11493 char arguments_0[] = "/test-command";
11494 char arguments_1[] = "3";
11495 char *arguments[] = {
11501 suppress_error = 0;
11502 r = guestfs_command (g, arguments);
11505 if (strcmp (r, expected) != 0) {
11506 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11514 static int test_command_3_skip (void)
11518 str = getenv ("TEST_ONLY");
11520 return strstr (str, "command") == NULL;
11521 str = getenv ("SKIP_TEST_COMMAND_3");
11522 if (str && strcmp (str, "1") == 0) return 1;
11523 str = getenv ("SKIP_TEST_COMMAND");
11524 if (str && strcmp (str, "1") == 0) return 1;
11528 static int test_command_3 (void)
11530 if (test_command_3_skip ()) {
11531 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11535 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11537 char device[] = "/dev/sda";
11539 suppress_error = 0;
11540 r = guestfs_blockdev_setrw (g, device);
11546 suppress_error = 0;
11547 r = guestfs_umount_all (g);
11553 suppress_error = 0;
11554 r = guestfs_lvm_remove_all (g);
11559 char device[] = "/dev/sda";
11560 char lines_0[] = ",";
11566 suppress_error = 0;
11567 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11572 char fstype[] = "ext2";
11573 char device[] = "/dev/sda1";
11575 suppress_error = 0;
11576 r = guestfs_mkfs (g, fstype, device);
11581 char device[] = "/dev/sda1";
11582 char mountpoint[] = "/";
11584 suppress_error = 0;
11585 r = guestfs_mount (g, device, mountpoint);
11589 /* TestOutput for command (3) */
11590 char expected[] = "\nResult4\n";
11592 char remotefilename[] = "/test-command";
11594 suppress_error = 0;
11595 r = guestfs_upload (g, "test-command", remotefilename);
11600 char path[] = "/test-command";
11602 suppress_error = 0;
11603 r = guestfs_chmod (g, 493, path);
11608 char arguments_0[] = "/test-command";
11609 char arguments_1[] = "4";
11610 char *arguments[] = {
11616 suppress_error = 0;
11617 r = guestfs_command (g, arguments);
11620 if (strcmp (r, expected) != 0) {
11621 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11629 static int test_command_4_skip (void)
11633 str = getenv ("TEST_ONLY");
11635 return strstr (str, "command") == NULL;
11636 str = getenv ("SKIP_TEST_COMMAND_4");
11637 if (str && strcmp (str, "1") == 0) return 1;
11638 str = getenv ("SKIP_TEST_COMMAND");
11639 if (str && strcmp (str, "1") == 0) return 1;
11643 static int test_command_4 (void)
11645 if (test_command_4_skip ()) {
11646 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11650 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11652 char device[] = "/dev/sda";
11654 suppress_error = 0;
11655 r = guestfs_blockdev_setrw (g, device);
11661 suppress_error = 0;
11662 r = guestfs_umount_all (g);
11668 suppress_error = 0;
11669 r = guestfs_lvm_remove_all (g);
11674 char device[] = "/dev/sda";
11675 char lines_0[] = ",";
11681 suppress_error = 0;
11682 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11687 char fstype[] = "ext2";
11688 char device[] = "/dev/sda1";
11690 suppress_error = 0;
11691 r = guestfs_mkfs (g, fstype, device);
11696 char device[] = "/dev/sda1";
11697 char mountpoint[] = "/";
11699 suppress_error = 0;
11700 r = guestfs_mount (g, device, mountpoint);
11704 /* TestOutput for command (4) */
11705 char expected[] = "\nResult5\n\n";
11707 char remotefilename[] = "/test-command";
11709 suppress_error = 0;
11710 r = guestfs_upload (g, "test-command", remotefilename);
11715 char path[] = "/test-command";
11717 suppress_error = 0;
11718 r = guestfs_chmod (g, 493, path);
11723 char arguments_0[] = "/test-command";
11724 char arguments_1[] = "5";
11725 char *arguments[] = {
11731 suppress_error = 0;
11732 r = guestfs_command (g, arguments);
11735 if (strcmp (r, expected) != 0) {
11736 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11744 static int test_command_5_skip (void)
11748 str = getenv ("TEST_ONLY");
11750 return strstr (str, "command") == NULL;
11751 str = getenv ("SKIP_TEST_COMMAND_5");
11752 if (str && strcmp (str, "1") == 0) return 1;
11753 str = getenv ("SKIP_TEST_COMMAND");
11754 if (str && strcmp (str, "1") == 0) return 1;
11758 static int test_command_5 (void)
11760 if (test_command_5_skip ()) {
11761 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11765 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11767 char device[] = "/dev/sda";
11769 suppress_error = 0;
11770 r = guestfs_blockdev_setrw (g, device);
11776 suppress_error = 0;
11777 r = guestfs_umount_all (g);
11783 suppress_error = 0;
11784 r = guestfs_lvm_remove_all (g);
11789 char device[] = "/dev/sda";
11790 char lines_0[] = ",";
11796 suppress_error = 0;
11797 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11802 char fstype[] = "ext2";
11803 char device[] = "/dev/sda1";
11805 suppress_error = 0;
11806 r = guestfs_mkfs (g, fstype, device);
11811 char device[] = "/dev/sda1";
11812 char mountpoint[] = "/";
11814 suppress_error = 0;
11815 r = guestfs_mount (g, device, mountpoint);
11819 /* TestOutput for command (5) */
11820 char expected[] = "\n\nResult6\n\n";
11822 char remotefilename[] = "/test-command";
11824 suppress_error = 0;
11825 r = guestfs_upload (g, "test-command", remotefilename);
11830 char path[] = "/test-command";
11832 suppress_error = 0;
11833 r = guestfs_chmod (g, 493, path);
11838 char arguments_0[] = "/test-command";
11839 char arguments_1[] = "6";
11840 char *arguments[] = {
11846 suppress_error = 0;
11847 r = guestfs_command (g, arguments);
11850 if (strcmp (r, expected) != 0) {
11851 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11859 static int test_command_6_skip (void)
11863 str = getenv ("TEST_ONLY");
11865 return strstr (str, "command") == NULL;
11866 str = getenv ("SKIP_TEST_COMMAND_6");
11867 if (str && strcmp (str, "1") == 0) return 1;
11868 str = getenv ("SKIP_TEST_COMMAND");
11869 if (str && strcmp (str, "1") == 0) return 1;
11873 static int test_command_6 (void)
11875 if (test_command_6_skip ()) {
11876 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11880 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11882 char device[] = "/dev/sda";
11884 suppress_error = 0;
11885 r = guestfs_blockdev_setrw (g, device);
11891 suppress_error = 0;
11892 r = guestfs_umount_all (g);
11898 suppress_error = 0;
11899 r = guestfs_lvm_remove_all (g);
11904 char device[] = "/dev/sda";
11905 char lines_0[] = ",";
11911 suppress_error = 0;
11912 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11917 char fstype[] = "ext2";
11918 char device[] = "/dev/sda1";
11920 suppress_error = 0;
11921 r = guestfs_mkfs (g, fstype, device);
11926 char device[] = "/dev/sda1";
11927 char mountpoint[] = "/";
11929 suppress_error = 0;
11930 r = guestfs_mount (g, device, mountpoint);
11934 /* TestOutput for command (6) */
11935 char expected[] = "";
11937 char remotefilename[] = "/test-command";
11939 suppress_error = 0;
11940 r = guestfs_upload (g, "test-command", remotefilename);
11945 char path[] = "/test-command";
11947 suppress_error = 0;
11948 r = guestfs_chmod (g, 493, path);
11953 char arguments_0[] = "/test-command";
11954 char arguments_1[] = "7";
11955 char *arguments[] = {
11961 suppress_error = 0;
11962 r = guestfs_command (g, arguments);
11965 if (strcmp (r, expected) != 0) {
11966 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11974 static int test_command_7_skip (void)
11978 str = getenv ("TEST_ONLY");
11980 return strstr (str, "command") == NULL;
11981 str = getenv ("SKIP_TEST_COMMAND_7");
11982 if (str && strcmp (str, "1") == 0) return 1;
11983 str = getenv ("SKIP_TEST_COMMAND");
11984 if (str && strcmp (str, "1") == 0) return 1;
11988 static int test_command_7 (void)
11990 if (test_command_7_skip ()) {
11991 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11995 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11997 char device[] = "/dev/sda";
11999 suppress_error = 0;
12000 r = guestfs_blockdev_setrw (g, device);
12006 suppress_error = 0;
12007 r = guestfs_umount_all (g);
12013 suppress_error = 0;
12014 r = guestfs_lvm_remove_all (g);
12019 char device[] = "/dev/sda";
12020 char lines_0[] = ",";
12026 suppress_error = 0;
12027 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12032 char fstype[] = "ext2";
12033 char device[] = "/dev/sda1";
12035 suppress_error = 0;
12036 r = guestfs_mkfs (g, fstype, device);
12041 char device[] = "/dev/sda1";
12042 char mountpoint[] = "/";
12044 suppress_error = 0;
12045 r = guestfs_mount (g, device, mountpoint);
12049 /* TestOutput for command (7) */
12050 char expected[] = "\n";
12052 char remotefilename[] = "/test-command";
12054 suppress_error = 0;
12055 r = guestfs_upload (g, "test-command", remotefilename);
12060 char path[] = "/test-command";
12062 suppress_error = 0;
12063 r = guestfs_chmod (g, 493, path);
12068 char arguments_0[] = "/test-command";
12069 char arguments_1[] = "8";
12070 char *arguments[] = {
12076 suppress_error = 0;
12077 r = guestfs_command (g, arguments);
12080 if (strcmp (r, expected) != 0) {
12081 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
12089 static int test_command_8_skip (void)
12093 str = getenv ("TEST_ONLY");
12095 return strstr (str, "command") == NULL;
12096 str = getenv ("SKIP_TEST_COMMAND_8");
12097 if (str && strcmp (str, "1") == 0) return 1;
12098 str = getenv ("SKIP_TEST_COMMAND");
12099 if (str && strcmp (str, "1") == 0) return 1;
12103 static int test_command_8 (void)
12105 if (test_command_8_skip ()) {
12106 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
12110 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
12112 char device[] = "/dev/sda";
12114 suppress_error = 0;
12115 r = guestfs_blockdev_setrw (g, device);
12121 suppress_error = 0;
12122 r = guestfs_umount_all (g);
12128 suppress_error = 0;
12129 r = guestfs_lvm_remove_all (g);
12134 char device[] = "/dev/sda";
12135 char lines_0[] = ",";
12141 suppress_error = 0;
12142 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12147 char fstype[] = "ext2";
12148 char device[] = "/dev/sda1";
12150 suppress_error = 0;
12151 r = guestfs_mkfs (g, fstype, device);
12156 char device[] = "/dev/sda1";
12157 char mountpoint[] = "/";
12159 suppress_error = 0;
12160 r = guestfs_mount (g, device, mountpoint);
12164 /* TestOutput for command (8) */
12165 char expected[] = "\n\n";
12167 char remotefilename[] = "/test-command";
12169 suppress_error = 0;
12170 r = guestfs_upload (g, "test-command", remotefilename);
12175 char path[] = "/test-command";
12177 suppress_error = 0;
12178 r = guestfs_chmod (g, 493, path);
12183 char arguments_0[] = "/test-command";
12184 char arguments_1[] = "9";
12185 char *arguments[] = {
12191 suppress_error = 0;
12192 r = guestfs_command (g, arguments);
12195 if (strcmp (r, expected) != 0) {
12196 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12204 static int test_command_9_skip (void)
12208 str = getenv ("TEST_ONLY");
12210 return strstr (str, "command") == NULL;
12211 str = getenv ("SKIP_TEST_COMMAND_9");
12212 if (str && strcmp (str, "1") == 0) return 1;
12213 str = getenv ("SKIP_TEST_COMMAND");
12214 if (str && strcmp (str, "1") == 0) return 1;
12218 static int test_command_9 (void)
12220 if (test_command_9_skip ()) {
12221 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12225 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12227 char device[] = "/dev/sda";
12229 suppress_error = 0;
12230 r = guestfs_blockdev_setrw (g, device);
12236 suppress_error = 0;
12237 r = guestfs_umount_all (g);
12243 suppress_error = 0;
12244 r = guestfs_lvm_remove_all (g);
12249 char device[] = "/dev/sda";
12250 char lines_0[] = ",";
12256 suppress_error = 0;
12257 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12262 char fstype[] = "ext2";
12263 char device[] = "/dev/sda1";
12265 suppress_error = 0;
12266 r = guestfs_mkfs (g, fstype, device);
12271 char device[] = "/dev/sda1";
12272 char mountpoint[] = "/";
12274 suppress_error = 0;
12275 r = guestfs_mount (g, device, mountpoint);
12279 /* TestOutput for command (9) */
12280 char expected[] = "Result10-1\nResult10-2\n";
12282 char remotefilename[] = "/test-command";
12284 suppress_error = 0;
12285 r = guestfs_upload (g, "test-command", remotefilename);
12290 char path[] = "/test-command";
12292 suppress_error = 0;
12293 r = guestfs_chmod (g, 493, path);
12298 char arguments_0[] = "/test-command";
12299 char arguments_1[] = "10";
12300 char *arguments[] = {
12306 suppress_error = 0;
12307 r = guestfs_command (g, arguments);
12310 if (strcmp (r, expected) != 0) {
12311 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12319 static int test_command_10_skip (void)
12323 str = getenv ("TEST_ONLY");
12325 return strstr (str, "command") == NULL;
12326 str = getenv ("SKIP_TEST_COMMAND_10");
12327 if (str && strcmp (str, "1") == 0) return 1;
12328 str = getenv ("SKIP_TEST_COMMAND");
12329 if (str && strcmp (str, "1") == 0) return 1;
12333 static int test_command_10 (void)
12335 if (test_command_10_skip ()) {
12336 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12340 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12342 char device[] = "/dev/sda";
12344 suppress_error = 0;
12345 r = guestfs_blockdev_setrw (g, device);
12351 suppress_error = 0;
12352 r = guestfs_umount_all (g);
12358 suppress_error = 0;
12359 r = guestfs_lvm_remove_all (g);
12364 char device[] = "/dev/sda";
12365 char lines_0[] = ",";
12371 suppress_error = 0;
12372 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12377 char fstype[] = "ext2";
12378 char device[] = "/dev/sda1";
12380 suppress_error = 0;
12381 r = guestfs_mkfs (g, fstype, device);
12386 char device[] = "/dev/sda1";
12387 char mountpoint[] = "/";
12389 suppress_error = 0;
12390 r = guestfs_mount (g, device, mountpoint);
12394 /* TestOutput for command (10) */
12395 char expected[] = "Result11-1\nResult11-2";
12397 char remotefilename[] = "/test-command";
12399 suppress_error = 0;
12400 r = guestfs_upload (g, "test-command", remotefilename);
12405 char path[] = "/test-command";
12407 suppress_error = 0;
12408 r = guestfs_chmod (g, 493, path);
12413 char arguments_0[] = "/test-command";
12414 char arguments_1[] = "11";
12415 char *arguments[] = {
12421 suppress_error = 0;
12422 r = guestfs_command (g, arguments);
12425 if (strcmp (r, expected) != 0) {
12426 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12434 static int test_command_11_skip (void)
12438 str = getenv ("TEST_ONLY");
12440 return strstr (str, "command") == NULL;
12441 str = getenv ("SKIP_TEST_COMMAND_11");
12442 if (str && strcmp (str, "1") == 0) return 1;
12443 str = getenv ("SKIP_TEST_COMMAND");
12444 if (str && strcmp (str, "1") == 0) return 1;
12448 static int test_command_11 (void)
12450 if (test_command_11_skip ()) {
12451 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12455 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12457 char device[] = "/dev/sda";
12459 suppress_error = 0;
12460 r = guestfs_blockdev_setrw (g, device);
12466 suppress_error = 0;
12467 r = guestfs_umount_all (g);
12473 suppress_error = 0;
12474 r = guestfs_lvm_remove_all (g);
12479 char device[] = "/dev/sda";
12480 char lines_0[] = ",";
12486 suppress_error = 0;
12487 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12492 char fstype[] = "ext2";
12493 char device[] = "/dev/sda1";
12495 suppress_error = 0;
12496 r = guestfs_mkfs (g, fstype, device);
12501 char device[] = "/dev/sda1";
12502 char mountpoint[] = "/";
12504 suppress_error = 0;
12505 r = guestfs_mount (g, device, mountpoint);
12509 /* TestLastFail for command (11) */
12511 char remotefilename[] = "/test-command";
12513 suppress_error = 0;
12514 r = guestfs_upload (g, "test-command", remotefilename);
12519 char path[] = "/test-command";
12521 suppress_error = 0;
12522 r = guestfs_chmod (g, 493, path);
12527 char arguments_0[] = "/test-command";
12528 char *arguments[] = {
12533 suppress_error = 1;
12534 r = guestfs_command (g, arguments);
12542 static int test_file_0_skip (void)
12546 str = getenv ("TEST_ONLY");
12548 return strstr (str, "file") == NULL;
12549 str = getenv ("SKIP_TEST_FILE_0");
12550 if (str && strcmp (str, "1") == 0) return 1;
12551 str = getenv ("SKIP_TEST_FILE");
12552 if (str && strcmp (str, "1") == 0) return 1;
12556 static int test_file_0 (void)
12558 if (test_file_0_skip ()) {
12559 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12563 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12565 char device[] = "/dev/sda";
12567 suppress_error = 0;
12568 r = guestfs_blockdev_setrw (g, device);
12574 suppress_error = 0;
12575 r = guestfs_umount_all (g);
12581 suppress_error = 0;
12582 r = guestfs_lvm_remove_all (g);
12587 char device[] = "/dev/sda";
12588 char lines_0[] = ",";
12594 suppress_error = 0;
12595 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12600 char fstype[] = "ext2";
12601 char device[] = "/dev/sda1";
12603 suppress_error = 0;
12604 r = guestfs_mkfs (g, fstype, device);
12609 char device[] = "/dev/sda1";
12610 char mountpoint[] = "/";
12612 suppress_error = 0;
12613 r = guestfs_mount (g, device, mountpoint);
12617 /* TestOutput for file (0) */
12618 char expected[] = "empty";
12620 char path[] = "/new";
12622 suppress_error = 0;
12623 r = guestfs_touch (g, path);
12628 char path[] = "/new";
12630 suppress_error = 0;
12631 r = guestfs_file (g, path);
12634 if (strcmp (r, expected) != 0) {
12635 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12643 static int test_file_1_skip (void)
12647 str = getenv ("TEST_ONLY");
12649 return strstr (str, "file") == NULL;
12650 str = getenv ("SKIP_TEST_FILE_1");
12651 if (str && strcmp (str, "1") == 0) return 1;
12652 str = getenv ("SKIP_TEST_FILE");
12653 if (str && strcmp (str, "1") == 0) return 1;
12657 static int test_file_1 (void)
12659 if (test_file_1_skip ()) {
12660 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12664 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12666 char device[] = "/dev/sda";
12668 suppress_error = 0;
12669 r = guestfs_blockdev_setrw (g, device);
12675 suppress_error = 0;
12676 r = guestfs_umount_all (g);
12682 suppress_error = 0;
12683 r = guestfs_lvm_remove_all (g);
12688 char device[] = "/dev/sda";
12689 char lines_0[] = ",";
12695 suppress_error = 0;
12696 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12701 char fstype[] = "ext2";
12702 char device[] = "/dev/sda1";
12704 suppress_error = 0;
12705 r = guestfs_mkfs (g, fstype, device);
12710 char device[] = "/dev/sda1";
12711 char mountpoint[] = "/";
12713 suppress_error = 0;
12714 r = guestfs_mount (g, device, mountpoint);
12718 /* TestOutput for file (1) */
12719 char expected[] = "ASCII text";
12721 char path[] = "/new";
12722 char content[] = "some content\n";
12724 suppress_error = 0;
12725 r = guestfs_write_file (g, path, content, 0);
12730 char path[] = "/new";
12732 suppress_error = 0;
12733 r = guestfs_file (g, path);
12736 if (strcmp (r, expected) != 0) {
12737 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12745 static int test_file_2_skip (void)
12749 str = getenv ("TEST_ONLY");
12751 return strstr (str, "file") == NULL;
12752 str = getenv ("SKIP_TEST_FILE_2");
12753 if (str && strcmp (str, "1") == 0) return 1;
12754 str = getenv ("SKIP_TEST_FILE");
12755 if (str && strcmp (str, "1") == 0) return 1;
12759 static int test_file_2 (void)
12761 if (test_file_2_skip ()) {
12762 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12766 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12768 char device[] = "/dev/sda";
12770 suppress_error = 0;
12771 r = guestfs_blockdev_setrw (g, device);
12777 suppress_error = 0;
12778 r = guestfs_umount_all (g);
12784 suppress_error = 0;
12785 r = guestfs_lvm_remove_all (g);
12790 char device[] = "/dev/sda";
12791 char lines_0[] = ",";
12797 suppress_error = 0;
12798 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12803 char fstype[] = "ext2";
12804 char device[] = "/dev/sda1";
12806 suppress_error = 0;
12807 r = guestfs_mkfs (g, fstype, device);
12812 char device[] = "/dev/sda1";
12813 char mountpoint[] = "/";
12815 suppress_error = 0;
12816 r = guestfs_mount (g, device, mountpoint);
12820 /* TestLastFail for file (2) */
12822 char path[] = "/nofile";
12824 suppress_error = 1;
12825 r = guestfs_file (g, path);
12833 static int test_umount_all_0_skip (void)
12837 str = getenv ("TEST_ONLY");
12839 return strstr (str, "umount_all") == NULL;
12840 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12841 if (str && strcmp (str, "1") == 0) return 1;
12842 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12843 if (str && strcmp (str, "1") == 0) return 1;
12847 static int test_umount_all_0 (void)
12849 if (test_umount_all_0_skip ()) {
12850 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12854 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12856 char device[] = "/dev/sda";
12858 suppress_error = 0;
12859 r = guestfs_blockdev_setrw (g, device);
12865 suppress_error = 0;
12866 r = guestfs_umount_all (g);
12872 suppress_error = 0;
12873 r = guestfs_lvm_remove_all (g);
12878 char device[] = "/dev/sda";
12879 char lines_0[] = ",";
12885 suppress_error = 0;
12886 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12891 char fstype[] = "ext2";
12892 char device[] = "/dev/sda1";
12894 suppress_error = 0;
12895 r = guestfs_mkfs (g, fstype, device);
12900 char device[] = "/dev/sda1";
12901 char mountpoint[] = "/";
12903 suppress_error = 0;
12904 r = guestfs_mount (g, device, mountpoint);
12908 /* TestOutputList for umount_all (0) */
12911 suppress_error = 0;
12912 r = guestfs_umount_all (g);
12919 suppress_error = 0;
12920 r = guestfs_mounts (g);
12923 if (r[0] != NULL) {
12924 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12928 for (i = 0; r[i] != NULL; ++i)
12935 static int test_umount_all_1_skip (void)
12939 str = getenv ("TEST_ONLY");
12941 return strstr (str, "umount_all") == NULL;
12942 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12943 if (str && strcmp (str, "1") == 0) return 1;
12944 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12945 if (str && strcmp (str, "1") == 0) return 1;
12949 static int test_umount_all_1 (void)
12951 if (test_umount_all_1_skip ()) {
12952 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12956 /* InitNone|InitEmpty for test_umount_all_1 */
12958 char device[] = "/dev/sda";
12960 suppress_error = 0;
12961 r = guestfs_blockdev_setrw (g, device);
12967 suppress_error = 0;
12968 r = guestfs_umount_all (g);
12974 suppress_error = 0;
12975 r = guestfs_lvm_remove_all (g);
12979 /* TestOutputList for umount_all (1) */
12981 char device[] = "/dev/sda";
12982 char lines_0[] = ",10";
12983 char lines_1[] = ",20";
12984 char lines_2[] = ",";
12992 suppress_error = 0;
12993 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12998 char fstype[] = "ext2";
12999 char device[] = "/dev/sda1";
13001 suppress_error = 0;
13002 r = guestfs_mkfs (g, fstype, device);
13007 char fstype[] = "ext2";
13008 char device[] = "/dev/sda2";
13010 suppress_error = 0;
13011 r = guestfs_mkfs (g, fstype, device);
13016 char fstype[] = "ext2";
13017 char device[] = "/dev/sda3";
13019 suppress_error = 0;
13020 r = guestfs_mkfs (g, fstype, device);
13025 char device[] = "/dev/sda1";
13026 char mountpoint[] = "/";
13028 suppress_error = 0;
13029 r = guestfs_mount (g, device, mountpoint);
13034 char path[] = "/mp1";
13036 suppress_error = 0;
13037 r = guestfs_mkdir (g, path);
13042 char device[] = "/dev/sda2";
13043 char mountpoint[] = "/mp1";
13045 suppress_error = 0;
13046 r = guestfs_mount (g, device, mountpoint);
13051 char path[] = "/mp1/mp2";
13053 suppress_error = 0;
13054 r = guestfs_mkdir (g, path);
13059 char device[] = "/dev/sda3";
13060 char mountpoint[] = "/mp1/mp2";
13062 suppress_error = 0;
13063 r = guestfs_mount (g, device, mountpoint);
13068 char path[] = "/mp1/mp2/mp3";
13070 suppress_error = 0;
13071 r = guestfs_mkdir (g, path);
13077 suppress_error = 0;
13078 r = guestfs_umount_all (g);
13085 suppress_error = 0;
13086 r = guestfs_mounts (g);
13089 if (r[0] != NULL) {
13090 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
13094 for (i = 0; r[i] != NULL; ++i)
13101 static int test_mounts_0_skip (void)
13105 str = getenv ("TEST_ONLY");
13107 return strstr (str, "mounts") == NULL;
13108 str = getenv ("SKIP_TEST_MOUNTS_0");
13109 if (str && strcmp (str, "1") == 0) return 1;
13110 str = getenv ("SKIP_TEST_MOUNTS");
13111 if (str && strcmp (str, "1") == 0) return 1;
13115 static int test_mounts_0 (void)
13117 if (test_mounts_0_skip ()) {
13118 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
13122 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
13124 char device[] = "/dev/sda";
13126 suppress_error = 0;
13127 r = guestfs_blockdev_setrw (g, device);
13133 suppress_error = 0;
13134 r = guestfs_umount_all (g);
13140 suppress_error = 0;
13141 r = guestfs_lvm_remove_all (g);
13146 char device[] = "/dev/sda";
13147 char lines_0[] = ",";
13153 suppress_error = 0;
13154 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13159 char fstype[] = "ext2";
13160 char device[] = "/dev/sda1";
13162 suppress_error = 0;
13163 r = guestfs_mkfs (g, fstype, device);
13168 char device[] = "/dev/sda1";
13169 char mountpoint[] = "/";
13171 suppress_error = 0;
13172 r = guestfs_mount (g, device, mountpoint);
13176 /* TestOutputListOfDevices for mounts (0) */
13180 suppress_error = 0;
13181 r = guestfs_mounts (g);
13185 fprintf (stderr, "test_mounts_0: short list returned from command\n");
13190 char expected[] = "/dev/sda1";
13192 if (strcmp (r[0], expected) != 0) {
13193 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13197 if (r[1] != NULL) {
13198 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13202 for (i = 0; r[i] != NULL; ++i)
13209 static int test_umount_0_skip (void)
13213 str = getenv ("TEST_ONLY");
13215 return strstr (str, "umount") == NULL;
13216 str = getenv ("SKIP_TEST_UMOUNT_0");
13217 if (str && strcmp (str, "1") == 0) return 1;
13218 str = getenv ("SKIP_TEST_UMOUNT");
13219 if (str && strcmp (str, "1") == 0) return 1;
13223 static int test_umount_0 (void)
13225 if (test_umount_0_skip ()) {
13226 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13230 /* InitNone|InitEmpty for test_umount_0 */
13232 char device[] = "/dev/sda";
13234 suppress_error = 0;
13235 r = guestfs_blockdev_setrw (g, device);
13241 suppress_error = 0;
13242 r = guestfs_umount_all (g);
13248 suppress_error = 0;
13249 r = guestfs_lvm_remove_all (g);
13253 /* TestOutputListOfDevices for umount (0) */
13255 char device[] = "/dev/sda";
13256 char lines_0[] = ",";
13262 suppress_error = 0;
13263 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13268 char fstype[] = "ext2";
13269 char device[] = "/dev/sda1";
13271 suppress_error = 0;
13272 r = guestfs_mkfs (g, fstype, device);
13277 char device[] = "/dev/sda1";
13278 char mountpoint[] = "/";
13280 suppress_error = 0;
13281 r = guestfs_mount (g, device, mountpoint);
13288 suppress_error = 0;
13289 r = guestfs_mounts (g);
13293 fprintf (stderr, "test_umount_0: short list returned from command\n");
13298 char expected[] = "/dev/sda1";
13300 if (strcmp (r[0], expected) != 0) {
13301 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13305 if (r[1] != NULL) {
13306 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13310 for (i = 0; r[i] != NULL; ++i)
13317 static int test_umount_1_skip (void)
13321 str = getenv ("TEST_ONLY");
13323 return strstr (str, "umount") == NULL;
13324 str = getenv ("SKIP_TEST_UMOUNT_1");
13325 if (str && strcmp (str, "1") == 0) return 1;
13326 str = getenv ("SKIP_TEST_UMOUNT");
13327 if (str && strcmp (str, "1") == 0) return 1;
13331 static int test_umount_1 (void)
13333 if (test_umount_1_skip ()) {
13334 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13338 /* InitNone|InitEmpty for test_umount_1 */
13340 char device[] = "/dev/sda";
13342 suppress_error = 0;
13343 r = guestfs_blockdev_setrw (g, device);
13349 suppress_error = 0;
13350 r = guestfs_umount_all (g);
13356 suppress_error = 0;
13357 r = guestfs_lvm_remove_all (g);
13361 /* TestOutputList for umount (1) */
13363 char device[] = "/dev/sda";
13364 char lines_0[] = ",";
13370 suppress_error = 0;
13371 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13376 char fstype[] = "ext2";
13377 char device[] = "/dev/sda1";
13379 suppress_error = 0;
13380 r = guestfs_mkfs (g, fstype, device);
13385 char device[] = "/dev/sda1";
13386 char mountpoint[] = "/";
13388 suppress_error = 0;
13389 r = guestfs_mount (g, device, mountpoint);
13394 char pathordevice[] = "/";
13396 suppress_error = 0;
13397 r = guestfs_umount (g, pathordevice);
13404 suppress_error = 0;
13405 r = guestfs_mounts (g);
13408 if (r[0] != NULL) {
13409 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13413 for (i = 0; r[i] != NULL; ++i)
13420 static int test_write_file_0_skip (void)
13424 str = getenv ("TEST_ONLY");
13426 return strstr (str, "write_file") == NULL;
13427 str = getenv ("SKIP_TEST_WRITE_FILE_0");
13428 if (str && strcmp (str, "1") == 0) return 1;
13429 str = getenv ("SKIP_TEST_WRITE_FILE");
13430 if (str && strcmp (str, "1") == 0) return 1;
13434 static int test_write_file_0 (void)
13436 if (test_write_file_0_skip ()) {
13437 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13441 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
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);
13465 char device[] = "/dev/sda";
13466 char lines_0[] = ",";
13472 suppress_error = 0;
13473 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13478 char fstype[] = "ext2";
13479 char device[] = "/dev/sda1";
13481 suppress_error = 0;
13482 r = guestfs_mkfs (g, fstype, device);
13487 char device[] = "/dev/sda1";
13488 char mountpoint[] = "/";
13490 suppress_error = 0;
13491 r = guestfs_mount (g, device, mountpoint);
13495 /* TestOutput for write_file (0) */
13496 char expected[] = "new file contents";
13498 char path[] = "/new";
13499 char content[] = "new file contents";
13501 suppress_error = 0;
13502 r = guestfs_write_file (g, path, content, 0);
13507 char path[] = "/new";
13509 suppress_error = 0;
13510 r = guestfs_cat (g, path);
13513 if (strcmp (r, expected) != 0) {
13514 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13522 static int test_write_file_1_skip (void)
13526 str = getenv ("TEST_ONLY");
13528 return strstr (str, "write_file") == NULL;
13529 str = getenv ("SKIP_TEST_WRITE_FILE_1");
13530 if (str && strcmp (str, "1") == 0) return 1;
13531 str = getenv ("SKIP_TEST_WRITE_FILE");
13532 if (str && strcmp (str, "1") == 0) return 1;
13536 static int test_write_file_1 (void)
13538 if (test_write_file_1_skip ()) {
13539 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13543 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13545 char device[] = "/dev/sda";
13547 suppress_error = 0;
13548 r = guestfs_blockdev_setrw (g, device);
13554 suppress_error = 0;
13555 r = guestfs_umount_all (g);
13561 suppress_error = 0;
13562 r = guestfs_lvm_remove_all (g);
13567 char device[] = "/dev/sda";
13568 char lines_0[] = ",";
13574 suppress_error = 0;
13575 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13580 char fstype[] = "ext2";
13581 char device[] = "/dev/sda1";
13583 suppress_error = 0;
13584 r = guestfs_mkfs (g, fstype, device);
13589 char device[] = "/dev/sda1";
13590 char mountpoint[] = "/";
13592 suppress_error = 0;
13593 r = guestfs_mount (g, device, mountpoint);
13597 /* TestOutput for write_file (1) */
13598 char expected[] = "\nnew file contents\n";
13600 char path[] = "/new";
13601 char content[] = "\nnew file contents\n";
13603 suppress_error = 0;
13604 r = guestfs_write_file (g, path, content, 0);
13609 char path[] = "/new";
13611 suppress_error = 0;
13612 r = guestfs_cat (g, path);
13615 if (strcmp (r, expected) != 0) {
13616 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13624 static int test_write_file_2_skip (void)
13628 str = getenv ("TEST_ONLY");
13630 return strstr (str, "write_file") == NULL;
13631 str = getenv ("SKIP_TEST_WRITE_FILE_2");
13632 if (str && strcmp (str, "1") == 0) return 1;
13633 str = getenv ("SKIP_TEST_WRITE_FILE");
13634 if (str && strcmp (str, "1") == 0) return 1;
13638 static int test_write_file_2 (void)
13640 if (test_write_file_2_skip ()) {
13641 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13645 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13647 char device[] = "/dev/sda";
13649 suppress_error = 0;
13650 r = guestfs_blockdev_setrw (g, device);
13656 suppress_error = 0;
13657 r = guestfs_umount_all (g);
13663 suppress_error = 0;
13664 r = guestfs_lvm_remove_all (g);
13669 char device[] = "/dev/sda";
13670 char lines_0[] = ",";
13676 suppress_error = 0;
13677 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13682 char fstype[] = "ext2";
13683 char device[] = "/dev/sda1";
13685 suppress_error = 0;
13686 r = guestfs_mkfs (g, fstype, device);
13691 char device[] = "/dev/sda1";
13692 char mountpoint[] = "/";
13694 suppress_error = 0;
13695 r = guestfs_mount (g, device, mountpoint);
13699 /* TestOutput for write_file (2) */
13700 char expected[] = "\n\n";
13702 char path[] = "/new";
13703 char content[] = "\n\n";
13705 suppress_error = 0;
13706 r = guestfs_write_file (g, path, content, 0);
13711 char path[] = "/new";
13713 suppress_error = 0;
13714 r = guestfs_cat (g, path);
13717 if (strcmp (r, expected) != 0) {
13718 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13726 static int test_write_file_3_skip (void)
13730 str = getenv ("TEST_ONLY");
13732 return strstr (str, "write_file") == NULL;
13733 str = getenv ("SKIP_TEST_WRITE_FILE_3");
13734 if (str && strcmp (str, "1") == 0) return 1;
13735 str = getenv ("SKIP_TEST_WRITE_FILE");
13736 if (str && strcmp (str, "1") == 0) return 1;
13740 static int test_write_file_3 (void)
13742 if (test_write_file_3_skip ()) {
13743 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13747 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13749 char device[] = "/dev/sda";
13751 suppress_error = 0;
13752 r = guestfs_blockdev_setrw (g, device);
13758 suppress_error = 0;
13759 r = guestfs_umount_all (g);
13765 suppress_error = 0;
13766 r = guestfs_lvm_remove_all (g);
13771 char device[] = "/dev/sda";
13772 char lines_0[] = ",";
13778 suppress_error = 0;
13779 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13784 char fstype[] = "ext2";
13785 char device[] = "/dev/sda1";
13787 suppress_error = 0;
13788 r = guestfs_mkfs (g, fstype, device);
13793 char device[] = "/dev/sda1";
13794 char mountpoint[] = "/";
13796 suppress_error = 0;
13797 r = guestfs_mount (g, device, mountpoint);
13801 /* TestOutput for write_file (3) */
13802 char expected[] = "";
13804 char path[] = "/new";
13805 char content[] = "";
13807 suppress_error = 0;
13808 r = guestfs_write_file (g, path, content, 0);
13813 char path[] = "/new";
13815 suppress_error = 0;
13816 r = guestfs_cat (g, path);
13819 if (strcmp (r, expected) != 0) {
13820 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13828 static int test_write_file_4_skip (void)
13832 str = getenv ("TEST_ONLY");
13834 return strstr (str, "write_file") == NULL;
13835 str = getenv ("SKIP_TEST_WRITE_FILE_4");
13836 if (str && strcmp (str, "1") == 0) return 1;
13837 str = getenv ("SKIP_TEST_WRITE_FILE");
13838 if (str && strcmp (str, "1") == 0) return 1;
13842 static int test_write_file_4 (void)
13844 if (test_write_file_4_skip ()) {
13845 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13849 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13851 char device[] = "/dev/sda";
13853 suppress_error = 0;
13854 r = guestfs_blockdev_setrw (g, device);
13860 suppress_error = 0;
13861 r = guestfs_umount_all (g);
13867 suppress_error = 0;
13868 r = guestfs_lvm_remove_all (g);
13873 char device[] = "/dev/sda";
13874 char lines_0[] = ",";
13880 suppress_error = 0;
13881 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13886 char fstype[] = "ext2";
13887 char device[] = "/dev/sda1";
13889 suppress_error = 0;
13890 r = guestfs_mkfs (g, fstype, device);
13895 char device[] = "/dev/sda1";
13896 char mountpoint[] = "/";
13898 suppress_error = 0;
13899 r = guestfs_mount (g, device, mountpoint);
13903 /* TestOutput for write_file (4) */
13904 char expected[] = "\n\n\n";
13906 char path[] = "/new";
13907 char content[] = "\n\n\n";
13909 suppress_error = 0;
13910 r = guestfs_write_file (g, path, content, 0);
13915 char path[] = "/new";
13917 suppress_error = 0;
13918 r = guestfs_cat (g, path);
13921 if (strcmp (r, expected) != 0) {
13922 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13930 static int test_write_file_5_skip (void)
13934 str = getenv ("TEST_ONLY");
13936 return strstr (str, "write_file") == NULL;
13937 str = getenv ("SKIP_TEST_WRITE_FILE_5");
13938 if (str && strcmp (str, "1") == 0) return 1;
13939 str = getenv ("SKIP_TEST_WRITE_FILE");
13940 if (str && strcmp (str, "1") == 0) return 1;
13944 static int test_write_file_5 (void)
13946 if (test_write_file_5_skip ()) {
13947 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13951 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13953 char device[] = "/dev/sda";
13955 suppress_error = 0;
13956 r = guestfs_blockdev_setrw (g, device);
13962 suppress_error = 0;
13963 r = guestfs_umount_all (g);
13969 suppress_error = 0;
13970 r = guestfs_lvm_remove_all (g);
13975 char device[] = "/dev/sda";
13976 char lines_0[] = ",";
13982 suppress_error = 0;
13983 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13988 char fstype[] = "ext2";
13989 char device[] = "/dev/sda1";
13991 suppress_error = 0;
13992 r = guestfs_mkfs (g, fstype, device);
13997 char device[] = "/dev/sda1";
13998 char mountpoint[] = "/";
14000 suppress_error = 0;
14001 r = guestfs_mount (g, device, mountpoint);
14005 /* TestOutput for write_file (5) */
14006 char expected[] = "\n";
14008 char path[] = "/new";
14009 char content[] = "\n";
14011 suppress_error = 0;
14012 r = guestfs_write_file (g, path, content, 0);
14017 char path[] = "/new";
14019 suppress_error = 0;
14020 r = guestfs_cat (g, path);
14023 if (strcmp (r, expected) != 0) {
14024 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
14032 static int test_mkfs_0_skip (void)
14036 str = getenv ("TEST_ONLY");
14038 return strstr (str, "mkfs") == NULL;
14039 str = getenv ("SKIP_TEST_MKFS_0");
14040 if (str && strcmp (str, "1") == 0) return 1;
14041 str = getenv ("SKIP_TEST_MKFS");
14042 if (str && strcmp (str, "1") == 0) return 1;
14046 static int test_mkfs_0 (void)
14048 if (test_mkfs_0_skip ()) {
14049 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
14053 /* InitNone|InitEmpty for test_mkfs_0 */
14055 char device[] = "/dev/sda";
14057 suppress_error = 0;
14058 r = guestfs_blockdev_setrw (g, device);
14064 suppress_error = 0;
14065 r = guestfs_umount_all (g);
14071 suppress_error = 0;
14072 r = guestfs_lvm_remove_all (g);
14076 /* TestOutput for mkfs (0) */
14077 char expected[] = "new file contents";
14079 char device[] = "/dev/sda";
14080 char lines_0[] = ",";
14086 suppress_error = 0;
14087 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14092 char fstype[] = "ext2";
14093 char device[] = "/dev/sda1";
14095 suppress_error = 0;
14096 r = guestfs_mkfs (g, fstype, device);
14101 char device[] = "/dev/sda1";
14102 char mountpoint[] = "/";
14104 suppress_error = 0;
14105 r = guestfs_mount (g, device, mountpoint);
14110 char path[] = "/new";
14111 char content[] = "new file contents";
14113 suppress_error = 0;
14114 r = guestfs_write_file (g, path, content, 0);
14119 char path[] = "/new";
14121 suppress_error = 0;
14122 r = guestfs_cat (g, path);
14125 if (strcmp (r, expected) != 0) {
14126 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
14134 static int test_lvcreate_0_skip (void)
14138 str = getenv ("TEST_ONLY");
14140 return strstr (str, "lvcreate") == NULL;
14141 str = getenv ("SKIP_TEST_LVCREATE_0");
14142 if (str && strcmp (str, "1") == 0) return 1;
14143 str = getenv ("SKIP_TEST_LVCREATE");
14144 if (str && strcmp (str, "1") == 0) return 1;
14148 static int test_lvcreate_0 (void)
14150 if (test_lvcreate_0_skip ()) {
14151 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
14155 /* InitNone|InitEmpty for test_lvcreate_0 */
14157 char device[] = "/dev/sda";
14159 suppress_error = 0;
14160 r = guestfs_blockdev_setrw (g, device);
14166 suppress_error = 0;
14167 r = guestfs_umount_all (g);
14173 suppress_error = 0;
14174 r = guestfs_lvm_remove_all (g);
14178 /* TestOutputList for lvcreate (0) */
14180 char device[] = "/dev/sda";
14181 char lines_0[] = ",10";
14182 char lines_1[] = ",20";
14183 char lines_2[] = ",";
14191 suppress_error = 0;
14192 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14197 char device[] = "/dev/sda1";
14199 suppress_error = 0;
14200 r = guestfs_pvcreate (g, device);
14205 char device[] = "/dev/sda2";
14207 suppress_error = 0;
14208 r = guestfs_pvcreate (g, device);
14213 char device[] = "/dev/sda3";
14215 suppress_error = 0;
14216 r = guestfs_pvcreate (g, device);
14221 char volgroup[] = "VG1";
14222 char physvols_0[] = "/dev/sda1";
14223 char physvols_1[] = "/dev/sda2";
14224 char *physvols[] = {
14230 suppress_error = 0;
14231 r = guestfs_vgcreate (g, volgroup, physvols);
14236 char volgroup[] = "VG2";
14237 char physvols_0[] = "/dev/sda3";
14238 char *physvols[] = {
14243 suppress_error = 0;
14244 r = guestfs_vgcreate (g, volgroup, physvols);
14249 char logvol[] = "LV1";
14250 char volgroup[] = "VG1";
14252 suppress_error = 0;
14253 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14258 char logvol[] = "LV2";
14259 char volgroup[] = "VG1";
14261 suppress_error = 0;
14262 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14267 char logvol[] = "LV3";
14268 char volgroup[] = "VG2";
14270 suppress_error = 0;
14271 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14276 char logvol[] = "LV4";
14277 char volgroup[] = "VG2";
14279 suppress_error = 0;
14280 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14285 char logvol[] = "LV5";
14286 char volgroup[] = "VG2";
14288 suppress_error = 0;
14289 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14296 suppress_error = 0;
14297 r = guestfs_lvs (g);
14301 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14306 char expected[] = "/dev/VG1/LV1";
14307 if (strcmp (r[0], expected) != 0) {
14308 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14313 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14318 char expected[] = "/dev/VG1/LV2";
14319 if (strcmp (r[1], expected) != 0) {
14320 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14325 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14330 char expected[] = "/dev/VG2/LV3";
14331 if (strcmp (r[2], expected) != 0) {
14332 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14337 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14342 char expected[] = "/dev/VG2/LV4";
14343 if (strcmp (r[3], expected) != 0) {
14344 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14349 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14354 char expected[] = "/dev/VG2/LV5";
14355 if (strcmp (r[4], expected) != 0) {
14356 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14360 if (r[5] != NULL) {
14361 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14365 for (i = 0; r[i] != NULL; ++i)
14372 static int test_vgcreate_0_skip (void)
14376 str = getenv ("TEST_ONLY");
14378 return strstr (str, "vgcreate") == NULL;
14379 str = getenv ("SKIP_TEST_VGCREATE_0");
14380 if (str && strcmp (str, "1") == 0) return 1;
14381 str = getenv ("SKIP_TEST_VGCREATE");
14382 if (str && strcmp (str, "1") == 0) return 1;
14386 static int test_vgcreate_0 (void)
14388 if (test_vgcreate_0_skip ()) {
14389 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14393 /* InitNone|InitEmpty for test_vgcreate_0 */
14395 char device[] = "/dev/sda";
14397 suppress_error = 0;
14398 r = guestfs_blockdev_setrw (g, device);
14404 suppress_error = 0;
14405 r = guestfs_umount_all (g);
14411 suppress_error = 0;
14412 r = guestfs_lvm_remove_all (g);
14416 /* TestOutputList for vgcreate (0) */
14418 char device[] = "/dev/sda";
14419 char lines_0[] = ",10";
14420 char lines_1[] = ",20";
14421 char lines_2[] = ",";
14429 suppress_error = 0;
14430 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14435 char device[] = "/dev/sda1";
14437 suppress_error = 0;
14438 r = guestfs_pvcreate (g, device);
14443 char device[] = "/dev/sda2";
14445 suppress_error = 0;
14446 r = guestfs_pvcreate (g, device);
14451 char device[] = "/dev/sda3";
14453 suppress_error = 0;
14454 r = guestfs_pvcreate (g, device);
14459 char volgroup[] = "VG1";
14460 char physvols_0[] = "/dev/sda1";
14461 char physvols_1[] = "/dev/sda2";
14462 char *physvols[] = {
14468 suppress_error = 0;
14469 r = guestfs_vgcreate (g, volgroup, physvols);
14474 char volgroup[] = "VG2";
14475 char physvols_0[] = "/dev/sda3";
14476 char *physvols[] = {
14481 suppress_error = 0;
14482 r = guestfs_vgcreate (g, volgroup, physvols);
14489 suppress_error = 0;
14490 r = guestfs_vgs (g);
14494 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14499 char expected[] = "VG1";
14500 if (strcmp (r[0], expected) != 0) {
14501 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14506 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14511 char expected[] = "VG2";
14512 if (strcmp (r[1], expected) != 0) {
14513 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14517 if (r[2] != NULL) {
14518 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14522 for (i = 0; r[i] != NULL; ++i)
14529 static int test_pvcreate_0_skip (void)
14533 str = getenv ("TEST_ONLY");
14535 return strstr (str, "pvcreate") == NULL;
14536 str = getenv ("SKIP_TEST_PVCREATE_0");
14537 if (str && strcmp (str, "1") == 0) return 1;
14538 str = getenv ("SKIP_TEST_PVCREATE");
14539 if (str && strcmp (str, "1") == 0) return 1;
14543 static int test_pvcreate_0 (void)
14545 if (test_pvcreate_0_skip ()) {
14546 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14550 /* InitNone|InitEmpty for test_pvcreate_0 */
14552 char device[] = "/dev/sda";
14554 suppress_error = 0;
14555 r = guestfs_blockdev_setrw (g, device);
14561 suppress_error = 0;
14562 r = guestfs_umount_all (g);
14568 suppress_error = 0;
14569 r = guestfs_lvm_remove_all (g);
14573 /* TestOutputListOfDevices for pvcreate (0) */
14575 char device[] = "/dev/sda";
14576 char lines_0[] = ",10";
14577 char lines_1[] = ",20";
14578 char lines_2[] = ",";
14586 suppress_error = 0;
14587 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14592 char device[] = "/dev/sda1";
14594 suppress_error = 0;
14595 r = guestfs_pvcreate (g, device);
14600 char device[] = "/dev/sda2";
14602 suppress_error = 0;
14603 r = guestfs_pvcreate (g, device);
14608 char device[] = "/dev/sda3";
14610 suppress_error = 0;
14611 r = guestfs_pvcreate (g, device);
14618 suppress_error = 0;
14619 r = guestfs_pvs (g);
14623 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14628 char expected[] = "/dev/sda1";
14630 if (strcmp (r[0], expected) != 0) {
14631 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14636 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14641 char expected[] = "/dev/sda2";
14643 if (strcmp (r[1], expected) != 0) {
14644 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14649 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14654 char expected[] = "/dev/sda3";
14656 if (strcmp (r[2], expected) != 0) {
14657 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14661 if (r[3] != NULL) {
14662 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14666 for (i = 0; r[i] != NULL; ++i)
14673 static int test_is_dir_0_skip (void)
14677 str = getenv ("TEST_ONLY");
14679 return strstr (str, "is_dir") == NULL;
14680 str = getenv ("SKIP_TEST_IS_DIR_0");
14681 if (str && strcmp (str, "1") == 0) return 1;
14682 str = getenv ("SKIP_TEST_IS_DIR");
14683 if (str && strcmp (str, "1") == 0) return 1;
14687 static int test_is_dir_0 (void)
14689 if (test_is_dir_0_skip ()) {
14690 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14694 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14696 char device[] = "/dev/sda";
14698 suppress_error = 0;
14699 r = guestfs_blockdev_setrw (g, device);
14705 suppress_error = 0;
14706 r = guestfs_umount_all (g);
14712 suppress_error = 0;
14713 r = guestfs_lvm_remove_all (g);
14718 char device[] = "/dev/sda";
14719 char lines_0[] = ",";
14725 suppress_error = 0;
14726 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14731 char fstype[] = "ext2";
14732 char device[] = "/dev/sda1";
14734 suppress_error = 0;
14735 r = guestfs_mkfs (g, fstype, device);
14740 char device[] = "/dev/sda1";
14741 char mountpoint[] = "/";
14743 suppress_error = 0;
14744 r = guestfs_mount (g, device, mountpoint);
14748 /* TestOutputFalse for is_dir (0) */
14750 char path[] = "/new";
14752 suppress_error = 0;
14753 r = guestfs_touch (g, path);
14758 char path[] = "/new";
14760 suppress_error = 0;
14761 r = guestfs_is_dir (g, path);
14765 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14772 static int test_is_dir_1_skip (void)
14776 str = getenv ("TEST_ONLY");
14778 return strstr (str, "is_dir") == NULL;
14779 str = getenv ("SKIP_TEST_IS_DIR_1");
14780 if (str && strcmp (str, "1") == 0) return 1;
14781 str = getenv ("SKIP_TEST_IS_DIR");
14782 if (str && strcmp (str, "1") == 0) return 1;
14786 static int test_is_dir_1 (void)
14788 if (test_is_dir_1_skip ()) {
14789 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14793 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
14795 char device[] = "/dev/sda";
14797 suppress_error = 0;
14798 r = guestfs_blockdev_setrw (g, device);
14804 suppress_error = 0;
14805 r = guestfs_umount_all (g);
14811 suppress_error = 0;
14812 r = guestfs_lvm_remove_all (g);
14817 char device[] = "/dev/sda";
14818 char lines_0[] = ",";
14824 suppress_error = 0;
14825 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14830 char fstype[] = "ext2";
14831 char device[] = "/dev/sda1";
14833 suppress_error = 0;
14834 r = guestfs_mkfs (g, fstype, device);
14839 char device[] = "/dev/sda1";
14840 char mountpoint[] = "/";
14842 suppress_error = 0;
14843 r = guestfs_mount (g, device, mountpoint);
14847 /* TestOutputTrue for is_dir (1) */
14849 char path[] = "/new";
14851 suppress_error = 0;
14852 r = guestfs_mkdir (g, path);
14857 char path[] = "/new";
14859 suppress_error = 0;
14860 r = guestfs_is_dir (g, path);
14864 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14871 static int test_is_file_0_skip (void)
14875 str = getenv ("TEST_ONLY");
14877 return strstr (str, "is_file") == NULL;
14878 str = getenv ("SKIP_TEST_IS_FILE_0");
14879 if (str && strcmp (str, "1") == 0) return 1;
14880 str = getenv ("SKIP_TEST_IS_FILE");
14881 if (str && strcmp (str, "1") == 0) return 1;
14885 static int test_is_file_0 (void)
14887 if (test_is_file_0_skip ()) {
14888 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14892 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
14894 char device[] = "/dev/sda";
14896 suppress_error = 0;
14897 r = guestfs_blockdev_setrw (g, device);
14903 suppress_error = 0;
14904 r = guestfs_umount_all (g);
14910 suppress_error = 0;
14911 r = guestfs_lvm_remove_all (g);
14916 char device[] = "/dev/sda";
14917 char lines_0[] = ",";
14923 suppress_error = 0;
14924 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14929 char fstype[] = "ext2";
14930 char device[] = "/dev/sda1";
14932 suppress_error = 0;
14933 r = guestfs_mkfs (g, fstype, device);
14938 char device[] = "/dev/sda1";
14939 char mountpoint[] = "/";
14941 suppress_error = 0;
14942 r = guestfs_mount (g, device, mountpoint);
14946 /* TestOutputTrue for is_file (0) */
14948 char path[] = "/new";
14950 suppress_error = 0;
14951 r = guestfs_touch (g, path);
14956 char path[] = "/new";
14958 suppress_error = 0;
14959 r = guestfs_is_file (g, path);
14963 fprintf (stderr, "test_is_file_0: expected true, got false\n");
14970 static int test_is_file_1_skip (void)
14974 str = getenv ("TEST_ONLY");
14976 return strstr (str, "is_file") == NULL;
14977 str = getenv ("SKIP_TEST_IS_FILE_1");
14978 if (str && strcmp (str, "1") == 0) return 1;
14979 str = getenv ("SKIP_TEST_IS_FILE");
14980 if (str && strcmp (str, "1") == 0) return 1;
14984 static int test_is_file_1 (void)
14986 if (test_is_file_1_skip ()) {
14987 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14991 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
14993 char device[] = "/dev/sda";
14995 suppress_error = 0;
14996 r = guestfs_blockdev_setrw (g, device);
15002 suppress_error = 0;
15003 r = guestfs_umount_all (g);
15009 suppress_error = 0;
15010 r = guestfs_lvm_remove_all (g);
15015 char device[] = "/dev/sda";
15016 char lines_0[] = ",";
15022 suppress_error = 0;
15023 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15028 char fstype[] = "ext2";
15029 char device[] = "/dev/sda1";
15031 suppress_error = 0;
15032 r = guestfs_mkfs (g, fstype, device);
15037 char device[] = "/dev/sda1";
15038 char mountpoint[] = "/";
15040 suppress_error = 0;
15041 r = guestfs_mount (g, device, mountpoint);
15045 /* TestOutputFalse for is_file (1) */
15047 char path[] = "/new";
15049 suppress_error = 0;
15050 r = guestfs_mkdir (g, path);
15055 char path[] = "/new";
15057 suppress_error = 0;
15058 r = guestfs_is_file (g, path);
15062 fprintf (stderr, "test_is_file_1: expected false, got true\n");
15069 static int test_exists_0_skip (void)
15073 str = getenv ("TEST_ONLY");
15075 return strstr (str, "exists") == NULL;
15076 str = getenv ("SKIP_TEST_EXISTS_0");
15077 if (str && strcmp (str, "1") == 0) return 1;
15078 str = getenv ("SKIP_TEST_EXISTS");
15079 if (str && strcmp (str, "1") == 0) return 1;
15083 static int test_exists_0 (void)
15085 if (test_exists_0_skip ()) {
15086 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
15090 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
15092 char device[] = "/dev/sda";
15094 suppress_error = 0;
15095 r = guestfs_blockdev_setrw (g, device);
15101 suppress_error = 0;
15102 r = guestfs_umount_all (g);
15108 suppress_error = 0;
15109 r = guestfs_lvm_remove_all (g);
15114 char device[] = "/dev/sda";
15115 char lines_0[] = ",";
15121 suppress_error = 0;
15122 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15127 char fstype[] = "ext2";
15128 char device[] = "/dev/sda1";
15130 suppress_error = 0;
15131 r = guestfs_mkfs (g, fstype, device);
15136 char device[] = "/dev/sda1";
15137 char mountpoint[] = "/";
15139 suppress_error = 0;
15140 r = guestfs_mount (g, device, mountpoint);
15144 /* TestOutputTrue for exists (0) */
15146 char path[] = "/new";
15148 suppress_error = 0;
15149 r = guestfs_touch (g, path);
15154 char path[] = "/new";
15156 suppress_error = 0;
15157 r = guestfs_exists (g, path);
15161 fprintf (stderr, "test_exists_0: expected true, got false\n");
15168 static int test_exists_1_skip (void)
15172 str = getenv ("TEST_ONLY");
15174 return strstr (str, "exists") == NULL;
15175 str = getenv ("SKIP_TEST_EXISTS_1");
15176 if (str && strcmp (str, "1") == 0) return 1;
15177 str = getenv ("SKIP_TEST_EXISTS");
15178 if (str && strcmp (str, "1") == 0) return 1;
15182 static int test_exists_1 (void)
15184 if (test_exists_1_skip ()) {
15185 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15189 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
15191 char device[] = "/dev/sda";
15193 suppress_error = 0;
15194 r = guestfs_blockdev_setrw (g, device);
15200 suppress_error = 0;
15201 r = guestfs_umount_all (g);
15207 suppress_error = 0;
15208 r = guestfs_lvm_remove_all (g);
15213 char device[] = "/dev/sda";
15214 char lines_0[] = ",";
15220 suppress_error = 0;
15221 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15226 char fstype[] = "ext2";
15227 char device[] = "/dev/sda1";
15229 suppress_error = 0;
15230 r = guestfs_mkfs (g, fstype, device);
15235 char device[] = "/dev/sda1";
15236 char mountpoint[] = "/";
15238 suppress_error = 0;
15239 r = guestfs_mount (g, device, mountpoint);
15243 /* TestOutputTrue for exists (1) */
15245 char path[] = "/new";
15247 suppress_error = 0;
15248 r = guestfs_mkdir (g, path);
15253 char path[] = "/new";
15255 suppress_error = 0;
15256 r = guestfs_exists (g, path);
15260 fprintf (stderr, "test_exists_1: expected true, got false\n");
15267 static int test_mkdir_p_0_skip (void)
15271 str = getenv ("TEST_ONLY");
15273 return strstr (str, "mkdir_p") == NULL;
15274 str = getenv ("SKIP_TEST_MKDIR_P_0");
15275 if (str && strcmp (str, "1") == 0) return 1;
15276 str = getenv ("SKIP_TEST_MKDIR_P");
15277 if (str && strcmp (str, "1") == 0) return 1;
15281 static int test_mkdir_p_0 (void)
15283 if (test_mkdir_p_0_skip ()) {
15284 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15288 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15290 char device[] = "/dev/sda";
15292 suppress_error = 0;
15293 r = guestfs_blockdev_setrw (g, device);
15299 suppress_error = 0;
15300 r = guestfs_umount_all (g);
15306 suppress_error = 0;
15307 r = guestfs_lvm_remove_all (g);
15312 char device[] = "/dev/sda";
15313 char lines_0[] = ",";
15319 suppress_error = 0;
15320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15325 char fstype[] = "ext2";
15326 char device[] = "/dev/sda1";
15328 suppress_error = 0;
15329 r = guestfs_mkfs (g, fstype, device);
15334 char device[] = "/dev/sda1";
15335 char mountpoint[] = "/";
15337 suppress_error = 0;
15338 r = guestfs_mount (g, device, mountpoint);
15342 /* TestOutputTrue for mkdir_p (0) */
15344 char path[] = "/new/foo/bar";
15346 suppress_error = 0;
15347 r = guestfs_mkdir_p (g, path);
15352 char path[] = "/new/foo/bar";
15354 suppress_error = 0;
15355 r = guestfs_is_dir (g, path);
15359 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15366 static int test_mkdir_p_1_skip (void)
15370 str = getenv ("TEST_ONLY");
15372 return strstr (str, "mkdir_p") == NULL;
15373 str = getenv ("SKIP_TEST_MKDIR_P_1");
15374 if (str && strcmp (str, "1") == 0) return 1;
15375 str = getenv ("SKIP_TEST_MKDIR_P");
15376 if (str && strcmp (str, "1") == 0) return 1;
15380 static int test_mkdir_p_1 (void)
15382 if (test_mkdir_p_1_skip ()) {
15383 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15387 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15389 char device[] = "/dev/sda";
15391 suppress_error = 0;
15392 r = guestfs_blockdev_setrw (g, device);
15398 suppress_error = 0;
15399 r = guestfs_umount_all (g);
15405 suppress_error = 0;
15406 r = guestfs_lvm_remove_all (g);
15411 char device[] = "/dev/sda";
15412 char lines_0[] = ",";
15418 suppress_error = 0;
15419 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15424 char fstype[] = "ext2";
15425 char device[] = "/dev/sda1";
15427 suppress_error = 0;
15428 r = guestfs_mkfs (g, fstype, device);
15433 char device[] = "/dev/sda1";
15434 char mountpoint[] = "/";
15436 suppress_error = 0;
15437 r = guestfs_mount (g, device, mountpoint);
15441 /* TestOutputTrue for mkdir_p (1) */
15443 char path[] = "/new/foo/bar";
15445 suppress_error = 0;
15446 r = guestfs_mkdir_p (g, path);
15451 char path[] = "/new/foo";
15453 suppress_error = 0;
15454 r = guestfs_is_dir (g, path);
15458 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15465 static int test_mkdir_p_2_skip (void)
15469 str = getenv ("TEST_ONLY");
15471 return strstr (str, "mkdir_p") == NULL;
15472 str = getenv ("SKIP_TEST_MKDIR_P_2");
15473 if (str && strcmp (str, "1") == 0) return 1;
15474 str = getenv ("SKIP_TEST_MKDIR_P");
15475 if (str && strcmp (str, "1") == 0) return 1;
15479 static int test_mkdir_p_2 (void)
15481 if (test_mkdir_p_2_skip ()) {
15482 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15486 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15488 char device[] = "/dev/sda";
15490 suppress_error = 0;
15491 r = guestfs_blockdev_setrw (g, device);
15497 suppress_error = 0;
15498 r = guestfs_umount_all (g);
15504 suppress_error = 0;
15505 r = guestfs_lvm_remove_all (g);
15510 char device[] = "/dev/sda";
15511 char lines_0[] = ",";
15517 suppress_error = 0;
15518 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15523 char fstype[] = "ext2";
15524 char device[] = "/dev/sda1";
15526 suppress_error = 0;
15527 r = guestfs_mkfs (g, fstype, device);
15532 char device[] = "/dev/sda1";
15533 char mountpoint[] = "/";
15535 suppress_error = 0;
15536 r = guestfs_mount (g, device, mountpoint);
15540 /* TestOutputTrue for mkdir_p (2) */
15542 char path[] = "/new/foo/bar";
15544 suppress_error = 0;
15545 r = guestfs_mkdir_p (g, path);
15550 char path[] = "/new";
15552 suppress_error = 0;
15553 r = guestfs_is_dir (g, path);
15557 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15564 static int test_mkdir_p_3_skip (void)
15568 str = getenv ("TEST_ONLY");
15570 return strstr (str, "mkdir_p") == NULL;
15571 str = getenv ("SKIP_TEST_MKDIR_P_3");
15572 if (str && strcmp (str, "1") == 0) return 1;
15573 str = getenv ("SKIP_TEST_MKDIR_P");
15574 if (str && strcmp (str, "1") == 0) return 1;
15578 static int test_mkdir_p_3 (void)
15580 if (test_mkdir_p_3_skip ()) {
15581 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15585 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15587 char device[] = "/dev/sda";
15589 suppress_error = 0;
15590 r = guestfs_blockdev_setrw (g, device);
15596 suppress_error = 0;
15597 r = guestfs_umount_all (g);
15603 suppress_error = 0;
15604 r = guestfs_lvm_remove_all (g);
15609 char device[] = "/dev/sda";
15610 char lines_0[] = ",";
15616 suppress_error = 0;
15617 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15622 char fstype[] = "ext2";
15623 char device[] = "/dev/sda1";
15625 suppress_error = 0;
15626 r = guestfs_mkfs (g, fstype, device);
15631 char device[] = "/dev/sda1";
15632 char mountpoint[] = "/";
15634 suppress_error = 0;
15635 r = guestfs_mount (g, device, mountpoint);
15639 /* TestRun for mkdir_p (3) */
15641 char path[] = "/new";
15643 suppress_error = 0;
15644 r = guestfs_mkdir (g, path);
15649 char path[] = "/new";
15651 suppress_error = 0;
15652 r = guestfs_mkdir_p (g, path);
15659 static int test_mkdir_p_4_skip (void)
15663 str = getenv ("TEST_ONLY");
15665 return strstr (str, "mkdir_p") == NULL;
15666 str = getenv ("SKIP_TEST_MKDIR_P_4");
15667 if (str && strcmp (str, "1") == 0) return 1;
15668 str = getenv ("SKIP_TEST_MKDIR_P");
15669 if (str && strcmp (str, "1") == 0) return 1;
15673 static int test_mkdir_p_4 (void)
15675 if (test_mkdir_p_4_skip ()) {
15676 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15680 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15682 char device[] = "/dev/sda";
15684 suppress_error = 0;
15685 r = guestfs_blockdev_setrw (g, device);
15691 suppress_error = 0;
15692 r = guestfs_umount_all (g);
15698 suppress_error = 0;
15699 r = guestfs_lvm_remove_all (g);
15704 char device[] = "/dev/sda";
15705 char lines_0[] = ",";
15711 suppress_error = 0;
15712 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15717 char fstype[] = "ext2";
15718 char device[] = "/dev/sda1";
15720 suppress_error = 0;
15721 r = guestfs_mkfs (g, fstype, device);
15726 char device[] = "/dev/sda1";
15727 char mountpoint[] = "/";
15729 suppress_error = 0;
15730 r = guestfs_mount (g, device, mountpoint);
15734 /* TestLastFail for mkdir_p (4) */
15736 char path[] = "/new";
15738 suppress_error = 0;
15739 r = guestfs_touch (g, path);
15744 char path[] = "/new";
15746 suppress_error = 1;
15747 r = guestfs_mkdir_p (g, path);
15754 static int test_mkdir_0_skip (void)
15758 str = getenv ("TEST_ONLY");
15760 return strstr (str, "mkdir") == NULL;
15761 str = getenv ("SKIP_TEST_MKDIR_0");
15762 if (str && strcmp (str, "1") == 0) return 1;
15763 str = getenv ("SKIP_TEST_MKDIR");
15764 if (str && strcmp (str, "1") == 0) return 1;
15768 static int test_mkdir_0 (void)
15770 if (test_mkdir_0_skip ()) {
15771 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15775 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15777 char device[] = "/dev/sda";
15779 suppress_error = 0;
15780 r = guestfs_blockdev_setrw (g, device);
15786 suppress_error = 0;
15787 r = guestfs_umount_all (g);
15793 suppress_error = 0;
15794 r = guestfs_lvm_remove_all (g);
15799 char device[] = "/dev/sda";
15800 char lines_0[] = ",";
15806 suppress_error = 0;
15807 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15812 char fstype[] = "ext2";
15813 char device[] = "/dev/sda1";
15815 suppress_error = 0;
15816 r = guestfs_mkfs (g, fstype, device);
15821 char device[] = "/dev/sda1";
15822 char mountpoint[] = "/";
15824 suppress_error = 0;
15825 r = guestfs_mount (g, device, mountpoint);
15829 /* TestOutputTrue for mkdir (0) */
15831 char path[] = "/new";
15833 suppress_error = 0;
15834 r = guestfs_mkdir (g, path);
15839 char path[] = "/new";
15841 suppress_error = 0;
15842 r = guestfs_is_dir (g, path);
15846 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15853 static int test_mkdir_1_skip (void)
15857 str = getenv ("TEST_ONLY");
15859 return strstr (str, "mkdir") == NULL;
15860 str = getenv ("SKIP_TEST_MKDIR_1");
15861 if (str && strcmp (str, "1") == 0) return 1;
15862 str = getenv ("SKIP_TEST_MKDIR");
15863 if (str && strcmp (str, "1") == 0) return 1;
15867 static int test_mkdir_1 (void)
15869 if (test_mkdir_1_skip ()) {
15870 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15874 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15876 char device[] = "/dev/sda";
15878 suppress_error = 0;
15879 r = guestfs_blockdev_setrw (g, device);
15885 suppress_error = 0;
15886 r = guestfs_umount_all (g);
15892 suppress_error = 0;
15893 r = guestfs_lvm_remove_all (g);
15898 char device[] = "/dev/sda";
15899 char lines_0[] = ",";
15905 suppress_error = 0;
15906 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15911 char fstype[] = "ext2";
15912 char device[] = "/dev/sda1";
15914 suppress_error = 0;
15915 r = guestfs_mkfs (g, fstype, device);
15920 char device[] = "/dev/sda1";
15921 char mountpoint[] = "/";
15923 suppress_error = 0;
15924 r = guestfs_mount (g, device, mountpoint);
15928 /* TestLastFail for mkdir (1) */
15930 char path[] = "/new/foo/bar";
15932 suppress_error = 1;
15933 r = guestfs_mkdir (g, path);
15940 static int test_rm_rf_0_skip (void)
15944 str = getenv ("TEST_ONLY");
15946 return strstr (str, "rm_rf") == NULL;
15947 str = getenv ("SKIP_TEST_RM_RF_0");
15948 if (str && strcmp (str, "1") == 0) return 1;
15949 str = getenv ("SKIP_TEST_RM_RF");
15950 if (str && strcmp (str, "1") == 0) return 1;
15954 static int test_rm_rf_0 (void)
15956 if (test_rm_rf_0_skip ()) {
15957 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15961 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15963 char device[] = "/dev/sda";
15965 suppress_error = 0;
15966 r = guestfs_blockdev_setrw (g, device);
15972 suppress_error = 0;
15973 r = guestfs_umount_all (g);
15979 suppress_error = 0;
15980 r = guestfs_lvm_remove_all (g);
15985 char device[] = "/dev/sda";
15986 char lines_0[] = ",";
15992 suppress_error = 0;
15993 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15998 char fstype[] = "ext2";
15999 char device[] = "/dev/sda1";
16001 suppress_error = 0;
16002 r = guestfs_mkfs (g, fstype, device);
16007 char device[] = "/dev/sda1";
16008 char mountpoint[] = "/";
16010 suppress_error = 0;
16011 r = guestfs_mount (g, device, mountpoint);
16015 /* TestOutputFalse for rm_rf (0) */
16017 char path[] = "/new";
16019 suppress_error = 0;
16020 r = guestfs_mkdir (g, path);
16025 char path[] = "/new/foo";
16027 suppress_error = 0;
16028 r = guestfs_mkdir (g, path);
16033 char path[] = "/new/foo/bar";
16035 suppress_error = 0;
16036 r = guestfs_touch (g, path);
16041 char path[] = "/new";
16043 suppress_error = 0;
16044 r = guestfs_rm_rf (g, path);
16049 char path[] = "/new";
16051 suppress_error = 0;
16052 r = guestfs_exists (g, path);
16056 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
16063 static int test_rmdir_0_skip (void)
16067 str = getenv ("TEST_ONLY");
16069 return strstr (str, "rmdir") == NULL;
16070 str = getenv ("SKIP_TEST_RMDIR_0");
16071 if (str && strcmp (str, "1") == 0) return 1;
16072 str = getenv ("SKIP_TEST_RMDIR");
16073 if (str && strcmp (str, "1") == 0) return 1;
16077 static int test_rmdir_0 (void)
16079 if (test_rmdir_0_skip ()) {
16080 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
16084 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
16086 char device[] = "/dev/sda";
16088 suppress_error = 0;
16089 r = guestfs_blockdev_setrw (g, device);
16095 suppress_error = 0;
16096 r = guestfs_umount_all (g);
16102 suppress_error = 0;
16103 r = guestfs_lvm_remove_all (g);
16108 char device[] = "/dev/sda";
16109 char lines_0[] = ",";
16115 suppress_error = 0;
16116 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16121 char fstype[] = "ext2";
16122 char device[] = "/dev/sda1";
16124 suppress_error = 0;
16125 r = guestfs_mkfs (g, fstype, device);
16130 char device[] = "/dev/sda1";
16131 char mountpoint[] = "/";
16133 suppress_error = 0;
16134 r = guestfs_mount (g, device, mountpoint);
16138 /* TestRun for rmdir (0) */
16140 char path[] = "/new";
16142 suppress_error = 0;
16143 r = guestfs_mkdir (g, path);
16148 char path[] = "/new";
16150 suppress_error = 0;
16151 r = guestfs_rmdir (g, path);
16158 static int test_rmdir_1_skip (void)
16162 str = getenv ("TEST_ONLY");
16164 return strstr (str, "rmdir") == NULL;
16165 str = getenv ("SKIP_TEST_RMDIR_1");
16166 if (str && strcmp (str, "1") == 0) return 1;
16167 str = getenv ("SKIP_TEST_RMDIR");
16168 if (str && strcmp (str, "1") == 0) return 1;
16172 static int test_rmdir_1 (void)
16174 if (test_rmdir_1_skip ()) {
16175 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16179 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16181 char device[] = "/dev/sda";
16183 suppress_error = 0;
16184 r = guestfs_blockdev_setrw (g, device);
16190 suppress_error = 0;
16191 r = guestfs_umount_all (g);
16197 suppress_error = 0;
16198 r = guestfs_lvm_remove_all (g);
16203 char device[] = "/dev/sda";
16204 char lines_0[] = ",";
16210 suppress_error = 0;
16211 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16216 char fstype[] = "ext2";
16217 char device[] = "/dev/sda1";
16219 suppress_error = 0;
16220 r = guestfs_mkfs (g, fstype, device);
16225 char device[] = "/dev/sda1";
16226 char mountpoint[] = "/";
16228 suppress_error = 0;
16229 r = guestfs_mount (g, device, mountpoint);
16233 /* TestLastFail for rmdir (1) */
16235 char path[] = "/new";
16237 suppress_error = 1;
16238 r = guestfs_rmdir (g, path);
16245 static int test_rmdir_2_skip (void)
16249 str = getenv ("TEST_ONLY");
16251 return strstr (str, "rmdir") == NULL;
16252 str = getenv ("SKIP_TEST_RMDIR_2");
16253 if (str && strcmp (str, "1") == 0) return 1;
16254 str = getenv ("SKIP_TEST_RMDIR");
16255 if (str && strcmp (str, "1") == 0) return 1;
16259 static int test_rmdir_2 (void)
16261 if (test_rmdir_2_skip ()) {
16262 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16266 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16268 char device[] = "/dev/sda";
16270 suppress_error = 0;
16271 r = guestfs_blockdev_setrw (g, device);
16277 suppress_error = 0;
16278 r = guestfs_umount_all (g);
16284 suppress_error = 0;
16285 r = guestfs_lvm_remove_all (g);
16290 char device[] = "/dev/sda";
16291 char lines_0[] = ",";
16297 suppress_error = 0;
16298 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16303 char fstype[] = "ext2";
16304 char device[] = "/dev/sda1";
16306 suppress_error = 0;
16307 r = guestfs_mkfs (g, fstype, device);
16312 char device[] = "/dev/sda1";
16313 char mountpoint[] = "/";
16315 suppress_error = 0;
16316 r = guestfs_mount (g, device, mountpoint);
16320 /* TestLastFail for rmdir (2) */
16322 char path[] = "/new";
16324 suppress_error = 0;
16325 r = guestfs_touch (g, path);
16330 char path[] = "/new";
16332 suppress_error = 1;
16333 r = guestfs_rmdir (g, path);
16340 static int test_rm_0_skip (void)
16344 str = getenv ("TEST_ONLY");
16346 return strstr (str, "rm") == NULL;
16347 str = getenv ("SKIP_TEST_RM_0");
16348 if (str && strcmp (str, "1") == 0) return 1;
16349 str = getenv ("SKIP_TEST_RM");
16350 if (str && strcmp (str, "1") == 0) return 1;
16354 static int test_rm_0 (void)
16356 if (test_rm_0_skip ()) {
16357 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16361 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16363 char device[] = "/dev/sda";
16365 suppress_error = 0;
16366 r = guestfs_blockdev_setrw (g, device);
16372 suppress_error = 0;
16373 r = guestfs_umount_all (g);
16379 suppress_error = 0;
16380 r = guestfs_lvm_remove_all (g);
16385 char device[] = "/dev/sda";
16386 char lines_0[] = ",";
16392 suppress_error = 0;
16393 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16398 char fstype[] = "ext2";
16399 char device[] = "/dev/sda1";
16401 suppress_error = 0;
16402 r = guestfs_mkfs (g, fstype, device);
16407 char device[] = "/dev/sda1";
16408 char mountpoint[] = "/";
16410 suppress_error = 0;
16411 r = guestfs_mount (g, device, mountpoint);
16415 /* TestRun for rm (0) */
16417 char path[] = "/new";
16419 suppress_error = 0;
16420 r = guestfs_touch (g, path);
16425 char path[] = "/new";
16427 suppress_error = 0;
16428 r = guestfs_rm (g, path);
16435 static int test_rm_1_skip (void)
16439 str = getenv ("TEST_ONLY");
16441 return strstr (str, "rm") == NULL;
16442 str = getenv ("SKIP_TEST_RM_1");
16443 if (str && strcmp (str, "1") == 0) return 1;
16444 str = getenv ("SKIP_TEST_RM");
16445 if (str && strcmp (str, "1") == 0) return 1;
16449 static int test_rm_1 (void)
16451 if (test_rm_1_skip ()) {
16452 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16456 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16458 char device[] = "/dev/sda";
16460 suppress_error = 0;
16461 r = guestfs_blockdev_setrw (g, device);
16467 suppress_error = 0;
16468 r = guestfs_umount_all (g);
16474 suppress_error = 0;
16475 r = guestfs_lvm_remove_all (g);
16480 char device[] = "/dev/sda";
16481 char lines_0[] = ",";
16487 suppress_error = 0;
16488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16493 char fstype[] = "ext2";
16494 char device[] = "/dev/sda1";
16496 suppress_error = 0;
16497 r = guestfs_mkfs (g, fstype, device);
16502 char device[] = "/dev/sda1";
16503 char mountpoint[] = "/";
16505 suppress_error = 0;
16506 r = guestfs_mount (g, device, mountpoint);
16510 /* TestLastFail for rm (1) */
16512 char path[] = "/new";
16514 suppress_error = 1;
16515 r = guestfs_rm (g, path);
16522 static int test_rm_2_skip (void)
16526 str = getenv ("TEST_ONLY");
16528 return strstr (str, "rm") == NULL;
16529 str = getenv ("SKIP_TEST_RM_2");
16530 if (str && strcmp (str, "1") == 0) return 1;
16531 str = getenv ("SKIP_TEST_RM");
16532 if (str && strcmp (str, "1") == 0) return 1;
16536 static int test_rm_2 (void)
16538 if (test_rm_2_skip ()) {
16539 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16543 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16545 char device[] = "/dev/sda";
16547 suppress_error = 0;
16548 r = guestfs_blockdev_setrw (g, device);
16554 suppress_error = 0;
16555 r = guestfs_umount_all (g);
16561 suppress_error = 0;
16562 r = guestfs_lvm_remove_all (g);
16567 char device[] = "/dev/sda";
16568 char lines_0[] = ",";
16574 suppress_error = 0;
16575 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16580 char fstype[] = "ext2";
16581 char device[] = "/dev/sda1";
16583 suppress_error = 0;
16584 r = guestfs_mkfs (g, fstype, device);
16589 char device[] = "/dev/sda1";
16590 char mountpoint[] = "/";
16592 suppress_error = 0;
16593 r = guestfs_mount (g, device, mountpoint);
16597 /* TestLastFail for rm (2) */
16599 char path[] = "/new";
16601 suppress_error = 0;
16602 r = guestfs_mkdir (g, path);
16607 char path[] = "/new";
16609 suppress_error = 1;
16610 r = guestfs_rm (g, path);
16617 static int test_read_lines_0_skip (void)
16621 str = getenv ("TEST_ONLY");
16623 return strstr (str, "read_lines") == NULL;
16624 str = getenv ("SKIP_TEST_READ_LINES_0");
16625 if (str && strcmp (str, "1") == 0) return 1;
16626 str = getenv ("SKIP_TEST_READ_LINES");
16627 if (str && strcmp (str, "1") == 0) return 1;
16631 static int test_read_lines_0 (void)
16633 if (test_read_lines_0_skip ()) {
16634 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16638 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16640 char device[] = "/dev/sda";
16642 suppress_error = 0;
16643 r = guestfs_blockdev_setrw (g, device);
16649 suppress_error = 0;
16650 r = guestfs_umount_all (g);
16656 suppress_error = 0;
16657 r = guestfs_lvm_remove_all (g);
16662 char device[] = "/dev/sda";
16663 char lines_0[] = ",";
16669 suppress_error = 0;
16670 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16675 char fstype[] = "ext2";
16676 char device[] = "/dev/sda1";
16678 suppress_error = 0;
16679 r = guestfs_mkfs (g, fstype, device);
16684 char device[] = "/dev/sda1";
16685 char mountpoint[] = "/";
16687 suppress_error = 0;
16688 r = guestfs_mount (g, device, mountpoint);
16692 /* TestOutputList for read_lines (0) */
16694 char path[] = "/new";
16695 char content[] = "line1\r\nline2\nline3";
16697 suppress_error = 0;
16698 r = guestfs_write_file (g, path, content, 0);
16703 char path[] = "/new";
16706 suppress_error = 0;
16707 r = guestfs_read_lines (g, path);
16711 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16716 char expected[] = "line1";
16717 if (strcmp (r[0], expected) != 0) {
16718 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16723 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16728 char expected[] = "line2";
16729 if (strcmp (r[1], expected) != 0) {
16730 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16735 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16740 char expected[] = "line3";
16741 if (strcmp (r[2], expected) != 0) {
16742 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16746 if (r[3] != NULL) {
16747 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16751 for (i = 0; r[i] != NULL; ++i)
16758 static int test_read_lines_1_skip (void)
16762 str = getenv ("TEST_ONLY");
16764 return strstr (str, "read_lines") == NULL;
16765 str = getenv ("SKIP_TEST_READ_LINES_1");
16766 if (str && strcmp (str, "1") == 0) return 1;
16767 str = getenv ("SKIP_TEST_READ_LINES");
16768 if (str && strcmp (str, "1") == 0) return 1;
16772 static int test_read_lines_1 (void)
16774 if (test_read_lines_1_skip ()) {
16775 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16779 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16781 char device[] = "/dev/sda";
16783 suppress_error = 0;
16784 r = guestfs_blockdev_setrw (g, device);
16790 suppress_error = 0;
16791 r = guestfs_umount_all (g);
16797 suppress_error = 0;
16798 r = guestfs_lvm_remove_all (g);
16803 char device[] = "/dev/sda";
16804 char lines_0[] = ",";
16810 suppress_error = 0;
16811 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16816 char fstype[] = "ext2";
16817 char device[] = "/dev/sda1";
16819 suppress_error = 0;
16820 r = guestfs_mkfs (g, fstype, device);
16825 char device[] = "/dev/sda1";
16826 char mountpoint[] = "/";
16828 suppress_error = 0;
16829 r = guestfs_mount (g, device, mountpoint);
16833 /* TestOutputList for read_lines (1) */
16835 char path[] = "/new";
16836 char content[] = "";
16838 suppress_error = 0;
16839 r = guestfs_write_file (g, path, content, 0);
16844 char path[] = "/new";
16847 suppress_error = 0;
16848 r = guestfs_read_lines (g, path);
16851 if (r[0] != NULL) {
16852 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16856 for (i = 0; r[i] != NULL; ++i)
16863 static int test_lvs_0_skip (void)
16867 str = getenv ("TEST_ONLY");
16869 return strstr (str, "lvs") == NULL;
16870 str = getenv ("SKIP_TEST_LVS_0");
16871 if (str && strcmp (str, "1") == 0) return 1;
16872 str = getenv ("SKIP_TEST_LVS");
16873 if (str && strcmp (str, "1") == 0) return 1;
16877 static int test_lvs_0 (void)
16879 if (test_lvs_0_skip ()) {
16880 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16884 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16886 char device[] = "/dev/sda";
16888 suppress_error = 0;
16889 r = guestfs_blockdev_setrw (g, device);
16895 suppress_error = 0;
16896 r = guestfs_umount_all (g);
16902 suppress_error = 0;
16903 r = guestfs_lvm_remove_all (g);
16908 char device[] = "/dev/sda";
16909 char lines_0[] = ",";
16915 suppress_error = 0;
16916 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16921 char device[] = "/dev/sda1";
16923 suppress_error = 0;
16924 r = guestfs_pvcreate (g, device);
16929 char volgroup[] = "VG";
16930 char physvols_0[] = "/dev/sda1";
16931 char *physvols[] = {
16936 suppress_error = 0;
16937 r = guestfs_vgcreate (g, volgroup, physvols);
16942 char logvol[] = "LV";
16943 char volgroup[] = "VG";
16945 suppress_error = 0;
16946 r = guestfs_lvcreate (g, logvol, volgroup, 8);
16951 char fstype[] = "ext2";
16952 char device[] = "/dev/VG/LV";
16954 suppress_error = 0;
16955 r = guestfs_mkfs (g, fstype, device);
16960 char device[] = "/dev/VG/LV";
16961 char mountpoint[] = "/";
16963 suppress_error = 0;
16964 r = guestfs_mount (g, device, mountpoint);
16968 /* TestOutputList for lvs (0) */
16972 suppress_error = 0;
16973 r = guestfs_lvs (g);
16977 fprintf (stderr, "test_lvs_0: short list returned from command\n");
16982 char expected[] = "/dev/VG/LV";
16983 if (strcmp (r[0], expected) != 0) {
16984 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16988 if (r[1] != NULL) {
16989 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16993 for (i = 0; r[i] != NULL; ++i)
17000 static int test_lvs_1_skip (void)
17004 str = getenv ("TEST_ONLY");
17006 return strstr (str, "lvs") == NULL;
17007 str = getenv ("SKIP_TEST_LVS_1");
17008 if (str && strcmp (str, "1") == 0) return 1;
17009 str = getenv ("SKIP_TEST_LVS");
17010 if (str && strcmp (str, "1") == 0) return 1;
17014 static int test_lvs_1 (void)
17016 if (test_lvs_1_skip ()) {
17017 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
17021 /* InitNone|InitEmpty for test_lvs_1 */
17023 char device[] = "/dev/sda";
17025 suppress_error = 0;
17026 r = guestfs_blockdev_setrw (g, device);
17032 suppress_error = 0;
17033 r = guestfs_umount_all (g);
17039 suppress_error = 0;
17040 r = guestfs_lvm_remove_all (g);
17044 /* TestOutputList for lvs (1) */
17046 char device[] = "/dev/sda";
17047 char lines_0[] = ",10";
17048 char lines_1[] = ",20";
17049 char lines_2[] = ",";
17057 suppress_error = 0;
17058 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17063 char device[] = "/dev/sda1";
17065 suppress_error = 0;
17066 r = guestfs_pvcreate (g, device);
17071 char device[] = "/dev/sda2";
17073 suppress_error = 0;
17074 r = guestfs_pvcreate (g, device);
17079 char device[] = "/dev/sda3";
17081 suppress_error = 0;
17082 r = guestfs_pvcreate (g, device);
17087 char volgroup[] = "VG1";
17088 char physvols_0[] = "/dev/sda1";
17089 char physvols_1[] = "/dev/sda2";
17090 char *physvols[] = {
17096 suppress_error = 0;
17097 r = guestfs_vgcreate (g, volgroup, physvols);
17102 char volgroup[] = "VG2";
17103 char physvols_0[] = "/dev/sda3";
17104 char *physvols[] = {
17109 suppress_error = 0;
17110 r = guestfs_vgcreate (g, volgroup, physvols);
17115 char logvol[] = "LV1";
17116 char volgroup[] = "VG1";
17118 suppress_error = 0;
17119 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17124 char logvol[] = "LV2";
17125 char volgroup[] = "VG1";
17127 suppress_error = 0;
17128 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17133 char logvol[] = "LV3";
17134 char volgroup[] = "VG2";
17136 suppress_error = 0;
17137 r = guestfs_lvcreate (g, logvol, volgroup, 50);
17144 suppress_error = 0;
17145 r = guestfs_lvs (g);
17149 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17154 char expected[] = "/dev/VG1/LV1";
17155 if (strcmp (r[0], expected) != 0) {
17156 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17161 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17166 char expected[] = "/dev/VG1/LV2";
17167 if (strcmp (r[1], expected) != 0) {
17168 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17173 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17178 char expected[] = "/dev/VG2/LV3";
17179 if (strcmp (r[2], expected) != 0) {
17180 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17184 if (r[3] != NULL) {
17185 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17189 for (i = 0; r[i] != NULL; ++i)
17196 static int test_vgs_0_skip (void)
17200 str = getenv ("TEST_ONLY");
17202 return strstr (str, "vgs") == NULL;
17203 str = getenv ("SKIP_TEST_VGS_0");
17204 if (str && strcmp (str, "1") == 0) return 1;
17205 str = getenv ("SKIP_TEST_VGS");
17206 if (str && strcmp (str, "1") == 0) return 1;
17210 static int test_vgs_0 (void)
17212 if (test_vgs_0_skip ()) {
17213 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17217 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17219 char device[] = "/dev/sda";
17221 suppress_error = 0;
17222 r = guestfs_blockdev_setrw (g, device);
17228 suppress_error = 0;
17229 r = guestfs_umount_all (g);
17235 suppress_error = 0;
17236 r = guestfs_lvm_remove_all (g);
17241 char device[] = "/dev/sda";
17242 char lines_0[] = ",";
17248 suppress_error = 0;
17249 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17254 char device[] = "/dev/sda1";
17256 suppress_error = 0;
17257 r = guestfs_pvcreate (g, device);
17262 char volgroup[] = "VG";
17263 char physvols_0[] = "/dev/sda1";
17264 char *physvols[] = {
17269 suppress_error = 0;
17270 r = guestfs_vgcreate (g, volgroup, physvols);
17275 char logvol[] = "LV";
17276 char volgroup[] = "VG";
17278 suppress_error = 0;
17279 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17284 char fstype[] = "ext2";
17285 char device[] = "/dev/VG/LV";
17287 suppress_error = 0;
17288 r = guestfs_mkfs (g, fstype, device);
17293 char device[] = "/dev/VG/LV";
17294 char mountpoint[] = "/";
17296 suppress_error = 0;
17297 r = guestfs_mount (g, device, mountpoint);
17301 /* TestOutputList for vgs (0) */
17305 suppress_error = 0;
17306 r = guestfs_vgs (g);
17310 fprintf (stderr, "test_vgs_0: short list returned from command\n");
17315 char expected[] = "VG";
17316 if (strcmp (r[0], expected) != 0) {
17317 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17321 if (r[1] != NULL) {
17322 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17326 for (i = 0; r[i] != NULL; ++i)
17333 static int test_vgs_1_skip (void)
17337 str = getenv ("TEST_ONLY");
17339 return strstr (str, "vgs") == NULL;
17340 str = getenv ("SKIP_TEST_VGS_1");
17341 if (str && strcmp (str, "1") == 0) return 1;
17342 str = getenv ("SKIP_TEST_VGS");
17343 if (str && strcmp (str, "1") == 0) return 1;
17347 static int test_vgs_1 (void)
17349 if (test_vgs_1_skip ()) {
17350 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17354 /* InitNone|InitEmpty for test_vgs_1 */
17356 char device[] = "/dev/sda";
17358 suppress_error = 0;
17359 r = guestfs_blockdev_setrw (g, device);
17365 suppress_error = 0;
17366 r = guestfs_umount_all (g);
17372 suppress_error = 0;
17373 r = guestfs_lvm_remove_all (g);
17377 /* TestOutputList for vgs (1) */
17379 char device[] = "/dev/sda";
17380 char lines_0[] = ",10";
17381 char lines_1[] = ",20";
17382 char lines_2[] = ",";
17390 suppress_error = 0;
17391 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17396 char device[] = "/dev/sda1";
17398 suppress_error = 0;
17399 r = guestfs_pvcreate (g, device);
17404 char device[] = "/dev/sda2";
17406 suppress_error = 0;
17407 r = guestfs_pvcreate (g, device);
17412 char device[] = "/dev/sda3";
17414 suppress_error = 0;
17415 r = guestfs_pvcreate (g, device);
17420 char volgroup[] = "VG1";
17421 char physvols_0[] = "/dev/sda1";
17422 char physvols_1[] = "/dev/sda2";
17423 char *physvols[] = {
17429 suppress_error = 0;
17430 r = guestfs_vgcreate (g, volgroup, physvols);
17435 char volgroup[] = "VG2";
17436 char physvols_0[] = "/dev/sda3";
17437 char *physvols[] = {
17442 suppress_error = 0;
17443 r = guestfs_vgcreate (g, volgroup, physvols);
17450 suppress_error = 0;
17451 r = guestfs_vgs (g);
17455 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17460 char expected[] = "VG1";
17461 if (strcmp (r[0], expected) != 0) {
17462 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17467 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17472 char expected[] = "VG2";
17473 if (strcmp (r[1], expected) != 0) {
17474 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17478 if (r[2] != NULL) {
17479 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17483 for (i = 0; r[i] != NULL; ++i)
17490 static int test_pvs_0_skip (void)
17494 str = getenv ("TEST_ONLY");
17496 return strstr (str, "pvs") == NULL;
17497 str = getenv ("SKIP_TEST_PVS_0");
17498 if (str && strcmp (str, "1") == 0) return 1;
17499 str = getenv ("SKIP_TEST_PVS");
17500 if (str && strcmp (str, "1") == 0) return 1;
17504 static int test_pvs_0 (void)
17506 if (test_pvs_0_skip ()) {
17507 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17511 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17513 char device[] = "/dev/sda";
17515 suppress_error = 0;
17516 r = guestfs_blockdev_setrw (g, device);
17522 suppress_error = 0;
17523 r = guestfs_umount_all (g);
17529 suppress_error = 0;
17530 r = guestfs_lvm_remove_all (g);
17535 char device[] = "/dev/sda";
17536 char lines_0[] = ",";
17542 suppress_error = 0;
17543 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17548 char device[] = "/dev/sda1";
17550 suppress_error = 0;
17551 r = guestfs_pvcreate (g, device);
17556 char volgroup[] = "VG";
17557 char physvols_0[] = "/dev/sda1";
17558 char *physvols[] = {
17563 suppress_error = 0;
17564 r = guestfs_vgcreate (g, volgroup, physvols);
17569 char logvol[] = "LV";
17570 char volgroup[] = "VG";
17572 suppress_error = 0;
17573 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17578 char fstype[] = "ext2";
17579 char device[] = "/dev/VG/LV";
17581 suppress_error = 0;
17582 r = guestfs_mkfs (g, fstype, device);
17587 char device[] = "/dev/VG/LV";
17588 char mountpoint[] = "/";
17590 suppress_error = 0;
17591 r = guestfs_mount (g, device, mountpoint);
17595 /* TestOutputListOfDevices for pvs (0) */
17599 suppress_error = 0;
17600 r = guestfs_pvs (g);
17604 fprintf (stderr, "test_pvs_0: short list returned from command\n");
17609 char expected[] = "/dev/sda1";
17611 if (strcmp (r[0], expected) != 0) {
17612 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17616 if (r[1] != NULL) {
17617 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17621 for (i = 0; r[i] != NULL; ++i)
17628 static int test_pvs_1_skip (void)
17632 str = getenv ("TEST_ONLY");
17634 return strstr (str, "pvs") == NULL;
17635 str = getenv ("SKIP_TEST_PVS_1");
17636 if (str && strcmp (str, "1") == 0) return 1;
17637 str = getenv ("SKIP_TEST_PVS");
17638 if (str && strcmp (str, "1") == 0) return 1;
17642 static int test_pvs_1 (void)
17644 if (test_pvs_1_skip ()) {
17645 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17649 /* InitNone|InitEmpty for test_pvs_1 */
17651 char device[] = "/dev/sda";
17653 suppress_error = 0;
17654 r = guestfs_blockdev_setrw (g, device);
17660 suppress_error = 0;
17661 r = guestfs_umount_all (g);
17667 suppress_error = 0;
17668 r = guestfs_lvm_remove_all (g);
17672 /* TestOutputListOfDevices for pvs (1) */
17674 char device[] = "/dev/sda";
17675 char lines_0[] = ",10";
17676 char lines_1[] = ",20";
17677 char lines_2[] = ",";
17685 suppress_error = 0;
17686 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17691 char device[] = "/dev/sda1";
17693 suppress_error = 0;
17694 r = guestfs_pvcreate (g, device);
17699 char device[] = "/dev/sda2";
17701 suppress_error = 0;
17702 r = guestfs_pvcreate (g, device);
17707 char device[] = "/dev/sda3";
17709 suppress_error = 0;
17710 r = guestfs_pvcreate (g, device);
17717 suppress_error = 0;
17718 r = guestfs_pvs (g);
17722 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17727 char expected[] = "/dev/sda1";
17729 if (strcmp (r[0], expected) != 0) {
17730 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17735 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17740 char expected[] = "/dev/sda2";
17742 if (strcmp (r[1], expected) != 0) {
17743 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17748 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17753 char expected[] = "/dev/sda3";
17755 if (strcmp (r[2], expected) != 0) {
17756 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17760 if (r[3] != NULL) {
17761 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17765 for (i = 0; r[i] != NULL; ++i)
17772 static int test_list_partitions_0_skip (void)
17776 str = getenv ("TEST_ONLY");
17778 return strstr (str, "list_partitions") == NULL;
17779 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17780 if (str && strcmp (str, "1") == 0) return 1;
17781 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17782 if (str && strcmp (str, "1") == 0) return 1;
17786 static int test_list_partitions_0 (void)
17788 if (test_list_partitions_0_skip ()) {
17789 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17793 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17795 char device[] = "/dev/sda";
17797 suppress_error = 0;
17798 r = guestfs_blockdev_setrw (g, device);
17804 suppress_error = 0;
17805 r = guestfs_umount_all (g);
17811 suppress_error = 0;
17812 r = guestfs_lvm_remove_all (g);
17817 char device[] = "/dev/sda";
17818 char lines_0[] = ",";
17824 suppress_error = 0;
17825 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17830 char fstype[] = "ext2";
17831 char device[] = "/dev/sda1";
17833 suppress_error = 0;
17834 r = guestfs_mkfs (g, fstype, device);
17839 char device[] = "/dev/sda1";
17840 char mountpoint[] = "/";
17842 suppress_error = 0;
17843 r = guestfs_mount (g, device, mountpoint);
17847 /* TestOutputListOfDevices for list_partitions (0) */
17851 suppress_error = 0;
17852 r = guestfs_list_partitions (g);
17856 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17861 char expected[] = "/dev/sda1";
17863 if (strcmp (r[0], expected) != 0) {
17864 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17868 if (r[1] != NULL) {
17869 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17873 for (i = 0; r[i] != NULL; ++i)
17880 static int test_list_partitions_1_skip (void)
17884 str = getenv ("TEST_ONLY");
17886 return strstr (str, "list_partitions") == NULL;
17887 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17888 if (str && strcmp (str, "1") == 0) return 1;
17889 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17890 if (str && strcmp (str, "1") == 0) return 1;
17894 static int test_list_partitions_1 (void)
17896 if (test_list_partitions_1_skip ()) {
17897 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17901 /* InitNone|InitEmpty for test_list_partitions_1 */
17903 char device[] = "/dev/sda";
17905 suppress_error = 0;
17906 r = guestfs_blockdev_setrw (g, device);
17912 suppress_error = 0;
17913 r = guestfs_umount_all (g);
17919 suppress_error = 0;
17920 r = guestfs_lvm_remove_all (g);
17924 /* TestOutputListOfDevices for list_partitions (1) */
17926 char device[] = "/dev/sda";
17927 char lines_0[] = ",10";
17928 char lines_1[] = ",20";
17929 char lines_2[] = ",";
17937 suppress_error = 0;
17938 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17945 suppress_error = 0;
17946 r = guestfs_list_partitions (g);
17950 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17955 char expected[] = "/dev/sda1";
17957 if (strcmp (r[0], expected) != 0) {
17958 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17963 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17968 char expected[] = "/dev/sda2";
17970 if (strcmp (r[1], expected) != 0) {
17971 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17976 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17981 char expected[] = "/dev/sda3";
17983 if (strcmp (r[2], expected) != 0) {
17984 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17988 if (r[3] != NULL) {
17989 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17993 for (i = 0; r[i] != NULL; ++i)
18000 static int test_list_devices_0_skip (void)
18004 str = getenv ("TEST_ONLY");
18006 return strstr (str, "list_devices") == NULL;
18007 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
18008 if (str && strcmp (str, "1") == 0) return 1;
18009 str = getenv ("SKIP_TEST_LIST_DEVICES");
18010 if (str && strcmp (str, "1") == 0) return 1;
18014 static int test_list_devices_0 (void)
18016 if (test_list_devices_0_skip ()) {
18017 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
18021 /* InitNone|InitEmpty for test_list_devices_0 */
18023 char device[] = "/dev/sda";
18025 suppress_error = 0;
18026 r = guestfs_blockdev_setrw (g, device);
18032 suppress_error = 0;
18033 r = guestfs_umount_all (g);
18039 suppress_error = 0;
18040 r = guestfs_lvm_remove_all (g);
18044 /* TestOutputListOfDevices for list_devices (0) */
18048 suppress_error = 0;
18049 r = guestfs_list_devices (g);
18053 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18058 char expected[] = "/dev/sda";
18060 if (strcmp (r[0], expected) != 0) {
18061 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18066 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18071 char expected[] = "/dev/sdb";
18073 if (strcmp (r[1], expected) != 0) {
18074 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18079 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18084 char expected[] = "/dev/sdc";
18086 if (strcmp (r[2], expected) != 0) {
18087 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18092 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
18097 char expected[] = "/dev/sdd";
18099 if (strcmp (r[3], expected) != 0) {
18100 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18104 if (r[4] != NULL) {
18105 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
18109 for (i = 0; r[i] != NULL; ++i)
18116 static int test_ls_0_skip (void)
18120 str = getenv ("TEST_ONLY");
18122 return strstr (str, "ls") == NULL;
18123 str = getenv ("SKIP_TEST_LS_0");
18124 if (str && strcmp (str, "1") == 0) return 1;
18125 str = getenv ("SKIP_TEST_LS");
18126 if (str && strcmp (str, "1") == 0) return 1;
18130 static int test_ls_0 (void)
18132 if (test_ls_0_skip ()) {
18133 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
18137 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
18139 char device[] = "/dev/sda";
18141 suppress_error = 0;
18142 r = guestfs_blockdev_setrw (g, device);
18148 suppress_error = 0;
18149 r = guestfs_umount_all (g);
18155 suppress_error = 0;
18156 r = guestfs_lvm_remove_all (g);
18161 char device[] = "/dev/sda";
18162 char lines_0[] = ",";
18168 suppress_error = 0;
18169 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18174 char fstype[] = "ext2";
18175 char device[] = "/dev/sda1";
18177 suppress_error = 0;
18178 r = guestfs_mkfs (g, fstype, device);
18183 char device[] = "/dev/sda1";
18184 char mountpoint[] = "/";
18186 suppress_error = 0;
18187 r = guestfs_mount (g, device, mountpoint);
18191 /* TestOutputList for ls (0) */
18193 char path[] = "/new";
18195 suppress_error = 0;
18196 r = guestfs_touch (g, path);
18201 char path[] = "/newer";
18203 suppress_error = 0;
18204 r = guestfs_touch (g, path);
18209 char path[] = "/newest";
18211 suppress_error = 0;
18212 r = guestfs_touch (g, path);
18217 char directory[] = "/";
18220 suppress_error = 0;
18221 r = guestfs_ls (g, directory);
18225 fprintf (stderr, "test_ls_0: short list returned from command\n");
18230 char expected[] = "lost+found";
18231 if (strcmp (r[0], expected) != 0) {
18232 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18237 fprintf (stderr, "test_ls_0: short list returned from command\n");
18242 char expected[] = "new";
18243 if (strcmp (r[1], expected) != 0) {
18244 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18249 fprintf (stderr, "test_ls_0: short list returned from command\n");
18254 char expected[] = "newer";
18255 if (strcmp (r[2], expected) != 0) {
18256 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18261 fprintf (stderr, "test_ls_0: short list returned from command\n");
18266 char expected[] = "newest";
18267 if (strcmp (r[3], expected) != 0) {
18268 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18272 if (r[4] != NULL) {
18273 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18277 for (i = 0; r[i] != NULL; ++i)
18284 static int test_cat_0_skip (void)
18288 str = getenv ("TEST_ONLY");
18290 return strstr (str, "cat") == NULL;
18291 str = getenv ("SKIP_TEST_CAT_0");
18292 if (str && strcmp (str, "1") == 0) return 1;
18293 str = getenv ("SKIP_TEST_CAT");
18294 if (str && strcmp (str, "1") == 0) return 1;
18298 static int test_cat_0 (void)
18300 if (test_cat_0_skip ()) {
18301 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18305 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18307 char device[] = "/dev/sda";
18309 suppress_error = 0;
18310 r = guestfs_blockdev_setrw (g, device);
18316 suppress_error = 0;
18317 r = guestfs_umount_all (g);
18323 suppress_error = 0;
18324 r = guestfs_lvm_remove_all (g);
18329 char device[] = "/dev/sda";
18330 char lines_0[] = ",";
18336 suppress_error = 0;
18337 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18342 char fstype[] = "ext2";
18343 char device[] = "/dev/sda1";
18345 suppress_error = 0;
18346 r = guestfs_mkfs (g, fstype, device);
18351 char device[] = "/dev/sda1";
18352 char mountpoint[] = "/";
18354 suppress_error = 0;
18355 r = guestfs_mount (g, device, mountpoint);
18359 /* TestOutput for cat (0) */
18360 char expected[] = "new file contents";
18362 char path[] = "/new";
18363 char content[] = "new file contents";
18365 suppress_error = 0;
18366 r = guestfs_write_file (g, path, content, 0);
18371 char path[] = "/new";
18373 suppress_error = 0;
18374 r = guestfs_cat (g, path);
18377 if (strcmp (r, expected) != 0) {
18378 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18386 static int test_touch_0_skip (void)
18390 str = getenv ("TEST_ONLY");
18392 return strstr (str, "touch") == NULL;
18393 str = getenv ("SKIP_TEST_TOUCH_0");
18394 if (str && strcmp (str, "1") == 0) return 1;
18395 str = getenv ("SKIP_TEST_TOUCH");
18396 if (str && strcmp (str, "1") == 0) return 1;
18400 static int test_touch_0 (void)
18402 if (test_touch_0_skip ()) {
18403 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18407 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18409 char device[] = "/dev/sda";
18411 suppress_error = 0;
18412 r = guestfs_blockdev_setrw (g, device);
18418 suppress_error = 0;
18419 r = guestfs_umount_all (g);
18425 suppress_error = 0;
18426 r = guestfs_lvm_remove_all (g);
18431 char device[] = "/dev/sda";
18432 char lines_0[] = ",";
18438 suppress_error = 0;
18439 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18444 char fstype[] = "ext2";
18445 char device[] = "/dev/sda1";
18447 suppress_error = 0;
18448 r = guestfs_mkfs (g, fstype, device);
18453 char device[] = "/dev/sda1";
18454 char mountpoint[] = "/";
18456 suppress_error = 0;
18457 r = guestfs_mount (g, device, mountpoint);
18461 /* TestOutputTrue for touch (0) */
18463 char path[] = "/new";
18465 suppress_error = 0;
18466 r = guestfs_touch (g, path);
18471 char path[] = "/new";
18473 suppress_error = 0;
18474 r = guestfs_exists (g, path);
18478 fprintf (stderr, "test_touch_0: expected true, got false\n");
18485 static int test_sync_0_skip (void)
18489 str = getenv ("TEST_ONLY");
18491 return strstr (str, "sync") == NULL;
18492 str = getenv ("SKIP_TEST_SYNC_0");
18493 if (str && strcmp (str, "1") == 0) return 1;
18494 str = getenv ("SKIP_TEST_SYNC");
18495 if (str && strcmp (str, "1") == 0) return 1;
18499 static int test_sync_0 (void)
18501 if (test_sync_0_skip ()) {
18502 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18506 /* InitNone|InitEmpty for test_sync_0 */
18508 char device[] = "/dev/sda";
18510 suppress_error = 0;
18511 r = guestfs_blockdev_setrw (g, device);
18517 suppress_error = 0;
18518 r = guestfs_umount_all (g);
18524 suppress_error = 0;
18525 r = guestfs_lvm_remove_all (g);
18529 /* TestRun for sync (0) */
18532 suppress_error = 0;
18533 r = guestfs_sync (g);
18540 static int test_mount_0_skip (void)
18544 str = getenv ("TEST_ONLY");
18546 return strstr (str, "mount") == NULL;
18547 str = getenv ("SKIP_TEST_MOUNT_0");
18548 if (str && strcmp (str, "1") == 0) return 1;
18549 str = getenv ("SKIP_TEST_MOUNT");
18550 if (str && strcmp (str, "1") == 0) return 1;
18554 static int test_mount_0 (void)
18556 if (test_mount_0_skip ()) {
18557 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18561 /* InitNone|InitEmpty for test_mount_0 */
18563 char device[] = "/dev/sda";
18565 suppress_error = 0;
18566 r = guestfs_blockdev_setrw (g, device);
18572 suppress_error = 0;
18573 r = guestfs_umount_all (g);
18579 suppress_error = 0;
18580 r = guestfs_lvm_remove_all (g);
18584 /* TestOutput for mount (0) */
18585 char expected[] = "new file contents";
18587 char device[] = "/dev/sda";
18588 char lines_0[] = ",";
18594 suppress_error = 0;
18595 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18600 char fstype[] = "ext2";
18601 char device[] = "/dev/sda1";
18603 suppress_error = 0;
18604 r = guestfs_mkfs (g, fstype, device);
18609 char device[] = "/dev/sda1";
18610 char mountpoint[] = "/";
18612 suppress_error = 0;
18613 r = guestfs_mount (g, device, mountpoint);
18618 char path[] = "/new";
18619 char content[] = "new file contents";
18621 suppress_error = 0;
18622 r = guestfs_write_file (g, path, content, 0);
18627 char path[] = "/new";
18629 suppress_error = 0;
18630 r = guestfs_cat (g, path);
18633 if (strcmp (r, expected) != 0) {
18634 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18642 int main (int argc, char *argv[])
18646 const char *filename;
18648 int nr_tests, test_num = 0;
18650 no_test_warnings ();
18652 g = guestfs_create ();
18654 printf ("guestfs_create FAILED\n");
18658 guestfs_set_error_handler (g, print_error, NULL);
18660 guestfs_set_path (g, "../appliance");
18662 filename = "test1.img";
18663 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18668 if (lseek (fd, 524288000, SEEK_SET) == -1) {
18674 if (write (fd, &c, 1) == -1) {
18680 if (close (fd) == -1) {
18685 if (guestfs_add_drive (g, filename) == -1) {
18686 printf ("guestfs_add_drive %s FAILED\n", filename);
18690 filename = "test2.img";
18691 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18696 if (lseek (fd, 52428800, SEEK_SET) == -1) {
18702 if (write (fd, &c, 1) == -1) {
18708 if (close (fd) == -1) {
18713 if (guestfs_add_drive (g, filename) == -1) {
18714 printf ("guestfs_add_drive %s FAILED\n", filename);
18718 filename = "test3.img";
18719 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18724 if (lseek (fd, 10485760, SEEK_SET) == -1) {
18730 if (write (fd, &c, 1) == -1) {
18736 if (close (fd) == -1) {
18741 if (guestfs_add_drive (g, filename) == -1) {
18742 printf ("guestfs_add_drive %s FAILED\n", filename);
18746 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18747 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18751 if (guestfs_launch (g) == -1) {
18752 printf ("guestfs_launch FAILED\n");
18756 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18759 if (guestfs_wait_ready (g) == -1) {
18760 printf ("guestfs_wait_ready FAILED\n");
18764 /* Cancel previous alarm. */
18770 printf ("%3d/%3d test_initrd_list_0\n", test_num, nr_tests);
18771 if (test_initrd_list_0 () == -1) {
18772 printf ("test_initrd_list_0 FAILED\n");
18776 printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
18777 if (test_du_0 () == -1) {
18778 printf ("test_du_0 FAILED\n");
18782 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18783 if (test_tail_n_0 () == -1) {
18784 printf ("test_tail_n_0 FAILED\n");
18788 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18789 if (test_tail_n_1 () == -1) {
18790 printf ("test_tail_n_1 FAILED\n");
18794 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18795 if (test_tail_n_2 () == -1) {
18796 printf ("test_tail_n_2 FAILED\n");
18800 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18801 if (test_tail_0 () == -1) {
18802 printf ("test_tail_0 FAILED\n");
18806 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18807 if (test_head_n_0 () == -1) {
18808 printf ("test_head_n_0 FAILED\n");
18812 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18813 if (test_head_n_1 () == -1) {
18814 printf ("test_head_n_1 FAILED\n");
18818 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18819 if (test_head_n_2 () == -1) {
18820 printf ("test_head_n_2 FAILED\n");
18824 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18825 if (test_head_0 () == -1) {
18826 printf ("test_head_0 FAILED\n");
18830 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18831 if (test_wc_c_0 () == -1) {
18832 printf ("test_wc_c_0 FAILED\n");
18836 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18837 if (test_wc_w_0 () == -1) {
18838 printf ("test_wc_w_0 FAILED\n");
18842 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18843 if (test_wc_l_0 () == -1) {
18844 printf ("test_wc_l_0 FAILED\n");
18848 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18849 if (test_mkdtemp_0 () == -1) {
18850 printf ("test_mkdtemp_0 FAILED\n");
18854 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18855 if (test_scrub_file_0 () == -1) {
18856 printf ("test_scrub_file_0 FAILED\n");
18860 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18861 if (test_scrub_device_0 () == -1) {
18862 printf ("test_scrub_device_0 FAILED\n");
18866 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18867 if (test_glob_expand_0 () == -1) {
18868 printf ("test_glob_expand_0 FAILED\n");
18872 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18873 if (test_glob_expand_1 () == -1) {
18874 printf ("test_glob_expand_1 FAILED\n");
18878 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18879 if (test_glob_expand_2 () == -1) {
18880 printf ("test_glob_expand_2 FAILED\n");
18884 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18885 if (test_ntfs_3g_probe_0 () == -1) {
18886 printf ("test_ntfs_3g_probe_0 FAILED\n");
18890 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18891 if (test_ntfs_3g_probe_1 () == -1) {
18892 printf ("test_ntfs_3g_probe_1 FAILED\n");
18896 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18897 if (test_sleep_0 () == -1) {
18898 printf ("test_sleep_0 FAILED\n");
18902 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18903 if (test_find_0 () == -1) {
18904 printf ("test_find_0 FAILED\n");
18908 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18909 if (test_find_1 () == -1) {
18910 printf ("test_find_1 FAILED\n");
18914 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18915 if (test_find_2 () == -1) {
18916 printf ("test_find_2 FAILED\n");
18920 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18921 if (test_lvresize_0 () == -1) {
18922 printf ("test_lvresize_0 FAILED\n");
18926 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18927 if (test_zerofree_0 () == -1) {
18928 printf ("test_zerofree_0 FAILED\n");
18932 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18933 if (test_hexdump_0 () == -1) {
18934 printf ("test_hexdump_0 FAILED\n");
18938 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18939 if (test_hexdump_1 () == -1) {
18940 printf ("test_hexdump_1 FAILED\n");
18944 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18945 if (test_strings_e_0 () == -1) {
18946 printf ("test_strings_e_0 FAILED\n");
18950 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18951 if (test_strings_e_1 () == -1) {
18952 printf ("test_strings_e_1 FAILED\n");
18956 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18957 if (test_strings_0 () == -1) {
18958 printf ("test_strings_0 FAILED\n");
18962 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18963 if (test_strings_1 () == -1) {
18964 printf ("test_strings_1 FAILED\n");
18968 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18969 if (test_equal_0 () == -1) {
18970 printf ("test_equal_0 FAILED\n");
18974 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18975 if (test_equal_1 () == -1) {
18976 printf ("test_equal_1 FAILED\n");
18980 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18981 if (test_equal_2 () == -1) {
18982 printf ("test_equal_2 FAILED\n");
18986 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18987 if (test_ping_daemon_0 () == -1) {
18988 printf ("test_ping_daemon_0 FAILED\n");
18992 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18993 if (test_dmesg_0 () == -1) {
18994 printf ("test_dmesg_0 FAILED\n");
18998 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18999 if (test_drop_caches_0 () == -1) {
19000 printf ("test_drop_caches_0 FAILED\n");
19004 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
19005 if (test_mv_0 () == -1) {
19006 printf ("test_mv_0 FAILED\n");
19010 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
19011 if (test_mv_1 () == -1) {
19012 printf ("test_mv_1 FAILED\n");
19016 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
19017 if (test_cp_a_0 () == -1) {
19018 printf ("test_cp_a_0 FAILED\n");
19022 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
19023 if (test_cp_0 () == -1) {
19024 printf ("test_cp_0 FAILED\n");
19028 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
19029 if (test_cp_1 () == -1) {
19030 printf ("test_cp_1 FAILED\n");
19034 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
19035 if (test_cp_2 () == -1) {
19036 printf ("test_cp_2 FAILED\n");
19040 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
19041 if (test_grub_install_0 () == -1) {
19042 printf ("test_grub_install_0 FAILED\n");
19046 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
19047 if (test_zero_0 () == -1) {
19048 printf ("test_zero_0 FAILED\n");
19052 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
19053 if (test_fsck_0 () == -1) {
19054 printf ("test_fsck_0 FAILED\n");
19058 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
19059 if (test_fsck_1 () == -1) {
19060 printf ("test_fsck_1 FAILED\n");
19064 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
19065 if (test_set_e2uuid_0 () == -1) {
19066 printf ("test_set_e2uuid_0 FAILED\n");
19070 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
19071 if (test_set_e2uuid_1 () == -1) {
19072 printf ("test_set_e2uuid_1 FAILED\n");
19076 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
19077 if (test_set_e2uuid_2 () == -1) {
19078 printf ("test_set_e2uuid_2 FAILED\n");
19082 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
19083 if (test_set_e2uuid_3 () == -1) {
19084 printf ("test_set_e2uuid_3 FAILED\n");
19088 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
19089 if (test_set_e2label_0 () == -1) {
19090 printf ("test_set_e2label_0 FAILED\n");
19094 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
19095 if (test_pvremove_0 () == -1) {
19096 printf ("test_pvremove_0 FAILED\n");
19100 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
19101 if (test_pvremove_1 () == -1) {
19102 printf ("test_pvremove_1 FAILED\n");
19106 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
19107 if (test_pvremove_2 () == -1) {
19108 printf ("test_pvremove_2 FAILED\n");
19112 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
19113 if (test_vgremove_0 () == -1) {
19114 printf ("test_vgremove_0 FAILED\n");
19118 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
19119 if (test_vgremove_1 () == -1) {
19120 printf ("test_vgremove_1 FAILED\n");
19124 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
19125 if (test_lvremove_0 () == -1) {
19126 printf ("test_lvremove_0 FAILED\n");
19130 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
19131 if (test_lvremove_1 () == -1) {
19132 printf ("test_lvremove_1 FAILED\n");
19136 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
19137 if (test_lvremove_2 () == -1) {
19138 printf ("test_lvremove_2 FAILED\n");
19142 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
19143 if (test_mount_ro_0 () == -1) {
19144 printf ("test_mount_ro_0 FAILED\n");
19148 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
19149 if (test_mount_ro_1 () == -1) {
19150 printf ("test_mount_ro_1 FAILED\n");
19154 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
19155 if (test_tgz_in_0 () == -1) {
19156 printf ("test_tgz_in_0 FAILED\n");
19160 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
19161 if (test_tar_in_0 () == -1) {
19162 printf ("test_tar_in_0 FAILED\n");
19166 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19167 if (test_checksum_0 () == -1) {
19168 printf ("test_checksum_0 FAILED\n");
19172 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19173 if (test_checksum_1 () == -1) {
19174 printf ("test_checksum_1 FAILED\n");
19178 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19179 if (test_checksum_2 () == -1) {
19180 printf ("test_checksum_2 FAILED\n");
19184 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19185 if (test_checksum_3 () == -1) {
19186 printf ("test_checksum_3 FAILED\n");
19190 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19191 if (test_checksum_4 () == -1) {
19192 printf ("test_checksum_4 FAILED\n");
19196 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19197 if (test_checksum_5 () == -1) {
19198 printf ("test_checksum_5 FAILED\n");
19202 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19203 if (test_checksum_6 () == -1) {
19204 printf ("test_checksum_6 FAILED\n");
19208 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19209 if (test_checksum_7 () == -1) {
19210 printf ("test_checksum_7 FAILED\n");
19214 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19215 if (test_checksum_8 () == -1) {
19216 printf ("test_checksum_8 FAILED\n");
19220 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19221 if (test_download_0 () == -1) {
19222 printf ("test_download_0 FAILED\n");
19226 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19227 if (test_upload_0 () == -1) {
19228 printf ("test_upload_0 FAILED\n");
19232 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19233 if (test_blockdev_rereadpt_0 () == -1) {
19234 printf ("test_blockdev_rereadpt_0 FAILED\n");
19238 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19239 if (test_blockdev_flushbufs_0 () == -1) {
19240 printf ("test_blockdev_flushbufs_0 FAILED\n");
19244 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19245 if (test_blockdev_getsize64_0 () == -1) {
19246 printf ("test_blockdev_getsize64_0 FAILED\n");
19250 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19251 if (test_blockdev_getsz_0 () == -1) {
19252 printf ("test_blockdev_getsz_0 FAILED\n");
19256 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19257 if (test_blockdev_getbsz_0 () == -1) {
19258 printf ("test_blockdev_getbsz_0 FAILED\n");
19262 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19263 if (test_blockdev_getss_0 () == -1) {
19264 printf ("test_blockdev_getss_0 FAILED\n");
19268 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19269 if (test_blockdev_getro_0 () == -1) {
19270 printf ("test_blockdev_getro_0 FAILED\n");
19274 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19275 if (test_blockdev_setrw_0 () == -1) {
19276 printf ("test_blockdev_setrw_0 FAILED\n");
19280 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19281 if (test_blockdev_setro_0 () == -1) {
19282 printf ("test_blockdev_setro_0 FAILED\n");
19286 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19287 if (test_statvfs_0 () == -1) {
19288 printf ("test_statvfs_0 FAILED\n");
19292 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19293 if (test_lstat_0 () == -1) {
19294 printf ("test_lstat_0 FAILED\n");
19298 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19299 if (test_stat_0 () == -1) {
19300 printf ("test_stat_0 FAILED\n");
19304 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19305 if (test_command_lines_0 () == -1) {
19306 printf ("test_command_lines_0 FAILED\n");
19310 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19311 if (test_command_lines_1 () == -1) {
19312 printf ("test_command_lines_1 FAILED\n");
19316 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19317 if (test_command_lines_2 () == -1) {
19318 printf ("test_command_lines_2 FAILED\n");
19322 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19323 if (test_command_lines_3 () == -1) {
19324 printf ("test_command_lines_3 FAILED\n");
19328 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19329 if (test_command_lines_4 () == -1) {
19330 printf ("test_command_lines_4 FAILED\n");
19334 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19335 if (test_command_lines_5 () == -1) {
19336 printf ("test_command_lines_5 FAILED\n");
19340 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19341 if (test_command_lines_6 () == -1) {
19342 printf ("test_command_lines_6 FAILED\n");
19346 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19347 if (test_command_lines_7 () == -1) {
19348 printf ("test_command_lines_7 FAILED\n");
19352 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19353 if (test_command_lines_8 () == -1) {
19354 printf ("test_command_lines_8 FAILED\n");
19358 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19359 if (test_command_lines_9 () == -1) {
19360 printf ("test_command_lines_9 FAILED\n");
19364 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19365 if (test_command_lines_10 () == -1) {
19366 printf ("test_command_lines_10 FAILED\n");
19370 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19371 if (test_command_0 () == -1) {
19372 printf ("test_command_0 FAILED\n");
19376 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19377 if (test_command_1 () == -1) {
19378 printf ("test_command_1 FAILED\n");
19382 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19383 if (test_command_2 () == -1) {
19384 printf ("test_command_2 FAILED\n");
19388 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19389 if (test_command_3 () == -1) {
19390 printf ("test_command_3 FAILED\n");
19394 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19395 if (test_command_4 () == -1) {
19396 printf ("test_command_4 FAILED\n");
19400 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19401 if (test_command_5 () == -1) {
19402 printf ("test_command_5 FAILED\n");
19406 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19407 if (test_command_6 () == -1) {
19408 printf ("test_command_6 FAILED\n");
19412 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19413 if (test_command_7 () == -1) {
19414 printf ("test_command_7 FAILED\n");
19418 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19419 if (test_command_8 () == -1) {
19420 printf ("test_command_8 FAILED\n");
19424 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19425 if (test_command_9 () == -1) {
19426 printf ("test_command_9 FAILED\n");
19430 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19431 if (test_command_10 () == -1) {
19432 printf ("test_command_10 FAILED\n");
19436 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19437 if (test_command_11 () == -1) {
19438 printf ("test_command_11 FAILED\n");
19442 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19443 if (test_file_0 () == -1) {
19444 printf ("test_file_0 FAILED\n");
19448 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19449 if (test_file_1 () == -1) {
19450 printf ("test_file_1 FAILED\n");
19454 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19455 if (test_file_2 () == -1) {
19456 printf ("test_file_2 FAILED\n");
19460 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19461 if (test_umount_all_0 () == -1) {
19462 printf ("test_umount_all_0 FAILED\n");
19466 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19467 if (test_umount_all_1 () == -1) {
19468 printf ("test_umount_all_1 FAILED\n");
19472 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19473 if (test_mounts_0 () == -1) {
19474 printf ("test_mounts_0 FAILED\n");
19478 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19479 if (test_umount_0 () == -1) {
19480 printf ("test_umount_0 FAILED\n");
19484 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19485 if (test_umount_1 () == -1) {
19486 printf ("test_umount_1 FAILED\n");
19490 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19491 if (test_write_file_0 () == -1) {
19492 printf ("test_write_file_0 FAILED\n");
19496 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19497 if (test_write_file_1 () == -1) {
19498 printf ("test_write_file_1 FAILED\n");
19502 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19503 if (test_write_file_2 () == -1) {
19504 printf ("test_write_file_2 FAILED\n");
19508 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19509 if (test_write_file_3 () == -1) {
19510 printf ("test_write_file_3 FAILED\n");
19514 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19515 if (test_write_file_4 () == -1) {
19516 printf ("test_write_file_4 FAILED\n");
19520 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19521 if (test_write_file_5 () == -1) {
19522 printf ("test_write_file_5 FAILED\n");
19526 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19527 if (test_mkfs_0 () == -1) {
19528 printf ("test_mkfs_0 FAILED\n");
19532 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19533 if (test_lvcreate_0 () == -1) {
19534 printf ("test_lvcreate_0 FAILED\n");
19538 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19539 if (test_vgcreate_0 () == -1) {
19540 printf ("test_vgcreate_0 FAILED\n");
19544 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19545 if (test_pvcreate_0 () == -1) {
19546 printf ("test_pvcreate_0 FAILED\n");
19550 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19551 if (test_is_dir_0 () == -1) {
19552 printf ("test_is_dir_0 FAILED\n");
19556 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19557 if (test_is_dir_1 () == -1) {
19558 printf ("test_is_dir_1 FAILED\n");
19562 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19563 if (test_is_file_0 () == -1) {
19564 printf ("test_is_file_0 FAILED\n");
19568 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19569 if (test_is_file_1 () == -1) {
19570 printf ("test_is_file_1 FAILED\n");
19574 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19575 if (test_exists_0 () == -1) {
19576 printf ("test_exists_0 FAILED\n");
19580 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19581 if (test_exists_1 () == -1) {
19582 printf ("test_exists_1 FAILED\n");
19586 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19587 if (test_mkdir_p_0 () == -1) {
19588 printf ("test_mkdir_p_0 FAILED\n");
19592 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19593 if (test_mkdir_p_1 () == -1) {
19594 printf ("test_mkdir_p_1 FAILED\n");
19598 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19599 if (test_mkdir_p_2 () == -1) {
19600 printf ("test_mkdir_p_2 FAILED\n");
19604 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19605 if (test_mkdir_p_3 () == -1) {
19606 printf ("test_mkdir_p_3 FAILED\n");
19610 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19611 if (test_mkdir_p_4 () == -1) {
19612 printf ("test_mkdir_p_4 FAILED\n");
19616 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19617 if (test_mkdir_0 () == -1) {
19618 printf ("test_mkdir_0 FAILED\n");
19622 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19623 if (test_mkdir_1 () == -1) {
19624 printf ("test_mkdir_1 FAILED\n");
19628 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19629 if (test_rm_rf_0 () == -1) {
19630 printf ("test_rm_rf_0 FAILED\n");
19634 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19635 if (test_rmdir_0 () == -1) {
19636 printf ("test_rmdir_0 FAILED\n");
19640 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19641 if (test_rmdir_1 () == -1) {
19642 printf ("test_rmdir_1 FAILED\n");
19646 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19647 if (test_rmdir_2 () == -1) {
19648 printf ("test_rmdir_2 FAILED\n");
19652 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19653 if (test_rm_0 () == -1) {
19654 printf ("test_rm_0 FAILED\n");
19658 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19659 if (test_rm_1 () == -1) {
19660 printf ("test_rm_1 FAILED\n");
19664 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19665 if (test_rm_2 () == -1) {
19666 printf ("test_rm_2 FAILED\n");
19670 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19671 if (test_read_lines_0 () == -1) {
19672 printf ("test_read_lines_0 FAILED\n");
19676 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19677 if (test_read_lines_1 () == -1) {
19678 printf ("test_read_lines_1 FAILED\n");
19682 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19683 if (test_lvs_0 () == -1) {
19684 printf ("test_lvs_0 FAILED\n");
19688 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19689 if (test_lvs_1 () == -1) {
19690 printf ("test_lvs_1 FAILED\n");
19694 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19695 if (test_vgs_0 () == -1) {
19696 printf ("test_vgs_0 FAILED\n");
19700 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19701 if (test_vgs_1 () == -1) {
19702 printf ("test_vgs_1 FAILED\n");
19706 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19707 if (test_pvs_0 () == -1) {
19708 printf ("test_pvs_0 FAILED\n");
19712 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19713 if (test_pvs_1 () == -1) {
19714 printf ("test_pvs_1 FAILED\n");
19718 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19719 if (test_list_partitions_0 () == -1) {
19720 printf ("test_list_partitions_0 FAILED\n");
19724 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19725 if (test_list_partitions_1 () == -1) {
19726 printf ("test_list_partitions_1 FAILED\n");
19730 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19731 if (test_list_devices_0 () == -1) {
19732 printf ("test_list_devices_0 FAILED\n");
19736 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19737 if (test_ls_0 () == -1) {
19738 printf ("test_ls_0 FAILED\n");
19742 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19743 if (test_cat_0 () == -1) {
19744 printf ("test_cat_0 FAILED\n");
19748 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19749 if (test_touch_0 () == -1) {
19750 printf ("test_touch_0 FAILED\n");
19754 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19755 if (test_sync_0 () == -1) {
19756 printf ("test_sync_0 FAILED\n");
19760 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19761 if (test_mount_0 () == -1) {
19762 printf ("test_mount_0 FAILED\n");
19767 unlink ("test1.img");
19768 unlink ("test2.img");
19769 unlink ("test3.img");
19772 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);