1 /* libguestfs generated file
2 * WARNING: THIS FILE IS GENERATED BY 'src/generator.ml'.
3 * ANY CHANGES YOU MAKE TO THIS FILE WILL BE LOST.
5 * Copyright (C) 2009 Red Hat Inc.
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License along
18 * with this program; if not, write to the Free Software Foundation, Inc.,
19 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
26 #include <sys/types.h>
32 static int suppress_error = 0;
34 static void print_error (guestfs_h *g, void *data, const char *msg)
37 fprintf (stderr, "%s\n", msg);
40 static void print_strings (char * const * const argv)
44 for (argc = 0; argv[argc] != NULL; ++argc)
45 printf ("\t%s\n", argv[argc]);
49 static void print_table (char * const * const argv)
53 for (i = 0; argv[i] != NULL; i += 2)
54 printf ("%s: %s\n", argv[i], argv[i+1]);
58 static void no_test_warnings (void)
60 fprintf (stderr, "warning: \"guestfs_test0\" has no tests\n");
61 fprintf (stderr, "warning: \"guestfs_test0rint\" has no tests\n");
62 fprintf (stderr, "warning: \"guestfs_test0rinterr\" has no tests\n");
63 fprintf (stderr, "warning: \"guestfs_test0rint64\" has no tests\n");
64 fprintf (stderr, "warning: \"guestfs_test0rint64err\" has no tests\n");
65 fprintf (stderr, "warning: \"guestfs_test0rbool\" has no tests\n");
66 fprintf (stderr, "warning: \"guestfs_test0rboolerr\" has no tests\n");
67 fprintf (stderr, "warning: \"guestfs_test0rconststring\" has no tests\n");
68 fprintf (stderr, "warning: \"guestfs_test0rconststringerr\" has no tests\n");
69 fprintf (stderr, "warning: \"guestfs_test0rstring\" has no tests\n");
70 fprintf (stderr, "warning: \"guestfs_test0rstringerr\" has no tests\n");
71 fprintf (stderr, "warning: \"guestfs_test0rstringlist\" has no tests\n");
72 fprintf (stderr, "warning: \"guestfs_test0rstringlisterr\" has no tests\n");
73 fprintf (stderr, "warning: \"guestfs_test0rintbool\" has no tests\n");
74 fprintf (stderr, "warning: \"guestfs_test0rintboolerr\" has no tests\n");
75 fprintf (stderr, "warning: \"guestfs_test0rpvlist\" has no tests\n");
76 fprintf (stderr, "warning: \"guestfs_test0rpvlisterr\" has no tests\n");
77 fprintf (stderr, "warning: \"guestfs_test0rvglist\" has no tests\n");
78 fprintf (stderr, "warning: \"guestfs_test0rvglisterr\" has no tests\n");
79 fprintf (stderr, "warning: \"guestfs_test0rlvlist\" has no tests\n");
80 fprintf (stderr, "warning: \"guestfs_test0rlvlisterr\" has no tests\n");
81 fprintf (stderr, "warning: \"guestfs_test0rstat\" has no tests\n");
82 fprintf (stderr, "warning: \"guestfs_test0rstaterr\" has no tests\n");
83 fprintf (stderr, "warning: \"guestfs_test0rstatvfs\" has no tests\n");
84 fprintf (stderr, "warning: \"guestfs_test0rstatvfserr\" has no tests\n");
85 fprintf (stderr, "warning: \"guestfs_test0rhashtable\" has no tests\n");
86 fprintf (stderr, "warning: \"guestfs_test0rhashtableerr\" has no tests\n");
87 fprintf (stderr, "warning: \"guestfs_launch\" has no tests\n");
88 fprintf (stderr, "warning: \"guestfs_wait_ready\" has no tests\n");
89 fprintf (stderr, "warning: \"guestfs_kill_subprocess\" has no tests\n");
90 fprintf (stderr, "warning: \"guestfs_add_drive\" has no tests\n");
91 fprintf (stderr, "warning: \"guestfs_add_cdrom\" has no tests\n");
92 fprintf (stderr, "warning: \"guestfs_add_drive_ro\" has no tests\n");
93 fprintf (stderr, "warning: \"guestfs_config\" has no tests\n");
94 fprintf (stderr, "warning: \"guestfs_set_qemu\" has no tests\n");
95 fprintf (stderr, "warning: \"guestfs_get_qemu\" has no tests\n");
96 fprintf (stderr, "warning: \"guestfs_set_path\" has no tests\n");
97 fprintf (stderr, "warning: \"guestfs_get_path\" has no tests\n");
98 fprintf (stderr, "warning: \"guestfs_set_append\" has no tests\n");
99 fprintf (stderr, "warning: \"guestfs_get_append\" has no tests\n");
100 fprintf (stderr, "warning: \"guestfs_set_autosync\" has no tests\n");
101 fprintf (stderr, "warning: \"guestfs_get_autosync\" has no tests\n");
102 fprintf (stderr, "warning: \"guestfs_set_verbose\" has no tests\n");
103 fprintf (stderr, "warning: \"guestfs_get_verbose\" has no tests\n");
104 fprintf (stderr, "warning: \"guestfs_is_ready\" has no tests\n");
105 fprintf (stderr, "warning: \"guestfs_is_config\" has no tests\n");
106 fprintf (stderr, "warning: \"guestfs_is_launching\" has no tests\n");
107 fprintf (stderr, "warning: \"guestfs_is_busy\" has no tests\n");
108 fprintf (stderr, "warning: \"guestfs_get_state\" has no tests\n");
109 fprintf (stderr, "warning: \"guestfs_set_busy\" has no tests\n");
110 fprintf (stderr, "warning: \"guestfs_set_ready\" has no tests\n");
111 fprintf (stderr, "warning: \"guestfs_end_busy\" has no tests\n");
112 fprintf (stderr, "warning: \"guestfs_ll\" has no tests\n");
113 fprintf (stderr, "warning: \"guestfs_pvs_full\" has no tests\n");
114 fprintf (stderr, "warning: \"guestfs_vgs_full\" has no tests\n");
115 fprintf (stderr, "warning: \"guestfs_lvs_full\" has no tests\n");
116 fprintf (stderr, "warning: \"guestfs_aug_init\" has no tests\n");
117 fprintf (stderr, "warning: \"guestfs_aug_close\" has no tests\n");
118 fprintf (stderr, "warning: \"guestfs_aug_defvar\" has no tests\n");
119 fprintf (stderr, "warning: \"guestfs_aug_defnode\" has no tests\n");
120 fprintf (stderr, "warning: \"guestfs_aug_get\" has no tests\n");
121 fprintf (stderr, "warning: \"guestfs_aug_set\" has no tests\n");
122 fprintf (stderr, "warning: \"guestfs_aug_insert\" has no tests\n");
123 fprintf (stderr, "warning: \"guestfs_aug_rm\" has no tests\n");
124 fprintf (stderr, "warning: \"guestfs_aug_mv\" has no tests\n");
125 fprintf (stderr, "warning: \"guestfs_aug_match\" has no tests\n");
126 fprintf (stderr, "warning: \"guestfs_aug_save\" has no tests\n");
127 fprintf (stderr, "warning: \"guestfs_aug_load\" has no tests\n");
128 fprintf (stderr, "warning: \"guestfs_aug_ls\" has no tests\n");
129 fprintf (stderr, "warning: \"guestfs_chmod\" has no tests\n");
130 fprintf (stderr, "warning: \"guestfs_chown\" has no tests\n");
131 fprintf (stderr, "warning: \"guestfs_sfdisk\" has no tests\n");
132 fprintf (stderr, "warning: \"guestfs_lvm_remove_all\" has no tests\n");
133 fprintf (stderr, "warning: \"guestfs_tune2fs_l\" has no tests\n");
134 fprintf (stderr, "warning: \"guestfs_blockdev_setbsz\" has no tests\n");
135 fprintf (stderr, "warning: \"guestfs_tar_out\" has no tests\n");
136 fprintf (stderr, "warning: \"guestfs_tgz_out\" has no tests\n");
137 fprintf (stderr, "warning: \"guestfs_mount_options\" has no tests\n");
138 fprintf (stderr, "warning: \"guestfs_mount_vfs\" has no tests\n");
139 fprintf (stderr, "warning: \"guestfs_debug\" has no tests\n");
140 fprintf (stderr, "warning: \"guestfs_get_e2label\" has no tests\n");
141 fprintf (stderr, "warning: \"guestfs_get_e2uuid\" has no tests\n");
142 fprintf (stderr, "warning: \"guestfs_pvresize\" has no tests\n");
143 fprintf (stderr, "warning: \"guestfs_sfdisk_N\" has no tests\n");
144 fprintf (stderr, "warning: \"guestfs_sfdisk_l\" has no tests\n");
145 fprintf (stderr, "warning: \"guestfs_sfdisk_kernel_geometry\" has no tests\n");
146 fprintf (stderr, "warning: \"guestfs_sfdisk_disk_geometry\" has no tests\n");
147 fprintf (stderr, "warning: \"guestfs_vg_activate_all\" has no tests\n");
148 fprintf (stderr, "warning: \"guestfs_vg_activate\" has no tests\n");
149 fprintf (stderr, "warning: \"guestfs_resize2fs\" has no tests\n");
150 fprintf (stderr, "warning: \"guestfs_e2fsck_f\" has no tests\n");
151 fprintf (stderr, "warning: \"guestfs_sh\" has no tests\n");
152 fprintf (stderr, "warning: \"guestfs_sh_lines\" has no tests\n");
153 fprintf (stderr, "warning: \"guestfs_scrub_freespace\" has no tests\n");
156 static int test_wc_c_0_skip (void)
160 str = getenv ("TEST_ONLY");
162 return strstr (str, "wc_c") == NULL;
163 str = getenv ("SKIP_TEST_WC_C_0");
164 if (str && strcmp (str, "1") == 0) return 1;
165 str = getenv ("SKIP_TEST_WC_C");
166 if (str && strcmp (str, "1") == 0) return 1;
170 static int test_wc_c_0 (void)
172 if (test_wc_c_0_skip ()) {
173 printf ("%s skipped (reason: environment variable set)\n", "test_wc_c_0");
177 /* InitBasicFS for test_wc_c_0: create ext2 on /dev/sda1 */
179 char device[] = "/dev/sda";
182 r = guestfs_blockdev_setrw (g, device);
189 r = guestfs_umount_all (g);
196 r = guestfs_lvm_remove_all (g);
201 char device[] = "/dev/sda";
202 char lines_0[] = ",";
209 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
214 char fstype[] = "ext2";
215 char device[] = "/dev/sda1";
218 r = guestfs_mkfs (g, fstype, device);
223 char device[] = "/dev/sda1";
224 char mountpoint[] = "/";
227 r = guestfs_mount (g, device, mountpoint);
231 /* TestOutputInt for wc_c (0) */
233 char options[] = "ro";
234 char vfstype[] = "squashfs";
235 char device[] = "/dev/sdd";
236 char mountpoint[] = "/";
239 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
244 char path[] = "/100kallspaces";
247 r = guestfs_wc_c (g, path);
251 fprintf (stderr, "test_wc_c_0: expected 102400 but got %d\n", (int) r);
258 static int test_wc_w_0_skip (void)
262 str = getenv ("TEST_ONLY");
264 return strstr (str, "wc_w") == NULL;
265 str = getenv ("SKIP_TEST_WC_W_0");
266 if (str && strcmp (str, "1") == 0) return 1;
267 str = getenv ("SKIP_TEST_WC_W");
268 if (str && strcmp (str, "1") == 0) return 1;
272 static int test_wc_w_0 (void)
274 if (test_wc_w_0_skip ()) {
275 printf ("%s skipped (reason: environment variable set)\n", "test_wc_w_0");
279 /* InitBasicFS for test_wc_w_0: create ext2 on /dev/sda1 */
281 char device[] = "/dev/sda";
284 r = guestfs_blockdev_setrw (g, device);
291 r = guestfs_umount_all (g);
298 r = guestfs_lvm_remove_all (g);
303 char device[] = "/dev/sda";
304 char lines_0[] = ",";
311 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
316 char fstype[] = "ext2";
317 char device[] = "/dev/sda1";
320 r = guestfs_mkfs (g, fstype, device);
325 char device[] = "/dev/sda1";
326 char mountpoint[] = "/";
329 r = guestfs_mount (g, device, mountpoint);
333 /* TestOutputInt for wc_w (0) */
335 char options[] = "ro";
336 char vfstype[] = "squashfs";
337 char device[] = "/dev/sdd";
338 char mountpoint[] = "/";
341 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
346 char path[] = "/10klines";
349 r = guestfs_wc_w (g, path);
353 fprintf (stderr, "test_wc_w_0: expected 10000 but got %d\n", (int) r);
360 static int test_wc_l_0_skip (void)
364 str = getenv ("TEST_ONLY");
366 return strstr (str, "wc_l") == NULL;
367 str = getenv ("SKIP_TEST_WC_L_0");
368 if (str && strcmp (str, "1") == 0) return 1;
369 str = getenv ("SKIP_TEST_WC_L");
370 if (str && strcmp (str, "1") == 0) return 1;
374 static int test_wc_l_0 (void)
376 if (test_wc_l_0_skip ()) {
377 printf ("%s skipped (reason: environment variable set)\n", "test_wc_l_0");
381 /* InitBasicFS for test_wc_l_0: create ext2 on /dev/sda1 */
383 char device[] = "/dev/sda";
386 r = guestfs_blockdev_setrw (g, device);
393 r = guestfs_umount_all (g);
400 r = guestfs_lvm_remove_all (g);
405 char device[] = "/dev/sda";
406 char lines_0[] = ",";
413 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
418 char fstype[] = "ext2";
419 char device[] = "/dev/sda1";
422 r = guestfs_mkfs (g, fstype, device);
427 char device[] = "/dev/sda1";
428 char mountpoint[] = "/";
431 r = guestfs_mount (g, device, mountpoint);
435 /* TestOutputInt for wc_l (0) */
437 char options[] = "ro";
438 char vfstype[] = "squashfs";
439 char device[] = "/dev/sdd";
440 char mountpoint[] = "/";
443 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
448 char path[] = "/10klines";
451 r = guestfs_wc_l (g, path);
455 fprintf (stderr, "test_wc_l_0: expected 10000 but got %d\n", (int) r);
462 static int test_mkdtemp_0_skip (void)
466 str = getenv ("TEST_ONLY");
468 return strstr (str, "mkdtemp") == NULL;
469 str = getenv ("SKIP_TEST_MKDTEMP_0");
470 if (str && strcmp (str, "1") == 0) return 1;
471 str = getenv ("SKIP_TEST_MKDTEMP");
472 if (str && strcmp (str, "1") == 0) return 1;
476 static int test_mkdtemp_0 (void)
478 if (test_mkdtemp_0_skip ()) {
479 printf ("%s skipped (reason: environment variable set)\n", "test_mkdtemp_0");
483 /* InitBasicFS for test_mkdtemp_0: create ext2 on /dev/sda1 */
485 char device[] = "/dev/sda";
488 r = guestfs_blockdev_setrw (g, device);
495 r = guestfs_umount_all (g);
502 r = guestfs_lvm_remove_all (g);
507 char device[] = "/dev/sda";
508 char lines_0[] = ",";
515 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
520 char fstype[] = "ext2";
521 char device[] = "/dev/sda1";
524 r = guestfs_mkfs (g, fstype, device);
529 char device[] = "/dev/sda1";
530 char mountpoint[] = "/";
533 r = guestfs_mount (g, device, mountpoint);
537 /* TestRun for mkdtemp (0) */
539 char path[] = "/tmp";
542 r = guestfs_mkdir (g, path);
547 char template[] = "/tmp/tmpXXXXXX";
550 r = guestfs_mkdtemp (g, template);
558 static int test_scrub_file_0_skip (void)
562 str = getenv ("TEST_ONLY");
564 return strstr (str, "scrub_file") == NULL;
565 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
566 if (str && strcmp (str, "1") == 0) return 1;
567 str = getenv ("SKIP_TEST_SCRUB_FILE");
568 if (str && strcmp (str, "1") == 0) return 1;
572 static int test_scrub_file_0 (void)
574 if (test_scrub_file_0_skip ()) {
575 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_file_0");
579 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
581 char device[] = "/dev/sda";
584 r = guestfs_blockdev_setrw (g, device);
591 r = guestfs_umount_all (g);
598 r = guestfs_lvm_remove_all (g);
603 char device[] = "/dev/sda";
604 char lines_0[] = ",";
611 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
616 char fstype[] = "ext2";
617 char device[] = "/dev/sda1";
620 r = guestfs_mkfs (g, fstype, device);
625 char device[] = "/dev/sda1";
626 char mountpoint[] = "/";
629 r = guestfs_mount (g, device, mountpoint);
633 /* TestRun for scrub_file (0) */
635 char path[] = "/file";
636 char content[] = "content";
639 r = guestfs_write_file (g, path, content, 0);
644 char file[] = "/file";
647 r = guestfs_scrub_file (g, file);
654 static int test_scrub_device_0_skip (void)
658 str = getenv ("TEST_ONLY");
660 return strstr (str, "scrub_device") == NULL;
661 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
662 if (str && strcmp (str, "1") == 0) return 1;
663 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
664 if (str && strcmp (str, "1") == 0) return 1;
668 static int test_scrub_device_0 (void)
670 if (test_scrub_device_0_skip ()) {
671 printf ("%s skipped (reason: environment variable set)\n", "test_scrub_device_0");
675 /* InitNone|InitEmpty for test_scrub_device_0 */
677 char device[] = "/dev/sda";
680 r = guestfs_blockdev_setrw (g, device);
687 r = guestfs_umount_all (g);
694 r = guestfs_lvm_remove_all (g);
698 /* TestRun for scrub_device (0) */
700 char device[] = "/dev/sdc";
703 r = guestfs_scrub_device (g, device);
710 static int test_glob_expand_0_skip (void)
714 str = getenv ("TEST_ONLY");
716 return strstr (str, "glob_expand") == NULL;
717 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
718 if (str && strcmp (str, "1") == 0) return 1;
719 str = getenv ("SKIP_TEST_GLOB_EXPAND");
720 if (str && strcmp (str, "1") == 0) return 1;
724 static int test_glob_expand_0 (void)
726 if (test_glob_expand_0_skip ()) {
727 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_0");
731 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
733 char device[] = "/dev/sda";
736 r = guestfs_blockdev_setrw (g, device);
743 r = guestfs_umount_all (g);
750 r = guestfs_lvm_remove_all (g);
755 char device[] = "/dev/sda";
756 char lines_0[] = ",";
763 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
768 char fstype[] = "ext2";
769 char device[] = "/dev/sda1";
772 r = guestfs_mkfs (g, fstype, device);
777 char device[] = "/dev/sda1";
778 char mountpoint[] = "/";
781 r = guestfs_mount (g, device, mountpoint);
785 /* TestOutputList for glob_expand (0) */
787 char path[] = "/a/b/c";
790 r = guestfs_mkdir_p (g, path);
795 char path[] = "/a/b/c/d";
798 r = guestfs_touch (g, path);
803 char path[] = "/a/b/c/e";
806 r = guestfs_touch (g, path);
811 char pattern[] = "/a/b/c/*";
815 r = guestfs_glob_expand (g, pattern);
819 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
824 char expected[] = "/a/b/c/d";
825 if (strcmp (r[0], expected) != 0) {
826 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
831 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
836 char expected[] = "/a/b/c/e";
837 if (strcmp (r[1], expected) != 0) {
838 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
843 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
847 for (i = 0; r[i] != NULL; ++i)
854 static int test_glob_expand_1_skip (void)
858 str = getenv ("TEST_ONLY");
860 return strstr (str, "glob_expand") == NULL;
861 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
862 if (str && strcmp (str, "1") == 0) return 1;
863 str = getenv ("SKIP_TEST_GLOB_EXPAND");
864 if (str && strcmp (str, "1") == 0) return 1;
868 static int test_glob_expand_1 (void)
870 if (test_glob_expand_1_skip ()) {
871 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_1");
875 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
877 char device[] = "/dev/sda";
880 r = guestfs_blockdev_setrw (g, device);
887 r = guestfs_umount_all (g);
894 r = guestfs_lvm_remove_all (g);
899 char device[] = "/dev/sda";
900 char lines_0[] = ",";
907 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
912 char fstype[] = "ext2";
913 char device[] = "/dev/sda1";
916 r = guestfs_mkfs (g, fstype, device);
921 char device[] = "/dev/sda1";
922 char mountpoint[] = "/";
925 r = guestfs_mount (g, device, mountpoint);
929 /* TestOutputList for glob_expand (1) */
931 char path[] = "/a/b/c";
934 r = guestfs_mkdir_p (g, path);
939 char path[] = "/a/b/c/d";
942 r = guestfs_touch (g, path);
947 char path[] = "/a/b/c/e";
950 r = guestfs_touch (g, path);
955 char pattern[] = "/a/*/c/*";
959 r = guestfs_glob_expand (g, pattern);
963 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
968 char expected[] = "/a/b/c/d";
969 if (strcmp (r[0], expected) != 0) {
970 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
975 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
980 char expected[] = "/a/b/c/e";
981 if (strcmp (r[1], expected) != 0) {
982 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
987 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
991 for (i = 0; r[i] != NULL; ++i)
998 static int test_glob_expand_2_skip (void)
1002 str = getenv ("TEST_ONLY");
1004 return strstr (str, "glob_expand") == NULL;
1005 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
1006 if (str && strcmp (str, "1") == 0) return 1;
1007 str = getenv ("SKIP_TEST_GLOB_EXPAND");
1008 if (str && strcmp (str, "1") == 0) return 1;
1012 static int test_glob_expand_2 (void)
1014 if (test_glob_expand_2_skip ()) {
1015 printf ("%s skipped (reason: environment variable set)\n", "test_glob_expand_2");
1019 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
1021 char device[] = "/dev/sda";
1024 r = guestfs_blockdev_setrw (g, device);
1031 r = guestfs_umount_all (g);
1038 r = guestfs_lvm_remove_all (g);
1043 char device[] = "/dev/sda";
1044 char lines_0[] = ",";
1051 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1056 char fstype[] = "ext2";
1057 char device[] = "/dev/sda1";
1060 r = guestfs_mkfs (g, fstype, device);
1065 char device[] = "/dev/sda1";
1066 char mountpoint[] = "/";
1069 r = guestfs_mount (g, device, mountpoint);
1073 /* TestOutputList for glob_expand (2) */
1075 char path[] = "/a/b/c";
1078 r = guestfs_mkdir_p (g, path);
1083 char path[] = "/a/b/c/d";
1086 r = guestfs_touch (g, path);
1091 char path[] = "/a/b/c/e";
1094 r = guestfs_touch (g, path);
1099 char pattern[] = "/a/*/x/*";
1103 r = guestfs_glob_expand (g, pattern);
1107 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
1111 for (i = 0; r[i] != NULL; ++i)
1118 static int test_ntfs_3g_probe_0_skip (void)
1122 str = getenv ("TEST_ONLY");
1124 return strstr (str, "ntfs_3g_probe") == NULL;
1125 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
1126 if (str && strcmp (str, "1") == 0) return 1;
1127 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
1128 if (str && strcmp (str, "1") == 0) return 1;
1132 static int test_ntfs_3g_probe_0 (void)
1134 if (test_ntfs_3g_probe_0_skip ()) {
1135 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_0");
1139 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
1141 char device[] = "/dev/sda";
1144 r = guestfs_blockdev_setrw (g, device);
1151 r = guestfs_umount_all (g);
1158 r = guestfs_lvm_remove_all (g);
1162 /* TestOutputInt for ntfs_3g_probe (0) */
1164 char device[] = "/dev/sda";
1165 char lines_0[] = ",";
1172 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1177 char fstype[] = "ntfs";
1178 char device[] = "/dev/sda1";
1181 r = guestfs_mkfs (g, fstype, device);
1186 char device[] = "/dev/sda1";
1189 r = guestfs_ntfs_3g_probe (g, 1, device);
1193 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
1200 static int test_ntfs_3g_probe_1_skip (void)
1204 str = getenv ("TEST_ONLY");
1206 return strstr (str, "ntfs_3g_probe") == NULL;
1207 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
1208 if (str && strcmp (str, "1") == 0) return 1;
1209 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
1210 if (str && strcmp (str, "1") == 0) return 1;
1214 static int test_ntfs_3g_probe_1 (void)
1216 if (test_ntfs_3g_probe_1_skip ()) {
1217 printf ("%s skipped (reason: environment variable set)\n", "test_ntfs_3g_probe_1");
1221 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
1223 char device[] = "/dev/sda";
1226 r = guestfs_blockdev_setrw (g, device);
1233 r = guestfs_umount_all (g);
1240 r = guestfs_lvm_remove_all (g);
1244 /* TestOutputInt for ntfs_3g_probe (1) */
1246 char device[] = "/dev/sda";
1247 char lines_0[] = ",";
1254 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1259 char fstype[] = "ext2";
1260 char device[] = "/dev/sda1";
1263 r = guestfs_mkfs (g, fstype, device);
1268 char device[] = "/dev/sda1";
1271 r = guestfs_ntfs_3g_probe (g, 1, device);
1275 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
1282 static int test_sleep_0_skip (void)
1286 str = getenv ("TEST_ONLY");
1288 return strstr (str, "sleep") == NULL;
1289 str = getenv ("SKIP_TEST_SLEEP_0");
1290 if (str && strcmp (str, "1") == 0) return 1;
1291 str = getenv ("SKIP_TEST_SLEEP");
1292 if (str && strcmp (str, "1") == 0) return 1;
1296 static int test_sleep_0 (void)
1298 if (test_sleep_0_skip ()) {
1299 printf ("%s skipped (reason: environment variable set)\n", "test_sleep_0");
1303 /* InitNone|InitEmpty for test_sleep_0 */
1305 char device[] = "/dev/sda";
1308 r = guestfs_blockdev_setrw (g, device);
1315 r = guestfs_umount_all (g);
1322 r = guestfs_lvm_remove_all (g);
1326 /* TestRun for sleep (0) */
1330 r = guestfs_sleep (g, 1);
1337 static int test_find_0_skip (void)
1341 str = getenv ("TEST_ONLY");
1343 return strstr (str, "find") == NULL;
1344 str = getenv ("SKIP_TEST_FIND_0");
1345 if (str && strcmp (str, "1") == 0) return 1;
1346 str = getenv ("SKIP_TEST_FIND");
1347 if (str && strcmp (str, "1") == 0) return 1;
1351 static int test_find_0 (void)
1353 if (test_find_0_skip ()) {
1354 printf ("%s skipped (reason: environment variable set)\n", "test_find_0");
1358 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
1360 char device[] = "/dev/sda";
1363 r = guestfs_blockdev_setrw (g, device);
1370 r = guestfs_umount_all (g);
1377 r = guestfs_lvm_remove_all (g);
1382 char device[] = "/dev/sda";
1383 char lines_0[] = ",";
1390 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1395 char fstype[] = "ext2";
1396 char device[] = "/dev/sda1";
1399 r = guestfs_mkfs (g, fstype, device);
1404 char device[] = "/dev/sda1";
1405 char mountpoint[] = "/";
1408 r = guestfs_mount (g, device, mountpoint);
1412 /* TestOutputList for find (0) */
1414 char directory[] = "/";
1418 r = guestfs_find (g, directory);
1422 fprintf (stderr, "test_find_0: short list returned from command\n");
1427 char expected[] = "lost+found";
1428 if (strcmp (r[0], expected) != 0) {
1429 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1434 fprintf (stderr, "test_find_0: extra elements returned from command\n");
1438 for (i = 0; r[i] != NULL; ++i)
1445 static int test_find_1_skip (void)
1449 str = getenv ("TEST_ONLY");
1451 return strstr (str, "find") == NULL;
1452 str = getenv ("SKIP_TEST_FIND_1");
1453 if (str && strcmp (str, "1") == 0) return 1;
1454 str = getenv ("SKIP_TEST_FIND");
1455 if (str && strcmp (str, "1") == 0) return 1;
1459 static int test_find_1 (void)
1461 if (test_find_1_skip ()) {
1462 printf ("%s skipped (reason: environment variable set)\n", "test_find_1");
1466 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
1468 char device[] = "/dev/sda";
1471 r = guestfs_blockdev_setrw (g, device);
1478 r = guestfs_umount_all (g);
1485 r = guestfs_lvm_remove_all (g);
1490 char device[] = "/dev/sda";
1491 char lines_0[] = ",";
1498 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1503 char fstype[] = "ext2";
1504 char device[] = "/dev/sda1";
1507 r = guestfs_mkfs (g, fstype, device);
1512 char device[] = "/dev/sda1";
1513 char mountpoint[] = "/";
1516 r = guestfs_mount (g, device, mountpoint);
1520 /* TestOutputList for find (1) */
1525 r = guestfs_touch (g, path);
1533 r = guestfs_mkdir (g, path);
1538 char path[] = "/b/c";
1541 r = guestfs_touch (g, path);
1546 char directory[] = "/";
1550 r = guestfs_find (g, directory);
1554 fprintf (stderr, "test_find_1: short list returned from command\n");
1559 char expected[] = "a";
1560 if (strcmp (r[0], expected) != 0) {
1561 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1566 fprintf (stderr, "test_find_1: short list returned from command\n");
1571 char expected[] = "b";
1572 if (strcmp (r[1], expected) != 0) {
1573 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1578 fprintf (stderr, "test_find_1: short list returned from command\n");
1583 char expected[] = "b/c";
1584 if (strcmp (r[2], expected) != 0) {
1585 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1590 fprintf (stderr, "test_find_1: short list returned from command\n");
1595 char expected[] = "lost+found";
1596 if (strcmp (r[3], expected) != 0) {
1597 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1602 fprintf (stderr, "test_find_1: extra elements returned from command\n");
1606 for (i = 0; r[i] != NULL; ++i)
1613 static int test_find_2_skip (void)
1617 str = getenv ("TEST_ONLY");
1619 return strstr (str, "find") == NULL;
1620 str = getenv ("SKIP_TEST_FIND_2");
1621 if (str && strcmp (str, "1") == 0) return 1;
1622 str = getenv ("SKIP_TEST_FIND");
1623 if (str && strcmp (str, "1") == 0) return 1;
1627 static int test_find_2 (void)
1629 if (test_find_2_skip ()) {
1630 printf ("%s skipped (reason: environment variable set)\n", "test_find_2");
1634 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1636 char device[] = "/dev/sda";
1639 r = guestfs_blockdev_setrw (g, device);
1646 r = guestfs_umount_all (g);
1653 r = guestfs_lvm_remove_all (g);
1658 char device[] = "/dev/sda";
1659 char lines_0[] = ",";
1666 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1671 char fstype[] = "ext2";
1672 char device[] = "/dev/sda1";
1675 r = guestfs_mkfs (g, fstype, device);
1680 char device[] = "/dev/sda1";
1681 char mountpoint[] = "/";
1684 r = guestfs_mount (g, device, mountpoint);
1688 /* TestOutputList for find (2) */
1690 char path[] = "/a/b/c";
1693 r = guestfs_mkdir_p (g, path);
1698 char path[] = "/a/b/c/d";
1701 r = guestfs_touch (g, path);
1706 char directory[] = "/a/b/";
1710 r = guestfs_find (g, directory);
1714 fprintf (stderr, "test_find_2: short list returned from command\n");
1719 char expected[] = "c";
1720 if (strcmp (r[0], expected) != 0) {
1721 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1726 fprintf (stderr, "test_find_2: short list returned from command\n");
1731 char expected[] = "c/d";
1732 if (strcmp (r[1], expected) != 0) {
1733 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1738 fprintf (stderr, "test_find_2: extra elements returned from command\n");
1742 for (i = 0; r[i] != NULL; ++i)
1749 static int test_lvresize_0_skip (void)
1753 str = getenv ("TEST_ONLY");
1755 return strstr (str, "lvresize") == NULL;
1756 str = getenv ("SKIP_TEST_LVRESIZE_0");
1757 if (str && strcmp (str, "1") == 0) return 1;
1758 str = getenv ("SKIP_TEST_LVRESIZE");
1759 if (str && strcmp (str, "1") == 0) return 1;
1763 static int test_lvresize_0 (void)
1765 if (test_lvresize_0_skip ()) {
1766 printf ("%s skipped (reason: environment variable set)\n", "test_lvresize_0");
1770 /* InitNone|InitEmpty for test_lvresize_0 */
1772 char device[] = "/dev/sda";
1775 r = guestfs_blockdev_setrw (g, device);
1782 r = guestfs_umount_all (g);
1789 r = guestfs_lvm_remove_all (g);
1793 /* TestOutput for lvresize (0) */
1794 char expected[] = "test content";
1796 char device[] = "/dev/sda";
1797 char lines_0[] = ",";
1804 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1809 char device[] = "/dev/sda1";
1812 r = guestfs_pvcreate (g, device);
1817 char volgroup[] = "VG";
1818 char physvols_0[] = "/dev/sda1";
1819 char *physvols[] = {
1825 r = guestfs_vgcreate (g, volgroup, physvols);
1830 char logvol[] = "LV";
1831 char volgroup[] = "VG";
1834 r = guestfs_lvcreate (g, logvol, volgroup, 10);
1839 char fstype[] = "ext2";
1840 char device[] = "/dev/VG/LV";
1843 r = guestfs_mkfs (g, fstype, device);
1848 char device[] = "/dev/VG/LV";
1849 char mountpoint[] = "/";
1852 r = guestfs_mount (g, device, mountpoint);
1857 char path[] = "/new";
1858 char content[] = "test content";
1861 r = guestfs_write_file (g, path, content, 0);
1866 char pathordevice[] = "/";
1869 r = guestfs_umount (g, pathordevice);
1874 char device[] = "/dev/VG/LV";
1877 r = guestfs_lvresize (g, device, 20);
1882 char device[] = "/dev/VG/LV";
1885 r = guestfs_e2fsck_f (g, device);
1890 char device[] = "/dev/VG/LV";
1893 r = guestfs_resize2fs (g, device);
1898 char device[] = "/dev/VG/LV";
1899 char mountpoint[] = "/";
1902 r = guestfs_mount (g, device, mountpoint);
1907 char path[] = "/new";
1910 r = guestfs_cat (g, path);
1913 if (strcmp (r, expected) != 0) {
1914 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1922 static int test_zerofree_0_skip (void)
1926 str = getenv ("TEST_ONLY");
1928 return strstr (str, "zerofree") == NULL;
1929 str = getenv ("SKIP_TEST_ZEROFREE_0");
1930 if (str && strcmp (str, "1") == 0) return 1;
1931 str = getenv ("SKIP_TEST_ZEROFREE");
1932 if (str && strcmp (str, "1") == 0) return 1;
1936 static int test_zerofree_0 (void)
1938 if (test_zerofree_0_skip ()) {
1939 printf ("%s skipped (reason: environment variable set)\n", "test_zerofree_0");
1943 /* InitNone|InitEmpty for test_zerofree_0 */
1945 char device[] = "/dev/sda";
1948 r = guestfs_blockdev_setrw (g, device);
1955 r = guestfs_umount_all (g);
1962 r = guestfs_lvm_remove_all (g);
1966 /* TestOutput for zerofree (0) */
1967 char expected[] = "test file";
1969 char device[] = "/dev/sda";
1970 char lines_0[] = ",";
1977 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1982 char fstype[] = "ext3";
1983 char device[] = "/dev/sda1";
1986 r = guestfs_mkfs (g, fstype, device);
1991 char device[] = "/dev/sda1";
1992 char mountpoint[] = "/";
1995 r = guestfs_mount (g, device, mountpoint);
2000 char path[] = "/new";
2001 char content[] = "test file";
2004 r = guestfs_write_file (g, path, content, 0);
2009 char pathordevice[] = "/dev/sda1";
2012 r = guestfs_umount (g, pathordevice);
2017 char device[] = "/dev/sda1";
2020 r = guestfs_zerofree (g, device);
2025 char device[] = "/dev/sda1";
2026 char mountpoint[] = "/";
2029 r = guestfs_mount (g, device, mountpoint);
2034 char path[] = "/new";
2037 r = guestfs_cat (g, path);
2040 if (strcmp (r, expected) != 0) {
2041 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
2049 static int test_hexdump_0_skip (void)
2053 str = getenv ("TEST_ONLY");
2055 return strstr (str, "hexdump") == NULL;
2056 str = getenv ("SKIP_TEST_HEXDUMP_0");
2057 if (str && strcmp (str, "1") == 0) return 1;
2058 str = getenv ("SKIP_TEST_HEXDUMP");
2059 if (str && strcmp (str, "1") == 0) return 1;
2063 static int test_hexdump_0 (void)
2065 if (test_hexdump_0_skip ()) {
2066 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_0");
2070 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
2072 char device[] = "/dev/sda";
2075 r = guestfs_blockdev_setrw (g, device);
2082 r = guestfs_umount_all (g);
2089 r = guestfs_lvm_remove_all (g);
2094 char device[] = "/dev/sda";
2095 char lines_0[] = ",";
2102 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2107 char fstype[] = "ext2";
2108 char device[] = "/dev/sda1";
2111 r = guestfs_mkfs (g, fstype, device);
2116 char device[] = "/dev/sda1";
2117 char mountpoint[] = "/";
2120 r = guestfs_mount (g, device, mountpoint);
2124 /* TestOutput for hexdump (0) */
2125 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
2127 char path[] = "/new";
2128 char content[] = "hello\nworld\n";
2131 r = guestfs_write_file (g, path, content, 12);
2136 char path[] = "/new";
2139 r = guestfs_hexdump (g, path);
2142 if (strcmp (r, expected) != 0) {
2143 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
2151 static int test_hexdump_1_skip (void)
2155 str = getenv ("TEST_ONLY");
2157 return strstr (str, "hexdump") == NULL;
2158 str = getenv ("SKIP_TEST_HEXDUMP_1");
2159 if (str && strcmp (str, "1") == 0) return 1;
2160 str = getenv ("SKIP_TEST_HEXDUMP");
2161 if (str && strcmp (str, "1") == 0) return 1;
2165 static int test_hexdump_1 (void)
2167 if (test_hexdump_1_skip ()) {
2168 printf ("%s skipped (reason: environment variable set)\n", "test_hexdump_1");
2172 /* InitBasicFS for test_hexdump_1: create ext2 on /dev/sda1 */
2174 char device[] = "/dev/sda";
2177 r = guestfs_blockdev_setrw (g, device);
2184 r = guestfs_umount_all (g);
2191 r = guestfs_lvm_remove_all (g);
2196 char device[] = "/dev/sda";
2197 char lines_0[] = ",";
2204 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2209 char fstype[] = "ext2";
2210 char device[] = "/dev/sda1";
2213 r = guestfs_mkfs (g, fstype, device);
2218 char device[] = "/dev/sda1";
2219 char mountpoint[] = "/";
2222 r = guestfs_mount (g, device, mountpoint);
2226 /* TestRun for hexdump (1) */
2228 char options[] = "ro";
2229 char vfstype[] = "squashfs";
2230 char device[] = "/dev/sdd";
2231 char mountpoint[] = "/";
2234 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
2239 char path[] = "/100krandom";
2242 r = guestfs_hexdump (g, path);
2250 static int test_strings_e_0_skip (void)
2254 str = getenv ("TEST_ONLY");
2256 return strstr (str, "strings_e") == NULL;
2257 str = getenv ("SKIP_TEST_STRINGS_E_0");
2258 if (str && strcmp (str, "1") == 0) return 1;
2259 str = getenv ("SKIP_TEST_STRINGS_E");
2260 if (str && strcmp (str, "1") == 0) return 1;
2264 static int test_strings_e_0 (void)
2266 if (test_strings_e_0_skip ()) {
2267 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_0");
2271 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
2273 char device[] = "/dev/sda";
2276 r = guestfs_blockdev_setrw (g, device);
2283 r = guestfs_umount_all (g);
2290 r = guestfs_lvm_remove_all (g);
2295 char device[] = "/dev/sda";
2296 char lines_0[] = ",";
2303 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2308 char fstype[] = "ext2";
2309 char device[] = "/dev/sda1";
2312 r = guestfs_mkfs (g, fstype, device);
2317 char device[] = "/dev/sda1";
2318 char mountpoint[] = "/";
2321 r = guestfs_mount (g, device, mountpoint);
2325 /* TestOutputList for strings_e (0) */
2327 char path[] = "/new";
2328 char content[] = "hello\nworld\n";
2331 r = guestfs_write_file (g, path, content, 0);
2336 char encoding[] = "b";
2337 char path[] = "/new";
2341 r = guestfs_strings_e (g, encoding, path);
2345 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
2349 for (i = 0; r[i] != NULL; ++i)
2356 static int test_strings_e_1_skip (void)
2360 str = getenv ("TEST_ONLY");
2362 return strstr (str, "strings_e") == NULL;
2363 str = getenv ("SKIP_TEST_STRINGS_E_1");
2364 if (str && strcmp (str, "1") == 0) return 1;
2365 str = getenv ("SKIP_TEST_STRINGS_E");
2366 if (str && strcmp (str, "1") == 0) return 1;
2370 static int test_strings_e_1 (void)
2372 if (test_strings_e_1_skip ()) {
2373 printf ("%s skipped (reason: environment variable set)\n", "test_strings_e_1");
2377 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
2381 static int test_strings_0_skip (void)
2385 str = getenv ("TEST_ONLY");
2387 return strstr (str, "strings") == NULL;
2388 str = getenv ("SKIP_TEST_STRINGS_0");
2389 if (str && strcmp (str, "1") == 0) return 1;
2390 str = getenv ("SKIP_TEST_STRINGS");
2391 if (str && strcmp (str, "1") == 0) return 1;
2395 static int test_strings_0 (void)
2397 if (test_strings_0_skip ()) {
2398 printf ("%s skipped (reason: environment variable set)\n", "test_strings_0");
2402 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
2404 char device[] = "/dev/sda";
2407 r = guestfs_blockdev_setrw (g, device);
2414 r = guestfs_umount_all (g);
2421 r = guestfs_lvm_remove_all (g);
2426 char device[] = "/dev/sda";
2427 char lines_0[] = ",";
2434 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2439 char fstype[] = "ext2";
2440 char device[] = "/dev/sda1";
2443 r = guestfs_mkfs (g, fstype, device);
2448 char device[] = "/dev/sda1";
2449 char mountpoint[] = "/";
2452 r = guestfs_mount (g, device, mountpoint);
2456 /* TestOutputList for strings (0) */
2458 char path[] = "/new";
2459 char content[] = "hello\nworld\n";
2462 r = guestfs_write_file (g, path, content, 0);
2467 char path[] = "/new";
2471 r = guestfs_strings (g, path);
2475 fprintf (stderr, "test_strings_0: short list returned from command\n");
2480 char expected[] = "hello";
2481 if (strcmp (r[0], expected) != 0) {
2482 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2487 fprintf (stderr, "test_strings_0: short list returned from command\n");
2492 char expected[] = "world";
2493 if (strcmp (r[1], expected) != 0) {
2494 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2499 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
2503 for (i = 0; r[i] != NULL; ++i)
2510 static int test_strings_1_skip (void)
2514 str = getenv ("TEST_ONLY");
2516 return strstr (str, "strings") == NULL;
2517 str = getenv ("SKIP_TEST_STRINGS_1");
2518 if (str && strcmp (str, "1") == 0) return 1;
2519 str = getenv ("SKIP_TEST_STRINGS");
2520 if (str && strcmp (str, "1") == 0) return 1;
2524 static int test_strings_1 (void)
2526 if (test_strings_1_skip ()) {
2527 printf ("%s skipped (reason: environment variable set)\n", "test_strings_1");
2531 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
2533 char device[] = "/dev/sda";
2536 r = guestfs_blockdev_setrw (g, device);
2543 r = guestfs_umount_all (g);
2550 r = guestfs_lvm_remove_all (g);
2555 char device[] = "/dev/sda";
2556 char lines_0[] = ",";
2563 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2568 char fstype[] = "ext2";
2569 char device[] = "/dev/sda1";
2572 r = guestfs_mkfs (g, fstype, device);
2577 char device[] = "/dev/sda1";
2578 char mountpoint[] = "/";
2581 r = guestfs_mount (g, device, mountpoint);
2585 /* TestOutputList for strings (1) */
2587 char path[] = "/new";
2590 r = guestfs_touch (g, path);
2595 char path[] = "/new";
2599 r = guestfs_strings (g, path);
2603 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2607 for (i = 0; r[i] != NULL; ++i)
2614 static int test_equal_0_skip (void)
2618 str = getenv ("TEST_ONLY");
2620 return strstr (str, "equal") == NULL;
2621 str = getenv ("SKIP_TEST_EQUAL_0");
2622 if (str && strcmp (str, "1") == 0) return 1;
2623 str = getenv ("SKIP_TEST_EQUAL");
2624 if (str && strcmp (str, "1") == 0) return 1;
2628 static int test_equal_0 (void)
2630 if (test_equal_0_skip ()) {
2631 printf ("%s skipped (reason: environment variable set)\n", "test_equal_0");
2635 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2637 char device[] = "/dev/sda";
2640 r = guestfs_blockdev_setrw (g, device);
2647 r = guestfs_umount_all (g);
2654 r = guestfs_lvm_remove_all (g);
2659 char device[] = "/dev/sda";
2660 char lines_0[] = ",";
2667 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2672 char fstype[] = "ext2";
2673 char device[] = "/dev/sda1";
2676 r = guestfs_mkfs (g, fstype, device);
2681 char device[] = "/dev/sda1";
2682 char mountpoint[] = "/";
2685 r = guestfs_mount (g, device, mountpoint);
2689 /* TestOutputTrue for equal (0) */
2691 char path[] = "/file1";
2692 char content[] = "contents of a file";
2695 r = guestfs_write_file (g, path, content, 0);
2700 char src[] = "/file1";
2701 char dest[] = "/file2";
2704 r = guestfs_cp (g, src, dest);
2709 char file1[] = "/file1";
2710 char file2[] = "/file2";
2713 r = guestfs_equal (g, file1, file2);
2717 fprintf (stderr, "test_equal_0: expected true, got false\n");
2724 static int test_equal_1_skip (void)
2728 str = getenv ("TEST_ONLY");
2730 return strstr (str, "equal") == NULL;
2731 str = getenv ("SKIP_TEST_EQUAL_1");
2732 if (str && strcmp (str, "1") == 0) return 1;
2733 str = getenv ("SKIP_TEST_EQUAL");
2734 if (str && strcmp (str, "1") == 0) return 1;
2738 static int test_equal_1 (void)
2740 if (test_equal_1_skip ()) {
2741 printf ("%s skipped (reason: environment variable set)\n", "test_equal_1");
2745 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2747 char device[] = "/dev/sda";
2750 r = guestfs_blockdev_setrw (g, device);
2757 r = guestfs_umount_all (g);
2764 r = guestfs_lvm_remove_all (g);
2769 char device[] = "/dev/sda";
2770 char lines_0[] = ",";
2777 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2782 char fstype[] = "ext2";
2783 char device[] = "/dev/sda1";
2786 r = guestfs_mkfs (g, fstype, device);
2791 char device[] = "/dev/sda1";
2792 char mountpoint[] = "/";
2795 r = guestfs_mount (g, device, mountpoint);
2799 /* TestOutputFalse for equal (1) */
2801 char path[] = "/file1";
2802 char content[] = "contents of a file";
2805 r = guestfs_write_file (g, path, content, 0);
2810 char path[] = "/file2";
2811 char content[] = "contents of another file";
2814 r = guestfs_write_file (g, path, content, 0);
2819 char file1[] = "/file1";
2820 char file2[] = "/file2";
2823 r = guestfs_equal (g, file1, file2);
2827 fprintf (stderr, "test_equal_1: expected false, got true\n");
2834 static int test_equal_2_skip (void)
2838 str = getenv ("TEST_ONLY");
2840 return strstr (str, "equal") == NULL;
2841 str = getenv ("SKIP_TEST_EQUAL_2");
2842 if (str && strcmp (str, "1") == 0) return 1;
2843 str = getenv ("SKIP_TEST_EQUAL");
2844 if (str && strcmp (str, "1") == 0) return 1;
2848 static int test_equal_2 (void)
2850 if (test_equal_2_skip ()) {
2851 printf ("%s skipped (reason: environment variable set)\n", "test_equal_2");
2855 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2857 char device[] = "/dev/sda";
2860 r = guestfs_blockdev_setrw (g, device);
2867 r = guestfs_umount_all (g);
2874 r = guestfs_lvm_remove_all (g);
2879 char device[] = "/dev/sda";
2880 char lines_0[] = ",";
2887 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2892 char fstype[] = "ext2";
2893 char device[] = "/dev/sda1";
2896 r = guestfs_mkfs (g, fstype, device);
2901 char device[] = "/dev/sda1";
2902 char mountpoint[] = "/";
2905 r = guestfs_mount (g, device, mountpoint);
2909 /* TestLastFail for equal (2) */
2911 char file1[] = "/file1";
2912 char file2[] = "/file2";
2915 r = guestfs_equal (g, file1, file2);
2922 static int test_ping_daemon_0_skip (void)
2926 str = getenv ("TEST_ONLY");
2928 return strstr (str, "ping_daemon") == NULL;
2929 str = getenv ("SKIP_TEST_PING_DAEMON_0");
2930 if (str && strcmp (str, "1") == 0) return 1;
2931 str = getenv ("SKIP_TEST_PING_DAEMON");
2932 if (str && strcmp (str, "1") == 0) return 1;
2936 static int test_ping_daemon_0 (void)
2938 if (test_ping_daemon_0_skip ()) {
2939 printf ("%s skipped (reason: environment variable set)\n", "test_ping_daemon_0");
2943 /* InitNone|InitEmpty for test_ping_daemon_0 */
2945 char device[] = "/dev/sda";
2948 r = guestfs_blockdev_setrw (g, device);
2955 r = guestfs_umount_all (g);
2962 r = guestfs_lvm_remove_all (g);
2966 /* TestRun for ping_daemon (0) */
2970 r = guestfs_ping_daemon (g);
2977 static int test_dmesg_0_skip (void)
2981 str = getenv ("TEST_ONLY");
2983 return strstr (str, "dmesg") == NULL;
2984 str = getenv ("SKIP_TEST_DMESG_0");
2985 if (str && strcmp (str, "1") == 0) return 1;
2986 str = getenv ("SKIP_TEST_DMESG");
2987 if (str && strcmp (str, "1") == 0) return 1;
2991 static int test_dmesg_0 (void)
2993 if (test_dmesg_0_skip ()) {
2994 printf ("%s skipped (reason: environment variable set)\n", "test_dmesg_0");
2998 /* InitNone|InitEmpty for test_dmesg_0 */
3000 char device[] = "/dev/sda";
3003 r = guestfs_blockdev_setrw (g, device);
3010 r = guestfs_umount_all (g);
3017 r = guestfs_lvm_remove_all (g);
3021 /* TestRun for dmesg (0) */
3025 r = guestfs_dmesg (g);
3033 static int test_drop_caches_0_skip (void)
3037 str = getenv ("TEST_ONLY");
3039 return strstr (str, "drop_caches") == NULL;
3040 str = getenv ("SKIP_TEST_DROP_CACHES_0");
3041 if (str && strcmp (str, "1") == 0) return 1;
3042 str = getenv ("SKIP_TEST_DROP_CACHES");
3043 if (str && strcmp (str, "1") == 0) return 1;
3047 static int test_drop_caches_0 (void)
3049 if (test_drop_caches_0_skip ()) {
3050 printf ("%s skipped (reason: environment variable set)\n", "test_drop_caches_0");
3054 /* InitNone|InitEmpty for test_drop_caches_0 */
3056 char device[] = "/dev/sda";
3059 r = guestfs_blockdev_setrw (g, device);
3066 r = guestfs_umount_all (g);
3073 r = guestfs_lvm_remove_all (g);
3077 /* TestRun for drop_caches (0) */
3081 r = guestfs_drop_caches (g, 3);
3088 static int test_mv_0_skip (void)
3092 str = getenv ("TEST_ONLY");
3094 return strstr (str, "mv") == NULL;
3095 str = getenv ("SKIP_TEST_MV_0");
3096 if (str && strcmp (str, "1") == 0) return 1;
3097 str = getenv ("SKIP_TEST_MV");
3098 if (str && strcmp (str, "1") == 0) return 1;
3102 static int test_mv_0 (void)
3104 if (test_mv_0_skip ()) {
3105 printf ("%s skipped (reason: environment variable set)\n", "test_mv_0");
3109 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
3111 char device[] = "/dev/sda";
3114 r = guestfs_blockdev_setrw (g, device);
3121 r = guestfs_umount_all (g);
3128 r = guestfs_lvm_remove_all (g);
3133 char device[] = "/dev/sda";
3134 char lines_0[] = ",";
3141 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3146 char fstype[] = "ext2";
3147 char device[] = "/dev/sda1";
3150 r = guestfs_mkfs (g, fstype, device);
3155 char device[] = "/dev/sda1";
3156 char mountpoint[] = "/";
3159 r = guestfs_mount (g, device, mountpoint);
3163 /* TestOutput for mv (0) */
3164 char expected[] = "file content";
3166 char path[] = "/old";
3167 char content[] = "file content";
3170 r = guestfs_write_file (g, path, content, 0);
3175 char src[] = "/old";
3176 char dest[] = "/new";
3179 r = guestfs_mv (g, src, dest);
3184 char path[] = "/new";
3187 r = guestfs_cat (g, path);
3190 if (strcmp (r, expected) != 0) {
3191 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
3199 static int test_mv_1_skip (void)
3203 str = getenv ("TEST_ONLY");
3205 return strstr (str, "mv") == NULL;
3206 str = getenv ("SKIP_TEST_MV_1");
3207 if (str && strcmp (str, "1") == 0) return 1;
3208 str = getenv ("SKIP_TEST_MV");
3209 if (str && strcmp (str, "1") == 0) return 1;
3213 static int test_mv_1 (void)
3215 if (test_mv_1_skip ()) {
3216 printf ("%s skipped (reason: environment variable set)\n", "test_mv_1");
3220 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
3222 char device[] = "/dev/sda";
3225 r = guestfs_blockdev_setrw (g, device);
3232 r = guestfs_umount_all (g);
3239 r = guestfs_lvm_remove_all (g);
3244 char device[] = "/dev/sda";
3245 char lines_0[] = ",";
3252 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3257 char fstype[] = "ext2";
3258 char device[] = "/dev/sda1";
3261 r = guestfs_mkfs (g, fstype, device);
3266 char device[] = "/dev/sda1";
3267 char mountpoint[] = "/";
3270 r = guestfs_mount (g, device, mountpoint);
3274 /* TestOutputFalse for mv (1) */
3276 char path[] = "/old";
3277 char content[] = "file content";
3280 r = guestfs_write_file (g, path, content, 0);
3285 char src[] = "/old";
3286 char dest[] = "/new";
3289 r = guestfs_mv (g, src, dest);
3294 char path[] = "/old";
3297 r = guestfs_is_file (g, path);
3301 fprintf (stderr, "test_mv_1: expected false, got true\n");
3308 static int test_cp_a_0_skip (void)
3312 str = getenv ("TEST_ONLY");
3314 return strstr (str, "cp_a") == NULL;
3315 str = getenv ("SKIP_TEST_CP_A_0");
3316 if (str && strcmp (str, "1") == 0) return 1;
3317 str = getenv ("SKIP_TEST_CP_A");
3318 if (str && strcmp (str, "1") == 0) return 1;
3322 static int test_cp_a_0 (void)
3324 if (test_cp_a_0_skip ()) {
3325 printf ("%s skipped (reason: environment variable set)\n", "test_cp_a_0");
3329 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
3331 char device[] = "/dev/sda";
3334 r = guestfs_blockdev_setrw (g, device);
3341 r = guestfs_umount_all (g);
3348 r = guestfs_lvm_remove_all (g);
3353 char device[] = "/dev/sda";
3354 char lines_0[] = ",";
3361 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3366 char fstype[] = "ext2";
3367 char device[] = "/dev/sda1";
3370 r = guestfs_mkfs (g, fstype, device);
3375 char device[] = "/dev/sda1";
3376 char mountpoint[] = "/";
3379 r = guestfs_mount (g, device, mountpoint);
3383 /* TestOutput for cp_a (0) */
3384 char expected[] = "file content";
3386 char path[] = "/olddir";
3389 r = guestfs_mkdir (g, path);
3394 char path[] = "/newdir";
3397 r = guestfs_mkdir (g, path);
3402 char path[] = "/olddir/file";
3403 char content[] = "file content";
3406 r = guestfs_write_file (g, path, content, 0);
3411 char src[] = "/olddir";
3412 char dest[] = "/newdir";
3415 r = guestfs_cp_a (g, src, dest);
3420 char path[] = "/newdir/olddir/file";
3423 r = guestfs_cat (g, path);
3426 if (strcmp (r, expected) != 0) {
3427 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
3435 static int test_cp_0_skip (void)
3439 str = getenv ("TEST_ONLY");
3441 return strstr (str, "cp") == NULL;
3442 str = getenv ("SKIP_TEST_CP_0");
3443 if (str && strcmp (str, "1") == 0) return 1;
3444 str = getenv ("SKIP_TEST_CP");
3445 if (str && strcmp (str, "1") == 0) return 1;
3449 static int test_cp_0 (void)
3451 if (test_cp_0_skip ()) {
3452 printf ("%s skipped (reason: environment variable set)\n", "test_cp_0");
3456 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
3458 char device[] = "/dev/sda";
3461 r = guestfs_blockdev_setrw (g, device);
3468 r = guestfs_umount_all (g);
3475 r = guestfs_lvm_remove_all (g);
3480 char device[] = "/dev/sda";
3481 char lines_0[] = ",";
3488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3493 char fstype[] = "ext2";
3494 char device[] = "/dev/sda1";
3497 r = guestfs_mkfs (g, fstype, device);
3502 char device[] = "/dev/sda1";
3503 char mountpoint[] = "/";
3506 r = guestfs_mount (g, device, mountpoint);
3510 /* TestOutput for cp (0) */
3511 char expected[] = "file content";
3513 char path[] = "/old";
3514 char content[] = "file content";
3517 r = guestfs_write_file (g, path, content, 0);
3522 char src[] = "/old";
3523 char dest[] = "/new";
3526 r = guestfs_cp (g, src, dest);
3531 char path[] = "/new";
3534 r = guestfs_cat (g, path);
3537 if (strcmp (r, expected) != 0) {
3538 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
3546 static int test_cp_1_skip (void)
3550 str = getenv ("TEST_ONLY");
3552 return strstr (str, "cp") == NULL;
3553 str = getenv ("SKIP_TEST_CP_1");
3554 if (str && strcmp (str, "1") == 0) return 1;
3555 str = getenv ("SKIP_TEST_CP");
3556 if (str && strcmp (str, "1") == 0) return 1;
3560 static int test_cp_1 (void)
3562 if (test_cp_1_skip ()) {
3563 printf ("%s skipped (reason: environment variable set)\n", "test_cp_1");
3567 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
3569 char device[] = "/dev/sda";
3572 r = guestfs_blockdev_setrw (g, device);
3579 r = guestfs_umount_all (g);
3586 r = guestfs_lvm_remove_all (g);
3591 char device[] = "/dev/sda";
3592 char lines_0[] = ",";
3599 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3604 char fstype[] = "ext2";
3605 char device[] = "/dev/sda1";
3608 r = guestfs_mkfs (g, fstype, device);
3613 char device[] = "/dev/sda1";
3614 char mountpoint[] = "/";
3617 r = guestfs_mount (g, device, mountpoint);
3621 /* TestOutputTrue for cp (1) */
3623 char path[] = "/old";
3624 char content[] = "file content";
3627 r = guestfs_write_file (g, path, content, 0);
3632 char src[] = "/old";
3633 char dest[] = "/new";
3636 r = guestfs_cp (g, src, dest);
3641 char path[] = "/old";
3644 r = guestfs_is_file (g, path);
3648 fprintf (stderr, "test_cp_1: expected true, got false\n");
3655 static int test_cp_2_skip (void)
3659 str = getenv ("TEST_ONLY");
3661 return strstr (str, "cp") == NULL;
3662 str = getenv ("SKIP_TEST_CP_2");
3663 if (str && strcmp (str, "1") == 0) return 1;
3664 str = getenv ("SKIP_TEST_CP");
3665 if (str && strcmp (str, "1") == 0) return 1;
3669 static int test_cp_2 (void)
3671 if (test_cp_2_skip ()) {
3672 printf ("%s skipped (reason: environment variable set)\n", "test_cp_2");
3676 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3678 char device[] = "/dev/sda";
3681 r = guestfs_blockdev_setrw (g, device);
3688 r = guestfs_umount_all (g);
3695 r = guestfs_lvm_remove_all (g);
3700 char device[] = "/dev/sda";
3701 char lines_0[] = ",";
3708 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3713 char fstype[] = "ext2";
3714 char device[] = "/dev/sda1";
3717 r = guestfs_mkfs (g, fstype, device);
3722 char device[] = "/dev/sda1";
3723 char mountpoint[] = "/";
3726 r = guestfs_mount (g, device, mountpoint);
3730 /* TestOutput for cp (2) */
3731 char expected[] = "file content";
3733 char path[] = "/old";
3734 char content[] = "file content";
3737 r = guestfs_write_file (g, path, content, 0);
3742 char path[] = "/dir";
3745 r = guestfs_mkdir (g, path);
3750 char src[] = "/old";
3751 char dest[] = "/dir/new";
3754 r = guestfs_cp (g, src, dest);
3759 char path[] = "/dir/new";
3762 r = guestfs_cat (g, path);
3765 if (strcmp (r, expected) != 0) {
3766 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3774 static int test_grub_install_0_skip (void)
3778 str = getenv ("TEST_ONLY");
3780 return strstr (str, "grub_install") == NULL;
3781 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3782 if (str && strcmp (str, "1") == 0) return 1;
3783 str = getenv ("SKIP_TEST_GRUB_INSTALL");
3784 if (str && strcmp (str, "1") == 0) return 1;
3788 static int test_grub_install_0 (void)
3790 if (test_grub_install_0_skip ()) {
3791 printf ("%s skipped (reason: environment variable set)\n", "test_grub_install_0");
3795 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3797 char device[] = "/dev/sda";
3800 r = guestfs_blockdev_setrw (g, device);
3807 r = guestfs_umount_all (g);
3814 r = guestfs_lvm_remove_all (g);
3819 char device[] = "/dev/sda";
3820 char lines_0[] = ",";
3827 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3832 char fstype[] = "ext2";
3833 char device[] = "/dev/sda1";
3836 r = guestfs_mkfs (g, fstype, device);
3841 char device[] = "/dev/sda1";
3842 char mountpoint[] = "/";
3845 r = guestfs_mount (g, device, mountpoint);
3849 /* TestOutputTrue for grub_install (0) */
3852 char device[] = "/dev/sda1";
3855 r = guestfs_grub_install (g, root, device);
3860 char path[] = "/boot";
3863 r = guestfs_is_dir (g, path);
3867 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3874 static int test_zero_0_skip (void)
3878 str = getenv ("TEST_ONLY");
3880 return strstr (str, "zero") == NULL;
3881 str = getenv ("SKIP_TEST_ZERO_0");
3882 if (str && strcmp (str, "1") == 0) return 1;
3883 str = getenv ("SKIP_TEST_ZERO");
3884 if (str && strcmp (str, "1") == 0) return 1;
3888 static int test_zero_0 (void)
3890 if (test_zero_0_skip ()) {
3891 printf ("%s skipped (reason: environment variable set)\n", "test_zero_0");
3895 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3897 char device[] = "/dev/sda";
3900 r = guestfs_blockdev_setrw (g, device);
3907 r = guestfs_umount_all (g);
3914 r = guestfs_lvm_remove_all (g);
3919 char device[] = "/dev/sda";
3920 char lines_0[] = ",";
3927 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3932 char fstype[] = "ext2";
3933 char device[] = "/dev/sda1";
3936 r = guestfs_mkfs (g, fstype, device);
3941 char device[] = "/dev/sda1";
3942 char mountpoint[] = "/";
3945 r = guestfs_mount (g, device, mountpoint);
3949 /* TestOutput for zero (0) */
3950 char expected[] = "data";
3952 char pathordevice[] = "/dev/sda1";
3955 r = guestfs_umount (g, pathordevice);
3960 char device[] = "/dev/sda1";
3963 r = guestfs_zero (g, device);
3968 char path[] = "/dev/sda1";
3971 r = guestfs_file (g, path);
3974 if (strcmp (r, expected) != 0) {
3975 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3983 static int test_fsck_0_skip (void)
3987 str = getenv ("TEST_ONLY");
3989 return strstr (str, "fsck") == NULL;
3990 str = getenv ("SKIP_TEST_FSCK_0");
3991 if (str && strcmp (str, "1") == 0) return 1;
3992 str = getenv ("SKIP_TEST_FSCK");
3993 if (str && strcmp (str, "1") == 0) return 1;
3997 static int test_fsck_0 (void)
3999 if (test_fsck_0_skip ()) {
4000 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_0");
4004 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
4006 char device[] = "/dev/sda";
4009 r = guestfs_blockdev_setrw (g, device);
4016 r = guestfs_umount_all (g);
4023 r = guestfs_lvm_remove_all (g);
4028 char device[] = "/dev/sda";
4029 char lines_0[] = ",";
4036 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4041 char fstype[] = "ext2";
4042 char device[] = "/dev/sda1";
4045 r = guestfs_mkfs (g, fstype, device);
4050 char device[] = "/dev/sda1";
4051 char mountpoint[] = "/";
4054 r = guestfs_mount (g, device, mountpoint);
4058 /* TestOutputInt for fsck (0) */
4060 char pathordevice[] = "/dev/sda1";
4063 r = guestfs_umount (g, pathordevice);
4068 char fstype[] = "ext2";
4069 char device[] = "/dev/sda1";
4072 r = guestfs_fsck (g, fstype, device);
4076 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
4083 static int test_fsck_1_skip (void)
4087 str = getenv ("TEST_ONLY");
4089 return strstr (str, "fsck") == NULL;
4090 str = getenv ("SKIP_TEST_FSCK_1");
4091 if (str && strcmp (str, "1") == 0) return 1;
4092 str = getenv ("SKIP_TEST_FSCK");
4093 if (str && strcmp (str, "1") == 0) return 1;
4097 static int test_fsck_1 (void)
4099 if (test_fsck_1_skip ()) {
4100 printf ("%s skipped (reason: environment variable set)\n", "test_fsck_1");
4104 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
4106 char device[] = "/dev/sda";
4109 r = guestfs_blockdev_setrw (g, device);
4116 r = guestfs_umount_all (g);
4123 r = guestfs_lvm_remove_all (g);
4128 char device[] = "/dev/sda";
4129 char lines_0[] = ",";
4136 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4141 char fstype[] = "ext2";
4142 char device[] = "/dev/sda1";
4145 r = guestfs_mkfs (g, fstype, device);
4150 char device[] = "/dev/sda1";
4151 char mountpoint[] = "/";
4154 r = guestfs_mount (g, device, mountpoint);
4158 /* TestOutputInt for fsck (1) */
4160 char pathordevice[] = "/dev/sda1";
4163 r = guestfs_umount (g, pathordevice);
4168 char device[] = "/dev/sda1";
4171 r = guestfs_zero (g, device);
4176 char fstype[] = "ext2";
4177 char device[] = "/dev/sda1";
4180 r = guestfs_fsck (g, fstype, device);
4184 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
4191 static int test_set_e2uuid_0_skip (void)
4195 str = getenv ("TEST_ONLY");
4197 return strstr (str, "set_e2uuid") == NULL;
4198 str = getenv ("SKIP_TEST_SET_E2UUID_0");
4199 if (str && strcmp (str, "1") == 0) return 1;
4200 str = getenv ("SKIP_TEST_SET_E2UUID");
4201 if (str && strcmp (str, "1") == 0) return 1;
4205 static int test_set_e2uuid_0 (void)
4207 if (test_set_e2uuid_0_skip ()) {
4208 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_0");
4212 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
4214 char device[] = "/dev/sda";
4217 r = guestfs_blockdev_setrw (g, device);
4224 r = guestfs_umount_all (g);
4231 r = guestfs_lvm_remove_all (g);
4236 char device[] = "/dev/sda";
4237 char lines_0[] = ",";
4244 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4249 char fstype[] = "ext2";
4250 char device[] = "/dev/sda1";
4253 r = guestfs_mkfs (g, fstype, device);
4258 char device[] = "/dev/sda1";
4259 char mountpoint[] = "/";
4262 r = guestfs_mount (g, device, mountpoint);
4266 /* TestOutput for set_e2uuid (0) */
4267 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
4269 char device[] = "/dev/sda1";
4270 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
4273 r = guestfs_set_e2uuid (g, device, uuid);
4278 char device[] = "/dev/sda1";
4281 r = guestfs_get_e2uuid (g, device);
4284 if (strcmp (r, expected) != 0) {
4285 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
4293 static int test_set_e2uuid_1_skip (void)
4297 str = getenv ("TEST_ONLY");
4299 return strstr (str, "set_e2uuid") == NULL;
4300 str = getenv ("SKIP_TEST_SET_E2UUID_1");
4301 if (str && strcmp (str, "1") == 0) return 1;
4302 str = getenv ("SKIP_TEST_SET_E2UUID");
4303 if (str && strcmp (str, "1") == 0) return 1;
4307 static int test_set_e2uuid_1 (void)
4309 if (test_set_e2uuid_1_skip ()) {
4310 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_1");
4314 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
4316 char device[] = "/dev/sda";
4319 r = guestfs_blockdev_setrw (g, device);
4326 r = guestfs_umount_all (g);
4333 r = guestfs_lvm_remove_all (g);
4338 char device[] = "/dev/sda";
4339 char lines_0[] = ",";
4346 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4351 char fstype[] = "ext2";
4352 char device[] = "/dev/sda1";
4355 r = guestfs_mkfs (g, fstype, device);
4360 char device[] = "/dev/sda1";
4361 char mountpoint[] = "/";
4364 r = guestfs_mount (g, device, mountpoint);
4368 /* TestOutput for set_e2uuid (1) */
4369 char expected[] = "";
4371 char device[] = "/dev/sda1";
4372 char uuid[] = "clear";
4375 r = guestfs_set_e2uuid (g, device, uuid);
4380 char device[] = "/dev/sda1";
4383 r = guestfs_get_e2uuid (g, device);
4386 if (strcmp (r, expected) != 0) {
4387 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
4395 static int test_set_e2uuid_2_skip (void)
4399 str = getenv ("TEST_ONLY");
4401 return strstr (str, "set_e2uuid") == NULL;
4402 str = getenv ("SKIP_TEST_SET_E2UUID_2");
4403 if (str && strcmp (str, "1") == 0) return 1;
4404 str = getenv ("SKIP_TEST_SET_E2UUID");
4405 if (str && strcmp (str, "1") == 0) return 1;
4409 static int test_set_e2uuid_2 (void)
4411 if (test_set_e2uuid_2_skip ()) {
4412 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_2");
4416 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
4418 char device[] = "/dev/sda";
4421 r = guestfs_blockdev_setrw (g, device);
4428 r = guestfs_umount_all (g);
4435 r = guestfs_lvm_remove_all (g);
4440 char device[] = "/dev/sda";
4441 char lines_0[] = ",";
4448 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4453 char fstype[] = "ext2";
4454 char device[] = "/dev/sda1";
4457 r = guestfs_mkfs (g, fstype, device);
4462 char device[] = "/dev/sda1";
4463 char mountpoint[] = "/";
4466 r = guestfs_mount (g, device, mountpoint);
4470 /* TestRun for set_e2uuid (2) */
4472 char device[] = "/dev/sda1";
4473 char uuid[] = "random";
4476 r = guestfs_set_e2uuid (g, device, uuid);
4483 static int test_set_e2uuid_3_skip (void)
4487 str = getenv ("TEST_ONLY");
4489 return strstr (str, "set_e2uuid") == NULL;
4490 str = getenv ("SKIP_TEST_SET_E2UUID_3");
4491 if (str && strcmp (str, "1") == 0) return 1;
4492 str = getenv ("SKIP_TEST_SET_E2UUID");
4493 if (str && strcmp (str, "1") == 0) return 1;
4497 static int test_set_e2uuid_3 (void)
4499 if (test_set_e2uuid_3_skip ()) {
4500 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2uuid_3");
4504 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
4506 char device[] = "/dev/sda";
4509 r = guestfs_blockdev_setrw (g, device);
4516 r = guestfs_umount_all (g);
4523 r = guestfs_lvm_remove_all (g);
4528 char device[] = "/dev/sda";
4529 char lines_0[] = ",";
4536 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4541 char fstype[] = "ext2";
4542 char device[] = "/dev/sda1";
4545 r = guestfs_mkfs (g, fstype, device);
4550 char device[] = "/dev/sda1";
4551 char mountpoint[] = "/";
4554 r = guestfs_mount (g, device, mountpoint);
4558 /* TestRun for set_e2uuid (3) */
4560 char device[] = "/dev/sda1";
4561 char uuid[] = "time";
4564 r = guestfs_set_e2uuid (g, device, uuid);
4571 static int test_set_e2label_0_skip (void)
4575 str = getenv ("TEST_ONLY");
4577 return strstr (str, "set_e2label") == NULL;
4578 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
4579 if (str && strcmp (str, "1") == 0) return 1;
4580 str = getenv ("SKIP_TEST_SET_E2LABEL");
4581 if (str && strcmp (str, "1") == 0) return 1;
4585 static int test_set_e2label_0 (void)
4587 if (test_set_e2label_0_skip ()) {
4588 printf ("%s skipped (reason: environment variable set)\n", "test_set_e2label_0");
4592 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
4594 char device[] = "/dev/sda";
4597 r = guestfs_blockdev_setrw (g, device);
4604 r = guestfs_umount_all (g);
4611 r = guestfs_lvm_remove_all (g);
4616 char device[] = "/dev/sda";
4617 char lines_0[] = ",";
4624 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4629 char fstype[] = "ext2";
4630 char device[] = "/dev/sda1";
4633 r = guestfs_mkfs (g, fstype, device);
4638 char device[] = "/dev/sda1";
4639 char mountpoint[] = "/";
4642 r = guestfs_mount (g, device, mountpoint);
4646 /* TestOutput for set_e2label (0) */
4647 char expected[] = "testlabel";
4649 char device[] = "/dev/sda1";
4650 char label[] = "testlabel";
4653 r = guestfs_set_e2label (g, device, label);
4658 char device[] = "/dev/sda1";
4661 r = guestfs_get_e2label (g, device);
4664 if (strcmp (r, expected) != 0) {
4665 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
4673 static int test_pvremove_0_skip (void)
4677 str = getenv ("TEST_ONLY");
4679 return strstr (str, "pvremove") == NULL;
4680 str = getenv ("SKIP_TEST_PVREMOVE_0");
4681 if (str && strcmp (str, "1") == 0) return 1;
4682 str = getenv ("SKIP_TEST_PVREMOVE");
4683 if (str && strcmp (str, "1") == 0) return 1;
4687 static int test_pvremove_0 (void)
4689 if (test_pvremove_0_skip ()) {
4690 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_0");
4694 /* InitNone|InitEmpty for test_pvremove_0 */
4696 char device[] = "/dev/sda";
4699 r = guestfs_blockdev_setrw (g, device);
4706 r = guestfs_umount_all (g);
4713 r = guestfs_lvm_remove_all (g);
4717 /* TestOutputListOfDevices for pvremove (0) */
4719 char device[] = "/dev/sda";
4720 char lines_0[] = ",";
4727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4732 char device[] = "/dev/sda1";
4735 r = guestfs_pvcreate (g, device);
4740 char volgroup[] = "VG";
4741 char physvols_0[] = "/dev/sda1";
4742 char *physvols[] = {
4748 r = guestfs_vgcreate (g, volgroup, physvols);
4753 char logvol[] = "LV1";
4754 char volgroup[] = "VG";
4757 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4762 char logvol[] = "LV2";
4763 char volgroup[] = "VG";
4766 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4771 char vgname[] = "VG";
4774 r = guestfs_vgremove (g, vgname);
4779 char device[] = "/dev/sda1";
4782 r = guestfs_pvremove (g, device);
4790 r = guestfs_lvs (g);
4794 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4798 for (i = 0; r[i] != NULL; ++i)
4805 static int test_pvremove_1_skip (void)
4809 str = getenv ("TEST_ONLY");
4811 return strstr (str, "pvremove") == NULL;
4812 str = getenv ("SKIP_TEST_PVREMOVE_1");
4813 if (str && strcmp (str, "1") == 0) return 1;
4814 str = getenv ("SKIP_TEST_PVREMOVE");
4815 if (str && strcmp (str, "1") == 0) return 1;
4819 static int test_pvremove_1 (void)
4821 if (test_pvremove_1_skip ()) {
4822 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_1");
4826 /* InitNone|InitEmpty for test_pvremove_1 */
4828 char device[] = "/dev/sda";
4831 r = guestfs_blockdev_setrw (g, device);
4838 r = guestfs_umount_all (g);
4845 r = guestfs_lvm_remove_all (g);
4849 /* TestOutputListOfDevices for pvremove (1) */
4851 char device[] = "/dev/sda";
4852 char lines_0[] = ",";
4859 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4864 char device[] = "/dev/sda1";
4867 r = guestfs_pvcreate (g, device);
4872 char volgroup[] = "VG";
4873 char physvols_0[] = "/dev/sda1";
4874 char *physvols[] = {
4880 r = guestfs_vgcreate (g, volgroup, physvols);
4885 char logvol[] = "LV1";
4886 char volgroup[] = "VG";
4889 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4894 char logvol[] = "LV2";
4895 char volgroup[] = "VG";
4898 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4903 char vgname[] = "VG";
4906 r = guestfs_vgremove (g, vgname);
4911 char device[] = "/dev/sda1";
4914 r = guestfs_pvremove (g, device);
4922 r = guestfs_vgs (g);
4926 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4930 for (i = 0; r[i] != NULL; ++i)
4937 static int test_pvremove_2_skip (void)
4941 str = getenv ("TEST_ONLY");
4943 return strstr (str, "pvremove") == NULL;
4944 str = getenv ("SKIP_TEST_PVREMOVE_2");
4945 if (str && strcmp (str, "1") == 0) return 1;
4946 str = getenv ("SKIP_TEST_PVREMOVE");
4947 if (str && strcmp (str, "1") == 0) return 1;
4951 static int test_pvremove_2 (void)
4953 if (test_pvremove_2_skip ()) {
4954 printf ("%s skipped (reason: environment variable set)\n", "test_pvremove_2");
4958 /* InitNone|InitEmpty for test_pvremove_2 */
4960 char device[] = "/dev/sda";
4963 r = guestfs_blockdev_setrw (g, device);
4970 r = guestfs_umount_all (g);
4977 r = guestfs_lvm_remove_all (g);
4981 /* TestOutputListOfDevices for pvremove (2) */
4983 char device[] = "/dev/sda";
4984 char lines_0[] = ",";
4991 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4996 char device[] = "/dev/sda1";
4999 r = guestfs_pvcreate (g, device);
5004 char volgroup[] = "VG";
5005 char physvols_0[] = "/dev/sda1";
5006 char *physvols[] = {
5012 r = guestfs_vgcreate (g, volgroup, physvols);
5017 char logvol[] = "LV1";
5018 char volgroup[] = "VG";
5021 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5026 char logvol[] = "LV2";
5027 char volgroup[] = "VG";
5030 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5035 char vgname[] = "VG";
5038 r = guestfs_vgremove (g, vgname);
5043 char device[] = "/dev/sda1";
5046 r = guestfs_pvremove (g, device);
5054 r = guestfs_pvs (g);
5058 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
5062 for (i = 0; r[i] != NULL; ++i)
5069 static int test_vgremove_0_skip (void)
5073 str = getenv ("TEST_ONLY");
5075 return strstr (str, "vgremove") == NULL;
5076 str = getenv ("SKIP_TEST_VGREMOVE_0");
5077 if (str && strcmp (str, "1") == 0) return 1;
5078 str = getenv ("SKIP_TEST_VGREMOVE");
5079 if (str && strcmp (str, "1") == 0) return 1;
5083 static int test_vgremove_0 (void)
5085 if (test_vgremove_0_skip ()) {
5086 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_0");
5090 /* InitNone|InitEmpty for test_vgremove_0 */
5092 char device[] = "/dev/sda";
5095 r = guestfs_blockdev_setrw (g, device);
5102 r = guestfs_umount_all (g);
5109 r = guestfs_lvm_remove_all (g);
5113 /* TestOutputList for vgremove (0) */
5115 char device[] = "/dev/sda";
5116 char lines_0[] = ",";
5123 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5128 char device[] = "/dev/sda1";
5131 r = guestfs_pvcreate (g, device);
5136 char volgroup[] = "VG";
5137 char physvols_0[] = "/dev/sda1";
5138 char *physvols[] = {
5144 r = guestfs_vgcreate (g, volgroup, physvols);
5149 char logvol[] = "LV1";
5150 char volgroup[] = "VG";
5153 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5158 char logvol[] = "LV2";
5159 char volgroup[] = "VG";
5162 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5167 char vgname[] = "VG";
5170 r = guestfs_vgremove (g, vgname);
5178 r = guestfs_lvs (g);
5182 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
5186 for (i = 0; r[i] != NULL; ++i)
5193 static int test_vgremove_1_skip (void)
5197 str = getenv ("TEST_ONLY");
5199 return strstr (str, "vgremove") == NULL;
5200 str = getenv ("SKIP_TEST_VGREMOVE_1");
5201 if (str && strcmp (str, "1") == 0) return 1;
5202 str = getenv ("SKIP_TEST_VGREMOVE");
5203 if (str && strcmp (str, "1") == 0) return 1;
5207 static int test_vgremove_1 (void)
5209 if (test_vgremove_1_skip ()) {
5210 printf ("%s skipped (reason: environment variable set)\n", "test_vgremove_1");
5214 /* InitNone|InitEmpty for test_vgremove_1 */
5216 char device[] = "/dev/sda";
5219 r = guestfs_blockdev_setrw (g, device);
5226 r = guestfs_umount_all (g);
5233 r = guestfs_lvm_remove_all (g);
5237 /* TestOutputList for vgremove (1) */
5239 char device[] = "/dev/sda";
5240 char lines_0[] = ",";
5247 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5252 char device[] = "/dev/sda1";
5255 r = guestfs_pvcreate (g, device);
5260 char volgroup[] = "VG";
5261 char physvols_0[] = "/dev/sda1";
5262 char *physvols[] = {
5268 r = guestfs_vgcreate (g, volgroup, physvols);
5273 char logvol[] = "LV1";
5274 char volgroup[] = "VG";
5277 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5282 char logvol[] = "LV2";
5283 char volgroup[] = "VG";
5286 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5291 char vgname[] = "VG";
5294 r = guestfs_vgremove (g, vgname);
5302 r = guestfs_vgs (g);
5306 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
5310 for (i = 0; r[i] != NULL; ++i)
5317 static int test_lvremove_0_skip (void)
5321 str = getenv ("TEST_ONLY");
5323 return strstr (str, "lvremove") == NULL;
5324 str = getenv ("SKIP_TEST_LVREMOVE_0");
5325 if (str && strcmp (str, "1") == 0) return 1;
5326 str = getenv ("SKIP_TEST_LVREMOVE");
5327 if (str && strcmp (str, "1") == 0) return 1;
5331 static int test_lvremove_0 (void)
5333 if (test_lvremove_0_skip ()) {
5334 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_0");
5338 /* InitNone|InitEmpty for test_lvremove_0 */
5340 char device[] = "/dev/sda";
5343 r = guestfs_blockdev_setrw (g, device);
5350 r = guestfs_umount_all (g);
5357 r = guestfs_lvm_remove_all (g);
5361 /* TestOutputList for lvremove (0) */
5363 char device[] = "/dev/sda";
5364 char lines_0[] = ",";
5371 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5376 char device[] = "/dev/sda1";
5379 r = guestfs_pvcreate (g, device);
5384 char volgroup[] = "VG";
5385 char physvols_0[] = "/dev/sda1";
5386 char *physvols[] = {
5392 r = guestfs_vgcreate (g, volgroup, physvols);
5397 char logvol[] = "LV1";
5398 char volgroup[] = "VG";
5401 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5406 char logvol[] = "LV2";
5407 char volgroup[] = "VG";
5410 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5415 char device[] = "/dev/VG/LV1";
5418 r = guestfs_lvremove (g, device);
5426 r = guestfs_lvs (g);
5430 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
5435 char expected[] = "/dev/VG/LV2";
5436 if (strcmp (r[0], expected) != 0) {
5437 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5442 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
5446 for (i = 0; r[i] != NULL; ++i)
5453 static int test_lvremove_1_skip (void)
5457 str = getenv ("TEST_ONLY");
5459 return strstr (str, "lvremove") == NULL;
5460 str = getenv ("SKIP_TEST_LVREMOVE_1");
5461 if (str && strcmp (str, "1") == 0) return 1;
5462 str = getenv ("SKIP_TEST_LVREMOVE");
5463 if (str && strcmp (str, "1") == 0) return 1;
5467 static int test_lvremove_1 (void)
5469 if (test_lvremove_1_skip ()) {
5470 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_1");
5474 /* InitNone|InitEmpty for test_lvremove_1 */
5476 char device[] = "/dev/sda";
5479 r = guestfs_blockdev_setrw (g, device);
5486 r = guestfs_umount_all (g);
5493 r = guestfs_lvm_remove_all (g);
5497 /* TestOutputList for lvremove (1) */
5499 char device[] = "/dev/sda";
5500 char lines_0[] = ",";
5507 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5512 char device[] = "/dev/sda1";
5515 r = guestfs_pvcreate (g, device);
5520 char volgroup[] = "VG";
5521 char physvols_0[] = "/dev/sda1";
5522 char *physvols[] = {
5528 r = guestfs_vgcreate (g, volgroup, physvols);
5533 char logvol[] = "LV1";
5534 char volgroup[] = "VG";
5537 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5542 char logvol[] = "LV2";
5543 char volgroup[] = "VG";
5546 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5551 char device[] = "/dev/VG";
5554 r = guestfs_lvremove (g, device);
5562 r = guestfs_lvs (g);
5566 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
5570 for (i = 0; r[i] != NULL; ++i)
5577 static int test_lvremove_2_skip (void)
5581 str = getenv ("TEST_ONLY");
5583 return strstr (str, "lvremove") == NULL;
5584 str = getenv ("SKIP_TEST_LVREMOVE_2");
5585 if (str && strcmp (str, "1") == 0) return 1;
5586 str = getenv ("SKIP_TEST_LVREMOVE");
5587 if (str && strcmp (str, "1") == 0) return 1;
5591 static int test_lvremove_2 (void)
5593 if (test_lvremove_2_skip ()) {
5594 printf ("%s skipped (reason: environment variable set)\n", "test_lvremove_2");
5598 /* InitNone|InitEmpty for test_lvremove_2 */
5600 char device[] = "/dev/sda";
5603 r = guestfs_blockdev_setrw (g, device);
5610 r = guestfs_umount_all (g);
5617 r = guestfs_lvm_remove_all (g);
5621 /* TestOutputList for lvremove (2) */
5623 char device[] = "/dev/sda";
5624 char lines_0[] = ",";
5631 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5636 char device[] = "/dev/sda1";
5639 r = guestfs_pvcreate (g, device);
5644 char volgroup[] = "VG";
5645 char physvols_0[] = "/dev/sda1";
5646 char *physvols[] = {
5652 r = guestfs_vgcreate (g, volgroup, physvols);
5657 char logvol[] = "LV1";
5658 char volgroup[] = "VG";
5661 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5666 char logvol[] = "LV2";
5667 char volgroup[] = "VG";
5670 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5675 char device[] = "/dev/VG";
5678 r = guestfs_lvremove (g, device);
5686 r = guestfs_vgs (g);
5690 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5695 char expected[] = "VG";
5696 if (strcmp (r[0], expected) != 0) {
5697 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5702 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5706 for (i = 0; r[i] != NULL; ++i)
5713 static int test_mount_ro_0_skip (void)
5717 str = getenv ("TEST_ONLY");
5719 return strstr (str, "mount_ro") == NULL;
5720 str = getenv ("SKIP_TEST_MOUNT_RO_0");
5721 if (str && strcmp (str, "1") == 0) return 1;
5722 str = getenv ("SKIP_TEST_MOUNT_RO");
5723 if (str && strcmp (str, "1") == 0) return 1;
5727 static int test_mount_ro_0 (void)
5729 if (test_mount_ro_0_skip ()) {
5730 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_0");
5734 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5736 char device[] = "/dev/sda";
5739 r = guestfs_blockdev_setrw (g, device);
5746 r = guestfs_umount_all (g);
5753 r = guestfs_lvm_remove_all (g);
5758 char device[] = "/dev/sda";
5759 char lines_0[] = ",";
5766 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5771 char fstype[] = "ext2";
5772 char device[] = "/dev/sda1";
5775 r = guestfs_mkfs (g, fstype, device);
5780 char device[] = "/dev/sda1";
5781 char mountpoint[] = "/";
5784 r = guestfs_mount (g, device, mountpoint);
5788 /* TestLastFail for mount_ro (0) */
5790 char pathordevice[] = "/";
5793 r = guestfs_umount (g, pathordevice);
5798 char device[] = "/dev/sda1";
5799 char mountpoint[] = "/";
5802 r = guestfs_mount_ro (g, device, mountpoint);
5807 char path[] = "/new";
5810 r = guestfs_touch (g, path);
5817 static int test_mount_ro_1_skip (void)
5821 str = getenv ("TEST_ONLY");
5823 return strstr (str, "mount_ro") == NULL;
5824 str = getenv ("SKIP_TEST_MOUNT_RO_1");
5825 if (str && strcmp (str, "1") == 0) return 1;
5826 str = getenv ("SKIP_TEST_MOUNT_RO");
5827 if (str && strcmp (str, "1") == 0) return 1;
5831 static int test_mount_ro_1 (void)
5833 if (test_mount_ro_1_skip ()) {
5834 printf ("%s skipped (reason: environment variable set)\n", "test_mount_ro_1");
5838 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5840 char device[] = "/dev/sda";
5843 r = guestfs_blockdev_setrw (g, device);
5850 r = guestfs_umount_all (g);
5857 r = guestfs_lvm_remove_all (g);
5862 char device[] = "/dev/sda";
5863 char lines_0[] = ",";
5870 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5875 char fstype[] = "ext2";
5876 char device[] = "/dev/sda1";
5879 r = guestfs_mkfs (g, fstype, device);
5884 char device[] = "/dev/sda1";
5885 char mountpoint[] = "/";
5888 r = guestfs_mount (g, device, mountpoint);
5892 /* TestOutput for mount_ro (1) */
5893 char expected[] = "data";
5895 char path[] = "/new";
5896 char content[] = "data";
5899 r = guestfs_write_file (g, path, content, 0);
5904 char pathordevice[] = "/";
5907 r = guestfs_umount (g, pathordevice);
5912 char device[] = "/dev/sda1";
5913 char mountpoint[] = "/";
5916 r = guestfs_mount_ro (g, device, mountpoint);
5921 char path[] = "/new";
5924 r = guestfs_cat (g, path);
5927 if (strcmp (r, expected) != 0) {
5928 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5936 static int test_tgz_in_0_skip (void)
5940 str = getenv ("TEST_ONLY");
5942 return strstr (str, "tgz_in") == NULL;
5943 str = getenv ("SKIP_TEST_TGZ_IN_0");
5944 if (str && strcmp (str, "1") == 0) return 1;
5945 str = getenv ("SKIP_TEST_TGZ_IN");
5946 if (str && strcmp (str, "1") == 0) return 1;
5950 static int test_tgz_in_0 (void)
5952 if (test_tgz_in_0_skip ()) {
5953 printf ("%s skipped (reason: environment variable set)\n", "test_tgz_in_0");
5957 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5959 char device[] = "/dev/sda";
5962 r = guestfs_blockdev_setrw (g, device);
5969 r = guestfs_umount_all (g);
5976 r = guestfs_lvm_remove_all (g);
5981 char device[] = "/dev/sda";
5982 char lines_0[] = ",";
5989 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5994 char fstype[] = "ext2";
5995 char device[] = "/dev/sda1";
5998 r = guestfs_mkfs (g, fstype, device);
6003 char device[] = "/dev/sda1";
6004 char mountpoint[] = "/";
6007 r = guestfs_mount (g, device, mountpoint);
6011 /* TestOutput for tgz_in (0) */
6012 char expected[] = "hello\n";
6014 char directory[] = "/";
6017 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
6022 char path[] = "/hello";
6025 r = guestfs_cat (g, path);
6028 if (strcmp (r, expected) != 0) {
6029 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
6037 static int test_tar_in_0_skip (void)
6041 str = getenv ("TEST_ONLY");
6043 return strstr (str, "tar_in") == NULL;
6044 str = getenv ("SKIP_TEST_TAR_IN_0");
6045 if (str && strcmp (str, "1") == 0) return 1;
6046 str = getenv ("SKIP_TEST_TAR_IN");
6047 if (str && strcmp (str, "1") == 0) return 1;
6051 static int test_tar_in_0 (void)
6053 if (test_tar_in_0_skip ()) {
6054 printf ("%s skipped (reason: environment variable set)\n", "test_tar_in_0");
6058 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
6060 char device[] = "/dev/sda";
6063 r = guestfs_blockdev_setrw (g, device);
6070 r = guestfs_umount_all (g);
6077 r = guestfs_lvm_remove_all (g);
6082 char device[] = "/dev/sda";
6083 char lines_0[] = ",";
6090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6095 char fstype[] = "ext2";
6096 char device[] = "/dev/sda1";
6099 r = guestfs_mkfs (g, fstype, device);
6104 char device[] = "/dev/sda1";
6105 char mountpoint[] = "/";
6108 r = guestfs_mount (g, device, mountpoint);
6112 /* TestOutput for tar_in (0) */
6113 char expected[] = "hello\n";
6115 char directory[] = "/";
6118 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
6123 char path[] = "/hello";
6126 r = guestfs_cat (g, path);
6129 if (strcmp (r, expected) != 0) {
6130 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
6138 static int test_checksum_0_skip (void)
6142 str = getenv ("TEST_ONLY");
6144 return strstr (str, "checksum") == NULL;
6145 str = getenv ("SKIP_TEST_CHECKSUM_0");
6146 if (str && strcmp (str, "1") == 0) return 1;
6147 str = getenv ("SKIP_TEST_CHECKSUM");
6148 if (str && strcmp (str, "1") == 0) return 1;
6152 static int test_checksum_0 (void)
6154 if (test_checksum_0_skip ()) {
6155 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_0");
6159 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
6161 char device[] = "/dev/sda";
6164 r = guestfs_blockdev_setrw (g, device);
6171 r = guestfs_umount_all (g);
6178 r = guestfs_lvm_remove_all (g);
6183 char device[] = "/dev/sda";
6184 char lines_0[] = ",";
6191 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6196 char fstype[] = "ext2";
6197 char device[] = "/dev/sda1";
6200 r = guestfs_mkfs (g, fstype, device);
6205 char device[] = "/dev/sda1";
6206 char mountpoint[] = "/";
6209 r = guestfs_mount (g, device, mountpoint);
6213 /* TestOutput for checksum (0) */
6214 char expected[] = "935282863";
6216 char path[] = "/new";
6217 char content[] = "test\n";
6220 r = guestfs_write_file (g, path, content, 0);
6225 char csumtype[] = "crc";
6226 char path[] = "/new";
6229 r = guestfs_checksum (g, csumtype, path);
6232 if (strcmp (r, expected) != 0) {
6233 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
6241 static int test_checksum_1_skip (void)
6245 str = getenv ("TEST_ONLY");
6247 return strstr (str, "checksum") == NULL;
6248 str = getenv ("SKIP_TEST_CHECKSUM_1");
6249 if (str && strcmp (str, "1") == 0) return 1;
6250 str = getenv ("SKIP_TEST_CHECKSUM");
6251 if (str && strcmp (str, "1") == 0) return 1;
6255 static int test_checksum_1 (void)
6257 if (test_checksum_1_skip ()) {
6258 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_1");
6262 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
6264 char device[] = "/dev/sda";
6267 r = guestfs_blockdev_setrw (g, device);
6274 r = guestfs_umount_all (g);
6281 r = guestfs_lvm_remove_all (g);
6286 char device[] = "/dev/sda";
6287 char lines_0[] = ",";
6294 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6299 char fstype[] = "ext2";
6300 char device[] = "/dev/sda1";
6303 r = guestfs_mkfs (g, fstype, device);
6308 char device[] = "/dev/sda1";
6309 char mountpoint[] = "/";
6312 r = guestfs_mount (g, device, mountpoint);
6316 /* TestLastFail for checksum (1) */
6318 char csumtype[] = "crc";
6319 char path[] = "/new";
6322 r = guestfs_checksum (g, csumtype, path);
6330 static int test_checksum_2_skip (void)
6334 str = getenv ("TEST_ONLY");
6336 return strstr (str, "checksum") == NULL;
6337 str = getenv ("SKIP_TEST_CHECKSUM_2");
6338 if (str && strcmp (str, "1") == 0) return 1;
6339 str = getenv ("SKIP_TEST_CHECKSUM");
6340 if (str && strcmp (str, "1") == 0) return 1;
6344 static int test_checksum_2 (void)
6346 if (test_checksum_2_skip ()) {
6347 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_2");
6351 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
6353 char device[] = "/dev/sda";
6356 r = guestfs_blockdev_setrw (g, device);
6363 r = guestfs_umount_all (g);
6370 r = guestfs_lvm_remove_all (g);
6375 char device[] = "/dev/sda";
6376 char lines_0[] = ",";
6383 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6388 char fstype[] = "ext2";
6389 char device[] = "/dev/sda1";
6392 r = guestfs_mkfs (g, fstype, device);
6397 char device[] = "/dev/sda1";
6398 char mountpoint[] = "/";
6401 r = guestfs_mount (g, device, mountpoint);
6405 /* TestOutput for checksum (2) */
6406 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
6408 char path[] = "/new";
6409 char content[] = "test\n";
6412 r = guestfs_write_file (g, path, content, 0);
6417 char csumtype[] = "md5";
6418 char path[] = "/new";
6421 r = guestfs_checksum (g, csumtype, path);
6424 if (strcmp (r, expected) != 0) {
6425 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
6433 static int test_checksum_3_skip (void)
6437 str = getenv ("TEST_ONLY");
6439 return strstr (str, "checksum") == NULL;
6440 str = getenv ("SKIP_TEST_CHECKSUM_3");
6441 if (str && strcmp (str, "1") == 0) return 1;
6442 str = getenv ("SKIP_TEST_CHECKSUM");
6443 if (str && strcmp (str, "1") == 0) return 1;
6447 static int test_checksum_3 (void)
6449 if (test_checksum_3_skip ()) {
6450 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_3");
6454 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
6456 char device[] = "/dev/sda";
6459 r = guestfs_blockdev_setrw (g, device);
6466 r = guestfs_umount_all (g);
6473 r = guestfs_lvm_remove_all (g);
6478 char device[] = "/dev/sda";
6479 char lines_0[] = ",";
6486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6491 char fstype[] = "ext2";
6492 char device[] = "/dev/sda1";
6495 r = guestfs_mkfs (g, fstype, device);
6500 char device[] = "/dev/sda1";
6501 char mountpoint[] = "/";
6504 r = guestfs_mount (g, device, mountpoint);
6508 /* TestOutput for checksum (3) */
6509 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
6511 char path[] = "/new";
6512 char content[] = "test\n";
6515 r = guestfs_write_file (g, path, content, 0);
6520 char csumtype[] = "sha1";
6521 char path[] = "/new";
6524 r = guestfs_checksum (g, csumtype, path);
6527 if (strcmp (r, expected) != 0) {
6528 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
6536 static int test_checksum_4_skip (void)
6540 str = getenv ("TEST_ONLY");
6542 return strstr (str, "checksum") == NULL;
6543 str = getenv ("SKIP_TEST_CHECKSUM_4");
6544 if (str && strcmp (str, "1") == 0) return 1;
6545 str = getenv ("SKIP_TEST_CHECKSUM");
6546 if (str && strcmp (str, "1") == 0) return 1;
6550 static int test_checksum_4 (void)
6552 if (test_checksum_4_skip ()) {
6553 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_4");
6557 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
6559 char device[] = "/dev/sda";
6562 r = guestfs_blockdev_setrw (g, device);
6569 r = guestfs_umount_all (g);
6576 r = guestfs_lvm_remove_all (g);
6581 char device[] = "/dev/sda";
6582 char lines_0[] = ",";
6589 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6594 char fstype[] = "ext2";
6595 char device[] = "/dev/sda1";
6598 r = guestfs_mkfs (g, fstype, device);
6603 char device[] = "/dev/sda1";
6604 char mountpoint[] = "/";
6607 r = guestfs_mount (g, device, mountpoint);
6611 /* TestOutput for checksum (4) */
6612 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
6614 char path[] = "/new";
6615 char content[] = "test\n";
6618 r = guestfs_write_file (g, path, content, 0);
6623 char csumtype[] = "sha224";
6624 char path[] = "/new";
6627 r = guestfs_checksum (g, csumtype, path);
6630 if (strcmp (r, expected) != 0) {
6631 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
6639 static int test_checksum_5_skip (void)
6643 str = getenv ("TEST_ONLY");
6645 return strstr (str, "checksum") == NULL;
6646 str = getenv ("SKIP_TEST_CHECKSUM_5");
6647 if (str && strcmp (str, "1") == 0) return 1;
6648 str = getenv ("SKIP_TEST_CHECKSUM");
6649 if (str && strcmp (str, "1") == 0) return 1;
6653 static int test_checksum_5 (void)
6655 if (test_checksum_5_skip ()) {
6656 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_5");
6660 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
6662 char device[] = "/dev/sda";
6665 r = guestfs_blockdev_setrw (g, device);
6672 r = guestfs_umount_all (g);
6679 r = guestfs_lvm_remove_all (g);
6684 char device[] = "/dev/sda";
6685 char lines_0[] = ",";
6692 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6697 char fstype[] = "ext2";
6698 char device[] = "/dev/sda1";
6701 r = guestfs_mkfs (g, fstype, device);
6706 char device[] = "/dev/sda1";
6707 char mountpoint[] = "/";
6710 r = guestfs_mount (g, device, mountpoint);
6714 /* TestOutput for checksum (5) */
6715 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6717 char path[] = "/new";
6718 char content[] = "test\n";
6721 r = guestfs_write_file (g, path, content, 0);
6726 char csumtype[] = "sha256";
6727 char path[] = "/new";
6730 r = guestfs_checksum (g, csumtype, path);
6733 if (strcmp (r, expected) != 0) {
6734 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6742 static int test_checksum_6_skip (void)
6746 str = getenv ("TEST_ONLY");
6748 return strstr (str, "checksum") == NULL;
6749 str = getenv ("SKIP_TEST_CHECKSUM_6");
6750 if (str && strcmp (str, "1") == 0) return 1;
6751 str = getenv ("SKIP_TEST_CHECKSUM");
6752 if (str && strcmp (str, "1") == 0) return 1;
6756 static int test_checksum_6 (void)
6758 if (test_checksum_6_skip ()) {
6759 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_6");
6763 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6765 char device[] = "/dev/sda";
6768 r = guestfs_blockdev_setrw (g, device);
6775 r = guestfs_umount_all (g);
6782 r = guestfs_lvm_remove_all (g);
6787 char device[] = "/dev/sda";
6788 char lines_0[] = ",";
6795 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6800 char fstype[] = "ext2";
6801 char device[] = "/dev/sda1";
6804 r = guestfs_mkfs (g, fstype, device);
6809 char device[] = "/dev/sda1";
6810 char mountpoint[] = "/";
6813 r = guestfs_mount (g, device, mountpoint);
6817 /* TestOutput for checksum (6) */
6818 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6820 char path[] = "/new";
6821 char content[] = "test\n";
6824 r = guestfs_write_file (g, path, content, 0);
6829 char csumtype[] = "sha384";
6830 char path[] = "/new";
6833 r = guestfs_checksum (g, csumtype, path);
6836 if (strcmp (r, expected) != 0) {
6837 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6845 static int test_checksum_7_skip (void)
6849 str = getenv ("TEST_ONLY");
6851 return strstr (str, "checksum") == NULL;
6852 str = getenv ("SKIP_TEST_CHECKSUM_7");
6853 if (str && strcmp (str, "1") == 0) return 1;
6854 str = getenv ("SKIP_TEST_CHECKSUM");
6855 if (str && strcmp (str, "1") == 0) return 1;
6859 static int test_checksum_7 (void)
6861 if (test_checksum_7_skip ()) {
6862 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_7");
6866 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6868 char device[] = "/dev/sda";
6871 r = guestfs_blockdev_setrw (g, device);
6878 r = guestfs_umount_all (g);
6885 r = guestfs_lvm_remove_all (g);
6890 char device[] = "/dev/sda";
6891 char lines_0[] = ",";
6898 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6903 char fstype[] = "ext2";
6904 char device[] = "/dev/sda1";
6907 r = guestfs_mkfs (g, fstype, device);
6912 char device[] = "/dev/sda1";
6913 char mountpoint[] = "/";
6916 r = guestfs_mount (g, device, mountpoint);
6920 /* TestOutput for checksum (7) */
6921 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6923 char path[] = "/new";
6924 char content[] = "test\n";
6927 r = guestfs_write_file (g, path, content, 0);
6932 char csumtype[] = "sha512";
6933 char path[] = "/new";
6936 r = guestfs_checksum (g, csumtype, path);
6939 if (strcmp (r, expected) != 0) {
6940 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6948 static int test_checksum_8_skip (void)
6952 str = getenv ("TEST_ONLY");
6954 return strstr (str, "checksum") == NULL;
6955 str = getenv ("SKIP_TEST_CHECKSUM_8");
6956 if (str && strcmp (str, "1") == 0) return 1;
6957 str = getenv ("SKIP_TEST_CHECKSUM");
6958 if (str && strcmp (str, "1") == 0) return 1;
6962 static int test_checksum_8 (void)
6964 if (test_checksum_8_skip ()) {
6965 printf ("%s skipped (reason: environment variable set)\n", "test_checksum_8");
6969 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6971 char device[] = "/dev/sda";
6974 r = guestfs_blockdev_setrw (g, device);
6981 r = guestfs_umount_all (g);
6988 r = guestfs_lvm_remove_all (g);
6993 char device[] = "/dev/sda";
6994 char lines_0[] = ",";
7001 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7006 char fstype[] = "ext2";
7007 char device[] = "/dev/sda1";
7010 r = guestfs_mkfs (g, fstype, device);
7015 char device[] = "/dev/sda1";
7016 char mountpoint[] = "/";
7019 r = guestfs_mount (g, device, mountpoint);
7023 /* TestOutput for checksum (8) */
7024 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
7026 char options[] = "ro";
7027 char vfstype[] = "squashfs";
7028 char device[] = "/dev/sdd";
7029 char mountpoint[] = "/";
7032 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
7037 char csumtype[] = "md5";
7038 char path[] = "/known-3";
7041 r = guestfs_checksum (g, csumtype, path);
7044 if (strcmp (r, expected) != 0) {
7045 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
7053 static int test_download_0_skip (void)
7057 str = getenv ("TEST_ONLY");
7059 return strstr (str, "download") == NULL;
7060 str = getenv ("SKIP_TEST_DOWNLOAD_0");
7061 if (str && strcmp (str, "1") == 0) return 1;
7062 str = getenv ("SKIP_TEST_DOWNLOAD");
7063 if (str && strcmp (str, "1") == 0) return 1;
7067 static int test_download_0 (void)
7069 if (test_download_0_skip ()) {
7070 printf ("%s skipped (reason: environment variable set)\n", "test_download_0");
7074 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
7076 char device[] = "/dev/sda";
7079 r = guestfs_blockdev_setrw (g, device);
7086 r = guestfs_umount_all (g);
7093 r = guestfs_lvm_remove_all (g);
7098 char device[] = "/dev/sda";
7099 char lines_0[] = ",";
7106 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7111 char fstype[] = "ext2";
7112 char device[] = "/dev/sda1";
7115 r = guestfs_mkfs (g, fstype, device);
7120 char device[] = "/dev/sda1";
7121 char mountpoint[] = "/";
7124 r = guestfs_mount (g, device, mountpoint);
7128 /* TestOutput for download (0) */
7129 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
7131 char remotefilename[] = "/COPYING.LIB";
7134 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
7139 char remotefilename[] = "/COPYING.LIB";
7142 r = guestfs_download (g, remotefilename, "testdownload.tmp");
7147 char remotefilename[] = "/upload";
7150 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
7155 char csumtype[] = "md5";
7156 char path[] = "/upload";
7159 r = guestfs_checksum (g, csumtype, path);
7162 if (strcmp (r, expected) != 0) {
7163 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
7171 static int test_upload_0_skip (void)
7175 str = getenv ("TEST_ONLY");
7177 return strstr (str, "upload") == NULL;
7178 str = getenv ("SKIP_TEST_UPLOAD_0");
7179 if (str && strcmp (str, "1") == 0) return 1;
7180 str = getenv ("SKIP_TEST_UPLOAD");
7181 if (str && strcmp (str, "1") == 0) return 1;
7185 static int test_upload_0 (void)
7187 if (test_upload_0_skip ()) {
7188 printf ("%s skipped (reason: environment variable set)\n", "test_upload_0");
7192 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
7194 char device[] = "/dev/sda";
7197 r = guestfs_blockdev_setrw (g, device);
7204 r = guestfs_umount_all (g);
7211 r = guestfs_lvm_remove_all (g);
7216 char device[] = "/dev/sda";
7217 char lines_0[] = ",";
7224 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7229 char fstype[] = "ext2";
7230 char device[] = "/dev/sda1";
7233 r = guestfs_mkfs (g, fstype, device);
7238 char device[] = "/dev/sda1";
7239 char mountpoint[] = "/";
7242 r = guestfs_mount (g, device, mountpoint);
7246 /* TestOutput for upload (0) */
7247 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
7249 char remotefilename[] = "/COPYING.LIB";
7252 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
7257 char csumtype[] = "md5";
7258 char path[] = "/COPYING.LIB";
7261 r = guestfs_checksum (g, csumtype, path);
7264 if (strcmp (r, expected) != 0) {
7265 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
7273 static int test_blockdev_rereadpt_0_skip (void)
7277 str = getenv ("TEST_ONLY");
7279 return strstr (str, "blockdev_rereadpt") == NULL;
7280 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
7281 if (str && strcmp (str, "1") == 0) return 1;
7282 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
7283 if (str && strcmp (str, "1") == 0) return 1;
7287 static int test_blockdev_rereadpt_0 (void)
7289 if (test_blockdev_rereadpt_0_skip ()) {
7290 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_rereadpt_0");
7294 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
7296 char device[] = "/dev/sda";
7299 r = guestfs_blockdev_setrw (g, device);
7306 r = guestfs_umount_all (g);
7313 r = guestfs_lvm_remove_all (g);
7317 /* TestRun for blockdev_rereadpt (0) */
7319 char device[] = "/dev/sda";
7322 r = guestfs_blockdev_rereadpt (g, device);
7329 static int test_blockdev_flushbufs_0_skip (void)
7333 str = getenv ("TEST_ONLY");
7335 return strstr (str, "blockdev_flushbufs") == NULL;
7336 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
7337 if (str && strcmp (str, "1") == 0) return 1;
7338 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
7339 if (str && strcmp (str, "1") == 0) return 1;
7343 static int test_blockdev_flushbufs_0 (void)
7345 if (test_blockdev_flushbufs_0_skip ()) {
7346 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_flushbufs_0");
7350 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
7352 char device[] = "/dev/sda";
7355 r = guestfs_blockdev_setrw (g, device);
7362 r = guestfs_umount_all (g);
7369 r = guestfs_lvm_remove_all (g);
7373 /* TestRun for blockdev_flushbufs (0) */
7375 char device[] = "/dev/sda";
7378 r = guestfs_blockdev_flushbufs (g, device);
7385 static int test_blockdev_getsize64_0_skip (void)
7389 str = getenv ("TEST_ONLY");
7391 return strstr (str, "blockdev_getsize64") == NULL;
7392 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
7393 if (str && strcmp (str, "1") == 0) return 1;
7394 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
7395 if (str && strcmp (str, "1") == 0) return 1;
7399 static int test_blockdev_getsize64_0 (void)
7401 if (test_blockdev_getsize64_0_skip ()) {
7402 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsize64_0");
7406 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
7408 char device[] = "/dev/sda";
7411 r = guestfs_blockdev_setrw (g, device);
7418 r = guestfs_umount_all (g);
7425 r = guestfs_lvm_remove_all (g);
7429 /* TestOutputInt for blockdev_getsize64 (0) */
7431 char device[] = "/dev/sda";
7434 r = guestfs_blockdev_getsize64 (g, device);
7437 if (r != 524288000) {
7438 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
7445 static int test_blockdev_getsz_0_skip (void)
7449 str = getenv ("TEST_ONLY");
7451 return strstr (str, "blockdev_getsz") == NULL;
7452 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
7453 if (str && strcmp (str, "1") == 0) return 1;
7454 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
7455 if (str && strcmp (str, "1") == 0) return 1;
7459 static int test_blockdev_getsz_0 (void)
7461 if (test_blockdev_getsz_0_skip ()) {
7462 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getsz_0");
7466 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
7468 char device[] = "/dev/sda";
7471 r = guestfs_blockdev_setrw (g, device);
7478 r = guestfs_umount_all (g);
7485 r = guestfs_lvm_remove_all (g);
7489 /* TestOutputInt for blockdev_getsz (0) */
7491 char device[] = "/dev/sda";
7494 r = guestfs_blockdev_getsz (g, device);
7498 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
7505 static int test_blockdev_getbsz_0_skip (void)
7509 str = getenv ("TEST_ONLY");
7511 return strstr (str, "blockdev_getbsz") == NULL;
7512 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
7513 if (str && strcmp (str, "1") == 0) return 1;
7514 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
7515 if (str && strcmp (str, "1") == 0) return 1;
7519 static int test_blockdev_getbsz_0 (void)
7521 if (test_blockdev_getbsz_0_skip ()) {
7522 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getbsz_0");
7526 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
7528 char device[] = "/dev/sda";
7531 r = guestfs_blockdev_setrw (g, device);
7538 r = guestfs_umount_all (g);
7545 r = guestfs_lvm_remove_all (g);
7549 /* TestOutputInt for blockdev_getbsz (0) */
7551 char device[] = "/dev/sda";
7554 r = guestfs_blockdev_getbsz (g, device);
7558 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
7565 static int test_blockdev_getss_0_skip (void)
7569 str = getenv ("TEST_ONLY");
7571 return strstr (str, "blockdev_getss") == NULL;
7572 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
7573 if (str && strcmp (str, "1") == 0) return 1;
7574 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
7575 if (str && strcmp (str, "1") == 0) return 1;
7579 static int test_blockdev_getss_0 (void)
7581 if (test_blockdev_getss_0_skip ()) {
7582 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getss_0");
7586 /* InitNone|InitEmpty for test_blockdev_getss_0 */
7588 char device[] = "/dev/sda";
7591 r = guestfs_blockdev_setrw (g, device);
7598 r = guestfs_umount_all (g);
7605 r = guestfs_lvm_remove_all (g);
7609 /* TestOutputInt for blockdev_getss (0) */
7611 char device[] = "/dev/sda";
7614 r = guestfs_blockdev_getss (g, device);
7618 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
7625 static int test_blockdev_getro_0_skip (void)
7629 str = getenv ("TEST_ONLY");
7631 return strstr (str, "blockdev_getro") == NULL;
7632 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
7633 if (str && strcmp (str, "1") == 0) return 1;
7634 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
7635 if (str && strcmp (str, "1") == 0) return 1;
7639 static int test_blockdev_getro_0 (void)
7641 if (test_blockdev_getro_0_skip ()) {
7642 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_getro_0");
7646 /* InitNone|InitEmpty for test_blockdev_getro_0 */
7648 char device[] = "/dev/sda";
7651 r = guestfs_blockdev_setrw (g, device);
7658 r = guestfs_umount_all (g);
7665 r = guestfs_lvm_remove_all (g);
7669 /* TestOutputTrue for blockdev_getro (0) */
7671 char device[] = "/dev/sda";
7674 r = guestfs_blockdev_setro (g, device);
7679 char device[] = "/dev/sda";
7682 r = guestfs_blockdev_getro (g, device);
7686 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
7693 static int test_blockdev_setrw_0_skip (void)
7697 str = getenv ("TEST_ONLY");
7699 return strstr (str, "blockdev_setrw") == NULL;
7700 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
7701 if (str && strcmp (str, "1") == 0) return 1;
7702 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
7703 if (str && strcmp (str, "1") == 0) return 1;
7707 static int test_blockdev_setrw_0 (void)
7709 if (test_blockdev_setrw_0_skip ()) {
7710 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setrw_0");
7714 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7716 char device[] = "/dev/sda";
7719 r = guestfs_blockdev_setrw (g, device);
7726 r = guestfs_umount_all (g);
7733 r = guestfs_lvm_remove_all (g);
7737 /* TestOutputFalse for blockdev_setrw (0) */
7739 char device[] = "/dev/sda";
7742 r = guestfs_blockdev_setrw (g, device);
7747 char device[] = "/dev/sda";
7750 r = guestfs_blockdev_getro (g, device);
7754 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7761 static int test_blockdev_setro_0_skip (void)
7765 str = getenv ("TEST_ONLY");
7767 return strstr (str, "blockdev_setro") == NULL;
7768 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7769 if (str && strcmp (str, "1") == 0) return 1;
7770 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7771 if (str && strcmp (str, "1") == 0) return 1;
7775 static int test_blockdev_setro_0 (void)
7777 if (test_blockdev_setro_0_skip ()) {
7778 printf ("%s skipped (reason: environment variable set)\n", "test_blockdev_setro_0");
7782 /* InitNone|InitEmpty for test_blockdev_setro_0 */
7784 char device[] = "/dev/sda";
7787 r = guestfs_blockdev_setrw (g, device);
7794 r = guestfs_umount_all (g);
7801 r = guestfs_lvm_remove_all (g);
7805 /* TestOutputTrue for blockdev_setro (0) */
7807 char device[] = "/dev/sda";
7810 r = guestfs_blockdev_setro (g, device);
7815 char device[] = "/dev/sda";
7818 r = guestfs_blockdev_getro (g, device);
7822 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7829 static int test_statvfs_0_skip (void)
7833 str = getenv ("TEST_ONLY");
7835 return strstr (str, "statvfs") == NULL;
7836 str = getenv ("SKIP_TEST_STATVFS_0");
7837 if (str && strcmp (str, "1") == 0) return 1;
7838 str = getenv ("SKIP_TEST_STATVFS");
7839 if (str && strcmp (str, "1") == 0) return 1;
7843 static int test_statvfs_0 (void)
7845 if (test_statvfs_0_skip ()) {
7846 printf ("%s skipped (reason: environment variable set)\n", "test_statvfs_0");
7850 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7852 char device[] = "/dev/sda";
7855 r = guestfs_blockdev_setrw (g, device);
7862 r = guestfs_umount_all (g);
7869 r = guestfs_lvm_remove_all (g);
7874 char device[] = "/dev/sda";
7875 char lines_0[] = ",";
7882 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7887 char fstype[] = "ext2";
7888 char device[] = "/dev/sda1";
7891 r = guestfs_mkfs (g, fstype, device);
7896 char device[] = "/dev/sda1";
7897 char mountpoint[] = "/";
7900 r = guestfs_mount (g, device, mountpoint);
7904 /* TestOutputStruct for statvfs (0) */
7907 struct guestfs_statvfs *r;
7909 r = guestfs_statvfs (g, path);
7912 if (r->bfree != 487702) {
7913 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7917 if (r->blocks != 490020) {
7918 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7922 if (r->bsize != 1024) {
7923 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7932 static int test_lstat_0_skip (void)
7936 str = getenv ("TEST_ONLY");
7938 return strstr (str, "lstat") == NULL;
7939 str = getenv ("SKIP_TEST_LSTAT_0");
7940 if (str && strcmp (str, "1") == 0) return 1;
7941 str = getenv ("SKIP_TEST_LSTAT");
7942 if (str && strcmp (str, "1") == 0) return 1;
7946 static int test_lstat_0 (void)
7948 if (test_lstat_0_skip ()) {
7949 printf ("%s skipped (reason: environment variable set)\n", "test_lstat_0");
7953 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7955 char device[] = "/dev/sda";
7958 r = guestfs_blockdev_setrw (g, device);
7965 r = guestfs_umount_all (g);
7972 r = guestfs_lvm_remove_all (g);
7977 char device[] = "/dev/sda";
7978 char lines_0[] = ",";
7985 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7990 char fstype[] = "ext2";
7991 char device[] = "/dev/sda1";
7994 r = guestfs_mkfs (g, fstype, device);
7999 char device[] = "/dev/sda1";
8000 char mountpoint[] = "/";
8003 r = guestfs_mount (g, device, mountpoint);
8007 /* TestOutputStruct for lstat (0) */
8009 char path[] = "/new";
8012 r = guestfs_touch (g, path);
8017 char path[] = "/new";
8018 struct guestfs_stat *r;
8020 r = guestfs_lstat (g, path);
8024 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
8033 static int test_stat_0_skip (void)
8037 str = getenv ("TEST_ONLY");
8039 return strstr (str, "stat") == NULL;
8040 str = getenv ("SKIP_TEST_STAT_0");
8041 if (str && strcmp (str, "1") == 0) return 1;
8042 str = getenv ("SKIP_TEST_STAT");
8043 if (str && strcmp (str, "1") == 0) return 1;
8047 static int test_stat_0 (void)
8049 if (test_stat_0_skip ()) {
8050 printf ("%s skipped (reason: environment variable set)\n", "test_stat_0");
8054 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
8056 char device[] = "/dev/sda";
8059 r = guestfs_blockdev_setrw (g, device);
8066 r = guestfs_umount_all (g);
8073 r = guestfs_lvm_remove_all (g);
8078 char device[] = "/dev/sda";
8079 char lines_0[] = ",";
8086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8091 char fstype[] = "ext2";
8092 char device[] = "/dev/sda1";
8095 r = guestfs_mkfs (g, fstype, device);
8100 char device[] = "/dev/sda1";
8101 char mountpoint[] = "/";
8104 r = guestfs_mount (g, device, mountpoint);
8108 /* TestOutputStruct for stat (0) */
8110 char path[] = "/new";
8113 r = guestfs_touch (g, path);
8118 char path[] = "/new";
8119 struct guestfs_stat *r;
8121 r = guestfs_stat (g, path);
8125 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
8134 static int test_command_lines_0_skip (void)
8138 str = getenv ("TEST_ONLY");
8140 return strstr (str, "command_lines") == NULL;
8141 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
8142 if (str && strcmp (str, "1") == 0) return 1;
8143 str = getenv ("SKIP_TEST_COMMAND_LINES");
8144 if (str && strcmp (str, "1") == 0) return 1;
8148 static int test_command_lines_0 (void)
8150 if (test_command_lines_0_skip ()) {
8151 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_0");
8155 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
8157 char device[] = "/dev/sda";
8160 r = guestfs_blockdev_setrw (g, device);
8167 r = guestfs_umount_all (g);
8174 r = guestfs_lvm_remove_all (g);
8179 char device[] = "/dev/sda";
8180 char lines_0[] = ",";
8187 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8192 char fstype[] = "ext2";
8193 char device[] = "/dev/sda1";
8196 r = guestfs_mkfs (g, fstype, device);
8201 char device[] = "/dev/sda1";
8202 char mountpoint[] = "/";
8205 r = guestfs_mount (g, device, mountpoint);
8209 /* TestOutputList for command_lines (0) */
8211 char remotefilename[] = "/test-command";
8214 r = guestfs_upload (g, "test-command", remotefilename);
8219 char path[] = "/test-command";
8222 r = guestfs_chmod (g, 493, path);
8227 char arguments_0[] = "/test-command";
8228 char arguments_1[] = "1";
8229 char *arguments[] = {
8237 r = guestfs_command_lines (g, arguments);
8241 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
8246 char expected[] = "Result1";
8247 if (strcmp (r[0], expected) != 0) {
8248 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8253 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
8257 for (i = 0; r[i] != NULL; ++i)
8264 static int test_command_lines_1_skip (void)
8268 str = getenv ("TEST_ONLY");
8270 return strstr (str, "command_lines") == NULL;
8271 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
8272 if (str && strcmp (str, "1") == 0) return 1;
8273 str = getenv ("SKIP_TEST_COMMAND_LINES");
8274 if (str && strcmp (str, "1") == 0) return 1;
8278 static int test_command_lines_1 (void)
8280 if (test_command_lines_1_skip ()) {
8281 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_1");
8285 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
8287 char device[] = "/dev/sda";
8290 r = guestfs_blockdev_setrw (g, device);
8297 r = guestfs_umount_all (g);
8304 r = guestfs_lvm_remove_all (g);
8309 char device[] = "/dev/sda";
8310 char lines_0[] = ",";
8317 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8322 char fstype[] = "ext2";
8323 char device[] = "/dev/sda1";
8326 r = guestfs_mkfs (g, fstype, device);
8331 char device[] = "/dev/sda1";
8332 char mountpoint[] = "/";
8335 r = guestfs_mount (g, device, mountpoint);
8339 /* TestOutputList for command_lines (1) */
8341 char remotefilename[] = "/test-command";
8344 r = guestfs_upload (g, "test-command", remotefilename);
8349 char path[] = "/test-command";
8352 r = guestfs_chmod (g, 493, path);
8357 char arguments_0[] = "/test-command";
8358 char arguments_1[] = "2";
8359 char *arguments[] = {
8367 r = guestfs_command_lines (g, arguments);
8371 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
8376 char expected[] = "Result2";
8377 if (strcmp (r[0], expected) != 0) {
8378 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8383 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
8387 for (i = 0; r[i] != NULL; ++i)
8394 static int test_command_lines_2_skip (void)
8398 str = getenv ("TEST_ONLY");
8400 return strstr (str, "command_lines") == NULL;
8401 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
8402 if (str && strcmp (str, "1") == 0) return 1;
8403 str = getenv ("SKIP_TEST_COMMAND_LINES");
8404 if (str && strcmp (str, "1") == 0) return 1;
8408 static int test_command_lines_2 (void)
8410 if (test_command_lines_2_skip ()) {
8411 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_2");
8415 /* InitBasicFS for test_command_lines_2: 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 /* TestOutputList for command_lines (2) */
8471 char remotefilename[] = "/test-command";
8474 r = guestfs_upload (g, "test-command", remotefilename);
8479 char path[] = "/test-command";
8482 r = guestfs_chmod (g, 493, path);
8487 char arguments_0[] = "/test-command";
8488 char arguments_1[] = "3";
8489 char *arguments[] = {
8497 r = guestfs_command_lines (g, arguments);
8501 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
8506 char expected[] = "";
8507 if (strcmp (r[0], expected) != 0) {
8508 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8513 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
8518 char expected[] = "Result3";
8519 if (strcmp (r[1], expected) != 0) {
8520 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8525 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
8529 for (i = 0; r[i] != NULL; ++i)
8536 static int test_command_lines_3_skip (void)
8540 str = getenv ("TEST_ONLY");
8542 return strstr (str, "command_lines") == NULL;
8543 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
8544 if (str && strcmp (str, "1") == 0) return 1;
8545 str = getenv ("SKIP_TEST_COMMAND_LINES");
8546 if (str && strcmp (str, "1") == 0) return 1;
8550 static int test_command_lines_3 (void)
8552 if (test_command_lines_3_skip ()) {
8553 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_3");
8557 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
8559 char device[] = "/dev/sda";
8562 r = guestfs_blockdev_setrw (g, device);
8569 r = guestfs_umount_all (g);
8576 r = guestfs_lvm_remove_all (g);
8581 char device[] = "/dev/sda";
8582 char lines_0[] = ",";
8589 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8594 char fstype[] = "ext2";
8595 char device[] = "/dev/sda1";
8598 r = guestfs_mkfs (g, fstype, device);
8603 char device[] = "/dev/sda1";
8604 char mountpoint[] = "/";
8607 r = guestfs_mount (g, device, mountpoint);
8611 /* TestOutputList for command_lines (3) */
8613 char remotefilename[] = "/test-command";
8616 r = guestfs_upload (g, "test-command", remotefilename);
8621 char path[] = "/test-command";
8624 r = guestfs_chmod (g, 493, path);
8629 char arguments_0[] = "/test-command";
8630 char arguments_1[] = "4";
8631 char *arguments[] = {
8639 r = guestfs_command_lines (g, arguments);
8643 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8648 char expected[] = "";
8649 if (strcmp (r[0], expected) != 0) {
8650 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8655 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8660 char expected[] = "Result4";
8661 if (strcmp (r[1], expected) != 0) {
8662 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8667 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
8671 for (i = 0; r[i] != NULL; ++i)
8678 static int test_command_lines_4_skip (void)
8682 str = getenv ("TEST_ONLY");
8684 return strstr (str, "command_lines") == NULL;
8685 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
8686 if (str && strcmp (str, "1") == 0) return 1;
8687 str = getenv ("SKIP_TEST_COMMAND_LINES");
8688 if (str && strcmp (str, "1") == 0) return 1;
8692 static int test_command_lines_4 (void)
8694 if (test_command_lines_4_skip ()) {
8695 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_4");
8699 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
8701 char device[] = "/dev/sda";
8704 r = guestfs_blockdev_setrw (g, device);
8711 r = guestfs_umount_all (g);
8718 r = guestfs_lvm_remove_all (g);
8723 char device[] = "/dev/sda";
8724 char lines_0[] = ",";
8731 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8736 char fstype[] = "ext2";
8737 char device[] = "/dev/sda1";
8740 r = guestfs_mkfs (g, fstype, device);
8745 char device[] = "/dev/sda1";
8746 char mountpoint[] = "/";
8749 r = guestfs_mount (g, device, mountpoint);
8753 /* TestOutputList for command_lines (4) */
8755 char remotefilename[] = "/test-command";
8758 r = guestfs_upload (g, "test-command", remotefilename);
8763 char path[] = "/test-command";
8766 r = guestfs_chmod (g, 493, path);
8771 char arguments_0[] = "/test-command";
8772 char arguments_1[] = "5";
8773 char *arguments[] = {
8781 r = guestfs_command_lines (g, arguments);
8785 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8790 char expected[] = "";
8791 if (strcmp (r[0], expected) != 0) {
8792 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8797 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8802 char expected[] = "Result5";
8803 if (strcmp (r[1], expected) != 0) {
8804 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8809 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8814 char expected[] = "";
8815 if (strcmp (r[2], expected) != 0) {
8816 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8821 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8825 for (i = 0; r[i] != NULL; ++i)
8832 static int test_command_lines_5_skip (void)
8836 str = getenv ("TEST_ONLY");
8838 return strstr (str, "command_lines") == NULL;
8839 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8840 if (str && strcmp (str, "1") == 0) return 1;
8841 str = getenv ("SKIP_TEST_COMMAND_LINES");
8842 if (str && strcmp (str, "1") == 0) return 1;
8846 static int test_command_lines_5 (void)
8848 if (test_command_lines_5_skip ()) {
8849 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_5");
8853 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8855 char device[] = "/dev/sda";
8858 r = guestfs_blockdev_setrw (g, device);
8865 r = guestfs_umount_all (g);
8872 r = guestfs_lvm_remove_all (g);
8877 char device[] = "/dev/sda";
8878 char lines_0[] = ",";
8885 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8890 char fstype[] = "ext2";
8891 char device[] = "/dev/sda1";
8894 r = guestfs_mkfs (g, fstype, device);
8899 char device[] = "/dev/sda1";
8900 char mountpoint[] = "/";
8903 r = guestfs_mount (g, device, mountpoint);
8907 /* TestOutputList for command_lines (5) */
8909 char remotefilename[] = "/test-command";
8912 r = guestfs_upload (g, "test-command", remotefilename);
8917 char path[] = "/test-command";
8920 r = guestfs_chmod (g, 493, path);
8925 char arguments_0[] = "/test-command";
8926 char arguments_1[] = "6";
8927 char *arguments[] = {
8935 r = guestfs_command_lines (g, arguments);
8939 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8944 char expected[] = "";
8945 if (strcmp (r[0], expected) != 0) {
8946 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8951 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8956 char expected[] = "";
8957 if (strcmp (r[1], expected) != 0) {
8958 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8963 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8968 char expected[] = "Result6";
8969 if (strcmp (r[2], expected) != 0) {
8970 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8975 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8980 char expected[] = "";
8981 if (strcmp (r[3], expected) != 0) {
8982 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8987 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8991 for (i = 0; r[i] != NULL; ++i)
8998 static int test_command_lines_6_skip (void)
9002 str = getenv ("TEST_ONLY");
9004 return strstr (str, "command_lines") == NULL;
9005 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
9006 if (str && strcmp (str, "1") == 0) return 1;
9007 str = getenv ("SKIP_TEST_COMMAND_LINES");
9008 if (str && strcmp (str, "1") == 0) return 1;
9012 static int test_command_lines_6 (void)
9014 if (test_command_lines_6_skip ()) {
9015 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_6");
9019 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
9021 char device[] = "/dev/sda";
9024 r = guestfs_blockdev_setrw (g, device);
9031 r = guestfs_umount_all (g);
9038 r = guestfs_lvm_remove_all (g);
9043 char device[] = "/dev/sda";
9044 char lines_0[] = ",";
9051 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9056 char fstype[] = "ext2";
9057 char device[] = "/dev/sda1";
9060 r = guestfs_mkfs (g, fstype, device);
9065 char device[] = "/dev/sda1";
9066 char mountpoint[] = "/";
9069 r = guestfs_mount (g, device, mountpoint);
9073 /* TestOutputList for command_lines (6) */
9075 char remotefilename[] = "/test-command";
9078 r = guestfs_upload (g, "test-command", remotefilename);
9083 char path[] = "/test-command";
9086 r = guestfs_chmod (g, 493, path);
9091 char arguments_0[] = "/test-command";
9092 char arguments_1[] = "7";
9093 char *arguments[] = {
9101 r = guestfs_command_lines (g, arguments);
9105 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
9109 for (i = 0; r[i] != NULL; ++i)
9116 static int test_command_lines_7_skip (void)
9120 str = getenv ("TEST_ONLY");
9122 return strstr (str, "command_lines") == NULL;
9123 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
9124 if (str && strcmp (str, "1") == 0) return 1;
9125 str = getenv ("SKIP_TEST_COMMAND_LINES");
9126 if (str && strcmp (str, "1") == 0) return 1;
9130 static int test_command_lines_7 (void)
9132 if (test_command_lines_7_skip ()) {
9133 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_7");
9137 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
9139 char device[] = "/dev/sda";
9142 r = guestfs_blockdev_setrw (g, device);
9149 r = guestfs_umount_all (g);
9156 r = guestfs_lvm_remove_all (g);
9161 char device[] = "/dev/sda";
9162 char lines_0[] = ",";
9169 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9174 char fstype[] = "ext2";
9175 char device[] = "/dev/sda1";
9178 r = guestfs_mkfs (g, fstype, device);
9183 char device[] = "/dev/sda1";
9184 char mountpoint[] = "/";
9187 r = guestfs_mount (g, device, mountpoint);
9191 /* TestOutputList for command_lines (7) */
9193 char remotefilename[] = "/test-command";
9196 r = guestfs_upload (g, "test-command", remotefilename);
9201 char path[] = "/test-command";
9204 r = guestfs_chmod (g, 493, path);
9209 char arguments_0[] = "/test-command";
9210 char arguments_1[] = "8";
9211 char *arguments[] = {
9219 r = guestfs_command_lines (g, arguments);
9223 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
9228 char expected[] = "";
9229 if (strcmp (r[0], expected) != 0) {
9230 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9235 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
9239 for (i = 0; r[i] != NULL; ++i)
9246 static int test_command_lines_8_skip (void)
9250 str = getenv ("TEST_ONLY");
9252 return strstr (str, "command_lines") == NULL;
9253 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
9254 if (str && strcmp (str, "1") == 0) return 1;
9255 str = getenv ("SKIP_TEST_COMMAND_LINES");
9256 if (str && strcmp (str, "1") == 0) return 1;
9260 static int test_command_lines_8 (void)
9262 if (test_command_lines_8_skip ()) {
9263 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_8");
9267 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
9269 char device[] = "/dev/sda";
9272 r = guestfs_blockdev_setrw (g, device);
9279 r = guestfs_umount_all (g);
9286 r = guestfs_lvm_remove_all (g);
9291 char device[] = "/dev/sda";
9292 char lines_0[] = ",";
9299 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9304 char fstype[] = "ext2";
9305 char device[] = "/dev/sda1";
9308 r = guestfs_mkfs (g, fstype, device);
9313 char device[] = "/dev/sda1";
9314 char mountpoint[] = "/";
9317 r = guestfs_mount (g, device, mountpoint);
9321 /* TestOutputList for command_lines (8) */
9323 char remotefilename[] = "/test-command";
9326 r = guestfs_upload (g, "test-command", remotefilename);
9331 char path[] = "/test-command";
9334 r = guestfs_chmod (g, 493, path);
9339 char arguments_0[] = "/test-command";
9340 char arguments_1[] = "9";
9341 char *arguments[] = {
9349 r = guestfs_command_lines (g, arguments);
9353 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
9358 char expected[] = "";
9359 if (strcmp (r[0], expected) != 0) {
9360 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9365 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
9370 char expected[] = "";
9371 if (strcmp (r[1], expected) != 0) {
9372 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9377 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
9381 for (i = 0; r[i] != NULL; ++i)
9388 static int test_command_lines_9_skip (void)
9392 str = getenv ("TEST_ONLY");
9394 return strstr (str, "command_lines") == NULL;
9395 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
9396 if (str && strcmp (str, "1") == 0) return 1;
9397 str = getenv ("SKIP_TEST_COMMAND_LINES");
9398 if (str && strcmp (str, "1") == 0) return 1;
9402 static int test_command_lines_9 (void)
9404 if (test_command_lines_9_skip ()) {
9405 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_9");
9409 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
9411 char device[] = "/dev/sda";
9414 r = guestfs_blockdev_setrw (g, device);
9421 r = guestfs_umount_all (g);
9428 r = guestfs_lvm_remove_all (g);
9433 char device[] = "/dev/sda";
9434 char lines_0[] = ",";
9441 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9446 char fstype[] = "ext2";
9447 char device[] = "/dev/sda1";
9450 r = guestfs_mkfs (g, fstype, device);
9455 char device[] = "/dev/sda1";
9456 char mountpoint[] = "/";
9459 r = guestfs_mount (g, device, mountpoint);
9463 /* TestOutputList for command_lines (9) */
9465 char remotefilename[] = "/test-command";
9468 r = guestfs_upload (g, "test-command", remotefilename);
9473 char path[] = "/test-command";
9476 r = guestfs_chmod (g, 493, path);
9481 char arguments_0[] = "/test-command";
9482 char arguments_1[] = "10";
9483 char *arguments[] = {
9491 r = guestfs_command_lines (g, arguments);
9495 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
9500 char expected[] = "Result10-1";
9501 if (strcmp (r[0], expected) != 0) {
9502 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9507 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
9512 char expected[] = "Result10-2";
9513 if (strcmp (r[1], expected) != 0) {
9514 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9519 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
9523 for (i = 0; r[i] != NULL; ++i)
9530 static int test_command_lines_10_skip (void)
9534 str = getenv ("TEST_ONLY");
9536 return strstr (str, "command_lines") == NULL;
9537 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
9538 if (str && strcmp (str, "1") == 0) return 1;
9539 str = getenv ("SKIP_TEST_COMMAND_LINES");
9540 if (str && strcmp (str, "1") == 0) return 1;
9544 static int test_command_lines_10 (void)
9546 if (test_command_lines_10_skip ()) {
9547 printf ("%s skipped (reason: environment variable set)\n", "test_command_lines_10");
9551 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
9553 char device[] = "/dev/sda";
9556 r = guestfs_blockdev_setrw (g, device);
9563 r = guestfs_umount_all (g);
9570 r = guestfs_lvm_remove_all (g);
9575 char device[] = "/dev/sda";
9576 char lines_0[] = ",";
9583 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9588 char fstype[] = "ext2";
9589 char device[] = "/dev/sda1";
9592 r = guestfs_mkfs (g, fstype, device);
9597 char device[] = "/dev/sda1";
9598 char mountpoint[] = "/";
9601 r = guestfs_mount (g, device, mountpoint);
9605 /* TestOutputList for command_lines (10) */
9607 char remotefilename[] = "/test-command";
9610 r = guestfs_upload (g, "test-command", remotefilename);
9615 char path[] = "/test-command";
9618 r = guestfs_chmod (g, 493, path);
9623 char arguments_0[] = "/test-command";
9624 char arguments_1[] = "11";
9625 char *arguments[] = {
9633 r = guestfs_command_lines (g, arguments);
9637 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9642 char expected[] = "Result11-1";
9643 if (strcmp (r[0], expected) != 0) {
9644 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
9649 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
9654 char expected[] = "Result11-2";
9655 if (strcmp (r[1], expected) != 0) {
9656 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
9661 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
9665 for (i = 0; r[i] != NULL; ++i)
9672 static int test_command_0_skip (void)
9676 str = getenv ("TEST_ONLY");
9678 return strstr (str, "command") == NULL;
9679 str = getenv ("SKIP_TEST_COMMAND_0");
9680 if (str && strcmp (str, "1") == 0) return 1;
9681 str = getenv ("SKIP_TEST_COMMAND");
9682 if (str && strcmp (str, "1") == 0) return 1;
9686 static int test_command_0 (void)
9688 if (test_command_0_skip ()) {
9689 printf ("%s skipped (reason: environment variable set)\n", "test_command_0");
9693 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
9695 char device[] = "/dev/sda";
9698 r = guestfs_blockdev_setrw (g, device);
9705 r = guestfs_umount_all (g);
9712 r = guestfs_lvm_remove_all (g);
9717 char device[] = "/dev/sda";
9718 char lines_0[] = ",";
9725 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9730 char fstype[] = "ext2";
9731 char device[] = "/dev/sda1";
9734 r = guestfs_mkfs (g, fstype, device);
9739 char device[] = "/dev/sda1";
9740 char mountpoint[] = "/";
9743 r = guestfs_mount (g, device, mountpoint);
9747 /* TestOutput for command (0) */
9748 char expected[] = "Result1";
9750 char remotefilename[] = "/test-command";
9753 r = guestfs_upload (g, "test-command", remotefilename);
9758 char path[] = "/test-command";
9761 r = guestfs_chmod (g, 493, path);
9766 char arguments_0[] = "/test-command";
9767 char arguments_1[] = "1";
9768 char *arguments[] = {
9775 r = guestfs_command (g, arguments);
9778 if (strcmp (r, expected) != 0) {
9779 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9787 static int test_command_1_skip (void)
9791 str = getenv ("TEST_ONLY");
9793 return strstr (str, "command") == NULL;
9794 str = getenv ("SKIP_TEST_COMMAND_1");
9795 if (str && strcmp (str, "1") == 0) return 1;
9796 str = getenv ("SKIP_TEST_COMMAND");
9797 if (str && strcmp (str, "1") == 0) return 1;
9801 static int test_command_1 (void)
9803 if (test_command_1_skip ()) {
9804 printf ("%s skipped (reason: environment variable set)\n", "test_command_1");
9808 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9810 char device[] = "/dev/sda";
9813 r = guestfs_blockdev_setrw (g, device);
9820 r = guestfs_umount_all (g);
9827 r = guestfs_lvm_remove_all (g);
9832 char device[] = "/dev/sda";
9833 char lines_0[] = ",";
9840 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9845 char fstype[] = "ext2";
9846 char device[] = "/dev/sda1";
9849 r = guestfs_mkfs (g, fstype, device);
9854 char device[] = "/dev/sda1";
9855 char mountpoint[] = "/";
9858 r = guestfs_mount (g, device, mountpoint);
9862 /* TestOutput for command (1) */
9863 char expected[] = "Result2\n";
9865 char remotefilename[] = "/test-command";
9868 r = guestfs_upload (g, "test-command", remotefilename);
9873 char path[] = "/test-command";
9876 r = guestfs_chmod (g, 493, path);
9881 char arguments_0[] = "/test-command";
9882 char arguments_1[] = "2";
9883 char *arguments[] = {
9890 r = guestfs_command (g, arguments);
9893 if (strcmp (r, expected) != 0) {
9894 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9902 static int test_command_2_skip (void)
9906 str = getenv ("TEST_ONLY");
9908 return strstr (str, "command") == NULL;
9909 str = getenv ("SKIP_TEST_COMMAND_2");
9910 if (str && strcmp (str, "1") == 0) return 1;
9911 str = getenv ("SKIP_TEST_COMMAND");
9912 if (str && strcmp (str, "1") == 0) return 1;
9916 static int test_command_2 (void)
9918 if (test_command_2_skip ()) {
9919 printf ("%s skipped (reason: environment variable set)\n", "test_command_2");
9923 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9925 char device[] = "/dev/sda";
9928 r = guestfs_blockdev_setrw (g, device);
9935 r = guestfs_umount_all (g);
9942 r = guestfs_lvm_remove_all (g);
9947 char device[] = "/dev/sda";
9948 char lines_0[] = ",";
9955 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9960 char fstype[] = "ext2";
9961 char device[] = "/dev/sda1";
9964 r = guestfs_mkfs (g, fstype, device);
9969 char device[] = "/dev/sda1";
9970 char mountpoint[] = "/";
9973 r = guestfs_mount (g, device, mountpoint);
9977 /* TestOutput for command (2) */
9978 char expected[] = "\nResult3";
9980 char remotefilename[] = "/test-command";
9983 r = guestfs_upload (g, "test-command", remotefilename);
9988 char path[] = "/test-command";
9991 r = guestfs_chmod (g, 493, path);
9996 char arguments_0[] = "/test-command";
9997 char arguments_1[] = "3";
9998 char *arguments[] = {
10004 suppress_error = 0;
10005 r = guestfs_command (g, arguments);
10008 if (strcmp (r, expected) != 0) {
10009 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
10017 static int test_command_3_skip (void)
10021 str = getenv ("TEST_ONLY");
10023 return strstr (str, "command") == NULL;
10024 str = getenv ("SKIP_TEST_COMMAND_3");
10025 if (str && strcmp (str, "1") == 0) return 1;
10026 str = getenv ("SKIP_TEST_COMMAND");
10027 if (str && strcmp (str, "1") == 0) return 1;
10031 static int test_command_3 (void)
10033 if (test_command_3_skip ()) {
10034 printf ("%s skipped (reason: environment variable set)\n", "test_command_3");
10038 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
10040 char device[] = "/dev/sda";
10042 suppress_error = 0;
10043 r = guestfs_blockdev_setrw (g, device);
10049 suppress_error = 0;
10050 r = guestfs_umount_all (g);
10056 suppress_error = 0;
10057 r = guestfs_lvm_remove_all (g);
10062 char device[] = "/dev/sda";
10063 char lines_0[] = ",";
10069 suppress_error = 0;
10070 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10075 char fstype[] = "ext2";
10076 char device[] = "/dev/sda1";
10078 suppress_error = 0;
10079 r = guestfs_mkfs (g, fstype, device);
10084 char device[] = "/dev/sda1";
10085 char mountpoint[] = "/";
10087 suppress_error = 0;
10088 r = guestfs_mount (g, device, mountpoint);
10092 /* TestOutput for command (3) */
10093 char expected[] = "\nResult4\n";
10095 char remotefilename[] = "/test-command";
10097 suppress_error = 0;
10098 r = guestfs_upload (g, "test-command", remotefilename);
10103 char path[] = "/test-command";
10105 suppress_error = 0;
10106 r = guestfs_chmod (g, 493, path);
10111 char arguments_0[] = "/test-command";
10112 char arguments_1[] = "4";
10113 char *arguments[] = {
10119 suppress_error = 0;
10120 r = guestfs_command (g, arguments);
10123 if (strcmp (r, expected) != 0) {
10124 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
10132 static int test_command_4_skip (void)
10136 str = getenv ("TEST_ONLY");
10138 return strstr (str, "command") == NULL;
10139 str = getenv ("SKIP_TEST_COMMAND_4");
10140 if (str && strcmp (str, "1") == 0) return 1;
10141 str = getenv ("SKIP_TEST_COMMAND");
10142 if (str && strcmp (str, "1") == 0) return 1;
10146 static int test_command_4 (void)
10148 if (test_command_4_skip ()) {
10149 printf ("%s skipped (reason: environment variable set)\n", "test_command_4");
10153 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
10155 char device[] = "/dev/sda";
10157 suppress_error = 0;
10158 r = guestfs_blockdev_setrw (g, device);
10164 suppress_error = 0;
10165 r = guestfs_umount_all (g);
10171 suppress_error = 0;
10172 r = guestfs_lvm_remove_all (g);
10177 char device[] = "/dev/sda";
10178 char lines_0[] = ",";
10184 suppress_error = 0;
10185 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10190 char fstype[] = "ext2";
10191 char device[] = "/dev/sda1";
10193 suppress_error = 0;
10194 r = guestfs_mkfs (g, fstype, device);
10199 char device[] = "/dev/sda1";
10200 char mountpoint[] = "/";
10202 suppress_error = 0;
10203 r = guestfs_mount (g, device, mountpoint);
10207 /* TestOutput for command (4) */
10208 char expected[] = "\nResult5\n\n";
10210 char remotefilename[] = "/test-command";
10212 suppress_error = 0;
10213 r = guestfs_upload (g, "test-command", remotefilename);
10218 char path[] = "/test-command";
10220 suppress_error = 0;
10221 r = guestfs_chmod (g, 493, path);
10226 char arguments_0[] = "/test-command";
10227 char arguments_1[] = "5";
10228 char *arguments[] = {
10234 suppress_error = 0;
10235 r = guestfs_command (g, arguments);
10238 if (strcmp (r, expected) != 0) {
10239 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
10247 static int test_command_5_skip (void)
10251 str = getenv ("TEST_ONLY");
10253 return strstr (str, "command") == NULL;
10254 str = getenv ("SKIP_TEST_COMMAND_5");
10255 if (str && strcmp (str, "1") == 0) return 1;
10256 str = getenv ("SKIP_TEST_COMMAND");
10257 if (str && strcmp (str, "1") == 0) return 1;
10261 static int test_command_5 (void)
10263 if (test_command_5_skip ()) {
10264 printf ("%s skipped (reason: environment variable set)\n", "test_command_5");
10268 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
10270 char device[] = "/dev/sda";
10272 suppress_error = 0;
10273 r = guestfs_blockdev_setrw (g, device);
10279 suppress_error = 0;
10280 r = guestfs_umount_all (g);
10286 suppress_error = 0;
10287 r = guestfs_lvm_remove_all (g);
10292 char device[] = "/dev/sda";
10293 char lines_0[] = ",";
10299 suppress_error = 0;
10300 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10305 char fstype[] = "ext2";
10306 char device[] = "/dev/sda1";
10308 suppress_error = 0;
10309 r = guestfs_mkfs (g, fstype, device);
10314 char device[] = "/dev/sda1";
10315 char mountpoint[] = "/";
10317 suppress_error = 0;
10318 r = guestfs_mount (g, device, mountpoint);
10322 /* TestOutput for command (5) */
10323 char expected[] = "\n\nResult6\n\n";
10325 char remotefilename[] = "/test-command";
10327 suppress_error = 0;
10328 r = guestfs_upload (g, "test-command", remotefilename);
10333 char path[] = "/test-command";
10335 suppress_error = 0;
10336 r = guestfs_chmod (g, 493, path);
10341 char arguments_0[] = "/test-command";
10342 char arguments_1[] = "6";
10343 char *arguments[] = {
10349 suppress_error = 0;
10350 r = guestfs_command (g, arguments);
10353 if (strcmp (r, expected) != 0) {
10354 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
10362 static int test_command_6_skip (void)
10366 str = getenv ("TEST_ONLY");
10368 return strstr (str, "command") == NULL;
10369 str = getenv ("SKIP_TEST_COMMAND_6");
10370 if (str && strcmp (str, "1") == 0) return 1;
10371 str = getenv ("SKIP_TEST_COMMAND");
10372 if (str && strcmp (str, "1") == 0) return 1;
10376 static int test_command_6 (void)
10378 if (test_command_6_skip ()) {
10379 printf ("%s skipped (reason: environment variable set)\n", "test_command_6");
10383 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
10385 char device[] = "/dev/sda";
10387 suppress_error = 0;
10388 r = guestfs_blockdev_setrw (g, device);
10394 suppress_error = 0;
10395 r = guestfs_umount_all (g);
10401 suppress_error = 0;
10402 r = guestfs_lvm_remove_all (g);
10407 char device[] = "/dev/sda";
10408 char lines_0[] = ",";
10414 suppress_error = 0;
10415 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10420 char fstype[] = "ext2";
10421 char device[] = "/dev/sda1";
10423 suppress_error = 0;
10424 r = guestfs_mkfs (g, fstype, device);
10429 char device[] = "/dev/sda1";
10430 char mountpoint[] = "/";
10432 suppress_error = 0;
10433 r = guestfs_mount (g, device, mountpoint);
10437 /* TestOutput for command (6) */
10438 char expected[] = "";
10440 char remotefilename[] = "/test-command";
10442 suppress_error = 0;
10443 r = guestfs_upload (g, "test-command", remotefilename);
10448 char path[] = "/test-command";
10450 suppress_error = 0;
10451 r = guestfs_chmod (g, 493, path);
10456 char arguments_0[] = "/test-command";
10457 char arguments_1[] = "7";
10458 char *arguments[] = {
10464 suppress_error = 0;
10465 r = guestfs_command (g, arguments);
10468 if (strcmp (r, expected) != 0) {
10469 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
10477 static int test_command_7_skip (void)
10481 str = getenv ("TEST_ONLY");
10483 return strstr (str, "command") == NULL;
10484 str = getenv ("SKIP_TEST_COMMAND_7");
10485 if (str && strcmp (str, "1") == 0) return 1;
10486 str = getenv ("SKIP_TEST_COMMAND");
10487 if (str && strcmp (str, "1") == 0) return 1;
10491 static int test_command_7 (void)
10493 if (test_command_7_skip ()) {
10494 printf ("%s skipped (reason: environment variable set)\n", "test_command_7");
10498 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
10500 char device[] = "/dev/sda";
10502 suppress_error = 0;
10503 r = guestfs_blockdev_setrw (g, device);
10509 suppress_error = 0;
10510 r = guestfs_umount_all (g);
10516 suppress_error = 0;
10517 r = guestfs_lvm_remove_all (g);
10522 char device[] = "/dev/sda";
10523 char lines_0[] = ",";
10529 suppress_error = 0;
10530 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10535 char fstype[] = "ext2";
10536 char device[] = "/dev/sda1";
10538 suppress_error = 0;
10539 r = guestfs_mkfs (g, fstype, device);
10544 char device[] = "/dev/sda1";
10545 char mountpoint[] = "/";
10547 suppress_error = 0;
10548 r = guestfs_mount (g, device, mountpoint);
10552 /* TestOutput for command (7) */
10553 char expected[] = "\n";
10555 char remotefilename[] = "/test-command";
10557 suppress_error = 0;
10558 r = guestfs_upload (g, "test-command", remotefilename);
10563 char path[] = "/test-command";
10565 suppress_error = 0;
10566 r = guestfs_chmod (g, 493, path);
10571 char arguments_0[] = "/test-command";
10572 char arguments_1[] = "8";
10573 char *arguments[] = {
10579 suppress_error = 0;
10580 r = guestfs_command (g, arguments);
10583 if (strcmp (r, expected) != 0) {
10584 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
10592 static int test_command_8_skip (void)
10596 str = getenv ("TEST_ONLY");
10598 return strstr (str, "command") == NULL;
10599 str = getenv ("SKIP_TEST_COMMAND_8");
10600 if (str && strcmp (str, "1") == 0) return 1;
10601 str = getenv ("SKIP_TEST_COMMAND");
10602 if (str && strcmp (str, "1") == 0) return 1;
10606 static int test_command_8 (void)
10608 if (test_command_8_skip ()) {
10609 printf ("%s skipped (reason: environment variable set)\n", "test_command_8");
10613 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
10615 char device[] = "/dev/sda";
10617 suppress_error = 0;
10618 r = guestfs_blockdev_setrw (g, device);
10624 suppress_error = 0;
10625 r = guestfs_umount_all (g);
10631 suppress_error = 0;
10632 r = guestfs_lvm_remove_all (g);
10637 char device[] = "/dev/sda";
10638 char lines_0[] = ",";
10644 suppress_error = 0;
10645 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10650 char fstype[] = "ext2";
10651 char device[] = "/dev/sda1";
10653 suppress_error = 0;
10654 r = guestfs_mkfs (g, fstype, device);
10659 char device[] = "/dev/sda1";
10660 char mountpoint[] = "/";
10662 suppress_error = 0;
10663 r = guestfs_mount (g, device, mountpoint);
10667 /* TestOutput for command (8) */
10668 char expected[] = "\n\n";
10670 char remotefilename[] = "/test-command";
10672 suppress_error = 0;
10673 r = guestfs_upload (g, "test-command", remotefilename);
10678 char path[] = "/test-command";
10680 suppress_error = 0;
10681 r = guestfs_chmod (g, 493, path);
10686 char arguments_0[] = "/test-command";
10687 char arguments_1[] = "9";
10688 char *arguments[] = {
10694 suppress_error = 0;
10695 r = guestfs_command (g, arguments);
10698 if (strcmp (r, expected) != 0) {
10699 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
10707 static int test_command_9_skip (void)
10711 str = getenv ("TEST_ONLY");
10713 return strstr (str, "command") == NULL;
10714 str = getenv ("SKIP_TEST_COMMAND_9");
10715 if (str && strcmp (str, "1") == 0) return 1;
10716 str = getenv ("SKIP_TEST_COMMAND");
10717 if (str && strcmp (str, "1") == 0) return 1;
10721 static int test_command_9 (void)
10723 if (test_command_9_skip ()) {
10724 printf ("%s skipped (reason: environment variable set)\n", "test_command_9");
10728 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
10730 char device[] = "/dev/sda";
10732 suppress_error = 0;
10733 r = guestfs_blockdev_setrw (g, device);
10739 suppress_error = 0;
10740 r = guestfs_umount_all (g);
10746 suppress_error = 0;
10747 r = guestfs_lvm_remove_all (g);
10752 char device[] = "/dev/sda";
10753 char lines_0[] = ",";
10759 suppress_error = 0;
10760 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10765 char fstype[] = "ext2";
10766 char device[] = "/dev/sda1";
10768 suppress_error = 0;
10769 r = guestfs_mkfs (g, fstype, device);
10774 char device[] = "/dev/sda1";
10775 char mountpoint[] = "/";
10777 suppress_error = 0;
10778 r = guestfs_mount (g, device, mountpoint);
10782 /* TestOutput for command (9) */
10783 char expected[] = "Result10-1\nResult10-2\n";
10785 char remotefilename[] = "/test-command";
10787 suppress_error = 0;
10788 r = guestfs_upload (g, "test-command", remotefilename);
10793 char path[] = "/test-command";
10795 suppress_error = 0;
10796 r = guestfs_chmod (g, 493, path);
10801 char arguments_0[] = "/test-command";
10802 char arguments_1[] = "10";
10803 char *arguments[] = {
10809 suppress_error = 0;
10810 r = guestfs_command (g, arguments);
10813 if (strcmp (r, expected) != 0) {
10814 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10822 static int test_command_10_skip (void)
10826 str = getenv ("TEST_ONLY");
10828 return strstr (str, "command") == NULL;
10829 str = getenv ("SKIP_TEST_COMMAND_10");
10830 if (str && strcmp (str, "1") == 0) return 1;
10831 str = getenv ("SKIP_TEST_COMMAND");
10832 if (str && strcmp (str, "1") == 0) return 1;
10836 static int test_command_10 (void)
10838 if (test_command_10_skip ()) {
10839 printf ("%s skipped (reason: environment variable set)\n", "test_command_10");
10843 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10845 char device[] = "/dev/sda";
10847 suppress_error = 0;
10848 r = guestfs_blockdev_setrw (g, device);
10854 suppress_error = 0;
10855 r = guestfs_umount_all (g);
10861 suppress_error = 0;
10862 r = guestfs_lvm_remove_all (g);
10867 char device[] = "/dev/sda";
10868 char lines_0[] = ",";
10874 suppress_error = 0;
10875 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10880 char fstype[] = "ext2";
10881 char device[] = "/dev/sda1";
10883 suppress_error = 0;
10884 r = guestfs_mkfs (g, fstype, device);
10889 char device[] = "/dev/sda1";
10890 char mountpoint[] = "/";
10892 suppress_error = 0;
10893 r = guestfs_mount (g, device, mountpoint);
10897 /* TestOutput for command (10) */
10898 char expected[] = "Result11-1\nResult11-2";
10900 char remotefilename[] = "/test-command";
10902 suppress_error = 0;
10903 r = guestfs_upload (g, "test-command", remotefilename);
10908 char path[] = "/test-command";
10910 suppress_error = 0;
10911 r = guestfs_chmod (g, 493, path);
10916 char arguments_0[] = "/test-command";
10917 char arguments_1[] = "11";
10918 char *arguments[] = {
10924 suppress_error = 0;
10925 r = guestfs_command (g, arguments);
10928 if (strcmp (r, expected) != 0) {
10929 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10937 static int test_command_11_skip (void)
10941 str = getenv ("TEST_ONLY");
10943 return strstr (str, "command") == NULL;
10944 str = getenv ("SKIP_TEST_COMMAND_11");
10945 if (str && strcmp (str, "1") == 0) return 1;
10946 str = getenv ("SKIP_TEST_COMMAND");
10947 if (str && strcmp (str, "1") == 0) return 1;
10951 static int test_command_11 (void)
10953 if (test_command_11_skip ()) {
10954 printf ("%s skipped (reason: environment variable set)\n", "test_command_11");
10958 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10960 char device[] = "/dev/sda";
10962 suppress_error = 0;
10963 r = guestfs_blockdev_setrw (g, device);
10969 suppress_error = 0;
10970 r = guestfs_umount_all (g);
10976 suppress_error = 0;
10977 r = guestfs_lvm_remove_all (g);
10982 char device[] = "/dev/sda";
10983 char lines_0[] = ",";
10989 suppress_error = 0;
10990 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10995 char fstype[] = "ext2";
10996 char device[] = "/dev/sda1";
10998 suppress_error = 0;
10999 r = guestfs_mkfs (g, fstype, device);
11004 char device[] = "/dev/sda1";
11005 char mountpoint[] = "/";
11007 suppress_error = 0;
11008 r = guestfs_mount (g, device, mountpoint);
11012 /* TestLastFail for command (11) */
11014 char remotefilename[] = "/test-command";
11016 suppress_error = 0;
11017 r = guestfs_upload (g, "test-command", remotefilename);
11022 char path[] = "/test-command";
11024 suppress_error = 0;
11025 r = guestfs_chmod (g, 493, path);
11030 char arguments_0[] = "/test-command";
11031 char *arguments[] = {
11036 suppress_error = 1;
11037 r = guestfs_command (g, arguments);
11045 static int test_file_0_skip (void)
11049 str = getenv ("TEST_ONLY");
11051 return strstr (str, "file") == NULL;
11052 str = getenv ("SKIP_TEST_FILE_0");
11053 if (str && strcmp (str, "1") == 0) return 1;
11054 str = getenv ("SKIP_TEST_FILE");
11055 if (str && strcmp (str, "1") == 0) return 1;
11059 static int test_file_0 (void)
11061 if (test_file_0_skip ()) {
11062 printf ("%s skipped (reason: environment variable set)\n", "test_file_0");
11066 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
11068 char device[] = "/dev/sda";
11070 suppress_error = 0;
11071 r = guestfs_blockdev_setrw (g, device);
11077 suppress_error = 0;
11078 r = guestfs_umount_all (g);
11084 suppress_error = 0;
11085 r = guestfs_lvm_remove_all (g);
11090 char device[] = "/dev/sda";
11091 char lines_0[] = ",";
11097 suppress_error = 0;
11098 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11103 char fstype[] = "ext2";
11104 char device[] = "/dev/sda1";
11106 suppress_error = 0;
11107 r = guestfs_mkfs (g, fstype, device);
11112 char device[] = "/dev/sda1";
11113 char mountpoint[] = "/";
11115 suppress_error = 0;
11116 r = guestfs_mount (g, device, mountpoint);
11120 /* TestOutput for file (0) */
11121 char expected[] = "empty";
11123 char path[] = "/new";
11125 suppress_error = 0;
11126 r = guestfs_touch (g, path);
11131 char path[] = "/new";
11133 suppress_error = 0;
11134 r = guestfs_file (g, path);
11137 if (strcmp (r, expected) != 0) {
11138 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11146 static int test_file_1_skip (void)
11150 str = getenv ("TEST_ONLY");
11152 return strstr (str, "file") == NULL;
11153 str = getenv ("SKIP_TEST_FILE_1");
11154 if (str && strcmp (str, "1") == 0) return 1;
11155 str = getenv ("SKIP_TEST_FILE");
11156 if (str && strcmp (str, "1") == 0) return 1;
11160 static int test_file_1 (void)
11162 if (test_file_1_skip ()) {
11163 printf ("%s skipped (reason: environment variable set)\n", "test_file_1");
11167 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
11169 char device[] = "/dev/sda";
11171 suppress_error = 0;
11172 r = guestfs_blockdev_setrw (g, device);
11178 suppress_error = 0;
11179 r = guestfs_umount_all (g);
11185 suppress_error = 0;
11186 r = guestfs_lvm_remove_all (g);
11191 char device[] = "/dev/sda";
11192 char lines_0[] = ",";
11198 suppress_error = 0;
11199 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11204 char fstype[] = "ext2";
11205 char device[] = "/dev/sda1";
11207 suppress_error = 0;
11208 r = guestfs_mkfs (g, fstype, device);
11213 char device[] = "/dev/sda1";
11214 char mountpoint[] = "/";
11216 suppress_error = 0;
11217 r = guestfs_mount (g, device, mountpoint);
11221 /* TestOutput for file (1) */
11222 char expected[] = "ASCII text";
11224 char path[] = "/new";
11225 char content[] = "some content\n";
11227 suppress_error = 0;
11228 r = guestfs_write_file (g, path, content, 0);
11233 char path[] = "/new";
11235 suppress_error = 0;
11236 r = guestfs_file (g, path);
11239 if (strcmp (r, expected) != 0) {
11240 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11248 static int test_file_2_skip (void)
11252 str = getenv ("TEST_ONLY");
11254 return strstr (str, "file") == NULL;
11255 str = getenv ("SKIP_TEST_FILE_2");
11256 if (str && strcmp (str, "1") == 0) return 1;
11257 str = getenv ("SKIP_TEST_FILE");
11258 if (str && strcmp (str, "1") == 0) return 1;
11262 static int test_file_2 (void)
11264 if (test_file_2_skip ()) {
11265 printf ("%s skipped (reason: environment variable set)\n", "test_file_2");
11269 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
11271 char device[] = "/dev/sda";
11273 suppress_error = 0;
11274 r = guestfs_blockdev_setrw (g, device);
11280 suppress_error = 0;
11281 r = guestfs_umount_all (g);
11287 suppress_error = 0;
11288 r = guestfs_lvm_remove_all (g);
11293 char device[] = "/dev/sda";
11294 char lines_0[] = ",";
11300 suppress_error = 0;
11301 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11306 char fstype[] = "ext2";
11307 char device[] = "/dev/sda1";
11309 suppress_error = 0;
11310 r = guestfs_mkfs (g, fstype, device);
11315 char device[] = "/dev/sda1";
11316 char mountpoint[] = "/";
11318 suppress_error = 0;
11319 r = guestfs_mount (g, device, mountpoint);
11323 /* TestLastFail for file (2) */
11325 char path[] = "/nofile";
11327 suppress_error = 1;
11328 r = guestfs_file (g, path);
11336 static int test_umount_all_0_skip (void)
11340 str = getenv ("TEST_ONLY");
11342 return strstr (str, "umount_all") == NULL;
11343 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
11344 if (str && strcmp (str, "1") == 0) return 1;
11345 str = getenv ("SKIP_TEST_UMOUNT_ALL");
11346 if (str && strcmp (str, "1") == 0) return 1;
11350 static int test_umount_all_0 (void)
11352 if (test_umount_all_0_skip ()) {
11353 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_0");
11357 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
11359 char device[] = "/dev/sda";
11361 suppress_error = 0;
11362 r = guestfs_blockdev_setrw (g, device);
11368 suppress_error = 0;
11369 r = guestfs_umount_all (g);
11375 suppress_error = 0;
11376 r = guestfs_lvm_remove_all (g);
11381 char device[] = "/dev/sda";
11382 char lines_0[] = ",";
11388 suppress_error = 0;
11389 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11394 char fstype[] = "ext2";
11395 char device[] = "/dev/sda1";
11397 suppress_error = 0;
11398 r = guestfs_mkfs (g, fstype, device);
11403 char device[] = "/dev/sda1";
11404 char mountpoint[] = "/";
11406 suppress_error = 0;
11407 r = guestfs_mount (g, device, mountpoint);
11411 /* TestOutputList for umount_all (0) */
11414 suppress_error = 0;
11415 r = guestfs_umount_all (g);
11422 suppress_error = 0;
11423 r = guestfs_mounts (g);
11426 if (r[0] != NULL) {
11427 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
11431 for (i = 0; r[i] != NULL; ++i)
11438 static int test_umount_all_1_skip (void)
11442 str = getenv ("TEST_ONLY");
11444 return strstr (str, "umount_all") == NULL;
11445 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
11446 if (str && strcmp (str, "1") == 0) return 1;
11447 str = getenv ("SKIP_TEST_UMOUNT_ALL");
11448 if (str && strcmp (str, "1") == 0) return 1;
11452 static int test_umount_all_1 (void)
11454 if (test_umount_all_1_skip ()) {
11455 printf ("%s skipped (reason: environment variable set)\n", "test_umount_all_1");
11459 /* InitNone|InitEmpty for test_umount_all_1 */
11461 char device[] = "/dev/sda";
11463 suppress_error = 0;
11464 r = guestfs_blockdev_setrw (g, device);
11470 suppress_error = 0;
11471 r = guestfs_umount_all (g);
11477 suppress_error = 0;
11478 r = guestfs_lvm_remove_all (g);
11482 /* TestOutputList for umount_all (1) */
11484 char device[] = "/dev/sda";
11485 char lines_0[] = ",10";
11486 char lines_1[] = ",20";
11487 char lines_2[] = ",";
11495 suppress_error = 0;
11496 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11501 char fstype[] = "ext2";
11502 char device[] = "/dev/sda1";
11504 suppress_error = 0;
11505 r = guestfs_mkfs (g, fstype, device);
11510 char fstype[] = "ext2";
11511 char device[] = "/dev/sda2";
11513 suppress_error = 0;
11514 r = guestfs_mkfs (g, fstype, device);
11519 char fstype[] = "ext2";
11520 char device[] = "/dev/sda3";
11522 suppress_error = 0;
11523 r = guestfs_mkfs (g, fstype, device);
11528 char device[] = "/dev/sda1";
11529 char mountpoint[] = "/";
11531 suppress_error = 0;
11532 r = guestfs_mount (g, device, mountpoint);
11537 char path[] = "/mp1";
11539 suppress_error = 0;
11540 r = guestfs_mkdir (g, path);
11545 char device[] = "/dev/sda2";
11546 char mountpoint[] = "/mp1";
11548 suppress_error = 0;
11549 r = guestfs_mount (g, device, mountpoint);
11554 char path[] = "/mp1/mp2";
11556 suppress_error = 0;
11557 r = guestfs_mkdir (g, path);
11562 char device[] = "/dev/sda3";
11563 char mountpoint[] = "/mp1/mp2";
11565 suppress_error = 0;
11566 r = guestfs_mount (g, device, mountpoint);
11571 char path[] = "/mp1/mp2/mp3";
11573 suppress_error = 0;
11574 r = guestfs_mkdir (g, path);
11580 suppress_error = 0;
11581 r = guestfs_umount_all (g);
11588 suppress_error = 0;
11589 r = guestfs_mounts (g);
11592 if (r[0] != NULL) {
11593 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
11597 for (i = 0; r[i] != NULL; ++i)
11604 static int test_mounts_0_skip (void)
11608 str = getenv ("TEST_ONLY");
11610 return strstr (str, "mounts") == NULL;
11611 str = getenv ("SKIP_TEST_MOUNTS_0");
11612 if (str && strcmp (str, "1") == 0) return 1;
11613 str = getenv ("SKIP_TEST_MOUNTS");
11614 if (str && strcmp (str, "1") == 0) return 1;
11618 static int test_mounts_0 (void)
11620 if (test_mounts_0_skip ()) {
11621 printf ("%s skipped (reason: environment variable set)\n", "test_mounts_0");
11625 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
11627 char device[] = "/dev/sda";
11629 suppress_error = 0;
11630 r = guestfs_blockdev_setrw (g, device);
11636 suppress_error = 0;
11637 r = guestfs_umount_all (g);
11643 suppress_error = 0;
11644 r = guestfs_lvm_remove_all (g);
11649 char device[] = "/dev/sda";
11650 char lines_0[] = ",";
11656 suppress_error = 0;
11657 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11662 char fstype[] = "ext2";
11663 char device[] = "/dev/sda1";
11665 suppress_error = 0;
11666 r = guestfs_mkfs (g, fstype, device);
11671 char device[] = "/dev/sda1";
11672 char mountpoint[] = "/";
11674 suppress_error = 0;
11675 r = guestfs_mount (g, device, mountpoint);
11679 /* TestOutputListOfDevices for mounts (0) */
11683 suppress_error = 0;
11684 r = guestfs_mounts (g);
11688 fprintf (stderr, "test_mounts_0: short list returned from command\n");
11693 char expected[] = "/dev/sda1";
11695 if (strcmp (r[0], expected) != 0) {
11696 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11700 if (r[1] != NULL) {
11701 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
11705 for (i = 0; r[i] != NULL; ++i)
11712 static int test_umount_0_skip (void)
11716 str = getenv ("TEST_ONLY");
11718 return strstr (str, "umount") == NULL;
11719 str = getenv ("SKIP_TEST_UMOUNT_0");
11720 if (str && strcmp (str, "1") == 0) return 1;
11721 str = getenv ("SKIP_TEST_UMOUNT");
11722 if (str && strcmp (str, "1") == 0) return 1;
11726 static int test_umount_0 (void)
11728 if (test_umount_0_skip ()) {
11729 printf ("%s skipped (reason: environment variable set)\n", "test_umount_0");
11733 /* InitNone|InitEmpty for test_umount_0 */
11735 char device[] = "/dev/sda";
11737 suppress_error = 0;
11738 r = guestfs_blockdev_setrw (g, device);
11744 suppress_error = 0;
11745 r = guestfs_umount_all (g);
11751 suppress_error = 0;
11752 r = guestfs_lvm_remove_all (g);
11756 /* TestOutputListOfDevices for umount (0) */
11758 char device[] = "/dev/sda";
11759 char lines_0[] = ",";
11765 suppress_error = 0;
11766 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11771 char fstype[] = "ext2";
11772 char device[] = "/dev/sda1";
11774 suppress_error = 0;
11775 r = guestfs_mkfs (g, fstype, device);
11780 char device[] = "/dev/sda1";
11781 char mountpoint[] = "/";
11783 suppress_error = 0;
11784 r = guestfs_mount (g, device, mountpoint);
11791 suppress_error = 0;
11792 r = guestfs_mounts (g);
11796 fprintf (stderr, "test_umount_0: short list returned from command\n");
11801 char expected[] = "/dev/sda1";
11803 if (strcmp (r[0], expected) != 0) {
11804 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11808 if (r[1] != NULL) {
11809 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
11813 for (i = 0; r[i] != NULL; ++i)
11820 static int test_umount_1_skip (void)
11824 str = getenv ("TEST_ONLY");
11826 return strstr (str, "umount") == NULL;
11827 str = getenv ("SKIP_TEST_UMOUNT_1");
11828 if (str && strcmp (str, "1") == 0) return 1;
11829 str = getenv ("SKIP_TEST_UMOUNT");
11830 if (str && strcmp (str, "1") == 0) return 1;
11834 static int test_umount_1 (void)
11836 if (test_umount_1_skip ()) {
11837 printf ("%s skipped (reason: environment variable set)\n", "test_umount_1");
11841 /* InitNone|InitEmpty for test_umount_1 */
11843 char device[] = "/dev/sda";
11845 suppress_error = 0;
11846 r = guestfs_blockdev_setrw (g, device);
11852 suppress_error = 0;
11853 r = guestfs_umount_all (g);
11859 suppress_error = 0;
11860 r = guestfs_lvm_remove_all (g);
11864 /* TestOutputList for umount (1) */
11866 char device[] = "/dev/sda";
11867 char lines_0[] = ",";
11873 suppress_error = 0;
11874 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11879 char fstype[] = "ext2";
11880 char device[] = "/dev/sda1";
11882 suppress_error = 0;
11883 r = guestfs_mkfs (g, fstype, device);
11888 char device[] = "/dev/sda1";
11889 char mountpoint[] = "/";
11891 suppress_error = 0;
11892 r = guestfs_mount (g, device, mountpoint);
11897 char pathordevice[] = "/";
11899 suppress_error = 0;
11900 r = guestfs_umount (g, pathordevice);
11907 suppress_error = 0;
11908 r = guestfs_mounts (g);
11911 if (r[0] != NULL) {
11912 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11916 for (i = 0; r[i] != NULL; ++i)
11923 static int test_write_file_0_skip (void)
11927 str = getenv ("TEST_ONLY");
11929 return strstr (str, "write_file") == NULL;
11930 str = getenv ("SKIP_TEST_WRITE_FILE_0");
11931 if (str && strcmp (str, "1") == 0) return 1;
11932 str = getenv ("SKIP_TEST_WRITE_FILE");
11933 if (str && strcmp (str, "1") == 0) return 1;
11937 static int test_write_file_0 (void)
11939 if (test_write_file_0_skip ()) {
11940 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_0");
11944 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11946 char device[] = "/dev/sda";
11948 suppress_error = 0;
11949 r = guestfs_blockdev_setrw (g, device);
11955 suppress_error = 0;
11956 r = guestfs_umount_all (g);
11962 suppress_error = 0;
11963 r = guestfs_lvm_remove_all (g);
11968 char device[] = "/dev/sda";
11969 char lines_0[] = ",";
11975 suppress_error = 0;
11976 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11981 char fstype[] = "ext2";
11982 char device[] = "/dev/sda1";
11984 suppress_error = 0;
11985 r = guestfs_mkfs (g, fstype, device);
11990 char device[] = "/dev/sda1";
11991 char mountpoint[] = "/";
11993 suppress_error = 0;
11994 r = guestfs_mount (g, device, mountpoint);
11998 /* TestOutput for write_file (0) */
11999 char expected[] = "new file contents";
12001 char path[] = "/new";
12002 char content[] = "new file contents";
12004 suppress_error = 0;
12005 r = guestfs_write_file (g, path, content, 0);
12010 char path[] = "/new";
12012 suppress_error = 0;
12013 r = guestfs_cat (g, path);
12016 if (strcmp (r, expected) != 0) {
12017 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
12025 static int test_write_file_1_skip (void)
12029 str = getenv ("TEST_ONLY");
12031 return strstr (str, "write_file") == NULL;
12032 str = getenv ("SKIP_TEST_WRITE_FILE_1");
12033 if (str && strcmp (str, "1") == 0) return 1;
12034 str = getenv ("SKIP_TEST_WRITE_FILE");
12035 if (str && strcmp (str, "1") == 0) return 1;
12039 static int test_write_file_1 (void)
12041 if (test_write_file_1_skip ()) {
12042 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_1");
12046 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
12048 char device[] = "/dev/sda";
12050 suppress_error = 0;
12051 r = guestfs_blockdev_setrw (g, device);
12057 suppress_error = 0;
12058 r = guestfs_umount_all (g);
12064 suppress_error = 0;
12065 r = guestfs_lvm_remove_all (g);
12070 char device[] = "/dev/sda";
12071 char lines_0[] = ",";
12077 suppress_error = 0;
12078 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12083 char fstype[] = "ext2";
12084 char device[] = "/dev/sda1";
12086 suppress_error = 0;
12087 r = guestfs_mkfs (g, fstype, device);
12092 char device[] = "/dev/sda1";
12093 char mountpoint[] = "/";
12095 suppress_error = 0;
12096 r = guestfs_mount (g, device, mountpoint);
12100 /* TestOutput for write_file (1) */
12101 char expected[] = "\nnew file contents\n";
12103 char path[] = "/new";
12104 char content[] = "\nnew file contents\n";
12106 suppress_error = 0;
12107 r = guestfs_write_file (g, path, content, 0);
12112 char path[] = "/new";
12114 suppress_error = 0;
12115 r = guestfs_cat (g, path);
12118 if (strcmp (r, expected) != 0) {
12119 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
12127 static int test_write_file_2_skip (void)
12131 str = getenv ("TEST_ONLY");
12133 return strstr (str, "write_file") == NULL;
12134 str = getenv ("SKIP_TEST_WRITE_FILE_2");
12135 if (str && strcmp (str, "1") == 0) return 1;
12136 str = getenv ("SKIP_TEST_WRITE_FILE");
12137 if (str && strcmp (str, "1") == 0) return 1;
12141 static int test_write_file_2 (void)
12143 if (test_write_file_2_skip ()) {
12144 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_2");
12148 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
12150 char device[] = "/dev/sda";
12152 suppress_error = 0;
12153 r = guestfs_blockdev_setrw (g, device);
12159 suppress_error = 0;
12160 r = guestfs_umount_all (g);
12166 suppress_error = 0;
12167 r = guestfs_lvm_remove_all (g);
12172 char device[] = "/dev/sda";
12173 char lines_0[] = ",";
12179 suppress_error = 0;
12180 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12185 char fstype[] = "ext2";
12186 char device[] = "/dev/sda1";
12188 suppress_error = 0;
12189 r = guestfs_mkfs (g, fstype, device);
12194 char device[] = "/dev/sda1";
12195 char mountpoint[] = "/";
12197 suppress_error = 0;
12198 r = guestfs_mount (g, device, mountpoint);
12202 /* TestOutput for write_file (2) */
12203 char expected[] = "\n\n";
12205 char path[] = "/new";
12206 char content[] = "\n\n";
12208 suppress_error = 0;
12209 r = guestfs_write_file (g, path, content, 0);
12214 char path[] = "/new";
12216 suppress_error = 0;
12217 r = guestfs_cat (g, path);
12220 if (strcmp (r, expected) != 0) {
12221 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
12229 static int test_write_file_3_skip (void)
12233 str = getenv ("TEST_ONLY");
12235 return strstr (str, "write_file") == NULL;
12236 str = getenv ("SKIP_TEST_WRITE_FILE_3");
12237 if (str && strcmp (str, "1") == 0) return 1;
12238 str = getenv ("SKIP_TEST_WRITE_FILE");
12239 if (str && strcmp (str, "1") == 0) return 1;
12243 static int test_write_file_3 (void)
12245 if (test_write_file_3_skip ()) {
12246 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_3");
12250 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
12252 char device[] = "/dev/sda";
12254 suppress_error = 0;
12255 r = guestfs_blockdev_setrw (g, device);
12261 suppress_error = 0;
12262 r = guestfs_umount_all (g);
12268 suppress_error = 0;
12269 r = guestfs_lvm_remove_all (g);
12274 char device[] = "/dev/sda";
12275 char lines_0[] = ",";
12281 suppress_error = 0;
12282 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12287 char fstype[] = "ext2";
12288 char device[] = "/dev/sda1";
12290 suppress_error = 0;
12291 r = guestfs_mkfs (g, fstype, device);
12296 char device[] = "/dev/sda1";
12297 char mountpoint[] = "/";
12299 suppress_error = 0;
12300 r = guestfs_mount (g, device, mountpoint);
12304 /* TestOutput for write_file (3) */
12305 char expected[] = "";
12307 char path[] = "/new";
12308 char content[] = "";
12310 suppress_error = 0;
12311 r = guestfs_write_file (g, path, content, 0);
12316 char path[] = "/new";
12318 suppress_error = 0;
12319 r = guestfs_cat (g, path);
12322 if (strcmp (r, expected) != 0) {
12323 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
12331 static int test_write_file_4_skip (void)
12335 str = getenv ("TEST_ONLY");
12337 return strstr (str, "write_file") == NULL;
12338 str = getenv ("SKIP_TEST_WRITE_FILE_4");
12339 if (str && strcmp (str, "1") == 0) return 1;
12340 str = getenv ("SKIP_TEST_WRITE_FILE");
12341 if (str && strcmp (str, "1") == 0) return 1;
12345 static int test_write_file_4 (void)
12347 if (test_write_file_4_skip ()) {
12348 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_4");
12352 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
12354 char device[] = "/dev/sda";
12356 suppress_error = 0;
12357 r = guestfs_blockdev_setrw (g, device);
12363 suppress_error = 0;
12364 r = guestfs_umount_all (g);
12370 suppress_error = 0;
12371 r = guestfs_lvm_remove_all (g);
12376 char device[] = "/dev/sda";
12377 char lines_0[] = ",";
12383 suppress_error = 0;
12384 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12389 char fstype[] = "ext2";
12390 char device[] = "/dev/sda1";
12392 suppress_error = 0;
12393 r = guestfs_mkfs (g, fstype, device);
12398 char device[] = "/dev/sda1";
12399 char mountpoint[] = "/";
12401 suppress_error = 0;
12402 r = guestfs_mount (g, device, mountpoint);
12406 /* TestOutput for write_file (4) */
12407 char expected[] = "\n\n\n";
12409 char path[] = "/new";
12410 char content[] = "\n\n\n";
12412 suppress_error = 0;
12413 r = guestfs_write_file (g, path, content, 0);
12418 char path[] = "/new";
12420 suppress_error = 0;
12421 r = guestfs_cat (g, path);
12424 if (strcmp (r, expected) != 0) {
12425 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
12433 static int test_write_file_5_skip (void)
12437 str = getenv ("TEST_ONLY");
12439 return strstr (str, "write_file") == NULL;
12440 str = getenv ("SKIP_TEST_WRITE_FILE_5");
12441 if (str && strcmp (str, "1") == 0) return 1;
12442 str = getenv ("SKIP_TEST_WRITE_FILE");
12443 if (str && strcmp (str, "1") == 0) return 1;
12447 static int test_write_file_5 (void)
12449 if (test_write_file_5_skip ()) {
12450 printf ("%s skipped (reason: environment variable set)\n", "test_write_file_5");
12454 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
12456 char device[] = "/dev/sda";
12458 suppress_error = 0;
12459 r = guestfs_blockdev_setrw (g, device);
12465 suppress_error = 0;
12466 r = guestfs_umount_all (g);
12472 suppress_error = 0;
12473 r = guestfs_lvm_remove_all (g);
12478 char device[] = "/dev/sda";
12479 char lines_0[] = ",";
12485 suppress_error = 0;
12486 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12491 char fstype[] = "ext2";
12492 char device[] = "/dev/sda1";
12494 suppress_error = 0;
12495 r = guestfs_mkfs (g, fstype, device);
12500 char device[] = "/dev/sda1";
12501 char mountpoint[] = "/";
12503 suppress_error = 0;
12504 r = guestfs_mount (g, device, mountpoint);
12508 /* TestOutput for write_file (5) */
12509 char expected[] = "\n";
12511 char path[] = "/new";
12512 char content[] = "\n";
12514 suppress_error = 0;
12515 r = guestfs_write_file (g, path, content, 0);
12520 char path[] = "/new";
12522 suppress_error = 0;
12523 r = guestfs_cat (g, path);
12526 if (strcmp (r, expected) != 0) {
12527 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
12535 static int test_mkfs_0_skip (void)
12539 str = getenv ("TEST_ONLY");
12541 return strstr (str, "mkfs") == NULL;
12542 str = getenv ("SKIP_TEST_MKFS_0");
12543 if (str && strcmp (str, "1") == 0) return 1;
12544 str = getenv ("SKIP_TEST_MKFS");
12545 if (str && strcmp (str, "1") == 0) return 1;
12549 static int test_mkfs_0 (void)
12551 if (test_mkfs_0_skip ()) {
12552 printf ("%s skipped (reason: environment variable set)\n", "test_mkfs_0");
12556 /* InitNone|InitEmpty for test_mkfs_0 */
12558 char device[] = "/dev/sda";
12560 suppress_error = 0;
12561 r = guestfs_blockdev_setrw (g, device);
12567 suppress_error = 0;
12568 r = guestfs_umount_all (g);
12574 suppress_error = 0;
12575 r = guestfs_lvm_remove_all (g);
12579 /* TestOutput for mkfs (0) */
12580 char expected[] = "new file contents";
12582 char device[] = "/dev/sda";
12583 char lines_0[] = ",";
12589 suppress_error = 0;
12590 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12595 char fstype[] = "ext2";
12596 char device[] = "/dev/sda1";
12598 suppress_error = 0;
12599 r = guestfs_mkfs (g, fstype, device);
12604 char device[] = "/dev/sda1";
12605 char mountpoint[] = "/";
12607 suppress_error = 0;
12608 r = guestfs_mount (g, device, mountpoint);
12613 char path[] = "/new";
12614 char content[] = "new file contents";
12616 suppress_error = 0;
12617 r = guestfs_write_file (g, path, content, 0);
12622 char path[] = "/new";
12624 suppress_error = 0;
12625 r = guestfs_cat (g, path);
12628 if (strcmp (r, expected) != 0) {
12629 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
12637 static int test_lvcreate_0_skip (void)
12641 str = getenv ("TEST_ONLY");
12643 return strstr (str, "lvcreate") == NULL;
12644 str = getenv ("SKIP_TEST_LVCREATE_0");
12645 if (str && strcmp (str, "1") == 0) return 1;
12646 str = getenv ("SKIP_TEST_LVCREATE");
12647 if (str && strcmp (str, "1") == 0) return 1;
12651 static int test_lvcreate_0 (void)
12653 if (test_lvcreate_0_skip ()) {
12654 printf ("%s skipped (reason: environment variable set)\n", "test_lvcreate_0");
12658 /* InitNone|InitEmpty for test_lvcreate_0 */
12660 char device[] = "/dev/sda";
12662 suppress_error = 0;
12663 r = guestfs_blockdev_setrw (g, device);
12669 suppress_error = 0;
12670 r = guestfs_umount_all (g);
12676 suppress_error = 0;
12677 r = guestfs_lvm_remove_all (g);
12681 /* TestOutputList for lvcreate (0) */
12683 char device[] = "/dev/sda";
12684 char lines_0[] = ",10";
12685 char lines_1[] = ",20";
12686 char lines_2[] = ",";
12694 suppress_error = 0;
12695 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12700 char device[] = "/dev/sda1";
12702 suppress_error = 0;
12703 r = guestfs_pvcreate (g, device);
12708 char device[] = "/dev/sda2";
12710 suppress_error = 0;
12711 r = guestfs_pvcreate (g, device);
12716 char device[] = "/dev/sda3";
12718 suppress_error = 0;
12719 r = guestfs_pvcreate (g, device);
12724 char volgroup[] = "VG1";
12725 char physvols_0[] = "/dev/sda1";
12726 char physvols_1[] = "/dev/sda2";
12727 char *physvols[] = {
12733 suppress_error = 0;
12734 r = guestfs_vgcreate (g, volgroup, physvols);
12739 char volgroup[] = "VG2";
12740 char physvols_0[] = "/dev/sda3";
12741 char *physvols[] = {
12746 suppress_error = 0;
12747 r = guestfs_vgcreate (g, volgroup, physvols);
12752 char logvol[] = "LV1";
12753 char volgroup[] = "VG1";
12755 suppress_error = 0;
12756 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12761 char logvol[] = "LV2";
12762 char volgroup[] = "VG1";
12764 suppress_error = 0;
12765 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12770 char logvol[] = "LV3";
12771 char volgroup[] = "VG2";
12773 suppress_error = 0;
12774 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12779 char logvol[] = "LV4";
12780 char volgroup[] = "VG2";
12782 suppress_error = 0;
12783 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12788 char logvol[] = "LV5";
12789 char volgroup[] = "VG2";
12791 suppress_error = 0;
12792 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12799 suppress_error = 0;
12800 r = guestfs_lvs (g);
12804 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12809 char expected[] = "/dev/VG1/LV1";
12810 if (strcmp (r[0], expected) != 0) {
12811 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12816 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12821 char expected[] = "/dev/VG1/LV2";
12822 if (strcmp (r[1], expected) != 0) {
12823 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12828 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12833 char expected[] = "/dev/VG2/LV3";
12834 if (strcmp (r[2], expected) != 0) {
12835 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12840 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12845 char expected[] = "/dev/VG2/LV4";
12846 if (strcmp (r[3], expected) != 0) {
12847 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12852 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12857 char expected[] = "/dev/VG2/LV5";
12858 if (strcmp (r[4], expected) != 0) {
12859 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12863 if (r[5] != NULL) {
12864 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12868 for (i = 0; r[i] != NULL; ++i)
12875 static int test_vgcreate_0_skip (void)
12879 str = getenv ("TEST_ONLY");
12881 return strstr (str, "vgcreate") == NULL;
12882 str = getenv ("SKIP_TEST_VGCREATE_0");
12883 if (str && strcmp (str, "1") == 0) return 1;
12884 str = getenv ("SKIP_TEST_VGCREATE");
12885 if (str && strcmp (str, "1") == 0) return 1;
12889 static int test_vgcreate_0 (void)
12891 if (test_vgcreate_0_skip ()) {
12892 printf ("%s skipped (reason: environment variable set)\n", "test_vgcreate_0");
12896 /* InitNone|InitEmpty for test_vgcreate_0 */
12898 char device[] = "/dev/sda";
12900 suppress_error = 0;
12901 r = guestfs_blockdev_setrw (g, device);
12907 suppress_error = 0;
12908 r = guestfs_umount_all (g);
12914 suppress_error = 0;
12915 r = guestfs_lvm_remove_all (g);
12919 /* TestOutputList for vgcreate (0) */
12921 char device[] = "/dev/sda";
12922 char lines_0[] = ",10";
12923 char lines_1[] = ",20";
12924 char lines_2[] = ",";
12932 suppress_error = 0;
12933 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12938 char device[] = "/dev/sda1";
12940 suppress_error = 0;
12941 r = guestfs_pvcreate (g, device);
12946 char device[] = "/dev/sda2";
12948 suppress_error = 0;
12949 r = guestfs_pvcreate (g, device);
12954 char device[] = "/dev/sda3";
12956 suppress_error = 0;
12957 r = guestfs_pvcreate (g, device);
12962 char volgroup[] = "VG1";
12963 char physvols_0[] = "/dev/sda1";
12964 char physvols_1[] = "/dev/sda2";
12965 char *physvols[] = {
12971 suppress_error = 0;
12972 r = guestfs_vgcreate (g, volgroup, physvols);
12977 char volgroup[] = "VG2";
12978 char physvols_0[] = "/dev/sda3";
12979 char *physvols[] = {
12984 suppress_error = 0;
12985 r = guestfs_vgcreate (g, volgroup, physvols);
12992 suppress_error = 0;
12993 r = guestfs_vgs (g);
12997 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
13002 char expected[] = "VG1";
13003 if (strcmp (r[0], expected) != 0) {
13004 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13009 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
13014 char expected[] = "VG2";
13015 if (strcmp (r[1], expected) != 0) {
13016 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13020 if (r[2] != NULL) {
13021 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
13025 for (i = 0; r[i] != NULL; ++i)
13032 static int test_pvcreate_0_skip (void)
13036 str = getenv ("TEST_ONLY");
13038 return strstr (str, "pvcreate") == NULL;
13039 str = getenv ("SKIP_TEST_PVCREATE_0");
13040 if (str && strcmp (str, "1") == 0) return 1;
13041 str = getenv ("SKIP_TEST_PVCREATE");
13042 if (str && strcmp (str, "1") == 0) return 1;
13046 static int test_pvcreate_0 (void)
13048 if (test_pvcreate_0_skip ()) {
13049 printf ("%s skipped (reason: environment variable set)\n", "test_pvcreate_0");
13053 /* InitNone|InitEmpty for test_pvcreate_0 */
13055 char device[] = "/dev/sda";
13057 suppress_error = 0;
13058 r = guestfs_blockdev_setrw (g, device);
13064 suppress_error = 0;
13065 r = guestfs_umount_all (g);
13071 suppress_error = 0;
13072 r = guestfs_lvm_remove_all (g);
13076 /* TestOutputListOfDevices for pvcreate (0) */
13078 char device[] = "/dev/sda";
13079 char lines_0[] = ",10";
13080 char lines_1[] = ",20";
13081 char lines_2[] = ",";
13089 suppress_error = 0;
13090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13095 char device[] = "/dev/sda1";
13097 suppress_error = 0;
13098 r = guestfs_pvcreate (g, device);
13103 char device[] = "/dev/sda2";
13105 suppress_error = 0;
13106 r = guestfs_pvcreate (g, device);
13111 char device[] = "/dev/sda3";
13113 suppress_error = 0;
13114 r = guestfs_pvcreate (g, device);
13121 suppress_error = 0;
13122 r = guestfs_pvs (g);
13126 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
13131 char expected[] = "/dev/sda1";
13133 if (strcmp (r[0], expected) != 0) {
13134 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
13139 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
13144 char expected[] = "/dev/sda2";
13146 if (strcmp (r[1], expected) != 0) {
13147 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
13152 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
13157 char expected[] = "/dev/sda3";
13159 if (strcmp (r[2], expected) != 0) {
13160 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
13164 if (r[3] != NULL) {
13165 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
13169 for (i = 0; r[i] != NULL; ++i)
13176 static int test_is_dir_0_skip (void)
13180 str = getenv ("TEST_ONLY");
13182 return strstr (str, "is_dir") == NULL;
13183 str = getenv ("SKIP_TEST_IS_DIR_0");
13184 if (str && strcmp (str, "1") == 0) return 1;
13185 str = getenv ("SKIP_TEST_IS_DIR");
13186 if (str && strcmp (str, "1") == 0) return 1;
13190 static int test_is_dir_0 (void)
13192 if (test_is_dir_0_skip ()) {
13193 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_0");
13197 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
13199 char device[] = "/dev/sda";
13201 suppress_error = 0;
13202 r = guestfs_blockdev_setrw (g, device);
13208 suppress_error = 0;
13209 r = guestfs_umount_all (g);
13215 suppress_error = 0;
13216 r = guestfs_lvm_remove_all (g);
13221 char device[] = "/dev/sda";
13222 char lines_0[] = ",";
13228 suppress_error = 0;
13229 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13234 char fstype[] = "ext2";
13235 char device[] = "/dev/sda1";
13237 suppress_error = 0;
13238 r = guestfs_mkfs (g, fstype, device);
13243 char device[] = "/dev/sda1";
13244 char mountpoint[] = "/";
13246 suppress_error = 0;
13247 r = guestfs_mount (g, device, mountpoint);
13251 /* TestOutputFalse for is_dir (0) */
13253 char path[] = "/new";
13255 suppress_error = 0;
13256 r = guestfs_touch (g, path);
13261 char path[] = "/new";
13263 suppress_error = 0;
13264 r = guestfs_is_dir (g, path);
13268 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
13275 static int test_is_dir_1_skip (void)
13279 str = getenv ("TEST_ONLY");
13281 return strstr (str, "is_dir") == NULL;
13282 str = getenv ("SKIP_TEST_IS_DIR_1");
13283 if (str && strcmp (str, "1") == 0) return 1;
13284 str = getenv ("SKIP_TEST_IS_DIR");
13285 if (str && strcmp (str, "1") == 0) return 1;
13289 static int test_is_dir_1 (void)
13291 if (test_is_dir_1_skip ()) {
13292 printf ("%s skipped (reason: environment variable set)\n", "test_is_dir_1");
13296 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
13298 char device[] = "/dev/sda";
13300 suppress_error = 0;
13301 r = guestfs_blockdev_setrw (g, device);
13307 suppress_error = 0;
13308 r = guestfs_umount_all (g);
13314 suppress_error = 0;
13315 r = guestfs_lvm_remove_all (g);
13320 char device[] = "/dev/sda";
13321 char lines_0[] = ",";
13327 suppress_error = 0;
13328 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13333 char fstype[] = "ext2";
13334 char device[] = "/dev/sda1";
13336 suppress_error = 0;
13337 r = guestfs_mkfs (g, fstype, device);
13342 char device[] = "/dev/sda1";
13343 char mountpoint[] = "/";
13345 suppress_error = 0;
13346 r = guestfs_mount (g, device, mountpoint);
13350 /* TestOutputTrue for is_dir (1) */
13352 char path[] = "/new";
13354 suppress_error = 0;
13355 r = guestfs_mkdir (g, path);
13360 char path[] = "/new";
13362 suppress_error = 0;
13363 r = guestfs_is_dir (g, path);
13367 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
13374 static int test_is_file_0_skip (void)
13378 str = getenv ("TEST_ONLY");
13380 return strstr (str, "is_file") == NULL;
13381 str = getenv ("SKIP_TEST_IS_FILE_0");
13382 if (str && strcmp (str, "1") == 0) return 1;
13383 str = getenv ("SKIP_TEST_IS_FILE");
13384 if (str && strcmp (str, "1") == 0) return 1;
13388 static int test_is_file_0 (void)
13390 if (test_is_file_0_skip ()) {
13391 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_0");
13395 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
13397 char device[] = "/dev/sda";
13399 suppress_error = 0;
13400 r = guestfs_blockdev_setrw (g, device);
13406 suppress_error = 0;
13407 r = guestfs_umount_all (g);
13413 suppress_error = 0;
13414 r = guestfs_lvm_remove_all (g);
13419 char device[] = "/dev/sda";
13420 char lines_0[] = ",";
13426 suppress_error = 0;
13427 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13432 char fstype[] = "ext2";
13433 char device[] = "/dev/sda1";
13435 suppress_error = 0;
13436 r = guestfs_mkfs (g, fstype, device);
13441 char device[] = "/dev/sda1";
13442 char mountpoint[] = "/";
13444 suppress_error = 0;
13445 r = guestfs_mount (g, device, mountpoint);
13449 /* TestOutputTrue for is_file (0) */
13451 char path[] = "/new";
13453 suppress_error = 0;
13454 r = guestfs_touch (g, path);
13459 char path[] = "/new";
13461 suppress_error = 0;
13462 r = guestfs_is_file (g, path);
13466 fprintf (stderr, "test_is_file_0: expected true, got false\n");
13473 static int test_is_file_1_skip (void)
13477 str = getenv ("TEST_ONLY");
13479 return strstr (str, "is_file") == NULL;
13480 str = getenv ("SKIP_TEST_IS_FILE_1");
13481 if (str && strcmp (str, "1") == 0) return 1;
13482 str = getenv ("SKIP_TEST_IS_FILE");
13483 if (str && strcmp (str, "1") == 0) return 1;
13487 static int test_is_file_1 (void)
13489 if (test_is_file_1_skip ()) {
13490 printf ("%s skipped (reason: environment variable set)\n", "test_is_file_1");
13494 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
13496 char device[] = "/dev/sda";
13498 suppress_error = 0;
13499 r = guestfs_blockdev_setrw (g, device);
13505 suppress_error = 0;
13506 r = guestfs_umount_all (g);
13512 suppress_error = 0;
13513 r = guestfs_lvm_remove_all (g);
13518 char device[] = "/dev/sda";
13519 char lines_0[] = ",";
13525 suppress_error = 0;
13526 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13531 char fstype[] = "ext2";
13532 char device[] = "/dev/sda1";
13534 suppress_error = 0;
13535 r = guestfs_mkfs (g, fstype, device);
13540 char device[] = "/dev/sda1";
13541 char mountpoint[] = "/";
13543 suppress_error = 0;
13544 r = guestfs_mount (g, device, mountpoint);
13548 /* TestOutputFalse for is_file (1) */
13550 char path[] = "/new";
13552 suppress_error = 0;
13553 r = guestfs_mkdir (g, path);
13558 char path[] = "/new";
13560 suppress_error = 0;
13561 r = guestfs_is_file (g, path);
13565 fprintf (stderr, "test_is_file_1: expected false, got true\n");
13572 static int test_exists_0_skip (void)
13576 str = getenv ("TEST_ONLY");
13578 return strstr (str, "exists") == NULL;
13579 str = getenv ("SKIP_TEST_EXISTS_0");
13580 if (str && strcmp (str, "1") == 0) return 1;
13581 str = getenv ("SKIP_TEST_EXISTS");
13582 if (str && strcmp (str, "1") == 0) return 1;
13586 static int test_exists_0 (void)
13588 if (test_exists_0_skip ()) {
13589 printf ("%s skipped (reason: environment variable set)\n", "test_exists_0");
13593 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
13595 char device[] = "/dev/sda";
13597 suppress_error = 0;
13598 r = guestfs_blockdev_setrw (g, device);
13604 suppress_error = 0;
13605 r = guestfs_umount_all (g);
13611 suppress_error = 0;
13612 r = guestfs_lvm_remove_all (g);
13617 char device[] = "/dev/sda";
13618 char lines_0[] = ",";
13624 suppress_error = 0;
13625 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13630 char fstype[] = "ext2";
13631 char device[] = "/dev/sda1";
13633 suppress_error = 0;
13634 r = guestfs_mkfs (g, fstype, device);
13639 char device[] = "/dev/sda1";
13640 char mountpoint[] = "/";
13642 suppress_error = 0;
13643 r = guestfs_mount (g, device, mountpoint);
13647 /* TestOutputTrue for exists (0) */
13649 char path[] = "/new";
13651 suppress_error = 0;
13652 r = guestfs_touch (g, path);
13657 char path[] = "/new";
13659 suppress_error = 0;
13660 r = guestfs_exists (g, path);
13664 fprintf (stderr, "test_exists_0: expected true, got false\n");
13671 static int test_exists_1_skip (void)
13675 str = getenv ("TEST_ONLY");
13677 return strstr (str, "exists") == NULL;
13678 str = getenv ("SKIP_TEST_EXISTS_1");
13679 if (str && strcmp (str, "1") == 0) return 1;
13680 str = getenv ("SKIP_TEST_EXISTS");
13681 if (str && strcmp (str, "1") == 0) return 1;
13685 static int test_exists_1 (void)
13687 if (test_exists_1_skip ()) {
13688 printf ("%s skipped (reason: environment variable set)\n", "test_exists_1");
13692 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
13694 char device[] = "/dev/sda";
13696 suppress_error = 0;
13697 r = guestfs_blockdev_setrw (g, device);
13703 suppress_error = 0;
13704 r = guestfs_umount_all (g);
13710 suppress_error = 0;
13711 r = guestfs_lvm_remove_all (g);
13716 char device[] = "/dev/sda";
13717 char lines_0[] = ",";
13723 suppress_error = 0;
13724 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13729 char fstype[] = "ext2";
13730 char device[] = "/dev/sda1";
13732 suppress_error = 0;
13733 r = guestfs_mkfs (g, fstype, device);
13738 char device[] = "/dev/sda1";
13739 char mountpoint[] = "/";
13741 suppress_error = 0;
13742 r = guestfs_mount (g, device, mountpoint);
13746 /* TestOutputTrue for exists (1) */
13748 char path[] = "/new";
13750 suppress_error = 0;
13751 r = guestfs_mkdir (g, path);
13756 char path[] = "/new";
13758 suppress_error = 0;
13759 r = guestfs_exists (g, path);
13763 fprintf (stderr, "test_exists_1: expected true, got false\n");
13770 static int test_mkdir_p_0_skip (void)
13774 str = getenv ("TEST_ONLY");
13776 return strstr (str, "mkdir_p") == NULL;
13777 str = getenv ("SKIP_TEST_MKDIR_P_0");
13778 if (str && strcmp (str, "1") == 0) return 1;
13779 str = getenv ("SKIP_TEST_MKDIR_P");
13780 if (str && strcmp (str, "1") == 0) return 1;
13784 static int test_mkdir_p_0 (void)
13786 if (test_mkdir_p_0_skip ()) {
13787 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_0");
13791 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
13793 char device[] = "/dev/sda";
13795 suppress_error = 0;
13796 r = guestfs_blockdev_setrw (g, device);
13802 suppress_error = 0;
13803 r = guestfs_umount_all (g);
13809 suppress_error = 0;
13810 r = guestfs_lvm_remove_all (g);
13815 char device[] = "/dev/sda";
13816 char lines_0[] = ",";
13822 suppress_error = 0;
13823 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13828 char fstype[] = "ext2";
13829 char device[] = "/dev/sda1";
13831 suppress_error = 0;
13832 r = guestfs_mkfs (g, fstype, device);
13837 char device[] = "/dev/sda1";
13838 char mountpoint[] = "/";
13840 suppress_error = 0;
13841 r = guestfs_mount (g, device, mountpoint);
13845 /* TestOutputTrue for mkdir_p (0) */
13847 char path[] = "/new/foo/bar";
13849 suppress_error = 0;
13850 r = guestfs_mkdir_p (g, path);
13855 char path[] = "/new/foo/bar";
13857 suppress_error = 0;
13858 r = guestfs_is_dir (g, path);
13862 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
13869 static int test_mkdir_p_1_skip (void)
13873 str = getenv ("TEST_ONLY");
13875 return strstr (str, "mkdir_p") == NULL;
13876 str = getenv ("SKIP_TEST_MKDIR_P_1");
13877 if (str && strcmp (str, "1") == 0) return 1;
13878 str = getenv ("SKIP_TEST_MKDIR_P");
13879 if (str && strcmp (str, "1") == 0) return 1;
13883 static int test_mkdir_p_1 (void)
13885 if (test_mkdir_p_1_skip ()) {
13886 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_1");
13890 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
13892 char device[] = "/dev/sda";
13894 suppress_error = 0;
13895 r = guestfs_blockdev_setrw (g, device);
13901 suppress_error = 0;
13902 r = guestfs_umount_all (g);
13908 suppress_error = 0;
13909 r = guestfs_lvm_remove_all (g);
13914 char device[] = "/dev/sda";
13915 char lines_0[] = ",";
13921 suppress_error = 0;
13922 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13927 char fstype[] = "ext2";
13928 char device[] = "/dev/sda1";
13930 suppress_error = 0;
13931 r = guestfs_mkfs (g, fstype, device);
13936 char device[] = "/dev/sda1";
13937 char mountpoint[] = "/";
13939 suppress_error = 0;
13940 r = guestfs_mount (g, device, mountpoint);
13944 /* TestOutputTrue for mkdir_p (1) */
13946 char path[] = "/new/foo/bar";
13948 suppress_error = 0;
13949 r = guestfs_mkdir_p (g, path);
13954 char path[] = "/new/foo";
13956 suppress_error = 0;
13957 r = guestfs_is_dir (g, path);
13961 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13968 static int test_mkdir_p_2_skip (void)
13972 str = getenv ("TEST_ONLY");
13974 return strstr (str, "mkdir_p") == NULL;
13975 str = getenv ("SKIP_TEST_MKDIR_P_2");
13976 if (str && strcmp (str, "1") == 0) return 1;
13977 str = getenv ("SKIP_TEST_MKDIR_P");
13978 if (str && strcmp (str, "1") == 0) return 1;
13982 static int test_mkdir_p_2 (void)
13984 if (test_mkdir_p_2_skip ()) {
13985 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_2");
13989 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13991 char device[] = "/dev/sda";
13993 suppress_error = 0;
13994 r = guestfs_blockdev_setrw (g, device);
14000 suppress_error = 0;
14001 r = guestfs_umount_all (g);
14007 suppress_error = 0;
14008 r = guestfs_lvm_remove_all (g);
14013 char device[] = "/dev/sda";
14014 char lines_0[] = ",";
14020 suppress_error = 0;
14021 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14026 char fstype[] = "ext2";
14027 char device[] = "/dev/sda1";
14029 suppress_error = 0;
14030 r = guestfs_mkfs (g, fstype, device);
14035 char device[] = "/dev/sda1";
14036 char mountpoint[] = "/";
14038 suppress_error = 0;
14039 r = guestfs_mount (g, device, mountpoint);
14043 /* TestOutputTrue for mkdir_p (2) */
14045 char path[] = "/new/foo/bar";
14047 suppress_error = 0;
14048 r = guestfs_mkdir_p (g, path);
14053 char path[] = "/new";
14055 suppress_error = 0;
14056 r = guestfs_is_dir (g, path);
14060 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
14067 static int test_mkdir_p_3_skip (void)
14071 str = getenv ("TEST_ONLY");
14073 return strstr (str, "mkdir_p") == NULL;
14074 str = getenv ("SKIP_TEST_MKDIR_P_3");
14075 if (str && strcmp (str, "1") == 0) return 1;
14076 str = getenv ("SKIP_TEST_MKDIR_P");
14077 if (str && strcmp (str, "1") == 0) return 1;
14081 static int test_mkdir_p_3 (void)
14083 if (test_mkdir_p_3_skip ()) {
14084 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_3");
14088 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
14090 char device[] = "/dev/sda";
14092 suppress_error = 0;
14093 r = guestfs_blockdev_setrw (g, device);
14099 suppress_error = 0;
14100 r = guestfs_umount_all (g);
14106 suppress_error = 0;
14107 r = guestfs_lvm_remove_all (g);
14112 char device[] = "/dev/sda";
14113 char lines_0[] = ",";
14119 suppress_error = 0;
14120 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14125 char fstype[] = "ext2";
14126 char device[] = "/dev/sda1";
14128 suppress_error = 0;
14129 r = guestfs_mkfs (g, fstype, device);
14134 char device[] = "/dev/sda1";
14135 char mountpoint[] = "/";
14137 suppress_error = 0;
14138 r = guestfs_mount (g, device, mountpoint);
14142 /* TestRun for mkdir_p (3) */
14144 char path[] = "/new";
14146 suppress_error = 0;
14147 r = guestfs_mkdir (g, path);
14152 char path[] = "/new";
14154 suppress_error = 0;
14155 r = guestfs_mkdir_p (g, path);
14162 static int test_mkdir_p_4_skip (void)
14166 str = getenv ("TEST_ONLY");
14168 return strstr (str, "mkdir_p") == NULL;
14169 str = getenv ("SKIP_TEST_MKDIR_P_4");
14170 if (str && strcmp (str, "1") == 0) return 1;
14171 str = getenv ("SKIP_TEST_MKDIR_P");
14172 if (str && strcmp (str, "1") == 0) return 1;
14176 static int test_mkdir_p_4 (void)
14178 if (test_mkdir_p_4_skip ()) {
14179 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_p_4");
14183 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
14185 char device[] = "/dev/sda";
14187 suppress_error = 0;
14188 r = guestfs_blockdev_setrw (g, device);
14194 suppress_error = 0;
14195 r = guestfs_umount_all (g);
14201 suppress_error = 0;
14202 r = guestfs_lvm_remove_all (g);
14207 char device[] = "/dev/sda";
14208 char lines_0[] = ",";
14214 suppress_error = 0;
14215 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14220 char fstype[] = "ext2";
14221 char device[] = "/dev/sda1";
14223 suppress_error = 0;
14224 r = guestfs_mkfs (g, fstype, device);
14229 char device[] = "/dev/sda1";
14230 char mountpoint[] = "/";
14232 suppress_error = 0;
14233 r = guestfs_mount (g, device, mountpoint);
14237 /* TestLastFail for mkdir_p (4) */
14239 char path[] = "/new";
14241 suppress_error = 0;
14242 r = guestfs_touch (g, path);
14247 char path[] = "/new";
14249 suppress_error = 1;
14250 r = guestfs_mkdir_p (g, path);
14257 static int test_mkdir_0_skip (void)
14261 str = getenv ("TEST_ONLY");
14263 return strstr (str, "mkdir") == NULL;
14264 str = getenv ("SKIP_TEST_MKDIR_0");
14265 if (str && strcmp (str, "1") == 0) return 1;
14266 str = getenv ("SKIP_TEST_MKDIR");
14267 if (str && strcmp (str, "1") == 0) return 1;
14271 static int test_mkdir_0 (void)
14273 if (test_mkdir_0_skip ()) {
14274 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_0");
14278 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
14280 char device[] = "/dev/sda";
14282 suppress_error = 0;
14283 r = guestfs_blockdev_setrw (g, device);
14289 suppress_error = 0;
14290 r = guestfs_umount_all (g);
14296 suppress_error = 0;
14297 r = guestfs_lvm_remove_all (g);
14302 char device[] = "/dev/sda";
14303 char lines_0[] = ",";
14309 suppress_error = 0;
14310 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14315 char fstype[] = "ext2";
14316 char device[] = "/dev/sda1";
14318 suppress_error = 0;
14319 r = guestfs_mkfs (g, fstype, device);
14324 char device[] = "/dev/sda1";
14325 char mountpoint[] = "/";
14327 suppress_error = 0;
14328 r = guestfs_mount (g, device, mountpoint);
14332 /* TestOutputTrue for mkdir (0) */
14334 char path[] = "/new";
14336 suppress_error = 0;
14337 r = guestfs_mkdir (g, path);
14342 char path[] = "/new";
14344 suppress_error = 0;
14345 r = guestfs_is_dir (g, path);
14349 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
14356 static int test_mkdir_1_skip (void)
14360 str = getenv ("TEST_ONLY");
14362 return strstr (str, "mkdir") == NULL;
14363 str = getenv ("SKIP_TEST_MKDIR_1");
14364 if (str && strcmp (str, "1") == 0) return 1;
14365 str = getenv ("SKIP_TEST_MKDIR");
14366 if (str && strcmp (str, "1") == 0) return 1;
14370 static int test_mkdir_1 (void)
14372 if (test_mkdir_1_skip ()) {
14373 printf ("%s skipped (reason: environment variable set)\n", "test_mkdir_1");
14377 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
14379 char device[] = "/dev/sda";
14381 suppress_error = 0;
14382 r = guestfs_blockdev_setrw (g, device);
14388 suppress_error = 0;
14389 r = guestfs_umount_all (g);
14395 suppress_error = 0;
14396 r = guestfs_lvm_remove_all (g);
14401 char device[] = "/dev/sda";
14402 char lines_0[] = ",";
14408 suppress_error = 0;
14409 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14414 char fstype[] = "ext2";
14415 char device[] = "/dev/sda1";
14417 suppress_error = 0;
14418 r = guestfs_mkfs (g, fstype, device);
14423 char device[] = "/dev/sda1";
14424 char mountpoint[] = "/";
14426 suppress_error = 0;
14427 r = guestfs_mount (g, device, mountpoint);
14431 /* TestLastFail for mkdir (1) */
14433 char path[] = "/new/foo/bar";
14435 suppress_error = 1;
14436 r = guestfs_mkdir (g, path);
14443 static int test_rm_rf_0_skip (void)
14447 str = getenv ("TEST_ONLY");
14449 return strstr (str, "rm_rf") == NULL;
14450 str = getenv ("SKIP_TEST_RM_RF_0");
14451 if (str && strcmp (str, "1") == 0) return 1;
14452 str = getenv ("SKIP_TEST_RM_RF");
14453 if (str && strcmp (str, "1") == 0) return 1;
14457 static int test_rm_rf_0 (void)
14459 if (test_rm_rf_0_skip ()) {
14460 printf ("%s skipped (reason: environment variable set)\n", "test_rm_rf_0");
14464 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
14466 char device[] = "/dev/sda";
14468 suppress_error = 0;
14469 r = guestfs_blockdev_setrw (g, device);
14475 suppress_error = 0;
14476 r = guestfs_umount_all (g);
14482 suppress_error = 0;
14483 r = guestfs_lvm_remove_all (g);
14488 char device[] = "/dev/sda";
14489 char lines_0[] = ",";
14495 suppress_error = 0;
14496 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14501 char fstype[] = "ext2";
14502 char device[] = "/dev/sda1";
14504 suppress_error = 0;
14505 r = guestfs_mkfs (g, fstype, device);
14510 char device[] = "/dev/sda1";
14511 char mountpoint[] = "/";
14513 suppress_error = 0;
14514 r = guestfs_mount (g, device, mountpoint);
14518 /* TestOutputFalse for rm_rf (0) */
14520 char path[] = "/new";
14522 suppress_error = 0;
14523 r = guestfs_mkdir (g, path);
14528 char path[] = "/new/foo";
14530 suppress_error = 0;
14531 r = guestfs_mkdir (g, path);
14536 char path[] = "/new/foo/bar";
14538 suppress_error = 0;
14539 r = guestfs_touch (g, path);
14544 char path[] = "/new";
14546 suppress_error = 0;
14547 r = guestfs_rm_rf (g, path);
14552 char path[] = "/new";
14554 suppress_error = 0;
14555 r = guestfs_exists (g, path);
14559 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
14566 static int test_rmdir_0_skip (void)
14570 str = getenv ("TEST_ONLY");
14572 return strstr (str, "rmdir") == NULL;
14573 str = getenv ("SKIP_TEST_RMDIR_0");
14574 if (str && strcmp (str, "1") == 0) return 1;
14575 str = getenv ("SKIP_TEST_RMDIR");
14576 if (str && strcmp (str, "1") == 0) return 1;
14580 static int test_rmdir_0 (void)
14582 if (test_rmdir_0_skip ()) {
14583 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_0");
14587 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
14589 char device[] = "/dev/sda";
14591 suppress_error = 0;
14592 r = guestfs_blockdev_setrw (g, device);
14598 suppress_error = 0;
14599 r = guestfs_umount_all (g);
14605 suppress_error = 0;
14606 r = guestfs_lvm_remove_all (g);
14611 char device[] = "/dev/sda";
14612 char lines_0[] = ",";
14618 suppress_error = 0;
14619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14624 char fstype[] = "ext2";
14625 char device[] = "/dev/sda1";
14627 suppress_error = 0;
14628 r = guestfs_mkfs (g, fstype, device);
14633 char device[] = "/dev/sda1";
14634 char mountpoint[] = "/";
14636 suppress_error = 0;
14637 r = guestfs_mount (g, device, mountpoint);
14641 /* TestRun for rmdir (0) */
14643 char path[] = "/new";
14645 suppress_error = 0;
14646 r = guestfs_mkdir (g, path);
14651 char path[] = "/new";
14653 suppress_error = 0;
14654 r = guestfs_rmdir (g, path);
14661 static int test_rmdir_1_skip (void)
14665 str = getenv ("TEST_ONLY");
14667 return strstr (str, "rmdir") == NULL;
14668 str = getenv ("SKIP_TEST_RMDIR_1");
14669 if (str && strcmp (str, "1") == 0) return 1;
14670 str = getenv ("SKIP_TEST_RMDIR");
14671 if (str && strcmp (str, "1") == 0) return 1;
14675 static int test_rmdir_1 (void)
14677 if (test_rmdir_1_skip ()) {
14678 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_1");
14682 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
14684 char device[] = "/dev/sda";
14686 suppress_error = 0;
14687 r = guestfs_blockdev_setrw (g, device);
14693 suppress_error = 0;
14694 r = guestfs_umount_all (g);
14700 suppress_error = 0;
14701 r = guestfs_lvm_remove_all (g);
14706 char device[] = "/dev/sda";
14707 char lines_0[] = ",";
14713 suppress_error = 0;
14714 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14719 char fstype[] = "ext2";
14720 char device[] = "/dev/sda1";
14722 suppress_error = 0;
14723 r = guestfs_mkfs (g, fstype, device);
14728 char device[] = "/dev/sda1";
14729 char mountpoint[] = "/";
14731 suppress_error = 0;
14732 r = guestfs_mount (g, device, mountpoint);
14736 /* TestLastFail for rmdir (1) */
14738 char path[] = "/new";
14740 suppress_error = 1;
14741 r = guestfs_rmdir (g, path);
14748 static int test_rmdir_2_skip (void)
14752 str = getenv ("TEST_ONLY");
14754 return strstr (str, "rmdir") == NULL;
14755 str = getenv ("SKIP_TEST_RMDIR_2");
14756 if (str && strcmp (str, "1") == 0) return 1;
14757 str = getenv ("SKIP_TEST_RMDIR");
14758 if (str && strcmp (str, "1") == 0) return 1;
14762 static int test_rmdir_2 (void)
14764 if (test_rmdir_2_skip ()) {
14765 printf ("%s skipped (reason: environment variable set)\n", "test_rmdir_2");
14769 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
14771 char device[] = "/dev/sda";
14773 suppress_error = 0;
14774 r = guestfs_blockdev_setrw (g, device);
14780 suppress_error = 0;
14781 r = guestfs_umount_all (g);
14787 suppress_error = 0;
14788 r = guestfs_lvm_remove_all (g);
14793 char device[] = "/dev/sda";
14794 char lines_0[] = ",";
14800 suppress_error = 0;
14801 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14806 char fstype[] = "ext2";
14807 char device[] = "/dev/sda1";
14809 suppress_error = 0;
14810 r = guestfs_mkfs (g, fstype, device);
14815 char device[] = "/dev/sda1";
14816 char mountpoint[] = "/";
14818 suppress_error = 0;
14819 r = guestfs_mount (g, device, mountpoint);
14823 /* TestLastFail for rmdir (2) */
14825 char path[] = "/new";
14827 suppress_error = 0;
14828 r = guestfs_touch (g, path);
14833 char path[] = "/new";
14835 suppress_error = 1;
14836 r = guestfs_rmdir (g, path);
14843 static int test_rm_0_skip (void)
14847 str = getenv ("TEST_ONLY");
14849 return strstr (str, "rm") == NULL;
14850 str = getenv ("SKIP_TEST_RM_0");
14851 if (str && strcmp (str, "1") == 0) return 1;
14852 str = getenv ("SKIP_TEST_RM");
14853 if (str && strcmp (str, "1") == 0) return 1;
14857 static int test_rm_0 (void)
14859 if (test_rm_0_skip ()) {
14860 printf ("%s skipped (reason: environment variable set)\n", "test_rm_0");
14864 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
14866 char device[] = "/dev/sda";
14868 suppress_error = 0;
14869 r = guestfs_blockdev_setrw (g, device);
14875 suppress_error = 0;
14876 r = guestfs_umount_all (g);
14882 suppress_error = 0;
14883 r = guestfs_lvm_remove_all (g);
14888 char device[] = "/dev/sda";
14889 char lines_0[] = ",";
14895 suppress_error = 0;
14896 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14901 char fstype[] = "ext2";
14902 char device[] = "/dev/sda1";
14904 suppress_error = 0;
14905 r = guestfs_mkfs (g, fstype, device);
14910 char device[] = "/dev/sda1";
14911 char mountpoint[] = "/";
14913 suppress_error = 0;
14914 r = guestfs_mount (g, device, mountpoint);
14918 /* TestRun for rm (0) */
14920 char path[] = "/new";
14922 suppress_error = 0;
14923 r = guestfs_touch (g, path);
14928 char path[] = "/new";
14930 suppress_error = 0;
14931 r = guestfs_rm (g, path);
14938 static int test_rm_1_skip (void)
14942 str = getenv ("TEST_ONLY");
14944 return strstr (str, "rm") == NULL;
14945 str = getenv ("SKIP_TEST_RM_1");
14946 if (str && strcmp (str, "1") == 0) return 1;
14947 str = getenv ("SKIP_TEST_RM");
14948 if (str && strcmp (str, "1") == 0) return 1;
14952 static int test_rm_1 (void)
14954 if (test_rm_1_skip ()) {
14955 printf ("%s skipped (reason: environment variable set)\n", "test_rm_1");
14959 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14961 char device[] = "/dev/sda";
14963 suppress_error = 0;
14964 r = guestfs_blockdev_setrw (g, device);
14970 suppress_error = 0;
14971 r = guestfs_umount_all (g);
14977 suppress_error = 0;
14978 r = guestfs_lvm_remove_all (g);
14983 char device[] = "/dev/sda";
14984 char lines_0[] = ",";
14990 suppress_error = 0;
14991 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14996 char fstype[] = "ext2";
14997 char device[] = "/dev/sda1";
14999 suppress_error = 0;
15000 r = guestfs_mkfs (g, fstype, device);
15005 char device[] = "/dev/sda1";
15006 char mountpoint[] = "/";
15008 suppress_error = 0;
15009 r = guestfs_mount (g, device, mountpoint);
15013 /* TestLastFail for rm (1) */
15015 char path[] = "/new";
15017 suppress_error = 1;
15018 r = guestfs_rm (g, path);
15025 static int test_rm_2_skip (void)
15029 str = getenv ("TEST_ONLY");
15031 return strstr (str, "rm") == NULL;
15032 str = getenv ("SKIP_TEST_RM_2");
15033 if (str && strcmp (str, "1") == 0) return 1;
15034 str = getenv ("SKIP_TEST_RM");
15035 if (str && strcmp (str, "1") == 0) return 1;
15039 static int test_rm_2 (void)
15041 if (test_rm_2_skip ()) {
15042 printf ("%s skipped (reason: environment variable set)\n", "test_rm_2");
15046 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
15048 char device[] = "/dev/sda";
15050 suppress_error = 0;
15051 r = guestfs_blockdev_setrw (g, device);
15057 suppress_error = 0;
15058 r = guestfs_umount_all (g);
15064 suppress_error = 0;
15065 r = guestfs_lvm_remove_all (g);
15070 char device[] = "/dev/sda";
15071 char lines_0[] = ",";
15077 suppress_error = 0;
15078 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15083 char fstype[] = "ext2";
15084 char device[] = "/dev/sda1";
15086 suppress_error = 0;
15087 r = guestfs_mkfs (g, fstype, device);
15092 char device[] = "/dev/sda1";
15093 char mountpoint[] = "/";
15095 suppress_error = 0;
15096 r = guestfs_mount (g, device, mountpoint);
15100 /* TestLastFail for rm (2) */
15102 char path[] = "/new";
15104 suppress_error = 0;
15105 r = guestfs_mkdir (g, path);
15110 char path[] = "/new";
15112 suppress_error = 1;
15113 r = guestfs_rm (g, path);
15120 static int test_read_lines_0_skip (void)
15124 str = getenv ("TEST_ONLY");
15126 return strstr (str, "read_lines") == NULL;
15127 str = getenv ("SKIP_TEST_READ_LINES_0");
15128 if (str && strcmp (str, "1") == 0) return 1;
15129 str = getenv ("SKIP_TEST_READ_LINES");
15130 if (str && strcmp (str, "1") == 0) return 1;
15134 static int test_read_lines_0 (void)
15136 if (test_read_lines_0_skip ()) {
15137 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_0");
15141 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
15143 char device[] = "/dev/sda";
15145 suppress_error = 0;
15146 r = guestfs_blockdev_setrw (g, device);
15152 suppress_error = 0;
15153 r = guestfs_umount_all (g);
15159 suppress_error = 0;
15160 r = guestfs_lvm_remove_all (g);
15165 char device[] = "/dev/sda";
15166 char lines_0[] = ",";
15172 suppress_error = 0;
15173 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15178 char fstype[] = "ext2";
15179 char device[] = "/dev/sda1";
15181 suppress_error = 0;
15182 r = guestfs_mkfs (g, fstype, device);
15187 char device[] = "/dev/sda1";
15188 char mountpoint[] = "/";
15190 suppress_error = 0;
15191 r = guestfs_mount (g, device, mountpoint);
15195 /* TestOutputList for read_lines (0) */
15197 char path[] = "/new";
15198 char content[] = "line1\r\nline2\nline3";
15200 suppress_error = 0;
15201 r = guestfs_write_file (g, path, content, 0);
15206 char path[] = "/new";
15209 suppress_error = 0;
15210 r = guestfs_read_lines (g, path);
15214 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
15219 char expected[] = "line1";
15220 if (strcmp (r[0], expected) != 0) {
15221 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15226 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
15231 char expected[] = "line2";
15232 if (strcmp (r[1], expected) != 0) {
15233 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15238 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
15243 char expected[] = "line3";
15244 if (strcmp (r[2], expected) != 0) {
15245 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15249 if (r[3] != NULL) {
15250 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
15254 for (i = 0; r[i] != NULL; ++i)
15261 static int test_read_lines_1_skip (void)
15265 str = getenv ("TEST_ONLY");
15267 return strstr (str, "read_lines") == NULL;
15268 str = getenv ("SKIP_TEST_READ_LINES_1");
15269 if (str && strcmp (str, "1") == 0) return 1;
15270 str = getenv ("SKIP_TEST_READ_LINES");
15271 if (str && strcmp (str, "1") == 0) return 1;
15275 static int test_read_lines_1 (void)
15277 if (test_read_lines_1_skip ()) {
15278 printf ("%s skipped (reason: environment variable set)\n", "test_read_lines_1");
15282 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
15284 char device[] = "/dev/sda";
15286 suppress_error = 0;
15287 r = guestfs_blockdev_setrw (g, device);
15293 suppress_error = 0;
15294 r = guestfs_umount_all (g);
15300 suppress_error = 0;
15301 r = guestfs_lvm_remove_all (g);
15306 char device[] = "/dev/sda";
15307 char lines_0[] = ",";
15313 suppress_error = 0;
15314 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15319 char fstype[] = "ext2";
15320 char device[] = "/dev/sda1";
15322 suppress_error = 0;
15323 r = guestfs_mkfs (g, fstype, device);
15328 char device[] = "/dev/sda1";
15329 char mountpoint[] = "/";
15331 suppress_error = 0;
15332 r = guestfs_mount (g, device, mountpoint);
15336 /* TestOutputList for read_lines (1) */
15338 char path[] = "/new";
15339 char content[] = "";
15341 suppress_error = 0;
15342 r = guestfs_write_file (g, path, content, 0);
15347 char path[] = "/new";
15350 suppress_error = 0;
15351 r = guestfs_read_lines (g, path);
15354 if (r[0] != NULL) {
15355 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
15359 for (i = 0; r[i] != NULL; ++i)
15366 static int test_lvs_0_skip (void)
15370 str = getenv ("TEST_ONLY");
15372 return strstr (str, "lvs") == NULL;
15373 str = getenv ("SKIP_TEST_LVS_0");
15374 if (str && strcmp (str, "1") == 0) return 1;
15375 str = getenv ("SKIP_TEST_LVS");
15376 if (str && strcmp (str, "1") == 0) return 1;
15380 static int test_lvs_0 (void)
15382 if (test_lvs_0_skip ()) {
15383 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_0");
15387 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
15389 char device[] = "/dev/sda";
15391 suppress_error = 0;
15392 r = guestfs_blockdev_setrw (g, device);
15398 suppress_error = 0;
15399 r = guestfs_umount_all (g);
15405 suppress_error = 0;
15406 r = guestfs_lvm_remove_all (g);
15411 char device[] = "/dev/sda";
15412 char lines_0[] = ",";
15418 suppress_error = 0;
15419 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15424 char device[] = "/dev/sda1";
15426 suppress_error = 0;
15427 r = guestfs_pvcreate (g, device);
15432 char volgroup[] = "VG";
15433 char physvols_0[] = "/dev/sda1";
15434 char *physvols[] = {
15439 suppress_error = 0;
15440 r = guestfs_vgcreate (g, volgroup, physvols);
15445 char logvol[] = "LV";
15446 char volgroup[] = "VG";
15448 suppress_error = 0;
15449 r = guestfs_lvcreate (g, logvol, volgroup, 8);
15454 char fstype[] = "ext2";
15455 char device[] = "/dev/VG/LV";
15457 suppress_error = 0;
15458 r = guestfs_mkfs (g, fstype, device);
15463 char device[] = "/dev/VG/LV";
15464 char mountpoint[] = "/";
15466 suppress_error = 0;
15467 r = guestfs_mount (g, device, mountpoint);
15471 /* TestOutputList for lvs (0) */
15475 suppress_error = 0;
15476 r = guestfs_lvs (g);
15480 fprintf (stderr, "test_lvs_0: short list returned from command\n");
15485 char expected[] = "/dev/VG/LV";
15486 if (strcmp (r[0], expected) != 0) {
15487 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15491 if (r[1] != NULL) {
15492 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
15496 for (i = 0; r[i] != NULL; ++i)
15503 static int test_lvs_1_skip (void)
15507 str = getenv ("TEST_ONLY");
15509 return strstr (str, "lvs") == NULL;
15510 str = getenv ("SKIP_TEST_LVS_1");
15511 if (str && strcmp (str, "1") == 0) return 1;
15512 str = getenv ("SKIP_TEST_LVS");
15513 if (str && strcmp (str, "1") == 0) return 1;
15517 static int test_lvs_1 (void)
15519 if (test_lvs_1_skip ()) {
15520 printf ("%s skipped (reason: environment variable set)\n", "test_lvs_1");
15524 /* InitNone|InitEmpty for test_lvs_1 */
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);
15547 /* TestOutputList for lvs (1) */
15549 char device[] = "/dev/sda";
15550 char lines_0[] = ",10";
15551 char lines_1[] = ",20";
15552 char lines_2[] = ",";
15560 suppress_error = 0;
15561 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15566 char device[] = "/dev/sda1";
15568 suppress_error = 0;
15569 r = guestfs_pvcreate (g, device);
15574 char device[] = "/dev/sda2";
15576 suppress_error = 0;
15577 r = guestfs_pvcreate (g, device);
15582 char device[] = "/dev/sda3";
15584 suppress_error = 0;
15585 r = guestfs_pvcreate (g, device);
15590 char volgroup[] = "VG1";
15591 char physvols_0[] = "/dev/sda1";
15592 char physvols_1[] = "/dev/sda2";
15593 char *physvols[] = {
15599 suppress_error = 0;
15600 r = guestfs_vgcreate (g, volgroup, physvols);
15605 char volgroup[] = "VG2";
15606 char physvols_0[] = "/dev/sda3";
15607 char *physvols[] = {
15612 suppress_error = 0;
15613 r = guestfs_vgcreate (g, volgroup, physvols);
15618 char logvol[] = "LV1";
15619 char volgroup[] = "VG1";
15621 suppress_error = 0;
15622 r = guestfs_lvcreate (g, logvol, volgroup, 50);
15627 char logvol[] = "LV2";
15628 char volgroup[] = "VG1";
15630 suppress_error = 0;
15631 r = guestfs_lvcreate (g, logvol, volgroup, 50);
15636 char logvol[] = "LV3";
15637 char volgroup[] = "VG2";
15639 suppress_error = 0;
15640 r = guestfs_lvcreate (g, logvol, volgroup, 50);
15647 suppress_error = 0;
15648 r = guestfs_lvs (g);
15652 fprintf (stderr, "test_lvs_1: short list returned from command\n");
15657 char expected[] = "/dev/VG1/LV1";
15658 if (strcmp (r[0], expected) != 0) {
15659 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15664 fprintf (stderr, "test_lvs_1: short list returned from command\n");
15669 char expected[] = "/dev/VG1/LV2";
15670 if (strcmp (r[1], expected) != 0) {
15671 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15676 fprintf (stderr, "test_lvs_1: short list returned from command\n");
15681 char expected[] = "/dev/VG2/LV3";
15682 if (strcmp (r[2], expected) != 0) {
15683 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15687 if (r[3] != NULL) {
15688 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
15692 for (i = 0; r[i] != NULL; ++i)
15699 static int test_vgs_0_skip (void)
15703 str = getenv ("TEST_ONLY");
15705 return strstr (str, "vgs") == NULL;
15706 str = getenv ("SKIP_TEST_VGS_0");
15707 if (str && strcmp (str, "1") == 0) return 1;
15708 str = getenv ("SKIP_TEST_VGS");
15709 if (str && strcmp (str, "1") == 0) return 1;
15713 static int test_vgs_0 (void)
15715 if (test_vgs_0_skip ()) {
15716 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_0");
15720 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
15722 char device[] = "/dev/sda";
15724 suppress_error = 0;
15725 r = guestfs_blockdev_setrw (g, device);
15731 suppress_error = 0;
15732 r = guestfs_umount_all (g);
15738 suppress_error = 0;
15739 r = guestfs_lvm_remove_all (g);
15744 char device[] = "/dev/sda";
15745 char lines_0[] = ",";
15751 suppress_error = 0;
15752 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15757 char device[] = "/dev/sda1";
15759 suppress_error = 0;
15760 r = guestfs_pvcreate (g, device);
15765 char volgroup[] = "VG";
15766 char physvols_0[] = "/dev/sda1";
15767 char *physvols[] = {
15772 suppress_error = 0;
15773 r = guestfs_vgcreate (g, volgroup, physvols);
15778 char logvol[] = "LV";
15779 char volgroup[] = "VG";
15781 suppress_error = 0;
15782 r = guestfs_lvcreate (g, logvol, volgroup, 8);
15787 char fstype[] = "ext2";
15788 char device[] = "/dev/VG/LV";
15790 suppress_error = 0;
15791 r = guestfs_mkfs (g, fstype, device);
15796 char device[] = "/dev/VG/LV";
15797 char mountpoint[] = "/";
15799 suppress_error = 0;
15800 r = guestfs_mount (g, device, mountpoint);
15804 /* TestOutputList for vgs (0) */
15808 suppress_error = 0;
15809 r = guestfs_vgs (g);
15813 fprintf (stderr, "test_vgs_0: short list returned from command\n");
15818 char expected[] = "VG";
15819 if (strcmp (r[0], expected) != 0) {
15820 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15824 if (r[1] != NULL) {
15825 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
15829 for (i = 0; r[i] != NULL; ++i)
15836 static int test_vgs_1_skip (void)
15840 str = getenv ("TEST_ONLY");
15842 return strstr (str, "vgs") == NULL;
15843 str = getenv ("SKIP_TEST_VGS_1");
15844 if (str && strcmp (str, "1") == 0) return 1;
15845 str = getenv ("SKIP_TEST_VGS");
15846 if (str && strcmp (str, "1") == 0) return 1;
15850 static int test_vgs_1 (void)
15852 if (test_vgs_1_skip ()) {
15853 printf ("%s skipped (reason: environment variable set)\n", "test_vgs_1");
15857 /* InitNone|InitEmpty for test_vgs_1 */
15859 char device[] = "/dev/sda";
15861 suppress_error = 0;
15862 r = guestfs_blockdev_setrw (g, device);
15868 suppress_error = 0;
15869 r = guestfs_umount_all (g);
15875 suppress_error = 0;
15876 r = guestfs_lvm_remove_all (g);
15880 /* TestOutputList for vgs (1) */
15882 char device[] = "/dev/sda";
15883 char lines_0[] = ",10";
15884 char lines_1[] = ",20";
15885 char lines_2[] = ",";
15893 suppress_error = 0;
15894 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15899 char device[] = "/dev/sda1";
15901 suppress_error = 0;
15902 r = guestfs_pvcreate (g, device);
15907 char device[] = "/dev/sda2";
15909 suppress_error = 0;
15910 r = guestfs_pvcreate (g, device);
15915 char device[] = "/dev/sda3";
15917 suppress_error = 0;
15918 r = guestfs_pvcreate (g, device);
15923 char volgroup[] = "VG1";
15924 char physvols_0[] = "/dev/sda1";
15925 char physvols_1[] = "/dev/sda2";
15926 char *physvols[] = {
15932 suppress_error = 0;
15933 r = guestfs_vgcreate (g, volgroup, physvols);
15938 char volgroup[] = "VG2";
15939 char physvols_0[] = "/dev/sda3";
15940 char *physvols[] = {
15945 suppress_error = 0;
15946 r = guestfs_vgcreate (g, volgroup, physvols);
15953 suppress_error = 0;
15954 r = guestfs_vgs (g);
15958 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15963 char expected[] = "VG1";
15964 if (strcmp (r[0], expected) != 0) {
15965 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15970 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15975 char expected[] = "VG2";
15976 if (strcmp (r[1], expected) != 0) {
15977 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15981 if (r[2] != NULL) {
15982 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15986 for (i = 0; r[i] != NULL; ++i)
15993 static int test_pvs_0_skip (void)
15997 str = getenv ("TEST_ONLY");
15999 return strstr (str, "pvs") == NULL;
16000 str = getenv ("SKIP_TEST_PVS_0");
16001 if (str && strcmp (str, "1") == 0) return 1;
16002 str = getenv ("SKIP_TEST_PVS");
16003 if (str && strcmp (str, "1") == 0) return 1;
16007 static int test_pvs_0 (void)
16009 if (test_pvs_0_skip ()) {
16010 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_0");
16014 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
16016 char device[] = "/dev/sda";
16018 suppress_error = 0;
16019 r = guestfs_blockdev_setrw (g, device);
16025 suppress_error = 0;
16026 r = guestfs_umount_all (g);
16032 suppress_error = 0;
16033 r = guestfs_lvm_remove_all (g);
16038 char device[] = "/dev/sda";
16039 char lines_0[] = ",";
16045 suppress_error = 0;
16046 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16051 char device[] = "/dev/sda1";
16053 suppress_error = 0;
16054 r = guestfs_pvcreate (g, device);
16059 char volgroup[] = "VG";
16060 char physvols_0[] = "/dev/sda1";
16061 char *physvols[] = {
16066 suppress_error = 0;
16067 r = guestfs_vgcreate (g, volgroup, physvols);
16072 char logvol[] = "LV";
16073 char volgroup[] = "VG";
16075 suppress_error = 0;
16076 r = guestfs_lvcreate (g, logvol, volgroup, 8);
16081 char fstype[] = "ext2";
16082 char device[] = "/dev/VG/LV";
16084 suppress_error = 0;
16085 r = guestfs_mkfs (g, fstype, device);
16090 char device[] = "/dev/VG/LV";
16091 char mountpoint[] = "/";
16093 suppress_error = 0;
16094 r = guestfs_mount (g, device, mountpoint);
16098 /* TestOutputListOfDevices for pvs (0) */
16102 suppress_error = 0;
16103 r = guestfs_pvs (g);
16107 fprintf (stderr, "test_pvs_0: short list returned from command\n");
16112 char expected[] = "/dev/sda1";
16114 if (strcmp (r[0], expected) != 0) {
16115 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16119 if (r[1] != NULL) {
16120 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
16124 for (i = 0; r[i] != NULL; ++i)
16131 static int test_pvs_1_skip (void)
16135 str = getenv ("TEST_ONLY");
16137 return strstr (str, "pvs") == NULL;
16138 str = getenv ("SKIP_TEST_PVS_1");
16139 if (str && strcmp (str, "1") == 0) return 1;
16140 str = getenv ("SKIP_TEST_PVS");
16141 if (str && strcmp (str, "1") == 0) return 1;
16145 static int test_pvs_1 (void)
16147 if (test_pvs_1_skip ()) {
16148 printf ("%s skipped (reason: environment variable set)\n", "test_pvs_1");
16152 /* InitNone|InitEmpty for test_pvs_1 */
16154 char device[] = "/dev/sda";
16156 suppress_error = 0;
16157 r = guestfs_blockdev_setrw (g, device);
16163 suppress_error = 0;
16164 r = guestfs_umount_all (g);
16170 suppress_error = 0;
16171 r = guestfs_lvm_remove_all (g);
16175 /* TestOutputListOfDevices for pvs (1) */
16177 char device[] = "/dev/sda";
16178 char lines_0[] = ",10";
16179 char lines_1[] = ",20";
16180 char lines_2[] = ",";
16188 suppress_error = 0;
16189 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16194 char device[] = "/dev/sda1";
16196 suppress_error = 0;
16197 r = guestfs_pvcreate (g, device);
16202 char device[] = "/dev/sda2";
16204 suppress_error = 0;
16205 r = guestfs_pvcreate (g, device);
16210 char device[] = "/dev/sda3";
16212 suppress_error = 0;
16213 r = guestfs_pvcreate (g, device);
16220 suppress_error = 0;
16221 r = guestfs_pvs (g);
16225 fprintf (stderr, "test_pvs_1: short list returned from command\n");
16230 char expected[] = "/dev/sda1";
16232 if (strcmp (r[0], expected) != 0) {
16233 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16238 fprintf (stderr, "test_pvs_1: short list returned from command\n");
16243 char expected[] = "/dev/sda2";
16245 if (strcmp (r[1], expected) != 0) {
16246 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16251 fprintf (stderr, "test_pvs_1: short list returned from command\n");
16256 char expected[] = "/dev/sda3";
16258 if (strcmp (r[2], expected) != 0) {
16259 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16263 if (r[3] != NULL) {
16264 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
16268 for (i = 0; r[i] != NULL; ++i)
16275 static int test_list_partitions_0_skip (void)
16279 str = getenv ("TEST_ONLY");
16281 return strstr (str, "list_partitions") == NULL;
16282 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
16283 if (str && strcmp (str, "1") == 0) return 1;
16284 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
16285 if (str && strcmp (str, "1") == 0) return 1;
16289 static int test_list_partitions_0 (void)
16291 if (test_list_partitions_0_skip ()) {
16292 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_0");
16296 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
16298 char device[] = "/dev/sda";
16300 suppress_error = 0;
16301 r = guestfs_blockdev_setrw (g, device);
16307 suppress_error = 0;
16308 r = guestfs_umount_all (g);
16314 suppress_error = 0;
16315 r = guestfs_lvm_remove_all (g);
16320 char device[] = "/dev/sda";
16321 char lines_0[] = ",";
16327 suppress_error = 0;
16328 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16333 char fstype[] = "ext2";
16334 char device[] = "/dev/sda1";
16336 suppress_error = 0;
16337 r = guestfs_mkfs (g, fstype, device);
16342 char device[] = "/dev/sda1";
16343 char mountpoint[] = "/";
16345 suppress_error = 0;
16346 r = guestfs_mount (g, device, mountpoint);
16350 /* TestOutputListOfDevices for list_partitions (0) */
16354 suppress_error = 0;
16355 r = guestfs_list_partitions (g);
16359 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
16364 char expected[] = "/dev/sda1";
16366 if (strcmp (r[0], expected) != 0) {
16367 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16371 if (r[1] != NULL) {
16372 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
16376 for (i = 0; r[i] != NULL; ++i)
16383 static int test_list_partitions_1_skip (void)
16387 str = getenv ("TEST_ONLY");
16389 return strstr (str, "list_partitions") == NULL;
16390 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
16391 if (str && strcmp (str, "1") == 0) return 1;
16392 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
16393 if (str && strcmp (str, "1") == 0) return 1;
16397 static int test_list_partitions_1 (void)
16399 if (test_list_partitions_1_skip ()) {
16400 printf ("%s skipped (reason: environment variable set)\n", "test_list_partitions_1");
16404 /* InitNone|InitEmpty for test_list_partitions_1 */
16406 char device[] = "/dev/sda";
16408 suppress_error = 0;
16409 r = guestfs_blockdev_setrw (g, device);
16415 suppress_error = 0;
16416 r = guestfs_umount_all (g);
16422 suppress_error = 0;
16423 r = guestfs_lvm_remove_all (g);
16427 /* TestOutputListOfDevices for list_partitions (1) */
16429 char device[] = "/dev/sda";
16430 char lines_0[] = ",10";
16431 char lines_1[] = ",20";
16432 char lines_2[] = ",";
16440 suppress_error = 0;
16441 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16448 suppress_error = 0;
16449 r = guestfs_list_partitions (g);
16453 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16458 char expected[] = "/dev/sda1";
16460 if (strcmp (r[0], expected) != 0) {
16461 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16466 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16471 char expected[] = "/dev/sda2";
16473 if (strcmp (r[1], expected) != 0) {
16474 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16479 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
16484 char expected[] = "/dev/sda3";
16486 if (strcmp (r[2], expected) != 0) {
16487 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16491 if (r[3] != NULL) {
16492 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
16496 for (i = 0; r[i] != NULL; ++i)
16503 static int test_list_devices_0_skip (void)
16507 str = getenv ("TEST_ONLY");
16509 return strstr (str, "list_devices") == NULL;
16510 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
16511 if (str && strcmp (str, "1") == 0) return 1;
16512 str = getenv ("SKIP_TEST_LIST_DEVICES");
16513 if (str && strcmp (str, "1") == 0) return 1;
16517 static int test_list_devices_0 (void)
16519 if (test_list_devices_0_skip ()) {
16520 printf ("%s skipped (reason: environment variable set)\n", "test_list_devices_0");
16524 /* InitNone|InitEmpty for test_list_devices_0 */
16526 char device[] = "/dev/sda";
16528 suppress_error = 0;
16529 r = guestfs_blockdev_setrw (g, device);
16535 suppress_error = 0;
16536 r = guestfs_umount_all (g);
16542 suppress_error = 0;
16543 r = guestfs_lvm_remove_all (g);
16547 /* TestOutputListOfDevices for list_devices (0) */
16551 suppress_error = 0;
16552 r = guestfs_list_devices (g);
16556 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16561 char expected[] = "/dev/sda";
16563 if (strcmp (r[0], expected) != 0) {
16564 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16569 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16574 char expected[] = "/dev/sdb";
16576 if (strcmp (r[1], expected) != 0) {
16577 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16582 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16587 char expected[] = "/dev/sdc";
16589 if (strcmp (r[2], expected) != 0) {
16590 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16595 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
16600 char expected[] = "/dev/sdd";
16602 if (strcmp (r[3], expected) != 0) {
16603 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
16607 if (r[4] != NULL) {
16608 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
16612 for (i = 0; r[i] != NULL; ++i)
16619 static int test_ls_0_skip (void)
16623 str = getenv ("TEST_ONLY");
16625 return strstr (str, "ls") == NULL;
16626 str = getenv ("SKIP_TEST_LS_0");
16627 if (str && strcmp (str, "1") == 0) return 1;
16628 str = getenv ("SKIP_TEST_LS");
16629 if (str && strcmp (str, "1") == 0) return 1;
16633 static int test_ls_0 (void)
16635 if (test_ls_0_skip ()) {
16636 printf ("%s skipped (reason: environment variable set)\n", "test_ls_0");
16640 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
16642 char device[] = "/dev/sda";
16644 suppress_error = 0;
16645 r = guestfs_blockdev_setrw (g, device);
16651 suppress_error = 0;
16652 r = guestfs_umount_all (g);
16658 suppress_error = 0;
16659 r = guestfs_lvm_remove_all (g);
16664 char device[] = "/dev/sda";
16665 char lines_0[] = ",";
16671 suppress_error = 0;
16672 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16677 char fstype[] = "ext2";
16678 char device[] = "/dev/sda1";
16680 suppress_error = 0;
16681 r = guestfs_mkfs (g, fstype, device);
16686 char device[] = "/dev/sda1";
16687 char mountpoint[] = "/";
16689 suppress_error = 0;
16690 r = guestfs_mount (g, device, mountpoint);
16694 /* TestOutputList for ls (0) */
16696 char path[] = "/new";
16698 suppress_error = 0;
16699 r = guestfs_touch (g, path);
16704 char path[] = "/newer";
16706 suppress_error = 0;
16707 r = guestfs_touch (g, path);
16712 char path[] = "/newest";
16714 suppress_error = 0;
16715 r = guestfs_touch (g, path);
16720 char directory[] = "/";
16723 suppress_error = 0;
16724 r = guestfs_ls (g, directory);
16728 fprintf (stderr, "test_ls_0: short list returned from command\n");
16733 char expected[] = "lost+found";
16734 if (strcmp (r[0], expected) != 0) {
16735 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
16740 fprintf (stderr, "test_ls_0: short list returned from command\n");
16745 char expected[] = "new";
16746 if (strcmp (r[1], expected) != 0) {
16747 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
16752 fprintf (stderr, "test_ls_0: short list returned from command\n");
16757 char expected[] = "newer";
16758 if (strcmp (r[2], expected) != 0) {
16759 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
16764 fprintf (stderr, "test_ls_0: short list returned from command\n");
16769 char expected[] = "newest";
16770 if (strcmp (r[3], expected) != 0) {
16771 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
16775 if (r[4] != NULL) {
16776 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
16780 for (i = 0; r[i] != NULL; ++i)
16787 static int test_cat_0_skip (void)
16791 str = getenv ("TEST_ONLY");
16793 return strstr (str, "cat") == NULL;
16794 str = getenv ("SKIP_TEST_CAT_0");
16795 if (str && strcmp (str, "1") == 0) return 1;
16796 str = getenv ("SKIP_TEST_CAT");
16797 if (str && strcmp (str, "1") == 0) return 1;
16801 static int test_cat_0 (void)
16803 if (test_cat_0_skip ()) {
16804 printf ("%s skipped (reason: environment variable set)\n", "test_cat_0");
16808 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
16810 char device[] = "/dev/sda";
16812 suppress_error = 0;
16813 r = guestfs_blockdev_setrw (g, device);
16819 suppress_error = 0;
16820 r = guestfs_umount_all (g);
16826 suppress_error = 0;
16827 r = guestfs_lvm_remove_all (g);
16832 char device[] = "/dev/sda";
16833 char lines_0[] = ",";
16839 suppress_error = 0;
16840 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16845 char fstype[] = "ext2";
16846 char device[] = "/dev/sda1";
16848 suppress_error = 0;
16849 r = guestfs_mkfs (g, fstype, device);
16854 char device[] = "/dev/sda1";
16855 char mountpoint[] = "/";
16857 suppress_error = 0;
16858 r = guestfs_mount (g, device, mountpoint);
16862 /* TestOutput for cat (0) */
16863 char expected[] = "new file contents";
16865 char path[] = "/new";
16866 char content[] = "new file contents";
16868 suppress_error = 0;
16869 r = guestfs_write_file (g, path, content, 0);
16874 char path[] = "/new";
16876 suppress_error = 0;
16877 r = guestfs_cat (g, path);
16880 if (strcmp (r, expected) != 0) {
16881 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
16889 static int test_touch_0_skip (void)
16893 str = getenv ("TEST_ONLY");
16895 return strstr (str, "touch") == NULL;
16896 str = getenv ("SKIP_TEST_TOUCH_0");
16897 if (str && strcmp (str, "1") == 0) return 1;
16898 str = getenv ("SKIP_TEST_TOUCH");
16899 if (str && strcmp (str, "1") == 0) return 1;
16903 static int test_touch_0 (void)
16905 if (test_touch_0_skip ()) {
16906 printf ("%s skipped (reason: environment variable set)\n", "test_touch_0");
16910 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
16912 char device[] = "/dev/sda";
16914 suppress_error = 0;
16915 r = guestfs_blockdev_setrw (g, device);
16921 suppress_error = 0;
16922 r = guestfs_umount_all (g);
16928 suppress_error = 0;
16929 r = guestfs_lvm_remove_all (g);
16934 char device[] = "/dev/sda";
16935 char lines_0[] = ",";
16941 suppress_error = 0;
16942 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16947 char fstype[] = "ext2";
16948 char device[] = "/dev/sda1";
16950 suppress_error = 0;
16951 r = guestfs_mkfs (g, fstype, device);
16956 char device[] = "/dev/sda1";
16957 char mountpoint[] = "/";
16959 suppress_error = 0;
16960 r = guestfs_mount (g, device, mountpoint);
16964 /* TestOutputTrue for touch (0) */
16966 char path[] = "/new";
16968 suppress_error = 0;
16969 r = guestfs_touch (g, path);
16974 char path[] = "/new";
16976 suppress_error = 0;
16977 r = guestfs_exists (g, path);
16981 fprintf (stderr, "test_touch_0: expected true, got false\n");
16988 static int test_sync_0_skip (void)
16992 str = getenv ("TEST_ONLY");
16994 return strstr (str, "sync") == NULL;
16995 str = getenv ("SKIP_TEST_SYNC_0");
16996 if (str && strcmp (str, "1") == 0) return 1;
16997 str = getenv ("SKIP_TEST_SYNC");
16998 if (str && strcmp (str, "1") == 0) return 1;
17002 static int test_sync_0 (void)
17004 if (test_sync_0_skip ()) {
17005 printf ("%s skipped (reason: environment variable set)\n", "test_sync_0");
17009 /* InitNone|InitEmpty for test_sync_0 */
17011 char device[] = "/dev/sda";
17013 suppress_error = 0;
17014 r = guestfs_blockdev_setrw (g, device);
17020 suppress_error = 0;
17021 r = guestfs_umount_all (g);
17027 suppress_error = 0;
17028 r = guestfs_lvm_remove_all (g);
17032 /* TestRun for sync (0) */
17035 suppress_error = 0;
17036 r = guestfs_sync (g);
17043 static int test_mount_0_skip (void)
17047 str = getenv ("TEST_ONLY");
17049 return strstr (str, "mount") == NULL;
17050 str = getenv ("SKIP_TEST_MOUNT_0");
17051 if (str && strcmp (str, "1") == 0) return 1;
17052 str = getenv ("SKIP_TEST_MOUNT");
17053 if (str && strcmp (str, "1") == 0) return 1;
17057 static int test_mount_0 (void)
17059 if (test_mount_0_skip ()) {
17060 printf ("%s skipped (reason: environment variable set)\n", "test_mount_0");
17064 /* InitNone|InitEmpty for test_mount_0 */
17066 char device[] = "/dev/sda";
17068 suppress_error = 0;
17069 r = guestfs_blockdev_setrw (g, device);
17075 suppress_error = 0;
17076 r = guestfs_umount_all (g);
17082 suppress_error = 0;
17083 r = guestfs_lvm_remove_all (g);
17087 /* TestOutput for mount (0) */
17088 char expected[] = "new file contents";
17090 char device[] = "/dev/sda";
17091 char lines_0[] = ",";
17097 suppress_error = 0;
17098 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
17103 char fstype[] = "ext2";
17104 char device[] = "/dev/sda1";
17106 suppress_error = 0;
17107 r = guestfs_mkfs (g, fstype, device);
17112 char device[] = "/dev/sda1";
17113 char mountpoint[] = "/";
17115 suppress_error = 0;
17116 r = guestfs_mount (g, device, mountpoint);
17121 char path[] = "/new";
17122 char content[] = "new file contents";
17124 suppress_error = 0;
17125 r = guestfs_write_file (g, path, content, 0);
17130 char path[] = "/new";
17132 suppress_error = 0;
17133 r = guestfs_cat (g, path);
17136 if (strcmp (r, expected) != 0) {
17137 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
17145 int main (int argc, char *argv[])
17149 const char *filename;
17151 int nr_tests, test_num = 0;
17153 no_test_warnings ();
17155 g = guestfs_create ();
17157 printf ("guestfs_create FAILED\n");
17161 guestfs_set_error_handler (g, print_error, NULL);
17163 guestfs_set_path (g, "../appliance");
17165 filename = "test1.img";
17166 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
17171 if (lseek (fd, 524288000, SEEK_SET) == -1) {
17177 if (write (fd, &c, 1) == -1) {
17183 if (close (fd) == -1) {
17188 if (guestfs_add_drive (g, filename) == -1) {
17189 printf ("guestfs_add_drive %s FAILED\n", filename);
17193 filename = "test2.img";
17194 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
17199 if (lseek (fd, 52428800, SEEK_SET) == -1) {
17205 if (write (fd, &c, 1) == -1) {
17211 if (close (fd) == -1) {
17216 if (guestfs_add_drive (g, filename) == -1) {
17217 printf ("guestfs_add_drive %s FAILED\n", filename);
17221 filename = "test3.img";
17222 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
17227 if (lseek (fd, 10485760, SEEK_SET) == -1) {
17233 if (write (fd, &c, 1) == -1) {
17239 if (close (fd) == -1) {
17244 if (guestfs_add_drive (g, filename) == -1) {
17245 printf ("guestfs_add_drive %s FAILED\n", filename);
17249 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
17250 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
17254 if (guestfs_launch (g) == -1) {
17255 printf ("guestfs_launch FAILED\n");
17259 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
17262 if (guestfs_wait_ready (g) == -1) {
17263 printf ("guestfs_wait_ready FAILED\n");
17267 /* Cancel previous alarm. */
17273 printf ("%3d/%3d test_wc_c_0\n", test_num, nr_tests);
17274 if (test_wc_c_0 () == -1) {
17275 printf ("test_wc_c_0 FAILED\n");
17279 printf ("%3d/%3d test_wc_w_0\n", test_num, nr_tests);
17280 if (test_wc_w_0 () == -1) {
17281 printf ("test_wc_w_0 FAILED\n");
17285 printf ("%3d/%3d test_wc_l_0\n", test_num, nr_tests);
17286 if (test_wc_l_0 () == -1) {
17287 printf ("test_wc_l_0 FAILED\n");
17291 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
17292 if (test_mkdtemp_0 () == -1) {
17293 printf ("test_mkdtemp_0 FAILED\n");
17297 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
17298 if (test_scrub_file_0 () == -1) {
17299 printf ("test_scrub_file_0 FAILED\n");
17303 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
17304 if (test_scrub_device_0 () == -1) {
17305 printf ("test_scrub_device_0 FAILED\n");
17309 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
17310 if (test_glob_expand_0 () == -1) {
17311 printf ("test_glob_expand_0 FAILED\n");
17315 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
17316 if (test_glob_expand_1 () == -1) {
17317 printf ("test_glob_expand_1 FAILED\n");
17321 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
17322 if (test_glob_expand_2 () == -1) {
17323 printf ("test_glob_expand_2 FAILED\n");
17327 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
17328 if (test_ntfs_3g_probe_0 () == -1) {
17329 printf ("test_ntfs_3g_probe_0 FAILED\n");
17333 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
17334 if (test_ntfs_3g_probe_1 () == -1) {
17335 printf ("test_ntfs_3g_probe_1 FAILED\n");
17339 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
17340 if (test_sleep_0 () == -1) {
17341 printf ("test_sleep_0 FAILED\n");
17345 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
17346 if (test_find_0 () == -1) {
17347 printf ("test_find_0 FAILED\n");
17351 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
17352 if (test_find_1 () == -1) {
17353 printf ("test_find_1 FAILED\n");
17357 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
17358 if (test_find_2 () == -1) {
17359 printf ("test_find_2 FAILED\n");
17363 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
17364 if (test_lvresize_0 () == -1) {
17365 printf ("test_lvresize_0 FAILED\n");
17369 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
17370 if (test_zerofree_0 () == -1) {
17371 printf ("test_zerofree_0 FAILED\n");
17375 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
17376 if (test_hexdump_0 () == -1) {
17377 printf ("test_hexdump_0 FAILED\n");
17381 printf ("%3d/%3d test_hexdump_1\n", test_num, nr_tests);
17382 if (test_hexdump_1 () == -1) {
17383 printf ("test_hexdump_1 FAILED\n");
17387 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
17388 if (test_strings_e_0 () == -1) {
17389 printf ("test_strings_e_0 FAILED\n");
17393 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
17394 if (test_strings_e_1 () == -1) {
17395 printf ("test_strings_e_1 FAILED\n");
17399 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
17400 if (test_strings_0 () == -1) {
17401 printf ("test_strings_0 FAILED\n");
17405 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
17406 if (test_strings_1 () == -1) {
17407 printf ("test_strings_1 FAILED\n");
17411 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
17412 if (test_equal_0 () == -1) {
17413 printf ("test_equal_0 FAILED\n");
17417 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
17418 if (test_equal_1 () == -1) {
17419 printf ("test_equal_1 FAILED\n");
17423 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
17424 if (test_equal_2 () == -1) {
17425 printf ("test_equal_2 FAILED\n");
17429 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
17430 if (test_ping_daemon_0 () == -1) {
17431 printf ("test_ping_daemon_0 FAILED\n");
17435 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
17436 if (test_dmesg_0 () == -1) {
17437 printf ("test_dmesg_0 FAILED\n");
17441 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
17442 if (test_drop_caches_0 () == -1) {
17443 printf ("test_drop_caches_0 FAILED\n");
17447 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
17448 if (test_mv_0 () == -1) {
17449 printf ("test_mv_0 FAILED\n");
17453 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
17454 if (test_mv_1 () == -1) {
17455 printf ("test_mv_1 FAILED\n");
17459 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
17460 if (test_cp_a_0 () == -1) {
17461 printf ("test_cp_a_0 FAILED\n");
17465 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
17466 if (test_cp_0 () == -1) {
17467 printf ("test_cp_0 FAILED\n");
17471 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
17472 if (test_cp_1 () == -1) {
17473 printf ("test_cp_1 FAILED\n");
17477 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
17478 if (test_cp_2 () == -1) {
17479 printf ("test_cp_2 FAILED\n");
17483 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
17484 if (test_grub_install_0 () == -1) {
17485 printf ("test_grub_install_0 FAILED\n");
17489 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
17490 if (test_zero_0 () == -1) {
17491 printf ("test_zero_0 FAILED\n");
17495 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
17496 if (test_fsck_0 () == -1) {
17497 printf ("test_fsck_0 FAILED\n");
17501 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
17502 if (test_fsck_1 () == -1) {
17503 printf ("test_fsck_1 FAILED\n");
17507 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
17508 if (test_set_e2uuid_0 () == -1) {
17509 printf ("test_set_e2uuid_0 FAILED\n");
17513 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
17514 if (test_set_e2uuid_1 () == -1) {
17515 printf ("test_set_e2uuid_1 FAILED\n");
17519 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
17520 if (test_set_e2uuid_2 () == -1) {
17521 printf ("test_set_e2uuid_2 FAILED\n");
17525 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
17526 if (test_set_e2uuid_3 () == -1) {
17527 printf ("test_set_e2uuid_3 FAILED\n");
17531 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
17532 if (test_set_e2label_0 () == -1) {
17533 printf ("test_set_e2label_0 FAILED\n");
17537 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
17538 if (test_pvremove_0 () == -1) {
17539 printf ("test_pvremove_0 FAILED\n");
17543 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
17544 if (test_pvremove_1 () == -1) {
17545 printf ("test_pvremove_1 FAILED\n");
17549 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
17550 if (test_pvremove_2 () == -1) {
17551 printf ("test_pvremove_2 FAILED\n");
17555 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
17556 if (test_vgremove_0 () == -1) {
17557 printf ("test_vgremove_0 FAILED\n");
17561 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
17562 if (test_vgremove_1 () == -1) {
17563 printf ("test_vgremove_1 FAILED\n");
17567 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
17568 if (test_lvremove_0 () == -1) {
17569 printf ("test_lvremove_0 FAILED\n");
17573 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
17574 if (test_lvremove_1 () == -1) {
17575 printf ("test_lvremove_1 FAILED\n");
17579 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
17580 if (test_lvremove_2 () == -1) {
17581 printf ("test_lvremove_2 FAILED\n");
17585 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
17586 if (test_mount_ro_0 () == -1) {
17587 printf ("test_mount_ro_0 FAILED\n");
17591 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
17592 if (test_mount_ro_1 () == -1) {
17593 printf ("test_mount_ro_1 FAILED\n");
17597 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
17598 if (test_tgz_in_0 () == -1) {
17599 printf ("test_tgz_in_0 FAILED\n");
17603 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
17604 if (test_tar_in_0 () == -1) {
17605 printf ("test_tar_in_0 FAILED\n");
17609 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
17610 if (test_checksum_0 () == -1) {
17611 printf ("test_checksum_0 FAILED\n");
17615 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
17616 if (test_checksum_1 () == -1) {
17617 printf ("test_checksum_1 FAILED\n");
17621 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
17622 if (test_checksum_2 () == -1) {
17623 printf ("test_checksum_2 FAILED\n");
17627 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
17628 if (test_checksum_3 () == -1) {
17629 printf ("test_checksum_3 FAILED\n");
17633 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
17634 if (test_checksum_4 () == -1) {
17635 printf ("test_checksum_4 FAILED\n");
17639 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
17640 if (test_checksum_5 () == -1) {
17641 printf ("test_checksum_5 FAILED\n");
17645 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
17646 if (test_checksum_6 () == -1) {
17647 printf ("test_checksum_6 FAILED\n");
17651 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
17652 if (test_checksum_7 () == -1) {
17653 printf ("test_checksum_7 FAILED\n");
17657 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
17658 if (test_checksum_8 () == -1) {
17659 printf ("test_checksum_8 FAILED\n");
17663 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
17664 if (test_download_0 () == -1) {
17665 printf ("test_download_0 FAILED\n");
17669 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
17670 if (test_upload_0 () == -1) {
17671 printf ("test_upload_0 FAILED\n");
17675 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
17676 if (test_blockdev_rereadpt_0 () == -1) {
17677 printf ("test_blockdev_rereadpt_0 FAILED\n");
17681 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
17682 if (test_blockdev_flushbufs_0 () == -1) {
17683 printf ("test_blockdev_flushbufs_0 FAILED\n");
17687 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
17688 if (test_blockdev_getsize64_0 () == -1) {
17689 printf ("test_blockdev_getsize64_0 FAILED\n");
17693 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
17694 if (test_blockdev_getsz_0 () == -1) {
17695 printf ("test_blockdev_getsz_0 FAILED\n");
17699 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
17700 if (test_blockdev_getbsz_0 () == -1) {
17701 printf ("test_blockdev_getbsz_0 FAILED\n");
17705 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
17706 if (test_blockdev_getss_0 () == -1) {
17707 printf ("test_blockdev_getss_0 FAILED\n");
17711 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
17712 if (test_blockdev_getro_0 () == -1) {
17713 printf ("test_blockdev_getro_0 FAILED\n");
17717 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
17718 if (test_blockdev_setrw_0 () == -1) {
17719 printf ("test_blockdev_setrw_0 FAILED\n");
17723 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
17724 if (test_blockdev_setro_0 () == -1) {
17725 printf ("test_blockdev_setro_0 FAILED\n");
17729 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
17730 if (test_statvfs_0 () == -1) {
17731 printf ("test_statvfs_0 FAILED\n");
17735 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
17736 if (test_lstat_0 () == -1) {
17737 printf ("test_lstat_0 FAILED\n");
17741 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
17742 if (test_stat_0 () == -1) {
17743 printf ("test_stat_0 FAILED\n");
17747 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
17748 if (test_command_lines_0 () == -1) {
17749 printf ("test_command_lines_0 FAILED\n");
17753 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
17754 if (test_command_lines_1 () == -1) {
17755 printf ("test_command_lines_1 FAILED\n");
17759 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
17760 if (test_command_lines_2 () == -1) {
17761 printf ("test_command_lines_2 FAILED\n");
17765 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
17766 if (test_command_lines_3 () == -1) {
17767 printf ("test_command_lines_3 FAILED\n");
17771 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
17772 if (test_command_lines_4 () == -1) {
17773 printf ("test_command_lines_4 FAILED\n");
17777 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
17778 if (test_command_lines_5 () == -1) {
17779 printf ("test_command_lines_5 FAILED\n");
17783 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
17784 if (test_command_lines_6 () == -1) {
17785 printf ("test_command_lines_6 FAILED\n");
17789 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
17790 if (test_command_lines_7 () == -1) {
17791 printf ("test_command_lines_7 FAILED\n");
17795 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
17796 if (test_command_lines_8 () == -1) {
17797 printf ("test_command_lines_8 FAILED\n");
17801 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
17802 if (test_command_lines_9 () == -1) {
17803 printf ("test_command_lines_9 FAILED\n");
17807 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
17808 if (test_command_lines_10 () == -1) {
17809 printf ("test_command_lines_10 FAILED\n");
17813 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
17814 if (test_command_0 () == -1) {
17815 printf ("test_command_0 FAILED\n");
17819 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
17820 if (test_command_1 () == -1) {
17821 printf ("test_command_1 FAILED\n");
17825 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
17826 if (test_command_2 () == -1) {
17827 printf ("test_command_2 FAILED\n");
17831 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
17832 if (test_command_3 () == -1) {
17833 printf ("test_command_3 FAILED\n");
17837 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
17838 if (test_command_4 () == -1) {
17839 printf ("test_command_4 FAILED\n");
17843 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
17844 if (test_command_5 () == -1) {
17845 printf ("test_command_5 FAILED\n");
17849 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
17850 if (test_command_6 () == -1) {
17851 printf ("test_command_6 FAILED\n");
17855 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
17856 if (test_command_7 () == -1) {
17857 printf ("test_command_7 FAILED\n");
17861 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
17862 if (test_command_8 () == -1) {
17863 printf ("test_command_8 FAILED\n");
17867 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
17868 if (test_command_9 () == -1) {
17869 printf ("test_command_9 FAILED\n");
17873 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
17874 if (test_command_10 () == -1) {
17875 printf ("test_command_10 FAILED\n");
17879 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
17880 if (test_command_11 () == -1) {
17881 printf ("test_command_11 FAILED\n");
17885 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
17886 if (test_file_0 () == -1) {
17887 printf ("test_file_0 FAILED\n");
17891 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
17892 if (test_file_1 () == -1) {
17893 printf ("test_file_1 FAILED\n");
17897 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
17898 if (test_file_2 () == -1) {
17899 printf ("test_file_2 FAILED\n");
17903 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
17904 if (test_umount_all_0 () == -1) {
17905 printf ("test_umount_all_0 FAILED\n");
17909 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
17910 if (test_umount_all_1 () == -1) {
17911 printf ("test_umount_all_1 FAILED\n");
17915 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
17916 if (test_mounts_0 () == -1) {
17917 printf ("test_mounts_0 FAILED\n");
17921 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
17922 if (test_umount_0 () == -1) {
17923 printf ("test_umount_0 FAILED\n");
17927 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
17928 if (test_umount_1 () == -1) {
17929 printf ("test_umount_1 FAILED\n");
17933 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
17934 if (test_write_file_0 () == -1) {
17935 printf ("test_write_file_0 FAILED\n");
17939 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
17940 if (test_write_file_1 () == -1) {
17941 printf ("test_write_file_1 FAILED\n");
17945 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
17946 if (test_write_file_2 () == -1) {
17947 printf ("test_write_file_2 FAILED\n");
17951 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17952 if (test_write_file_3 () == -1) {
17953 printf ("test_write_file_3 FAILED\n");
17957 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17958 if (test_write_file_4 () == -1) {
17959 printf ("test_write_file_4 FAILED\n");
17963 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17964 if (test_write_file_5 () == -1) {
17965 printf ("test_write_file_5 FAILED\n");
17969 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17970 if (test_mkfs_0 () == -1) {
17971 printf ("test_mkfs_0 FAILED\n");
17975 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17976 if (test_lvcreate_0 () == -1) {
17977 printf ("test_lvcreate_0 FAILED\n");
17981 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17982 if (test_vgcreate_0 () == -1) {
17983 printf ("test_vgcreate_0 FAILED\n");
17987 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17988 if (test_pvcreate_0 () == -1) {
17989 printf ("test_pvcreate_0 FAILED\n");
17993 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17994 if (test_is_dir_0 () == -1) {
17995 printf ("test_is_dir_0 FAILED\n");
17999 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
18000 if (test_is_dir_1 () == -1) {
18001 printf ("test_is_dir_1 FAILED\n");
18005 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
18006 if (test_is_file_0 () == -1) {
18007 printf ("test_is_file_0 FAILED\n");
18011 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
18012 if (test_is_file_1 () == -1) {
18013 printf ("test_is_file_1 FAILED\n");
18017 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
18018 if (test_exists_0 () == -1) {
18019 printf ("test_exists_0 FAILED\n");
18023 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
18024 if (test_exists_1 () == -1) {
18025 printf ("test_exists_1 FAILED\n");
18029 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
18030 if (test_mkdir_p_0 () == -1) {
18031 printf ("test_mkdir_p_0 FAILED\n");
18035 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
18036 if (test_mkdir_p_1 () == -1) {
18037 printf ("test_mkdir_p_1 FAILED\n");
18041 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
18042 if (test_mkdir_p_2 () == -1) {
18043 printf ("test_mkdir_p_2 FAILED\n");
18047 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
18048 if (test_mkdir_p_3 () == -1) {
18049 printf ("test_mkdir_p_3 FAILED\n");
18053 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
18054 if (test_mkdir_p_4 () == -1) {
18055 printf ("test_mkdir_p_4 FAILED\n");
18059 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
18060 if (test_mkdir_0 () == -1) {
18061 printf ("test_mkdir_0 FAILED\n");
18065 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
18066 if (test_mkdir_1 () == -1) {
18067 printf ("test_mkdir_1 FAILED\n");
18071 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
18072 if (test_rm_rf_0 () == -1) {
18073 printf ("test_rm_rf_0 FAILED\n");
18077 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
18078 if (test_rmdir_0 () == -1) {
18079 printf ("test_rmdir_0 FAILED\n");
18083 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
18084 if (test_rmdir_1 () == -1) {
18085 printf ("test_rmdir_1 FAILED\n");
18089 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
18090 if (test_rmdir_2 () == -1) {
18091 printf ("test_rmdir_2 FAILED\n");
18095 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
18096 if (test_rm_0 () == -1) {
18097 printf ("test_rm_0 FAILED\n");
18101 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
18102 if (test_rm_1 () == -1) {
18103 printf ("test_rm_1 FAILED\n");
18107 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
18108 if (test_rm_2 () == -1) {
18109 printf ("test_rm_2 FAILED\n");
18113 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
18114 if (test_read_lines_0 () == -1) {
18115 printf ("test_read_lines_0 FAILED\n");
18119 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
18120 if (test_read_lines_1 () == -1) {
18121 printf ("test_read_lines_1 FAILED\n");
18125 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
18126 if (test_lvs_0 () == -1) {
18127 printf ("test_lvs_0 FAILED\n");
18131 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
18132 if (test_lvs_1 () == -1) {
18133 printf ("test_lvs_1 FAILED\n");
18137 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
18138 if (test_vgs_0 () == -1) {
18139 printf ("test_vgs_0 FAILED\n");
18143 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
18144 if (test_vgs_1 () == -1) {
18145 printf ("test_vgs_1 FAILED\n");
18149 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
18150 if (test_pvs_0 () == -1) {
18151 printf ("test_pvs_0 FAILED\n");
18155 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
18156 if (test_pvs_1 () == -1) {
18157 printf ("test_pvs_1 FAILED\n");
18161 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
18162 if (test_list_partitions_0 () == -1) {
18163 printf ("test_list_partitions_0 FAILED\n");
18167 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
18168 if (test_list_partitions_1 () == -1) {
18169 printf ("test_list_partitions_1 FAILED\n");
18173 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
18174 if (test_list_devices_0 () == -1) {
18175 printf ("test_list_devices_0 FAILED\n");
18179 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
18180 if (test_ls_0 () == -1) {
18181 printf ("test_ls_0 FAILED\n");
18185 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
18186 if (test_cat_0 () == -1) {
18187 printf ("test_cat_0 FAILED\n");
18191 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
18192 if (test_touch_0 () == -1) {
18193 printf ("test_touch_0 FAILED\n");
18197 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
18198 if (test_sync_0 () == -1) {
18199 printf ("test_sync_0 FAILED\n");
18203 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
18204 if (test_mount_0 () == -1) {
18205 printf ("test_mount_0 FAILED\n");
18210 unlink ("test1.img");
18211 unlink ("test2.img");
18212 unlink ("test3.img");
18215 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);