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_mkdtemp_0_skip (void)
160 str = getenv ("SKIP_TEST_MKDTEMP_0");
161 if (str && strcmp (str, "1") == 0) return 1;
162 str = getenv ("SKIP_TEST_MKDTEMP");
163 if (str && strcmp (str, "1") == 0) return 1;
167 static int test_mkdtemp_0 (void)
169 if (test_mkdtemp_0_skip ()) {
170 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdtemp_0");
174 /* InitBasicFS for test_mkdtemp_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 mkdtemp (0) */
230 char path[] = "/tmp";
233 r = guestfs_mkdir (g, path);
238 char template[] = "/tmp/tmpXXXXXX";
241 r = guestfs_mkdtemp (g, template);
249 static int test_scrub_file_0_skip (void)
253 str = getenv ("SKIP_TEST_SCRUB_FILE_0");
254 if (str && strcmp (str, "1") == 0) return 1;
255 str = getenv ("SKIP_TEST_SCRUB_FILE");
256 if (str && strcmp (str, "1") == 0) return 1;
260 static int test_scrub_file_0 (void)
262 if (test_scrub_file_0_skip ()) {
263 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_file_0");
267 /* InitBasicFS for test_scrub_file_0: create ext2 on /dev/sda1 */
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);
291 char device[] = "/dev/sda";
292 char lines_0[] = ",";
299 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
304 char fstype[] = "ext2";
305 char device[] = "/dev/sda1";
308 r = guestfs_mkfs (g, fstype, device);
313 char device[] = "/dev/sda1";
314 char mountpoint[] = "/";
317 r = guestfs_mount (g, device, mountpoint);
321 /* TestRun for scrub_file (0) */
323 char path[] = "/file";
324 char content[] = "content";
327 r = guestfs_write_file (g, path, content, 0);
332 char file[] = "/file";
335 r = guestfs_scrub_file (g, file);
342 static int test_scrub_device_0_skip (void)
346 str = getenv ("SKIP_TEST_SCRUB_DEVICE_0");
347 if (str && strcmp (str, "1") == 0) return 1;
348 str = getenv ("SKIP_TEST_SCRUB_DEVICE");
349 if (str && strcmp (str, "1") == 0) return 1;
353 static int test_scrub_device_0 (void)
355 if (test_scrub_device_0_skip ()) {
356 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_scrub_device_0");
360 /* InitNone|InitEmpty for test_scrub_device_0 */
362 char device[] = "/dev/sda";
365 r = guestfs_blockdev_setrw (g, device);
372 r = guestfs_umount_all (g);
379 r = guestfs_lvm_remove_all (g);
383 /* TestRun for scrub_device (0) */
385 char device[] = "/dev/sdc";
388 r = guestfs_scrub_device (g, device);
395 static int test_glob_expand_0_skip (void)
399 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
400 if (str && strcmp (str, "1") == 0) return 1;
401 str = getenv ("SKIP_TEST_GLOB_EXPAND");
402 if (str && strcmp (str, "1") == 0) return 1;
406 static int test_glob_expand_0 (void)
408 if (test_glob_expand_0_skip ()) {
409 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_0");
413 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
415 char device[] = "/dev/sda";
418 r = guestfs_blockdev_setrw (g, device);
425 r = guestfs_umount_all (g);
432 r = guestfs_lvm_remove_all (g);
437 char device[] = "/dev/sda";
438 char lines_0[] = ",";
445 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
450 char fstype[] = "ext2";
451 char device[] = "/dev/sda1";
454 r = guestfs_mkfs (g, fstype, device);
459 char device[] = "/dev/sda1";
460 char mountpoint[] = "/";
463 r = guestfs_mount (g, device, mountpoint);
467 /* TestOutputList for glob_expand (0) */
469 char path[] = "/a/b/c";
472 r = guestfs_mkdir_p (g, path);
477 char path[] = "/a/b/c/d";
480 r = guestfs_touch (g, path);
485 char path[] = "/a/b/c/e";
488 r = guestfs_touch (g, path);
493 char pattern[] = "/a/b/c/*";
497 r = guestfs_glob_expand (g, pattern);
501 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
506 char expected[] = "/a/b/c/d";
507 if (strcmp (r[0], expected) != 0) {
508 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
513 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
518 char expected[] = "/a/b/c/e";
519 if (strcmp (r[1], expected) != 0) {
520 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
525 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
529 for (i = 0; r[i] != NULL; ++i)
536 static int test_glob_expand_1_skip (void)
540 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
541 if (str && strcmp (str, "1") == 0) return 1;
542 str = getenv ("SKIP_TEST_GLOB_EXPAND");
543 if (str && strcmp (str, "1") == 0) return 1;
547 static int test_glob_expand_1 (void)
549 if (test_glob_expand_1_skip ()) {
550 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_1");
554 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
556 char device[] = "/dev/sda";
559 r = guestfs_blockdev_setrw (g, device);
566 r = guestfs_umount_all (g);
573 r = guestfs_lvm_remove_all (g);
578 char device[] = "/dev/sda";
579 char lines_0[] = ",";
586 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
591 char fstype[] = "ext2";
592 char device[] = "/dev/sda1";
595 r = guestfs_mkfs (g, fstype, device);
600 char device[] = "/dev/sda1";
601 char mountpoint[] = "/";
604 r = guestfs_mount (g, device, mountpoint);
608 /* TestOutputList for glob_expand (1) */
610 char path[] = "/a/b/c";
613 r = guestfs_mkdir_p (g, path);
618 char path[] = "/a/b/c/d";
621 r = guestfs_touch (g, path);
626 char path[] = "/a/b/c/e";
629 r = guestfs_touch (g, path);
634 char pattern[] = "/a/*/c/*";
638 r = guestfs_glob_expand (g, pattern);
642 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
647 char expected[] = "/a/b/c/d";
648 if (strcmp (r[0], expected) != 0) {
649 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
654 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
659 char expected[] = "/a/b/c/e";
660 if (strcmp (r[1], expected) != 0) {
661 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
666 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
670 for (i = 0; r[i] != NULL; ++i)
677 static int test_glob_expand_2_skip (void)
681 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
682 if (str && strcmp (str, "1") == 0) return 1;
683 str = getenv ("SKIP_TEST_GLOB_EXPAND");
684 if (str && strcmp (str, "1") == 0) return 1;
688 static int test_glob_expand_2 (void)
690 if (test_glob_expand_2_skip ()) {
691 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_2");
695 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
697 char device[] = "/dev/sda";
700 r = guestfs_blockdev_setrw (g, device);
707 r = guestfs_umount_all (g);
714 r = guestfs_lvm_remove_all (g);
719 char device[] = "/dev/sda";
720 char lines_0[] = ",";
727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
732 char fstype[] = "ext2";
733 char device[] = "/dev/sda1";
736 r = guestfs_mkfs (g, fstype, device);
741 char device[] = "/dev/sda1";
742 char mountpoint[] = "/";
745 r = guestfs_mount (g, device, mountpoint);
749 /* TestOutputList for glob_expand (2) */
751 char path[] = "/a/b/c";
754 r = guestfs_mkdir_p (g, path);
759 char path[] = "/a/b/c/d";
762 r = guestfs_touch (g, path);
767 char path[] = "/a/b/c/e";
770 r = guestfs_touch (g, path);
775 char pattern[] = "/a/*/x/*";
779 r = guestfs_glob_expand (g, pattern);
783 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
787 for (i = 0; r[i] != NULL; ++i)
794 static int test_ntfs_3g_probe_0_skip (void)
798 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
799 if (str && strcmp (str, "1") == 0) return 1;
800 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
801 if (str && strcmp (str, "1") == 0) return 1;
805 static int test_ntfs_3g_probe_0 (void)
807 if (test_ntfs_3g_probe_0_skip ()) {
808 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
812 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
814 char device[] = "/dev/sda";
817 r = guestfs_blockdev_setrw (g, device);
824 r = guestfs_umount_all (g);
831 r = guestfs_lvm_remove_all (g);
835 /* TestOutputInt for ntfs_3g_probe (0) */
837 char device[] = "/dev/sda";
838 char lines_0[] = ",";
845 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
850 char fstype[] = "ntfs";
851 char device[] = "/dev/sda1";
854 r = guestfs_mkfs (g, fstype, device);
859 char device[] = "/dev/sda1";
862 r = guestfs_ntfs_3g_probe (g, 1, device);
866 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
873 static int test_ntfs_3g_probe_1_skip (void)
877 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
878 if (str && strcmp (str, "1") == 0) return 1;
879 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
880 if (str && strcmp (str, "1") == 0) return 1;
884 static int test_ntfs_3g_probe_1 (void)
886 if (test_ntfs_3g_probe_1_skip ()) {
887 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
891 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
893 char device[] = "/dev/sda";
896 r = guestfs_blockdev_setrw (g, device);
903 r = guestfs_umount_all (g);
910 r = guestfs_lvm_remove_all (g);
914 /* TestOutputInt for ntfs_3g_probe (1) */
916 char device[] = "/dev/sda";
917 char lines_0[] = ",";
924 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
929 char fstype[] = "ext2";
930 char device[] = "/dev/sda1";
933 r = guestfs_mkfs (g, fstype, device);
938 char device[] = "/dev/sda1";
941 r = guestfs_ntfs_3g_probe (g, 1, device);
945 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
952 static int test_sleep_0_skip (void)
956 str = getenv ("SKIP_TEST_SLEEP_0");
957 if (str && strcmp (str, "1") == 0) return 1;
958 str = getenv ("SKIP_TEST_SLEEP");
959 if (str && strcmp (str, "1") == 0) return 1;
963 static int test_sleep_0 (void)
965 if (test_sleep_0_skip ()) {
966 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
970 /* InitNone|InitEmpty for test_sleep_0 */
972 char device[] = "/dev/sda";
975 r = guestfs_blockdev_setrw (g, device);
982 r = guestfs_umount_all (g);
989 r = guestfs_lvm_remove_all (g);
993 /* TestRun for sleep (0) */
997 r = guestfs_sleep (g, 1);
1004 static int test_find_0_skip (void)
1008 str = getenv ("SKIP_TEST_FIND_0");
1009 if (str && strcmp (str, "1") == 0) return 1;
1010 str = getenv ("SKIP_TEST_FIND");
1011 if (str && strcmp (str, "1") == 0) return 1;
1015 static int test_find_0 (void)
1017 if (test_find_0_skip ()) {
1018 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
1022 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
1024 char device[] = "/dev/sda";
1027 r = guestfs_blockdev_setrw (g, device);
1034 r = guestfs_umount_all (g);
1041 r = guestfs_lvm_remove_all (g);
1046 char device[] = "/dev/sda";
1047 char lines_0[] = ",";
1054 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1059 char fstype[] = "ext2";
1060 char device[] = "/dev/sda1";
1063 r = guestfs_mkfs (g, fstype, device);
1068 char device[] = "/dev/sda1";
1069 char mountpoint[] = "/";
1072 r = guestfs_mount (g, device, mountpoint);
1076 /* TestOutputList for find (0) */
1078 char directory[] = "/";
1082 r = guestfs_find (g, directory);
1086 fprintf (stderr, "test_find_0: short list returned from command\n");
1091 char expected[] = "lost+found";
1092 if (strcmp (r[0], expected) != 0) {
1093 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1098 fprintf (stderr, "test_find_0: extra elements returned from command\n");
1102 for (i = 0; r[i] != NULL; ++i)
1109 static int test_find_1_skip (void)
1113 str = getenv ("SKIP_TEST_FIND_1");
1114 if (str && strcmp (str, "1") == 0) return 1;
1115 str = getenv ("SKIP_TEST_FIND");
1116 if (str && strcmp (str, "1") == 0) return 1;
1120 static int test_find_1 (void)
1122 if (test_find_1_skip ()) {
1123 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
1127 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
1129 char device[] = "/dev/sda";
1132 r = guestfs_blockdev_setrw (g, device);
1139 r = guestfs_umount_all (g);
1146 r = guestfs_lvm_remove_all (g);
1151 char device[] = "/dev/sda";
1152 char lines_0[] = ",";
1159 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1164 char fstype[] = "ext2";
1165 char device[] = "/dev/sda1";
1168 r = guestfs_mkfs (g, fstype, device);
1173 char device[] = "/dev/sda1";
1174 char mountpoint[] = "/";
1177 r = guestfs_mount (g, device, mountpoint);
1181 /* TestOutputList for find (1) */
1186 r = guestfs_touch (g, path);
1194 r = guestfs_mkdir (g, path);
1199 char path[] = "/b/c";
1202 r = guestfs_touch (g, path);
1207 char directory[] = "/";
1211 r = guestfs_find (g, directory);
1215 fprintf (stderr, "test_find_1: short list returned from command\n");
1220 char expected[] = "a";
1221 if (strcmp (r[0], expected) != 0) {
1222 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1227 fprintf (stderr, "test_find_1: short list returned from command\n");
1232 char expected[] = "b";
1233 if (strcmp (r[1], expected) != 0) {
1234 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1239 fprintf (stderr, "test_find_1: short list returned from command\n");
1244 char expected[] = "b/c";
1245 if (strcmp (r[2], expected) != 0) {
1246 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1251 fprintf (stderr, "test_find_1: short list returned from command\n");
1256 char expected[] = "lost+found";
1257 if (strcmp (r[3], expected) != 0) {
1258 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1263 fprintf (stderr, "test_find_1: extra elements returned from command\n");
1267 for (i = 0; r[i] != NULL; ++i)
1274 static int test_find_2_skip (void)
1278 str = getenv ("SKIP_TEST_FIND_2");
1279 if (str && strcmp (str, "1") == 0) return 1;
1280 str = getenv ("SKIP_TEST_FIND");
1281 if (str && strcmp (str, "1") == 0) return 1;
1285 static int test_find_2 (void)
1287 if (test_find_2_skip ()) {
1288 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
1292 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1294 char device[] = "/dev/sda";
1297 r = guestfs_blockdev_setrw (g, device);
1304 r = guestfs_umount_all (g);
1311 r = guestfs_lvm_remove_all (g);
1316 char device[] = "/dev/sda";
1317 char lines_0[] = ",";
1324 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1329 char fstype[] = "ext2";
1330 char device[] = "/dev/sda1";
1333 r = guestfs_mkfs (g, fstype, device);
1338 char device[] = "/dev/sda1";
1339 char mountpoint[] = "/";
1342 r = guestfs_mount (g, device, mountpoint);
1346 /* TestOutputList for find (2) */
1348 char path[] = "/a/b/c";
1351 r = guestfs_mkdir_p (g, path);
1356 char path[] = "/a/b/c/d";
1359 r = guestfs_touch (g, path);
1364 char directory[] = "/a/b/";
1368 r = guestfs_find (g, directory);
1372 fprintf (stderr, "test_find_2: short list returned from command\n");
1377 char expected[] = "c";
1378 if (strcmp (r[0], expected) != 0) {
1379 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1384 fprintf (stderr, "test_find_2: short list returned from command\n");
1389 char expected[] = "c/d";
1390 if (strcmp (r[1], expected) != 0) {
1391 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1396 fprintf (stderr, "test_find_2: extra elements returned from command\n");
1400 for (i = 0; r[i] != NULL; ++i)
1407 static int test_lvresize_0_skip (void)
1411 str = getenv ("SKIP_TEST_LVRESIZE_0");
1412 if (str && strcmp (str, "1") == 0) return 1;
1413 str = getenv ("SKIP_TEST_LVRESIZE");
1414 if (str && strcmp (str, "1") == 0) return 1;
1418 static int test_lvresize_0 (void)
1420 if (test_lvresize_0_skip ()) {
1421 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
1425 /* InitNone|InitEmpty for test_lvresize_0 */
1427 char device[] = "/dev/sda";
1430 r = guestfs_blockdev_setrw (g, device);
1437 r = guestfs_umount_all (g);
1444 r = guestfs_lvm_remove_all (g);
1448 /* TestOutput for lvresize (0) */
1449 char expected[] = "test content";
1451 char device[] = "/dev/sda";
1452 char lines_0[] = ",";
1459 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1464 char device[] = "/dev/sda1";
1467 r = guestfs_pvcreate (g, device);
1472 char volgroup[] = "VG";
1473 char physvols_0[] = "/dev/sda1";
1474 char *physvols[] = {
1480 r = guestfs_vgcreate (g, volgroup, physvols);
1485 char logvol[] = "LV";
1486 char volgroup[] = "VG";
1489 r = guestfs_lvcreate (g, logvol, volgroup, 10);
1494 char fstype[] = "ext2";
1495 char device[] = "/dev/VG/LV";
1498 r = guestfs_mkfs (g, fstype, device);
1503 char device[] = "/dev/VG/LV";
1504 char mountpoint[] = "/";
1507 r = guestfs_mount (g, device, mountpoint);
1512 char path[] = "/new";
1513 char content[] = "test content";
1516 r = guestfs_write_file (g, path, content, 0);
1521 char pathordevice[] = "/";
1524 r = guestfs_umount (g, pathordevice);
1529 char device[] = "/dev/VG/LV";
1532 r = guestfs_lvresize (g, device, 20);
1537 char device[] = "/dev/VG/LV";
1540 r = guestfs_e2fsck_f (g, device);
1545 char device[] = "/dev/VG/LV";
1548 r = guestfs_resize2fs (g, device);
1553 char device[] = "/dev/VG/LV";
1554 char mountpoint[] = "/";
1557 r = guestfs_mount (g, device, mountpoint);
1562 char path[] = "/new";
1565 r = guestfs_cat (g, path);
1568 if (strcmp (r, expected) != 0) {
1569 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1577 static int test_zerofree_0_skip (void)
1581 str = getenv ("SKIP_TEST_ZEROFREE_0");
1582 if (str && strcmp (str, "1") == 0) return 1;
1583 str = getenv ("SKIP_TEST_ZEROFREE");
1584 if (str && strcmp (str, "1") == 0) return 1;
1588 static int test_zerofree_0 (void)
1590 if (test_zerofree_0_skip ()) {
1591 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
1595 /* InitNone|InitEmpty for test_zerofree_0 */
1597 char device[] = "/dev/sda";
1600 r = guestfs_blockdev_setrw (g, device);
1607 r = guestfs_umount_all (g);
1614 r = guestfs_lvm_remove_all (g);
1618 /* TestOutput for zerofree (0) */
1619 char expected[] = "test file";
1621 char device[] = "/dev/sda";
1622 char lines_0[] = ",";
1629 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1634 char fstype[] = "ext3";
1635 char device[] = "/dev/sda1";
1638 r = guestfs_mkfs (g, fstype, device);
1643 char device[] = "/dev/sda1";
1644 char mountpoint[] = "/";
1647 r = guestfs_mount (g, device, mountpoint);
1652 char path[] = "/new";
1653 char content[] = "test file";
1656 r = guestfs_write_file (g, path, content, 0);
1661 char pathordevice[] = "/dev/sda1";
1664 r = guestfs_umount (g, pathordevice);
1669 char device[] = "/dev/sda1";
1672 r = guestfs_zerofree (g, device);
1677 char device[] = "/dev/sda1";
1678 char mountpoint[] = "/";
1681 r = guestfs_mount (g, device, mountpoint);
1686 char path[] = "/new";
1689 r = guestfs_cat (g, path);
1692 if (strcmp (r, expected) != 0) {
1693 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1701 static int test_hexdump_0_skip (void)
1705 str = getenv ("SKIP_TEST_HEXDUMP_0");
1706 if (str && strcmp (str, "1") == 0) return 1;
1707 str = getenv ("SKIP_TEST_HEXDUMP");
1708 if (str && strcmp (str, "1") == 0) return 1;
1712 static int test_hexdump_0 (void)
1714 if (test_hexdump_0_skip ()) {
1715 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1719 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1721 char device[] = "/dev/sda";
1724 r = guestfs_blockdev_setrw (g, device);
1731 r = guestfs_umount_all (g);
1738 r = guestfs_lvm_remove_all (g);
1743 char device[] = "/dev/sda";
1744 char lines_0[] = ",";
1751 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1756 char fstype[] = "ext2";
1757 char device[] = "/dev/sda1";
1760 r = guestfs_mkfs (g, fstype, device);
1765 char device[] = "/dev/sda1";
1766 char mountpoint[] = "/";
1769 r = guestfs_mount (g, device, mountpoint);
1773 /* TestOutput for hexdump (0) */
1774 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
1776 char path[] = "/new";
1777 char content[] = "hello\nworld\n";
1780 r = guestfs_write_file (g, path, content, 12);
1785 char path[] = "/new";
1788 r = guestfs_hexdump (g, path);
1791 if (strcmp (r, expected) != 0) {
1792 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1800 static int test_strings_e_0_skip (void)
1804 str = getenv ("SKIP_TEST_STRINGS_E_0");
1805 if (str && strcmp (str, "1") == 0) return 1;
1806 str = getenv ("SKIP_TEST_STRINGS_E");
1807 if (str && strcmp (str, "1") == 0) return 1;
1811 static int test_strings_e_0 (void)
1813 if (test_strings_e_0_skip ()) {
1814 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1818 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1820 char device[] = "/dev/sda";
1823 r = guestfs_blockdev_setrw (g, device);
1830 r = guestfs_umount_all (g);
1837 r = guestfs_lvm_remove_all (g);
1842 char device[] = "/dev/sda";
1843 char lines_0[] = ",";
1850 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1855 char fstype[] = "ext2";
1856 char device[] = "/dev/sda1";
1859 r = guestfs_mkfs (g, fstype, device);
1864 char device[] = "/dev/sda1";
1865 char mountpoint[] = "/";
1868 r = guestfs_mount (g, device, mountpoint);
1872 /* TestOutputList for strings_e (0) */
1874 char path[] = "/new";
1875 char content[] = "hello\nworld\n";
1878 r = guestfs_write_file (g, path, content, 0);
1883 char encoding[] = "b";
1884 char path[] = "/new";
1888 r = guestfs_strings_e (g, encoding, path);
1892 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1896 for (i = 0; r[i] != NULL; ++i)
1903 static int test_strings_e_1_skip (void)
1907 str = getenv ("SKIP_TEST_STRINGS_E_1");
1908 if (str && strcmp (str, "1") == 0) return 1;
1909 str = getenv ("SKIP_TEST_STRINGS_E");
1910 if (str && strcmp (str, "1") == 0) return 1;
1914 static int test_strings_e_1 (void)
1916 if (test_strings_e_1_skip ()) {
1917 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1921 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1925 static int test_strings_0_skip (void)
1929 str = getenv ("SKIP_TEST_STRINGS_0");
1930 if (str && strcmp (str, "1") == 0) return 1;
1931 str = getenv ("SKIP_TEST_STRINGS");
1932 if (str && strcmp (str, "1") == 0) return 1;
1936 static int test_strings_0 (void)
1938 if (test_strings_0_skip ()) {
1939 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1943 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1945 char device[] = "/dev/sda";
1948 r = guestfs_blockdev_setrw (g, device);
1955 r = guestfs_umount_all (g);
1962 r = guestfs_lvm_remove_all (g);
1967 char device[] = "/dev/sda";
1968 char lines_0[] = ",";
1975 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1980 char fstype[] = "ext2";
1981 char device[] = "/dev/sda1";
1984 r = guestfs_mkfs (g, fstype, device);
1989 char device[] = "/dev/sda1";
1990 char mountpoint[] = "/";
1993 r = guestfs_mount (g, device, mountpoint);
1997 /* TestOutputList for strings (0) */
1999 char path[] = "/new";
2000 char content[] = "hello\nworld\n";
2003 r = guestfs_write_file (g, path, content, 0);
2008 char path[] = "/new";
2012 r = guestfs_strings (g, path);
2016 fprintf (stderr, "test_strings_0: short list returned from command\n");
2021 char expected[] = "hello";
2022 if (strcmp (r[0], expected) != 0) {
2023 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
2028 fprintf (stderr, "test_strings_0: short list returned from command\n");
2033 char expected[] = "world";
2034 if (strcmp (r[1], expected) != 0) {
2035 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
2040 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
2044 for (i = 0; r[i] != NULL; ++i)
2051 static int test_strings_1_skip (void)
2055 str = getenv ("SKIP_TEST_STRINGS_1");
2056 if (str && strcmp (str, "1") == 0) return 1;
2057 str = getenv ("SKIP_TEST_STRINGS");
2058 if (str && strcmp (str, "1") == 0) return 1;
2062 static int test_strings_1 (void)
2064 if (test_strings_1_skip ()) {
2065 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
2069 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
2071 char device[] = "/dev/sda";
2074 r = guestfs_blockdev_setrw (g, device);
2081 r = guestfs_umount_all (g);
2088 r = guestfs_lvm_remove_all (g);
2093 char device[] = "/dev/sda";
2094 char lines_0[] = ",";
2101 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2106 char fstype[] = "ext2";
2107 char device[] = "/dev/sda1";
2110 r = guestfs_mkfs (g, fstype, device);
2115 char device[] = "/dev/sda1";
2116 char mountpoint[] = "/";
2119 r = guestfs_mount (g, device, mountpoint);
2123 /* TestOutputList for strings (1) */
2125 char path[] = "/new";
2128 r = guestfs_touch (g, path);
2133 char path[] = "/new";
2137 r = guestfs_strings (g, path);
2141 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
2145 for (i = 0; r[i] != NULL; ++i)
2152 static int test_equal_0_skip (void)
2156 str = getenv ("SKIP_TEST_EQUAL_0");
2157 if (str && strcmp (str, "1") == 0) return 1;
2158 str = getenv ("SKIP_TEST_EQUAL");
2159 if (str && strcmp (str, "1") == 0) return 1;
2163 static int test_equal_0 (void)
2165 if (test_equal_0_skip ()) {
2166 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
2170 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
2172 char device[] = "/dev/sda";
2175 r = guestfs_blockdev_setrw (g, device);
2182 r = guestfs_umount_all (g);
2189 r = guestfs_lvm_remove_all (g);
2194 char device[] = "/dev/sda";
2195 char lines_0[] = ",";
2202 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2207 char fstype[] = "ext2";
2208 char device[] = "/dev/sda1";
2211 r = guestfs_mkfs (g, fstype, device);
2216 char device[] = "/dev/sda1";
2217 char mountpoint[] = "/";
2220 r = guestfs_mount (g, device, mountpoint);
2224 /* TestOutputTrue for equal (0) */
2226 char path[] = "/file1";
2227 char content[] = "contents of a file";
2230 r = guestfs_write_file (g, path, content, 0);
2235 char src[] = "/file1";
2236 char dest[] = "/file2";
2239 r = guestfs_cp (g, src, dest);
2244 char file1[] = "/file1";
2245 char file2[] = "/file2";
2248 r = guestfs_equal (g, file1, file2);
2252 fprintf (stderr, "test_equal_0: expected true, got false\n");
2259 static int test_equal_1_skip (void)
2263 str = getenv ("SKIP_TEST_EQUAL_1");
2264 if (str && strcmp (str, "1") == 0) return 1;
2265 str = getenv ("SKIP_TEST_EQUAL");
2266 if (str && strcmp (str, "1") == 0) return 1;
2270 static int test_equal_1 (void)
2272 if (test_equal_1_skip ()) {
2273 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2277 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2279 char device[] = "/dev/sda";
2282 r = guestfs_blockdev_setrw (g, device);
2289 r = guestfs_umount_all (g);
2296 r = guestfs_lvm_remove_all (g);
2301 char device[] = "/dev/sda";
2302 char lines_0[] = ",";
2309 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2314 char fstype[] = "ext2";
2315 char device[] = "/dev/sda1";
2318 r = guestfs_mkfs (g, fstype, device);
2323 char device[] = "/dev/sda1";
2324 char mountpoint[] = "/";
2327 r = guestfs_mount (g, device, mountpoint);
2331 /* TestOutputFalse for equal (1) */
2333 char path[] = "/file1";
2334 char content[] = "contents of a file";
2337 r = guestfs_write_file (g, path, content, 0);
2342 char path[] = "/file2";
2343 char content[] = "contents of another file";
2346 r = guestfs_write_file (g, path, content, 0);
2351 char file1[] = "/file1";
2352 char file2[] = "/file2";
2355 r = guestfs_equal (g, file1, file2);
2359 fprintf (stderr, "test_equal_1: expected false, got true\n");
2366 static int test_equal_2_skip (void)
2370 str = getenv ("SKIP_TEST_EQUAL_2");
2371 if (str && strcmp (str, "1") == 0) return 1;
2372 str = getenv ("SKIP_TEST_EQUAL");
2373 if (str && strcmp (str, "1") == 0) return 1;
2377 static int test_equal_2 (void)
2379 if (test_equal_2_skip ()) {
2380 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2384 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2386 char device[] = "/dev/sda";
2389 r = guestfs_blockdev_setrw (g, device);
2396 r = guestfs_umount_all (g);
2403 r = guestfs_lvm_remove_all (g);
2408 char device[] = "/dev/sda";
2409 char lines_0[] = ",";
2416 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2421 char fstype[] = "ext2";
2422 char device[] = "/dev/sda1";
2425 r = guestfs_mkfs (g, fstype, device);
2430 char device[] = "/dev/sda1";
2431 char mountpoint[] = "/";
2434 r = guestfs_mount (g, device, mountpoint);
2438 /* TestLastFail for equal (2) */
2440 char file1[] = "/file1";
2441 char file2[] = "/file2";
2444 r = guestfs_equal (g, file1, file2);
2451 static int test_ping_daemon_0_skip (void)
2455 str = getenv ("SKIP_TEST_PING_DAEMON_0");
2456 if (str && strcmp (str, "1") == 0) return 1;
2457 str = getenv ("SKIP_TEST_PING_DAEMON");
2458 if (str && strcmp (str, "1") == 0) return 1;
2462 static int test_ping_daemon_0 (void)
2464 if (test_ping_daemon_0_skip ()) {
2465 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2469 /* InitNone|InitEmpty for test_ping_daemon_0 */
2471 char device[] = "/dev/sda";
2474 r = guestfs_blockdev_setrw (g, device);
2481 r = guestfs_umount_all (g);
2488 r = guestfs_lvm_remove_all (g);
2492 /* TestRun for ping_daemon (0) */
2496 r = guestfs_ping_daemon (g);
2503 static int test_dmesg_0_skip (void)
2507 str = getenv ("SKIP_TEST_DMESG_0");
2508 if (str && strcmp (str, "1") == 0) return 1;
2509 str = getenv ("SKIP_TEST_DMESG");
2510 if (str && strcmp (str, "1") == 0) return 1;
2514 static int test_dmesg_0 (void)
2516 if (test_dmesg_0_skip ()) {
2517 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2521 /* InitNone|InitEmpty for test_dmesg_0 */
2523 char device[] = "/dev/sda";
2526 r = guestfs_blockdev_setrw (g, device);
2533 r = guestfs_umount_all (g);
2540 r = guestfs_lvm_remove_all (g);
2544 /* TestRun for dmesg (0) */
2548 r = guestfs_dmesg (g);
2556 static int test_drop_caches_0_skip (void)
2560 str = getenv ("SKIP_TEST_DROP_CACHES_0");
2561 if (str && strcmp (str, "1") == 0) return 1;
2562 str = getenv ("SKIP_TEST_DROP_CACHES");
2563 if (str && strcmp (str, "1") == 0) return 1;
2567 static int test_drop_caches_0 (void)
2569 if (test_drop_caches_0_skip ()) {
2570 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2574 /* InitNone|InitEmpty for test_drop_caches_0 */
2576 char device[] = "/dev/sda";
2579 r = guestfs_blockdev_setrw (g, device);
2586 r = guestfs_umount_all (g);
2593 r = guestfs_lvm_remove_all (g);
2597 /* TestRun for drop_caches (0) */
2601 r = guestfs_drop_caches (g, 3);
2608 static int test_mv_0_skip (void)
2612 str = getenv ("SKIP_TEST_MV_0");
2613 if (str && strcmp (str, "1") == 0) return 1;
2614 str = getenv ("SKIP_TEST_MV");
2615 if (str && strcmp (str, "1") == 0) return 1;
2619 static int test_mv_0 (void)
2621 if (test_mv_0_skip ()) {
2622 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2626 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2628 char device[] = "/dev/sda";
2631 r = guestfs_blockdev_setrw (g, device);
2638 r = guestfs_umount_all (g);
2645 r = guestfs_lvm_remove_all (g);
2650 char device[] = "/dev/sda";
2651 char lines_0[] = ",";
2658 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2663 char fstype[] = "ext2";
2664 char device[] = "/dev/sda1";
2667 r = guestfs_mkfs (g, fstype, device);
2672 char device[] = "/dev/sda1";
2673 char mountpoint[] = "/";
2676 r = guestfs_mount (g, device, mountpoint);
2680 /* TestOutput for mv (0) */
2681 char expected[] = "file content";
2683 char path[] = "/old";
2684 char content[] = "file content";
2687 r = guestfs_write_file (g, path, content, 0);
2692 char src[] = "/old";
2693 char dest[] = "/new";
2696 r = guestfs_mv (g, src, dest);
2701 char path[] = "/new";
2704 r = guestfs_cat (g, path);
2707 if (strcmp (r, expected) != 0) {
2708 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2716 static int test_mv_1_skip (void)
2720 str = getenv ("SKIP_TEST_MV_1");
2721 if (str && strcmp (str, "1") == 0) return 1;
2722 str = getenv ("SKIP_TEST_MV");
2723 if (str && strcmp (str, "1") == 0) return 1;
2727 static int test_mv_1 (void)
2729 if (test_mv_1_skip ()) {
2730 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2734 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2736 char device[] = "/dev/sda";
2739 r = guestfs_blockdev_setrw (g, device);
2746 r = guestfs_umount_all (g);
2753 r = guestfs_lvm_remove_all (g);
2758 char device[] = "/dev/sda";
2759 char lines_0[] = ",";
2766 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2771 char fstype[] = "ext2";
2772 char device[] = "/dev/sda1";
2775 r = guestfs_mkfs (g, fstype, device);
2780 char device[] = "/dev/sda1";
2781 char mountpoint[] = "/";
2784 r = guestfs_mount (g, device, mountpoint);
2788 /* TestOutputFalse for mv (1) */
2790 char path[] = "/old";
2791 char content[] = "file content";
2794 r = guestfs_write_file (g, path, content, 0);
2799 char src[] = "/old";
2800 char dest[] = "/new";
2803 r = guestfs_mv (g, src, dest);
2808 char path[] = "/old";
2811 r = guestfs_is_file (g, path);
2815 fprintf (stderr, "test_mv_1: expected false, got true\n");
2822 static int test_cp_a_0_skip (void)
2826 str = getenv ("SKIP_TEST_CP_A_0");
2827 if (str && strcmp (str, "1") == 0) return 1;
2828 str = getenv ("SKIP_TEST_CP_A");
2829 if (str && strcmp (str, "1") == 0) return 1;
2833 static int test_cp_a_0 (void)
2835 if (test_cp_a_0_skip ()) {
2836 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2840 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2842 char device[] = "/dev/sda";
2845 r = guestfs_blockdev_setrw (g, device);
2852 r = guestfs_umount_all (g);
2859 r = guestfs_lvm_remove_all (g);
2864 char device[] = "/dev/sda";
2865 char lines_0[] = ",";
2872 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2877 char fstype[] = "ext2";
2878 char device[] = "/dev/sda1";
2881 r = guestfs_mkfs (g, fstype, device);
2886 char device[] = "/dev/sda1";
2887 char mountpoint[] = "/";
2890 r = guestfs_mount (g, device, mountpoint);
2894 /* TestOutput for cp_a (0) */
2895 char expected[] = "file content";
2897 char path[] = "/olddir";
2900 r = guestfs_mkdir (g, path);
2905 char path[] = "/newdir";
2908 r = guestfs_mkdir (g, path);
2913 char path[] = "/olddir/file";
2914 char content[] = "file content";
2917 r = guestfs_write_file (g, path, content, 0);
2922 char src[] = "/olddir";
2923 char dest[] = "/newdir";
2926 r = guestfs_cp_a (g, src, dest);
2931 char path[] = "/newdir/olddir/file";
2934 r = guestfs_cat (g, path);
2937 if (strcmp (r, expected) != 0) {
2938 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2946 static int test_cp_0_skip (void)
2950 str = getenv ("SKIP_TEST_CP_0");
2951 if (str && strcmp (str, "1") == 0) return 1;
2952 str = getenv ("SKIP_TEST_CP");
2953 if (str && strcmp (str, "1") == 0) return 1;
2957 static int test_cp_0 (void)
2959 if (test_cp_0_skip ()) {
2960 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2964 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2966 char device[] = "/dev/sda";
2969 r = guestfs_blockdev_setrw (g, device);
2976 r = guestfs_umount_all (g);
2983 r = guestfs_lvm_remove_all (g);
2988 char device[] = "/dev/sda";
2989 char lines_0[] = ",";
2996 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3001 char fstype[] = "ext2";
3002 char device[] = "/dev/sda1";
3005 r = guestfs_mkfs (g, fstype, device);
3010 char device[] = "/dev/sda1";
3011 char mountpoint[] = "/";
3014 r = guestfs_mount (g, device, mountpoint);
3018 /* TestOutput for cp (0) */
3019 char expected[] = "file content";
3021 char path[] = "/old";
3022 char content[] = "file content";
3025 r = guestfs_write_file (g, path, content, 0);
3030 char src[] = "/old";
3031 char dest[] = "/new";
3034 r = guestfs_cp (g, src, dest);
3039 char path[] = "/new";
3042 r = guestfs_cat (g, path);
3045 if (strcmp (r, expected) != 0) {
3046 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
3054 static int test_cp_1_skip (void)
3058 str = getenv ("SKIP_TEST_CP_1");
3059 if (str && strcmp (str, "1") == 0) return 1;
3060 str = getenv ("SKIP_TEST_CP");
3061 if (str && strcmp (str, "1") == 0) return 1;
3065 static int test_cp_1 (void)
3067 if (test_cp_1_skip ()) {
3068 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
3072 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
3074 char device[] = "/dev/sda";
3077 r = guestfs_blockdev_setrw (g, device);
3084 r = guestfs_umount_all (g);
3091 r = guestfs_lvm_remove_all (g);
3096 char device[] = "/dev/sda";
3097 char lines_0[] = ",";
3104 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3109 char fstype[] = "ext2";
3110 char device[] = "/dev/sda1";
3113 r = guestfs_mkfs (g, fstype, device);
3118 char device[] = "/dev/sda1";
3119 char mountpoint[] = "/";
3122 r = guestfs_mount (g, device, mountpoint);
3126 /* TestOutputTrue for cp (1) */
3128 char path[] = "/old";
3129 char content[] = "file content";
3132 r = guestfs_write_file (g, path, content, 0);
3137 char src[] = "/old";
3138 char dest[] = "/new";
3141 r = guestfs_cp (g, src, dest);
3146 char path[] = "/old";
3149 r = guestfs_is_file (g, path);
3153 fprintf (stderr, "test_cp_1: expected true, got false\n");
3160 static int test_cp_2_skip (void)
3164 str = getenv ("SKIP_TEST_CP_2");
3165 if (str && strcmp (str, "1") == 0) return 1;
3166 str = getenv ("SKIP_TEST_CP");
3167 if (str && strcmp (str, "1") == 0) return 1;
3171 static int test_cp_2 (void)
3173 if (test_cp_2_skip ()) {
3174 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
3178 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
3180 char device[] = "/dev/sda";
3183 r = guestfs_blockdev_setrw (g, device);
3190 r = guestfs_umount_all (g);
3197 r = guestfs_lvm_remove_all (g);
3202 char device[] = "/dev/sda";
3203 char lines_0[] = ",";
3210 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3215 char fstype[] = "ext2";
3216 char device[] = "/dev/sda1";
3219 r = guestfs_mkfs (g, fstype, device);
3224 char device[] = "/dev/sda1";
3225 char mountpoint[] = "/";
3228 r = guestfs_mount (g, device, mountpoint);
3232 /* TestOutput for cp (2) */
3233 char expected[] = "file content";
3235 char path[] = "/old";
3236 char content[] = "file content";
3239 r = guestfs_write_file (g, path, content, 0);
3244 char path[] = "/dir";
3247 r = guestfs_mkdir (g, path);
3252 char src[] = "/old";
3253 char dest[] = "/dir/new";
3256 r = guestfs_cp (g, src, dest);
3261 char path[] = "/dir/new";
3264 r = guestfs_cat (g, path);
3267 if (strcmp (r, expected) != 0) {
3268 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3276 static int test_grub_install_0_skip (void)
3280 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3281 if (str && strcmp (str, "1") == 0) return 1;
3282 str = getenv ("SKIP_TEST_GRUB_INSTALL");
3283 if (str && strcmp (str, "1") == 0) return 1;
3287 static int test_grub_install_0 (void)
3289 if (test_grub_install_0_skip ()) {
3290 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3294 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3296 char device[] = "/dev/sda";
3299 r = guestfs_blockdev_setrw (g, device);
3306 r = guestfs_umount_all (g);
3313 r = guestfs_lvm_remove_all (g);
3318 char device[] = "/dev/sda";
3319 char lines_0[] = ",";
3326 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3331 char fstype[] = "ext2";
3332 char device[] = "/dev/sda1";
3335 r = guestfs_mkfs (g, fstype, device);
3340 char device[] = "/dev/sda1";
3341 char mountpoint[] = "/";
3344 r = guestfs_mount (g, device, mountpoint);
3348 /* TestOutputTrue for grub_install (0) */
3351 char device[] = "/dev/sda1";
3354 r = guestfs_grub_install (g, root, device);
3359 char path[] = "/boot";
3362 r = guestfs_is_dir (g, path);
3366 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3373 static int test_zero_0_skip (void)
3377 str = getenv ("SKIP_TEST_ZERO_0");
3378 if (str && strcmp (str, "1") == 0) return 1;
3379 str = getenv ("SKIP_TEST_ZERO");
3380 if (str && strcmp (str, "1") == 0) return 1;
3384 static int test_zero_0 (void)
3386 if (test_zero_0_skip ()) {
3387 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3391 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3393 char device[] = "/dev/sda";
3396 r = guestfs_blockdev_setrw (g, device);
3403 r = guestfs_umount_all (g);
3410 r = guestfs_lvm_remove_all (g);
3415 char device[] = "/dev/sda";
3416 char lines_0[] = ",";
3423 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3428 char fstype[] = "ext2";
3429 char device[] = "/dev/sda1";
3432 r = guestfs_mkfs (g, fstype, device);
3437 char device[] = "/dev/sda1";
3438 char mountpoint[] = "/";
3441 r = guestfs_mount (g, device, mountpoint);
3445 /* TestOutput for zero (0) */
3446 char expected[] = "data";
3448 char pathordevice[] = "/dev/sda1";
3451 r = guestfs_umount (g, pathordevice);
3456 char device[] = "/dev/sda1";
3459 r = guestfs_zero (g, device);
3464 char path[] = "/dev/sda1";
3467 r = guestfs_file (g, path);
3470 if (strcmp (r, expected) != 0) {
3471 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3479 static int test_fsck_0_skip (void)
3483 str = getenv ("SKIP_TEST_FSCK_0");
3484 if (str && strcmp (str, "1") == 0) return 1;
3485 str = getenv ("SKIP_TEST_FSCK");
3486 if (str && strcmp (str, "1") == 0) return 1;
3490 static int test_fsck_0 (void)
3492 if (test_fsck_0_skip ()) {
3493 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3497 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3499 char device[] = "/dev/sda";
3502 r = guestfs_blockdev_setrw (g, device);
3509 r = guestfs_umount_all (g);
3516 r = guestfs_lvm_remove_all (g);
3521 char device[] = "/dev/sda";
3522 char lines_0[] = ",";
3529 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3534 char fstype[] = "ext2";
3535 char device[] = "/dev/sda1";
3538 r = guestfs_mkfs (g, fstype, device);
3543 char device[] = "/dev/sda1";
3544 char mountpoint[] = "/";
3547 r = guestfs_mount (g, device, mountpoint);
3551 /* TestOutputInt for fsck (0) */
3553 char pathordevice[] = "/dev/sda1";
3556 r = guestfs_umount (g, pathordevice);
3561 char fstype[] = "ext2";
3562 char device[] = "/dev/sda1";
3565 r = guestfs_fsck (g, fstype, device);
3569 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
3576 static int test_fsck_1_skip (void)
3580 str = getenv ("SKIP_TEST_FSCK_1");
3581 if (str && strcmp (str, "1") == 0) return 1;
3582 str = getenv ("SKIP_TEST_FSCK");
3583 if (str && strcmp (str, "1") == 0) return 1;
3587 static int test_fsck_1 (void)
3589 if (test_fsck_1_skip ()) {
3590 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3594 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3596 char device[] = "/dev/sda";
3599 r = guestfs_blockdev_setrw (g, device);
3606 r = guestfs_umount_all (g);
3613 r = guestfs_lvm_remove_all (g);
3618 char device[] = "/dev/sda";
3619 char lines_0[] = ",";
3626 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3631 char fstype[] = "ext2";
3632 char device[] = "/dev/sda1";
3635 r = guestfs_mkfs (g, fstype, device);
3640 char device[] = "/dev/sda1";
3641 char mountpoint[] = "/";
3644 r = guestfs_mount (g, device, mountpoint);
3648 /* TestOutputInt for fsck (1) */
3650 char pathordevice[] = "/dev/sda1";
3653 r = guestfs_umount (g, pathordevice);
3658 char device[] = "/dev/sda1";
3661 r = guestfs_zero (g, device);
3666 char fstype[] = "ext2";
3667 char device[] = "/dev/sda1";
3670 r = guestfs_fsck (g, fstype, device);
3674 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
3681 static int test_set_e2uuid_0_skip (void)
3685 str = getenv ("SKIP_TEST_SET_E2UUID_0");
3686 if (str && strcmp (str, "1") == 0) return 1;
3687 str = getenv ("SKIP_TEST_SET_E2UUID");
3688 if (str && strcmp (str, "1") == 0) return 1;
3692 static int test_set_e2uuid_0 (void)
3694 if (test_set_e2uuid_0_skip ()) {
3695 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3699 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3701 char device[] = "/dev/sda";
3704 r = guestfs_blockdev_setrw (g, device);
3711 r = guestfs_umount_all (g);
3718 r = guestfs_lvm_remove_all (g);
3723 char device[] = "/dev/sda";
3724 char lines_0[] = ",";
3731 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3736 char fstype[] = "ext2";
3737 char device[] = "/dev/sda1";
3740 r = guestfs_mkfs (g, fstype, device);
3745 char device[] = "/dev/sda1";
3746 char mountpoint[] = "/";
3749 r = guestfs_mount (g, device, mountpoint);
3753 /* TestOutput for set_e2uuid (0) */
3754 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3756 char device[] = "/dev/sda1";
3757 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3760 r = guestfs_set_e2uuid (g, device, uuid);
3765 char device[] = "/dev/sda1";
3768 r = guestfs_get_e2uuid (g, device);
3771 if (strcmp (r, expected) != 0) {
3772 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3780 static int test_set_e2uuid_1_skip (void)
3784 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3785 if (str && strcmp (str, "1") == 0) return 1;
3786 str = getenv ("SKIP_TEST_SET_E2UUID");
3787 if (str && strcmp (str, "1") == 0) return 1;
3791 static int test_set_e2uuid_1 (void)
3793 if (test_set_e2uuid_1_skip ()) {
3794 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3798 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3800 char device[] = "/dev/sda";
3803 r = guestfs_blockdev_setrw (g, device);
3810 r = guestfs_umount_all (g);
3817 r = guestfs_lvm_remove_all (g);
3822 char device[] = "/dev/sda";
3823 char lines_0[] = ",";
3830 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3835 char fstype[] = "ext2";
3836 char device[] = "/dev/sda1";
3839 r = guestfs_mkfs (g, fstype, device);
3844 char device[] = "/dev/sda1";
3845 char mountpoint[] = "/";
3848 r = guestfs_mount (g, device, mountpoint);
3852 /* TestOutput for set_e2uuid (1) */
3853 char expected[] = "";
3855 char device[] = "/dev/sda1";
3856 char uuid[] = "clear";
3859 r = guestfs_set_e2uuid (g, device, uuid);
3864 char device[] = "/dev/sda1";
3867 r = guestfs_get_e2uuid (g, device);
3870 if (strcmp (r, expected) != 0) {
3871 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3879 static int test_set_e2uuid_2_skip (void)
3883 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3884 if (str && strcmp (str, "1") == 0) return 1;
3885 str = getenv ("SKIP_TEST_SET_E2UUID");
3886 if (str && strcmp (str, "1") == 0) return 1;
3890 static int test_set_e2uuid_2 (void)
3892 if (test_set_e2uuid_2_skip ()) {
3893 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3897 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3899 char device[] = "/dev/sda";
3902 r = guestfs_blockdev_setrw (g, device);
3909 r = guestfs_umount_all (g);
3916 r = guestfs_lvm_remove_all (g);
3921 char device[] = "/dev/sda";
3922 char lines_0[] = ",";
3929 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3934 char fstype[] = "ext2";
3935 char device[] = "/dev/sda1";
3938 r = guestfs_mkfs (g, fstype, device);
3943 char device[] = "/dev/sda1";
3944 char mountpoint[] = "/";
3947 r = guestfs_mount (g, device, mountpoint);
3951 /* TestRun for set_e2uuid (2) */
3953 char device[] = "/dev/sda1";
3954 char uuid[] = "random";
3957 r = guestfs_set_e2uuid (g, device, uuid);
3964 static int test_set_e2uuid_3_skip (void)
3968 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3969 if (str && strcmp (str, "1") == 0) return 1;
3970 str = getenv ("SKIP_TEST_SET_E2UUID");
3971 if (str && strcmp (str, "1") == 0) return 1;
3975 static int test_set_e2uuid_3 (void)
3977 if (test_set_e2uuid_3_skip ()) {
3978 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3982 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3984 char device[] = "/dev/sda";
3987 r = guestfs_blockdev_setrw (g, device);
3994 r = guestfs_umount_all (g);
4001 r = guestfs_lvm_remove_all (g);
4006 char device[] = "/dev/sda";
4007 char lines_0[] = ",";
4014 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4019 char fstype[] = "ext2";
4020 char device[] = "/dev/sda1";
4023 r = guestfs_mkfs (g, fstype, device);
4028 char device[] = "/dev/sda1";
4029 char mountpoint[] = "/";
4032 r = guestfs_mount (g, device, mountpoint);
4036 /* TestRun for set_e2uuid (3) */
4038 char device[] = "/dev/sda1";
4039 char uuid[] = "time";
4042 r = guestfs_set_e2uuid (g, device, uuid);
4049 static int test_set_e2label_0_skip (void)
4053 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
4054 if (str && strcmp (str, "1") == 0) return 1;
4055 str = getenv ("SKIP_TEST_SET_E2LABEL");
4056 if (str && strcmp (str, "1") == 0) return 1;
4060 static int test_set_e2label_0 (void)
4062 if (test_set_e2label_0_skip ()) {
4063 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
4067 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
4069 char device[] = "/dev/sda";
4072 r = guestfs_blockdev_setrw (g, device);
4079 r = guestfs_umount_all (g);
4086 r = guestfs_lvm_remove_all (g);
4091 char device[] = "/dev/sda";
4092 char lines_0[] = ",";
4099 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4104 char fstype[] = "ext2";
4105 char device[] = "/dev/sda1";
4108 r = guestfs_mkfs (g, fstype, device);
4113 char device[] = "/dev/sda1";
4114 char mountpoint[] = "/";
4117 r = guestfs_mount (g, device, mountpoint);
4121 /* TestOutput for set_e2label (0) */
4122 char expected[] = "testlabel";
4124 char device[] = "/dev/sda1";
4125 char label[] = "testlabel";
4128 r = guestfs_set_e2label (g, device, label);
4133 char device[] = "/dev/sda1";
4136 r = guestfs_get_e2label (g, device);
4139 if (strcmp (r, expected) != 0) {
4140 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
4148 static int test_pvremove_0_skip (void)
4152 str = getenv ("SKIP_TEST_PVREMOVE_0");
4153 if (str && strcmp (str, "1") == 0) return 1;
4154 str = getenv ("SKIP_TEST_PVREMOVE");
4155 if (str && strcmp (str, "1") == 0) return 1;
4159 static int test_pvremove_0 (void)
4161 if (test_pvremove_0_skip ()) {
4162 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
4166 /* InitNone|InitEmpty for test_pvremove_0 */
4168 char device[] = "/dev/sda";
4171 r = guestfs_blockdev_setrw (g, device);
4178 r = guestfs_umount_all (g);
4185 r = guestfs_lvm_remove_all (g);
4189 /* TestOutputListOfDevices for pvremove (0) */
4191 char device[] = "/dev/sda";
4192 char lines_0[] = ",";
4199 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4204 char device[] = "/dev/sda1";
4207 r = guestfs_pvcreate (g, device);
4212 char volgroup[] = "VG";
4213 char physvols_0[] = "/dev/sda1";
4214 char *physvols[] = {
4220 r = guestfs_vgcreate (g, volgroup, physvols);
4225 char logvol[] = "LV1";
4226 char volgroup[] = "VG";
4229 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4234 char logvol[] = "LV2";
4235 char volgroup[] = "VG";
4238 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4243 char vgname[] = "VG";
4246 r = guestfs_vgremove (g, vgname);
4251 char device[] = "/dev/sda1";
4254 r = guestfs_pvremove (g, device);
4262 r = guestfs_lvs (g);
4266 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4270 for (i = 0; r[i] != NULL; ++i)
4277 static int test_pvremove_1_skip (void)
4281 str = getenv ("SKIP_TEST_PVREMOVE_1");
4282 if (str && strcmp (str, "1") == 0) return 1;
4283 str = getenv ("SKIP_TEST_PVREMOVE");
4284 if (str && strcmp (str, "1") == 0) return 1;
4288 static int test_pvremove_1 (void)
4290 if (test_pvremove_1_skip ()) {
4291 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
4295 /* InitNone|InitEmpty for test_pvremove_1 */
4297 char device[] = "/dev/sda";
4300 r = guestfs_blockdev_setrw (g, device);
4307 r = guestfs_umount_all (g);
4314 r = guestfs_lvm_remove_all (g);
4318 /* TestOutputListOfDevices for pvremove (1) */
4320 char device[] = "/dev/sda";
4321 char lines_0[] = ",";
4328 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4333 char device[] = "/dev/sda1";
4336 r = guestfs_pvcreate (g, device);
4341 char volgroup[] = "VG";
4342 char physvols_0[] = "/dev/sda1";
4343 char *physvols[] = {
4349 r = guestfs_vgcreate (g, volgroup, physvols);
4354 char logvol[] = "LV1";
4355 char volgroup[] = "VG";
4358 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4363 char logvol[] = "LV2";
4364 char volgroup[] = "VG";
4367 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4372 char vgname[] = "VG";
4375 r = guestfs_vgremove (g, vgname);
4380 char device[] = "/dev/sda1";
4383 r = guestfs_pvremove (g, device);
4391 r = guestfs_vgs (g);
4395 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4399 for (i = 0; r[i] != NULL; ++i)
4406 static int test_pvremove_2_skip (void)
4410 str = getenv ("SKIP_TEST_PVREMOVE_2");
4411 if (str && strcmp (str, "1") == 0) return 1;
4412 str = getenv ("SKIP_TEST_PVREMOVE");
4413 if (str && strcmp (str, "1") == 0) return 1;
4417 static int test_pvremove_2 (void)
4419 if (test_pvremove_2_skip ()) {
4420 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
4424 /* InitNone|InitEmpty for test_pvremove_2 */
4426 char device[] = "/dev/sda";
4429 r = guestfs_blockdev_setrw (g, device);
4436 r = guestfs_umount_all (g);
4443 r = guestfs_lvm_remove_all (g);
4447 /* TestOutputListOfDevices for pvremove (2) */
4449 char device[] = "/dev/sda";
4450 char lines_0[] = ",";
4457 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4462 char device[] = "/dev/sda1";
4465 r = guestfs_pvcreate (g, device);
4470 char volgroup[] = "VG";
4471 char physvols_0[] = "/dev/sda1";
4472 char *physvols[] = {
4478 r = guestfs_vgcreate (g, volgroup, physvols);
4483 char logvol[] = "LV1";
4484 char volgroup[] = "VG";
4487 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4492 char logvol[] = "LV2";
4493 char volgroup[] = "VG";
4496 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4501 char vgname[] = "VG";
4504 r = guestfs_vgremove (g, vgname);
4509 char device[] = "/dev/sda1";
4512 r = guestfs_pvremove (g, device);
4520 r = guestfs_pvs (g);
4524 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4528 for (i = 0; r[i] != NULL; ++i)
4535 static int test_vgremove_0_skip (void)
4539 str = getenv ("SKIP_TEST_VGREMOVE_0");
4540 if (str && strcmp (str, "1") == 0) return 1;
4541 str = getenv ("SKIP_TEST_VGREMOVE");
4542 if (str && strcmp (str, "1") == 0) return 1;
4546 static int test_vgremove_0 (void)
4548 if (test_vgremove_0_skip ()) {
4549 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4553 /* InitNone|InitEmpty for test_vgremove_0 */
4555 char device[] = "/dev/sda";
4558 r = guestfs_blockdev_setrw (g, device);
4565 r = guestfs_umount_all (g);
4572 r = guestfs_lvm_remove_all (g);
4576 /* TestOutputList for vgremove (0) */
4578 char device[] = "/dev/sda";
4579 char lines_0[] = ",";
4586 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4591 char device[] = "/dev/sda1";
4594 r = guestfs_pvcreate (g, device);
4599 char volgroup[] = "VG";
4600 char physvols_0[] = "/dev/sda1";
4601 char *physvols[] = {
4607 r = guestfs_vgcreate (g, volgroup, physvols);
4612 char logvol[] = "LV1";
4613 char volgroup[] = "VG";
4616 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4621 char logvol[] = "LV2";
4622 char volgroup[] = "VG";
4625 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4630 char vgname[] = "VG";
4633 r = guestfs_vgremove (g, vgname);
4641 r = guestfs_lvs (g);
4645 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4649 for (i = 0; r[i] != NULL; ++i)
4656 static int test_vgremove_1_skip (void)
4660 str = getenv ("SKIP_TEST_VGREMOVE_1");
4661 if (str && strcmp (str, "1") == 0) return 1;
4662 str = getenv ("SKIP_TEST_VGREMOVE");
4663 if (str && strcmp (str, "1") == 0) return 1;
4667 static int test_vgremove_1 (void)
4669 if (test_vgremove_1_skip ()) {
4670 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4674 /* InitNone|InitEmpty for test_vgremove_1 */
4676 char device[] = "/dev/sda";
4679 r = guestfs_blockdev_setrw (g, device);
4686 r = guestfs_umount_all (g);
4693 r = guestfs_lvm_remove_all (g);
4697 /* TestOutputList for vgremove (1) */
4699 char device[] = "/dev/sda";
4700 char lines_0[] = ",";
4707 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4712 char device[] = "/dev/sda1";
4715 r = guestfs_pvcreate (g, device);
4720 char volgroup[] = "VG";
4721 char physvols_0[] = "/dev/sda1";
4722 char *physvols[] = {
4728 r = guestfs_vgcreate (g, volgroup, physvols);
4733 char logvol[] = "LV1";
4734 char volgroup[] = "VG";
4737 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4742 char logvol[] = "LV2";
4743 char volgroup[] = "VG";
4746 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4751 char vgname[] = "VG";
4754 r = guestfs_vgremove (g, vgname);
4762 r = guestfs_vgs (g);
4766 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4770 for (i = 0; r[i] != NULL; ++i)
4777 static int test_lvremove_0_skip (void)
4781 str = getenv ("SKIP_TEST_LVREMOVE_0");
4782 if (str && strcmp (str, "1") == 0) return 1;
4783 str = getenv ("SKIP_TEST_LVREMOVE");
4784 if (str && strcmp (str, "1") == 0) return 1;
4788 static int test_lvremove_0 (void)
4790 if (test_lvremove_0_skip ()) {
4791 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4795 /* InitNone|InitEmpty for test_lvremove_0 */
4797 char device[] = "/dev/sda";
4800 r = guestfs_blockdev_setrw (g, device);
4807 r = guestfs_umount_all (g);
4814 r = guestfs_lvm_remove_all (g);
4818 /* TestOutputList for lvremove (0) */
4820 char device[] = "/dev/sda";
4821 char lines_0[] = ",";
4828 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4833 char device[] = "/dev/sda1";
4836 r = guestfs_pvcreate (g, device);
4841 char volgroup[] = "VG";
4842 char physvols_0[] = "/dev/sda1";
4843 char *physvols[] = {
4849 r = guestfs_vgcreate (g, volgroup, physvols);
4854 char logvol[] = "LV1";
4855 char volgroup[] = "VG";
4858 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4863 char logvol[] = "LV2";
4864 char volgroup[] = "VG";
4867 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4872 char device[] = "/dev/VG/LV1";
4875 r = guestfs_lvremove (g, device);
4883 r = guestfs_lvs (g);
4887 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4892 char expected[] = "/dev/VG/LV2";
4893 if (strcmp (r[0], expected) != 0) {
4894 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4899 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4903 for (i = 0; r[i] != NULL; ++i)
4910 static int test_lvremove_1_skip (void)
4914 str = getenv ("SKIP_TEST_LVREMOVE_1");
4915 if (str && strcmp (str, "1") == 0) return 1;
4916 str = getenv ("SKIP_TEST_LVREMOVE");
4917 if (str && strcmp (str, "1") == 0) return 1;
4921 static int test_lvremove_1 (void)
4923 if (test_lvremove_1_skip ()) {
4924 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4928 /* InitNone|InitEmpty for test_lvremove_1 */
4930 char device[] = "/dev/sda";
4933 r = guestfs_blockdev_setrw (g, device);
4940 r = guestfs_umount_all (g);
4947 r = guestfs_lvm_remove_all (g);
4951 /* TestOutputList for lvremove (1) */
4953 char device[] = "/dev/sda";
4954 char lines_0[] = ",";
4961 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4966 char device[] = "/dev/sda1";
4969 r = guestfs_pvcreate (g, device);
4974 char volgroup[] = "VG";
4975 char physvols_0[] = "/dev/sda1";
4976 char *physvols[] = {
4982 r = guestfs_vgcreate (g, volgroup, physvols);
4987 char logvol[] = "LV1";
4988 char volgroup[] = "VG";
4991 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4996 char logvol[] = "LV2";
4997 char volgroup[] = "VG";
5000 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5005 char device[] = "/dev/VG";
5008 r = guestfs_lvremove (g, device);
5016 r = guestfs_lvs (g);
5020 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
5024 for (i = 0; r[i] != NULL; ++i)
5031 static int test_lvremove_2_skip (void)
5035 str = getenv ("SKIP_TEST_LVREMOVE_2");
5036 if (str && strcmp (str, "1") == 0) return 1;
5037 str = getenv ("SKIP_TEST_LVREMOVE");
5038 if (str && strcmp (str, "1") == 0) return 1;
5042 static int test_lvremove_2 (void)
5044 if (test_lvremove_2_skip ()) {
5045 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
5049 /* InitNone|InitEmpty for test_lvremove_2 */
5051 char device[] = "/dev/sda";
5054 r = guestfs_blockdev_setrw (g, device);
5061 r = guestfs_umount_all (g);
5068 r = guestfs_lvm_remove_all (g);
5072 /* TestOutputList for lvremove (2) */
5074 char device[] = "/dev/sda";
5075 char lines_0[] = ",";
5082 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5087 char device[] = "/dev/sda1";
5090 r = guestfs_pvcreate (g, device);
5095 char volgroup[] = "VG";
5096 char physvols_0[] = "/dev/sda1";
5097 char *physvols[] = {
5103 r = guestfs_vgcreate (g, volgroup, physvols);
5108 char logvol[] = "LV1";
5109 char volgroup[] = "VG";
5112 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5117 char logvol[] = "LV2";
5118 char volgroup[] = "VG";
5121 r = guestfs_lvcreate (g, logvol, volgroup, 50);
5126 char device[] = "/dev/VG";
5129 r = guestfs_lvremove (g, device);
5137 r = guestfs_vgs (g);
5141 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
5146 char expected[] = "VG";
5147 if (strcmp (r[0], expected) != 0) {
5148 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
5153 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
5157 for (i = 0; r[i] != NULL; ++i)
5164 static int test_mount_ro_0_skip (void)
5168 str = getenv ("SKIP_TEST_MOUNT_RO_0");
5169 if (str && strcmp (str, "1") == 0) return 1;
5170 str = getenv ("SKIP_TEST_MOUNT_RO");
5171 if (str && strcmp (str, "1") == 0) return 1;
5175 static int test_mount_ro_0 (void)
5177 if (test_mount_ro_0_skip ()) {
5178 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
5182 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
5184 char device[] = "/dev/sda";
5187 r = guestfs_blockdev_setrw (g, device);
5194 r = guestfs_umount_all (g);
5201 r = guestfs_lvm_remove_all (g);
5206 char device[] = "/dev/sda";
5207 char lines_0[] = ",";
5214 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5219 char fstype[] = "ext2";
5220 char device[] = "/dev/sda1";
5223 r = guestfs_mkfs (g, fstype, device);
5228 char device[] = "/dev/sda1";
5229 char mountpoint[] = "/";
5232 r = guestfs_mount (g, device, mountpoint);
5236 /* TestLastFail for mount_ro (0) */
5238 char pathordevice[] = "/";
5241 r = guestfs_umount (g, pathordevice);
5246 char device[] = "/dev/sda1";
5247 char mountpoint[] = "/";
5250 r = guestfs_mount_ro (g, device, mountpoint);
5255 char path[] = "/new";
5258 r = guestfs_touch (g, path);
5265 static int test_mount_ro_1_skip (void)
5269 str = getenv ("SKIP_TEST_MOUNT_RO_1");
5270 if (str && strcmp (str, "1") == 0) return 1;
5271 str = getenv ("SKIP_TEST_MOUNT_RO");
5272 if (str && strcmp (str, "1") == 0) return 1;
5276 static int test_mount_ro_1 (void)
5278 if (test_mount_ro_1_skip ()) {
5279 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5283 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5285 char device[] = "/dev/sda";
5288 r = guestfs_blockdev_setrw (g, device);
5295 r = guestfs_umount_all (g);
5302 r = guestfs_lvm_remove_all (g);
5307 char device[] = "/dev/sda";
5308 char lines_0[] = ",";
5315 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5320 char fstype[] = "ext2";
5321 char device[] = "/dev/sda1";
5324 r = guestfs_mkfs (g, fstype, device);
5329 char device[] = "/dev/sda1";
5330 char mountpoint[] = "/";
5333 r = guestfs_mount (g, device, mountpoint);
5337 /* TestOutput for mount_ro (1) */
5338 char expected[] = "data";
5340 char path[] = "/new";
5341 char content[] = "data";
5344 r = guestfs_write_file (g, path, content, 0);
5349 char pathordevice[] = "/";
5352 r = guestfs_umount (g, pathordevice);
5357 char device[] = "/dev/sda1";
5358 char mountpoint[] = "/";
5361 r = guestfs_mount_ro (g, device, mountpoint);
5366 char path[] = "/new";
5369 r = guestfs_cat (g, path);
5372 if (strcmp (r, expected) != 0) {
5373 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5381 static int test_tgz_in_0_skip (void)
5385 str = getenv ("SKIP_TEST_TGZ_IN_0");
5386 if (str && strcmp (str, "1") == 0) return 1;
5387 str = getenv ("SKIP_TEST_TGZ_IN");
5388 if (str && strcmp (str, "1") == 0) return 1;
5392 static int test_tgz_in_0 (void)
5394 if (test_tgz_in_0_skip ()) {
5395 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5399 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5401 char device[] = "/dev/sda";
5404 r = guestfs_blockdev_setrw (g, device);
5411 r = guestfs_umount_all (g);
5418 r = guestfs_lvm_remove_all (g);
5423 char device[] = "/dev/sda";
5424 char lines_0[] = ",";
5431 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5436 char fstype[] = "ext2";
5437 char device[] = "/dev/sda1";
5440 r = guestfs_mkfs (g, fstype, device);
5445 char device[] = "/dev/sda1";
5446 char mountpoint[] = "/";
5449 r = guestfs_mount (g, device, mountpoint);
5453 /* TestOutput for tgz_in (0) */
5454 char expected[] = "hello\n";
5456 char directory[] = "/";
5459 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5464 char path[] = "/hello";
5467 r = guestfs_cat (g, path);
5470 if (strcmp (r, expected) != 0) {
5471 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5479 static int test_tar_in_0_skip (void)
5483 str = getenv ("SKIP_TEST_TAR_IN_0");
5484 if (str && strcmp (str, "1") == 0) return 1;
5485 str = getenv ("SKIP_TEST_TAR_IN");
5486 if (str && strcmp (str, "1") == 0) return 1;
5490 static int test_tar_in_0 (void)
5492 if (test_tar_in_0_skip ()) {
5493 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5497 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5499 char device[] = "/dev/sda";
5502 r = guestfs_blockdev_setrw (g, device);
5509 r = guestfs_umount_all (g);
5516 r = guestfs_lvm_remove_all (g);
5521 char device[] = "/dev/sda";
5522 char lines_0[] = ",";
5529 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5534 char fstype[] = "ext2";
5535 char device[] = "/dev/sda1";
5538 r = guestfs_mkfs (g, fstype, device);
5543 char device[] = "/dev/sda1";
5544 char mountpoint[] = "/";
5547 r = guestfs_mount (g, device, mountpoint);
5551 /* TestOutput for tar_in (0) */
5552 char expected[] = "hello\n";
5554 char directory[] = "/";
5557 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5562 char path[] = "/hello";
5565 r = guestfs_cat (g, path);
5568 if (strcmp (r, expected) != 0) {
5569 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5577 static int test_checksum_0_skip (void)
5581 str = getenv ("SKIP_TEST_CHECKSUM_0");
5582 if (str && strcmp (str, "1") == 0) return 1;
5583 str = getenv ("SKIP_TEST_CHECKSUM");
5584 if (str && strcmp (str, "1") == 0) return 1;
5588 static int test_checksum_0 (void)
5590 if (test_checksum_0_skip ()) {
5591 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5595 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5597 char device[] = "/dev/sda";
5600 r = guestfs_blockdev_setrw (g, device);
5607 r = guestfs_umount_all (g);
5614 r = guestfs_lvm_remove_all (g);
5619 char device[] = "/dev/sda";
5620 char lines_0[] = ",";
5627 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5632 char fstype[] = "ext2";
5633 char device[] = "/dev/sda1";
5636 r = guestfs_mkfs (g, fstype, device);
5641 char device[] = "/dev/sda1";
5642 char mountpoint[] = "/";
5645 r = guestfs_mount (g, device, mountpoint);
5649 /* TestOutput for checksum (0) */
5650 char expected[] = "935282863";
5652 char path[] = "/new";
5653 char content[] = "test\n";
5656 r = guestfs_write_file (g, path, content, 0);
5661 char csumtype[] = "crc";
5662 char path[] = "/new";
5665 r = guestfs_checksum (g, csumtype, path);
5668 if (strcmp (r, expected) != 0) {
5669 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5677 static int test_checksum_1_skip (void)
5681 str = getenv ("SKIP_TEST_CHECKSUM_1");
5682 if (str && strcmp (str, "1") == 0) return 1;
5683 str = getenv ("SKIP_TEST_CHECKSUM");
5684 if (str && strcmp (str, "1") == 0) return 1;
5688 static int test_checksum_1 (void)
5690 if (test_checksum_1_skip ()) {
5691 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5695 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5697 char device[] = "/dev/sda";
5700 r = guestfs_blockdev_setrw (g, device);
5707 r = guestfs_umount_all (g);
5714 r = guestfs_lvm_remove_all (g);
5719 char device[] = "/dev/sda";
5720 char lines_0[] = ",";
5727 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5732 char fstype[] = "ext2";
5733 char device[] = "/dev/sda1";
5736 r = guestfs_mkfs (g, fstype, device);
5741 char device[] = "/dev/sda1";
5742 char mountpoint[] = "/";
5745 r = guestfs_mount (g, device, mountpoint);
5749 /* TestLastFail for checksum (1) */
5751 char csumtype[] = "crc";
5752 char path[] = "/new";
5755 r = guestfs_checksum (g, csumtype, path);
5763 static int test_checksum_2_skip (void)
5767 str = getenv ("SKIP_TEST_CHECKSUM_2");
5768 if (str && strcmp (str, "1") == 0) return 1;
5769 str = getenv ("SKIP_TEST_CHECKSUM");
5770 if (str && strcmp (str, "1") == 0) return 1;
5774 static int test_checksum_2 (void)
5776 if (test_checksum_2_skip ()) {
5777 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5781 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5783 char device[] = "/dev/sda";
5786 r = guestfs_blockdev_setrw (g, device);
5793 r = guestfs_umount_all (g);
5800 r = guestfs_lvm_remove_all (g);
5805 char device[] = "/dev/sda";
5806 char lines_0[] = ",";
5813 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5818 char fstype[] = "ext2";
5819 char device[] = "/dev/sda1";
5822 r = guestfs_mkfs (g, fstype, device);
5827 char device[] = "/dev/sda1";
5828 char mountpoint[] = "/";
5831 r = guestfs_mount (g, device, mountpoint);
5835 /* TestOutput for checksum (2) */
5836 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5838 char path[] = "/new";
5839 char content[] = "test\n";
5842 r = guestfs_write_file (g, path, content, 0);
5847 char csumtype[] = "md5";
5848 char path[] = "/new";
5851 r = guestfs_checksum (g, csumtype, path);
5854 if (strcmp (r, expected) != 0) {
5855 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5863 static int test_checksum_3_skip (void)
5867 str = getenv ("SKIP_TEST_CHECKSUM_3");
5868 if (str && strcmp (str, "1") == 0) return 1;
5869 str = getenv ("SKIP_TEST_CHECKSUM");
5870 if (str && strcmp (str, "1") == 0) return 1;
5874 static int test_checksum_3 (void)
5876 if (test_checksum_3_skip ()) {
5877 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5881 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5883 char device[] = "/dev/sda";
5886 r = guestfs_blockdev_setrw (g, device);
5893 r = guestfs_umount_all (g);
5900 r = guestfs_lvm_remove_all (g);
5905 char device[] = "/dev/sda";
5906 char lines_0[] = ",";
5913 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5918 char fstype[] = "ext2";
5919 char device[] = "/dev/sda1";
5922 r = guestfs_mkfs (g, fstype, device);
5927 char device[] = "/dev/sda1";
5928 char mountpoint[] = "/";
5931 r = guestfs_mount (g, device, mountpoint);
5935 /* TestOutput for checksum (3) */
5936 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5938 char path[] = "/new";
5939 char content[] = "test\n";
5942 r = guestfs_write_file (g, path, content, 0);
5947 char csumtype[] = "sha1";
5948 char path[] = "/new";
5951 r = guestfs_checksum (g, csumtype, path);
5954 if (strcmp (r, expected) != 0) {
5955 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5963 static int test_checksum_4_skip (void)
5967 str = getenv ("SKIP_TEST_CHECKSUM_4");
5968 if (str && strcmp (str, "1") == 0) return 1;
5969 str = getenv ("SKIP_TEST_CHECKSUM");
5970 if (str && strcmp (str, "1") == 0) return 1;
5974 static int test_checksum_4 (void)
5976 if (test_checksum_4_skip ()) {
5977 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5981 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5983 char device[] = "/dev/sda";
5986 r = guestfs_blockdev_setrw (g, device);
5993 r = guestfs_umount_all (g);
6000 r = guestfs_lvm_remove_all (g);
6005 char device[] = "/dev/sda";
6006 char lines_0[] = ",";
6013 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6018 char fstype[] = "ext2";
6019 char device[] = "/dev/sda1";
6022 r = guestfs_mkfs (g, fstype, device);
6027 char device[] = "/dev/sda1";
6028 char mountpoint[] = "/";
6031 r = guestfs_mount (g, device, mountpoint);
6035 /* TestOutput for checksum (4) */
6036 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
6038 char path[] = "/new";
6039 char content[] = "test\n";
6042 r = guestfs_write_file (g, path, content, 0);
6047 char csumtype[] = "sha224";
6048 char path[] = "/new";
6051 r = guestfs_checksum (g, csumtype, path);
6054 if (strcmp (r, expected) != 0) {
6055 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
6063 static int test_checksum_5_skip (void)
6067 str = getenv ("SKIP_TEST_CHECKSUM_5");
6068 if (str && strcmp (str, "1") == 0) return 1;
6069 str = getenv ("SKIP_TEST_CHECKSUM");
6070 if (str && strcmp (str, "1") == 0) return 1;
6074 static int test_checksum_5 (void)
6076 if (test_checksum_5_skip ()) {
6077 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
6081 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
6083 char device[] = "/dev/sda";
6086 r = guestfs_blockdev_setrw (g, device);
6093 r = guestfs_umount_all (g);
6100 r = guestfs_lvm_remove_all (g);
6105 char device[] = "/dev/sda";
6106 char lines_0[] = ",";
6113 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6118 char fstype[] = "ext2";
6119 char device[] = "/dev/sda1";
6122 r = guestfs_mkfs (g, fstype, device);
6127 char device[] = "/dev/sda1";
6128 char mountpoint[] = "/";
6131 r = guestfs_mount (g, device, mountpoint);
6135 /* TestOutput for checksum (5) */
6136 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
6138 char path[] = "/new";
6139 char content[] = "test\n";
6142 r = guestfs_write_file (g, path, content, 0);
6147 char csumtype[] = "sha256";
6148 char path[] = "/new";
6151 r = guestfs_checksum (g, csumtype, path);
6154 if (strcmp (r, expected) != 0) {
6155 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
6163 static int test_checksum_6_skip (void)
6167 str = getenv ("SKIP_TEST_CHECKSUM_6");
6168 if (str && strcmp (str, "1") == 0) return 1;
6169 str = getenv ("SKIP_TEST_CHECKSUM");
6170 if (str && strcmp (str, "1") == 0) return 1;
6174 static int test_checksum_6 (void)
6176 if (test_checksum_6_skip ()) {
6177 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
6181 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
6183 char device[] = "/dev/sda";
6186 r = guestfs_blockdev_setrw (g, device);
6193 r = guestfs_umount_all (g);
6200 r = guestfs_lvm_remove_all (g);
6205 char device[] = "/dev/sda";
6206 char lines_0[] = ",";
6213 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6218 char fstype[] = "ext2";
6219 char device[] = "/dev/sda1";
6222 r = guestfs_mkfs (g, fstype, device);
6227 char device[] = "/dev/sda1";
6228 char mountpoint[] = "/";
6231 r = guestfs_mount (g, device, mountpoint);
6235 /* TestOutput for checksum (6) */
6236 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
6238 char path[] = "/new";
6239 char content[] = "test\n";
6242 r = guestfs_write_file (g, path, content, 0);
6247 char csumtype[] = "sha384";
6248 char path[] = "/new";
6251 r = guestfs_checksum (g, csumtype, path);
6254 if (strcmp (r, expected) != 0) {
6255 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6263 static int test_checksum_7_skip (void)
6267 str = getenv ("SKIP_TEST_CHECKSUM_7");
6268 if (str && strcmp (str, "1") == 0) return 1;
6269 str = getenv ("SKIP_TEST_CHECKSUM");
6270 if (str && strcmp (str, "1") == 0) return 1;
6274 static int test_checksum_7 (void)
6276 if (test_checksum_7_skip ()) {
6277 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6281 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6283 char device[] = "/dev/sda";
6286 r = guestfs_blockdev_setrw (g, device);
6293 r = guestfs_umount_all (g);
6300 r = guestfs_lvm_remove_all (g);
6305 char device[] = "/dev/sda";
6306 char lines_0[] = ",";
6313 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6318 char fstype[] = "ext2";
6319 char device[] = "/dev/sda1";
6322 r = guestfs_mkfs (g, fstype, device);
6327 char device[] = "/dev/sda1";
6328 char mountpoint[] = "/";
6331 r = guestfs_mount (g, device, mountpoint);
6335 /* TestOutput for checksum (7) */
6336 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6338 char path[] = "/new";
6339 char content[] = "test\n";
6342 r = guestfs_write_file (g, path, content, 0);
6347 char csumtype[] = "sha512";
6348 char path[] = "/new";
6351 r = guestfs_checksum (g, csumtype, path);
6354 if (strcmp (r, expected) != 0) {
6355 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6363 static int test_checksum_8_skip (void)
6367 str = getenv ("SKIP_TEST_CHECKSUM_8");
6368 if (str && strcmp (str, "1") == 0) return 1;
6369 str = getenv ("SKIP_TEST_CHECKSUM");
6370 if (str && strcmp (str, "1") == 0) return 1;
6374 static int test_checksum_8 (void)
6376 if (test_checksum_8_skip ()) {
6377 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6381 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6383 char device[] = "/dev/sda";
6386 r = guestfs_blockdev_setrw (g, device);
6393 r = guestfs_umount_all (g);
6400 r = guestfs_lvm_remove_all (g);
6405 char device[] = "/dev/sda";
6406 char lines_0[] = ",";
6413 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6418 char fstype[] = "ext2";
6419 char device[] = "/dev/sda1";
6422 r = guestfs_mkfs (g, fstype, device);
6427 char device[] = "/dev/sda1";
6428 char mountpoint[] = "/";
6431 r = guestfs_mount (g, device, mountpoint);
6435 /* TestOutput for checksum (8) */
6436 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6438 char options[] = "ro";
6439 char vfstype[] = "squashfs";
6440 char device[] = "/dev/sdd";
6441 char mountpoint[] = "/";
6444 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6449 char csumtype[] = "md5";
6450 char path[] = "/known-3";
6453 r = guestfs_checksum (g, csumtype, path);
6456 if (strcmp (r, expected) != 0) {
6457 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6465 static int test_download_0_skip (void)
6469 str = getenv ("SKIP_TEST_DOWNLOAD_0");
6470 if (str && strcmp (str, "1") == 0) return 1;
6471 str = getenv ("SKIP_TEST_DOWNLOAD");
6472 if (str && strcmp (str, "1") == 0) return 1;
6476 static int test_download_0 (void)
6478 if (test_download_0_skip ()) {
6479 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6483 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6485 char device[] = "/dev/sda";
6488 r = guestfs_blockdev_setrw (g, device);
6495 r = guestfs_umount_all (g);
6502 r = guestfs_lvm_remove_all (g);
6507 char device[] = "/dev/sda";
6508 char lines_0[] = ",";
6515 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6520 char fstype[] = "ext2";
6521 char device[] = "/dev/sda1";
6524 r = guestfs_mkfs (g, fstype, device);
6529 char device[] = "/dev/sda1";
6530 char mountpoint[] = "/";
6533 r = guestfs_mount (g, device, mountpoint);
6537 /* TestOutput for download (0) */
6538 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6540 char remotefilename[] = "/COPYING.LIB";
6543 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6548 char remotefilename[] = "/COPYING.LIB";
6551 r = guestfs_download (g, remotefilename, "testdownload.tmp");
6556 char remotefilename[] = "/upload";
6559 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6564 char csumtype[] = "md5";
6565 char path[] = "/upload";
6568 r = guestfs_checksum (g, csumtype, path);
6571 if (strcmp (r, expected) != 0) {
6572 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6580 static int test_upload_0_skip (void)
6584 str = getenv ("SKIP_TEST_UPLOAD_0");
6585 if (str && strcmp (str, "1") == 0) return 1;
6586 str = getenv ("SKIP_TEST_UPLOAD");
6587 if (str && strcmp (str, "1") == 0) return 1;
6591 static int test_upload_0 (void)
6593 if (test_upload_0_skip ()) {
6594 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6598 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6600 char device[] = "/dev/sda";
6603 r = guestfs_blockdev_setrw (g, device);
6610 r = guestfs_umount_all (g);
6617 r = guestfs_lvm_remove_all (g);
6622 char device[] = "/dev/sda";
6623 char lines_0[] = ",";
6630 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6635 char fstype[] = "ext2";
6636 char device[] = "/dev/sda1";
6639 r = guestfs_mkfs (g, fstype, device);
6644 char device[] = "/dev/sda1";
6645 char mountpoint[] = "/";
6648 r = guestfs_mount (g, device, mountpoint);
6652 /* TestOutput for upload (0) */
6653 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6655 char remotefilename[] = "/COPYING.LIB";
6658 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6663 char csumtype[] = "md5";
6664 char path[] = "/COPYING.LIB";
6667 r = guestfs_checksum (g, csumtype, path);
6670 if (strcmp (r, expected) != 0) {
6671 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6679 static int test_blockdev_rereadpt_0_skip (void)
6683 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6684 if (str && strcmp (str, "1") == 0) return 1;
6685 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6686 if (str && strcmp (str, "1") == 0) return 1;
6690 static int test_blockdev_rereadpt_0 (void)
6692 if (test_blockdev_rereadpt_0_skip ()) {
6693 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6697 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6699 char device[] = "/dev/sda";
6702 r = guestfs_blockdev_setrw (g, device);
6709 r = guestfs_umount_all (g);
6716 r = guestfs_lvm_remove_all (g);
6720 /* TestRun for blockdev_rereadpt (0) */
6722 char device[] = "/dev/sda";
6725 r = guestfs_blockdev_rereadpt (g, device);
6732 static int test_blockdev_flushbufs_0_skip (void)
6736 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6737 if (str && strcmp (str, "1") == 0) return 1;
6738 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6739 if (str && strcmp (str, "1") == 0) return 1;
6743 static int test_blockdev_flushbufs_0 (void)
6745 if (test_blockdev_flushbufs_0_skip ()) {
6746 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6750 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6752 char device[] = "/dev/sda";
6755 r = guestfs_blockdev_setrw (g, device);
6762 r = guestfs_umount_all (g);
6769 r = guestfs_lvm_remove_all (g);
6773 /* TestRun for blockdev_flushbufs (0) */
6775 char device[] = "/dev/sda";
6778 r = guestfs_blockdev_flushbufs (g, device);
6785 static int test_blockdev_getsize64_0_skip (void)
6789 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6790 if (str && strcmp (str, "1") == 0) return 1;
6791 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6792 if (str && strcmp (str, "1") == 0) return 1;
6796 static int test_blockdev_getsize64_0 (void)
6798 if (test_blockdev_getsize64_0_skip ()) {
6799 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6803 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6805 char device[] = "/dev/sda";
6808 r = guestfs_blockdev_setrw (g, device);
6815 r = guestfs_umount_all (g);
6822 r = guestfs_lvm_remove_all (g);
6826 /* TestOutputInt for blockdev_getsize64 (0) */
6828 char device[] = "/dev/sda";
6831 r = guestfs_blockdev_getsize64 (g, device);
6834 if (r != 524288000) {
6835 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6842 static int test_blockdev_getsz_0_skip (void)
6846 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6847 if (str && strcmp (str, "1") == 0) return 1;
6848 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6849 if (str && strcmp (str, "1") == 0) return 1;
6853 static int test_blockdev_getsz_0 (void)
6855 if (test_blockdev_getsz_0_skip ()) {
6856 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6860 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6862 char device[] = "/dev/sda";
6865 r = guestfs_blockdev_setrw (g, device);
6872 r = guestfs_umount_all (g);
6879 r = guestfs_lvm_remove_all (g);
6883 /* TestOutputInt for blockdev_getsz (0) */
6885 char device[] = "/dev/sda";
6888 r = guestfs_blockdev_getsz (g, device);
6892 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6899 static int test_blockdev_getbsz_0_skip (void)
6903 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6904 if (str && strcmp (str, "1") == 0) return 1;
6905 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6906 if (str && strcmp (str, "1") == 0) return 1;
6910 static int test_blockdev_getbsz_0 (void)
6912 if (test_blockdev_getbsz_0_skip ()) {
6913 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6917 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6919 char device[] = "/dev/sda";
6922 r = guestfs_blockdev_setrw (g, device);
6929 r = guestfs_umount_all (g);
6936 r = guestfs_lvm_remove_all (g);
6940 /* TestOutputInt for blockdev_getbsz (0) */
6942 char device[] = "/dev/sda";
6945 r = guestfs_blockdev_getbsz (g, device);
6949 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6956 static int test_blockdev_getss_0_skip (void)
6960 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6961 if (str && strcmp (str, "1") == 0) return 1;
6962 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6963 if (str && strcmp (str, "1") == 0) return 1;
6967 static int test_blockdev_getss_0 (void)
6969 if (test_blockdev_getss_0_skip ()) {
6970 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6974 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6976 char device[] = "/dev/sda";
6979 r = guestfs_blockdev_setrw (g, device);
6986 r = guestfs_umount_all (g);
6993 r = guestfs_lvm_remove_all (g);
6997 /* TestOutputInt for blockdev_getss (0) */
6999 char device[] = "/dev/sda";
7002 r = guestfs_blockdev_getss (g, device);
7006 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
7013 static int test_blockdev_getro_0_skip (void)
7017 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
7018 if (str && strcmp (str, "1") == 0) return 1;
7019 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
7020 if (str && strcmp (str, "1") == 0) return 1;
7024 static int test_blockdev_getro_0 (void)
7026 if (test_blockdev_getro_0_skip ()) {
7027 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
7031 /* InitNone|InitEmpty for test_blockdev_getro_0 */
7033 char device[] = "/dev/sda";
7036 r = guestfs_blockdev_setrw (g, device);
7043 r = guestfs_umount_all (g);
7050 r = guestfs_lvm_remove_all (g);
7054 /* TestOutputTrue for blockdev_getro (0) */
7056 char device[] = "/dev/sda";
7059 r = guestfs_blockdev_setro (g, device);
7064 char device[] = "/dev/sda";
7067 r = guestfs_blockdev_getro (g, device);
7071 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
7078 static int test_blockdev_setrw_0_skip (void)
7082 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
7083 if (str && strcmp (str, "1") == 0) return 1;
7084 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
7085 if (str && strcmp (str, "1") == 0) return 1;
7089 static int test_blockdev_setrw_0 (void)
7091 if (test_blockdev_setrw_0_skip ()) {
7092 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
7096 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
7098 char device[] = "/dev/sda";
7101 r = guestfs_blockdev_setrw (g, device);
7108 r = guestfs_umount_all (g);
7115 r = guestfs_lvm_remove_all (g);
7119 /* TestOutputFalse for blockdev_setrw (0) */
7121 char device[] = "/dev/sda";
7124 r = guestfs_blockdev_setrw (g, device);
7129 char device[] = "/dev/sda";
7132 r = guestfs_blockdev_getro (g, device);
7136 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
7143 static int test_blockdev_setro_0_skip (void)
7147 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
7148 if (str && strcmp (str, "1") == 0) return 1;
7149 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
7150 if (str && strcmp (str, "1") == 0) return 1;
7154 static int test_blockdev_setro_0 (void)
7156 if (test_blockdev_setro_0_skip ()) {
7157 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
7161 /* InitNone|InitEmpty for test_blockdev_setro_0 */
7163 char device[] = "/dev/sda";
7166 r = guestfs_blockdev_setrw (g, device);
7173 r = guestfs_umount_all (g);
7180 r = guestfs_lvm_remove_all (g);
7184 /* TestOutputTrue for blockdev_setro (0) */
7186 char device[] = "/dev/sda";
7189 r = guestfs_blockdev_setro (g, device);
7194 char device[] = "/dev/sda";
7197 r = guestfs_blockdev_getro (g, device);
7201 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
7208 static int test_statvfs_0_skip (void)
7212 str = getenv ("SKIP_TEST_STATVFS_0");
7213 if (str && strcmp (str, "1") == 0) return 1;
7214 str = getenv ("SKIP_TEST_STATVFS");
7215 if (str && strcmp (str, "1") == 0) return 1;
7219 static int test_statvfs_0 (void)
7221 if (test_statvfs_0_skip ()) {
7222 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
7226 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
7228 char device[] = "/dev/sda";
7231 r = guestfs_blockdev_setrw (g, device);
7238 r = guestfs_umount_all (g);
7245 r = guestfs_lvm_remove_all (g);
7250 char device[] = "/dev/sda";
7251 char lines_0[] = ",";
7258 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7263 char fstype[] = "ext2";
7264 char device[] = "/dev/sda1";
7267 r = guestfs_mkfs (g, fstype, device);
7272 char device[] = "/dev/sda1";
7273 char mountpoint[] = "/";
7276 r = guestfs_mount (g, device, mountpoint);
7280 /* TestOutputStruct for statvfs (0) */
7283 struct guestfs_statvfs *r;
7285 r = guestfs_statvfs (g, path);
7288 if (r->bfree != 487702) {
7289 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7293 if (r->blocks != 490020) {
7294 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7298 if (r->bsize != 1024) {
7299 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7308 static int test_lstat_0_skip (void)
7312 str = getenv ("SKIP_TEST_LSTAT_0");
7313 if (str && strcmp (str, "1") == 0) return 1;
7314 str = getenv ("SKIP_TEST_LSTAT");
7315 if (str && strcmp (str, "1") == 0) return 1;
7319 static int test_lstat_0 (void)
7321 if (test_lstat_0_skip ()) {
7322 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7326 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7328 char device[] = "/dev/sda";
7331 r = guestfs_blockdev_setrw (g, device);
7338 r = guestfs_umount_all (g);
7345 r = guestfs_lvm_remove_all (g);
7350 char device[] = "/dev/sda";
7351 char lines_0[] = ",";
7358 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7363 char fstype[] = "ext2";
7364 char device[] = "/dev/sda1";
7367 r = guestfs_mkfs (g, fstype, device);
7372 char device[] = "/dev/sda1";
7373 char mountpoint[] = "/";
7376 r = guestfs_mount (g, device, mountpoint);
7380 /* TestOutputStruct for lstat (0) */
7382 char path[] = "/new";
7385 r = guestfs_touch (g, path);
7390 char path[] = "/new";
7391 struct guestfs_stat *r;
7393 r = guestfs_lstat (g, path);
7397 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7406 static int test_stat_0_skip (void)
7410 str = getenv ("SKIP_TEST_STAT_0");
7411 if (str && strcmp (str, "1") == 0) return 1;
7412 str = getenv ("SKIP_TEST_STAT");
7413 if (str && strcmp (str, "1") == 0) return 1;
7417 static int test_stat_0 (void)
7419 if (test_stat_0_skip ()) {
7420 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7424 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7426 char device[] = "/dev/sda";
7429 r = guestfs_blockdev_setrw (g, device);
7436 r = guestfs_umount_all (g);
7443 r = guestfs_lvm_remove_all (g);
7448 char device[] = "/dev/sda";
7449 char lines_0[] = ",";
7456 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7461 char fstype[] = "ext2";
7462 char device[] = "/dev/sda1";
7465 r = guestfs_mkfs (g, fstype, device);
7470 char device[] = "/dev/sda1";
7471 char mountpoint[] = "/";
7474 r = guestfs_mount (g, device, mountpoint);
7478 /* TestOutputStruct for stat (0) */
7480 char path[] = "/new";
7483 r = guestfs_touch (g, path);
7488 char path[] = "/new";
7489 struct guestfs_stat *r;
7491 r = guestfs_stat (g, path);
7495 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7504 static int test_command_lines_0_skip (void)
7508 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7509 if (str && strcmp (str, "1") == 0) return 1;
7510 str = getenv ("SKIP_TEST_COMMAND_LINES");
7511 if (str && strcmp (str, "1") == 0) return 1;
7515 static int test_command_lines_0 (void)
7517 if (test_command_lines_0_skip ()) {
7518 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7522 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7524 char device[] = "/dev/sda";
7527 r = guestfs_blockdev_setrw (g, device);
7534 r = guestfs_umount_all (g);
7541 r = guestfs_lvm_remove_all (g);
7546 char device[] = "/dev/sda";
7547 char lines_0[] = ",";
7554 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7559 char fstype[] = "ext2";
7560 char device[] = "/dev/sda1";
7563 r = guestfs_mkfs (g, fstype, device);
7568 char device[] = "/dev/sda1";
7569 char mountpoint[] = "/";
7572 r = guestfs_mount (g, device, mountpoint);
7576 /* TestOutputList for command_lines (0) */
7578 char remotefilename[] = "/test-command";
7581 r = guestfs_upload (g, "test-command", remotefilename);
7586 char path[] = "/test-command";
7589 r = guestfs_chmod (g, 493, path);
7594 char arguments_0[] = "/test-command";
7595 char arguments_1[] = "1";
7596 char *arguments[] = {
7604 r = guestfs_command_lines (g, arguments);
7608 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7613 char expected[] = "Result1";
7614 if (strcmp (r[0], expected) != 0) {
7615 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7620 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7624 for (i = 0; r[i] != NULL; ++i)
7631 static int test_command_lines_1_skip (void)
7635 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7636 if (str && strcmp (str, "1") == 0) return 1;
7637 str = getenv ("SKIP_TEST_COMMAND_LINES");
7638 if (str && strcmp (str, "1") == 0) return 1;
7642 static int test_command_lines_1 (void)
7644 if (test_command_lines_1_skip ()) {
7645 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7649 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7651 char device[] = "/dev/sda";
7654 r = guestfs_blockdev_setrw (g, device);
7661 r = guestfs_umount_all (g);
7668 r = guestfs_lvm_remove_all (g);
7673 char device[] = "/dev/sda";
7674 char lines_0[] = ",";
7681 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7686 char fstype[] = "ext2";
7687 char device[] = "/dev/sda1";
7690 r = guestfs_mkfs (g, fstype, device);
7695 char device[] = "/dev/sda1";
7696 char mountpoint[] = "/";
7699 r = guestfs_mount (g, device, mountpoint);
7703 /* TestOutputList for command_lines (1) */
7705 char remotefilename[] = "/test-command";
7708 r = guestfs_upload (g, "test-command", remotefilename);
7713 char path[] = "/test-command";
7716 r = guestfs_chmod (g, 493, path);
7721 char arguments_0[] = "/test-command";
7722 char arguments_1[] = "2";
7723 char *arguments[] = {
7731 r = guestfs_command_lines (g, arguments);
7735 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7740 char expected[] = "Result2";
7741 if (strcmp (r[0], expected) != 0) {
7742 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7747 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7751 for (i = 0; r[i] != NULL; ++i)
7758 static int test_command_lines_2_skip (void)
7762 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7763 if (str && strcmp (str, "1") == 0) return 1;
7764 str = getenv ("SKIP_TEST_COMMAND_LINES");
7765 if (str && strcmp (str, "1") == 0) return 1;
7769 static int test_command_lines_2 (void)
7771 if (test_command_lines_2_skip ()) {
7772 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7776 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7778 char device[] = "/dev/sda";
7781 r = guestfs_blockdev_setrw (g, device);
7788 r = guestfs_umount_all (g);
7795 r = guestfs_lvm_remove_all (g);
7800 char device[] = "/dev/sda";
7801 char lines_0[] = ",";
7808 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7813 char fstype[] = "ext2";
7814 char device[] = "/dev/sda1";
7817 r = guestfs_mkfs (g, fstype, device);
7822 char device[] = "/dev/sda1";
7823 char mountpoint[] = "/";
7826 r = guestfs_mount (g, device, mountpoint);
7830 /* TestOutputList for command_lines (2) */
7832 char remotefilename[] = "/test-command";
7835 r = guestfs_upload (g, "test-command", remotefilename);
7840 char path[] = "/test-command";
7843 r = guestfs_chmod (g, 493, path);
7848 char arguments_0[] = "/test-command";
7849 char arguments_1[] = "3";
7850 char *arguments[] = {
7858 r = guestfs_command_lines (g, arguments);
7862 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7867 char expected[] = "";
7868 if (strcmp (r[0], expected) != 0) {
7869 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7874 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7879 char expected[] = "Result3";
7880 if (strcmp (r[1], expected) != 0) {
7881 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7886 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7890 for (i = 0; r[i] != NULL; ++i)
7897 static int test_command_lines_3_skip (void)
7901 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7902 if (str && strcmp (str, "1") == 0) return 1;
7903 str = getenv ("SKIP_TEST_COMMAND_LINES");
7904 if (str && strcmp (str, "1") == 0) return 1;
7908 static int test_command_lines_3 (void)
7910 if (test_command_lines_3_skip ()) {
7911 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7915 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7917 char device[] = "/dev/sda";
7920 r = guestfs_blockdev_setrw (g, device);
7927 r = guestfs_umount_all (g);
7934 r = guestfs_lvm_remove_all (g);
7939 char device[] = "/dev/sda";
7940 char lines_0[] = ",";
7947 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7952 char fstype[] = "ext2";
7953 char device[] = "/dev/sda1";
7956 r = guestfs_mkfs (g, fstype, device);
7961 char device[] = "/dev/sda1";
7962 char mountpoint[] = "/";
7965 r = guestfs_mount (g, device, mountpoint);
7969 /* TestOutputList for command_lines (3) */
7971 char remotefilename[] = "/test-command";
7974 r = guestfs_upload (g, "test-command", remotefilename);
7979 char path[] = "/test-command";
7982 r = guestfs_chmod (g, 493, path);
7987 char arguments_0[] = "/test-command";
7988 char arguments_1[] = "4";
7989 char *arguments[] = {
7997 r = guestfs_command_lines (g, arguments);
8001 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8006 char expected[] = "";
8007 if (strcmp (r[0], expected) != 0) {
8008 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8013 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
8018 char expected[] = "Result4";
8019 if (strcmp (r[1], expected) != 0) {
8020 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8025 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
8029 for (i = 0; r[i] != NULL; ++i)
8036 static int test_command_lines_4_skip (void)
8040 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
8041 if (str && strcmp (str, "1") == 0) return 1;
8042 str = getenv ("SKIP_TEST_COMMAND_LINES");
8043 if (str && strcmp (str, "1") == 0) return 1;
8047 static int test_command_lines_4 (void)
8049 if (test_command_lines_4_skip ()) {
8050 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
8054 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
8056 char device[] = "/dev/sda";
8059 r = guestfs_blockdev_setrw (g, device);
8066 r = guestfs_umount_all (g);
8073 r = guestfs_lvm_remove_all (g);
8078 char device[] = "/dev/sda";
8079 char lines_0[] = ",";
8086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8091 char fstype[] = "ext2";
8092 char device[] = "/dev/sda1";
8095 r = guestfs_mkfs (g, fstype, device);
8100 char device[] = "/dev/sda1";
8101 char mountpoint[] = "/";
8104 r = guestfs_mount (g, device, mountpoint);
8108 /* TestOutputList for command_lines (4) */
8110 char remotefilename[] = "/test-command";
8113 r = guestfs_upload (g, "test-command", remotefilename);
8118 char path[] = "/test-command";
8121 r = guestfs_chmod (g, 493, path);
8126 char arguments_0[] = "/test-command";
8127 char arguments_1[] = "5";
8128 char *arguments[] = {
8136 r = guestfs_command_lines (g, arguments);
8140 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8145 char expected[] = "";
8146 if (strcmp (r[0], expected) != 0) {
8147 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8152 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8157 char expected[] = "Result5";
8158 if (strcmp (r[1], expected) != 0) {
8159 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8164 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
8169 char expected[] = "";
8170 if (strcmp (r[2], expected) != 0) {
8171 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8176 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
8180 for (i = 0; r[i] != NULL; ++i)
8187 static int test_command_lines_5_skip (void)
8191 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
8192 if (str && strcmp (str, "1") == 0) return 1;
8193 str = getenv ("SKIP_TEST_COMMAND_LINES");
8194 if (str && strcmp (str, "1") == 0) return 1;
8198 static int test_command_lines_5 (void)
8200 if (test_command_lines_5_skip ()) {
8201 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
8205 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
8207 char device[] = "/dev/sda";
8210 r = guestfs_blockdev_setrw (g, device);
8217 r = guestfs_umount_all (g);
8224 r = guestfs_lvm_remove_all (g);
8229 char device[] = "/dev/sda";
8230 char lines_0[] = ",";
8237 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8242 char fstype[] = "ext2";
8243 char device[] = "/dev/sda1";
8246 r = guestfs_mkfs (g, fstype, device);
8251 char device[] = "/dev/sda1";
8252 char mountpoint[] = "/";
8255 r = guestfs_mount (g, device, mountpoint);
8259 /* TestOutputList for command_lines (5) */
8261 char remotefilename[] = "/test-command";
8264 r = guestfs_upload (g, "test-command", remotefilename);
8269 char path[] = "/test-command";
8272 r = guestfs_chmod (g, 493, path);
8277 char arguments_0[] = "/test-command";
8278 char arguments_1[] = "6";
8279 char *arguments[] = {
8287 r = guestfs_command_lines (g, arguments);
8291 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8296 char expected[] = "";
8297 if (strcmp (r[0], expected) != 0) {
8298 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8303 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8308 char expected[] = "";
8309 if (strcmp (r[1], expected) != 0) {
8310 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8315 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8320 char expected[] = "Result6";
8321 if (strcmp (r[2], expected) != 0) {
8322 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8327 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8332 char expected[] = "";
8333 if (strcmp (r[3], expected) != 0) {
8334 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8339 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8343 for (i = 0; r[i] != NULL; ++i)
8350 static int test_command_lines_6_skip (void)
8354 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8355 if (str && strcmp (str, "1") == 0) return 1;
8356 str = getenv ("SKIP_TEST_COMMAND_LINES");
8357 if (str && strcmp (str, "1") == 0) return 1;
8361 static int test_command_lines_6 (void)
8363 if (test_command_lines_6_skip ()) {
8364 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8368 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8370 char device[] = "/dev/sda";
8373 r = guestfs_blockdev_setrw (g, device);
8380 r = guestfs_umount_all (g);
8387 r = guestfs_lvm_remove_all (g);
8392 char device[] = "/dev/sda";
8393 char lines_0[] = ",";
8400 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8405 char fstype[] = "ext2";
8406 char device[] = "/dev/sda1";
8409 r = guestfs_mkfs (g, fstype, device);
8414 char device[] = "/dev/sda1";
8415 char mountpoint[] = "/";
8418 r = guestfs_mount (g, device, mountpoint);
8422 /* TestOutputList for command_lines (6) */
8424 char remotefilename[] = "/test-command";
8427 r = guestfs_upload (g, "test-command", remotefilename);
8432 char path[] = "/test-command";
8435 r = guestfs_chmod (g, 493, path);
8440 char arguments_0[] = "/test-command";
8441 char arguments_1[] = "7";
8442 char *arguments[] = {
8450 r = guestfs_command_lines (g, arguments);
8454 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8458 for (i = 0; r[i] != NULL; ++i)
8465 static int test_command_lines_7_skip (void)
8469 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8470 if (str && strcmp (str, "1") == 0) return 1;
8471 str = getenv ("SKIP_TEST_COMMAND_LINES");
8472 if (str && strcmp (str, "1") == 0) return 1;
8476 static int test_command_lines_7 (void)
8478 if (test_command_lines_7_skip ()) {
8479 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8483 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8485 char device[] = "/dev/sda";
8488 r = guestfs_blockdev_setrw (g, device);
8495 r = guestfs_umount_all (g);
8502 r = guestfs_lvm_remove_all (g);
8507 char device[] = "/dev/sda";
8508 char lines_0[] = ",";
8515 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8520 char fstype[] = "ext2";
8521 char device[] = "/dev/sda1";
8524 r = guestfs_mkfs (g, fstype, device);
8529 char device[] = "/dev/sda1";
8530 char mountpoint[] = "/";
8533 r = guestfs_mount (g, device, mountpoint);
8537 /* TestOutputList for command_lines (7) */
8539 char remotefilename[] = "/test-command";
8542 r = guestfs_upload (g, "test-command", remotefilename);
8547 char path[] = "/test-command";
8550 r = guestfs_chmod (g, 493, path);
8555 char arguments_0[] = "/test-command";
8556 char arguments_1[] = "8";
8557 char *arguments[] = {
8565 r = guestfs_command_lines (g, arguments);
8569 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8574 char expected[] = "";
8575 if (strcmp (r[0], expected) != 0) {
8576 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8581 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8585 for (i = 0; r[i] != NULL; ++i)
8592 static int test_command_lines_8_skip (void)
8596 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8597 if (str && strcmp (str, "1") == 0) return 1;
8598 str = getenv ("SKIP_TEST_COMMAND_LINES");
8599 if (str && strcmp (str, "1") == 0) return 1;
8603 static int test_command_lines_8 (void)
8605 if (test_command_lines_8_skip ()) {
8606 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8610 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8612 char device[] = "/dev/sda";
8615 r = guestfs_blockdev_setrw (g, device);
8622 r = guestfs_umount_all (g);
8629 r = guestfs_lvm_remove_all (g);
8634 char device[] = "/dev/sda";
8635 char lines_0[] = ",";
8642 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8647 char fstype[] = "ext2";
8648 char device[] = "/dev/sda1";
8651 r = guestfs_mkfs (g, fstype, device);
8656 char device[] = "/dev/sda1";
8657 char mountpoint[] = "/";
8660 r = guestfs_mount (g, device, mountpoint);
8664 /* TestOutputList for command_lines (8) */
8666 char remotefilename[] = "/test-command";
8669 r = guestfs_upload (g, "test-command", remotefilename);
8674 char path[] = "/test-command";
8677 r = guestfs_chmod (g, 493, path);
8682 char arguments_0[] = "/test-command";
8683 char arguments_1[] = "9";
8684 char *arguments[] = {
8692 r = guestfs_command_lines (g, arguments);
8696 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8701 char expected[] = "";
8702 if (strcmp (r[0], expected) != 0) {
8703 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8708 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8713 char expected[] = "";
8714 if (strcmp (r[1], expected) != 0) {
8715 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8720 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8724 for (i = 0; r[i] != NULL; ++i)
8731 static int test_command_lines_9_skip (void)
8735 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8736 if (str && strcmp (str, "1") == 0) return 1;
8737 str = getenv ("SKIP_TEST_COMMAND_LINES");
8738 if (str && strcmp (str, "1") == 0) return 1;
8742 static int test_command_lines_9 (void)
8744 if (test_command_lines_9_skip ()) {
8745 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8749 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8751 char device[] = "/dev/sda";
8754 r = guestfs_blockdev_setrw (g, device);
8761 r = guestfs_umount_all (g);
8768 r = guestfs_lvm_remove_all (g);
8773 char device[] = "/dev/sda";
8774 char lines_0[] = ",";
8781 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8786 char fstype[] = "ext2";
8787 char device[] = "/dev/sda1";
8790 r = guestfs_mkfs (g, fstype, device);
8795 char device[] = "/dev/sda1";
8796 char mountpoint[] = "/";
8799 r = guestfs_mount (g, device, mountpoint);
8803 /* TestOutputList for command_lines (9) */
8805 char remotefilename[] = "/test-command";
8808 r = guestfs_upload (g, "test-command", remotefilename);
8813 char path[] = "/test-command";
8816 r = guestfs_chmod (g, 493, path);
8821 char arguments_0[] = "/test-command";
8822 char arguments_1[] = "10";
8823 char *arguments[] = {
8831 r = guestfs_command_lines (g, arguments);
8835 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8840 char expected[] = "Result10-1";
8841 if (strcmp (r[0], expected) != 0) {
8842 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8847 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8852 char expected[] = "Result10-2";
8853 if (strcmp (r[1], expected) != 0) {
8854 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8859 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8863 for (i = 0; r[i] != NULL; ++i)
8870 static int test_command_lines_10_skip (void)
8874 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8875 if (str && strcmp (str, "1") == 0) return 1;
8876 str = getenv ("SKIP_TEST_COMMAND_LINES");
8877 if (str && strcmp (str, "1") == 0) return 1;
8881 static int test_command_lines_10 (void)
8883 if (test_command_lines_10_skip ()) {
8884 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8888 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8890 char device[] = "/dev/sda";
8893 r = guestfs_blockdev_setrw (g, device);
8900 r = guestfs_umount_all (g);
8907 r = guestfs_lvm_remove_all (g);
8912 char device[] = "/dev/sda";
8913 char lines_0[] = ",";
8920 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8925 char fstype[] = "ext2";
8926 char device[] = "/dev/sda1";
8929 r = guestfs_mkfs (g, fstype, device);
8934 char device[] = "/dev/sda1";
8935 char mountpoint[] = "/";
8938 r = guestfs_mount (g, device, mountpoint);
8942 /* TestOutputList for command_lines (10) */
8944 char remotefilename[] = "/test-command";
8947 r = guestfs_upload (g, "test-command", remotefilename);
8952 char path[] = "/test-command";
8955 r = guestfs_chmod (g, 493, path);
8960 char arguments_0[] = "/test-command";
8961 char arguments_1[] = "11";
8962 char *arguments[] = {
8970 r = guestfs_command_lines (g, arguments);
8974 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8979 char expected[] = "Result11-1";
8980 if (strcmp (r[0], expected) != 0) {
8981 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8986 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8991 char expected[] = "Result11-2";
8992 if (strcmp (r[1], expected) != 0) {
8993 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8998 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
9002 for (i = 0; r[i] != NULL; ++i)
9009 static int test_command_0_skip (void)
9013 str = getenv ("SKIP_TEST_COMMAND_0");
9014 if (str && strcmp (str, "1") == 0) return 1;
9015 str = getenv ("SKIP_TEST_COMMAND");
9016 if (str && strcmp (str, "1") == 0) return 1;
9020 static int test_command_0 (void)
9022 if (test_command_0_skip ()) {
9023 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
9027 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
9029 char device[] = "/dev/sda";
9032 r = guestfs_blockdev_setrw (g, device);
9039 r = guestfs_umount_all (g);
9046 r = guestfs_lvm_remove_all (g);
9051 char device[] = "/dev/sda";
9052 char lines_0[] = ",";
9059 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9064 char fstype[] = "ext2";
9065 char device[] = "/dev/sda1";
9068 r = guestfs_mkfs (g, fstype, device);
9073 char device[] = "/dev/sda1";
9074 char mountpoint[] = "/";
9077 r = guestfs_mount (g, device, mountpoint);
9081 /* TestOutput for command (0) */
9082 char expected[] = "Result1";
9084 char remotefilename[] = "/test-command";
9087 r = guestfs_upload (g, "test-command", remotefilename);
9092 char path[] = "/test-command";
9095 r = guestfs_chmod (g, 493, path);
9100 char arguments_0[] = "/test-command";
9101 char arguments_1[] = "1";
9102 char *arguments[] = {
9109 r = guestfs_command (g, arguments);
9112 if (strcmp (r, expected) != 0) {
9113 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
9121 static int test_command_1_skip (void)
9125 str = getenv ("SKIP_TEST_COMMAND_1");
9126 if (str && strcmp (str, "1") == 0) return 1;
9127 str = getenv ("SKIP_TEST_COMMAND");
9128 if (str && strcmp (str, "1") == 0) return 1;
9132 static int test_command_1 (void)
9134 if (test_command_1_skip ()) {
9135 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
9139 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
9141 char device[] = "/dev/sda";
9144 r = guestfs_blockdev_setrw (g, device);
9151 r = guestfs_umount_all (g);
9158 r = guestfs_lvm_remove_all (g);
9163 char device[] = "/dev/sda";
9164 char lines_0[] = ",";
9171 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9176 char fstype[] = "ext2";
9177 char device[] = "/dev/sda1";
9180 r = guestfs_mkfs (g, fstype, device);
9185 char device[] = "/dev/sda1";
9186 char mountpoint[] = "/";
9189 r = guestfs_mount (g, device, mountpoint);
9193 /* TestOutput for command (1) */
9194 char expected[] = "Result2\n";
9196 char remotefilename[] = "/test-command";
9199 r = guestfs_upload (g, "test-command", remotefilename);
9204 char path[] = "/test-command";
9207 r = guestfs_chmod (g, 493, path);
9212 char arguments_0[] = "/test-command";
9213 char arguments_1[] = "2";
9214 char *arguments[] = {
9221 r = guestfs_command (g, arguments);
9224 if (strcmp (r, expected) != 0) {
9225 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
9233 static int test_command_2_skip (void)
9237 str = getenv ("SKIP_TEST_COMMAND_2");
9238 if (str && strcmp (str, "1") == 0) return 1;
9239 str = getenv ("SKIP_TEST_COMMAND");
9240 if (str && strcmp (str, "1") == 0) return 1;
9244 static int test_command_2 (void)
9246 if (test_command_2_skip ()) {
9247 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9251 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9253 char device[] = "/dev/sda";
9256 r = guestfs_blockdev_setrw (g, device);
9263 r = guestfs_umount_all (g);
9270 r = guestfs_lvm_remove_all (g);
9275 char device[] = "/dev/sda";
9276 char lines_0[] = ",";
9283 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9288 char fstype[] = "ext2";
9289 char device[] = "/dev/sda1";
9292 r = guestfs_mkfs (g, fstype, device);
9297 char device[] = "/dev/sda1";
9298 char mountpoint[] = "/";
9301 r = guestfs_mount (g, device, mountpoint);
9305 /* TestOutput for command (2) */
9306 char expected[] = "\nResult3";
9308 char remotefilename[] = "/test-command";
9311 r = guestfs_upload (g, "test-command", remotefilename);
9316 char path[] = "/test-command";
9319 r = guestfs_chmod (g, 493, path);
9324 char arguments_0[] = "/test-command";
9325 char arguments_1[] = "3";
9326 char *arguments[] = {
9333 r = guestfs_command (g, arguments);
9336 if (strcmp (r, expected) != 0) {
9337 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9345 static int test_command_3_skip (void)
9349 str = getenv ("SKIP_TEST_COMMAND_3");
9350 if (str && strcmp (str, "1") == 0) return 1;
9351 str = getenv ("SKIP_TEST_COMMAND");
9352 if (str && strcmp (str, "1") == 0) return 1;
9356 static int test_command_3 (void)
9358 if (test_command_3_skip ()) {
9359 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9363 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9365 char device[] = "/dev/sda";
9368 r = guestfs_blockdev_setrw (g, device);
9375 r = guestfs_umount_all (g);
9382 r = guestfs_lvm_remove_all (g);
9387 char device[] = "/dev/sda";
9388 char lines_0[] = ",";
9395 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9400 char fstype[] = "ext2";
9401 char device[] = "/dev/sda1";
9404 r = guestfs_mkfs (g, fstype, device);
9409 char device[] = "/dev/sda1";
9410 char mountpoint[] = "/";
9413 r = guestfs_mount (g, device, mountpoint);
9417 /* TestOutput for command (3) */
9418 char expected[] = "\nResult4\n";
9420 char remotefilename[] = "/test-command";
9423 r = guestfs_upload (g, "test-command", remotefilename);
9428 char path[] = "/test-command";
9431 r = guestfs_chmod (g, 493, path);
9436 char arguments_0[] = "/test-command";
9437 char arguments_1[] = "4";
9438 char *arguments[] = {
9445 r = guestfs_command (g, arguments);
9448 if (strcmp (r, expected) != 0) {
9449 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9457 static int test_command_4_skip (void)
9461 str = getenv ("SKIP_TEST_COMMAND_4");
9462 if (str && strcmp (str, "1") == 0) return 1;
9463 str = getenv ("SKIP_TEST_COMMAND");
9464 if (str && strcmp (str, "1") == 0) return 1;
9468 static int test_command_4 (void)
9470 if (test_command_4_skip ()) {
9471 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9475 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9477 char device[] = "/dev/sda";
9480 r = guestfs_blockdev_setrw (g, device);
9487 r = guestfs_umount_all (g);
9494 r = guestfs_lvm_remove_all (g);
9499 char device[] = "/dev/sda";
9500 char lines_0[] = ",";
9507 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9512 char fstype[] = "ext2";
9513 char device[] = "/dev/sda1";
9516 r = guestfs_mkfs (g, fstype, device);
9521 char device[] = "/dev/sda1";
9522 char mountpoint[] = "/";
9525 r = guestfs_mount (g, device, mountpoint);
9529 /* TestOutput for command (4) */
9530 char expected[] = "\nResult5\n\n";
9532 char remotefilename[] = "/test-command";
9535 r = guestfs_upload (g, "test-command", remotefilename);
9540 char path[] = "/test-command";
9543 r = guestfs_chmod (g, 493, path);
9548 char arguments_0[] = "/test-command";
9549 char arguments_1[] = "5";
9550 char *arguments[] = {
9557 r = guestfs_command (g, arguments);
9560 if (strcmp (r, expected) != 0) {
9561 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9569 static int test_command_5_skip (void)
9573 str = getenv ("SKIP_TEST_COMMAND_5");
9574 if (str && strcmp (str, "1") == 0) return 1;
9575 str = getenv ("SKIP_TEST_COMMAND");
9576 if (str && strcmp (str, "1") == 0) return 1;
9580 static int test_command_5 (void)
9582 if (test_command_5_skip ()) {
9583 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9587 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9589 char device[] = "/dev/sda";
9592 r = guestfs_blockdev_setrw (g, device);
9599 r = guestfs_umount_all (g);
9606 r = guestfs_lvm_remove_all (g);
9611 char device[] = "/dev/sda";
9612 char lines_0[] = ",";
9619 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9624 char fstype[] = "ext2";
9625 char device[] = "/dev/sda1";
9628 r = guestfs_mkfs (g, fstype, device);
9633 char device[] = "/dev/sda1";
9634 char mountpoint[] = "/";
9637 r = guestfs_mount (g, device, mountpoint);
9641 /* TestOutput for command (5) */
9642 char expected[] = "\n\nResult6\n\n";
9644 char remotefilename[] = "/test-command";
9647 r = guestfs_upload (g, "test-command", remotefilename);
9652 char path[] = "/test-command";
9655 r = guestfs_chmod (g, 493, path);
9660 char arguments_0[] = "/test-command";
9661 char arguments_1[] = "6";
9662 char *arguments[] = {
9669 r = guestfs_command (g, arguments);
9672 if (strcmp (r, expected) != 0) {
9673 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9681 static int test_command_6_skip (void)
9685 str = getenv ("SKIP_TEST_COMMAND_6");
9686 if (str && strcmp (str, "1") == 0) return 1;
9687 str = getenv ("SKIP_TEST_COMMAND");
9688 if (str && strcmp (str, "1") == 0) return 1;
9692 static int test_command_6 (void)
9694 if (test_command_6_skip ()) {
9695 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9699 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9701 char device[] = "/dev/sda";
9704 r = guestfs_blockdev_setrw (g, device);
9711 r = guestfs_umount_all (g);
9718 r = guestfs_lvm_remove_all (g);
9723 char device[] = "/dev/sda";
9724 char lines_0[] = ",";
9731 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9736 char fstype[] = "ext2";
9737 char device[] = "/dev/sda1";
9740 r = guestfs_mkfs (g, fstype, device);
9745 char device[] = "/dev/sda1";
9746 char mountpoint[] = "/";
9749 r = guestfs_mount (g, device, mountpoint);
9753 /* TestOutput for command (6) */
9754 char expected[] = "";
9756 char remotefilename[] = "/test-command";
9759 r = guestfs_upload (g, "test-command", remotefilename);
9764 char path[] = "/test-command";
9767 r = guestfs_chmod (g, 493, path);
9772 char arguments_0[] = "/test-command";
9773 char arguments_1[] = "7";
9774 char *arguments[] = {
9781 r = guestfs_command (g, arguments);
9784 if (strcmp (r, expected) != 0) {
9785 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9793 static int test_command_7_skip (void)
9797 str = getenv ("SKIP_TEST_COMMAND_7");
9798 if (str && strcmp (str, "1") == 0) return 1;
9799 str = getenv ("SKIP_TEST_COMMAND");
9800 if (str && strcmp (str, "1") == 0) return 1;
9804 static int test_command_7 (void)
9806 if (test_command_7_skip ()) {
9807 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9811 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9813 char device[] = "/dev/sda";
9816 r = guestfs_blockdev_setrw (g, device);
9823 r = guestfs_umount_all (g);
9830 r = guestfs_lvm_remove_all (g);
9835 char device[] = "/dev/sda";
9836 char lines_0[] = ",";
9843 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9848 char fstype[] = "ext2";
9849 char device[] = "/dev/sda1";
9852 r = guestfs_mkfs (g, fstype, device);
9857 char device[] = "/dev/sda1";
9858 char mountpoint[] = "/";
9861 r = guestfs_mount (g, device, mountpoint);
9865 /* TestOutput for command (7) */
9866 char expected[] = "\n";
9868 char remotefilename[] = "/test-command";
9871 r = guestfs_upload (g, "test-command", remotefilename);
9876 char path[] = "/test-command";
9879 r = guestfs_chmod (g, 493, path);
9884 char arguments_0[] = "/test-command";
9885 char arguments_1[] = "8";
9886 char *arguments[] = {
9893 r = guestfs_command (g, arguments);
9896 if (strcmp (r, expected) != 0) {
9897 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9905 static int test_command_8_skip (void)
9909 str = getenv ("SKIP_TEST_COMMAND_8");
9910 if (str && strcmp (str, "1") == 0) return 1;
9911 str = getenv ("SKIP_TEST_COMMAND");
9912 if (str && strcmp (str, "1") == 0) return 1;
9916 static int test_command_8 (void)
9918 if (test_command_8_skip ()) {
9919 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9923 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9925 char device[] = "/dev/sda";
9928 r = guestfs_blockdev_setrw (g, device);
9935 r = guestfs_umount_all (g);
9942 r = guestfs_lvm_remove_all (g);
9947 char device[] = "/dev/sda";
9948 char lines_0[] = ",";
9955 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9960 char fstype[] = "ext2";
9961 char device[] = "/dev/sda1";
9964 r = guestfs_mkfs (g, fstype, device);
9969 char device[] = "/dev/sda1";
9970 char mountpoint[] = "/";
9973 r = guestfs_mount (g, device, mountpoint);
9977 /* TestOutput for command (8) */
9978 char expected[] = "\n\n";
9980 char remotefilename[] = "/test-command";
9983 r = guestfs_upload (g, "test-command", remotefilename);
9988 char path[] = "/test-command";
9991 r = guestfs_chmod (g, 493, path);
9996 char arguments_0[] = "/test-command";
9997 char arguments_1[] = "9";
9998 char *arguments[] = {
10004 suppress_error = 0;
10005 r = guestfs_command (g, arguments);
10008 if (strcmp (r, expected) != 0) {
10009 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
10017 static int test_command_9_skip (void)
10021 str = getenv ("SKIP_TEST_COMMAND_9");
10022 if (str && strcmp (str, "1") == 0) return 1;
10023 str = getenv ("SKIP_TEST_COMMAND");
10024 if (str && strcmp (str, "1") == 0) return 1;
10028 static int test_command_9 (void)
10030 if (test_command_9_skip ()) {
10031 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
10035 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
10037 char device[] = "/dev/sda";
10039 suppress_error = 0;
10040 r = guestfs_blockdev_setrw (g, device);
10046 suppress_error = 0;
10047 r = guestfs_umount_all (g);
10053 suppress_error = 0;
10054 r = guestfs_lvm_remove_all (g);
10059 char device[] = "/dev/sda";
10060 char lines_0[] = ",";
10066 suppress_error = 0;
10067 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10072 char fstype[] = "ext2";
10073 char device[] = "/dev/sda1";
10075 suppress_error = 0;
10076 r = guestfs_mkfs (g, fstype, device);
10081 char device[] = "/dev/sda1";
10082 char mountpoint[] = "/";
10084 suppress_error = 0;
10085 r = guestfs_mount (g, device, mountpoint);
10089 /* TestOutput for command (9) */
10090 char expected[] = "Result10-1\nResult10-2\n";
10092 char remotefilename[] = "/test-command";
10094 suppress_error = 0;
10095 r = guestfs_upload (g, "test-command", remotefilename);
10100 char path[] = "/test-command";
10102 suppress_error = 0;
10103 r = guestfs_chmod (g, 493, path);
10108 char arguments_0[] = "/test-command";
10109 char arguments_1[] = "10";
10110 char *arguments[] = {
10116 suppress_error = 0;
10117 r = guestfs_command (g, arguments);
10120 if (strcmp (r, expected) != 0) {
10121 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
10129 static int test_command_10_skip (void)
10133 str = getenv ("SKIP_TEST_COMMAND_10");
10134 if (str && strcmp (str, "1") == 0) return 1;
10135 str = getenv ("SKIP_TEST_COMMAND");
10136 if (str && strcmp (str, "1") == 0) return 1;
10140 static int test_command_10 (void)
10142 if (test_command_10_skip ()) {
10143 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
10147 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
10149 char device[] = "/dev/sda";
10151 suppress_error = 0;
10152 r = guestfs_blockdev_setrw (g, device);
10158 suppress_error = 0;
10159 r = guestfs_umount_all (g);
10165 suppress_error = 0;
10166 r = guestfs_lvm_remove_all (g);
10171 char device[] = "/dev/sda";
10172 char lines_0[] = ",";
10178 suppress_error = 0;
10179 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10184 char fstype[] = "ext2";
10185 char device[] = "/dev/sda1";
10187 suppress_error = 0;
10188 r = guestfs_mkfs (g, fstype, device);
10193 char device[] = "/dev/sda1";
10194 char mountpoint[] = "/";
10196 suppress_error = 0;
10197 r = guestfs_mount (g, device, mountpoint);
10201 /* TestOutput for command (10) */
10202 char expected[] = "Result11-1\nResult11-2";
10204 char remotefilename[] = "/test-command";
10206 suppress_error = 0;
10207 r = guestfs_upload (g, "test-command", remotefilename);
10212 char path[] = "/test-command";
10214 suppress_error = 0;
10215 r = guestfs_chmod (g, 493, path);
10220 char arguments_0[] = "/test-command";
10221 char arguments_1[] = "11";
10222 char *arguments[] = {
10228 suppress_error = 0;
10229 r = guestfs_command (g, arguments);
10232 if (strcmp (r, expected) != 0) {
10233 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10241 static int test_command_11_skip (void)
10245 str = getenv ("SKIP_TEST_COMMAND_11");
10246 if (str && strcmp (str, "1") == 0) return 1;
10247 str = getenv ("SKIP_TEST_COMMAND");
10248 if (str && strcmp (str, "1") == 0) return 1;
10252 static int test_command_11 (void)
10254 if (test_command_11_skip ()) {
10255 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10259 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10261 char device[] = "/dev/sda";
10263 suppress_error = 0;
10264 r = guestfs_blockdev_setrw (g, device);
10270 suppress_error = 0;
10271 r = guestfs_umount_all (g);
10277 suppress_error = 0;
10278 r = guestfs_lvm_remove_all (g);
10283 char device[] = "/dev/sda";
10284 char lines_0[] = ",";
10290 suppress_error = 0;
10291 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10296 char fstype[] = "ext2";
10297 char device[] = "/dev/sda1";
10299 suppress_error = 0;
10300 r = guestfs_mkfs (g, fstype, device);
10305 char device[] = "/dev/sda1";
10306 char mountpoint[] = "/";
10308 suppress_error = 0;
10309 r = guestfs_mount (g, device, mountpoint);
10313 /* TestLastFail for command (11) */
10315 char remotefilename[] = "/test-command";
10317 suppress_error = 0;
10318 r = guestfs_upload (g, "test-command", remotefilename);
10323 char path[] = "/test-command";
10325 suppress_error = 0;
10326 r = guestfs_chmod (g, 493, path);
10331 char arguments_0[] = "/test-command";
10332 char *arguments[] = {
10337 suppress_error = 1;
10338 r = guestfs_command (g, arguments);
10346 static int test_file_0_skip (void)
10350 str = getenv ("SKIP_TEST_FILE_0");
10351 if (str && strcmp (str, "1") == 0) return 1;
10352 str = getenv ("SKIP_TEST_FILE");
10353 if (str && strcmp (str, "1") == 0) return 1;
10357 static int test_file_0 (void)
10359 if (test_file_0_skip ()) {
10360 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10364 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10366 char device[] = "/dev/sda";
10368 suppress_error = 0;
10369 r = guestfs_blockdev_setrw (g, device);
10375 suppress_error = 0;
10376 r = guestfs_umount_all (g);
10382 suppress_error = 0;
10383 r = guestfs_lvm_remove_all (g);
10388 char device[] = "/dev/sda";
10389 char lines_0[] = ",";
10395 suppress_error = 0;
10396 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10401 char fstype[] = "ext2";
10402 char device[] = "/dev/sda1";
10404 suppress_error = 0;
10405 r = guestfs_mkfs (g, fstype, device);
10410 char device[] = "/dev/sda1";
10411 char mountpoint[] = "/";
10413 suppress_error = 0;
10414 r = guestfs_mount (g, device, mountpoint);
10418 /* TestOutput for file (0) */
10419 char expected[] = "empty";
10421 char path[] = "/new";
10423 suppress_error = 0;
10424 r = guestfs_touch (g, path);
10429 char path[] = "/new";
10431 suppress_error = 0;
10432 r = guestfs_file (g, path);
10435 if (strcmp (r, expected) != 0) {
10436 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10444 static int test_file_1_skip (void)
10448 str = getenv ("SKIP_TEST_FILE_1");
10449 if (str && strcmp (str, "1") == 0) return 1;
10450 str = getenv ("SKIP_TEST_FILE");
10451 if (str && strcmp (str, "1") == 0) return 1;
10455 static int test_file_1 (void)
10457 if (test_file_1_skip ()) {
10458 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10462 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10464 char device[] = "/dev/sda";
10466 suppress_error = 0;
10467 r = guestfs_blockdev_setrw (g, device);
10473 suppress_error = 0;
10474 r = guestfs_umount_all (g);
10480 suppress_error = 0;
10481 r = guestfs_lvm_remove_all (g);
10486 char device[] = "/dev/sda";
10487 char lines_0[] = ",";
10493 suppress_error = 0;
10494 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10499 char fstype[] = "ext2";
10500 char device[] = "/dev/sda1";
10502 suppress_error = 0;
10503 r = guestfs_mkfs (g, fstype, device);
10508 char device[] = "/dev/sda1";
10509 char mountpoint[] = "/";
10511 suppress_error = 0;
10512 r = guestfs_mount (g, device, mountpoint);
10516 /* TestOutput for file (1) */
10517 char expected[] = "ASCII text";
10519 char path[] = "/new";
10520 char content[] = "some content\n";
10522 suppress_error = 0;
10523 r = guestfs_write_file (g, path, content, 0);
10528 char path[] = "/new";
10530 suppress_error = 0;
10531 r = guestfs_file (g, path);
10534 if (strcmp (r, expected) != 0) {
10535 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10543 static int test_file_2_skip (void)
10547 str = getenv ("SKIP_TEST_FILE_2");
10548 if (str && strcmp (str, "1") == 0) return 1;
10549 str = getenv ("SKIP_TEST_FILE");
10550 if (str && strcmp (str, "1") == 0) return 1;
10554 static int test_file_2 (void)
10556 if (test_file_2_skip ()) {
10557 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10561 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10563 char device[] = "/dev/sda";
10565 suppress_error = 0;
10566 r = guestfs_blockdev_setrw (g, device);
10572 suppress_error = 0;
10573 r = guestfs_umount_all (g);
10579 suppress_error = 0;
10580 r = guestfs_lvm_remove_all (g);
10585 char device[] = "/dev/sda";
10586 char lines_0[] = ",";
10592 suppress_error = 0;
10593 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10598 char fstype[] = "ext2";
10599 char device[] = "/dev/sda1";
10601 suppress_error = 0;
10602 r = guestfs_mkfs (g, fstype, device);
10607 char device[] = "/dev/sda1";
10608 char mountpoint[] = "/";
10610 suppress_error = 0;
10611 r = guestfs_mount (g, device, mountpoint);
10615 /* TestLastFail for file (2) */
10617 char path[] = "/nofile";
10619 suppress_error = 1;
10620 r = guestfs_file (g, path);
10628 static int test_umount_all_0_skip (void)
10632 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10633 if (str && strcmp (str, "1") == 0) return 1;
10634 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10635 if (str && strcmp (str, "1") == 0) return 1;
10639 static int test_umount_all_0 (void)
10641 if (test_umount_all_0_skip ()) {
10642 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10646 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10648 char device[] = "/dev/sda";
10650 suppress_error = 0;
10651 r = guestfs_blockdev_setrw (g, device);
10657 suppress_error = 0;
10658 r = guestfs_umount_all (g);
10664 suppress_error = 0;
10665 r = guestfs_lvm_remove_all (g);
10670 char device[] = "/dev/sda";
10671 char lines_0[] = ",";
10677 suppress_error = 0;
10678 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10683 char fstype[] = "ext2";
10684 char device[] = "/dev/sda1";
10686 suppress_error = 0;
10687 r = guestfs_mkfs (g, fstype, device);
10692 char device[] = "/dev/sda1";
10693 char mountpoint[] = "/";
10695 suppress_error = 0;
10696 r = guestfs_mount (g, device, mountpoint);
10700 /* TestOutputList for umount_all (0) */
10703 suppress_error = 0;
10704 r = guestfs_umount_all (g);
10711 suppress_error = 0;
10712 r = guestfs_mounts (g);
10715 if (r[0] != NULL) {
10716 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10720 for (i = 0; r[i] != NULL; ++i)
10727 static int test_umount_all_1_skip (void)
10731 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10732 if (str && strcmp (str, "1") == 0) return 1;
10733 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10734 if (str && strcmp (str, "1") == 0) return 1;
10738 static int test_umount_all_1 (void)
10740 if (test_umount_all_1_skip ()) {
10741 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10745 /* InitNone|InitEmpty for test_umount_all_1 */
10747 char device[] = "/dev/sda";
10749 suppress_error = 0;
10750 r = guestfs_blockdev_setrw (g, device);
10756 suppress_error = 0;
10757 r = guestfs_umount_all (g);
10763 suppress_error = 0;
10764 r = guestfs_lvm_remove_all (g);
10768 /* TestOutputList for umount_all (1) */
10770 char device[] = "/dev/sda";
10771 char lines_0[] = ",10";
10772 char lines_1[] = ",20";
10773 char lines_2[] = ",";
10781 suppress_error = 0;
10782 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10787 char fstype[] = "ext2";
10788 char device[] = "/dev/sda1";
10790 suppress_error = 0;
10791 r = guestfs_mkfs (g, fstype, device);
10796 char fstype[] = "ext2";
10797 char device[] = "/dev/sda2";
10799 suppress_error = 0;
10800 r = guestfs_mkfs (g, fstype, device);
10805 char fstype[] = "ext2";
10806 char device[] = "/dev/sda3";
10808 suppress_error = 0;
10809 r = guestfs_mkfs (g, fstype, device);
10814 char device[] = "/dev/sda1";
10815 char mountpoint[] = "/";
10817 suppress_error = 0;
10818 r = guestfs_mount (g, device, mountpoint);
10823 char path[] = "/mp1";
10825 suppress_error = 0;
10826 r = guestfs_mkdir (g, path);
10831 char device[] = "/dev/sda2";
10832 char mountpoint[] = "/mp1";
10834 suppress_error = 0;
10835 r = guestfs_mount (g, device, mountpoint);
10840 char path[] = "/mp1/mp2";
10842 suppress_error = 0;
10843 r = guestfs_mkdir (g, path);
10848 char device[] = "/dev/sda3";
10849 char mountpoint[] = "/mp1/mp2";
10851 suppress_error = 0;
10852 r = guestfs_mount (g, device, mountpoint);
10857 char path[] = "/mp1/mp2/mp3";
10859 suppress_error = 0;
10860 r = guestfs_mkdir (g, path);
10866 suppress_error = 0;
10867 r = guestfs_umount_all (g);
10874 suppress_error = 0;
10875 r = guestfs_mounts (g);
10878 if (r[0] != NULL) {
10879 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10883 for (i = 0; r[i] != NULL; ++i)
10890 static int test_mounts_0_skip (void)
10894 str = getenv ("SKIP_TEST_MOUNTS_0");
10895 if (str && strcmp (str, "1") == 0) return 1;
10896 str = getenv ("SKIP_TEST_MOUNTS");
10897 if (str && strcmp (str, "1") == 0) return 1;
10901 static int test_mounts_0 (void)
10903 if (test_mounts_0_skip ()) {
10904 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10908 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10910 char device[] = "/dev/sda";
10912 suppress_error = 0;
10913 r = guestfs_blockdev_setrw (g, device);
10919 suppress_error = 0;
10920 r = guestfs_umount_all (g);
10926 suppress_error = 0;
10927 r = guestfs_lvm_remove_all (g);
10932 char device[] = "/dev/sda";
10933 char lines_0[] = ",";
10939 suppress_error = 0;
10940 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10945 char fstype[] = "ext2";
10946 char device[] = "/dev/sda1";
10948 suppress_error = 0;
10949 r = guestfs_mkfs (g, fstype, device);
10954 char device[] = "/dev/sda1";
10955 char mountpoint[] = "/";
10957 suppress_error = 0;
10958 r = guestfs_mount (g, device, mountpoint);
10962 /* TestOutputListOfDevices for mounts (0) */
10966 suppress_error = 0;
10967 r = guestfs_mounts (g);
10971 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10976 char expected[] = "/dev/sda1";
10978 if (strcmp (r[0], expected) != 0) {
10979 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10983 if (r[1] != NULL) {
10984 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10988 for (i = 0; r[i] != NULL; ++i)
10995 static int test_umount_0_skip (void)
10999 str = getenv ("SKIP_TEST_UMOUNT_0");
11000 if (str && strcmp (str, "1") == 0) return 1;
11001 str = getenv ("SKIP_TEST_UMOUNT");
11002 if (str && strcmp (str, "1") == 0) return 1;
11006 static int test_umount_0 (void)
11008 if (test_umount_0_skip ()) {
11009 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
11013 /* InitNone|InitEmpty for test_umount_0 */
11015 char device[] = "/dev/sda";
11017 suppress_error = 0;
11018 r = guestfs_blockdev_setrw (g, device);
11024 suppress_error = 0;
11025 r = guestfs_umount_all (g);
11031 suppress_error = 0;
11032 r = guestfs_lvm_remove_all (g);
11036 /* TestOutputListOfDevices for umount (0) */
11038 char device[] = "/dev/sda";
11039 char lines_0[] = ",";
11045 suppress_error = 0;
11046 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11051 char fstype[] = "ext2";
11052 char device[] = "/dev/sda1";
11054 suppress_error = 0;
11055 r = guestfs_mkfs (g, fstype, device);
11060 char device[] = "/dev/sda1";
11061 char mountpoint[] = "/";
11063 suppress_error = 0;
11064 r = guestfs_mount (g, device, mountpoint);
11071 suppress_error = 0;
11072 r = guestfs_mounts (g);
11076 fprintf (stderr, "test_umount_0: short list returned from command\n");
11081 char expected[] = "/dev/sda1";
11083 if (strcmp (r[0], expected) != 0) {
11084 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11088 if (r[1] != NULL) {
11089 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
11093 for (i = 0; r[i] != NULL; ++i)
11100 static int test_umount_1_skip (void)
11104 str = getenv ("SKIP_TEST_UMOUNT_1");
11105 if (str && strcmp (str, "1") == 0) return 1;
11106 str = getenv ("SKIP_TEST_UMOUNT");
11107 if (str && strcmp (str, "1") == 0) return 1;
11111 static int test_umount_1 (void)
11113 if (test_umount_1_skip ()) {
11114 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
11118 /* InitNone|InitEmpty for test_umount_1 */
11120 char device[] = "/dev/sda";
11122 suppress_error = 0;
11123 r = guestfs_blockdev_setrw (g, device);
11129 suppress_error = 0;
11130 r = guestfs_umount_all (g);
11136 suppress_error = 0;
11137 r = guestfs_lvm_remove_all (g);
11141 /* TestOutputList for umount (1) */
11143 char device[] = "/dev/sda";
11144 char lines_0[] = ",";
11150 suppress_error = 0;
11151 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11156 char fstype[] = "ext2";
11157 char device[] = "/dev/sda1";
11159 suppress_error = 0;
11160 r = guestfs_mkfs (g, fstype, device);
11165 char device[] = "/dev/sda1";
11166 char mountpoint[] = "/";
11168 suppress_error = 0;
11169 r = guestfs_mount (g, device, mountpoint);
11174 char pathordevice[] = "/";
11176 suppress_error = 0;
11177 r = guestfs_umount (g, pathordevice);
11184 suppress_error = 0;
11185 r = guestfs_mounts (g);
11188 if (r[0] != NULL) {
11189 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
11193 for (i = 0; r[i] != NULL; ++i)
11200 static int test_write_file_0_skip (void)
11204 str = getenv ("SKIP_TEST_WRITE_FILE_0");
11205 if (str && strcmp (str, "1") == 0) return 1;
11206 str = getenv ("SKIP_TEST_WRITE_FILE");
11207 if (str && strcmp (str, "1") == 0) return 1;
11211 static int test_write_file_0 (void)
11213 if (test_write_file_0_skip ()) {
11214 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
11218 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
11220 char device[] = "/dev/sda";
11222 suppress_error = 0;
11223 r = guestfs_blockdev_setrw (g, device);
11229 suppress_error = 0;
11230 r = guestfs_umount_all (g);
11236 suppress_error = 0;
11237 r = guestfs_lvm_remove_all (g);
11242 char device[] = "/dev/sda";
11243 char lines_0[] = ",";
11249 suppress_error = 0;
11250 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11255 char fstype[] = "ext2";
11256 char device[] = "/dev/sda1";
11258 suppress_error = 0;
11259 r = guestfs_mkfs (g, fstype, device);
11264 char device[] = "/dev/sda1";
11265 char mountpoint[] = "/";
11267 suppress_error = 0;
11268 r = guestfs_mount (g, device, mountpoint);
11272 /* TestOutput for write_file (0) */
11273 char expected[] = "new file contents";
11275 char path[] = "/new";
11276 char content[] = "new file contents";
11278 suppress_error = 0;
11279 r = guestfs_write_file (g, path, content, 0);
11284 char path[] = "/new";
11286 suppress_error = 0;
11287 r = guestfs_cat (g, path);
11290 if (strcmp (r, expected) != 0) {
11291 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11299 static int test_write_file_1_skip (void)
11303 str = getenv ("SKIP_TEST_WRITE_FILE_1");
11304 if (str && strcmp (str, "1") == 0) return 1;
11305 str = getenv ("SKIP_TEST_WRITE_FILE");
11306 if (str && strcmp (str, "1") == 0) return 1;
11310 static int test_write_file_1 (void)
11312 if (test_write_file_1_skip ()) {
11313 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11317 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11319 char device[] = "/dev/sda";
11321 suppress_error = 0;
11322 r = guestfs_blockdev_setrw (g, device);
11328 suppress_error = 0;
11329 r = guestfs_umount_all (g);
11335 suppress_error = 0;
11336 r = guestfs_lvm_remove_all (g);
11341 char device[] = "/dev/sda";
11342 char lines_0[] = ",";
11348 suppress_error = 0;
11349 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11354 char fstype[] = "ext2";
11355 char device[] = "/dev/sda1";
11357 suppress_error = 0;
11358 r = guestfs_mkfs (g, fstype, device);
11363 char device[] = "/dev/sda1";
11364 char mountpoint[] = "/";
11366 suppress_error = 0;
11367 r = guestfs_mount (g, device, mountpoint);
11371 /* TestOutput for write_file (1) */
11372 char expected[] = "\nnew file contents\n";
11374 char path[] = "/new";
11375 char content[] = "\nnew file contents\n";
11377 suppress_error = 0;
11378 r = guestfs_write_file (g, path, content, 0);
11383 char path[] = "/new";
11385 suppress_error = 0;
11386 r = guestfs_cat (g, path);
11389 if (strcmp (r, expected) != 0) {
11390 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11398 static int test_write_file_2_skip (void)
11402 str = getenv ("SKIP_TEST_WRITE_FILE_2");
11403 if (str && strcmp (str, "1") == 0) return 1;
11404 str = getenv ("SKIP_TEST_WRITE_FILE");
11405 if (str && strcmp (str, "1") == 0) return 1;
11409 static int test_write_file_2 (void)
11411 if (test_write_file_2_skip ()) {
11412 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11416 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11418 char device[] = "/dev/sda";
11420 suppress_error = 0;
11421 r = guestfs_blockdev_setrw (g, device);
11427 suppress_error = 0;
11428 r = guestfs_umount_all (g);
11434 suppress_error = 0;
11435 r = guestfs_lvm_remove_all (g);
11440 char device[] = "/dev/sda";
11441 char lines_0[] = ",";
11447 suppress_error = 0;
11448 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11453 char fstype[] = "ext2";
11454 char device[] = "/dev/sda1";
11456 suppress_error = 0;
11457 r = guestfs_mkfs (g, fstype, device);
11462 char device[] = "/dev/sda1";
11463 char mountpoint[] = "/";
11465 suppress_error = 0;
11466 r = guestfs_mount (g, device, mountpoint);
11470 /* TestOutput for write_file (2) */
11471 char expected[] = "\n\n";
11473 char path[] = "/new";
11474 char content[] = "\n\n";
11476 suppress_error = 0;
11477 r = guestfs_write_file (g, path, content, 0);
11482 char path[] = "/new";
11484 suppress_error = 0;
11485 r = guestfs_cat (g, path);
11488 if (strcmp (r, expected) != 0) {
11489 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11497 static int test_write_file_3_skip (void)
11501 str = getenv ("SKIP_TEST_WRITE_FILE_3");
11502 if (str && strcmp (str, "1") == 0) return 1;
11503 str = getenv ("SKIP_TEST_WRITE_FILE");
11504 if (str && strcmp (str, "1") == 0) return 1;
11508 static int test_write_file_3 (void)
11510 if (test_write_file_3_skip ()) {
11511 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11515 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11517 char device[] = "/dev/sda";
11519 suppress_error = 0;
11520 r = guestfs_blockdev_setrw (g, device);
11526 suppress_error = 0;
11527 r = guestfs_umount_all (g);
11533 suppress_error = 0;
11534 r = guestfs_lvm_remove_all (g);
11539 char device[] = "/dev/sda";
11540 char lines_0[] = ",";
11546 suppress_error = 0;
11547 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11552 char fstype[] = "ext2";
11553 char device[] = "/dev/sda1";
11555 suppress_error = 0;
11556 r = guestfs_mkfs (g, fstype, device);
11561 char device[] = "/dev/sda1";
11562 char mountpoint[] = "/";
11564 suppress_error = 0;
11565 r = guestfs_mount (g, device, mountpoint);
11569 /* TestOutput for write_file (3) */
11570 char expected[] = "";
11572 char path[] = "/new";
11573 char content[] = "";
11575 suppress_error = 0;
11576 r = guestfs_write_file (g, path, content, 0);
11581 char path[] = "/new";
11583 suppress_error = 0;
11584 r = guestfs_cat (g, path);
11587 if (strcmp (r, expected) != 0) {
11588 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11596 static int test_write_file_4_skip (void)
11600 str = getenv ("SKIP_TEST_WRITE_FILE_4");
11601 if (str && strcmp (str, "1") == 0) return 1;
11602 str = getenv ("SKIP_TEST_WRITE_FILE");
11603 if (str && strcmp (str, "1") == 0) return 1;
11607 static int test_write_file_4 (void)
11609 if (test_write_file_4_skip ()) {
11610 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11614 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11616 char device[] = "/dev/sda";
11618 suppress_error = 0;
11619 r = guestfs_blockdev_setrw (g, device);
11625 suppress_error = 0;
11626 r = guestfs_umount_all (g);
11632 suppress_error = 0;
11633 r = guestfs_lvm_remove_all (g);
11638 char device[] = "/dev/sda";
11639 char lines_0[] = ",";
11645 suppress_error = 0;
11646 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11651 char fstype[] = "ext2";
11652 char device[] = "/dev/sda1";
11654 suppress_error = 0;
11655 r = guestfs_mkfs (g, fstype, device);
11660 char device[] = "/dev/sda1";
11661 char mountpoint[] = "/";
11663 suppress_error = 0;
11664 r = guestfs_mount (g, device, mountpoint);
11668 /* TestOutput for write_file (4) */
11669 char expected[] = "\n\n\n";
11671 char path[] = "/new";
11672 char content[] = "\n\n\n";
11674 suppress_error = 0;
11675 r = guestfs_write_file (g, path, content, 0);
11680 char path[] = "/new";
11682 suppress_error = 0;
11683 r = guestfs_cat (g, path);
11686 if (strcmp (r, expected) != 0) {
11687 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11695 static int test_write_file_5_skip (void)
11699 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11700 if (str && strcmp (str, "1") == 0) return 1;
11701 str = getenv ("SKIP_TEST_WRITE_FILE");
11702 if (str && strcmp (str, "1") == 0) return 1;
11706 static int test_write_file_5 (void)
11708 if (test_write_file_5_skip ()) {
11709 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11713 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11715 char device[] = "/dev/sda";
11717 suppress_error = 0;
11718 r = guestfs_blockdev_setrw (g, device);
11724 suppress_error = 0;
11725 r = guestfs_umount_all (g);
11731 suppress_error = 0;
11732 r = guestfs_lvm_remove_all (g);
11737 char device[] = "/dev/sda";
11738 char lines_0[] = ",";
11744 suppress_error = 0;
11745 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11750 char fstype[] = "ext2";
11751 char device[] = "/dev/sda1";
11753 suppress_error = 0;
11754 r = guestfs_mkfs (g, fstype, device);
11759 char device[] = "/dev/sda1";
11760 char mountpoint[] = "/";
11762 suppress_error = 0;
11763 r = guestfs_mount (g, device, mountpoint);
11767 /* TestOutput for write_file (5) */
11768 char expected[] = "\n";
11770 char path[] = "/new";
11771 char content[] = "\n";
11773 suppress_error = 0;
11774 r = guestfs_write_file (g, path, content, 0);
11779 char path[] = "/new";
11781 suppress_error = 0;
11782 r = guestfs_cat (g, path);
11785 if (strcmp (r, expected) != 0) {
11786 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11794 static int test_mkfs_0_skip (void)
11798 str = getenv ("SKIP_TEST_MKFS_0");
11799 if (str && strcmp (str, "1") == 0) return 1;
11800 str = getenv ("SKIP_TEST_MKFS");
11801 if (str && strcmp (str, "1") == 0) return 1;
11805 static int test_mkfs_0 (void)
11807 if (test_mkfs_0_skip ()) {
11808 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11812 /* InitNone|InitEmpty for test_mkfs_0 */
11814 char device[] = "/dev/sda";
11816 suppress_error = 0;
11817 r = guestfs_blockdev_setrw (g, device);
11823 suppress_error = 0;
11824 r = guestfs_umount_all (g);
11830 suppress_error = 0;
11831 r = guestfs_lvm_remove_all (g);
11835 /* TestOutput for mkfs (0) */
11836 char expected[] = "new file contents";
11838 char device[] = "/dev/sda";
11839 char lines_0[] = ",";
11845 suppress_error = 0;
11846 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11851 char fstype[] = "ext2";
11852 char device[] = "/dev/sda1";
11854 suppress_error = 0;
11855 r = guestfs_mkfs (g, fstype, device);
11860 char device[] = "/dev/sda1";
11861 char mountpoint[] = "/";
11863 suppress_error = 0;
11864 r = guestfs_mount (g, device, mountpoint);
11869 char path[] = "/new";
11870 char content[] = "new file contents";
11872 suppress_error = 0;
11873 r = guestfs_write_file (g, path, content, 0);
11878 char path[] = "/new";
11880 suppress_error = 0;
11881 r = guestfs_cat (g, path);
11884 if (strcmp (r, expected) != 0) {
11885 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11893 static int test_lvcreate_0_skip (void)
11897 str = getenv ("SKIP_TEST_LVCREATE_0");
11898 if (str && strcmp (str, "1") == 0) return 1;
11899 str = getenv ("SKIP_TEST_LVCREATE");
11900 if (str && strcmp (str, "1") == 0) return 1;
11904 static int test_lvcreate_0 (void)
11906 if (test_lvcreate_0_skip ()) {
11907 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11911 /* InitNone|InitEmpty for test_lvcreate_0 */
11913 char device[] = "/dev/sda";
11915 suppress_error = 0;
11916 r = guestfs_blockdev_setrw (g, device);
11922 suppress_error = 0;
11923 r = guestfs_umount_all (g);
11929 suppress_error = 0;
11930 r = guestfs_lvm_remove_all (g);
11934 /* TestOutputList for lvcreate (0) */
11936 char device[] = "/dev/sda";
11937 char lines_0[] = ",10";
11938 char lines_1[] = ",20";
11939 char lines_2[] = ",";
11947 suppress_error = 0;
11948 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11953 char device[] = "/dev/sda1";
11955 suppress_error = 0;
11956 r = guestfs_pvcreate (g, device);
11961 char device[] = "/dev/sda2";
11963 suppress_error = 0;
11964 r = guestfs_pvcreate (g, device);
11969 char device[] = "/dev/sda3";
11971 suppress_error = 0;
11972 r = guestfs_pvcreate (g, device);
11977 char volgroup[] = "VG1";
11978 char physvols_0[] = "/dev/sda1";
11979 char physvols_1[] = "/dev/sda2";
11980 char *physvols[] = {
11986 suppress_error = 0;
11987 r = guestfs_vgcreate (g, volgroup, physvols);
11992 char volgroup[] = "VG2";
11993 char physvols_0[] = "/dev/sda3";
11994 char *physvols[] = {
11999 suppress_error = 0;
12000 r = guestfs_vgcreate (g, volgroup, physvols);
12005 char logvol[] = "LV1";
12006 char volgroup[] = "VG1";
12008 suppress_error = 0;
12009 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12014 char logvol[] = "LV2";
12015 char volgroup[] = "VG1";
12017 suppress_error = 0;
12018 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12023 char logvol[] = "LV3";
12024 char volgroup[] = "VG2";
12026 suppress_error = 0;
12027 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12032 char logvol[] = "LV4";
12033 char volgroup[] = "VG2";
12035 suppress_error = 0;
12036 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12041 char logvol[] = "LV5";
12042 char volgroup[] = "VG2";
12044 suppress_error = 0;
12045 r = guestfs_lvcreate (g, logvol, volgroup, 50);
12052 suppress_error = 0;
12053 r = guestfs_lvs (g);
12057 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12062 char expected[] = "/dev/VG1/LV1";
12063 if (strcmp (r[0], expected) != 0) {
12064 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12069 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12074 char expected[] = "/dev/VG1/LV2";
12075 if (strcmp (r[1], expected) != 0) {
12076 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12081 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12086 char expected[] = "/dev/VG2/LV3";
12087 if (strcmp (r[2], expected) != 0) {
12088 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12093 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12098 char expected[] = "/dev/VG2/LV4";
12099 if (strcmp (r[3], expected) != 0) {
12100 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
12105 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
12110 char expected[] = "/dev/VG2/LV5";
12111 if (strcmp (r[4], expected) != 0) {
12112 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
12116 if (r[5] != NULL) {
12117 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
12121 for (i = 0; r[i] != NULL; ++i)
12128 static int test_vgcreate_0_skip (void)
12132 str = getenv ("SKIP_TEST_VGCREATE_0");
12133 if (str && strcmp (str, "1") == 0) return 1;
12134 str = getenv ("SKIP_TEST_VGCREATE");
12135 if (str && strcmp (str, "1") == 0) return 1;
12139 static int test_vgcreate_0 (void)
12141 if (test_vgcreate_0_skip ()) {
12142 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
12146 /* InitNone|InitEmpty for test_vgcreate_0 */
12148 char device[] = "/dev/sda";
12150 suppress_error = 0;
12151 r = guestfs_blockdev_setrw (g, device);
12157 suppress_error = 0;
12158 r = guestfs_umount_all (g);
12164 suppress_error = 0;
12165 r = guestfs_lvm_remove_all (g);
12169 /* TestOutputList for vgcreate (0) */
12171 char device[] = "/dev/sda";
12172 char lines_0[] = ",10";
12173 char lines_1[] = ",20";
12174 char lines_2[] = ",";
12182 suppress_error = 0;
12183 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12188 char device[] = "/dev/sda1";
12190 suppress_error = 0;
12191 r = guestfs_pvcreate (g, device);
12196 char device[] = "/dev/sda2";
12198 suppress_error = 0;
12199 r = guestfs_pvcreate (g, device);
12204 char device[] = "/dev/sda3";
12206 suppress_error = 0;
12207 r = guestfs_pvcreate (g, device);
12212 char volgroup[] = "VG1";
12213 char physvols_0[] = "/dev/sda1";
12214 char physvols_1[] = "/dev/sda2";
12215 char *physvols[] = {
12221 suppress_error = 0;
12222 r = guestfs_vgcreate (g, volgroup, physvols);
12227 char volgroup[] = "VG2";
12228 char physvols_0[] = "/dev/sda3";
12229 char *physvols[] = {
12234 suppress_error = 0;
12235 r = guestfs_vgcreate (g, volgroup, physvols);
12242 suppress_error = 0;
12243 r = guestfs_vgs (g);
12247 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12252 char expected[] = "VG1";
12253 if (strcmp (r[0], expected) != 0) {
12254 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12259 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12264 char expected[] = "VG2";
12265 if (strcmp (r[1], expected) != 0) {
12266 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12270 if (r[2] != NULL) {
12271 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12275 for (i = 0; r[i] != NULL; ++i)
12282 static int test_pvcreate_0_skip (void)
12286 str = getenv ("SKIP_TEST_PVCREATE_0");
12287 if (str && strcmp (str, "1") == 0) return 1;
12288 str = getenv ("SKIP_TEST_PVCREATE");
12289 if (str && strcmp (str, "1") == 0) return 1;
12293 static int test_pvcreate_0 (void)
12295 if (test_pvcreate_0_skip ()) {
12296 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12300 /* InitNone|InitEmpty for test_pvcreate_0 */
12302 char device[] = "/dev/sda";
12304 suppress_error = 0;
12305 r = guestfs_blockdev_setrw (g, device);
12311 suppress_error = 0;
12312 r = guestfs_umount_all (g);
12318 suppress_error = 0;
12319 r = guestfs_lvm_remove_all (g);
12323 /* TestOutputListOfDevices for pvcreate (0) */
12325 char device[] = "/dev/sda";
12326 char lines_0[] = ",10";
12327 char lines_1[] = ",20";
12328 char lines_2[] = ",";
12336 suppress_error = 0;
12337 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12342 char device[] = "/dev/sda1";
12344 suppress_error = 0;
12345 r = guestfs_pvcreate (g, device);
12350 char device[] = "/dev/sda2";
12352 suppress_error = 0;
12353 r = guestfs_pvcreate (g, device);
12358 char device[] = "/dev/sda3";
12360 suppress_error = 0;
12361 r = guestfs_pvcreate (g, device);
12368 suppress_error = 0;
12369 r = guestfs_pvs (g);
12373 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12378 char expected[] = "/dev/sda1";
12380 if (strcmp (r[0], expected) != 0) {
12381 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12386 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12391 char expected[] = "/dev/sda2";
12393 if (strcmp (r[1], expected) != 0) {
12394 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12399 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12404 char expected[] = "/dev/sda3";
12406 if (strcmp (r[2], expected) != 0) {
12407 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12411 if (r[3] != NULL) {
12412 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12416 for (i = 0; r[i] != NULL; ++i)
12423 static int test_is_dir_0_skip (void)
12427 str = getenv ("SKIP_TEST_IS_DIR_0");
12428 if (str && strcmp (str, "1") == 0) return 1;
12429 str = getenv ("SKIP_TEST_IS_DIR");
12430 if (str && strcmp (str, "1") == 0) return 1;
12434 static int test_is_dir_0 (void)
12436 if (test_is_dir_0_skip ()) {
12437 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12441 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12443 char device[] = "/dev/sda";
12445 suppress_error = 0;
12446 r = guestfs_blockdev_setrw (g, device);
12452 suppress_error = 0;
12453 r = guestfs_umount_all (g);
12459 suppress_error = 0;
12460 r = guestfs_lvm_remove_all (g);
12465 char device[] = "/dev/sda";
12466 char lines_0[] = ",";
12472 suppress_error = 0;
12473 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12478 char fstype[] = "ext2";
12479 char device[] = "/dev/sda1";
12481 suppress_error = 0;
12482 r = guestfs_mkfs (g, fstype, device);
12487 char device[] = "/dev/sda1";
12488 char mountpoint[] = "/";
12490 suppress_error = 0;
12491 r = guestfs_mount (g, device, mountpoint);
12495 /* TestOutputFalse for is_dir (0) */
12497 char path[] = "/new";
12499 suppress_error = 0;
12500 r = guestfs_touch (g, path);
12505 char path[] = "/new";
12507 suppress_error = 0;
12508 r = guestfs_is_dir (g, path);
12512 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12519 static int test_is_dir_1_skip (void)
12523 str = getenv ("SKIP_TEST_IS_DIR_1");
12524 if (str && strcmp (str, "1") == 0) return 1;
12525 str = getenv ("SKIP_TEST_IS_DIR");
12526 if (str && strcmp (str, "1") == 0) return 1;
12530 static int test_is_dir_1 (void)
12532 if (test_is_dir_1_skip ()) {
12533 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12537 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12539 char device[] = "/dev/sda";
12541 suppress_error = 0;
12542 r = guestfs_blockdev_setrw (g, device);
12548 suppress_error = 0;
12549 r = guestfs_umount_all (g);
12555 suppress_error = 0;
12556 r = guestfs_lvm_remove_all (g);
12561 char device[] = "/dev/sda";
12562 char lines_0[] = ",";
12568 suppress_error = 0;
12569 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12574 char fstype[] = "ext2";
12575 char device[] = "/dev/sda1";
12577 suppress_error = 0;
12578 r = guestfs_mkfs (g, fstype, device);
12583 char device[] = "/dev/sda1";
12584 char mountpoint[] = "/";
12586 suppress_error = 0;
12587 r = guestfs_mount (g, device, mountpoint);
12591 /* TestOutputTrue for is_dir (1) */
12593 char path[] = "/new";
12595 suppress_error = 0;
12596 r = guestfs_mkdir (g, path);
12601 char path[] = "/new";
12603 suppress_error = 0;
12604 r = guestfs_is_dir (g, path);
12608 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12615 static int test_is_file_0_skip (void)
12619 str = getenv ("SKIP_TEST_IS_FILE_0");
12620 if (str && strcmp (str, "1") == 0) return 1;
12621 str = getenv ("SKIP_TEST_IS_FILE");
12622 if (str && strcmp (str, "1") == 0) return 1;
12626 static int test_is_file_0 (void)
12628 if (test_is_file_0_skip ()) {
12629 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12633 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12635 char device[] = "/dev/sda";
12637 suppress_error = 0;
12638 r = guestfs_blockdev_setrw (g, device);
12644 suppress_error = 0;
12645 r = guestfs_umount_all (g);
12651 suppress_error = 0;
12652 r = guestfs_lvm_remove_all (g);
12657 char device[] = "/dev/sda";
12658 char lines_0[] = ",";
12664 suppress_error = 0;
12665 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12670 char fstype[] = "ext2";
12671 char device[] = "/dev/sda1";
12673 suppress_error = 0;
12674 r = guestfs_mkfs (g, fstype, device);
12679 char device[] = "/dev/sda1";
12680 char mountpoint[] = "/";
12682 suppress_error = 0;
12683 r = guestfs_mount (g, device, mountpoint);
12687 /* TestOutputTrue for is_file (0) */
12689 char path[] = "/new";
12691 suppress_error = 0;
12692 r = guestfs_touch (g, path);
12697 char path[] = "/new";
12699 suppress_error = 0;
12700 r = guestfs_is_file (g, path);
12704 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12711 static int test_is_file_1_skip (void)
12715 str = getenv ("SKIP_TEST_IS_FILE_1");
12716 if (str && strcmp (str, "1") == 0) return 1;
12717 str = getenv ("SKIP_TEST_IS_FILE");
12718 if (str && strcmp (str, "1") == 0) return 1;
12722 static int test_is_file_1 (void)
12724 if (test_is_file_1_skip ()) {
12725 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12729 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12731 char device[] = "/dev/sda";
12733 suppress_error = 0;
12734 r = guestfs_blockdev_setrw (g, device);
12740 suppress_error = 0;
12741 r = guestfs_umount_all (g);
12747 suppress_error = 0;
12748 r = guestfs_lvm_remove_all (g);
12753 char device[] = "/dev/sda";
12754 char lines_0[] = ",";
12760 suppress_error = 0;
12761 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12766 char fstype[] = "ext2";
12767 char device[] = "/dev/sda1";
12769 suppress_error = 0;
12770 r = guestfs_mkfs (g, fstype, device);
12775 char device[] = "/dev/sda1";
12776 char mountpoint[] = "/";
12778 suppress_error = 0;
12779 r = guestfs_mount (g, device, mountpoint);
12783 /* TestOutputFalse for is_file (1) */
12785 char path[] = "/new";
12787 suppress_error = 0;
12788 r = guestfs_mkdir (g, path);
12793 char path[] = "/new";
12795 suppress_error = 0;
12796 r = guestfs_is_file (g, path);
12800 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12807 static int test_exists_0_skip (void)
12811 str = getenv ("SKIP_TEST_EXISTS_0");
12812 if (str && strcmp (str, "1") == 0) return 1;
12813 str = getenv ("SKIP_TEST_EXISTS");
12814 if (str && strcmp (str, "1") == 0) return 1;
12818 static int test_exists_0 (void)
12820 if (test_exists_0_skip ()) {
12821 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12825 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12827 char device[] = "/dev/sda";
12829 suppress_error = 0;
12830 r = guestfs_blockdev_setrw (g, device);
12836 suppress_error = 0;
12837 r = guestfs_umount_all (g);
12843 suppress_error = 0;
12844 r = guestfs_lvm_remove_all (g);
12849 char device[] = "/dev/sda";
12850 char lines_0[] = ",";
12856 suppress_error = 0;
12857 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12862 char fstype[] = "ext2";
12863 char device[] = "/dev/sda1";
12865 suppress_error = 0;
12866 r = guestfs_mkfs (g, fstype, device);
12871 char device[] = "/dev/sda1";
12872 char mountpoint[] = "/";
12874 suppress_error = 0;
12875 r = guestfs_mount (g, device, mountpoint);
12879 /* TestOutputTrue for exists (0) */
12881 char path[] = "/new";
12883 suppress_error = 0;
12884 r = guestfs_touch (g, path);
12889 char path[] = "/new";
12891 suppress_error = 0;
12892 r = guestfs_exists (g, path);
12896 fprintf (stderr, "test_exists_0: expected true, got false\n");
12903 static int test_exists_1_skip (void)
12907 str = getenv ("SKIP_TEST_EXISTS_1");
12908 if (str && strcmp (str, "1") == 0) return 1;
12909 str = getenv ("SKIP_TEST_EXISTS");
12910 if (str && strcmp (str, "1") == 0) return 1;
12914 static int test_exists_1 (void)
12916 if (test_exists_1_skip ()) {
12917 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12921 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12923 char device[] = "/dev/sda";
12925 suppress_error = 0;
12926 r = guestfs_blockdev_setrw (g, device);
12932 suppress_error = 0;
12933 r = guestfs_umount_all (g);
12939 suppress_error = 0;
12940 r = guestfs_lvm_remove_all (g);
12945 char device[] = "/dev/sda";
12946 char lines_0[] = ",";
12952 suppress_error = 0;
12953 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12958 char fstype[] = "ext2";
12959 char device[] = "/dev/sda1";
12961 suppress_error = 0;
12962 r = guestfs_mkfs (g, fstype, device);
12967 char device[] = "/dev/sda1";
12968 char mountpoint[] = "/";
12970 suppress_error = 0;
12971 r = guestfs_mount (g, device, mountpoint);
12975 /* TestOutputTrue for exists (1) */
12977 char path[] = "/new";
12979 suppress_error = 0;
12980 r = guestfs_mkdir (g, path);
12985 char path[] = "/new";
12987 suppress_error = 0;
12988 r = guestfs_exists (g, path);
12992 fprintf (stderr, "test_exists_1: expected true, got false\n");
12999 static int test_mkdir_p_0_skip (void)
13003 str = getenv ("SKIP_TEST_MKDIR_P_0");
13004 if (str && strcmp (str, "1") == 0) return 1;
13005 str = getenv ("SKIP_TEST_MKDIR_P");
13006 if (str && strcmp (str, "1") == 0) return 1;
13010 static int test_mkdir_p_0 (void)
13012 if (test_mkdir_p_0_skip ()) {
13013 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
13017 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
13019 char device[] = "/dev/sda";
13021 suppress_error = 0;
13022 r = guestfs_blockdev_setrw (g, device);
13028 suppress_error = 0;
13029 r = guestfs_umount_all (g);
13035 suppress_error = 0;
13036 r = guestfs_lvm_remove_all (g);
13041 char device[] = "/dev/sda";
13042 char lines_0[] = ",";
13048 suppress_error = 0;
13049 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13054 char fstype[] = "ext2";
13055 char device[] = "/dev/sda1";
13057 suppress_error = 0;
13058 r = guestfs_mkfs (g, fstype, device);
13063 char device[] = "/dev/sda1";
13064 char mountpoint[] = "/";
13066 suppress_error = 0;
13067 r = guestfs_mount (g, device, mountpoint);
13071 /* TestOutputTrue for mkdir_p (0) */
13073 char path[] = "/new/foo/bar";
13075 suppress_error = 0;
13076 r = guestfs_mkdir_p (g, path);
13081 char path[] = "/new/foo/bar";
13083 suppress_error = 0;
13084 r = guestfs_is_dir (g, path);
13088 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
13095 static int test_mkdir_p_1_skip (void)
13099 str = getenv ("SKIP_TEST_MKDIR_P_1");
13100 if (str && strcmp (str, "1") == 0) return 1;
13101 str = getenv ("SKIP_TEST_MKDIR_P");
13102 if (str && strcmp (str, "1") == 0) return 1;
13106 static int test_mkdir_p_1 (void)
13108 if (test_mkdir_p_1_skip ()) {
13109 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
13113 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
13115 char device[] = "/dev/sda";
13117 suppress_error = 0;
13118 r = guestfs_blockdev_setrw (g, device);
13124 suppress_error = 0;
13125 r = guestfs_umount_all (g);
13131 suppress_error = 0;
13132 r = guestfs_lvm_remove_all (g);
13137 char device[] = "/dev/sda";
13138 char lines_0[] = ",";
13144 suppress_error = 0;
13145 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13150 char fstype[] = "ext2";
13151 char device[] = "/dev/sda1";
13153 suppress_error = 0;
13154 r = guestfs_mkfs (g, fstype, device);
13159 char device[] = "/dev/sda1";
13160 char mountpoint[] = "/";
13162 suppress_error = 0;
13163 r = guestfs_mount (g, device, mountpoint);
13167 /* TestOutputTrue for mkdir_p (1) */
13169 char path[] = "/new/foo/bar";
13171 suppress_error = 0;
13172 r = guestfs_mkdir_p (g, path);
13177 char path[] = "/new/foo";
13179 suppress_error = 0;
13180 r = guestfs_is_dir (g, path);
13184 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
13191 static int test_mkdir_p_2_skip (void)
13195 str = getenv ("SKIP_TEST_MKDIR_P_2");
13196 if (str && strcmp (str, "1") == 0) return 1;
13197 str = getenv ("SKIP_TEST_MKDIR_P");
13198 if (str && strcmp (str, "1") == 0) return 1;
13202 static int test_mkdir_p_2 (void)
13204 if (test_mkdir_p_2_skip ()) {
13205 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
13209 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
13211 char device[] = "/dev/sda";
13213 suppress_error = 0;
13214 r = guestfs_blockdev_setrw (g, device);
13220 suppress_error = 0;
13221 r = guestfs_umount_all (g);
13227 suppress_error = 0;
13228 r = guestfs_lvm_remove_all (g);
13233 char device[] = "/dev/sda";
13234 char lines_0[] = ",";
13240 suppress_error = 0;
13241 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13246 char fstype[] = "ext2";
13247 char device[] = "/dev/sda1";
13249 suppress_error = 0;
13250 r = guestfs_mkfs (g, fstype, device);
13255 char device[] = "/dev/sda1";
13256 char mountpoint[] = "/";
13258 suppress_error = 0;
13259 r = guestfs_mount (g, device, mountpoint);
13263 /* TestOutputTrue for mkdir_p (2) */
13265 char path[] = "/new/foo/bar";
13267 suppress_error = 0;
13268 r = guestfs_mkdir_p (g, path);
13273 char path[] = "/new";
13275 suppress_error = 0;
13276 r = guestfs_is_dir (g, path);
13280 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13287 static int test_mkdir_p_3_skip (void)
13291 str = getenv ("SKIP_TEST_MKDIR_P_3");
13292 if (str && strcmp (str, "1") == 0) return 1;
13293 str = getenv ("SKIP_TEST_MKDIR_P");
13294 if (str && strcmp (str, "1") == 0) return 1;
13298 static int test_mkdir_p_3 (void)
13300 if (test_mkdir_p_3_skip ()) {
13301 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13305 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13307 char device[] = "/dev/sda";
13309 suppress_error = 0;
13310 r = guestfs_blockdev_setrw (g, device);
13316 suppress_error = 0;
13317 r = guestfs_umount_all (g);
13323 suppress_error = 0;
13324 r = guestfs_lvm_remove_all (g);
13329 char device[] = "/dev/sda";
13330 char lines_0[] = ",";
13336 suppress_error = 0;
13337 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13342 char fstype[] = "ext2";
13343 char device[] = "/dev/sda1";
13345 suppress_error = 0;
13346 r = guestfs_mkfs (g, fstype, device);
13351 char device[] = "/dev/sda1";
13352 char mountpoint[] = "/";
13354 suppress_error = 0;
13355 r = guestfs_mount (g, device, mountpoint);
13359 /* TestRun for mkdir_p (3) */
13361 char path[] = "/new";
13363 suppress_error = 0;
13364 r = guestfs_mkdir (g, path);
13369 char path[] = "/new";
13371 suppress_error = 0;
13372 r = guestfs_mkdir_p (g, path);
13379 static int test_mkdir_p_4_skip (void)
13383 str = getenv ("SKIP_TEST_MKDIR_P_4");
13384 if (str && strcmp (str, "1") == 0) return 1;
13385 str = getenv ("SKIP_TEST_MKDIR_P");
13386 if (str && strcmp (str, "1") == 0) return 1;
13390 static int test_mkdir_p_4 (void)
13392 if (test_mkdir_p_4_skip ()) {
13393 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13397 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13399 char device[] = "/dev/sda";
13401 suppress_error = 0;
13402 r = guestfs_blockdev_setrw (g, device);
13408 suppress_error = 0;
13409 r = guestfs_umount_all (g);
13415 suppress_error = 0;
13416 r = guestfs_lvm_remove_all (g);
13421 char device[] = "/dev/sda";
13422 char lines_0[] = ",";
13428 suppress_error = 0;
13429 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13434 char fstype[] = "ext2";
13435 char device[] = "/dev/sda1";
13437 suppress_error = 0;
13438 r = guestfs_mkfs (g, fstype, device);
13443 char device[] = "/dev/sda1";
13444 char mountpoint[] = "/";
13446 suppress_error = 0;
13447 r = guestfs_mount (g, device, mountpoint);
13451 /* TestLastFail for mkdir_p (4) */
13453 char path[] = "/new";
13455 suppress_error = 0;
13456 r = guestfs_touch (g, path);
13461 char path[] = "/new";
13463 suppress_error = 1;
13464 r = guestfs_mkdir_p (g, path);
13471 static int test_mkdir_0_skip (void)
13475 str = getenv ("SKIP_TEST_MKDIR_0");
13476 if (str && strcmp (str, "1") == 0) return 1;
13477 str = getenv ("SKIP_TEST_MKDIR");
13478 if (str && strcmp (str, "1") == 0) return 1;
13482 static int test_mkdir_0 (void)
13484 if (test_mkdir_0_skip ()) {
13485 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13489 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13491 char device[] = "/dev/sda";
13493 suppress_error = 0;
13494 r = guestfs_blockdev_setrw (g, device);
13500 suppress_error = 0;
13501 r = guestfs_umount_all (g);
13507 suppress_error = 0;
13508 r = guestfs_lvm_remove_all (g);
13513 char device[] = "/dev/sda";
13514 char lines_0[] = ",";
13520 suppress_error = 0;
13521 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13526 char fstype[] = "ext2";
13527 char device[] = "/dev/sda1";
13529 suppress_error = 0;
13530 r = guestfs_mkfs (g, fstype, device);
13535 char device[] = "/dev/sda1";
13536 char mountpoint[] = "/";
13538 suppress_error = 0;
13539 r = guestfs_mount (g, device, mountpoint);
13543 /* TestOutputTrue for mkdir (0) */
13545 char path[] = "/new";
13547 suppress_error = 0;
13548 r = guestfs_mkdir (g, path);
13553 char path[] = "/new";
13555 suppress_error = 0;
13556 r = guestfs_is_dir (g, path);
13560 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13567 static int test_mkdir_1_skip (void)
13571 str = getenv ("SKIP_TEST_MKDIR_1");
13572 if (str && strcmp (str, "1") == 0) return 1;
13573 str = getenv ("SKIP_TEST_MKDIR");
13574 if (str && strcmp (str, "1") == 0) return 1;
13578 static int test_mkdir_1 (void)
13580 if (test_mkdir_1_skip ()) {
13581 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13585 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13587 char device[] = "/dev/sda";
13589 suppress_error = 0;
13590 r = guestfs_blockdev_setrw (g, device);
13596 suppress_error = 0;
13597 r = guestfs_umount_all (g);
13603 suppress_error = 0;
13604 r = guestfs_lvm_remove_all (g);
13609 char device[] = "/dev/sda";
13610 char lines_0[] = ",";
13616 suppress_error = 0;
13617 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13622 char fstype[] = "ext2";
13623 char device[] = "/dev/sda1";
13625 suppress_error = 0;
13626 r = guestfs_mkfs (g, fstype, device);
13631 char device[] = "/dev/sda1";
13632 char mountpoint[] = "/";
13634 suppress_error = 0;
13635 r = guestfs_mount (g, device, mountpoint);
13639 /* TestLastFail for mkdir (1) */
13641 char path[] = "/new/foo/bar";
13643 suppress_error = 1;
13644 r = guestfs_mkdir (g, path);
13651 static int test_rm_rf_0_skip (void)
13655 str = getenv ("SKIP_TEST_RM_RF_0");
13656 if (str && strcmp (str, "1") == 0) return 1;
13657 str = getenv ("SKIP_TEST_RM_RF");
13658 if (str && strcmp (str, "1") == 0) return 1;
13662 static int test_rm_rf_0 (void)
13664 if (test_rm_rf_0_skip ()) {
13665 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13669 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13671 char device[] = "/dev/sda";
13673 suppress_error = 0;
13674 r = guestfs_blockdev_setrw (g, device);
13680 suppress_error = 0;
13681 r = guestfs_umount_all (g);
13687 suppress_error = 0;
13688 r = guestfs_lvm_remove_all (g);
13693 char device[] = "/dev/sda";
13694 char lines_0[] = ",";
13700 suppress_error = 0;
13701 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13706 char fstype[] = "ext2";
13707 char device[] = "/dev/sda1";
13709 suppress_error = 0;
13710 r = guestfs_mkfs (g, fstype, device);
13715 char device[] = "/dev/sda1";
13716 char mountpoint[] = "/";
13718 suppress_error = 0;
13719 r = guestfs_mount (g, device, mountpoint);
13723 /* TestOutputFalse for rm_rf (0) */
13725 char path[] = "/new";
13727 suppress_error = 0;
13728 r = guestfs_mkdir (g, path);
13733 char path[] = "/new/foo";
13735 suppress_error = 0;
13736 r = guestfs_mkdir (g, path);
13741 char path[] = "/new/foo/bar";
13743 suppress_error = 0;
13744 r = guestfs_touch (g, path);
13749 char path[] = "/new";
13751 suppress_error = 0;
13752 r = guestfs_rm_rf (g, path);
13757 char path[] = "/new";
13759 suppress_error = 0;
13760 r = guestfs_exists (g, path);
13764 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13771 static int test_rmdir_0_skip (void)
13775 str = getenv ("SKIP_TEST_RMDIR_0");
13776 if (str && strcmp (str, "1") == 0) return 1;
13777 str = getenv ("SKIP_TEST_RMDIR");
13778 if (str && strcmp (str, "1") == 0) return 1;
13782 static int test_rmdir_0 (void)
13784 if (test_rmdir_0_skip ()) {
13785 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13789 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13791 char device[] = "/dev/sda";
13793 suppress_error = 0;
13794 r = guestfs_blockdev_setrw (g, device);
13800 suppress_error = 0;
13801 r = guestfs_umount_all (g);
13807 suppress_error = 0;
13808 r = guestfs_lvm_remove_all (g);
13813 char device[] = "/dev/sda";
13814 char lines_0[] = ",";
13820 suppress_error = 0;
13821 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13826 char fstype[] = "ext2";
13827 char device[] = "/dev/sda1";
13829 suppress_error = 0;
13830 r = guestfs_mkfs (g, fstype, device);
13835 char device[] = "/dev/sda1";
13836 char mountpoint[] = "/";
13838 suppress_error = 0;
13839 r = guestfs_mount (g, device, mountpoint);
13843 /* TestRun for rmdir (0) */
13845 char path[] = "/new";
13847 suppress_error = 0;
13848 r = guestfs_mkdir (g, path);
13853 char path[] = "/new";
13855 suppress_error = 0;
13856 r = guestfs_rmdir (g, path);
13863 static int test_rmdir_1_skip (void)
13867 str = getenv ("SKIP_TEST_RMDIR_1");
13868 if (str && strcmp (str, "1") == 0) return 1;
13869 str = getenv ("SKIP_TEST_RMDIR");
13870 if (str && strcmp (str, "1") == 0) return 1;
13874 static int test_rmdir_1 (void)
13876 if (test_rmdir_1_skip ()) {
13877 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13881 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13883 char device[] = "/dev/sda";
13885 suppress_error = 0;
13886 r = guestfs_blockdev_setrw (g, device);
13892 suppress_error = 0;
13893 r = guestfs_umount_all (g);
13899 suppress_error = 0;
13900 r = guestfs_lvm_remove_all (g);
13905 char device[] = "/dev/sda";
13906 char lines_0[] = ",";
13912 suppress_error = 0;
13913 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13918 char fstype[] = "ext2";
13919 char device[] = "/dev/sda1";
13921 suppress_error = 0;
13922 r = guestfs_mkfs (g, fstype, device);
13927 char device[] = "/dev/sda1";
13928 char mountpoint[] = "/";
13930 suppress_error = 0;
13931 r = guestfs_mount (g, device, mountpoint);
13935 /* TestLastFail for rmdir (1) */
13937 char path[] = "/new";
13939 suppress_error = 1;
13940 r = guestfs_rmdir (g, path);
13947 static int test_rmdir_2_skip (void)
13951 str = getenv ("SKIP_TEST_RMDIR_2");
13952 if (str && strcmp (str, "1") == 0) return 1;
13953 str = getenv ("SKIP_TEST_RMDIR");
13954 if (str && strcmp (str, "1") == 0) return 1;
13958 static int test_rmdir_2 (void)
13960 if (test_rmdir_2_skip ()) {
13961 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13965 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13967 char device[] = "/dev/sda";
13969 suppress_error = 0;
13970 r = guestfs_blockdev_setrw (g, device);
13976 suppress_error = 0;
13977 r = guestfs_umount_all (g);
13983 suppress_error = 0;
13984 r = guestfs_lvm_remove_all (g);
13989 char device[] = "/dev/sda";
13990 char lines_0[] = ",";
13996 suppress_error = 0;
13997 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14002 char fstype[] = "ext2";
14003 char device[] = "/dev/sda1";
14005 suppress_error = 0;
14006 r = guestfs_mkfs (g, fstype, device);
14011 char device[] = "/dev/sda1";
14012 char mountpoint[] = "/";
14014 suppress_error = 0;
14015 r = guestfs_mount (g, device, mountpoint);
14019 /* TestLastFail for rmdir (2) */
14021 char path[] = "/new";
14023 suppress_error = 0;
14024 r = guestfs_touch (g, path);
14029 char path[] = "/new";
14031 suppress_error = 1;
14032 r = guestfs_rmdir (g, path);
14039 static int test_rm_0_skip (void)
14043 str = getenv ("SKIP_TEST_RM_0");
14044 if (str && strcmp (str, "1") == 0) return 1;
14045 str = getenv ("SKIP_TEST_RM");
14046 if (str && strcmp (str, "1") == 0) return 1;
14050 static int test_rm_0 (void)
14052 if (test_rm_0_skip ()) {
14053 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
14057 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
14059 char device[] = "/dev/sda";
14061 suppress_error = 0;
14062 r = guestfs_blockdev_setrw (g, device);
14068 suppress_error = 0;
14069 r = guestfs_umount_all (g);
14075 suppress_error = 0;
14076 r = guestfs_lvm_remove_all (g);
14081 char device[] = "/dev/sda";
14082 char lines_0[] = ",";
14088 suppress_error = 0;
14089 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14094 char fstype[] = "ext2";
14095 char device[] = "/dev/sda1";
14097 suppress_error = 0;
14098 r = guestfs_mkfs (g, fstype, device);
14103 char device[] = "/dev/sda1";
14104 char mountpoint[] = "/";
14106 suppress_error = 0;
14107 r = guestfs_mount (g, device, mountpoint);
14111 /* TestRun for rm (0) */
14113 char path[] = "/new";
14115 suppress_error = 0;
14116 r = guestfs_touch (g, path);
14121 char path[] = "/new";
14123 suppress_error = 0;
14124 r = guestfs_rm (g, path);
14131 static int test_rm_1_skip (void)
14135 str = getenv ("SKIP_TEST_RM_1");
14136 if (str && strcmp (str, "1") == 0) return 1;
14137 str = getenv ("SKIP_TEST_RM");
14138 if (str && strcmp (str, "1") == 0) return 1;
14142 static int test_rm_1 (void)
14144 if (test_rm_1_skip ()) {
14145 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
14149 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
14151 char device[] = "/dev/sda";
14153 suppress_error = 0;
14154 r = guestfs_blockdev_setrw (g, device);
14160 suppress_error = 0;
14161 r = guestfs_umount_all (g);
14167 suppress_error = 0;
14168 r = guestfs_lvm_remove_all (g);
14173 char device[] = "/dev/sda";
14174 char lines_0[] = ",";
14180 suppress_error = 0;
14181 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14186 char fstype[] = "ext2";
14187 char device[] = "/dev/sda1";
14189 suppress_error = 0;
14190 r = guestfs_mkfs (g, fstype, device);
14195 char device[] = "/dev/sda1";
14196 char mountpoint[] = "/";
14198 suppress_error = 0;
14199 r = guestfs_mount (g, device, mountpoint);
14203 /* TestLastFail for rm (1) */
14205 char path[] = "/new";
14207 suppress_error = 1;
14208 r = guestfs_rm (g, path);
14215 static int test_rm_2_skip (void)
14219 str = getenv ("SKIP_TEST_RM_2");
14220 if (str && strcmp (str, "1") == 0) return 1;
14221 str = getenv ("SKIP_TEST_RM");
14222 if (str && strcmp (str, "1") == 0) return 1;
14226 static int test_rm_2 (void)
14228 if (test_rm_2_skip ()) {
14229 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
14233 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
14235 char device[] = "/dev/sda";
14237 suppress_error = 0;
14238 r = guestfs_blockdev_setrw (g, device);
14244 suppress_error = 0;
14245 r = guestfs_umount_all (g);
14251 suppress_error = 0;
14252 r = guestfs_lvm_remove_all (g);
14257 char device[] = "/dev/sda";
14258 char lines_0[] = ",";
14264 suppress_error = 0;
14265 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14270 char fstype[] = "ext2";
14271 char device[] = "/dev/sda1";
14273 suppress_error = 0;
14274 r = guestfs_mkfs (g, fstype, device);
14279 char device[] = "/dev/sda1";
14280 char mountpoint[] = "/";
14282 suppress_error = 0;
14283 r = guestfs_mount (g, device, mountpoint);
14287 /* TestLastFail for rm (2) */
14289 char path[] = "/new";
14291 suppress_error = 0;
14292 r = guestfs_mkdir (g, path);
14297 char path[] = "/new";
14299 suppress_error = 1;
14300 r = guestfs_rm (g, path);
14307 static int test_read_lines_0_skip (void)
14311 str = getenv ("SKIP_TEST_READ_LINES_0");
14312 if (str && strcmp (str, "1") == 0) return 1;
14313 str = getenv ("SKIP_TEST_READ_LINES");
14314 if (str && strcmp (str, "1") == 0) return 1;
14318 static int test_read_lines_0 (void)
14320 if (test_read_lines_0_skip ()) {
14321 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14325 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14327 char device[] = "/dev/sda";
14329 suppress_error = 0;
14330 r = guestfs_blockdev_setrw (g, device);
14336 suppress_error = 0;
14337 r = guestfs_umount_all (g);
14343 suppress_error = 0;
14344 r = guestfs_lvm_remove_all (g);
14349 char device[] = "/dev/sda";
14350 char lines_0[] = ",";
14356 suppress_error = 0;
14357 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14362 char fstype[] = "ext2";
14363 char device[] = "/dev/sda1";
14365 suppress_error = 0;
14366 r = guestfs_mkfs (g, fstype, device);
14371 char device[] = "/dev/sda1";
14372 char mountpoint[] = "/";
14374 suppress_error = 0;
14375 r = guestfs_mount (g, device, mountpoint);
14379 /* TestOutputList for read_lines (0) */
14381 char path[] = "/new";
14382 char content[] = "line1\r\nline2\nline3";
14384 suppress_error = 0;
14385 r = guestfs_write_file (g, path, content, 0);
14390 char path[] = "/new";
14393 suppress_error = 0;
14394 r = guestfs_read_lines (g, path);
14398 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14403 char expected[] = "line1";
14404 if (strcmp (r[0], expected) != 0) {
14405 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14410 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14415 char expected[] = "line2";
14416 if (strcmp (r[1], expected) != 0) {
14417 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14422 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14427 char expected[] = "line3";
14428 if (strcmp (r[2], expected) != 0) {
14429 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14433 if (r[3] != NULL) {
14434 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14438 for (i = 0; r[i] != NULL; ++i)
14445 static int test_read_lines_1_skip (void)
14449 str = getenv ("SKIP_TEST_READ_LINES_1");
14450 if (str && strcmp (str, "1") == 0) return 1;
14451 str = getenv ("SKIP_TEST_READ_LINES");
14452 if (str && strcmp (str, "1") == 0) return 1;
14456 static int test_read_lines_1 (void)
14458 if (test_read_lines_1_skip ()) {
14459 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14463 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14465 char device[] = "/dev/sda";
14467 suppress_error = 0;
14468 r = guestfs_blockdev_setrw (g, device);
14474 suppress_error = 0;
14475 r = guestfs_umount_all (g);
14481 suppress_error = 0;
14482 r = guestfs_lvm_remove_all (g);
14487 char device[] = "/dev/sda";
14488 char lines_0[] = ",";
14494 suppress_error = 0;
14495 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14500 char fstype[] = "ext2";
14501 char device[] = "/dev/sda1";
14503 suppress_error = 0;
14504 r = guestfs_mkfs (g, fstype, device);
14509 char device[] = "/dev/sda1";
14510 char mountpoint[] = "/";
14512 suppress_error = 0;
14513 r = guestfs_mount (g, device, mountpoint);
14517 /* TestOutputList for read_lines (1) */
14519 char path[] = "/new";
14520 char content[] = "";
14522 suppress_error = 0;
14523 r = guestfs_write_file (g, path, content, 0);
14528 char path[] = "/new";
14531 suppress_error = 0;
14532 r = guestfs_read_lines (g, path);
14535 if (r[0] != NULL) {
14536 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14540 for (i = 0; r[i] != NULL; ++i)
14547 static int test_lvs_0_skip (void)
14551 str = getenv ("SKIP_TEST_LVS_0");
14552 if (str && strcmp (str, "1") == 0) return 1;
14553 str = getenv ("SKIP_TEST_LVS");
14554 if (str && strcmp (str, "1") == 0) return 1;
14558 static int test_lvs_0 (void)
14560 if (test_lvs_0_skip ()) {
14561 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14565 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
14567 char device[] = "/dev/sda";
14569 suppress_error = 0;
14570 r = guestfs_blockdev_setrw (g, device);
14576 suppress_error = 0;
14577 r = guestfs_umount_all (g);
14583 suppress_error = 0;
14584 r = guestfs_lvm_remove_all (g);
14589 char device[] = "/dev/sda";
14590 char lines_0[] = ",";
14596 suppress_error = 0;
14597 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14602 char device[] = "/dev/sda1";
14604 suppress_error = 0;
14605 r = guestfs_pvcreate (g, device);
14610 char volgroup[] = "VG";
14611 char physvols_0[] = "/dev/sda1";
14612 char *physvols[] = {
14617 suppress_error = 0;
14618 r = guestfs_vgcreate (g, volgroup, physvols);
14623 char logvol[] = "LV";
14624 char volgroup[] = "VG";
14626 suppress_error = 0;
14627 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14632 char fstype[] = "ext2";
14633 char device[] = "/dev/VG/LV";
14635 suppress_error = 0;
14636 r = guestfs_mkfs (g, fstype, device);
14641 char device[] = "/dev/VG/LV";
14642 char mountpoint[] = "/";
14644 suppress_error = 0;
14645 r = guestfs_mount (g, device, mountpoint);
14649 /* TestOutputList for lvs (0) */
14653 suppress_error = 0;
14654 r = guestfs_lvs (g);
14658 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14663 char expected[] = "/dev/VG/LV";
14664 if (strcmp (r[0], expected) != 0) {
14665 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14669 if (r[1] != NULL) {
14670 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14674 for (i = 0; r[i] != NULL; ++i)
14681 static int test_lvs_1_skip (void)
14685 str = getenv ("SKIP_TEST_LVS_1");
14686 if (str && strcmp (str, "1") == 0) return 1;
14687 str = getenv ("SKIP_TEST_LVS");
14688 if (str && strcmp (str, "1") == 0) return 1;
14692 static int test_lvs_1 (void)
14694 if (test_lvs_1_skip ()) {
14695 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14699 /* InitNone|InitEmpty for test_lvs_1 */
14701 char device[] = "/dev/sda";
14703 suppress_error = 0;
14704 r = guestfs_blockdev_setrw (g, device);
14710 suppress_error = 0;
14711 r = guestfs_umount_all (g);
14717 suppress_error = 0;
14718 r = guestfs_lvm_remove_all (g);
14722 /* TestOutputList for lvs (1) */
14724 char device[] = "/dev/sda";
14725 char lines_0[] = ",10";
14726 char lines_1[] = ",20";
14727 char lines_2[] = ",";
14735 suppress_error = 0;
14736 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14741 char device[] = "/dev/sda1";
14743 suppress_error = 0;
14744 r = guestfs_pvcreate (g, device);
14749 char device[] = "/dev/sda2";
14751 suppress_error = 0;
14752 r = guestfs_pvcreate (g, device);
14757 char device[] = "/dev/sda3";
14759 suppress_error = 0;
14760 r = guestfs_pvcreate (g, device);
14765 char volgroup[] = "VG1";
14766 char physvols_0[] = "/dev/sda1";
14767 char physvols_1[] = "/dev/sda2";
14768 char *physvols[] = {
14774 suppress_error = 0;
14775 r = guestfs_vgcreate (g, volgroup, physvols);
14780 char volgroup[] = "VG2";
14781 char physvols_0[] = "/dev/sda3";
14782 char *physvols[] = {
14787 suppress_error = 0;
14788 r = guestfs_vgcreate (g, volgroup, physvols);
14793 char logvol[] = "LV1";
14794 char volgroup[] = "VG1";
14796 suppress_error = 0;
14797 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14802 char logvol[] = "LV2";
14803 char volgroup[] = "VG1";
14805 suppress_error = 0;
14806 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14811 char logvol[] = "LV3";
14812 char volgroup[] = "VG2";
14814 suppress_error = 0;
14815 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14822 suppress_error = 0;
14823 r = guestfs_lvs (g);
14827 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14832 char expected[] = "/dev/VG1/LV1";
14833 if (strcmp (r[0], expected) != 0) {
14834 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14839 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14844 char expected[] = "/dev/VG1/LV2";
14845 if (strcmp (r[1], expected) != 0) {
14846 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14851 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14856 char expected[] = "/dev/VG2/LV3";
14857 if (strcmp (r[2], expected) != 0) {
14858 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14862 if (r[3] != NULL) {
14863 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14867 for (i = 0; r[i] != NULL; ++i)
14874 static int test_vgs_0_skip (void)
14878 str = getenv ("SKIP_TEST_VGS_0");
14879 if (str && strcmp (str, "1") == 0) return 1;
14880 str = getenv ("SKIP_TEST_VGS");
14881 if (str && strcmp (str, "1") == 0) return 1;
14885 static int test_vgs_0 (void)
14887 if (test_vgs_0_skip ()) {
14888 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14892 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14894 char device[] = "/dev/sda";
14896 suppress_error = 0;
14897 r = guestfs_blockdev_setrw (g, device);
14903 suppress_error = 0;
14904 r = guestfs_umount_all (g);
14910 suppress_error = 0;
14911 r = guestfs_lvm_remove_all (g);
14916 char device[] = "/dev/sda";
14917 char lines_0[] = ",";
14923 suppress_error = 0;
14924 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14929 char device[] = "/dev/sda1";
14931 suppress_error = 0;
14932 r = guestfs_pvcreate (g, device);
14937 char volgroup[] = "VG";
14938 char physvols_0[] = "/dev/sda1";
14939 char *physvols[] = {
14944 suppress_error = 0;
14945 r = guestfs_vgcreate (g, volgroup, physvols);
14950 char logvol[] = "LV";
14951 char volgroup[] = "VG";
14953 suppress_error = 0;
14954 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14959 char fstype[] = "ext2";
14960 char device[] = "/dev/VG/LV";
14962 suppress_error = 0;
14963 r = guestfs_mkfs (g, fstype, device);
14968 char device[] = "/dev/VG/LV";
14969 char mountpoint[] = "/";
14971 suppress_error = 0;
14972 r = guestfs_mount (g, device, mountpoint);
14976 /* TestOutputList for vgs (0) */
14980 suppress_error = 0;
14981 r = guestfs_vgs (g);
14985 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14990 char expected[] = "VG";
14991 if (strcmp (r[0], expected) != 0) {
14992 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14996 if (r[1] != NULL) {
14997 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
15001 for (i = 0; r[i] != NULL; ++i)
15008 static int test_vgs_1_skip (void)
15012 str = getenv ("SKIP_TEST_VGS_1");
15013 if (str && strcmp (str, "1") == 0) return 1;
15014 str = getenv ("SKIP_TEST_VGS");
15015 if (str && strcmp (str, "1") == 0) return 1;
15019 static int test_vgs_1 (void)
15021 if (test_vgs_1_skip ()) {
15022 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
15026 /* InitNone|InitEmpty for test_vgs_1 */
15028 char device[] = "/dev/sda";
15030 suppress_error = 0;
15031 r = guestfs_blockdev_setrw (g, device);
15037 suppress_error = 0;
15038 r = guestfs_umount_all (g);
15044 suppress_error = 0;
15045 r = guestfs_lvm_remove_all (g);
15049 /* TestOutputList for vgs (1) */
15051 char device[] = "/dev/sda";
15052 char lines_0[] = ",10";
15053 char lines_1[] = ",20";
15054 char lines_2[] = ",";
15062 suppress_error = 0;
15063 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15068 char device[] = "/dev/sda1";
15070 suppress_error = 0;
15071 r = guestfs_pvcreate (g, device);
15076 char device[] = "/dev/sda2";
15078 suppress_error = 0;
15079 r = guestfs_pvcreate (g, device);
15084 char device[] = "/dev/sda3";
15086 suppress_error = 0;
15087 r = guestfs_pvcreate (g, device);
15092 char volgroup[] = "VG1";
15093 char physvols_0[] = "/dev/sda1";
15094 char physvols_1[] = "/dev/sda2";
15095 char *physvols[] = {
15101 suppress_error = 0;
15102 r = guestfs_vgcreate (g, volgroup, physvols);
15107 char volgroup[] = "VG2";
15108 char physvols_0[] = "/dev/sda3";
15109 char *physvols[] = {
15114 suppress_error = 0;
15115 r = guestfs_vgcreate (g, volgroup, physvols);
15122 suppress_error = 0;
15123 r = guestfs_vgs (g);
15127 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15132 char expected[] = "VG1";
15133 if (strcmp (r[0], expected) != 0) {
15134 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15139 fprintf (stderr, "test_vgs_1: short list returned from command\n");
15144 char expected[] = "VG2";
15145 if (strcmp (r[1], expected) != 0) {
15146 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15150 if (r[2] != NULL) {
15151 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
15155 for (i = 0; r[i] != NULL; ++i)
15162 static int test_pvs_0_skip (void)
15166 str = getenv ("SKIP_TEST_PVS_0");
15167 if (str && strcmp (str, "1") == 0) return 1;
15168 str = getenv ("SKIP_TEST_PVS");
15169 if (str && strcmp (str, "1") == 0) return 1;
15173 static int test_pvs_0 (void)
15175 if (test_pvs_0_skip ()) {
15176 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
15180 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
15182 char device[] = "/dev/sda";
15184 suppress_error = 0;
15185 r = guestfs_blockdev_setrw (g, device);
15191 suppress_error = 0;
15192 r = guestfs_umount_all (g);
15198 suppress_error = 0;
15199 r = guestfs_lvm_remove_all (g);
15204 char device[] = "/dev/sda";
15205 char lines_0[] = ",";
15211 suppress_error = 0;
15212 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15217 char device[] = "/dev/sda1";
15219 suppress_error = 0;
15220 r = guestfs_pvcreate (g, device);
15225 char volgroup[] = "VG";
15226 char physvols_0[] = "/dev/sda1";
15227 char *physvols[] = {
15232 suppress_error = 0;
15233 r = guestfs_vgcreate (g, volgroup, physvols);
15238 char logvol[] = "LV";
15239 char volgroup[] = "VG";
15241 suppress_error = 0;
15242 r = guestfs_lvcreate (g, logvol, volgroup, 8);
15247 char fstype[] = "ext2";
15248 char device[] = "/dev/VG/LV";
15250 suppress_error = 0;
15251 r = guestfs_mkfs (g, fstype, device);
15256 char device[] = "/dev/VG/LV";
15257 char mountpoint[] = "/";
15259 suppress_error = 0;
15260 r = guestfs_mount (g, device, mountpoint);
15264 /* TestOutputListOfDevices for pvs (0) */
15268 suppress_error = 0;
15269 r = guestfs_pvs (g);
15273 fprintf (stderr, "test_pvs_0: short list returned from command\n");
15278 char expected[] = "/dev/sda1";
15280 if (strcmp (r[0], expected) != 0) {
15281 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15285 if (r[1] != NULL) {
15286 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15290 for (i = 0; r[i] != NULL; ++i)
15297 static int test_pvs_1_skip (void)
15301 str = getenv ("SKIP_TEST_PVS_1");
15302 if (str && strcmp (str, "1") == 0) return 1;
15303 str = getenv ("SKIP_TEST_PVS");
15304 if (str && strcmp (str, "1") == 0) return 1;
15308 static int test_pvs_1 (void)
15310 if (test_pvs_1_skip ()) {
15311 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15315 /* InitNone|InitEmpty for test_pvs_1 */
15317 char device[] = "/dev/sda";
15319 suppress_error = 0;
15320 r = guestfs_blockdev_setrw (g, device);
15326 suppress_error = 0;
15327 r = guestfs_umount_all (g);
15333 suppress_error = 0;
15334 r = guestfs_lvm_remove_all (g);
15338 /* TestOutputListOfDevices for pvs (1) */
15340 char device[] = "/dev/sda";
15341 char lines_0[] = ",10";
15342 char lines_1[] = ",20";
15343 char lines_2[] = ",";
15351 suppress_error = 0;
15352 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15357 char device[] = "/dev/sda1";
15359 suppress_error = 0;
15360 r = guestfs_pvcreate (g, device);
15365 char device[] = "/dev/sda2";
15367 suppress_error = 0;
15368 r = guestfs_pvcreate (g, device);
15373 char device[] = "/dev/sda3";
15375 suppress_error = 0;
15376 r = guestfs_pvcreate (g, device);
15383 suppress_error = 0;
15384 r = guestfs_pvs (g);
15388 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15393 char expected[] = "/dev/sda1";
15395 if (strcmp (r[0], expected) != 0) {
15396 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15401 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15406 char expected[] = "/dev/sda2";
15408 if (strcmp (r[1], expected) != 0) {
15409 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15414 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15419 char expected[] = "/dev/sda3";
15421 if (strcmp (r[2], expected) != 0) {
15422 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15426 if (r[3] != NULL) {
15427 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15431 for (i = 0; r[i] != NULL; ++i)
15438 static int test_list_partitions_0_skip (void)
15442 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15443 if (str && strcmp (str, "1") == 0) return 1;
15444 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15445 if (str && strcmp (str, "1") == 0) return 1;
15449 static int test_list_partitions_0 (void)
15451 if (test_list_partitions_0_skip ()) {
15452 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15456 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15458 char device[] = "/dev/sda";
15460 suppress_error = 0;
15461 r = guestfs_blockdev_setrw (g, device);
15467 suppress_error = 0;
15468 r = guestfs_umount_all (g);
15474 suppress_error = 0;
15475 r = guestfs_lvm_remove_all (g);
15480 char device[] = "/dev/sda";
15481 char lines_0[] = ",";
15487 suppress_error = 0;
15488 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15493 char fstype[] = "ext2";
15494 char device[] = "/dev/sda1";
15496 suppress_error = 0;
15497 r = guestfs_mkfs (g, fstype, device);
15502 char device[] = "/dev/sda1";
15503 char mountpoint[] = "/";
15505 suppress_error = 0;
15506 r = guestfs_mount (g, device, mountpoint);
15510 /* TestOutputListOfDevices for list_partitions (0) */
15514 suppress_error = 0;
15515 r = guestfs_list_partitions (g);
15519 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15524 char expected[] = "/dev/sda1";
15526 if (strcmp (r[0], expected) != 0) {
15527 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15531 if (r[1] != NULL) {
15532 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15536 for (i = 0; r[i] != NULL; ++i)
15543 static int test_list_partitions_1_skip (void)
15547 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15548 if (str && strcmp (str, "1") == 0) return 1;
15549 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15550 if (str && strcmp (str, "1") == 0) return 1;
15554 static int test_list_partitions_1 (void)
15556 if (test_list_partitions_1_skip ()) {
15557 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15561 /* InitNone|InitEmpty for test_list_partitions_1 */
15563 char device[] = "/dev/sda";
15565 suppress_error = 0;
15566 r = guestfs_blockdev_setrw (g, device);
15572 suppress_error = 0;
15573 r = guestfs_umount_all (g);
15579 suppress_error = 0;
15580 r = guestfs_lvm_remove_all (g);
15584 /* TestOutputListOfDevices for list_partitions (1) */
15586 char device[] = "/dev/sda";
15587 char lines_0[] = ",10";
15588 char lines_1[] = ",20";
15589 char lines_2[] = ",";
15597 suppress_error = 0;
15598 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15605 suppress_error = 0;
15606 r = guestfs_list_partitions (g);
15610 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15615 char expected[] = "/dev/sda1";
15617 if (strcmp (r[0], expected) != 0) {
15618 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15623 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15628 char expected[] = "/dev/sda2";
15630 if (strcmp (r[1], expected) != 0) {
15631 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15636 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15641 char expected[] = "/dev/sda3";
15643 if (strcmp (r[2], expected) != 0) {
15644 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15648 if (r[3] != NULL) {
15649 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15653 for (i = 0; r[i] != NULL; ++i)
15660 static int test_list_devices_0_skip (void)
15664 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15665 if (str && strcmp (str, "1") == 0) return 1;
15666 str = getenv ("SKIP_TEST_LIST_DEVICES");
15667 if (str && strcmp (str, "1") == 0) return 1;
15671 static int test_list_devices_0 (void)
15673 if (test_list_devices_0_skip ()) {
15674 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15678 /* InitNone|InitEmpty for test_list_devices_0 */
15680 char device[] = "/dev/sda";
15682 suppress_error = 0;
15683 r = guestfs_blockdev_setrw (g, device);
15689 suppress_error = 0;
15690 r = guestfs_umount_all (g);
15696 suppress_error = 0;
15697 r = guestfs_lvm_remove_all (g);
15701 /* TestOutputListOfDevices for list_devices (0) */
15705 suppress_error = 0;
15706 r = guestfs_list_devices (g);
15710 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15715 char expected[] = "/dev/sda";
15717 if (strcmp (r[0], expected) != 0) {
15718 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15723 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15728 char expected[] = "/dev/sdb";
15730 if (strcmp (r[1], expected) != 0) {
15731 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15736 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15741 char expected[] = "/dev/sdc";
15743 if (strcmp (r[2], expected) != 0) {
15744 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15749 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15754 char expected[] = "/dev/sdd";
15756 if (strcmp (r[3], expected) != 0) {
15757 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15761 if (r[4] != NULL) {
15762 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15766 for (i = 0; r[i] != NULL; ++i)
15773 static int test_ls_0_skip (void)
15777 str = getenv ("SKIP_TEST_LS_0");
15778 if (str && strcmp (str, "1") == 0) return 1;
15779 str = getenv ("SKIP_TEST_LS");
15780 if (str && strcmp (str, "1") == 0) return 1;
15784 static int test_ls_0 (void)
15786 if (test_ls_0_skip ()) {
15787 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15791 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15793 char device[] = "/dev/sda";
15795 suppress_error = 0;
15796 r = guestfs_blockdev_setrw (g, device);
15802 suppress_error = 0;
15803 r = guestfs_umount_all (g);
15809 suppress_error = 0;
15810 r = guestfs_lvm_remove_all (g);
15815 char device[] = "/dev/sda";
15816 char lines_0[] = ",";
15822 suppress_error = 0;
15823 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15828 char fstype[] = "ext2";
15829 char device[] = "/dev/sda1";
15831 suppress_error = 0;
15832 r = guestfs_mkfs (g, fstype, device);
15837 char device[] = "/dev/sda1";
15838 char mountpoint[] = "/";
15840 suppress_error = 0;
15841 r = guestfs_mount (g, device, mountpoint);
15845 /* TestOutputList for ls (0) */
15847 char path[] = "/new";
15849 suppress_error = 0;
15850 r = guestfs_touch (g, path);
15855 char path[] = "/newer";
15857 suppress_error = 0;
15858 r = guestfs_touch (g, path);
15863 char path[] = "/newest";
15865 suppress_error = 0;
15866 r = guestfs_touch (g, path);
15871 char directory[] = "/";
15874 suppress_error = 0;
15875 r = guestfs_ls (g, directory);
15879 fprintf (stderr, "test_ls_0: short list returned from command\n");
15884 char expected[] = "lost+found";
15885 if (strcmp (r[0], expected) != 0) {
15886 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15891 fprintf (stderr, "test_ls_0: short list returned from command\n");
15896 char expected[] = "new";
15897 if (strcmp (r[1], expected) != 0) {
15898 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15903 fprintf (stderr, "test_ls_0: short list returned from command\n");
15908 char expected[] = "newer";
15909 if (strcmp (r[2], expected) != 0) {
15910 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15915 fprintf (stderr, "test_ls_0: short list returned from command\n");
15920 char expected[] = "newest";
15921 if (strcmp (r[3], expected) != 0) {
15922 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15926 if (r[4] != NULL) {
15927 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15931 for (i = 0; r[i] != NULL; ++i)
15938 static int test_cat_0_skip (void)
15942 str = getenv ("SKIP_TEST_CAT_0");
15943 if (str && strcmp (str, "1") == 0) return 1;
15944 str = getenv ("SKIP_TEST_CAT");
15945 if (str && strcmp (str, "1") == 0) return 1;
15949 static int test_cat_0 (void)
15951 if (test_cat_0_skip ()) {
15952 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15956 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15958 char device[] = "/dev/sda";
15960 suppress_error = 0;
15961 r = guestfs_blockdev_setrw (g, device);
15967 suppress_error = 0;
15968 r = guestfs_umount_all (g);
15974 suppress_error = 0;
15975 r = guestfs_lvm_remove_all (g);
15980 char device[] = "/dev/sda";
15981 char lines_0[] = ",";
15987 suppress_error = 0;
15988 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15993 char fstype[] = "ext2";
15994 char device[] = "/dev/sda1";
15996 suppress_error = 0;
15997 r = guestfs_mkfs (g, fstype, device);
16002 char device[] = "/dev/sda1";
16003 char mountpoint[] = "/";
16005 suppress_error = 0;
16006 r = guestfs_mount (g, device, mountpoint);
16010 /* TestOutput for cat (0) */
16011 char expected[] = "new file contents";
16013 char path[] = "/new";
16014 char content[] = "new file contents";
16016 suppress_error = 0;
16017 r = guestfs_write_file (g, path, content, 0);
16022 char path[] = "/new";
16024 suppress_error = 0;
16025 r = guestfs_cat (g, path);
16028 if (strcmp (r, expected) != 0) {
16029 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
16037 static int test_touch_0_skip (void)
16041 str = getenv ("SKIP_TEST_TOUCH_0");
16042 if (str && strcmp (str, "1") == 0) return 1;
16043 str = getenv ("SKIP_TEST_TOUCH");
16044 if (str && strcmp (str, "1") == 0) return 1;
16048 static int test_touch_0 (void)
16050 if (test_touch_0_skip ()) {
16051 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
16055 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
16057 char device[] = "/dev/sda";
16059 suppress_error = 0;
16060 r = guestfs_blockdev_setrw (g, device);
16066 suppress_error = 0;
16067 r = guestfs_umount_all (g);
16073 suppress_error = 0;
16074 r = guestfs_lvm_remove_all (g);
16079 char device[] = "/dev/sda";
16080 char lines_0[] = ",";
16086 suppress_error = 0;
16087 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16092 char fstype[] = "ext2";
16093 char device[] = "/dev/sda1";
16095 suppress_error = 0;
16096 r = guestfs_mkfs (g, fstype, device);
16101 char device[] = "/dev/sda1";
16102 char mountpoint[] = "/";
16104 suppress_error = 0;
16105 r = guestfs_mount (g, device, mountpoint);
16109 /* TestOutputTrue for touch (0) */
16111 char path[] = "/new";
16113 suppress_error = 0;
16114 r = guestfs_touch (g, path);
16119 char path[] = "/new";
16121 suppress_error = 0;
16122 r = guestfs_exists (g, path);
16126 fprintf (stderr, "test_touch_0: expected true, got false\n");
16133 static int test_sync_0_skip (void)
16137 str = getenv ("SKIP_TEST_SYNC_0");
16138 if (str && strcmp (str, "1") == 0) return 1;
16139 str = getenv ("SKIP_TEST_SYNC");
16140 if (str && strcmp (str, "1") == 0) return 1;
16144 static int test_sync_0 (void)
16146 if (test_sync_0_skip ()) {
16147 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
16151 /* InitNone|InitEmpty for test_sync_0 */
16153 char device[] = "/dev/sda";
16155 suppress_error = 0;
16156 r = guestfs_blockdev_setrw (g, device);
16162 suppress_error = 0;
16163 r = guestfs_umount_all (g);
16169 suppress_error = 0;
16170 r = guestfs_lvm_remove_all (g);
16174 /* TestRun for sync (0) */
16177 suppress_error = 0;
16178 r = guestfs_sync (g);
16185 static int test_mount_0_skip (void)
16189 str = getenv ("SKIP_TEST_MOUNT_0");
16190 if (str && strcmp (str, "1") == 0) return 1;
16191 str = getenv ("SKIP_TEST_MOUNT");
16192 if (str && strcmp (str, "1") == 0) return 1;
16196 static int test_mount_0 (void)
16198 if (test_mount_0_skip ()) {
16199 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
16203 /* InitNone|InitEmpty for test_mount_0 */
16205 char device[] = "/dev/sda";
16207 suppress_error = 0;
16208 r = guestfs_blockdev_setrw (g, device);
16214 suppress_error = 0;
16215 r = guestfs_umount_all (g);
16221 suppress_error = 0;
16222 r = guestfs_lvm_remove_all (g);
16226 /* TestOutput for mount (0) */
16227 char expected[] = "new file contents";
16229 char device[] = "/dev/sda";
16230 char lines_0[] = ",";
16236 suppress_error = 0;
16237 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16242 char fstype[] = "ext2";
16243 char device[] = "/dev/sda1";
16245 suppress_error = 0;
16246 r = guestfs_mkfs (g, fstype, device);
16251 char device[] = "/dev/sda1";
16252 char mountpoint[] = "/";
16254 suppress_error = 0;
16255 r = guestfs_mount (g, device, mountpoint);
16260 char path[] = "/new";
16261 char content[] = "new file contents";
16263 suppress_error = 0;
16264 r = guestfs_write_file (g, path, content, 0);
16269 char path[] = "/new";
16271 suppress_error = 0;
16272 r = guestfs_cat (g, path);
16275 if (strcmp (r, expected) != 0) {
16276 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16284 int main (int argc, char *argv[])
16288 const char *filename;
16290 int nr_tests, test_num = 0;
16292 no_test_warnings ();
16294 g = guestfs_create ();
16296 printf ("guestfs_create FAILED\n");
16300 guestfs_set_error_handler (g, print_error, NULL);
16302 guestfs_set_path (g, "../appliance");
16304 filename = "test1.img";
16305 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16310 if (lseek (fd, 524288000, SEEK_SET) == -1) {
16316 if (write (fd, &c, 1) == -1) {
16322 if (close (fd) == -1) {
16327 if (guestfs_add_drive (g, filename) == -1) {
16328 printf ("guestfs_add_drive %s FAILED\n", filename);
16332 filename = "test2.img";
16333 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16338 if (lseek (fd, 52428800, SEEK_SET) == -1) {
16344 if (write (fd, &c, 1) == -1) {
16350 if (close (fd) == -1) {
16355 if (guestfs_add_drive (g, filename) == -1) {
16356 printf ("guestfs_add_drive %s FAILED\n", filename);
16360 filename = "test3.img";
16361 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16366 if (lseek (fd, 10485760, SEEK_SET) == -1) {
16372 if (write (fd, &c, 1) == -1) {
16378 if (close (fd) == -1) {
16383 if (guestfs_add_drive (g, filename) == -1) {
16384 printf ("guestfs_add_drive %s FAILED\n", filename);
16388 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16389 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16393 if (guestfs_launch (g) == -1) {
16394 printf ("guestfs_launch FAILED\n");
16398 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16401 if (guestfs_wait_ready (g) == -1) {
16402 printf ("guestfs_wait_ready FAILED\n");
16406 /* Cancel previous alarm. */
16412 printf ("%3d/%3d test_mkdtemp_0\n", test_num, nr_tests);
16413 if (test_mkdtemp_0 () == -1) {
16414 printf ("test_mkdtemp_0 FAILED\n");
16418 printf ("%3d/%3d test_scrub_file_0\n", test_num, nr_tests);
16419 if (test_scrub_file_0 () == -1) {
16420 printf ("test_scrub_file_0 FAILED\n");
16424 printf ("%3d/%3d test_scrub_device_0\n", test_num, nr_tests);
16425 if (test_scrub_device_0 () == -1) {
16426 printf ("test_scrub_device_0 FAILED\n");
16430 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16431 if (test_glob_expand_0 () == -1) {
16432 printf ("test_glob_expand_0 FAILED\n");
16436 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16437 if (test_glob_expand_1 () == -1) {
16438 printf ("test_glob_expand_1 FAILED\n");
16442 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16443 if (test_glob_expand_2 () == -1) {
16444 printf ("test_glob_expand_2 FAILED\n");
16448 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16449 if (test_ntfs_3g_probe_0 () == -1) {
16450 printf ("test_ntfs_3g_probe_0 FAILED\n");
16454 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16455 if (test_ntfs_3g_probe_1 () == -1) {
16456 printf ("test_ntfs_3g_probe_1 FAILED\n");
16460 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16461 if (test_sleep_0 () == -1) {
16462 printf ("test_sleep_0 FAILED\n");
16466 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16467 if (test_find_0 () == -1) {
16468 printf ("test_find_0 FAILED\n");
16472 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16473 if (test_find_1 () == -1) {
16474 printf ("test_find_1 FAILED\n");
16478 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16479 if (test_find_2 () == -1) {
16480 printf ("test_find_2 FAILED\n");
16484 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16485 if (test_lvresize_0 () == -1) {
16486 printf ("test_lvresize_0 FAILED\n");
16490 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16491 if (test_zerofree_0 () == -1) {
16492 printf ("test_zerofree_0 FAILED\n");
16496 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16497 if (test_hexdump_0 () == -1) {
16498 printf ("test_hexdump_0 FAILED\n");
16502 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16503 if (test_strings_e_0 () == -1) {
16504 printf ("test_strings_e_0 FAILED\n");
16508 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16509 if (test_strings_e_1 () == -1) {
16510 printf ("test_strings_e_1 FAILED\n");
16514 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16515 if (test_strings_0 () == -1) {
16516 printf ("test_strings_0 FAILED\n");
16520 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16521 if (test_strings_1 () == -1) {
16522 printf ("test_strings_1 FAILED\n");
16526 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16527 if (test_equal_0 () == -1) {
16528 printf ("test_equal_0 FAILED\n");
16532 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16533 if (test_equal_1 () == -1) {
16534 printf ("test_equal_1 FAILED\n");
16538 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16539 if (test_equal_2 () == -1) {
16540 printf ("test_equal_2 FAILED\n");
16544 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16545 if (test_ping_daemon_0 () == -1) {
16546 printf ("test_ping_daemon_0 FAILED\n");
16550 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16551 if (test_dmesg_0 () == -1) {
16552 printf ("test_dmesg_0 FAILED\n");
16556 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16557 if (test_drop_caches_0 () == -1) {
16558 printf ("test_drop_caches_0 FAILED\n");
16562 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16563 if (test_mv_0 () == -1) {
16564 printf ("test_mv_0 FAILED\n");
16568 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16569 if (test_mv_1 () == -1) {
16570 printf ("test_mv_1 FAILED\n");
16574 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16575 if (test_cp_a_0 () == -1) {
16576 printf ("test_cp_a_0 FAILED\n");
16580 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16581 if (test_cp_0 () == -1) {
16582 printf ("test_cp_0 FAILED\n");
16586 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16587 if (test_cp_1 () == -1) {
16588 printf ("test_cp_1 FAILED\n");
16592 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16593 if (test_cp_2 () == -1) {
16594 printf ("test_cp_2 FAILED\n");
16598 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16599 if (test_grub_install_0 () == -1) {
16600 printf ("test_grub_install_0 FAILED\n");
16604 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16605 if (test_zero_0 () == -1) {
16606 printf ("test_zero_0 FAILED\n");
16610 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16611 if (test_fsck_0 () == -1) {
16612 printf ("test_fsck_0 FAILED\n");
16616 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16617 if (test_fsck_1 () == -1) {
16618 printf ("test_fsck_1 FAILED\n");
16622 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16623 if (test_set_e2uuid_0 () == -1) {
16624 printf ("test_set_e2uuid_0 FAILED\n");
16628 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16629 if (test_set_e2uuid_1 () == -1) {
16630 printf ("test_set_e2uuid_1 FAILED\n");
16634 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16635 if (test_set_e2uuid_2 () == -1) {
16636 printf ("test_set_e2uuid_2 FAILED\n");
16640 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16641 if (test_set_e2uuid_3 () == -1) {
16642 printf ("test_set_e2uuid_3 FAILED\n");
16646 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16647 if (test_set_e2label_0 () == -1) {
16648 printf ("test_set_e2label_0 FAILED\n");
16652 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16653 if (test_pvremove_0 () == -1) {
16654 printf ("test_pvremove_0 FAILED\n");
16658 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16659 if (test_pvremove_1 () == -1) {
16660 printf ("test_pvremove_1 FAILED\n");
16664 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16665 if (test_pvremove_2 () == -1) {
16666 printf ("test_pvremove_2 FAILED\n");
16670 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16671 if (test_vgremove_0 () == -1) {
16672 printf ("test_vgremove_0 FAILED\n");
16676 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16677 if (test_vgremove_1 () == -1) {
16678 printf ("test_vgremove_1 FAILED\n");
16682 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16683 if (test_lvremove_0 () == -1) {
16684 printf ("test_lvremove_0 FAILED\n");
16688 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16689 if (test_lvremove_1 () == -1) {
16690 printf ("test_lvremove_1 FAILED\n");
16694 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16695 if (test_lvremove_2 () == -1) {
16696 printf ("test_lvremove_2 FAILED\n");
16700 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16701 if (test_mount_ro_0 () == -1) {
16702 printf ("test_mount_ro_0 FAILED\n");
16706 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16707 if (test_mount_ro_1 () == -1) {
16708 printf ("test_mount_ro_1 FAILED\n");
16712 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16713 if (test_tgz_in_0 () == -1) {
16714 printf ("test_tgz_in_0 FAILED\n");
16718 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16719 if (test_tar_in_0 () == -1) {
16720 printf ("test_tar_in_0 FAILED\n");
16724 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16725 if (test_checksum_0 () == -1) {
16726 printf ("test_checksum_0 FAILED\n");
16730 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16731 if (test_checksum_1 () == -1) {
16732 printf ("test_checksum_1 FAILED\n");
16736 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16737 if (test_checksum_2 () == -1) {
16738 printf ("test_checksum_2 FAILED\n");
16742 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16743 if (test_checksum_3 () == -1) {
16744 printf ("test_checksum_3 FAILED\n");
16748 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16749 if (test_checksum_4 () == -1) {
16750 printf ("test_checksum_4 FAILED\n");
16754 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16755 if (test_checksum_5 () == -1) {
16756 printf ("test_checksum_5 FAILED\n");
16760 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16761 if (test_checksum_6 () == -1) {
16762 printf ("test_checksum_6 FAILED\n");
16766 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16767 if (test_checksum_7 () == -1) {
16768 printf ("test_checksum_7 FAILED\n");
16772 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16773 if (test_checksum_8 () == -1) {
16774 printf ("test_checksum_8 FAILED\n");
16778 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16779 if (test_download_0 () == -1) {
16780 printf ("test_download_0 FAILED\n");
16784 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16785 if (test_upload_0 () == -1) {
16786 printf ("test_upload_0 FAILED\n");
16790 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16791 if (test_blockdev_rereadpt_0 () == -1) {
16792 printf ("test_blockdev_rereadpt_0 FAILED\n");
16796 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16797 if (test_blockdev_flushbufs_0 () == -1) {
16798 printf ("test_blockdev_flushbufs_0 FAILED\n");
16802 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16803 if (test_blockdev_getsize64_0 () == -1) {
16804 printf ("test_blockdev_getsize64_0 FAILED\n");
16808 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16809 if (test_blockdev_getsz_0 () == -1) {
16810 printf ("test_blockdev_getsz_0 FAILED\n");
16814 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16815 if (test_blockdev_getbsz_0 () == -1) {
16816 printf ("test_blockdev_getbsz_0 FAILED\n");
16820 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16821 if (test_blockdev_getss_0 () == -1) {
16822 printf ("test_blockdev_getss_0 FAILED\n");
16826 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16827 if (test_blockdev_getro_0 () == -1) {
16828 printf ("test_blockdev_getro_0 FAILED\n");
16832 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16833 if (test_blockdev_setrw_0 () == -1) {
16834 printf ("test_blockdev_setrw_0 FAILED\n");
16838 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16839 if (test_blockdev_setro_0 () == -1) {
16840 printf ("test_blockdev_setro_0 FAILED\n");
16844 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16845 if (test_statvfs_0 () == -1) {
16846 printf ("test_statvfs_0 FAILED\n");
16850 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16851 if (test_lstat_0 () == -1) {
16852 printf ("test_lstat_0 FAILED\n");
16856 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16857 if (test_stat_0 () == -1) {
16858 printf ("test_stat_0 FAILED\n");
16862 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16863 if (test_command_lines_0 () == -1) {
16864 printf ("test_command_lines_0 FAILED\n");
16868 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16869 if (test_command_lines_1 () == -1) {
16870 printf ("test_command_lines_1 FAILED\n");
16874 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16875 if (test_command_lines_2 () == -1) {
16876 printf ("test_command_lines_2 FAILED\n");
16880 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16881 if (test_command_lines_3 () == -1) {
16882 printf ("test_command_lines_3 FAILED\n");
16886 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16887 if (test_command_lines_4 () == -1) {
16888 printf ("test_command_lines_4 FAILED\n");
16892 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16893 if (test_command_lines_5 () == -1) {
16894 printf ("test_command_lines_5 FAILED\n");
16898 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16899 if (test_command_lines_6 () == -1) {
16900 printf ("test_command_lines_6 FAILED\n");
16904 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16905 if (test_command_lines_7 () == -1) {
16906 printf ("test_command_lines_7 FAILED\n");
16910 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16911 if (test_command_lines_8 () == -1) {
16912 printf ("test_command_lines_8 FAILED\n");
16916 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16917 if (test_command_lines_9 () == -1) {
16918 printf ("test_command_lines_9 FAILED\n");
16922 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16923 if (test_command_lines_10 () == -1) {
16924 printf ("test_command_lines_10 FAILED\n");
16928 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16929 if (test_command_0 () == -1) {
16930 printf ("test_command_0 FAILED\n");
16934 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16935 if (test_command_1 () == -1) {
16936 printf ("test_command_1 FAILED\n");
16940 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16941 if (test_command_2 () == -1) {
16942 printf ("test_command_2 FAILED\n");
16946 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16947 if (test_command_3 () == -1) {
16948 printf ("test_command_3 FAILED\n");
16952 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16953 if (test_command_4 () == -1) {
16954 printf ("test_command_4 FAILED\n");
16958 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16959 if (test_command_5 () == -1) {
16960 printf ("test_command_5 FAILED\n");
16964 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16965 if (test_command_6 () == -1) {
16966 printf ("test_command_6 FAILED\n");
16970 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16971 if (test_command_7 () == -1) {
16972 printf ("test_command_7 FAILED\n");
16976 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16977 if (test_command_8 () == -1) {
16978 printf ("test_command_8 FAILED\n");
16982 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16983 if (test_command_9 () == -1) {
16984 printf ("test_command_9 FAILED\n");
16988 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16989 if (test_command_10 () == -1) {
16990 printf ("test_command_10 FAILED\n");
16994 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16995 if (test_command_11 () == -1) {
16996 printf ("test_command_11 FAILED\n");
17000 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
17001 if (test_file_0 () == -1) {
17002 printf ("test_file_0 FAILED\n");
17006 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
17007 if (test_file_1 () == -1) {
17008 printf ("test_file_1 FAILED\n");
17012 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
17013 if (test_file_2 () == -1) {
17014 printf ("test_file_2 FAILED\n");
17018 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
17019 if (test_umount_all_0 () == -1) {
17020 printf ("test_umount_all_0 FAILED\n");
17024 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
17025 if (test_umount_all_1 () == -1) {
17026 printf ("test_umount_all_1 FAILED\n");
17030 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
17031 if (test_mounts_0 () == -1) {
17032 printf ("test_mounts_0 FAILED\n");
17036 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
17037 if (test_umount_0 () == -1) {
17038 printf ("test_umount_0 FAILED\n");
17042 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
17043 if (test_umount_1 () == -1) {
17044 printf ("test_umount_1 FAILED\n");
17048 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
17049 if (test_write_file_0 () == -1) {
17050 printf ("test_write_file_0 FAILED\n");
17054 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
17055 if (test_write_file_1 () == -1) {
17056 printf ("test_write_file_1 FAILED\n");
17060 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
17061 if (test_write_file_2 () == -1) {
17062 printf ("test_write_file_2 FAILED\n");
17066 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
17067 if (test_write_file_3 () == -1) {
17068 printf ("test_write_file_3 FAILED\n");
17072 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
17073 if (test_write_file_4 () == -1) {
17074 printf ("test_write_file_4 FAILED\n");
17078 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
17079 if (test_write_file_5 () == -1) {
17080 printf ("test_write_file_5 FAILED\n");
17084 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
17085 if (test_mkfs_0 () == -1) {
17086 printf ("test_mkfs_0 FAILED\n");
17090 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
17091 if (test_lvcreate_0 () == -1) {
17092 printf ("test_lvcreate_0 FAILED\n");
17096 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
17097 if (test_vgcreate_0 () == -1) {
17098 printf ("test_vgcreate_0 FAILED\n");
17102 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
17103 if (test_pvcreate_0 () == -1) {
17104 printf ("test_pvcreate_0 FAILED\n");
17108 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
17109 if (test_is_dir_0 () == -1) {
17110 printf ("test_is_dir_0 FAILED\n");
17114 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
17115 if (test_is_dir_1 () == -1) {
17116 printf ("test_is_dir_1 FAILED\n");
17120 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
17121 if (test_is_file_0 () == -1) {
17122 printf ("test_is_file_0 FAILED\n");
17126 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
17127 if (test_is_file_1 () == -1) {
17128 printf ("test_is_file_1 FAILED\n");
17132 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
17133 if (test_exists_0 () == -1) {
17134 printf ("test_exists_0 FAILED\n");
17138 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
17139 if (test_exists_1 () == -1) {
17140 printf ("test_exists_1 FAILED\n");
17144 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
17145 if (test_mkdir_p_0 () == -1) {
17146 printf ("test_mkdir_p_0 FAILED\n");
17150 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
17151 if (test_mkdir_p_1 () == -1) {
17152 printf ("test_mkdir_p_1 FAILED\n");
17156 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
17157 if (test_mkdir_p_2 () == -1) {
17158 printf ("test_mkdir_p_2 FAILED\n");
17162 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
17163 if (test_mkdir_p_3 () == -1) {
17164 printf ("test_mkdir_p_3 FAILED\n");
17168 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
17169 if (test_mkdir_p_4 () == -1) {
17170 printf ("test_mkdir_p_4 FAILED\n");
17174 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
17175 if (test_mkdir_0 () == -1) {
17176 printf ("test_mkdir_0 FAILED\n");
17180 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
17181 if (test_mkdir_1 () == -1) {
17182 printf ("test_mkdir_1 FAILED\n");
17186 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
17187 if (test_rm_rf_0 () == -1) {
17188 printf ("test_rm_rf_0 FAILED\n");
17192 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
17193 if (test_rmdir_0 () == -1) {
17194 printf ("test_rmdir_0 FAILED\n");
17198 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
17199 if (test_rmdir_1 () == -1) {
17200 printf ("test_rmdir_1 FAILED\n");
17204 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
17205 if (test_rmdir_2 () == -1) {
17206 printf ("test_rmdir_2 FAILED\n");
17210 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
17211 if (test_rm_0 () == -1) {
17212 printf ("test_rm_0 FAILED\n");
17216 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
17217 if (test_rm_1 () == -1) {
17218 printf ("test_rm_1 FAILED\n");
17222 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
17223 if (test_rm_2 () == -1) {
17224 printf ("test_rm_2 FAILED\n");
17228 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
17229 if (test_read_lines_0 () == -1) {
17230 printf ("test_read_lines_0 FAILED\n");
17234 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
17235 if (test_read_lines_1 () == -1) {
17236 printf ("test_read_lines_1 FAILED\n");
17240 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
17241 if (test_lvs_0 () == -1) {
17242 printf ("test_lvs_0 FAILED\n");
17246 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
17247 if (test_lvs_1 () == -1) {
17248 printf ("test_lvs_1 FAILED\n");
17252 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
17253 if (test_vgs_0 () == -1) {
17254 printf ("test_vgs_0 FAILED\n");
17258 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17259 if (test_vgs_1 () == -1) {
17260 printf ("test_vgs_1 FAILED\n");
17264 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17265 if (test_pvs_0 () == -1) {
17266 printf ("test_pvs_0 FAILED\n");
17270 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17271 if (test_pvs_1 () == -1) {
17272 printf ("test_pvs_1 FAILED\n");
17276 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17277 if (test_list_partitions_0 () == -1) {
17278 printf ("test_list_partitions_0 FAILED\n");
17282 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17283 if (test_list_partitions_1 () == -1) {
17284 printf ("test_list_partitions_1 FAILED\n");
17288 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17289 if (test_list_devices_0 () == -1) {
17290 printf ("test_list_devices_0 FAILED\n");
17294 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17295 if (test_ls_0 () == -1) {
17296 printf ("test_ls_0 FAILED\n");
17300 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17301 if (test_cat_0 () == -1) {
17302 printf ("test_cat_0 FAILED\n");
17306 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17307 if (test_touch_0 () == -1) {
17308 printf ("test_touch_0 FAILED\n");
17312 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17313 if (test_sync_0 () == -1) {
17314 printf ("test_sync_0 FAILED\n");
17318 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17319 if (test_mount_0 () == -1) {
17320 printf ("test_mount_0 FAILED\n");
17325 unlink ("test1.img");
17326 unlink ("test2.img");
17327 unlink ("test3.img");
17330 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);