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_scrub_file_0_skip (void)
160 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
161 if (str && strcmp (str, "1") == 0) return 1;
162 str = getenv ("SKIP_TEST_SCRUB_FILE");
163 if (str && strcmp (str, "1") == 0) return 1;
167 static int test_scrub_file_0 (void)
169 if (test_scrub_file_0_skip ()) {
170 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_file_0");
174 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
176 char device[] = "/dev/sda";
179 r = guestfs_blockdev_setrw (g, device);
186 r = guestfs_umount_all (g);
193 r = guestfs_lvm_remove_all (g);
198 char device[] = "/dev/sda";
199 char lines_0[] = ",";
206 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
211 char fstype[] = "ext2";
212 char device[] = "/dev/sda1";
215 r = guestfs_mkfs (g, fstype, device);
220 char device[] = "/dev/sda1";
221 char mountpoint[] = "/";
224 r = guestfs_mount (g, device, mountpoint);
228 /* TestRun for scrub_file (0) */
230 char path[] = "/file";
231 char content[] = "content";
234 r = guestfs_write_file (g, path, content, 0);
239 char file[] = "/file";
242 r = guestfs_scrub_file (g, file);
249 static int test_scrub_device_0_skip (void)
253 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
254 if (str && strcmp (str, "1") == 0) return 1;
255 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
256 if (str && strcmp (str, "1") == 0) return 1;
260 static int test_scrub_device_0 (void)
262 if (test_scrub_device_0_skip ()) {
263 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_device_0");
267 /* InitNone|InitEmpty for test_scrub_device_0 */
269 char device[] = "/dev/sda";
272 r = guestfs_blockdev_setrw (g, device);
279 r = guestfs_umount_all (g);
286 r = guestfs_lvm_remove_all (g);
290 /* TestRun for scrub_device (0) */
292 char device[] = "/dev/sdc";
295 r = guestfs_scrub_device (g, device);
302 static int test_glob_expand_0_skip (void)
306 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
307 if (str && strcmp (str, "1") == 0) return 1;
308 str = getenv ("SKIP_TEST_GLOB_EXPAND");
309 if (str && strcmp (str, "1") == 0) return 1;
313 static int test_glob_expand_0 (void)
315 if (test_glob_expand_0_skip ()) {
316 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_0");
320 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
322 char device[] = "/dev/sda";
325 r = guestfs_blockdev_setrw (g, device);
332 r = guestfs_umount_all (g);
339 r = guestfs_lvm_remove_all (g);
344 char device[] = "/dev/sda";
345 char lines_0[] = ",";
352 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
357 char fstype[] = "ext2";
358 char device[] = "/dev/sda1";
361 r = guestfs_mkfs (g, fstype, device);
366 char device[] = "/dev/sda1";
367 char mountpoint[] = "/";
370 r = guestfs_mount (g, device, mountpoint);
374 /* TestOutputList for glob_expand (0) */
376 char path[] = "/a/b/c";
379 r = guestfs_mkdir_p (g, path);
384 char path[] = "/a/b/c/d";
387 r = guestfs_touch (g, path);
392 char path[] = "/a/b/c/e";
395 r = guestfs_touch (g, path);
400 char pattern[] = "/a/b/c/*";
404 r = guestfs_glob_expand (g, pattern);
408 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
413 char expected[] = "/a/b/c/d";
414 if (strcmp (r[0], expected) != 0) {
415 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
420 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
425 char expected[] = "/a/b/c/e";
426 if (strcmp (r[1], expected) != 0) {
427 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
432 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
436 for (i = 0; r[i] != NULL; ++i)
443 static int test_glob_expand_1_skip (void)
447 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
448 if (str && strcmp (str, "1") == 0) return 1;
449 str = getenv ("SKIP_TEST_GLOB_EXPAND");
450 if (str && strcmp (str, "1") == 0) return 1;
454 static int test_glob_expand_1 (void)
456 if (test_glob_expand_1_skip ()) {
457 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_1");
461 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
463 char device[] = "/dev/sda";
466 r = guestfs_blockdev_setrw (g, device);
473 r = guestfs_umount_all (g);
480 r = guestfs_lvm_remove_all (g);
485 char device[] = "/dev/sda";
486 char lines_0[] = ",";
493 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
498 char fstype[] = "ext2";
499 char device[] = "/dev/sda1";
502 r = guestfs_mkfs (g, fstype, device);
507 char device[] = "/dev/sda1";
508 char mountpoint[] = "/";
511 r = guestfs_mount (g, device, mountpoint);
515 /* TestOutputList for glob_expand (1) */
517 char path[] = "/a/b/c";
520 r = guestfs_mkdir_p (g, path);
525 char path[] = "/a/b/c/d";
528 r = guestfs_touch (g, path);
533 char path[] = "/a/b/c/e";
536 r = guestfs_touch (g, path);
541 char pattern[] = "/a/*/c/*";
545 r = guestfs_glob_expand (g, pattern);
549 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
554 char expected[] = "/a/b/c/d";
555 if (strcmp (r[0], expected) != 0) {
556 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
561 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
566 char expected[] = "/a/b/c/e";
567 if (strcmp (r[1], expected) != 0) {
568 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
573 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
577 for (i = 0; r[i] != NULL; ++i)
584 static int test_glob_expand_2_skip (void)
588 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
589 if (str && strcmp (str, "1") == 0) return 1;
590 str = getenv ("SKIP_TEST_GLOB_EXPAND");
591 if (str && strcmp (str, "1") == 0) return 1;
595 static int test_glob_expand_2 (void)
597 if (test_glob_expand_2_skip ()) {
598 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_2");
602 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
604 char device[] = "/dev/sda";
607 r = guestfs_blockdev_setrw (g, device);
614 r = guestfs_umount_all (g);
621 r = guestfs_lvm_remove_all (g);
626 char device[] = "/dev/sda";
627 char lines_0[] = ",";
634 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
639 char fstype[] = "ext2";
640 char device[] = "/dev/sda1";
643 r = guestfs_mkfs (g, fstype, device);
648 char device[] = "/dev/sda1";
649 char mountpoint[] = "/";
652 r = guestfs_mount (g, device, mountpoint);
656 /* TestOutputList for glob_expand (2) */
658 char path[] = "/a/b/c";
661 r = guestfs_mkdir_p (g, path);
666 char path[] = "/a/b/c/d";
669 r = guestfs_touch (g, path);
674 char path[] = "/a/b/c/e";
677 r = guestfs_touch (g, path);
682 char pattern[] = "/a/*/x/*";
686 r = guestfs_glob_expand (g, pattern);
690 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
694 for (i = 0; r[i] != NULL; ++i)
701 static int test_ntfs_3g_probe_0_skip (void)
705 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
706 if (str && strcmp (str, "1") == 0) return 1;
707 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
708 if (str && strcmp (str, "1") == 0) return 1;
712 static int test_ntfs_3g_probe_0 (void)
714 if (test_ntfs_3g_probe_0_skip ()) {
715 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
719 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
721 char device[] = "/dev/sda";
724 r = guestfs_blockdev_setrw (g, device);
731 r = guestfs_umount_all (g);
738 r = guestfs_lvm_remove_all (g);
742 /* TestOutputInt for ntfs_3g_probe (0) */
744 char device[] = "/dev/sda";
745 char lines_0[] = ",";
752 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
757 char fstype[] = "ntfs";
758 char device[] = "/dev/sda1";
761 r = guestfs_mkfs (g, fstype, device);
766 char device[] = "/dev/sda1";
769 r = guestfs_ntfs_3g_probe (g, 1, device);
773 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
780 static int test_ntfs_3g_probe_1_skip (void)
784 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
785 if (str && strcmp (str, "1") == 0) return 1;
786 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
787 if (str && strcmp (str, "1") == 0) return 1;
791 static int test_ntfs_3g_probe_1 (void)
793 if (test_ntfs_3g_probe_1_skip ()) {
794 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
798 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
800 char device[] = "/dev/sda";
803 r = guestfs_blockdev_setrw (g, device);
810 r = guestfs_umount_all (g);
817 r = guestfs_lvm_remove_all (g);
821 /* TestOutputInt for ntfs_3g_probe (1) */
823 char device[] = "/dev/sda";
824 char lines_0[] = ",";
831 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
836 char fstype[] = "ext2";
837 char device[] = "/dev/sda1";
840 r = guestfs_mkfs (g, fstype, device);
845 char device[] = "/dev/sda1";
848 r = guestfs_ntfs_3g_probe (g, 1, device);
852 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
859 static int test_sleep_0_skip (void)
863 str = getenv ("SKIP_TEST_SLEEP_0");
864 if (str && strcmp (str, "1") == 0) return 1;
865 str = getenv ("SKIP_TEST_SLEEP");
866 if (str && strcmp (str, "1") == 0) return 1;
870 static int test_sleep_0 (void)
872 if (test_sleep_0_skip ()) {
873 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
877 /* InitNone|InitEmpty for test_sleep_0 */
879 char device[] = "/dev/sda";
882 r = guestfs_blockdev_setrw (g, device);
889 r = guestfs_umount_all (g);
896 r = guestfs_lvm_remove_all (g);
900 /* TestRun for sleep (0) */
904 r = guestfs_sleep (g, 1);
911 static int test_find_0_skip (void)
915 str = getenv ("SKIP_TEST_FIND_0");
916 if (str && strcmp (str, "1") == 0) return 1;
917 str = getenv ("SKIP_TEST_FIND");
918 if (str && strcmp (str, "1") == 0) return 1;
922 static int test_find_0 (void)
924 if (test_find_0_skip ()) {
925 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
929 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
931 char device[] = "/dev/sda";
934 r = guestfs_blockdev_setrw (g, device);
941 r = guestfs_umount_all (g);
948 r = guestfs_lvm_remove_all (g);
953 char device[] = "/dev/sda";
954 char lines_0[] = ",";
961 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
966 char fstype[] = "ext2";
967 char device[] = "/dev/sda1";
970 r = guestfs_mkfs (g, fstype, device);
975 char device[] = "/dev/sda1";
976 char mountpoint[] = "/";
979 r = guestfs_mount (g, device, mountpoint);
983 /* TestOutputList for find (0) */
985 char directory[] = "/";
989 r = guestfs_find (g, directory);
993 fprintf (stderr, "test_find_0: short list returned from command\n");
998 char expected[] = "lost+found";
999 if (strcmp (r[0], expected) != 0) {
1000 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1005 fprintf (stderr, "test_find_0: extra elements returned from command\n");
1009 for (i = 0; r[i] != NULL; ++i)
1016 static int test_find_1_skip (void)
1020 str = getenv ("SKIP_TEST_FIND_1");
1021 if (str && strcmp (str, "1") == 0) return 1;
1022 str = getenv ("SKIP_TEST_FIND");
1023 if (str && strcmp (str, "1") == 0) return 1;
1027 static int test_find_1 (void)
1029 if (test_find_1_skip ()) {
1030 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
1034 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
1036 char device[] = "/dev/sda";
1039 r = guestfs_blockdev_setrw (g, device);
1046 r = guestfs_umount_all (g);
1053 r = guestfs_lvm_remove_all (g);
1058 char device[] = "/dev/sda";
1059 char lines_0[] = ",";
1066 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1071 char fstype[] = "ext2";
1072 char device[] = "/dev/sda1";
1075 r = guestfs_mkfs (g, fstype, device);
1080 char device[] = "/dev/sda1";
1081 char mountpoint[] = "/";
1084 r = guestfs_mount (g, device, mountpoint);
1088 /* TestOutputList for find (1) */
1093 r = guestfs_touch (g, path);
1101 r = guestfs_mkdir (g, path);
1106 char path[] = "/b/c";
1109 r = guestfs_touch (g, path);
1114 char directory[] = "/";
1118 r = guestfs_find (g, directory);
1122 fprintf (stderr, "test_find_1: short list returned from command\n");
1127 char expected[] = "a";
1128 if (strcmp (r[0], expected) != 0) {
1129 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1134 fprintf (stderr, "test_find_1: short list returned from command\n");
1139 char expected[] = "b";
1140 if (strcmp (r[1], expected) != 0) {
1141 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1146 fprintf (stderr, "test_find_1: short list returned from command\n");
1151 char expected[] = "b/c";
1152 if (strcmp (r[2], expected) != 0) {
1153 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1158 fprintf (stderr, "test_find_1: short list returned from command\n");
1163 char expected[] = "lost+found";
1164 if (strcmp (r[3], expected) != 0) {
1165 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1170 fprintf (stderr, "test_find_1: extra elements returned from command\n");
1174 for (i = 0; r[i] != NULL; ++i)
1181 static int test_find_2_skip (void)
1185 str = getenv ("SKIP_TEST_FIND_2");
1186 if (str && strcmp (str, "1") == 0) return 1;
1187 str = getenv ("SKIP_TEST_FIND");
1188 if (str && strcmp (str, "1") == 0) return 1;
1192 static int test_find_2 (void)
1194 if (test_find_2_skip ()) {
1195 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
1199 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1201 char device[] = "/dev/sda";
1204 r = guestfs_blockdev_setrw (g, device);
1211 r = guestfs_umount_all (g);
1218 r = guestfs_lvm_remove_all (g);
1223 char device[] = "/dev/sda";
1224 char lines_0[] = ",";
1231 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1236 char fstype[] = "ext2";
1237 char device[] = "/dev/sda1";
1240 r = guestfs_mkfs (g, fstype, device);
1245 char device[] = "/dev/sda1";
1246 char mountpoint[] = "/";
1249 r = guestfs_mount (g, device, mountpoint);
1253 /* TestOutputList for find (2) */
1255 char path[] = "/a/b/c";
1258 r = guestfs_mkdir_p (g, path);
1263 char path[] = "/a/b/c/d";
1266 r = guestfs_touch (g, path);
1271 char directory[] = "/a/b/";
1275 r = guestfs_find (g, directory);
1279 fprintf (stderr, "test_find_2: short list returned from command\n");
1284 char expected[] = "c";
1285 if (strcmp (r[0], expected) != 0) {
1286 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1291 fprintf (stderr, "test_find_2: short list returned from command\n");
1296 char expected[] = "c/d";
1297 if (strcmp (r[1], expected) != 0) {
1298 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1303 fprintf (stderr, "test_find_2: extra elements returned from command\n");
1307 for (i = 0; r[i] != NULL; ++i)
1314 static int test_lvresize_0_skip (void)
1318 str = getenv ("SKIP_TEST_LVRESIZE_0");
1319 if (str && strcmp (str, "1") == 0) return 1;
1320 str = getenv ("SKIP_TEST_LVRESIZE");
1321 if (str && strcmp (str, "1") == 0) return 1;
1325 static int test_lvresize_0 (void)
1327 if (test_lvresize_0_skip ()) {
1328 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
1332 /* InitNone|InitEmpty for test_lvresize_0 */
1334 char device[] = "/dev/sda";
1337 r = guestfs_blockdev_setrw (g, device);
1344 r = guestfs_umount_all (g);
1351 r = guestfs_lvm_remove_all (g);
1355 /* TestOutput for lvresize (0) */
1356 char expected[] = "test content";
1358 char device[] = "/dev/sda";
1359 char lines_0[] = ",";
1366 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1371 char device[] = "/dev/sda1";
1374 r = guestfs_pvcreate (g, device);
1379 char volgroup[] = "VG";
1380 char physvols_0[] = "/dev/sda1";
1381 char *physvols[] = {
1387 r = guestfs_vgcreate (g, volgroup, physvols);
1392 char logvol[] = "LV";
1393 char volgroup[] = "VG";
1396 r = guestfs_lvcreate (g, logvol, volgroup, 10);
1401 char fstype[] = "ext2";
1402 char device[] = "/dev/VG/LV";
1405 r = guestfs_mkfs (g, fstype, device);
1410 char device[] = "/dev/VG/LV";
1411 char mountpoint[] = "/";
1414 r = guestfs_mount (g, device, mountpoint);
1419 char path[] = "/new";
1420 char content[] = "test content";
1423 r = guestfs_write_file (g, path, content, 0);
1428 char pathordevice[] = "/";
1431 r = guestfs_umount (g, pathordevice);
1436 char device[] = "/dev/VG/LV";
1439 r = guestfs_lvresize (g, device, 20);
1444 char device[] = "/dev/VG/LV";
1447 r = guestfs_e2fsck_f (g, device);
1452 char device[] = "/dev/VG/LV";
1455 r = guestfs_resize2fs (g, device);
1460 char device[] = "/dev/VG/LV";
1461 char mountpoint[] = "/";
1464 r = guestfs_mount (g, device, mountpoint);
1469 char path[] = "/new";
1472 r = guestfs_cat (g, path);
1475 if (strcmp (r, expected) != 0) {
1476 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1484 static int test_zerofree_0_skip (void)
1488 str = getenv ("SKIP_TEST_ZEROFREE_0");
1489 if (str && strcmp (str, "1") == 0) return 1;
1490 str = getenv ("SKIP_TEST_ZEROFREE");
1491 if (str && strcmp (str, "1") == 0) return 1;
1495 static int test_zerofree_0 (void)
1497 if (test_zerofree_0_skip ()) {
1498 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
1502 /* InitNone|InitEmpty for test_zerofree_0 */
1504 char device[] = "/dev/sda";
1507 r = guestfs_blockdev_setrw (g, device);
1514 r = guestfs_umount_all (g);
1521 r = guestfs_lvm_remove_all (g);
1525 /* TestOutput for zerofree (0) */
1526 char expected[] = "test file";
1528 char device[] = "/dev/sda";
1529 char lines_0[] = ",";
1536 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1541 char fstype[] = "ext3";
1542 char device[] = "/dev/sda1";
1545 r = guestfs_mkfs (g, fstype, device);
1550 char device[] = "/dev/sda1";
1551 char mountpoint[] = "/";
1554 r = guestfs_mount (g, device, mountpoint);
1559 char path[] = "/new";
1560 char content[] = "test file";
1563 r = guestfs_write_file (g, path, content, 0);
1568 char pathordevice[] = "/dev/sda1";
1571 r = guestfs_umount (g, pathordevice);
1576 char device[] = "/dev/sda1";
1579 r = guestfs_zerofree (g, device);
1584 char device[] = "/dev/sda1";
1585 char mountpoint[] = "/";
1588 r = guestfs_mount (g, device, mountpoint);
1593 char path[] = "/new";
1596 r = guestfs_cat (g, path);
1599 if (strcmp (r, expected) != 0) {
1600 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1608 static int test_hexdump_0_skip (void)
1612 str = getenv ("SKIP_TEST_HEXDUMP_0");
1613 if (str && strcmp (str, "1") == 0) return 1;
1614 str = getenv ("SKIP_TEST_HEXDUMP");
1615 if (str && strcmp (str, "1") == 0) return 1;
1619 static int test_hexdump_0 (void)
1621 if (test_hexdump_0_skip ()) {
1622 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1626 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1628 char device[] = "/dev/sda";
1631 r = guestfs_blockdev_setrw (g, device);
1638 r = guestfs_umount_all (g);
1645 r = guestfs_lvm_remove_all (g);
1650 char device[] = "/dev/sda";
1651 char lines_0[] = ",";
1658 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1663 char fstype[] = "ext2";
1664 char device[] = "/dev/sda1";
1667 r = guestfs_mkfs (g, fstype, device);
1672 char device[] = "/dev/sda1";
1673 char mountpoint[] = "/";
1676 r = guestfs_mount (g, device, mountpoint);
1680 /* TestOutput for hexdump (0) */
1681 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
1683 char path[] = "/new";
1684 char content[] = "hello\nworld\n";
1687 r = guestfs_write_file (g, path, content, 12);
1692 char path[] = "/new";
1695 r = guestfs_hexdump (g, path);
1698 if (strcmp (r, expected) != 0) {
1699 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1707 static int test_strings_e_0_skip (void)
1711 str = getenv ("SKIP_TEST_STRINGS_E_0");
1712 if (str && strcmp (str, "1") == 0) return 1;
1713 str = getenv ("SKIP_TEST_STRINGS_E");
1714 if (str && strcmp (str, "1") == 0) return 1;
1718 static int test_strings_e_0 (void)
1720 if (test_strings_e_0_skip ()) {
1721 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1725 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1727 char device[] = "/dev/sda";
1730 r = guestfs_blockdev_setrw (g, device);
1737 r = guestfs_umount_all (g);
1744 r = guestfs_lvm_remove_all (g);
1749 char device[] = "/dev/sda";
1750 char lines_0[] = ",";
1757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1762 char fstype[] = "ext2";
1763 char device[] = "/dev/sda1";
1766 r = guestfs_mkfs (g, fstype, device);
1771 char device[] = "/dev/sda1";
1772 char mountpoint[] = "/";
1775 r = guestfs_mount (g, device, mountpoint);
1779 /* TestOutputList for strings_e (0) */
1781 char path[] = "/new";
1782 char content[] = "hello\nworld\n";
1785 r = guestfs_write_file (g, path, content, 0);
1790 char encoding[] = "b";
1791 char path[] = "/new";
1795 r = guestfs_strings_e (g, encoding, path);
1799 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1803 for (i = 0; r[i] != NULL; ++i)
1810 static int test_strings_e_1_skip (void)
1814 str = getenv ("SKIP_TEST_STRINGS_E_1");
1815 if (str && strcmp (str, "1") == 0) return 1;
1816 str = getenv ("SKIP_TEST_STRINGS_E");
1817 if (str && strcmp (str, "1") == 0) return 1;
1821 static int test_strings_e_1 (void)
1823 if (test_strings_e_1_skip ()) {
1824 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1828 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1832 static int test_strings_0_skip (void)
1836 str = getenv ("SKIP_TEST_STRINGS_0");
1837 if (str && strcmp (str, "1") == 0) return 1;
1838 str = getenv ("SKIP_TEST_STRINGS");
1839 if (str && strcmp (str, "1") == 0) return 1;
1843 static int test_strings_0 (void)
1845 if (test_strings_0_skip ()) {
1846 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1850 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1852 char device[] = "/dev/sda";
1855 r = guestfs_blockdev_setrw (g, device);
1862 r = guestfs_umount_all (g);
1869 r = guestfs_lvm_remove_all (g);
1874 char device[] = "/dev/sda";
1875 char lines_0[] = ",";
1882 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1887 char fstype[] = "ext2";
1888 char device[] = "/dev/sda1";
1891 r = guestfs_mkfs (g, fstype, device);
1896 char device[] = "/dev/sda1";
1897 char mountpoint[] = "/";
1900 r = guestfs_mount (g, device, mountpoint);
1904 /* TestOutputList for strings (0) */
1906 char path[] = "/new";
1907 char content[] = "hello\nworld\n";
1910 r = guestfs_write_file (g, path, content, 0);
1915 char path[] = "/new";
1919 r = guestfs_strings (g, path);
1923 fprintf (stderr, "test_strings_0: short list returned from command\n");
1928 char expected[] = "hello";
1929 if (strcmp (r[0], expected) != 0) {
1930 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1935 fprintf (stderr, "test_strings_0: short list returned from command\n");
1940 char expected[] = "world";
1941 if (strcmp (r[1], expected) != 0) {
1942 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1947 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1951 for (i = 0; r[i] != NULL; ++i)
1958 static int test_strings_1_skip (void)
1962 str = getenv ("SKIP_TEST_STRINGS_1");
1963 if (str && strcmp (str, "1") == 0) return 1;
1964 str = getenv ("SKIP_TEST_STRINGS");
1965 if (str && strcmp (str, "1") == 0) return 1;
1969 static int test_strings_1 (void)
1971 if (test_strings_1_skip ()) {
1972 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1976 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1978 char device[] = "/dev/sda";
1981 r = guestfs_blockdev_setrw (g, device);
1988 r = guestfs_umount_all (g);
1995 r = guestfs_lvm_remove_all (g);
2000 char device[] = "/dev/sda";
2001 char lines_0[] = ",";
2008 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2013 char fstype[] = "ext2";
2014 char device[] = "/dev/sda1";
2017 r = guestfs_mkfs (g, fstype, device);
2022 char device[] = "/dev/sda1";
2023 char mountpoint[] = "/";
2026 r = guestfs_mount (g, device, mountpoint);
2030 /* TestOutputList for strings (1) */
2032 char path[] = "/new";
2035 r = guestfs_touch (g, path);
2040 char path[] = "/new";
2044 r = guestfs_strings (g, path);
2048 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2052 for (i = 0; r[i] != NULL; ++i)
2059 static int test_equal_0_skip (void)
2063 str = getenv ("SKIP_TEST_EQUAL_0");
2064 if (str && strcmp (str, "1") == 0) return 1;
2065 str = getenv ("SKIP_TEST_EQUAL");
2066 if (str && strcmp (str, "1") == 0) return 1;
2070 static int test_equal_0 (void)
2072 if (test_equal_0_skip ()) {
2073 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
2077 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2079 char device[] = "/dev/sda";
2082 r = guestfs_blockdev_setrw (g, device);
2089 r = guestfs_umount_all (g);
2096 r = guestfs_lvm_remove_all (g);
2101 char device[] = "/dev/sda";
2102 char lines_0[] = ",";
2109 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2114 char fstype[] = "ext2";
2115 char device[] = "/dev/sda1";
2118 r = guestfs_mkfs (g, fstype, device);
2123 char device[] = "/dev/sda1";
2124 char mountpoint[] = "/";
2127 r = guestfs_mount (g, device, mountpoint);
2131 /* TestOutputTrue for equal (0) */
2133 char path[] = "/file1";
2134 char content[] = "contents of a file";
2137 r = guestfs_write_file (g, path, content, 0);
2142 char src[] = "/file1";
2143 char dest[] = "/file2";
2146 r = guestfs_cp (g, src, dest);
2151 char file1[] = "/file1";
2152 char file2[] = "/file2";
2155 r = guestfs_equal (g, file1, file2);
2159 fprintf (stderr, "test_equal_0: expected true, got false\n");
2166 static int test_equal_1_skip (void)
2170 str = getenv ("SKIP_TEST_EQUAL_1");
2171 if (str && strcmp (str, "1") == 0) return 1;
2172 str = getenv ("SKIP_TEST_EQUAL");
2173 if (str && strcmp (str, "1") == 0) return 1;
2177 static int test_equal_1 (void)
2179 if (test_equal_1_skip ()) {
2180 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2184 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2186 char device[] = "/dev/sda";
2189 r = guestfs_blockdev_setrw (g, device);
2196 r = guestfs_umount_all (g);
2203 r = guestfs_lvm_remove_all (g);
2208 char device[] = "/dev/sda";
2209 char lines_0[] = ",";
2216 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2221 char fstype[] = "ext2";
2222 char device[] = "/dev/sda1";
2225 r = guestfs_mkfs (g, fstype, device);
2230 char device[] = "/dev/sda1";
2231 char mountpoint[] = "/";
2234 r = guestfs_mount (g, device, mountpoint);
2238 /* TestOutputFalse for equal (1) */
2240 char path[] = "/file1";
2241 char content[] = "contents of a file";
2244 r = guestfs_write_file (g, path, content, 0);
2249 char path[] = "/file2";
2250 char content[] = "contents of another file";
2253 r = guestfs_write_file (g, path, content, 0);
2258 char file1[] = "/file1";
2259 char file2[] = "/file2";
2262 r = guestfs_equal (g, file1, file2);
2266 fprintf (stderr, "test_equal_1: expected false, got true\n");
2273 static int test_equal_2_skip (void)
2277 str = getenv ("SKIP_TEST_EQUAL_2");
2278 if (str && strcmp (str, "1") == 0) return 1;
2279 str = getenv ("SKIP_TEST_EQUAL");
2280 if (str && strcmp (str, "1") == 0) return 1;
2284 static int test_equal_2 (void)
2286 if (test_equal_2_skip ()) {
2287 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2291 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2293 char device[] = "/dev/sda";
2296 r = guestfs_blockdev_setrw (g, device);
2303 r = guestfs_umount_all (g);
2310 r = guestfs_lvm_remove_all (g);
2315 char device[] = "/dev/sda";
2316 char lines_0[] = ",";
2323 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2328 char fstype[] = "ext2";
2329 char device[] = "/dev/sda1";
2332 r = guestfs_mkfs (g, fstype, device);
2337 char device[] = "/dev/sda1";
2338 char mountpoint[] = "/";
2341 r = guestfs_mount (g, device, mountpoint);
2345 /* TestLastFail for equal (2) */
2347 char file1[] = "/file1";
2348 char file2[] = "/file2";
2351 r = guestfs_equal (g, file1, file2);
2358 static int test_ping_daemon_0_skip (void)
2362 str = getenv ("SKIP_TEST_PING_DAEMON_0");
2363 if (str && strcmp (str, "1") == 0) return 1;
2364 str = getenv ("SKIP_TEST_PING_DAEMON");
2365 if (str && strcmp (str, "1") == 0) return 1;
2369 static int test_ping_daemon_0 (void)
2371 if (test_ping_daemon_0_skip ()) {
2372 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2376 /* InitNone|InitEmpty for test_ping_daemon_0 */
2378 char device[] = "/dev/sda";
2381 r = guestfs_blockdev_setrw (g, device);
2388 r = guestfs_umount_all (g);
2395 r = guestfs_lvm_remove_all (g);
2399 /* TestRun for ping_daemon (0) */
2403 r = guestfs_ping_daemon (g);
2410 static int test_dmesg_0_skip (void)
2414 str = getenv ("SKIP_TEST_DMESG_0");
2415 if (str && strcmp (str, "1") == 0) return 1;
2416 str = getenv ("SKIP_TEST_DMESG");
2417 if (str && strcmp (str, "1") == 0) return 1;
2421 static int test_dmesg_0 (void)
2423 if (test_dmesg_0_skip ()) {
2424 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2428 /* InitNone|InitEmpty for test_dmesg_0 */
2430 char device[] = "/dev/sda";
2433 r = guestfs_blockdev_setrw (g, device);
2440 r = guestfs_umount_all (g);
2447 r = guestfs_lvm_remove_all (g);
2451 /* TestRun for dmesg (0) */
2455 r = guestfs_dmesg (g);
2463 static int test_drop_caches_0_skip (void)
2467 str = getenv ("SKIP_TEST_DROP_CACHES_0");
2468 if (str && strcmp (str, "1") == 0) return 1;
2469 str = getenv ("SKIP_TEST_DROP_CACHES");
2470 if (str && strcmp (str, "1") == 0) return 1;
2474 static int test_drop_caches_0 (void)
2476 if (test_drop_caches_0_skip ()) {
2477 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2481 /* InitNone|InitEmpty for test_drop_caches_0 */
2483 char device[] = "/dev/sda";
2486 r = guestfs_blockdev_setrw (g, device);
2493 r = guestfs_umount_all (g);
2500 r = guestfs_lvm_remove_all (g);
2504 /* TestRun for drop_caches (0) */
2508 r = guestfs_drop_caches (g, 3);
2515 static int test_mv_0_skip (void)
2519 str = getenv ("SKIP_TEST_MV_0");
2520 if (str && strcmp (str, "1") == 0) return 1;
2521 str = getenv ("SKIP_TEST_MV");
2522 if (str && strcmp (str, "1") == 0) return 1;
2526 static int test_mv_0 (void)
2528 if (test_mv_0_skip ()) {
2529 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2533 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2535 char device[] = "/dev/sda";
2538 r = guestfs_blockdev_setrw (g, device);
2545 r = guestfs_umount_all (g);
2552 r = guestfs_lvm_remove_all (g);
2557 char device[] = "/dev/sda";
2558 char lines_0[] = ",";
2565 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2570 char fstype[] = "ext2";
2571 char device[] = "/dev/sda1";
2574 r = guestfs_mkfs (g, fstype, device);
2579 char device[] = "/dev/sda1";
2580 char mountpoint[] = "/";
2583 r = guestfs_mount (g, device, mountpoint);
2587 /* TestOutput for mv (0) */
2588 char expected[] = "file content";
2590 char path[] = "/old";
2591 char content[] = "file content";
2594 r = guestfs_write_file (g, path, content, 0);
2599 char src[] = "/old";
2600 char dest[] = "/new";
2603 r = guestfs_mv (g, src, dest);
2608 char path[] = "/new";
2611 r = guestfs_cat (g, path);
2614 if (strcmp (r, expected) != 0) {
2615 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2623 static int test_mv_1_skip (void)
2627 str = getenv ("SKIP_TEST_MV_1");
2628 if (str && strcmp (str, "1") == 0) return 1;
2629 str = getenv ("SKIP_TEST_MV");
2630 if (str && strcmp (str, "1") == 0) return 1;
2634 static int test_mv_1 (void)
2636 if (test_mv_1_skip ()) {
2637 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2641 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2643 char device[] = "/dev/sda";
2646 r = guestfs_blockdev_setrw (g, device);
2653 r = guestfs_umount_all (g);
2660 r = guestfs_lvm_remove_all (g);
2665 char device[] = "/dev/sda";
2666 char lines_0[] = ",";
2673 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2678 char fstype[] = "ext2";
2679 char device[] = "/dev/sda1";
2682 r = guestfs_mkfs (g, fstype, device);
2687 char device[] = "/dev/sda1";
2688 char mountpoint[] = "/";
2691 r = guestfs_mount (g, device, mountpoint);
2695 /* TestOutputFalse for mv (1) */
2697 char path[] = "/old";
2698 char content[] = "file content";
2701 r = guestfs_write_file (g, path, content, 0);
2706 char src[] = "/old";
2707 char dest[] = "/new";
2710 r = guestfs_mv (g, src, dest);
2715 char path[] = "/old";
2718 r = guestfs_is_file (g, path);
2722 fprintf (stderr, "test_mv_1: expected false, got true\n");
2729 static int test_cp_a_0_skip (void)
2733 str = getenv ("SKIP_TEST_CP_A_0");
2734 if (str && strcmp (str, "1") == 0) return 1;
2735 str = getenv ("SKIP_TEST_CP_A");
2736 if (str && strcmp (str, "1") == 0) return 1;
2740 static int test_cp_a_0 (void)
2742 if (test_cp_a_0_skip ()) {
2743 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2747 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2749 char device[] = "/dev/sda";
2752 r = guestfs_blockdev_setrw (g, device);
2759 r = guestfs_umount_all (g);
2766 r = guestfs_lvm_remove_all (g);
2771 char device[] = "/dev/sda";
2772 char lines_0[] = ",";
2779 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2784 char fstype[] = "ext2";
2785 char device[] = "/dev/sda1";
2788 r = guestfs_mkfs (g, fstype, device);
2793 char device[] = "/dev/sda1";
2794 char mountpoint[] = "/";
2797 r = guestfs_mount (g, device, mountpoint);
2801 /* TestOutput for cp_a (0) */
2802 char expected[] = "file content";
2804 char path[] = "/olddir";
2807 r = guestfs_mkdir (g, path);
2812 char path[] = "/newdir";
2815 r = guestfs_mkdir (g, path);
2820 char path[] = "/olddir/file";
2821 char content[] = "file content";
2824 r = guestfs_write_file (g, path, content, 0);
2829 char src[] = "/olddir";
2830 char dest[] = "/newdir";
2833 r = guestfs_cp_a (g, src, dest);
2838 char path[] = "/newdir/olddir/file";
2841 r = guestfs_cat (g, path);
2844 if (strcmp (r, expected) != 0) {
2845 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2853 static int test_cp_0_skip (void)
2857 str = getenv ("SKIP_TEST_CP_0");
2858 if (str && strcmp (str, "1") == 0) return 1;
2859 str = getenv ("SKIP_TEST_CP");
2860 if (str && strcmp (str, "1") == 0) return 1;
2864 static int test_cp_0 (void)
2866 if (test_cp_0_skip ()) {
2867 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2871 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2873 char device[] = "/dev/sda";
2876 r = guestfs_blockdev_setrw (g, device);
2883 r = guestfs_umount_all (g);
2890 r = guestfs_lvm_remove_all (g);
2895 char device[] = "/dev/sda";
2896 char lines_0[] = ",";
2903 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2908 char fstype[] = "ext2";
2909 char device[] = "/dev/sda1";
2912 r = guestfs_mkfs (g, fstype, device);
2917 char device[] = "/dev/sda1";
2918 char mountpoint[] = "/";
2921 r = guestfs_mount (g, device, mountpoint);
2925 /* TestOutput for cp (0) */
2926 char expected[] = "file content";
2928 char path[] = "/old";
2929 char content[] = "file content";
2932 r = guestfs_write_file (g, path, content, 0);
2937 char src[] = "/old";
2938 char dest[] = "/new";
2941 r = guestfs_cp (g, src, dest);
2946 char path[] = "/new";
2949 r = guestfs_cat (g, path);
2952 if (strcmp (r, expected) != 0) {
2953 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2961 static int test_cp_1_skip (void)
2965 str = getenv ("SKIP_TEST_CP_1");
2966 if (str && strcmp (str, "1") == 0) return 1;
2967 str = getenv ("SKIP_TEST_CP");
2968 if (str && strcmp (str, "1") == 0) return 1;
2972 static int test_cp_1 (void)
2974 if (test_cp_1_skip ()) {
2975 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2979 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2981 char device[] = "/dev/sda";
2984 r = guestfs_blockdev_setrw (g, device);
2991 r = guestfs_umount_all (g);
2998 r = guestfs_lvm_remove_all (g);
3003 char device[] = "/dev/sda";
3004 char lines_0[] = ",";
3011 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3016 char fstype[] = "ext2";
3017 char device[] = "/dev/sda1";
3020 r = guestfs_mkfs (g, fstype, device);
3025 char device[] = "/dev/sda1";
3026 char mountpoint[] = "/";
3029 r = guestfs_mount (g, device, mountpoint);
3033 /* TestOutputTrue for cp (1) */
3035 char path[] = "/old";
3036 char content[] = "file content";
3039 r = guestfs_write_file (g, path, content, 0);
3044 char src[] = "/old";
3045 char dest[] = "/new";
3048 r = guestfs_cp (g, src, dest);
3053 char path[] = "/old";
3056 r = guestfs_is_file (g, path);
3060 fprintf (stderr, "test_cp_1: expected true, got false\n");
3067 static int test_cp_2_skip (void)
3071 str = getenv ("SKIP_TEST_CP_2");
3072 if (str && strcmp (str, "1") == 0) return 1;
3073 str = getenv ("SKIP_TEST_CP");
3074 if (str && strcmp (str, "1") == 0) return 1;
3078 static int test_cp_2 (void)
3080 if (test_cp_2_skip ()) {
3081 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
3085 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3087 char device[] = "/dev/sda";
3090 r = guestfs_blockdev_setrw (g, device);
3097 r = guestfs_umount_all (g);
3104 r = guestfs_lvm_remove_all (g);
3109 char device[] = "/dev/sda";
3110 char lines_0[] = ",";
3117 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3122 char fstype[] = "ext2";
3123 char device[] = "/dev/sda1";
3126 r = guestfs_mkfs (g, fstype, device);
3131 char device[] = "/dev/sda1";
3132 char mountpoint[] = "/";
3135 r = guestfs_mount (g, device, mountpoint);
3139 /* TestOutput for cp (2) */
3140 char expected[] = "file content";
3142 char path[] = "/old";
3143 char content[] = "file content";
3146 r = guestfs_write_file (g, path, content, 0);
3151 char path[] = "/dir";
3154 r = guestfs_mkdir (g, path);
3159 char src[] = "/old";
3160 char dest[] = "/dir/new";
3163 r = guestfs_cp (g, src, dest);
3168 char path[] = "/dir/new";
3171 r = guestfs_cat (g, path);
3174 if (strcmp (r, expected) != 0) {
3175 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3183 static int test_grub_install_0_skip (void)
3187 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3188 if (str && strcmp (str, "1") == 0) return 1;
3189 str = getenv ("SKIP_TEST_GRUB_INSTALL");
3190 if (str && strcmp (str, "1") == 0) return 1;
3194 static int test_grub_install_0 (void)
3196 if (test_grub_install_0_skip ()) {
3197 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3201 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3203 char device[] = "/dev/sda";
3206 r = guestfs_blockdev_setrw (g, device);
3213 r = guestfs_umount_all (g);
3220 r = guestfs_lvm_remove_all (g);
3225 char device[] = "/dev/sda";
3226 char lines_0[] = ",";
3233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3238 char fstype[] = "ext2";
3239 char device[] = "/dev/sda1";
3242 r = guestfs_mkfs (g, fstype, device);
3247 char device[] = "/dev/sda1";
3248 char mountpoint[] = "/";
3251 r = guestfs_mount (g, device, mountpoint);
3255 /* TestOutputTrue for grub_install (0) */
3258 char device[] = "/dev/sda1";
3261 r = guestfs_grub_install (g, root, device);
3266 char path[] = "/boot";
3269 r = guestfs_is_dir (g, path);
3273 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3280 static int test_zero_0_skip (void)
3284 str = getenv ("SKIP_TEST_ZERO_0");
3285 if (str && strcmp (str, "1") == 0) return 1;
3286 str = getenv ("SKIP_TEST_ZERO");
3287 if (str && strcmp (str, "1") == 0) return 1;
3291 static int test_zero_0 (void)
3293 if (test_zero_0_skip ()) {
3294 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3298 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3300 char device[] = "/dev/sda";
3303 r = guestfs_blockdev_setrw (g, device);
3310 r = guestfs_umount_all (g);
3317 r = guestfs_lvm_remove_all (g);
3322 char device[] = "/dev/sda";
3323 char lines_0[] = ",";
3330 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3335 char fstype[] = "ext2";
3336 char device[] = "/dev/sda1";
3339 r = guestfs_mkfs (g, fstype, device);
3344 char device[] = "/dev/sda1";
3345 char mountpoint[] = "/";
3348 r = guestfs_mount (g, device, mountpoint);
3352 /* TestOutput for zero (0) */
3353 char expected[] = "data";
3355 char pathordevice[] = "/dev/sda1";
3358 r = guestfs_umount (g, pathordevice);
3363 char device[] = "/dev/sda1";
3366 r = guestfs_zero (g, device);
3371 char path[] = "/dev/sda1";
3374 r = guestfs_file (g, path);
3377 if (strcmp (r, expected) != 0) {
3378 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3386 static int test_fsck_0_skip (void)
3390 str = getenv ("SKIP_TEST_FSCK_0");
3391 if (str && strcmp (str, "1") == 0) return 1;
3392 str = getenv ("SKIP_TEST_FSCK");
3393 if (str && strcmp (str, "1") == 0) return 1;
3397 static int test_fsck_0 (void)
3399 if (test_fsck_0_skip ()) {
3400 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3404 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3406 char device[] = "/dev/sda";
3409 r = guestfs_blockdev_setrw (g, device);
3416 r = guestfs_umount_all (g);
3423 r = guestfs_lvm_remove_all (g);
3428 char device[] = "/dev/sda";
3429 char lines_0[] = ",";
3436 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3441 char fstype[] = "ext2";
3442 char device[] = "/dev/sda1";
3445 r = guestfs_mkfs (g, fstype, device);
3450 char device[] = "/dev/sda1";
3451 char mountpoint[] = "/";
3454 r = guestfs_mount (g, device, mountpoint);
3458 /* TestOutputInt for fsck (0) */
3460 char pathordevice[] = "/dev/sda1";
3463 r = guestfs_umount (g, pathordevice);
3468 char fstype[] = "ext2";
3469 char device[] = "/dev/sda1";
3472 r = guestfs_fsck (g, fstype, device);
3476 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
3483 static int test_fsck_1_skip (void)
3487 str = getenv ("SKIP_TEST_FSCK_1");
3488 if (str && strcmp (str, "1") == 0) return 1;
3489 str = getenv ("SKIP_TEST_FSCK");
3490 if (str && strcmp (str, "1") == 0) return 1;
3494 static int test_fsck_1 (void)
3496 if (test_fsck_1_skip ()) {
3497 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3501 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3503 char device[] = "/dev/sda";
3506 r = guestfs_blockdev_setrw (g, device);
3513 r = guestfs_umount_all (g);
3520 r = guestfs_lvm_remove_all (g);
3525 char device[] = "/dev/sda";
3526 char lines_0[] = ",";
3533 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3538 char fstype[] = "ext2";
3539 char device[] = "/dev/sda1";
3542 r = guestfs_mkfs (g, fstype, device);
3547 char device[] = "/dev/sda1";
3548 char mountpoint[] = "/";
3551 r = guestfs_mount (g, device, mountpoint);
3555 /* TestOutputInt for fsck (1) */
3557 char pathordevice[] = "/dev/sda1";
3560 r = guestfs_umount (g, pathordevice);
3565 char device[] = "/dev/sda1";
3568 r = guestfs_zero (g, device);
3573 char fstype[] = "ext2";
3574 char device[] = "/dev/sda1";
3577 r = guestfs_fsck (g, fstype, device);
3581 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
3588 static int test_set_e2uuid_0_skip (void)
3592 str = getenv ("SKIP_TEST_SET_E2UUID_0");
3593 if (str && strcmp (str, "1") == 0) return 1;
3594 str = getenv ("SKIP_TEST_SET_E2UUID");
3595 if (str && strcmp (str, "1") == 0) return 1;
3599 static int test_set_e2uuid_0 (void)
3601 if (test_set_e2uuid_0_skip ()) {
3602 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3606 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3608 char device[] = "/dev/sda";
3611 r = guestfs_blockdev_setrw (g, device);
3618 r = guestfs_umount_all (g);
3625 r = guestfs_lvm_remove_all (g);
3630 char device[] = "/dev/sda";
3631 char lines_0[] = ",";
3638 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3643 char fstype[] = "ext2";
3644 char device[] = "/dev/sda1";
3647 r = guestfs_mkfs (g, fstype, device);
3652 char device[] = "/dev/sda1";
3653 char mountpoint[] = "/";
3656 r = guestfs_mount (g, device, mountpoint);
3660 /* TestOutput for set_e2uuid (0) */
3661 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3663 char device[] = "/dev/sda1";
3664 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3667 r = guestfs_set_e2uuid (g, device, uuid);
3672 char device[] = "/dev/sda1";
3675 r = guestfs_get_e2uuid (g, device);
3678 if (strcmp (r, expected) != 0) {
3679 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3687 static int test_set_e2uuid_1_skip (void)
3691 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3692 if (str && strcmp (str, "1") == 0) return 1;
3693 str = getenv ("SKIP_TEST_SET_E2UUID");
3694 if (str && strcmp (str, "1") == 0) return 1;
3698 static int test_set_e2uuid_1 (void)
3700 if (test_set_e2uuid_1_skip ()) {
3701 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3705 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3707 char device[] = "/dev/sda";
3710 r = guestfs_blockdev_setrw (g, device);
3717 r = guestfs_umount_all (g);
3724 r = guestfs_lvm_remove_all (g);
3729 char device[] = "/dev/sda";
3730 char lines_0[] = ",";
3737 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3742 char fstype[] = "ext2";
3743 char device[] = "/dev/sda1";
3746 r = guestfs_mkfs (g, fstype, device);
3751 char device[] = "/dev/sda1";
3752 char mountpoint[] = "/";
3755 r = guestfs_mount (g, device, mountpoint);
3759 /* TestOutput for set_e2uuid (1) */
3760 char expected[] = "";
3762 char device[] = "/dev/sda1";
3763 char uuid[] = "clear";
3766 r = guestfs_set_e2uuid (g, device, uuid);
3771 char device[] = "/dev/sda1";
3774 r = guestfs_get_e2uuid (g, device);
3777 if (strcmp (r, expected) != 0) {
3778 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3786 static int test_set_e2uuid_2_skip (void)
3790 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3791 if (str && strcmp (str, "1") == 0) return 1;
3792 str = getenv ("SKIP_TEST_SET_E2UUID");
3793 if (str && strcmp (str, "1") == 0) return 1;
3797 static int test_set_e2uuid_2 (void)
3799 if (test_set_e2uuid_2_skip ()) {
3800 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3804 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3806 char device[] = "/dev/sda";
3809 r = guestfs_blockdev_setrw (g, device);
3816 r = guestfs_umount_all (g);
3823 r = guestfs_lvm_remove_all (g);
3828 char device[] = "/dev/sda";
3829 char lines_0[] = ",";
3836 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3841 char fstype[] = "ext2";
3842 char device[] = "/dev/sda1";
3845 r = guestfs_mkfs (g, fstype, device);
3850 char device[] = "/dev/sda1";
3851 char mountpoint[] = "/";
3854 r = guestfs_mount (g, device, mountpoint);
3858 /* TestRun for set_e2uuid (2) */
3860 char device[] = "/dev/sda1";
3861 char uuid[] = "random";
3864 r = guestfs_set_e2uuid (g, device, uuid);
3871 static int test_set_e2uuid_3_skip (void)
3875 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3876 if (str && strcmp (str, "1") == 0) return 1;
3877 str = getenv ("SKIP_TEST_SET_E2UUID");
3878 if (str && strcmp (str, "1") == 0) return 1;
3882 static int test_set_e2uuid_3 (void)
3884 if (test_set_e2uuid_3_skip ()) {
3885 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3889 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3891 char device[] = "/dev/sda";
3894 r = guestfs_blockdev_setrw (g, device);
3901 r = guestfs_umount_all (g);
3908 r = guestfs_lvm_remove_all (g);
3913 char device[] = "/dev/sda";
3914 char lines_0[] = ",";
3921 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3926 char fstype[] = "ext2";
3927 char device[] = "/dev/sda1";
3930 r = guestfs_mkfs (g, fstype, device);
3935 char device[] = "/dev/sda1";
3936 char mountpoint[] = "/";
3939 r = guestfs_mount (g, device, mountpoint);
3943 /* TestRun for set_e2uuid (3) */
3945 char device[] = "/dev/sda1";
3946 char uuid[] = "time";
3949 r = guestfs_set_e2uuid (g, device, uuid);
3956 static int test_set_e2label_0_skip (void)
3960 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3961 if (str && strcmp (str, "1") == 0) return 1;
3962 str = getenv ("SKIP_TEST_SET_E2LABEL");
3963 if (str && strcmp (str, "1") == 0) return 1;
3967 static int test_set_e2label_0 (void)
3969 if (test_set_e2label_0_skip ()) {
3970 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3974 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3976 char device[] = "/dev/sda";
3979 r = guestfs_blockdev_setrw (g, device);
3986 r = guestfs_umount_all (g);
3993 r = guestfs_lvm_remove_all (g);
3998 char device[] = "/dev/sda";
3999 char lines_0[] = ",";
4006 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4011 char fstype[] = "ext2";
4012 char device[] = "/dev/sda1";
4015 r = guestfs_mkfs (g, fstype, device);
4020 char device[] = "/dev/sda1";
4021 char mountpoint[] = "/";
4024 r = guestfs_mount (g, device, mountpoint);
4028 /* TestOutput for set_e2label (0) */
4029 char expected[] = "testlabel";
4031 char device[] = "/dev/sda1";
4032 char label[] = "testlabel";
4035 r = guestfs_set_e2label (g, device, label);
4040 char device[] = "/dev/sda1";
4043 r = guestfs_get_e2label (g, device);
4046 if (strcmp (r, expected) != 0) {
4047 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
4055 static int test_pvremove_0_skip (void)
4059 str = getenv ("SKIP_TEST_PVREMOVE_0");
4060 if (str && strcmp (str, "1") == 0) return 1;
4061 str = getenv ("SKIP_TEST_PVREMOVE");
4062 if (str && strcmp (str, "1") == 0) return 1;
4066 static int test_pvremove_0 (void)
4068 if (test_pvremove_0_skip ()) {
4069 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
4073 /* InitNone|InitEmpty for test_pvremove_0 */
4075 char device[] = "/dev/sda";
4078 r = guestfs_blockdev_setrw (g, device);
4085 r = guestfs_umount_all (g);
4092 r = guestfs_lvm_remove_all (g);
4096 /* TestOutputListOfDevices for pvremove (0) */
4098 char device[] = "/dev/sda";
4099 char lines_0[] = ",";
4106 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4111 char device[] = "/dev/sda1";
4114 r = guestfs_pvcreate (g, device);
4119 char volgroup[] = "VG";
4120 char physvols_0[] = "/dev/sda1";
4121 char *physvols[] = {
4127 r = guestfs_vgcreate (g, volgroup, physvols);
4132 char logvol[] = "LV1";
4133 char volgroup[] = "VG";
4136 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4141 char logvol[] = "LV2";
4142 char volgroup[] = "VG";
4145 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4150 char vgname[] = "VG";
4153 r = guestfs_vgremove (g, vgname);
4158 char device[] = "/dev/sda1";
4161 r = guestfs_pvremove (g, device);
4169 r = guestfs_lvs (g);
4173 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4177 for (i = 0; r[i] != NULL; ++i)
4184 static int test_pvremove_1_skip (void)
4188 str = getenv ("SKIP_TEST_PVREMOVE_1");
4189 if (str && strcmp (str, "1") == 0) return 1;
4190 str = getenv ("SKIP_TEST_PVREMOVE");
4191 if (str && strcmp (str, "1") == 0) return 1;
4195 static int test_pvremove_1 (void)
4197 if (test_pvremove_1_skip ()) {
4198 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
4202 /* InitNone|InitEmpty for test_pvremove_1 */
4204 char device[] = "/dev/sda";
4207 r = guestfs_blockdev_setrw (g, device);
4214 r = guestfs_umount_all (g);
4221 r = guestfs_lvm_remove_all (g);
4225 /* TestOutputListOfDevices for pvremove (1) */
4227 char device[] = "/dev/sda";
4228 char lines_0[] = ",";
4235 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4240 char device[] = "/dev/sda1";
4243 r = guestfs_pvcreate (g, device);
4248 char volgroup[] = "VG";
4249 char physvols_0[] = "/dev/sda1";
4250 char *physvols[] = {
4256 r = guestfs_vgcreate (g, volgroup, physvols);
4261 char logvol[] = "LV1";
4262 char volgroup[] = "VG";
4265 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4270 char logvol[] = "LV2";
4271 char volgroup[] = "VG";
4274 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4279 char vgname[] = "VG";
4282 r = guestfs_vgremove (g, vgname);
4287 char device[] = "/dev/sda1";
4290 r = guestfs_pvremove (g, device);
4298 r = guestfs_vgs (g);
4302 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4306 for (i = 0; r[i] != NULL; ++i)
4313 static int test_pvremove_2_skip (void)
4317 str = getenv ("SKIP_TEST_PVREMOVE_2");
4318 if (str && strcmp (str, "1") == 0) return 1;
4319 str = getenv ("SKIP_TEST_PVREMOVE");
4320 if (str && strcmp (str, "1") == 0) return 1;
4324 static int test_pvremove_2 (void)
4326 if (test_pvremove_2_skip ()) {
4327 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
4331 /* InitNone|InitEmpty for test_pvremove_2 */
4333 char device[] = "/dev/sda";
4336 r = guestfs_blockdev_setrw (g, device);
4343 r = guestfs_umount_all (g);
4350 r = guestfs_lvm_remove_all (g);
4354 /* TestOutputListOfDevices for pvremove (2) */
4356 char device[] = "/dev/sda";
4357 char lines_0[] = ",";
4364 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4369 char device[] = "/dev/sda1";
4372 r = guestfs_pvcreate (g, device);
4377 char volgroup[] = "VG";
4378 char physvols_0[] = "/dev/sda1";
4379 char *physvols[] = {
4385 r = guestfs_vgcreate (g, volgroup, physvols);
4390 char logvol[] = "LV1";
4391 char volgroup[] = "VG";
4394 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4399 char logvol[] = "LV2";
4400 char volgroup[] = "VG";
4403 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4408 char vgname[] = "VG";
4411 r = guestfs_vgremove (g, vgname);
4416 char device[] = "/dev/sda1";
4419 r = guestfs_pvremove (g, device);
4427 r = guestfs_pvs (g);
4431 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4435 for (i = 0; r[i] != NULL; ++i)
4442 static int test_vgremove_0_skip (void)
4446 str = getenv ("SKIP_TEST_VGREMOVE_0");
4447 if (str && strcmp (str, "1") == 0) return 1;
4448 str = getenv ("SKIP_TEST_VGREMOVE");
4449 if (str && strcmp (str, "1") == 0) return 1;
4453 static int test_vgremove_0 (void)
4455 if (test_vgremove_0_skip ()) {
4456 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4460 /* InitNone|InitEmpty for test_vgremove_0 */
4462 char device[] = "/dev/sda";
4465 r = guestfs_blockdev_setrw (g, device);
4472 r = guestfs_umount_all (g);
4479 r = guestfs_lvm_remove_all (g);
4483 /* TestOutputList for vgremove (0) */
4485 char device[] = "/dev/sda";
4486 char lines_0[] = ",";
4493 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4498 char device[] = "/dev/sda1";
4501 r = guestfs_pvcreate (g, device);
4506 char volgroup[] = "VG";
4507 char physvols_0[] = "/dev/sda1";
4508 char *physvols[] = {
4514 r = guestfs_vgcreate (g, volgroup, physvols);
4519 char logvol[] = "LV1";
4520 char volgroup[] = "VG";
4523 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4528 char logvol[] = "LV2";
4529 char volgroup[] = "VG";
4532 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4537 char vgname[] = "VG";
4540 r = guestfs_vgremove (g, vgname);
4548 r = guestfs_lvs (g);
4552 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4556 for (i = 0; r[i] != NULL; ++i)
4563 static int test_vgremove_1_skip (void)
4567 str = getenv ("SKIP_TEST_VGREMOVE_1");
4568 if (str && strcmp (str, "1") == 0) return 1;
4569 str = getenv ("SKIP_TEST_VGREMOVE");
4570 if (str && strcmp (str, "1") == 0) return 1;
4574 static int test_vgremove_1 (void)
4576 if (test_vgremove_1_skip ()) {
4577 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4581 /* InitNone|InitEmpty for test_vgremove_1 */
4583 char device[] = "/dev/sda";
4586 r = guestfs_blockdev_setrw (g, device);
4593 r = guestfs_umount_all (g);
4600 r = guestfs_lvm_remove_all (g);
4604 /* TestOutputList for vgremove (1) */
4606 char device[] = "/dev/sda";
4607 char lines_0[] = ",";
4614 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4619 char device[] = "/dev/sda1";
4622 r = guestfs_pvcreate (g, device);
4627 char volgroup[] = "VG";
4628 char physvols_0[] = "/dev/sda1";
4629 char *physvols[] = {
4635 r = guestfs_vgcreate (g, volgroup, physvols);
4640 char logvol[] = "LV1";
4641 char volgroup[] = "VG";
4644 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4649 char logvol[] = "LV2";
4650 char volgroup[] = "VG";
4653 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4658 char vgname[] = "VG";
4661 r = guestfs_vgremove (g, vgname);
4669 r = guestfs_vgs (g);
4673 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4677 for (i = 0; r[i] != NULL; ++i)
4684 static int test_lvremove_0_skip (void)
4688 str = getenv ("SKIP_TEST_LVREMOVE_0");
4689 if (str && strcmp (str, "1") == 0) return 1;
4690 str = getenv ("SKIP_TEST_LVREMOVE");
4691 if (str && strcmp (str, "1") == 0) return 1;
4695 static int test_lvremove_0 (void)
4697 if (test_lvremove_0_skip ()) {
4698 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4702 /* InitNone|InitEmpty for test_lvremove_0 */
4704 char device[] = "/dev/sda";
4707 r = guestfs_blockdev_setrw (g, device);
4714 r = guestfs_umount_all (g);
4721 r = guestfs_lvm_remove_all (g);
4725 /* TestOutputList for lvremove (0) */
4727 char device[] = "/dev/sda";
4728 char lines_0[] = ",";
4735 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4740 char device[] = "/dev/sda1";
4743 r = guestfs_pvcreate (g, device);
4748 char volgroup[] = "VG";
4749 char physvols_0[] = "/dev/sda1";
4750 char *physvols[] = {
4756 r = guestfs_vgcreate (g, volgroup, physvols);
4761 char logvol[] = "LV1";
4762 char volgroup[] = "VG";
4765 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4770 char logvol[] = "LV2";
4771 char volgroup[] = "VG";
4774 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4779 char device[] = "/dev/VG/LV1";
4782 r = guestfs_lvremove (g, device);
4790 r = guestfs_lvs (g);
4794 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4799 char expected[] = "/dev/VG/LV2";
4800 if (strcmp (r[0], expected) != 0) {
4801 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4806 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4810 for (i = 0; r[i] != NULL; ++i)
4817 static int test_lvremove_1_skip (void)
4821 str = getenv ("SKIP_TEST_LVREMOVE_1");
4822 if (str && strcmp (str, "1") == 0) return 1;
4823 str = getenv ("SKIP_TEST_LVREMOVE");
4824 if (str && strcmp (str, "1") == 0) return 1;
4828 static int test_lvremove_1 (void)
4830 if (test_lvremove_1_skip ()) {
4831 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4835 /* InitNone|InitEmpty for test_lvremove_1 */
4837 char device[] = "/dev/sda";
4840 r = guestfs_blockdev_setrw (g, device);
4847 r = guestfs_umount_all (g);
4854 r = guestfs_lvm_remove_all (g);
4858 /* TestOutputList for lvremove (1) */
4860 char device[] = "/dev/sda";
4861 char lines_0[] = ",";
4868 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4873 char device[] = "/dev/sda1";
4876 r = guestfs_pvcreate (g, device);
4881 char volgroup[] = "VG";
4882 char physvols_0[] = "/dev/sda1";
4883 char *physvols[] = {
4889 r = guestfs_vgcreate (g, volgroup, physvols);
4894 char logvol[] = "LV1";
4895 char volgroup[] = "VG";
4898 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4903 char logvol[] = "LV2";
4904 char volgroup[] = "VG";
4907 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4912 char device[] = "/dev/VG";
4915 r = guestfs_lvremove (g, device);
4923 r = guestfs_lvs (g);
4927 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4931 for (i = 0; r[i] != NULL; ++i)
4938 static int test_lvremove_2_skip (void)
4942 str = getenv ("SKIP_TEST_LVREMOVE_2");
4943 if (str && strcmp (str, "1") == 0) return 1;
4944 str = getenv ("SKIP_TEST_LVREMOVE");
4945 if (str && strcmp (str, "1") == 0) return 1;
4949 static int test_lvremove_2 (void)
4951 if (test_lvremove_2_skip ()) {
4952 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4956 /* InitNone|InitEmpty for test_lvremove_2 */
4958 char device[] = "/dev/sda";
4961 r = guestfs_blockdev_setrw (g, device);
4968 r = guestfs_umount_all (g);
4975 r = guestfs_lvm_remove_all (g);
4979 /* TestOutputList for lvremove (2) */
4981 char device[] = "/dev/sda";
4982 char lines_0[] = ",";
4989 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4994 char device[] = "/dev/sda1";
4997 r = guestfs_pvcreate (g, device);
5002 char volgroup[] = "VG";
5003 char physvols_0[] = "/dev/sda1";
5004 char *physvols[] = {
5010 r = guestfs_vgcreate (g, volgroup, physvols);
5015 char logvol[] = "LV1";
5016 char volgroup[] = "VG";
5019 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5024 char logvol[] = "LV2";
5025 char volgroup[] = "VG";
5028 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5033 char device[] = "/dev/VG";
5036 r = guestfs_lvremove (g, device);
5044 r = guestfs_vgs (g);
5048 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5053 char expected[] = "VG";
5054 if (strcmp (r[0], expected) != 0) {
5055 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5060 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5064 for (i = 0; r[i] != NULL; ++i)
5071 static int test_mount_ro_0_skip (void)
5075 str = getenv ("SKIP_TEST_MOUNT_RO_0");
5076 if (str && strcmp (str, "1") == 0) return 1;
5077 str = getenv ("SKIP_TEST_MOUNT_RO");
5078 if (str && strcmp (str, "1") == 0) return 1;
5082 static int test_mount_ro_0 (void)
5084 if (test_mount_ro_0_skip ()) {
5085 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
5089 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5091 char device[] = "/dev/sda";
5094 r = guestfs_blockdev_setrw (g, device);
5101 r = guestfs_umount_all (g);
5108 r = guestfs_lvm_remove_all (g);
5113 char device[] = "/dev/sda";
5114 char lines_0[] = ",";
5121 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5126 char fstype[] = "ext2";
5127 char device[] = "/dev/sda1";
5130 r = guestfs_mkfs (g, fstype, device);
5135 char device[] = "/dev/sda1";
5136 char mountpoint[] = "/";
5139 r = guestfs_mount (g, device, mountpoint);
5143 /* TestLastFail for mount_ro (0) */
5145 char pathordevice[] = "/";
5148 r = guestfs_umount (g, pathordevice);
5153 char device[] = "/dev/sda1";
5154 char mountpoint[] = "/";
5157 r = guestfs_mount_ro (g, device, mountpoint);
5162 char path[] = "/new";
5165 r = guestfs_touch (g, path);
5172 static int test_mount_ro_1_skip (void)
5176 str = getenv ("SKIP_TEST_MOUNT_RO_1");
5177 if (str && strcmp (str, "1") == 0) return 1;
5178 str = getenv ("SKIP_TEST_MOUNT_RO");
5179 if (str && strcmp (str, "1") == 0) return 1;
5183 static int test_mount_ro_1 (void)
5185 if (test_mount_ro_1_skip ()) {
5186 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5190 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5192 char device[] = "/dev/sda";
5195 r = guestfs_blockdev_setrw (g, device);
5202 r = guestfs_umount_all (g);
5209 r = guestfs_lvm_remove_all (g);
5214 char device[] = "/dev/sda";
5215 char lines_0[] = ",";
5222 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5227 char fstype[] = "ext2";
5228 char device[] = "/dev/sda1";
5231 r = guestfs_mkfs (g, fstype, device);
5236 char device[] = "/dev/sda1";
5237 char mountpoint[] = "/";
5240 r = guestfs_mount (g, device, mountpoint);
5244 /* TestOutput for mount_ro (1) */
5245 char expected[] = "data";
5247 char path[] = "/new";
5248 char content[] = "data";
5251 r = guestfs_write_file (g, path, content, 0);
5256 char pathordevice[] = "/";
5259 r = guestfs_umount (g, pathordevice);
5264 char device[] = "/dev/sda1";
5265 char mountpoint[] = "/";
5268 r = guestfs_mount_ro (g, device, mountpoint);
5273 char path[] = "/new";
5276 r = guestfs_cat (g, path);
5279 if (strcmp (r, expected) != 0) {
5280 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5288 static int test_tgz_in_0_skip (void)
5292 str = getenv ("SKIP_TEST_TGZ_IN_0");
5293 if (str && strcmp (str, "1") == 0) return 1;
5294 str = getenv ("SKIP_TEST_TGZ_IN");
5295 if (str && strcmp (str, "1") == 0) return 1;
5299 static int test_tgz_in_0 (void)
5301 if (test_tgz_in_0_skip ()) {
5302 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5306 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5308 char device[] = "/dev/sda";
5311 r = guestfs_blockdev_setrw (g, device);
5318 r = guestfs_umount_all (g);
5325 r = guestfs_lvm_remove_all (g);
5330 char device[] = "/dev/sda";
5331 char lines_0[] = ",";
5338 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5343 char fstype[] = "ext2";
5344 char device[] = "/dev/sda1";
5347 r = guestfs_mkfs (g, fstype, device);
5352 char device[] = "/dev/sda1";
5353 char mountpoint[] = "/";
5356 r = guestfs_mount (g, device, mountpoint);
5360 /* TestOutput for tgz_in (0) */
5361 char expected[] = "hello\n";
5363 char directory[] = "/";
5366 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5371 char path[] = "/hello";
5374 r = guestfs_cat (g, path);
5377 if (strcmp (r, expected) != 0) {
5378 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5386 static int test_tar_in_0_skip (void)
5390 str = getenv ("SKIP_TEST_TAR_IN_0");
5391 if (str && strcmp (str, "1") == 0) return 1;
5392 str = getenv ("SKIP_TEST_TAR_IN");
5393 if (str && strcmp (str, "1") == 0) return 1;
5397 static int test_tar_in_0 (void)
5399 if (test_tar_in_0_skip ()) {
5400 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5404 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5406 char device[] = "/dev/sda";
5409 r = guestfs_blockdev_setrw (g, device);
5416 r = guestfs_umount_all (g);
5423 r = guestfs_lvm_remove_all (g);
5428 char device[] = "/dev/sda";
5429 char lines_0[] = ",";
5436 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5441 char fstype[] = "ext2";
5442 char device[] = "/dev/sda1";
5445 r = guestfs_mkfs (g, fstype, device);
5450 char device[] = "/dev/sda1";
5451 char mountpoint[] = "/";
5454 r = guestfs_mount (g, device, mountpoint);
5458 /* TestOutput for tar_in (0) */
5459 char expected[] = "hello\n";
5461 char directory[] = "/";
5464 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5469 char path[] = "/hello";
5472 r = guestfs_cat (g, path);
5475 if (strcmp (r, expected) != 0) {
5476 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5484 static int test_checksum_0_skip (void)
5488 str = getenv ("SKIP_TEST_CHECKSUM_0");
5489 if (str && strcmp (str, "1") == 0) return 1;
5490 str = getenv ("SKIP_TEST_CHECKSUM");
5491 if (str && strcmp (str, "1") == 0) return 1;
5495 static int test_checksum_0 (void)
5497 if (test_checksum_0_skip ()) {
5498 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5502 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5504 char device[] = "/dev/sda";
5507 r = guestfs_blockdev_setrw (g, device);
5514 r = guestfs_umount_all (g);
5521 r = guestfs_lvm_remove_all (g);
5526 char device[] = "/dev/sda";
5527 char lines_0[] = ",";
5534 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5539 char fstype[] = "ext2";
5540 char device[] = "/dev/sda1";
5543 r = guestfs_mkfs (g, fstype, device);
5548 char device[] = "/dev/sda1";
5549 char mountpoint[] = "/";
5552 r = guestfs_mount (g, device, mountpoint);
5556 /* TestOutput for checksum (0) */
5557 char expected[] = "935282863";
5559 char path[] = "/new";
5560 char content[] = "test\n";
5563 r = guestfs_write_file (g, path, content, 0);
5568 char csumtype[] = "crc";
5569 char path[] = "/new";
5572 r = guestfs_checksum (g, csumtype, path);
5575 if (strcmp (r, expected) != 0) {
5576 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5584 static int test_checksum_1_skip (void)
5588 str = getenv ("SKIP_TEST_CHECKSUM_1");
5589 if (str && strcmp (str, "1") == 0) return 1;
5590 str = getenv ("SKIP_TEST_CHECKSUM");
5591 if (str && strcmp (str, "1") == 0) return 1;
5595 static int test_checksum_1 (void)
5597 if (test_checksum_1_skip ()) {
5598 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5602 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5604 char device[] = "/dev/sda";
5607 r = guestfs_blockdev_setrw (g, device);
5614 r = guestfs_umount_all (g);
5621 r = guestfs_lvm_remove_all (g);
5626 char device[] = "/dev/sda";
5627 char lines_0[] = ",";
5634 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5639 char fstype[] = "ext2";
5640 char device[] = "/dev/sda1";
5643 r = guestfs_mkfs (g, fstype, device);
5648 char device[] = "/dev/sda1";
5649 char mountpoint[] = "/";
5652 r = guestfs_mount (g, device, mountpoint);
5656 /* TestLastFail for checksum (1) */
5658 char csumtype[] = "crc";
5659 char path[] = "/new";
5662 r = guestfs_checksum (g, csumtype, path);
5670 static int test_checksum_2_skip (void)
5674 str = getenv ("SKIP_TEST_CHECKSUM_2");
5675 if (str && strcmp (str, "1") == 0) return 1;
5676 str = getenv ("SKIP_TEST_CHECKSUM");
5677 if (str && strcmp (str, "1") == 0) return 1;
5681 static int test_checksum_2 (void)
5683 if (test_checksum_2_skip ()) {
5684 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5688 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5690 char device[] = "/dev/sda";
5693 r = guestfs_blockdev_setrw (g, device);
5700 r = guestfs_umount_all (g);
5707 r = guestfs_lvm_remove_all (g);
5712 char device[] = "/dev/sda";
5713 char lines_0[] = ",";
5720 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5725 char fstype[] = "ext2";
5726 char device[] = "/dev/sda1";
5729 r = guestfs_mkfs (g, fstype, device);
5734 char device[] = "/dev/sda1";
5735 char mountpoint[] = "/";
5738 r = guestfs_mount (g, device, mountpoint);
5742 /* TestOutput for checksum (2) */
5743 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5745 char path[] = "/new";
5746 char content[] = "test\n";
5749 r = guestfs_write_file (g, path, content, 0);
5754 char csumtype[] = "md5";
5755 char path[] = "/new";
5758 r = guestfs_checksum (g, csumtype, path);
5761 if (strcmp (r, expected) != 0) {
5762 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5770 static int test_checksum_3_skip (void)
5774 str = getenv ("SKIP_TEST_CHECKSUM_3");
5775 if (str && strcmp (str, "1") == 0) return 1;
5776 str = getenv ("SKIP_TEST_CHECKSUM");
5777 if (str && strcmp (str, "1") == 0) return 1;
5781 static int test_checksum_3 (void)
5783 if (test_checksum_3_skip ()) {
5784 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5788 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5790 char device[] = "/dev/sda";
5793 r = guestfs_blockdev_setrw (g, device);
5800 r = guestfs_umount_all (g);
5807 r = guestfs_lvm_remove_all (g);
5812 char device[] = "/dev/sda";
5813 char lines_0[] = ",";
5820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5825 char fstype[] = "ext2";
5826 char device[] = "/dev/sda1";
5829 r = guestfs_mkfs (g, fstype, device);
5834 char device[] = "/dev/sda1";
5835 char mountpoint[] = "/";
5838 r = guestfs_mount (g, device, mountpoint);
5842 /* TestOutput for checksum (3) */
5843 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5845 char path[] = "/new";
5846 char content[] = "test\n";
5849 r = guestfs_write_file (g, path, content, 0);
5854 char csumtype[] = "sha1";
5855 char path[] = "/new";
5858 r = guestfs_checksum (g, csumtype, path);
5861 if (strcmp (r, expected) != 0) {
5862 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5870 static int test_checksum_4_skip (void)
5874 str = getenv ("SKIP_TEST_CHECKSUM_4");
5875 if (str && strcmp (str, "1") == 0) return 1;
5876 str = getenv ("SKIP_TEST_CHECKSUM");
5877 if (str && strcmp (str, "1") == 0) return 1;
5881 static int test_checksum_4 (void)
5883 if (test_checksum_4_skip ()) {
5884 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5888 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5890 char device[] = "/dev/sda";
5893 r = guestfs_blockdev_setrw (g, device);
5900 r = guestfs_umount_all (g);
5907 r = guestfs_lvm_remove_all (g);
5912 char device[] = "/dev/sda";
5913 char lines_0[] = ",";
5920 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5925 char fstype[] = "ext2";
5926 char device[] = "/dev/sda1";
5929 r = guestfs_mkfs (g, fstype, device);
5934 char device[] = "/dev/sda1";
5935 char mountpoint[] = "/";
5938 r = guestfs_mount (g, device, mountpoint);
5942 /* TestOutput for checksum (4) */
5943 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5945 char path[] = "/new";
5946 char content[] = "test\n";
5949 r = guestfs_write_file (g, path, content, 0);
5954 char csumtype[] = "sha224";
5955 char path[] = "/new";
5958 r = guestfs_checksum (g, csumtype, path);
5961 if (strcmp (r, expected) != 0) {
5962 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5970 static int test_checksum_5_skip (void)
5974 str = getenv ("SKIP_TEST_CHECKSUM_5");
5975 if (str && strcmp (str, "1") == 0) return 1;
5976 str = getenv ("SKIP_TEST_CHECKSUM");
5977 if (str && strcmp (str, "1") == 0) return 1;
5981 static int test_checksum_5 (void)
5983 if (test_checksum_5_skip ()) {
5984 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5988 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5990 char device[] = "/dev/sda";
5993 r = guestfs_blockdev_setrw (g, device);
6000 r = guestfs_umount_all (g);
6007 r = guestfs_lvm_remove_all (g);
6012 char device[] = "/dev/sda";
6013 char lines_0[] = ",";
6020 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6025 char fstype[] = "ext2";
6026 char device[] = "/dev/sda1";
6029 r = guestfs_mkfs (g, fstype, device);
6034 char device[] = "/dev/sda1";
6035 char mountpoint[] = "/";
6038 r = guestfs_mount (g, device, mountpoint);
6042 /* TestOutput for checksum (5) */
6043 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6045 char path[] = "/new";
6046 char content[] = "test\n";
6049 r = guestfs_write_file (g, path, content, 0);
6054 char csumtype[] = "sha256";
6055 char path[] = "/new";
6058 r = guestfs_checksum (g, csumtype, path);
6061 if (strcmp (r, expected) != 0) {
6062 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6070 static int test_checksum_6_skip (void)
6074 str = getenv ("SKIP_TEST_CHECKSUM_6");
6075 if (str && strcmp (str, "1") == 0) return 1;
6076 str = getenv ("SKIP_TEST_CHECKSUM");
6077 if (str && strcmp (str, "1") == 0) return 1;
6081 static int test_checksum_6 (void)
6083 if (test_checksum_6_skip ()) {
6084 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
6088 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6090 char device[] = "/dev/sda";
6093 r = guestfs_blockdev_setrw (g, device);
6100 r = guestfs_umount_all (g);
6107 r = guestfs_lvm_remove_all (g);
6112 char device[] = "/dev/sda";
6113 char lines_0[] = ",";
6120 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6125 char fstype[] = "ext2";
6126 char device[] = "/dev/sda1";
6129 r = guestfs_mkfs (g, fstype, device);
6134 char device[] = "/dev/sda1";
6135 char mountpoint[] = "/";
6138 r = guestfs_mount (g, device, mountpoint);
6142 /* TestOutput for checksum (6) */
6143 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6145 char path[] = "/new";
6146 char content[] = "test\n";
6149 r = guestfs_write_file (g, path, content, 0);
6154 char csumtype[] = "sha384";
6155 char path[] = "/new";
6158 r = guestfs_checksum (g, csumtype, path);
6161 if (strcmp (r, expected) != 0) {
6162 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6170 static int test_checksum_7_skip (void)
6174 str = getenv ("SKIP_TEST_CHECKSUM_7");
6175 if (str && strcmp (str, "1") == 0) return 1;
6176 str = getenv ("SKIP_TEST_CHECKSUM");
6177 if (str && strcmp (str, "1") == 0) return 1;
6181 static int test_checksum_7 (void)
6183 if (test_checksum_7_skip ()) {
6184 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6188 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6190 char device[] = "/dev/sda";
6193 r = guestfs_blockdev_setrw (g, device);
6200 r = guestfs_umount_all (g);
6207 r = guestfs_lvm_remove_all (g);
6212 char device[] = "/dev/sda";
6213 char lines_0[] = ",";
6220 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6225 char fstype[] = "ext2";
6226 char device[] = "/dev/sda1";
6229 r = guestfs_mkfs (g, fstype, device);
6234 char device[] = "/dev/sda1";
6235 char mountpoint[] = "/";
6238 r = guestfs_mount (g, device, mountpoint);
6242 /* TestOutput for checksum (7) */
6243 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6245 char path[] = "/new";
6246 char content[] = "test\n";
6249 r = guestfs_write_file (g, path, content, 0);
6254 char csumtype[] = "sha512";
6255 char path[] = "/new";
6258 r = guestfs_checksum (g, csumtype, path);
6261 if (strcmp (r, expected) != 0) {
6262 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6270 static int test_checksum_8_skip (void)
6274 str = getenv ("SKIP_TEST_CHECKSUM_8");
6275 if (str && strcmp (str, "1") == 0) return 1;
6276 str = getenv ("SKIP_TEST_CHECKSUM");
6277 if (str && strcmp (str, "1") == 0) return 1;
6281 static int test_checksum_8 (void)
6283 if (test_checksum_8_skip ()) {
6284 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6288 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6290 char device[] = "/dev/sda";
6293 r = guestfs_blockdev_setrw (g, device);
6300 r = guestfs_umount_all (g);
6307 r = guestfs_lvm_remove_all (g);
6312 char device[] = "/dev/sda";
6313 char lines_0[] = ",";
6320 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6325 char fstype[] = "ext2";
6326 char device[] = "/dev/sda1";
6329 r = guestfs_mkfs (g, fstype, device);
6334 char device[] = "/dev/sda1";
6335 char mountpoint[] = "/";
6338 r = guestfs_mount (g, device, mountpoint);
6342 /* TestOutput for checksum (8) */
6343 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6345 char options[] = "ro";
6346 char vfstype[] = "squashfs";
6347 char device[] = "/dev/sdd";
6348 char mountpoint[] = "/";
6351 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6356 char csumtype[] = "md5";
6357 char path[] = "/known-3";
6360 r = guestfs_checksum (g, csumtype, path);
6363 if (strcmp (r, expected) != 0) {
6364 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6372 static int test_download_0_skip (void)
6376 str = getenv ("SKIP_TEST_DOWNLOAD_0");
6377 if (str && strcmp (str, "1") == 0) return 1;
6378 str = getenv ("SKIP_TEST_DOWNLOAD");
6379 if (str && strcmp (str, "1") == 0) return 1;
6383 static int test_download_0 (void)
6385 if (test_download_0_skip ()) {
6386 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6390 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6392 char device[] = "/dev/sda";
6395 r = guestfs_blockdev_setrw (g, device);
6402 r = guestfs_umount_all (g);
6409 r = guestfs_lvm_remove_all (g);
6414 char device[] = "/dev/sda";
6415 char lines_0[] = ",";
6422 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6427 char fstype[] = "ext2";
6428 char device[] = "/dev/sda1";
6431 r = guestfs_mkfs (g, fstype, device);
6436 char device[] = "/dev/sda1";
6437 char mountpoint[] = "/";
6440 r = guestfs_mount (g, device, mountpoint);
6444 /* TestOutput for download (0) */
6445 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6447 char remotefilename[] = "/COPYING.LIB";
6450 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6455 char remotefilename[] = "/COPYING.LIB";
6458 r = guestfs_download (g, remotefilename, "testdownload.tmp");
6463 char remotefilename[] = "/upload";
6466 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6471 char csumtype[] = "md5";
6472 char path[] = "/upload";
6475 r = guestfs_checksum (g, csumtype, path);
6478 if (strcmp (r, expected) != 0) {
6479 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6487 static int test_upload_0_skip (void)
6491 str = getenv ("SKIP_TEST_UPLOAD_0");
6492 if (str && strcmp (str, "1") == 0) return 1;
6493 str = getenv ("SKIP_TEST_UPLOAD");
6494 if (str && strcmp (str, "1") == 0) return 1;
6498 static int test_upload_0 (void)
6500 if (test_upload_0_skip ()) {
6501 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6505 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6507 char device[] = "/dev/sda";
6510 r = guestfs_blockdev_setrw (g, device);
6517 r = guestfs_umount_all (g);
6524 r = guestfs_lvm_remove_all (g);
6529 char device[] = "/dev/sda";
6530 char lines_0[] = ",";
6537 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6542 char fstype[] = "ext2";
6543 char device[] = "/dev/sda1";
6546 r = guestfs_mkfs (g, fstype, device);
6551 char device[] = "/dev/sda1";
6552 char mountpoint[] = "/";
6555 r = guestfs_mount (g, device, mountpoint);
6559 /* TestOutput for upload (0) */
6560 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6562 char remotefilename[] = "/COPYING.LIB";
6565 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6570 char csumtype[] = "md5";
6571 char path[] = "/COPYING.LIB";
6574 r = guestfs_checksum (g, csumtype, path);
6577 if (strcmp (r, expected) != 0) {
6578 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6586 static int test_blockdev_rereadpt_0_skip (void)
6590 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6591 if (str && strcmp (str, "1") == 0) return 1;
6592 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6593 if (str && strcmp (str, "1") == 0) return 1;
6597 static int test_blockdev_rereadpt_0 (void)
6599 if (test_blockdev_rereadpt_0_skip ()) {
6600 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6604 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6606 char device[] = "/dev/sda";
6609 r = guestfs_blockdev_setrw (g, device);
6616 r = guestfs_umount_all (g);
6623 r = guestfs_lvm_remove_all (g);
6627 /* TestRun for blockdev_rereadpt (0) */
6629 char device[] = "/dev/sda";
6632 r = guestfs_blockdev_rereadpt (g, device);
6639 static int test_blockdev_flushbufs_0_skip (void)
6643 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6644 if (str && strcmp (str, "1") == 0) return 1;
6645 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6646 if (str && strcmp (str, "1") == 0) return 1;
6650 static int test_blockdev_flushbufs_0 (void)
6652 if (test_blockdev_flushbufs_0_skip ()) {
6653 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6657 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6659 char device[] = "/dev/sda";
6662 r = guestfs_blockdev_setrw (g, device);
6669 r = guestfs_umount_all (g);
6676 r = guestfs_lvm_remove_all (g);
6680 /* TestRun for blockdev_flushbufs (0) */
6682 char device[] = "/dev/sda";
6685 r = guestfs_blockdev_flushbufs (g, device);
6692 static int test_blockdev_getsize64_0_skip (void)
6696 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6697 if (str && strcmp (str, "1") == 0) return 1;
6698 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6699 if (str && strcmp (str, "1") == 0) return 1;
6703 static int test_blockdev_getsize64_0 (void)
6705 if (test_blockdev_getsize64_0_skip ()) {
6706 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6710 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6712 char device[] = "/dev/sda";
6715 r = guestfs_blockdev_setrw (g, device);
6722 r = guestfs_umount_all (g);
6729 r = guestfs_lvm_remove_all (g);
6733 /* TestOutputInt for blockdev_getsize64 (0) */
6735 char device[] = "/dev/sda";
6738 r = guestfs_blockdev_getsize64 (g, device);
6741 if (r != 524288000) {
6742 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6749 static int test_blockdev_getsz_0_skip (void)
6753 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6754 if (str && strcmp (str, "1") == 0) return 1;
6755 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6756 if (str && strcmp (str, "1") == 0) return 1;
6760 static int test_blockdev_getsz_0 (void)
6762 if (test_blockdev_getsz_0_skip ()) {
6763 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6767 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6769 char device[] = "/dev/sda";
6772 r = guestfs_blockdev_setrw (g, device);
6779 r = guestfs_umount_all (g);
6786 r = guestfs_lvm_remove_all (g);
6790 /* TestOutputInt for blockdev_getsz (0) */
6792 char device[] = "/dev/sda";
6795 r = guestfs_blockdev_getsz (g, device);
6799 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6806 static int test_blockdev_getbsz_0_skip (void)
6810 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6811 if (str && strcmp (str, "1") == 0) return 1;
6812 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6813 if (str && strcmp (str, "1") == 0) return 1;
6817 static int test_blockdev_getbsz_0 (void)
6819 if (test_blockdev_getbsz_0_skip ()) {
6820 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6824 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6826 char device[] = "/dev/sda";
6829 r = guestfs_blockdev_setrw (g, device);
6836 r = guestfs_umount_all (g);
6843 r = guestfs_lvm_remove_all (g);
6847 /* TestOutputInt for blockdev_getbsz (0) */
6849 char device[] = "/dev/sda";
6852 r = guestfs_blockdev_getbsz (g, device);
6856 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6863 static int test_blockdev_getss_0_skip (void)
6867 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6868 if (str && strcmp (str, "1") == 0) return 1;
6869 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6870 if (str && strcmp (str, "1") == 0) return 1;
6874 static int test_blockdev_getss_0 (void)
6876 if (test_blockdev_getss_0_skip ()) {
6877 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6881 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6883 char device[] = "/dev/sda";
6886 r = guestfs_blockdev_setrw (g, device);
6893 r = guestfs_umount_all (g);
6900 r = guestfs_lvm_remove_all (g);
6904 /* TestOutputInt for blockdev_getss (0) */
6906 char device[] = "/dev/sda";
6909 r = guestfs_blockdev_getss (g, device);
6913 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6920 static int test_blockdev_getro_0_skip (void)
6924 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6925 if (str && strcmp (str, "1") == 0) return 1;
6926 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6927 if (str && strcmp (str, "1") == 0) return 1;
6931 static int test_blockdev_getro_0 (void)
6933 if (test_blockdev_getro_0_skip ()) {
6934 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6938 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6940 char device[] = "/dev/sda";
6943 r = guestfs_blockdev_setrw (g, device);
6950 r = guestfs_umount_all (g);
6957 r = guestfs_lvm_remove_all (g);
6961 /* TestOutputTrue for blockdev_getro (0) */
6963 char device[] = "/dev/sda";
6966 r = guestfs_blockdev_setro (g, device);
6971 char device[] = "/dev/sda";
6974 r = guestfs_blockdev_getro (g, device);
6978 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6985 static int test_blockdev_setrw_0_skip (void)
6989 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6990 if (str && strcmp (str, "1") == 0) return 1;
6991 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6992 if (str && strcmp (str, "1") == 0) return 1;
6996 static int test_blockdev_setrw_0 (void)
6998 if (test_blockdev_setrw_0_skip ()) {
6999 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
7003 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7005 char device[] = "/dev/sda";
7008 r = guestfs_blockdev_setrw (g, device);
7015 r = guestfs_umount_all (g);
7022 r = guestfs_lvm_remove_all (g);
7026 /* TestOutputFalse for blockdev_setrw (0) */
7028 char device[] = "/dev/sda";
7031 r = guestfs_blockdev_setrw (g, device);
7036 char device[] = "/dev/sda";
7039 r = guestfs_blockdev_getro (g, device);
7043 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7050 static int test_blockdev_setro_0_skip (void)
7054 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7055 if (str && strcmp (str, "1") == 0) return 1;
7056 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7057 if (str && strcmp (str, "1") == 0) return 1;
7061 static int test_blockdev_setro_0 (void)
7063 if (test_blockdev_setro_0_skip ()) {
7064 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
7068 /* InitNone|InitEmpty for test_blockdev_setro_0 */
7070 char device[] = "/dev/sda";
7073 r = guestfs_blockdev_setrw (g, device);
7080 r = guestfs_umount_all (g);
7087 r = guestfs_lvm_remove_all (g);
7091 /* TestOutputTrue for blockdev_setro (0) */
7093 char device[] = "/dev/sda";
7096 r = guestfs_blockdev_setro (g, device);
7101 char device[] = "/dev/sda";
7104 r = guestfs_blockdev_getro (g, device);
7108 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7115 static int test_statvfs_0_skip (void)
7119 str = getenv ("SKIP_TEST_STATVFS_0");
7120 if (str && strcmp (str, "1") == 0) return 1;
7121 str = getenv ("SKIP_TEST_STATVFS");
7122 if (str && strcmp (str, "1") == 0) return 1;
7126 static int test_statvfs_0 (void)
7128 if (test_statvfs_0_skip ()) {
7129 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
7133 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7135 char device[] = "/dev/sda";
7138 r = guestfs_blockdev_setrw (g, device);
7145 r = guestfs_umount_all (g);
7152 r = guestfs_lvm_remove_all (g);
7157 char device[] = "/dev/sda";
7158 char lines_0[] = ",";
7165 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7170 char fstype[] = "ext2";
7171 char device[] = "/dev/sda1";
7174 r = guestfs_mkfs (g, fstype, device);
7179 char device[] = "/dev/sda1";
7180 char mountpoint[] = "/";
7183 r = guestfs_mount (g, device, mountpoint);
7187 /* TestOutputStruct for statvfs (0) */
7190 struct guestfs_statvfs *r;
7192 r = guestfs_statvfs (g, path);
7195 if (r->bfree != 487702) {
7196 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7200 if (r->blocks != 490020) {
7201 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7205 if (r->bsize != 1024) {
7206 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7215 static int test_lstat_0_skip (void)
7219 str = getenv ("SKIP_TEST_LSTAT_0");
7220 if (str && strcmp (str, "1") == 0) return 1;
7221 str = getenv ("SKIP_TEST_LSTAT");
7222 if (str && strcmp (str, "1") == 0) return 1;
7226 static int test_lstat_0 (void)
7228 if (test_lstat_0_skip ()) {
7229 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7233 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7235 char device[] = "/dev/sda";
7238 r = guestfs_blockdev_setrw (g, device);
7245 r = guestfs_umount_all (g);
7252 r = guestfs_lvm_remove_all (g);
7257 char device[] = "/dev/sda";
7258 char lines_0[] = ",";
7265 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7270 char fstype[] = "ext2";
7271 char device[] = "/dev/sda1";
7274 r = guestfs_mkfs (g, fstype, device);
7279 char device[] = "/dev/sda1";
7280 char mountpoint[] = "/";
7283 r = guestfs_mount (g, device, mountpoint);
7287 /* TestOutputStruct for lstat (0) */
7289 char path[] = "/new";
7292 r = guestfs_touch (g, path);
7297 char path[] = "/new";
7298 struct guestfs_stat *r;
7300 r = guestfs_lstat (g, path);
7304 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7313 static int test_stat_0_skip (void)
7317 str = getenv ("SKIP_TEST_STAT_0");
7318 if (str && strcmp (str, "1") == 0) return 1;
7319 str = getenv ("SKIP_TEST_STAT");
7320 if (str && strcmp (str, "1") == 0) return 1;
7324 static int test_stat_0 (void)
7326 if (test_stat_0_skip ()) {
7327 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7331 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7333 char device[] = "/dev/sda";
7336 r = guestfs_blockdev_setrw (g, device);
7343 r = guestfs_umount_all (g);
7350 r = guestfs_lvm_remove_all (g);
7355 char device[] = "/dev/sda";
7356 char lines_0[] = ",";
7363 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7368 char fstype[] = "ext2";
7369 char device[] = "/dev/sda1";
7372 r = guestfs_mkfs (g, fstype, device);
7377 char device[] = "/dev/sda1";
7378 char mountpoint[] = "/";
7381 r = guestfs_mount (g, device, mountpoint);
7385 /* TestOutputStruct for stat (0) */
7387 char path[] = "/new";
7390 r = guestfs_touch (g, path);
7395 char path[] = "/new";
7396 struct guestfs_stat *r;
7398 r = guestfs_stat (g, path);
7402 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7411 static int test_command_lines_0_skip (void)
7415 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7416 if (str && strcmp (str, "1") == 0) return 1;
7417 str = getenv ("SKIP_TEST_COMMAND_LINES");
7418 if (str && strcmp (str, "1") == 0) return 1;
7422 static int test_command_lines_0 (void)
7424 if (test_command_lines_0_skip ()) {
7425 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7429 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7431 char device[] = "/dev/sda";
7434 r = guestfs_blockdev_setrw (g, device);
7441 r = guestfs_umount_all (g);
7448 r = guestfs_lvm_remove_all (g);
7453 char device[] = "/dev/sda";
7454 char lines_0[] = ",";
7461 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7466 char fstype[] = "ext2";
7467 char device[] = "/dev/sda1";
7470 r = guestfs_mkfs (g, fstype, device);
7475 char device[] = "/dev/sda1";
7476 char mountpoint[] = "/";
7479 r = guestfs_mount (g, device, mountpoint);
7483 /* TestOutputList for command_lines (0) */
7485 char remotefilename[] = "/test-command";
7488 r = guestfs_upload (g, "test-command", remotefilename);
7493 char path[] = "/test-command";
7496 r = guestfs_chmod (g, 493, path);
7501 char arguments_0[] = "/test-command";
7502 char arguments_1[] = "1";
7503 char *arguments[] = {
7511 r = guestfs_command_lines (g, arguments);
7515 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7520 char expected[] = "Result1";
7521 if (strcmp (r[0], expected) != 0) {
7522 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7527 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7531 for (i = 0; r[i] != NULL; ++i)
7538 static int test_command_lines_1_skip (void)
7542 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7543 if (str && strcmp (str, "1") == 0) return 1;
7544 str = getenv ("SKIP_TEST_COMMAND_LINES");
7545 if (str && strcmp (str, "1") == 0) return 1;
7549 static int test_command_lines_1 (void)
7551 if (test_command_lines_1_skip ()) {
7552 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7556 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7558 char device[] = "/dev/sda";
7561 r = guestfs_blockdev_setrw (g, device);
7568 r = guestfs_umount_all (g);
7575 r = guestfs_lvm_remove_all (g);
7580 char device[] = "/dev/sda";
7581 char lines_0[] = ",";
7588 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7593 char fstype[] = "ext2";
7594 char device[] = "/dev/sda1";
7597 r = guestfs_mkfs (g, fstype, device);
7602 char device[] = "/dev/sda1";
7603 char mountpoint[] = "/";
7606 r = guestfs_mount (g, device, mountpoint);
7610 /* TestOutputList for command_lines (1) */
7612 char remotefilename[] = "/test-command";
7615 r = guestfs_upload (g, "test-command", remotefilename);
7620 char path[] = "/test-command";
7623 r = guestfs_chmod (g, 493, path);
7628 char arguments_0[] = "/test-command";
7629 char arguments_1[] = "2";
7630 char *arguments[] = {
7638 r = guestfs_command_lines (g, arguments);
7642 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7647 char expected[] = "Result2";
7648 if (strcmp (r[0], expected) != 0) {
7649 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7654 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7658 for (i = 0; r[i] != NULL; ++i)
7665 static int test_command_lines_2_skip (void)
7669 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7670 if (str && strcmp (str, "1") == 0) return 1;
7671 str = getenv ("SKIP_TEST_COMMAND_LINES");
7672 if (str && strcmp (str, "1") == 0) return 1;
7676 static int test_command_lines_2 (void)
7678 if (test_command_lines_2_skip ()) {
7679 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7683 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7685 char device[] = "/dev/sda";
7688 r = guestfs_blockdev_setrw (g, device);
7695 r = guestfs_umount_all (g);
7702 r = guestfs_lvm_remove_all (g);
7707 char device[] = "/dev/sda";
7708 char lines_0[] = ",";
7715 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7720 char fstype[] = "ext2";
7721 char device[] = "/dev/sda1";
7724 r = guestfs_mkfs (g, fstype, device);
7729 char device[] = "/dev/sda1";
7730 char mountpoint[] = "/";
7733 r = guestfs_mount (g, device, mountpoint);
7737 /* TestOutputList for command_lines (2) */
7739 char remotefilename[] = "/test-command";
7742 r = guestfs_upload (g, "test-command", remotefilename);
7747 char path[] = "/test-command";
7750 r = guestfs_chmod (g, 493, path);
7755 char arguments_0[] = "/test-command";
7756 char arguments_1[] = "3";
7757 char *arguments[] = {
7765 r = guestfs_command_lines (g, arguments);
7769 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7774 char expected[] = "";
7775 if (strcmp (r[0], expected) != 0) {
7776 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7781 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7786 char expected[] = "Result3";
7787 if (strcmp (r[1], expected) != 0) {
7788 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7793 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7797 for (i = 0; r[i] != NULL; ++i)
7804 static int test_command_lines_3_skip (void)
7808 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7809 if (str && strcmp (str, "1") == 0) return 1;
7810 str = getenv ("SKIP_TEST_COMMAND_LINES");
7811 if (str && strcmp (str, "1") == 0) return 1;
7815 static int test_command_lines_3 (void)
7817 if (test_command_lines_3_skip ()) {
7818 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7822 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7824 char device[] = "/dev/sda";
7827 r = guestfs_blockdev_setrw (g, device);
7834 r = guestfs_umount_all (g);
7841 r = guestfs_lvm_remove_all (g);
7846 char device[] = "/dev/sda";
7847 char lines_0[] = ",";
7854 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7859 char fstype[] = "ext2";
7860 char device[] = "/dev/sda1";
7863 r = guestfs_mkfs (g, fstype, device);
7868 char device[] = "/dev/sda1";
7869 char mountpoint[] = "/";
7872 r = guestfs_mount (g, device, mountpoint);
7876 /* TestOutputList for command_lines (3) */
7878 char remotefilename[] = "/test-command";
7881 r = guestfs_upload (g, "test-command", remotefilename);
7886 char path[] = "/test-command";
7889 r = guestfs_chmod (g, 493, path);
7894 char arguments_0[] = "/test-command";
7895 char arguments_1[] = "4";
7896 char *arguments[] = {
7904 r = guestfs_command_lines (g, arguments);
7908 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7913 char expected[] = "";
7914 if (strcmp (r[0], expected) != 0) {
7915 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7920 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7925 char expected[] = "Result4";
7926 if (strcmp (r[1], expected) != 0) {
7927 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7932 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7936 for (i = 0; r[i] != NULL; ++i)
7943 static int test_command_lines_4_skip (void)
7947 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7948 if (str && strcmp (str, "1") == 0) return 1;
7949 str = getenv ("SKIP_TEST_COMMAND_LINES");
7950 if (str && strcmp (str, "1") == 0) return 1;
7954 static int test_command_lines_4 (void)
7956 if (test_command_lines_4_skip ()) {
7957 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7961 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7963 char device[] = "/dev/sda";
7966 r = guestfs_blockdev_setrw (g, device);
7973 r = guestfs_umount_all (g);
7980 r = guestfs_lvm_remove_all (g);
7985 char device[] = "/dev/sda";
7986 char lines_0[] = ",";
7993 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7998 char fstype[] = "ext2";
7999 char device[] = "/dev/sda1";
8002 r = guestfs_mkfs (g, fstype, device);
8007 char device[] = "/dev/sda1";
8008 char mountpoint[] = "/";
8011 r = guestfs_mount (g, device, mountpoint);
8015 /* TestOutputList for command_lines (4) */
8017 char remotefilename[] = "/test-command";
8020 r = guestfs_upload (g, "test-command", remotefilename);
8025 char path[] = "/test-command";
8028 r = guestfs_chmod (g, 493, path);
8033 char arguments_0[] = "/test-command";
8034 char arguments_1[] = "5";
8035 char *arguments[] = {
8043 r = guestfs_command_lines (g, arguments);
8047 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8052 char expected[] = "";
8053 if (strcmp (r[0], expected) != 0) {
8054 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8059 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8064 char expected[] = "Result5";
8065 if (strcmp (r[1], expected) != 0) {
8066 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8071 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8076 char expected[] = "";
8077 if (strcmp (r[2], expected) != 0) {
8078 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8083 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8087 for (i = 0; r[i] != NULL; ++i)
8094 static int test_command_lines_5_skip (void)
8098 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8099 if (str && strcmp (str, "1") == 0) return 1;
8100 str = getenv ("SKIP_TEST_COMMAND_LINES");
8101 if (str && strcmp (str, "1") == 0) return 1;
8105 static int test_command_lines_5 (void)
8107 if (test_command_lines_5_skip ()) {
8108 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
8112 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8114 char device[] = "/dev/sda";
8117 r = guestfs_blockdev_setrw (g, device);
8124 r = guestfs_umount_all (g);
8131 r = guestfs_lvm_remove_all (g);
8136 char device[] = "/dev/sda";
8137 char lines_0[] = ",";
8144 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8149 char fstype[] = "ext2";
8150 char device[] = "/dev/sda1";
8153 r = guestfs_mkfs (g, fstype, device);
8158 char device[] = "/dev/sda1";
8159 char mountpoint[] = "/";
8162 r = guestfs_mount (g, device, mountpoint);
8166 /* TestOutputList for command_lines (5) */
8168 char remotefilename[] = "/test-command";
8171 r = guestfs_upload (g, "test-command", remotefilename);
8176 char path[] = "/test-command";
8179 r = guestfs_chmod (g, 493, path);
8184 char arguments_0[] = "/test-command";
8185 char arguments_1[] = "6";
8186 char *arguments[] = {
8194 r = guestfs_command_lines (g, arguments);
8198 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8203 char expected[] = "";
8204 if (strcmp (r[0], expected) != 0) {
8205 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8210 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8215 char expected[] = "";
8216 if (strcmp (r[1], expected) != 0) {
8217 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8222 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8227 char expected[] = "Result6";
8228 if (strcmp (r[2], expected) != 0) {
8229 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8234 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8239 char expected[] = "";
8240 if (strcmp (r[3], expected) != 0) {
8241 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8246 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8250 for (i = 0; r[i] != NULL; ++i)
8257 static int test_command_lines_6_skip (void)
8261 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8262 if (str && strcmp (str, "1") == 0) return 1;
8263 str = getenv ("SKIP_TEST_COMMAND_LINES");
8264 if (str && strcmp (str, "1") == 0) return 1;
8268 static int test_command_lines_6 (void)
8270 if (test_command_lines_6_skip ()) {
8271 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8275 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8277 char device[] = "/dev/sda";
8280 r = guestfs_blockdev_setrw (g, device);
8287 r = guestfs_umount_all (g);
8294 r = guestfs_lvm_remove_all (g);
8299 char device[] = "/dev/sda";
8300 char lines_0[] = ",";
8307 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8312 char fstype[] = "ext2";
8313 char device[] = "/dev/sda1";
8316 r = guestfs_mkfs (g, fstype, device);
8321 char device[] = "/dev/sda1";
8322 char mountpoint[] = "/";
8325 r = guestfs_mount (g, device, mountpoint);
8329 /* TestOutputList for command_lines (6) */
8331 char remotefilename[] = "/test-command";
8334 r = guestfs_upload (g, "test-command", remotefilename);
8339 char path[] = "/test-command";
8342 r = guestfs_chmod (g, 493, path);
8347 char arguments_0[] = "/test-command";
8348 char arguments_1[] = "7";
8349 char *arguments[] = {
8357 r = guestfs_command_lines (g, arguments);
8361 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8365 for (i = 0; r[i] != NULL; ++i)
8372 static int test_command_lines_7_skip (void)
8376 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8377 if (str && strcmp (str, "1") == 0) return 1;
8378 str = getenv ("SKIP_TEST_COMMAND_LINES");
8379 if (str && strcmp (str, "1") == 0) return 1;
8383 static int test_command_lines_7 (void)
8385 if (test_command_lines_7_skip ()) {
8386 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8390 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8392 char device[] = "/dev/sda";
8395 r = guestfs_blockdev_setrw (g, device);
8402 r = guestfs_umount_all (g);
8409 r = guestfs_lvm_remove_all (g);
8414 char device[] = "/dev/sda";
8415 char lines_0[] = ",";
8422 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8427 char fstype[] = "ext2";
8428 char device[] = "/dev/sda1";
8431 r = guestfs_mkfs (g, fstype, device);
8436 char device[] = "/dev/sda1";
8437 char mountpoint[] = "/";
8440 r = guestfs_mount (g, device, mountpoint);
8444 /* TestOutputList for command_lines (7) */
8446 char remotefilename[] = "/test-command";
8449 r = guestfs_upload (g, "test-command", remotefilename);
8454 char path[] = "/test-command";
8457 r = guestfs_chmod (g, 493, path);
8462 char arguments_0[] = "/test-command";
8463 char arguments_1[] = "8";
8464 char *arguments[] = {
8472 r = guestfs_command_lines (g, arguments);
8476 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8481 char expected[] = "";
8482 if (strcmp (r[0], expected) != 0) {
8483 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8488 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8492 for (i = 0; r[i] != NULL; ++i)
8499 static int test_command_lines_8_skip (void)
8503 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8504 if (str && strcmp (str, "1") == 0) return 1;
8505 str = getenv ("SKIP_TEST_COMMAND_LINES");
8506 if (str && strcmp (str, "1") == 0) return 1;
8510 static int test_command_lines_8 (void)
8512 if (test_command_lines_8_skip ()) {
8513 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8517 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8519 char device[] = "/dev/sda";
8522 r = guestfs_blockdev_setrw (g, device);
8529 r = guestfs_umount_all (g);
8536 r = guestfs_lvm_remove_all (g);
8541 char device[] = "/dev/sda";
8542 char lines_0[] = ",";
8549 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8554 char fstype[] = "ext2";
8555 char device[] = "/dev/sda1";
8558 r = guestfs_mkfs (g, fstype, device);
8563 char device[] = "/dev/sda1";
8564 char mountpoint[] = "/";
8567 r = guestfs_mount (g, device, mountpoint);
8571 /* TestOutputList for command_lines (8) */
8573 char remotefilename[] = "/test-command";
8576 r = guestfs_upload (g, "test-command", remotefilename);
8581 char path[] = "/test-command";
8584 r = guestfs_chmod (g, 493, path);
8589 char arguments_0[] = "/test-command";
8590 char arguments_1[] = "9";
8591 char *arguments[] = {
8599 r = guestfs_command_lines (g, arguments);
8603 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8608 char expected[] = "";
8609 if (strcmp (r[0], expected) != 0) {
8610 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8615 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8620 char expected[] = "";
8621 if (strcmp (r[1], expected) != 0) {
8622 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8627 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8631 for (i = 0; r[i] != NULL; ++i)
8638 static int test_command_lines_9_skip (void)
8642 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8643 if (str && strcmp (str, "1") == 0) return 1;
8644 str = getenv ("SKIP_TEST_COMMAND_LINES");
8645 if (str && strcmp (str, "1") == 0) return 1;
8649 static int test_command_lines_9 (void)
8651 if (test_command_lines_9_skip ()) {
8652 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8656 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8658 char device[] = "/dev/sda";
8661 r = guestfs_blockdev_setrw (g, device);
8668 r = guestfs_umount_all (g);
8675 r = guestfs_lvm_remove_all (g);
8680 char device[] = "/dev/sda";
8681 char lines_0[] = ",";
8688 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8693 char fstype[] = "ext2";
8694 char device[] = "/dev/sda1";
8697 r = guestfs_mkfs (g, fstype, device);
8702 char device[] = "/dev/sda1";
8703 char mountpoint[] = "/";
8706 r = guestfs_mount (g, device, mountpoint);
8710 /* TestOutputList for command_lines (9) */
8712 char remotefilename[] = "/test-command";
8715 r = guestfs_upload (g, "test-command", remotefilename);
8720 char path[] = "/test-command";
8723 r = guestfs_chmod (g, 493, path);
8728 char arguments_0[] = "/test-command";
8729 char arguments_1[] = "10";
8730 char *arguments[] = {
8738 r = guestfs_command_lines (g, arguments);
8742 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8747 char expected[] = "Result10-1";
8748 if (strcmp (r[0], expected) != 0) {
8749 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8754 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8759 char expected[] = "Result10-2";
8760 if (strcmp (r[1], expected) != 0) {
8761 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8766 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8770 for (i = 0; r[i] != NULL; ++i)
8777 static int test_command_lines_10_skip (void)
8781 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8782 if (str && strcmp (str, "1") == 0) return 1;
8783 str = getenv ("SKIP_TEST_COMMAND_LINES");
8784 if (str && strcmp (str, "1") == 0) return 1;
8788 static int test_command_lines_10 (void)
8790 if (test_command_lines_10_skip ()) {
8791 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8795 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8797 char device[] = "/dev/sda";
8800 r = guestfs_blockdev_setrw (g, device);
8807 r = guestfs_umount_all (g);
8814 r = guestfs_lvm_remove_all (g);
8819 char device[] = "/dev/sda";
8820 char lines_0[] = ",";
8827 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8832 char fstype[] = "ext2";
8833 char device[] = "/dev/sda1";
8836 r = guestfs_mkfs (g, fstype, device);
8841 char device[] = "/dev/sda1";
8842 char mountpoint[] = "/";
8845 r = guestfs_mount (g, device, mountpoint);
8849 /* TestOutputList for command_lines (10) */
8851 char remotefilename[] = "/test-command";
8854 r = guestfs_upload (g, "test-command", remotefilename);
8859 char path[] = "/test-command";
8862 r = guestfs_chmod (g, 493, path);
8867 char arguments_0[] = "/test-command";
8868 char arguments_1[] = "11";
8869 char *arguments[] = {
8877 r = guestfs_command_lines (g, arguments);
8881 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8886 char expected[] = "Result11-1";
8887 if (strcmp (r[0], expected) != 0) {
8888 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8893 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8898 char expected[] = "Result11-2";
8899 if (strcmp (r[1], expected) != 0) {
8900 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8905 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8909 for (i = 0; r[i] != NULL; ++i)
8916 static int test_command_0_skip (void)
8920 str = getenv ("SKIP_TEST_COMMAND_0");
8921 if (str && strcmp (str, "1") == 0) return 1;
8922 str = getenv ("SKIP_TEST_COMMAND");
8923 if (str && strcmp (str, "1") == 0) return 1;
8927 static int test_command_0 (void)
8929 if (test_command_0_skip ()) {
8930 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8934 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8936 char device[] = "/dev/sda";
8939 r = guestfs_blockdev_setrw (g, device);
8946 r = guestfs_umount_all (g);
8953 r = guestfs_lvm_remove_all (g);
8958 char device[] = "/dev/sda";
8959 char lines_0[] = ",";
8966 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8971 char fstype[] = "ext2";
8972 char device[] = "/dev/sda1";
8975 r = guestfs_mkfs (g, fstype, device);
8980 char device[] = "/dev/sda1";
8981 char mountpoint[] = "/";
8984 r = guestfs_mount (g, device, mountpoint);
8988 /* TestOutput for command (0) */
8989 char expected[] = "Result1";
8991 char remotefilename[] = "/test-command";
8994 r = guestfs_upload (g, "test-command", remotefilename);
8999 char path[] = "/test-command";
9002 r = guestfs_chmod (g, 493, path);
9007 char arguments_0[] = "/test-command";
9008 char arguments_1[] = "1";
9009 char *arguments[] = {
9016 r = guestfs_command (g, arguments);
9019 if (strcmp (r, expected) != 0) {
9020 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9028 static int test_command_1_skip (void)
9032 str = getenv ("SKIP_TEST_COMMAND_1");
9033 if (str && strcmp (str, "1") == 0) return 1;
9034 str = getenv ("SKIP_TEST_COMMAND");
9035 if (str && strcmp (str, "1") == 0) return 1;
9039 static int test_command_1 (void)
9041 if (test_command_1_skip ()) {
9042 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
9046 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9048 char device[] = "/dev/sda";
9051 r = guestfs_blockdev_setrw (g, device);
9058 r = guestfs_umount_all (g);
9065 r = guestfs_lvm_remove_all (g);
9070 char device[] = "/dev/sda";
9071 char lines_0[] = ",";
9078 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9083 char fstype[] = "ext2";
9084 char device[] = "/dev/sda1";
9087 r = guestfs_mkfs (g, fstype, device);
9092 char device[] = "/dev/sda1";
9093 char mountpoint[] = "/";
9096 r = guestfs_mount (g, device, mountpoint);
9100 /* TestOutput for command (1) */
9101 char expected[] = "Result2\n";
9103 char remotefilename[] = "/test-command";
9106 r = guestfs_upload (g, "test-command", remotefilename);
9111 char path[] = "/test-command";
9114 r = guestfs_chmod (g, 493, path);
9119 char arguments_0[] = "/test-command";
9120 char arguments_1[] = "2";
9121 char *arguments[] = {
9128 r = guestfs_command (g, arguments);
9131 if (strcmp (r, expected) != 0) {
9132 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9140 static int test_command_2_skip (void)
9144 str = getenv ("SKIP_TEST_COMMAND_2");
9145 if (str && strcmp (str, "1") == 0) return 1;
9146 str = getenv ("SKIP_TEST_COMMAND");
9147 if (str && strcmp (str, "1") == 0) return 1;
9151 static int test_command_2 (void)
9153 if (test_command_2_skip ()) {
9154 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9158 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9160 char device[] = "/dev/sda";
9163 r = guestfs_blockdev_setrw (g, device);
9170 r = guestfs_umount_all (g);
9177 r = guestfs_lvm_remove_all (g);
9182 char device[] = "/dev/sda";
9183 char lines_0[] = ",";
9190 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9195 char fstype[] = "ext2";
9196 char device[] = "/dev/sda1";
9199 r = guestfs_mkfs (g, fstype, device);
9204 char device[] = "/dev/sda1";
9205 char mountpoint[] = "/";
9208 r = guestfs_mount (g, device, mountpoint);
9212 /* TestOutput for command (2) */
9213 char expected[] = "\nResult3";
9215 char remotefilename[] = "/test-command";
9218 r = guestfs_upload (g, "test-command", remotefilename);
9223 char path[] = "/test-command";
9226 r = guestfs_chmod (g, 493, path);
9231 char arguments_0[] = "/test-command";
9232 char arguments_1[] = "3";
9233 char *arguments[] = {
9240 r = guestfs_command (g, arguments);
9243 if (strcmp (r, expected) != 0) {
9244 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9252 static int test_command_3_skip (void)
9256 str = getenv ("SKIP_TEST_COMMAND_3");
9257 if (str && strcmp (str, "1") == 0) return 1;
9258 str = getenv ("SKIP_TEST_COMMAND");
9259 if (str && strcmp (str, "1") == 0) return 1;
9263 static int test_command_3 (void)
9265 if (test_command_3_skip ()) {
9266 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9270 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9272 char device[] = "/dev/sda";
9275 r = guestfs_blockdev_setrw (g, device);
9282 r = guestfs_umount_all (g);
9289 r = guestfs_lvm_remove_all (g);
9294 char device[] = "/dev/sda";
9295 char lines_0[] = ",";
9302 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9307 char fstype[] = "ext2";
9308 char device[] = "/dev/sda1";
9311 r = guestfs_mkfs (g, fstype, device);
9316 char device[] = "/dev/sda1";
9317 char mountpoint[] = "/";
9320 r = guestfs_mount (g, device, mountpoint);
9324 /* TestOutput for command (3) */
9325 char expected[] = "\nResult4\n";
9327 char remotefilename[] = "/test-command";
9330 r = guestfs_upload (g, "test-command", remotefilename);
9335 char path[] = "/test-command";
9338 r = guestfs_chmod (g, 493, path);
9343 char arguments_0[] = "/test-command";
9344 char arguments_1[] = "4";
9345 char *arguments[] = {
9352 r = guestfs_command (g, arguments);
9355 if (strcmp (r, expected) != 0) {
9356 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9364 static int test_command_4_skip (void)
9368 str = getenv ("SKIP_TEST_COMMAND_4");
9369 if (str && strcmp (str, "1") == 0) return 1;
9370 str = getenv ("SKIP_TEST_COMMAND");
9371 if (str && strcmp (str, "1") == 0) return 1;
9375 static int test_command_4 (void)
9377 if (test_command_4_skip ()) {
9378 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9382 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9384 char device[] = "/dev/sda";
9387 r = guestfs_blockdev_setrw (g, device);
9394 r = guestfs_umount_all (g);
9401 r = guestfs_lvm_remove_all (g);
9406 char device[] = "/dev/sda";
9407 char lines_0[] = ",";
9414 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9419 char fstype[] = "ext2";
9420 char device[] = "/dev/sda1";
9423 r = guestfs_mkfs (g, fstype, device);
9428 char device[] = "/dev/sda1";
9429 char mountpoint[] = "/";
9432 r = guestfs_mount (g, device, mountpoint);
9436 /* TestOutput for command (4) */
9437 char expected[] = "\nResult5\n\n";
9439 char remotefilename[] = "/test-command";
9442 r = guestfs_upload (g, "test-command", remotefilename);
9447 char path[] = "/test-command";
9450 r = guestfs_chmod (g, 493, path);
9455 char arguments_0[] = "/test-command";
9456 char arguments_1[] = "5";
9457 char *arguments[] = {
9464 r = guestfs_command (g, arguments);
9467 if (strcmp (r, expected) != 0) {
9468 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9476 static int test_command_5_skip (void)
9480 str = getenv ("SKIP_TEST_COMMAND_5");
9481 if (str && strcmp (str, "1") == 0) return 1;
9482 str = getenv ("SKIP_TEST_COMMAND");
9483 if (str && strcmp (str, "1") == 0) return 1;
9487 static int test_command_5 (void)
9489 if (test_command_5_skip ()) {
9490 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9494 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9496 char device[] = "/dev/sda";
9499 r = guestfs_blockdev_setrw (g, device);
9506 r = guestfs_umount_all (g);
9513 r = guestfs_lvm_remove_all (g);
9518 char device[] = "/dev/sda";
9519 char lines_0[] = ",";
9526 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9531 char fstype[] = "ext2";
9532 char device[] = "/dev/sda1";
9535 r = guestfs_mkfs (g, fstype, device);
9540 char device[] = "/dev/sda1";
9541 char mountpoint[] = "/";
9544 r = guestfs_mount (g, device, mountpoint);
9548 /* TestOutput for command (5) */
9549 char expected[] = "\n\nResult6\n\n";
9551 char remotefilename[] = "/test-command";
9554 r = guestfs_upload (g, "test-command", remotefilename);
9559 char path[] = "/test-command";
9562 r = guestfs_chmod (g, 493, path);
9567 char arguments_0[] = "/test-command";
9568 char arguments_1[] = "6";
9569 char *arguments[] = {
9576 r = guestfs_command (g, arguments);
9579 if (strcmp (r, expected) != 0) {
9580 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9588 static int test_command_6_skip (void)
9592 str = getenv ("SKIP_TEST_COMMAND_6");
9593 if (str && strcmp (str, "1") == 0) return 1;
9594 str = getenv ("SKIP_TEST_COMMAND");
9595 if (str && strcmp (str, "1") == 0) return 1;
9599 static int test_command_6 (void)
9601 if (test_command_6_skip ()) {
9602 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9606 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9608 char device[] = "/dev/sda";
9611 r = guestfs_blockdev_setrw (g, device);
9618 r = guestfs_umount_all (g);
9625 r = guestfs_lvm_remove_all (g);
9630 char device[] = "/dev/sda";
9631 char lines_0[] = ",";
9638 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9643 char fstype[] = "ext2";
9644 char device[] = "/dev/sda1";
9647 r = guestfs_mkfs (g, fstype, device);
9652 char device[] = "/dev/sda1";
9653 char mountpoint[] = "/";
9656 r = guestfs_mount (g, device, mountpoint);
9660 /* TestOutput for command (6) */
9661 char expected[] = "";
9663 char remotefilename[] = "/test-command";
9666 r = guestfs_upload (g, "test-command", remotefilename);
9671 char path[] = "/test-command";
9674 r = guestfs_chmod (g, 493, path);
9679 char arguments_0[] = "/test-command";
9680 char arguments_1[] = "7";
9681 char *arguments[] = {
9688 r = guestfs_command (g, arguments);
9691 if (strcmp (r, expected) != 0) {
9692 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9700 static int test_command_7_skip (void)
9704 str = getenv ("SKIP_TEST_COMMAND_7");
9705 if (str && strcmp (str, "1") == 0) return 1;
9706 str = getenv ("SKIP_TEST_COMMAND");
9707 if (str && strcmp (str, "1") == 0) return 1;
9711 static int test_command_7 (void)
9713 if (test_command_7_skip ()) {
9714 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9718 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9720 char device[] = "/dev/sda";
9723 r = guestfs_blockdev_setrw (g, device);
9730 r = guestfs_umount_all (g);
9737 r = guestfs_lvm_remove_all (g);
9742 char device[] = "/dev/sda";
9743 char lines_0[] = ",";
9750 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9755 char fstype[] = "ext2";
9756 char device[] = "/dev/sda1";
9759 r = guestfs_mkfs (g, fstype, device);
9764 char device[] = "/dev/sda1";
9765 char mountpoint[] = "/";
9768 r = guestfs_mount (g, device, mountpoint);
9772 /* TestOutput for command (7) */
9773 char expected[] = "\n";
9775 char remotefilename[] = "/test-command";
9778 r = guestfs_upload (g, "test-command", remotefilename);
9783 char path[] = "/test-command";
9786 r = guestfs_chmod (g, 493, path);
9791 char arguments_0[] = "/test-command";
9792 char arguments_1[] = "8";
9793 char *arguments[] = {
9800 r = guestfs_command (g, arguments);
9803 if (strcmp (r, expected) != 0) {
9804 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9812 static int test_command_8_skip (void)
9816 str = getenv ("SKIP_TEST_COMMAND_8");
9817 if (str && strcmp (str, "1") == 0) return 1;
9818 str = getenv ("SKIP_TEST_COMMAND");
9819 if (str && strcmp (str, "1") == 0) return 1;
9823 static int test_command_8 (void)
9825 if (test_command_8_skip ()) {
9826 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9830 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9832 char device[] = "/dev/sda";
9835 r = guestfs_blockdev_setrw (g, device);
9842 r = guestfs_umount_all (g);
9849 r = guestfs_lvm_remove_all (g);
9854 char device[] = "/dev/sda";
9855 char lines_0[] = ",";
9862 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9867 char fstype[] = "ext2";
9868 char device[] = "/dev/sda1";
9871 r = guestfs_mkfs (g, fstype, device);
9876 char device[] = "/dev/sda1";
9877 char mountpoint[] = "/";
9880 r = guestfs_mount (g, device, mountpoint);
9884 /* TestOutput for command (8) */
9885 char expected[] = "\n\n";
9887 char remotefilename[] = "/test-command";
9890 r = guestfs_upload (g, "test-command", remotefilename);
9895 char path[] = "/test-command";
9898 r = guestfs_chmod (g, 493, path);
9903 char arguments_0[] = "/test-command";
9904 char arguments_1[] = "9";
9905 char *arguments[] = {
9912 r = guestfs_command (g, arguments);
9915 if (strcmp (r, expected) != 0) {
9916 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9924 static int test_command_9_skip (void)
9928 str = getenv ("SKIP_TEST_COMMAND_9");
9929 if (str && strcmp (str, "1") == 0) return 1;
9930 str = getenv ("SKIP_TEST_COMMAND");
9931 if (str && strcmp (str, "1") == 0) return 1;
9935 static int test_command_9 (void)
9937 if (test_command_9_skip ()) {
9938 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9942 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9944 char device[] = "/dev/sda";
9947 r = guestfs_blockdev_setrw (g, device);
9954 r = guestfs_umount_all (g);
9961 r = guestfs_lvm_remove_all (g);
9966 char device[] = "/dev/sda";
9967 char lines_0[] = ",";
9974 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9979 char fstype[] = "ext2";
9980 char device[] = "/dev/sda1";
9983 r = guestfs_mkfs (g, fstype, device);
9988 char device[] = "/dev/sda1";
9989 char mountpoint[] = "/";
9992 r = guestfs_mount (g, device, mountpoint);
9996 /* TestOutput for command (9) */
9997 char expected[] = "Result10-1\nResult10-2\n";
9999 char remotefilename[] = "/test-command";
10001 suppress_error = 0;
10002 r = guestfs_upload (g, "test-command", remotefilename);
10007 char path[] = "/test-command";
10009 suppress_error = 0;
10010 r = guestfs_chmod (g, 493, path);
10015 char arguments_0[] = "/test-command";
10016 char arguments_1[] = "10";
10017 char *arguments[] = {
10023 suppress_error = 0;
10024 r = guestfs_command (g, arguments);
10027 if (strcmp (r, expected) != 0) {
10028 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10036 static int test_command_10_skip (void)
10040 str = getenv ("SKIP_TEST_COMMAND_10");
10041 if (str && strcmp (str, "1") == 0) return 1;
10042 str = getenv ("SKIP_TEST_COMMAND");
10043 if (str && strcmp (str, "1") == 0) return 1;
10047 static int test_command_10 (void)
10049 if (test_command_10_skip ()) {
10050 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
10054 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10056 char device[] = "/dev/sda";
10058 suppress_error = 0;
10059 r = guestfs_blockdev_setrw (g, device);
10065 suppress_error = 0;
10066 r = guestfs_umount_all (g);
10072 suppress_error = 0;
10073 r = guestfs_lvm_remove_all (g);
10078 char device[] = "/dev/sda";
10079 char lines_0[] = ",";
10085 suppress_error = 0;
10086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10091 char fstype[] = "ext2";
10092 char device[] = "/dev/sda1";
10094 suppress_error = 0;
10095 r = guestfs_mkfs (g, fstype, device);
10100 char device[] = "/dev/sda1";
10101 char mountpoint[] = "/";
10103 suppress_error = 0;
10104 r = guestfs_mount (g, device, mountpoint);
10108 /* TestOutput for command (10) */
10109 char expected[] = "Result11-1\nResult11-2";
10111 char remotefilename[] = "/test-command";
10113 suppress_error = 0;
10114 r = guestfs_upload (g, "test-command", remotefilename);
10119 char path[] = "/test-command";
10121 suppress_error = 0;
10122 r = guestfs_chmod (g, 493, path);
10127 char arguments_0[] = "/test-command";
10128 char arguments_1[] = "11";
10129 char *arguments[] = {
10135 suppress_error = 0;
10136 r = guestfs_command (g, arguments);
10139 if (strcmp (r, expected) != 0) {
10140 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10148 static int test_command_11_skip (void)
10152 str = getenv ("SKIP_TEST_COMMAND_11");
10153 if (str && strcmp (str, "1") == 0) return 1;
10154 str = getenv ("SKIP_TEST_COMMAND");
10155 if (str && strcmp (str, "1") == 0) return 1;
10159 static int test_command_11 (void)
10161 if (test_command_11_skip ()) {
10162 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10166 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10168 char device[] = "/dev/sda";
10170 suppress_error = 0;
10171 r = guestfs_blockdev_setrw (g, device);
10177 suppress_error = 0;
10178 r = guestfs_umount_all (g);
10184 suppress_error = 0;
10185 r = guestfs_lvm_remove_all (g);
10190 char device[] = "/dev/sda";
10191 char lines_0[] = ",";
10197 suppress_error = 0;
10198 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10203 char fstype[] = "ext2";
10204 char device[] = "/dev/sda1";
10206 suppress_error = 0;
10207 r = guestfs_mkfs (g, fstype, device);
10212 char device[] = "/dev/sda1";
10213 char mountpoint[] = "/";
10215 suppress_error = 0;
10216 r = guestfs_mount (g, device, mountpoint);
10220 /* TestLastFail for command (11) */
10222 char remotefilename[] = "/test-command";
10224 suppress_error = 0;
10225 r = guestfs_upload (g, "test-command", remotefilename);
10230 char path[] = "/test-command";
10232 suppress_error = 0;
10233 r = guestfs_chmod (g, 493, path);
10238 char arguments_0[] = "/test-command";
10239 char *arguments[] = {
10244 suppress_error = 1;
10245 r = guestfs_command (g, arguments);
10253 static int test_file_0_skip (void)
10257 str = getenv ("SKIP_TEST_FILE_0");
10258 if (str && strcmp (str, "1") == 0) return 1;
10259 str = getenv ("SKIP_TEST_FILE");
10260 if (str && strcmp (str, "1") == 0) return 1;
10264 static int test_file_0 (void)
10266 if (test_file_0_skip ()) {
10267 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10271 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10273 char device[] = "/dev/sda";
10275 suppress_error = 0;
10276 r = guestfs_blockdev_setrw (g, device);
10282 suppress_error = 0;
10283 r = guestfs_umount_all (g);
10289 suppress_error = 0;
10290 r = guestfs_lvm_remove_all (g);
10295 char device[] = "/dev/sda";
10296 char lines_0[] = ",";
10302 suppress_error = 0;
10303 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10308 char fstype[] = "ext2";
10309 char device[] = "/dev/sda1";
10311 suppress_error = 0;
10312 r = guestfs_mkfs (g, fstype, device);
10317 char device[] = "/dev/sda1";
10318 char mountpoint[] = "/";
10320 suppress_error = 0;
10321 r = guestfs_mount (g, device, mountpoint);
10325 /* TestOutput for file (0) */
10326 char expected[] = "empty";
10328 char path[] = "/new";
10330 suppress_error = 0;
10331 r = guestfs_touch (g, path);
10336 char path[] = "/new";
10338 suppress_error = 0;
10339 r = guestfs_file (g, path);
10342 if (strcmp (r, expected) != 0) {
10343 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10351 static int test_file_1_skip (void)
10355 str = getenv ("SKIP_TEST_FILE_1");
10356 if (str && strcmp (str, "1") == 0) return 1;
10357 str = getenv ("SKIP_TEST_FILE");
10358 if (str && strcmp (str, "1") == 0) return 1;
10362 static int test_file_1 (void)
10364 if (test_file_1_skip ()) {
10365 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10369 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10371 char device[] = "/dev/sda";
10373 suppress_error = 0;
10374 r = guestfs_blockdev_setrw (g, device);
10380 suppress_error = 0;
10381 r = guestfs_umount_all (g);
10387 suppress_error = 0;
10388 r = guestfs_lvm_remove_all (g);
10393 char device[] = "/dev/sda";
10394 char lines_0[] = ",";
10400 suppress_error = 0;
10401 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10406 char fstype[] = "ext2";
10407 char device[] = "/dev/sda1";
10409 suppress_error = 0;
10410 r = guestfs_mkfs (g, fstype, device);
10415 char device[] = "/dev/sda1";
10416 char mountpoint[] = "/";
10418 suppress_error = 0;
10419 r = guestfs_mount (g, device, mountpoint);
10423 /* TestOutput for file (1) */
10424 char expected[] = "ASCII text";
10426 char path[] = "/new";
10427 char content[] = "some content\n";
10429 suppress_error = 0;
10430 r = guestfs_write_file (g, path, content, 0);
10435 char path[] = "/new";
10437 suppress_error = 0;
10438 r = guestfs_file (g, path);
10441 if (strcmp (r, expected) != 0) {
10442 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10450 static int test_file_2_skip (void)
10454 str = getenv ("SKIP_TEST_FILE_2");
10455 if (str && strcmp (str, "1") == 0) return 1;
10456 str = getenv ("SKIP_TEST_FILE");
10457 if (str && strcmp (str, "1") == 0) return 1;
10461 static int test_file_2 (void)
10463 if (test_file_2_skip ()) {
10464 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10468 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10470 char device[] = "/dev/sda";
10472 suppress_error = 0;
10473 r = guestfs_blockdev_setrw (g, device);
10479 suppress_error = 0;
10480 r = guestfs_umount_all (g);
10486 suppress_error = 0;
10487 r = guestfs_lvm_remove_all (g);
10492 char device[] = "/dev/sda";
10493 char lines_0[] = ",";
10499 suppress_error = 0;
10500 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10505 char fstype[] = "ext2";
10506 char device[] = "/dev/sda1";
10508 suppress_error = 0;
10509 r = guestfs_mkfs (g, fstype, device);
10514 char device[] = "/dev/sda1";
10515 char mountpoint[] = "/";
10517 suppress_error = 0;
10518 r = guestfs_mount (g, device, mountpoint);
10522 /* TestLastFail for file (2) */
10524 char path[] = "/nofile";
10526 suppress_error = 1;
10527 r = guestfs_file (g, path);
10535 static int test_umount_all_0_skip (void)
10539 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10540 if (str && strcmp (str, "1") == 0) return 1;
10541 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10542 if (str && strcmp (str, "1") == 0) return 1;
10546 static int test_umount_all_0 (void)
10548 if (test_umount_all_0_skip ()) {
10549 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10553 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10555 char device[] = "/dev/sda";
10557 suppress_error = 0;
10558 r = guestfs_blockdev_setrw (g, device);
10564 suppress_error = 0;
10565 r = guestfs_umount_all (g);
10571 suppress_error = 0;
10572 r = guestfs_lvm_remove_all (g);
10577 char device[] = "/dev/sda";
10578 char lines_0[] = ",";
10584 suppress_error = 0;
10585 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10590 char fstype[] = "ext2";
10591 char device[] = "/dev/sda1";
10593 suppress_error = 0;
10594 r = guestfs_mkfs (g, fstype, device);
10599 char device[] = "/dev/sda1";
10600 char mountpoint[] = "/";
10602 suppress_error = 0;
10603 r = guestfs_mount (g, device, mountpoint);
10607 /* TestOutputList for umount_all (0) */
10610 suppress_error = 0;
10611 r = guestfs_umount_all (g);
10618 suppress_error = 0;
10619 r = guestfs_mounts (g);
10622 if (r[0] != NULL) {
10623 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10627 for (i = 0; r[i] != NULL; ++i)
10634 static int test_umount_all_1_skip (void)
10638 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10639 if (str && strcmp (str, "1") == 0) return 1;
10640 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10641 if (str && strcmp (str, "1") == 0) return 1;
10645 static int test_umount_all_1 (void)
10647 if (test_umount_all_1_skip ()) {
10648 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10652 /* InitNone|InitEmpty for test_umount_all_1 */
10654 char device[] = "/dev/sda";
10656 suppress_error = 0;
10657 r = guestfs_blockdev_setrw (g, device);
10663 suppress_error = 0;
10664 r = guestfs_umount_all (g);
10670 suppress_error = 0;
10671 r = guestfs_lvm_remove_all (g);
10675 /* TestOutputList for umount_all (1) */
10677 char device[] = "/dev/sda";
10678 char lines_0[] = ",10";
10679 char lines_1[] = ",20";
10680 char lines_2[] = ",";
10688 suppress_error = 0;
10689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10694 char fstype[] = "ext2";
10695 char device[] = "/dev/sda1";
10697 suppress_error = 0;
10698 r = guestfs_mkfs (g, fstype, device);
10703 char fstype[] = "ext2";
10704 char device[] = "/dev/sda2";
10706 suppress_error = 0;
10707 r = guestfs_mkfs (g, fstype, device);
10712 char fstype[] = "ext2";
10713 char device[] = "/dev/sda3";
10715 suppress_error = 0;
10716 r = guestfs_mkfs (g, fstype, device);
10721 char device[] = "/dev/sda1";
10722 char mountpoint[] = "/";
10724 suppress_error = 0;
10725 r = guestfs_mount (g, device, mountpoint);
10730 char path[] = "/mp1";
10732 suppress_error = 0;
10733 r = guestfs_mkdir (g, path);
10738 char device[] = "/dev/sda2";
10739 char mountpoint[] = "/mp1";
10741 suppress_error = 0;
10742 r = guestfs_mount (g, device, mountpoint);
10747 char path[] = "/mp1/mp2";
10749 suppress_error = 0;
10750 r = guestfs_mkdir (g, path);
10755 char device[] = "/dev/sda3";
10756 char mountpoint[] = "/mp1/mp2";
10758 suppress_error = 0;
10759 r = guestfs_mount (g, device, mountpoint);
10764 char path[] = "/mp1/mp2/mp3";
10766 suppress_error = 0;
10767 r = guestfs_mkdir (g, path);
10773 suppress_error = 0;
10774 r = guestfs_umount_all (g);
10781 suppress_error = 0;
10782 r = guestfs_mounts (g);
10785 if (r[0] != NULL) {
10786 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10790 for (i = 0; r[i] != NULL; ++i)
10797 static int test_mounts_0_skip (void)
10801 str = getenv ("SKIP_TEST_MOUNTS_0");
10802 if (str && strcmp (str, "1") == 0) return 1;
10803 str = getenv ("SKIP_TEST_MOUNTS");
10804 if (str && strcmp (str, "1") == 0) return 1;
10808 static int test_mounts_0 (void)
10810 if (test_mounts_0_skip ()) {
10811 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10815 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10817 char device[] = "/dev/sda";
10819 suppress_error = 0;
10820 r = guestfs_blockdev_setrw (g, device);
10826 suppress_error = 0;
10827 r = guestfs_umount_all (g);
10833 suppress_error = 0;
10834 r = guestfs_lvm_remove_all (g);
10839 char device[] = "/dev/sda";
10840 char lines_0[] = ",";
10846 suppress_error = 0;
10847 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10852 char fstype[] = "ext2";
10853 char device[] = "/dev/sda1";
10855 suppress_error = 0;
10856 r = guestfs_mkfs (g, fstype, device);
10861 char device[] = "/dev/sda1";
10862 char mountpoint[] = "/";
10864 suppress_error = 0;
10865 r = guestfs_mount (g, device, mountpoint);
10869 /* TestOutputListOfDevices for mounts (0) */
10873 suppress_error = 0;
10874 r = guestfs_mounts (g);
10878 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10883 char expected[] = "/dev/sda1";
10885 if (strcmp (r[0], expected) != 0) {
10886 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10890 if (r[1] != NULL) {
10891 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10895 for (i = 0; r[i] != NULL; ++i)
10902 static int test_umount_0_skip (void)
10906 str = getenv ("SKIP_TEST_UMOUNT_0");
10907 if (str && strcmp (str, "1") == 0) return 1;
10908 str = getenv ("SKIP_TEST_UMOUNT");
10909 if (str && strcmp (str, "1") == 0) return 1;
10913 static int test_umount_0 (void)
10915 if (test_umount_0_skip ()) {
10916 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10920 /* InitNone|InitEmpty for test_umount_0 */
10922 char device[] = "/dev/sda";
10924 suppress_error = 0;
10925 r = guestfs_blockdev_setrw (g, device);
10931 suppress_error = 0;
10932 r = guestfs_umount_all (g);
10938 suppress_error = 0;
10939 r = guestfs_lvm_remove_all (g);
10943 /* TestOutputListOfDevices for umount (0) */
10945 char device[] = "/dev/sda";
10946 char lines_0[] = ",";
10952 suppress_error = 0;
10953 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10958 char fstype[] = "ext2";
10959 char device[] = "/dev/sda1";
10961 suppress_error = 0;
10962 r = guestfs_mkfs (g, fstype, device);
10967 char device[] = "/dev/sda1";
10968 char mountpoint[] = "/";
10970 suppress_error = 0;
10971 r = guestfs_mount (g, device, mountpoint);
10978 suppress_error = 0;
10979 r = guestfs_mounts (g);
10983 fprintf (stderr, "test_umount_0: short list returned from command\n");
10988 char expected[] = "/dev/sda1";
10990 if (strcmp (r[0], expected) != 0) {
10991 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10995 if (r[1] != NULL) {
10996 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
11000 for (i = 0; r[i] != NULL; ++i)
11007 static int test_umount_1_skip (void)
11011 str = getenv ("SKIP_TEST_UMOUNT_1");
11012 if (str && strcmp (str, "1") == 0) return 1;
11013 str = getenv ("SKIP_TEST_UMOUNT");
11014 if (str && strcmp (str, "1") == 0) return 1;
11018 static int test_umount_1 (void)
11020 if (test_umount_1_skip ()) {
11021 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
11025 /* InitNone|InitEmpty for test_umount_1 */
11027 char device[] = "/dev/sda";
11029 suppress_error = 0;
11030 r = guestfs_blockdev_setrw (g, device);
11036 suppress_error = 0;
11037 r = guestfs_umount_all (g);
11043 suppress_error = 0;
11044 r = guestfs_lvm_remove_all (g);
11048 /* TestOutputList for umount (1) */
11050 char device[] = "/dev/sda";
11051 char lines_0[] = ",";
11057 suppress_error = 0;
11058 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11063 char fstype[] = "ext2";
11064 char device[] = "/dev/sda1";
11066 suppress_error = 0;
11067 r = guestfs_mkfs (g, fstype, device);
11072 char device[] = "/dev/sda1";
11073 char mountpoint[] = "/";
11075 suppress_error = 0;
11076 r = guestfs_mount (g, device, mountpoint);
11081 char pathordevice[] = "/";
11083 suppress_error = 0;
11084 r = guestfs_umount (g, pathordevice);
11091 suppress_error = 0;
11092 r = guestfs_mounts (g);
11095 if (r[0] != NULL) {
11096 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11100 for (i = 0; r[i] != NULL; ++i)
11107 static int test_write_file_0_skip (void)
11111 str = getenv ("SKIP_TEST_WRITE_FILE_0");
11112 if (str && strcmp (str, "1") == 0) return 1;
11113 str = getenv ("SKIP_TEST_WRITE_FILE");
11114 if (str && strcmp (str, "1") == 0) return 1;
11118 static int test_write_file_0 (void)
11120 if (test_write_file_0_skip ()) {
11121 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
11125 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11127 char device[] = "/dev/sda";
11129 suppress_error = 0;
11130 r = guestfs_blockdev_setrw (g, device);
11136 suppress_error = 0;
11137 r = guestfs_umount_all (g);
11143 suppress_error = 0;
11144 r = guestfs_lvm_remove_all (g);
11149 char device[] = "/dev/sda";
11150 char lines_0[] = ",";
11156 suppress_error = 0;
11157 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11162 char fstype[] = "ext2";
11163 char device[] = "/dev/sda1";
11165 suppress_error = 0;
11166 r = guestfs_mkfs (g, fstype, device);
11171 char device[] = "/dev/sda1";
11172 char mountpoint[] = "/";
11174 suppress_error = 0;
11175 r = guestfs_mount (g, device, mountpoint);
11179 /* TestOutput for write_file (0) */
11180 char expected[] = "new file contents";
11182 char path[] = "/new";
11183 char content[] = "new file contents";
11185 suppress_error = 0;
11186 r = guestfs_write_file (g, path, content, 0);
11191 char path[] = "/new";
11193 suppress_error = 0;
11194 r = guestfs_cat (g, path);
11197 if (strcmp (r, expected) != 0) {
11198 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11206 static int test_write_file_1_skip (void)
11210 str = getenv ("SKIP_TEST_WRITE_FILE_1");
11211 if (str && strcmp (str, "1") == 0) return 1;
11212 str = getenv ("SKIP_TEST_WRITE_FILE");
11213 if (str && strcmp (str, "1") == 0) return 1;
11217 static int test_write_file_1 (void)
11219 if (test_write_file_1_skip ()) {
11220 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11224 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11226 char device[] = "/dev/sda";
11228 suppress_error = 0;
11229 r = guestfs_blockdev_setrw (g, device);
11235 suppress_error = 0;
11236 r = guestfs_umount_all (g);
11242 suppress_error = 0;
11243 r = guestfs_lvm_remove_all (g);
11248 char device[] = "/dev/sda";
11249 char lines_0[] = ",";
11255 suppress_error = 0;
11256 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11261 char fstype[] = "ext2";
11262 char device[] = "/dev/sda1";
11264 suppress_error = 0;
11265 r = guestfs_mkfs (g, fstype, device);
11270 char device[] = "/dev/sda1";
11271 char mountpoint[] = "/";
11273 suppress_error = 0;
11274 r = guestfs_mount (g, device, mountpoint);
11278 /* TestOutput for write_file (1) */
11279 char expected[] = "\nnew file contents\n";
11281 char path[] = "/new";
11282 char content[] = "\nnew file contents\n";
11284 suppress_error = 0;
11285 r = guestfs_write_file (g, path, content, 0);
11290 char path[] = "/new";
11292 suppress_error = 0;
11293 r = guestfs_cat (g, path);
11296 if (strcmp (r, expected) != 0) {
11297 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11305 static int test_write_file_2_skip (void)
11309 str = getenv ("SKIP_TEST_WRITE_FILE_2");
11310 if (str && strcmp (str, "1") == 0) return 1;
11311 str = getenv ("SKIP_TEST_WRITE_FILE");
11312 if (str && strcmp (str, "1") == 0) return 1;
11316 static int test_write_file_2 (void)
11318 if (test_write_file_2_skip ()) {
11319 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11323 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11325 char device[] = "/dev/sda";
11327 suppress_error = 0;
11328 r = guestfs_blockdev_setrw (g, device);
11334 suppress_error = 0;
11335 r = guestfs_umount_all (g);
11341 suppress_error = 0;
11342 r = guestfs_lvm_remove_all (g);
11347 char device[] = "/dev/sda";
11348 char lines_0[] = ",";
11354 suppress_error = 0;
11355 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11360 char fstype[] = "ext2";
11361 char device[] = "/dev/sda1";
11363 suppress_error = 0;
11364 r = guestfs_mkfs (g, fstype, device);
11369 char device[] = "/dev/sda1";
11370 char mountpoint[] = "/";
11372 suppress_error = 0;
11373 r = guestfs_mount (g, device, mountpoint);
11377 /* TestOutput for write_file (2) */
11378 char expected[] = "\n\n";
11380 char path[] = "/new";
11381 char content[] = "\n\n";
11383 suppress_error = 0;
11384 r = guestfs_write_file (g, path, content, 0);
11389 char path[] = "/new";
11391 suppress_error = 0;
11392 r = guestfs_cat (g, path);
11395 if (strcmp (r, expected) != 0) {
11396 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11404 static int test_write_file_3_skip (void)
11408 str = getenv ("SKIP_TEST_WRITE_FILE_3");
11409 if (str && strcmp (str, "1") == 0) return 1;
11410 str = getenv ("SKIP_TEST_WRITE_FILE");
11411 if (str && strcmp (str, "1") == 0) return 1;
11415 static int test_write_file_3 (void)
11417 if (test_write_file_3_skip ()) {
11418 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11422 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11424 char device[] = "/dev/sda";
11426 suppress_error = 0;
11427 r = guestfs_blockdev_setrw (g, device);
11433 suppress_error = 0;
11434 r = guestfs_umount_all (g);
11440 suppress_error = 0;
11441 r = guestfs_lvm_remove_all (g);
11446 char device[] = "/dev/sda";
11447 char lines_0[] = ",";
11453 suppress_error = 0;
11454 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11459 char fstype[] = "ext2";
11460 char device[] = "/dev/sda1";
11462 suppress_error = 0;
11463 r = guestfs_mkfs (g, fstype, device);
11468 char device[] = "/dev/sda1";
11469 char mountpoint[] = "/";
11471 suppress_error = 0;
11472 r = guestfs_mount (g, device, mountpoint);
11476 /* TestOutput for write_file (3) */
11477 char expected[] = "";
11479 char path[] = "/new";
11480 char content[] = "";
11482 suppress_error = 0;
11483 r = guestfs_write_file (g, path, content, 0);
11488 char path[] = "/new";
11490 suppress_error = 0;
11491 r = guestfs_cat (g, path);
11494 if (strcmp (r, expected) != 0) {
11495 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11503 static int test_write_file_4_skip (void)
11507 str = getenv ("SKIP_TEST_WRITE_FILE_4");
11508 if (str && strcmp (str, "1") == 0) return 1;
11509 str = getenv ("SKIP_TEST_WRITE_FILE");
11510 if (str && strcmp (str, "1") == 0) return 1;
11514 static int test_write_file_4 (void)
11516 if (test_write_file_4_skip ()) {
11517 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11521 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11523 char device[] = "/dev/sda";
11525 suppress_error = 0;
11526 r = guestfs_blockdev_setrw (g, device);
11532 suppress_error = 0;
11533 r = guestfs_umount_all (g);
11539 suppress_error = 0;
11540 r = guestfs_lvm_remove_all (g);
11545 char device[] = "/dev/sda";
11546 char lines_0[] = ",";
11552 suppress_error = 0;
11553 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11558 char fstype[] = "ext2";
11559 char device[] = "/dev/sda1";
11561 suppress_error = 0;
11562 r = guestfs_mkfs (g, fstype, device);
11567 char device[] = "/dev/sda1";
11568 char mountpoint[] = "/";
11570 suppress_error = 0;
11571 r = guestfs_mount (g, device, mountpoint);
11575 /* TestOutput for write_file (4) */
11576 char expected[] = "\n\n\n";
11578 char path[] = "/new";
11579 char content[] = "\n\n\n";
11581 suppress_error = 0;
11582 r = guestfs_write_file (g, path, content, 0);
11587 char path[] = "/new";
11589 suppress_error = 0;
11590 r = guestfs_cat (g, path);
11593 if (strcmp (r, expected) != 0) {
11594 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11602 static int test_write_file_5_skip (void)
11606 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11607 if (str && strcmp (str, "1") == 0) return 1;
11608 str = getenv ("SKIP_TEST_WRITE_FILE");
11609 if (str && strcmp (str, "1") == 0) return 1;
11613 static int test_write_file_5 (void)
11615 if (test_write_file_5_skip ()) {
11616 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11620 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11622 char device[] = "/dev/sda";
11624 suppress_error = 0;
11625 r = guestfs_blockdev_setrw (g, device);
11631 suppress_error = 0;
11632 r = guestfs_umount_all (g);
11638 suppress_error = 0;
11639 r = guestfs_lvm_remove_all (g);
11644 char device[] = "/dev/sda";
11645 char lines_0[] = ",";
11651 suppress_error = 0;
11652 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11657 char fstype[] = "ext2";
11658 char device[] = "/dev/sda1";
11660 suppress_error = 0;
11661 r = guestfs_mkfs (g, fstype, device);
11666 char device[] = "/dev/sda1";
11667 char mountpoint[] = "/";
11669 suppress_error = 0;
11670 r = guestfs_mount (g, device, mountpoint);
11674 /* TestOutput for write_file (5) */
11675 char expected[] = "\n";
11677 char path[] = "/new";
11678 char content[] = "\n";
11680 suppress_error = 0;
11681 r = guestfs_write_file (g, path, content, 0);
11686 char path[] = "/new";
11688 suppress_error = 0;
11689 r = guestfs_cat (g, path);
11692 if (strcmp (r, expected) != 0) {
11693 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11701 static int test_mkfs_0_skip (void)
11705 str = getenv ("SKIP_TEST_MKFS_0");
11706 if (str && strcmp (str, "1") == 0) return 1;
11707 str = getenv ("SKIP_TEST_MKFS");
11708 if (str && strcmp (str, "1") == 0) return 1;
11712 static int test_mkfs_0 (void)
11714 if (test_mkfs_0_skip ()) {
11715 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11719 /* InitNone|InitEmpty for test_mkfs_0 */
11721 char device[] = "/dev/sda";
11723 suppress_error = 0;
11724 r = guestfs_blockdev_setrw (g, device);
11730 suppress_error = 0;
11731 r = guestfs_umount_all (g);
11737 suppress_error = 0;
11738 r = guestfs_lvm_remove_all (g);
11742 /* TestOutput for mkfs (0) */
11743 char expected[] = "new file contents";
11745 char device[] = "/dev/sda";
11746 char lines_0[] = ",";
11752 suppress_error = 0;
11753 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11758 char fstype[] = "ext2";
11759 char device[] = "/dev/sda1";
11761 suppress_error = 0;
11762 r = guestfs_mkfs (g, fstype, device);
11767 char device[] = "/dev/sda1";
11768 char mountpoint[] = "/";
11770 suppress_error = 0;
11771 r = guestfs_mount (g, device, mountpoint);
11776 char path[] = "/new";
11777 char content[] = "new file contents";
11779 suppress_error = 0;
11780 r = guestfs_write_file (g, path, content, 0);
11785 char path[] = "/new";
11787 suppress_error = 0;
11788 r = guestfs_cat (g, path);
11791 if (strcmp (r, expected) != 0) {
11792 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11800 static int test_lvcreate_0_skip (void)
11804 str = getenv ("SKIP_TEST_LVCREATE_0");
11805 if (str && strcmp (str, "1") == 0) return 1;
11806 str = getenv ("SKIP_TEST_LVCREATE");
11807 if (str && strcmp (str, "1") == 0) return 1;
11811 static int test_lvcreate_0 (void)
11813 if (test_lvcreate_0_skip ()) {
11814 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11818 /* InitNone|InitEmpty for test_lvcreate_0 */
11820 char device[] = "/dev/sda";
11822 suppress_error = 0;
11823 r = guestfs_blockdev_setrw (g, device);
11829 suppress_error = 0;
11830 r = guestfs_umount_all (g);
11836 suppress_error = 0;
11837 r = guestfs_lvm_remove_all (g);
11841 /* TestOutputList for lvcreate (0) */
11843 char device[] = "/dev/sda";
11844 char lines_0[] = ",10";
11845 char lines_1[] = ",20";
11846 char lines_2[] = ",";
11854 suppress_error = 0;
11855 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11860 char device[] = "/dev/sda1";
11862 suppress_error = 0;
11863 r = guestfs_pvcreate (g, device);
11868 char device[] = "/dev/sda2";
11870 suppress_error = 0;
11871 r = guestfs_pvcreate (g, device);
11876 char device[] = "/dev/sda3";
11878 suppress_error = 0;
11879 r = guestfs_pvcreate (g, device);
11884 char volgroup[] = "VG1";
11885 char physvols_0[] = "/dev/sda1";
11886 char physvols_1[] = "/dev/sda2";
11887 char *physvols[] = {
11893 suppress_error = 0;
11894 r = guestfs_vgcreate (g, volgroup, physvols);
11899 char volgroup[] = "VG2";
11900 char physvols_0[] = "/dev/sda3";
11901 char *physvols[] = {
11906 suppress_error = 0;
11907 r = guestfs_vgcreate (g, volgroup, physvols);
11912 char logvol[] = "LV1";
11913 char volgroup[] = "VG1";
11915 suppress_error = 0;
11916 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11921 char logvol[] = "LV2";
11922 char volgroup[] = "VG1";
11924 suppress_error = 0;
11925 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11930 char logvol[] = "LV3";
11931 char volgroup[] = "VG2";
11933 suppress_error = 0;
11934 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11939 char logvol[] = "LV4";
11940 char volgroup[] = "VG2";
11942 suppress_error = 0;
11943 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11948 char logvol[] = "LV5";
11949 char volgroup[] = "VG2";
11951 suppress_error = 0;
11952 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11959 suppress_error = 0;
11960 r = guestfs_lvs (g);
11964 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11969 char expected[] = "/dev/VG1/LV1";
11970 if (strcmp (r[0], expected) != 0) {
11971 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11976 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11981 char expected[] = "/dev/VG1/LV2";
11982 if (strcmp (r[1], expected) != 0) {
11983 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11988 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11993 char expected[] = "/dev/VG2/LV3";
11994 if (strcmp (r[2], expected) != 0) {
11995 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12000 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12005 char expected[] = "/dev/VG2/LV4";
12006 if (strcmp (r[3], expected) != 0) {
12007 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12012 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12017 char expected[] = "/dev/VG2/LV5";
12018 if (strcmp (r[4], expected) != 0) {
12019 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12023 if (r[5] != NULL) {
12024 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12028 for (i = 0; r[i] != NULL; ++i)
12035 static int test_vgcreate_0_skip (void)
12039 str = getenv ("SKIP_TEST_VGCREATE_0");
12040 if (str && strcmp (str, "1") == 0) return 1;
12041 str = getenv ("SKIP_TEST_VGCREATE");
12042 if (str && strcmp (str, "1") == 0) return 1;
12046 static int test_vgcreate_0 (void)
12048 if (test_vgcreate_0_skip ()) {
12049 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
12053 /* InitNone|InitEmpty for test_vgcreate_0 */
12055 char device[] = "/dev/sda";
12057 suppress_error = 0;
12058 r = guestfs_blockdev_setrw (g, device);
12064 suppress_error = 0;
12065 r = guestfs_umount_all (g);
12071 suppress_error = 0;
12072 r = guestfs_lvm_remove_all (g);
12076 /* TestOutputList for vgcreate (0) */
12078 char device[] = "/dev/sda";
12079 char lines_0[] = ",10";
12080 char lines_1[] = ",20";
12081 char lines_2[] = ",";
12089 suppress_error = 0;
12090 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12095 char device[] = "/dev/sda1";
12097 suppress_error = 0;
12098 r = guestfs_pvcreate (g, device);
12103 char device[] = "/dev/sda2";
12105 suppress_error = 0;
12106 r = guestfs_pvcreate (g, device);
12111 char device[] = "/dev/sda3";
12113 suppress_error = 0;
12114 r = guestfs_pvcreate (g, device);
12119 char volgroup[] = "VG1";
12120 char physvols_0[] = "/dev/sda1";
12121 char physvols_1[] = "/dev/sda2";
12122 char *physvols[] = {
12128 suppress_error = 0;
12129 r = guestfs_vgcreate (g, volgroup, physvols);
12134 char volgroup[] = "VG2";
12135 char physvols_0[] = "/dev/sda3";
12136 char *physvols[] = {
12141 suppress_error = 0;
12142 r = guestfs_vgcreate (g, volgroup, physvols);
12149 suppress_error = 0;
12150 r = guestfs_vgs (g);
12154 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12159 char expected[] = "VG1";
12160 if (strcmp (r[0], expected) != 0) {
12161 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12166 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12171 char expected[] = "VG2";
12172 if (strcmp (r[1], expected) != 0) {
12173 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12177 if (r[2] != NULL) {
12178 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12182 for (i = 0; r[i] != NULL; ++i)
12189 static int test_pvcreate_0_skip (void)
12193 str = getenv ("SKIP_TEST_PVCREATE_0");
12194 if (str && strcmp (str, "1") == 0) return 1;
12195 str = getenv ("SKIP_TEST_PVCREATE");
12196 if (str && strcmp (str, "1") == 0) return 1;
12200 static int test_pvcreate_0 (void)
12202 if (test_pvcreate_0_skip ()) {
12203 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12207 /* InitNone|InitEmpty for test_pvcreate_0 */
12209 char device[] = "/dev/sda";
12211 suppress_error = 0;
12212 r = guestfs_blockdev_setrw (g, device);
12218 suppress_error = 0;
12219 r = guestfs_umount_all (g);
12225 suppress_error = 0;
12226 r = guestfs_lvm_remove_all (g);
12230 /* TestOutputListOfDevices for pvcreate (0) */
12232 char device[] = "/dev/sda";
12233 char lines_0[] = ",10";
12234 char lines_1[] = ",20";
12235 char lines_2[] = ",";
12243 suppress_error = 0;
12244 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12249 char device[] = "/dev/sda1";
12251 suppress_error = 0;
12252 r = guestfs_pvcreate (g, device);
12257 char device[] = "/dev/sda2";
12259 suppress_error = 0;
12260 r = guestfs_pvcreate (g, device);
12265 char device[] = "/dev/sda3";
12267 suppress_error = 0;
12268 r = guestfs_pvcreate (g, device);
12275 suppress_error = 0;
12276 r = guestfs_pvs (g);
12280 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12285 char expected[] = "/dev/sda1";
12287 if (strcmp (r[0], expected) != 0) {
12288 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12293 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12298 char expected[] = "/dev/sda2";
12300 if (strcmp (r[1], expected) != 0) {
12301 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12306 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12311 char expected[] = "/dev/sda3";
12313 if (strcmp (r[2], expected) != 0) {
12314 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12318 if (r[3] != NULL) {
12319 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12323 for (i = 0; r[i] != NULL; ++i)
12330 static int test_is_dir_0_skip (void)
12334 str = getenv ("SKIP_TEST_IS_DIR_0");
12335 if (str && strcmp (str, "1") == 0) return 1;
12336 str = getenv ("SKIP_TEST_IS_DIR");
12337 if (str && strcmp (str, "1") == 0) return 1;
12341 static int test_is_dir_0 (void)
12343 if (test_is_dir_0_skip ()) {
12344 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12348 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12350 char device[] = "/dev/sda";
12352 suppress_error = 0;
12353 r = guestfs_blockdev_setrw (g, device);
12359 suppress_error = 0;
12360 r = guestfs_umount_all (g);
12366 suppress_error = 0;
12367 r = guestfs_lvm_remove_all (g);
12372 char device[] = "/dev/sda";
12373 char lines_0[] = ",";
12379 suppress_error = 0;
12380 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12385 char fstype[] = "ext2";
12386 char device[] = "/dev/sda1";
12388 suppress_error = 0;
12389 r = guestfs_mkfs (g, fstype, device);
12394 char device[] = "/dev/sda1";
12395 char mountpoint[] = "/";
12397 suppress_error = 0;
12398 r = guestfs_mount (g, device, mountpoint);
12402 /* TestOutputFalse for is_dir (0) */
12404 char path[] = "/new";
12406 suppress_error = 0;
12407 r = guestfs_touch (g, path);
12412 char path[] = "/new";
12414 suppress_error = 0;
12415 r = guestfs_is_dir (g, path);
12419 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12426 static int test_is_dir_1_skip (void)
12430 str = getenv ("SKIP_TEST_IS_DIR_1");
12431 if (str && strcmp (str, "1") == 0) return 1;
12432 str = getenv ("SKIP_TEST_IS_DIR");
12433 if (str && strcmp (str, "1") == 0) return 1;
12437 static int test_is_dir_1 (void)
12439 if (test_is_dir_1_skip ()) {
12440 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12444 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12446 char device[] = "/dev/sda";
12448 suppress_error = 0;
12449 r = guestfs_blockdev_setrw (g, device);
12455 suppress_error = 0;
12456 r = guestfs_umount_all (g);
12462 suppress_error = 0;
12463 r = guestfs_lvm_remove_all (g);
12468 char device[] = "/dev/sda";
12469 char lines_0[] = ",";
12475 suppress_error = 0;
12476 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12481 char fstype[] = "ext2";
12482 char device[] = "/dev/sda1";
12484 suppress_error = 0;
12485 r = guestfs_mkfs (g, fstype, device);
12490 char device[] = "/dev/sda1";
12491 char mountpoint[] = "/";
12493 suppress_error = 0;
12494 r = guestfs_mount (g, device, mountpoint);
12498 /* TestOutputTrue for is_dir (1) */
12500 char path[] = "/new";
12502 suppress_error = 0;
12503 r = guestfs_mkdir (g, path);
12508 char path[] = "/new";
12510 suppress_error = 0;
12511 r = guestfs_is_dir (g, path);
12515 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12522 static int test_is_file_0_skip (void)
12526 str = getenv ("SKIP_TEST_IS_FILE_0");
12527 if (str && strcmp (str, "1") == 0) return 1;
12528 str = getenv ("SKIP_TEST_IS_FILE");
12529 if (str && strcmp (str, "1") == 0) return 1;
12533 static int test_is_file_0 (void)
12535 if (test_is_file_0_skip ()) {
12536 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12540 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12542 char device[] = "/dev/sda";
12544 suppress_error = 0;
12545 r = guestfs_blockdev_setrw (g, device);
12551 suppress_error = 0;
12552 r = guestfs_umount_all (g);
12558 suppress_error = 0;
12559 r = guestfs_lvm_remove_all (g);
12564 char device[] = "/dev/sda";
12565 char lines_0[] = ",";
12571 suppress_error = 0;
12572 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12577 char fstype[] = "ext2";
12578 char device[] = "/dev/sda1";
12580 suppress_error = 0;
12581 r = guestfs_mkfs (g, fstype, device);
12586 char device[] = "/dev/sda1";
12587 char mountpoint[] = "/";
12589 suppress_error = 0;
12590 r = guestfs_mount (g, device, mountpoint);
12594 /* TestOutputTrue for is_file (0) */
12596 char path[] = "/new";
12598 suppress_error = 0;
12599 r = guestfs_touch (g, path);
12604 char path[] = "/new";
12606 suppress_error = 0;
12607 r = guestfs_is_file (g, path);
12611 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12618 static int test_is_file_1_skip (void)
12622 str = getenv ("SKIP_TEST_IS_FILE_1");
12623 if (str && strcmp (str, "1") == 0) return 1;
12624 str = getenv ("SKIP_TEST_IS_FILE");
12625 if (str && strcmp (str, "1") == 0) return 1;
12629 static int test_is_file_1 (void)
12631 if (test_is_file_1_skip ()) {
12632 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12636 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12638 char device[] = "/dev/sda";
12640 suppress_error = 0;
12641 r = guestfs_blockdev_setrw (g, device);
12647 suppress_error = 0;
12648 r = guestfs_umount_all (g);
12654 suppress_error = 0;
12655 r = guestfs_lvm_remove_all (g);
12660 char device[] = "/dev/sda";
12661 char lines_0[] = ",";
12667 suppress_error = 0;
12668 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12673 char fstype[] = "ext2";
12674 char device[] = "/dev/sda1";
12676 suppress_error = 0;
12677 r = guestfs_mkfs (g, fstype, device);
12682 char device[] = "/dev/sda1";
12683 char mountpoint[] = "/";
12685 suppress_error = 0;
12686 r = guestfs_mount (g, device, mountpoint);
12690 /* TestOutputFalse for is_file (1) */
12692 char path[] = "/new";
12694 suppress_error = 0;
12695 r = guestfs_mkdir (g, path);
12700 char path[] = "/new";
12702 suppress_error = 0;
12703 r = guestfs_is_file (g, path);
12707 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12714 static int test_exists_0_skip (void)
12718 str = getenv ("SKIP_TEST_EXISTS_0");
12719 if (str && strcmp (str, "1") == 0) return 1;
12720 str = getenv ("SKIP_TEST_EXISTS");
12721 if (str && strcmp (str, "1") == 0) return 1;
12725 static int test_exists_0 (void)
12727 if (test_exists_0_skip ()) {
12728 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12732 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12734 char device[] = "/dev/sda";
12736 suppress_error = 0;
12737 r = guestfs_blockdev_setrw (g, device);
12743 suppress_error = 0;
12744 r = guestfs_umount_all (g);
12750 suppress_error = 0;
12751 r = guestfs_lvm_remove_all (g);
12756 char device[] = "/dev/sda";
12757 char lines_0[] = ",";
12763 suppress_error = 0;
12764 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12769 char fstype[] = "ext2";
12770 char device[] = "/dev/sda1";
12772 suppress_error = 0;
12773 r = guestfs_mkfs (g, fstype, device);
12778 char device[] = "/dev/sda1";
12779 char mountpoint[] = "/";
12781 suppress_error = 0;
12782 r = guestfs_mount (g, device, mountpoint);
12786 /* TestOutputTrue for exists (0) */
12788 char path[] = "/new";
12790 suppress_error = 0;
12791 r = guestfs_touch (g, path);
12796 char path[] = "/new";
12798 suppress_error = 0;
12799 r = guestfs_exists (g, path);
12803 fprintf (stderr, "test_exists_0: expected true, got false\n");
12810 static int test_exists_1_skip (void)
12814 str = getenv ("SKIP_TEST_EXISTS_1");
12815 if (str && strcmp (str, "1") == 0) return 1;
12816 str = getenv ("SKIP_TEST_EXISTS");
12817 if (str && strcmp (str, "1") == 0) return 1;
12821 static int test_exists_1 (void)
12823 if (test_exists_1_skip ()) {
12824 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12828 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12830 char device[] = "/dev/sda";
12832 suppress_error = 0;
12833 r = guestfs_blockdev_setrw (g, device);
12839 suppress_error = 0;
12840 r = guestfs_umount_all (g);
12846 suppress_error = 0;
12847 r = guestfs_lvm_remove_all (g);
12852 char device[] = "/dev/sda";
12853 char lines_0[] = ",";
12859 suppress_error = 0;
12860 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12865 char fstype[] = "ext2";
12866 char device[] = "/dev/sda1";
12868 suppress_error = 0;
12869 r = guestfs_mkfs (g, fstype, device);
12874 char device[] = "/dev/sda1";
12875 char mountpoint[] = "/";
12877 suppress_error = 0;
12878 r = guestfs_mount (g, device, mountpoint);
12882 /* TestOutputTrue for exists (1) */
12884 char path[] = "/new";
12886 suppress_error = 0;
12887 r = guestfs_mkdir (g, path);
12892 char path[] = "/new";
12894 suppress_error = 0;
12895 r = guestfs_exists (g, path);
12899 fprintf (stderr, "test_exists_1: expected true, got false\n");
12906 static int test_mkdir_p_0_skip (void)
12910 str = getenv ("SKIP_TEST_MKDIR_P_0");
12911 if (str && strcmp (str, "1") == 0) return 1;
12912 str = getenv ("SKIP_TEST_MKDIR_P");
12913 if (str && strcmp (str, "1") == 0) return 1;
12917 static int test_mkdir_p_0 (void)
12919 if (test_mkdir_p_0_skip ()) {
12920 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12924 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12926 char device[] = "/dev/sda";
12928 suppress_error = 0;
12929 r = guestfs_blockdev_setrw (g, device);
12935 suppress_error = 0;
12936 r = guestfs_umount_all (g);
12942 suppress_error = 0;
12943 r = guestfs_lvm_remove_all (g);
12948 char device[] = "/dev/sda";
12949 char lines_0[] = ",";
12955 suppress_error = 0;
12956 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12961 char fstype[] = "ext2";
12962 char device[] = "/dev/sda1";
12964 suppress_error = 0;
12965 r = guestfs_mkfs (g, fstype, device);
12970 char device[] = "/dev/sda1";
12971 char mountpoint[] = "/";
12973 suppress_error = 0;
12974 r = guestfs_mount (g, device, mountpoint);
12978 /* TestOutputTrue for mkdir_p (0) */
12980 char path[] = "/new/foo/bar";
12982 suppress_error = 0;
12983 r = guestfs_mkdir_p (g, path);
12988 char path[] = "/new/foo/bar";
12990 suppress_error = 0;
12991 r = guestfs_is_dir (g, path);
12995 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
13002 static int test_mkdir_p_1_skip (void)
13006 str = getenv ("SKIP_TEST_MKDIR_P_1");
13007 if (str && strcmp (str, "1") == 0) return 1;
13008 str = getenv ("SKIP_TEST_MKDIR_P");
13009 if (str && strcmp (str, "1") == 0) return 1;
13013 static int test_mkdir_p_1 (void)
13015 if (test_mkdir_p_1_skip ()) {
13016 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
13020 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
13022 char device[] = "/dev/sda";
13024 suppress_error = 0;
13025 r = guestfs_blockdev_setrw (g, device);
13031 suppress_error = 0;
13032 r = guestfs_umount_all (g);
13038 suppress_error = 0;
13039 r = guestfs_lvm_remove_all (g);
13044 char device[] = "/dev/sda";
13045 char lines_0[] = ",";
13051 suppress_error = 0;
13052 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13057 char fstype[] = "ext2";
13058 char device[] = "/dev/sda1";
13060 suppress_error = 0;
13061 r = guestfs_mkfs (g, fstype, device);
13066 char device[] = "/dev/sda1";
13067 char mountpoint[] = "/";
13069 suppress_error = 0;
13070 r = guestfs_mount (g, device, mountpoint);
13074 /* TestOutputTrue for mkdir_p (1) */
13076 char path[] = "/new/foo/bar";
13078 suppress_error = 0;
13079 r = guestfs_mkdir_p (g, path);
13084 char path[] = "/new/foo";
13086 suppress_error = 0;
13087 r = guestfs_is_dir (g, path);
13091 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13098 static int test_mkdir_p_2_skip (void)
13102 str = getenv ("SKIP_TEST_MKDIR_P_2");
13103 if (str && strcmp (str, "1") == 0) return 1;
13104 str = getenv ("SKIP_TEST_MKDIR_P");
13105 if (str && strcmp (str, "1") == 0) return 1;
13109 static int test_mkdir_p_2 (void)
13111 if (test_mkdir_p_2_skip ()) {
13112 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13116 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13118 char device[] = "/dev/sda";
13120 suppress_error = 0;
13121 r = guestfs_blockdev_setrw (g, device);
13127 suppress_error = 0;
13128 r = guestfs_umount_all (g);
13134 suppress_error = 0;
13135 r = guestfs_lvm_remove_all (g);
13140 char device[] = "/dev/sda";
13141 char lines_0[] = ",";
13147 suppress_error = 0;
13148 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13153 char fstype[] = "ext2";
13154 char device[] = "/dev/sda1";
13156 suppress_error = 0;
13157 r = guestfs_mkfs (g, fstype, device);
13162 char device[] = "/dev/sda1";
13163 char mountpoint[] = "/";
13165 suppress_error = 0;
13166 r = guestfs_mount (g, device, mountpoint);
13170 /* TestOutputTrue for mkdir_p (2) */
13172 char path[] = "/new/foo/bar";
13174 suppress_error = 0;
13175 r = guestfs_mkdir_p (g, path);
13180 char path[] = "/new";
13182 suppress_error = 0;
13183 r = guestfs_is_dir (g, path);
13187 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13194 static int test_mkdir_p_3_skip (void)
13198 str = getenv ("SKIP_TEST_MKDIR_P_3");
13199 if (str && strcmp (str, "1") == 0) return 1;
13200 str = getenv ("SKIP_TEST_MKDIR_P");
13201 if (str && strcmp (str, "1") == 0) return 1;
13205 static int test_mkdir_p_3 (void)
13207 if (test_mkdir_p_3_skip ()) {
13208 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13212 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13214 char device[] = "/dev/sda";
13216 suppress_error = 0;
13217 r = guestfs_blockdev_setrw (g, device);
13223 suppress_error = 0;
13224 r = guestfs_umount_all (g);
13230 suppress_error = 0;
13231 r = guestfs_lvm_remove_all (g);
13236 char device[] = "/dev/sda";
13237 char lines_0[] = ",";
13243 suppress_error = 0;
13244 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13249 char fstype[] = "ext2";
13250 char device[] = "/dev/sda1";
13252 suppress_error = 0;
13253 r = guestfs_mkfs (g, fstype, device);
13258 char device[] = "/dev/sda1";
13259 char mountpoint[] = "/";
13261 suppress_error = 0;
13262 r = guestfs_mount (g, device, mountpoint);
13266 /* TestRun for mkdir_p (3) */
13268 char path[] = "/new";
13270 suppress_error = 0;
13271 r = guestfs_mkdir (g, path);
13276 char path[] = "/new";
13278 suppress_error = 0;
13279 r = guestfs_mkdir_p (g, path);
13286 static int test_mkdir_p_4_skip (void)
13290 str = getenv ("SKIP_TEST_MKDIR_P_4");
13291 if (str && strcmp (str, "1") == 0) return 1;
13292 str = getenv ("SKIP_TEST_MKDIR_P");
13293 if (str && strcmp (str, "1") == 0) return 1;
13297 static int test_mkdir_p_4 (void)
13299 if (test_mkdir_p_4_skip ()) {
13300 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13304 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13306 char device[] = "/dev/sda";
13308 suppress_error = 0;
13309 r = guestfs_blockdev_setrw (g, device);
13315 suppress_error = 0;
13316 r = guestfs_umount_all (g);
13322 suppress_error = 0;
13323 r = guestfs_lvm_remove_all (g);
13328 char device[] = "/dev/sda";
13329 char lines_0[] = ",";
13335 suppress_error = 0;
13336 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13341 char fstype[] = "ext2";
13342 char device[] = "/dev/sda1";
13344 suppress_error = 0;
13345 r = guestfs_mkfs (g, fstype, device);
13350 char device[] = "/dev/sda1";
13351 char mountpoint[] = "/";
13353 suppress_error = 0;
13354 r = guestfs_mount (g, device, mountpoint);
13358 /* TestLastFail for mkdir_p (4) */
13360 char path[] = "/new";
13362 suppress_error = 0;
13363 r = guestfs_touch (g, path);
13368 char path[] = "/new";
13370 suppress_error = 1;
13371 r = guestfs_mkdir_p (g, path);
13378 static int test_mkdir_0_skip (void)
13382 str = getenv ("SKIP_TEST_MKDIR_0");
13383 if (str && strcmp (str, "1") == 0) return 1;
13384 str = getenv ("SKIP_TEST_MKDIR");
13385 if (str && strcmp (str, "1") == 0) return 1;
13389 static int test_mkdir_0 (void)
13391 if (test_mkdir_0_skip ()) {
13392 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13396 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13398 char device[] = "/dev/sda";
13400 suppress_error = 0;
13401 r = guestfs_blockdev_setrw (g, device);
13407 suppress_error = 0;
13408 r = guestfs_umount_all (g);
13414 suppress_error = 0;
13415 r = guestfs_lvm_remove_all (g);
13420 char device[] = "/dev/sda";
13421 char lines_0[] = ",";
13427 suppress_error = 0;
13428 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13433 char fstype[] = "ext2";
13434 char device[] = "/dev/sda1";
13436 suppress_error = 0;
13437 r = guestfs_mkfs (g, fstype, device);
13442 char device[] = "/dev/sda1";
13443 char mountpoint[] = "/";
13445 suppress_error = 0;
13446 r = guestfs_mount (g, device, mountpoint);
13450 /* TestOutputTrue for mkdir (0) */
13452 char path[] = "/new";
13454 suppress_error = 0;
13455 r = guestfs_mkdir (g, path);
13460 char path[] = "/new";
13462 suppress_error = 0;
13463 r = guestfs_is_dir (g, path);
13467 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13474 static int test_mkdir_1_skip (void)
13478 str = getenv ("SKIP_TEST_MKDIR_1");
13479 if (str && strcmp (str, "1") == 0) return 1;
13480 str = getenv ("SKIP_TEST_MKDIR");
13481 if (str && strcmp (str, "1") == 0) return 1;
13485 static int test_mkdir_1 (void)
13487 if (test_mkdir_1_skip ()) {
13488 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13492 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13494 char device[] = "/dev/sda";
13496 suppress_error = 0;
13497 r = guestfs_blockdev_setrw (g, device);
13503 suppress_error = 0;
13504 r = guestfs_umount_all (g);
13510 suppress_error = 0;
13511 r = guestfs_lvm_remove_all (g);
13516 char device[] = "/dev/sda";
13517 char lines_0[] = ",";
13523 suppress_error = 0;
13524 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13529 char fstype[] = "ext2";
13530 char device[] = "/dev/sda1";
13532 suppress_error = 0;
13533 r = guestfs_mkfs (g, fstype, device);
13538 char device[] = "/dev/sda1";
13539 char mountpoint[] = "/";
13541 suppress_error = 0;
13542 r = guestfs_mount (g, device, mountpoint);
13546 /* TestLastFail for mkdir (1) */
13548 char path[] = "/new/foo/bar";
13550 suppress_error = 1;
13551 r = guestfs_mkdir (g, path);
13558 static int test_rm_rf_0_skip (void)
13562 str = getenv ("SKIP_TEST_RM_RF_0");
13563 if (str && strcmp (str, "1") == 0) return 1;
13564 str = getenv ("SKIP_TEST_RM_RF");
13565 if (str && strcmp (str, "1") == 0) return 1;
13569 static int test_rm_rf_0 (void)
13571 if (test_rm_rf_0_skip ()) {
13572 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13576 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13578 char device[] = "/dev/sda";
13580 suppress_error = 0;
13581 r = guestfs_blockdev_setrw (g, device);
13587 suppress_error = 0;
13588 r = guestfs_umount_all (g);
13594 suppress_error = 0;
13595 r = guestfs_lvm_remove_all (g);
13600 char device[] = "/dev/sda";
13601 char lines_0[] = ",";
13607 suppress_error = 0;
13608 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13613 char fstype[] = "ext2";
13614 char device[] = "/dev/sda1";
13616 suppress_error = 0;
13617 r = guestfs_mkfs (g, fstype, device);
13622 char device[] = "/dev/sda1";
13623 char mountpoint[] = "/";
13625 suppress_error = 0;
13626 r = guestfs_mount (g, device, mountpoint);
13630 /* TestOutputFalse for rm_rf (0) */
13632 char path[] = "/new";
13634 suppress_error = 0;
13635 r = guestfs_mkdir (g, path);
13640 char path[] = "/new/foo";
13642 suppress_error = 0;
13643 r = guestfs_mkdir (g, path);
13648 char path[] = "/new/foo/bar";
13650 suppress_error = 0;
13651 r = guestfs_touch (g, path);
13656 char path[] = "/new";
13658 suppress_error = 0;
13659 r = guestfs_rm_rf (g, path);
13664 char path[] = "/new";
13666 suppress_error = 0;
13667 r = guestfs_exists (g, path);
13671 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13678 static int test_rmdir_0_skip (void)
13682 str = getenv ("SKIP_TEST_RMDIR_0");
13683 if (str && strcmp (str, "1") == 0) return 1;
13684 str = getenv ("SKIP_TEST_RMDIR");
13685 if (str && strcmp (str, "1") == 0) return 1;
13689 static int test_rmdir_0 (void)
13691 if (test_rmdir_0_skip ()) {
13692 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13696 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13698 char device[] = "/dev/sda";
13700 suppress_error = 0;
13701 r = guestfs_blockdev_setrw (g, device);
13707 suppress_error = 0;
13708 r = guestfs_umount_all (g);
13714 suppress_error = 0;
13715 r = guestfs_lvm_remove_all (g);
13720 char device[] = "/dev/sda";
13721 char lines_0[] = ",";
13727 suppress_error = 0;
13728 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13733 char fstype[] = "ext2";
13734 char device[] = "/dev/sda1";
13736 suppress_error = 0;
13737 r = guestfs_mkfs (g, fstype, device);
13742 char device[] = "/dev/sda1";
13743 char mountpoint[] = "/";
13745 suppress_error = 0;
13746 r = guestfs_mount (g, device, mountpoint);
13750 /* TestRun for rmdir (0) */
13752 char path[] = "/new";
13754 suppress_error = 0;
13755 r = guestfs_mkdir (g, path);
13760 char path[] = "/new";
13762 suppress_error = 0;
13763 r = guestfs_rmdir (g, path);
13770 static int test_rmdir_1_skip (void)
13774 str = getenv ("SKIP_TEST_RMDIR_1");
13775 if (str && strcmp (str, "1") == 0) return 1;
13776 str = getenv ("SKIP_TEST_RMDIR");
13777 if (str && strcmp (str, "1") == 0) return 1;
13781 static int test_rmdir_1 (void)
13783 if (test_rmdir_1_skip ()) {
13784 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13788 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13790 char device[] = "/dev/sda";
13792 suppress_error = 0;
13793 r = guestfs_blockdev_setrw (g, device);
13799 suppress_error = 0;
13800 r = guestfs_umount_all (g);
13806 suppress_error = 0;
13807 r = guestfs_lvm_remove_all (g);
13812 char device[] = "/dev/sda";
13813 char lines_0[] = ",";
13819 suppress_error = 0;
13820 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13825 char fstype[] = "ext2";
13826 char device[] = "/dev/sda1";
13828 suppress_error = 0;
13829 r = guestfs_mkfs (g, fstype, device);
13834 char device[] = "/dev/sda1";
13835 char mountpoint[] = "/";
13837 suppress_error = 0;
13838 r = guestfs_mount (g, device, mountpoint);
13842 /* TestLastFail for rmdir (1) */
13844 char path[] = "/new";
13846 suppress_error = 1;
13847 r = guestfs_rmdir (g, path);
13854 static int test_rmdir_2_skip (void)
13858 str = getenv ("SKIP_TEST_RMDIR_2");
13859 if (str && strcmp (str, "1") == 0) return 1;
13860 str = getenv ("SKIP_TEST_RMDIR");
13861 if (str && strcmp (str, "1") == 0) return 1;
13865 static int test_rmdir_2 (void)
13867 if (test_rmdir_2_skip ()) {
13868 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13872 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13874 char device[] = "/dev/sda";
13876 suppress_error = 0;
13877 r = guestfs_blockdev_setrw (g, device);
13883 suppress_error = 0;
13884 r = guestfs_umount_all (g);
13890 suppress_error = 0;
13891 r = guestfs_lvm_remove_all (g);
13896 char device[] = "/dev/sda";
13897 char lines_0[] = ",";
13903 suppress_error = 0;
13904 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13909 char fstype[] = "ext2";
13910 char device[] = "/dev/sda1";
13912 suppress_error = 0;
13913 r = guestfs_mkfs (g, fstype, device);
13918 char device[] = "/dev/sda1";
13919 char mountpoint[] = "/";
13921 suppress_error = 0;
13922 r = guestfs_mount (g, device, mountpoint);
13926 /* TestLastFail for rmdir (2) */
13928 char path[] = "/new";
13930 suppress_error = 0;
13931 r = guestfs_touch (g, path);
13936 char path[] = "/new";
13938 suppress_error = 1;
13939 r = guestfs_rmdir (g, path);
13946 static int test_rm_0_skip (void)
13950 str = getenv ("SKIP_TEST_RM_0");
13951 if (str && strcmp (str, "1") == 0) return 1;
13952 str = getenv ("SKIP_TEST_RM");
13953 if (str && strcmp (str, "1") == 0) return 1;
13957 static int test_rm_0 (void)
13959 if (test_rm_0_skip ()) {
13960 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13964 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13966 char device[] = "/dev/sda";
13968 suppress_error = 0;
13969 r = guestfs_blockdev_setrw (g, device);
13975 suppress_error = 0;
13976 r = guestfs_umount_all (g);
13982 suppress_error = 0;
13983 r = guestfs_lvm_remove_all (g);
13988 char device[] = "/dev/sda";
13989 char lines_0[] = ",";
13995 suppress_error = 0;
13996 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14001 char fstype[] = "ext2";
14002 char device[] = "/dev/sda1";
14004 suppress_error = 0;
14005 r = guestfs_mkfs (g, fstype, device);
14010 char device[] = "/dev/sda1";
14011 char mountpoint[] = "/";
14013 suppress_error = 0;
14014 r = guestfs_mount (g, device, mountpoint);
14018 /* TestRun for rm (0) */
14020 char path[] = "/new";
14022 suppress_error = 0;
14023 r = guestfs_touch (g, path);
14028 char path[] = "/new";
14030 suppress_error = 0;
14031 r = guestfs_rm (g, path);
14038 static int test_rm_1_skip (void)
14042 str = getenv ("SKIP_TEST_RM_1");
14043 if (str && strcmp (str, "1") == 0) return 1;
14044 str = getenv ("SKIP_TEST_RM");
14045 if (str && strcmp (str, "1") == 0) return 1;
14049 static int test_rm_1 (void)
14051 if (test_rm_1_skip ()) {
14052 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14056 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14058 char device[] = "/dev/sda";
14060 suppress_error = 0;
14061 r = guestfs_blockdev_setrw (g, device);
14067 suppress_error = 0;
14068 r = guestfs_umount_all (g);
14074 suppress_error = 0;
14075 r = guestfs_lvm_remove_all (g);
14080 char device[] = "/dev/sda";
14081 char lines_0[] = ",";
14087 suppress_error = 0;
14088 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14093 char fstype[] = "ext2";
14094 char device[] = "/dev/sda1";
14096 suppress_error = 0;
14097 r = guestfs_mkfs (g, fstype, device);
14102 char device[] = "/dev/sda1";
14103 char mountpoint[] = "/";
14105 suppress_error = 0;
14106 r = guestfs_mount (g, device, mountpoint);
14110 /* TestLastFail for rm (1) */
14112 char path[] = "/new";
14114 suppress_error = 1;
14115 r = guestfs_rm (g, path);
14122 static int test_rm_2_skip (void)
14126 str = getenv ("SKIP_TEST_RM_2");
14127 if (str && strcmp (str, "1") == 0) return 1;
14128 str = getenv ("SKIP_TEST_RM");
14129 if (str && strcmp (str, "1") == 0) return 1;
14133 static int test_rm_2 (void)
14135 if (test_rm_2_skip ()) {
14136 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14140 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14142 char device[] = "/dev/sda";
14144 suppress_error = 0;
14145 r = guestfs_blockdev_setrw (g, device);
14151 suppress_error = 0;
14152 r = guestfs_umount_all (g);
14158 suppress_error = 0;
14159 r = guestfs_lvm_remove_all (g);
14164 char device[] = "/dev/sda";
14165 char lines_0[] = ",";
14171 suppress_error = 0;
14172 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14177 char fstype[] = "ext2";
14178 char device[] = "/dev/sda1";
14180 suppress_error = 0;
14181 r = guestfs_mkfs (g, fstype, device);
14186 char device[] = "/dev/sda1";
14187 char mountpoint[] = "/";
14189 suppress_error = 0;
14190 r = guestfs_mount (g, device, mountpoint);
14194 /* TestLastFail for rm (2) */
14196 char path[] = "/new";
14198 suppress_error = 0;
14199 r = guestfs_mkdir (g, path);
14204 char path[] = "/new";
14206 suppress_error = 1;
14207 r = guestfs_rm (g, path);
14214 static int test_read_lines_0_skip (void)
14218 str = getenv ("SKIP_TEST_READ_LINES_0");
14219 if (str && strcmp (str, "1") == 0) return 1;
14220 str = getenv ("SKIP_TEST_READ_LINES");
14221 if (str && strcmp (str, "1") == 0) return 1;
14225 static int test_read_lines_0 (void)
14227 if (test_read_lines_0_skip ()) {
14228 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14232 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14234 char device[] = "/dev/sda";
14236 suppress_error = 0;
14237 r = guestfs_blockdev_setrw (g, device);
14243 suppress_error = 0;
14244 r = guestfs_umount_all (g);
14250 suppress_error = 0;
14251 r = guestfs_lvm_remove_all (g);
14256 char device[] = "/dev/sda";
14257 char lines_0[] = ",";
14263 suppress_error = 0;
14264 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14269 char fstype[] = "ext2";
14270 char device[] = "/dev/sda1";
14272 suppress_error = 0;
14273 r = guestfs_mkfs (g, fstype, device);
14278 char device[] = "/dev/sda1";
14279 char mountpoint[] = "/";
14281 suppress_error = 0;
14282 r = guestfs_mount (g, device, mountpoint);
14286 /* TestOutputList for read_lines (0) */
14288 char path[] = "/new";
14289 char content[] = "line1\r\nline2\nline3";
14291 suppress_error = 0;
14292 r = guestfs_write_file (g, path, content, 0);
14297 char path[] = "/new";
14300 suppress_error = 0;
14301 r = guestfs_read_lines (g, path);
14305 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14310 char expected[] = "line1";
14311 if (strcmp (r[0], expected) != 0) {
14312 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14317 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14322 char expected[] = "line2";
14323 if (strcmp (r[1], expected) != 0) {
14324 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14329 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14334 char expected[] = "line3";
14335 if (strcmp (r[2], expected) != 0) {
14336 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14340 if (r[3] != NULL) {
14341 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14345 for (i = 0; r[i] != NULL; ++i)
14352 static int test_read_lines_1_skip (void)
14356 str = getenv ("SKIP_TEST_READ_LINES_1");
14357 if (str && strcmp (str, "1") == 0) return 1;
14358 str = getenv ("SKIP_TEST_READ_LINES");
14359 if (str && strcmp (str, "1") == 0) return 1;
14363 static int test_read_lines_1 (void)
14365 if (test_read_lines_1_skip ()) {
14366 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14370 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14372 char device[] = "/dev/sda";
14374 suppress_error = 0;
14375 r = guestfs_blockdev_setrw (g, device);
14381 suppress_error = 0;
14382 r = guestfs_umount_all (g);
14388 suppress_error = 0;
14389 r = guestfs_lvm_remove_all (g);
14394 char device[] = "/dev/sda";
14395 char lines_0[] = ",";
14401 suppress_error = 0;
14402 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14407 char fstype[] = "ext2";
14408 char device[] = "/dev/sda1";
14410 suppress_error = 0;
14411 r = guestfs_mkfs (g, fstype, device);
14416 char device[] = "/dev/sda1";
14417 char mountpoint[] = "/";
14419 suppress_error = 0;
14420 r = guestfs_mount (g, device, mountpoint);
14424 /* TestOutputList for read_lines (1) */
14426 char path[] = "/new";
14427 char content[] = "";
14429 suppress_error = 0;
14430 r = guestfs_write_file (g, path, content, 0);
14435 char path[] = "/new";
14438 suppress_error = 0;
14439 r = guestfs_read_lines (g, path);
14442 if (r[0] != NULL) {
14443 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14447 for (i = 0; r[i] != NULL; ++i)
14454 static int test_lvs_0_skip (void)
14458 str = getenv ("SKIP_TEST_LVS_0");
14459 if (str && strcmp (str, "1") == 0) return 1;
14460 str = getenv ("SKIP_TEST_LVS");
14461 if (str && strcmp (str, "1") == 0) return 1;
14465 static int test_lvs_0 (void)
14467 if (test_lvs_0_skip ()) {
14468 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14472 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14474 char device[] = "/dev/sda";
14476 suppress_error = 0;
14477 r = guestfs_blockdev_setrw (g, device);
14483 suppress_error = 0;
14484 r = guestfs_umount_all (g);
14490 suppress_error = 0;
14491 r = guestfs_lvm_remove_all (g);
14496 char device[] = "/dev/sda";
14497 char lines_0[] = ",";
14503 suppress_error = 0;
14504 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14509 char device[] = "/dev/sda1";
14511 suppress_error = 0;
14512 r = guestfs_pvcreate (g, device);
14517 char volgroup[] = "VG";
14518 char physvols_0[] = "/dev/sda1";
14519 char *physvols[] = {
14524 suppress_error = 0;
14525 r = guestfs_vgcreate (g, volgroup, physvols);
14530 char logvol[] = "LV";
14531 char volgroup[] = "VG";
14533 suppress_error = 0;
14534 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14539 char fstype[] = "ext2";
14540 char device[] = "/dev/VG/LV";
14542 suppress_error = 0;
14543 r = guestfs_mkfs (g, fstype, device);
14548 char device[] = "/dev/VG/LV";
14549 char mountpoint[] = "/";
14551 suppress_error = 0;
14552 r = guestfs_mount (g, device, mountpoint);
14556 /* TestOutputList for lvs (0) */
14560 suppress_error = 0;
14561 r = guestfs_lvs (g);
14565 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14570 char expected[] = "/dev/VG/LV";
14571 if (strcmp (r[0], expected) != 0) {
14572 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14576 if (r[1] != NULL) {
14577 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14581 for (i = 0; r[i] != NULL; ++i)
14588 static int test_lvs_1_skip (void)
14592 str = getenv ("SKIP_TEST_LVS_1");
14593 if (str && strcmp (str, "1") == 0) return 1;
14594 str = getenv ("SKIP_TEST_LVS");
14595 if (str && strcmp (str, "1") == 0) return 1;
14599 static int test_lvs_1 (void)
14601 if (test_lvs_1_skip ()) {
14602 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14606 /* InitNone|InitEmpty for test_lvs_1 */
14608 char device[] = "/dev/sda";
14610 suppress_error = 0;
14611 r = guestfs_blockdev_setrw (g, device);
14617 suppress_error = 0;
14618 r = guestfs_umount_all (g);
14624 suppress_error = 0;
14625 r = guestfs_lvm_remove_all (g);
14629 /* TestOutputList for lvs (1) */
14631 char device[] = "/dev/sda";
14632 char lines_0[] = ",10";
14633 char lines_1[] = ",20";
14634 char lines_2[] = ",";
14642 suppress_error = 0;
14643 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14648 char device[] = "/dev/sda1";
14650 suppress_error = 0;
14651 r = guestfs_pvcreate (g, device);
14656 char device[] = "/dev/sda2";
14658 suppress_error = 0;
14659 r = guestfs_pvcreate (g, device);
14664 char device[] = "/dev/sda3";
14666 suppress_error = 0;
14667 r = guestfs_pvcreate (g, device);
14672 char volgroup[] = "VG1";
14673 char physvols_0[] = "/dev/sda1";
14674 char physvols_1[] = "/dev/sda2";
14675 char *physvols[] = {
14681 suppress_error = 0;
14682 r = guestfs_vgcreate (g, volgroup, physvols);
14687 char volgroup[] = "VG2";
14688 char physvols_0[] = "/dev/sda3";
14689 char *physvols[] = {
14694 suppress_error = 0;
14695 r = guestfs_vgcreate (g, volgroup, physvols);
14700 char logvol[] = "LV1";
14701 char volgroup[] = "VG1";
14703 suppress_error = 0;
14704 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14709 char logvol[] = "LV2";
14710 char volgroup[] = "VG1";
14712 suppress_error = 0;
14713 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14718 char logvol[] = "LV3";
14719 char volgroup[] = "VG2";
14721 suppress_error = 0;
14722 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14729 suppress_error = 0;
14730 r = guestfs_lvs (g);
14734 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14739 char expected[] = "/dev/VG1/LV1";
14740 if (strcmp (r[0], expected) != 0) {
14741 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14746 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14751 char expected[] = "/dev/VG1/LV2";
14752 if (strcmp (r[1], expected) != 0) {
14753 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14758 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14763 char expected[] = "/dev/VG2/LV3";
14764 if (strcmp (r[2], expected) != 0) {
14765 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14769 if (r[3] != NULL) {
14770 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14774 for (i = 0; r[i] != NULL; ++i)
14781 static int test_vgs_0_skip (void)
14785 str = getenv ("SKIP_TEST_VGS_0");
14786 if (str && strcmp (str, "1") == 0) return 1;
14787 str = getenv ("SKIP_TEST_VGS");
14788 if (str && strcmp (str, "1") == 0) return 1;
14792 static int test_vgs_0 (void)
14794 if (test_vgs_0_skip ()) {
14795 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14799 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14801 char device[] = "/dev/sda";
14803 suppress_error = 0;
14804 r = guestfs_blockdev_setrw (g, device);
14810 suppress_error = 0;
14811 r = guestfs_umount_all (g);
14817 suppress_error = 0;
14818 r = guestfs_lvm_remove_all (g);
14823 char device[] = "/dev/sda";
14824 char lines_0[] = ",";
14830 suppress_error = 0;
14831 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14836 char device[] = "/dev/sda1";
14838 suppress_error = 0;
14839 r = guestfs_pvcreate (g, device);
14844 char volgroup[] = "VG";
14845 char physvols_0[] = "/dev/sda1";
14846 char *physvols[] = {
14851 suppress_error = 0;
14852 r = guestfs_vgcreate (g, volgroup, physvols);
14857 char logvol[] = "LV";
14858 char volgroup[] = "VG";
14860 suppress_error = 0;
14861 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14866 char fstype[] = "ext2";
14867 char device[] = "/dev/VG/LV";
14869 suppress_error = 0;
14870 r = guestfs_mkfs (g, fstype, device);
14875 char device[] = "/dev/VG/LV";
14876 char mountpoint[] = "/";
14878 suppress_error = 0;
14879 r = guestfs_mount (g, device, mountpoint);
14883 /* TestOutputList for vgs (0) */
14887 suppress_error = 0;
14888 r = guestfs_vgs (g);
14892 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14897 char expected[] = "VG";
14898 if (strcmp (r[0], expected) != 0) {
14899 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14903 if (r[1] != NULL) {
14904 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14908 for (i = 0; r[i] != NULL; ++i)
14915 static int test_vgs_1_skip (void)
14919 str = getenv ("SKIP_TEST_VGS_1");
14920 if (str && strcmp (str, "1") == 0) return 1;
14921 str = getenv ("SKIP_TEST_VGS");
14922 if (str && strcmp (str, "1") == 0) return 1;
14926 static int test_vgs_1 (void)
14928 if (test_vgs_1_skip ()) {
14929 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14933 /* InitNone|InitEmpty for test_vgs_1 */
14935 char device[] = "/dev/sda";
14937 suppress_error = 0;
14938 r = guestfs_blockdev_setrw (g, device);
14944 suppress_error = 0;
14945 r = guestfs_umount_all (g);
14951 suppress_error = 0;
14952 r = guestfs_lvm_remove_all (g);
14956 /* TestOutputList for vgs (1) */
14958 char device[] = "/dev/sda";
14959 char lines_0[] = ",10";
14960 char lines_1[] = ",20";
14961 char lines_2[] = ",";
14969 suppress_error = 0;
14970 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14975 char device[] = "/dev/sda1";
14977 suppress_error = 0;
14978 r = guestfs_pvcreate (g, device);
14983 char device[] = "/dev/sda2";
14985 suppress_error = 0;
14986 r = guestfs_pvcreate (g, device);
14991 char device[] = "/dev/sda3";
14993 suppress_error = 0;
14994 r = guestfs_pvcreate (g, device);
14999 char volgroup[] = "VG1";
15000 char physvols_0[] = "/dev/sda1";
15001 char physvols_1[] = "/dev/sda2";
15002 char *physvols[] = {
15008 suppress_error = 0;
15009 r = guestfs_vgcreate (g, volgroup, physvols);
15014 char volgroup[] = "VG2";
15015 char physvols_0[] = "/dev/sda3";
15016 char *physvols[] = {
15021 suppress_error = 0;
15022 r = guestfs_vgcreate (g, volgroup, physvols);
15029 suppress_error = 0;
15030 r = guestfs_vgs (g);
15034 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15039 char expected[] = "VG1";
15040 if (strcmp (r[0], expected) != 0) {
15041 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15046 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15051 char expected[] = "VG2";
15052 if (strcmp (r[1], expected) != 0) {
15053 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15057 if (r[2] != NULL) {
15058 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15062 for (i = 0; r[i] != NULL; ++i)
15069 static int test_pvs_0_skip (void)
15073 str = getenv ("SKIP_TEST_PVS_0");
15074 if (str && strcmp (str, "1") == 0) return 1;
15075 str = getenv ("SKIP_TEST_PVS");
15076 if (str && strcmp (str, "1") == 0) return 1;
15080 static int test_pvs_0 (void)
15082 if (test_pvs_0_skip ()) {
15083 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15087 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15089 char device[] = "/dev/sda";
15091 suppress_error = 0;
15092 r = guestfs_blockdev_setrw (g, device);
15098 suppress_error = 0;
15099 r = guestfs_umount_all (g);
15105 suppress_error = 0;
15106 r = guestfs_lvm_remove_all (g);
15111 char device[] = "/dev/sda";
15112 char lines_0[] = ",";
15118 suppress_error = 0;
15119 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15124 char device[] = "/dev/sda1";
15126 suppress_error = 0;
15127 r = guestfs_pvcreate (g, device);
15132 char volgroup[] = "VG";
15133 char physvols_0[] = "/dev/sda1";
15134 char *physvols[] = {
15139 suppress_error = 0;
15140 r = guestfs_vgcreate (g, volgroup, physvols);
15145 char logvol[] = "LV";
15146 char volgroup[] = "VG";
15148 suppress_error = 0;
15149 r = guestfs_lvcreate (g, logvol, volgroup, 8);
15154 char fstype[] = "ext2";
15155 char device[] = "/dev/VG/LV";
15157 suppress_error = 0;
15158 r = guestfs_mkfs (g, fstype, device);
15163 char device[] = "/dev/VG/LV";
15164 char mountpoint[] = "/";
15166 suppress_error = 0;
15167 r = guestfs_mount (g, device, mountpoint);
15171 /* TestOutputListOfDevices for pvs (0) */
15175 suppress_error = 0;
15176 r = guestfs_pvs (g);
15180 fprintf (stderr, "test_pvs_0: short list returned from command\n");
15185 char expected[] = "/dev/sda1";
15187 if (strcmp (r[0], expected) != 0) {
15188 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15192 if (r[1] != NULL) {
15193 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15197 for (i = 0; r[i] != NULL; ++i)
15204 static int test_pvs_1_skip (void)
15208 str = getenv ("SKIP_TEST_PVS_1");
15209 if (str && strcmp (str, "1") == 0) return 1;
15210 str = getenv ("SKIP_TEST_PVS");
15211 if (str && strcmp (str, "1") == 0) return 1;
15215 static int test_pvs_1 (void)
15217 if (test_pvs_1_skip ()) {
15218 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15222 /* InitNone|InitEmpty for test_pvs_1 */
15224 char device[] = "/dev/sda";
15226 suppress_error = 0;
15227 r = guestfs_blockdev_setrw (g, device);
15233 suppress_error = 0;
15234 r = guestfs_umount_all (g);
15240 suppress_error = 0;
15241 r = guestfs_lvm_remove_all (g);
15245 /* TestOutputListOfDevices for pvs (1) */
15247 char device[] = "/dev/sda";
15248 char lines_0[] = ",10";
15249 char lines_1[] = ",20";
15250 char lines_2[] = ",";
15258 suppress_error = 0;
15259 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15264 char device[] = "/dev/sda1";
15266 suppress_error = 0;
15267 r = guestfs_pvcreate (g, device);
15272 char device[] = "/dev/sda2";
15274 suppress_error = 0;
15275 r = guestfs_pvcreate (g, device);
15280 char device[] = "/dev/sda3";
15282 suppress_error = 0;
15283 r = guestfs_pvcreate (g, device);
15290 suppress_error = 0;
15291 r = guestfs_pvs (g);
15295 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15300 char expected[] = "/dev/sda1";
15302 if (strcmp (r[0], expected) != 0) {
15303 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15308 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15313 char expected[] = "/dev/sda2";
15315 if (strcmp (r[1], expected) != 0) {
15316 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15321 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15326 char expected[] = "/dev/sda3";
15328 if (strcmp (r[2], expected) != 0) {
15329 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15333 if (r[3] != NULL) {
15334 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15338 for (i = 0; r[i] != NULL; ++i)
15345 static int test_list_partitions_0_skip (void)
15349 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15350 if (str && strcmp (str, "1") == 0) return 1;
15351 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15352 if (str && strcmp (str, "1") == 0) return 1;
15356 static int test_list_partitions_0 (void)
15358 if (test_list_partitions_0_skip ()) {
15359 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15363 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15365 char device[] = "/dev/sda";
15367 suppress_error = 0;
15368 r = guestfs_blockdev_setrw (g, device);
15374 suppress_error = 0;
15375 r = guestfs_umount_all (g);
15381 suppress_error = 0;
15382 r = guestfs_lvm_remove_all (g);
15387 char device[] = "/dev/sda";
15388 char lines_0[] = ",";
15394 suppress_error = 0;
15395 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15400 char fstype[] = "ext2";
15401 char device[] = "/dev/sda1";
15403 suppress_error = 0;
15404 r = guestfs_mkfs (g, fstype, device);
15409 char device[] = "/dev/sda1";
15410 char mountpoint[] = "/";
15412 suppress_error = 0;
15413 r = guestfs_mount (g, device, mountpoint);
15417 /* TestOutputListOfDevices for list_partitions (0) */
15421 suppress_error = 0;
15422 r = guestfs_list_partitions (g);
15426 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15431 char expected[] = "/dev/sda1";
15433 if (strcmp (r[0], expected) != 0) {
15434 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15438 if (r[1] != NULL) {
15439 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15443 for (i = 0; r[i] != NULL; ++i)
15450 static int test_list_partitions_1_skip (void)
15454 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15455 if (str && strcmp (str, "1") == 0) return 1;
15456 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15457 if (str && strcmp (str, "1") == 0) return 1;
15461 static int test_list_partitions_1 (void)
15463 if (test_list_partitions_1_skip ()) {
15464 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15468 /* InitNone|InitEmpty for test_list_partitions_1 */
15470 char device[] = "/dev/sda";
15472 suppress_error = 0;
15473 r = guestfs_blockdev_setrw (g, device);
15479 suppress_error = 0;
15480 r = guestfs_umount_all (g);
15486 suppress_error = 0;
15487 r = guestfs_lvm_remove_all (g);
15491 /* TestOutputListOfDevices for list_partitions (1) */
15493 char device[] = "/dev/sda";
15494 char lines_0[] = ",10";
15495 char lines_1[] = ",20";
15496 char lines_2[] = ",";
15504 suppress_error = 0;
15505 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15512 suppress_error = 0;
15513 r = guestfs_list_partitions (g);
15517 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15522 char expected[] = "/dev/sda1";
15524 if (strcmp (r[0], expected) != 0) {
15525 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15530 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15535 char expected[] = "/dev/sda2";
15537 if (strcmp (r[1], expected) != 0) {
15538 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15543 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15548 char expected[] = "/dev/sda3";
15550 if (strcmp (r[2], expected) != 0) {
15551 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15555 if (r[3] != NULL) {
15556 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15560 for (i = 0; r[i] != NULL; ++i)
15567 static int test_list_devices_0_skip (void)
15571 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15572 if (str && strcmp (str, "1") == 0) return 1;
15573 str = getenv ("SKIP_TEST_LIST_DEVICES");
15574 if (str && strcmp (str, "1") == 0) return 1;
15578 static int test_list_devices_0 (void)
15580 if (test_list_devices_0_skip ()) {
15581 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15585 /* InitNone|InitEmpty for test_list_devices_0 */
15587 char device[] = "/dev/sda";
15589 suppress_error = 0;
15590 r = guestfs_blockdev_setrw (g, device);
15596 suppress_error = 0;
15597 r = guestfs_umount_all (g);
15603 suppress_error = 0;
15604 r = guestfs_lvm_remove_all (g);
15608 /* TestOutputListOfDevices for list_devices (0) */
15612 suppress_error = 0;
15613 r = guestfs_list_devices (g);
15617 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15622 char expected[] = "/dev/sda";
15624 if (strcmp (r[0], expected) != 0) {
15625 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15630 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15635 char expected[] = "/dev/sdb";
15637 if (strcmp (r[1], expected) != 0) {
15638 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15643 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15648 char expected[] = "/dev/sdc";
15650 if (strcmp (r[2], expected) != 0) {
15651 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15656 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15661 char expected[] = "/dev/sdd";
15663 if (strcmp (r[3], expected) != 0) {
15664 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15668 if (r[4] != NULL) {
15669 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15673 for (i = 0; r[i] != NULL; ++i)
15680 static int test_ls_0_skip (void)
15684 str = getenv ("SKIP_TEST_LS_0");
15685 if (str && strcmp (str, "1") == 0) return 1;
15686 str = getenv ("SKIP_TEST_LS");
15687 if (str && strcmp (str, "1") == 0) return 1;
15691 static int test_ls_0 (void)
15693 if (test_ls_0_skip ()) {
15694 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15698 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15700 char device[] = "/dev/sda";
15702 suppress_error = 0;
15703 r = guestfs_blockdev_setrw (g, device);
15709 suppress_error = 0;
15710 r = guestfs_umount_all (g);
15716 suppress_error = 0;
15717 r = guestfs_lvm_remove_all (g);
15722 char device[] = "/dev/sda";
15723 char lines_0[] = ",";
15729 suppress_error = 0;
15730 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15735 char fstype[] = "ext2";
15736 char device[] = "/dev/sda1";
15738 suppress_error = 0;
15739 r = guestfs_mkfs (g, fstype, device);
15744 char device[] = "/dev/sda1";
15745 char mountpoint[] = "/";
15747 suppress_error = 0;
15748 r = guestfs_mount (g, device, mountpoint);
15752 /* TestOutputList for ls (0) */
15754 char path[] = "/new";
15756 suppress_error = 0;
15757 r = guestfs_touch (g, path);
15762 char path[] = "/newer";
15764 suppress_error = 0;
15765 r = guestfs_touch (g, path);
15770 char path[] = "/newest";
15772 suppress_error = 0;
15773 r = guestfs_touch (g, path);
15778 char directory[] = "/";
15781 suppress_error = 0;
15782 r = guestfs_ls (g, directory);
15786 fprintf (stderr, "test_ls_0: short list returned from command\n");
15791 char expected[] = "lost+found";
15792 if (strcmp (r[0], expected) != 0) {
15793 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15798 fprintf (stderr, "test_ls_0: short list returned from command\n");
15803 char expected[] = "new";
15804 if (strcmp (r[1], expected) != 0) {
15805 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15810 fprintf (stderr, "test_ls_0: short list returned from command\n");
15815 char expected[] = "newer";
15816 if (strcmp (r[2], expected) != 0) {
15817 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15822 fprintf (stderr, "test_ls_0: short list returned from command\n");
15827 char expected[] = "newest";
15828 if (strcmp (r[3], expected) != 0) {
15829 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15833 if (r[4] != NULL) {
15834 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15838 for (i = 0; r[i] != NULL; ++i)
15845 static int test_cat_0_skip (void)
15849 str = getenv ("SKIP_TEST_CAT_0");
15850 if (str && strcmp (str, "1") == 0) return 1;
15851 str = getenv ("SKIP_TEST_CAT");
15852 if (str && strcmp (str, "1") == 0) return 1;
15856 static int test_cat_0 (void)
15858 if (test_cat_0_skip ()) {
15859 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15863 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15865 char device[] = "/dev/sda";
15867 suppress_error = 0;
15868 r = guestfs_blockdev_setrw (g, device);
15874 suppress_error = 0;
15875 r = guestfs_umount_all (g);
15881 suppress_error = 0;
15882 r = guestfs_lvm_remove_all (g);
15887 char device[] = "/dev/sda";
15888 char lines_0[] = ",";
15894 suppress_error = 0;
15895 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15900 char fstype[] = "ext2";
15901 char device[] = "/dev/sda1";
15903 suppress_error = 0;
15904 r = guestfs_mkfs (g, fstype, device);
15909 char device[] = "/dev/sda1";
15910 char mountpoint[] = "/";
15912 suppress_error = 0;
15913 r = guestfs_mount (g, device, mountpoint);
15917 /* TestOutput for cat (0) */
15918 char expected[] = "new file contents";
15920 char path[] = "/new";
15921 char content[] = "new file contents";
15923 suppress_error = 0;
15924 r = guestfs_write_file (g, path, content, 0);
15929 char path[] = "/new";
15931 suppress_error = 0;
15932 r = guestfs_cat (g, path);
15935 if (strcmp (r, expected) != 0) {
15936 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15944 static int test_touch_0_skip (void)
15948 str = getenv ("SKIP_TEST_TOUCH_0");
15949 if (str && strcmp (str, "1") == 0) return 1;
15950 str = getenv ("SKIP_TEST_TOUCH");
15951 if (str && strcmp (str, "1") == 0) return 1;
15955 static int test_touch_0 (void)
15957 if (test_touch_0_skip ()) {
15958 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15962 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15964 char device[] = "/dev/sda";
15966 suppress_error = 0;
15967 r = guestfs_blockdev_setrw (g, device);
15973 suppress_error = 0;
15974 r = guestfs_umount_all (g);
15980 suppress_error = 0;
15981 r = guestfs_lvm_remove_all (g);
15986 char device[] = "/dev/sda";
15987 char lines_0[] = ",";
15993 suppress_error = 0;
15994 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15999 char fstype[] = "ext2";
16000 char device[] = "/dev/sda1";
16002 suppress_error = 0;
16003 r = guestfs_mkfs (g, fstype, device);
16008 char device[] = "/dev/sda1";
16009 char mountpoint[] = "/";
16011 suppress_error = 0;
16012 r = guestfs_mount (g, device, mountpoint);
16016 /* TestOutputTrue for touch (0) */
16018 char path[] = "/new";
16020 suppress_error = 0;
16021 r = guestfs_touch (g, path);
16026 char path[] = "/new";
16028 suppress_error = 0;
16029 r = guestfs_exists (g, path);
16033 fprintf (stderr, "test_touch_0: expected true, got false\n");
16040 static int test_sync_0_skip (void)
16044 str = getenv ("SKIP_TEST_SYNC_0");
16045 if (str && strcmp (str, "1") == 0) return 1;
16046 str = getenv ("SKIP_TEST_SYNC");
16047 if (str && strcmp (str, "1") == 0) return 1;
16051 static int test_sync_0 (void)
16053 if (test_sync_0_skip ()) {
16054 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16058 /* InitNone|InitEmpty for test_sync_0 */
16060 char device[] = "/dev/sda";
16062 suppress_error = 0;
16063 r = guestfs_blockdev_setrw (g, device);
16069 suppress_error = 0;
16070 r = guestfs_umount_all (g);
16076 suppress_error = 0;
16077 r = guestfs_lvm_remove_all (g);
16081 /* TestRun for sync (0) */
16084 suppress_error = 0;
16085 r = guestfs_sync (g);
16092 static int test_mount_0_skip (void)
16096 str = getenv ("SKIP_TEST_MOUNT_0");
16097 if (str && strcmp (str, "1") == 0) return 1;
16098 str = getenv ("SKIP_TEST_MOUNT");
16099 if (str && strcmp (str, "1") == 0) return 1;
16103 static int test_mount_0 (void)
16105 if (test_mount_0_skip ()) {
16106 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16110 /* InitNone|InitEmpty for test_mount_0 */
16112 char device[] = "/dev/sda";
16114 suppress_error = 0;
16115 r = guestfs_blockdev_setrw (g, device);
16121 suppress_error = 0;
16122 r = guestfs_umount_all (g);
16128 suppress_error = 0;
16129 r = guestfs_lvm_remove_all (g);
16133 /* TestOutput for mount (0) */
16134 char expected[] = "new file contents";
16136 char device[] = "/dev/sda";
16137 char lines_0[] = ",";
16143 suppress_error = 0;
16144 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16149 char fstype[] = "ext2";
16150 char device[] = "/dev/sda1";
16152 suppress_error = 0;
16153 r = guestfs_mkfs (g, fstype, device);
16158 char device[] = "/dev/sda1";
16159 char mountpoint[] = "/";
16161 suppress_error = 0;
16162 r = guestfs_mount (g, device, mountpoint);
16167 char path[] = "/new";
16168 char content[] = "new file contents";
16170 suppress_error = 0;
16171 r = guestfs_write_file (g, path, content, 0);
16176 char path[] = "/new";
16178 suppress_error = 0;
16179 r = guestfs_cat (g, path);
16182 if (strcmp (r, expected) != 0) {
16183 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16191 int main (int argc, char *argv[])
16195 const char *filename;
16197 int nr_tests, test_num = 0;
16199 no_test_warnings ();
16201 g = guestfs_create ();
16203 printf ("guestfs_create FAILED\n");
16207 guestfs_set_error_handler (g, print_error, NULL);
16209 guestfs_set_path (g, "../appliance");
16211 filename = "test1.img";
16212 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16217 if (lseek (fd, 524288000, SEEK_SET) == -1) {
16223 if (write (fd, &c, 1) == -1) {
16229 if (close (fd) == -1) {
16234 if (guestfs_add_drive (g, filename) == -1) {
16235 printf ("guestfs_add_drive %s FAILED\n", filename);
16239 filename = "test2.img";
16240 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16245 if (lseek (fd, 52428800, SEEK_SET) == -1) {
16251 if (write (fd, &c, 1) == -1) {
16257 if (close (fd) == -1) {
16262 if (guestfs_add_drive (g, filename) == -1) {
16263 printf ("guestfs_add_drive %s FAILED\n", filename);
16267 filename = "test3.img";
16268 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16273 if (lseek (fd, 10485760, SEEK_SET) == -1) {
16279 if (write (fd, &c, 1) == -1) {
16285 if (close (fd) == -1) {
16290 if (guestfs_add_drive (g, filename) == -1) {
16291 printf ("guestfs_add_drive %s FAILED\n", filename);
16295 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16296 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16300 if (guestfs_launch (g) == -1) {
16301 printf ("guestfs_launch FAILED\n");
16305 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16308 if (guestfs_wait_ready (g) == -1) {
16309 printf ("guestfs_wait_ready FAILED\n");
16313 /* Cancel previous alarm. */
16319 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
16320 if (test_scrub_file_0 () == -1) {
16321 printf ("test_scrub_file_0 FAILED\n");
16325 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
16326 if (test_scrub_device_0 () == -1) {
16327 printf ("test_scrub_device_0 FAILED\n");
16331 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16332 if (test_glob_expand_0 () == -1) {
16333 printf ("test_glob_expand_0 FAILED\n");
16337 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16338 if (test_glob_expand_1 () == -1) {
16339 printf ("test_glob_expand_1 FAILED\n");
16343 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16344 if (test_glob_expand_2 () == -1) {
16345 printf ("test_glob_expand_2 FAILED\n");
16349 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16350 if (test_ntfs_3g_probe_0 () == -1) {
16351 printf ("test_ntfs_3g_probe_0 FAILED\n");
16355 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16356 if (test_ntfs_3g_probe_1 () == -1) {
16357 printf ("test_ntfs_3g_probe_1 FAILED\n");
16361 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16362 if (test_sleep_0 () == -1) {
16363 printf ("test_sleep_0 FAILED\n");
16367 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16368 if (test_find_0 () == -1) {
16369 printf ("test_find_0 FAILED\n");
16373 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16374 if (test_find_1 () == -1) {
16375 printf ("test_find_1 FAILED\n");
16379 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16380 if (test_find_2 () == -1) {
16381 printf ("test_find_2 FAILED\n");
16385 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16386 if (test_lvresize_0 () == -1) {
16387 printf ("test_lvresize_0 FAILED\n");
16391 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16392 if (test_zerofree_0 () == -1) {
16393 printf ("test_zerofree_0 FAILED\n");
16397 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16398 if (test_hexdump_0 () == -1) {
16399 printf ("test_hexdump_0 FAILED\n");
16403 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16404 if (test_strings_e_0 () == -1) {
16405 printf ("test_strings_e_0 FAILED\n");
16409 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16410 if (test_strings_e_1 () == -1) {
16411 printf ("test_strings_e_1 FAILED\n");
16415 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16416 if (test_strings_0 () == -1) {
16417 printf ("test_strings_0 FAILED\n");
16421 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16422 if (test_strings_1 () == -1) {
16423 printf ("test_strings_1 FAILED\n");
16427 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16428 if (test_equal_0 () == -1) {
16429 printf ("test_equal_0 FAILED\n");
16433 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16434 if (test_equal_1 () == -1) {
16435 printf ("test_equal_1 FAILED\n");
16439 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16440 if (test_equal_2 () == -1) {
16441 printf ("test_equal_2 FAILED\n");
16445 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16446 if (test_ping_daemon_0 () == -1) {
16447 printf ("test_ping_daemon_0 FAILED\n");
16451 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16452 if (test_dmesg_0 () == -1) {
16453 printf ("test_dmesg_0 FAILED\n");
16457 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16458 if (test_drop_caches_0 () == -1) {
16459 printf ("test_drop_caches_0 FAILED\n");
16463 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16464 if (test_mv_0 () == -1) {
16465 printf ("test_mv_0 FAILED\n");
16469 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16470 if (test_mv_1 () == -1) {
16471 printf ("test_mv_1 FAILED\n");
16475 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16476 if (test_cp_a_0 () == -1) {
16477 printf ("test_cp_a_0 FAILED\n");
16481 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16482 if (test_cp_0 () == -1) {
16483 printf ("test_cp_0 FAILED\n");
16487 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16488 if (test_cp_1 () == -1) {
16489 printf ("test_cp_1 FAILED\n");
16493 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16494 if (test_cp_2 () == -1) {
16495 printf ("test_cp_2 FAILED\n");
16499 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16500 if (test_grub_install_0 () == -1) {
16501 printf ("test_grub_install_0 FAILED\n");
16505 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16506 if (test_zero_0 () == -1) {
16507 printf ("test_zero_0 FAILED\n");
16511 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16512 if (test_fsck_0 () == -1) {
16513 printf ("test_fsck_0 FAILED\n");
16517 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16518 if (test_fsck_1 () == -1) {
16519 printf ("test_fsck_1 FAILED\n");
16523 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16524 if (test_set_e2uuid_0 () == -1) {
16525 printf ("test_set_e2uuid_0 FAILED\n");
16529 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16530 if (test_set_e2uuid_1 () == -1) {
16531 printf ("test_set_e2uuid_1 FAILED\n");
16535 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16536 if (test_set_e2uuid_2 () == -1) {
16537 printf ("test_set_e2uuid_2 FAILED\n");
16541 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16542 if (test_set_e2uuid_3 () == -1) {
16543 printf ("test_set_e2uuid_3 FAILED\n");
16547 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16548 if (test_set_e2label_0 () == -1) {
16549 printf ("test_set_e2label_0 FAILED\n");
16553 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16554 if (test_pvremove_0 () == -1) {
16555 printf ("test_pvremove_0 FAILED\n");
16559 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16560 if (test_pvremove_1 () == -1) {
16561 printf ("test_pvremove_1 FAILED\n");
16565 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16566 if (test_pvremove_2 () == -1) {
16567 printf ("test_pvremove_2 FAILED\n");
16571 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16572 if (test_vgremove_0 () == -1) {
16573 printf ("test_vgremove_0 FAILED\n");
16577 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16578 if (test_vgremove_1 () == -1) {
16579 printf ("test_vgremove_1 FAILED\n");
16583 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16584 if (test_lvremove_0 () == -1) {
16585 printf ("test_lvremove_0 FAILED\n");
16589 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16590 if (test_lvremove_1 () == -1) {
16591 printf ("test_lvremove_1 FAILED\n");
16595 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16596 if (test_lvremove_2 () == -1) {
16597 printf ("test_lvremove_2 FAILED\n");
16601 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16602 if (test_mount_ro_0 () == -1) {
16603 printf ("test_mount_ro_0 FAILED\n");
16607 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16608 if (test_mount_ro_1 () == -1) {
16609 printf ("test_mount_ro_1 FAILED\n");
16613 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16614 if (test_tgz_in_0 () == -1) {
16615 printf ("test_tgz_in_0 FAILED\n");
16619 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16620 if (test_tar_in_0 () == -1) {
16621 printf ("test_tar_in_0 FAILED\n");
16625 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16626 if (test_checksum_0 () == -1) {
16627 printf ("test_checksum_0 FAILED\n");
16631 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16632 if (test_checksum_1 () == -1) {
16633 printf ("test_checksum_1 FAILED\n");
16637 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16638 if (test_checksum_2 () == -1) {
16639 printf ("test_checksum_2 FAILED\n");
16643 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16644 if (test_checksum_3 () == -1) {
16645 printf ("test_checksum_3 FAILED\n");
16649 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16650 if (test_checksum_4 () == -1) {
16651 printf ("test_checksum_4 FAILED\n");
16655 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16656 if (test_checksum_5 () == -1) {
16657 printf ("test_checksum_5 FAILED\n");
16661 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16662 if (test_checksum_6 () == -1) {
16663 printf ("test_checksum_6 FAILED\n");
16667 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16668 if (test_checksum_7 () == -1) {
16669 printf ("test_checksum_7 FAILED\n");
16673 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16674 if (test_checksum_8 () == -1) {
16675 printf ("test_checksum_8 FAILED\n");
16679 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16680 if (test_download_0 () == -1) {
16681 printf ("test_download_0 FAILED\n");
16685 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16686 if (test_upload_0 () == -1) {
16687 printf ("test_upload_0 FAILED\n");
16691 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16692 if (test_blockdev_rereadpt_0 () == -1) {
16693 printf ("test_blockdev_rereadpt_0 FAILED\n");
16697 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16698 if (test_blockdev_flushbufs_0 () == -1) {
16699 printf ("test_blockdev_flushbufs_0 FAILED\n");
16703 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16704 if (test_blockdev_getsize64_0 () == -1) {
16705 printf ("test_blockdev_getsize64_0 FAILED\n");
16709 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16710 if (test_blockdev_getsz_0 () == -1) {
16711 printf ("test_blockdev_getsz_0 FAILED\n");
16715 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16716 if (test_blockdev_getbsz_0 () == -1) {
16717 printf ("test_blockdev_getbsz_0 FAILED\n");
16721 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16722 if (test_blockdev_getss_0 () == -1) {
16723 printf ("test_blockdev_getss_0 FAILED\n");
16727 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16728 if (test_blockdev_getro_0 () == -1) {
16729 printf ("test_blockdev_getro_0 FAILED\n");
16733 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16734 if (test_blockdev_setrw_0 () == -1) {
16735 printf ("test_blockdev_setrw_0 FAILED\n");
16739 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16740 if (test_blockdev_setro_0 () == -1) {
16741 printf ("test_blockdev_setro_0 FAILED\n");
16745 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16746 if (test_statvfs_0 () == -1) {
16747 printf ("test_statvfs_0 FAILED\n");
16751 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16752 if (test_lstat_0 () == -1) {
16753 printf ("test_lstat_0 FAILED\n");
16757 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16758 if (test_stat_0 () == -1) {
16759 printf ("test_stat_0 FAILED\n");
16763 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16764 if (test_command_lines_0 () == -1) {
16765 printf ("test_command_lines_0 FAILED\n");
16769 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16770 if (test_command_lines_1 () == -1) {
16771 printf ("test_command_lines_1 FAILED\n");
16775 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16776 if (test_command_lines_2 () == -1) {
16777 printf ("test_command_lines_2 FAILED\n");
16781 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16782 if (test_command_lines_3 () == -1) {
16783 printf ("test_command_lines_3 FAILED\n");
16787 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16788 if (test_command_lines_4 () == -1) {
16789 printf ("test_command_lines_4 FAILED\n");
16793 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16794 if (test_command_lines_5 () == -1) {
16795 printf ("test_command_lines_5 FAILED\n");
16799 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16800 if (test_command_lines_6 () == -1) {
16801 printf ("test_command_lines_6 FAILED\n");
16805 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16806 if (test_command_lines_7 () == -1) {
16807 printf ("test_command_lines_7 FAILED\n");
16811 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16812 if (test_command_lines_8 () == -1) {
16813 printf ("test_command_lines_8 FAILED\n");
16817 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16818 if (test_command_lines_9 () == -1) {
16819 printf ("test_command_lines_9 FAILED\n");
16823 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16824 if (test_command_lines_10 () == -1) {
16825 printf ("test_command_lines_10 FAILED\n");
16829 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16830 if (test_command_0 () == -1) {
16831 printf ("test_command_0 FAILED\n");
16835 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16836 if (test_command_1 () == -1) {
16837 printf ("test_command_1 FAILED\n");
16841 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16842 if (test_command_2 () == -1) {
16843 printf ("test_command_2 FAILED\n");
16847 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16848 if (test_command_3 () == -1) {
16849 printf ("test_command_3 FAILED\n");
16853 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16854 if (test_command_4 () == -1) {
16855 printf ("test_command_4 FAILED\n");
16859 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16860 if (test_command_5 () == -1) {
16861 printf ("test_command_5 FAILED\n");
16865 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16866 if (test_command_6 () == -1) {
16867 printf ("test_command_6 FAILED\n");
16871 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16872 if (test_command_7 () == -1) {
16873 printf ("test_command_7 FAILED\n");
16877 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16878 if (test_command_8 () == -1) {
16879 printf ("test_command_8 FAILED\n");
16883 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16884 if (test_command_9 () == -1) {
16885 printf ("test_command_9 FAILED\n");
16889 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16890 if (test_command_10 () == -1) {
16891 printf ("test_command_10 FAILED\n");
16895 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16896 if (test_command_11 () == -1) {
16897 printf ("test_command_11 FAILED\n");
16901 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16902 if (test_file_0 () == -1) {
16903 printf ("test_file_0 FAILED\n");
16907 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16908 if (test_file_1 () == -1) {
16909 printf ("test_file_1 FAILED\n");
16913 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16914 if (test_file_2 () == -1) {
16915 printf ("test_file_2 FAILED\n");
16919 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16920 if (test_umount_all_0 () == -1) {
16921 printf ("test_umount_all_0 FAILED\n");
16925 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16926 if (test_umount_all_1 () == -1) {
16927 printf ("test_umount_all_1 FAILED\n");
16931 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16932 if (test_mounts_0 () == -1) {
16933 printf ("test_mounts_0 FAILED\n");
16937 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16938 if (test_umount_0 () == -1) {
16939 printf ("test_umount_0 FAILED\n");
16943 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16944 if (test_umount_1 () == -1) {
16945 printf ("test_umount_1 FAILED\n");
16949 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16950 if (test_write_file_0 () == -1) {
16951 printf ("test_write_file_0 FAILED\n");
16955 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16956 if (test_write_file_1 () == -1) {
16957 printf ("test_write_file_1 FAILED\n");
16961 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16962 if (test_write_file_2 () == -1) {
16963 printf ("test_write_file_2 FAILED\n");
16967 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16968 if (test_write_file_3 () == -1) {
16969 printf ("test_write_file_3 FAILED\n");
16973 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16974 if (test_write_file_4 () == -1) {
16975 printf ("test_write_file_4 FAILED\n");
16979 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16980 if (test_write_file_5 () == -1) {
16981 printf ("test_write_file_5 FAILED\n");
16985 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16986 if (test_mkfs_0 () == -1) {
16987 printf ("test_mkfs_0 FAILED\n");
16991 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16992 if (test_lvcreate_0 () == -1) {
16993 printf ("test_lvcreate_0 FAILED\n");
16997 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16998 if (test_vgcreate_0 () == -1) {
16999 printf ("test_vgcreate_0 FAILED\n");
17003 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17004 if (test_pvcreate_0 () == -1) {
17005 printf ("test_pvcreate_0 FAILED\n");
17009 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17010 if (test_is_dir_0 () == -1) {
17011 printf ("test_is_dir_0 FAILED\n");
17015 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17016 if (test_is_dir_1 () == -1) {
17017 printf ("test_is_dir_1 FAILED\n");
17021 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17022 if (test_is_file_0 () == -1) {
17023 printf ("test_is_file_0 FAILED\n");
17027 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17028 if (test_is_file_1 () == -1) {
17029 printf ("test_is_file_1 FAILED\n");
17033 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17034 if (test_exists_0 () == -1) {
17035 printf ("test_exists_0 FAILED\n");
17039 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17040 if (test_exists_1 () == -1) {
17041 printf ("test_exists_1 FAILED\n");
17045 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17046 if (test_mkdir_p_0 () == -1) {
17047 printf ("test_mkdir_p_0 FAILED\n");
17051 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17052 if (test_mkdir_p_1 () == -1) {
17053 printf ("test_mkdir_p_1 FAILED\n");
17057 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17058 if (test_mkdir_p_2 () == -1) {
17059 printf ("test_mkdir_p_2 FAILED\n");
17063 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17064 if (test_mkdir_p_3 () == -1) {
17065 printf ("test_mkdir_p_3 FAILED\n");
17069 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17070 if (test_mkdir_p_4 () == -1) {
17071 printf ("test_mkdir_p_4 FAILED\n");
17075 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17076 if (test_mkdir_0 () == -1) {
17077 printf ("test_mkdir_0 FAILED\n");
17081 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17082 if (test_mkdir_1 () == -1) {
17083 printf ("test_mkdir_1 FAILED\n");
17087 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17088 if (test_rm_rf_0 () == -1) {
17089 printf ("test_rm_rf_0 FAILED\n");
17093 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17094 if (test_rmdir_0 () == -1) {
17095 printf ("test_rmdir_0 FAILED\n");
17099 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17100 if (test_rmdir_1 () == -1) {
17101 printf ("test_rmdir_1 FAILED\n");
17105 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17106 if (test_rmdir_2 () == -1) {
17107 printf ("test_rmdir_2 FAILED\n");
17111 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17112 if (test_rm_0 () == -1) {
17113 printf ("test_rm_0 FAILED\n");
17117 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17118 if (test_rm_1 () == -1) {
17119 printf ("test_rm_1 FAILED\n");
17123 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17124 if (test_rm_2 () == -1) {
17125 printf ("test_rm_2 FAILED\n");
17129 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17130 if (test_read_lines_0 () == -1) {
17131 printf ("test_read_lines_0 FAILED\n");
17135 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17136 if (test_read_lines_1 () == -1) {
17137 printf ("test_read_lines_1 FAILED\n");
17141 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17142 if (test_lvs_0 () == -1) {
17143 printf ("test_lvs_0 FAILED\n");
17147 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17148 if (test_lvs_1 () == -1) {
17149 printf ("test_lvs_1 FAILED\n");
17153 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17154 if (test_vgs_0 () == -1) {
17155 printf ("test_vgs_0 FAILED\n");
17159 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17160 if (test_vgs_1 () == -1) {
17161 printf ("test_vgs_1 FAILED\n");
17165 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17166 if (test_pvs_0 () == -1) {
17167 printf ("test_pvs_0 FAILED\n");
17171 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17172 if (test_pvs_1 () == -1) {
17173 printf ("test_pvs_1 FAILED\n");
17177 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17178 if (test_list_partitions_0 () == -1) {
17179 printf ("test_list_partitions_0 FAILED\n");
17183 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17184 if (test_list_partitions_1 () == -1) {
17185 printf ("test_list_partitions_1 FAILED\n");
17189 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17190 if (test_list_devices_0 () == -1) {
17191 printf ("test_list_devices_0 FAILED\n");
17195 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17196 if (test_ls_0 () == -1) {
17197 printf ("test_ls_0 FAILED\n");
17201 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17202 if (test_cat_0 () == -1) {
17203 printf ("test_cat_0 FAILED\n");
17207 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17208 if (test_touch_0 () == -1) {
17209 printf ("test_touch_0 FAILED\n");
17213 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17214 if (test_sync_0 () == -1) {
17215 printf ("test_sync_0 FAILED\n");
17219 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17220 if (test_mount_0 () == -1) {
17221 printf ("test_mount_0 FAILED\n");
17226 unlink ("test1.img");
17227 unlink ("test2.img");
17228 unlink ("test3.img");
17231 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);