1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 static void print_error (guestfs_h *g, void *data, const char *msg)
37 fprintf (stderr, "%s\n", msg);
40 static void print_strings (char * const * const argv)
44 for (argc = 0; argv[argc] != NULL; ++argc)
45 printf ("\t%s\n", argv[argc]);
49 static void print_table (char * const * const argv)
53 for (i = 0; argv[i] != NULL; i += 2)
54 printf ("%s: %s\n", argv[i], argv[i+1]);
58 static void no_test_warnings (void)
60 fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
61 fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
62 fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
63 fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
64 fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
65 fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
154 fprintf (stderr, "warning: \"guestfs_df\" has no tests\n");
155 fprintf (stderr, "warning: \"guestfs_df_h\" has no tests\n");
158 static int test_tail_n_0_skip (void)
162 str = getenv ("TEST_ONLY");
164 return strstr (str, "tail_n") == NULL;
165 str = getenv ("SKIP_TEST_TAIL_N_0");
166 if (str && strcmp (str, "1") == 0) return 1;
167 str = getenv ("SKIP_TEST_TAIL_N");
168 if (str && strcmp (str, "1") == 0) return 1;
172 static int test_tail_n_0 (void)
174 if (test_tail_n_0_skip ()) {
175 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
179 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
181 char device[] = "/dev/sda";
184 r = guestfs_blockdev_setrw (g, device);
191 r = guestfs_umount_all (g);
198 r = guestfs_lvm_remove_all (g);
203 char device[] = "/dev/sda";
204 char lines_0[] = ",";
211 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
216 char fstype[] = "ext2";
217 char device[] = "/dev/sda1";
220 r = guestfs_mkfs (g, fstype, device);
225 char device[] = "/dev/sda1";
226 char mountpoint[] = "/";
229 r = guestfs_mount (g, device, mountpoint);
233 /* TestOutputList for tail_n (0) */
235 char options[] = "ro";
236 char vfstype[] = "squashfs";
237 char device[] = "/dev/sdd";
238 char mountpoint[] = "/";
241 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
246 char path[] = "/10klines";
250 r = guestfs_tail_n (g, 3, path);
254 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
259 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
260 if (strcmp (r[0], expected) != 0) {
261 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
266 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
271 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
272 if (strcmp (r[1], expected) != 0) {
273 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
278 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
283 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
284 if (strcmp (r[2], expected) != 0) {
285 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
290 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
294 for (i = 0; r[i] != NULL; ++i)
301 static int test_tail_n_1_skip (void)
305 str = getenv ("TEST_ONLY");
307 return strstr (str, "tail_n") == NULL;
308 str = getenv ("SKIP_TEST_TAIL_N_1");
309 if (str && strcmp (str, "1") == 0) return 1;
310 str = getenv ("SKIP_TEST_TAIL_N");
311 if (str && strcmp (str, "1") == 0) return 1;
315 static int test_tail_n_1 (void)
317 if (test_tail_n_1_skip ()) {
318 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
322 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
324 char device[] = "/dev/sda";
327 r = guestfs_blockdev_setrw (g, device);
334 r = guestfs_umount_all (g);
341 r = guestfs_lvm_remove_all (g);
346 char device[] = "/dev/sda";
347 char lines_0[] = ",";
354 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
359 char fstype[] = "ext2";
360 char device[] = "/dev/sda1";
363 r = guestfs_mkfs (g, fstype, device);
368 char device[] = "/dev/sda1";
369 char mountpoint[] = "/";
372 r = guestfs_mount (g, device, mountpoint);
376 /* TestOutputList for tail_n (1) */
378 char options[] = "ro";
379 char vfstype[] = "squashfs";
380 char device[] = "/dev/sdd";
381 char mountpoint[] = "/";
384 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
389 char path[] = "/10klines";
393 r = guestfs_tail_n (g, -9998, path);
397 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
402 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
403 if (strcmp (r[0], expected) != 0) {
404 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
409 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
414 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
415 if (strcmp (r[1], expected) != 0) {
416 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
421 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
426 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
427 if (strcmp (r[2], expected) != 0) {
428 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
433 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
437 for (i = 0; r[i] != NULL; ++i)
444 static int test_tail_n_2_skip (void)
448 str = getenv ("TEST_ONLY");
450 return strstr (str, "tail_n") == NULL;
451 str = getenv ("SKIP_TEST_TAIL_N_2");
452 if (str && strcmp (str, "1") == 0) return 1;
453 str = getenv ("SKIP_TEST_TAIL_N");
454 if (str && strcmp (str, "1") == 0) return 1;
458 static int test_tail_n_2 (void)
460 if (test_tail_n_2_skip ()) {
461 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
465 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
467 char device[] = "/dev/sda";
470 r = guestfs_blockdev_setrw (g, device);
477 r = guestfs_umount_all (g);
484 r = guestfs_lvm_remove_all (g);
489 char device[] = "/dev/sda";
490 char lines_0[] = ",";
497 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
502 char fstype[] = "ext2";
503 char device[] = "/dev/sda1";
506 r = guestfs_mkfs (g, fstype, device);
511 char device[] = "/dev/sda1";
512 char mountpoint[] = "/";
515 r = guestfs_mount (g, device, mountpoint);
519 /* TestOutputList for tail_n (2) */
521 char options[] = "ro";
522 char vfstype[] = "squashfs";
523 char device[] = "/dev/sdd";
524 char mountpoint[] = "/";
527 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
532 char path[] = "/10klines";
536 r = guestfs_tail_n (g, 0, path);
540 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
544 for (i = 0; r[i] != NULL; ++i)
551 static int test_tail_0_skip (void)
555 str = getenv ("TEST_ONLY");
557 return strstr (str, "tail") == NULL;
558 str = getenv ("SKIP_TEST_TAIL_0");
559 if (str && strcmp (str, "1") == 0) return 1;
560 str = getenv ("SKIP_TEST_TAIL");
561 if (str && strcmp (str, "1") == 0) return 1;
565 static int test_tail_0 (void)
567 if (test_tail_0_skip ()) {
568 printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
572 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
574 char device[] = "/dev/sda";
577 r = guestfs_blockdev_setrw (g, device);
584 r = guestfs_umount_all (g);
591 r = guestfs_lvm_remove_all (g);
596 char device[] = "/dev/sda";
597 char lines_0[] = ",";
604 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
609 char fstype[] = "ext2";
610 char device[] = "/dev/sda1";
613 r = guestfs_mkfs (g, fstype, device);
618 char device[] = "/dev/sda1";
619 char mountpoint[] = "/";
622 r = guestfs_mount (g, device, mountpoint);
626 /* TestOutputList for tail (0) */
628 char options[] = "ro";
629 char vfstype[] = "squashfs";
630 char device[] = "/dev/sdd";
631 char mountpoint[] = "/";
634 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
639 char path[] = "/10klines";
643 r = guestfs_tail (g, path);
647 fprintf (stderr, "test_tail_0: short list returned from command\n");
652 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
653 if (strcmp (r[0], expected) != 0) {
654 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
659 fprintf (stderr, "test_tail_0: short list returned from command\n");
664 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
665 if (strcmp (r[1], expected) != 0) {
666 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
671 fprintf (stderr, "test_tail_0: short list returned from command\n");
676 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
677 if (strcmp (r[2], expected) != 0) {
678 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
683 fprintf (stderr, "test_tail_0: short list returned from command\n");
688 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
689 if (strcmp (r[3], expected) != 0) {
690 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
695 fprintf (stderr, "test_tail_0: short list returned from command\n");
700 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
701 if (strcmp (r[4], expected) != 0) {
702 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
707 fprintf (stderr, "test_tail_0: short list returned from command\n");
712 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
713 if (strcmp (r[5], expected) != 0) {
714 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
719 fprintf (stderr, "test_tail_0: short list returned from command\n");
724 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
725 if (strcmp (r[6], expected) != 0) {
726 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
731 fprintf (stderr, "test_tail_0: short list returned from command\n");
736 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
737 if (strcmp (r[7], expected) != 0) {
738 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
743 fprintf (stderr, "test_tail_0: short list returned from command\n");
748 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
749 if (strcmp (r[8], expected) != 0) {
750 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
755 fprintf (stderr, "test_tail_0: short list returned from command\n");
760 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
761 if (strcmp (r[9], expected) != 0) {
762 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
767 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
771 for (i = 0; r[i] != NULL; ++i)
778 static int test_head_n_0_skip (void)
782 str = getenv ("TEST_ONLY");
784 return strstr (str, "head_n") == NULL;
785 str = getenv ("SKIP_TEST_HEAD_N_0");
786 if (str && strcmp (str, "1") == 0) return 1;
787 str = getenv ("SKIP_TEST_HEAD_N");
788 if (str && strcmp (str, "1") == 0) return 1;
792 static int test_head_n_0 (void)
794 if (test_head_n_0_skip ()) {
795 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
799 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
801 char device[] = "/dev/sda";
804 r = guestfs_blockdev_setrw (g, device);
811 r = guestfs_umount_all (g);
818 r = guestfs_lvm_remove_all (g);
823 char device[] = "/dev/sda";
824 char lines_0[] = ",";
831 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
836 char fstype[] = "ext2";
837 char device[] = "/dev/sda1";
840 r = guestfs_mkfs (g, fstype, device);
845 char device[] = "/dev/sda1";
846 char mountpoint[] = "/";
849 r = guestfs_mount (g, device, mountpoint);
853 /* TestOutputList for head_n (0) */
855 char options[] = "ro";
856 char vfstype[] = "squashfs";
857 char device[] = "/dev/sdd";
858 char mountpoint[] = "/";
861 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
866 char path[] = "/10klines";
870 r = guestfs_head_n (g, 3, path);
874 fprintf (stderr, "test_head_n_0: short list returned from command\n");
879 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
880 if (strcmp (r[0], expected) != 0) {
881 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
886 fprintf (stderr, "test_head_n_0: short list returned from command\n");
891 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
892 if (strcmp (r[1], expected) != 0) {
893 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
898 fprintf (stderr, "test_head_n_0: short list returned from command\n");
903 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
904 if (strcmp (r[2], expected) != 0) {
905 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
910 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
914 for (i = 0; r[i] != NULL; ++i)
921 static int test_head_n_1_skip (void)
925 str = getenv ("TEST_ONLY");
927 return strstr (str, "head_n") == NULL;
928 str = getenv ("SKIP_TEST_HEAD_N_1");
929 if (str && strcmp (str, "1") == 0) return 1;
930 str = getenv ("SKIP_TEST_HEAD_N");
931 if (str && strcmp (str, "1") == 0) return 1;
935 static int test_head_n_1 (void)
937 if (test_head_n_1_skip ()) {
938 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
942 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
944 char device[] = "/dev/sda";
947 r = guestfs_blockdev_setrw (g, device);
954 r = guestfs_umount_all (g);
961 r = guestfs_lvm_remove_all (g);
966 char device[] = "/dev/sda";
967 char lines_0[] = ",";
974 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
979 char fstype[] = "ext2";
980 char device[] = "/dev/sda1";
983 r = guestfs_mkfs (g, fstype, device);
988 char device[] = "/dev/sda1";
989 char mountpoint[] = "/";
992 r = guestfs_mount (g, device, mountpoint);
996 /* TestOutputList for head_n (1) */
998 char options[] = "ro";
999 char vfstype[] = "squashfs";
1000 char device[] = "/dev/sdd";
1001 char mountpoint[] = "/";
1004 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1009 char path[] = "/10klines";
1013 r = guestfs_head_n (g, -9997, path);
1017 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1022 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1023 if (strcmp (r[0], expected) != 0) {
1024 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1029 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1034 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1035 if (strcmp (r[1], expected) != 0) {
1036 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1041 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1046 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1047 if (strcmp (r[2], expected) != 0) {
1048 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1053 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1057 for (i = 0; r[i] != NULL; ++i)
1064 static int test_head_n_2_skip (void)
1068 str = getenv ("TEST_ONLY");
1070 return strstr (str, "head_n") == NULL;
1071 str = getenv ("SKIP_TEST_HEAD_N_2");
1072 if (str && strcmp (str, "1") == 0) return 1;
1073 str = getenv ("SKIP_TEST_HEAD_N");
1074 if (str && strcmp (str, "1") == 0) return 1;
1078 static int test_head_n_2 (void)
1080 if (test_head_n_2_skip ()) {
1081 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1085 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1087 char device[] = "/dev/sda";
1090 r = guestfs_blockdev_setrw (g, device);
1097 r = guestfs_umount_all (g);
1104 r = guestfs_lvm_remove_all (g);
1109 char device[] = "/dev/sda";
1110 char lines_0[] = ",";
1117 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1122 char fstype[] = "ext2";
1123 char device[] = "/dev/sda1";
1126 r = guestfs_mkfs (g, fstype, device);
1131 char device[] = "/dev/sda1";
1132 char mountpoint[] = "/";
1135 r = guestfs_mount (g, device, mountpoint);
1139 /* TestOutputList for head_n (2) */
1141 char options[] = "ro";
1142 char vfstype[] = "squashfs";
1143 char device[] = "/dev/sdd";
1144 char mountpoint[] = "/";
1147 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1152 char path[] = "/10klines";
1156 r = guestfs_head_n (g, 0, path);
1160 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1164 for (i = 0; r[i] != NULL; ++i)
1171 static int test_head_0_skip (void)
1175 str = getenv ("TEST_ONLY");
1177 return strstr (str, "head") == NULL;
1178 str = getenv ("SKIP_TEST_HEAD_0");
1179 if (str && strcmp (str, "1") == 0) return 1;
1180 str = getenv ("SKIP_TEST_HEAD");
1181 if (str && strcmp (str, "1") == 0) return 1;
1185 static int test_head_0 (void)
1187 if (test_head_0_skip ()) {
1188 printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1192 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1194 char device[] = "/dev/sda";
1197 r = guestfs_blockdev_setrw (g, device);
1204 r = guestfs_umount_all (g);
1211 r = guestfs_lvm_remove_all (g);
1216 char device[] = "/dev/sda";
1217 char lines_0[] = ",";
1224 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1229 char fstype[] = "ext2";
1230 char device[] = "/dev/sda1";
1233 r = guestfs_mkfs (g, fstype, device);
1238 char device[] = "/dev/sda1";
1239 char mountpoint[] = "/";
1242 r = guestfs_mount (g, device, mountpoint);
1246 /* TestOutputList for head (0) */
1248 char options[] = "ro";
1249 char vfstype[] = "squashfs";
1250 char device[] = "/dev/sdd";
1251 char mountpoint[] = "/";
1254 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1259 char path[] = "/10klines";
1263 r = guestfs_head (g, path);
1267 fprintf (stderr, "test_head_0: short list returned from command\n");
1272 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1273 if (strcmp (r[0], expected) != 0) {
1274 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1279 fprintf (stderr, "test_head_0: short list returned from command\n");
1284 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1285 if (strcmp (r[1], expected) != 0) {
1286 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1291 fprintf (stderr, "test_head_0: short list returned from command\n");
1296 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1297 if (strcmp (r[2], expected) != 0) {
1298 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1303 fprintf (stderr, "test_head_0: short list returned from command\n");
1308 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1309 if (strcmp (r[3], expected) != 0) {
1310 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1315 fprintf (stderr, "test_head_0: short list returned from command\n");
1320 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1321 if (strcmp (r[4], expected) != 0) {
1322 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1327 fprintf (stderr, "test_head_0: short list returned from command\n");
1332 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1333 if (strcmp (r[5], expected) != 0) {
1334 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1339 fprintf (stderr, "test_head_0: short list returned from command\n");
1344 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1345 if (strcmp (r[6], expected) != 0) {
1346 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1351 fprintf (stderr, "test_head_0: short list returned from command\n");
1356 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1357 if (strcmp (r[7], expected) != 0) {
1358 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1363 fprintf (stderr, "test_head_0: short list returned from command\n");
1368 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1369 if (strcmp (r[8], expected) != 0) {
1370 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1375 fprintf (stderr, "test_head_0: short list returned from command\n");
1380 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1381 if (strcmp (r[9], expected) != 0) {
1382 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1386 if (r[10] != NULL) {
1387 fprintf (stderr, "test_head_0: extra elements returned from command\n");
1391 for (i = 0; r[i] != NULL; ++i)
1398 static int test_wc_c_0_skip (void)
1402 str = getenv ("TEST_ONLY");
1404 return strstr (str, "wc_c") == NULL;
1405 str = getenv ("SKIP_TEST_WC_C_0");
1406 if (str && strcmp (str, "1") == 0) return 1;
1407 str = getenv ("SKIP_TEST_WC_C");
1408 if (str && strcmp (str, "1") == 0) return 1;
1412 static int test_wc_c_0 (void)
1414 if (test_wc_c_0_skip ()) {
1415 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1419 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1421 char device[] = "/dev/sda";
1424 r = guestfs_blockdev_setrw (g, device);
1431 r = guestfs_umount_all (g);
1438 r = guestfs_lvm_remove_all (g);
1443 char device[] = "/dev/sda";
1444 char lines_0[] = ",";
1451 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1456 char fstype[] = "ext2";
1457 char device[] = "/dev/sda1";
1460 r = guestfs_mkfs (g, fstype, device);
1465 char device[] = "/dev/sda1";
1466 char mountpoint[] = "/";
1469 r = guestfs_mount (g, device, mountpoint);
1473 /* TestOutputInt for wc_c (0) */
1475 char options[] = "ro";
1476 char vfstype[] = "squashfs";
1477 char device[] = "/dev/sdd";
1478 char mountpoint[] = "/";
1481 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1486 char path[] = "/100kallspaces";
1489 r = guestfs_wc_c (g, path);
1493 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
1500 static int test_wc_w_0_skip (void)
1504 str = getenv ("TEST_ONLY");
1506 return strstr (str, "wc_w") == NULL;
1507 str = getenv ("SKIP_TEST_WC_W_0");
1508 if (str && strcmp (str, "1") == 0) return 1;
1509 str = getenv ("SKIP_TEST_WC_W");
1510 if (str && strcmp (str, "1") == 0) return 1;
1514 static int test_wc_w_0 (void)
1516 if (test_wc_w_0_skip ()) {
1517 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1521 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1523 char device[] = "/dev/sda";
1526 r = guestfs_blockdev_setrw (g, device);
1533 r = guestfs_umount_all (g);
1540 r = guestfs_lvm_remove_all (g);
1545 char device[] = "/dev/sda";
1546 char lines_0[] = ",";
1553 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1558 char fstype[] = "ext2";
1559 char device[] = "/dev/sda1";
1562 r = guestfs_mkfs (g, fstype, device);
1567 char device[] = "/dev/sda1";
1568 char mountpoint[] = "/";
1571 r = guestfs_mount (g, device, mountpoint);
1575 /* TestOutputInt for wc_w (0) */
1577 char options[] = "ro";
1578 char vfstype[] = "squashfs";
1579 char device[] = "/dev/sdd";
1580 char mountpoint[] = "/";
1583 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1588 char path[] = "/10klines";
1591 r = guestfs_wc_w (g, path);
1595 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
1602 static int test_wc_l_0_skip (void)
1606 str = getenv ("TEST_ONLY");
1608 return strstr (str, "wc_l") == NULL;
1609 str = getenv ("SKIP_TEST_WC_L_0");
1610 if (str && strcmp (str, "1") == 0) return 1;
1611 str = getenv ("SKIP_TEST_WC_L");
1612 if (str && strcmp (str, "1") == 0) return 1;
1616 static int test_wc_l_0 (void)
1618 if (test_wc_l_0_skip ()) {
1619 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1623 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1625 char device[] = "/dev/sda";
1628 r = guestfs_blockdev_setrw (g, device);
1635 r = guestfs_umount_all (g);
1642 r = guestfs_lvm_remove_all (g);
1647 char device[] = "/dev/sda";
1648 char lines_0[] = ",";
1655 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1660 char fstype[] = "ext2";
1661 char device[] = "/dev/sda1";
1664 r = guestfs_mkfs (g, fstype, device);
1669 char device[] = "/dev/sda1";
1670 char mountpoint[] = "/";
1673 r = guestfs_mount (g, device, mountpoint);
1677 /* TestOutputInt for wc_l (0) */
1679 char options[] = "ro";
1680 char vfstype[] = "squashfs";
1681 char device[] = "/dev/sdd";
1682 char mountpoint[] = "/";
1685 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1690 char path[] = "/10klines";
1693 r = guestfs_wc_l (g, path);
1697 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
1704 static int test_mkdtemp_0_skip (void)
1708 str = getenv ("TEST_ONLY");
1710 return strstr (str, "mkdtemp") == NULL;
1711 str = getenv ("SKIP_TEST_MKDTEMP_0");
1712 if (str && strcmp (str, "1") == 0) return 1;
1713 str = getenv ("SKIP_TEST_MKDTEMP");
1714 if (str && strcmp (str, "1") == 0) return 1;
1718 static int test_mkdtemp_0 (void)
1720 if (test_mkdtemp_0_skip ()) {
1721 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1725 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1727 char device[] = "/dev/sda";
1730 r = guestfs_blockdev_setrw (g, device);
1737 r = guestfs_umount_all (g);
1744 r = guestfs_lvm_remove_all (g);
1749 char device[] = "/dev/sda";
1750 char lines_0[] = ",";
1757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1762 char fstype[] = "ext2";
1763 char device[] = "/dev/sda1";
1766 r = guestfs_mkfs (g, fstype, device);
1771 char device[] = "/dev/sda1";
1772 char mountpoint[] = "/";
1775 r = guestfs_mount (g, device, mountpoint);
1779 /* TestRun for mkdtemp (0) */
1781 char path[] = "/tmp";
1784 r = guestfs_mkdir (g, path);
1789 char template[] = "/tmp/tmpXXXXXX";
1792 r = guestfs_mkdtemp (g, template);
1800 static int test_scrub_file_0_skip (void)
1804 str = getenv ("TEST_ONLY");
1806 return strstr (str, "scrub_file") == NULL;
1807 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
1808 if (str && strcmp (str, "1") == 0) return 1;
1809 str = getenv ("SKIP_TEST_SCRUB_FILE");
1810 if (str && strcmp (str, "1") == 0) return 1;
1814 static int test_scrub_file_0 (void)
1816 if (test_scrub_file_0_skip ()) {
1817 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
1821 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
1823 char device[] = "/dev/sda";
1826 r = guestfs_blockdev_setrw (g, device);
1833 r = guestfs_umount_all (g);
1840 r = guestfs_lvm_remove_all (g);
1845 char device[] = "/dev/sda";
1846 char lines_0[] = ",";
1853 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1858 char fstype[] = "ext2";
1859 char device[] = "/dev/sda1";
1862 r = guestfs_mkfs (g, fstype, device);
1867 char device[] = "/dev/sda1";
1868 char mountpoint[] = "/";
1871 r = guestfs_mount (g, device, mountpoint);
1875 /* TestRun for scrub_file (0) */
1877 char path[] = "/file";
1878 char content[] = "content";
1881 r = guestfs_write_file (g, path, content, 0);
1886 char file[] = "/file";
1889 r = guestfs_scrub_file (g, file);
1896 static int test_scrub_device_0_skip (void)
1900 str = getenv ("TEST_ONLY");
1902 return strstr (str, "scrub_device") == NULL;
1903 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
1904 if (str && strcmp (str, "1") == 0) return 1;
1905 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
1906 if (str && strcmp (str, "1") == 0) return 1;
1910 static int test_scrub_device_0 (void)
1912 if (test_scrub_device_0_skip ()) {
1913 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
1917 /* InitNone|InitEmpty for test_scrub_device_0 */
1919 char device[] = "/dev/sda";
1922 r = guestfs_blockdev_setrw (g, device);
1929 r = guestfs_umount_all (g);
1936 r = guestfs_lvm_remove_all (g);
1940 /* TestRun for scrub_device (0) */
1942 char device[] = "/dev/sdc";
1945 r = guestfs_scrub_device (g, device);
1952 static int test_glob_expand_0_skip (void)
1956 str = getenv ("TEST_ONLY");
1958 return strstr (str, "glob_expand") == NULL;
1959 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
1960 if (str && strcmp (str, "1") == 0) return 1;
1961 str = getenv ("SKIP_TEST_GLOB_EXPAND");
1962 if (str && strcmp (str, "1") == 0) return 1;
1966 static int test_glob_expand_0 (void)
1968 if (test_glob_expand_0_skip ()) {
1969 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
1973 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
1975 char device[] = "/dev/sda";
1978 r = guestfs_blockdev_setrw (g, device);
1985 r = guestfs_umount_all (g);
1992 r = guestfs_lvm_remove_all (g);
1997 char device[] = "/dev/sda";
1998 char lines_0[] = ",";
2005 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2010 char fstype[] = "ext2";
2011 char device[] = "/dev/sda1";
2014 r = guestfs_mkfs (g, fstype, device);
2019 char device[] = "/dev/sda1";
2020 char mountpoint[] = "/";
2023 r = guestfs_mount (g, device, mountpoint);
2027 /* TestOutputList for glob_expand (0) */
2029 char path[] = "/a/b/c";
2032 r = guestfs_mkdir_p (g, path);
2037 char path[] = "/a/b/c/d";
2040 r = guestfs_touch (g, path);
2045 char path[] = "/a/b/c/e";
2048 r = guestfs_touch (g, path);
2053 char pattern[] = "/a/b/c/*";
2057 r = guestfs_glob_expand (g, pattern);
2061 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2066 char expected[] = "/a/b/c/d";
2067 if (strcmp (r[0], expected) != 0) {
2068 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2073 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2078 char expected[] = "/a/b/c/e";
2079 if (strcmp (r[1], expected) != 0) {
2080 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2085 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2089 for (i = 0; r[i] != NULL; ++i)
2096 static int test_glob_expand_1_skip (void)
2100 str = getenv ("TEST_ONLY");
2102 return strstr (str, "glob_expand") == NULL;
2103 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2104 if (str && strcmp (str, "1") == 0) return 1;
2105 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2106 if (str && strcmp (str, "1") == 0) return 1;
2110 static int test_glob_expand_1 (void)
2112 if (test_glob_expand_1_skip ()) {
2113 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2117 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2119 char device[] = "/dev/sda";
2122 r = guestfs_blockdev_setrw (g, device);
2129 r = guestfs_umount_all (g);
2136 r = guestfs_lvm_remove_all (g);
2141 char device[] = "/dev/sda";
2142 char lines_0[] = ",";
2149 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2154 char fstype[] = "ext2";
2155 char device[] = "/dev/sda1";
2158 r = guestfs_mkfs (g, fstype, device);
2163 char device[] = "/dev/sda1";
2164 char mountpoint[] = "/";
2167 r = guestfs_mount (g, device, mountpoint);
2171 /* TestOutputList for glob_expand (1) */
2173 char path[] = "/a/b/c";
2176 r = guestfs_mkdir_p (g, path);
2181 char path[] = "/a/b/c/d";
2184 r = guestfs_touch (g, path);
2189 char path[] = "/a/b/c/e";
2192 r = guestfs_touch (g, path);
2197 char pattern[] = "/a/*/c/*";
2201 r = guestfs_glob_expand (g, pattern);
2205 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2210 char expected[] = "/a/b/c/d";
2211 if (strcmp (r[0], expected) != 0) {
2212 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2217 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2222 char expected[] = "/a/b/c/e";
2223 if (strcmp (r[1], expected) != 0) {
2224 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2229 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2233 for (i = 0; r[i] != NULL; ++i)
2240 static int test_glob_expand_2_skip (void)
2244 str = getenv ("TEST_ONLY");
2246 return strstr (str, "glob_expand") == NULL;
2247 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2248 if (str && strcmp (str, "1") == 0) return 1;
2249 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2250 if (str && strcmp (str, "1") == 0) return 1;
2254 static int test_glob_expand_2 (void)
2256 if (test_glob_expand_2_skip ()) {
2257 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2261 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2263 char device[] = "/dev/sda";
2266 r = guestfs_blockdev_setrw (g, device);
2273 r = guestfs_umount_all (g);
2280 r = guestfs_lvm_remove_all (g);
2285 char device[] = "/dev/sda";
2286 char lines_0[] = ",";
2293 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2298 char fstype[] = "ext2";
2299 char device[] = "/dev/sda1";
2302 r = guestfs_mkfs (g, fstype, device);
2307 char device[] = "/dev/sda1";
2308 char mountpoint[] = "/";
2311 r = guestfs_mount (g, device, mountpoint);
2315 /* TestOutputList for glob_expand (2) */
2317 char path[] = "/a/b/c";
2320 r = guestfs_mkdir_p (g, path);
2325 char path[] = "/a/b/c/d";
2328 r = guestfs_touch (g, path);
2333 char path[] = "/a/b/c/e";
2336 r = guestfs_touch (g, path);
2341 char pattern[] = "/a/*/x/*";
2345 r = guestfs_glob_expand (g, pattern);
2349 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2353 for (i = 0; r[i] != NULL; ++i)
2360 static int test_ntfs_3g_probe_0_skip (void)
2364 str = getenv ("TEST_ONLY");
2366 return strstr (str, "ntfs_3g_probe") == NULL;
2367 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2368 if (str && strcmp (str, "1") == 0) return 1;
2369 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2370 if (str && strcmp (str, "1") == 0) return 1;
2374 static int test_ntfs_3g_probe_0 (void)
2376 if (test_ntfs_3g_probe_0_skip ()) {
2377 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2381 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2383 char device[] = "/dev/sda";
2386 r = guestfs_blockdev_setrw (g, device);
2393 r = guestfs_umount_all (g);
2400 r = guestfs_lvm_remove_all (g);
2404 /* TestOutputInt for ntfs_3g_probe (0) */
2406 char device[] = "/dev/sda";
2407 char lines_0[] = ",";
2414 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2419 char fstype[] = "ntfs";
2420 char device[] = "/dev/sda1";
2423 r = guestfs_mkfs (g, fstype, device);
2428 char device[] = "/dev/sda1";
2431 r = guestfs_ntfs_3g_probe (g, 1, device);
2435 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
2442 static int test_ntfs_3g_probe_1_skip (void)
2446 str = getenv ("TEST_ONLY");
2448 return strstr (str, "ntfs_3g_probe") == NULL;
2449 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2450 if (str && strcmp (str, "1") == 0) return 1;
2451 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2452 if (str && strcmp (str, "1") == 0) return 1;
2456 static int test_ntfs_3g_probe_1 (void)
2458 if (test_ntfs_3g_probe_1_skip ()) {
2459 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2463 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2465 char device[] = "/dev/sda";
2468 r = guestfs_blockdev_setrw (g, device);
2475 r = guestfs_umount_all (g);
2482 r = guestfs_lvm_remove_all (g);
2486 /* TestOutputInt for ntfs_3g_probe (1) */
2488 char device[] = "/dev/sda";
2489 char lines_0[] = ",";
2496 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2501 char fstype[] = "ext2";
2502 char device[] = "/dev/sda1";
2505 r = guestfs_mkfs (g, fstype, device);
2510 char device[] = "/dev/sda1";
2513 r = guestfs_ntfs_3g_probe (g, 1, device);
2517 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
2524 static int test_sleep_0_skip (void)
2528 str = getenv ("TEST_ONLY");
2530 return strstr (str, "sleep") == NULL;
2531 str = getenv ("SKIP_TEST_SLEEP_0");
2532 if (str && strcmp (str, "1") == 0) return 1;
2533 str = getenv ("SKIP_TEST_SLEEP");
2534 if (str && strcmp (str, "1") == 0) return 1;
2538 static int test_sleep_0 (void)
2540 if (test_sleep_0_skip ()) {
2541 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2545 /* InitNone|InitEmpty for test_sleep_0 */
2547 char device[] = "/dev/sda";
2550 r = guestfs_blockdev_setrw (g, device);
2557 r = guestfs_umount_all (g);
2564 r = guestfs_lvm_remove_all (g);
2568 /* TestRun for sleep (0) */
2572 r = guestfs_sleep (g, 1);
2579 static int test_find_0_skip (void)
2583 str = getenv ("TEST_ONLY");
2585 return strstr (str, "find") == NULL;
2586 str = getenv ("SKIP_TEST_FIND_0");
2587 if (str && strcmp (str, "1") == 0) return 1;
2588 str = getenv ("SKIP_TEST_FIND");
2589 if (str && strcmp (str, "1") == 0) return 1;
2593 static int test_find_0 (void)
2595 if (test_find_0_skip ()) {
2596 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2600 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2602 char device[] = "/dev/sda";
2605 r = guestfs_blockdev_setrw (g, device);
2612 r = guestfs_umount_all (g);
2619 r = guestfs_lvm_remove_all (g);
2624 char device[] = "/dev/sda";
2625 char lines_0[] = ",";
2632 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2637 char fstype[] = "ext2";
2638 char device[] = "/dev/sda1";
2641 r = guestfs_mkfs (g, fstype, device);
2646 char device[] = "/dev/sda1";
2647 char mountpoint[] = "/";
2650 r = guestfs_mount (g, device, mountpoint);
2654 /* TestOutputList for find (0) */
2656 char directory[] = "/";
2660 r = guestfs_find (g, directory);
2664 fprintf (stderr, "test_find_0: short list returned from command\n");
2669 char expected[] = "lost+found";
2670 if (strcmp (r[0], expected) != 0) {
2671 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2676 fprintf (stderr, "test_find_0: extra elements returned from command\n");
2680 for (i = 0; r[i] != NULL; ++i)
2687 static int test_find_1_skip (void)
2691 str = getenv ("TEST_ONLY");
2693 return strstr (str, "find") == NULL;
2694 str = getenv ("SKIP_TEST_FIND_1");
2695 if (str && strcmp (str, "1") == 0) return 1;
2696 str = getenv ("SKIP_TEST_FIND");
2697 if (str && strcmp (str, "1") == 0) return 1;
2701 static int test_find_1 (void)
2703 if (test_find_1_skip ()) {
2704 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2708 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2710 char device[] = "/dev/sda";
2713 r = guestfs_blockdev_setrw (g, device);
2720 r = guestfs_umount_all (g);
2727 r = guestfs_lvm_remove_all (g);
2732 char device[] = "/dev/sda";
2733 char lines_0[] = ",";
2740 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2745 char fstype[] = "ext2";
2746 char device[] = "/dev/sda1";
2749 r = guestfs_mkfs (g, fstype, device);
2754 char device[] = "/dev/sda1";
2755 char mountpoint[] = "/";
2758 r = guestfs_mount (g, device, mountpoint);
2762 /* TestOutputList for find (1) */
2767 r = guestfs_touch (g, path);
2775 r = guestfs_mkdir (g, path);
2780 char path[] = "/b/c";
2783 r = guestfs_touch (g, path);
2788 char directory[] = "/";
2792 r = guestfs_find (g, directory);
2796 fprintf (stderr, "test_find_1: short list returned from command\n");
2801 char expected[] = "a";
2802 if (strcmp (r[0], expected) != 0) {
2803 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2808 fprintf (stderr, "test_find_1: short list returned from command\n");
2813 char expected[] = "b";
2814 if (strcmp (r[1], expected) != 0) {
2815 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2820 fprintf (stderr, "test_find_1: short list returned from command\n");
2825 char expected[] = "b/c";
2826 if (strcmp (r[2], expected) != 0) {
2827 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2832 fprintf (stderr, "test_find_1: short list returned from command\n");
2837 char expected[] = "lost+found";
2838 if (strcmp (r[3], expected) != 0) {
2839 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2844 fprintf (stderr, "test_find_1: extra elements returned from command\n");
2848 for (i = 0; r[i] != NULL; ++i)
2855 static int test_find_2_skip (void)
2859 str = getenv ("TEST_ONLY");
2861 return strstr (str, "find") == NULL;
2862 str = getenv ("SKIP_TEST_FIND_2");
2863 if (str && strcmp (str, "1") == 0) return 1;
2864 str = getenv ("SKIP_TEST_FIND");
2865 if (str && strcmp (str, "1") == 0) return 1;
2869 static int test_find_2 (void)
2871 if (test_find_2_skip ()) {
2872 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
2876 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
2878 char device[] = "/dev/sda";
2881 r = guestfs_blockdev_setrw (g, device);
2888 r = guestfs_umount_all (g);
2895 r = guestfs_lvm_remove_all (g);
2900 char device[] = "/dev/sda";
2901 char lines_0[] = ",";
2908 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2913 char fstype[] = "ext2";
2914 char device[] = "/dev/sda1";
2917 r = guestfs_mkfs (g, fstype, device);
2922 char device[] = "/dev/sda1";
2923 char mountpoint[] = "/";
2926 r = guestfs_mount (g, device, mountpoint);
2930 /* TestOutputList for find (2) */
2932 char path[] = "/a/b/c";
2935 r = guestfs_mkdir_p (g, path);
2940 char path[] = "/a/b/c/d";
2943 r = guestfs_touch (g, path);
2948 char directory[] = "/a/b/";
2952 r = guestfs_find (g, directory);
2956 fprintf (stderr, "test_find_2: short list returned from command\n");
2961 char expected[] = "c";
2962 if (strcmp (r[0], expected) != 0) {
2963 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2968 fprintf (stderr, "test_find_2: short list returned from command\n");
2973 char expected[] = "c/d";
2974 if (strcmp (r[1], expected) != 0) {
2975 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2980 fprintf (stderr, "test_find_2: extra elements returned from command\n");
2984 for (i = 0; r[i] != NULL; ++i)
2991 static int test_lvresize_0_skip (void)
2995 str = getenv ("TEST_ONLY");
2997 return strstr (str, "lvresize") == NULL;
2998 str = getenv ("SKIP_TEST_LVRESIZE_0");
2999 if (str && strcmp (str, "1") == 0) return 1;
3000 str = getenv ("SKIP_TEST_LVRESIZE");
3001 if (str && strcmp (str, "1") == 0) return 1;
3005 static int test_lvresize_0 (void)
3007 if (test_lvresize_0_skip ()) {
3008 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3012 /* InitNone|InitEmpty for test_lvresize_0 */
3014 char device[] = "/dev/sda";
3017 r = guestfs_blockdev_setrw (g, device);
3024 r = guestfs_umount_all (g);
3031 r = guestfs_lvm_remove_all (g);
3035 /* TestOutput for lvresize (0) */
3036 char expected[] = "test content";
3038 char device[] = "/dev/sda";
3039 char lines_0[] = ",";
3046 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3051 char device[] = "/dev/sda1";
3054 r = guestfs_pvcreate (g, device);
3059 char volgroup[] = "VG";
3060 char physvols_0[] = "/dev/sda1";
3061 char *physvols[] = {
3067 r = guestfs_vgcreate (g, volgroup, physvols);
3072 char logvol[] = "LV";
3073 char volgroup[] = "VG";
3076 r = guestfs_lvcreate (g, logvol, volgroup, 10);
3081 char fstype[] = "ext2";
3082 char device[] = "/dev/VG/LV";
3085 r = guestfs_mkfs (g, fstype, device);
3090 char device[] = "/dev/VG/LV";
3091 char mountpoint[] = "/";
3094 r = guestfs_mount (g, device, mountpoint);
3099 char path[] = "/new";
3100 char content[] = "test content";
3103 r = guestfs_write_file (g, path, content, 0);
3108 char pathordevice[] = "/";
3111 r = guestfs_umount (g, pathordevice);
3116 char device[] = "/dev/VG/LV";
3119 r = guestfs_lvresize (g, device, 20);
3124 char device[] = "/dev/VG/LV";
3127 r = guestfs_e2fsck_f (g, device);
3132 char device[] = "/dev/VG/LV";
3135 r = guestfs_resize2fs (g, device);
3140 char device[] = "/dev/VG/LV";
3141 char mountpoint[] = "/";
3144 r = guestfs_mount (g, device, mountpoint);
3149 char path[] = "/new";
3152 r = guestfs_cat (g, path);
3155 if (strcmp (r, expected) != 0) {
3156 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3164 static int test_zerofree_0_skip (void)
3168 str = getenv ("TEST_ONLY");
3170 return strstr (str, "zerofree") == NULL;
3171 str = getenv ("SKIP_TEST_ZEROFREE_0");
3172 if (str && strcmp (str, "1") == 0) return 1;
3173 str = getenv ("SKIP_TEST_ZEROFREE");
3174 if (str && strcmp (str, "1") == 0) return 1;
3178 static int test_zerofree_0 (void)
3180 if (test_zerofree_0_skip ()) {
3181 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3185 /* InitNone|InitEmpty for test_zerofree_0 */
3187 char device[] = "/dev/sda";
3190 r = guestfs_blockdev_setrw (g, device);
3197 r = guestfs_umount_all (g);
3204 r = guestfs_lvm_remove_all (g);
3208 /* TestOutput for zerofree (0) */
3209 char expected[] = "test file";
3211 char device[] = "/dev/sda";
3212 char lines_0[] = ",";
3219 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3224 char fstype[] = "ext3";
3225 char device[] = "/dev/sda1";
3228 r = guestfs_mkfs (g, fstype, device);
3233 char device[] = "/dev/sda1";
3234 char mountpoint[] = "/";
3237 r = guestfs_mount (g, device, mountpoint);
3242 char path[] = "/new";
3243 char content[] = "test file";
3246 r = guestfs_write_file (g, path, content, 0);
3251 char pathordevice[] = "/dev/sda1";
3254 r = guestfs_umount (g, pathordevice);
3259 char device[] = "/dev/sda1";
3262 r = guestfs_zerofree (g, device);
3267 char device[] = "/dev/sda1";
3268 char mountpoint[] = "/";
3271 r = guestfs_mount (g, device, mountpoint);
3276 char path[] = "/new";
3279 r = guestfs_cat (g, path);
3282 if (strcmp (r, expected) != 0) {
3283 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3291 static int test_hexdump_0_skip (void)
3295 str = getenv ("TEST_ONLY");
3297 return strstr (str, "hexdump") == NULL;
3298 str = getenv ("SKIP_TEST_HEXDUMP_0");
3299 if (str && strcmp (str, "1") == 0) return 1;
3300 str = getenv ("SKIP_TEST_HEXDUMP");
3301 if (str && strcmp (str, "1") == 0) return 1;
3305 static int test_hexdump_0 (void)
3307 if (test_hexdump_0_skip ()) {
3308 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3312 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3314 char device[] = "/dev/sda";
3317 r = guestfs_blockdev_setrw (g, device);
3324 r = guestfs_umount_all (g);
3331 r = guestfs_lvm_remove_all (g);
3336 char device[] = "/dev/sda";
3337 char lines_0[] = ",";
3344 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3349 char fstype[] = "ext2";
3350 char device[] = "/dev/sda1";
3353 r = guestfs_mkfs (g, fstype, device);
3358 char device[] = "/dev/sda1";
3359 char mountpoint[] = "/";
3362 r = guestfs_mount (g, device, mountpoint);
3366 /* TestOutput for hexdump (0) */
3367 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
3369 char path[] = "/new";
3370 char content[] = "hello\nworld\n";
3373 r = guestfs_write_file (g, path, content, 12);
3378 char path[] = "/new";
3381 r = guestfs_hexdump (g, path);
3384 if (strcmp (r, expected) != 0) {
3385 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3393 static int test_hexdump_1_skip (void)
3397 str = getenv ("TEST_ONLY");
3399 return strstr (str, "hexdump") == NULL;
3400 str = getenv ("SKIP_TEST_HEXDUMP_1");
3401 if (str && strcmp (str, "1") == 0) return 1;
3402 str = getenv ("SKIP_TEST_HEXDUMP");
3403 if (str && strcmp (str, "1") == 0) return 1;
3407 static int test_hexdump_1 (void)
3409 if (test_hexdump_1_skip ()) {
3410 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3414 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
3416 char device[] = "/dev/sda";
3419 r = guestfs_blockdev_setrw (g, device);
3426 r = guestfs_umount_all (g);
3433 r = guestfs_lvm_remove_all (g);
3438 char device[] = "/dev/sda";
3439 char lines_0[] = ",";
3446 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3451 char fstype[] = "ext2";
3452 char device[] = "/dev/sda1";
3455 r = guestfs_mkfs (g, fstype, device);
3460 char device[] = "/dev/sda1";
3461 char mountpoint[] = "/";
3464 r = guestfs_mount (g, device, mountpoint);
3468 /* TestRun for hexdump (1) */
3470 char options[] = "ro";
3471 char vfstype[] = "squashfs";
3472 char device[] = "/dev/sdd";
3473 char mountpoint[] = "/";
3476 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3481 char path[] = "/100krandom";
3484 r = guestfs_hexdump (g, path);
3492 static int test_strings_e_0_skip (void)
3496 str = getenv ("TEST_ONLY");
3498 return strstr (str, "strings_e") == NULL;
3499 str = getenv ("SKIP_TEST_STRINGS_E_0");
3500 if (str && strcmp (str, "1") == 0) return 1;
3501 str = getenv ("SKIP_TEST_STRINGS_E");
3502 if (str && strcmp (str, "1") == 0) return 1;
3506 static int test_strings_e_0 (void)
3508 if (test_strings_e_0_skip ()) {
3509 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3513 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3515 char device[] = "/dev/sda";
3518 r = guestfs_blockdev_setrw (g, device);
3525 r = guestfs_umount_all (g);
3532 r = guestfs_lvm_remove_all (g);
3537 char device[] = "/dev/sda";
3538 char lines_0[] = ",";
3545 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3550 char fstype[] = "ext2";
3551 char device[] = "/dev/sda1";
3554 r = guestfs_mkfs (g, fstype, device);
3559 char device[] = "/dev/sda1";
3560 char mountpoint[] = "/";
3563 r = guestfs_mount (g, device, mountpoint);
3567 /* TestOutputList for strings_e (0) */
3569 char path[] = "/new";
3570 char content[] = "hello\nworld\n";
3573 r = guestfs_write_file (g, path, content, 0);
3578 char encoding[] = "b";
3579 char path[] = "/new";
3583 r = guestfs_strings_e (g, encoding, path);
3587 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3591 for (i = 0; r[i] != NULL; ++i)
3598 static int test_strings_e_1_skip (void)
3602 str = getenv ("TEST_ONLY");
3604 return strstr (str, "strings_e") == NULL;
3605 str = getenv ("SKIP_TEST_STRINGS_E_1");
3606 if (str && strcmp (str, "1") == 0) return 1;
3607 str = getenv ("SKIP_TEST_STRINGS_E");
3608 if (str && strcmp (str, "1") == 0) return 1;
3612 static int test_strings_e_1 (void)
3614 if (test_strings_e_1_skip ()) {
3615 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3619 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3623 static int test_strings_0_skip (void)
3627 str = getenv ("TEST_ONLY");
3629 return strstr (str, "strings") == NULL;
3630 str = getenv ("SKIP_TEST_STRINGS_0");
3631 if (str && strcmp (str, "1") == 0) return 1;
3632 str = getenv ("SKIP_TEST_STRINGS");
3633 if (str && strcmp (str, "1") == 0) return 1;
3637 static int test_strings_0 (void)
3639 if (test_strings_0_skip ()) {
3640 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3644 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3646 char device[] = "/dev/sda";
3649 r = guestfs_blockdev_setrw (g, device);
3656 r = guestfs_umount_all (g);
3663 r = guestfs_lvm_remove_all (g);
3668 char device[] = "/dev/sda";
3669 char lines_0[] = ",";
3676 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3681 char fstype[] = "ext2";
3682 char device[] = "/dev/sda1";
3685 r = guestfs_mkfs (g, fstype, device);
3690 char device[] = "/dev/sda1";
3691 char mountpoint[] = "/";
3694 r = guestfs_mount (g, device, mountpoint);
3698 /* TestOutputList for strings (0) */
3700 char path[] = "/new";
3701 char content[] = "hello\nworld\n";
3704 r = guestfs_write_file (g, path, content, 0);
3709 char path[] = "/new";
3713 r = guestfs_strings (g, path);
3717 fprintf (stderr, "test_strings_0: short list returned from command\n");
3722 char expected[] = "hello";
3723 if (strcmp (r[0], expected) != 0) {
3724 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3729 fprintf (stderr, "test_strings_0: short list returned from command\n");
3734 char expected[] = "world";
3735 if (strcmp (r[1], expected) != 0) {
3736 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3741 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
3745 for (i = 0; r[i] != NULL; ++i)
3752 static int test_strings_1_skip (void)
3756 str = getenv ("TEST_ONLY");
3758 return strstr (str, "strings") == NULL;
3759 str = getenv ("SKIP_TEST_STRINGS_1");
3760 if (str && strcmp (str, "1") == 0) return 1;
3761 str = getenv ("SKIP_TEST_STRINGS");
3762 if (str && strcmp (str, "1") == 0) return 1;
3766 static int test_strings_1 (void)
3768 if (test_strings_1_skip ()) {
3769 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
3773 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
3775 char device[] = "/dev/sda";
3778 r = guestfs_blockdev_setrw (g, device);
3785 r = guestfs_umount_all (g);
3792 r = guestfs_lvm_remove_all (g);
3797 char device[] = "/dev/sda";
3798 char lines_0[] = ",";
3805 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3810 char fstype[] = "ext2";
3811 char device[] = "/dev/sda1";
3814 r = guestfs_mkfs (g, fstype, device);
3819 char device[] = "/dev/sda1";
3820 char mountpoint[] = "/";
3823 r = guestfs_mount (g, device, mountpoint);
3827 /* TestOutputList for strings (1) */
3829 char path[] = "/new";
3832 r = guestfs_touch (g, path);
3837 char path[] = "/new";
3841 r = guestfs_strings (g, path);
3845 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
3849 for (i = 0; r[i] != NULL; ++i)
3856 static int test_equal_0_skip (void)
3860 str = getenv ("TEST_ONLY");
3862 return strstr (str, "equal") == NULL;
3863 str = getenv ("SKIP_TEST_EQUAL_0");
3864 if (str && strcmp (str, "1") == 0) return 1;
3865 str = getenv ("SKIP_TEST_EQUAL");
3866 if (str && strcmp (str, "1") == 0) return 1;
3870 static int test_equal_0 (void)
3872 if (test_equal_0_skip ()) {
3873 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
3877 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
3879 char device[] = "/dev/sda";
3882 r = guestfs_blockdev_setrw (g, device);
3889 r = guestfs_umount_all (g);
3896 r = guestfs_lvm_remove_all (g);
3901 char device[] = "/dev/sda";
3902 char lines_0[] = ",";
3909 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3914 char fstype[] = "ext2";
3915 char device[] = "/dev/sda1";
3918 r = guestfs_mkfs (g, fstype, device);
3923 char device[] = "/dev/sda1";
3924 char mountpoint[] = "/";
3927 r = guestfs_mount (g, device, mountpoint);
3931 /* TestOutputTrue for equal (0) */
3933 char path[] = "/file1";
3934 char content[] = "contents of a file";
3937 r = guestfs_write_file (g, path, content, 0);
3942 char src[] = "/file1";
3943 char dest[] = "/file2";
3946 r = guestfs_cp (g, src, dest);
3951 char file1[] = "/file1";
3952 char file2[] = "/file2";
3955 r = guestfs_equal (g, file1, file2);
3959 fprintf (stderr, "test_equal_0: expected true, got false\n");
3966 static int test_equal_1_skip (void)
3970 str = getenv ("TEST_ONLY");
3972 return strstr (str, "equal") == NULL;
3973 str = getenv ("SKIP_TEST_EQUAL_1");
3974 if (str && strcmp (str, "1") == 0) return 1;
3975 str = getenv ("SKIP_TEST_EQUAL");
3976 if (str && strcmp (str, "1") == 0) return 1;
3980 static int test_equal_1 (void)
3982 if (test_equal_1_skip ()) {
3983 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
3987 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
3989 char device[] = "/dev/sda";
3992 r = guestfs_blockdev_setrw (g, device);
3999 r = guestfs_umount_all (g);
4006 r = guestfs_lvm_remove_all (g);
4011 char device[] = "/dev/sda";
4012 char lines_0[] = ",";
4019 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4024 char fstype[] = "ext2";
4025 char device[] = "/dev/sda1";
4028 r = guestfs_mkfs (g, fstype, device);
4033 char device[] = "/dev/sda1";
4034 char mountpoint[] = "/";
4037 r = guestfs_mount (g, device, mountpoint);
4041 /* TestOutputFalse for equal (1) */
4043 char path[] = "/file1";
4044 char content[] = "contents of a file";
4047 r = guestfs_write_file (g, path, content, 0);
4052 char path[] = "/file2";
4053 char content[] = "contents of another file";
4056 r = guestfs_write_file (g, path, content, 0);
4061 char file1[] = "/file1";
4062 char file2[] = "/file2";
4065 r = guestfs_equal (g, file1, file2);
4069 fprintf (stderr, "test_equal_1: expected false, got true\n");
4076 static int test_equal_2_skip (void)
4080 str = getenv ("TEST_ONLY");
4082 return strstr (str, "equal") == NULL;
4083 str = getenv ("SKIP_TEST_EQUAL_2");
4084 if (str && strcmp (str, "1") == 0) return 1;
4085 str = getenv ("SKIP_TEST_EQUAL");
4086 if (str && strcmp (str, "1") == 0) return 1;
4090 static int test_equal_2 (void)
4092 if (test_equal_2_skip ()) {
4093 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4097 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4099 char device[] = "/dev/sda";
4102 r = guestfs_blockdev_setrw (g, device);
4109 r = guestfs_umount_all (g);
4116 r = guestfs_lvm_remove_all (g);
4121 char device[] = "/dev/sda";
4122 char lines_0[] = ",";
4129 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4134 char fstype[] = "ext2";
4135 char device[] = "/dev/sda1";
4138 r = guestfs_mkfs (g, fstype, device);
4143 char device[] = "/dev/sda1";
4144 char mountpoint[] = "/";
4147 r = guestfs_mount (g, device, mountpoint);
4151 /* TestLastFail for equal (2) */
4153 char file1[] = "/file1";
4154 char file2[] = "/file2";
4157 r = guestfs_equal (g, file1, file2);
4164 static int test_ping_daemon_0_skip (void)
4168 str = getenv ("TEST_ONLY");
4170 return strstr (str, "ping_daemon") == NULL;
4171 str = getenv ("SKIP_TEST_PING_DAEMON_0");
4172 if (str && strcmp (str, "1") == 0) return 1;
4173 str = getenv ("SKIP_TEST_PING_DAEMON");
4174 if (str && strcmp (str, "1") == 0) return 1;
4178 static int test_ping_daemon_0 (void)
4180 if (test_ping_daemon_0_skip ()) {
4181 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4185 /* InitNone|InitEmpty for test_ping_daemon_0 */
4187 char device[] = "/dev/sda";
4190 r = guestfs_blockdev_setrw (g, device);
4197 r = guestfs_umount_all (g);
4204 r = guestfs_lvm_remove_all (g);
4208 /* TestRun for ping_daemon (0) */
4212 r = guestfs_ping_daemon (g);
4219 static int test_dmesg_0_skip (void)
4223 str = getenv ("TEST_ONLY");
4225 return strstr (str, "dmesg") == NULL;
4226 str = getenv ("SKIP_TEST_DMESG_0");
4227 if (str && strcmp (str, "1") == 0) return 1;
4228 str = getenv ("SKIP_TEST_DMESG");
4229 if (str && strcmp (str, "1") == 0) return 1;
4233 static int test_dmesg_0 (void)
4235 if (test_dmesg_0_skip ()) {
4236 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4240 /* InitNone|InitEmpty for test_dmesg_0 */
4242 char device[] = "/dev/sda";
4245 r = guestfs_blockdev_setrw (g, device);
4252 r = guestfs_umount_all (g);
4259 r = guestfs_lvm_remove_all (g);
4263 /* TestRun for dmesg (0) */
4267 r = guestfs_dmesg (g);
4275 static int test_drop_caches_0_skip (void)
4279 str = getenv ("TEST_ONLY");
4281 return strstr (str, "drop_caches") == NULL;
4282 str = getenv ("SKIP_TEST_DROP_CACHES_0");
4283 if (str && strcmp (str, "1") == 0) return 1;
4284 str = getenv ("SKIP_TEST_DROP_CACHES");
4285 if (str && strcmp (str, "1") == 0) return 1;
4289 static int test_drop_caches_0 (void)
4291 if (test_drop_caches_0_skip ()) {
4292 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4296 /* InitNone|InitEmpty for test_drop_caches_0 */
4298 char device[] = "/dev/sda";
4301 r = guestfs_blockdev_setrw (g, device);
4308 r = guestfs_umount_all (g);
4315 r = guestfs_lvm_remove_all (g);
4319 /* TestRun for drop_caches (0) */
4323 r = guestfs_drop_caches (g, 3);
4330 static int test_mv_0_skip (void)
4334 str = getenv ("TEST_ONLY");
4336 return strstr (str, "mv") == NULL;
4337 str = getenv ("SKIP_TEST_MV_0");
4338 if (str && strcmp (str, "1") == 0) return 1;
4339 str = getenv ("SKIP_TEST_MV");
4340 if (str && strcmp (str, "1") == 0) return 1;
4344 static int test_mv_0 (void)
4346 if (test_mv_0_skip ()) {
4347 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4351 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4353 char device[] = "/dev/sda";
4356 r = guestfs_blockdev_setrw (g, device);
4363 r = guestfs_umount_all (g);
4370 r = guestfs_lvm_remove_all (g);
4375 char device[] = "/dev/sda";
4376 char lines_0[] = ",";
4383 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4388 char fstype[] = "ext2";
4389 char device[] = "/dev/sda1";
4392 r = guestfs_mkfs (g, fstype, device);
4397 char device[] = "/dev/sda1";
4398 char mountpoint[] = "/";
4401 r = guestfs_mount (g, device, mountpoint);
4405 /* TestOutput for mv (0) */
4406 char expected[] = "file content";
4408 char path[] = "/old";
4409 char content[] = "file content";
4412 r = guestfs_write_file (g, path, content, 0);
4417 char src[] = "/old";
4418 char dest[] = "/new";
4421 r = guestfs_mv (g, src, dest);
4426 char path[] = "/new";
4429 r = guestfs_cat (g, path);
4432 if (strcmp (r, expected) != 0) {
4433 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4441 static int test_mv_1_skip (void)
4445 str = getenv ("TEST_ONLY");
4447 return strstr (str, "mv") == NULL;
4448 str = getenv ("SKIP_TEST_MV_1");
4449 if (str && strcmp (str, "1") == 0) return 1;
4450 str = getenv ("SKIP_TEST_MV");
4451 if (str && strcmp (str, "1") == 0) return 1;
4455 static int test_mv_1 (void)
4457 if (test_mv_1_skip ()) {
4458 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4462 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4464 char device[] = "/dev/sda";
4467 r = guestfs_blockdev_setrw (g, device);
4474 r = guestfs_umount_all (g);
4481 r = guestfs_lvm_remove_all (g);
4486 char device[] = "/dev/sda";
4487 char lines_0[] = ",";
4494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4499 char fstype[] = "ext2";
4500 char device[] = "/dev/sda1";
4503 r = guestfs_mkfs (g, fstype, device);
4508 char device[] = "/dev/sda1";
4509 char mountpoint[] = "/";
4512 r = guestfs_mount (g, device, mountpoint);
4516 /* TestOutputFalse for mv (1) */
4518 char path[] = "/old";
4519 char content[] = "file content";
4522 r = guestfs_write_file (g, path, content, 0);
4527 char src[] = "/old";
4528 char dest[] = "/new";
4531 r = guestfs_mv (g, src, dest);
4536 char path[] = "/old";
4539 r = guestfs_is_file (g, path);
4543 fprintf (stderr, "test_mv_1: expected false, got true\n");
4550 static int test_cp_a_0_skip (void)
4554 str = getenv ("TEST_ONLY");
4556 return strstr (str, "cp_a") == NULL;
4557 str = getenv ("SKIP_TEST_CP_A_0");
4558 if (str && strcmp (str, "1") == 0) return 1;
4559 str = getenv ("SKIP_TEST_CP_A");
4560 if (str && strcmp (str, "1") == 0) return 1;
4564 static int test_cp_a_0 (void)
4566 if (test_cp_a_0_skip ()) {
4567 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4571 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4573 char device[] = "/dev/sda";
4576 r = guestfs_blockdev_setrw (g, device);
4583 r = guestfs_umount_all (g);
4590 r = guestfs_lvm_remove_all (g);
4595 char device[] = "/dev/sda";
4596 char lines_0[] = ",";
4603 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4608 char fstype[] = "ext2";
4609 char device[] = "/dev/sda1";
4612 r = guestfs_mkfs (g, fstype, device);
4617 char device[] = "/dev/sda1";
4618 char mountpoint[] = "/";
4621 r = guestfs_mount (g, device, mountpoint);
4625 /* TestOutput for cp_a (0) */
4626 char expected[] = "file content";
4628 char path[] = "/olddir";
4631 r = guestfs_mkdir (g, path);
4636 char path[] = "/newdir";
4639 r = guestfs_mkdir (g, path);
4644 char path[] = "/olddir/file";
4645 char content[] = "file content";
4648 r = guestfs_write_file (g, path, content, 0);
4653 char src[] = "/olddir";
4654 char dest[] = "/newdir";
4657 r = guestfs_cp_a (g, src, dest);
4662 char path[] = "/newdir/olddir/file";
4665 r = guestfs_cat (g, path);
4668 if (strcmp (r, expected) != 0) {
4669 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4677 static int test_cp_0_skip (void)
4681 str = getenv ("TEST_ONLY");
4683 return strstr (str, "cp") == NULL;
4684 str = getenv ("SKIP_TEST_CP_0");
4685 if (str && strcmp (str, "1") == 0) return 1;
4686 str = getenv ("SKIP_TEST_CP");
4687 if (str && strcmp (str, "1") == 0) return 1;
4691 static int test_cp_0 (void)
4693 if (test_cp_0_skip ()) {
4694 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4698 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4700 char device[] = "/dev/sda";
4703 r = guestfs_blockdev_setrw (g, device);
4710 r = guestfs_umount_all (g);
4717 r = guestfs_lvm_remove_all (g);
4722 char device[] = "/dev/sda";
4723 char lines_0[] = ",";
4730 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4735 char fstype[] = "ext2";
4736 char device[] = "/dev/sda1";
4739 r = guestfs_mkfs (g, fstype, device);
4744 char device[] = "/dev/sda1";
4745 char mountpoint[] = "/";
4748 r = guestfs_mount (g, device, mountpoint);
4752 /* TestOutput for cp (0) */
4753 char expected[] = "file content";
4755 char path[] = "/old";
4756 char content[] = "file content";
4759 r = guestfs_write_file (g, path, content, 0);
4764 char src[] = "/old";
4765 char dest[] = "/new";
4768 r = guestfs_cp (g, src, dest);
4773 char path[] = "/new";
4776 r = guestfs_cat (g, path);
4779 if (strcmp (r, expected) != 0) {
4780 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
4788 static int test_cp_1_skip (void)
4792 str = getenv ("TEST_ONLY");
4794 return strstr (str, "cp") == NULL;
4795 str = getenv ("SKIP_TEST_CP_1");
4796 if (str && strcmp (str, "1") == 0) return 1;
4797 str = getenv ("SKIP_TEST_CP");
4798 if (str && strcmp (str, "1") == 0) return 1;
4802 static int test_cp_1 (void)
4804 if (test_cp_1_skip ()) {
4805 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
4809 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
4811 char device[] = "/dev/sda";
4814 r = guestfs_blockdev_setrw (g, device);
4821 r = guestfs_umount_all (g);
4828 r = guestfs_lvm_remove_all (g);
4833 char device[] = "/dev/sda";
4834 char lines_0[] = ",";
4841 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4846 char fstype[] = "ext2";
4847 char device[] = "/dev/sda1";
4850 r = guestfs_mkfs (g, fstype, device);
4855 char device[] = "/dev/sda1";
4856 char mountpoint[] = "/";
4859 r = guestfs_mount (g, device, mountpoint);
4863 /* TestOutputTrue for cp (1) */
4865 char path[] = "/old";
4866 char content[] = "file content";
4869 r = guestfs_write_file (g, path, content, 0);
4874 char src[] = "/old";
4875 char dest[] = "/new";
4878 r = guestfs_cp (g, src, dest);
4883 char path[] = "/old";
4886 r = guestfs_is_file (g, path);
4890 fprintf (stderr, "test_cp_1: expected true, got false\n");
4897 static int test_cp_2_skip (void)
4901 str = getenv ("TEST_ONLY");
4903 return strstr (str, "cp") == NULL;
4904 str = getenv ("SKIP_TEST_CP_2");
4905 if (str && strcmp (str, "1") == 0) return 1;
4906 str = getenv ("SKIP_TEST_CP");
4907 if (str && strcmp (str, "1") == 0) return 1;
4911 static int test_cp_2 (void)
4913 if (test_cp_2_skip ()) {
4914 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
4918 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
4920 char device[] = "/dev/sda";
4923 r = guestfs_blockdev_setrw (g, device);
4930 r = guestfs_umount_all (g);
4937 r = guestfs_lvm_remove_all (g);
4942 char device[] = "/dev/sda";
4943 char lines_0[] = ",";
4950 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4955 char fstype[] = "ext2";
4956 char device[] = "/dev/sda1";
4959 r = guestfs_mkfs (g, fstype, device);
4964 char device[] = "/dev/sda1";
4965 char mountpoint[] = "/";
4968 r = guestfs_mount (g, device, mountpoint);
4972 /* TestOutput for cp (2) */
4973 char expected[] = "file content";
4975 char path[] = "/old";
4976 char content[] = "file content";
4979 r = guestfs_write_file (g, path, content, 0);
4984 char path[] = "/dir";
4987 r = guestfs_mkdir (g, path);
4992 char src[] = "/old";
4993 char dest[] = "/dir/new";
4996 r = guestfs_cp (g, src, dest);
5001 char path[] = "/dir/new";
5004 r = guestfs_cat (g, path);
5007 if (strcmp (r, expected) != 0) {
5008 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5016 static int test_grub_install_0_skip (void)
5020 str = getenv ("TEST_ONLY");
5022 return strstr (str, "grub_install") == NULL;
5023 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5024 if (str && strcmp (str, "1") == 0) return 1;
5025 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5026 if (str && strcmp (str, "1") == 0) return 1;
5030 static int test_grub_install_0 (void)
5032 if (test_grub_install_0_skip ()) {
5033 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5037 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5039 char device[] = "/dev/sda";
5042 r = guestfs_blockdev_setrw (g, device);
5049 r = guestfs_umount_all (g);
5056 r = guestfs_lvm_remove_all (g);
5061 char device[] = "/dev/sda";
5062 char lines_0[] = ",";
5069 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5074 char fstype[] = "ext2";
5075 char device[] = "/dev/sda1";
5078 r = guestfs_mkfs (g, fstype, device);
5083 char device[] = "/dev/sda1";
5084 char mountpoint[] = "/";
5087 r = guestfs_mount (g, device, mountpoint);
5091 /* TestOutputTrue for grub_install (0) */
5094 char device[] = "/dev/sda1";
5097 r = guestfs_grub_install (g, root, device);
5102 char path[] = "/boot";
5105 r = guestfs_is_dir (g, path);
5109 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5116 static int test_zero_0_skip (void)
5120 str = getenv ("TEST_ONLY");
5122 return strstr (str, "zero") == NULL;
5123 str = getenv ("SKIP_TEST_ZERO_0");
5124 if (str && strcmp (str, "1") == 0) return 1;
5125 str = getenv ("SKIP_TEST_ZERO");
5126 if (str && strcmp (str, "1") == 0) return 1;
5130 static int test_zero_0 (void)
5132 if (test_zero_0_skip ()) {
5133 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5137 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5139 char device[] = "/dev/sda";
5142 r = guestfs_blockdev_setrw (g, device);
5149 r = guestfs_umount_all (g);
5156 r = guestfs_lvm_remove_all (g);
5161 char device[] = "/dev/sda";
5162 char lines_0[] = ",";
5169 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5174 char fstype[] = "ext2";
5175 char device[] = "/dev/sda1";
5178 r = guestfs_mkfs (g, fstype, device);
5183 char device[] = "/dev/sda1";
5184 char mountpoint[] = "/";
5187 r = guestfs_mount (g, device, mountpoint);
5191 /* TestOutput for zero (0) */
5192 char expected[] = "data";
5194 char pathordevice[] = "/dev/sda1";
5197 r = guestfs_umount (g, pathordevice);
5202 char device[] = "/dev/sda1";
5205 r = guestfs_zero (g, device);
5210 char path[] = "/dev/sda1";
5213 r = guestfs_file (g, path);
5216 if (strcmp (r, expected) != 0) {
5217 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5225 static int test_fsck_0_skip (void)
5229 str = getenv ("TEST_ONLY");
5231 return strstr (str, "fsck") == NULL;
5232 str = getenv ("SKIP_TEST_FSCK_0");
5233 if (str && strcmp (str, "1") == 0) return 1;
5234 str = getenv ("SKIP_TEST_FSCK");
5235 if (str && strcmp (str, "1") == 0) return 1;
5239 static int test_fsck_0 (void)
5241 if (test_fsck_0_skip ()) {
5242 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5246 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5248 char device[] = "/dev/sda";
5251 r = guestfs_blockdev_setrw (g, device);
5258 r = guestfs_umount_all (g);
5265 r = guestfs_lvm_remove_all (g);
5270 char device[] = "/dev/sda";
5271 char lines_0[] = ",";
5278 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5283 char fstype[] = "ext2";
5284 char device[] = "/dev/sda1";
5287 r = guestfs_mkfs (g, fstype, device);
5292 char device[] = "/dev/sda1";
5293 char mountpoint[] = "/";
5296 r = guestfs_mount (g, device, mountpoint);
5300 /* TestOutputInt for fsck (0) */
5302 char pathordevice[] = "/dev/sda1";
5305 r = guestfs_umount (g, pathordevice);
5310 char fstype[] = "ext2";
5311 char device[] = "/dev/sda1";
5314 r = guestfs_fsck (g, fstype, device);
5318 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
5325 static int test_fsck_1_skip (void)
5329 str = getenv ("TEST_ONLY");
5331 return strstr (str, "fsck") == NULL;
5332 str = getenv ("SKIP_TEST_FSCK_1");
5333 if (str && strcmp (str, "1") == 0) return 1;
5334 str = getenv ("SKIP_TEST_FSCK");
5335 if (str && strcmp (str, "1") == 0) return 1;
5339 static int test_fsck_1 (void)
5341 if (test_fsck_1_skip ()) {
5342 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5346 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5348 char device[] = "/dev/sda";
5351 r = guestfs_blockdev_setrw (g, device);
5358 r = guestfs_umount_all (g);
5365 r = guestfs_lvm_remove_all (g);
5370 char device[] = "/dev/sda";
5371 char lines_0[] = ",";
5378 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5383 char fstype[] = "ext2";
5384 char device[] = "/dev/sda1";
5387 r = guestfs_mkfs (g, fstype, device);
5392 char device[] = "/dev/sda1";
5393 char mountpoint[] = "/";
5396 r = guestfs_mount (g, device, mountpoint);
5400 /* TestOutputInt for fsck (1) */
5402 char pathordevice[] = "/dev/sda1";
5405 r = guestfs_umount (g, pathordevice);
5410 char device[] = "/dev/sda1";
5413 r = guestfs_zero (g, device);
5418 char fstype[] = "ext2";
5419 char device[] = "/dev/sda1";
5422 r = guestfs_fsck (g, fstype, device);
5426 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
5433 static int test_set_e2uuid_0_skip (void)
5437 str = getenv ("TEST_ONLY");
5439 return strstr (str, "set_e2uuid") == NULL;
5440 str = getenv ("SKIP_TEST_SET_E2UUID_0");
5441 if (str && strcmp (str, "1") == 0) return 1;
5442 str = getenv ("SKIP_TEST_SET_E2UUID");
5443 if (str && strcmp (str, "1") == 0) return 1;
5447 static int test_set_e2uuid_0 (void)
5449 if (test_set_e2uuid_0_skip ()) {
5450 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5454 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5456 char device[] = "/dev/sda";
5459 r = guestfs_blockdev_setrw (g, device);
5466 r = guestfs_umount_all (g);
5473 r = guestfs_lvm_remove_all (g);
5478 char device[] = "/dev/sda";
5479 char lines_0[] = ",";
5486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5491 char fstype[] = "ext2";
5492 char device[] = "/dev/sda1";
5495 r = guestfs_mkfs (g, fstype, device);
5500 char device[] = "/dev/sda1";
5501 char mountpoint[] = "/";
5504 r = guestfs_mount (g, device, mountpoint);
5508 /* TestOutput for set_e2uuid (0) */
5509 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5511 char device[] = "/dev/sda1";
5512 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5515 r = guestfs_set_e2uuid (g, device, uuid);
5520 char device[] = "/dev/sda1";
5523 r = guestfs_get_e2uuid (g, device);
5526 if (strcmp (r, expected) != 0) {
5527 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5535 static int test_set_e2uuid_1_skip (void)
5539 str = getenv ("TEST_ONLY");
5541 return strstr (str, "set_e2uuid") == NULL;
5542 str = getenv ("SKIP_TEST_SET_E2UUID_1");
5543 if (str && strcmp (str, "1") == 0) return 1;
5544 str = getenv ("SKIP_TEST_SET_E2UUID");
5545 if (str && strcmp (str, "1") == 0) return 1;
5549 static int test_set_e2uuid_1 (void)
5551 if (test_set_e2uuid_1_skip ()) {
5552 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5556 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
5558 char device[] = "/dev/sda";
5561 r = guestfs_blockdev_setrw (g, device);
5568 r = guestfs_umount_all (g);
5575 r = guestfs_lvm_remove_all (g);
5580 char device[] = "/dev/sda";
5581 char lines_0[] = ",";
5588 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5593 char fstype[] = "ext2";
5594 char device[] = "/dev/sda1";
5597 r = guestfs_mkfs (g, fstype, device);
5602 char device[] = "/dev/sda1";
5603 char mountpoint[] = "/";
5606 r = guestfs_mount (g, device, mountpoint);
5610 /* TestOutput for set_e2uuid (1) */
5611 char expected[] = "";
5613 char device[] = "/dev/sda1";
5614 char uuid[] = "clear";
5617 r = guestfs_set_e2uuid (g, device, uuid);
5622 char device[] = "/dev/sda1";
5625 r = guestfs_get_e2uuid (g, device);
5628 if (strcmp (r, expected) != 0) {
5629 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5637 static int test_set_e2uuid_2_skip (void)
5641 str = getenv ("TEST_ONLY");
5643 return strstr (str, "set_e2uuid") == NULL;
5644 str = getenv ("SKIP_TEST_SET_E2UUID_2");
5645 if (str && strcmp (str, "1") == 0) return 1;
5646 str = getenv ("SKIP_TEST_SET_E2UUID");
5647 if (str && strcmp (str, "1") == 0) return 1;
5651 static int test_set_e2uuid_2 (void)
5653 if (test_set_e2uuid_2_skip ()) {
5654 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5658 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5660 char device[] = "/dev/sda";
5663 r = guestfs_blockdev_setrw (g, device);
5670 r = guestfs_umount_all (g);
5677 r = guestfs_lvm_remove_all (g);
5682 char device[] = "/dev/sda";
5683 char lines_0[] = ",";
5690 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5695 char fstype[] = "ext2";
5696 char device[] = "/dev/sda1";
5699 r = guestfs_mkfs (g, fstype, device);
5704 char device[] = "/dev/sda1";
5705 char mountpoint[] = "/";
5708 r = guestfs_mount (g, device, mountpoint);
5712 /* TestRun for set_e2uuid (2) */
5714 char device[] = "/dev/sda1";
5715 char uuid[] = "random";
5718 r = guestfs_set_e2uuid (g, device, uuid);
5725 static int test_set_e2uuid_3_skip (void)
5729 str = getenv ("TEST_ONLY");
5731 return strstr (str, "set_e2uuid") == NULL;
5732 str = getenv ("SKIP_TEST_SET_E2UUID_3");
5733 if (str && strcmp (str, "1") == 0) return 1;
5734 str = getenv ("SKIP_TEST_SET_E2UUID");
5735 if (str && strcmp (str, "1") == 0) return 1;
5739 static int test_set_e2uuid_3 (void)
5741 if (test_set_e2uuid_3_skip ()) {
5742 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
5746 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
5748 char device[] = "/dev/sda";
5751 r = guestfs_blockdev_setrw (g, device);
5758 r = guestfs_umount_all (g);
5765 r = guestfs_lvm_remove_all (g);
5770 char device[] = "/dev/sda";
5771 char lines_0[] = ",";
5778 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5783 char fstype[] = "ext2";
5784 char device[] = "/dev/sda1";
5787 r = guestfs_mkfs (g, fstype, device);
5792 char device[] = "/dev/sda1";
5793 char mountpoint[] = "/";
5796 r = guestfs_mount (g, device, mountpoint);
5800 /* TestRun for set_e2uuid (3) */
5802 char device[] = "/dev/sda1";
5803 char uuid[] = "time";
5806 r = guestfs_set_e2uuid (g, device, uuid);
5813 static int test_set_e2label_0_skip (void)
5817 str = getenv ("TEST_ONLY");
5819 return strstr (str, "set_e2label") == NULL;
5820 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
5821 if (str && strcmp (str, "1") == 0) return 1;
5822 str = getenv ("SKIP_TEST_SET_E2LABEL");
5823 if (str && strcmp (str, "1") == 0) return 1;
5827 static int test_set_e2label_0 (void)
5829 if (test_set_e2label_0_skip ()) {
5830 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
5834 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
5836 char device[] = "/dev/sda";
5839 r = guestfs_blockdev_setrw (g, device);
5846 r = guestfs_umount_all (g);
5853 r = guestfs_lvm_remove_all (g);
5858 char device[] = "/dev/sda";
5859 char lines_0[] = ",";
5866 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5871 char fstype[] = "ext2";
5872 char device[] = "/dev/sda1";
5875 r = guestfs_mkfs (g, fstype, device);
5880 char device[] = "/dev/sda1";
5881 char mountpoint[] = "/";
5884 r = guestfs_mount (g, device, mountpoint);
5888 /* TestOutput for set_e2label (0) */
5889 char expected[] = "testlabel";
5891 char device[] = "/dev/sda1";
5892 char label[] = "testlabel";
5895 r = guestfs_set_e2label (g, device, label);
5900 char device[] = "/dev/sda1";
5903 r = guestfs_get_e2label (g, device);
5906 if (strcmp (r, expected) != 0) {
5907 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
5915 static int test_pvremove_0_skip (void)
5919 str = getenv ("TEST_ONLY");
5921 return strstr (str, "pvremove") == NULL;
5922 str = getenv ("SKIP_TEST_PVREMOVE_0");
5923 if (str && strcmp (str, "1") == 0) return 1;
5924 str = getenv ("SKIP_TEST_PVREMOVE");
5925 if (str && strcmp (str, "1") == 0) return 1;
5929 static int test_pvremove_0 (void)
5931 if (test_pvremove_0_skip ()) {
5932 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
5936 /* InitNone|InitEmpty for test_pvremove_0 */
5938 char device[] = "/dev/sda";
5941 r = guestfs_blockdev_setrw (g, device);
5948 r = guestfs_umount_all (g);
5955 r = guestfs_lvm_remove_all (g);
5959 /* TestOutputListOfDevices for pvremove (0) */
5961 char device[] = "/dev/sda";
5962 char lines_0[] = ",";
5969 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5974 char device[] = "/dev/sda1";
5977 r = guestfs_pvcreate (g, device);
5982 char volgroup[] = "VG";
5983 char physvols_0[] = "/dev/sda1";
5984 char *physvols[] = {
5990 r = guestfs_vgcreate (g, volgroup, physvols);
5995 char logvol[] = "LV1";
5996 char volgroup[] = "VG";
5999 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6004 char logvol[] = "LV2";
6005 char volgroup[] = "VG";
6008 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6013 char vgname[] = "VG";
6016 r = guestfs_vgremove (g, vgname);
6021 char device[] = "/dev/sda1";
6024 r = guestfs_pvremove (g, device);
6032 r = guestfs_lvs (g);
6036 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6040 for (i = 0; r[i] != NULL; ++i)
6047 static int test_pvremove_1_skip (void)
6051 str = getenv ("TEST_ONLY");
6053 return strstr (str, "pvremove") == NULL;
6054 str = getenv ("SKIP_TEST_PVREMOVE_1");
6055 if (str && strcmp (str, "1") == 0) return 1;
6056 str = getenv ("SKIP_TEST_PVREMOVE");
6057 if (str && strcmp (str, "1") == 0) return 1;
6061 static int test_pvremove_1 (void)
6063 if (test_pvremove_1_skip ()) {
6064 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6068 /* InitNone|InitEmpty for test_pvremove_1 */
6070 char device[] = "/dev/sda";
6073 r = guestfs_blockdev_setrw (g, device);
6080 r = guestfs_umount_all (g);
6087 r = guestfs_lvm_remove_all (g);
6091 /* TestOutputListOfDevices for pvremove (1) */
6093 char device[] = "/dev/sda";
6094 char lines_0[] = ",";
6101 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6106 char device[] = "/dev/sda1";
6109 r = guestfs_pvcreate (g, device);
6114 char volgroup[] = "VG";
6115 char physvols_0[] = "/dev/sda1";
6116 char *physvols[] = {
6122 r = guestfs_vgcreate (g, volgroup, physvols);
6127 char logvol[] = "LV1";
6128 char volgroup[] = "VG";
6131 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6136 char logvol[] = "LV2";
6137 char volgroup[] = "VG";
6140 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6145 char vgname[] = "VG";
6148 r = guestfs_vgremove (g, vgname);
6153 char device[] = "/dev/sda1";
6156 r = guestfs_pvremove (g, device);
6164 r = guestfs_vgs (g);
6168 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6172 for (i = 0; r[i] != NULL; ++i)
6179 static int test_pvremove_2_skip (void)
6183 str = getenv ("TEST_ONLY");
6185 return strstr (str, "pvremove") == NULL;
6186 str = getenv ("SKIP_TEST_PVREMOVE_2");
6187 if (str && strcmp (str, "1") == 0) return 1;
6188 str = getenv ("SKIP_TEST_PVREMOVE");
6189 if (str && strcmp (str, "1") == 0) return 1;
6193 static int test_pvremove_2 (void)
6195 if (test_pvremove_2_skip ()) {
6196 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6200 /* InitNone|InitEmpty for test_pvremove_2 */
6202 char device[] = "/dev/sda";
6205 r = guestfs_blockdev_setrw (g, device);
6212 r = guestfs_umount_all (g);
6219 r = guestfs_lvm_remove_all (g);
6223 /* TestOutputListOfDevices for pvremove (2) */
6225 char device[] = "/dev/sda";
6226 char lines_0[] = ",";
6233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6238 char device[] = "/dev/sda1";
6241 r = guestfs_pvcreate (g, device);
6246 char volgroup[] = "VG";
6247 char physvols_0[] = "/dev/sda1";
6248 char *physvols[] = {
6254 r = guestfs_vgcreate (g, volgroup, physvols);
6259 char logvol[] = "LV1";
6260 char volgroup[] = "VG";
6263 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6268 char logvol[] = "LV2";
6269 char volgroup[] = "VG";
6272 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6277 char vgname[] = "VG";
6280 r = guestfs_vgremove (g, vgname);
6285 char device[] = "/dev/sda1";
6288 r = guestfs_pvremove (g, device);
6296 r = guestfs_pvs (g);
6300 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6304 for (i = 0; r[i] != NULL; ++i)
6311 static int test_vgremove_0_skip (void)
6315 str = getenv ("TEST_ONLY");
6317 return strstr (str, "vgremove") == NULL;
6318 str = getenv ("SKIP_TEST_VGREMOVE_0");
6319 if (str && strcmp (str, "1") == 0) return 1;
6320 str = getenv ("SKIP_TEST_VGREMOVE");
6321 if (str && strcmp (str, "1") == 0) return 1;
6325 static int test_vgremove_0 (void)
6327 if (test_vgremove_0_skip ()) {
6328 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6332 /* InitNone|InitEmpty for test_vgremove_0 */
6334 char device[] = "/dev/sda";
6337 r = guestfs_blockdev_setrw (g, device);
6344 r = guestfs_umount_all (g);
6351 r = guestfs_lvm_remove_all (g);
6355 /* TestOutputList for vgremove (0) */
6357 char device[] = "/dev/sda";
6358 char lines_0[] = ",";
6365 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6370 char device[] = "/dev/sda1";
6373 r = guestfs_pvcreate (g, device);
6378 char volgroup[] = "VG";
6379 char physvols_0[] = "/dev/sda1";
6380 char *physvols[] = {
6386 r = guestfs_vgcreate (g, volgroup, physvols);
6391 char logvol[] = "LV1";
6392 char volgroup[] = "VG";
6395 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6400 char logvol[] = "LV2";
6401 char volgroup[] = "VG";
6404 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6409 char vgname[] = "VG";
6412 r = guestfs_vgremove (g, vgname);
6420 r = guestfs_lvs (g);
6424 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6428 for (i = 0; r[i] != NULL; ++i)
6435 static int test_vgremove_1_skip (void)
6439 str = getenv ("TEST_ONLY");
6441 return strstr (str, "vgremove") == NULL;
6442 str = getenv ("SKIP_TEST_VGREMOVE_1");
6443 if (str && strcmp (str, "1") == 0) return 1;
6444 str = getenv ("SKIP_TEST_VGREMOVE");
6445 if (str && strcmp (str, "1") == 0) return 1;
6449 static int test_vgremove_1 (void)
6451 if (test_vgremove_1_skip ()) {
6452 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6456 /* InitNone|InitEmpty for test_vgremove_1 */
6458 char device[] = "/dev/sda";
6461 r = guestfs_blockdev_setrw (g, device);
6468 r = guestfs_umount_all (g);
6475 r = guestfs_lvm_remove_all (g);
6479 /* TestOutputList for vgremove (1) */
6481 char device[] = "/dev/sda";
6482 char lines_0[] = ",";
6489 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6494 char device[] = "/dev/sda1";
6497 r = guestfs_pvcreate (g, device);
6502 char volgroup[] = "VG";
6503 char physvols_0[] = "/dev/sda1";
6504 char *physvols[] = {
6510 r = guestfs_vgcreate (g, volgroup, physvols);
6515 char logvol[] = "LV1";
6516 char volgroup[] = "VG";
6519 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6524 char logvol[] = "LV2";
6525 char volgroup[] = "VG";
6528 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6533 char vgname[] = "VG";
6536 r = guestfs_vgremove (g, vgname);
6544 r = guestfs_vgs (g);
6548 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6552 for (i = 0; r[i] != NULL; ++i)
6559 static int test_lvremove_0_skip (void)
6563 str = getenv ("TEST_ONLY");
6565 return strstr (str, "lvremove") == NULL;
6566 str = getenv ("SKIP_TEST_LVREMOVE_0");
6567 if (str && strcmp (str, "1") == 0) return 1;
6568 str = getenv ("SKIP_TEST_LVREMOVE");
6569 if (str && strcmp (str, "1") == 0) return 1;
6573 static int test_lvremove_0 (void)
6575 if (test_lvremove_0_skip ()) {
6576 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6580 /* InitNone|InitEmpty for test_lvremove_0 */
6582 char device[] = "/dev/sda";
6585 r = guestfs_blockdev_setrw (g, device);
6592 r = guestfs_umount_all (g);
6599 r = guestfs_lvm_remove_all (g);
6603 /* TestOutputList for lvremove (0) */
6605 char device[] = "/dev/sda";
6606 char lines_0[] = ",";
6613 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6618 char device[] = "/dev/sda1";
6621 r = guestfs_pvcreate (g, device);
6626 char volgroup[] = "VG";
6627 char physvols_0[] = "/dev/sda1";
6628 char *physvols[] = {
6634 r = guestfs_vgcreate (g, volgroup, physvols);
6639 char logvol[] = "LV1";
6640 char volgroup[] = "VG";
6643 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6648 char logvol[] = "LV2";
6649 char volgroup[] = "VG";
6652 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6657 char device[] = "/dev/VG/LV1";
6660 r = guestfs_lvremove (g, device);
6668 r = guestfs_lvs (g);
6672 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6677 char expected[] = "/dev/VG/LV2";
6678 if (strcmp (r[0], expected) != 0) {
6679 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6684 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6688 for (i = 0; r[i] != NULL; ++i)
6695 static int test_lvremove_1_skip (void)
6699 str = getenv ("TEST_ONLY");
6701 return strstr (str, "lvremove") == NULL;
6702 str = getenv ("SKIP_TEST_LVREMOVE_1");
6703 if (str && strcmp (str, "1") == 0) return 1;
6704 str = getenv ("SKIP_TEST_LVREMOVE");
6705 if (str && strcmp (str, "1") == 0) return 1;
6709 static int test_lvremove_1 (void)
6711 if (test_lvremove_1_skip ()) {
6712 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6716 /* InitNone|InitEmpty for test_lvremove_1 */
6718 char device[] = "/dev/sda";
6721 r = guestfs_blockdev_setrw (g, device);
6728 r = guestfs_umount_all (g);
6735 r = guestfs_lvm_remove_all (g);
6739 /* TestOutputList for lvremove (1) */
6741 char device[] = "/dev/sda";
6742 char lines_0[] = ",";
6749 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6754 char device[] = "/dev/sda1";
6757 r = guestfs_pvcreate (g, device);
6762 char volgroup[] = "VG";
6763 char physvols_0[] = "/dev/sda1";
6764 char *physvols[] = {
6770 r = guestfs_vgcreate (g, volgroup, physvols);
6775 char logvol[] = "LV1";
6776 char volgroup[] = "VG";
6779 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6784 char logvol[] = "LV2";
6785 char volgroup[] = "VG";
6788 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6793 char device[] = "/dev/VG";
6796 r = guestfs_lvremove (g, device);
6804 r = guestfs_lvs (g);
6808 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
6812 for (i = 0; r[i] != NULL; ++i)
6819 static int test_lvremove_2_skip (void)
6823 str = getenv ("TEST_ONLY");
6825 return strstr (str, "lvremove") == NULL;
6826 str = getenv ("SKIP_TEST_LVREMOVE_2");
6827 if (str && strcmp (str, "1") == 0) return 1;
6828 str = getenv ("SKIP_TEST_LVREMOVE");
6829 if (str && strcmp (str, "1") == 0) return 1;
6833 static int test_lvremove_2 (void)
6835 if (test_lvremove_2_skip ()) {
6836 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
6840 /* InitNone|InitEmpty for test_lvremove_2 */
6842 char device[] = "/dev/sda";
6845 r = guestfs_blockdev_setrw (g, device);
6852 r = guestfs_umount_all (g);
6859 r = guestfs_lvm_remove_all (g);
6863 /* TestOutputList for lvremove (2) */
6865 char device[] = "/dev/sda";
6866 char lines_0[] = ",";
6873 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6878 char device[] = "/dev/sda1";
6881 r = guestfs_pvcreate (g, device);
6886 char volgroup[] = "VG";
6887 char physvols_0[] = "/dev/sda1";
6888 char *physvols[] = {
6894 r = guestfs_vgcreate (g, volgroup, physvols);
6899 char logvol[] = "LV1";
6900 char volgroup[] = "VG";
6903 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6908 char logvol[] = "LV2";
6909 char volgroup[] = "VG";
6912 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6917 char device[] = "/dev/VG";
6920 r = guestfs_lvremove (g, device);
6928 r = guestfs_vgs (g);
6932 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
6937 char expected[] = "VG";
6938 if (strcmp (r[0], expected) != 0) {
6939 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6944 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
6948 for (i = 0; r[i] != NULL; ++i)
6955 static int test_mount_ro_0_skip (void)
6959 str = getenv ("TEST_ONLY");
6961 return strstr (str, "mount_ro") == NULL;
6962 str = getenv ("SKIP_TEST_MOUNT_RO_0");
6963 if (str && strcmp (str, "1") == 0) return 1;
6964 str = getenv ("SKIP_TEST_MOUNT_RO");
6965 if (str && strcmp (str, "1") == 0) return 1;
6969 static int test_mount_ro_0 (void)
6971 if (test_mount_ro_0_skip ()) {
6972 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
6976 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
6978 char device[] = "/dev/sda";
6981 r = guestfs_blockdev_setrw (g, device);
6988 r = guestfs_umount_all (g);
6995 r = guestfs_lvm_remove_all (g);
7000 char device[] = "/dev/sda";
7001 char lines_0[] = ",";
7008 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7013 char fstype[] = "ext2";
7014 char device[] = "/dev/sda1";
7017 r = guestfs_mkfs (g, fstype, device);
7022 char device[] = "/dev/sda1";
7023 char mountpoint[] = "/";
7026 r = guestfs_mount (g, device, mountpoint);
7030 /* TestLastFail for mount_ro (0) */
7032 char pathordevice[] = "/";
7035 r = guestfs_umount (g, pathordevice);
7040 char device[] = "/dev/sda1";
7041 char mountpoint[] = "/";
7044 r = guestfs_mount_ro (g, device, mountpoint);
7049 char path[] = "/new";
7052 r = guestfs_touch (g, path);
7059 static int test_mount_ro_1_skip (void)
7063 str = getenv ("TEST_ONLY");
7065 return strstr (str, "mount_ro") == NULL;
7066 str = getenv ("SKIP_TEST_MOUNT_RO_1");
7067 if (str && strcmp (str, "1") == 0) return 1;
7068 str = getenv ("SKIP_TEST_MOUNT_RO");
7069 if (str && strcmp (str, "1") == 0) return 1;
7073 static int test_mount_ro_1 (void)
7075 if (test_mount_ro_1_skip ()) {
7076 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7080 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7082 char device[] = "/dev/sda";
7085 r = guestfs_blockdev_setrw (g, device);
7092 r = guestfs_umount_all (g);
7099 r = guestfs_lvm_remove_all (g);
7104 char device[] = "/dev/sda";
7105 char lines_0[] = ",";
7112 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7117 char fstype[] = "ext2";
7118 char device[] = "/dev/sda1";
7121 r = guestfs_mkfs (g, fstype, device);
7126 char device[] = "/dev/sda1";
7127 char mountpoint[] = "/";
7130 r = guestfs_mount (g, device, mountpoint);
7134 /* TestOutput for mount_ro (1) */
7135 char expected[] = "data";
7137 char path[] = "/new";
7138 char content[] = "data";
7141 r = guestfs_write_file (g, path, content, 0);
7146 char pathordevice[] = "/";
7149 r = guestfs_umount (g, pathordevice);
7154 char device[] = "/dev/sda1";
7155 char mountpoint[] = "/";
7158 r = guestfs_mount_ro (g, device, mountpoint);
7163 char path[] = "/new";
7166 r = guestfs_cat (g, path);
7169 if (strcmp (r, expected) != 0) {
7170 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7178 static int test_tgz_in_0_skip (void)
7182 str = getenv ("TEST_ONLY");
7184 return strstr (str, "tgz_in") == NULL;
7185 str = getenv ("SKIP_TEST_TGZ_IN_0");
7186 if (str && strcmp (str, "1") == 0) return 1;
7187 str = getenv ("SKIP_TEST_TGZ_IN");
7188 if (str && strcmp (str, "1") == 0) return 1;
7192 static int test_tgz_in_0 (void)
7194 if (test_tgz_in_0_skip ()) {
7195 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7199 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7201 char device[] = "/dev/sda";
7204 r = guestfs_blockdev_setrw (g, device);
7211 r = guestfs_umount_all (g);
7218 r = guestfs_lvm_remove_all (g);
7223 char device[] = "/dev/sda";
7224 char lines_0[] = ",";
7231 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7236 char fstype[] = "ext2";
7237 char device[] = "/dev/sda1";
7240 r = guestfs_mkfs (g, fstype, device);
7245 char device[] = "/dev/sda1";
7246 char mountpoint[] = "/";
7249 r = guestfs_mount (g, device, mountpoint);
7253 /* TestOutput for tgz_in (0) */
7254 char expected[] = "hello\n";
7256 char directory[] = "/";
7259 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7264 char path[] = "/hello";
7267 r = guestfs_cat (g, path);
7270 if (strcmp (r, expected) != 0) {
7271 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7279 static int test_tar_in_0_skip (void)
7283 str = getenv ("TEST_ONLY");
7285 return strstr (str, "tar_in") == NULL;
7286 str = getenv ("SKIP_TEST_TAR_IN_0");
7287 if (str && strcmp (str, "1") == 0) return 1;
7288 str = getenv ("SKIP_TEST_TAR_IN");
7289 if (str && strcmp (str, "1") == 0) return 1;
7293 static int test_tar_in_0 (void)
7295 if (test_tar_in_0_skip ()) {
7296 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7300 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7302 char device[] = "/dev/sda";
7305 r = guestfs_blockdev_setrw (g, device);
7312 r = guestfs_umount_all (g);
7319 r = guestfs_lvm_remove_all (g);
7324 char device[] = "/dev/sda";
7325 char lines_0[] = ",";
7332 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7337 char fstype[] = "ext2";
7338 char device[] = "/dev/sda1";
7341 r = guestfs_mkfs (g, fstype, device);
7346 char device[] = "/dev/sda1";
7347 char mountpoint[] = "/";
7350 r = guestfs_mount (g, device, mountpoint);
7354 /* TestOutput for tar_in (0) */
7355 char expected[] = "hello\n";
7357 char directory[] = "/";
7360 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7365 char path[] = "/hello";
7368 r = guestfs_cat (g, path);
7371 if (strcmp (r, expected) != 0) {
7372 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7380 static int test_checksum_0_skip (void)
7384 str = getenv ("TEST_ONLY");
7386 return strstr (str, "checksum") == NULL;
7387 str = getenv ("SKIP_TEST_CHECKSUM_0");
7388 if (str && strcmp (str, "1") == 0) return 1;
7389 str = getenv ("SKIP_TEST_CHECKSUM");
7390 if (str && strcmp (str, "1") == 0) return 1;
7394 static int test_checksum_0 (void)
7396 if (test_checksum_0_skip ()) {
7397 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7401 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7403 char device[] = "/dev/sda";
7406 r = guestfs_blockdev_setrw (g, device);
7413 r = guestfs_umount_all (g);
7420 r = guestfs_lvm_remove_all (g);
7425 char device[] = "/dev/sda";
7426 char lines_0[] = ",";
7433 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7438 char fstype[] = "ext2";
7439 char device[] = "/dev/sda1";
7442 r = guestfs_mkfs (g, fstype, device);
7447 char device[] = "/dev/sda1";
7448 char mountpoint[] = "/";
7451 r = guestfs_mount (g, device, mountpoint);
7455 /* TestOutput for checksum (0) */
7456 char expected[] = "935282863";
7458 char path[] = "/new";
7459 char content[] = "test\n";
7462 r = guestfs_write_file (g, path, content, 0);
7467 char csumtype[] = "crc";
7468 char path[] = "/new";
7471 r = guestfs_checksum (g, csumtype, path);
7474 if (strcmp (r, expected) != 0) {
7475 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7483 static int test_checksum_1_skip (void)
7487 str = getenv ("TEST_ONLY");
7489 return strstr (str, "checksum") == NULL;
7490 str = getenv ("SKIP_TEST_CHECKSUM_1");
7491 if (str && strcmp (str, "1") == 0) return 1;
7492 str = getenv ("SKIP_TEST_CHECKSUM");
7493 if (str && strcmp (str, "1") == 0) return 1;
7497 static int test_checksum_1 (void)
7499 if (test_checksum_1_skip ()) {
7500 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7504 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7506 char device[] = "/dev/sda";
7509 r = guestfs_blockdev_setrw (g, device);
7516 r = guestfs_umount_all (g);
7523 r = guestfs_lvm_remove_all (g);
7528 char device[] = "/dev/sda";
7529 char lines_0[] = ",";
7536 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7541 char fstype[] = "ext2";
7542 char device[] = "/dev/sda1";
7545 r = guestfs_mkfs (g, fstype, device);
7550 char device[] = "/dev/sda1";
7551 char mountpoint[] = "/";
7554 r = guestfs_mount (g, device, mountpoint);
7558 /* TestLastFail for checksum (1) */
7560 char csumtype[] = "crc";
7561 char path[] = "/new";
7564 r = guestfs_checksum (g, csumtype, path);
7572 static int test_checksum_2_skip (void)
7576 str = getenv ("TEST_ONLY");
7578 return strstr (str, "checksum") == NULL;
7579 str = getenv ("SKIP_TEST_CHECKSUM_2");
7580 if (str && strcmp (str, "1") == 0) return 1;
7581 str = getenv ("SKIP_TEST_CHECKSUM");
7582 if (str && strcmp (str, "1") == 0) return 1;
7586 static int test_checksum_2 (void)
7588 if (test_checksum_2_skip ()) {
7589 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7593 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7595 char device[] = "/dev/sda";
7598 r = guestfs_blockdev_setrw (g, device);
7605 r = guestfs_umount_all (g);
7612 r = guestfs_lvm_remove_all (g);
7617 char device[] = "/dev/sda";
7618 char lines_0[] = ",";
7625 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7630 char fstype[] = "ext2";
7631 char device[] = "/dev/sda1";
7634 r = guestfs_mkfs (g, fstype, device);
7639 char device[] = "/dev/sda1";
7640 char mountpoint[] = "/";
7643 r = guestfs_mount (g, device, mountpoint);
7647 /* TestOutput for checksum (2) */
7648 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7650 char path[] = "/new";
7651 char content[] = "test\n";
7654 r = guestfs_write_file (g, path, content, 0);
7659 char csumtype[] = "md5";
7660 char path[] = "/new";
7663 r = guestfs_checksum (g, csumtype, path);
7666 if (strcmp (r, expected) != 0) {
7667 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7675 static int test_checksum_3_skip (void)
7679 str = getenv ("TEST_ONLY");
7681 return strstr (str, "checksum") == NULL;
7682 str = getenv ("SKIP_TEST_CHECKSUM_3");
7683 if (str && strcmp (str, "1") == 0) return 1;
7684 str = getenv ("SKIP_TEST_CHECKSUM");
7685 if (str && strcmp (str, "1") == 0) return 1;
7689 static int test_checksum_3 (void)
7691 if (test_checksum_3_skip ()) {
7692 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7696 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7698 char device[] = "/dev/sda";
7701 r = guestfs_blockdev_setrw (g, device);
7708 r = guestfs_umount_all (g);
7715 r = guestfs_lvm_remove_all (g);
7720 char device[] = "/dev/sda";
7721 char lines_0[] = ",";
7728 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7733 char fstype[] = "ext2";
7734 char device[] = "/dev/sda1";
7737 r = guestfs_mkfs (g, fstype, device);
7742 char device[] = "/dev/sda1";
7743 char mountpoint[] = "/";
7746 r = guestfs_mount (g, device, mountpoint);
7750 /* TestOutput for checksum (3) */
7751 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
7753 char path[] = "/new";
7754 char content[] = "test\n";
7757 r = guestfs_write_file (g, path, content, 0);
7762 char csumtype[] = "sha1";
7763 char path[] = "/new";
7766 r = guestfs_checksum (g, csumtype, path);
7769 if (strcmp (r, expected) != 0) {
7770 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
7778 static int test_checksum_4_skip (void)
7782 str = getenv ("TEST_ONLY");
7784 return strstr (str, "checksum") == NULL;
7785 str = getenv ("SKIP_TEST_CHECKSUM_4");
7786 if (str && strcmp (str, "1") == 0) return 1;
7787 str = getenv ("SKIP_TEST_CHECKSUM");
7788 if (str && strcmp (str, "1") == 0) return 1;
7792 static int test_checksum_4 (void)
7794 if (test_checksum_4_skip ()) {
7795 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
7799 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
7801 char device[] = "/dev/sda";
7804 r = guestfs_blockdev_setrw (g, device);
7811 r = guestfs_umount_all (g);
7818 r = guestfs_lvm_remove_all (g);
7823 char device[] = "/dev/sda";
7824 char lines_0[] = ",";
7831 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7836 char fstype[] = "ext2";
7837 char device[] = "/dev/sda1";
7840 r = guestfs_mkfs (g, fstype, device);
7845 char device[] = "/dev/sda1";
7846 char mountpoint[] = "/";
7849 r = guestfs_mount (g, device, mountpoint);
7853 /* TestOutput for checksum (4) */
7854 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
7856 char path[] = "/new";
7857 char content[] = "test\n";
7860 r = guestfs_write_file (g, path, content, 0);
7865 char csumtype[] = "sha224";
7866 char path[] = "/new";
7869 r = guestfs_checksum (g, csumtype, path);
7872 if (strcmp (r, expected) != 0) {
7873 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
7881 static int test_checksum_5_skip (void)
7885 str = getenv ("TEST_ONLY");
7887 return strstr (str, "checksum") == NULL;
7888 str = getenv ("SKIP_TEST_CHECKSUM_5");
7889 if (str && strcmp (str, "1") == 0) return 1;
7890 str = getenv ("SKIP_TEST_CHECKSUM");
7891 if (str && strcmp (str, "1") == 0) return 1;
7895 static int test_checksum_5 (void)
7897 if (test_checksum_5_skip ()) {
7898 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
7902 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
7904 char device[] = "/dev/sda";
7907 r = guestfs_blockdev_setrw (g, device);
7914 r = guestfs_umount_all (g);
7921 r = guestfs_lvm_remove_all (g);
7926 char device[] = "/dev/sda";
7927 char lines_0[] = ",";
7934 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7939 char fstype[] = "ext2";
7940 char device[] = "/dev/sda1";
7943 r = guestfs_mkfs (g, fstype, device);
7948 char device[] = "/dev/sda1";
7949 char mountpoint[] = "/";
7952 r = guestfs_mount (g, device, mountpoint);
7956 /* TestOutput for checksum (5) */
7957 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
7959 char path[] = "/new";
7960 char content[] = "test\n";
7963 r = guestfs_write_file (g, path, content, 0);
7968 char csumtype[] = "sha256";
7969 char path[] = "/new";
7972 r = guestfs_checksum (g, csumtype, path);
7975 if (strcmp (r, expected) != 0) {
7976 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
7984 static int test_checksum_6_skip (void)
7988 str = getenv ("TEST_ONLY");
7990 return strstr (str, "checksum") == NULL;
7991 str = getenv ("SKIP_TEST_CHECKSUM_6");
7992 if (str && strcmp (str, "1") == 0) return 1;
7993 str = getenv ("SKIP_TEST_CHECKSUM");
7994 if (str && strcmp (str, "1") == 0) return 1;
7998 static int test_checksum_6 (void)
8000 if (test_checksum_6_skip ()) {
8001 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8005 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8007 char device[] = "/dev/sda";
8010 r = guestfs_blockdev_setrw (g, device);
8017 r = guestfs_umount_all (g);
8024 r = guestfs_lvm_remove_all (g);
8029 char device[] = "/dev/sda";
8030 char lines_0[] = ",";
8037 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8042 char fstype[] = "ext2";
8043 char device[] = "/dev/sda1";
8046 r = guestfs_mkfs (g, fstype, device);
8051 char device[] = "/dev/sda1";
8052 char mountpoint[] = "/";
8055 r = guestfs_mount (g, device, mountpoint);
8059 /* TestOutput for checksum (6) */
8060 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8062 char path[] = "/new";
8063 char content[] = "test\n";
8066 r = guestfs_write_file (g, path, content, 0);
8071 char csumtype[] = "sha384";
8072 char path[] = "/new";
8075 r = guestfs_checksum (g, csumtype, path);
8078 if (strcmp (r, expected) != 0) {
8079 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8087 static int test_checksum_7_skip (void)
8091 str = getenv ("TEST_ONLY");
8093 return strstr (str, "checksum") == NULL;
8094 str = getenv ("SKIP_TEST_CHECKSUM_7");
8095 if (str && strcmp (str, "1") == 0) return 1;
8096 str = getenv ("SKIP_TEST_CHECKSUM");
8097 if (str && strcmp (str, "1") == 0) return 1;
8101 static int test_checksum_7 (void)
8103 if (test_checksum_7_skip ()) {
8104 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8108 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8110 char device[] = "/dev/sda";
8113 r = guestfs_blockdev_setrw (g, device);
8120 r = guestfs_umount_all (g);
8127 r = guestfs_lvm_remove_all (g);
8132 char device[] = "/dev/sda";
8133 char lines_0[] = ",";
8140 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8145 char fstype[] = "ext2";
8146 char device[] = "/dev/sda1";
8149 r = guestfs_mkfs (g, fstype, device);
8154 char device[] = "/dev/sda1";
8155 char mountpoint[] = "/";
8158 r = guestfs_mount (g, device, mountpoint);
8162 /* TestOutput for checksum (7) */
8163 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8165 char path[] = "/new";
8166 char content[] = "test\n";
8169 r = guestfs_write_file (g, path, content, 0);
8174 char csumtype[] = "sha512";
8175 char path[] = "/new";
8178 r = guestfs_checksum (g, csumtype, path);
8181 if (strcmp (r, expected) != 0) {
8182 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8190 static int test_checksum_8_skip (void)
8194 str = getenv ("TEST_ONLY");
8196 return strstr (str, "checksum") == NULL;
8197 str = getenv ("SKIP_TEST_CHECKSUM_8");
8198 if (str && strcmp (str, "1") == 0) return 1;
8199 str = getenv ("SKIP_TEST_CHECKSUM");
8200 if (str && strcmp (str, "1") == 0) return 1;
8204 static int test_checksum_8 (void)
8206 if (test_checksum_8_skip ()) {
8207 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8211 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8213 char device[] = "/dev/sda";
8216 r = guestfs_blockdev_setrw (g, device);
8223 r = guestfs_umount_all (g);
8230 r = guestfs_lvm_remove_all (g);
8235 char device[] = "/dev/sda";
8236 char lines_0[] = ",";
8243 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8248 char fstype[] = "ext2";
8249 char device[] = "/dev/sda1";
8252 r = guestfs_mkfs (g, fstype, device);
8257 char device[] = "/dev/sda1";
8258 char mountpoint[] = "/";
8261 r = guestfs_mount (g, device, mountpoint);
8265 /* TestOutput for checksum (8) */
8266 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8268 char options[] = "ro";
8269 char vfstype[] = "squashfs";
8270 char device[] = "/dev/sdd";
8271 char mountpoint[] = "/";
8274 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8279 char csumtype[] = "md5";
8280 char path[] = "/known-3";
8283 r = guestfs_checksum (g, csumtype, path);
8286 if (strcmp (r, expected) != 0) {
8287 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8295 static int test_download_0_skip (void)
8299 str = getenv ("TEST_ONLY");
8301 return strstr (str, "download") == NULL;
8302 str = getenv ("SKIP_TEST_DOWNLOAD_0");
8303 if (str && strcmp (str, "1") == 0) return 1;
8304 str = getenv ("SKIP_TEST_DOWNLOAD");
8305 if (str && strcmp (str, "1") == 0) return 1;
8309 static int test_download_0 (void)
8311 if (test_download_0_skip ()) {
8312 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8316 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8318 char device[] = "/dev/sda";
8321 r = guestfs_blockdev_setrw (g, device);
8328 r = guestfs_umount_all (g);
8335 r = guestfs_lvm_remove_all (g);
8340 char device[] = "/dev/sda";
8341 char lines_0[] = ",";
8348 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8353 char fstype[] = "ext2";
8354 char device[] = "/dev/sda1";
8357 r = guestfs_mkfs (g, fstype, device);
8362 char device[] = "/dev/sda1";
8363 char mountpoint[] = "/";
8366 r = guestfs_mount (g, device, mountpoint);
8370 /* TestOutput for download (0) */
8371 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8373 char remotefilename[] = "/COPYING.LIB";
8376 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8381 char remotefilename[] = "/COPYING.LIB";
8384 r = guestfs_download (g, remotefilename, "testdownload.tmp");
8389 char remotefilename[] = "/upload";
8392 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8397 char csumtype[] = "md5";
8398 char path[] = "/upload";
8401 r = guestfs_checksum (g, csumtype, path);
8404 if (strcmp (r, expected) != 0) {
8405 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8413 static int test_upload_0_skip (void)
8417 str = getenv ("TEST_ONLY");
8419 return strstr (str, "upload") == NULL;
8420 str = getenv ("SKIP_TEST_UPLOAD_0");
8421 if (str && strcmp (str, "1") == 0) return 1;
8422 str = getenv ("SKIP_TEST_UPLOAD");
8423 if (str && strcmp (str, "1") == 0) return 1;
8427 static int test_upload_0 (void)
8429 if (test_upload_0_skip ()) {
8430 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8434 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8436 char device[] = "/dev/sda";
8439 r = guestfs_blockdev_setrw (g, device);
8446 r = guestfs_umount_all (g);
8453 r = guestfs_lvm_remove_all (g);
8458 char device[] = "/dev/sda";
8459 char lines_0[] = ",";
8466 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8471 char fstype[] = "ext2";
8472 char device[] = "/dev/sda1";
8475 r = guestfs_mkfs (g, fstype, device);
8480 char device[] = "/dev/sda1";
8481 char mountpoint[] = "/";
8484 r = guestfs_mount (g, device, mountpoint);
8488 /* TestOutput for upload (0) */
8489 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8491 char remotefilename[] = "/COPYING.LIB";
8494 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8499 char csumtype[] = "md5";
8500 char path[] = "/COPYING.LIB";
8503 r = guestfs_checksum (g, csumtype, path);
8506 if (strcmp (r, expected) != 0) {
8507 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8515 static int test_blockdev_rereadpt_0_skip (void)
8519 str = getenv ("TEST_ONLY");
8521 return strstr (str, "blockdev_rereadpt") == NULL;
8522 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8523 if (str && strcmp (str, "1") == 0) return 1;
8524 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8525 if (str && strcmp (str, "1") == 0) return 1;
8529 static int test_blockdev_rereadpt_0 (void)
8531 if (test_blockdev_rereadpt_0_skip ()) {
8532 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8536 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8538 char device[] = "/dev/sda";
8541 r = guestfs_blockdev_setrw (g, device);
8548 r = guestfs_umount_all (g);
8555 r = guestfs_lvm_remove_all (g);
8559 /* TestRun for blockdev_rereadpt (0) */
8561 char device[] = "/dev/sda";
8564 r = guestfs_blockdev_rereadpt (g, device);
8571 static int test_blockdev_flushbufs_0_skip (void)
8575 str = getenv ("TEST_ONLY");
8577 return strstr (str, "blockdev_flushbufs") == NULL;
8578 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8579 if (str && strcmp (str, "1") == 0) return 1;
8580 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8581 if (str && strcmp (str, "1") == 0) return 1;
8585 static int test_blockdev_flushbufs_0 (void)
8587 if (test_blockdev_flushbufs_0_skip ()) {
8588 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8592 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8594 char device[] = "/dev/sda";
8597 r = guestfs_blockdev_setrw (g, device);
8604 r = guestfs_umount_all (g);
8611 r = guestfs_lvm_remove_all (g);
8615 /* TestRun for blockdev_flushbufs (0) */
8617 char device[] = "/dev/sda";
8620 r = guestfs_blockdev_flushbufs (g, device);
8627 static int test_blockdev_getsize64_0_skip (void)
8631 str = getenv ("TEST_ONLY");
8633 return strstr (str, "blockdev_getsize64") == NULL;
8634 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8635 if (str && strcmp (str, "1") == 0) return 1;
8636 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8637 if (str && strcmp (str, "1") == 0) return 1;
8641 static int test_blockdev_getsize64_0 (void)
8643 if (test_blockdev_getsize64_0_skip ()) {
8644 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8648 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8650 char device[] = "/dev/sda";
8653 r = guestfs_blockdev_setrw (g, device);
8660 r = guestfs_umount_all (g);
8667 r = guestfs_lvm_remove_all (g);
8671 /* TestOutputInt for blockdev_getsize64 (0) */
8673 char device[] = "/dev/sda";
8676 r = guestfs_blockdev_getsize64 (g, device);
8679 if (r != 524288000) {
8680 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
8687 static int test_blockdev_getsz_0_skip (void)
8691 str = getenv ("TEST_ONLY");
8693 return strstr (str, "blockdev_getsz") == NULL;
8694 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8695 if (str && strcmp (str, "1") == 0) return 1;
8696 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8697 if (str && strcmp (str, "1") == 0) return 1;
8701 static int test_blockdev_getsz_0 (void)
8703 if (test_blockdev_getsz_0_skip ()) {
8704 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8708 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8710 char device[] = "/dev/sda";
8713 r = guestfs_blockdev_setrw (g, device);
8720 r = guestfs_umount_all (g);
8727 r = guestfs_lvm_remove_all (g);
8731 /* TestOutputInt for blockdev_getsz (0) */
8733 char device[] = "/dev/sda";
8736 r = guestfs_blockdev_getsz (g, device);
8740 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
8747 static int test_blockdev_getbsz_0_skip (void)
8751 str = getenv ("TEST_ONLY");
8753 return strstr (str, "blockdev_getbsz") == NULL;
8754 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
8755 if (str && strcmp (str, "1") == 0) return 1;
8756 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
8757 if (str && strcmp (str, "1") == 0) return 1;
8761 static int test_blockdev_getbsz_0 (void)
8763 if (test_blockdev_getbsz_0_skip ()) {
8764 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
8768 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
8770 char device[] = "/dev/sda";
8773 r = guestfs_blockdev_setrw (g, device);
8780 r = guestfs_umount_all (g);
8787 r = guestfs_lvm_remove_all (g);
8791 /* TestOutputInt for blockdev_getbsz (0) */
8793 char device[] = "/dev/sda";
8796 r = guestfs_blockdev_getbsz (g, device);
8800 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
8807 static int test_blockdev_getss_0_skip (void)
8811 str = getenv ("TEST_ONLY");
8813 return strstr (str, "blockdev_getss") == NULL;
8814 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
8815 if (str && strcmp (str, "1") == 0) return 1;
8816 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
8817 if (str && strcmp (str, "1") == 0) return 1;
8821 static int test_blockdev_getss_0 (void)
8823 if (test_blockdev_getss_0_skip ()) {
8824 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
8828 /* InitNone|InitEmpty for test_blockdev_getss_0 */
8830 char device[] = "/dev/sda";
8833 r = guestfs_blockdev_setrw (g, device);
8840 r = guestfs_umount_all (g);
8847 r = guestfs_lvm_remove_all (g);
8851 /* TestOutputInt for blockdev_getss (0) */
8853 char device[] = "/dev/sda";
8856 r = guestfs_blockdev_getss (g, device);
8860 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
8867 static int test_blockdev_getro_0_skip (void)
8871 str = getenv ("TEST_ONLY");
8873 return strstr (str, "blockdev_getro") == NULL;
8874 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
8875 if (str && strcmp (str, "1") == 0) return 1;
8876 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
8877 if (str && strcmp (str, "1") == 0) return 1;
8881 static int test_blockdev_getro_0 (void)
8883 if (test_blockdev_getro_0_skip ()) {
8884 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
8888 /* InitNone|InitEmpty for test_blockdev_getro_0 */
8890 char device[] = "/dev/sda";
8893 r = guestfs_blockdev_setrw (g, device);
8900 r = guestfs_umount_all (g);
8907 r = guestfs_lvm_remove_all (g);
8911 /* TestOutputTrue for blockdev_getro (0) */
8913 char device[] = "/dev/sda";
8916 r = guestfs_blockdev_setro (g, device);
8921 char device[] = "/dev/sda";
8924 r = guestfs_blockdev_getro (g, device);
8928 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
8935 static int test_blockdev_setrw_0_skip (void)
8939 str = getenv ("TEST_ONLY");
8941 return strstr (str, "blockdev_setrw") == NULL;
8942 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
8943 if (str && strcmp (str, "1") == 0) return 1;
8944 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
8945 if (str && strcmp (str, "1") == 0) return 1;
8949 static int test_blockdev_setrw_0 (void)
8951 if (test_blockdev_setrw_0_skip ()) {
8952 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
8956 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
8958 char device[] = "/dev/sda";
8961 r = guestfs_blockdev_setrw (g, device);
8968 r = guestfs_umount_all (g);
8975 r = guestfs_lvm_remove_all (g);
8979 /* TestOutputFalse for blockdev_setrw (0) */
8981 char device[] = "/dev/sda";
8984 r = guestfs_blockdev_setrw (g, device);
8989 char device[] = "/dev/sda";
8992 r = guestfs_blockdev_getro (g, device);
8996 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9003 static int test_blockdev_setro_0_skip (void)
9007 str = getenv ("TEST_ONLY");
9009 return strstr (str, "blockdev_setro") == NULL;
9010 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9011 if (str && strcmp (str, "1") == 0) return 1;
9012 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9013 if (str && strcmp (str, "1") == 0) return 1;
9017 static int test_blockdev_setro_0 (void)
9019 if (test_blockdev_setro_0_skip ()) {
9020 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9024 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9026 char device[] = "/dev/sda";
9029 r = guestfs_blockdev_setrw (g, device);
9036 r = guestfs_umount_all (g);
9043 r = guestfs_lvm_remove_all (g);
9047 /* TestOutputTrue for blockdev_setro (0) */
9049 char device[] = "/dev/sda";
9052 r = guestfs_blockdev_setro (g, device);
9057 char device[] = "/dev/sda";
9060 r = guestfs_blockdev_getro (g, device);
9064 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9071 static int test_statvfs_0_skip (void)
9075 str = getenv ("TEST_ONLY");
9077 return strstr (str, "statvfs") == NULL;
9078 str = getenv ("SKIP_TEST_STATVFS_0");
9079 if (str && strcmp (str, "1") == 0) return 1;
9080 str = getenv ("SKIP_TEST_STATVFS");
9081 if (str && strcmp (str, "1") == 0) return 1;
9085 static int test_statvfs_0 (void)
9087 if (test_statvfs_0_skip ()) {
9088 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9092 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9094 char device[] = "/dev/sda";
9097 r = guestfs_blockdev_setrw (g, device);
9104 r = guestfs_umount_all (g);
9111 r = guestfs_lvm_remove_all (g);
9116 char device[] = "/dev/sda";
9117 char lines_0[] = ",";
9124 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9129 char fstype[] = "ext2";
9130 char device[] = "/dev/sda1";
9133 r = guestfs_mkfs (g, fstype, device);
9138 char device[] = "/dev/sda1";
9139 char mountpoint[] = "/";
9142 r = guestfs_mount (g, device, mountpoint);
9146 /* TestOutputStruct for statvfs (0) */
9149 struct guestfs_statvfs *r;
9151 r = guestfs_statvfs (g, path);
9154 if (r->bfree != 487702) {
9155 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9159 if (r->blocks != 490020) {
9160 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9164 if (r->bsize != 1024) {
9165 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9174 static int test_lstat_0_skip (void)
9178 str = getenv ("TEST_ONLY");
9180 return strstr (str, "lstat") == NULL;
9181 str = getenv ("SKIP_TEST_LSTAT_0");
9182 if (str && strcmp (str, "1") == 0) return 1;
9183 str = getenv ("SKIP_TEST_LSTAT");
9184 if (str && strcmp (str, "1") == 0) return 1;
9188 static int test_lstat_0 (void)
9190 if (test_lstat_0_skip ()) {
9191 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9195 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9197 char device[] = "/dev/sda";
9200 r = guestfs_blockdev_setrw (g, device);
9207 r = guestfs_umount_all (g);
9214 r = guestfs_lvm_remove_all (g);
9219 char device[] = "/dev/sda";
9220 char lines_0[] = ",";
9227 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9232 char fstype[] = "ext2";
9233 char device[] = "/dev/sda1";
9236 r = guestfs_mkfs (g, fstype, device);
9241 char device[] = "/dev/sda1";
9242 char mountpoint[] = "/";
9245 r = guestfs_mount (g, device, mountpoint);
9249 /* TestOutputStruct for lstat (0) */
9251 char path[] = "/new";
9254 r = guestfs_touch (g, path);
9259 char path[] = "/new";
9260 struct guestfs_stat *r;
9262 r = guestfs_lstat (g, path);
9266 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9275 static int test_stat_0_skip (void)
9279 str = getenv ("TEST_ONLY");
9281 return strstr (str, "stat") == NULL;
9282 str = getenv ("SKIP_TEST_STAT_0");
9283 if (str && strcmp (str, "1") == 0) return 1;
9284 str = getenv ("SKIP_TEST_STAT");
9285 if (str && strcmp (str, "1") == 0) return 1;
9289 static int test_stat_0 (void)
9291 if (test_stat_0_skip ()) {
9292 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9296 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9298 char device[] = "/dev/sda";
9301 r = guestfs_blockdev_setrw (g, device);
9308 r = guestfs_umount_all (g);
9315 r = guestfs_lvm_remove_all (g);
9320 char device[] = "/dev/sda";
9321 char lines_0[] = ",";
9328 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9333 char fstype[] = "ext2";
9334 char device[] = "/dev/sda1";
9337 r = guestfs_mkfs (g, fstype, device);
9342 char device[] = "/dev/sda1";
9343 char mountpoint[] = "/";
9346 r = guestfs_mount (g, device, mountpoint);
9350 /* TestOutputStruct for stat (0) */
9352 char path[] = "/new";
9355 r = guestfs_touch (g, path);
9360 char path[] = "/new";
9361 struct guestfs_stat *r;
9363 r = guestfs_stat (g, path);
9367 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9376 static int test_command_lines_0_skip (void)
9380 str = getenv ("TEST_ONLY");
9382 return strstr (str, "command_lines") == NULL;
9383 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9384 if (str && strcmp (str, "1") == 0) return 1;
9385 str = getenv ("SKIP_TEST_COMMAND_LINES");
9386 if (str && strcmp (str, "1") == 0) return 1;
9390 static int test_command_lines_0 (void)
9392 if (test_command_lines_0_skip ()) {
9393 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9397 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9399 char device[] = "/dev/sda";
9402 r = guestfs_blockdev_setrw (g, device);
9409 r = guestfs_umount_all (g);
9416 r = guestfs_lvm_remove_all (g);
9421 char device[] = "/dev/sda";
9422 char lines_0[] = ",";
9429 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9434 char fstype[] = "ext2";
9435 char device[] = "/dev/sda1";
9438 r = guestfs_mkfs (g, fstype, device);
9443 char device[] = "/dev/sda1";
9444 char mountpoint[] = "/";
9447 r = guestfs_mount (g, device, mountpoint);
9451 /* TestOutputList for command_lines (0) */
9453 char remotefilename[] = "/test-command";
9456 r = guestfs_upload (g, "test-command", remotefilename);
9461 char path[] = "/test-command";
9464 r = guestfs_chmod (g, 493, path);
9469 char arguments_0[] = "/test-command";
9470 char arguments_1[] = "1";
9471 char *arguments[] = {
9479 r = guestfs_command_lines (g, arguments);
9483 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9488 char expected[] = "Result1";
9489 if (strcmp (r[0], expected) != 0) {
9490 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9495 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9499 for (i = 0; r[i] != NULL; ++i)
9506 static int test_command_lines_1_skip (void)
9510 str = getenv ("TEST_ONLY");
9512 return strstr (str, "command_lines") == NULL;
9513 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9514 if (str && strcmp (str, "1") == 0) return 1;
9515 str = getenv ("SKIP_TEST_COMMAND_LINES");
9516 if (str && strcmp (str, "1") == 0) return 1;
9520 static int test_command_lines_1 (void)
9522 if (test_command_lines_1_skip ()) {
9523 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9527 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9529 char device[] = "/dev/sda";
9532 r = guestfs_blockdev_setrw (g, device);
9539 r = guestfs_umount_all (g);
9546 r = guestfs_lvm_remove_all (g);
9551 char device[] = "/dev/sda";
9552 char lines_0[] = ",";
9559 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9564 char fstype[] = "ext2";
9565 char device[] = "/dev/sda1";
9568 r = guestfs_mkfs (g, fstype, device);
9573 char device[] = "/dev/sda1";
9574 char mountpoint[] = "/";
9577 r = guestfs_mount (g, device, mountpoint);
9581 /* TestOutputList for command_lines (1) */
9583 char remotefilename[] = "/test-command";
9586 r = guestfs_upload (g, "test-command", remotefilename);
9591 char path[] = "/test-command";
9594 r = guestfs_chmod (g, 493, path);
9599 char arguments_0[] = "/test-command";
9600 char arguments_1[] = "2";
9601 char *arguments[] = {
9609 r = guestfs_command_lines (g, arguments);
9613 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9618 char expected[] = "Result2";
9619 if (strcmp (r[0], expected) != 0) {
9620 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9625 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9629 for (i = 0; r[i] != NULL; ++i)
9636 static int test_command_lines_2_skip (void)
9640 str = getenv ("TEST_ONLY");
9642 return strstr (str, "command_lines") == NULL;
9643 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9644 if (str && strcmp (str, "1") == 0) return 1;
9645 str = getenv ("SKIP_TEST_COMMAND_LINES");
9646 if (str && strcmp (str, "1") == 0) return 1;
9650 static int test_command_lines_2 (void)
9652 if (test_command_lines_2_skip ()) {
9653 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9657 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9659 char device[] = "/dev/sda";
9662 r = guestfs_blockdev_setrw (g, device);
9669 r = guestfs_umount_all (g);
9676 r = guestfs_lvm_remove_all (g);
9681 char device[] = "/dev/sda";
9682 char lines_0[] = ",";
9689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9694 char fstype[] = "ext2";
9695 char device[] = "/dev/sda1";
9698 r = guestfs_mkfs (g, fstype, device);
9703 char device[] = "/dev/sda1";
9704 char mountpoint[] = "/";
9707 r = guestfs_mount (g, device, mountpoint);
9711 /* TestOutputList for command_lines (2) */
9713 char remotefilename[] = "/test-command";
9716 r = guestfs_upload (g, "test-command", remotefilename);
9721 char path[] = "/test-command";
9724 r = guestfs_chmod (g, 493, path);
9729 char arguments_0[] = "/test-command";
9730 char arguments_1[] = "3";
9731 char *arguments[] = {
9739 r = guestfs_command_lines (g, arguments);
9743 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9748 char expected[] = "";
9749 if (strcmp (r[0], expected) != 0) {
9750 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9755 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9760 char expected[] = "Result3";
9761 if (strcmp (r[1], expected) != 0) {
9762 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9767 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
9771 for (i = 0; r[i] != NULL; ++i)
9778 static int test_command_lines_3_skip (void)
9782 str = getenv ("TEST_ONLY");
9784 return strstr (str, "command_lines") == NULL;
9785 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
9786 if (str && strcmp (str, "1") == 0) return 1;
9787 str = getenv ("SKIP_TEST_COMMAND_LINES");
9788 if (str && strcmp (str, "1") == 0) return 1;
9792 static int test_command_lines_3 (void)
9794 if (test_command_lines_3_skip ()) {
9795 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
9799 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
9801 char device[] = "/dev/sda";
9804 r = guestfs_blockdev_setrw (g, device);
9811 r = guestfs_umount_all (g);
9818 r = guestfs_lvm_remove_all (g);
9823 char device[] = "/dev/sda";
9824 char lines_0[] = ",";
9831 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9836 char fstype[] = "ext2";
9837 char device[] = "/dev/sda1";
9840 r = guestfs_mkfs (g, fstype, device);
9845 char device[] = "/dev/sda1";
9846 char mountpoint[] = "/";
9849 r = guestfs_mount (g, device, mountpoint);
9853 /* TestOutputList for command_lines (3) */
9855 char remotefilename[] = "/test-command";
9858 r = guestfs_upload (g, "test-command", remotefilename);
9863 char path[] = "/test-command";
9866 r = guestfs_chmod (g, 493, path);
9871 char arguments_0[] = "/test-command";
9872 char arguments_1[] = "4";
9873 char *arguments[] = {
9881 r = guestfs_command_lines (g, arguments);
9885 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9890 char expected[] = "";
9891 if (strcmp (r[0], expected) != 0) {
9892 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9897 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9902 char expected[] = "Result4";
9903 if (strcmp (r[1], expected) != 0) {
9904 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9909 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
9913 for (i = 0; r[i] != NULL; ++i)
9920 static int test_command_lines_4_skip (void)
9924 str = getenv ("TEST_ONLY");
9926 return strstr (str, "command_lines") == NULL;
9927 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
9928 if (str && strcmp (str, "1") == 0) return 1;
9929 str = getenv ("SKIP_TEST_COMMAND_LINES");
9930 if (str && strcmp (str, "1") == 0) return 1;
9934 static int test_command_lines_4 (void)
9936 if (test_command_lines_4_skip ()) {
9937 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
9941 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
9943 char device[] = "/dev/sda";
9946 r = guestfs_blockdev_setrw (g, device);
9953 r = guestfs_umount_all (g);
9960 r = guestfs_lvm_remove_all (g);
9965 char device[] = "/dev/sda";
9966 char lines_0[] = ",";
9973 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9978 char fstype[] = "ext2";
9979 char device[] = "/dev/sda1";
9982 r = guestfs_mkfs (g, fstype, device);
9987 char device[] = "/dev/sda1";
9988 char mountpoint[] = "/";
9991 r = guestfs_mount (g, device, mountpoint);
9995 /* TestOutputList for command_lines (4) */
9997 char remotefilename[] = "/test-command";
10000 r = guestfs_upload (g, "test-command", remotefilename);
10005 char path[] = "/test-command";
10007 suppress_error = 0;
10008 r = guestfs_chmod (g, 493, path);
10013 char arguments_0[] = "/test-command";
10014 char arguments_1[] = "5";
10015 char *arguments[] = {
10022 suppress_error = 0;
10023 r = guestfs_command_lines (g, arguments);
10027 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10032 char expected[] = "";
10033 if (strcmp (r[0], expected) != 0) {
10034 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10039 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10044 char expected[] = "Result5";
10045 if (strcmp (r[1], expected) != 0) {
10046 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10051 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10056 char expected[] = "";
10057 if (strcmp (r[2], expected) != 0) {
10058 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10062 if (r[3] != NULL) {
10063 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10067 for (i = 0; r[i] != NULL; ++i)
10074 static int test_command_lines_5_skip (void)
10078 str = getenv ("TEST_ONLY");
10080 return strstr (str, "command_lines") == NULL;
10081 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10082 if (str && strcmp (str, "1") == 0) return 1;
10083 str = getenv ("SKIP_TEST_COMMAND_LINES");
10084 if (str && strcmp (str, "1") == 0) return 1;
10088 static int test_command_lines_5 (void)
10090 if (test_command_lines_5_skip ()) {
10091 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10095 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10097 char device[] = "/dev/sda";
10099 suppress_error = 0;
10100 r = guestfs_blockdev_setrw (g, device);
10106 suppress_error = 0;
10107 r = guestfs_umount_all (g);
10113 suppress_error = 0;
10114 r = guestfs_lvm_remove_all (g);
10119 char device[] = "/dev/sda";
10120 char lines_0[] = ",";
10126 suppress_error = 0;
10127 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10132 char fstype[] = "ext2";
10133 char device[] = "/dev/sda1";
10135 suppress_error = 0;
10136 r = guestfs_mkfs (g, fstype, device);
10141 char device[] = "/dev/sda1";
10142 char mountpoint[] = "/";
10144 suppress_error = 0;
10145 r = guestfs_mount (g, device, mountpoint);
10149 /* TestOutputList for command_lines (5) */
10151 char remotefilename[] = "/test-command";
10153 suppress_error = 0;
10154 r = guestfs_upload (g, "test-command", remotefilename);
10159 char path[] = "/test-command";
10161 suppress_error = 0;
10162 r = guestfs_chmod (g, 493, path);
10167 char arguments_0[] = "/test-command";
10168 char arguments_1[] = "6";
10169 char *arguments[] = {
10176 suppress_error = 0;
10177 r = guestfs_command_lines (g, arguments);
10181 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10186 char expected[] = "";
10187 if (strcmp (r[0], expected) != 0) {
10188 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10193 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10198 char expected[] = "";
10199 if (strcmp (r[1], expected) != 0) {
10200 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10205 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10210 char expected[] = "Result6";
10211 if (strcmp (r[2], expected) != 0) {
10212 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10217 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10222 char expected[] = "";
10223 if (strcmp (r[3], expected) != 0) {
10224 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10228 if (r[4] != NULL) {
10229 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10233 for (i = 0; r[i] != NULL; ++i)
10240 static int test_command_lines_6_skip (void)
10244 str = getenv ("TEST_ONLY");
10246 return strstr (str, "command_lines") == NULL;
10247 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10248 if (str && strcmp (str, "1") == 0) return 1;
10249 str = getenv ("SKIP_TEST_COMMAND_LINES");
10250 if (str && strcmp (str, "1") == 0) return 1;
10254 static int test_command_lines_6 (void)
10256 if (test_command_lines_6_skip ()) {
10257 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10261 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10263 char device[] = "/dev/sda";
10265 suppress_error = 0;
10266 r = guestfs_blockdev_setrw (g, device);
10272 suppress_error = 0;
10273 r = guestfs_umount_all (g);
10279 suppress_error = 0;
10280 r = guestfs_lvm_remove_all (g);
10285 char device[] = "/dev/sda";
10286 char lines_0[] = ",";
10292 suppress_error = 0;
10293 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10298 char fstype[] = "ext2";
10299 char device[] = "/dev/sda1";
10301 suppress_error = 0;
10302 r = guestfs_mkfs (g, fstype, device);
10307 char device[] = "/dev/sda1";
10308 char mountpoint[] = "/";
10310 suppress_error = 0;
10311 r = guestfs_mount (g, device, mountpoint);
10315 /* TestOutputList for command_lines (6) */
10317 char remotefilename[] = "/test-command";
10319 suppress_error = 0;
10320 r = guestfs_upload (g, "test-command", remotefilename);
10325 char path[] = "/test-command";
10327 suppress_error = 0;
10328 r = guestfs_chmod (g, 493, path);
10333 char arguments_0[] = "/test-command";
10334 char arguments_1[] = "7";
10335 char *arguments[] = {
10342 suppress_error = 0;
10343 r = guestfs_command_lines (g, arguments);
10346 if (r[0] != NULL) {
10347 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10351 for (i = 0; r[i] != NULL; ++i)
10358 static int test_command_lines_7_skip (void)
10362 str = getenv ("TEST_ONLY");
10364 return strstr (str, "command_lines") == NULL;
10365 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10366 if (str && strcmp (str, "1") == 0) return 1;
10367 str = getenv ("SKIP_TEST_COMMAND_LINES");
10368 if (str && strcmp (str, "1") == 0) return 1;
10372 static int test_command_lines_7 (void)
10374 if (test_command_lines_7_skip ()) {
10375 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10379 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10381 char device[] = "/dev/sda";
10383 suppress_error = 0;
10384 r = guestfs_blockdev_setrw (g, device);
10390 suppress_error = 0;
10391 r = guestfs_umount_all (g);
10397 suppress_error = 0;
10398 r = guestfs_lvm_remove_all (g);
10403 char device[] = "/dev/sda";
10404 char lines_0[] = ",";
10410 suppress_error = 0;
10411 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10416 char fstype[] = "ext2";
10417 char device[] = "/dev/sda1";
10419 suppress_error = 0;
10420 r = guestfs_mkfs (g, fstype, device);
10425 char device[] = "/dev/sda1";
10426 char mountpoint[] = "/";
10428 suppress_error = 0;
10429 r = guestfs_mount (g, device, mountpoint);
10433 /* TestOutputList for command_lines (7) */
10435 char remotefilename[] = "/test-command";
10437 suppress_error = 0;
10438 r = guestfs_upload (g, "test-command", remotefilename);
10443 char path[] = "/test-command";
10445 suppress_error = 0;
10446 r = guestfs_chmod (g, 493, path);
10451 char arguments_0[] = "/test-command";
10452 char arguments_1[] = "8";
10453 char *arguments[] = {
10460 suppress_error = 0;
10461 r = guestfs_command_lines (g, arguments);
10465 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10470 char expected[] = "";
10471 if (strcmp (r[0], expected) != 0) {
10472 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10476 if (r[1] != NULL) {
10477 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10481 for (i = 0; r[i] != NULL; ++i)
10488 static int test_command_lines_8_skip (void)
10492 str = getenv ("TEST_ONLY");
10494 return strstr (str, "command_lines") == NULL;
10495 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10496 if (str && strcmp (str, "1") == 0) return 1;
10497 str = getenv ("SKIP_TEST_COMMAND_LINES");
10498 if (str && strcmp (str, "1") == 0) return 1;
10502 static int test_command_lines_8 (void)
10504 if (test_command_lines_8_skip ()) {
10505 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10509 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10511 char device[] = "/dev/sda";
10513 suppress_error = 0;
10514 r = guestfs_blockdev_setrw (g, device);
10520 suppress_error = 0;
10521 r = guestfs_umount_all (g);
10527 suppress_error = 0;
10528 r = guestfs_lvm_remove_all (g);
10533 char device[] = "/dev/sda";
10534 char lines_0[] = ",";
10540 suppress_error = 0;
10541 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10546 char fstype[] = "ext2";
10547 char device[] = "/dev/sda1";
10549 suppress_error = 0;
10550 r = guestfs_mkfs (g, fstype, device);
10555 char device[] = "/dev/sda1";
10556 char mountpoint[] = "/";
10558 suppress_error = 0;
10559 r = guestfs_mount (g, device, mountpoint);
10563 /* TestOutputList for command_lines (8) */
10565 char remotefilename[] = "/test-command";
10567 suppress_error = 0;
10568 r = guestfs_upload (g, "test-command", remotefilename);
10573 char path[] = "/test-command";
10575 suppress_error = 0;
10576 r = guestfs_chmod (g, 493, path);
10581 char arguments_0[] = "/test-command";
10582 char arguments_1[] = "9";
10583 char *arguments[] = {
10590 suppress_error = 0;
10591 r = guestfs_command_lines (g, arguments);
10595 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10600 char expected[] = "";
10601 if (strcmp (r[0], expected) != 0) {
10602 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10607 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10612 char expected[] = "";
10613 if (strcmp (r[1], expected) != 0) {
10614 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10618 if (r[2] != NULL) {
10619 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10623 for (i = 0; r[i] != NULL; ++i)
10630 static int test_command_lines_9_skip (void)
10634 str = getenv ("TEST_ONLY");
10636 return strstr (str, "command_lines") == NULL;
10637 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10638 if (str && strcmp (str, "1") == 0) return 1;
10639 str = getenv ("SKIP_TEST_COMMAND_LINES");
10640 if (str && strcmp (str, "1") == 0) return 1;
10644 static int test_command_lines_9 (void)
10646 if (test_command_lines_9_skip ()) {
10647 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10651 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10653 char device[] = "/dev/sda";
10655 suppress_error = 0;
10656 r = guestfs_blockdev_setrw (g, device);
10662 suppress_error = 0;
10663 r = guestfs_umount_all (g);
10669 suppress_error = 0;
10670 r = guestfs_lvm_remove_all (g);
10675 char device[] = "/dev/sda";
10676 char lines_0[] = ",";
10682 suppress_error = 0;
10683 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10688 char fstype[] = "ext2";
10689 char device[] = "/dev/sda1";
10691 suppress_error = 0;
10692 r = guestfs_mkfs (g, fstype, device);
10697 char device[] = "/dev/sda1";
10698 char mountpoint[] = "/";
10700 suppress_error = 0;
10701 r = guestfs_mount (g, device, mountpoint);
10705 /* TestOutputList for command_lines (9) */
10707 char remotefilename[] = "/test-command";
10709 suppress_error = 0;
10710 r = guestfs_upload (g, "test-command", remotefilename);
10715 char path[] = "/test-command";
10717 suppress_error = 0;
10718 r = guestfs_chmod (g, 493, path);
10723 char arguments_0[] = "/test-command";
10724 char arguments_1[] = "10";
10725 char *arguments[] = {
10732 suppress_error = 0;
10733 r = guestfs_command_lines (g, arguments);
10737 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10742 char expected[] = "Result10-1";
10743 if (strcmp (r[0], expected) != 0) {
10744 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10749 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10754 char expected[] = "Result10-2";
10755 if (strcmp (r[1], expected) != 0) {
10756 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10760 if (r[2] != NULL) {
10761 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
10765 for (i = 0; r[i] != NULL; ++i)
10772 static int test_command_lines_10_skip (void)
10776 str = getenv ("TEST_ONLY");
10778 return strstr (str, "command_lines") == NULL;
10779 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
10780 if (str && strcmp (str, "1") == 0) return 1;
10781 str = getenv ("SKIP_TEST_COMMAND_LINES");
10782 if (str && strcmp (str, "1") == 0) return 1;
10786 static int test_command_lines_10 (void)
10788 if (test_command_lines_10_skip ()) {
10789 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
10793 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
10795 char device[] = "/dev/sda";
10797 suppress_error = 0;
10798 r = guestfs_blockdev_setrw (g, device);
10804 suppress_error = 0;
10805 r = guestfs_umount_all (g);
10811 suppress_error = 0;
10812 r = guestfs_lvm_remove_all (g);
10817 char device[] = "/dev/sda";
10818 char lines_0[] = ",";
10824 suppress_error = 0;
10825 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10830 char fstype[] = "ext2";
10831 char device[] = "/dev/sda1";
10833 suppress_error = 0;
10834 r = guestfs_mkfs (g, fstype, device);
10839 char device[] = "/dev/sda1";
10840 char mountpoint[] = "/";
10842 suppress_error = 0;
10843 r = guestfs_mount (g, device, mountpoint);
10847 /* TestOutputList for command_lines (10) */
10849 char remotefilename[] = "/test-command";
10851 suppress_error = 0;
10852 r = guestfs_upload (g, "test-command", remotefilename);
10857 char path[] = "/test-command";
10859 suppress_error = 0;
10860 r = guestfs_chmod (g, 493, path);
10865 char arguments_0[] = "/test-command";
10866 char arguments_1[] = "11";
10867 char *arguments[] = {
10874 suppress_error = 0;
10875 r = guestfs_command_lines (g, arguments);
10879 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10884 char expected[] = "Result11-1";
10885 if (strcmp (r[0], expected) != 0) {
10886 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10891 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10896 char expected[] = "Result11-2";
10897 if (strcmp (r[1], expected) != 0) {
10898 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10902 if (r[2] != NULL) {
10903 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
10907 for (i = 0; r[i] != NULL; ++i)
10914 static int test_command_0_skip (void)
10918 str = getenv ("TEST_ONLY");
10920 return strstr (str, "command") == NULL;
10921 str = getenv ("SKIP_TEST_COMMAND_0");
10922 if (str && strcmp (str, "1") == 0) return 1;
10923 str = getenv ("SKIP_TEST_COMMAND");
10924 if (str && strcmp (str, "1") == 0) return 1;
10928 static int test_command_0 (void)
10930 if (test_command_0_skip ()) {
10931 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
10935 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
10937 char device[] = "/dev/sda";
10939 suppress_error = 0;
10940 r = guestfs_blockdev_setrw (g, device);
10946 suppress_error = 0;
10947 r = guestfs_umount_all (g);
10953 suppress_error = 0;
10954 r = guestfs_lvm_remove_all (g);
10959 char device[] = "/dev/sda";
10960 char lines_0[] = ",";
10966 suppress_error = 0;
10967 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10972 char fstype[] = "ext2";
10973 char device[] = "/dev/sda1";
10975 suppress_error = 0;
10976 r = guestfs_mkfs (g, fstype, device);
10981 char device[] = "/dev/sda1";
10982 char mountpoint[] = "/";
10984 suppress_error = 0;
10985 r = guestfs_mount (g, device, mountpoint);
10989 /* TestOutput for command (0) */
10990 char expected[] = "Result1";
10992 char remotefilename[] = "/test-command";
10994 suppress_error = 0;
10995 r = guestfs_upload (g, "test-command", remotefilename);
11000 char path[] = "/test-command";
11002 suppress_error = 0;
11003 r = guestfs_chmod (g, 493, path);
11008 char arguments_0[] = "/test-command";
11009 char arguments_1[] = "1";
11010 char *arguments[] = {
11016 suppress_error = 0;
11017 r = guestfs_command (g, arguments);
11020 if (strcmp (r, expected) != 0) {
11021 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11029 static int test_command_1_skip (void)
11033 str = getenv ("TEST_ONLY");
11035 return strstr (str, "command") == NULL;
11036 str = getenv ("SKIP_TEST_COMMAND_1");
11037 if (str && strcmp (str, "1") == 0) return 1;
11038 str = getenv ("SKIP_TEST_COMMAND");
11039 if (str && strcmp (str, "1") == 0) return 1;
11043 static int test_command_1 (void)
11045 if (test_command_1_skip ()) {
11046 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11050 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11052 char device[] = "/dev/sda";
11054 suppress_error = 0;
11055 r = guestfs_blockdev_setrw (g, device);
11061 suppress_error = 0;
11062 r = guestfs_umount_all (g);
11068 suppress_error = 0;
11069 r = guestfs_lvm_remove_all (g);
11074 char device[] = "/dev/sda";
11075 char lines_0[] = ",";
11081 suppress_error = 0;
11082 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11087 char fstype[] = "ext2";
11088 char device[] = "/dev/sda1";
11090 suppress_error = 0;
11091 r = guestfs_mkfs (g, fstype, device);
11096 char device[] = "/dev/sda1";
11097 char mountpoint[] = "/";
11099 suppress_error = 0;
11100 r = guestfs_mount (g, device, mountpoint);
11104 /* TestOutput for command (1) */
11105 char expected[] = "Result2\n";
11107 char remotefilename[] = "/test-command";
11109 suppress_error = 0;
11110 r = guestfs_upload (g, "test-command", remotefilename);
11115 char path[] = "/test-command";
11117 suppress_error = 0;
11118 r = guestfs_chmod (g, 493, path);
11123 char arguments_0[] = "/test-command";
11124 char arguments_1[] = "2";
11125 char *arguments[] = {
11131 suppress_error = 0;
11132 r = guestfs_command (g, arguments);
11135 if (strcmp (r, expected) != 0) {
11136 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11144 static int test_command_2_skip (void)
11148 str = getenv ("TEST_ONLY");
11150 return strstr (str, "command") == NULL;
11151 str = getenv ("SKIP_TEST_COMMAND_2");
11152 if (str && strcmp (str, "1") == 0) return 1;
11153 str = getenv ("SKIP_TEST_COMMAND");
11154 if (str && strcmp (str, "1") == 0) return 1;
11158 static int test_command_2 (void)
11160 if (test_command_2_skip ()) {
11161 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11165 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11167 char device[] = "/dev/sda";
11169 suppress_error = 0;
11170 r = guestfs_blockdev_setrw (g, device);
11176 suppress_error = 0;
11177 r = guestfs_umount_all (g);
11183 suppress_error = 0;
11184 r = guestfs_lvm_remove_all (g);
11189 char device[] = "/dev/sda";
11190 char lines_0[] = ",";
11196 suppress_error = 0;
11197 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11202 char fstype[] = "ext2";
11203 char device[] = "/dev/sda1";
11205 suppress_error = 0;
11206 r = guestfs_mkfs (g, fstype, device);
11211 char device[] = "/dev/sda1";
11212 char mountpoint[] = "/";
11214 suppress_error = 0;
11215 r = guestfs_mount (g, device, mountpoint);
11219 /* TestOutput for command (2) */
11220 char expected[] = "\nResult3";
11222 char remotefilename[] = "/test-command";
11224 suppress_error = 0;
11225 r = guestfs_upload (g, "test-command", remotefilename);
11230 char path[] = "/test-command";
11232 suppress_error = 0;
11233 r = guestfs_chmod (g, 493, path);
11238 char arguments_0[] = "/test-command";
11239 char arguments_1[] = "3";
11240 char *arguments[] = {
11246 suppress_error = 0;
11247 r = guestfs_command (g, arguments);
11250 if (strcmp (r, expected) != 0) {
11251 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11259 static int test_command_3_skip (void)
11263 str = getenv ("TEST_ONLY");
11265 return strstr (str, "command") == NULL;
11266 str = getenv ("SKIP_TEST_COMMAND_3");
11267 if (str && strcmp (str, "1") == 0) return 1;
11268 str = getenv ("SKIP_TEST_COMMAND");
11269 if (str && strcmp (str, "1") == 0) return 1;
11273 static int test_command_3 (void)
11275 if (test_command_3_skip ()) {
11276 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11280 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11282 char device[] = "/dev/sda";
11284 suppress_error = 0;
11285 r = guestfs_blockdev_setrw (g, device);
11291 suppress_error = 0;
11292 r = guestfs_umount_all (g);
11298 suppress_error = 0;
11299 r = guestfs_lvm_remove_all (g);
11304 char device[] = "/dev/sda";
11305 char lines_0[] = ",";
11311 suppress_error = 0;
11312 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11317 char fstype[] = "ext2";
11318 char device[] = "/dev/sda1";
11320 suppress_error = 0;
11321 r = guestfs_mkfs (g, fstype, device);
11326 char device[] = "/dev/sda1";
11327 char mountpoint[] = "/";
11329 suppress_error = 0;
11330 r = guestfs_mount (g, device, mountpoint);
11334 /* TestOutput for command (3) */
11335 char expected[] = "\nResult4\n";
11337 char remotefilename[] = "/test-command";
11339 suppress_error = 0;
11340 r = guestfs_upload (g, "test-command", remotefilename);
11345 char path[] = "/test-command";
11347 suppress_error = 0;
11348 r = guestfs_chmod (g, 493, path);
11353 char arguments_0[] = "/test-command";
11354 char arguments_1[] = "4";
11355 char *arguments[] = {
11361 suppress_error = 0;
11362 r = guestfs_command (g, arguments);
11365 if (strcmp (r, expected) != 0) {
11366 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11374 static int test_command_4_skip (void)
11378 str = getenv ("TEST_ONLY");
11380 return strstr (str, "command") == NULL;
11381 str = getenv ("SKIP_TEST_COMMAND_4");
11382 if (str && strcmp (str, "1") == 0) return 1;
11383 str = getenv ("SKIP_TEST_COMMAND");
11384 if (str && strcmp (str, "1") == 0) return 1;
11388 static int test_command_4 (void)
11390 if (test_command_4_skip ()) {
11391 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11395 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11397 char device[] = "/dev/sda";
11399 suppress_error = 0;
11400 r = guestfs_blockdev_setrw (g, device);
11406 suppress_error = 0;
11407 r = guestfs_umount_all (g);
11413 suppress_error = 0;
11414 r = guestfs_lvm_remove_all (g);
11419 char device[] = "/dev/sda";
11420 char lines_0[] = ",";
11426 suppress_error = 0;
11427 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11432 char fstype[] = "ext2";
11433 char device[] = "/dev/sda1";
11435 suppress_error = 0;
11436 r = guestfs_mkfs (g, fstype, device);
11441 char device[] = "/dev/sda1";
11442 char mountpoint[] = "/";
11444 suppress_error = 0;
11445 r = guestfs_mount (g, device, mountpoint);
11449 /* TestOutput for command (4) */
11450 char expected[] = "\nResult5\n\n";
11452 char remotefilename[] = "/test-command";
11454 suppress_error = 0;
11455 r = guestfs_upload (g, "test-command", remotefilename);
11460 char path[] = "/test-command";
11462 suppress_error = 0;
11463 r = guestfs_chmod (g, 493, path);
11468 char arguments_0[] = "/test-command";
11469 char arguments_1[] = "5";
11470 char *arguments[] = {
11476 suppress_error = 0;
11477 r = guestfs_command (g, arguments);
11480 if (strcmp (r, expected) != 0) {
11481 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11489 static int test_command_5_skip (void)
11493 str = getenv ("TEST_ONLY");
11495 return strstr (str, "command") == NULL;
11496 str = getenv ("SKIP_TEST_COMMAND_5");
11497 if (str && strcmp (str, "1") == 0) return 1;
11498 str = getenv ("SKIP_TEST_COMMAND");
11499 if (str && strcmp (str, "1") == 0) return 1;
11503 static int test_command_5 (void)
11505 if (test_command_5_skip ()) {
11506 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11510 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11512 char device[] = "/dev/sda";
11514 suppress_error = 0;
11515 r = guestfs_blockdev_setrw (g, device);
11521 suppress_error = 0;
11522 r = guestfs_umount_all (g);
11528 suppress_error = 0;
11529 r = guestfs_lvm_remove_all (g);
11534 char device[] = "/dev/sda";
11535 char lines_0[] = ",";
11541 suppress_error = 0;
11542 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11547 char fstype[] = "ext2";
11548 char device[] = "/dev/sda1";
11550 suppress_error = 0;
11551 r = guestfs_mkfs (g, fstype, device);
11556 char device[] = "/dev/sda1";
11557 char mountpoint[] = "/";
11559 suppress_error = 0;
11560 r = guestfs_mount (g, device, mountpoint);
11564 /* TestOutput for command (5) */
11565 char expected[] = "\n\nResult6\n\n";
11567 char remotefilename[] = "/test-command";
11569 suppress_error = 0;
11570 r = guestfs_upload (g, "test-command", remotefilename);
11575 char path[] = "/test-command";
11577 suppress_error = 0;
11578 r = guestfs_chmod (g, 493, path);
11583 char arguments_0[] = "/test-command";
11584 char arguments_1[] = "6";
11585 char *arguments[] = {
11591 suppress_error = 0;
11592 r = guestfs_command (g, arguments);
11595 if (strcmp (r, expected) != 0) {
11596 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11604 static int test_command_6_skip (void)
11608 str = getenv ("TEST_ONLY");
11610 return strstr (str, "command") == NULL;
11611 str = getenv ("SKIP_TEST_COMMAND_6");
11612 if (str && strcmp (str, "1") == 0) return 1;
11613 str = getenv ("SKIP_TEST_COMMAND");
11614 if (str && strcmp (str, "1") == 0) return 1;
11618 static int test_command_6 (void)
11620 if (test_command_6_skip ()) {
11621 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11625 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11627 char device[] = "/dev/sda";
11629 suppress_error = 0;
11630 r = guestfs_blockdev_setrw (g, device);
11636 suppress_error = 0;
11637 r = guestfs_umount_all (g);
11643 suppress_error = 0;
11644 r = guestfs_lvm_remove_all (g);
11649 char device[] = "/dev/sda";
11650 char lines_0[] = ",";
11656 suppress_error = 0;
11657 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11662 char fstype[] = "ext2";
11663 char device[] = "/dev/sda1";
11665 suppress_error = 0;
11666 r = guestfs_mkfs (g, fstype, device);
11671 char device[] = "/dev/sda1";
11672 char mountpoint[] = "/";
11674 suppress_error = 0;
11675 r = guestfs_mount (g, device, mountpoint);
11679 /* TestOutput for command (6) */
11680 char expected[] = "";
11682 char remotefilename[] = "/test-command";
11684 suppress_error = 0;
11685 r = guestfs_upload (g, "test-command", remotefilename);
11690 char path[] = "/test-command";
11692 suppress_error = 0;
11693 r = guestfs_chmod (g, 493, path);
11698 char arguments_0[] = "/test-command";
11699 char arguments_1[] = "7";
11700 char *arguments[] = {
11706 suppress_error = 0;
11707 r = guestfs_command (g, arguments);
11710 if (strcmp (r, expected) != 0) {
11711 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11719 static int test_command_7_skip (void)
11723 str = getenv ("TEST_ONLY");
11725 return strstr (str, "command") == NULL;
11726 str = getenv ("SKIP_TEST_COMMAND_7");
11727 if (str && strcmp (str, "1") == 0) return 1;
11728 str = getenv ("SKIP_TEST_COMMAND");
11729 if (str && strcmp (str, "1") == 0) return 1;
11733 static int test_command_7 (void)
11735 if (test_command_7_skip ()) {
11736 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11740 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11742 char device[] = "/dev/sda";
11744 suppress_error = 0;
11745 r = guestfs_blockdev_setrw (g, device);
11751 suppress_error = 0;
11752 r = guestfs_umount_all (g);
11758 suppress_error = 0;
11759 r = guestfs_lvm_remove_all (g);
11764 char device[] = "/dev/sda";
11765 char lines_0[] = ",";
11771 suppress_error = 0;
11772 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11777 char fstype[] = "ext2";
11778 char device[] = "/dev/sda1";
11780 suppress_error = 0;
11781 r = guestfs_mkfs (g, fstype, device);
11786 char device[] = "/dev/sda1";
11787 char mountpoint[] = "/";
11789 suppress_error = 0;
11790 r = guestfs_mount (g, device, mountpoint);
11794 /* TestOutput for command (7) */
11795 char expected[] = "\n";
11797 char remotefilename[] = "/test-command";
11799 suppress_error = 0;
11800 r = guestfs_upload (g, "test-command", remotefilename);
11805 char path[] = "/test-command";
11807 suppress_error = 0;
11808 r = guestfs_chmod (g, 493, path);
11813 char arguments_0[] = "/test-command";
11814 char arguments_1[] = "8";
11815 char *arguments[] = {
11821 suppress_error = 0;
11822 r = guestfs_command (g, arguments);
11825 if (strcmp (r, expected) != 0) {
11826 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
11834 static int test_command_8_skip (void)
11838 str = getenv ("TEST_ONLY");
11840 return strstr (str, "command") == NULL;
11841 str = getenv ("SKIP_TEST_COMMAND_8");
11842 if (str && strcmp (str, "1") == 0) return 1;
11843 str = getenv ("SKIP_TEST_COMMAND");
11844 if (str && strcmp (str, "1") == 0) return 1;
11848 static int test_command_8 (void)
11850 if (test_command_8_skip ()) {
11851 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
11855 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
11857 char device[] = "/dev/sda";
11859 suppress_error = 0;
11860 r = guestfs_blockdev_setrw (g, device);
11866 suppress_error = 0;
11867 r = guestfs_umount_all (g);
11873 suppress_error = 0;
11874 r = guestfs_lvm_remove_all (g);
11879 char device[] = "/dev/sda";
11880 char lines_0[] = ",";
11886 suppress_error = 0;
11887 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11892 char fstype[] = "ext2";
11893 char device[] = "/dev/sda1";
11895 suppress_error = 0;
11896 r = guestfs_mkfs (g, fstype, device);
11901 char device[] = "/dev/sda1";
11902 char mountpoint[] = "/";
11904 suppress_error = 0;
11905 r = guestfs_mount (g, device, mountpoint);
11909 /* TestOutput for command (8) */
11910 char expected[] = "\n\n";
11912 char remotefilename[] = "/test-command";
11914 suppress_error = 0;
11915 r = guestfs_upload (g, "test-command", remotefilename);
11920 char path[] = "/test-command";
11922 suppress_error = 0;
11923 r = guestfs_chmod (g, 493, path);
11928 char arguments_0[] = "/test-command";
11929 char arguments_1[] = "9";
11930 char *arguments[] = {
11936 suppress_error = 0;
11937 r = guestfs_command (g, arguments);
11940 if (strcmp (r, expected) != 0) {
11941 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
11949 static int test_command_9_skip (void)
11953 str = getenv ("TEST_ONLY");
11955 return strstr (str, "command") == NULL;
11956 str = getenv ("SKIP_TEST_COMMAND_9");
11957 if (str && strcmp (str, "1") == 0) return 1;
11958 str = getenv ("SKIP_TEST_COMMAND");
11959 if (str && strcmp (str, "1") == 0) return 1;
11963 static int test_command_9 (void)
11965 if (test_command_9_skip ()) {
11966 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
11970 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
11972 char device[] = "/dev/sda";
11974 suppress_error = 0;
11975 r = guestfs_blockdev_setrw (g, device);
11981 suppress_error = 0;
11982 r = guestfs_umount_all (g);
11988 suppress_error = 0;
11989 r = guestfs_lvm_remove_all (g);
11994 char device[] = "/dev/sda";
11995 char lines_0[] = ",";
12001 suppress_error = 0;
12002 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12007 char fstype[] = "ext2";
12008 char device[] = "/dev/sda1";
12010 suppress_error = 0;
12011 r = guestfs_mkfs (g, fstype, device);
12016 char device[] = "/dev/sda1";
12017 char mountpoint[] = "/";
12019 suppress_error = 0;
12020 r = guestfs_mount (g, device, mountpoint);
12024 /* TestOutput for command (9) */
12025 char expected[] = "Result10-1\nResult10-2\n";
12027 char remotefilename[] = "/test-command";
12029 suppress_error = 0;
12030 r = guestfs_upload (g, "test-command", remotefilename);
12035 char path[] = "/test-command";
12037 suppress_error = 0;
12038 r = guestfs_chmod (g, 493, path);
12043 char arguments_0[] = "/test-command";
12044 char arguments_1[] = "10";
12045 char *arguments[] = {
12051 suppress_error = 0;
12052 r = guestfs_command (g, arguments);
12055 if (strcmp (r, expected) != 0) {
12056 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12064 static int test_command_10_skip (void)
12068 str = getenv ("TEST_ONLY");
12070 return strstr (str, "command") == NULL;
12071 str = getenv ("SKIP_TEST_COMMAND_10");
12072 if (str && strcmp (str, "1") == 0) return 1;
12073 str = getenv ("SKIP_TEST_COMMAND");
12074 if (str && strcmp (str, "1") == 0) return 1;
12078 static int test_command_10 (void)
12080 if (test_command_10_skip ()) {
12081 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12085 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12087 char device[] = "/dev/sda";
12089 suppress_error = 0;
12090 r = guestfs_blockdev_setrw (g, device);
12096 suppress_error = 0;
12097 r = guestfs_umount_all (g);
12103 suppress_error = 0;
12104 r = guestfs_lvm_remove_all (g);
12109 char device[] = "/dev/sda";
12110 char lines_0[] = ",";
12116 suppress_error = 0;
12117 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12122 char fstype[] = "ext2";
12123 char device[] = "/dev/sda1";
12125 suppress_error = 0;
12126 r = guestfs_mkfs (g, fstype, device);
12131 char device[] = "/dev/sda1";
12132 char mountpoint[] = "/";
12134 suppress_error = 0;
12135 r = guestfs_mount (g, device, mountpoint);
12139 /* TestOutput for command (10) */
12140 char expected[] = "Result11-1\nResult11-2";
12142 char remotefilename[] = "/test-command";
12144 suppress_error = 0;
12145 r = guestfs_upload (g, "test-command", remotefilename);
12150 char path[] = "/test-command";
12152 suppress_error = 0;
12153 r = guestfs_chmod (g, 493, path);
12158 char arguments_0[] = "/test-command";
12159 char arguments_1[] = "11";
12160 char *arguments[] = {
12166 suppress_error = 0;
12167 r = guestfs_command (g, arguments);
12170 if (strcmp (r, expected) != 0) {
12171 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12179 static int test_command_11_skip (void)
12183 str = getenv ("TEST_ONLY");
12185 return strstr (str, "command") == NULL;
12186 str = getenv ("SKIP_TEST_COMMAND_11");
12187 if (str && strcmp (str, "1") == 0) return 1;
12188 str = getenv ("SKIP_TEST_COMMAND");
12189 if (str && strcmp (str, "1") == 0) return 1;
12193 static int test_command_11 (void)
12195 if (test_command_11_skip ()) {
12196 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12200 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12202 char device[] = "/dev/sda";
12204 suppress_error = 0;
12205 r = guestfs_blockdev_setrw (g, device);
12211 suppress_error = 0;
12212 r = guestfs_umount_all (g);
12218 suppress_error = 0;
12219 r = guestfs_lvm_remove_all (g);
12224 char device[] = "/dev/sda";
12225 char lines_0[] = ",";
12231 suppress_error = 0;
12232 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12237 char fstype[] = "ext2";
12238 char device[] = "/dev/sda1";
12240 suppress_error = 0;
12241 r = guestfs_mkfs (g, fstype, device);
12246 char device[] = "/dev/sda1";
12247 char mountpoint[] = "/";
12249 suppress_error = 0;
12250 r = guestfs_mount (g, device, mountpoint);
12254 /* TestLastFail for command (11) */
12256 char remotefilename[] = "/test-command";
12258 suppress_error = 0;
12259 r = guestfs_upload (g, "test-command", remotefilename);
12264 char path[] = "/test-command";
12266 suppress_error = 0;
12267 r = guestfs_chmod (g, 493, path);
12272 char arguments_0[] = "/test-command";
12273 char *arguments[] = {
12278 suppress_error = 1;
12279 r = guestfs_command (g, arguments);
12287 static int test_file_0_skip (void)
12291 str = getenv ("TEST_ONLY");
12293 return strstr (str, "file") == NULL;
12294 str = getenv ("SKIP_TEST_FILE_0");
12295 if (str && strcmp (str, "1") == 0) return 1;
12296 str = getenv ("SKIP_TEST_FILE");
12297 if (str && strcmp (str, "1") == 0) return 1;
12301 static int test_file_0 (void)
12303 if (test_file_0_skip ()) {
12304 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12308 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12310 char device[] = "/dev/sda";
12312 suppress_error = 0;
12313 r = guestfs_blockdev_setrw (g, device);
12319 suppress_error = 0;
12320 r = guestfs_umount_all (g);
12326 suppress_error = 0;
12327 r = guestfs_lvm_remove_all (g);
12332 char device[] = "/dev/sda";
12333 char lines_0[] = ",";
12339 suppress_error = 0;
12340 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12345 char fstype[] = "ext2";
12346 char device[] = "/dev/sda1";
12348 suppress_error = 0;
12349 r = guestfs_mkfs (g, fstype, device);
12354 char device[] = "/dev/sda1";
12355 char mountpoint[] = "/";
12357 suppress_error = 0;
12358 r = guestfs_mount (g, device, mountpoint);
12362 /* TestOutput for file (0) */
12363 char expected[] = "empty";
12365 char path[] = "/new";
12367 suppress_error = 0;
12368 r = guestfs_touch (g, path);
12373 char path[] = "/new";
12375 suppress_error = 0;
12376 r = guestfs_file (g, path);
12379 if (strcmp (r, expected) != 0) {
12380 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12388 static int test_file_1_skip (void)
12392 str = getenv ("TEST_ONLY");
12394 return strstr (str, "file") == NULL;
12395 str = getenv ("SKIP_TEST_FILE_1");
12396 if (str && strcmp (str, "1") == 0) return 1;
12397 str = getenv ("SKIP_TEST_FILE");
12398 if (str && strcmp (str, "1") == 0) return 1;
12402 static int test_file_1 (void)
12404 if (test_file_1_skip ()) {
12405 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12409 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12411 char device[] = "/dev/sda";
12413 suppress_error = 0;
12414 r = guestfs_blockdev_setrw (g, device);
12420 suppress_error = 0;
12421 r = guestfs_umount_all (g);
12427 suppress_error = 0;
12428 r = guestfs_lvm_remove_all (g);
12433 char device[] = "/dev/sda";
12434 char lines_0[] = ",";
12440 suppress_error = 0;
12441 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12446 char fstype[] = "ext2";
12447 char device[] = "/dev/sda1";
12449 suppress_error = 0;
12450 r = guestfs_mkfs (g, fstype, device);
12455 char device[] = "/dev/sda1";
12456 char mountpoint[] = "/";
12458 suppress_error = 0;
12459 r = guestfs_mount (g, device, mountpoint);
12463 /* TestOutput for file (1) */
12464 char expected[] = "ASCII text";
12466 char path[] = "/new";
12467 char content[] = "some content\n";
12469 suppress_error = 0;
12470 r = guestfs_write_file (g, path, content, 0);
12475 char path[] = "/new";
12477 suppress_error = 0;
12478 r = guestfs_file (g, path);
12481 if (strcmp (r, expected) != 0) {
12482 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12490 static int test_file_2_skip (void)
12494 str = getenv ("TEST_ONLY");
12496 return strstr (str, "file") == NULL;
12497 str = getenv ("SKIP_TEST_FILE_2");
12498 if (str && strcmp (str, "1") == 0) return 1;
12499 str = getenv ("SKIP_TEST_FILE");
12500 if (str && strcmp (str, "1") == 0) return 1;
12504 static int test_file_2 (void)
12506 if (test_file_2_skip ()) {
12507 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12511 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12513 char device[] = "/dev/sda";
12515 suppress_error = 0;
12516 r = guestfs_blockdev_setrw (g, device);
12522 suppress_error = 0;
12523 r = guestfs_umount_all (g);
12529 suppress_error = 0;
12530 r = guestfs_lvm_remove_all (g);
12535 char device[] = "/dev/sda";
12536 char lines_0[] = ",";
12542 suppress_error = 0;
12543 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12548 char fstype[] = "ext2";
12549 char device[] = "/dev/sda1";
12551 suppress_error = 0;
12552 r = guestfs_mkfs (g, fstype, device);
12557 char device[] = "/dev/sda1";
12558 char mountpoint[] = "/";
12560 suppress_error = 0;
12561 r = guestfs_mount (g, device, mountpoint);
12565 /* TestLastFail for file (2) */
12567 char path[] = "/nofile";
12569 suppress_error = 1;
12570 r = guestfs_file (g, path);
12578 static int test_umount_all_0_skip (void)
12582 str = getenv ("TEST_ONLY");
12584 return strstr (str, "umount_all") == NULL;
12585 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12586 if (str && strcmp (str, "1") == 0) return 1;
12587 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12588 if (str && strcmp (str, "1") == 0) return 1;
12592 static int test_umount_all_0 (void)
12594 if (test_umount_all_0_skip ()) {
12595 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12599 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12601 char device[] = "/dev/sda";
12603 suppress_error = 0;
12604 r = guestfs_blockdev_setrw (g, device);
12610 suppress_error = 0;
12611 r = guestfs_umount_all (g);
12617 suppress_error = 0;
12618 r = guestfs_lvm_remove_all (g);
12623 char device[] = "/dev/sda";
12624 char lines_0[] = ",";
12630 suppress_error = 0;
12631 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12636 char fstype[] = "ext2";
12637 char device[] = "/dev/sda1";
12639 suppress_error = 0;
12640 r = guestfs_mkfs (g, fstype, device);
12645 char device[] = "/dev/sda1";
12646 char mountpoint[] = "/";
12648 suppress_error = 0;
12649 r = guestfs_mount (g, device, mountpoint);
12653 /* TestOutputList for umount_all (0) */
12656 suppress_error = 0;
12657 r = guestfs_umount_all (g);
12664 suppress_error = 0;
12665 r = guestfs_mounts (g);
12668 if (r[0] != NULL) {
12669 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12673 for (i = 0; r[i] != NULL; ++i)
12680 static int test_umount_all_1_skip (void)
12684 str = getenv ("TEST_ONLY");
12686 return strstr (str, "umount_all") == NULL;
12687 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12688 if (str && strcmp (str, "1") == 0) return 1;
12689 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12690 if (str && strcmp (str, "1") == 0) return 1;
12694 static int test_umount_all_1 (void)
12696 if (test_umount_all_1_skip ()) {
12697 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12701 /* InitNone|InitEmpty for test_umount_all_1 */
12703 char device[] = "/dev/sda";
12705 suppress_error = 0;
12706 r = guestfs_blockdev_setrw (g, device);
12712 suppress_error = 0;
12713 r = guestfs_umount_all (g);
12719 suppress_error = 0;
12720 r = guestfs_lvm_remove_all (g);
12724 /* TestOutputList for umount_all (1) */
12726 char device[] = "/dev/sda";
12727 char lines_0[] = ",10";
12728 char lines_1[] = ",20";
12729 char lines_2[] = ",";
12737 suppress_error = 0;
12738 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12743 char fstype[] = "ext2";
12744 char device[] = "/dev/sda1";
12746 suppress_error = 0;
12747 r = guestfs_mkfs (g, fstype, device);
12752 char fstype[] = "ext2";
12753 char device[] = "/dev/sda2";
12755 suppress_error = 0;
12756 r = guestfs_mkfs (g, fstype, device);
12761 char fstype[] = "ext2";
12762 char device[] = "/dev/sda3";
12764 suppress_error = 0;
12765 r = guestfs_mkfs (g, fstype, device);
12770 char device[] = "/dev/sda1";
12771 char mountpoint[] = "/";
12773 suppress_error = 0;
12774 r = guestfs_mount (g, device, mountpoint);
12779 char path[] = "/mp1";
12781 suppress_error = 0;
12782 r = guestfs_mkdir (g, path);
12787 char device[] = "/dev/sda2";
12788 char mountpoint[] = "/mp1";
12790 suppress_error = 0;
12791 r = guestfs_mount (g, device, mountpoint);
12796 char path[] = "/mp1/mp2";
12798 suppress_error = 0;
12799 r = guestfs_mkdir (g, path);
12804 char device[] = "/dev/sda3";
12805 char mountpoint[] = "/mp1/mp2";
12807 suppress_error = 0;
12808 r = guestfs_mount (g, device, mountpoint);
12813 char path[] = "/mp1/mp2/mp3";
12815 suppress_error = 0;
12816 r = guestfs_mkdir (g, path);
12822 suppress_error = 0;
12823 r = guestfs_umount_all (g);
12830 suppress_error = 0;
12831 r = guestfs_mounts (g);
12834 if (r[0] != NULL) {
12835 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
12839 for (i = 0; r[i] != NULL; ++i)
12846 static int test_mounts_0_skip (void)
12850 str = getenv ("TEST_ONLY");
12852 return strstr (str, "mounts") == NULL;
12853 str = getenv ("SKIP_TEST_MOUNTS_0");
12854 if (str && strcmp (str, "1") == 0) return 1;
12855 str = getenv ("SKIP_TEST_MOUNTS");
12856 if (str && strcmp (str, "1") == 0) return 1;
12860 static int test_mounts_0 (void)
12862 if (test_mounts_0_skip ()) {
12863 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
12867 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
12869 char device[] = "/dev/sda";
12871 suppress_error = 0;
12872 r = guestfs_blockdev_setrw (g, device);
12878 suppress_error = 0;
12879 r = guestfs_umount_all (g);
12885 suppress_error = 0;
12886 r = guestfs_lvm_remove_all (g);
12891 char device[] = "/dev/sda";
12892 char lines_0[] = ",";
12898 suppress_error = 0;
12899 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12904 char fstype[] = "ext2";
12905 char device[] = "/dev/sda1";
12907 suppress_error = 0;
12908 r = guestfs_mkfs (g, fstype, device);
12913 char device[] = "/dev/sda1";
12914 char mountpoint[] = "/";
12916 suppress_error = 0;
12917 r = guestfs_mount (g, device, mountpoint);
12921 /* TestOutputListOfDevices for mounts (0) */
12925 suppress_error = 0;
12926 r = guestfs_mounts (g);
12930 fprintf (stderr, "test_mounts_0: short list returned from command\n");
12935 char expected[] = "/dev/sda1";
12937 if (strcmp (r[0], expected) != 0) {
12938 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12942 if (r[1] != NULL) {
12943 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
12947 for (i = 0; r[i] != NULL; ++i)
12954 static int test_umount_0_skip (void)
12958 str = getenv ("TEST_ONLY");
12960 return strstr (str, "umount") == NULL;
12961 str = getenv ("SKIP_TEST_UMOUNT_0");
12962 if (str && strcmp (str, "1") == 0) return 1;
12963 str = getenv ("SKIP_TEST_UMOUNT");
12964 if (str && strcmp (str, "1") == 0) return 1;
12968 static int test_umount_0 (void)
12970 if (test_umount_0_skip ()) {
12971 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
12975 /* InitNone|InitEmpty for test_umount_0 */
12977 char device[] = "/dev/sda";
12979 suppress_error = 0;
12980 r = guestfs_blockdev_setrw (g, device);
12986 suppress_error = 0;
12987 r = guestfs_umount_all (g);
12993 suppress_error = 0;
12994 r = guestfs_lvm_remove_all (g);
12998 /* TestOutputListOfDevices for umount (0) */
13000 char device[] = "/dev/sda";
13001 char lines_0[] = ",";
13007 suppress_error = 0;
13008 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13013 char fstype[] = "ext2";
13014 char device[] = "/dev/sda1";
13016 suppress_error = 0;
13017 r = guestfs_mkfs (g, fstype, device);
13022 char device[] = "/dev/sda1";
13023 char mountpoint[] = "/";
13025 suppress_error = 0;
13026 r = guestfs_mount (g, device, mountpoint);
13033 suppress_error = 0;
13034 r = guestfs_mounts (g);
13038 fprintf (stderr, "test_umount_0: short list returned from command\n");
13043 char expected[] = "/dev/sda1";
13045 if (strcmp (r[0], expected) != 0) {
13046 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13050 if (r[1] != NULL) {
13051 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13055 for (i = 0; r[i] != NULL; ++i)
13062 static int test_umount_1_skip (void)
13066 str = getenv ("TEST_ONLY");
13068 return strstr (str, "umount") == NULL;
13069 str = getenv ("SKIP_TEST_UMOUNT_1");
13070 if (str && strcmp (str, "1") == 0) return 1;
13071 str = getenv ("SKIP_TEST_UMOUNT");
13072 if (str && strcmp (str, "1") == 0) return 1;
13076 static int test_umount_1 (void)
13078 if (test_umount_1_skip ()) {
13079 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13083 /* InitNone|InitEmpty for test_umount_1 */
13085 char device[] = "/dev/sda";
13087 suppress_error = 0;
13088 r = guestfs_blockdev_setrw (g, device);
13094 suppress_error = 0;
13095 r = guestfs_umount_all (g);
13101 suppress_error = 0;
13102 r = guestfs_lvm_remove_all (g);
13106 /* TestOutputList for umount (1) */
13108 char device[] = "/dev/sda";
13109 char lines_0[] = ",";
13115 suppress_error = 0;
13116 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13121 char fstype[] = "ext2";
13122 char device[] = "/dev/sda1";
13124 suppress_error = 0;
13125 r = guestfs_mkfs (g, fstype, device);
13130 char device[] = "/dev/sda1";
13131 char mountpoint[] = "/";
13133 suppress_error = 0;
13134 r = guestfs_mount (g, device, mountpoint);
13139 char pathordevice[] = "/";
13141 suppress_error = 0;
13142 r = guestfs_umount (g, pathordevice);
13149 suppress_error = 0;
13150 r = guestfs_mounts (g);
13153 if (r[0] != NULL) {
13154 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13158 for (i = 0; r[i] != NULL; ++i)
13165 static int test_write_file_0_skip (void)
13169 str = getenv ("TEST_ONLY");
13171 return strstr (str, "write_file") == NULL;
13172 str = getenv ("SKIP_TEST_WRITE_FILE_0");
13173 if (str && strcmp (str, "1") == 0) return 1;
13174 str = getenv ("SKIP_TEST_WRITE_FILE");
13175 if (str && strcmp (str, "1") == 0) return 1;
13179 static int test_write_file_0 (void)
13181 if (test_write_file_0_skip ()) {
13182 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13186 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13188 char device[] = "/dev/sda";
13190 suppress_error = 0;
13191 r = guestfs_blockdev_setrw (g, device);
13197 suppress_error = 0;
13198 r = guestfs_umount_all (g);
13204 suppress_error = 0;
13205 r = guestfs_lvm_remove_all (g);
13210 char device[] = "/dev/sda";
13211 char lines_0[] = ",";
13217 suppress_error = 0;
13218 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13223 char fstype[] = "ext2";
13224 char device[] = "/dev/sda1";
13226 suppress_error = 0;
13227 r = guestfs_mkfs (g, fstype, device);
13232 char device[] = "/dev/sda1";
13233 char mountpoint[] = "/";
13235 suppress_error = 0;
13236 r = guestfs_mount (g, device, mountpoint);
13240 /* TestOutput for write_file (0) */
13241 char expected[] = "new file contents";
13243 char path[] = "/new";
13244 char content[] = "new file contents";
13246 suppress_error = 0;
13247 r = guestfs_write_file (g, path, content, 0);
13252 char path[] = "/new";
13254 suppress_error = 0;
13255 r = guestfs_cat (g, path);
13258 if (strcmp (r, expected) != 0) {
13259 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13267 static int test_write_file_1_skip (void)
13271 str = getenv ("TEST_ONLY");
13273 return strstr (str, "write_file") == NULL;
13274 str = getenv ("SKIP_TEST_WRITE_FILE_1");
13275 if (str && strcmp (str, "1") == 0) return 1;
13276 str = getenv ("SKIP_TEST_WRITE_FILE");
13277 if (str && strcmp (str, "1") == 0) return 1;
13281 static int test_write_file_1 (void)
13283 if (test_write_file_1_skip ()) {
13284 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13288 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13290 char device[] = "/dev/sda";
13292 suppress_error = 0;
13293 r = guestfs_blockdev_setrw (g, device);
13299 suppress_error = 0;
13300 r = guestfs_umount_all (g);
13306 suppress_error = 0;
13307 r = guestfs_lvm_remove_all (g);
13312 char device[] = "/dev/sda";
13313 char lines_0[] = ",";
13319 suppress_error = 0;
13320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13325 char fstype[] = "ext2";
13326 char device[] = "/dev/sda1";
13328 suppress_error = 0;
13329 r = guestfs_mkfs (g, fstype, device);
13334 char device[] = "/dev/sda1";
13335 char mountpoint[] = "/";
13337 suppress_error = 0;
13338 r = guestfs_mount (g, device, mountpoint);
13342 /* TestOutput for write_file (1) */
13343 char expected[] = "\nnew file contents\n";
13345 char path[] = "/new";
13346 char content[] = "\nnew file contents\n";
13348 suppress_error = 0;
13349 r = guestfs_write_file (g, path, content, 0);
13354 char path[] = "/new";
13356 suppress_error = 0;
13357 r = guestfs_cat (g, path);
13360 if (strcmp (r, expected) != 0) {
13361 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13369 static int test_write_file_2_skip (void)
13373 str = getenv ("TEST_ONLY");
13375 return strstr (str, "write_file") == NULL;
13376 str = getenv ("SKIP_TEST_WRITE_FILE_2");
13377 if (str && strcmp (str, "1") == 0) return 1;
13378 str = getenv ("SKIP_TEST_WRITE_FILE");
13379 if (str && strcmp (str, "1") == 0) return 1;
13383 static int test_write_file_2 (void)
13385 if (test_write_file_2_skip ()) {
13386 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13390 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13392 char device[] = "/dev/sda";
13394 suppress_error = 0;
13395 r = guestfs_blockdev_setrw (g, device);
13401 suppress_error = 0;
13402 r = guestfs_umount_all (g);
13408 suppress_error = 0;
13409 r = guestfs_lvm_remove_all (g);
13414 char device[] = "/dev/sda";
13415 char lines_0[] = ",";
13421 suppress_error = 0;
13422 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13427 char fstype[] = "ext2";
13428 char device[] = "/dev/sda1";
13430 suppress_error = 0;
13431 r = guestfs_mkfs (g, fstype, device);
13436 char device[] = "/dev/sda1";
13437 char mountpoint[] = "/";
13439 suppress_error = 0;
13440 r = guestfs_mount (g, device, mountpoint);
13444 /* TestOutput for write_file (2) */
13445 char expected[] = "\n\n";
13447 char path[] = "/new";
13448 char content[] = "\n\n";
13450 suppress_error = 0;
13451 r = guestfs_write_file (g, path, content, 0);
13456 char path[] = "/new";
13458 suppress_error = 0;
13459 r = guestfs_cat (g, path);
13462 if (strcmp (r, expected) != 0) {
13463 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13471 static int test_write_file_3_skip (void)
13475 str = getenv ("TEST_ONLY");
13477 return strstr (str, "write_file") == NULL;
13478 str = getenv ("SKIP_TEST_WRITE_FILE_3");
13479 if (str && strcmp (str, "1") == 0) return 1;
13480 str = getenv ("SKIP_TEST_WRITE_FILE");
13481 if (str && strcmp (str, "1") == 0) return 1;
13485 static int test_write_file_3 (void)
13487 if (test_write_file_3_skip ()) {
13488 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13492 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13494 char device[] = "/dev/sda";
13496 suppress_error = 0;
13497 r = guestfs_blockdev_setrw (g, device);
13503 suppress_error = 0;
13504 r = guestfs_umount_all (g);
13510 suppress_error = 0;
13511 r = guestfs_lvm_remove_all (g);
13516 char device[] = "/dev/sda";
13517 char lines_0[] = ",";
13523 suppress_error = 0;
13524 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13529 char fstype[] = "ext2";
13530 char device[] = "/dev/sda1";
13532 suppress_error = 0;
13533 r = guestfs_mkfs (g, fstype, device);
13538 char device[] = "/dev/sda1";
13539 char mountpoint[] = "/";
13541 suppress_error = 0;
13542 r = guestfs_mount (g, device, mountpoint);
13546 /* TestOutput for write_file (3) */
13547 char expected[] = "";
13549 char path[] = "/new";
13550 char content[] = "";
13552 suppress_error = 0;
13553 r = guestfs_write_file (g, path, content, 0);
13558 char path[] = "/new";
13560 suppress_error = 0;
13561 r = guestfs_cat (g, path);
13564 if (strcmp (r, expected) != 0) {
13565 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13573 static int test_write_file_4_skip (void)
13577 str = getenv ("TEST_ONLY");
13579 return strstr (str, "write_file") == NULL;
13580 str = getenv ("SKIP_TEST_WRITE_FILE_4");
13581 if (str && strcmp (str, "1") == 0) return 1;
13582 str = getenv ("SKIP_TEST_WRITE_FILE");
13583 if (str && strcmp (str, "1") == 0) return 1;
13587 static int test_write_file_4 (void)
13589 if (test_write_file_4_skip ()) {
13590 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13594 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13596 char device[] = "/dev/sda";
13598 suppress_error = 0;
13599 r = guestfs_blockdev_setrw (g, device);
13605 suppress_error = 0;
13606 r = guestfs_umount_all (g);
13612 suppress_error = 0;
13613 r = guestfs_lvm_remove_all (g);
13618 char device[] = "/dev/sda";
13619 char lines_0[] = ",";
13625 suppress_error = 0;
13626 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13631 char fstype[] = "ext2";
13632 char device[] = "/dev/sda1";
13634 suppress_error = 0;
13635 r = guestfs_mkfs (g, fstype, device);
13640 char device[] = "/dev/sda1";
13641 char mountpoint[] = "/";
13643 suppress_error = 0;
13644 r = guestfs_mount (g, device, mountpoint);
13648 /* TestOutput for write_file (4) */
13649 char expected[] = "\n\n\n";
13651 char path[] = "/new";
13652 char content[] = "\n\n\n";
13654 suppress_error = 0;
13655 r = guestfs_write_file (g, path, content, 0);
13660 char path[] = "/new";
13662 suppress_error = 0;
13663 r = guestfs_cat (g, path);
13666 if (strcmp (r, expected) != 0) {
13667 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13675 static int test_write_file_5_skip (void)
13679 str = getenv ("TEST_ONLY");
13681 return strstr (str, "write_file") == NULL;
13682 str = getenv ("SKIP_TEST_WRITE_FILE_5");
13683 if (str && strcmp (str, "1") == 0) return 1;
13684 str = getenv ("SKIP_TEST_WRITE_FILE");
13685 if (str && strcmp (str, "1") == 0) return 1;
13689 static int test_write_file_5 (void)
13691 if (test_write_file_5_skip ()) {
13692 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13696 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13698 char device[] = "/dev/sda";
13700 suppress_error = 0;
13701 r = guestfs_blockdev_setrw (g, device);
13707 suppress_error = 0;
13708 r = guestfs_umount_all (g);
13714 suppress_error = 0;
13715 r = guestfs_lvm_remove_all (g);
13720 char device[] = "/dev/sda";
13721 char lines_0[] = ",";
13727 suppress_error = 0;
13728 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13733 char fstype[] = "ext2";
13734 char device[] = "/dev/sda1";
13736 suppress_error = 0;
13737 r = guestfs_mkfs (g, fstype, device);
13742 char device[] = "/dev/sda1";
13743 char mountpoint[] = "/";
13745 suppress_error = 0;
13746 r = guestfs_mount (g, device, mountpoint);
13750 /* TestOutput for write_file (5) */
13751 char expected[] = "\n";
13753 char path[] = "/new";
13754 char content[] = "\n";
13756 suppress_error = 0;
13757 r = guestfs_write_file (g, path, content, 0);
13762 char path[] = "/new";
13764 suppress_error = 0;
13765 r = guestfs_cat (g, path);
13768 if (strcmp (r, expected) != 0) {
13769 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
13777 static int test_mkfs_0_skip (void)
13781 str = getenv ("TEST_ONLY");
13783 return strstr (str, "mkfs") == NULL;
13784 str = getenv ("SKIP_TEST_MKFS_0");
13785 if (str && strcmp (str, "1") == 0) return 1;
13786 str = getenv ("SKIP_TEST_MKFS");
13787 if (str && strcmp (str, "1") == 0) return 1;
13791 static int test_mkfs_0 (void)
13793 if (test_mkfs_0_skip ()) {
13794 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
13798 /* InitNone|InitEmpty for test_mkfs_0 */
13800 char device[] = "/dev/sda";
13802 suppress_error = 0;
13803 r = guestfs_blockdev_setrw (g, device);
13809 suppress_error = 0;
13810 r = guestfs_umount_all (g);
13816 suppress_error = 0;
13817 r = guestfs_lvm_remove_all (g);
13821 /* TestOutput for mkfs (0) */
13822 char expected[] = "new file contents";
13824 char device[] = "/dev/sda";
13825 char lines_0[] = ",";
13831 suppress_error = 0;
13832 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13837 char fstype[] = "ext2";
13838 char device[] = "/dev/sda1";
13840 suppress_error = 0;
13841 r = guestfs_mkfs (g, fstype, device);
13846 char device[] = "/dev/sda1";
13847 char mountpoint[] = "/";
13849 suppress_error = 0;
13850 r = guestfs_mount (g, device, mountpoint);
13855 char path[] = "/new";
13856 char content[] = "new file contents";
13858 suppress_error = 0;
13859 r = guestfs_write_file (g, path, content, 0);
13864 char path[] = "/new";
13866 suppress_error = 0;
13867 r = guestfs_cat (g, path);
13870 if (strcmp (r, expected) != 0) {
13871 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
13879 static int test_lvcreate_0_skip (void)
13883 str = getenv ("TEST_ONLY");
13885 return strstr (str, "lvcreate") == NULL;
13886 str = getenv ("SKIP_TEST_LVCREATE_0");
13887 if (str && strcmp (str, "1") == 0) return 1;
13888 str = getenv ("SKIP_TEST_LVCREATE");
13889 if (str && strcmp (str, "1") == 0) return 1;
13893 static int test_lvcreate_0 (void)
13895 if (test_lvcreate_0_skip ()) {
13896 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
13900 /* InitNone|InitEmpty for test_lvcreate_0 */
13902 char device[] = "/dev/sda";
13904 suppress_error = 0;
13905 r = guestfs_blockdev_setrw (g, device);
13911 suppress_error = 0;
13912 r = guestfs_umount_all (g);
13918 suppress_error = 0;
13919 r = guestfs_lvm_remove_all (g);
13923 /* TestOutputList for lvcreate (0) */
13925 char device[] = "/dev/sda";
13926 char lines_0[] = ",10";
13927 char lines_1[] = ",20";
13928 char lines_2[] = ",";
13936 suppress_error = 0;
13937 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13942 char device[] = "/dev/sda1";
13944 suppress_error = 0;
13945 r = guestfs_pvcreate (g, device);
13950 char device[] = "/dev/sda2";
13952 suppress_error = 0;
13953 r = guestfs_pvcreate (g, device);
13958 char device[] = "/dev/sda3";
13960 suppress_error = 0;
13961 r = guestfs_pvcreate (g, device);
13966 char volgroup[] = "VG1";
13967 char physvols_0[] = "/dev/sda1";
13968 char physvols_1[] = "/dev/sda2";
13969 char *physvols[] = {
13975 suppress_error = 0;
13976 r = guestfs_vgcreate (g, volgroup, physvols);
13981 char volgroup[] = "VG2";
13982 char physvols_0[] = "/dev/sda3";
13983 char *physvols[] = {
13988 suppress_error = 0;
13989 r = guestfs_vgcreate (g, volgroup, physvols);
13994 char logvol[] = "LV1";
13995 char volgroup[] = "VG1";
13997 suppress_error = 0;
13998 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14003 char logvol[] = "LV2";
14004 char volgroup[] = "VG1";
14006 suppress_error = 0;
14007 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14012 char logvol[] = "LV3";
14013 char volgroup[] = "VG2";
14015 suppress_error = 0;
14016 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14021 char logvol[] = "LV4";
14022 char volgroup[] = "VG2";
14024 suppress_error = 0;
14025 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14030 char logvol[] = "LV5";
14031 char volgroup[] = "VG2";
14033 suppress_error = 0;
14034 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14041 suppress_error = 0;
14042 r = guestfs_lvs (g);
14046 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14051 char expected[] = "/dev/VG1/LV1";
14052 if (strcmp (r[0], expected) != 0) {
14053 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14058 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14063 char expected[] = "/dev/VG1/LV2";
14064 if (strcmp (r[1], expected) != 0) {
14065 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14070 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14075 char expected[] = "/dev/VG2/LV3";
14076 if (strcmp (r[2], expected) != 0) {
14077 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14082 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14087 char expected[] = "/dev/VG2/LV4";
14088 if (strcmp (r[3], expected) != 0) {
14089 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14094 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14099 char expected[] = "/dev/VG2/LV5";
14100 if (strcmp (r[4], expected) != 0) {
14101 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14105 if (r[5] != NULL) {
14106 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14110 for (i = 0; r[i] != NULL; ++i)
14117 static int test_vgcreate_0_skip (void)
14121 str = getenv ("TEST_ONLY");
14123 return strstr (str, "vgcreate") == NULL;
14124 str = getenv ("SKIP_TEST_VGCREATE_0");
14125 if (str && strcmp (str, "1") == 0) return 1;
14126 str = getenv ("SKIP_TEST_VGCREATE");
14127 if (str && strcmp (str, "1") == 0) return 1;
14131 static int test_vgcreate_0 (void)
14133 if (test_vgcreate_0_skip ()) {
14134 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14138 /* InitNone|InitEmpty for test_vgcreate_0 */
14140 char device[] = "/dev/sda";
14142 suppress_error = 0;
14143 r = guestfs_blockdev_setrw (g, device);
14149 suppress_error = 0;
14150 r = guestfs_umount_all (g);
14156 suppress_error = 0;
14157 r = guestfs_lvm_remove_all (g);
14161 /* TestOutputList for vgcreate (0) */
14163 char device[] = "/dev/sda";
14164 char lines_0[] = ",10";
14165 char lines_1[] = ",20";
14166 char lines_2[] = ",";
14174 suppress_error = 0;
14175 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14180 char device[] = "/dev/sda1";
14182 suppress_error = 0;
14183 r = guestfs_pvcreate (g, device);
14188 char device[] = "/dev/sda2";
14190 suppress_error = 0;
14191 r = guestfs_pvcreate (g, device);
14196 char device[] = "/dev/sda3";
14198 suppress_error = 0;
14199 r = guestfs_pvcreate (g, device);
14204 char volgroup[] = "VG1";
14205 char physvols_0[] = "/dev/sda1";
14206 char physvols_1[] = "/dev/sda2";
14207 char *physvols[] = {
14213 suppress_error = 0;
14214 r = guestfs_vgcreate (g, volgroup, physvols);
14219 char volgroup[] = "VG2";
14220 char physvols_0[] = "/dev/sda3";
14221 char *physvols[] = {
14226 suppress_error = 0;
14227 r = guestfs_vgcreate (g, volgroup, physvols);
14234 suppress_error = 0;
14235 r = guestfs_vgs (g);
14239 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14244 char expected[] = "VG1";
14245 if (strcmp (r[0], expected) != 0) {
14246 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14251 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14256 char expected[] = "VG2";
14257 if (strcmp (r[1], expected) != 0) {
14258 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14262 if (r[2] != NULL) {
14263 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14267 for (i = 0; r[i] != NULL; ++i)
14274 static int test_pvcreate_0_skip (void)
14278 str = getenv ("TEST_ONLY");
14280 return strstr (str, "pvcreate") == NULL;
14281 str = getenv ("SKIP_TEST_PVCREATE_0");
14282 if (str && strcmp (str, "1") == 0) return 1;
14283 str = getenv ("SKIP_TEST_PVCREATE");
14284 if (str && strcmp (str, "1") == 0) return 1;
14288 static int test_pvcreate_0 (void)
14290 if (test_pvcreate_0_skip ()) {
14291 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14295 /* InitNone|InitEmpty for test_pvcreate_0 */
14297 char device[] = "/dev/sda";
14299 suppress_error = 0;
14300 r = guestfs_blockdev_setrw (g, device);
14306 suppress_error = 0;
14307 r = guestfs_umount_all (g);
14313 suppress_error = 0;
14314 r = guestfs_lvm_remove_all (g);
14318 /* TestOutputListOfDevices for pvcreate (0) */
14320 char device[] = "/dev/sda";
14321 char lines_0[] = ",10";
14322 char lines_1[] = ",20";
14323 char lines_2[] = ",";
14331 suppress_error = 0;
14332 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14337 char device[] = "/dev/sda1";
14339 suppress_error = 0;
14340 r = guestfs_pvcreate (g, device);
14345 char device[] = "/dev/sda2";
14347 suppress_error = 0;
14348 r = guestfs_pvcreate (g, device);
14353 char device[] = "/dev/sda3";
14355 suppress_error = 0;
14356 r = guestfs_pvcreate (g, device);
14363 suppress_error = 0;
14364 r = guestfs_pvs (g);
14368 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14373 char expected[] = "/dev/sda1";
14375 if (strcmp (r[0], expected) != 0) {
14376 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14381 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14386 char expected[] = "/dev/sda2";
14388 if (strcmp (r[1], expected) != 0) {
14389 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14394 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14399 char expected[] = "/dev/sda3";
14401 if (strcmp (r[2], expected) != 0) {
14402 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14406 if (r[3] != NULL) {
14407 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14411 for (i = 0; r[i] != NULL; ++i)
14418 static int test_is_dir_0_skip (void)
14422 str = getenv ("TEST_ONLY");
14424 return strstr (str, "is_dir") == NULL;
14425 str = getenv ("SKIP_TEST_IS_DIR_0");
14426 if (str && strcmp (str, "1") == 0) return 1;
14427 str = getenv ("SKIP_TEST_IS_DIR");
14428 if (str && strcmp (str, "1") == 0) return 1;
14432 static int test_is_dir_0 (void)
14434 if (test_is_dir_0_skip ()) {
14435 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14439 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
14441 char device[] = "/dev/sda";
14443 suppress_error = 0;
14444 r = guestfs_blockdev_setrw (g, device);
14450 suppress_error = 0;
14451 r = guestfs_umount_all (g);
14457 suppress_error = 0;
14458 r = guestfs_lvm_remove_all (g);
14463 char device[] = "/dev/sda";
14464 char lines_0[] = ",";
14470 suppress_error = 0;
14471 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14476 char fstype[] = "ext2";
14477 char device[] = "/dev/sda1";
14479 suppress_error = 0;
14480 r = guestfs_mkfs (g, fstype, device);
14485 char device[] = "/dev/sda1";
14486 char mountpoint[] = "/";
14488 suppress_error = 0;
14489 r = guestfs_mount (g, device, mountpoint);
14493 /* TestOutputFalse for is_dir (0) */
14495 char path[] = "/new";
14497 suppress_error = 0;
14498 r = guestfs_touch (g, path);
14503 char path[] = "/new";
14505 suppress_error = 0;
14506 r = guestfs_is_dir (g, path);
14510 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14517 static int test_is_dir_1_skip (void)
14521 str = getenv ("TEST_ONLY");
14523 return strstr (str, "is_dir") == NULL;
14524 str = getenv ("SKIP_TEST_IS_DIR_1");
14525 if (str && strcmp (str, "1") == 0) return 1;
14526 str = getenv ("SKIP_TEST_IS_DIR");
14527 if (str && strcmp (str, "1") == 0) return 1;
14531 static int test_is_dir_1 (void)
14533 if (test_is_dir_1_skip ()) {
14534 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14538 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
14540 char device[] = "/dev/sda";
14542 suppress_error = 0;
14543 r = guestfs_blockdev_setrw (g, device);
14549 suppress_error = 0;
14550 r = guestfs_umount_all (g);
14556 suppress_error = 0;
14557 r = guestfs_lvm_remove_all (g);
14562 char device[] = "/dev/sda";
14563 char lines_0[] = ",";
14569 suppress_error = 0;
14570 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14575 char fstype[] = "ext2";
14576 char device[] = "/dev/sda1";
14578 suppress_error = 0;
14579 r = guestfs_mkfs (g, fstype, device);
14584 char device[] = "/dev/sda1";
14585 char mountpoint[] = "/";
14587 suppress_error = 0;
14588 r = guestfs_mount (g, device, mountpoint);
14592 /* TestOutputTrue for is_dir (1) */
14594 char path[] = "/new";
14596 suppress_error = 0;
14597 r = guestfs_mkdir (g, path);
14602 char path[] = "/new";
14604 suppress_error = 0;
14605 r = guestfs_is_dir (g, path);
14609 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14616 static int test_is_file_0_skip (void)
14620 str = getenv ("TEST_ONLY");
14622 return strstr (str, "is_file") == NULL;
14623 str = getenv ("SKIP_TEST_IS_FILE_0");
14624 if (str && strcmp (str, "1") == 0) return 1;
14625 str = getenv ("SKIP_TEST_IS_FILE");
14626 if (str && strcmp (str, "1") == 0) return 1;
14630 static int test_is_file_0 (void)
14632 if (test_is_file_0_skip ()) {
14633 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14637 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
14639 char device[] = "/dev/sda";
14641 suppress_error = 0;
14642 r = guestfs_blockdev_setrw (g, device);
14648 suppress_error = 0;
14649 r = guestfs_umount_all (g);
14655 suppress_error = 0;
14656 r = guestfs_lvm_remove_all (g);
14661 char device[] = "/dev/sda";
14662 char lines_0[] = ",";
14668 suppress_error = 0;
14669 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14674 char fstype[] = "ext2";
14675 char device[] = "/dev/sda1";
14677 suppress_error = 0;
14678 r = guestfs_mkfs (g, fstype, device);
14683 char device[] = "/dev/sda1";
14684 char mountpoint[] = "/";
14686 suppress_error = 0;
14687 r = guestfs_mount (g, device, mountpoint);
14691 /* TestOutputTrue for is_file (0) */
14693 char path[] = "/new";
14695 suppress_error = 0;
14696 r = guestfs_touch (g, path);
14701 char path[] = "/new";
14703 suppress_error = 0;
14704 r = guestfs_is_file (g, path);
14708 fprintf (stderr, "test_is_file_0: expected true, got false\n");
14715 static int test_is_file_1_skip (void)
14719 str = getenv ("TEST_ONLY");
14721 return strstr (str, "is_file") == NULL;
14722 str = getenv ("SKIP_TEST_IS_FILE_1");
14723 if (str && strcmp (str, "1") == 0) return 1;
14724 str = getenv ("SKIP_TEST_IS_FILE");
14725 if (str && strcmp (str, "1") == 0) return 1;
14729 static int test_is_file_1 (void)
14731 if (test_is_file_1_skip ()) {
14732 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14736 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
14738 char device[] = "/dev/sda";
14740 suppress_error = 0;
14741 r = guestfs_blockdev_setrw (g, device);
14747 suppress_error = 0;
14748 r = guestfs_umount_all (g);
14754 suppress_error = 0;
14755 r = guestfs_lvm_remove_all (g);
14760 char device[] = "/dev/sda";
14761 char lines_0[] = ",";
14767 suppress_error = 0;
14768 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14773 char fstype[] = "ext2";
14774 char device[] = "/dev/sda1";
14776 suppress_error = 0;
14777 r = guestfs_mkfs (g, fstype, device);
14782 char device[] = "/dev/sda1";
14783 char mountpoint[] = "/";
14785 suppress_error = 0;
14786 r = guestfs_mount (g, device, mountpoint);
14790 /* TestOutputFalse for is_file (1) */
14792 char path[] = "/new";
14794 suppress_error = 0;
14795 r = guestfs_mkdir (g, path);
14800 char path[] = "/new";
14802 suppress_error = 0;
14803 r = guestfs_is_file (g, path);
14807 fprintf (stderr, "test_is_file_1: expected false, got true\n");
14814 static int test_exists_0_skip (void)
14818 str = getenv ("TEST_ONLY");
14820 return strstr (str, "exists") == NULL;
14821 str = getenv ("SKIP_TEST_EXISTS_0");
14822 if (str && strcmp (str, "1") == 0) return 1;
14823 str = getenv ("SKIP_TEST_EXISTS");
14824 if (str && strcmp (str, "1") == 0) return 1;
14828 static int test_exists_0 (void)
14830 if (test_exists_0_skip ()) {
14831 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
14835 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
14837 char device[] = "/dev/sda";
14839 suppress_error = 0;
14840 r = guestfs_blockdev_setrw (g, device);
14846 suppress_error = 0;
14847 r = guestfs_umount_all (g);
14853 suppress_error = 0;
14854 r = guestfs_lvm_remove_all (g);
14859 char device[] = "/dev/sda";
14860 char lines_0[] = ",";
14866 suppress_error = 0;
14867 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14872 char fstype[] = "ext2";
14873 char device[] = "/dev/sda1";
14875 suppress_error = 0;
14876 r = guestfs_mkfs (g, fstype, device);
14881 char device[] = "/dev/sda1";
14882 char mountpoint[] = "/";
14884 suppress_error = 0;
14885 r = guestfs_mount (g, device, mountpoint);
14889 /* TestOutputTrue for exists (0) */
14891 char path[] = "/new";
14893 suppress_error = 0;
14894 r = guestfs_touch (g, path);
14899 char path[] = "/new";
14901 suppress_error = 0;
14902 r = guestfs_exists (g, path);
14906 fprintf (stderr, "test_exists_0: expected true, got false\n");
14913 static int test_exists_1_skip (void)
14917 str = getenv ("TEST_ONLY");
14919 return strstr (str, "exists") == NULL;
14920 str = getenv ("SKIP_TEST_EXISTS_1");
14921 if (str && strcmp (str, "1") == 0) return 1;
14922 str = getenv ("SKIP_TEST_EXISTS");
14923 if (str && strcmp (str, "1") == 0) return 1;
14927 static int test_exists_1 (void)
14929 if (test_exists_1_skip ()) {
14930 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
14934 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
14936 char device[] = "/dev/sda";
14938 suppress_error = 0;
14939 r = guestfs_blockdev_setrw (g, device);
14945 suppress_error = 0;
14946 r = guestfs_umount_all (g);
14952 suppress_error = 0;
14953 r = guestfs_lvm_remove_all (g);
14958 char device[] = "/dev/sda";
14959 char lines_0[] = ",";
14965 suppress_error = 0;
14966 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14971 char fstype[] = "ext2";
14972 char device[] = "/dev/sda1";
14974 suppress_error = 0;
14975 r = guestfs_mkfs (g, fstype, device);
14980 char device[] = "/dev/sda1";
14981 char mountpoint[] = "/";
14983 suppress_error = 0;
14984 r = guestfs_mount (g, device, mountpoint);
14988 /* TestOutputTrue for exists (1) */
14990 char path[] = "/new";
14992 suppress_error = 0;
14993 r = guestfs_mkdir (g, path);
14998 char path[] = "/new";
15000 suppress_error = 0;
15001 r = guestfs_exists (g, path);
15005 fprintf (stderr, "test_exists_1: expected true, got false\n");
15012 static int test_mkdir_p_0_skip (void)
15016 str = getenv ("TEST_ONLY");
15018 return strstr (str, "mkdir_p") == NULL;
15019 str = getenv ("SKIP_TEST_MKDIR_P_0");
15020 if (str && strcmp (str, "1") == 0) return 1;
15021 str = getenv ("SKIP_TEST_MKDIR_P");
15022 if (str && strcmp (str, "1") == 0) return 1;
15026 static int test_mkdir_p_0 (void)
15028 if (test_mkdir_p_0_skip ()) {
15029 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15033 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
15035 char device[] = "/dev/sda";
15037 suppress_error = 0;
15038 r = guestfs_blockdev_setrw (g, device);
15044 suppress_error = 0;
15045 r = guestfs_umount_all (g);
15051 suppress_error = 0;
15052 r = guestfs_lvm_remove_all (g);
15057 char device[] = "/dev/sda";
15058 char lines_0[] = ",";
15064 suppress_error = 0;
15065 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15070 char fstype[] = "ext2";
15071 char device[] = "/dev/sda1";
15073 suppress_error = 0;
15074 r = guestfs_mkfs (g, fstype, device);
15079 char device[] = "/dev/sda1";
15080 char mountpoint[] = "/";
15082 suppress_error = 0;
15083 r = guestfs_mount (g, device, mountpoint);
15087 /* TestOutputTrue for mkdir_p (0) */
15089 char path[] = "/new/foo/bar";
15091 suppress_error = 0;
15092 r = guestfs_mkdir_p (g, path);
15097 char path[] = "/new/foo/bar";
15099 suppress_error = 0;
15100 r = guestfs_is_dir (g, path);
15104 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15111 static int test_mkdir_p_1_skip (void)
15115 str = getenv ("TEST_ONLY");
15117 return strstr (str, "mkdir_p") == NULL;
15118 str = getenv ("SKIP_TEST_MKDIR_P_1");
15119 if (str && strcmp (str, "1") == 0) return 1;
15120 str = getenv ("SKIP_TEST_MKDIR_P");
15121 if (str && strcmp (str, "1") == 0) return 1;
15125 static int test_mkdir_p_1 (void)
15127 if (test_mkdir_p_1_skip ()) {
15128 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15132 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
15134 char device[] = "/dev/sda";
15136 suppress_error = 0;
15137 r = guestfs_blockdev_setrw (g, device);
15143 suppress_error = 0;
15144 r = guestfs_umount_all (g);
15150 suppress_error = 0;
15151 r = guestfs_lvm_remove_all (g);
15156 char device[] = "/dev/sda";
15157 char lines_0[] = ",";
15163 suppress_error = 0;
15164 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15169 char fstype[] = "ext2";
15170 char device[] = "/dev/sda1";
15172 suppress_error = 0;
15173 r = guestfs_mkfs (g, fstype, device);
15178 char device[] = "/dev/sda1";
15179 char mountpoint[] = "/";
15181 suppress_error = 0;
15182 r = guestfs_mount (g, device, mountpoint);
15186 /* TestOutputTrue for mkdir_p (1) */
15188 char path[] = "/new/foo/bar";
15190 suppress_error = 0;
15191 r = guestfs_mkdir_p (g, path);
15196 char path[] = "/new/foo";
15198 suppress_error = 0;
15199 r = guestfs_is_dir (g, path);
15203 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15210 static int test_mkdir_p_2_skip (void)
15214 str = getenv ("TEST_ONLY");
15216 return strstr (str, "mkdir_p") == NULL;
15217 str = getenv ("SKIP_TEST_MKDIR_P_2");
15218 if (str && strcmp (str, "1") == 0) return 1;
15219 str = getenv ("SKIP_TEST_MKDIR_P");
15220 if (str && strcmp (str, "1") == 0) return 1;
15224 static int test_mkdir_p_2 (void)
15226 if (test_mkdir_p_2_skip ()) {
15227 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15231 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
15233 char device[] = "/dev/sda";
15235 suppress_error = 0;
15236 r = guestfs_blockdev_setrw (g, device);
15242 suppress_error = 0;
15243 r = guestfs_umount_all (g);
15249 suppress_error = 0;
15250 r = guestfs_lvm_remove_all (g);
15255 char device[] = "/dev/sda";
15256 char lines_0[] = ",";
15262 suppress_error = 0;
15263 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15268 char fstype[] = "ext2";
15269 char device[] = "/dev/sda1";
15271 suppress_error = 0;
15272 r = guestfs_mkfs (g, fstype, device);
15277 char device[] = "/dev/sda1";
15278 char mountpoint[] = "/";
15280 suppress_error = 0;
15281 r = guestfs_mount (g, device, mountpoint);
15285 /* TestOutputTrue for mkdir_p (2) */
15287 char path[] = "/new/foo/bar";
15289 suppress_error = 0;
15290 r = guestfs_mkdir_p (g, path);
15295 char path[] = "/new";
15297 suppress_error = 0;
15298 r = guestfs_is_dir (g, path);
15302 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15309 static int test_mkdir_p_3_skip (void)
15313 str = getenv ("TEST_ONLY");
15315 return strstr (str, "mkdir_p") == NULL;
15316 str = getenv ("SKIP_TEST_MKDIR_P_3");
15317 if (str && strcmp (str, "1") == 0) return 1;
15318 str = getenv ("SKIP_TEST_MKDIR_P");
15319 if (str && strcmp (str, "1") == 0) return 1;
15323 static int test_mkdir_p_3 (void)
15325 if (test_mkdir_p_3_skip ()) {
15326 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15330 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15332 char device[] = "/dev/sda";
15334 suppress_error = 0;
15335 r = guestfs_blockdev_setrw (g, device);
15341 suppress_error = 0;
15342 r = guestfs_umount_all (g);
15348 suppress_error = 0;
15349 r = guestfs_lvm_remove_all (g);
15354 char device[] = "/dev/sda";
15355 char lines_0[] = ",";
15361 suppress_error = 0;
15362 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15367 char fstype[] = "ext2";
15368 char device[] = "/dev/sda1";
15370 suppress_error = 0;
15371 r = guestfs_mkfs (g, fstype, device);
15376 char device[] = "/dev/sda1";
15377 char mountpoint[] = "/";
15379 suppress_error = 0;
15380 r = guestfs_mount (g, device, mountpoint);
15384 /* TestRun for mkdir_p (3) */
15386 char path[] = "/new";
15388 suppress_error = 0;
15389 r = guestfs_mkdir (g, path);
15394 char path[] = "/new";
15396 suppress_error = 0;
15397 r = guestfs_mkdir_p (g, path);
15404 static int test_mkdir_p_4_skip (void)
15408 str = getenv ("TEST_ONLY");
15410 return strstr (str, "mkdir_p") == NULL;
15411 str = getenv ("SKIP_TEST_MKDIR_P_4");
15412 if (str && strcmp (str, "1") == 0) return 1;
15413 str = getenv ("SKIP_TEST_MKDIR_P");
15414 if (str && strcmp (str, "1") == 0) return 1;
15418 static int test_mkdir_p_4 (void)
15420 if (test_mkdir_p_4_skip ()) {
15421 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15425 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15427 char device[] = "/dev/sda";
15429 suppress_error = 0;
15430 r = guestfs_blockdev_setrw (g, device);
15436 suppress_error = 0;
15437 r = guestfs_umount_all (g);
15443 suppress_error = 0;
15444 r = guestfs_lvm_remove_all (g);
15449 char device[] = "/dev/sda";
15450 char lines_0[] = ",";
15456 suppress_error = 0;
15457 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15462 char fstype[] = "ext2";
15463 char device[] = "/dev/sda1";
15465 suppress_error = 0;
15466 r = guestfs_mkfs (g, fstype, device);
15471 char device[] = "/dev/sda1";
15472 char mountpoint[] = "/";
15474 suppress_error = 0;
15475 r = guestfs_mount (g, device, mountpoint);
15479 /* TestLastFail for mkdir_p (4) */
15481 char path[] = "/new";
15483 suppress_error = 0;
15484 r = guestfs_touch (g, path);
15489 char path[] = "/new";
15491 suppress_error = 1;
15492 r = guestfs_mkdir_p (g, path);
15499 static int test_mkdir_0_skip (void)
15503 str = getenv ("TEST_ONLY");
15505 return strstr (str, "mkdir") == NULL;
15506 str = getenv ("SKIP_TEST_MKDIR_0");
15507 if (str && strcmp (str, "1") == 0) return 1;
15508 str = getenv ("SKIP_TEST_MKDIR");
15509 if (str && strcmp (str, "1") == 0) return 1;
15513 static int test_mkdir_0 (void)
15515 if (test_mkdir_0_skip ()) {
15516 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15520 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
15522 char device[] = "/dev/sda";
15524 suppress_error = 0;
15525 r = guestfs_blockdev_setrw (g, device);
15531 suppress_error = 0;
15532 r = guestfs_umount_all (g);
15538 suppress_error = 0;
15539 r = guestfs_lvm_remove_all (g);
15544 char device[] = "/dev/sda";
15545 char lines_0[] = ",";
15551 suppress_error = 0;
15552 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15557 char fstype[] = "ext2";
15558 char device[] = "/dev/sda1";
15560 suppress_error = 0;
15561 r = guestfs_mkfs (g, fstype, device);
15566 char device[] = "/dev/sda1";
15567 char mountpoint[] = "/";
15569 suppress_error = 0;
15570 r = guestfs_mount (g, device, mountpoint);
15574 /* TestOutputTrue for mkdir (0) */
15576 char path[] = "/new";
15578 suppress_error = 0;
15579 r = guestfs_mkdir (g, path);
15584 char path[] = "/new";
15586 suppress_error = 0;
15587 r = guestfs_is_dir (g, path);
15591 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15598 static int test_mkdir_1_skip (void)
15602 str = getenv ("TEST_ONLY");
15604 return strstr (str, "mkdir") == NULL;
15605 str = getenv ("SKIP_TEST_MKDIR_1");
15606 if (str && strcmp (str, "1") == 0) return 1;
15607 str = getenv ("SKIP_TEST_MKDIR");
15608 if (str && strcmp (str, "1") == 0) return 1;
15612 static int test_mkdir_1 (void)
15614 if (test_mkdir_1_skip ()) {
15615 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15619 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15621 char device[] = "/dev/sda";
15623 suppress_error = 0;
15624 r = guestfs_blockdev_setrw (g, device);
15630 suppress_error = 0;
15631 r = guestfs_umount_all (g);
15637 suppress_error = 0;
15638 r = guestfs_lvm_remove_all (g);
15643 char device[] = "/dev/sda";
15644 char lines_0[] = ",";
15650 suppress_error = 0;
15651 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15656 char fstype[] = "ext2";
15657 char device[] = "/dev/sda1";
15659 suppress_error = 0;
15660 r = guestfs_mkfs (g, fstype, device);
15665 char device[] = "/dev/sda1";
15666 char mountpoint[] = "/";
15668 suppress_error = 0;
15669 r = guestfs_mount (g, device, mountpoint);
15673 /* TestLastFail for mkdir (1) */
15675 char path[] = "/new/foo/bar";
15677 suppress_error = 1;
15678 r = guestfs_mkdir (g, path);
15685 static int test_rm_rf_0_skip (void)
15689 str = getenv ("TEST_ONLY");
15691 return strstr (str, "rm_rf") == NULL;
15692 str = getenv ("SKIP_TEST_RM_RF_0");
15693 if (str && strcmp (str, "1") == 0) return 1;
15694 str = getenv ("SKIP_TEST_RM_RF");
15695 if (str && strcmp (str, "1") == 0) return 1;
15699 static int test_rm_rf_0 (void)
15701 if (test_rm_rf_0_skip ()) {
15702 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15706 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15708 char device[] = "/dev/sda";
15710 suppress_error = 0;
15711 r = guestfs_blockdev_setrw (g, device);
15717 suppress_error = 0;
15718 r = guestfs_umount_all (g);
15724 suppress_error = 0;
15725 r = guestfs_lvm_remove_all (g);
15730 char device[] = "/dev/sda";
15731 char lines_0[] = ",";
15737 suppress_error = 0;
15738 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15743 char fstype[] = "ext2";
15744 char device[] = "/dev/sda1";
15746 suppress_error = 0;
15747 r = guestfs_mkfs (g, fstype, device);
15752 char device[] = "/dev/sda1";
15753 char mountpoint[] = "/";
15755 suppress_error = 0;
15756 r = guestfs_mount (g, device, mountpoint);
15760 /* TestOutputFalse for rm_rf (0) */
15762 char path[] = "/new";
15764 suppress_error = 0;
15765 r = guestfs_mkdir (g, path);
15770 char path[] = "/new/foo";
15772 suppress_error = 0;
15773 r = guestfs_mkdir (g, path);
15778 char path[] = "/new/foo/bar";
15780 suppress_error = 0;
15781 r = guestfs_touch (g, path);
15786 char path[] = "/new";
15788 suppress_error = 0;
15789 r = guestfs_rm_rf (g, path);
15794 char path[] = "/new";
15796 suppress_error = 0;
15797 r = guestfs_exists (g, path);
15801 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
15808 static int test_rmdir_0_skip (void)
15812 str = getenv ("TEST_ONLY");
15814 return strstr (str, "rmdir") == NULL;
15815 str = getenv ("SKIP_TEST_RMDIR_0");
15816 if (str && strcmp (str, "1") == 0) return 1;
15817 str = getenv ("SKIP_TEST_RMDIR");
15818 if (str && strcmp (str, "1") == 0) return 1;
15822 static int test_rmdir_0 (void)
15824 if (test_rmdir_0_skip ()) {
15825 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
15829 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
15831 char device[] = "/dev/sda";
15833 suppress_error = 0;
15834 r = guestfs_blockdev_setrw (g, device);
15840 suppress_error = 0;
15841 r = guestfs_umount_all (g);
15847 suppress_error = 0;
15848 r = guestfs_lvm_remove_all (g);
15853 char device[] = "/dev/sda";
15854 char lines_0[] = ",";
15860 suppress_error = 0;
15861 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15866 char fstype[] = "ext2";
15867 char device[] = "/dev/sda1";
15869 suppress_error = 0;
15870 r = guestfs_mkfs (g, fstype, device);
15875 char device[] = "/dev/sda1";
15876 char mountpoint[] = "/";
15878 suppress_error = 0;
15879 r = guestfs_mount (g, device, mountpoint);
15883 /* TestRun for rmdir (0) */
15885 char path[] = "/new";
15887 suppress_error = 0;
15888 r = guestfs_mkdir (g, path);
15893 char path[] = "/new";
15895 suppress_error = 0;
15896 r = guestfs_rmdir (g, path);
15903 static int test_rmdir_1_skip (void)
15907 str = getenv ("TEST_ONLY");
15909 return strstr (str, "rmdir") == NULL;
15910 str = getenv ("SKIP_TEST_RMDIR_1");
15911 if (str && strcmp (str, "1") == 0) return 1;
15912 str = getenv ("SKIP_TEST_RMDIR");
15913 if (str && strcmp (str, "1") == 0) return 1;
15917 static int test_rmdir_1 (void)
15919 if (test_rmdir_1_skip ()) {
15920 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
15924 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
15926 char device[] = "/dev/sda";
15928 suppress_error = 0;
15929 r = guestfs_blockdev_setrw (g, device);
15935 suppress_error = 0;
15936 r = guestfs_umount_all (g);
15942 suppress_error = 0;
15943 r = guestfs_lvm_remove_all (g);
15948 char device[] = "/dev/sda";
15949 char lines_0[] = ",";
15955 suppress_error = 0;
15956 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15961 char fstype[] = "ext2";
15962 char device[] = "/dev/sda1";
15964 suppress_error = 0;
15965 r = guestfs_mkfs (g, fstype, device);
15970 char device[] = "/dev/sda1";
15971 char mountpoint[] = "/";
15973 suppress_error = 0;
15974 r = guestfs_mount (g, device, mountpoint);
15978 /* TestLastFail for rmdir (1) */
15980 char path[] = "/new";
15982 suppress_error = 1;
15983 r = guestfs_rmdir (g, path);
15990 static int test_rmdir_2_skip (void)
15994 str = getenv ("TEST_ONLY");
15996 return strstr (str, "rmdir") == NULL;
15997 str = getenv ("SKIP_TEST_RMDIR_2");
15998 if (str && strcmp (str, "1") == 0) return 1;
15999 str = getenv ("SKIP_TEST_RMDIR");
16000 if (str && strcmp (str, "1") == 0) return 1;
16004 static int test_rmdir_2 (void)
16006 if (test_rmdir_2_skip ()) {
16007 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16011 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16013 char device[] = "/dev/sda";
16015 suppress_error = 0;
16016 r = guestfs_blockdev_setrw (g, device);
16022 suppress_error = 0;
16023 r = guestfs_umount_all (g);
16029 suppress_error = 0;
16030 r = guestfs_lvm_remove_all (g);
16035 char device[] = "/dev/sda";
16036 char lines_0[] = ",";
16042 suppress_error = 0;
16043 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16048 char fstype[] = "ext2";
16049 char device[] = "/dev/sda1";
16051 suppress_error = 0;
16052 r = guestfs_mkfs (g, fstype, device);
16057 char device[] = "/dev/sda1";
16058 char mountpoint[] = "/";
16060 suppress_error = 0;
16061 r = guestfs_mount (g, device, mountpoint);
16065 /* TestLastFail for rmdir (2) */
16067 char path[] = "/new";
16069 suppress_error = 0;
16070 r = guestfs_touch (g, path);
16075 char path[] = "/new";
16077 suppress_error = 1;
16078 r = guestfs_rmdir (g, path);
16085 static int test_rm_0_skip (void)
16089 str = getenv ("TEST_ONLY");
16091 return strstr (str, "rm") == NULL;
16092 str = getenv ("SKIP_TEST_RM_0");
16093 if (str && strcmp (str, "1") == 0) return 1;
16094 str = getenv ("SKIP_TEST_RM");
16095 if (str && strcmp (str, "1") == 0) return 1;
16099 static int test_rm_0 (void)
16101 if (test_rm_0_skip ()) {
16102 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16106 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16108 char device[] = "/dev/sda";
16110 suppress_error = 0;
16111 r = guestfs_blockdev_setrw (g, device);
16117 suppress_error = 0;
16118 r = guestfs_umount_all (g);
16124 suppress_error = 0;
16125 r = guestfs_lvm_remove_all (g);
16130 char device[] = "/dev/sda";
16131 char lines_0[] = ",";
16137 suppress_error = 0;
16138 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16143 char fstype[] = "ext2";
16144 char device[] = "/dev/sda1";
16146 suppress_error = 0;
16147 r = guestfs_mkfs (g, fstype, device);
16152 char device[] = "/dev/sda1";
16153 char mountpoint[] = "/";
16155 suppress_error = 0;
16156 r = guestfs_mount (g, device, mountpoint);
16160 /* TestRun for rm (0) */
16162 char path[] = "/new";
16164 suppress_error = 0;
16165 r = guestfs_touch (g, path);
16170 char path[] = "/new";
16172 suppress_error = 0;
16173 r = guestfs_rm (g, path);
16180 static int test_rm_1_skip (void)
16184 str = getenv ("TEST_ONLY");
16186 return strstr (str, "rm") == NULL;
16187 str = getenv ("SKIP_TEST_RM_1");
16188 if (str && strcmp (str, "1") == 0) return 1;
16189 str = getenv ("SKIP_TEST_RM");
16190 if (str && strcmp (str, "1") == 0) return 1;
16194 static int test_rm_1 (void)
16196 if (test_rm_1_skip ()) {
16197 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16201 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16203 char device[] = "/dev/sda";
16205 suppress_error = 0;
16206 r = guestfs_blockdev_setrw (g, device);
16212 suppress_error = 0;
16213 r = guestfs_umount_all (g);
16219 suppress_error = 0;
16220 r = guestfs_lvm_remove_all (g);
16225 char device[] = "/dev/sda";
16226 char lines_0[] = ",";
16232 suppress_error = 0;
16233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16238 char fstype[] = "ext2";
16239 char device[] = "/dev/sda1";
16241 suppress_error = 0;
16242 r = guestfs_mkfs (g, fstype, device);
16247 char device[] = "/dev/sda1";
16248 char mountpoint[] = "/";
16250 suppress_error = 0;
16251 r = guestfs_mount (g, device, mountpoint);
16255 /* TestLastFail for rm (1) */
16257 char path[] = "/new";
16259 suppress_error = 1;
16260 r = guestfs_rm (g, path);
16267 static int test_rm_2_skip (void)
16271 str = getenv ("TEST_ONLY");
16273 return strstr (str, "rm") == NULL;
16274 str = getenv ("SKIP_TEST_RM_2");
16275 if (str && strcmp (str, "1") == 0) return 1;
16276 str = getenv ("SKIP_TEST_RM");
16277 if (str && strcmp (str, "1") == 0) return 1;
16281 static int test_rm_2 (void)
16283 if (test_rm_2_skip ()) {
16284 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16288 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16290 char device[] = "/dev/sda";
16292 suppress_error = 0;
16293 r = guestfs_blockdev_setrw (g, device);
16299 suppress_error = 0;
16300 r = guestfs_umount_all (g);
16306 suppress_error = 0;
16307 r = guestfs_lvm_remove_all (g);
16312 char device[] = "/dev/sda";
16313 char lines_0[] = ",";
16319 suppress_error = 0;
16320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16325 char fstype[] = "ext2";
16326 char device[] = "/dev/sda1";
16328 suppress_error = 0;
16329 r = guestfs_mkfs (g, fstype, device);
16334 char device[] = "/dev/sda1";
16335 char mountpoint[] = "/";
16337 suppress_error = 0;
16338 r = guestfs_mount (g, device, mountpoint);
16342 /* TestLastFail for rm (2) */
16344 char path[] = "/new";
16346 suppress_error = 0;
16347 r = guestfs_mkdir (g, path);
16352 char path[] = "/new";
16354 suppress_error = 1;
16355 r = guestfs_rm (g, path);
16362 static int test_read_lines_0_skip (void)
16366 str = getenv ("TEST_ONLY");
16368 return strstr (str, "read_lines") == NULL;
16369 str = getenv ("SKIP_TEST_READ_LINES_0");
16370 if (str && strcmp (str, "1") == 0) return 1;
16371 str = getenv ("SKIP_TEST_READ_LINES");
16372 if (str && strcmp (str, "1") == 0) return 1;
16376 static int test_read_lines_0 (void)
16378 if (test_read_lines_0_skip ()) {
16379 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16383 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16385 char device[] = "/dev/sda";
16387 suppress_error = 0;
16388 r = guestfs_blockdev_setrw (g, device);
16394 suppress_error = 0;
16395 r = guestfs_umount_all (g);
16401 suppress_error = 0;
16402 r = guestfs_lvm_remove_all (g);
16407 char device[] = "/dev/sda";
16408 char lines_0[] = ",";
16414 suppress_error = 0;
16415 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16420 char fstype[] = "ext2";
16421 char device[] = "/dev/sda1";
16423 suppress_error = 0;
16424 r = guestfs_mkfs (g, fstype, device);
16429 char device[] = "/dev/sda1";
16430 char mountpoint[] = "/";
16432 suppress_error = 0;
16433 r = guestfs_mount (g, device, mountpoint);
16437 /* TestOutputList for read_lines (0) */
16439 char path[] = "/new";
16440 char content[] = "line1\r\nline2\nline3";
16442 suppress_error = 0;
16443 r = guestfs_write_file (g, path, content, 0);
16448 char path[] = "/new";
16451 suppress_error = 0;
16452 r = guestfs_read_lines (g, path);
16456 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16461 char expected[] = "line1";
16462 if (strcmp (r[0], expected) != 0) {
16463 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16468 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16473 char expected[] = "line2";
16474 if (strcmp (r[1], expected) != 0) {
16475 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16480 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16485 char expected[] = "line3";
16486 if (strcmp (r[2], expected) != 0) {
16487 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16491 if (r[3] != NULL) {
16492 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16496 for (i = 0; r[i] != NULL; ++i)
16503 static int test_read_lines_1_skip (void)
16507 str = getenv ("TEST_ONLY");
16509 return strstr (str, "read_lines") == NULL;
16510 str = getenv ("SKIP_TEST_READ_LINES_1");
16511 if (str && strcmp (str, "1") == 0) return 1;
16512 str = getenv ("SKIP_TEST_READ_LINES");
16513 if (str && strcmp (str, "1") == 0) return 1;
16517 static int test_read_lines_1 (void)
16519 if (test_read_lines_1_skip ()) {
16520 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16524 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16526 char device[] = "/dev/sda";
16528 suppress_error = 0;
16529 r = guestfs_blockdev_setrw (g, device);
16535 suppress_error = 0;
16536 r = guestfs_umount_all (g);
16542 suppress_error = 0;
16543 r = guestfs_lvm_remove_all (g);
16548 char device[] = "/dev/sda";
16549 char lines_0[] = ",";
16555 suppress_error = 0;
16556 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16561 char fstype[] = "ext2";
16562 char device[] = "/dev/sda1";
16564 suppress_error = 0;
16565 r = guestfs_mkfs (g, fstype, device);
16570 char device[] = "/dev/sda1";
16571 char mountpoint[] = "/";
16573 suppress_error = 0;
16574 r = guestfs_mount (g, device, mountpoint);
16578 /* TestOutputList for read_lines (1) */
16580 char path[] = "/new";
16581 char content[] = "";
16583 suppress_error = 0;
16584 r = guestfs_write_file (g, path, content, 0);
16589 char path[] = "/new";
16592 suppress_error = 0;
16593 r = guestfs_read_lines (g, path);
16596 if (r[0] != NULL) {
16597 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16601 for (i = 0; r[i] != NULL; ++i)
16608 static int test_lvs_0_skip (void)
16612 str = getenv ("TEST_ONLY");
16614 return strstr (str, "lvs") == NULL;
16615 str = getenv ("SKIP_TEST_LVS_0");
16616 if (str && strcmp (str, "1") == 0) return 1;
16617 str = getenv ("SKIP_TEST_LVS");
16618 if (str && strcmp (str, "1") == 0) return 1;
16622 static int test_lvs_0 (void)
16624 if (test_lvs_0_skip ()) {
16625 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16629 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16631 char device[] = "/dev/sda";
16633 suppress_error = 0;
16634 r = guestfs_blockdev_setrw (g, device);
16640 suppress_error = 0;
16641 r = guestfs_umount_all (g);
16647 suppress_error = 0;
16648 r = guestfs_lvm_remove_all (g);
16653 char device[] = "/dev/sda";
16654 char lines_0[] = ",";
16660 suppress_error = 0;
16661 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16666 char device[] = "/dev/sda1";
16668 suppress_error = 0;
16669 r = guestfs_pvcreate (g, device);
16674 char volgroup[] = "VG";
16675 char physvols_0[] = "/dev/sda1";
16676 char *physvols[] = {
16681 suppress_error = 0;
16682 r = guestfs_vgcreate (g, volgroup, physvols);
16687 char logvol[] = "LV";
16688 char volgroup[] = "VG";
16690 suppress_error = 0;
16691 r = guestfs_lvcreate (g, logvol, volgroup, 8);
16696 char fstype[] = "ext2";
16697 char device[] = "/dev/VG/LV";
16699 suppress_error = 0;
16700 r = guestfs_mkfs (g, fstype, device);
16705 char device[] = "/dev/VG/LV";
16706 char mountpoint[] = "/";
16708 suppress_error = 0;
16709 r = guestfs_mount (g, device, mountpoint);
16713 /* TestOutputList for lvs (0) */
16717 suppress_error = 0;
16718 r = guestfs_lvs (g);
16722 fprintf (stderr, "test_lvs_0: short list returned from command\n");
16727 char expected[] = "/dev/VG/LV";
16728 if (strcmp (r[0], expected) != 0) {
16729 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16733 if (r[1] != NULL) {
16734 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16738 for (i = 0; r[i] != NULL; ++i)
16745 static int test_lvs_1_skip (void)
16749 str = getenv ("TEST_ONLY");
16751 return strstr (str, "lvs") == NULL;
16752 str = getenv ("SKIP_TEST_LVS_1");
16753 if (str && strcmp (str, "1") == 0) return 1;
16754 str = getenv ("SKIP_TEST_LVS");
16755 if (str && strcmp (str, "1") == 0) return 1;
16759 static int test_lvs_1 (void)
16761 if (test_lvs_1_skip ()) {
16762 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
16766 /* InitNone|InitEmpty for test_lvs_1 */
16768 char device[] = "/dev/sda";
16770 suppress_error = 0;
16771 r = guestfs_blockdev_setrw (g, device);
16777 suppress_error = 0;
16778 r = guestfs_umount_all (g);
16784 suppress_error = 0;
16785 r = guestfs_lvm_remove_all (g);
16789 /* TestOutputList for lvs (1) */
16791 char device[] = "/dev/sda";
16792 char lines_0[] = ",10";
16793 char lines_1[] = ",20";
16794 char lines_2[] = ",";
16802 suppress_error = 0;
16803 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16808 char device[] = "/dev/sda1";
16810 suppress_error = 0;
16811 r = guestfs_pvcreate (g, device);
16816 char device[] = "/dev/sda2";
16818 suppress_error = 0;
16819 r = guestfs_pvcreate (g, device);
16824 char device[] = "/dev/sda3";
16826 suppress_error = 0;
16827 r = guestfs_pvcreate (g, device);
16832 char volgroup[] = "VG1";
16833 char physvols_0[] = "/dev/sda1";
16834 char physvols_1[] = "/dev/sda2";
16835 char *physvols[] = {
16841 suppress_error = 0;
16842 r = guestfs_vgcreate (g, volgroup, physvols);
16847 char volgroup[] = "VG2";
16848 char physvols_0[] = "/dev/sda3";
16849 char *physvols[] = {
16854 suppress_error = 0;
16855 r = guestfs_vgcreate (g, volgroup, physvols);
16860 char logvol[] = "LV1";
16861 char volgroup[] = "VG1";
16863 suppress_error = 0;
16864 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16869 char logvol[] = "LV2";
16870 char volgroup[] = "VG1";
16872 suppress_error = 0;
16873 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16878 char logvol[] = "LV3";
16879 char volgroup[] = "VG2";
16881 suppress_error = 0;
16882 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16889 suppress_error = 0;
16890 r = guestfs_lvs (g);
16894 fprintf (stderr, "test_lvs_1: short list returned from command\n");
16899 char expected[] = "/dev/VG1/LV1";
16900 if (strcmp (r[0], expected) != 0) {
16901 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16906 fprintf (stderr, "test_lvs_1: short list returned from command\n");
16911 char expected[] = "/dev/VG1/LV2";
16912 if (strcmp (r[1], expected) != 0) {
16913 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16918 fprintf (stderr, "test_lvs_1: short list returned from command\n");
16923 char expected[] = "/dev/VG2/LV3";
16924 if (strcmp (r[2], expected) != 0) {
16925 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16929 if (r[3] != NULL) {
16930 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
16934 for (i = 0; r[i] != NULL; ++i)
16941 static int test_vgs_0_skip (void)
16945 str = getenv ("TEST_ONLY");
16947 return strstr (str, "vgs") == NULL;
16948 str = getenv ("SKIP_TEST_VGS_0");
16949 if (str && strcmp (str, "1") == 0) return 1;
16950 str = getenv ("SKIP_TEST_VGS");
16951 if (str && strcmp (str, "1") == 0) return 1;
16955 static int test_vgs_0 (void)
16957 if (test_vgs_0_skip ()) {
16958 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
16962 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
16964 char device[] = "/dev/sda";
16966 suppress_error = 0;
16967 r = guestfs_blockdev_setrw (g, device);
16973 suppress_error = 0;
16974 r = guestfs_umount_all (g);
16980 suppress_error = 0;
16981 r = guestfs_lvm_remove_all (g);
16986 char device[] = "/dev/sda";
16987 char lines_0[] = ",";
16993 suppress_error = 0;
16994 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16999 char device[] = "/dev/sda1";
17001 suppress_error = 0;
17002 r = guestfs_pvcreate (g, device);
17007 char volgroup[] = "VG";
17008 char physvols_0[] = "/dev/sda1";
17009 char *physvols[] = {
17014 suppress_error = 0;
17015 r = guestfs_vgcreate (g, volgroup, physvols);
17020 char logvol[] = "LV";
17021 char volgroup[] = "VG";
17023 suppress_error = 0;
17024 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17029 char fstype[] = "ext2";
17030 char device[] = "/dev/VG/LV";
17032 suppress_error = 0;
17033 r = guestfs_mkfs (g, fstype, device);
17038 char device[] = "/dev/VG/LV";
17039 char mountpoint[] = "/";
17041 suppress_error = 0;
17042 r = guestfs_mount (g, device, mountpoint);
17046 /* TestOutputList for vgs (0) */
17050 suppress_error = 0;
17051 r = guestfs_vgs (g);
17055 fprintf (stderr, "test_vgs_0: short list returned from command\n");
17060 char expected[] = "VG";
17061 if (strcmp (r[0], expected) != 0) {
17062 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17066 if (r[1] != NULL) {
17067 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17071 for (i = 0; r[i] != NULL; ++i)
17078 static int test_vgs_1_skip (void)
17082 str = getenv ("TEST_ONLY");
17084 return strstr (str, "vgs") == NULL;
17085 str = getenv ("SKIP_TEST_VGS_1");
17086 if (str && strcmp (str, "1") == 0) return 1;
17087 str = getenv ("SKIP_TEST_VGS");
17088 if (str && strcmp (str, "1") == 0) return 1;
17092 static int test_vgs_1 (void)
17094 if (test_vgs_1_skip ()) {
17095 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17099 /* InitNone|InitEmpty for test_vgs_1 */
17101 char device[] = "/dev/sda";
17103 suppress_error = 0;
17104 r = guestfs_blockdev_setrw (g, device);
17110 suppress_error = 0;
17111 r = guestfs_umount_all (g);
17117 suppress_error = 0;
17118 r = guestfs_lvm_remove_all (g);
17122 /* TestOutputList for vgs (1) */
17124 char device[] = "/dev/sda";
17125 char lines_0[] = ",10";
17126 char lines_1[] = ",20";
17127 char lines_2[] = ",";
17135 suppress_error = 0;
17136 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17141 char device[] = "/dev/sda1";
17143 suppress_error = 0;
17144 r = guestfs_pvcreate (g, device);
17149 char device[] = "/dev/sda2";
17151 suppress_error = 0;
17152 r = guestfs_pvcreate (g, device);
17157 char device[] = "/dev/sda3";
17159 suppress_error = 0;
17160 r = guestfs_pvcreate (g, device);
17165 char volgroup[] = "VG1";
17166 char physvols_0[] = "/dev/sda1";
17167 char physvols_1[] = "/dev/sda2";
17168 char *physvols[] = {
17174 suppress_error = 0;
17175 r = guestfs_vgcreate (g, volgroup, physvols);
17180 char volgroup[] = "VG2";
17181 char physvols_0[] = "/dev/sda3";
17182 char *physvols[] = {
17187 suppress_error = 0;
17188 r = guestfs_vgcreate (g, volgroup, physvols);
17195 suppress_error = 0;
17196 r = guestfs_vgs (g);
17200 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17205 char expected[] = "VG1";
17206 if (strcmp (r[0], expected) != 0) {
17207 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17212 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17217 char expected[] = "VG2";
17218 if (strcmp (r[1], expected) != 0) {
17219 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17223 if (r[2] != NULL) {
17224 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17228 for (i = 0; r[i] != NULL; ++i)
17235 static int test_pvs_0_skip (void)
17239 str = getenv ("TEST_ONLY");
17241 return strstr (str, "pvs") == NULL;
17242 str = getenv ("SKIP_TEST_PVS_0");
17243 if (str && strcmp (str, "1") == 0) return 1;
17244 str = getenv ("SKIP_TEST_PVS");
17245 if (str && strcmp (str, "1") == 0) return 1;
17249 static int test_pvs_0 (void)
17251 if (test_pvs_0_skip ()) {
17252 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17256 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17258 char device[] = "/dev/sda";
17260 suppress_error = 0;
17261 r = guestfs_blockdev_setrw (g, device);
17267 suppress_error = 0;
17268 r = guestfs_umount_all (g);
17274 suppress_error = 0;
17275 r = guestfs_lvm_remove_all (g);
17280 char device[] = "/dev/sda";
17281 char lines_0[] = ",";
17287 suppress_error = 0;
17288 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17293 char device[] = "/dev/sda1";
17295 suppress_error = 0;
17296 r = guestfs_pvcreate (g, device);
17301 char volgroup[] = "VG";
17302 char physvols_0[] = "/dev/sda1";
17303 char *physvols[] = {
17308 suppress_error = 0;
17309 r = guestfs_vgcreate (g, volgroup, physvols);
17314 char logvol[] = "LV";
17315 char volgroup[] = "VG";
17317 suppress_error = 0;
17318 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17323 char fstype[] = "ext2";
17324 char device[] = "/dev/VG/LV";
17326 suppress_error = 0;
17327 r = guestfs_mkfs (g, fstype, device);
17332 char device[] = "/dev/VG/LV";
17333 char mountpoint[] = "/";
17335 suppress_error = 0;
17336 r = guestfs_mount (g, device, mountpoint);
17340 /* TestOutputListOfDevices for pvs (0) */
17344 suppress_error = 0;
17345 r = guestfs_pvs (g);
17349 fprintf (stderr, "test_pvs_0: short list returned from command\n");
17354 char expected[] = "/dev/sda1";
17356 if (strcmp (r[0], expected) != 0) {
17357 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17361 if (r[1] != NULL) {
17362 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17366 for (i = 0; r[i] != NULL; ++i)
17373 static int test_pvs_1_skip (void)
17377 str = getenv ("TEST_ONLY");
17379 return strstr (str, "pvs") == NULL;
17380 str = getenv ("SKIP_TEST_PVS_1");
17381 if (str && strcmp (str, "1") == 0) return 1;
17382 str = getenv ("SKIP_TEST_PVS");
17383 if (str && strcmp (str, "1") == 0) return 1;
17387 static int test_pvs_1 (void)
17389 if (test_pvs_1_skip ()) {
17390 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17394 /* InitNone|InitEmpty for test_pvs_1 */
17396 char device[] = "/dev/sda";
17398 suppress_error = 0;
17399 r = guestfs_blockdev_setrw (g, device);
17405 suppress_error = 0;
17406 r = guestfs_umount_all (g);
17412 suppress_error = 0;
17413 r = guestfs_lvm_remove_all (g);
17417 /* TestOutputListOfDevices for pvs (1) */
17419 char device[] = "/dev/sda";
17420 char lines_0[] = ",10";
17421 char lines_1[] = ",20";
17422 char lines_2[] = ",";
17430 suppress_error = 0;
17431 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17436 char device[] = "/dev/sda1";
17438 suppress_error = 0;
17439 r = guestfs_pvcreate (g, device);
17444 char device[] = "/dev/sda2";
17446 suppress_error = 0;
17447 r = guestfs_pvcreate (g, device);
17452 char device[] = "/dev/sda3";
17454 suppress_error = 0;
17455 r = guestfs_pvcreate (g, device);
17462 suppress_error = 0;
17463 r = guestfs_pvs (g);
17467 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17472 char expected[] = "/dev/sda1";
17474 if (strcmp (r[0], expected) != 0) {
17475 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17480 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17485 char expected[] = "/dev/sda2";
17487 if (strcmp (r[1], expected) != 0) {
17488 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17493 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17498 char expected[] = "/dev/sda3";
17500 if (strcmp (r[2], expected) != 0) {
17501 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17505 if (r[3] != NULL) {
17506 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17510 for (i = 0; r[i] != NULL; ++i)
17517 static int test_list_partitions_0_skip (void)
17521 str = getenv ("TEST_ONLY");
17523 return strstr (str, "list_partitions") == NULL;
17524 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17525 if (str && strcmp (str, "1") == 0) return 1;
17526 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17527 if (str && strcmp (str, "1") == 0) return 1;
17531 static int test_list_partitions_0 (void)
17533 if (test_list_partitions_0_skip ()) {
17534 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17538 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17540 char device[] = "/dev/sda";
17542 suppress_error = 0;
17543 r = guestfs_blockdev_setrw (g, device);
17549 suppress_error = 0;
17550 r = guestfs_umount_all (g);
17556 suppress_error = 0;
17557 r = guestfs_lvm_remove_all (g);
17562 char device[] = "/dev/sda";
17563 char lines_0[] = ",";
17569 suppress_error = 0;
17570 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17575 char fstype[] = "ext2";
17576 char device[] = "/dev/sda1";
17578 suppress_error = 0;
17579 r = guestfs_mkfs (g, fstype, device);
17584 char device[] = "/dev/sda1";
17585 char mountpoint[] = "/";
17587 suppress_error = 0;
17588 r = guestfs_mount (g, device, mountpoint);
17592 /* TestOutputListOfDevices for list_partitions (0) */
17596 suppress_error = 0;
17597 r = guestfs_list_partitions (g);
17601 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17606 char expected[] = "/dev/sda1";
17608 if (strcmp (r[0], expected) != 0) {
17609 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17613 if (r[1] != NULL) {
17614 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17618 for (i = 0; r[i] != NULL; ++i)
17625 static int test_list_partitions_1_skip (void)
17629 str = getenv ("TEST_ONLY");
17631 return strstr (str, "list_partitions") == NULL;
17632 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17633 if (str && strcmp (str, "1") == 0) return 1;
17634 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17635 if (str && strcmp (str, "1") == 0) return 1;
17639 static int test_list_partitions_1 (void)
17641 if (test_list_partitions_1_skip ()) {
17642 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17646 /* InitNone|InitEmpty for test_list_partitions_1 */
17648 char device[] = "/dev/sda";
17650 suppress_error = 0;
17651 r = guestfs_blockdev_setrw (g, device);
17657 suppress_error = 0;
17658 r = guestfs_umount_all (g);
17664 suppress_error = 0;
17665 r = guestfs_lvm_remove_all (g);
17669 /* TestOutputListOfDevices for list_partitions (1) */
17671 char device[] = "/dev/sda";
17672 char lines_0[] = ",10";
17673 char lines_1[] = ",20";
17674 char lines_2[] = ",";
17682 suppress_error = 0;
17683 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17690 suppress_error = 0;
17691 r = guestfs_list_partitions (g);
17695 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17700 char expected[] = "/dev/sda1";
17702 if (strcmp (r[0], expected) != 0) {
17703 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17708 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17713 char expected[] = "/dev/sda2";
17715 if (strcmp (r[1], expected) != 0) {
17716 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17721 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17726 char expected[] = "/dev/sda3";
17728 if (strcmp (r[2], expected) != 0) {
17729 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17733 if (r[3] != NULL) {
17734 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17738 for (i = 0; r[i] != NULL; ++i)
17745 static int test_list_devices_0_skip (void)
17749 str = getenv ("TEST_ONLY");
17751 return strstr (str, "list_devices") == NULL;
17752 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
17753 if (str && strcmp (str, "1") == 0) return 1;
17754 str = getenv ("SKIP_TEST_LIST_DEVICES");
17755 if (str && strcmp (str, "1") == 0) return 1;
17759 static int test_list_devices_0 (void)
17761 if (test_list_devices_0_skip ()) {
17762 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
17766 /* InitNone|InitEmpty for test_list_devices_0 */
17768 char device[] = "/dev/sda";
17770 suppress_error = 0;
17771 r = guestfs_blockdev_setrw (g, device);
17777 suppress_error = 0;
17778 r = guestfs_umount_all (g);
17784 suppress_error = 0;
17785 r = guestfs_lvm_remove_all (g);
17789 /* TestOutputListOfDevices for list_devices (0) */
17793 suppress_error = 0;
17794 r = guestfs_list_devices (g);
17798 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17803 char expected[] = "/dev/sda";
17805 if (strcmp (r[0], expected) != 0) {
17806 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17811 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17816 char expected[] = "/dev/sdb";
17818 if (strcmp (r[1], expected) != 0) {
17819 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17824 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17829 char expected[] = "/dev/sdc";
17831 if (strcmp (r[2], expected) != 0) {
17832 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17837 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17842 char expected[] = "/dev/sdd";
17844 if (strcmp (r[3], expected) != 0) {
17845 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
17849 if (r[4] != NULL) {
17850 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
17854 for (i = 0; r[i] != NULL; ++i)
17861 static int test_ls_0_skip (void)
17865 str = getenv ("TEST_ONLY");
17867 return strstr (str, "ls") == NULL;
17868 str = getenv ("SKIP_TEST_LS_0");
17869 if (str && strcmp (str, "1") == 0) return 1;
17870 str = getenv ("SKIP_TEST_LS");
17871 if (str && strcmp (str, "1") == 0) return 1;
17875 static int test_ls_0 (void)
17877 if (test_ls_0_skip ()) {
17878 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
17882 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
17884 char device[] = "/dev/sda";
17886 suppress_error = 0;
17887 r = guestfs_blockdev_setrw (g, device);
17893 suppress_error = 0;
17894 r = guestfs_umount_all (g);
17900 suppress_error = 0;
17901 r = guestfs_lvm_remove_all (g);
17906 char device[] = "/dev/sda";
17907 char lines_0[] = ",";
17913 suppress_error = 0;
17914 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17919 char fstype[] = "ext2";
17920 char device[] = "/dev/sda1";
17922 suppress_error = 0;
17923 r = guestfs_mkfs (g, fstype, device);
17928 char device[] = "/dev/sda1";
17929 char mountpoint[] = "/";
17931 suppress_error = 0;
17932 r = guestfs_mount (g, device, mountpoint);
17936 /* TestOutputList for ls (0) */
17938 char path[] = "/new";
17940 suppress_error = 0;
17941 r = guestfs_touch (g, path);
17946 char path[] = "/newer";
17948 suppress_error = 0;
17949 r = guestfs_touch (g, path);
17954 char path[] = "/newest";
17956 suppress_error = 0;
17957 r = guestfs_touch (g, path);
17962 char directory[] = "/";
17965 suppress_error = 0;
17966 r = guestfs_ls (g, directory);
17970 fprintf (stderr, "test_ls_0: short list returned from command\n");
17975 char expected[] = "lost+found";
17976 if (strcmp (r[0], expected) != 0) {
17977 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17982 fprintf (stderr, "test_ls_0: short list returned from command\n");
17987 char expected[] = "new";
17988 if (strcmp (r[1], expected) != 0) {
17989 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17994 fprintf (stderr, "test_ls_0: short list returned from command\n");
17999 char expected[] = "newer";
18000 if (strcmp (r[2], expected) != 0) {
18001 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18006 fprintf (stderr, "test_ls_0: short list returned from command\n");
18011 char expected[] = "newest";
18012 if (strcmp (r[3], expected) != 0) {
18013 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18017 if (r[4] != NULL) {
18018 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18022 for (i = 0; r[i] != NULL; ++i)
18029 static int test_cat_0_skip (void)
18033 str = getenv ("TEST_ONLY");
18035 return strstr (str, "cat") == NULL;
18036 str = getenv ("SKIP_TEST_CAT_0");
18037 if (str && strcmp (str, "1") == 0) return 1;
18038 str = getenv ("SKIP_TEST_CAT");
18039 if (str && strcmp (str, "1") == 0) return 1;
18043 static int test_cat_0 (void)
18045 if (test_cat_0_skip ()) {
18046 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18050 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18052 char device[] = "/dev/sda";
18054 suppress_error = 0;
18055 r = guestfs_blockdev_setrw (g, device);
18061 suppress_error = 0;
18062 r = guestfs_umount_all (g);
18068 suppress_error = 0;
18069 r = guestfs_lvm_remove_all (g);
18074 char device[] = "/dev/sda";
18075 char lines_0[] = ",";
18081 suppress_error = 0;
18082 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18087 char fstype[] = "ext2";
18088 char device[] = "/dev/sda1";
18090 suppress_error = 0;
18091 r = guestfs_mkfs (g, fstype, device);
18096 char device[] = "/dev/sda1";
18097 char mountpoint[] = "/";
18099 suppress_error = 0;
18100 r = guestfs_mount (g, device, mountpoint);
18104 /* TestOutput for cat (0) */
18105 char expected[] = "new file contents";
18107 char path[] = "/new";
18108 char content[] = "new file contents";
18110 suppress_error = 0;
18111 r = guestfs_write_file (g, path, content, 0);
18116 char path[] = "/new";
18118 suppress_error = 0;
18119 r = guestfs_cat (g, path);
18122 if (strcmp (r, expected) != 0) {
18123 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18131 static int test_touch_0_skip (void)
18135 str = getenv ("TEST_ONLY");
18137 return strstr (str, "touch") == NULL;
18138 str = getenv ("SKIP_TEST_TOUCH_0");
18139 if (str && strcmp (str, "1") == 0) return 1;
18140 str = getenv ("SKIP_TEST_TOUCH");
18141 if (str && strcmp (str, "1") == 0) return 1;
18145 static int test_touch_0 (void)
18147 if (test_touch_0_skip ()) {
18148 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18152 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
18154 char device[] = "/dev/sda";
18156 suppress_error = 0;
18157 r = guestfs_blockdev_setrw (g, device);
18163 suppress_error = 0;
18164 r = guestfs_umount_all (g);
18170 suppress_error = 0;
18171 r = guestfs_lvm_remove_all (g);
18176 char device[] = "/dev/sda";
18177 char lines_0[] = ",";
18183 suppress_error = 0;
18184 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18189 char fstype[] = "ext2";
18190 char device[] = "/dev/sda1";
18192 suppress_error = 0;
18193 r = guestfs_mkfs (g, fstype, device);
18198 char device[] = "/dev/sda1";
18199 char mountpoint[] = "/";
18201 suppress_error = 0;
18202 r = guestfs_mount (g, device, mountpoint);
18206 /* TestOutputTrue for touch (0) */
18208 char path[] = "/new";
18210 suppress_error = 0;
18211 r = guestfs_touch (g, path);
18216 char path[] = "/new";
18218 suppress_error = 0;
18219 r = guestfs_exists (g, path);
18223 fprintf (stderr, "test_touch_0: expected true, got false\n");
18230 static int test_sync_0_skip (void)
18234 str = getenv ("TEST_ONLY");
18236 return strstr (str, "sync") == NULL;
18237 str = getenv ("SKIP_TEST_SYNC_0");
18238 if (str && strcmp (str, "1") == 0) return 1;
18239 str = getenv ("SKIP_TEST_SYNC");
18240 if (str && strcmp (str, "1") == 0) return 1;
18244 static int test_sync_0 (void)
18246 if (test_sync_0_skip ()) {
18247 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18251 /* InitNone|InitEmpty for test_sync_0 */
18253 char device[] = "/dev/sda";
18255 suppress_error = 0;
18256 r = guestfs_blockdev_setrw (g, device);
18262 suppress_error = 0;
18263 r = guestfs_umount_all (g);
18269 suppress_error = 0;
18270 r = guestfs_lvm_remove_all (g);
18274 /* TestRun for sync (0) */
18277 suppress_error = 0;
18278 r = guestfs_sync (g);
18285 static int test_mount_0_skip (void)
18289 str = getenv ("TEST_ONLY");
18291 return strstr (str, "mount") == NULL;
18292 str = getenv ("SKIP_TEST_MOUNT_0");
18293 if (str && strcmp (str, "1") == 0) return 1;
18294 str = getenv ("SKIP_TEST_MOUNT");
18295 if (str && strcmp (str, "1") == 0) return 1;
18299 static int test_mount_0 (void)
18301 if (test_mount_0_skip ()) {
18302 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18306 /* InitNone|InitEmpty for test_mount_0 */
18308 char device[] = "/dev/sda";
18310 suppress_error = 0;
18311 r = guestfs_blockdev_setrw (g, device);
18317 suppress_error = 0;
18318 r = guestfs_umount_all (g);
18324 suppress_error = 0;
18325 r = guestfs_lvm_remove_all (g);
18329 /* TestOutput for mount (0) */
18330 char expected[] = "new file contents";
18332 char device[] = "/dev/sda";
18333 char lines_0[] = ",";
18339 suppress_error = 0;
18340 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18345 char fstype[] = "ext2";
18346 char device[] = "/dev/sda1";
18348 suppress_error = 0;
18349 r = guestfs_mkfs (g, fstype, device);
18354 char device[] = "/dev/sda1";
18355 char mountpoint[] = "/";
18357 suppress_error = 0;
18358 r = guestfs_mount (g, device, mountpoint);
18363 char path[] = "/new";
18364 char content[] = "new file contents";
18366 suppress_error = 0;
18367 r = guestfs_write_file (g, path, content, 0);
18372 char path[] = "/new";
18374 suppress_error = 0;
18375 r = guestfs_cat (g, path);
18378 if (strcmp (r, expected) != 0) {
18379 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18387 int main (int argc, char *argv[])
18391 const char *filename;
18393 int nr_tests, test_num = 0;
18395 no_test_warnings ();
18397 g = guestfs_create ();
18399 printf ("guestfs_create FAILED\n");
18403 guestfs_set_error_handler (g, print_error, NULL);
18405 guestfs_set_path (g, "../appliance");
18407 filename = "test1.img";
18408 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18413 if (lseek (fd, 524288000, SEEK_SET) == -1) {
18419 if (write (fd, &c, 1) == -1) {
18425 if (close (fd) == -1) {
18430 if (guestfs_add_drive (g, filename) == -1) {
18431 printf ("guestfs_add_drive %s FAILED\n", filename);
18435 filename = "test2.img";
18436 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18441 if (lseek (fd, 52428800, SEEK_SET) == -1) {
18447 if (write (fd, &c, 1) == -1) {
18453 if (close (fd) == -1) {
18458 if (guestfs_add_drive (g, filename) == -1) {
18459 printf ("guestfs_add_drive %s FAILED\n", filename);
18463 filename = "test3.img";
18464 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18469 if (lseek (fd, 10485760, SEEK_SET) == -1) {
18475 if (write (fd, &c, 1) == -1) {
18481 if (close (fd) == -1) {
18486 if (guestfs_add_drive (g, filename) == -1) {
18487 printf ("guestfs_add_drive %s FAILED\n", filename);
18491 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18492 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18496 if (guestfs_launch (g) == -1) {
18497 printf ("guestfs_launch FAILED\n");
18501 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18504 if (guestfs_wait_ready (g) == -1) {
18505 printf ("guestfs_wait_ready FAILED\n");
18509 /* Cancel previous alarm. */
18515 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18516 if (test_tail_n_0 () == -1) {
18517 printf ("test_tail_n_0 FAILED\n");
18521 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18522 if (test_tail_n_1 () == -1) {
18523 printf ("test_tail_n_1 FAILED\n");
18527 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18528 if (test_tail_n_2 () == -1) {
18529 printf ("test_tail_n_2 FAILED\n");
18533 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18534 if (test_tail_0 () == -1) {
18535 printf ("test_tail_0 FAILED\n");
18539 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18540 if (test_head_n_0 () == -1) {
18541 printf ("test_head_n_0 FAILED\n");
18545 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18546 if (test_head_n_1 () == -1) {
18547 printf ("test_head_n_1 FAILED\n");
18551 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18552 if (test_head_n_2 () == -1) {
18553 printf ("test_head_n_2 FAILED\n");
18557 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18558 if (test_head_0 () == -1) {
18559 printf ("test_head_0 FAILED\n");
18563 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18564 if (test_wc_c_0 () == -1) {
18565 printf ("test_wc_c_0 FAILED\n");
18569 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18570 if (test_wc_w_0 () == -1) {
18571 printf ("test_wc_w_0 FAILED\n");
18575 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18576 if (test_wc_l_0 () == -1) {
18577 printf ("test_wc_l_0 FAILED\n");
18581 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18582 if (test_mkdtemp_0 () == -1) {
18583 printf ("test_mkdtemp_0 FAILED\n");
18587 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18588 if (test_scrub_file_0 () == -1) {
18589 printf ("test_scrub_file_0 FAILED\n");
18593 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18594 if (test_scrub_device_0 () == -1) {
18595 printf ("test_scrub_device_0 FAILED\n");
18599 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18600 if (test_glob_expand_0 () == -1) {
18601 printf ("test_glob_expand_0 FAILED\n");
18605 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18606 if (test_glob_expand_1 () == -1) {
18607 printf ("test_glob_expand_1 FAILED\n");
18611 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18612 if (test_glob_expand_2 () == -1) {
18613 printf ("test_glob_expand_2 FAILED\n");
18617 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18618 if (test_ntfs_3g_probe_0 () == -1) {
18619 printf ("test_ntfs_3g_probe_0 FAILED\n");
18623 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18624 if (test_ntfs_3g_probe_1 () == -1) {
18625 printf ("test_ntfs_3g_probe_1 FAILED\n");
18629 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18630 if (test_sleep_0 () == -1) {
18631 printf ("test_sleep_0 FAILED\n");
18635 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18636 if (test_find_0 () == -1) {
18637 printf ("test_find_0 FAILED\n");
18641 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18642 if (test_find_1 () == -1) {
18643 printf ("test_find_1 FAILED\n");
18647 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18648 if (test_find_2 () == -1) {
18649 printf ("test_find_2 FAILED\n");
18653 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18654 if (test_lvresize_0 () == -1) {
18655 printf ("test_lvresize_0 FAILED\n");
18659 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18660 if (test_zerofree_0 () == -1) {
18661 printf ("test_zerofree_0 FAILED\n");
18665 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18666 if (test_hexdump_0 () == -1) {
18667 printf ("test_hexdump_0 FAILED\n");
18671 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18672 if (test_hexdump_1 () == -1) {
18673 printf ("test_hexdump_1 FAILED\n");
18677 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18678 if (test_strings_e_0 () == -1) {
18679 printf ("test_strings_e_0 FAILED\n");
18683 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18684 if (test_strings_e_1 () == -1) {
18685 printf ("test_strings_e_1 FAILED\n");
18689 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18690 if (test_strings_0 () == -1) {
18691 printf ("test_strings_0 FAILED\n");
18695 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18696 if (test_strings_1 () == -1) {
18697 printf ("test_strings_1 FAILED\n");
18701 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18702 if (test_equal_0 () == -1) {
18703 printf ("test_equal_0 FAILED\n");
18707 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18708 if (test_equal_1 () == -1) {
18709 printf ("test_equal_1 FAILED\n");
18713 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18714 if (test_equal_2 () == -1) {
18715 printf ("test_equal_2 FAILED\n");
18719 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18720 if (test_ping_daemon_0 () == -1) {
18721 printf ("test_ping_daemon_0 FAILED\n");
18725 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18726 if (test_dmesg_0 () == -1) {
18727 printf ("test_dmesg_0 FAILED\n");
18731 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18732 if (test_drop_caches_0 () == -1) {
18733 printf ("test_drop_caches_0 FAILED\n");
18737 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
18738 if (test_mv_0 () == -1) {
18739 printf ("test_mv_0 FAILED\n");
18743 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
18744 if (test_mv_1 () == -1) {
18745 printf ("test_mv_1 FAILED\n");
18749 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
18750 if (test_cp_a_0 () == -1) {
18751 printf ("test_cp_a_0 FAILED\n");
18755 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
18756 if (test_cp_0 () == -1) {
18757 printf ("test_cp_0 FAILED\n");
18761 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
18762 if (test_cp_1 () == -1) {
18763 printf ("test_cp_1 FAILED\n");
18767 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
18768 if (test_cp_2 () == -1) {
18769 printf ("test_cp_2 FAILED\n");
18773 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
18774 if (test_grub_install_0 () == -1) {
18775 printf ("test_grub_install_0 FAILED\n");
18779 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
18780 if (test_zero_0 () == -1) {
18781 printf ("test_zero_0 FAILED\n");
18785 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
18786 if (test_fsck_0 () == -1) {
18787 printf ("test_fsck_0 FAILED\n");
18791 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
18792 if (test_fsck_1 () == -1) {
18793 printf ("test_fsck_1 FAILED\n");
18797 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
18798 if (test_set_e2uuid_0 () == -1) {
18799 printf ("test_set_e2uuid_0 FAILED\n");
18803 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
18804 if (test_set_e2uuid_1 () == -1) {
18805 printf ("test_set_e2uuid_1 FAILED\n");
18809 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
18810 if (test_set_e2uuid_2 () == -1) {
18811 printf ("test_set_e2uuid_2 FAILED\n");
18815 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
18816 if (test_set_e2uuid_3 () == -1) {
18817 printf ("test_set_e2uuid_3 FAILED\n");
18821 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
18822 if (test_set_e2label_0 () == -1) {
18823 printf ("test_set_e2label_0 FAILED\n");
18827 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
18828 if (test_pvremove_0 () == -1) {
18829 printf ("test_pvremove_0 FAILED\n");
18833 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
18834 if (test_pvremove_1 () == -1) {
18835 printf ("test_pvremove_1 FAILED\n");
18839 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
18840 if (test_pvremove_2 () == -1) {
18841 printf ("test_pvremove_2 FAILED\n");
18845 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
18846 if (test_vgremove_0 () == -1) {
18847 printf ("test_vgremove_0 FAILED\n");
18851 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
18852 if (test_vgremove_1 () == -1) {
18853 printf ("test_vgremove_1 FAILED\n");
18857 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
18858 if (test_lvremove_0 () == -1) {
18859 printf ("test_lvremove_0 FAILED\n");
18863 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
18864 if (test_lvremove_1 () == -1) {
18865 printf ("test_lvremove_1 FAILED\n");
18869 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
18870 if (test_lvremove_2 () == -1) {
18871 printf ("test_lvremove_2 FAILED\n");
18875 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
18876 if (test_mount_ro_0 () == -1) {
18877 printf ("test_mount_ro_0 FAILED\n");
18881 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
18882 if (test_mount_ro_1 () == -1) {
18883 printf ("test_mount_ro_1 FAILED\n");
18887 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
18888 if (test_tgz_in_0 () == -1) {
18889 printf ("test_tgz_in_0 FAILED\n");
18893 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
18894 if (test_tar_in_0 () == -1) {
18895 printf ("test_tar_in_0 FAILED\n");
18899 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
18900 if (test_checksum_0 () == -1) {
18901 printf ("test_checksum_0 FAILED\n");
18905 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
18906 if (test_checksum_1 () == -1) {
18907 printf ("test_checksum_1 FAILED\n");
18911 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
18912 if (test_checksum_2 () == -1) {
18913 printf ("test_checksum_2 FAILED\n");
18917 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
18918 if (test_checksum_3 () == -1) {
18919 printf ("test_checksum_3 FAILED\n");
18923 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
18924 if (test_checksum_4 () == -1) {
18925 printf ("test_checksum_4 FAILED\n");
18929 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
18930 if (test_checksum_5 () == -1) {
18931 printf ("test_checksum_5 FAILED\n");
18935 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
18936 if (test_checksum_6 () == -1) {
18937 printf ("test_checksum_6 FAILED\n");
18941 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
18942 if (test_checksum_7 () == -1) {
18943 printf ("test_checksum_7 FAILED\n");
18947 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
18948 if (test_checksum_8 () == -1) {
18949 printf ("test_checksum_8 FAILED\n");
18953 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
18954 if (test_download_0 () == -1) {
18955 printf ("test_download_0 FAILED\n");
18959 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
18960 if (test_upload_0 () == -1) {
18961 printf ("test_upload_0 FAILED\n");
18965 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
18966 if (test_blockdev_rereadpt_0 () == -1) {
18967 printf ("test_blockdev_rereadpt_0 FAILED\n");
18971 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
18972 if (test_blockdev_flushbufs_0 () == -1) {
18973 printf ("test_blockdev_flushbufs_0 FAILED\n");
18977 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
18978 if (test_blockdev_getsize64_0 () == -1) {
18979 printf ("test_blockdev_getsize64_0 FAILED\n");
18983 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
18984 if (test_blockdev_getsz_0 () == -1) {
18985 printf ("test_blockdev_getsz_0 FAILED\n");
18989 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
18990 if (test_blockdev_getbsz_0 () == -1) {
18991 printf ("test_blockdev_getbsz_0 FAILED\n");
18995 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
18996 if (test_blockdev_getss_0 () == -1) {
18997 printf ("test_blockdev_getss_0 FAILED\n");
19001 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19002 if (test_blockdev_getro_0 () == -1) {
19003 printf ("test_blockdev_getro_0 FAILED\n");
19007 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19008 if (test_blockdev_setrw_0 () == -1) {
19009 printf ("test_blockdev_setrw_0 FAILED\n");
19013 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19014 if (test_blockdev_setro_0 () == -1) {
19015 printf ("test_blockdev_setro_0 FAILED\n");
19019 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19020 if (test_statvfs_0 () == -1) {
19021 printf ("test_statvfs_0 FAILED\n");
19025 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19026 if (test_lstat_0 () == -1) {
19027 printf ("test_lstat_0 FAILED\n");
19031 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19032 if (test_stat_0 () == -1) {
19033 printf ("test_stat_0 FAILED\n");
19037 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19038 if (test_command_lines_0 () == -1) {
19039 printf ("test_command_lines_0 FAILED\n");
19043 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19044 if (test_command_lines_1 () == -1) {
19045 printf ("test_command_lines_1 FAILED\n");
19049 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19050 if (test_command_lines_2 () == -1) {
19051 printf ("test_command_lines_2 FAILED\n");
19055 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19056 if (test_command_lines_3 () == -1) {
19057 printf ("test_command_lines_3 FAILED\n");
19061 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19062 if (test_command_lines_4 () == -1) {
19063 printf ("test_command_lines_4 FAILED\n");
19067 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19068 if (test_command_lines_5 () == -1) {
19069 printf ("test_command_lines_5 FAILED\n");
19073 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19074 if (test_command_lines_6 () == -1) {
19075 printf ("test_command_lines_6 FAILED\n");
19079 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19080 if (test_command_lines_7 () == -1) {
19081 printf ("test_command_lines_7 FAILED\n");
19085 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19086 if (test_command_lines_8 () == -1) {
19087 printf ("test_command_lines_8 FAILED\n");
19091 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19092 if (test_command_lines_9 () == -1) {
19093 printf ("test_command_lines_9 FAILED\n");
19097 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19098 if (test_command_lines_10 () == -1) {
19099 printf ("test_command_lines_10 FAILED\n");
19103 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19104 if (test_command_0 () == -1) {
19105 printf ("test_command_0 FAILED\n");
19109 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19110 if (test_command_1 () == -1) {
19111 printf ("test_command_1 FAILED\n");
19115 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19116 if (test_command_2 () == -1) {
19117 printf ("test_command_2 FAILED\n");
19121 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19122 if (test_command_3 () == -1) {
19123 printf ("test_command_3 FAILED\n");
19127 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19128 if (test_command_4 () == -1) {
19129 printf ("test_command_4 FAILED\n");
19133 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19134 if (test_command_5 () == -1) {
19135 printf ("test_command_5 FAILED\n");
19139 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19140 if (test_command_6 () == -1) {
19141 printf ("test_command_6 FAILED\n");
19145 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19146 if (test_command_7 () == -1) {
19147 printf ("test_command_7 FAILED\n");
19151 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19152 if (test_command_8 () == -1) {
19153 printf ("test_command_8 FAILED\n");
19157 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19158 if (test_command_9 () == -1) {
19159 printf ("test_command_9 FAILED\n");
19163 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19164 if (test_command_10 () == -1) {
19165 printf ("test_command_10 FAILED\n");
19169 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19170 if (test_command_11 () == -1) {
19171 printf ("test_command_11 FAILED\n");
19175 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19176 if (test_file_0 () == -1) {
19177 printf ("test_file_0 FAILED\n");
19181 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19182 if (test_file_1 () == -1) {
19183 printf ("test_file_1 FAILED\n");
19187 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19188 if (test_file_2 () == -1) {
19189 printf ("test_file_2 FAILED\n");
19193 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19194 if (test_umount_all_0 () == -1) {
19195 printf ("test_umount_all_0 FAILED\n");
19199 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19200 if (test_umount_all_1 () == -1) {
19201 printf ("test_umount_all_1 FAILED\n");
19205 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19206 if (test_mounts_0 () == -1) {
19207 printf ("test_mounts_0 FAILED\n");
19211 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19212 if (test_umount_0 () == -1) {
19213 printf ("test_umount_0 FAILED\n");
19217 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19218 if (test_umount_1 () == -1) {
19219 printf ("test_umount_1 FAILED\n");
19223 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19224 if (test_write_file_0 () == -1) {
19225 printf ("test_write_file_0 FAILED\n");
19229 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19230 if (test_write_file_1 () == -1) {
19231 printf ("test_write_file_1 FAILED\n");
19235 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19236 if (test_write_file_2 () == -1) {
19237 printf ("test_write_file_2 FAILED\n");
19241 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19242 if (test_write_file_3 () == -1) {
19243 printf ("test_write_file_3 FAILED\n");
19247 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19248 if (test_write_file_4 () == -1) {
19249 printf ("test_write_file_4 FAILED\n");
19253 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19254 if (test_write_file_5 () == -1) {
19255 printf ("test_write_file_5 FAILED\n");
19259 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19260 if (test_mkfs_0 () == -1) {
19261 printf ("test_mkfs_0 FAILED\n");
19265 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19266 if (test_lvcreate_0 () == -1) {
19267 printf ("test_lvcreate_0 FAILED\n");
19271 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19272 if (test_vgcreate_0 () == -1) {
19273 printf ("test_vgcreate_0 FAILED\n");
19277 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19278 if (test_pvcreate_0 () == -1) {
19279 printf ("test_pvcreate_0 FAILED\n");
19283 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19284 if (test_is_dir_0 () == -1) {
19285 printf ("test_is_dir_0 FAILED\n");
19289 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19290 if (test_is_dir_1 () == -1) {
19291 printf ("test_is_dir_1 FAILED\n");
19295 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19296 if (test_is_file_0 () == -1) {
19297 printf ("test_is_file_0 FAILED\n");
19301 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19302 if (test_is_file_1 () == -1) {
19303 printf ("test_is_file_1 FAILED\n");
19307 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19308 if (test_exists_0 () == -1) {
19309 printf ("test_exists_0 FAILED\n");
19313 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19314 if (test_exists_1 () == -1) {
19315 printf ("test_exists_1 FAILED\n");
19319 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19320 if (test_mkdir_p_0 () == -1) {
19321 printf ("test_mkdir_p_0 FAILED\n");
19325 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19326 if (test_mkdir_p_1 () == -1) {
19327 printf ("test_mkdir_p_1 FAILED\n");
19331 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19332 if (test_mkdir_p_2 () == -1) {
19333 printf ("test_mkdir_p_2 FAILED\n");
19337 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19338 if (test_mkdir_p_3 () == -1) {
19339 printf ("test_mkdir_p_3 FAILED\n");
19343 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19344 if (test_mkdir_p_4 () == -1) {
19345 printf ("test_mkdir_p_4 FAILED\n");
19349 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19350 if (test_mkdir_0 () == -1) {
19351 printf ("test_mkdir_0 FAILED\n");
19355 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19356 if (test_mkdir_1 () == -1) {
19357 printf ("test_mkdir_1 FAILED\n");
19361 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19362 if (test_rm_rf_0 () == -1) {
19363 printf ("test_rm_rf_0 FAILED\n");
19367 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19368 if (test_rmdir_0 () == -1) {
19369 printf ("test_rmdir_0 FAILED\n");
19373 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19374 if (test_rmdir_1 () == -1) {
19375 printf ("test_rmdir_1 FAILED\n");
19379 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19380 if (test_rmdir_2 () == -1) {
19381 printf ("test_rmdir_2 FAILED\n");
19385 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19386 if (test_rm_0 () == -1) {
19387 printf ("test_rm_0 FAILED\n");
19391 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19392 if (test_rm_1 () == -1) {
19393 printf ("test_rm_1 FAILED\n");
19397 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19398 if (test_rm_2 () == -1) {
19399 printf ("test_rm_2 FAILED\n");
19403 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19404 if (test_read_lines_0 () == -1) {
19405 printf ("test_read_lines_0 FAILED\n");
19409 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19410 if (test_read_lines_1 () == -1) {
19411 printf ("test_read_lines_1 FAILED\n");
19415 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19416 if (test_lvs_0 () == -1) {
19417 printf ("test_lvs_0 FAILED\n");
19421 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19422 if (test_lvs_1 () == -1) {
19423 printf ("test_lvs_1 FAILED\n");
19427 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19428 if (test_vgs_0 () == -1) {
19429 printf ("test_vgs_0 FAILED\n");
19433 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19434 if (test_vgs_1 () == -1) {
19435 printf ("test_vgs_1 FAILED\n");
19439 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19440 if (test_pvs_0 () == -1) {
19441 printf ("test_pvs_0 FAILED\n");
19445 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19446 if (test_pvs_1 () == -1) {
19447 printf ("test_pvs_1 FAILED\n");
19451 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19452 if (test_list_partitions_0 () == -1) {
19453 printf ("test_list_partitions_0 FAILED\n");
19457 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19458 if (test_list_partitions_1 () == -1) {
19459 printf ("test_list_partitions_1 FAILED\n");
19463 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19464 if (test_list_devices_0 () == -1) {
19465 printf ("test_list_devices_0 FAILED\n");
19469 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19470 if (test_ls_0 () == -1) {
19471 printf ("test_ls_0 FAILED\n");
19475 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19476 if (test_cat_0 () == -1) {
19477 printf ("test_cat_0 FAILED\n");
19481 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19482 if (test_touch_0 () == -1) {
19483 printf ("test_touch_0 FAILED\n");
19487 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19488 if (test_sync_0 () == -1) {
19489 printf ("test_sync_0 FAILED\n");
19493 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19494 if (test_mount_0 () == -1) {
19495 printf ("test_mount_0 FAILED\n");
19500 unlink ("test1.img");
19501 unlink ("test2.img");
19502 unlink ("test3.img");
19505 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);