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_du_0_skip (void)
162 str = getenv ("TEST_ONLY");
164 return strstr (str, "du") == NULL;
165 str = getenv ("SKIP_TEST_DU_0");
166 if (str && strcmp (str, "1") == 0) return 1;
167 str = getenv ("SKIP_TEST_DU");
168 if (str && strcmp (str, "1") == 0) return 1;
172 static int test_du_0 (void)
174 if (test_du_0_skip ()) {
175 printf ("%s skipped (reason: environment variable set)\n", "test_du_0");
179 /* InitBasicFS for test_du_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 /* TestOutputInt for du (0) */
238 r = guestfs_mkdir (g, path);
246 r = guestfs_du (g, path);
250 fprintf (stderr, "test_du_0: expected 1 but got %d\n", (int) r);
257 static int test_tail_n_0_skip (void)
261 str = getenv ("TEST_ONLY");
263 return strstr (str, "tail_n") == NULL;
264 str = getenv ("SKIP_TEST_TAIL_N_0");
265 if (str && strcmp (str, "1") == 0) return 1;
266 str = getenv ("SKIP_TEST_TAIL_N");
267 if (str && strcmp (str, "1") == 0) return 1;
271 static int test_tail_n_0 (void)
273 if (test_tail_n_0_skip ()) {
274 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_0");
278 /* InitBasicFS for test_tail_n_0: create ext2 on /dev/sda1 */
280 char device[] = "/dev/sda";
283 r = guestfs_blockdev_setrw (g, device);
290 r = guestfs_umount_all (g);
297 r = guestfs_lvm_remove_all (g);
302 char device[] = "/dev/sda";
303 char lines_0[] = ",";
310 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
315 char fstype[] = "ext2";
316 char device[] = "/dev/sda1";
319 r = guestfs_mkfs (g, fstype, device);
324 char device[] = "/dev/sda1";
325 char mountpoint[] = "/";
328 r = guestfs_mount (g, device, mountpoint);
332 /* TestOutputList for tail_n (0) */
334 char options[] = "ro";
335 char vfstype[] = "squashfs";
336 char device[] = "/dev/sdd";
337 char mountpoint[] = "/";
340 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
345 char path[] = "/10klines";
349 r = guestfs_tail_n (g, 3, path);
353 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
358 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
359 if (strcmp (r[0], expected) != 0) {
360 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
365 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
370 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
371 if (strcmp (r[1], expected) != 0) {
372 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
377 fprintf (stderr, "test_tail_n_0: short list returned from command\n");
382 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
383 if (strcmp (r[2], expected) != 0) {
384 fprintf (stderr, "test_tail_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
389 fprintf (stderr, "test_tail_n_0: extra elements returned from command\n");
393 for (i = 0; r[i] != NULL; ++i)
400 static int test_tail_n_1_skip (void)
404 str = getenv ("TEST_ONLY");
406 return strstr (str, "tail_n") == NULL;
407 str = getenv ("SKIP_TEST_TAIL_N_1");
408 if (str && strcmp (str, "1") == 0) return 1;
409 str = getenv ("SKIP_TEST_TAIL_N");
410 if (str && strcmp (str, "1") == 0) return 1;
414 static int test_tail_n_1 (void)
416 if (test_tail_n_1_skip ()) {
417 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_1");
421 /* InitBasicFS for test_tail_n_1: create ext2 on /dev/sda1 */
423 char device[] = "/dev/sda";
426 r = guestfs_blockdev_setrw (g, device);
433 r = guestfs_umount_all (g);
440 r = guestfs_lvm_remove_all (g);
445 char device[] = "/dev/sda";
446 char lines_0[] = ",";
453 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
458 char fstype[] = "ext2";
459 char device[] = "/dev/sda1";
462 r = guestfs_mkfs (g, fstype, device);
467 char device[] = "/dev/sda1";
468 char mountpoint[] = "/";
471 r = guestfs_mount (g, device, mountpoint);
475 /* TestOutputList for tail_n (1) */
477 char options[] = "ro";
478 char vfstype[] = "squashfs";
479 char device[] = "/dev/sdd";
480 char mountpoint[] = "/";
483 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
488 char path[] = "/10klines";
492 r = guestfs_tail_n (g, -9998, path);
496 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
501 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
502 if (strcmp (r[0], expected) != 0) {
503 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
508 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
513 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
514 if (strcmp (r[1], expected) != 0) {
515 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
520 fprintf (stderr, "test_tail_n_1: short list returned from command\n");
525 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
526 if (strcmp (r[2], expected) != 0) {
527 fprintf (stderr, "test_tail_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
532 fprintf (stderr, "test_tail_n_1: extra elements returned from command\n");
536 for (i = 0; r[i] != NULL; ++i)
543 static int test_tail_n_2_skip (void)
547 str = getenv ("TEST_ONLY");
549 return strstr (str, "tail_n") == NULL;
550 str = getenv ("SKIP_TEST_TAIL_N_2");
551 if (str && strcmp (str, "1") == 0) return 1;
552 str = getenv ("SKIP_TEST_TAIL_N");
553 if (str && strcmp (str, "1") == 0) return 1;
557 static int test_tail_n_2 (void)
559 if (test_tail_n_2_skip ()) {
560 printf ("%s skipped (reason: environment variable set)\n", "test_tail_n_2");
564 /* InitBasicFS for test_tail_n_2: create ext2 on /dev/sda1 */
566 char device[] = "/dev/sda";
569 r = guestfs_blockdev_setrw (g, device);
576 r = guestfs_umount_all (g);
583 r = guestfs_lvm_remove_all (g);
588 char device[] = "/dev/sda";
589 char lines_0[] = ",";
596 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
601 char fstype[] = "ext2";
602 char device[] = "/dev/sda1";
605 r = guestfs_mkfs (g, fstype, device);
610 char device[] = "/dev/sda1";
611 char mountpoint[] = "/";
614 r = guestfs_mount (g, device, mountpoint);
618 /* TestOutputList for tail_n (2) */
620 char options[] = "ro";
621 char vfstype[] = "squashfs";
622 char device[] = "/dev/sdd";
623 char mountpoint[] = "/";
626 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
631 char path[] = "/10klines";
635 r = guestfs_tail_n (g, 0, path);
639 fprintf (stderr, "test_tail_n_2: extra elements returned from command\n");
643 for (i = 0; r[i] != NULL; ++i)
650 static int test_tail_0_skip (void)
654 str = getenv ("TEST_ONLY");
656 return strstr (str, "tail") == NULL;
657 str = getenv ("SKIP_TEST_TAIL_0");
658 if (str && strcmp (str, "1") == 0) return 1;
659 str = getenv ("SKIP_TEST_TAIL");
660 if (str && strcmp (str, "1") == 0) return 1;
664 static int test_tail_0 (void)
666 if (test_tail_0_skip ()) {
667 printf ("%s skipped (reason: environment variable set)\n", "test_tail_0");
671 /* InitBasicFS for test_tail_0: create ext2 on /dev/sda1 */
673 char device[] = "/dev/sda";
676 r = guestfs_blockdev_setrw (g, device);
683 r = guestfs_umount_all (g);
690 r = guestfs_lvm_remove_all (g);
695 char device[] = "/dev/sda";
696 char lines_0[] = ",";
703 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
708 char fstype[] = "ext2";
709 char device[] = "/dev/sda1";
712 r = guestfs_mkfs (g, fstype, device);
717 char device[] = "/dev/sda1";
718 char mountpoint[] = "/";
721 r = guestfs_mount (g, device, mountpoint);
725 /* TestOutputList for tail (0) */
727 char options[] = "ro";
728 char vfstype[] = "squashfs";
729 char device[] = "/dev/sdd";
730 char mountpoint[] = "/";
733 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
738 char path[] = "/10klines";
742 r = guestfs_tail (g, path);
746 fprintf (stderr, "test_tail_0: short list returned from command\n");
751 char expected[] = "9990abcdefghijklmnopqrstuvwxyz";
752 if (strcmp (r[0], expected) != 0) {
753 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
758 fprintf (stderr, "test_tail_0: short list returned from command\n");
763 char expected[] = "9991abcdefghijklmnopqrstuvwxyz";
764 if (strcmp (r[1], expected) != 0) {
765 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
770 fprintf (stderr, "test_tail_0: short list returned from command\n");
775 char expected[] = "9992abcdefghijklmnopqrstuvwxyz";
776 if (strcmp (r[2], expected) != 0) {
777 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
782 fprintf (stderr, "test_tail_0: short list returned from command\n");
787 char expected[] = "9993abcdefghijklmnopqrstuvwxyz";
788 if (strcmp (r[3], expected) != 0) {
789 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
794 fprintf (stderr, "test_tail_0: short list returned from command\n");
799 char expected[] = "9994abcdefghijklmnopqrstuvwxyz";
800 if (strcmp (r[4], expected) != 0) {
801 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
806 fprintf (stderr, "test_tail_0: short list returned from command\n");
811 char expected[] = "9995abcdefghijklmnopqrstuvwxyz";
812 if (strcmp (r[5], expected) != 0) {
813 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
818 fprintf (stderr, "test_tail_0: short list returned from command\n");
823 char expected[] = "9996abcdefghijklmnopqrstuvwxyz";
824 if (strcmp (r[6], expected) != 0) {
825 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
830 fprintf (stderr, "test_tail_0: short list returned from command\n");
835 char expected[] = "9997abcdefghijklmnopqrstuvwxyz";
836 if (strcmp (r[7], expected) != 0) {
837 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
842 fprintf (stderr, "test_tail_0: short list returned from command\n");
847 char expected[] = "9998abcdefghijklmnopqrstuvwxyz";
848 if (strcmp (r[8], expected) != 0) {
849 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
854 fprintf (stderr, "test_tail_0: short list returned from command\n");
859 char expected[] = "9999abcdefghijklmnopqrstuvwxyz";
860 if (strcmp (r[9], expected) != 0) {
861 fprintf (stderr, "test_tail_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
866 fprintf (stderr, "test_tail_0: extra elements returned from command\n");
870 for (i = 0; r[i] != NULL; ++i)
877 static int test_head_n_0_skip (void)
881 str = getenv ("TEST_ONLY");
883 return strstr (str, "head_n") == NULL;
884 str = getenv ("SKIP_TEST_HEAD_N_0");
885 if (str && strcmp (str, "1") == 0) return 1;
886 str = getenv ("SKIP_TEST_HEAD_N");
887 if (str && strcmp (str, "1") == 0) return 1;
891 static int test_head_n_0 (void)
893 if (test_head_n_0_skip ()) {
894 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_0");
898 /* InitBasicFS for test_head_n_0: create ext2 on /dev/sda1 */
900 char device[] = "/dev/sda";
903 r = guestfs_blockdev_setrw (g, device);
910 r = guestfs_umount_all (g);
917 r = guestfs_lvm_remove_all (g);
922 char device[] = "/dev/sda";
923 char lines_0[] = ",";
930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
935 char fstype[] = "ext2";
936 char device[] = "/dev/sda1";
939 r = guestfs_mkfs (g, fstype, device);
944 char device[] = "/dev/sda1";
945 char mountpoint[] = "/";
948 r = guestfs_mount (g, device, mountpoint);
952 /* TestOutputList for head_n (0) */
954 char options[] = "ro";
955 char vfstype[] = "squashfs";
956 char device[] = "/dev/sdd";
957 char mountpoint[] = "/";
960 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
965 char path[] = "/10klines";
969 r = guestfs_head_n (g, 3, path);
973 fprintf (stderr, "test_head_n_0: short list returned from command\n");
978 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
979 if (strcmp (r[0], expected) != 0) {
980 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
985 fprintf (stderr, "test_head_n_0: short list returned from command\n");
990 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
991 if (strcmp (r[1], expected) != 0) {
992 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
997 fprintf (stderr, "test_head_n_0: short list returned from command\n");
1002 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1003 if (strcmp (r[2], expected) != 0) {
1004 fprintf (stderr, "test_head_n_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1009 fprintf (stderr, "test_head_n_0: extra elements returned from command\n");
1013 for (i = 0; r[i] != NULL; ++i)
1020 static int test_head_n_1_skip (void)
1024 str = getenv ("TEST_ONLY");
1026 return strstr (str, "head_n") == NULL;
1027 str = getenv ("SKIP_TEST_HEAD_N_1");
1028 if (str && strcmp (str, "1") == 0) return 1;
1029 str = getenv ("SKIP_TEST_HEAD_N");
1030 if (str && strcmp (str, "1") == 0) return 1;
1034 static int test_head_n_1 (void)
1036 if (test_head_n_1_skip ()) {
1037 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_1");
1041 /* InitBasicFS for test_head_n_1: create ext2 on /dev/sda1 */
1043 char device[] = "/dev/sda";
1046 r = guestfs_blockdev_setrw (g, device);
1053 r = guestfs_umount_all (g);
1060 r = guestfs_lvm_remove_all (g);
1065 char device[] = "/dev/sda";
1066 char lines_0[] = ",";
1073 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1078 char fstype[] = "ext2";
1079 char device[] = "/dev/sda1";
1082 r = guestfs_mkfs (g, fstype, device);
1087 char device[] = "/dev/sda1";
1088 char mountpoint[] = "/";
1091 r = guestfs_mount (g, device, mountpoint);
1095 /* TestOutputList for head_n (1) */
1097 char options[] = "ro";
1098 char vfstype[] = "squashfs";
1099 char device[] = "/dev/sdd";
1100 char mountpoint[] = "/";
1103 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1108 char path[] = "/10klines";
1112 r = guestfs_head_n (g, -9997, path);
1116 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1121 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1122 if (strcmp (r[0], expected) != 0) {
1123 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1128 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1133 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1134 if (strcmp (r[1], expected) != 0) {
1135 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1140 fprintf (stderr, "test_head_n_1: short list returned from command\n");
1145 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1146 if (strcmp (r[2], expected) != 0) {
1147 fprintf (stderr, "test_head_n_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1152 fprintf (stderr, "test_head_n_1: extra elements returned from command\n");
1156 for (i = 0; r[i] != NULL; ++i)
1163 static int test_head_n_2_skip (void)
1167 str = getenv ("TEST_ONLY");
1169 return strstr (str, "head_n") == NULL;
1170 str = getenv ("SKIP_TEST_HEAD_N_2");
1171 if (str && strcmp (str, "1") == 0) return 1;
1172 str = getenv ("SKIP_TEST_HEAD_N");
1173 if (str && strcmp (str, "1") == 0) return 1;
1177 static int test_head_n_2 (void)
1179 if (test_head_n_2_skip ()) {
1180 printf ("%s skipped (reason: environment variable set)\n", "test_head_n_2");
1184 /* InitBasicFS for test_head_n_2: create ext2 on /dev/sda1 */
1186 char device[] = "/dev/sda";
1189 r = guestfs_blockdev_setrw (g, device);
1196 r = guestfs_umount_all (g);
1203 r = guestfs_lvm_remove_all (g);
1208 char device[] = "/dev/sda";
1209 char lines_0[] = ",";
1216 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1221 char fstype[] = "ext2";
1222 char device[] = "/dev/sda1";
1225 r = guestfs_mkfs (g, fstype, device);
1230 char device[] = "/dev/sda1";
1231 char mountpoint[] = "/";
1234 r = guestfs_mount (g, device, mountpoint);
1238 /* TestOutputList for head_n (2) */
1240 char options[] = "ro";
1241 char vfstype[] = "squashfs";
1242 char device[] = "/dev/sdd";
1243 char mountpoint[] = "/";
1246 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1251 char path[] = "/10klines";
1255 r = guestfs_head_n (g, 0, path);
1259 fprintf (stderr, "test_head_n_2: extra elements returned from command\n");
1263 for (i = 0; r[i] != NULL; ++i)
1270 static int test_head_0_skip (void)
1274 str = getenv ("TEST_ONLY");
1276 return strstr (str, "head") == NULL;
1277 str = getenv ("SKIP_TEST_HEAD_0");
1278 if (str && strcmp (str, "1") == 0) return 1;
1279 str = getenv ("SKIP_TEST_HEAD");
1280 if (str && strcmp (str, "1") == 0) return 1;
1284 static int test_head_0 (void)
1286 if (test_head_0_skip ()) {
1287 printf ("%s skipped (reason: environment variable set)\n", "test_head_0");
1291 /* InitBasicFS for test_head_0: create ext2 on /dev/sda1 */
1293 char device[] = "/dev/sda";
1296 r = guestfs_blockdev_setrw (g, device);
1303 r = guestfs_umount_all (g);
1310 r = guestfs_lvm_remove_all (g);
1315 char device[] = "/dev/sda";
1316 char lines_0[] = ",";
1323 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1328 char fstype[] = "ext2";
1329 char device[] = "/dev/sda1";
1332 r = guestfs_mkfs (g, fstype, device);
1337 char device[] = "/dev/sda1";
1338 char mountpoint[] = "/";
1341 r = guestfs_mount (g, device, mountpoint);
1345 /* TestOutputList for head (0) */
1347 char options[] = "ro";
1348 char vfstype[] = "squashfs";
1349 char device[] = "/dev/sdd";
1350 char mountpoint[] = "/";
1353 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1358 char path[] = "/10klines";
1362 r = guestfs_head (g, path);
1366 fprintf (stderr, "test_head_0: short list returned from command\n");
1371 char expected[] = "0abcdefghijklmnopqrstuvwxyz";
1372 if (strcmp (r[0], expected) != 0) {
1373 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1378 fprintf (stderr, "test_head_0: short list returned from command\n");
1383 char expected[] = "1abcdefghijklmnopqrstuvwxyz";
1384 if (strcmp (r[1], expected) != 0) {
1385 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1390 fprintf (stderr, "test_head_0: short list returned from command\n");
1395 char expected[] = "2abcdefghijklmnopqrstuvwxyz";
1396 if (strcmp (r[2], expected) != 0) {
1397 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1402 fprintf (stderr, "test_head_0: short list returned from command\n");
1407 char expected[] = "3abcdefghijklmnopqrstuvwxyz";
1408 if (strcmp (r[3], expected) != 0) {
1409 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1414 fprintf (stderr, "test_head_0: short list returned from command\n");
1419 char expected[] = "4abcdefghijklmnopqrstuvwxyz";
1420 if (strcmp (r[4], expected) != 0) {
1421 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
1426 fprintf (stderr, "test_head_0: short list returned from command\n");
1431 char expected[] = "5abcdefghijklmnopqrstuvwxyz";
1432 if (strcmp (r[5], expected) != 0) {
1433 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[5]);
1438 fprintf (stderr, "test_head_0: short list returned from command\n");
1443 char expected[] = "6abcdefghijklmnopqrstuvwxyz";
1444 if (strcmp (r[6], expected) != 0) {
1445 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[6]);
1450 fprintf (stderr, "test_head_0: short list returned from command\n");
1455 char expected[] = "7abcdefghijklmnopqrstuvwxyz";
1456 if (strcmp (r[7], expected) != 0) {
1457 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[7]);
1462 fprintf (stderr, "test_head_0: short list returned from command\n");
1467 char expected[] = "8abcdefghijklmnopqrstuvwxyz";
1468 if (strcmp (r[8], expected) != 0) {
1469 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[8]);
1474 fprintf (stderr, "test_head_0: short list returned from command\n");
1479 char expected[] = "9abcdefghijklmnopqrstuvwxyz";
1480 if (strcmp (r[9], expected) != 0) {
1481 fprintf (stderr, "test_head_0: expected \"%s\" but got \"%s\"\n", expected, r[9]);
1485 if (r[10] != NULL) {
1486 fprintf (stderr, "test_head_0: extra elements returned from command\n");
1490 for (i = 0; r[i] != NULL; ++i)
1497 static int test_wc_c_0_skip (void)
1501 str = getenv ("TEST_ONLY");
1503 return strstr (str, "wc_c") == NULL;
1504 str = getenv ("SKIP_TEST_WC_C_0");
1505 if (str && strcmp (str, "1") == 0) return 1;
1506 str = getenv ("SKIP_TEST_WC_C");
1507 if (str && strcmp (str, "1") == 0) return 1;
1511 static int test_wc_c_0 (void)
1513 if (test_wc_c_0_skip ()) {
1514 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
1518 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
1520 char device[] = "/dev/sda";
1523 r = guestfs_blockdev_setrw (g, device);
1530 r = guestfs_umount_all (g);
1537 r = guestfs_lvm_remove_all (g);
1542 char device[] = "/dev/sda";
1543 char lines_0[] = ",";
1550 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1555 char fstype[] = "ext2";
1556 char device[] = "/dev/sda1";
1559 r = guestfs_mkfs (g, fstype, device);
1564 char device[] = "/dev/sda1";
1565 char mountpoint[] = "/";
1568 r = guestfs_mount (g, device, mountpoint);
1572 /* TestOutputInt for wc_c (0) */
1574 char options[] = "ro";
1575 char vfstype[] = "squashfs";
1576 char device[] = "/dev/sdd";
1577 char mountpoint[] = "/";
1580 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1585 char path[] = "/100kallspaces";
1588 r = guestfs_wc_c (g, path);
1592 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
1599 static int test_wc_w_0_skip (void)
1603 str = getenv ("TEST_ONLY");
1605 return strstr (str, "wc_w") == NULL;
1606 str = getenv ("SKIP_TEST_WC_W_0");
1607 if (str && strcmp (str, "1") == 0) return 1;
1608 str = getenv ("SKIP_TEST_WC_W");
1609 if (str && strcmp (str, "1") == 0) return 1;
1613 static int test_wc_w_0 (void)
1615 if (test_wc_w_0_skip ()) {
1616 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
1620 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
1622 char device[] = "/dev/sda";
1625 r = guestfs_blockdev_setrw (g, device);
1632 r = guestfs_umount_all (g);
1639 r = guestfs_lvm_remove_all (g);
1644 char device[] = "/dev/sda";
1645 char lines_0[] = ",";
1652 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1657 char fstype[] = "ext2";
1658 char device[] = "/dev/sda1";
1661 r = guestfs_mkfs (g, fstype, device);
1666 char device[] = "/dev/sda1";
1667 char mountpoint[] = "/";
1670 r = guestfs_mount (g, device, mountpoint);
1674 /* TestOutputInt for wc_w (0) */
1676 char options[] = "ro";
1677 char vfstype[] = "squashfs";
1678 char device[] = "/dev/sdd";
1679 char mountpoint[] = "/";
1682 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1687 char path[] = "/10klines";
1690 r = guestfs_wc_w (g, path);
1694 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
1701 static int test_wc_l_0_skip (void)
1705 str = getenv ("TEST_ONLY");
1707 return strstr (str, "wc_l") == NULL;
1708 str = getenv ("SKIP_TEST_WC_L_0");
1709 if (str && strcmp (str, "1") == 0) return 1;
1710 str = getenv ("SKIP_TEST_WC_L");
1711 if (str && strcmp (str, "1") == 0) return 1;
1715 static int test_wc_l_0 (void)
1717 if (test_wc_l_0_skip ()) {
1718 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
1722 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
1724 char device[] = "/dev/sda";
1727 r = guestfs_blockdev_setrw (g, device);
1734 r = guestfs_umount_all (g);
1741 r = guestfs_lvm_remove_all (g);
1746 char device[] = "/dev/sda";
1747 char lines_0[] = ",";
1754 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1759 char fstype[] = "ext2";
1760 char device[] = "/dev/sda1";
1763 r = guestfs_mkfs (g, fstype, device);
1768 char device[] = "/dev/sda1";
1769 char mountpoint[] = "/";
1772 r = guestfs_mount (g, device, mountpoint);
1776 /* TestOutputInt for wc_l (0) */
1778 char options[] = "ro";
1779 char vfstype[] = "squashfs";
1780 char device[] = "/dev/sdd";
1781 char mountpoint[] = "/";
1784 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
1789 char path[] = "/10klines";
1792 r = guestfs_wc_l (g, path);
1796 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
1803 static int test_mkdtemp_0_skip (void)
1807 str = getenv ("TEST_ONLY");
1809 return strstr (str, "mkdtemp") == NULL;
1810 str = getenv ("SKIP_TEST_MKDTEMP_0");
1811 if (str && strcmp (str, "1") == 0) return 1;
1812 str = getenv ("SKIP_TEST_MKDTEMP");
1813 if (str && strcmp (str, "1") == 0) return 1;
1817 static int test_mkdtemp_0 (void)
1819 if (test_mkdtemp_0_skip ()) {
1820 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
1824 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
1826 char device[] = "/dev/sda";
1829 r = guestfs_blockdev_setrw (g, device);
1836 r = guestfs_umount_all (g);
1843 r = guestfs_lvm_remove_all (g);
1848 char device[] = "/dev/sda";
1849 char lines_0[] = ",";
1856 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1861 char fstype[] = "ext2";
1862 char device[] = "/dev/sda1";
1865 r = guestfs_mkfs (g, fstype, device);
1870 char device[] = "/dev/sda1";
1871 char mountpoint[] = "/";
1874 r = guestfs_mount (g, device, mountpoint);
1878 /* TestRun for mkdtemp (0) */
1880 char path[] = "/tmp";
1883 r = guestfs_mkdir (g, path);
1888 char template[] = "/tmp/tmpXXXXXX";
1891 r = guestfs_mkdtemp (g, template);
1899 static int test_scrub_file_0_skip (void)
1903 str = getenv ("TEST_ONLY");
1905 return strstr (str, "scrub_file") == NULL;
1906 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
1907 if (str && strcmp (str, "1") == 0) return 1;
1908 str = getenv ("SKIP_TEST_SCRUB_FILE");
1909 if (str && strcmp (str, "1") == 0) return 1;
1913 static int test_scrub_file_0 (void)
1915 if (test_scrub_file_0_skip ()) {
1916 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
1920 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
1922 char device[] = "/dev/sda";
1925 r = guestfs_blockdev_setrw (g, device);
1932 r = guestfs_umount_all (g);
1939 r = guestfs_lvm_remove_all (g);
1944 char device[] = "/dev/sda";
1945 char lines_0[] = ",";
1952 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1957 char fstype[] = "ext2";
1958 char device[] = "/dev/sda1";
1961 r = guestfs_mkfs (g, fstype, device);
1966 char device[] = "/dev/sda1";
1967 char mountpoint[] = "/";
1970 r = guestfs_mount (g, device, mountpoint);
1974 /* TestRun for scrub_file (0) */
1976 char path[] = "/file";
1977 char content[] = "content";
1980 r = guestfs_write_file (g, path, content, 0);
1985 char file[] = "/file";
1988 r = guestfs_scrub_file (g, file);
1995 static int test_scrub_device_0_skip (void)
1999 str = getenv ("TEST_ONLY");
2001 return strstr (str, "scrub_device") == NULL;
2002 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
2003 if (str && strcmp (str, "1") == 0) return 1;
2004 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
2005 if (str && strcmp (str, "1") == 0) return 1;
2009 static int test_scrub_device_0 (void)
2011 if (test_scrub_device_0_skip ()) {
2012 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
2016 /* InitNone|InitEmpty for test_scrub_device_0 */
2018 char device[] = "/dev/sda";
2021 r = guestfs_blockdev_setrw (g, device);
2028 r = guestfs_umount_all (g);
2035 r = guestfs_lvm_remove_all (g);
2039 /* TestRun for scrub_device (0) */
2041 char device[] = "/dev/sdc";
2044 r = guestfs_scrub_device (g, device);
2051 static int test_glob_expand_0_skip (void)
2055 str = getenv ("TEST_ONLY");
2057 return strstr (str, "glob_expand") == NULL;
2058 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
2059 if (str && strcmp (str, "1") == 0) return 1;
2060 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2061 if (str && strcmp (str, "1") == 0) return 1;
2065 static int test_glob_expand_0 (void)
2067 if (test_glob_expand_0_skip ()) {
2068 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
2072 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
2074 char device[] = "/dev/sda";
2077 r = guestfs_blockdev_setrw (g, device);
2084 r = guestfs_umount_all (g);
2091 r = guestfs_lvm_remove_all (g);
2096 char device[] = "/dev/sda";
2097 char lines_0[] = ",";
2104 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2109 char fstype[] = "ext2";
2110 char device[] = "/dev/sda1";
2113 r = guestfs_mkfs (g, fstype, device);
2118 char device[] = "/dev/sda1";
2119 char mountpoint[] = "/";
2122 r = guestfs_mount (g, device, mountpoint);
2126 /* TestOutputList for glob_expand (0) */
2128 char path[] = "/a/b/c";
2131 r = guestfs_mkdir_p (g, path);
2136 char path[] = "/a/b/c/d";
2139 r = guestfs_touch (g, path);
2144 char path[] = "/a/b/c/e";
2147 r = guestfs_touch (g, path);
2152 char pattern[] = "/a/b/c/*";
2156 r = guestfs_glob_expand (g, pattern);
2160 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2165 char expected[] = "/a/b/c/d";
2166 if (strcmp (r[0], expected) != 0) {
2167 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2172 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
2177 char expected[] = "/a/b/c/e";
2178 if (strcmp (r[1], expected) != 0) {
2179 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2184 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
2188 for (i = 0; r[i] != NULL; ++i)
2195 static int test_glob_expand_1_skip (void)
2199 str = getenv ("TEST_ONLY");
2201 return strstr (str, "glob_expand") == NULL;
2202 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
2203 if (str && strcmp (str, "1") == 0) return 1;
2204 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2205 if (str && strcmp (str, "1") == 0) return 1;
2209 static int test_glob_expand_1 (void)
2211 if (test_glob_expand_1_skip ()) {
2212 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
2216 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
2218 char device[] = "/dev/sda";
2221 r = guestfs_blockdev_setrw (g, device);
2228 r = guestfs_umount_all (g);
2235 r = guestfs_lvm_remove_all (g);
2240 char device[] = "/dev/sda";
2241 char lines_0[] = ",";
2248 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2253 char fstype[] = "ext2";
2254 char device[] = "/dev/sda1";
2257 r = guestfs_mkfs (g, fstype, device);
2262 char device[] = "/dev/sda1";
2263 char mountpoint[] = "/";
2266 r = guestfs_mount (g, device, mountpoint);
2270 /* TestOutputList for glob_expand (1) */
2272 char path[] = "/a/b/c";
2275 r = guestfs_mkdir_p (g, path);
2280 char path[] = "/a/b/c/d";
2283 r = guestfs_touch (g, path);
2288 char path[] = "/a/b/c/e";
2291 r = guestfs_touch (g, path);
2296 char pattern[] = "/a/*/c/*";
2300 r = guestfs_glob_expand (g, pattern);
2304 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2309 char expected[] = "/a/b/c/d";
2310 if (strcmp (r[0], expected) != 0) {
2311 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2316 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
2321 char expected[] = "/a/b/c/e";
2322 if (strcmp (r[1], expected) != 0) {
2323 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2328 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
2332 for (i = 0; r[i] != NULL; ++i)
2339 static int test_glob_expand_2_skip (void)
2343 str = getenv ("TEST_ONLY");
2345 return strstr (str, "glob_expand") == NULL;
2346 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
2347 if (str && strcmp (str, "1") == 0) return 1;
2348 str = getenv ("SKIP_TEST_GLOB_EXPAND");
2349 if (str && strcmp (str, "1") == 0) return 1;
2353 static int test_glob_expand_2 (void)
2355 if (test_glob_expand_2_skip ()) {
2356 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
2360 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
2362 char device[] = "/dev/sda";
2365 r = guestfs_blockdev_setrw (g, device);
2372 r = guestfs_umount_all (g);
2379 r = guestfs_lvm_remove_all (g);
2384 char device[] = "/dev/sda";
2385 char lines_0[] = ",";
2392 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2397 char fstype[] = "ext2";
2398 char device[] = "/dev/sda1";
2401 r = guestfs_mkfs (g, fstype, device);
2406 char device[] = "/dev/sda1";
2407 char mountpoint[] = "/";
2410 r = guestfs_mount (g, device, mountpoint);
2414 /* TestOutputList for glob_expand (2) */
2416 char path[] = "/a/b/c";
2419 r = guestfs_mkdir_p (g, path);
2424 char path[] = "/a/b/c/d";
2427 r = guestfs_touch (g, path);
2432 char path[] = "/a/b/c/e";
2435 r = guestfs_touch (g, path);
2440 char pattern[] = "/a/*/x/*";
2444 r = guestfs_glob_expand (g, pattern);
2448 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
2452 for (i = 0; r[i] != NULL; ++i)
2459 static int test_ntfs_3g_probe_0_skip (void)
2463 str = getenv ("TEST_ONLY");
2465 return strstr (str, "ntfs_3g_probe") == NULL;
2466 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
2467 if (str && strcmp (str, "1") == 0) return 1;
2468 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2469 if (str && strcmp (str, "1") == 0) return 1;
2473 static int test_ntfs_3g_probe_0 (void)
2475 if (test_ntfs_3g_probe_0_skip ()) {
2476 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
2480 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
2482 char device[] = "/dev/sda";
2485 r = guestfs_blockdev_setrw (g, device);
2492 r = guestfs_umount_all (g);
2499 r = guestfs_lvm_remove_all (g);
2503 /* TestOutputInt for ntfs_3g_probe (0) */
2505 char device[] = "/dev/sda";
2506 char lines_0[] = ",";
2513 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2518 char fstype[] = "ntfs";
2519 char device[] = "/dev/sda1";
2522 r = guestfs_mkfs (g, fstype, device);
2527 char device[] = "/dev/sda1";
2530 r = guestfs_ntfs_3g_probe (g, 1, device);
2534 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
2541 static int test_ntfs_3g_probe_1_skip (void)
2545 str = getenv ("TEST_ONLY");
2547 return strstr (str, "ntfs_3g_probe") == NULL;
2548 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
2549 if (str && strcmp (str, "1") == 0) return 1;
2550 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
2551 if (str && strcmp (str, "1") == 0) return 1;
2555 static int test_ntfs_3g_probe_1 (void)
2557 if (test_ntfs_3g_probe_1_skip ()) {
2558 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
2562 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
2564 char device[] = "/dev/sda";
2567 r = guestfs_blockdev_setrw (g, device);
2574 r = guestfs_umount_all (g);
2581 r = guestfs_lvm_remove_all (g);
2585 /* TestOutputInt for ntfs_3g_probe (1) */
2587 char device[] = "/dev/sda";
2588 char lines_0[] = ",";
2595 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2600 char fstype[] = "ext2";
2601 char device[] = "/dev/sda1";
2604 r = guestfs_mkfs (g, fstype, device);
2609 char device[] = "/dev/sda1";
2612 r = guestfs_ntfs_3g_probe (g, 1, device);
2616 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
2623 static int test_sleep_0_skip (void)
2627 str = getenv ("TEST_ONLY");
2629 return strstr (str, "sleep") == NULL;
2630 str = getenv ("SKIP_TEST_SLEEP_0");
2631 if (str && strcmp (str, "1") == 0) return 1;
2632 str = getenv ("SKIP_TEST_SLEEP");
2633 if (str && strcmp (str, "1") == 0) return 1;
2637 static int test_sleep_0 (void)
2639 if (test_sleep_0_skip ()) {
2640 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
2644 /* InitNone|InitEmpty for test_sleep_0 */
2646 char device[] = "/dev/sda";
2649 r = guestfs_blockdev_setrw (g, device);
2656 r = guestfs_umount_all (g);
2663 r = guestfs_lvm_remove_all (g);
2667 /* TestRun for sleep (0) */
2671 r = guestfs_sleep (g, 1);
2678 static int test_find_0_skip (void)
2682 str = getenv ("TEST_ONLY");
2684 return strstr (str, "find") == NULL;
2685 str = getenv ("SKIP_TEST_FIND_0");
2686 if (str && strcmp (str, "1") == 0) return 1;
2687 str = getenv ("SKIP_TEST_FIND");
2688 if (str && strcmp (str, "1") == 0) return 1;
2692 static int test_find_0 (void)
2694 if (test_find_0_skip ()) {
2695 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
2699 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
2701 char device[] = "/dev/sda";
2704 r = guestfs_blockdev_setrw (g, device);
2711 r = guestfs_umount_all (g);
2718 r = guestfs_lvm_remove_all (g);
2723 char device[] = "/dev/sda";
2724 char lines_0[] = ",";
2731 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2736 char fstype[] = "ext2";
2737 char device[] = "/dev/sda1";
2740 r = guestfs_mkfs (g, fstype, device);
2745 char device[] = "/dev/sda1";
2746 char mountpoint[] = "/";
2749 r = guestfs_mount (g, device, mountpoint);
2753 /* TestOutputList for find (0) */
2755 char directory[] = "/";
2759 r = guestfs_find (g, directory);
2763 fprintf (stderr, "test_find_0: short list returned from command\n");
2768 char expected[] = "lost+found";
2769 if (strcmp (r[0], expected) != 0) {
2770 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2775 fprintf (stderr, "test_find_0: extra elements returned from command\n");
2779 for (i = 0; r[i] != NULL; ++i)
2786 static int test_find_1_skip (void)
2790 str = getenv ("TEST_ONLY");
2792 return strstr (str, "find") == NULL;
2793 str = getenv ("SKIP_TEST_FIND_1");
2794 if (str && strcmp (str, "1") == 0) return 1;
2795 str = getenv ("SKIP_TEST_FIND");
2796 if (str && strcmp (str, "1") == 0) return 1;
2800 static int test_find_1 (void)
2802 if (test_find_1_skip ()) {
2803 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
2807 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
2809 char device[] = "/dev/sda";
2812 r = guestfs_blockdev_setrw (g, device);
2819 r = guestfs_umount_all (g);
2826 r = guestfs_lvm_remove_all (g);
2831 char device[] = "/dev/sda";
2832 char lines_0[] = ",";
2839 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2844 char fstype[] = "ext2";
2845 char device[] = "/dev/sda1";
2848 r = guestfs_mkfs (g, fstype, device);
2853 char device[] = "/dev/sda1";
2854 char mountpoint[] = "/";
2857 r = guestfs_mount (g, device, mountpoint);
2861 /* TestOutputList for find (1) */
2866 r = guestfs_touch (g, path);
2874 r = guestfs_mkdir (g, path);
2879 char path[] = "/b/c";
2882 r = guestfs_touch (g, path);
2887 char directory[] = "/";
2891 r = guestfs_find (g, directory);
2895 fprintf (stderr, "test_find_1: short list returned from command\n");
2900 char expected[] = "a";
2901 if (strcmp (r[0], expected) != 0) {
2902 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2907 fprintf (stderr, "test_find_1: short list returned from command\n");
2912 char expected[] = "b";
2913 if (strcmp (r[1], expected) != 0) {
2914 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2919 fprintf (stderr, "test_find_1: short list returned from command\n");
2924 char expected[] = "b/c";
2925 if (strcmp (r[2], expected) != 0) {
2926 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
2931 fprintf (stderr, "test_find_1: short list returned from command\n");
2936 char expected[] = "lost+found";
2937 if (strcmp (r[3], expected) != 0) {
2938 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
2943 fprintf (stderr, "test_find_1: extra elements returned from command\n");
2947 for (i = 0; r[i] != NULL; ++i)
2954 static int test_find_2_skip (void)
2958 str = getenv ("TEST_ONLY");
2960 return strstr (str, "find") == NULL;
2961 str = getenv ("SKIP_TEST_FIND_2");
2962 if (str && strcmp (str, "1") == 0) return 1;
2963 str = getenv ("SKIP_TEST_FIND");
2964 if (str && strcmp (str, "1") == 0) return 1;
2968 static int test_find_2 (void)
2970 if (test_find_2_skip ()) {
2971 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
2975 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
2977 char device[] = "/dev/sda";
2980 r = guestfs_blockdev_setrw (g, device);
2987 r = guestfs_umount_all (g);
2994 r = guestfs_lvm_remove_all (g);
2999 char device[] = "/dev/sda";
3000 char lines_0[] = ",";
3007 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3012 char fstype[] = "ext2";
3013 char device[] = "/dev/sda1";
3016 r = guestfs_mkfs (g, fstype, device);
3021 char device[] = "/dev/sda1";
3022 char mountpoint[] = "/";
3025 r = guestfs_mount (g, device, mountpoint);
3029 /* TestOutputList for find (2) */
3031 char path[] = "/a/b/c";
3034 r = guestfs_mkdir_p (g, path);
3039 char path[] = "/a/b/c/d";
3042 r = guestfs_touch (g, path);
3047 char directory[] = "/a/b/";
3051 r = guestfs_find (g, directory);
3055 fprintf (stderr, "test_find_2: short list returned from command\n");
3060 char expected[] = "c";
3061 if (strcmp (r[0], expected) != 0) {
3062 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3067 fprintf (stderr, "test_find_2: short list returned from command\n");
3072 char expected[] = "c/d";
3073 if (strcmp (r[1], expected) != 0) {
3074 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3079 fprintf (stderr, "test_find_2: extra elements returned from command\n");
3083 for (i = 0; r[i] != NULL; ++i)
3090 static int test_lvresize_0_skip (void)
3094 str = getenv ("TEST_ONLY");
3096 return strstr (str, "lvresize") == NULL;
3097 str = getenv ("SKIP_TEST_LVRESIZE_0");
3098 if (str && strcmp (str, "1") == 0) return 1;
3099 str = getenv ("SKIP_TEST_LVRESIZE");
3100 if (str && strcmp (str, "1") == 0) return 1;
3104 static int test_lvresize_0 (void)
3106 if (test_lvresize_0_skip ()) {
3107 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
3111 /* InitNone|InitEmpty for test_lvresize_0 */
3113 char device[] = "/dev/sda";
3116 r = guestfs_blockdev_setrw (g, device);
3123 r = guestfs_umount_all (g);
3130 r = guestfs_lvm_remove_all (g);
3134 /* TestOutput for lvresize (0) */
3135 char expected[] = "test content";
3137 char device[] = "/dev/sda";
3138 char lines_0[] = ",";
3145 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3150 char device[] = "/dev/sda1";
3153 r = guestfs_pvcreate (g, device);
3158 char volgroup[] = "VG";
3159 char physvols_0[] = "/dev/sda1";
3160 char *physvols[] = {
3166 r = guestfs_vgcreate (g, volgroup, physvols);
3171 char logvol[] = "LV";
3172 char volgroup[] = "VG";
3175 r = guestfs_lvcreate (g, logvol, volgroup, 10);
3180 char fstype[] = "ext2";
3181 char device[] = "/dev/VG/LV";
3184 r = guestfs_mkfs (g, fstype, device);
3189 char device[] = "/dev/VG/LV";
3190 char mountpoint[] = "/";
3193 r = guestfs_mount (g, device, mountpoint);
3198 char path[] = "/new";
3199 char content[] = "test content";
3202 r = guestfs_write_file (g, path, content, 0);
3207 char pathordevice[] = "/";
3210 r = guestfs_umount (g, pathordevice);
3215 char device[] = "/dev/VG/LV";
3218 r = guestfs_lvresize (g, device, 20);
3223 char device[] = "/dev/VG/LV";
3226 r = guestfs_e2fsck_f (g, device);
3231 char device[] = "/dev/VG/LV";
3234 r = guestfs_resize2fs (g, device);
3239 char device[] = "/dev/VG/LV";
3240 char mountpoint[] = "/";
3243 r = guestfs_mount (g, device, mountpoint);
3248 char path[] = "/new";
3251 r = guestfs_cat (g, path);
3254 if (strcmp (r, expected) != 0) {
3255 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
3263 static int test_zerofree_0_skip (void)
3267 str = getenv ("TEST_ONLY");
3269 return strstr (str, "zerofree") == NULL;
3270 str = getenv ("SKIP_TEST_ZEROFREE_0");
3271 if (str && strcmp (str, "1") == 0) return 1;
3272 str = getenv ("SKIP_TEST_ZEROFREE");
3273 if (str && strcmp (str, "1") == 0) return 1;
3277 static int test_zerofree_0 (void)
3279 if (test_zerofree_0_skip ()) {
3280 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
3284 /* InitNone|InitEmpty for test_zerofree_0 */
3286 char device[] = "/dev/sda";
3289 r = guestfs_blockdev_setrw (g, device);
3296 r = guestfs_umount_all (g);
3303 r = guestfs_lvm_remove_all (g);
3307 /* TestOutput for zerofree (0) */
3308 char expected[] = "test file";
3310 char device[] = "/dev/sda";
3311 char lines_0[] = ",";
3318 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3323 char fstype[] = "ext3";
3324 char device[] = "/dev/sda1";
3327 r = guestfs_mkfs (g, fstype, device);
3332 char device[] = "/dev/sda1";
3333 char mountpoint[] = "/";
3336 r = guestfs_mount (g, device, mountpoint);
3341 char path[] = "/new";
3342 char content[] = "test file";
3345 r = guestfs_write_file (g, path, content, 0);
3350 char pathordevice[] = "/dev/sda1";
3353 r = guestfs_umount (g, pathordevice);
3358 char device[] = "/dev/sda1";
3361 r = guestfs_zerofree (g, device);
3366 char device[] = "/dev/sda1";
3367 char mountpoint[] = "/";
3370 r = guestfs_mount (g, device, mountpoint);
3375 char path[] = "/new";
3378 r = guestfs_cat (g, path);
3381 if (strcmp (r, expected) != 0) {
3382 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
3390 static int test_hexdump_0_skip (void)
3394 str = getenv ("TEST_ONLY");
3396 return strstr (str, "hexdump") == NULL;
3397 str = getenv ("SKIP_TEST_HEXDUMP_0");
3398 if (str && strcmp (str, "1") == 0) return 1;
3399 str = getenv ("SKIP_TEST_HEXDUMP");
3400 if (str && strcmp (str, "1") == 0) return 1;
3404 static int test_hexdump_0 (void)
3406 if (test_hexdump_0_skip ()) {
3407 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
3411 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
3413 char device[] = "/dev/sda";
3416 r = guestfs_blockdev_setrw (g, device);
3423 r = guestfs_umount_all (g);
3430 r = guestfs_lvm_remove_all (g);
3435 char device[] = "/dev/sda";
3436 char lines_0[] = ",";
3443 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3448 char fstype[] = "ext2";
3449 char device[] = "/dev/sda1";
3452 r = guestfs_mkfs (g, fstype, device);
3457 char device[] = "/dev/sda1";
3458 char mountpoint[] = "/";
3461 r = guestfs_mount (g, device, mountpoint);
3465 /* TestOutput for hexdump (0) */
3466 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
3468 char path[] = "/new";
3469 char content[] = "hello\nworld\n";
3472 r = guestfs_write_file (g, path, content, 12);
3477 char path[] = "/new";
3480 r = guestfs_hexdump (g, path);
3483 if (strcmp (r, expected) != 0) {
3484 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
3492 static int test_hexdump_1_skip (void)
3496 str = getenv ("TEST_ONLY");
3498 return strstr (str, "hexdump") == NULL;
3499 str = getenv ("SKIP_TEST_HEXDUMP_1");
3500 if (str && strcmp (str, "1") == 0) return 1;
3501 str = getenv ("SKIP_TEST_HEXDUMP");
3502 if (str && strcmp (str, "1") == 0) return 1;
3506 static int test_hexdump_1 (void)
3508 if (test_hexdump_1_skip ()) {
3509 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
3513 /* InitBasicFS for test_hexdump_1: 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 /* TestRun for hexdump (1) */
3569 char options[] = "ro";
3570 char vfstype[] = "squashfs";
3571 char device[] = "/dev/sdd";
3572 char mountpoint[] = "/";
3575 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
3580 char path[] = "/100krandom";
3583 r = guestfs_hexdump (g, path);
3591 static int test_strings_e_0_skip (void)
3595 str = getenv ("TEST_ONLY");
3597 return strstr (str, "strings_e") == NULL;
3598 str = getenv ("SKIP_TEST_STRINGS_E_0");
3599 if (str && strcmp (str, "1") == 0) return 1;
3600 str = getenv ("SKIP_TEST_STRINGS_E");
3601 if (str && strcmp (str, "1") == 0) return 1;
3605 static int test_strings_e_0 (void)
3607 if (test_strings_e_0_skip ()) {
3608 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
3612 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
3614 char device[] = "/dev/sda";
3617 r = guestfs_blockdev_setrw (g, device);
3624 r = guestfs_umount_all (g);
3631 r = guestfs_lvm_remove_all (g);
3636 char device[] = "/dev/sda";
3637 char lines_0[] = ",";
3644 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3649 char fstype[] = "ext2";
3650 char device[] = "/dev/sda1";
3653 r = guestfs_mkfs (g, fstype, device);
3658 char device[] = "/dev/sda1";
3659 char mountpoint[] = "/";
3662 r = guestfs_mount (g, device, mountpoint);
3666 /* TestOutputList for strings_e (0) */
3668 char path[] = "/new";
3669 char content[] = "hello\nworld\n";
3672 r = guestfs_write_file (g, path, content, 0);
3677 char encoding[] = "b";
3678 char path[] = "/new";
3682 r = guestfs_strings_e (g, encoding, path);
3686 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
3690 for (i = 0; r[i] != NULL; ++i)
3697 static int test_strings_e_1_skip (void)
3701 str = getenv ("TEST_ONLY");
3703 return strstr (str, "strings_e") == NULL;
3704 str = getenv ("SKIP_TEST_STRINGS_E_1");
3705 if (str && strcmp (str, "1") == 0) return 1;
3706 str = getenv ("SKIP_TEST_STRINGS_E");
3707 if (str && strcmp (str, "1") == 0) return 1;
3711 static int test_strings_e_1 (void)
3713 if (test_strings_e_1_skip ()) {
3714 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
3718 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
3722 static int test_strings_0_skip (void)
3726 str = getenv ("TEST_ONLY");
3728 return strstr (str, "strings") == NULL;
3729 str = getenv ("SKIP_TEST_STRINGS_0");
3730 if (str && strcmp (str, "1") == 0) return 1;
3731 str = getenv ("SKIP_TEST_STRINGS");
3732 if (str && strcmp (str, "1") == 0) return 1;
3736 static int test_strings_0 (void)
3738 if (test_strings_0_skip ()) {
3739 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
3743 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
3745 char device[] = "/dev/sda";
3748 r = guestfs_blockdev_setrw (g, device);
3755 r = guestfs_umount_all (g);
3762 r = guestfs_lvm_remove_all (g);
3767 char device[] = "/dev/sda";
3768 char lines_0[] = ",";
3775 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3780 char fstype[] = "ext2";
3781 char device[] = "/dev/sda1";
3784 r = guestfs_mkfs (g, fstype, device);
3789 char device[] = "/dev/sda1";
3790 char mountpoint[] = "/";
3793 r = guestfs_mount (g, device, mountpoint);
3797 /* TestOutputList for strings (0) */
3799 char path[] = "/new";
3800 char content[] = "hello\nworld\n";
3803 r = guestfs_write_file (g, path, content, 0);
3808 char path[] = "/new";
3812 r = guestfs_strings (g, path);
3816 fprintf (stderr, "test_strings_0: short list returned from command\n");
3821 char expected[] = "hello";
3822 if (strcmp (r[0], expected) != 0) {
3823 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
3828 fprintf (stderr, "test_strings_0: short list returned from command\n");
3833 char expected[] = "world";
3834 if (strcmp (r[1], expected) != 0) {
3835 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
3840 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
3844 for (i = 0; r[i] != NULL; ++i)
3851 static int test_strings_1_skip (void)
3855 str = getenv ("TEST_ONLY");
3857 return strstr (str, "strings") == NULL;
3858 str = getenv ("SKIP_TEST_STRINGS_1");
3859 if (str && strcmp (str, "1") == 0) return 1;
3860 str = getenv ("SKIP_TEST_STRINGS");
3861 if (str && strcmp (str, "1") == 0) return 1;
3865 static int test_strings_1 (void)
3867 if (test_strings_1_skip ()) {
3868 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
3872 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
3874 char device[] = "/dev/sda";
3877 r = guestfs_blockdev_setrw (g, device);
3884 r = guestfs_umount_all (g);
3891 r = guestfs_lvm_remove_all (g);
3896 char device[] = "/dev/sda";
3897 char lines_0[] = ",";
3904 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3909 char fstype[] = "ext2";
3910 char device[] = "/dev/sda1";
3913 r = guestfs_mkfs (g, fstype, device);
3918 char device[] = "/dev/sda1";
3919 char mountpoint[] = "/";
3922 r = guestfs_mount (g, device, mountpoint);
3926 /* TestOutputList for strings (1) */
3928 char path[] = "/new";
3931 r = guestfs_touch (g, path);
3936 char path[] = "/new";
3940 r = guestfs_strings (g, path);
3944 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
3948 for (i = 0; r[i] != NULL; ++i)
3955 static int test_equal_0_skip (void)
3959 str = getenv ("TEST_ONLY");
3961 return strstr (str, "equal") == NULL;
3962 str = getenv ("SKIP_TEST_EQUAL_0");
3963 if (str && strcmp (str, "1") == 0) return 1;
3964 str = getenv ("SKIP_TEST_EQUAL");
3965 if (str && strcmp (str, "1") == 0) return 1;
3969 static int test_equal_0 (void)
3971 if (test_equal_0_skip ()) {
3972 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
3976 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
3978 char device[] = "/dev/sda";
3981 r = guestfs_blockdev_setrw (g, device);
3988 r = guestfs_umount_all (g);
3995 r = guestfs_lvm_remove_all (g);
4000 char device[] = "/dev/sda";
4001 char lines_0[] = ",";
4008 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4013 char fstype[] = "ext2";
4014 char device[] = "/dev/sda1";
4017 r = guestfs_mkfs (g, fstype, device);
4022 char device[] = "/dev/sda1";
4023 char mountpoint[] = "/";
4026 r = guestfs_mount (g, device, mountpoint);
4030 /* TestOutputTrue for equal (0) */
4032 char path[] = "/file1";
4033 char content[] = "contents of a file";
4036 r = guestfs_write_file (g, path, content, 0);
4041 char src[] = "/file1";
4042 char dest[] = "/file2";
4045 r = guestfs_cp (g, src, dest);
4050 char file1[] = "/file1";
4051 char file2[] = "/file2";
4054 r = guestfs_equal (g, file1, file2);
4058 fprintf (stderr, "test_equal_0: expected true, got false\n");
4065 static int test_equal_1_skip (void)
4069 str = getenv ("TEST_ONLY");
4071 return strstr (str, "equal") == NULL;
4072 str = getenv ("SKIP_TEST_EQUAL_1");
4073 if (str && strcmp (str, "1") == 0) return 1;
4074 str = getenv ("SKIP_TEST_EQUAL");
4075 if (str && strcmp (str, "1") == 0) return 1;
4079 static int test_equal_1 (void)
4081 if (test_equal_1_skip ()) {
4082 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
4086 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
4088 char device[] = "/dev/sda";
4091 r = guestfs_blockdev_setrw (g, device);
4098 r = guestfs_umount_all (g);
4105 r = guestfs_lvm_remove_all (g);
4110 char device[] = "/dev/sda";
4111 char lines_0[] = ",";
4118 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4123 char fstype[] = "ext2";
4124 char device[] = "/dev/sda1";
4127 r = guestfs_mkfs (g, fstype, device);
4132 char device[] = "/dev/sda1";
4133 char mountpoint[] = "/";
4136 r = guestfs_mount (g, device, mountpoint);
4140 /* TestOutputFalse for equal (1) */
4142 char path[] = "/file1";
4143 char content[] = "contents of a file";
4146 r = guestfs_write_file (g, path, content, 0);
4151 char path[] = "/file2";
4152 char content[] = "contents of another file";
4155 r = guestfs_write_file (g, path, content, 0);
4160 char file1[] = "/file1";
4161 char file2[] = "/file2";
4164 r = guestfs_equal (g, file1, file2);
4168 fprintf (stderr, "test_equal_1: expected false, got true\n");
4175 static int test_equal_2_skip (void)
4179 str = getenv ("TEST_ONLY");
4181 return strstr (str, "equal") == NULL;
4182 str = getenv ("SKIP_TEST_EQUAL_2");
4183 if (str && strcmp (str, "1") == 0) return 1;
4184 str = getenv ("SKIP_TEST_EQUAL");
4185 if (str && strcmp (str, "1") == 0) return 1;
4189 static int test_equal_2 (void)
4191 if (test_equal_2_skip ()) {
4192 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
4196 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
4198 char device[] = "/dev/sda";
4201 r = guestfs_blockdev_setrw (g, device);
4208 r = guestfs_umount_all (g);
4215 r = guestfs_lvm_remove_all (g);
4220 char device[] = "/dev/sda";
4221 char lines_0[] = ",";
4228 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4233 char fstype[] = "ext2";
4234 char device[] = "/dev/sda1";
4237 r = guestfs_mkfs (g, fstype, device);
4242 char device[] = "/dev/sda1";
4243 char mountpoint[] = "/";
4246 r = guestfs_mount (g, device, mountpoint);
4250 /* TestLastFail for equal (2) */
4252 char file1[] = "/file1";
4253 char file2[] = "/file2";
4256 r = guestfs_equal (g, file1, file2);
4263 static int test_ping_daemon_0_skip (void)
4267 str = getenv ("TEST_ONLY");
4269 return strstr (str, "ping_daemon") == NULL;
4270 str = getenv ("SKIP_TEST_PING_DAEMON_0");
4271 if (str && strcmp (str, "1") == 0) return 1;
4272 str = getenv ("SKIP_TEST_PING_DAEMON");
4273 if (str && strcmp (str, "1") == 0) return 1;
4277 static int test_ping_daemon_0 (void)
4279 if (test_ping_daemon_0_skip ()) {
4280 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
4284 /* InitNone|InitEmpty for test_ping_daemon_0 */
4286 char device[] = "/dev/sda";
4289 r = guestfs_blockdev_setrw (g, device);
4296 r = guestfs_umount_all (g);
4303 r = guestfs_lvm_remove_all (g);
4307 /* TestRun for ping_daemon (0) */
4311 r = guestfs_ping_daemon (g);
4318 static int test_dmesg_0_skip (void)
4322 str = getenv ("TEST_ONLY");
4324 return strstr (str, "dmesg") == NULL;
4325 str = getenv ("SKIP_TEST_DMESG_0");
4326 if (str && strcmp (str, "1") == 0) return 1;
4327 str = getenv ("SKIP_TEST_DMESG");
4328 if (str && strcmp (str, "1") == 0) return 1;
4332 static int test_dmesg_0 (void)
4334 if (test_dmesg_0_skip ()) {
4335 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
4339 /* InitNone|InitEmpty for test_dmesg_0 */
4341 char device[] = "/dev/sda";
4344 r = guestfs_blockdev_setrw (g, device);
4351 r = guestfs_umount_all (g);
4358 r = guestfs_lvm_remove_all (g);
4362 /* TestRun for dmesg (0) */
4366 r = guestfs_dmesg (g);
4374 static int test_drop_caches_0_skip (void)
4378 str = getenv ("TEST_ONLY");
4380 return strstr (str, "drop_caches") == NULL;
4381 str = getenv ("SKIP_TEST_DROP_CACHES_0");
4382 if (str && strcmp (str, "1") == 0) return 1;
4383 str = getenv ("SKIP_TEST_DROP_CACHES");
4384 if (str && strcmp (str, "1") == 0) return 1;
4388 static int test_drop_caches_0 (void)
4390 if (test_drop_caches_0_skip ()) {
4391 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
4395 /* InitNone|InitEmpty for test_drop_caches_0 */
4397 char device[] = "/dev/sda";
4400 r = guestfs_blockdev_setrw (g, device);
4407 r = guestfs_umount_all (g);
4414 r = guestfs_lvm_remove_all (g);
4418 /* TestRun for drop_caches (0) */
4422 r = guestfs_drop_caches (g, 3);
4429 static int test_mv_0_skip (void)
4433 str = getenv ("TEST_ONLY");
4435 return strstr (str, "mv") == NULL;
4436 str = getenv ("SKIP_TEST_MV_0");
4437 if (str && strcmp (str, "1") == 0) return 1;
4438 str = getenv ("SKIP_TEST_MV");
4439 if (str && strcmp (str, "1") == 0) return 1;
4443 static int test_mv_0 (void)
4445 if (test_mv_0_skip ()) {
4446 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
4450 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
4452 char device[] = "/dev/sda";
4455 r = guestfs_blockdev_setrw (g, device);
4462 r = guestfs_umount_all (g);
4469 r = guestfs_lvm_remove_all (g);
4474 char device[] = "/dev/sda";
4475 char lines_0[] = ",";
4482 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4487 char fstype[] = "ext2";
4488 char device[] = "/dev/sda1";
4491 r = guestfs_mkfs (g, fstype, device);
4496 char device[] = "/dev/sda1";
4497 char mountpoint[] = "/";
4500 r = guestfs_mount (g, device, mountpoint);
4504 /* TestOutput for mv (0) */
4505 char expected[] = "file content";
4507 char path[] = "/old";
4508 char content[] = "file content";
4511 r = guestfs_write_file (g, path, content, 0);
4516 char src[] = "/old";
4517 char dest[] = "/new";
4520 r = guestfs_mv (g, src, dest);
4525 char path[] = "/new";
4528 r = guestfs_cat (g, path);
4531 if (strcmp (r, expected) != 0) {
4532 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
4540 static int test_mv_1_skip (void)
4544 str = getenv ("TEST_ONLY");
4546 return strstr (str, "mv") == NULL;
4547 str = getenv ("SKIP_TEST_MV_1");
4548 if (str && strcmp (str, "1") == 0) return 1;
4549 str = getenv ("SKIP_TEST_MV");
4550 if (str && strcmp (str, "1") == 0) return 1;
4554 static int test_mv_1 (void)
4556 if (test_mv_1_skip ()) {
4557 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
4561 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
4563 char device[] = "/dev/sda";
4566 r = guestfs_blockdev_setrw (g, device);
4573 r = guestfs_umount_all (g);
4580 r = guestfs_lvm_remove_all (g);
4585 char device[] = "/dev/sda";
4586 char lines_0[] = ",";
4593 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4598 char fstype[] = "ext2";
4599 char device[] = "/dev/sda1";
4602 r = guestfs_mkfs (g, fstype, device);
4607 char device[] = "/dev/sda1";
4608 char mountpoint[] = "/";
4611 r = guestfs_mount (g, device, mountpoint);
4615 /* TestOutputFalse for mv (1) */
4617 char path[] = "/old";
4618 char content[] = "file content";
4621 r = guestfs_write_file (g, path, content, 0);
4626 char src[] = "/old";
4627 char dest[] = "/new";
4630 r = guestfs_mv (g, src, dest);
4635 char path[] = "/old";
4638 r = guestfs_is_file (g, path);
4642 fprintf (stderr, "test_mv_1: expected false, got true\n");
4649 static int test_cp_a_0_skip (void)
4653 str = getenv ("TEST_ONLY");
4655 return strstr (str, "cp_a") == NULL;
4656 str = getenv ("SKIP_TEST_CP_A_0");
4657 if (str && strcmp (str, "1") == 0) return 1;
4658 str = getenv ("SKIP_TEST_CP_A");
4659 if (str && strcmp (str, "1") == 0) return 1;
4663 static int test_cp_a_0 (void)
4665 if (test_cp_a_0_skip ()) {
4666 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
4670 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
4672 char device[] = "/dev/sda";
4675 r = guestfs_blockdev_setrw (g, device);
4682 r = guestfs_umount_all (g);
4689 r = guestfs_lvm_remove_all (g);
4694 char device[] = "/dev/sda";
4695 char lines_0[] = ",";
4702 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4707 char fstype[] = "ext2";
4708 char device[] = "/dev/sda1";
4711 r = guestfs_mkfs (g, fstype, device);
4716 char device[] = "/dev/sda1";
4717 char mountpoint[] = "/";
4720 r = guestfs_mount (g, device, mountpoint);
4724 /* TestOutput for cp_a (0) */
4725 char expected[] = "file content";
4727 char path[] = "/olddir";
4730 r = guestfs_mkdir (g, path);
4735 char path[] = "/newdir";
4738 r = guestfs_mkdir (g, path);
4743 char path[] = "/olddir/file";
4744 char content[] = "file content";
4747 r = guestfs_write_file (g, path, content, 0);
4752 char src[] = "/olddir";
4753 char dest[] = "/newdir";
4756 r = guestfs_cp_a (g, src, dest);
4761 char path[] = "/newdir/olddir/file";
4764 r = guestfs_cat (g, path);
4767 if (strcmp (r, expected) != 0) {
4768 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
4776 static int test_cp_0_skip (void)
4780 str = getenv ("TEST_ONLY");
4782 return strstr (str, "cp") == NULL;
4783 str = getenv ("SKIP_TEST_CP_0");
4784 if (str && strcmp (str, "1") == 0) return 1;
4785 str = getenv ("SKIP_TEST_CP");
4786 if (str && strcmp (str, "1") == 0) return 1;
4790 static int test_cp_0 (void)
4792 if (test_cp_0_skip ()) {
4793 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
4797 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
4799 char device[] = "/dev/sda";
4802 r = guestfs_blockdev_setrw (g, device);
4809 r = guestfs_umount_all (g);
4816 r = guestfs_lvm_remove_all (g);
4821 char device[] = "/dev/sda";
4822 char lines_0[] = ",";
4829 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4834 char fstype[] = "ext2";
4835 char device[] = "/dev/sda1";
4838 r = guestfs_mkfs (g, fstype, device);
4843 char device[] = "/dev/sda1";
4844 char mountpoint[] = "/";
4847 r = guestfs_mount (g, device, mountpoint);
4851 /* TestOutput for cp (0) */
4852 char expected[] = "file content";
4854 char path[] = "/old";
4855 char content[] = "file content";
4858 r = guestfs_write_file (g, path, content, 0);
4863 char src[] = "/old";
4864 char dest[] = "/new";
4867 r = guestfs_cp (g, src, dest);
4872 char path[] = "/new";
4875 r = guestfs_cat (g, path);
4878 if (strcmp (r, expected) != 0) {
4879 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
4887 static int test_cp_1_skip (void)
4891 str = getenv ("TEST_ONLY");
4893 return strstr (str, "cp") == NULL;
4894 str = getenv ("SKIP_TEST_CP_1");
4895 if (str && strcmp (str, "1") == 0) return 1;
4896 str = getenv ("SKIP_TEST_CP");
4897 if (str && strcmp (str, "1") == 0) return 1;
4901 static int test_cp_1 (void)
4903 if (test_cp_1_skip ()) {
4904 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
4908 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
4910 char device[] = "/dev/sda";
4913 r = guestfs_blockdev_setrw (g, device);
4920 r = guestfs_umount_all (g);
4927 r = guestfs_lvm_remove_all (g);
4932 char device[] = "/dev/sda";
4933 char lines_0[] = ",";
4940 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4945 char fstype[] = "ext2";
4946 char device[] = "/dev/sda1";
4949 r = guestfs_mkfs (g, fstype, device);
4954 char device[] = "/dev/sda1";
4955 char mountpoint[] = "/";
4958 r = guestfs_mount (g, device, mountpoint);
4962 /* TestOutputTrue for cp (1) */
4964 char path[] = "/old";
4965 char content[] = "file content";
4968 r = guestfs_write_file (g, path, content, 0);
4973 char src[] = "/old";
4974 char dest[] = "/new";
4977 r = guestfs_cp (g, src, dest);
4982 char path[] = "/old";
4985 r = guestfs_is_file (g, path);
4989 fprintf (stderr, "test_cp_1: expected true, got false\n");
4996 static int test_cp_2_skip (void)
5000 str = getenv ("TEST_ONLY");
5002 return strstr (str, "cp") == NULL;
5003 str = getenv ("SKIP_TEST_CP_2");
5004 if (str && strcmp (str, "1") == 0) return 1;
5005 str = getenv ("SKIP_TEST_CP");
5006 if (str && strcmp (str, "1") == 0) return 1;
5010 static int test_cp_2 (void)
5012 if (test_cp_2_skip ()) {
5013 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
5017 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
5019 char device[] = "/dev/sda";
5022 r = guestfs_blockdev_setrw (g, device);
5029 r = guestfs_umount_all (g);
5036 r = guestfs_lvm_remove_all (g);
5041 char device[] = "/dev/sda";
5042 char lines_0[] = ",";
5049 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5054 char fstype[] = "ext2";
5055 char device[] = "/dev/sda1";
5058 r = guestfs_mkfs (g, fstype, device);
5063 char device[] = "/dev/sda1";
5064 char mountpoint[] = "/";
5067 r = guestfs_mount (g, device, mountpoint);
5071 /* TestOutput for cp (2) */
5072 char expected[] = "file content";
5074 char path[] = "/old";
5075 char content[] = "file content";
5078 r = guestfs_write_file (g, path, content, 0);
5083 char path[] = "/dir";
5086 r = guestfs_mkdir (g, path);
5091 char src[] = "/old";
5092 char dest[] = "/dir/new";
5095 r = guestfs_cp (g, src, dest);
5100 char path[] = "/dir/new";
5103 r = guestfs_cat (g, path);
5106 if (strcmp (r, expected) != 0) {
5107 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
5115 static int test_grub_install_0_skip (void)
5119 str = getenv ("TEST_ONLY");
5121 return strstr (str, "grub_install") == NULL;
5122 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
5123 if (str && strcmp (str, "1") == 0) return 1;
5124 str = getenv ("SKIP_TEST_GRUB_INSTALL");
5125 if (str && strcmp (str, "1") == 0) return 1;
5129 static int test_grub_install_0 (void)
5131 if (test_grub_install_0_skip ()) {
5132 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
5136 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
5138 char device[] = "/dev/sda";
5141 r = guestfs_blockdev_setrw (g, device);
5148 r = guestfs_umount_all (g);
5155 r = guestfs_lvm_remove_all (g);
5160 char device[] = "/dev/sda";
5161 char lines_0[] = ",";
5168 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5173 char fstype[] = "ext2";
5174 char device[] = "/dev/sda1";
5177 r = guestfs_mkfs (g, fstype, device);
5182 char device[] = "/dev/sda1";
5183 char mountpoint[] = "/";
5186 r = guestfs_mount (g, device, mountpoint);
5190 /* TestOutputTrue for grub_install (0) */
5193 char device[] = "/dev/sda1";
5196 r = guestfs_grub_install (g, root, device);
5201 char path[] = "/boot";
5204 r = guestfs_is_dir (g, path);
5208 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
5215 static int test_zero_0_skip (void)
5219 str = getenv ("TEST_ONLY");
5221 return strstr (str, "zero") == NULL;
5222 str = getenv ("SKIP_TEST_ZERO_0");
5223 if (str && strcmp (str, "1") == 0) return 1;
5224 str = getenv ("SKIP_TEST_ZERO");
5225 if (str && strcmp (str, "1") == 0) return 1;
5229 static int test_zero_0 (void)
5231 if (test_zero_0_skip ()) {
5232 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
5236 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
5238 char device[] = "/dev/sda";
5241 r = guestfs_blockdev_setrw (g, device);
5248 r = guestfs_umount_all (g);
5255 r = guestfs_lvm_remove_all (g);
5260 char device[] = "/dev/sda";
5261 char lines_0[] = ",";
5268 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5273 char fstype[] = "ext2";
5274 char device[] = "/dev/sda1";
5277 r = guestfs_mkfs (g, fstype, device);
5282 char device[] = "/dev/sda1";
5283 char mountpoint[] = "/";
5286 r = guestfs_mount (g, device, mountpoint);
5290 /* TestOutput for zero (0) */
5291 char expected[] = "data";
5293 char pathordevice[] = "/dev/sda1";
5296 r = guestfs_umount (g, pathordevice);
5301 char device[] = "/dev/sda1";
5304 r = guestfs_zero (g, device);
5309 char path[] = "/dev/sda1";
5312 r = guestfs_file (g, path);
5315 if (strcmp (r, expected) != 0) {
5316 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
5324 static int test_fsck_0_skip (void)
5328 str = getenv ("TEST_ONLY");
5330 return strstr (str, "fsck") == NULL;
5331 str = getenv ("SKIP_TEST_FSCK_0");
5332 if (str && strcmp (str, "1") == 0) return 1;
5333 str = getenv ("SKIP_TEST_FSCK");
5334 if (str && strcmp (str, "1") == 0) return 1;
5338 static int test_fsck_0 (void)
5340 if (test_fsck_0_skip ()) {
5341 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
5345 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
5347 char device[] = "/dev/sda";
5350 r = guestfs_blockdev_setrw (g, device);
5357 r = guestfs_umount_all (g);
5364 r = guestfs_lvm_remove_all (g);
5369 char device[] = "/dev/sda";
5370 char lines_0[] = ",";
5377 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5382 char fstype[] = "ext2";
5383 char device[] = "/dev/sda1";
5386 r = guestfs_mkfs (g, fstype, device);
5391 char device[] = "/dev/sda1";
5392 char mountpoint[] = "/";
5395 r = guestfs_mount (g, device, mountpoint);
5399 /* TestOutputInt for fsck (0) */
5401 char pathordevice[] = "/dev/sda1";
5404 r = guestfs_umount (g, pathordevice);
5409 char fstype[] = "ext2";
5410 char device[] = "/dev/sda1";
5413 r = guestfs_fsck (g, fstype, device);
5417 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
5424 static int test_fsck_1_skip (void)
5428 str = getenv ("TEST_ONLY");
5430 return strstr (str, "fsck") == NULL;
5431 str = getenv ("SKIP_TEST_FSCK_1");
5432 if (str && strcmp (str, "1") == 0) return 1;
5433 str = getenv ("SKIP_TEST_FSCK");
5434 if (str && strcmp (str, "1") == 0) return 1;
5438 static int test_fsck_1 (void)
5440 if (test_fsck_1_skip ()) {
5441 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
5445 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
5447 char device[] = "/dev/sda";
5450 r = guestfs_blockdev_setrw (g, device);
5457 r = guestfs_umount_all (g);
5464 r = guestfs_lvm_remove_all (g);
5469 char device[] = "/dev/sda";
5470 char lines_0[] = ",";
5477 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5482 char fstype[] = "ext2";
5483 char device[] = "/dev/sda1";
5486 r = guestfs_mkfs (g, fstype, device);
5491 char device[] = "/dev/sda1";
5492 char mountpoint[] = "/";
5495 r = guestfs_mount (g, device, mountpoint);
5499 /* TestOutputInt for fsck (1) */
5501 char pathordevice[] = "/dev/sda1";
5504 r = guestfs_umount (g, pathordevice);
5509 char device[] = "/dev/sda1";
5512 r = guestfs_zero (g, device);
5517 char fstype[] = "ext2";
5518 char device[] = "/dev/sda1";
5521 r = guestfs_fsck (g, fstype, device);
5525 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
5532 static int test_set_e2uuid_0_skip (void)
5536 str = getenv ("TEST_ONLY");
5538 return strstr (str, "set_e2uuid") == NULL;
5539 str = getenv ("SKIP_TEST_SET_E2UUID_0");
5540 if (str && strcmp (str, "1") == 0) return 1;
5541 str = getenv ("SKIP_TEST_SET_E2UUID");
5542 if (str && strcmp (str, "1") == 0) return 1;
5546 static int test_set_e2uuid_0 (void)
5548 if (test_set_e2uuid_0_skip ()) {
5549 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
5553 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
5555 char device[] = "/dev/sda";
5558 r = guestfs_blockdev_setrw (g, device);
5565 r = guestfs_umount_all (g);
5572 r = guestfs_lvm_remove_all (g);
5577 char device[] = "/dev/sda";
5578 char lines_0[] = ",";
5585 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5590 char fstype[] = "ext2";
5591 char device[] = "/dev/sda1";
5594 r = guestfs_mkfs (g, fstype, device);
5599 char device[] = "/dev/sda1";
5600 char mountpoint[] = "/";
5603 r = guestfs_mount (g, device, mountpoint);
5607 /* TestOutput for set_e2uuid (0) */
5608 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5610 char device[] = "/dev/sda1";
5611 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
5614 r = guestfs_set_e2uuid (g, device, uuid);
5619 char device[] = "/dev/sda1";
5622 r = guestfs_get_e2uuid (g, device);
5625 if (strcmp (r, expected) != 0) {
5626 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
5634 static int test_set_e2uuid_1_skip (void)
5638 str = getenv ("TEST_ONLY");
5640 return strstr (str, "set_e2uuid") == NULL;
5641 str = getenv ("SKIP_TEST_SET_E2UUID_1");
5642 if (str && strcmp (str, "1") == 0) return 1;
5643 str = getenv ("SKIP_TEST_SET_E2UUID");
5644 if (str && strcmp (str, "1") == 0) return 1;
5648 static int test_set_e2uuid_1 (void)
5650 if (test_set_e2uuid_1_skip ()) {
5651 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
5655 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
5657 char device[] = "/dev/sda";
5660 r = guestfs_blockdev_setrw (g, device);
5667 r = guestfs_umount_all (g);
5674 r = guestfs_lvm_remove_all (g);
5679 char device[] = "/dev/sda";
5680 char lines_0[] = ",";
5687 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5692 char fstype[] = "ext2";
5693 char device[] = "/dev/sda1";
5696 r = guestfs_mkfs (g, fstype, device);
5701 char device[] = "/dev/sda1";
5702 char mountpoint[] = "/";
5705 r = guestfs_mount (g, device, mountpoint);
5709 /* TestOutput for set_e2uuid (1) */
5710 char expected[] = "";
5712 char device[] = "/dev/sda1";
5713 char uuid[] = "clear";
5716 r = guestfs_set_e2uuid (g, device, uuid);
5721 char device[] = "/dev/sda1";
5724 r = guestfs_get_e2uuid (g, device);
5727 if (strcmp (r, expected) != 0) {
5728 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
5736 static int test_set_e2uuid_2_skip (void)
5740 str = getenv ("TEST_ONLY");
5742 return strstr (str, "set_e2uuid") == NULL;
5743 str = getenv ("SKIP_TEST_SET_E2UUID_2");
5744 if (str && strcmp (str, "1") == 0) return 1;
5745 str = getenv ("SKIP_TEST_SET_E2UUID");
5746 if (str && strcmp (str, "1") == 0) return 1;
5750 static int test_set_e2uuid_2 (void)
5752 if (test_set_e2uuid_2_skip ()) {
5753 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
5757 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
5759 char device[] = "/dev/sda";
5762 r = guestfs_blockdev_setrw (g, device);
5769 r = guestfs_umount_all (g);
5776 r = guestfs_lvm_remove_all (g);
5781 char device[] = "/dev/sda";
5782 char lines_0[] = ",";
5789 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5794 char fstype[] = "ext2";
5795 char device[] = "/dev/sda1";
5798 r = guestfs_mkfs (g, fstype, device);
5803 char device[] = "/dev/sda1";
5804 char mountpoint[] = "/";
5807 r = guestfs_mount (g, device, mountpoint);
5811 /* TestRun for set_e2uuid (2) */
5813 char device[] = "/dev/sda1";
5814 char uuid[] = "random";
5817 r = guestfs_set_e2uuid (g, device, uuid);
5824 static int test_set_e2uuid_3_skip (void)
5828 str = getenv ("TEST_ONLY");
5830 return strstr (str, "set_e2uuid") == NULL;
5831 str = getenv ("SKIP_TEST_SET_E2UUID_3");
5832 if (str && strcmp (str, "1") == 0) return 1;
5833 str = getenv ("SKIP_TEST_SET_E2UUID");
5834 if (str && strcmp (str, "1") == 0) return 1;
5838 static int test_set_e2uuid_3 (void)
5840 if (test_set_e2uuid_3_skip ()) {
5841 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
5845 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
5847 char device[] = "/dev/sda";
5850 r = guestfs_blockdev_setrw (g, device);
5857 r = guestfs_umount_all (g);
5864 r = guestfs_lvm_remove_all (g);
5869 char device[] = "/dev/sda";
5870 char lines_0[] = ",";
5877 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5882 char fstype[] = "ext2";
5883 char device[] = "/dev/sda1";
5886 r = guestfs_mkfs (g, fstype, device);
5891 char device[] = "/dev/sda1";
5892 char mountpoint[] = "/";
5895 r = guestfs_mount (g, device, mountpoint);
5899 /* TestRun for set_e2uuid (3) */
5901 char device[] = "/dev/sda1";
5902 char uuid[] = "time";
5905 r = guestfs_set_e2uuid (g, device, uuid);
5912 static int test_set_e2label_0_skip (void)
5916 str = getenv ("TEST_ONLY");
5918 return strstr (str, "set_e2label") == NULL;
5919 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
5920 if (str && strcmp (str, "1") == 0) return 1;
5921 str = getenv ("SKIP_TEST_SET_E2LABEL");
5922 if (str && strcmp (str, "1") == 0) return 1;
5926 static int test_set_e2label_0 (void)
5928 if (test_set_e2label_0_skip ()) {
5929 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
5933 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
5935 char device[] = "/dev/sda";
5938 r = guestfs_blockdev_setrw (g, device);
5945 r = guestfs_umount_all (g);
5952 r = guestfs_lvm_remove_all (g);
5957 char device[] = "/dev/sda";
5958 char lines_0[] = ",";
5965 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5970 char fstype[] = "ext2";
5971 char device[] = "/dev/sda1";
5974 r = guestfs_mkfs (g, fstype, device);
5979 char device[] = "/dev/sda1";
5980 char mountpoint[] = "/";
5983 r = guestfs_mount (g, device, mountpoint);
5987 /* TestOutput for set_e2label (0) */
5988 char expected[] = "testlabel";
5990 char device[] = "/dev/sda1";
5991 char label[] = "testlabel";
5994 r = guestfs_set_e2label (g, device, label);
5999 char device[] = "/dev/sda1";
6002 r = guestfs_get_e2label (g, device);
6005 if (strcmp (r, expected) != 0) {
6006 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
6014 static int test_pvremove_0_skip (void)
6018 str = getenv ("TEST_ONLY");
6020 return strstr (str, "pvremove") == NULL;
6021 str = getenv ("SKIP_TEST_PVREMOVE_0");
6022 if (str && strcmp (str, "1") == 0) return 1;
6023 str = getenv ("SKIP_TEST_PVREMOVE");
6024 if (str && strcmp (str, "1") == 0) return 1;
6028 static int test_pvremove_0 (void)
6030 if (test_pvremove_0_skip ()) {
6031 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
6035 /* InitNone|InitEmpty for test_pvremove_0 */
6037 char device[] = "/dev/sda";
6040 r = guestfs_blockdev_setrw (g, device);
6047 r = guestfs_umount_all (g);
6054 r = guestfs_lvm_remove_all (g);
6058 /* TestOutputListOfDevices for pvremove (0) */
6060 char device[] = "/dev/sda";
6061 char lines_0[] = ",";
6068 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6073 char device[] = "/dev/sda1";
6076 r = guestfs_pvcreate (g, device);
6081 char volgroup[] = "VG";
6082 char physvols_0[] = "/dev/sda1";
6083 char *physvols[] = {
6089 r = guestfs_vgcreate (g, volgroup, physvols);
6094 char logvol[] = "LV1";
6095 char volgroup[] = "VG";
6098 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6103 char logvol[] = "LV2";
6104 char volgroup[] = "VG";
6107 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6112 char vgname[] = "VG";
6115 r = guestfs_vgremove (g, vgname);
6120 char device[] = "/dev/sda1";
6123 r = guestfs_pvremove (g, device);
6131 r = guestfs_lvs (g);
6135 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
6139 for (i = 0; r[i] != NULL; ++i)
6146 static int test_pvremove_1_skip (void)
6150 str = getenv ("TEST_ONLY");
6152 return strstr (str, "pvremove") == NULL;
6153 str = getenv ("SKIP_TEST_PVREMOVE_1");
6154 if (str && strcmp (str, "1") == 0) return 1;
6155 str = getenv ("SKIP_TEST_PVREMOVE");
6156 if (str && strcmp (str, "1") == 0) return 1;
6160 static int test_pvremove_1 (void)
6162 if (test_pvremove_1_skip ()) {
6163 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
6167 /* InitNone|InitEmpty for test_pvremove_1 */
6169 char device[] = "/dev/sda";
6172 r = guestfs_blockdev_setrw (g, device);
6179 r = guestfs_umount_all (g);
6186 r = guestfs_lvm_remove_all (g);
6190 /* TestOutputListOfDevices for pvremove (1) */
6192 char device[] = "/dev/sda";
6193 char lines_0[] = ",";
6200 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6205 char device[] = "/dev/sda1";
6208 r = guestfs_pvcreate (g, device);
6213 char volgroup[] = "VG";
6214 char physvols_0[] = "/dev/sda1";
6215 char *physvols[] = {
6221 r = guestfs_vgcreate (g, volgroup, physvols);
6226 char logvol[] = "LV1";
6227 char volgroup[] = "VG";
6230 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6235 char logvol[] = "LV2";
6236 char volgroup[] = "VG";
6239 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6244 char vgname[] = "VG";
6247 r = guestfs_vgremove (g, vgname);
6252 char device[] = "/dev/sda1";
6255 r = guestfs_pvremove (g, device);
6263 r = guestfs_vgs (g);
6267 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
6271 for (i = 0; r[i] != NULL; ++i)
6278 static int test_pvremove_2_skip (void)
6282 str = getenv ("TEST_ONLY");
6284 return strstr (str, "pvremove") == NULL;
6285 str = getenv ("SKIP_TEST_PVREMOVE_2");
6286 if (str && strcmp (str, "1") == 0) return 1;
6287 str = getenv ("SKIP_TEST_PVREMOVE");
6288 if (str && strcmp (str, "1") == 0) return 1;
6292 static int test_pvremove_2 (void)
6294 if (test_pvremove_2_skip ()) {
6295 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
6299 /* InitNone|InitEmpty for test_pvremove_2 */
6301 char device[] = "/dev/sda";
6304 r = guestfs_blockdev_setrw (g, device);
6311 r = guestfs_umount_all (g);
6318 r = guestfs_lvm_remove_all (g);
6322 /* TestOutputListOfDevices for pvremove (2) */
6324 char device[] = "/dev/sda";
6325 char lines_0[] = ",";
6332 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6337 char device[] = "/dev/sda1";
6340 r = guestfs_pvcreate (g, device);
6345 char volgroup[] = "VG";
6346 char physvols_0[] = "/dev/sda1";
6347 char *physvols[] = {
6353 r = guestfs_vgcreate (g, volgroup, physvols);
6358 char logvol[] = "LV1";
6359 char volgroup[] = "VG";
6362 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6367 char logvol[] = "LV2";
6368 char volgroup[] = "VG";
6371 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6376 char vgname[] = "VG";
6379 r = guestfs_vgremove (g, vgname);
6384 char device[] = "/dev/sda1";
6387 r = guestfs_pvremove (g, device);
6395 r = guestfs_pvs (g);
6399 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
6403 for (i = 0; r[i] != NULL; ++i)
6410 static int test_vgremove_0_skip (void)
6414 str = getenv ("TEST_ONLY");
6416 return strstr (str, "vgremove") == NULL;
6417 str = getenv ("SKIP_TEST_VGREMOVE_0");
6418 if (str && strcmp (str, "1") == 0) return 1;
6419 str = getenv ("SKIP_TEST_VGREMOVE");
6420 if (str && strcmp (str, "1") == 0) return 1;
6424 static int test_vgremove_0 (void)
6426 if (test_vgremove_0_skip ()) {
6427 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
6431 /* InitNone|InitEmpty for test_vgremove_0 */
6433 char device[] = "/dev/sda";
6436 r = guestfs_blockdev_setrw (g, device);
6443 r = guestfs_umount_all (g);
6450 r = guestfs_lvm_remove_all (g);
6454 /* TestOutputList for vgremove (0) */
6456 char device[] = "/dev/sda";
6457 char lines_0[] = ",";
6464 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6469 char device[] = "/dev/sda1";
6472 r = guestfs_pvcreate (g, device);
6477 char volgroup[] = "VG";
6478 char physvols_0[] = "/dev/sda1";
6479 char *physvols[] = {
6485 r = guestfs_vgcreate (g, volgroup, physvols);
6490 char logvol[] = "LV1";
6491 char volgroup[] = "VG";
6494 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6499 char logvol[] = "LV2";
6500 char volgroup[] = "VG";
6503 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6508 char vgname[] = "VG";
6511 r = guestfs_vgremove (g, vgname);
6519 r = guestfs_lvs (g);
6523 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
6527 for (i = 0; r[i] != NULL; ++i)
6534 static int test_vgremove_1_skip (void)
6538 str = getenv ("TEST_ONLY");
6540 return strstr (str, "vgremove") == NULL;
6541 str = getenv ("SKIP_TEST_VGREMOVE_1");
6542 if (str && strcmp (str, "1") == 0) return 1;
6543 str = getenv ("SKIP_TEST_VGREMOVE");
6544 if (str && strcmp (str, "1") == 0) return 1;
6548 static int test_vgremove_1 (void)
6550 if (test_vgremove_1_skip ()) {
6551 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
6555 /* InitNone|InitEmpty for test_vgremove_1 */
6557 char device[] = "/dev/sda";
6560 r = guestfs_blockdev_setrw (g, device);
6567 r = guestfs_umount_all (g);
6574 r = guestfs_lvm_remove_all (g);
6578 /* TestOutputList for vgremove (1) */
6580 char device[] = "/dev/sda";
6581 char lines_0[] = ",";
6588 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6593 char device[] = "/dev/sda1";
6596 r = guestfs_pvcreate (g, device);
6601 char volgroup[] = "VG";
6602 char physvols_0[] = "/dev/sda1";
6603 char *physvols[] = {
6609 r = guestfs_vgcreate (g, volgroup, physvols);
6614 char logvol[] = "LV1";
6615 char volgroup[] = "VG";
6618 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6623 char logvol[] = "LV2";
6624 char volgroup[] = "VG";
6627 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6632 char vgname[] = "VG";
6635 r = guestfs_vgremove (g, vgname);
6643 r = guestfs_vgs (g);
6647 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
6651 for (i = 0; r[i] != NULL; ++i)
6658 static int test_lvremove_0_skip (void)
6662 str = getenv ("TEST_ONLY");
6664 return strstr (str, "lvremove") == NULL;
6665 str = getenv ("SKIP_TEST_LVREMOVE_0");
6666 if (str && strcmp (str, "1") == 0) return 1;
6667 str = getenv ("SKIP_TEST_LVREMOVE");
6668 if (str && strcmp (str, "1") == 0) return 1;
6672 static int test_lvremove_0 (void)
6674 if (test_lvremove_0_skip ()) {
6675 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
6679 /* InitNone|InitEmpty for test_lvremove_0 */
6681 char device[] = "/dev/sda";
6684 r = guestfs_blockdev_setrw (g, device);
6691 r = guestfs_umount_all (g);
6698 r = guestfs_lvm_remove_all (g);
6702 /* TestOutputList for lvremove (0) */
6704 char device[] = "/dev/sda";
6705 char lines_0[] = ",";
6712 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6717 char device[] = "/dev/sda1";
6720 r = guestfs_pvcreate (g, device);
6725 char volgroup[] = "VG";
6726 char physvols_0[] = "/dev/sda1";
6727 char *physvols[] = {
6733 r = guestfs_vgcreate (g, volgroup, physvols);
6738 char logvol[] = "LV1";
6739 char volgroup[] = "VG";
6742 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6747 char logvol[] = "LV2";
6748 char volgroup[] = "VG";
6751 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6756 char device[] = "/dev/VG/LV1";
6759 r = guestfs_lvremove (g, device);
6767 r = guestfs_lvs (g);
6771 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
6776 char expected[] = "/dev/VG/LV2";
6777 if (strcmp (r[0], expected) != 0) {
6778 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
6783 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
6787 for (i = 0; r[i] != NULL; ++i)
6794 static int test_lvremove_1_skip (void)
6798 str = getenv ("TEST_ONLY");
6800 return strstr (str, "lvremove") == NULL;
6801 str = getenv ("SKIP_TEST_LVREMOVE_1");
6802 if (str && strcmp (str, "1") == 0) return 1;
6803 str = getenv ("SKIP_TEST_LVREMOVE");
6804 if (str && strcmp (str, "1") == 0) return 1;
6808 static int test_lvremove_1 (void)
6810 if (test_lvremove_1_skip ()) {
6811 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
6815 /* InitNone|InitEmpty for test_lvremove_1 */
6817 char device[] = "/dev/sda";
6820 r = guestfs_blockdev_setrw (g, device);
6827 r = guestfs_umount_all (g);
6834 r = guestfs_lvm_remove_all (g);
6838 /* TestOutputList for lvremove (1) */
6840 char device[] = "/dev/sda";
6841 char lines_0[] = ",";
6848 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6853 char device[] = "/dev/sda1";
6856 r = guestfs_pvcreate (g, device);
6861 char volgroup[] = "VG";
6862 char physvols_0[] = "/dev/sda1";
6863 char *physvols[] = {
6869 r = guestfs_vgcreate (g, volgroup, physvols);
6874 char logvol[] = "LV1";
6875 char volgroup[] = "VG";
6878 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6883 char logvol[] = "LV2";
6884 char volgroup[] = "VG";
6887 r = guestfs_lvcreate (g, logvol, volgroup, 50);
6892 char device[] = "/dev/VG";
6895 r = guestfs_lvremove (g, device);
6903 r = guestfs_lvs (g);
6907 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
6911 for (i = 0; r[i] != NULL; ++i)
6918 static int test_lvremove_2_skip (void)
6922 str = getenv ("TEST_ONLY");
6924 return strstr (str, "lvremove") == NULL;
6925 str = getenv ("SKIP_TEST_LVREMOVE_2");
6926 if (str && strcmp (str, "1") == 0) return 1;
6927 str = getenv ("SKIP_TEST_LVREMOVE");
6928 if (str && strcmp (str, "1") == 0) return 1;
6932 static int test_lvremove_2 (void)
6934 if (test_lvremove_2_skip ()) {
6935 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
6939 /* InitNone|InitEmpty for test_lvremove_2 */
6941 char device[] = "/dev/sda";
6944 r = guestfs_blockdev_setrw (g, device);
6951 r = guestfs_umount_all (g);
6958 r = guestfs_lvm_remove_all (g);
6962 /* TestOutputList for lvremove (2) */
6964 char device[] = "/dev/sda";
6965 char lines_0[] = ",";
6972 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6977 char device[] = "/dev/sda1";
6980 r = guestfs_pvcreate (g, device);
6985 char volgroup[] = "VG";
6986 char physvols_0[] = "/dev/sda1";
6987 char *physvols[] = {
6993 r = guestfs_vgcreate (g, volgroup, physvols);
6998 char logvol[] = "LV1";
6999 char volgroup[] = "VG";
7002 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7007 char logvol[] = "LV2";
7008 char volgroup[] = "VG";
7011 r = guestfs_lvcreate (g, logvol, volgroup, 50);
7016 char device[] = "/dev/VG";
7019 r = guestfs_lvremove (g, device);
7027 r = guestfs_vgs (g);
7031 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
7036 char expected[] = "VG";
7037 if (strcmp (r[0], expected) != 0) {
7038 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7043 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
7047 for (i = 0; r[i] != NULL; ++i)
7054 static int test_mount_ro_0_skip (void)
7058 str = getenv ("TEST_ONLY");
7060 return strstr (str, "mount_ro") == NULL;
7061 str = getenv ("SKIP_TEST_MOUNT_RO_0");
7062 if (str && strcmp (str, "1") == 0) return 1;
7063 str = getenv ("SKIP_TEST_MOUNT_RO");
7064 if (str && strcmp (str, "1") == 0) return 1;
7068 static int test_mount_ro_0 (void)
7070 if (test_mount_ro_0_skip ()) {
7071 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
7075 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
7077 char device[] = "/dev/sda";
7080 r = guestfs_blockdev_setrw (g, device);
7087 r = guestfs_umount_all (g);
7094 r = guestfs_lvm_remove_all (g);
7099 char device[] = "/dev/sda";
7100 char lines_0[] = ",";
7107 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7112 char fstype[] = "ext2";
7113 char device[] = "/dev/sda1";
7116 r = guestfs_mkfs (g, fstype, device);
7121 char device[] = "/dev/sda1";
7122 char mountpoint[] = "/";
7125 r = guestfs_mount (g, device, mountpoint);
7129 /* TestLastFail for mount_ro (0) */
7131 char pathordevice[] = "/";
7134 r = guestfs_umount (g, pathordevice);
7139 char device[] = "/dev/sda1";
7140 char mountpoint[] = "/";
7143 r = guestfs_mount_ro (g, device, mountpoint);
7148 char path[] = "/new";
7151 r = guestfs_touch (g, path);
7158 static int test_mount_ro_1_skip (void)
7162 str = getenv ("TEST_ONLY");
7164 return strstr (str, "mount_ro") == NULL;
7165 str = getenv ("SKIP_TEST_MOUNT_RO_1");
7166 if (str && strcmp (str, "1") == 0) return 1;
7167 str = getenv ("SKIP_TEST_MOUNT_RO");
7168 if (str && strcmp (str, "1") == 0) return 1;
7172 static int test_mount_ro_1 (void)
7174 if (test_mount_ro_1_skip ()) {
7175 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
7179 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
7181 char device[] = "/dev/sda";
7184 r = guestfs_blockdev_setrw (g, device);
7191 r = guestfs_umount_all (g);
7198 r = guestfs_lvm_remove_all (g);
7203 char device[] = "/dev/sda";
7204 char lines_0[] = ",";
7211 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7216 char fstype[] = "ext2";
7217 char device[] = "/dev/sda1";
7220 r = guestfs_mkfs (g, fstype, device);
7225 char device[] = "/dev/sda1";
7226 char mountpoint[] = "/";
7229 r = guestfs_mount (g, device, mountpoint);
7233 /* TestOutput for mount_ro (1) */
7234 char expected[] = "data";
7236 char path[] = "/new";
7237 char content[] = "data";
7240 r = guestfs_write_file (g, path, content, 0);
7245 char pathordevice[] = "/";
7248 r = guestfs_umount (g, pathordevice);
7253 char device[] = "/dev/sda1";
7254 char mountpoint[] = "/";
7257 r = guestfs_mount_ro (g, device, mountpoint);
7262 char path[] = "/new";
7265 r = guestfs_cat (g, path);
7268 if (strcmp (r, expected) != 0) {
7269 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
7277 static int test_tgz_in_0_skip (void)
7281 str = getenv ("TEST_ONLY");
7283 return strstr (str, "tgz_in") == NULL;
7284 str = getenv ("SKIP_TEST_TGZ_IN_0");
7285 if (str && strcmp (str, "1") == 0) return 1;
7286 str = getenv ("SKIP_TEST_TGZ_IN");
7287 if (str && strcmp (str, "1") == 0) return 1;
7291 static int test_tgz_in_0 (void)
7293 if (test_tgz_in_0_skip ()) {
7294 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
7298 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
7300 char device[] = "/dev/sda";
7303 r = guestfs_blockdev_setrw (g, device);
7310 r = guestfs_umount_all (g);
7317 r = guestfs_lvm_remove_all (g);
7322 char device[] = "/dev/sda";
7323 char lines_0[] = ",";
7330 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7335 char fstype[] = "ext2";
7336 char device[] = "/dev/sda1";
7339 r = guestfs_mkfs (g, fstype, device);
7344 char device[] = "/dev/sda1";
7345 char mountpoint[] = "/";
7348 r = guestfs_mount (g, device, mountpoint);
7352 /* TestOutput for tgz_in (0) */
7353 char expected[] = "hello\n";
7355 char directory[] = "/";
7358 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
7363 char path[] = "/hello";
7366 r = guestfs_cat (g, path);
7369 if (strcmp (r, expected) != 0) {
7370 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7378 static int test_tar_in_0_skip (void)
7382 str = getenv ("TEST_ONLY");
7384 return strstr (str, "tar_in") == NULL;
7385 str = getenv ("SKIP_TEST_TAR_IN_0");
7386 if (str && strcmp (str, "1") == 0) return 1;
7387 str = getenv ("SKIP_TEST_TAR_IN");
7388 if (str && strcmp (str, "1") == 0) return 1;
7392 static int test_tar_in_0 (void)
7394 if (test_tar_in_0_skip ()) {
7395 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
7399 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
7401 char device[] = "/dev/sda";
7404 r = guestfs_blockdev_setrw (g, device);
7411 r = guestfs_umount_all (g);
7418 r = guestfs_lvm_remove_all (g);
7423 char device[] = "/dev/sda";
7424 char lines_0[] = ",";
7431 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7436 char fstype[] = "ext2";
7437 char device[] = "/dev/sda1";
7440 r = guestfs_mkfs (g, fstype, device);
7445 char device[] = "/dev/sda1";
7446 char mountpoint[] = "/";
7449 r = guestfs_mount (g, device, mountpoint);
7453 /* TestOutput for tar_in (0) */
7454 char expected[] = "hello\n";
7456 char directory[] = "/";
7459 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
7464 char path[] = "/hello";
7467 r = guestfs_cat (g, path);
7470 if (strcmp (r, expected) != 0) {
7471 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
7479 static int test_checksum_0_skip (void)
7483 str = getenv ("TEST_ONLY");
7485 return strstr (str, "checksum") == NULL;
7486 str = getenv ("SKIP_TEST_CHECKSUM_0");
7487 if (str && strcmp (str, "1") == 0) return 1;
7488 str = getenv ("SKIP_TEST_CHECKSUM");
7489 if (str && strcmp (str, "1") == 0) return 1;
7493 static int test_checksum_0 (void)
7495 if (test_checksum_0_skip ()) {
7496 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
7500 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
7502 char device[] = "/dev/sda";
7505 r = guestfs_blockdev_setrw (g, device);
7512 r = guestfs_umount_all (g);
7519 r = guestfs_lvm_remove_all (g);
7524 char device[] = "/dev/sda";
7525 char lines_0[] = ",";
7532 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7537 char fstype[] = "ext2";
7538 char device[] = "/dev/sda1";
7541 r = guestfs_mkfs (g, fstype, device);
7546 char device[] = "/dev/sda1";
7547 char mountpoint[] = "/";
7550 r = guestfs_mount (g, device, mountpoint);
7554 /* TestOutput for checksum (0) */
7555 char expected[] = "935282863";
7557 char path[] = "/new";
7558 char content[] = "test\n";
7561 r = guestfs_write_file (g, path, content, 0);
7566 char csumtype[] = "crc";
7567 char path[] = "/new";
7570 r = guestfs_checksum (g, csumtype, path);
7573 if (strcmp (r, expected) != 0) {
7574 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
7582 static int test_checksum_1_skip (void)
7586 str = getenv ("TEST_ONLY");
7588 return strstr (str, "checksum") == NULL;
7589 str = getenv ("SKIP_TEST_CHECKSUM_1");
7590 if (str && strcmp (str, "1") == 0) return 1;
7591 str = getenv ("SKIP_TEST_CHECKSUM");
7592 if (str && strcmp (str, "1") == 0) return 1;
7596 static int test_checksum_1 (void)
7598 if (test_checksum_1_skip ()) {
7599 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
7603 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
7605 char device[] = "/dev/sda";
7608 r = guestfs_blockdev_setrw (g, device);
7615 r = guestfs_umount_all (g);
7622 r = guestfs_lvm_remove_all (g);
7627 char device[] = "/dev/sda";
7628 char lines_0[] = ",";
7635 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7640 char fstype[] = "ext2";
7641 char device[] = "/dev/sda1";
7644 r = guestfs_mkfs (g, fstype, device);
7649 char device[] = "/dev/sda1";
7650 char mountpoint[] = "/";
7653 r = guestfs_mount (g, device, mountpoint);
7657 /* TestLastFail for checksum (1) */
7659 char csumtype[] = "crc";
7660 char path[] = "/new";
7663 r = guestfs_checksum (g, csumtype, path);
7671 static int test_checksum_2_skip (void)
7675 str = getenv ("TEST_ONLY");
7677 return strstr (str, "checksum") == NULL;
7678 str = getenv ("SKIP_TEST_CHECKSUM_2");
7679 if (str && strcmp (str, "1") == 0) return 1;
7680 str = getenv ("SKIP_TEST_CHECKSUM");
7681 if (str && strcmp (str, "1") == 0) return 1;
7685 static int test_checksum_2 (void)
7687 if (test_checksum_2_skip ()) {
7688 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
7692 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
7694 char device[] = "/dev/sda";
7697 r = guestfs_blockdev_setrw (g, device);
7704 r = guestfs_umount_all (g);
7711 r = guestfs_lvm_remove_all (g);
7716 char device[] = "/dev/sda";
7717 char lines_0[] = ",";
7724 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7729 char fstype[] = "ext2";
7730 char device[] = "/dev/sda1";
7733 r = guestfs_mkfs (g, fstype, device);
7738 char device[] = "/dev/sda1";
7739 char mountpoint[] = "/";
7742 r = guestfs_mount (g, device, mountpoint);
7746 /* TestOutput for checksum (2) */
7747 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
7749 char path[] = "/new";
7750 char content[] = "test\n";
7753 r = guestfs_write_file (g, path, content, 0);
7758 char csumtype[] = "md5";
7759 char path[] = "/new";
7762 r = guestfs_checksum (g, csumtype, path);
7765 if (strcmp (r, expected) != 0) {
7766 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
7774 static int test_checksum_3_skip (void)
7778 str = getenv ("TEST_ONLY");
7780 return strstr (str, "checksum") == NULL;
7781 str = getenv ("SKIP_TEST_CHECKSUM_3");
7782 if (str && strcmp (str, "1") == 0) return 1;
7783 str = getenv ("SKIP_TEST_CHECKSUM");
7784 if (str && strcmp (str, "1") == 0) return 1;
7788 static int test_checksum_3 (void)
7790 if (test_checksum_3_skip ()) {
7791 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
7795 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
7797 char device[] = "/dev/sda";
7800 r = guestfs_blockdev_setrw (g, device);
7807 r = guestfs_umount_all (g);
7814 r = guestfs_lvm_remove_all (g);
7819 char device[] = "/dev/sda";
7820 char lines_0[] = ",";
7827 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7832 char fstype[] = "ext2";
7833 char device[] = "/dev/sda1";
7836 r = guestfs_mkfs (g, fstype, device);
7841 char device[] = "/dev/sda1";
7842 char mountpoint[] = "/";
7845 r = guestfs_mount (g, device, mountpoint);
7849 /* TestOutput for checksum (3) */
7850 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
7852 char path[] = "/new";
7853 char content[] = "test\n";
7856 r = guestfs_write_file (g, path, content, 0);
7861 char csumtype[] = "sha1";
7862 char path[] = "/new";
7865 r = guestfs_checksum (g, csumtype, path);
7868 if (strcmp (r, expected) != 0) {
7869 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
7877 static int test_checksum_4_skip (void)
7881 str = getenv ("TEST_ONLY");
7883 return strstr (str, "checksum") == NULL;
7884 str = getenv ("SKIP_TEST_CHECKSUM_4");
7885 if (str && strcmp (str, "1") == 0) return 1;
7886 str = getenv ("SKIP_TEST_CHECKSUM");
7887 if (str && strcmp (str, "1") == 0) return 1;
7891 static int test_checksum_4 (void)
7893 if (test_checksum_4_skip ()) {
7894 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
7898 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
7900 char device[] = "/dev/sda";
7903 r = guestfs_blockdev_setrw (g, device);
7910 r = guestfs_umount_all (g);
7917 r = guestfs_lvm_remove_all (g);
7922 char device[] = "/dev/sda";
7923 char lines_0[] = ",";
7930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7935 char fstype[] = "ext2";
7936 char device[] = "/dev/sda1";
7939 r = guestfs_mkfs (g, fstype, device);
7944 char device[] = "/dev/sda1";
7945 char mountpoint[] = "/";
7948 r = guestfs_mount (g, device, mountpoint);
7952 /* TestOutput for checksum (4) */
7953 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
7955 char path[] = "/new";
7956 char content[] = "test\n";
7959 r = guestfs_write_file (g, path, content, 0);
7964 char csumtype[] = "sha224";
7965 char path[] = "/new";
7968 r = guestfs_checksum (g, csumtype, path);
7971 if (strcmp (r, expected) != 0) {
7972 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
7980 static int test_checksum_5_skip (void)
7984 str = getenv ("TEST_ONLY");
7986 return strstr (str, "checksum") == NULL;
7987 str = getenv ("SKIP_TEST_CHECKSUM_5");
7988 if (str && strcmp (str, "1") == 0) return 1;
7989 str = getenv ("SKIP_TEST_CHECKSUM");
7990 if (str && strcmp (str, "1") == 0) return 1;
7994 static int test_checksum_5 (void)
7996 if (test_checksum_5_skip ()) {
7997 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
8001 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
8003 char device[] = "/dev/sda";
8006 r = guestfs_blockdev_setrw (g, device);
8013 r = guestfs_umount_all (g);
8020 r = guestfs_lvm_remove_all (g);
8025 char device[] = "/dev/sda";
8026 char lines_0[] = ",";
8033 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8038 char fstype[] = "ext2";
8039 char device[] = "/dev/sda1";
8042 r = guestfs_mkfs (g, fstype, device);
8047 char device[] = "/dev/sda1";
8048 char mountpoint[] = "/";
8051 r = guestfs_mount (g, device, mountpoint);
8055 /* TestOutput for checksum (5) */
8056 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
8058 char path[] = "/new";
8059 char content[] = "test\n";
8062 r = guestfs_write_file (g, path, content, 0);
8067 char csumtype[] = "sha256";
8068 char path[] = "/new";
8071 r = guestfs_checksum (g, csumtype, path);
8074 if (strcmp (r, expected) != 0) {
8075 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
8083 static int test_checksum_6_skip (void)
8087 str = getenv ("TEST_ONLY");
8089 return strstr (str, "checksum") == NULL;
8090 str = getenv ("SKIP_TEST_CHECKSUM_6");
8091 if (str && strcmp (str, "1") == 0) return 1;
8092 str = getenv ("SKIP_TEST_CHECKSUM");
8093 if (str && strcmp (str, "1") == 0) return 1;
8097 static int test_checksum_6 (void)
8099 if (test_checksum_6_skip ()) {
8100 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
8104 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
8106 char device[] = "/dev/sda";
8109 r = guestfs_blockdev_setrw (g, device);
8116 r = guestfs_umount_all (g);
8123 r = guestfs_lvm_remove_all (g);
8128 char device[] = "/dev/sda";
8129 char lines_0[] = ",";
8136 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8141 char fstype[] = "ext2";
8142 char device[] = "/dev/sda1";
8145 r = guestfs_mkfs (g, fstype, device);
8150 char device[] = "/dev/sda1";
8151 char mountpoint[] = "/";
8154 r = guestfs_mount (g, device, mountpoint);
8158 /* TestOutput for checksum (6) */
8159 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
8161 char path[] = "/new";
8162 char content[] = "test\n";
8165 r = guestfs_write_file (g, path, content, 0);
8170 char csumtype[] = "sha384";
8171 char path[] = "/new";
8174 r = guestfs_checksum (g, csumtype, path);
8177 if (strcmp (r, expected) != 0) {
8178 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
8186 static int test_checksum_7_skip (void)
8190 str = getenv ("TEST_ONLY");
8192 return strstr (str, "checksum") == NULL;
8193 str = getenv ("SKIP_TEST_CHECKSUM_7");
8194 if (str && strcmp (str, "1") == 0) return 1;
8195 str = getenv ("SKIP_TEST_CHECKSUM");
8196 if (str && strcmp (str, "1") == 0) return 1;
8200 static int test_checksum_7 (void)
8202 if (test_checksum_7_skip ()) {
8203 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
8207 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
8209 char device[] = "/dev/sda";
8212 r = guestfs_blockdev_setrw (g, device);
8219 r = guestfs_umount_all (g);
8226 r = guestfs_lvm_remove_all (g);
8231 char device[] = "/dev/sda";
8232 char lines_0[] = ",";
8239 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8244 char fstype[] = "ext2";
8245 char device[] = "/dev/sda1";
8248 r = guestfs_mkfs (g, fstype, device);
8253 char device[] = "/dev/sda1";
8254 char mountpoint[] = "/";
8257 r = guestfs_mount (g, device, mountpoint);
8261 /* TestOutput for checksum (7) */
8262 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
8264 char path[] = "/new";
8265 char content[] = "test\n";
8268 r = guestfs_write_file (g, path, content, 0);
8273 char csumtype[] = "sha512";
8274 char path[] = "/new";
8277 r = guestfs_checksum (g, csumtype, path);
8280 if (strcmp (r, expected) != 0) {
8281 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
8289 static int test_checksum_8_skip (void)
8293 str = getenv ("TEST_ONLY");
8295 return strstr (str, "checksum") == NULL;
8296 str = getenv ("SKIP_TEST_CHECKSUM_8");
8297 if (str && strcmp (str, "1") == 0) return 1;
8298 str = getenv ("SKIP_TEST_CHECKSUM");
8299 if (str && strcmp (str, "1") == 0) return 1;
8303 static int test_checksum_8 (void)
8305 if (test_checksum_8_skip ()) {
8306 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
8310 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
8312 char device[] = "/dev/sda";
8315 r = guestfs_blockdev_setrw (g, device);
8322 r = guestfs_umount_all (g);
8329 r = guestfs_lvm_remove_all (g);
8334 char device[] = "/dev/sda";
8335 char lines_0[] = ",";
8342 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8347 char fstype[] = "ext2";
8348 char device[] = "/dev/sda1";
8351 r = guestfs_mkfs (g, fstype, device);
8356 char device[] = "/dev/sda1";
8357 char mountpoint[] = "/";
8360 r = guestfs_mount (g, device, mountpoint);
8364 /* TestOutput for checksum (8) */
8365 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
8367 char options[] = "ro";
8368 char vfstype[] = "squashfs";
8369 char device[] = "/dev/sdd";
8370 char mountpoint[] = "/";
8373 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
8378 char csumtype[] = "md5";
8379 char path[] = "/known-3";
8382 r = guestfs_checksum (g, csumtype, path);
8385 if (strcmp (r, expected) != 0) {
8386 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
8394 static int test_download_0_skip (void)
8398 str = getenv ("TEST_ONLY");
8400 return strstr (str, "download") == NULL;
8401 str = getenv ("SKIP_TEST_DOWNLOAD_0");
8402 if (str && strcmp (str, "1") == 0) return 1;
8403 str = getenv ("SKIP_TEST_DOWNLOAD");
8404 if (str && strcmp (str, "1") == 0) return 1;
8408 static int test_download_0 (void)
8410 if (test_download_0_skip ()) {
8411 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
8415 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
8417 char device[] = "/dev/sda";
8420 r = guestfs_blockdev_setrw (g, device);
8427 r = guestfs_umount_all (g);
8434 r = guestfs_lvm_remove_all (g);
8439 char device[] = "/dev/sda";
8440 char lines_0[] = ",";
8447 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8452 char fstype[] = "ext2";
8453 char device[] = "/dev/sda1";
8456 r = guestfs_mkfs (g, fstype, device);
8461 char device[] = "/dev/sda1";
8462 char mountpoint[] = "/";
8465 r = guestfs_mount (g, device, mountpoint);
8469 /* TestOutput for download (0) */
8470 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8472 char remotefilename[] = "/COPYING.LIB";
8475 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8480 char remotefilename[] = "/COPYING.LIB";
8483 r = guestfs_download (g, remotefilename, "testdownload.tmp");
8488 char remotefilename[] = "/upload";
8491 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
8496 char csumtype[] = "md5";
8497 char path[] = "/upload";
8500 r = guestfs_checksum (g, csumtype, path);
8503 if (strcmp (r, expected) != 0) {
8504 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
8512 static int test_upload_0_skip (void)
8516 str = getenv ("TEST_ONLY");
8518 return strstr (str, "upload") == NULL;
8519 str = getenv ("SKIP_TEST_UPLOAD_0");
8520 if (str && strcmp (str, "1") == 0) return 1;
8521 str = getenv ("SKIP_TEST_UPLOAD");
8522 if (str && strcmp (str, "1") == 0) return 1;
8526 static int test_upload_0 (void)
8528 if (test_upload_0_skip ()) {
8529 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
8533 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
8535 char device[] = "/dev/sda";
8538 r = guestfs_blockdev_setrw (g, device);
8545 r = guestfs_umount_all (g);
8552 r = guestfs_lvm_remove_all (g);
8557 char device[] = "/dev/sda";
8558 char lines_0[] = ",";
8565 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8570 char fstype[] = "ext2";
8571 char device[] = "/dev/sda1";
8574 r = guestfs_mkfs (g, fstype, device);
8579 char device[] = "/dev/sda1";
8580 char mountpoint[] = "/";
8583 r = guestfs_mount (g, device, mountpoint);
8587 /* TestOutput for upload (0) */
8588 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
8590 char remotefilename[] = "/COPYING.LIB";
8593 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
8598 char csumtype[] = "md5";
8599 char path[] = "/COPYING.LIB";
8602 r = guestfs_checksum (g, csumtype, path);
8605 if (strcmp (r, expected) != 0) {
8606 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
8614 static int test_blockdev_rereadpt_0_skip (void)
8618 str = getenv ("TEST_ONLY");
8620 return strstr (str, "blockdev_rereadpt") == NULL;
8621 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
8622 if (str && strcmp (str, "1") == 0) return 1;
8623 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
8624 if (str && strcmp (str, "1") == 0) return 1;
8628 static int test_blockdev_rereadpt_0 (void)
8630 if (test_blockdev_rereadpt_0_skip ()) {
8631 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
8635 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
8637 char device[] = "/dev/sda";
8640 r = guestfs_blockdev_setrw (g, device);
8647 r = guestfs_umount_all (g);
8654 r = guestfs_lvm_remove_all (g);
8658 /* TestRun for blockdev_rereadpt (0) */
8660 char device[] = "/dev/sda";
8663 r = guestfs_blockdev_rereadpt (g, device);
8670 static int test_blockdev_flushbufs_0_skip (void)
8674 str = getenv ("TEST_ONLY");
8676 return strstr (str, "blockdev_flushbufs") == NULL;
8677 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
8678 if (str && strcmp (str, "1") == 0) return 1;
8679 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
8680 if (str && strcmp (str, "1") == 0) return 1;
8684 static int test_blockdev_flushbufs_0 (void)
8686 if (test_blockdev_flushbufs_0_skip ()) {
8687 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
8691 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
8693 char device[] = "/dev/sda";
8696 r = guestfs_blockdev_setrw (g, device);
8703 r = guestfs_umount_all (g);
8710 r = guestfs_lvm_remove_all (g);
8714 /* TestRun for blockdev_flushbufs (0) */
8716 char device[] = "/dev/sda";
8719 r = guestfs_blockdev_flushbufs (g, device);
8726 static int test_blockdev_getsize64_0_skip (void)
8730 str = getenv ("TEST_ONLY");
8732 return strstr (str, "blockdev_getsize64") == NULL;
8733 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
8734 if (str && strcmp (str, "1") == 0) return 1;
8735 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
8736 if (str && strcmp (str, "1") == 0) return 1;
8740 static int test_blockdev_getsize64_0 (void)
8742 if (test_blockdev_getsize64_0_skip ()) {
8743 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
8747 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
8749 char device[] = "/dev/sda";
8752 r = guestfs_blockdev_setrw (g, device);
8759 r = guestfs_umount_all (g);
8766 r = guestfs_lvm_remove_all (g);
8770 /* TestOutputInt for blockdev_getsize64 (0) */
8772 char device[] = "/dev/sda";
8775 r = guestfs_blockdev_getsize64 (g, device);
8778 if (r != 524288000) {
8779 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
8786 static int test_blockdev_getsz_0_skip (void)
8790 str = getenv ("TEST_ONLY");
8792 return strstr (str, "blockdev_getsz") == NULL;
8793 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
8794 if (str && strcmp (str, "1") == 0) return 1;
8795 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
8796 if (str && strcmp (str, "1") == 0) return 1;
8800 static int test_blockdev_getsz_0 (void)
8802 if (test_blockdev_getsz_0_skip ()) {
8803 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
8807 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
8809 char device[] = "/dev/sda";
8812 r = guestfs_blockdev_setrw (g, device);
8819 r = guestfs_umount_all (g);
8826 r = guestfs_lvm_remove_all (g);
8830 /* TestOutputInt for blockdev_getsz (0) */
8832 char device[] = "/dev/sda";
8835 r = guestfs_blockdev_getsz (g, device);
8839 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
8846 static int test_blockdev_getbsz_0_skip (void)
8850 str = getenv ("TEST_ONLY");
8852 return strstr (str, "blockdev_getbsz") == NULL;
8853 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
8854 if (str && strcmp (str, "1") == 0) return 1;
8855 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
8856 if (str && strcmp (str, "1") == 0) return 1;
8860 static int test_blockdev_getbsz_0 (void)
8862 if (test_blockdev_getbsz_0_skip ()) {
8863 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
8867 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
8869 char device[] = "/dev/sda";
8872 r = guestfs_blockdev_setrw (g, device);
8879 r = guestfs_umount_all (g);
8886 r = guestfs_lvm_remove_all (g);
8890 /* TestOutputInt for blockdev_getbsz (0) */
8892 char device[] = "/dev/sda";
8895 r = guestfs_blockdev_getbsz (g, device);
8899 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
8906 static int test_blockdev_getss_0_skip (void)
8910 str = getenv ("TEST_ONLY");
8912 return strstr (str, "blockdev_getss") == NULL;
8913 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
8914 if (str && strcmp (str, "1") == 0) return 1;
8915 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
8916 if (str && strcmp (str, "1") == 0) return 1;
8920 static int test_blockdev_getss_0 (void)
8922 if (test_blockdev_getss_0_skip ()) {
8923 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
8927 /* InitNone|InitEmpty for test_blockdev_getss_0 */
8929 char device[] = "/dev/sda";
8932 r = guestfs_blockdev_setrw (g, device);
8939 r = guestfs_umount_all (g);
8946 r = guestfs_lvm_remove_all (g);
8950 /* TestOutputInt for blockdev_getss (0) */
8952 char device[] = "/dev/sda";
8955 r = guestfs_blockdev_getss (g, device);
8959 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
8966 static int test_blockdev_getro_0_skip (void)
8970 str = getenv ("TEST_ONLY");
8972 return strstr (str, "blockdev_getro") == NULL;
8973 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
8974 if (str && strcmp (str, "1") == 0) return 1;
8975 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
8976 if (str && strcmp (str, "1") == 0) return 1;
8980 static int test_blockdev_getro_0 (void)
8982 if (test_blockdev_getro_0_skip ()) {
8983 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
8987 /* InitNone|InitEmpty for test_blockdev_getro_0 */
8989 char device[] = "/dev/sda";
8992 r = guestfs_blockdev_setrw (g, device);
8999 r = guestfs_umount_all (g);
9006 r = guestfs_lvm_remove_all (g);
9010 /* TestOutputTrue for blockdev_getro (0) */
9012 char device[] = "/dev/sda";
9015 r = guestfs_blockdev_setro (g, device);
9020 char device[] = "/dev/sda";
9023 r = guestfs_blockdev_getro (g, device);
9027 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
9034 static int test_blockdev_setrw_0_skip (void)
9038 str = getenv ("TEST_ONLY");
9040 return strstr (str, "blockdev_setrw") == NULL;
9041 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
9042 if (str && strcmp (str, "1") == 0) return 1;
9043 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
9044 if (str && strcmp (str, "1") == 0) return 1;
9048 static int test_blockdev_setrw_0 (void)
9050 if (test_blockdev_setrw_0_skip ()) {
9051 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
9055 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
9057 char device[] = "/dev/sda";
9060 r = guestfs_blockdev_setrw (g, device);
9067 r = guestfs_umount_all (g);
9074 r = guestfs_lvm_remove_all (g);
9078 /* TestOutputFalse for blockdev_setrw (0) */
9080 char device[] = "/dev/sda";
9083 r = guestfs_blockdev_setrw (g, device);
9088 char device[] = "/dev/sda";
9091 r = guestfs_blockdev_getro (g, device);
9095 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
9102 static int test_blockdev_setro_0_skip (void)
9106 str = getenv ("TEST_ONLY");
9108 return strstr (str, "blockdev_setro") == NULL;
9109 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
9110 if (str && strcmp (str, "1") == 0) return 1;
9111 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
9112 if (str && strcmp (str, "1") == 0) return 1;
9116 static int test_blockdev_setro_0 (void)
9118 if (test_blockdev_setro_0_skip ()) {
9119 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
9123 /* InitNone|InitEmpty for test_blockdev_setro_0 */
9125 char device[] = "/dev/sda";
9128 r = guestfs_blockdev_setrw (g, device);
9135 r = guestfs_umount_all (g);
9142 r = guestfs_lvm_remove_all (g);
9146 /* TestOutputTrue for blockdev_setro (0) */
9148 char device[] = "/dev/sda";
9151 r = guestfs_blockdev_setro (g, device);
9156 char device[] = "/dev/sda";
9159 r = guestfs_blockdev_getro (g, device);
9163 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
9170 static int test_statvfs_0_skip (void)
9174 str = getenv ("TEST_ONLY");
9176 return strstr (str, "statvfs") == NULL;
9177 str = getenv ("SKIP_TEST_STATVFS_0");
9178 if (str && strcmp (str, "1") == 0) return 1;
9179 str = getenv ("SKIP_TEST_STATVFS");
9180 if (str && strcmp (str, "1") == 0) return 1;
9184 static int test_statvfs_0 (void)
9186 if (test_statvfs_0_skip ()) {
9187 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
9191 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
9193 char device[] = "/dev/sda";
9196 r = guestfs_blockdev_setrw (g, device);
9203 r = guestfs_umount_all (g);
9210 r = guestfs_lvm_remove_all (g);
9215 char device[] = "/dev/sda";
9216 char lines_0[] = ",";
9223 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9228 char fstype[] = "ext2";
9229 char device[] = "/dev/sda1";
9232 r = guestfs_mkfs (g, fstype, device);
9237 char device[] = "/dev/sda1";
9238 char mountpoint[] = "/";
9241 r = guestfs_mount (g, device, mountpoint);
9245 /* TestOutputStruct for statvfs (0) */
9248 struct guestfs_statvfs *r;
9250 r = guestfs_statvfs (g, path);
9253 if (r->bfree != 487702) {
9254 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
9258 if (r->blocks != 490020) {
9259 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
9263 if (r->bsize != 1024) {
9264 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
9273 static int test_lstat_0_skip (void)
9277 str = getenv ("TEST_ONLY");
9279 return strstr (str, "lstat") == NULL;
9280 str = getenv ("SKIP_TEST_LSTAT_0");
9281 if (str && strcmp (str, "1") == 0) return 1;
9282 str = getenv ("SKIP_TEST_LSTAT");
9283 if (str && strcmp (str, "1") == 0) return 1;
9287 static int test_lstat_0 (void)
9289 if (test_lstat_0_skip ()) {
9290 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
9294 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
9296 char device[] = "/dev/sda";
9299 r = guestfs_blockdev_setrw (g, device);
9306 r = guestfs_umount_all (g);
9313 r = guestfs_lvm_remove_all (g);
9318 char device[] = "/dev/sda";
9319 char lines_0[] = ",";
9326 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9331 char fstype[] = "ext2";
9332 char device[] = "/dev/sda1";
9335 r = guestfs_mkfs (g, fstype, device);
9340 char device[] = "/dev/sda1";
9341 char mountpoint[] = "/";
9344 r = guestfs_mount (g, device, mountpoint);
9348 /* TestOutputStruct for lstat (0) */
9350 char path[] = "/new";
9353 r = guestfs_touch (g, path);
9358 char path[] = "/new";
9359 struct guestfs_stat *r;
9361 r = guestfs_lstat (g, path);
9365 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
9374 static int test_stat_0_skip (void)
9378 str = getenv ("TEST_ONLY");
9380 return strstr (str, "stat") == NULL;
9381 str = getenv ("SKIP_TEST_STAT_0");
9382 if (str && strcmp (str, "1") == 0) return 1;
9383 str = getenv ("SKIP_TEST_STAT");
9384 if (str && strcmp (str, "1") == 0) return 1;
9388 static int test_stat_0 (void)
9390 if (test_stat_0_skip ()) {
9391 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
9395 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
9397 char device[] = "/dev/sda";
9400 r = guestfs_blockdev_setrw (g, device);
9407 r = guestfs_umount_all (g);
9414 r = guestfs_lvm_remove_all (g);
9419 char device[] = "/dev/sda";
9420 char lines_0[] = ",";
9427 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9432 char fstype[] = "ext2";
9433 char device[] = "/dev/sda1";
9436 r = guestfs_mkfs (g, fstype, device);
9441 char device[] = "/dev/sda1";
9442 char mountpoint[] = "/";
9445 r = guestfs_mount (g, device, mountpoint);
9449 /* TestOutputStruct for stat (0) */
9451 char path[] = "/new";
9454 r = guestfs_touch (g, path);
9459 char path[] = "/new";
9460 struct guestfs_stat *r;
9462 r = guestfs_stat (g, path);
9466 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
9475 static int test_command_lines_0_skip (void)
9479 str = getenv ("TEST_ONLY");
9481 return strstr (str, "command_lines") == NULL;
9482 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
9483 if (str && strcmp (str, "1") == 0) return 1;
9484 str = getenv ("SKIP_TEST_COMMAND_LINES");
9485 if (str && strcmp (str, "1") == 0) return 1;
9489 static int test_command_lines_0 (void)
9491 if (test_command_lines_0_skip ()) {
9492 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
9496 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
9498 char device[] = "/dev/sda";
9501 r = guestfs_blockdev_setrw (g, device);
9508 r = guestfs_umount_all (g);
9515 r = guestfs_lvm_remove_all (g);
9520 char device[] = "/dev/sda";
9521 char lines_0[] = ",";
9528 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9533 char fstype[] = "ext2";
9534 char device[] = "/dev/sda1";
9537 r = guestfs_mkfs (g, fstype, device);
9542 char device[] = "/dev/sda1";
9543 char mountpoint[] = "/";
9546 r = guestfs_mount (g, device, mountpoint);
9550 /* TestOutputList for command_lines (0) */
9552 char remotefilename[] = "/test-command";
9555 r = guestfs_upload (g, "test-command", remotefilename);
9560 char path[] = "/test-command";
9563 r = guestfs_chmod (g, 493, path);
9568 char arguments_0[] = "/test-command";
9569 char arguments_1[] = "1";
9570 char *arguments[] = {
9578 r = guestfs_command_lines (g, arguments);
9582 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
9587 char expected[] = "Result1";
9588 if (strcmp (r[0], expected) != 0) {
9589 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9594 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
9598 for (i = 0; r[i] != NULL; ++i)
9605 static int test_command_lines_1_skip (void)
9609 str = getenv ("TEST_ONLY");
9611 return strstr (str, "command_lines") == NULL;
9612 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
9613 if (str && strcmp (str, "1") == 0) return 1;
9614 str = getenv ("SKIP_TEST_COMMAND_LINES");
9615 if (str && strcmp (str, "1") == 0) return 1;
9619 static int test_command_lines_1 (void)
9621 if (test_command_lines_1_skip ()) {
9622 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
9626 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
9628 char device[] = "/dev/sda";
9631 r = guestfs_blockdev_setrw (g, device);
9638 r = guestfs_umount_all (g);
9645 r = guestfs_lvm_remove_all (g);
9650 char device[] = "/dev/sda";
9651 char lines_0[] = ",";
9658 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9663 char fstype[] = "ext2";
9664 char device[] = "/dev/sda1";
9667 r = guestfs_mkfs (g, fstype, device);
9672 char device[] = "/dev/sda1";
9673 char mountpoint[] = "/";
9676 r = guestfs_mount (g, device, mountpoint);
9680 /* TestOutputList for command_lines (1) */
9682 char remotefilename[] = "/test-command";
9685 r = guestfs_upload (g, "test-command", remotefilename);
9690 char path[] = "/test-command";
9693 r = guestfs_chmod (g, 493, path);
9698 char arguments_0[] = "/test-command";
9699 char arguments_1[] = "2";
9700 char *arguments[] = {
9708 r = guestfs_command_lines (g, arguments);
9712 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
9717 char expected[] = "Result2";
9718 if (strcmp (r[0], expected) != 0) {
9719 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9724 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
9728 for (i = 0; r[i] != NULL; ++i)
9735 static int test_command_lines_2_skip (void)
9739 str = getenv ("TEST_ONLY");
9741 return strstr (str, "command_lines") == NULL;
9742 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
9743 if (str && strcmp (str, "1") == 0) return 1;
9744 str = getenv ("SKIP_TEST_COMMAND_LINES");
9745 if (str && strcmp (str, "1") == 0) return 1;
9749 static int test_command_lines_2 (void)
9751 if (test_command_lines_2_skip ()) {
9752 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
9756 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
9758 char device[] = "/dev/sda";
9761 r = guestfs_blockdev_setrw (g, device);
9768 r = guestfs_umount_all (g);
9775 r = guestfs_lvm_remove_all (g);
9780 char device[] = "/dev/sda";
9781 char lines_0[] = ",";
9788 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9793 char fstype[] = "ext2";
9794 char device[] = "/dev/sda1";
9797 r = guestfs_mkfs (g, fstype, device);
9802 char device[] = "/dev/sda1";
9803 char mountpoint[] = "/";
9806 r = guestfs_mount (g, device, mountpoint);
9810 /* TestOutputList for command_lines (2) */
9812 char remotefilename[] = "/test-command";
9815 r = guestfs_upload (g, "test-command", remotefilename);
9820 char path[] = "/test-command";
9823 r = guestfs_chmod (g, 493, path);
9828 char arguments_0[] = "/test-command";
9829 char arguments_1[] = "3";
9830 char *arguments[] = {
9838 r = guestfs_command_lines (g, arguments);
9842 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9847 char expected[] = "";
9848 if (strcmp (r[0], expected) != 0) {
9849 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9854 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
9859 char expected[] = "Result3";
9860 if (strcmp (r[1], expected) != 0) {
9861 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9866 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
9870 for (i = 0; r[i] != NULL; ++i)
9877 static int test_command_lines_3_skip (void)
9881 str = getenv ("TEST_ONLY");
9883 return strstr (str, "command_lines") == NULL;
9884 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
9885 if (str && strcmp (str, "1") == 0) return 1;
9886 str = getenv ("SKIP_TEST_COMMAND_LINES");
9887 if (str && strcmp (str, "1") == 0) return 1;
9891 static int test_command_lines_3 (void)
9893 if (test_command_lines_3_skip ()) {
9894 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
9898 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
9900 char device[] = "/dev/sda";
9903 r = guestfs_blockdev_setrw (g, device);
9910 r = guestfs_umount_all (g);
9917 r = guestfs_lvm_remove_all (g);
9922 char device[] = "/dev/sda";
9923 char lines_0[] = ",";
9930 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9935 char fstype[] = "ext2";
9936 char device[] = "/dev/sda1";
9939 r = guestfs_mkfs (g, fstype, device);
9944 char device[] = "/dev/sda1";
9945 char mountpoint[] = "/";
9948 r = guestfs_mount (g, device, mountpoint);
9952 /* TestOutputList for command_lines (3) */
9954 char remotefilename[] = "/test-command";
9957 r = guestfs_upload (g, "test-command", remotefilename);
9962 char path[] = "/test-command";
9965 r = guestfs_chmod (g, 493, path);
9970 char arguments_0[] = "/test-command";
9971 char arguments_1[] = "4";
9972 char *arguments[] = {
9980 r = guestfs_command_lines (g, arguments);
9984 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
9989 char expected[] = "";
9990 if (strcmp (r[0], expected) != 0) {
9991 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9996 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
10001 char expected[] = "Result4";
10002 if (strcmp (r[1], expected) != 0) {
10003 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10007 if (r[2] != NULL) {
10008 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
10012 for (i = 0; r[i] != NULL; ++i)
10019 static int test_command_lines_4_skip (void)
10023 str = getenv ("TEST_ONLY");
10025 return strstr (str, "command_lines") == NULL;
10026 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
10027 if (str && strcmp (str, "1") == 0) return 1;
10028 str = getenv ("SKIP_TEST_COMMAND_LINES");
10029 if (str && strcmp (str, "1") == 0) return 1;
10033 static int test_command_lines_4 (void)
10035 if (test_command_lines_4_skip ()) {
10036 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
10040 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
10042 char device[] = "/dev/sda";
10044 suppress_error = 0;
10045 r = guestfs_blockdev_setrw (g, device);
10051 suppress_error = 0;
10052 r = guestfs_umount_all (g);
10058 suppress_error = 0;
10059 r = guestfs_lvm_remove_all (g);
10064 char device[] = "/dev/sda";
10065 char lines_0[] = ",";
10071 suppress_error = 0;
10072 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10077 char fstype[] = "ext2";
10078 char device[] = "/dev/sda1";
10080 suppress_error = 0;
10081 r = guestfs_mkfs (g, fstype, device);
10086 char device[] = "/dev/sda1";
10087 char mountpoint[] = "/";
10089 suppress_error = 0;
10090 r = guestfs_mount (g, device, mountpoint);
10094 /* TestOutputList for command_lines (4) */
10096 char remotefilename[] = "/test-command";
10098 suppress_error = 0;
10099 r = guestfs_upload (g, "test-command", remotefilename);
10104 char path[] = "/test-command";
10106 suppress_error = 0;
10107 r = guestfs_chmod (g, 493, path);
10112 char arguments_0[] = "/test-command";
10113 char arguments_1[] = "5";
10114 char *arguments[] = {
10121 suppress_error = 0;
10122 r = guestfs_command_lines (g, arguments);
10126 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10131 char expected[] = "";
10132 if (strcmp (r[0], expected) != 0) {
10133 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10138 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10143 char expected[] = "Result5";
10144 if (strcmp (r[1], expected) != 0) {
10145 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10150 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
10155 char expected[] = "";
10156 if (strcmp (r[2], expected) != 0) {
10157 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10161 if (r[3] != NULL) {
10162 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
10166 for (i = 0; r[i] != NULL; ++i)
10173 static int test_command_lines_5_skip (void)
10177 str = getenv ("TEST_ONLY");
10179 return strstr (str, "command_lines") == NULL;
10180 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
10181 if (str && strcmp (str, "1") == 0) return 1;
10182 str = getenv ("SKIP_TEST_COMMAND_LINES");
10183 if (str && strcmp (str, "1") == 0) return 1;
10187 static int test_command_lines_5 (void)
10189 if (test_command_lines_5_skip ()) {
10190 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
10194 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
10196 char device[] = "/dev/sda";
10198 suppress_error = 0;
10199 r = guestfs_blockdev_setrw (g, device);
10205 suppress_error = 0;
10206 r = guestfs_umount_all (g);
10212 suppress_error = 0;
10213 r = guestfs_lvm_remove_all (g);
10218 char device[] = "/dev/sda";
10219 char lines_0[] = ",";
10225 suppress_error = 0;
10226 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10231 char fstype[] = "ext2";
10232 char device[] = "/dev/sda1";
10234 suppress_error = 0;
10235 r = guestfs_mkfs (g, fstype, device);
10240 char device[] = "/dev/sda1";
10241 char mountpoint[] = "/";
10243 suppress_error = 0;
10244 r = guestfs_mount (g, device, mountpoint);
10248 /* TestOutputList for command_lines (5) */
10250 char remotefilename[] = "/test-command";
10252 suppress_error = 0;
10253 r = guestfs_upload (g, "test-command", remotefilename);
10258 char path[] = "/test-command";
10260 suppress_error = 0;
10261 r = guestfs_chmod (g, 493, path);
10266 char arguments_0[] = "/test-command";
10267 char arguments_1[] = "6";
10268 char *arguments[] = {
10275 suppress_error = 0;
10276 r = guestfs_command_lines (g, arguments);
10280 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10285 char expected[] = "";
10286 if (strcmp (r[0], expected) != 0) {
10287 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10292 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10297 char expected[] = "";
10298 if (strcmp (r[1], expected) != 0) {
10299 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10304 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10309 char expected[] = "Result6";
10310 if (strcmp (r[2], expected) != 0) {
10311 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
10316 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
10321 char expected[] = "";
10322 if (strcmp (r[3], expected) != 0) {
10323 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
10327 if (r[4] != NULL) {
10328 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
10332 for (i = 0; r[i] != NULL; ++i)
10339 static int test_command_lines_6_skip (void)
10343 str = getenv ("TEST_ONLY");
10345 return strstr (str, "command_lines") == NULL;
10346 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
10347 if (str && strcmp (str, "1") == 0) return 1;
10348 str = getenv ("SKIP_TEST_COMMAND_LINES");
10349 if (str && strcmp (str, "1") == 0) return 1;
10353 static int test_command_lines_6 (void)
10355 if (test_command_lines_6_skip ()) {
10356 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
10360 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
10362 char device[] = "/dev/sda";
10364 suppress_error = 0;
10365 r = guestfs_blockdev_setrw (g, device);
10371 suppress_error = 0;
10372 r = guestfs_umount_all (g);
10378 suppress_error = 0;
10379 r = guestfs_lvm_remove_all (g);
10384 char device[] = "/dev/sda";
10385 char lines_0[] = ",";
10391 suppress_error = 0;
10392 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10397 char fstype[] = "ext2";
10398 char device[] = "/dev/sda1";
10400 suppress_error = 0;
10401 r = guestfs_mkfs (g, fstype, device);
10406 char device[] = "/dev/sda1";
10407 char mountpoint[] = "/";
10409 suppress_error = 0;
10410 r = guestfs_mount (g, device, mountpoint);
10414 /* TestOutputList for command_lines (6) */
10416 char remotefilename[] = "/test-command";
10418 suppress_error = 0;
10419 r = guestfs_upload (g, "test-command", remotefilename);
10424 char path[] = "/test-command";
10426 suppress_error = 0;
10427 r = guestfs_chmod (g, 493, path);
10432 char arguments_0[] = "/test-command";
10433 char arguments_1[] = "7";
10434 char *arguments[] = {
10441 suppress_error = 0;
10442 r = guestfs_command_lines (g, arguments);
10445 if (r[0] != NULL) {
10446 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
10450 for (i = 0; r[i] != NULL; ++i)
10457 static int test_command_lines_7_skip (void)
10461 str = getenv ("TEST_ONLY");
10463 return strstr (str, "command_lines") == NULL;
10464 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
10465 if (str && strcmp (str, "1") == 0) return 1;
10466 str = getenv ("SKIP_TEST_COMMAND_LINES");
10467 if (str && strcmp (str, "1") == 0) return 1;
10471 static int test_command_lines_7 (void)
10473 if (test_command_lines_7_skip ()) {
10474 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
10478 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
10480 char device[] = "/dev/sda";
10482 suppress_error = 0;
10483 r = guestfs_blockdev_setrw (g, device);
10489 suppress_error = 0;
10490 r = guestfs_umount_all (g);
10496 suppress_error = 0;
10497 r = guestfs_lvm_remove_all (g);
10502 char device[] = "/dev/sda";
10503 char lines_0[] = ",";
10509 suppress_error = 0;
10510 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10515 char fstype[] = "ext2";
10516 char device[] = "/dev/sda1";
10518 suppress_error = 0;
10519 r = guestfs_mkfs (g, fstype, device);
10524 char device[] = "/dev/sda1";
10525 char mountpoint[] = "/";
10527 suppress_error = 0;
10528 r = guestfs_mount (g, device, mountpoint);
10532 /* TestOutputList for command_lines (7) */
10534 char remotefilename[] = "/test-command";
10536 suppress_error = 0;
10537 r = guestfs_upload (g, "test-command", remotefilename);
10542 char path[] = "/test-command";
10544 suppress_error = 0;
10545 r = guestfs_chmod (g, 493, path);
10550 char arguments_0[] = "/test-command";
10551 char arguments_1[] = "8";
10552 char *arguments[] = {
10559 suppress_error = 0;
10560 r = guestfs_command_lines (g, arguments);
10564 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
10569 char expected[] = "";
10570 if (strcmp (r[0], expected) != 0) {
10571 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10575 if (r[1] != NULL) {
10576 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
10580 for (i = 0; r[i] != NULL; ++i)
10587 static int test_command_lines_8_skip (void)
10591 str = getenv ("TEST_ONLY");
10593 return strstr (str, "command_lines") == NULL;
10594 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
10595 if (str && strcmp (str, "1") == 0) return 1;
10596 str = getenv ("SKIP_TEST_COMMAND_LINES");
10597 if (str && strcmp (str, "1") == 0) return 1;
10601 static int test_command_lines_8 (void)
10603 if (test_command_lines_8_skip ()) {
10604 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
10608 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
10610 char device[] = "/dev/sda";
10612 suppress_error = 0;
10613 r = guestfs_blockdev_setrw (g, device);
10619 suppress_error = 0;
10620 r = guestfs_umount_all (g);
10626 suppress_error = 0;
10627 r = guestfs_lvm_remove_all (g);
10632 char device[] = "/dev/sda";
10633 char lines_0[] = ",";
10639 suppress_error = 0;
10640 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10645 char fstype[] = "ext2";
10646 char device[] = "/dev/sda1";
10648 suppress_error = 0;
10649 r = guestfs_mkfs (g, fstype, device);
10654 char device[] = "/dev/sda1";
10655 char mountpoint[] = "/";
10657 suppress_error = 0;
10658 r = guestfs_mount (g, device, mountpoint);
10662 /* TestOutputList for command_lines (8) */
10664 char remotefilename[] = "/test-command";
10666 suppress_error = 0;
10667 r = guestfs_upload (g, "test-command", remotefilename);
10672 char path[] = "/test-command";
10674 suppress_error = 0;
10675 r = guestfs_chmod (g, 493, path);
10680 char arguments_0[] = "/test-command";
10681 char arguments_1[] = "9";
10682 char *arguments[] = {
10689 suppress_error = 0;
10690 r = guestfs_command_lines (g, arguments);
10694 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10699 char expected[] = "";
10700 if (strcmp (r[0], expected) != 0) {
10701 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10706 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
10711 char expected[] = "";
10712 if (strcmp (r[1], expected) != 0) {
10713 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10717 if (r[2] != NULL) {
10718 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
10722 for (i = 0; r[i] != NULL; ++i)
10729 static int test_command_lines_9_skip (void)
10733 str = getenv ("TEST_ONLY");
10735 return strstr (str, "command_lines") == NULL;
10736 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
10737 if (str && strcmp (str, "1") == 0) return 1;
10738 str = getenv ("SKIP_TEST_COMMAND_LINES");
10739 if (str && strcmp (str, "1") == 0) return 1;
10743 static int test_command_lines_9 (void)
10745 if (test_command_lines_9_skip ()) {
10746 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
10750 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
10752 char device[] = "/dev/sda";
10754 suppress_error = 0;
10755 r = guestfs_blockdev_setrw (g, device);
10761 suppress_error = 0;
10762 r = guestfs_umount_all (g);
10768 suppress_error = 0;
10769 r = guestfs_lvm_remove_all (g);
10774 char device[] = "/dev/sda";
10775 char lines_0[] = ",";
10781 suppress_error = 0;
10782 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10787 char fstype[] = "ext2";
10788 char device[] = "/dev/sda1";
10790 suppress_error = 0;
10791 r = guestfs_mkfs (g, fstype, device);
10796 char device[] = "/dev/sda1";
10797 char mountpoint[] = "/";
10799 suppress_error = 0;
10800 r = guestfs_mount (g, device, mountpoint);
10804 /* TestOutputList for command_lines (9) */
10806 char remotefilename[] = "/test-command";
10808 suppress_error = 0;
10809 r = guestfs_upload (g, "test-command", remotefilename);
10814 char path[] = "/test-command";
10816 suppress_error = 0;
10817 r = guestfs_chmod (g, 493, path);
10822 char arguments_0[] = "/test-command";
10823 char arguments_1[] = "10";
10824 char *arguments[] = {
10831 suppress_error = 0;
10832 r = guestfs_command_lines (g, arguments);
10836 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10841 char expected[] = "Result10-1";
10842 if (strcmp (r[0], expected) != 0) {
10843 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10848 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
10853 char expected[] = "Result10-2";
10854 if (strcmp (r[1], expected) != 0) {
10855 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
10859 if (r[2] != NULL) {
10860 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
10864 for (i = 0; r[i] != NULL; ++i)
10871 static int test_command_lines_10_skip (void)
10875 str = getenv ("TEST_ONLY");
10877 return strstr (str, "command_lines") == NULL;
10878 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
10879 if (str && strcmp (str, "1") == 0) return 1;
10880 str = getenv ("SKIP_TEST_COMMAND_LINES");
10881 if (str && strcmp (str, "1") == 0) return 1;
10885 static int test_command_lines_10 (void)
10887 if (test_command_lines_10_skip ()) {
10888 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
10892 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
10894 char device[] = "/dev/sda";
10896 suppress_error = 0;
10897 r = guestfs_blockdev_setrw (g, device);
10903 suppress_error = 0;
10904 r = guestfs_umount_all (g);
10910 suppress_error = 0;
10911 r = guestfs_lvm_remove_all (g);
10916 char device[] = "/dev/sda";
10917 char lines_0[] = ",";
10923 suppress_error = 0;
10924 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10929 char fstype[] = "ext2";
10930 char device[] = "/dev/sda1";
10932 suppress_error = 0;
10933 r = guestfs_mkfs (g, fstype, device);
10938 char device[] = "/dev/sda1";
10939 char mountpoint[] = "/";
10941 suppress_error = 0;
10942 r = guestfs_mount (g, device, mountpoint);
10946 /* TestOutputList for command_lines (10) */
10948 char remotefilename[] = "/test-command";
10950 suppress_error = 0;
10951 r = guestfs_upload (g, "test-command", remotefilename);
10956 char path[] = "/test-command";
10958 suppress_error = 0;
10959 r = guestfs_chmod (g, 493, path);
10964 char arguments_0[] = "/test-command";
10965 char arguments_1[] = "11";
10966 char *arguments[] = {
10973 suppress_error = 0;
10974 r = guestfs_command_lines (g, arguments);
10978 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10983 char expected[] = "Result11-1";
10984 if (strcmp (r[0], expected) != 0) {
10985 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10990 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
10995 char expected[] = "Result11-2";
10996 if (strcmp (r[1], expected) != 0) {
10997 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11001 if (r[2] != NULL) {
11002 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
11006 for (i = 0; r[i] != NULL; ++i)
11013 static int test_command_0_skip (void)
11017 str = getenv ("TEST_ONLY");
11019 return strstr (str, "command") == NULL;
11020 str = getenv ("SKIP_TEST_COMMAND_0");
11021 if (str && strcmp (str, "1") == 0) return 1;
11022 str = getenv ("SKIP_TEST_COMMAND");
11023 if (str && strcmp (str, "1") == 0) return 1;
11027 static int test_command_0 (void)
11029 if (test_command_0_skip ()) {
11030 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
11034 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
11036 char device[] = "/dev/sda";
11038 suppress_error = 0;
11039 r = guestfs_blockdev_setrw (g, device);
11045 suppress_error = 0;
11046 r = guestfs_umount_all (g);
11052 suppress_error = 0;
11053 r = guestfs_lvm_remove_all (g);
11058 char device[] = "/dev/sda";
11059 char lines_0[] = ",";
11065 suppress_error = 0;
11066 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11071 char fstype[] = "ext2";
11072 char device[] = "/dev/sda1";
11074 suppress_error = 0;
11075 r = guestfs_mkfs (g, fstype, device);
11080 char device[] = "/dev/sda1";
11081 char mountpoint[] = "/";
11083 suppress_error = 0;
11084 r = guestfs_mount (g, device, mountpoint);
11088 /* TestOutput for command (0) */
11089 char expected[] = "Result1";
11091 char remotefilename[] = "/test-command";
11093 suppress_error = 0;
11094 r = guestfs_upload (g, "test-command", remotefilename);
11099 char path[] = "/test-command";
11101 suppress_error = 0;
11102 r = guestfs_chmod (g, 493, path);
11107 char arguments_0[] = "/test-command";
11108 char arguments_1[] = "1";
11109 char *arguments[] = {
11115 suppress_error = 0;
11116 r = guestfs_command (g, arguments);
11119 if (strcmp (r, expected) != 0) {
11120 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
11128 static int test_command_1_skip (void)
11132 str = getenv ("TEST_ONLY");
11134 return strstr (str, "command") == NULL;
11135 str = getenv ("SKIP_TEST_COMMAND_1");
11136 if (str && strcmp (str, "1") == 0) return 1;
11137 str = getenv ("SKIP_TEST_COMMAND");
11138 if (str && strcmp (str, "1") == 0) return 1;
11142 static int test_command_1 (void)
11144 if (test_command_1_skip ()) {
11145 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
11149 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
11151 char device[] = "/dev/sda";
11153 suppress_error = 0;
11154 r = guestfs_blockdev_setrw (g, device);
11160 suppress_error = 0;
11161 r = guestfs_umount_all (g);
11167 suppress_error = 0;
11168 r = guestfs_lvm_remove_all (g);
11173 char device[] = "/dev/sda";
11174 char lines_0[] = ",";
11180 suppress_error = 0;
11181 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11186 char fstype[] = "ext2";
11187 char device[] = "/dev/sda1";
11189 suppress_error = 0;
11190 r = guestfs_mkfs (g, fstype, device);
11195 char device[] = "/dev/sda1";
11196 char mountpoint[] = "/";
11198 suppress_error = 0;
11199 r = guestfs_mount (g, device, mountpoint);
11203 /* TestOutput for command (1) */
11204 char expected[] = "Result2\n";
11206 char remotefilename[] = "/test-command";
11208 suppress_error = 0;
11209 r = guestfs_upload (g, "test-command", remotefilename);
11214 char path[] = "/test-command";
11216 suppress_error = 0;
11217 r = guestfs_chmod (g, 493, path);
11222 char arguments_0[] = "/test-command";
11223 char arguments_1[] = "2";
11224 char *arguments[] = {
11230 suppress_error = 0;
11231 r = guestfs_command (g, arguments);
11234 if (strcmp (r, expected) != 0) {
11235 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
11243 static int test_command_2_skip (void)
11247 str = getenv ("TEST_ONLY");
11249 return strstr (str, "command") == NULL;
11250 str = getenv ("SKIP_TEST_COMMAND_2");
11251 if (str && strcmp (str, "1") == 0) return 1;
11252 str = getenv ("SKIP_TEST_COMMAND");
11253 if (str && strcmp (str, "1") == 0) return 1;
11257 static int test_command_2 (void)
11259 if (test_command_2_skip ()) {
11260 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
11264 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
11266 char device[] = "/dev/sda";
11268 suppress_error = 0;
11269 r = guestfs_blockdev_setrw (g, device);
11275 suppress_error = 0;
11276 r = guestfs_umount_all (g);
11282 suppress_error = 0;
11283 r = guestfs_lvm_remove_all (g);
11288 char device[] = "/dev/sda";
11289 char lines_0[] = ",";
11295 suppress_error = 0;
11296 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11301 char fstype[] = "ext2";
11302 char device[] = "/dev/sda1";
11304 suppress_error = 0;
11305 r = guestfs_mkfs (g, fstype, device);
11310 char device[] = "/dev/sda1";
11311 char mountpoint[] = "/";
11313 suppress_error = 0;
11314 r = guestfs_mount (g, device, mountpoint);
11318 /* TestOutput for command (2) */
11319 char expected[] = "\nResult3";
11321 char remotefilename[] = "/test-command";
11323 suppress_error = 0;
11324 r = guestfs_upload (g, "test-command", remotefilename);
11329 char path[] = "/test-command";
11331 suppress_error = 0;
11332 r = guestfs_chmod (g, 493, path);
11337 char arguments_0[] = "/test-command";
11338 char arguments_1[] = "3";
11339 char *arguments[] = {
11345 suppress_error = 0;
11346 r = guestfs_command (g, arguments);
11349 if (strcmp (r, expected) != 0) {
11350 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
11358 static int test_command_3_skip (void)
11362 str = getenv ("TEST_ONLY");
11364 return strstr (str, "command") == NULL;
11365 str = getenv ("SKIP_TEST_COMMAND_3");
11366 if (str && strcmp (str, "1") == 0) return 1;
11367 str = getenv ("SKIP_TEST_COMMAND");
11368 if (str && strcmp (str, "1") == 0) return 1;
11372 static int test_command_3 (void)
11374 if (test_command_3_skip ()) {
11375 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
11379 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
11381 char device[] = "/dev/sda";
11383 suppress_error = 0;
11384 r = guestfs_blockdev_setrw (g, device);
11390 suppress_error = 0;
11391 r = guestfs_umount_all (g);
11397 suppress_error = 0;
11398 r = guestfs_lvm_remove_all (g);
11403 char device[] = "/dev/sda";
11404 char lines_0[] = ",";
11410 suppress_error = 0;
11411 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11416 char fstype[] = "ext2";
11417 char device[] = "/dev/sda1";
11419 suppress_error = 0;
11420 r = guestfs_mkfs (g, fstype, device);
11425 char device[] = "/dev/sda1";
11426 char mountpoint[] = "/";
11428 suppress_error = 0;
11429 r = guestfs_mount (g, device, mountpoint);
11433 /* TestOutput for command (3) */
11434 char expected[] = "\nResult4\n";
11436 char remotefilename[] = "/test-command";
11438 suppress_error = 0;
11439 r = guestfs_upload (g, "test-command", remotefilename);
11444 char path[] = "/test-command";
11446 suppress_error = 0;
11447 r = guestfs_chmod (g, 493, path);
11452 char arguments_0[] = "/test-command";
11453 char arguments_1[] = "4";
11454 char *arguments[] = {
11460 suppress_error = 0;
11461 r = guestfs_command (g, arguments);
11464 if (strcmp (r, expected) != 0) {
11465 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
11473 static int test_command_4_skip (void)
11477 str = getenv ("TEST_ONLY");
11479 return strstr (str, "command") == NULL;
11480 str = getenv ("SKIP_TEST_COMMAND_4");
11481 if (str && strcmp (str, "1") == 0) return 1;
11482 str = getenv ("SKIP_TEST_COMMAND");
11483 if (str && strcmp (str, "1") == 0) return 1;
11487 static int test_command_4 (void)
11489 if (test_command_4_skip ()) {
11490 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
11494 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
11496 char device[] = "/dev/sda";
11498 suppress_error = 0;
11499 r = guestfs_blockdev_setrw (g, device);
11505 suppress_error = 0;
11506 r = guestfs_umount_all (g);
11512 suppress_error = 0;
11513 r = guestfs_lvm_remove_all (g);
11518 char device[] = "/dev/sda";
11519 char lines_0[] = ",";
11525 suppress_error = 0;
11526 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11531 char fstype[] = "ext2";
11532 char device[] = "/dev/sda1";
11534 suppress_error = 0;
11535 r = guestfs_mkfs (g, fstype, device);
11540 char device[] = "/dev/sda1";
11541 char mountpoint[] = "/";
11543 suppress_error = 0;
11544 r = guestfs_mount (g, device, mountpoint);
11548 /* TestOutput for command (4) */
11549 char expected[] = "\nResult5\n\n";
11551 char remotefilename[] = "/test-command";
11553 suppress_error = 0;
11554 r = guestfs_upload (g, "test-command", remotefilename);
11559 char path[] = "/test-command";
11561 suppress_error = 0;
11562 r = guestfs_chmod (g, 493, path);
11567 char arguments_0[] = "/test-command";
11568 char arguments_1[] = "5";
11569 char *arguments[] = {
11575 suppress_error = 0;
11576 r = guestfs_command (g, arguments);
11579 if (strcmp (r, expected) != 0) {
11580 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
11588 static int test_command_5_skip (void)
11592 str = getenv ("TEST_ONLY");
11594 return strstr (str, "command") == NULL;
11595 str = getenv ("SKIP_TEST_COMMAND_5");
11596 if (str && strcmp (str, "1") == 0) return 1;
11597 str = getenv ("SKIP_TEST_COMMAND");
11598 if (str && strcmp (str, "1") == 0) return 1;
11602 static int test_command_5 (void)
11604 if (test_command_5_skip ()) {
11605 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
11609 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
11611 char device[] = "/dev/sda";
11613 suppress_error = 0;
11614 r = guestfs_blockdev_setrw (g, device);
11620 suppress_error = 0;
11621 r = guestfs_umount_all (g);
11627 suppress_error = 0;
11628 r = guestfs_lvm_remove_all (g);
11633 char device[] = "/dev/sda";
11634 char lines_0[] = ",";
11640 suppress_error = 0;
11641 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11646 char fstype[] = "ext2";
11647 char device[] = "/dev/sda1";
11649 suppress_error = 0;
11650 r = guestfs_mkfs (g, fstype, device);
11655 char device[] = "/dev/sda1";
11656 char mountpoint[] = "/";
11658 suppress_error = 0;
11659 r = guestfs_mount (g, device, mountpoint);
11663 /* TestOutput for command (5) */
11664 char expected[] = "\n\nResult6\n\n";
11666 char remotefilename[] = "/test-command";
11668 suppress_error = 0;
11669 r = guestfs_upload (g, "test-command", remotefilename);
11674 char path[] = "/test-command";
11676 suppress_error = 0;
11677 r = guestfs_chmod (g, 493, path);
11682 char arguments_0[] = "/test-command";
11683 char arguments_1[] = "6";
11684 char *arguments[] = {
11690 suppress_error = 0;
11691 r = guestfs_command (g, arguments);
11694 if (strcmp (r, expected) != 0) {
11695 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
11703 static int test_command_6_skip (void)
11707 str = getenv ("TEST_ONLY");
11709 return strstr (str, "command") == NULL;
11710 str = getenv ("SKIP_TEST_COMMAND_6");
11711 if (str && strcmp (str, "1") == 0) return 1;
11712 str = getenv ("SKIP_TEST_COMMAND");
11713 if (str && strcmp (str, "1") == 0) return 1;
11717 static int test_command_6 (void)
11719 if (test_command_6_skip ()) {
11720 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
11724 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
11726 char device[] = "/dev/sda";
11728 suppress_error = 0;
11729 r = guestfs_blockdev_setrw (g, device);
11735 suppress_error = 0;
11736 r = guestfs_umount_all (g);
11742 suppress_error = 0;
11743 r = guestfs_lvm_remove_all (g);
11748 char device[] = "/dev/sda";
11749 char lines_0[] = ",";
11755 suppress_error = 0;
11756 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11761 char fstype[] = "ext2";
11762 char device[] = "/dev/sda1";
11764 suppress_error = 0;
11765 r = guestfs_mkfs (g, fstype, device);
11770 char device[] = "/dev/sda1";
11771 char mountpoint[] = "/";
11773 suppress_error = 0;
11774 r = guestfs_mount (g, device, mountpoint);
11778 /* TestOutput for command (6) */
11779 char expected[] = "";
11781 char remotefilename[] = "/test-command";
11783 suppress_error = 0;
11784 r = guestfs_upload (g, "test-command", remotefilename);
11789 char path[] = "/test-command";
11791 suppress_error = 0;
11792 r = guestfs_chmod (g, 493, path);
11797 char arguments_0[] = "/test-command";
11798 char arguments_1[] = "7";
11799 char *arguments[] = {
11805 suppress_error = 0;
11806 r = guestfs_command (g, arguments);
11809 if (strcmp (r, expected) != 0) {
11810 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
11818 static int test_command_7_skip (void)
11822 str = getenv ("TEST_ONLY");
11824 return strstr (str, "command") == NULL;
11825 str = getenv ("SKIP_TEST_COMMAND_7");
11826 if (str && strcmp (str, "1") == 0) return 1;
11827 str = getenv ("SKIP_TEST_COMMAND");
11828 if (str && strcmp (str, "1") == 0) return 1;
11832 static int test_command_7 (void)
11834 if (test_command_7_skip ()) {
11835 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
11839 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
11841 char device[] = "/dev/sda";
11843 suppress_error = 0;
11844 r = guestfs_blockdev_setrw (g, device);
11850 suppress_error = 0;
11851 r = guestfs_umount_all (g);
11857 suppress_error = 0;
11858 r = guestfs_lvm_remove_all (g);
11863 char device[] = "/dev/sda";
11864 char lines_0[] = ",";
11870 suppress_error = 0;
11871 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11876 char fstype[] = "ext2";
11877 char device[] = "/dev/sda1";
11879 suppress_error = 0;
11880 r = guestfs_mkfs (g, fstype, device);
11885 char device[] = "/dev/sda1";
11886 char mountpoint[] = "/";
11888 suppress_error = 0;
11889 r = guestfs_mount (g, device, mountpoint);
11893 /* TestOutput for command (7) */
11894 char expected[] = "\n";
11896 char remotefilename[] = "/test-command";
11898 suppress_error = 0;
11899 r = guestfs_upload (g, "test-command", remotefilename);
11904 char path[] = "/test-command";
11906 suppress_error = 0;
11907 r = guestfs_chmod (g, 493, path);
11912 char arguments_0[] = "/test-command";
11913 char arguments_1[] = "8";
11914 char *arguments[] = {
11920 suppress_error = 0;
11921 r = guestfs_command (g, arguments);
11924 if (strcmp (r, expected) != 0) {
11925 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
11933 static int test_command_8_skip (void)
11937 str = getenv ("TEST_ONLY");
11939 return strstr (str, "command") == NULL;
11940 str = getenv ("SKIP_TEST_COMMAND_8");
11941 if (str && strcmp (str, "1") == 0) return 1;
11942 str = getenv ("SKIP_TEST_COMMAND");
11943 if (str && strcmp (str, "1") == 0) return 1;
11947 static int test_command_8 (void)
11949 if (test_command_8_skip ()) {
11950 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
11954 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
11956 char device[] = "/dev/sda";
11958 suppress_error = 0;
11959 r = guestfs_blockdev_setrw (g, device);
11965 suppress_error = 0;
11966 r = guestfs_umount_all (g);
11972 suppress_error = 0;
11973 r = guestfs_lvm_remove_all (g);
11978 char device[] = "/dev/sda";
11979 char lines_0[] = ",";
11985 suppress_error = 0;
11986 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11991 char fstype[] = "ext2";
11992 char device[] = "/dev/sda1";
11994 suppress_error = 0;
11995 r = guestfs_mkfs (g, fstype, device);
12000 char device[] = "/dev/sda1";
12001 char mountpoint[] = "/";
12003 suppress_error = 0;
12004 r = guestfs_mount (g, device, mountpoint);
12008 /* TestOutput for command (8) */
12009 char expected[] = "\n\n";
12011 char remotefilename[] = "/test-command";
12013 suppress_error = 0;
12014 r = guestfs_upload (g, "test-command", remotefilename);
12019 char path[] = "/test-command";
12021 suppress_error = 0;
12022 r = guestfs_chmod (g, 493, path);
12027 char arguments_0[] = "/test-command";
12028 char arguments_1[] = "9";
12029 char *arguments[] = {
12035 suppress_error = 0;
12036 r = guestfs_command (g, arguments);
12039 if (strcmp (r, expected) != 0) {
12040 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
12048 static int test_command_9_skip (void)
12052 str = getenv ("TEST_ONLY");
12054 return strstr (str, "command") == NULL;
12055 str = getenv ("SKIP_TEST_COMMAND_9");
12056 if (str && strcmp (str, "1") == 0) return 1;
12057 str = getenv ("SKIP_TEST_COMMAND");
12058 if (str && strcmp (str, "1") == 0) return 1;
12062 static int test_command_9 (void)
12064 if (test_command_9_skip ()) {
12065 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
12069 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
12071 char device[] = "/dev/sda";
12073 suppress_error = 0;
12074 r = guestfs_blockdev_setrw (g, device);
12080 suppress_error = 0;
12081 r = guestfs_umount_all (g);
12087 suppress_error = 0;
12088 r = guestfs_lvm_remove_all (g);
12093 char device[] = "/dev/sda";
12094 char lines_0[] = ",";
12100 suppress_error = 0;
12101 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12106 char fstype[] = "ext2";
12107 char device[] = "/dev/sda1";
12109 suppress_error = 0;
12110 r = guestfs_mkfs (g, fstype, device);
12115 char device[] = "/dev/sda1";
12116 char mountpoint[] = "/";
12118 suppress_error = 0;
12119 r = guestfs_mount (g, device, mountpoint);
12123 /* TestOutput for command (9) */
12124 char expected[] = "Result10-1\nResult10-2\n";
12126 char remotefilename[] = "/test-command";
12128 suppress_error = 0;
12129 r = guestfs_upload (g, "test-command", remotefilename);
12134 char path[] = "/test-command";
12136 suppress_error = 0;
12137 r = guestfs_chmod (g, 493, path);
12142 char arguments_0[] = "/test-command";
12143 char arguments_1[] = "10";
12144 char *arguments[] = {
12150 suppress_error = 0;
12151 r = guestfs_command (g, arguments);
12154 if (strcmp (r, expected) != 0) {
12155 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
12163 static int test_command_10_skip (void)
12167 str = getenv ("TEST_ONLY");
12169 return strstr (str, "command") == NULL;
12170 str = getenv ("SKIP_TEST_COMMAND_10");
12171 if (str && strcmp (str, "1") == 0) return 1;
12172 str = getenv ("SKIP_TEST_COMMAND");
12173 if (str && strcmp (str, "1") == 0) return 1;
12177 static int test_command_10 (void)
12179 if (test_command_10_skip ()) {
12180 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
12184 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
12186 char device[] = "/dev/sda";
12188 suppress_error = 0;
12189 r = guestfs_blockdev_setrw (g, device);
12195 suppress_error = 0;
12196 r = guestfs_umount_all (g);
12202 suppress_error = 0;
12203 r = guestfs_lvm_remove_all (g);
12208 char device[] = "/dev/sda";
12209 char lines_0[] = ",";
12215 suppress_error = 0;
12216 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12221 char fstype[] = "ext2";
12222 char device[] = "/dev/sda1";
12224 suppress_error = 0;
12225 r = guestfs_mkfs (g, fstype, device);
12230 char device[] = "/dev/sda1";
12231 char mountpoint[] = "/";
12233 suppress_error = 0;
12234 r = guestfs_mount (g, device, mountpoint);
12238 /* TestOutput for command (10) */
12239 char expected[] = "Result11-1\nResult11-2";
12241 char remotefilename[] = "/test-command";
12243 suppress_error = 0;
12244 r = guestfs_upload (g, "test-command", remotefilename);
12249 char path[] = "/test-command";
12251 suppress_error = 0;
12252 r = guestfs_chmod (g, 493, path);
12257 char arguments_0[] = "/test-command";
12258 char arguments_1[] = "11";
12259 char *arguments[] = {
12265 suppress_error = 0;
12266 r = guestfs_command (g, arguments);
12269 if (strcmp (r, expected) != 0) {
12270 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
12278 static int test_command_11_skip (void)
12282 str = getenv ("TEST_ONLY");
12284 return strstr (str, "command") == NULL;
12285 str = getenv ("SKIP_TEST_COMMAND_11");
12286 if (str && strcmp (str, "1") == 0) return 1;
12287 str = getenv ("SKIP_TEST_COMMAND");
12288 if (str && strcmp (str, "1") == 0) return 1;
12292 static int test_command_11 (void)
12294 if (test_command_11_skip ()) {
12295 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
12299 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
12301 char device[] = "/dev/sda";
12303 suppress_error = 0;
12304 r = guestfs_blockdev_setrw (g, device);
12310 suppress_error = 0;
12311 r = guestfs_umount_all (g);
12317 suppress_error = 0;
12318 r = guestfs_lvm_remove_all (g);
12323 char device[] = "/dev/sda";
12324 char lines_0[] = ",";
12330 suppress_error = 0;
12331 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12336 char fstype[] = "ext2";
12337 char device[] = "/dev/sda1";
12339 suppress_error = 0;
12340 r = guestfs_mkfs (g, fstype, device);
12345 char device[] = "/dev/sda1";
12346 char mountpoint[] = "/";
12348 suppress_error = 0;
12349 r = guestfs_mount (g, device, mountpoint);
12353 /* TestLastFail for command (11) */
12355 char remotefilename[] = "/test-command";
12357 suppress_error = 0;
12358 r = guestfs_upload (g, "test-command", remotefilename);
12363 char path[] = "/test-command";
12365 suppress_error = 0;
12366 r = guestfs_chmod (g, 493, path);
12371 char arguments_0[] = "/test-command";
12372 char *arguments[] = {
12377 suppress_error = 1;
12378 r = guestfs_command (g, arguments);
12386 static int test_file_0_skip (void)
12390 str = getenv ("TEST_ONLY");
12392 return strstr (str, "file") == NULL;
12393 str = getenv ("SKIP_TEST_FILE_0");
12394 if (str && strcmp (str, "1") == 0) return 1;
12395 str = getenv ("SKIP_TEST_FILE");
12396 if (str && strcmp (str, "1") == 0) return 1;
12400 static int test_file_0 (void)
12402 if (test_file_0_skip ()) {
12403 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
12407 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
12409 char device[] = "/dev/sda";
12411 suppress_error = 0;
12412 r = guestfs_blockdev_setrw (g, device);
12418 suppress_error = 0;
12419 r = guestfs_umount_all (g);
12425 suppress_error = 0;
12426 r = guestfs_lvm_remove_all (g);
12431 char device[] = "/dev/sda";
12432 char lines_0[] = ",";
12438 suppress_error = 0;
12439 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12444 char fstype[] = "ext2";
12445 char device[] = "/dev/sda1";
12447 suppress_error = 0;
12448 r = guestfs_mkfs (g, fstype, device);
12453 char device[] = "/dev/sda1";
12454 char mountpoint[] = "/";
12456 suppress_error = 0;
12457 r = guestfs_mount (g, device, mountpoint);
12461 /* TestOutput for file (0) */
12462 char expected[] = "empty";
12464 char path[] = "/new";
12466 suppress_error = 0;
12467 r = guestfs_touch (g, path);
12472 char path[] = "/new";
12474 suppress_error = 0;
12475 r = guestfs_file (g, path);
12478 if (strcmp (r, expected) != 0) {
12479 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12487 static int test_file_1_skip (void)
12491 str = getenv ("TEST_ONLY");
12493 return strstr (str, "file") == NULL;
12494 str = getenv ("SKIP_TEST_FILE_1");
12495 if (str && strcmp (str, "1") == 0) return 1;
12496 str = getenv ("SKIP_TEST_FILE");
12497 if (str && strcmp (str, "1") == 0) return 1;
12501 static int test_file_1 (void)
12503 if (test_file_1_skip ()) {
12504 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
12508 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
12510 char device[] = "/dev/sda";
12512 suppress_error = 0;
12513 r = guestfs_blockdev_setrw (g, device);
12519 suppress_error = 0;
12520 r = guestfs_umount_all (g);
12526 suppress_error = 0;
12527 r = guestfs_lvm_remove_all (g);
12532 char device[] = "/dev/sda";
12533 char lines_0[] = ",";
12539 suppress_error = 0;
12540 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12545 char fstype[] = "ext2";
12546 char device[] = "/dev/sda1";
12548 suppress_error = 0;
12549 r = guestfs_mkfs (g, fstype, device);
12554 char device[] = "/dev/sda1";
12555 char mountpoint[] = "/";
12557 suppress_error = 0;
12558 r = guestfs_mount (g, device, mountpoint);
12562 /* TestOutput for file (1) */
12563 char expected[] = "ASCII text";
12565 char path[] = "/new";
12566 char content[] = "some content\n";
12568 suppress_error = 0;
12569 r = guestfs_write_file (g, path, content, 0);
12574 char path[] = "/new";
12576 suppress_error = 0;
12577 r = guestfs_file (g, path);
12580 if (strcmp (r, expected) != 0) {
12581 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12589 static int test_file_2_skip (void)
12593 str = getenv ("TEST_ONLY");
12595 return strstr (str, "file") == NULL;
12596 str = getenv ("SKIP_TEST_FILE_2");
12597 if (str && strcmp (str, "1") == 0) return 1;
12598 str = getenv ("SKIP_TEST_FILE");
12599 if (str && strcmp (str, "1") == 0) return 1;
12603 static int test_file_2 (void)
12605 if (test_file_2_skip ()) {
12606 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
12610 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
12612 char device[] = "/dev/sda";
12614 suppress_error = 0;
12615 r = guestfs_blockdev_setrw (g, device);
12621 suppress_error = 0;
12622 r = guestfs_umount_all (g);
12628 suppress_error = 0;
12629 r = guestfs_lvm_remove_all (g);
12634 char device[] = "/dev/sda";
12635 char lines_0[] = ",";
12641 suppress_error = 0;
12642 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12647 char fstype[] = "ext2";
12648 char device[] = "/dev/sda1";
12650 suppress_error = 0;
12651 r = guestfs_mkfs (g, fstype, device);
12656 char device[] = "/dev/sda1";
12657 char mountpoint[] = "/";
12659 suppress_error = 0;
12660 r = guestfs_mount (g, device, mountpoint);
12664 /* TestLastFail for file (2) */
12666 char path[] = "/nofile";
12668 suppress_error = 1;
12669 r = guestfs_file (g, path);
12677 static int test_umount_all_0_skip (void)
12681 str = getenv ("TEST_ONLY");
12683 return strstr (str, "umount_all") == NULL;
12684 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
12685 if (str && strcmp (str, "1") == 0) return 1;
12686 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12687 if (str && strcmp (str, "1") == 0) return 1;
12691 static int test_umount_all_0 (void)
12693 if (test_umount_all_0_skip ()) {
12694 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
12698 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
12700 char device[] = "/dev/sda";
12702 suppress_error = 0;
12703 r = guestfs_blockdev_setrw (g, device);
12709 suppress_error = 0;
12710 r = guestfs_umount_all (g);
12716 suppress_error = 0;
12717 r = guestfs_lvm_remove_all (g);
12722 char device[] = "/dev/sda";
12723 char lines_0[] = ",";
12729 suppress_error = 0;
12730 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12735 char fstype[] = "ext2";
12736 char device[] = "/dev/sda1";
12738 suppress_error = 0;
12739 r = guestfs_mkfs (g, fstype, device);
12744 char device[] = "/dev/sda1";
12745 char mountpoint[] = "/";
12747 suppress_error = 0;
12748 r = guestfs_mount (g, device, mountpoint);
12752 /* TestOutputList for umount_all (0) */
12755 suppress_error = 0;
12756 r = guestfs_umount_all (g);
12763 suppress_error = 0;
12764 r = guestfs_mounts (g);
12767 if (r[0] != NULL) {
12768 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
12772 for (i = 0; r[i] != NULL; ++i)
12779 static int test_umount_all_1_skip (void)
12783 str = getenv ("TEST_ONLY");
12785 return strstr (str, "umount_all") == NULL;
12786 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
12787 if (str && strcmp (str, "1") == 0) return 1;
12788 str = getenv ("SKIP_TEST_UMOUNT_ALL");
12789 if (str && strcmp (str, "1") == 0) return 1;
12793 static int test_umount_all_1 (void)
12795 if (test_umount_all_1_skip ()) {
12796 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
12800 /* InitNone|InitEmpty for test_umount_all_1 */
12802 char device[] = "/dev/sda";
12804 suppress_error = 0;
12805 r = guestfs_blockdev_setrw (g, device);
12811 suppress_error = 0;
12812 r = guestfs_umount_all (g);
12818 suppress_error = 0;
12819 r = guestfs_lvm_remove_all (g);
12823 /* TestOutputList for umount_all (1) */
12825 char device[] = "/dev/sda";
12826 char lines_0[] = ",10";
12827 char lines_1[] = ",20";
12828 char lines_2[] = ",";
12836 suppress_error = 0;
12837 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12842 char fstype[] = "ext2";
12843 char device[] = "/dev/sda1";
12845 suppress_error = 0;
12846 r = guestfs_mkfs (g, fstype, device);
12851 char fstype[] = "ext2";
12852 char device[] = "/dev/sda2";
12854 suppress_error = 0;
12855 r = guestfs_mkfs (g, fstype, device);
12860 char fstype[] = "ext2";
12861 char device[] = "/dev/sda3";
12863 suppress_error = 0;
12864 r = guestfs_mkfs (g, fstype, device);
12869 char device[] = "/dev/sda1";
12870 char mountpoint[] = "/";
12872 suppress_error = 0;
12873 r = guestfs_mount (g, device, mountpoint);
12878 char path[] = "/mp1";
12880 suppress_error = 0;
12881 r = guestfs_mkdir (g, path);
12886 char device[] = "/dev/sda2";
12887 char mountpoint[] = "/mp1";
12889 suppress_error = 0;
12890 r = guestfs_mount (g, device, mountpoint);
12895 char path[] = "/mp1/mp2";
12897 suppress_error = 0;
12898 r = guestfs_mkdir (g, path);
12903 char device[] = "/dev/sda3";
12904 char mountpoint[] = "/mp1/mp2";
12906 suppress_error = 0;
12907 r = guestfs_mount (g, device, mountpoint);
12912 char path[] = "/mp1/mp2/mp3";
12914 suppress_error = 0;
12915 r = guestfs_mkdir (g, path);
12921 suppress_error = 0;
12922 r = guestfs_umount_all (g);
12929 suppress_error = 0;
12930 r = guestfs_mounts (g);
12933 if (r[0] != NULL) {
12934 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
12938 for (i = 0; r[i] != NULL; ++i)
12945 static int test_mounts_0_skip (void)
12949 str = getenv ("TEST_ONLY");
12951 return strstr (str, "mounts") == NULL;
12952 str = getenv ("SKIP_TEST_MOUNTS_0");
12953 if (str && strcmp (str, "1") == 0) return 1;
12954 str = getenv ("SKIP_TEST_MOUNTS");
12955 if (str && strcmp (str, "1") == 0) return 1;
12959 static int test_mounts_0 (void)
12961 if (test_mounts_0_skip ()) {
12962 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
12966 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
12968 char device[] = "/dev/sda";
12970 suppress_error = 0;
12971 r = guestfs_blockdev_setrw (g, device);
12977 suppress_error = 0;
12978 r = guestfs_umount_all (g);
12984 suppress_error = 0;
12985 r = guestfs_lvm_remove_all (g);
12990 char device[] = "/dev/sda";
12991 char lines_0[] = ",";
12997 suppress_error = 0;
12998 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13003 char fstype[] = "ext2";
13004 char device[] = "/dev/sda1";
13006 suppress_error = 0;
13007 r = guestfs_mkfs (g, fstype, device);
13012 char device[] = "/dev/sda1";
13013 char mountpoint[] = "/";
13015 suppress_error = 0;
13016 r = guestfs_mount (g, device, mountpoint);
13020 /* TestOutputListOfDevices for mounts (0) */
13024 suppress_error = 0;
13025 r = guestfs_mounts (g);
13029 fprintf (stderr, "test_mounts_0: short list returned from command\n");
13034 char expected[] = "/dev/sda1";
13036 if (strcmp (r[0], expected) != 0) {
13037 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13041 if (r[1] != NULL) {
13042 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
13046 for (i = 0; r[i] != NULL; ++i)
13053 static int test_umount_0_skip (void)
13057 str = getenv ("TEST_ONLY");
13059 return strstr (str, "umount") == NULL;
13060 str = getenv ("SKIP_TEST_UMOUNT_0");
13061 if (str && strcmp (str, "1") == 0) return 1;
13062 str = getenv ("SKIP_TEST_UMOUNT");
13063 if (str && strcmp (str, "1") == 0) return 1;
13067 static int test_umount_0 (void)
13069 if (test_umount_0_skip ()) {
13070 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
13074 /* InitNone|InitEmpty for test_umount_0 */
13076 char device[] = "/dev/sda";
13078 suppress_error = 0;
13079 r = guestfs_blockdev_setrw (g, device);
13085 suppress_error = 0;
13086 r = guestfs_umount_all (g);
13092 suppress_error = 0;
13093 r = guestfs_lvm_remove_all (g);
13097 /* TestOutputListOfDevices for umount (0) */
13099 char device[] = "/dev/sda";
13100 char lines_0[] = ",";
13106 suppress_error = 0;
13107 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13112 char fstype[] = "ext2";
13113 char device[] = "/dev/sda1";
13115 suppress_error = 0;
13116 r = guestfs_mkfs (g, fstype, device);
13121 char device[] = "/dev/sda1";
13122 char mountpoint[] = "/";
13124 suppress_error = 0;
13125 r = guestfs_mount (g, device, mountpoint);
13132 suppress_error = 0;
13133 r = guestfs_mounts (g);
13137 fprintf (stderr, "test_umount_0: short list returned from command\n");
13142 char expected[] = "/dev/sda1";
13144 if (strcmp (r[0], expected) != 0) {
13145 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13149 if (r[1] != NULL) {
13150 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
13154 for (i = 0; r[i] != NULL; ++i)
13161 static int test_umount_1_skip (void)
13165 str = getenv ("TEST_ONLY");
13167 return strstr (str, "umount") == NULL;
13168 str = getenv ("SKIP_TEST_UMOUNT_1");
13169 if (str && strcmp (str, "1") == 0) return 1;
13170 str = getenv ("SKIP_TEST_UMOUNT");
13171 if (str && strcmp (str, "1") == 0) return 1;
13175 static int test_umount_1 (void)
13177 if (test_umount_1_skip ()) {
13178 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
13182 /* InitNone|InitEmpty for test_umount_1 */
13184 char device[] = "/dev/sda";
13186 suppress_error = 0;
13187 r = guestfs_blockdev_setrw (g, device);
13193 suppress_error = 0;
13194 r = guestfs_umount_all (g);
13200 suppress_error = 0;
13201 r = guestfs_lvm_remove_all (g);
13205 /* TestOutputList for umount (1) */
13207 char device[] = "/dev/sda";
13208 char lines_0[] = ",";
13214 suppress_error = 0;
13215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13220 char fstype[] = "ext2";
13221 char device[] = "/dev/sda1";
13223 suppress_error = 0;
13224 r = guestfs_mkfs (g, fstype, device);
13229 char device[] = "/dev/sda1";
13230 char mountpoint[] = "/";
13232 suppress_error = 0;
13233 r = guestfs_mount (g, device, mountpoint);
13238 char pathordevice[] = "/";
13240 suppress_error = 0;
13241 r = guestfs_umount (g, pathordevice);
13248 suppress_error = 0;
13249 r = guestfs_mounts (g);
13252 if (r[0] != NULL) {
13253 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
13257 for (i = 0; r[i] != NULL; ++i)
13264 static int test_write_file_0_skip (void)
13268 str = getenv ("TEST_ONLY");
13270 return strstr (str, "write_file") == NULL;
13271 str = getenv ("SKIP_TEST_WRITE_FILE_0");
13272 if (str && strcmp (str, "1") == 0) return 1;
13273 str = getenv ("SKIP_TEST_WRITE_FILE");
13274 if (str && strcmp (str, "1") == 0) return 1;
13278 static int test_write_file_0 (void)
13280 if (test_write_file_0_skip ()) {
13281 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
13285 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
13287 char device[] = "/dev/sda";
13289 suppress_error = 0;
13290 r = guestfs_blockdev_setrw (g, device);
13296 suppress_error = 0;
13297 r = guestfs_umount_all (g);
13303 suppress_error = 0;
13304 r = guestfs_lvm_remove_all (g);
13309 char device[] = "/dev/sda";
13310 char lines_0[] = ",";
13316 suppress_error = 0;
13317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13322 char fstype[] = "ext2";
13323 char device[] = "/dev/sda1";
13325 suppress_error = 0;
13326 r = guestfs_mkfs (g, fstype, device);
13331 char device[] = "/dev/sda1";
13332 char mountpoint[] = "/";
13334 suppress_error = 0;
13335 r = guestfs_mount (g, device, mountpoint);
13339 /* TestOutput for write_file (0) */
13340 char expected[] = "new file contents";
13342 char path[] = "/new";
13343 char content[] = "new file contents";
13345 suppress_error = 0;
13346 r = guestfs_write_file (g, path, content, 0);
13351 char path[] = "/new";
13353 suppress_error = 0;
13354 r = guestfs_cat (g, path);
13357 if (strcmp (r, expected) != 0) {
13358 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
13366 static int test_write_file_1_skip (void)
13370 str = getenv ("TEST_ONLY");
13372 return strstr (str, "write_file") == NULL;
13373 str = getenv ("SKIP_TEST_WRITE_FILE_1");
13374 if (str && strcmp (str, "1") == 0) return 1;
13375 str = getenv ("SKIP_TEST_WRITE_FILE");
13376 if (str && strcmp (str, "1") == 0) return 1;
13380 static int test_write_file_1 (void)
13382 if (test_write_file_1_skip ()) {
13383 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
13387 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
13389 char device[] = "/dev/sda";
13391 suppress_error = 0;
13392 r = guestfs_blockdev_setrw (g, device);
13398 suppress_error = 0;
13399 r = guestfs_umount_all (g);
13405 suppress_error = 0;
13406 r = guestfs_lvm_remove_all (g);
13411 char device[] = "/dev/sda";
13412 char lines_0[] = ",";
13418 suppress_error = 0;
13419 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13424 char fstype[] = "ext2";
13425 char device[] = "/dev/sda1";
13427 suppress_error = 0;
13428 r = guestfs_mkfs (g, fstype, device);
13433 char device[] = "/dev/sda1";
13434 char mountpoint[] = "/";
13436 suppress_error = 0;
13437 r = guestfs_mount (g, device, mountpoint);
13441 /* TestOutput for write_file (1) */
13442 char expected[] = "\nnew file contents\n";
13444 char path[] = "/new";
13445 char content[] = "\nnew file contents\n";
13447 suppress_error = 0;
13448 r = guestfs_write_file (g, path, content, 0);
13453 char path[] = "/new";
13455 suppress_error = 0;
13456 r = guestfs_cat (g, path);
13459 if (strcmp (r, expected) != 0) {
13460 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
13468 static int test_write_file_2_skip (void)
13472 str = getenv ("TEST_ONLY");
13474 return strstr (str, "write_file") == NULL;
13475 str = getenv ("SKIP_TEST_WRITE_FILE_2");
13476 if (str && strcmp (str, "1") == 0) return 1;
13477 str = getenv ("SKIP_TEST_WRITE_FILE");
13478 if (str && strcmp (str, "1") == 0) return 1;
13482 static int test_write_file_2 (void)
13484 if (test_write_file_2_skip ()) {
13485 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
13489 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
13491 char device[] = "/dev/sda";
13493 suppress_error = 0;
13494 r = guestfs_blockdev_setrw (g, device);
13500 suppress_error = 0;
13501 r = guestfs_umount_all (g);
13507 suppress_error = 0;
13508 r = guestfs_lvm_remove_all (g);
13513 char device[] = "/dev/sda";
13514 char lines_0[] = ",";
13520 suppress_error = 0;
13521 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13526 char fstype[] = "ext2";
13527 char device[] = "/dev/sda1";
13529 suppress_error = 0;
13530 r = guestfs_mkfs (g, fstype, device);
13535 char device[] = "/dev/sda1";
13536 char mountpoint[] = "/";
13538 suppress_error = 0;
13539 r = guestfs_mount (g, device, mountpoint);
13543 /* TestOutput for write_file (2) */
13544 char expected[] = "\n\n";
13546 char path[] = "/new";
13547 char content[] = "\n\n";
13549 suppress_error = 0;
13550 r = guestfs_write_file (g, path, content, 0);
13555 char path[] = "/new";
13557 suppress_error = 0;
13558 r = guestfs_cat (g, path);
13561 if (strcmp (r, expected) != 0) {
13562 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
13570 static int test_write_file_3_skip (void)
13574 str = getenv ("TEST_ONLY");
13576 return strstr (str, "write_file") == NULL;
13577 str = getenv ("SKIP_TEST_WRITE_FILE_3");
13578 if (str && strcmp (str, "1") == 0) return 1;
13579 str = getenv ("SKIP_TEST_WRITE_FILE");
13580 if (str && strcmp (str, "1") == 0) return 1;
13584 static int test_write_file_3 (void)
13586 if (test_write_file_3_skip ()) {
13587 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
13591 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
13593 char device[] = "/dev/sda";
13595 suppress_error = 0;
13596 r = guestfs_blockdev_setrw (g, device);
13602 suppress_error = 0;
13603 r = guestfs_umount_all (g);
13609 suppress_error = 0;
13610 r = guestfs_lvm_remove_all (g);
13615 char device[] = "/dev/sda";
13616 char lines_0[] = ",";
13622 suppress_error = 0;
13623 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13628 char fstype[] = "ext2";
13629 char device[] = "/dev/sda1";
13631 suppress_error = 0;
13632 r = guestfs_mkfs (g, fstype, device);
13637 char device[] = "/dev/sda1";
13638 char mountpoint[] = "/";
13640 suppress_error = 0;
13641 r = guestfs_mount (g, device, mountpoint);
13645 /* TestOutput for write_file (3) */
13646 char expected[] = "";
13648 char path[] = "/new";
13649 char content[] = "";
13651 suppress_error = 0;
13652 r = guestfs_write_file (g, path, content, 0);
13657 char path[] = "/new";
13659 suppress_error = 0;
13660 r = guestfs_cat (g, path);
13663 if (strcmp (r, expected) != 0) {
13664 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
13672 static int test_write_file_4_skip (void)
13676 str = getenv ("TEST_ONLY");
13678 return strstr (str, "write_file") == NULL;
13679 str = getenv ("SKIP_TEST_WRITE_FILE_4");
13680 if (str && strcmp (str, "1") == 0) return 1;
13681 str = getenv ("SKIP_TEST_WRITE_FILE");
13682 if (str && strcmp (str, "1") == 0) return 1;
13686 static int test_write_file_4 (void)
13688 if (test_write_file_4_skip ()) {
13689 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
13693 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
13695 char device[] = "/dev/sda";
13697 suppress_error = 0;
13698 r = guestfs_blockdev_setrw (g, device);
13704 suppress_error = 0;
13705 r = guestfs_umount_all (g);
13711 suppress_error = 0;
13712 r = guestfs_lvm_remove_all (g);
13717 char device[] = "/dev/sda";
13718 char lines_0[] = ",";
13724 suppress_error = 0;
13725 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13730 char fstype[] = "ext2";
13731 char device[] = "/dev/sda1";
13733 suppress_error = 0;
13734 r = guestfs_mkfs (g, fstype, device);
13739 char device[] = "/dev/sda1";
13740 char mountpoint[] = "/";
13742 suppress_error = 0;
13743 r = guestfs_mount (g, device, mountpoint);
13747 /* TestOutput for write_file (4) */
13748 char expected[] = "\n\n\n";
13750 char path[] = "/new";
13751 char content[] = "\n\n\n";
13753 suppress_error = 0;
13754 r = guestfs_write_file (g, path, content, 0);
13759 char path[] = "/new";
13761 suppress_error = 0;
13762 r = guestfs_cat (g, path);
13765 if (strcmp (r, expected) != 0) {
13766 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
13774 static int test_write_file_5_skip (void)
13778 str = getenv ("TEST_ONLY");
13780 return strstr (str, "write_file") == NULL;
13781 str = getenv ("SKIP_TEST_WRITE_FILE_5");
13782 if (str && strcmp (str, "1") == 0) return 1;
13783 str = getenv ("SKIP_TEST_WRITE_FILE");
13784 if (str && strcmp (str, "1") == 0) return 1;
13788 static int test_write_file_5 (void)
13790 if (test_write_file_5_skip ()) {
13791 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
13795 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
13797 char device[] = "/dev/sda";
13799 suppress_error = 0;
13800 r = guestfs_blockdev_setrw (g, device);
13806 suppress_error = 0;
13807 r = guestfs_umount_all (g);
13813 suppress_error = 0;
13814 r = guestfs_lvm_remove_all (g);
13819 char device[] = "/dev/sda";
13820 char lines_0[] = ",";
13826 suppress_error = 0;
13827 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13832 char fstype[] = "ext2";
13833 char device[] = "/dev/sda1";
13835 suppress_error = 0;
13836 r = guestfs_mkfs (g, fstype, device);
13841 char device[] = "/dev/sda1";
13842 char mountpoint[] = "/";
13844 suppress_error = 0;
13845 r = guestfs_mount (g, device, mountpoint);
13849 /* TestOutput for write_file (5) */
13850 char expected[] = "\n";
13852 char path[] = "/new";
13853 char content[] = "\n";
13855 suppress_error = 0;
13856 r = guestfs_write_file (g, path, content, 0);
13861 char path[] = "/new";
13863 suppress_error = 0;
13864 r = guestfs_cat (g, path);
13867 if (strcmp (r, expected) != 0) {
13868 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
13876 static int test_mkfs_0_skip (void)
13880 str = getenv ("TEST_ONLY");
13882 return strstr (str, "mkfs") == NULL;
13883 str = getenv ("SKIP_TEST_MKFS_0");
13884 if (str && strcmp (str, "1") == 0) return 1;
13885 str = getenv ("SKIP_TEST_MKFS");
13886 if (str && strcmp (str, "1") == 0) return 1;
13890 static int test_mkfs_0 (void)
13892 if (test_mkfs_0_skip ()) {
13893 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
13897 /* InitNone|InitEmpty for test_mkfs_0 */
13899 char device[] = "/dev/sda";
13901 suppress_error = 0;
13902 r = guestfs_blockdev_setrw (g, device);
13908 suppress_error = 0;
13909 r = guestfs_umount_all (g);
13915 suppress_error = 0;
13916 r = guestfs_lvm_remove_all (g);
13920 /* TestOutput for mkfs (0) */
13921 char expected[] = "new file contents";
13923 char device[] = "/dev/sda";
13924 char lines_0[] = ",";
13930 suppress_error = 0;
13931 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13936 char fstype[] = "ext2";
13937 char device[] = "/dev/sda1";
13939 suppress_error = 0;
13940 r = guestfs_mkfs (g, fstype, device);
13945 char device[] = "/dev/sda1";
13946 char mountpoint[] = "/";
13948 suppress_error = 0;
13949 r = guestfs_mount (g, device, mountpoint);
13954 char path[] = "/new";
13955 char content[] = "new file contents";
13957 suppress_error = 0;
13958 r = guestfs_write_file (g, path, content, 0);
13963 char path[] = "/new";
13965 suppress_error = 0;
13966 r = guestfs_cat (g, path);
13969 if (strcmp (r, expected) != 0) {
13970 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
13978 static int test_lvcreate_0_skip (void)
13982 str = getenv ("TEST_ONLY");
13984 return strstr (str, "lvcreate") == NULL;
13985 str = getenv ("SKIP_TEST_LVCREATE_0");
13986 if (str && strcmp (str, "1") == 0) return 1;
13987 str = getenv ("SKIP_TEST_LVCREATE");
13988 if (str && strcmp (str, "1") == 0) return 1;
13992 static int test_lvcreate_0 (void)
13994 if (test_lvcreate_0_skip ()) {
13995 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
13999 /* InitNone|InitEmpty for test_lvcreate_0 */
14001 char device[] = "/dev/sda";
14003 suppress_error = 0;
14004 r = guestfs_blockdev_setrw (g, device);
14010 suppress_error = 0;
14011 r = guestfs_umount_all (g);
14017 suppress_error = 0;
14018 r = guestfs_lvm_remove_all (g);
14022 /* TestOutputList for lvcreate (0) */
14024 char device[] = "/dev/sda";
14025 char lines_0[] = ",10";
14026 char lines_1[] = ",20";
14027 char lines_2[] = ",";
14035 suppress_error = 0;
14036 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14041 char device[] = "/dev/sda1";
14043 suppress_error = 0;
14044 r = guestfs_pvcreate (g, device);
14049 char device[] = "/dev/sda2";
14051 suppress_error = 0;
14052 r = guestfs_pvcreate (g, device);
14057 char device[] = "/dev/sda3";
14059 suppress_error = 0;
14060 r = guestfs_pvcreate (g, device);
14065 char volgroup[] = "VG1";
14066 char physvols_0[] = "/dev/sda1";
14067 char physvols_1[] = "/dev/sda2";
14068 char *physvols[] = {
14074 suppress_error = 0;
14075 r = guestfs_vgcreate (g, volgroup, physvols);
14080 char volgroup[] = "VG2";
14081 char physvols_0[] = "/dev/sda3";
14082 char *physvols[] = {
14087 suppress_error = 0;
14088 r = guestfs_vgcreate (g, volgroup, physvols);
14093 char logvol[] = "LV1";
14094 char volgroup[] = "VG1";
14096 suppress_error = 0;
14097 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14102 char logvol[] = "LV2";
14103 char volgroup[] = "VG1";
14105 suppress_error = 0;
14106 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14111 char logvol[] = "LV3";
14112 char volgroup[] = "VG2";
14114 suppress_error = 0;
14115 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14120 char logvol[] = "LV4";
14121 char volgroup[] = "VG2";
14123 suppress_error = 0;
14124 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14129 char logvol[] = "LV5";
14130 char volgroup[] = "VG2";
14132 suppress_error = 0;
14133 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14140 suppress_error = 0;
14141 r = guestfs_lvs (g);
14145 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14150 char expected[] = "/dev/VG1/LV1";
14151 if (strcmp (r[0], expected) != 0) {
14152 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14157 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14162 char expected[] = "/dev/VG1/LV2";
14163 if (strcmp (r[1], expected) != 0) {
14164 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14169 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14174 char expected[] = "/dev/VG2/LV3";
14175 if (strcmp (r[2], expected) != 0) {
14176 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14181 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14186 char expected[] = "/dev/VG2/LV4";
14187 if (strcmp (r[3], expected) != 0) {
14188 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
14193 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
14198 char expected[] = "/dev/VG2/LV5";
14199 if (strcmp (r[4], expected) != 0) {
14200 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
14204 if (r[5] != NULL) {
14205 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
14209 for (i = 0; r[i] != NULL; ++i)
14216 static int test_vgcreate_0_skip (void)
14220 str = getenv ("TEST_ONLY");
14222 return strstr (str, "vgcreate") == NULL;
14223 str = getenv ("SKIP_TEST_VGCREATE_0");
14224 if (str && strcmp (str, "1") == 0) return 1;
14225 str = getenv ("SKIP_TEST_VGCREATE");
14226 if (str && strcmp (str, "1") == 0) return 1;
14230 static int test_vgcreate_0 (void)
14232 if (test_vgcreate_0_skip ()) {
14233 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
14237 /* InitNone|InitEmpty for test_vgcreate_0 */
14239 char device[] = "/dev/sda";
14241 suppress_error = 0;
14242 r = guestfs_blockdev_setrw (g, device);
14248 suppress_error = 0;
14249 r = guestfs_umount_all (g);
14255 suppress_error = 0;
14256 r = guestfs_lvm_remove_all (g);
14260 /* TestOutputList for vgcreate (0) */
14262 char device[] = "/dev/sda";
14263 char lines_0[] = ",10";
14264 char lines_1[] = ",20";
14265 char lines_2[] = ",";
14273 suppress_error = 0;
14274 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14279 char device[] = "/dev/sda1";
14281 suppress_error = 0;
14282 r = guestfs_pvcreate (g, device);
14287 char device[] = "/dev/sda2";
14289 suppress_error = 0;
14290 r = guestfs_pvcreate (g, device);
14295 char device[] = "/dev/sda3";
14297 suppress_error = 0;
14298 r = guestfs_pvcreate (g, device);
14303 char volgroup[] = "VG1";
14304 char physvols_0[] = "/dev/sda1";
14305 char physvols_1[] = "/dev/sda2";
14306 char *physvols[] = {
14312 suppress_error = 0;
14313 r = guestfs_vgcreate (g, volgroup, physvols);
14318 char volgroup[] = "VG2";
14319 char physvols_0[] = "/dev/sda3";
14320 char *physvols[] = {
14325 suppress_error = 0;
14326 r = guestfs_vgcreate (g, volgroup, physvols);
14333 suppress_error = 0;
14334 r = guestfs_vgs (g);
14338 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14343 char expected[] = "VG1";
14344 if (strcmp (r[0], expected) != 0) {
14345 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14350 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
14355 char expected[] = "VG2";
14356 if (strcmp (r[1], expected) != 0) {
14357 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14361 if (r[2] != NULL) {
14362 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
14366 for (i = 0; r[i] != NULL; ++i)
14373 static int test_pvcreate_0_skip (void)
14377 str = getenv ("TEST_ONLY");
14379 return strstr (str, "pvcreate") == NULL;
14380 str = getenv ("SKIP_TEST_PVCREATE_0");
14381 if (str && strcmp (str, "1") == 0) return 1;
14382 str = getenv ("SKIP_TEST_PVCREATE");
14383 if (str && strcmp (str, "1") == 0) return 1;
14387 static int test_pvcreate_0 (void)
14389 if (test_pvcreate_0_skip ()) {
14390 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
14394 /* InitNone|InitEmpty for test_pvcreate_0 */
14396 char device[] = "/dev/sda";
14398 suppress_error = 0;
14399 r = guestfs_blockdev_setrw (g, device);
14405 suppress_error = 0;
14406 r = guestfs_umount_all (g);
14412 suppress_error = 0;
14413 r = guestfs_lvm_remove_all (g);
14417 /* TestOutputListOfDevices for pvcreate (0) */
14419 char device[] = "/dev/sda";
14420 char lines_0[] = ",10";
14421 char lines_1[] = ",20";
14422 char lines_2[] = ",";
14430 suppress_error = 0;
14431 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14436 char device[] = "/dev/sda1";
14438 suppress_error = 0;
14439 r = guestfs_pvcreate (g, device);
14444 char device[] = "/dev/sda2";
14446 suppress_error = 0;
14447 r = guestfs_pvcreate (g, device);
14452 char device[] = "/dev/sda3";
14454 suppress_error = 0;
14455 r = guestfs_pvcreate (g, device);
14462 suppress_error = 0;
14463 r = guestfs_pvs (g);
14467 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14472 char expected[] = "/dev/sda1";
14474 if (strcmp (r[0], expected) != 0) {
14475 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14480 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14485 char expected[] = "/dev/sda2";
14487 if (strcmp (r[1], expected) != 0) {
14488 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14493 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
14498 char expected[] = "/dev/sda3";
14500 if (strcmp (r[2], expected) != 0) {
14501 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14505 if (r[3] != NULL) {
14506 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
14510 for (i = 0; r[i] != NULL; ++i)
14517 static int test_is_dir_0_skip (void)
14521 str = getenv ("TEST_ONLY");
14523 return strstr (str, "is_dir") == NULL;
14524 str = getenv ("SKIP_TEST_IS_DIR_0");
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_0 (void)
14533 if (test_is_dir_0_skip ()) {
14534 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
14538 /* InitBasicFS for test_is_dir_0: 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 /* TestOutputFalse for is_dir (0) */
14594 char path[] = "/new";
14596 suppress_error = 0;
14597 r = guestfs_touch (g, path);
14602 char path[] = "/new";
14604 suppress_error = 0;
14605 r = guestfs_is_dir (g, path);
14609 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
14616 static int test_is_dir_1_skip (void)
14620 str = getenv ("TEST_ONLY");
14622 return strstr (str, "is_dir") == NULL;
14623 str = getenv ("SKIP_TEST_IS_DIR_1");
14624 if (str && strcmp (str, "1") == 0) return 1;
14625 str = getenv ("SKIP_TEST_IS_DIR");
14626 if (str && strcmp (str, "1") == 0) return 1;
14630 static int test_is_dir_1 (void)
14632 if (test_is_dir_1_skip ()) {
14633 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
14637 /* InitBasicFS for test_is_dir_1: 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_dir (1) */
14693 char path[] = "/new";
14695 suppress_error = 0;
14696 r = guestfs_mkdir (g, path);
14701 char path[] = "/new";
14703 suppress_error = 0;
14704 r = guestfs_is_dir (g, path);
14708 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
14715 static int test_is_file_0_skip (void)
14719 str = getenv ("TEST_ONLY");
14721 return strstr (str, "is_file") == NULL;
14722 str = getenv ("SKIP_TEST_IS_FILE_0");
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_0 (void)
14731 if (test_is_file_0_skip ()) {
14732 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
14736 /* InitBasicFS for test_is_file_0: 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 /* TestOutputTrue for is_file (0) */
14792 char path[] = "/new";
14794 suppress_error = 0;
14795 r = guestfs_touch (g, path);
14800 char path[] = "/new";
14802 suppress_error = 0;
14803 r = guestfs_is_file (g, path);
14807 fprintf (stderr, "test_is_file_0: expected true, got false\n");
14814 static int test_is_file_1_skip (void)
14818 str = getenv ("TEST_ONLY");
14820 return strstr (str, "is_file") == NULL;
14821 str = getenv ("SKIP_TEST_IS_FILE_1");
14822 if (str && strcmp (str, "1") == 0) return 1;
14823 str = getenv ("SKIP_TEST_IS_FILE");
14824 if (str && strcmp (str, "1") == 0) return 1;
14828 static int test_is_file_1 (void)
14830 if (test_is_file_1_skip ()) {
14831 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
14835 /* InitBasicFS for test_is_file_1: 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 /* TestOutputFalse for is_file (1) */
14891 char path[] = "/new";
14893 suppress_error = 0;
14894 r = guestfs_mkdir (g, path);
14899 char path[] = "/new";
14901 suppress_error = 0;
14902 r = guestfs_is_file (g, path);
14906 fprintf (stderr, "test_is_file_1: expected false, got true\n");
14913 static int test_exists_0_skip (void)
14917 str = getenv ("TEST_ONLY");
14919 return strstr (str, "exists") == NULL;
14920 str = getenv ("SKIP_TEST_EXISTS_0");
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_0 (void)
14929 if (test_exists_0_skip ()) {
14930 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
14934 /* InitBasicFS for test_exists_0: 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 (0) */
14990 char path[] = "/new";
14992 suppress_error = 0;
14993 r = guestfs_touch (g, path);
14998 char path[] = "/new";
15000 suppress_error = 0;
15001 r = guestfs_exists (g, path);
15005 fprintf (stderr, "test_exists_0: expected true, got false\n");
15012 static int test_exists_1_skip (void)
15016 str = getenv ("TEST_ONLY");
15018 return strstr (str, "exists") == NULL;
15019 str = getenv ("SKIP_TEST_EXISTS_1");
15020 if (str && strcmp (str, "1") == 0) return 1;
15021 str = getenv ("SKIP_TEST_EXISTS");
15022 if (str && strcmp (str, "1") == 0) return 1;
15026 static int test_exists_1 (void)
15028 if (test_exists_1_skip ()) {
15029 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
15033 /* InitBasicFS for test_exists_1: 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 exists (1) */
15089 char path[] = "/new";
15091 suppress_error = 0;
15092 r = guestfs_mkdir (g, path);
15097 char path[] = "/new";
15099 suppress_error = 0;
15100 r = guestfs_exists (g, path);
15104 fprintf (stderr, "test_exists_1: expected true, got false\n");
15111 static int test_mkdir_p_0_skip (void)
15115 str = getenv ("TEST_ONLY");
15117 return strstr (str, "mkdir_p") == NULL;
15118 str = getenv ("SKIP_TEST_MKDIR_P_0");
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_0 (void)
15127 if (test_mkdir_p_0_skip ()) {
15128 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
15132 /* InitBasicFS for test_mkdir_p_0: 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 (0) */
15188 char path[] = "/new/foo/bar";
15190 suppress_error = 0;
15191 r = guestfs_mkdir_p (g, path);
15196 char path[] = "/new/foo/bar";
15198 suppress_error = 0;
15199 r = guestfs_is_dir (g, path);
15203 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
15210 static int test_mkdir_p_1_skip (void)
15214 str = getenv ("TEST_ONLY");
15216 return strstr (str, "mkdir_p") == NULL;
15217 str = getenv ("SKIP_TEST_MKDIR_P_1");
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_1 (void)
15226 if (test_mkdir_p_1_skip ()) {
15227 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
15231 /* InitBasicFS for test_mkdir_p_1: 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 (1) */
15287 char path[] = "/new/foo/bar";
15289 suppress_error = 0;
15290 r = guestfs_mkdir_p (g, path);
15295 char path[] = "/new/foo";
15297 suppress_error = 0;
15298 r = guestfs_is_dir (g, path);
15302 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
15309 static int test_mkdir_p_2_skip (void)
15313 str = getenv ("TEST_ONLY");
15315 return strstr (str, "mkdir_p") == NULL;
15316 str = getenv ("SKIP_TEST_MKDIR_P_2");
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_2 (void)
15325 if (test_mkdir_p_2_skip ()) {
15326 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
15330 /* InitBasicFS for test_mkdir_p_2: 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 /* TestOutputTrue for mkdir_p (2) */
15386 char path[] = "/new/foo/bar";
15388 suppress_error = 0;
15389 r = guestfs_mkdir_p (g, path);
15394 char path[] = "/new";
15396 suppress_error = 0;
15397 r = guestfs_is_dir (g, path);
15401 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
15408 static int test_mkdir_p_3_skip (void)
15412 str = getenv ("TEST_ONLY");
15414 return strstr (str, "mkdir_p") == NULL;
15415 str = getenv ("SKIP_TEST_MKDIR_P_3");
15416 if (str && strcmp (str, "1") == 0) return 1;
15417 str = getenv ("SKIP_TEST_MKDIR_P");
15418 if (str && strcmp (str, "1") == 0) return 1;
15422 static int test_mkdir_p_3 (void)
15424 if (test_mkdir_p_3_skip ()) {
15425 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
15429 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
15431 char device[] = "/dev/sda";
15433 suppress_error = 0;
15434 r = guestfs_blockdev_setrw (g, device);
15440 suppress_error = 0;
15441 r = guestfs_umount_all (g);
15447 suppress_error = 0;
15448 r = guestfs_lvm_remove_all (g);
15453 char device[] = "/dev/sda";
15454 char lines_0[] = ",";
15460 suppress_error = 0;
15461 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15466 char fstype[] = "ext2";
15467 char device[] = "/dev/sda1";
15469 suppress_error = 0;
15470 r = guestfs_mkfs (g, fstype, device);
15475 char device[] = "/dev/sda1";
15476 char mountpoint[] = "/";
15478 suppress_error = 0;
15479 r = guestfs_mount (g, device, mountpoint);
15483 /* TestRun for mkdir_p (3) */
15485 char path[] = "/new";
15487 suppress_error = 0;
15488 r = guestfs_mkdir (g, path);
15493 char path[] = "/new";
15495 suppress_error = 0;
15496 r = guestfs_mkdir_p (g, path);
15503 static int test_mkdir_p_4_skip (void)
15507 str = getenv ("TEST_ONLY");
15509 return strstr (str, "mkdir_p") == NULL;
15510 str = getenv ("SKIP_TEST_MKDIR_P_4");
15511 if (str && strcmp (str, "1") == 0) return 1;
15512 str = getenv ("SKIP_TEST_MKDIR_P");
15513 if (str && strcmp (str, "1") == 0) return 1;
15517 static int test_mkdir_p_4 (void)
15519 if (test_mkdir_p_4_skip ()) {
15520 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
15524 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
15526 char device[] = "/dev/sda";
15528 suppress_error = 0;
15529 r = guestfs_blockdev_setrw (g, device);
15535 suppress_error = 0;
15536 r = guestfs_umount_all (g);
15542 suppress_error = 0;
15543 r = guestfs_lvm_remove_all (g);
15548 char device[] = "/dev/sda";
15549 char lines_0[] = ",";
15555 suppress_error = 0;
15556 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15561 char fstype[] = "ext2";
15562 char device[] = "/dev/sda1";
15564 suppress_error = 0;
15565 r = guestfs_mkfs (g, fstype, device);
15570 char device[] = "/dev/sda1";
15571 char mountpoint[] = "/";
15573 suppress_error = 0;
15574 r = guestfs_mount (g, device, mountpoint);
15578 /* TestLastFail for mkdir_p (4) */
15580 char path[] = "/new";
15582 suppress_error = 0;
15583 r = guestfs_touch (g, path);
15588 char path[] = "/new";
15590 suppress_error = 1;
15591 r = guestfs_mkdir_p (g, path);
15598 static int test_mkdir_0_skip (void)
15602 str = getenv ("TEST_ONLY");
15604 return strstr (str, "mkdir") == NULL;
15605 str = getenv ("SKIP_TEST_MKDIR_0");
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_0 (void)
15614 if (test_mkdir_0_skip ()) {
15615 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
15619 /* InitBasicFS for test_mkdir_0: 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 /* TestOutputTrue for mkdir (0) */
15675 char path[] = "/new";
15677 suppress_error = 0;
15678 r = guestfs_mkdir (g, path);
15683 char path[] = "/new";
15685 suppress_error = 0;
15686 r = guestfs_is_dir (g, path);
15690 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
15697 static int test_mkdir_1_skip (void)
15701 str = getenv ("TEST_ONLY");
15703 return strstr (str, "mkdir") == NULL;
15704 str = getenv ("SKIP_TEST_MKDIR_1");
15705 if (str && strcmp (str, "1") == 0) return 1;
15706 str = getenv ("SKIP_TEST_MKDIR");
15707 if (str && strcmp (str, "1") == 0) return 1;
15711 static int test_mkdir_1 (void)
15713 if (test_mkdir_1_skip ()) {
15714 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
15718 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
15720 char device[] = "/dev/sda";
15722 suppress_error = 0;
15723 r = guestfs_blockdev_setrw (g, device);
15729 suppress_error = 0;
15730 r = guestfs_umount_all (g);
15736 suppress_error = 0;
15737 r = guestfs_lvm_remove_all (g);
15742 char device[] = "/dev/sda";
15743 char lines_0[] = ",";
15749 suppress_error = 0;
15750 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15755 char fstype[] = "ext2";
15756 char device[] = "/dev/sda1";
15758 suppress_error = 0;
15759 r = guestfs_mkfs (g, fstype, device);
15764 char device[] = "/dev/sda1";
15765 char mountpoint[] = "/";
15767 suppress_error = 0;
15768 r = guestfs_mount (g, device, mountpoint);
15772 /* TestLastFail for mkdir (1) */
15774 char path[] = "/new/foo/bar";
15776 suppress_error = 1;
15777 r = guestfs_mkdir (g, path);
15784 static int test_rm_rf_0_skip (void)
15788 str = getenv ("TEST_ONLY");
15790 return strstr (str, "rm_rf") == NULL;
15791 str = getenv ("SKIP_TEST_RM_RF_0");
15792 if (str && strcmp (str, "1") == 0) return 1;
15793 str = getenv ("SKIP_TEST_RM_RF");
15794 if (str && strcmp (str, "1") == 0) return 1;
15798 static int test_rm_rf_0 (void)
15800 if (test_rm_rf_0_skip ()) {
15801 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
15805 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
15807 char device[] = "/dev/sda";
15809 suppress_error = 0;
15810 r = guestfs_blockdev_setrw (g, device);
15816 suppress_error = 0;
15817 r = guestfs_umount_all (g);
15823 suppress_error = 0;
15824 r = guestfs_lvm_remove_all (g);
15829 char device[] = "/dev/sda";
15830 char lines_0[] = ",";
15836 suppress_error = 0;
15837 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15842 char fstype[] = "ext2";
15843 char device[] = "/dev/sda1";
15845 suppress_error = 0;
15846 r = guestfs_mkfs (g, fstype, device);
15851 char device[] = "/dev/sda1";
15852 char mountpoint[] = "/";
15854 suppress_error = 0;
15855 r = guestfs_mount (g, device, mountpoint);
15859 /* TestOutputFalse for rm_rf (0) */
15861 char path[] = "/new";
15863 suppress_error = 0;
15864 r = guestfs_mkdir (g, path);
15869 char path[] = "/new/foo";
15871 suppress_error = 0;
15872 r = guestfs_mkdir (g, path);
15877 char path[] = "/new/foo/bar";
15879 suppress_error = 0;
15880 r = guestfs_touch (g, path);
15885 char path[] = "/new";
15887 suppress_error = 0;
15888 r = guestfs_rm_rf (g, path);
15893 char path[] = "/new";
15895 suppress_error = 0;
15896 r = guestfs_exists (g, path);
15900 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
15907 static int test_rmdir_0_skip (void)
15911 str = getenv ("TEST_ONLY");
15913 return strstr (str, "rmdir") == NULL;
15914 str = getenv ("SKIP_TEST_RMDIR_0");
15915 if (str && strcmp (str, "1") == 0) return 1;
15916 str = getenv ("SKIP_TEST_RMDIR");
15917 if (str && strcmp (str, "1") == 0) return 1;
15921 static int test_rmdir_0 (void)
15923 if (test_rmdir_0_skip ()) {
15924 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
15928 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
15930 char device[] = "/dev/sda";
15932 suppress_error = 0;
15933 r = guestfs_blockdev_setrw (g, device);
15939 suppress_error = 0;
15940 r = guestfs_umount_all (g);
15946 suppress_error = 0;
15947 r = guestfs_lvm_remove_all (g);
15952 char device[] = "/dev/sda";
15953 char lines_0[] = ",";
15959 suppress_error = 0;
15960 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15965 char fstype[] = "ext2";
15966 char device[] = "/dev/sda1";
15968 suppress_error = 0;
15969 r = guestfs_mkfs (g, fstype, device);
15974 char device[] = "/dev/sda1";
15975 char mountpoint[] = "/";
15977 suppress_error = 0;
15978 r = guestfs_mount (g, device, mountpoint);
15982 /* TestRun for rmdir (0) */
15984 char path[] = "/new";
15986 suppress_error = 0;
15987 r = guestfs_mkdir (g, path);
15992 char path[] = "/new";
15994 suppress_error = 0;
15995 r = guestfs_rmdir (g, path);
16002 static int test_rmdir_1_skip (void)
16006 str = getenv ("TEST_ONLY");
16008 return strstr (str, "rmdir") == NULL;
16009 str = getenv ("SKIP_TEST_RMDIR_1");
16010 if (str && strcmp (str, "1") == 0) return 1;
16011 str = getenv ("SKIP_TEST_RMDIR");
16012 if (str && strcmp (str, "1") == 0) return 1;
16016 static int test_rmdir_1 (void)
16018 if (test_rmdir_1_skip ()) {
16019 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
16023 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
16025 char device[] = "/dev/sda";
16027 suppress_error = 0;
16028 r = guestfs_blockdev_setrw (g, device);
16034 suppress_error = 0;
16035 r = guestfs_umount_all (g);
16041 suppress_error = 0;
16042 r = guestfs_lvm_remove_all (g);
16047 char device[] = "/dev/sda";
16048 char lines_0[] = ",";
16054 suppress_error = 0;
16055 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16060 char fstype[] = "ext2";
16061 char device[] = "/dev/sda1";
16063 suppress_error = 0;
16064 r = guestfs_mkfs (g, fstype, device);
16069 char device[] = "/dev/sda1";
16070 char mountpoint[] = "/";
16072 suppress_error = 0;
16073 r = guestfs_mount (g, device, mountpoint);
16077 /* TestLastFail for rmdir (1) */
16079 char path[] = "/new";
16081 suppress_error = 1;
16082 r = guestfs_rmdir (g, path);
16089 static int test_rmdir_2_skip (void)
16093 str = getenv ("TEST_ONLY");
16095 return strstr (str, "rmdir") == NULL;
16096 str = getenv ("SKIP_TEST_RMDIR_2");
16097 if (str && strcmp (str, "1") == 0) return 1;
16098 str = getenv ("SKIP_TEST_RMDIR");
16099 if (str && strcmp (str, "1") == 0) return 1;
16103 static int test_rmdir_2 (void)
16105 if (test_rmdir_2_skip ()) {
16106 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
16110 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
16112 char device[] = "/dev/sda";
16114 suppress_error = 0;
16115 r = guestfs_blockdev_setrw (g, device);
16121 suppress_error = 0;
16122 r = guestfs_umount_all (g);
16128 suppress_error = 0;
16129 r = guestfs_lvm_remove_all (g);
16134 char device[] = "/dev/sda";
16135 char lines_0[] = ",";
16141 suppress_error = 0;
16142 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16147 char fstype[] = "ext2";
16148 char device[] = "/dev/sda1";
16150 suppress_error = 0;
16151 r = guestfs_mkfs (g, fstype, device);
16156 char device[] = "/dev/sda1";
16157 char mountpoint[] = "/";
16159 suppress_error = 0;
16160 r = guestfs_mount (g, device, mountpoint);
16164 /* TestLastFail for rmdir (2) */
16166 char path[] = "/new";
16168 suppress_error = 0;
16169 r = guestfs_touch (g, path);
16174 char path[] = "/new";
16176 suppress_error = 1;
16177 r = guestfs_rmdir (g, path);
16184 static int test_rm_0_skip (void)
16188 str = getenv ("TEST_ONLY");
16190 return strstr (str, "rm") == NULL;
16191 str = getenv ("SKIP_TEST_RM_0");
16192 if (str && strcmp (str, "1") == 0) return 1;
16193 str = getenv ("SKIP_TEST_RM");
16194 if (str && strcmp (str, "1") == 0) return 1;
16198 static int test_rm_0 (void)
16200 if (test_rm_0_skip ()) {
16201 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
16205 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
16207 char device[] = "/dev/sda";
16209 suppress_error = 0;
16210 r = guestfs_blockdev_setrw (g, device);
16216 suppress_error = 0;
16217 r = guestfs_umount_all (g);
16223 suppress_error = 0;
16224 r = guestfs_lvm_remove_all (g);
16229 char device[] = "/dev/sda";
16230 char lines_0[] = ",";
16236 suppress_error = 0;
16237 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16242 char fstype[] = "ext2";
16243 char device[] = "/dev/sda1";
16245 suppress_error = 0;
16246 r = guestfs_mkfs (g, fstype, device);
16251 char device[] = "/dev/sda1";
16252 char mountpoint[] = "/";
16254 suppress_error = 0;
16255 r = guestfs_mount (g, device, mountpoint);
16259 /* TestRun for rm (0) */
16261 char path[] = "/new";
16263 suppress_error = 0;
16264 r = guestfs_touch (g, path);
16269 char path[] = "/new";
16271 suppress_error = 0;
16272 r = guestfs_rm (g, path);
16279 static int test_rm_1_skip (void)
16283 str = getenv ("TEST_ONLY");
16285 return strstr (str, "rm") == NULL;
16286 str = getenv ("SKIP_TEST_RM_1");
16287 if (str && strcmp (str, "1") == 0) return 1;
16288 str = getenv ("SKIP_TEST_RM");
16289 if (str && strcmp (str, "1") == 0) return 1;
16293 static int test_rm_1 (void)
16295 if (test_rm_1_skip ()) {
16296 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
16300 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
16302 char device[] = "/dev/sda";
16304 suppress_error = 0;
16305 r = guestfs_blockdev_setrw (g, device);
16311 suppress_error = 0;
16312 r = guestfs_umount_all (g);
16318 suppress_error = 0;
16319 r = guestfs_lvm_remove_all (g);
16324 char device[] = "/dev/sda";
16325 char lines_0[] = ",";
16331 suppress_error = 0;
16332 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16337 char fstype[] = "ext2";
16338 char device[] = "/dev/sda1";
16340 suppress_error = 0;
16341 r = guestfs_mkfs (g, fstype, device);
16346 char device[] = "/dev/sda1";
16347 char mountpoint[] = "/";
16349 suppress_error = 0;
16350 r = guestfs_mount (g, device, mountpoint);
16354 /* TestLastFail for rm (1) */
16356 char path[] = "/new";
16358 suppress_error = 1;
16359 r = guestfs_rm (g, path);
16366 static int test_rm_2_skip (void)
16370 str = getenv ("TEST_ONLY");
16372 return strstr (str, "rm") == NULL;
16373 str = getenv ("SKIP_TEST_RM_2");
16374 if (str && strcmp (str, "1") == 0) return 1;
16375 str = getenv ("SKIP_TEST_RM");
16376 if (str && strcmp (str, "1") == 0) return 1;
16380 static int test_rm_2 (void)
16382 if (test_rm_2_skip ()) {
16383 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
16387 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
16389 char device[] = "/dev/sda";
16391 suppress_error = 0;
16392 r = guestfs_blockdev_setrw (g, device);
16398 suppress_error = 0;
16399 r = guestfs_umount_all (g);
16405 suppress_error = 0;
16406 r = guestfs_lvm_remove_all (g);
16411 char device[] = "/dev/sda";
16412 char lines_0[] = ",";
16418 suppress_error = 0;
16419 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16424 char fstype[] = "ext2";
16425 char device[] = "/dev/sda1";
16427 suppress_error = 0;
16428 r = guestfs_mkfs (g, fstype, device);
16433 char device[] = "/dev/sda1";
16434 char mountpoint[] = "/";
16436 suppress_error = 0;
16437 r = guestfs_mount (g, device, mountpoint);
16441 /* TestLastFail for rm (2) */
16443 char path[] = "/new";
16445 suppress_error = 0;
16446 r = guestfs_mkdir (g, path);
16451 char path[] = "/new";
16453 suppress_error = 1;
16454 r = guestfs_rm (g, path);
16461 static int test_read_lines_0_skip (void)
16465 str = getenv ("TEST_ONLY");
16467 return strstr (str, "read_lines") == NULL;
16468 str = getenv ("SKIP_TEST_READ_LINES_0");
16469 if (str && strcmp (str, "1") == 0) return 1;
16470 str = getenv ("SKIP_TEST_READ_LINES");
16471 if (str && strcmp (str, "1") == 0) return 1;
16475 static int test_read_lines_0 (void)
16477 if (test_read_lines_0_skip ()) {
16478 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
16482 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
16484 char device[] = "/dev/sda";
16486 suppress_error = 0;
16487 r = guestfs_blockdev_setrw (g, device);
16493 suppress_error = 0;
16494 r = guestfs_umount_all (g);
16500 suppress_error = 0;
16501 r = guestfs_lvm_remove_all (g);
16506 char device[] = "/dev/sda";
16507 char lines_0[] = ",";
16513 suppress_error = 0;
16514 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16519 char fstype[] = "ext2";
16520 char device[] = "/dev/sda1";
16522 suppress_error = 0;
16523 r = guestfs_mkfs (g, fstype, device);
16528 char device[] = "/dev/sda1";
16529 char mountpoint[] = "/";
16531 suppress_error = 0;
16532 r = guestfs_mount (g, device, mountpoint);
16536 /* TestOutputList for read_lines (0) */
16538 char path[] = "/new";
16539 char content[] = "line1\r\nline2\nline3";
16541 suppress_error = 0;
16542 r = guestfs_write_file (g, path, content, 0);
16547 char path[] = "/new";
16550 suppress_error = 0;
16551 r = guestfs_read_lines (g, path);
16555 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16560 char expected[] = "line1";
16561 if (strcmp (r[0], expected) != 0) {
16562 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16567 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16572 char expected[] = "line2";
16573 if (strcmp (r[1], expected) != 0) {
16574 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16579 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
16584 char expected[] = "line3";
16585 if (strcmp (r[2], expected) != 0) {
16586 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16590 if (r[3] != NULL) {
16591 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
16595 for (i = 0; r[i] != NULL; ++i)
16602 static int test_read_lines_1_skip (void)
16606 str = getenv ("TEST_ONLY");
16608 return strstr (str, "read_lines") == NULL;
16609 str = getenv ("SKIP_TEST_READ_LINES_1");
16610 if (str && strcmp (str, "1") == 0) return 1;
16611 str = getenv ("SKIP_TEST_READ_LINES");
16612 if (str && strcmp (str, "1") == 0) return 1;
16616 static int test_read_lines_1 (void)
16618 if (test_read_lines_1_skip ()) {
16619 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
16623 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
16625 char device[] = "/dev/sda";
16627 suppress_error = 0;
16628 r = guestfs_blockdev_setrw (g, device);
16634 suppress_error = 0;
16635 r = guestfs_umount_all (g);
16641 suppress_error = 0;
16642 r = guestfs_lvm_remove_all (g);
16647 char device[] = "/dev/sda";
16648 char lines_0[] = ",";
16654 suppress_error = 0;
16655 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16660 char fstype[] = "ext2";
16661 char device[] = "/dev/sda1";
16663 suppress_error = 0;
16664 r = guestfs_mkfs (g, fstype, device);
16669 char device[] = "/dev/sda1";
16670 char mountpoint[] = "/";
16672 suppress_error = 0;
16673 r = guestfs_mount (g, device, mountpoint);
16677 /* TestOutputList for read_lines (1) */
16679 char path[] = "/new";
16680 char content[] = "";
16682 suppress_error = 0;
16683 r = guestfs_write_file (g, path, content, 0);
16688 char path[] = "/new";
16691 suppress_error = 0;
16692 r = guestfs_read_lines (g, path);
16695 if (r[0] != NULL) {
16696 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
16700 for (i = 0; r[i] != NULL; ++i)
16707 static int test_lvs_0_skip (void)
16711 str = getenv ("TEST_ONLY");
16713 return strstr (str, "lvs") == NULL;
16714 str = getenv ("SKIP_TEST_LVS_0");
16715 if (str && strcmp (str, "1") == 0) return 1;
16716 str = getenv ("SKIP_TEST_LVS");
16717 if (str && strcmp (str, "1") == 0) return 1;
16721 static int test_lvs_0 (void)
16723 if (test_lvs_0_skip ()) {
16724 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
16728 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
16730 char device[] = "/dev/sda";
16732 suppress_error = 0;
16733 r = guestfs_blockdev_setrw (g, device);
16739 suppress_error = 0;
16740 r = guestfs_umount_all (g);
16746 suppress_error = 0;
16747 r = guestfs_lvm_remove_all (g);
16752 char device[] = "/dev/sda";
16753 char lines_0[] = ",";
16759 suppress_error = 0;
16760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16765 char device[] = "/dev/sda1";
16767 suppress_error = 0;
16768 r = guestfs_pvcreate (g, device);
16773 char volgroup[] = "VG";
16774 char physvols_0[] = "/dev/sda1";
16775 char *physvols[] = {
16780 suppress_error = 0;
16781 r = guestfs_vgcreate (g, volgroup, physvols);
16786 char logvol[] = "LV";
16787 char volgroup[] = "VG";
16789 suppress_error = 0;
16790 r = guestfs_lvcreate (g, logvol, volgroup, 8);
16795 char fstype[] = "ext2";
16796 char device[] = "/dev/VG/LV";
16798 suppress_error = 0;
16799 r = guestfs_mkfs (g, fstype, device);
16804 char device[] = "/dev/VG/LV";
16805 char mountpoint[] = "/";
16807 suppress_error = 0;
16808 r = guestfs_mount (g, device, mountpoint);
16812 /* TestOutputList for lvs (0) */
16816 suppress_error = 0;
16817 r = guestfs_lvs (g);
16821 fprintf (stderr, "test_lvs_0: short list returned from command\n");
16826 char expected[] = "/dev/VG/LV";
16827 if (strcmp (r[0], expected) != 0) {
16828 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16832 if (r[1] != NULL) {
16833 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
16837 for (i = 0; r[i] != NULL; ++i)
16844 static int test_lvs_1_skip (void)
16848 str = getenv ("TEST_ONLY");
16850 return strstr (str, "lvs") == NULL;
16851 str = getenv ("SKIP_TEST_LVS_1");
16852 if (str && strcmp (str, "1") == 0) return 1;
16853 str = getenv ("SKIP_TEST_LVS");
16854 if (str && strcmp (str, "1") == 0) return 1;
16858 static int test_lvs_1 (void)
16860 if (test_lvs_1_skip ()) {
16861 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
16865 /* InitNone|InitEmpty for test_lvs_1 */
16867 char device[] = "/dev/sda";
16869 suppress_error = 0;
16870 r = guestfs_blockdev_setrw (g, device);
16876 suppress_error = 0;
16877 r = guestfs_umount_all (g);
16883 suppress_error = 0;
16884 r = guestfs_lvm_remove_all (g);
16888 /* TestOutputList for lvs (1) */
16890 char device[] = "/dev/sda";
16891 char lines_0[] = ",10";
16892 char lines_1[] = ",20";
16893 char lines_2[] = ",";
16901 suppress_error = 0;
16902 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16907 char device[] = "/dev/sda1";
16909 suppress_error = 0;
16910 r = guestfs_pvcreate (g, device);
16915 char device[] = "/dev/sda2";
16917 suppress_error = 0;
16918 r = guestfs_pvcreate (g, device);
16923 char device[] = "/dev/sda3";
16925 suppress_error = 0;
16926 r = guestfs_pvcreate (g, device);
16931 char volgroup[] = "VG1";
16932 char physvols_0[] = "/dev/sda1";
16933 char physvols_1[] = "/dev/sda2";
16934 char *physvols[] = {
16940 suppress_error = 0;
16941 r = guestfs_vgcreate (g, volgroup, physvols);
16946 char volgroup[] = "VG2";
16947 char physvols_0[] = "/dev/sda3";
16948 char *physvols[] = {
16953 suppress_error = 0;
16954 r = guestfs_vgcreate (g, volgroup, physvols);
16959 char logvol[] = "LV1";
16960 char volgroup[] = "VG1";
16962 suppress_error = 0;
16963 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16968 char logvol[] = "LV2";
16969 char volgroup[] = "VG1";
16971 suppress_error = 0;
16972 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16977 char logvol[] = "LV3";
16978 char volgroup[] = "VG2";
16980 suppress_error = 0;
16981 r = guestfs_lvcreate (g, logvol, volgroup, 50);
16988 suppress_error = 0;
16989 r = guestfs_lvs (g);
16993 fprintf (stderr, "test_lvs_1: short list returned from command\n");
16998 char expected[] = "/dev/VG1/LV1";
16999 if (strcmp (r[0], expected) != 0) {
17000 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17005 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17010 char expected[] = "/dev/VG1/LV2";
17011 if (strcmp (r[1], expected) != 0) {
17012 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17017 fprintf (stderr, "test_lvs_1: short list returned from command\n");
17022 char expected[] = "/dev/VG2/LV3";
17023 if (strcmp (r[2], expected) != 0) {
17024 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17028 if (r[3] != NULL) {
17029 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
17033 for (i = 0; r[i] != NULL; ++i)
17040 static int test_vgs_0_skip (void)
17044 str = getenv ("TEST_ONLY");
17046 return strstr (str, "vgs") == NULL;
17047 str = getenv ("SKIP_TEST_VGS_0");
17048 if (str && strcmp (str, "1") == 0) return 1;
17049 str = getenv ("SKIP_TEST_VGS");
17050 if (str && strcmp (str, "1") == 0) return 1;
17054 static int test_vgs_0 (void)
17056 if (test_vgs_0_skip ()) {
17057 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
17061 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
17063 char device[] = "/dev/sda";
17065 suppress_error = 0;
17066 r = guestfs_blockdev_setrw (g, device);
17072 suppress_error = 0;
17073 r = guestfs_umount_all (g);
17079 suppress_error = 0;
17080 r = guestfs_lvm_remove_all (g);
17085 char device[] = "/dev/sda";
17086 char lines_0[] = ",";
17092 suppress_error = 0;
17093 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17098 char device[] = "/dev/sda1";
17100 suppress_error = 0;
17101 r = guestfs_pvcreate (g, device);
17106 char volgroup[] = "VG";
17107 char physvols_0[] = "/dev/sda1";
17108 char *physvols[] = {
17113 suppress_error = 0;
17114 r = guestfs_vgcreate (g, volgroup, physvols);
17119 char logvol[] = "LV";
17120 char volgroup[] = "VG";
17122 suppress_error = 0;
17123 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17128 char fstype[] = "ext2";
17129 char device[] = "/dev/VG/LV";
17131 suppress_error = 0;
17132 r = guestfs_mkfs (g, fstype, device);
17137 char device[] = "/dev/VG/LV";
17138 char mountpoint[] = "/";
17140 suppress_error = 0;
17141 r = guestfs_mount (g, device, mountpoint);
17145 /* TestOutputList for vgs (0) */
17149 suppress_error = 0;
17150 r = guestfs_vgs (g);
17154 fprintf (stderr, "test_vgs_0: short list returned from command\n");
17159 char expected[] = "VG";
17160 if (strcmp (r[0], expected) != 0) {
17161 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17165 if (r[1] != NULL) {
17166 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
17170 for (i = 0; r[i] != NULL; ++i)
17177 static int test_vgs_1_skip (void)
17181 str = getenv ("TEST_ONLY");
17183 return strstr (str, "vgs") == NULL;
17184 str = getenv ("SKIP_TEST_VGS_1");
17185 if (str && strcmp (str, "1") == 0) return 1;
17186 str = getenv ("SKIP_TEST_VGS");
17187 if (str && strcmp (str, "1") == 0) return 1;
17191 static int test_vgs_1 (void)
17193 if (test_vgs_1_skip ()) {
17194 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
17198 /* InitNone|InitEmpty for test_vgs_1 */
17200 char device[] = "/dev/sda";
17202 suppress_error = 0;
17203 r = guestfs_blockdev_setrw (g, device);
17209 suppress_error = 0;
17210 r = guestfs_umount_all (g);
17216 suppress_error = 0;
17217 r = guestfs_lvm_remove_all (g);
17221 /* TestOutputList for vgs (1) */
17223 char device[] = "/dev/sda";
17224 char lines_0[] = ",10";
17225 char lines_1[] = ",20";
17226 char lines_2[] = ",";
17234 suppress_error = 0;
17235 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17240 char device[] = "/dev/sda1";
17242 suppress_error = 0;
17243 r = guestfs_pvcreate (g, device);
17248 char device[] = "/dev/sda2";
17250 suppress_error = 0;
17251 r = guestfs_pvcreate (g, device);
17256 char device[] = "/dev/sda3";
17258 suppress_error = 0;
17259 r = guestfs_pvcreate (g, device);
17264 char volgroup[] = "VG1";
17265 char physvols_0[] = "/dev/sda1";
17266 char physvols_1[] = "/dev/sda2";
17267 char *physvols[] = {
17273 suppress_error = 0;
17274 r = guestfs_vgcreate (g, volgroup, physvols);
17279 char volgroup[] = "VG2";
17280 char physvols_0[] = "/dev/sda3";
17281 char *physvols[] = {
17286 suppress_error = 0;
17287 r = guestfs_vgcreate (g, volgroup, physvols);
17294 suppress_error = 0;
17295 r = guestfs_vgs (g);
17299 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17304 char expected[] = "VG1";
17305 if (strcmp (r[0], expected) != 0) {
17306 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17311 fprintf (stderr, "test_vgs_1: short list returned from command\n");
17316 char expected[] = "VG2";
17317 if (strcmp (r[1], expected) != 0) {
17318 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17322 if (r[2] != NULL) {
17323 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
17327 for (i = 0; r[i] != NULL; ++i)
17334 static int test_pvs_0_skip (void)
17338 str = getenv ("TEST_ONLY");
17340 return strstr (str, "pvs") == NULL;
17341 str = getenv ("SKIP_TEST_PVS_0");
17342 if (str && strcmp (str, "1") == 0) return 1;
17343 str = getenv ("SKIP_TEST_PVS");
17344 if (str && strcmp (str, "1") == 0) return 1;
17348 static int test_pvs_0 (void)
17350 if (test_pvs_0_skip ()) {
17351 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
17355 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
17357 char device[] = "/dev/sda";
17359 suppress_error = 0;
17360 r = guestfs_blockdev_setrw (g, device);
17366 suppress_error = 0;
17367 r = guestfs_umount_all (g);
17373 suppress_error = 0;
17374 r = guestfs_lvm_remove_all (g);
17379 char device[] = "/dev/sda";
17380 char lines_0[] = ",";
17386 suppress_error = 0;
17387 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17392 char device[] = "/dev/sda1";
17394 suppress_error = 0;
17395 r = guestfs_pvcreate (g, device);
17400 char volgroup[] = "VG";
17401 char physvols_0[] = "/dev/sda1";
17402 char *physvols[] = {
17407 suppress_error = 0;
17408 r = guestfs_vgcreate (g, volgroup, physvols);
17413 char logvol[] = "LV";
17414 char volgroup[] = "VG";
17416 suppress_error = 0;
17417 r = guestfs_lvcreate (g, logvol, volgroup, 8);
17422 char fstype[] = "ext2";
17423 char device[] = "/dev/VG/LV";
17425 suppress_error = 0;
17426 r = guestfs_mkfs (g, fstype, device);
17431 char device[] = "/dev/VG/LV";
17432 char mountpoint[] = "/";
17434 suppress_error = 0;
17435 r = guestfs_mount (g, device, mountpoint);
17439 /* TestOutputListOfDevices for pvs (0) */
17443 suppress_error = 0;
17444 r = guestfs_pvs (g);
17448 fprintf (stderr, "test_pvs_0: short list returned from command\n");
17453 char expected[] = "/dev/sda1";
17455 if (strcmp (r[0], expected) != 0) {
17456 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17460 if (r[1] != NULL) {
17461 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
17465 for (i = 0; r[i] != NULL; ++i)
17472 static int test_pvs_1_skip (void)
17476 str = getenv ("TEST_ONLY");
17478 return strstr (str, "pvs") == NULL;
17479 str = getenv ("SKIP_TEST_PVS_1");
17480 if (str && strcmp (str, "1") == 0) return 1;
17481 str = getenv ("SKIP_TEST_PVS");
17482 if (str && strcmp (str, "1") == 0) return 1;
17486 static int test_pvs_1 (void)
17488 if (test_pvs_1_skip ()) {
17489 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
17493 /* InitNone|InitEmpty for test_pvs_1 */
17495 char device[] = "/dev/sda";
17497 suppress_error = 0;
17498 r = guestfs_blockdev_setrw (g, device);
17504 suppress_error = 0;
17505 r = guestfs_umount_all (g);
17511 suppress_error = 0;
17512 r = guestfs_lvm_remove_all (g);
17516 /* TestOutputListOfDevices for pvs (1) */
17518 char device[] = "/dev/sda";
17519 char lines_0[] = ",10";
17520 char lines_1[] = ",20";
17521 char lines_2[] = ",";
17529 suppress_error = 0;
17530 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17535 char device[] = "/dev/sda1";
17537 suppress_error = 0;
17538 r = guestfs_pvcreate (g, device);
17543 char device[] = "/dev/sda2";
17545 suppress_error = 0;
17546 r = guestfs_pvcreate (g, device);
17551 char device[] = "/dev/sda3";
17553 suppress_error = 0;
17554 r = guestfs_pvcreate (g, device);
17561 suppress_error = 0;
17562 r = guestfs_pvs (g);
17566 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17571 char expected[] = "/dev/sda1";
17573 if (strcmp (r[0], expected) != 0) {
17574 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17579 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17584 char expected[] = "/dev/sda2";
17586 if (strcmp (r[1], expected) != 0) {
17587 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17592 fprintf (stderr, "test_pvs_1: short list returned from command\n");
17597 char expected[] = "/dev/sda3";
17599 if (strcmp (r[2], expected) != 0) {
17600 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17604 if (r[3] != NULL) {
17605 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
17609 for (i = 0; r[i] != NULL; ++i)
17616 static int test_list_partitions_0_skip (void)
17620 str = getenv ("TEST_ONLY");
17622 return strstr (str, "list_partitions") == NULL;
17623 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
17624 if (str && strcmp (str, "1") == 0) return 1;
17625 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17626 if (str && strcmp (str, "1") == 0) return 1;
17630 static int test_list_partitions_0 (void)
17632 if (test_list_partitions_0_skip ()) {
17633 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
17637 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
17639 char device[] = "/dev/sda";
17641 suppress_error = 0;
17642 r = guestfs_blockdev_setrw (g, device);
17648 suppress_error = 0;
17649 r = guestfs_umount_all (g);
17655 suppress_error = 0;
17656 r = guestfs_lvm_remove_all (g);
17661 char device[] = "/dev/sda";
17662 char lines_0[] = ",";
17668 suppress_error = 0;
17669 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17674 char fstype[] = "ext2";
17675 char device[] = "/dev/sda1";
17677 suppress_error = 0;
17678 r = guestfs_mkfs (g, fstype, device);
17683 char device[] = "/dev/sda1";
17684 char mountpoint[] = "/";
17686 suppress_error = 0;
17687 r = guestfs_mount (g, device, mountpoint);
17691 /* TestOutputListOfDevices for list_partitions (0) */
17695 suppress_error = 0;
17696 r = guestfs_list_partitions (g);
17700 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
17705 char expected[] = "/dev/sda1";
17707 if (strcmp (r[0], expected) != 0) {
17708 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17712 if (r[1] != NULL) {
17713 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
17717 for (i = 0; r[i] != NULL; ++i)
17724 static int test_list_partitions_1_skip (void)
17728 str = getenv ("TEST_ONLY");
17730 return strstr (str, "list_partitions") == NULL;
17731 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
17732 if (str && strcmp (str, "1") == 0) return 1;
17733 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
17734 if (str && strcmp (str, "1") == 0) return 1;
17738 static int test_list_partitions_1 (void)
17740 if (test_list_partitions_1_skip ()) {
17741 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
17745 /* InitNone|InitEmpty for test_list_partitions_1 */
17747 char device[] = "/dev/sda";
17749 suppress_error = 0;
17750 r = guestfs_blockdev_setrw (g, device);
17756 suppress_error = 0;
17757 r = guestfs_umount_all (g);
17763 suppress_error = 0;
17764 r = guestfs_lvm_remove_all (g);
17768 /* TestOutputListOfDevices for list_partitions (1) */
17770 char device[] = "/dev/sda";
17771 char lines_0[] = ",10";
17772 char lines_1[] = ",20";
17773 char lines_2[] = ",";
17781 suppress_error = 0;
17782 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17789 suppress_error = 0;
17790 r = guestfs_list_partitions (g);
17794 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17799 char expected[] = "/dev/sda1";
17801 if (strcmp (r[0], expected) != 0) {
17802 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17807 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17812 char expected[] = "/dev/sda2";
17814 if (strcmp (r[1], expected) != 0) {
17815 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17820 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
17825 char expected[] = "/dev/sda3";
17827 if (strcmp (r[2], expected) != 0) {
17828 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17832 if (r[3] != NULL) {
17833 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
17837 for (i = 0; r[i] != NULL; ++i)
17844 static int test_list_devices_0_skip (void)
17848 str = getenv ("TEST_ONLY");
17850 return strstr (str, "list_devices") == NULL;
17851 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
17852 if (str && strcmp (str, "1") == 0) return 1;
17853 str = getenv ("SKIP_TEST_LIST_DEVICES");
17854 if (str && strcmp (str, "1") == 0) return 1;
17858 static int test_list_devices_0 (void)
17860 if (test_list_devices_0_skip ()) {
17861 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
17865 /* InitNone|InitEmpty for test_list_devices_0 */
17867 char device[] = "/dev/sda";
17869 suppress_error = 0;
17870 r = guestfs_blockdev_setrw (g, device);
17876 suppress_error = 0;
17877 r = guestfs_umount_all (g);
17883 suppress_error = 0;
17884 r = guestfs_lvm_remove_all (g);
17888 /* TestOutputListOfDevices for list_devices (0) */
17892 suppress_error = 0;
17893 r = guestfs_list_devices (g);
17897 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17902 char expected[] = "/dev/sda";
17904 if (strcmp (r[0], expected) != 0) {
17905 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
17910 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17915 char expected[] = "/dev/sdb";
17917 if (strcmp (r[1], expected) != 0) {
17918 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
17923 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17928 char expected[] = "/dev/sdc";
17930 if (strcmp (r[2], expected) != 0) {
17931 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
17936 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
17941 char expected[] = "/dev/sdd";
17943 if (strcmp (r[3], expected) != 0) {
17944 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
17948 if (r[4] != NULL) {
17949 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
17953 for (i = 0; r[i] != NULL; ++i)
17960 static int test_ls_0_skip (void)
17964 str = getenv ("TEST_ONLY");
17966 return strstr (str, "ls") == NULL;
17967 str = getenv ("SKIP_TEST_LS_0");
17968 if (str && strcmp (str, "1") == 0) return 1;
17969 str = getenv ("SKIP_TEST_LS");
17970 if (str && strcmp (str, "1") == 0) return 1;
17974 static int test_ls_0 (void)
17976 if (test_ls_0_skip ()) {
17977 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
17981 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
17983 char device[] = "/dev/sda";
17985 suppress_error = 0;
17986 r = guestfs_blockdev_setrw (g, device);
17992 suppress_error = 0;
17993 r = guestfs_umount_all (g);
17999 suppress_error = 0;
18000 r = guestfs_lvm_remove_all (g);
18005 char device[] = "/dev/sda";
18006 char lines_0[] = ",";
18012 suppress_error = 0;
18013 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18018 char fstype[] = "ext2";
18019 char device[] = "/dev/sda1";
18021 suppress_error = 0;
18022 r = guestfs_mkfs (g, fstype, device);
18027 char device[] = "/dev/sda1";
18028 char mountpoint[] = "/";
18030 suppress_error = 0;
18031 r = guestfs_mount (g, device, mountpoint);
18035 /* TestOutputList for ls (0) */
18037 char path[] = "/new";
18039 suppress_error = 0;
18040 r = guestfs_touch (g, path);
18045 char path[] = "/newer";
18047 suppress_error = 0;
18048 r = guestfs_touch (g, path);
18053 char path[] = "/newest";
18055 suppress_error = 0;
18056 r = guestfs_touch (g, path);
18061 char directory[] = "/";
18064 suppress_error = 0;
18065 r = guestfs_ls (g, directory);
18069 fprintf (stderr, "test_ls_0: short list returned from command\n");
18074 char expected[] = "lost+found";
18075 if (strcmp (r[0], expected) != 0) {
18076 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
18081 fprintf (stderr, "test_ls_0: short list returned from command\n");
18086 char expected[] = "new";
18087 if (strcmp (r[1], expected) != 0) {
18088 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
18093 fprintf (stderr, "test_ls_0: short list returned from command\n");
18098 char expected[] = "newer";
18099 if (strcmp (r[2], expected) != 0) {
18100 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
18105 fprintf (stderr, "test_ls_0: short list returned from command\n");
18110 char expected[] = "newest";
18111 if (strcmp (r[3], expected) != 0) {
18112 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
18116 if (r[4] != NULL) {
18117 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
18121 for (i = 0; r[i] != NULL; ++i)
18128 static int test_cat_0_skip (void)
18132 str = getenv ("TEST_ONLY");
18134 return strstr (str, "cat") == NULL;
18135 str = getenv ("SKIP_TEST_CAT_0");
18136 if (str && strcmp (str, "1") == 0) return 1;
18137 str = getenv ("SKIP_TEST_CAT");
18138 if (str && strcmp (str, "1") == 0) return 1;
18142 static int test_cat_0 (void)
18144 if (test_cat_0_skip ()) {
18145 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
18149 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
18151 char device[] = "/dev/sda";
18153 suppress_error = 0;
18154 r = guestfs_blockdev_setrw (g, device);
18160 suppress_error = 0;
18161 r = guestfs_umount_all (g);
18167 suppress_error = 0;
18168 r = guestfs_lvm_remove_all (g);
18173 char device[] = "/dev/sda";
18174 char lines_0[] = ",";
18180 suppress_error = 0;
18181 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18186 char fstype[] = "ext2";
18187 char device[] = "/dev/sda1";
18189 suppress_error = 0;
18190 r = guestfs_mkfs (g, fstype, device);
18195 char device[] = "/dev/sda1";
18196 char mountpoint[] = "/";
18198 suppress_error = 0;
18199 r = guestfs_mount (g, device, mountpoint);
18203 /* TestOutput for cat (0) */
18204 char expected[] = "new file contents";
18206 char path[] = "/new";
18207 char content[] = "new file contents";
18209 suppress_error = 0;
18210 r = guestfs_write_file (g, path, content, 0);
18215 char path[] = "/new";
18217 suppress_error = 0;
18218 r = guestfs_cat (g, path);
18221 if (strcmp (r, expected) != 0) {
18222 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
18230 static int test_touch_0_skip (void)
18234 str = getenv ("TEST_ONLY");
18236 return strstr (str, "touch") == NULL;
18237 str = getenv ("SKIP_TEST_TOUCH_0");
18238 if (str && strcmp (str, "1") == 0) return 1;
18239 str = getenv ("SKIP_TEST_TOUCH");
18240 if (str && strcmp (str, "1") == 0) return 1;
18244 static int test_touch_0 (void)
18246 if (test_touch_0_skip ()) {
18247 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
18251 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
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);
18275 char device[] = "/dev/sda";
18276 char lines_0[] = ",";
18282 suppress_error = 0;
18283 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18288 char fstype[] = "ext2";
18289 char device[] = "/dev/sda1";
18291 suppress_error = 0;
18292 r = guestfs_mkfs (g, fstype, device);
18297 char device[] = "/dev/sda1";
18298 char mountpoint[] = "/";
18300 suppress_error = 0;
18301 r = guestfs_mount (g, device, mountpoint);
18305 /* TestOutputTrue for touch (0) */
18307 char path[] = "/new";
18309 suppress_error = 0;
18310 r = guestfs_touch (g, path);
18315 char path[] = "/new";
18317 suppress_error = 0;
18318 r = guestfs_exists (g, path);
18322 fprintf (stderr, "test_touch_0: expected true, got false\n");
18329 static int test_sync_0_skip (void)
18333 str = getenv ("TEST_ONLY");
18335 return strstr (str, "sync") == NULL;
18336 str = getenv ("SKIP_TEST_SYNC_0");
18337 if (str && strcmp (str, "1") == 0) return 1;
18338 str = getenv ("SKIP_TEST_SYNC");
18339 if (str && strcmp (str, "1") == 0) return 1;
18343 static int test_sync_0 (void)
18345 if (test_sync_0_skip ()) {
18346 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
18350 /* InitNone|InitEmpty for test_sync_0 */
18352 char device[] = "/dev/sda";
18354 suppress_error = 0;
18355 r = guestfs_blockdev_setrw (g, device);
18361 suppress_error = 0;
18362 r = guestfs_umount_all (g);
18368 suppress_error = 0;
18369 r = guestfs_lvm_remove_all (g);
18373 /* TestRun for sync (0) */
18376 suppress_error = 0;
18377 r = guestfs_sync (g);
18384 static int test_mount_0_skip (void)
18388 str = getenv ("TEST_ONLY");
18390 return strstr (str, "mount") == NULL;
18391 str = getenv ("SKIP_TEST_MOUNT_0");
18392 if (str && strcmp (str, "1") == 0) return 1;
18393 str = getenv ("SKIP_TEST_MOUNT");
18394 if (str && strcmp (str, "1") == 0) return 1;
18398 static int test_mount_0 (void)
18400 if (test_mount_0_skip ()) {
18401 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
18405 /* InitNone|InitEmpty for test_mount_0 */
18407 char device[] = "/dev/sda";
18409 suppress_error = 0;
18410 r = guestfs_blockdev_setrw (g, device);
18416 suppress_error = 0;
18417 r = guestfs_umount_all (g);
18423 suppress_error = 0;
18424 r = guestfs_lvm_remove_all (g);
18428 /* TestOutput for mount (0) */
18429 char expected[] = "new file contents";
18431 char device[] = "/dev/sda";
18432 char lines_0[] = ",";
18438 suppress_error = 0;
18439 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
18444 char fstype[] = "ext2";
18445 char device[] = "/dev/sda1";
18447 suppress_error = 0;
18448 r = guestfs_mkfs (g, fstype, device);
18453 char device[] = "/dev/sda1";
18454 char mountpoint[] = "/";
18456 suppress_error = 0;
18457 r = guestfs_mount (g, device, mountpoint);
18462 char path[] = "/new";
18463 char content[] = "new file contents";
18465 suppress_error = 0;
18466 r = guestfs_write_file (g, path, content, 0);
18471 char path[] = "/new";
18473 suppress_error = 0;
18474 r = guestfs_cat (g, path);
18477 if (strcmp (r, expected) != 0) {
18478 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
18486 int main (int argc, char *argv[])
18490 const char *filename;
18492 int nr_tests, test_num = 0;
18494 no_test_warnings ();
18496 g = guestfs_create ();
18498 printf ("guestfs_create FAILED\n");
18502 guestfs_set_error_handler (g, print_error, NULL);
18504 guestfs_set_path (g, "../appliance");
18506 filename = "test1.img";
18507 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18512 if (lseek (fd, 524288000, SEEK_SET) == -1) {
18518 if (write (fd, &c, 1) == -1) {
18524 if (close (fd) == -1) {
18529 if (guestfs_add_drive (g, filename) == -1) {
18530 printf ("guestfs_add_drive %s FAILED\n", filename);
18534 filename = "test2.img";
18535 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18540 if (lseek (fd, 52428800, SEEK_SET) == -1) {
18546 if (write (fd, &c, 1) == -1) {
18552 if (close (fd) == -1) {
18557 if (guestfs_add_drive (g, filename) == -1) {
18558 printf ("guestfs_add_drive %s FAILED\n", filename);
18562 filename = "test3.img";
18563 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
18568 if (lseek (fd, 10485760, SEEK_SET) == -1) {
18574 if (write (fd, &c, 1) == -1) {
18580 if (close (fd) == -1) {
18585 if (guestfs_add_drive (g, filename) == -1) {
18586 printf ("guestfs_add_drive %s FAILED\n", filename);
18590 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
18591 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
18595 if (guestfs_launch (g) == -1) {
18596 printf ("guestfs_launch FAILED\n");
18600 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
18603 if (guestfs_wait_ready (g) == -1) {
18604 printf ("guestfs_wait_ready FAILED\n");
18608 /* Cancel previous alarm. */
18614 printf ("%3d/%3d test_du_0\n", test_num, nr_tests);
18615 if (test_du_0 () == -1) {
18616 printf ("test_du_0 FAILED\n");
18620 printf ("%3d/%3d test_tail_n_0\n", test_num, nr_tests);
18621 if (test_tail_n_0 () == -1) {
18622 printf ("test_tail_n_0 FAILED\n");
18626 printf ("%3d/%3d test_tail_n_1\n", test_num, nr_tests);
18627 if (test_tail_n_1 () == -1) {
18628 printf ("test_tail_n_1 FAILED\n");
18632 printf ("%3d/%3d test_tail_n_2\n", test_num, nr_tests);
18633 if (test_tail_n_2 () == -1) {
18634 printf ("test_tail_n_2 FAILED\n");
18638 printf ("%3d/%3d test_tail_0\n", test_num, nr_tests);
18639 if (test_tail_0 () == -1) {
18640 printf ("test_tail_0 FAILED\n");
18644 printf ("%3d/%3d test_head_n_0\n", test_num, nr_tests);
18645 if (test_head_n_0 () == -1) {
18646 printf ("test_head_n_0 FAILED\n");
18650 printf ("%3d/%3d test_head_n_1\n", test_num, nr_tests);
18651 if (test_head_n_1 () == -1) {
18652 printf ("test_head_n_1 FAILED\n");
18656 printf ("%3d/%3d test_head_n_2\n", test_num, nr_tests);
18657 if (test_head_n_2 () == -1) {
18658 printf ("test_head_n_2 FAILED\n");
18662 printf ("%3d/%3d test_head_0\n", test_num, nr_tests);
18663 if (test_head_0 () == -1) {
18664 printf ("test_head_0 FAILED\n");
18668 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
18669 if (test_wc_c_0 () == -1) {
18670 printf ("test_wc_c_0 FAILED\n");
18674 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
18675 if (test_wc_w_0 () == -1) {
18676 printf ("test_wc_w_0 FAILED\n");
18680 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
18681 if (test_wc_l_0 () == -1) {
18682 printf ("test_wc_l_0 FAILED\n");
18686 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
18687 if (test_mkdtemp_0 () == -1) {
18688 printf ("test_mkdtemp_0 FAILED\n");
18692 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
18693 if (test_scrub_file_0 () == -1) {
18694 printf ("test_scrub_file_0 FAILED\n");
18698 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
18699 if (test_scrub_device_0 () == -1) {
18700 printf ("test_scrub_device_0 FAILED\n");
18704 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
18705 if (test_glob_expand_0 () == -1) {
18706 printf ("test_glob_expand_0 FAILED\n");
18710 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
18711 if (test_glob_expand_1 () == -1) {
18712 printf ("test_glob_expand_1 FAILED\n");
18716 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
18717 if (test_glob_expand_2 () == -1) {
18718 printf ("test_glob_expand_2 FAILED\n");
18722 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
18723 if (test_ntfs_3g_probe_0 () == -1) {
18724 printf ("test_ntfs_3g_probe_0 FAILED\n");
18728 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
18729 if (test_ntfs_3g_probe_1 () == -1) {
18730 printf ("test_ntfs_3g_probe_1 FAILED\n");
18734 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
18735 if (test_sleep_0 () == -1) {
18736 printf ("test_sleep_0 FAILED\n");
18740 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
18741 if (test_find_0 () == -1) {
18742 printf ("test_find_0 FAILED\n");
18746 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
18747 if (test_find_1 () == -1) {
18748 printf ("test_find_1 FAILED\n");
18752 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
18753 if (test_find_2 () == -1) {
18754 printf ("test_find_2 FAILED\n");
18758 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
18759 if (test_lvresize_0 () == -1) {
18760 printf ("test_lvresize_0 FAILED\n");
18764 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
18765 if (test_zerofree_0 () == -1) {
18766 printf ("test_zerofree_0 FAILED\n");
18770 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
18771 if (test_hexdump_0 () == -1) {
18772 printf ("test_hexdump_0 FAILED\n");
18776 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
18777 if (test_hexdump_1 () == -1) {
18778 printf ("test_hexdump_1 FAILED\n");
18782 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
18783 if (test_strings_e_0 () == -1) {
18784 printf ("test_strings_e_0 FAILED\n");
18788 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
18789 if (test_strings_e_1 () == -1) {
18790 printf ("test_strings_e_1 FAILED\n");
18794 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
18795 if (test_strings_0 () == -1) {
18796 printf ("test_strings_0 FAILED\n");
18800 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
18801 if (test_strings_1 () == -1) {
18802 printf ("test_strings_1 FAILED\n");
18806 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
18807 if (test_equal_0 () == -1) {
18808 printf ("test_equal_0 FAILED\n");
18812 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
18813 if (test_equal_1 () == -1) {
18814 printf ("test_equal_1 FAILED\n");
18818 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
18819 if (test_equal_2 () == -1) {
18820 printf ("test_equal_2 FAILED\n");
18824 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
18825 if (test_ping_daemon_0 () == -1) {
18826 printf ("test_ping_daemon_0 FAILED\n");
18830 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
18831 if (test_dmesg_0 () == -1) {
18832 printf ("test_dmesg_0 FAILED\n");
18836 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
18837 if (test_drop_caches_0 () == -1) {
18838 printf ("test_drop_caches_0 FAILED\n");
18842 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
18843 if (test_mv_0 () == -1) {
18844 printf ("test_mv_0 FAILED\n");
18848 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
18849 if (test_mv_1 () == -1) {
18850 printf ("test_mv_1 FAILED\n");
18854 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
18855 if (test_cp_a_0 () == -1) {
18856 printf ("test_cp_a_0 FAILED\n");
18860 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
18861 if (test_cp_0 () == -1) {
18862 printf ("test_cp_0 FAILED\n");
18866 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
18867 if (test_cp_1 () == -1) {
18868 printf ("test_cp_1 FAILED\n");
18872 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
18873 if (test_cp_2 () == -1) {
18874 printf ("test_cp_2 FAILED\n");
18878 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
18879 if (test_grub_install_0 () == -1) {
18880 printf ("test_grub_install_0 FAILED\n");
18884 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
18885 if (test_zero_0 () == -1) {
18886 printf ("test_zero_0 FAILED\n");
18890 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
18891 if (test_fsck_0 () == -1) {
18892 printf ("test_fsck_0 FAILED\n");
18896 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
18897 if (test_fsck_1 () == -1) {
18898 printf ("test_fsck_1 FAILED\n");
18902 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
18903 if (test_set_e2uuid_0 () == -1) {
18904 printf ("test_set_e2uuid_0 FAILED\n");
18908 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
18909 if (test_set_e2uuid_1 () == -1) {
18910 printf ("test_set_e2uuid_1 FAILED\n");
18914 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
18915 if (test_set_e2uuid_2 () == -1) {
18916 printf ("test_set_e2uuid_2 FAILED\n");
18920 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
18921 if (test_set_e2uuid_3 () == -1) {
18922 printf ("test_set_e2uuid_3 FAILED\n");
18926 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
18927 if (test_set_e2label_0 () == -1) {
18928 printf ("test_set_e2label_0 FAILED\n");
18932 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
18933 if (test_pvremove_0 () == -1) {
18934 printf ("test_pvremove_0 FAILED\n");
18938 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
18939 if (test_pvremove_1 () == -1) {
18940 printf ("test_pvremove_1 FAILED\n");
18944 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
18945 if (test_pvremove_2 () == -1) {
18946 printf ("test_pvremove_2 FAILED\n");
18950 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
18951 if (test_vgremove_0 () == -1) {
18952 printf ("test_vgremove_0 FAILED\n");
18956 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
18957 if (test_vgremove_1 () == -1) {
18958 printf ("test_vgremove_1 FAILED\n");
18962 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
18963 if (test_lvremove_0 () == -1) {
18964 printf ("test_lvremove_0 FAILED\n");
18968 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
18969 if (test_lvremove_1 () == -1) {
18970 printf ("test_lvremove_1 FAILED\n");
18974 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
18975 if (test_lvremove_2 () == -1) {
18976 printf ("test_lvremove_2 FAILED\n");
18980 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
18981 if (test_mount_ro_0 () == -1) {
18982 printf ("test_mount_ro_0 FAILED\n");
18986 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
18987 if (test_mount_ro_1 () == -1) {
18988 printf ("test_mount_ro_1 FAILED\n");
18992 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
18993 if (test_tgz_in_0 () == -1) {
18994 printf ("test_tgz_in_0 FAILED\n");
18998 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
18999 if (test_tar_in_0 () == -1) {
19000 printf ("test_tar_in_0 FAILED\n");
19004 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
19005 if (test_checksum_0 () == -1) {
19006 printf ("test_checksum_0 FAILED\n");
19010 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
19011 if (test_checksum_1 () == -1) {
19012 printf ("test_checksum_1 FAILED\n");
19016 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
19017 if (test_checksum_2 () == -1) {
19018 printf ("test_checksum_2 FAILED\n");
19022 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
19023 if (test_checksum_3 () == -1) {
19024 printf ("test_checksum_3 FAILED\n");
19028 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
19029 if (test_checksum_4 () == -1) {
19030 printf ("test_checksum_4 FAILED\n");
19034 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
19035 if (test_checksum_5 () == -1) {
19036 printf ("test_checksum_5 FAILED\n");
19040 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
19041 if (test_checksum_6 () == -1) {
19042 printf ("test_checksum_6 FAILED\n");
19046 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
19047 if (test_checksum_7 () == -1) {
19048 printf ("test_checksum_7 FAILED\n");
19052 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
19053 if (test_checksum_8 () == -1) {
19054 printf ("test_checksum_8 FAILED\n");
19058 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
19059 if (test_download_0 () == -1) {
19060 printf ("test_download_0 FAILED\n");
19064 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
19065 if (test_upload_0 () == -1) {
19066 printf ("test_upload_0 FAILED\n");
19070 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
19071 if (test_blockdev_rereadpt_0 () == -1) {
19072 printf ("test_blockdev_rereadpt_0 FAILED\n");
19076 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
19077 if (test_blockdev_flushbufs_0 () == -1) {
19078 printf ("test_blockdev_flushbufs_0 FAILED\n");
19082 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
19083 if (test_blockdev_getsize64_0 () == -1) {
19084 printf ("test_blockdev_getsize64_0 FAILED\n");
19088 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
19089 if (test_blockdev_getsz_0 () == -1) {
19090 printf ("test_blockdev_getsz_0 FAILED\n");
19094 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
19095 if (test_blockdev_getbsz_0 () == -1) {
19096 printf ("test_blockdev_getbsz_0 FAILED\n");
19100 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
19101 if (test_blockdev_getss_0 () == -1) {
19102 printf ("test_blockdev_getss_0 FAILED\n");
19106 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
19107 if (test_blockdev_getro_0 () == -1) {
19108 printf ("test_blockdev_getro_0 FAILED\n");
19112 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
19113 if (test_blockdev_setrw_0 () == -1) {
19114 printf ("test_blockdev_setrw_0 FAILED\n");
19118 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
19119 if (test_blockdev_setro_0 () == -1) {
19120 printf ("test_blockdev_setro_0 FAILED\n");
19124 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
19125 if (test_statvfs_0 () == -1) {
19126 printf ("test_statvfs_0 FAILED\n");
19130 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
19131 if (test_lstat_0 () == -1) {
19132 printf ("test_lstat_0 FAILED\n");
19136 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
19137 if (test_stat_0 () == -1) {
19138 printf ("test_stat_0 FAILED\n");
19142 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
19143 if (test_command_lines_0 () == -1) {
19144 printf ("test_command_lines_0 FAILED\n");
19148 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
19149 if (test_command_lines_1 () == -1) {
19150 printf ("test_command_lines_1 FAILED\n");
19154 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
19155 if (test_command_lines_2 () == -1) {
19156 printf ("test_command_lines_2 FAILED\n");
19160 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
19161 if (test_command_lines_3 () == -1) {
19162 printf ("test_command_lines_3 FAILED\n");
19166 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
19167 if (test_command_lines_4 () == -1) {
19168 printf ("test_command_lines_4 FAILED\n");
19172 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
19173 if (test_command_lines_5 () == -1) {
19174 printf ("test_command_lines_5 FAILED\n");
19178 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
19179 if (test_command_lines_6 () == -1) {
19180 printf ("test_command_lines_6 FAILED\n");
19184 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
19185 if (test_command_lines_7 () == -1) {
19186 printf ("test_command_lines_7 FAILED\n");
19190 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
19191 if (test_command_lines_8 () == -1) {
19192 printf ("test_command_lines_8 FAILED\n");
19196 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
19197 if (test_command_lines_9 () == -1) {
19198 printf ("test_command_lines_9 FAILED\n");
19202 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
19203 if (test_command_lines_10 () == -1) {
19204 printf ("test_command_lines_10 FAILED\n");
19208 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
19209 if (test_command_0 () == -1) {
19210 printf ("test_command_0 FAILED\n");
19214 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
19215 if (test_command_1 () == -1) {
19216 printf ("test_command_1 FAILED\n");
19220 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
19221 if (test_command_2 () == -1) {
19222 printf ("test_command_2 FAILED\n");
19226 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
19227 if (test_command_3 () == -1) {
19228 printf ("test_command_3 FAILED\n");
19232 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
19233 if (test_command_4 () == -1) {
19234 printf ("test_command_4 FAILED\n");
19238 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
19239 if (test_command_5 () == -1) {
19240 printf ("test_command_5 FAILED\n");
19244 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
19245 if (test_command_6 () == -1) {
19246 printf ("test_command_6 FAILED\n");
19250 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
19251 if (test_command_7 () == -1) {
19252 printf ("test_command_7 FAILED\n");
19256 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
19257 if (test_command_8 () == -1) {
19258 printf ("test_command_8 FAILED\n");
19262 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
19263 if (test_command_9 () == -1) {
19264 printf ("test_command_9 FAILED\n");
19268 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
19269 if (test_command_10 () == -1) {
19270 printf ("test_command_10 FAILED\n");
19274 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
19275 if (test_command_11 () == -1) {
19276 printf ("test_command_11 FAILED\n");
19280 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
19281 if (test_file_0 () == -1) {
19282 printf ("test_file_0 FAILED\n");
19286 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
19287 if (test_file_1 () == -1) {
19288 printf ("test_file_1 FAILED\n");
19292 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
19293 if (test_file_2 () == -1) {
19294 printf ("test_file_2 FAILED\n");
19298 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
19299 if (test_umount_all_0 () == -1) {
19300 printf ("test_umount_all_0 FAILED\n");
19304 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
19305 if (test_umount_all_1 () == -1) {
19306 printf ("test_umount_all_1 FAILED\n");
19310 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
19311 if (test_mounts_0 () == -1) {
19312 printf ("test_mounts_0 FAILED\n");
19316 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
19317 if (test_umount_0 () == -1) {
19318 printf ("test_umount_0 FAILED\n");
19322 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
19323 if (test_umount_1 () == -1) {
19324 printf ("test_umount_1 FAILED\n");
19328 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
19329 if (test_write_file_0 () == -1) {
19330 printf ("test_write_file_0 FAILED\n");
19334 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
19335 if (test_write_file_1 () == -1) {
19336 printf ("test_write_file_1 FAILED\n");
19340 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
19341 if (test_write_file_2 () == -1) {
19342 printf ("test_write_file_2 FAILED\n");
19346 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
19347 if (test_write_file_3 () == -1) {
19348 printf ("test_write_file_3 FAILED\n");
19352 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
19353 if (test_write_file_4 () == -1) {
19354 printf ("test_write_file_4 FAILED\n");
19358 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
19359 if (test_write_file_5 () == -1) {
19360 printf ("test_write_file_5 FAILED\n");
19364 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
19365 if (test_mkfs_0 () == -1) {
19366 printf ("test_mkfs_0 FAILED\n");
19370 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
19371 if (test_lvcreate_0 () == -1) {
19372 printf ("test_lvcreate_0 FAILED\n");
19376 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
19377 if (test_vgcreate_0 () == -1) {
19378 printf ("test_vgcreate_0 FAILED\n");
19382 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
19383 if (test_pvcreate_0 () == -1) {
19384 printf ("test_pvcreate_0 FAILED\n");
19388 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
19389 if (test_is_dir_0 () == -1) {
19390 printf ("test_is_dir_0 FAILED\n");
19394 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
19395 if (test_is_dir_1 () == -1) {
19396 printf ("test_is_dir_1 FAILED\n");
19400 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
19401 if (test_is_file_0 () == -1) {
19402 printf ("test_is_file_0 FAILED\n");
19406 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
19407 if (test_is_file_1 () == -1) {
19408 printf ("test_is_file_1 FAILED\n");
19412 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
19413 if (test_exists_0 () == -1) {
19414 printf ("test_exists_0 FAILED\n");
19418 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
19419 if (test_exists_1 () == -1) {
19420 printf ("test_exists_1 FAILED\n");
19424 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
19425 if (test_mkdir_p_0 () == -1) {
19426 printf ("test_mkdir_p_0 FAILED\n");
19430 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
19431 if (test_mkdir_p_1 () == -1) {
19432 printf ("test_mkdir_p_1 FAILED\n");
19436 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
19437 if (test_mkdir_p_2 () == -1) {
19438 printf ("test_mkdir_p_2 FAILED\n");
19442 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
19443 if (test_mkdir_p_3 () == -1) {
19444 printf ("test_mkdir_p_3 FAILED\n");
19448 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
19449 if (test_mkdir_p_4 () == -1) {
19450 printf ("test_mkdir_p_4 FAILED\n");
19454 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
19455 if (test_mkdir_0 () == -1) {
19456 printf ("test_mkdir_0 FAILED\n");
19460 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
19461 if (test_mkdir_1 () == -1) {
19462 printf ("test_mkdir_1 FAILED\n");
19466 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
19467 if (test_rm_rf_0 () == -1) {
19468 printf ("test_rm_rf_0 FAILED\n");
19472 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
19473 if (test_rmdir_0 () == -1) {
19474 printf ("test_rmdir_0 FAILED\n");
19478 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
19479 if (test_rmdir_1 () == -1) {
19480 printf ("test_rmdir_1 FAILED\n");
19484 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
19485 if (test_rmdir_2 () == -1) {
19486 printf ("test_rmdir_2 FAILED\n");
19490 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
19491 if (test_rm_0 () == -1) {
19492 printf ("test_rm_0 FAILED\n");
19496 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
19497 if (test_rm_1 () == -1) {
19498 printf ("test_rm_1 FAILED\n");
19502 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
19503 if (test_rm_2 () == -1) {
19504 printf ("test_rm_2 FAILED\n");
19508 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
19509 if (test_read_lines_0 () == -1) {
19510 printf ("test_read_lines_0 FAILED\n");
19514 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
19515 if (test_read_lines_1 () == -1) {
19516 printf ("test_read_lines_1 FAILED\n");
19520 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
19521 if (test_lvs_0 () == -1) {
19522 printf ("test_lvs_0 FAILED\n");
19526 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
19527 if (test_lvs_1 () == -1) {
19528 printf ("test_lvs_1 FAILED\n");
19532 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
19533 if (test_vgs_0 () == -1) {
19534 printf ("test_vgs_0 FAILED\n");
19538 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
19539 if (test_vgs_1 () == -1) {
19540 printf ("test_vgs_1 FAILED\n");
19544 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
19545 if (test_pvs_0 () == -1) {
19546 printf ("test_pvs_0 FAILED\n");
19550 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
19551 if (test_pvs_1 () == -1) {
19552 printf ("test_pvs_1 FAILED\n");
19556 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
19557 if (test_list_partitions_0 () == -1) {
19558 printf ("test_list_partitions_0 FAILED\n");
19562 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
19563 if (test_list_partitions_1 () == -1) {
19564 printf ("test_list_partitions_1 FAILED\n");
19568 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
19569 if (test_list_devices_0 () == -1) {
19570 printf ("test_list_devices_0 FAILED\n");
19574 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
19575 if (test_ls_0 () == -1) {
19576 printf ("test_ls_0 FAILED\n");
19580 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
19581 if (test_cat_0 () == -1) {
19582 printf ("test_cat_0 FAILED\n");
19586 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
19587 if (test_touch_0 () == -1) {
19588 printf ("test_touch_0 FAILED\n");
19592 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
19593 if (test_sync_0 () == -1) {
19594 printf ("test_sync_0 FAILED\n");
19598 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
19599 if (test_mount_0 () == -1) {
19600 printf ("test_mount_0 FAILED\n");
19605 unlink ("test1.img");
19606 unlink ("test2.img");
19607 unlink ("test3.img");
19610 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);