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");
155 static int test_glob_expand_0_skip (void)
159 str = getenv ("SKIP_TEST_GLOB_EXPAND_0");
160 if (str && strcmp (str, "1") == 0) return 1;
161 str = getenv ("SKIP_TEST_GLOB_EXPAND");
162 if (str && strcmp (str, "1") == 0) return 1;
166 static int test_glob_expand_0 (void)
168 if (test_glob_expand_0_skip ()) {
169 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_0");
173 /* InitBasicFS for test_glob_expand_0: create ext2 on /dev/sda1 */
175 char device[] = "/dev/sda";
178 r = guestfs_blockdev_setrw (g, device);
185 r = guestfs_umount_all (g);
192 r = guestfs_lvm_remove_all (g);
197 char device[] = "/dev/sda";
198 char lines_0[] = ",";
205 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
210 char fstype[] = "ext2";
211 char device[] = "/dev/sda1";
214 r = guestfs_mkfs (g, fstype, device);
219 char device[] = "/dev/sda1";
220 char mountpoint[] = "/";
223 r = guestfs_mount (g, device, mountpoint);
227 /* TestOutputList for glob_expand (0) */
229 char path[] = "/a/b/c";
232 r = guestfs_mkdir_p (g, path);
237 char path[] = "/a/b/c/d";
240 r = guestfs_touch (g, path);
245 char path[] = "/a/b/c/e";
248 r = guestfs_touch (g, path);
253 char pattern[] = "/a/b/c/*";
257 r = guestfs_glob_expand (g, pattern);
261 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
266 char expected[] = "/a/b/c/d";
267 if (strcmp (r[0], expected) != 0) {
268 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
273 fprintf (stderr, "test_glob_expand_0: short list returned from command\n");
278 char expected[] = "/a/b/c/e";
279 if (strcmp (r[1], expected) != 0) {
280 fprintf (stderr, "test_glob_expand_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
285 fprintf (stderr, "test_glob_expand_0: extra elements returned from command\n");
289 for (i = 0; r[i] != NULL; ++i)
296 static int test_glob_expand_1_skip (void)
300 str = getenv ("SKIP_TEST_GLOB_EXPAND_1");
301 if (str && strcmp (str, "1") == 0) return 1;
302 str = getenv ("SKIP_TEST_GLOB_EXPAND");
303 if (str && strcmp (str, "1") == 0) return 1;
307 static int test_glob_expand_1 (void)
309 if (test_glob_expand_1_skip ()) {
310 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_1");
314 /* InitBasicFS for test_glob_expand_1: create ext2 on /dev/sda1 */
316 char device[] = "/dev/sda";
319 r = guestfs_blockdev_setrw (g, device);
326 r = guestfs_umount_all (g);
333 r = guestfs_lvm_remove_all (g);
338 char device[] = "/dev/sda";
339 char lines_0[] = ",";
346 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
351 char fstype[] = "ext2";
352 char device[] = "/dev/sda1";
355 r = guestfs_mkfs (g, fstype, device);
360 char device[] = "/dev/sda1";
361 char mountpoint[] = "/";
364 r = guestfs_mount (g, device, mountpoint);
368 /* TestOutputList for glob_expand (1) */
370 char path[] = "/a/b/c";
373 r = guestfs_mkdir_p (g, path);
378 char path[] = "/a/b/c/d";
381 r = guestfs_touch (g, path);
386 char path[] = "/a/b/c/e";
389 r = guestfs_touch (g, path);
394 char pattern[] = "/a/*/c/*";
398 r = guestfs_glob_expand (g, pattern);
402 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
407 char expected[] = "/a/b/c/d";
408 if (strcmp (r[0], expected) != 0) {
409 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
414 fprintf (stderr, "test_glob_expand_1: short list returned from command\n");
419 char expected[] = "/a/b/c/e";
420 if (strcmp (r[1], expected) != 0) {
421 fprintf (stderr, "test_glob_expand_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
426 fprintf (stderr, "test_glob_expand_1: extra elements returned from command\n");
430 for (i = 0; r[i] != NULL; ++i)
437 static int test_glob_expand_2_skip (void)
441 str = getenv ("SKIP_TEST_GLOB_EXPAND_2");
442 if (str && strcmp (str, "1") == 0) return 1;
443 str = getenv ("SKIP_TEST_GLOB_EXPAND");
444 if (str && strcmp (str, "1") == 0) return 1;
448 static int test_glob_expand_2 (void)
450 if (test_glob_expand_2_skip ()) {
451 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_glob_expand_2");
455 /* InitBasicFS for test_glob_expand_2: create ext2 on /dev/sda1 */
457 char device[] = "/dev/sda";
460 r = guestfs_blockdev_setrw (g, device);
467 r = guestfs_umount_all (g);
474 r = guestfs_lvm_remove_all (g);
479 char device[] = "/dev/sda";
480 char lines_0[] = ",";
487 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
492 char fstype[] = "ext2";
493 char device[] = "/dev/sda1";
496 r = guestfs_mkfs (g, fstype, device);
501 char device[] = "/dev/sda1";
502 char mountpoint[] = "/";
505 r = guestfs_mount (g, device, mountpoint);
509 /* TestOutputList for glob_expand (2) */
511 char path[] = "/a/b/c";
514 r = guestfs_mkdir_p (g, path);
519 char path[] = "/a/b/c/d";
522 r = guestfs_touch (g, path);
527 char path[] = "/a/b/c/e";
530 r = guestfs_touch (g, path);
535 char pattern[] = "/a/*/x/*";
539 r = guestfs_glob_expand (g, pattern);
543 fprintf (stderr, "test_glob_expand_2: extra elements returned from command\n");
547 for (i = 0; r[i] != NULL; ++i)
554 static int test_ntfs_3g_probe_0_skip (void)
558 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_0");
559 if (str && strcmp (str, "1") == 0) return 1;
560 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
561 if (str && strcmp (str, "1") == 0) return 1;
565 static int test_ntfs_3g_probe_0 (void)
567 if (test_ntfs_3g_probe_0_skip ()) {
568 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_0");
572 /* InitNone|InitEmpty for test_ntfs_3g_probe_0 */
574 char device[] = "/dev/sda";
577 r = guestfs_blockdev_setrw (g, device);
584 r = guestfs_umount_all (g);
591 r = guestfs_lvm_remove_all (g);
595 /* TestOutputInt for ntfs_3g_probe (0) */
597 char device[] = "/dev/sda";
598 char lines_0[] = ",";
605 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
610 char fstype[] = "ntfs";
611 char device[] = "/dev/sda1";
614 r = guestfs_mkfs (g, fstype, device);
619 char device[] = "/dev/sda1";
622 r = guestfs_ntfs_3g_probe (g, 1, device);
626 fprintf (stderr, "test_ntfs_3g_probe_0: expected 0 but got %d\n", (int) r);
633 static int test_ntfs_3g_probe_1_skip (void)
637 str = getenv ("SKIP_TEST_NTFS_3G_PROBE_1");
638 if (str && strcmp (str, "1") == 0) return 1;
639 str = getenv ("SKIP_TEST_NTFS_3G_PROBE");
640 if (str && strcmp (str, "1") == 0) return 1;
644 static int test_ntfs_3g_probe_1 (void)
646 if (test_ntfs_3g_probe_1_skip ()) {
647 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ntfs_3g_probe_1");
651 /* InitNone|InitEmpty for test_ntfs_3g_probe_1 */
653 char device[] = "/dev/sda";
656 r = guestfs_blockdev_setrw (g, device);
663 r = guestfs_umount_all (g);
670 r = guestfs_lvm_remove_all (g);
674 /* TestOutputInt for ntfs_3g_probe (1) */
676 char device[] = "/dev/sda";
677 char lines_0[] = ",";
684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
689 char fstype[] = "ext2";
690 char device[] = "/dev/sda1";
693 r = guestfs_mkfs (g, fstype, device);
698 char device[] = "/dev/sda1";
701 r = guestfs_ntfs_3g_probe (g, 1, device);
705 fprintf (stderr, "test_ntfs_3g_probe_1: expected 12 but got %d\n", (int) r);
712 static int test_sleep_0_skip (void)
716 str = getenv ("SKIP_TEST_SLEEP_0");
717 if (str && strcmp (str, "1") == 0) return 1;
718 str = getenv ("SKIP_TEST_SLEEP");
719 if (str && strcmp (str, "1") == 0) return 1;
723 static int test_sleep_0 (void)
725 if (test_sleep_0_skip ()) {
726 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sleep_0");
730 /* InitNone|InitEmpty for test_sleep_0 */
732 char device[] = "/dev/sda";
735 r = guestfs_blockdev_setrw (g, device);
742 r = guestfs_umount_all (g);
749 r = guestfs_lvm_remove_all (g);
753 /* TestRun for sleep (0) */
757 r = guestfs_sleep (g, 1);
764 static int test_find_0_skip (void)
768 str = getenv ("SKIP_TEST_FIND_0");
769 if (str && strcmp (str, "1") == 0) return 1;
770 str = getenv ("SKIP_TEST_FIND");
771 if (str && strcmp (str, "1") == 0) return 1;
775 static int test_find_0 (void)
777 if (test_find_0_skip ()) {
778 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_0");
782 /* InitBasicFS for test_find_0: create ext2 on /dev/sda1 */
784 char device[] = "/dev/sda";
787 r = guestfs_blockdev_setrw (g, device);
794 r = guestfs_umount_all (g);
801 r = guestfs_lvm_remove_all (g);
806 char device[] = "/dev/sda";
807 char lines_0[] = ",";
814 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
819 char fstype[] = "ext2";
820 char device[] = "/dev/sda1";
823 r = guestfs_mkfs (g, fstype, device);
828 char device[] = "/dev/sda1";
829 char mountpoint[] = "/";
832 r = guestfs_mount (g, device, mountpoint);
836 /* TestOutputList for find (0) */
838 char directory[] = "/";
842 r = guestfs_find (g, directory);
846 fprintf (stderr, "test_find_0: short list returned from command\n");
851 char expected[] = "lost+found";
852 if (strcmp (r[0], expected) != 0) {
853 fprintf (stderr, "test_find_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
858 fprintf (stderr, "test_find_0: extra elements returned from command\n");
862 for (i = 0; r[i] != NULL; ++i)
869 static int test_find_1_skip (void)
873 str = getenv ("SKIP_TEST_FIND_1");
874 if (str && strcmp (str, "1") == 0) return 1;
875 str = getenv ("SKIP_TEST_FIND");
876 if (str && strcmp (str, "1") == 0) return 1;
880 static int test_find_1 (void)
882 if (test_find_1_skip ()) {
883 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_1");
887 /* InitBasicFS for test_find_1: create ext2 on /dev/sda1 */
889 char device[] = "/dev/sda";
892 r = guestfs_blockdev_setrw (g, device);
899 r = guestfs_umount_all (g);
906 r = guestfs_lvm_remove_all (g);
911 char device[] = "/dev/sda";
912 char lines_0[] = ",";
919 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
924 char fstype[] = "ext2";
925 char device[] = "/dev/sda1";
928 r = guestfs_mkfs (g, fstype, device);
933 char device[] = "/dev/sda1";
934 char mountpoint[] = "/";
937 r = guestfs_mount (g, device, mountpoint);
941 /* TestOutputList for find (1) */
946 r = guestfs_touch (g, path);
954 r = guestfs_mkdir (g, path);
959 char path[] = "/b/c";
962 r = guestfs_touch (g, path);
967 char directory[] = "/";
971 r = guestfs_find (g, directory);
975 fprintf (stderr, "test_find_1: short list returned from command\n");
980 char expected[] = "a";
981 if (strcmp (r[0], expected) != 0) {
982 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
987 fprintf (stderr, "test_find_1: short list returned from command\n");
992 char expected[] = "b";
993 if (strcmp (r[1], expected) != 0) {
994 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
999 fprintf (stderr, "test_find_1: short list returned from command\n");
1004 char expected[] = "b/c";
1005 if (strcmp (r[2], expected) != 0) {
1006 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
1011 fprintf (stderr, "test_find_1: short list returned from command\n");
1016 char expected[] = "lost+found";
1017 if (strcmp (r[3], expected) != 0) {
1018 fprintf (stderr, "test_find_1: expected \"%s\" but got \"%s\"\n", expected, r[3]);
1023 fprintf (stderr, "test_find_1: extra elements returned from command\n");
1027 for (i = 0; r[i] != NULL; ++i)
1034 static int test_find_2_skip (void)
1038 str = getenv ("SKIP_TEST_FIND_2");
1039 if (str && strcmp (str, "1") == 0) return 1;
1040 str = getenv ("SKIP_TEST_FIND");
1041 if (str && strcmp (str, "1") == 0) return 1;
1045 static int test_find_2 (void)
1047 if (test_find_2_skip ()) {
1048 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_find_2");
1052 /* InitBasicFS for test_find_2: create ext2 on /dev/sda1 */
1054 char device[] = "/dev/sda";
1057 r = guestfs_blockdev_setrw (g, device);
1064 r = guestfs_umount_all (g);
1071 r = guestfs_lvm_remove_all (g);
1076 char device[] = "/dev/sda";
1077 char lines_0[] = ",";
1084 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1089 char fstype[] = "ext2";
1090 char device[] = "/dev/sda1";
1093 r = guestfs_mkfs (g, fstype, device);
1098 char device[] = "/dev/sda1";
1099 char mountpoint[] = "/";
1102 r = guestfs_mount (g, device, mountpoint);
1106 /* TestOutputList for find (2) */
1108 char path[] = "/a/b/c";
1111 r = guestfs_mkdir_p (g, path);
1116 char path[] = "/a/b/c/d";
1119 r = guestfs_touch (g, path);
1124 char directory[] = "/a/b/";
1128 r = guestfs_find (g, directory);
1132 fprintf (stderr, "test_find_2: short list returned from command\n");
1137 char expected[] = "c";
1138 if (strcmp (r[0], expected) != 0) {
1139 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1144 fprintf (stderr, "test_find_2: short list returned from command\n");
1149 char expected[] = "c/d";
1150 if (strcmp (r[1], expected) != 0) {
1151 fprintf (stderr, "test_find_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1156 fprintf (stderr, "test_find_2: extra elements returned from command\n");
1160 for (i = 0; r[i] != NULL; ++i)
1167 static int test_lvresize_0_skip (void)
1171 str = getenv ("SKIP_TEST_LVRESIZE_0");
1172 if (str && strcmp (str, "1") == 0) return 1;
1173 str = getenv ("SKIP_TEST_LVRESIZE");
1174 if (str && strcmp (str, "1") == 0) return 1;
1178 static int test_lvresize_0 (void)
1180 if (test_lvresize_0_skip ()) {
1181 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvresize_0");
1185 /* InitNone|InitEmpty for test_lvresize_0 */
1187 char device[] = "/dev/sda";
1190 r = guestfs_blockdev_setrw (g, device);
1197 r = guestfs_umount_all (g);
1204 r = guestfs_lvm_remove_all (g);
1208 /* TestOutput for lvresize (0) */
1209 char expected[] = "test content";
1211 char device[] = "/dev/sda";
1212 char lines_0[] = ",";
1219 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1224 char device[] = "/dev/sda1";
1227 r = guestfs_pvcreate (g, device);
1232 char volgroup[] = "VG";
1233 char physvols_0[] = "/dev/sda1";
1234 char *physvols[] = {
1240 r = guestfs_vgcreate (g, volgroup, physvols);
1245 char logvol[] = "LV";
1246 char volgroup[] = "VG";
1249 r = guestfs_lvcreate (g, logvol, volgroup, 10);
1254 char fstype[] = "ext2";
1255 char device[] = "/dev/VG/LV";
1258 r = guestfs_mkfs (g, fstype, device);
1263 char device[] = "/dev/VG/LV";
1264 char mountpoint[] = "/";
1267 r = guestfs_mount (g, device, mountpoint);
1272 char path[] = "/new";
1273 char content[] = "test content";
1276 r = guestfs_write_file (g, path, content, 0);
1281 char pathordevice[] = "/";
1284 r = guestfs_umount (g, pathordevice);
1289 char device[] = "/dev/VG/LV";
1292 r = guestfs_lvresize (g, device, 20);
1297 char device[] = "/dev/VG/LV";
1300 r = guestfs_e2fsck_f (g, device);
1305 char device[] = "/dev/VG/LV";
1308 r = guestfs_resize2fs (g, device);
1313 char device[] = "/dev/VG/LV";
1314 char mountpoint[] = "/";
1317 r = guestfs_mount (g, device, mountpoint);
1322 char path[] = "/new";
1325 r = guestfs_cat (g, path);
1328 if (strcmp (r, expected) != 0) {
1329 fprintf (stderr, "test_lvresize_0: expected \"%s\" but got \"%s\"\n", expected, r);
1337 static int test_zerofree_0_skip (void)
1341 str = getenv ("SKIP_TEST_ZEROFREE_0");
1342 if (str && strcmp (str, "1") == 0) return 1;
1343 str = getenv ("SKIP_TEST_ZEROFREE");
1344 if (str && strcmp (str, "1") == 0) return 1;
1348 static int test_zerofree_0 (void)
1350 if (test_zerofree_0_skip ()) {
1351 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zerofree_0");
1355 /* InitNone|InitEmpty for test_zerofree_0 */
1357 char device[] = "/dev/sda";
1360 r = guestfs_blockdev_setrw (g, device);
1367 r = guestfs_umount_all (g);
1374 r = guestfs_lvm_remove_all (g);
1378 /* TestOutput for zerofree (0) */
1379 char expected[] = "test file";
1381 char device[] = "/dev/sda";
1382 char lines_0[] = ",";
1389 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1394 char fstype[] = "ext3";
1395 char device[] = "/dev/sda1";
1398 r = guestfs_mkfs (g, fstype, device);
1403 char device[] = "/dev/sda1";
1404 char mountpoint[] = "/";
1407 r = guestfs_mount (g, device, mountpoint);
1412 char path[] = "/new";
1413 char content[] = "test file";
1416 r = guestfs_write_file (g, path, content, 0);
1421 char pathordevice[] = "/dev/sda1";
1424 r = guestfs_umount (g, pathordevice);
1429 char device[] = "/dev/sda1";
1432 r = guestfs_zerofree (g, device);
1437 char device[] = "/dev/sda1";
1438 char mountpoint[] = "/";
1441 r = guestfs_mount (g, device, mountpoint);
1446 char path[] = "/new";
1449 r = guestfs_cat (g, path);
1452 if (strcmp (r, expected) != 0) {
1453 fprintf (stderr, "test_zerofree_0: expected \"%s\" but got \"%s\"\n", expected, r);
1461 static int test_hexdump_0_skip (void)
1465 str = getenv ("SKIP_TEST_HEXDUMP_0");
1466 if (str && strcmp (str, "1") == 0) return 1;
1467 str = getenv ("SKIP_TEST_HEXDUMP");
1468 if (str && strcmp (str, "1") == 0) return 1;
1472 static int test_hexdump_0 (void)
1474 if (test_hexdump_0_skip ()) {
1475 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_hexdump_0");
1479 /* InitBasicFS for test_hexdump_0: create ext2 on /dev/sda1 */
1481 char device[] = "/dev/sda";
1484 r = guestfs_blockdev_setrw (g, device);
1491 r = guestfs_umount_all (g);
1498 r = guestfs_lvm_remove_all (g);
1503 char device[] = "/dev/sda";
1504 char lines_0[] = ",";
1511 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1516 char fstype[] = "ext2";
1517 char device[] = "/dev/sda1";
1520 r = guestfs_mkfs (g, fstype, device);
1525 char device[] = "/dev/sda1";
1526 char mountpoint[] = "/";
1529 r = guestfs_mount (g, device, mountpoint);
1533 /* TestOutput for hexdump (0) */
1534 char expected[] = "00000000 68 65 6c 6c 6f 0a 77 6f 72 6c 64 0a |hello.world.|\n0000000c\n";
1536 char path[] = "/new";
1537 char content[] = "hello\nworld\n";
1540 r = guestfs_write_file (g, path, content, 12);
1545 char path[] = "/new";
1548 r = guestfs_hexdump (g, path);
1551 if (strcmp (r, expected) != 0) {
1552 fprintf (stderr, "test_hexdump_0: expected \"%s\" but got \"%s\"\n", expected, r);
1560 static int test_strings_e_0_skip (void)
1564 str = getenv ("SKIP_TEST_STRINGS_E_0");
1565 if (str && strcmp (str, "1") == 0) return 1;
1566 str = getenv ("SKIP_TEST_STRINGS_E");
1567 if (str && strcmp (str, "1") == 0) return 1;
1571 static int test_strings_e_0 (void)
1573 if (test_strings_e_0_skip ()) {
1574 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_0");
1578 /* InitBasicFS for test_strings_e_0: create ext2 on /dev/sda1 */
1580 char device[] = "/dev/sda";
1583 r = guestfs_blockdev_setrw (g, device);
1590 r = guestfs_umount_all (g);
1597 r = guestfs_lvm_remove_all (g);
1602 char device[] = "/dev/sda";
1603 char lines_0[] = ",";
1610 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1615 char fstype[] = "ext2";
1616 char device[] = "/dev/sda1";
1619 r = guestfs_mkfs (g, fstype, device);
1624 char device[] = "/dev/sda1";
1625 char mountpoint[] = "/";
1628 r = guestfs_mount (g, device, mountpoint);
1632 /* TestOutputList for strings_e (0) */
1634 char path[] = "/new";
1635 char content[] = "hello\nworld\n";
1638 r = guestfs_write_file (g, path, content, 0);
1643 char encoding[] = "b";
1644 char path[] = "/new";
1648 r = guestfs_strings_e (g, encoding, path);
1652 fprintf (stderr, "test_strings_e_0: extra elements returned from command\n");
1656 for (i = 0; r[i] != NULL; ++i)
1663 static int test_strings_e_1_skip (void)
1667 str = getenv ("SKIP_TEST_STRINGS_E_1");
1668 if (str && strcmp (str, "1") == 0) return 1;
1669 str = getenv ("SKIP_TEST_STRINGS_E");
1670 if (str && strcmp (str, "1") == 0) return 1;
1674 static int test_strings_e_1 (void)
1676 if (test_strings_e_1_skip ()) {
1677 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_e_1");
1681 printf ("%s skipped (reason: test disabled in generator)\n", "test_strings_e_1");
1685 static int test_strings_0_skip (void)
1689 str = getenv ("SKIP_TEST_STRINGS_0");
1690 if (str && strcmp (str, "1") == 0) return 1;
1691 str = getenv ("SKIP_TEST_STRINGS");
1692 if (str && strcmp (str, "1") == 0) return 1;
1696 static int test_strings_0 (void)
1698 if (test_strings_0_skip ()) {
1699 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_0");
1703 /* InitBasicFS for test_strings_0: create ext2 on /dev/sda1 */
1705 char device[] = "/dev/sda";
1708 r = guestfs_blockdev_setrw (g, device);
1715 r = guestfs_umount_all (g);
1722 r = guestfs_lvm_remove_all (g);
1727 char device[] = "/dev/sda";
1728 char lines_0[] = ",";
1735 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1740 char fstype[] = "ext2";
1741 char device[] = "/dev/sda1";
1744 r = guestfs_mkfs (g, fstype, device);
1749 char device[] = "/dev/sda1";
1750 char mountpoint[] = "/";
1753 r = guestfs_mount (g, device, mountpoint);
1757 /* TestOutputList for strings (0) */
1759 char path[] = "/new";
1760 char content[] = "hello\nworld\n";
1763 r = guestfs_write_file (g, path, content, 0);
1768 char path[] = "/new";
1772 r = guestfs_strings (g, path);
1776 fprintf (stderr, "test_strings_0: short list returned from command\n");
1781 char expected[] = "hello";
1782 if (strcmp (r[0], expected) != 0) {
1783 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
1788 fprintf (stderr, "test_strings_0: short list returned from command\n");
1793 char expected[] = "world";
1794 if (strcmp (r[1], expected) != 0) {
1795 fprintf (stderr, "test_strings_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
1800 fprintf (stderr, "test_strings_0: extra elements returned from command\n");
1804 for (i = 0; r[i] != NULL; ++i)
1811 static int test_strings_1_skip (void)
1815 str = getenv ("SKIP_TEST_STRINGS_1");
1816 if (str && strcmp (str, "1") == 0) return 1;
1817 str = getenv ("SKIP_TEST_STRINGS");
1818 if (str && strcmp (str, "1") == 0) return 1;
1822 static int test_strings_1 (void)
1824 if (test_strings_1_skip ()) {
1825 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_strings_1");
1829 /* InitBasicFS for test_strings_1: create ext2 on /dev/sda1 */
1831 char device[] = "/dev/sda";
1834 r = guestfs_blockdev_setrw (g, device);
1841 r = guestfs_umount_all (g);
1848 r = guestfs_lvm_remove_all (g);
1853 char device[] = "/dev/sda";
1854 char lines_0[] = ",";
1861 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1866 char fstype[] = "ext2";
1867 char device[] = "/dev/sda1";
1870 r = guestfs_mkfs (g, fstype, device);
1875 char device[] = "/dev/sda1";
1876 char mountpoint[] = "/";
1879 r = guestfs_mount (g, device, mountpoint);
1883 /* TestOutputList for strings (1) */
1885 char path[] = "/new";
1888 r = guestfs_touch (g, path);
1893 char path[] = "/new";
1897 r = guestfs_strings (g, path);
1901 fprintf (stderr, "test_strings_1: extra elements returned from command\n");
1905 for (i = 0; r[i] != NULL; ++i)
1912 static int test_equal_0_skip (void)
1916 str = getenv ("SKIP_TEST_EQUAL_0");
1917 if (str && strcmp (str, "1") == 0) return 1;
1918 str = getenv ("SKIP_TEST_EQUAL");
1919 if (str && strcmp (str, "1") == 0) return 1;
1923 static int test_equal_0 (void)
1925 if (test_equal_0_skip ()) {
1926 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_0");
1930 /* InitBasicFS for test_equal_0: create ext2 on /dev/sda1 */
1932 char device[] = "/dev/sda";
1935 r = guestfs_blockdev_setrw (g, device);
1942 r = guestfs_umount_all (g);
1949 r = guestfs_lvm_remove_all (g);
1954 char device[] = "/dev/sda";
1955 char lines_0[] = ",";
1962 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
1967 char fstype[] = "ext2";
1968 char device[] = "/dev/sda1";
1971 r = guestfs_mkfs (g, fstype, device);
1976 char device[] = "/dev/sda1";
1977 char mountpoint[] = "/";
1980 r = guestfs_mount (g, device, mountpoint);
1984 /* TestOutputTrue for equal (0) */
1986 char path[] = "/file1";
1987 char content[] = "contents of a file";
1990 r = guestfs_write_file (g, path, content, 0);
1995 char src[] = "/file1";
1996 char dest[] = "/file2";
1999 r = guestfs_cp (g, src, dest);
2004 char file1[] = "/file1";
2005 char file2[] = "/file2";
2008 r = guestfs_equal (g, file1, file2);
2012 fprintf (stderr, "test_equal_0: expected true, got false\n");
2019 static int test_equal_1_skip (void)
2023 str = getenv ("SKIP_TEST_EQUAL_1");
2024 if (str && strcmp (str, "1") == 0) return 1;
2025 str = getenv ("SKIP_TEST_EQUAL");
2026 if (str && strcmp (str, "1") == 0) return 1;
2030 static int test_equal_1 (void)
2032 if (test_equal_1_skip ()) {
2033 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_1");
2037 /* InitBasicFS for test_equal_1: create ext2 on /dev/sda1 */
2039 char device[] = "/dev/sda";
2042 r = guestfs_blockdev_setrw (g, device);
2049 r = guestfs_umount_all (g);
2056 r = guestfs_lvm_remove_all (g);
2061 char device[] = "/dev/sda";
2062 char lines_0[] = ",";
2069 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2074 char fstype[] = "ext2";
2075 char device[] = "/dev/sda1";
2078 r = guestfs_mkfs (g, fstype, device);
2083 char device[] = "/dev/sda1";
2084 char mountpoint[] = "/";
2087 r = guestfs_mount (g, device, mountpoint);
2091 /* TestOutputFalse for equal (1) */
2093 char path[] = "/file1";
2094 char content[] = "contents of a file";
2097 r = guestfs_write_file (g, path, content, 0);
2102 char path[] = "/file2";
2103 char content[] = "contents of another file";
2106 r = guestfs_write_file (g, path, content, 0);
2111 char file1[] = "/file1";
2112 char file2[] = "/file2";
2115 r = guestfs_equal (g, file1, file2);
2119 fprintf (stderr, "test_equal_1: expected false, got true\n");
2126 static int test_equal_2_skip (void)
2130 str = getenv ("SKIP_TEST_EQUAL_2");
2131 if (str && strcmp (str, "1") == 0) return 1;
2132 str = getenv ("SKIP_TEST_EQUAL");
2133 if (str && strcmp (str, "1") == 0) return 1;
2137 static int test_equal_2 (void)
2139 if (test_equal_2_skip ()) {
2140 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_equal_2");
2144 /* InitBasicFS for test_equal_2: create ext2 on /dev/sda1 */
2146 char device[] = "/dev/sda";
2149 r = guestfs_blockdev_setrw (g, device);
2156 r = guestfs_umount_all (g);
2163 r = guestfs_lvm_remove_all (g);
2168 char device[] = "/dev/sda";
2169 char lines_0[] = ",";
2176 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2181 char fstype[] = "ext2";
2182 char device[] = "/dev/sda1";
2185 r = guestfs_mkfs (g, fstype, device);
2190 char device[] = "/dev/sda1";
2191 char mountpoint[] = "/";
2194 r = guestfs_mount (g, device, mountpoint);
2198 /* TestLastFail for equal (2) */
2200 char file1[] = "/file1";
2201 char file2[] = "/file2";
2204 r = guestfs_equal (g, file1, file2);
2211 static int test_ping_daemon_0_skip (void)
2215 str = getenv ("SKIP_TEST_PING_DAEMON_0");
2216 if (str && strcmp (str, "1") == 0) return 1;
2217 str = getenv ("SKIP_TEST_PING_DAEMON");
2218 if (str && strcmp (str, "1") == 0) return 1;
2222 static int test_ping_daemon_0 (void)
2224 if (test_ping_daemon_0_skip ()) {
2225 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ping_daemon_0");
2229 /* InitNone|InitEmpty for test_ping_daemon_0 */
2231 char device[] = "/dev/sda";
2234 r = guestfs_blockdev_setrw (g, device);
2241 r = guestfs_umount_all (g);
2248 r = guestfs_lvm_remove_all (g);
2252 /* TestRun for ping_daemon (0) */
2256 r = guestfs_ping_daemon (g);
2263 static int test_dmesg_0_skip (void)
2267 str = getenv ("SKIP_TEST_DMESG_0");
2268 if (str && strcmp (str, "1") == 0) return 1;
2269 str = getenv ("SKIP_TEST_DMESG");
2270 if (str && strcmp (str, "1") == 0) return 1;
2274 static int test_dmesg_0 (void)
2276 if (test_dmesg_0_skip ()) {
2277 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_dmesg_0");
2281 /* InitNone|InitEmpty for test_dmesg_0 */
2283 char device[] = "/dev/sda";
2286 r = guestfs_blockdev_setrw (g, device);
2293 r = guestfs_umount_all (g);
2300 r = guestfs_lvm_remove_all (g);
2304 /* TestRun for dmesg (0) */
2308 r = guestfs_dmesg (g);
2316 static int test_drop_caches_0_skip (void)
2320 str = getenv ("SKIP_TEST_DROP_CACHES_0");
2321 if (str && strcmp (str, "1") == 0) return 1;
2322 str = getenv ("SKIP_TEST_DROP_CACHES");
2323 if (str && strcmp (str, "1") == 0) return 1;
2327 static int test_drop_caches_0 (void)
2329 if (test_drop_caches_0_skip ()) {
2330 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_drop_caches_0");
2334 /* InitNone|InitEmpty for test_drop_caches_0 */
2336 char device[] = "/dev/sda";
2339 r = guestfs_blockdev_setrw (g, device);
2346 r = guestfs_umount_all (g);
2353 r = guestfs_lvm_remove_all (g);
2357 /* TestRun for drop_caches (0) */
2361 r = guestfs_drop_caches (g, 3);
2368 static int test_mv_0_skip (void)
2372 str = getenv ("SKIP_TEST_MV_0");
2373 if (str && strcmp (str, "1") == 0) return 1;
2374 str = getenv ("SKIP_TEST_MV");
2375 if (str && strcmp (str, "1") == 0) return 1;
2379 static int test_mv_0 (void)
2381 if (test_mv_0_skip ()) {
2382 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_0");
2386 /* InitBasicFS for test_mv_0: create ext2 on /dev/sda1 */
2388 char device[] = "/dev/sda";
2391 r = guestfs_blockdev_setrw (g, device);
2398 r = guestfs_umount_all (g);
2405 r = guestfs_lvm_remove_all (g);
2410 char device[] = "/dev/sda";
2411 char lines_0[] = ",";
2418 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2423 char fstype[] = "ext2";
2424 char device[] = "/dev/sda1";
2427 r = guestfs_mkfs (g, fstype, device);
2432 char device[] = "/dev/sda1";
2433 char mountpoint[] = "/";
2436 r = guestfs_mount (g, device, mountpoint);
2440 /* TestOutput for mv (0) */
2441 char expected[] = "file content";
2443 char path[] = "/old";
2444 char content[] = "file content";
2447 r = guestfs_write_file (g, path, content, 0);
2452 char src[] = "/old";
2453 char dest[] = "/new";
2456 r = guestfs_mv (g, src, dest);
2461 char path[] = "/new";
2464 r = guestfs_cat (g, path);
2467 if (strcmp (r, expected) != 0) {
2468 fprintf (stderr, "test_mv_0: expected \"%s\" but got \"%s\"\n", expected, r);
2476 static int test_mv_1_skip (void)
2480 str = getenv ("SKIP_TEST_MV_1");
2481 if (str && strcmp (str, "1") == 0) return 1;
2482 str = getenv ("SKIP_TEST_MV");
2483 if (str && strcmp (str, "1") == 0) return 1;
2487 static int test_mv_1 (void)
2489 if (test_mv_1_skip ()) {
2490 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mv_1");
2494 /* InitBasicFS for test_mv_1: create ext2 on /dev/sda1 */
2496 char device[] = "/dev/sda";
2499 r = guestfs_blockdev_setrw (g, device);
2506 r = guestfs_umount_all (g);
2513 r = guestfs_lvm_remove_all (g);
2518 char device[] = "/dev/sda";
2519 char lines_0[] = ",";
2526 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2531 char fstype[] = "ext2";
2532 char device[] = "/dev/sda1";
2535 r = guestfs_mkfs (g, fstype, device);
2540 char device[] = "/dev/sda1";
2541 char mountpoint[] = "/";
2544 r = guestfs_mount (g, device, mountpoint);
2548 /* TestOutputFalse for mv (1) */
2550 char path[] = "/old";
2551 char content[] = "file content";
2554 r = guestfs_write_file (g, path, content, 0);
2559 char src[] = "/old";
2560 char dest[] = "/new";
2563 r = guestfs_mv (g, src, dest);
2568 char path[] = "/old";
2571 r = guestfs_is_file (g, path);
2575 fprintf (stderr, "test_mv_1: expected false, got true\n");
2582 static int test_cp_a_0_skip (void)
2586 str = getenv ("SKIP_TEST_CP_A_0");
2587 if (str && strcmp (str, "1") == 0) return 1;
2588 str = getenv ("SKIP_TEST_CP_A");
2589 if (str && strcmp (str, "1") == 0) return 1;
2593 static int test_cp_a_0 (void)
2595 if (test_cp_a_0_skip ()) {
2596 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_a_0");
2600 /* InitBasicFS for test_cp_a_0: create ext2 on /dev/sda1 */
2602 char device[] = "/dev/sda";
2605 r = guestfs_blockdev_setrw (g, device);
2612 r = guestfs_umount_all (g);
2619 r = guestfs_lvm_remove_all (g);
2624 char device[] = "/dev/sda";
2625 char lines_0[] = ",";
2632 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2637 char fstype[] = "ext2";
2638 char device[] = "/dev/sda1";
2641 r = guestfs_mkfs (g, fstype, device);
2646 char device[] = "/dev/sda1";
2647 char mountpoint[] = "/";
2650 r = guestfs_mount (g, device, mountpoint);
2654 /* TestOutput for cp_a (0) */
2655 char expected[] = "file content";
2657 char path[] = "/olddir";
2660 r = guestfs_mkdir (g, path);
2665 char path[] = "/newdir";
2668 r = guestfs_mkdir (g, path);
2673 char path[] = "/olddir/file";
2674 char content[] = "file content";
2677 r = guestfs_write_file (g, path, content, 0);
2682 char src[] = "/olddir";
2683 char dest[] = "/newdir";
2686 r = guestfs_cp_a (g, src, dest);
2691 char path[] = "/newdir/olddir/file";
2694 r = guestfs_cat (g, path);
2697 if (strcmp (r, expected) != 0) {
2698 fprintf (stderr, "test_cp_a_0: expected \"%s\" but got \"%s\"\n", expected, r);
2706 static int test_cp_0_skip (void)
2710 str = getenv ("SKIP_TEST_CP_0");
2711 if (str && strcmp (str, "1") == 0) return 1;
2712 str = getenv ("SKIP_TEST_CP");
2713 if (str && strcmp (str, "1") == 0) return 1;
2717 static int test_cp_0 (void)
2719 if (test_cp_0_skip ()) {
2720 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_0");
2724 /* InitBasicFS for test_cp_0: create ext2 on /dev/sda1 */
2726 char device[] = "/dev/sda";
2729 r = guestfs_blockdev_setrw (g, device);
2736 r = guestfs_umount_all (g);
2743 r = guestfs_lvm_remove_all (g);
2748 char device[] = "/dev/sda";
2749 char lines_0[] = ",";
2756 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2761 char fstype[] = "ext2";
2762 char device[] = "/dev/sda1";
2765 r = guestfs_mkfs (g, fstype, device);
2770 char device[] = "/dev/sda1";
2771 char mountpoint[] = "/";
2774 r = guestfs_mount (g, device, mountpoint);
2778 /* TestOutput for cp (0) */
2779 char expected[] = "file content";
2781 char path[] = "/old";
2782 char content[] = "file content";
2785 r = guestfs_write_file (g, path, content, 0);
2790 char src[] = "/old";
2791 char dest[] = "/new";
2794 r = guestfs_cp (g, src, dest);
2799 char path[] = "/new";
2802 r = guestfs_cat (g, path);
2805 if (strcmp (r, expected) != 0) {
2806 fprintf (stderr, "test_cp_0: expected \"%s\" but got \"%s\"\n", expected, r);
2814 static int test_cp_1_skip (void)
2818 str = getenv ("SKIP_TEST_CP_1");
2819 if (str && strcmp (str, "1") == 0) return 1;
2820 str = getenv ("SKIP_TEST_CP");
2821 if (str && strcmp (str, "1") == 0) return 1;
2825 static int test_cp_1 (void)
2827 if (test_cp_1_skip ()) {
2828 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_1");
2832 /* InitBasicFS for test_cp_1: create ext2 on /dev/sda1 */
2834 char device[] = "/dev/sda";
2837 r = guestfs_blockdev_setrw (g, device);
2844 r = guestfs_umount_all (g);
2851 r = guestfs_lvm_remove_all (g);
2856 char device[] = "/dev/sda";
2857 char lines_0[] = ",";
2864 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2869 char fstype[] = "ext2";
2870 char device[] = "/dev/sda1";
2873 r = guestfs_mkfs (g, fstype, device);
2878 char device[] = "/dev/sda1";
2879 char mountpoint[] = "/";
2882 r = guestfs_mount (g, device, mountpoint);
2886 /* TestOutputTrue for cp (1) */
2888 char path[] = "/old";
2889 char content[] = "file content";
2892 r = guestfs_write_file (g, path, content, 0);
2897 char src[] = "/old";
2898 char dest[] = "/new";
2901 r = guestfs_cp (g, src, dest);
2906 char path[] = "/old";
2909 r = guestfs_is_file (g, path);
2913 fprintf (stderr, "test_cp_1: expected true, got false\n");
2920 static int test_cp_2_skip (void)
2924 str = getenv ("SKIP_TEST_CP_2");
2925 if (str && strcmp (str, "1") == 0) return 1;
2926 str = getenv ("SKIP_TEST_CP");
2927 if (str && strcmp (str, "1") == 0) return 1;
2931 static int test_cp_2 (void)
2933 if (test_cp_2_skip ()) {
2934 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cp_2");
2938 /* InitBasicFS for test_cp_2: create ext2 on /dev/sda1 */
2940 char device[] = "/dev/sda";
2943 r = guestfs_blockdev_setrw (g, device);
2950 r = guestfs_umount_all (g);
2957 r = guestfs_lvm_remove_all (g);
2962 char device[] = "/dev/sda";
2963 char lines_0[] = ",";
2970 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
2975 char fstype[] = "ext2";
2976 char device[] = "/dev/sda1";
2979 r = guestfs_mkfs (g, fstype, device);
2984 char device[] = "/dev/sda1";
2985 char mountpoint[] = "/";
2988 r = guestfs_mount (g, device, mountpoint);
2992 /* TestOutput for cp (2) */
2993 char expected[] = "file content";
2995 char path[] = "/old";
2996 char content[] = "file content";
2999 r = guestfs_write_file (g, path, content, 0);
3004 char path[] = "/dir";
3007 r = guestfs_mkdir (g, path);
3012 char src[] = "/old";
3013 char dest[] = "/dir/new";
3016 r = guestfs_cp (g, src, dest);
3021 char path[] = "/dir/new";
3024 r = guestfs_cat (g, path);
3027 if (strcmp (r, expected) != 0) {
3028 fprintf (stderr, "test_cp_2: expected \"%s\" but got \"%s\"\n", expected, r);
3036 static int test_grub_install_0_skip (void)
3040 str = getenv ("SKIP_TEST_GRUB_INSTALL_0");
3041 if (str && strcmp (str, "1") == 0) return 1;
3042 str = getenv ("SKIP_TEST_GRUB_INSTALL");
3043 if (str && strcmp (str, "1") == 0) return 1;
3047 static int test_grub_install_0 (void)
3049 if (test_grub_install_0_skip ()) {
3050 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_grub_install_0");
3054 /* InitBasicFS for test_grub_install_0: create ext2 on /dev/sda1 */
3056 char device[] = "/dev/sda";
3059 r = guestfs_blockdev_setrw (g, device);
3066 r = guestfs_umount_all (g);
3073 r = guestfs_lvm_remove_all (g);
3078 char device[] = "/dev/sda";
3079 char lines_0[] = ",";
3086 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3091 char fstype[] = "ext2";
3092 char device[] = "/dev/sda1";
3095 r = guestfs_mkfs (g, fstype, device);
3100 char device[] = "/dev/sda1";
3101 char mountpoint[] = "/";
3104 r = guestfs_mount (g, device, mountpoint);
3108 /* TestOutputTrue for grub_install (0) */
3111 char device[] = "/dev/sda1";
3114 r = guestfs_grub_install (g, root, device);
3119 char path[] = "/boot";
3122 r = guestfs_is_dir (g, path);
3126 fprintf (stderr, "test_grub_install_0: expected true, got false\n");
3133 static int test_zero_0_skip (void)
3137 str = getenv ("SKIP_TEST_ZERO_0");
3138 if (str && strcmp (str, "1") == 0) return 1;
3139 str = getenv ("SKIP_TEST_ZERO");
3140 if (str && strcmp (str, "1") == 0) return 1;
3144 static int test_zero_0 (void)
3146 if (test_zero_0_skip ()) {
3147 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_zero_0");
3151 /* InitBasicFS for test_zero_0: create ext2 on /dev/sda1 */
3153 char device[] = "/dev/sda";
3156 r = guestfs_blockdev_setrw (g, device);
3163 r = guestfs_umount_all (g);
3170 r = guestfs_lvm_remove_all (g);
3175 char device[] = "/dev/sda";
3176 char lines_0[] = ",";
3183 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3188 char fstype[] = "ext2";
3189 char device[] = "/dev/sda1";
3192 r = guestfs_mkfs (g, fstype, device);
3197 char device[] = "/dev/sda1";
3198 char mountpoint[] = "/";
3201 r = guestfs_mount (g, device, mountpoint);
3205 /* TestOutput for zero (0) */
3206 char expected[] = "data";
3208 char pathordevice[] = "/dev/sda1";
3211 r = guestfs_umount (g, pathordevice);
3216 char device[] = "/dev/sda1";
3219 r = guestfs_zero (g, device);
3224 char path[] = "/dev/sda1";
3227 r = guestfs_file (g, path);
3230 if (strcmp (r, expected) != 0) {
3231 fprintf (stderr, "test_zero_0: expected \"%s\" but got \"%s\"\n", expected, r);
3239 static int test_fsck_0_skip (void)
3243 str = getenv ("SKIP_TEST_FSCK_0");
3244 if (str && strcmp (str, "1") == 0) return 1;
3245 str = getenv ("SKIP_TEST_FSCK");
3246 if (str && strcmp (str, "1") == 0) return 1;
3250 static int test_fsck_0 (void)
3252 if (test_fsck_0_skip ()) {
3253 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_0");
3257 /* InitBasicFS for test_fsck_0: create ext2 on /dev/sda1 */
3259 char device[] = "/dev/sda";
3262 r = guestfs_blockdev_setrw (g, device);
3269 r = guestfs_umount_all (g);
3276 r = guestfs_lvm_remove_all (g);
3281 char device[] = "/dev/sda";
3282 char lines_0[] = ",";
3289 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3294 char fstype[] = "ext2";
3295 char device[] = "/dev/sda1";
3298 r = guestfs_mkfs (g, fstype, device);
3303 char device[] = "/dev/sda1";
3304 char mountpoint[] = "/";
3307 r = guestfs_mount (g, device, mountpoint);
3311 /* TestOutputInt for fsck (0) */
3313 char pathordevice[] = "/dev/sda1";
3316 r = guestfs_umount (g, pathordevice);
3321 char fstype[] = "ext2";
3322 char device[] = "/dev/sda1";
3325 r = guestfs_fsck (g, fstype, device);
3329 fprintf (stderr, "test_fsck_0: expected 0 but got %d\n", (int) r);
3336 static int test_fsck_1_skip (void)
3340 str = getenv ("SKIP_TEST_FSCK_1");
3341 if (str && strcmp (str, "1") == 0) return 1;
3342 str = getenv ("SKIP_TEST_FSCK");
3343 if (str && strcmp (str, "1") == 0) return 1;
3347 static int test_fsck_1 (void)
3349 if (test_fsck_1_skip ()) {
3350 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_fsck_1");
3354 /* InitBasicFS for test_fsck_1: create ext2 on /dev/sda1 */
3356 char device[] = "/dev/sda";
3359 r = guestfs_blockdev_setrw (g, device);
3366 r = guestfs_umount_all (g);
3373 r = guestfs_lvm_remove_all (g);
3378 char device[] = "/dev/sda";
3379 char lines_0[] = ",";
3386 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3391 char fstype[] = "ext2";
3392 char device[] = "/dev/sda1";
3395 r = guestfs_mkfs (g, fstype, device);
3400 char device[] = "/dev/sda1";
3401 char mountpoint[] = "/";
3404 r = guestfs_mount (g, device, mountpoint);
3408 /* TestOutputInt for fsck (1) */
3410 char pathordevice[] = "/dev/sda1";
3413 r = guestfs_umount (g, pathordevice);
3418 char device[] = "/dev/sda1";
3421 r = guestfs_zero (g, device);
3426 char fstype[] = "ext2";
3427 char device[] = "/dev/sda1";
3430 r = guestfs_fsck (g, fstype, device);
3434 fprintf (stderr, "test_fsck_1: expected 8 but got %d\n", (int) r);
3441 static int test_set_e2uuid_0_skip (void)
3445 str = getenv ("SKIP_TEST_SET_E2UUID_0");
3446 if (str && strcmp (str, "1") == 0) return 1;
3447 str = getenv ("SKIP_TEST_SET_E2UUID");
3448 if (str && strcmp (str, "1") == 0) return 1;
3452 static int test_set_e2uuid_0 (void)
3454 if (test_set_e2uuid_0_skip ()) {
3455 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_0");
3459 /* InitBasicFS for test_set_e2uuid_0: create ext2 on /dev/sda1 */
3461 char device[] = "/dev/sda";
3464 r = guestfs_blockdev_setrw (g, device);
3471 r = guestfs_umount_all (g);
3478 r = guestfs_lvm_remove_all (g);
3483 char device[] = "/dev/sda";
3484 char lines_0[] = ",";
3491 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3496 char fstype[] = "ext2";
3497 char device[] = "/dev/sda1";
3500 r = guestfs_mkfs (g, fstype, device);
3505 char device[] = "/dev/sda1";
3506 char mountpoint[] = "/";
3509 r = guestfs_mount (g, device, mountpoint);
3513 /* TestOutput for set_e2uuid (0) */
3514 char expected[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3516 char device[] = "/dev/sda1";
3517 char uuid[] = "a3a61220-882b-4f61-89f4-cf24dcc7297d";
3520 r = guestfs_set_e2uuid (g, device, uuid);
3525 char device[] = "/dev/sda1";
3528 r = guestfs_get_e2uuid (g, device);
3531 if (strcmp (r, expected) != 0) {
3532 fprintf (stderr, "test_set_e2uuid_0: expected \"%s\" but got \"%s\"\n", expected, r);
3540 static int test_set_e2uuid_1_skip (void)
3544 str = getenv ("SKIP_TEST_SET_E2UUID_1");
3545 if (str && strcmp (str, "1") == 0) return 1;
3546 str = getenv ("SKIP_TEST_SET_E2UUID");
3547 if (str && strcmp (str, "1") == 0) return 1;
3551 static int test_set_e2uuid_1 (void)
3553 if (test_set_e2uuid_1_skip ()) {
3554 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_1");
3558 /* InitBasicFS for test_set_e2uuid_1: create ext2 on /dev/sda1 */
3560 char device[] = "/dev/sda";
3563 r = guestfs_blockdev_setrw (g, device);
3570 r = guestfs_umount_all (g);
3577 r = guestfs_lvm_remove_all (g);
3582 char device[] = "/dev/sda";
3583 char lines_0[] = ",";
3590 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3595 char fstype[] = "ext2";
3596 char device[] = "/dev/sda1";
3599 r = guestfs_mkfs (g, fstype, device);
3604 char device[] = "/dev/sda1";
3605 char mountpoint[] = "/";
3608 r = guestfs_mount (g, device, mountpoint);
3612 /* TestOutput for set_e2uuid (1) */
3613 char expected[] = "";
3615 char device[] = "/dev/sda1";
3616 char uuid[] = "clear";
3619 r = guestfs_set_e2uuid (g, device, uuid);
3624 char device[] = "/dev/sda1";
3627 r = guestfs_get_e2uuid (g, device);
3630 if (strcmp (r, expected) != 0) {
3631 fprintf (stderr, "test_set_e2uuid_1: expected \"%s\" but got \"%s\"\n", expected, r);
3639 static int test_set_e2uuid_2_skip (void)
3643 str = getenv ("SKIP_TEST_SET_E2UUID_2");
3644 if (str && strcmp (str, "1") == 0) return 1;
3645 str = getenv ("SKIP_TEST_SET_E2UUID");
3646 if (str && strcmp (str, "1") == 0) return 1;
3650 static int test_set_e2uuid_2 (void)
3652 if (test_set_e2uuid_2_skip ()) {
3653 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_2");
3657 /* InitBasicFS for test_set_e2uuid_2: create ext2 on /dev/sda1 */
3659 char device[] = "/dev/sda";
3662 r = guestfs_blockdev_setrw (g, device);
3669 r = guestfs_umount_all (g);
3676 r = guestfs_lvm_remove_all (g);
3681 char device[] = "/dev/sda";
3682 char lines_0[] = ",";
3689 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3694 char fstype[] = "ext2";
3695 char device[] = "/dev/sda1";
3698 r = guestfs_mkfs (g, fstype, device);
3703 char device[] = "/dev/sda1";
3704 char mountpoint[] = "/";
3707 r = guestfs_mount (g, device, mountpoint);
3711 /* TestRun for set_e2uuid (2) */
3713 char device[] = "/dev/sda1";
3714 char uuid[] = "random";
3717 r = guestfs_set_e2uuid (g, device, uuid);
3724 static int test_set_e2uuid_3_skip (void)
3728 str = getenv ("SKIP_TEST_SET_E2UUID_3");
3729 if (str && strcmp (str, "1") == 0) return 1;
3730 str = getenv ("SKIP_TEST_SET_E2UUID");
3731 if (str && strcmp (str, "1") == 0) return 1;
3735 static int test_set_e2uuid_3 (void)
3737 if (test_set_e2uuid_3_skip ()) {
3738 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2uuid_3");
3742 /* InitBasicFS for test_set_e2uuid_3: create ext2 on /dev/sda1 */
3744 char device[] = "/dev/sda";
3747 r = guestfs_blockdev_setrw (g, device);
3754 r = guestfs_umount_all (g);
3761 r = guestfs_lvm_remove_all (g);
3766 char device[] = "/dev/sda";
3767 char lines_0[] = ",";
3774 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3779 char fstype[] = "ext2";
3780 char device[] = "/dev/sda1";
3783 r = guestfs_mkfs (g, fstype, device);
3788 char device[] = "/dev/sda1";
3789 char mountpoint[] = "/";
3792 r = guestfs_mount (g, device, mountpoint);
3796 /* TestRun for set_e2uuid (3) */
3798 char device[] = "/dev/sda1";
3799 char uuid[] = "time";
3802 r = guestfs_set_e2uuid (g, device, uuid);
3809 static int test_set_e2label_0_skip (void)
3813 str = getenv ("SKIP_TEST_SET_E2LABEL_0");
3814 if (str && strcmp (str, "1") == 0) return 1;
3815 str = getenv ("SKIP_TEST_SET_E2LABEL");
3816 if (str && strcmp (str, "1") == 0) return 1;
3820 static int test_set_e2label_0 (void)
3822 if (test_set_e2label_0_skip ()) {
3823 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_set_e2label_0");
3827 /* InitBasicFS for test_set_e2label_0: create ext2 on /dev/sda1 */
3829 char device[] = "/dev/sda";
3832 r = guestfs_blockdev_setrw (g, device);
3839 r = guestfs_umount_all (g);
3846 r = guestfs_lvm_remove_all (g);
3851 char device[] = "/dev/sda";
3852 char lines_0[] = ",";
3859 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3864 char fstype[] = "ext2";
3865 char device[] = "/dev/sda1";
3868 r = guestfs_mkfs (g, fstype, device);
3873 char device[] = "/dev/sda1";
3874 char mountpoint[] = "/";
3877 r = guestfs_mount (g, device, mountpoint);
3881 /* TestOutput for set_e2label (0) */
3882 char expected[] = "testlabel";
3884 char device[] = "/dev/sda1";
3885 char label[] = "testlabel";
3888 r = guestfs_set_e2label (g, device, label);
3893 char device[] = "/dev/sda1";
3896 r = guestfs_get_e2label (g, device);
3899 if (strcmp (r, expected) != 0) {
3900 fprintf (stderr, "test_set_e2label_0: expected \"%s\" but got \"%s\"\n", expected, r);
3908 static int test_pvremove_0_skip (void)
3912 str = getenv ("SKIP_TEST_PVREMOVE_0");
3913 if (str && strcmp (str, "1") == 0) return 1;
3914 str = getenv ("SKIP_TEST_PVREMOVE");
3915 if (str && strcmp (str, "1") == 0) return 1;
3919 static int test_pvremove_0 (void)
3921 if (test_pvremove_0_skip ()) {
3922 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_0");
3926 /* InitNone|InitEmpty for test_pvremove_0 */
3928 char device[] = "/dev/sda";
3931 r = guestfs_blockdev_setrw (g, device);
3938 r = guestfs_umount_all (g);
3945 r = guestfs_lvm_remove_all (g);
3949 /* TestOutputListOfDevices for pvremove (0) */
3951 char device[] = "/dev/sda";
3952 char lines_0[] = ",";
3959 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
3964 char device[] = "/dev/sda1";
3967 r = guestfs_pvcreate (g, device);
3972 char volgroup[] = "VG";
3973 char physvols_0[] = "/dev/sda1";
3974 char *physvols[] = {
3980 r = guestfs_vgcreate (g, volgroup, physvols);
3985 char logvol[] = "LV1";
3986 char volgroup[] = "VG";
3989 r = guestfs_lvcreate (g, logvol, volgroup, 50);
3994 char logvol[] = "LV2";
3995 char volgroup[] = "VG";
3998 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4003 char vgname[] = "VG";
4006 r = guestfs_vgremove (g, vgname);
4011 char device[] = "/dev/sda1";
4014 r = guestfs_pvremove (g, device);
4022 r = guestfs_lvs (g);
4026 fprintf (stderr, "test_pvremove_0: extra elements returned from command\n");
4030 for (i = 0; r[i] != NULL; ++i)
4037 static int test_pvremove_1_skip (void)
4041 str = getenv ("SKIP_TEST_PVREMOVE_1");
4042 if (str && strcmp (str, "1") == 0) return 1;
4043 str = getenv ("SKIP_TEST_PVREMOVE");
4044 if (str && strcmp (str, "1") == 0) return 1;
4048 static int test_pvremove_1 (void)
4050 if (test_pvremove_1_skip ()) {
4051 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_1");
4055 /* InitNone|InitEmpty for test_pvremove_1 */
4057 char device[] = "/dev/sda";
4060 r = guestfs_blockdev_setrw (g, device);
4067 r = guestfs_umount_all (g);
4074 r = guestfs_lvm_remove_all (g);
4078 /* TestOutputListOfDevices for pvremove (1) */
4080 char device[] = "/dev/sda";
4081 char lines_0[] = ",";
4088 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4093 char device[] = "/dev/sda1";
4096 r = guestfs_pvcreate (g, device);
4101 char volgroup[] = "VG";
4102 char physvols_0[] = "/dev/sda1";
4103 char *physvols[] = {
4109 r = guestfs_vgcreate (g, volgroup, physvols);
4114 char logvol[] = "LV1";
4115 char volgroup[] = "VG";
4118 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4123 char logvol[] = "LV2";
4124 char volgroup[] = "VG";
4127 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4132 char vgname[] = "VG";
4135 r = guestfs_vgremove (g, vgname);
4140 char device[] = "/dev/sda1";
4143 r = guestfs_pvremove (g, device);
4151 r = guestfs_vgs (g);
4155 fprintf (stderr, "test_pvremove_1: extra elements returned from command\n");
4159 for (i = 0; r[i] != NULL; ++i)
4166 static int test_pvremove_2_skip (void)
4170 str = getenv ("SKIP_TEST_PVREMOVE_2");
4171 if (str && strcmp (str, "1") == 0) return 1;
4172 str = getenv ("SKIP_TEST_PVREMOVE");
4173 if (str && strcmp (str, "1") == 0) return 1;
4177 static int test_pvremove_2 (void)
4179 if (test_pvremove_2_skip ()) {
4180 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvremove_2");
4184 /* InitNone|InitEmpty for test_pvremove_2 */
4186 char device[] = "/dev/sda";
4189 r = guestfs_blockdev_setrw (g, device);
4196 r = guestfs_umount_all (g);
4203 r = guestfs_lvm_remove_all (g);
4207 /* TestOutputListOfDevices for pvremove (2) */
4209 char device[] = "/dev/sda";
4210 char lines_0[] = ",";
4217 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4222 char device[] = "/dev/sda1";
4225 r = guestfs_pvcreate (g, device);
4230 char volgroup[] = "VG";
4231 char physvols_0[] = "/dev/sda1";
4232 char *physvols[] = {
4238 r = guestfs_vgcreate (g, volgroup, physvols);
4243 char logvol[] = "LV1";
4244 char volgroup[] = "VG";
4247 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4252 char logvol[] = "LV2";
4253 char volgroup[] = "VG";
4256 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4261 char vgname[] = "VG";
4264 r = guestfs_vgremove (g, vgname);
4269 char device[] = "/dev/sda1";
4272 r = guestfs_pvremove (g, device);
4280 r = guestfs_pvs (g);
4284 fprintf (stderr, "test_pvremove_2: extra elements returned from command\n");
4288 for (i = 0; r[i] != NULL; ++i)
4295 static int test_vgremove_0_skip (void)
4299 str = getenv ("SKIP_TEST_VGREMOVE_0");
4300 if (str && strcmp (str, "1") == 0) return 1;
4301 str = getenv ("SKIP_TEST_VGREMOVE");
4302 if (str && strcmp (str, "1") == 0) return 1;
4306 static int test_vgremove_0 (void)
4308 if (test_vgremove_0_skip ()) {
4309 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_0");
4313 /* InitNone|InitEmpty for test_vgremove_0 */
4315 char device[] = "/dev/sda";
4318 r = guestfs_blockdev_setrw (g, device);
4325 r = guestfs_umount_all (g);
4332 r = guestfs_lvm_remove_all (g);
4336 /* TestOutputList for vgremove (0) */
4338 char device[] = "/dev/sda";
4339 char lines_0[] = ",";
4346 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4351 char device[] = "/dev/sda1";
4354 r = guestfs_pvcreate (g, device);
4359 char volgroup[] = "VG";
4360 char physvols_0[] = "/dev/sda1";
4361 char *physvols[] = {
4367 r = guestfs_vgcreate (g, volgroup, physvols);
4372 char logvol[] = "LV1";
4373 char volgroup[] = "VG";
4376 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4381 char logvol[] = "LV2";
4382 char volgroup[] = "VG";
4385 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4390 char vgname[] = "VG";
4393 r = guestfs_vgremove (g, vgname);
4401 r = guestfs_lvs (g);
4405 fprintf (stderr, "test_vgremove_0: extra elements returned from command\n");
4409 for (i = 0; r[i] != NULL; ++i)
4416 static int test_vgremove_1_skip (void)
4420 str = getenv ("SKIP_TEST_VGREMOVE_1");
4421 if (str && strcmp (str, "1") == 0) return 1;
4422 str = getenv ("SKIP_TEST_VGREMOVE");
4423 if (str && strcmp (str, "1") == 0) return 1;
4427 static int test_vgremove_1 (void)
4429 if (test_vgremove_1_skip ()) {
4430 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgremove_1");
4434 /* InitNone|InitEmpty for test_vgremove_1 */
4436 char device[] = "/dev/sda";
4439 r = guestfs_blockdev_setrw (g, device);
4446 r = guestfs_umount_all (g);
4453 r = guestfs_lvm_remove_all (g);
4457 /* TestOutputList for vgremove (1) */
4459 char device[] = "/dev/sda";
4460 char lines_0[] = ",";
4467 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4472 char device[] = "/dev/sda1";
4475 r = guestfs_pvcreate (g, device);
4480 char volgroup[] = "VG";
4481 char physvols_0[] = "/dev/sda1";
4482 char *physvols[] = {
4488 r = guestfs_vgcreate (g, volgroup, physvols);
4493 char logvol[] = "LV1";
4494 char volgroup[] = "VG";
4497 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4502 char logvol[] = "LV2";
4503 char volgroup[] = "VG";
4506 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4511 char vgname[] = "VG";
4514 r = guestfs_vgremove (g, vgname);
4522 r = guestfs_vgs (g);
4526 fprintf (stderr, "test_vgremove_1: extra elements returned from command\n");
4530 for (i = 0; r[i] != NULL; ++i)
4537 static int test_lvremove_0_skip (void)
4541 str = getenv ("SKIP_TEST_LVREMOVE_0");
4542 if (str && strcmp (str, "1") == 0) return 1;
4543 str = getenv ("SKIP_TEST_LVREMOVE");
4544 if (str && strcmp (str, "1") == 0) return 1;
4548 static int test_lvremove_0 (void)
4550 if (test_lvremove_0_skip ()) {
4551 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_0");
4555 /* InitNone|InitEmpty for test_lvremove_0 */
4557 char device[] = "/dev/sda";
4560 r = guestfs_blockdev_setrw (g, device);
4567 r = guestfs_umount_all (g);
4574 r = guestfs_lvm_remove_all (g);
4578 /* TestOutputList for lvremove (0) */
4580 char device[] = "/dev/sda";
4581 char lines_0[] = ",";
4588 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4593 char device[] = "/dev/sda1";
4596 r = guestfs_pvcreate (g, device);
4601 char volgroup[] = "VG";
4602 char physvols_0[] = "/dev/sda1";
4603 char *physvols[] = {
4609 r = guestfs_vgcreate (g, volgroup, physvols);
4614 char logvol[] = "LV1";
4615 char volgroup[] = "VG";
4618 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4623 char logvol[] = "LV2";
4624 char volgroup[] = "VG";
4627 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4632 char device[] = "/dev/VG/LV1";
4635 r = guestfs_lvremove (g, device);
4643 r = guestfs_lvs (g);
4647 fprintf (stderr, "test_lvremove_0: short list returned from command\n");
4652 char expected[] = "/dev/VG/LV2";
4653 if (strcmp (r[0], expected) != 0) {
4654 fprintf (stderr, "test_lvremove_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4659 fprintf (stderr, "test_lvremove_0: extra elements returned from command\n");
4663 for (i = 0; r[i] != NULL; ++i)
4670 static int test_lvremove_1_skip (void)
4674 str = getenv ("SKIP_TEST_LVREMOVE_1");
4675 if (str && strcmp (str, "1") == 0) return 1;
4676 str = getenv ("SKIP_TEST_LVREMOVE");
4677 if (str && strcmp (str, "1") == 0) return 1;
4681 static int test_lvremove_1 (void)
4683 if (test_lvremove_1_skip ()) {
4684 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_1");
4688 /* InitNone|InitEmpty for test_lvremove_1 */
4690 char device[] = "/dev/sda";
4693 r = guestfs_blockdev_setrw (g, device);
4700 r = guestfs_umount_all (g);
4707 r = guestfs_lvm_remove_all (g);
4711 /* TestOutputList for lvremove (1) */
4713 char device[] = "/dev/sda";
4714 char lines_0[] = ",";
4721 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4726 char device[] = "/dev/sda1";
4729 r = guestfs_pvcreate (g, device);
4734 char volgroup[] = "VG";
4735 char physvols_0[] = "/dev/sda1";
4736 char *physvols[] = {
4742 r = guestfs_vgcreate (g, volgroup, physvols);
4747 char logvol[] = "LV1";
4748 char volgroup[] = "VG";
4751 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4756 char logvol[] = "LV2";
4757 char volgroup[] = "VG";
4760 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4765 char device[] = "/dev/VG";
4768 r = guestfs_lvremove (g, device);
4776 r = guestfs_lvs (g);
4780 fprintf (stderr, "test_lvremove_1: extra elements returned from command\n");
4784 for (i = 0; r[i] != NULL; ++i)
4791 static int test_lvremove_2_skip (void)
4795 str = getenv ("SKIP_TEST_LVREMOVE_2");
4796 if (str && strcmp (str, "1") == 0) return 1;
4797 str = getenv ("SKIP_TEST_LVREMOVE");
4798 if (str && strcmp (str, "1") == 0) return 1;
4802 static int test_lvremove_2 (void)
4804 if (test_lvremove_2_skip ()) {
4805 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvremove_2");
4809 /* InitNone|InitEmpty for test_lvremove_2 */
4811 char device[] = "/dev/sda";
4814 r = guestfs_blockdev_setrw (g, device);
4821 r = guestfs_umount_all (g);
4828 r = guestfs_lvm_remove_all (g);
4832 /* TestOutputList for lvremove (2) */
4834 char device[] = "/dev/sda";
4835 char lines_0[] = ",";
4842 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4847 char device[] = "/dev/sda1";
4850 r = guestfs_pvcreate (g, device);
4855 char volgroup[] = "VG";
4856 char physvols_0[] = "/dev/sda1";
4857 char *physvols[] = {
4863 r = guestfs_vgcreate (g, volgroup, physvols);
4868 char logvol[] = "LV1";
4869 char volgroup[] = "VG";
4872 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4877 char logvol[] = "LV2";
4878 char volgroup[] = "VG";
4881 r = guestfs_lvcreate (g, logvol, volgroup, 50);
4886 char device[] = "/dev/VG";
4889 r = guestfs_lvremove (g, device);
4897 r = guestfs_vgs (g);
4901 fprintf (stderr, "test_lvremove_2: short list returned from command\n");
4906 char expected[] = "VG";
4907 if (strcmp (r[0], expected) != 0) {
4908 fprintf (stderr, "test_lvremove_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
4913 fprintf (stderr, "test_lvremove_2: extra elements returned from command\n");
4917 for (i = 0; r[i] != NULL; ++i)
4924 static int test_mount_ro_0_skip (void)
4928 str = getenv ("SKIP_TEST_MOUNT_RO_0");
4929 if (str && strcmp (str, "1") == 0) return 1;
4930 str = getenv ("SKIP_TEST_MOUNT_RO");
4931 if (str && strcmp (str, "1") == 0) return 1;
4935 static int test_mount_ro_0 (void)
4937 if (test_mount_ro_0_skip ()) {
4938 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_0");
4942 /* InitBasicFS for test_mount_ro_0: create ext2 on /dev/sda1 */
4944 char device[] = "/dev/sda";
4947 r = guestfs_blockdev_setrw (g, device);
4954 r = guestfs_umount_all (g);
4961 r = guestfs_lvm_remove_all (g);
4966 char device[] = "/dev/sda";
4967 char lines_0[] = ",";
4974 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
4979 char fstype[] = "ext2";
4980 char device[] = "/dev/sda1";
4983 r = guestfs_mkfs (g, fstype, device);
4988 char device[] = "/dev/sda1";
4989 char mountpoint[] = "/";
4992 r = guestfs_mount (g, device, mountpoint);
4996 /* TestLastFail for mount_ro (0) */
4998 char pathordevice[] = "/";
5001 r = guestfs_umount (g, pathordevice);
5006 char device[] = "/dev/sda1";
5007 char mountpoint[] = "/";
5010 r = guestfs_mount_ro (g, device, mountpoint);
5015 char path[] = "/new";
5018 r = guestfs_touch (g, path);
5025 static int test_mount_ro_1_skip (void)
5029 str = getenv ("SKIP_TEST_MOUNT_RO_1");
5030 if (str && strcmp (str, "1") == 0) return 1;
5031 str = getenv ("SKIP_TEST_MOUNT_RO");
5032 if (str && strcmp (str, "1") == 0) return 1;
5036 static int test_mount_ro_1 (void)
5038 if (test_mount_ro_1_skip ()) {
5039 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_ro_1");
5043 /* InitBasicFS for test_mount_ro_1: create ext2 on /dev/sda1 */
5045 char device[] = "/dev/sda";
5048 r = guestfs_blockdev_setrw (g, device);
5055 r = guestfs_umount_all (g);
5062 r = guestfs_lvm_remove_all (g);
5067 char device[] = "/dev/sda";
5068 char lines_0[] = ",";
5075 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5080 char fstype[] = "ext2";
5081 char device[] = "/dev/sda1";
5084 r = guestfs_mkfs (g, fstype, device);
5089 char device[] = "/dev/sda1";
5090 char mountpoint[] = "/";
5093 r = guestfs_mount (g, device, mountpoint);
5097 /* TestOutput for mount_ro (1) */
5098 char expected[] = "data";
5100 char path[] = "/new";
5101 char content[] = "data";
5104 r = guestfs_write_file (g, path, content, 0);
5109 char pathordevice[] = "/";
5112 r = guestfs_umount (g, pathordevice);
5117 char device[] = "/dev/sda1";
5118 char mountpoint[] = "/";
5121 r = guestfs_mount_ro (g, device, mountpoint);
5126 char path[] = "/new";
5129 r = guestfs_cat (g, path);
5132 if (strcmp (r, expected) != 0) {
5133 fprintf (stderr, "test_mount_ro_1: expected \"%s\" but got \"%s\"\n", expected, r);
5141 static int test_tgz_in_0_skip (void)
5145 str = getenv ("SKIP_TEST_TGZ_IN_0");
5146 if (str && strcmp (str, "1") == 0) return 1;
5147 str = getenv ("SKIP_TEST_TGZ_IN");
5148 if (str && strcmp (str, "1") == 0) return 1;
5152 static int test_tgz_in_0 (void)
5154 if (test_tgz_in_0_skip ()) {
5155 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tgz_in_0");
5159 /* InitBasicFS for test_tgz_in_0: create ext2 on /dev/sda1 */
5161 char device[] = "/dev/sda";
5164 r = guestfs_blockdev_setrw (g, device);
5171 r = guestfs_umount_all (g);
5178 r = guestfs_lvm_remove_all (g);
5183 char device[] = "/dev/sda";
5184 char lines_0[] = ",";
5191 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5196 char fstype[] = "ext2";
5197 char device[] = "/dev/sda1";
5200 r = guestfs_mkfs (g, fstype, device);
5205 char device[] = "/dev/sda1";
5206 char mountpoint[] = "/";
5209 r = guestfs_mount (g, device, mountpoint);
5213 /* TestOutput for tgz_in (0) */
5214 char expected[] = "hello\n";
5216 char directory[] = "/";
5219 r = guestfs_tgz_in (g, "../images/helloworld.tar.gz", directory);
5224 char path[] = "/hello";
5227 r = guestfs_cat (g, path);
5230 if (strcmp (r, expected) != 0) {
5231 fprintf (stderr, "test_tgz_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5239 static int test_tar_in_0_skip (void)
5243 str = getenv ("SKIP_TEST_TAR_IN_0");
5244 if (str && strcmp (str, "1") == 0) return 1;
5245 str = getenv ("SKIP_TEST_TAR_IN");
5246 if (str && strcmp (str, "1") == 0) return 1;
5250 static int test_tar_in_0 (void)
5252 if (test_tar_in_0_skip ()) {
5253 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_tar_in_0");
5257 /* InitBasicFS for test_tar_in_0: create ext2 on /dev/sda1 */
5259 char device[] = "/dev/sda";
5262 r = guestfs_blockdev_setrw (g, device);
5269 r = guestfs_umount_all (g);
5276 r = guestfs_lvm_remove_all (g);
5281 char device[] = "/dev/sda";
5282 char lines_0[] = ",";
5289 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5294 char fstype[] = "ext2";
5295 char device[] = "/dev/sda1";
5298 r = guestfs_mkfs (g, fstype, device);
5303 char device[] = "/dev/sda1";
5304 char mountpoint[] = "/";
5307 r = guestfs_mount (g, device, mountpoint);
5311 /* TestOutput for tar_in (0) */
5312 char expected[] = "hello\n";
5314 char directory[] = "/";
5317 r = guestfs_tar_in (g, "../images/helloworld.tar", directory);
5322 char path[] = "/hello";
5325 r = guestfs_cat (g, path);
5328 if (strcmp (r, expected) != 0) {
5329 fprintf (stderr, "test_tar_in_0: expected \"%s\" but got \"%s\"\n", expected, r);
5337 static int test_checksum_0_skip (void)
5341 str = getenv ("SKIP_TEST_CHECKSUM_0");
5342 if (str && strcmp (str, "1") == 0) return 1;
5343 str = getenv ("SKIP_TEST_CHECKSUM");
5344 if (str && strcmp (str, "1") == 0) return 1;
5348 static int test_checksum_0 (void)
5350 if (test_checksum_0_skip ()) {
5351 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_0");
5355 /* InitBasicFS for test_checksum_0: create ext2 on /dev/sda1 */
5357 char device[] = "/dev/sda";
5360 r = guestfs_blockdev_setrw (g, device);
5367 r = guestfs_umount_all (g);
5374 r = guestfs_lvm_remove_all (g);
5379 char device[] = "/dev/sda";
5380 char lines_0[] = ",";
5387 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5392 char fstype[] = "ext2";
5393 char device[] = "/dev/sda1";
5396 r = guestfs_mkfs (g, fstype, device);
5401 char device[] = "/dev/sda1";
5402 char mountpoint[] = "/";
5405 r = guestfs_mount (g, device, mountpoint);
5409 /* TestOutput for checksum (0) */
5410 char expected[] = "935282863";
5412 char path[] = "/new";
5413 char content[] = "test\n";
5416 r = guestfs_write_file (g, path, content, 0);
5421 char csumtype[] = "crc";
5422 char path[] = "/new";
5425 r = guestfs_checksum (g, csumtype, path);
5428 if (strcmp (r, expected) != 0) {
5429 fprintf (stderr, "test_checksum_0: expected \"%s\" but got \"%s\"\n", expected, r);
5437 static int test_checksum_1_skip (void)
5441 str = getenv ("SKIP_TEST_CHECKSUM_1");
5442 if (str && strcmp (str, "1") == 0) return 1;
5443 str = getenv ("SKIP_TEST_CHECKSUM");
5444 if (str && strcmp (str, "1") == 0) return 1;
5448 static int test_checksum_1 (void)
5450 if (test_checksum_1_skip ()) {
5451 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_1");
5455 /* InitBasicFS for test_checksum_1: create ext2 on /dev/sda1 */
5457 char device[] = "/dev/sda";
5460 r = guestfs_blockdev_setrw (g, device);
5467 r = guestfs_umount_all (g);
5474 r = guestfs_lvm_remove_all (g);
5479 char device[] = "/dev/sda";
5480 char lines_0[] = ",";
5487 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5492 char fstype[] = "ext2";
5493 char device[] = "/dev/sda1";
5496 r = guestfs_mkfs (g, fstype, device);
5501 char device[] = "/dev/sda1";
5502 char mountpoint[] = "/";
5505 r = guestfs_mount (g, device, mountpoint);
5509 /* TestLastFail for checksum (1) */
5511 char csumtype[] = "crc";
5512 char path[] = "/new";
5515 r = guestfs_checksum (g, csumtype, path);
5523 static int test_checksum_2_skip (void)
5527 str = getenv ("SKIP_TEST_CHECKSUM_2");
5528 if (str && strcmp (str, "1") == 0) return 1;
5529 str = getenv ("SKIP_TEST_CHECKSUM");
5530 if (str && strcmp (str, "1") == 0) return 1;
5534 static int test_checksum_2 (void)
5536 if (test_checksum_2_skip ()) {
5537 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_2");
5541 /* InitBasicFS for test_checksum_2: create ext2 on /dev/sda1 */
5543 char device[] = "/dev/sda";
5546 r = guestfs_blockdev_setrw (g, device);
5553 r = guestfs_umount_all (g);
5560 r = guestfs_lvm_remove_all (g);
5565 char device[] = "/dev/sda";
5566 char lines_0[] = ",";
5573 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5578 char fstype[] = "ext2";
5579 char device[] = "/dev/sda1";
5582 r = guestfs_mkfs (g, fstype, device);
5587 char device[] = "/dev/sda1";
5588 char mountpoint[] = "/";
5591 r = guestfs_mount (g, device, mountpoint);
5595 /* TestOutput for checksum (2) */
5596 char expected[] = "d8e8fca2dc0f896fd7cb4cb0031ba249";
5598 char path[] = "/new";
5599 char content[] = "test\n";
5602 r = guestfs_write_file (g, path, content, 0);
5607 char csumtype[] = "md5";
5608 char path[] = "/new";
5611 r = guestfs_checksum (g, csumtype, path);
5614 if (strcmp (r, expected) != 0) {
5615 fprintf (stderr, "test_checksum_2: expected \"%s\" but got \"%s\"\n", expected, r);
5623 static int test_checksum_3_skip (void)
5627 str = getenv ("SKIP_TEST_CHECKSUM_3");
5628 if (str && strcmp (str, "1") == 0) return 1;
5629 str = getenv ("SKIP_TEST_CHECKSUM");
5630 if (str && strcmp (str, "1") == 0) return 1;
5634 static int test_checksum_3 (void)
5636 if (test_checksum_3_skip ()) {
5637 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_3");
5641 /* InitBasicFS for test_checksum_3: create ext2 on /dev/sda1 */
5643 char device[] = "/dev/sda";
5646 r = guestfs_blockdev_setrw (g, device);
5653 r = guestfs_umount_all (g);
5660 r = guestfs_lvm_remove_all (g);
5665 char device[] = "/dev/sda";
5666 char lines_0[] = ",";
5673 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5678 char fstype[] = "ext2";
5679 char device[] = "/dev/sda1";
5682 r = guestfs_mkfs (g, fstype, device);
5687 char device[] = "/dev/sda1";
5688 char mountpoint[] = "/";
5691 r = guestfs_mount (g, device, mountpoint);
5695 /* TestOutput for checksum (3) */
5696 char expected[] = "4e1243bd22c66e76c2ba9eddc1f91394e57f9f83";
5698 char path[] = "/new";
5699 char content[] = "test\n";
5702 r = guestfs_write_file (g, path, content, 0);
5707 char csumtype[] = "sha1";
5708 char path[] = "/new";
5711 r = guestfs_checksum (g, csumtype, path);
5714 if (strcmp (r, expected) != 0) {
5715 fprintf (stderr, "test_checksum_3: expected \"%s\" but got \"%s\"\n", expected, r);
5723 static int test_checksum_4_skip (void)
5727 str = getenv ("SKIP_TEST_CHECKSUM_4");
5728 if (str && strcmp (str, "1") == 0) return 1;
5729 str = getenv ("SKIP_TEST_CHECKSUM");
5730 if (str && strcmp (str, "1") == 0) return 1;
5734 static int test_checksum_4 (void)
5736 if (test_checksum_4_skip ()) {
5737 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_4");
5741 /* InitBasicFS for test_checksum_4: create ext2 on /dev/sda1 */
5743 char device[] = "/dev/sda";
5746 r = guestfs_blockdev_setrw (g, device);
5753 r = guestfs_umount_all (g);
5760 r = guestfs_lvm_remove_all (g);
5765 char device[] = "/dev/sda";
5766 char lines_0[] = ",";
5773 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5778 char fstype[] = "ext2";
5779 char device[] = "/dev/sda1";
5782 r = guestfs_mkfs (g, fstype, device);
5787 char device[] = "/dev/sda1";
5788 char mountpoint[] = "/";
5791 r = guestfs_mount (g, device, mountpoint);
5795 /* TestOutput for checksum (4) */
5796 char expected[] = "52f1bf093f4b7588726035c176c0cdb4376cfea53819f1395ac9e6ec";
5798 char path[] = "/new";
5799 char content[] = "test\n";
5802 r = guestfs_write_file (g, path, content, 0);
5807 char csumtype[] = "sha224";
5808 char path[] = "/new";
5811 r = guestfs_checksum (g, csumtype, path);
5814 if (strcmp (r, expected) != 0) {
5815 fprintf (stderr, "test_checksum_4: expected \"%s\" but got \"%s\"\n", expected, r);
5823 static int test_checksum_5_skip (void)
5827 str = getenv ("SKIP_TEST_CHECKSUM_5");
5828 if (str && strcmp (str, "1") == 0) return 1;
5829 str = getenv ("SKIP_TEST_CHECKSUM");
5830 if (str && strcmp (str, "1") == 0) return 1;
5834 static int test_checksum_5 (void)
5836 if (test_checksum_5_skip ()) {
5837 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_5");
5841 /* InitBasicFS for test_checksum_5: create ext2 on /dev/sda1 */
5843 char device[] = "/dev/sda";
5846 r = guestfs_blockdev_setrw (g, device);
5853 r = guestfs_umount_all (g);
5860 r = guestfs_lvm_remove_all (g);
5865 char device[] = "/dev/sda";
5866 char lines_0[] = ",";
5873 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5878 char fstype[] = "ext2";
5879 char device[] = "/dev/sda1";
5882 r = guestfs_mkfs (g, fstype, device);
5887 char device[] = "/dev/sda1";
5888 char mountpoint[] = "/";
5891 r = guestfs_mount (g, device, mountpoint);
5895 /* TestOutput for checksum (5) */
5896 char expected[] = "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2";
5898 char path[] = "/new";
5899 char content[] = "test\n";
5902 r = guestfs_write_file (g, path, content, 0);
5907 char csumtype[] = "sha256";
5908 char path[] = "/new";
5911 r = guestfs_checksum (g, csumtype, path);
5914 if (strcmp (r, expected) != 0) {
5915 fprintf (stderr, "test_checksum_5: expected \"%s\" but got \"%s\"\n", expected, r);
5923 static int test_checksum_6_skip (void)
5927 str = getenv ("SKIP_TEST_CHECKSUM_6");
5928 if (str && strcmp (str, "1") == 0) return 1;
5929 str = getenv ("SKIP_TEST_CHECKSUM");
5930 if (str && strcmp (str, "1") == 0) return 1;
5934 static int test_checksum_6 (void)
5936 if (test_checksum_6_skip ()) {
5937 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_6");
5941 /* InitBasicFS for test_checksum_6: create ext2 on /dev/sda1 */
5943 char device[] = "/dev/sda";
5946 r = guestfs_blockdev_setrw (g, device);
5953 r = guestfs_umount_all (g);
5960 r = guestfs_lvm_remove_all (g);
5965 char device[] = "/dev/sda";
5966 char lines_0[] = ",";
5973 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
5978 char fstype[] = "ext2";
5979 char device[] = "/dev/sda1";
5982 r = guestfs_mkfs (g, fstype, device);
5987 char device[] = "/dev/sda1";
5988 char mountpoint[] = "/";
5991 r = guestfs_mount (g, device, mountpoint);
5995 /* TestOutput for checksum (6) */
5996 char expected[] = "109bb6b5b6d5547c1ce03c7a8bd7d8f80c1cb0957f50c4f7fda04692079917e4f9cad52b878f3d8234e1a170b154b72d";
5998 char path[] = "/new";
5999 char content[] = "test\n";
6002 r = guestfs_write_file (g, path, content, 0);
6007 char csumtype[] = "sha384";
6008 char path[] = "/new";
6011 r = guestfs_checksum (g, csumtype, path);
6014 if (strcmp (r, expected) != 0) {
6015 fprintf (stderr, "test_checksum_6: expected \"%s\" but got \"%s\"\n", expected, r);
6023 static int test_checksum_7_skip (void)
6027 str = getenv ("SKIP_TEST_CHECKSUM_7");
6028 if (str && strcmp (str, "1") == 0) return 1;
6029 str = getenv ("SKIP_TEST_CHECKSUM");
6030 if (str && strcmp (str, "1") == 0) return 1;
6034 static int test_checksum_7 (void)
6036 if (test_checksum_7_skip ()) {
6037 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_7");
6041 /* InitBasicFS for test_checksum_7: create ext2 on /dev/sda1 */
6043 char device[] = "/dev/sda";
6046 r = guestfs_blockdev_setrw (g, device);
6053 r = guestfs_umount_all (g);
6060 r = guestfs_lvm_remove_all (g);
6065 char device[] = "/dev/sda";
6066 char lines_0[] = ",";
6073 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6078 char fstype[] = "ext2";
6079 char device[] = "/dev/sda1";
6082 r = guestfs_mkfs (g, fstype, device);
6087 char device[] = "/dev/sda1";
6088 char mountpoint[] = "/";
6091 r = guestfs_mount (g, device, mountpoint);
6095 /* TestOutput for checksum (7) */
6096 char expected[] = "0e3e75234abc68f4378a86b3f4b32a198ba301845b0cd6e50106e874345700cc6663a86c1ea125dc5e92be17c98f9a0f85ca9d5f595db2012f7cc3571945c123";
6098 char path[] = "/new";
6099 char content[] = "test\n";
6102 r = guestfs_write_file (g, path, content, 0);
6107 char csumtype[] = "sha512";
6108 char path[] = "/new";
6111 r = guestfs_checksum (g, csumtype, path);
6114 if (strcmp (r, expected) != 0) {
6115 fprintf (stderr, "test_checksum_7: expected \"%s\" but got \"%s\"\n", expected, r);
6123 static int test_checksum_8_skip (void)
6127 str = getenv ("SKIP_TEST_CHECKSUM_8");
6128 if (str && strcmp (str, "1") == 0) return 1;
6129 str = getenv ("SKIP_TEST_CHECKSUM");
6130 if (str && strcmp (str, "1") == 0) return 1;
6134 static int test_checksum_8 (void)
6136 if (test_checksum_8_skip ()) {
6137 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_checksum_8");
6141 /* InitBasicFS for test_checksum_8: create ext2 on /dev/sda1 */
6143 char device[] = "/dev/sda";
6146 r = guestfs_blockdev_setrw (g, device);
6153 r = guestfs_umount_all (g);
6160 r = guestfs_lvm_remove_all (g);
6165 char device[] = "/dev/sda";
6166 char lines_0[] = ",";
6173 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6178 char fstype[] = "ext2";
6179 char device[] = "/dev/sda1";
6182 r = guestfs_mkfs (g, fstype, device);
6187 char device[] = "/dev/sda1";
6188 char mountpoint[] = "/";
6191 r = guestfs_mount (g, device, mountpoint);
6195 /* TestOutput for checksum (8) */
6196 char expected[] = "46d6ca27ee07cdc6fa99c2e138cc522c";
6198 char options[] = "ro";
6199 char vfstype[] = "squashfs";
6200 char device[] = "/dev/sdd";
6201 char mountpoint[] = "/";
6204 r = guestfs_mount_vfs (g, options, vfstype, device, mountpoint);
6209 char csumtype[] = "md5";
6210 char path[] = "/known-3";
6213 r = guestfs_checksum (g, csumtype, path);
6216 if (strcmp (r, expected) != 0) {
6217 fprintf (stderr, "test_checksum_8: expected \"%s\" but got \"%s\"\n", expected, r);
6225 static int test_download_0_skip (void)
6229 str = getenv ("SKIP_TEST_DOWNLOAD_0");
6230 if (str && strcmp (str, "1") == 0) return 1;
6231 str = getenv ("SKIP_TEST_DOWNLOAD");
6232 if (str && strcmp (str, "1") == 0) return 1;
6236 static int test_download_0 (void)
6238 if (test_download_0_skip ()) {
6239 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_download_0");
6243 /* InitBasicFS for test_download_0: create ext2 on /dev/sda1 */
6245 char device[] = "/dev/sda";
6248 r = guestfs_blockdev_setrw (g, device);
6255 r = guestfs_umount_all (g);
6262 r = guestfs_lvm_remove_all (g);
6267 char device[] = "/dev/sda";
6268 char lines_0[] = ",";
6275 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6280 char fstype[] = "ext2";
6281 char device[] = "/dev/sda1";
6284 r = guestfs_mkfs (g, fstype, device);
6289 char device[] = "/dev/sda1";
6290 char mountpoint[] = "/";
6293 r = guestfs_mount (g, device, mountpoint);
6297 /* TestOutput for download (0) */
6298 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6300 char remotefilename[] = "/COPYING.LIB";
6303 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6308 char remotefilename[] = "/COPYING.LIB";
6311 r = guestfs_download (g, remotefilename, "testdownload.tmp");
6316 char remotefilename[] = "/upload";
6319 r = guestfs_upload (g, "testdownload.tmp", remotefilename);
6324 char csumtype[] = "md5";
6325 char path[] = "/upload";
6328 r = guestfs_checksum (g, csumtype, path);
6331 if (strcmp (r, expected) != 0) {
6332 fprintf (stderr, "test_download_0: expected \"%s\" but got \"%s\"\n", expected, r);
6340 static int test_upload_0_skip (void)
6344 str = getenv ("SKIP_TEST_UPLOAD_0");
6345 if (str && strcmp (str, "1") == 0) return 1;
6346 str = getenv ("SKIP_TEST_UPLOAD");
6347 if (str && strcmp (str, "1") == 0) return 1;
6351 static int test_upload_0 (void)
6353 if (test_upload_0_skip ()) {
6354 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_upload_0");
6358 /* InitBasicFS for test_upload_0: create ext2 on /dev/sda1 */
6360 char device[] = "/dev/sda";
6363 r = guestfs_blockdev_setrw (g, device);
6370 r = guestfs_umount_all (g);
6377 r = guestfs_lvm_remove_all (g);
6382 char device[] = "/dev/sda";
6383 char lines_0[] = ",";
6390 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
6395 char fstype[] = "ext2";
6396 char device[] = "/dev/sda1";
6399 r = guestfs_mkfs (g, fstype, device);
6404 char device[] = "/dev/sda1";
6405 char mountpoint[] = "/";
6408 r = guestfs_mount (g, device, mountpoint);
6412 /* TestOutput for upload (0) */
6413 char expected[] = "e3eda01d9815f8d24aae2dbd89b68b06";
6415 char remotefilename[] = "/COPYING.LIB";
6418 r = guestfs_upload (g, "../COPYING.LIB", remotefilename);
6423 char csumtype[] = "md5";
6424 char path[] = "/COPYING.LIB";
6427 r = guestfs_checksum (g, csumtype, path);
6430 if (strcmp (r, expected) != 0) {
6431 fprintf (stderr, "test_upload_0: expected \"%s\" but got \"%s\"\n", expected, r);
6439 static int test_blockdev_rereadpt_0_skip (void)
6443 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT_0");
6444 if (str && strcmp (str, "1") == 0) return 1;
6445 str = getenv ("SKIP_TEST_BLOCKDEV_REREADPT");
6446 if (str && strcmp (str, "1") == 0) return 1;
6450 static int test_blockdev_rereadpt_0 (void)
6452 if (test_blockdev_rereadpt_0_skip ()) {
6453 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_rereadpt_0");
6457 /* InitNone|InitEmpty for test_blockdev_rereadpt_0 */
6459 char device[] = "/dev/sda";
6462 r = guestfs_blockdev_setrw (g, device);
6469 r = guestfs_umount_all (g);
6476 r = guestfs_lvm_remove_all (g);
6480 /* TestRun for blockdev_rereadpt (0) */
6482 char device[] = "/dev/sda";
6485 r = guestfs_blockdev_rereadpt (g, device);
6492 static int test_blockdev_flushbufs_0_skip (void)
6496 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS_0");
6497 if (str && strcmp (str, "1") == 0) return 1;
6498 str = getenv ("SKIP_TEST_BLOCKDEV_FLUSHBUFS");
6499 if (str && strcmp (str, "1") == 0) return 1;
6503 static int test_blockdev_flushbufs_0 (void)
6505 if (test_blockdev_flushbufs_0_skip ()) {
6506 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_flushbufs_0");
6510 /* InitNone|InitEmpty for test_blockdev_flushbufs_0 */
6512 char device[] = "/dev/sda";
6515 r = guestfs_blockdev_setrw (g, device);
6522 r = guestfs_umount_all (g);
6529 r = guestfs_lvm_remove_all (g);
6533 /* TestRun for blockdev_flushbufs (0) */
6535 char device[] = "/dev/sda";
6538 r = guestfs_blockdev_flushbufs (g, device);
6545 static int test_blockdev_getsize64_0_skip (void)
6549 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64_0");
6550 if (str && strcmp (str, "1") == 0) return 1;
6551 str = getenv ("SKIP_TEST_BLOCKDEV_GETSIZE64");
6552 if (str && strcmp (str, "1") == 0) return 1;
6556 static int test_blockdev_getsize64_0 (void)
6558 if (test_blockdev_getsize64_0_skip ()) {
6559 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsize64_0");
6563 /* InitNone|InitEmpty for test_blockdev_getsize64_0 */
6565 char device[] = "/dev/sda";
6568 r = guestfs_blockdev_setrw (g, device);
6575 r = guestfs_umount_all (g);
6582 r = guestfs_lvm_remove_all (g);
6586 /* TestOutputInt for blockdev_getsize64 (0) */
6588 char device[] = "/dev/sda";
6591 r = guestfs_blockdev_getsize64 (g, device);
6594 if (r != 524288000) {
6595 fprintf (stderr, "test_blockdev_getsize64_0: expected 524288000 but got %d\n", (int) r);
6602 static int test_blockdev_getsz_0_skip (void)
6606 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ_0");
6607 if (str && strcmp (str, "1") == 0) return 1;
6608 str = getenv ("SKIP_TEST_BLOCKDEV_GETSZ");
6609 if (str && strcmp (str, "1") == 0) return 1;
6613 static int test_blockdev_getsz_0 (void)
6615 if (test_blockdev_getsz_0_skip ()) {
6616 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getsz_0");
6620 /* InitNone|InitEmpty for test_blockdev_getsz_0 */
6622 char device[] = "/dev/sda";
6625 r = guestfs_blockdev_setrw (g, device);
6632 r = guestfs_umount_all (g);
6639 r = guestfs_lvm_remove_all (g);
6643 /* TestOutputInt for blockdev_getsz (0) */
6645 char device[] = "/dev/sda";
6648 r = guestfs_blockdev_getsz (g, device);
6652 fprintf (stderr, "test_blockdev_getsz_0: expected 1024000 but got %d\n", (int) r);
6659 static int test_blockdev_getbsz_0_skip (void)
6663 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ_0");
6664 if (str && strcmp (str, "1") == 0) return 1;
6665 str = getenv ("SKIP_TEST_BLOCKDEV_GETBSZ");
6666 if (str && strcmp (str, "1") == 0) return 1;
6670 static int test_blockdev_getbsz_0 (void)
6672 if (test_blockdev_getbsz_0_skip ()) {
6673 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getbsz_0");
6677 /* InitNone|InitEmpty for test_blockdev_getbsz_0 */
6679 char device[] = "/dev/sda";
6682 r = guestfs_blockdev_setrw (g, device);
6689 r = guestfs_umount_all (g);
6696 r = guestfs_lvm_remove_all (g);
6700 /* TestOutputInt for blockdev_getbsz (0) */
6702 char device[] = "/dev/sda";
6705 r = guestfs_blockdev_getbsz (g, device);
6709 fprintf (stderr, "test_blockdev_getbsz_0: expected 4096 but got %d\n", (int) r);
6716 static int test_blockdev_getss_0_skip (void)
6720 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS_0");
6721 if (str && strcmp (str, "1") == 0) return 1;
6722 str = getenv ("SKIP_TEST_BLOCKDEV_GETSS");
6723 if (str && strcmp (str, "1") == 0) return 1;
6727 static int test_blockdev_getss_0 (void)
6729 if (test_blockdev_getss_0_skip ()) {
6730 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getss_0");
6734 /* InitNone|InitEmpty for test_blockdev_getss_0 */
6736 char device[] = "/dev/sda";
6739 r = guestfs_blockdev_setrw (g, device);
6746 r = guestfs_umount_all (g);
6753 r = guestfs_lvm_remove_all (g);
6757 /* TestOutputInt for blockdev_getss (0) */
6759 char device[] = "/dev/sda";
6762 r = guestfs_blockdev_getss (g, device);
6766 fprintf (stderr, "test_blockdev_getss_0: expected 512 but got %d\n", (int) r);
6773 static int test_blockdev_getro_0_skip (void)
6777 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO_0");
6778 if (str && strcmp (str, "1") == 0) return 1;
6779 str = getenv ("SKIP_TEST_BLOCKDEV_GETRO");
6780 if (str && strcmp (str, "1") == 0) return 1;
6784 static int test_blockdev_getro_0 (void)
6786 if (test_blockdev_getro_0_skip ()) {
6787 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_getro_0");
6791 /* InitNone|InitEmpty for test_blockdev_getro_0 */
6793 char device[] = "/dev/sda";
6796 r = guestfs_blockdev_setrw (g, device);
6803 r = guestfs_umount_all (g);
6810 r = guestfs_lvm_remove_all (g);
6814 /* TestOutputTrue for blockdev_getro (0) */
6816 char device[] = "/dev/sda";
6819 r = guestfs_blockdev_setro (g, device);
6824 char device[] = "/dev/sda";
6827 r = guestfs_blockdev_getro (g, device);
6831 fprintf (stderr, "test_blockdev_getro_0: expected true, got false\n");
6838 static int test_blockdev_setrw_0_skip (void)
6842 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW_0");
6843 if (str && strcmp (str, "1") == 0) return 1;
6844 str = getenv ("SKIP_TEST_BLOCKDEV_SETRW");
6845 if (str && strcmp (str, "1") == 0) return 1;
6849 static int test_blockdev_setrw_0 (void)
6851 if (test_blockdev_setrw_0_skip ()) {
6852 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setrw_0");
6856 /* InitNone|InitEmpty for test_blockdev_setrw_0 */
6858 char device[] = "/dev/sda";
6861 r = guestfs_blockdev_setrw (g, device);
6868 r = guestfs_umount_all (g);
6875 r = guestfs_lvm_remove_all (g);
6879 /* TestOutputFalse for blockdev_setrw (0) */
6881 char device[] = "/dev/sda";
6884 r = guestfs_blockdev_setrw (g, device);
6889 char device[] = "/dev/sda";
6892 r = guestfs_blockdev_getro (g, device);
6896 fprintf (stderr, "test_blockdev_setrw_0: expected false, got true\n");
6903 static int test_blockdev_setro_0_skip (void)
6907 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO_0");
6908 if (str && strcmp (str, "1") == 0) return 1;
6909 str = getenv ("SKIP_TEST_BLOCKDEV_SETRO");
6910 if (str && strcmp (str, "1") == 0) return 1;
6914 static int test_blockdev_setro_0 (void)
6916 if (test_blockdev_setro_0_skip ()) {
6917 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_blockdev_setro_0");
6921 /* InitNone|InitEmpty for test_blockdev_setro_0 */
6923 char device[] = "/dev/sda";
6926 r = guestfs_blockdev_setrw (g, device);
6933 r = guestfs_umount_all (g);
6940 r = guestfs_lvm_remove_all (g);
6944 /* TestOutputTrue for blockdev_setro (0) */
6946 char device[] = "/dev/sda";
6949 r = guestfs_blockdev_setro (g, device);
6954 char device[] = "/dev/sda";
6957 r = guestfs_blockdev_getro (g, device);
6961 fprintf (stderr, "test_blockdev_setro_0: expected true, got false\n");
6968 static int test_statvfs_0_skip (void)
6972 str = getenv ("SKIP_TEST_STATVFS_0");
6973 if (str && strcmp (str, "1") == 0) return 1;
6974 str = getenv ("SKIP_TEST_STATVFS");
6975 if (str && strcmp (str, "1") == 0) return 1;
6979 static int test_statvfs_0 (void)
6981 if (test_statvfs_0_skip ()) {
6982 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_statvfs_0");
6986 /* InitBasicFS for test_statvfs_0: create ext2 on /dev/sda1 */
6988 char device[] = "/dev/sda";
6991 r = guestfs_blockdev_setrw (g, device);
6998 r = guestfs_umount_all (g);
7005 r = guestfs_lvm_remove_all (g);
7010 char device[] = "/dev/sda";
7011 char lines_0[] = ",";
7018 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7023 char fstype[] = "ext2";
7024 char device[] = "/dev/sda1";
7027 r = guestfs_mkfs (g, fstype, device);
7032 char device[] = "/dev/sda1";
7033 char mountpoint[] = "/";
7036 r = guestfs_mount (g, device, mountpoint);
7040 /* TestOutputStruct for statvfs (0) */
7043 struct guestfs_statvfs *r;
7045 r = guestfs_statvfs (g, path);
7048 if (r->bfree != 487702) {
7049 fprintf (stderr, "test_statvfs_0: bfree was %d, expected 487702\n",
7053 if (r->blocks != 490020) {
7054 fprintf (stderr, "test_statvfs_0: blocks was %d, expected 490020\n",
7058 if (r->bsize != 1024) {
7059 fprintf (stderr, "test_statvfs_0: bsize was %d, expected 1024\n",
7068 static int test_lstat_0_skip (void)
7072 str = getenv ("SKIP_TEST_LSTAT_0");
7073 if (str && strcmp (str, "1") == 0) return 1;
7074 str = getenv ("SKIP_TEST_LSTAT");
7075 if (str && strcmp (str, "1") == 0) return 1;
7079 static int test_lstat_0 (void)
7081 if (test_lstat_0_skip ()) {
7082 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lstat_0");
7086 /* InitBasicFS for test_lstat_0: create ext2 on /dev/sda1 */
7088 char device[] = "/dev/sda";
7091 r = guestfs_blockdev_setrw (g, device);
7098 r = guestfs_umount_all (g);
7105 r = guestfs_lvm_remove_all (g);
7110 char device[] = "/dev/sda";
7111 char lines_0[] = ",";
7118 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7123 char fstype[] = "ext2";
7124 char device[] = "/dev/sda1";
7127 r = guestfs_mkfs (g, fstype, device);
7132 char device[] = "/dev/sda1";
7133 char mountpoint[] = "/";
7136 r = guestfs_mount (g, device, mountpoint);
7140 /* TestOutputStruct for lstat (0) */
7142 char path[] = "/new";
7145 r = guestfs_touch (g, path);
7150 char path[] = "/new";
7151 struct guestfs_stat *r;
7153 r = guestfs_lstat (g, path);
7157 fprintf (stderr, "test_lstat_0: size was %d, expected 0\n",
7166 static int test_stat_0_skip (void)
7170 str = getenv ("SKIP_TEST_STAT_0");
7171 if (str && strcmp (str, "1") == 0) return 1;
7172 str = getenv ("SKIP_TEST_STAT");
7173 if (str && strcmp (str, "1") == 0) return 1;
7177 static int test_stat_0 (void)
7179 if (test_stat_0_skip ()) {
7180 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_stat_0");
7184 /* InitBasicFS for test_stat_0: create ext2 on /dev/sda1 */
7186 char device[] = "/dev/sda";
7189 r = guestfs_blockdev_setrw (g, device);
7196 r = guestfs_umount_all (g);
7203 r = guestfs_lvm_remove_all (g);
7208 char device[] = "/dev/sda";
7209 char lines_0[] = ",";
7216 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7221 char fstype[] = "ext2";
7222 char device[] = "/dev/sda1";
7225 r = guestfs_mkfs (g, fstype, device);
7230 char device[] = "/dev/sda1";
7231 char mountpoint[] = "/";
7234 r = guestfs_mount (g, device, mountpoint);
7238 /* TestOutputStruct for stat (0) */
7240 char path[] = "/new";
7243 r = guestfs_touch (g, path);
7248 char path[] = "/new";
7249 struct guestfs_stat *r;
7251 r = guestfs_stat (g, path);
7255 fprintf (stderr, "test_stat_0: size was %d, expected 0\n",
7264 static int test_command_lines_0_skip (void)
7268 str = getenv ("SKIP_TEST_COMMAND_LINES_0");
7269 if (str && strcmp (str, "1") == 0) return 1;
7270 str = getenv ("SKIP_TEST_COMMAND_LINES");
7271 if (str && strcmp (str, "1") == 0) return 1;
7275 static int test_command_lines_0 (void)
7277 if (test_command_lines_0_skip ()) {
7278 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_0");
7282 /* InitBasicFS for test_command_lines_0: create ext2 on /dev/sda1 */
7284 char device[] = "/dev/sda";
7287 r = guestfs_blockdev_setrw (g, device);
7294 r = guestfs_umount_all (g);
7301 r = guestfs_lvm_remove_all (g);
7306 char device[] = "/dev/sda";
7307 char lines_0[] = ",";
7314 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7319 char fstype[] = "ext2";
7320 char device[] = "/dev/sda1";
7323 r = guestfs_mkfs (g, fstype, device);
7328 char device[] = "/dev/sda1";
7329 char mountpoint[] = "/";
7332 r = guestfs_mount (g, device, mountpoint);
7336 /* TestOutputList for command_lines (0) */
7338 char remotefilename[] = "/test-command";
7341 r = guestfs_upload (g, "test-command", remotefilename);
7346 char path[] = "/test-command";
7349 r = guestfs_chmod (g, 493, path);
7354 char arguments_0[] = "/test-command";
7355 char arguments_1[] = "1";
7356 char *arguments[] = {
7364 r = guestfs_command_lines (g, arguments);
7368 fprintf (stderr, "test_command_lines_0: short list returned from command\n");
7373 char expected[] = "Result1";
7374 if (strcmp (r[0], expected) != 0) {
7375 fprintf (stderr, "test_command_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7380 fprintf (stderr, "test_command_lines_0: extra elements returned from command\n");
7384 for (i = 0; r[i] != NULL; ++i)
7391 static int test_command_lines_1_skip (void)
7395 str = getenv ("SKIP_TEST_COMMAND_LINES_1");
7396 if (str && strcmp (str, "1") == 0) return 1;
7397 str = getenv ("SKIP_TEST_COMMAND_LINES");
7398 if (str && strcmp (str, "1") == 0) return 1;
7402 static int test_command_lines_1 (void)
7404 if (test_command_lines_1_skip ()) {
7405 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_1");
7409 /* InitBasicFS for test_command_lines_1: create ext2 on /dev/sda1 */
7411 char device[] = "/dev/sda";
7414 r = guestfs_blockdev_setrw (g, device);
7421 r = guestfs_umount_all (g);
7428 r = guestfs_lvm_remove_all (g);
7433 char device[] = "/dev/sda";
7434 char lines_0[] = ",";
7441 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7446 char fstype[] = "ext2";
7447 char device[] = "/dev/sda1";
7450 r = guestfs_mkfs (g, fstype, device);
7455 char device[] = "/dev/sda1";
7456 char mountpoint[] = "/";
7459 r = guestfs_mount (g, device, mountpoint);
7463 /* TestOutputList for command_lines (1) */
7465 char remotefilename[] = "/test-command";
7468 r = guestfs_upload (g, "test-command", remotefilename);
7473 char path[] = "/test-command";
7476 r = guestfs_chmod (g, 493, path);
7481 char arguments_0[] = "/test-command";
7482 char arguments_1[] = "2";
7483 char *arguments[] = {
7491 r = guestfs_command_lines (g, arguments);
7495 fprintf (stderr, "test_command_lines_1: short list returned from command\n");
7500 char expected[] = "Result2";
7501 if (strcmp (r[0], expected) != 0) {
7502 fprintf (stderr, "test_command_lines_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7507 fprintf (stderr, "test_command_lines_1: extra elements returned from command\n");
7511 for (i = 0; r[i] != NULL; ++i)
7518 static int test_command_lines_2_skip (void)
7522 str = getenv ("SKIP_TEST_COMMAND_LINES_2");
7523 if (str && strcmp (str, "1") == 0) return 1;
7524 str = getenv ("SKIP_TEST_COMMAND_LINES");
7525 if (str && strcmp (str, "1") == 0) return 1;
7529 static int test_command_lines_2 (void)
7531 if (test_command_lines_2_skip ()) {
7532 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_2");
7536 /* InitBasicFS for test_command_lines_2: create ext2 on /dev/sda1 */
7538 char device[] = "/dev/sda";
7541 r = guestfs_blockdev_setrw (g, device);
7548 r = guestfs_umount_all (g);
7555 r = guestfs_lvm_remove_all (g);
7560 char device[] = "/dev/sda";
7561 char lines_0[] = ",";
7568 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7573 char fstype[] = "ext2";
7574 char device[] = "/dev/sda1";
7577 r = guestfs_mkfs (g, fstype, device);
7582 char device[] = "/dev/sda1";
7583 char mountpoint[] = "/";
7586 r = guestfs_mount (g, device, mountpoint);
7590 /* TestOutputList for command_lines (2) */
7592 char remotefilename[] = "/test-command";
7595 r = guestfs_upload (g, "test-command", remotefilename);
7600 char path[] = "/test-command";
7603 r = guestfs_chmod (g, 493, path);
7608 char arguments_0[] = "/test-command";
7609 char arguments_1[] = "3";
7610 char *arguments[] = {
7618 r = guestfs_command_lines (g, arguments);
7622 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7627 char expected[] = "";
7628 if (strcmp (r[0], expected) != 0) {
7629 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7634 fprintf (stderr, "test_command_lines_2: short list returned from command\n");
7639 char expected[] = "Result3";
7640 if (strcmp (r[1], expected) != 0) {
7641 fprintf (stderr, "test_command_lines_2: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7646 fprintf (stderr, "test_command_lines_2: extra elements returned from command\n");
7650 for (i = 0; r[i] != NULL; ++i)
7657 static int test_command_lines_3_skip (void)
7661 str = getenv ("SKIP_TEST_COMMAND_LINES_3");
7662 if (str && strcmp (str, "1") == 0) return 1;
7663 str = getenv ("SKIP_TEST_COMMAND_LINES");
7664 if (str && strcmp (str, "1") == 0) return 1;
7668 static int test_command_lines_3 (void)
7670 if (test_command_lines_3_skip ()) {
7671 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_3");
7675 /* InitBasicFS for test_command_lines_3: create ext2 on /dev/sda1 */
7677 char device[] = "/dev/sda";
7680 r = guestfs_blockdev_setrw (g, device);
7687 r = guestfs_umount_all (g);
7694 r = guestfs_lvm_remove_all (g);
7699 char device[] = "/dev/sda";
7700 char lines_0[] = ",";
7707 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7712 char fstype[] = "ext2";
7713 char device[] = "/dev/sda1";
7716 r = guestfs_mkfs (g, fstype, device);
7721 char device[] = "/dev/sda1";
7722 char mountpoint[] = "/";
7725 r = guestfs_mount (g, device, mountpoint);
7729 /* TestOutputList for command_lines (3) */
7731 char remotefilename[] = "/test-command";
7734 r = guestfs_upload (g, "test-command", remotefilename);
7739 char path[] = "/test-command";
7742 r = guestfs_chmod (g, 493, path);
7747 char arguments_0[] = "/test-command";
7748 char arguments_1[] = "4";
7749 char *arguments[] = {
7757 r = guestfs_command_lines (g, arguments);
7761 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7766 char expected[] = "";
7767 if (strcmp (r[0], expected) != 0) {
7768 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7773 fprintf (stderr, "test_command_lines_3: short list returned from command\n");
7778 char expected[] = "Result4";
7779 if (strcmp (r[1], expected) != 0) {
7780 fprintf (stderr, "test_command_lines_3: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7785 fprintf (stderr, "test_command_lines_3: extra elements returned from command\n");
7789 for (i = 0; r[i] != NULL; ++i)
7796 static int test_command_lines_4_skip (void)
7800 str = getenv ("SKIP_TEST_COMMAND_LINES_4");
7801 if (str && strcmp (str, "1") == 0) return 1;
7802 str = getenv ("SKIP_TEST_COMMAND_LINES");
7803 if (str && strcmp (str, "1") == 0) return 1;
7807 static int test_command_lines_4 (void)
7809 if (test_command_lines_4_skip ()) {
7810 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_4");
7814 /* InitBasicFS for test_command_lines_4: create ext2 on /dev/sda1 */
7816 char device[] = "/dev/sda";
7819 r = guestfs_blockdev_setrw (g, device);
7826 r = guestfs_umount_all (g);
7833 r = guestfs_lvm_remove_all (g);
7838 char device[] = "/dev/sda";
7839 char lines_0[] = ",";
7846 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
7851 char fstype[] = "ext2";
7852 char device[] = "/dev/sda1";
7855 r = guestfs_mkfs (g, fstype, device);
7860 char device[] = "/dev/sda1";
7861 char mountpoint[] = "/";
7864 r = guestfs_mount (g, device, mountpoint);
7868 /* TestOutputList for command_lines (4) */
7870 char remotefilename[] = "/test-command";
7873 r = guestfs_upload (g, "test-command", remotefilename);
7878 char path[] = "/test-command";
7881 r = guestfs_chmod (g, 493, path);
7886 char arguments_0[] = "/test-command";
7887 char arguments_1[] = "5";
7888 char *arguments[] = {
7896 r = guestfs_command_lines (g, arguments);
7900 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7905 char expected[] = "";
7906 if (strcmp (r[0], expected) != 0) {
7907 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[0]);
7912 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7917 char expected[] = "Result5";
7918 if (strcmp (r[1], expected) != 0) {
7919 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[1]);
7924 fprintf (stderr, "test_command_lines_4: short list returned from command\n");
7929 char expected[] = "";
7930 if (strcmp (r[2], expected) != 0) {
7931 fprintf (stderr, "test_command_lines_4: expected \"%s\" but got \"%s\"\n", expected, r[2]);
7936 fprintf (stderr, "test_command_lines_4: extra elements returned from command\n");
7940 for (i = 0; r[i] != NULL; ++i)
7947 static int test_command_lines_5_skip (void)
7951 str = getenv ("SKIP_TEST_COMMAND_LINES_5");
7952 if (str && strcmp (str, "1") == 0) return 1;
7953 str = getenv ("SKIP_TEST_COMMAND_LINES");
7954 if (str && strcmp (str, "1") == 0) return 1;
7958 static int test_command_lines_5 (void)
7960 if (test_command_lines_5_skip ()) {
7961 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_5");
7965 /* InitBasicFS for test_command_lines_5: create ext2 on /dev/sda1 */
7967 char device[] = "/dev/sda";
7970 r = guestfs_blockdev_setrw (g, device);
7977 r = guestfs_umount_all (g);
7984 r = guestfs_lvm_remove_all (g);
7989 char device[] = "/dev/sda";
7990 char lines_0[] = ",";
7997 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8002 char fstype[] = "ext2";
8003 char device[] = "/dev/sda1";
8006 r = guestfs_mkfs (g, fstype, device);
8011 char device[] = "/dev/sda1";
8012 char mountpoint[] = "/";
8015 r = guestfs_mount (g, device, mountpoint);
8019 /* TestOutputList for command_lines (5) */
8021 char remotefilename[] = "/test-command";
8024 r = guestfs_upload (g, "test-command", remotefilename);
8029 char path[] = "/test-command";
8032 r = guestfs_chmod (g, 493, path);
8037 char arguments_0[] = "/test-command";
8038 char arguments_1[] = "6";
8039 char *arguments[] = {
8047 r = guestfs_command_lines (g, arguments);
8051 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8056 char expected[] = "";
8057 if (strcmp (r[0], expected) != 0) {
8058 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8063 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8068 char expected[] = "";
8069 if (strcmp (r[1], expected) != 0) {
8070 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8075 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8080 char expected[] = "Result6";
8081 if (strcmp (r[2], expected) != 0) {
8082 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[2]);
8087 fprintf (stderr, "test_command_lines_5: short list returned from command\n");
8092 char expected[] = "";
8093 if (strcmp (r[3], expected) != 0) {
8094 fprintf (stderr, "test_command_lines_5: expected \"%s\" but got \"%s\"\n", expected, r[3]);
8099 fprintf (stderr, "test_command_lines_5: extra elements returned from command\n");
8103 for (i = 0; r[i] != NULL; ++i)
8110 static int test_command_lines_6_skip (void)
8114 str = getenv ("SKIP_TEST_COMMAND_LINES_6");
8115 if (str && strcmp (str, "1") == 0) return 1;
8116 str = getenv ("SKIP_TEST_COMMAND_LINES");
8117 if (str && strcmp (str, "1") == 0) return 1;
8121 static int test_command_lines_6 (void)
8123 if (test_command_lines_6_skip ()) {
8124 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_6");
8128 /* InitBasicFS for test_command_lines_6: create ext2 on /dev/sda1 */
8130 char device[] = "/dev/sda";
8133 r = guestfs_blockdev_setrw (g, device);
8140 r = guestfs_umount_all (g);
8147 r = guestfs_lvm_remove_all (g);
8152 char device[] = "/dev/sda";
8153 char lines_0[] = ",";
8160 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8165 char fstype[] = "ext2";
8166 char device[] = "/dev/sda1";
8169 r = guestfs_mkfs (g, fstype, device);
8174 char device[] = "/dev/sda1";
8175 char mountpoint[] = "/";
8178 r = guestfs_mount (g, device, mountpoint);
8182 /* TestOutputList for command_lines (6) */
8184 char remotefilename[] = "/test-command";
8187 r = guestfs_upload (g, "test-command", remotefilename);
8192 char path[] = "/test-command";
8195 r = guestfs_chmod (g, 493, path);
8200 char arguments_0[] = "/test-command";
8201 char arguments_1[] = "7";
8202 char *arguments[] = {
8210 r = guestfs_command_lines (g, arguments);
8214 fprintf (stderr, "test_command_lines_6: extra elements returned from command\n");
8218 for (i = 0; r[i] != NULL; ++i)
8225 static int test_command_lines_7_skip (void)
8229 str = getenv ("SKIP_TEST_COMMAND_LINES_7");
8230 if (str && strcmp (str, "1") == 0) return 1;
8231 str = getenv ("SKIP_TEST_COMMAND_LINES");
8232 if (str && strcmp (str, "1") == 0) return 1;
8236 static int test_command_lines_7 (void)
8238 if (test_command_lines_7_skip ()) {
8239 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_7");
8243 /* InitBasicFS for test_command_lines_7: create ext2 on /dev/sda1 */
8245 char device[] = "/dev/sda";
8248 r = guestfs_blockdev_setrw (g, device);
8255 r = guestfs_umount_all (g);
8262 r = guestfs_lvm_remove_all (g);
8267 char device[] = "/dev/sda";
8268 char lines_0[] = ",";
8275 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8280 char fstype[] = "ext2";
8281 char device[] = "/dev/sda1";
8284 r = guestfs_mkfs (g, fstype, device);
8289 char device[] = "/dev/sda1";
8290 char mountpoint[] = "/";
8293 r = guestfs_mount (g, device, mountpoint);
8297 /* TestOutputList for command_lines (7) */
8299 char remotefilename[] = "/test-command";
8302 r = guestfs_upload (g, "test-command", remotefilename);
8307 char path[] = "/test-command";
8310 r = guestfs_chmod (g, 493, path);
8315 char arguments_0[] = "/test-command";
8316 char arguments_1[] = "8";
8317 char *arguments[] = {
8325 r = guestfs_command_lines (g, arguments);
8329 fprintf (stderr, "test_command_lines_7: short list returned from command\n");
8334 char expected[] = "";
8335 if (strcmp (r[0], expected) != 0) {
8336 fprintf (stderr, "test_command_lines_7: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8341 fprintf (stderr, "test_command_lines_7: extra elements returned from command\n");
8345 for (i = 0; r[i] != NULL; ++i)
8352 static int test_command_lines_8_skip (void)
8356 str = getenv ("SKIP_TEST_COMMAND_LINES_8");
8357 if (str && strcmp (str, "1") == 0) return 1;
8358 str = getenv ("SKIP_TEST_COMMAND_LINES");
8359 if (str && strcmp (str, "1") == 0) return 1;
8363 static int test_command_lines_8 (void)
8365 if (test_command_lines_8_skip ()) {
8366 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_8");
8370 /* InitBasicFS for test_command_lines_8: create ext2 on /dev/sda1 */
8372 char device[] = "/dev/sda";
8375 r = guestfs_blockdev_setrw (g, device);
8382 r = guestfs_umount_all (g);
8389 r = guestfs_lvm_remove_all (g);
8394 char device[] = "/dev/sda";
8395 char lines_0[] = ",";
8402 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8407 char fstype[] = "ext2";
8408 char device[] = "/dev/sda1";
8411 r = guestfs_mkfs (g, fstype, device);
8416 char device[] = "/dev/sda1";
8417 char mountpoint[] = "/";
8420 r = guestfs_mount (g, device, mountpoint);
8424 /* TestOutputList for command_lines (8) */
8426 char remotefilename[] = "/test-command";
8429 r = guestfs_upload (g, "test-command", remotefilename);
8434 char path[] = "/test-command";
8437 r = guestfs_chmod (g, 493, path);
8442 char arguments_0[] = "/test-command";
8443 char arguments_1[] = "9";
8444 char *arguments[] = {
8452 r = guestfs_command_lines (g, arguments);
8456 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8461 char expected[] = "";
8462 if (strcmp (r[0], expected) != 0) {
8463 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8468 fprintf (stderr, "test_command_lines_8: short list returned from command\n");
8473 char expected[] = "";
8474 if (strcmp (r[1], expected) != 0) {
8475 fprintf (stderr, "test_command_lines_8: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8480 fprintf (stderr, "test_command_lines_8: extra elements returned from command\n");
8484 for (i = 0; r[i] != NULL; ++i)
8491 static int test_command_lines_9_skip (void)
8495 str = getenv ("SKIP_TEST_COMMAND_LINES_9");
8496 if (str && strcmp (str, "1") == 0) return 1;
8497 str = getenv ("SKIP_TEST_COMMAND_LINES");
8498 if (str && strcmp (str, "1") == 0) return 1;
8502 static int test_command_lines_9 (void)
8504 if (test_command_lines_9_skip ()) {
8505 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_9");
8509 /* InitBasicFS for test_command_lines_9: create ext2 on /dev/sda1 */
8511 char device[] = "/dev/sda";
8514 r = guestfs_blockdev_setrw (g, device);
8521 r = guestfs_umount_all (g);
8528 r = guestfs_lvm_remove_all (g);
8533 char device[] = "/dev/sda";
8534 char lines_0[] = ",";
8541 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8546 char fstype[] = "ext2";
8547 char device[] = "/dev/sda1";
8550 r = guestfs_mkfs (g, fstype, device);
8555 char device[] = "/dev/sda1";
8556 char mountpoint[] = "/";
8559 r = guestfs_mount (g, device, mountpoint);
8563 /* TestOutputList for command_lines (9) */
8565 char remotefilename[] = "/test-command";
8568 r = guestfs_upload (g, "test-command", remotefilename);
8573 char path[] = "/test-command";
8576 r = guestfs_chmod (g, 493, path);
8581 char arguments_0[] = "/test-command";
8582 char arguments_1[] = "10";
8583 char *arguments[] = {
8591 r = guestfs_command_lines (g, arguments);
8595 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8600 char expected[] = "Result10-1";
8601 if (strcmp (r[0], expected) != 0) {
8602 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8607 fprintf (stderr, "test_command_lines_9: short list returned from command\n");
8612 char expected[] = "Result10-2";
8613 if (strcmp (r[1], expected) != 0) {
8614 fprintf (stderr, "test_command_lines_9: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8619 fprintf (stderr, "test_command_lines_9: extra elements returned from command\n");
8623 for (i = 0; r[i] != NULL; ++i)
8630 static int test_command_lines_10_skip (void)
8634 str = getenv ("SKIP_TEST_COMMAND_LINES_10");
8635 if (str && strcmp (str, "1") == 0) return 1;
8636 str = getenv ("SKIP_TEST_COMMAND_LINES");
8637 if (str && strcmp (str, "1") == 0) return 1;
8641 static int test_command_lines_10 (void)
8643 if (test_command_lines_10_skip ()) {
8644 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_lines_10");
8648 /* InitBasicFS for test_command_lines_10: create ext2 on /dev/sda1 */
8650 char device[] = "/dev/sda";
8653 r = guestfs_blockdev_setrw (g, device);
8660 r = guestfs_umount_all (g);
8667 r = guestfs_lvm_remove_all (g);
8672 char device[] = "/dev/sda";
8673 char lines_0[] = ",";
8680 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8685 char fstype[] = "ext2";
8686 char device[] = "/dev/sda1";
8689 r = guestfs_mkfs (g, fstype, device);
8694 char device[] = "/dev/sda1";
8695 char mountpoint[] = "/";
8698 r = guestfs_mount (g, device, mountpoint);
8702 /* TestOutputList for command_lines (10) */
8704 char remotefilename[] = "/test-command";
8707 r = guestfs_upload (g, "test-command", remotefilename);
8712 char path[] = "/test-command";
8715 r = guestfs_chmod (g, 493, path);
8720 char arguments_0[] = "/test-command";
8721 char arguments_1[] = "11";
8722 char *arguments[] = {
8730 r = guestfs_command_lines (g, arguments);
8734 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8739 char expected[] = "Result11-1";
8740 if (strcmp (r[0], expected) != 0) {
8741 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[0]);
8746 fprintf (stderr, "test_command_lines_10: short list returned from command\n");
8751 char expected[] = "Result11-2";
8752 if (strcmp (r[1], expected) != 0) {
8753 fprintf (stderr, "test_command_lines_10: expected \"%s\" but got \"%s\"\n", expected, r[1]);
8758 fprintf (stderr, "test_command_lines_10: extra elements returned from command\n");
8762 for (i = 0; r[i] != NULL; ++i)
8769 static int test_command_0_skip (void)
8773 str = getenv ("SKIP_TEST_COMMAND_0");
8774 if (str && strcmp (str, "1") == 0) return 1;
8775 str = getenv ("SKIP_TEST_COMMAND");
8776 if (str && strcmp (str, "1") == 0) return 1;
8780 static int test_command_0 (void)
8782 if (test_command_0_skip ()) {
8783 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_0");
8787 /* InitBasicFS for test_command_0: create ext2 on /dev/sda1 */
8789 char device[] = "/dev/sda";
8792 r = guestfs_blockdev_setrw (g, device);
8799 r = guestfs_umount_all (g);
8806 r = guestfs_lvm_remove_all (g);
8811 char device[] = "/dev/sda";
8812 char lines_0[] = ",";
8819 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8824 char fstype[] = "ext2";
8825 char device[] = "/dev/sda1";
8828 r = guestfs_mkfs (g, fstype, device);
8833 char device[] = "/dev/sda1";
8834 char mountpoint[] = "/";
8837 r = guestfs_mount (g, device, mountpoint);
8841 /* TestOutput for command (0) */
8842 char expected[] = "Result1";
8844 char remotefilename[] = "/test-command";
8847 r = guestfs_upload (g, "test-command", remotefilename);
8852 char path[] = "/test-command";
8855 r = guestfs_chmod (g, 493, path);
8860 char arguments_0[] = "/test-command";
8861 char arguments_1[] = "1";
8862 char *arguments[] = {
8869 r = guestfs_command (g, arguments);
8872 if (strcmp (r, expected) != 0) {
8873 fprintf (stderr, "test_command_0: expected \"%s\" but got \"%s\"\n", expected, r);
8881 static int test_command_1_skip (void)
8885 str = getenv ("SKIP_TEST_COMMAND_1");
8886 if (str && strcmp (str, "1") == 0) return 1;
8887 str = getenv ("SKIP_TEST_COMMAND");
8888 if (str && strcmp (str, "1") == 0) return 1;
8892 static int test_command_1 (void)
8894 if (test_command_1_skip ()) {
8895 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_1");
8899 /* InitBasicFS for test_command_1: create ext2 on /dev/sda1 */
8901 char device[] = "/dev/sda";
8904 r = guestfs_blockdev_setrw (g, device);
8911 r = guestfs_umount_all (g);
8918 r = guestfs_lvm_remove_all (g);
8923 char device[] = "/dev/sda";
8924 char lines_0[] = ",";
8931 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
8936 char fstype[] = "ext2";
8937 char device[] = "/dev/sda1";
8940 r = guestfs_mkfs (g, fstype, device);
8945 char device[] = "/dev/sda1";
8946 char mountpoint[] = "/";
8949 r = guestfs_mount (g, device, mountpoint);
8953 /* TestOutput for command (1) */
8954 char expected[] = "Result2\n";
8956 char remotefilename[] = "/test-command";
8959 r = guestfs_upload (g, "test-command", remotefilename);
8964 char path[] = "/test-command";
8967 r = guestfs_chmod (g, 493, path);
8972 char arguments_0[] = "/test-command";
8973 char arguments_1[] = "2";
8974 char *arguments[] = {
8981 r = guestfs_command (g, arguments);
8984 if (strcmp (r, expected) != 0) {
8985 fprintf (stderr, "test_command_1: expected \"%s\" but got \"%s\"\n", expected, r);
8993 static int test_command_2_skip (void)
8997 str = getenv ("SKIP_TEST_COMMAND_2");
8998 if (str && strcmp (str, "1") == 0) return 1;
8999 str = getenv ("SKIP_TEST_COMMAND");
9000 if (str && strcmp (str, "1") == 0) return 1;
9004 static int test_command_2 (void)
9006 if (test_command_2_skip ()) {
9007 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_2");
9011 /* InitBasicFS for test_command_2: create ext2 on /dev/sda1 */
9013 char device[] = "/dev/sda";
9016 r = guestfs_blockdev_setrw (g, device);
9023 r = guestfs_umount_all (g);
9030 r = guestfs_lvm_remove_all (g);
9035 char device[] = "/dev/sda";
9036 char lines_0[] = ",";
9043 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9048 char fstype[] = "ext2";
9049 char device[] = "/dev/sda1";
9052 r = guestfs_mkfs (g, fstype, device);
9057 char device[] = "/dev/sda1";
9058 char mountpoint[] = "/";
9061 r = guestfs_mount (g, device, mountpoint);
9065 /* TestOutput for command (2) */
9066 char expected[] = "\nResult3";
9068 char remotefilename[] = "/test-command";
9071 r = guestfs_upload (g, "test-command", remotefilename);
9076 char path[] = "/test-command";
9079 r = guestfs_chmod (g, 493, path);
9084 char arguments_0[] = "/test-command";
9085 char arguments_1[] = "3";
9086 char *arguments[] = {
9093 r = guestfs_command (g, arguments);
9096 if (strcmp (r, expected) != 0) {
9097 fprintf (stderr, "test_command_2: expected \"%s\" but got \"%s\"\n", expected, r);
9105 static int test_command_3_skip (void)
9109 str = getenv ("SKIP_TEST_COMMAND_3");
9110 if (str && strcmp (str, "1") == 0) return 1;
9111 str = getenv ("SKIP_TEST_COMMAND");
9112 if (str && strcmp (str, "1") == 0) return 1;
9116 static int test_command_3 (void)
9118 if (test_command_3_skip ()) {
9119 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_3");
9123 /* InitBasicFS for test_command_3: create ext2 on /dev/sda1 */
9125 char device[] = "/dev/sda";
9128 r = guestfs_blockdev_setrw (g, device);
9135 r = guestfs_umount_all (g);
9142 r = guestfs_lvm_remove_all (g);
9147 char device[] = "/dev/sda";
9148 char lines_0[] = ",";
9155 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9160 char fstype[] = "ext2";
9161 char device[] = "/dev/sda1";
9164 r = guestfs_mkfs (g, fstype, device);
9169 char device[] = "/dev/sda1";
9170 char mountpoint[] = "/";
9173 r = guestfs_mount (g, device, mountpoint);
9177 /* TestOutput for command (3) */
9178 char expected[] = "\nResult4\n";
9180 char remotefilename[] = "/test-command";
9183 r = guestfs_upload (g, "test-command", remotefilename);
9188 char path[] = "/test-command";
9191 r = guestfs_chmod (g, 493, path);
9196 char arguments_0[] = "/test-command";
9197 char arguments_1[] = "4";
9198 char *arguments[] = {
9205 r = guestfs_command (g, arguments);
9208 if (strcmp (r, expected) != 0) {
9209 fprintf (stderr, "test_command_3: expected \"%s\" but got \"%s\"\n", expected, r);
9217 static int test_command_4_skip (void)
9221 str = getenv ("SKIP_TEST_COMMAND_4");
9222 if (str && strcmp (str, "1") == 0) return 1;
9223 str = getenv ("SKIP_TEST_COMMAND");
9224 if (str && strcmp (str, "1") == 0) return 1;
9228 static int test_command_4 (void)
9230 if (test_command_4_skip ()) {
9231 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_4");
9235 /* InitBasicFS for test_command_4: create ext2 on /dev/sda1 */
9237 char device[] = "/dev/sda";
9240 r = guestfs_blockdev_setrw (g, device);
9247 r = guestfs_umount_all (g);
9254 r = guestfs_lvm_remove_all (g);
9259 char device[] = "/dev/sda";
9260 char lines_0[] = ",";
9267 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9272 char fstype[] = "ext2";
9273 char device[] = "/dev/sda1";
9276 r = guestfs_mkfs (g, fstype, device);
9281 char device[] = "/dev/sda1";
9282 char mountpoint[] = "/";
9285 r = guestfs_mount (g, device, mountpoint);
9289 /* TestOutput for command (4) */
9290 char expected[] = "\nResult5\n\n";
9292 char remotefilename[] = "/test-command";
9295 r = guestfs_upload (g, "test-command", remotefilename);
9300 char path[] = "/test-command";
9303 r = guestfs_chmod (g, 493, path);
9308 char arguments_0[] = "/test-command";
9309 char arguments_1[] = "5";
9310 char *arguments[] = {
9317 r = guestfs_command (g, arguments);
9320 if (strcmp (r, expected) != 0) {
9321 fprintf (stderr, "test_command_4: expected \"%s\" but got \"%s\"\n", expected, r);
9329 static int test_command_5_skip (void)
9333 str = getenv ("SKIP_TEST_COMMAND_5");
9334 if (str && strcmp (str, "1") == 0) return 1;
9335 str = getenv ("SKIP_TEST_COMMAND");
9336 if (str && strcmp (str, "1") == 0) return 1;
9340 static int test_command_5 (void)
9342 if (test_command_5_skip ()) {
9343 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_5");
9347 /* InitBasicFS for test_command_5: create ext2 on /dev/sda1 */
9349 char device[] = "/dev/sda";
9352 r = guestfs_blockdev_setrw (g, device);
9359 r = guestfs_umount_all (g);
9366 r = guestfs_lvm_remove_all (g);
9371 char device[] = "/dev/sda";
9372 char lines_0[] = ",";
9379 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9384 char fstype[] = "ext2";
9385 char device[] = "/dev/sda1";
9388 r = guestfs_mkfs (g, fstype, device);
9393 char device[] = "/dev/sda1";
9394 char mountpoint[] = "/";
9397 r = guestfs_mount (g, device, mountpoint);
9401 /* TestOutput for command (5) */
9402 char expected[] = "\n\nResult6\n\n";
9404 char remotefilename[] = "/test-command";
9407 r = guestfs_upload (g, "test-command", remotefilename);
9412 char path[] = "/test-command";
9415 r = guestfs_chmod (g, 493, path);
9420 char arguments_0[] = "/test-command";
9421 char arguments_1[] = "6";
9422 char *arguments[] = {
9429 r = guestfs_command (g, arguments);
9432 if (strcmp (r, expected) != 0) {
9433 fprintf (stderr, "test_command_5: expected \"%s\" but got \"%s\"\n", expected, r);
9441 static int test_command_6_skip (void)
9445 str = getenv ("SKIP_TEST_COMMAND_6");
9446 if (str && strcmp (str, "1") == 0) return 1;
9447 str = getenv ("SKIP_TEST_COMMAND");
9448 if (str && strcmp (str, "1") == 0) return 1;
9452 static int test_command_6 (void)
9454 if (test_command_6_skip ()) {
9455 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_6");
9459 /* InitBasicFS for test_command_6: create ext2 on /dev/sda1 */
9461 char device[] = "/dev/sda";
9464 r = guestfs_blockdev_setrw (g, device);
9471 r = guestfs_umount_all (g);
9478 r = guestfs_lvm_remove_all (g);
9483 char device[] = "/dev/sda";
9484 char lines_0[] = ",";
9491 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9496 char fstype[] = "ext2";
9497 char device[] = "/dev/sda1";
9500 r = guestfs_mkfs (g, fstype, device);
9505 char device[] = "/dev/sda1";
9506 char mountpoint[] = "/";
9509 r = guestfs_mount (g, device, mountpoint);
9513 /* TestOutput for command (6) */
9514 char expected[] = "";
9516 char remotefilename[] = "/test-command";
9519 r = guestfs_upload (g, "test-command", remotefilename);
9524 char path[] = "/test-command";
9527 r = guestfs_chmod (g, 493, path);
9532 char arguments_0[] = "/test-command";
9533 char arguments_1[] = "7";
9534 char *arguments[] = {
9541 r = guestfs_command (g, arguments);
9544 if (strcmp (r, expected) != 0) {
9545 fprintf (stderr, "test_command_6: expected \"%s\" but got \"%s\"\n", expected, r);
9553 static int test_command_7_skip (void)
9557 str = getenv ("SKIP_TEST_COMMAND_7");
9558 if (str && strcmp (str, "1") == 0) return 1;
9559 str = getenv ("SKIP_TEST_COMMAND");
9560 if (str && strcmp (str, "1") == 0) return 1;
9564 static int test_command_7 (void)
9566 if (test_command_7_skip ()) {
9567 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_7");
9571 /* InitBasicFS for test_command_7: create ext2 on /dev/sda1 */
9573 char device[] = "/dev/sda";
9576 r = guestfs_blockdev_setrw (g, device);
9583 r = guestfs_umount_all (g);
9590 r = guestfs_lvm_remove_all (g);
9595 char device[] = "/dev/sda";
9596 char lines_0[] = ",";
9603 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9608 char fstype[] = "ext2";
9609 char device[] = "/dev/sda1";
9612 r = guestfs_mkfs (g, fstype, device);
9617 char device[] = "/dev/sda1";
9618 char mountpoint[] = "/";
9621 r = guestfs_mount (g, device, mountpoint);
9625 /* TestOutput for command (7) */
9626 char expected[] = "\n";
9628 char remotefilename[] = "/test-command";
9631 r = guestfs_upload (g, "test-command", remotefilename);
9636 char path[] = "/test-command";
9639 r = guestfs_chmod (g, 493, path);
9644 char arguments_0[] = "/test-command";
9645 char arguments_1[] = "8";
9646 char *arguments[] = {
9653 r = guestfs_command (g, arguments);
9656 if (strcmp (r, expected) != 0) {
9657 fprintf (stderr, "test_command_7: expected \"%s\" but got \"%s\"\n", expected, r);
9665 static int test_command_8_skip (void)
9669 str = getenv ("SKIP_TEST_COMMAND_8");
9670 if (str && strcmp (str, "1") == 0) return 1;
9671 str = getenv ("SKIP_TEST_COMMAND");
9672 if (str && strcmp (str, "1") == 0) return 1;
9676 static int test_command_8 (void)
9678 if (test_command_8_skip ()) {
9679 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_8");
9683 /* InitBasicFS for test_command_8: create ext2 on /dev/sda1 */
9685 char device[] = "/dev/sda";
9688 r = guestfs_blockdev_setrw (g, device);
9695 r = guestfs_umount_all (g);
9702 r = guestfs_lvm_remove_all (g);
9707 char device[] = "/dev/sda";
9708 char lines_0[] = ",";
9715 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9720 char fstype[] = "ext2";
9721 char device[] = "/dev/sda1";
9724 r = guestfs_mkfs (g, fstype, device);
9729 char device[] = "/dev/sda1";
9730 char mountpoint[] = "/";
9733 r = guestfs_mount (g, device, mountpoint);
9737 /* TestOutput for command (8) */
9738 char expected[] = "\n\n";
9740 char remotefilename[] = "/test-command";
9743 r = guestfs_upload (g, "test-command", remotefilename);
9748 char path[] = "/test-command";
9751 r = guestfs_chmod (g, 493, path);
9756 char arguments_0[] = "/test-command";
9757 char arguments_1[] = "9";
9758 char *arguments[] = {
9765 r = guestfs_command (g, arguments);
9768 if (strcmp (r, expected) != 0) {
9769 fprintf (stderr, "test_command_8: expected \"%s\" but got \"%s\"\n", expected, r);
9777 static int test_command_9_skip (void)
9781 str = getenv ("SKIP_TEST_COMMAND_9");
9782 if (str && strcmp (str, "1") == 0) return 1;
9783 str = getenv ("SKIP_TEST_COMMAND");
9784 if (str && strcmp (str, "1") == 0) return 1;
9788 static int test_command_9 (void)
9790 if (test_command_9_skip ()) {
9791 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_9");
9795 /* InitBasicFS for test_command_9: create ext2 on /dev/sda1 */
9797 char device[] = "/dev/sda";
9800 r = guestfs_blockdev_setrw (g, device);
9807 r = guestfs_umount_all (g);
9814 r = guestfs_lvm_remove_all (g);
9819 char device[] = "/dev/sda";
9820 char lines_0[] = ",";
9827 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9832 char fstype[] = "ext2";
9833 char device[] = "/dev/sda1";
9836 r = guestfs_mkfs (g, fstype, device);
9841 char device[] = "/dev/sda1";
9842 char mountpoint[] = "/";
9845 r = guestfs_mount (g, device, mountpoint);
9849 /* TestOutput for command (9) */
9850 char expected[] = "Result10-1\nResult10-2\n";
9852 char remotefilename[] = "/test-command";
9855 r = guestfs_upload (g, "test-command", remotefilename);
9860 char path[] = "/test-command";
9863 r = guestfs_chmod (g, 493, path);
9868 char arguments_0[] = "/test-command";
9869 char arguments_1[] = "10";
9870 char *arguments[] = {
9877 r = guestfs_command (g, arguments);
9880 if (strcmp (r, expected) != 0) {
9881 fprintf (stderr, "test_command_9: expected \"%s\" but got \"%s\"\n", expected, r);
9889 static int test_command_10_skip (void)
9893 str = getenv ("SKIP_TEST_COMMAND_10");
9894 if (str && strcmp (str, "1") == 0) return 1;
9895 str = getenv ("SKIP_TEST_COMMAND");
9896 if (str && strcmp (str, "1") == 0) return 1;
9900 static int test_command_10 (void)
9902 if (test_command_10_skip ()) {
9903 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_10");
9907 /* InitBasicFS for test_command_10: create ext2 on /dev/sda1 */
9909 char device[] = "/dev/sda";
9912 r = guestfs_blockdev_setrw (g, device);
9919 r = guestfs_umount_all (g);
9926 r = guestfs_lvm_remove_all (g);
9931 char device[] = "/dev/sda";
9932 char lines_0[] = ",";
9939 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
9944 char fstype[] = "ext2";
9945 char device[] = "/dev/sda1";
9948 r = guestfs_mkfs (g, fstype, device);
9953 char device[] = "/dev/sda1";
9954 char mountpoint[] = "/";
9957 r = guestfs_mount (g, device, mountpoint);
9961 /* TestOutput for command (10) */
9962 char expected[] = "Result11-1\nResult11-2";
9964 char remotefilename[] = "/test-command";
9967 r = guestfs_upload (g, "test-command", remotefilename);
9972 char path[] = "/test-command";
9975 r = guestfs_chmod (g, 493, path);
9980 char arguments_0[] = "/test-command";
9981 char arguments_1[] = "11";
9982 char *arguments[] = {
9989 r = guestfs_command (g, arguments);
9992 if (strcmp (r, expected) != 0) {
9993 fprintf (stderr, "test_command_10: expected \"%s\" but got \"%s\"\n", expected, r);
10001 static int test_command_11_skip (void)
10005 str = getenv ("SKIP_TEST_COMMAND_11");
10006 if (str && strcmp (str, "1") == 0) return 1;
10007 str = getenv ("SKIP_TEST_COMMAND");
10008 if (str && strcmp (str, "1") == 0) return 1;
10012 static int test_command_11 (void)
10014 if (test_command_11_skip ()) {
10015 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_command_11");
10019 /* InitBasicFS for test_command_11: create ext2 on /dev/sda1 */
10021 char device[] = "/dev/sda";
10023 suppress_error = 0;
10024 r = guestfs_blockdev_setrw (g, device);
10030 suppress_error = 0;
10031 r = guestfs_umount_all (g);
10037 suppress_error = 0;
10038 r = guestfs_lvm_remove_all (g);
10043 char device[] = "/dev/sda";
10044 char lines_0[] = ",";
10050 suppress_error = 0;
10051 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10056 char fstype[] = "ext2";
10057 char device[] = "/dev/sda1";
10059 suppress_error = 0;
10060 r = guestfs_mkfs (g, fstype, device);
10065 char device[] = "/dev/sda1";
10066 char mountpoint[] = "/";
10068 suppress_error = 0;
10069 r = guestfs_mount (g, device, mountpoint);
10073 /* TestLastFail for command (11) */
10075 char remotefilename[] = "/test-command";
10077 suppress_error = 0;
10078 r = guestfs_upload (g, "test-command", remotefilename);
10083 char path[] = "/test-command";
10085 suppress_error = 0;
10086 r = guestfs_chmod (g, 493, path);
10091 char arguments_0[] = "/test-command";
10092 char *arguments[] = {
10097 suppress_error = 1;
10098 r = guestfs_command (g, arguments);
10106 static int test_file_0_skip (void)
10110 str = getenv ("SKIP_TEST_FILE_0");
10111 if (str && strcmp (str, "1") == 0) return 1;
10112 str = getenv ("SKIP_TEST_FILE");
10113 if (str && strcmp (str, "1") == 0) return 1;
10117 static int test_file_0 (void)
10119 if (test_file_0_skip ()) {
10120 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_0");
10124 /* InitBasicFS for test_file_0: create ext2 on /dev/sda1 */
10126 char device[] = "/dev/sda";
10128 suppress_error = 0;
10129 r = guestfs_blockdev_setrw (g, device);
10135 suppress_error = 0;
10136 r = guestfs_umount_all (g);
10142 suppress_error = 0;
10143 r = guestfs_lvm_remove_all (g);
10148 char device[] = "/dev/sda";
10149 char lines_0[] = ",";
10155 suppress_error = 0;
10156 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10161 char fstype[] = "ext2";
10162 char device[] = "/dev/sda1";
10164 suppress_error = 0;
10165 r = guestfs_mkfs (g, fstype, device);
10170 char device[] = "/dev/sda1";
10171 char mountpoint[] = "/";
10173 suppress_error = 0;
10174 r = guestfs_mount (g, device, mountpoint);
10178 /* TestOutput for file (0) */
10179 char expected[] = "empty";
10181 char path[] = "/new";
10183 suppress_error = 0;
10184 r = guestfs_touch (g, path);
10189 char path[] = "/new";
10191 suppress_error = 0;
10192 r = guestfs_file (g, path);
10195 if (strcmp (r, expected) != 0) {
10196 fprintf (stderr, "test_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
10204 static int test_file_1_skip (void)
10208 str = getenv ("SKIP_TEST_FILE_1");
10209 if (str && strcmp (str, "1") == 0) return 1;
10210 str = getenv ("SKIP_TEST_FILE");
10211 if (str && strcmp (str, "1") == 0) return 1;
10215 static int test_file_1 (void)
10217 if (test_file_1_skip ()) {
10218 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_1");
10222 /* InitBasicFS for test_file_1: create ext2 on /dev/sda1 */
10224 char device[] = "/dev/sda";
10226 suppress_error = 0;
10227 r = guestfs_blockdev_setrw (g, device);
10233 suppress_error = 0;
10234 r = guestfs_umount_all (g);
10240 suppress_error = 0;
10241 r = guestfs_lvm_remove_all (g);
10246 char device[] = "/dev/sda";
10247 char lines_0[] = ",";
10253 suppress_error = 0;
10254 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10259 char fstype[] = "ext2";
10260 char device[] = "/dev/sda1";
10262 suppress_error = 0;
10263 r = guestfs_mkfs (g, fstype, device);
10268 char device[] = "/dev/sda1";
10269 char mountpoint[] = "/";
10271 suppress_error = 0;
10272 r = guestfs_mount (g, device, mountpoint);
10276 /* TestOutput for file (1) */
10277 char expected[] = "ASCII text";
10279 char path[] = "/new";
10280 char content[] = "some content\n";
10282 suppress_error = 0;
10283 r = guestfs_write_file (g, path, content, 0);
10288 char path[] = "/new";
10290 suppress_error = 0;
10291 r = guestfs_file (g, path);
10294 if (strcmp (r, expected) != 0) {
10295 fprintf (stderr, "test_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
10303 static int test_file_2_skip (void)
10307 str = getenv ("SKIP_TEST_FILE_2");
10308 if (str && strcmp (str, "1") == 0) return 1;
10309 str = getenv ("SKIP_TEST_FILE");
10310 if (str && strcmp (str, "1") == 0) return 1;
10314 static int test_file_2 (void)
10316 if (test_file_2_skip ()) {
10317 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_file_2");
10321 /* InitBasicFS for test_file_2: create ext2 on /dev/sda1 */
10323 char device[] = "/dev/sda";
10325 suppress_error = 0;
10326 r = guestfs_blockdev_setrw (g, device);
10332 suppress_error = 0;
10333 r = guestfs_umount_all (g);
10339 suppress_error = 0;
10340 r = guestfs_lvm_remove_all (g);
10345 char device[] = "/dev/sda";
10346 char lines_0[] = ",";
10352 suppress_error = 0;
10353 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10358 char fstype[] = "ext2";
10359 char device[] = "/dev/sda1";
10361 suppress_error = 0;
10362 r = guestfs_mkfs (g, fstype, device);
10367 char device[] = "/dev/sda1";
10368 char mountpoint[] = "/";
10370 suppress_error = 0;
10371 r = guestfs_mount (g, device, mountpoint);
10375 /* TestLastFail for file (2) */
10377 char path[] = "/nofile";
10379 suppress_error = 1;
10380 r = guestfs_file (g, path);
10388 static int test_umount_all_0_skip (void)
10392 str = getenv ("SKIP_TEST_UMOUNT_ALL_0");
10393 if (str && strcmp (str, "1") == 0) return 1;
10394 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10395 if (str && strcmp (str, "1") == 0) return 1;
10399 static int test_umount_all_0 (void)
10401 if (test_umount_all_0_skip ()) {
10402 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_0");
10406 /* InitBasicFS for test_umount_all_0: create ext2 on /dev/sda1 */
10408 char device[] = "/dev/sda";
10410 suppress_error = 0;
10411 r = guestfs_blockdev_setrw (g, device);
10417 suppress_error = 0;
10418 r = guestfs_umount_all (g);
10424 suppress_error = 0;
10425 r = guestfs_lvm_remove_all (g);
10430 char device[] = "/dev/sda";
10431 char lines_0[] = ",";
10437 suppress_error = 0;
10438 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10443 char fstype[] = "ext2";
10444 char device[] = "/dev/sda1";
10446 suppress_error = 0;
10447 r = guestfs_mkfs (g, fstype, device);
10452 char device[] = "/dev/sda1";
10453 char mountpoint[] = "/";
10455 suppress_error = 0;
10456 r = guestfs_mount (g, device, mountpoint);
10460 /* TestOutputList for umount_all (0) */
10463 suppress_error = 0;
10464 r = guestfs_umount_all (g);
10471 suppress_error = 0;
10472 r = guestfs_mounts (g);
10475 if (r[0] != NULL) {
10476 fprintf (stderr, "test_umount_all_0: extra elements returned from command\n");
10480 for (i = 0; r[i] != NULL; ++i)
10487 static int test_umount_all_1_skip (void)
10491 str = getenv ("SKIP_TEST_UMOUNT_ALL_1");
10492 if (str && strcmp (str, "1") == 0) return 1;
10493 str = getenv ("SKIP_TEST_UMOUNT_ALL");
10494 if (str && strcmp (str, "1") == 0) return 1;
10498 static int test_umount_all_1 (void)
10500 if (test_umount_all_1_skip ()) {
10501 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_all_1");
10505 /* InitNone|InitEmpty for test_umount_all_1 */
10507 char device[] = "/dev/sda";
10509 suppress_error = 0;
10510 r = guestfs_blockdev_setrw (g, device);
10516 suppress_error = 0;
10517 r = guestfs_umount_all (g);
10523 suppress_error = 0;
10524 r = guestfs_lvm_remove_all (g);
10528 /* TestOutputList for umount_all (1) */
10530 char device[] = "/dev/sda";
10531 char lines_0[] = ",10";
10532 char lines_1[] = ",20";
10533 char lines_2[] = ",";
10541 suppress_error = 0;
10542 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10547 char fstype[] = "ext2";
10548 char device[] = "/dev/sda1";
10550 suppress_error = 0;
10551 r = guestfs_mkfs (g, fstype, device);
10556 char fstype[] = "ext2";
10557 char device[] = "/dev/sda2";
10559 suppress_error = 0;
10560 r = guestfs_mkfs (g, fstype, device);
10565 char fstype[] = "ext2";
10566 char device[] = "/dev/sda3";
10568 suppress_error = 0;
10569 r = guestfs_mkfs (g, fstype, device);
10574 char device[] = "/dev/sda1";
10575 char mountpoint[] = "/";
10577 suppress_error = 0;
10578 r = guestfs_mount (g, device, mountpoint);
10583 char path[] = "/mp1";
10585 suppress_error = 0;
10586 r = guestfs_mkdir (g, path);
10591 char device[] = "/dev/sda2";
10592 char mountpoint[] = "/mp1";
10594 suppress_error = 0;
10595 r = guestfs_mount (g, device, mountpoint);
10600 char path[] = "/mp1/mp2";
10602 suppress_error = 0;
10603 r = guestfs_mkdir (g, path);
10608 char device[] = "/dev/sda3";
10609 char mountpoint[] = "/mp1/mp2";
10611 suppress_error = 0;
10612 r = guestfs_mount (g, device, mountpoint);
10617 char path[] = "/mp1/mp2/mp3";
10619 suppress_error = 0;
10620 r = guestfs_mkdir (g, path);
10626 suppress_error = 0;
10627 r = guestfs_umount_all (g);
10634 suppress_error = 0;
10635 r = guestfs_mounts (g);
10638 if (r[0] != NULL) {
10639 fprintf (stderr, "test_umount_all_1: extra elements returned from command\n");
10643 for (i = 0; r[i] != NULL; ++i)
10650 static int test_mounts_0_skip (void)
10654 str = getenv ("SKIP_TEST_MOUNTS_0");
10655 if (str && strcmp (str, "1") == 0) return 1;
10656 str = getenv ("SKIP_TEST_MOUNTS");
10657 if (str && strcmp (str, "1") == 0) return 1;
10661 static int test_mounts_0 (void)
10663 if (test_mounts_0_skip ()) {
10664 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mounts_0");
10668 /* InitBasicFS for test_mounts_0: create ext2 on /dev/sda1 */
10670 char device[] = "/dev/sda";
10672 suppress_error = 0;
10673 r = guestfs_blockdev_setrw (g, device);
10679 suppress_error = 0;
10680 r = guestfs_umount_all (g);
10686 suppress_error = 0;
10687 r = guestfs_lvm_remove_all (g);
10692 char device[] = "/dev/sda";
10693 char lines_0[] = ",";
10699 suppress_error = 0;
10700 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10705 char fstype[] = "ext2";
10706 char device[] = "/dev/sda1";
10708 suppress_error = 0;
10709 r = guestfs_mkfs (g, fstype, device);
10714 char device[] = "/dev/sda1";
10715 char mountpoint[] = "/";
10717 suppress_error = 0;
10718 r = guestfs_mount (g, device, mountpoint);
10722 /* TestOutputListOfDevices for mounts (0) */
10726 suppress_error = 0;
10727 r = guestfs_mounts (g);
10731 fprintf (stderr, "test_mounts_0: short list returned from command\n");
10736 char expected[] = "/dev/sda1";
10738 if (strcmp (r[0], expected) != 0) {
10739 fprintf (stderr, "test_mounts_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10743 if (r[1] != NULL) {
10744 fprintf (stderr, "test_mounts_0: extra elements returned from command\n");
10748 for (i = 0; r[i] != NULL; ++i)
10755 static int test_umount_0_skip (void)
10759 str = getenv ("SKIP_TEST_UMOUNT_0");
10760 if (str && strcmp (str, "1") == 0) return 1;
10761 str = getenv ("SKIP_TEST_UMOUNT");
10762 if (str && strcmp (str, "1") == 0) return 1;
10766 static int test_umount_0 (void)
10768 if (test_umount_0_skip ()) {
10769 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_0");
10773 /* InitNone|InitEmpty for test_umount_0 */
10775 char device[] = "/dev/sda";
10777 suppress_error = 0;
10778 r = guestfs_blockdev_setrw (g, device);
10784 suppress_error = 0;
10785 r = guestfs_umount_all (g);
10791 suppress_error = 0;
10792 r = guestfs_lvm_remove_all (g);
10796 /* TestOutputListOfDevices for umount (0) */
10798 char device[] = "/dev/sda";
10799 char lines_0[] = ",";
10805 suppress_error = 0;
10806 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10811 char fstype[] = "ext2";
10812 char device[] = "/dev/sda1";
10814 suppress_error = 0;
10815 r = guestfs_mkfs (g, fstype, device);
10820 char device[] = "/dev/sda1";
10821 char mountpoint[] = "/";
10823 suppress_error = 0;
10824 r = guestfs_mount (g, device, mountpoint);
10831 suppress_error = 0;
10832 r = guestfs_mounts (g);
10836 fprintf (stderr, "test_umount_0: short list returned from command\n");
10841 char expected[] = "/dev/sda1";
10843 if (strcmp (r[0], expected) != 0) {
10844 fprintf (stderr, "test_umount_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
10848 if (r[1] != NULL) {
10849 fprintf (stderr, "test_umount_0: extra elements returned from command\n");
10853 for (i = 0; r[i] != NULL; ++i)
10860 static int test_umount_1_skip (void)
10864 str = getenv ("SKIP_TEST_UMOUNT_1");
10865 if (str && strcmp (str, "1") == 0) return 1;
10866 str = getenv ("SKIP_TEST_UMOUNT");
10867 if (str && strcmp (str, "1") == 0) return 1;
10871 static int test_umount_1 (void)
10873 if (test_umount_1_skip ()) {
10874 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_umount_1");
10878 /* InitNone|InitEmpty for test_umount_1 */
10880 char device[] = "/dev/sda";
10882 suppress_error = 0;
10883 r = guestfs_blockdev_setrw (g, device);
10889 suppress_error = 0;
10890 r = guestfs_umount_all (g);
10896 suppress_error = 0;
10897 r = guestfs_lvm_remove_all (g);
10901 /* TestOutputList for umount (1) */
10903 char device[] = "/dev/sda";
10904 char lines_0[] = ",";
10910 suppress_error = 0;
10911 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
10916 char fstype[] = "ext2";
10917 char device[] = "/dev/sda1";
10919 suppress_error = 0;
10920 r = guestfs_mkfs (g, fstype, device);
10925 char device[] = "/dev/sda1";
10926 char mountpoint[] = "/";
10928 suppress_error = 0;
10929 r = guestfs_mount (g, device, mountpoint);
10934 char pathordevice[] = "/";
10936 suppress_error = 0;
10937 r = guestfs_umount (g, pathordevice);
10944 suppress_error = 0;
10945 r = guestfs_mounts (g);
10948 if (r[0] != NULL) {
10949 fprintf (stderr, "test_umount_1: extra elements returned from command\n");
10953 for (i = 0; r[i] != NULL; ++i)
10960 static int test_write_file_0_skip (void)
10964 str = getenv ("SKIP_TEST_WRITE_FILE_0");
10965 if (str && strcmp (str, "1") == 0) return 1;
10966 str = getenv ("SKIP_TEST_WRITE_FILE");
10967 if (str && strcmp (str, "1") == 0) return 1;
10971 static int test_write_file_0 (void)
10973 if (test_write_file_0_skip ()) {
10974 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_0");
10978 /* InitBasicFS for test_write_file_0: create ext2 on /dev/sda1 */
10980 char device[] = "/dev/sda";
10982 suppress_error = 0;
10983 r = guestfs_blockdev_setrw (g, device);
10989 suppress_error = 0;
10990 r = guestfs_umount_all (g);
10996 suppress_error = 0;
10997 r = guestfs_lvm_remove_all (g);
11002 char device[] = "/dev/sda";
11003 char lines_0[] = ",";
11009 suppress_error = 0;
11010 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11015 char fstype[] = "ext2";
11016 char device[] = "/dev/sda1";
11018 suppress_error = 0;
11019 r = guestfs_mkfs (g, fstype, device);
11024 char device[] = "/dev/sda1";
11025 char mountpoint[] = "/";
11027 suppress_error = 0;
11028 r = guestfs_mount (g, device, mountpoint);
11032 /* TestOutput for write_file (0) */
11033 char expected[] = "new file contents";
11035 char path[] = "/new";
11036 char content[] = "new file contents";
11038 suppress_error = 0;
11039 r = guestfs_write_file (g, path, content, 0);
11044 char path[] = "/new";
11046 suppress_error = 0;
11047 r = guestfs_cat (g, path);
11050 if (strcmp (r, expected) != 0) {
11051 fprintf (stderr, "test_write_file_0: expected \"%s\" but got \"%s\"\n", expected, r);
11059 static int test_write_file_1_skip (void)
11063 str = getenv ("SKIP_TEST_WRITE_FILE_1");
11064 if (str && strcmp (str, "1") == 0) return 1;
11065 str = getenv ("SKIP_TEST_WRITE_FILE");
11066 if (str && strcmp (str, "1") == 0) return 1;
11070 static int test_write_file_1 (void)
11072 if (test_write_file_1_skip ()) {
11073 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_1");
11077 /* InitBasicFS for test_write_file_1: create ext2 on /dev/sda1 */
11079 char device[] = "/dev/sda";
11081 suppress_error = 0;
11082 r = guestfs_blockdev_setrw (g, device);
11088 suppress_error = 0;
11089 r = guestfs_umount_all (g);
11095 suppress_error = 0;
11096 r = guestfs_lvm_remove_all (g);
11101 char device[] = "/dev/sda";
11102 char lines_0[] = ",";
11108 suppress_error = 0;
11109 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11114 char fstype[] = "ext2";
11115 char device[] = "/dev/sda1";
11117 suppress_error = 0;
11118 r = guestfs_mkfs (g, fstype, device);
11123 char device[] = "/dev/sda1";
11124 char mountpoint[] = "/";
11126 suppress_error = 0;
11127 r = guestfs_mount (g, device, mountpoint);
11131 /* TestOutput for write_file (1) */
11132 char expected[] = "\nnew file contents\n";
11134 char path[] = "/new";
11135 char content[] = "\nnew file contents\n";
11137 suppress_error = 0;
11138 r = guestfs_write_file (g, path, content, 0);
11143 char path[] = "/new";
11145 suppress_error = 0;
11146 r = guestfs_cat (g, path);
11149 if (strcmp (r, expected) != 0) {
11150 fprintf (stderr, "test_write_file_1: expected \"%s\" but got \"%s\"\n", expected, r);
11158 static int test_write_file_2_skip (void)
11162 str = getenv ("SKIP_TEST_WRITE_FILE_2");
11163 if (str && strcmp (str, "1") == 0) return 1;
11164 str = getenv ("SKIP_TEST_WRITE_FILE");
11165 if (str && strcmp (str, "1") == 0) return 1;
11169 static int test_write_file_2 (void)
11171 if (test_write_file_2_skip ()) {
11172 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_2");
11176 /* InitBasicFS for test_write_file_2: create ext2 on /dev/sda1 */
11178 char device[] = "/dev/sda";
11180 suppress_error = 0;
11181 r = guestfs_blockdev_setrw (g, device);
11187 suppress_error = 0;
11188 r = guestfs_umount_all (g);
11194 suppress_error = 0;
11195 r = guestfs_lvm_remove_all (g);
11200 char device[] = "/dev/sda";
11201 char lines_0[] = ",";
11207 suppress_error = 0;
11208 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11213 char fstype[] = "ext2";
11214 char device[] = "/dev/sda1";
11216 suppress_error = 0;
11217 r = guestfs_mkfs (g, fstype, device);
11222 char device[] = "/dev/sda1";
11223 char mountpoint[] = "/";
11225 suppress_error = 0;
11226 r = guestfs_mount (g, device, mountpoint);
11230 /* TestOutput for write_file (2) */
11231 char expected[] = "\n\n";
11233 char path[] = "/new";
11234 char content[] = "\n\n";
11236 suppress_error = 0;
11237 r = guestfs_write_file (g, path, content, 0);
11242 char path[] = "/new";
11244 suppress_error = 0;
11245 r = guestfs_cat (g, path);
11248 if (strcmp (r, expected) != 0) {
11249 fprintf (stderr, "test_write_file_2: expected \"%s\" but got \"%s\"\n", expected, r);
11257 static int test_write_file_3_skip (void)
11261 str = getenv ("SKIP_TEST_WRITE_FILE_3");
11262 if (str && strcmp (str, "1") == 0) return 1;
11263 str = getenv ("SKIP_TEST_WRITE_FILE");
11264 if (str && strcmp (str, "1") == 0) return 1;
11268 static int test_write_file_3 (void)
11270 if (test_write_file_3_skip ()) {
11271 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_3");
11275 /* InitBasicFS for test_write_file_3: create ext2 on /dev/sda1 */
11277 char device[] = "/dev/sda";
11279 suppress_error = 0;
11280 r = guestfs_blockdev_setrw (g, device);
11286 suppress_error = 0;
11287 r = guestfs_umount_all (g);
11293 suppress_error = 0;
11294 r = guestfs_lvm_remove_all (g);
11299 char device[] = "/dev/sda";
11300 char lines_0[] = ",";
11306 suppress_error = 0;
11307 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11312 char fstype[] = "ext2";
11313 char device[] = "/dev/sda1";
11315 suppress_error = 0;
11316 r = guestfs_mkfs (g, fstype, device);
11321 char device[] = "/dev/sda1";
11322 char mountpoint[] = "/";
11324 suppress_error = 0;
11325 r = guestfs_mount (g, device, mountpoint);
11329 /* TestOutput for write_file (3) */
11330 char expected[] = "";
11332 char path[] = "/new";
11333 char content[] = "";
11335 suppress_error = 0;
11336 r = guestfs_write_file (g, path, content, 0);
11341 char path[] = "/new";
11343 suppress_error = 0;
11344 r = guestfs_cat (g, path);
11347 if (strcmp (r, expected) != 0) {
11348 fprintf (stderr, "test_write_file_3: expected \"%s\" but got \"%s\"\n", expected, r);
11356 static int test_write_file_4_skip (void)
11360 str = getenv ("SKIP_TEST_WRITE_FILE_4");
11361 if (str && strcmp (str, "1") == 0) return 1;
11362 str = getenv ("SKIP_TEST_WRITE_FILE");
11363 if (str && strcmp (str, "1") == 0) return 1;
11367 static int test_write_file_4 (void)
11369 if (test_write_file_4_skip ()) {
11370 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_4");
11374 /* InitBasicFS for test_write_file_4: create ext2 on /dev/sda1 */
11376 char device[] = "/dev/sda";
11378 suppress_error = 0;
11379 r = guestfs_blockdev_setrw (g, device);
11385 suppress_error = 0;
11386 r = guestfs_umount_all (g);
11392 suppress_error = 0;
11393 r = guestfs_lvm_remove_all (g);
11398 char device[] = "/dev/sda";
11399 char lines_0[] = ",";
11405 suppress_error = 0;
11406 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11411 char fstype[] = "ext2";
11412 char device[] = "/dev/sda1";
11414 suppress_error = 0;
11415 r = guestfs_mkfs (g, fstype, device);
11420 char device[] = "/dev/sda1";
11421 char mountpoint[] = "/";
11423 suppress_error = 0;
11424 r = guestfs_mount (g, device, mountpoint);
11428 /* TestOutput for write_file (4) */
11429 char expected[] = "\n\n\n";
11431 char path[] = "/new";
11432 char content[] = "\n\n\n";
11434 suppress_error = 0;
11435 r = guestfs_write_file (g, path, content, 0);
11440 char path[] = "/new";
11442 suppress_error = 0;
11443 r = guestfs_cat (g, path);
11446 if (strcmp (r, expected) != 0) {
11447 fprintf (stderr, "test_write_file_4: expected \"%s\" but got \"%s\"\n", expected, r);
11455 static int test_write_file_5_skip (void)
11459 str = getenv ("SKIP_TEST_WRITE_FILE_5");
11460 if (str && strcmp (str, "1") == 0) return 1;
11461 str = getenv ("SKIP_TEST_WRITE_FILE");
11462 if (str && strcmp (str, "1") == 0) return 1;
11466 static int test_write_file_5 (void)
11468 if (test_write_file_5_skip ()) {
11469 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_write_file_5");
11473 /* InitBasicFS for test_write_file_5: create ext2 on /dev/sda1 */
11475 char device[] = "/dev/sda";
11477 suppress_error = 0;
11478 r = guestfs_blockdev_setrw (g, device);
11484 suppress_error = 0;
11485 r = guestfs_umount_all (g);
11491 suppress_error = 0;
11492 r = guestfs_lvm_remove_all (g);
11497 char device[] = "/dev/sda";
11498 char lines_0[] = ",";
11504 suppress_error = 0;
11505 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11510 char fstype[] = "ext2";
11511 char device[] = "/dev/sda1";
11513 suppress_error = 0;
11514 r = guestfs_mkfs (g, fstype, device);
11519 char device[] = "/dev/sda1";
11520 char mountpoint[] = "/";
11522 suppress_error = 0;
11523 r = guestfs_mount (g, device, mountpoint);
11527 /* TestOutput for write_file (5) */
11528 char expected[] = "\n";
11530 char path[] = "/new";
11531 char content[] = "\n";
11533 suppress_error = 0;
11534 r = guestfs_write_file (g, path, content, 0);
11539 char path[] = "/new";
11541 suppress_error = 0;
11542 r = guestfs_cat (g, path);
11545 if (strcmp (r, expected) != 0) {
11546 fprintf (stderr, "test_write_file_5: expected \"%s\" but got \"%s\"\n", expected, r);
11554 static int test_mkfs_0_skip (void)
11558 str = getenv ("SKIP_TEST_MKFS_0");
11559 if (str && strcmp (str, "1") == 0) return 1;
11560 str = getenv ("SKIP_TEST_MKFS");
11561 if (str && strcmp (str, "1") == 0) return 1;
11565 static int test_mkfs_0 (void)
11567 if (test_mkfs_0_skip ()) {
11568 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkfs_0");
11572 /* InitNone|InitEmpty for test_mkfs_0 */
11574 char device[] = "/dev/sda";
11576 suppress_error = 0;
11577 r = guestfs_blockdev_setrw (g, device);
11583 suppress_error = 0;
11584 r = guestfs_umount_all (g);
11590 suppress_error = 0;
11591 r = guestfs_lvm_remove_all (g);
11595 /* TestOutput for mkfs (0) */
11596 char expected[] = "new file contents";
11598 char device[] = "/dev/sda";
11599 char lines_0[] = ",";
11605 suppress_error = 0;
11606 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11611 char fstype[] = "ext2";
11612 char device[] = "/dev/sda1";
11614 suppress_error = 0;
11615 r = guestfs_mkfs (g, fstype, device);
11620 char device[] = "/dev/sda1";
11621 char mountpoint[] = "/";
11623 suppress_error = 0;
11624 r = guestfs_mount (g, device, mountpoint);
11629 char path[] = "/new";
11630 char content[] = "new file contents";
11632 suppress_error = 0;
11633 r = guestfs_write_file (g, path, content, 0);
11638 char path[] = "/new";
11640 suppress_error = 0;
11641 r = guestfs_cat (g, path);
11644 if (strcmp (r, expected) != 0) {
11645 fprintf (stderr, "test_mkfs_0: expected \"%s\" but got \"%s\"\n", expected, r);
11653 static int test_lvcreate_0_skip (void)
11657 str = getenv ("SKIP_TEST_LVCREATE_0");
11658 if (str && strcmp (str, "1") == 0) return 1;
11659 str = getenv ("SKIP_TEST_LVCREATE");
11660 if (str && strcmp (str, "1") == 0) return 1;
11664 static int test_lvcreate_0 (void)
11666 if (test_lvcreate_0_skip ()) {
11667 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvcreate_0");
11671 /* InitNone|InitEmpty for test_lvcreate_0 */
11673 char device[] = "/dev/sda";
11675 suppress_error = 0;
11676 r = guestfs_blockdev_setrw (g, device);
11682 suppress_error = 0;
11683 r = guestfs_umount_all (g);
11689 suppress_error = 0;
11690 r = guestfs_lvm_remove_all (g);
11694 /* TestOutputList for lvcreate (0) */
11696 char device[] = "/dev/sda";
11697 char lines_0[] = ",10";
11698 char lines_1[] = ",20";
11699 char lines_2[] = ",";
11707 suppress_error = 0;
11708 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11713 char device[] = "/dev/sda1";
11715 suppress_error = 0;
11716 r = guestfs_pvcreate (g, device);
11721 char device[] = "/dev/sda2";
11723 suppress_error = 0;
11724 r = guestfs_pvcreate (g, device);
11729 char device[] = "/dev/sda3";
11731 suppress_error = 0;
11732 r = guestfs_pvcreate (g, device);
11737 char volgroup[] = "VG1";
11738 char physvols_0[] = "/dev/sda1";
11739 char physvols_1[] = "/dev/sda2";
11740 char *physvols[] = {
11746 suppress_error = 0;
11747 r = guestfs_vgcreate (g, volgroup, physvols);
11752 char volgroup[] = "VG2";
11753 char physvols_0[] = "/dev/sda3";
11754 char *physvols[] = {
11759 suppress_error = 0;
11760 r = guestfs_vgcreate (g, volgroup, physvols);
11765 char logvol[] = "LV1";
11766 char volgroup[] = "VG1";
11768 suppress_error = 0;
11769 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11774 char logvol[] = "LV2";
11775 char volgroup[] = "VG1";
11777 suppress_error = 0;
11778 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11783 char logvol[] = "LV3";
11784 char volgroup[] = "VG2";
11786 suppress_error = 0;
11787 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11792 char logvol[] = "LV4";
11793 char volgroup[] = "VG2";
11795 suppress_error = 0;
11796 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11801 char logvol[] = "LV5";
11802 char volgroup[] = "VG2";
11804 suppress_error = 0;
11805 r = guestfs_lvcreate (g, logvol, volgroup, 50);
11812 suppress_error = 0;
11813 r = guestfs_lvs (g);
11817 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11822 char expected[] = "/dev/VG1/LV1";
11823 if (strcmp (r[0], expected) != 0) {
11824 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
11829 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11834 char expected[] = "/dev/VG1/LV2";
11835 if (strcmp (r[1], expected) != 0) {
11836 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
11841 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11846 char expected[] = "/dev/VG2/LV3";
11847 if (strcmp (r[2], expected) != 0) {
11848 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
11853 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11858 char expected[] = "/dev/VG2/LV4";
11859 if (strcmp (r[3], expected) != 0) {
11860 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
11865 fprintf (stderr, "test_lvcreate_0: short list returned from command\n");
11870 char expected[] = "/dev/VG2/LV5";
11871 if (strcmp (r[4], expected) != 0) {
11872 fprintf (stderr, "test_lvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[4]);
11876 if (r[5] != NULL) {
11877 fprintf (stderr, "test_lvcreate_0: extra elements returned from command\n");
11881 for (i = 0; r[i] != NULL; ++i)
11888 static int test_vgcreate_0_skip (void)
11892 str = getenv ("SKIP_TEST_VGCREATE_0");
11893 if (str && strcmp (str, "1") == 0) return 1;
11894 str = getenv ("SKIP_TEST_VGCREATE");
11895 if (str && strcmp (str, "1") == 0) return 1;
11899 static int test_vgcreate_0 (void)
11901 if (test_vgcreate_0_skip ()) {
11902 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgcreate_0");
11906 /* InitNone|InitEmpty for test_vgcreate_0 */
11908 char device[] = "/dev/sda";
11910 suppress_error = 0;
11911 r = guestfs_blockdev_setrw (g, device);
11917 suppress_error = 0;
11918 r = guestfs_umount_all (g);
11924 suppress_error = 0;
11925 r = guestfs_lvm_remove_all (g);
11929 /* TestOutputList for vgcreate (0) */
11931 char device[] = "/dev/sda";
11932 char lines_0[] = ",10";
11933 char lines_1[] = ",20";
11934 char lines_2[] = ",";
11942 suppress_error = 0;
11943 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
11948 char device[] = "/dev/sda1";
11950 suppress_error = 0;
11951 r = guestfs_pvcreate (g, device);
11956 char device[] = "/dev/sda2";
11958 suppress_error = 0;
11959 r = guestfs_pvcreate (g, device);
11964 char device[] = "/dev/sda3";
11966 suppress_error = 0;
11967 r = guestfs_pvcreate (g, device);
11972 char volgroup[] = "VG1";
11973 char physvols_0[] = "/dev/sda1";
11974 char physvols_1[] = "/dev/sda2";
11975 char *physvols[] = {
11981 suppress_error = 0;
11982 r = guestfs_vgcreate (g, volgroup, physvols);
11987 char volgroup[] = "VG2";
11988 char physvols_0[] = "/dev/sda3";
11989 char *physvols[] = {
11994 suppress_error = 0;
11995 r = guestfs_vgcreate (g, volgroup, physvols);
12002 suppress_error = 0;
12003 r = guestfs_vgs (g);
12007 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12012 char expected[] = "VG1";
12013 if (strcmp (r[0], expected) != 0) {
12014 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12019 fprintf (stderr, "test_vgcreate_0: short list returned from command\n");
12024 char expected[] = "VG2";
12025 if (strcmp (r[1], expected) != 0) {
12026 fprintf (stderr, "test_vgcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12030 if (r[2] != NULL) {
12031 fprintf (stderr, "test_vgcreate_0: extra elements returned from command\n");
12035 for (i = 0; r[i] != NULL; ++i)
12042 static int test_pvcreate_0_skip (void)
12046 str = getenv ("SKIP_TEST_PVCREATE_0");
12047 if (str && strcmp (str, "1") == 0) return 1;
12048 str = getenv ("SKIP_TEST_PVCREATE");
12049 if (str && strcmp (str, "1") == 0) return 1;
12053 static int test_pvcreate_0 (void)
12055 if (test_pvcreate_0_skip ()) {
12056 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvcreate_0");
12060 /* InitNone|InitEmpty for test_pvcreate_0 */
12062 char device[] = "/dev/sda";
12064 suppress_error = 0;
12065 r = guestfs_blockdev_setrw (g, device);
12071 suppress_error = 0;
12072 r = guestfs_umount_all (g);
12078 suppress_error = 0;
12079 r = guestfs_lvm_remove_all (g);
12083 /* TestOutputListOfDevices for pvcreate (0) */
12085 char device[] = "/dev/sda";
12086 char lines_0[] = ",10";
12087 char lines_1[] = ",20";
12088 char lines_2[] = ",";
12096 suppress_error = 0;
12097 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12102 char device[] = "/dev/sda1";
12104 suppress_error = 0;
12105 r = guestfs_pvcreate (g, device);
12110 char device[] = "/dev/sda2";
12112 suppress_error = 0;
12113 r = guestfs_pvcreate (g, device);
12118 char device[] = "/dev/sda3";
12120 suppress_error = 0;
12121 r = guestfs_pvcreate (g, device);
12128 suppress_error = 0;
12129 r = guestfs_pvs (g);
12133 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12138 char expected[] = "/dev/sda1";
12140 if (strcmp (r[0], expected) != 0) {
12141 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
12146 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12151 char expected[] = "/dev/sda2";
12153 if (strcmp (r[1], expected) != 0) {
12154 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
12159 fprintf (stderr, "test_pvcreate_0: short list returned from command\n");
12164 char expected[] = "/dev/sda3";
12166 if (strcmp (r[2], expected) != 0) {
12167 fprintf (stderr, "test_pvcreate_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
12171 if (r[3] != NULL) {
12172 fprintf (stderr, "test_pvcreate_0: extra elements returned from command\n");
12176 for (i = 0; r[i] != NULL; ++i)
12183 static int test_is_dir_0_skip (void)
12187 str = getenv ("SKIP_TEST_IS_DIR_0");
12188 if (str && strcmp (str, "1") == 0) return 1;
12189 str = getenv ("SKIP_TEST_IS_DIR");
12190 if (str && strcmp (str, "1") == 0) return 1;
12194 static int test_is_dir_0 (void)
12196 if (test_is_dir_0_skip ()) {
12197 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_0");
12201 /* InitBasicFS for test_is_dir_0: create ext2 on /dev/sda1 */
12203 char device[] = "/dev/sda";
12205 suppress_error = 0;
12206 r = guestfs_blockdev_setrw (g, device);
12212 suppress_error = 0;
12213 r = guestfs_umount_all (g);
12219 suppress_error = 0;
12220 r = guestfs_lvm_remove_all (g);
12225 char device[] = "/dev/sda";
12226 char lines_0[] = ",";
12232 suppress_error = 0;
12233 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12238 char fstype[] = "ext2";
12239 char device[] = "/dev/sda1";
12241 suppress_error = 0;
12242 r = guestfs_mkfs (g, fstype, device);
12247 char device[] = "/dev/sda1";
12248 char mountpoint[] = "/";
12250 suppress_error = 0;
12251 r = guestfs_mount (g, device, mountpoint);
12255 /* TestOutputFalse for is_dir (0) */
12257 char path[] = "/new";
12259 suppress_error = 0;
12260 r = guestfs_touch (g, path);
12265 char path[] = "/new";
12267 suppress_error = 0;
12268 r = guestfs_is_dir (g, path);
12272 fprintf (stderr, "test_is_dir_0: expected false, got true\n");
12279 static int test_is_dir_1_skip (void)
12283 str = getenv ("SKIP_TEST_IS_DIR_1");
12284 if (str && strcmp (str, "1") == 0) return 1;
12285 str = getenv ("SKIP_TEST_IS_DIR");
12286 if (str && strcmp (str, "1") == 0) return 1;
12290 static int test_is_dir_1 (void)
12292 if (test_is_dir_1_skip ()) {
12293 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_dir_1");
12297 /* InitBasicFS for test_is_dir_1: create ext2 on /dev/sda1 */
12299 char device[] = "/dev/sda";
12301 suppress_error = 0;
12302 r = guestfs_blockdev_setrw (g, device);
12308 suppress_error = 0;
12309 r = guestfs_umount_all (g);
12315 suppress_error = 0;
12316 r = guestfs_lvm_remove_all (g);
12321 char device[] = "/dev/sda";
12322 char lines_0[] = ",";
12328 suppress_error = 0;
12329 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12334 char fstype[] = "ext2";
12335 char device[] = "/dev/sda1";
12337 suppress_error = 0;
12338 r = guestfs_mkfs (g, fstype, device);
12343 char device[] = "/dev/sda1";
12344 char mountpoint[] = "/";
12346 suppress_error = 0;
12347 r = guestfs_mount (g, device, mountpoint);
12351 /* TestOutputTrue for is_dir (1) */
12353 char path[] = "/new";
12355 suppress_error = 0;
12356 r = guestfs_mkdir (g, path);
12361 char path[] = "/new";
12363 suppress_error = 0;
12364 r = guestfs_is_dir (g, path);
12368 fprintf (stderr, "test_is_dir_1: expected true, got false\n");
12375 static int test_is_file_0_skip (void)
12379 str = getenv ("SKIP_TEST_IS_FILE_0");
12380 if (str && strcmp (str, "1") == 0) return 1;
12381 str = getenv ("SKIP_TEST_IS_FILE");
12382 if (str && strcmp (str, "1") == 0) return 1;
12386 static int test_is_file_0 (void)
12388 if (test_is_file_0_skip ()) {
12389 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_0");
12393 /* InitBasicFS for test_is_file_0: create ext2 on /dev/sda1 */
12395 char device[] = "/dev/sda";
12397 suppress_error = 0;
12398 r = guestfs_blockdev_setrw (g, device);
12404 suppress_error = 0;
12405 r = guestfs_umount_all (g);
12411 suppress_error = 0;
12412 r = guestfs_lvm_remove_all (g);
12417 char device[] = "/dev/sda";
12418 char lines_0[] = ",";
12424 suppress_error = 0;
12425 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12430 char fstype[] = "ext2";
12431 char device[] = "/dev/sda1";
12433 suppress_error = 0;
12434 r = guestfs_mkfs (g, fstype, device);
12439 char device[] = "/dev/sda1";
12440 char mountpoint[] = "/";
12442 suppress_error = 0;
12443 r = guestfs_mount (g, device, mountpoint);
12447 /* TestOutputTrue for is_file (0) */
12449 char path[] = "/new";
12451 suppress_error = 0;
12452 r = guestfs_touch (g, path);
12457 char path[] = "/new";
12459 suppress_error = 0;
12460 r = guestfs_is_file (g, path);
12464 fprintf (stderr, "test_is_file_0: expected true, got false\n");
12471 static int test_is_file_1_skip (void)
12475 str = getenv ("SKIP_TEST_IS_FILE_1");
12476 if (str && strcmp (str, "1") == 0) return 1;
12477 str = getenv ("SKIP_TEST_IS_FILE");
12478 if (str && strcmp (str, "1") == 0) return 1;
12482 static int test_is_file_1 (void)
12484 if (test_is_file_1_skip ()) {
12485 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_is_file_1");
12489 /* InitBasicFS for test_is_file_1: create ext2 on /dev/sda1 */
12491 char device[] = "/dev/sda";
12493 suppress_error = 0;
12494 r = guestfs_blockdev_setrw (g, device);
12500 suppress_error = 0;
12501 r = guestfs_umount_all (g);
12507 suppress_error = 0;
12508 r = guestfs_lvm_remove_all (g);
12513 char device[] = "/dev/sda";
12514 char lines_0[] = ",";
12520 suppress_error = 0;
12521 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12526 char fstype[] = "ext2";
12527 char device[] = "/dev/sda1";
12529 suppress_error = 0;
12530 r = guestfs_mkfs (g, fstype, device);
12535 char device[] = "/dev/sda1";
12536 char mountpoint[] = "/";
12538 suppress_error = 0;
12539 r = guestfs_mount (g, device, mountpoint);
12543 /* TestOutputFalse for is_file (1) */
12545 char path[] = "/new";
12547 suppress_error = 0;
12548 r = guestfs_mkdir (g, path);
12553 char path[] = "/new";
12555 suppress_error = 0;
12556 r = guestfs_is_file (g, path);
12560 fprintf (stderr, "test_is_file_1: expected false, got true\n");
12567 static int test_exists_0_skip (void)
12571 str = getenv ("SKIP_TEST_EXISTS_0");
12572 if (str && strcmp (str, "1") == 0) return 1;
12573 str = getenv ("SKIP_TEST_EXISTS");
12574 if (str && strcmp (str, "1") == 0) return 1;
12578 static int test_exists_0 (void)
12580 if (test_exists_0_skip ()) {
12581 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_0");
12585 /* InitBasicFS for test_exists_0: create ext2 on /dev/sda1 */
12587 char device[] = "/dev/sda";
12589 suppress_error = 0;
12590 r = guestfs_blockdev_setrw (g, device);
12596 suppress_error = 0;
12597 r = guestfs_umount_all (g);
12603 suppress_error = 0;
12604 r = guestfs_lvm_remove_all (g);
12609 char device[] = "/dev/sda";
12610 char lines_0[] = ",";
12616 suppress_error = 0;
12617 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12622 char fstype[] = "ext2";
12623 char device[] = "/dev/sda1";
12625 suppress_error = 0;
12626 r = guestfs_mkfs (g, fstype, device);
12631 char device[] = "/dev/sda1";
12632 char mountpoint[] = "/";
12634 suppress_error = 0;
12635 r = guestfs_mount (g, device, mountpoint);
12639 /* TestOutputTrue for exists (0) */
12641 char path[] = "/new";
12643 suppress_error = 0;
12644 r = guestfs_touch (g, path);
12649 char path[] = "/new";
12651 suppress_error = 0;
12652 r = guestfs_exists (g, path);
12656 fprintf (stderr, "test_exists_0: expected true, got false\n");
12663 static int test_exists_1_skip (void)
12667 str = getenv ("SKIP_TEST_EXISTS_1");
12668 if (str && strcmp (str, "1") == 0) return 1;
12669 str = getenv ("SKIP_TEST_EXISTS");
12670 if (str && strcmp (str, "1") == 0) return 1;
12674 static int test_exists_1 (void)
12676 if (test_exists_1_skip ()) {
12677 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_exists_1");
12681 /* InitBasicFS for test_exists_1: create ext2 on /dev/sda1 */
12683 char device[] = "/dev/sda";
12685 suppress_error = 0;
12686 r = guestfs_blockdev_setrw (g, device);
12692 suppress_error = 0;
12693 r = guestfs_umount_all (g);
12699 suppress_error = 0;
12700 r = guestfs_lvm_remove_all (g);
12705 char device[] = "/dev/sda";
12706 char lines_0[] = ",";
12712 suppress_error = 0;
12713 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12718 char fstype[] = "ext2";
12719 char device[] = "/dev/sda1";
12721 suppress_error = 0;
12722 r = guestfs_mkfs (g, fstype, device);
12727 char device[] = "/dev/sda1";
12728 char mountpoint[] = "/";
12730 suppress_error = 0;
12731 r = guestfs_mount (g, device, mountpoint);
12735 /* TestOutputTrue for exists (1) */
12737 char path[] = "/new";
12739 suppress_error = 0;
12740 r = guestfs_mkdir (g, path);
12745 char path[] = "/new";
12747 suppress_error = 0;
12748 r = guestfs_exists (g, path);
12752 fprintf (stderr, "test_exists_1: expected true, got false\n");
12759 static int test_mkdir_p_0_skip (void)
12763 str = getenv ("SKIP_TEST_MKDIR_P_0");
12764 if (str && strcmp (str, "1") == 0) return 1;
12765 str = getenv ("SKIP_TEST_MKDIR_P");
12766 if (str && strcmp (str, "1") == 0) return 1;
12770 static int test_mkdir_p_0 (void)
12772 if (test_mkdir_p_0_skip ()) {
12773 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_0");
12777 /* InitBasicFS for test_mkdir_p_0: create ext2 on /dev/sda1 */
12779 char device[] = "/dev/sda";
12781 suppress_error = 0;
12782 r = guestfs_blockdev_setrw (g, device);
12788 suppress_error = 0;
12789 r = guestfs_umount_all (g);
12795 suppress_error = 0;
12796 r = guestfs_lvm_remove_all (g);
12801 char device[] = "/dev/sda";
12802 char lines_0[] = ",";
12808 suppress_error = 0;
12809 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12814 char fstype[] = "ext2";
12815 char device[] = "/dev/sda1";
12817 suppress_error = 0;
12818 r = guestfs_mkfs (g, fstype, device);
12823 char device[] = "/dev/sda1";
12824 char mountpoint[] = "/";
12826 suppress_error = 0;
12827 r = guestfs_mount (g, device, mountpoint);
12831 /* TestOutputTrue for mkdir_p (0) */
12833 char path[] = "/new/foo/bar";
12835 suppress_error = 0;
12836 r = guestfs_mkdir_p (g, path);
12841 char path[] = "/new/foo/bar";
12843 suppress_error = 0;
12844 r = guestfs_is_dir (g, path);
12848 fprintf (stderr, "test_mkdir_p_0: expected true, got false\n");
12855 static int test_mkdir_p_1_skip (void)
12859 str = getenv ("SKIP_TEST_MKDIR_P_1");
12860 if (str && strcmp (str, "1") == 0) return 1;
12861 str = getenv ("SKIP_TEST_MKDIR_P");
12862 if (str && strcmp (str, "1") == 0) return 1;
12866 static int test_mkdir_p_1 (void)
12868 if (test_mkdir_p_1_skip ()) {
12869 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_1");
12873 /* InitBasicFS for test_mkdir_p_1: create ext2 on /dev/sda1 */
12875 char device[] = "/dev/sda";
12877 suppress_error = 0;
12878 r = guestfs_blockdev_setrw (g, device);
12884 suppress_error = 0;
12885 r = guestfs_umount_all (g);
12891 suppress_error = 0;
12892 r = guestfs_lvm_remove_all (g);
12897 char device[] = "/dev/sda";
12898 char lines_0[] = ",";
12904 suppress_error = 0;
12905 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
12910 char fstype[] = "ext2";
12911 char device[] = "/dev/sda1";
12913 suppress_error = 0;
12914 r = guestfs_mkfs (g, fstype, device);
12919 char device[] = "/dev/sda1";
12920 char mountpoint[] = "/";
12922 suppress_error = 0;
12923 r = guestfs_mount (g, device, mountpoint);
12927 /* TestOutputTrue for mkdir_p (1) */
12929 char path[] = "/new/foo/bar";
12931 suppress_error = 0;
12932 r = guestfs_mkdir_p (g, path);
12937 char path[] = "/new/foo";
12939 suppress_error = 0;
12940 r = guestfs_is_dir (g, path);
12944 fprintf (stderr, "test_mkdir_p_1: expected true, got false\n");
12951 static int test_mkdir_p_2_skip (void)
12955 str = getenv ("SKIP_TEST_MKDIR_P_2");
12956 if (str && strcmp (str, "1") == 0) return 1;
12957 str = getenv ("SKIP_TEST_MKDIR_P");
12958 if (str && strcmp (str, "1") == 0) return 1;
12962 static int test_mkdir_p_2 (void)
12964 if (test_mkdir_p_2_skip ()) {
12965 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_2");
12969 /* InitBasicFS for test_mkdir_p_2: create ext2 on /dev/sda1 */
12971 char device[] = "/dev/sda";
12973 suppress_error = 0;
12974 r = guestfs_blockdev_setrw (g, device);
12980 suppress_error = 0;
12981 r = guestfs_umount_all (g);
12987 suppress_error = 0;
12988 r = guestfs_lvm_remove_all (g);
12993 char device[] = "/dev/sda";
12994 char lines_0[] = ",";
13000 suppress_error = 0;
13001 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13006 char fstype[] = "ext2";
13007 char device[] = "/dev/sda1";
13009 suppress_error = 0;
13010 r = guestfs_mkfs (g, fstype, device);
13015 char device[] = "/dev/sda1";
13016 char mountpoint[] = "/";
13018 suppress_error = 0;
13019 r = guestfs_mount (g, device, mountpoint);
13023 /* TestOutputTrue for mkdir_p (2) */
13025 char path[] = "/new/foo/bar";
13027 suppress_error = 0;
13028 r = guestfs_mkdir_p (g, path);
13033 char path[] = "/new";
13035 suppress_error = 0;
13036 r = guestfs_is_dir (g, path);
13040 fprintf (stderr, "test_mkdir_p_2: expected true, got false\n");
13047 static int test_mkdir_p_3_skip (void)
13051 str = getenv ("SKIP_TEST_MKDIR_P_3");
13052 if (str && strcmp (str, "1") == 0) return 1;
13053 str = getenv ("SKIP_TEST_MKDIR_P");
13054 if (str && strcmp (str, "1") == 0) return 1;
13058 static int test_mkdir_p_3 (void)
13060 if (test_mkdir_p_3_skip ()) {
13061 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_3");
13065 /* InitBasicFS for test_mkdir_p_3: create ext2 on /dev/sda1 */
13067 char device[] = "/dev/sda";
13069 suppress_error = 0;
13070 r = guestfs_blockdev_setrw (g, device);
13076 suppress_error = 0;
13077 r = guestfs_umount_all (g);
13083 suppress_error = 0;
13084 r = guestfs_lvm_remove_all (g);
13089 char device[] = "/dev/sda";
13090 char lines_0[] = ",";
13096 suppress_error = 0;
13097 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13102 char fstype[] = "ext2";
13103 char device[] = "/dev/sda1";
13105 suppress_error = 0;
13106 r = guestfs_mkfs (g, fstype, device);
13111 char device[] = "/dev/sda1";
13112 char mountpoint[] = "/";
13114 suppress_error = 0;
13115 r = guestfs_mount (g, device, mountpoint);
13119 /* TestRun for mkdir_p (3) */
13121 char path[] = "/new";
13123 suppress_error = 0;
13124 r = guestfs_mkdir (g, path);
13129 char path[] = "/new";
13131 suppress_error = 0;
13132 r = guestfs_mkdir_p (g, path);
13139 static int test_mkdir_p_4_skip (void)
13143 str = getenv ("SKIP_TEST_MKDIR_P_4");
13144 if (str && strcmp (str, "1") == 0) return 1;
13145 str = getenv ("SKIP_TEST_MKDIR_P");
13146 if (str && strcmp (str, "1") == 0) return 1;
13150 static int test_mkdir_p_4 (void)
13152 if (test_mkdir_p_4_skip ()) {
13153 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_p_4");
13157 /* InitBasicFS for test_mkdir_p_4: create ext2 on /dev/sda1 */
13159 char device[] = "/dev/sda";
13161 suppress_error = 0;
13162 r = guestfs_blockdev_setrw (g, device);
13168 suppress_error = 0;
13169 r = guestfs_umount_all (g);
13175 suppress_error = 0;
13176 r = guestfs_lvm_remove_all (g);
13181 char device[] = "/dev/sda";
13182 char lines_0[] = ",";
13188 suppress_error = 0;
13189 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13194 char fstype[] = "ext2";
13195 char device[] = "/dev/sda1";
13197 suppress_error = 0;
13198 r = guestfs_mkfs (g, fstype, device);
13203 char device[] = "/dev/sda1";
13204 char mountpoint[] = "/";
13206 suppress_error = 0;
13207 r = guestfs_mount (g, device, mountpoint);
13211 /* TestLastFail for mkdir_p (4) */
13213 char path[] = "/new";
13215 suppress_error = 0;
13216 r = guestfs_touch (g, path);
13221 char path[] = "/new";
13223 suppress_error = 1;
13224 r = guestfs_mkdir_p (g, path);
13231 static int test_mkdir_0_skip (void)
13235 str = getenv ("SKIP_TEST_MKDIR_0");
13236 if (str && strcmp (str, "1") == 0) return 1;
13237 str = getenv ("SKIP_TEST_MKDIR");
13238 if (str && strcmp (str, "1") == 0) return 1;
13242 static int test_mkdir_0 (void)
13244 if (test_mkdir_0_skip ()) {
13245 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_0");
13249 /* InitBasicFS for test_mkdir_0: create ext2 on /dev/sda1 */
13251 char device[] = "/dev/sda";
13253 suppress_error = 0;
13254 r = guestfs_blockdev_setrw (g, device);
13260 suppress_error = 0;
13261 r = guestfs_umount_all (g);
13267 suppress_error = 0;
13268 r = guestfs_lvm_remove_all (g);
13273 char device[] = "/dev/sda";
13274 char lines_0[] = ",";
13280 suppress_error = 0;
13281 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13286 char fstype[] = "ext2";
13287 char device[] = "/dev/sda1";
13289 suppress_error = 0;
13290 r = guestfs_mkfs (g, fstype, device);
13295 char device[] = "/dev/sda1";
13296 char mountpoint[] = "/";
13298 suppress_error = 0;
13299 r = guestfs_mount (g, device, mountpoint);
13303 /* TestOutputTrue for mkdir (0) */
13305 char path[] = "/new";
13307 suppress_error = 0;
13308 r = guestfs_mkdir (g, path);
13313 char path[] = "/new";
13315 suppress_error = 0;
13316 r = guestfs_is_dir (g, path);
13320 fprintf (stderr, "test_mkdir_0: expected true, got false\n");
13327 static int test_mkdir_1_skip (void)
13331 str = getenv ("SKIP_TEST_MKDIR_1");
13332 if (str && strcmp (str, "1") == 0) return 1;
13333 str = getenv ("SKIP_TEST_MKDIR");
13334 if (str && strcmp (str, "1") == 0) return 1;
13338 static int test_mkdir_1 (void)
13340 if (test_mkdir_1_skip ()) {
13341 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mkdir_1");
13345 /* InitBasicFS for test_mkdir_1: create ext2 on /dev/sda1 */
13347 char device[] = "/dev/sda";
13349 suppress_error = 0;
13350 r = guestfs_blockdev_setrw (g, device);
13356 suppress_error = 0;
13357 r = guestfs_umount_all (g);
13363 suppress_error = 0;
13364 r = guestfs_lvm_remove_all (g);
13369 char device[] = "/dev/sda";
13370 char lines_0[] = ",";
13376 suppress_error = 0;
13377 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13382 char fstype[] = "ext2";
13383 char device[] = "/dev/sda1";
13385 suppress_error = 0;
13386 r = guestfs_mkfs (g, fstype, device);
13391 char device[] = "/dev/sda1";
13392 char mountpoint[] = "/";
13394 suppress_error = 0;
13395 r = guestfs_mount (g, device, mountpoint);
13399 /* TestLastFail for mkdir (1) */
13401 char path[] = "/new/foo/bar";
13403 suppress_error = 1;
13404 r = guestfs_mkdir (g, path);
13411 static int test_rm_rf_0_skip (void)
13415 str = getenv ("SKIP_TEST_RM_RF_0");
13416 if (str && strcmp (str, "1") == 0) return 1;
13417 str = getenv ("SKIP_TEST_RM_RF");
13418 if (str && strcmp (str, "1") == 0) return 1;
13422 static int test_rm_rf_0 (void)
13424 if (test_rm_rf_0_skip ()) {
13425 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_rf_0");
13429 /* InitBasicFS for test_rm_rf_0: create ext2 on /dev/sda1 */
13431 char device[] = "/dev/sda";
13433 suppress_error = 0;
13434 r = guestfs_blockdev_setrw (g, device);
13440 suppress_error = 0;
13441 r = guestfs_umount_all (g);
13447 suppress_error = 0;
13448 r = guestfs_lvm_remove_all (g);
13453 char device[] = "/dev/sda";
13454 char lines_0[] = ",";
13460 suppress_error = 0;
13461 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13466 char fstype[] = "ext2";
13467 char device[] = "/dev/sda1";
13469 suppress_error = 0;
13470 r = guestfs_mkfs (g, fstype, device);
13475 char device[] = "/dev/sda1";
13476 char mountpoint[] = "/";
13478 suppress_error = 0;
13479 r = guestfs_mount (g, device, mountpoint);
13483 /* TestOutputFalse for rm_rf (0) */
13485 char path[] = "/new";
13487 suppress_error = 0;
13488 r = guestfs_mkdir (g, path);
13493 char path[] = "/new/foo";
13495 suppress_error = 0;
13496 r = guestfs_mkdir (g, path);
13501 char path[] = "/new/foo/bar";
13503 suppress_error = 0;
13504 r = guestfs_touch (g, path);
13509 char path[] = "/new";
13511 suppress_error = 0;
13512 r = guestfs_rm_rf (g, path);
13517 char path[] = "/new";
13519 suppress_error = 0;
13520 r = guestfs_exists (g, path);
13524 fprintf (stderr, "test_rm_rf_0: expected false, got true\n");
13531 static int test_rmdir_0_skip (void)
13535 str = getenv ("SKIP_TEST_RMDIR_0");
13536 if (str && strcmp (str, "1") == 0) return 1;
13537 str = getenv ("SKIP_TEST_RMDIR");
13538 if (str && strcmp (str, "1") == 0) return 1;
13542 static int test_rmdir_0 (void)
13544 if (test_rmdir_0_skip ()) {
13545 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_0");
13549 /* InitBasicFS for test_rmdir_0: create ext2 on /dev/sda1 */
13551 char device[] = "/dev/sda";
13553 suppress_error = 0;
13554 r = guestfs_blockdev_setrw (g, device);
13560 suppress_error = 0;
13561 r = guestfs_umount_all (g);
13567 suppress_error = 0;
13568 r = guestfs_lvm_remove_all (g);
13573 char device[] = "/dev/sda";
13574 char lines_0[] = ",";
13580 suppress_error = 0;
13581 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13586 char fstype[] = "ext2";
13587 char device[] = "/dev/sda1";
13589 suppress_error = 0;
13590 r = guestfs_mkfs (g, fstype, device);
13595 char device[] = "/dev/sda1";
13596 char mountpoint[] = "/";
13598 suppress_error = 0;
13599 r = guestfs_mount (g, device, mountpoint);
13603 /* TestRun for rmdir (0) */
13605 char path[] = "/new";
13607 suppress_error = 0;
13608 r = guestfs_mkdir (g, path);
13613 char path[] = "/new";
13615 suppress_error = 0;
13616 r = guestfs_rmdir (g, path);
13623 static int test_rmdir_1_skip (void)
13627 str = getenv ("SKIP_TEST_RMDIR_1");
13628 if (str && strcmp (str, "1") == 0) return 1;
13629 str = getenv ("SKIP_TEST_RMDIR");
13630 if (str && strcmp (str, "1") == 0) return 1;
13634 static int test_rmdir_1 (void)
13636 if (test_rmdir_1_skip ()) {
13637 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_1");
13641 /* InitBasicFS for test_rmdir_1: create ext2 on /dev/sda1 */
13643 char device[] = "/dev/sda";
13645 suppress_error = 0;
13646 r = guestfs_blockdev_setrw (g, device);
13652 suppress_error = 0;
13653 r = guestfs_umount_all (g);
13659 suppress_error = 0;
13660 r = guestfs_lvm_remove_all (g);
13665 char device[] = "/dev/sda";
13666 char lines_0[] = ",";
13672 suppress_error = 0;
13673 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13678 char fstype[] = "ext2";
13679 char device[] = "/dev/sda1";
13681 suppress_error = 0;
13682 r = guestfs_mkfs (g, fstype, device);
13687 char device[] = "/dev/sda1";
13688 char mountpoint[] = "/";
13690 suppress_error = 0;
13691 r = guestfs_mount (g, device, mountpoint);
13695 /* TestLastFail for rmdir (1) */
13697 char path[] = "/new";
13699 suppress_error = 1;
13700 r = guestfs_rmdir (g, path);
13707 static int test_rmdir_2_skip (void)
13711 str = getenv ("SKIP_TEST_RMDIR_2");
13712 if (str && strcmp (str, "1") == 0) return 1;
13713 str = getenv ("SKIP_TEST_RMDIR");
13714 if (str && strcmp (str, "1") == 0) return 1;
13718 static int test_rmdir_2 (void)
13720 if (test_rmdir_2_skip ()) {
13721 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rmdir_2");
13725 /* InitBasicFS for test_rmdir_2: create ext2 on /dev/sda1 */
13727 char device[] = "/dev/sda";
13729 suppress_error = 0;
13730 r = guestfs_blockdev_setrw (g, device);
13736 suppress_error = 0;
13737 r = guestfs_umount_all (g);
13743 suppress_error = 0;
13744 r = guestfs_lvm_remove_all (g);
13749 char device[] = "/dev/sda";
13750 char lines_0[] = ",";
13756 suppress_error = 0;
13757 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13762 char fstype[] = "ext2";
13763 char device[] = "/dev/sda1";
13765 suppress_error = 0;
13766 r = guestfs_mkfs (g, fstype, device);
13771 char device[] = "/dev/sda1";
13772 char mountpoint[] = "/";
13774 suppress_error = 0;
13775 r = guestfs_mount (g, device, mountpoint);
13779 /* TestLastFail for rmdir (2) */
13781 char path[] = "/new";
13783 suppress_error = 0;
13784 r = guestfs_touch (g, path);
13789 char path[] = "/new";
13791 suppress_error = 1;
13792 r = guestfs_rmdir (g, path);
13799 static int test_rm_0_skip (void)
13803 str = getenv ("SKIP_TEST_RM_0");
13804 if (str && strcmp (str, "1") == 0) return 1;
13805 str = getenv ("SKIP_TEST_RM");
13806 if (str && strcmp (str, "1") == 0) return 1;
13810 static int test_rm_0 (void)
13812 if (test_rm_0_skip ()) {
13813 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_0");
13817 /* InitBasicFS for test_rm_0: create ext2 on /dev/sda1 */
13819 char device[] = "/dev/sda";
13821 suppress_error = 0;
13822 r = guestfs_blockdev_setrw (g, device);
13828 suppress_error = 0;
13829 r = guestfs_umount_all (g);
13835 suppress_error = 0;
13836 r = guestfs_lvm_remove_all (g);
13841 char device[] = "/dev/sda";
13842 char lines_0[] = ",";
13848 suppress_error = 0;
13849 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13854 char fstype[] = "ext2";
13855 char device[] = "/dev/sda1";
13857 suppress_error = 0;
13858 r = guestfs_mkfs (g, fstype, device);
13863 char device[] = "/dev/sda1";
13864 char mountpoint[] = "/";
13866 suppress_error = 0;
13867 r = guestfs_mount (g, device, mountpoint);
13871 /* TestRun for rm (0) */
13873 char path[] = "/new";
13875 suppress_error = 0;
13876 r = guestfs_touch (g, path);
13881 char path[] = "/new";
13883 suppress_error = 0;
13884 r = guestfs_rm (g, path);
13891 static int test_rm_1_skip (void)
13895 str = getenv ("SKIP_TEST_RM_1");
13896 if (str && strcmp (str, "1") == 0) return 1;
13897 str = getenv ("SKIP_TEST_RM");
13898 if (str && strcmp (str, "1") == 0) return 1;
13902 static int test_rm_1 (void)
13904 if (test_rm_1_skip ()) {
13905 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_1");
13909 /* InitBasicFS for test_rm_1: create ext2 on /dev/sda1 */
13911 char device[] = "/dev/sda";
13913 suppress_error = 0;
13914 r = guestfs_blockdev_setrw (g, device);
13920 suppress_error = 0;
13921 r = guestfs_umount_all (g);
13927 suppress_error = 0;
13928 r = guestfs_lvm_remove_all (g);
13933 char device[] = "/dev/sda";
13934 char lines_0[] = ",";
13940 suppress_error = 0;
13941 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
13946 char fstype[] = "ext2";
13947 char device[] = "/dev/sda1";
13949 suppress_error = 0;
13950 r = guestfs_mkfs (g, fstype, device);
13955 char device[] = "/dev/sda1";
13956 char mountpoint[] = "/";
13958 suppress_error = 0;
13959 r = guestfs_mount (g, device, mountpoint);
13963 /* TestLastFail for rm (1) */
13965 char path[] = "/new";
13967 suppress_error = 1;
13968 r = guestfs_rm (g, path);
13975 static int test_rm_2_skip (void)
13979 str = getenv ("SKIP_TEST_RM_2");
13980 if (str && strcmp (str, "1") == 0) return 1;
13981 str = getenv ("SKIP_TEST_RM");
13982 if (str && strcmp (str, "1") == 0) return 1;
13986 static int test_rm_2 (void)
13988 if (test_rm_2_skip ()) {
13989 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_rm_2");
13993 /* InitBasicFS for test_rm_2: create ext2 on /dev/sda1 */
13995 char device[] = "/dev/sda";
13997 suppress_error = 0;
13998 r = guestfs_blockdev_setrw (g, device);
14004 suppress_error = 0;
14005 r = guestfs_umount_all (g);
14011 suppress_error = 0;
14012 r = guestfs_lvm_remove_all (g);
14017 char device[] = "/dev/sda";
14018 char lines_0[] = ",";
14024 suppress_error = 0;
14025 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14030 char fstype[] = "ext2";
14031 char device[] = "/dev/sda1";
14033 suppress_error = 0;
14034 r = guestfs_mkfs (g, fstype, device);
14039 char device[] = "/dev/sda1";
14040 char mountpoint[] = "/";
14042 suppress_error = 0;
14043 r = guestfs_mount (g, device, mountpoint);
14047 /* TestLastFail for rm (2) */
14049 char path[] = "/new";
14051 suppress_error = 0;
14052 r = guestfs_mkdir (g, path);
14057 char path[] = "/new";
14059 suppress_error = 1;
14060 r = guestfs_rm (g, path);
14067 static int test_read_lines_0_skip (void)
14071 str = getenv ("SKIP_TEST_READ_LINES_0");
14072 if (str && strcmp (str, "1") == 0) return 1;
14073 str = getenv ("SKIP_TEST_READ_LINES");
14074 if (str && strcmp (str, "1") == 0) return 1;
14078 static int test_read_lines_0 (void)
14080 if (test_read_lines_0_skip ()) {
14081 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_0");
14085 /* InitBasicFS for test_read_lines_0: create ext2 on /dev/sda1 */
14087 char device[] = "/dev/sda";
14089 suppress_error = 0;
14090 r = guestfs_blockdev_setrw (g, device);
14096 suppress_error = 0;
14097 r = guestfs_umount_all (g);
14103 suppress_error = 0;
14104 r = guestfs_lvm_remove_all (g);
14109 char device[] = "/dev/sda";
14110 char lines_0[] = ",";
14116 suppress_error = 0;
14117 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14122 char fstype[] = "ext2";
14123 char device[] = "/dev/sda1";
14125 suppress_error = 0;
14126 r = guestfs_mkfs (g, fstype, device);
14131 char device[] = "/dev/sda1";
14132 char mountpoint[] = "/";
14134 suppress_error = 0;
14135 r = guestfs_mount (g, device, mountpoint);
14139 /* TestOutputList for read_lines (0) */
14141 char path[] = "/new";
14142 char content[] = "line1\r\nline2\nline3";
14144 suppress_error = 0;
14145 r = guestfs_write_file (g, path, content, 0);
14150 char path[] = "/new";
14153 suppress_error = 0;
14154 r = guestfs_read_lines (g, path);
14158 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14163 char expected[] = "line1";
14164 if (strcmp (r[0], expected) != 0) {
14165 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14170 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14175 char expected[] = "line2";
14176 if (strcmp (r[1], expected) != 0) {
14177 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14182 fprintf (stderr, "test_read_lines_0: short list returned from command\n");
14187 char expected[] = "line3";
14188 if (strcmp (r[2], expected) != 0) {
14189 fprintf (stderr, "test_read_lines_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14193 if (r[3] != NULL) {
14194 fprintf (stderr, "test_read_lines_0: extra elements returned from command\n");
14198 for (i = 0; r[i] != NULL; ++i)
14205 static int test_read_lines_1_skip (void)
14209 str = getenv ("SKIP_TEST_READ_LINES_1");
14210 if (str && strcmp (str, "1") == 0) return 1;
14211 str = getenv ("SKIP_TEST_READ_LINES");
14212 if (str && strcmp (str, "1") == 0) return 1;
14216 static int test_read_lines_1 (void)
14218 if (test_read_lines_1_skip ()) {
14219 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_read_lines_1");
14223 /* InitBasicFS for test_read_lines_1: create ext2 on /dev/sda1 */
14225 char device[] = "/dev/sda";
14227 suppress_error = 0;
14228 r = guestfs_blockdev_setrw (g, device);
14234 suppress_error = 0;
14235 r = guestfs_umount_all (g);
14241 suppress_error = 0;
14242 r = guestfs_lvm_remove_all (g);
14247 char device[] = "/dev/sda";
14248 char lines_0[] = ",";
14254 suppress_error = 0;
14255 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14260 char fstype[] = "ext2";
14261 char device[] = "/dev/sda1";
14263 suppress_error = 0;
14264 r = guestfs_mkfs (g, fstype, device);
14269 char device[] = "/dev/sda1";
14270 char mountpoint[] = "/";
14272 suppress_error = 0;
14273 r = guestfs_mount (g, device, mountpoint);
14277 /* TestOutputList for read_lines (1) */
14279 char path[] = "/new";
14280 char content[] = "";
14282 suppress_error = 0;
14283 r = guestfs_write_file (g, path, content, 0);
14288 char path[] = "/new";
14291 suppress_error = 0;
14292 r = guestfs_read_lines (g, path);
14295 if (r[0] != NULL) {
14296 fprintf (stderr, "test_read_lines_1: extra elements returned from command\n");
14300 for (i = 0; r[i] != NULL; ++i)
14307 static int test_lvs_0_skip (void)
14311 str = getenv ("SKIP_TEST_LVS_0");
14312 if (str && strcmp (str, "1") == 0) return 1;
14313 str = getenv ("SKIP_TEST_LVS");
14314 if (str && strcmp (str, "1") == 0) return 1;
14318 static int test_lvs_0 (void)
14320 if (test_lvs_0_skip ()) {
14321 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_0");
14325 /* InitBasicFSonLVM for test_lvs_0: create ext2 on /dev/VG/LV */
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 device[] = "/dev/sda1";
14364 suppress_error = 0;
14365 r = guestfs_pvcreate (g, device);
14370 char volgroup[] = "VG";
14371 char physvols_0[] = "/dev/sda1";
14372 char *physvols[] = {
14377 suppress_error = 0;
14378 r = guestfs_vgcreate (g, volgroup, physvols);
14383 char logvol[] = "LV";
14384 char volgroup[] = "VG";
14386 suppress_error = 0;
14387 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14392 char fstype[] = "ext2";
14393 char device[] = "/dev/VG/LV";
14395 suppress_error = 0;
14396 r = guestfs_mkfs (g, fstype, device);
14401 char device[] = "/dev/VG/LV";
14402 char mountpoint[] = "/";
14404 suppress_error = 0;
14405 r = guestfs_mount (g, device, mountpoint);
14409 /* TestOutputList for lvs (0) */
14413 suppress_error = 0;
14414 r = guestfs_lvs (g);
14418 fprintf (stderr, "test_lvs_0: short list returned from command\n");
14423 char expected[] = "/dev/VG/LV";
14424 if (strcmp (r[0], expected) != 0) {
14425 fprintf (stderr, "test_lvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14429 if (r[1] != NULL) {
14430 fprintf (stderr, "test_lvs_0: extra elements returned from command\n");
14434 for (i = 0; r[i] != NULL; ++i)
14441 static int test_lvs_1_skip (void)
14445 str = getenv ("SKIP_TEST_LVS_1");
14446 if (str && strcmp (str, "1") == 0) return 1;
14447 str = getenv ("SKIP_TEST_LVS");
14448 if (str && strcmp (str, "1") == 0) return 1;
14452 static int test_lvs_1 (void)
14454 if (test_lvs_1_skip ()) {
14455 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_lvs_1");
14459 /* InitNone|InitEmpty for test_lvs_1 */
14461 char device[] = "/dev/sda";
14463 suppress_error = 0;
14464 r = guestfs_blockdev_setrw (g, device);
14470 suppress_error = 0;
14471 r = guestfs_umount_all (g);
14477 suppress_error = 0;
14478 r = guestfs_lvm_remove_all (g);
14482 /* TestOutputList for lvs (1) */
14484 char device[] = "/dev/sda";
14485 char lines_0[] = ",10";
14486 char lines_1[] = ",20";
14487 char lines_2[] = ",";
14495 suppress_error = 0;
14496 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14501 char device[] = "/dev/sda1";
14503 suppress_error = 0;
14504 r = guestfs_pvcreate (g, device);
14509 char device[] = "/dev/sda2";
14511 suppress_error = 0;
14512 r = guestfs_pvcreate (g, device);
14517 char device[] = "/dev/sda3";
14519 suppress_error = 0;
14520 r = guestfs_pvcreate (g, device);
14525 char volgroup[] = "VG1";
14526 char physvols_0[] = "/dev/sda1";
14527 char physvols_1[] = "/dev/sda2";
14528 char *physvols[] = {
14534 suppress_error = 0;
14535 r = guestfs_vgcreate (g, volgroup, physvols);
14540 char volgroup[] = "VG2";
14541 char physvols_0[] = "/dev/sda3";
14542 char *physvols[] = {
14547 suppress_error = 0;
14548 r = guestfs_vgcreate (g, volgroup, physvols);
14553 char logvol[] = "LV1";
14554 char volgroup[] = "VG1";
14556 suppress_error = 0;
14557 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14562 char logvol[] = "LV2";
14563 char volgroup[] = "VG1";
14565 suppress_error = 0;
14566 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14571 char logvol[] = "LV3";
14572 char volgroup[] = "VG2";
14574 suppress_error = 0;
14575 r = guestfs_lvcreate (g, logvol, volgroup, 50);
14582 suppress_error = 0;
14583 r = guestfs_lvs (g);
14587 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14592 char expected[] = "/dev/VG1/LV1";
14593 if (strcmp (r[0], expected) != 0) {
14594 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14599 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14604 char expected[] = "/dev/VG1/LV2";
14605 if (strcmp (r[1], expected) != 0) {
14606 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14611 fprintf (stderr, "test_lvs_1: short list returned from command\n");
14616 char expected[] = "/dev/VG2/LV3";
14617 if (strcmp (r[2], expected) != 0) {
14618 fprintf (stderr, "test_lvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
14622 if (r[3] != NULL) {
14623 fprintf (stderr, "test_lvs_1: extra elements returned from command\n");
14627 for (i = 0; r[i] != NULL; ++i)
14634 static int test_vgs_0_skip (void)
14638 str = getenv ("SKIP_TEST_VGS_0");
14639 if (str && strcmp (str, "1") == 0) return 1;
14640 str = getenv ("SKIP_TEST_VGS");
14641 if (str && strcmp (str, "1") == 0) return 1;
14645 static int test_vgs_0 (void)
14647 if (test_vgs_0_skip ()) {
14648 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_0");
14652 /* InitBasicFSonLVM for test_vgs_0: create ext2 on /dev/VG/LV */
14654 char device[] = "/dev/sda";
14656 suppress_error = 0;
14657 r = guestfs_blockdev_setrw (g, device);
14663 suppress_error = 0;
14664 r = guestfs_umount_all (g);
14670 suppress_error = 0;
14671 r = guestfs_lvm_remove_all (g);
14676 char device[] = "/dev/sda";
14677 char lines_0[] = ",";
14683 suppress_error = 0;
14684 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14689 char device[] = "/dev/sda1";
14691 suppress_error = 0;
14692 r = guestfs_pvcreate (g, device);
14697 char volgroup[] = "VG";
14698 char physvols_0[] = "/dev/sda1";
14699 char *physvols[] = {
14704 suppress_error = 0;
14705 r = guestfs_vgcreate (g, volgroup, physvols);
14710 char logvol[] = "LV";
14711 char volgroup[] = "VG";
14713 suppress_error = 0;
14714 r = guestfs_lvcreate (g, logvol, volgroup, 8);
14719 char fstype[] = "ext2";
14720 char device[] = "/dev/VG/LV";
14722 suppress_error = 0;
14723 r = guestfs_mkfs (g, fstype, device);
14728 char device[] = "/dev/VG/LV";
14729 char mountpoint[] = "/";
14731 suppress_error = 0;
14732 r = guestfs_mount (g, device, mountpoint);
14736 /* TestOutputList for vgs (0) */
14740 suppress_error = 0;
14741 r = guestfs_vgs (g);
14745 fprintf (stderr, "test_vgs_0: short list returned from command\n");
14750 char expected[] = "VG";
14751 if (strcmp (r[0], expected) != 0) {
14752 fprintf (stderr, "test_vgs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14756 if (r[1] != NULL) {
14757 fprintf (stderr, "test_vgs_0: extra elements returned from command\n");
14761 for (i = 0; r[i] != NULL; ++i)
14768 static int test_vgs_1_skip (void)
14772 str = getenv ("SKIP_TEST_VGS_1");
14773 if (str && strcmp (str, "1") == 0) return 1;
14774 str = getenv ("SKIP_TEST_VGS");
14775 if (str && strcmp (str, "1") == 0) return 1;
14779 static int test_vgs_1 (void)
14781 if (test_vgs_1_skip ()) {
14782 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_vgs_1");
14786 /* InitNone|InitEmpty for test_vgs_1 */
14788 char device[] = "/dev/sda";
14790 suppress_error = 0;
14791 r = guestfs_blockdev_setrw (g, device);
14797 suppress_error = 0;
14798 r = guestfs_umount_all (g);
14804 suppress_error = 0;
14805 r = guestfs_lvm_remove_all (g);
14809 /* TestOutputList for vgs (1) */
14811 char device[] = "/dev/sda";
14812 char lines_0[] = ",10";
14813 char lines_1[] = ",20";
14814 char lines_2[] = ",";
14822 suppress_error = 0;
14823 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14828 char device[] = "/dev/sda1";
14830 suppress_error = 0;
14831 r = guestfs_pvcreate (g, device);
14836 char device[] = "/dev/sda2";
14838 suppress_error = 0;
14839 r = guestfs_pvcreate (g, device);
14844 char device[] = "/dev/sda3";
14846 suppress_error = 0;
14847 r = guestfs_pvcreate (g, device);
14852 char volgroup[] = "VG1";
14853 char physvols_0[] = "/dev/sda1";
14854 char physvols_1[] = "/dev/sda2";
14855 char *physvols[] = {
14861 suppress_error = 0;
14862 r = guestfs_vgcreate (g, volgroup, physvols);
14867 char volgroup[] = "VG2";
14868 char physvols_0[] = "/dev/sda3";
14869 char *physvols[] = {
14874 suppress_error = 0;
14875 r = guestfs_vgcreate (g, volgroup, physvols);
14882 suppress_error = 0;
14883 r = guestfs_vgs (g);
14887 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14892 char expected[] = "VG1";
14893 if (strcmp (r[0], expected) != 0) {
14894 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
14899 fprintf (stderr, "test_vgs_1: short list returned from command\n");
14904 char expected[] = "VG2";
14905 if (strcmp (r[1], expected) != 0) {
14906 fprintf (stderr, "test_vgs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
14910 if (r[2] != NULL) {
14911 fprintf (stderr, "test_vgs_1: extra elements returned from command\n");
14915 for (i = 0; r[i] != NULL; ++i)
14922 static int test_pvs_0_skip (void)
14926 str = getenv ("SKIP_TEST_PVS_0");
14927 if (str && strcmp (str, "1") == 0) return 1;
14928 str = getenv ("SKIP_TEST_PVS");
14929 if (str && strcmp (str, "1") == 0) return 1;
14933 static int test_pvs_0 (void)
14935 if (test_pvs_0_skip ()) {
14936 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_0");
14940 /* InitBasicFSonLVM for test_pvs_0: create ext2 on /dev/VG/LV */
14942 char device[] = "/dev/sda";
14944 suppress_error = 0;
14945 r = guestfs_blockdev_setrw (g, device);
14951 suppress_error = 0;
14952 r = guestfs_umount_all (g);
14958 suppress_error = 0;
14959 r = guestfs_lvm_remove_all (g);
14964 char device[] = "/dev/sda";
14965 char lines_0[] = ",";
14971 suppress_error = 0;
14972 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
14977 char device[] = "/dev/sda1";
14979 suppress_error = 0;
14980 r = guestfs_pvcreate (g, device);
14985 char volgroup[] = "VG";
14986 char physvols_0[] = "/dev/sda1";
14987 char *physvols[] = {
14992 suppress_error = 0;
14993 r = guestfs_vgcreate (g, volgroup, physvols);
14998 char logvol[] = "LV";
14999 char volgroup[] = "VG";
15001 suppress_error = 0;
15002 r = guestfs_lvcreate (g, logvol, volgroup, 8);
15007 char fstype[] = "ext2";
15008 char device[] = "/dev/VG/LV";
15010 suppress_error = 0;
15011 r = guestfs_mkfs (g, fstype, device);
15016 char device[] = "/dev/VG/LV";
15017 char mountpoint[] = "/";
15019 suppress_error = 0;
15020 r = guestfs_mount (g, device, mountpoint);
15024 /* TestOutputListOfDevices for pvs (0) */
15028 suppress_error = 0;
15029 r = guestfs_pvs (g);
15033 fprintf (stderr, "test_pvs_0: short list returned from command\n");
15038 char expected[] = "/dev/sda1";
15040 if (strcmp (r[0], expected) != 0) {
15041 fprintf (stderr, "test_pvs_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15045 if (r[1] != NULL) {
15046 fprintf (stderr, "test_pvs_0: extra elements returned from command\n");
15050 for (i = 0; r[i] != NULL; ++i)
15057 static int test_pvs_1_skip (void)
15061 str = getenv ("SKIP_TEST_PVS_1");
15062 if (str && strcmp (str, "1") == 0) return 1;
15063 str = getenv ("SKIP_TEST_PVS");
15064 if (str && strcmp (str, "1") == 0) return 1;
15068 static int test_pvs_1 (void)
15070 if (test_pvs_1_skip ()) {
15071 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_pvs_1");
15075 /* InitNone|InitEmpty for test_pvs_1 */
15077 char device[] = "/dev/sda";
15079 suppress_error = 0;
15080 r = guestfs_blockdev_setrw (g, device);
15086 suppress_error = 0;
15087 r = guestfs_umount_all (g);
15093 suppress_error = 0;
15094 r = guestfs_lvm_remove_all (g);
15098 /* TestOutputListOfDevices for pvs (1) */
15100 char device[] = "/dev/sda";
15101 char lines_0[] = ",10";
15102 char lines_1[] = ",20";
15103 char lines_2[] = ",";
15111 suppress_error = 0;
15112 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15117 char device[] = "/dev/sda1";
15119 suppress_error = 0;
15120 r = guestfs_pvcreate (g, device);
15125 char device[] = "/dev/sda2";
15127 suppress_error = 0;
15128 r = guestfs_pvcreate (g, device);
15133 char device[] = "/dev/sda3";
15135 suppress_error = 0;
15136 r = guestfs_pvcreate (g, device);
15143 suppress_error = 0;
15144 r = guestfs_pvs (g);
15148 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15153 char expected[] = "/dev/sda1";
15155 if (strcmp (r[0], expected) != 0) {
15156 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15161 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15166 char expected[] = "/dev/sda2";
15168 if (strcmp (r[1], expected) != 0) {
15169 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15174 fprintf (stderr, "test_pvs_1: short list returned from command\n");
15179 char expected[] = "/dev/sda3";
15181 if (strcmp (r[2], expected) != 0) {
15182 fprintf (stderr, "test_pvs_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15186 if (r[3] != NULL) {
15187 fprintf (stderr, "test_pvs_1: extra elements returned from command\n");
15191 for (i = 0; r[i] != NULL; ++i)
15198 static int test_list_partitions_0_skip (void)
15202 str = getenv ("SKIP_TEST_LIST_PARTITIONS_0");
15203 if (str && strcmp (str, "1") == 0) return 1;
15204 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15205 if (str && strcmp (str, "1") == 0) return 1;
15209 static int test_list_partitions_0 (void)
15211 if (test_list_partitions_0_skip ()) {
15212 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_0");
15216 /* InitBasicFS for test_list_partitions_0: create ext2 on /dev/sda1 */
15218 char device[] = "/dev/sda";
15220 suppress_error = 0;
15221 r = guestfs_blockdev_setrw (g, device);
15227 suppress_error = 0;
15228 r = guestfs_umount_all (g);
15234 suppress_error = 0;
15235 r = guestfs_lvm_remove_all (g);
15240 char device[] = "/dev/sda";
15241 char lines_0[] = ",";
15247 suppress_error = 0;
15248 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15253 char fstype[] = "ext2";
15254 char device[] = "/dev/sda1";
15256 suppress_error = 0;
15257 r = guestfs_mkfs (g, fstype, device);
15262 char device[] = "/dev/sda1";
15263 char mountpoint[] = "/";
15265 suppress_error = 0;
15266 r = guestfs_mount (g, device, mountpoint);
15270 /* TestOutputListOfDevices for list_partitions (0) */
15274 suppress_error = 0;
15275 r = guestfs_list_partitions (g);
15279 fprintf (stderr, "test_list_partitions_0: short list returned from command\n");
15284 char expected[] = "/dev/sda1";
15286 if (strcmp (r[0], expected) != 0) {
15287 fprintf (stderr, "test_list_partitions_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15291 if (r[1] != NULL) {
15292 fprintf (stderr, "test_list_partitions_0: extra elements returned from command\n");
15296 for (i = 0; r[i] != NULL; ++i)
15303 static int test_list_partitions_1_skip (void)
15307 str = getenv ("SKIP_TEST_LIST_PARTITIONS_1");
15308 if (str && strcmp (str, "1") == 0) return 1;
15309 str = getenv ("SKIP_TEST_LIST_PARTITIONS");
15310 if (str && strcmp (str, "1") == 0) return 1;
15314 static int test_list_partitions_1 (void)
15316 if (test_list_partitions_1_skip ()) {
15317 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_partitions_1");
15321 /* InitNone|InitEmpty for test_list_partitions_1 */
15323 char device[] = "/dev/sda";
15325 suppress_error = 0;
15326 r = guestfs_blockdev_setrw (g, device);
15332 suppress_error = 0;
15333 r = guestfs_umount_all (g);
15339 suppress_error = 0;
15340 r = guestfs_lvm_remove_all (g);
15344 /* TestOutputListOfDevices for list_partitions (1) */
15346 char device[] = "/dev/sda";
15347 char lines_0[] = ",10";
15348 char lines_1[] = ",20";
15349 char lines_2[] = ",";
15357 suppress_error = 0;
15358 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15365 suppress_error = 0;
15366 r = guestfs_list_partitions (g);
15370 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15375 char expected[] = "/dev/sda1";
15377 if (strcmp (r[0], expected) != 0) {
15378 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15383 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15388 char expected[] = "/dev/sda2";
15390 if (strcmp (r[1], expected) != 0) {
15391 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15396 fprintf (stderr, "test_list_partitions_1: short list returned from command\n");
15401 char expected[] = "/dev/sda3";
15403 if (strcmp (r[2], expected) != 0) {
15404 fprintf (stderr, "test_list_partitions_1: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15408 if (r[3] != NULL) {
15409 fprintf (stderr, "test_list_partitions_1: extra elements returned from command\n");
15413 for (i = 0; r[i] != NULL; ++i)
15420 static int test_list_devices_0_skip (void)
15424 str = getenv ("SKIP_TEST_LIST_DEVICES_0");
15425 if (str && strcmp (str, "1") == 0) return 1;
15426 str = getenv ("SKIP_TEST_LIST_DEVICES");
15427 if (str && strcmp (str, "1") == 0) return 1;
15431 static int test_list_devices_0 (void)
15433 if (test_list_devices_0_skip ()) {
15434 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_list_devices_0");
15438 /* InitNone|InitEmpty for test_list_devices_0 */
15440 char device[] = "/dev/sda";
15442 suppress_error = 0;
15443 r = guestfs_blockdev_setrw (g, device);
15449 suppress_error = 0;
15450 r = guestfs_umount_all (g);
15456 suppress_error = 0;
15457 r = guestfs_lvm_remove_all (g);
15461 /* TestOutputListOfDevices for list_devices (0) */
15465 suppress_error = 0;
15466 r = guestfs_list_devices (g);
15470 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15475 char expected[] = "/dev/sda";
15477 if (strcmp (r[0], expected) != 0) {
15478 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15483 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15488 char expected[] = "/dev/sdb";
15490 if (strcmp (r[1], expected) != 0) {
15491 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15496 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15501 char expected[] = "/dev/sdc";
15503 if (strcmp (r[2], expected) != 0) {
15504 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15509 fprintf (stderr, "test_list_devices_0: short list returned from command\n");
15514 char expected[] = "/dev/sdd";
15516 if (strcmp (r[3], expected) != 0) {
15517 fprintf (stderr, "test_list_devices_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15521 if (r[4] != NULL) {
15522 fprintf (stderr, "test_list_devices_0: extra elements returned from command\n");
15526 for (i = 0; r[i] != NULL; ++i)
15533 static int test_ls_0_skip (void)
15537 str = getenv ("SKIP_TEST_LS_0");
15538 if (str && strcmp (str, "1") == 0) return 1;
15539 str = getenv ("SKIP_TEST_LS");
15540 if (str && strcmp (str, "1") == 0) return 1;
15544 static int test_ls_0 (void)
15546 if (test_ls_0_skip ()) {
15547 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_ls_0");
15551 /* InitBasicFS for test_ls_0: create ext2 on /dev/sda1 */
15553 char device[] = "/dev/sda";
15555 suppress_error = 0;
15556 r = guestfs_blockdev_setrw (g, device);
15562 suppress_error = 0;
15563 r = guestfs_umount_all (g);
15569 suppress_error = 0;
15570 r = guestfs_lvm_remove_all (g);
15575 char device[] = "/dev/sda";
15576 char lines_0[] = ",";
15582 suppress_error = 0;
15583 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15588 char fstype[] = "ext2";
15589 char device[] = "/dev/sda1";
15591 suppress_error = 0;
15592 r = guestfs_mkfs (g, fstype, device);
15597 char device[] = "/dev/sda1";
15598 char mountpoint[] = "/";
15600 suppress_error = 0;
15601 r = guestfs_mount (g, device, mountpoint);
15605 /* TestOutputList for ls (0) */
15607 char path[] = "/new";
15609 suppress_error = 0;
15610 r = guestfs_touch (g, path);
15615 char path[] = "/newer";
15617 suppress_error = 0;
15618 r = guestfs_touch (g, path);
15623 char path[] = "/newest";
15625 suppress_error = 0;
15626 r = guestfs_touch (g, path);
15631 char directory[] = "/";
15634 suppress_error = 0;
15635 r = guestfs_ls (g, directory);
15639 fprintf (stderr, "test_ls_0: short list returned from command\n");
15644 char expected[] = "lost+found";
15645 if (strcmp (r[0], expected) != 0) {
15646 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[0]);
15651 fprintf (stderr, "test_ls_0: short list returned from command\n");
15656 char expected[] = "new";
15657 if (strcmp (r[1], expected) != 0) {
15658 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[1]);
15663 fprintf (stderr, "test_ls_0: short list returned from command\n");
15668 char expected[] = "newer";
15669 if (strcmp (r[2], expected) != 0) {
15670 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[2]);
15675 fprintf (stderr, "test_ls_0: short list returned from command\n");
15680 char expected[] = "newest";
15681 if (strcmp (r[3], expected) != 0) {
15682 fprintf (stderr, "test_ls_0: expected \"%s\" but got \"%s\"\n", expected, r[3]);
15686 if (r[4] != NULL) {
15687 fprintf (stderr, "test_ls_0: extra elements returned from command\n");
15691 for (i = 0; r[i] != NULL; ++i)
15698 static int test_cat_0_skip (void)
15702 str = getenv ("SKIP_TEST_CAT_0");
15703 if (str && strcmp (str, "1") == 0) return 1;
15704 str = getenv ("SKIP_TEST_CAT");
15705 if (str && strcmp (str, "1") == 0) return 1;
15709 static int test_cat_0 (void)
15711 if (test_cat_0_skip ()) {
15712 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_cat_0");
15716 /* InitBasicFS for test_cat_0: create ext2 on /dev/sda1 */
15718 char device[] = "/dev/sda";
15720 suppress_error = 0;
15721 r = guestfs_blockdev_setrw (g, device);
15727 suppress_error = 0;
15728 r = guestfs_umount_all (g);
15734 suppress_error = 0;
15735 r = guestfs_lvm_remove_all (g);
15740 char device[] = "/dev/sda";
15741 char lines_0[] = ",";
15747 suppress_error = 0;
15748 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15753 char fstype[] = "ext2";
15754 char device[] = "/dev/sda1";
15756 suppress_error = 0;
15757 r = guestfs_mkfs (g, fstype, device);
15762 char device[] = "/dev/sda1";
15763 char mountpoint[] = "/";
15765 suppress_error = 0;
15766 r = guestfs_mount (g, device, mountpoint);
15770 /* TestOutput for cat (0) */
15771 char expected[] = "new file contents";
15773 char path[] = "/new";
15774 char content[] = "new file contents";
15776 suppress_error = 0;
15777 r = guestfs_write_file (g, path, content, 0);
15782 char path[] = "/new";
15784 suppress_error = 0;
15785 r = guestfs_cat (g, path);
15788 if (strcmp (r, expected) != 0) {
15789 fprintf (stderr, "test_cat_0: expected \"%s\" but got \"%s\"\n", expected, r);
15797 static int test_touch_0_skip (void)
15801 str = getenv ("SKIP_TEST_TOUCH_0");
15802 if (str && strcmp (str, "1") == 0) return 1;
15803 str = getenv ("SKIP_TEST_TOUCH");
15804 if (str && strcmp (str, "1") == 0) return 1;
15808 static int test_touch_0 (void)
15810 if (test_touch_0_skip ()) {
15811 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_touch_0");
15815 /* InitBasicFS for test_touch_0: create ext2 on /dev/sda1 */
15817 char device[] = "/dev/sda";
15819 suppress_error = 0;
15820 r = guestfs_blockdev_setrw (g, device);
15826 suppress_error = 0;
15827 r = guestfs_umount_all (g);
15833 suppress_error = 0;
15834 r = guestfs_lvm_remove_all (g);
15839 char device[] = "/dev/sda";
15840 char lines_0[] = ",";
15846 suppress_error = 0;
15847 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
15852 char fstype[] = "ext2";
15853 char device[] = "/dev/sda1";
15855 suppress_error = 0;
15856 r = guestfs_mkfs (g, fstype, device);
15861 char device[] = "/dev/sda1";
15862 char mountpoint[] = "/";
15864 suppress_error = 0;
15865 r = guestfs_mount (g, device, mountpoint);
15869 /* TestOutputTrue for touch (0) */
15871 char path[] = "/new";
15873 suppress_error = 0;
15874 r = guestfs_touch (g, path);
15879 char path[] = "/new";
15881 suppress_error = 0;
15882 r = guestfs_exists (g, path);
15886 fprintf (stderr, "test_touch_0: expected true, got false\n");
15893 static int test_sync_0_skip (void)
15897 str = getenv ("SKIP_TEST_SYNC_0");
15898 if (str && strcmp (str, "1") == 0) return 1;
15899 str = getenv ("SKIP_TEST_SYNC");
15900 if (str && strcmp (str, "1") == 0) return 1;
15904 static int test_sync_0 (void)
15906 if (test_sync_0_skip ()) {
15907 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_sync_0");
15911 /* InitNone|InitEmpty for test_sync_0 */
15913 char device[] = "/dev/sda";
15915 suppress_error = 0;
15916 r = guestfs_blockdev_setrw (g, device);
15922 suppress_error = 0;
15923 r = guestfs_umount_all (g);
15929 suppress_error = 0;
15930 r = guestfs_lvm_remove_all (g);
15934 /* TestRun for sync (0) */
15937 suppress_error = 0;
15938 r = guestfs_sync (g);
15945 static int test_mount_0_skip (void)
15949 str = getenv ("SKIP_TEST_MOUNT_0");
15950 if (str && strcmp (str, "1") == 0) return 1;
15951 str = getenv ("SKIP_TEST_MOUNT");
15952 if (str && strcmp (str, "1") == 0) return 1;
15956 static int test_mount_0 (void)
15958 if (test_mount_0_skip ()) {
15959 printf ("%s skipped (reason: SKIP_TEST_* variable set)\n", "test_mount_0");
15963 /* InitNone|InitEmpty for test_mount_0 */
15965 char device[] = "/dev/sda";
15967 suppress_error = 0;
15968 r = guestfs_blockdev_setrw (g, device);
15974 suppress_error = 0;
15975 r = guestfs_umount_all (g);
15981 suppress_error = 0;
15982 r = guestfs_lvm_remove_all (g);
15986 /* TestOutput for mount (0) */
15987 char expected[] = "new file contents";
15989 char device[] = "/dev/sda";
15990 char lines_0[] = ",";
15996 suppress_error = 0;
15997 r = guestfs_sfdisk (g, device, 0, 0, 0, lines);
16002 char fstype[] = "ext2";
16003 char device[] = "/dev/sda1";
16005 suppress_error = 0;
16006 r = guestfs_mkfs (g, fstype, device);
16011 char device[] = "/dev/sda1";
16012 char mountpoint[] = "/";
16014 suppress_error = 0;
16015 r = guestfs_mount (g, device, mountpoint);
16020 char path[] = "/new";
16021 char content[] = "new file contents";
16023 suppress_error = 0;
16024 r = guestfs_write_file (g, path, content, 0);
16029 char path[] = "/new";
16031 suppress_error = 0;
16032 r = guestfs_cat (g, path);
16035 if (strcmp (r, expected) != 0) {
16036 fprintf (stderr, "test_mount_0: expected \"%s\" but got \"%s\"\n", expected, r);
16044 int main (int argc, char *argv[])
16048 const char *filename;
16050 int nr_tests, test_num = 0;
16052 no_test_warnings ();
16054 g = guestfs_create ();
16056 printf ("guestfs_create FAILED\n");
16060 guestfs_set_error_handler (g, print_error, NULL);
16062 guestfs_set_path (g, "../appliance");
16064 filename = "test1.img";
16065 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16070 if (lseek (fd, 524288000, SEEK_SET) == -1) {
16076 if (write (fd, &c, 1) == -1) {
16082 if (close (fd) == -1) {
16087 if (guestfs_add_drive (g, filename) == -1) {
16088 printf ("guestfs_add_drive %s FAILED\n", filename);
16092 filename = "test2.img";
16093 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16098 if (lseek (fd, 52428800, SEEK_SET) == -1) {
16104 if (write (fd, &c, 1) == -1) {
16110 if (close (fd) == -1) {
16115 if (guestfs_add_drive (g, filename) == -1) {
16116 printf ("guestfs_add_drive %s FAILED\n", filename);
16120 filename = "test3.img";
16121 fd = open (filename, O_WRONLY|O_CREAT|O_NOCTTY|O_NONBLOCK|O_TRUNC, 0666);
16126 if (lseek (fd, 10485760, SEEK_SET) == -1) {
16132 if (write (fd, &c, 1) == -1) {
16138 if (close (fd) == -1) {
16143 if (guestfs_add_drive (g, filename) == -1) {
16144 printf ("guestfs_add_drive %s FAILED\n", filename);
16148 if (guestfs_add_drive_ro (g, "../images/test.sqsh") == -1) {
16149 printf ("guestfs_add_drive_ro ../images/test.sqsh FAILED\n");
16153 if (guestfs_launch (g) == -1) {
16154 printf ("guestfs_launch FAILED\n");
16158 /* Set a timeout in case qemu hangs during launch (RHBZ#505329). */
16161 if (guestfs_wait_ready (g) == -1) {
16162 printf ("guestfs_wait_ready FAILED\n");
16166 /* Cancel previous alarm. */
16172 printf ("%3d/%3d test_glob_expand_0\n", test_num, nr_tests);
16173 if (test_glob_expand_0 () == -1) {
16174 printf ("test_glob_expand_0 FAILED\n");
16178 printf ("%3d/%3d test_glob_expand_1\n", test_num, nr_tests);
16179 if (test_glob_expand_1 () == -1) {
16180 printf ("test_glob_expand_1 FAILED\n");
16184 printf ("%3d/%3d test_glob_expand_2\n", test_num, nr_tests);
16185 if (test_glob_expand_2 () == -1) {
16186 printf ("test_glob_expand_2 FAILED\n");
16190 printf ("%3d/%3d test_ntfs_3g_probe_0\n", test_num, nr_tests);
16191 if (test_ntfs_3g_probe_0 () == -1) {
16192 printf ("test_ntfs_3g_probe_0 FAILED\n");
16196 printf ("%3d/%3d test_ntfs_3g_probe_1\n", test_num, nr_tests);
16197 if (test_ntfs_3g_probe_1 () == -1) {
16198 printf ("test_ntfs_3g_probe_1 FAILED\n");
16202 printf ("%3d/%3d test_sleep_0\n", test_num, nr_tests);
16203 if (test_sleep_0 () == -1) {
16204 printf ("test_sleep_0 FAILED\n");
16208 printf ("%3d/%3d test_find_0\n", test_num, nr_tests);
16209 if (test_find_0 () == -1) {
16210 printf ("test_find_0 FAILED\n");
16214 printf ("%3d/%3d test_find_1\n", test_num, nr_tests);
16215 if (test_find_1 () == -1) {
16216 printf ("test_find_1 FAILED\n");
16220 printf ("%3d/%3d test_find_2\n", test_num, nr_tests);
16221 if (test_find_2 () == -1) {
16222 printf ("test_find_2 FAILED\n");
16226 printf ("%3d/%3d test_lvresize_0\n", test_num, nr_tests);
16227 if (test_lvresize_0 () == -1) {
16228 printf ("test_lvresize_0 FAILED\n");
16232 printf ("%3d/%3d test_zerofree_0\n", test_num, nr_tests);
16233 if (test_zerofree_0 () == -1) {
16234 printf ("test_zerofree_0 FAILED\n");
16238 printf ("%3d/%3d test_hexdump_0\n", test_num, nr_tests);
16239 if (test_hexdump_0 () == -1) {
16240 printf ("test_hexdump_0 FAILED\n");
16244 printf ("%3d/%3d test_strings_e_0\n", test_num, nr_tests);
16245 if (test_strings_e_0 () == -1) {
16246 printf ("test_strings_e_0 FAILED\n");
16250 printf ("%3d/%3d test_strings_e_1\n", test_num, nr_tests);
16251 if (test_strings_e_1 () == -1) {
16252 printf ("test_strings_e_1 FAILED\n");
16256 printf ("%3d/%3d test_strings_0\n", test_num, nr_tests);
16257 if (test_strings_0 () == -1) {
16258 printf ("test_strings_0 FAILED\n");
16262 printf ("%3d/%3d test_strings_1\n", test_num, nr_tests);
16263 if (test_strings_1 () == -1) {
16264 printf ("test_strings_1 FAILED\n");
16268 printf ("%3d/%3d test_equal_0\n", test_num, nr_tests);
16269 if (test_equal_0 () == -1) {
16270 printf ("test_equal_0 FAILED\n");
16274 printf ("%3d/%3d test_equal_1\n", test_num, nr_tests);
16275 if (test_equal_1 () == -1) {
16276 printf ("test_equal_1 FAILED\n");
16280 printf ("%3d/%3d test_equal_2\n", test_num, nr_tests);
16281 if (test_equal_2 () == -1) {
16282 printf ("test_equal_2 FAILED\n");
16286 printf ("%3d/%3d test_ping_daemon_0\n", test_num, nr_tests);
16287 if (test_ping_daemon_0 () == -1) {
16288 printf ("test_ping_daemon_0 FAILED\n");
16292 printf ("%3d/%3d test_dmesg_0\n", test_num, nr_tests);
16293 if (test_dmesg_0 () == -1) {
16294 printf ("test_dmesg_0 FAILED\n");
16298 printf ("%3d/%3d test_drop_caches_0\n", test_num, nr_tests);
16299 if (test_drop_caches_0 () == -1) {
16300 printf ("test_drop_caches_0 FAILED\n");
16304 printf ("%3d/%3d test_mv_0\n", test_num, nr_tests);
16305 if (test_mv_0 () == -1) {
16306 printf ("test_mv_0 FAILED\n");
16310 printf ("%3d/%3d test_mv_1\n", test_num, nr_tests);
16311 if (test_mv_1 () == -1) {
16312 printf ("test_mv_1 FAILED\n");
16316 printf ("%3d/%3d test_cp_a_0\n", test_num, nr_tests);
16317 if (test_cp_a_0 () == -1) {
16318 printf ("test_cp_a_0 FAILED\n");
16322 printf ("%3d/%3d test_cp_0\n", test_num, nr_tests);
16323 if (test_cp_0 () == -1) {
16324 printf ("test_cp_0 FAILED\n");
16328 printf ("%3d/%3d test_cp_1\n", test_num, nr_tests);
16329 if (test_cp_1 () == -1) {
16330 printf ("test_cp_1 FAILED\n");
16334 printf ("%3d/%3d test_cp_2\n", test_num, nr_tests);
16335 if (test_cp_2 () == -1) {
16336 printf ("test_cp_2 FAILED\n");
16340 printf ("%3d/%3d test_grub_install_0\n", test_num, nr_tests);
16341 if (test_grub_install_0 () == -1) {
16342 printf ("test_grub_install_0 FAILED\n");
16346 printf ("%3d/%3d test_zero_0\n", test_num, nr_tests);
16347 if (test_zero_0 () == -1) {
16348 printf ("test_zero_0 FAILED\n");
16352 printf ("%3d/%3d test_fsck_0\n", test_num, nr_tests);
16353 if (test_fsck_0 () == -1) {
16354 printf ("test_fsck_0 FAILED\n");
16358 printf ("%3d/%3d test_fsck_1\n", test_num, nr_tests);
16359 if (test_fsck_1 () == -1) {
16360 printf ("test_fsck_1 FAILED\n");
16364 printf ("%3d/%3d test_set_e2uuid_0\n", test_num, nr_tests);
16365 if (test_set_e2uuid_0 () == -1) {
16366 printf ("test_set_e2uuid_0 FAILED\n");
16370 printf ("%3d/%3d test_set_e2uuid_1\n", test_num, nr_tests);
16371 if (test_set_e2uuid_1 () == -1) {
16372 printf ("test_set_e2uuid_1 FAILED\n");
16376 printf ("%3d/%3d test_set_e2uuid_2\n", test_num, nr_tests);
16377 if (test_set_e2uuid_2 () == -1) {
16378 printf ("test_set_e2uuid_2 FAILED\n");
16382 printf ("%3d/%3d test_set_e2uuid_3\n", test_num, nr_tests);
16383 if (test_set_e2uuid_3 () == -1) {
16384 printf ("test_set_e2uuid_3 FAILED\n");
16388 printf ("%3d/%3d test_set_e2label_0\n", test_num, nr_tests);
16389 if (test_set_e2label_0 () == -1) {
16390 printf ("test_set_e2label_0 FAILED\n");
16394 printf ("%3d/%3d test_pvremove_0\n", test_num, nr_tests);
16395 if (test_pvremove_0 () == -1) {
16396 printf ("test_pvremove_0 FAILED\n");
16400 printf ("%3d/%3d test_pvremove_1\n", test_num, nr_tests);
16401 if (test_pvremove_1 () == -1) {
16402 printf ("test_pvremove_1 FAILED\n");
16406 printf ("%3d/%3d test_pvremove_2\n", test_num, nr_tests);
16407 if (test_pvremove_2 () == -1) {
16408 printf ("test_pvremove_2 FAILED\n");
16412 printf ("%3d/%3d test_vgremove_0\n", test_num, nr_tests);
16413 if (test_vgremove_0 () == -1) {
16414 printf ("test_vgremove_0 FAILED\n");
16418 printf ("%3d/%3d test_vgremove_1\n", test_num, nr_tests);
16419 if (test_vgremove_1 () == -1) {
16420 printf ("test_vgremove_1 FAILED\n");
16424 printf ("%3d/%3d test_lvremove_0\n", test_num, nr_tests);
16425 if (test_lvremove_0 () == -1) {
16426 printf ("test_lvremove_0 FAILED\n");
16430 printf ("%3d/%3d test_lvremove_1\n", test_num, nr_tests);
16431 if (test_lvremove_1 () == -1) {
16432 printf ("test_lvremove_1 FAILED\n");
16436 printf ("%3d/%3d test_lvremove_2\n", test_num, nr_tests);
16437 if (test_lvremove_2 () == -1) {
16438 printf ("test_lvremove_2 FAILED\n");
16442 printf ("%3d/%3d test_mount_ro_0\n", test_num, nr_tests);
16443 if (test_mount_ro_0 () == -1) {
16444 printf ("test_mount_ro_0 FAILED\n");
16448 printf ("%3d/%3d test_mount_ro_1\n", test_num, nr_tests);
16449 if (test_mount_ro_1 () == -1) {
16450 printf ("test_mount_ro_1 FAILED\n");
16454 printf ("%3d/%3d test_tgz_in_0\n", test_num, nr_tests);
16455 if (test_tgz_in_0 () == -1) {
16456 printf ("test_tgz_in_0 FAILED\n");
16460 printf ("%3d/%3d test_tar_in_0\n", test_num, nr_tests);
16461 if (test_tar_in_0 () == -1) {
16462 printf ("test_tar_in_0 FAILED\n");
16466 printf ("%3d/%3d test_checksum_0\n", test_num, nr_tests);
16467 if (test_checksum_0 () == -1) {
16468 printf ("test_checksum_0 FAILED\n");
16472 printf ("%3d/%3d test_checksum_1\n", test_num, nr_tests);
16473 if (test_checksum_1 () == -1) {
16474 printf ("test_checksum_1 FAILED\n");
16478 printf ("%3d/%3d test_checksum_2\n", test_num, nr_tests);
16479 if (test_checksum_2 () == -1) {
16480 printf ("test_checksum_2 FAILED\n");
16484 printf ("%3d/%3d test_checksum_3\n", test_num, nr_tests);
16485 if (test_checksum_3 () == -1) {
16486 printf ("test_checksum_3 FAILED\n");
16490 printf ("%3d/%3d test_checksum_4\n", test_num, nr_tests);
16491 if (test_checksum_4 () == -1) {
16492 printf ("test_checksum_4 FAILED\n");
16496 printf ("%3d/%3d test_checksum_5\n", test_num, nr_tests);
16497 if (test_checksum_5 () == -1) {
16498 printf ("test_checksum_5 FAILED\n");
16502 printf ("%3d/%3d test_checksum_6\n", test_num, nr_tests);
16503 if (test_checksum_6 () == -1) {
16504 printf ("test_checksum_6 FAILED\n");
16508 printf ("%3d/%3d test_checksum_7\n", test_num, nr_tests);
16509 if (test_checksum_7 () == -1) {
16510 printf ("test_checksum_7 FAILED\n");
16514 printf ("%3d/%3d test_checksum_8\n", test_num, nr_tests);
16515 if (test_checksum_8 () == -1) {
16516 printf ("test_checksum_8 FAILED\n");
16520 printf ("%3d/%3d test_download_0\n", test_num, nr_tests);
16521 if (test_download_0 () == -1) {
16522 printf ("test_download_0 FAILED\n");
16526 printf ("%3d/%3d test_upload_0\n", test_num, nr_tests);
16527 if (test_upload_0 () == -1) {
16528 printf ("test_upload_0 FAILED\n");
16532 printf ("%3d/%3d test_blockdev_rereadpt_0\n", test_num, nr_tests);
16533 if (test_blockdev_rereadpt_0 () == -1) {
16534 printf ("test_blockdev_rereadpt_0 FAILED\n");
16538 printf ("%3d/%3d test_blockdev_flushbufs_0\n", test_num, nr_tests);
16539 if (test_blockdev_flushbufs_0 () == -1) {
16540 printf ("test_blockdev_flushbufs_0 FAILED\n");
16544 printf ("%3d/%3d test_blockdev_getsize64_0\n", test_num, nr_tests);
16545 if (test_blockdev_getsize64_0 () == -1) {
16546 printf ("test_blockdev_getsize64_0 FAILED\n");
16550 printf ("%3d/%3d test_blockdev_getsz_0\n", test_num, nr_tests);
16551 if (test_blockdev_getsz_0 () == -1) {
16552 printf ("test_blockdev_getsz_0 FAILED\n");
16556 printf ("%3d/%3d test_blockdev_getbsz_0\n", test_num, nr_tests);
16557 if (test_blockdev_getbsz_0 () == -1) {
16558 printf ("test_blockdev_getbsz_0 FAILED\n");
16562 printf ("%3d/%3d test_blockdev_getss_0\n", test_num, nr_tests);
16563 if (test_blockdev_getss_0 () == -1) {
16564 printf ("test_blockdev_getss_0 FAILED\n");
16568 printf ("%3d/%3d test_blockdev_getro_0\n", test_num, nr_tests);
16569 if (test_blockdev_getro_0 () == -1) {
16570 printf ("test_blockdev_getro_0 FAILED\n");
16574 printf ("%3d/%3d test_blockdev_setrw_0\n", test_num, nr_tests);
16575 if (test_blockdev_setrw_0 () == -1) {
16576 printf ("test_blockdev_setrw_0 FAILED\n");
16580 printf ("%3d/%3d test_blockdev_setro_0\n", test_num, nr_tests);
16581 if (test_blockdev_setro_0 () == -1) {
16582 printf ("test_blockdev_setro_0 FAILED\n");
16586 printf ("%3d/%3d test_statvfs_0\n", test_num, nr_tests);
16587 if (test_statvfs_0 () == -1) {
16588 printf ("test_statvfs_0 FAILED\n");
16592 printf ("%3d/%3d test_lstat_0\n", test_num, nr_tests);
16593 if (test_lstat_0 () == -1) {
16594 printf ("test_lstat_0 FAILED\n");
16598 printf ("%3d/%3d test_stat_0\n", test_num, nr_tests);
16599 if (test_stat_0 () == -1) {
16600 printf ("test_stat_0 FAILED\n");
16604 printf ("%3d/%3d test_command_lines_0\n", test_num, nr_tests);
16605 if (test_command_lines_0 () == -1) {
16606 printf ("test_command_lines_0 FAILED\n");
16610 printf ("%3d/%3d test_command_lines_1\n", test_num, nr_tests);
16611 if (test_command_lines_1 () == -1) {
16612 printf ("test_command_lines_1 FAILED\n");
16616 printf ("%3d/%3d test_command_lines_2\n", test_num, nr_tests);
16617 if (test_command_lines_2 () == -1) {
16618 printf ("test_command_lines_2 FAILED\n");
16622 printf ("%3d/%3d test_command_lines_3\n", test_num, nr_tests);
16623 if (test_command_lines_3 () == -1) {
16624 printf ("test_command_lines_3 FAILED\n");
16628 printf ("%3d/%3d test_command_lines_4\n", test_num, nr_tests);
16629 if (test_command_lines_4 () == -1) {
16630 printf ("test_command_lines_4 FAILED\n");
16634 printf ("%3d/%3d test_command_lines_5\n", test_num, nr_tests);
16635 if (test_command_lines_5 () == -1) {
16636 printf ("test_command_lines_5 FAILED\n");
16640 printf ("%3d/%3d test_command_lines_6\n", test_num, nr_tests);
16641 if (test_command_lines_6 () == -1) {
16642 printf ("test_command_lines_6 FAILED\n");
16646 printf ("%3d/%3d test_command_lines_7\n", test_num, nr_tests);
16647 if (test_command_lines_7 () == -1) {
16648 printf ("test_command_lines_7 FAILED\n");
16652 printf ("%3d/%3d test_command_lines_8\n", test_num, nr_tests);
16653 if (test_command_lines_8 () == -1) {
16654 printf ("test_command_lines_8 FAILED\n");
16658 printf ("%3d/%3d test_command_lines_9\n", test_num, nr_tests);
16659 if (test_command_lines_9 () == -1) {
16660 printf ("test_command_lines_9 FAILED\n");
16664 printf ("%3d/%3d test_command_lines_10\n", test_num, nr_tests);
16665 if (test_command_lines_10 () == -1) {
16666 printf ("test_command_lines_10 FAILED\n");
16670 printf ("%3d/%3d test_command_0\n", test_num, nr_tests);
16671 if (test_command_0 () == -1) {
16672 printf ("test_command_0 FAILED\n");
16676 printf ("%3d/%3d test_command_1\n", test_num, nr_tests);
16677 if (test_command_1 () == -1) {
16678 printf ("test_command_1 FAILED\n");
16682 printf ("%3d/%3d test_command_2\n", test_num, nr_tests);
16683 if (test_command_2 () == -1) {
16684 printf ("test_command_2 FAILED\n");
16688 printf ("%3d/%3d test_command_3\n", test_num, nr_tests);
16689 if (test_command_3 () == -1) {
16690 printf ("test_command_3 FAILED\n");
16694 printf ("%3d/%3d test_command_4\n", test_num, nr_tests);
16695 if (test_command_4 () == -1) {
16696 printf ("test_command_4 FAILED\n");
16700 printf ("%3d/%3d test_command_5\n", test_num, nr_tests);
16701 if (test_command_5 () == -1) {
16702 printf ("test_command_5 FAILED\n");
16706 printf ("%3d/%3d test_command_6\n", test_num, nr_tests);
16707 if (test_command_6 () == -1) {
16708 printf ("test_command_6 FAILED\n");
16712 printf ("%3d/%3d test_command_7\n", test_num, nr_tests);
16713 if (test_command_7 () == -1) {
16714 printf ("test_command_7 FAILED\n");
16718 printf ("%3d/%3d test_command_8\n", test_num, nr_tests);
16719 if (test_command_8 () == -1) {
16720 printf ("test_command_8 FAILED\n");
16724 printf ("%3d/%3d test_command_9\n", test_num, nr_tests);
16725 if (test_command_9 () == -1) {
16726 printf ("test_command_9 FAILED\n");
16730 printf ("%3d/%3d test_command_10\n", test_num, nr_tests);
16731 if (test_command_10 () == -1) {
16732 printf ("test_command_10 FAILED\n");
16736 printf ("%3d/%3d test_command_11\n", test_num, nr_tests);
16737 if (test_command_11 () == -1) {
16738 printf ("test_command_11 FAILED\n");
16742 printf ("%3d/%3d test_file_0\n", test_num, nr_tests);
16743 if (test_file_0 () == -1) {
16744 printf ("test_file_0 FAILED\n");
16748 printf ("%3d/%3d test_file_1\n", test_num, nr_tests);
16749 if (test_file_1 () == -1) {
16750 printf ("test_file_1 FAILED\n");
16754 printf ("%3d/%3d test_file_2\n", test_num, nr_tests);
16755 if (test_file_2 () == -1) {
16756 printf ("test_file_2 FAILED\n");
16760 printf ("%3d/%3d test_umount_all_0\n", test_num, nr_tests);
16761 if (test_umount_all_0 () == -1) {
16762 printf ("test_umount_all_0 FAILED\n");
16766 printf ("%3d/%3d test_umount_all_1\n", test_num, nr_tests);
16767 if (test_umount_all_1 () == -1) {
16768 printf ("test_umount_all_1 FAILED\n");
16772 printf ("%3d/%3d test_mounts_0\n", test_num, nr_tests);
16773 if (test_mounts_0 () == -1) {
16774 printf ("test_mounts_0 FAILED\n");
16778 printf ("%3d/%3d test_umount_0\n", test_num, nr_tests);
16779 if (test_umount_0 () == -1) {
16780 printf ("test_umount_0 FAILED\n");
16784 printf ("%3d/%3d test_umount_1\n", test_num, nr_tests);
16785 if (test_umount_1 () == -1) {
16786 printf ("test_umount_1 FAILED\n");
16790 printf ("%3d/%3d test_write_file_0\n", test_num, nr_tests);
16791 if (test_write_file_0 () == -1) {
16792 printf ("test_write_file_0 FAILED\n");
16796 printf ("%3d/%3d test_write_file_1\n", test_num, nr_tests);
16797 if (test_write_file_1 () == -1) {
16798 printf ("test_write_file_1 FAILED\n");
16802 printf ("%3d/%3d test_write_file_2\n", test_num, nr_tests);
16803 if (test_write_file_2 () == -1) {
16804 printf ("test_write_file_2 FAILED\n");
16808 printf ("%3d/%3d test_write_file_3\n", test_num, nr_tests);
16809 if (test_write_file_3 () == -1) {
16810 printf ("test_write_file_3 FAILED\n");
16814 printf ("%3d/%3d test_write_file_4\n", test_num, nr_tests);
16815 if (test_write_file_4 () == -1) {
16816 printf ("test_write_file_4 FAILED\n");
16820 printf ("%3d/%3d test_write_file_5\n", test_num, nr_tests);
16821 if (test_write_file_5 () == -1) {
16822 printf ("test_write_file_5 FAILED\n");
16826 printf ("%3d/%3d test_mkfs_0\n", test_num, nr_tests);
16827 if (test_mkfs_0 () == -1) {
16828 printf ("test_mkfs_0 FAILED\n");
16832 printf ("%3d/%3d test_lvcreate_0\n", test_num, nr_tests);
16833 if (test_lvcreate_0 () == -1) {
16834 printf ("test_lvcreate_0 FAILED\n");
16838 printf ("%3d/%3d test_vgcreate_0\n", test_num, nr_tests);
16839 if (test_vgcreate_0 () == -1) {
16840 printf ("test_vgcreate_0 FAILED\n");
16844 printf ("%3d/%3d test_pvcreate_0\n", test_num, nr_tests);
16845 if (test_pvcreate_0 () == -1) {
16846 printf ("test_pvcreate_0 FAILED\n");
16850 printf ("%3d/%3d test_is_dir_0\n", test_num, nr_tests);
16851 if (test_is_dir_0 () == -1) {
16852 printf ("test_is_dir_0 FAILED\n");
16856 printf ("%3d/%3d test_is_dir_1\n", test_num, nr_tests);
16857 if (test_is_dir_1 () == -1) {
16858 printf ("test_is_dir_1 FAILED\n");
16862 printf ("%3d/%3d test_is_file_0\n", test_num, nr_tests);
16863 if (test_is_file_0 () == -1) {
16864 printf ("test_is_file_0 FAILED\n");
16868 printf ("%3d/%3d test_is_file_1\n", test_num, nr_tests);
16869 if (test_is_file_1 () == -1) {
16870 printf ("test_is_file_1 FAILED\n");
16874 printf ("%3d/%3d test_exists_0\n", test_num, nr_tests);
16875 if (test_exists_0 () == -1) {
16876 printf ("test_exists_0 FAILED\n");
16880 printf ("%3d/%3d test_exists_1\n", test_num, nr_tests);
16881 if (test_exists_1 () == -1) {
16882 printf ("test_exists_1 FAILED\n");
16886 printf ("%3d/%3d test_mkdir_p_0\n", test_num, nr_tests);
16887 if (test_mkdir_p_0 () == -1) {
16888 printf ("test_mkdir_p_0 FAILED\n");
16892 printf ("%3d/%3d test_mkdir_p_1\n", test_num, nr_tests);
16893 if (test_mkdir_p_1 () == -1) {
16894 printf ("test_mkdir_p_1 FAILED\n");
16898 printf ("%3d/%3d test_mkdir_p_2\n", test_num, nr_tests);
16899 if (test_mkdir_p_2 () == -1) {
16900 printf ("test_mkdir_p_2 FAILED\n");
16904 printf ("%3d/%3d test_mkdir_p_3\n", test_num, nr_tests);
16905 if (test_mkdir_p_3 () == -1) {
16906 printf ("test_mkdir_p_3 FAILED\n");
16910 printf ("%3d/%3d test_mkdir_p_4\n", test_num, nr_tests);
16911 if (test_mkdir_p_4 () == -1) {
16912 printf ("test_mkdir_p_4 FAILED\n");
16916 printf ("%3d/%3d test_mkdir_0\n", test_num, nr_tests);
16917 if (test_mkdir_0 () == -1) {
16918 printf ("test_mkdir_0 FAILED\n");
16922 printf ("%3d/%3d test_mkdir_1\n", test_num, nr_tests);
16923 if (test_mkdir_1 () == -1) {
16924 printf ("test_mkdir_1 FAILED\n");
16928 printf ("%3d/%3d test_rm_rf_0\n", test_num, nr_tests);
16929 if (test_rm_rf_0 () == -1) {
16930 printf ("test_rm_rf_0 FAILED\n");
16934 printf ("%3d/%3d test_rmdir_0\n", test_num, nr_tests);
16935 if (test_rmdir_0 () == -1) {
16936 printf ("test_rmdir_0 FAILED\n");
16940 printf ("%3d/%3d test_rmdir_1\n", test_num, nr_tests);
16941 if (test_rmdir_1 () == -1) {
16942 printf ("test_rmdir_1 FAILED\n");
16946 printf ("%3d/%3d test_rmdir_2\n", test_num, nr_tests);
16947 if (test_rmdir_2 () == -1) {
16948 printf ("test_rmdir_2 FAILED\n");
16952 printf ("%3d/%3d test_rm_0\n", test_num, nr_tests);
16953 if (test_rm_0 () == -1) {
16954 printf ("test_rm_0 FAILED\n");
16958 printf ("%3d/%3d test_rm_1\n", test_num, nr_tests);
16959 if (test_rm_1 () == -1) {
16960 printf ("test_rm_1 FAILED\n");
16964 printf ("%3d/%3d test_rm_2\n", test_num, nr_tests);
16965 if (test_rm_2 () == -1) {
16966 printf ("test_rm_2 FAILED\n");
16970 printf ("%3d/%3d test_read_lines_0\n", test_num, nr_tests);
16971 if (test_read_lines_0 () == -1) {
16972 printf ("test_read_lines_0 FAILED\n");
16976 printf ("%3d/%3d test_read_lines_1\n", test_num, nr_tests);
16977 if (test_read_lines_1 () == -1) {
16978 printf ("test_read_lines_1 FAILED\n");
16982 printf ("%3d/%3d test_lvs_0\n", test_num, nr_tests);
16983 if (test_lvs_0 () == -1) {
16984 printf ("test_lvs_0 FAILED\n");
16988 printf ("%3d/%3d test_lvs_1\n", test_num, nr_tests);
16989 if (test_lvs_1 () == -1) {
16990 printf ("test_lvs_1 FAILED\n");
16994 printf ("%3d/%3d test_vgs_0\n", test_num, nr_tests);
16995 if (test_vgs_0 () == -1) {
16996 printf ("test_vgs_0 FAILED\n");
17000 printf ("%3d/%3d test_vgs_1\n", test_num, nr_tests);
17001 if (test_vgs_1 () == -1) {
17002 printf ("test_vgs_1 FAILED\n");
17006 printf ("%3d/%3d test_pvs_0\n", test_num, nr_tests);
17007 if (test_pvs_0 () == -1) {
17008 printf ("test_pvs_0 FAILED\n");
17012 printf ("%3d/%3d test_pvs_1\n", test_num, nr_tests);
17013 if (test_pvs_1 () == -1) {
17014 printf ("test_pvs_1 FAILED\n");
17018 printf ("%3d/%3d test_list_partitions_0\n", test_num, nr_tests);
17019 if (test_list_partitions_0 () == -1) {
17020 printf ("test_list_partitions_0 FAILED\n");
17024 printf ("%3d/%3d test_list_partitions_1\n", test_num, nr_tests);
17025 if (test_list_partitions_1 () == -1) {
17026 printf ("test_list_partitions_1 FAILED\n");
17030 printf ("%3d/%3d test_list_devices_0\n", test_num, nr_tests);
17031 if (test_list_devices_0 () == -1) {
17032 printf ("test_list_devices_0 FAILED\n");
17036 printf ("%3d/%3d test_ls_0\n", test_num, nr_tests);
17037 if (test_ls_0 () == -1) {
17038 printf ("test_ls_0 FAILED\n");
17042 printf ("%3d/%3d test_cat_0\n", test_num, nr_tests);
17043 if (test_cat_0 () == -1) {
17044 printf ("test_cat_0 FAILED\n");
17048 printf ("%3d/%3d test_touch_0\n", test_num, nr_tests);
17049 if (test_touch_0 () == -1) {
17050 printf ("test_touch_0 FAILED\n");
17054 printf ("%3d/%3d test_sync_0\n", test_num, nr_tests);
17055 if (test_sync_0 () == -1) {
17056 printf ("test_sync_0 FAILED\n");
17060 printf ("%3d/%3d test_mount_0\n", test_num, nr_tests);
17061 if (test_mount_0 () == -1) {
17062 printf ("test_mount_0 FAILED\n");
17067 unlink ("test1.img");
17068 unlink ("test2.img");
17069 unlink ("test3.img");
17072 printf ("***** %d / %d tests FAILED *****\n", failed, nr_tests);