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");
156 static int test_tail_n_0_skip (void)
160 str = getenv ("TEST_ONLY");
162 return strstr (str, "tail_n") == NULL;
163 str = getenv ("SKIP_TEST_TAIL_N_0");
164 if (str && strcmp (str, "1") == 0) return 1;
165 str = getenv ("SKIP_TEST_TAIL_N");
166 if (str && strcmp (str, "1") == 0) return 1;
170 static int test_tail_n_0 (void)
172 if (test_tail_n_0_skip ()) {
173 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
177 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
179 char device[] = "/dev/sda";
182 r = guestfs_blockdev_setrw (g, device);
189 r = guestfs_umount_all (g);
196 r = guestfs_lvm_remove_all (g);
201 char device[] = "/dev/sda";
202 char lines_0[] = ",";
209 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
214 char fstype[] = "ext2";
215 char device[] = "/dev/sda1";
218 r = guestfs_mkfs (g, fstype, device);
223 char device[] = "/dev/sda1";
224 char mountpoint[] = "/";
227 r = guestfs_mount (g, device, mountpoint);
231 /* TestOutputList for tail_n (0) */
233 char options[] = "ro";
234 char vfstype[] = "squashfs";
235 char device[] = "/dev/sdd";
236 char mountpoint[] = "/";
239 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
244 char path[] = "/10klines";
248 r = guestfs_tail_n (g, 3, path);
252 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
257 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
258 if (strcmp (r[0], expected) != 0) {
259 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
264 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
269 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
270 if (strcmp (r[1], expected) != 0) {
271 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
276 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
281 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
282 if (strcmp (r[2], expected) != 0) {
283 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
288 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
292 for (i = 0; r[i] != NULL; ++i)
299 static int test_tail_n_1_skip (void)
303 str = getenv ("TEST_ONLY");
305 return strstr (str, "tail_n") == NULL;
306 str = getenv ("SKIP_TEST_TAIL_N_1");
307 if (str && strcmp (str, "1") == 0) return 1;
308 str = getenv ("SKIP_TEST_TAIL_N");
309 if (str && strcmp (str, "1") == 0) return 1;
313 static int test_tail_n_1 (void)
315 if (test_tail_n_1_skip ()) {
316 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
320 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
322 char device[] = "/dev/sda";
325 r = guestfs_blockdev_setrw (g, device);
332 r = guestfs_umount_all (g);
339 r = guestfs_lvm_remove_all (g);
344 char device[] = "/dev/sda";
345 char lines_0[] = ",";
352 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
357 char fstype[] = "ext2";
358 char device[] = "/dev/sda1";
361 r = guestfs_mkfs (g, fstype, device);
366 char device[] = "/dev/sda1";
367 char mountpoint[] = "/";
370 r = guestfs_mount (g, device, mountpoint);
374 /* TestOutputList for tail_n (1) */
376 char options[] = "ro";
377 char vfstype[] = "squashfs";
378 char device[] = "/dev/sdd";
379 char mountpoint[] = "/";
382 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
387 char path[] = "/10klines";
391 r = guestfs_tail_n (g, -9998, path);
395 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
400 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
401 if (strcmp (r[0], expected) != 0) {
402 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
407 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
412 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
413 if (strcmp (r[1], expected) != 0) {
414 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
419 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
424 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
425 if (strcmp (r[2], expected) != 0) {
426 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
431 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
435 for (i = 0; r[i] != NULL; ++i)
442 static int test_tail_n_2_skip (void)
446 str = getenv ("TEST_ONLY");
448 return strstr (str, "tail_n") == NULL;
449 str = getenv ("SKIP_TEST_TAIL_N_2");
450 if (str && strcmp (str, "1") == 0) return 1;
451 str = getenv ("SKIP_TEST_TAIL_N");
452 if (str && strcmp (str, "1") == 0) return 1;
456 static int test_tail_n_2 (void)
458 if (test_tail_n_2_skip ()) {
459 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
463 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
465 char device[] = "/dev/sda";
468 r = guestfs_blockdev_setrw (g, device);
475 r = guestfs_umount_all (g);
482 r = guestfs_lvm_remove_all (g);
487 char device[] = "/dev/sda";
488 char lines_0[] = ",";
495 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
500 char fstype[] = "ext2";
501 char device[] = "/dev/sda1";
504 r = guestfs_mkfs (g, fstype, device);
509 char device[] = "/dev/sda1";
510 char mountpoint[] = "/";
513 r = guestfs_mount (g, device, mountpoint);
517 /* TestOutputList for tail_n (2) */
519 char options[] = "ro";
520 char vfstype[] = "squashfs";
521 char device[] = "/dev/sdd";
522 char mountpoint[] = "/";
525 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
530 char path[] = "/10klines";
534 r = guestfs_tail_n (g, 0, path);
538 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
542 for (i = 0; r[i] != NULL; ++i)
549 static int test_tail_0_skip (void)
553 str = getenv ("TEST_ONLY");
555 return strstr (str, "tail") == NULL;
556 str = getenv ("SKIP_TEST_TAIL_0");
557 if (str && strcmp (str, "1") == 0) return 1;
558 str = getenv ("SKIP_TEST_TAIL");
559 if (str && strcmp (str, "1") == 0) return 1;
563 static int test_tail_0 (void)
565 if (test_tail_0_skip ()) {
566 printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
570 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
572 char device[] = "/dev/sda";
575 r = guestfs_blockdev_setrw (g, device);
582 r = guestfs_umount_all (g);
589 r = guestfs_lvm_remove_all (g);
594 char device[] = "/dev/sda";
595 char lines_0[] = ",";
602 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
607 char fstype[] = "ext2";
608 char device[] = "/dev/sda1";
611 r = guestfs_mkfs (g, fstype, device);
616 char device[] = "/dev/sda1";
617 char mountpoint[] = "/";
620 r = guestfs_mount (g, device, mountpoint);
624 /* TestOutputList for tail (0) */
626 char options[] = "ro";
627 char vfstype[] = "squashfs";
628 char device[] = "/dev/sdd";
629 char mountpoint[] = "/";
632 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
637 char path[] = "/10klines";
641 r = guestfs_tail (g, path);
645 fprintf (stderr, "test_tail_0: short list returned from command\n");
650 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
651 if (strcmp (r[0], expected) != 0) {
652 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
657 fprintf (stderr, "test_tail_0: short list returned from command\n");
662 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
663 if (strcmp (r[1], expected) != 0) {
664 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
669 fprintf (stderr, "test_tail_0: short list returned from command\n");
674 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
675 if (strcmp (r[2], expected) != 0) {
676 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
681 fprintf (stderr, "test_tail_0: short list returned from command\n");
686 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
687 if (strcmp (r[3], expected) != 0) {
688 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
693 fprintf (stderr, "test_tail_0: short list returned from command\n");
698 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
699 if (strcmp (r[4], expected) != 0) {
700 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
705 fprintf (stderr, "test_tail_0: short list returned from command\n");
710 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
711 if (strcmp (r[5], expected) != 0) {
712 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
717 fprintf (stderr, "test_tail_0: short list returned from command\n");
722 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
723 if (strcmp (r[6], expected) != 0) {
724 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
729 fprintf (stderr, "test_tail_0: short list returned from command\n");
734 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
735 if (strcmp (r[7], expected) != 0) {
736 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
741 fprintf (stderr, "test_tail_0: short list returned from command\n");
746 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
747 if (strcmp (r[8], expected) != 0) {
748 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
753 fprintf (stderr, "test_tail_0: short list returned from command\n");
758 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
759 if (strcmp (r[9], expected) != 0) {
760 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
765 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
769 for (i = 0; r[i] != NULL; ++i)
776 static int test_head_n_0_skip (void)
780 str = getenv ("TEST_ONLY");
782 return strstr (str, "head_n") == NULL;
783 str = getenv ("SKIP_TEST_HEAD_N_0");
784 if (str && strcmp (str, "1") == 0) return 1;
785 str = getenv ("SKIP_TEST_HEAD_N");
786 if (str && strcmp (str, "1") == 0) return 1;
790 static int test_head_n_0 (void)
792 if (test_head_n_0_skip ()) {
793 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
797 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
799 char device[] = "/dev/sda";
802 r = guestfs_blockdev_setrw (g, device);
809 r = guestfs_umount_all (g);
816 r = guestfs_lvm_remove_all (g);
821 char device[] = "/dev/sda";
822 char lines_0[] = ",";
829 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
834 char fstype[] = "ext2";
835 char device[] = "/dev/sda1";
838 r = guestfs_mkfs (g, fstype, device);
843 char device[] = "/dev/sda1";
844 char mountpoint[] = "/";
847 r = guestfs_mount (g, device, mountpoint);
851 /* TestOutputList for head_n (0) */
853 char options[] = "ro";
854 char vfstype[] = "squashfs";
855 char device[] = "/dev/sdd";
856 char mountpoint[] = "/";
859 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
864 char path[] = "/10klines";
868 r = guestfs_head_n (g, 3, path);
872 fprintf (stderr, "test_head_n_0: short list returned from command\n");
877 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
878 if (strcmp (r[0], expected) != 0) {
879 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
884 fprintf (stderr, "test_head_n_0: short list returned from command\n");
889 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
890 if (strcmp (r[1], expected) != 0) {
891 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
896 fprintf (stderr, "test_head_n_0: short list returned from command\n");
901 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
902 if (strcmp (r[2], expected) != 0) {
903 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
908 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
912 for (i = 0; r[i] != NULL; ++i)
919 static int test_head_n_1_skip (void)
923 str = getenv ("TEST_ONLY");
925 return strstr (str, "head_n") == NULL;
926 str = getenv ("SKIP_TEST_HEAD_N_1");
927 if (str && strcmp (str, "1") == 0) return 1;
928 str = getenv ("SKIP_TEST_HEAD_N");
929 if (str && strcmp (str, "1") == 0) return 1;
933 static int test_head_n_1 (void)
935 if (test_head_n_1_skip ()) {
936 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
940 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
942 char device[] = "/dev/sda";
945 r = guestfs_blockdev_setrw (g, device);
952 r = guestfs_umount_all (g);
959 r = guestfs_lvm_remove_all (g);
964 char device[] = "/dev/sda";
965 char lines_0[] = ",";
972 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
977 char fstype[] = "ext2";
978 char device[] = "/dev/sda1";
981 r = guestfs_mkfs (g, fstype, device);
986 char device[] = "/dev/sda1";
987 char mountpoint[] = "/";
990 r = guestfs_mount (g, device, mountpoint);
994 /* TestOutputList for head_n (1) */
996 char options[] = "ro";
997 char vfstype[] = "squashfs";
998 char device[] = "/dev/sdd";
999 char mountpoint[] = "/";
1002 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1007 char path[] = "/10klines";
1011 r = guestfs_head_n (g, -9997, path);
1015 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1020 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1021 if (strcmp (r[0], expected) != 0) {
1022 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1027 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1032 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1033 if (strcmp (r[1], expected) != 0) {
1034 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1039 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1044 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1045 if (strcmp (r[2], expected) != 0) {
1046 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1051 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1055 for (i = 0; r[i] != NULL; ++i)
1062 static int test_head_n_2_skip (void)
1066 str = getenv ("TEST_ONLY");
1068 return strstr (str, "head_n") == NULL;
1069 str = getenv ("SKIP_TEST_HEAD_N_2");
1070 if (str && strcmp (str, "1") == 0) return 1;
1071 str = getenv ("SKIP_TEST_HEAD_N");
1072 if (str && strcmp (str, "1") == 0) return 1;
1076 static int test_head_n_2 (void)
1078 if (test_head_n_2_skip ()) {
1079 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1083 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1085 char device[] = "/dev/sda";
1088 r = guestfs_blockdev_setrw (g, device);
1095 r = guestfs_umount_all (g);
1102 r = guestfs_lvm_remove_all (g);
1107 char device[] = "/dev/sda";
1108 char lines_0[] = ",";
1115 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1120 char fstype[] = "ext2";
1121 char device[] = "/dev/sda1";
1124 r = guestfs_mkfs (g, fstype, device);
1129 char device[] = "/dev/sda1";
1130 char mountpoint[] = "/";
1133 r = guestfs_mount (g, device, mountpoint);
1137 /* TestOutputList for head_n (2) */
1139 char options[] = "ro";
1140 char vfstype[] = "squashfs";
1141 char device[] = "/dev/sdd";
1142 char mountpoint[] = "/";
1145 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1150 char path[] = "/10klines";
1154 r = guestfs_head_n (g, 0, path);
1158 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1162 for (i = 0; r[i] != NULL; ++i)
1169 static int test_head_0_skip (void)
1173 str = getenv ("TEST_ONLY");
1175 return strstr (str, "head") == NULL;
1176 str = getenv ("SKIP_TEST_HEAD_0");
1177 if (str && strcmp (str, "1") == 0) return 1;
1178 str = getenv ("SKIP_TEST_HEAD");
1179 if (str && strcmp (str, "1") == 0) return 1;
1183 static int test_head_0 (void)
1185 if (test_head_0_skip ()) {
1186 printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1190 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1192 char device[] = "/dev/sda";
1195 r = guestfs_blockdev_setrw (g, device);
1202 r = guestfs_umount_all (g);
1209 r = guestfs_lvm_remove_all (g);
1214 char device[] = "/dev/sda";
1215 char lines_0[] = ",";
1222 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1227 char fstype[] = "ext2";
1228 char device[] = "/dev/sda1";
1231 r = guestfs_mkfs (g, fstype, device);
1236 char device[] = "/dev/sda1";
1237 char mountpoint[] = "/";
1240 r = guestfs_mount (g, device, mountpoint);
1244 /* TestOutputList for head (0) */
1246 char options[] = "ro";
1247 char vfstype[] = "squashfs";
1248 char device[] = "/dev/sdd";
1249 char mountpoint[] = "/";
1252 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1257 char path[] = "/10klines";
1261 r = guestfs_head (g, path);
1265 fprintf (stderr, "test_head_0: short list returned from command\n");
1270 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1271 if (strcmp (r[0], expected) != 0) {
1272 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1277 fprintf (stderr, "test_head_0: short list returned from command\n");
1282 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1283 if (strcmp (r[1], expected) != 0) {
1284 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1289 fprintf (stderr, "test_head_0: short list returned from command\n");
1294 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1295 if (strcmp (r[2], expected) != 0) {
1296 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1301 fprintf (stderr, "test_head_0: short list returned from command\n");
1306 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1307 if (strcmp (r[3], expected) != 0) {
1308 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1313 fprintf (stderr, "test_head_0: short list returned from command\n");
1318 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1319 if (strcmp (r[4], expected) != 0) {
1320 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1325 fprintf (stderr, "test_head_0: short list returned from command\n");
1330 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1331 if (strcmp (r[5], expected) != 0) {
1332 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1337 fprintf (stderr, "test_head_0: short list returned from command\n");
1342 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1343 if (strcmp (r[6], expected) != 0) {
1344 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1349 fprintf (stderr, "test_head_0: short list returned from command\n");
1354 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1355 if (strcmp (r[7], expected) != 0) {
1356 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1361 fprintf (stderr, "test_head_0: short list returned from command\n");
1366 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1367 if (strcmp (r[8], expected) != 0) {
1368 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1373 fprintf (stderr, "test_head_0: short list returned from command\n");
1378 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1379 if (strcmp (r[9], expected) != 0) {
1380 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1384 if (r[10] != NULL) {
1385 fprintf (stderr, "test_head_0: extra elements returned from command\n");
1389 for (i = 0; r[i] != NULL; ++i)
1396 static int test_wc_c_0_skip (void)
1400 str = getenv ("TEST_ONLY");
1402 return strstr (str, "wc_c") == NULL;
1403 str = getenv ("SKIP_TEST_WC_C_0");
1404 if (str && strcmp (str, "1") == 0) return 1;
1405 str = getenv ("SKIP_TEST_WC_C");
1406 if (str && strcmp (str, "1") == 0) return 1;
1410 static int test_wc_c_0 (void)
1412 if (test_wc_c_0_skip ()) {
1413 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1417 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1419 char device[] = "/dev/sda";
1422 r = guestfs_blockdev_setrw (g, device);
1429 r = guestfs_umount_all (g);
1436 r = guestfs_lvm_remove_all (g);
1441 char device[] = "/dev/sda";
1442 char lines_0[] = ",";
1449 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1454 char fstype[] = "ext2";
1455 char device[] = "/dev/sda1";
1458 r = guestfs_mkfs (g, fstype, device);
1463 char device[] = "/dev/sda1";
1464 char mountpoint[] = "/";
1467 r = guestfs_mount (g, device, mountpoint);
1471 /* TestOutputInt for wc_c (0) */
1473 char options[] = "ro";
1474 char vfstype[] = "squashfs";
1475 char device[] = "/dev/sdd";
1476 char mountpoint[] = "/";
1479 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1484 char path[] = "/100kallspaces";
1487 r = guestfs_wc_c (g, path);
1491 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
1498 static int test_wc_w_0_skip (void)
1502 str = getenv ("TEST_ONLY");
1504 return strstr (str, "wc_w") == NULL;
1505 str = getenv ("SKIP_TEST_WC_W_0");
1506 if (str && strcmp (str, "1") == 0) return 1;
1507 str = getenv ("SKIP_TEST_WC_W");
1508 if (str && strcmp (str, "1") == 0) return 1;
1512 static int test_wc_w_0 (void)
1514 if (test_wc_w_0_skip ()) {
1515 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1519 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1521 char device[] = "/dev/sda";
1524 r = guestfs_blockdev_setrw (g, device);
1531 r = guestfs_umount_all (g);
1538 r = guestfs_lvm_remove_all (g);
1543 char device[] = "/dev/sda";
1544 char lines_0[] = ",";
1551 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1556 char fstype[] = "ext2";
1557 char device[] = "/dev/sda1";
1560 r = guestfs_mkfs (g, fstype, device);
1565 char device[] = "/dev/sda1";
1566 char mountpoint[] = "/";
1569 r = guestfs_mount (g, device, mountpoint);
1573 /* TestOutputInt for wc_w (0) */
1575 char options[] = "ro";
1576 char vfstype[] = "squashfs";
1577 char device[] = "/dev/sdd";
1578 char mountpoint[] = "/";
1581 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1586 char path[] = "/10klines";
1589 r = guestfs_wc_w (g, path);
1593 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
1600 static int test_wc_l_0_skip (void)
1604 str = getenv ("TEST_ONLY");
1606 return strstr (str, "wc_l") == NULL;
1607 str = getenv ("SKIP_TEST_WC_L_0");
1608 if (str && strcmp (str, "1") == 0) return 1;
1609 str = getenv ("SKIP_TEST_WC_L");
1610 if (str && strcmp (str, "1") == 0) return 1;
1614 static int test_wc_l_0 (void)
1616 if (test_wc_l_0_skip ()) {
1617 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1621 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1623 char device[] = "/dev/sda";
1626 r = guestfs_blockdev_setrw (g, device);
1633 r = guestfs_umount_all (g);
1640 r = guestfs_lvm_remove_all (g);
1645 char device[] = "/dev/sda";
1646 char lines_0[] = ",";
1653 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1658 char fstype[] = "ext2";
1659 char device[] = "/dev/sda1";
1662 r = guestfs_mkfs (g, fstype, device);
1667 char device[] = "/dev/sda1";
1668 char mountpoint[] = "/";
1671 r = guestfs_mount (g, device, mountpoint);
1675 /* TestOutputInt for wc_l (0) */
1677 char options[] = "ro";
1678 char vfstype[] = "squashfs";
1679 char device[] = "/dev/sdd";
1680 char mountpoint[] = "/";
1683 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1688 char path[] = "/10klines";
1691 r = guestfs_wc_l (g, path);
1695 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
1702 static int test_mkdtemp_0_skip (void)
1706 str = getenv ("TEST_ONLY");
1708 return strstr (str, "mkdtemp") == NULL;
1709 str = getenv ("SKIP_TEST_MKDTEMP_0");
1710 if (str && strcmp (str, "1") == 0) return 1;
1711 str = getenv ("SKIP_TEST_MKDTEMP");
1712 if (str && strcmp (str, "1") == 0) return 1;
1716 static int test_mkdtemp_0 (void)
1718 if (test_mkdtemp_0_skip ()) {
1719 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1723 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1725 char device[] = "/dev/sda";
1728 r = guestfs_blockdev_setrw (g, device);
1735 r = guestfs_umount_all (g);
1742 r = guestfs_lvm_remove_all (g);
1747 char device[] = "/dev/sda";
1748 char lines_0[] = ",";
1755 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1760 char fstype[] = "ext2";
1761 char device[] = "/dev/sda1";
1764 r = guestfs_mkfs (g, fstype, device);
1769 char device[] = "/dev/sda1";
1770 char mountpoint[] = "/";
1773 r = guestfs_mount (g, device, mountpoint);
1777 /* TestRun for mkdtemp (0) */
1779 char path[] = "/tmp";
1782 r = guestfs_mkdir (g, path);
1787 char template[] = "/tmp/tmpXXXXXX";
1790 r = guestfs_mkdtemp (g, template);
1798 static int test_scrub_file_0_skip (void)
1802 str = getenv ("TEST_ONLY");
1804 return strstr (str, "scrub_file") == NULL;
1805 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
1806 if (str && strcmp (str, "1") == 0) return 1;
1807 str = getenv ("SKIP_TEST_SCRUB_FILE");
1808 if (str && strcmp (str, "1") == 0) return 1;
1812 static int test_scrub_file_0 (void)
1814 if (test_scrub_file_0_skip ()) {
1815 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
1819 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
1821 char device[] = "/dev/sda";
1824 r = guestfs_blockdev_setrw (g, device);
1831 r = guestfs_umount_all (g);
1838 r = guestfs_lvm_remove_all (g);
1843 char device[] = "/dev/sda";
1844 char lines_0[] = ",";
1851 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1856 char fstype[] = "ext2";
1857 char device[] = "/dev/sda1";
1860 r = guestfs_mkfs (g, fstype, device);
1865 char device[] = "/dev/sda1";
1866 char mountpoint[] = "/";
1869 r = guestfs_mount (g, device, mountpoint);
1873 /* TestRun for scrub_file (0) */
1875 char path[] = "/file";
1876 char content[] = "content";
1879 r = guestfs_write_file (g, path, content, 0);
1884 char file[] = "/file";
1887 r = guestfs_scrub_file (g, file);
1894 static int test_scrub_device_0_skip (void)
1898 str = getenv ("TEST_ONLY");
1900 return strstr (str, "scrub_device") == NULL;
1901 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
1902 if (str && strcmp (str, "1") == 0) return 1;
1903 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
1904 if (str && strcmp (str, "1") == 0) return 1;
1908 static int test_scrub_device_0 (void)
1910 if (test_scrub_device_0_skip ()) {
1911 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
1915 /* InitNone|InitEmpty for test_scrub_device_0 */
1917 char device[] = "/dev/sda";
1920 r = guestfs_blockdev_setrw (g, device);
1927 r = guestfs_umount_all (g);
1934 r = guestfs_lvm_remove_all (g);
1938 /* TestRun for scrub_device (0) */
1940 char device[] = "/dev/sdc";
1943 r = guestfs_scrub_device (g, device);
1950 static int test_glob_expand_0_skip (void)
1954 str = getenv ("TEST_ONLY");
1956 return strstr (str, "glob_expand") == NULL;
1957 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
1958 if (str && strcmp (str, "1") == 0) return 1;
1959 str = getenv ("SKIP_TEST_GLOB_EXPAND");
1960 if (str && strcmp (str, "1") == 0) return 1;
1964 static int test_glob_expand_0 (void)
1966 if (test_glob_expand_0_skip ()) {
1967 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
1971 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
1973 char device[] = "/dev/sda";
1976 r = guestfs_blockdev_setrw (g, device);
1983 r = guestfs_umount_all (g);
1990 r = guestfs_lvm_remove_all (g);
1995 char device[] = "/dev/sda";
1996 char lines_0[] = ",";
2003 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2008 char fstype[] = "ext2";
2009 char device[] = "/dev/sda1";
2012 r = guestfs_mkfs (g, fstype, device);
2017 char device[] = "/dev/sda1";
2018 char mountpoint[] = "/";
2021 r = guestfs_mount (g, device, mountpoint);
2025 /* TestOutputList for glob_expand (0) */
2027 char path[] = "/a/b/c";
2030 r = guestfs_mkdir_p (g, path);
2035 char path[] = "/a/b/c/d";
2038 r = guestfs_touch (g, path);
2043 char path[] = "/a/b/c/e";
2046 r = guestfs_touch (g, path);
2051 char pattern[] = "/a/b/c/*";
2055 r = guestfs_glob_expand (g, pattern);
2059 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2064 char expected[] = "/a/b/c/d";
2065 if (strcmp (r[0], expected) != 0) {
2066 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2071 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2076 char expected[] = "/a/b/c/e";
2077 if (strcmp (r[1], expected) != 0) {
2078 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2083 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2087 for (i = 0; r[i] != NULL; ++i)
2094 static int test_glob_expand_1_skip (void)
2098 str = getenv ("TEST_ONLY");
2100 return strstr (str, "glob_expand") == NULL;
2101 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2102 if (str && strcmp (str, "1") == 0) return 1;
2103 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2104 if (str && strcmp (str, "1") == 0) return 1;
2108 static int test_glob_expand_1 (void)
2110 if (test_glob_expand_1_skip ()) {
2111 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2115 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2117 char device[] = "/dev/sda";
2120 r = guestfs_blockdev_setrw (g, device);
2127 r = guestfs_umount_all (g);
2134 r = guestfs_lvm_remove_all (g);
2139 char device[] = "/dev/sda";
2140 char lines_0[] = ",";
2147 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2152 char fstype[] = "ext2";
2153 char device[] = "/dev/sda1";
2156 r = guestfs_mkfs (g, fstype, device);
2161 char device[] = "/dev/sda1";
2162 char mountpoint[] = "/";
2165 r = guestfs_mount (g, device, mountpoint);
2169 /* TestOutputList for glob_expand (1) */
2171 char path[] = "/a/b/c";
2174 r = guestfs_mkdir_p (g, path);
2179 char path[] = "/a/b/c/d";
2182 r = guestfs_touch (g, path);
2187 char path[] = "/a/b/c/e";
2190 r = guestfs_touch (g, path);
2195 char pattern[] = "/a/*/c/*";
2199 r = guestfs_glob_expand (g, pattern);
2203 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2208 char expected[] = "/a/b/c/d";
2209 if (strcmp (r[0], expected) != 0) {
2210 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2215 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2220 char expected[] = "/a/b/c/e";
2221 if (strcmp (r[1], expected) != 0) {
2222 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2227 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2231 for (i = 0; r[i] != NULL; ++i)
2238 static int test_glob_expand_2_skip (void)
2242 str = getenv ("TEST_ONLY");
2244 return strstr (str, "glob_expand") == NULL;
2245 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2246 if (str && strcmp (str, "1") == 0) return 1;
2247 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2248 if (str && strcmp (str, "1") == 0) return 1;
2252 static int test_glob_expand_2 (void)
2254 if (test_glob_expand_2_skip ()) {
2255 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2259 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2261 char device[] = "/dev/sda";
2264 r = guestfs_blockdev_setrw (g, device);
2271 r = guestfs_umount_all (g);
2278 r = guestfs_lvm_remove_all (g);
2283 char device[] = "/dev/sda";
2284 char lines_0[] = ",";
2291 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2296 char fstype[] = "ext2";
2297 char device[] = "/dev/sda1";
2300 r = guestfs_mkfs (g, fstype, device);
2305 char device[] = "/dev/sda1";
2306 char mountpoint[] = "/";
2309 r = guestfs_mount (g, device, mountpoint);
2313 /* TestOutputList for glob_expand (2) */
2315 char path[] = "/a/b/c";
2318 r = guestfs_mkdir_p (g, path);
2323 char path[] = "/a/b/c/d";
2326 r = guestfs_touch (g, path);
2331 char path[] = "/a/b/c/e";
2334 r = guestfs_touch (g, path);
2339 char pattern[] = "/a/*/x/*";
2343 r = guestfs_glob_expand (g, pattern);
2347 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2351 for (i = 0; r[i] != NULL; ++i)
2358 static int test_ntfs_3g_probe_0_skip (void)
2362 str = getenv ("TEST_ONLY");
2364 return strstr (str, "ntfs_3g_probe") == NULL;
2365 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2366 if (str && strcmp (str, "1") == 0) return 1;
2367 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2368 if (str && strcmp (str, "1") == 0) return 1;
2372 static int test_ntfs_3g_probe_0 (void)
2374 if (test_ntfs_3g_probe_0_skip ()) {
2375 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2379 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2381 char device[] = "/dev/sda";
2384 r = guestfs_blockdev_setrw (g, device);
2391 r = guestfs_umount_all (g);
2398 r = guestfs_lvm_remove_all (g);
2402 /* TestOutputInt for ntfs_3g_probe (0) */
2404 char device[] = "/dev/sda";
2405 char lines_0[] = ",";
2412 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2417 char fstype[] = "ntfs";
2418 char device[] = "/dev/sda1";
2421 r = guestfs_mkfs (g, fstype, device);
2426 char device[] = "/dev/sda1";
2429 r = guestfs_ntfs_3g_probe (g, 1, device);
2433 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
2440 static int test_ntfs_3g_probe_1_skip (void)
2444 str = getenv ("TEST_ONLY");
2446 return strstr (str, "ntfs_3g_probe") == NULL;
2447 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2448 if (str && strcmp (str, "1") == 0) return 1;
2449 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2450 if (str && strcmp (str, "1") == 0) return 1;
2454 static int test_ntfs_3g_probe_1 (void)
2456 if (test_ntfs_3g_probe_1_skip ()) {
2457 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2461 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2463 char device[] = "/dev/sda";
2466 r = guestfs_blockdev_setrw (g, device);
2473 r = guestfs_umount_all (g);
2480 r = guestfs_lvm_remove_all (g);
2484 /* TestOutputInt for ntfs_3g_probe (1) */
2486 char device[] = "/dev/sda";
2487 char lines_0[] = ",";
2494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2499 char fstype[] = "ext2";
2500 char device[] = "/dev/sda1";
2503 r = guestfs_mkfs (g, fstype, device);
2508 char device[] = "/dev/sda1";
2511 r = guestfs_ntfs_3g_probe (g, 1, device);
2515 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
2522 static int test_sleep_0_skip (void)
2526 str = getenv ("TEST_ONLY");
2528 return strstr (str, "sleep") == NULL;
2529 str = getenv ("SKIP_TEST_SLEEP_0");
2530 if (str && strcmp (str, "1") == 0) return 1;
2531 str = getenv ("SKIP_TEST_SLEEP");
2532 if (str && strcmp (str, "1") == 0) return 1;
2536 static int test_sleep_0 (void)
2538 if (test_sleep_0_skip ()) {
2539 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2543 /* InitNone|InitEmpty for test_sleep_0 */
2545 char device[] = "/dev/sda";
2548 r = guestfs_blockdev_setrw (g, device);
2555 r = guestfs_umount_all (g);
2562 r = guestfs_lvm_remove_all (g);
2566 /* TestRun for sleep (0) */
2570 r = guestfs_sleep (g, 1);
2577 static int test_find_0_skip (void)
2581 str = getenv ("TEST_ONLY");
2583 return strstr (str, "find") == NULL;
2584 str = getenv ("SKIP_TEST_FIND_0");
2585 if (str && strcmp (str, "1") == 0) return 1;
2586 str = getenv ("SKIP_TEST_FIND");
2587 if (str && strcmp (str, "1") == 0) return 1;
2591 static int test_find_0 (void)
2593 if (test_find_0_skip ()) {
2594 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2598 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2600 char device[] = "/dev/sda";
2603 r = guestfs_blockdev_setrw (g, device);
2610 r = guestfs_umount_all (g);
2617 r = guestfs_lvm_remove_all (g);
2622 char device[] = "/dev/sda";
2623 char lines_0[] = ",";
2630 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2635 char fstype[] = "ext2";
2636 char device[] = "/dev/sda1";
2639 r = guestfs_mkfs (g, fstype, device);
2644 char device[] = "/dev/sda1";
2645 char mountpoint[] = "/";
2648 r = guestfs_mount (g, device, mountpoint);
2652 /* TestOutputList for find (0) */
2654 char directory[] = "/";
2658 r = guestfs_find (g, directory);
2662 fprintf (stderr, "test_find_0: short list returned from command\n");
2667 char expected[] = "lost+found";
2668 if (strcmp (r[0], expected) != 0) {
2669 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2674 fprintf (stderr, "test_find_0: extra elements returned from command\n");
2678 for (i = 0; r[i] != NULL; ++i)
2685 static int test_find_1_skip (void)
2689 str = getenv ("TEST_ONLY");
2691 return strstr (str, "find") == NULL;
2692 str = getenv ("SKIP_TEST_FIND_1");
2693 if (str && strcmp (str, "1") == 0) return 1;
2694 str = getenv ("SKIP_TEST_FIND");
2695 if (str && strcmp (str, "1") == 0) return 1;
2699 static int test_find_1 (void)
2701 if (test_find_1_skip ()) {
2702 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2706 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2708 char device[] = "/dev/sda";
2711 r = guestfs_blockdev_setrw (g, device);
2718 r = guestfs_umount_all (g);
2725 r = guestfs_lvm_remove_all (g);
2730 char device[] = "/dev/sda";
2731 char lines_0[] = ",";
2738 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2743 char fstype[] = "ext2";
2744 char device[] = "/dev/sda1";
2747 r = guestfs_mkfs (g, fstype, device);
2752 char device[] = "/dev/sda1";
2753 char mountpoint[] = "/";
2756 r = guestfs_mount (g, device, mountpoint);
2760 /* TestOutputList for find (1) */
2765 r = guestfs_touch (g, path);
2773 r = guestfs_mkdir (g, path);
2778 char path[] = "/b/c";
2781 r = guestfs_touch (g, path);
2786 char directory[] = "/";
2790 r = guestfs_find (g, directory);
2794 fprintf (stderr, "test_find_1: short list returned from command\n");
2799 char expected[] = "a";
2800 if (strcmp (r[0], expected) != 0) {
2801 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2806 fprintf (stderr, "test_find_1: short list returned from command\n");
2811 char expected[] = "b";
2812 if (strcmp (r[1], expected) != 0) {
2813 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2818 fprintf (stderr, "test_find_1: short list returned from command\n");
2823 char expected[] = "b/c";
2824 if (strcmp (r[2], expected) != 0) {
2825 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2830 fprintf (stderr, "test_find_1: short list returned from command\n");
2835 char expected[] = "lost+found";
2836 if (strcmp (r[3], expected) != 0) {
2837 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2842 fprintf (stderr, "test_find_1: extra elements returned from command\n");
2846 for (i = 0; r[i] != NULL; ++i)
2853 static int test_find_2_skip (void)
2857 str = getenv ("TEST_ONLY");
2859 return strstr (str, "find") == NULL;
2860 str = getenv ("SKIP_TEST_FIND_2");
2861 if (str && strcmp (str, "1") == 0) return 1;
2862 str = getenv ("SKIP_TEST_FIND");
2863 if (str && strcmp (str, "1") == 0) return 1;
2867 static int test_find_2 (void)
2869 if (test_find_2_skip ()) {
2870 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
2874 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
2876 char device[] = "/dev/sda";
2879 r = guestfs_blockdev_setrw (g, device);
2886 r = guestfs_umount_all (g);
2893 r = guestfs_lvm_remove_all (g);
2898 char device[] = "/dev/sda";
2899 char lines_0[] = ",";
2906 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2911 char fstype[] = "ext2";
2912 char device[] = "/dev/sda1";
2915 r = guestfs_mkfs (g, fstype, device);
2920 char device[] = "/dev/sda1";
2921 char mountpoint[] = "/";
2924 r = guestfs_mount (g, device, mountpoint);
2928 /* TestOutputList for find (2) */
2930 char path[] = "/a/b/c";
2933 r = guestfs_mkdir_p (g, path);
2938 char path[] = "/a/b/c/d";
2941 r = guestfs_touch (g, path);
2946 char directory[] = "/a/b/";
2950 r = guestfs_find (g, directory);
2954 fprintf (stderr, "test_find_2: short list returned from command\n");
2959 char expected[] = "c";
2960 if (strcmp (r[0], expected) != 0) {
2961 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2966 fprintf (stderr, "test_find_2: short list returned from command\n");
2971 char expected[] = "c/d";
2972 if (strcmp (r[1], expected) != 0) {
2973 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2978 fprintf (stderr, "test_find_2: extra elements returned from command\n");
2982 for (i = 0; r[i] != NULL; ++i)
2989 static int test_lvresize_0_skip (void)
2993 str = getenv ("TEST_ONLY");
2995 return strstr (str, "lvresize") == NULL;
2996 str = getenv ("SKIP_TEST_LVRESIZE_0");
2997 if (str && strcmp (str, "1") == 0) return 1;
2998 str = getenv ("SKIP_TEST_LVRESIZE");
2999 if (str && strcmp (str, "1") == 0) return 1;
3003 static int test_lvresize_0 (void)
3005 if (test_lvresize_0_skip ()) {
3006 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3010 /* InitNone|InitEmpty for test_lvresize_0 */
3012 char device[] = "/dev/sda";
3015 r = guestfs_blockdev_setrw (g, device);
3022 r = guestfs_umount_all (g);
3029 r = guestfs_lvm_remove_all (g);
3033 /* TestOutput for lvresize (0) */
3034 char expected[] = "test content";
3036 char device[] = "/dev/sda";
3037 char lines_0[] = ",";
3044 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3049 char device[] = "/dev/sda1";
3052 r = guestfs_pvcreate (g, device);
3057 char volgroup[] = "VG";
3058 char physvols_0[] = "/dev/sda1";
3059 char *physvols[] = {
3065 r = guestfs_vgcreate (g, volgroup, physvols);
3070 char logvol[] = "LV";
3071 char volgroup[] = "VG";
3074 r = guestfs_lvcreate (g, logvol, volgroup, 10);
3079 char fstype[] = "ext2";
3080 char device[] = "/dev/VG/LV";
3083 r = guestfs_mkfs (g, fstype, device);
3088 char device[] = "/dev/VG/LV";
3089 char mountpoint[] = "/";
3092 r = guestfs_mount (g, device, mountpoint);
3097 char path[] = "/new";
3098 char content[] = "test content";
3101 r = guestfs_write_file (g, path, content, 0);
3106 char pathordevice[] = "/";
3109 r = guestfs_umount (g, pathordevice);
3114 char device[] = "/dev/VG/LV";
3117 r = guestfs_lvresize (g, device, 20);
3122 char device[] = "/dev/VG/LV";
3125 r = guestfs_e2fsck_f (g, device);
3130 char device[] = "/dev/VG/LV";
3133 r = guestfs_resize2fs (g, device);
3138 char device[] = "/dev/VG/LV";
3139 char mountpoint[] = "/";
3142 r = guestfs_mount (g, device, mountpoint);
3147 char path[] = "/new";
3150 r = guestfs_cat (g, path);
3153 if (strcmp (r, expected) != 0) {
3154 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3162 static int test_zerofree_0_skip (void)
3166 str = getenv ("TEST_ONLY");
3168 return strstr (str, "zerofree") == NULL;
3169 str = getenv ("SKIP_TEST_ZEROFREE_0");
3170 if (str && strcmp (str, "1") == 0) return 1;
3171 str = getenv ("SKIP_TEST_ZEROFREE");
3172 if (str && strcmp (str, "1") == 0) return 1;
3176 static int test_zerofree_0 (void)
3178 if (test_zerofree_0_skip ()) {
3179 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3183 /* InitNone|InitEmpty for test_zerofree_0 */
3185 char device[] = "/dev/sda";
3188 r = guestfs_blockdev_setrw (g, device);
3195 r = guestfs_umount_all (g);
3202 r = guestfs_lvm_remove_all (g);
3206 /* TestOutput for zerofree (0) */
3207 char expected[] = "test file";
3209 char device[] = "/dev/sda";
3210 char lines_0[] = ",";
3217 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3222 char fstype[] = "ext3";
3223 char device[] = "/dev/sda1";
3226 r = guestfs_mkfs (g, fstype, device);
3231 char device[] = "/dev/sda1";
3232 char mountpoint[] = "/";
3235 r = guestfs_mount (g, device, mountpoint);
3240 char path[] = "/new";
3241 char content[] = "test file";
3244 r = guestfs_write_file (g, path, content, 0);
3249 char pathordevice[] = "/dev/sda1";
3252 r = guestfs_umount (g, pathordevice);
3257 char device[] = "/dev/sda1";
3260 r = guestfs_zerofree (g, device);
3265 char device[] = "/dev/sda1";
3266 char mountpoint[] = "/";
3269 r = guestfs_mount (g, device, mountpoint);
3274 char path[] = "/new";
3277 r = guestfs_cat (g, path);
3280 if (strcmp (r, expected) != 0) {
3281 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3289 static int test_hexdump_0_skip (void)
3293 str = getenv ("TEST_ONLY");
3295 return strstr (str, "hexdump") == NULL;
3296 str = getenv ("SKIP_TEST_HEXDUMP_0");
3297 if (str && strcmp (str, "1") == 0) return 1;
3298 str = getenv ("SKIP_TEST_HEXDUMP");
3299 if (str && strcmp (str, "1") == 0) return 1;
3303 static int test_hexdump_0 (void)
3305 if (test_hexdump_0_skip ()) {
3306 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3310 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3312 char device[] = "/dev/sda";
3315 r = guestfs_blockdev_setrw (g, device);
3322 r = guestfs_umount_all (g);
3329 r = guestfs_lvm_remove_all (g);
3334 char device[] = "/dev/sda";
3335 char lines_0[] = ",";
3342 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3347 char fstype[] = "ext2";
3348 char device[] = "/dev/sda1";
3351 r = guestfs_mkfs (g, fstype, device);
3356 char device[] = "/dev/sda1";
3357 char mountpoint[] = "/";
3360 r = guestfs_mount (g, device, mountpoint);
3364 /* TestOutput for hexdump (0) */
3365 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
3367 char path[] = "/new";
3368 char content[] = "hello\nworld\n";
3371 r = guestfs_write_file (g, path, content, 12);
3376 char path[] = "/new";
3379 r = guestfs_hexdump (g, path);
3382 if (strcmp (r, expected) != 0) {
3383 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3391 static int test_hexdump_1_skip (void)
3395 str = getenv ("TEST_ONLY");
3397 return strstr (str, "hexdump") == NULL;
3398 str = getenv ("SKIP_TEST_HEXDUMP_1");
3399 if (str && strcmp (str, "1") == 0) return 1;
3400 str = getenv ("SKIP_TEST_HEXDUMP");
3401 if (str && strcmp (str, "1") == 0) return 1;
3405 static int test_hexdump_1 (void)
3407 if (test_hexdump_1_skip ()) {
3408 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3412 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3414 char device[] = "/dev/sda";
3417 r = guestfs_blockdev_setrw (g, device);
3424 r = guestfs_umount_all (g);
3431 r = guestfs_lvm_remove_all (g);
3436 char device[] = "/dev/sda";
3437 char lines_0[] = ",";
3444 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3449 char fstype[] = "ext2";
3450 char device[] = "/dev/sda1";
3453 r = guestfs_mkfs (g, fstype, device);
3458 char device[] = "/dev/sda1";
3459 char mountpoint[] = "/";
3462 r = guestfs_mount (g, device, mountpoint);
3466 /* TestRun for hexdump (1) */
3468 char options[] = "ro";
3469 char vfstype[] = "squashfs";
3470 char device[] = "/dev/sdd";
3471 char mountpoint[] = "/";
3474 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3479 char path[] = "/100krandom";
3482 r = guestfs_hexdump (g, path);
3490 static int test_strings_e_0_skip (void)
3494 str = getenv ("TEST_ONLY");
3496 return strstr (str, "strings_e") == NULL;
3497 str = getenv ("SKIP_TEST_STRINGS_E_0");
3498 if (str && strcmp (str, "1") == 0) return 1;
3499 str = getenv ("SKIP_TEST_STRINGS_E");
3500 if (str && strcmp (str, "1") == 0) return 1;
3504 static int test_strings_e_0 (void)
3506 if (test_strings_e_0_skip ()) {
3507 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3511 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3513 char device[] = "/dev/sda";
3516 r = guestfs_blockdev_setrw (g, device);
3523 r = guestfs_umount_all (g);
3530 r = guestfs_lvm_remove_all (g);
3535 char device[] = "/dev/sda";
3536 char lines_0[] = ",";
3543 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3548 char fstype[] = "ext2";
3549 char device[] = "/dev/sda1";
3552 r = guestfs_mkfs (g, fstype, device);
3557 char device[] = "/dev/sda1";
3558 char mountpoint[] = "/";
3561 r = guestfs_mount (g, device, mountpoint);
3565 /* TestOutputList for strings_e (0) */
3567 char path[] = "/new";
3568 char content[] = "hello\nworld\n";
3571 r = guestfs_write_file (g, path, content, 0);
3576 char encoding[] = "b";
3577 char path[] = "/new";
3581 r = guestfs_strings_e (g, encoding, path);
3585 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3589 for (i = 0; r[i] != NULL; ++i)
3596 static int test_strings_e_1_skip (void)
3600 str = getenv ("TEST_ONLY");
3602 return strstr (str, "strings_e") == NULL;
3603 str = getenv ("SKIP_TEST_STRINGS_E_1");
3604 if (str && strcmp (str, "1") == 0) return 1;
3605 str = getenv ("SKIP_TEST_STRINGS_E");
3606 if (str && strcmp (str, "1") == 0) return 1;
3610 static int test_strings_e_1 (void)
3612 if (test_strings_e_1_skip ()) {
3613 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3617 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3621 static int test_strings_0_skip (void)
3625 str = getenv ("TEST_ONLY");
3627 return strstr (str, "strings") == NULL;
3628 str = getenv ("SKIP_TEST_STRINGS_0");
3629 if (str && strcmp (str, "1") == 0) return 1;
3630 str = getenv ("SKIP_TEST_STRINGS");
3631 if (str && strcmp (str, "1") == 0) return 1;
3635 static int test_strings_0 (void)
3637 if (test_strings_0_skip ()) {
3638 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3642 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3644 char device[] = "/dev/sda";
3647 r = guestfs_blockdev_setrw (g, device);
3654 r = guestfs_umount_all (g);
3661 r = guestfs_lvm_remove_all (g);
3666 char device[] = "/dev/sda";
3667 char lines_0[] = ",";
3674 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3679 char fstype[] = "ext2";
3680 char device[] = "/dev/sda1";
3683 r = guestfs_mkfs (g, fstype, device);
3688 char device[] = "/dev/sda1";
3689 char mountpoint[] = "/";
3692 r = guestfs_mount (g, device, mountpoint);
3696 /* TestOutputList for strings (0) */
3698 char path[] = "/new";
3699 char content[] = "hello\nworld\n";
3702 r = guestfs_write_file (g, path, content, 0);
3707 char path[] = "/new";
3711 r = guestfs_strings (g, path);
3715 fprintf (stderr, "test_strings_0: short list returned from command\n");
3720 char expected[] = "hello";
3721 if (strcmp (r[0], expected) != 0) {
3722 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3727 fprintf (stderr, "test_strings_0: short list returned from command\n");
3732 char expected[] = "world";
3733 if (strcmp (r[1], expected) != 0) {
3734 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3739 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
3743 for (i = 0; r[i] != NULL; ++i)
3750 static int test_strings_1_skip (void)
3754 str = getenv ("TEST_ONLY");
3756 return strstr (str, "strings") == NULL;
3757 str = getenv ("SKIP_TEST_STRINGS_1");
3758 if (str && strcmp (str, "1") == 0) return 1;
3759 str = getenv ("SKIP_TEST_STRINGS");
3760 if (str && strcmp (str, "1") == 0) return 1;
3764 static int test_strings_1 (void)
3766 if (test_strings_1_skip ()) {
3767 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
3771 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
3773 char device[] = "/dev/sda";
3776 r = guestfs_blockdev_setrw (g, device);
3783 r = guestfs_umount_all (g);
3790 r = guestfs_lvm_remove_all (g);
3795 char device[] = "/dev/sda";
3796 char lines_0[] = ",";
3803 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3808 char fstype[] = "ext2";
3809 char device[] = "/dev/sda1";
3812 r = guestfs_mkfs (g, fstype, device);
3817 char device[] = "/dev/sda1";
3818 char mountpoint[] = "/";
3821 r = guestfs_mount (g, device, mountpoint);
3825 /* TestOutputList for strings (1) */
3827 char path[] = "/new";
3830 r = guestfs_touch (g, path);
3835 char path[] = "/new";
3839 r = guestfs_strings (g, path);
3843 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
3847 for (i = 0; r[i] != NULL; ++i)
3854 static int test_equal_0_skip (void)
3858 str = getenv ("TEST_ONLY");
3860 return strstr (str, "equal") == NULL;
3861 str = getenv ("SKIP_TEST_EQUAL_0");
3862 if (str && strcmp (str, "1") == 0) return 1;
3863 str = getenv ("SKIP_TEST_EQUAL");
3864 if (str && strcmp (str, "1") == 0) return 1;
3868 static int test_equal_0 (void)
3870 if (test_equal_0_skip ()) {
3871 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
3875 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
3877 char device[] = "/dev/sda";
3880 r = guestfs_blockdev_setrw (g, device);
3887 r = guestfs_umount_all (g);
3894 r = guestfs_lvm_remove_all (g);
3899 char device[] = "/dev/sda";
3900 char lines_0[] = ",";
3907 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3912 char fstype[] = "ext2";
3913 char device[] = "/dev/sda1";
3916 r = guestfs_mkfs (g, fstype, device);
3921 char device[] = "/dev/sda1";
3922 char mountpoint[] = "/";
3925 r = guestfs_mount (g, device, mountpoint);
3929 /* TestOutputTrue for equal (0) */
3931 char path[] = "/file1";
3932 char content[] = "contents of a file";
3935 r = guestfs_write_file (g, path, content, 0);
3940 char src[] = "/file1";
3941 char dest[] = "/file2";
3944 r = guestfs_cp (g, src, dest);
3949 char file1[] = "/file1";
3950 char file2[] = "/file2";
3953 r = guestfs_equal (g, file1, file2);
3957 fprintf (stderr, "test_equal_0: expected true, got false\n");
3964 static int test_equal_1_skip (void)
3968 str = getenv ("TEST_ONLY");
3970 return strstr (str, "equal") == NULL;
3971 str = getenv ("SKIP_TEST_EQUAL_1");
3972 if (str && strcmp (str, "1") == 0) return 1;
3973 str = getenv ("SKIP_TEST_EQUAL");
3974 if (str && strcmp (str, "1") == 0) return 1;
3978 static int test_equal_1 (void)
3980 if (test_equal_1_skip ()) {
3981 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
3985 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
3987 char device[] = "/dev/sda";
3990 r = guestfs_blockdev_setrw (g, device);
3997 r = guestfs_umount_all (g);
4004 r = guestfs_lvm_remove_all (g);
4009 char device[] = "/dev/sda";
4010 char lines_0[] = ",";
4017 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4022 char fstype[] = "ext2";
4023 char device[] = "/dev/sda1";
4026 r = guestfs_mkfs (g, fstype, device);
4031 char device[] = "/dev/sda1";
4032 char mountpoint[] = "/";
4035 r = guestfs_mount (g, device, mountpoint);
4039 /* TestOutputFalse for equal (1) */
4041 char path[] = "/file1";
4042 char content[] = "contents of a file";
4045 r = guestfs_write_file (g, path, content, 0);
4050 char path[] = "/file2";
4051 char content[] = "contents of another file";
4054 r = guestfs_write_file (g, path, content, 0);
4059 char file1[] = "/file1";
4060 char file2[] = "/file2";
4063 r = guestfs_equal (g, file1, file2);
4067 fprintf (stderr, "test_equal_1: expected false, got true\n");
4074 static int test_equal_2_skip (void)
4078 str = getenv ("TEST_ONLY");
4080 return strstr (str, "equal") == NULL;
4081 str = getenv ("SKIP_TEST_EQUAL_2");
4082 if (str && strcmp (str, "1") == 0) return 1;
4083 str = getenv ("SKIP_TEST_EQUAL");
4084 if (str && strcmp (str, "1") == 0) return 1;
4088 static int test_equal_2 (void)
4090 if (test_equal_2_skip ()) {
4091 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4095 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4097 char device[] = "/dev/sda";
4100 r = guestfs_blockdev_setrw (g, device);
4107 r = guestfs_umount_all (g);
4114 r = guestfs_lvm_remove_all (g);
4119 char device[] = "/dev/sda";
4120 char lines_0[] = ",";
4127 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4132 char fstype[] = "ext2";
4133 char device[] = "/dev/sda1";
4136 r = guestfs_mkfs (g, fstype, device);
4141 char device[] = "/dev/sda1";
4142 char mountpoint[] = "/";
4145 r = guestfs_mount (g, device, mountpoint);
4149 /* TestLastFail for equal (2) */
4151 char file1[] = "/file1";
4152 char file2[] = "/file2";
4155 r = guestfs_equal (g, file1, file2);
4162 static int test_ping_daemon_0_skip (void)
4166 str = getenv ("TEST_ONLY");
4168 return strstr (str, "ping_daemon") == NULL;
4169 str = getenv ("SKIP_TEST_PING_DAEMON_0");
4170 if (str && strcmp (str, "1") == 0) return 1;
4171 str = getenv ("SKIP_TEST_PING_DAEMON");
4172 if (str && strcmp (str, "1") == 0) return 1;
4176 static int test_ping_daemon_0 (void)
4178 if (test_ping_daemon_0_skip ()) {
4179 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4183 /* InitNone|InitEmpty for test_ping_daemon_0 */
4185 char device[] = "/dev/sda";
4188 r = guestfs_blockdev_setrw (g, device);
4195 r = guestfs_umount_all (g);
4202 r = guestfs_lvm_remove_all (g);
4206 /* TestRun for ping_daemon (0) */
4210 r = guestfs_ping_daemon (g);
4217 static int test_dmesg_0_skip (void)
4221 str = getenv ("TEST_ONLY");
4223 return strstr (str, "dmesg") == NULL;
4224 str = getenv ("SKIP_TEST_DMESG_0");
4225 if (str && strcmp (str, "1") == 0) return 1;
4226 str = getenv ("SKIP_TEST_DMESG");
4227 if (str && strcmp (str, "1") == 0) return 1;
4231 static int test_dmesg_0 (void)
4233 if (test_dmesg_0_skip ()) {
4234 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4238 /* InitNone|InitEmpty for test_dmesg_0 */
4240 char device[] = "/dev/sda";
4243 r = guestfs_blockdev_setrw (g, device);
4250 r = guestfs_umount_all (g);
4257 r = guestfs_lvm_remove_all (g);
4261 /* TestRun for dmesg (0) */
4265 r = guestfs_dmesg (g);
4273 static int test_drop_caches_0_skip (void)
4277 str = getenv ("TEST_ONLY");
4279 return strstr (str, "drop_caches") == NULL;
4280 str = getenv ("SKIP_TEST_DROP_CACHES_0");
4281 if (str && strcmp (str, "1") == 0) return 1;
4282 str = getenv ("SKIP_TEST_DROP_CACHES");
4283 if (str && strcmp (str, "1") == 0) return 1;
4287 static int test_drop_caches_0 (void)
4289 if (test_drop_caches_0_skip ()) {
4290 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4294 /* InitNone|InitEmpty for test_drop_caches_0 */
4296 char device[] = "/dev/sda";
4299 r = guestfs_blockdev_setrw (g, device);
4306 r = guestfs_umount_all (g);
4313 r = guestfs_lvm_remove_all (g);
4317 /* TestRun for drop_caches (0) */
4321 r = guestfs_drop_caches (g, 3);
4328 static int test_mv_0_skip (void)
4332 str = getenv ("TEST_ONLY");
4334 return strstr (str, "mv") == NULL;
4335 str = getenv ("SKIP_TEST_MV_0");
4336 if (str && strcmp (str, "1") == 0) return 1;
4337 str = getenv ("SKIP_TEST_MV");
4338 if (str && strcmp (str, "1") == 0) return 1;
4342 static int test_mv_0 (void)
4344 if (test_mv_0_skip ()) {
4345 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4349 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4351 char device[] = "/dev/sda";
4354 r = guestfs_blockdev_setrw (g, device);
4361 r = guestfs_umount_all (g);
4368 r = guestfs_lvm_remove_all (g);
4373 char device[] = "/dev/sda";
4374 char lines_0[] = ",";
4381 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4386 char fstype[] = "ext2";
4387 char device[] = "/dev/sda1";
4390 r = guestfs_mkfs (g, fstype, device);
4395 char device[] = "/dev/sda1";
4396 char mountpoint[] = "/";
4399 r = guestfs_mount (g, device, mountpoint);
4403 /* TestOutput for mv (0) */
4404 char expected[] = "file content";
4406 char path[] = "/old";
4407 char content[] = "file content";
4410 r = guestfs_write_file (g, path, content, 0);
4415 char src[] = "/old";
4416 char dest[] = "/new";
4419 r = guestfs_mv (g, src, dest);
4424 char path[] = "/new";
4427 r = guestfs_cat (g, path);
4430 if (strcmp (r, expected) != 0) {
4431 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4439 static int test_mv_1_skip (void)
4443 str = getenv ("TEST_ONLY");
4445 return strstr (str, "mv") == NULL;
4446 str = getenv ("SKIP_TEST_MV_1");
4447 if (str && strcmp (str, "1") == 0) return 1;
4448 str = getenv ("SKIP_TEST_MV");
4449 if (str && strcmp (str, "1") == 0) return 1;
4453 static int test_mv_1 (void)
4455 if (test_mv_1_skip ()) {
4456 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4460 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4462 char device[] = "/dev/sda";
4465 r = guestfs_blockdev_setrw (g, device);
4472 r = guestfs_umount_all (g);
4479 r = guestfs_lvm_remove_all (g);
4484 char device[] = "/dev/sda";
4485 char lines_0[] = ",";
4492 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4497 char fstype[] = "ext2";
4498 char device[] = "/dev/sda1";
4501 r = guestfs_mkfs (g, fstype, device);
4506 char device[] = "/dev/sda1";
4507 char mountpoint[] = "/";
4510 r = guestfs_mount (g, device, mountpoint);
4514 /* TestOutputFalse for mv (1) */
4516 char path[] = "/old";
4517 char content[] = "file content";
4520 r = guestfs_write_file (g, path, content, 0);
4525 char src[] = "/old";
4526 char dest[] = "/new";
4529 r = guestfs_mv (g, src, dest);
4534 char path[] = "/old";
4537 r = guestfs_is_file (g, path);
4541 fprintf (stderr, "test_mv_1: expected false, got true\n");
4548 static int test_cp_a_0_skip (void)
4552 str = getenv ("TEST_ONLY");
4554 return strstr (str, "cp_a") == NULL;
4555 str = getenv ("SKIP_TEST_CP_A_0");
4556 if (str && strcmp (str, "1") == 0) return 1;
4557 str = getenv ("SKIP_TEST_CP_A");
4558 if (str && strcmp (str, "1") == 0) return 1;
4562 static int test_cp_a_0 (void)
4564 if (test_cp_a_0_skip ()) {
4565 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4569 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4571 char device[] = "/dev/sda";
4574 r = guestfs_blockdev_setrw (g, device);
4581 r = guestfs_umount_all (g);
4588 r = guestfs_lvm_remove_all (g);
4593 char device[] = "/dev/sda";
4594 char lines_0[] = ",";
4601 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4606 char fstype[] = "ext2";
4607 char device[] = "/dev/sda1";
4610 r = guestfs_mkfs (g, fstype, device);
4615 char device[] = "/dev/sda1";
4616 char mountpoint[] = "/";
4619 r = guestfs_mount (g, device, mountpoint);
4623 /* TestOutput for cp_a (0) */
4624 char expected[] = "file content";
4626 char path[] = "/olddir";
4629 r = guestfs_mkdir (g, path);
4634 char path[] = "/newdir";
4637 r = guestfs_mkdir (g, path);
4642 char path[] = "/olddir/file";
4643 char content[] = "file content";
4646 r = guestfs_write_file (g, path, content, 0);
4651 char src[] = "/olddir";
4652 char dest[] = "/newdir";
4655 r = guestfs_cp_a (g, src, dest);
4660 char path[] = "/newdir/olddir/file";
4663 r = guestfs_cat (g, path);
4666 if (strcmp (r, expected) != 0) {
4667 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4675 static int test_cp_0_skip (void)
4679 str = getenv ("TEST_ONLY");
4681 return strstr (str, "cp") == NULL;
4682 str = getenv ("SKIP_TEST_CP_0");
4683 if (str && strcmp (str, "1") == 0) return 1;
4684 str = getenv ("SKIP_TEST_CP");
4685 if (str && strcmp (str, "1") == 0) return 1;
4689 static int test_cp_0 (void)
4691 if (test_cp_0_skip ()) {
4692 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4696 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4698 char device[] = "/dev/sda";
4701 r = guestfs_blockdev_setrw (g, device);
4708 r = guestfs_umount_all (g);
4715 r = guestfs_lvm_remove_all (g);
4720 char device[] = "/dev/sda";
4721 char lines_0[] = ",";
4728 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4733 char fstype[] = "ext2";
4734 char device[] = "/dev/sda1";
4737 r = guestfs_mkfs (g, fstype, device);
4742 char device[] = "/dev/sda1";
4743 char mountpoint[] = "/";
4746 r = guestfs_mount (g, device, mountpoint);
4750 /* TestOutput for cp (0) */
4751 char expected[] = "file content";
4753 char path[] = "/old";
4754 char content[] = "file content";
4757 r = guestfs_write_file (g, path, content, 0);
4762 char src[] = "/old";
4763 char dest[] = "/new";
4766 r = guestfs_cp (g, src, dest);
4771 char path[] = "/new";
4774 r = guestfs_cat (g, path);
4777 if (strcmp (r, expected) != 0) {
4778 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
4786 static int test_cp_1_skip (void)
4790 str = getenv ("TEST_ONLY");
4792 return strstr (str, "cp") == NULL;
4793 str = getenv ("SKIP_TEST_CP_1");
4794 if (str && strcmp (str, "1") == 0) return 1;
4795 str = getenv ("SKIP_TEST_CP");
4796 if (str && strcmp (str, "1") == 0) return 1;
4800 static int test_cp_1 (void)
4802 if (test_cp_1_skip ()) {
4803 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
4807 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
4809 char device[] = "/dev/sda";
4812 r = guestfs_blockdev_setrw (g, device);
4819 r = guestfs_umount_all (g);
4826 r = guestfs_lvm_remove_all (g);
4831 char device[] = "/dev/sda";
4832 char lines_0[] = ",";
4839 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4844 char fstype[] = "ext2";
4845 char device[] = "/dev/sda1";
4848 r = guestfs_mkfs (g, fstype, device);
4853 char device[] = "/dev/sda1";
4854 char mountpoint[] = "/";
4857 r = guestfs_mount (g, device, mountpoint);
4861 /* TestOutputTrue for cp (1) */
4863 char path[] = "/old";
4864 char content[] = "file content";
4867 r = guestfs_write_file (g, path, content, 0);
4872 char src[] = "/old";
4873 char dest[] = "/new";
4876 r = guestfs_cp (g, src, dest);
4881 char path[] = "/old";
4884 r = guestfs_is_file (g, path);
4888 fprintf (stderr, "test_cp_1: expected true, got false\n");
4895 static int test_cp_2_skip (void)
4899 str = getenv ("TEST_ONLY");
4901 return strstr (str, "cp") == NULL;
4902 str = getenv ("SKIP_TEST_CP_2");
4903 if (str && strcmp (str, "1") == 0) return 1;
4904 str = getenv ("SKIP_TEST_CP");
4905 if (str && strcmp (str, "1") == 0) return 1;
4909 static int test_cp_2 (void)
4911 if (test_cp_2_skip ()) {
4912 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
4916 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
4918 char device[] = "/dev/sda";
4921 r = guestfs_blockdev_setrw (g, device);
4928 r = guestfs_umount_all (g);
4935 r = guestfs_lvm_remove_all (g);
4940 char device[] = "/dev/sda";
4941 char lines_0[] = ",";
4948 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4953 char fstype[] = "ext2";
4954 char device[] = "/dev/sda1";
4957 r = guestfs_mkfs (g, fstype, device);
4962 char device[] = "/dev/sda1";
4963 char mountpoint[] = "/";
4966 r = guestfs_mount (g, device, mountpoint);
4970 /* TestOutput for cp (2) */
4971 char expected[] = "file content";
4973 char path[] = "/old";
4974 char content[] = "file content";
4977 r = guestfs_write_file (g, path, content, 0);
4982 char path[] = "/dir";
4985 r = guestfs_mkdir (g, path);
4990 char src[] = "/old";
4991 char dest[] = "/dir/new";
4994 r = guestfs_cp (g, src, dest);
4999 char path[] = "/dir/new";
5002 r = guestfs_cat (g, path);
5005 if (strcmp (r, expected) != 0) {
5006 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5014 static int test_grub_install_0_skip (void)
5018 str = getenv ("TEST_ONLY");
5020 return strstr (str, "grub_install") == NULL;
5021 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5022 if (str && strcmp (str, "1") == 0) return 1;
5023 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5024 if (str && strcmp (str, "1") == 0) return 1;
5028 static int test_grub_install_0 (void)
5030 if (test_grub_install_0_skip ()) {
5031 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5035 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5037 char device[] = "/dev/sda";
5040 r = guestfs_blockdev_setrw (g, device);
5047 r = guestfs_umount_all (g);
5054 r = guestfs_lvm_remove_all (g);
5059 char device[] = "/dev/sda";
5060 char lines_0[] = ",";
5067 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5072 char fstype[] = "ext2";
5073 char device[] = "/dev/sda1";
5076 r = guestfs_mkfs (g, fstype, device);
5081 char device[] = "/dev/sda1";
5082 char mountpoint[] = "/";
5085 r = guestfs_mount (g, device, mountpoint);
5089 /* TestOutputTrue for grub_install (0) */
5092 char device[] = "/dev/sda1";
5095 r = guestfs_grub_install (g, root, device);
5100 char path[] = "/boot";
5103 r = guestfs_is_dir (g, path);
5107 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5114 static int test_zero_0_skip (void)
5118 str = getenv ("TEST_ONLY");
5120 return strstr (str, "zero") == NULL;
5121 str = getenv ("SKIP_TEST_ZERO_0");
5122 if (str && strcmp (str, "1") == 0) return 1;
5123 str = getenv ("SKIP_TEST_ZERO");
5124 if (str && strcmp (str, "1") == 0) return 1;
5128 static int test_zero_0 (void)
5130 if (test_zero_0_skip ()) {
5131 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5135 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5137 char device[] = "/dev/sda";
5140 r = guestfs_blockdev_setrw (g, device);
5147 r = guestfs_umount_all (g);
5154 r = guestfs_lvm_remove_all (g);
5159 char device[] = "/dev/sda";
5160 char lines_0[] = ",";
5167 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5172 char fstype[] = "ext2";
5173 char device[] = "/dev/sda1";
5176 r = guestfs_mkfs (g, fstype, device);
5181 char device[] = "/dev/sda1";
5182 char mountpoint[] = "/";
5185 r = guestfs_mount (g, device, mountpoint);
5189 /* TestOutput for zero (0) */
5190 char expected[] = "data";
5192 char pathordevice[] = "/dev/sda1";
5195 r = guestfs_umount (g, pathordevice);
5200 char device[] = "/dev/sda1";
5203 r = guestfs_zero (g, device);
5208 char path[] = "/dev/sda1";
5211 r = guestfs_file (g, path);
5214 if (strcmp (r, expected) != 0) {
5215 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5223 static int test_fsck_0_skip (void)
5227 str = getenv ("TEST_ONLY");
5229 return strstr (str, "fsck") == NULL;
5230 str = getenv ("SKIP_TEST_FSCK_0");
5231 if (str && strcmp (str, "1") == 0) return 1;
5232 str = getenv ("SKIP_TEST_FSCK");
5233 if (str && strcmp (str, "1") == 0) return 1;
5237 static int test_fsck_0 (void)
5239 if (test_fsck_0_skip ()) {
5240 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5244 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5246 char device[] = "/dev/sda";
5249 r = guestfs_blockdev_setrw (g, device);
5256 r = guestfs_umount_all (g);
5263 r = guestfs_lvm_remove_all (g);
5268 char device[] = "/dev/sda";
5269 char lines_0[] = ",";
5276 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5281 char fstype[] = "ext2";
5282 char device[] = "/dev/sda1";
5285 r = guestfs_mkfs (g, fstype, device);
5290 char device[] = "/dev/sda1";
5291 char mountpoint[] = "/";
5294 r = guestfs_mount (g, device, mountpoint);
5298 /* TestOutputInt for fsck (0) */
5300 char pathordevice[] = "/dev/sda1";
5303 r = guestfs_umount (g, pathordevice);
5308 char fstype[] = "ext2";
5309 char device[] = "/dev/sda1";
5312 r = guestfs_fsck (g, fstype, device);
5316 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
5323 static int test_fsck_1_skip (void)
5327 str = getenv ("TEST_ONLY");
5329 return strstr (str, "fsck") == NULL;
5330 str = getenv ("SKIP_TEST_FSCK_1");
5331 if (str && strcmp (str, "1") == 0) return 1;
5332 str = getenv ("SKIP_TEST_FSCK");
5333 if (str && strcmp (str, "1") == 0) return 1;
5337 static int test_fsck_1 (void)
5339 if (test_fsck_1_skip ()) {
5340 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5344 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5346 char device[] = "/dev/sda";
5349 r = guestfs_blockdev_setrw (g, device);
5356 r = guestfs_umount_all (g);
5363 r = guestfs_lvm_remove_all (g);
5368 char device[] = "/dev/sda";
5369 char lines_0[] = ",";
5376 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5381 char fstype[] = "ext2";
5382 char device[] = "/dev/sda1";
5385 r = guestfs_mkfs (g, fstype, device);
5390 char device[] = "/dev/sda1";
5391 char mountpoint[] = "/";
5394 r = guestfs_mount (g, device, mountpoint);
5398 /* TestOutputInt for fsck (1) */
5400 char pathordevice[] = "/dev/sda1";
5403 r = guestfs_umount (g, pathordevice);
5408 char device[] = "/dev/sda1";
5411 r = guestfs_zero (g, device);
5416 char fstype[] = "ext2";
5417 char device[] = "/dev/sda1";
5420 r = guestfs_fsck (g, fstype, device);
5424 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
5431 static int test_set_e2uuid_0_skip (void)
5435 str = getenv ("TEST_ONLY");
5437 return strstr (str, "set_e2uuid") == NULL;
5438 str = getenv ("SKIP_TEST_SET_E2UUID_0");
5439 if (str && strcmp (str, "1") == 0) return 1;
5440 str = getenv ("SKIP_TEST_SET_E2UUID");
5441 if (str && strcmp (str, "1") == 0) return 1;
5445 static int test_set_e2uuid_0 (void)
5447 if (test_set_e2uuid_0_skip ()) {
5448 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5452 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5454 char device[] = "/dev/sda";
5457 r = guestfs_blockdev_setrw (g, device);
5464 r = guestfs_umount_all (g);
5471 r = guestfs_lvm_remove_all (g);
5476 char device[] = "/dev/sda";
5477 char lines_0[] = ",";
5484 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5489 char fstype[] = "ext2";
5490 char device[] = "/dev/sda1";
5493 r = guestfs_mkfs (g, fstype, device);
5498 char device[] = "/dev/sda1";
5499 char mountpoint[] = "/";
5502 r = guestfs_mount (g, device, mountpoint);
5506 /* TestOutput for set_e2uuid (0) */
5507 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5509 char device[] = "/dev/sda1";
5510 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5513 r = guestfs_set_e2uuid (g, device, uuid);
5518 char device[] = "/dev/sda1";
5521 r = guestfs_get_e2uuid (g, device);
5524 if (strcmp (r, expected) != 0) {
5525 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5533 static int test_set_e2uuid_1_skip (void)
5537 str = getenv ("TEST_ONLY");
5539 return strstr (str, "set_e2uuid") == NULL;
5540 str = getenv ("SKIP_TEST_SET_E2UUID_1");
5541 if (str && strcmp (str, "1") == 0) return 1;
5542 str = getenv ("SKIP_TEST_SET_E2UUID");
5543 if (str && strcmp (str, "1") == 0) return 1;
5547 static int test_set_e2uuid_1 (void)
5549 if (test_set_e2uuid_1_skip ()) {
5550 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5554 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
5556 char device[] = "/dev/sda";
5559 r = guestfs_blockdev_setrw (g, device);
5566 r = guestfs_umount_all (g);
5573 r = guestfs_lvm_remove_all (g);
5578 char device[] = "/dev/sda";
5579 char lines_0[] = ",";
5586 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5591 char fstype[] = "ext2";
5592 char device[] = "/dev/sda1";
5595 r = guestfs_mkfs (g, fstype, device);
5600 char device[] = "/dev/sda1";
5601 char mountpoint[] = "/";
5604 r = guestfs_mount (g, device, mountpoint);
5608 /* TestOutput for set_e2uuid (1) */
5609 char expected[] = "";
5611 char device[] = "/dev/sda1";
5612 char uuid[] = "clear";
5615 r = guestfs_set_e2uuid (g, device, uuid);
5620 char device[] = "/dev/sda1";
5623 r = guestfs_get_e2uuid (g, device);
5626 if (strcmp (r, expected) != 0) {
5627 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5635 static int test_set_e2uuid_2_skip (void)
5639 str = getenv ("TEST_ONLY");
5641 return strstr (str, "set_e2uuid") == NULL;
5642 str = getenv ("SKIP_TEST_SET_E2UUID_2");
5643 if (str && strcmp (str, "1") == 0) return 1;
5644 str = getenv ("SKIP_TEST_SET_E2UUID");
5645 if (str && strcmp (str, "1") == 0) return 1;
5649 static int test_set_e2uuid_2 (void)
5651 if (test_set_e2uuid_2_skip ()) {
5652 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5656 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5658 char device[] = "/dev/sda";
5661 r = guestfs_blockdev_setrw (g, device);
5668 r = guestfs_umount_all (g);
5675 r = guestfs_lvm_remove_all (g);
5680 char device[] = "/dev/sda";
5681 char lines_0[] = ",";
5688 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5693 char fstype[] = "ext2";
5694 char device[] = "/dev/sda1";
5697 r = guestfs_mkfs (g, fstype, device);
5702 char device[] = "/dev/sda1";
5703 char mountpoint[] = "/";
5706 r = guestfs_mount (g, device, mountpoint);
5710 /* TestRun for set_e2uuid (2) */
5712 char device[] = "/dev/sda1";
5713 char uuid[] = "random";
5716 r = guestfs_set_e2uuid (g, device, uuid);
5723 static int test_set_e2uuid_3_skip (void)
5727 str = getenv ("TEST_ONLY");
5729 return strstr (str, "set_e2uuid") == NULL;
5730 str = getenv ("SKIP_TEST_SET_E2UUID_3");
5731 if (str && strcmp (str, "1") == 0) return 1;
5732 str = getenv ("SKIP_TEST_SET_E2UUID");
5733 if (str && strcmp (str, "1") == 0) return 1;
5737 static int test_set_e2uuid_3 (void)
5739 if (test_set_e2uuid_3_skip ()) {
5740 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
5744 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
5746 char device[] = "/dev/sda";
5749 r = guestfs_blockdev_setrw (g, device);
5756 r = guestfs_umount_all (g);
5763 r = guestfs_lvm_remove_all (g);
5768 char device[] = "/dev/sda";
5769 char lines_0[] = ",";
5776 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5781 char fstype[] = "ext2";
5782 char device[] = "/dev/sda1";
5785 r = guestfs_mkfs (g, fstype, device);
5790 char device[] = "/dev/sda1";
5791 char mountpoint[] = "/";
5794 r = guestfs_mount (g, device, mountpoint);
5798 /* TestRun for set_e2uuid (3) */
5800 char device[] = "/dev/sda1";
5801 char uuid[] = "time";
5804 r = guestfs_set_e2uuid (g, device, uuid);
5811 static int test_set_e2label_0_skip (void)
5815 str = getenv ("TEST_ONLY");
5817 return strstr (str, "set_e2label") == NULL;
5818 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
5819 if (str && strcmp (str, "1") == 0) return 1;
5820 str = getenv ("SKIP_TEST_SET_E2LABEL");
5821 if (str && strcmp (str, "1") == 0) return 1;
5825 static int test_set_e2label_0 (void)
5827 if (test_set_e2label_0_skip ()) {
5828 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
5832 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
5834 char device[] = "/dev/sda";
5837 r = guestfs_blockdev_setrw (g, device);
5844 r = guestfs_umount_all (g);
5851 r = guestfs_lvm_remove_all (g);
5856 char device[] = "/dev/sda";
5857 char lines_0[] = ",";
5864 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5869 char fstype[] = "ext2";
5870 char device[] = "/dev/sda1";
5873 r = guestfs_mkfs (g, fstype, device);
5878 char device[] = "/dev/sda1";
5879 char mountpoint[] = "/";
5882 r = guestfs_mount (g, device, mountpoint);
5886 /* TestOutput for set_e2label (0) */
5887 char expected[] = "testlabel";
5889 char device[] = "/dev/sda1";
5890 char label[] = "testlabel";
5893 r = guestfs_set_e2label (g, device, label);
5898 char device[] = "/dev/sda1";
5901 r = guestfs_get_e2label (g, device);
5904 if (strcmp (r, expected) != 0) {
5905 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
5913 static int test_pvremove_0_skip (void)
5917 str = getenv ("TEST_ONLY");
5919 return strstr (str, "pvremove") == NULL;
5920 str = getenv ("SKIP_TEST_PVREMOVE_0");
5921 if (str && strcmp (str, "1") == 0) return 1;
5922 str = getenv ("SKIP_TEST_PVREMOVE");
5923 if (str && strcmp (str, "1") == 0) return 1;
5927 static int test_pvremove_0 (void)
5929 if (test_pvremove_0_skip ()) {
5930 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
5934 /* InitNone|InitEmpty for test_pvremove_0 */
5936 char device[] = "/dev/sda";
5939 r = guestfs_blockdev_setrw (g, device);
5946 r = guestfs_umount_all (g);
5953 r = guestfs_lvm_remove_all (g);
5957 /* TestOutputListOfDevices for pvremove (0) */
5959 char device[] = "/dev/sda";
5960 char lines_0[] = ",";
5967 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5972 char device[] = "/dev/sda1";
5975 r = guestfs_pvcreate (g, device);
5980 char volgroup[] = "VG";
5981 char physvols_0[] = "/dev/sda1";
5982 char *physvols[] = {
5988 r = guestfs_vgcreate (g, volgroup, physvols);
5993 char logvol[] = "LV1";
5994 char volgroup[] = "VG";
5997 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6002 char logvol[] = "LV2";
6003 char volgroup[] = "VG";
6006 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6011 char vgname[] = "VG";
6014 r = guestfs_vgremove (g, vgname);
6019 char device[] = "/dev/sda1";
6022 r = guestfs_pvremove (g, device);
6030 r = guestfs_lvs (g);
6034 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6038 for (i = 0; r[i] != NULL; ++i)
6045 static int test_pvremove_1_skip (void)
6049 str = getenv ("TEST_ONLY");
6051 return strstr (str, "pvremove") == NULL;
6052 str = getenv ("SKIP_TEST_PVREMOVE_1");
6053 if (str && strcmp (str, "1") == 0) return 1;
6054 str = getenv ("SKIP_TEST_PVREMOVE");
6055 if (str && strcmp (str, "1") == 0) return 1;
6059 static int test_pvremove_1 (void)
6061 if (test_pvremove_1_skip ()) {
6062 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6066 /* InitNone|InitEmpty for test_pvremove_1 */
6068 char device[] = "/dev/sda";
6071 r = guestfs_blockdev_setrw (g, device);
6078 r = guestfs_umount_all (g);
6085 r = guestfs_lvm_remove_all (g);
6089 /* TestOutputListOfDevices for pvremove (1) */
6091 char device[] = "/dev/sda";
6092 char lines_0[] = ",";
6099 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6104 char device[] = "/dev/sda1";
6107 r = guestfs_pvcreate (g, device);
6112 char volgroup[] = "VG";
6113 char physvols_0[] = "/dev/sda1";
6114 char *physvols[] = {
6120 r = guestfs_vgcreate (g, volgroup, physvols);
6125 char logvol[] = "LV1";
6126 char volgroup[] = "VG";
6129 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6134 char logvol[] = "LV2";
6135 char volgroup[] = "VG";
6138 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6143 char vgname[] = "VG";
6146 r = guestfs_vgremove (g, vgname);
6151 char device[] = "/dev/sda1";
6154 r = guestfs_pvremove (g, device);
6162 r = guestfs_vgs (g);
6166 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6170 for (i = 0; r[i] != NULL; ++i)
6177 static int test_pvremove_2_skip (void)
6181 str = getenv ("TEST_ONLY");
6183 return strstr (str, "pvremove") == NULL;
6184 str = getenv ("SKIP_TEST_PVREMOVE_2");
6185 if (str && strcmp (str, "1") == 0) return 1;
6186 str = getenv ("SKIP_TEST_PVREMOVE");
6187 if (str && strcmp (str, "1") == 0) return 1;
6191 static int test_pvremove_2 (void)
6193 if (test_pvremove_2_skip ()) {
6194 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6198 /* InitNone|InitEmpty for test_pvremove_2 */
6200 char device[] = "/dev/sda";
6203 r = guestfs_blockdev_setrw (g, device);
6210 r = guestfs_umount_all (g);
6217 r = guestfs_lvm_remove_all (g);
6221 /* TestOutputListOfDevices for pvremove (2) */
6223 char device[] = "/dev/sda";
6224 char lines_0[] = ",";
6231 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6236 char device[] = "/dev/sda1";
6239 r = guestfs_pvcreate (g, device);
6244 char volgroup[] = "VG";
6245 char physvols_0[] = "/dev/sda1";
6246 char *physvols[] = {
6252 r = guestfs_vgcreate (g, volgroup, physvols);
6257 char logvol[] = "LV1";
6258 char volgroup[] = "VG";
6261 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6266 char logvol[] = "LV2";
6267 char volgroup[] = "VG";
6270 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6275 char vgname[] = "VG";
6278 r = guestfs_vgremove (g, vgname);
6283 char device[] = "/dev/sda1";
6286 r = guestfs_pvremove (g, device);
6294 r = guestfs_pvs (g);
6298 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6302 for (i = 0; r[i] != NULL; ++i)
6309 static int test_vgremove_0_skip (void)
6313 str = getenv ("TEST_ONLY");
6315 return strstr (str, "vgremove") == NULL;
6316 str = getenv ("SKIP_TEST_VGREMOVE_0");
6317 if (str && strcmp (str, "1") == 0) return 1;
6318 str = getenv ("SKIP_TEST_VGREMOVE");
6319 if (str && strcmp (str, "1") == 0) return 1;
6323 static int test_vgremove_0 (void)
6325 if (test_vgremove_0_skip ()) {
6326 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6330 /* InitNone|InitEmpty for test_vgremove_0 */
6332 char device[] = "/dev/sda";
6335 r = guestfs_blockdev_setrw (g, device);
6342 r = guestfs_umount_all (g);
6349 r = guestfs_lvm_remove_all (g);
6353 /* TestOutputList for vgremove (0) */
6355 char device[] = "/dev/sda";
6356 char lines_0[] = ",";
6363 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6368 char device[] = "/dev/sda1";
6371 r = guestfs_pvcreate (g, device);
6376 char volgroup[] = "VG";
6377 char physvols_0[] = "/dev/sda1";
6378 char *physvols[] = {
6384 r = guestfs_vgcreate (g, volgroup, physvols);
6389 char logvol[] = "LV1";
6390 char volgroup[] = "VG";
6393 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6398 char logvol[] = "LV2";
6399 char volgroup[] = "VG";
6402 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6407 char vgname[] = "VG";
6410 r = guestfs_vgremove (g, vgname);
6418 r = guestfs_lvs (g);
6422 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6426 for (i = 0; r[i] != NULL; ++i)
6433 static int test_vgremove_1_skip (void)
6437 str = getenv ("TEST_ONLY");
6439 return strstr (str, "vgremove") == NULL;
6440 str = getenv ("SKIP_TEST_VGREMOVE_1");
6441 if (str && strcmp (str, "1") == 0) return 1;
6442 str = getenv ("SKIP_TEST_VGREMOVE");
6443 if (str && strcmp (str, "1") == 0) return 1;
6447 static int test_vgremove_1 (void)
6449 if (test_vgremove_1_skip ()) {
6450 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6454 /* InitNone|InitEmpty for test_vgremove_1 */
6456 char device[] = "/dev/sda";
6459 r = guestfs_blockdev_setrw (g, device);
6466 r = guestfs_umount_all (g);
6473 r = guestfs_lvm_remove_all (g);
6477 /* TestOutputList for vgremove (1) */
6479 char device[] = "/dev/sda";
6480 char lines_0[] = ",";
6487 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6492 char device[] = "/dev/sda1";
6495 r = guestfs_pvcreate (g, device);
6500 char volgroup[] = "VG";
6501 char physvols_0[] = "/dev/sda1";
6502 char *physvols[] = {
6508 r = guestfs_vgcreate (g, volgroup, physvols);
6513 char logvol[] = "LV1";
6514 char volgroup[] = "VG";
6517 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6522 char logvol[] = "LV2";
6523 char volgroup[] = "VG";
6526 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6531 char vgname[] = "VG";
6534 r = guestfs_vgremove (g, vgname);
6542 r = guestfs_vgs (g);
6546 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6550 for (i = 0; r[i] != NULL; ++i)
6557 static int test_lvremove_0_skip (void)
6561 str = getenv ("TEST_ONLY");
6563 return strstr (str, "lvremove") == NULL;
6564 str = getenv ("SKIP_TEST_LVREMOVE_0");
6565 if (str && strcmp (str, "1") == 0) return 1;
6566 str = getenv ("SKIP_TEST_LVREMOVE");
6567 if (str && strcmp (str, "1") == 0) return 1;
6571 static int test_lvremove_0 (void)
6573 if (test_lvremove_0_skip ()) {
6574 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6578 /* InitNone|InitEmpty for test_lvremove_0 */
6580 char device[] = "/dev/sda";
6583 r = guestfs_blockdev_setrw (g, device);
6590 r = guestfs_umount_all (g);
6597 r = guestfs_lvm_remove_all (g);
6601 /* TestOutputList for lvremove (0) */
6603 char device[] = "/dev/sda";
6604 char lines_0[] = ",";
6611 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6616 char device[] = "/dev/sda1";
6619 r = guestfs_pvcreate (g, device);
6624 char volgroup[] = "VG";
6625 char physvols_0[] = "/dev/sda1";
6626 char *physvols[] = {
6632 r = guestfs_vgcreate (g, volgroup, physvols);
6637 char logvol[] = "LV1";
6638 char volgroup[] = "VG";
6641 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6646 char logvol[] = "LV2";
6647 char volgroup[] = "VG";
6650 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6655 char device[] = "/dev/VG/LV1";
6658 r = guestfs_lvremove (g, device);
6666 r = guestfs_lvs (g);
6670 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6675 char expected[] = "/dev/VG/LV2";
6676 if (strcmp (r[0], expected) != 0) {
6677 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6682 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6686 for (i = 0; r[i] != NULL; ++i)
6693 static int test_lvremove_1_skip (void)
6697 str = getenv ("TEST_ONLY");
6699 return strstr (str, "lvremove") == NULL;
6700 str = getenv ("SKIP_TEST_LVREMOVE_1");
6701 if (str && strcmp (str, "1") == 0) return 1;
6702 str = getenv ("SKIP_TEST_LVREMOVE");
6703 if (str && strcmp (str, "1") == 0) return 1;
6707 static int test_lvremove_1 (void)
6709 if (test_lvremove_1_skip ()) {
6710 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6714 /* InitNone|InitEmpty for test_lvremove_1 */
6716 char device[] = "/dev/sda";
6719 r = guestfs_blockdev_setrw (g, device);
6726 r = guestfs_umount_all (g);
6733 r = guestfs_lvm_remove_all (g);
6737 /* TestOutputList for lvremove (1) */
6739 char device[] = "/dev/sda";
6740 char lines_0[] = ",";
6747 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6752 char device[] = "/dev/sda1";
6755 r = guestfs_pvcreate (g, device);
6760 char volgroup[] = "VG";
6761 char physvols_0[] = "/dev/sda1";
6762 char *physvols[] = {
6768 r = guestfs_vgcreate (g, volgroup, physvols);
6773 char logvol[] = "LV1";
6774 char volgroup[] = "VG";
6777 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6782 char logvol[] = "LV2";
6783 char volgroup[] = "VG";
6786 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6791 char device[] = "/dev/VG";
6794 r = guestfs_lvremove (g, device);
6802 r = guestfs_lvs (g);
6806 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
6810 for (i = 0; r[i] != NULL; ++i)
6817 static int test_lvremove_2_skip (void)
6821 str = getenv ("TEST_ONLY");
6823 return strstr (str, "lvremove") == NULL;
6824 str = getenv ("SKIP_TEST_LVREMOVE_2");
6825 if (str && strcmp (str, "1") == 0) return 1;
6826 str = getenv ("SKIP_TEST_LVREMOVE");
6827 if (str && strcmp (str, "1") == 0) return 1;
6831 static int test_lvremove_2 (void)
6833 if (test_lvremove_2_skip ()) {
6834 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
6838 /* InitNone|InitEmpty for test_lvremove_2 */
6840 char device[] = "/dev/sda";
6843 r = guestfs_blockdev_setrw (g, device);
6850 r = guestfs_umount_all (g);
6857 r = guestfs_lvm_remove_all (g);
6861 /* TestOutputList for lvremove (2) */
6863 char device[] = "/dev/sda";
6864 char lines_0[] = ",";
6871 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6876 char device[] = "/dev/sda1";
6879 r = guestfs_pvcreate (g, device);
6884 char volgroup[] = "VG";
6885 char physvols_0[] = "/dev/sda1";
6886 char *physvols[] = {
6892 r = guestfs_vgcreate (g, volgroup, physvols);
6897 char logvol[] = "LV1";
6898 char volgroup[] = "VG";
6901 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6906 char logvol[] = "LV2";
6907 char volgroup[] = "VG";
6910 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6915 char device[] = "/dev/VG";
6918 r = guestfs_lvremove (g, device);
6926 r = guestfs_vgs (g);
6930 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
6935 char expected[] = "VG";
6936 if (strcmp (r[0], expected) != 0) {
6937 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6942 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
6946 for (i = 0; r[i] != NULL; ++i)
6953 static int test_mount_ro_0_skip (void)
6957 str = getenv ("TEST_ONLY");
6959 return strstr (str, "mount_ro") == NULL;
6960 str = getenv ("SKIP_TEST_MOUNT_RO_0");
6961 if (str && strcmp (str, "1") == 0) return 1;
6962 str = getenv ("SKIP_TEST_MOUNT_RO");
6963 if (str && strcmp (str, "1") == 0) return 1;
6967 static int test_mount_ro_0 (void)
6969 if (test_mount_ro_0_skip ()) {
6970 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
6974 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
6976 char device[] = "/dev/sda";
6979 r = guestfs_blockdev_setrw (g, device);
6986 r = guestfs_umount_all (g);
6993 r = guestfs_lvm_remove_all (g);
6998 char device[] = "/dev/sda";
6999 char lines_0[] = ",";
7006 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7011 char fstype[] = "ext2";
7012 char device[] = "/dev/sda1";
7015 r = guestfs_mkfs (g, fstype, device);
7020 char device[] = "/dev/sda1";
7021 char mountpoint[] = "/";
7024 r = guestfs_mount (g, device, mountpoint);
7028 /* TestLastFail for mount_ro (0) */
7030 char pathordevice[] = "/";
7033 r = guestfs_umount (g, pathordevice);
7038 char device[] = "/dev/sda1";
7039 char mountpoint[] = "/";
7042 r = guestfs_mount_ro (g, device, mountpoint);
7047 char path[] = "/new";
7050 r = guestfs_touch (g, path);
7057 static int test_mount_ro_1_skip (void)
7061 str = getenv ("TEST_ONLY");
7063 return strstr (str, "mount_ro") == NULL;
7064 str = getenv ("SKIP_TEST_MOUNT_RO_1");
7065 if (str && strcmp (str, "1") == 0) return 1;
7066 str = getenv ("SKIP_TEST_MOUNT_RO");
7067 if (str && strcmp (str, "1") == 0) return 1;
7071 static int test_mount_ro_1 (void)
7073 if (test_mount_ro_1_skip ()) {
7074 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7078 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7080 char device[] = "/dev/sda";
7083 r = guestfs_blockdev_setrw (g, device);
7090 r = guestfs_umount_all (g);
7097 r = guestfs_lvm_remove_all (g);
7102 char device[] = "/dev/sda";
7103 char lines_0[] = ",";
7110 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7115 char fstype[] = "ext2";
7116 char device[] = "/dev/sda1";
7119 r = guestfs_mkfs (g, fstype, device);
7124 char device[] = "/dev/sda1";
7125 char mountpoint[] = "/";
7128 r = guestfs_mount (g, device, mountpoint);
7132 /* TestOutput for mount_ro (1) */
7133 char expected[] = "data";
7135 char path[] = "/new";
7136 char content[] = "data";
7139 r = guestfs_write_file (g, path, content, 0);
7144 char pathordevice[] = "/";
7147 r = guestfs_umount (g, pathordevice);
7152 char device[] = "/dev/sda1";
7153 char mountpoint[] = "/";
7156 r = guestfs_mount_ro (g, device, mountpoint);
7161 char path[] = "/new";
7164 r = guestfs_cat (g, path);
7167 if (strcmp (r, expected) != 0) {
7168 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7176 static int test_tgz_in_0_skip (void)
7180 str = getenv ("TEST_ONLY");
7182 return strstr (str, "tgz_in") == NULL;
7183 str = getenv ("SKIP_TEST_TGZ_IN_0");
7184 if (str && strcmp (str, "1") == 0) return 1;
7185 str = getenv ("SKIP_TEST_TGZ_IN");
7186 if (str && strcmp (str, "1") == 0) return 1;
7190 static int test_tgz_in_0 (void)
7192 if (test_tgz_in_0_skip ()) {
7193 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7197 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7199 char device[] = "/dev/sda";
7202 r = guestfs_blockdev_setrw (g, device);
7209 r = guestfs_umount_all (g);
7216 r = guestfs_lvm_remove_all (g);
7221 char device[] = "/dev/sda";
7222 char lines_0[] = ",";
7229 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7234 char fstype[] = "ext2";
7235 char device[] = "/dev/sda1";
7238 r = guestfs_mkfs (g, fstype, device);
7243 char device[] = "/dev/sda1";
7244 char mountpoint[] = "/";
7247 r = guestfs_mount (g, device, mountpoint);
7251 /* TestOutput for tgz_in (0) */
7252 char expected[] = "hello\n";
7254 char directory[] = "/";
7257 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7262 char path[] = "/hello";
7265 r = guestfs_cat (g, path);
7268 if (strcmp (r, expected) != 0) {
7269 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7277 static int test_tar_in_0_skip (void)
7281 str = getenv ("TEST_ONLY");
7283 return strstr (str, "tar_in") == NULL;
7284 str = getenv ("SKIP_TEST_TAR_IN_0");
7285 if (str && strcmp (str, "1") == 0) return 1;
7286 str = getenv ("SKIP_TEST_TAR_IN");
7287 if (str && strcmp (str, "1") == 0) return 1;
7291 static int test_tar_in_0 (void)
7293 if (test_tar_in_0_skip ()) {
7294 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7298 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7300 char device[] = "/dev/sda";
7303 r = guestfs_blockdev_setrw (g, device);
7310 r = guestfs_umount_all (g);
7317 r = guestfs_lvm_remove_all (g);
7322 char device[] = "/dev/sda";
7323 char lines_0[] = ",";
7330 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7335 char fstype[] = "ext2";
7336 char device[] = "/dev/sda1";
7339 r = guestfs_mkfs (g, fstype, device);
7344 char device[] = "/dev/sda1";
7345 char mountpoint[] = "/";
7348 r = guestfs_mount (g, device, mountpoint);
7352 /* TestOutput for tar_in (0) */
7353 char expected[] = "hello\n";
7355 char directory[] = "/";
7358 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7363 char path[] = "/hello";
7366 r = guestfs_cat (g, path);
7369 if (strcmp (r, expected) != 0) {
7370 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7378 static int test_checksum_0_skip (void)
7382 str = getenv ("TEST_ONLY");
7384 return strstr (str, "checksum") == NULL;
7385 str = getenv ("SKIP_TEST_CHECKSUM_0");
7386 if (str && strcmp (str, "1") == 0) return 1;
7387 str = getenv ("SKIP_TEST_CHECKSUM");
7388 if (str && strcmp (str, "1") == 0) return 1;
7392 static int test_checksum_0 (void)
7394 if (test_checksum_0_skip ()) {
7395 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7399 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7401 char device[] = "/dev/sda";
7404 r = guestfs_blockdev_setrw (g, device);
7411 r = guestfs_umount_all (g);
7418 r = guestfs_lvm_remove_all (g);
7423 char device[] = "/dev/sda";
7424 char lines_0[] = ",";
7431 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7436 char fstype[] = "ext2";
7437 char device[] = "/dev/sda1";
7440 r = guestfs_mkfs (g, fstype, device);
7445 char device[] = "/dev/sda1";
7446 char mountpoint[] = "/";
7449 r = guestfs_mount (g, device, mountpoint);
7453 /* TestOutput for checksum (0) */
7454 char expected[] = "935282863";
7456 char path[] = "/new";
7457 char content[] = "test\n";
7460 r = guestfs_write_file (g, path, content, 0);
7465 char csumtype[] = "crc";
7466 char path[] = "/new";
7469 r = guestfs_checksum (g, csumtype, path);
7472 if (strcmp (r, expected) != 0) {
7473 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7481 static int test_checksum_1_skip (void)
7485 str = getenv ("TEST_ONLY");
7487 return strstr (str, "checksum") == NULL;
7488 str = getenv ("SKIP_TEST_CHECKSUM_1");
7489 if (str && strcmp (str, "1") == 0) return 1;
7490 str = getenv ("SKIP_TEST_CHECKSUM");
7491 if (str && strcmp (str, "1") == 0) return 1;
7495 static int test_checksum_1 (void)
7497 if (test_checksum_1_skip ()) {
7498 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7502 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7504 char device[] = "/dev/sda";
7507 r = guestfs_blockdev_setrw (g, device);
7514 r = guestfs_umount_all (g);
7521 r = guestfs_lvm_remove_all (g);
7526 char device[] = "/dev/sda";
7527 char lines_0[] = ",";
7534 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7539 char fstype[] = "ext2";
7540 char device[] = "/dev/sda1";
7543 r = guestfs_mkfs (g, fstype, device);
7548 char device[] = "/dev/sda1";
7549 char mountpoint[] = "/";
7552 r = guestfs_mount (g, device, mountpoint);
7556 /* TestLastFail for checksum (1) */
7558 char csumtype[] = "crc";
7559 char path[] = "/new";
7562 r = guestfs_checksum (g, csumtype, path);
7570 static int test_checksum_2_skip (void)
7574 str = getenv ("TEST_ONLY");
7576 return strstr (str, "checksum") == NULL;
7577 str = getenv ("SKIP_TEST_CHECKSUM_2");
7578 if (str && strcmp (str, "1") == 0) return 1;
7579 str = getenv ("SKIP_TEST_CHECKSUM");
7580 if (str && strcmp (str, "1") == 0) return 1;
7584 static int test_checksum_2 (void)
7586 if (test_checksum_2_skip ()) {
7587 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7591 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7593 char device[] = "/dev/sda";
7596 r = guestfs_blockdev_setrw (g, device);
7603 r = guestfs_umount_all (g);
7610 r = guestfs_lvm_remove_all (g);
7615 char device[] = "/dev/sda";
7616 char lines_0[] = ",";
7623 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7628 char fstype[] = "ext2";
7629 char device[] = "/dev/sda1";
7632 r = guestfs_mkfs (g, fstype, device);
7637 char device[] = "/dev/sda1";
7638 char mountpoint[] = "/";
7641 r = guestfs_mount (g, device, mountpoint);
7645 /* TestOutput for checksum (2) */
7646 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7648 char path[] = "/new";
7649 char content[] = "test\n";
7652 r = guestfs_write_file (g, path, content, 0);
7657 char csumtype[] = "md5";
7658 char path[] = "/new";
7661 r = guestfs_checksum (g, csumtype, path);
7664 if (strcmp (r, expected) != 0) {
7665 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7673 static int test_checksum_3_skip (void)
7677 str = getenv ("TEST_ONLY");
7679 return strstr (str, "checksum") == NULL;
7680 str = getenv ("SKIP_TEST_CHECKSUM_3");
7681 if (str && strcmp (str, "1") == 0) return 1;
7682 str = getenv ("SKIP_TEST_CHECKSUM");
7683 if (str && strcmp (str, "1") == 0) return 1;
7687 static int test_checksum_3 (void)
7689 if (test_checksum_3_skip ()) {
7690 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7694 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7696 char device[] = "/dev/sda";
7699 r = guestfs_blockdev_setrw (g, device);
7706 r = guestfs_umount_all (g);
7713 r = guestfs_lvm_remove_all (g);
7718 char device[] = "/dev/sda";
7719 char lines_0[] = ",";
7726 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7731 char fstype[] = "ext2";
7732 char device[] = "/dev/sda1";
7735 r = guestfs_mkfs (g, fstype, device);
7740 char device[] = "/dev/sda1";
7741 char mountpoint[] = "/";
7744 r = guestfs_mount (g, device, mountpoint);
7748 /* TestOutput for checksum (3) */
7749 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
7751 char path[] = "/new";
7752 char content[] = "test\n";
7755 r = guestfs_write_file (g, path, content, 0);
7760 char csumtype[] = "sha1";
7761 char path[] = "/new";
7764 r = guestfs_checksum (g, csumtype, path);
7767 if (strcmp (r, expected) != 0) {
7768 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
7776 static int test_checksum_4_skip (void)
7780 str = getenv ("TEST_ONLY");
7782 return strstr (str, "checksum") == NULL;
7783 str = getenv ("SKIP_TEST_CHECKSUM_4");
7784 if (str && strcmp (str, "1") == 0) return 1;
7785 str = getenv ("SKIP_TEST_CHECKSUM");
7786 if (str && strcmp (str, "1") == 0) return 1;
7790 static int test_checksum_4 (void)
7792 if (test_checksum_4_skip ()) {
7793 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
7797 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
7799 char device[] = "/dev/sda";
7802 r = guestfs_blockdev_setrw (g, device);
7809 r = guestfs_umount_all (g);
7816 r = guestfs_lvm_remove_all (g);
7821 char device[] = "/dev/sda";
7822 char lines_0[] = ",";
7829 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7834 char fstype[] = "ext2";
7835 char device[] = "/dev/sda1";
7838 r = guestfs_mkfs (g, fstype, device);
7843 char device[] = "/dev/sda1";
7844 char mountpoint[] = "/";
7847 r = guestfs_mount (g, device, mountpoint);
7851 /* TestOutput for checksum (4) */
7852 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
7854 char path[] = "/new";
7855 char content[] = "test\n";
7858 r = guestfs_write_file (g, path, content, 0);
7863 char csumtype[] = "sha224";
7864 char path[] = "/new";
7867 r = guestfs_checksum (g, csumtype, path);
7870 if (strcmp (r, expected) != 0) {
7871 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
7879 static int test_checksum_5_skip (void)
7883 str = getenv ("TEST_ONLY");
7885 return strstr (str, "checksum") == NULL;
7886 str = getenv ("SKIP_TEST_CHECKSUM_5");
7887 if (str && strcmp (str, "1") == 0) return 1;
7888 str = getenv ("SKIP_TEST_CHECKSUM");
7889 if (str && strcmp (str, "1") == 0) return 1;
7893 static int test_checksum_5 (void)
7895 if (test_checksum_5_skip ()) {
7896 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
7900 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
7902 char device[] = "/dev/sda";
7905 r = guestfs_blockdev_setrw (g, device);
7912 r = guestfs_umount_all (g);
7919 r = guestfs_lvm_remove_all (g);
7924 char device[] = "/dev/sda";
7925 char lines_0[] = ",";
7932 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7937 char fstype[] = "ext2";
7938 char device[] = "/dev/sda1";
7941 r = guestfs_mkfs (g, fstype, device);
7946 char device[] = "/dev/sda1";
7947 char mountpoint[] = "/";
7950 r = guestfs_mount (g, device, mountpoint);
7954 /* TestOutput for checksum (5) */
7955 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
7957 char path[] = "/new";
7958 char content[] = "test\n";
7961 r = guestfs_write_file (g, path, content, 0);
7966 char csumtype[] = "sha256";
7967 char path[] = "/new";
7970 r = guestfs_checksum (g, csumtype, path);
7973 if (strcmp (r, expected) != 0) {
7974 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
7982 static int test_checksum_6_skip (void)
7986 str = getenv ("TEST_ONLY");
7988 return strstr (str, "checksum") == NULL;
7989 str = getenv ("SKIP_TEST_CHECKSUM_6");
7990 if (str && strcmp (str, "1") == 0) return 1;
7991 str = getenv ("SKIP_TEST_CHECKSUM");
7992 if (str && strcmp (str, "1") == 0) return 1;
7996 static int test_checksum_6 (void)
7998 if (test_checksum_6_skip ()) {
7999 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8003 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8005 char device[] = "/dev/sda";
8008 r = guestfs_blockdev_setrw (g, device);
8015 r = guestfs_umount_all (g);
8022 r = guestfs_lvm_remove_all (g);
8027 char device[] = "/dev/sda";
8028 char lines_0[] = ",";
8035 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8040 char fstype[] = "ext2";
8041 char device[] = "/dev/sda1";
8044 r = guestfs_mkfs (g, fstype, device);
8049 char device[] = "/dev/sda1";
8050 char mountpoint[] = "/";
8053 r = guestfs_mount (g, device, mountpoint);
8057 /* TestOutput for checksum (6) */
8058 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8060 char path[] = "/new";
8061 char content[] = "test\n";
8064 r = guestfs_write_file (g, path, content, 0);
8069 char csumtype[] = "sha384";
8070 char path[] = "/new";
8073 r = guestfs_checksum (g, csumtype, path);
8076 if (strcmp (r, expected) != 0) {
8077 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8085 static int test_checksum_7_skip (void)
8089 str = getenv ("TEST_ONLY");
8091 return strstr (str, "checksum") == NULL;
8092 str = getenv ("SKIP_TEST_CHECKSUM_7");
8093 if (str && strcmp (str, "1") == 0) return 1;
8094 str = getenv ("SKIP_TEST_CHECKSUM");
8095 if (str && strcmp (str, "1") == 0) return 1;
8099 static int test_checksum_7 (void)
8101 if (test_checksum_7_skip ()) {
8102 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8106 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8108 char device[] = "/dev/sda";
8111 r = guestfs_blockdev_setrw (g, device);
8118 r = guestfs_umount_all (g);
8125 r = guestfs_lvm_remove_all (g);
8130 char device[] = "/dev/sda";
8131 char lines_0[] = ",";
8138 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8143 char fstype[] = "ext2";
8144 char device[] = "/dev/sda1";
8147 r = guestfs_mkfs (g, fstype, device);
8152 char device[] = "/dev/sda1";
8153 char mountpoint[] = "/";
8156 r = guestfs_mount (g, device, mountpoint);
8160 /* TestOutput for checksum (7) */
8161 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8163 char path[] = "/new";
8164 char content[] = "test\n";
8167 r = guestfs_write_file (g, path, content, 0);
8172 char csumtype[] = "sha512";
8173 char path[] = "/new";
8176 r = guestfs_checksum (g, csumtype, path);
8179 if (strcmp (r, expected) != 0) {
8180 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8188 static int test_checksum_8_skip (void)
8192 str = getenv ("TEST_ONLY");
8194 return strstr (str, "checksum") == NULL;
8195 str = getenv ("SKIP_TEST_CHECKSUM_8");
8196 if (str && strcmp (str, "1") == 0) return 1;
8197 str = getenv ("SKIP_TEST_CHECKSUM");
8198 if (str && strcmp (str, "1") == 0) return 1;
8202 static int test_checksum_8 (void)
8204 if (test_checksum_8_skip ()) {
8205 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8209 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8211 char device[] = "/dev/sda";
8214 r = guestfs_blockdev_setrw (g, device);
8221 r = guestfs_umount_all (g);
8228 r = guestfs_lvm_remove_all (g);
8233 char device[] = "/dev/sda";
8234 char lines_0[] = ",";
8241 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8246 char fstype[] = "ext2";
8247 char device[] = "/dev/sda1";
8250 r = guestfs_mkfs (g, fstype, device);
8255 char device[] = "/dev/sda1";
8256 char mountpoint[] = "/";
8259 r = guestfs_mount (g, device, mountpoint);
8263 /* TestOutput for checksum (8) */
8264 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8266 char options[] = "ro";
8267 char vfstype[] = "squashfs";
8268 char device[] = "/dev/sdd";
8269 char mountpoint[] = "/";
8272 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8277 char csumtype[] = "md5";
8278 char path[] = "/known-3";
8281 r = guestfs_checksum (g, csumtype, path);
8284 if (strcmp (r, expected) != 0) {
8285 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8293 static int test_download_0_skip (void)
8297 str = getenv ("TEST_ONLY");
8299 return strstr (str, "download") == NULL;
8300 str = getenv ("SKIP_TEST_DOWNLOAD_0");
8301 if (str && strcmp (str, "1") == 0) return 1;
8302 str = getenv ("SKIP_TEST_DOWNLOAD");
8303 if (str && strcmp (str, "1") == 0) return 1;
8307 static int test_download_0 (void)
8309 if (test_download_0_skip ()) {
8310 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8314 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8316 char device[] = "/dev/sda";
8319 r = guestfs_blockdev_setrw (g, device);
8326 r = guestfs_umount_all (g);
8333 r = guestfs_lvm_remove_all (g);
8338 char device[] = "/dev/sda";
8339 char lines_0[] = ",";
8346 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8351 char fstype[] = "ext2";
8352 char device[] = "/dev/sda1";
8355 r = guestfs_mkfs (g, fstype, device);
8360 char device[] = "/dev/sda1";
8361 char mountpoint[] = "/";
8364 r = guestfs_mount (g, device, mountpoint);
8368 /* TestOutput for download (0) */
8369 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8371 char remotefilename[] = "/COPYING.LIB";
8374 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8379 char remotefilename[] = "/COPYING.LIB";
8382 r = guestfs_download (g, remotefilename, "testdownload.tmp");
8387 char remotefilename[] = "/upload";
8390 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8395 char csumtype[] = "md5";
8396 char path[] = "/upload";
8399 r = guestfs_checksum (g, csumtype, path);
8402 if (strcmp (r, expected) != 0) {
8403 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8411 static int test_upload_0_skip (void)
8415 str = getenv ("TEST_ONLY");
8417 return strstr (str, "upload") == NULL;
8418 str = getenv ("SKIP_TEST_UPLOAD_0");
8419 if (str && strcmp (str, "1") == 0) return 1;
8420 str = getenv ("SKIP_TEST_UPLOAD");
8421 if (str && strcmp (str, "1") == 0) return 1;
8425 static int test_upload_0 (void)
8427 if (test_upload_0_skip ()) {
8428 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8432 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8434 char device[] = "/dev/sda";
8437 r = guestfs_blockdev_setrw (g, device);
8444 r = guestfs_umount_all (g);
8451 r = guestfs_lvm_remove_all (g);
8456 char device[] = "/dev/sda";
8457 char lines_0[] = ",";
8464 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8469 char fstype[] = "ext2";
8470 char device[] = "/dev/sda1";
8473 r = guestfs_mkfs (g, fstype, device);
8478 char device[] = "/dev/sda1";
8479 char mountpoint[] = "/";
8482 r = guestfs_mount (g, device, mountpoint);
8486 /* TestOutput for upload (0) */
8487 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8489 char remotefilename[] = "/COPYING.LIB";
8492 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8497 char csumtype[] = "md5";
8498 char path[] = "/COPYING.LIB";
8501 r = guestfs_checksum (g, csumtype, path);
8504 if (strcmp (r, expected) != 0) {
8505 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8513 static int test_blockdev_rereadpt_0_skip (void)
8517 str = getenv ("TEST_ONLY");
8519 return strstr (str, "blockdev_rereadpt") == NULL;
8520 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8521 if (str && strcmp (str, "1") == 0) return 1;
8522 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8523 if (str && strcmp (str, "1") == 0) return 1;
8527 static int test_blockdev_rereadpt_0 (void)
8529 if (test_blockdev_rereadpt_0_skip ()) {
8530 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8534 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8536 char device[] = "/dev/sda";
8539 r = guestfs_blockdev_setrw (g, device);
8546 r = guestfs_umount_all (g);
8553 r = guestfs_lvm_remove_all (g);
8557 /* TestRun for blockdev_rereadpt (0) */
8559 char device[] = "/dev/sda";
8562 r = guestfs_blockdev_rereadpt (g, device);
8569 static int test_blockdev_flushbufs_0_skip (void)
8573 str = getenv ("TEST_ONLY");
8575 return strstr (str, "blockdev_flushbufs") == NULL;
8576 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8577 if (str && strcmp (str, "1") == 0) return 1;
8578 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8579 if (str && strcmp (str, "1") == 0) return 1;
8583 static int test_blockdev_flushbufs_0 (void)
8585 if (test_blockdev_flushbufs_0_skip ()) {
8586 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8590 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8592 char device[] = "/dev/sda";
8595 r = guestfs_blockdev_setrw (g, device);
8602 r = guestfs_umount_all (g);
8609 r = guestfs_lvm_remove_all (g);
8613 /* TestRun for blockdev_flushbufs (0) */
8615 char device[] = "/dev/sda";
8618 r = guestfs_blockdev_flushbufs (g, device);
8625 static int test_blockdev_getsize64_0_skip (void)
8629 str = getenv ("TEST_ONLY");
8631 return strstr (str, "blockdev_getsize64") == NULL;
8632 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8633 if (str && strcmp (str, "1") == 0) return 1;
8634 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8635 if (str && strcmp (str, "1") == 0) return 1;
8639 static int test_blockdev_getsize64_0 (void)
8641 if (test_blockdev_getsize64_0_skip ()) {
8642 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8646 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8648 char device[] = "/dev/sda";
8651 r = guestfs_blockdev_setrw (g, device);
8658 r = guestfs_umount_all (g);
8665 r = guestfs_lvm_remove_all (g);
8669 /* TestOutputInt for blockdev_getsize64 (0) */
8671 char device[] = "/dev/sda";
8674 r = guestfs_blockdev_getsize64 (g, device);
8677 if (r != 524288000) {
8678 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
8685 static int test_blockdev_getsz_0_skip (void)
8689 str = getenv ("TEST_ONLY");
8691 return strstr (str, "blockdev_getsz") == NULL;
8692 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8693 if (str && strcmp (str, "1") == 0) return 1;
8694 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8695 if (str && strcmp (str, "1") == 0) return 1;
8699 static int test_blockdev_getsz_0 (void)
8701 if (test_blockdev_getsz_0_skip ()) {
8702 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8706 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8708 char device[] = "/dev/sda";
8711 r = guestfs_blockdev_setrw (g, device);
8718 r = guestfs_umount_all (g);
8725 r = guestfs_lvm_remove_all (g);
8729 /* TestOutputInt for blockdev_getsz (0) */
8731 char device[] = "/dev/sda";
8734 r = guestfs_blockdev_getsz (g, device);
8738 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
8745 static int test_blockdev_getbsz_0_skip (void)
8749 str = getenv ("TEST_ONLY");
8751 return strstr (str, "blockdev_getbsz") == NULL;
8752 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
8753 if (str && strcmp (str, "1") == 0) return 1;
8754 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
8755 if (str && strcmp (str, "1") == 0) return 1;
8759 static int test_blockdev_getbsz_0 (void)
8761 if (test_blockdev_getbsz_0_skip ()) {
8762 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
8766 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
8768 char device[] = "/dev/sda";
8771 r = guestfs_blockdev_setrw (g, device);
8778 r = guestfs_umount_all (g);
8785 r = guestfs_lvm_remove_all (g);
8789 /* TestOutputInt for blockdev_getbsz (0) */
8791 char device[] = "/dev/sda";
8794 r = guestfs_blockdev_getbsz (g, device);
8798 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
8805 static int test_blockdev_getss_0_skip (void)
8809 str = getenv ("TEST_ONLY");
8811 return strstr (str, "blockdev_getss") == NULL;
8812 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
8813 if (str && strcmp (str, "1") == 0) return 1;
8814 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
8815 if (str && strcmp (str, "1") == 0) return 1;
8819 static int test_blockdev_getss_0 (void)
8821 if (test_blockdev_getss_0_skip ()) {
8822 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
8826 /* InitNone|InitEmpty for test_blockdev_getss_0 */
8828 char device[] = "/dev/sda";
8831 r = guestfs_blockdev_setrw (g, device);
8838 r = guestfs_umount_all (g);
8845 r = guestfs_lvm_remove_all (g);
8849 /* TestOutputInt for blockdev_getss (0) */
8851 char device[] = "/dev/sda";
8854 r = guestfs_blockdev_getss (g, device);
8858 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
8865 static int test_blockdev_getro_0_skip (void)
8869 str = getenv ("TEST_ONLY");
8871 return strstr (str, "blockdev_getro") == NULL;
8872 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
8873 if (str && strcmp (str, "1") == 0) return 1;
8874 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
8875 if (str && strcmp (str, "1") == 0) return 1;
8879 static int test_blockdev_getro_0 (void)
8881 if (test_blockdev_getro_0_skip ()) {
8882 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
8886 /* InitNone|InitEmpty for test_blockdev_getro_0 */
8888 char device[] = "/dev/sda";
8891 r = guestfs_blockdev_setrw (g, device);
8898 r = guestfs_umount_all (g);
8905 r = guestfs_lvm_remove_all (g);
8909 /* TestOutputTrue for blockdev_getro (0) */
8911 char device[] = "/dev/sda";
8914 r = guestfs_blockdev_setro (g, device);
8919 char device[] = "/dev/sda";
8922 r = guestfs_blockdev_getro (g, device);
8926 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
8933 static int test_blockdev_setrw_0_skip (void)
8937 str = getenv ("TEST_ONLY");
8939 return strstr (str, "blockdev_setrw") == NULL;
8940 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
8941 if (str && strcmp (str, "1") == 0) return 1;
8942 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
8943 if (str && strcmp (str, "1") == 0) return 1;
8947 static int test_blockdev_setrw_0 (void)
8949 if (test_blockdev_setrw_0_skip ()) {
8950 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
8954 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
8956 char device[] = "/dev/sda";
8959 r = guestfs_blockdev_setrw (g, device);
8966 r = guestfs_umount_all (g);
8973 r = guestfs_lvm_remove_all (g);
8977 /* TestOutputFalse for blockdev_setrw (0) */
8979 char device[] = "/dev/sda";
8982 r = guestfs_blockdev_setrw (g, device);
8987 char device[] = "/dev/sda";
8990 r = guestfs_blockdev_getro (g, device);
8994 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9001 static int test_blockdev_setro_0_skip (void)
9005 str = getenv ("TEST_ONLY");
9007 return strstr (str, "blockdev_setro") == NULL;
9008 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9009 if (str && strcmp (str, "1") == 0) return 1;
9010 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9011 if (str && strcmp (str, "1") == 0) return 1;
9015 static int test_blockdev_setro_0 (void)
9017 if (test_blockdev_setro_0_skip ()) {
9018 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9022 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9024 char device[] = "/dev/sda";
9027 r = guestfs_blockdev_setrw (g, device);
9034 r = guestfs_umount_all (g);
9041 r = guestfs_lvm_remove_all (g);
9045 /* TestOutputTrue for blockdev_setro (0) */
9047 char device[] = "/dev/sda";
9050 r = guestfs_blockdev_setro (g, device);
9055 char device[] = "/dev/sda";
9058 r = guestfs_blockdev_getro (g, device);
9062 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9069 static int test_statvfs_0_skip (void)
9073 str = getenv ("TEST_ONLY");
9075 return strstr (str, "statvfs") == NULL;
9076 str = getenv ("SKIP_TEST_STATVFS_0");
9077 if (str && strcmp (str, "1") == 0) return 1;
9078 str = getenv ("SKIP_TEST_STATVFS");
9079 if (str && strcmp (str, "1") == 0) return 1;
9083 static int test_statvfs_0 (void)
9085 if (test_statvfs_0_skip ()) {
9086 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9090 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9092 char device[] = "/dev/sda";
9095 r = guestfs_blockdev_setrw (g, device);
9102 r = guestfs_umount_all (g);
9109 r = guestfs_lvm_remove_all (g);
9114 char device[] = "/dev/sda";
9115 char lines_0[] = ",";
9122 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9127 char fstype[] = "ext2";
9128 char device[] = "/dev/sda1";
9131 r = guestfs_mkfs (g, fstype, device);
9136 char device[] = "/dev/sda1";
9137 char mountpoint[] = "/";
9140 r = guestfs_mount (g, device, mountpoint);
9144 /* TestOutputStruct for statvfs (0) */
9147 struct guestfs_statvfs *r;
9149 r = guestfs_statvfs (g, path);
9152 if (r->bfree != 487702) {
9153 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9157 if (r->blocks != 490020) {
9158 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9162 if (r->bsize != 1024) {
9163 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9172 static int test_lstat_0_skip (void)
9176 str = getenv ("TEST_ONLY");
9178 return strstr (str, "lstat") == NULL;
9179 str = getenv ("SKIP_TEST_LSTAT_0");
9180 if (str && strcmp (str, "1") == 0) return 1;
9181 str = getenv ("SKIP_TEST_LSTAT");
9182 if (str && strcmp (str, "1") == 0) return 1;
9186 static int test_lstat_0 (void)
9188 if (test_lstat_0_skip ()) {
9189 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9193 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9195 char device[] = "/dev/sda";
9198 r = guestfs_blockdev_setrw (g, device);
9205 r = guestfs_umount_all (g);
9212 r = guestfs_lvm_remove_all (g);
9217 char device[] = "/dev/sda";
9218 char lines_0[] = ",";
9225 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9230 char fstype[] = "ext2";
9231 char device[] = "/dev/sda1";
9234 r = guestfs_mkfs (g, fstype, device);
9239 char device[] = "/dev/sda1";
9240 char mountpoint[] = "/";
9243 r = guestfs_mount (g, device, mountpoint);
9247 /* TestOutputStruct for lstat (0) */
9249 char path[] = "/new";
9252 r = guestfs_touch (g, path);
9257 char path[] = "/new";
9258 struct guestfs_stat *r;
9260 r = guestfs_lstat (g, path);
9264 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9273 static int test_stat_0_skip (void)
9277 str = getenv ("TEST_ONLY");
9279 return strstr (str, "stat") == NULL;
9280 str = getenv ("SKIP_TEST_STAT_0");
9281 if (str && strcmp (str, "1") == 0) return 1;
9282 str = getenv ("SKIP_TEST_STAT");
9283 if (str && strcmp (str, "1") == 0) return 1;
9287 static int test_stat_0 (void)
9289 if (test_stat_0_skip ()) {
9290 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9294 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9296 char device[] = "/dev/sda";
9299 r = guestfs_blockdev_setrw (g, device);
9306 r = guestfs_umount_all (g);
9313 r = guestfs_lvm_remove_all (g);
9318 char device[] = "/dev/sda";
9319 char lines_0[] = ",";
9326 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9331 char fstype[] = "ext2";
9332 char device[] = "/dev/sda1";
9335 r = guestfs_mkfs (g, fstype, device);
9340 char device[] = "/dev/sda1";
9341 char mountpoint[] = "/";
9344 r = guestfs_mount (g, device, mountpoint);
9348 /* TestOutputStruct for stat (0) */
9350 char path[] = "/new";
9353 r = guestfs_touch (g, path);
9358 char path[] = "/new";
9359 struct guestfs_stat *r;
9361 r = guestfs_stat (g, path);
9365 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9374 static int test_command_lines_0_skip (void)
9378 str = getenv ("TEST_ONLY");
9380 return strstr (str, "command_lines") == NULL;
9381 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9382 if (str && strcmp (str, "1") == 0) return 1;
9383 str = getenv ("SKIP_TEST_COMMAND_LINES");
9384 if (str && strcmp (str, "1") == 0) return 1;
9388 static int test_command_lines_0 (void)
9390 if (test_command_lines_0_skip ()) {
9391 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9395 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9397 char device[] = "/dev/sda";
9400 r = guestfs_blockdev_setrw (g, device);
9407 r = guestfs_umount_all (g);
9414 r = guestfs_lvm_remove_all (g);
9419 char device[] = "/dev/sda";
9420 char lines_0[] = ",";
9427 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9432 char fstype[] = "ext2";
9433 char device[] = "/dev/sda1";
9436 r = guestfs_mkfs (g, fstype, device);
9441 char device[] = "/dev/sda1";
9442 char mountpoint[] = "/";
9445 r = guestfs_mount (g, device, mountpoint);
9449 /* TestOutputList for command_lines (0) */
9451 char remotefilename[] = "/test-command";
9454 r = guestfs_upload (g, "test-command", remotefilename);
9459 char path[] = "/test-command";
9462 r = guestfs_chmod (g, 493, path);
9467 char arguments_0[] = "/test-command";
9468 char arguments_1[] = "1";
9469 char *arguments[] = {
9477 r = guestfs_command_lines (g, arguments);
9481 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9486 char expected[] = "Result1";
9487 if (strcmp (r[0], expected) != 0) {
9488 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9493 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9497 for (i = 0; r[i] != NULL; ++i)
9504 static int test_command_lines_1_skip (void)
9508 str = getenv ("TEST_ONLY");
9510 return strstr (str, "command_lines") == NULL;
9511 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9512 if (str && strcmp (str, "1") == 0) return 1;
9513 str = getenv ("SKIP_TEST_COMMAND_LINES");
9514 if (str && strcmp (str, "1") == 0) return 1;
9518 static int test_command_lines_1 (void)
9520 if (test_command_lines_1_skip ()) {
9521 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9525 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9527 char device[] = "/dev/sda";
9530 r = guestfs_blockdev_setrw (g, device);
9537 r = guestfs_umount_all (g);
9544 r = guestfs_lvm_remove_all (g);
9549 char device[] = "/dev/sda";
9550 char lines_0[] = ",";
9557 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9562 char fstype[] = "ext2";
9563 char device[] = "/dev/sda1";
9566 r = guestfs_mkfs (g, fstype, device);
9571 char device[] = "/dev/sda1";
9572 char mountpoint[] = "/";
9575 r = guestfs_mount (g, device, mountpoint);
9579 /* TestOutputList for command_lines (1) */
9581 char remotefilename[] = "/test-command";
9584 r = guestfs_upload (g, "test-command", remotefilename);
9589 char path[] = "/test-command";
9592 r = guestfs_chmod (g, 493, path);
9597 char arguments_0[] = "/test-command";
9598 char arguments_1[] = "2";
9599 char *arguments[] = {
9607 r = guestfs_command_lines (g, arguments);
9611 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9616 char expected[] = "Result2";
9617 if (strcmp (r[0], expected) != 0) {
9618 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9623 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9627 for (i = 0; r[i] != NULL; ++i)
9634 static int test_command_lines_2_skip (void)
9638 str = getenv ("TEST_ONLY");
9640 return strstr (str, "command_lines") == NULL;
9641 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9642 if (str && strcmp (str, "1") == 0) return 1;
9643 str = getenv ("SKIP_TEST_COMMAND_LINES");
9644 if (str && strcmp (str, "1") == 0) return 1;
9648 static int test_command_lines_2 (void)
9650 if (test_command_lines_2_skip ()) {
9651 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9655 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9657 char device[] = "/dev/sda";
9660 r = guestfs_blockdev_setrw (g, device);
9667 r = guestfs_umount_all (g);
9674 r = guestfs_lvm_remove_all (g);
9679 char device[] = "/dev/sda";
9680 char lines_0[] = ",";
9687 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9692 char fstype[] = "ext2";
9693 char device[] = "/dev/sda1";
9696 r = guestfs_mkfs (g, fstype, device);
9701 char device[] = "/dev/sda1";
9702 char mountpoint[] = "/";
9705 r = guestfs_mount (g, device, mountpoint);
9709 /* TestOutputList for command_lines (2) */
9711 char remotefilename[] = "/test-command";
9714 r = guestfs_upload (g, "test-command", remotefilename);
9719 char path[] = "/test-command";
9722 r = guestfs_chmod (g, 493, path);
9727 char arguments_0[] = "/test-command";
9728 char arguments_1[] = "3";
9729 char *arguments[] = {
9737 r = guestfs_command_lines (g, arguments);
9741 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9746 char expected[] = "";
9747 if (strcmp (r[0], expected) != 0) {
9748 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9753 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9758 char expected[] = "Result3";
9759 if (strcmp (r[1], expected) != 0) {
9760 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9765 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
9769 for (i = 0; r[i] != NULL; ++i)
9776 static int test_command_lines_3_skip (void)
9780 str = getenv ("TEST_ONLY");
9782 return strstr (str, "command_lines") == NULL;
9783 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
9784 if (str && strcmp (str, "1") == 0) return 1;
9785 str = getenv ("SKIP_TEST_COMMAND_LINES");
9786 if (str && strcmp (str, "1") == 0) return 1;
9790 static int test_command_lines_3 (void)
9792 if (test_command_lines_3_skip ()) {
9793 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
9797 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
9799 char device[] = "/dev/sda";
9802 r = guestfs_blockdev_setrw (g, device);
9809 r = guestfs_umount_all (g);
9816 r = guestfs_lvm_remove_all (g);
9821 char device[] = "/dev/sda";
9822 char lines_0[] = ",";
9829 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9834 char fstype[] = "ext2";
9835 char device[] = "/dev/sda1";
9838 r = guestfs_mkfs (g, fstype, device);
9843 char device[] = "/dev/sda1";
9844 char mountpoint[] = "/";
9847 r = guestfs_mount (g, device, mountpoint);
9851 /* TestOutputList for command_lines (3) */
9853 char remotefilename[] = "/test-command";
9856 r = guestfs_upload (g, "test-command", remotefilename);
9861 char path[] = "/test-command";
9864 r = guestfs_chmod (g, 493, path);
9869 char arguments_0[] = "/test-command";
9870 char arguments_1[] = "4";
9871 char *arguments[] = {
9879 r = guestfs_command_lines (g, arguments);
9883 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9888 char expected[] = "";
9889 if (strcmp (r[0], expected) != 0) {
9890 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9895 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9900 char expected[] = "Result4";
9901 if (strcmp (r[1], expected) != 0) {
9902 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9907 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
9911 for (i = 0; r[i] != NULL; ++i)
9918 static int test_command_lines_4_skip (void)
9922 str = getenv ("TEST_ONLY");
9924 return strstr (str, "command_lines") == NULL;
9925 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
9926 if (str && strcmp (str, "1") == 0) return 1;
9927 str = getenv ("SKIP_TEST_COMMAND_LINES");
9928 if (str && strcmp (str, "1") == 0) return 1;
9932 static int test_command_lines_4 (void)
9934 if (test_command_lines_4_skip ()) {
9935 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
9939 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
9941 char device[] = "/dev/sda";
9944 r = guestfs_blockdev_setrw (g, device);
9951 r = guestfs_umount_all (g);
9958 r = guestfs_lvm_remove_all (g);
9963 char device[] = "/dev/sda";
9964 char lines_0[] = ",";
9971 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9976 char fstype[] = "ext2";
9977 char device[] = "/dev/sda1";
9980 r = guestfs_mkfs (g, fstype, device);
9985 char device[] = "/dev/sda1";
9986 char mountpoint[] = "/";
9989 r = guestfs_mount (g, device, mountpoint);
9993 /* TestOutputList for command_lines (4) */
9995 char remotefilename[] = "/test-command";
9998 r = guestfs_upload (g, "test-command", remotefilename);
10003 char path[] = "/test-command";
10005 suppress_error = 0;
10006 r = guestfs_chmod (g, 493, path);
10011 char arguments_0[] = "/test-command";
10012 char arguments_1[] = "5";
10013 char *arguments[] = {
10020 suppress_error = 0;
10021 r = guestfs_command_lines (g, arguments);
10025 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10030 char expected[] = "";
10031 if (strcmp (r[0], expected) != 0) {
10032 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10037 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10042 char expected[] = "Result5";
10043 if (strcmp (r[1], expected) != 0) {
10044 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10049 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10054 char expected[] = "";
10055 if (strcmp (r[2], expected) != 0) {
10056 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10060 if (r[3] != NULL) {
10061 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10065 for (i = 0; r[i] != NULL; ++i)
10072 static int test_command_lines_5_skip (void)
10076 str = getenv ("TEST_ONLY");
10078 return strstr (str, "command_lines") == NULL;
10079 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10080 if (str && strcmp (str, "1") == 0) return 1;
10081 str = getenv ("SKIP_TEST_COMMAND_LINES");
10082 if (str && strcmp (str, "1") == 0) return 1;
10086 static int test_command_lines_5 (void)
10088 if (test_command_lines_5_skip ()) {
10089 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10093 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10095 char device[] = "/dev/sda";
10097 suppress_error = 0;
10098 r = guestfs_blockdev_setrw (g, device);
10104 suppress_error = 0;
10105 r = guestfs_umount_all (g);
10111 suppress_error = 0;
10112 r = guestfs_lvm_remove_all (g);
10117 char device[] = "/dev/sda";
10118 char lines_0[] = ",";
10124 suppress_error = 0;
10125 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10130 char fstype[] = "ext2";
10131 char device[] = "/dev/sda1";
10133 suppress_error = 0;
10134 r = guestfs_mkfs (g, fstype, device);
10139 char device[] = "/dev/sda1";
10140 char mountpoint[] = "/";
10142 suppress_error = 0;
10143 r = guestfs_mount (g, device, mountpoint);
10147 /* TestOutputList for command_lines (5) */
10149 char remotefilename[] = "/test-command";
10151 suppress_error = 0;
10152 r = guestfs_upload (g, "test-command", remotefilename);
10157 char path[] = "/test-command";
10159 suppress_error = 0;
10160 r = guestfs_chmod (g, 493, path);
10165 char arguments_0[] = "/test-command";
10166 char arguments_1[] = "6";
10167 char *arguments[] = {
10174 suppress_error = 0;
10175 r = guestfs_command_lines (g, arguments);
10179 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10184 char expected[] = "";
10185 if (strcmp (r[0], expected) != 0) {
10186 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10191 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10196 char expected[] = "";
10197 if (strcmp (r[1], expected) != 0) {
10198 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10203 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10208 char expected[] = "Result6";
10209 if (strcmp (r[2], expected) != 0) {
10210 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10215 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10220 char expected[] = "";
10221 if (strcmp (r[3], expected) != 0) {
10222 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10226 if (r[4] != NULL) {
10227 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10231 for (i = 0; r[i] != NULL; ++i)
10238 static int test_command_lines_6_skip (void)
10242 str = getenv ("TEST_ONLY");
10244 return strstr (str, "command_lines") == NULL;
10245 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10246 if (str && strcmp (str, "1") == 0) return 1;
10247 str = getenv ("SKIP_TEST_COMMAND_LINES");
10248 if (str && strcmp (str, "1") == 0) return 1;
10252 static int test_command_lines_6 (void)
10254 if (test_command_lines_6_skip ()) {
10255 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10259 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10261 char device[] = "/dev/sda";
10263 suppress_error = 0;
10264 r = guestfs_blockdev_setrw (g, device);
10270 suppress_error = 0;
10271 r = guestfs_umount_all (g);
10277 suppress_error = 0;
10278 r = guestfs_lvm_remove_all (g);
10283 char device[] = "/dev/sda";
10284 char lines_0[] = ",";
10290 suppress_error = 0;
10291 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10296 char fstype[] = "ext2";
10297 char device[] = "/dev/sda1";
10299 suppress_error = 0;
10300 r = guestfs_mkfs (g, fstype, device);
10305 char device[] = "/dev/sda1";
10306 char mountpoint[] = "/";
10308 suppress_error = 0;
10309 r = guestfs_mount (g, device, mountpoint);
10313 /* TestOutputList for command_lines (6) */
10315 char remotefilename[] = "/test-command";
10317 suppress_error = 0;
10318 r = guestfs_upload (g, "test-command", remotefilename);
10323 char path[] = "/test-command";
10325 suppress_error = 0;
10326 r = guestfs_chmod (g, 493, path);
10331 char arguments_0[] = "/test-command";
10332 char arguments_1[] = "7";
10333 char *arguments[] = {
10340 suppress_error = 0;
10341 r = guestfs_command_lines (g, arguments);
10344 if (r[0] != NULL) {
10345 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10349 for (i = 0; r[i] != NULL; ++i)
10356 static int test_command_lines_7_skip (void)
10360 str = getenv ("TEST_ONLY");
10362 return strstr (str, "command_lines") == NULL;
10363 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10364 if (str && strcmp (str, "1") == 0) return 1;
10365 str = getenv ("SKIP_TEST_COMMAND_LINES");
10366 if (str && strcmp (str, "1") == 0) return 1;
10370 static int test_command_lines_7 (void)
10372 if (test_command_lines_7_skip ()) {
10373 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10377 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10379 char device[] = "/dev/sda";
10381 suppress_error = 0;
10382 r = guestfs_blockdev_setrw (g, device);
10388 suppress_error = 0;
10389 r = guestfs_umount_all (g);
10395 suppress_error = 0;
10396 r = guestfs_lvm_remove_all (g);
10401 char device[] = "/dev/sda";
10402 char lines_0[] = ",";
10408 suppress_error = 0;
10409 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10414 char fstype[] = "ext2";
10415 char device[] = "/dev/sda1";
10417 suppress_error = 0;
10418 r = guestfs_mkfs (g, fstype, device);
10423 char device[] = "/dev/sda1";
10424 char mountpoint[] = "/";
10426 suppress_error = 0;
10427 r = guestfs_mount (g, device, mountpoint);
10431 /* TestOutputList for command_lines (7) */
10433 char remotefilename[] = "/test-command";
10435 suppress_error = 0;
10436 r = guestfs_upload (g, "test-command", remotefilename);
10441 char path[] = "/test-command";
10443 suppress_error = 0;
10444 r = guestfs_chmod (g, 493, path);
10449 char arguments_0[] = "/test-command";
10450 char arguments_1[] = "8";
10451 char *arguments[] = {
10458 suppress_error = 0;
10459 r = guestfs_command_lines (g, arguments);
10463 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10468 char expected[] = "";
10469 if (strcmp (r[0], expected) != 0) {
10470 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10474 if (r[1] != NULL) {
10475 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10479 for (i = 0; r[i] != NULL; ++i)
10486 static int test_command_lines_8_skip (void)
10490 str = getenv ("TEST_ONLY");
10492 return strstr (str, "command_lines") == NULL;
10493 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10494 if (str && strcmp (str, "1") == 0) return 1;
10495 str = getenv ("SKIP_TEST_COMMAND_LINES");
10496 if (str && strcmp (str, "1") == 0) return 1;
10500 static int test_command_lines_8 (void)
10502 if (test_command_lines_8_skip ()) {
10503 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10507 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10509 char device[] = "/dev/sda";
10511 suppress_error = 0;
10512 r = guestfs_blockdev_setrw (g, device);
10518 suppress_error = 0;
10519 r = guestfs_umount_all (g);
10525 suppress_error = 0;
10526 r = guestfs_lvm_remove_all (g);
10531 char device[] = "/dev/sda";
10532 char lines_0[] = ",";
10538 suppress_error = 0;
10539 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10544 char fstype[] = "ext2";
10545 char device[] = "/dev/sda1";
10547 suppress_error = 0;
10548 r = guestfs_mkfs (g, fstype, device);
10553 char device[] = "/dev/sda1";
10554 char mountpoint[] = "/";
10556 suppress_error = 0;
10557 r = guestfs_mount (g, device, mountpoint);
10561 /* TestOutputList for command_lines (8) */
10563 char remotefilename[] = "/test-command";
10565 suppress_error = 0;
10566 r = guestfs_upload (g, "test-command", remotefilename);
10571 char path[] = "/test-command";
10573 suppress_error = 0;
10574 r = guestfs_chmod (g, 493, path);
10579 char arguments_0[] = "/test-command";
10580 char arguments_1[] = "9";
10581 char *arguments[] = {
10588 suppress_error = 0;
10589 r = guestfs_command_lines (g, arguments);
10593 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10598 char expected[] = "";
10599 if (strcmp (r[0], expected) != 0) {
10600 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10605 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10610 char expected[] = "";
10611 if (strcmp (r[1], expected) != 0) {
10612 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10616 if (r[2] != NULL) {
10617 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10621 for (i = 0; r[i] != NULL; ++i)
10628 static int test_command_lines_9_skip (void)
10632 str = getenv ("TEST_ONLY");
10634 return strstr (str, "command_lines") == NULL;
10635 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10636 if (str && strcmp (str, "1") == 0) return 1;
10637 str = getenv ("SKIP_TEST_COMMAND_LINES");
10638 if (str && strcmp (str, "1") == 0) return 1;
10642 static int test_command_lines_9 (void)
10644 if (test_command_lines_9_skip ()) {
10645 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10649 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10651 char device[] = "/dev/sda";
10653 suppress_error = 0;
10654 r = guestfs_blockdev_setrw (g, device);
10660 suppress_error = 0;
10661 r = guestfs_umount_all (g);
10667 suppress_error = 0;
10668 r = guestfs_lvm_remove_all (g);
10673 char device[] = "/dev/sda";
10674 char lines_0[] = ",";
10680 suppress_error = 0;
10681 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10686 char fstype[] = "ext2";
10687 char device[] = "/dev/sda1";
10689 suppress_error = 0;
10690 r = guestfs_mkfs (g, fstype, device);
10695 char device[] = "/dev/sda1";
10696 char mountpoint[] = "/";
10698 suppress_error = 0;
10699 r = guestfs_mount (g, device, mountpoint);
10703 /* TestOutputList for command_lines (9) */
10705 char remotefilename[] = "/test-command";
10707 suppress_error = 0;
10708 r = guestfs_upload (g, "test-command", remotefilename);
10713 char path[] = "/test-command";
10715 suppress_error = 0;
10716 r = guestfs_chmod (g, 493, path);
10721 char arguments_0[] = "/test-command";
10722 char arguments_1[] = "10";
10723 char *arguments[] = {
10730 suppress_error = 0;
10731 r = guestfs_command_lines (g, arguments);
10735 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10740 char expected[] = "Result10-1";
10741 if (strcmp (r[0], expected) != 0) {
10742 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10747 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10752 char expected[] = "Result10-2";
10753 if (strcmp (r[1], expected) != 0) {
10754 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10758 if (r[2] != NULL) {
10759 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
10763 for (i = 0; r[i] != NULL; ++i)
10770 static int test_command_lines_10_skip (void)
10774 str = getenv ("TEST_ONLY");
10776 return strstr (str, "command_lines") == NULL;
10777 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
10778 if (str && strcmp (str, "1") == 0) return 1;
10779 str = getenv ("SKIP_TEST_COMMAND_LINES");
10780 if (str && strcmp (str, "1") == 0) return 1;
10784 static int test_command_lines_10 (void)
10786 if (test_command_lines_10_skip ()) {
10787 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
10791 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
10793 char device[] = "/dev/sda";
10795 suppress_error = 0;
10796 r = guestfs_blockdev_setrw (g, device);
10802 suppress_error = 0;
10803 r = guestfs_umount_all (g);
10809 suppress_error = 0;
10810 r = guestfs_lvm_remove_all (g);
10815 char device[] = "/dev/sda";
10816 char lines_0[] = ",";
10822 suppress_error = 0;
10823 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10828 char fstype[] = "ext2";
10829 char device[] = "/dev/sda1";
10831 suppress_error = 0;
10832 r = guestfs_mkfs (g, fstype, device);
10837 char device[] = "/dev/sda1";
10838 char mountpoint[] = "/";
10840 suppress_error = 0;
10841 r = guestfs_mount (g, device, mountpoint);
10845 /* TestOutputList for command_lines (10) */
10847 char remotefilename[] = "/test-command";
10849 suppress_error = 0;
10850 r = guestfs_upload (g, "test-command", remotefilename);
10855 char path[] = "/test-command";
10857 suppress_error = 0;
10858 r = guestfs_chmod (g, 493, path);
10863 char arguments_0[] = "/test-command";
10864 char arguments_1[] = "11";
10865 char *arguments[] = {
10872 suppress_error = 0;
10873 r = guestfs_command_lines (g, arguments);
10877 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10882 char expected[] = "Result11-1";
10883 if (strcmp (r[0], expected) != 0) {
10884 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10889 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10894 char expected[] = "Result11-2";
10895 if (strcmp (r[1], expected) != 0) {
10896 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10900 if (r[2] != NULL) {
10901 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
10905 for (i = 0; r[i] != NULL; ++i)
10912 static int test_command_0_skip (void)
10916 str = getenv ("TEST_ONLY");
10918 return strstr (str, "command") == NULL;
10919 str = getenv ("SKIP_TEST_COMMAND_0");
10920 if (str && strcmp (str, "1") == 0) return 1;
10921 str = getenv ("SKIP_TEST_COMMAND");
10922 if (str && strcmp (str, "1") == 0) return 1;
10926 static int test_command_0 (void)
10928 if (test_command_0_skip ()) {
10929 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
10933 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
10935 char device[] = "/dev/sda";
10937 suppress_error = 0;
10938 r = guestfs_blockdev_setrw (g, device);
10944 suppress_error = 0;
10945 r = guestfs_umount_all (g);
10951 suppress_error = 0;
10952 r = guestfs_lvm_remove_all (g);
10957 char device[] = "/dev/sda";
10958 char lines_0[] = ",";
10964 suppress_error = 0;
10965 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10970 char fstype[] = "ext2";
10971 char device[] = "/dev/sda1";
10973 suppress_error = 0;
10974 r = guestfs_mkfs (g, fstype, device);
10979 char device[] = "/dev/sda1";
10980 char mountpoint[] = "/";
10982 suppress_error = 0;
10983 r = guestfs_mount (g, device, mountpoint);
10987 /* TestOutput for command (0) */
10988 char expected[] = "Result1";
10990 char remotefilename[] = "/test-command";
10992 suppress_error = 0;
10993 r = guestfs_upload (g, "test-command", remotefilename);
10998 char path[] = "/test-command";
11000 suppress_error = 0;
11001 r = guestfs_chmod (g, 493, path);
11006 char arguments_0[] = "/test-command";
11007 char arguments_1[] = "1";
11008 char *arguments[] = {
11014 suppress_error = 0;
11015 r = guestfs_command (g, arguments);
11018 if (strcmp (r, expected) != 0) {
11019 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11027 static int test_command_1_skip (void)
11031 str = getenv ("TEST_ONLY");
11033 return strstr (str, "command") == NULL;
11034 str = getenv ("SKIP_TEST_COMMAND_1");
11035 if (str && strcmp (str, "1") == 0) return 1;
11036 str = getenv ("SKIP_TEST_COMMAND");
11037 if (str && strcmp (str, "1") == 0) return 1;
11041 static int test_command_1 (void)
11043 if (test_command_1_skip ()) {
11044 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11048 /* InitBasicFS for test_command_1: 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 /* TestOutput for command (1) */
11103 char expected[] = "Result2\n";
11105 char remotefilename[] = "/test-command";
11107 suppress_error = 0;
11108 r = guestfs_upload (g, "test-command", remotefilename);
11113 char path[] = "/test-command";
11115 suppress_error = 0;
11116 r = guestfs_chmod (g, 493, path);
11121 char arguments_0[] = "/test-command";
11122 char arguments_1[] = "2";
11123 char *arguments[] = {
11129 suppress_error = 0;
11130 r = guestfs_command (g, arguments);
11133 if (strcmp (r, expected) != 0) {
11134 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11142 static int test_command_2_skip (void)
11146 str = getenv ("TEST_ONLY");
11148 return strstr (str, "command") == NULL;
11149 str = getenv ("SKIP_TEST_COMMAND_2");
11150 if (str && strcmp (str, "1") == 0) return 1;
11151 str = getenv ("SKIP_TEST_COMMAND");
11152 if (str && strcmp (str, "1") == 0) return 1;
11156 static int test_command_2 (void)
11158 if (test_command_2_skip ()) {
11159 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11163 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11165 char device[] = "/dev/sda";
11167 suppress_error = 0;
11168 r = guestfs_blockdev_setrw (g, device);
11174 suppress_error = 0;
11175 r = guestfs_umount_all (g);
11181 suppress_error = 0;
11182 r = guestfs_lvm_remove_all (g);
11187 char device[] = "/dev/sda";
11188 char lines_0[] = ",";
11194 suppress_error = 0;
11195 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11200 char fstype[] = "ext2";
11201 char device[] = "/dev/sda1";
11203 suppress_error = 0;
11204 r = guestfs_mkfs (g, fstype, device);
11209 char device[] = "/dev/sda1";
11210 char mountpoint[] = "/";
11212 suppress_error = 0;
11213 r = guestfs_mount (g, device, mountpoint);
11217 /* TestOutput for command (2) */
11218 char expected[] = "\nResult3";
11220 char remotefilename[] = "/test-command";
11222 suppress_error = 0;
11223 r = guestfs_upload (g, "test-command", remotefilename);
11228 char path[] = "/test-command";
11230 suppress_error = 0;
11231 r = guestfs_chmod (g, 493, path);
11236 char arguments_0[] = "/test-command";
11237 char arguments_1[] = "3";
11238 char *arguments[] = {
11244 suppress_error = 0;
11245 r = guestfs_command (g, arguments);
11248 if (strcmp (r, expected) != 0) {
11249 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11257 static int test_command_3_skip (void)
11261 str = getenv ("TEST_ONLY");
11263 return strstr (str, "command") == NULL;
11264 str = getenv ("SKIP_TEST_COMMAND_3");
11265 if (str && strcmp (str, "1") == 0) return 1;
11266 str = getenv ("SKIP_TEST_COMMAND");
11267 if (str && strcmp (str, "1") == 0) return 1;
11271 static int test_command_3 (void)
11273 if (test_command_3_skip ()) {
11274 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11278 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11280 char device[] = "/dev/sda";
11282 suppress_error = 0;
11283 r = guestfs_blockdev_setrw (g, device);
11289 suppress_error = 0;
11290 r = guestfs_umount_all (g);
11296 suppress_error = 0;
11297 r = guestfs_lvm_remove_all (g);
11302 char device[] = "/dev/sda";
11303 char lines_0[] = ",";
11309 suppress_error = 0;
11310 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11315 char fstype[] = "ext2";
11316 char device[] = "/dev/sda1";
11318 suppress_error = 0;
11319 r = guestfs_mkfs (g, fstype, device);
11324 char device[] = "/dev/sda1";
11325 char mountpoint[] = "/";
11327 suppress_error = 0;
11328 r = guestfs_mount (g, device, mountpoint);
11332 /* TestOutput for command (3) */
11333 char expected[] = "\nResult4\n";
11335 char remotefilename[] = "/test-command";
11337 suppress_error = 0;
11338 r = guestfs_upload (g, "test-command", remotefilename);
11343 char path[] = "/test-command";
11345 suppress_error = 0;
11346 r = guestfs_chmod (g, 493, path);
11351 char arguments_0[] = "/test-command";
11352 char arguments_1[] = "4";
11353 char *arguments[] = {
11359 suppress_error = 0;
11360 r = guestfs_command (g, arguments);
11363 if (strcmp (r, expected) != 0) {
11364 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11372 static int test_command_4_skip (void)
11376 str = getenv ("TEST_ONLY");
11378 return strstr (str, "command") == NULL;
11379 str = getenv ("SKIP_TEST_COMMAND_4");
11380 if (str && strcmp (str, "1") == 0) return 1;
11381 str = getenv ("SKIP_TEST_COMMAND");
11382 if (str && strcmp (str, "1") == 0) return 1;
11386 static int test_command_4 (void)
11388 if (test_command_4_skip ()) {
11389 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11393 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11395 char device[] = "/dev/sda";
11397 suppress_error = 0;
11398 r = guestfs_blockdev_setrw (g, device);
11404 suppress_error = 0;
11405 r = guestfs_umount_all (g);
11411 suppress_error = 0;
11412 r = guestfs_lvm_remove_all (g);
11417 char device[] = "/dev/sda";
11418 char lines_0[] = ",";
11424 suppress_error = 0;
11425 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11430 char fstype[] = "ext2";
11431 char device[] = "/dev/sda1";
11433 suppress_error = 0;
11434 r = guestfs_mkfs (g, fstype, device);
11439 char device[] = "/dev/sda1";
11440 char mountpoint[] = "/";
11442 suppress_error = 0;
11443 r = guestfs_mount (g, device, mountpoint);
11447 /* TestOutput for command (4) */
11448 char expected[] = "\nResult5\n\n";
11450 char remotefilename[] = "/test-command";
11452 suppress_error = 0;
11453 r = guestfs_upload (g, "test-command", remotefilename);
11458 char path[] = "/test-command";
11460 suppress_error = 0;
11461 r = guestfs_chmod (g, 493, path);
11466 char arguments_0[] = "/test-command";
11467 char arguments_1[] = "5";
11468 char *arguments[] = {
11474 suppress_error = 0;
11475 r = guestfs_command (g, arguments);
11478 if (strcmp (r, expected) != 0) {
11479 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11487 static int test_command_5_skip (void)
11491 str = getenv ("TEST_ONLY");
11493 return strstr (str, "command") == NULL;
11494 str = getenv ("SKIP_TEST_COMMAND_5");
11495 if (str && strcmp (str, "1") == 0) return 1;
11496 str = getenv ("SKIP_TEST_COMMAND");
11497 if (str && strcmp (str, "1") == 0) return 1;
11501 static int test_command_5 (void)
11503 if (test_command_5_skip ()) {
11504 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11508 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11510 char device[] = "/dev/sda";
11512 suppress_error = 0;
11513 r = guestfs_blockdev_setrw (g, device);
11519 suppress_error = 0;
11520 r = guestfs_umount_all (g);
11526 suppress_error = 0;
11527 r = guestfs_lvm_remove_all (g);
11532 char device[] = "/dev/sda";
11533 char lines_0[] = ",";
11539 suppress_error = 0;
11540 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11545 char fstype[] = "ext2";
11546 char device[] = "/dev/sda1";
11548 suppress_error = 0;
11549 r = guestfs_mkfs (g, fstype, device);
11554 char device[] = "/dev/sda1";
11555 char mountpoint[] = "/";
11557 suppress_error = 0;
11558 r = guestfs_mount (g, device, mountpoint);
11562 /* TestOutput for command (5) */
11563 char expected[] = "\n\nResult6\n\n";
11565 char remotefilename[] = "/test-command";
11567 suppress_error = 0;
11568 r = guestfs_upload (g, "test-command", remotefilename);
11573 char path[] = "/test-command";
11575 suppress_error = 0;
11576 r = guestfs_chmod (g, 493, path);
11581 char arguments_0[] = "/test-command";
11582 char arguments_1[] = "6";
11583 char *arguments[] = {
11589 suppress_error = 0;
11590 r = guestfs_command (g, arguments);
11593 if (strcmp (r, expected) != 0) {
11594 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11602 static int test_command_6_skip (void)
11606 str = getenv ("TEST_ONLY");
11608 return strstr (str, "command") == NULL;
11609 str = getenv ("SKIP_TEST_COMMAND_6");
11610 if (str && strcmp (str, "1") == 0) return 1;
11611 str = getenv ("SKIP_TEST_COMMAND");
11612 if (str && strcmp (str, "1") == 0) return 1;
11616 static int test_command_6 (void)
11618 if (test_command_6_skip ()) {
11619 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11623 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11625 char device[] = "/dev/sda";
11627 suppress_error = 0;
11628 r = guestfs_blockdev_setrw (g, device);
11634 suppress_error = 0;
11635 r = guestfs_umount_all (g);
11641 suppress_error = 0;
11642 r = guestfs_lvm_remove_all (g);
11647 char device[] = "/dev/sda";
11648 char lines_0[] = ",";
11654 suppress_error = 0;
11655 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11660 char fstype[] = "ext2";
11661 char device[] = "/dev/sda1";
11663 suppress_error = 0;
11664 r = guestfs_mkfs (g, fstype, device);
11669 char device[] = "/dev/sda1";
11670 char mountpoint[] = "/";
11672 suppress_error = 0;
11673 r = guestfs_mount (g, device, mountpoint);
11677 /* TestOutput for command (6) */
11678 char expected[] = "";
11680 char remotefilename[] = "/test-command";
11682 suppress_error = 0;
11683 r = guestfs_upload (g, "test-command", remotefilename);
11688 char path[] = "/test-command";
11690 suppress_error = 0;
11691 r = guestfs_chmod (g, 493, path);
11696 char arguments_0[] = "/test-command";
11697 char arguments_1[] = "7";
11698 char *arguments[] = {
11704 suppress_error = 0;
11705 r = guestfs_command (g, arguments);
11708 if (strcmp (r, expected) != 0) {
11709 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11717 static int test_command_7_skip (void)
11721 str = getenv ("TEST_ONLY");
11723 return strstr (str, "command") == NULL;
11724 str = getenv ("SKIP_TEST_COMMAND_7");
11725 if (str && strcmp (str, "1") == 0) return 1;
11726 str = getenv ("SKIP_TEST_COMMAND");
11727 if (str && strcmp (str, "1") == 0) return 1;
11731 static int test_command_7 (void)
11733 if (test_command_7_skip ()) {
11734 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11738 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11740 char device[] = "/dev/sda";
11742 suppress_error = 0;
11743 r = guestfs_blockdev_setrw (g, device);
11749 suppress_error = 0;
11750 r = guestfs_umount_all (g);
11756 suppress_error = 0;
11757 r = guestfs_lvm_remove_all (g);
11762 char device[] = "/dev/sda";
11763 char lines_0[] = ",";
11769 suppress_error = 0;
11770 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11775 char fstype[] = "ext2";
11776 char device[] = "/dev/sda1";
11778 suppress_error = 0;
11779 r = guestfs_mkfs (g, fstype, device);
11784 char device[] = "/dev/sda1";
11785 char mountpoint[] = "/";
11787 suppress_error = 0;
11788 r = guestfs_mount (g, device, mountpoint);
11792 /* TestOutput for command (7) */
11793 char expected[] = "\n";
11795 char remotefilename[] = "/test-command";
11797 suppress_error = 0;
11798 r = guestfs_upload (g, "test-command", remotefilename);
11803 char path[] = "/test-command";
11805 suppress_error = 0;
11806 r = guestfs_chmod (g, 493, path);
11811 char arguments_0[] = "/test-command";
11812 char arguments_1[] = "8";
11813 char *arguments[] = {
11819 suppress_error = 0;
11820 r = guestfs_command (g, arguments);
11823 if (strcmp (r, expected) != 0) {
11824 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
11832 static int test_command_8_skip (void)
11836 str = getenv ("TEST_ONLY");
11838 return strstr (str, "command") == NULL;
11839 str = getenv ("SKIP_TEST_COMMAND_8");
11840 if (str && strcmp (str, "1") == 0) return 1;
11841 str = getenv ("SKIP_TEST_COMMAND");
11842 if (str && strcmp (str, "1") == 0) return 1;
11846 static int test_command_8 (void)
11848 if (test_command_8_skip ()) {
11849 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
11853 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
11855 char device[] = "/dev/sda";
11857 suppress_error = 0;
11858 r = guestfs_blockdev_setrw (g, device);
11864 suppress_error = 0;
11865 r = guestfs_umount_all (g);
11871 suppress_error = 0;
11872 r = guestfs_lvm_remove_all (g);
11877 char device[] = "/dev/sda";
11878 char lines_0[] = ",";
11884 suppress_error = 0;
11885 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11890 char fstype[] = "ext2";
11891 char device[] = "/dev/sda1";
11893 suppress_error = 0;
11894 r = guestfs_mkfs (g, fstype, device);
11899 char device[] = "/dev/sda1";
11900 char mountpoint[] = "/";
11902 suppress_error = 0;
11903 r = guestfs_mount (g, device, mountpoint);
11907 /* TestOutput for command (8) */
11908 char expected[] = "\n\n";
11910 char remotefilename[] = "/test-command";
11912 suppress_error = 0;
11913 r = guestfs_upload (g, "test-command", remotefilename);
11918 char path[] = "/test-command";
11920 suppress_error = 0;
11921 r = guestfs_chmod (g, 493, path);
11926 char arguments_0[] = "/test-command";
11927 char arguments_1[] = "9";
11928 char *arguments[] = {
11934 suppress_error = 0;
11935 r = guestfs_command (g, arguments);
11938 if (strcmp (r, expected) != 0) {
11939 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
11947 static int test_command_9_skip (void)
11951 str = getenv ("TEST_ONLY");
11953 return strstr (str, "command") == NULL;
11954 str = getenv ("SKIP_TEST_COMMAND_9");
11955 if (str && strcmp (str, "1") == 0) return 1;
11956 str = getenv ("SKIP_TEST_COMMAND");
11957 if (str && strcmp (str, "1") == 0) return 1;
11961 static int test_command_9 (void)
11963 if (test_command_9_skip ()) {
11964 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
11968 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
11970 char device[] = "/dev/sda";
11972 suppress_error = 0;
11973 r = guestfs_blockdev_setrw (g, device);
11979 suppress_error = 0;
11980 r = guestfs_umount_all (g);
11986 suppress_error = 0;
11987 r = guestfs_lvm_remove_all (g);
11992 char device[] = "/dev/sda";
11993 char lines_0[] = ",";
11999 suppress_error = 0;
12000 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12005 char fstype[] = "ext2";
12006 char device[] = "/dev/sda1";
12008 suppress_error = 0;
12009 r = guestfs_mkfs (g, fstype, device);
12014 char device[] = "/dev/sda1";
12015 char mountpoint[] = "/";
12017 suppress_error = 0;
12018 r = guestfs_mount (g, device, mountpoint);
12022 /* TestOutput for command (9) */
12023 char expected[] = "Result10-1\nResult10-2\n";
12025 char remotefilename[] = "/test-command";
12027 suppress_error = 0;
12028 r = guestfs_upload (g, "test-command", remotefilename);
12033 char path[] = "/test-command";
12035 suppress_error = 0;
12036 r = guestfs_chmod (g, 493, path);
12041 char arguments_0[] = "/test-command";
12042 char arguments_1[] = "10";
12043 char *arguments[] = {
12049 suppress_error = 0;
12050 r = guestfs_command (g, arguments);
12053 if (strcmp (r, expected) != 0) {
12054 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12062 static int test_command_10_skip (void)
12066 str = getenv ("TEST_ONLY");
12068 return strstr (str, "command") == NULL;
12069 str = getenv ("SKIP_TEST_COMMAND_10");
12070 if (str && strcmp (str, "1") == 0) return 1;
12071 str = getenv ("SKIP_TEST_COMMAND");
12072 if (str && strcmp (str, "1") == 0) return 1;
12076 static int test_command_10 (void)
12078 if (test_command_10_skip ()) {
12079 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12083 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12085 char device[] = "/dev/sda";
12087 suppress_error = 0;
12088 r = guestfs_blockdev_setrw (g, device);
12094 suppress_error = 0;
12095 r = guestfs_umount_all (g);
12101 suppress_error = 0;
12102 r = guestfs_lvm_remove_all (g);
12107 char device[] = "/dev/sda";
12108 char lines_0[] = ",";
12114 suppress_error = 0;
12115 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12120 char fstype[] = "ext2";
12121 char device[] = "/dev/sda1";
12123 suppress_error = 0;
12124 r = guestfs_mkfs (g, fstype, device);
12129 char device[] = "/dev/sda1";
12130 char mountpoint[] = "/";
12132 suppress_error = 0;
12133 r = guestfs_mount (g, device, mountpoint);
12137 /* TestOutput for command (10) */
12138 char expected[] = "Result11-1\nResult11-2";
12140 char remotefilename[] = "/test-command";
12142 suppress_error = 0;
12143 r = guestfs_upload (g, "test-command", remotefilename);
12148 char path[] = "/test-command";
12150 suppress_error = 0;
12151 r = guestfs_chmod (g, 493, path);
12156 char arguments_0[] = "/test-command";
12157 char arguments_1[] = "11";
12158 char *arguments[] = {
12164 suppress_error = 0;
12165 r = guestfs_command (g, arguments);
12168 if (strcmp (r, expected) != 0) {
12169 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12177 static int test_command_11_skip (void)
12181 str = getenv ("TEST_ONLY");
12183 return strstr (str, "command") == NULL;
12184 str = getenv ("SKIP_TEST_COMMAND_11");
12185 if (str && strcmp (str, "1") == 0) return 1;
12186 str = getenv ("SKIP_TEST_COMMAND");
12187 if (str && strcmp (str, "1") == 0) return 1;
12191 static int test_command_11 (void)
12193 if (test_command_11_skip ()) {
12194 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12198 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12200 char device[] = "/dev/sda";
12202 suppress_error = 0;
12203 r = guestfs_blockdev_setrw (g, device);
12209 suppress_error = 0;
12210 r = guestfs_umount_all (g);
12216 suppress_error = 0;
12217 r = guestfs_lvm_remove_all (g);
12222 char device[] = "/dev/sda";
12223 char lines_0[] = ",";
12229 suppress_error = 0;
12230 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12235 char fstype[] = "ext2";
12236 char device[] = "/dev/sda1";
12238 suppress_error = 0;
12239 r = guestfs_mkfs (g, fstype, device);
12244 char device[] = "/dev/sda1";
12245 char mountpoint[] = "/";
12247 suppress_error = 0;
12248 r = guestfs_mount (g, device, mountpoint);
12252 /* TestLastFail for command (11) */
12254 char remotefilename[] = "/test-command";
12256 suppress_error = 0;
12257 r = guestfs_upload (g, "test-command", remotefilename);
12262 char path[] = "/test-command";
12264 suppress_error = 0;
12265 r = guestfs_chmod (g, 493, path);
12270 char arguments_0[] = "/test-command";
12271 char *arguments[] = {
12276 suppress_error = 1;
12277 r = guestfs_command (g, arguments);
12285 static int test_file_0_skip (void)
12289 str = getenv ("TEST_ONLY");
12291 return strstr (str, "file") == NULL;
12292 str = getenv ("SKIP_TEST_FILE_0");
12293 if (str && strcmp (str, "1") == 0) return 1;
12294 str = getenv ("SKIP_TEST_FILE");
12295 if (str && strcmp (str, "1") == 0) return 1;
12299 static int test_file_0 (void)
12301 if (test_file_0_skip ()) {
12302 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12306 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12308 char device[] = "/dev/sda";
12310 suppress_error = 0;
12311 r = guestfs_blockdev_setrw (g, device);
12317 suppress_error = 0;
12318 r = guestfs_umount_all (g);
12324 suppress_error = 0;
12325 r = guestfs_lvm_remove_all (g);
12330 char device[] = "/dev/sda";
12331 char lines_0[] = ",";
12337 suppress_error = 0;
12338 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12343 char fstype[] = "ext2";
12344 char device[] = "/dev/sda1";
12346 suppress_error = 0;
12347 r = guestfs_mkfs (g, fstype, device);
12352 char device[] = "/dev/sda1";
12353 char mountpoint[] = "/";
12355 suppress_error = 0;
12356 r = guestfs_mount (g, device, mountpoint);
12360 /* TestOutput for file (0) */
12361 char expected[] = "empty";
12363 char path[] = "/new";
12365 suppress_error = 0;
12366 r = guestfs_touch (g, path);
12371 char path[] = "/new";
12373 suppress_error = 0;
12374 r = guestfs_file (g, path);
12377 if (strcmp (r, expected) != 0) {
12378 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12386 static int test_file_1_skip (void)
12390 str = getenv ("TEST_ONLY");
12392 return strstr (str, "file") == NULL;
12393 str = getenv ("SKIP_TEST_FILE_1");
12394 if (str && strcmp (str, "1") == 0) return 1;
12395 str = getenv ("SKIP_TEST_FILE");
12396 if (str && strcmp (str, "1") == 0) return 1;
12400 static int test_file_1 (void)
12402 if (test_file_1_skip ()) {
12403 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12407 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12409 char device[] = "/dev/sda";
12411 suppress_error = 0;
12412 r = guestfs_blockdev_setrw (g, device);
12418 suppress_error = 0;
12419 r = guestfs_umount_all (g);
12425 suppress_error = 0;
12426 r = guestfs_lvm_remove_all (g);
12431 char device[] = "/dev/sda";
12432 char lines_0[] = ",";
12438 suppress_error = 0;
12439 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12444 char fstype[] = "ext2";
12445 char device[] = "/dev/sda1";
12447 suppress_error = 0;
12448 r = guestfs_mkfs (g, fstype, device);
12453 char device[] = "/dev/sda1";
12454 char mountpoint[] = "/";
12456 suppress_error = 0;
12457 r = guestfs_mount (g, device, mountpoint);
12461 /* TestOutput for file (1) */
12462 char expected[] = "ASCII text";
12464 char path[] = "/new";
12465 char content[] = "some content\n";
12467 suppress_error = 0;
12468 r = guestfs_write_file (g, path, content, 0);
12473 char path[] = "/new";
12475 suppress_error = 0;
12476 r = guestfs_file (g, path);
12479 if (strcmp (r, expected) != 0) {
12480 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12488 static int test_file_2_skip (void)
12492 str = getenv ("TEST_ONLY");
12494 return strstr (str, "file") == NULL;
12495 str = getenv ("SKIP_TEST_FILE_2");
12496 if (str && strcmp (str, "1") == 0) return 1;
12497 str = getenv ("SKIP_TEST_FILE");
12498 if (str && strcmp (str, "1") == 0) return 1;
12502 static int test_file_2 (void)
12504 if (test_file_2_skip ()) {
12505 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12509 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12511 char device[] = "/dev/sda";
12513 suppress_error = 0;
12514 r = guestfs_blockdev_setrw (g, device);
12520 suppress_error = 0;
12521 r = guestfs_umount_all (g);
12527 suppress_error = 0;
12528 r = guestfs_lvm_remove_all (g);
12533 char device[] = "/dev/sda";
12534 char lines_0[] = ",";
12540 suppress_error = 0;
12541 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12546 char fstype[] = "ext2";
12547 char device[] = "/dev/sda1";
12549 suppress_error = 0;
12550 r = guestfs_mkfs (g, fstype, device);
12555 char device[] = "/dev/sda1";
12556 char mountpoint[] = "/";
12558 suppress_error = 0;
12559 r = guestfs_mount (g, device, mountpoint);
12563 /* TestLastFail for file (2) */
12565 char path[] = "/nofile";
12567 suppress_error = 1;
12568 r = guestfs_file (g, path);
12576 static int test_umount_all_0_skip (void)
12580 str = getenv ("TEST_ONLY");
12582 return strstr (str, "umount_all") == NULL;
12583 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12584 if (str && strcmp (str, "1") == 0) return 1;
12585 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12586 if (str && strcmp (str, "1") == 0) return 1;
12590 static int test_umount_all_0 (void)
12592 if (test_umount_all_0_skip ()) {
12593 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12597 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12599 char device[] = "/dev/sda";
12601 suppress_error = 0;
12602 r = guestfs_blockdev_setrw (g, device);
12608 suppress_error = 0;
12609 r = guestfs_umount_all (g);
12615 suppress_error = 0;
12616 r = guestfs_lvm_remove_all (g);
12621 char device[] = "/dev/sda";
12622 char lines_0[] = ",";
12628 suppress_error = 0;
12629 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12634 char fstype[] = "ext2";
12635 char device[] = "/dev/sda1";
12637 suppress_error = 0;
12638 r = guestfs_mkfs (g, fstype, device);
12643 char device[] = "/dev/sda1";
12644 char mountpoint[] = "/";
12646 suppress_error = 0;
12647 r = guestfs_mount (g, device, mountpoint);
12651 /* TestOutputList for umount_all (0) */
12654 suppress_error = 0;
12655 r = guestfs_umount_all (g);
12662 suppress_error = 0;
12663 r = guestfs_mounts (g);
12666 if (r[0] != NULL) {
12667 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12671 for (i = 0; r[i] != NULL; ++i)
12678 static int test_umount_all_1_skip (void)
12682 str = getenv ("TEST_ONLY");
12684 return strstr (str, "umount_all") == NULL;
12685 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12686 if (str && strcmp (str, "1") == 0) return 1;
12687 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12688 if (str && strcmp (str, "1") == 0) return 1;
12692 static int test_umount_all_1 (void)
12694 if (test_umount_all_1_skip ()) {
12695 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12699 /* InitNone|InitEmpty for test_umount_all_1 */
12701 char device[] = "/dev/sda";
12703 suppress_error = 0;
12704 r = guestfs_blockdev_setrw (g, device);
12710 suppress_error = 0;
12711 r = guestfs_umount_all (g);
12717 suppress_error = 0;
12718 r = guestfs_lvm_remove_all (g);
12722 /* TestOutputList for umount_all (1) */
12724 char device[] = "/dev/sda";
12725 char lines_0[] = ",10";
12726 char lines_1[] = ",20";
12727 char lines_2[] = ",";
12735 suppress_error = 0;
12736 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12741 char fstype[] = "ext2";
12742 char device[] = "/dev/sda1";
12744 suppress_error = 0;
12745 r = guestfs_mkfs (g, fstype, device);
12750 char fstype[] = "ext2";
12751 char device[] = "/dev/sda2";
12753 suppress_error = 0;
12754 r = guestfs_mkfs (g, fstype, device);
12759 char fstype[] = "ext2";
12760 char device[] = "/dev/sda3";
12762 suppress_error = 0;
12763 r = guestfs_mkfs (g, fstype, device);
12768 char device[] = "/dev/sda1";
12769 char mountpoint[] = "/";
12771 suppress_error = 0;
12772 r = guestfs_mount (g, device, mountpoint);
12777 char path[] = "/mp1";
12779 suppress_error = 0;
12780 r = guestfs_mkdir (g, path);
12785 char device[] = "/dev/sda2";
12786 char mountpoint[] = "/mp1";
12788 suppress_error = 0;
12789 r = guestfs_mount (g, device, mountpoint);
12794 char path[] = "/mp1/mp2";
12796 suppress_error = 0;
12797 r = guestfs_mkdir (g, path);
12802 char device[] = "/dev/sda3";
12803 char mountpoint[] = "/mp1/mp2";
12805 suppress_error = 0;
12806 r = guestfs_mount (g, device, mountpoint);
12811 char path[] = "/mp1/mp2/mp3";
12813 suppress_error = 0;
12814 r = guestfs_mkdir (g, path);
12820 suppress_error = 0;
12821 r = guestfs_umount_all (g);
12828 suppress_error = 0;
12829 r = guestfs_mounts (g);
12832 if (r[0] != NULL) {
12833 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
12837 for (i = 0; r[i] != NULL; ++i)
12844 static int test_mounts_0_skip (void)
12848 str = getenv ("TEST_ONLY");
12850 return strstr (str, "mounts") == NULL;
12851 str = getenv ("SKIP_TEST_MOUNTS_0");
12852 if (str && strcmp (str, "1") == 0) return 1;
12853 str = getenv ("SKIP_TEST_MOUNTS");
12854 if (str && strcmp (str, "1") == 0) return 1;
12858 static int test_mounts_0 (void)
12860 if (test_mounts_0_skip ()) {
12861 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
12865 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
12867 char device[] = "/dev/sda";
12869 suppress_error = 0;
12870 r = guestfs_blockdev_setrw (g, device);
12876 suppress_error = 0;
12877 r = guestfs_umount_all (g);
12883 suppress_error = 0;
12884 r = guestfs_lvm_remove_all (g);
12889 char device[] = "/dev/sda";
12890 char lines_0[] = ",";
12896 suppress_error = 0;
12897 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12902 char fstype[] = "ext2";
12903 char device[] = "/dev/sda1";
12905 suppress_error = 0;
12906 r = guestfs_mkfs (g, fstype, device);
12911 char device[] = "/dev/sda1";
12912 char mountpoint[] = "/";
12914 suppress_error = 0;
12915 r = guestfs_mount (g, device, mountpoint);
12919 /* TestOutputListOfDevices for mounts (0) */
12923 suppress_error = 0;
12924 r = guestfs_mounts (g);
12928 fprintf (stderr, "test_mounts_0: short list returned from command\n");
12933 char expected[] = "/dev/sda1";
12935 if (strcmp (r[0], expected) != 0) {
12936 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12940 if (r[1] != NULL) {
12941 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
12945 for (i = 0; r[i] != NULL; ++i)
12952 static int test_umount_0_skip (void)
12956 str = getenv ("TEST_ONLY");
12958 return strstr (str, "umount") == NULL;
12959 str = getenv ("SKIP_TEST_UMOUNT_0");
12960 if (str && strcmp (str, "1") == 0) return 1;
12961 str = getenv ("SKIP_TEST_UMOUNT");
12962 if (str && strcmp (str, "1") == 0) return 1;
12966 static int test_umount_0 (void)
12968 if (test_umount_0_skip ()) {
12969 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
12973 /* InitNone|InitEmpty for test_umount_0 */
12975 char device[] = "/dev/sda";
12977 suppress_error = 0;
12978 r = guestfs_blockdev_setrw (g, device);
12984 suppress_error = 0;
12985 r = guestfs_umount_all (g);
12991 suppress_error = 0;
12992 r = guestfs_lvm_remove_all (g);
12996 /* TestOutputListOfDevices for umount (0) */
12998 char device[] = "/dev/sda";
12999 char lines_0[] = ",";
13005 suppress_error = 0;
13006 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13011 char fstype[] = "ext2";
13012 char device[] = "/dev/sda1";
13014 suppress_error = 0;
13015 r = guestfs_mkfs (g, fstype, device);
13020 char device[] = "/dev/sda1";
13021 char mountpoint[] = "/";
13023 suppress_error = 0;
13024 r = guestfs_mount (g, device, mountpoint);
13031 suppress_error = 0;
13032 r = guestfs_mounts (g);
13036 fprintf (stderr, "test_umount_0: short list returned from command\n");
13041 char expected[] = "/dev/sda1";
13043 if (strcmp (r[0], expected) != 0) {
13044 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13048 if (r[1] != NULL) {
13049 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13053 for (i = 0; r[i] != NULL; ++i)
13060 static int test_umount_1_skip (void)
13064 str = getenv ("TEST_ONLY");
13066 return strstr (str, "umount") == NULL;
13067 str = getenv ("SKIP_TEST_UMOUNT_1");
13068 if (str && strcmp (str, "1") == 0) return 1;
13069 str = getenv ("SKIP_TEST_UMOUNT");
13070 if (str && strcmp (str, "1") == 0) return 1;
13074 static int test_umount_1 (void)
13076 if (test_umount_1_skip ()) {
13077 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13081 /* InitNone|InitEmpty for test_umount_1 */
13083 char device[] = "/dev/sda";
13085 suppress_error = 0;
13086 r = guestfs_blockdev_setrw (g, device);
13092 suppress_error = 0;
13093 r = guestfs_umount_all (g);
13099 suppress_error = 0;
13100 r = guestfs_lvm_remove_all (g);
13104 /* TestOutputList for umount (1) */
13106 char device[] = "/dev/sda";
13107 char lines_0[] = ",";
13113 suppress_error = 0;
13114 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13119 char fstype[] = "ext2";
13120 char device[] = "/dev/sda1";
13122 suppress_error = 0;
13123 r = guestfs_mkfs (g, fstype, device);
13128 char device[] = "/dev/sda1";
13129 char mountpoint[] = "/";
13131 suppress_error = 0;
13132 r = guestfs_mount (g, device, mountpoint);
13137 char pathordevice[] = "/";
13139 suppress_error = 0;
13140 r = guestfs_umount (g, pathordevice);
13147 suppress_error = 0;
13148 r = guestfs_mounts (g);
13151 if (r[0] != NULL) {
13152 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13156 for (i = 0; r[i] != NULL; ++i)
13163 static int test_write_file_0_skip (void)
13167 str = getenv ("TEST_ONLY");
13169 return strstr (str, "write_file") == NULL;
13170 str = getenv ("SKIP_TEST_WRITE_FILE_0");
13171 if (str && strcmp (str, "1") == 0) return 1;
13172 str = getenv ("SKIP_TEST_WRITE_FILE");
13173 if (str && strcmp (str, "1") == 0) return 1;
13177 static int test_write_file_0 (void)
13179 if (test_write_file_0_skip ()) {
13180 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13184 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13186 char device[] = "/dev/sda";
13188 suppress_error = 0;
13189 r = guestfs_blockdev_setrw (g, device);
13195 suppress_error = 0;
13196 r = guestfs_umount_all (g);
13202 suppress_error = 0;
13203 r = guestfs_lvm_remove_all (g);
13208 char device[] = "/dev/sda";
13209 char lines_0[] = ",";
13215 suppress_error = 0;
13216 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13221 char fstype[] = "ext2";
13222 char device[] = "/dev/sda1";
13224 suppress_error = 0;
13225 r = guestfs_mkfs (g, fstype, device);
13230 char device[] = "/dev/sda1";
13231 char mountpoint[] = "/";
13233 suppress_error = 0;
13234 r = guestfs_mount (g, device, mountpoint);
13238 /* TestOutput for write_file (0) */
13239 char expected[] = "new file contents";
13241 char path[] = "/new";
13242 char content[] = "new file contents";
13244 suppress_error = 0;
13245 r = guestfs_write_file (g, path, content, 0);
13250 char path[] = "/new";
13252 suppress_error = 0;
13253 r = guestfs_cat (g, path);
13256 if (strcmp (r, expected) != 0) {
13257 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13265 static int test_write_file_1_skip (void)
13269 str = getenv ("TEST_ONLY");
13271 return strstr (str, "write_file") == NULL;
13272 str = getenv ("SKIP_TEST_WRITE_FILE_1");
13273 if (str && strcmp (str, "1") == 0) return 1;
13274 str = getenv ("SKIP_TEST_WRITE_FILE");
13275 if (str && strcmp (str, "1") == 0) return 1;
13279 static int test_write_file_1 (void)
13281 if (test_write_file_1_skip ()) {
13282 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13286 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13288 char device[] = "/dev/sda";
13290 suppress_error = 0;
13291 r = guestfs_blockdev_setrw (g, device);
13297 suppress_error = 0;
13298 r = guestfs_umount_all (g);
13304 suppress_error = 0;
13305 r = guestfs_lvm_remove_all (g);
13310 char device[] = "/dev/sda";
13311 char lines_0[] = ",";
13317 suppress_error = 0;
13318 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13323 char fstype[] = "ext2";
13324 char device[] = "/dev/sda1";
13326 suppress_error = 0;
13327 r = guestfs_mkfs (g, fstype, device);
13332 char device[] = "/dev/sda1";
13333 char mountpoint[] = "/";
13335 suppress_error = 0;
13336 r = guestfs_mount (g, device, mountpoint);
13340 /* TestOutput for write_file (1) */
13341 char expected[] = "\nnew file contents\n";
13343 char path[] = "/new";
13344 char content[] = "\nnew file contents\n";
13346 suppress_error = 0;
13347 r = guestfs_write_file (g, path, content, 0);
13352 char path[] = "/new";
13354 suppress_error = 0;
13355 r = guestfs_cat (g, path);
13358 if (strcmp (r, expected) != 0) {
13359 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13367 static int test_write_file_2_skip (void)
13371 str = getenv ("TEST_ONLY");
13373 return strstr (str, "write_file") == NULL;
13374 str = getenv ("SKIP_TEST_WRITE_FILE_2");
13375 if (str && strcmp (str, "1") == 0) return 1;
13376 str = getenv ("SKIP_TEST_WRITE_FILE");
13377 if (str && strcmp (str, "1") == 0) return 1;
13381 static int test_write_file_2 (void)
13383 if (test_write_file_2_skip ()) {
13384 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13388 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13390 char device[] = "/dev/sda";
13392 suppress_error = 0;
13393 r = guestfs_blockdev_setrw (g, device);
13399 suppress_error = 0;
13400 r = guestfs_umount_all (g);
13406 suppress_error = 0;
13407 r = guestfs_lvm_remove_all (g);
13412 char device[] = "/dev/sda";
13413 char lines_0[] = ",";
13419 suppress_error = 0;
13420 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13425 char fstype[] = "ext2";
13426 char device[] = "/dev/sda1";
13428 suppress_error = 0;
13429 r = guestfs_mkfs (g, fstype, device);
13434 char device[] = "/dev/sda1";
13435 char mountpoint[] = "/";
13437 suppress_error = 0;
13438 r = guestfs_mount (g, device, mountpoint);
13442 /* TestOutput for write_file (2) */
13443 char expected[] = "\n\n";
13445 char path[] = "/new";
13446 char content[] = "\n\n";
13448 suppress_error = 0;
13449 r = guestfs_write_file (g, path, content, 0);
13454 char path[] = "/new";
13456 suppress_error = 0;
13457 r = guestfs_cat (g, path);
13460 if (strcmp (r, expected) != 0) {
13461 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13469 static int test_write_file_3_skip (void)
13473 str = getenv ("TEST_ONLY");
13475 return strstr (str, "write_file") == NULL;
13476 str = getenv ("SKIP_TEST_WRITE_FILE_3");
13477 if (str && strcmp (str, "1") == 0) return 1;
13478 str = getenv ("SKIP_TEST_WRITE_FILE");
13479 if (str && strcmp (str, "1") == 0) return 1;
13483 static int test_write_file_3 (void)
13485 if (test_write_file_3_skip ()) {
13486 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13490 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13492 char device[] = "/dev/sda";
13494 suppress_error = 0;
13495 r = guestfs_blockdev_setrw (g, device);
13501 suppress_error = 0;
13502 r = guestfs_umount_all (g);
13508 suppress_error = 0;
13509 r = guestfs_lvm_remove_all (g);
13514 char device[] = "/dev/sda";
13515 char lines_0[] = ",";
13521 suppress_error = 0;
13522 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13527 char fstype[] = "ext2";
13528 char device[] = "/dev/sda1";
13530 suppress_error = 0;
13531 r = guestfs_mkfs (g, fstype, device);
13536 char device[] = "/dev/sda1";
13537 char mountpoint[] = "/";
13539 suppress_error = 0;
13540 r = guestfs_mount (g, device, mountpoint);
13544 /* TestOutput for write_file (3) */
13545 char expected[] = "";
13547 char path[] = "/new";
13548 char content[] = "";
13550 suppress_error = 0;
13551 r = guestfs_write_file (g, path, content, 0);
13556 char path[] = "/new";
13558 suppress_error = 0;
13559 r = guestfs_cat (g, path);
13562 if (strcmp (r, expected) != 0) {
13563 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13571 static int test_write_file_4_skip (void)
13575 str = getenv ("TEST_ONLY");
13577 return strstr (str, "write_file") == NULL;
13578 str = getenv ("SKIP_TEST_WRITE_FILE_4");
13579 if (str && strcmp (str, "1") == 0) return 1;
13580 str = getenv ("SKIP_TEST_WRITE_FILE");
13581 if (str && strcmp (str, "1") == 0) return 1;
13585 static int test_write_file_4 (void)
13587 if (test_write_file_4_skip ()) {
13588 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13592 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13594 char device[] = "/dev/sda";
13596 suppress_error = 0;
13597 r = guestfs_blockdev_setrw (g, device);
13603 suppress_error = 0;
13604 r = guestfs_umount_all (g);
13610 suppress_error = 0;
13611 r = guestfs_lvm_remove_all (g);
13616 char device[] = "/dev/sda";
13617 char lines_0[] = ",";
13623 suppress_error = 0;
13624 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13629 char fstype[] = "ext2";
13630 char device[] = "/dev/sda1";
13632 suppress_error = 0;
13633 r = guestfs_mkfs (g, fstype, device);
13638 char device[] = "/dev/sda1";
13639 char mountpoint[] = "/";
13641 suppress_error = 0;
13642 r = guestfs_mount (g, device, mountpoint);
13646 /* TestOutput for write_file (4) */
13647 char expected[] = "\n\n\n";
13649 char path[] = "/new";
13650 char content[] = "\n\n\n";
13652 suppress_error = 0;
13653 r = guestfs_write_file (g, path, content, 0);
13658 char path[] = "/new";
13660 suppress_error = 0;
13661 r = guestfs_cat (g, path);
13664 if (strcmp (r, expected) != 0) {
13665 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13673 static int test_write_file_5_skip (void)
13677 str = getenv ("TEST_ONLY");
13679 return strstr (str, "write_file") == NULL;
13680 str = getenv ("SKIP_TEST_WRITE_FILE_5");
13681 if (str && strcmp (str, "1") == 0) return 1;
13682 str = getenv ("SKIP_TEST_WRITE_FILE");
13683 if (str && strcmp (str, "1") == 0) return 1;
13687 static int test_write_file_5 (void)
13689 if (test_write_file_5_skip ()) {
13690 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13694 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13696 char device[] = "/dev/sda";
13698 suppress_error = 0;
13699 r = guestfs_blockdev_setrw (g, device);
13705 suppress_error = 0;
13706 r = guestfs_umount_all (g);
13712 suppress_error = 0;
13713 r = guestfs_lvm_remove_all (g);
13718 char device[] = "/dev/sda";
13719 char lines_0[] = ",";
13725 suppress_error = 0;
13726 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13731 char fstype[] = "ext2";
13732 char device[] = "/dev/sda1";
13734 suppress_error = 0;
13735 r = guestfs_mkfs (g, fstype, device);
13740 char device[] = "/dev/sda1";
13741 char mountpoint[] = "/";
13743 suppress_error = 0;
13744 r = guestfs_mount (g, device, mountpoint);
13748 /* TestOutput for write_file (5) */
13749 char expected[] = "\n";
13751 char path[] = "/new";
13752 char content[] = "\n";
13754 suppress_error = 0;
13755 r = guestfs_write_file (g, path, content, 0);
13760 char path[] = "/new";
13762 suppress_error = 0;
13763 r = guestfs_cat (g, path);
13766 if (strcmp (r, expected) != 0) {
13767 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
13775 static int test_mkfs_0_skip (void)
13779 str = getenv ("TEST_ONLY");
13781 return strstr (str, "mkfs") == NULL;
13782 str = getenv ("SKIP_TEST_MKFS_0");
13783 if (str && strcmp (str, "1") == 0) return 1;
13784 str = getenv ("SKIP_TEST_MKFS");
13785 if (str && strcmp (str, "1") == 0) return 1;
13789 static int test_mkfs_0 (void)
13791 if (test_mkfs_0_skip ()) {
13792 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
13796 /* InitNone|InitEmpty for test_mkfs_0 */
13798 char device[] = "/dev/sda";
13800 suppress_error = 0;
13801 r = guestfs_blockdev_setrw (g, device);
13807 suppress_error = 0;
13808 r = guestfs_umount_all (g);
13814 suppress_error = 0;
13815 r = guestfs_lvm_remove_all (g);
13819 /* TestOutput for mkfs (0) */
13820 char expected[] = "new file contents";
13822 char device[] = "/dev/sda";
13823 char lines_0[] = ",";
13829 suppress_error = 0;
13830 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13835 char fstype[] = "ext2";
13836 char device[] = "/dev/sda1";
13838 suppress_error = 0;
13839 r = guestfs_mkfs (g, fstype, device);
13844 char device[] = "/dev/sda1";
13845 char mountpoint[] = "/";
13847 suppress_error = 0;
13848 r = guestfs_mount (g, device, mountpoint);
13853 char path[] = "/new";
13854 char content[] = "new file contents";
13856 suppress_error = 0;
13857 r = guestfs_write_file (g, path, content, 0);
13862 char path[] = "/new";
13864 suppress_error = 0;
13865 r = guestfs_cat (g, path);
13868 if (strcmp (r, expected) != 0) {
13869 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
13877 static int test_lvcreate_0_skip (void)
13881 str = getenv ("TEST_ONLY");
13883 return strstr (str, "lvcreate") == NULL;
13884 str = getenv ("SKIP_TEST_LVCREATE_0");
13885 if (str && strcmp (str, "1") == 0) return 1;
13886 str = getenv ("SKIP_TEST_LVCREATE");
13887 if (str && strcmp (str, "1") == 0) return 1;
13891 static int test_lvcreate_0 (void)
13893 if (test_lvcreate_0_skip ()) {
13894 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
13898 /* InitNone|InitEmpty for test_lvcreate_0 */
13900 char device[] = "/dev/sda";
13902 suppress_error = 0;
13903 r = guestfs_blockdev_setrw (g, device);
13909 suppress_error = 0;
13910 r = guestfs_umount_all (g);
13916 suppress_error = 0;
13917 r = guestfs_lvm_remove_all (g);
13921 /* TestOutputList for lvcreate (0) */
13923 char device[] = "/dev/sda";
13924 char lines_0[] = ",10";
13925 char lines_1[] = ",20";
13926 char lines_2[] = ",";
13934 suppress_error = 0;
13935 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13940 char device[] = "/dev/sda1";
13942 suppress_error = 0;
13943 r = guestfs_pvcreate (g, device);
13948 char device[] = "/dev/sda2";
13950 suppress_error = 0;
13951 r = guestfs_pvcreate (g, device);
13956 char device[] = "/dev/sda3";
13958 suppress_error = 0;
13959 r = guestfs_pvcreate (g, device);
13964 char volgroup[] = "VG1";
13965 char physvols_0[] = "/dev/sda1";
13966 char physvols_1[] = "/dev/sda2";
13967 char *physvols[] = {
13973 suppress_error = 0;
13974 r = guestfs_vgcreate (g, volgroup, physvols);
13979 char volgroup[] = "VG2";
13980 char physvols_0[] = "/dev/sda3";
13981 char *physvols[] = {
13986 suppress_error = 0;
13987 r = guestfs_vgcreate (g, volgroup, physvols);
13992 char logvol[] = "LV1";
13993 char volgroup[] = "VG1";
13995 suppress_error = 0;
13996 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14001 char logvol[] = "LV2";
14002 char volgroup[] = "VG1";
14004 suppress_error = 0;
14005 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14010 char logvol[] = "LV3";
14011 char volgroup[] = "VG2";
14013 suppress_error = 0;
14014 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14019 char logvol[] = "LV4";
14020 char volgroup[] = "VG2";
14022 suppress_error = 0;
14023 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14028 char logvol[] = "LV5";
14029 char volgroup[] = "VG2";
14031 suppress_error = 0;
14032 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14039 suppress_error = 0;
14040 r = guestfs_lvs (g);
14044 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14049 char expected[] = "/dev/VG1/LV1";
14050 if (strcmp (r[0], expected) != 0) {
14051 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14056 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14061 char expected[] = "/dev/VG1/LV2";
14062 if (strcmp (r[1], expected) != 0) {
14063 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14068 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14073 char expected[] = "/dev/VG2/LV3";
14074 if (strcmp (r[2], expected) != 0) {
14075 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14080 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14085 char expected[] = "/dev/VG2/LV4";
14086 if (strcmp (r[3], expected) != 0) {
14087 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14092 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14097 char expected[] = "/dev/VG2/LV5";
14098 if (strcmp (r[4], expected) != 0) {
14099 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14103 if (r[5] != NULL) {
14104 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14108 for (i = 0; r[i] != NULL; ++i)
14115 static int test_vgcreate_0_skip (void)
14119 str = getenv ("TEST_ONLY");
14121 return strstr (str, "vgcreate") == NULL;
14122 str = getenv ("SKIP_TEST_VGCREATE_0");
14123 if (str && strcmp (str, "1") == 0) return 1;
14124 str = getenv ("SKIP_TEST_VGCREATE");
14125 if (str && strcmp (str, "1") == 0) return 1;
14129 static int test_vgcreate_0 (void)
14131 if (test_vgcreate_0_skip ()) {
14132 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14136 /* InitNone|InitEmpty for test_vgcreate_0 */
14138 char device[] = "/dev/sda";
14140 suppress_error = 0;
14141 r = guestfs_blockdev_setrw (g, device);
14147 suppress_error = 0;
14148 r = guestfs_umount_all (g);
14154 suppress_error = 0;
14155 r = guestfs_lvm_remove_all (g);
14159 /* TestOutputList for vgcreate (0) */
14161 char device[] = "/dev/sda";
14162 char lines_0[] = ",10";
14163 char lines_1[] = ",20";
14164 char lines_2[] = ",";
14172 suppress_error = 0;
14173 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14178 char device[] = "/dev/sda1";
14180 suppress_error = 0;
14181 r = guestfs_pvcreate (g, device);
14186 char device[] = "/dev/sda2";
14188 suppress_error = 0;
14189 r = guestfs_pvcreate (g, device);
14194 char device[] = "/dev/sda3";
14196 suppress_error = 0;
14197 r = guestfs_pvcreate (g, device);
14202 char volgroup[] = "VG1";
14203 char physvols_0[] = "/dev/sda1";
14204 char physvols_1[] = "/dev/sda2";
14205 char *physvols[] = {
14211 suppress_error = 0;
14212 r = guestfs_vgcreate (g, volgroup, physvols);
14217 char volgroup[] = "VG2";
14218 char physvols_0[] = "/dev/sda3";
14219 char *physvols[] = {
14224 suppress_error = 0;
14225 r = guestfs_vgcreate (g, volgroup, physvols);
14232 suppress_error = 0;
14233 r = guestfs_vgs (g);
14237 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14242 char expected[] = "VG1";
14243 if (strcmp (r[0], expected) != 0) {
14244 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14249 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14254 char expected[] = "VG2";
14255 if (strcmp (r[1], expected) != 0) {
14256 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14260 if (r[2] != NULL) {
14261 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14265 for (i = 0; r[i] != NULL; ++i)
14272 static int test_pvcreate_0_skip (void)
14276 str = getenv ("TEST_ONLY");
14278 return strstr (str, "pvcreate") == NULL;
14279 str = getenv ("SKIP_TEST_PVCREATE_0");
14280 if (str && strcmp (str, "1") == 0) return 1;
14281 str = getenv ("SKIP_TEST_PVCREATE");
14282 if (str && strcmp (str, "1") == 0) return 1;
14286 static int test_pvcreate_0 (void)
14288 if (test_pvcreate_0_skip ()) {
14289 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14293 /* InitNone|InitEmpty for test_pvcreate_0 */
14295 char device[] = "/dev/sda";
14297 suppress_error = 0;
14298 r = guestfs_blockdev_setrw (g, device);
14304 suppress_error = 0;
14305 r = guestfs_umount_all (g);
14311 suppress_error = 0;
14312 r = guestfs_lvm_remove_all (g);
14316 /* TestOutputListOfDevices for pvcreate (0) */
14318 char device[] = "/dev/sda";
14319 char lines_0[] = ",10";
14320 char lines_1[] = ",20";
14321 char lines_2[] = ",";
14329 suppress_error = 0;
14330 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14335 char device[] = "/dev/sda1";
14337 suppress_error = 0;
14338 r = guestfs_pvcreate (g, device);
14343 char device[] = "/dev/sda2";
14345 suppress_error = 0;
14346 r = guestfs_pvcreate (g, device);
14351 char device[] = "/dev/sda3";
14353 suppress_error = 0;
14354 r = guestfs_pvcreate (g, device);
14361 suppress_error = 0;
14362 r = guestfs_pvs (g);
14366 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14371 char expected[] = "/dev/sda1";
14373 if (strcmp (r[0], expected) != 0) {
14374 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14379 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14384 char expected[] = "/dev/sda2";
14386 if (strcmp (r[1], expected) != 0) {
14387 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14392 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14397 char expected[] = "/dev/sda3";
14399 if (strcmp (r[2], expected) != 0) {
14400 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14404 if (r[3] != NULL) {
14405 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14409 for (i = 0; r[i] != NULL; ++i)
14416 static int test_is_dir_0_skip (void)
14420 str = getenv ("TEST_ONLY");
14422 return strstr (str, "is_dir") == NULL;
14423 str = getenv ("SKIP_TEST_IS_DIR_0");
14424 if (str && strcmp (str, "1") == 0) return 1;
14425 str = getenv ("SKIP_TEST_IS_DIR");
14426 if (str && strcmp (str, "1") == 0) return 1;
14430 static int test_is_dir_0 (void)
14432 if (test_is_dir_0_skip ()) {
14433 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14437 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14439 char device[] = "/dev/sda";
14441 suppress_error = 0;
14442 r = guestfs_blockdev_setrw (g, device);
14448 suppress_error = 0;
14449 r = guestfs_umount_all (g);
14455 suppress_error = 0;
14456 r = guestfs_lvm_remove_all (g);
14461 char device[] = "/dev/sda";
14462 char lines_0[] = ",";
14468 suppress_error = 0;
14469 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14474 char fstype[] = "ext2";
14475 char device[] = "/dev/sda1";
14477 suppress_error = 0;
14478 r = guestfs_mkfs (g, fstype, device);
14483 char device[] = "/dev/sda1";
14484 char mountpoint[] = "/";
14486 suppress_error = 0;
14487 r = guestfs_mount (g, device, mountpoint);
14491 /* TestOutputFalse for is_dir (0) */
14493 char path[] = "/new";
14495 suppress_error = 0;
14496 r = guestfs_touch (g, path);
14501 char path[] = "/new";
14503 suppress_error = 0;
14504 r = guestfs_is_dir (g, path);
14508 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14515 static int test_is_dir_1_skip (void)
14519 str = getenv ("TEST_ONLY");
14521 return strstr (str, "is_dir") == NULL;
14522 str = getenv ("SKIP_TEST_IS_DIR_1");
14523 if (str && strcmp (str, "1") == 0) return 1;
14524 str = getenv ("SKIP_TEST_IS_DIR");
14525 if (str && strcmp (str, "1") == 0) return 1;
14529 static int test_is_dir_1 (void)
14531 if (test_is_dir_1_skip ()) {
14532 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14536 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
14538 char device[] = "/dev/sda";
14540 suppress_error = 0;
14541 r = guestfs_blockdev_setrw (g, device);
14547 suppress_error = 0;
14548 r = guestfs_umount_all (g);
14554 suppress_error = 0;
14555 r = guestfs_lvm_remove_all (g);
14560 char device[] = "/dev/sda";
14561 char lines_0[] = ",";
14567 suppress_error = 0;
14568 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14573 char fstype[] = "ext2";
14574 char device[] = "/dev/sda1";
14576 suppress_error = 0;
14577 r = guestfs_mkfs (g, fstype, device);
14582 char device[] = "/dev/sda1";
14583 char mountpoint[] = "/";
14585 suppress_error = 0;
14586 r = guestfs_mount (g, device, mountpoint);
14590 /* TestOutputTrue for is_dir (1) */
14592 char path[] = "/new";
14594 suppress_error = 0;
14595 r = guestfs_mkdir (g, path);
14600 char path[] = "/new";
14602 suppress_error = 0;
14603 r = guestfs_is_dir (g, path);
14607 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14614 static int test_is_file_0_skip (void)
14618 str = getenv ("TEST_ONLY");
14620 return strstr (str, "is_file") == NULL;
14621 str = getenv ("SKIP_TEST_IS_FILE_0");
14622 if (str && strcmp (str, "1") == 0) return 1;
14623 str = getenv ("SKIP_TEST_IS_FILE");
14624 if (str && strcmp (str, "1") == 0) return 1;
14628 static int test_is_file_0 (void)
14630 if (test_is_file_0_skip ()) {
14631 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14635 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
14637 char device[] = "/dev/sda";
14639 suppress_error = 0;
14640 r = guestfs_blockdev_setrw (g, device);
14646 suppress_error = 0;
14647 r = guestfs_umount_all (g);
14653 suppress_error = 0;
14654 r = guestfs_lvm_remove_all (g);
14659 char device[] = "/dev/sda";
14660 char lines_0[] = ",";
14666 suppress_error = 0;
14667 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14672 char fstype[] = "ext2";
14673 char device[] = "/dev/sda1";
14675 suppress_error = 0;
14676 r = guestfs_mkfs (g, fstype, device);
14681 char device[] = "/dev/sda1";
14682 char mountpoint[] = "/";
14684 suppress_error = 0;
14685 r = guestfs_mount (g, device, mountpoint);
14689 /* TestOutputTrue for is_file (0) */
14691 char path[] = "/new";
14693 suppress_error = 0;
14694 r = guestfs_touch (g, path);
14699 char path[] = "/new";
14701 suppress_error = 0;
14702 r = guestfs_is_file (g, path);
14706 fprintf (stderr, "test_is_file_0: expected true, got false\n");
14713 static int test_is_file_1_skip (void)
14717 str = getenv ("TEST_ONLY");
14719 return strstr (str, "is_file") == NULL;
14720 str = getenv ("SKIP_TEST_IS_FILE_1");
14721 if (str && strcmp (str, "1") == 0) return 1;
14722 str = getenv ("SKIP_TEST_IS_FILE");
14723 if (str && strcmp (str, "1") == 0) return 1;
14727 static int test_is_file_1 (void)
14729 if (test_is_file_1_skip ()) {
14730 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14734 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
14736 char device[] = "/dev/sda";
14738 suppress_error = 0;
14739 r = guestfs_blockdev_setrw (g, device);
14745 suppress_error = 0;
14746 r = guestfs_umount_all (g);
14752 suppress_error = 0;
14753 r = guestfs_lvm_remove_all (g);
14758 char device[] = "/dev/sda";
14759 char lines_0[] = ",";
14765 suppress_error = 0;
14766 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14771 char fstype[] = "ext2";
14772 char device[] = "/dev/sda1";
14774 suppress_error = 0;
14775 r = guestfs_mkfs (g, fstype, device);
14780 char device[] = "/dev/sda1";
14781 char mountpoint[] = "/";
14783 suppress_error = 0;
14784 r = guestfs_mount (g, device, mountpoint);
14788 /* TestOutputFalse for is_file (1) */
14790 char path[] = "/new";
14792 suppress_error = 0;
14793 r = guestfs_mkdir (g, path);
14798 char path[] = "/new";
14800 suppress_error = 0;
14801 r = guestfs_is_file (g, path);
14805 fprintf (stderr, "test_is_file_1: expected false, got true\n");
14812 static int test_exists_0_skip (void)
14816 str = getenv ("TEST_ONLY");
14818 return strstr (str, "exists") == NULL;
14819 str = getenv ("SKIP_TEST_EXISTS_0");
14820 if (str && strcmp (str, "1") == 0) return 1;
14821 str = getenv ("SKIP_TEST_EXISTS");
14822 if (str && strcmp (str, "1") == 0) return 1;
14826 static int test_exists_0 (void)
14828 if (test_exists_0_skip ()) {
14829 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
14833 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
14835 char device[] = "/dev/sda";
14837 suppress_error = 0;
14838 r = guestfs_blockdev_setrw (g, device);
14844 suppress_error = 0;
14845 r = guestfs_umount_all (g);
14851 suppress_error = 0;
14852 r = guestfs_lvm_remove_all (g);
14857 char device[] = "/dev/sda";
14858 char lines_0[] = ",";
14864 suppress_error = 0;
14865 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14870 char fstype[] = "ext2";
14871 char device[] = "/dev/sda1";
14873 suppress_error = 0;
14874 r = guestfs_mkfs (g, fstype, device);
14879 char device[] = "/dev/sda1";
14880 char mountpoint[] = "/";
14882 suppress_error = 0;
14883 r = guestfs_mount (g, device, mountpoint);
14887 /* TestOutputTrue for exists (0) */
14889 char path[] = "/new";
14891 suppress_error = 0;
14892 r = guestfs_touch (g, path);
14897 char path[] = "/new";
14899 suppress_error = 0;
14900 r = guestfs_exists (g, path);
14904 fprintf (stderr, "test_exists_0: expected true, got false\n");
14911 static int test_exists_1_skip (void)
14915 str = getenv ("TEST_ONLY");
14917 return strstr (str, "exists") == NULL;
14918 str = getenv ("SKIP_TEST_EXISTS_1");
14919 if (str && strcmp (str, "1") == 0) return 1;
14920 str = getenv ("SKIP_TEST_EXISTS");
14921 if (str && strcmp (str, "1") == 0) return 1;
14925 static int test_exists_1 (void)
14927 if (test_exists_1_skip ()) {
14928 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
14932 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
14934 char device[] = "/dev/sda";
14936 suppress_error = 0;
14937 r = guestfs_blockdev_setrw (g, device);
14943 suppress_error = 0;
14944 r = guestfs_umount_all (g);
14950 suppress_error = 0;
14951 r = guestfs_lvm_remove_all (g);
14956 char device[] = "/dev/sda";
14957 char lines_0[] = ",";
14963 suppress_error = 0;
14964 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14969 char fstype[] = "ext2";
14970 char device[] = "/dev/sda1";
14972 suppress_error = 0;
14973 r = guestfs_mkfs (g, fstype, device);
14978 char device[] = "/dev/sda1";
14979 char mountpoint[] = "/";
14981 suppress_error = 0;
14982 r = guestfs_mount (g, device, mountpoint);
14986 /* TestOutputTrue for exists (1) */
14988 char path[] = "/new";
14990 suppress_error = 0;
14991 r = guestfs_mkdir (g, path);
14996 char path[] = "/new";
14998 suppress_error = 0;
14999 r = guestfs_exists (g, path);
15003 fprintf (stderr, "test_exists_1: expected true, got false\n");
15010 static int test_mkdir_p_0_skip (void)
15014 str = getenv ("TEST_ONLY");
15016 return strstr (str, "mkdir_p") == NULL;
15017 str = getenv ("SKIP_TEST_MKDIR_P_0");
15018 if (str && strcmp (str, "1") == 0) return 1;
15019 str = getenv ("SKIP_TEST_MKDIR_P");
15020 if (str && strcmp (str, "1") == 0) return 1;
15024 static int test_mkdir_p_0 (void)
15026 if (test_mkdir_p_0_skip ()) {
15027 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15031 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15033 char device[] = "/dev/sda";
15035 suppress_error = 0;
15036 r = guestfs_blockdev_setrw (g, device);
15042 suppress_error = 0;
15043 r = guestfs_umount_all (g);
15049 suppress_error = 0;
15050 r = guestfs_lvm_remove_all (g);
15055 char device[] = "/dev/sda";
15056 char lines_0[] = ",";
15062 suppress_error = 0;
15063 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15068 char fstype[] = "ext2";
15069 char device[] = "/dev/sda1";
15071 suppress_error = 0;
15072 r = guestfs_mkfs (g, fstype, device);
15077 char device[] = "/dev/sda1";
15078 char mountpoint[] = "/";
15080 suppress_error = 0;
15081 r = guestfs_mount (g, device, mountpoint);
15085 /* TestOutputTrue for mkdir_p (0) */
15087 char path[] = "/new/foo/bar";
15089 suppress_error = 0;
15090 r = guestfs_mkdir_p (g, path);
15095 char path[] = "/new/foo/bar";
15097 suppress_error = 0;
15098 r = guestfs_is_dir (g, path);
15102 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15109 static int test_mkdir_p_1_skip (void)
15113 str = getenv ("TEST_ONLY");
15115 return strstr (str, "mkdir_p") == NULL;
15116 str = getenv ("SKIP_TEST_MKDIR_P_1");
15117 if (str && strcmp (str, "1") == 0) return 1;
15118 str = getenv ("SKIP_TEST_MKDIR_P");
15119 if (str && strcmp (str, "1") == 0) return 1;
15123 static int test_mkdir_p_1 (void)
15125 if (test_mkdir_p_1_skip ()) {
15126 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15130 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15132 char device[] = "/dev/sda";
15134 suppress_error = 0;
15135 r = guestfs_blockdev_setrw (g, device);
15141 suppress_error = 0;
15142 r = guestfs_umount_all (g);
15148 suppress_error = 0;
15149 r = guestfs_lvm_remove_all (g);
15154 char device[] = "/dev/sda";
15155 char lines_0[] = ",";
15161 suppress_error = 0;
15162 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15167 char fstype[] = "ext2";
15168 char device[] = "/dev/sda1";
15170 suppress_error = 0;
15171 r = guestfs_mkfs (g, fstype, device);
15176 char device[] = "/dev/sda1";
15177 char mountpoint[] = "/";
15179 suppress_error = 0;
15180 r = guestfs_mount (g, device, mountpoint);
15184 /* TestOutputTrue for mkdir_p (1) */
15186 char path[] = "/new/foo/bar";
15188 suppress_error = 0;
15189 r = guestfs_mkdir_p (g, path);
15194 char path[] = "/new/foo";
15196 suppress_error = 0;
15197 r = guestfs_is_dir (g, path);
15201 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15208 static int test_mkdir_p_2_skip (void)
15212 str = getenv ("TEST_ONLY");
15214 return strstr (str, "mkdir_p") == NULL;
15215 str = getenv ("SKIP_TEST_MKDIR_P_2");
15216 if (str && strcmp (str, "1") == 0) return 1;
15217 str = getenv ("SKIP_TEST_MKDIR_P");
15218 if (str && strcmp (str, "1") == 0) return 1;
15222 static int test_mkdir_p_2 (void)
15224 if (test_mkdir_p_2_skip ()) {
15225 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15229 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15231 char device[] = "/dev/sda";
15233 suppress_error = 0;
15234 r = guestfs_blockdev_setrw (g, device);
15240 suppress_error = 0;
15241 r = guestfs_umount_all (g);
15247 suppress_error = 0;
15248 r = guestfs_lvm_remove_all (g);
15253 char device[] = "/dev/sda";
15254 char lines_0[] = ",";
15260 suppress_error = 0;
15261 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15266 char fstype[] = "ext2";
15267 char device[] = "/dev/sda1";
15269 suppress_error = 0;
15270 r = guestfs_mkfs (g, fstype, device);
15275 char device[] = "/dev/sda1";
15276 char mountpoint[] = "/";
15278 suppress_error = 0;
15279 r = guestfs_mount (g, device, mountpoint);
15283 /* TestOutputTrue for mkdir_p (2) */
15285 char path[] = "/new/foo/bar";
15287 suppress_error = 0;
15288 r = guestfs_mkdir_p (g, path);
15293 char path[] = "/new";
15295 suppress_error = 0;
15296 r = guestfs_is_dir (g, path);
15300 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15307 static int test_mkdir_p_3_skip (void)
15311 str = getenv ("TEST_ONLY");
15313 return strstr (str, "mkdir_p") == NULL;
15314 str = getenv ("SKIP_TEST_MKDIR_P_3");
15315 if (str && strcmp (str, "1") == 0) return 1;
15316 str = getenv ("SKIP_TEST_MKDIR_P");
15317 if (str && strcmp (str, "1") == 0) return 1;
15321 static int test_mkdir_p_3 (void)
15323 if (test_mkdir_p_3_skip ()) {
15324 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15328 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15330 char device[] = "/dev/sda";
15332 suppress_error = 0;
15333 r = guestfs_blockdev_setrw (g, device);
15339 suppress_error = 0;
15340 r = guestfs_umount_all (g);
15346 suppress_error = 0;
15347 r = guestfs_lvm_remove_all (g);
15352 char device[] = "/dev/sda";
15353 char lines_0[] = ",";
15359 suppress_error = 0;
15360 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15365 char fstype[] = "ext2";
15366 char device[] = "/dev/sda1";
15368 suppress_error = 0;
15369 r = guestfs_mkfs (g, fstype, device);
15374 char device[] = "/dev/sda1";
15375 char mountpoint[] = "/";
15377 suppress_error = 0;
15378 r = guestfs_mount (g, device, mountpoint);
15382 /* TestRun for mkdir_p (3) */
15384 char path[] = "/new";
15386 suppress_error = 0;
15387 r = guestfs_mkdir (g, path);
15392 char path[] = "/new";
15394 suppress_error = 0;
15395 r = guestfs_mkdir_p (g, path);
15402 static int test_mkdir_p_4_skip (void)
15406 str = getenv ("TEST_ONLY");
15408 return strstr (str, "mkdir_p") == NULL;
15409 str = getenv ("SKIP_TEST_MKDIR_P_4");
15410 if (str && strcmp (str, "1") == 0) return 1;
15411 str = getenv ("SKIP_TEST_MKDIR_P");
15412 if (str && strcmp (str, "1") == 0) return 1;
15416 static int test_mkdir_p_4 (void)
15418 if (test_mkdir_p_4_skip ()) {
15419 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15423 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15425 char device[] = "/dev/sda";
15427 suppress_error = 0;
15428 r = guestfs_blockdev_setrw (g, device);
15434 suppress_error = 0;
15435 r = guestfs_umount_all (g);
15441 suppress_error = 0;
15442 r = guestfs_lvm_remove_all (g);
15447 char device[] = "/dev/sda";
15448 char lines_0[] = ",";
15454 suppress_error = 0;
15455 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15460 char fstype[] = "ext2";
15461 char device[] = "/dev/sda1";
15463 suppress_error = 0;
15464 r = guestfs_mkfs (g, fstype, device);
15469 char device[] = "/dev/sda1";
15470 char mountpoint[] = "/";
15472 suppress_error = 0;
15473 r = guestfs_mount (g, device, mountpoint);
15477 /* TestLastFail for mkdir_p (4) */
15479 char path[] = "/new";
15481 suppress_error = 0;
15482 r = guestfs_touch (g, path);
15487 char path[] = "/new";
15489 suppress_error = 1;
15490 r = guestfs_mkdir_p (g, path);
15497 static int test_mkdir_0_skip (void)
15501 str = getenv ("TEST_ONLY");
15503 return strstr (str, "mkdir") == NULL;
15504 str = getenv ("SKIP_TEST_MKDIR_0");
15505 if (str && strcmp (str, "1") == 0) return 1;
15506 str = getenv ("SKIP_TEST_MKDIR");
15507 if (str && strcmp (str, "1") == 0) return 1;
15511 static int test_mkdir_0 (void)
15513 if (test_mkdir_0_skip ()) {
15514 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15518 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15520 char device[] = "/dev/sda";
15522 suppress_error = 0;
15523 r = guestfs_blockdev_setrw (g, device);
15529 suppress_error = 0;
15530 r = guestfs_umount_all (g);
15536 suppress_error = 0;
15537 r = guestfs_lvm_remove_all (g);
15542 char device[] = "/dev/sda";
15543 char lines_0[] = ",";
15549 suppress_error = 0;
15550 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15555 char fstype[] = "ext2";
15556 char device[] = "/dev/sda1";
15558 suppress_error = 0;
15559 r = guestfs_mkfs (g, fstype, device);
15564 char device[] = "/dev/sda1";
15565 char mountpoint[] = "/";
15567 suppress_error = 0;
15568 r = guestfs_mount (g, device, mountpoint);
15572 /* TestOutputTrue for mkdir (0) */
15574 char path[] = "/new";
15576 suppress_error = 0;
15577 r = guestfs_mkdir (g, path);
15582 char path[] = "/new";
15584 suppress_error = 0;
15585 r = guestfs_is_dir (g, path);
15589 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15596 static int test_mkdir_1_skip (void)
15600 str = getenv ("TEST_ONLY");
15602 return strstr (str, "mkdir") == NULL;
15603 str = getenv ("SKIP_TEST_MKDIR_1");
15604 if (str && strcmp (str, "1") == 0) return 1;
15605 str = getenv ("SKIP_TEST_MKDIR");
15606 if (str && strcmp (str, "1") == 0) return 1;
15610 static int test_mkdir_1 (void)
15612 if (test_mkdir_1_skip ()) {
15613 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15617 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15619 char device[] = "/dev/sda";
15621 suppress_error = 0;
15622 r = guestfs_blockdev_setrw (g, device);
15628 suppress_error = 0;
15629 r = guestfs_umount_all (g);
15635 suppress_error = 0;
15636 r = guestfs_lvm_remove_all (g);
15641 char device[] = "/dev/sda";
15642 char lines_0[] = ",";
15648 suppress_error = 0;
15649 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15654 char fstype[] = "ext2";
15655 char device[] = "/dev/sda1";
15657 suppress_error = 0;
15658 r = guestfs_mkfs (g, fstype, device);
15663 char device[] = "/dev/sda1";
15664 char mountpoint[] = "/";
15666 suppress_error = 0;
15667 r = guestfs_mount (g, device, mountpoint);
15671 /* TestLastFail for mkdir (1) */
15673 char path[] = "/new/foo/bar";
15675 suppress_error = 1;
15676 r = guestfs_mkdir (g, path);
15683 static int test_rm_rf_0_skip (void)
15687 str = getenv ("TEST_ONLY");
15689 return strstr (str, "rm_rf") == NULL;
15690 str = getenv ("SKIP_TEST_RM_RF_0");
15691 if (str && strcmp (str, "1") == 0) return 1;
15692 str = getenv ("SKIP_TEST_RM_RF");
15693 if (str && strcmp (str, "1") == 0) return 1;
15697 static int test_rm_rf_0 (void)
15699 if (test_rm_rf_0_skip ()) {
15700 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15704 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15706 char device[] = "/dev/sda";
15708 suppress_error = 0;
15709 r = guestfs_blockdev_setrw (g, device);
15715 suppress_error = 0;
15716 r = guestfs_umount_all (g);
15722 suppress_error = 0;
15723 r = guestfs_lvm_remove_all (g);
15728 char device[] = "/dev/sda";
15729 char lines_0[] = ",";
15735 suppress_error = 0;
15736 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15741 char fstype[] = "ext2";
15742 char device[] = "/dev/sda1";
15744 suppress_error = 0;
15745 r = guestfs_mkfs (g, fstype, device);
15750 char device[] = "/dev/sda1";
15751 char mountpoint[] = "/";
15753 suppress_error = 0;
15754 r = guestfs_mount (g, device, mountpoint);
15758 /* TestOutputFalse for rm_rf (0) */
15760 char path[] = "/new";
15762 suppress_error = 0;
15763 r = guestfs_mkdir (g, path);
15768 char path[] = "/new/foo";
15770 suppress_error = 0;
15771 r = guestfs_mkdir (g, path);
15776 char path[] = "/new/foo/bar";
15778 suppress_error = 0;
15779 r = guestfs_touch (g, path);
15784 char path[] = "/new";
15786 suppress_error = 0;
15787 r = guestfs_rm_rf (g, path);
15792 char path[] = "/new";
15794 suppress_error = 0;
15795 r = guestfs_exists (g, path);
15799 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
15806 static int test_rmdir_0_skip (void)
15810 str = getenv ("TEST_ONLY");
15812 return strstr (str, "rmdir") == NULL;
15813 str = getenv ("SKIP_TEST_RMDIR_0");
15814 if (str && strcmp (str, "1") == 0) return 1;
15815 str = getenv ("SKIP_TEST_RMDIR");
15816 if (str && strcmp (str, "1") == 0) return 1;
15820 static int test_rmdir_0 (void)
15822 if (test_rmdir_0_skip ()) {
15823 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
15827 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
15829 char device[] = "/dev/sda";
15831 suppress_error = 0;
15832 r = guestfs_blockdev_setrw (g, device);
15838 suppress_error = 0;
15839 r = guestfs_umount_all (g);
15845 suppress_error = 0;
15846 r = guestfs_lvm_remove_all (g);
15851 char device[] = "/dev/sda";
15852 char lines_0[] = ",";
15858 suppress_error = 0;
15859 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15864 char fstype[] = "ext2";
15865 char device[] = "/dev/sda1";
15867 suppress_error = 0;
15868 r = guestfs_mkfs (g, fstype, device);
15873 char device[] = "/dev/sda1";
15874 char mountpoint[] = "/";
15876 suppress_error = 0;
15877 r = guestfs_mount (g, device, mountpoint);
15881 /* TestRun for rmdir (0) */
15883 char path[] = "/new";
15885 suppress_error = 0;
15886 r = guestfs_mkdir (g, path);
15891 char path[] = "/new";
15893 suppress_error = 0;
15894 r = guestfs_rmdir (g, path);
15901 static int test_rmdir_1_skip (void)
15905 str = getenv ("TEST_ONLY");
15907 return strstr (str, "rmdir") == NULL;
15908 str = getenv ("SKIP_TEST_RMDIR_1");
15909 if (str && strcmp (str, "1") == 0) return 1;
15910 str = getenv ("SKIP_TEST_RMDIR");
15911 if (str && strcmp (str, "1") == 0) return 1;
15915 static int test_rmdir_1 (void)
15917 if (test_rmdir_1_skip ()) {
15918 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
15922 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
15924 char device[] = "/dev/sda";
15926 suppress_error = 0;
15927 r = guestfs_blockdev_setrw (g, device);
15933 suppress_error = 0;
15934 r = guestfs_umount_all (g);
15940 suppress_error = 0;
15941 r = guestfs_lvm_remove_all (g);
15946 char device[] = "/dev/sda";
15947 char lines_0[] = ",";
15953 suppress_error = 0;
15954 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15959 char fstype[] = "ext2";
15960 char device[] = "/dev/sda1";
15962 suppress_error = 0;
15963 r = guestfs_mkfs (g, fstype, device);
15968 char device[] = "/dev/sda1";
15969 char mountpoint[] = "/";
15971 suppress_error = 0;
15972 r = guestfs_mount (g, device, mountpoint);
15976 /* TestLastFail for rmdir (1) */
15978 char path[] = "/new";
15980 suppress_error = 1;
15981 r = guestfs_rmdir (g, path);
15988 static int test_rmdir_2_skip (void)
15992 str = getenv ("TEST_ONLY");
15994 return strstr (str, "rmdir") == NULL;
15995 str = getenv ("SKIP_TEST_RMDIR_2");
15996 if (str && strcmp (str, "1") == 0) return 1;
15997 str = getenv ("SKIP_TEST_RMDIR");
15998 if (str && strcmp (str, "1") == 0) return 1;
16002 static int test_rmdir_2 (void)
16004 if (test_rmdir_2_skip ()) {
16005 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16009 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16011 char device[] = "/dev/sda";
16013 suppress_error = 0;
16014 r = guestfs_blockdev_setrw (g, device);
16020 suppress_error = 0;
16021 r = guestfs_umount_all (g);
16027 suppress_error = 0;
16028 r = guestfs_lvm_remove_all (g);
16033 char device[] = "/dev/sda";
16034 char lines_0[] = ",";
16040 suppress_error = 0;
16041 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16046 char fstype[] = "ext2";
16047 char device[] = "/dev/sda1";
16049 suppress_error = 0;
16050 r = guestfs_mkfs (g, fstype, device);
16055 char device[] = "/dev/sda1";
16056 char mountpoint[] = "/";
16058 suppress_error = 0;
16059 r = guestfs_mount (g, device, mountpoint);
16063 /* TestLastFail for rmdir (2) */
16065 char path[] = "/new";
16067 suppress_error = 0;
16068 r = guestfs_touch (g, path);
16073 char path[] = "/new";
16075 suppress_error = 1;
16076 r = guestfs_rmdir (g, path);
16083 static int test_rm_0_skip (void)
16087 str = getenv ("TEST_ONLY");
16089 return strstr (str, "rm") == NULL;
16090 str = getenv ("SKIP_TEST_RM_0");
16091 if (str && strcmp (str, "1") == 0) return 1;
16092 str = getenv ("SKIP_TEST_RM");
16093 if (str && strcmp (str, "1") == 0) return 1;
16097 static int test_rm_0 (void)
16099 if (test_rm_0_skip ()) {
16100 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16104 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16106 char device[] = "/dev/sda";
16108 suppress_error = 0;
16109 r = guestfs_blockdev_setrw (g, device);
16115 suppress_error = 0;
16116 r = guestfs_umount_all (g);
16122 suppress_error = 0;
16123 r = guestfs_lvm_remove_all (g);
16128 char device[] = "/dev/sda";
16129 char lines_0[] = ",";
16135 suppress_error = 0;
16136 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16141 char fstype[] = "ext2";
16142 char device[] = "/dev/sda1";
16144 suppress_error = 0;
16145 r = guestfs_mkfs (g, fstype, device);
16150 char device[] = "/dev/sda1";
16151 char mountpoint[] = "/";
16153 suppress_error = 0;
16154 r = guestfs_mount (g, device, mountpoint);
16158 /* TestRun for rm (0) */
16160 char path[] = "/new";
16162 suppress_error = 0;
16163 r = guestfs_touch (g, path);
16168 char path[] = "/new";
16170 suppress_error = 0;
16171 r = guestfs_rm (g, path);
16178 static int test_rm_1_skip (void)
16182 str = getenv ("TEST_ONLY");
16184 return strstr (str, "rm") == NULL;
16185 str = getenv ("SKIP_TEST_RM_1");
16186 if (str && strcmp (str, "1") == 0) return 1;
16187 str = getenv ("SKIP_TEST_RM");
16188 if (str && strcmp (str, "1") == 0) return 1;
16192 static int test_rm_1 (void)
16194 if (test_rm_1_skip ()) {
16195 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16199 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16201 char device[] = "/dev/sda";
16203 suppress_error = 0;
16204 r = guestfs_blockdev_setrw (g, device);
16210 suppress_error = 0;
16211 r = guestfs_umount_all (g);
16217 suppress_error = 0;
16218 r = guestfs_lvm_remove_all (g);
16223 char device[] = "/dev/sda";
16224 char lines_0[] = ",";
16230 suppress_error = 0;
16231 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16236 char fstype[] = "ext2";
16237 char device[] = "/dev/sda1";
16239 suppress_error = 0;
16240 r = guestfs_mkfs (g, fstype, device);
16245 char device[] = "/dev/sda1";
16246 char mountpoint[] = "/";
16248 suppress_error = 0;
16249 r = guestfs_mount (g, device, mountpoint);
16253 /* TestLastFail for rm (1) */
16255 char path[] = "/new";
16257 suppress_error = 1;
16258 r = guestfs_rm (g, path);
16265 static int test_rm_2_skip (void)
16269 str = getenv ("TEST_ONLY");
16271 return strstr (str, "rm") == NULL;
16272 str = getenv ("SKIP_TEST_RM_2");
16273 if (str && strcmp (str, "1") == 0) return 1;
16274 str = getenv ("SKIP_TEST_RM");
16275 if (str && strcmp (str, "1") == 0) return 1;
16279 static int test_rm_2 (void)
16281 if (test_rm_2_skip ()) {
16282 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16286 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16288 char device[] = "/dev/sda";
16290 suppress_error = 0;
16291 r = guestfs_blockdev_setrw (g, device);
16297 suppress_error = 0;
16298 r = guestfs_umount_all (g);
16304 suppress_error = 0;
16305 r = guestfs_lvm_remove_all (g);
16310 char device[] = "/dev/sda";
16311 char lines_0[] = ",";
16317 suppress_error = 0;
16318 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16323 char fstype[] = "ext2";
16324 char device[] = "/dev/sda1";
16326 suppress_error = 0;
16327 r = guestfs_mkfs (g, fstype, device);
16332 char device[] = "/dev/sda1";
16333 char mountpoint[] = "/";
16335 suppress_error = 0;
16336 r = guestfs_mount (g, device, mountpoint);
16340 /* TestLastFail for rm (2) */
16342 char path[] = "/new";
16344 suppress_error = 0;
16345 r = guestfs_mkdir (g, path);
16350 char path[] = "/new";
16352 suppress_error = 1;
16353 r = guestfs_rm (g, path);
16360 static int test_read_lines_0_skip (void)
16364 str = getenv ("TEST_ONLY");
16366 return strstr (str, "read_lines") == NULL;
16367 str = getenv ("SKIP_TEST_READ_LINES_0");
16368 if (str && strcmp (str, "1") == 0) return 1;
16369 str = getenv ("SKIP_TEST_READ_LINES");
16370 if (str && strcmp (str, "1") == 0) return 1;
16374 static int test_read_lines_0 (void)
16376 if (test_read_lines_0_skip ()) {
16377 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16381 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16383 char device[] = "/dev/sda";
16385 suppress_error = 0;
16386 r = guestfs_blockdev_setrw (g, device);
16392 suppress_error = 0;
16393 r = guestfs_umount_all (g);
16399 suppress_error = 0;
16400 r = guestfs_lvm_remove_all (g);
16405 char device[] = "/dev/sda";
16406 char lines_0[] = ",";
16412 suppress_error = 0;
16413 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16418 char fstype[] = "ext2";
16419 char device[] = "/dev/sda1";
16421 suppress_error = 0;
16422 r = guestfs_mkfs (g, fstype, device);
16427 char device[] = "/dev/sda1";
16428 char mountpoint[] = "/";
16430 suppress_error = 0;
16431 r = guestfs_mount (g, device, mountpoint);
16435 /* TestOutputList for read_lines (0) */
16437 char path[] = "/new";
16438 char content[] = "line1\r\nline2\nline3";
16440 suppress_error = 0;
16441 r = guestfs_write_file (g, path, content, 0);
16446 char path[] = "/new";
16449 suppress_error = 0;
16450 r = guestfs_read_lines (g, path);
16454 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16459 char expected[] = "line1";
16460 if (strcmp (r[0], expected) != 0) {
16461 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16466 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16471 char expected[] = "line2";
16472 if (strcmp (r[1], expected) != 0) {
16473 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16478 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16483 char expected[] = "line3";
16484 if (strcmp (r[2], expected) != 0) {
16485 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16489 if (r[3] != NULL) {
16490 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16494 for (i = 0; r[i] != NULL; ++i)
16501 static int test_read_lines_1_skip (void)
16505 str = getenv ("TEST_ONLY");
16507 return strstr (str, "read_lines") == NULL;
16508 str = getenv ("SKIP_TEST_READ_LINES_1");
16509 if (str && strcmp (str, "1") == 0) return 1;
16510 str = getenv ("SKIP_TEST_READ_LINES");
16511 if (str && strcmp (str, "1") == 0) return 1;
16515 static int test_read_lines_1 (void)
16517 if (test_read_lines_1_skip ()) {
16518 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16522 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16524 char device[] = "/dev/sda";
16526 suppress_error = 0;
16527 r = guestfs_blockdev_setrw (g, device);
16533 suppress_error = 0;
16534 r = guestfs_umount_all (g);
16540 suppress_error = 0;
16541 r = guestfs_lvm_remove_all (g);
16546 char device[] = "/dev/sda";
16547 char lines_0[] = ",";
16553 suppress_error = 0;
16554 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16559 char fstype[] = "ext2";
16560 char device[] = "/dev/sda1";
16562 suppress_error = 0;
16563 r = guestfs_mkfs (g, fstype, device);
16568 char device[] = "/dev/sda1";
16569 char mountpoint[] = "/";
16571 suppress_error = 0;
16572 r = guestfs_mount (g, device, mountpoint);
16576 /* TestOutputList for read_lines (1) */
16578 char path[] = "/new";
16579 char content[] = "";
16581 suppress_error = 0;
16582 r = guestfs_write_file (g, path, content, 0);
16587 char path[] = "/new";
16590 suppress_error = 0;
16591 r = guestfs_read_lines (g, path);
16594 if (r[0] != NULL) {
16595 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16599 for (i = 0; r[i] != NULL; ++i)
16606 static int test_lvs_0_skip (void)
16610 str = getenv ("TEST_ONLY");
16612 return strstr (str, "lvs") == NULL;
16613 str = getenv ("SKIP_TEST_LVS_0");
16614 if (str && strcmp (str, "1") == 0) return 1;
16615 str = getenv ("SKIP_TEST_LVS");
16616 if (str && strcmp (str, "1") == 0) return 1;
16620 static int test_lvs_0 (void)
16622 if (test_lvs_0_skip ()) {
16623 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16627 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16629 char device[] = "/dev/sda";
16631 suppress_error = 0;
16632 r = guestfs_blockdev_setrw (g, device);
16638 suppress_error = 0;
16639 r = guestfs_umount_all (g);
16645 suppress_error = 0;
16646 r = guestfs_lvm_remove_all (g);
16651 char device[] = "/dev/sda";
16652 char lines_0[] = ",";
16658 suppress_error = 0;
16659 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16664 char device[] = "/dev/sda1";
16666 suppress_error = 0;
16667 r = guestfs_pvcreate (g, device);
16672 char volgroup[] = "VG";
16673 char physvols_0[] = "/dev/sda1";
16674 char *physvols[] = {
16679 suppress_error = 0;
16680 r = guestfs_vgcreate (g, volgroup, physvols);
16685 char logvol[] = "LV";
16686 char volgroup[] = "VG";
16688 suppress_error = 0;
16689 r = guestfs_lvcreate (g, logvol, volgroup, 8);
16694 char fstype[] = "ext2";
16695 char device[] = "/dev/VG/LV";
16697 suppress_error = 0;
16698 r = guestfs_mkfs (g, fstype, device);
16703 char device[] = "/dev/VG/LV";
16704 char mountpoint[] = "/";
16706 suppress_error = 0;
16707 r = guestfs_mount (g, device, mountpoint);
16711 /* TestOutputList for lvs (0) */
16715 suppress_error = 0;
16716 r = guestfs_lvs (g);
16720 fprintf (stderr, "test_lvs_0: short list returned from command\n");
16725 char expected[] = "/dev/VG/LV";
16726 if (strcmp (r[0], expected) != 0) {
16727 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16731 if (r[1] != NULL) {
16732 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16736 for (i = 0; r[i] != NULL; ++i)
16743 static int test_lvs_1_skip (void)
16747 str = getenv ("TEST_ONLY");
16749 return strstr (str, "lvs") == NULL;
16750 str = getenv ("SKIP_TEST_LVS_1");
16751 if (str && strcmp (str, "1") == 0) return 1;
16752 str = getenv ("SKIP_TEST_LVS");
16753 if (str && strcmp (str, "1") == 0) return 1;
16757 static int test_lvs_1 (void)
16759 if (test_lvs_1_skip ()) {
16760 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
16764 /* InitNone|InitEmpty for test_lvs_1 */
16766 char device[] = "/dev/sda";
16768 suppress_error = 0;
16769 r = guestfs_blockdev_setrw (g, device);
16775 suppress_error = 0;
16776 r = guestfs_umount_all (g);
16782 suppress_error = 0;
16783 r = guestfs_lvm_remove_all (g);
16787 /* TestOutputList for lvs (1) */
16789 char device[] = "/dev/sda";
16790 char lines_0[] = ",10";
16791 char lines_1[] = ",20";
16792 char lines_2[] = ",";
16800 suppress_error = 0;
16801 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16806 char device[] = "/dev/sda1";
16808 suppress_error = 0;
16809 r = guestfs_pvcreate (g, device);
16814 char device[] = "/dev/sda2";
16816 suppress_error = 0;
16817 r = guestfs_pvcreate (g, device);
16822 char device[] = "/dev/sda3";
16824 suppress_error = 0;
16825 r = guestfs_pvcreate (g, device);
16830 char volgroup[] = "VG1";
16831 char physvols_0[] = "/dev/sda1";
16832 char physvols_1[] = "/dev/sda2";
16833 char *physvols[] = {
16839 suppress_error = 0;
16840 r = guestfs_vgcreate (g, volgroup, physvols);
16845 char volgroup[] = "VG2";
16846 char physvols_0[] = "/dev/sda3";
16847 char *physvols[] = {
16852 suppress_error = 0;
16853 r = guestfs_vgcreate (g, volgroup, physvols);
16858 char logvol[] = "LV1";
16859 char volgroup[] = "VG1";
16861 suppress_error = 0;
16862 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16867 char logvol[] = "LV2";
16868 char volgroup[] = "VG1";
16870 suppress_error = 0;
16871 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16876 char logvol[] = "LV3";
16877 char volgroup[] = "VG2";
16879 suppress_error = 0;
16880 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16887 suppress_error = 0;
16888 r = guestfs_lvs (g);
16892 fprintf (stderr, "test_lvs_1: short list returned from command\n");
16897 char expected[] = "/dev/VG1/LV1";
16898 if (strcmp (r[0], expected) != 0) {
16899 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16904 fprintf (stderr, "test_lvs_1: short list returned from command\n");
16909 char expected[] = "/dev/VG1/LV2";
16910 if (strcmp (r[1], expected) != 0) {
16911 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16916 fprintf (stderr, "test_lvs_1: short list returned from command\n");
16921 char expected[] = "/dev/VG2/LV3";
16922 if (strcmp (r[2], expected) != 0) {
16923 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16927 if (r[3] != NULL) {
16928 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
16932 for (i = 0; r[i] != NULL; ++i)
16939 static int test_vgs_0_skip (void)
16943 str = getenv ("TEST_ONLY");
16945 return strstr (str, "vgs") == NULL;
16946 str = getenv ("SKIP_TEST_VGS_0");
16947 if (str && strcmp (str, "1") == 0) return 1;
16948 str = getenv ("SKIP_TEST_VGS");
16949 if (str && strcmp (str, "1") == 0) return 1;
16953 static int test_vgs_0 (void)
16955 if (test_vgs_0_skip ()) {
16956 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
16960 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
16962 char device[] = "/dev/sda";
16964 suppress_error = 0;
16965 r = guestfs_blockdev_setrw (g, device);
16971 suppress_error = 0;
16972 r = guestfs_umount_all (g);
16978 suppress_error = 0;
16979 r = guestfs_lvm_remove_all (g);
16984 char device[] = "/dev/sda";
16985 char lines_0[] = ",";
16991 suppress_error = 0;
16992 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16997 char device[] = "/dev/sda1";
16999 suppress_error = 0;
17000 r = guestfs_pvcreate (g, device);
17005 char volgroup[] = "VG";
17006 char physvols_0[] = "/dev/sda1";
17007 char *physvols[] = {
17012 suppress_error = 0;
17013 r = guestfs_vgcreate (g, volgroup, physvols);
17018 char logvol[] = "LV";
17019 char volgroup[] = "VG";
17021 suppress_error = 0;
17022 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17027 char fstype[] = "ext2";
17028 char device[] = "/dev/VG/LV";
17030 suppress_error = 0;
17031 r = guestfs_mkfs (g, fstype, device);
17036 char device[] = "/dev/VG/LV";
17037 char mountpoint[] = "/";
17039 suppress_error = 0;
17040 r = guestfs_mount (g, device, mountpoint);
17044 /* TestOutputList for vgs (0) */
17048 suppress_error = 0;
17049 r = guestfs_vgs (g);
17053 fprintf (stderr, "test_vgs_0: short list returned from command\n");
17058 char expected[] = "VG";
17059 if (strcmp (r[0], expected) != 0) {
17060 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17064 if (r[1] != NULL) {
17065 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17069 for (i = 0; r[i] != NULL; ++i)
17076 static int test_vgs_1_skip (void)
17080 str = getenv ("TEST_ONLY");
17082 return strstr (str, "vgs") == NULL;
17083 str = getenv ("SKIP_TEST_VGS_1");
17084 if (str && strcmp (str, "1") == 0) return 1;
17085 str = getenv ("SKIP_TEST_VGS");
17086 if (str && strcmp (str, "1") == 0) return 1;
17090 static int test_vgs_1 (void)
17092 if (test_vgs_1_skip ()) {
17093 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17097 /* InitNone|InitEmpty for test_vgs_1 */
17099 char device[] = "/dev/sda";
17101 suppress_error = 0;
17102 r = guestfs_blockdev_setrw (g, device);
17108 suppress_error = 0;
17109 r = guestfs_umount_all (g);
17115 suppress_error = 0;
17116 r = guestfs_lvm_remove_all (g);
17120 /* TestOutputList for vgs (1) */
17122 char device[] = "/dev/sda";
17123 char lines_0[] = ",10";
17124 char lines_1[] = ",20";
17125 char lines_2[] = ",";
17133 suppress_error = 0;
17134 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17139 char device[] = "/dev/sda1";
17141 suppress_error = 0;
17142 r = guestfs_pvcreate (g, device);
17147 char device[] = "/dev/sda2";
17149 suppress_error = 0;
17150 r = guestfs_pvcreate (g, device);
17155 char device[] = "/dev/sda3";
17157 suppress_error = 0;
17158 r = guestfs_pvcreate (g, device);
17163 char volgroup[] = "VG1";
17164 char physvols_0[] = "/dev/sda1";
17165 char physvols_1[] = "/dev/sda2";
17166 char *physvols[] = {
17172 suppress_error = 0;
17173 r = guestfs_vgcreate (g, volgroup, physvols);
17178 char volgroup[] = "VG2";
17179 char physvols_0[] = "/dev/sda3";
17180 char *physvols[] = {
17185 suppress_error = 0;
17186 r = guestfs_vgcreate (g, volgroup, physvols);
17193 suppress_error = 0;
17194 r = guestfs_vgs (g);
17198 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17203 char expected[] = "VG1";
17204 if (strcmp (r[0], expected) != 0) {
17205 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17210 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17215 char expected[] = "VG2";
17216 if (strcmp (r[1], expected) != 0) {
17217 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17221 if (r[2] != NULL) {
17222 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17226 for (i = 0; r[i] != NULL; ++i)
17233 static int test_pvs_0_skip (void)
17237 str = getenv ("TEST_ONLY");
17239 return strstr (str, "pvs") == NULL;
17240 str = getenv ("SKIP_TEST_PVS_0");
17241 if (str && strcmp (str, "1") == 0) return 1;
17242 str = getenv ("SKIP_TEST_PVS");
17243 if (str && strcmp (str, "1") == 0) return 1;
17247 static int test_pvs_0 (void)
17249 if (test_pvs_0_skip ()) {
17250 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17254 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17256 char device[] = "/dev/sda";
17258 suppress_error = 0;
17259 r = guestfs_blockdev_setrw (g, device);
17265 suppress_error = 0;
17266 r = guestfs_umount_all (g);
17272 suppress_error = 0;
17273 r = guestfs_lvm_remove_all (g);
17278 char device[] = "/dev/sda";
17279 char lines_0[] = ",";
17285 suppress_error = 0;
17286 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17291 char device[] = "/dev/sda1";
17293 suppress_error = 0;
17294 r = guestfs_pvcreate (g, device);
17299 char volgroup[] = "VG";
17300 char physvols_0[] = "/dev/sda1";
17301 char *physvols[] = {
17306 suppress_error = 0;
17307 r = guestfs_vgcreate (g, volgroup, physvols);
17312 char logvol[] = "LV";
17313 char volgroup[] = "VG";
17315 suppress_error = 0;
17316 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17321 char fstype[] = "ext2";
17322 char device[] = "/dev/VG/LV";
17324 suppress_error = 0;
17325 r = guestfs_mkfs (g, fstype, device);
17330 char device[] = "/dev/VG/LV";
17331 char mountpoint[] = "/";
17333 suppress_error = 0;
17334 r = guestfs_mount (g, device, mountpoint);
17338 /* TestOutputListOfDevices for pvs (0) */
17342 suppress_error = 0;
17343 r = guestfs_pvs (g);
17347 fprintf (stderr, "test_pvs_0: short list returned from command\n");
17352 char expected[] = "/dev/sda1";
17354 if (strcmp (r[0], expected) != 0) {
17355 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17359 if (r[1] != NULL) {
17360 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17364 for (i = 0; r[i] != NULL; ++i)
17371 static int test_pvs_1_skip (void)
17375 str = getenv ("TEST_ONLY");
17377 return strstr (str, "pvs") == NULL;
17378 str = getenv ("SKIP_TEST_PVS_1");
17379 if (str && strcmp (str, "1") == 0) return 1;
17380 str = getenv ("SKIP_TEST_PVS");
17381 if (str && strcmp (str, "1") == 0) return 1;
17385 static int test_pvs_1 (void)
17387 if (test_pvs_1_skip ()) {
17388 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17392 /* InitNone|InitEmpty for test_pvs_1 */
17394 char device[] = "/dev/sda";
17396 suppress_error = 0;
17397 r = guestfs_blockdev_setrw (g, device);
17403 suppress_error = 0;
17404 r = guestfs_umount_all (g);
17410 suppress_error = 0;
17411 r = guestfs_lvm_remove_all (g);
17415 /* TestOutputListOfDevices for pvs (1) */
17417 char device[] = "/dev/sda";
17418 char lines_0[] = ",10";
17419 char lines_1[] = ",20";
17420 char lines_2[] = ",";
17428 suppress_error = 0;
17429 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17434 char device[] = "/dev/sda1";
17436 suppress_error = 0;
17437 r = guestfs_pvcreate (g, device);
17442 char device[] = "/dev/sda2";
17444 suppress_error = 0;
17445 r = guestfs_pvcreate (g, device);
17450 char device[] = "/dev/sda3";
17452 suppress_error = 0;
17453 r = guestfs_pvcreate (g, device);
17460 suppress_error = 0;
17461 r = guestfs_pvs (g);
17465 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17470 char expected[] = "/dev/sda1";
17472 if (strcmp (r[0], expected) != 0) {
17473 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17478 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17483 char expected[] = "/dev/sda2";
17485 if (strcmp (r[1], expected) != 0) {
17486 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17491 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17496 char expected[] = "/dev/sda3";
17498 if (strcmp (r[2], expected) != 0) {
17499 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17503 if (r[3] != NULL) {
17504 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17508 for (i = 0; r[i] != NULL; ++i)
17515 static int test_list_partitions_0_skip (void)
17519 str = getenv ("TEST_ONLY");
17521 return strstr (str, "list_partitions") == NULL;
17522 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17523 if (str && strcmp (str, "1") == 0) return 1;
17524 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17525 if (str && strcmp (str, "1") == 0) return 1;
17529 static int test_list_partitions_0 (void)
17531 if (test_list_partitions_0_skip ()) {
17532 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17536 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17538 char device[] = "/dev/sda";
17540 suppress_error = 0;
17541 r = guestfs_blockdev_setrw (g, device);
17547 suppress_error = 0;
17548 r = guestfs_umount_all (g);
17554 suppress_error = 0;
17555 r = guestfs_lvm_remove_all (g);
17560 char device[] = "/dev/sda";
17561 char lines_0[] = ",";
17567 suppress_error = 0;
17568 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17573 char fstype[] = "ext2";
17574 char device[] = "/dev/sda1";
17576 suppress_error = 0;
17577 r = guestfs_mkfs (g, fstype, device);
17582 char device[] = "/dev/sda1";
17583 char mountpoint[] = "/";
17585 suppress_error = 0;
17586 r = guestfs_mount (g, device, mountpoint);
17590 /* TestOutputListOfDevices for list_partitions (0) */
17594 suppress_error = 0;
17595 r = guestfs_list_partitions (g);
17599 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17604 char expected[] = "/dev/sda1";
17606 if (strcmp (r[0], expected) != 0) {
17607 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17611 if (r[1] != NULL) {
17612 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17616 for (i = 0; r[i] != NULL; ++i)
17623 static int test_list_partitions_1_skip (void)
17627 str = getenv ("TEST_ONLY");
17629 return strstr (str, "list_partitions") == NULL;
17630 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17631 if (str && strcmp (str, "1") == 0) return 1;
17632 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17633 if (str && strcmp (str, "1") == 0) return 1;
17637 static int test_list_partitions_1 (void)
17639 if (test_list_partitions_1_skip ()) {
17640 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17644 /* InitNone|InitEmpty for test_list_partitions_1 */
17646 char device[] = "/dev/sda";
17648 suppress_error = 0;
17649 r = guestfs_blockdev_setrw (g, device);
17655 suppress_error = 0;
17656 r = guestfs_umount_all (g);
17662 suppress_error = 0;
17663 r = guestfs_lvm_remove_all (g);
17667 /* TestOutputListOfDevices for list_partitions (1) */
17669 char device[] = "/dev/sda";
17670 char lines_0[] = ",10";
17671 char lines_1[] = ",20";
17672 char lines_2[] = ",";
17680 suppress_error = 0;
17681 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17688 suppress_error = 0;
17689 r = guestfs_list_partitions (g);
17693 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17698 char expected[] = "/dev/sda1";
17700 if (strcmp (r[0], expected) != 0) {
17701 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17706 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17711 char expected[] = "/dev/sda2";
17713 if (strcmp (r[1], expected) != 0) {
17714 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17719 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17724 char expected[] = "/dev/sda3";
17726 if (strcmp (r[2], expected) != 0) {
17727 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17731 if (r[3] != NULL) {
17732 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17736 for (i = 0; r[i] != NULL; ++i)
17743 static int test_list_devices_0_skip (void)
17747 str = getenv ("TEST_ONLY");
17749 return strstr (str, "list_devices") == NULL;
17750 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
17751 if (str && strcmp (str, "1") == 0) return 1;
17752 str = getenv ("SKIP_TEST_LIST_DEVICES");
17753 if (str && strcmp (str, "1") == 0) return 1;
17757 static int test_list_devices_0 (void)
17759 if (test_list_devices_0_skip ()) {
17760 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
17764 /* InitNone|InitEmpty for test_list_devices_0 */
17766 char device[] = "/dev/sda";
17768 suppress_error = 0;
17769 r = guestfs_blockdev_setrw (g, device);
17775 suppress_error = 0;
17776 r = guestfs_umount_all (g);
17782 suppress_error = 0;
17783 r = guestfs_lvm_remove_all (g);
17787 /* TestOutputListOfDevices for list_devices (0) */
17791 suppress_error = 0;
17792 r = guestfs_list_devices (g);
17796 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17801 char expected[] = "/dev/sda";
17803 if (strcmp (r[0], expected) != 0) {
17804 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17809 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17814 char expected[] = "/dev/sdb";
17816 if (strcmp (r[1], expected) != 0) {
17817 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17822 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17827 char expected[] = "/dev/sdc";
17829 if (strcmp (r[2], expected) != 0) {
17830 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17835 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17840 char expected[] = "/dev/sdd";
17842 if (strcmp (r[3], expected) != 0) {
17843 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
17847 if (r[4] != NULL) {
17848 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
17852 for (i = 0; r[i] != NULL; ++i)
17859 static int test_ls_0_skip (void)
17863 str = getenv ("TEST_ONLY");
17865 return strstr (str, "ls") == NULL;
17866 str = getenv ("SKIP_TEST_LS_0");
17867 if (str && strcmp (str, "1") == 0) return 1;
17868 str = getenv ("SKIP_TEST_LS");
17869 if (str && strcmp (str, "1") == 0) return 1;
17873 static int test_ls_0 (void)
17875 if (test_ls_0_skip ()) {
17876 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
17880 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
17882 char device[] = "/dev/sda";
17884 suppress_error = 0;
17885 r = guestfs_blockdev_setrw (g, device);
17891 suppress_error = 0;
17892 r = guestfs_umount_all (g);
17898 suppress_error = 0;
17899 r = guestfs_lvm_remove_all (g);
17904 char device[] = "/dev/sda";
17905 char lines_0[] = ",";
17911 suppress_error = 0;
17912 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17917 char fstype[] = "ext2";
17918 char device[] = "/dev/sda1";
17920 suppress_error = 0;
17921 r = guestfs_mkfs (g, fstype, device);
17926 char device[] = "/dev/sda1";
17927 char mountpoint[] = "/";
17929 suppress_error = 0;
17930 r = guestfs_mount (g, device, mountpoint);
17934 /* TestOutputList for ls (0) */
17936 char path[] = "/new";
17938 suppress_error = 0;
17939 r = guestfs_touch (g, path);
17944 char path[] = "/newer";
17946 suppress_error = 0;
17947 r = guestfs_touch (g, path);
17952 char path[] = "/newest";
17954 suppress_error = 0;
17955 r = guestfs_touch (g, path);
17960 char directory[] = "/";
17963 suppress_error = 0;
17964 r = guestfs_ls (g, directory);
17968 fprintf (stderr, "test_ls_0: short list returned from command\n");
17973 char expected[] = "lost+found";
17974 if (strcmp (r[0], expected) != 0) {
17975 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17980 fprintf (stderr, "test_ls_0: short list returned from command\n");
17985 char expected[] = "new";
17986 if (strcmp (r[1], expected) != 0) {
17987 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17992 fprintf (stderr, "test_ls_0: short list returned from command\n");
17997 char expected[] = "newer";
17998 if (strcmp (r[2], expected) != 0) {
17999 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18004 fprintf (stderr, "test_ls_0: short list returned from command\n");
18009 char expected[] = "newest";
18010 if (strcmp (r[3], expected) != 0) {
18011 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18015 if (r[4] != NULL) {
18016 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18020 for (i = 0; r[i] != NULL; ++i)
18027 static int test_cat_0_skip (void)
18031 str = getenv ("TEST_ONLY");
18033 return strstr (str, "cat") == NULL;
18034 str = getenv ("SKIP_TEST_CAT_0");
18035 if (str && strcmp (str, "1") == 0) return 1;
18036 str = getenv ("SKIP_TEST_CAT");
18037 if (str && strcmp (str, "1") == 0) return 1;
18041 static int test_cat_0 (void)
18043 if (test_cat_0_skip ()) {
18044 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18048 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18050 char device[] = "/dev/sda";
18052 suppress_error = 0;
18053 r = guestfs_blockdev_setrw (g, device);
18059 suppress_error = 0;
18060 r = guestfs_umount_all (g);
18066 suppress_error = 0;
18067 r = guestfs_lvm_remove_all (g);
18072 char device[] = "/dev/sda";
18073 char lines_0[] = ",";
18079 suppress_error = 0;
18080 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18085 char fstype[] = "ext2";
18086 char device[] = "/dev/sda1";
18088 suppress_error = 0;
18089 r = guestfs_mkfs (g, fstype, device);
18094 char device[] = "/dev/sda1";
18095 char mountpoint[] = "/";
18097 suppress_error = 0;
18098 r = guestfs_mount (g, device, mountpoint);
18102 /* TestOutput for cat (0) */
18103 char expected[] = "new file contents";
18105 char path[] = "/new";
18106 char content[] = "new file contents";
18108 suppress_error = 0;
18109 r = guestfs_write_file (g, path, content, 0);
18114 char path[] = "/new";
18116 suppress_error = 0;
18117 r = guestfs_cat (g, path);
18120 if (strcmp (r, expected) != 0) {
18121 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18129 static int test_touch_0_skip (void)
18133 str = getenv ("TEST_ONLY");
18135 return strstr (str, "touch") == NULL;
18136 str = getenv ("SKIP_TEST_TOUCH_0");
18137 if (str && strcmp (str, "1") == 0) return 1;
18138 str = getenv ("SKIP_TEST_TOUCH");
18139 if (str && strcmp (str, "1") == 0) return 1;
18143 static int test_touch_0 (void)
18145 if (test_touch_0_skip ()) {
18146 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18150 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18152 char device[] = "/dev/sda";
18154 suppress_error = 0;
18155 r = guestfs_blockdev_setrw (g, device);
18161 suppress_error = 0;
18162 r = guestfs_umount_all (g);
18168 suppress_error = 0;
18169 r = guestfs_lvm_remove_all (g);
18174 char device[] = "/dev/sda";
18175 char lines_0[] = ",";
18181 suppress_error = 0;
18182 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18187 char fstype[] = "ext2";
18188 char device[] = "/dev/sda1";
18190 suppress_error = 0;
18191 r = guestfs_mkfs (g, fstype, device);
18196 char device[] = "/dev/sda1";
18197 char mountpoint[] = "/";
18199 suppress_error = 0;
18200 r = guestfs_mount (g, device, mountpoint);
18204 /* TestOutputTrue for touch (0) */
18206 char path[] = "/new";
18208 suppress_error = 0;
18209 r = guestfs_touch (g, path);
18214 char path[] = "/new";
18216 suppress_error = 0;
18217 r = guestfs_exists (g, path);
18221 fprintf (stderr, "test_touch_0: expected true, got false\n");
18228 static int test_sync_0_skip (void)
18232 str = getenv ("TEST_ONLY");
18234 return strstr (str, "sync") == NULL;
18235 str = getenv ("SKIP_TEST_SYNC_0");
18236 if (str && strcmp (str, "1") == 0) return 1;
18237 str = getenv ("SKIP_TEST_SYNC");
18238 if (str && strcmp (str, "1") == 0) return 1;
18242 static int test_sync_0 (void)
18244 if (test_sync_0_skip ()) {
18245 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18249 /* InitNone|InitEmpty for test_sync_0 */
18251 char device[] = "/dev/sda";
18253 suppress_error = 0;
18254 r = guestfs_blockdev_setrw (g, device);
18260 suppress_error = 0;
18261 r = guestfs_umount_all (g);
18267 suppress_error = 0;
18268 r = guestfs_lvm_remove_all (g);
18272 /* TestRun for sync (0) */
18275 suppress_error = 0;
18276 r = guestfs_sync (g);
18283 static int test_mount_0_skip (void)
18287 str = getenv ("TEST_ONLY");
18289 return strstr (str, "mount") == NULL;
18290 str = getenv ("SKIP_TEST_MOUNT_0");
18291 if (str && strcmp (str, "1") == 0) return 1;
18292 str = getenv ("SKIP_TEST_MOUNT");
18293 if (str && strcmp (str, "1") == 0) return 1;
18297 static int test_mount_0 (void)
18299 if (test_mount_0_skip ()) {
18300 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18304 /* InitNone|InitEmpty for test_mount_0 */
18306 char device[] = "/dev/sda";
18308 suppress_error = 0;
18309 r = guestfs_blockdev_setrw (g, device);
18315 suppress_error = 0;
18316 r = guestfs_umount_all (g);
18322 suppress_error = 0;
18323 r = guestfs_lvm_remove_all (g);
18327 /* TestOutput for mount (0) */
18328 char expected[] = "new file contents";
18330 char device[] = "/dev/sda";
18331 char lines_0[] = ",";
18337 suppress_error = 0;
18338 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18343 char fstype[] = "ext2";
18344 char device[] = "/dev/sda1";
18346 suppress_error = 0;
18347 r = guestfs_mkfs (g, fstype, device);
18352 char device[] = "/dev/sda1";
18353 char mountpoint[] = "/";
18355 suppress_error = 0;
18356 r = guestfs_mount (g, device, mountpoint);
18361 char path[] = "/new";
18362 char content[] = "new file contents";
18364 suppress_error = 0;
18365 r = guestfs_write_file (g, path, content, 0);
18370 char path[] = "/new";
18372 suppress_error = 0;
18373 r = guestfs_cat (g, path);
18376 if (strcmp (r, expected) != 0) {
18377 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18385 int main (int argc, char *argv[])
18389 const char *filename;
18391 int nr_tests, test_num = 0;
18393 no_test_warnings ();
18395 g = guestfs_create ();
18397 printf ("guestfs_create FAILED\n");
18401 guestfs_set_error_handler (g, print_error, NULL);
18403 guestfs_set_path (g, "../appliance");
18405 filename = "test1.img";
18406 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18411 if (lseek (fd, 524288000, SEEK_SET) == -1) {
18417 if (write (fd, &c, 1) == -1) {
18423 if (close (fd) == -1) {
18428 if (guestfs_add_drive (g, filename) == -1) {
18429 printf ("guestfs_add_drive %s FAILED\n", filename);
18433 filename = "test2.img";
18434 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18439 if (lseek (fd, 52428800, SEEK_SET) == -1) {
18445 if (write (fd, &c, 1) == -1) {
18451 if (close (fd) == -1) {
18456 if (guestfs_add_drive (g, filename) == -1) {
18457 printf ("guestfs_add_drive %s FAILED\n", filename);
18461 filename = "test3.img";
18462 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18467 if (lseek (fd, 10485760, SEEK_SET) == -1) {
18473 if (write (fd, &c, 1) == -1) {
18479 if (close (fd) == -1) {
18484 if (guestfs_add_drive (g, filename) == -1) {
18485 printf ("guestfs_add_drive %s FAILED\n", filename);
18489 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18490 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18494 if (guestfs_launch (g) == -1) {
18495 printf ("guestfs_launch FAILED\n");
18499 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18502 if (guestfs_wait_ready (g) == -1) {
18503 printf ("guestfs_wait_ready FAILED\n");
18507 /* Cancel previous alarm. */
18513 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18514 if (test_tail_n_0 () == -1) {
18515 printf ("test_tail_n_0 FAILED\n");
18519 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18520 if (test_tail_n_1 () == -1) {
18521 printf ("test_tail_n_1 FAILED\n");
18525 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18526 if (test_tail_n_2 () == -1) {
18527 printf ("test_tail_n_2 FAILED\n");
18531 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18532 if (test_tail_0 () == -1) {
18533 printf ("test_tail_0 FAILED\n");
18537 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18538 if (test_head_n_0 () == -1) {
18539 printf ("test_head_n_0 FAILED\n");
18543 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18544 if (test_head_n_1 () == -1) {
18545 printf ("test_head_n_1 FAILED\n");
18549 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18550 if (test_head_n_2 () == -1) {
18551 printf ("test_head_n_2 FAILED\n");
18555 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18556 if (test_head_0 () == -1) {
18557 printf ("test_head_0 FAILED\n");
18561 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18562 if (test_wc_c_0 () == -1) {
18563 printf ("test_wc_c_0 FAILED\n");
18567 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18568 if (test_wc_w_0 () == -1) {
18569 printf ("test_wc_w_0 FAILED\n");
18573 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18574 if (test_wc_l_0 () == -1) {
18575 printf ("test_wc_l_0 FAILED\n");
18579 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18580 if (test_mkdtemp_0 () == -1) {
18581 printf ("test_mkdtemp_0 FAILED\n");
18585 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18586 if (test_scrub_file_0 () == -1) {
18587 printf ("test_scrub_file_0 FAILED\n");
18591 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18592 if (test_scrub_device_0 () == -1) {
18593 printf ("test_scrub_device_0 FAILED\n");
18597 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18598 if (test_glob_expand_0 () == -1) {
18599 printf ("test_glob_expand_0 FAILED\n");
18603 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18604 if (test_glob_expand_1 () == -1) {
18605 printf ("test_glob_expand_1 FAILED\n");
18609 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18610 if (test_glob_expand_2 () == -1) {
18611 printf ("test_glob_expand_2 FAILED\n");
18615 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18616 if (test_ntfs_3g_probe_0 () == -1) {
18617 printf ("test_ntfs_3g_probe_0 FAILED\n");
18621 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18622 if (test_ntfs_3g_probe_1 () == -1) {
18623 printf ("test_ntfs_3g_probe_1 FAILED\n");
18627 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18628 if (test_sleep_0 () == -1) {
18629 printf ("test_sleep_0 FAILED\n");
18633 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18634 if (test_find_0 () == -1) {
18635 printf ("test_find_0 FAILED\n");
18639 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18640 if (test_find_1 () == -1) {
18641 printf ("test_find_1 FAILED\n");
18645 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18646 if (test_find_2 () == -1) {
18647 printf ("test_find_2 FAILED\n");
18651 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18652 if (test_lvresize_0 () == -1) {
18653 printf ("test_lvresize_0 FAILED\n");
18657 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18658 if (test_zerofree_0 () == -1) {
18659 printf ("test_zerofree_0 FAILED\n");
18663 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18664 if (test_hexdump_0 () == -1) {
18665 printf ("test_hexdump_0 FAILED\n");
18669 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18670 if (test_hexdump_1 () == -1) {
18671 printf ("test_hexdump_1 FAILED\n");
18675 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18676 if (test_strings_e_0 () == -1) {
18677 printf ("test_strings_e_0 FAILED\n");
18681 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18682 if (test_strings_e_1 () == -1) {
18683 printf ("test_strings_e_1 FAILED\n");
18687 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18688 if (test_strings_0 () == -1) {
18689 printf ("test_strings_0 FAILED\n");
18693 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18694 if (test_strings_1 () == -1) {
18695 printf ("test_strings_1 FAILED\n");
18699 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18700 if (test_equal_0 () == -1) {
18701 printf ("test_equal_0 FAILED\n");
18705 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18706 if (test_equal_1 () == -1) {
18707 printf ("test_equal_1 FAILED\n");
18711 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18712 if (test_equal_2 () == -1) {
18713 printf ("test_equal_2 FAILED\n");
18717 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18718 if (test_ping_daemon_0 () == -1) {
18719 printf ("test_ping_daemon_0 FAILED\n");
18723 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18724 if (test_dmesg_0 () == -1) {
18725 printf ("test_dmesg_0 FAILED\n");
18729 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18730 if (test_drop_caches_0 () == -1) {
18731 printf ("test_drop_caches_0 FAILED\n");
18735 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
18736 if (test_mv_0 () == -1) {
18737 printf ("test_mv_0 FAILED\n");
18741 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
18742 if (test_mv_1 () == -1) {
18743 printf ("test_mv_1 FAILED\n");
18747 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
18748 if (test_cp_a_0 () == -1) {
18749 printf ("test_cp_a_0 FAILED\n");
18753 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
18754 if (test_cp_0 () == -1) {
18755 printf ("test_cp_0 FAILED\n");
18759 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
18760 if (test_cp_1 () == -1) {
18761 printf ("test_cp_1 FAILED\n");
18765 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
18766 if (test_cp_2 () == -1) {
18767 printf ("test_cp_2 FAILED\n");
18771 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
18772 if (test_grub_install_0 () == -1) {
18773 printf ("test_grub_install_0 FAILED\n");
18777 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
18778 if (test_zero_0 () == -1) {
18779 printf ("test_zero_0 FAILED\n");
18783 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
18784 if (test_fsck_0 () == -1) {
18785 printf ("test_fsck_0 FAILED\n");
18789 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
18790 if (test_fsck_1 () == -1) {
18791 printf ("test_fsck_1 FAILED\n");
18795 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
18796 if (test_set_e2uuid_0 () == -1) {
18797 printf ("test_set_e2uuid_0 FAILED\n");
18801 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
18802 if (test_set_e2uuid_1 () == -1) {
18803 printf ("test_set_e2uuid_1 FAILED\n");
18807 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
18808 if (test_set_e2uuid_2 () == -1) {
18809 printf ("test_set_e2uuid_2 FAILED\n");
18813 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
18814 if (test_set_e2uuid_3 () == -1) {
18815 printf ("test_set_e2uuid_3 FAILED\n");
18819 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
18820 if (test_set_e2label_0 () == -1) {
18821 printf ("test_set_e2label_0 FAILED\n");
18825 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
18826 if (test_pvremove_0 () == -1) {
18827 printf ("test_pvremove_0 FAILED\n");
18831 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
18832 if (test_pvremove_1 () == -1) {
18833 printf ("test_pvremove_1 FAILED\n");
18837 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
18838 if (test_pvremove_2 () == -1) {
18839 printf ("test_pvremove_2 FAILED\n");
18843 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
18844 if (test_vgremove_0 () == -1) {
18845 printf ("test_vgremove_0 FAILED\n");
18849 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
18850 if (test_vgremove_1 () == -1) {
18851 printf ("test_vgremove_1 FAILED\n");
18855 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
18856 if (test_lvremove_0 () == -1) {
18857 printf ("test_lvremove_0 FAILED\n");
18861 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
18862 if (test_lvremove_1 () == -1) {
18863 printf ("test_lvremove_1 FAILED\n");
18867 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
18868 if (test_lvremove_2 () == -1) {
18869 printf ("test_lvremove_2 FAILED\n");
18873 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
18874 if (test_mount_ro_0 () == -1) {
18875 printf ("test_mount_ro_0 FAILED\n");
18879 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
18880 if (test_mount_ro_1 () == -1) {
18881 printf ("test_mount_ro_1 FAILED\n");
18885 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
18886 if (test_tgz_in_0 () == -1) {
18887 printf ("test_tgz_in_0 FAILED\n");
18891 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
18892 if (test_tar_in_0 () == -1) {
18893 printf ("test_tar_in_0 FAILED\n");
18897 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
18898 if (test_checksum_0 () == -1) {
18899 printf ("test_checksum_0 FAILED\n");
18903 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
18904 if (test_checksum_1 () == -1) {
18905 printf ("test_checksum_1 FAILED\n");
18909 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
18910 if (test_checksum_2 () == -1) {
18911 printf ("test_checksum_2 FAILED\n");
18915 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
18916 if (test_checksum_3 () == -1) {
18917 printf ("test_checksum_3 FAILED\n");
18921 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
18922 if (test_checksum_4 () == -1) {
18923 printf ("test_checksum_4 FAILED\n");
18927 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
18928 if (test_checksum_5 () == -1) {
18929 printf ("test_checksum_5 FAILED\n");
18933 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
18934 if (test_checksum_6 () == -1) {
18935 printf ("test_checksum_6 FAILED\n");
18939 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
18940 if (test_checksum_7 () == -1) {
18941 printf ("test_checksum_7 FAILED\n");
18945 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
18946 if (test_checksum_8 () == -1) {
18947 printf ("test_checksum_8 FAILED\n");
18951 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
18952 if (test_download_0 () == -1) {
18953 printf ("test_download_0 FAILED\n");
18957 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
18958 if (test_upload_0 () == -1) {
18959 printf ("test_upload_0 FAILED\n");
18963 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
18964 if (test_blockdev_rereadpt_0 () == -1) {
18965 printf ("test_blockdev_rereadpt_0 FAILED\n");
18969 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
18970 if (test_blockdev_flushbufs_0 () == -1) {
18971 printf ("test_blockdev_flushbufs_0 FAILED\n");
18975 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
18976 if (test_blockdev_getsize64_0 () == -1) {
18977 printf ("test_blockdev_getsize64_0 FAILED\n");
18981 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
18982 if (test_blockdev_getsz_0 () == -1) {
18983 printf ("test_blockdev_getsz_0 FAILED\n");
18987 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
18988 if (test_blockdev_getbsz_0 () == -1) {
18989 printf ("test_blockdev_getbsz_0 FAILED\n");
18993 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
18994 if (test_blockdev_getss_0 () == -1) {
18995 printf ("test_blockdev_getss_0 FAILED\n");
18999 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19000 if (test_blockdev_getro_0 () == -1) {
19001 printf ("test_blockdev_getro_0 FAILED\n");
19005 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19006 if (test_blockdev_setrw_0 () == -1) {
19007 printf ("test_blockdev_setrw_0 FAILED\n");
19011 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19012 if (test_blockdev_setro_0 () == -1) {
19013 printf ("test_blockdev_setro_0 FAILED\n");
19017 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19018 if (test_statvfs_0 () == -1) {
19019 printf ("test_statvfs_0 FAILED\n");
19023 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19024 if (test_lstat_0 () == -1) {
19025 printf ("test_lstat_0 FAILED\n");
19029 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19030 if (test_stat_0 () == -1) {
19031 printf ("test_stat_0 FAILED\n");
19035 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19036 if (test_command_lines_0 () == -1) {
19037 printf ("test_command_lines_0 FAILED\n");
19041 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19042 if (test_command_lines_1 () == -1) {
19043 printf ("test_command_lines_1 FAILED\n");
19047 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19048 if (test_command_lines_2 () == -1) {
19049 printf ("test_command_lines_2 FAILED\n");
19053 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19054 if (test_command_lines_3 () == -1) {
19055 printf ("test_command_lines_3 FAILED\n");
19059 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19060 if (test_command_lines_4 () == -1) {
19061 printf ("test_command_lines_4 FAILED\n");
19065 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19066 if (test_command_lines_5 () == -1) {
19067 printf ("test_command_lines_5 FAILED\n");
19071 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19072 if (test_command_lines_6 () == -1) {
19073 printf ("test_command_lines_6 FAILED\n");
19077 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19078 if (test_command_lines_7 () == -1) {
19079 printf ("test_command_lines_7 FAILED\n");
19083 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19084 if (test_command_lines_8 () == -1) {
19085 printf ("test_command_lines_8 FAILED\n");
19089 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19090 if (test_command_lines_9 () == -1) {
19091 printf ("test_command_lines_9 FAILED\n");
19095 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19096 if (test_command_lines_10 () == -1) {
19097 printf ("test_command_lines_10 FAILED\n");
19101 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19102 if (test_command_0 () == -1) {
19103 printf ("test_command_0 FAILED\n");
19107 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19108 if (test_command_1 () == -1) {
19109 printf ("test_command_1 FAILED\n");
19113 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19114 if (test_command_2 () == -1) {
19115 printf ("test_command_2 FAILED\n");
19119 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19120 if (test_command_3 () == -1) {
19121 printf ("test_command_3 FAILED\n");
19125 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19126 if (test_command_4 () == -1) {
19127 printf ("test_command_4 FAILED\n");
19131 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19132 if (test_command_5 () == -1) {
19133 printf ("test_command_5 FAILED\n");
19137 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19138 if (test_command_6 () == -1) {
19139 printf ("test_command_6 FAILED\n");
19143 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19144 if (test_command_7 () == -1) {
19145 printf ("test_command_7 FAILED\n");
19149 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19150 if (test_command_8 () == -1) {
19151 printf ("test_command_8 FAILED\n");
19155 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19156 if (test_command_9 () == -1) {
19157 printf ("test_command_9 FAILED\n");
19161 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19162 if (test_command_10 () == -1) {
19163 printf ("test_command_10 FAILED\n");
19167 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19168 if (test_command_11 () == -1) {
19169 printf ("test_command_11 FAILED\n");
19173 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19174 if (test_file_0 () == -1) {
19175 printf ("test_file_0 FAILED\n");
19179 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19180 if (test_file_1 () == -1) {
19181 printf ("test_file_1 FAILED\n");
19185 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19186 if (test_file_2 () == -1) {
19187 printf ("test_file_2 FAILED\n");
19191 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19192 if (test_umount_all_0 () == -1) {
19193 printf ("test_umount_all_0 FAILED\n");
19197 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19198 if (test_umount_all_1 () == -1) {
19199 printf ("test_umount_all_1 FAILED\n");
19203 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19204 if (test_mounts_0 () == -1) {
19205 printf ("test_mounts_0 FAILED\n");
19209 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19210 if (test_umount_0 () == -1) {
19211 printf ("test_umount_0 FAILED\n");
19215 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19216 if (test_umount_1 () == -1) {
19217 printf ("test_umount_1 FAILED\n");
19221 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19222 if (test_write_file_0 () == -1) {
19223 printf ("test_write_file_0 FAILED\n");
19227 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19228 if (test_write_file_1 () == -1) {
19229 printf ("test_write_file_1 FAILED\n");
19233 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19234 if (test_write_file_2 () == -1) {
19235 printf ("test_write_file_2 FAILED\n");
19239 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19240 if (test_write_file_3 () == -1) {
19241 printf ("test_write_file_3 FAILED\n");
19245 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19246 if (test_write_file_4 () == -1) {
19247 printf ("test_write_file_4 FAILED\n");
19251 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19252 if (test_write_file_5 () == -1) {
19253 printf ("test_write_file_5 FAILED\n");
19257 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19258 if (test_mkfs_0 () == -1) {
19259 printf ("test_mkfs_0 FAILED\n");
19263 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19264 if (test_lvcreate_0 () == -1) {
19265 printf ("test_lvcreate_0 FAILED\n");
19269 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19270 if (test_vgcreate_0 () == -1) {
19271 printf ("test_vgcreate_0 FAILED\n");
19275 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19276 if (test_pvcreate_0 () == -1) {
19277 printf ("test_pvcreate_0 FAILED\n");
19281 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19282 if (test_is_dir_0 () == -1) {
19283 printf ("test_is_dir_0 FAILED\n");
19287 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19288 if (test_is_dir_1 () == -1) {
19289 printf ("test_is_dir_1 FAILED\n");
19293 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19294 if (test_is_file_0 () == -1) {
19295 printf ("test_is_file_0 FAILED\n");
19299 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19300 if (test_is_file_1 () == -1) {
19301 printf ("test_is_file_1 FAILED\n");
19305 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19306 if (test_exists_0 () == -1) {
19307 printf ("test_exists_0 FAILED\n");
19311 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19312 if (test_exists_1 () == -1) {
19313 printf ("test_exists_1 FAILED\n");
19317 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19318 if (test_mkdir_p_0 () == -1) {
19319 printf ("test_mkdir_p_0 FAILED\n");
19323 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19324 if (test_mkdir_p_1 () == -1) {
19325 printf ("test_mkdir_p_1 FAILED\n");
19329 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19330 if (test_mkdir_p_2 () == -1) {
19331 printf ("test_mkdir_p_2 FAILED\n");
19335 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19336 if (test_mkdir_p_3 () == -1) {
19337 printf ("test_mkdir_p_3 FAILED\n");
19341 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19342 if (test_mkdir_p_4 () == -1) {
19343 printf ("test_mkdir_p_4 FAILED\n");
19347 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19348 if (test_mkdir_0 () == -1) {
19349 printf ("test_mkdir_0 FAILED\n");
19353 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19354 if (test_mkdir_1 () == -1) {
19355 printf ("test_mkdir_1 FAILED\n");
19359 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19360 if (test_rm_rf_0 () == -1) {
19361 printf ("test_rm_rf_0 FAILED\n");
19365 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19366 if (test_rmdir_0 () == -1) {
19367 printf ("test_rmdir_0 FAILED\n");
19371 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19372 if (test_rmdir_1 () == -1) {
19373 printf ("test_rmdir_1 FAILED\n");
19377 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19378 if (test_rmdir_2 () == -1) {
19379 printf ("test_rmdir_2 FAILED\n");
19383 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19384 if (test_rm_0 () == -1) {
19385 printf ("test_rm_0 FAILED\n");
19389 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19390 if (test_rm_1 () == -1) {
19391 printf ("test_rm_1 FAILED\n");
19395 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19396 if (test_rm_2 () == -1) {
19397 printf ("test_rm_2 FAILED\n");
19401 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19402 if (test_read_lines_0 () == -1) {
19403 printf ("test_read_lines_0 FAILED\n");
19407 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19408 if (test_read_lines_1 () == -1) {
19409 printf ("test_read_lines_1 FAILED\n");
19413 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19414 if (test_lvs_0 () == -1) {
19415 printf ("test_lvs_0 FAILED\n");
19419 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19420 if (test_lvs_1 () == -1) {
19421 printf ("test_lvs_1 FAILED\n");
19425 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19426 if (test_vgs_0 () == -1) {
19427 printf ("test_vgs_0 FAILED\n");
19431 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19432 if (test_vgs_1 () == -1) {
19433 printf ("test_vgs_1 FAILED\n");
19437 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19438 if (test_pvs_0 () == -1) {
19439 printf ("test_pvs_0 FAILED\n");
19443 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19444 if (test_pvs_1 () == -1) {
19445 printf ("test_pvs_1 FAILED\n");
19449 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19450 if (test_list_partitions_0 () == -1) {
19451 printf ("test_list_partitions_0 FAILED\n");
19455 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19456 if (test_list_partitions_1 () == -1) {
19457 printf ("test_list_partitions_1 FAILED\n");
19461 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19462 if (test_list_devices_0 () == -1) {
19463 printf ("test_list_devices_0 FAILED\n");
19467 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19468 if (test_ls_0 () == -1) {
19469 printf ("test_ls_0 FAILED\n");
19473 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19474 if (test_cat_0 () == -1) {
19475 printf ("test_cat_0 FAILED\n");
19479 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19480 if (test_touch_0 () == -1) {
19481 printf ("test_touch_0 FAILED\n");
19485 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19486 if (test_sync_0 () == -1) {
19487 printf ("test_sync_0 FAILED\n");
19491 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19492 if (test_mount_0 () == -1) {
19493 printf ("test_mount_0 FAILED\n");
19498 unlink ("test1.img");
19499 unlink ("test2.img");
19500 unlink ("test3.img");
19503 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);